Removing exceptions

include/anki/Gl.h

@@ -31,8 +31,6 @@
 #include "anki/gl/GlFramebufferHandle.h"
 #include "anki/gl/GlProgramPipelineHandle.h"
 
-#include "anki/gl/GlOperations.h"
-
 #include "anki/gl/GlCommandBufferHandle.h"
 #include "anki/gl/GlDevice.h"
 

include/anki/gl/GlFramebuffer.h

@@ -72,7 +72,8 @@ private:
 		const U32 layer);
 
 	/// Create the FBO
-	void createFbo(const Array<U, MAX_COLOR_ATTACHMENTS + 1>& layers,
+	ANKI_USE_RESULT Error createFbo(
+		const Array<U, MAX_COLOR_ATTACHMENTS + 1>& layers,
 		GLenum depthStencilBindingPoint);
 
 	void destroy();

src/gl/GlFramebuffer.cpp

@@ -5,6 +5,7 @@
 
 #include "anki/gl/GlFramebuffer.h"
 #include "anki/gl/GlTexture.h"
+#include "anki/core/Logger.h"
 
 namespace anki {
 
@@ -47,10 +48,10 @@ Error GlFramebuffer::create(
 	} while(++attachment != attachmentsEnd);
 
 	// Now create the FBO
-	createFbo(layers, depthStencilBindingPoint);
+	Error err = createFbo(layers, depthStencilBindingPoint);
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
-	return ErrorCode::NONE;
+	return err;
 }
 
 //==============================================================================
@@ -64,10 +65,12 @@ void GlFramebuffer::destroy()
 }
 
 //==============================================================================
-void GlFramebuffer::createFbo(
+Error GlFramebuffer::createFbo(
 	const Array<U, MAX_COLOR_ATTACHMENTS + 1>& layers,
 	GLenum depthStencilBindingPoint)
 {
+	Error err = ErrorCode::NONE;
+
 	ANKI_ASSERT(!isCreated());
 	glGenFramebuffers(1, &m_glName);
 	ANKI_ASSERT(m_glName != 0);
@@ -100,9 +103,12 @@ void GlFramebuffer::createFbo(
 	GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
 	if(status != GL_FRAMEBUFFER_COMPLETE)
 	{
+		ANKI_LOGE("FBO is incomplete");
 		destroy();
-		throw ANKI_EXCEPTION("FBO is incomplete");
+		err = ErrorCode::FUNCTION_FAILED;
 	}
+
+	return err;
 }
 
 //==============================================================================
@@ -198,3 +204,4 @@ void GlFramebuffer::blit(const GlFramebuffer& b,
 
 } // end namespace anki
 
+

src/renderer/DebugDrawer.cpp

@@ -26,12 +26,13 @@ DebugDrawer::DebugDrawer(Renderer* r)
 	m_vert.load("shaders/Dbg.vert.glsl", &r->_getResourceManager());
 	m_frag.load("shaders/Dbg.frag.glsl", &r->_getResourceManager());
 
-	GlCommandBufferHandle jobs(&gl);
+	GlCommandBufferHandle jobs;
+	jobs.create(&gl);
 
-	m_ppline = GlProgramPipelineHandle(jobs, 
+	m_ppline.create(jobs, 
 		{m_vert->getGlProgram(), m_frag->getGlProgram()});
 
-	m_vertBuff = GlBufferHandle(jobs, GL_ARRAY_BUFFER, 
+	m_vertBuff.create(jobs, GL_ARRAY_BUFFER, 
 		sizeof(m_clientLineVerts), GL_DYNAMIC_STORAGE_BIT);
 
 	m_lineVertCount = 0;
@@ -125,7 +126,8 @@ void DebugDrawer::flushInternal(GLenum primitive)
 
 	U size = sizeof(Vertex) * clientVerts;
 
-	GlClientBufferHandle tmpBuff(m_jobs, size, nullptr);
+	GlClientBufferHandle tmpBuff;
+	tmpBuff.create(m_jobs, size, nullptr);
 	memcpy(tmpBuff.getBaseAddress(), vertBuff, size);
 
 	m_vertBuff.write(m_jobs, tmpBuff, 0, 0, size);

src/renderer/Hdr.cpp

@@ -22,12 +22,13 @@ void Hdr::initFb(GlFramebufferHandle& fb, GlTextureHandle& rt)
 		GL_UNSIGNED_BYTE, 1, rt);
 
 	// Set to bilinear because the blurring techniques take advantage of that
-	GlCommandBufferHandle jobs(&gl);
-	rt.setFilter(jobs, GlTextureHandle::Filter::LINEAR);
+	GlCommandBufferHandle cmdb;
+	cmdb.create(&gl);
+	rt.setFilter(cmdb, GlTextureHandle::Filter::LINEAR);
 
 	// Create FB
-	fb = GlFramebufferHandle(jobs, {{rt, GL_COLOR_ATTACHMENT0}});
-	jobs.finish();
+	fb.create(cmdb, {{rt, GL_COLOR_ATTACHMENT0}});
+	cmdb.finish();
 }
 
 //==============================================================================
@@ -57,14 +58,15 @@ void Hdr::initInternal(const ConfigSet& initializer)
 
 	// init shaders
 	GlDevice& gl = getGlDevice();
-	GlCommandBufferHandle jobs(&gl);
+	GlCommandBufferHandle cmdb;
+	cmdb.create(&gl);
 
-	m_commonBuff = GlBufferHandle(jobs, GL_UNIFORM_BUFFER, 
+	m_commonBuff.create(cmdb, GL_UNIFORM_BUFFER, 
 		sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT);
 
-	updateDefaultBlock(jobs);
+	updateDefaultBlock(cmdb);
 
-	jobs.flush();
+	cmdb.flush();
 
 	m_toneFrag.load("shaders/PpsHdr.frag.glsl", &getResourceManager());
 
@@ -122,7 +124,7 @@ void Hdr::init(const ConfigSet& initializer)
 }
 
 //==============================================================================
-void Hdr::run(GlCommandBufferHandle& jobs)
+void Hdr::run(GlCommandBufferHandle& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
 
@@ -130,38 +132,38 @@ void Hdr::run(GlCommandBufferHandle& jobs)
 	//vblurFai.setFiltering(Texture::TFrustumType::NEAREST);
 
 	// pass 0
-	m_vblurFb.bind(jobs, true);
-	jobs.setViewport(0, 0, m_width, m_height);
-	m_tonePpline.bind(jobs);
+	m_vblurFb.bind(cmdb, true);
+	cmdb.setViewport(0, 0, m_width, m_height);
+	m_tonePpline.bind(cmdb);
 
 	if(m_parameterUpdateTimestamp > m_commonUboUpdateTimestamp)
 	{
-		updateDefaultBlock(jobs);
+		updateDefaultBlock(cmdb);
 		m_commonUboUpdateTimestamp = getGlobTimestamp();
 	}
 
-	m_r->getIs()._getRt().bind(jobs, 0);
-	m_commonBuff.bindShaderBuffer(jobs, 0);
+	m_r->getIs()._getRt().bind(cmdb, 0);
+	m_commonBuff.bindShaderBuffer(cmdb, 0);
 
-	m_r->drawQuad(jobs);
+	m_r->drawQuad(cmdb);
 
 	// Blurring passes
 	for(U32 i = 0; i < m_blurringIterationsCount; i++)
 	{
 		if(i == 0)
 		{
-			jobs.bindTextures(0, {m_hblurRt, m_vblurRt});
+			cmdb.bindTextures(0, {m_hblurRt, m_vblurRt});
 		}
 
 		// hpass
-		m_hblurFb.bind(jobs, true);
-		m_hblurPpline.bind(jobs);		
-		m_r->drawQuad(jobs);
+		m_hblurFb.bind(cmdb, true);
+		m_hblurPpline.bind(cmdb);		
+		m_r->drawQuad(cmdb);
 
 		// vpass
-		m_vblurFb.bind(jobs, true);
-		m_vblurPpline.bind(jobs);
-		m_r->drawQuad(jobs);
+		m_vblurFb.bind(cmdb, true);
+		m_vblurPpline.bind(cmdb);
+		m_r->drawQuad(cmdb);
 	}
 
 	// For the next stage it should be LINEAR though
@@ -169,13 +171,14 @@ void Hdr::run(GlCommandBufferHandle& jobs)
 }
 
 //==============================================================================
-void Hdr::updateDefaultBlock(GlCommandBufferHandle& jobs)
+void Hdr::updateDefaultBlock(GlCommandBufferHandle& cmdb)
 {
-	GlClientBufferHandle tempBuff(jobs, sizeof(Vec4), nullptr);
+	GlClientBufferHandle tempBuff;
+	tempBuff.create(cmdb, sizeof(Vec4), nullptr);
 	
 	*((Vec4*)tempBuff.getBaseAddress()) = Vec4(m_exposure, 0.0, 0.0, 0.0);
 
-	m_commonBuff.write(jobs, tempBuff, 0, 0, tempBuff.getSize());
+	m_commonBuff.write(cmdb, tempBuff, 0, 0, tempBuff.getSize());
 }
 
 } // end namespace anki

src/resource/Material.cpp

@@ -303,9 +303,10 @@ GlProgramPipelineHandle Material::getProgramPipeline(
 			getProgram(key, ShaderType::FRAGMENT)->getGlProgram();
 
 		GlDevice& gl = m_resources->_getGlDevice();
-		GlCommandBufferHandle cmdBuff(&gl);
+		GlCommandBufferHandle cmdBuff;
+		cmdBuff.create(&gl);
 
-		ppline = GlProgramPipelineHandle(
+		ppline.create(
 			cmdBuff, &progs[0], &progs[0] + progCount);
 
 		cmdBuff.flush();

src/resource/Mesh.cpp

@@ -127,19 +127,22 @@ void Mesh::createBuffers(const MeshLoader& loader,
 
 	// Create GL buffers
 	GlDevice& gl = init.m_resources._getGlDevice();
-	GlCommandBufferHandle jobs(&gl);
+	GlCommandBufferHandle cmdb;
+	cmdb.create(&gl);
 	
-	GlClientBufferHandle clientVertBuff(jobs, vbosize, &buff[0]);
-	m_vertBuff = GlBufferHandle(jobs, GL_ARRAY_BUFFER, clientVertBuff, 0);
+	GlClientBufferHandle clientVertBuff;
+	clientVertBuff.create(cmdb, vbosize, &buff[0]);
+	m_vertBuff.create(cmdb, GL_ARRAY_BUFFER, clientVertBuff, 0);
 
-	GlClientBufferHandle clientIndexBuff(
-		jobs, 
+	GlClientBufferHandle clientIndexBuff;
+	clientIndexBuff.create(
+		cmdb, 
 		getVectorSizeInBytes(loader.getIndices()), 
 		(void*)&loader.getIndices()[0]);
-	m_indicesBuff = GlBufferHandle(
-		jobs, GL_ELEMENT_ARRAY_BUFFER, clientIndexBuff, 0);
+	m_indicesBuff.create(
+		cmdb, GL_ELEMENT_ARRAY_BUFFER, clientIndexBuff, 0);
 
-	jobs.finish();
+	cmdb.finish();
 }
 
 //==============================================================================

src/resource/Model.cpp

@@ -193,7 +193,8 @@ void ModelPatchBase::create(GlDevice* gl)
 			prog = ppline.getAttachedProgram(GL_VERTEX_SHADER);
 			
 			// Create vert descriptor
-			GlCommandBufferHandle vertJobs(gl);
+			GlCommandBufferHandle vertJobs;
+			vertJobs.create(gl);
 			createVertexDesc(prog, *mesh, vertJobs);
 
 			m_vertJobs[getVertexDescIdx(key)] = vertJobs;

src/resource/ProgramResource.cpp

@@ -29,15 +29,17 @@ void ProgramResource::load(const CString& filename, const CString& extraSrc,
 	TempResourceString source(extraSrc + pars.getShaderSource());
 
 	GlDevice& gl = manager._getGlDevice();
-	GlCommandBufferHandle jobs(&gl);
-	GlClientBufferHandle glsource(jobs, source.getLength() + 1, nullptr);
+	GlCommandBufferHandle cmdb;
+	cmdb.create(&gl);
+	GlClientBufferHandle glsource;
+	glsource.create(cmdb, source.getLength() + 1, nullptr);
 
 	std::strcpy(reinterpret_cast<char*>(glsource.getBaseAddress()), &source[0]);
 
-	m_prog = GlProgramHandle(jobs, 
+	m_prog.create(cmdb, 
 		computeGlShaderType(pars.getShaderType()), glsource);
 
-	jobs.flush();
+	cmdb.flush();
 }
 
 //==============================================================================

src/resource/TextureResource.cpp

@@ -17,11 +17,12 @@
 namespace anki {
 
 //==============================================================================
-static void deleteImageCallback(void* data)
+static Error deleteImageCallback(void* data)
 {
 	Image* image = reinterpret_cast<Image*>(data);
 	auto alloc = image->getAllocator();
 	alloc.deleteInstance(image);
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -50,8 +51,9 @@ void TextureResource::loadInternal(const CString& filename,
 	ResourceInitializer& rinit)
 {
 	GlDevice& gl = rinit.m_resources._getGlDevice();
-	GlCommandBufferHandle jobs(&gl); // Always first to avoid assertions (
-	                                 // because of the check of the allocator)
+	GlCommandBufferHandle cmdb;
+	cmdb.create(&gl); // Always first to avoid assertions (
+	                  // because of the check of the allocator)
 
 	GlTextureHandle::Initializer init;
 	U layers = 0;
@@ -200,21 +202,21 @@ void TextureResource::loadInternal(const CString& filename,
 		{
 			GlClientBufferHandle& buff = init.m_data[level][layer];
 
-			buff = GlClientBufferHandle(
-				jobs, 
+			buff.create(
+				cmdb, 
 				img.getSurface(level, layer).m_data.size(), 
 				(void*)&img.getSurface(level, layer).m_data[0]);
 		}
 	}
 
 	// Add the GL job to create the texture
-	m_tex = GlTextureHandle(jobs, init);
+	m_tex.create(cmdb, init);
 
 	// Add cleanup job
-	jobs.pushBackUserCommand(deleteImageCallback, imgPtr);
+	cmdb.pushBackUserCommand(deleteImageCallback, imgPtr);
 
 	// Finaly enque the GL job chain
-	jobs.flush();
+	cmdb.flush();
 }
 
 } // end namespace anki

src/scene/ParticleEmitter.cpp

@@ -246,13 +246,14 @@ ParticleEmitter::ParticleEmitter(
 	PtrSize buffSize = m_maxNumOfParticles * VERT_SIZE * 3;
 
 	GlDevice& gl = getSceneGraph()._getGlDevice();
-	GlCommandBufferHandle jobs(&gl);
+	GlCommandBufferHandle cmd;
+	cmd.create(&gl);
 
-	m_vertBuff = GlBufferHandle(jobs, GL_ARRAY_BUFFER, buffSize, 
+	m_vertBuff.create(cmd, GL_ARRAY_BUFFER, buffSize, 
 		GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 
 	// TODO Optimize that to avoid serialization
-	jobs.finish();
+	cmd.finish();
 
 	m_vertBuffMapping = (U8*)m_vertBuff.getPersistentMappingAddress();
 }