Shader building is not part of the CMake building process. Android support will be added

AnKi/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(ANKI_SUB_DIRS Importer Core Script Renderer Scene Ui Input Physics Resource Gr Collision Math Util ShaderCompiler)
+set(ANKI_SUB_DIRS Importer Core Script Renderer Scene Ui Input Physics Resource Gr Collision Math Util ShaderCompiler
+	Shaders)
 foreach(TMP ${ANKI_SUB_DIRS})
 	add_subdirectory(${TMP})
 endforeach()

AnKi/Collision/CMakeLists.txt

@@ -1,3 +1,4 @@
-file(GLOB SOURCES *.cpp)
-file(GLOB HEADERS *.h)
-anki_add_source_files(${SOURCES} ${HEADERS})
+file(GLOB_RECURSE sources *.cpp)
+add_library(AnKiCollision ${sources})
+target_compile_definitions(AnKiCollision PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiCollision AnKiMath)

AnKi/Core/App.cpp

@@ -153,11 +153,11 @@ void App::cleanup()
 	m_cacheDir.destroy(m_heapAlloc);
 }
 
-Error App::init(ConfigSet* config, AllocAlignedCallback allocCb, void* allocCbUserData)
+Error App::init(ConfigSet* config, CString executableFilename, AllocAlignedCallback allocCb, void* allocCbUserData)
 {
 	ANKI_ASSERT(config);
 	m_config = config;
-	const Error err = initInternal(allocCb, allocCbUserData);
+	const Error err = initInternal(executableFilename, allocCb, allocCbUserData);
 	if(err)
 	{
 		ANKI_CORE_LOGE("App initialization failed. Shutting down");
@@ -167,13 +167,13 @@ Error App::init(ConfigSet* config, AllocAlignedCallback allocCb, void* allocCbUs
 	return err;
 }
 
-Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
+Error App::initInternal(CString executableFilename, AllocAlignedCallback allocCb, void* allocCbUserData)
 {
 	LoggerSingleton::get().enableVerbosity(m_config->getCoreVerboseLog());
 
 	setSignalHandlers();
 
-	Thread::setNameOfCurrentThread("anki_main");
+	Thread::setNameOfCurrentThread("AnKiMain");
 
 	initMemoryCallbacks(allocCb, allocCbUserData);
 	m_heapAlloc = HeapAllocator<U8>(m_allocCb, m_allocCbData, "Core");
@@ -292,6 +292,15 @@ Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
 	//
 	// Resource FS
 	//
+#if !ANKI_OS_ANDROID
+	// Add the location of the executable where the shaders are supposed to be
+	StringAuto shadersPath(m_heapAlloc);
+	getParentFilepath(executableFilename, shadersPath);
+	shadersPath.append(":");
+	shadersPath.append(m_config->getRsrcDataPaths());
+	m_config->setRsrcDataPaths(shadersPath);
+#endif
+
 	m_resourceFs = m_heapAlloc.newInstance<ResourceFilesystem>(m_heapAlloc);
 	ANKI_CHECK(m_resourceFs->init(*m_config, m_cacheDir.toCString()));
 
@@ -304,7 +313,6 @@ Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
 	rinit.m_resourceFs = m_resourceFs;
 	rinit.m_vertexMemory = m_vertexMem;
 	rinit.m_config = m_config;
-	rinit.m_cacheDir = m_cacheDir.toCString();
 	rinit.m_allocCallback = m_allocCb;
 	rinit.m_allocCallbackData = m_allocCbData;
 	m_resources = m_heapAlloc.newInstance<ResourceManager>();

AnKi/Core/App.h

@@ -42,7 +42,8 @@ public:
 
 	/// Initialize the application.
 	/// @param[in,out] config The config. Needs to be alive as long as the app is alive.
-	ANKI_USE_RESULT Error init(ConfigSet* config, AllocAlignedCallback allocCb, void* allocCbUserData);
+	ANKI_USE_RESULT Error init(ConfigSet* config, CString executableFilename, AllocAlignedCallback allocCb,
+							   void* allocCbUserData);
 
 	const String& getSettingsDirectory() const
 	{
@@ -199,7 +200,7 @@ private:
 
 	void initMemoryCallbacks(AllocAlignedCallback allocCb, void* allocCbUserData);
 
-	ANKI_USE_RESULT Error initInternal(AllocAlignedCallback allocCb, void* allocCbUserData);
+	ANKI_USE_RESULT Error initInternal(CString executableFilename, AllocAlignedCallback allocCb, void* allocCbUserData);
 
 	ANKI_USE_RESULT Error initDirs();
 	void cleanup();

AnKi/Core/CMakeLists.txt

@@ -1,17 +1,35 @@
-set(SOURCES App.cpp ConfigSet.cpp GpuMemoryPools.cpp DeveloperConsole.cpp CoreTracer.cpp MaliHwCounters.cpp
+set(sources
+	App.cpp
+	ConfigSet.cpp
+	GpuMemoryPools.cpp
+	DeveloperConsole.cpp
+	CoreTracer.cpp
+	MaliHwCounters.cpp
 	StatsUi.cpp)
-file(GLOB HEADERS *.h)
 
 if(ANKI_HEADLESS)
-	set(SOURCES ${SOURCES} NativeWindowHeadless.cpp)
+	set(sources ${sources} NativeWindowHeadless.cpp)
 elseif(SDL)
-	set(SOURCES ${SOURCES} NativeWindowSdl.cpp)
+	set(sources ${sources} NativeWindowSdl.cpp)
 elseif(ANDROID)
-	set(SOURCES ${SOURCES} NativeWindowAndroid.cpp)
+	set(sources ${sources} NativeWindowAndroid.cpp)
 else()
 	message(FATAL_ERROR "Not implemented")
 endif()
 
-foreach(S ${SOURCES})
-	anki_add_source_files("${CMAKE_CURRENT_SOURCE_DIR}/${S}" ${HEADERS})
-endforeach()
+add_library(AnKiCore ${sources})
+
+if(SDL)
+	if(LINUX)
+		set(extra_libs X11-xcb pthread dl)
+	endif()
+
+	set(extra_libs ${extra_libs} SDL2-static)
+elseif(ANDROID)
+	set(extra_libs log android AnKiAndroidNativeGlue AnKiHwcPipe)
+elseif(WINDOWS)
+	set(extra_libs version Imm32 Winmm DbgHelp)
+endif()
+
+target_compile_definitions(AnKiCore PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiCore AnKiGr AnKiResource AnKiUi AnKiRenderer AnKiUtil AnKiPhysics AnKiScript AnKiInput ${extra_libs})

AnKi/Gr/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(COMMON
+set(common_sources
 	"Common.cpp"
 	"GrObject.cpp"
 	"RenderGraph.cpp"
@@ -7,12 +7,8 @@ set(COMMON
 	"Utils/FrameGpuAllocator.cpp"
 	"Utils/Functions.cpp")
 
-foreach(S ${COMMON})
-	anki_add_source_files("${CMAKE_CURRENT_SOURCE_DIR}/${S}")
-endforeach()
-
 if(VULKAN)
-	set(VKCPP
+	set(backend_sources
 		"Vulkan/AccelerationStructure.cpp"
 		"Vulkan/AccelerationStructureImpl.cpp"
 		"Vulkan/Buffer.cpp"
@@ -53,14 +49,21 @@ if(VULKAN)
 		"Vulkan/FrameGarbageCollector.cpp")
 
 	if(ANKI_HEADLESS)
-		set(VKCPP ${VKCPP} "Vulkan/GrManagerImplHeadless.cpp")
+		set(backend_sources ${backend_sources} "Vulkan/GrManagerImplHeadless.cpp")
 	elseif(SDL)
-		set(VKCPP ${VKCPP} "Vulkan/GrManagerImplSdl.cpp")
+		set(backend_sources ${backend_sources} "Vulkan/GrManagerImplSdl.cpp")
 	elseif(ANDROID)
-		set(VKCPP ${VKCPP} "Vulkan/GrManagerImplAndroid.cpp")
+		set(backend_sources ${backend_sources} "Vulkan/GrManagerImplAndroid.cpp")
 	endif()
-
-	foreach(S ${VKCPP})
-		anki_add_source_files("${CMAKE_CURRENT_SOURCE_DIR}/${S}")
-	endforeach()
 endif()
+
+# Have 2 libraries. The AnKiGrCommon is the bare minimum for the AnKiShaderCompiler to work. Don't have
+# AnKiShaderCompiler depend on what AnKiGr depends on
+
+add_library(AnKiGrCommon ${common_sources})
+target_compile_definitions(AnKiGrCommon PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiGrCommon AnKiUtil) # Only depend on Util
+
+add_library(AnKiGr ${backend_sources})
+target_compile_definitions(AnKiGr PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiGr AnKiCore AnKiSpirvCross AnKiGrCommon)

AnKi/Gr/Vulkan/GrManagerImpl.cpp

@@ -12,7 +12,6 @@
 #include <AnKi/Util/Functions.h>
 #include <AnKi/Util/StringList.h>
 #include <AnKi/Core/ConfigSet.h>
-#include <glslang/Public/ShaderLang.h>
 
 namespace anki {
 
@@ -153,7 +152,6 @@ Error GrManagerImpl::initInternal(const GrManagerInitInfo& init)
 		resetFrame(f);
 	}
 
-	glslang::InitializeProcess();
 	m_fenceFactory.init(getAllocator(), m_device);
 	m_semaphoreFactory.init(getAllocator(), m_device);
 	m_samplerFactory.init(this);

AnKi/Gr/Vulkan/PipelineCache.cpp

@@ -15,7 +15,7 @@ Error PipelineCache::init(VkDevice dev, VkPhysicalDevice pdev, CString cacheDir,
 {
 	ANKI_ASSERT(cacheDir && dev && pdev);
 	m_dumpSize = cfg.getGrDiskShaderCacheMaxSize();
-	m_dumpFilename.sprintf(alloc, "%s/vk_pipeline_cache", &cacheDir[0]);
+	m_dumpFilename.sprintf(alloc, "%s/VkPipelineCache", &cacheDir[0]);
 
 	// Try read the pipeline cache file.
 	DynamicArrayAuto<U8, PtrSize> diskDump(alloc);

AnKi/Importer/CMakeLists.txt

@@ -1,2 +1,4 @@
-file(GLOB SOURCES *.cpp)
-anki_add_source_files(${SOURCES})
+file(GLOB_RECURSE sources *.cpp)
+add_library(AnKiImporter ${sources})
+target_compile_definitions(AnKiImporter PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiImporter AnKiResource)

AnKi/Importer/GltfImporterMaterial.cpp

@@ -12,7 +12,7 @@ namespace anki {
 const char* MATERIAL_TEMPLATE = R"(<!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="%diffTexMutator%"/>
 				<mutator name="SPECULAR_TEX" value="%specTexMutator%"/>
@@ -42,7 +42,7 @@ const char* MATERIAL_TEMPLATE = R"(<!-- This file is auto generated by ImporterM
 )";
 
 const char* RT_MATERIAL_TEMPLATE = R"(
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

AnKi/Input/CMakeLists.txt

@@ -1,13 +1,11 @@
-set(SOURCES "")
-
 if(ANKI_HEADLESS)
-	set(SOURCES ${SOURCES} InputDummy.cpp)
+	set(sources InputDummy.cpp)
 elseif(SDL)
-	set(SOURCES ${SOURCES} InputSdl.cpp)
+	set(sources InputSdl.cpp)
 elseif(ANDROID)
-	set(SOURCES ${SOURCES} InputAndroid.cpp)
+	set(sources InputAndroid.cpp)
 endif()
 
-foreach(F ${SOURCES})
-	anki_add_source_files("${CMAKE_CURRENT_SOURCE_DIR}/${F}")
-endforeach()
+add_library(AnKiInput ${sources})
+target_compile_definitions(AnKiInput PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiInput AnKiCore AnKiImGui)

AnKi/Math/CMakeLists.txt

@@ -1,2 +1,4 @@
-file(GLOB SOURCES *.cpp)
-anki_add_source_files(${SOURCES})
+file(GLOB_RECURSE sources *.cpp)
+add_library(AnKiMath ${sources})
+target_compile_definitions(AnKiMath PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiMath AnKiUtil)

AnKi/Physics/CMakeLists.txt

@@ -1,2 +1,4 @@
-file(GLOB SOURCES *.cpp)
-anki_add_source_files(${SOURCES})
+file(GLOB_RECURSE sources *.cpp)
+add_library(AnKiPhysics ${sources})
+target_compile_definitions(AnKiPhysics PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiPhysics AnKiUtil BulletSoftBody BulletDynamics BulletCollision LinearMath)

AnKi/Renderer/Bloom.cpp

@@ -43,8 +43,9 @@ Error Bloom::initExposure()
 	m_exposure.m_rtDescr.bake();
 
 	// init shaders
-	ANKI_CHECK(getResourceManager().loadResource((getConfig().getRPreferCompute()) ? "Shaders/BloomCompute.ankiprog"
-																				   : "Shaders/BloomRaster.ankiprog",
+	ANKI_CHECK(getResourceManager().loadResource((getConfig().getRPreferCompute())
+													 ? "ShaderBinaries/BloomCompute.ankiprogbin"
+													 : "ShaderBinaries/BloomRaster.ankiprogbin",
 												 m_exposure.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_exposure.m_prog);
@@ -72,8 +73,8 @@ Error Bloom::initUpscale()
 
 	// init shaders
 	ANKI_CHECK(getResourceManager().loadResource((getConfig().getRPreferCompute())
-													 ? "Shaders/BloomUpscaleCompute.ankiprog"
-													 : "Shaders/BloomUpscaleRaster.ankiprog",
+													 ? "ShaderBinaries/BloomUpscaleCompute.ankiprogbin"
+													 : "ShaderBinaries/BloomUpscaleRaster.ankiprogbin",
 												 m_upscale.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_upscale.m_prog);

AnKi/Renderer/CMakeLists.txt

@@ -1,2 +1,4 @@
-file(GLOB_RECURSE SOURCES *.cpp)
-anki_add_source_files(${SOURCES})
+file(GLOB_RECURSE sources *.cpp)
+add_library(AnKiRenderer ${sources})
+target_compile_definitions(AnKiRenderer PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiRenderer AnKiGr AnKiResource AnKiUi)

AnKi/Renderer/ClusterBinning.cpp

@@ -30,7 +30,7 @@ Error ClusterBinning::init()
 {
 	ANKI_R_LOGV("Initializing clusterer binning");
 
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/ClusterBinning.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/ClusterBinning.ankiprogbin", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("TILE_SIZE", m_r->getTileSize());

AnKi/Renderer/DepthDownscale.cpp

@@ -68,7 +68,7 @@ Error DepthDownscale::initInternal()
 	// Progs
 	if(preferCompute)
 	{
-		ANKI_CHECK(getResourceManager().loadResource("Shaders/DepthDownscaleCompute.ankiprog", m_prog));
+		ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/DepthDownscaleCompute.ankiprogbin", m_prog));
 
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 		variantInitInfo.addMutation("WAVE_OPERATIONS", 0);
@@ -79,7 +79,7 @@ Error DepthDownscale::initInternal()
 	}
 	else
 	{
-		ANKI_CHECK(getResourceManager().loadResource("Shaders/DepthDownscaleRaster.ankiprog", m_prog));
+		ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/DepthDownscaleRaster.ankiprogbin", m_prog));
 
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 		variantInitInfo.addMutation("REDUCTION_SAMPLER", supportsReductionSampler);

AnKi/Renderer/DownscaleBlur.cpp

@@ -65,8 +65,9 @@ Error DownscaleBlur::initInternal()
 	}
 
 	// Shader programs
-	ANKI_CHECK(getResourceManager().loadResource(
-		(preferCompute) ? "Shaders/DownscaleBlurCompute.ankiprog" : "Shaders/DownscaleBlurRaster.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource((preferCompute) ? "ShaderBinaries/DownscaleBlurCompute.ankiprogbin"
+																 : "ShaderBinaries/DownscaleBlurRaster.ankiprogbin",
+												 m_prog));
 	const ShaderProgramResourceVariant* variant = nullptr;
 	m_prog->getOrCreateVariant(variant);
 	m_grProg = variant->getProgram();

AnKi/Renderer/FinalComposite.cpp

@@ -40,7 +40,7 @@ Error FinalComposite::initInternal()
 	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/BlueNoise_Rgba8_64x64.png", m_blueNoise));
 
 	// Progs
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/FinalComposite.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/FinalComposite.ankiprogbin", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addMutation("BLUE_NOISE", 1);
@@ -57,7 +57,7 @@ Error FinalComposite::initInternal()
 		m_grProgs[dbg] = variant->getProgram();
 	}
 
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/VisualizeRenderTarget.ankiprog",
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/VisualizeRenderTarget.ankiprogbin",
 												 m_defaultVisualizeRenderTargetProg));
 	const ShaderProgramResourceVariant* variant;
 	m_defaultVisualizeRenderTargetProg->getOrCreateVariant(variant);

AnKi/Renderer/GBufferPost.cpp

@@ -29,7 +29,7 @@ Error GBufferPost::initInternal()
 	ANKI_R_LOGV("Initializing GBufferPost pass");
 
 	// Load shaders
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/GBufferPost.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/GBufferPost.ankiprogbin", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("TILE_COUNTS", m_r->getTileCounts());

AnKi/Renderer/IndirectDiffuse.cpp

@@ -52,8 +52,9 @@ Error IndirectDiffuse::initInternal()
 
 	// Init SSGI+probes pass
 	{
-		ANKI_CHECK(getResourceManager().loadResource((preferCompute) ? "Shaders/IndirectDiffuseCompute.ankiprog"
-																	 : "Shaders/IndirectDiffuseRaster.ankiprog",
+		ANKI_CHECK(getResourceManager().loadResource((preferCompute)
+														 ? "ShaderBinaries/IndirectDiffuseCompute.ankiprogbin"
+														 : "ShaderBinaries/IndirectDiffuseRaster.ankiprogbin",
 													 m_main.m_prog));
 
 		const ShaderProgramResourceVariant* variant;
@@ -63,8 +64,9 @@ Error IndirectDiffuse::initInternal()
 
 	// Init denoise
 	{
-		ANKI_CHECK(getResourceManager().loadResource((preferCompute) ? "Shaders/IndirectDiffuseDenoiseCompute.ankiprog"
-																	 : "Shaders/IndirectDiffuseDenoiseRaster.ankiprog",
+		ANKI_CHECK(getResourceManager().loadResource((preferCompute)
+														 ? "ShaderBinaries/IndirectDiffuseDenoiseCompute.ankiprogbin"
+														 : "ShaderBinaries/IndirectDiffuseDenoiseRaster.ankiprogbin",
 													 m_denoise.m_prog));
 
 		ShaderProgramResourceVariantInitInfo variantInit(m_denoise.m_prog);

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -208,7 +208,8 @@ Error IndirectDiffuseProbes::initLightShading()
 
 Error IndirectDiffuseProbes::initIrradiance()
 {
-	ANKI_CHECK(m_r->getResourceManager().loadResource("Shaders/IrradianceDice.ankiprog", m_irradiance.m_prog));
+	ANKI_CHECK(
+		m_r->getResourceManager().loadResource("ShaderBinaries/IrradianceDice.ankiprogbin", m_irradiance.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_irradiance.m_prog);
 	variantInitInfo.addMutation("WORKGROUP_SIZE_XY", m_tileSize);

AnKi/Renderer/IndirectSpecular.cpp

@@ -46,8 +46,8 @@ Error IndirectSpecular::initInternal()
 
 	// Create shader
 	ANKI_CHECK(getResourceManager().loadResource((getConfig().getRPreferCompute())
-													 ? "Shaders/IndirectSpecularCompute.ankiprog"
-													 : "Shaders/IndirectSpecularRaster.ankiprog",
+													 ? "ShaderBinaries/IndirectSpecularCompute.ankiprogbin"
+													 : "ShaderBinaries/IndirectSpecularRaster.ankiprogbin",
 												 m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInit(m_prog);

AnKi/Renderer/LensFlare.cpp

@@ -51,7 +51,7 @@ Error LensFlare::initSprite()
 	m_maxSprites = U16(m_maxSpritesPerFlare * m_maxFlares);
 
 	// Load prog
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/LensFlareSprite.ankiprog", m_realProg));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/LensFlareSprite.ankiprogbin", m_realProg));
 	const ShaderProgramResourceVariant* variant;
 	m_realProg->getOrCreateVariant(variant);
 	m_realGrProg = variant->getProgram();
@@ -67,8 +67,8 @@ Error LensFlare::initOcclusion()
 												 BufferUsageBit::INDIRECT_DRAW | BufferUsageBit::STORAGE_COMPUTE_WRITE,
 												 BufferMapAccessBit::NONE, "LensFlares"));
 
-	ANKI_CHECK(
-		getResourceManager().loadResource("Shaders/LensFlareUpdateIndirectInfo.ankiprog", m_updateIndirectBuffProg));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/LensFlareUpdateIndirectInfo.ankiprogbin",
+												 m_updateIndirectBuffProg));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_updateIndirectBuffProg);
 	variantInitInfo.addConstant(

AnKi/Renderer/LightShading.cpp

@@ -62,7 +62,7 @@ Error LightShading::init()
 Error LightShading::initLightShading()
 {
 	// Load shaders and programs
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/LightShading.ankiprog", m_lightShading.m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/LightShading.ankiprogbin", m_lightShading.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_lightShading.m_prog);
 	variantInitInfo.addConstant("TILE_COUNTS", m_r->getTileCounts());
@@ -102,7 +102,7 @@ Error LightShading::initLightShading()
 
 Error LightShading::initSkybox()
 {
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/LightShadingSkybox.ankiprog", m_skybox.m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/LightShadingSkybox.ankiprogbin", m_skybox.m_prog));
 
 	for(U32 method = 0; method < 2; ++method)
 	{
@@ -120,7 +120,7 @@ Error LightShading::initSkybox()
 Error LightShading::initApplyFog()
 {
 	// Load shaders and programs
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/LightShadingApplyFog.ankiprog", m_applyFog.m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/LightShadingApplyFog.ankiprogbin", m_applyFog.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_applyFog.m_prog);
 	variantInitInfo.addConstant("Z_SPLIT_COUNT", m_r->getZSplitCount());
@@ -135,7 +135,8 @@ Error LightShading::initApplyFog()
 
 Error LightShading::initApplyIndirect()
 {
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/LightShadingApplyIndirect.ankiprog", m_applyIndirect.m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/LightShadingApplyIndirect.ankiprogbin",
+												 m_applyIndirect.m_prog));
 	const ShaderProgramResourceVariant* variant;
 	m_applyIndirect.m_prog->getOrCreateVariant(variant);
 	m_applyIndirect.m_grProg = variant->getProgram();

AnKi/Renderer/MainRenderer.cpp

@@ -46,7 +46,7 @@ Error MainRenderer::init(const MainRendererInitInfo& inf)
 	// Init other
 	if(!m_rDrawToDefaultFb)
 	{
-		ANKI_CHECK(inf.m_resourceManager->loadResource("Shaders/BlitRaster.ankiprog", m_blitProg));
+		ANKI_CHECK(inf.m_resourceManager->loadResource("ShaderBinaries/BlitRaster.ankiprogbin", m_blitProg));
 		const ShaderProgramResourceVariant* variant;
 		m_blitProg->getOrCreateVariant(variant);
 		m_blitGrProg = variant->getProgram();

AnKi/Renderer/MotionVectors.cpp

@@ -31,8 +31,8 @@ Error MotionVectors::initInternal()
 
 	// Prog
 	ANKI_CHECK(getResourceManager().loadResource((getConfig().getRPreferCompute())
-													 ? "Shaders/MotionVectorsCompute.ankiprog"
-													 : "Shaders/MotionVectorsRaster.ankiprog",
+													 ? "ShaderBinaries/MotionVectorsCompute.ankiprogbin"
+													 : "ShaderBinaries/MotionVectorsRaster.ankiprogbin",
 												 m_prog));
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("FB_SIZE", UVec2(m_r->getInternalResolution().x(), m_r->getInternalResolution().y()));

AnKi/Renderer/ProbeReflections.cpp

@@ -141,7 +141,8 @@ Error ProbeReflections::initIrradiance()
 
 	// Create prog
 	{
-		ANKI_CHECK(m_r->getResourceManager().loadResource("Shaders/IrradianceDice.ankiprog", m_irradiance.m_prog));
+		ANKI_CHECK(
+			m_r->getResourceManager().loadResource("ShaderBinaries/IrradianceDice.ankiprogbin", m_irradiance.m_prog));
 
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_irradiance.m_prog);
 
@@ -169,7 +170,7 @@ Error ProbeReflections::initIrradiance()
 Error ProbeReflections::initIrradianceToRefl()
 {
 	// Create program
-	ANKI_CHECK(m_r->getResourceManager().loadResource("Shaders/ApplyIrradianceToReflection.ankiprog",
+	ANKI_CHECK(m_r->getResourceManager().loadResource("ShaderBinaries/ApplyIrradianceToReflection.ankiprogbin",
 													  m_irradianceToRefl.m_prog));
 
 	const ShaderProgramResourceVariant* variant;

AnKi/Renderer/Renderer.cpp

@@ -113,7 +113,7 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 		return Error::USER_DATA;
 	}
 
-	ANKI_CHECK(m_resources->loadResource("Shaders/ClearTextureCompute.ankiprog", m_clearTexComputeProg));
+	ANKI_CHECK(m_resources->loadResource("ShaderBinaries/ClearTextureCompute.ankiprogbin", m_clearTexComputeProg));
 
 	// Dummy resources
 	{

AnKi/Renderer/RtShadows.cpp

@@ -42,7 +42,7 @@ Error RtShadows::initInternal()
 
 	// Ray gen program
 	{
-		ANKI_CHECK(getResourceManager().loadResource("Shaders/RtShadowsRayGen.ankiprog", m_rayGenProg));
+		ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/RtShadowsRayGen.ankiprogbin", m_rayGenProg));
 
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_rayGenProg);
 		variantInitInfo.addMutation("RAYS_PER_PIXEL", getConfig().getRRtShadowsRaysPerPixel());
@@ -55,7 +55,7 @@ Error RtShadows::initInternal()
 
 	// Miss prog
 	{
-		ANKI_CHECK(getResourceManager().loadResource("Shaders/RtShadowsMiss.ankiprog", m_missProg));
+		ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/RtShadowsMiss.ankiprogbin", m_missProg));
 		const ShaderProgramResourceVariant* variant;
 		m_missProg->getOrCreateVariant(variant);
 		m_missShaderGroupIdx = variant->getShaderGroupHandleIndex();
@@ -64,7 +64,7 @@ Error RtShadows::initInternal()
 	// Denoise program
 	if(!m_useSvgf)
 	{
-		ANKI_CHECK(getResourceManager().loadResource("Shaders/RtShadowsDenoise.ankiprog", m_denoiseProg));
+		ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/RtShadowsDenoise.ankiprogbin", m_denoiseProg));
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_denoiseProg);
 		variantInitInfo.addConstant("OUT_IMAGE_SIZE",
 									UVec2(m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2));
@@ -84,7 +84,8 @@ Error RtShadows::initInternal()
 	// SVGF variance program
 	if(m_useSvgf)
 	{
-		ANKI_CHECK(getResourceManager().loadResource("Shaders/RtShadowsSvgfVariance.ankiprog", m_svgfVarianceProg));
+		ANKI_CHECK(
+			getResourceManager().loadResource("ShaderBinaries/RtShadowsSvgfVariance.ankiprogbin", m_svgfVarianceProg));
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_svgfVarianceProg);
 		variantInitInfo.addConstant("FB_SIZE",
 									UVec2(m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2));
@@ -97,7 +98,8 @@ Error RtShadows::initInternal()
 	// SVGF atrous program
 	if(m_useSvgf)
 	{
-		ANKI_CHECK(getResourceManager().loadResource("Shaders/RtShadowsSvgfAtrous.ankiprog", m_svgfAtrousProg));
+		ANKI_CHECK(
+			getResourceManager().loadResource("ShaderBinaries/RtShadowsSvgfAtrous.ankiprogbin", m_svgfAtrousProg));
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_svgfAtrousProg);
 		variantInitInfo.addConstant("FB_SIZE",
 									UVec2(m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2));
@@ -114,7 +116,7 @@ Error RtShadows::initInternal()
 
 	// Upscale program
 	{
-		ANKI_CHECK(getResourceManager().loadResource("Shaders/RtShadowsUpscale.ankiprog", m_upscaleProg));
+		ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/RtShadowsUpscale.ankiprogbin", m_upscaleProg));
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_upscaleProg);
 		variantInitInfo.addConstant("OUT_IMAGE_SIZE",
 									UVec2(m_r->getInternalResolution().x(), m_r->getInternalResolution().y()));
@@ -125,7 +127,7 @@ Error RtShadows::initInternal()
 	}
 
 	// Debug program
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/RtShadowsVisualizeRenderTarget.ankiprog",
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/RtShadowsVisualizeRenderTarget.ankiprogbin",
 												 m_visualizeRenderTargetsProg));
 
 	// Quarter rez shadow RT

AnKi/Renderer/Scale.cpp

@@ -47,19 +47,19 @@ Error Scale::init()
 		CString shaderFname;
 		if(m_fsr && preferCompute)
 		{
-			shaderFname = "Shaders/FsrCompute.ankiprog";
+			shaderFname = "ShaderBinaries/FsrCompute.ankiprogbin";
 		}
 		else if(m_fsr)
 		{
-			shaderFname = "Shaders/FsrRaster.ankiprog";
+			shaderFname = "ShaderBinaries/FsrRaster.ankiprogbin";
 		}
 		else if(preferCompute)
 		{
-			shaderFname = "Shaders/BlitCompute.ankiprog";
+			shaderFname = "ShaderBinaries/BlitCompute.ankiprogbin";
 		}
 		else
 		{
-			shaderFname = "Shaders/BlitRaster.ankiprog";
+			shaderFname = "ShaderBinaries/BlitRaster.ankiprogbin";
 		}
 
 		ANKI_CHECK(getResourceManager().loadResource(shaderFname, m_scaleProg));
@@ -80,8 +80,9 @@ Error Scale::init()
 
 	if(needsSharpening)
 	{
-		ANKI_CHECK(getResourceManager().loadResource(
-			(preferCompute) ? "Shaders/FsrCompute.ankiprog" : "Shaders/FsrRaster.ankiprog", m_sharpenProg));
+		ANKI_CHECK(getResourceManager().loadResource((preferCompute) ? "ShaderBinaries/FsrCompute.ankiprogbin"
+																	 : "ShaderBinaries/FsrRaster.ankiprogbin",
+													 m_sharpenProg));
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_sharpenProg);
 		variantInitInfo.addMutation("SHARPEN", 1);
 		variantInitInfo.addMutation("FSR_QUALITY", 0);

AnKi/Renderer/ShadowMapping.cpp

@@ -119,8 +119,9 @@ Error ShadowMapping::initAtlas()
 
 	// Programs and shaders
 	{
-		ANKI_CHECK(getResourceManager().loadResource(
-			(preferCompute) ? "Shaders/EvsmCompute.ankiprog" : "Shaders/EvsmRaster.ankiprog", m_atlas.m_resolveProg));
+		ANKI_CHECK(getResourceManager().loadResource((preferCompute) ? "ShaderBinaries/EvsmCompute.ankiprogbin"
+																	 : "ShaderBinaries/EvsmRaster.ankiprogbin",
+													 m_atlas.m_resolveProg));
 
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_atlas.m_resolveProg);
 		variantInitInfo.addConstant("INPUT_TEXTURE_SIZE", UVec2(m_scratch.m_tileCountX * m_scratch.m_tileResolution,

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -44,8 +44,8 @@ Error ShadowmapsResolve::initInternal()
 
 	// Prog
 	ANKI_CHECK(getResourceManager().loadResource((getConfig().getRPreferCompute())
-													 ? "Shaders/ShadowmapsResolveCompute.ankiprog"
-													 : "Shaders/ShadowmapsResolveRaster.ankiprog",
+													 ? "ShaderBinaries/ShadowmapsResolveCompute.ankiprogbin"
+													 : "ShaderBinaries/ShadowmapsResolveRaster.ankiprogbin",
 												 m_prog));
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	if(getConfig().getRPreferCompute())

AnKi/Renderer/TemporalAA.cpp

@@ -37,9 +37,10 @@ Error TemporalAA::initInternal()
 {
 	ANKI_R_LOGV("Initializing TAA");
 
-	ANKI_CHECK(m_r->getResourceManager().loadResource(
-		(getConfig().getRPreferCompute()) ? "Shaders/TemporalAACompute.ankiprog" : "Shaders/TemporalAARaster.ankiprog",
-		m_prog));
+	ANKI_CHECK(m_r->getResourceManager().loadResource((getConfig().getRPreferCompute())
+														  ? "ShaderBinaries/TemporalAACompute.ankiprogbin"
+														  : "ShaderBinaries/TemporalAARaster.ankiprogbin",
+													  m_prog));
 
 	{
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);

AnKi/Renderer/Tonemapping.cpp

@@ -29,7 +29,7 @@ Error Tonemapping::initInternal()
 	ANKI_R_LOGV("Initializing tonemapping. Resolution %ux%u", width, height);
 
 	// Create program
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/TonemappingAverageLuminance.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/TonemappingAverageLuminance.ankiprogbin", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("INPUT_TEX_SIZE", UVec2(width, height));

AnKi/Renderer/TraditionalDeferredShading.cpp

@@ -25,7 +25,8 @@ Error TraditionalDeferredLightShading::init()
 {
 	// Init progs
 	{
-		ANKI_CHECK(getResourceManager().loadResource("Shaders/TraditionalDeferredShading.ankiprog", m_lightProg));
+		ANKI_CHECK(
+			getResourceManager().loadResource("ShaderBinaries/TraditionalDeferredShading.ankiprogbin", m_lightProg));
 
 		for(U32 specular = 0; specular <= 1; ++specular)
 		{
@@ -63,8 +64,8 @@ Error TraditionalDeferredLightShading::init()
 
 	// Skybox
 	{
-		ANKI_CHECK(
-			getResourceManager().loadResource("Shaders/TraditionalDeferredShadingSkybox.ankiprog", m_skyboxProg));
+		ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/TraditionalDeferredShadingSkybox.ankiprogbin",
+													 m_skyboxProg));
 
 		for(U32 i = 0; i < m_skyboxGrProgs.getSize(); ++i)
 		{

AnKi/Renderer/VolumetricFog.cpp

@@ -28,7 +28,7 @@ Error VolumetricFog::init()
 	ANKI_R_LOGV("Initializing volumetric fog. Resolution %ux%ux%u", m_volumeSize[0], m_volumeSize[1], m_volumeSize[2]);
 
 	// Shaders
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/VolumetricFogAccumulation.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/VolumetricFogAccumulation.ankiprogbin", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("VOLUME_SIZE", UVec3(m_volumeSize[0], m_volumeSize[1], m_volumeSize[2]));

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -44,7 +44,7 @@ Error VolumetricLightingAccumulation::init()
 	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/BlueNoise_Rgba8_64x64.png", m_noiseImage));
 
 	// Shaders
-	ANKI_CHECK(getResourceManager().loadResource("Shaders/VolumetricLightingAccumulation.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("ShaderBinaries/VolumetricLightingAccumulation.ankiprogbin", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addMutation("ENABLE_SHADOWS", 1);

AnKi/Renderer/VrsSriGeneration.cpp

@@ -53,14 +53,15 @@ Error VrsSriGeneration::initInternal()
 	m_fbDescr.bake();
 
 	// Load programs
-	ANKI_CHECK(getResourceManager().loadResource("AnKi/Shaders/VrsSriGenerationCompute.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("AnKi/Shaders/VrsSriGenerationCompute.ankiprogbin", m_prog));
 	ShaderProgramResourceVariantInitInfo variantInit(m_prog);
 	variantInit.addMutation("SRI_TEXEL_DIMENSION", m_sriTexelDimension);
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInit, variant);
 	m_grProg = variant->getProgram();
 
-	ANKI_CHECK(getResourceManager().loadResource("AnKi/Shaders/VrsSriVisualizeRenderTarget.ankiprog", m_visualizeProg));
+	ANKI_CHECK(
+		getResourceManager().loadResource("AnKi/Shaders/VrsSriVisualizeRenderTarget.ankiprogbin", m_visualizeProg));
 	m_visualizeProg->getOrCreateVariant(variant);
 	m_visualizeGrProg = variant->getProgram();
 

AnKi/Resource/CMakeLists.txt

@@ -1,2 +1,4 @@
-file(GLOB_RECURSE SOURCES *.cpp)
-anki_add_source_files(${SOURCES})
+file(GLOB_RECURSE sources *.cpp)
+add_library(AnKiResource ${sources})
+target_compile_definitions(AnKiResource PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiResource AnKiCore AnKiGr AnKiPhysics AnKiZLib AnKiShaderCompiler)

AnKi/Resource/ResourceManager.cpp

@@ -33,7 +33,6 @@ ResourceManager::~ResourceManager()
 {
 	ANKI_RESOURCE_LOGI("Destroying resource manager");
 
-	m_cacheDir.destroy(m_alloc);
 	m_alloc.deleteInstance(m_asyncLoader);
 	m_alloc.deleteInstance(m_shaderProgramSystem);
 	m_alloc.deleteInstance(m_transferGpuAlloc);
@@ -52,8 +51,6 @@ Error ResourceManager::init(ResourceManagerInitInfo& init)
 
 	m_tmpAlloc = TempResourceAllocator<U8>(init.m_allocCallback, init.m_allocCallbackData, 10_MB);
 
-	m_cacheDir.create(m_alloc, init.m_cacheDir);
-
 	// Init type resource managers
 #define ANKI_INSTANTIATE_RESOURCE(rsrc_, ptr_) TypeResourceManager<rsrc_>::init(m_alloc);
 #define ANKI_INSTANSIATE_RESOURCE_DELIMITER()
@@ -69,8 +66,8 @@ Error ResourceManager::init(ResourceManagerInitInfo& init)
 	ANKI_CHECK(m_transferGpuAlloc->init(m_config->getRsrcTransferScratchMemorySize(), m_gr, m_alloc));
 
 	// Init the programs
-	m_shaderProgramSystem = m_alloc.newInstance<ShaderProgramResourceSystem>(m_cacheDir, m_gr, m_fs, m_alloc);
-	ANKI_CHECK(m_shaderProgramSystem->init());
+	m_shaderProgramSystem = m_alloc.newInstance<ShaderProgramResourceSystem>(m_alloc);
+	ANKI_CHECK(m_shaderProgramSystem->init(*m_fs, *m_gr));
 
 	return Error::NONE;
 }

AnKi/Resource/ResourceManager.h

@@ -94,7 +94,6 @@ public:
 	PhysicsWorld* m_physics = nullptr;
 	ResourceFilesystem* m_resourceFs = nullptr;
 	ConfigSet* m_config = nullptr;
-	CString m_cacheDir;
 	VertexGpuMemoryPool* m_vertexMemory = nullptr;
 	AllocAlignedCallback m_allocCallback = 0;
 	void* m_allocCallbackData = nullptr;
@@ -163,11 +162,6 @@ public:
 		return *m_fs;
 	}
 
-	ANKI_INTERNAL const String& getCacheDirectory() const
-	{
-		return m_cacheDir;
-	}
-
 	template<typename T>
 	ANKI_INTERNAL T* findLoadedResource(const CString& filename)
 	{
@@ -225,7 +219,6 @@ private:
 	ConfigSet* m_config = nullptr;
 	ResourceAllocator<U8> m_alloc;
 	TempResourceAllocator<U8> m_tmpAlloc;
-	String m_cacheDir;
 	AsyncLoader* m_asyncLoader = nullptr; ///< Async loading thread
 	ShaderProgramResourceSystem* m_shaderProgramSystem = nullptr;
 	VertexGpuMemoryPool* m_vertexMem = nullptr;

AnKi/Resource/ShaderProgramResource.cpp

@@ -50,12 +50,10 @@ ShaderProgramResource::~ShaderProgramResource()
 
 Error ShaderProgramResource::load(const ResourceFilename& filename, Bool async)
 {
-	// Load the binary from the cache. It should have been compiled there
-	StringAuto baseFilename(getTempAllocator());
-	getFilepathFilename(filename, baseFilename);
-	StringAuto binaryFilename(getTempAllocator());
-	binaryFilename.sprintf("%s/%sbin", getManager().getCacheDirectory().cstr(), baseFilename.cstr());
-	ANKI_CHECK(m_binary.deserializeFromFile(binaryFilename));
+	// Load the binary
+	ResourceFilePtr file;
+	ANKI_CHECK(openFile(filename, file));
+	ANKI_CHECK(m_binary.deserializeFromAnyFile(*file));
 	const ShaderProgramBinary& binary = m_binary.getBinary();
 
 	// Create the mutators

AnKi/Resource/ShaderProgramResourceSystem.cpp

@@ -28,226 +28,28 @@ U64 ShaderProgramRaytracingLibrary::generateShaderGroupGroupHash(CString resourc
 
 ShaderProgramResourceSystem::~ShaderProgramResourceSystem()
 {
-	m_cacheDir.destroy(m_alloc);
 	m_rtLibraries.destroy(m_alloc);
 }
 
-Error ShaderProgramResourceSystem::init()
+Error ShaderProgramResourceSystem::init(ResourceFilesystem& fs, GrManager& gr)
 {
-	ANKI_TRACE_SCOPED_EVENT(COMPILE_SHADERS);
-
-	StringListAuto rtProgramFilenames(m_alloc);
-	ANKI_CHECK(compileAllShaders(m_cacheDir, *m_gr, *m_fs, m_alloc, rtProgramFilenames));
-
-	if(m_gr->getDeviceCapabilities().m_rayTracingEnabled)
+	if(!gr.getDeviceCapabilities().m_rayTracingEnabled)
 	{
-		ANKI_CHECK(createRayTracingPrograms(m_cacheDir, rtProgramFilenames, *m_gr, m_alloc, m_rtLibraries));
+		return Error::NONE;
 	}
 
-	return Error::NONE;
-}
-
-Error ShaderProgramResourceSystem::compileAllShaders(CString cacheDir, GrManager& gr, ResourceFilesystem& fs,
-													 GenericMemoryPoolAllocator<U8>& alloc,
-													 StringListAuto& rtProgramFilenames)
-{
-	class MetaFileData
+	// Create RT pipeline libraries
+	const Error err = createRayTracingPrograms(fs, gr, m_alloc, m_rtLibraries);
+	if(err)
 	{
-	public:
-		U64 m_hash;
-		ShaderTypeBit m_shaderTypes;
-		Array<U16, 3> m_padding = {};
-	};
-
-	ANKI_RESOURCE_LOGI("Compiling shader programs");
-	U32 shadersCompileCount = 0;
-	U32 shadersTotalCount = 0;
-
-	ThreadHive threadHive(getCpuCoresCount(), alloc, false);
-
-	// Compute hash for both
-	ShaderCompilerOptions compilerOptions;
-	compilerOptions.m_forceFullFloatingPointPrecision = gr.getConfig().getRsrcForceFullFpPrecision();
-	compilerOptions.m_mobilePlatform = ANKI_PLATFORM_MOBILE;
-	U64 gpuHash = computeHash(&compilerOptions, sizeof(compilerOptions));
-	gpuHash = appendHash(&SHADER_BINARY_VERSION, sizeof(SHADER_BINARY_VERSION), gpuHash);
-
-	ANKI_CHECK(fs.iterateAllFilenames([&](CString fname) -> Error {
-		// Check file extension
-		StringAuto extension(alloc);
-		getFilepathExtension(fname, extension);
-		if(extension.getLength() != 8 || extension != "ankiprog")
-		{
-			return Error::NONE;
-		}
-
-		++shadersTotalCount;
-
-		if(fname.find("/Rt") != CString::NPOS && !gr.getDeviceCapabilities().m_rayTracingEnabled)
-		{
-			// Skip RT programs when RT is disabled
-			return Error::NONE;
-		}
-
-		// Get some filenames
-		StringAuto baseFname(alloc);
-		getFilepathFilename(fname, baseFname);
-		StringAuto metaFname(alloc);
-		metaFname.sprintf("%s/%smeta", cacheDir.cstr(), baseFname.cstr());
-
-		// Get the hash from the meta file
-		U64 metafileHash = 0;
-		ShaderTypeBit metafileShaderTypes = ShaderTypeBit::NONE;
-		if(fileExists(metaFname))
-		{
-			File metaFile;
-			ANKI_CHECK(metaFile.open(metaFname, FileOpenFlag::READ | FileOpenFlag::BINARY));
-			MetaFileData data;
-			ANKI_CHECK(metaFile.read(&data, sizeof(data)));
-
-			if(data.m_hash == 0 || data.m_shaderTypes == ShaderTypeBit::NONE)
-			{
-				ANKI_RESOURCE_LOGE("Wrong data found in the metafile: %s", metaFname.cstr());
-				return Error::USER_DATA;
-			}
-
-			metafileHash = data.m_hash;
-			metafileShaderTypes = data.m_shaderTypes;
-		}
-
-		// Load interface
-		class FSystem : public ShaderProgramFilesystemInterface
-		{
-		public:
-			ResourceFilesystem* m_fsystem = nullptr;
-
-			Error readAllText(CString filename, StringAuto& txt) final
-			{
-				ResourceFilePtr file;
-				ANKI_CHECK(m_fsystem->openFile(filename, file));
-				ANKI_CHECK(file->readAllText(txt));
-				return Error::NONE;
-			}
-		} fsystem;
-		fsystem.m_fsystem = &fs;
-
-		// Skip interface
-		class Skip : public ShaderProgramPostParseInterface
-		{
-		public:
-			U64 m_metafileHash;
-			U64 m_newHash;
-			U64 m_gpuHash;
-			CString m_fname;
-
-			Bool skipCompilation(U64 hash)
-			{
-				ANKI_ASSERT(hash != 0);
-				const Array<U64, 2> hashes = {hash, m_gpuHash};
-				const U64 finalHash = computeHash(hashes.getBegin(), hashes.getSizeInBytes());
-
-				m_newHash = finalHash;
-				const Bool skip = finalHash == m_metafileHash;
-
-				if(!skip)
-				{
-					ANKI_RESOURCE_LOGI("\t%s", m_fname.cstr());
-				}
-
-				return skip;
-			};
-		} skip;
-		skip.m_metafileHash = metafileHash;
-		skip.m_newHash = 0;
-		skip.m_gpuHash = gpuHash;
-		skip.m_fname = fname;
-
-		// Threading interface
-		class TaskManager : public ShaderProgramAsyncTaskInterface
-		{
-		public:
-			ThreadHive* m_hive = nullptr;
-			GenericMemoryPoolAllocator<U8> m_alloc;
-
-			void enqueueTask(void (*callback)(void* userData), void* userData)
-			{
-				class Ctx
-				{
-				public:
-					void (*m_callback)(void* userData);
-					void* m_userData;
-					GenericMemoryPoolAllocator<U8> m_alloc;
-				};
-				Ctx* ctx = m_alloc.newInstance<Ctx>();
-				ctx->m_callback = callback;
-				ctx->m_userData = userData;
-				ctx->m_alloc = m_alloc;
-
-				m_hive->submitTask(
-					[](void* userData, U32 threadId, ThreadHive& hive, ThreadHiveSemaphore* signalSemaphore) {
-						Ctx* ctx = static_cast<Ctx*>(userData);
-						ctx->m_callback(ctx->m_userData);
-						auto alloc = ctx->m_alloc;
-						alloc.deleteInstance(ctx);
-					},
-					ctx);
-			}
-
-			Error joinTasks()
-			{
-				m_hive->waitAllTasks();
-				return Error::NONE;
-			}
-		} taskManager;
-		taskManager.m_hive = &threadHive;
-		taskManager.m_alloc = alloc;
-
-		// Compile
-		ShaderProgramBinaryWrapper binary(alloc);
-		ANKI_CHECK(compileShaderProgram(fname, fsystem, &skip, &taskManager, alloc, compilerOptions, binary));
-
-		const Bool cachedBinIsUpToDate = metafileHash == skip.m_newHash;
-		if(!cachedBinIsUpToDate)
-		{
-			++shadersCompileCount;
-		}
-
-		// Update the meta file
-		if(!cachedBinIsUpToDate)
-		{
-			File metaFile;
-			ANKI_CHECK(metaFile.open(metaFname, FileOpenFlag::WRITE | FileOpenFlag::BINARY));
-
-			MetaFileData data;
-			data.m_hash = skip.m_newHash;
-			data.m_shaderTypes = binary.getBinary().m_presentShaderTypes;
-			metafileShaderTypes = data.m_shaderTypes;
-			ANKI_CHECK(metaFile.write(&data, sizeof(data)));
-		}
-
-		// Save the binary to the cache
-		if(!cachedBinIsUpToDate)
-		{
-			StringAuto storeFname(alloc);
-			storeFname.sprintf("%s/%sbin", cacheDir.cstr(), baseFname.cstr());
-			ANKI_CHECK(binary.serializeToFile(storeFname));
-		}
-
-		// Gather RT programs
-		if(!!(metafileShaderTypes & ShaderTypeBit::ALL_RAY_TRACING))
-		{
-			rtProgramFilenames.pushBack(fname);
-		}
-
-		return Error::NONE;
-	}));
+		ANKI_RESOURCE_LOGE("Failed to create ray tracing programs");
+	}
 
-	ANKI_RESOURCE_LOGI("Compiled %u shader programs out of %u", shadersCompileCount, shadersTotalCount);
-	return Error::NONE;
+	return err;
 }
 
-Error ShaderProgramResourceSystem::createRayTracingPrograms(CString cacheDir, const StringListAuto& rtProgramFilenames,
-															GrManager& gr, GenericMemoryPoolAllocator<U8>& alloc,
+Error ShaderProgramResourceSystem::createRayTracingPrograms(ResourceFilesystem& fs, GrManager& gr,
+															GenericMemoryPoolAllocator<U8>& alloc,
 															DynamicArray<ShaderProgramRaytracingLibrary>& outLibs)
 {
 	ANKI_RESOURCE_LOGI("Creating ray tracing programs");
@@ -356,17 +158,34 @@ Error ShaderProgramResourceSystem::createRayTracingPrograms(CString cacheDir, co
 
 	DynamicArrayAuto<Lib> libs(alloc);
 
-	for(const String& filename : rtProgramFilenames)
-	{
+	ANKI_CHECK(fs.iterateAllFilenames([&](CString filename) -> Error {
+		// Check file extension
+		StringAuto extension(alloc);
+		getFilepathExtension(filename, extension);
+		const Char binExtension[] = "ankiprogbin";
+		if(extension.getLength() != sizeof(binExtension) - 1 || extension != binExtension)
+		{
+			return Error::NONE;
+		}
+
+		if(filename.find("ShaderBinaries/Rt") != 0)
+		{
+			// Doesn't start with the expected path, skip it
+			return Error::NONE;
+		}
+
 		// Get the binary
-		StringAuto baseFilename(alloc);
-		getFilepathFilename(filename, baseFilename);
-		StringAuto binaryFilename(alloc);
-		binaryFilename.sprintf("%s/%sbin", cacheDir.cstr(), baseFilename.cstr());
+		ResourceFilePtr file;
+		ANKI_CHECK(fs.openFile(filename, file));
 		ShaderProgramBinaryWrapper binaryw(alloc);
-		ANKI_CHECK(binaryw.deserializeFromFile(binaryFilename));
+		ANKI_CHECK(binaryw.deserializeFromAnyFile(*file));
 		const ShaderProgramBinary& binary = binaryw.getBinary();
 
+		if(!(binary.m_presentShaderTypes & ShaderTypeBit::ALL_RAY_TRACING))
+		{
+			return Error::NONE;
+		}
+
 		// Checks
 		if(binary.m_libraryName[0] == '\0')
 		{
@@ -543,7 +362,9 @@ Error ShaderProgramResourceSystem::createRayTracingPrograms(CString cacheDir, co
 				lib->addGroup(filename, mutation.m_hash, MAX_U32, MAX_U32, chitShaderIdx, ahitShaderIdx);
 			}
 		}
-	} // For all RT filenames
+
+		return Error::NONE;
+	})); // For all RT filenames
 
 	// Create the libraries the value that goes to the m_resourceHashToShaderGroupHandleIndex hashmap is the index of
 	// the shader handle inside the program. Leverage the fact that there is a predefined order between shader types.

AnKi/Resource/ShaderProgramResourceSystem.h

@@ -76,18 +76,14 @@ private:
 class ShaderProgramResourceSystem
 {
 public:
-	ShaderProgramResourceSystem(CString cacheDir, GrManager* gr, ResourceFilesystem* fs,
-								const GenericMemoryPoolAllocator<U8>& alloc)
+	ShaderProgramResourceSystem(const GenericMemoryPoolAllocator<U8>& alloc)
 		: m_alloc(alloc)
-		, m_gr(gr)
-		, m_fs(fs)
 	{
-		m_cacheDir.create(alloc, cacheDir);
 	}
 
 	~ShaderProgramResourceSystem();
 
-	ANKI_USE_RESULT Error init();
+	ANKI_USE_RESULT Error init(ResourceFilesystem& fs, GrManager& gr);
 
 	ConstWeakArray<ShaderProgramRaytracingLibrary> getRayTracingLibraries() const
 	{
@@ -96,18 +92,10 @@ public:
 
 private:
 	GenericMemoryPoolAllocator<U8> m_alloc;
-	String m_cacheDir;
-	GrManager* m_gr;
-	ResourceFilesystem* m_fs;
 	DynamicArray<ShaderProgramRaytracingLibrary> m_rtLibraries;
 
-	/// Iterate all programs in the filesystem and compile them to AnKi's binary format.
-	static Error compileAllShaders(CString cacheDir, GrManager& gr, ResourceFilesystem& fs,
-								   GenericMemoryPoolAllocator<U8>& alloc, StringListAuto& rtProgramFilenames);
-
-	static Error createRayTracingPrograms(CString cacheDir, const StringListAuto& rtProgramFilenames, GrManager& gr,
-										  GenericMemoryPoolAllocator<U8>& alloc,
-										  DynamicArray<ShaderProgramRaytracingLibrary>& libs);
+	static Error createRayTracingPrograms(ResourceFilesystem& fs, GrManager& gr, GenericMemoryPoolAllocator<U8>& alloc,
+										  DynamicArray<ShaderProgramRaytracingLibrary>& outLibs);
 };
 /// @}
 

AnKi/Scene/CMakeLists.txt

@@ -1,2 +1,4 @@
-file(GLOB_RECURSE SOURCES *.cpp)
-anki_add_source_files(${SOURCES})
+file(GLOB_RECURSE sources *.cpp)
+add_library(AnKiScene ${sources})
+target_compile_definitions(AnKiScene PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiScene AnKiResource AnKiScript AnKiCollision)

AnKi/Scene/Components/GpuParticleEmitterComponent.cpp

@@ -41,8 +41,8 @@ Error GpuParticleEmitterComponent::loadParticleEmitterResource(CString filename)
 	m_maxParticleCount = inProps.m_maxNumOfParticles;
 
 	// Create program
-	ANKI_CHECK(
-		m_node->getSceneGraph().getResourceManager().loadResource("Shaders/GpuParticlesSimulation.ankiprog", m_prog));
+	ANKI_CHECK(m_node->getSceneGraph().getResourceManager().loadResource(
+		"ShaderBinaries/GpuParticlesSimulation.ankiprogbin", m_prog));
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variant);
 	m_grProg = variant->getProgram();

AnKi/Scene/DebugDrawer.cpp

@@ -67,7 +67,7 @@ void allocateAndPopulateDebugBox(StagingGpuMemoryPool& stagingGpuAllocator, Stag
 
 Error DebugDrawer2::init(ResourceManager* rsrcManager)
 {
-	ANKI_CHECK(rsrcManager->loadResource("Shaders/SceneDebug.ankiprog", m_prog));
+	ANKI_CHECK(rsrcManager->loadResource("ShaderBinaries/SceneDebug.ankiprogbin", m_prog));
 
 	{
 		BufferInitInfo bufferInit("DebugCube");

AnKi/Script/CMakeLists.txt

@@ -1,2 +1,4 @@
-file(GLOB_RECURSE SOURCES *.cpp)
-anki_add_source_files(${SOURCES})
+file(GLOB_RECURSE sources *.cpp)
+add_library(AnKiScript ${sources})
+target_compile_definitions(AnKiScript PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiScript AnKiRenderer AnKiScene AnKiMath AnKiLua)

AnKi/ShaderCompiler/CMakeLists.txt

@@ -1,2 +1,4 @@
-file(GLOB SOURCES *.cpp)
-anki_add_source_files(${SOURCES})
+file(GLOB_RECURSE sources *.cpp)
+add_library(AnKiShaderCompiler ${sources})
+target_compile_definitions(AnKiShaderCompiler PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiShaderCompiler AnKiGrCommon AnKiSpirvCross glslang SPIRV OGLCompiler OSDependent)

AnKi/ShaderCompiler/ShaderProgramCompiler.cpp

@@ -30,23 +30,9 @@ Error ShaderProgramBinaryWrapper::serializeToFile(CString fname) const
 
 Error ShaderProgramBinaryWrapper::deserializeFromFile(CString fname)
 {
-	cleanup();
-
 	File file;
 	ANKI_CHECK(file.open(fname, FileOpenFlag::READ | FileOpenFlag::BINARY));
-
-	BinaryDeserializer deserializer;
-	ANKI_CHECK(deserializer.deserialize(m_binary, m_alloc, file));
-
-	m_singleAllocation = true;
-
-	if(memcmp(SHADER_BINARY_MAGIC, &m_binary->m_magic[0], strlen(SHADER_BINARY_MAGIC)) != 0)
-	{
-		ANKI_SHADER_COMPILER_LOGE("Corrupted or wrong version of shader binary: %s. Clean the shader cache",
-								  fname.cstr());
-		return Error::USER_DATA;
-	}
-
+	ANKI_CHECK(deserializeFromAnyFile(file));
 	return Error::NONE;
 }
 

AnKi/ShaderCompiler/ShaderProgramCompiler.h

@@ -47,6 +47,9 @@ public:
 
 	ANKI_USE_RESULT Error deserializeFromFile(CString fname);
 
+	template<typename TFile>
+	ANKI_USE_RESULT Error deserializeFromAnyFile(TFile& fname);
+
 	const ShaderProgramBinary& getBinary() const
 	{
 		ANKI_ASSERT(m_binary);
@@ -61,6 +64,24 @@ private:
 	void cleanup();
 };
 
+template<typename TFile>
+Error ShaderProgramBinaryWrapper::deserializeFromAnyFile(TFile& file)
+{
+	cleanup();
+	BinaryDeserializer deserializer;
+	ANKI_CHECK(deserializer.deserialize(m_binary, m_alloc, file));
+
+	m_singleAllocation = true;
+
+	if(memcmp(SHADER_BINARY_MAGIC, &m_binary->m_magic[0], strlen(SHADER_BINARY_MAGIC)) != 0)
+	{
+		ANKI_SHADER_COMPILER_LOGE("Corrupted or wrong version of shader binary.");
+		return Error::USER_DATA;
+	}
+
+	return Error::NONE;
+}
+
 /// Takes an AnKi special shader program and spits a binary.
 ANKI_USE_RESULT Error compileShaderProgram(CString fname, ShaderProgramFilesystemInterface& fsystem,
 										   ShaderProgramPostParseInterface* postParseCallback,

AnKi/Shaders/CMakeLists.txt

@@ -0,0 +1,33 @@
+file(GLOB_RECURSE prog_fnames *.ankiprog)
+file(GLOB_RECURSE glsl_fnames *.glsl)
+file(GLOB_RECURSE header_fnames *.h)
+
+ProcessorCount(proc_count)
+MATH(EXPR proc_count "${proc_count}-1")
+
+foreach(prog_fname ${prog_fnames})
+	get_filename_component(filename ${prog_fname} NAME)
+	set(bin_fname ${CMAKE_CURRENT_BINARY_DIR}/${filename}bin)
+
+	get_filename_component(filename ${prog_fname} NAME_WE)
+	set(target_name "${filename}.ankiprogbin")
+
+	add_custom_command(
+		OUTPUT ${bin_fname}
+		COMMAND ShaderCompiler -o ${bin_fname} -j ${proc_count} -I "${CMAKE_CURRENT_SOURCE_DIR}/../.." ${prog_fname}
+		DEPENDS ShaderCompiler ${prog_fname} ${glsl_fnames} ${header_fnames}
+		COMMENT "Build ${prog_fname}")
+
+	add_custom_target(
+		${target_name} ALL
+		DEPENDS ${bin_fname})
+
+	add_custom_command(
+		TARGET ${target_name} POST_BUILD
+		COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/Bin/ShaderBinaries
+		COMMAND ${CMAKE_COMMAND} -E copy ${bin_fname} ${CMAKE_BINARY_DIR}/Bin/ShaderBinaries)
+
+	list(APPEND program_targets ${target_name})
+endforeach()
+
+add_custom_target(AnKiShaders DEPENDS ${program_targets})

AnKi/Ui/CMakeLists.txt

@@ -1,2 +1,4 @@
-file(GLOB SOURCES *.cpp)
-anki_add_source_files(${SOURCES})
+file(GLOB_RECURSE sources *.cpp)
+add_library(AnKiUi ${sources})
+target_compile_definitions(AnKiUi PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiUi AnKiGr AnKiResource AnKiImGui)

AnKi/Ui/Canvas.cpp

@@ -36,7 +36,7 @@ Error Canvas::init(FontPtr font, U32 fontHeight, U32 width, U32 height)
 	resize(width, height);
 
 	// Create program
-	ANKI_CHECK(m_manager->getResourceManager().loadResource("Shaders/Ui.ankiprog", m_prog));
+	ANKI_CHECK(m_manager->getResourceManager().loadResource("ShaderBinaries/Ui.ankiprogbin", m_prog));
 
 	for(U32 i = 0; i < SHADER_COUNT; ++i)
 	{

AnKi/Util/Array.h

@@ -35,7 +35,6 @@ public:
 	template<typename TInt, ANKI_ENABLE(!std::is_enum<TInt>::value)>
 	Reference operator[](const TInt n)
 	{
-		ANKI_ASSERT(!(std::is_signed<TInt>::value && n < 0));
 		ANKI_ASSERT(PtrSize(n) < N);
 		return m_data[n];
 	}
@@ -44,7 +43,6 @@ public:
 	template<typename TInt, ANKI_ENABLE(!std::is_enum<TInt>::value)>
 	ConstReference operator[](const TInt n) const
 	{
-		ANKI_ASSERT(!(std::is_signed<TInt>::value && n < 0));
 		ANKI_ASSERT(PtrSize(n) < N);
 		return m_data[n];
 	}

AnKi/Util/CMakeLists.txt

@@ -1,18 +1,43 @@
-set(SOURCES Assert.cpp Functions.cpp File.cpp Filesystem.cpp Memory.cpp System.cpp HighRezTimer.cpp ThreadPool.cpp
-	ThreadHive.cpp Hash.cpp Logger.cpp String.cpp StringList.cpp Tracer.cpp Serializer.cpp Xml.cpp F16.cpp)
+set(sources
+	Assert.cpp
+	Functions.cpp
+	File.cpp
+	Filesystem.cpp
+	Memory.cpp
+	System.cpp
+	HighRezTimer.cpp
+	ThreadPool.cpp
+	ThreadHive.cpp
+	Hash.cpp
+	Logger.cpp
+	String.cpp
+	StringList.cpp
+	Tracer.cpp
+	Serializer.cpp
+	Xml.cpp
+	F16.cpp)
 
 if(LINUX OR ANDROID OR MACOS)
-	set(SOURCES ${SOURCES} HighRezTimerPosix.cpp FilesystemPosix.cpp ThreadPosix.cpp ProcessPosix.cpp)
+	set(sources ${sources}
+		HighRezTimerPosix.cpp
+		FilesystemPosix.cpp
+		ThreadPosix.cpp
+		ProcessPosix.cpp)
 else()
-	set(SOURCES ${SOURCES} HighRezTimerWindows.cpp FilesystemWindows.cpp ThreadWindows.cpp ProcessWindows.cpp Win32Minimal.cpp)
+	set(sources ${sources}
+		HighRezTimerWindows.cpp
+		FilesystemWindows.cpp
+		ThreadWindows.cpp
+		ProcessWindows.cpp
+		Win32Minimal.cpp)
 endif()
 
 if(LINUX OR ANDROID)
-	set(SOURCES ${SOURCES} INotifyPosix.cpp)
+	set(sources ${sources} INotifyPosix.cpp)
 elseif(WINDOWS)
-	set(SOURCES ${SOURCES} INotifyWindows.cpp)
+	set(sources ${sources} INotifyWindows.cpp)
 endif()
 
-foreach(F ${SOURCES})
-	anki_add_source_files("${CMAKE_CURRENT_SOURCE_DIR}/${F}")
-endforeach()
+add_library(AnKiUtil ${sources})
+target_compile_definitions(AnKiUtil PRIVATE -DANKI_SOURCE_FILE)
+target_link_libraries(AnKiUtil AnKiTinyXml2)

AnKi/Util/Serializer.h

@@ -203,8 +203,8 @@ public:
 	/// @param x The struct to read.
 	/// @param allocator The allocator to use to allocate the new structures.
 	/// @param file The file to read from.
-	template<typename T>
-	static ANKI_USE_RESULT Error deserialize(T*& x, GenericMemoryPoolAllocator<U8> allocator, File& file);
+	template<typename T, typename TFile>
+	static ANKI_USE_RESULT Error deserialize(T*& x, GenericMemoryPoolAllocator<U8> allocator, TFile& file);
 
 	/// Read a single value. Can't call this directly.
 	template<typename T>

AnKi/Util/Serializer.inl.h

@@ -161,14 +161,14 @@ Error BinarySerializer::doDynamicArrayComplexType(const T* arr, PtrSize size, Pt
 	return Error::NONE;
 }
 
-template<typename T>
-Error BinaryDeserializer::deserialize(T*& x, GenericMemoryPoolAllocator<U8> allocator, File& file)
+template<typename T, typename TFile>
+Error BinaryDeserializer::deserialize(T*& x, GenericMemoryPoolAllocator<U8> allocator, TFile& file)
 {
 	x = nullptr;
 
 	detail::BinarySerializerHeader header;
 	ANKI_CHECK(file.read(&header, sizeof(header)));
-	const PtrSize dataFilePos = file.tell();
+	const PtrSize dataFilePos = sizeof(header);
 
 	// Sanity checks
 	{

CMakeLists.txt

@@ -16,14 +16,6 @@ function(anki_install_executable EXE)
 	endif()
 endfunction()
 
-macro(anki_add_source_files)
-	foreach(f ${ARGV})
-		set(AK_SOURCES "${AK_SOURCES} ${f}")
-	endforeach()
-
-	set(AK_SOURCES ${AK_SOURCES} PARENT_SCOPE)
-endmacro()
-
 macro(anki_new_executable)
 	if(NOT ANDROID)
 		add_executable(${ARGV})
@@ -404,56 +396,11 @@ else()
 	add_compile_definitions("_CRT_SECURE_NO_WARNINGS=1") # Disable some string function warnings
 endif()
 
-# Set platform specific
-if(LINUX)
-	if(GL)
-		set(THIRD_PARTY_LIBS ${ANKI_GR_BACKEND} AnKiGlew)
-	else()
-		if(SDL)
-			set(THIRD_PARTY_LIBS ${THIRD_PARTY_LIBS} X11-xcb)
-		endif()
-	endif()
-
-	set(THIRD_PARTY_LIBS ${THIRD_PARTY_LIBS} pthread dl)
-elseif(MACOS)
-	find_package(OpenGL REQUIRED)
-	set(THIRD_PARTY_LIBS ${OPENGL_LIBRARIES} AnKiGlew pthread)
-elseif(ANDROID)
-	set(THIRD_PARTY_LIBS log android)
-	#include_directories("${ANDROID_NDK}/sources/android/native_app_glue")
-	#set(_SYS_SRC "${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c")
-
-	set(THIRD_PARTY_LIBS ${THIRD_PARTY_LIBS} AnKiAndroidNativeGlue)
-elseif(WINDOWS)
-	if(GL)
-		set(THIRD_PARTY_LIBS ${THIRD_PARTY_LIBS} AnKiGlew opengl32)
-	else()
-		set(THIRD_PARTY_LIBS ${THIRD_PARTY_LIBS})
-	endif()
-
-	set(THIRD_PARTY_LIBS ${THIRD_PARTY_LIBS} version Imm32 Winmm DbgHelp)
-else()
-	message(FATAL_ERROR "Unhandled case")
-endif()
-
-if(SDL)
-	set(THIRD_PARTY_LIBS ${THIRD_PARTY_LIBS} SDL2-static)
-endif()
-
-if(ANDROID)
-	set(THIRD_PARTY_LIBS ${THIRD_PARTY_LIBS} AnKiHwcPipe)
-endif()
-
-set(THIRD_PARTY_LIBS ${THIRD_PARTY_LIBS} BulletSoftBody BulletDynamics BulletCollision LinearMath
-	AnKiSpirvCross AnKiTinyXml2 AnKiLua AnKiMeshOptimizer AnKiZLib glslang SPIRV OGLCompiler OSDependent AnKiImGui)
-
 # Add AnKi sub libraries
 add_subdirectory(AnKi)
 
-separate_arguments(AK_SOURCES)
-add_library(AnKi ${AK_SOURCES})
-target_compile_definitions(AnKi PRIVATE -DANKI_SOURCE_FILE)
-target_link_libraries(AnKi ${THIRD_PARTY_LIBS})
+add_library(AnKi INTERFACE)
+target_link_libraries(AnKi INTERFACE AnKiCore ${THIRD_PARTY_LIBS})
 
 ################################################################################
 # AnKi extra                                                                   #

Samples/Common/SampleApp.cpp

@@ -33,7 +33,7 @@ Error SampleApp::init(int argc, char** argv, CString sampleName)
 #endif
 
 	ANKI_CHECK(m_config.setFromCommandLineArguments(argc - 1, argv + 1));
-	ANKI_CHECK(App::init(&m_config, allocAligned, nullptr));
+	ANKI_CHECK(App::init(&m_config, argv[0], allocAligned, nullptr));
 
 	ANKI_CHECK(sampleExtraInit());
 

Samples/Sponza/Assets/Fire.ankimtl

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <material shadow="0">
 	<shaderPrograms>
-		<shaderProgram filename="Anki/Shaders/ForwardShadingParticles.ankiprog">
+		<shaderProgram filename="ShaderBinaries/ForwardShadingParticles.ankiprogbin">
 			<mutation>
 				<mutator name="ANIMATED_TEXTURE" value="0"/>
 				<mutator name="LIGHT" value="0"/>

Samples/Sponza/Assets/Smoke.ankimtl

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <material shadow="0">
 	<shaderPrograms>
-		<shaderProgram filename="Anki/Shaders/ForwardShadingParticles.ankiprog">
+		<shaderProgram filename="ShaderBinaries/ForwardShadingParticles.ankiprogbin">
 			<mutation>
 				<mutator name="ANIMATED_TEXTURE" value="0"/>
 				<mutator name="LIGHT" value="1"/>

Samples/Sponza/Assets/arch.001_efebbb2a6f84fff0.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/arch_e0c8c7e29c806284.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/bricks_8bd6f24aa0ad3654.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/ceiling_3fd94cde277a48e1.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/chain_33ef478b87fe7c15.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/column_a_1e1bacae3460b88.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/column_b_c9391d56bff59fc3.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/column_c_43f866fc7b9f0169.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/details_4242afc5fc479920.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/fabric_a_945c29fc221550fb.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/fabric_c_c8bf70dee411d1bd.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/fabric_d_8ff4aebb25bf20b0.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/fabric_e_d1c5a44841c48230.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/fabric_f_d54bbaca38ed4391.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/flagpole_6c7e0eb8dd33b39e.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/floor_71cbd2644e53ab8c.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/leaf_3a245efd17475037.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/lion_c45d3035db3bc17b.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/lion_stand_ab5e3642131ad971.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/roof_4359bd4e3b26845.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/vase_45c3983f6cc9c489.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/vase_fl_580cea687de3d758.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/vase_hanging_c2d2b40b27cacd7d.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Samples/Sponza/Assets/vase_round_71af81a1ac0a7c3e.ankimtl

@@ -2,7 +2,7 @@
 <!-- This file is auto generated by ImporterMaterial.cpp -->
 <material shadows="1">
 	<shaderPrograms>
-		<shaderProgram filename="AnKi/Shaders/GBufferGeneric.ankiprog">
+		<shaderProgram filename="ShaderBinaries/GBufferGeneric.ankiprogbin">
 			<mutation>
 				<mutator name="DIFFUSE_TEX" value="1"/>
 				<mutator name="SPECULAR_TEX" value="0"/>
@@ -15,7 +15,7 @@
 			</mutation>
 		</shaderProgram>
 		
-		<shaderProgram filename="AnKi/Shaders/RtShadowsHit.ankiprog">
+		<shaderProgram filename="ShaderBinaries/RtShadowsHit.ankiprogbin">
 			<mutation>
 				<mutator name="ALPHA_TEXTURE" value="0"/>
 			</mutation>

Sandbox/Main.cpp

@@ -38,7 +38,7 @@ Error MyApp::init(int argc, char* argv[])
 	ANKI_CHECK(m_config.setFromCommandLineArguments(argc - 2, argv + 2));
 
 	// Init super class
-	ANKI_CHECK(App::init(&m_config, allocAligned, nullptr));
+	ANKI_CHECK(App::init(&m_config, argv[0], allocAligned, nullptr));
 
 	// Other init
 	ResourceManager& resources = getResourceManager();

Tests/CMakeLists.txt

@@ -1,8 +1,7 @@
-file(GLOB_RECURSE TESTS_SOURCES *.cpp)
-file(GLOB_RECURSE TESTS_HEADERS *.h)
+file(GLOB_RECURSE sources *.cpp)
 
 include_directories("..")
 
-anki_new_executable(Tests ${TESTS_SOURCES} ${TESTS_HEADERS})
+anki_new_executable(Tests ${sources})
 target_compile_definitions(Tests PRIVATE -DANKI_SOURCE_FILE)
-target_link_libraries(Tests AnKi)
+target_link_libraries(Tests AnKi AnKiShaderCompiler AnKiImporter)

Tests/Framework/Framework.cpp

@@ -286,7 +286,6 @@ ResourceManager* createResourceManager(ConfigSet* cfg, GrManager* gr, PhysicsWor
 	rinit.m_physics = physics;
 	rinit.m_resourceFs = resourceFs;
 	rinit.m_config = cfg;
-	rinit.m_cacheDir = "./";
 	rinit.m_allocCallback = allocAligned;
 	rinit.m_allocCallbackData = nullptr;
 	ResourceManager* resources = new ResourceManager();

Tests/Resource/ResourceManager.cpp

@@ -20,7 +20,6 @@ ANKI_TEST(Resource, ResourceManager)
 	ResourceManagerInitInfo rinit;
 	rinit.m_gr = nullptr;
 	rinit.m_config = &config;
-	rinit.m_cacheDir = "/tmp/";
 	rinit.m_allocCallback = allocAligned;
 	rinit.m_allocCallbackData = nullptr;
 	ResourceManager* resources = alloc.newInstance<ResourceManager>();

Tools/GltfImporter/CMakeLists.txt

@@ -1,4 +1,4 @@
-file(GLOB_RECURSE SOURCES *.cpp)
+file(GLOB_RECURSE sources *.cpp)
 
-anki_new_executable(GltfImporter ${SOURCES})
-target_link_libraries(GltfImporter AnKi)
+anki_new_executable(GltfImporter ${sources})
+target_link_libraries(GltfImporter AnKiImporter AnKiMeshOptimizer)

Tools/Image/CMakeLists.txt

@@ -2,4 +2,4 @@ anki_new_executable(ImageViewer ImageViewerMain.cpp)
 target_link_libraries(ImageViewer AnKi)
 
 anki_new_executable(ImageImporter ImageImporterMain.cpp)
-target_link_libraries(ImageImporter AnKi)
+target_link_libraries(ImageImporter AnKiImporter)

Tools/Image/ImageViewerMain.cpp

@@ -285,7 +285,7 @@ public:
 		config->setGrDebugMarkers(false);
 		ANKI_CHECK(config->setFromCommandLineArguments(argc - 2, argv + 2));
 
-		ANKI_CHECK(App::init(config, allocAligned, nullptr));
+		ANKI_CHECK(App::init(config, argv[0], allocAligned, nullptr));
 
 		// Load the texture
 		ImageResourcePtr image;

Tools/Shader/CMakeLists.txt

@@ -1,5 +1,5 @@
 anki_new_executable(ShaderDump ShaderProgramBinaryDumpMain.cpp)
-target_link_libraries(ShaderDump AnKi)
+target_link_libraries(ShaderDump AnKiShaderCompiler)
 
 anki_new_executable(ShaderCompiler ShaderProgramCompilerMain.cpp)
-target_link_libraries(ShaderCompiler AnKi)
+target_link_libraries(ShaderCompiler AnKiShaderCompiler)

Tools/Shader/ShaderProgramCompilerMain.cpp

@@ -241,7 +241,5 @@ int main(int argc, char** argv)
 		return 1;
 	}
 
-	ANKI_LOGI("Done!");
-
 	return 0;
 }