Rename the ver2 of shader program and material to its original name

src/anki/Resource.h

@@ -10,14 +10,14 @@
 #include <anki/resource/AnimationResource.h>
 #include <anki/resource/ScriptResource.h>
 #include <anki/resource/MeshResource.h>
-#include <anki/resource/MaterialResource2.h>
+#include <anki/resource/MaterialResource.h>
 #include <anki/resource/TextureAtlasResource.h>
 #include <anki/resource/TextureResource.h>
 #include <anki/resource/GenericResource.h>
 #include <anki/resource/SkeletonResource.h>
 #include <anki/resource/DummyResource.h>
 #include <anki/resource/ModelResource.h>
-#include <anki/resource/ShaderProgramResource2.h>
+#include <anki/resource/ShaderProgramResource.h>
 #include <anki/resource/CollisionResource.h>
 
 #include <anki/resource/MeshLoader.h>

src/anki/renderer/Bloom.cpp

@@ -38,10 +38,10 @@ Error Bloom::initExposure(const ConfigSet& config)
 	// init shaders
 	ANKI_CHECK(getResourceManager().loadResource("shaders/Bloom.ankiprog", m_exposure.m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_exposure.m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_exposure.m_prog);
 	variantInitInfo.addConstant("FB_SIZE", UVec2(m_exposure.m_width, m_exposure.m_height));
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_exposure.m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_exposure.m_grProg = variant->getProgram();
 	ANKI_ASSERT(variant->getWorkgroupSizes()[0] == m_workgroupSize[0]
@@ -64,11 +64,11 @@ Error Bloom::initUpscale(const ConfigSet& config)
 	// init shaders
 	ANKI_CHECK(getResourceManager().loadResource("shaders/BloomUpscale.ankiprog", m_upscale.m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_upscale.m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_upscale.m_prog);
 	variantInitInfo.addConstant("FB_SIZE", UVec2(m_upscale.m_width, m_upscale.m_height));
 	variantInitInfo.addConstant("INPUT_TEX_SIZE", UVec2(m_exposure.m_width, m_exposure.m_height));
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_upscale.m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_upscale.m_grProg = variant->getProgram();
 	ANKI_ASSERT(variant->getWorkgroupSizes()[0] == m_workgroupSize[0]

src/anki/renderer/Bloom.h

@@ -50,7 +50,7 @@ private:
 	class
 	{
 	public:
-		ShaderProgramResource2Ptr m_prog;
+		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
 
 		F32 m_threshold = 10.0; ///< How bright it is
@@ -65,7 +65,7 @@ private:
 	{
 	public:
 		TextureResourcePtr m_lensDirtTex;
-		ShaderProgramResource2Ptr m_prog;
+		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
 
 		U32 m_width = 0;

src/anki/renderer/DepthDownscale.cpp

@@ -43,10 +43,10 @@ Error DepthDownscale::initInternal(const ConfigSet&)
 	// Progs
 	ANKI_CHECK(getResourceManager().loadResource("shaders/DepthDownscale.ankiprog", m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addMutation("SAMPLE_RESOLVE_TYPE", 2);
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_grProg = variant->getProgram();
 

src/anki/renderer/DepthDownscale.h

@@ -58,7 +58,7 @@ private:
 
 	TexturePtr m_hizTex;
 	Bool m_hizTexImportedOnce = false;
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 	U32 m_mipCount = 0;
 

src/anki/renderer/DownscaleBlur.cpp

@@ -61,7 +61,7 @@ Error DownscaleBlur::initInternal(const ConfigSet&)
 	}
 
 	// Shader programs
-	const ShaderProgramResourceVariant2* variant = nullptr;
+	const ShaderProgramResourceVariant* variant = nullptr;
 	if(m_useCompute)
 	{
 		ANKI_CHECK(getResourceManager().loadResource("shaders/DownscaleBlurCompute.ankiprog", m_prog));

src/anki/renderer/DownscaleBlur.h

@@ -62,7 +62,7 @@ private:
 
 	DynamicArray<FramebufferDescription> m_fbDescrs;
 
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 
 	class

src/anki/renderer/FinalComposite.cpp

@@ -45,7 +45,7 @@ Error FinalComposite::initInternal(const ConfigSet& config)
 	// Progs
 	ANKI_CHECK(getResourceManager().loadResource("shaders/FinalComposite.ankiprog", m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addMutation("BLUE_NOISE", 1);
 	variantInitInfo.addMutation("BLOOM_ENABLED", 1);
 	variantInitInfo.addMutation("DBG_ENABLED", 0);
@@ -54,7 +54,7 @@ Error FinalComposite::initInternal(const ConfigSet& config)
 	variantInitInfo.addConstant("FB_SIZE", UVec2(m_r->getWidth(), m_r->getHeight()));
 	variantInitInfo.addConstant("MOTION_BLUR_SAMPLES", config.getNumberU32("r_motionBlurSamples"));
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_grProgs[0] = variant->getProgram();
 

src/anki/renderer/FinalComposite.h

@@ -34,7 +34,7 @@ private:
 
 	FramebufferDescription m_fbDescr;
 
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 	Array<ShaderProgramPtr, 2> m_grProgs; ///< One with Dbg and one without
 
 	TextureResourcePtr m_lut; ///< Color grading lookup texture.

src/anki/renderer/GBufferPost.cpp

@@ -33,11 +33,11 @@ Error GBufferPost::initInternal(const ConfigSet& cfg)
 	// Load shaders
 	ANKI_CHECK(getResourceManager().loadResource("shaders/GBufferPost.ankiprog", m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("CLUSTER_COUNT_X", cfg.getNumberU32("r_clusterSizeX"));
 	variantInitInfo.addConstant("CLUSTER_COUNT_Y", cfg.getNumberU32("r_clusterSizeY"));
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_grProg = variant->getProgram();
 

src/anki/renderer/GBufferPost.h

@@ -30,7 +30,7 @@ public:
 	void populateRenderGraph(RenderingContext& ctx);
 
 private:
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 
 	FramebufferDescription m_fbDescr;

src/anki/renderer/GlobalIllumination.cpp

@@ -229,13 +229,13 @@ Error GlobalIllumination::initIrradiance(const ConfigSet& cfg)
 {
 	ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/IrradianceDice.ankiprog", m_irradiance.m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_irradiance.m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_irradiance.m_prog);
 	variantInitInfo.addMutation("WORKGROUP_SIZE_XY", m_tileSize);
 	variantInitInfo.addMutation("LIGHT_SHADING_TEX", 0);
 	variantInitInfo.addMutation("STORE_LOCATION", 0);
 	variantInitInfo.addMutation("SECOND_BOUNCE", 1);
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_irradiance.m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_irradiance.m_grProg = variant->getProgram();
 

src/anki/renderer/GlobalIllumination.h

@@ -92,7 +92,7 @@ private:
 	class
 	{
 	public:
-		ShaderProgramResource2Ptr m_prog;
+		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
 	} m_irradiance; ///< Irradiance.
 

src/anki/renderer/LensFlare.cpp

@@ -54,7 +54,7 @@ Error LensFlare::initSprite(const ConfigSet& config)
 
 	// Load prog
 	ANKI_CHECK(getResourceManager().loadResource("shaders/LensFlareSprite.ankiprog", m_realProg));
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_realProg->getOrCreateVariant(variant);
 	m_realGrProg = variant->getProgram();
 
@@ -73,9 +73,9 @@ Error LensFlare::initOcclusion(const ConfigSet& config)
 	ANKI_CHECK(
 		getResourceManager().loadResource("shaders/LensFlareUpdateIndirectInfo.ankiprog", m_updateIndirectBuffProg));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_updateIndirectBuffProg);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_updateIndirectBuffProg);
 	variantInitInfo.addConstant("IN_DEPTH_MAP_SIZE", UVec2(m_r->getWidth() / 2 / 2, m_r->getHeight() / 2 / 2));
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_updateIndirectBuffProg->getOrCreateVariant(variantInitInfo, variant);
 	m_updateIndirectBuffGrProg = variant->getProgram();
 

src/anki/renderer/LensFlare.h

@@ -41,11 +41,11 @@ public:
 private:
 	// Occlusion test
 	BufferPtr m_indirectBuff;
-	ShaderProgramResource2Ptr m_updateIndirectBuffProg;
+	ShaderProgramResourcePtr m_updateIndirectBuffProg;
 	ShaderProgramPtr m_updateIndirectBuffGrProg;
 
 	// Sprite billboards
-	ShaderProgramResource2Ptr m_realProg;
+	ShaderProgramResourcePtr m_realProg;
 	ShaderProgramPtr m_realGrProg;
 	U8 m_maxSpritesPerFlare;
 	U8 m_maxFlares;

src/anki/renderer/LightShading.cpp

@@ -53,14 +53,14 @@ Error LightShading::initLightShading(const ConfigSet& config)
 	// Load shaders and programs
 	ANKI_CHECK(getResourceManager().loadResource("shaders/LightShading.ankiprog", m_lightShading.m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_lightShading.m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_lightShading.m_prog);
 	variantInitInfo.addConstant("CLUSTER_COUNT_X", U32(m_r->getClusterCount()[0]));
 	variantInitInfo.addConstant("CLUSTER_COUNT_Y", U32(m_r->getClusterCount()[1]));
 	variantInitInfo.addConstant("CLUSTER_COUNT_Z", U32(m_r->getClusterCount()[2]));
 	variantInitInfo.addConstant("CLUSTER_COUNT", U32(m_r->getClusterCount()[3]));
 	variantInitInfo.addConstant("IR_MIPMAP_COUNT", U32(m_r->getProbeReflections().getReflectionTextureMipmapCount()));
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_lightShading.m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_lightShading.m_grProg = variant->getProgram();
 
@@ -84,10 +84,10 @@ Error LightShading::initApplyFog(const ConfigSet& config)
 	// Load shaders and programs
 	ANKI_CHECK(getResourceManager().loadResource("shaders/LightShadingApplyFog.ankiprog", m_applyFog.m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_applyFog.m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_applyFog.m_prog);
 	variantInitInfo.addConstant("FOG_LAST_CLASTER", m_r->getVolumetricFog().getFinalClusterInZ());
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_applyFog.m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_applyFog.m_grProg = variant->getProgram();
 

src/anki/renderer/LightShading.h

@@ -39,14 +39,14 @@ private:
 		FramebufferDescription m_fbDescr;
 
 		// Light shaders
-		ShaderProgramResource2Ptr m_prog;
+		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
 	} m_lightShading;
 
 	class
 	{
 	public:
-		ShaderProgramResource2Ptr m_prog;
+		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
 	} m_applyFog;
 

src/anki/renderer/MainRenderer.cpp

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

src/anki/renderer/MainRenderer.h

@@ -81,7 +81,7 @@ private:
 	UniquePtr<Renderer> m_r;
 	Bool m_rDrawToDefaultFb = false;
 
-	ShaderProgramResource2Ptr m_blitProg;
+	ShaderProgramResourcePtr m_blitProg;
 	ShaderProgramPtr m_blitGrProg;
 
 	U32 m_width = 0; ///< Default FB size.

src/anki/renderer/ProbeReflections.cpp

@@ -149,14 +149,14 @@ Error ProbeReflections::initIrradiance(const ConfigSet& config)
 	{
 		ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/IrradianceDice.ankiprog", m_irradiance.m_prog));
 
-		ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_irradiance.m_prog);
+		ShaderProgramResourceVariantInitInfo variantInitInfo(m_irradiance.m_prog);
 
 		variantInitInfo.addMutation("WORKGROUP_SIZE_XY", U32(m_irradiance.m_workgroupSize));
 		variantInitInfo.addMutation("LIGHT_SHADING_TEX", 1);
 		variantInitInfo.addMutation("STORE_LOCATION", 1);
 		variantInitInfo.addMutation("SECOND_BOUNCE", 0);
 
-		const ShaderProgramResourceVariant2* variant;
+		const ShaderProgramResourceVariant* variant;
 		m_irradiance.m_prog->getOrCreateVariant(variantInitInfo, variant);
 		m_irradiance.m_grProg = variant->getProgram();
 	}
@@ -178,9 +178,9 @@ Error ProbeReflections::initIrradianceToRefl(const ConfigSet& cfg)
 	ANKI_CHECK(m_r->getResourceManager().loadResource(
 		"shaders/ApplyIrradianceToReflection.ankiprog", m_irradianceToRefl.m_prog));
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_irradianceToRefl.m_prog->getOrCreateVariant(
-		ShaderProgramResourceVariantInitInfo2(m_irradianceToRefl.m_prog), variant);
+		ShaderProgramResourceVariantInitInfo(m_irradianceToRefl.m_prog), variant);
 	m_irradianceToRefl.m_grProg = variant->getProgram();
 
 	return Error::NONE;

src/anki/renderer/ProbeReflections.h

@@ -80,7 +80,7 @@ private:
 	class
 	{
 	public:
-		ShaderProgramResource2Ptr m_prog;
+		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
 		BufferPtr m_diceValuesBuff;
 		U32 m_workgroupSize = 16;
@@ -89,7 +89,7 @@ private:
 	class
 	{
 	public:
-		ShaderProgramResource2Ptr m_prog;
+		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
 	} m_irradianceToRefl; ///< Apply irradiance back to the reflection.
 

src/anki/renderer/Renderer.cpp

@@ -497,10 +497,10 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf, cons
 				else
 				{
 					// Compute
-					ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_clearTexComputeProg);
+					ShaderProgramResourceVariantInitInfo variantInitInfo(m_clearTexComputeProg);
 					variantInitInfo.addMutation("IS_2D", I32((inf.m_type != TextureType::_3D) ? 1 : 0));
 
-					const ShaderProgramResourceVariant2* variant;
+					const ShaderProgramResourceVariant* variant;
 					m_clearTexComputeProg->getOrCreateVariant(variantInitInfo, variant);
 
 					cmdb->bindShaderProgram(variant->getProgram());

src/anki/renderer/Renderer.h

@@ -421,7 +421,7 @@ private:
 
 	RendererPrecreatedSamplers m_samplers;
 
-	ShaderProgramResource2Ptr m_clearTexComputeProg;
+	ShaderProgramResourcePtr m_clearTexComputeProg;
 
 	RendererStats m_stats;
 	Bool m_statsEnabled = false;

src/anki/renderer/RendererObject.h

@@ -9,7 +9,7 @@
 #include <anki/util/StdTypes.h>
 #include <anki/Gr.h>
 #include <anki/resource/ResourceManager.h>
-#include <anki/resource/ShaderProgramResource2.h>
+#include <anki/resource/ShaderProgramResource.h>
 #include <anki/core/StagingGpuMemoryManager.h>
 
 namespace anki

src/anki/renderer/ShadowMapping.cpp

@@ -118,12 +118,12 @@ Error ShadowMapping::initAtlas(const ConfigSet& cfg)
 		ANKI_CHECK(getResourceManager().loadResource(
 			"shaders/ExponentialShadowmappingResolve.ankiprog", m_atlas.m_resolveProg));
 
-		ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_atlas.m_resolveProg);
+		ShaderProgramResourceVariantInitInfo variantInitInfo(m_atlas.m_resolveProg);
 		variantInitInfo.addConstant("INPUT_TEXTURE_SIZE",
 			UVec2(m_scratch.m_tileCountX * m_scratch.m_tileResolution,
 				m_scratch.m_tileCountY * m_scratch.m_tileResolution));
 
-		const ShaderProgramResourceVariant2* variant;
+		const ShaderProgramResourceVariant* variant;
 		m_atlas.m_resolveProg->getOrCreateVariant(variantInitInfo, variant);
 		m_atlas.m_resolveGrProg = variant->getProgram();
 	}

src/anki/renderer/ShadowMapping.h

@@ -56,7 +56,7 @@ private:
 		U32 m_tileResolution = 0; ///< Tile resolution.
 		U32 m_tileCountBothAxis = 0;
 
-		ShaderProgramResource2Ptr m_resolveProg;
+		ShaderProgramResourcePtr m_resolveProg;
 		ShaderProgramPtr m_resolveGrProg;
 
 		WeakArray<ResolveWorkItem> m_resolveWorkItems;

src/anki/renderer/Ssao.cpp

@@ -33,7 +33,7 @@ Error Ssao::initMain(const ConfigSet& config)
 		ANKI_CHECK(getResourceManager().loadResource("shaders/Ssao.ankiprog", m_main.m_prog));
 	}
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_main.m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_main.m_prog);
 	variantInitInfo.addMutation("USE_NORMAL", (m_useNormal) ? 1u : 0u);
 	variantInitInfo.addMutation("SOFT_BLUR", (m_useSoftBlur) ? 1u : 0u);
 	variantInitInfo.addConstant("NOISE_MAP_SIZE", U32(m_main.m_noiseTex->getWidth()));
@@ -42,7 +42,7 @@ Error Ssao::initMain(const ConfigSet& config)
 	variantInitInfo.addConstant("BIAS", 0.0f);
 	variantInitInfo.addConstant("STRENGTH", 2.5f);
 	variantInitInfo.addConstant("SAMPLE_COUNT", 8u);
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_main.m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_main.m_workgroupSize[0] = variant->getWorkgroupSizes()[0];
 	m_main.m_workgroupSize[1] = variant->getWorkgroupSizes()[1];
@@ -58,13 +58,13 @@ Error Ssao::initBlur(const ConfigSet& config)
 	{
 		ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/GaussianBlurCompute.ankiprog", m_blur.m_prog));
 
-		ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_blur.m_prog);
+		ShaderProgramResourceVariantInitInfo variantInitInfo(m_blur.m_prog);
 		variantInitInfo.addMutation("ORIENTATION", 2);
 		variantInitInfo.addMutation("KERNEL_SIZE", 3);
 		variantInitInfo.addMutation("COLOR_COMPONENTS", 1);
 		variantInitInfo.addConstant("TEXTURE_SIZE", UVec2(m_width, m_height));
 
-		const ShaderProgramResourceVariant2* variant;
+		const ShaderProgramResourceVariant* variant;
 		m_blur.m_prog->getOrCreateVariant(variantInitInfo, variant);
 
 		m_blur.m_workgroupSize[0] = variant->getWorkgroupSizes()[0];
@@ -76,13 +76,13 @@ Error Ssao::initBlur(const ConfigSet& config)
 	{
 		ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/GaussianBlur.ankiprog", m_blur.m_prog));
 
-		ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_blur.m_prog);
+		ShaderProgramResourceVariantInitInfo variantInitInfo(m_blur.m_prog);
 		variantInitInfo.addMutation("ORIENTATION", 2);
 		variantInitInfo.addMutation("KERNEL_SIZE", 3);
 		variantInitInfo.addMutation("COLOR_COMPONENTS", 1);
 		variantInitInfo.addConstant("TEXTURE_SIZE", UVec2(m_width, m_height));
 
-		const ShaderProgramResourceVariant2* variant;
+		const ShaderProgramResourceVariant* variant;
 		m_blur.m_prog->getOrCreateVariant(variantInitInfo, variant);
 
 		m_blur.m_grProg = variant->getProgram();

src/anki/renderer/Ssao.h

@@ -48,7 +48,7 @@ private:
 	class
 	{
 	public:
-		ShaderProgramResource2Ptr m_prog;
+		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
 		TextureResourcePtr m_noiseTex;
 		Array<U32, 2> m_workgroupSize = {};
@@ -57,7 +57,7 @@ private:
 	class
 	{
 	public:
-		ShaderProgramResource2Ptr m_prog;
+		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
 		Array<U32, 2> m_workgroupSize = {};
 	} m_blur; ///< Box blur.

src/anki/renderer/Ssr.cpp

@@ -47,14 +47,14 @@ Error Ssr::initInternal(const ConfigSet& cfg)
 	// Create shader
 	ANKI_CHECK(getResourceManager().loadResource("shaders/Ssr.ankiprog", m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("FB_SIZE", UVec2(width, height));
 	variantInitInfo.addConstant("MAX_STEPS", cfg.getNumberU32("r_ssrMaxSteps"));
 	variantInitInfo.addConstant("LIGHT_BUFFER_MIP_COUNT", m_r->getDownscaleBlur().getMipmapCount());
 	variantInitInfo.addConstant("HISTORY_COLOR_BLEND_FACTOR", cfg.getNumberF32("r_ssrHistoryBlendFactor"));
 	variantInitInfo.addMutation("VARIANT", 0);
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_grProg[0] = variant->getProgram();
 	m_workgroupSize[0] = variant->getWorkgroupSizes()[0];

src/anki/renderer/Ssr.h

@@ -35,7 +35,7 @@ public:
 	}
 
 private:
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 	Array<ShaderProgramPtr, 2> m_grProg;
 
 	TexturePtr m_rt;

src/anki/renderer/TemporalAA.cpp

@@ -40,7 +40,7 @@ Error TemporalAA::initInternal(const ConfigSet& config)
 
 	for(U32 i = 0; i < 2; ++i)
 	{
-		ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+		ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 		variantInitInfo.addConstant("VARIANCE_CLIPPING_GAMMA", 1.7f);
 		variantInitInfo.addConstant("BLEND_FACTOR", 1.0f / 16.0f);
 		variantInitInfo.addConstant("FB_SIZE", UVec2(m_r->getWidth(), m_r->getHeight()));
@@ -49,7 +49,7 @@ Error TemporalAA::initInternal(const ConfigSet& config)
 		variantInitInfo.addMutation("TONEMAP_FIX", 1);
 		variantInitInfo.addMutation("YCBCR", 0);
 
-		const ShaderProgramResourceVariant2* variant;
+		const ShaderProgramResourceVariant* variant;
 		m_prog->getOrCreateVariant(variantInitInfo, variant);
 		m_grProgs[i] = variant->getProgram();
 

src/anki/renderer/TemporalAA.h

@@ -33,7 +33,7 @@ public:
 private:
 	Array<TexturePtr, 2> m_rtTextures;
 
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 	Array<ShaderProgramPtr, 2> m_grProgs;
 
 	Array<U32, 2> m_workgroupSize = {};

src/anki/renderer/Tonemapping.cpp

@@ -31,10 +31,10 @@ Error Tonemapping::initInternal(const ConfigSet& initializer)
 	// Create program
 	ANKI_CHECK(getResourceManager().loadResource("shaders/TonemappingAverageLuminance.ankiprog", m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("INPUT_TEX_SIZE", UVec2(width, height));
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_grProg = variant->getProgram();
 

src/anki/renderer/Tonemapping.h

@@ -35,7 +35,7 @@ public:
 	}
 
 private:
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 	U32 m_inputTexMip;
 

src/anki/renderer/TraditionalDeferredShading.cpp

@@ -29,11 +29,11 @@ Error TraditionalDeferredLightShading::init()
 
 		for(U32 specular = 0; specular <= 1; ++specular)
 		{
-			ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_lightProg);
+			ShaderProgramResourceVariantInitInfo variantInitInfo(m_lightProg);
 			variantInitInfo.addMutation("LIGHT_TYPE", 0);
 			variantInitInfo.addMutation("SPECULAR", specular);
 
-			const ShaderProgramResourceVariant2* variant;
+			const ShaderProgramResourceVariant* variant;
 			m_lightProg->getOrCreateVariant(variantInitInfo, variant);
 			m_plightGrProg[specular] = variant->getProgram();
 

src/anki/renderer/TraditionalDeferredShading.h

@@ -49,7 +49,7 @@ public:
 	void drawLights(TraditionalDeferredLightShadingDrawInfo& info);
 
 private:
-	ShaderProgramResource2Ptr m_lightProg;
+	ShaderProgramResourcePtr m_lightProg;
 	Array<ShaderProgramPtr, 2> m_plightGrProg;
 	Array<ShaderProgramPtr, 2> m_slightGrProg;
 	Array<ShaderProgramPtr, 2> m_dirLightGrProg;

src/anki/renderer/VolumetricFog.cpp

@@ -33,11 +33,11 @@ Error VolumetricFog::init(const ConfigSet& config)
 	// Shaders
 	ANKI_CHECK(getResourceManager().loadResource("shaders/VolumetricFogAccumulation.ankiprog", m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("VOLUME_SIZE", UVec3(m_volumeSize[0], m_volumeSize[1], m_volumeSize[2]));
 	variantInitInfo.addConstant("FINAL_CLUSTER_Z", m_finalClusterZ);
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_grProg = variant->getProgram();
 	m_workgroupSize[0] = variant->getWorkgroupSizes()[0];

src/anki/renderer/VolumetricFog.h

@@ -68,7 +68,7 @@ public:
 	}
 
 private:
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 
 	RenderTargetDescription m_rtDescr;

src/anki/renderer/VolumetricLightingAccumulation.cpp

@@ -45,7 +45,7 @@ Error VolumetricLightingAccumulation::init(const ConfigSet& config)
 	// Shaders
 	ANKI_CHECK(getResourceManager().loadResource("shaders/VolumetricLightingAccumulation.ankiprog", m_prog));
 
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addMutation("ENABLE_SHADOWS", 1);
 	variantInitInfo.addConstant("VOLUME_SIZE", UVec3(m_volumeSize[0], m_volumeSize[1], m_volumeSize[2]));
 	variantInitInfo.addConstant(
@@ -55,7 +55,7 @@ Error VolumetricLightingAccumulation::init(const ConfigSet& config)
 	variantInitInfo.addConstant(
 		"NOISE_TEX_SIZE", UVec3(m_noiseTex->getWidth(), m_noiseTex->getHeight(), m_noiseTex->getDepth()));
 
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_grProg = variant->getProgram();
 	m_workgroupSize = variant->getWorkgroupSizes();

src/anki/renderer/VolumetricLightingAccumulation.h

@@ -37,7 +37,7 @@ public:
 	}
 
 private:
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 
 	Array<TexturePtr, 2> m_rtTextures;

src/anki/resource/InstantiationMacros.h

@@ -27,6 +27,6 @@ ANKI_INSTANTIATE_RESOURCE(GenericResource, GenericResourcePtr)
 ANKI_INSTANSIATE_RESOURCE_DELIMITER()
 ANKI_INSTANTIATE_RESOURCE(TextureAtlasResource, TextureAtlasResourcePtr)
 ANKI_INSTANSIATE_RESOURCE_DELIMITER()
-ANKI_INSTANTIATE_RESOURCE(ShaderProgramResource2, ShaderProgramResource2Ptr)
+ANKI_INSTANTIATE_RESOURCE(ShaderProgramResource, ShaderProgramResourcePtr)
 ANKI_INSTANSIATE_RESOURCE_DELIMITER()
-ANKI_INSTANTIATE_RESOURCE(MaterialResource2, MaterialResource2Ptr)
+ANKI_INSTANTIATE_RESOURCE(MaterialResource, MaterialResourcePtr)

src/anki/resource/MaterialResource2.cpp → src/anki/resource/MaterialResource.cpp

@@ -3,7 +3,7 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include <anki/resource/MaterialResource2.h>
+#include <anki/resource/MaterialResource.h>
 #include <anki/resource/ResourceManager.h>
 #include <anki/resource/TextureResource.h>
 #include <anki/util/Xml.h>
@@ -11,7 +11,7 @@
 namespace anki
 {
 
-static const Array<CString, U32(BuiltinMutatorId2::COUNT)> BUILTIN_MUTATOR_NAMES = {
+static const Array<CString, U32(BuiltinMutatorId::COUNT)> BUILTIN_MUTATOR_NAMES = {
 	{"NONE", "ANKI_INSTANCE_COUNT", "ANKI_PASS", "ANKI_LOD", "ANKI_BONES", "ANKI_VELOCITY"}};
 
 class BuiltinVarInfo
@@ -22,7 +22,7 @@ public:
 	Bool m_instanced;
 };
 
-static const Array<BuiltinVarInfo, U(BuiltinMaterialVariableId2::COUNT)> BUILTIN_INFOS = {
+static const Array<BuiltinVarInfo, U(BuiltinMaterialVariableId::COUNT)> BUILTIN_INFOS = {
 	{{"NONE", ShaderVariableDataType::NONE, false},
 		{"m_ankiMvp", ShaderVariableDataType::MAT4, true},
 		{"m_ankiPreviousMvp", ShaderVariableDataType::MAT4, true},
@@ -38,13 +38,13 @@ static const Array<BuiltinVarInfo, U(BuiltinMaterialVariableId2::COUNT)> BUILTIN
 		{"u_ankiGlobalSampler", ShaderVariableDataType::SAMPLER, false}}};
 
 static ANKI_USE_RESULT Error checkBuiltin(
-	CString name, ShaderVariableDataType dataType, Bool instanced, BuiltinMaterialVariableId2& outId)
+	CString name, ShaderVariableDataType dataType, Bool instanced, BuiltinMaterialVariableId& outId)
 {
-	outId = BuiltinMaterialVariableId2::NONE;
+	outId = BuiltinMaterialVariableId::NONE;
 
-	for(BuiltinMaterialVariableId2 id : EnumIterable<BuiltinMaterialVariableId2>())
+	for(BuiltinMaterialVariableId id : EnumIterable<BuiltinMaterialVariableId>())
 	{
-		if(id == BuiltinMaterialVariableId2::NONE)
+		if(id == BuiltinMaterialVariableId::NONE)
 		{
 			continue;
 		}
@@ -71,7 +71,7 @@ static ANKI_USE_RESULT Error checkBuiltin(
 		}
 	}
 
-	if(outId == BuiltinMaterialVariableId2::NONE && (name.find("m_anki") == 0 || name.find("u_anki") == 0))
+	if(outId == BuiltinMaterialVariableId::NONE && (name.find("m_anki") == 0 || name.find("u_anki") == 0))
 	{
 		ANKI_RESOURCE_LOGE("Unknown builtin var: %s", name.cstr());
 		return Error::USER_DATA;
@@ -80,22 +80,22 @@ static ANKI_USE_RESULT Error checkBuiltin(
 	return Error::NONE;
 }
 
-MaterialVariable2::MaterialVariable2()
+MaterialVariable::MaterialVariable()
 {
 	m_mat4 = Mat4::getZero();
 	m_mat4(3, 3) = NO_VALUE; // Add a random value
 }
 
-MaterialVariable2::~MaterialVariable2()
+MaterialVariable::~MaterialVariable()
 {
 }
 
-MaterialResource2::MaterialResource2(ResourceManager* manager)
+MaterialResource::MaterialResource(ResourceManager* manager)
 	: ResourceObject(manager)
 {
 }
 
-MaterialResource2::~MaterialResource2()
+MaterialResource::~MaterialResource()
 {
 	for(Pass p : EnumIterable<Pass>())
 	{
@@ -107,7 +107,7 @@ MaterialResource2::~MaterialResource2()
 				{
 					for(U32 vel = 0; vel <= 1; ++vel)
 					{
-						MaterialVariant2& variant = m_variantMatrix[p][l][inst][skinned][vel];
+						MaterialVariant& variant = m_variantMatrix[p][l][inst][skinned][vel];
 						variant.m_blockInfos.destroy(getAllocator());
 						variant.m_opaqueBindings.destroy(getAllocator());
 					}
@@ -116,7 +116,7 @@ MaterialResource2::~MaterialResource2()
 		}
 	}
 
-	for(MaterialVariable2& var : m_vars)
+	for(MaterialVariable& var : m_vars)
 	{
 		var.m_name.destroy(getAllocator());
 	}
@@ -125,7 +125,7 @@ MaterialResource2::~MaterialResource2()
 	m_nonBuiltinsMutation.destroy(getAllocator());
 }
 
-Error MaterialResource2::load(const ResourceFilename& filename, Bool async)
+Error MaterialResource::load(const ResourceFilename& filename, Bool async)
 {
 	XmlDocument doc;
 	XmlElement el;
@@ -173,7 +173,7 @@ Error MaterialResource2::load(const ResourceFilename& filename, Bool async)
 	return Error::NONE;
 }
 
-Error MaterialResource2::parseMutators(XmlElement mutatorsEl)
+Error MaterialResource::parseMutators(XmlElement mutatorsEl)
 {
 	XmlElement mutatorEl;
 	ANKI_CHECK(mutatorsEl.getChildElement("mutator", mutatorEl));
@@ -201,9 +201,9 @@ Error MaterialResource2::parseMutators(XmlElement mutatorsEl)
 			return Error::USER_DATA;
 		}
 
-		for(BuiltinMutatorId2 id : EnumIterable<BuiltinMutatorId2>())
+		for(BuiltinMutatorId id : EnumIterable<BuiltinMutatorId>())
 		{
-			if(id == BuiltinMutatorId2::NONE)
+			if(id == BuiltinMutatorId::NONE)
 			{
 				continue;
 			}
@@ -249,29 +249,29 @@ Error MaterialResource2::parseMutators(XmlElement mutatorsEl)
 	return Error::NONE;
 }
 
-Error MaterialResource2::findBuiltinMutators()
+Error MaterialResource::findBuiltinMutators()
 {
 	// INSTANCE_COUNT
 	U builtinMutatorCount = 0;
 
-	m_builtinMutators[BuiltinMutatorId2::INSTANCE_COUNT] =
-		m_prog->tryFindMutator(BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::INSTANCE_COUNT]);
-	if(m_builtinMutators[BuiltinMutatorId2::INSTANCE_COUNT])
+	m_builtinMutators[BuiltinMutatorId::INSTANCE_COUNT] =
+		m_prog->tryFindMutator(BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::INSTANCE_COUNT]);
+	if(m_builtinMutators[BuiltinMutatorId::INSTANCE_COUNT])
 	{
-		if(m_builtinMutators[BuiltinMutatorId2::INSTANCE_COUNT]->m_values.getSize() != MAX_INSTANCE_GROUPS)
+		if(m_builtinMutators[BuiltinMutatorId::INSTANCE_COUNT]->m_values.getSize() != MAX_INSTANCE_GROUPS)
 		{
 			ANKI_RESOURCE_LOGE("Mutator %s should have %u values in the program",
-				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::INSTANCE_COUNT].cstr(),
+				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::INSTANCE_COUNT].cstr(),
 				MAX_INSTANCE_GROUPS);
 			return Error::USER_DATA;
 		}
 
 		for(U32 i = 0; i < MAX_INSTANCE_GROUPS; ++i)
 		{
-			if(m_builtinMutators[BuiltinMutatorId2::INSTANCE_COUNT]->m_values[i] != (1 << i))
+			if(m_builtinMutators[BuiltinMutatorId::INSTANCE_COUNT]->m_values[i] != (1 << i))
 			{
 				ANKI_RESOURCE_LOGE("Values of the %s mutator in the program are not the expected",
-					BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::INSTANCE_COUNT].cstr());
+					BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::INSTANCE_COUNT].cstr());
 				return Error::USER_DATA;
 			}
 		}
@@ -280,26 +280,26 @@ Error MaterialResource2::findBuiltinMutators()
 	}
 
 	// PASS
-	m_builtinMutators[BuiltinMutatorId2::PASS] = m_prog->tryFindMutator(BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::PASS]);
-	if(m_builtinMutators[BuiltinMutatorId2::PASS] && m_forwardShading)
+	m_builtinMutators[BuiltinMutatorId::PASS] = m_prog->tryFindMutator(BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::PASS]);
+	if(m_builtinMutators[BuiltinMutatorId::PASS] && m_forwardShading)
 	{
 		ANKI_RESOURCE_LOGE(
-			"Mutator is not required for forward shading: %s", BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::PASS].cstr());
+			"Mutator is not required for forward shading: %s", BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::PASS].cstr());
 		return Error::USER_DATA;
 	}
-	else if(!m_builtinMutators[BuiltinMutatorId2::PASS] && !m_forwardShading)
+	else if(!m_builtinMutators[BuiltinMutatorId::PASS] && !m_forwardShading)
 	{
 		ANKI_RESOURCE_LOGE(
-			"Mutator is required for opaque shading: %s", BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::PASS].cstr());
+			"Mutator is required for opaque shading: %s", BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::PASS].cstr());
 		return Error::USER_DATA;
 	}
 
-	if(m_builtinMutators[BuiltinMutatorId2::PASS])
+	if(m_builtinMutators[BuiltinMutatorId::PASS])
 	{
-		if(m_builtinMutators[BuiltinMutatorId2::PASS]->m_values.getSize() != U32(Pass::COUNT) - 1)
+		if(m_builtinMutators[BuiltinMutatorId::PASS]->m_values.getSize() != U32(Pass::COUNT) - 1)
 		{
 			ANKI_RESOURCE_LOGE("Mutator %s should have %u values in the program",
-				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::PASS].cstr(),
+				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::PASS].cstr(),
 				U32(Pass::COUNT) - 1);
 			return Error::USER_DATA;
 		}
@@ -312,10 +312,10 @@ Error MaterialResource2::findBuiltinMutators()
 				continue;
 			}
 
-			if(m_builtinMutators[BuiltinMutatorId2::PASS]->m_values[count++] != I(p))
+			if(m_builtinMutators[BuiltinMutatorId::PASS]->m_values[count++] != I(p))
 			{
 				ANKI_RESOURCE_LOGE("Values of the %s mutator in the program are not the expected",
-					BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::PASS].cstr());
+					BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::PASS].cstr());
 				return Error::USER_DATA;
 			}
 		}
@@ -323,56 +323,55 @@ Error MaterialResource2::findBuiltinMutators()
 		++builtinMutatorCount;
 	}
 
-	if(!m_forwardShading && !m_builtinMutators[BuiltinMutatorId2::PASS])
+	if(!m_forwardShading && !m_builtinMutators[BuiltinMutatorId::PASS])
 	{
-		ANKI_RESOURCE_LOGE("%s mutator is required", BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::PASS].cstr());
+		ANKI_RESOURCE_LOGE("%s mutator is required", BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::PASS].cstr());
 		return Error::USER_DATA;
 	}
 
 	// LOD
-	m_builtinMutators[BuiltinMutatorId2::LOD] = m_prog->tryFindMutator(BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::LOD]);
-	if(m_builtinMutators[BuiltinMutatorId2::LOD])
+	m_builtinMutators[BuiltinMutatorId::LOD] = m_prog->tryFindMutator(BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::LOD]);
+	if(m_builtinMutators[BuiltinMutatorId::LOD])
 	{
-		if(m_builtinMutators[BuiltinMutatorId2::LOD]->m_values.getSize() > MAX_LOD_COUNT)
+		if(m_builtinMutators[BuiltinMutatorId::LOD]->m_values.getSize() > MAX_LOD_COUNT)
 		{
 			ANKI_RESOURCE_LOGE("Mutator %s should have at least %u values in the program",
-				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::LOD].cstr(),
+				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::LOD].cstr(),
 				U32(MAX_LOD_COUNT));
 			return Error::USER_DATA;
 		}
 
-		for(U32 i = 0; i < m_builtinMutators[BuiltinMutatorId2::LOD]->m_values.getSize(); ++i)
+		for(U32 i = 0; i < m_builtinMutators[BuiltinMutatorId::LOD]->m_values.getSize(); ++i)
 		{
-			if(m_builtinMutators[BuiltinMutatorId2::LOD]->m_values[i] != I(i))
+			if(m_builtinMutators[BuiltinMutatorId::LOD]->m_values[i] != I(i))
 			{
 				ANKI_RESOURCE_LOGE("Values of the %s mutator in the program are not the expected",
-					BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::LOD].cstr());
+					BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::LOD].cstr());
 				return Error::USER_DATA;
 			}
 		}
 
-		m_lodCount = U8(m_builtinMutators[BuiltinMutatorId2::LOD]->m_values.getSize());
+		m_lodCount = U8(m_builtinMutators[BuiltinMutatorId::LOD]->m_values.getSize());
 		++builtinMutatorCount;
 	}
 
 	// BONES
-	m_builtinMutators[BuiltinMutatorId2::BONES] =
-		m_prog->tryFindMutator(BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::BONES]);
-	if(m_builtinMutators[BuiltinMutatorId2::BONES])
+	m_builtinMutators[BuiltinMutatorId::BONES] = m_prog->tryFindMutator(BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::BONES]);
+	if(m_builtinMutators[BuiltinMutatorId::BONES])
 	{
-		if(m_builtinMutators[BuiltinMutatorId2::BONES]->m_values.getSize() != 2)
+		if(m_builtinMutators[BuiltinMutatorId::BONES]->m_values.getSize() != 2)
 		{
 			ANKI_RESOURCE_LOGE("Mutator %s should have 2 values in the program",
-				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::BONES].cstr());
+				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::BONES].cstr());
 			return Error::USER_DATA;
 		}
 
-		for(U32 i = 0; i < m_builtinMutators[BuiltinMutatorId2::BONES]->m_values.getSize(); ++i)
+		for(U32 i = 0; i < m_builtinMutators[BuiltinMutatorId::BONES]->m_values.getSize(); ++i)
 		{
-			if(m_builtinMutators[BuiltinMutatorId2::BONES]->m_values[i] != I(i))
+			if(m_builtinMutators[BuiltinMutatorId::BONES]->m_values[i] != I(i))
 			{
 				ANKI_RESOURCE_LOGE("Values of the %s mutator in the program are not the expected",
-					BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::BONES].cstr());
+					BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::BONES].cstr());
 				return Error::USER_DATA;
 			}
 		}
@@ -399,29 +398,29 @@ Error MaterialResource2::findBuiltinMutators()
 		if(m_boneTrfsBinding == MAX_U32)
 		{
 			ANKI_RESOURCE_LOGE("The program is using the %s mutator but b_ankiBoneTransforms was not found",
-				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::BONES].cstr());
+				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::BONES].cstr());
 			return Error::NONE;
 		}
 	}
 
 	// VELOCITY
-	m_builtinMutators[BuiltinMutatorId2::VELOCITY] =
-		m_prog->tryFindMutator(BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::VELOCITY]);
-	if(m_builtinMutators[BuiltinMutatorId2::VELOCITY])
+	m_builtinMutators[BuiltinMutatorId::VELOCITY] =
+		m_prog->tryFindMutator(BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::VELOCITY]);
+	if(m_builtinMutators[BuiltinMutatorId::VELOCITY])
 	{
-		if(m_builtinMutators[BuiltinMutatorId2::VELOCITY]->m_values.getSize() != 2)
+		if(m_builtinMutators[BuiltinMutatorId::VELOCITY]->m_values.getSize() != 2)
 		{
 			ANKI_RESOURCE_LOGE("Mutator %s should have 2 values in the program",
-				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::VELOCITY].cstr());
+				BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::VELOCITY].cstr());
 			return Error::USER_DATA;
 		}
 
-		for(U32 i = 0; i < m_builtinMutators[BuiltinMutatorId2::VELOCITY]->m_values.getSize(); ++i)
+		for(U32 i = 0; i < m_builtinMutators[BuiltinMutatorId::VELOCITY]->m_values.getSize(); ++i)
 		{
-			if(m_builtinMutators[BuiltinMutatorId2::VELOCITY]->m_values[i] != I(i))
+			if(m_builtinMutators[BuiltinMutatorId::VELOCITY]->m_values[i] != I(i))
 			{
 				ANKI_RESOURCE_LOGE("Values of the %s mutator in the program are not the expected",
-					BUILTIN_MUTATOR_NAMES[BuiltinMutatorId2::VELOCITY].cstr());
+					BUILTIN_MUTATOR_NAMES[BuiltinMutatorId::VELOCITY].cstr());
 				return Error::USER_DATA;
 			}
 		}
@@ -438,7 +437,7 @@ Error MaterialResource2::findBuiltinMutators()
 	return Error::NONE;
 }
 
-Error MaterialResource2::parseVariable(CString fullVarName, Bool& instanced, U32& idx, CString& name)
+Error MaterialResource::parseVariable(CString fullVarName, Bool& instanced, U32& idx, CString& name)
 {
 	idx = 0;
 
@@ -506,7 +505,7 @@ Error MaterialResource2::parseVariable(CString fullVarName, Bool& instanced, U32
 	return Error::NONE;
 }
 
-Error MaterialResource2::createVars()
+Error MaterialResource::createVars()
 {
 	const ShaderProgramBinary& binary = m_prog->getBinary();
 
@@ -545,7 +544,7 @@ Error MaterialResource2::createVars()
 				if(idx == 1)
 				{
 					// Find the idx==0
-					MaterialVariable2* other = tryFindVariable(name);
+					MaterialVariable* other = tryFindVariable(name);
 					ANKI_ASSERT(other);
 					ANKI_ASSERT(other->m_indexInBinary2ndElement == MAX_U32);
 					other->m_indexInBinary2ndElement = U32(&var - block.m_variables.getBegin());
@@ -555,14 +554,14 @@ Error MaterialResource2::createVars()
 				continue;
 			}
 
-			const MaterialVariable2* other = tryFindVariable(name);
+			const MaterialVariable* other = tryFindVariable(name);
 			if(other)
 			{
 				ANKI_RESOURCE_LOGE("Variable found twice: %s", name.cstr());
 				return Error::USER_DATA;
 			}
 
-			MaterialVariable2& in = *m_vars.emplaceBack(getAllocator());
+			MaterialVariable& in = *m_vars.emplaceBack(getAllocator());
 			in.m_name.create(getAllocator(), name);
 			in.m_index = m_vars.getSize() - 1;
 			in.m_indexInBinary = U32(&var - block.m_variables.getBegin());
@@ -591,7 +590,7 @@ Error MaterialResource2::createVars()
 			continue;
 		}
 
-		MaterialVariable2& in = *m_vars.emplaceBack(getAllocator());
+		MaterialVariable& in = *m_vars.emplaceBack(getAllocator());
 		in.m_name.create(getAllocator(), o.m_name.getBegin());
 		in.m_index = m_vars.getSize() - 1;
 		in.m_indexInBinary = U32(&o - binary.m_opaques.getBegin());
@@ -612,9 +611,9 @@ Error MaterialResource2::createVars()
 	m_descriptorSetIdx = U8(descriptorSet);
 
 	// Consts
-	for(const ShaderProgramResourceConstant2& c : m_prog->getConstants())
+	for(const ShaderProgramResourceConstant& c : m_prog->getConstants())
 	{
-		MaterialVariable2& in = *m_vars.emplaceBack(getAllocator());
+		MaterialVariable& in = *m_vars.emplaceBack(getAllocator());
 		in.m_name.create(getAllocator(), c.m_name);
 		in.m_index = m_vars.getSize() - 1;
 		in.m_constant = true;
@@ -625,7 +624,7 @@ Error MaterialResource2::createVars()
 	return Error::NONE;
 }
 
-Error MaterialResource2::parseInputs(XmlElement inputsEl, Bool async)
+Error MaterialResource::parseInputs(XmlElement inputsEl, Bool async)
 {
 	// Connect the input variables
 	XmlElement inputEl;
@@ -637,7 +636,7 @@ Error MaterialResource2::parseInputs(XmlElement inputsEl, Bool async)
 		ANKI_CHECK(inputEl.getAttributeText("shaderVar", varName));
 
 		// Try find var
-		MaterialVariable2* foundVar = tryFindVariable(varName);
+		MaterialVariable* foundVar = tryFindVariable(varName);
 
 		if(foundVar == nullptr)
 		{
@@ -645,7 +644,7 @@ Error MaterialResource2::parseInputs(XmlElement inputsEl, Bool async)
 			return Error::USER_DATA;
 		}
 
-		if(foundVar->m_builtin != BuiltinMaterialVariableId2::NONE)
+		if(foundVar->m_builtin != BuiltinMaterialVariableId::NONE)
 		{
 			ANKI_RESOURCE_LOGE("Shouldn't list builtin vars: %s", varName.cstr());
 			return Error::USER_DATA;
@@ -780,7 +779,7 @@ Error MaterialResource2::parseInputs(XmlElement inputsEl, Bool async)
 	return Error::NONE;
 }
 
-const MaterialVariant2& MaterialResource2::getOrCreateVariant(const RenderingKey& key_) const
+const MaterialVariant& MaterialResource::getOrCreateVariant(const RenderingKey& key_) const
 {
 	RenderingKey key = key_;
 	key.setLod(min<U32>(m_lodCount - 1, key.getLod()));
@@ -790,13 +789,13 @@ const MaterialVariant2& MaterialResource2::getOrCreateVariant(const RenderingKey
 		ANKI_ASSERT(key.getInstanceCount() == 1);
 	}
 
-	ANKI_ASSERT(!key.isSkinned() || m_builtinMutators[BuiltinMutatorId2::BONES]);
-	ANKI_ASSERT(!key.hasVelocity() || m_builtinMutators[BuiltinMutatorId2::VELOCITY]);
+	ANKI_ASSERT(!key.isSkinned() || m_builtinMutators[BuiltinMutatorId::BONES]);
+	ANKI_ASSERT(!key.hasVelocity() || m_builtinMutators[BuiltinMutatorId::VELOCITY]);
 
 	key.setInstanceCount(1 << getInstanceGroupIdx(key.getInstanceCount()));
 
-	MaterialVariant2& variant = m_variantMatrix[key.getPass()][key.getLod()][getInstanceGroupIdx(
-		key.getInstanceCount())][key.isSkinned()][key.hasVelocity()];
+	MaterialVariant& variant = m_variantMatrix[key.getPass()][key.getLod()][getInstanceGroupIdx(key.getInstanceCount())]
+											  [key.isSkinned()][key.hasVelocity()];
 
 	// Check if it's initialized
 	{
@@ -816,39 +815,39 @@ const MaterialVariant2& MaterialResource2::getOrCreateVariant(const RenderingKey
 		return variant;
 	}
 
-	ShaderProgramResourceVariantInitInfo2 initInfo(m_prog);
+	ShaderProgramResourceVariantInitInfo initInfo(m_prog);
 
 	for(const SubMutation& m : m_nonBuiltinsMutation)
 	{
 		initInfo.addMutation(m.m_mutator->m_name, m.m_value);
 	}
 
-	if(m_builtinMutators[BuiltinMutatorId2::INSTANCE_COUNT])
+	if(m_builtinMutators[BuiltinMutatorId::INSTANCE_COUNT])
 	{
-		initInfo.addMutation(m_builtinMutators[BuiltinMutatorId2::INSTANCE_COUNT]->m_name, key.getInstanceCount());
+		initInfo.addMutation(m_builtinMutators[BuiltinMutatorId::INSTANCE_COUNT]->m_name, key.getInstanceCount());
 	}
 
-	if(m_builtinMutators[BuiltinMutatorId2::PASS])
+	if(m_builtinMutators[BuiltinMutatorId::PASS])
 	{
-		initInfo.addMutation(m_builtinMutators[BuiltinMutatorId2::PASS]->m_name, MutatorValue(key.getPass()));
+		initInfo.addMutation(m_builtinMutators[BuiltinMutatorId::PASS]->m_name, MutatorValue(key.getPass()));
 	}
 
-	if(m_builtinMutators[BuiltinMutatorId2::LOD])
+	if(m_builtinMutators[BuiltinMutatorId::LOD])
 	{
-		initInfo.addMutation(m_builtinMutators[BuiltinMutatorId2::LOD]->m_name, MutatorValue(key.getLod()));
+		initInfo.addMutation(m_builtinMutators[BuiltinMutatorId::LOD]->m_name, MutatorValue(key.getLod()));
 	}
 
-	if(m_builtinMutators[BuiltinMutatorId2::BONES])
+	if(m_builtinMutators[BuiltinMutatorId::BONES])
 	{
-		initInfo.addMutation(m_builtinMutators[BuiltinMutatorId2::BONES]->m_name, key.isSkinned() != 0);
+		initInfo.addMutation(m_builtinMutators[BuiltinMutatorId::BONES]->m_name, key.isSkinned() != 0);
 	}
 
-	if(m_builtinMutators[BuiltinMutatorId2::VELOCITY])
+	if(m_builtinMutators[BuiltinMutatorId::VELOCITY])
 	{
-		initInfo.addMutation(m_builtinMutators[BuiltinMutatorId2::VELOCITY]->m_name, key.hasVelocity() != 0);
+		initInfo.addMutation(m_builtinMutators[BuiltinMutatorId::VELOCITY]->m_name, key.hasVelocity() != 0);
 	}
 
-	for(const MaterialVariable2& var : m_vars)
+	for(const MaterialVariable& var : m_vars)
 	{
 		if(!var.isConstant())
 		{
@@ -891,7 +890,7 @@ const MaterialVariant2& MaterialResource2::getOrCreateVariant(const RenderingKey
 		}
 	}
 
-	const ShaderProgramResourceVariant2* progVariant;
+	const ShaderProgramResourceVariant* progVariant;
 	m_prog->getOrCreateVariant(initInfo, progVariant);
 
 	// Init the variant
@@ -900,8 +899,8 @@ const MaterialVariant2& MaterialResource2::getOrCreateVariant(const RenderingKey
 	return variant;
 }
 
-void MaterialResource2::initVariant(
-	const ShaderProgramResourceVariant2& progVariant, MaterialVariant2& variant, U32 instanceCount) const
+void MaterialResource::initVariant(
+	const ShaderProgramResourceVariant& progVariant, MaterialVariant& variant, U32 instanceCount) const
 {
 	// Find the block instance
 	const ShaderProgramBinary& binary = m_prog->getBinary();
@@ -930,11 +929,11 @@ void MaterialResource2::initVariant(
 	ANKI_ASSERT(variant.m_uniBlockSize > 0);
 
 	// Initialize the block infos, active vars and bindings
-	for(const MaterialVariable2& var : m_vars)
+	for(const MaterialVariable& var : m_vars)
 	{
 		if(var.m_constant)
 		{
-			for(const ShaderProgramResourceConstant2& c : m_prog->getConstants())
+			for(const ShaderProgramResourceConstant& c : m_prog->getConstants())
 			{
 				if(c.m_name == var.m_name)
 				{
@@ -988,9 +987,9 @@ void MaterialResource2::initVariant(
 	}
 
 	// No make sure that the vars that are active
-	for(const MaterialVariable2& var : m_vars)
+	for(const MaterialVariable& var : m_vars)
 	{
-		if(var.m_builtin == BuiltinMaterialVariableId2::NONE && variant.m_activeVars.get(var.m_index)
+		if(var.m_builtin == BuiltinMaterialVariableId::NONE && variant.m_activeVars.get(var.m_index)
 			&& !var.valueSetByMaterial())
 		{
 			ANKI_RESOURCE_LOGF("An active variable doesn't have its value set by the material: %s", var.m_name.cstr());
@@ -1002,7 +1001,7 @@ void MaterialResource2::initVariant(
 // Debug print
 #if 0
 	printf("binary variant idx %u\n", U32(&binaryVariant - binary.m_variants.getBegin()));
-	for(const MaterialVariable2& var : m_vars)
+	for(const MaterialVariable& var : m_vars)
 	{
 
 		printf("Var %s %s\n", var.m_name.cstr(), variant.m_activeVars.get(var.m_index) ? "active" : "inactive");
@@ -1015,7 +1014,7 @@ void MaterialResource2::initVariant(
 #endif
 }
 
-U32 MaterialResource2::getInstanceGroupIdx(U32 instanceCount)
+U32 MaterialResource::getInstanceGroupIdx(U32 instanceCount)
 {
 	ANKI_ASSERT(instanceCount > 0);
 	instanceCount = nextPowerOfTwo(instanceCount);

src/anki/resource/MaterialResource2.h → src/anki/resource/MaterialResource.h

@@ -7,7 +7,7 @@
 
 #include <anki/resource/ResourceObject.h>
 #include <anki/resource/RenderingKey.h>
-#include <anki/resource/ShaderProgramResource2.h>
+#include <anki/resource/ShaderProgramResource.h>
 #include <anki/resource/TextureResource.h>
 #include <anki/Math.h>
 #include <anki/util/Enum.h>
@@ -22,7 +22,7 @@ class XmlElement;
 /// @{
 
 /// The ID of a buildin material variable.
-enum class BuiltinMaterialVariableId2 : U8
+enum class BuiltinMaterialVariableId : U8
 {
 	NONE = 0,
 	MODEL_VIEW_PROJECTION_MATRIX,
@@ -41,10 +41,10 @@ enum class BuiltinMaterialVariableId2 : U8
 	COUNT,
 	FIRST = 0,
 };
-ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(BuiltinMaterialVariableId2, inline)
+ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(BuiltinMaterialVariableId, inline)
 
 /// The ID of builtin mutators.
-enum class BuiltinMutatorId2 : U8
+enum class BuiltinMutatorId : U8
 {
 	NONE = 0,
 	INSTANCE_COUNT,
@@ -56,25 +56,25 @@ enum class BuiltinMutatorId2 : U8
 	COUNT,
 	FIRST = 0
 };
-ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(BuiltinMutatorId2, inline)
+ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(BuiltinMutatorId, inline)
 
 /// Holds the shader variables. It's a container for shader program variables that share the same name.
-class MaterialVariable2 : public NonCopyable
+class MaterialVariable : public NonCopyable
 {
-	friend class MaterialVariant2;
-	friend class MaterialResource2;
+	friend class MaterialVariant;
+	friend class MaterialResource;
 
 public:
-	MaterialVariable2();
+	MaterialVariable();
 
-	MaterialVariable2(MaterialVariable2&& b)
+	MaterialVariable(MaterialVariable&& b)
 	{
 		*this = std::move(b);
 	}
 
-	~MaterialVariable2();
+	~MaterialVariable();
 
-	MaterialVariable2& operator=(MaterialVariable2&& b)
+	MaterialVariable& operator=(MaterialVariable&& b)
 	{
 		m_name = std::move(b.m_name);
 		m_index = b.m_index;
@@ -90,7 +90,7 @@ public:
 	}
 
 	/// Get the builtin info.
-	BuiltinMaterialVariableId2 getBuiltin() const
+	BuiltinMaterialVariableId getBuiltin() const
 	{
 		return m_builtin;
 	}
@@ -131,7 +131,7 @@ public:
 
 	Bool isBuildin() const
 	{
-		return m_builtin != BuiltinMaterialVariableId2::NONE;
+		return m_builtin != BuiltinMaterialVariableId::NONE;
 	}
 
 	ShaderVariableDataType getDataType() const
@@ -150,7 +150,7 @@ protected:
 	Bool m_constant = false;
 	Bool m_instanced = false;
 	ShaderVariableDataType m_dataType = ShaderVariableDataType::NONE;
-	BuiltinMaterialVariableId2 m_builtin = BuiltinMaterialVariableId2::NONE;
+	BuiltinMaterialVariableId m_builtin = BuiltinMaterialVariableId::NONE;
 
 	/// Values for non-builtins
 	/// @{
@@ -184,10 +184,10 @@ protected:
 // Specialize the MaterialVariable::getValue
 #define ANKI_SPECIALIZE_GET_VALUE(t_, var_, shaderType_) \
 	template<> \
-	inline const t_& MaterialVariable2::getValue<t_>() const \
+	inline const t_& MaterialVariable::getValue<t_>() const \
 	{ \
 		ANKI_ASSERT(m_dataType == ShaderVariableDataType::shaderType_); \
-		ANKI_ASSERT(m_builtin == BuiltinMaterialVariableId2::NONE); \
+		ANKI_ASSERT(m_builtin == BuiltinMaterialVariableId::NONE); \
 		return var_; \
 	}
 
@@ -207,23 +207,23 @@ ANKI_SPECIALIZE_GET_VALUE(Mat3, m_mat3, MAT3)
 ANKI_SPECIALIZE_GET_VALUE(Mat4, m_mat4, MAT4)
 
 template<>
-inline const TextureResourcePtr& MaterialVariable2::getValue() const
+inline const TextureResourcePtr& MaterialVariable::getValue() const
 {
 	ANKI_ASSERT(isTexture());
-	ANKI_ASSERT(m_builtin == BuiltinMaterialVariableId2::NONE);
+	ANKI_ASSERT(m_builtin == BuiltinMaterialVariableId::NONE);
 	return m_tex;
 }
 
 #undef ANKI_SPECIALIZE_GET_VALUE
 
 /// Material variant.
-class MaterialVariant2 : public NonCopyable
+class MaterialVariant : public NonCopyable
 {
-	friend class MaterialResource2;
+	friend class MaterialResource;
 
 public:
 	/// Return true of the the variable is active.
-	Bool isVariableActive(const MaterialVariable2& var) const
+	Bool isVariableActive(const MaterialVariable& var) const
 	{
 		return m_activeVars.get(var.m_index);
 	}
@@ -238,13 +238,13 @@ public:
 		return m_uniBlockSize;
 	}
 
-	U32 getOpaqueBinding(const MaterialVariable2& var) const
+	U32 getOpaqueBinding(const MaterialVariable& var) const
 	{
 		ANKI_ASSERT(m_opaqueBindings[var.m_index] >= 0);
 		return U32(m_opaqueBindings[var.m_index]);
 	}
 
-	const ShaderVariableBlockInfo& getBlockInfo(const MaterialVariable2& var) const
+	const ShaderVariableBlockInfo& getBlockInfo(const MaterialVariable& var) const
 	{
 		ANKI_ASSERT(isVariableActive(var));
 		ANKI_ASSERT(var.inBlock());
@@ -254,7 +254,7 @@ public:
 
 	template<typename T>
 	void writeShaderBlockMemory(
-		const MaterialVariable2& var, const T* elements, U32 elementsCount, void* buffBegin, const void* buffEnd) const
+		const MaterialVariable& var, const T* elements, U32 elementsCount, void* buffBegin, const void* buffEnd) const
 	{
 		ANKI_ASSERT(isVariableActive(var));
 		ANKI_ASSERT(getShaderVariableTypeFromTypename<T>() == var.getDataType());
@@ -289,12 +289,12 @@ private:
 /// </material>
 /// @endcode
 /// (1): Only for non-builtins.
-class MaterialResource2 : public ResourceObject
+class MaterialResource : public ResourceObject
 {
 public:
-	MaterialResource2(ResourceManager* manager);
+	MaterialResource(ResourceManager* manager);
 
-	~MaterialResource2();
+	~MaterialResource();
 
 	/// Load a material file
 	ANKI_USE_RESULT Error load(const ResourceFilename& filename, Bool async);
@@ -321,10 +321,10 @@ public:
 
 	Bool isInstanced() const
 	{
-		return m_builtinMutators[BuiltinMutatorId2::INSTANCE_COUNT] != nullptr;
+		return m_builtinMutators[BuiltinMutatorId::INSTANCE_COUNT] != nullptr;
 	}
 
-	ConstWeakArray<MaterialVariable2> getVariables() const
+	ConstWeakArray<MaterialVariable> getVariables() const
 	{
 		return m_vars;
 	}
@@ -346,19 +346,19 @@ public:
 		return m_uboBinding;
 	}
 
-	const MaterialVariant2& getOrCreateVariant(const RenderingKey& key) const;
+	const MaterialVariant& getOrCreateVariant(const RenderingKey& key) const;
 
 private:
 	class SubMutation
 	{
 	public:
-		const ShaderProgramResourceMutator2* m_mutator;
+		const ShaderProgramResourceMutator* m_mutator;
 		MutatorValue m_value;
 	};
 
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 
-	Array<const ShaderProgramResourceMutator2*, U32(BuiltinMutatorId2::COUNT)> m_builtinMutators = {};
+	Array<const ShaderProgramResourceMutator*, U32(BuiltinMutatorId::COUNT)> m_builtinMutators = {};
 
 	Bool m_shadow = true;
 	Bool m_forwardShading = false;
@@ -369,10 +369,10 @@ private:
 	U32 m_boneTrfsBinding = MAX_U32;
 
 	/// Matrix of variants.
-	mutable Array5d<MaterialVariant2, U(Pass::COUNT), MAX_LOD_COUNT, MAX_INSTANCE_GROUPS, 2, 2> m_variantMatrix;
+	mutable Array5d<MaterialVariant, U(Pass::COUNT), MAX_LOD_COUNT, MAX_INSTANCE_GROUPS, 2, 2> m_variantMatrix;
 	mutable RWMutex m_variantMatrixMtx;
 
-	DynamicArray<MaterialVariable2> m_vars;
+	DynamicArray<MaterialVariable> m_vars;
 
 	DynamicArray<SubMutation> m_nonBuiltinsMutation;
 
@@ -389,11 +389,11 @@ private:
 	static U32 getInstanceGroupIdx(U32 instanceCount);
 
 	void initVariant(
-		const ShaderProgramResourceVariant2& progVariant, MaterialVariant2& variant, U32 instanceCount) const;
+		const ShaderProgramResourceVariant& progVariant, MaterialVariant& variant, U32 instanceCount) const;
 
-	const MaterialVariable2* tryFindVariableInternal(CString name) const
+	const MaterialVariable* tryFindVariableInternal(CString name) const
 	{
-		for(const MaterialVariable2& v : m_vars)
+		for(const MaterialVariable& v : m_vars)
 		{
 			if(v.m_name == name)
 			{
@@ -404,14 +404,14 @@ private:
 		return nullptr;
 	}
 
-	const MaterialVariable2* tryFindVariable(CString name) const
+	const MaterialVariable* tryFindVariable(CString name) const
 	{
 		return tryFindVariableInternal(name);
 	}
 
-	MaterialVariable2* tryFindVariable(CString name)
+	MaterialVariable* tryFindVariable(CString name)
 	{
-		return const_cast<MaterialVariable2*>(tryFindVariableInternal(name));
+		return const_cast<MaterialVariable*>(tryFindVariableInternal(name));
 	}
 };
 /// @}

src/anki/resource/ModelResource.cpp

@@ -46,7 +46,7 @@ void ModelPatch::getRenderingDataSub(
 		mtlKey.setLod(min(key.getLod(), m_mtl->getLodCount() - 1));
 		mtlKey.setSkinned(hasSkin);
 
-		const MaterialVariant2& variant = m_mtl->getOrCreateVariant(mtlKey);
+		const MaterialVariant& variant = m_mtl->getOrCreateVariant(mtlKey);
 
 		inf.m_program = variant.getShaderProgram();
 

src/anki/resource/ModelResource.h

@@ -10,7 +10,7 @@
 #include <anki/collision/Obb.h>
 #include <anki/resource/RenderingKey.h>
 #include <anki/resource/MeshResource.h>
-#include <anki/resource/MaterialResource2.h>
+#include <anki/resource/MaterialResource.h>
 #include <anki/resource/SkeletonResource.h>
 #include <anki/resource/AnimationResource.h>
 
@@ -88,7 +88,7 @@ class ModelPatch
 	friend class ModelResource;
 
 public:
-	const MaterialResource2Ptr& getMaterial() const
+	const MaterialResourcePtr& getMaterial() const
 	{
 		return m_mtl;
 	}
@@ -131,7 +131,7 @@ private:
 
 	Array<MeshResourcePtr, MAX_LOD_COUNT> m_meshes; ///< One for each LOD
 	U8 m_meshCount = 0;
-	MaterialResource2Ptr m_mtl;
+	MaterialResourcePtr m_mtl;
 
 	/// Return the maximum number of LODs
 	U32 getLodCount() const;

src/anki/resource/ParticleEmitterResource.cpp

@@ -145,7 +145,7 @@ void ParticleEmitterResource::getRenderingInfo(const RenderingKey& key_, ShaderP
 {
 	RenderingKey key = key_;
 	key.setLod(min<U32>(key.getLod(), m_lodCount - 1));
-	const MaterialVariant2& variant = m_material->getOrCreateVariant(key);
+	const MaterialVariant& variant = m_material->getOrCreateVariant(key);
 	prog = variant.getShaderProgram();
 }
 

src/anki/resource/ParticleEmitterResource.h

@@ -7,7 +7,7 @@
 
 #include <anki/resource/ResourceObject.h>
 #include <anki/resource/RenderingKey.h>
-#include <anki/resource/MaterialResource2.h>
+#include <anki/resource/MaterialResource.h>
 #include <anki/Math.h>
 #include <anki/Gr.h>
 
@@ -105,7 +105,7 @@ public:
 		return *this;
 	}
 
-	const MaterialResource2Ptr& getMaterial() const
+	const MaterialResourcePtr& getMaterial() const
 	{
 		return m_material;
 	}
@@ -117,7 +117,7 @@ public:
 	ANKI_USE_RESULT Error load(const ResourceFilename& filename, Bool async);
 
 private:
-	MaterialResource2Ptr m_material;
+	MaterialResourcePtr m_material;
 	U8 m_lodCount = 1; ///< Cache the value from the material
 
 	void loadInternal(const XmlElement& el);

src/anki/resource/ResourceManager.cpp

@@ -9,7 +9,7 @@
 #include <anki/util/Logger.h>
 #include <anki/core/ConfigSet.h>
 
-#include <anki/resource/MaterialResource2.h>
+#include <anki/resource/MaterialResource.h>
 #include <anki/resource/MeshResource.h>
 #include <anki/resource/ModelResource.h>
 #include <anki/resource/ScriptResource.h>
@@ -18,7 +18,7 @@
 #include <anki/resource/TextureResource.h>
 #include <anki/resource/GenericResource.h>
 #include <anki/resource/TextureAtlasResource.h>
-#include <anki/resource/ShaderProgramResource2.h>
+#include <anki/resource/ShaderProgramResource.h>
 #include <anki/resource/CollisionResource.h>
 
 namespace anki

src/anki/resource/ShaderProgramResource2.cpp → src/anki/resource/ShaderProgramResource.cpp

@@ -3,7 +3,7 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include <anki/resource/ShaderProgramResource2.h>
+#include <anki/resource/ShaderProgramResource.h>
 #include <anki/resource/ResourceManager.h>
 #include <anki/gr/ShaderProgram.h>
 #include <anki/gr/GrManager.h>
@@ -13,25 +13,25 @@
 namespace anki
 {
 
-ShaderProgramResourceVariant2::ShaderProgramResourceVariant2()
+ShaderProgramResourceVariant::ShaderProgramResourceVariant()
 {
 }
 
-ShaderProgramResourceVariant2::~ShaderProgramResourceVariant2()
+ShaderProgramResourceVariant::~ShaderProgramResourceVariant()
 {
 }
 
-ShaderProgramResource2::ShaderProgramResource2(ResourceManager* manager)
+ShaderProgramResource::ShaderProgramResource(ResourceManager* manager)
 	: ResourceObject(manager)
 	, m_binary(getAllocator())
 {
 }
 
-ShaderProgramResource2::~ShaderProgramResource2()
+ShaderProgramResource::~ShaderProgramResource()
 {
 	m_mutators.destroy(getAllocator());
 
-	for(ShaderProgramResourceConstant2& c : m_consts)
+	for(ShaderProgramResourceConstant& c : m_consts)
 	{
 		c.m_name.destroy(getAllocator());
 	}
@@ -40,13 +40,13 @@ ShaderProgramResource2::~ShaderProgramResource2()
 
 	for(auto it : m_variants)
 	{
-		ShaderProgramResourceVariant2* variant = &(*it);
+		ShaderProgramResourceVariant* variant = &(*it);
 		getAllocator().deleteInstance(variant);
 	}
 	m_variants.destroy(getAllocator());
 }
 
-Error ShaderProgramResource2::load(const ResourceFilename& filename, Bool async)
+Error ShaderProgramResource::load(const ResourceFilename& filename, Bool async)
 {
 	// Load the binary from the cache. It should have been compiled there
 	StringAuto baseFilename(getTempAllocator());
@@ -82,7 +82,7 @@ Error ShaderProgramResource2::load(const ResourceFilename& filename, Bool async)
 		mapping.m_component = componentIdx;
 		if(componentIdx > 0)
 		{
-			const ShaderProgramResourceConstant2* other = tryFindConstant(name);
+			const ShaderProgramResourceConstant* other = tryFindConstant(name);
 			ANKI_ASSERT(other);
 			mapping.m_constsIdx = U32(other - m_consts.getBegin());
 		}
@@ -100,7 +100,7 @@ Error ShaderProgramResource2::load(const ResourceFilename& filename, Bool async)
 		}
 
 		// Create new one
-		ShaderProgramResourceConstant2& in = *m_consts.emplaceBack(getAllocator());
+		ShaderProgramResourceConstant& in = *m_consts.emplaceBack(getAllocator());
 		in.m_name.create(getAllocator(), name);
 		in.m_index = m_consts.getSize() - 1;
 
@@ -167,7 +167,7 @@ Error ShaderProgramResource2::load(const ResourceFilename& filename, Bool async)
 	return Error::NONE;
 }
 
-Error ShaderProgramResource2::parseConst(CString constName, U32& componentIdx, U32& componentCount, CString& name)
+Error ShaderProgramResource::parseConst(CString constName, U32& componentIdx, U32& componentCount, CString& name)
 {
 	const CString prefixName = "_anki_const_";
 	const PtrSize prefix = constName.find(prefixName);
@@ -193,8 +193,8 @@ Error ShaderProgramResource2::parseConst(CString constName, U32& componentIdx, U
 	return Error::NONE;
 }
 
-void ShaderProgramResource2::getOrCreateVariant(
-	const ShaderProgramResourceVariantInitInfo2& info, const ShaderProgramResourceVariant2*& variant) const
+void ShaderProgramResource::getOrCreateVariant(
+	const ShaderProgramResourceVariantInitInfo& info, const ShaderProgramResourceVariant*& variant) const
 {
 	// Sanity checks
 	ANKI_ASSERT(info.m_setMutators.getEnabledBitCount() == m_mutators.getSize());
@@ -240,14 +240,14 @@ void ShaderProgramResource2::getOrCreateVariant(
 	}
 
 	// Create
-	ShaderProgramResourceVariant2* v = getAllocator().newInstance<ShaderProgramResourceVariant2>();
+	ShaderProgramResourceVariant* v = getAllocator().newInstance<ShaderProgramResourceVariant>();
 	initVariant(info, *v);
 	m_variants.emplace(getAllocator(), hash, v);
 	variant = v;
 }
 
-void ShaderProgramResource2::initVariant(
-	const ShaderProgramResourceVariantInitInfo2& info, ShaderProgramResourceVariant2& variant) const
+void ShaderProgramResource::initVariant(
+	const ShaderProgramResourceVariantInitInfo& info, ShaderProgramResourceVariant& variant) const
 {
 	const ShaderProgramBinary& binary = m_binary.getBinary();
 
@@ -287,7 +287,7 @@ void ShaderProgramResource2::initVariant(
 		const U32 component = m_constBinaryMapping[instance.m_index].m_component;
 
 		// Get value
-		const ShaderProgramResourceConstantValue2* value = nullptr;
+		const ShaderProgramResourceConstantValue* value = nullptr;
 		for(U32 i = 0; i < m_consts.getSize(); ++i)
 		{
 			if(info.m_constantValues[i].m_constantIndex == inputIdx)

src/anki/resource/ShaderProgramResource2.h → src/anki/resource/ShaderProgramResource.h

@@ -19,14 +19,14 @@ namespace anki
 {
 
 // Forward
-class ShaderProgramResourceVariantInitInfo2;
+class ShaderProgramResourceVariantInitInfo;
 
 /// @addtogroup resource
 /// @{
 
 /// The means to mutate a shader program.
-/// @memberof ShaderProgramResource2
-class ShaderProgramResourceMutator2 : public NonCopyable
+/// @memberof ShaderProgramResource
+class ShaderProgramResourceMutator : public NonCopyable
 {
 public:
 	CString m_name;
@@ -46,7 +46,7 @@ public:
 };
 
 /// Shader program resource variant.
-class ShaderProgramResourceConstant2
+class ShaderProgramResourceConstant
 {
 public:
 	String m_name;
@@ -55,14 +55,14 @@ public:
 };
 
 /// Shader program resource variant.
-class ShaderProgramResourceVariant2
+class ShaderProgramResourceVariant
 {
-	friend class ShaderProgramResource2;
+	friend class ShaderProgramResource;
 
 public:
-	ShaderProgramResourceVariant2();
+	ShaderProgramResourceVariant();
 
-	~ShaderProgramResourceVariant2();
+	~ShaderProgramResourceVariant();
 
 	const ShaderProgramPtr& getProgram() const
 	{
@@ -70,7 +70,7 @@ public:
 	}
 
 	/// Return true if the the variable is active in this variant.
-	Bool isConstantActive(const ShaderProgramResourceConstant2& var) const
+	Bool isConstantActive(const ShaderProgramResourceConstant& var) const
 	{
 		return m_activeConsts.get(var.m_index);
 	}
@@ -97,7 +97,7 @@ private:
 };
 
 /// The value of a constant.
-class ShaderProgramResourceConstantValue2
+class ShaderProgramResourceConstantValue
 {
 public:
 	union
@@ -121,44 +121,44 @@ public:
 	U32 m_constantIndex;
 	U8 _m_padding[sizeof(Vec4) - sizeof(m_constantIndex)];
 
-	ShaderProgramResourceConstantValue2()
+	ShaderProgramResourceConstantValue()
 	{
 		zeroMemory(*this);
 	}
 };
-static_assert(sizeof(ShaderProgramResourceConstantValue2) == sizeof(Vec4) * 2, "Need it to be packed");
+static_assert(sizeof(ShaderProgramResourceConstantValue) == sizeof(Vec4) * 2, "Need it to be packed");
 
 /// Smart initializer of multiple ShaderProgramResourceConstantValue.
-class ShaderProgramResourceVariantInitInfo2
+class ShaderProgramResourceVariantInitInfo
 {
-	friend class ShaderProgramResource2;
+	friend class ShaderProgramResource;
 
 public:
-	ShaderProgramResourceVariantInitInfo2()
+	ShaderProgramResourceVariantInitInfo()
 	{
 	}
 
-	ShaderProgramResourceVariantInitInfo2(const ShaderProgramResource2Ptr& ptr)
+	ShaderProgramResourceVariantInitInfo(const ShaderProgramResourcePtr& ptr)
 		: m_ptr(ptr)
 	{
 	}
 
-	~ShaderProgramResourceVariantInitInfo2()
+	~ShaderProgramResourceVariantInitInfo()
 	{
 	}
 
 	template<typename T>
-	ShaderProgramResourceVariantInitInfo2& addConstant(CString name, const T& value);
+	ShaderProgramResourceVariantInitInfo& addConstant(CString name, const T& value);
 
-	ShaderProgramResourceVariantInitInfo2& addMutation(CString name, MutatorValue t);
+	ShaderProgramResourceVariantInitInfo& addMutation(CString name, MutatorValue t);
 
 private:
 	static constexpr U32 MAX_CONSTANTS = 32;
 	static constexpr U32 MAX_MUTATORS = 32;
 
-	ShaderProgramResource2Ptr m_ptr;
+	ShaderProgramResourcePtr m_ptr;
 
-	Array<ShaderProgramResourceConstantValue2, MAX_CONSTANTS> m_constantValues;
+	Array<ShaderProgramResourceConstantValue, MAX_CONSTANTS> m_constantValues;
 	BitSet<MAX_CONSTANTS> m_setConstants = {false};
 
 	Array<MutatorValue, MAX_MUTATORS> m_mutation; ///< The order of storing the values is important. It will be hashed.
@@ -166,26 +166,26 @@ private:
 };
 
 /// Shader program resource. It loads special AnKi programs.
-class ShaderProgramResource2 : public ResourceObject
+class ShaderProgramResource : public ResourceObject
 {
 public:
-	ShaderProgramResource2(ResourceManager* manager);
+	ShaderProgramResource(ResourceManager* manager);
 
-	~ShaderProgramResource2();
+	~ShaderProgramResource();
 
 	/// Load the resource.
 	ANKI_USE_RESULT Error load(const ResourceFilename& filename, Bool async);
 
 	/// Get the array of constants.
-	ConstWeakArray<ShaderProgramResourceConstant2> getConstants() const
+	ConstWeakArray<ShaderProgramResourceConstant> getConstants() const
 	{
 		return m_consts;
 	}
 
 	/// Try to find a constant.
-	const ShaderProgramResourceConstant2* tryFindConstant(CString name) const
+	const ShaderProgramResourceConstant* tryFindConstant(CString name) const
 	{
-		for(const ShaderProgramResourceConstant2& m : m_consts)
+		for(const ShaderProgramResourceConstant& m : m_consts)
 		{
 			if(m.m_name == name)
 			{
@@ -196,15 +196,15 @@ public:
 	}
 
 	/// Get the array of mutators.
-	ConstWeakArray<ShaderProgramResourceMutator2> getMutators() const
+	ConstWeakArray<ShaderProgramResourceMutator> getMutators() const
 	{
 		return m_mutators;
 	}
 
 	/// Try to find a mutator.
-	const ShaderProgramResourceMutator2* tryFindMutator(CString name) const
+	const ShaderProgramResourceMutator* tryFindMutator(CString name) const
 	{
-		for(const ShaderProgramResourceMutator2& m : m_mutators)
+		for(const ShaderProgramResourceMutator& m : m_mutators)
 		{
 			if(m.m_name == name)
 			{
@@ -227,17 +227,17 @@ public:
 	/// Get or create a graphics shader program variant.
 	/// @note It's thread-safe.
 	void getOrCreateVariant(
-		const ShaderProgramResourceVariantInitInfo2& info, const ShaderProgramResourceVariant2*& variant) const;
+		const ShaderProgramResourceVariantInitInfo& info, const ShaderProgramResourceVariant*& variant) const;
 
 	/// @copydoc getOrCreateVariant
-	void getOrCreateVariant(const ShaderProgramResourceVariant2*& variant) const
+	void getOrCreateVariant(const ShaderProgramResourceVariant*& variant) const
 	{
-		getOrCreateVariant(ShaderProgramResourceVariantInitInfo2(), variant);
+		getOrCreateVariant(ShaderProgramResourceVariantInitInfo(), variant);
 	}
 
 private:
-	using Mutator = ShaderProgramResourceMutator2;
-	using Const = ShaderProgramResourceConstant2;
+	using Mutator = ShaderProgramResourceMutator;
+	using Const = ShaderProgramResourceConstant;
 
 	ShaderProgramBinaryWrapper m_binary;
 
@@ -253,21 +253,21 @@ private:
 
 	DynamicArray<ConstMapping> m_constBinaryMapping;
 
-	mutable HashMap<U64, ShaderProgramResourceVariant2*> m_variants;
+	mutable HashMap<U64, ShaderProgramResourceVariant*> m_variants;
 	mutable RWMutex m_mtx;
 
 	ShaderTypeBit m_shaderStages = ShaderTypeBit::NONE;
 
-	void initVariant(const ShaderProgramResourceVariantInitInfo2& info, ShaderProgramResourceVariant2& variant) const;
+	void initVariant(const ShaderProgramResourceVariantInitInfo& info, ShaderProgramResourceVariant& variant) const;
 
 	static ANKI_USE_RESULT Error parseConst(CString constName, U32& componentIdx, U32& componentCount, CString& name);
 };
 
 template<typename T>
-inline ShaderProgramResourceVariantInitInfo2& ShaderProgramResourceVariantInitInfo2::addConstant(
+inline ShaderProgramResourceVariantInitInfo& ShaderProgramResourceVariantInitInfo::addConstant(
 	CString name, const T& value)
 {
-	const ShaderProgramResourceConstant2* in = m_ptr->tryFindConstant(name);
+	const ShaderProgramResourceConstant* in = m_ptr->tryFindConstant(name);
 	ANKI_ASSERT(in);
 	ANKI_ASSERT(in->m_dataType == getShaderVariableTypeFromTypename<T>());
 	const U32 constIdx = U32(in - m_ptr->getConstants().getBegin());
@@ -277,10 +277,10 @@ inline ShaderProgramResourceVariantInitInfo2& ShaderProgramResourceVariantInitIn
 	return *this;
 }
 
-inline ShaderProgramResourceVariantInitInfo2& ShaderProgramResourceVariantInitInfo2::addMutation(
+inline ShaderProgramResourceVariantInitInfo& ShaderProgramResourceVariantInitInfo::addMutation(
 	CString name, MutatorValue t)
 {
-	const ShaderProgramResourceMutator2* m = m_ptr->tryFindMutator(name);
+	const ShaderProgramResourceMutator* m = m_ptr->tryFindMutator(name);
 	ANKI_ASSERT(m);
 	ANKI_ASSERT(m->valueExists(t));
 	const PtrSize mutatorIdx = m - m_ptr->getMutators().getBegin();

src/anki/scene/DebugDrawer.cpp

@@ -39,12 +39,12 @@ void DebugDrawer::flush()
 
 	// Bind program
 	{
-		ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+		ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 		variantInitInfo.addMutation("COLOR_TEXTURE", 0);
 		variantInitInfo.addMutation(
 			"DITHERED_DEPTH_TEST", m_ctx->m_debugDrawFlags.get(RenderQueueDebugDrawFlag::DITHERED_DEPTH_TEST_ON));
 		variantInitInfo.addConstant("INSTANCE_COUNT", 1u);
-		const ShaderProgramResourceVariant2* variant;
+		const ShaderProgramResourceVariant* variant;
 		m_prog->getOrCreateVariant(variantInitInfo, variant);
 		cmdb->bindShaderProgram(variant->getProgram());
 	}
@@ -364,11 +364,11 @@ void DebugDrawer2::drawCubes(ConstWeakArray<Mat4> mvps,
 	*pcolor = color;
 
 	// Setup state
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addMutation("COLOR_TEXTURE", 0);
 	variantInitInfo.addMutation("DITHERED_DEPTH_TEST", U32(ditherFailedDepth != 0));
 	variantInitInfo.addConstant("INSTANCE_COUNT", mvps.getSize());
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	cmdb->bindShaderProgram(variant->getProgram());
 
@@ -438,11 +438,11 @@ void DebugDrawer2::drawBillboardTextures(const Mat4& projMat,
 	*pcolor = color;
 
 	// Setup state
-	ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addMutation("COLOR_TEXTURE", 1);
 	variantInitInfo.addMutation("DITHERED_DEPTH_TEST", U32(ditherFailedDepth != 0));
 	variantInitInfo.addConstant("INSTANCE_COUNT", positions.getSize());
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	cmdb->bindShaderProgram(variant->getProgram());
 

src/anki/scene/DebugDrawer.h

@@ -9,7 +9,7 @@
 #include <anki/Math.h>
 #include <anki/Gr.h>
 #include <anki/physics/PhysicsDrawer.h>
-#include <anki/resource/ShaderProgramResource2.h>
+#include <anki/resource/ShaderProgramResource.h>
 #include <anki/util/Array.h>
 
 namespace anki
@@ -86,7 +86,7 @@ public:
 	}
 
 private:
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 
 	RenderQueueDrawContext* m_ctx = nullptr;
 
@@ -188,7 +188,7 @@ public:
 	}
 
 private:
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 };
 /// @}
 

src/anki/scene/GpuParticleEmitterNode.cpp

@@ -51,7 +51,7 @@ Error GpuParticleEmitterNode::init(const CString& filename)
 {
 	// Create program
 	ANKI_CHECK(getResourceManager().loadResource("shaders/GpuParticlesSimulation.ankiprog", m_prog));
-	const ShaderProgramResourceVariant2* variant;
+	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variant);
 	m_grProg = variant->getProgram();
 	m_workgroupSizeX = variant->getWorkgroupSizes()[0];

src/anki/scene/GpuParticleEmitterNode.h

@@ -41,7 +41,7 @@ private:
 
 	class MoveFeedbackComponent;
 
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 	U32 m_workgroupSizeX = 0;
 

src/anki/scene/components/RenderComponent.cpp

@@ -12,7 +12,7 @@
 namespace anki
 {
 
-MaterialRenderComponent::MaterialRenderComponent(SceneNode* node, MaterialResource2Ptr mtl)
+MaterialRenderComponent::MaterialRenderComponent(SceneNode* node, MaterialResourcePtr mtl)
 	: m_node(node)
 	, m_mtl(mtl)
 {
@@ -21,7 +21,7 @@ MaterialRenderComponent::MaterialRenderComponent(SceneNode* node, MaterialResour
 	// Create the material variables
 	m_vars.create(m_node->getAllocator(), m_mtl->getVariables().getSize());
 	U32 count = 0;
-	for(const MaterialVariable2& mv : m_mtl->getVariables())
+	for(const MaterialVariable& mv : m_mtl->getVariables())
 	{
 		m_vars[count++].m_mvar = &mv;
 	}
@@ -45,7 +45,7 @@ void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawCont
 	ANKI_ASSERT(transforms.getSize() <= MAX_INSTANCES);
 	ANKI_ASSERT(prevTransforms.getSize() == transforms.getSize());
 
-	const MaterialVariant2& variant = m_mtl->getOrCreateVariant(ctx.m_key);
+	const MaterialVariant& variant = m_mtl->getOrCreateVariant(ctx.m_key);
 	const U32 set = m_mtl->getDescriptorSetIndex();
 
 	// Allocate uniform memory
@@ -60,7 +60,7 @@ void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawCont
 	for(auto it = m_vars.getBegin(); it != m_vars.getEnd(); ++it)
 	{
 		const MaterialRenderComponentVariable& var = *it;
-		const MaterialVariable2& mvar = var.getMaterialVariable();
+		const MaterialVariable& mvar = var.getMaterialVariable();
 
 		if(!variant.isVariableActive(mvar))
 		{
@@ -85,13 +85,13 @@ void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawCont
 		{
 			switch(mvar.getBuiltin())
 			{
-			case BuiltinMaterialVariableId2::NONE:
+			case BuiltinMaterialVariableId::NONE:
 			{
 				const Vec3 val = mvar.getValue<Vec3>();
 				variant.writeShaderBlockMemory(mvar, &val, 1, uniformsBegin, uniformsEnd);
 				break;
 			}
-			case BuiltinMaterialVariableId2::CAMERA_POSITION:
+			case BuiltinMaterialVariableId::CAMERA_POSITION:
 			{
 				const Vec3 val = ctx.m_cameraTransform.getTranslationPart().xyz();
 				variant.writeShaderBlockMemory(mvar, &val, 1, uniformsBegin, uniformsEnd);
@@ -113,13 +113,13 @@ void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawCont
 		{
 			switch(mvar.getBuiltin())
 			{
-			case BuiltinMaterialVariableId2::NONE:
+			case BuiltinMaterialVariableId::NONE:
 			{
 				const Mat3 val = mvar.getValue<Mat3>();
 				variant.writeShaderBlockMemory(mvar, &val, 1, uniformsBegin, uniformsEnd);
 				break;
 			}
-			case BuiltinMaterialVariableId2::NORMAL_MATRIX:
+			case BuiltinMaterialVariableId::NORMAL_MATRIX:
 			{
 				ANKI_ASSERT(transforms.getSize() > 0);
 
@@ -134,7 +134,7 @@ void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawCont
 				variant.writeShaderBlockMemory(mvar, &normMats[0], transforms.getSize(), uniformsBegin, uniformsEnd);
 				break;
 			}
-			case BuiltinMaterialVariableId2::ROTATION_MATRIX:
+			case BuiltinMaterialVariableId::ROTATION_MATRIX:
 			{
 				ANKI_ASSERT(transforms.getSize() > 0);
 
@@ -147,7 +147,7 @@ void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawCont
 				variant.writeShaderBlockMemory(mvar, &rots[0], transforms.getSize(), uniformsBegin, uniformsEnd);
 				break;
 			}
-			case BuiltinMaterialVariableId2::CAMERA_ROTATION_MATRIX:
+			case BuiltinMaterialVariableId::CAMERA_ROTATION_MATRIX:
 			{
 				const Mat3 rot = ctx.m_cameraTransform.getRotationPart();
 				variant.writeShaderBlockMemory(mvar, &rot, 1, uniformsBegin, uniformsEnd);
@@ -163,13 +163,13 @@ void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawCont
 		{
 			switch(mvar.getBuiltin())
 			{
-			case BuiltinMaterialVariableId2::NONE:
+			case BuiltinMaterialVariableId::NONE:
 			{
 				const Mat4 val = mvar.getValue<Mat4>();
 				variant.writeShaderBlockMemory(mvar, &val, 1, uniformsBegin, uniformsEnd);
 				break;
 			}
-			case BuiltinMaterialVariableId2::MODEL_VIEW_PROJECTION_MATRIX:
+			case BuiltinMaterialVariableId::MODEL_VIEW_PROJECTION_MATRIX:
 			{
 				ANKI_ASSERT(transforms.getSize() > 0);
 
@@ -182,7 +182,7 @@ void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawCont
 				variant.writeShaderBlockMemory(mvar, &mvp[0], transforms.getSize(), uniformsBegin, uniformsEnd);
 				break;
 			}
-			case BuiltinMaterialVariableId2::PREVIOUS_MODEL_VIEW_PROJECTION_MATRIX:
+			case BuiltinMaterialVariableId::PREVIOUS_MODEL_VIEW_PROJECTION_MATRIX:
 			{
 				ANKI_ASSERT(prevTransforms.getSize() > 0);
 
@@ -195,7 +195,7 @@ void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawCont
 				variant.writeShaderBlockMemory(mvar, &mvp[0], prevTransforms.getSize(), uniformsBegin, uniformsEnd);
 				break;
 			}
-			case BuiltinMaterialVariableId2::MODEL_VIEW_MATRIX:
+			case BuiltinMaterialVariableId::MODEL_VIEW_MATRIX:
 			{
 				ANKI_ASSERT(transforms.getSize() > 0);
 
@@ -208,20 +208,20 @@ void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawCont
 				variant.writeShaderBlockMemory(mvar, &mv[0], transforms.getSize(), uniformsBegin, uniformsEnd);
 				break;
 			}
-			case BuiltinMaterialVariableId2::MODEL_MATRIX:
+			case BuiltinMaterialVariableId::MODEL_MATRIX:
 			{
 				ANKI_ASSERT(transforms.getSize() > 0);
 
 				variant.writeShaderBlockMemory(mvar, &transforms[0], transforms.getSize(), uniformsBegin, uniformsEnd);
 				break;
 			}
-			case BuiltinMaterialVariableId2::VIEW_PROJECTION_MATRIX:
+			case BuiltinMaterialVariableId::VIEW_PROJECTION_MATRIX:
 			{
 				ANKI_ASSERT(transforms.getSize() == 0 && "Cannot have transform");
 				variant.writeShaderBlockMemory(mvar, &ctx.m_viewProjectionMatrix, 1, uniformsBegin, uniformsEnd);
 				break;
 			}
-			case BuiltinMaterialVariableId2::VIEW_MATRIX:
+			case BuiltinMaterialVariableId::VIEW_MATRIX:
 			{
 				variant.writeShaderBlockMemory(mvar, &ctx.m_viewMatrix, 1, uniformsBegin, uniformsEnd);
 				break;
@@ -247,7 +247,7 @@ void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawCont
 		{
 			switch(mvar.getBuiltin())
 			{
-			case BuiltinMaterialVariableId2::GLOBAL_SAMPLER:
+			case BuiltinMaterialVariableId::GLOBAL_SAMPLER:
 				ctx.m_commandBuffer->bindSampler(set, variant.getOpaqueBinding(mvar), ctx.m_sampler);
 				break;
 			default:

src/anki/scene/components/RenderComponent.h

@@ -7,7 +7,7 @@
 
 #include <anki/scene/Common.h>
 #include <anki/scene/components/SceneComponent.h>
-#include <anki/resource/MaterialResource2.h>
+#include <anki/resource/MaterialResource.h>
 #include <anki/core/StagingGpuMemoryManager.h>
 #include <anki/renderer/RenderQueue.h>
 
@@ -89,13 +89,13 @@ public:
 		return m_mvar->getValue<T>();
 	}
 
-	const MaterialVariable2& getMaterialVariable() const
+	const MaterialVariable& getMaterialVariable() const
 	{
 		return *m_mvar;
 	}
 
 private:
-	const MaterialVariable2* m_mvar = nullptr;
+	const MaterialVariable* m_mvar = nullptr;
 };
 
 /// Material render component interface.
@@ -104,7 +104,7 @@ class MaterialRenderComponent : public RenderComponent
 public:
 	using Variables = DynamicArray<MaterialRenderComponentVariable>;
 
-	MaterialRenderComponent(SceneNode* node, MaterialResource2Ptr mtl);
+	MaterialRenderComponent(SceneNode* node, MaterialResourcePtr mtl);
 
 	~MaterialRenderComponent();
 
@@ -129,7 +129,7 @@ public:
 	}
 
 	/// Access the material
-	const MaterialResource2& getMaterial() const
+	const MaterialResource& getMaterial() const
 	{
 		ANKI_ASSERT(m_mtl);
 		return *m_mtl;
@@ -167,7 +167,7 @@ public:
 private:
 	SceneNode* m_node;
 	Variables m_vars;
-	MaterialResource2Ptr m_mtl;
+	MaterialResourcePtr m_mtl;
 };
 /// @}
 

src/anki/ui/Canvas.cpp

@@ -41,8 +41,8 @@ Error Canvas::init(FontPtr font, U32 fontHeight, U32 width, U32 height)
 
 	for(U32 i = 0; i < SHADER_COUNT; ++i)
 	{
-		const ShaderProgramResourceVariant2* variant;
-		ShaderProgramResourceVariantInitInfo2 variantInitInfo(m_prog);
+		const ShaderProgramResourceVariant* variant;
+		ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 		variantInitInfo.addMutation("TEXTURE_TYPE", i);
 		m_prog->getOrCreateVariant(variantInitInfo, variant);
 		m_grProgs[i] = variant->getProgram();

src/anki/ui/Canvas.h

@@ -7,7 +7,7 @@
 
 #include <anki/ui/UiObject.h>
 #include <anki/gr/CommandBuffer.h>
-#include <anki/resource/ShaderProgramResource2.h>
+#include <anki/resource/ShaderProgramResource.h>
 
 namespace anki
 {
@@ -81,7 +81,7 @@ private:
 		SHADER_COUNT
 	};
 
-	ShaderProgramResource2Ptr m_prog;
+	ShaderProgramResourcePtr m_prog;
 	Array<ShaderProgramPtr, SHADER_COUNT> m_grProgs;
 	SamplerPtr m_sampler;