GL refactoring

include/anki/core/App.h

@@ -24,7 +24,7 @@ class ConfigSet;
 class Threadpool;
 class NativeWindow;
 class Input;
-class GlDevice;
+class GrManager;
 class MainRenderer;
 class PhysicsWorld;
 class SceneGraph;
@@ -140,7 +140,7 @@ private:
 	// Sybsystems
 	NativeWindow* m_window = nullptr;
 	Input* m_input = nullptr;
-	GlDevice* m_gl = nullptr;
+	GrManager* m_gr = nullptr;
 	PhysicsWorld* m_physics = nullptr;
 	ResourceManager* m_resources = nullptr;
 	MainRenderer* m_renderer = nullptr;

include/anki/gr/TextureCommon.h

@@ -15,7 +15,7 @@ namespace anki {
 
 struct SurfaceData
 {
-	void* m_ptr = nullptr;
+	const void* m_ptr = nullptr;
 	PtrSize m_size = 0;
 };
 

include/anki/renderer/Dbg.h

@@ -58,7 +58,7 @@ public:
 	}
 
 private:
-	GlFramebufferHandle m_fb;
+	FramebufferHandle m_fb;
 	DebugDrawer* m_drawer = nullptr;
 	// Have it as ptr because the constructor calls opengl
 	SceneDebugDrawer* m_sceneDrawer = nullptr;
@@ -72,7 +72,7 @@ private:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
 
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& jobs);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& jobs);
 };
 
 /// @}

include/anki/renderer/DebugDrawer.h

@@ -37,14 +37,14 @@ public:
 	void drawCube(F32 size = 1.0);
 	void drawLine(const Vec3& from, const Vec3& to, const Vec4& color);
 
-	void prepareDraw(GlCommandBufferHandle& jobs)
+	void prepareDraw(CommandBufferHandle& jobs)
 	{
 		m_jobs = jobs;
 	}
 
 	void finishDraw()
 	{
-		m_jobs = GlCommandBufferHandle(); // Release job chain
+		m_jobs = CommandBufferHandle(); // Release job chain
 	}
 
 	/// @name Render functions. Imitate the GL 1.1 immediate mode
@@ -85,8 +85,8 @@ private:
 
 	ProgramResourcePointer m_frag;
 	ProgramResourcePointer m_vert;
-	GlPipelineHandle m_ppline;
-	GlCommandBufferHandle m_jobs;
+	PipelineHandle m_ppline;
+	CommandBufferHandle m_jobs;
 
 	static const U MAX_POINTS_PER_DRAW = 256;
 	Mat4 m_mMat;
@@ -97,7 +97,7 @@ private:
 	Vec3 m_crntCol;
 	GLenum m_primitive;
 
-	GlBufferHandle m_vertBuff;
+	BufferHandle m_vertBuff;
 
 	Array<Vertex, MAX_POINTS_PER_DRAW> m_clientLineVerts;
 	Array<Vertex, MAX_POINTS_PER_DRAW> m_clientTriVerts;

include/anki/renderer/Dp.h

@@ -24,18 +24,18 @@ public:
 	:	RenderingPass(r)
 	{}
 
-	GlTextureHandle& getSmallDepthRt()
+	TextureHandle& getSmallDepthRt()
 	{
 		return m_smallDepthRt;
 	}
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& cmdBuff);
 	/// @}
 
 private:
-	GlTextureHandle m_smallDepthRt; ///< A smaller depth buffer
-	GlFramebufferHandle m_smallDepthFb; ///< Used to blit
+	TextureHandle m_smallDepthRt; ///< A smaller depth buffer
+	FramebufferHandle m_smallDepthFb; ///< Used to blit
 	UVec2 m_smallDepthSize;
 };
 /// @}

include/anki/renderer/Drawer.h

@@ -39,7 +39,7 @@ public:
 	ANKI_USE_RESULT Error create(Renderer* r);
 
 	void prepareDraw(
-		RenderingStage stage, Pass pass, GlCommandBufferHandle& cmdBuff);
+		RenderingStage stage, Pass pass, CommandBufferHandle& cmdBuff);
 
 	ANKI_USE_RESULT Error render(
 		SceneNode& frsn,
@@ -49,12 +49,12 @@ public:
 
 private:
 	Renderer* m_r;
-	GlBufferHandle m_uniformBuff;
+	BufferHandle m_uniformBuff;
 	U8* m_uniformBuffMapAddr = nullptr;
 
 	/// @name State
 	/// @{
-	GlCommandBufferHandle m_cmdBuff;
+	CommandBufferHandle m_cmdBuff;
 	U8* m_uniformPtr;
 
 	/// Used to calc if the uni buffer is big enough. Zero it per swap buffers

include/anki/renderer/Ez.h

@@ -27,7 +27,7 @@ private:
 	{}
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& cmdBuff);
 };
 /// @}
 

include/anki/renderer/Fs.h

@@ -24,10 +24,10 @@ public:
 	~Fs();
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& cmdb);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& cmdb);
 
 private:
-	GlFramebufferHandle m_fb;
+	FramebufferHandle m_fb;
 };
 /// @}
 

include/anki/renderer/Hdr.h

@@ -50,7 +50,7 @@ public:
 
 	/// @privatesection
 	/// @{
-	GlTextureHandle& _getRt()
+	TextureHandle& _getRt()
 	{
 		return m_vblurRt;
 	}
@@ -72,24 +72,24 @@ private:
 	U32 m_blurringIterationsCount = 2; ///< The blurring iterations
 	F32 m_blurringDist = 1.0; ///< Distance in blurring
 	
-	GlFramebufferHandle m_hblurFb;
-	GlFramebufferHandle m_vblurFb;
+	FramebufferHandle m_hblurFb;
+	FramebufferHandle m_vblurFb;
 
 	ProgramResourcePointer m_toneFrag;
 	ProgramResourcePointer m_hblurFrag;
 	ProgramResourcePointer m_vblurFrag;
 
-	GlPipelineHandle m_tonePpline;
-	GlPipelineHandle m_hblurPpline;
-	GlPipelineHandle m_vblurPpline;
+	PipelineHandle m_tonePpline;
+	PipelineHandle m_hblurPpline;
+	PipelineHandle m_vblurPpline;
 
-	GlTextureHandle m_hblurRt; ///< pass0Fai with the horizontal blur FAI
-	GlTextureHandle m_vblurRt; ///< The final FAI
+	TextureHandle m_hblurRt; ///< pass0Fai with the horizontal blur FAI
+	TextureHandle m_vblurRt; ///< The final FAI
 	/// When a parameter changed by the setters
 	Timestamp m_parameterUpdateTimestamp = 0;
 	/// When the commonUbo got updated
 	Timestamp m_commonUboUpdateTimestamp = 0;
-	GlBufferHandle m_commonBuff;
+	BufferHandle m_commonBuff;
 
 	Hdr(Renderer* r)
 	:	RenderingPass(r)
@@ -98,12 +98,12 @@ private:
 	~Hdr();
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& jobs);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& jobs);
 
-	ANKI_USE_RESULT Error initFb(GlFramebufferHandle& fb, GlTextureHandle& rt);
+	ANKI_USE_RESULT Error initFb(FramebufferHandle& fb, TextureHandle& rt);
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 
-	ANKI_USE_RESULT Error updateDefaultBlock(GlCommandBufferHandle& jobs);
+	ANKI_USE_RESULT Error updateDefaultBlock(CommandBufferHandle& jobs);
 };
 
 /// @}

include/anki/renderer/Is.h

@@ -44,7 +44,7 @@ class Is: private RenderingPass
 public:
 	/// @privatesection
 	/// @{
-	GlTextureHandle& _getRt()
+	TextureHandle& _getRt()
 	{
 		return m_rt;
 	}
@@ -65,37 +65,37 @@ private:
 	U32 m_currentFrame = 0; ///< Cache value.
 
 	/// The IS render target
-	GlTextureHandle m_rt;
+	TextureHandle m_rt;
 
 	/// The IS FBO
-	GlFramebufferHandle m_fb;
+	FramebufferHandle m_fb;
 
 	/// @name GPU buffers
 	/// @{
 
 	/// Contains common data for all shader programs
-	GlBufferHandle m_commonBuffer;
+	BufferHandle m_commonBuffer;
 
 	/// Track the updates of commonUbo
 	Timestamp m_commonBuffUpdateTimestamp = 0;
 
 	/// Contains all the lights
-	Array<GlBufferHandle, MAX_FRAMES> m_lightsBuffers;
+	Array<BufferHandle, MAX_FRAMES> m_lightsBuffers;
 	Array<void*, MAX_FRAMES> m_lightsBufferAddresses;
 
 	/// Contains the number of lights per tile
-	Array<GlBufferHandle, MAX_FRAMES> m_tilesBuffers;
+	Array<BufferHandle, MAX_FRAMES> m_tilesBuffers;
 	Array<void*, MAX_FRAMES> m_tilesBufferAddresses;
 
 	/// Contains light indices.
-	Array<GlBufferHandle, MAX_FRAMES> m_lightIdsBuffers;
+	Array<BufferHandle, MAX_FRAMES> m_lightIdsBuffers;
 	Array<void*, MAX_FRAMES> m_lightIdsBufferAddresses;
 	/// @}
 
 	// Light shaders
 	ProgramResourcePointer m_lightVert;
 	ProgramResourcePointer m_lightFrag;
-	GlPipelineHandle m_lightPpline;
+	PipelineHandle m_lightPpline;
 
 	/// Shadow mapping
 	Sm m_sm;
@@ -110,7 +110,7 @@ private:
 
 	/// @name For drawing a quad into the active framebuffer
 	/// @{
-	GlBufferHandle m_quadPositionsVertBuff;
+	BufferHandle m_quadPositionsVertBuff;
 	/// @}
 
 	/// @name Limits
@@ -126,16 +126,16 @@ private:
 	~Is();
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& cmdBuff);
 
 	/// Called by init
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 
 	/// Do the actual pass
-	ANKI_USE_RESULT Error lightPass(GlCommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error lightPass(CommandBufferHandle& cmdBuff);
 
 	/// Prepare GL for rendering
-	void setState(GlCommandBufferHandle& cmdBuff);
+	void setState(CommandBufferHandle& cmdBuff);
 
 	/// Calculate the size of the lights UBO
 	PtrSize calcLightsBufferSize() const;
@@ -143,7 +143,7 @@ private:
 	/// Calculate the size of the tile
 	PtrSize calcTileSize() const;
 
-	ANKI_USE_RESULT Error updateCommonBlock(GlCommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error updateCommonBlock(CommandBufferHandle& cmdBuff);
 
 	// Binning
 	void binLights(U32 threadId, PtrSize threadsCount, TaskCommonData& data);

include/anki/renderer/Lf.h

@@ -29,37 +29,37 @@ public:
 
 	~Lf();
 
-	const GlTextureHandle& _getRt() const
+	const TextureHandle& _getRt() const
 	{
 		return m_rt;
 	}
 
-	GlTextureHandle& _getRt()
+	TextureHandle& _getRt()
 	{
 		return m_rt;
 	}
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
 
-	ANKI_USE_RESULT Error runOcclusionTests(GlCommandBufferHandle& cmdb);
+	ANKI_USE_RESULT Error runOcclusionTests(CommandBufferHandle& cmdb);
 
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& jobs);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& jobs);
 	/// @}
 
 private:
-	GlTextureHandle m_rt;
-	GlFramebufferHandle m_fb;
+	TextureHandle m_rt;
+	FramebufferHandle m_fb;
 
 	// Occlusion query
-	GlBufferHandle m_positionsVertBuff;
-	GlBufferHandle m_mvpBuff;
+	Array<BufferHandle, 3> m_positionsVertBuff;
+	BufferHandle m_mvpBuff;
 	ProgramResourcePointer m_occlusionVert;
 	ProgramResourcePointer m_occlusionFrag;
-	GlPipelineHandle m_occlusionPpline;
+	PipelineHandle m_occlusionPpline;
 
 	// Pseudo flares
 	ProgramResourcePointer m_pseudoFrag;
-	GlPipelineHandle m_pseudoPpline;
+	PipelineHandle m_pseudoPpline;
 	TextureResourcePointer m_lensDirtTex;
 	U8 m_maxSpritesPerFlare;
 	U8 m_maxFlares;
@@ -67,24 +67,23 @@ private:
 	// Sprite billboards
 	ProgramResourcePointer m_realVert;
 	ProgramResourcePointer m_realFrag;
-	GlPipelineHandle m_realPpline;
-	GlBufferHandle m_flareDataBuff;
+	PipelineHandle m_realPpline;
+	Array<BufferHandle, 3> m_flareDataBuff;
 	U32 m_flareSize;
 
 	// Final HDR blit
 	ProgramResourcePointer m_blitFrag;
-	GlPipelineHandle m_blitPpline;
+	PipelineHandle m_blitPpline;
 
 	ANKI_USE_RESULT Error initPseudo(
-		const ConfigSet& config, GlCommandBufferHandle& cmdBuff);
+		const ConfigSet& config, CommandBufferHandle& cmdBuff);
 	ANKI_USE_RESULT Error initSprite(
-		const ConfigSet& config, GlCommandBufferHandle& cmdBuff);
+		const ConfigSet& config, CommandBufferHandle& cmdBuff);
 	ANKI_USE_RESULT Error initOcclusion(
-		const ConfigSet& config, GlCommandBufferHandle& cmdBuff);
+		const ConfigSet& config, CommandBufferHandle& cmdBuff);
 
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 };
-
 /// @}
 
 } // end namespace anki

include/anki/renderer/MainRenderer.h

@@ -24,7 +24,7 @@ public:
 	ANKI_USE_RESULT Error create(
 		Threadpool* threadpool, 
 		ResourceManager* resources,
-		GlDevice* gl,
+		GrManager* gl,
 		HeapAllocator<U8>& alloc,
 		const ConfigSet& config,
 		const Timestamp* globalTimestamp);
@@ -38,10 +38,10 @@ public:
 
 private:
 	ProgramResourcePointer m_blitFrag;
-	GlPipelineHandle m_blitPpline;
+	PipelineHandle m_blitPpline;
 
 	/// Optimize job chain
-	Array<GlCommandBufferInitHints, JOB_CHAINS_COUNT> m_jobsInitHints; 
+	Array<CommandBufferInitHints, JOB_CHAINS_COUNT> m_jobsInitHints; 
 
 	void takeScreenshotTga(const char* filename);
 	ANKI_USE_RESULT Error initGl();

include/anki/renderer/Ms.h

@@ -23,22 +23,22 @@ class Ms: public RenderingPass
 public:
 	/// @privatesection
 	/// @{
-	GlTextureHandle& _getRt0()
+	TextureHandle& _getRt0()
 	{
 		return m_planes[1].m_rt0;
 	}
 
-	GlTextureHandle& _getRt1()
+	TextureHandle& _getRt1()
 	{
 		return m_planes[1].m_rt1;
 	}
 
-	GlTextureHandle& _getDepthRt()
+	TextureHandle& _getDepthRt()
 	{
 		return m_planes[1].m_depthRt;
 	}
 
-	GlFramebufferHandle& getFramebuffer()
+	FramebufferHandle& getFramebuffer()
 	{
 		return m_planes[1].m_fb;
 	}
@@ -49,16 +49,16 @@ private:
 	class Plane
 	{
 	public:
-		GlFramebufferHandle m_fb;
+		FramebufferHandle m_fb;
 
 		/// Contains diffuse color and part of specular
-		GlTextureHandle m_rt0; 
+		TextureHandle m_rt0; 
 
 		/// Contains the normal and spec power
-		GlTextureHandle m_rt1;
+		TextureHandle m_rt1;
 
 		/// Depth stencil
-		GlTextureHandle m_depthRt;
+		TextureHandle m_depthRt;
 	};
 
 	Ez m_ez; /// EarlyZ pass
@@ -75,7 +75,7 @@ private:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& jobs);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& jobs);
 
 	/// Create a G buffer FBO
 	ANKI_USE_RESULT Error createRt(U32 index, U32 samples);

include/anki/renderer/Pps.h

@@ -77,11 +77,11 @@ public:
 
 	/// @privatesection
 	/// @{
-	const GlTextureHandle& _getRt() const
+	const TextureHandle& _getRt() const
 	{
 		return m_rt;
 	}
-	GlTextureHandle& _getRt()
+	TextureHandle& _getRt()
 	{
 		return m_rt;
 	}
@@ -94,16 +94,16 @@ private:
 	Lf m_lf;
 	Sslr m_sslr;
 
-	GlFramebufferHandle m_fb;
+	FramebufferHandle m_fb;
 	ProgramResourcePointer m_frag;
-	GlPipelineHandle m_ppline;
-	GlTextureHandle m_rt;
+	PipelineHandle m_ppline;
+	TextureHandle m_rt;
 
 	Pps(Renderer* r);
 	~Pps();
 
 	ANKI_USE_RESULT Error init(const ConfigSet& config);
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& jobs);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& jobs);
 
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& config);
 };

include/anki/renderer/Renderer.h

@@ -187,19 +187,19 @@ public:
 		return m_tilesCountXY;
 	}
 
-	const Gr.haderHandle& getDrawQuadVertexProgram() const
+	const ShaderHandle& getDrawQuadVertexProgram() const
 	{
 		return m_drawQuadVert->getGlProgram();
 	}
 
-	GlFramebufferHandle& getDefaultFramebuffer()
+	FramebufferHandle& getDefaultFramebuffer()
 	{
 		return m_defaultFb;
 	}
 
 	/// This function does all the rendering stages and produces a final FAI
 	ANKI_USE_RESULT Error render(SceneGraph& scene, 
-		Array<GlCommandBufferHandle, JOB_CHAINS_COUNT>& cmdBuff);
+		Array<CommandBufferHandle, JOB_CHAINS_COUNT>& cmdBuff);
 
 	/// My version of gluUnproject
 	/// @param windowCoords Window screen coords
@@ -213,12 +213,12 @@ public:
 
 	/// Draws a quad. Actually it draws 2 triangles because OpenGL will no
 	/// longer support quads
-	void drawQuad(GlCommandBufferHandle& cmdBuff);
+	void drawQuad(CommandBufferHandle& cmdBuff);
 
 	void drawQuadConditional(
-		GlOcclusionQueryHandle& q, GlCommandBufferHandle& cmdBuff);
+		OcclusionQueryHandle& q, CommandBufferHandle& cmdBuff);
 
-	void drawQuadInstanced(GlCommandBufferHandle& cmdBuff, U32 primitiveCount);
+	void drawQuadInstanced(CommandBufferHandle& cmdBuff, U32 primitiveCount);
 
 	/// Get the LOD given the distance of an object from the camera
 	F32 calculateLod(F32 distance) const
@@ -229,26 +229,26 @@ public:
 	/// Create a framebuffer attachment texture
 	ANKI_USE_RESULT Error createRenderTarget(U32 w, U32 h, 
 		GLenum internalFormat, U32 samples, 
-		GlTextureHandle& rt);
+		TextureHandle& rt);
 
 	/// Create a pipeline object that has as a vertex shader the m_drawQuadVert
 	/// and the given fragment progam
 	ANKI_USE_RESULT Error createDrawQuadPipeline(
-		Gr.haderHandle frag, GlPipelineHandle& ppline);
+		ShaderHandle frag, PipelineHandle& ppline);
 
 	/// Init the renderer given an initialization class
 	/// @param initializer The initializer class
 	ANKI_USE_RESULT Error init(
 		Threadpool* threadpool, 
 		ResourceManager* resources,
-		GlDevice* gl,
+		GrManager* gl,
 		HeapAllocator<U8>& alloc,
 		const ConfigSet& config,
 		const Timestamp* globalTimestamp);
 
 	/// @privatesection
 	/// @{
-	GlDevice& _getGlDevice()
+	GrManager& _getGrManager()
 	{
 		return *m_gl;
 	}
@@ -282,7 +282,7 @@ public:
 private:
 	Threadpool* m_threadpool;
 	ResourceManager* m_resources;
-	GlDevice* m_gl;
+	GrManager* m_gl;
 	HeapAllocator<U8> m_alloc;
 	const Timestamp* m_globalTimestamp = nullptr;
 
@@ -312,7 +312,7 @@ private:
 
 	/// @name For drawing a quad into the active framebuffer
 	/// @{
-	GlBufferHandle m_quadPositionsBuff; ///< The VBO for quad positions
+	BufferHandle m_quadPositionsBuff; ///< The VBO for quad positions
 	ProgramResourcePointer m_drawQuadVert;
 	/// @}
 
@@ -332,7 +332,7 @@ private:
 
 	U m_framesNum; ///< Frame number
 
-	GlFramebufferHandle m_defaultFb;
+	FramebufferHandle m_defaultFb;
 
 	String m_shadersPrependedSource; ///< String to append in user shaders
 

include/anki/renderer/RenderingPass.h

@@ -50,8 +50,8 @@ protected:
 
 	HeapAllocator<U8>& getAllocator();
 
-	GlDevice& getGlDevice();
-	const GlDevice& getGlDevice() const;
+	GrManager& getGrManager();
+	const GrManager& getGrManager() const;
 
 	ResourceManager& getResourceManager();
 };
@@ -69,10 +69,10 @@ protected:
 	class Direction
 	{
 	public:
-		GlFramebufferHandle m_fb;
-		GlTextureHandle m_rt; 
+		FramebufferHandle m_fb;
+		TextureHandle m_rt; 
 		ProgramResourcePointer m_frag;
-		GlPipelineHandle m_ppline;
+		PipelineHandle m_ppline;
 	};
 
 	enum class DirectionEnum: U
@@ -86,7 +86,7 @@ protected:
 	ANKI_USE_RESULT Error initBlurring(Renderer& r, U width, U height, U samples, 
 		F32 blurringDistance);
 
-	ANKI_USE_RESULT Error runBlurring(Renderer& r, GlCommandBufferHandle& jobs);
+	ANKI_USE_RESULT Error runBlurring(Renderer& r, CommandBufferHandle& jobs);
 };
 
 /// @}

include/anki/renderer/Sm.h

@@ -41,13 +41,13 @@ public:
 	/// @}
 
 private:
-	GlTextureHandle m_sm2DArrayTex;
+	TextureHandle m_sm2DArrayTex;
 
 	/// Shadowmap
 	struct Shadowmap
 	{
 		U32 m_layerId;
-		GlFramebufferHandle m_fb;
+		FramebufferHandle m_fb;
 		SceneNode* m_light = nullptr;
 		U32 m_timestamp = 0; ///< Timestamp of last render or light change
 	};
@@ -79,7 +79,7 @@ private:
 	ANKI_USE_RESULT Error run(
 		SceneNode* shadowCasters[], 
 		U32 shadowCastersCount, 
-		GlCommandBufferHandle& cmdBuff);
+		CommandBufferHandle& cmdBuff);
 
 	/// Get max shadow casters
 	U32 getMaxLightsCount()
@@ -87,14 +87,14 @@ private:
 		return m_sms.getSize();
 	}
 
-	void prepareDraw(GlCommandBufferHandle& cmdBuff);
-	void finishDraw(GlCommandBufferHandle& cmdBuff);
+	void prepareDraw(CommandBufferHandle& cmdBuff);
+	void finishDraw(CommandBufferHandle& cmdBuff);
 
 	/// Find the best shadowmap for that light
 	Shadowmap& bestCandidate(SceneNode& light);
 
 	ANKI_USE_RESULT Error doLight(
-		SceneNode& light, GlCommandBufferHandle& cmdBuff, Shadowmap*& sm);
+		SceneNode& light, CommandBufferHandle& cmdBuff, Shadowmap*& sm);
 };
 
 /// @}

include/anki/renderer/Ssao.h

@@ -25,7 +25,7 @@ class Ssao: public RenderingPass
 	friend class Sslr;
 	friend class MainRenderer;
 
-	GlTextureHandle& _getRt()
+	TextureHandle& _getRt()
 	{
 		return m_vblurRt;
 	}
@@ -34,31 +34,31 @@ private:
 	U32 m_width, m_height; ///< Blur passes size
 	U8 m_blurringIterationsCount;
 
-	GlTextureHandle m_vblurRt;
-	GlTextureHandle m_hblurRt;
-	GlFramebufferHandle m_vblurFb;
-	GlFramebufferHandle m_hblurFb;
+	TextureHandle m_vblurRt;
+	TextureHandle m_hblurRt;
+	FramebufferHandle m_vblurFb;
+	FramebufferHandle m_hblurFb;
 
 	ProgramResourcePointer m_ssaoFrag;
 	ProgramResourcePointer m_hblurFrag;
 	ProgramResourcePointer m_vblurFrag;
-	GlPipelineHandle m_ssaoPpline;
-	GlPipelineHandle m_hblurPpline;
-	GlPipelineHandle m_vblurPpline;
+	PipelineHandle m_ssaoPpline;
+	PipelineHandle m_hblurPpline;
+	PipelineHandle m_vblurPpline;
 	
 	Timestamp m_commonUboUpdateTimestamp = 0;
-	GlBufferHandle m_uniformsBuff;
-	GlTextureHandle m_noiseTex;
+	BufferHandle m_uniformsBuff;
+	TextureHandle m_noiseTex;
 
 	Ssao(Renderer* r)
 	:	RenderingPass(r)
 	{}
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& cmdBuff);
 
 	ANKI_USE_RESULT Error createFb(
-		GlFramebufferHandle& fb, GlTextureHandle& rt);
+		FramebufferHandle& fb, TextureHandle& rt);
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 };
 

include/anki/renderer/Sslr.h

@@ -23,7 +23,7 @@ class Sslr: public BlurringRenderingPass
 public:
 	/// @privatesection
 	/// @{
-	GlTextureHandle& _getRt()
+	TextureHandle& _getRt()
 	{
 		return m_dirs[(U)DirectionEnum::VERTICAL].m_rt;
 	}
@@ -35,19 +35,19 @@ private:
 
 	// 1st pass
 	ProgramResourcePointer m_reflectionFrag;
-	GlPipelineHandle m_reflectionPpline;
-	GlSamplerHandle m_depthMapSampler;
+	PipelineHandle m_reflectionPpline;
+	SamplerHandle m_depthMapSampler;
 
 	// 2nd pass: blit
 	ProgramResourcePointer m_blitFrag;
-	GlPipelineHandle m_blitPpline;
+	PipelineHandle m_blitPpline;
 
 	Sslr(Renderer* r)
 	:	BlurringRenderingPass(r)
 	{}
 
 	ANKI_USE_RESULT Error init(const ConfigSet& config);
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& cmdBuff);
 };
 
 /// @}

include/anki/renderer/Tiler.h

@@ -74,8 +74,8 @@ public:
 	Error init();
 
 	/// Issue the GPU job
-	void runMinMax(GlTextureHandle& depthMap,
-		GlCommandBufferHandle& cmd);
+	void runMinMax(TextureHandle& depthMap,
+		CommandBufferHandle& cmd);
 
 	/// Update the tiles before doing visibility tests
 	void updateTiles(Camera& cam);
@@ -86,7 +86,7 @@ public:
 
 	/// @privatesection
 	/// @{
-	GlTextureHandle& getRt()
+	TextureHandle& getRt()
 	{
 		return m_rt;
 	}
@@ -104,19 +104,19 @@ private:
 
 	/// A texture of tilesXCount * tilesYCount size and format RG32UI. Used to
 	/// calculate the near and far planes of the tiles
-	GlTextureHandle m_rt;
+	TextureHandle m_rt;
 
 	/// Main FB for the fai
-	GlFramebufferHandle m_fb;
+	FramebufferHandle m_fb;
 
 	/// PBO buffer that is used to read the data of fai asynchronously
-	Array<GlBufferHandle, 2> m_pbos;
+	Array<BufferHandle, 2> m_pbos;
 	Array<Vec2*, 2> m_pbosAddress;
 	DArray<Vec2> m_prevMinMaxDepth;
 
 	/// Main shader program
 	ProgramResourcePointer m_frag;
-	GlPipelineHandle m_ppline;
+	PipelineHandle m_ppline;
 
 	/// Used to check if the camera is changed and we need to update the planes
 	const Camera* m_prevCam = nullptr;

include/anki/resource/Common.h

@@ -13,7 +13,7 @@
 namespace anki {
 
 // Forward
-class GlDevice;
+class GrManager;
 class ResourceManager;
 
 /// @addtogroup resource
@@ -57,13 +57,6 @@ public:
 /// @{
 
 // Sortcut
-#define ANKI_CHECK(x_) \
-	err = x_; \
-	if(ANKI_UNLIKELY(err)) \
-	{ \
-		return err; \
-	}
-
 #define ANKI_CHECK_C(x_) \
 	err = x_; \
 	if(ANKI_UNLIKELY(err)) \

include/anki/resource/Model.h

@@ -70,8 +70,8 @@ public:
 	/// offsets and counts
 	ANKI_USE_RESULT Error getRenderingDataSub(
 		const RenderingKey& key, 
-		GlCommandBufferHandle& vertJobs,
-		GlPipelineHandle& ppline,
+		CommandBufferHandle& vertJobs,
+		PipelineHandle& ppline,
 		const U8* subMeshIndicesArray, 
 		U32 subMeshIndicesCount,
 		Array<U32, ANKI_GL_MAX_SUB_DRAWCALLS>& indicesCountArray,
@@ -81,20 +81,20 @@ public:
 protected:
 	ResourceAllocator<U8> m_alloc;
 	/// Array [lod][pass]
-	ResourceDArray<GlCommandBufferHandle> m_vertJobs;
+	ResourceDArray<CommandBufferHandle> m_vertJobs;
 	Material* m_mtl = nullptr;
 	ResourceDArray<Mesh*> m_meshes; ///< One for each LOD
 
 	/// Create vertex descriptors using a material and a mesh
-	ANKI_USE_RESULT Error create(GlDevice* gl);
+	ANKI_USE_RESULT Error create(GrManager* gr);
 
 private:
 	/// Called by @a create multiple times to create and populate a single
 	/// vertex descriptor
 	static ANKI_USE_RESULT Error createVertexDesc(
-		const Gr.haderHandle& prog,
+		const ShaderHandle& prog,
 		const Mesh& mesh,
-		GlCommandBufferHandle& vertexJobs);
+		CommandBufferHandle& vertexJobs);
 
 	/// Return the maximum number of LODs
 	U getLodsCount() const;

include/anki/resource/TextureResource.h

@@ -33,7 +33,7 @@ public:
 		const CString& filename, ResourceInitializer& init);
 
 	/// Get the GL texture
-	const GlTextureHandle& getGlTexture() const
+	const TextureHandle& getGlTexture() const
 	{
 		return m_tex;
 	}
@@ -60,7 +60,7 @@ public:
 	}
 
 private:
-	GlTextureHandle m_tex;
+	TextureHandle m_tex;
 	UVec3 m_size;
 };
 /// @}

include/anki/scene/LensFlareComponent.h

@@ -67,19 +67,19 @@ public:
 		return m_colorMul;
 	}
 
-	GlTextureHandle getTexture() const
+	TextureHandle getTexture() const
 	{
 		return m_tex->getGlTexture();
 	}
 
-	GlOcclusionQueryHandle& getOcclusionQueryToTest();
+	OcclusionQueryHandle& getOcclusionQueryToTest();
 
 	/// Get the occlusion query to test.
 	/// @param[out] q The returned query.
 	/// @param[out] queryInvalid It's true if the query has an old result that
 	///             cannot be used.
 	void getOcclusionQueryToCheck(
-		GlOcclusionQueryHandle& q, Bool& queryInvalid);
+		OcclusionQueryHandle& q, Bool& queryInvalid);
 
 	/// @name SceneComponent virtuals
 	/// @{
@@ -105,7 +105,7 @@ private:
 	Vec2 m_firstFlareSize = Vec2(1.0);
 	Vec2 m_otherFlareSize = Vec2(1.0);
 
-	Array<GlOcclusionQueryHandle, 3> m_queries;
+	Array<OcclusionQueryHandle, 3> m_queries;
 	Array<Timestamp, 3> m_queryTestTimestamp = {{MAX_U32, MAX_U32, MAX_U32}};
 	U8 m_crntQueryIndex = 0;
 	

include/anki/scene/ParticleEmitter.h

@@ -190,7 +190,7 @@ private:
 
 	U32 m_aliveParticlesCount = 0;
 
-	GlBufferHandle m_vertBuff; ///< Hold the vertex data
+	BufferHandle m_vertBuff; ///< Hold the vertex data
 	U8* m_vertBuffMapping = nullptr; 
 
 	SimulationType m_simulationType = SimulationType::UNDEFINED;

include/anki/scene/RenderComponent.h

@@ -215,7 +215,7 @@ public:
 	RenderingKey m_key;
 	const U8* m_subMeshIndicesArray; ///< @note indices != drawing indices
 	U32 m_subMeshIndicesCount;
-	GlCommandBufferHandle m_jobs; ///< A job chain 
+	CommandBufferHandle m_jobs; ///< A job chain 
 };
 
 /// RenderComponent interface. Implemented by renderable scene nodes

include/anki/scene/SceneGraph.h

@@ -166,9 +166,9 @@ public:
 		return *m_resources;
 	}
 
-	GlDevice& _getGlDevice()
+	GrManager& getGrManager()
 	{
-		return *m_gl;
+		return *m_gr;
 	}
 
 	PhysicsWorld& _getPhysicsWorld()
@@ -189,7 +189,7 @@ private:
 
 	Threadpool* m_threadpool = nullptr;
 	ResourceManager* m_resources = nullptr;
-	GlDevice* m_gl = nullptr;
+	GrManager* m_gr = nullptr;
 	PhysicsWorld* m_physics = nullptr;
 	Input* m_input = nullptr;
 

include/anki/util/StdTypes.h

@@ -154,6 +154,13 @@ private:
 	ErrorCode m_code = ErrorCode::NONE;
 };
 
+#define ANKI_CHECK(x_) \
+	do { \
+		Error error = x_; \
+		if(ANKI_UNLIKELY(error)) { \
+			return error; \
+		} \
+	} while(0)
 /// @}
 
 } // end namespace anki

src/core/App.cpp

@@ -75,10 +75,10 @@ void App::cleanup()
 		m_physics = nullptr;
 	}
 
-	if(m_gl != nullptr)
+	if(m_gr != nullptr)
 	{
-		m_heapAlloc.deleteInstance(m_gl);
-		m_gl = nullptr;
+		m_heapAlloc.deleteInstance(m_gr);
+		m_gr = nullptr;
 	}
 
 	if(m_threadpool != nullptr)
@@ -118,14 +118,12 @@ Error App::create(const ConfigSet& config,
 Error App::createInternal(const ConfigSet& config_, 
 	AllocAlignedCallback allocCb, void* allocCbUserData)
 {
-	Error err = ErrorCode::NONE;
 	m_allocCb = allocCb;
 	m_allocCbData = allocCbUserData;
 	m_heapAlloc = HeapAllocator<U8>(allocCb, allocCbUserData);
 	ConfigSet config = config_;
 
-	err = initDirs();
-	if(err) return err;
+	ANKI_CHECK(initDirs());
 
 	// Print a message
 	const char* buildType =
@@ -147,13 +145,11 @@ Error App::createInternal(const ConfigSet& config_,
 	m_timerTick = 1.0 / 60.0; // in sec. 1.0 / period
 
 #if ANKI_ENABLE_COUNTERS
-	err = CountersManagerSingleton::get().create(
-		m_heapAlloc, m_settingsDir.toCString(), &m_globalTimestamp);
-	if(err) return err;
+	ANKI_CHECK(CountersManagerSingleton::get().create(
+		m_heapAlloc, m_settingsDir.toCString(), &m_globalTimestamp));
 
-	err = TraceManagerSingleton::get().create(
-		m_heapAlloc, m_settingsDir.toCString());
-	if(err) return err;
+	ANKI_CHECK(TraceManagerSingleton::get().create(
+		m_heapAlloc, m_settingsDir.toCString()));
 #endif
 
 	//
@@ -171,8 +167,7 @@ Error App::createInternal(const ConfigSet& config_,
 	m_window = m_heapAlloc.newInstance<NativeWindow>();
 	if(!m_window) return ErrorCode::OUT_OF_MEMORY;
 
-	err = m_window->create(nwinit, m_heapAlloc);
-	if(err) return err;
+	ANKI_CHECK(m_window->create(nwinit, m_heapAlloc));
 
 	m_ctx = m_window->getCurrentContext();
 	m_window->contextMakeCurrent(nullptr);
@@ -183,8 +178,7 @@ Error App::createInternal(const ConfigSet& config_,
 	m_input = m_heapAlloc.newInstance<Input>();
 	if(!m_input) return ErrorCode::OUT_OF_MEMORY;
 
-	err = m_input->create(m_window);
-	if(err) return err;
+	ANKI_CHECK(m_input->create(m_window));
 
 	//
 	// Threadpool
@@ -195,32 +189,41 @@ Error App::createInternal(const ConfigSet& config_,
 	//
 	// GL
 	//
-	m_gl = m_heapAlloc.newInstance<GlDevice>();
-	if(!m_gl) return ErrorCode::OUT_OF_MEMORY;
+	m_gr = m_heapAlloc.newInstance<GrManager>();
+	if(!m_gr)
+	{
+		return ErrorCode::OUT_OF_MEMORY;
+	}
 
-	err = m_gl->create(m_allocCb, m_allocCbData, m_cacheDir.toCString());
-	if(err) return err;
+	GrManagerInitializer grInit;
+	grInit.m_allocCallback = m_allocCb;
+	grInit.m_allocCallbackUserData = m_allocCbData;
+	grInit.m_makeCurrentCallback = makeCurrent;
+	grInit.m_makeCurrentCallbackData = this;
+	grInit.m_ctx = m_ctx;
+	grInit.m_swapBuffersCallback = swapWindow;
+	grInit.m_swapBuffersCallbackData = m_window;
+	grInit.m_cacheDirectory = m_cacheDir.toCString();
+	grInit.m_registerDebugMessages = nwinit.m_debugContext;
 
-	err = m_gl->startServer(
-		makeCurrent, this, m_ctx,
-		swapWindow, m_window,
-		nwinit.m_debugContext);
-	if(err) return err;
+	ANKI_CHECK(m_gr->create(grInit));
 
 	//
 	// Physics
 	//
 	m_physics = m_heapAlloc.newInstance<PhysicsWorld>();
-	if(!m_gl) return ErrorCode::OUT_OF_MEMORY;
+	if(!m_physics)
+	{
+		return ErrorCode::OUT_OF_MEMORY;
+	}
 
-	err = m_physics->create(m_allocCb, m_allocCbData);
-	if(err) return err;
+	ANKI_CHECK(m_physics->create(m_allocCb, m_allocCbData));
 
 	//
 	// Resources
 	//
 	ResourceManager::Initializer rinit;
-	rinit.m_gl = m_gl;
+	rinit.m_gr = m_gr;
 	rinit.m_physics = m_physics;
 	rinit.m_config = &config;
 	rinit.m_cacheDir = m_cacheDir.toCString();
@@ -230,8 +233,7 @@ Error App::createInternal(const ConfigSet& config_,
 	m_resources = m_heapAlloc.newInstance<ResourceManager>();
 	if(!m_resources) return ErrorCode::OUT_OF_MEMORY;
 
-	err = m_resources->create(rinit);
-	if(err) return err;
+	ANKI_CHECK(m_resources->create(rinit));
 
 	//
 	// Renderer
@@ -245,37 +247,33 @@ Error App::createInternal(const ConfigSet& config_,
 	m_renderer = m_heapAlloc.newInstance<MainRenderer>();
 	if(!m_renderer) return ErrorCode::OUT_OF_MEMORY;
 
-	err = m_renderer->create(
+	ANKI_CHECK(m_renderer->create(
 		m_threadpool,
 		m_resources,
-		m_gl,
+		m_gr,
 		m_heapAlloc,
 		config,
-		&m_globalTimestamp);
-	if(err) return err;
+		&m_globalTimestamp));
 
-	err = m_resources->_setShadersPrependedSource(
-		m_renderer->_getShadersPrependedSource().toCString());
-	if(err) return err;
+	ANKI_CHECK(m_resources->_setShadersPrependedSource(
+		m_renderer->_getShadersPrependedSource().toCString()));
 
 	// Scene
 	m_scene = m_heapAlloc.newInstance<SceneGraph>();
 	if(!m_scene) return ErrorCode::OUT_OF_MEMORY;
 
-	err = m_scene->create(m_allocCb, m_allocCbData, 
+	ANKI_CHECK(m_scene->create(m_allocCb, m_allocCbData, 
 		config.get("sceneFrameAllocatorSize"), m_threadpool, m_resources,
-		m_input, &m_globalTimestamp);
-	if(err) return err;
+		m_input, &m_globalTimestamp));
 
 	// Script
 	m_script = m_heapAlloc.newInstance<ScriptManager>();
 	if(!m_script) return ErrorCode::OUT_OF_MEMORY;
 		
-	err = m_script->create(m_allocCb, m_allocCbData, m_scene);
-	if(err) return err;
+	ANKI_CHECK(m_script->create(m_allocCb, m_allocCbData, m_scene));
 
 	ANKI_LOGI("Application initialized");
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -299,29 +297,24 @@ Error App::initDirs()
 	// Settings path
 	String home;
 	String::ScopeDestroyer homed(&home, m_heapAlloc);
-	Error err = getHomeDirectory(m_heapAlloc, home);
-	if(err) return err;
+	ANKI_CHECK(getHomeDirectory(m_heapAlloc, home));
 
-	err = m_settingsDir.sprintf(m_heapAlloc, "%s/.anki", &home[0]);
-	if(err) return err;
+	ANKI_CHECK(m_settingsDir.sprintf(m_heapAlloc, "%s/.anki", &home[0]));
 
 	if(!directoryExists(m_settingsDir.toCString()))
 	{
-		err = createDirectory(m_settingsDir.toCString());
-		if(err) return err;
+		ANKI_CHECK(createDirectory(m_settingsDir.toCString()));
 	}
 
 	// Cache
-	err = m_cacheDir.sprintf(m_heapAlloc, "%s/cache", &m_settingsDir[0]);
-	if(err) return err;
+	ANKI_CHECK(m_cacheDir.sprintf(m_heapAlloc, "%s/cache", &m_settingsDir[0]));
 
 	if(directoryExists(m_cacheDir.toCString()))
 	{
-		err = removeDirectory(m_cacheDir.toCString());
-		if(err) return err;
+		ANKI_CHECK(removeDirectory(m_cacheDir.toCString()));
 	}
 
-	err = createDirectory(m_cacheDir.toCString());
+	ANKI_CHECK(createDirectory(m_cacheDir.toCString()));
 #else
 	//ANKI_ASSERT(gAndroidApp);
 	//ANativeActivity* activity = gAndroidApp->activity;
@@ -344,13 +337,12 @@ Error App::initDirs()
 	createDirectory(cacheDir.c_str());
 #endif
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error App::mainLoop(UserMainLoopCallback callback, void* userData)
 {
-	Error err = ErrorCode::NONE;
 	ANKI_LOGI("Entering main loop");
 	Bool quit = false;
 
@@ -367,20 +359,16 @@ Error App::mainLoop(UserMainLoopCallback callback, void* userData)
 		crntTime = HighRezTimer::getCurrentTime();
 
 		// Update
-		err = m_input->handleEvents();
-		if(err)	break;
+		ANKI_CHECK(m_input->handleEvents());
 
 		// User update
-		err = callback(*this, userData, quit);
-		if(err)	break;
+		ANKI_CHECK(callback(*this, userData, quit));
 
-		err = m_scene->update(prevUpdateTime, crntTime, *m_renderer);
-		if(err)	break;
+		ANKI_CHECK(m_scene->update(prevUpdateTime, crntTime, *m_renderer));
 
-		err = m_renderer->render(*m_scene);
-		if(err)	break;
+		ANKI_CHECK(m_renderer->render(*m_scene));
 
-		m_gl->swapBuffers();
+		m_gr->swapBuffers();
 		ANKI_COUNTERS_RESOLVE_FRAME();
 
 		// Sleep
@@ -398,7 +386,7 @@ Error App::mainLoop(UserMainLoopCallback callback, void* userData)
 	ANKI_COUNTERS_FLUSH();
 	ANKI_TRACE_FLUSH();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/gr/gl/BufferHandle.cpp

@@ -230,6 +230,11 @@ void BufferHandle::write(CommandBufferHandle& commands,
 	PtrSize size)
 {
 	ANKI_ASSERT(isCreated());
+
+	void* newData = commands.get().getInternalAllocator().allocate(size);
+	memcpy(newData, static_cast<const U8*>(data) + readOffset, size);
+	data = newData;
+
 	commands.get().pushBackNewCommand<BufferWriteCommand>(
 		*this, data, dataSize, readOffset, writeOffset, size);
 }

src/gr/gl/TextureHandle.cpp

@@ -133,12 +133,33 @@ TextureHandle::~TextureHandle()
 
 //==============================================================================
 Error TextureHandle::create(
-	CommandBufferHandle& commands, const Initializer& init)
+	CommandBufferHandle& commands, const Initializer& initS)
 {
 	ANKI_ASSERT(!isCreated());
+	Initializer init;
+	memcpy(&init, &initS, sizeof(init));
 
-	using DeleteCommand = DeleteObjectCommand<TextureImpl>;
+	// Copy data to temp buffers
+	if(init.m_copyDataBeforeReturn)
+	{
+		for(U layer = 0; layer < MAX_TEXTURE_LAYERS; ++layer)
+		{
+			for(U level = 0; level < MAX_MIPMAPS; ++level)
+			{
+				SurfaceData& surf = init.m_data[level][layer];
+				if(surf.m_ptr)
+				{
+					void* newData = commands.get().getInternalAllocator().
+						allocate(surf.m_size);
+
+					memcpy(newData, surf.m_ptr, surf.m_size);
+					surf.m_ptr = newData;
+				}
+			}
+		}
+	}
 
+	using DeleteCommand = DeleteObjectCommand<TextureImpl>;
 	using Deleter = DeferredDeleter<TextureImpl, DeleteCommand>;
 
 	Error err = Base::create(commands.get().getManager(), Deleter());

src/renderer/Dbg.cpp

@@ -39,8 +39,8 @@ Error Dbg::init(const ConfigSet& initializer)
 	m_enabled = initializer.get("dbg.enabled");
 	enableBits(Flag::ALL);
 
-	GlDevice& gl = getGlDevice();
-	GlCommandBufferHandle cmdb;
+	GrManager& gl = getGrManager();
+	CommandBufferHandle cmdb;
 	err = cmdb.create(&gl);
 	if(err)
 	{
@@ -48,19 +48,19 @@ Error Dbg::init(const ConfigSet& initializer)
 	}
 
 	// Chose the correct color FAI
+	FramebufferHandle::Initializer fbInit;
+	fbInit.m_colorAttachmentsCount = 1;
+	fbInit.m_depthStencilAttachment.m_texture = m_r->getMs()._getDepthRt();
 	if(m_r->getPps().getEnabled())
 	{
-		err = m_fb.create(cmdb, 
-			{{m_r->getPps()._getRt(), GL_COLOR_ATTACHMENT0},
-			{m_r->getMs()._getDepthRt(), GL_DEPTH_ATTACHMENT}});
+		fbInit.m_colorAttachments[0].m_texture = m_r->getPps()._getRt();
 	}
 	else
 	{
-		err = m_fb.create(cmdb, 
-			{{m_r->getIs()._getRt(), GL_COLOR_ATTACHMENT0},
-			{m_r->getMs()._getDepthRt(), GL_DEPTH_ATTACHMENT}});
+		fbInit.m_colorAttachments[0].m_texture = m_r->getIs()._getRt();
 	}
 
+	err = m_fb.create(cmdb, fbInit);
 	if(!err)
 	{
 		m_drawer = getAllocator().newInstance<DebugDrawer>();
@@ -93,7 +93,7 @@ Error Dbg::init(const ConfigSet& initializer)
 }
 
 //==============================================================================
-Error Dbg::run(GlCommandBufferHandle& cmdb)
+Error Dbg::run(CommandBufferHandle& cmdb)
 {
 	Error err = ErrorCode::NONE;
 

src/renderer/DebugDrawer.cpp

@@ -31,7 +31,7 @@ Error DebugDrawer::create(Renderer* r)
 {
 	Error err = ErrorCode::NONE;
 
-	GlDevice& gl = r->_getGlDevice();
+	GrManager& gl = r->_getGrManager();
 
 	err = m_vert.load("shaders/Dbg.vert.glsl", &r->_getResourceManager());
 
@@ -40,7 +40,7 @@ Error DebugDrawer::create(Renderer* r)
 		err = m_frag.load("shaders/Dbg.frag.glsl", &r->_getResourceManager());
 	}
 
-	GlCommandBufferHandle jobs;
+	CommandBufferHandle jobs;
 
 	if(!err)
 	{
@@ -55,7 +55,7 @@ Error DebugDrawer::create(Renderer* r)
 
 	if(!err)
 	{
-		err = m_vertBuff.create(jobs, GL_ARRAY_BUFFER, 
+		err = m_vertBuff.create(jobs, GL_ARRAY_BUFFER, nullptr,
 			sizeof(m_clientLineVerts), GL_DYNAMIC_STORAGE_BIT);
 	}
 
@@ -159,16 +159,7 @@ Error DebugDrawer::flushInternal(GLenum primitive)
 
 	U size = sizeof(Vertex) * clientVerts;
 
-	GlClientBufferHandle tmpBuff;
-	err = tmpBuff.create(m_jobs, size, nullptr);
-	if(err)
-	{
-		return err;
-	}
-
-	memcpy(tmpBuff.getBaseAddress(), vertBuff, size);
-
-	m_vertBuff.write(m_jobs, tmpBuff, 0, 0, size);
+	m_vertBuff.write(m_jobs, vertBuff, size, 0, 0, size);
 
 	m_ppline.bind(m_jobs);
 

src/renderer/Deformer.cpp

@@ -7,7 +7,6 @@
 #include "anki/resource/ProgramResource.h"
 #include "anki/resource/Material.h"
 #include "anki/scene/SkinNode.h"
-#include "anki/gr/GlState.h"
 
 namespace anki {
 

src/renderer/Dp.cpp

@@ -15,22 +15,20 @@ Error Dp::init(const ConfigSet& config)
 		getAlignedRoundDown(16, m_r->getWidth() / 3),
 		getAlignedRoundDown(16, m_r->getHeight() / 3));
 
-	Error err = m_r->createRenderTarget(
+	ANKI_CHECK(m_r->createRenderTarget(
 		m_smallDepthSize.x(), m_smallDepthSize.y(),
-		GL_DEPTH_COMPONENT24, 1, m_smallDepthRt);
-	if(err) return err;
+		GL_DEPTH_COMPONENT24, 1, m_smallDepthRt));
 
-	GlDevice& gl = getGlDevice();
-	GlCommandBufferHandle cmdb;
-	err = cmdb.create(&gl);
-	if(err)	return err;
+	GrManager& gl = getGrManager();
+	CommandBufferHandle cmdb;
+	ANKI_CHECK(cmdb.create(&gl));
 
-	m_smallDepthRt.setFilter(cmdb, GlTextureHandle::Filter::LINEAR);
+	m_smallDepthRt.setFilter(cmdb, TextureHandle::Filter::LINEAR);
 
-	err = m_smallDepthFb.create(
-		cmdb,
-		{{m_smallDepthRt, GL_DEPTH_ATTACHMENT}});
-	if(err)	return err;
+	FramebufferHandle::Initializer fbInit;
+	fbInit.m_colorAttachmentsCount = 1;
+	fbInit.m_colorAttachments[0].m_texture = m_smallDepthRt;
+	ANKI_CHECK(m_smallDepthFb.create(cmdb, fbInit));
 
 	cmdb.finish();
 
@@ -38,7 +36,7 @@ Error Dp::init(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Dp::run(GlCommandBufferHandle& cmdb)
+Error Dp::run(CommandBufferHandle& cmdb)
 {
 	m_smallDepthFb.blit(
 		cmdb, 

src/renderer/Drawer.cpp

@@ -30,7 +30,7 @@ public:
 	Ptr<const FrustumComponent> m_fr;
 	Ptr<RenderableDrawer> m_drawer;
 	U8 m_instanceCount;
-	GlCommandBufferHandle m_cmdBuff;
+	CommandBufferHandle m_cmdBuff;
 
 	F32 m_flod;
 
@@ -221,7 +221,7 @@ void SetupRenderableVariableVisitor::uniSet<TextureResourcePointer>(
 	const TextureResourcePointer* values, U32 size)
 {
 	ANKI_ASSERT(size == 1);
-	GlTextureHandle tex = (*values)->getGlTexture();
+	TextureHandle tex = (*values)->getGlTexture();
 	auto unit = mtlvar.getTextureUnit();
 
 	tex.bind(m_cmdBuff, unit);
@@ -230,25 +230,15 @@ void SetupRenderableVariableVisitor::uniSet<TextureResourcePointer>(
 //==============================================================================
 Error RenderableDrawer::create(Renderer* r)
 {
-	Error err = ErrorCode::NONE;
-
 	m_r = r;
 
 	// Create the uniform buffer
-	GlCommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&m_r->_getGlDevice());
-	if(err)
-	{
-		return err;
-	}
+	CommandBufferHandle cmdBuff;
+	ANKI_CHECK(cmdBuff.create(&m_r->_getGrManager()));
 
-	err = m_uniformBuff.create(cmdBuff, GL_UNIFORM_BUFFER, 
+	ANKI_CHECK(m_uniformBuff.create(cmdBuff, GL_UNIFORM_BUFFER, nullptr,
 		MAX_UNIFORM_BUFFER_SIZE,
-		GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
-	if(err)
-	{
-		return err;
-	}
+		GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
 
 	cmdBuff.flush();
 
@@ -256,14 +246,14 @@ Error RenderableDrawer::create(Renderer* r)
 		m_uniformBuff.getPersistentMappingAddress());
 	m_uniformBuffMapAddr = m_uniformPtr;
 	ANKI_ASSERT(m_uniformPtr != nullptr);
-	ANKI_ASSERT(isAligned(m_r->_getGlDevice().getBufferOffsetAlignment(
+	ANKI_ASSERT(isAligned(m_r->_getGrManager().getBufferOffsetAlignment(
 		m_uniformBuff.getTarget()), m_uniformPtr));
 
 	// Set some other values
 	m_uniformsUsedSize = 0;
 	m_uniformsUsedSizeFrame = 0;
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -280,7 +270,7 @@ void RenderableDrawer::setupUniforms(
 	// Find a place to write the uniforms
 	//
 	U8* prevUniformPtr = m_uniformPtr;
-	alignRoundUp(m_r->_getGlDevice().getBufferOffsetAlignment(
+	alignRoundUp(m_r->_getGrManager().getBufferOffsetAlignment(
 		m_uniformBuff.getTarget()), m_uniformPtr);
 	U diff = m_uniformPtr - prevUniformPtr;
 
@@ -409,7 +399,7 @@ Error RenderableDrawer::render(SceneNode& frsn, VisibleNode& visibleNode)
 
 //==============================================================================
 void RenderableDrawer::prepareDraw(RenderingStage stage, Pass pass,
-	GlCommandBufferHandle& cmdBuff)
+	CommandBufferHandle& cmdBuff)
 {
 	// Set some numbers
 	m_stage = stage;
@@ -433,7 +423,7 @@ void RenderableDrawer::prepareDraw(RenderingStage stage, Pass pass,
 void RenderableDrawer::finishDraw()
 {
 	// Release the job chain
-	m_cmdBuff = GlCommandBufferHandle();
+	m_cmdBuff = CommandBufferHandle();
 
 	if(m_uniformsUsedSize > MAX_UNIFORM_BUFFER_SIZE / 3)
 	{

src/renderer/Ez.cpp

@@ -22,7 +22,7 @@ Error Ez::init(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Ez::run(GlCommandBufferHandle& cmdBuff)
+Error Ez::run(CommandBufferHandle& cmdBuff)
 {
 	ANKI_ASSERT(m_enabled);
 

src/renderer/Fs.cpp

@@ -17,25 +17,20 @@ Fs::~Fs()
 //==============================================================================
 Error Fs::init(const ConfigSet&)
 {
-	GlCommandBufferHandle cmdb;
-	Error err = cmdb.create(&getGlDevice());
-	if(err)
-	{
-		return err;
-	}
+	CommandBufferHandle cmdb;
+	ANKI_CHECK(cmdb.create(&getGrManager()));
 
-	err = m_fb.create(
-		cmdb,
-		{{m_r->getIs()._getRt(), GL_COLOR_ATTACHMENT0}, 
-		{m_r->getMs()._getDepthRt(), GL_DEPTH_ATTACHMENT}});
+	FramebufferHandle::Initializer fbInit;
+	fbInit.m_colorAttachmentsCount = 1;
+	fbInit.m_colorAttachments[0].m_texture = m_r->getIs()._getRt();
+	fbInit.m_depthStencilAttachment.m_texture = m_r->getMs()._getDepthRt();
+	ANKI_CHECK(m_fb.create(cmdb,fbInit));
 
-	cmdb.flush();
-
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
-Error Fs::run(GlCommandBufferHandle& cmdb)
+Error Fs::run(CommandBufferHandle& cmdb)
 {
 	Error err = ErrorCode::NONE;
 

src/renderer/Hdr.cpp

@@ -14,7 +14,7 @@ Hdr::~Hdr()
 {}
 
 //==============================================================================
-Error Hdr::initFb(GlFramebufferHandle& fb, GlTextureHandle& rt)
+Error Hdr::initFb(FramebufferHandle& fb, TextureHandle& rt)
 {
 	Error err = ErrorCode::NONE;
 
@@ -22,14 +22,17 @@ Error Hdr::initFb(GlFramebufferHandle& fb, GlTextureHandle& rt)
 	if(err) return err;
 
 	// Set to bilinear because the blurring techniques take advantage of that
-	GlCommandBufferHandle cmdb;
-	err = cmdb.create(&getGlDevice());
+	CommandBufferHandle cmdb;
+	err = cmdb.create(&getGrManager());
 	if(err) return err;
 
-	rt.setFilter(cmdb, GlTextureHandle::Filter::LINEAR);
+	rt.setFilter(cmdb, TextureHandle::Filter::LINEAR);
 
 	// Create FB
-	err = fb.create(cmdb, {{rt, GL_COLOR_ATTACHMENT0}});
+	FramebufferHandle::Initializer fbInit;
+	fbInit.m_colorAttachmentsCount = 1;
+	fbInit.m_colorAttachments[0].m_texture = rt;
+	err = fb.create(cmdb, fbInit);
 	if(err) return err;
 
 	cmdb.finish();
@@ -68,12 +71,12 @@ Error Hdr::initInternal(const ConfigSet& initializer)
 	if(err) return err;
 
 	// init shaders
-	GlDevice& gl = getGlDevice();
-	GlCommandBufferHandle cmdb;
+	GrManager& gl = getGrManager();
+	CommandBufferHandle cmdb;
 	err = cmdb.create(&gl);
 	if(err) return err;
 
-	err = m_commonBuff.create(cmdb, GL_UNIFORM_BUFFER, 
+	err = m_commonBuff.create(cmdb, GL_UNIFORM_BUFFER, nullptr,
 		sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT);
 	if(err) return err;
 
@@ -153,7 +156,7 @@ Error Hdr::init(const ConfigSet& initializer)
 }
 
 //==============================================================================
-Error Hdr::run(GlCommandBufferHandle& cmdb)
+Error Hdr::run(CommandBufferHandle& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
 	Error err = ErrorCode::NONE;
@@ -187,7 +190,7 @@ Error Hdr::run(GlCommandBufferHandle& cmdb)
 	{
 		if(i == 0)
 		{
-			Array<GlTextureHandle, 2> arr = {{m_hblurRt, m_vblurRt}};
+			Array<TextureHandle, 2> arr = {{m_hblurRt, m_vblurRt}};
 			cmdb.bindTextures(0, arr.begin(), arr.getSize());
 		}
 
@@ -209,19 +212,12 @@ Error Hdr::run(GlCommandBufferHandle& cmdb)
 }
 
 //==============================================================================
-Error Hdr::updateDefaultBlock(GlCommandBufferHandle& cmdb)
+Error Hdr::updateDefaultBlock(CommandBufferHandle& cmdb)
 {
-	GlClientBufferHandle tempBuff;
-	Error err = tempBuff.create(cmdb, sizeof(Vec4), nullptr);
-	
-	if(!err)
-	{
-		*((Vec4*)tempBuff.getBaseAddress()) = Vec4(m_exposure, 0.0, 0.0, 0.0);
-
-		m_commonBuff.write(cmdb, tempBuff, 0, 0, tempBuff.getSize());
-	}
+	Vec4 uniform(m_exposure, 0.0, 0.0, 0.0);
+	m_commonBuff.write(cmdb, &uniform, sizeof(uniform), 0, 0, sizeof(uniform));
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/renderer/Is.cpp

@@ -206,8 +206,8 @@ Error Is::initInternal(const ConfigSet& config)
 	if(err) return err;
 
 	// point light
-	GlCommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGlDevice()); // Job for initialization
+	CommandBufferHandle cmdBuff;
+	err = cmdBuff.create(&getGrManager()); // Job for initialization
 	if(err)
 	{
 		return err;
@@ -245,7 +245,10 @@ Error Is::initInternal(const ConfigSet& config)
 		return err;
 	}
 
-	err = m_fb.create(cmdBuff, {{m_rt, GL_COLOR_ATTACHMENT0}});
+	FramebufferHandle::Initializer fbInit;
+	fbInit.m_colorAttachmentsCount = 1;
+	fbInit.m_colorAttachments[0].m_texture = m_rt;
+	err = m_fb.create(cmdBuff, fbInit);
 	if(err)
 	{
 		return err;
@@ -257,15 +260,8 @@ Error Is::initInternal(const ConfigSet& config)
 	static const F32 quadVertCoords[][2] = 
 		{{1.0, 1.0}, {0.0, 1.0}, {1.0, 0.0}, {0.0, 0.0}};
 
-	GlClientBufferHandle tempBuff;
-	err = tempBuff.create(cmdBuff, sizeof(quadVertCoords), 
-		(void*)&quadVertCoords[0][0]);
-	if(err)
-	{
-		return err;
-	}
-
-	err = m_quadPositionsVertBuff.create(cmdBuff, GL_ARRAY_BUFFER, tempBuff, 0);
+	err = m_quadPositionsVertBuff.create(cmdBuff, GL_ARRAY_BUFFER, 
+		&quadVertCoords[0][0], sizeof(quadVertCoords), 0);
 	if(err)
 	{
 		return err;
@@ -274,7 +270,7 @@ Error Is::initInternal(const ConfigSet& config)
 	//
 	// Create UBOs
 	//
-	err = m_commonBuffer.create(cmdBuff, GL_UNIFORM_BUFFER, 
+	err = m_commonBuffer.create(cmdBuff, GL_UNIFORM_BUFFER, nullptr,
 		sizeof(shader::CommonUniforms), GL_DYNAMIC_STORAGE_BIT);
 	if(err)
 	{
@@ -285,7 +281,7 @@ Error Is::initInternal(const ConfigSet& config)
 	{
 		// Lights
 		err = m_lightsBuffers[i].create(cmdBuff, GL_SHADER_STORAGE_BUFFER, 
-			calcLightsBufferSize(), 
+			nullptr, calcLightsBufferSize(), 
 			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 		if(err)
 		{
@@ -294,7 +290,7 @@ Error Is::initInternal(const ConfigSet& config)
 
 		// Tiles
 		err = m_tilesBuffers[i].create(cmdBuff, GL_SHADER_STORAGE_BUFFER,
-			m_r->getTilesCountXY() * sizeof(shader::Tile),
+			nullptr, m_r->getTilesCountXY() * sizeof(shader::Tile),
 			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 		if(err)
 		{
@@ -303,7 +299,7 @@ Error Is::initInternal(const ConfigSet& config)
 
 		// Index
 		err = m_lightIdsBuffers[i].create(cmdBuff, GL_SHADER_STORAGE_BUFFER,
-			(m_maxPointLights * m_maxSpotLights * m_maxSpotTexLights)
+			nullptr, (m_maxPointLights * m_maxSpotLights * m_maxSpotTexLights)
 			* sizeof(U32),
 			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 		if(err)
@@ -332,7 +328,7 @@ Error Is::initInternal(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Is::lightPass(GlCommandBufferHandle& cmdBuff)
+Error Is::lightPass(CommandBufferHandle& cmdBuff)
 {
 	Error err = ErrorCode::NONE;
 	Threadpool& threadPool = m_r->_getThreadpool();
@@ -402,7 +398,7 @@ Error Is::lightPass(GlCommandBufferHandle& cmdBuff)
 	// Write the lights and tiles UBOs
 	//
 	U32 blockAlignment = 
-		getGlDevice().getBufferOffsetAlignment(m_lightsBuffers[0].getTarget());
+		getGrManager().getBufferOffsetAlignment(m_lightsBuffers[0].getTarget());
 
 	// Get the offsets and sizes of each uniform block
 	PtrSize pointLightsOffset = 0;
@@ -508,7 +504,7 @@ Error Is::lightPass(GlCommandBufferHandle& cmdBuff)
 		cmdBuff, LIGHT_IDS_BLOCK_BINDING);
 
 	// The binding points should much the shader
-	Array<GlTextureHandle, 4> tarr = {{
+	Array<TextureHandle, 4> tarr = {{
 		m_r->getMs()._getRt0(), 
 		m_r->getMs()._getRt1(), 
 		m_r->getMs()._getDepthRt(),
@@ -815,7 +811,7 @@ void Is::binLight(
 }
 
 //==============================================================================
-void Is::setState(GlCommandBufferHandle& cmdBuff)
+void Is::setState(CommandBufferHandle& cmdBuff)
 {
 	/*Bool drawToDefaultFbo = !m_r->getPps().getEnabled() 
 		&& !m_r->getDbg().getEnabled() 
@@ -839,27 +835,20 @@ void Is::setState(GlCommandBufferHandle& cmdBuff)
 }
 
 //==============================================================================
-Error Is::run(GlCommandBufferHandle& cmdBuff)
+Error Is::run(CommandBufferHandle& cmdBuff)
 {
 	// Do the light pass including the shadow passes
 	return lightPass(cmdBuff);
 }
 
 //==============================================================================
-Error Is::updateCommonBlock(GlCommandBufferHandle& cmdBuff)
+Error Is::updateCommonBlock(CommandBufferHandle& cmdBuff)
 {
 	SceneGraph& scene = m_r->getSceneGraph();
-
-	GlClientBufferHandle cbuff;
-	Error err = cbuff.create(cmdBuff, sizeof(shader::CommonUniforms), nullptr);
-	if(err) return err;
-
-	shader::CommonUniforms& blk = 
-		*(shader::CommonUniforms*)cbuff.getBaseAddress();
+	shader::CommonUniforms blk;
 
 	// Start writing
 	blk.m_projectionParams = m_r->getProjectionParameters();
-
 	blk.m_sceneAmbientColor = scene.getAmbientColor();
 
 	Vec3 groundLightDir;
@@ -870,16 +859,16 @@ Error Is::updateCommonBlock(GlCommandBufferHandle& cmdBuff)
 		blk.m_groundLightDir = Vec4(-viewMat.getColumn(1).xyz(), 1.0);
 	}
 
-	m_commonBuffer.write(cmdBuff, cbuff, 0, 0, cbuff.getSize());
+	m_commonBuffer.write(cmdBuff, &blk, sizeof(blk), 0, 0, sizeof(blk));
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 PtrSize Is::calcLightsBufferSize() const
 {
 	U32 buffAlignment = 
-		getGlDevice().getBufferOffsetAlignment(GL_SHADER_STORAGE_BUFFER);
+		getGrManager().getBufferOffsetAlignment(GL_SHADER_STORAGE_BUFFER);
 	PtrSize size;
 
 	size = getAlignedRoundUp(

src/renderer/Lf.cpp

@@ -50,7 +50,7 @@ Error Lf::init(const ConfigSet& config)
 
 //==============================================================================
 Error Lf::initPseudo(const ConfigSet& config, 
-	GlCommandBufferHandle& cmdBuff)
+	CommandBufferHandle& cmdBuff)
 {
 	Error err = ErrorCode::NONE;
 
@@ -91,7 +91,7 @@ Error Lf::initPseudo(const ConfigSet& config,
 
 //==============================================================================
 Error Lf::initSprite(const ConfigSet& config, 
-	GlCommandBufferHandle& cmdBuff)
+	CommandBufferHandle& cmdBuff)
 {
 	Error err = ErrorCode::NONE;
 
@@ -101,64 +101,102 @@ Error Lf::initSprite(const ConfigSet& config,
 
 	err = pps.sprintf(getAllocator(), "#define MAX_SPRITES %u\n",
 		m_maxSpritesPerFlare);
-	if(err)	return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_realVert.loadToCache(&getResourceManager(), 
 		"shaders/PpsLfSpritePass.vert.glsl", pps.toCString(), "r_");
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_realFrag.loadToCache(&getResourceManager(), 
 		"shaders/PpsLfSpritePass.frag.glsl", pps.toCString(), "r_");
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_realPpline.create(cmdBuff,
 		{m_realVert->getGlProgram(), m_realFrag->getGlProgram()});
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	// Create buffer
 	PtrSize uboAlignment = 
-		m_r->_getGlDevice().getBufferOffsetAlignment(GL_UNIFORM_BUFFER);
+		m_r->_getGrManager().getBufferOffsetAlignment(GL_UNIFORM_BUFFER);
 	m_flareSize = getAlignedRoundUp(
 		uboAlignment, sizeof(Sprite) * m_maxSpritesPerFlare);
 	PtrSize blockSize = m_flareSize * m_maxFlares;
 
-	err = m_flareDataBuff.create(
-		cmdBuff, GL_UNIFORM_BUFFER, blockSize, GL_DYNAMIC_STORAGE_BIT);
-	if(err) return err;
+	for(U i = 0; i < m_flareDataBuff.getSize(); ++i)
+	{
+		err = m_flareDataBuff[i].create(
+			cmdBuff, GL_UNIFORM_BUFFER, nullptr, blockSize, 
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
+		if(err)
+		{
+			return err;
+		}
+	}
 
 	return err;
 }
 
 //==============================================================================
 Error Lf::initOcclusion(
-	const ConfigSet& config, GlCommandBufferHandle& cmdBuff)
+	const ConfigSet& config, CommandBufferHandle& cmdBuff)
 {
 	Error err = ErrorCode::NONE;
 
 	// Init vert buff
 	U buffSize = sizeof(Vec3) * m_maxFlares;
 
-	err = m_positionsVertBuff.create(
-		cmdBuff, GL_ARRAY_BUFFER, buffSize, GL_DYNAMIC_STORAGE_BIT);
-	if(err) return err;
+	for(U i = 0; i < m_positionsVertBuff.getSize(); ++i)
+	{
+		err = m_positionsVertBuff[i].create(
+			cmdBuff, GL_ARRAY_BUFFER, nullptr, buffSize, 
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
+		if(err)
+		{
+			return err;
+		}
+	}
 
 	// Init MVP buff
-	err = m_mvpBuff.create(
-		cmdBuff, GL_UNIFORM_BUFFER, sizeof(Mat4), GL_DYNAMIC_STORAGE_BIT);
-	if(err) return err;
+	err = m_mvpBuff.create(cmdBuff, GL_UNIFORM_BUFFER, 
+		nullptr, sizeof(Mat4), GL_DYNAMIC_STORAGE_BIT);
+	if(err)
+	{
+		return err;
+	}
 
 	// Shaders
 	err = m_occlusionVert.load("shaders/PpsLfOcclusion.vert.glsl",
 		&getResourceManager());
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_occlusionFrag.load("shaders/PpsLfOcclusion.frag.glsl",
 		&getResourceManager());
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_occlusionPpline.create(cmdBuff,
 		{m_occlusionVert->getGlProgram(), m_occlusionFrag->getGlProgram()});
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	return err;
 }
@@ -174,34 +212,61 @@ Error Lf::initInternal(const ConfigSet& config)
 		return err;
 	}
 
-	GlCommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGlDevice());
-	if(err) return err;
+	CommandBufferHandle cmdBuff;
+	err = cmdBuff.create(&getGrManager());
+	if(err)
+	{
+		return err;
+	}
 
 	err = initPseudo(config, cmdBuff);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = initSprite(config, cmdBuff);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = initOcclusion(config, cmdBuff);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	// Create the render target
 	err = m_r->createRenderTarget(m_r->getPps().getHdr()._getWidth(), 
 		m_r->getPps().getHdr()._getHeight(), GL_RGB8, 1, m_rt);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
-	err = m_fb.create(cmdBuff, {{m_rt, GL_COLOR_ATTACHMENT0}});
-	if(err) return err;
+	FramebufferHandle::Initializer fbInit;
+	fbInit.m_colorAttachmentsCount = 1;
+	fbInit.m_colorAttachments[0].m_texture = m_rt;
+	err = m_fb.create(cmdBuff, fbInit);
+	if(err)
+	{
+		return err;
+	}
 
 	// Blit
 	err = m_blitFrag.load("shaders/Blit.frag.glsl", &getResourceManager());
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_r->createDrawQuadPipeline(
 		m_blitFrag->getGlProgram(), m_blitPpline);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	cmdBuff.flush();
 
@@ -209,7 +274,7 @@ Error Lf::initInternal(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Lf::runOcclusionTests(GlCommandBufferHandle& cmdb)
+Error Lf::runOcclusionTests(CommandBufferHandle& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
 	Error err = ErrorCode::NONE;
@@ -235,24 +300,20 @@ Error Lf::runOcclusionTests(GlCommandBufferHandle& cmdb)
 		m_occlusionPpline.bind(cmdb);
 
 		// Setup MVP UBO
-		GlClientBufferHandle mvpCBuff;
-		err = mvpCBuff.create(cmdb, sizeof(Mat4), nullptr);
-		if(err) return err;
-		Mat4* mvpWrite = static_cast<Mat4*>(mvpCBuff.getBaseAddress());
-		ANKI_ASSERT(mvpWrite);
-		*mvpWrite = camFr.getViewProjectionMatrix().getTransposed();
-		m_mvpBuff.write(cmdb, mvpCBuff, 0, 0, sizeof(Mat4));
+		Mat4 mvp = camFr.getViewProjectionMatrix().getTransposed();
+		m_mvpBuff.write(cmdb, &mvp, sizeof(mvp), 0, 0, sizeof(mvp));
 		m_mvpBuff.bindShaderBuffer(cmdb, 0, sizeof(Mat4), 0);
 
 		// Allocate vertices and fire write job
-		GlClientBufferHandle posCBuff;
-		err = posCBuff.create(cmdb, sizeof(Vec3) * totalCount, nullptr);
-		if(err) return err;
-		m_positionsVertBuff.write(cmdb, posCBuff, 0, 0, posCBuff.getSize());
-		m_positionsVertBuff.bindVertexBuffer(
+		BufferHandle& positionsVertBuff = m_positionsVertBuff[
+			getGlobalTimestamp() % m_positionsVertBuff.getSize()];
+		ANKI_ASSERT(sizeof(Vec3) * totalCount <= positionsVertBuff.getSize());
+		
+		positionsVertBuff.bindVertexBuffer(
 			cmdb, 3, GL_FLOAT, false, sizeof(Vec3), 0, 0);
 
-		Vec3* positions = static_cast<Vec3*>(posCBuff.getBaseAddress());
+		Vec3* positions = static_cast<Vec3*>(
+			positionsVertBuff.getPersistentMappingAddress());
 		Vec3* initialPositions = positions;
 
 		// Iterate lens flare
@@ -266,7 +327,7 @@ Error Lf::runOcclusionTests(GlCommandBufferHandle& cmdb)
 			*positions = lf.getWorldPosition().xyz();
 
 			// Draw and query
-			GlOcclusionQueryHandle& query = lf.getOcclusionQueryToTest();
+			OcclusionQueryHandle& query = lf.getOcclusionQueryToTest();
 			query.begin(cmdb);
 
 			cmdb.drawArrays(GL_POINTS, 1, 1, positions - initialPositions);
@@ -288,7 +349,7 @@ Error Lf::runOcclusionTests(GlCommandBufferHandle& cmdb)
 }
 
 //==============================================================================
-Error Lf::run(GlCommandBufferHandle& cmdBuff)
+Error Lf::run(CommandBufferHandle& cmdBuff)
 {
 	ANKI_ASSERT(m_enabled);
 	Error err = ErrorCode::NONE;
@@ -304,7 +365,7 @@ Error Lf::run(GlCommandBufferHandle& cmdBuff)
 
 	m_pseudoPpline.bind(cmdBuff);
 
-	Array<GlTextureHandle, 2> tarr = {{
+	Array<TextureHandle, 2> tarr = {{
 		m_r->getPps().getHdr()._getRt(), 
 		m_lensDirtTex->getGlTexture()}};
 	cmdBuff.bindTextures(0, tarr.begin(), tarr.getSize());
@@ -326,23 +387,21 @@ Error Lf::run(GlCommandBufferHandle& cmdBuff)
 	{
 		// Allocate client buffer
 		const U uboAlignment = 
-			m_r->_getGlDevice().getBufferOffsetAlignment(GL_UNIFORM_BUFFER);
+			m_r->_getGrManager().getBufferOffsetAlignment(GL_UNIFORM_BUFFER);
 		const U bufferSize = m_flareSize * totalCount;
 
-		GlClientBufferHandle flaresCBuff;
-		err = flaresCBuff.create(cmdBuff, bufferSize, nullptr);
-		if(err)	return err;
-
-		Sprite* sprites = static_cast<Sprite*>(flaresCBuff.getBaseAddress());
-		U8* spritesInitialPtr = reinterpret_cast<U8*>(sprites);
-
 		// Set common rendering state
 		m_realPpline.bind(cmdBuff);
 		cmdBuff.enableBlend(true);
 		cmdBuff.setBlendFunctions(GL_ONE, GL_ONE);
 
 		// Send the command to write the buffer now
-		m_flareDataBuff.write(cmdBuff, flaresCBuff, 0, 0, bufferSize);
+		BufferHandle& flareDataBuff = m_flareDataBuff[
+			getGlobalTimestamp() % m_flareDataBuff.getSize()];
+
+		Sprite* sprites = static_cast<Sprite*>(
+			flareDataBuff.getPersistentMappingAddress());
+		U8* spritesInitialPtr = reinterpret_cast<U8*>(sprites);
 
 		// Iterate lens flare
 		auto it = vi.getLensFlaresBegin();
@@ -380,13 +439,13 @@ Error Lf::run(GlCommandBufferHandle& cmdBuff)
 
 			// Render
 			lf.getTexture().bind(cmdBuff, 0);
-			m_flareDataBuff.bindShaderBuffer(
+			flareDataBuff.bindShaderBuffer(
 				cmdBuff, 
 				reinterpret_cast<U8*>(sprites) - spritesInitialPtr, 
 				sizeof(Sprite) * count,
 				0);
 
-			GlOcclusionQueryHandle query;
+			OcclusionQueryHandle query;
 			Bool queryInvalid;
 			lf.getOcclusionQueryToCheck(query, queryInvalid);
 			

src/renderer/MainRenderer.cpp

@@ -26,7 +26,7 @@ MainRenderer::~MainRenderer()
 Error MainRenderer::create(
 	Threadpool* threadpool, 
 	ResourceManager* resources,
-	GlDevice* gl,
+	GrManager* gl,
 	HeapAllocator<U8>& alloc,
 	const ConfigSet& config,
 	const Timestamp* globalTimestamp)
@@ -60,9 +60,9 @@ Error MainRenderer::render(SceneGraph& scene)
 	Error err = ErrorCode::NONE;
 	ANKI_COUNTER_START_TIMER(MAIN_RENDERER_TIME);
 
-	GlDevice& gl = _getGlDevice();
-	Array<GlCommandBufferHandle, JOB_CHAINS_COUNT> jobs;
-	GlCommandBufferHandle& lastJobs = jobs[JOB_CHAINS_COUNT - 1];
+	GrManager& gl = _getGrManager();
+	Array<CommandBufferHandle, JOB_CHAINS_COUNT> jobs;
+	CommandBufferHandle& lastJobs = jobs[JOB_CHAINS_COUNT - 1];
 
 	for(U i = 0; i < JOB_CHAINS_COUNT; i++)
 	{
@@ -86,7 +86,7 @@ Error MainRenderer::render(SceneGraph& scene)
 
 		m_blitPpline.bind(lastJobs);
 
-		GlTextureHandle* rt;
+		TextureHandle* rt;
 
 		if(getPps().getEnabled())
 		{
@@ -100,7 +100,7 @@ Error MainRenderer::render(SceneGraph& scene)
 		//rt = &getTiler().getRt();
 		//rt = &getIs()._getRt();
 
-		rt->setFilter(lastJobs, GlTextureHandle::Filter::LINEAR);
+		rt->setFilter(lastJobs, TextureHandle::Filter::LINEAR);
 		rt->bind(lastJobs, 0);
 
 		drawQuad(lastJobs);
@@ -113,7 +113,7 @@ Error MainRenderer::render(SceneGraph& scene)
 	}
 
 	// Flush the last job chain
-	ANKI_ASSERT(lastJobs.getReferenceCount() == 1);
+	//ANKI_ASSERT(lastJobs.get().getReferenceCount() == 1);
 	lastJobs.flush();
 
 	ANKI_COUNTER_STOP_TIMER_INC(MAIN_RENDERER_TIME);
@@ -125,8 +125,8 @@ Error MainRenderer::render(SceneGraph& scene)
 Error MainRenderer::initGl()
 {
 	// get max texture units
-	GlCommandBufferHandle cmdb;
-	Error err = cmdb.create(&_getGlDevice());
+	CommandBufferHandle cmdb;
+	Error err = cmdb.create(&_getGrManager());
 
 	if(!err)
 	{

src/renderer/Ms.cpp

@@ -27,27 +27,44 @@ Error Ms::createRt(U32 index, U32 samples)
 
 	err = m_r->createRenderTarget(m_r->getWidth(), m_r->getHeight(),
 		GL_DEPTH_COMPONENT24, samples, plane.m_depthRt);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_r->createRenderTarget(m_r->getWidth(), m_r->getHeight(), GL_RGBA8,
 			samples, plane.m_rt0);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_r->createRenderTarget(m_r->getWidth(), m_r->getHeight(), GL_RGBA8,
 		samples, plane.m_rt1);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
-	GlDevice& gl = getGlDevice();
-	GlCommandBufferHandle cmdb;
+	GrManager& gl = getGrManager();
+	CommandBufferHandle cmdb;
 	err = cmdb.create(&gl);
-	if(err)	return err;
+	if(err)
+	{
+		return err;
+	}
 
-	err = plane.m_fb.create(
-		cmdb,
-		{{plane.m_rt0, GL_COLOR_ATTACHMENT0}, 
-		{plane.m_rt1, GL_COLOR_ATTACHMENT1},
-		{plane.m_depthRt, GL_DEPTH_ATTACHMENT}});
-	if(err)	return err;
+	FramebufferHandle::Initializer fbInit;
+	fbInit.m_colorAttachmentsCount = 2;
+	fbInit.m_colorAttachments[0].m_texture = plane.m_rt0;
+	fbInit.m_colorAttachments[1].m_texture = plane.m_rt1;
+	fbInit.m_depthStencilAttachment.m_texture = plane.m_depthRt;
+
+	err = plane.m_fb.create(cmdb, fbInit);
+	if(err)
+	{
+		return err;
+	}
 
 	cmdb.finish();
 
@@ -85,7 +102,7 @@ Error Ms::initInternal(const ConfigSet& initializer)
 }
 
 //==============================================================================
-Error Ms::run(GlCommandBufferHandle& cmdb)
+Error Ms::run(CommandBufferHandle& cmdb)
 {
 	Error err = ErrorCode::NONE;
 

src/renderer/Pps.cpp

@@ -29,42 +29,37 @@ Pps::~Pps()
 //==============================================================================
 Error Pps::initInternal(const ConfigSet& config)
 {
-	Error err = ErrorCode::NONE;
-
 	m_enabled = config.get("pps.enabled");
 	if(!m_enabled)
 	{
-		return err;
+		return ErrorCode::NONE;
 	}
 
 	ANKI_ASSERT("Initializing PPS");
 
-	err = m_ssao.init(config);
-	if(err) return err;
-	err = m_hdr.init(config);
-	if(err) return err;
-	err = m_lf.init(config);
-	if(err) return err;
-	err = m_sslr.init(config);
-	if(err) return err;
+	ANKI_CHECK(m_ssao.init(config));
+	ANKI_CHECK(m_hdr.init(config));
+	ANKI_CHECK(m_lf.init(config));
+	ANKI_CHECK(m_sslr.init(config));
 
 	// FBO
-	GlCommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGlDevice());
-	if(err) return err;
+	CommandBufferHandle cmdBuff;
+	ANKI_CHECK(cmdBuff.create(&getGrManager()));
 
-	err = m_r->createRenderTarget(
-		m_r->getWidth(), m_r->getHeight(), GL_RGB8, 1, m_rt);
-	if(err) return err;
+	ANKI_CHECK(
+		m_r->createRenderTarget(
+		m_r->getWidth(), m_r->getHeight(), GL_RGB8, 1, m_rt));
 
-	err = m_fb.create(cmdBuff, {{m_rt, GL_COLOR_ATTACHMENT0}});
-	if(err) return err;
+	FramebufferHandle::Initializer fbInit;
+	fbInit.m_colorAttachmentsCount = 1;
+	fbInit.m_colorAttachments[0].m_texture = m_rt;
+	ANKI_CHECK(m_fb.create(cmdBuff, fbInit));
 
 	// SProg
 	String pps;
 	String::ScopeDestroyer ppsd(&pps, getAllocator());
 
-	err = pps.sprintf(getAllocator(),
+	ANKI_CHECK(pps.sprintf(getAllocator(),
 		"#define SSAO_ENABLED %u\n"
 		"#define HDR_ENABLED %u\n"
 		"#define SHARPEN_ENABLED %u\n"
@@ -76,19 +71,16 @@ Error Pps::initInternal(const ConfigSet& config)
 		static_cast<U>(config.get("pps.sharpen")),
 		static_cast<U>(config.get("pps.gammaCorrection")),
 		m_r->getWidth(),
-		m_r->getHeight());
-	if(err) return err;
+		m_r->getHeight()));
 
-	err = m_frag.loadToCache(&getResourceManager(),
-		"shaders/Pps.frag.glsl", pps.toCString(), "r_");
-	if(err) return err;
+	ANKI_CHECK(m_frag.loadToCache(&getResourceManager(),
+		"shaders/Pps.frag.glsl", pps.toCString(), "r_"));
 
-	err = m_r->createDrawQuadPipeline(m_frag->getGlProgram(), m_ppline);
-	if(err) return err;
+	ANKI_CHECK(m_r->createDrawQuadPipeline(m_frag->getGlProgram(), m_ppline));
 
 	cmdBuff.finish();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -104,7 +96,7 @@ Error Pps::init(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Pps::run(GlCommandBufferHandle& cmdBuff)
+Error Pps::run(CommandBufferHandle& cmdBuff)
 {
 	ANKI_ASSERT(m_enabled);
 	Error err = ErrorCode::NONE;

src/renderer/Renderer.cpp

@@ -33,7 +33,7 @@ Renderer::~Renderer()
 Error Renderer::init(
 	Threadpool* threadpool, 
 	ResourceManager* resources,
-	GlDevice* gl,
+	GrManager* gl,
 	HeapAllocator<U8>& alloc,
 	const ConfigSet& config,
 	const Timestamp* globalTimestamp)
@@ -102,37 +102,57 @@ Error Renderer::initInternal(const ConfigSet& config)
 
 	// Drawer
 	err = m_sceneDrawer.create(this);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	// quad setup
 	static const F32 quadVertCoords[][2] = {{1.0, 1.0}, {-1.0, 1.0}, 
 		{1.0, -1.0}, {-1.0, -1.0}};
 
-	GlCommandBufferHandle cmdBuff;
+	CommandBufferHandle cmdBuff;
 	err = cmdBuff.create(m_gl);
-	if(err) return err;
-
-	GlClientBufferHandle tmpBuff;
-	err = tmpBuff.create(
-		cmdBuff, sizeof(quadVertCoords), (void*)&quadVertCoords[0][0]);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
-	err = m_quadPositionsBuff.create(cmdBuff, GL_ARRAY_BUFFER, tmpBuff, 0);
-	if(err) return err;
+	err = m_quadPositionsBuff.create(cmdBuff, GL_ARRAY_BUFFER, 
+		&quadVertCoords[0][0], sizeof(quadVertCoords), 0);
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_drawQuadVert.load("shaders/Quad.vert.glsl", m_resources);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	// Init the stages. Careful with the order!!!!!!!!!!
 	err = m_tiler.init();
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_ms.init(config);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 	err = m_dp.init(config);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 	err = m_is.init(config);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 	
 	m_fs = m_alloc.newInstance<Fs>(this);
 	if(err = m_fs->init(config))
@@ -141,13 +161,23 @@ Error Renderer::initInternal(const ConfigSet& config)
 	}
 	
 	err = m_pps.init(config);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 	err = m_dbg.init(config);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	// Default FB
-	err = m_defaultFb.create(cmdBuff, {});
-	if(err) return err;
+	FramebufferHandle::Initializer fbInit;
+	err = m_defaultFb.create(cmdBuff, fbInit);
+	if(err)
+	{
+		return err;
+	}
 
 	cmdBuff.finish();
 
@@ -163,7 +193,7 @@ Error Renderer::initInternal(const ConfigSet& config)
 
 //==============================================================================
 Error Renderer::render(SceneGraph& scene, 
-	Array<GlCommandBufferHandle, JOB_CHAINS_COUNT>& cmdBuff)
+	Array<CommandBufferHandle, JOB_CHAINS_COUNT>& cmdBuff)
 {
 	Error err = ErrorCode::NONE;
 	m_scene = &scene;
@@ -186,8 +216,10 @@ Error Renderer::render(SceneGraph& scene,
 
 	ANKI_COUNTER_START_TIMER(RENDERER_MS_TIME);
 	err = m_ms.run(cmdBuff[0]);
-	if(err) return err;
-	ANKI_ASSERT(cmdBuff[0].getReferenceCount() == 1);
+	if(err)
+	{
+		return err;
+	}
 	ANKI_COUNTER_STOP_TIMER_INC(RENDERER_MS_TIME);
 
 	m_tiler.runMinMax(m_ms._getDepthRt(), cmdBuff[0]);
@@ -196,12 +228,18 @@ Error Renderer::render(SceneGraph& scene,
 	if(m_pps.getEnabled() && m_pps.getLf().getEnabled())
 	{
 		err = m_pps.getLf().runOcclusionTests(cmdBuff[1]);
-		if(err) return err;
+		if(err)
+		{
+			return err;
+		}
 	}
 
 	ANKI_COUNTER_START_TIMER(RENDERER_IS_TIME);
 	err = m_is.run(cmdBuff[1]);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 	ANKI_COUNTER_STOP_TIMER_INC(RENDERER_IS_TIME);
 
 	if(err = m_fs->run(cmdBuff[1])) 
@@ -216,14 +254,20 @@ Error Renderer::render(SceneGraph& scene,
 	if(m_pps.getEnabled())
 	{
 		err = m_pps.run(cmdBuff[1]);
-		if(err) return err;
+		if(err)
+		{
+			return err;
+		}
 	}
 	ANKI_COUNTER_STOP_TIMER_INC(RENDERER_PPS_TIME);
 
 	if(m_dbg.getEnabled())
 	{
 		err = m_dbg.run(cmdBuff[1]);
-		if(err) return err;
+		if(err)
+		{
+			return err;
+		}
 	}
 
 	++m_framesNum;
@@ -232,14 +276,14 @@ Error Renderer::render(SceneGraph& scene,
 }
 
 //==============================================================================
-void Renderer::drawQuad(GlCommandBufferHandle& cmdBuff)
+void Renderer::drawQuad(CommandBufferHandle& cmdBuff)
 {
 	drawQuadInstanced(cmdBuff, 1);
 }
 
 //==============================================================================
-void Renderer::drawQuadConditional(GlOcclusionQueryHandle& q,
-	GlCommandBufferHandle& cmdBuff)
+void Renderer::drawQuadConditional(OcclusionQueryHandle& q,
+	CommandBufferHandle& cmdBuff)
 {
 	m_quadPositionsBuff.bindVertexBuffer(cmdBuff, 2, GL_FLOAT, false, 0, 0, 0);
 	cmdBuff.drawArraysConditional(q, GL_TRIANGLE_STRIP, 4, 1);
@@ -247,7 +291,7 @@ void Renderer::drawQuadConditional(GlOcclusionQueryHandle& q,
 
 //==============================================================================
 void Renderer::drawQuadInstanced(
-	GlCommandBufferHandle& cmdBuff, U32 primitiveCount)
+	CommandBufferHandle& cmdBuff, U32 primitiveCount)
 {
 	m_quadPositionsBuff.bindVertexBuffer(cmdBuff, 2, GL_FLOAT, false, 0, 0, 0);
 
@@ -275,7 +319,7 @@ Vec3 Renderer::unproject(const Vec3& windowCoords, const Mat4& modelViewMat,
 
 //==============================================================================
 Error Renderer::createRenderTarget(U32 w, U32 h, GLenum internalFormat, 
-	U32 samples, GlTextureHandle& rt)
+	U32 samples, TextureHandle& rt)
 {
 	Error err = ErrorCode::NONE;
 
@@ -287,7 +331,7 @@ Error Renderer::createRenderTarget(U32 w, U32 h, GLenum internalFormat,
 		ANKI_ASSERT(isAligned(16, h));
 	}
 
-	GlTextureHandle::Initializer init;
+	TextureHandle::Initializer init;
 
 	init.m_width = w;
 	init.m_height = h;
@@ -300,12 +344,12 @@ Error Renderer::createRenderTarget(U32 w, U32 h, GLenum internalFormat,
 #endif
 	init.m_internalFormat = internalFormat;
 	init.m_mipmapsCount = 1;
-	init.m_filterType = GlTextureHandle::Filter::NEAREST;
+	init.m_filterType = TextureHandle::Filter::NEAREST;
 	init.m_repeat = false;
 	init.m_anisotropyLevel = 0;
 	init.m_samples = samples;
 
-	GlCommandBufferHandle cmdBuff;
+	CommandBufferHandle cmdBuff;
 	err = cmdBuff.create(m_gl);
 
 	if(!err)
@@ -319,14 +363,14 @@ Error Renderer::createRenderTarget(U32 w, U32 h, GLenum internalFormat,
 
 //==============================================================================
 Error Renderer::createDrawQuadPipeline(
-	GlShaderHandle frag, GlPipelineHandle& ppline)
+	ShaderHandle frag, PipelineHandle& ppline)
 {
-	GlCommandBufferHandle cmdBuff;
+	CommandBufferHandle cmdBuff;
 	Error err = cmdBuff.create(m_gl);
 
 	if(!err)
 	{
-		Array<GlShaderHandle, 2> progs = 
+		Array<ShaderHandle, 2> progs = 
 			{{m_drawQuadVert->getGlProgram(), frag}};
 
 		err = ppline.create(cmdBuff, &progs[0], &progs[0] + 2);

src/renderer/RenderingPass.cpp

@@ -16,15 +16,15 @@ Timestamp RenderingPass::getGlobalTimestamp() const
 }
 
 //==============================================================================
-GlDevice& RenderingPass::getGlDevice()
+GrManager& RenderingPass::getGrManager()
 {
-	return m_r->_getGlDevice();
+	return m_r->_getGrManager();
 }
 
 //==============================================================================
-const GlDevice& RenderingPass::getGlDevice() const
+const GrManager& RenderingPass::getGrManager() const
 {
-	return m_r->_getGlDevice();
+	return m_r->_getGrManager();
 }
 
 //==============================================================================
@@ -43,68 +43,64 @@ ResourceManager& RenderingPass::getResourceManager()
 Error BlurringRenderingPass::initBlurring(
 	Renderer& r, U width, U height, U samples, F32 blurringDistance)
 {
-	Error err = ErrorCode::NONE;
-	GlDevice& gl = getGlDevice();
-	GlCommandBufferHandle cmdb;
-	err = cmdb.create(&gl);
-	if(err) return err;
+	GrManager& gl = getGrManager();
+	CommandBufferHandle cmdb;
+	ANKI_CHECK(cmdb.create(&gl));
 
 	Array<String, 2> pps;
 	String::ScopeDestroyer ppsd0(&pps[0], getAllocator());
 	String::ScopeDestroyer ppsd1(&pps[1], getAllocator());
 
-	err = pps[1].sprintf(getAllocator(),
+	ANKI_CHECK(
+		pps[1].sprintf(getAllocator(),
 		"#define HPASS\n"
 		"#define COL_RGB\n"
 		"#define BLURRING_DIST float(%f)\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES %u\n", 
-		blurringDistance, height, samples);
-	if(err) return err;
+		blurringDistance, height, samples));
 
-	err = pps[0].sprintf(getAllocator(),
+	ANKI_CHECK(
+		pps[0].sprintf(getAllocator(),
 		"#define VPASS\n"
 		"#define COL_RGB\n"
 		"#define BLURRING_DIST float(%f)\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES %u\n",
-		blurringDistance, width, samples);
-	if(err) return err;
+		blurringDistance, width, samples));
 
 	for(U i = 0; i < 2; i++)
 	{
 		Direction& dir = m_dirs[i];
 
-		err = r.createRenderTarget(width, height, GL_RGB8, 1, dir.m_rt);
-		if(err) return err;
+		ANKI_CHECK(r.createRenderTarget(width, height, GL_RGB8, 1, dir.m_rt));
 
 		// Set to bilinear because the blurring techniques take advantage of 
 		// that
-		dir.m_rt.setFilter(cmdb, GlTextureHandle::Filter::LINEAR);
+		dir.m_rt.setFilter(cmdb, TextureHandle::Filter::LINEAR);
 
 		// Create FB
-		err = dir.m_fb.create(
-			cmdb, {{dir.m_rt, GL_COLOR_ATTACHMENT0}});
-		if(err) return err;
+		FramebufferHandle::Initializer fbInit;
+		fbInit.m_colorAttachmentsCount = 1;
+		fbInit.m_colorAttachments[0].m_texture = dir.m_rt;
+		ANKI_CHECK(dir.m_fb.create(cmdb, fbInit));
 
-		err = dir.m_frag.loadToCache(&getResourceManager(),
+		ANKI_CHECK(dir.m_frag.loadToCache(&getResourceManager(),
 			"shaders/VariableSamplingBlurGeneric.frag.glsl", 
-			pps[i].toCString(), "r_");
-		if(err) return err;
+			pps[i].toCString(), "r_"));
 
-		err = r.createDrawQuadPipeline(
-			dir.m_frag->getGlProgram(), dir.m_ppline);
-		if(err) return err;
+		ANKI_CHECK(r.createDrawQuadPipeline(
+			dir.m_frag->getGlProgram(), dir.m_ppline));
 	}
 
 	cmdb.finish();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error BlurringRenderingPass::runBlurring(
-	Renderer& r, GlCommandBufferHandle& cmdb)
+	Renderer& r, CommandBufferHandle& cmdb)
 {
 	// H pass input
 	m_dirs[enumToValue(DirectionEnum::VERTICAL)].m_rt.bind(cmdb, 1); 

src/renderer/Sm.cpp

@@ -17,12 +17,11 @@ namespace anki {
 //==============================================================================
 Error Sm::init(const ConfigSet& initializer)
 {
-	Error err = ErrorCode::NONE;
 	m_enabled = initializer.get("is.sm.enabled");
 
 	if(!m_enabled)
 	{
-		return err;
+		return ErrorCode::NONE;
 	}
 
 	m_poissonEnabled = initializer.get("is.sm.poissonEnabled");
@@ -39,7 +38,7 @@ Error Sm::init(const ConfigSet& initializer)
 	}
 
 	// Create shadowmaps array
-	GlTextureHandle::Initializer sminit;
+	TextureHandle::Initializer sminit;
 	sminit.m_target = GL_TEXTURE_2D_ARRAY;
 	sminit.m_width = m_resolution;
 	sminit.m_height = m_resolution;
@@ -48,19 +47,17 @@ Error Sm::init(const ConfigSet& initializer)
 	sminit.m_mipmapsCount = 1;
 	if(m_bilinearEnabled)
 	{
-		sminit.m_filterType = GlTextureHandle::Filter::LINEAR;
+		sminit.m_filterType = TextureHandle::Filter::LINEAR;
 	}
 	else
 	{
-		sminit.m_filterType = GlTextureHandle::Filter::NEAREST;
+		sminit.m_filterType = TextureHandle::Filter::NEAREST;
 	}
 
-	GlCommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGlDevice());
-	if(err) return err;
+	CommandBufferHandle cmdBuff;
+	ANKI_CHECK(cmdBuff.create(&getGrManager()));
 
-	err = m_sm2DArrayTex.create(cmdBuff, sminit);
-	if(err) return err;
+	ANKI_CHECK(m_sm2DArrayTex.create(cmdBuff, sminit));
 
 	m_sm2DArrayTex.setParameter(cmdBuff, 
 		GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
@@ -68,24 +65,27 @@ Error Sm::init(const ConfigSet& initializer)
 
 	// Init sms
 	U32 layer = 0;
-	err = m_sms.create(getAllocator(), initializer.get("is.sm.maxLights"));
+	ANKI_CHECK(
+		m_sms.create(getAllocator(), initializer.get("is.sm.maxLights")));
 	for(Shadowmap& sm : m_sms)
 	{
 		sm.m_layerId = layer;
-		err = sm.m_fb.create(cmdBuff, 
-			{{m_sm2DArrayTex, GL_DEPTH_ATTACHMENT, (U32)layer}});
-		if(err) return err;
+
+		FramebufferHandle::Initializer fbInit;
+		fbInit.m_depthStencilAttachment.m_texture = m_sm2DArrayTex;
+		fbInit.m_depthStencilAttachment.m_layer = layer;
+		ANKI_CHECK(sm.m_fb.create(cmdBuff, fbInit));
 
 		++layer;
 	}
 
 	cmdBuff.flush();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
-void Sm::prepareDraw(GlCommandBufferHandle& cmdBuff)
+void Sm::prepareDraw(CommandBufferHandle& cmdBuff)
 {
 	// disable color & blend & enable depth test
 
@@ -101,7 +101,7 @@ void Sm::prepareDraw(GlCommandBufferHandle& cmdBuff)
 }
 
 //==============================================================================
-void Sm::finishDraw(GlCommandBufferHandle& cmdBuff)
+void Sm::finishDraw(CommandBufferHandle& cmdBuff)
 {
 	m_r->getSceneDrawer().finishDraw();
 
@@ -112,7 +112,7 @@ void Sm::finishDraw(GlCommandBufferHandle& cmdBuff)
 
 //==============================================================================
 Error Sm::run(SceneNode* shadowCasters[], U32 shadowCastersCount, 
-	GlCommandBufferHandle& cmdBuff)
+	CommandBufferHandle& cmdBuff)
 {
 	ANKI_ASSERT(m_enabled);
 	Error err = ErrorCode::NONE;
@@ -175,7 +175,7 @@ Sm::Shadowmap& Sm::bestCandidate(SceneNode& light)
 
 //==============================================================================
 Error Sm::doLight(
-	SceneNode& light, GlCommandBufferHandle& cmdBuff, Sm::Shadowmap*& sm)
+	SceneNode& light, CommandBufferHandle& cmdBuff, Sm::Shadowmap*& sm)
 {
 	Error err = ErrorCode::NONE;
 

src/renderer/Ssao.cpp

@@ -67,7 +67,7 @@ public:
 //==============================================================================
 
 //==============================================================================
-Error Ssao::createFb(GlFramebufferHandle& fb, GlTextureHandle& rt)
+Error Ssao::createFb(FramebufferHandle& fb, TextureHandle& rt)
 {
 	Error err = ErrorCode::NONE;
 
@@ -75,13 +75,16 @@ Error Ssao::createFb(GlFramebufferHandle& fb, GlTextureHandle& rt)
 	if(err) return err;
 
 	// Set to bilinear because the blurring techniques take advantage of that
-	GlCommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGlDevice());
+	CommandBufferHandle cmdBuff;
+	err = cmdBuff.create(&getGrManager());
 	if(err) return err;
-	rt.setFilter(cmdBuff, GlTextureHandle::Filter::LINEAR);
+	rt.setFilter(cmdBuff, TextureHandle::Filter::LINEAR);
 
 	// create FB
-	err = fb.create(cmdBuff, {{rt, GL_COLOR_ATTACHMENT0}});
+	FramebufferHandle::Initializer fbInit;
+	fbInit.m_colorAttachmentsCount = 1;
+	fbInit.m_colorAttachments[0].m_texture = rt;
+	err = fb.create(cmdBuff, fbInit);
 	if(err) return err;
 
 	cmdBuff.flush();
@@ -118,34 +121,40 @@ Error Ssao::initInternal(const ConfigSet& config)
 	// create FBOs
 	//
 	err = createFb(m_hblurFb, m_hblurRt);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 	err = createFb(m_vblurFb, m_vblurRt);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	//
 	// noise texture
 	//
-	GlCommandBufferHandle cmdb;
-	err = cmdb.create(&getGlDevice());
-	if(err) return err;
+	CommandBufferHandle cmdb;
+	err = cmdb.create(&getGrManager());
+	if(err)
+	{
+		return err;
+	}
 
-	GlClientBufferHandle noise;
-	err = noise.create(
-		cmdb, sizeof(Vec3) * NOISE_TEX_SIZE * NOISE_TEX_SIZE, nullptr);
-	if(err) return err;
+	Array<Vec3, NOISE_TEX_SIZE * NOISE_TEX_SIZE> noise;
 
-	genNoise((Vec3*)noise.getBaseAddress(), 
-		(Vec3*)((U8*)noise.getBaseAddress() + noise.getSize()));
+	genNoise(&noise[0], &noise[0] + noise.getSize());
 
-	GlTextureHandle::Initializer tinit;
+	TextureHandle::Initializer tinit;
 
 	tinit.m_width = tinit.m_height = NOISE_TEX_SIZE;
 	tinit.m_target = GL_TEXTURE_2D;
 	tinit.m_internalFormat = GL_RGB32F;
-	tinit.m_filterType = GlTextureHandle::Filter::NEAREST;
+	tinit.m_filterType = TextureHandle::Filter::NEAREST;
 	tinit.m_repeat = true;
 	tinit.m_mipmapsCount = 1;
-	tinit.m_data[0][0] = noise;
+	tinit.m_data[0][0].m_ptr = static_cast<void*>(&noise[0]);
+	tinit.m_data[0][0].m_size = sizeof(noise);
 
 	m_noiseTex.create(cmdb, tinit);
 
@@ -178,7 +187,7 @@ Error Ssao::initInternal(const ConfigSet& config)
 	// Shaders
 	//
 	err = m_uniformsBuff.create(cmdb, GL_SHADER_STORAGE_BUFFER, 
-		sizeof(ShaderCommonUniforms), GL_DYNAMIC_STORAGE_BIT);
+		nullptr, sizeof(ShaderCommonUniforms), GL_DYNAMIC_STORAGE_BIT);
 	if(err) return err;
 
 	String pps;
@@ -259,7 +268,7 @@ Error Ssao::init(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Ssao::run(GlCommandBufferHandle& cmdb)
+Error Ssao::run(CommandBufferHandle& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
 	Error err = ErrorCode::NONE;
@@ -275,7 +284,7 @@ Error Ssao::run(GlCommandBufferHandle& cmdb)
 
 	m_uniformsBuff.bindShaderBuffer(cmdb, 0);
 
-	Array<GlTextureHandle, 3> tarr = {{
+	Array<TextureHandle, 3> tarr = {{
 		m_r->getDp().getSmallDepthRt(),
 		m_r->getMs()._getRt1(),
 		m_noiseTex}};
@@ -289,18 +298,11 @@ Error Ssao::run(GlCommandBufferHandle& cmdb)
 		|| m_commonUboUpdateTimestamp < camFr.getTimestamp()
 		|| m_commonUboUpdateTimestamp == 1)
 	{
-		GlClientBufferHandle tmpBuff;
-		err = tmpBuff.create(cmdb, sizeof(ShaderCommonUniforms), nullptr);
-		if(err) return err;
-
-		ShaderCommonUniforms& blk = 
-			*((ShaderCommonUniforms*)tmpBuff.getBaseAddress());
-
+		ShaderCommonUniforms blk;
 		blk.m_projectionParams = m_r->getProjectionParameters();
-
 		blk.m_projectionMatrix = camFr.getProjectionMatrix().getTransposed();
 
-		m_uniformsBuff.write(cmdb, tmpBuff, 0, 0, tmpBuff.getSize());
+		m_uniformsBuff.write(cmdb, &blk, sizeof(blk), 0, 0, sizeof(blk));
 		m_commonUboUpdateTimestamp = getGlobalTimestamp();
 	}
 
@@ -313,7 +315,7 @@ Error Ssao::run(GlCommandBufferHandle& cmdb)
 	{
 		if(i == 0)
 		{
-			Array<GlTextureHandle, 2> tarr = {{m_hblurRt, m_vblurRt}};
+			Array<TextureHandle, 2> tarr = {{m_hblurRt, m_vblurRt}};
 			cmdb.bindTextures(0, tarr.begin(), tarr.getSize());
 		}
 

src/renderer/Sslr.cpp

@@ -39,51 +39,83 @@ Error Sslr::init(const ConfigSet& config)
 		"#define WIDTH %u\n"
 		"#define HEIGHT %u\n",
 		m_width, m_height);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_reflectionFrag.loadToCache(&getResourceManager(),
 		"shaders/PpsSslr.frag.glsl", pps.toCString(), "r_");
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	err = m_r->createDrawQuadPipeline(
 		m_reflectionFrag->getGlProgram(), m_reflectionPpline);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
 
 	// Sampler
-	GlCommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGlDevice());
-	if(err) return err;
+	CommandBufferHandle cmdBuff;
+	err = cmdBuff.create(&getGrManager());
+	if(err)
+	{
+		return err;
+	}
 	err = m_depthMapSampler.create(cmdBuff);
-	if(err) return err;
-	m_depthMapSampler.setFilter(cmdBuff, GlSamplerHandle::Filter::NEAREST);
+	if(err)
+	{
+		return err;
+	}
+	m_depthMapSampler.setFilter(cmdBuff, SamplerHandle::Filter::NEAREST);
 
 	// Blit
 	err = m_blitFrag.load("shaders/Blit.frag.glsl", &getResourceManager());
-	if(err) return err;
-	err = m_r->createDrawQuadPipeline(
-		m_blitFrag->getGlProgram(), m_blitPpline);
-	if(err) return err;
+	if(err)
+	{
+		return err;
+	}
+	err = m_r->createDrawQuadPipeline(m_blitFrag->getGlProgram(), m_blitPpline);
+	if(err)
+	{
+		return err;
+	}
 
 	// Init FBOs and RTs and blurring
 	if(m_blurringIterationsCount > 0)
 	{
 		err = initBlurring(*m_r, m_width, m_height, 9, 0.0);
-		if(err) return err;
+		if(err)
+		{
+			return err;
+		}
 	}
 	else
 	{
 		Direction& dir = m_dirs[(U)DirectionEnum::VERTICAL];
 
 		err = m_r->createRenderTarget(m_width, m_height, GL_RGB8, 1, dir.m_rt);
-		if(err) return err;
+		if(err)
+		{
+			return err;
+		}
 
 		// Set to bilinear because the blurring techniques take advantage of 
 		// that
-		dir.m_rt.setFilter(cmdBuff, GlTextureHandle::Filter::LINEAR);
+		dir.m_rt.setFilter(cmdBuff, TextureHandle::Filter::LINEAR);
 
 		// Create FB
-		err = dir.m_fb.create(cmdBuff, {{dir.m_rt, GL_COLOR_ATTACHMENT0}});
-		if(err) return err;
+		FramebufferHandle::Initializer fbInit;
+		fbInit.m_colorAttachmentsCount = 1;
+		fbInit.m_colorAttachments[0].m_texture = dir.m_rt;
+		err = dir.m_fb.create(cmdBuff, fbInit);
+		if(err)
+		{
+			return err;
+		}
 	}
 
 	cmdBuff.finish();
@@ -92,7 +124,7 @@ Error Sslr::init(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Sslr::run(GlCommandBufferHandle& cmdBuff)
+Error Sslr::run(CommandBufferHandle& cmdBuff)
 {
 	ANKI_ASSERT(m_enabled);
 	Error err = ErrorCode::NONE;
@@ -104,7 +136,7 @@ Error Sslr::run(GlCommandBufferHandle& cmdBuff)
 
 	m_reflectionPpline.bind(cmdBuff);
 
-	Array<GlTextureHandle, 3> tarr = {{
+	Array<TextureHandle, 3> tarr = {{
 		m_r->getIs()._getRt(),
 		m_r->getDp().getSmallDepthRt(),
 		m_r->getMs()._getRt1()}};
@@ -115,7 +147,7 @@ Error Sslr::run(GlCommandBufferHandle& cmdBuff)
 
 	m_r->drawQuad(cmdBuff);
 
-	GlSamplerHandle::bindDefault(cmdBuff, 1); // Unbind the sampler
+	SamplerHandle::bindDefault(cmdBuff, 1); // Unbind the sampler
 
 	// Blurring
 	//

src/renderer/Tiler.cpp

@@ -86,7 +86,8 @@ Error Tiler::initInternal()
 	String pps;
 	String::ScopeDestroyer ppsd(&pps, getAllocator());
 
-	err = pps.sprintf(getAllocator(),
+	ANKI_CHECK(
+		pps.sprintf(getAllocator(),
 		"#define TILES_X_COUNT %u\n"
 		"#define TILES_Y_COUNT %u\n"
 		"#define RENDERER_WIDTH %u\n"
@@ -94,27 +95,27 @@ Error Tiler::initInternal()
 		m_r->getTilesCount().x(),
 		m_r->getTilesCount().y(),
 		m_r->getWidth(),
-		m_r->getHeight());
-	if(err) return err;
+		m_r->getHeight()));
 
-	err = m_frag.loadToCache(&getResourceManager(),
-		"shaders/TilerMinMax.frag.glsl", pps.toCString(), "r_");
-	if(err) return err;
+	ANKI_CHECK(
+		m_frag.loadToCache(&getResourceManager(), 
+		"shaders/TilerMinMax.frag.glsl", pps.toCString(), "r_"));
 
-	err = m_r->createDrawQuadPipeline(m_frag->getGlProgram(), m_ppline);
-	if(err) return err;
+	ANKI_CHECK(
+		m_r->createDrawQuadPipeline(m_frag->getGlProgram(), m_ppline));
 
 	// Create FB
-	err = m_r->createRenderTarget(
-		m_r->getTilesCount().x(), m_r->getTilesCount().y(), GL_RG32F, 1, m_rt);
-	if(err) return err;
+	ANKI_CHECK(
+		m_r->createRenderTarget(m_r->getTilesCount().x(), 
+		m_r->getTilesCount().y(), GL_RG32F, 1, m_rt));
 
-	GlCommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGlDevice());
-	if(err) return err;
+	CommandBufferHandle cmdBuff;
+	ANKI_CHECK(cmdBuff.create(&getGrManager()));
 
-	err = m_fb.create(cmdBuff, {{m_rt, GL_COLOR_ATTACHMENT0}});
-	if(err) return err;
+	FramebufferHandle::Initializer fbInit;
+	fbInit.m_colorAttachmentsCount = 1;
+	fbInit.m_colorAttachments[0].m_texture = m_rt;
+	ANKI_CHECK(m_fb.create(cmdBuff, fbInit));
 
 	// Init planes. One plane for each direction, plus near/far plus the world
 	// space of those
@@ -123,8 +124,7 @@ Error Tiler::initInternal()
 		+ (m_r->getTilesCount().y() - 1) * 2  // planes I
 		+ (m_r->getTilesCount().x() * m_r->getTilesCount().y() * 2); // near+far
 
-	err = m_allPlanes.create(getAllocator(), planesCount);
-	if(err) return err;
+	ANKI_CHECK(m_allPlanes.create(getAllocator(), planesCount));
 
 	Plane* base = &m_allPlanes[0];
 	U count = 0;
@@ -153,14 +153,10 @@ Error Tiler::initInternal()
 
 	cmdBuff.flush();
 
-	err = initPbos();
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(initPbos());
 
-	err = m_prevMinMaxDepth.create(getAllocator(),
-		m_r->getTilesCount().x() * m_r->getTilesCount().y(), Vec2(0.0, 1.0));
+	ANKI_CHECK(m_prevMinMaxDepth.create(getAllocator(),
+		m_r->getTilesCount().x() * m_r->getTilesCount().y(), Vec2(0.0, 1.0)));
 
 	return err;
 }
@@ -170,12 +166,8 @@ Error Tiler::initPbos()
 {
 	Error err = ErrorCode::NONE;
 
-	GlCommandBufferHandle cmd;
-	err = cmd.create(&getGlDevice());
-	if(err)
-	{
-		return err;
-	}
+	CommandBufferHandle cmd;
+	ANKI_CHECK(cmd.create(&getGrManager()));
 
 	// Allocate the buffers
 	U pboSize = m_r->getTilesCount().x() * m_r->getTilesCount().y();
@@ -183,12 +175,9 @@ Error Tiler::initPbos()
 
 	for(U i = 0; i < m_pbos.getSize(); ++i)
 	{
-		err = m_pbos[i].create(cmd, GL_PIXEL_PACK_BUFFER, pboSize,
-			GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
-		if(err)
-		{
-			return err;
-		}
+		ANKI_CHECK(
+			m_pbos[i].create(cmd, GL_PIXEL_PACK_BUFFER, nullptr, pboSize,
+			GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
 	}
 	cmd.flush();
 
@@ -203,8 +192,8 @@ Error Tiler::initPbos()
 }
 
 //==============================================================================
-void Tiler::runMinMax(GlTextureHandle& depthMap,
-	GlCommandBufferHandle& cmd)
+void Tiler::runMinMax(TextureHandle& depthMap,
+	CommandBufferHandle& cmd)
 {
 	if(m_enableGpuTests)
 	{

src/resource/Model.cpp

@@ -27,12 +27,12 @@ ModelPatchBase::~ModelPatchBase()
 
 //==============================================================================
 Error ModelPatchBase::createVertexDesc(
-	const GlShaderHandle& prog,
+	const ShaderHandle& prog,
 	const Mesh& mesh,
-	GlCommandBufferHandle& vertexJobs)
+	CommandBufferHandle& vertexJobs)
 {
 	Error err = ErrorCode::NONE;
-	GlBufferHandle vbo;
+	BufferHandle vbo;
 	U32 size;
 	GLenum type;
 	U32 stride;
@@ -76,8 +76,8 @@ Error ModelPatchBase::createVertexDesc(
 //==============================================================================
 Error ModelPatchBase::getRenderingDataSub(
 	const RenderingKey& key, 
-	GlCommandBufferHandle& vertJobs, 
-	GlPipelineHandle& ppline,
+	CommandBufferHandle& vertJobs, 
+	PipelineHandle& ppline,
 	const U8* subMeshIndexArray, 
 	U32 subMeshIndexCount,
 	Array<U32, ANKI_GL_MAX_SUB_DRAWCALLS>& indicesCountArray,
@@ -150,7 +150,7 @@ Error ModelPatchBase::getRenderingDataSub(
 }
 
 //==============================================================================
-Error ModelPatchBase::create(GlDevice* gl)
+Error ModelPatchBase::create(GrManager* gl)
 {
 	Error err = ErrorCode::NONE;
 
@@ -164,7 +164,7 @@ Error ModelPatchBase::create(GlDevice* gl)
 		for(U pass = 0; pass < mtl.getPassesCount(); ++pass)
 		{
 			RenderingKey key((Pass)pass, lod, false);
-			GlShaderHandle prog;
+			ShaderHandle prog;
 			const Mesh* mesh;
 
 			// Get mesh
@@ -179,12 +179,12 @@ Error ModelPatchBase::create(GlDevice* gl)
 			shaderKey.m_lod = std::min(key.m_lod, 
 				(U8)(getMaterial().getLevelsOfDetail() - 1));
 
-			GlPipelineHandle ppline;
+			PipelineHandle ppline;
 			ANKI_CHECK(m_mtl->getProgramPipeline(shaderKey, ppline));
 			prog = ppline.getAttachedProgram(GL_VERTEX_SHADER);
 			
 			// Create vert descriptor
-			GlCommandBufferHandle vertJobs;
+			CommandBufferHandle vertJobs;
 			ANKI_CHECK(vertJobs.create(gl));
 			ANKI_CHECK(createVertexDesc(prog, *mesh, vertJobs));
 
@@ -255,7 +255,7 @@ Error ModelPatch<MeshResourcePointerType>::create(
 	m_mtl = m_mtlResource.get();
 
 	// Create VAOs
-	ANKI_CHECK(Base::create(&resources->_getGlDevice()));
+	ANKI_CHECK(Base::create(&resources->getGrManager()));
 
 	return err;
 }

src/resource/ResourceManager.cpp

@@ -36,7 +36,7 @@ Error ResourceManager::create(Initializer& init)
 {
 	Error err = ErrorCode::NONE;
 
-	m_gl = init.m_gl;
+	m_gr = init.m_gr;
 	m_physics = init.m_physics;
 	m_alloc = ResourceAllocator<U8>(
 		init.m_allocCallback, init.m_allocCallbackData);

src/resource/TextureResource.cpp

@@ -31,14 +31,15 @@ Error TextureResource::load(const CString& filename, ResourceInitializer& rinit)
 {
 	GrManager& gr = rinit.m_resources.getGrManager();
 	CommandBufferHandle cmdb;
-	Error err = cmdb.create(&gl); // Always first to avoid assertions (
+	Error err = cmdb.create(&gr); // Always first to avoid assertions (
 	                              // because of the check of the allocator)
 	if(err)
 	{
 		return err;
 	}
 
-	GlTextureHandle::Initializer init;
+	TextureHandle::Initializer init;
+	init.m_copyDataBeforeReturn = false;
 	U layers = 0;
 
 	// Load image
@@ -143,7 +144,7 @@ Error TextureResource::load(const CString& filename, ResourceInitializer& rinit)
 	init.m_mipmapsCount = img->getMipLevelsCount();
 
 	// filteringType
-	init.m_filterType = GlTextureHandle::Filter::TRILINEAR;
+	init.m_filterType = TextureHandle::Filter::TRILINEAR;
 
 	// repeat
 	init.m_repeat = true;
@@ -156,19 +157,11 @@ Error TextureResource::load(const CString& filename, ResourceInitializer& rinit)
 	{
 		for(U level = 0; level < init.m_mipmapsCount; level++)
 		{
-			GlClientBufferHandle& buff = init.m_data[level][layer];
 			const auto& surf = img->getSurface(level, layer);
+			auto& grsurf = init.m_data[level][layer];
 
-			err = buff.create(
-				cmdb, 
-				surf.m_data.getSize(), 
-				const_cast<U8*>(&surf.m_data[0]));
-
-			if(err)
-			{
-				rinit.m_alloc.deleteInstance(img);
-				return err;
-			}
+			grsurf.m_size = surf.m_data.getSize();
+			grsurf.m_ptr = &surf.m_data[0];
 		}
 	}
 

src/scene/LensFlareComponent.cpp

@@ -17,17 +17,17 @@ Error LensFlareComponent::create(const CString& textureFilename)
 		textureFilename, &m_node->getSceneGraph()._getResourceManager());
 
 	// Queries
-	GlDevice& gl = m_node->getSceneGraph()._getGlDevice();
+	GrManager& gr = m_node->getSceneGraph().getGrManager();
 	for(auto it = m_queries.getBegin(); it != m_queries.getEnd() && !err; ++it)
 	{
-		err = (*it).create(&gl, GlOcclusionQueryHandle::ResultBit::VISIBLE);
+		err = (*it).create(&gr, OcclusionQueryHandle::ResultBit::VISIBLE);
 	}
 
 	return err;
 }
 
 //==============================================================================
-GlOcclusionQueryHandle& LensFlareComponent::getOcclusionQueryToTest()
+OcclusionQueryHandle& LensFlareComponent::getOcclusionQueryToTest()
 {
 	// Move the query counter
 	m_crntQueryIndex = (m_crntQueryIndex + 1) % m_queries.getSize();
@@ -40,7 +40,7 @@ GlOcclusionQueryHandle& LensFlareComponent::getOcclusionQueryToTest()
 
 //==============================================================================
 void LensFlareComponent::getOcclusionQueryToCheck(
-	GlOcclusionQueryHandle& q, Bool& queryInvalid)
+	OcclusionQueryHandle& q, Bool& queryInvalid)
 {
 	U idx = (m_crntQueryIndex + 1) % m_queries.getSize();
 

src/scene/ModelNode.cpp

@@ -110,8 +110,8 @@ Error ModelPatchNode::buildRendering(RenderingBuildData& data)
 	Array<PtrSize, ANKI_GL_MAX_SUB_DRAWCALLS> indicesOffsetArray;
 	U32 drawcallCount;
 
-	GlCommandBufferHandle vertJobs;
-	GlPipelineHandle ppline;
+	CommandBufferHandle vertJobs;
+	PipelineHandle ppline;
 
 	Error err = m_modelPatch->getRenderingDataSub(
 		data.m_key, vertJobs, ppline, 

src/scene/ParticleEmitter.cpp

@@ -347,13 +347,13 @@ Error ParticleEmitter::create(
 	if(err) return err;
 
 	// Create the vertex buffer and object
-	GlCommandBufferHandle cmd;
-	GlDevice& gl = getSceneGraph()._getGlDevice();
-	err = cmd.create(&gl);
+	CommandBufferHandle cmd;
+	GrManager& gr = getSceneGraph().getGrManager();
+	err = cmd.create(&gr);
 	if(err) return err;
 
 	PtrSize buffSize = m_maxNumOfParticles * VERT_SIZE * 3;
-	err = m_vertBuff.create(cmd, GL_ARRAY_BUFFER, buffSize, 
+	err = m_vertBuff.create(cmd, GL_ARRAY_BUFFER, nullptr, buffSize, 
 		GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 	if(err) return err;
 
@@ -379,7 +379,7 @@ Error ParticleEmitter::buildRendering(RenderingBuildData& data)
 	RenderingKey key = data.m_key;
 	key.m_lod = 0;
 
-	GlPipelineHandle ppline;
+	PipelineHandle ppline;
 	err = m_particleEmitterResource->getMaterial().getProgramPipeline(
 		key, ppline);
 	

src/scene/SceneGraph.cpp

@@ -113,7 +113,7 @@ Error SceneGraph::create(
 	m_resources = resources;
 	m_objectsMarkedForDeletionCount.store(0);
 	m_ambientCol = Vec3(0.0);
-	m_gl = &m_resources->_getGlDevice();
+	m_gr = &m_resources->getGrManager();
 	m_physics = &m_resources->_getPhysicsWorld();
 	m_input = input;
 

src/scene/StaticGeometryNode.cpp

@@ -96,8 +96,8 @@ Error StaticGeometryPatchNode::buildRendering(RenderingBuildData& data)
 	Array<U32, ANKI_GL_MAX_SUB_DRAWCALLS> indicesCountArray;
 	Array<PtrSize, ANKI_GL_MAX_SUB_DRAWCALLS> indicesOffsetArray;
 	U32 drawCount;
-	GlCommandBufferHandle vertJobs;
-	GlPipelineHandle ppline;
+	CommandBufferHandle vertJobs;
+	PipelineHandle ppline;
 
 	err = m_modelPatch->getRenderingDataSub(
 		data.m_key, vertJobs, ppline,