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

include/anki/resource/Material.h

@@ -53,6 +53,8 @@ public:
 
 	virtual ~MaterialVariable();
 
+	virtual void destroy(ResourceAllocator<U8> alloc) = 0;
+
 	template<typename T>
 	const T* begin() const
 	{
@@ -113,58 +115,66 @@ class MaterialVariableTemplate: public MaterialVariable
 public:
 	using Type = TData;
 
-	/// @name Constructors/Destructor
-	/// @{
 	MaterialVariableTemplate(
 		const GlProgramVariable* glvar, 
-		Bool instanced, 
-		const TData* x, 
-		U32 size,
-		ResourceAllocator<U8> alloc)
-	:	MaterialVariable(glvar, instanced),
-		m_data(alloc)
+		Bool instanced)
+	:	MaterialVariable(glvar, instanced)
 	{
 		setupVisitable(this);
+	}
+
+	~MaterialVariableTemplate()
+	{}
 
+	ANKI_USE_RESULT Error create(
+		ResourceAllocator<U8> alloc, const TData* x, U32 size)
+	{
+		Error err = ErrorCode::NONE;
 		if(size > 0)
 		{
-			m_data.insert(m_data.begin(), x, x + size);
+			err = m_data.create(alloc, size);
+			if(!err)
+			{
+				for(U i = 0; i < size; i++)
+				{
+					m_data[i] = x[i];
+				}
+			}
 		}
+
+		return ErrorCode::NONE;
 	}
 
-	~MaterialVariableTemplate()
-	{}
-	/// @}
+	void destroy(ResourceAllocator<U8> alloc)
+	{
+		m_data.destroy(alloc);
+	}
 
-	/// @name Accessors
-	/// @{
 	const TData* begin() const
 	{
 		ANKI_ASSERT(hasValues());
-		return &(*m_data.begin());
+		return m_data.begin();
 	}
 	const TData* end() const
 	{
 		ANKI_ASSERT(hasValues());
-		return &(*m_data.end());
+		return m_data.end();
 	}
 
 	const TData& operator[](U idx) const
 	{
 		ANKI_ASSERT(hasValues());
-		ANKI_ASSERT(idx < m_data.size());
 		return m_data[idx];
 	}
 
 	/// Implements hasValues
 	Bool hasValues() const
 	{
-		return m_data.size() > 0;
+		return m_data.getSize() > 0;
 	}
-	/// @}
 
 private:
-	ResourceVector<TData> m_data;
+	ResourceDArray<TData> m_data;
 };
 
 /// Contains a few properties that other classes may use. For an explanation of

include/anki/util/DArray.h

@@ -197,8 +197,6 @@ public:
 		ANKI_ASSERT(m_data == nullptr && m_size == 0);
 		Error err = ErrorCode::NONE;
 
-		destroy(alloc);
-
 		if(size > 0)
 		{
 			m_data = alloc.template newArray<Value>(size, v);

src/resource/Material.cpp

@@ -30,7 +30,7 @@ static MaterialVariable* newMaterialVariable(
 	const GlProgramVariable& glvar, const MaterialProgramCreator::Input& in,
 	ResourceAllocator<U8>& alloc, TempResourceAllocator<U8>& talloc)
 {
-	MaterialVariable* out = nullptr;
+	MaterialVariableTemplate<T>* out = nullptr;
 
 	if(in.m_value.getSize() > 0)
 	{
@@ -63,22 +63,26 @@ static MaterialVariable* newMaterialVariable(
 		}
 
 		out = alloc.newInstance<MaterialVariableTemplate<T>>(
-			&glvar, 
-			in.m_instanced,
-			(T*)&floatvec[0],
-			glvar.getArraySize(),
-			alloc);
+			&glvar, in.m_instanced);
+
+		if(out)
+		{
+			Error err = out->create(
+				alloc, (T*)&floatvec[0], glvar.getArraySize());
+
+			if(err)
+			{
+				alloc.deleteInstance(out);
+				out = nullptr;
+			}
+		}
 	}
 	else
 	{
 		// Buildin
 
 		out = alloc.newInstance<MaterialVariableTemplate<T>>(
-			&glvar, 
-			in.m_instanced,
-			nullptr,
-			0,
-			alloc);
+			&glvar, in.m_instanced);
 	}
 
 	return out;
@@ -152,7 +156,9 @@ Material::~Material()
 
 	for(auto it : m_vars)
 	{
-		alloc.deleteInstance(it);
+		MaterialVariable* mvar = &(*it);
+		mvar->destroy(alloc);
+		alloc.deleteInstance(mvar);
 	}
 
 	m_vars.destroy(alloc);
@@ -645,9 +651,23 @@ Error Material::populateVariables(const MaterialProgramCreator& loader)
 				}
 
 				auto alloc = m_resources->_getAllocator();
-				mtlvar = alloc.newInstance<
+				MaterialVariableTemplate<TextureResourcePointer>* tvar = 
+					alloc.newInstance<
 					MaterialVariableTemplate<TextureResourcePointer>>(
-					glvar, false, &tp, 1, alloc);
+					glvar, false);
+
+				if(tvar)
+				{
+					err = tvar->create(alloc, &tp, 1);
+
+					if(err)
+					{
+						alloc.deleteInstance(tvar);
+						tvar = nullptr;
+					}
+				}
+
+				mtlvar = tvar;
 			}
 			break;
 		// F32