Removing exceptions. It will not compile

include/anki/gl/GlCommandBuffer.h

@@ -29,7 +29,7 @@ public:
 	{}
 
 	/// Execute command
-	virtual void operator()(GlCommandBuffer*) = 0;
+	virtual ANKI_USE_RESULT Error operator()(GlCommandBuffer*) = 0;
 };
 
 /// A common command that deletes an object
@@ -47,9 +47,10 @@ public:
 		ANKI_ASSERT(m_ptr);
 	}
 
-	void operator()(GlCommandBuffer*)
+	Error operator()(GlCommandBuffer*)
 	{
 		m_alloc.deleteInstance(m_ptr);
+		return ErrorCode::NONE;
 	}
 };
 
@@ -62,7 +63,7 @@ class GlCommandBufferInitHints
 private:
 	enum
 	{
-		MAX_CHUNK_SIZE = 4 * 1024 * 1024 // 1MB
+		MAX_CHUNK_SIZE = 4 * 1024 * 1024 // 4MB
 	};
 
 	PtrSize m_chunkSize = 1024;
@@ -130,7 +131,7 @@ public:
 	}
 
 	/// Execute all commands
-	void executeAllCommands();
+	ANKI_USE_RESULT Error executeAllCommands();
 
 	/// Fake that it's been executed
 	void makeExecuted()

include/anki/gl/GlCommandBufferHandle.h

@@ -23,7 +23,7 @@ class GlCommandBufferHandle: public GlHandle<GlCommandBuffer>
 {
 public:
 	using Base = GlHandle<GlCommandBuffer>;
-	using UserCallback = void(*)(void*);
+	using UserCallback = Error(*)(void*);
 
 	GlCommandBufferHandle();
 
@@ -178,9 +178,9 @@ public:
 	}
 
 	/// Execute all commands
-	void _executeAllCommands()
+	ANKI_USE_RESULT Error _executeAllCommands()
 	{
-		_get().executeAllCommands();
+		return _get().executeAllCommands();
 	}
 	/// @}
 };

include/anki/gl/GlContainerHandle.h

@@ -23,16 +23,27 @@ public:
 
 protected:
 	/// Check if the object has been created and if not serialize the server
-	void serializeOnGetter() const
+	ANKI_USE_RESULT Error serializeOnGetter() const
 	{
+		Error err = ErrorCode::NONE;
 		GlHandleState state = Base::_getState();
 		ANKI_ASSERT(state != GlHandleState::NEW);
-
+		
 		if(state == GlHandleState::TO_BE_CREATED)
 		{
 			Base::_getDevice()._getQueue().syncClientServer();
-			ANKI_ASSERT(Base::_getState() > GlHandleState::TO_BE_CREATED);
+
+			state = Base::_getState();
+
+			if(state == GlHandleState::ERROR)
+			{
+				err = ErrorCode::UNKNOWN;
+			}
 		}
+
+		ANKI_ASSERT(state > GlHandleState::TO_BE_CREATED);
+
+		return err;
 	}
 };
 

include/anki/gl/GlDevice.h

@@ -34,7 +34,7 @@ public:
 		const CString& cacheDir);
 
 	/// Start the queue thread. @see GlQueue::start
-	void startServer(
+	ANKI_USE_RESULT Error startServer(
 		GlMakeCurrentCallback makeCurrentCb, void* makeCurrentCbData, void* ctx,
 		GlCallback swapBuffersCallback, void* swapBuffersCbData,
 		Bool registerDebugMessages);

include/anki/gl/GlOperations.h

@@ -1,232 +0,0 @@
-// Copyright (C) 2014, Panagiotis Christopoulos Charitos.
-// All rights reserved.
-// Code licensed under the BSD License.
-// http://www.anki3d.org/LICENSE
-
-#ifndef ANKI_GL_GL_OPERATIONS_H
-#define ANKI_GL_GL_OPERATIONS_H
-
-#include "anki/gl/GlCommon.h"
-#include "anki/gl/GlBufferHandle.h"
-#include "anki/gl/GlClientBufferHandle.h"
-
-namespace anki {
-
-/// @addtogroup opengl_other
-/// @{
-
-/// A GL drawcall for elements
-class GlDrawcallElements
-{
-	friend class GlDrawElementsCommand;
-
-public:
-	/// Indirect structure
-	class Indirect
-	{
-	public:
-		Indirect()
-		{}
-
-		Indirect(U32 count, U32 instanceCount, U32 firstIndex, 
-			U32 baseVertex, U32 baseInstance)
-			:	m_count(count), m_instanceCount(instanceCount), 
-				m_firstIndex(firstIndex), m_baseVertex(baseVertex),
-				m_baseInstance(baseInstance)
-		{}
-
-		U32 m_count;
-		U32 m_instanceCount = 1;
-		U32 m_firstIndex = 0;
-		U32 m_baseVertex = 0;
-		U32 m_baseInstance = 0;
-	};
-
-	/// Default
-	GlDrawcallElements()
-		: m_drawCount(0)
-	{}
-
-	/// Initialize a glDrawElementsInstancedBaseVertexBaseInstance call
-	GlDrawcallElements(GLenum mode, U8 indexSize, U32 count, 
-		U32 instanceCount = 1, U32 firstIndex = 0, U32 baseVertex = 0,
-		U32 baseInstance = 0)
-		:	m_primitiveType(mode),
-			m_indexSize(indexSize),
-			m_drawCount(1)
-	{
-		m_noIndirect.m_count = count;
-		m_noIndirect.m_instanceCount = instanceCount;
-		m_noIndirect.m_firstIndex = firstIndex;
-		m_noIndirect.m_baseVertex = baseVertex;
-		m_noIndirect.m_baseInstance = baseInstance;
-	}
-
-	/// Initialize a glMultiDrawElementsIndirect call with server buffer
-	GlDrawcallElements(GLenum mode, U8 indexSize, 
-		const GlBufferHandle& indirectBuff, U32 drawCount, 
-		PtrSize offset, PtrSize stride)
-		:	m_primitiveType(mode),
-			m_indexSize(indexSize),
-			m_drawCount(drawCount),
-			m_indirectBuff(indirectBuff)
-	{
-		m_indirect.m_offset = offset;
-		m_indirect.m_stride = stride;
-	}
-
-	/// Initialize a glMultiDrawElementsIndirect call with client buffer
-	GlDrawcallElements(GLenum mode, U8 indexSize, 
-		const GlClientBufferHandle& indirectBuff, U32 drawCount, 
-		PtrSize offset, PtrSize stride)
-		:	m_primitiveType(mode),
-			m_indexSize(indexSize),
-			m_drawCount(drawCount),
-			m_indirectClientBuff(indirectBuff)
-	{
-		m_indirect.m_offset = offset;
-		m_indirect.m_stride = stride;
-	}
-
-	Bool isCreated() const
-	{
-		return m_drawCount > 0;
-	}
-
-	/// Execute the drawcall
-	void draw(GlCommandBufferHandle& commands);
-
-private:
-	class IndirectView
-	{
-	public:
-		/// Indirect buffer offset
-		U32 m_offset;
-	
-		/// Indirect buffer stride
-		U32 m_stride;
-	};
-
-	/// The GL primitive type (eg GL_POINTS). Need to set it
-	GLenum m_primitiveType;
-	
-	/// Type of the indices
-	U8 m_indexSize;
-
-	/// Used in glMultiDrawElementsXXX
-	U8 m_drawCount;
-
-	/// Indirect buffer
-	GlBufferHandle m_indirectBuff;
-
-	/// Indirect client buffer
-	GlClientBufferHandle m_indirectClientBuff;
-
-	union
-	{
-		Indirect m_noIndirect;
-		IndirectView m_indirect;
-	};
-
-	/// Execute the command. Called by the server
-	void exec();
-};
-
-/// A GL drawcall for arrays
-class GlDrawcallArrays
-{
-	friend class GlDrawArraysCommand;
-
-public:
-	/// Indirect structure
-	class Indirect
-	{
-	public:
-		Indirect()
-		{}
-
-		Indirect(U32 count, U32 instanceCount, U32 first, U32 baseInstance)
-			:	m_count(count), 
-				m_instanceCount(instanceCount), 
-				m_first(first), 
-				m_baseInstance(baseInstance)
-		{}
-
-		U32 m_count;
-		U32 m_instanceCount = 1;
-		U32 m_first = 0;
-		U32 m_baseInstance = 0;	
-	};
-
-	/// Default
-	GlDrawcallArrays()
-		: m_drawCount(0)
-	{}
-
-	/// Initialize a glDrawArraysInstancedBaseInstance call
-	GlDrawcallArrays(GLenum mode, U32 count, U32 instanceCount = 1, 
-		U32 first = 0, U32 baseInstance = 0)
-		:	m_primitiveType(mode),
-			m_noIndirect{count, instanceCount, first, baseInstance},
-			m_drawCount(1)
-	{}
-	
-	/// Initialize a glMultiDrawArraysIndirect call with server buffer
-	GlDrawcallArrays(GLenum mode, const GlBufferHandle& indirectBuff,
-		U32 drawCount, PtrSize offset, PtrSize stride)
-		:	m_primitiveType(mode),
-			m_drawCount(drawCount),
-			m_indirectBuff(indirectBuff),
-			m_offset(offset),
-			m_stride(stride)
-	{}
-
-	/// Initialize a glMultiDrawArraysIndirect call with client buffer
-	GlDrawcallArrays(GLenum mode, const GlClientBufferHandle& indirectBuff,
-		U32 drawCount, PtrSize offset, PtrSize stride)
-		:	m_primitiveType(mode),
-			m_drawCount(drawCount),
-			m_indirectClientBuff(indirectBuff),
-			m_offset(offset),
-			m_stride(stride)
-	{}
-
-	Bool isCreated() const
-	{
-		return m_drawCount > 0;
-	}
-
-	/// Execute the drawcall
-	void draw(GlCommandBufferHandle& commands);
-
-private:
-	/// The GL primitive type (eg GL_POINTS). Need to set it
-	GLenum m_primitiveType;
-
-	/// No indirect data
-	Indirect m_noIndirect;
-
-	/// Used in glMultiDrawArraysXXX
-	U8 m_drawCount;
-
-	/// Indirect buffer
-	GlBufferHandle m_indirectBuff;
-
-	/// Indirect client buffer
-	GlClientBufferHandle m_indirectClientBuff;
-
-	/// Indirect buffer offset
-	U32 m_offset;
-	
-	/// Indirect buffer stride
-	U32 m_stride;
-
-	/// Execute the command. Called by the server
-	void exec();
-};
-
-/// @}
-
-} // end namespace anki
-
-#endif

include/anki/gl/GlQueue.h

@@ -63,7 +63,7 @@ public:
 
 	/// Start the working thread
 	/// @note Don't free the context before calling #stop
-	void start(
+	ANKI_USE_RESULT Error start(
 		GlMakeCurrentCallback makeCurrentCb, void* makeCurrentCbData, void* ctx,
 		GlCallback swapBuffersCallback, void* swapBuffersCbData,
 		Bool registerMessages);
@@ -129,7 +129,7 @@ private:
 	void prepare();
 	void finish();
 
-	static void swapBuffersInternal(void* self);
+	static Error swapBuffersInternal(void* self);
 };
 
 /// @}

include/anki/gl/GlTextureHandle.h

@@ -54,15 +54,6 @@ public:
 	/// Set a texture parameter
 	void setParameter(
 		GlCommandBufferHandle& commands, GLenum param, GLint value);
-
-	/// Get depth
-	U32 getDepth() const;
-
-	/// Get width
-	U32 getWidth() const;
-
-	/// Get height
-	U32 getHeight() const;
 };
 
 /// Sampler handle

src/gl/GlBufferHandle.cpp

@@ -42,7 +42,7 @@ public:
 		m_empty(true)
 	{}
 
-	void operator()(GlCommandBuffer*)
+	Error operator()(GlCommandBuffer*)
 	{
 		Error err = ErrorCode::NONE;
 
@@ -55,11 +55,14 @@ public:
 		{
 			err = m_buff._get().create(m_target, m_size, nullptr, m_flags);
 		}
-		ANKI_ASSERT(!err);
 
-		GlHandleState oldState = m_buff._setState(GlHandleState::CREATED);
+		GlHandleState oldState = m_buff._setState(
+			(err) ? GlHandleState::ERROR : GlHandleState::CREATED);
+
 		(void)oldState;
 		ANKI_ASSERT(oldState == GlHandleState::TO_BE_CREATED);
+
+		return err;
 	}
 };
 
@@ -151,7 +154,7 @@ void GlBufferHandle::write(GlCommandBufferHandle& commands,
 				m_writeOffset(writeOffset), m_size(size)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			ANKI_ASSERT(m_readOffset + m_size <= m_data.getSize());
 
@@ -159,6 +162,8 @@ void GlBufferHandle::write(GlCommandBufferHandle& commands,
 				(U8*)m_data.getBaseAddress() + m_readOffset, 
 				m_writeOffset, 
 				m_size);
+
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -183,12 +188,14 @@ void GlBufferHandle::bindShaderBufferInternal(GlCommandBufferHandle& commands,
 			: m_buff(buff), m_offset(offset), m_size(size), m_binding(binding)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			U32 offset = (m_offset != -1) ? m_offset : 0;
 			U32 size = (m_size != -1) ? m_size : m_buff._get().getSize();
 
 			m_buff._get().setBindingRange(m_binding, offset, size);
+
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -228,7 +235,7 @@ void GlBufferHandle::bindVertexBuffer(
 			m_attribLocation(attribLocation)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			GlBuffer& buff = m_buff._get();
 			ANKI_ASSERT(m_offset < m_buff.getSize());
@@ -244,6 +251,8 @@ void GlBufferHandle::bindVertexBuffer(
 				m_normalized,
 				m_stride, 
 				reinterpret_cast<const GLvoid*>(m_offset));
+
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -264,11 +273,13 @@ void GlBufferHandle::bindIndexBuffer(GlCommandBufferHandle& commands)
 		:	m_buff(buff)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			GlBuffer& buff = m_buff._get();
 			buff.setTarget(GL_ELEMENT_ARRAY_BUFFER);
 			buff.bind();
+
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -279,22 +290,20 @@ void GlBufferHandle::bindIndexBuffer(GlCommandBufferHandle& commands)
 //==============================================================================
 PtrSize GlBufferHandle::getSize() const
 {
-	serializeOnGetter();
-	return _get().getSize();
+	return (serializeOnGetter()) ? 0 : _get().getSize();
 }
 
 //==============================================================================
 GLenum GlBufferHandle::getTarget() const
 {
-	serializeOnGetter();
-	return _get().getTarget();
+	return (serializeOnGetter()) ? GL_NONE : _get().getTarget();
 }
 
 //==============================================================================
 void* GlBufferHandle::getPersistentMappingAddress()
 {
-	serializeOnGetter();
-	return _get().getPersistentMappingAddress();
+	return 
+		(serializeOnGetter()) ? nullptr : _get().getPersistentMappingAddress();
 }
 
 } // end namespace anki

src/gl/GlCommandBuffer.cpp

@@ -64,7 +64,7 @@ GlAllocator<U8> GlCommandBuffer::getGlobalAllocator() const
 }
 
 //==============================================================================
-void GlCommandBuffer::executeAllCommands()
+Error GlCommandBuffer::executeAllCommands()
 {
 	ANKI_ASSERT(m_firstCommand != nullptr && "Empty command buffer");
 	ANKI_ASSERT(m_lastCommand != nullptr && "Empty command buffer");
@@ -72,15 +72,19 @@ void GlCommandBuffer::executeAllCommands()
 	m_executed = true;
 #endif
 	
+	Error err = ErrorCode::NONE;
+
 	GlCommand* command = m_firstCommand;
 
-	while(command != nullptr)
+	while(command != nullptr && !err)
 	{
-		(*command)(this);
+		err = (*command)(this);
 		ANKI_CHECK_GL_ERROR();
 
 		command = command->m_nextCommand;
 	}
+
+	return err;
 }
 
 //==============================================================================

src/gl/GlCommandBufferHandle.cpp

@@ -22,9 +22,10 @@ namespace anki {
 	{ \
 	public: \
 		Command() = default \
-		void operator()(GlCommandBuffer*) \
+		Error operator()(GlCommandBuffer*) \
 		{ \
 			glfunc_(); \
+			return ErrorCode::NONE; \
 		} \
 	}; \
 	_pushBackNewCommand<Command>(value_)
@@ -37,9 +38,10 @@ namespace anki {
 		Command(type_ v) \
 		:	m_value(v) \
 		{} \
-		void operator()(GlCommandBuffer*) \
+		Error operator()(GlCommandBuffer*) \
 		{ \
 			glfunc_(m_value); \
+			return ErrorCode::NONE; \
 		} \
 	}; \
 	_pushBackNewCommand<Command>(value_)
@@ -53,9 +55,10 @@ namespace anki {
 		{ \
 			m_value = {{a, b}}; \
 		} \
-		void operator()(GlCommandBuffer*) \
+		Error operator()(GlCommandBuffer*) \
 		{ \
 			glfunc_(m_value[0], m_value[1]); \
+			return ErrorCode::NONE; \
 		} \
 	}; \
 	_pushBackNewCommand<Command>(a_, b_)
@@ -69,9 +72,10 @@ namespace anki {
 		{ \
 			m_value = {{a, b, c}}; \
 		} \
-		void operator()(GlCommandBuffer*) \
+		Error operator()(GlCommandBuffer*) \
 		{ \
 			glfunc_(m_value[0], m_value[1], m_value[2]); \
+			return ErrorCode::NONE; \
 		} \
 	}; \
 	_pushBackNewCommand<Command>(a_, b_, c_)
@@ -85,9 +89,10 @@ namespace anki {
 		{ \
 			m_value = {{a, b, c, d}}; \
 		} \
-		void operator()(GlCommandBuffer*) \
+		Error operator()(GlCommandBuffer*) \
 		{ \
 			glfunc_(m_value[0], m_value[1], m_value[2], m_value[3]); \
+			return ErrorCode::NONE; \
 		} \
 	}; \
 	_pushBackNewCommand<Command>(a_, b_, c_, d_)
@@ -100,7 +105,7 @@ namespace anki {
 		Command(Bool enable) \
 		:	m_enable(enable) \
 		{} \
-		void operator()(GlCommandBuffer*) \
+		Error operator()(GlCommandBuffer*) \
 		{ \
 			if(m_enable) \
 			{ \
@@ -110,6 +115,7 @@ namespace anki {
 			{ \
 				glDisable(enum_); \
 			} \
+			return ErrorCode::NONE; \
 		} \
 	}; \
 	_pushBackNewCommand<Command>(enable_)
@@ -162,9 +168,9 @@ void GlCommandBufferHandle::pushBackUserCommand(
 			ANKI_ASSERT(m_callback);
 		}
 
-		void operator()(GlCommandBuffer* commands)
+		Error operator()(GlCommandBuffer* commands)
 		{
-			(*m_callback)(m_userData);
+			return (*m_callback)(m_userData);
 		}
 	};
 
@@ -184,9 +190,9 @@ void GlCommandBufferHandle::pushBackOtherCommandBuffer(
 		:	m_commands(commands)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
-			m_commands._executeAllCommands();
+			return m_commands._executeAllCommands();
 		}
 	};
 
@@ -243,7 +249,7 @@ void GlCommandBufferHandle::setViewport(U16 minx, U16 miny, U16 maxx, U16 maxy)
 			m_value = {{a, b, c, d}};
 		}
 
-		void operator()(GlCommandBuffer* commands)
+		Error operator()(GlCommandBuffer* commands)
 		{
 			GlState& state = commands->getQueue().getState();
 
@@ -256,6 +262,8 @@ void GlCommandBufferHandle::setViewport(U16 minx, U16 miny, U16 maxx, U16 maxy)
 
 				state.m_viewport = m_value;
 			}
+
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -338,7 +346,7 @@ void GlCommandBufferHandle::setBlendFunctions(GLenum sfactor, GLenum dfactor)
 			: m_sfactor(sfactor), m_dfactor(dfactor)
 		{}
 
-		void operator()(GlCommandBuffer* commands)
+		Error operator()(GlCommandBuffer* commands)
 		{
 			GlState& state = commands->getQueue().getState();
 
@@ -350,6 +358,8 @@ void GlCommandBufferHandle::setBlendFunctions(GLenum sfactor, GLenum dfactor)
 				state.m_blendSfunc = m_sfactor;
 				state.m_blendDfunc = m_dfactor;
 			}
+
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -423,7 +433,7 @@ void GlCommandBufferHandle::bindTextures(U32 first,
 			m_texes = std::move(texes);
 		}
 
-		void operator()(GlCommandBuffer* commands)
+		Error operator()(GlCommandBuffer* commands)
 		{
 			Array<GLuint, 16> names;
 
@@ -435,6 +445,8 @@ void GlCommandBufferHandle::bindTextures(U32 first,
 
 			ANKI_ASSERT(count > 0);
 			glBindTextures(m_first, count, &names[0]);
+
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -462,7 +474,7 @@ public:
 	:	m_info(info)
 	{}
 
-	void operator()(GlCommandBuffer*)
+	Error operator()(GlCommandBuffer*)
 	{
 		ANKI_ASSERT(indexSize != 0);
 
@@ -493,6 +505,8 @@ public:
 			m_info.m_baseInstance);
 
 		ANKI_COUNTER_INC(GL_DRAWCALLS_COUNT, (U64)1);
+
+		return ErrorCode::NONE;
 	}
 };
 
@@ -542,7 +556,7 @@ public:
 	:	m_info(info)
 	{}
 
-	void operator()(GlCommandBuffer*)
+	Error operator()(GlCommandBuffer*)
 	{
 		glDrawArraysInstancedBaseInstance(
 			mode,
@@ -552,6 +566,8 @@ public:
 			m_info.m_baseInstance);
 
 		ANKI_COUNTER_INC(GL_DRAWCALLS_COUNT, (U64)1);
+
+		return ErrorCode::NONE;
 	}
 };
 

src/gl/GlDevice.cpp

@@ -48,18 +48,23 @@ void GlDevice::destroy()
 }
 
 //==============================================================================
-void GlDevice::startServer(
+Error GlDevice::startServer(
 	GlMakeCurrentCallback makeCurrentCb, void* makeCurrentCbData, void* ctx,
 	GlCallback swapBuffersCallback, void* swapBuffersCbData,
 	Bool registerDebugMessages)
 {
-	m_queue->start(makeCurrentCb, makeCurrentCbData, ctx, 
+	Error err = m_queue->start(makeCurrentCb, makeCurrentCbData, ctx, 
 		swapBuffersCallback, swapBuffersCbData, 
 		registerDebugMessages);
 
-	syncClientServer();
+	if(!err)
+	{
+		syncClientServer();
+
+		m_queueStarted = true;
+	}
 
-	m_queueStarted = true;
+	return err;
 }
 
 //==============================================================================

src/gl/GlFramebufferHandle.cpp

@@ -38,7 +38,7 @@ Error GlFramebufferHandle::create(
 			m_fb(handle)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			Attachment* begin;
 			Attachment* end;
@@ -54,10 +54,13 @@ Error GlFramebufferHandle::create(
 			}
 
 			Error err = m_fb._get().create(begin, end);
-			ANKI_ASSERT(!err);
-			GlHandleState oldState = m_fb._setState(GlHandleState::CREATED);
+
+			GlHandleState oldState = m_fb._setState(
+				(err) ? GlHandleState::ERROR : GlHandleState::CREATED);
 			ANKI_ASSERT(oldState == GlHandleState::TO_BE_CREATED);
 			(void)oldState;
+
+			return err;
 		}
 	};
 
@@ -102,9 +105,10 @@ void GlFramebufferHandle::bind(GlCommandBufferHandle& commands, Bool invalidate)
 			m_invalidate(invalidate)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			m_fb._get().bind(m_invalidate);
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -142,10 +146,12 @@ void GlFramebufferHandle::blit(GlCommandBufferHandle& commands,
 			m_linear(linear)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			m_fbDest._get().blit(m_fbSrc._get(), m_sourceRect, m_destRect, 
 				m_attachmentMask, m_linear);
+
+			return ErrorCode::NONE;
 		}
 	};
 

src/gl/GlOperations.cpp

@@ -1,180 +0,0 @@
-// Copyright (C) 2014, Panagiotis Christopoulos Charitos.
-// All rights reserved.
-// Code licensed under the BSD License.
-// http://www.anki3d.org/LICENSE
-
-#include "anki/gl/GlOperations.h"
-#include "anki/gl/GlBuffer.h"
-#include "anki/core/Counters.h"
-
-namespace anki {
-
-//==============================================================================
-// GlDrawcallElements                                                          =
-//==============================================================================
-
-//==============================================================================
-class GlDrawElementsCommand: public GlCommand
-{
-public:
-	GlDrawcallElements m_dc;
-
-	GlDrawElementsCommand(const GlDrawcallElements& dc)
-		: m_dc(dc)
-	{}
-
-	void operator()(GlCommandBuffer*)
-	{
-		m_dc.exec();
-	}
-};
-
-//==============================================================================
-void GlDrawcallElements::draw(GlCommandBufferHandle& commands)
-{
-	commands._pushBackNewCommand<GlDrawElementsCommand>(*this);
-}
-
-//==============================================================================
-void GlDrawcallElements::exec()
-{
-	ANKI_ASSERT(m_indexSize != 0);
-	ANKI_ASSERT(m_drawCount > 0);
-
-	GLenum indicesType = 0;
-	switch(m_indexSize)
-	{
-	case 1:
-		indicesType = GL_UNSIGNED_BYTE;
-		break;
-	case 2:
-		indicesType = GL_UNSIGNED_SHORT;
-		break;
-	case 4:
-		indicesType = GL_UNSIGNED_INT;
-		break;
-	default:
-		ANKI_ASSERT(0);
-		break;
-	};
-
-	// Check if draw indirect
-	if(m_drawCount == 1 && !m_indirectBuff.isCreated()
-		&& !m_indirectClientBuff.isCreated())
-	{
-		glDrawElementsInstancedBaseVertexBaseInstance(
-			m_primitiveType,
-			m_noIndirect.m_count,
-			indicesType,
-			(const void*)(PtrSize)(m_noIndirect.m_firstIndex * m_indexSize),
-			m_noIndirect.m_instanceCount,
-			m_noIndirect.m_baseVertex,
-			m_noIndirect.m_baseInstance);
-	}
-	else if(m_indirectBuff.isCreated())
-	{
-		GlBuffer& buff = m_indirectBuff._get();
-		buff.setTarget(GL_DRAW_INDIRECT_BUFFER);
-		buff.bind();
-
-		glMultiDrawElementsIndirect(
-			m_primitiveType,
-			indicesType,
-			(const void*)(PtrSize)m_indirect.m_offset,
-			m_drawCount,
-			m_indirect.m_stride);
-	}
-	else
-	{
-		ANKI_ASSERT(m_indirectClientBuff.isCreated());
-
-		GlBuffer::bindDefault(GL_DRAW_INDIRECT_BUFFER);
-
-		PtrSize ptr = 
-			(PtrSize)m_indirectClientBuff.getBaseAddress() 
-			+ m_indirect.m_offset;
-
-		glMultiDrawElementsIndirect(
-			m_primitiveType,
-			indicesType,
-			(const void*)ptr,
-			m_drawCount,
-			m_indirect.m_stride);
-	}
-
-	ANKI_COUNTER_INC(GL_DRAWCALLS_COUNT, (U64)1);
-}
-
-//==============================================================================
-// GlDrawcallArrays                                                            =
-//==============================================================================
-
-//==============================================================================
-class GlDrawArraysCommand: public GlCommand
-{
-public:
-	GlDrawcallArrays m_dc;
-
-	GlDrawArraysCommand(const GlDrawcallArrays& dc)
-		: m_dc(dc)
-	{}
-
-	void operator()(GlCommandBuffer*)
-	{
-		m_dc.exec();
-	}
-};
-
-//==============================================================================
-void GlDrawcallArrays::draw(GlCommandBufferHandle& commands)
-{
-	commands._pushBackNewCommand<GlDrawArraysCommand>(*this);
-}
-
-//==============================================================================
-void GlDrawcallArrays::exec()
-{
-	ANKI_ASSERT(m_drawCount > 0);
-
-	if(m_drawCount == 1 && !m_indirectBuff.isCreated()
-		&& !m_indirectClientBuff.isCreated())
-	{
-		glDrawArraysInstancedBaseInstance(
-			m_primitiveType,
-			m_noIndirect.m_first,
-			m_noIndirect.m_count,
-			m_noIndirect.m_instanceCount,
-			m_noIndirect.m_baseInstance);
-	}
-	else if(m_indirectBuff.isCreated())
-	{
-		GlBuffer& buff = m_indirectBuff._get();
-		buff.setTarget(GL_DRAW_INDIRECT_BUFFER);
-		buff.bind();
-
-		glMultiDrawArraysIndirect(
-			m_primitiveType,
-			(const void*)(PtrSize)m_offset,
-			m_drawCount,
-			m_stride);
-	}
-	else
-	{
-		ANKI_ASSERT(m_indirectClientBuff.isCreated());
-
-		GlBuffer::bindDefault(GL_DRAW_INDIRECT_BUFFER);
-
-		PtrSize ptr = 
-			(PtrSize)m_indirectClientBuff.getBaseAddress() + m_offset;
-
-		glMultiDrawArraysIndirect(
-			m_primitiveType,
-			(const void*)(PtrSize)ptr,
-			m_drawCount,
-			m_stride);
-	}
-
-	ANKI_COUNTER_INC(GL_DRAWCALLS_COUNT, (U64)1);
-}
-
-} // end namespace anki

src/gl/GlProgramHandle.cpp

@@ -27,17 +27,19 @@ public:
 		m_source(source)
 	{}
 
-	void operator()(GlCommandBuffer* commands)
+	Error operator()(GlCommandBuffer* commands)
 	{
 		Error err = m_prog._get().create(m_type, 
 			reinterpret_cast<const char*>(m_source.getBaseAddress()),
 			commands->getQueue().getDevice()._getAllocator(),
 			commands->getQueue().getDevice()._getCacheDirectory());
-		ANKI_ASSERT(!err);
 
-		GlHandleState oldState = m_prog._setState(GlHandleState::CREATED);
+		GlHandleState oldState = m_prog._setState(
+			(err) ? GlHandleState::ERROR : GlHandleState::CREATED);
 		ANKI_ASSERT(oldState == GlHandleState::TO_BE_CREATED);
 		(void)oldState;
+
+		return err;
 	}
 };
 
@@ -76,15 +78,15 @@ Error GlProgramHandle::create(GlCommandBufferHandle& commands,
 //==============================================================================
 GLenum GlProgramHandle::getType() const
 {
-	serializeOnGetter();
-	return _get().getType();
+	return (serializeOnGetter()) ? GL_NONE : _get().getType();
 }
 
 //==============================================================================
 const GlProgram::ProgramVector<GlProgramVariable>& 
 	GlProgramHandle::getVariables() const
 {
-	serializeOnGetter();
+	Error err = serializeOnGetter();
+	ANKI_ASSERT(!err);
 	return _get().getVariables();
 }
 
@@ -92,7 +94,8 @@ const GlProgram::ProgramVector<GlProgramVariable>&
 const GlProgram::ProgramVector<GlProgramBlock>& 
 	GlProgramHandle::getBlocks() const
 {
-	serializeOnGetter();
+	Error err = serializeOnGetter();
+	ANKI_ASSERT(!err);
 	return _get().getBlocks();
 }
 
@@ -100,15 +103,13 @@ const GlProgram::ProgramVector<GlProgramBlock>&
 const GlProgramVariable* 
 	GlProgramHandle::tryFindVariable(const CString& name) const
 {
-	serializeOnGetter();
-	return _get().tryFindVariable(name);
+	return (serializeOnGetter()) ? nullptr : _get().tryFindVariable(name);
 }
 
 //==============================================================================
 const GlProgramBlock* GlProgramHandle::tryFindBlock(const CString& name) const
 {
-	serializeOnGetter();
-	return _get().tryFindBlock(name);
+	return (serializeOnGetter()) ? nullptr : _get().tryFindBlock(name);
 }
 
 } // end namespace anki

src/gl/GlProgramPipelineHandle.cpp

@@ -57,15 +57,17 @@ Error GlProgramPipelineHandle::commonConstructor(
 			} while(++prog != progsEnd);
 		}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			Error err = m_ppline._get().create(
 				&m_progs[0], &m_progs[0] + m_progsCount);
-			ANKI_ASSERT(!err);
 
-			GlHandleState oldState = m_ppline._setState(GlHandleState::CREATED);
+			GlHandleState oldState = m_ppline._setState(
+				err ? GlHandleState::ERROR : GlHandleState::CREATED);
 			ANKI_ASSERT(oldState == GlHandleState::TO_BE_CREATED);
 			(void)oldState;
+
+			return err;
 		}
 	};
 
@@ -100,10 +102,10 @@ void GlProgramPipelineHandle::bind(GlCommandBufferHandle& commands)
 		GlProgramPipelineHandle m_ppline;
 
 		Command(GlProgramPipelineHandle& ppline)
-			: m_ppline(ppline)
+		:	m_ppline(ppline)
 		{}
 
-		void operator()(GlCommandBuffer* commands)
+		Error operator()(GlCommandBuffer* commands)
 		{
 			GlState& state = commands->getQueue().getState();
 
@@ -113,6 +115,8 @@ void GlProgramPipelineHandle::bind(GlCommandBufferHandle& commands)
 
 				state.m_crntPpline = m_ppline._get().getGlName();
 			}
+
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -123,7 +127,8 @@ void GlProgramPipelineHandle::bind(GlCommandBufferHandle& commands)
 GlProgramHandle GlProgramPipelineHandle::getAttachedProgram(GLenum type) const
 {
 	ANKI_ASSERT(isCreated());
-	serializeOnGetter();
+	Error err = serializeOnGetter();
+	ANKI_ASSERT(!err);
 	return _get().getAttachedProgram(type);
 }
 

src/gl/GlQueue.cpp

@@ -75,11 +75,13 @@ void GlQueue::finishCommandBuffer(GlCommandBufferHandle& commands)
 }
 
 //==============================================================================
-void GlQueue::start(
+Error GlQueue::start(
 	GlMakeCurrentCallback makeCurrentCb, void* makeCurrentCbData, void* ctx,
 	GlCallback swapBuffersCallback, void* swapBuffersCbData,
 	Bool registerMessages)
 {
+	Error err = ErrorCode::NONE;
+
 	ANKI_ASSERT(m_tail == 0 && m_head == 0);
 	m_state.m_registerMessages = registerMessages;
 
@@ -93,20 +95,43 @@ void GlQueue::start(
 	ANKI_ASSERT(swapBuffersCallback != nullptr);
 	m_swapBuffersCallback = swapBuffersCallback;
 	m_swapBuffersCbData = swapBuffersCbData;
-	m_swapBuffersCommands.create(m_device);
-	m_swapBuffersCommands.pushBackUserCommand(swapBuffersInternal, this);
+	err = m_swapBuffersCommands.create(m_device);
+	if(!err)
+	{
+		m_swapBuffersCommands.pushBackUserCommand(swapBuffersInternal, this);
+	}
 
 #if !ANKI_QUEUE_DISABLE_ASYNC
-	// Start thread
-	m_thread.start(this, threadCallback);
+	Bool threadStarted = false;
+	if(!err)
+	{
+		// Start thread
+		m_thread.start(this, threadCallback);
+		threadStarted = true;
+
+		// Create sync command buffer
+		err = m_syncCommands.create(m_device);
+	}
 
-	// Create sync command buffer
-	m_syncCommands.create(m_device);
-	m_sync.create(m_syncCommands);
-	m_sync.sync(m_syncCommands);
+	if(!err)
+	{
+		err = m_sync.create(m_syncCommands);
+	}
+
+	if(!err)
+	{
+		m_sync.sync(m_syncCommands);
+	}
+
+	if(err && threadStarted)
+	{
+		m_thread.join();
+	}
 #else
 	prepare();
 #endif
+
+	return err;
 }
 
 //==============================================================================
@@ -216,14 +241,11 @@ void GlQueue::threadLoop()
 			++m_head;
 		}
 
-		try
-		{
-			// Exec commands
-			cmd._executeAllCommands();
-		}
-		catch(const std::exception& e)
+		Error err = cmd._executeAllCommands();
+
+		if(err)
 		{
-			ANKI_LOGE("Exception in rendering thread. Aborting:\n%s", e.what());
+			ANKI_LOGE("Error in rendering thread. Aborting\n");
 			abort();
 		}
 	}
@@ -241,7 +263,7 @@ void GlQueue::syncClientServer()
 }
 
 //==============================================================================
-void GlQueue::swapBuffersInternal(void* ptr)
+Error GlQueue::swapBuffersInternal(void* ptr)
 {
 	ANKI_ASSERT(ptr);
 	GlQueue& self = *reinterpret_cast<GlQueue*>(ptr);
@@ -256,6 +278,8 @@ void GlQueue::swapBuffersInternal(void* ptr)
 	}
 
 	self.m_frameCondVar.notifyOne();
+
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gl/GlSyncHandles.cpp

@@ -23,11 +23,13 @@ public:
 	:	m_sync(s)
 	{}
 
-	void operator()(GlCommandBuffer*)
+	Error operator()(GlCommandBuffer*)
 	{
 		ANKI_COUNTER_START_TIMER(GL_SERVER_WAIT_TIME);
 		m_sync._get().wait();
 		ANKI_COUNTER_STOP_TIMER_INC(GL_SERVER_WAIT_TIME);
+
+		return ErrorCode::NONE;
 	}
 };
 

src/gl/GlTextureHandle.cpp

@@ -39,7 +39,7 @@ Error GlTextureHandle::create(
 			m_init(init)
 		{}
 
-		void operator()(GlCommandBuffer* commands)
+		Error operator()(GlCommandBuffer* commands)
 		{
 			ANKI_ASSERT(commands);
 			GlTexture::Initializer init;
@@ -87,11 +87,13 @@ Error GlTextureHandle::create(
 			auto alloc = commands->getGlobalAllocator();
 
 			Error err = m_tex._get().create(init, alloc);
-			ANKI_ASSERT(!err);
 
-			GlHandleState oldState = m_tex._setState(GlHandleState::CREATED);
+			GlHandleState oldState = m_tex._setState(
+				(err) ? GlHandleState::ERROR : GlHandleState::CREATED);
 			ANKI_ASSERT(oldState == GlHandleState::TO_BE_CREATED);
 			(void)oldState;
+
+			return err;
 		}
 	};
 
@@ -134,9 +136,10 @@ void GlTextureHandle::bind(GlCommandBufferHandle& commands, U32 unit)
 			m_unit(unit)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			m_tex._get().bind(m_unit);
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -158,9 +161,10 @@ void GlTextureHandle::setFilter(GlCommandBufferHandle& commands, Filter filter)
 			m_filter(filter)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			m_tex._get().setFilter(m_filter);
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -180,9 +184,10 @@ void GlTextureHandle::generateMipmaps(GlCommandBufferHandle& commands)
 		:	m_tex(tex)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			m_tex._get().generateMipmaps();
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -209,9 +214,10 @@ void GlTextureHandle::setParameter(GlCommandBufferHandle& commands,
 			m_value(value)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			m_tex._get().setParameter(m_param, m_value);
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -219,27 +225,6 @@ void GlTextureHandle::setParameter(GlCommandBufferHandle& commands,
 	commands._pushBackNewCommand<Command>(*this, param, value);
 }
 
-//==============================================================================
-U32 GlTextureHandle::getWidth() const
-{
-	serializeOnGetter();
-	return _get().getWidth();
-}
-
-//==============================================================================
-U32 GlTextureHandle::getHeight() const
-{
-	serializeOnGetter();
-	return _get().getHeight();
-}
-
-//==============================================================================
-U32 GlTextureHandle::getDepth() const
-{
-	serializeOnGetter();
-	return _get().getDepth();
-}
-
 //==============================================================================
 // GlSamplerHandle                                                             =
 //==============================================================================
@@ -264,17 +249,18 @@ Error GlSamplerHandle::create(GlCommandBufferHandle& commands)
 		:	m_sampler(sampler)
 		{}
 
-		void operator()(GlCommandBuffer* commands)
+		Error operator()(GlCommandBuffer* commands)
 		{
 			ANKI_ASSERT(commands);
 
 			Error err = m_sampler._get().create();
-			ANKI_ASSERT(!err);
 
-			GlHandleState oldState = 
-				m_sampler._setState(GlHandleState::CREATED);
+			GlHandleState oldState = m_sampler._setState(
+				(err) ? GlHandleState::ERROR : GlHandleState::CREATED);
 			ANKI_ASSERT(oldState == GlHandleState::TO_BE_CREATED);
 			(void)oldState;
+
+			return err;
 		}
 	};
 
@@ -312,9 +298,10 @@ void GlSamplerHandle::bind(GlCommandBufferHandle& commands, U32 unit)
 			m_unit(unit)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			m_sampler._get().bind(m_unit);
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -336,9 +323,10 @@ void GlSamplerHandle::setFilter(GlCommandBufferHandle& commands, Filter filter)
 			m_filter(filter)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			m_sampler._get().setFilter(m_filter);
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -363,9 +351,10 @@ void GlSamplerHandle::setParameter(
 			m_value(value)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			m_sampler._get().setParameter(m_param, m_value);
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -385,9 +374,10 @@ void GlSamplerHandle::bindDefault(GlCommandBufferHandle& commands, U32 unit)
 		:	m_unit(unit)
 		{}
 
-		void operator()(GlCommandBuffer*)
+		Error operator()(GlCommandBuffer*)
 		{
 			GlSampler::unbind(m_unit);
+			return ErrorCode::NONE;
 		}
 	};