Integrating the resources with the new graphics abstraction

include/anki/Gr.h

@@ -7,25 +7,21 @@
 /// This file contains the public OpenGL headers and all the GL classes that
 /// the rest of AnKi should use
 
-#ifndef ANKI_GR_H
-#define ANKI_GR_H
+#pragma once
 
 /// @defgroup graphics Graphics backend abstraction
 
 /// @defgroup opengl OpenGL backend
 /// @ingroup graphics
 
-#include "anki/gr/BufferPtr.h"
-#include "anki/gr/TexturePtr.h"
-#include "anki/gr/SamplerPtr.h"
-#include "anki/gr/ShaderPtr.h"
-
-#include "anki/gr/FramebufferPtr.h"
-#include "anki/gr/PipelineCommon.h"
-#include "anki/gr/PipelinePtr.h"
-
-#include "anki/gr/CommandBufferPtr.h"
-#include "anki/gr/OcclusionQueryPtr.h"
+#include "anki/gr/Buffer.h"
+#include "anki/gr/Texture.h"
+#include "anki/gr/Sampler.h"
+#include "anki/gr/Shader.h"
+#include "anki/gr/Framebuffer.h"
+#include "anki/gr/Pipeline.h"
+#include "anki/gr/CommandBuffer.h"
+#include "anki/gr/OcclusionQuery.h"
+#include "anki/gr/ResourceGroup.h"
 #include "anki/gr/GrManager.h"
 
-#endif

include/anki/gr/Enums.h

@@ -175,6 +175,18 @@ enum class ShaderType: U8
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(ShaderType, inline)
 
+enum class ShaderTypeBit: U8
+{
+	NONE = 0,
+	VERTEX = 1 << 0,
+	TESSELLATION_CONTROL = 1 << 1,
+	TESSELLATION_EVALUATION = 1 << 2,
+	GEOMETRY = 1 << 3,
+	FRAGMENT = 1 << 4,
+	COMPUTE = 1 << 5
+};
+ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(ShaderTypeBit, inline)
+
 enum class ShaderVariableDataType: U8
 {
 	NONE,

include/anki/gr/GrManager.h

@@ -87,7 +87,7 @@ template<typename T, typename... Args>
 IntrusivePtr<T> GrManager::newInstance(Args&&... args)
 {
 	T* ptr = m_alloc.newInstance<T>(this);
-	ptr->create(std::forward(args)...);
+	ptr->create(args...);
 	return IntrusivePtr<T>(ptr);
 }
 /// @}

include/anki/renderer/Is.h

@@ -60,7 +60,8 @@ public:
 
 	void generateMipmaps(CommandBufferPtr& cmdb)
 	{
-		m_rt.generateMipmaps(cmdb);
+		ANKI_ASSERT(0 && "TODO");
+		//m_rt.generateMipmaps(cmdb);
 	}
 
 	void setAmbientColor(const Vec4& color)

include/anki/resource/Material.h

@@ -120,6 +120,11 @@ public:
 			elements, elementsCount, buffBegin, buffEnd);
 	}
 
+	ShaderVariableDataType getShaderVariableType() const
+	{
+		return m_varType;
+	}
+
 protected:
 	ShaderVariableDataType m_varType = ShaderVariableDataType::NONE;
 	ShaderVariableBlockInfo m_varBlkInfo;

include/anki/resource/MaterialProgramCreator.h

@@ -29,8 +29,9 @@ public:
 	Bool8 m_instanced = false;
 
 	String m_line;
-	GLbitfield m_shaderDefinedMask = 0; ///< Defined in
-	GLbitfield m_shaderReferencedMask = 0; ///< Referenced by
+	ShaderTypeBit m_shaderDefinedMask = ShaderTypeBit::NONE; ///< Defined in
+	/// Referenced by
+	ShaderTypeBit m_shaderReferencedMask = ShaderTypeBit::NONE;
 	Bool8 m_inBlock = true;
 
 	I16 m_binding = -1; ///< Texture unit
@@ -143,11 +144,11 @@ private:
 	Array<String, 5> m_sourceBaked; ///< Final source baked
 	List<Input> m_inputs;
 	StringList m_uniformBlock;
-	GLbitfield m_uniformBlockReferencedMask = 0;
+	ShaderTypeBit m_uniformBlockReferencedMask = ShaderTypeBit::NONE;
 	U32 m_blockSize = 0;
 	Bool8 m_instanced = false;
 	U32 m_texBinding = 0;
-	GLbitfield m_instanceIdMask = 0;
+	ShaderTypeBit m_instanceIdMask = ShaderTypeBit::NONE;
 	Bool8 m_tessellation = false;
 
 	/// Parse what is within the
@@ -159,8 +160,8 @@ private:
 
 	/// Parse what is within the @code <operation></operation> @endcode
 	ANKI_USE_RESULT Error parseOperationTag(
-		const XmlElement& el, GLenum glshader,
-		GLbitfield glshaderbit, String& out);
+		const XmlElement& el, ShaderType glshader,
+		ShaderTypeBit glshaderbit, String& out);
 };
 
 } // end namespace anki

include/anki/resource/Mesh.h

@@ -87,7 +87,7 @@ public:
 	/// Helper function for correct loading
 	Bool isCompatible(const Mesh& other) const;
 
-	/// Load from a .mesh file
+	/// Load from a mesh file
 	ANKI_USE_RESULT Error load(const ResourceFilename& filename);
 
 protected:
@@ -110,7 +110,7 @@ protected:
 	BufferPtr m_indicesBuff;
 
 	/// Create the VBOs using the mesh data
-	ANKI_USE_RESULT Error createBuffers(const MeshLoader& loader);
+	void createBuffers(const MeshLoader& loader);
 };
 /// @}
 

include/anki/resource/Model.h

@@ -69,8 +69,7 @@ public:
 	void getRenderingDataSub(
 		const RenderingKey& key,
 		SArray<U8> subMeshIndicesArray,
-		BufferPtr& vertBuff,
-		BufferPtr& indexBuff,
+		ResourceGroupPtr& resourceGroup,
 		PipelinePtr& ppline,
 		Array<U32, ANKI_GL_MAX_SUB_DRAWCALLS>& indicesCountArray,
 		Array<PtrSize, ANKI_GL_MAX_SUB_DRAWCALLS>& indicesOffsetArray,
@@ -84,6 +83,7 @@ private:
 	MaterialResourcePtr m_mtl;
 
 	mutable Array3d<PipelinePtr, U(Pass::COUNT), MAX_LODS, 2> m_pplines;
+	Array<ResourceGroupPtr, MAX_LODS> m_grResources;
 
 	/// Return the maximum number of LODs
 	U getLodCount() const;

include/anki/resource/ShaderResource.h

@@ -45,7 +45,7 @@ public:
 	/// @param filenamePrefix Add that at the base filename for additional
 	///        ways to identify the file in the cache
 	/// @param out The file pathname of the new shader prog. It's
-	///            filenamePrefix + hash + .glsl
+	///        filenamePrefix + hash + .glsl
 	static ANKI_USE_RESULT Error createToCache(
 		const ResourceFilename& filename,
 		const CString& preAppendedSrcCode,

src/resource/MaterialProgramCreator.cpp

@@ -19,41 +19,41 @@ namespace anki {
 //==============================================================================
 /// Given a string return info about the shader
 static ANKI_USE_RESULT Error getShaderInfo(
-	const CString& str, 
-	GLenum& type, 
-	GLbitfield& bit,
+	const CString& str,
+	ShaderType& type,
+	ShaderTypeBit& bit,
 	U& idx)
 {
 	Error err = ErrorCode::NONE;
 
 	if(str == "vert")
 	{
-		type = GL_VERTEX_SHADER;
-		bit = GL_VERTEX_SHADER_BIT;
+		type = ShaderType::VERTEX;
+		bit = ShaderTypeBit::VERTEX;
 		idx = 0;
 	}
 	else if(str == "tesc")
 	{
-		type = GL_TESS_CONTROL_SHADER;
-		bit = GL_TESS_CONTROL_SHADER_BIT;
+		type = ShaderType::TESSELLATION_CONTROL;
+		bit = ShaderTypeBit::TESSELLATION_CONTROL;
 		idx = 1;
 	}
 	else if(str == "tese")
 	{
-		type = GL_TESS_EVALUATION_SHADER;
-		bit = GL_TESS_EVALUATION_SHADER_BIT;
+		type = ShaderType::TESSELLATION_EVALUATION;
+		bit = ShaderTypeBit::TESSELLATION_EVALUATION;
 		idx = 2;
 	}
 	else if(str == "geom")
 	{
-		type = GL_GEOMETRY_SHADER;
-		bit = GL_GEOMETRY_SHADER_BIT;
+		type = ShaderType::GEOMETRY;
+		bit = ShaderTypeBit::GEOMETRY;
 		idx = 3;
 	}
 	else if(str == "frag")
 	{
-		type = GL_FRAGMENT_SHADER;
-		bit = GL_FRAGMENT_SHADER_BIT;
+		type = ShaderType::FRAGMENT;
+		bit = ShaderTypeBit::FRAGMENT;
 		idx = 4;
 	}
 	else
@@ -180,7 +180,7 @@ Error MaterialProgramCreator::parseProgramsTag(const XmlElement& el)
 	{
 		if(in.m_shaderDefinedMask != in.m_shaderReferencedMask)
 		{
-			ANKI_LOGE("Variable not referenced or not defined %s", 
+			ANKI_LOGE("Variable not referenced or not defined %s",
 				&in.m_name[0]);
 			return ErrorCode::USER_DATA;
 		}
@@ -210,16 +210,16 @@ Error MaterialProgramCreator::parseProgramTag(
 	ANKI_CHECK(programEl.getChildElement("type", el));
 	CString type;
 	ANKI_CHECK(el.getText(type));
-	GLbitfield glshaderbit;
-	GLenum glshader;
+	ShaderTypeBit glshaderbit;
+	ShaderType glshader;
 	U shaderidx;
 	ANKI_CHECK(getShaderInfo(type, glshader, glshaderbit, shaderidx));
 
 	auto& lines = m_source[shaderidx];
 	lines.pushBackSprintf(m_alloc, "#pragma anki type %s", &type[0]);
 
-	if(glshader == GL_TESS_CONTROL_SHADER 
-		|| glshader == GL_TESS_EVALUATION_SHADER)
+	if(glshader == ShaderType::TESSELLATION_CONTROL
+		|| glshader == ShaderType::TESSELLATION_EVALUATION)
 	{
 		m_tessellation = true;
 	}
@@ -243,9 +243,9 @@ Error MaterialProgramCreator::parseProgramTag(
 
 	// Block
 	if(!m_uniformBlock.isEmpty()
-		&& (m_uniformBlockReferencedMask & glshaderbit))
+		&& (m_uniformBlockReferencedMask & glshaderbit) != ShaderTypeBit::NONE)
 	{
-		lines.pushBackSprintf(m_alloc, 
+		lines.pushBackSprintf(m_alloc,
 			"\nlayout(binding = 0, std140) uniform bDefaultBlock\n{");
 
 		for(auto& str : m_uniformBlock)
@@ -259,7 +259,8 @@ Error MaterialProgramCreator::parseProgramTag(
 	// Other variables
 	for(Input& in : m_inputs)
 	{
-		if(!in.m_inBlock && (in.m_shaderDefinedMask & glshaderbit))
+		if(!in.m_inBlock
+			&& (in.m_shaderDefinedMask & glshaderbit) != ShaderTypeBit::NONE)
 		{
 			lines.pushBackSprintf(m_alloc, &in.m_line[0]);
 		}
@@ -300,8 +301,8 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 	}
 
 	// Get shader type
-	GLbitfield glshaderbit;
-	GLenum glshader;
+	ShaderTypeBit glshaderbit;
+	ShaderType glshader;
 	U shaderidx;
 	ANKI_CHECK(programEl.getChildElement("type", el));
 	ANKI_CHECK(el.getText(cstr));
@@ -390,7 +391,7 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 			inpvar.m_instanced = false;
 		}
 
-		// If one input var is instanced notify the whole program that 
+		// If one input var is instanced notify the whole program that
 		// it's instanced
 		if(inpvar.m_instanced)
 		{
@@ -440,7 +441,7 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 
 			inpvar.m_line.sprintf(
 				m_alloc, "%s %s", &inpvar.m_typeStr[0], &inpvar.m_name[0]);
-			
+
 			if(inpvar.m_arraySize > 1)
 			{
 				String tmp;
@@ -452,7 +453,7 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 			inpvar.m_line.append(m_alloc, ";");
 
 			// Can put it block
-			if(inpvar.m_type >= ShaderVariableDataType::SAMPLERS_FIRST 
+			if(inpvar.m_type >= ShaderVariableDataType::SAMPLERS_FIRST
 				&& inpvar.m_type <= ShaderVariableDataType::SAMPLERS_LAST)
 			{
 				String tmp;
@@ -538,14 +539,14 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 					alignRoundUp(sizeof(Vec4), inpvar.m_offset);
 					inpvar.m_arrayStride = sizeof(Vec4) * 3;
 					m_blockSize += sizeof(Vec4) * 3 * inpvar.m_arraySize;
-					inpvar.m_matrixStride = sizeof(Vec4);				
+					inpvar.m_matrixStride = sizeof(Vec4);
 				}
 				else if(inpvar.m_type == ShaderVariableDataType::MAT4)
 				{
 					alignRoundUp(sizeof(Vec4), inpvar.m_offset);
 					inpvar.m_arrayStride = sizeof(Mat4);
 					m_blockSize += sizeof(Mat4) * inpvar.m_arraySize;
-					inpvar.m_matrixStride = sizeof(Vec4);				
+					inpvar.m_matrixStride = sizeof(Vec4);
 				}
 				else
 				{
@@ -576,7 +577,7 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 			inpvar.m_value.join(m_alloc, ", ", initList);
 
 			inpvar.m_line.sprintf(m_alloc, "const %s %s = %s(%s);",
-				&inpvar.m_typeStr[0], &inpvar.m_name[0], &inpvar.m_typeStr[0], 
+				&inpvar.m_typeStr[0], &inpvar.m_name[0], &inpvar.m_typeStr[0],
 				&initList[0]);
 			initList.destroy(m_alloc);
 		}
@@ -596,9 +597,9 @@ advance:
 
 //==============================================================================
 Error MaterialProgramCreator::parseOperationTag(
-	const XmlElement& operationTag, 
-	GLenum glshader, 
-	GLbitfield glshaderbit,
+	const XmlElement& operationTag,
+	ShaderType glshader,
+	ShaderTypeBit glshaderbit,
 	String& out)
 {
 	CString cstr;
@@ -613,21 +614,21 @@ Error MaterialProgramCreator::parseOperationTag(
 	I64 id;
 	ANKI_CHECK(operationTag.getChildElement("id", el));
 	ANKI_CHECK(el.getI64(id));
-	
+
 	// <returnType></returnType>
 	XmlElement retTypeEl;
 	ANKI_CHECK(operationTag.getChildElement("returnType", retTypeEl));
 	ANKI_CHECK(retTypeEl.getText(cstr));
 	Bool retTypeVoid = cstr == "void";
-	
+
 	// <function>functionName</function>
 	ANKI_CHECK(operationTag.getChildElement("function", el));
 	ANKI_CHECK(el.getText(funcName));
-	
+
 	// <arguments></arguments>
 	XmlElement argsEl;
 	ANKI_CHECK(operationTag.getChildElementOptional("arguments", argsEl));
-	
+
 	if(argsEl)
 	{
 		// Get all arguments
@@ -642,7 +643,7 @@ Error MaterialProgramCreator::parseOperationTag(
 			Input* input = nullptr;
 			for(Input& in : m_inputs)
 			{
-				// Check that the first part of the string is equal to the 
+				// Check that the first part of the string is equal to the
 				// variable and the following char is '['
 				if(in.m_name == arg)
 				{
@@ -653,7 +654,7 @@ Error MaterialProgramCreator::parseOperationTag(
 			}
 
 			// The argument should be an input variable or an outXX
-			if(!(input != nullptr 
+			if(!(input != nullptr
 				|| std::memcmp(&arg[0], OUT, 3) == 0))
 			{
 				ANKI_LOGE("Incorrect argument: %s", &arg[0]);
@@ -665,16 +666,16 @@ Error MaterialProgramCreator::parseOperationTag(
 			{
 				ANKI_CHECK(argEl.getText(cstr));
 
-				if(glshader == GL_VERTEX_SHADER)
+				if(glshader == ShaderType::VERTEX)
 				{
 					argsList.pushBackSprintf("%s [gl_InstanceID]", &cstr[0]);
 
 					m_instanceIdMask |= glshaderbit;
 				}
-				else if(glshader == GL_FRAGMENT_SHADER)
+				else if(glshader == ShaderType::FRAGMENT)
 				{
 					argsList.pushBackSprintf("%s [vInstanceId]", &cstr[0]);
-					
+
 					m_instanceIdMask |= glshaderbit;
 				}
 				else
@@ -719,7 +720,7 @@ Error MaterialProgramCreator::parseOperationTag(
 	{
 		lines.pushBackSprintf("\t");
 	}
-	
+
 	// write the "func(args...)" of "blah = func(args...)"
 	StringAuto argsStr(m_alloc);
 
@@ -729,7 +730,7 @@ Error MaterialProgramCreator::parseOperationTag(
 	}
 
 	lines.pushBackSprintf("%s(%s);\n#endif",
-		&funcName[0], 
+		&funcName[0],
 		(argsStr.isEmpty()) ? "" : &argsStr[0]);
 
 	// Bake final string

src/resource/Mesh.cpp

@@ -28,8 +28,6 @@ Bool Mesh::isCompatible(const Mesh& other) const
 //==============================================================================
 Error Mesh::load(const ResourceFilename& filename)
 {
-	Error err = ErrorCode::NONE;
-
 	MeshLoader loader(&getManager());
 	ANKI_CHECK(loader.load(filename));
 
@@ -49,25 +47,34 @@ Error Mesh::load(const ResourceFilename& filename)
 	m_texChannelsCount = header.m_uvsChannelCount;
 	m_weights = loader.hasBoneInfo();
 
-	err = createBuffers(loader);
+	createBuffers(loader);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
-Error Mesh::createBuffers(const MeshLoader& loader)
+void Mesh::createBuffers(const MeshLoader& loader)
 {
 	GrManager& gr = getManager().getGrManager();
 
+	CommandBufferPtr cmdb = gr.newInstance<CommandBuffer>();
+
 	// Create vertex buffer
-	m_vertBuff.create(&gr, GL_ARRAY_BUFFER, loader.getVertexData(),
-		loader.getVertexDataSize(), 0);
+	m_vertBuff = gr.newInstance<Buffer>(loader.getVertexDataSize(),
+		BufferUsageBit::VERTEX_BUFFER, BufferAccessBit::CLIENT_WRITE);
+
+	void* data = nullptr;
+	cmdb->writeBuffer(m_vertBuff, 0, loader.getVertexDataSize(), data);
+	memcpy(data, loader.getVertexData(), loader.getVertexDataSize());
 
 	// Create index buffer
-	m_indicesBuff.create(&gr, GL_ELEMENT_ARRAY_BUFFER,
-		loader.getIndexData(), loader.getIndexDataSize(), 0);
+	m_indicesBuff = gr.newInstance<Buffer>(loader.getIndexDataSize(),
+		BufferUsageBit::INDEX_BUFFER, BufferAccessBit::CLIENT_WRITE);
 
-	return ErrorCode::NONE;
+	cmdb->writeBuffer(m_indicesBuff, 0, loader.getIndexDataSize(), data);
+	memcpy(data, loader.getIndexData(), loader.getIndexDataSize());
+
+	cmdb->flush();
 }
 
 } // end namespace anki

src/resource/Model.cpp

@@ -17,6 +17,36 @@
 
 namespace anki {
 
+//==============================================================================
+// Misc                                                                        =
+//==============================================================================
+
+/// Visit the textures to bind them
+class UpdateTexturesVisitor
+{
+public:
+	U m_count = 0;
+	ResourceGroupInitializer* m_init = nullptr;
+
+	template<typename TMaterialVariableTemplate>
+	Error visit(const TMaterialVariableTemplate& var)
+	{
+		// Do nothing
+		return ErrorCode::NONE;
+	}
+};
+
+// Specialize for texture
+template<>
+Error UpdateTexturesVisitor
+	::visit<MaterialVariableTemplate<TextureResourcePtr>>(
+	const MaterialVariableTemplate<TextureResourcePtr>& var)
+{
+	m_init->m_textures[m_count++].m_texture =
+		(*var.begin())->getGlTexture();
+	return ErrorCode::NONE;
+}
+
 //==============================================================================
 // ModelPatch                                                                  =
 //==============================================================================
@@ -29,19 +59,17 @@ ModelPatch::~ModelPatch()
 void ModelPatch::getRenderingDataSub(
 	const RenderingKey& key,
 	SArray<U8> subMeshIndicesArray,
-	BufferPtr& vertBuff,
-	BufferPtr& indexBuff,
+	ResourceGroupPtr& resourceGroup,
 	PipelinePtr& ppline,
 	Array<U32, ANKI_GL_MAX_SUB_DRAWCALLS>& indicesCountArray,
 	Array<PtrSize, ANKI_GL_MAX_SUB_DRAWCALLS>& indicesOffsetArray,
 	U32& drawcallCount) const
 {
-	// Get the buffers
+	// Get the resources
 	RenderingKey meshKey = key;
 	meshKey.m_lod = min<U>(key.m_lod, m_meshCount - 1);
 	const Mesh& mesh = getMesh(meshKey);
-	vertBuff = mesh.getVertexBuffer();
-	indexBuff = mesh.getIndexBuffer();
+	resourceGroup = m_grResources[meshKey.m_lod];
 
 	// Get ppline
 	RenderingKey mtlKey = key;
@@ -75,7 +103,22 @@ Error ModelPatch::create(
 {
 	ANKI_ASSERT(meshFNames.getSize() > 0);
 
-	// Load meshes
+	// Load material
+	ANKI_CHECK(m_mtl.load(mtlFName, manager));
+
+	// Iterate material variables for textures
+	ResourceGroupInitializer rcinit;
+
+	UpdateTexturesVisitor visitor;
+	visitor.m_init = &rcinit;
+
+	for(const auto& var : m_mtl->getVariables())
+	{
+		Error err = var->acceptVisitor(visitor);
+		(void)err;
+	}
+
+	// Load meshes and update resource group
 	m_meshCount = 0;
 	for(U i = 0; i < meshFNames.getSize(); i++)
 	{
@@ -88,12 +131,15 @@ Error ModelPatch::create(
 			return ErrorCode::USER_DATA;
 		}
 
+		rcinit.m_vertexBuffers[0].m_buffer = m_meshes[i]->getVertexBuffer();
+		rcinit.m_indexBuffer.m_buffer = m_meshes[i]->getIndexBuffer();
+
+		m_grResources[i] =
+			manager->getGrManager().newInstance<ResourceGroup>(rcinit);
+
 		++m_meshCount;
 	}
 
-	// Load material
-	ANKI_CHECK(m_mtl.load(mtlFName, manager));
-
 	return ErrorCode::NONE;
 }
 
@@ -119,7 +165,7 @@ PipelinePtr ModelPatch::getPipeline(const RenderingKey& key) const
 	// Lazily create it
 	if(ANKI_UNLIKELY(!ppline.isCreated()))
 	{
-		PipelinePtr::Initializer pplineInit;
+		PipelineInitializer pplineInit;
 		computePipelineInitializer(key, pplineInit);
 
 		pplineInit.m_shaders[U(ShaderType::VERTEX)] =
@@ -138,7 +184,8 @@ PipelinePtr ModelPatch::getPipeline(const RenderingKey& key) const
 			m_mtl->getShader(key, ShaderType::FRAGMENT);
 
 		// Create
-		ppline.create(&m_model->getManager().getGrManager(), pplineInit);
+		ppline = m_model->getManager().getGrManager()
+			.newInstance<Pipeline>(pplineInit);
 	}
 
 	return ppline;

src/resource/ParticleEmitterResource.cpp

@@ -254,7 +254,7 @@ Error ParticleEmitterResource::load(const ResourceFilename& filename)
 
 	pinit.m_inputAssembler.m_topology = PrimitiveTopology::POINTS;
 
-	m_ppline.create(&getManager().getGrManager(), pinit);
+	m_ppline = getManager().getGrManager().newInstance<Pipeline>(pinit);
 
 	return ErrorCode::NONE;
 }

src/resource/ShaderResource.cpp

@@ -42,10 +42,8 @@ Error ShaderResource::load(const ResourceFilename& filename,
 	source.append(pars.getShaderSource());
 
 	// Create
-	m_shader.create(
-		&getManager().getGrManager(),
-		pars.getShaderType(), &source[0],
-		source.getLength() + 1);
+	m_shader = getManager().getGrManager().newInstance<Shader>(
+		pars.getShaderType(), &source[0], source.getLength() + 1);
 
 	m_type = pars.getShaderType();
 
@@ -55,8 +53,7 @@ Error ShaderResource::load(const ResourceFilename& filename,
 //==============================================================================
 Error ShaderResource::createToCache(
 	const ResourceFilename& filename, const CString& preAppendedSrcCode,
-	const CString& filenamePrefix, ResourceManager& manager,
-	StringAuto& out)
+	const CString& filenamePrefix, ResourceManager& manager, StringAuto& out)
 {
 	auto alloc = manager.getTempAllocator();
 

src/resource/TextureResource.cpp

@@ -17,12 +17,10 @@ TextureResource::~TextureResource()
 Error TextureResource::load(const ResourceFilename& filename)
 {
 	GrManager& gr = getManager().getGrManager();
-	CommandBufferPtr cmdb;
-	cmdb.create(&gr); // Always first to avoid assertions (
-	                  // because of the check of the allocator)
+	// Always first to avoid assertions (because of the check of the allocator)
+	CommandBufferPtr cmdb = gr.newInstance<CommandBuffer>();
 
-	TexturePtr::Initializer init;
-	init.m_copyDataBeforeReturn = false;
+	TextureInitializer init;
 	U layers = 0;
 
 	// Load image
@@ -136,25 +134,27 @@ Error TextureResource::load(const ResourceFilename& filename)
 	init.m_sampling.m_anisotropyLevel =
 		getManager().getTextureAnisotropy();
 
-	// Now assign the data
+	// Create the texture
+	m_tex = gr.newInstance<Texture>(init);
+
+	// Upload the data
 	for(U layer = 0; layer < layers; layer++)
 	{
 		for(U level = 0; level < init.m_mipmapsCount; level++)
 		{
 			const auto& surf = img->getSurface(level, layer);
-			auto& grsurf = init.m_data[level][layer];
 
-			grsurf.m_size = surf.m_data.getSize();
-			grsurf.m_ptr = &surf.m_data[0];
+			void* data;
+			cmdb->textureUpload(
+				m_tex, level, layer, surf.m_data.getSize(), data);
+
+			memcpy(data, &surf.m_data[0], surf.m_data.getSize());
 		}
 	}
 
-	// Add the GL job to create the texture
-	m_tex.create(cmdb, init);
-
 	// Finaly enque the GL job chain
 	// TODO Make asynchronous
-	cmdb.finish();
+	cmdb->finish();
 
 	m_size = UVec3(init.m_width, init.m_height, init.m_depth);