The material will calculate the uniform properties. Don't query GL

include/anki/gl/GlCommon.h

@@ -95,6 +95,7 @@ ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(ShaderType, inline)
 /// Shader variable type.
 enum class ShaderVariableDataType: U8
 {
+	NONE,
 	FLOAT,
 	VEC2,
 	VEC3,

include/anki/renderer/Drawer.h

@@ -50,6 +50,7 @@ public:
 private:
 	Renderer* m_r;
 	GlBufferHandle m_uniformBuff;
+	U8* m_uniformBuffMapAddr = nullptr;
 
 	/// @name State
 	/// @{

include/anki/resource/Material.h

@@ -45,12 +45,8 @@ class MaterialVariable: public MateriaVariableVisitable, public NonCopyable
 public:
 	using Base = MateriaVariableVisitable;
 
-	MaterialVariable(const GlProgramVariable* glvar, Bool instanced)
-	:	m_progVar(glvar), 
-		m_instanced(instanced)
-	{
-		ANKI_ASSERT(m_progVar);
-	}
+	MaterialVariable()
+	{}
 
 	virtual ~MaterialVariable();
 
@@ -80,18 +76,20 @@ public:
 		return (*derived)[idx];
 	}
 
-	const GlProgramVariable& getGlProgramVariable() const
+	/// Get the name of all the shader program variables
+	CString getName() const
 	{
-		return *m_progVar;
+		return m_name.toCString();
 	}
 
-	/// Get the name of all the shader program variables
-	CString getName() const;
-
 	/// If false then it should be buildin
 	virtual Bool hasValues() const = 0;
 
-	U32 getArraySize() const;
+	U32 getArraySize() const
+	{
+		ANKI_ASSERT(m_varBlkInfo.m_arraySize > 0);
+		return m_varBlkInfo.m_arraySize;
+	}
 
 	Bool isInstanced() const
 	{
@@ -109,24 +107,22 @@ public:
 		const T* elements, 
 		U32 elementsCount,
 		void* buffBegin,
-		const void* buffEnd)
+		const void* buffEnd) const
 	{
 		ANKI_ASSERT(Base::isTypeOf<MaterialVariableTemplate<T>>());
 		ANKI_ASSERT(m_varType == getShaderVariableTypeFromTypename<T>());
 		anki::writeShaderBlockMemory(m_varType, m_varBlkInfo, 
-			reinterpret_cast<T*>(elements), elementsCount, buffBegin, buffEnd);
+			reinterpret_cast<const T*>(elements), 
+			elementsCount, buffBegin, buffEnd);
 	}
 
 protected:
-	/// Keep one program variable here for easy access of the common
-	/// variable stuff like name or GL data type etc
-	const GlProgramVariable* m_progVar;
-	ShaderVariableDataType m_varType;
+	ShaderVariableDataType m_varType = ShaderVariableDataType::NONE;
 	ShaderVariableBlockInfo m_varBlkInfo;
 	I16 m_textureUnit = -1;
 	ResourceString m_name;
 
-	Bool8 m_instanced;
+	Bool8 m_instanced = false;
 };
 
 /// Material variable with data. A complete type
@@ -136,10 +132,7 @@ class MaterialVariableTemplate: public MaterialVariable
 public:
 	using Type = TData;
 
-	MaterialVariableTemplate(
-		const GlProgramVariable* glvar, 
-		Bool instanced)
-	:	MaterialVariable(glvar, instanced)
+	MaterialVariableTemplate()
 	{
 		setupVisitable(this);
 	}
@@ -179,7 +172,6 @@ public:
 	}
 
 	static MaterialVariableTemplate* _newInstance(
-		const GlProgramVariable& glvar, 
 		const MaterialProgramCreatorInputVariable& in,
 		ResourceAllocator<U8> alloc, 
 		TempResourceAllocator<U8> talloc);

include/anki/resource/MaterialProgramCreator.h

@@ -15,7 +15,8 @@ namespace anki {
 // Forward
 class XmlElement;
 
-/// XXX
+/// Material loader variable. It's the information on whatever is inside 
+/// \<input\>
 class MaterialProgramCreatorInputVariable: public NonCopyable
 {
 public:
@@ -25,7 +26,7 @@ public:
 	TempResourceAllocator<U8> m_alloc;
 	MPString m_name;
 	MPString m_typeStr;
-	ShaderVariableDataType m_type;
+	ShaderVariableDataType m_type = ShaderVariableDataType::NONE;
 	MPStringList m_value;
 	Bool8 m_constant = false;
 	U16 m_arraySize = 0;

include/anki/scene/RenderComponent.h

@@ -109,9 +109,9 @@ public:
 		return m_mvar->getArraySize();
 	}
 
-	const GlProgramVariable& getGlProgramVariable() const
+	const MaterialVariable& getMaterialVariable() const
 	{
-		return m_mvar->getGlProgramVariable();
+		return *m_mvar;
 	}
 
 	Bool isInstanced() const

include/anki/util/String.h

@@ -65,9 +65,6 @@ class CString
 	template<typename TAlloc>
 	friend class StringBase; // For the secret constructor
 
-	// For the secret constructor
-	friend CString operator"" _cstr(const char*, unsigned long); 
-
 public:
 	using Char = char;
 
@@ -284,12 +281,6 @@ private:
 	}
 };
 
-/// User defined string literal for CStrings.
-inline CString operator"" _cstr(const char* str, unsigned long length)
-{
-	return CString(str, length);
-}
-
 template<typename TAlloc>
 using StringScopeDestroyer = ScopeDestroyer<StringBase<TAlloc>, TAlloc>;
 

src/renderer/Drawer.cpp

@@ -36,21 +36,22 @@ public:
 
 	/// Set a uniform in a client block
 	template<typename T>
-	void uniSet(const GlProgramVariable& uni,
+	void uniSet(const MaterialVariable& mtlVar,
 		const T* value, U32 size)
 	{
-		uni.writeClientMemory(
+		mtlVar.writeShaderBlockMemory<T>(
+			value,
+			size,
 			m_drawer->m_uniformPtr,
-			m_renderable->getMaterial().getDefaultBlockSize(),
-			value, 
-			size);
+			m_drawer->m_uniformBuffMapAddr 
+				+ RenderableDrawer::MAX_UNIFORM_BUFFER_SIZE);
 	}
 
 	template<typename TRenderableVariableTemplate>
 	Error visit(const TRenderableVariableTemplate& rvar)
 	{
 		typedef typename TRenderableVariableTemplate::Type DataType;
-		const GlProgramVariable& glvar = rvar.getGlProgramVariable();
+		const MaterialVariable& glvar = rvar.getMaterialVariable();
 
 		// Array size
 		U arraySize;
@@ -216,12 +217,12 @@ public:
 // Texture specialization
 template<>
 void SetupRenderableVariableVisitor::uniSet<TextureResourcePointer>(
-	const GlProgramVariable& uni, 
+	const MaterialVariable& mtlvar, 
 	const TextureResourcePointer* values, U32 size)
 {
 	ANKI_ASSERT(size == 1);
 	GlTextureHandle tex = (*values)->getGlTexture();
-	auto unit = uni.getTextureUnit();
+	auto unit = mtlvar.getTextureUnit();
 
 	tex.bind(m_cmdBuff, unit);
 }
@@ -251,7 +252,9 @@ Error RenderableDrawer::create(Renderer* r)
 
 	cmdBuff.flush();
 
-	m_uniformPtr = (U8*)m_uniformBuff.getPersistentMappingAddress();
+	m_uniformPtr = static_cast<U8*>(
+		m_uniformBuff.getPersistentMappingAddress());
+	m_uniformBuffMapAddr = m_uniformPtr;
 	ANKI_ASSERT(m_uniformPtr != nullptr);
 	ANKI_ASSERT(isAligned(m_r->_getGlDevice().getBufferOffsetAlignment(
 		m_uniformBuff.getTarget()), m_uniformPtr));
@@ -272,7 +275,7 @@ void RenderableDrawer::setupUniforms(
 {
 	const Material& mtl = renderable.getMaterial();
 	U blockSize = mtl.getDefaultBlockSize();
-	U8* persistent = (U8*)m_uniformBuff.getPersistentMappingAddress();
+	U8* persistent = m_uniformBuffMapAddr;
 
 	// Find a place to write the uniforms
 	//

src/resource/Material.cpp

@@ -59,18 +59,6 @@ static GLenum blendToEnum(const CString& str)
 MaterialVariable::~MaterialVariable()
 {}
 
-//==============================================================================
-CString MaterialVariable::getName() const
-{
-	return m_progVar->getName();
-}
-
-//==============================================================================
-U32 MaterialVariable::getArraySize() const
-{
-	return m_progVar->getArraySize();
-}
-
 //==============================================================================
 template<typename T>
 Error MaterialVariableTemplate<T>::create(ResourceAllocator<U8> alloc, 
@@ -98,7 +86,7 @@ Error MaterialVariableTemplate<T>::create(ResourceAllocator<U8> alloc,
 //==============================================================================
 template<typename T>
 MaterialVariableTemplate<T>* MaterialVariableTemplate<T>::_newInstance(
-	const GlProgramVariable& glvar, const MaterialProgramCreator::Input& in,
+	const MaterialProgramCreator::Input& in,
 	ResourceAllocator<U8> alloc, TempResourceAllocator<U8> talloc)
 {
 	Error err = ErrorCode::NONE;
@@ -112,12 +100,12 @@ MaterialVariableTemplate<T>* MaterialVariableTemplate<T>::_newInstance(
 	{
 		// Has values
 
-		U floatsNeeded = glvar.getArraySize() * (sizeof(T) / sizeof(F32));
+		U floatsNeeded = in.m_arraySize * (sizeof(T) / sizeof(F32));
 
 		if(in.m_value.getSize() != floatsNeeded)
 		{
-			ANKI_LOGE("Incorrect number of values. Variable %s",
-				&glvar.getName()[0]);
+			ANKI_LOGE("Incorrect number of values. Variable %s", 
+				&in.m_name[0]);
 
 			return nullptr;
 		}
@@ -135,20 +123,16 @@ MaterialVariableTemplate<T>* MaterialVariableTemplate<T>::_newInstance(
 			floats[i] = d;
 			++it;
 		}
-
-		out = alloc.newInstance<MaterialVariableTemplate<T>>(
-			&glvar, in.m_instanced);
 	}
 
 	// Create new instance
-	out = alloc.newInstance<MaterialVariableTemplate<T>>(
-		&glvar, in.m_instanced);
+	out = alloc.newInstance<MaterialVariableTemplate<T>>();
 	if(!out) return nullptr;
 
 	if(floats.getSize() > 0)
 	{
 		err = out->create(alloc, in.m_name.toCString(), 
-			(T*)&floats[0], glvar.getArraySize());
+			(T*)&floats[0], in.m_arraySize);
 	}
 	else
 	{
@@ -163,6 +147,7 @@ MaterialVariableTemplate<T>* MaterialVariableTemplate<T>::_newInstance(
 	}
 
 	// Set some values
+	out->m_instanced = in.m_instanced;
 	out->m_varType = in.m_type;
 	out->m_textureUnit = in.m_binding;
 	out->m_varBlkInfo.m_arraySize = in.m_arraySize;
@@ -657,33 +642,12 @@ Error Material::populateVariables(const MaterialProgramCreator& loader)
 		}
 
 		MaterialVariable* mtlvar = nullptr;
-		const GlProgramVariable* glvar = nullptr;
-
-		// Find the input variable in one of the programs
-		for(const ProgramResourcePointer& progr : m_progs)
-		{
-			const GlShaderHandle& prog = progr->getGlProgram();
-
-			glvar = prog.tryFindVariable(in.m_name.toCString());
-			if(glvar)
-			{
-				break;
-			}
-		}
-
-		// Check if variable found
-		if(glvar == nullptr)
-		{
-			ANKI_LOGE("Variable not found in at least one program: %s", 
-				&in.m_name[0]);
-			return ErrorCode::USER_DATA;
-		}
 
-		switch(glvar->getDataType())
+		switch(in.m_type)
 		{
 		// samplers
-		case GL_SAMPLER_2D:
-		case GL_SAMPLER_CUBE:
+		case ShaderVariableDataType::SAMPLER_2D:
+		case ShaderVariableDataType::SAMPLER_CUBE:
 			{
 				TextureResourcePointer tp;
 				
@@ -696,8 +660,7 @@ Error Material::populateVariables(const MaterialProgramCreator& loader)
 				auto alloc = m_resources->_getAllocator();
 				MaterialVariableTemplate<TextureResourcePointer>* tvar = 
 					alloc.newInstance<
-					MaterialVariableTemplate<TextureResourcePointer>>(
-					glvar, false);
+					MaterialVariableTemplate<TextureResourcePointer>>();
 
 				if(tvar)
 				{
@@ -713,34 +676,28 @@ Error Material::populateVariables(const MaterialProgramCreator& loader)
 				mtlvar = tvar;
 			}
 			break;
-		// F32
-		case GL_FLOAT:
-			mtlvar = MaterialVariableTemplate<F32>::_newInstance(*glvar, in,
+		case ShaderVariableDataType::FLOAT:
+			mtlvar = MaterialVariableTemplate<F32>::_newInstance(in,
 				m_resources->_getAllocator(), m_resources->_getTempAllocator());
 			break;
-		// vec2
-		case GL_FLOAT_VEC2:
-			mtlvar = MaterialVariableTemplate<Vec2>::_newInstance(*glvar, in,
+		case ShaderVariableDataType::VEC2:
+			mtlvar = MaterialVariableTemplate<Vec2>::_newInstance(in,
 				m_resources->_getAllocator(), m_resources->_getTempAllocator());
 			break;
-		// vec3
-		case GL_FLOAT_VEC3:
-			mtlvar = MaterialVariableTemplate<Vec3>::_newInstance(*glvar, in,
+		case ShaderVariableDataType::VEC3:
+			mtlvar = MaterialVariableTemplate<Vec3>::_newInstance(in,
 				m_resources->_getAllocator(), m_resources->_getTempAllocator());
 			break;
-		// vec4
-		case GL_FLOAT_VEC4:
-			mtlvar = MaterialVariableTemplate<Vec4>::_newInstance(*glvar, in,
+		case ShaderVariableDataType::VEC4:
+			mtlvar = MaterialVariableTemplate<Vec4>::_newInstance(in,
 				m_resources->_getAllocator(), m_resources->_getTempAllocator());
 			break;
-		// mat3
-		case GL_FLOAT_MAT3:
-			mtlvar = MaterialVariableTemplate<Mat3>::_newInstance(*glvar, in,
+		case ShaderVariableDataType::MAT3:
+			mtlvar = MaterialVariableTemplate<Mat3>::_newInstance(in,
 				m_resources->_getAllocator(), m_resources->_getTempAllocator());
 			break;
-		// mat4
-		case GL_FLOAT_MAT4:
-			mtlvar = MaterialVariableTemplate<Mat4>::_newInstance(*glvar, in,
+		case ShaderVariableDataType::MAT4:
+			mtlvar = MaterialVariableTemplate<Mat4>::_newInstance(in,
 				m_resources->_getAllocator(), m_resources->_getTempAllocator());
 			break;
 		// default is error