Rename engine_data to EngineAssets

AnKi/Core/DeveloperConsole.cpp

@@ -26,7 +26,7 @@ Error DeveloperConsole::init(AllocAlignedCallback allocCb, void* allocCbUserData
 	m_alloc = HeapAllocator<U8>(allocCb, allocCbUserData);
 	zeroMemory(m_inputText);
 
-	ANKI_CHECK(m_manager->newInstance(m_font, "engine_data/UbuntuMonoRegular.ttf", std::initializer_list<U32>{16}));
+	ANKI_CHECK(m_manager->newInstance(m_font, "EngineAssets/UbuntuMonoRegular.ttf", std::initializer_list<U32>{16}));
 
 	// Add a new callback to the logger
 	LoggerSingleton::get().addMessageHandler(this, loggerCallback);

AnKi/Renderer/Bloom.cpp

@@ -36,7 +36,7 @@ Error Bloom::initExposure(const ConfigSet& config)
 	m_exposure.m_rtDescr.bake();
 
 	// init shaders
-	ANKI_CHECK(getResourceManager().loadResource("shaders/Bloom.ankiprog", m_exposure.m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/Bloom.ankiprog", m_exposure.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_exposure.m_prog);
 	variantInitInfo.addConstant("FB_SIZE", UVec2(m_exposure.m_width, m_exposure.m_height));
@@ -62,7 +62,7 @@ Error Bloom::initUpscale(const ConfigSet& config)
 	m_upscale.m_rtDescr.bake();
 
 	// init shaders
-	ANKI_CHECK(getResourceManager().loadResource("shaders/BloomUpscale.ankiprog", m_upscale.m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/BloomUpscale.ankiprog", m_upscale.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_upscale.m_prog);
 	variantInitInfo.addConstant("FB_SIZE", UVec2(m_upscale.m_width, m_upscale.m_height));
@@ -76,7 +76,7 @@ Error Bloom::initUpscale(const ConfigSet& config)
 				&& variant->getWorkgroupSizes()[2] == m_workgroupSize[2]);
 
 	// Textures
-	ANKI_CHECK(getResourceManager().loadResource("engine_data/LensDirt.ankitex", m_upscale.m_lensDirtTex));
+	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/LensDirt.ankitex", m_upscale.m_lensDirtTex));
 
 	return Error::NONE;
 }

AnKi/Renderer/DepthDownscale.cpp

@@ -40,7 +40,7 @@ Error DepthDownscale::initInternal(const ConfigSet&)
 	m_hizTex = m_r->createAndClearRenderTarget(texInit);
 
 	// Progs
-	ANKI_CHECK(getResourceManager().loadResource("shaders/DepthDownscale.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/DepthDownscale.ankiprog", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addMutation("SAMPLE_RESOLVE_TYPE", 2);

AnKi/Renderer/DownscaleBlur.cpp

@@ -64,7 +64,7 @@ Error DownscaleBlur::initInternal(const ConfigSet&)
 	const ShaderProgramResourceVariant* variant = nullptr;
 	if(m_useCompute)
 	{
-		ANKI_CHECK(getResourceManager().loadResource("shaders/DownscaleBlurCompute.ankiprog", m_prog));
+		ANKI_CHECK(getResourceManager().loadResource("Shaders/DownscaleBlurCompute.ankiprog", m_prog));
 		m_prog->getOrCreateVariant(variant);
 		m_workgroupSize[0] = variant->getWorkgroupSizes()[0];
 		m_workgroupSize[1] = variant->getWorkgroupSizes()[1];
@@ -72,7 +72,7 @@ Error DownscaleBlur::initInternal(const ConfigSet&)
 	}
 	else
 	{
-		ANKI_CHECK(getResourceManager().loadResource("shaders/DownscaleBlur.ankiprog", m_prog));
+		ANKI_CHECK(getResourceManager().loadResource("Shaders/DownscaleBlur.ankiprog", m_prog));
 		m_prog->getOrCreateVariant(variant);
 	}
 	m_grProg = variant->getProgram();

AnKi/Renderer/FinalComposite.cpp

@@ -35,16 +35,16 @@ Error FinalComposite::initInternal(const ConfigSet& config)
 {
 	ANKI_ASSERT("Initializing PPS");
 
-	ANKI_CHECK(loadColorGradingTexture("engine_data/DefaultLut.ankitex"));
+	ANKI_CHECK(loadColorGradingTexture("EngineAssets/DefaultLut.ankitex"));
 
 	m_fbDescr.m_colorAttachmentCount = 1;
 	m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
 	m_fbDescr.bake();
 
-	ANKI_CHECK(getResourceManager().loadResource("engine_data/BlueNoiseLdrRgb64x64.ankitex", m_blueNoise));
+	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/BlueNoiseLdrRgb64x64.ankitex", m_blueNoise));
 
 	// Progs
-	ANKI_CHECK(getResourceManager().loadResource("shaders/FinalComposite.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/FinalComposite.ankiprog", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addMutation("BLUE_NOISE", 1);

AnKi/Renderer/GBufferPost.cpp

@@ -31,7 +31,7 @@ Error GBufferPost::initInternal(const ConfigSet& cfg)
 	ANKI_R_LOGI("Initializing GBufferPost pass");
 
 	// Load shaders
-	ANKI_CHECK(getResourceManager().loadResource("shaders/GBufferPost.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/GBufferPost.ankiprog", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("CLUSTER_COUNT_X", cfg.getNumberU32("r_clusterSizeX"));

AnKi/Renderer/GlobalIllumination.cpp

@@ -222,7 +222,7 @@ Error GlobalIllumination::initLightShading(const ConfigSet& cfg)
 
 Error GlobalIllumination::initIrradiance(const ConfigSet& cfg)
 {
-	ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/IrradianceDice.ankiprog", m_irradiance.m_prog));
+	ANKI_CHECK(m_r->getResourceManager().loadResource("Shaders/IrradianceDice.ankiprog", m_irradiance.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_irradiance.m_prog);
 	variantInitInfo.addMutation("WORKGROUP_SIZE_XY", m_tileSize);

AnKi/Renderer/LensFlare.cpp

@@ -53,7 +53,7 @@ Error LensFlare::initSprite(const ConfigSet& config)
 	m_maxSprites = U16(m_maxSpritesPerFlare * m_maxFlares);
 
 	// Load prog
-	ANKI_CHECK(getResourceManager().loadResource("shaders/LensFlareSprite.ankiprog", m_realProg));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/LensFlareSprite.ankiprog", m_realProg));
 	const ShaderProgramResourceVariant* variant;
 	m_realProg->getOrCreateVariant(variant);
 	m_realGrProg = variant->getProgram();
@@ -70,7 +70,7 @@ Error LensFlare::initOcclusion(const ConfigSet& config)
 												 BufferMapAccessBit::NONE, "LensFlares"));
 
 	ANKI_CHECK(
-		getResourceManager().loadResource("shaders/LensFlareUpdateIndirectInfo.ankiprog", m_updateIndirectBuffProg));
+		getResourceManager().loadResource("Shaders/LensFlareUpdateIndirectInfo.ankiprog", m_updateIndirectBuffProg));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_updateIndirectBuffProg);
 	variantInitInfo.addConstant("IN_DEPTH_MAP_SIZE", UVec2(m_r->getWidth() / 2 / 2, m_r->getHeight() / 2 / 2));

AnKi/Renderer/LightShading.cpp

@@ -54,7 +54,7 @@ Error LightShading::init(const ConfigSet& config)
 Error LightShading::initLightShading(const ConfigSet& config)
 {
 	// Load shaders and programs
-	ANKI_CHECK(getResourceManager().loadResource("shaders/LightShading.ankiprog", m_lightShading.m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/LightShading.ankiprog", m_lightShading.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_lightShading.m_prog);
 	variantInitInfo.addConstant("CLUSTER_COUNT_X", U32(m_r->getClusterCount()[0]));
@@ -91,7 +91,7 @@ Error LightShading::initLightShading(const ConfigSet& config)
 Error LightShading::initApplyFog(const ConfigSet& config)
 {
 	// Load shaders and programs
-	ANKI_CHECK(getResourceManager().loadResource("shaders/LightShadingApplyFog.ankiprog", m_applyFog.m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/LightShadingApplyFog.ankiprog", m_applyFog.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_applyFog.m_prog);
 	variantInitInfo.addConstant("FOG_LAST_CLASTER", m_r->getVolumetricFog().getFinalClusterInZ());

AnKi/Renderer/MainRenderer.cpp

@@ -56,7 +56,7 @@ Error MainRenderer::init(ThreadHive* hive, ResourceManager* resources, GrManager
 	// Init other
 	if(!m_rDrawToDefaultFb)
 	{
-		ANKI_CHECK(resources->loadResource("shaders/Blit.ankiprog", m_blitProg));
+		ANKI_CHECK(resources->loadResource("Shaders/Blit.ankiprog", m_blitProg));
 		const ShaderProgramResourceVariant* variant;
 		m_blitProg->getOrCreateVariant(variant);
 		m_blitGrProg = variant->getProgram();

AnKi/Renderer/MotionVectors.cpp

@@ -20,7 +20,7 @@ Error MotionVectors::init(const ConfigSet& config)
 	ANKI_R_LOGI("Initializing motion vectors");
 
 	// Prog
-	ANKI_CHECK(getResourceManager().loadResource("shaders/MotionVectors.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/MotionVectors.ankiprog", m_prog));
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("FB_SIZE", UVec2(m_r->getWidth(), m_r->getHeight()));
 	const ShaderProgramResourceVariant* variant;

AnKi/Renderer/ProbeReflections.cpp

@@ -53,7 +53,7 @@ Error ProbeReflections::initInternal(const ConfigSet& config)
 	ANKI_CHECK(initShadowMapping(config));
 
 	// Load split sum integration LUT
-	ANKI_CHECK(getResourceManager().loadResource("engine_data/SplitSumIntegration.ankitex", m_integrationLut));
+	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/SplitSumIntegration.ankitex", m_integrationLut));
 
 	SamplerInitInfo sinit;
 	sinit.m_minMagFilter = SamplingFilter::LINEAR;
@@ -145,7 +145,7 @@ Error ProbeReflections::initIrradiance(const ConfigSet& config)
 
 	// Create prog
 	{
-		ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/IrradianceDice.ankiprog", m_irradiance.m_prog));
+		ANKI_CHECK(m_r->getResourceManager().loadResource("Shaders/IrradianceDice.ankiprog", m_irradiance.m_prog));
 
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_irradiance.m_prog);
 
@@ -173,7 +173,7 @@ Error ProbeReflections::initIrradiance(const ConfigSet& config)
 Error ProbeReflections::initIrradianceToRefl(const ConfigSet& cfg)
 {
 	// Create program
-	ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/ApplyIrradianceToReflection.ankiprog",
+	ANKI_CHECK(m_r->getResourceManager().loadResource("Shaders/ApplyIrradianceToReflection.ankiprog",
 													  m_irradianceToRefl.m_prog));
 
 	const ShaderProgramResourceVariant* variant;

AnKi/Renderer/Renderer.cpp

@@ -122,7 +122,7 @@ Error Renderer::initInternal(const ConfigSet& config)
 	m_dummyBuff = getGrManager().newBuffer(BufferInitInfo(
 		1024, BufferUsageBit::ALL_UNIFORM | BufferUsageBit::ALL_STORAGE, BufferMapAccessBit::NONE, "Dummy"));
 
-	ANKI_CHECK(m_resources->loadResource("shaders/ClearTextureCompute.ankiprog", m_clearTexComputeProg));
+	ANKI_CHECK(m_resources->loadResource("Shaders/ClearTextureCompute.ankiprog", m_clearTexComputeProg));
 
 	// Init the stages. Careful with the order!!!!!!!!!!
 	m_genericCompute.reset(m_alloc.newInstance<GenericCompute>(this));

AnKi/Renderer/RtShadows.cpp

@@ -48,7 +48,7 @@ Error RtShadows::initInternal(const ConfigSet& cfg)
 	m_grProg = library->getShaderProgram();
 
 	// Denoise program
-	ANKI_CHECK(getResourceManager().loadResource("shaders/RtShadowsDenoise.ankiprog", m_denoiseProg));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/RtShadowsDenoise.ankiprog", m_denoiseProg));
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_denoiseProg);
 	variantInitInfo.addConstant("OUT_IMAGE_SIZE", UVec2(m_r->getWidth(), m_r->getHeight()));
 	variantInitInfo.addConstant("SAMPLE_COUNT", 8u);

AnKi/Renderer/ShadowMapping.cpp

@@ -114,7 +114,7 @@ Error ShadowMapping::initAtlas(const ConfigSet& cfg)
 
 	// Programs and shaders
 	{
-		ANKI_CHECK(getResourceManager().loadResource("shaders/ExponentialShadowmappingResolve.ankiprog",
+		ANKI_CHECK(getResourceManager().loadResource("Shaders/ExponentialShadowmappingResolve.ankiprog",
 													 m_atlas.m_resolveProg));
 
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_atlas.m_resolveProg);

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -38,7 +38,7 @@ Error ShadowmapsResolve::initInternal(const ConfigSet& cfg)
 	m_rtDescr = m_r->create2DRenderTargetDescription(width, height, Format::R8G8B8A8_UNORM, "SM_resolve");
 	m_rtDescr.bake();
 
-	ANKI_CHECK(getResourceManager().loadResource("shaders/ShadowmapsResolve.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/ShadowmapsResolve.ankiprog", m_prog));
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("CLUSTER_COUNT_X", U32(m_r->getClusterCount()[0]));
 	variantInitInfo.addConstant("CLUSTER_COUNT_Y", U32(m_r->getClusterCount()[1]));

AnKi/Renderer/Ssao.cpp

@@ -21,16 +21,16 @@ Ssao::~Ssao()
 Error Ssao::initMain(const ConfigSet& config)
 {
 	// Noise
-	ANKI_CHECK(getResourceManager().loadResource("engine_data/BlueNoiseLdrRgb64x64.ankitex", m_main.m_noiseTex));
+	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/BlueNoiseLdrRgb64x64.ankitex", m_main.m_noiseTex));
 
 	// Shader
 	if(m_useCompute)
 	{
-		ANKI_CHECK(getResourceManager().loadResource("shaders/SsaoCompute.ankiprog", m_main.m_prog));
+		ANKI_CHECK(getResourceManager().loadResource("Shaders/SsaoCompute.ankiprog", m_main.m_prog));
 	}
 	else
 	{
-		ANKI_CHECK(getResourceManager().loadResource("shaders/Ssao.ankiprog", m_main.m_prog));
+		ANKI_CHECK(getResourceManager().loadResource("Shaders/Ssao.ankiprog", m_main.m_prog));
 	}
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_main.m_prog);
@@ -56,7 +56,7 @@ Error Ssao::initBlur(const ConfigSet& config)
 	// shader
 	if(m_blurUseCompute)
 	{
-		ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/GaussianBlurCompute.ankiprog", m_blur.m_prog));
+		ANKI_CHECK(m_r->getResourceManager().loadResource("Shaders/GaussianBlurCompute.ankiprog", m_blur.m_prog));
 
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_blur.m_prog);
 		variantInitInfo.addMutation("ORIENTATION", 2);
@@ -74,7 +74,7 @@ Error Ssao::initBlur(const ConfigSet& config)
 	}
 	else
 	{
-		ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/GaussianBlur.ankiprog", m_blur.m_prog));
+		ANKI_CHECK(m_r->getResourceManager().loadResource("Shaders/GaussianBlur.ankiprog", m_blur.m_prog));
 
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_blur.m_prog);
 		variantInitInfo.addMutation("ORIENTATION", 2);

AnKi/Renderer/Ssgi.cpp

@@ -42,7 +42,7 @@ Error Ssgi::initInternal(const ConfigSet& cfg)
 	m_main.m_depthLod = min(cfg.getNumberU32("r_ssgiDepthLod"), m_r->getDepthDownscale().getMipmapCount() - 1);
 	m_main.m_firstStepPixels = 32;
 
-	ANKI_CHECK(getResourceManager().loadResource("engine_data/BlueNoiseRgb816x16.png", m_main.m_noiseTex));
+	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/BlueNoiseRgb816x16.png", m_main.m_noiseTex));
 
 	// Init main
 	{
@@ -50,7 +50,7 @@ Error Ssgi::initInternal(const ConfigSet& cfg)
 			m_r->create2DRenderTargetDescription(width / 2, height / 2, Format::B10G11R11_UFLOAT_PACK32, "SSGI_tmp");
 		m_main.m_rtDescr.bake();
 
-		ANKI_CHECK(getResourceManager().loadResource("shaders/Ssgi.ankiprog", m_main.m_prog));
+		ANKI_CHECK(getResourceManager().loadResource("Shaders/Ssgi.ankiprog", m_main.m_prog));
 
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_main.m_prog);
 
@@ -66,7 +66,7 @@ Error Ssgi::initInternal(const ConfigSet& cfg)
 
 	// Init denoise
 	{
-		ANKI_CHECK(getResourceManager().loadResource("shaders/SsgiDenoise.ankiprog", m_denoise.m_prog));
+		ANKI_CHECK(getResourceManager().loadResource("Shaders/SsgiDenoise.ankiprog", m_denoise.m_prog));
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_denoise.m_prog);
 		const ShaderProgramResourceVariant* variant;
 
@@ -90,7 +90,7 @@ Error Ssgi::initInternal(const ConfigSet& cfg)
 
 	// Init reconstruction
 	{
-		ANKI_CHECK(getResourceManager().loadResource("shaders/SsgiReconstruct.ankiprog", m_recontruction.m_prog));
+		ANKI_CHECK(getResourceManager().loadResource("Shaders/SsgiReconstruct.ankiprog", m_recontruction.m_prog));
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_recontruction.m_prog);
 		variantInitInfo.addConstant("FB_SIZE", UVec2(m_r->getWidth(), m_r->getHeight()));
 		const ShaderProgramResourceVariant* variant;

AnKi/Renderer/Ssr.cpp

@@ -38,7 +38,7 @@ Error Ssr::initInternal(const ConfigSet& cfg)
 	m_depthLod = cfg.getNumberU32("r_ssrDepthLod");
 	m_firstStepPixels = 32;
 
-	ANKI_CHECK(getResourceManager().loadResource("engine_data/BlueNoiseRgb816x16.png", m_noiseTex));
+	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/BlueNoiseRgb816x16.png", m_noiseTex));
 
 	// Create RTs
 	TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(
@@ -49,7 +49,7 @@ Error Ssr::initInternal(const ConfigSet& cfg)
 	m_rt = m_r->createAndClearRenderTarget(texinit);
 
 	// Create shader
-	ANKI_CHECK(getResourceManager().loadResource("shaders/Ssr.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/Ssr.ankiprog", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addMutation("VARIANT", 0);

AnKi/Renderer/TemporalAA.cpp

@@ -37,7 +37,7 @@ Error TemporalAA::init(const ConfigSet& config)
 
 Error TemporalAA::initInternal(const ConfigSet& config)
 {
-	ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/TemporalAAResolve.ankiprog", m_prog));
+	ANKI_CHECK(m_r->getResourceManager().loadResource("Shaders/TemporalAAResolve.ankiprog", m_prog));
 
 	for(U32 i = 0; i < 2; ++i)
 	{

AnKi/Renderer/Tonemapping.cpp

@@ -29,7 +29,7 @@ Error Tonemapping::initInternal(const ConfigSet& initializer)
 	ANKI_R_LOGI("Initializing tonemapping (input %ux%u)", width, height);
 
 	// Create program
-	ANKI_CHECK(getResourceManager().loadResource("shaders/TonemappingAverageLuminance.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/TonemappingAverageLuminance.ankiprog", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("INPUT_TEX_SIZE", UVec2(width, height));

AnKi/Renderer/TraditionalDeferredShading.cpp

@@ -25,7 +25,7 @@ Error TraditionalDeferredLightShading::init()
 {
 	// Init progs
 	{
-		ANKI_CHECK(getResourceManager().loadResource("shaders/TraditionalDeferredShading.ankiprog", m_lightProg));
+		ANKI_CHECK(getResourceManager().loadResource("Shaders/TraditionalDeferredShading.ankiprog", m_lightProg));
 
 		for(U32 specular = 0; specular <= 1; ++specular)
 		{
@@ -48,8 +48,8 @@ Error TraditionalDeferredLightShading::init()
 	}
 
 	// Init meshes
-	ANKI_CHECK(getResourceManager().loadResource("engine_data/Plight.ankimesh", m_plightMesh, false));
-	ANKI_CHECK(getResourceManager().loadResource("engine_data/Slight.ankimesh", m_slightMesh, false));
+	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/Plight.ankimesh", m_plightMesh, false));
+	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/Slight.ankimesh", m_slightMesh, false));
 
 	return Error::NONE;
 }

AnKi/Renderer/UiStage.cpp

@@ -24,7 +24,7 @@ UiStage::~UiStage()
 
 Error UiStage::init(const ConfigSet&)
 {
-	ANKI_CHECK(m_r->getUiManager().newInstance(m_font, "engine_data/UbuntuRegular.ttf",
+	ANKI_CHECK(m_r->getUiManager().newInstance(m_font, "EngineAssets/UbuntuRegular.ttf",
 											   std::initializer_list<U32>{12, 16, 20}));
 	ANKI_CHECK(m_r->getUiManager().newInstance(m_canvas, m_font, 12, m_r->getWidth(), m_r->getHeight()));
 

AnKi/Renderer/VolumetricFog.cpp

@@ -31,7 +31,7 @@ Error VolumetricFog::init(const ConfigSet& config)
 	ANKI_R_LOGI("Initializing volumetric fog. Size %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("Shaders/VolumetricFogAccumulation.ankiprog", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("VOLUME_SIZE", UVec3(m_volumeSize[0], m_volumeSize[1], m_volumeSize[2]));

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -38,10 +38,10 @@ Error VolumetricLightingAccumulation::init(const ConfigSet& config)
 	ANKI_R_LOGI("Initializing volumetric lighting accumulation. Size %ux%ux%u", m_volumeSize[0], m_volumeSize[1],
 				m_volumeSize[2]);
 
-	ANKI_CHECK(getResourceManager().loadResource("engine_data/blue_noise_rgb8_16x16x16_3d.ankitex", m_noiseTex));
+	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/BlueNoiseLdr16x16x16.ankitex", m_noiseTex));
 
 	// Shaders
-	ANKI_CHECK(getResourceManager().loadResource("shaders/VolumetricLightingAccumulation.ankiprog", m_prog));
+	ANKI_CHECK(getResourceManager().loadResource("Shaders/VolumetricLightingAccumulation.ankiprog", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addMutation("ENABLE_SHADOWS", 1);

AnKi/Scene/Components/DecalComponent.cpp

@@ -18,7 +18,7 @@ DecalComponent::DecalComponent(SceneNode* node)
 	, m_node(node)
 {
 	ANKI_ASSERT(node);
-	if(node->getSceneGraph().getResourceManager().loadResource("engine_data/GreenDecal.ankitex", m_debugTex))
+	if(node->getSceneGraph().getResourceManager().loadResource("EngineAssets/GreenDecal.ankitex", m_debugTex))
 	{
 		ANKI_SCENE_LOGF("Failed to load resources");
 	}

AnKi/Scene/Components/GlobalIlluminationProbeComponent.cpp

@@ -21,7 +21,7 @@ GlobalIlluminationProbeComponent::GlobalIlluminationProbeComponent(SceneNode* no
 	, m_markedForRendering(false)
 	, m_shapeDirty(true)
 {
-	if(node->getSceneGraph().getResourceManager().loadResource("engine_data/GiProbe.ankitex", m_debugTex))
+	if(node->getSceneGraph().getResourceManager().loadResource("EngineAssets/GiProbe.ankitex", m_debugTex))
 	{
 		ANKI_SCENE_LOGF("Failed to load resources");
 	}

AnKi/Scene/Components/GpuParticleEmitterComponent.cpp

@@ -32,8 +32,8 @@ Error GpuParticleEmitterComponent::loadParticleEmitterResource(CString filename)
 	// Create the debug drawer
 	if(!m_dbgTex.isCreated())
 	{
-		ANKI_CHECK(
-			m_node->getSceneGraph().getResourceManager().loadResource("engine_data/ParticleEmitter.ankitex", m_dbgTex));
+		ANKI_CHECK(m_node->getSceneGraph().getResourceManager().loadResource("EngineAssets/ParticleEmitter.ankitex",
+																			 m_dbgTex));
 	}
 
 	// Load particle props
@@ -43,7 +43,7 @@ Error GpuParticleEmitterComponent::loadParticleEmitterResource(CString filename)
 
 	// Create program
 	ANKI_CHECK(
-		m_node->getSceneGraph().getResourceManager().loadResource("shaders/GpuParticlesSimulation.ankiprog", m_prog));
+		m_node->getSceneGraph().getResourceManager().loadResource("Shaders/GpuParticlesSimulation.ankiprog", m_prog));
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variant);
 	m_grProg = variant->getProgram();

AnKi/Scene/Components/LightComponent.cpp

@@ -29,8 +29,8 @@ LightComponent::LightComponent(SceneNode* node)
 	ANKI_ASSERT(m_uuid > 0);
 	m_point.m_radius = 1.0f;
 
-	if(node->getSceneGraph().getResourceManager().loadResource("engine_data/LightBulb.ankitex", m_pointDebugTex)
-	   || node->getSceneGraph().getResourceManager().loadResource("engine_data/SpotLight.ankitex", m_spotDebugTex))
+	if(node->getSceneGraph().getResourceManager().loadResource("EngineAssets/LightBulb.ankitex", m_pointDebugTex)
+	   || node->getSceneGraph().getResourceManager().loadResource("EngineAssets/SpotLight.ankitex", m_spotDebugTex))
 	{
 		ANKI_SCENE_LOGF("Failed to load resources");
 	}

AnKi/Scene/Components/ParticleEmitterComponent.cpp

@@ -214,8 +214,8 @@ Error ParticleEmitterComponent::loadParticleEmitterResource(CString filename)
 	// Create the debug drawer
 	if(!m_dbgTex.isCreated())
 	{
-		ANKI_CHECK(
-			m_node->getSceneGraph().getResourceManager().loadResource("engine_data/ParticleEmitter.ankitex", m_dbgTex));
+		ANKI_CHECK(m_node->getSceneGraph().getResourceManager().loadResource("EngineAssets/ParticleEmitter.ankitex",
+																			 m_dbgTex));
 	}
 
 	// Load

AnKi/Scene/Components/ReflectionProbeComponent.cpp

@@ -21,7 +21,7 @@ ReflectionProbeComponent::ReflectionProbeComponent(SceneNode* node)
 	, m_markedForRendering(false)
 	, m_markedForUpdate(true)
 {
-	if(node->getSceneGraph().getResourceManager().loadResource("engine_data/Mirror.ankitex", m_debugTex))
+	if(node->getSceneGraph().getResourceManager().loadResource("EngineAssets/Mirror.ankitex", m_debugTex))
 	{
 		ANKI_SCENE_LOGF("Failed to load resources");
 	}

AnKi/Scene/DebugDrawer.cpp

@@ -68,7 +68,7 @@ void allocateAndPopulateDebugBox(StagingGpuMemoryManager& stagingGpuAllocator, S
 
 Error DebugDrawer2::init(ResourceManager* rsrcManager)
 {
-	ANKI_CHECK(rsrcManager->loadResource("shaders/SceneDebug.ankiprog", m_prog));
+	ANKI_CHECK(rsrcManager->loadResource("Shaders/SceneDebug.ankiprog", m_prog));
 
 	{
 		BufferInitInfo bufferInit("DebugCube");

AnKi/Ui/Canvas.cpp

@@ -37,7 +37,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("Shaders/Ui.ankiprog", m_prog));
 
 	for(U32 i = 0; i < SHADER_COUNT; ++i)
 	{

Tests/Ui/Ui.cpp

@@ -60,7 +60,7 @@ ANKI_TEST(Ui, Ui)
 	cfg.set("gr_debugContext", 0);
 	cfg.set("width", 1024);
 	cfg.set("height", 760);
-	cfg.set("rsrc_dataPaths", "engine_data");
+	cfg.set("rsrc_dataPaths", "EngineAssets");
 
 	NativeWindow* win = createWindow(cfg);
 	Input* in = new Input();