Remove some unneeded error checking

include/anki/gr/BufferPtr.h

@@ -24,7 +24,7 @@ public:
 	~BufferPtr();
 
 	/// Create the buffer with data
-	ANKI_USE_RESULT Error create(GrManager* manager, GLenum target,
+	void create(GrManager* manager, GLenum target,
 		const void* data, PtrSize size, GLbitfield flags);
 
 	/// Get buffer size. It may serialize

include/anki/gr/CommandBufferPtr.h

@@ -25,7 +25,7 @@ public:
 	~CommandBufferPtr();
 
 	/// Create command buffer
-	ANKI_USE_RESULT Error create(GrManager* manager,
+	void create(GrManager* manager,
 		CommandBufferInitHints hints = CommandBufferInitHints());
 
 	/// Add a user command at the end of the command buffer

include/anki/gr/Enums.h

@@ -227,7 +227,7 @@ enum class OcclusionQueryResultBit: U8
 {
 	NOT_AVAILABLE = 1 << 0,
 	VISIBLE = 1 << 1,
-	NOT_VISIBLE = 1 << 2 
+	NOT_VISIBLE = 1 << 2
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(OcclusionQueryResultBit, inline)
 
@@ -255,14 +255,16 @@ enum class AttachmentStoreOperation: U8
 	DONT_CARE
 };
 
-/// Buffer access mode
+/// Buffer access mode.
 enum class BufferUsageBit: U8
 {
 	UNIFORM_BUFFER = 1 << 0,
 	STORAGE_BUFFER = 1 << 1,
 	INDEX_BUFFER = 1 << 2,
 	VERTEX_BUFFER = 1 << 3,
-	INDIRECT_BUFFER = 1 << 4
+	INDIRECT_BUFFER = 1 << 4,
+	CLIENT_READ = 1 << 5,
+	CLIENT_WRITE = 1 << 6
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(BufferUsageBit, inline)
 /// @}

include/anki/gr/FramebufferPtr.h

@@ -25,9 +25,8 @@ public:
 
 	~FramebufferPtr();
 
-	/// Create a framebuffer
-	ANKI_USE_RESULT Error create(GrManager* manager,
-		Initializer& attachments);
+	/// Create a framebuffer.
+	void create(GrManager* manager, Initializer& attachments);
 
 	/// Bind it to the command buffer
 	/// @param commands The command buffer

include/anki/gr/OcclusionQueryPtr.h

@@ -25,8 +25,7 @@ public:
 	~OcclusionQueryPtr();
 
 	/// Create a query.
-	ANKI_USE_RESULT Error create(
-		GrManager* manager, ResultBit condRenderingBit);
+	void create(GrManager* manager, ResultBit condRenderingBit);
 
 	/// Begin query.
 	void begin(CommandBufferPtr& commands);

include/anki/gr/PipelinePtr.h

@@ -25,7 +25,7 @@ public:
 	~PipelinePtr();
 
 	/// Create a pipeline
-	ANKI_USE_RESULT Error create(GrManager* manager, const Initializer& init);
+	void create(GrManager* manager, const Initializer& init);
 
 	/// Bind it to the state
 	void bind(CommandBufferPtr& commands);

include/anki/gr/SamplerPtr.h

@@ -27,8 +27,7 @@ public:
 	~SamplerPtr();
 
 	/// Create the sampler
-	ANKI_USE_RESULT Error create(CommandBufferPtr& commands,
-		const Initializer& init);
+	void create(CommandBufferPtr& commands, const Initializer& init);
 
 	/// Bind to a unit
 	void bind(CommandBufferPtr& commands, U32 unit);

include/anki/gr/ShaderPtr.h

@@ -25,7 +25,7 @@ public:
 	~ShaderPtr();
 
 	/// Create shader program.
-	ANKI_USE_RESULT Error create(GrManager* manager,
+	void create(GrManager* manager,
 		ShaderType shaderType, const void* source, PtrSize sourceSize);
 };
 /// @}

include/anki/gr/TexturePtr.h

@@ -27,7 +27,7 @@ public:
 	~TexturePtr();
 
 	/// Create the texture
-	Error create(CommandBufferPtr& commands, const Initializer& init);
+	void create(CommandBufferPtr& commands, const Initializer& init);
 
 	/// Bind to a unit
 	void bind(CommandBufferPtr& commands, U32 unit);

include/anki/renderer/MainRenderer.h

@@ -45,7 +45,7 @@ private:
 	Array<CommandBufferInitHints, JOB_CHAINS_COUNT> m_jobsInitHints;
 
 	void takeScreenshotTga(const char* filename);
-	ANKI_USE_RESULT Error initGl();
+	void initGl();
 };
 /// @}
 

src/gr/gl/BufferPtr.cpp

@@ -203,13 +203,13 @@ BufferPtr::~BufferPtr()
 {}
 
 //==============================================================================
-Error BufferPtr::create(GrManager* manager,
+void BufferPtr::create(GrManager* manager,
 	GLenum target, const void* data, PtrSize size, GLenum flags)
 {
 	ANKI_ASSERT(!isCreated());
 
 	CommandBufferPtr cmdb;
-	ANKI_CHECK(cmdb.create(manager));
+	cmdb.create(manager);
 
 	Base::create(cmdb.get().getManager());
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
@@ -228,8 +228,6 @@ Error BufferPtr::create(GrManager* manager,
 	cmdb.get().pushBackNewCommand<BufferCreateCommand>(
 		*this, target, data, size, flags, cleanup);
 	cmdb.flush();
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/CommandBufferPtr.cpp

@@ -134,16 +134,13 @@ CommandBufferPtr::~CommandBufferPtr()
 {}
 
 //==============================================================================
-Error CommandBufferPtr::create(GrManager* manager,
-	CommandBufferInitHints hints)
+void CommandBufferPtr::create(GrManager* manager, CommandBufferInitHints hints)
 {
 	ANKI_ASSERT(!isCreated());
 	ANKI_ASSERT(manager);
 
 	Base::create(*manager);
 	get().create(hints);
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/FramebufferPtr.cpp

@@ -105,10 +105,10 @@ FramebufferPtr::~FramebufferPtr()
 {}
 
 //==============================================================================
-Error FramebufferPtr::create(GrManager* manager, Initializer& init)
+void FramebufferPtr::create(GrManager* manager, Initializer& init)
 {
 	CommandBufferPtr cmdb;
-	ANKI_CHECK(cmdb.create(manager));
+	cmdb.create(manager);
 
 	Base::create(cmdb.get().getManager());
 
@@ -116,8 +116,6 @@ Error FramebufferPtr::create(GrManager* manager, Initializer& init)
 
 	cmdb.get().pushBackNewCommand<CreateFramebufferCommand>(*this, init);
 	cmdb.flush();
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/GlObject.cpp

@@ -66,17 +66,10 @@ void GlObject::destroyDeferred(GlDeleteFunction deleteCallback)
 	{
 		CommandBufferPtr commands;
 
-		Error err = commands.create(&manager);
-		if(!err)
-		{
-			commands.get().template pushBackNewCommand<DeleteGlObjectCommand>(
-				deleteCallback, m_glName);
-			commands.flush();
-		}
-		else
-		{
-			ANKI_LOGE("Failed to create command");
-		}
+		commands.create(&manager);
+		commands.get().template pushBackNewCommand<DeleteGlObjectCommand>(
+			deleteCallback, m_glName);
+		commands.flush();
 	}
 	else
 	{

src/gr/gl/OcclusionQueryPtr.cpp

@@ -87,19 +87,16 @@ OcclusionQueryPtr::~OcclusionQueryPtr()
 {}
 
 //==============================================================================
-Error OcclusionQueryPtr::create(
-	GrManager* manager, ResultBit condRenderingBit)
+void OcclusionQueryPtr::create(GrManager* manager, ResultBit condRenderingBit)
 {
 	CommandBufferPtr cmd;
-	ANKI_CHECK(cmd.create(manager));
+	cmd.create(manager);
 
 	Base::create(*manager);
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 
 	cmd.get().pushBackNewCommand<OqCreateCommand>(*this, condRenderingBit);
 	cmd.flush();
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/PipelinePtr.cpp

@@ -82,18 +82,16 @@ PipelinePtr::~PipelinePtr()
 {}
 
 //==============================================================================
-Error PipelinePtr::create(GrManager* manager, const Initializer& init)
+void PipelinePtr::create(GrManager* manager, const Initializer& init)
 {
 	CommandBufferPtr cmdb;
-	ANKI_CHECK(cmdb.create(manager));
+	cmdb.create(manager);
 
 	Base::create(cmdb.get().getManager());
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 	cmdb.get().pushBackNewCommand<CreatePipelineCommand>(*this, init);
 
 	cmdb.flush();
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/RenderingThread.cpp

@@ -100,8 +100,6 @@ Error RenderingThread::start(
 	SwapBuffersCallback swapBuffersCallback, void* swapBuffersCbData,
 	Bool registerMessages)
 {
-	Error err = ErrorCode::NONE;
-
 	ANKI_ASSERT(m_tail == 0 && m_head == 0);
 	m_state.m_registerMessages = registerMessages;
 
@@ -115,40 +113,24 @@ Error RenderingThread::start(
 	ANKI_ASSERT(swapBuffersCallback != nullptr);
 	m_swapBuffersCallback = swapBuffersCallback;
 	m_swapBuffersCbData = swapBuffersCbData;
-	err = m_swapBuffersCommands.create(m_manager);
-	if(!err)
-	{
-		m_swapBuffersCommands.pushBackUserCommand(swapBuffersInternal, this);
-	}
+	m_swapBuffersCommands.create(m_manager);
+	m_swapBuffersCommands.pushBackUserCommand(swapBuffersInternal, this);
 
 #if !ANKI_DISABLE_GL_RENDERING_THREAD
-	Bool threadStarted = false;
-	if(!err)
-	{
-		// Start thread
-		m_thread.start(this, threadCallback);
-		threadStarted = true;
+	// Start thread
+	m_thread.start(this, threadCallback);
 
-		// Create sync command buffer
-		err = m_syncCommands.create(m_manager);
-	}
+	// Create sync command buffer
+	m_syncCommands.create(m_manager);
 
-	if(!err)
-	{
-		m_syncCommands.get().pushBackNewCommand<SyncCommand>();
-	}
-
-	if(err && threadStarted)
-	{
-		err = m_thread.join();
-	}
+	m_syncCommands.get().pushBackNewCommand<SyncCommand>();
 #else
 	prepare();
 
 	ANKI_LOGW("GL queue works in synchronous mode");
 #endif
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/SamplerPtr.cpp

@@ -92,14 +92,12 @@ SamplerPtr::~SamplerPtr()
 {}
 
 //==============================================================================
-Error SamplerPtr::create(CommandBufferPtr& commands,
+void SamplerPtr::create(CommandBufferPtr& commands,
 	const SamplerInitializer& init)
 {
 	Base::create(commands.get().getManager());
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 	commands.get().pushBackNewCommand<CreateSamplerCommand>(*this, init);
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/ShaderPtr.cpp

@@ -60,13 +60,13 @@ ShaderPtr::~ShaderPtr()
 {}
 
 //==============================================================================
-Error ShaderPtr::create(GrManager* manager,
+void ShaderPtr::create(GrManager* manager,
 	ShaderType type, const void* source, PtrSize sourceSize)
 {
 	ANKI_ASSERT(strlen(static_cast<const char*>(source)) == sourceSize - 1);
 
 	CommandBufferPtr cmdb;
-	ANKI_CHECK(cmdb.create(manager));
+	cmdb.create(manager);
 
 	Base::create(cmdb.get().getManager());
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
@@ -79,8 +79,6 @@ Error ShaderPtr::create(GrManager* manager,
 		*this, type, static_cast<char*>(src));
 
 	cmdb.flush();
-
-	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/gr/gl/TexturePtr.cpp

@@ -112,7 +112,7 @@ TexturePtr::~TexturePtr()
 {}
 
 //==============================================================================
-Error TexturePtr::create(
+void TexturePtr::create(
 	CommandBufferPtr& commands, const Initializer& initS)
 {
 	ANKI_ASSERT(!isCreated());
@@ -144,8 +144,6 @@ Error TexturePtr::create(
 	// Fire the command
 	commands.get().pushBackNewCommand<CreateTextureCommand>(
 		*this, init, init.m_copyDataBeforeReturn);
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/renderer/Bloom.cpp

@@ -18,17 +18,17 @@ Bloom::~Bloom()
 Error Bloom::initFb(FramebufferPtr& fb, TexturePtr& rt)
 {
 	// Set to bilinear because the blurring techniques take advantage of that
-	ANKI_CHECK(m_r->createRenderTarget(m_width, m_height, 
-		PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM), 
+	ANKI_CHECK(m_r->createRenderTarget(m_width, m_height,
+		PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM),
 		1, SamplingFilter::LINEAR, 1, rt));
 
 	// Create FB
 	FramebufferPtr::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = rt;
-	fbInit.m_colorAttachments[0].m_loadOperation = 
+	fbInit.m_colorAttachments[0].m_loadOperation =
 		AttachmentLoadOperation::DONT_CARE;
-	ANKI_CHECK(fb.create(&getGrManager(), fbInit));
+	fb.create(&getGrManager(), fbInit);
 
 	return ErrorCode::NONE;
 }
@@ -53,7 +53,7 @@ Error Bloom::initInternal(const ConfigSet& initializer)
 	m_threshold = initializer.get("pps.bloom.threshold");
 	m_scale = initializer.get("pps.bloom.scale");
 	m_blurringDist = initializer.get("pps.bloom.blurringDist");
-	m_blurringIterationsCount = 
+	m_blurringIterationsCount =
 		initializer.get("pps.bloom.blurringIterationsCount");
 
 	ANKI_CHECK(initFb(m_hblurFb, m_hblurRt));
@@ -62,23 +62,23 @@ Error Bloom::initInternal(const ConfigSet& initializer)
 	// init shaders
 	GrManager& gl = getGrManager();
 
-	ANKI_CHECK(m_commonBuff.create(&gl, GL_UNIFORM_BUFFER, nullptr,
-		sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT));
+	m_commonBuff.create(&gl, GL_UNIFORM_BUFFER, nullptr,
+		sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT);
 
 	CommandBufferPtr cmdb;
-	ANKI_CHECK(cmdb.create(&gl));
+	cmdb.create(&gl);
 	updateDefaultBlock(cmdb);
 
 	cmdb.flush();
 
 	ANKI_CHECK(m_toneFrag.loadToCache(&getResourceManager(),
-		"shaders/PpsBloom.frag.glsl", 
+		"shaders/PpsBloom.frag.glsl",
 		m_r->_getShadersPrependedSource().toCString(), "r_"));
 
 	ANKI_CHECK(m_r->createDrawQuadPipeline(
 		m_toneFrag->getGrShader(), m_tonePpline));
 
-	const char* SHADER_FILENAME = 
+	const char* SHADER_FILENAME =
 		"shaders/VariableSamplingBlurGeneric.frag.glsl";
 
 	StringAuto pps(getAllocator());
@@ -167,7 +167,7 @@ void Bloom::run(CommandBufferPtr& cmdb)
 
 		// hpass
 		m_hblurFb.bind(cmdb);
-		m_hblurPpline.bind(cmdb);		
+		m_hblurPpline.bind(cmdb);
 		m_r->drawQuad(cmdb);
 
 		// vpass

src/renderer/Dbg.cpp

@@ -55,16 +55,10 @@ Error Dbg::init(const ConfigSet& initializer)
 	fbInit.m_colorAttachments[0].m_loadOperation =
 		AttachmentLoadOperation::LOAD;
 
-	err = m_fb.create(&getGrManager(), fbInit);
-	if(!err)
-	{
-		m_drawer = getAllocator().newInstance<DebugDrawer>();
-	}
+	m_fb.create(&getGrManager(), fbInit);
+	m_drawer = getAllocator().newInstance<DebugDrawer>();
 
-	if(!err)
-	{
-		err = m_drawer->create(m_r);
-	}
+	err = m_drawer->create(m_r);
 
 	if(!err)
 	{

src/renderer/DebugDrawer.cpp

@@ -39,10 +39,10 @@ Error DebugDrawer::create(Renderer* r)
 	init.m_shaders[U(ShaderType::VERTEX)] = m_vert->getGrShader();
 	init.m_shaders[U(ShaderType::FRAGMENT)] = m_frag->getGrShader();
 
-	ANKI_CHECK(m_ppline.create(&gl, init));
+	m_ppline.create(&gl, init);
 
-	ANKI_CHECK(m_vertBuff.create(&gl, GL_ARRAY_BUFFER, nullptr,
-			sizeof(m_clientLineVerts), GL_DYNAMIC_STORAGE_BIT));
+	m_vertBuff.create(&gl, GL_ARRAY_BUFFER, nullptr,
+		sizeof(m_clientLineVerts), GL_DYNAMIC_STORAGE_BIT);
 
 	m_lineVertCount = 0;
 	m_triVertCount = 0;

src/renderer/Fs.cpp

@@ -25,7 +25,7 @@ Error Fs::init(const ConfigSet&)
 	fbInit.m_depthStencilAttachment.m_texture = m_r->getMs().getDepthRt();
 	fbInit.m_depthStencilAttachment.m_loadOperation =
 		AttachmentLoadOperation::LOAD;
-	ANKI_CHECK(m_fb.create(&getGrManager(), fbInit));
+	m_fb.create(&getGrManager(), fbInit);
 
 	return ErrorCode::NONE;
 }

src/renderer/Is.cpp

@@ -208,7 +208,7 @@ Error Is::initInternal(const ConfigSet& config)
 	PipelinePtr::Initializer init;
 		init.m_shaders[U(ShaderType::VERTEX)] = m_lightVert->getGrShader();
 		init.m_shaders[U(ShaderType::FRAGMENT)] = m_lightFrag->getGrShader();
-	ANKI_CHECK(m_lightPpline.create(&getGrManager(), init));
+	m_lightPpline.create(&getGrManager(), init);
 
 	//
 	// Create framebuffer
@@ -225,7 +225,7 @@ Error Is::initInternal(const ConfigSet& config)
 	fbInit.m_colorAttachments[0].m_texture = m_rt;
 	fbInit.m_colorAttachments[0].m_loadOperation =
 		AttachmentLoadOperation::DONT_CARE;
-	ANKI_CHECK(m_fb.create(&getGrManager(), fbInit));
+	m_fb.create(&getGrManager(), fbInit);
 
 	//
 	// Init the quad
@@ -233,34 +233,34 @@ 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}};
 
-	ANKI_CHECK(m_quadPositionsVertBuff.create(&getGrManager(), GL_ARRAY_BUFFER,
-		&quadVertCoords[0][0], sizeof(quadVertCoords), 0));
+	m_quadPositionsVertBuff.create(&getGrManager(), GL_ARRAY_BUFFER,
+		&quadVertCoords[0][0], sizeof(quadVertCoords), 0);
 
 	//
 	// Create UBOs
 	//
-	ANKI_CHECK(m_commonBuffer.create(&getGrManager(), GL_UNIFORM_BUFFER,
-		nullptr, sizeof(shader::CommonUniforms), GL_DYNAMIC_STORAGE_BIT));
+	m_commonBuffer.create(&getGrManager(), GL_UNIFORM_BUFFER,
+		nullptr, sizeof(shader::CommonUniforms), GL_DYNAMIC_STORAGE_BIT);
 
 	for(U i = 0; i < MAX_FRAMES; ++i)
 	{
 		// Lights
-		ANKI_CHECK(m_lightsBuffers[i].create(&getGrManager(),
+		m_lightsBuffers[i].create(&getGrManager(),
 			GL_SHADER_STORAGE_BUFFER, nullptr, calcLightsBufferSize(),
-			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 
 		// Tiles
-		ANKI_CHECK(m_tilesBuffers[i].create(&getGrManager(),
+		m_tilesBuffers[i].create(&getGrManager(),
 			GL_SHADER_STORAGE_BUFFER, nullptr,
 			m_r->getTilesCountXY() * sizeof(shader::Tile),
-			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 
 		// Index
-		ANKI_CHECK(m_lightIdsBuffers[i].create(&getGrManager(),
+		m_lightIdsBuffers[i].create(&getGrManager(),
 			GL_SHADER_STORAGE_BUFFER,
 			nullptr, (m_maxPointLights * m_maxSpotLights * m_maxSpotTexLights)
 			* sizeof(U32),
-			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 	}
 
 	// Get addresses

src/renderer/Lf.cpp

@@ -60,25 +60,25 @@ Error Lf::initSprite(const ConfigSet& config)
 		ANKI_LOGE("Incorrect m_maxSpritesPerFlare or m_maxFlares");
 		return ErrorCode::USER_DATA;
 	}
-	
+
 	// Load program + ppline
 	StringAuto pps(getAllocator());
 
 	pps.sprintf("#define MAX_SPRITES %u\n", m_maxSpritesPerFlare);
 
-	ANKI_CHECK(m_realVert.loadToCache(&getResourceManager(), 
+	ANKI_CHECK(m_realVert.loadToCache(&getResourceManager(),
 		"shaders/LfSpritePass.vert.glsl", pps.toCString(), "r_"));
 
-	ANKI_CHECK(m_realFrag.loadToCache(&getResourceManager(), 
+	ANKI_CHECK(m_realFrag.loadToCache(&getResourceManager(),
 		"shaders/LfSpritePass.frag.glsl", pps.toCString(), "r_"));
 
 	PipelinePtr::Initializer init;
 	init.m_shaders[U(ShaderType::VERTEX)] = m_realVert->getGrShader();
 	init.m_shaders[U(ShaderType::FRAGMENT)] = m_realFrag->getGrShader();
-	ANKI_CHECK(m_realPpline.create(&getGrManager(), init));
+	m_realPpline.create(&getGrManager(), init);
 
 	// Create buffer
-	PtrSize uboAlignment = 
+	PtrSize uboAlignment =
 		m_r->_getGrManager().getBufferOffsetAlignment(GL_UNIFORM_BUFFER);
 	m_flareSize = getAlignedRoundUp(
 		uboAlignment, sizeof(Sprite) * m_maxSpritesPerFlare);
@@ -86,9 +86,9 @@ Error Lf::initSprite(const ConfigSet& config)
 
 	for(U i = 0; i < m_flareDataBuff.getSize(); ++i)
 	{
-		ANKI_CHECK(m_flareDataBuff[i].create(
-			&getGrManager(), GL_UNIFORM_BUFFER, nullptr, blockSize, 
-			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
+		m_flareDataBuff[i].create(
+			&getGrManager(), GL_UNIFORM_BUFFER, nullptr, blockSize,
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 	}
 
 	return ErrorCode::NONE;
@@ -102,14 +102,14 @@ Error Lf::initOcclusion(const ConfigSet& config)
 
 	for(U i = 0; i < m_positionsVertBuff.getSize(); ++i)
 	{
-		ANKI_CHECK(m_positionsVertBuff[i].create(
-			&getGrManager(), GL_ARRAY_BUFFER, nullptr, buffSize, 
-			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
+		m_positionsVertBuff[i].create(
+			&getGrManager(), GL_ARRAY_BUFFER, nullptr, buffSize,
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 	}
 
 	// Init MVP buff
-	ANKI_CHECK(m_mvpBuff.create(&getGrManager(), GL_UNIFORM_BUFFER, 
-		nullptr, sizeof(Mat4), GL_DYNAMIC_STORAGE_BIT));
+	m_mvpBuff.create(&getGrManager(), GL_UNIFORM_BUFFER,
+		nullptr, sizeof(Mat4), GL_DYNAMIC_STORAGE_BIT);
 
 	// Shaders
 	ANKI_CHECK(m_occlusionVert.load("shaders/LfOcclusion.vert.glsl",
@@ -120,9 +120,9 @@ Error Lf::initOcclusion(const ConfigSet& config)
 
 	PipelinePtr::Initializer init;
 		init.m_shaders[U(ShaderType::VERTEX)] = m_occlusionVert->getGrShader();
-		init.m_shaders[U(ShaderType::FRAGMENT)] = 
+		init.m_shaders[U(ShaderType::FRAGMENT)] =
 			m_occlusionFrag->getGrShader();
-	ANKI_CHECK(m_occlusionPpline.create(&getGrManager(), init));
+	m_occlusionPpline.create(&getGrManager(), init);
 
 	return ErrorCode::NONE;
 }
@@ -167,7 +167,7 @@ void Lf::runOcclusionTests(CommandBufferPtr& cmdb)
 		BufferPtr& 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);
 
@@ -180,7 +180,7 @@ void Lf::runOcclusionTests(CommandBufferPtr& cmdb)
 		auto end = vi.getLensFlaresBegin() + totalCount;
 		for(; it != end; ++it)
 		{
-			LensFlareComponent& lf = 
+			LensFlareComponent& lf =
 				(it->m_node)->getComponent<LensFlareComponent>();
 
 			*positions = lf.getWorldPosition().xyz();
@@ -190,7 +190,7 @@ void Lf::runOcclusionTests(CommandBufferPtr& cmdb)
 			query.begin(cmdb);
 
 			cmdb.drawArrays(GL_POINTS, 1, 1, positions - initialPositions);
-			
+
 			query.end(cmdb);
 
 			++positions;
@@ -217,7 +217,7 @@ void Lf::run(CommandBufferPtr& cmdb)
 	if(totalCount > 0)
 	{
 		// Allocate client buffer
-		const U uboAlignment = 
+		const U uboAlignment =
 			m_r->_getGrManager().getBufferOffsetAlignment(GL_UNIFORM_BUFFER);
 		const U bufferSize = m_flareSize * totalCount;
 
@@ -238,8 +238,8 @@ void Lf::run(CommandBufferPtr& cmdb)
 		auto it = vi.getLensFlaresBegin();
 		auto end = vi.getLensFlaresBegin() + totalCount;
 		for(; it != end; ++it)
-		{			
-			LensFlareComponent& lf = 
+		{
+			LensFlareComponent& lf =
 				(it->m_node)->getComponent<LensFlareComponent>();
 			U count = 0;
 
@@ -260,7 +260,7 @@ void Lf::run(CommandBufferPtr& cmdb)
 			F32 len = dir.getLength();
 			dir /= len; // Normalize dir
 
-			// First flare 
+			// First flare
 			sprites[count].m_pos = posNdc;
 			sprites[count].m_scale =
 				lf.getFirstFlareSize() * Vec2(1.0, m_r->getAspectRatio());
@@ -271,15 +271,15 @@ void Lf::run(CommandBufferPtr& cmdb)
 			// Render
 			lf.getTexture().bind(cmdb, 0);
 			flareDataBuff.bindShaderBuffer(
-				cmdb, 
-				reinterpret_cast<U8*>(sprites) - spritesInitialPtr, 
+				cmdb,
+				reinterpret_cast<U8*>(sprites) - spritesInitialPtr,
 				sizeof(Sprite) * count,
 				0);
 
 			OcclusionQueryPtr query;
 			Bool queryInvalid;
 			lf.getOcclusionQueryToCheck(query, queryInvalid);
-			
+
 			if(!queryInvalid)
 			{
 				m_r->drawQuadConditional(query, cmdb);
@@ -293,11 +293,11 @@ void Lf::run(CommandBufferPtr& cmdb)
 			ANKI_ASSERT(count <= m_maxSpritesPerFlare);
 
 			// Advance
-			U advancementSize = 
+			U advancementSize =
 				getAlignedRoundUp(uboAlignment, sizeof(Sprite) * count);
 			sprites = reinterpret_cast<Sprite*>(
 				reinterpret_cast<U8*>(sprites) + advancementSize);
-			
+
 		}
 
 		ANKI_ASSERT(

src/renderer/MainRenderer.cpp

@@ -37,7 +37,7 @@ Error MainRenderer::create(
 	ANKI_CHECK(Renderer::init(threadpool, resources, gl, allocCb,
 		allocCbUserData, config, globalTimestamp));
 
-	ANKI_CHECK(initGl());
+	initGl();
 
 	ANKI_CHECK(
 		m_blitFrag.load("shaders/Final.frag.glsl", &_getResourceManager()));
@@ -62,7 +62,7 @@ Error MainRenderer::render(SceneGraph& scene)
 
 	for(U i = 0; i < JOB_CHAINS_COUNT; i++)
 	{
-		ANKI_CHECK(jobs[i].create(&gl, m_jobsInitHints[i]));
+		jobs[i].create(&gl, m_jobsInitHints[i]);
 	}
 
 	ANKI_CHECK(Renderer::render(scene, jobs));
@@ -119,22 +119,16 @@ Error MainRenderer::render(SceneGraph& scene)
 }
 
 //==============================================================================
-Error MainRenderer::initGl()
+void MainRenderer::initGl()
 {
 	// get max texture units
 	CommandBufferPtr cmdb;
-	Error err = cmdb.create(&_getGrManager());
+	cmdb.create(&_getGrManager());
 
-	if(!err)
-	{
-		cmdb.enableCulling(true);
-		cmdb.setCullFace(GL_BACK);
-		cmdb.enablePointSize(true);
-
-		cmdb.flush();
-	}
-
-	return err;
+	cmdb.enableCulling(true);
+	cmdb.setCullFace(GL_BACK);
+	cmdb.enablePointSize(true);
+	cmdb.flush();
 }
 
 //==============================================================================

src/renderer/Ms.cpp

@@ -57,7 +57,7 @@ Error Ms::createRt(U32 index, U32 samples)
 		AttachmentLoadOperation::CLEAR;
 	fbInit.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0;
 
-	ANKI_CHECK(plane.m_fb.create(&getGrManager(), fbInit));
+	plane.m_fb.create(&getGrManager(), fbInit);
 
 	return ErrorCode::NONE;
 }

src/renderer/Pps.cpp

@@ -54,16 +54,16 @@ Error Pps::initInternal(const ConfigSet& config)
 	// FBO
 	ANKI_CHECK(
 		m_r->createRenderTarget(
-		m_r->getWidth(), m_r->getHeight(), 
-		PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM), 
+		m_r->getWidth(), m_r->getHeight(),
+		PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM),
 		1, SamplingFilter::LINEAR, 1, m_rt));
 
 	FramebufferPtr::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = m_rt;
-	fbInit.m_colorAttachments[0].m_loadOperation = 
+	fbInit.m_colorAttachments[0].m_loadOperation =
 		AttachmentLoadOperation::DONT_CARE;
-	ANKI_CHECK(m_fb.create(&getGrManager(), fbInit));
+	m_fb.create(&getGrManager(), fbInit);
 
 	// SProg
 	StringAuto pps(getAllocator());
@@ -76,7 +76,7 @@ Error Pps::initInternal(const ConfigSet& config)
 		"#define GAMMA_CORRECTION_ENABLED %u\n"
 		"#define FBO_WIDTH %u\n"
 		"#define FBO_HEIGHT %u\n",
-		m_ssao->getEnabled(), 
+		m_ssao->getEnabled(),
 		m_bloom->getEnabled(),
 		m_sslf->getEnabled(),
 		U(config.get("pps.sharpen")),
@@ -143,16 +143,16 @@ Error Pps::run(CommandBufferPtr& cmdb)
 		m_sslf->run(cmdb);
 	}
 
-	Bool drawToDefaultFbo = 
-		!m_r->getDbg().getEnabled() 
+	Bool drawToDefaultFbo =
+		!m_r->getDbg().getEnabled()
 		&& !m_r->getIsOffscreen()
 		&& m_r->getRenderingQuality() == 1.0;
 
 	if(drawToDefaultFbo)
 	{
 		m_r->getDefaultFramebuffer().bind(cmdb);
-		cmdb.setViewport(0, 0, 
-			m_r->getDefaultFramebufferWidth(), 
+		cmdb.setViewport(0, 0,
+			m_r->getDefaultFramebufferWidth(),
 			m_r->getDefaultFramebufferHeight());
 	}
 	else

src/renderer/Renderer.cpp

@@ -127,8 +127,8 @@ Error Renderer::initInternal(const ConfigSet& config)
 	static const F32 quadVertCoords[][2] = {{1.0, 1.0}, {-1.0, 1.0},
 		{1.0, -1.0}, {-1.0, -1.0}};
 
-	ANKI_CHECK(m_quadPositionsBuff.create(m_gr, GL_ARRAY_BUFFER,
-		&quadVertCoords[0][0], sizeof(quadVertCoords), 0));
+	m_quadPositionsBuff.create(m_gr, GL_ARRAY_BUFFER,
+		&quadVertCoords[0][0], sizeof(quadVertCoords), 0);
 
 	ANKI_CHECK(m_drawQuadVert.load("shaders/Quad.vert.glsl", m_resources));
 
@@ -149,7 +149,7 @@ Error Renderer::initInternal(const ConfigSet& config)
 
 	// Default FB
 	FramebufferPtr::Initializer fbInit;
-	ANKI_CHECK(m_defaultFb.create(m_gr, fbInit));
+	m_defaultFb.create(m_gr, fbInit);
 
 	return ErrorCode::NONE;
 }
@@ -288,7 +288,7 @@ Error Renderer::createRenderTarget(U32 w, U32 h, const PixelFormat& format,
 	init.m_sampling.m_anisotropyLevel = 0;
 
 	CommandBufferPtr cmdBuff;
-	ANKI_CHECK(cmdBuff.create(m_gr));
+	cmdBuff.create(m_gr);
 
 	rt.create(cmdBuff, init);
 	cmdBuff.finish();
@@ -303,8 +303,9 @@ Error Renderer::createDrawQuadPipeline(
 	PipelinePtr::Initializer init;
 	init.m_shaders[U(ShaderType::VERTEX)] = m_drawQuadVert->getGrShader();
 	init.m_shaders[U(ShaderType::FRAGMENT)] = frag;
+	ppline.create(m_gr, init);
 
-	return ppline.create(m_gr, init);
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/renderer/RenderingPass.cpp

@@ -81,7 +81,7 @@ Error BlurringRenderingPass::initBlurring(
 		fbInit.m_colorAttachments[0].m_texture = dir.m_rt;
 		fbInit.m_colorAttachments[0].m_loadOperation =
 			AttachmentLoadOperation::DONT_CARE;
-		ANKI_CHECK(dir.m_fb.create(&getGrManager(), fbInit));
+		dir.m_fb.create(&getGrManager(), fbInit);
 
 		ANKI_CHECK(dir.m_frag.loadToCache(&getResourceManager(),
 			"shaders/VariableSamplingBlurGeneric.frag.glsl",

src/renderer/Sm.cpp

@@ -45,15 +45,15 @@ Error Sm::init(const ConfigSet& initializer)
 	sminit.m_depth = initializer.get("is.sm.maxLights");
 	sminit.m_format = PixelFormat(ComponentFormat::D16, TransformFormat::FLOAT);
 	sminit.m_mipmapsCount = 1;
-	sminit.m_sampling.m_minMagFilter = m_bilinearEnabled 
-		? SamplingFilter::LINEAR 
+	sminit.m_sampling.m_minMagFilter = m_bilinearEnabled
+		? SamplingFilter::LINEAR
 		: SamplingFilter::NEAREST;
 	sminit.m_sampling.m_compareOperation = CompareOperation::LESS_EQUAL;
 
 	CommandBufferPtr cmdBuff;
-	ANKI_CHECK(cmdBuff.create(&getGrManager()));
+	cmdBuff.create(&getGrManager());
 
-	ANKI_CHECK(m_sm2DArrayTex.create(cmdBuff, sminit));
+	m_sm2DArrayTex.create(cmdBuff, sminit);
 	cmdBuff.flush();
 
 	// Init sms
@@ -61,7 +61,7 @@ Error Sm::init(const ConfigSet& initializer)
 
 	FramebufferPtr::Initializer fbInit;
 	fbInit.m_depthStencilAttachment.m_texture = m_sm2DArrayTex;
-	fbInit.m_depthStencilAttachment.m_loadOperation = 
+	fbInit.m_depthStencilAttachment.m_loadOperation =
 		AttachmentLoadOperation::CLEAR;
 	fbInit.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0;
 
@@ -71,7 +71,7 @@ Error Sm::init(const ConfigSet& initializer)
 		sm.m_layerId = layer;
 
 		fbInit.m_depthStencilAttachment.m_layer = layer;
-		ANKI_CHECK(sm.m_fb.create(&getGrManager(), fbInit));
+		sm.m_fb.create(&getGrManager(), fbInit);
 
 		++layer;
 	}
@@ -108,7 +108,7 @@ void Sm::finishDraw(CommandBufferPtr& cmdBuff)
 }
 
 //==============================================================================
-Error Sm::run(SceneNode* shadowCasters[], U32 shadowCastersCount, 
+Error Sm::run(SceneNode* shadowCasters[], U32 shadowCastersCount,
 	CommandBufferPtr& cmdBuff)
 {
 	ANKI_ASSERT(m_enabled);

src/renderer/Ssao.cpp

@@ -80,7 +80,7 @@ Error Ssao::createFb(FramebufferPtr& fb, TexturePtr& rt)
 	fbInit.m_colorAttachments[0].m_texture = rt;
 	fbInit.m_colorAttachments[0].m_loadOperation =
 		AttachmentLoadOperation::DONT_CARE;
-	ANKI_CHECK(fb.create(&getGrManager(), fbInit));
+	fb.create(&getGrManager(), fbInit);
 
 	return ErrorCode::NONE;
 }
@@ -118,7 +118,7 @@ Error Ssao::initInternal(const ConfigSet& config)
 	// noise texture
 	//
 	CommandBufferPtr cmdb;
-	ANKI_CHECK(cmdb.create(&getGrManager()));
+	cmdb.create(&getGrManager());
 
 	Array<Vec3, NOISE_TEX_SIZE * NOISE_TEX_SIZE> noise;
 
@@ -160,8 +160,8 @@ Error Ssao::initInternal(const ConfigSet& config)
 	//
 	// Shaders
 	//
-	ANKI_CHECK(m_uniformsBuff.create(&getGrManager(), GL_SHADER_STORAGE_BUFFER,
-		nullptr, sizeof(ShaderCommonUniforms), GL_DYNAMIC_STORAGE_BIT));
+	m_uniformsBuff.create(&getGrManager(), GL_SHADER_STORAGE_BUFFER,
+		nullptr, sizeof(ShaderCommonUniforms), GL_DYNAMIC_STORAGE_BIT);
 
 	StringAuto pps(getAllocator());
 

src/renderer/Sslf.cpp

@@ -36,11 +36,11 @@ Error Sslf::initInternal(const ConfigSet& config)
 	StringAuto pps(getAllocator());
 
 	pps.sprintf(
-		"#define TEX_DIMENSIONS vec2(%u.0, %u.0)\n", 
+		"#define TEX_DIMENSIONS vec2(%u.0, %u.0)\n",
 		m_r->getPps().getBloom().getWidth(),
 		m_r->getPps().getBloom().getHeight());
 
-	ANKI_CHECK(m_frag.loadToCache(&getResourceManager(), 
+	ANKI_CHECK(m_frag.loadToCache(&getResourceManager(),
 		"shaders/PpsSslf.frag.glsl", pps.toCString(), "r_"));
 
 	ANKI_CHECK(m_r->createDrawQuadPipeline(m_frag->getGrShader(), m_ppline));
@@ -50,17 +50,17 @@ Error Sslf::initInternal(const ConfigSet& config)
 		"engine_data/lens_dirt.ankitex", &getResourceManager()));
 
 	// Create the render target and FB
-	ANKI_CHECK(m_r->createRenderTarget(m_r->getPps().getBloom().getWidth(), 
-		m_r->getPps().getBloom().getHeight(), 
-		PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM), 
+	ANKI_CHECK(m_r->createRenderTarget(m_r->getPps().getBloom().getWidth(),
+		m_r->getPps().getBloom().getHeight(),
+		PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM),
 		1, SamplingFilter::LINEAR, 1, m_rt));
 
 	FramebufferPtr::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = m_rt;
-	fbInit.m_colorAttachments[0].m_loadOperation = 
+	fbInit.m_colorAttachments[0].m_loadOperation =
 		AttachmentLoadOperation::DONT_CARE;
-	ANKI_CHECK(m_fb.create(&getGrManager(), fbInit));
+	m_fb.create(&getGrManager(), fbInit);
 
 	return ErrorCode::NONE;
 }
@@ -69,16 +69,16 @@ Error Sslf::initInternal(const ConfigSet& config)
 void Sslf::run(CommandBufferPtr& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
-	
+
 	// Draw to the SSLF FB
 	m_fb.bind(cmdb);
-	cmdb.setViewport(0, 0, m_r->getPps().getBloom().getWidth(), 
+	cmdb.setViewport(0, 0, m_r->getPps().getBloom().getWidth(),
 		m_r->getPps().getBloom().getHeight());
 
 	m_ppline.bind(cmdb);
 
 	Array<TexturePtr, 2> tarr = {{
-		m_r->getPps().getBloom().getRt(), 
+		m_r->getPps().getBloom().getRt(),
 		m_lensDirtTex->getGlTexture()}};
 	cmdb.bindTextures(0, tarr.begin(), tarr.getSize());
 

src/renderer/Sslr.cpp

@@ -70,7 +70,7 @@ Error Sslr::init(const ConfigSet& config)
 		fbInit.m_colorAttachments[0].m_texture = dir.m_rt;
 		fbInit.m_colorAttachments[0].m_loadOperation =
 			AttachmentLoadOperation::LOAD;
-		ANKI_CHECK(dir.m_fb.create(&getGrManager(), fbInit));
+		dir.m_fb.create(&getGrManager(), fbInit);
 	}
 
 	return ErrorCode::NONE;

src/renderer/Tiler.cpp

@@ -99,7 +99,7 @@ Error Tiler::initInternal()
 
 	PipelinePtr::Initializer pplineInit;
 	pplineInit.m_shaders[U(ShaderType::COMPUTE)] = m_shader->getGrShader();
-	ANKI_CHECK(m_ppline.create(&getGrManager(), pplineInit));
+	m_ppline.create(&getGrManager(), pplineInit);
 
 	// Init planes. One plane for each direction, plus near/far plus the world
 	// space of those
@@ -152,10 +152,9 @@ Error Tiler::initPbos()
 
 	for(U i = 0; i < m_pbos.getSize(); ++i)
 	{
-		ANKI_CHECK(
-			m_pbos[i].create(&getGrManager(), GL_SHADER_STORAGE_BUFFER,
+		m_pbos[i].create(&getGrManager(), GL_SHADER_STORAGE_BUFFER,
 			nullptr, pboSize,
-			GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
+			GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 	}
 
 	// Get persistent address

src/renderer/Tm.cpp

@@ -23,19 +23,19 @@ Error Tm::create(const ConfigSet& initializer)
 		m_r->getWidth(),
 		m_r->getHeight());
 
-	ANKI_CHECK(m_luminanceShader.loadToCache(&getResourceManager(), 
+	ANKI_CHECK(m_luminanceShader.loadToCache(&getResourceManager(),
 		"shaders/PpsTmAverageLuminance.comp.glsl", pps.toCString(), "rppstm_"));
 
 	// Create ppline
 	PipelinePtr::Initializer pplineInit;
-	pplineInit.m_shaders[U(ShaderType::COMPUTE)] = 
+	pplineInit.m_shaders[U(ShaderType::COMPUTE)] =
 		m_luminanceShader->getGrShader();
-	ANKI_CHECK(m_luminancePpline.create(&getGrManager(), pplineInit));
+	m_luminancePpline.create(&getGrManager(), pplineInit);
 
 	// Create buffer
 	Vec4 data(0.5);
-	ANKI_CHECK(m_luminanceBuff.create(&getGrManager(), GL_SHADER_STORAGE_BUFFER,
-		&data[0], sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT));
+	m_luminanceBuff.create(&getGrManager(), GL_SHADER_STORAGE_BUFFER,
+		&data[0], sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT);
 
 	return ErrorCode::NONE;
 }

src/resource/Material.cpp

@@ -62,7 +62,7 @@ MaterialVariable::~MaterialVariable()
 
 //==============================================================================
 template<typename T>
-void MaterialVariableTemplate<T>::create(ResourceAllocator<U8> alloc, 
+void MaterialVariableTemplate<T>::create(ResourceAllocator<U8> alloc,
 	const CString& name, const T* x, U32 size)
 {
 	m_name.create(alloc, name);
@@ -96,7 +96,7 @@ Error MaterialVariableTemplate<T>::_newInstance(
 
 		if(in.m_value.getSize() != floatsNeeded)
 		{
-			ANKI_LOGE("Incorrect number of values. Variable %s", 
+			ANKI_LOGE("Incorrect number of values. Variable %s",
 				&in.m_name[0]);
 
 			return ErrorCode::USER_DATA;
@@ -120,7 +120,7 @@ Error MaterialVariableTemplate<T>::_newInstance(
 
 	if(floats.getSize() > 0)
 	{
-		out->create(alloc, in.m_name.toCString(), 
+		out->create(alloc, in.m_name.toCString(),
 			(T*)&floats[0], in.m_arraySize);
 	}
 	else
@@ -322,23 +322,23 @@ Error Material::getProgramPipeline(
 	{
 		PipelinePtr::Initializer pplineInit;
 
-		pplineInit.m_shaders[U(ShaderType::VERTEX)] = 
+		pplineInit.m_shaders[U(ShaderType::VERTEX)] =
 			getProgram(key, ShaderType::VERTEX)->getGrShader();
 
 		if(key.m_tessellation)
 		{
-			pplineInit.m_shaders[U(ShaderType::TESSELLATION_CONTROL)] = 
+			pplineInit.m_shaders[U(ShaderType::TESSELLATION_CONTROL)] =
 				getProgram(
 				key, ShaderType::TESSELLATION_CONTROL)->getGrShader();
-			pplineInit.m_shaders[U(ShaderType::TESSELLATION_EVALUATION)] = 
+			pplineInit.m_shaders[U(ShaderType::TESSELLATION_EVALUATION)] =
 				getProgram(
 				key, ShaderType::TESSELLATION_EVALUATION)->getGrShader();
 		}
 
-		pplineInit.m_shaders[U(ShaderType::FRAGMENT)] = 
+		pplineInit.m_shaders[U(ShaderType::FRAGMENT)] =
 			getProgram(key, ShaderType::FRAGMENT)->getGrShader();
 
-		ANKI_CHECK(ppline.create(&getManager().getGrManager(), pplineInit));
+		ppline.create(&getManager().getGrManager(), pplineInit);
 	}
 
 	out = ppline;
@@ -461,7 +461,7 @@ Error Material::parseMaterialTag(const XmlElement& materialEl)
 
 	// Alloc program vector
 	m_progs.create(getAllocator(),
-		countShaders(ShaderType::VERTEX) 
+		countShaders(ShaderType::VERTEX)
 		+ countShaders(ShaderType::TESSELLATION_CONTROL)
 		+ countShaders(ShaderType::TESSELLATION_EVALUATION)
 		+ countShaders(ShaderType::GEOMETRY)
@@ -471,11 +471,11 @@ Error Material::parseMaterialTag(const XmlElement& materialEl)
 	m_pplines.create(getAllocator(), m_passesCount * m_lodsCount * tessCount);
 
 	m_hash = 0;
-	for(ShaderType shader = ShaderType::VERTEX; 
-		shader <= ShaderType::FRAGMENT; 
+	for(ShaderType shader = ShaderType::VERTEX;
+		shader <= ShaderType::FRAGMENT;
 		++shader)
 	{
-		Bool isTessellationShader = shader == ShaderType::TESSELLATION_CONTROL 
+		Bool isTessellationShader = shader == ShaderType::TESSELLATION_CONTROL
 			|| shader == ShaderType::TESSELLATION_EVALUATION;
 
 		if(!m_tessellation && isTessellationShader)
@@ -556,7 +556,7 @@ Error Material::createProgramSourceToCache(
 	prefix.toString(h);
 
 	// Create path
-	out.sprintf("%s/mtl_%s.glsl", 
+	out.sprintf("%s/mtl_%s.glsl",
 		&getManager()._getCacheDirectory()[0],
 		&prefix[0]);
 
@@ -603,7 +603,7 @@ Error Material::populateVariables(const MaterialProgramCreator& loader)
 		case ShaderVariableDataType::SAMPLER_CUBE:
 			{
 				TextureResourcePointer tp;
-				
+
 				if(in.m_value.getSize() > 0)
 				{
 					ANKI_CHECK(tp.load(
@@ -611,7 +611,7 @@ Error Material::populateVariables(const MaterialProgramCreator& loader)
 				}
 
 				auto alloc = getAllocator();
-				MaterialVariableTemplate<TextureResourcePointer>* tvar = 
+				MaterialVariableTemplate<TextureResourcePointer>* tvar =
 					alloc.newInstance<
 					MaterialVariableTemplate<TextureResourcePointer>>();
 

src/resource/Mesh.cpp

@@ -24,8 +24,8 @@ Mesh::~Mesh()
 //==============================================================================
 Bool Mesh::isCompatible(const Mesh& other) const
 {
-	return hasWeights() == other.hasWeights() 
-		&& getSubMeshesCount() == other.getSubMeshesCount(); 
+	return hasWeights() == other.hasWeights()
+		&& getSubMeshesCount() == other.getSubMeshesCount();
 }
 
 //==============================================================================
@@ -63,23 +63,23 @@ Error Mesh::createBuffers(const MeshLoader& loader)
 	GrManager& gr = getManager().getGrManager();
 
 	// Create vertex buffer
-	ANKI_CHECK(m_vertBuff.create(&gr, GL_ARRAY_BUFFER, loader.getVertexData(), 
-		loader.getVertexDataSize(), 0));
+	m_vertBuff.create(&gr, GL_ARRAY_BUFFER, loader.getVertexData(),
+		loader.getVertexDataSize(), 0);
 
 	// Create index buffer
-	ANKI_CHECK(m_indicesBuff.create(&gr, GL_ELEMENT_ARRAY_BUFFER, 
-		loader.getIndexData(), loader.getIndexDataSize(), 0));
+	m_indicesBuff.create(&gr, GL_ELEMENT_ARRAY_BUFFER,
+		loader.getIndexData(), loader.getIndexDataSize(), 0);
 
 	return ErrorCode::NONE;
 }
 
 //==============================================================================
-void Mesh::getBufferInfo(const VertexAttribute attrib, 
-	BufferPtr& v, U32& size, GLenum& type, 
+void Mesh::getBufferInfo(const VertexAttribute attrib,
+	BufferPtr& v, U32& size, GLenum& type,
 	U32& stride, U32& offset, Bool& normalized) const
 {
-	stride = sizeof(Vec3) + sizeof(U32) + sizeof(U32) 
-		+ m_texChannelsCount * sizeof(HVec2) 
+	stride = sizeof(Vec3) + sizeof(U32) + sizeof(U32)
+		+ m_texChannelsCount * sizeof(HVec2)
 		+ ((m_weights) ? (sizeof(U8) * 4 + sizeof(HVec4)) : 0);
 
 	// Set all to zero
@@ -126,7 +126,7 @@ void Mesh::getBufferInfo(const VertexAttribute attrib,
 			v = m_vertBuff;
 			size = 2;
 			type = GL_HALF_FLOAT;
-			offset = sizeof(Vec3) + sizeof(U32) + sizeof(U32) 
+			offset = sizeof(Vec3) + sizeof(U32) + sizeof(U32)
 				+ sizeof(HVec2);
 		}
 		break;
@@ -136,7 +136,7 @@ void Mesh::getBufferInfo(const VertexAttribute attrib,
 			v = m_vertBuff;
 			size = 4;
 			type = GL_UNSIGNED_BYTE;
-			offset = sizeof(Vec3) + sizeof(U32) + sizeof(U32) 
+			offset = sizeof(Vec3) + sizeof(U32) + sizeof(U32)
 				+ m_texChannelsCount * sizeof(HVec2);
 			normalized = true;
 		}
@@ -147,7 +147,7 @@ void Mesh::getBufferInfo(const VertexAttribute attrib,
 			v = m_vertBuff;
 			size = 4;
 			type = GL_HALF_FLOAT;
-			offset = sizeof(Vec3) + sizeof(U32) + sizeof(U32) 
+			offset = sizeof(Vec3) + sizeof(U32) + sizeof(U32)
 				+ m_texChannelsCount * sizeof(HVec2) + sizeof(U8) * 4;
 		}
 		break;
@@ -203,7 +203,7 @@ Error BucketMesh::load(const CString& filename)
 		CString subMeshFilename;
 		ANKI_CHECK(meshEl.getText(subMeshFilename));
 
-		// Load the submesh and if not the first load the append the 
+		// Load the submesh and if not the first load the append the
 		// vertices to the fullMesh
 		MeshLoader* loader;
 		MeshLoader subLoader(init.m_tempAlloc);
@@ -228,7 +228,7 @@ Error BucketMesh::load(const CString& filename)
 				return ErrorCode::USER_DATA;
 			}
 
-			if(m_texChannelsCount 
+			if(m_texChannelsCount
 				!= loader->getTextureChannelsCount())
 			{
 				ANKI_LOGE("All sub meshes should have the "

src/resource/Model.cpp

@@ -168,7 +168,7 @@ Error ModelPatchBase::create(GrManager* gl)
 
 			// Create vert descriptor
 			CommandBufferPtr vertJobs;
-			ANKI_CHECK(vertJobs.create(gl));
+			vertJobs.create(gl);
 			ANKI_CHECK(createVertexDesc(*mesh, vertJobs));
 
 			m_vertJobs[getVertexDescIdx(key)] = vertJobs;

src/resource/ShaderResource.cpp

@@ -41,11 +41,10 @@ Error ShaderResource::load(const CString& filename, const CString& extraSrc)
 	source.append(pars.getShaderSource());
 
 	// Create
-	ANKI_CHECK(
-		m_shader.create(
+	m_shader.create(
 		&getManager().getGrManager(),
 		pars.getShaderType(), &source[0],
-		source.getLength() + 1));
+		source.getLength() + 1);
 
 	m_type = pars.getShaderType();
 

src/resource/TextureResource.cpp

@@ -27,8 +27,8 @@ Error TextureResource::load(const CString& filename)
 {
 	GrManager& gr = getManager().getGrManager();
 	CommandBufferPtr cmdb;
-	ANKI_CHECK(cmdb.create(&gr)); // Always first to avoid assertions (
-	                              // because of the check of the allocator)
+	cmdb.create(&gr); // Always first to avoid assertions (
+	                  // because of the check of the allocator)
 
 	TexturePtr::Initializer init;
 	init.m_copyDataBeforeReturn = false;
@@ -43,14 +43,14 @@ Error TextureResource::load(const CString& filename)
 		getAllocator().deleteInstance(img);
 		return err;
 	}
-	
+
 	// width + height
 	const auto& tmpSurf = img->getSurface(0, 0);
 	init.m_width = tmpSurf.m_width;
 	init.m_height = tmpSurf.m_height;
-	
+
 	// depth
-	if(img->getTextureType() == ImageLoader::TextureType::_2D_ARRAY 
+	if(img->getTextureType() == ImageLoader::TextureType::_2D_ARRAY
 		|| img->getTextureType() == ImageLoader::TextureType::_3D)
 	{
 		init.m_depth = img->getDepth();
@@ -143,7 +143,7 @@ Error TextureResource::load(const CString& filename)
 	init.m_sampling.m_repeat = true;
 
 	// anisotropyLevel
-	init.m_sampling.m_anisotropyLevel = 
+	init.m_sampling.m_anisotropyLevel =
 		getManager().getTextureAnisotropy();
 
 	// Now assign the data
@@ -160,12 +160,7 @@ Error TextureResource::load(const CString& filename)
 	}
 
 	// Add the GL job to create the texture
-	err = m_tex.create(cmdb, init);
-	if(err)
-	{
-		getAllocator().deleteInstance(img);
-		return err;
-	}
+	m_tex.create(cmdb, init);
 
 	// Add cleanup job
 	cmdb.pushBackUserCommand(deleteImageCallback, img);

src/scene/LensFlareComponent.cpp

@@ -13,17 +13,17 @@ namespace anki {
 Error LensFlareComponent::create(const CString& textureFilename)
 {
 	// Texture
-	Error err = m_tex.load(
-		textureFilename, &m_node->getSceneGraph()._getResourceManager());
+	ANKI_CHECK(m_tex.load(
+		textureFilename, &m_node->getSceneGraph()._getResourceManager()));
 
 	// Queries
 	GrManager& gr = m_node->getSceneGraph().getGrManager();
-	for(auto it = m_queries.getBegin(); it != m_queries.getEnd() && !err; ++it)
+	for(auto it = m_queries.getBegin(); it != m_queries.getEnd(); ++it)
 	{
-		err = (*it).create(&gr, OcclusionQueryPtr::ResultBit::VISIBLE);
+		(*it).create(&gr, OcclusionQueryPtr::ResultBit::VISIBLE);
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -31,7 +31,7 @@ OcclusionQueryPtr& LensFlareComponent::getOcclusionQueryToTest()
 {
 	// Move the query counter
 	m_crntQueryIndex = (m_crntQueryIndex + 1) % m_queries.getSize();
-	
+
 	// Save the timestamp
 	m_queryTestTimestamp[m_crntQueryIndex] = getGlobalTimestamp();
 

src/scene/ParticleEmitter.cpp

@@ -337,9 +337,9 @@ Error ParticleEmitter::create(
 
 	// Create the vertex buffer and object
 	PtrSize buffSize = m_maxNumOfParticles * VERT_SIZE * 3;
-	ANKI_CHECK(m_vertBuff.create(&getSceneGraph().getGrManager(),
+	m_vertBuff.create(&getSceneGraph().getGrManager(),
 		GL_ARRAY_BUFFER, nullptr, buffSize,
-		GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
+		GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
 
 	m_vertBuffMapping =
 		static_cast<U8*>(m_vertBuff.getPersistentMappingAddress());