Complete the RenderComponent

AnKi/Resource/MaterialResource.cpp

@@ -297,7 +297,7 @@ Error MaterialResource::createVars(Technique& technique)
 					// different programs have different signature for AnKiLocalUniforms
 					for(const MaterialVariable& otherVar : m_vars)
 					{
-						if(otherVar.isSampler() || otherVar.isTexture())
+						if(otherVar.isTexture())
 						{
 							continue;
 						}
@@ -331,6 +331,11 @@ Error MaterialResource::createVars(Technique& technique)
 		for(const ShaderProgramBinaryOpaqueInstance& instance : variant->getBinaryVariant().m_opaques)
 		{
 			const ShaderProgramBinaryOpaque& opaque = binary.m_opaques[instance.m_index];
+			if(opaque.m_type == ShaderVariableDataType::SAMPLER)
+			{
+				continue;
+			}
+
 			const CString opaqueName = opaque.m_name.getBegin();
 			MaterialVariable* var = tryFindVariable(opaqueName);
 
@@ -347,7 +352,7 @@ Error MaterialResource::createVars(Technique& technique)
 				// Check that there are no other opaque with the same binding
 				for(const MaterialVariable& otherVar : m_vars)
 				{
-					if(!otherVar.isSampler() && !otherVar.isTexture())
+					if(!otherVar.isTexture())
 					{
 						continue;
 					}
@@ -618,7 +623,7 @@ void MaterialResource::prefillLocalUniforms()
 
 	for(const MaterialVariable& var : m_vars)
 	{
-		if(var.isTexture() || var.isSampler())
+		if(var.isTexture())
 		{
 			continue;
 		}

AnKi/Resource/MaterialResource.h

@@ -78,14 +78,9 @@ public:
 			   && m_dataType <= ShaderVariableDataType::TEXTURE_LAST;
 	}
 
-	Bool isSampler() const
-	{
-		return m_dataType == ShaderVariableDataType::SAMPLER;
-	}
-
 	Bool isUniform() const
 	{
-		return !isTexture() && !isSampler();
+		return !isTexture();
 	}
 
 	ShaderVariableDataType getDataType() const
@@ -95,12 +90,18 @@ public:
 	}
 
 	/// Get the binding of a texture or a sampler type of material variable.
-	U32 getOpaqueBinding() const
+	U32 getTextureBinding() const
 	{
-		ANKI_ASSERT(m_opaqueBinding != MAX_U32 && (isTexture() || isSampler()));
+		ANKI_ASSERT(m_opaqueBinding != MAX_U32 && isTexture());
 		return m_opaqueBinding;
 	}
 
+	U32 getOffsetInLocalUniforms() const
+	{
+		ANKI_ASSERT(m_offsetInLocalUniforms != MAX_U32);
+		return m_offsetInLocalUniforms;
+	}
+
 protected:
 	String m_name;
 	U32 m_offsetInLocalUniforms = MAX_U32;

AnKi/Scene/Components/RenderComponent.cpp

@@ -8,6 +8,7 @@
 #include <AnKi/Resource/ImageResource.h>
 #include <AnKi/Resource/ResourceManager.h>
 #include <AnKi/Util/Logger.h>
+#include <AnKi/Shaders/Include/GpuSceneTypes.h>
 
 namespace anki {
 
@@ -20,161 +21,77 @@ void RenderComponent::allocateAndSetupUniforms(const MaterialResourcePtr& mtl, c
 	ANKI_ASSERT(transforms.getSize() <= MAX_INSTANCE_COUNT);
 	ANKI_ASSERT(prevTransforms.getSize() == transforms.getSize());
 
-	const MaterialVariant& variant = mtl->getOrCreateVariant(ctx.m_key);
-	const U32 set = mtl->getDescriptorSetIndex();
+	CommandBufferPtr cmdb = ctx.m_commandBuffer;
 
-	// Allocate and bind uniform memory
-	const U32 perDrawUboSize = variant.getPerDrawUniformBlockSize();
-	const U32 perInstanceUboSize = variant.getPerInstanceUniformBlockSize(transforms.getSize());
+	const U32 set = MATERIAL_SET_EXTERNAL;
 
-	StagingGpuMemoryToken token;
-	void* const perDrawUniformsBegin =
-		(perDrawUboSize != 0) ? alloc.allocateFrame(perDrawUboSize, StagingGpuMemoryType::UNIFORM, token) : nullptr;
-	const void* const perDrawUniformsEnd = static_cast<U8*>(perDrawUniformsBegin) + perDrawUboSize;
+	cmdb->bindSampler(set, MATERIAL_BINDING_GLOBAL_SAMPLER, ctx.m_sampler);
 
-	StagingGpuMemoryToken token1;
-	void* const perInstanceUniformsBegin =
-		(perInstanceUboSize != 0) ? alloc.allocateFrame(perInstanceUboSize, StagingGpuMemoryType::UNIFORM, token1)
-								  : nullptr;
-	const void* const perInstanceUniformsEnd = static_cast<U8*>(perInstanceUniformsBegin) + perInstanceUboSize;
+	cmdb->bindUniformBuffer(set, MATERIAL_BINDING_GLOBAL_UNIFORMS, ctx.m_globalUniforms.m_buffer,
+							ctx.m_globalUniforms.m_offset, ctx.m_globalUniforms.m_range);
 
-	if(perDrawUboSize)
+	// Fill the RenderableGpuView
+	const U32 renderableGpuViewsUboSize = sizeof(RenderableGpuView) * transforms.getSize();
+	if(renderableGpuViewsUboSize)
 	{
-		ctx.m_commandBuffer->bindUniformBuffer(set, mtl->getPerDrawUniformBlockBinding(), token.m_buffer,
-											   token.m_offset, token.m_range);
+		StagingGpuMemoryToken token;
+		RenderableGpuView* renderableGpuViews = static_cast<RenderableGpuView*>(
+			alloc.allocateFrame(renderableGpuViewsUboSize, StagingGpuMemoryType::UNIFORM, token));
+		ANKI_ASSERT(isAligned(alignof(RenderableGpuView), renderableGpuViews));
+
+		cmdb->bindUniformBuffer(set, MATERIAL_BINDING_RENDERABLE_GPU_VIEW, token.m_buffer, token.m_offset,
+								token.m_range);
+
+		for(U32 i = 0; i < transforms.getSize(); ++i)
+		{
+			memcpy(&renderableGpuViews->m_transform, &transforms[i], sizeof(renderableGpuViews->m_transform));
+			memcpy(&renderableGpuViews->m_previousTransform, &prevTransforms[i],
+				   sizeof(renderableGpuViews->m_previousTransform));
+			renderableGpuViews->m_rotation = transforms[i].getRotationPart();
+		}
 	}
 
-	if(perInstanceUboSize)
+	// Local uniforms
+	const U32 localUniformsUboSize = U32(mtl->getPrefilledLocalUniforms().getSizeInBytes());
+
+	StagingGpuMemoryToken token;
+	U8* const localUniformsBegin =
+		(localUniformsUboSize != 0)
+			? static_cast<U8*>(alloc.allocateFrame(localUniformsUboSize, StagingGpuMemoryType::UNIFORM, token))
+			: nullptr;
+
+	if(localUniformsUboSize)
 	{
-		ctx.m_commandBuffer->bindUniformBuffer(set, mtl->getPerInstanceUniformBlockBinding(), token1.m_buffer,
-											   token1.m_offset, token1.m_range);
+		cmdb->bindUniformBuffer(set, MATERIAL_BINDING_LOCAL_UNIFORMS, token.m_buffer, token.m_offset, token.m_range);
 	}
 
-	ctx.m_commandBuffer->bindUniformBuffer(set, mtl->getGlobalUniformsUniformBlockBinding(),
-										   ctx.m_globalUniforms.m_buffer, ctx.m_globalUniforms.m_offset,
-										   ctx.m_globalUniforms.m_range);
-
 	// Iterate variables
 	for(const MaterialVariable& mvar : mtl->getVariables())
 	{
-		if(!variant.isVariableActive(mvar))
-		{
-			continue;
-		}
-
 		switch(mvar.getDataType())
 		{
 		case ShaderVariableDataType::F32:
 		{
 			const F32 val = mvar.getValue<F32>();
-			variant.writeShaderBlockMemory(mvar, &val, 1, perDrawUniformsBegin, perDrawUniformsEnd);
+			memcpy(localUniformsBegin + mvar.getOffsetInLocalUniforms(), &val, sizeof(val));
 			break;
 		}
 		case ShaderVariableDataType::VEC2:
 		{
 			const Vec2 val = mvar.getValue<Vec2>();
-			variant.writeShaderBlockMemory(mvar, &val, 1, perDrawUniformsBegin, perDrawUniformsEnd);
+			memcpy(localUniformsBegin + mvar.getOffsetInLocalUniforms(), &val, sizeof(val));
 			break;
 		}
 		case ShaderVariableDataType::VEC3:
 		{
-			switch(mvar.getBuiltin())
-			{
-			case BuiltinMaterialVariableId::NONE:
-			{
-				const Vec3 val = mvar.getValue<Vec3>();
-				variant.writeShaderBlockMemory(mvar, &val, 1, perDrawUniformsBegin, perDrawUniformsEnd);
-				break;
-			}
-			default:
-				ANKI_ASSERT(0);
-			}
-
+			const Vec3 val = mvar.getValue<Vec3>();
+			memcpy(localUniformsBegin + mvar.getOffsetInLocalUniforms(), &val, sizeof(val));
 			break;
 		}
 		case ShaderVariableDataType::VEC4:
 		{
 			const Vec4 val = mvar.getValue<Vec4>();
-			variant.writeShaderBlockMemory(mvar, &val, 1, perDrawUniformsBegin, perDrawUniformsEnd);
-			break;
-		}
-		case ShaderVariableDataType::MAT3:
-		{
-			switch(mvar.getBuiltin())
-			{
-			case BuiltinMaterialVariableId::NONE:
-			{
-				const Mat3 val = mvar.getValue<Mat3>();
-				variant.writeShaderBlockMemory(mvar, &val, 1, perDrawUniformsBegin, perDrawUniformsEnd);
-				break;
-			}
-			case BuiltinMaterialVariableId::ROTATION:
-			{
-				ANKI_ASSERT(transforms.getSize() > 0);
-
-				Array<Mat3, MAX_INSTANCE_COUNT> rots;
-				for(U32 i = 0; i < transforms.getSize(); i++)
-				{
-					rots[i] = transforms[i].getRotationPart();
-				}
-
-				variant.writeShaderBlockMemory(mvar, &rots[0], transforms.getSize(),
-											   (mvar.isInstanced()) ? perInstanceUniformsBegin : perDrawUniformsBegin,
-											   (mvar.isInstanced()) ? perInstanceUniformsEnd : perDrawUniformsEnd);
-				break;
-			}
-			default:
-				ANKI_ASSERT(0);
-			}
-
-			break;
-		}
-		case ShaderVariableDataType::MAT4:
-		{
-			switch(mvar.getBuiltin())
-			{
-			case BuiltinMaterialVariableId::NONE:
-			{
-				const Mat4 val = mvar.getValue<Mat4>();
-				variant.writeShaderBlockMemory(mvar, &val, 1, perDrawUniformsBegin, perDrawUniformsEnd);
-				break;
-			}
-			default:
-				ANKI_ASSERT(0);
-			}
-
-			break;
-		}
-		case ShaderVariableDataType::MAT3X4:
-		{
-			switch(mvar.getBuiltin())
-			{
-			case BuiltinMaterialVariableId::NONE:
-			{
-				const Mat3x4 val = mvar.getValue<Mat3x4>();
-				variant.writeShaderBlockMemory(mvar, &val, 1, perDrawUniformsBegin, perDrawUniformsEnd);
-				break;
-			}
-			case BuiltinMaterialVariableId::TRANSFORM:
-			{
-				ANKI_ASSERT(transforms.getSize() > 0);
-				variant.writeShaderBlockMemory(mvar, &transforms[0], transforms.getSize(),
-											   (mvar.isInstanced()) ? perInstanceUniformsBegin : perDrawUniformsBegin,
-											   (mvar.isInstanced()) ? perInstanceUniformsEnd : perDrawUniformsEnd);
-				break;
-			}
-			case BuiltinMaterialVariableId::PREVIOUS_TRANSFORM:
-			{
-				ANKI_ASSERT(prevTransforms.getSize() > 0);
-				variant.writeShaderBlockMemory(mvar, &prevTransforms[0], prevTransforms.getSize(),
-											   (mvar.isInstanced()) ? perInstanceUniformsBegin : perDrawUniformsBegin,
-											   (mvar.isInstanced()) ? perInstanceUniformsEnd : perDrawUniformsEnd);
-				break;
-			}
-			default:
-				ANKI_ASSERT(0);
-			}
-
+			memcpy(localUniformsBegin + mvar.getOffsetInLocalUniforms(), &val, sizeof(val));
 			break;
 		}
 		case ShaderVariableDataType::TEXTURE_2D:
@@ -182,21 +99,7 @@ void RenderComponent::allocateAndSetupUniforms(const MaterialResourcePtr& mtl, c
 		case ShaderVariableDataType::TEXTURE_3D:
 		case ShaderVariableDataType::TEXTURE_CUBE:
 		{
-			ctx.m_commandBuffer->bindTexture(set, mvar.getOpaqueBinding(),
-											 mvar.getValue<ImageResourcePtr>()->getTextureView());
-			break;
-		}
-		case ShaderVariableDataType::SAMPLER:
-		{
-			switch(mvar.getBuiltin())
-			{
-			case BuiltinMaterialVariableId::GLOBAL_SAMPLER:
-				ctx.m_commandBuffer->bindSampler(set, mvar.getOpaqueBinding(), ctx.m_sampler);
-				break;
-			default:
-				ANKI_ASSERT(0);
-			}
-
+			cmdb->bindTexture(set, mvar.getTextureBinding(), mvar.getValue<ImageResourcePtr>()->getTextureView());
 			break;
 		}
 		default:

AnKi/Scene/Components/RenderComponent.h

@@ -55,8 +55,9 @@ public:
 
 	void setFlagsFromMaterial(const MaterialResourcePtr& mtl)
 	{
-		RenderComponentFlag flags =
-			(mtl->isForwardShading()) ? RenderComponentFlag::FORWARD_SHADING : RenderComponentFlag::NONE;
+		RenderComponentFlag flags = !!(mtl->getRenderingTechniques() & RenderingTechniqueBit::FORWARD)
+										? RenderComponentFlag::FORWARD_SHADING
+										: RenderComponentFlag::NONE;
 		flags |= (mtl->castsShadow()) ? RenderComponentFlag::CASTS_SHADOW : RenderComponentFlag::NONE;
 		setFlags(flags);
 	}

AnKi/Util/Hash.h

@@ -17,14 +17,14 @@ namespace anki {
 /// @param bufferSize The size of the buffer.
 /// @param seed A unique seed.
 /// @return The hash.
-ANKI_USE_RESULT U64 computeHash(const void* buffer, PtrSize bufferSize, U64 seed = 123);
+ANKI_PURE ANKI_USE_RESULT U64 computeHash(const void* buffer, PtrSize bufferSize, U64 seed = 123);
 
 /// Computes a hash of a buffer. This function implements the MurmurHash2 algorithm by Austin Appleby.
 /// @param[in] buffer The buffer to hash.
 /// @param bufferSize The size of the buffer.
 /// @param prevHash The hash to append to.
 /// @return The new hash.
-ANKI_USE_RESULT U64 appendHash(const void* buffer, PtrSize bufferSize, U64 prevHash);
+ANKI_PURE ANKI_USE_RESULT U64 appendHash(const void* buffer, PtrSize bufferSize, U64 prevHash);
 /// @}
 
 } // end namespace anki