Out of memory is fatal. Don't handle OOM errors

include/anki/event/EventManager.h

@@ -61,7 +61,13 @@ public:
 
 	/// Create a new event
 	template<typename T, typename... Args>
-	ANKI_USE_RESULT Error newEvent(T*& event, Args... args);
+	ANKI_USE_RESULT Error newEvent(T*& event, Args... args)
+	{
+		event = getSceneAllocator().template newInstance<T>();
+		ANKI_CHECK(event->create(this, args...));
+		registerEvent(event);
+		return ErrorCode::NONE;
+	}
 
 	/// Delete an event. It actualy marks it for deletion
 	void deleteEvent(Event* event)
@@ -88,35 +94,11 @@ private:
 	F32 m_crntTime;
 
 	/// Add an event to the local container
-	ANKI_USE_RESULT Error registerEvent(Event* event);
+	void registerEvent(Event* event);
 
 	/// Remove an event from the container
 	void unregisterEvent(EventsContainer::Iterator it);
 };
-
-//==============================================================================
-template<typename T, typename... Args>
-inline Error EventManager::newEvent(T*& event, Args... args)
-{
-	Error err = ErrorCode::NONE;
-	event = getSceneAllocator().template newInstance<T>();
-	if(event == nullptr)
-	{
-		err = ErrorCode::OUT_OF_MEMORY;
-	}
-	
-	if(!err)
-	{
-		err = event->create(this, args...);
-	}
-
-	if(!err)
-	{
-		err = registerEvent(event);
-	}
-
-	return err;
-}
 /// @}
 
 } // end namespace anki

include/anki/gr/GrHandle.h

@@ -110,40 +110,20 @@ public:
 	///                object. Some objects example may require deferred 
 	///                deleters.
 	template<typename TDeleter>
-	ANKI_USE_RESULT Error create(GrManager& manager, TDeleter del)
+	void create(GrManager& manager, TDeleter del)
 	{
 		using Cb = CtrlBlock<TDeleter>;
 
-		Error err = ErrorCode::NONE;
-
 		// Create the object
 		auto alloc = manager.getAllocator();
 		T* ptr = alloc.template newInstance<T>(&manager);
+		Cb* cb = alloc.template newInstance<Cb>();
 
-		if(ptr != nullptr)
-		{
-			Cb* cb = alloc.template newInstance<Cb>();
-
-			if(cb != nullptr)
-			{
-				cb->m_del = del;
-				ptr->GrObject::getRefcount().store(1);
-				cb->m_ptr = ptr;
-
-				m_cb = cb;
-			}
-			else
-			{
-				alloc.template deleteInstance(ptr);
-				err = ErrorCode::OUT_OF_MEMORY;
-			}
-		}
-		else
-		{
-			err = ErrorCode::OUT_OF_MEMORY;
-		}
+		cb->m_del = del;
+		ptr->GrObject::getRefcount().store(1);
+		cb->m_ptr = ptr;
 
-		return err;
+		m_cb = cb;
 	}
 
 	/// Return true if it's pointing to actual data

include/anki/gr/gl/BufferImpl.h

@@ -38,7 +38,7 @@ public:
 	///		   Put NULL if you want just to allocate memory
 	/// @param sizeInBytes The size of the buffer that we will allocate in bytes
 	/// @param flags GL access flags
-	ANKI_USE_RESULT Error create(
+	void create(
 		GLenum target, const void* dataPtr, U32 sizeInBytes, GLbitfield flags);
 
 	GLenum getTarget() const

include/anki/gr/gl/CommandBufferImpl.h

@@ -48,7 +48,7 @@ public:
 	/// Default constructor
 	/// @param server The command buffers server
 	/// @param hints Hints to optimize the command's allocator
-	ANKI_USE_RESULT Error create(const InitHints& hints);
+	void create(const InitHints& hints);
 
 	/// Get the internal allocator.
 	CommandBufferAllocator<U8> getInternalAllocator() const

include/anki/gr/gl/OcclusionQueryImpl.h

@@ -34,7 +34,7 @@ public:
 	/// @param condRenderingBit If the query is used in conditional rendering
 	///        the result will be checked against this mask. If the result
 	///        contains any of the bits then the dracall will not be skipped.
-	ANKI_USE_RESULT Error create(ResultBit condRenderingBit);
+	void create(ResultBit condRenderingBit);
 
 	/// Begin query.
 	void begin();

include/anki/gr/gl/ShaderImpl.h

@@ -57,7 +57,7 @@ private:
 
 	void destroy();
 
-	ANKI_USE_RESULT Error handleError(String& src);
+	void handleError(String& src);
 };
 /// @}
 

include/anki/gr/gl/TextureImpl.h

@@ -32,7 +32,7 @@ public:
 	}
 
 	/// Create a texture
-	ANKI_USE_RESULT Error create(const Initializer& init);
+	void create(const Initializer& init);
 
 	GLenum getInternalFormat() const
 	{

include/anki/physics/PhysicsWorld.h

@@ -126,7 +126,7 @@ inline T* PhysicsWorld::newObjectInternal(TContainer& cont, TArgs&&... args)
 
 	if(!err)
 	{
-		err = cont.pushBack(m_alloc, ptr);
+		cont.pushBack(m_alloc, ptr);
 	}
 
 	if(err)

include/anki/renderer/Hdr.h

@@ -103,7 +103,7 @@ private:
 	ANKI_USE_RESULT Error initFb(FramebufferHandle& fb, TextureHandle& rt);
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 
-	ANKI_USE_RESULT Error updateDefaultBlock(CommandBufferHandle& jobs);
+	void updateDefaultBlock(CommandBufferHandle& jobs);
 };
 
 /// @}

include/anki/resource/Material.h

@@ -143,7 +143,7 @@ public:
 	~MaterialVariableTemplate()
 	{}
 
-	ANKI_USE_RESULT Error create(ResourceAllocator<U8> alloc, 
+	void create(ResourceAllocator<U8> alloc, 
 		const CString& name, const TData* x, U32 size);
 
 	void destroy(ResourceAllocator<U8> alloc)
@@ -175,10 +175,11 @@ public:
 		return m_data.getSize() > 0;
 	}
 
-	static MaterialVariableTemplate* _newInstance(
+	static ANKI_USE_RESULT Error _newInstance(
 		const MaterialProgramCreatorInputVariable& in,
 		ResourceAllocator<U8> alloc, 
-		TempResourceAllocator<U8> talloc);
+		TempResourceAllocator<U8> talloc,
+		MaterialVariable*& out);
 
 private:
 	DArray<TData> m_data;

include/anki/resource/ResourceManager.h

@@ -79,12 +79,12 @@ public:
 		}
 	}
 
-	ANKI_USE_RESULT Error _registerResource(ResourcePointerType& ptr)
+	void _registerResource(ResourcePointerType& ptr)
 	{
 		ANKI_ASSERT(ptr.getReferenceCount() == 1);
 		ANKI_ASSERT(find(ptr.getResourceName()) == m_ptrs.getEnd());
 	
-		return m_ptrs.pushBack(m_alloc, ptr);
+		m_ptrs.pushBack(m_alloc, ptr);
 	}
 
 	void _unregisterResource(ResourcePointerType& ptr)
@@ -173,7 +173,7 @@ public:
 		return m_textureAnisotropy;
 	}
 
-	ANKI_USE_RESULT Error fixResourceFilename(
+	void fixResourceFilename(
 		const CString& filename,
 		StringAuto& out) const;
 
@@ -207,9 +207,9 @@ public:
 	}
 
 	/// Set it with information from the renderer
-	ANKI_USE_RESULT Error _setShadersPrependedSource(const CString& cstr)
+	void _setShadersPrependedSource(const CString& cstr)
 	{
-		return m_shadersPrependedSource.create(m_alloc, cstr);
+		m_shadersPrependedSource.create(m_alloc, cstr);
 	}
 
 	const String& _getShadersPrependedSource() const
@@ -226,10 +226,9 @@ public:
 	}
 
 	template<typename T>
-	ANKI_USE_RESULT Error _registerResource(
-		ResourcePointer<T, ResourceManager>& ptr)
+	void _registerResource(ResourcePointer<T, ResourceManager>& ptr)
 	{
-		return TypeResourceManager<T, ResourceManager>::_registerResource(ptr);
+		TypeResourceManager<T, ResourceManager>::_registerResource(ptr);
 	}
 
 	template<typename T>

include/anki/resource/ResourcePointer.inl.h

@@ -48,14 +48,7 @@ Error ResourcePointer<T, TResourceManager>::load(
 		{
 			StringAuto newFname(resources->_getTempAllocator());
 
-			err = resources->fixResourceFilename(filename, newFname);
-			if(err)
-			{
-				ANKI_LOGE("OOM when loading resource: %s", &newFname[0]);
-				alloc.deleteInstance(m_cb);
-				m_cb = nullptr;
-				return err;
-			}
+			resources->fixResourceFilename(filename, newFname);
 
 			ResourceInitializer init(
 				alloc,
@@ -89,14 +82,7 @@ Error ResourcePointer<T, TResourceManager>::load(
 		}
 
 		// Register resource
-		err = resources->_registerResource(*this);
-		if(err)
-		{
-			ANKI_LOGE("OOM when registering resource");
-			alloc.deleteInstance(m_cb);
-			m_cb = nullptr;
-			return err;
-		}
+		resources->_registerResource(*this);
 	}
 	else
 	{

include/anki/scene/InstanceNode.h

@@ -40,19 +40,11 @@ public:
 
 	ANKI_USE_RESULT Error create(const CString& name)
 	{
-		Error err = SceneNode::create(name);
+		ANKI_CHECK(SceneNode::create(name));
+		addComponent(static_cast<MoveComponent*>(this));
+		addComponent(static_cast<InstanceComponent*>(this));
 
-		if(!err)
-		{
-			err = addComponent(static_cast<MoveComponent*>(this));
-		}
-
-		if(!err)
-		{
-			err = addComponent(static_cast<InstanceComponent*>(this));
-		}
-
-		return err;
+		return ErrorCode::NONE;
 	}
 };
 /// @}

include/anki/scene/ModelNode.h

@@ -43,7 +43,7 @@ private:
 	const ModelPatchBase* m_modelPatch; ///< The resource
 	DArray<ObbSpatialComponent*> m_spatials;
 
-	ANKI_USE_RESULT Error updateInstanceSpatials(
+	void updateInstanceSpatials(
 		const MoveComponent* instanceMoves[], 
 		U32 instanceMovesCount);
 

include/anki/scene/ParticleEmitter.h

@@ -195,8 +195,8 @@ private:
 
 	SimulationType m_simulationType = SimulationType::UNDEFINED;
 
-	ANKI_USE_RESULT Error createParticlesSimulation(SceneGraph* scene);
-	ANKI_USE_RESULT Error createParticlesSimpleSimulation();
+	void createParticlesSimulation(SceneGraph* scene);
+	void createParticlesSimpleSimulation();
 
 	ANKI_USE_RESULT Error doInstancingCalcs();
 

include/anki/scene/SceneNode.h

@@ -64,9 +64,9 @@ public:
 
 	SceneFrameAllocator<U8> getSceneFrameAllocator() const;
 
-	ANKI_USE_RESULT Error addChild(SceneNode* obj)
+	void addChild(SceneNode* obj)
 	{
-		return Base::addChild(getSceneAllocator(), obj);
+		Base::addChild(getSceneAllocator(), obj);
 	}
 
 	/// This is called by the scene every frame after logic and before
@@ -168,8 +168,7 @@ public:
 protected:
 	/// Append a component to the components container. The SceneNode will not
 	/// take ownership
-	ANKI_USE_RESULT Error addComponent(
-		SceneComponent* comp, Bool transferOwnership = false);
+	void addComponent(SceneComponent* comp, Bool transferOwnership = false);
 
 	/// Remove a component from the container
 	void removeComponent(SceneComponent* comp);

include/anki/scene/Sector.h

@@ -64,7 +64,7 @@ public:
 		F32 prevUpdateTime, F32 crntTime) override;
 
 	/// Add reference to sector.
-	ANKI_USE_RESULT Error tryAddSector(Sector* sector);
+	void tryAddSector(Sector* sector);
 
 	/// Remove reference from sector.
 	void tryRemoveSector(Sector* sector);
@@ -90,10 +90,10 @@ public:
 	ANKI_USE_RESULT Error create(
 		const CString& name, const CString& modelFname);
 
-	ANKI_USE_RESULT Error tryAddPortal(Portal* portal);
+	void tryAddPortal(Portal* portal);
 	void tryRemovePortal(Portal* portal);
 
-	ANKI_USE_RESULT Error tryAddSpatialComponent(SpatialComponent* sp);
+	void tryAddSpatialComponent(SpatialComponent* sp);
 	void tryRemoveSpatialComponent(SpatialComponent* sp);
 
 	ANKI_USE_RESULT Error frameUpdate(
@@ -125,11 +125,10 @@ public:
 	/// Destructor
 	~SectorGroup();
 
-	ANKI_USE_RESULT Error spatialUpdated(SpatialComponent* sp);
+	void spatialUpdated(SpatialComponent* sp);
 	void spatialDeleted(SpatialComponent* sp);
 
-	ANKI_USE_RESULT Error prepareForVisibilityTests(
-		const FrustumComponent& frc);
+	void prepareForVisibilityTests(const FrustumComponent& frc);
 
 	template<typename Func>
 	ANKI_USE_RESULT Error iterateVisibleSceneNodes(
@@ -143,13 +142,13 @@ private:
 	SceneNode** m_visibleNodes = nullptr;
 	U m_visibleNodesCount = 0;
 
-	ANKI_USE_RESULT Error findVisibleSectors(
+	void findVisibleSectors(
 		const FrustumComponent& frc,
 		List<Sector*>& visibleSectors,
 		U& spatialsCount);
 
 	/// Recursive method
-	ANKI_USE_RESULT Error findVisibleSectorsInternal(
+	void findVisibleSectorsInternal(
 		const FrustumComponent& frc,
 		Sector& s,
 		List<Sector*>& visibleSectors,

include/anki/scene/Visibility.h

@@ -81,7 +81,7 @@ public:
 		ANKI_ASSERT(0 && "It's supposed to be deallocated on frame start");
 	}
 
-	ANKI_USE_RESULT Error create(
+	void create(
 		SceneFrameAllocator<U8> alloc,
 		U32 renderablesReservedSize,
 		U32 lightsReservedSize,
@@ -143,22 +143,19 @@ public:
 		return m_flaresCount;
 	}
 
-	ANKI_USE_RESULT Error moveBackRenderable(
-		SceneFrameAllocator<U8> alloc, VisibleNode& x)
+	void moveBackRenderable(SceneFrameAllocator<U8> alloc, VisibleNode& x)
 	{
-		return moveBack(alloc, m_renderables, m_renderablesCount, x);
+		moveBack(alloc, m_renderables, m_renderablesCount, x);
 	}
 
-	ANKI_USE_RESULT Error moveBackLight(
-		SceneFrameAllocator<U8> alloc, VisibleNode& x)
+	void moveBackLight(SceneFrameAllocator<U8> alloc, VisibleNode& x)
 	{
-		return moveBack(alloc, m_lights, m_lightsCount, x);
+		moveBack(alloc, m_lights, m_lightsCount, x);
 	}
 
-	ANKI_USE_RESULT Error moveBackLensFlare(
-		SceneFrameAllocator<U8> alloc, VisibleNode& x)
+	void moveBackLensFlare(SceneFrameAllocator<U8> alloc, VisibleNode& x)
 	{
-		return moveBack(alloc, m_flares, m_flaresCount, x);
+		moveBack(alloc, m_flares, m_flaresCount, x);
 	}
 
 private:
@@ -169,7 +166,7 @@ private:
 	U32 m_lightsCount = 0;
 	U32 m_flaresCount = 0;
 
-	ANKI_USE_RESULT Error moveBack(SceneFrameAllocator<U8> alloc, 
+	void moveBack(SceneFrameAllocator<U8> alloc, 
 		Container& c, U32& count, VisibleNode& x);
 };
 

include/anki/util/Allocator.h

@@ -53,7 +53,7 @@ public:
 	/// are going to happen
 	using propagate_on_container_move_assignment = std::true_type;
 
-	/// A struct to rebind the allocator to another allocator of type U
+	/// A struct to rebind the allocator to another allocator of type Y
 	template<typename Y>
 	struct rebind
 	{
@@ -96,19 +96,12 @@ public:
 			allocCb(allocCbUserData, nullptr, sizeof(TPool), alignof(TPool)));
 		if(!m_pool)
 		{
-			ANKI_LOGF("Initialization failed");
+			ANKI_LOGF("Out of memory");
 		}
 
 		new (m_pool) TPool();
 
-		Error error = m_pool->create(
-			allocCb, allocCbUserData, std::forward<TArgs>(args)...);
-
-		if(error)
-		{
-			ANKI_LOGF("Initialization failed");
-		}
-
+		m_pool->create(allocCb, allocCbUserData, std::forward<TArgs>(args)...);
 		m_pool->getRefcount().store(1);
 	}
 
@@ -133,8 +126,8 @@ public:
 	}
 
 	/// Copy
-	template<typename U>
-	GenericPoolAllocator& operator=(const GenericPoolAllocator<U, TPool>& b)
+	template<typename Y>
+	GenericPoolAllocator& operator=(const GenericPoolAllocator<Y, TPool>& b)
 	{
 		copy(b);
 		return *this;
@@ -169,12 +162,6 @@ public:
 			: alignof(value_type);
 
 		void* out = m_pool->allocate(size, alignment);
-
-		if(out == nullptr)
-		{
-			ANKI_LOGE("Allocation failed. There is not enough room");
-		}
-
 		return reinterpret_cast<pointer>(out);
 	}
 
@@ -193,11 +180,11 @@ public:
 	}
 
 	/// Call constructor with many arguments
-	template<typename U, typename... Args>
-	void construct(U* p, Args&&... args)
+	template<typename Y, typename... Args>
+	void construct(Y* p, Args&&... args)
 	{
 		// Placement new
-		::new((void *)p) U(std::forward<Args>(args)...);
+		::new((void *)p) Y(std::forward<Args>(args)...);
 	}
 
 	/// Call destructor
@@ -208,11 +195,11 @@ public:
 	}
 
 	/// Call destructor
-	template<typename U>
-	void destroy(U* p)
+	template<typename Y>
+	void destroy(Y* p)
 	{
 		ANKI_ASSERT(p != nullptr);
-		p->~U();
+		p->~Y();
 	}
 
 	/// Get the max allocation size
@@ -239,12 +226,12 @@ public:
 
 	/// Allocate a new object and call it's constructor
 	/// @note This is AnKi specific
-	template<typename U, typename... Args>
-	U* newInstance(Args&&... args)
+	template<typename Y, typename... Args>
+	Y* newInstance(Args&&... args)
 	{
-		typename rebind<U>::other alloc(*this);
+		typename rebind<Y>::other alloc(*this);
 
-		U* ptr = alloc.allocate(1);
+		Y* ptr = alloc.allocate(1);
 		if(ptr)
 		{
 			alloc.construct(ptr, std::forward<Args>(args)...);
@@ -255,16 +242,16 @@ public:
 
 	/// Allocate a new array of objects and call their constructor
 	/// @note This is AnKi specific
-	template<typename U>
-	U* newArray(size_type n)
+	template<typename Y>
+	Y* newArray(size_type n)
 	{
-		typename rebind<U>::other alloc(*this);
+		typename rebind<Y>::other alloc(*this);
 
-		U* ptr = alloc.allocate(n);
+		Y* ptr = alloc.allocate(n);
 		if(ptr)
 		{
 			// Call the constuctors
-			for(size_type i = 0; i < n; i++)
+			for(auto i = 0; i < n; i++)
 			{
 				alloc.construct(&ptr[i]);
 			}
@@ -275,16 +262,16 @@ public:
 
 	/// Allocate a new array of objects and call their constructor
 	/// @note This is AnKi specific
-	template<typename U>
-	U* newArray(size_type n, const U& v)
+	template<typename Y>
+	Y* newArray(size_type n, const Y& v)
 	{
-		typename rebind<U>::other alloc(*this);
+		typename rebind<Y>::other alloc(*this);
 
-		U* ptr = alloc.allocate(n);
+		Y* ptr = alloc.allocate(n);
 		if(ptr)
 		{
 			// Call the constuctors
-			for(size_type i = 0; i < n; i++)
+			for(auto i = 0; i < n; i++)
 			{
 				alloc.construct(&ptr[i], v);
 			}
@@ -295,10 +282,10 @@ public:
 
 	/// Call the destructor and deallocate an object
 	/// @note This is AnKi specific
-	template<typename U>
-	void deleteInstance(U* ptr)
+	template<typename Y>
+	void deleteInstance(Y* ptr)
 	{
-		typename rebind<U>::other alloc(*this);
+		typename rebind<Y>::other alloc(*this);
 
 		if(ptr != nullptr)
 		{
@@ -309,10 +296,10 @@ public:
 
 	/// Call the destructor and deallocate an array of objects
 	/// @note This is AnKi specific
-	template<typename U>
-	void deleteArray(U* ptr, size_type n)
+	template<typename Y>
+	void deleteArray(Y* ptr, size_type n)
 	{
-		typename rebind<U>::other alloc(*this);
+		typename rebind<Y>::other alloc(*this);
 
 		if(ptr != nullptr)
 		{

include/anki/util/DArray.h

@@ -165,73 +165,47 @@ public:
 
 	/// Create the array.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error create(TAllocator alloc, PtrSize size)
+	void create(TAllocator alloc, PtrSize size)
 	{
 		ANKI_ASSERT(m_data == nullptr && m_size == 0);
-		Error err = ErrorCode::NONE;
-
 		destroy(alloc);
 
 		if(size > 0)
 		{
 			m_data = alloc.template newArray<Value>(size);
-			if(m_data)
-			{
-				m_size = size;
-			}
-			else
-			{
-				err = ErrorCode::OUT_OF_MEMORY;
-			}
+			m_size = size;
 		}
-
-		return err;
 	}
 
 	/// Create the array.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error create(TAllocator alloc, PtrSize size, const Value& v)
+	void create(TAllocator alloc, PtrSize size, const Value& v)
 	{
 		ANKI_ASSERT(m_data == nullptr && m_size == 0);
-		Error err = ErrorCode::NONE;
 
 		if(size > 0)
 		{
 			m_data = alloc.template newArray<Value>(size, v);
-			if(m_data)
-			{
-				m_size = size;
-			}
-			else
-			{
-				err = ErrorCode::OUT_OF_MEMORY;
-			}
+			m_size = size;
 		}
-
-		return err;
 	}
 
 	/// Grow the array.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error resize(TAllocator alloc, PtrSize size)
+	void resize(TAllocator alloc, PtrSize size)
 	{
 		ANKI_ASSERT(size > 0);
 		DArray newArr;
-		Error err = newArr.create(alloc, size);
+		newArr.create(alloc, size);
 
-		if(!err)
+		PtrSize minSize = min<PtrSize>(size, m_size);
+		for(U i = 0; i < minSize; i++)
 		{
-			PtrSize minSize = min<PtrSize>(size, m_size);
-			for(U i = 0; i < minSize; i++)
-			{
-				newArr[i] = std::move((*this)[i]);
-			}
-
-			destroy(alloc);
-			move(newArr);
+			newArr[i] = std::move((*this)[i]);
 		}
 
-		return err;
+		destroy(alloc);
+		move(newArr);
 	}
 
 	/// Destroy the array.
@@ -301,21 +275,21 @@ public:
 	}
 
 	/// Create the array.
-	ANKI_USE_RESULT Error create(PtrSize size)
+	void create(PtrSize size)
 	{
-		return Base::create(m_alloc, size);
+		Base::create(m_alloc, size);
 	}
 
 	/// Create the array.
-	ANKI_USE_RESULT Error create(PtrSize size, const Value& v)
+	void create(PtrSize size, const Value& v)
 	{
-		return Base::create(m_alloc, size, v);
+		Base::create(m_alloc, size, v);
 	}
 
 	/// Grow the array.
-	ANKI_USE_RESULT Error resize(PtrSize size)
+	void resize(PtrSize size)
 	{
-		return Base::resize(m_alloc, size);
+		Base::resize(m_alloc, size);
 	}
 
 private:

include/anki/util/Filesystem.h

@@ -17,7 +17,7 @@ namespace anki {
 Bool fileExists(const CString& filename);
 
 /// Get file extension.
-ANKI_USE_RESULT Error getFileExtension(
+void getFileExtension(
 	const CString& filename, GenericMemoryPoolAllocator<U8> alloc, String& out);
 
 /// Return true if directory exists?

include/anki/util/Hierarchy.h

@@ -62,7 +62,7 @@ public:
 
 	/// Add a new child.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error addChild(TAllocator alloc, Value* child);
+	void addChild(TAllocator alloc, Value* child);
 
 	/// Remove a child.
 	template<typename TAllocator>

include/anki/util/Hierarchy.inl.h

@@ -31,7 +31,7 @@ void Hierarchy<T>::destroy(TAllocator alloc)
 //==============================================================================
 template<typename T>
 template<typename TAllocator>
-Error Hierarchy<T>::addChild(TAllocator alloc, Value* child)
+void Hierarchy<T>::addChild(TAllocator alloc, Value* child)
 {
 	ANKI_ASSERT(child != nullptr && "Null arg");
 	ANKI_ASSERT(child != getSelf() && "Cannot put itself");
@@ -42,9 +42,7 @@ Error Hierarchy<T>::addChild(TAllocator alloc, Value* child)
 		&& "Already has that child");
 
 	child->m_parent = getSelf();
-	Error err = m_children.emplaceBack(alloc, child);
-
-	return err;
+	m_children.emplaceBack(alloc, child);
 }
 
 //==============================================================================

include/anki/util/List.h

@@ -294,20 +294,28 @@ public:
 
 	/// Copy an element at the end of the list.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error pushBack(TAllocator alloc, const Value& x);
+	void pushBack(TAllocator alloc, const Value& x)
+	{
+		Node* node = alloc.template newInstance<Node>(x);
+		pushBackNode(node);
+	}
 
 	/// Construct an element at the end of the list.
 	template<typename TAllocator, typename... TArgs>
-	ANKI_USE_RESULT Error emplaceBack(TAllocator alloc, TArgs&&... args);
+	void emplaceBack(TAllocator alloc, TArgs&&... args)
+	{
+		Node* node = alloc.template newInstance<Node>(
+			std::forward<TArgs>(args)...);
+		pushBackNode(node);
+	}
 
 	/// Construct element at the beginning of the list.
 	template<typename TAllocator, typename... TArgs>
-	ANKI_USE_RESULT Error emplaceFront(TAllocator alloc, TArgs&&... args);
+	void emplaceFront(TAllocator alloc, TArgs&&... args);
 
 	/// Construct element at the the given position.
 	template<typename TAllocator, typename... TArgs>
-	ANKI_USE_RESULT Error emplace(
-		TAllocator alloc, Iterator pos, TArgs&&... args);
+	void emplace(TAllocator alloc, Iterator pos, TArgs&&... args);
 
 	/// Pop a value from the back of the list.
 	template<typename TAllocator>

include/anki/util/List.inl.h

@@ -77,126 +77,65 @@ void List<T>::pushBackNode(Node* node)
 	}
 }
 
-//==============================================================================
-template<typename T>
-template<typename TAllocator>
-Error List<T>::pushBack(TAllocator alloc, const Value& x)
-{
-	Error err = ErrorCode::NONE;
-	
-	Node* node = alloc.template newInstance<Node>(x);
-	if(node != nullptr)
-	{
-		pushBackNode(node);
-	}
-	else
-	{
-		err = ErrorCode::OUT_OF_MEMORY;
-	}
-
-	return err;
-}
-
 //==============================================================================
 template<typename T>
 template<typename TAllocator, typename... TArgs>
-Error List<T>::emplaceBack(TAllocator alloc, TArgs&&... args)
+void List<T>::emplaceFront(TAllocator alloc, TArgs&&... args)
 {
-	Error err = ErrorCode::NONE;
-	
-	Node* node = alloc.template newInstance<Node>(std::forward<TArgs>(args)...);
-	if(node != nullptr)
+	Node* el = alloc.template newInstance<Node>(std::forward<TArgs>(args)...);
+	if(m_head != nullptr)
 	{
-		pushBackNode(node);
+		ANKI_ASSERT(m_tail != nullptr);
+		m_head->m_prev = el;
+		el->m_next = m_head;
+		m_head = el;
 	}
 	else
 	{
-		err = ErrorCode::OUT_OF_MEMORY;
+		ANKI_ASSERT(m_tail == nullptr);
+		m_tail = m_head = el;
 	}
-
-	return err;
 }
 
 //==============================================================================
 template<typename T>
 template<typename TAllocator, typename... TArgs>
-Error List<T>::emplaceFront(TAllocator alloc, TArgs&&... args)
+void List<T>::emplace(TAllocator alloc, Iterator pos, TArgs&&... args)
 {
-	Error err = ErrorCode::NONE;
+	ANKI_ASSERT(pos.m_list == this);
 
 	Node* el = alloc.template newInstance<Node>(std::forward<TArgs>(args)...);
-	if(el != nullptr)
+	Node* node = pos.m_node;
+
+	if(node == nullptr)
 	{
-		if(m_head != nullptr)
+		// Place after the last
+
+		if(m_tail != nullptr)
 		{
-			ANKI_ASSERT(m_tail != nullptr);
-			m_head->m_prev = el;
-			el->m_next = m_head;
-			m_head = el;
+			ANKI_ASSERT(m_head != nullptr);
+			m_tail->m_next = el;
+			el->m_prev = m_tail;
+			m_tail = el;
 		}
 		else
 		{
-			ANKI_ASSERT(m_tail == nullptr);
+			ANKI_ASSERT(m_head == nullptr);
 			m_tail = m_head = el;
 		}
 	}
 	else
 	{
-		err = ErrorCode::OUT_OF_MEMORY;
-	}
-
-	return err;
-}
-
-//==============================================================================
-template<typename T>
-template<typename TAllocator, typename... TArgs>
-Error List<T>::emplace(TAllocator alloc, Iterator pos, TArgs&&... args)
-{
-	ANKI_ASSERT(pos.m_list == this);
-	Error err = ErrorCode::NONE;
-
-	Node* el = alloc.template newInstance<Node>(std::forward<TArgs>(args)...);
-	if(el != nullptr)
-	{
-		Node* node = pos.m_node;
+		el->m_prev = node->m_prev;
+		el->m_next = node;
+		node->m_prev = el;
 
-		if(node == nullptr)
-		{
-			// Place after the last
-
-			if(m_tail != nullptr)
-			{
-				ANKI_ASSERT(m_head != nullptr);
-				m_tail->m_next = el;
-				el->m_prev = m_tail;
-				m_tail = el;
-			}
-			else
-			{
-				ANKI_ASSERT(m_head == nullptr);
-				m_tail = m_head = el;
-			}
-		}
-		else
+		if(node == m_head)
 		{
-			el->m_prev = node->m_prev;
-			el->m_next = node;
-			node->m_prev = el;
-
-			if(node == m_head)
-			{
-				ANKI_ASSERT(m_tail != nullptr);
-				m_head = el;
-			}
+			ANKI_ASSERT(m_tail != nullptr);
+			m_head = el;
 		}
 	}
-	else
-	{
-		err = ErrorCode::OUT_OF_MEMORY;
-	}
-
-	return err;
 }
 
 //==============================================================================

include/anki/util/Memory.h

@@ -145,7 +145,7 @@ public:
 	/// The real constructor.
 	/// @param allocCb The allocation function callback
 	/// @param allocCbUserData The user data to pass to the allocation function
-	Error create(AllocAlignedCallback allocCb, void* allocCbUserData);
+	void create(AllocAlignedCallback allocCb, void* allocCbUserData);
 
 	/// Allocate memory
 	void* allocate(PtrSize size, PtrSize alignment);
@@ -186,7 +186,7 @@ public:
 	///        errors
 	/// @param alignmentBytes The maximum supported alignment for returned
 	///        memory
-	Error create(
+	void create(
 		AllocAlignedCallback allocCb, 
 		void* allocCbUserData,
 		PtrSize size, 
@@ -290,7 +290,7 @@ public:
 	///                       the ammount of chunk size increase 
 	/// @param alignmentBytes The maximum supported alignment for returned
 	///                       memory
-	Error create(
+	void create(
 		AllocAlignedCallback allocCb, 
 		void* allocCbUserData,
 		PtrSize initialChunkSize,

include/anki/util/String.h

@@ -306,22 +306,22 @@ public:
 
 	/// Initialize using a const string.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error create(TAllocator alloc, const CStringType& cstr);
+	void create(TAllocator alloc, const CStringType& cstr);
 
 	/// Initialize using a range. Copies the range of [first, last)
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error create(TAllocator alloc,
+	void create(TAllocator alloc,
 		ConstIterator first, ConstIterator last);
 
 	/// Initialize using a character.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error create(TAllocator alloc, Char c, PtrSize length);
+	void create(TAllocator alloc, Char c, PtrSize length);
 
 	/// Copy one string to this one.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error create(TAllocator alloc, const String& b)
+	void create(TAllocator alloc, const String& b)
 	{
-		return create(alloc, b.toCString());
+		create(alloc, b.toCString());
 	}
 
 	/// Destroy the string.
@@ -481,33 +481,27 @@ public:
 
 	/// Append another string to this one.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error append(TAllocator alloc, const String& b)
+	void append(TAllocator alloc, const String& b)
 	{
-		Error err = ErrorCode::NONE;
 		if(!b.isEmpty())
 		{
-			err = appendInternal(alloc, &b.m_data[0], b.m_data.getSize());
+			appendInternal(alloc, &b.m_data[0], b.m_data.getSize());
 		}
-
-		return err;
 	}
 
 	/// Append a const string to this one.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error append(TAllocator alloc, const CStringType& cstr)
+	void append(TAllocator alloc, const CStringType& cstr)
 	{
-		Error err = ErrorCode::NONE;
 		if(!cstr.isEmpty())
 		{
-			err = appendInternal(alloc, &cstr[0], cstr.getLength() + 1);
+			appendInternal(alloc, &cstr[0], cstr.getLength() + 1);
 		}
-
-		return err;
 	}
 
 	/// Create formated string.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error sprintf(TAllocator alloc, CString fmt, ...);
+	void sprintf(TAllocator alloc, CString fmt, ...);
 
 	/// Return true if it's empty.
 	Bool isEmpty() const 
@@ -539,7 +533,7 @@ public:
 
 	/// Convert a number to a string.
 	template<typename TAllocator, typename TNumber>
-	ANKI_USE_RESULT Error toString(TAllocator alloc, TNumber number);
+	void toString(TAllocator alloc, TNumber number);
 
 	/// Convert to F64.
 	ANKI_USE_RESULT Error toF64(F64& out) const
@@ -563,8 +557,7 @@ protected:
 
 	/// Append to this string.
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error appendInternal(
-		TAllocator alloc, const Char* str, PtrSize strSize);
+	void appendInternal(TAllocator alloc, const Char* str, PtrSize strSize);
 
 	void move(String& b)
 	{
@@ -600,27 +593,27 @@ public:
 	}
 
 	/// Initialize using a const string.
-	ANKI_USE_RESULT Error create(const CStringType& cstr)
+	void create(const CStringType& cstr)
 	{
-		return Base::create(m_alloc, cstr);
+		Base::create(m_alloc, cstr);
 	}
 
 	/// Initialize using a range. Copies the range of [first, last)
-	ANKI_USE_RESULT Error create(ConstIterator first, ConstIterator last)
+	void create(ConstIterator first, ConstIterator last)
 	{
-		return Base::create(m_alloc, first, last);
+		Base::create(m_alloc, first, last);
 	}
 
 	/// Initialize using a character.
-	ANKI_USE_RESULT Error create(Char c, PtrSize length)
+	void create(Char c, PtrSize length)
 	{
-		return Base::create(m_alloc, c, length);
+		Base::create(m_alloc, c, length);
 	}
 
 	/// Copy one string to this one.
-	ANKI_USE_RESULT Error create(const String& b)
+	void create(const String& b)
 	{
-		return Base::create(m_alloc, b.toCString());
+		Base::create(m_alloc, b.toCString());
 	}
 
 	/// Move one string to this one.
@@ -631,29 +624,29 @@ public:
 	}
 
 	/// Append another string to this one.
-	ANKI_USE_RESULT Error append(const String& b)
+	void append(const String& b)
 	{
-		return Base::append(m_alloc, b);
+		Base::append(m_alloc, b);
 	}
 
 	/// Append a const string to this one.
-	ANKI_USE_RESULT Error append(const CStringType& cstr)
+	void append(const CStringType& cstr)
 	{
-		return Base::append(m_alloc, cstr);
+		Base::append(m_alloc, cstr);
 	}
 
 	/// Create formated string.
 	template<typename... TArgs>
-	ANKI_USE_RESULT Error sprintf(CString fmt, TArgs... args)
+	void sprintf(CString fmt, TArgs... args)
 	{
-		return Base::sprintf(m_alloc, fmt, args...);
+		Base::sprintf(m_alloc, fmt, args...);
 	}
 
 	/// Convert a number to a string.
 	template<typename TNumber>
-	ANKI_USE_RESULT Error toString(TNumber number)
+	void toString(TNumber number)
 	{
-		return Base::toString(m_alloc, number);
+		Base::toString(m_alloc, number);
 	}
 
 private:

include/anki/util/String.inl.h

@@ -7,62 +7,44 @@ namespace anki {
 
 //==============================================================================
 template<typename TAllocator>
-inline Error String::create(TAllocator alloc, const CStringType& cstr)
+inline void String::create(TAllocator alloc, const CStringType& cstr)
 {
-	Error err = ErrorCode::NONE;
-	
 	auto len = cstr.getLength();
 	if(len > 0)
 	{
 		auto size = len + 1;
-		err = m_data.create(alloc, size);
-
-		if(!err)
-		{
-			std::memcpy(&m_data[0], &cstr[0], sizeof(Char) * size);
-		}
+		m_data.create(alloc, size);
+		std::memcpy(&m_data[0], &cstr[0], sizeof(Char) * size);
 	}
-
-	return err;
 }
 
 //==============================================================================
 template<typename TAllocator>
-inline Error String::create(
+inline void String::create(
 	TAllocator alloc, ConstIterator first, ConstIterator last)
 {
 	ANKI_ASSERT(first != 0 && last != 0);
 	auto length = last - first;
-	Error err = m_data.create(alloc, length + 1);
+	m_data.create(alloc, length + 1);
 
-	if(!err)
-	{
-		std::memcpy(&m_data[0], first, length);
-		m_data[length] = '\0';
-	}
-
-	return err;
+	std::memcpy(&m_data[0], first, length);
+	m_data[length] = '\0';
 }
 
 //==============================================================================
 template<typename TAllocator>
-inline Error String::create(TAllocator alloc, Char c, PtrSize length)
+inline void String::create(TAllocator alloc, Char c, PtrSize length)
 {
 	ANKI_ASSERT(c != '\0');
-	Error err = m_data.create(alloc, length + 1);
-
-	if(!err)
-	{
-		std::memset(&m_data[0], c, length);
-		m_data[length] = '\0';
-	}
+	m_data.create(alloc, length + 1);
 
-	return err;
+	std::memset(&m_data[0], c, length);
+	m_data[length] = '\0';
 }
 
 //==============================================================================
 template<typename TAllocator>
-inline Error String::appendInternal(
+inline void String::appendInternal(
 	TAllocator alloc, const Char* str, PtrSize strSize)
 {
 	ANKI_ASSERT(str != nullptr);
@@ -77,29 +59,23 @@ inline Error String::appendInternal(
 	}
 
 	DArray<Char> newData;	
-	Error err = newData.create(alloc, size + strSize - 1);
+	newData.create(alloc, size + strSize - 1);
 
-	if(!err)
+	if(!m_data.isEmpty())
 	{
-		if(!m_data.isEmpty())
-		{
-			std::memcpy(&newData[0], &m_data[0], sizeof(Char) * size);
-		}
-
-		std::memcpy(&newData[size - 1], str, sizeof(Char) * strSize);
-
-		m_data.destroy(alloc);
-		m_data = std::move(newData);
+		std::memcpy(&newData[0], &m_data[0], sizeof(Char) * size);
 	}
 
-	return err;
+	std::memcpy(&newData[size - 1], str, sizeof(Char) * strSize);
+
+	m_data.destroy(alloc);
+	m_data = std::move(newData);
 }
 
 //==============================================================================
 template<typename TAllocator>
-inline Error String::sprintf(TAllocator alloc, CString fmt, ...)
+inline void String::sprintf(TAllocator alloc, CString fmt, ...)
 {
-	Error err = ErrorCode::NONE;
 	Array<Char, 512> buffer;
 	va_list args;
 
@@ -109,39 +85,31 @@ inline Error String::sprintf(TAllocator alloc, CString fmt, ...)
 
 	if(len < 0)
 	{
-		ANKI_LOGE("vsnprintf() failed");
-		err = ErrorCode::FUNCTION_FAILED;
+		ANKI_LOGF("vsnprintf() failed");
 	}
 	else if(static_cast<PtrSize>(len) >= sizeof(buffer))
 	{
 		I size = len + 1;
-		err = m_data.create(alloc, size);
+		m_data.create(alloc, size);
 
-		if(!err)
-		{
-			va_start(args, fmt);
-			len = std::vsnprintf(&m_data[0], size, &fmt[0], args);
-			va_end(args);
+		va_start(args, fmt);
+		len = std::vsnprintf(&m_data[0], size, &fmt[0], args);
+		va_end(args);
 
-			(void)len;
-			ANKI_ASSERT((len + 1) == size);
-		}
+		(void)len;
+		ANKI_ASSERT((len + 1) == size);
 	}
 	else
 	{
 		// buffer was enough
-		err = create(alloc, CString(&buffer[0]));
+		create(alloc, CString(&buffer[0]));
 	}
-
-	return err;
 }
 
 //==============================================================================
 template<typename TAllocator, typename TNumber>
-inline Error String::toString(TAllocator alloc, TNumber number)
+inline void String::toString(TAllocator alloc, TNumber number)
 {
-	Error err = ErrorCode::NONE;
-
 	destroy(alloc);
 
 	Array<Char, 512> buff;
@@ -150,15 +118,12 @@ inline Error String::toString(TAllocator alloc, TNumber number)
 
 	if(ret < 0 || ret > static_cast<I>(buff.getSize()))
 	{
-		ANKI_LOGE("To small intermediate buffer");
-		err = ErrorCode::FUNCTION_FAILED;
+		ANKI_LOGF("To small intermediate buffer");
 	}
 	else
 	{
-		err = create(alloc, &buff[0]);
+		create(alloc, &buff[0]);
 	}
-
-	return err;
 }
 
 } // end namespace anki

include/anki/util/StringList.h

@@ -38,8 +38,7 @@ public:
 	/// Join all the elements into a single big string using a the
 	/// seperator @a separator
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error join(
-		TAllocator alloc, const CString& separator, String& out) const;
+	void join(TAllocator alloc, const CString& separator, String& out) const;
 
 	/// Returns the index position of the last occurrence of @a value in
 	/// the list
@@ -51,14 +50,12 @@ public:
 
 	/// Push at the end of the list a formated string
 	template<typename TAllocator, typename... TArgs>
-	ANKI_USE_RESULT Error pushBackSprintf(
-		TAllocator alloc, const TArgs&... args);
+	void pushBackSprintf(TAllocator alloc, const TArgs&... args);
 
 	/// Split a string using a separator (@a separator) and return these
 	/// strings in a string list
 	template<typename TAllocator>
-	ANKI_USE_RESULT Error splitString(
-		TAllocator alloc, const CString& s, const Char separator);
+	void splitString(TAllocator alloc, const CString& s, const Char separator);
 };
 
 /// String list with automatic destruction.
@@ -95,17 +92,16 @@ public:
 
 	/// Push at the end of the list a formated string
 	template<typename... TArgs>
-	ANKI_USE_RESULT Error pushBackSprintf(const TArgs&... args)
+	void pushBackSprintf(const TArgs&... args)
 	{
-		return Base::pushBackSprintf(m_alloc, args...);
+		Base::pushBackSprintf(m_alloc, args...);
 	}
 
 	/// Split a string using a separator (@a separator) and return these
 	/// strings in a string list
-	ANKI_USE_RESULT Error splitString(
-		const CString& s, const Base::Char separator)
+	void splitString(const CString& s, const Base::Char separator)
 	{
-		return Base::splitString(m_alloc, s, separator);
+		Base::splitString(m_alloc, s, separator);
 	}
 
 private:

include/anki/util/StringList.inl.h

@@ -24,14 +24,14 @@ inline void StringList::destroy(TAllocator alloc)
 
 //==============================================================================
 template<typename TAllocator>
-inline Error StringList::join(
+inline void StringList::join(
 	TAllocator alloc,
 	const CString& separator,
 	String& out) const
 {
 	if(Base::isEmpty())
 	{
-		return ErrorCode::NONE;
+		return;
 	}
 
 	// Count the characters
@@ -46,11 +46,7 @@ inline Error StringList::join(
 	ANKI_ASSERT(charCount > 0);
 
 	// Allocate
-	Error err = out.create(alloc, '?', charCount);
-	if(err)
-	{
-		return err;
-	}
+	out.create(alloc, '?', charCount);
 
 	// Append to output
 	Char* to = &out[0];
@@ -67,41 +63,31 @@ inline Error StringList::join(
 			to += sepLen;
 		}
 	}
-
-	return err;
 }
 
 //==============================================================================
 template<typename TAllocator>
-inline Error StringList::splitString(
+inline void StringList::splitString(
 	TAllocator alloc,
 	const CString& s, 
 	const Char separator)
 {
 	ANKI_ASSERT(Base::isEmpty());
 
-	Error err = ErrorCode::NONE;
 	const Char* begin = &s[0];
 	const Char* end = begin;
 
-	while(!err)
+	while(1)
 	{
 		if(*end == '\0')
 		{
 			if(begin < end)
 			{
-				err = Base::emplaceBack(alloc);
+				Base::emplaceBack(alloc);
 
 				String str;
-				if(!err)
-				{
-					err = str.create(alloc, begin, end);
-				}
-
-				if(!err)
-				{
-					Base::getBack() = std::move(str);
-				}
+				str.create(alloc, begin, end);
+				Base::getBack() = std::move(str);
 			}
 
 			break;
@@ -110,19 +96,13 @@ inline Error StringList::splitString(
 		{
 			if(begin < end)
 			{
-				err = Base::emplaceBack(alloc);
+				Base::emplaceBack(alloc);
 
 				String str;
-				if(!err)
-				{
-					err = str.create(alloc, begin, end);
-				}
-
-				if(!err)
-				{
-					Base::getBack() = std::move(str);
-					begin = end + 1;
-				}
+				str.create(alloc, begin, end);
+
+				Base::getBack() = std::move(str);
+				begin = end + 1;
 			}
 			else
 			{
@@ -132,29 +112,18 @@ inline Error StringList::splitString(
 
 		++end;
 	}
-
-	return err;
 }
 
 //==============================================================================
 template<typename TAllocator, typename... TArgs>
-inline Error StringList::pushBackSprintf(
+inline void StringList::pushBackSprintf(
 	TAllocator alloc, const TArgs&... args)
 {
 	String str;
-	Error err = str.sprintf(alloc, args...);
+	str.sprintf(alloc, args...);
 	
-	if(!err)
-	{
-		err = Base::emplaceBack(alloc);
-	}
-
-	if(!err)
-	{
-		Base::getBack() = std::move(str);
-	}
-
-	return err;
+	Base::emplaceBack(alloc);
+	Base::getBack() = std::move(str);
 }
 
 } // end namespace anki

src/core/App.cpp

@@ -255,8 +255,8 @@ Error App::createInternal(const ConfigSet& config_,
 		config,
 		&m_globalTimestamp));
 
-	ANKI_CHECK(m_resources->_setShadersPrependedSource(
-		m_renderer->_getShadersPrependedSource().toCString()));
+	m_resources->_setShadersPrependedSource(
+		m_renderer->_getShadersPrependedSource().toCString());
 
 	// Scene
 	m_scene = m_heapAlloc.newInstance<SceneGraph>();
@@ -298,7 +298,7 @@ Error App::initDirs()
 	StringAuto home(m_heapAlloc);
 	ANKI_CHECK(getHomeDirectory(m_heapAlloc, home));
 
-	ANKI_CHECK(m_settingsDir.sprintf(m_heapAlloc, "%s/.anki", &home[0]));
+	m_settingsDir.sprintf(m_heapAlloc, "%s/.anki", &home[0]);
 
 	if(!directoryExists(m_settingsDir.toCString()))
 	{
@@ -306,7 +306,7 @@ Error App::initDirs()
 	}
 
 	// Cache
-	ANKI_CHECK(m_cacheDir.sprintf(m_heapAlloc, "%s/cache", &m_settingsDir[0]));
+	m_cacheDir.sprintf(m_heapAlloc, "%s/cache", &m_settingsDir[0]);
 
 	if(directoryExists(m_cacheDir.toCString()))
 	{

src/core/StdinListener.cpp

@@ -41,28 +41,22 @@ Error StdinListener::create(HeapAllocator<String>& alloc)
 //==============================================================================
 Error StdinListener::workingFunc(Thread::Info& info)
 {
-	Error err = ErrorCode::NONE;
 	StdinListener& self = *reinterpret_cast<StdinListener*>(info.m_userData);
 	Array<char, 512> buff;
 
-	while(!self.m_quit && !err)
+	while(!self.m_quit)
 	{
 		I m = read(0, &buff[0], sizeof(buff));
 		buff[m] = '\0';
 
-		self.m_mtx.lock();
+		LockGuard<Mutex>(self.m_mtx);
 		auto alloc = self.m_alloc;
-		err = self.m_q.emplaceBack(self.m_alloc);
+		self.m_q.emplaceBack(self.m_alloc);
 
-		if(!err)
-		{
-			err = self.m_q.getBack().create(alloc, &buff[0]);
-		}
-
-		self.m_mtx.unlock();
+		self.m_q.getBack().create(alloc, &buff[0]);
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/event/EventManager.cpp

@@ -37,10 +37,10 @@ SceneFrameAllocator<U8> EventManager::getSceneFrameAllocator() const
 }
 
 //==============================================================================
-Error EventManager::registerEvent(Event* event)
+void EventManager::registerEvent(Event* event)
 {
 	ANKI_ASSERT(event);
-	return m_events.pushBack(getSceneAllocator(), event);
+	m_events.pushBack(getSceneAllocator(), event);
 }
 
 //==============================================================================

src/gr/gl/BufferHandle.cpp

@@ -39,12 +39,10 @@ public:
 
 	Error operator()(CommandBufferImpl* cmdb)
 	{
-		Error err = ErrorCode::NONE;
+		m_buff.get().create(m_target, m_data, m_size, m_flags);
 
-		err = m_buff.get().create(m_target, m_data, m_size, m_flags);
-
-		GlObject::State oldState = m_buff.get().setStateAtomically(
-			(err) ? GlObject::State::ERROR : GlObject::State::CREATED);
+		GlObject::State oldState = 
+			m_buff.get().setStateAtomically(GlObject::State::CREATED);
 
 		(void)oldState;
 		ANKI_ASSERT(oldState == GlObject::State::TO_BE_CREATED);
@@ -55,7 +53,7 @@ public:
 				const_cast<void*>(m_data), 1);
 		}
 
-		return err;
+		return ErrorCode::NONE;
 	}
 };
 
@@ -213,28 +211,25 @@ Error BufferHandle::create(CommandBufferHandle& commands,
 
 	using Deleter = DeferredDeleter<BufferImpl, DeleteCommand>;
 
-	Error err = Base::create(commands.get().getManager(), Deleter());
-	if(!err)
-	{
-		get().setStateAtomically(GlObject::State::TO_BE_CREATED);
-
-		// Allocate temp memory for the data
-		Bool cleanup = false;
-		if(data)
-		{
-			void* newData = 
-				commands.get().getInternalAllocator().allocate(size);
-			memcpy(newData, data, size);
-			data = newData;
-			cleanup = true;
-		}
+	Base::create(commands.get().getManager(), Deleter());
+	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 
-		// Fire the command
-		commands.get().pushBackNewCommand<BufferCreateCommand>(
-			*this, target, data, size, flags, cleanup);
+	// Allocate temp memory for the data
+	Bool cleanup = false;
+	if(data)
+	{
+		void* newData = 
+			commands.get().getInternalAllocator().allocate(size);
+		memcpy(newData, data, size);
+		data = newData;
+		cleanup = true;
 	}
 
-	return err;
+	// Fire the command
+	commands.get().pushBackNewCommand<BufferCreateCommand>(
+		*this, target, data, size, flags, cleanup);
+
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/BufferImpl.cpp

@@ -22,7 +22,7 @@ void BufferImpl::destroy()
 }
 
 //==============================================================================
-Error BufferImpl::create(GLenum target, const void* dataPtr, 
+void BufferImpl::create(GLenum target, const void* dataPtr, 
 	U32 sizeInBytes, GLbitfield flags)
 {
 	ANKI_ASSERT(!isCreated());
@@ -83,8 +83,6 @@ Error BufferImpl::create(GLenum target, const void* dataPtr,
 			glMapBufferRange(m_target, 0, sizeInBytes, flags & mapbits);
 		ANKI_ASSERT(m_persistentMapping != nullptr);
 	}
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/CommandBufferHandle.cpp

@@ -140,16 +140,13 @@ Error CommandBufferHandle::create(GrManager* manager,
 	ANKI_ASSERT(!isCreated());
 	ANKI_ASSERT(manager);
 
-	Error err = Base::create(
+	Base::create(
 		*manager,
 		GrHandleDefaultDeleter<CommandBufferImpl>());
 
-	if(!err)
-	{
-		err = get().create(hints);
-	}
+	get().create(hints);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/CommandBufferImpl.cpp

@@ -13,7 +13,7 @@
 namespace anki {
 
 //==============================================================================
-Error CommandBufferImpl::create(const InitHints& hints)
+void CommandBufferImpl::create(const InitHints& hints)
 {
 	auto& pool = getManager().getAllocator().getMemoryPool();
 
@@ -24,8 +24,6 @@ Error CommandBufferImpl::create(const InitHints& hints)
 		InitHints::MAX_CHUNK_SIZE, 
 		ChainMemoryPool::ChunkGrowMethod::ADD,
 		hints.m_chunkSize);
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/FramebufferHandle.cpp

@@ -111,16 +111,13 @@ Error FramebufferHandle::create(CommandBufferHandle& commands,
 	using DeleteCommand = DeleteObjectCommand<FramebufferImpl>;
 	using Deleter = DeferredDeleter<FramebufferImpl, DeleteCommand>;
 
-	Error err = Base::create(commands.get().getManager(), Deleter());
-	if(!err)
-	{
-		get().setStateAtomically(GlObject::State::TO_BE_CREATED);
+	Base::create(commands.get().getManager(), Deleter());
 
-		commands.get().pushBackNewCommand<CreateFramebufferCommand>(
-			*this, init);
-	}
+	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
+
+	commands.get().pushBackNewCommand<CreateFramebufferCommand>(*this, init);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/GrManager.cpp

@@ -17,23 +17,11 @@ Error GrManager::create(Initializer& init)
 	m_alloc = HeapAllocator<U8>(
 		init.m_allocCallback, init.m_allocCallbackUserData);
 
-	Error err = m_cacheDir.create(m_alloc, init.m_cacheDirectory);
+	m_cacheDir.create(m_alloc, init.m_cacheDirectory);
+	m_impl = m_alloc.newInstance<GrManagerImpl>(this);
+	Error err = m_impl->create(init);
 
-	if(!err)
-	{
-		m_impl = m_alloc.newInstance<GrManagerImpl>(this);
-	}
-
-	if(m_impl)
-	{
-		err = m_impl->create(init);
-	}
-	else
-	{
-		err = ErrorCode::OUT_OF_MEMORY;
-	}
-
-	return ErrorCode::NONE;
+	return err;
 }
 
 //==============================================================================

src/gr/gl/OcclusionQueryHandle.cpp

@@ -28,14 +28,14 @@ public:
 
 	Error operator()(CommandBufferImpl*)
 	{
-		Error err = m_handle.get().create(m_condRenderingBit);
+		m_handle.get().create(m_condRenderingBit);
 
 		GlObject::State oldState = m_handle.get().setStateAtomically(
-			(err) ? GlObject::State::ERROR : GlObject::State::CREATED);
+			GlObject::State::CREATED);
 		ANKI_ASSERT(oldState == GlObject::State::TO_BE_CREATED);
 		(void)oldState;
 
-		return err;
+		return ErrorCode::NONE;
 	}
 };
 
@@ -93,22 +93,15 @@ Error OcclusionQueryHandle::create(
 	using Deleter = DeferredDeleter<OcclusionQueryImpl, DeleteCommand>;
 
 	CommandBufferHandle cmd;
-	Error err = cmd.create(manager);
-
-	if(!err)
-	{
-		err = Base::create(*manager, Deleter());
-	}
+	ANKI_CHECK(cmd.create(manager));
 
-	if(!err)
-	{
-		get().setStateAtomically(GlObject::State::TO_BE_CREATED);
+	Base::create(*manager, Deleter());
+	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 
-		cmd.get().pushBackNewCommand<OqCreateCommand>(*this, condRenderingBit);
-		cmd.flush();
-	}
+	cmd.get().pushBackNewCommand<OqCreateCommand>(*this, condRenderingBit);
+	cmd.flush();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/OcclusionQueryImpl.cpp

@@ -8,12 +8,11 @@
 namespace anki {
 
 //==============================================================================
-Error OcclusionQueryImpl::create(ResultBit condRenderingBit)
+void OcclusionQueryImpl::create(ResultBit condRenderingBit)
 {
 	glGenQueries(1, &m_glName);
 	ANKI_ASSERT(m_glName != 0);
 	m_condRenderingBit = condRenderingBit;
-	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/PipelineHandle.cpp

@@ -107,16 +107,12 @@ Error PipelineHandle::commonConstructor(
 	using DeleteCommand = DeleteObjectCommand<PipelineImpl>;
 	using Deleter = DeferredDeleter<PipelineImpl, DeleteCommand>;
 
-	Error err = Base::create(commands.get().getManager(), Deleter());
-	if(!err)
-	{
-		get().setStateAtomically(GlObject::State::TO_BE_CREATED);
-
-		commands.get().pushBackNewCommand<CreatePipelineCommand>(
-			*this, progsBegin, progsEnd);
-	}
+	Base::create(commands.get().getManager(), Deleter());
+	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
+	commands.get().pushBackNewCommand<CreatePipelineCommand>(
+		*this, progsBegin, progsEnd);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/PipelineImpl.cpp

@@ -56,16 +56,13 @@ Error PipelineImpl::create(
 		glGetProgramPipelineiv(m_glName, GL_INFO_LOG_LENGTH, &infoLen);
 
 		auto alloc = getAllocator();
-		err = infoLogTxt.create(alloc, infoLen + 1);
+		infoLogTxt.create(alloc, infoLen + 1);
 
-		if(!err)
-		{
-			glGetProgramPipelineInfoLog(
-				m_glName, infoLen, &charsWritten, &infoLogTxt[0]);
+		glGetProgramPipelineInfoLog(
+			m_glName, infoLen, &charsWritten, &infoLogTxt[0]);
 
-			ANKI_LOGE("Ppline error log follows:\n%s", &infoLogTxt[0]);
-			err = ErrorCode::USER_DATA;
-		}
+		ANKI_LOGE("Ppline error log follows:\n%s", &infoLogTxt[0]);
+		err = ErrorCode::USER_DATA;
 	}
 
 	glBindProgramPipeline(0);

src/gr/gl/ShaderHandle.cpp

@@ -66,20 +66,17 @@ Error ShaderHandle::create(CommandBufferHandle& commands,
 	using DeleteCommand = DeleteObjectCommand<ShaderImpl>;
 	using Deleter = DeferredDeleter<ShaderImpl, DeleteCommand>;
 
-	Error err = Base::create(commands.get().getManager(), Deleter());
-	if(!err)
-	{
-		get().setStateAtomically(GlObject::State::TO_BE_CREATED);
+	Base::create(commands.get().getManager(), Deleter());
+	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 
-		// Copy source to the command buffer
-		void* src = commands.get().getInternalAllocator().allocate(sourceSize);
-		memcpy(src, source, sourceSize);
+	// Copy source to the command buffer
+	void* src = commands.get().getInternalAllocator().allocate(sourceSize);
+	memcpy(src, source, sourceSize);
 
-		commands.get().pushBackNewCommand<ShaderCreateCommand>(
-			*this, type, static_cast<char*>(src));
-	}
+	commands.get().pushBackNewCommand<ShaderCreateCommand>(
+		*this, type, static_cast<char*>(src));
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/gr/gl/ShaderImpl.cpp

@@ -22,8 +22,6 @@ Error ShaderImpl::create(ShaderType type, const CString& source)
 	ANKI_ASSERT(source);
 	ANKI_ASSERT(!isCreated());
 
-	Error err = ErrorCode::NONE;
-
 	static const Array<GLenum, 6> gltype = {{GL_VERTEX_SHADER, 
 		GL_TESS_CONTROL_SHADER, GL_TESS_EVALUATION_SHADER, GL_GEOMETRY_SHADER,
 		GL_FRAGMENT_SHADER, GL_COMPUTE_SHADER}};
@@ -44,26 +42,22 @@ Error ShaderImpl::create(ShaderType type, const CString& source)
 	auto alloc = getAllocator();
 	StringAuto fullSrc(alloc);
 #if ANKI_GL == ANKI_GL_DESKTOP
-	err = fullSrc.sprintf("#version %d core\n%s\n", version, &source[0]); 
+	fullSrc.sprintf("#version %d core\n%s\n", version, &source[0]); 
 #else
-	err = fullSrc.sprintf("#version %d es\n%s\n", version, &source[0]);
+	fullSrc.sprintf("#version %d es\n%s\n", version, &source[0]);
 #endif
 
 	// 2) Gen name, create, compile and link
 	//
-	if(!err)
+	const char* sourceStrs[1] = {nullptr};
+	sourceStrs[0] = &fullSrc[0];
+	m_glName = glCreateShaderProgramv(m_glType, 1, sourceStrs);
+	if(m_glName == 0)
 	{
-		const char* sourceStrs[1] = {nullptr};
-		sourceStrs[0] = &fullSrc[0];
-		m_glName = glCreateShaderProgramv(m_glType, 1, sourceStrs);
-		if(m_glName == 0)
-		{
-			err = ErrorCode::FUNCTION_FAILED;
-		}
+		return ErrorCode::FUNCTION_FAILED;
 	}
 
 #if ANKI_DUMP_SHADERS
-	if(!err)
 	{
 		const char* ext;
 
@@ -92,46 +86,31 @@ Error ShaderImpl::create(ShaderType type, const CString& source)
 			ANKI_ASSERT(0);
 		}
 
-		String fname;
+		StringAuto fname(alloc);
 		CString cacheDir = getManager().getCacheDirectory();
-		err = fname.sprintf(alloc,
-			"%s/%05u.%s", &cacheDir[0], static_cast<U32>(m_glName), ext);
-
-		if(!err)
-		{
-			File file;
-			err = file.open(fname.toCString(), File::OpenFlag::WRITE);
-		}
+		fname.sprintf("%s/%05u.%s", &cacheDir[0], 
+			static_cast<U32>(m_glName), ext);
 
-		fname.destroy(alloc);
+		File file;
+		ANKI_CHECK(file.open(fname.toCString(), File::OpenFlag::WRITE));
 	}
 #endif
 	
-	if(!err)
+	GLint status = GL_FALSE;
+	glGetProgramiv(m_glName, GL_LINK_STATUS, &status);
+	if(status == GL_FALSE)
 	{
-		GLint status = GL_FALSE;
-		glGetProgramiv(m_glName, GL_LINK_STATUS, &status);
-
-		if(status == GL_FALSE)
-		{
-			err = handleError(fullSrc);
-
-			if(!err)
-			{
-				// Compilation failed, set error anyway
-				err = ErrorCode::USER_DATA;
-			}
-		}
+		handleError(fullSrc);
+		// Compilation failed, set error anyway
+		return ErrorCode::USER_DATA;
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
-Error ShaderImpl::handleError(String& src)
+void ShaderImpl::handleError(String& src)
 {
-	Error err = ErrorCode::NONE;
-
 	auto alloc = getAllocator();
 	GLint compilerLogLen = 0;
 	GLint charsWritten = 0;
@@ -145,41 +124,29 @@ Error ShaderImpl::handleError(String& src)
 
 	glGetProgramiv(m_glName, GL_INFO_LOG_LENGTH, &compilerLogLen);
 
-	err = compilerLog.create(alloc, ' ', compilerLogLen + 1);
+	compilerLog.create(alloc, ' ', compilerLogLen + 1);
 
-	if(!err)
-	{
-		glGetProgramInfoLog(
-			m_glName, compilerLogLen, &charsWritten, &compilerLog[0]);
+	glGetProgramInfoLog(
+		m_glName, compilerLogLen, &charsWritten, &compilerLog[0]);
 		
-		err = lines.splitString(alloc, src.toCString(), '\n');
-	}
+	lines.splitString(alloc, src.toCString(), '\n');
 
 	I lineno = 0;
-	for(auto it = lines.getBegin(); it != lines.getEnd() && !err; ++it)
+	for(auto it = lines.getBegin(); it != lines.getEnd(); ++it)
 	{
 		String tmp;
 
-		err = tmp.sprintf(alloc, "%4d: %s\n", ++lineno, &(*it)[0]);
-		
-		if(!err)
-		{
-			err = prettySrc.append(alloc, tmp);
-		}
-
+		tmp.sprintf(alloc, "%4d: %s\n", ++lineno, &(*it)[0]);
+		prettySrc.append(alloc, tmp);
 		tmp.destroy(alloc);
 	}
 
-	if(!err)
-	{
-		ANKI_LOGE("Shader compilation failed (type %x):\n%s\n%s\n%s\n%s",
-			m_glType, padding, &compilerLog[0], padding, &prettySrc[0]);
-	}
+	ANKI_LOGE("Shader compilation failed (type %x):\n%s\n%s\n%s\n%s",
+		m_glType, padding, &compilerLog[0], padding, &prettySrc[0]);
 
 	lines.destroy(alloc);
 	prettySrc.destroy(alloc);
 	compilerLog.destroy(alloc);
-	return err;
 }
 
 //==============================================================================

src/gr/gl/TextureHandle.cpp

@@ -35,10 +35,10 @@ public:
 	{
 		ANKI_ASSERT(cmdb);
 
-		Error err = m_tex.get().create(m_init);
+		m_tex.get().create(m_init);
 
 		GlObject::State oldState = m_tex.get().setStateAtomically(
-			(err) ? GlObject::State::ERROR : GlObject::State::CREATED);
+			GlObject::State::CREATED);
 		ANKI_ASSERT(oldState == GlObject::State::TO_BE_CREATED);
 		(void)oldState;
 
@@ -58,7 +58,7 @@ public:
 			}
 		}
 
-		return err;
+		return ErrorCode::NONE;
 	}
 };
 
@@ -181,17 +181,14 @@ Error TextureHandle::create(
 	using DeleteCommand = DeleteObjectCommand<TextureImpl>;
 	using Deleter = DeferredDeleter<TextureImpl, DeleteCommand>;
 
-	Error err = Base::create(commands.get().getManager(), Deleter());
-	if(!err)
-	{
-		get().setStateAtomically(GlObject::State::TO_BE_CREATED);
+	Base::create(commands.get().getManager(), Deleter());
+	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 
-		// Fire the command
-		commands.get().pushBackNewCommand<CreateTextureCommand>(
-			*this, init, init.m_copyDataBeforeReturn);
-	}
+	// Fire the command
+	commands.get().pushBackNewCommand<CreateTextureCommand>(
+		*this, init, init.m_copyDataBeforeReturn);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -348,14 +345,11 @@ Error SamplerHandle::create(CommandBufferHandle& commands)
 	using DeleteCommand = DeleteObjectCommand<SamplerImpl>;
 	using Deleter = DeferredDeleter<SamplerImpl, DeleteCommand>;
 
-	Error err = Base::create(commands.get().getManager(), Deleter());
-	if(!err)
-	{
-		get().setStateAtomically(GlObject::State::TO_BE_CREATED);
-		commands.get().pushBackNewCommand<CreateSamplerCommand>(*this);
-	}
+	Base::create(commands.get().getManager(), Deleter());
+	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
+	commands.get().pushBackNewCommand<CreateSamplerCommand>(*this);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/gr/gl/TextureImpl.cpp

@@ -102,7 +102,7 @@ static void getTextureInformation(
 //==============================================================================
 
 //==============================================================================
-Error TextureImpl::create(const Initializer& init)
+void TextureImpl::create(const Initializer& init)
 {
 	GrAllocator<U8> alloc = getAllocator();
 
@@ -255,11 +255,7 @@ Error TextureImpl::create(const Initializer& init)
 					{
 						PtrSize layerSize = init.m_data[level][0].m_size;
 						ANKI_ASSERT(layerSize > 0);
-						Error err = data.create(layerSize * m_depth);
-						if(err)
-						{
-							return err;
-						}
+						data.create(layerSize * m_depth);
 
 						for(U d = 0; d < m_depth; d++)
 						{
@@ -345,7 +341,6 @@ Error TextureImpl::create(const Initializer& init)
 	}
 
 	ANKI_CHECK_GL_ERROR();
-	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/misc/Xml.cpp

@@ -104,14 +104,14 @@ Error XmlElement::getFloats(DArrayAuto<F64>& out) const
 	StringList list;
 	if(!err)
 	{
-		err = list.splitString(m_alloc, txt, ' ');
+		list.splitString(m_alloc, txt, ' ');
 	}
 
 	out = std::move(DArrayAuto<F64>(m_alloc));
 
 	if(!err)
 	{
-		err = out.create(list.getSize());
+		out.create(list.getSize());
 	}
 
 	auto it = list.getBegin();

src/renderer/Hdr.cpp

@@ -16,15 +16,11 @@ Hdr::~Hdr()
 //==============================================================================
 Error Hdr::initFb(FramebufferHandle& fb, TextureHandle& rt)
 {
-	Error err = ErrorCode::NONE;
-
-	err = m_r->createRenderTarget(m_width, m_height, GL_RGB8, 1, rt);
-	if(err) return err;
+	ANKI_CHECK(m_r->createRenderTarget(m_width, m_height, GL_RGB8, 1, rt));
 
 	// Set to bilinear because the blurring techniques take advantage of that
 	CommandBufferHandle cmdb;
-	err = cmdb.create(&getGrManager());
-	if(err) return err;
+	ANKI_CHECK(cmdb.create(&getGrManager()));
 
 	rt.setFilter(cmdb, TextureHandle::Filter::LINEAR);
 
@@ -32,19 +28,16 @@ Error Hdr::initFb(FramebufferHandle& fb, TextureHandle& rt)
 	FramebufferHandle::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = rt;
-	err = fb.create(cmdb, fbInit);
-	if(err) return err;
+	ANKI_CHECK(fb.create(cmdb, fbInit));
 
 	cmdb.finish();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error Hdr::initInternal(const ConfigSet& initializer)
 {
-	Error err = ErrorCode::NONE;
-
 	m_enabled = initializer.get("pps.hdr.enabled");
 
 	if(!m_enabled)
@@ -64,46 +57,39 @@ Error Hdr::initInternal(const ConfigSet& initializer)
 	m_blurringIterationsCount = 
 		initializer.get("pps.hdr.blurringIterationsCount");
 
-	err = initFb(m_hblurFb, m_hblurRt);
-	if(err) return err;
-
-	err = initFb(m_vblurFb, m_vblurRt);
-	if(err) return err;
+	ANKI_CHECK(initFb(m_hblurFb, m_hblurRt));
+	ANKI_CHECK(initFb(m_vblurFb, m_vblurRt));
 
 	// init shaders
 	GrManager& gl = getGrManager();
 	CommandBufferHandle cmdb;
-	err = cmdb.create(&gl);
-	if(err) return err;
+	ANKI_CHECK(cmdb.create(&gl));
 
-	err = m_commonBuff.create(cmdb, GL_UNIFORM_BUFFER, nullptr,
-		sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT);
-	if(err) return err;
+	ANKI_CHECK(m_commonBuff.create(cmdb, GL_UNIFORM_BUFFER, nullptr,
+		sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT));
 
-	err = updateDefaultBlock(cmdb);
-	if(err) return err;
+	updateDefaultBlock(cmdb);
 
 	cmdb.flush();
 
-	err = m_toneFrag.load("shaders/PpsHdr.frag.glsl", &getResourceManager());
-	if(err) return err;
+	ANKI_CHECK(
+		m_toneFrag.load("shaders/PpsHdr.frag.glsl", &getResourceManager()));
 
-	err = m_r->createDrawQuadPipeline(
-		m_toneFrag->getGrShader(), m_tonePpline);
-	if(err) return err;
+	ANKI_CHECK(m_r->createDrawQuadPipeline(
+		m_toneFrag->getGrShader(), m_tonePpline));
 
 	const char* SHADER_FILENAME = 
 		"shaders/VariableSamplingBlurGeneric.frag.glsl";
 
 	StringAuto pps(getAllocator());
-	ANKI_CHECK(pps.sprintf(
+	pps.sprintf(
 		"#define HPASS\n"
 		"#define COL_RGB\n"
 		"#define BLURRING_DIST float(%f)\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES %u\n",
 		m_blurringDist, m_height, 
-		static_cast<U>(initializer.get("pps.hdr.samples"))));
+		static_cast<U>(initializer.get("pps.hdr.samples")));
 
 	ANKI_CHECK(m_hblurFrag.loadToCache(&getResourceManager(),
 		SHADER_FILENAME, pps.toCString(), "r_"));
@@ -112,14 +98,14 @@ Error Hdr::initInternal(const ConfigSet& initializer)
 		m_hblurFrag->getGrShader(), m_hblurPpline));
 
 	pps.destroy(getAllocator());
-	ANKI_CHECK(pps.sprintf(
+	pps.sprintf(
 		"#define VPASS\n"
 		"#define COL_RGB\n"
 		"#define BLURRING_DIST float(%f)\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES %u\n",
 		m_blurringDist, m_width, 
-		static_cast<U>(initializer.get("pps.hdr.samples"))));
+		static_cast<U>(initializer.get("pps.hdr.samples")));
 
 	ANKI_CHECK(m_vblurFrag.loadToCache(&getResourceManager(),
 		SHADER_FILENAME, pps.toCString(), "r_"));
@@ -131,7 +117,7 @@ Error Hdr::initInternal(const ConfigSet& initializer)
 	m_parameterUpdateTimestamp = getGlobalTimestamp();
 	m_commonUboUpdateTimestamp = getGlobalTimestamp();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -151,7 +137,6 @@ Error Hdr::init(const ConfigSet& initializer)
 Error Hdr::run(CommandBufferHandle& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
-	Error err = ErrorCode::NONE;
 
 	// For the passes it should be NEAREST
 	//vblurFai.setFiltering(Texture::TFrustumType::NEAREST);
@@ -163,11 +148,7 @@ Error Hdr::run(CommandBufferHandle& cmdb)
 
 	if(m_parameterUpdateTimestamp > m_commonUboUpdateTimestamp)
 	{
-		err = updateDefaultBlock(cmdb);
-		if(err)
-		{
-			return err;
-		}
+		updateDefaultBlock(cmdb);
 
 		m_commonUboUpdateTimestamp = getGlobalTimestamp();
 	}
@@ -204,12 +185,10 @@ Error Hdr::run(CommandBufferHandle& cmdb)
 }
 
 //==============================================================================
-Error Hdr::updateDefaultBlock(CommandBufferHandle& cmdb)
+void Hdr::updateDefaultBlock(CommandBufferHandle& cmdb)
 {
 	Vec4 uniform(m_exposure, 0.0, 0.0, 0.0);
 	m_commonBuff.write(cmdb, &uniform, sizeof(uniform), 0, 0, sizeof(uniform));
-
-	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/renderer/Is.cpp

@@ -176,7 +176,7 @@ Error Is::initInternal(const ConfigSet& config)
 	//
 	StringAuto pps(getAllocator());
 
-	ANKI_CHECK(pps.sprintf(
+	pps.sprintf(
 		"\n#define TILES_X_COUNT %u\n"
 		"#define TILES_Y_COUNT %u\n"
 		"#define TILES_COUNT %u\n" 
@@ -200,7 +200,7 @@ Error Is::initInternal(const ConfigSet& config)
 		m_maxLightIds,
 		m_groundLightEnabled,
 		TILES_BLOCK_BINDING,
-		m_sm.getPoissonEnabled()));
+		m_sm.getPoissonEnabled());
 
 	// point light
 	CommandBufferHandle cmdBuff;

src/renderer/Lf.cpp

@@ -64,10 +64,10 @@ Error Lf::initPseudo(const ConfigSet& config,
 	// Load program 1
 	StringAuto pps(getAllocator());
 
-	ANKI_CHECK(pps.sprintf(
+	pps.sprintf(
 		"#define TEX_DIMENSIONS vec2(%u.0, %u.0)\n", 
 		m_r->getPps().getHdr()._getWidth(),
-		m_r->getPps().getHdr()._getHeight()));
+		m_r->getPps().getHdr()._getHeight());
 
 	ANKI_CHECK(m_pseudoFrag.loadToCache(&getResourceManager(), 
 		"shaders/PpsLfPseudoPass.frag.glsl", pps.toCString(), "r_"));
@@ -89,8 +89,7 @@ Error Lf::initSprite(const ConfigSet& config,
 	// Load program + ppline
 	StringAuto pps(getAllocator());
 
-	ANKI_CHECK(pps.sprintf("#define MAX_SPRITES %u\n",
-		m_maxSpritesPerFlare));
+	pps.sprintf("#define MAX_SPRITES %u\n", m_maxSpritesPerFlare);
 
 	ANKI_CHECK(m_realVert.loadToCache(&getResourceManager(), 
 		"shaders/PpsLfSpritePass.vert.glsl", pps.toCString(), "r_"));
@@ -122,132 +121,75 @@ Error Lf::initSprite(const ConfigSet& config,
 Error Lf::initOcclusion(
 	const ConfigSet& config, CommandBufferHandle& cmdBuff)
 {
-	Error err = ErrorCode::NONE;
-
 	// Init vert buff
 	U buffSize = sizeof(Vec3) * m_maxFlares;
 
 	for(U i = 0; i < m_positionsVertBuff.getSize(); ++i)
 	{
-		err = m_positionsVertBuff[i].create(
+		ANKI_CHECK(m_positionsVertBuff[i].create(
 			cmdBuff, GL_ARRAY_BUFFER, nullptr, buffSize, 
-			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
-		if(err)
-		{
-			return err;
-		}
+			GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
 	}
 
 	// Init MVP buff
-	err = m_mvpBuff.create(cmdBuff, GL_UNIFORM_BUFFER, 
-		nullptr, sizeof(Mat4), GL_DYNAMIC_STORAGE_BIT);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_mvpBuff.create(cmdBuff, GL_UNIFORM_BUFFER, 
+		nullptr, sizeof(Mat4), GL_DYNAMIC_STORAGE_BIT));
 
 	// Shaders
-	err = m_occlusionVert.load("shaders/PpsLfOcclusion.vert.glsl",
-		&getResourceManager());
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_occlusionVert.load("shaders/PpsLfOcclusion.vert.glsl",
+		&getResourceManager()));
 
-	err = m_occlusionFrag.load("shaders/PpsLfOcclusion.frag.glsl",
-		&getResourceManager());
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_occlusionFrag.load("shaders/PpsLfOcclusion.frag.glsl",
+		&getResourceManager()));
 
-	err = m_occlusionPpline.create(cmdBuff,
-		{m_occlusionVert->getGrShader(), m_occlusionFrag->getGrShader()});
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_occlusionPpline.create(cmdBuff,
+		{m_occlusionVert->getGrShader(), m_occlusionFrag->getGrShader()}));
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error Lf::initInternal(const ConfigSet& config)
 {
-	Error err = ErrorCode::NONE;
 	m_enabled = config.get("pps.lf.enabled") 
 		&& config.get("pps.hdr.enabled");
 	if(!m_enabled)
 	{
-		return err;
+		return ErrorCode::NONE;
 	}
 
 	CommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGrManager());
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(cmdBuff.create(&getGrManager()));
 
-	err = initPseudo(config, cmdBuff);
-	if(err)
-	{
-		return err;
-	}
-
-	err = initSprite(config, cmdBuff);
-	if(err)
-	{
-		return err;
-	}
-
-	err = initOcclusion(config, cmdBuff);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(initPseudo(config, cmdBuff));
+	ANKI_CHECK(initSprite(config, cmdBuff));
+	ANKI_CHECK(initOcclusion(config, cmdBuff));
 
 	// Create the render target
-	err = m_r->createRenderTarget(m_r->getPps().getHdr()._getWidth(), 
-		m_r->getPps().getHdr()._getHeight(), GL_RGB8, 1, m_rt);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_r->createRenderTarget(m_r->getPps().getHdr()._getWidth(), 
+		m_r->getPps().getHdr()._getHeight(), GL_RGB8, 1, m_rt));
 
 	FramebufferHandle::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = m_rt;
-	err = m_fb.create(cmdBuff, fbInit);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_fb.create(cmdBuff, fbInit));
 
 	// Blit
-	err = m_blitFrag.load("shaders/Blit.frag.glsl", &getResourceManager());
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(
+		m_blitFrag.load("shaders/Blit.frag.glsl", &getResourceManager()));
 
-	err = m_r->createDrawQuadPipeline(
-		m_blitFrag->getGrShader(), m_blitPpline);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_r->createDrawQuadPipeline(
+		m_blitFrag->getGrShader(), m_blitPpline));
 
 	cmdBuff.flush();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error Lf::runOcclusionTests(CommandBufferHandle& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
-	Error err = ErrorCode::NONE;
 
 	// Retrieve some things
 	SceneGraph& scene = m_r->getSceneGraph();
@@ -315,7 +257,7 @@ Error Lf::runOcclusionTests(CommandBufferHandle& cmdb)
 		cmdb.enableDepthTest(false);
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/renderer/Pps.cpp

@@ -58,7 +58,7 @@ Error Pps::initInternal(const ConfigSet& config)
 	// SProg
 	StringAuto pps(getAllocator());
 
-	ANKI_CHECK(pps.sprintf(
+	pps.sprintf(
 		"#define SSAO_ENABLED %u\n"
 		"#define HDR_ENABLED %u\n"
 		"#define SHARPEN_ENABLED %u\n"
@@ -70,7 +70,7 @@ Error Pps::initInternal(const ConfigSet& config)
 		static_cast<U>(config.get("pps.sharpen")),
 		static_cast<U>(config.get("pps.gammaCorrection")),
 		m_r->getWidth(),
-		m_r->getHeight()));
+		m_r->getHeight());
 
 	ANKI_CHECK(m_frag.loadToCache(&getResourceManager(),
 		"shaders/Pps.frag.glsl", pps.toCString(), "r_"));

src/renderer/Renderer.cpp

@@ -56,8 +56,6 @@ Error Renderer::init(
 //==============================================================================
 Error Renderer::initInternal(const ConfigSet& config)
 {
-	Error err = ErrorCode::NONE;
-
 	// Set from the config
 	m_renderingQuality = config.get("renderingQuality");
 	m_defaultFbWidth = config.get("width");
@@ -101,101 +99,52 @@ Error Renderer::initInternal(const ConfigSet& config)
 	}
 
 	// Drawer
-	err = m_sceneDrawer.create(this);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_sceneDrawer.create(this));
 
 	// quad setup
 	static const F32 quadVertCoords[][2] = {{1.0, 1.0}, {-1.0, 1.0}, 
 		{1.0, -1.0}, {-1.0, -1.0}};
 
 	CommandBufferHandle cmdBuff;
-	err = cmdBuff.create(m_gl);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(cmdBuff.create(m_gl));
 
-	err = m_quadPositionsBuff.create(cmdBuff, GL_ARRAY_BUFFER, 
-		&quadVertCoords[0][0], sizeof(quadVertCoords), 0);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_quadPositionsBuff.create(cmdBuff, GL_ARRAY_BUFFER, 
+		&quadVertCoords[0][0], sizeof(quadVertCoords), 0));
 
-	err = m_drawQuadVert.load("shaders/Quad.vert.glsl", m_resources);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_drawQuadVert.load("shaders/Quad.vert.glsl", m_resources));
 
 	// Init the stages. Careful with the order!!!!!!!!!!
-	err = m_tiler.init();
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_tiler.init());
 
-	err = m_ms.init(config);
-	if(err)
-	{
-		return err;
-	}
-	err = m_dp.init(config);
-	if(err)
-	{
-		return err;
-	}
-	err = m_is.init(config);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_ms.init(config));
+	ANKI_CHECK(m_dp.init(config));
+	ANKI_CHECK(m_is.init(config));
 	
 	m_fs = m_alloc.newInstance<Fs>(this);
-	if(err = m_fs->init(config))
-	{
-		return err;
-	}
-	
-	err = m_pps.init(config);
-	if(err)
-	{
-		return err;
-	}
-	err = m_dbg.init(config);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_fs->init(config));
+	ANKI_CHECK(m_pps.init(config));
+	ANKI_CHECK(m_dbg.init(config));
 
 	// Default FB
 	FramebufferHandle::Initializer fbInit;
-	err = m_defaultFb.create(cmdBuff, fbInit);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_defaultFb.create(cmdBuff, fbInit));
 
 	cmdBuff.finish();
 
 	// Set the default preprocessor string
-	err = m_shadersPrependedSource.sprintf(
+	m_shadersPrependedSource.sprintf(
 		m_alloc,
 		"#define ANKI_RENDERER_WIDTH %u\n"
 		"#define ANKI_RENDERER_HEIGHT %u\n",
 		m_width, m_height);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error Renderer::render(SceneGraph& scene, 
 	Array<CommandBufferHandle, JOB_CHAINS_COUNT>& cmdBuff)
 {
-	Error err = ErrorCode::NONE;
 	m_scene = &scene;
 	Camera& cam = m_scene->getActiveCamera();
 
@@ -215,11 +164,8 @@ Error Renderer::render(SceneGraph& scene,
 	}
 
 	ANKI_COUNTER_START_TIMER(RENDERER_MS_TIME);
-	err = m_ms.run(cmdBuff[0]);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_ms.run(cmdBuff[0]));
+	
 	ANKI_COUNTER_STOP_TIMER_INC(RENDERER_MS_TIME);
 
 	m_tiler.runMinMax(m_ms._getDepthRt(), cmdBuff[0]);
@@ -227,52 +173,32 @@ Error Renderer::render(SceneGraph& scene,
 
 	if(m_pps.getEnabled() && m_pps.getLf().getEnabled())
 	{
-		err = m_pps.getLf().runOcclusionTests(cmdBuff[1]);
-		if(err)
-		{
-			return err;
-		}
+		ANKI_CHECK(m_pps.getLf().runOcclusionTests(cmdBuff[1]));
 	}
 
 	ANKI_COUNTER_START_TIMER(RENDERER_IS_TIME);
-	err = m_is.run(cmdBuff[1]);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(m_is.run(cmdBuff[1]));
 	ANKI_COUNTER_STOP_TIMER_INC(RENDERER_IS_TIME);
 
-	if(err = m_fs->run(cmdBuff[1])) 
-	{
-		return err;
-	}
+	ANKI_CHECK(m_fs->run(cmdBuff[1])); 
 
-	err = m_dp.run(cmdBuff[1]);
-	if(err) return err;
+	ANKI_CHECK(m_dp.run(cmdBuff[1]));
 
 	ANKI_COUNTER_START_TIMER(RENDERER_PPS_TIME);
 	if(m_pps.getEnabled())
 	{
-		err = m_pps.run(cmdBuff[1]);
-		if(err)
-		{
-			return err;
-		}
+		ANKI_CHECK(m_pps.run(cmdBuff[1]));
 	}
 	ANKI_COUNTER_STOP_TIMER_INC(RENDERER_PPS_TIME);
 
 	if(m_dbg.getEnabled())
 	{
-		err = m_dbg.run(cmdBuff[1]);
-		if(err)
-		{
-			return err;
-		}
+		ANKI_CHECK(m_dbg.run(cmdBuff[1]));
 	}
 
 	++m_framesNum;
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -321,8 +247,6 @@ Vec3 Renderer::unproject(const Vec3& windowCoords, const Mat4& modelViewMat,
 Error Renderer::createRenderTarget(U32 w, U32 h, GLenum internalFormat, 
 	U32 samples, TextureHandle& rt)
 {
-	Error err = ErrorCode::NONE;
-
 	// Not very important but keep the resulution of render targets aligned to
 	// 16
 	if(0)
@@ -350,15 +274,12 @@ Error Renderer::createRenderTarget(U32 w, U32 h, GLenum internalFormat,
 	init.m_samples = samples;
 
 	CommandBufferHandle cmdBuff;
-	err = cmdBuff.create(m_gl);
+	ANKI_CHECK(cmdBuff.create(m_gl));
 
-	if(!err)
-	{
-		rt.create(cmdBuff, init);
-		cmdBuff.finish();
-	}
+	rt.create(cmdBuff, init);
+	cmdBuff.finish();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/renderer/RenderingPass.cpp

@@ -49,23 +49,21 @@ Error BlurringRenderingPass::initBlurring(
 
 	Array<StringAuto, 2> pps = {{getAllocator(), getAllocator()}};
 
-	ANKI_CHECK(
-		pps[1].sprintf(
+	pps[1].sprintf(
 		"#define HPASS\n"
 		"#define COL_RGB\n"
 		"#define BLURRING_DIST float(%f)\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES %u\n", 
-		blurringDistance, height, samples));
+		blurringDistance, height, samples);
 
-	ANKI_CHECK(
-		pps[0].sprintf(
+	pps[0].sprintf(
 		"#define VPASS\n"
 		"#define COL_RGB\n"
 		"#define BLURRING_DIST float(%f)\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES %u\n",
-		blurringDistance, width, samples));
+		blurringDistance, width, samples);
 
 	for(U i = 0; i < 2; i++)
 	{

src/renderer/Sm.cpp

@@ -65,8 +65,7 @@ Error Sm::init(const ConfigSet& initializer)
 
 	// Init sms
 	U32 layer = 0;
-	ANKI_CHECK(
-		m_sms.create(getAllocator(), initializer.get("is.sm.maxLights")));
+	m_sms.create(getAllocator(), initializer.get("is.sm.maxLights"));
 	for(Shadowmap& sm : m_sms)
 	{
 		sm.m_layerId = layer;

src/renderer/Ssao.cpp

@@ -69,39 +69,32 @@ public:
 //==============================================================================
 Error Ssao::createFb(FramebufferHandle& fb, TextureHandle& rt)
 {
-	Error err = ErrorCode::NONE;
-
-	err = m_r->createRenderTarget(m_width, m_height, GL_R8, 1, rt);
-	if(err) return err;
+	ANKI_CHECK(m_r->createRenderTarget(m_width, m_height, GL_R8, 1, rt));
 
 	// Set to bilinear because the blurring techniques take advantage of that
 	CommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGrManager());
-	if(err) return err;
+	ANKI_CHECK(cmdBuff.create(&getGrManager()));
 	rt.setFilter(cmdBuff, TextureHandle::Filter::LINEAR);
 
 	// create FB
 	FramebufferHandle::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = rt;
-	err = fb.create(cmdBuff, fbInit);
-	if(err) return err;
+	ANKI_CHECK(fb.create(cmdBuff, fbInit));
 
 	cmdBuff.flush();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error Ssao::initInternal(const ConfigSet& config)
 {
-	Error err = ErrorCode::NONE;
-
 	m_enabled = config.get("pps.ssao.enabled");
 
 	if(!m_enabled)
 	{
-		return err;
+		return ErrorCode::NONE;
 	}
 
 	m_blurringIterationsCount = 
@@ -120,26 +113,14 @@ Error Ssao::initInternal(const ConfigSet& config)
 	//
 	// create FBOs
 	//
-	err = createFb(m_hblurFb, m_hblurRt);
-	if(err)
-	{
-		return err;
-	}
-	err = createFb(m_vblurFb, m_vblurRt);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(createFb(m_hblurFb, m_hblurRt));
+	ANKI_CHECK(createFb(m_vblurFb, m_vblurRt));
 
 	//
 	// noise texture
 	//
 	CommandBufferHandle cmdb;
-	err = cmdb.create(&getGrManager());
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(cmdb.create(&getGrManager()));
 
 	Array<Vec3, NOISE_TEX_SIZE * NOISE_TEX_SIZE> noise;
 
@@ -165,17 +146,16 @@ Error Ssao::initInternal(const ConfigSet& config)
 	Array<Vec3, KERNEL_SIZE> kernel;
 
 	genKernel(kernel.begin(), kernel.end());
-	err = kernelStr.create("vec3[](");
-	if(err) return err;
+	kernelStr.create("vec3[](");
 	for(U i = 0; i < kernel.size(); i++)
 	{
 		StringAuto tmp(getAllocator());
 
-		ANKI_CHECK(tmp.sprintf("vec3(%f, %f, %f) %s",
+		tmp.sprintf("vec3(%f, %f, %f) %s",
 			kernel[i].x(), kernel[i].y(), kernel[i].z(),
-			(i != kernel.size() - 1) ? ", " : ")"));
+			(i != kernel.size() - 1) ? ", " : ")");
 
-		ANKI_CHECK(kernelStr.append(tmp));
+		kernelStr.append(tmp);
 	}
 
 	//
@@ -187,13 +167,13 @@ Error Ssao::initInternal(const ConfigSet& config)
 	StringAuto pps(getAllocator());
 
 	// main pass prog
-	ANKI_CHECK(pps.sprintf(
+	pps.sprintf(
 		"#define NOISE_MAP_SIZE %u\n"
 		"#define WIDTH %u\n"
 		"#define HEIGHT %u\n"
 		"#define KERNEL_SIZE %u\n"
 		"#define KERNEL_ARRAY %s\n",
-		NOISE_TEX_SIZE, m_width, m_height, KERNEL_SIZE, &kernelStr[0]));
+		NOISE_TEX_SIZE, m_width, m_height, KERNEL_SIZE, &kernelStr[0]);
 
 	ANKI_CHECK(m_ssaoFrag.loadToCache(&getResourceManager(),
 		"shaders/PpsSsao.frag.glsl", pps.toCString(), "r_"));
@@ -206,12 +186,12 @@ Error Ssao::initInternal(const ConfigSet& config)
 		"shaders/VariableSamplingBlurGeneric.frag.glsl";
 
 	pps.destroy(getAllocator());
-	ANKI_CHECK(pps.sprintf(
+	pps.sprintf(
 		"#define HPASS\n"
 		"#define COL_R\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES 7\n", 
-		m_height));
+		m_height);
 
 	ANKI_CHECK(m_hblurFrag.loadToCache(&getResourceManager(),
 		SHADER_FILENAME, pps.toCString(), "r_"));
@@ -220,12 +200,12 @@ Error Ssao::initInternal(const ConfigSet& config)
 		m_hblurFrag->getGrShader(), m_hblurPpline));
 
 	pps.destroy(getAllocator());
-	ANKI_CHECK(pps.sprintf(
+	pps.sprintf(
 		"#define VPASS\n"
 		"#define COL_R\n"
 		"#define IMG_DIMENSION %u\n"
 		"#define SAMPLES 7\n", 
-		m_width));
+		m_width);
 
 	ANKI_CHECK(m_vblurFrag.loadToCache(&getResourceManager(),
 		SHADER_FILENAME, pps.toCString(), "r_"));
@@ -235,7 +215,7 @@ Error Ssao::initInternal(const ConfigSet& config)
 
 	cmdb.flush();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -255,7 +235,6 @@ Error Ssao::init(const ConfigSet& config)
 Error Ssao::run(CommandBufferHandle& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
-	Error err = ErrorCode::NONE;
 
 	const Camera& cam = m_r->getSceneGraph().getActiveCamera();
 
@@ -314,7 +293,7 @@ Error Ssao::run(CommandBufferHandle& cmdb)
 		m_r->drawQuad(cmdb);
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/renderer/Sslr.cpp

@@ -12,13 +12,11 @@ namespace anki {
 //==============================================================================
 Error Sslr::init(const ConfigSet& config)
 {
-	Error err = ErrorCode::NONE;
-
 	m_enabled = config.get("pps.sslr.enabled");
 
 	if(!m_enabled)
 	{
-		return err;
+		return ErrorCode::NONE;
 	}
 
 	// Size
@@ -34,10 +32,10 @@ Error Sslr::init(const ConfigSet& config)
 	// Programs
 	StringAuto pps(getAllocator());
 
-	ANKI_CHECK(pps.sprintf(
+	pps.sprintf(
 		"#define WIDTH %u\n"
 		"#define HEIGHT %u\n",
-		m_width, m_height));
+		m_width, m_height);
 
 	ANKI_CHECK(m_reflectionFrag.loadToCache(&getResourceManager(),
 		"shaders/PpsSslr.frag.glsl", pps.toCString(), "r_"));
@@ -82,14 +80,13 @@ Error Sslr::init(const ConfigSet& config)
 
 	cmdBuff.finish();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error Sslr::run(CommandBufferHandle& cmdBuff)
 {
 	ANKI_ASSERT(m_enabled);
-	Error err = ErrorCode::NONE;
 
 	// Compute the reflection
 	//
@@ -115,8 +112,7 @@ Error Sslr::run(CommandBufferHandle& cmdBuff)
 	//
 	if(m_blurringIterationsCount > 0)
 	{
-		err = runBlurring(*m_r, cmdBuff);
-		if(err) return err;
+		ANKI_CHECK(runBlurring(*m_r, cmdBuff));
 	}
 
 	// Write the reflection back to IS RT
@@ -134,7 +130,7 @@ Error Sslr::run(CommandBufferHandle& cmdBuff)
 
 	cmdBuff.enableBlend(false);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/renderer/Tiler.cpp

@@ -78,15 +78,12 @@ Error Tiler::init()
 //==============================================================================
 Error Tiler::initInternal()
 {
-	Error err = ErrorCode::NONE;
-
 	m_enableGpuTests = false;
 
 	// Load the program
 	StringAuto pps(getAllocator());
 
-	ANKI_CHECK(
-		pps.sprintf(
+	pps.sprintf(
 		"#define TILES_X_COUNT %u\n"
 		"#define TILES_Y_COUNT %u\n"
 		"#define RENDERER_WIDTH %u\n"
@@ -94,7 +91,7 @@ Error Tiler::initInternal()
 		m_r->getTilesCount().x(),
 		m_r->getTilesCount().y(),
 		m_r->getWidth(),
-		m_r->getHeight()));
+		m_r->getHeight());
 
 	ANKI_CHECK(
 		m_frag.loadToCache(&getResourceManager(), 
@@ -123,7 +120,7 @@ Error Tiler::initInternal()
 		+ (m_r->getTilesCount().y() - 1) * 2  // planes I
 		+ (m_r->getTilesCount().x() * m_r->getTilesCount().y() * 2); // near+far
 
-	ANKI_CHECK(m_allPlanes.create(getAllocator(), planesCount));
+	m_allPlanes.create(getAllocator(), planesCount);
 
 	Plane* base = &m_allPlanes[0];
 	U count = 0;
@@ -154,10 +151,10 @@ Error Tiler::initInternal()
 
 	ANKI_CHECK(initPbos());
 
-	ANKI_CHECK(m_prevMinMaxDepth.create(getAllocator(),
-		m_r->getTilesCount().x() * m_r->getTilesCount().y(), Vec2(0.0, 1.0)));
+	m_prevMinMaxDepth.create(getAllocator(),
+		m_r->getTilesCount().x() * m_r->getTilesCount().y(), Vec2(0.0, 1.0));
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -616,8 +613,6 @@ void Tiler::update(U32 threadId, PtrSize threadsCount,
 	const MoveComponent& move = cam.getComponent<MoveComponent>();
 	const FrustumComponent& frc = cam.getComponent<FrustumComponent>();
 	ANKI_ASSERT(frc.getFrustum().getType() == Frustum::Type::PERSPECTIVE);
-	const PerspectiveFrustum& frustum = 
-		static_cast<const PerspectiveFrustum&>(frc.getFrustum());
 
 	const Transform& trf = move.getWorldTransform();
 	const Vec4& projParams = frc.getProjectionParameters();

src/resource/Animation.cpp

@@ -26,8 +26,6 @@ Animation::~Animation()
 //==============================================================================
 Error Animation::load(const CString& filename, ResourceInitializer& init)
 {
-	Error err = ErrorCode::NONE;
-
 	XmlElement el;
 	I64 tmp;
 	F64 ftmp;
@@ -74,7 +72,7 @@ Error Animation::load(const CString& filename, ResourceInitializer& init)
 		ANKI_LOGE("Didn't found any channels");
 		return ErrorCode::USER_DATA;
 	}
-	ANKI_CHECK(m_channels.create(m_alloc, channelCount));
+	m_channels.create(m_alloc, channelCount);
 
 	// For all channels
 	channelCount = 0;
@@ -86,7 +84,7 @@ Error Animation::load(const CString& filename, ResourceInitializer& init)
 		ANKI_CHECK(chEl.getChildElement("name", el));
 		CString strtmp;
 		ANKI_CHECK(el.getText(strtmp));
-		ANKI_CHECK(ch.m_name.create(m_alloc, strtmp));
+		ch.m_name.create(m_alloc, strtmp);
 
 		XmlElement keysEl, keyEl;
 
@@ -98,7 +96,7 @@ Error Animation::load(const CString& filename, ResourceInitializer& init)
 
 			U32 count = 0;
 			ANKI_CHECK(keyEl.getSiblingElementsCount(count));
-			ANKI_CHECK(ch.m_positions.create(m_alloc, count));
+			ch.m_positions.create(m_alloc, count);
 
 			count = 0;
 			do
@@ -135,7 +133,7 @@ Error Animation::load(const CString& filename, ResourceInitializer& init)
 
 			U32 count = 0;
 			ANKI_CHECK(keysEl.getSiblingElementsCount(count));
-			ANKI_CHECK(ch.m_rotations.create(m_alloc, count));
+			ch.m_rotations.create(m_alloc, count);
 
 			count = 0;
 			do
@@ -174,7 +172,7 @@ Error Animation::load(const CString& filename, ResourceInitializer& init)
 
 			U32 count = 0;
 			ANKI_CHECK(keyEl.getSiblingElementsCount(count));
-			ANKI_CHECK(ch.m_scales.create(m_alloc, count));
+			ch.m_scales.create(m_alloc, count);
 
 			count = 0;
 			do
@@ -227,7 +225,7 @@ Error Animation::load(const CString& filename, ResourceInitializer& init)
 
 	m_duration = maxTime - m_startTime;
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/resource/Image.cpp

@@ -29,11 +29,7 @@ static ANKI_USE_RESULT Error loadUncompressedTga(
 	U8 header6[6];
 
 	// read the info from header
-	Error err = fs.read((char*)&header6[0], sizeof(header6));
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(fs.read((char*)&header6[0], sizeof(header6)));
 
 	width  = header6[1] * 256 + header6[0];
 	height = header6[3] * 256 + header6[2];
@@ -48,17 +44,9 @@ static ANKI_USE_RESULT Error loadUncompressedTga(
 	// read the data
 	I bytesPerPxl = (bpp / 8);
 	I imageSize = bytesPerPxl * width * height;
-	err = data.create(alloc, imageSize);
-	if(err)
-	{
-		return err;
-	}
+	data.create(alloc, imageSize);
 
-	err = fs.read(reinterpret_cast<char*>(&data[0]), imageSize);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(fs.read(reinterpret_cast<char*>(&data[0]), imageSize));
 
 	// swap red with blue
 	for(I i = 0; i < imageSize; i += bytesPerPxl)
@@ -68,7 +56,7 @@ static ANKI_USE_RESULT Error loadUncompressedTga(
 		data[i + 2] = temp;
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -77,11 +65,7 @@ static ANKI_USE_RESULT Error loadCompressedTga(
 	GenericMemoryPoolAllocator<U8>& alloc)
 {
 	U8 header6[6];
-	Error err = fs.read(reinterpret_cast<char*>(&header6[0]), sizeof(header6));
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(fs.read(reinterpret_cast<char*>(&header6[0]), sizeof(header6)));
 
 	width  = header6[1] * 256 + header6[0];
 	height = header6[3] * 256 + header6[2];
@@ -95,11 +79,7 @@ static ANKI_USE_RESULT Error loadCompressedTga(
 
 	I bytesPerPxl = (bpp / 8);
 	I imageSize = bytesPerPxl * width * height;
-	err = data.create(alloc, imageSize);
-	if(err)
-	{
-		return err;
-	}
+	data.create(alloc, imageSize);
 
 	U pixelcount = height * width;
 	U currentpixel = 0;
@@ -110,23 +90,14 @@ static ANKI_USE_RESULT Error loadCompressedTga(
 	{
 		U8 chunkheader = 0;
 
-		err = fs.read((char*)&chunkheader, sizeof(U8));
-		if(err)
-		{
-			data.destroy(alloc);
-			return err;
-		}
+		ANKI_CHECK(fs.read((char*)&chunkheader, sizeof(U8)));
 
 		if(chunkheader < 128)
 		{
 			chunkheader++;
 			for(int counter = 0; counter < chunkheader; counter++)
 			{
-				err = fs.read((char*)&colorbuffer[0], bytesPerPxl);
-				if(err)
-				{
-					return err;
-				}
+				ANKI_CHECK(fs.read((char*)&colorbuffer[0], bytesPerPxl));
 
 				data[currentbyte] = colorbuffer[2];
 				data[currentbyte + 1] = colorbuffer[1];
@@ -150,11 +121,7 @@ static ANKI_USE_RESULT Error loadCompressedTga(
 		else
 		{
 			chunkheader -= 127;
-			err = fs.read((char*)&colorbuffer[0], bytesPerPxl);
-			if(err)
-			{
-				return err;
-			}
+			ANKI_CHECK(fs.read((char*)&colorbuffer[0], bytesPerPxl));
 
 			for(int counter = 0; counter < chunkheader; counter++)
 			{
@@ -180,7 +147,6 @@ static ANKI_USE_RESULT Error loadCompressedTga(
 		}
 	} while(currentpixel < pixelcount);
 
-	ANKI_ASSERT(err == ErrorCode::NONE);
 	return ErrorCode::NONE;
 }
 
@@ -192,47 +158,34 @@ static ANKI_USE_RESULT Error loadTga(const CString& filename,
 	File fs;
 	char myTgaHeader[12];
 
-	Error err = fs.open(filename, 
-		File::OpenFlag::READ | File::OpenFlag::BINARY);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(fs.open(filename, 
+		File::OpenFlag::READ | File::OpenFlag::BINARY));
 
-	err = fs.read(&myTgaHeader[0], sizeof(myTgaHeader));
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(fs.read(&myTgaHeader[0], sizeof(myTgaHeader)));
 
 	if(std::memcmp(
 		tgaHeaderUncompressed, &myTgaHeader[0], sizeof(myTgaHeader)) == 0)
 	{
-		err = loadUncompressedTga(fs, width, height, bpp, data, alloc);
+		ANKI_CHECK(loadUncompressedTga(fs, width, height, bpp, data, alloc));
 	}
 	else if(std::memcmp(tgaHeaderCompressed, &myTgaHeader[0],
 		sizeof(myTgaHeader)) == 0)
 	{
-		err = loadCompressedTga(fs, width, height, bpp, data, alloc);
+		ANKI_CHECK(loadCompressedTga(fs, width, height, bpp, data, alloc));
 	}
 	else
 	{
 		ANKI_LOGE("Invalid image header");
-		err = ErrorCode::USER_DATA;
-	}
-
-	if(err)
-	{
-		return err;
+		return ErrorCode::USER_DATA;
 	}
 
 	if(bpp != 32 && bpp != 24)
 	{
 		ANKI_LOGE("Invalid bpp");
-		err = ErrorCode::USER_DATA;
+		return ErrorCode::USER_DATA;
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -345,8 +298,6 @@ static ANKI_USE_RESULT Error loadAnkiTexture(
 	Image::TextureType& textureType,
 	Image::ColorFormat& colorFormat)
 {
-	Error err = ErrorCode::NONE;
-	
 	File file;
 	ANKI_CHECK(file.open(filename, 
 		File::OpenFlag::READ | File::OpenFlag::BINARY 
@@ -466,9 +417,9 @@ static ANKI_USE_RESULT Error loadAnkiTexture(
 			!= Image::DataCompression::NONE)
 		{
 			// If raw compression is present then skip it
-			err = file.seek(
+			ANKI_CHECK(file.seek(
 				calcSizeOfSegment(header, Image::DataCompression::RAW), 
-				File::SeekOrigin::CURRENT);
+				File::SeekOrigin::CURRENT));
 		}
 	}
 	else if(preferredCompression == Image::DataCompression::ETC)
@@ -477,36 +428,34 @@ static ANKI_USE_RESULT Error loadAnkiTexture(
 			!= Image::DataCompression::NONE)
 		{
 			// If raw compression is present then skip it
-			err = file.seek(
+			ANKI_CHECK(file.seek(
 				calcSizeOfSegment(header, Image::DataCompression::RAW), 
-				File::SeekOrigin::CURRENT);
+				File::SeekOrigin::CURRENT));
 		}
 
 		if((header.m_compressionFormats & Image::DataCompression::S3TC)
 			!= Image::DataCompression::NONE)
 		{
 			// If s3tc compression is present then skip it
-			err = file.seek(
+			ANKI_CHECK(file.seek(
 				calcSizeOfSegment(header, Image::DataCompression::S3TC), 
-				File::SeekOrigin::CURRENT);
+				File::SeekOrigin::CURRENT));
 		}
 	}
 
-	ANKI_CHECK(err);
-
 	//
 	// It's time to read
 	//
 
 	// Allocate the surfaces 
-	ANKI_CHECK(surfaces.create(alloc, mipLevels * depth));
+	surfaces.create(alloc, mipLevels * depth);
 
 	// Read all surfaces
 	U mipWidth = header.m_width;
 	U mipHeight = header.m_height;
 	for(U mip = 0; mip < header.m_mipLevels; mip++)
 	{
-		for(U d = 0; d < depth && !err; d++)
+		for(U d = 0; d < depth; d++)
 		{
 			U dataSize = calcSurfaceSize(
 				mipWidth, mipHeight, preferredCompression, 
@@ -521,25 +470,13 @@ static ANKI_USE_RESULT Error loadAnkiTexture(
 				surf.m_width = mipWidth;
 				surf.m_height = mipHeight;
 
-				err = surf.m_data.create(alloc, dataSize);
-				if(err)
-				{
-					return err;
-				}
+				surf.m_data.create(alloc, dataSize);
 
-				err = file.read(&surf.m_data[0], dataSize);
-				if(err)
-				{
-					return err;
-				}
+				ANKI_CHECK(file.read(&surf.m_data[0], dataSize));
 			}
 			else
 			{
-				err = file.seek(dataSize, File::SeekOrigin::CURRENT);
-				if(err)
-				{
-					return err;
-				}
+				ANKI_CHECK(file.seek(dataSize, File::SeekOrigin::CURRENT));
 			}
 		}
 
@@ -547,7 +484,7 @@ static ANKI_USE_RESULT Error loadAnkiTexture(
 		mipHeight /= 2;
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -557,15 +494,9 @@ static ANKI_USE_RESULT Error loadAnkiTexture(
 //==============================================================================
 Error Image::load(const CString& filename, U32 maxTextureSize)
 {
-	Error err = ErrorCode::NONE;
-
 	// get the extension
 	StringAuto ext(m_alloc);
-	err = getFileExtension(filename, m_alloc, ext);
-	if(err)
-	{
-		return err;
-	}
+	getFileExtension(filename, m_alloc, ext);
 	
 	if(ext.isEmpty())
 	{
@@ -580,20 +511,12 @@ Error Image::load(const CString& filename, U32 maxTextureSize)
 
 	if(ext == "tga")
 	{
-		err = m_surfaces.create(m_alloc, 1);
-		if(err)
-		{
-			return err;
-		}
-
+		m_surfaces.create(m_alloc, 1);
+		
 		m_mipLevels = 1;
 		m_depth = 1;
-		err = loadTga(filename, m_surfaces[0].m_width, 
-			m_surfaces[0].m_height, bpp, m_surfaces[0].m_data, m_alloc);
-		if(err)
-		{
-			return err;
-		}
+		ANKI_CHECK(loadTga(filename, m_surfaces[0].m_width, 
+			m_surfaces[0].m_height, bpp, m_surfaces[0].m_data, m_alloc));
 
 		if(bpp == 32)
 		{
@@ -618,18 +541,18 @@ Error Image::load(const CString& filename, U32 maxTextureSize)
 		m_compression = Image::DataCompression::ETC;
 #endif
 
-		err = loadAnkiTexture(filename, maxTextureSize, 
+		ANKI_CHECK(loadAnkiTexture(filename, maxTextureSize, 
 			m_compression, m_surfaces, m_alloc, m_depth, 
-			m_mipLevels, m_textureType, m_colorFormat);
+			m_mipLevels, m_textureType, m_colorFormat));
 
 	}
 	else
 	{
 		ANKI_LOGE("Unsupported extension: %s", &ext[0]);
-		err = ErrorCode::USER_DATA;
+		return ErrorCode::USER_DATA;
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/resource/Material.cpp

@@ -61,37 +61,29 @@ MaterialVariable::~MaterialVariable()
 
 //==============================================================================
 template<typename T>
-Error MaterialVariableTemplate<T>::create(ResourceAllocator<U8> alloc, 
+void MaterialVariableTemplate<T>::create(ResourceAllocator<U8> alloc, 
 	const CString& name, const T* x, U32 size)
 {
-	Error err = ErrorCode::NONE;
-
-	err = m_name.create(alloc, name);
+	m_name.create(alloc, name);
 
-	if(!err && size > 0)
+	if(size > 0)
 	{
-		err = m_data.create(alloc, size);
-		if(!err)
+		m_data.create(alloc, size);
+		for(U i = 0; i < size; i++)
 		{
-			for(U i = 0; i < size; i++)
-			{
-				m_data[i] = x[i];
-			}
+			m_data[i] = x[i];
 		}
 	}
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================
 template<typename T>
-MaterialVariableTemplate<T>* MaterialVariableTemplate<T>::_newInstance(
+Error MaterialVariableTemplate<T>::_newInstance(
 	const MaterialProgramCreator::Input& in,
-	ResourceAllocator<U8> alloc, TempResourceAllocator<U8> talloc)
+	ResourceAllocator<U8> alloc, TempResourceAllocator<U8> talloc,
+	MaterialVariable*& out2)
 {
-	Error err = ErrorCode::NONE;
-	MaterialVariableTemplate<T>* out = nullptr;
-
+	MaterialVariableTemplate* out;
 	DArrayAuto<F32> floats(talloc);
 
 	// Get the float values
@@ -106,18 +98,16 @@ MaterialVariableTemplate<T>* MaterialVariableTemplate<T>::_newInstance(
 			ANKI_LOGE("Incorrect number of values. Variable %s", 
 				&in.m_name[0]);
 
-			return nullptr;
+			return ErrorCode::USER_DATA;
 		}
 
-		err = floats.create(floatsNeeded);
-		if(err) return nullptr;
+		floats.create(floatsNeeded);
 
 		auto it = in.m_value.getBegin();
 		for(U i = 0; i < floatsNeeded; ++i)
 		{
 			F64 d;
-			err = it->toF64(d);
-			if(err)	return nullptr;
+			ANKI_CHECK(it->toF64(d));
 
 			floats[i] = d;
 			++it;
@@ -126,23 +116,16 @@ MaterialVariableTemplate<T>* MaterialVariableTemplate<T>::_newInstance(
 
 	// Create new instance
 	out = alloc.newInstance<MaterialVariableTemplate<T>>();
-	if(!out) return nullptr;
 
 	if(floats.getSize() > 0)
 	{
-		err = out->create(alloc, in.m_name.toCString(), 
+		out->create(alloc, in.m_name.toCString(), 
 			(T*)&floats[0], in.m_arraySize);
 	}
 	else
 	{
 		// Buildin
-		err = out->create(alloc, in.m_name.toCString(), nullptr, 0);
-	}
-
-	if(err && out)
-	{
-		alloc.deleteInstance(out);
-		return nullptr;
+		out->create(alloc, in.m_name.toCString(), nullptr, 0);
 	}
 
 	// Set some values
@@ -160,7 +143,9 @@ MaterialVariableTemplate<T>* MaterialVariableTemplate<T>::_newInstance(
 		out->m_varBlkInfo.m_matrixStride = in.m_matrixStride;
 	}
 
-	return out;
+	out2 = out;
+
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -486,16 +471,16 @@ Error Material::parseMaterialTag(const XmlElement& materialEl,
 	U tessCount = m_tessellation ? 2 : 1;
 
 	// Alloc program vector
-	ANKI_CHECK(m_progs.create(rinit.m_alloc,
+	m_progs.create(rinit.m_alloc,
 		countShaders(ShaderType::VERTEX) 
 		+ countShaders(ShaderType::TESSELLATION_CONTROL)
 		+ countShaders(ShaderType::TESSELLATION_EVALUATION)
 		+ countShaders(ShaderType::GEOMETRY)
-		+ countShaders(ShaderType::FRAGMENT)));
+		+ countShaders(ShaderType::FRAGMENT));
 
 	// Aloc progam descriptors
-	ANKI_CHECK(m_pplines.create(rinit.m_alloc,
-		m_passesCount * m_lodsCount * tessCount));
+	m_pplines.create(rinit.m_alloc,
+		m_passesCount * m_lodsCount * tessCount);
 
 	m_hash = 0;
 	for(ShaderType shader = ShaderType::VERTEX; 
@@ -539,14 +524,14 @@ Error Material::parseMaterialTag(const XmlElement& materialEl,
 					}
 
 					StringAuto src(rinit.m_tempAlloc);
-					ANKI_CHECK(src.sprintf(
+					src.sprintf(
 						"%s\n"
 						"#define LOD %u\n"
 						"#define PASS %u\n"
 						"#define TESSELLATION %u\n"
 						"%s\n",
 						&rinit.m_resources._getShadersPrependedSource()[0],
-						level, pid, tess, &loader.getProgramSource(shader)[0]));
+						level, pid, tess, &loader.getProgramSource(shader)[0]);
 
 					StringAuto filename(rinit.m_tempAlloc);
 
@@ -577,20 +562,18 @@ Error Material::parseMaterialTag(const XmlElement& materialEl,
 Error Material::createProgramSourceToCache(
 	const StringAuto& source, StringAuto& out)
 {
-	Error err = ErrorCode::NONE;
-
 	auto alloc = m_resources->_getTempAllocator();
 
 	// Create the hash
 	U64 h = computeHash(&source[0], source.getLength());
 	StringAuto prefix(alloc);
 
-	ANKI_CHECK(prefix.toString(h));
+	prefix.toString(h);
 
 	// Create path
-	ANKI_CHECK(out.sprintf("%s/mtl_%s.glsl", 
+	out.sprintf("%s/mtl_%s.glsl", 
 		&m_resources->_getCacheDirectory()[0],
-		&prefix[0]));
+		&prefix[0]);
 
 	// If file not exists write it
 	if(!fileExists(out.toCString()))
@@ -601,14 +584,12 @@ Error Material::createProgramSourceToCache(
 		ANKI_CHECK(f.writeText("%s\n", &source[0]));
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error Material::populateVariables(const MaterialProgramCreator& loader)
 {
-	Error err = ErrorCode::NONE;
-
 	U varCount = 0;
 	for(const auto& in : loader.getInputVariables())
 	{
@@ -618,7 +599,7 @@ Error Material::populateVariables(const MaterialProgramCreator& loader)
 		}
 	}
 
-	ANKI_CHECK(m_vars.create(m_resources->_getAllocator(), varCount));
+	m_vars.create(m_resources->_getAllocator(), varCount);
 
 	varCount = 0;
 	for(const auto& in : loader.getInputVariables())
@@ -651,13 +632,10 @@ Error Material::populateVariables(const MaterialProgramCreator& loader)
 
 				if(tvar)
 				{
-					err = tvar->create(alloc, in.m_name.toCString(), &tp, 1);
+					tvar->create(alloc, in.m_name.toCString(), &tp, 1);
 
-					if(err)
-					{
-						alloc.deleteInstance(tvar);
-						tvar = nullptr;
-					}
+					alloc.deleteInstance(tvar);
+					tvar = nullptr;
 				}
 
 				mtlvar = tvar;
@@ -666,28 +644,34 @@ Error Material::populateVariables(const MaterialProgramCreator& loader)
 			}
 			break;
 		case ShaderVariableDataType::FLOAT:
-			mtlvar = MaterialVariableTemplate<F32>::_newInstance(in,
-				m_resources->_getAllocator(), m_resources->_getTempAllocator());
+			ANKI_CHECK(MaterialVariableTemplate<F32>::_newInstance(in,
+				m_resources->_getAllocator(), m_resources->_getTempAllocator(),
+				mtlvar));
 			break;
 		case ShaderVariableDataType::VEC2:
-			mtlvar = MaterialVariableTemplate<Vec2>::_newInstance(in,
-				m_resources->_getAllocator(), m_resources->_getTempAllocator());
+			ANKI_CHECK(MaterialVariableTemplate<Vec2>::_newInstance(in,
+				m_resources->_getAllocator(), m_resources->_getTempAllocator(),
+				mtlvar));
 			break;
 		case ShaderVariableDataType::VEC3:
-			mtlvar = MaterialVariableTemplate<Vec3>::_newInstance(in,
-				m_resources->_getAllocator(), m_resources->_getTempAllocator());
+			ANKI_CHECK(MaterialVariableTemplate<Vec3>::_newInstance(in,
+				m_resources->_getAllocator(), m_resources->_getTempAllocator(),
+				mtlvar));
 			break;
 		case ShaderVariableDataType::VEC4:
-			mtlvar = MaterialVariableTemplate<Vec4>::_newInstance(in,
-				m_resources->_getAllocator(), m_resources->_getTempAllocator());
+			ANKI_CHECK(MaterialVariableTemplate<Vec4>::_newInstance(in,
+				m_resources->_getAllocator(), m_resources->_getTempAllocator(),
+				mtlvar));
 			break;
 		case ShaderVariableDataType::MAT3:
-			mtlvar = MaterialVariableTemplate<Mat3>::_newInstance(in,
-				m_resources->_getAllocator(), m_resources->_getTempAllocator());
+			ANKI_CHECK(MaterialVariableTemplate<Mat3>::_newInstance(in,
+				m_resources->_getAllocator(), m_resources->_getTempAllocator(),
+				mtlvar));
 			break;
 		case ShaderVariableDataType::MAT4:
-			mtlvar = MaterialVariableTemplate<Mat4>::_newInstance(in,
-				m_resources->_getAllocator(), m_resources->_getTempAllocator());
+			ANKI_CHECK(MaterialVariableTemplate<Mat4>::_newInstance(in,
+				m_resources->_getAllocator(), m_resources->_getTempAllocator(),
+				mtlvar));
 			break;
 		// default is error
 		default:

src/resource/MaterialProgramCreator.cpp

@@ -142,8 +142,6 @@ MaterialProgramCreator::~MaterialProgramCreator()
 //==============================================================================
 Error MaterialProgramCreator::parseProgramsTag(const XmlElement& el)
 {
-	Error err = ErrorCode::NONE;
-
 	//
 	// First gather all the inputs
 	//
@@ -195,18 +193,17 @@ Error MaterialProgramCreator::parseProgramsTag(const XmlElement& el)
 	{
 		if(!m_source[i].isEmpty())
 		{
-			ANKI_CHECK(m_source[i].join(m_alloc, "\n", m_sourceBaked[i]));
+			m_source[i].join(m_alloc, "\n", m_sourceBaked[i]);
 		}
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error MaterialProgramCreator::parseProgramTag(
 	const XmlElement& programEl)
 {
-	Error err = ErrorCode::NONE;
 	XmlElement el;
 
 	// <type>
@@ -219,8 +216,7 @@ Error MaterialProgramCreator::parseProgramTag(
 	ANKI_CHECK(getShaderInfo(type, glshader, glshaderbit, shaderidx));
 
 	auto& lines = m_source[shaderidx];
-	ANKI_CHECK(lines.pushBackSprintf(m_alloc, 
-		"#pragma anki type %s", &type[0]));
+	lines.pushBackSprintf(m_alloc, "#pragma anki type %s", &type[0]);
 
 	if(glshader == GL_TESS_CONTROL_SHADER 
 		|| glshader == GL_TESS_EVALUATION_SHADER)
@@ -238,8 +234,7 @@ Error MaterialProgramCreator::parseProgramTag(
 	{
 		CString tmp;
 		ANKI_CHECK(includeEl.getText(tmp));
-		ANKI_CHECK(lines.pushBackSprintf(m_alloc, 
-			"#pragma anki include \"%s\"", &tmp[0]));
+		lines.pushBackSprintf(m_alloc, "#pragma anki include \"%s\"", &tmp[0]);
 
 		ANKI_CHECK(includeEl.getNextSiblingElement("include", includeEl));
 	} while(includeEl);
@@ -250,15 +245,15 @@ Error MaterialProgramCreator::parseProgramTag(
 	if(!m_uniformBlock.isEmpty()
 		&& (m_uniformBlockReferencedMask & glshaderbit))
 	{
-		ANKI_CHECK(lines.pushBackSprintf(m_alloc, 
-			"\nlayout(binding = 0, std140) uniform bDefaultBlock\n{"));
+		lines.pushBackSprintf(m_alloc, 
+			"\nlayout(binding = 0, std140) uniform bDefaultBlock\n{");
 
 		for(auto& str : m_uniformBlock)
 		{
-			ANKI_CHECK(lines.pushBackSprintf(m_alloc, &str[0]));
+			lines.pushBackSprintf(m_alloc, &str[0]);
 		}
 
-		ANKI_CHECK(lines.pushBackSprintf(m_alloc, "};"));
+		lines.pushBackSprintf(m_alloc, "};");
 	}
 
 	// Other variables
@@ -266,12 +261,12 @@ Error MaterialProgramCreator::parseProgramTag(
 	{
 		if(!in.m_inBlock && (in.m_shaderDefinedMask & glshaderbit))
 		{
-			ANKI_CHECK(lines.pushBackSprintf(m_alloc, &in.m_line[0]));
+			lines.pushBackSprintf(m_alloc, &in.m_line[0]);
 		}
 	}
 
 	// <operations></operations>
-	ANKI_CHECK(lines.pushBackSprintf(m_alloc, "\nvoid main()\n{"));
+	lines.pushBackSprintf(m_alloc, "\nvoid main()\n{");
 
 	XmlElement opsEl;
 	ANKI_CHECK(programEl.getChildElement("operations", opsEl));
@@ -281,28 +276,27 @@ Error MaterialProgramCreator::parseProgramTag(
 	{
 		String out;
 		ANKI_CHECK(parseOperationTag(opEl, glshader, glshaderbit, out));
-		ANKI_CHECK(lines.pushBackSprintf(m_alloc, &out[0]));
+		lines.pushBackSprintf(m_alloc, &out[0]);
 		out.destroy(m_alloc);
 
 		// Advance
 		ANKI_CHECK(opEl.getNextSiblingElement("operation", opEl));
 	} while(opEl);
 
-	ANKI_CHECK(lines.pushBackSprintf(m_alloc, "}\n"));
-	return err;
+	lines.pushBackSprintf(m_alloc, "}\n");
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 {
-	Error err = ErrorCode::NONE;
 	XmlElement el;
 	CString cstr;
 	XmlElement inputsEl;
 	ANKI_CHECK(programEl.getChildElementOptional("inputs", inputsEl));
 	if(!inputsEl)
 	{
-		return err;
+		return ErrorCode::NONE;
 	}
 
 	// Get shader type
@@ -323,12 +317,12 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 		// <name>
 		ANKI_CHECK(inputEl.getChildElement("name", el));
 		ANKI_CHECK(el.getText(cstr));
-		ANKI_CHECK(inpvar.m_name.create(m_alloc, cstr));
+		inpvar.m_name.create(m_alloc, cstr);
 
 		// <type>
 		ANKI_CHECK(inputEl.getChildElement("type", el));
 		ANKI_CHECK(el.getText(cstr));
-		ANKI_CHECK(inpvar.m_typeStr.create(m_alloc, cstr));
+		inpvar.m_typeStr.create(m_alloc, cstr);
 		ANKI_CHECK(computeShaderVariableDataType(cstr, inpvar.m_type));
 
 		// <value>
@@ -337,8 +331,7 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 		ANKI_CHECK(valueEl.getText(cstr));
 		if(cstr)
 		{
-			ANKI_CHECK(
-				inpvar.m_value.splitString(m_alloc, cstr, ' '));
+			inpvar.m_value.splitString(m_alloc, cstr, ' ');
 		}
 
 		// <const>
@@ -405,7 +398,7 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 
 		// Now you have the info to check if duplicate
 		Input* duplicateInp = nullptr;
-		err = m_inputs.iterateForward(
+		Error err = m_inputs.iterateForward(
 			[&duplicateInp, &inpvar](Input& in) -> Error
 		{
 			if(in.m_name == inpvar.m_name)
@@ -416,6 +409,7 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 
 			return ErrorCode::NONE;
 		});
+		(void)err;
 
 		if(duplicateInp != nullptr)
 		{
@@ -443,18 +437,18 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 		{
 			// Handle NON-consts
 
-			ANKI_CHECK(inpvar.m_line.sprintf(
-				m_alloc, "%s %s", &inpvar.m_typeStr[0], &inpvar.m_name[0]));
+			inpvar.m_line.sprintf(
+				m_alloc, "%s %s", &inpvar.m_typeStr[0], &inpvar.m_name[0]);
 			
 			if(inpvar.m_arraySize > 1)
 			{
 				String tmp;
-				ANKI_CHECK(tmp.sprintf(m_alloc, "[%uU]", inpvar.m_arraySize));
-				ANKI_CHECK(inpvar.m_line.append(m_alloc, tmp));
+				tmp.sprintf(m_alloc, "[%uU]", inpvar.m_arraySize);
+				inpvar.m_line.append(m_alloc, tmp);
 				tmp.destroy(m_alloc);
 			}
 
-			ANKI_CHECK(inpvar.m_line.append(m_alloc, ";"));
+			inpvar.m_line.append(m_alloc, ";");
 
 			// Can put it block
 			if(inpvar.m_type >= ShaderVariableDataType::SAMPLERS_FIRST 
@@ -462,9 +456,9 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 			{
 				String tmp;
 
-				ANKI_CHECK(tmp.sprintf(
+				tmp.sprintf(
 					m_alloc, "layout(binding = %u) uniform %s",
-					m_texBinding, &inpvar.m_line[0]));
+					m_texBinding, &inpvar.m_line[0]);
 
 				inpvar.m_line.destroy(m_alloc);
 				inpvar.m_line = std::move(tmp);
@@ -478,8 +472,8 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 				// In block
 				String tmp;
 
-				ANKI_CHECK(tmp.create(m_alloc, inpvar.m_line));
-				ANKI_CHECK(m_uniformBlock.emplaceBack(m_alloc));
+				tmp.create(m_alloc, inpvar.m_line);
+				m_uniformBlock.emplaceBack(m_alloc);
 				m_uniformBlock.getBack() = std::move(tmp);
 
 				m_uniformBlockReferencedMask |= glshaderbit;
@@ -578,19 +572,17 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 			inpvar.m_inBlock = false;
 
 			String initList;
-			ANKI_CHECK(inpvar.m_value.join(m_alloc, ", ", initList));
+			inpvar.m_value.join(m_alloc, ", ", initList);
 
-			err = inpvar.m_line.sprintf(m_alloc, "const %s %s = %s(%s);",
+			inpvar.m_line.sprintf(m_alloc, "const %s %s = %s(%s);",
 				&inpvar.m_typeStr[0], &inpvar.m_name[0], &inpvar.m_typeStr[0], 
 				&initList[0]);
 			initList.destroy(m_alloc);
-
-			ANKI_CHECK(err);
 		}
 
 		inpvar.m_shaderDefinedMask = glshaderbit;
 
-		ANKI_CHECK(m_inputs.emplaceBack(m_alloc));
+		m_inputs.emplaceBack(m_alloc);
 		m_inputs.getBack().move(inpvar);
 
 advance:
@@ -598,7 +590,7 @@ advance:
 		ANKI_CHECK(inputEl.getNextSiblingElement("input", inputEl));
 	} while(inputEl);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -608,7 +600,6 @@ Error MaterialProgramCreator::parseOperationTag(
 	GLbitfield glshaderbit,
 	String& out)
 {
-	Error err = ErrorCode::NONE;
 	CString cstr;
 	XmlElement el;
 
@@ -675,15 +666,13 @@ Error MaterialProgramCreator::parseOperationTag(
 
 				if(glshader == GL_VERTEX_SHADER)
 				{
-					ANKI_CHECK(argsList.pushBackSprintf(
-						"%s [gl_InstanceID]", &cstr[0]));
+					argsList.pushBackSprintf("%s [gl_InstanceID]", &cstr[0]);
 
 					m_instanceIdMask |= glshaderbit;
 				}
 				else if(glshader == GL_FRAGMENT_SHADER)
 				{
-					ANKI_CHECK(argsList.pushBackSprintf(
-						"%s [vInstanceId]", &cstr[0]));
+					argsList.pushBackSprintf("%s [vInstanceId]", &cstr[0]);
 					
 					m_instanceIdMask |= glshaderbit;
 				}
@@ -696,7 +685,7 @@ Error MaterialProgramCreator::parseOperationTag(
 			else
 			{
 				ANKI_CHECK(argEl.getText(cstr));
-				ANKI_CHECK(argsList.pushBackSprintf(&cstr[0]));
+				argsList.pushBackSprintf(&cstr[0]);
 			}
 
 			// Advance
@@ -706,30 +695,28 @@ Error MaterialProgramCreator::parseOperationTag(
 
 	// Now write everything
 	StringListAuto lines(m_alloc);
-
-	ANKI_CHECK(lines.pushBackSprintf("#if defined(%s_DEFINED)", &funcName[0]));
+	lines.pushBackSprintf("#if defined(%s_DEFINED)", &funcName[0]);
 
 	// Write the defines for the operationOuts
 	for(const String& arg : argsList)
 	{
 		if(arg.find(OUT) == 0)
 		{
-			ANKI_CHECK(lines.pushBackSprintf(
-				" && defined(%s_DEFINED)", &arg[0]));
+			lines.pushBackSprintf(" && defined(%s_DEFINED)", &arg[0]);
 		}
 	}
-	ANKI_CHECK(lines.pushBackSprintf("\n"));
+	lines.pushBackSprintf("\n");
 
 	if(!retTypeVoid)
 	{
 		ANKI_CHECK(retTypeEl.getText(cstr));
-		ANKI_CHECK(lines.pushBackSprintf(
+		lines.pushBackSprintf(
 			"#\tdefine out%u_DEFINED\n"
-			"\t%s out%u = ", id, &cstr[0], id));
+			"\t%s out%u = ", id, &cstr[0], id);
 	}
 	else
 	{
-		ANKI_CHECK(lines.pushBackSprintf("\t"));
+		lines.pushBackSprintf("\t");
 	}
 	
 	// write the "func(args...)" of "blah = func(args...)"
@@ -737,17 +724,17 @@ Error MaterialProgramCreator::parseOperationTag(
 
 	if(!argsList.isEmpty())
 	{
-		ANKI_CHECK(argsList.join(m_alloc, ", ", argsStr));
+		argsList.join(m_alloc, ", ", argsStr);
 	}
 
-	ANKI_CHECK(lines.pushBackSprintf("%s(%s);\n#endif",
+	lines.pushBackSprintf("%s(%s);\n#endif",
 		&funcName[0], 
-		(argsStr.isEmpty()) ? "" : &argsStr[0]));
+		(argsStr.isEmpty()) ? "" : &argsStr[0]);
 
 	// Bake final string
-	ANKI_CHECK(lines.join(m_alloc, " ", out));
+	lines.join(m_alloc, " ", out);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/resource/MeshLoader.cpp

@@ -37,17 +37,13 @@ Error MeshLoader::load(
 //==============================================================================
 Error MeshLoader::loadInternal(const CString& filename)
 {
-	Error err = ErrorCode::NONE;
-
 	File file;
-	err = file.open(filename, 
+	ANKI_CHECK(file.open(filename, 
 		File::OpenFlag::READ | File::OpenFlag::BINARY 
-		| File::OpenFlag::LITTLE_ENDIAN);
-	if(err) return err;
+		| File::OpenFlag::LITTLE_ENDIAN));
 
 	// Load header
-	err = file.read(&m_header, sizeof(m_header));
-	if(err) return err;
+	ANKI_CHECK(file.read(&m_header, sizeof(m_header)));
 
 	//
 	// Check header
@@ -196,10 +192,8 @@ Error MeshLoader::loadInternal(const CString& filename)
 	//
 	// Read submesh info
 	//
-	err = m_subMeshes.create(m_alloc, m_header.m_subMeshCount);
-	if(err) return err;
-	err = file.read(&m_subMeshes[0], m_subMeshes.getSizeInBytes());
-	if(err) return err;
+	m_subMeshes.create(m_alloc, m_header.m_subMeshCount);
+	ANKI_CHECK(file.read(&m_subMeshes[0], m_subMeshes.getSizeInBytes()));
 
 	// Checks
 	U idxSum = 0;
@@ -225,10 +219,8 @@ Error MeshLoader::loadInternal(const CString& filename)
 	//
 	// Read indices
 	//
-	err = m_indices.create(m_alloc, m_header.m_totalIndicesCount * sizeof(U16));
-	if(err) return err;
-	err = file.read(&m_indices[0], m_indices.getSizeInBytes());
-	if(err) return err;
+	m_indices.create(m_alloc, m_header.m_totalIndicesCount * sizeof(U16));
+	ANKI_CHECK(file.read(&m_indices[0], m_indices.getSizeInBytes()));
 
 	//
 	// Read vertices
@@ -240,12 +232,10 @@ Error MeshLoader::loadInternal(const CString& filename)
 		+ 2 * sizeof(U16) // uvs
 		+ ((hasBoneInfo) ? (4 * sizeof(U8) + 4 * sizeof(U16)) : 0);
 
-	err = m_verts.create(m_alloc, m_header.m_totalVerticesCount * m_vertSize);
-	if(err) return err;
-	err = file.read(&m_verts[0], m_verts.getSizeInBytes());
-	if(err) return err;
+	m_verts.create(m_alloc, m_header.m_totalVerticesCount * m_vertSize);
+	ANKI_CHECK(file.read(&m_verts[0], m_verts.getSizeInBytes()));
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/resource/Model.cpp

@@ -30,7 +30,6 @@ Error ModelPatchBase::createVertexDesc(
 	const Mesh& mesh,
 	CommandBufferHandle& vertexJobs)
 {
-	Error err = ErrorCode::NONE;
 	BufferHandle vbo;
 	U32 size;
 	GLenum type;
@@ -64,12 +63,12 @@ Error ModelPatchBase::createVertexDesc(
 
 	// The indices VBO
 	mesh.getBufferInfo(VertexAttribute::INDICES, vbo, size, type,
-			stride, offset, normalized);
+		stride, offset, normalized);
 
 	ANKI_ASSERT(vbo.isCreated());
 	vbo.bindIndexBuffer(vertexJobs);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -151,12 +150,10 @@ Error ModelPatchBase::getRenderingDataSub(
 //==============================================================================
 Error ModelPatchBase::create(GrManager* gl)
 {
-	Error err = ErrorCode::NONE;
-
 	const Material& mtl = getMaterial();
 	U lodsCount = getLodsCount();
 
-	ANKI_CHECK(m_vertJobs.create(m_alloc, lodsCount * mtl.getPassesCount()));
+	m_vertJobs.create(m_alloc, lodsCount * mtl.getPassesCount());
 
 	for(U lod = 0; lod < lodsCount; ++lod)
 	{
@@ -180,7 +177,7 @@ Error ModelPatchBase::create(GrManager* gl)
 		}
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -221,8 +218,8 @@ Error ModelPatch<MeshResourcePointerType>::create(
 
 	Error err = ErrorCode::NONE;
 
-	ANKI_CHECK(m_meshes.create(m_alloc, meshesCount));
-	ANKI_CHECK(m_meshResources.create(m_alloc, meshesCount));
+	m_meshes.create(m_alloc, meshesCount);
+	m_meshResources.create(m_alloc, meshesCount);
 
 	// Load meshes
 	for(U i = 0; i < meshesCount; i++)
@@ -326,8 +323,7 @@ Error Model::load(const CString& filename, ResourceInitializer& init)
 			ANKI_CHECK(valEl.getText(filename));
 	
 			StringAuto fixedFilename(init.m_tempAlloc);
-			ANKI_CHECK(init.m_resources.fixResourceFilename(
-				filename, fixedFilename));
+			init.m_resources.fixResourceFilename(filename, fixedFilename);
 
 			MeshLoader loader;
 			ANKI_CHECK(
@@ -376,7 +372,7 @@ Error Model::load(const CString& filename, ResourceInitializer& init)
 		return ErrorCode::USER_DATA;
 	}
 
-	ANKI_CHECK(m_modelPatches.create(alloc, count));
+	m_modelPatches.create(alloc, count);
 
 	count = 0;
 	ANKI_CHECK(modelPatchesEl.getChildElement("modelPatch", modelPatchEl));

src/resource/ProgramPrePreprocessor.cpp

@@ -35,7 +35,7 @@ void ProgramPrePreprocessor::printSourceLines() const
 	auto end = m_sourceLines.getEnd();
 	for(; it != end; ++it)
 	{
-		printf("%4lu %s\n", i++, &(*it)[0]);
+		printf("%4d %s\n", I(i++), &(*it)[0]);
 	}
 }
 
@@ -47,7 +47,7 @@ Error ProgramPrePreprocessor::parseFile(const CString& filename)
 
 	if(!err)
 	{
-		err = m_sourceLines.join(m_alloc, "\n", m_shaderSource);
+		m_sourceLines.join(m_alloc, "\n", m_shaderSource);
 	}
 	
 	return err;
@@ -65,8 +65,6 @@ Error ProgramPrePreprocessor::parseFileForPragmas(
 		return ErrorCode::USER_DATA;
 	}
 
-	Error err = ErrorCode::NONE;
-
 	// load file in lines
 	StringAuto txt(m_alloc);
 	StringListAuto lines(m_alloc);
@@ -74,7 +72,7 @@ Error ProgramPrePreprocessor::parseFileForPragmas(
 	File file;
 	ANKI_CHECK(file.open(filename, File::OpenFlag::READ));
 	ANKI_CHECK(file.readAllText(TempResourceAllocator<char>(m_alloc), txt));
-	ANKI_CHECK(lines.splitString(txt.toCString(), '\n'));
+	lines.splitString(txt.toCString(), '\n');
 	if(lines.getSize() < 1)
 	{
 		ANKI_LOGE("File is empty: %s", &filename[0]);
@@ -103,14 +101,14 @@ Error ProgramPrePreprocessor::parseFileForPragmas(
 				{
 					StringAuto filen(m_alloc);
 					
-					ANKI_CHECK(filen.create(
+					filen.create(
 						line.begin() + std::strlen(commands[6]), 
-						line.end() - 1));
+						line.end() - 1);
 
 					StringAuto filenFixed(m_alloc);
 
-					ANKI_CHECK(m_manager->fixResourceFilename(
-						filen.toCString(), filenFixed));
+					m_manager->fixResourceFilename(
+						filen.toCString(), filenFixed);
 
 					ANKI_CHECK(parseFileForPragmas(
 						filenFixed.toCString(), depth + 1));
@@ -127,7 +125,7 @@ Error ProgramPrePreprocessor::parseFileForPragmas(
 		}
 		else
 		{
-			ANKI_CHECK(m_sourceLines.pushBackSprintf(m_alloc, "%s", &line[0]));
+			m_sourceLines.pushBackSprintf(m_alloc, "%s", &line[0]);
 		}
 	}
 
@@ -138,13 +136,12 @@ Error ProgramPrePreprocessor::parseFileForPragmas(
 		return ErrorCode::USER_DATA;
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error ProgramPrePreprocessor::parseType(const String& line, Bool& found)
 {
-	Error err = ErrorCode::NONE;
 	U i;
 	found = false;
 
@@ -162,7 +159,7 @@ Error ProgramPrePreprocessor::parseType(const String& line, Bool& found)
 		if(m_type != ShaderType::COUNT)
 		{
 			ANKI_LOGE("The shader type is already set. Line %s", &line[0]);
-			err = ErrorCode::USER_DATA;
+			return ErrorCode::USER_DATA;
 		}
 		else
 		{
@@ -170,7 +167,7 @@ Error ProgramPrePreprocessor::parseType(const String& line, Bool& found)
 		}
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/resource/ResourceManager.cpp

@@ -45,22 +45,22 @@ Error ResourceManager::create(Initializer& init)
 		init.m_allocCallback, init.m_allocCallbackData, 
 		init.m_tempAllocatorMemorySize);
 
-	ANKI_CHECK(m_cacheDir.create(m_alloc, init.m_cacheDir));
+	m_cacheDir.create(m_alloc, init.m_cacheDir);
 
 	// Init the data path
 	//
 	if(getenv("ANKI_DATA_PATH"))
 	{
-		ANKI_CHECK(m_dataDir.sprintf(m_alloc, "%s/", getenv("ANKI_DATA_PATH")));
+		m_dataDir.sprintf(m_alloc, "%s/", getenv("ANKI_DATA_PATH"));
 		ANKI_LOGI("Data path: %s", &m_dataDir[0]);
 	}
 	else
 	{
 		// Assume working directory
 #if ANKI_OS == ANKI_OS_ANDROID
-		ANKI_CHECK(m_dataDir.create(m_alloc, "$"));
+		m_dataDir.create(m_alloc, "$");
 #else
-		ANKI_CHECK(m_dataDir.create(m_alloc, "./"));
+		m_dataDir.create(m_alloc, "./");
 #endif
 	}
 
@@ -101,23 +101,19 @@ Error ResourceManager::create(Initializer& init)
 }
 
 //==============================================================================
-Error ResourceManager::fixResourceFilename(
+void ResourceManager::fixResourceFilename(
 	const CString& filename,
 	StringAuto& out) const
 {
-	Error err = ErrorCode::NONE;
-
 	// If the filename is in cache then dont append the data path
 	if(filename.find(m_cacheDir.toCString()) != String::NPOS)
 	{
-		err = out.create(filename);
+		out.create(filename);
 	}
 	else
 	{
-		err = out.sprintf("%s%s", &m_dataDir[0], &filename[0]);
+		out.sprintf("%s%s", &m_dataDir[0], &filename[0]);
 	}
-
-	return err;
 }
 
 } // end namespace anki

src/resource/ShaderResource.cpp

@@ -24,7 +24,6 @@ Error ShaderResource::load(const CString& filename, ResourceInitializer& init)
 Error ShaderResource::load(const CString& filename, const CString& extraSrc,
 	ResourceManager& manager)
 {
-	Error err = ErrorCode::NONE;
 	auto alloc = manager._getTempAllocator();
 
 	ProgramPrePreprocessor pars(&manager);
@@ -34,10 +33,10 @@ Error ShaderResource::load(const CString& filename, const CString& extraSrc,
 	StringAuto source(alloc);
 	if(extraSrc.getLength() > 0)
 	{
-		ANKI_CHECK(source.create(extraSrc));
+		source.create(extraSrc);
 	}
 
-	ANKI_CHECK(source.append(pars.getShaderSource()));
+	source.append(pars.getShaderSource());
 
 	// Create
 	GrManager& gr = manager.getGrManager();
@@ -54,7 +53,7 @@ Error ShaderResource::load(const CString& filename, const CString& extraSrc,
 
 	m_type = pars.getShaderType();
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -63,53 +62,52 @@ Error ShaderResource::createToCache(
 	const CString& filenamePrefix, ResourceManager& manager,
 	StringAuto& out)
 {
-	Error err = ErrorCode::NONE;
 	auto alloc = manager._getTempAllocator();
 
 	if(preAppendedSrcCode.getLength() < 1)
 	{
-		return out.create(filename);
+		out.create(filename);
+		return ErrorCode::NONE;
 	}
 
 	// Create suffix
 	StringAuto unique(alloc);
 
-	ANKI_CHECK(unique.create(filename));
-	ANKI_CHECK(unique.append(preAppendedSrcCode));
+	unique.create(filename);
+	unique.append(preAppendedSrcCode);
 
 	U64 h = computeHash(&unique[0], unique.getLength());
 
 	StringAuto suffix(alloc);
-	ANKI_CHECK(suffix.toString(h));
+	suffix.toString(h);
 
 	// Compose cached filename
 	StringAuto newFilename(alloc);
 
-	ANKI_CHECK(
-		newFilename.sprintf(
+	newFilename.sprintf(
 		"%s/%s%s.glsl", 
 		&manager._getCacheDirectory()[0],
 		&filenamePrefix[0],
-		&suffix[0]));
+		&suffix[0]);
 
 	if(fileExists(newFilename.toCString()))
 	{
 		out = std::move(newFilename);
-		return err;
+		return ErrorCode::NONE;
 	}
 
 	// Read file and append code
 	StringAuto src(alloc);
 
 	StringAuto fixedFname(alloc);
-	ANKI_CHECK(manager.fixResourceFilename(filename, fixedFname));
+	manager.fixResourceFilename(filename, fixedFname);
 
 	File file;
 	ANKI_CHECK(file.open(fixedFname.toCString(), File::OpenFlag::READ));
 	ANKI_CHECK(file.readAllText(TempResourceAllocator<char>(alloc), src));
 
 	StringAuto srcfull(alloc);
-	ANKI_CHECK(srcfull.sprintf("%s%s", &preAppendedSrcCode[0], &src[0]));
+	srcfull.sprintf("%s%s", &preAppendedSrcCode[0], &src[0]);
 
 	// Write cached file
 	File f;
@@ -117,7 +115,7 @@ Error ShaderResource::createToCache(
 	ANKI_CHECK(f.writeText("%s\n", &srcfull[0]));
 
 	out = std::move(newFilename);
-	return err;
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/resource/Skeleton.cpp

@@ -27,8 +27,6 @@ Skeleton::~Skeleton()
 //==============================================================================
 Error Skeleton::load(const CString& filename, ResourceInitializer& init)
 {
-	Error err = ErrorCode::NONE;
-
 	m_alloc = init.m_alloc;
 
 	XmlDocument doc;
@@ -47,7 +45,7 @@ Error Skeleton::load(const CString& filename, ResourceInitializer& init)
 	ANKI_CHECK(boneEl.getSiblingElementsCount(bonesCount));
 	++bonesCount;
 
-	ANKI_CHECK(m_bones.create(m_alloc, bonesCount));
+	m_bones.create(m_alloc, bonesCount);
 
 	// Load every bone
 	bonesCount = 0;
@@ -60,7 +58,7 @@ Error Skeleton::load(const CString& filename, ResourceInitializer& init)
 		ANKI_CHECK(boneEl.getChildElement("name", nameEl));
 		CString tmp;
 		ANKI_CHECK(nameEl.getText(tmp));
-		ANKI_CHECK(bone.m_name.create(m_alloc, tmp));
+		bone.m_name.create(m_alloc, tmp);
 
 		// <transform>
 		XmlElement trfEl;
@@ -71,7 +69,7 @@ Error Skeleton::load(const CString& filename, ResourceInitializer& init)
 		ANKI_CHECK(boneEl.getNextSiblingElement("bone", boneEl));
 	} while(boneEl);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/scene/Camera.cpp

@@ -76,48 +76,32 @@ Camera::Camera(SceneGraph* scene, Type type)
 //==============================================================================
 Error Camera::create(const CString& name, Frustum* frustum) 
 {
-	Error err = SceneNode::create(name);
-	if(err) return err;
+	ANKI_CHECK(SceneNode::create(name));
 
 	SceneComponent* comp;
 
 	// Move component
 	comp = getSceneAllocator().newInstance<MoveComponent>(this);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-	err = addComponent(comp, true);
-	if(err) return err;
+	addComponent(comp, true);
 
 	// Feedback component
 	comp = getSceneAllocator().newInstance<CameraMoveFeedbackComponent>(this);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-	err = addComponent(comp, true);
-	if(err) return err;
+	addComponent(comp, true);
 
 	// Frustum component
-	comp = getSceneAllocator().newInstance<FrustumComponent>(this, frustum);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-	err = addComponent(comp, true);
-	if(err) return err;
+	getSceneAllocator().newInstance<FrustumComponent>(this, frustum);
+	addComponent(comp, true);
 
 	// Feedback component #2
 	comp = 
 		getSceneAllocator().newInstance<CameraFrustumFeedbackComponent>(this);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-	err = addComponent(comp, true);
-	if(err) return err;
+	addComponent(comp, true);
 
 	// Spatial component
 	comp = getSceneAllocator().newInstance<SpatialComponent>(this, frustum);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-	err = addComponent(comp, true);
-	if(err) return err;
+	addComponent(comp, true);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/scene/Light.cpp

@@ -60,40 +60,27 @@ Error Light::create(const CString& name,
 	LightComponent::LightType type,
 	CollisionShape* shape)
 {
-	Error err = SceneNode::create(name);
-	if(err) return err;
+	ANKI_CHECK(SceneNode::create(name));
 
 	SceneComponent* comp;
 
 	// Move component
 	comp = getSceneAllocator().newInstance<MoveComponent>(this);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY; 
-
-	err = addComponent(comp, true);
-	if(err) return err;
+	addComponent(comp, true);
 
 	// Light component
 	comp = getSceneAllocator().newInstance<LightComponent>(this, type);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY; 
-
-	err = addComponent(comp, true);
-	if(err) return err;
+	addComponent(comp, true);
 
 	// Feedback component
 	comp = getSceneAllocator().newInstance<LightFeedbackComponent>(this);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY; 
-
-	err = addComponent(comp, true);
-	if(err) return err;
+	addComponent(comp, true);
 
 	// Spatial component
 	comp = getSceneAllocator().newInstance<SpatialComponent>(this, shape);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY; 
+	addComponent(comp, true);
 
-	err = addComponent(comp, true);
-	if(err) return err;
-
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -150,37 +137,21 @@ void Light::onShapeUpdateCommon(LightComponent& light)
 Error Light::loadLensFlare(const CString& filename)
 {
 	ANKI_ASSERT(tryGetComponent<LensFlareComponent>() == nullptr);
-	Error err = ErrorCode::NONE;
 
 	LensFlareComponent* flareComp = 
 		getSceneAllocator().newInstance<LensFlareComponent>(this);
 	
-	if(flareComp)
-	{
-		err = flareComp->create(filename);
-	}
-	else
-	{
-		err = ErrorCode::OUT_OF_MEMORY;
-	}
-
-	if(!err)
-	{
-		err = addComponent(flareComp);
-	}
-
-	if(!err)
-	{
-		flareComp->setAutomaticCleanup(true);
-	}
-
-	// Clean up on any error
-	if(err && flareComp)
+	Error err = ErrorCode::NONE;
+	if(err = flareComp->create(filename))
 	{
 		getSceneAllocator().deleteInstance(flareComp);
+		return err;
 	}
 
-	return err;
+	addComponent(flareComp);
+	flareComp->setAutomaticCleanup(true);
+
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -260,20 +231,16 @@ SpotLight::SpotLight(SceneGraph* scene)
 //==============================================================================
 Error SpotLight::create(const CString& name)
 {
-	Error err = Light::create(
-		name, LightComponent::LightType::SPOT, &m_frustum);
-	if(err) return err;
+	ANKI_CHECK(Light::create(
+		name, LightComponent::LightType::SPOT, &m_frustum));
 
 	FrustumComponent* fr = 
 		getSceneAllocator().newInstance<FrustumComponent>(this, &m_frustum);
-	if(fr == nullptr) return ErrorCode::OUT_OF_MEMORY;
 
 	fr->setShadowCaster(true);
-	
-	err = addComponent(fr, true);
-	if(err) return err;
+	addComponent(fr, true);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/scene/ModelNode.cpp

@@ -70,31 +70,25 @@ Error ModelPatchNode::create(const CString& name,
 	const ModelPatchBase* modelPatch)
 {
 	ANKI_ASSERT(modelPatch);
-	Error err = SceneNode::create(name);
-	if(err) return err;
+	ANKI_CHECK(SceneNode::create(name));
 
 	m_modelPatch = modelPatch;
 
 	// Spatial component
 	SceneComponent* comp = getSceneAllocator().newInstance<SpatialComponent>(
 		this, &m_obb);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
 
-	err = addComponent(comp, true);
-	if(err) return err;
+	addComponent(comp, true);
 
 	// Render component
 	RenderComponent* rcomp = 
 		getSceneAllocator().newInstance<ModelPatchRenderComponent>(this);
 	comp = rcomp;
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
 
-	err = addComponent(comp, true);
-	if(err) return err;
+	addComponent(comp, true);
+	ANKI_CHECK(rcomp->create());
 
-	err = rcomp->create();
-
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -165,11 +159,10 @@ void ModelPatchNode::getRenderWorldTransform(U index, Transform& trf)
 }
 
 //==============================================================================
-Error ModelPatchNode::updateInstanceSpatials(
+void ModelPatchNode::updateInstanceSpatials(
 	const MoveComponent* instanceMoves[],
 	U32 instanceMovesCount)
 {
-	Error err = ErrorCode::NONE;
 	Bool fullUpdate = false;
 
 	const U oldSize = m_spatials.getSize();
@@ -181,8 +174,7 @@ Error ModelPatchNode::updateInstanceSpatials(
 		
 		fullUpdate = true;
 		
-		err = m_spatials.resize(getSceneAllocator(), newSize);
-		if(err)	return err;
+		m_spatials.resize(getSceneAllocator(), newSize);
 
 		U diff = newSize - oldSize;
 		U index = oldSize;
@@ -190,11 +182,8 @@ Error ModelPatchNode::updateInstanceSpatials(
 		{
 			ObbSpatialComponent* newSpatial = getSceneAllocator().
 				newInstance<ObbSpatialComponent>(this);
-			if(newSpatial == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-			err = addComponent(newSpatial);
-			if(err)	return err;
 
+			addComponent(newSpatial);
 			m_spatials[index++] = newSpatial;
 		}
 	}
@@ -225,8 +214,6 @@ Error ModelPatchNode::updateInstanceSpatials(
 			sp.setSpatialOrigin(inst.getWorldTransform().getOrigin());
 		}
 	}
-
-	return err;
 }
 
 //==============================================================================
@@ -311,19 +298,14 @@ ModelNode::~ModelNode()
 //==============================================================================
 Error ModelNode::create(const CString& name, const CString& modelFname)
 {
-	Error err = ErrorCode::NONE;
-
-	err = SceneNode::create(name);
-	if(err) return err;
+	ANKI_CHECK(SceneNode::create(name));
 
 	SceneComponent* comp;
 
-	err = m_model.load(modelFname, &getResourceManager());
-	if(err) return err;
+	ANKI_CHECK(m_model.load(modelFname, &getResourceManager()));
 
-	err = m_modelPatches.create(
+	m_modelPatches.create(
 		getSceneAllocator(), m_model->getModelPatches().getSize(), nullptr);
-	if(err) return err;
 
 	U count = 0;
 	auto it = m_model->getModelPatches().getBegin();
@@ -331,12 +313,10 @@ Error ModelNode::create(const CString& name, const CString& modelFname)
 	for(; it != end; it++)
 	{
 		ModelPatchNode* mpn;
-		err = getSceneGraph().newSceneNode(CString(), mpn, *it);
-		if(err) return err;
+		ANKI_CHECK(getSceneGraph().newSceneNode(CString(), mpn, *it));
 
 		m_modelPatches[count++] = mpn;
-		err = addChild(mpn);
-		if(err) return err;
+		addChild(mpn);
 	}
 
 	// Load rigid body
@@ -349,55 +329,39 @@ Error ModelNode::create(const CString& name, const CString& modelFname)
 
 		m_body = 
 			getSceneGraph()._getPhysicsWorld().newBody<PhysicsBody>(init);
-		if(m_body == nullptr) return ErrorCode::OUT_OF_MEMORY;
 
 		// Body component
 		comp = getSceneAllocator().newInstance<BodyComponent>(this, m_body);
-		if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-		err = addComponent(comp, true);
-		if(err) return err;
+		addComponent(comp, true);
 
 		// Feedback component
 		comp = 
 			getSceneAllocator().newInstance<ModelBodyFeedbackComponent>(this);
-		if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-		err = addComponent(comp, true);
-		if(err) return err;
+		addComponent(comp, true);
 	}
 
 	// Move component
 	comp = getSceneAllocator().newInstance<MoveComponent>(this);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-	err = addComponent(comp, true);
-	if(err) return err;
+	addComponent(comp, true);
 
 	// Feedback component
 	comp = getSceneAllocator().newInstance<ModelMoveFeedbackComponent>(this);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-	err = addComponent(comp, true);
-	if(err) return err;
+	addComponent(comp, true);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
 Error ModelNode::frameUpdate(F32, F32)
 {
-	Error err = ErrorCode::NONE;
-
 	// Gather the move components of the instances
 	DArrayAuto<const MoveComponent*> instanceMoves(getSceneFrameAllocator());
 	U instanceMovesCount = 0;
 	Timestamp instancesTimestamp = 0;
 
-	err = instanceMoves.create(64);
-	if(err)	return err;
+	instanceMoves.create(64);
 
-	err = visitChildren([&](SceneNode& sn) -> Error
+	Error err = visitChildren([&](SceneNode& sn) -> Error
 	{
 		if(sn.tryGetComponent<InstanceComponent>())
 		{
@@ -411,6 +375,7 @@ Error ModelNode::frameUpdate(F32, F32)
 
 		return ErrorCode::NONE;
 	});
+	(void)err;
 
 	// If having instances
 	if(instanceMovesCount > 0)
@@ -420,8 +385,7 @@ Error ModelNode::frameUpdate(F32, F32)
 		if(instanceMovesCount != m_transforms.getSize())
 		{
 			fullUpdate = true;
-			err = m_transforms.resize(getSceneAllocator(), instanceMovesCount);
-			if(err) return err;
+			m_transforms.resize(getSceneAllocator(), instanceMovesCount);
 		}
 
 		if(fullUpdate || m_transformsTimestamp < instancesTimestamp)
@@ -439,13 +403,12 @@ Error ModelNode::frameUpdate(F32, F32)
 		auto end = m_modelPatches.getEnd();
 		for(; it != end; ++it)
 		{
-			err = (*it)->updateInstanceSpatials(
+			(*it)->updateInstanceSpatials(
 				&instanceMoves[0], instanceMovesCount);
-			return err;
 		}
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/scene/ParticleEmitter.cpp

@@ -287,39 +287,30 @@ ParticleEmitter::~ParticleEmitter()
 Error ParticleEmitter::create(
 	const CString& name, const CString& filename)
 {
-	Error err = SceneNode::create(name);
+	ANKI_CHECK(SceneNode::create(name));
 	SceneComponent* comp;
 
 	// Load resource
-	err = m_particleEmitterResource.load(filename, &getResourceManager());
-	if(err) return err;
+	ANKI_CHECK(m_particleEmitterResource.load(filename, &getResourceManager()));
 
 	// Move component
 	comp = getSceneAllocator().newInstance<MoveComponent>(this);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
 
-	err = addComponent(comp);
-	if(err) return err;
+	addComponent(comp);
 	comp->setAutomaticCleanup(true);
 
 	// Spatial component
 	comp = getSceneAllocator().newInstance<SpatialComponent>(this, &m_obb);
-	if(comp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-	err = addComponent(comp);
-	if(err) return err;
+	addComponent(comp);
 	comp->setAutomaticCleanup(true);
 
 	// Render component
 	ParticleEmitterRenderComponent* rcomp = 
 		getSceneAllocator().newInstance<ParticleEmitterRenderComponent>(this);
-	if(rcomp == nullptr) return ErrorCode::OUT_OF_MEMORY;
 
-	err = rcomp->create();
-	if(err) return err;
+	ANKI_CHECK(rcomp->create());
 
-	err = addComponent(comp);
-	if(err) return err;
+	addComponent(comp);
 	comp->setAutomaticCleanup(true);
 
 	// Other
@@ -335,33 +326,29 @@ Error ParticleEmitter::create(
 
 	if(m_usePhysicsEngine)
 	{
-		err = createParticlesSimulation(&getSceneGraph());
+		createParticlesSimulation(&getSceneGraph());
 		m_simulationType = SimulationType::PHYSICS_ENGINE;
 	}
 	else
 	{
-		err = createParticlesSimpleSimulation();
+		createParticlesSimpleSimulation();
 		m_simulationType = SimulationType::SIMPLE;
 	}
 
-	if(err) return err;
-
 	// Create the vertex buffer and object
 	CommandBufferHandle cmd;
 	GrManager& gr = getSceneGraph().getGrManager();
-	err = cmd.create(&gr);
-	if(err) return err;
+	ANKI_CHECK(cmd.create(&gr));
 
 	PtrSize buffSize = m_maxNumOfParticles * VERT_SIZE * 3;
-	err = m_vertBuff.create(cmd, GL_ARRAY_BUFFER, nullptr, buffSize, 
-		GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
-	if(err) return err;
+	ANKI_CHECK(m_vertBuff.create(cmd, GL_ARRAY_BUFFER, nullptr, buffSize, 
+		GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
 
 	cmd.finish(); /// TODO Optimize serialization
 	m_vertBuffMapping = 
 		static_cast<U8*>(m_vertBuff.getPersistentMappingAddress());
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -418,7 +405,7 @@ void ParticleEmitter::onMoveComponentUpdate(MoveComponent& move)
 }
 
 //==============================================================================
-Error ParticleEmitter::createParticlesSimulation(SceneGraph* scene)
+void ParticleEmitter::createParticlesSimulation(SceneGraph* scene)
 {
 #if 0
 	collShape = getSceneAllocator().newInstance<btSphereShape>(particle.size);
@@ -444,40 +431,25 @@ Error ParticleEmitter::createParticlesSimulation(SceneGraph* scene)
 		particles.push_back(part);
 	}
 #endif
-	return ErrorCode::NONE;
 }
 
 //==============================================================================
-Error ParticleEmitter::createParticlesSimpleSimulation()
+void ParticleEmitter::createParticlesSimpleSimulation()
 {
-	Error err = m_particles.create(getSceneAllocator(), m_maxNumOfParticles);
-	if(err)
-	{
-		return err;
-	}
+	m_particles.create(getSceneAllocator(), m_maxNumOfParticles);
 
 	for(U i = 0; i < m_maxNumOfParticles; i++)
 	{
 		ParticleSimple* part = 
 			getSceneAllocator().newInstance<ParticleSimple>();
 
-		if(part)
-		{
-			part->m_size = 
-				getRandom(m_particle.m_size, m_particle.m_sizeDeviation);
-			part->m_alpha = 
-				getRandom(m_particle.m_alpha, m_particle.m_alphaDeviation);
+		part->m_size = 
+			getRandom(m_particle.m_size, m_particle.m_sizeDeviation);
+		part->m_alpha = 
+			getRandom(m_particle.m_alpha, m_particle.m_alphaDeviation);
 
-			m_particles[i] = part;
-		}
-		else
-		{
-			err = ErrorCode::OUT_OF_MEMORY;
-			break;
-		}
+		m_particles[i] = part;
 	}
-
-	return err;
 }
 
 //==============================================================================

src/scene/PlayerNode.cpp

@@ -144,11 +144,7 @@ PlayerNode::~PlayerNode()
 //==============================================================================
 Error PlayerNode::create(const CString& name, const Vec4& position)
 {
-	Error err = SceneNode::create(name);
-	if(err)
-	{
-		return err;
-	}
+	ANKI_CHECK(SceneNode::create(name));
 
 	// Create physics object
 	PhysicsPlayerController::Initializer init;
@@ -160,57 +156,21 @@ Error PlayerNode::create(const CString& name, const Vec4& position)
 	// Player controller component
 	comp = getSceneAllocator().newInstance<PlayerControllerComponent>(
 		this, m_player);
-	if(comp == nullptr)
-	{
-		return ErrorCode::OUT_OF_MEMORY; 
-	}
-
-	err = addComponent(comp, true);
-	if(err)
-	{
-		return err;
-	}
+	addComponent(comp, true);
 
 	// Feedback component
 	comp = getSceneAllocator().newInstance<PlayerNodeFeedbackComponent>(this);
-	if(comp == nullptr)
-	{
-		return ErrorCode::OUT_OF_MEMORY; 
-	}
-
-	err = addComponent(comp, true);
-	if(err)
-	{
-		return err;
-	}
+	addComponent(comp, true);
 
 	// Move component
 	comp = getSceneAllocator().newInstance<MoveComponent>(this);
-	if(comp == nullptr)
-	{
-		return ErrorCode::OUT_OF_MEMORY; 
-	}
-
-	err = addComponent(comp, true);
-	if(err)
-	{
-		return err;
-	}
+	addComponent(comp, true);
 
 	// Feedback component #2
 	comp = getSceneAllocator().newInstance<PlayerNodeFeedbackComponent2>(this);
-	if(comp == nullptr)
-	{
-		return ErrorCode::OUT_OF_MEMORY; 
-	}
-
-	err = addComponent(comp, true);
-	if(err)
-	{
-		return err;
-	}
+	addComponent(comp, true);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/scene/RenderComponent.cpp

@@ -123,18 +123,18 @@ Error RenderComponent::create()
 	vis.m_count = &count;
 	vis.m_alloc = m_alloc;
 
-	Error err = m_vars.create(m_alloc, mtl.getVariables().getSize());
+	m_vars.create(m_alloc, mtl.getVariables().getSize());
 
 	auto it = mtl.getVariables().getBegin();
 	auto end = mtl.getVariables().getEnd();
-	for(; !err && it != end; it++)
+	for(; it != end; it++)
 	{
 		const MaterialVariable* mv = (*it);
 		vis.m_mvar = mv;
-		err = mv->acceptVisitor(vis);
+		ANKI_CHECK(mv->acceptVisitor(vis));
 	}
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 }  // end namespace anki

src/scene/SceneGraph.cpp

@@ -154,14 +154,10 @@ Error SceneGraph::registerNode(SceneNode* node)
 	}
 
 	// Add to vector
-	Error err = m_nodes.pushBack(m_alloc, node);
+	m_nodes.pushBack(m_alloc, node);
+	++m_nodesCount;
 
-	if(!err)
-	{
-		++m_nodesCount;
-	}
-
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================

src/scene/SceneNode.cpp

@@ -16,7 +16,8 @@ SceneNode::SceneNode(SceneGraph* scene)
 //==============================================================================
 Error SceneNode::create(const CString& name)
 {
-	return m_name.create(getSceneAllocator(), name);
+	m_name.create(getSceneAllocator(), name);
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -97,35 +98,28 @@ U32 SceneNode::getLastUpdateFrame() const
 }
 
 //==============================================================================
-Error SceneNode::addComponent(SceneComponent* comp, Bool transferOwnership)
+void SceneNode::addComponent(SceneComponent* comp, Bool transferOwnership)
 {
 	ANKI_ASSERT(comp);
-	Error err = ErrorCode::NONE;
 
 #if ANKI_ASSERTIONS
-	err = iterateComponents([&](const SceneComponent& bcomp) -> Error
+	Error err = iterateComponents([&](const SceneComponent& bcomp) -> Error
 	{
 		ANKI_ASSERT(comp != &bcomp);
 		return ErrorCode::NONE;
 	});
+	(void)err;
 #endif
 
 	if(m_components.getSize() < m_componentsCount + 1u)
 	{
 		// Not enough room
 		const U extra = 2;
-		err = m_components.resize(
-			getSceneAllocator(), m_componentsCount + 1 + extra);
-	}
-
-	if(!err)
-	{
-		m_components[m_componentsCount++] = comp;
-
-		comp->setAutomaticCleanup(transferOwnership);
+		m_components.resize(getSceneAllocator(), m_componentsCount + 1 + extra);
 	}
 
-	return err;
+	m_components[m_componentsCount++] = comp;
+	comp->setAutomaticCleanup(transferOwnership);
 }
 
 //==============================================================================

src/scene/Sector.cpp

@@ -41,9 +41,8 @@ Error PortalSectorBase::create(const CString& name, const CString& modelFname)
 	// Create move component
 	SceneComponent* comp = 
 		getSceneAllocator().newInstance<MoveComponent>(this);
-	ANKI_CHECK_OOM(comp);
 
-	ANKI_CHECK(addComponent(comp, true));
+	addComponent(comp, true);
 
 #if 0
 	// Load mesh 
@@ -109,7 +108,7 @@ Portal::~Portal()
 Error Portal::create(const CString& name, const CString& modelFname)
 {
 	ANKI_CHECK(PortalSectorBase::create(name, modelFname));
-	ANKI_CHECK(getSectorGroup().m_portals.pushBack(getSceneAllocator(), this));
+	getSectorGroup().m_portals.pushBack(getSceneAllocator(), this);
 	return ErrorCode::NONE;
 }
 
@@ -136,8 +135,8 @@ Error Portal::frameUpdate(F32 prevUpdateTime, F32 crntTime)
 
 			if(collide)
 			{
-				ANKI_CHECK(tryAddSector(sector));
-				ANKI_CHECK(sector->tryAddPortal(this));
+				tryAddSector(sector);
+				sector->tryAddPortal(this);
 			}
 			else
 			{
@@ -151,7 +150,7 @@ Error Portal::frameUpdate(F32 prevUpdateTime, F32 crntTime)
 }
 
 //==============================================================================
-Error Portal::tryAddSector(Sector* sector)
+void Portal::tryAddSector(Sector* sector)
 {
 	auto it = m_sectors.getBegin();
 	auto end = m_sectors.getEnd();
@@ -160,11 +159,11 @@ Error Portal::tryAddSector(Sector* sector)
 		if(*it == sector)
 		{
 			// Already there, return
-			return ErrorCode::NONE;
+			return;
 		}
 	}
 
-	return m_sectors.pushBack(getSceneAllocator(), sector);
+	m_sectors.pushBack(getSceneAllocator(), sector);
 }
 
 //==============================================================================
@@ -224,12 +223,12 @@ Sector::~Sector()
 Error Sector::create(const CString& name, const CString& modelFname)
 {
 	ANKI_CHECK(PortalSectorBase::create(name, modelFname));
-	ANKI_CHECK(getSectorGroup().m_sectors.pushBack(getSceneAllocator(), this));
+	getSectorGroup().m_sectors.pushBack(getSceneAllocator(), this);
 	return ErrorCode::NONE;
 }
 
 //==============================================================================
-Error Sector::tryAddPortal(Portal* portal)
+void Sector::tryAddPortal(Portal* portal)
 {
 	ANKI_ASSERT(portal);
 
@@ -240,11 +239,11 @@ Error Sector::tryAddPortal(Portal* portal)
 		if(*it == portal)
 		{
 			// Already there, return
-			return ErrorCode::NONE;
+			return;
 		}
 	}
 
-	return m_portals.pushBack(getSceneAllocator(), portal);
+	m_portals.pushBack(getSceneAllocator(), portal);
 }
 
 //==============================================================================
@@ -265,7 +264,7 @@ void Sector::tryRemovePortal(Portal* portal)
 }
 
 //==============================================================================
-Error Sector::tryAddSpatialComponent(SpatialComponent* sp)
+void Sector::tryAddSpatialComponent(SpatialComponent* sp)
 {
 	ANKI_ASSERT(sp);
 
@@ -282,7 +281,7 @@ Error Sector::tryAddSpatialComponent(SpatialComponent* sp)
 			ANKI_ASSERT(findSpatialComponent(sp) != m_spatials.getEnd()
 				&& "Spatial has reference to sector but sector not");
 #endif
-			return ErrorCode::NONE;
+			return;
 		}
 	}
 	
@@ -291,14 +290,8 @@ Error Sector::tryAddSpatialComponent(SpatialComponent* sp)
 
 	ANKI_ASSERT(findSpatialComponent(sp) == m_spatials.getEnd());
 
-	Error err = m_spatials.pushBack(getSceneAllocator(), sp);
-
-	if(!err)
-	{
-		err = sp->getSectorInfo().pushBack(getSceneAllocator(), this);
-	}
-
-	return err;
+	m_spatials.pushBack(getSceneAllocator(), sp);
+	sp->getSectorInfo().pushBack(getSceneAllocator(), this);
 }
 
 //==============================================================================
@@ -378,8 +371,8 @@ Error Sector::frameUpdate(F32 prevUpdateTime, F32 crntTime)
 
 			if(collide)
 			{
-				ANKI_CHECK(portal->tryAddSector(this));
-				ANKI_CHECK(tryAddPortal(portal));
+				portal->tryAddSector(this);
+				tryAddPortal(portal);
 			}
 			else
 			{
@@ -397,14 +390,12 @@ Error Sector::frameUpdate(F32 prevUpdateTime, F32 crntTime)
 //==============================================================================
 
 //==============================================================================
-Error SectorGroup::spatialUpdated(SpatialComponent* sp)
+void SectorGroup::spatialUpdated(SpatialComponent* sp)
 {
-	Error err = ErrorCode::NONE;
-
 	// Iterate all sectors and bin the spatial
 	auto it = m_sectors.getBegin();
 	auto end = m_sectors.getEnd();
-	for(; it != end && !err; ++it)
+	for(; it != end; ++it)
 	{
 		Sector& sector = *(*it);
 
@@ -413,15 +404,13 @@ Error SectorGroup::spatialUpdated(SpatialComponent* sp)
 
 		if(collide)	
 		{
-			err = sector.tryAddSpatialComponent(sp);
+			sector.tryAddSpatialComponent(sp);
 		}
 		else
 		{
 			sector.tryRemoveSpatialComponent(sp);
 		}
 	}
-
-	return err;
 }
 
 //==============================================================================
@@ -437,13 +426,11 @@ void SectorGroup::spatialDeleted(SpatialComponent* sp)
 }
 
 //==============================================================================
-Error SectorGroup::findVisibleSectors(
+void SectorGroup::findVisibleSectors(
 	const FrustumComponent& frc,
 	List<Sector*>& visibleSectors,
 	U& spatialsCount)
 {
-	Error err = ErrorCode::NONE;
-
 	// Find the sector the eye is in
 	Sphere eye(frc.getFrustumOrigin(), frc.getFrustum().getNear());
 
@@ -462,12 +449,12 @@ Error SectorGroup::findVisibleSectors(
 		// eye outside all sectors, find those it collides
 
 		it = m_sectors.getBegin();
-		for(; it != end && !err; ++it)
+		for(; it != end; ++it)
 		{
 			Sector& s = *(*it);
 			if(frc.insideFrustum(s.getBoundingShape()))
 			{
-				err = findVisibleSectorsInternal(
+				findVisibleSectorsInternal(
 					frc, s, visibleSectors, spatialsCount);
 			}
 		}
@@ -475,21 +462,18 @@ Error SectorGroup::findVisibleSectors(
 	else
 	{
 		// eye inside a sector
-		err = findVisibleSectorsInternal(
+		findVisibleSectorsInternal(
 			frc, *(*it), visibleSectors, spatialsCount);
 	}
-
-	return err;
 }
 
 //==============================================================================
-Error SectorGroup::findVisibleSectorsInternal(
+void SectorGroup::findVisibleSectorsInternal(
 	const FrustumComponent& frc,
 	Sector& s,
 	List<Sector*>& visibleSectors,
 	U& spatialsCount)
 {
-	Error err = ErrorCode::NONE;
 	auto alloc = m_scene->getFrameAllocator();
 
 	// Check if "s" is already there
@@ -500,47 +484,45 @@ Error SectorGroup::findVisibleSectorsInternal(
 		if(*it == &s)
 		{
 			// Sector already there, skip
-			return ErrorCode::NONE;
+			return;
 		}
 	}
 
 	// Sector not in the list, push it
-	ANKI_CHECK(visibleSectors.pushBack(alloc, &s));
+	visibleSectors.pushBack(alloc, &s);
 	spatialsCount += s.m_spatials.getSize();
 
 	// Check visible portals
 	auto itp = s.m_portals.getBegin();
 	auto itend = s.m_portals.getEnd();
-	for(; itp != itend && !err; ++itp)
+	for(; itp != itend; ++itp)
 	{
 		Portal& p = *(*itp);
 		if(frc.insideFrustum(p.getBoundingShape()))
 		{
 			it = p.m_sectors.getBegin();
 			end = p.m_sectors.getEnd();
-			for(; it != end && !err; ++it)
+			for(; it != end; ++it)
 			{
 				if(*it != &s)
 				{
-					err = findVisibleSectorsInternal(
+					findVisibleSectorsInternal(
 						frc, *(*it), visibleSectors, spatialsCount);
 				}
 			}
 		}
 	}
-
-	return err;
 }
 
 //==============================================================================
-Error SectorGroup::prepareForVisibilityTests(const FrustumComponent& frc)
+void SectorGroup::prepareForVisibilityTests(const FrustumComponent& frc)
 {
 	auto alloc = m_scene->getFrameAllocator();
 
 	// Find visible sectors
 	List<Sector*> visSectors;
 	U spatialsCount = 0;
-	ANKI_CHECK(findVisibleSectors(frc, visSectors, spatialsCount));
+	findVisibleSectors(frc, visSectors, spatialsCount);
 
 	// Initiate storage of nodes
 	m_visibleNodes = reinterpret_cast<SceneNode**>(
@@ -570,8 +552,6 @@ Error SectorGroup::prepareForVisibilityTests(const FrustumComponent& frc)
 			visibleNodes.getBegin(), 
 			visibleNodes.getBegin() + nodesCount);
 	}
-
-	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/scene/StaticGeometryNode.cpp

@@ -48,25 +48,18 @@ Error StaticGeometryPatchNode::create(
 	const CString& name, const ModelPatchBase* modelPatch)
 {
 	ANKI_ASSERT(modelPatch);
-	Error err = ErrorCode::NONE;
 
 	m_modelPatch = modelPatch;
-
-	err = SceneNode::create(name);
-	if(err) return err;
+	ANKI_CHECK(SceneNode::create(name));
 
 	// Create spatial components
-	for(U i = 1; i < m_modelPatch->getSubMeshesCount() && !err; i++)
+	for(U i = 1; i < m_modelPatch->getSubMeshesCount(); i++)
 	{
 		SpatialComponent* spatial =
 			getSceneAllocator().newInstance<SpatialComponent>(
 			this, &m_modelPatch->getBoundingShapeSub(i));
 
-		if(spatial == nullptr) return ErrorCode::OUT_OF_MEMORY;
-
-
-		err = addComponent(spatial);
-		if(err) return err;
+		addComponent(spatial);
 
 		spatial->setSpatialOrigin(
 			m_modelPatch->getBoundingShapeSub(i).getCenter());
@@ -76,12 +69,9 @@ Error StaticGeometryPatchNode::create(
 	// Create render component
 	RenderComponent* rcomp = 
 		getSceneAllocator().newInstance<StaticGeometryRenderComponent>(this);
-	if(rcomp == nullptr) return ErrorCode::OUT_OF_MEMORY;
-	
-	err = addComponent(rcomp);
-	if(err) return err;
+	addComponent(rcomp);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -159,11 +149,7 @@ Error StaticGeometryNode::create(const CString& name, const CString& filename)
 		{
 			StringAuto newname(getSceneAllocator());
 			
-			err = newname.sprintf("%s_%u", &name[0], i);
-			if(err)
-			{
-				break;
-			}
+			newname.sprintf("%s_%u", &name[0], i);
 
 			StaticGeometryPatchNode* node;
 			err = getSceneGraph().newSceneNode<StaticGeometryPatchNode>(

src/scene/Visibility.cpp

@@ -75,12 +75,9 @@ public:
 	VisibilityShared* m_shared;
 
 	/// Test a frustum component
-	ANKI_USE_RESULT Error test(SceneNode& testedNode,
-		U32 threadId, PtrSize threadsCount);
+	void test(SceneNode& testedNode, U32 threadId, PtrSize threadsCount);
 
-	ANKI_USE_RESULT Error combineTestResults(
-		FrustumComponent& frc,
-		PtrSize threadsCount);
+	void combineTestResults(FrustumComponent& frc, PtrSize threadsCount);
 
 	/// Do the tests
 	Error operator()(U32 threadId, PtrSize threadsCount)
@@ -102,7 +99,7 @@ public:
 			}
 
 			m_shared->m_barrier.wait();
-			ANKI_CHECK(test(*node, threadId, threadsCount));
+			test(*node, threadId, threadsCount);
 		}
 
 		return ErrorCode::NONE;
@@ -110,11 +107,9 @@ public:
 };
 
 //==============================================================================
-Error VisibilityTestTask::test(SceneNode& testedNode, 
+void VisibilityTestTask::test(SceneNode& testedNode, 
 	U32 threadId, PtrSize threadsCount)
 {
-	Error err = ErrorCode::NONE;
-
 	FrustumComponent& testedFr = 
 		testedNode.getComponent<FrustumComponent>();
 	Bool testedNodeShadowCaster = testedFr.getShadowCaster();
@@ -125,8 +120,7 @@ Error VisibilityTestTask::test(SceneNode& testedNode,
 
 	FrustumComponent::VisibilityStats stats = testedFr.getLastVisibilityStats();
 
-	ANKI_CHECK(visible->create(
-		alloc, stats.m_renderablesCount, stats.m_lightsCount, 4));
+	visible->create(alloc, stats.m_renderablesCount, stats.m_lightsCount, 4);
 
 	m_shared->m_testResults[threadId] = visible;
 
@@ -138,11 +132,9 @@ Error VisibilityTestTask::test(SceneNode& testedNode,
 	choseStartEnd(threadId, threadsCount, nodesCount, start, end);
 
 	// Iterate range of nodes
-	err = m_shared->m_scene->iterateSceneNodes(
+	Error err = m_shared->m_scene->iterateSceneNodes(
 		start, end, [&](SceneNode& node) -> Error
 	{
-		Error err = ErrorCode::NONE;
-
 		FrustumComponent* fr = node.tryGetComponent<FrustumComponent>();
 		
 		// Skip if it is the same
@@ -164,7 +156,7 @@ Error VisibilityTestTask::test(SceneNode& testedNode,
 
 		U spIdx = 0;
 		U count = 0;
-		err = node.iterateComponentsOfType<SpatialComponent>(
+		Error err = node.iterateComponentsOfType<SpatialComponent>(
 			[&](SpatialComponent& sp)
 		{
 			if(testedFr.insideFrustum(sp))
@@ -182,10 +174,11 @@ Error VisibilityTestTask::test(SceneNode& testedNode,
 
 			return ErrorCode::NONE;
 		});
+		(void)err;
 
 		if(ANKI_UNLIKELY(count == 0))
 		{
-			return err;
+			return ErrorCode::NONE;
 		}
 
 		// Sort sub-spatials
@@ -222,54 +215,51 @@ Error VisibilityTestTask::test(SceneNode& testedNode,
 		{
 			if(r && r->getCastsShadow())
 			{
-				err = visible->moveBackRenderable(alloc, visibleNode);
+				visible->moveBackRenderable(alloc, visibleNode);
 			}
 		}
 		else
 		{
 			if(r)
 			{
-				err = visible->moveBackRenderable(alloc, visibleNode);
+				visible->moveBackRenderable(alloc, visibleNode);
 			}
 
 			LightComponent* l = node.tryGetComponent<LightComponent>();
-			if(!err && l)
+			if(l)
 			{
-				err = visible->moveBackLight(alloc, visibleNode);
+				visible->moveBackLight(alloc, visibleNode);
 
-				if(!err && l->getShadowEnabled() && fr)
+				if(l->getShadowEnabled() && fr)
 				{
 					LockGuard<SpinLock> l(m_shared->m_lock);
-					err = m_shared->m_frustumsList.pushBack(alloc, &node);
+					m_shared->m_frustumsList.pushBack(alloc, &node);
 				}
 			}
 
 			LensFlareComponent* lf = node.tryGetComponent<LensFlareComponent>();
-			if(!err && lf)
+			if(lf)
 			{
-				err = visible->moveBackLensFlare(alloc, visibleNode);
+				visible->moveBackLensFlare(alloc, visibleNode);
 				ANKI_ASSERT(visibleNode.m_node);
 			}
 		}
 		
-		return err;
+		return ErrorCode::NONE;
 	}); // end for
-
-	ANKI_CHECK(err);
+	(void)err;
 
 	// Gather the results from all threads
 	m_shared->m_barrier.wait();
 	
 	if(threadId == 0)
 	{
-		ANKI_CHECK(combineTestResults(testedFr, threadsCount));
+		combineTestResults(testedFr, threadsCount);
 	}
-
-	return err;
 }
 
 //==============================================================================
-ANKI_USE_RESULT Error VisibilityTestTask::combineTestResults(
+void VisibilityTestTask::combineTestResults(
 	FrustumComponent& frc,
 	PtrSize threadsCount)
 {
@@ -291,17 +281,12 @@ ANKI_USE_RESULT Error VisibilityTestTask::combineTestResults(
 
 	// Allocate
 	VisibilityTestResults* visible = alloc.newInstance<VisibilityTestResults>();
-	if(visible == nullptr)
-	{
-		return ErrorCode::OUT_OF_MEMORY;
-	}
 
-	ANKI_CHECK(
-		visible->create(
+	visible->create(
 		alloc, 
 		renderablesSize, 
 		lightsSize,
-		lensFlaresSize));
+		lensFlaresSize);
 
 	visible->prepareMerge();
 
@@ -361,8 +346,6 @@ ANKI_USE_RESULT Error VisibilityTestTask::combineTestResults(
 	// Sort the renderables
 	std::sort(
 		visible->getRenderablesBegin(), visible->getRenderablesEnd(), comp);
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -370,46 +353,29 @@ ANKI_USE_RESULT Error VisibilityTestTask::combineTestResults(
 //==============================================================================
 
 //==============================================================================
-Error VisibilityTestResults::create(
+void VisibilityTestResults::create(
 	SceneFrameAllocator<U8> alloc,
 	U32 renderablesReservedSize,
 	U32 lightsReservedSize,
 	U32 lensFlaresReservedSize)
 {
-	Error err = m_renderables.create(alloc, renderablesReservedSize);
-	
-	if(!err)
-	{
-		err = m_lights.create(alloc, lightsReservedSize);
-	}
-
-	if(!err)
-	{
-		err = m_flares.create(alloc, lensFlaresReservedSize);
-	}
-
-	return err;
+	m_renderables.create(alloc, renderablesReservedSize);
+	m_lights.create(alloc, lightsReservedSize);
+	m_flares.create(alloc, lensFlaresReservedSize);
 }
 
 //==============================================================================
-Error VisibilityTestResults::moveBack(
+void VisibilityTestResults::moveBack(
 	SceneFrameAllocator<U8> alloc, Container& c, U32& count, VisibleNode& x)
 {
-	Error err = ErrorCode::NONE;
-
 	if(count + 1 > c.getSize())
 	{
 		// Need to grow
 		U newSize = (c.getSize() != 0) ? c.getSize() * 2 : 2;
-		err = c.resize(alloc, newSize);
-	}
-
-	if(!err)
-	{
-		c[count++] = x;
+		c.resize(alloc, newSize);
 	}
 
-	return err;
+	c[count++] = x;
 }
 
 //==============================================================================
@@ -424,7 +390,7 @@ Error doVisibilityTests(SceneNode& fsn, SceneGraph& scene, Renderer& r)
 	
 	VisibilityShared shared(threadPool.getThreadsCount());
 	shared.m_scene = &scene;
-	ANKI_CHECK(shared.m_frustumsList.pushBack(scene.getFrameAllocator(), &fsn));
+	shared.m_frustumsList.pushBack(scene.getFrameAllocator(), &fsn);
 
 	Array<VisibilityTestTask, Threadpool::MAX_THREADS> tasks;
 	for(U i = 0; i < threadPool.getThreadsCount(); i++)

src/script/Event.cpp

@@ -50,7 +50,7 @@ static const char* classnameSceneAmbientColorEvent = "SceneAmbientColorEvent";
 template<>
 I64 LuaBinder::getWrappedTypeSignature<SceneAmbientColorEvent>()
 {
-	return -2736282921550252951;
+	return 671577193;
 }
 
 template<>
@@ -77,7 +77,7 @@ static const char* classnameEventManager = "EventManager";
 template<>
 I64 LuaBinder::getWrappedTypeSignature<EventManager>()
 {
-	return -6959305329499243407;
+	return -1078526863;
 }
 
 template<>
@@ -98,7 +98,7 @@ static inline int pwrapEventManagernewSceneAmbientColorEvent(lua_State* l)
 	LuaBinder::checkArgsCount(l, 4);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameEventManager, -6959305329499243407, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameEventManager, -1078526863, ud)) return -1;
 	EventManager* self = static_cast<EventManager*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -109,7 +109,7 @@ static inline int pwrapEventManagernewSceneAmbientColorEvent(lua_State* l)
 	F32 arg1;
 	if(LuaBinder::checkNumber(l, 3, arg1)) return -1;
 	
-	if(LuaBinder::checkUserData(l, 4, "Vec4", 6804478823655046386, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 4, "Vec4", 1033927922, ud)) return -1;
 	Vec4* iarg2 = static_cast<Vec4*>(ud->m_data);
 	const Vec4& arg2(*iarg2);
 	
@@ -128,7 +128,7 @@ static inline int pwrapEventManagernewSceneAmbientColorEvent(lua_State* l)
 	luaL_setmetatable(l, "SceneAmbientColorEvent");
 	ud->m_data = static_cast<void*>(ret);
 	ud->m_gc = false;
-	ud->m_sig = -2736282921550252951;
+	ud->m_sig = 671577193;
 	
 	return 1;
 }
@@ -178,7 +178,7 @@ static inline int pwrapgetEventManager(lua_State* l)
 	luaL_setmetatable(l, "EventManager");
 	ud->m_data = static_cast<void*>(ret);
 	ud->m_gc = false;
-	ud->m_sig = -6959305329499243407;
+	ud->m_sig = -1078526863;
 	
 	return 1;
 }

src/script/Scene.cpp

@@ -50,7 +50,7 @@ static const char* classnameMoveComponent = "MoveComponent";
 template<>
 I64 LuaBinder::getWrappedTypeSignature<MoveComponent>()
 {
-	return 2038493110845313445;
+	return 352588197;
 }
 
 template<>
@@ -71,12 +71,12 @@ static inline int pwrapMoveComponentsetLocalOrigin(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 2038493110845313445, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 352588197, ud)) return -1;
 	MoveComponent* self = static_cast<MoveComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
 	// Pop arguments
-	if(LuaBinder::checkUserData(l, 2, "Vec4", 6804478823655046386, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 2, "Vec4", 1033927922, ud)) return -1;
 	Vec4* iarg0 = static_cast<Vec4*>(ud->m_data);
 	const Vec4& arg0(*iarg0);
 	
@@ -108,7 +108,7 @@ static inline int pwrapMoveComponentgetLocalOrigin(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 2038493110845313445, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 352588197, ud)) return -1;
 	MoveComponent* self = static_cast<MoveComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -121,7 +121,7 @@ static inline int pwrapMoveComponentgetLocalOrigin(lua_State* l)
 	luaL_setmetatable(l, "Vec4");
 	ud->m_data = const_cast<void*>(static_cast<const void*>(&ret));
 	ud->m_gc = false;
-	ud->m_sig = 6804478823655046386;
+	ud->m_sig = 1033927922;
 	
 	return 1;
 }
@@ -148,12 +148,12 @@ static inline int pwrapMoveComponentsetLocalRotation(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 2038493110845313445, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 352588197, ud)) return -1;
 	MoveComponent* self = static_cast<MoveComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
 	// Pop arguments
-	if(LuaBinder::checkUserData(l, 2, "Mat3x4", -2654194732934255869, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 2, "Mat3x4", -222450941, ud)) return -1;
 	Mat3x4* iarg0 = static_cast<Mat3x4*>(ud->m_data);
 	const Mat3x4& arg0(*iarg0);
 	
@@ -185,7 +185,7 @@ static inline int pwrapMoveComponentgetLocalRotation(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 2038493110845313445, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 352588197, ud)) return -1;
 	MoveComponent* self = static_cast<MoveComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -198,7 +198,7 @@ static inline int pwrapMoveComponentgetLocalRotation(lua_State* l)
 	luaL_setmetatable(l, "Mat3x4");
 	ud->m_data = const_cast<void*>(static_cast<const void*>(&ret));
 	ud->m_gc = false;
-	ud->m_sig = -2654194732934255869;
+	ud->m_sig = -222450941;
 	
 	return 1;
 }
@@ -225,7 +225,7 @@ static inline int pwrapMoveComponentsetLocalScale(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 2038493110845313445, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 352588197, ud)) return -1;
 	MoveComponent* self = static_cast<MoveComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -261,7 +261,7 @@ static inline int pwrapMoveComponentgetLocalScale(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 2038493110845313445, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameMoveComponent, 352588197, ud)) return -1;
 	MoveComponent* self = static_cast<MoveComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -308,7 +308,7 @@ static const char* classnameLightComponent = "LightComponent";
 template<>
 I64 LuaBinder::getWrappedTypeSignature<LightComponent>()
 {
-	return 7940823622056993903;
+	return 280814703;
 }
 
 template<>
@@ -329,12 +329,12 @@ static inline int pwrapLightComponentsetDiffuseColor(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
 	// Pop arguments
-	if(LuaBinder::checkUserData(l, 2, "Vec4", 6804478823655046386, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 2, "Vec4", 1033927922, ud)) return -1;
 	Vec4* iarg0 = static_cast<Vec4*>(ud->m_data);
 	const Vec4& arg0(*iarg0);
 	
@@ -366,7 +366,7 @@ static inline int pwrapLightComponentgetDiffuseColor(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -379,7 +379,7 @@ static inline int pwrapLightComponentgetDiffuseColor(lua_State* l)
 	luaL_setmetatable(l, "Vec4");
 	ud->m_data = const_cast<void*>(static_cast<const void*>(&ret));
 	ud->m_gc = false;
-	ud->m_sig = 6804478823655046386;
+	ud->m_sig = 1033927922;
 	
 	return 1;
 }
@@ -406,12 +406,12 @@ static inline int pwrapLightComponentsetSpecularColor(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
 	// Pop arguments
-	if(LuaBinder::checkUserData(l, 2, "Vec4", 6804478823655046386, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 2, "Vec4", 1033927922, ud)) return -1;
 	Vec4* iarg0 = static_cast<Vec4*>(ud->m_data);
 	const Vec4& arg0(*iarg0);
 	
@@ -443,7 +443,7 @@ static inline int pwrapLightComponentgetSpecularColor(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -456,7 +456,7 @@ static inline int pwrapLightComponentgetSpecularColor(lua_State* l)
 	luaL_setmetatable(l, "Vec4");
 	ud->m_data = const_cast<void*>(static_cast<const void*>(&ret));
 	ud->m_gc = false;
-	ud->m_sig = 6804478823655046386;
+	ud->m_sig = 1033927922;
 	
 	return 1;
 }
@@ -483,7 +483,7 @@ static inline int pwrapLightComponentsetRadius(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -519,7 +519,7 @@ static inline int pwrapLightComponentgetRadius(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -554,7 +554,7 @@ static inline int pwrapLightComponentsetDistance(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -590,7 +590,7 @@ static inline int pwrapLightComponentgetDistance(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -625,7 +625,7 @@ static inline int pwrapLightComponentsetInnerAngle(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -661,7 +661,7 @@ static inline int pwrapLightComponentgetInnerAngle(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -696,7 +696,7 @@ static inline int pwrapLightComponentsetOuterAngle(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -732,7 +732,7 @@ static inline int pwrapLightComponentgetOuterAngle(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -767,7 +767,7 @@ static inline int pwrapLightComponentsetShadowEnabled(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -803,7 +803,7 @@ static inline int pwrapLightComponentgetShadowEnabled(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 7940823622056993903, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLightComponent, 280814703, ud)) return -1;
 	LightComponent* self = static_cast<LightComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -858,7 +858,7 @@ static const char* classnameLensFlareComponent = "LensFlareComponent";
 template<>
 I64 LuaBinder::getWrappedTypeSignature<LensFlareComponent>()
 {
-	return -2019248835133422777;
+	return 79708999;
 }
 
 template<>
@@ -879,12 +879,12 @@ static inline int pwrapLensFlareComponentsetFirstFlareSize(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLensFlareComponent, -2019248835133422777, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLensFlareComponent, 79708999, ud)) return -1;
 	LensFlareComponent* self = static_cast<LensFlareComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
 	// Pop arguments
-	if(LuaBinder::checkUserData(l, 2, "Vec2", 6804478823655046388, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 2, "Vec2", 1033927924, ud)) return -1;
 	Vec2* iarg0 = static_cast<Vec2*>(ud->m_data);
 	const Vec2& arg0(*iarg0);
 	
@@ -916,12 +916,12 @@ static inline int pwrapLensFlareComponentsetColorMultiplier(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameLensFlareComponent, -2019248835133422777, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameLensFlareComponent, 79708999, ud)) return -1;
 	LensFlareComponent* self = static_cast<LensFlareComponent*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
 	// Pop arguments
-	if(LuaBinder::checkUserData(l, 2, "Vec4", 6804478823655046386, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 2, "Vec4", 1033927922, ud)) return -1;
 	Vec4* iarg0 = static_cast<Vec4*>(ud->m_data);
 	const Vec4& arg0(*iarg0);
 	
@@ -961,7 +961,7 @@ static const char* classnameSceneNode = "SceneNode";
 template<>
 I64 LuaBinder::getWrappedTypeSignature<SceneNode>()
 {
-	return -2220074417980276571;
+	return 1297776805;
 }
 
 template<>
@@ -982,7 +982,7 @@ static inline int pwrapSceneNodegetName(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameSceneNode, -2220074417980276571, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameSceneNode, 1297776805, ud)) return -1;
 	SceneNode* self = static_cast<SceneNode*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1017,28 +1017,19 @@ static inline int pwrapSceneNodeaddChild(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameSceneNode, -2220074417980276571, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameSceneNode, 1297776805, ud)) return -1;
 	SceneNode* self = static_cast<SceneNode*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
 	// Pop arguments
-	if(LuaBinder::checkUserData(l, 2, "SceneNode", -2220074417980276571, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 2, "SceneNode", 1297776805, ud)) return -1;
 	SceneNode* iarg0 = static_cast<SceneNode*>(ud->m_data);
 	SceneNode* arg0(iarg0);
 	
 	// Call the method
-	Error ret = self->addChild(arg0);
+	self->addChild(arg0);
 	
-	// Push return value
-	if(ANKI_UNLIKELY(ret))
-	{
-		lua_pushstring(l, "Glue code returned an error");
-		return -1;
-	}
-	
-	lua_pushnumber(l, ret);
-	
-	return 1;
+	return 0;
 }
 
 //==============================================================================
@@ -1063,7 +1054,7 @@ static inline int pwrapSceneNodegetMoveComponent(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameSceneNode, -2220074417980276571, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameSceneNode, 1297776805, ud)) return -1;
 	SceneNode* self = static_cast<SceneNode*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1082,7 +1073,7 @@ static inline int pwrapSceneNodegetMoveComponent(lua_State* l)
 	luaL_setmetatable(l, "MoveComponent");
 	ud->m_data = static_cast<void*>(ret);
 	ud->m_gc = false;
-	ud->m_sig = 2038493110845313445;
+	ud->m_sig = 352588197;
 	
 	return 1;
 }
@@ -1109,7 +1100,7 @@ static inline int pwrapSceneNodegetLightComponent(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameSceneNode, -2220074417980276571, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameSceneNode, 1297776805, ud)) return -1;
 	SceneNode* self = static_cast<SceneNode*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1128,7 +1119,7 @@ static inline int pwrapSceneNodegetLightComponent(lua_State* l)
 	luaL_setmetatable(l, "LightComponent");
 	ud->m_data = static_cast<void*>(ret);
 	ud->m_gc = false;
-	ud->m_sig = 7940823622056993903;
+	ud->m_sig = 280814703;
 	
 	return 1;
 }
@@ -1155,7 +1146,7 @@ static inline int pwrapSceneNodegetLensFlareComponent(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameSceneNode, -2220074417980276571, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameSceneNode, 1297776805, ud)) return -1;
 	SceneNode* self = static_cast<SceneNode*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1174,7 +1165,7 @@ static inline int pwrapSceneNodegetLensFlareComponent(lua_State* l)
 	luaL_setmetatable(l, "LensFlareComponent");
 	ud->m_data = static_cast<void*>(ret);
 	ud->m_gc = false;
-	ud->m_sig = -2019248835133422777;
+	ud->m_sig = 79708999;
 	
 	return 1;
 }
@@ -1212,7 +1203,7 @@ static const char* classnameModelNode = "ModelNode";
 template<>
 I64 LuaBinder::getWrappedTypeSignature<ModelNode>()
 {
-	return -1856316251880904290;
+	return 1071294878;
 }
 
 template<>
@@ -1233,7 +1224,7 @@ static inline int pwrapModelNodegetSceneNodeBase(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameModelNode, -1856316251880904290, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameModelNode, 1071294878, ud)) return -1;
 	ModelNode* self = static_cast<ModelNode*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1246,7 +1237,7 @@ static inline int pwrapModelNodegetSceneNodeBase(lua_State* l)
 	luaL_setmetatable(l, "SceneNode");
 	ud->m_data = static_cast<void*>(&ret);
 	ud->m_gc = false;
-	ud->m_sig = -2220074417980276571;
+	ud->m_sig = 1297776805;
 	
 	return 1;
 }
@@ -1280,7 +1271,7 @@ static const char* classnameInstanceNode = "InstanceNode";
 template<>
 I64 LuaBinder::getWrappedTypeSignature<InstanceNode>()
 {
-	return -2063375830923741403;
+	return 799668005;
 }
 
 template<>
@@ -1301,7 +1292,7 @@ static inline int pwrapInstanceNodegetSceneNodeBase(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameInstanceNode, -2063375830923741403, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameInstanceNode, 799668005, ud)) return -1;
 	InstanceNode* self = static_cast<InstanceNode*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1314,7 +1305,7 @@ static inline int pwrapInstanceNodegetSceneNodeBase(lua_State* l)
 	luaL_setmetatable(l, "SceneNode");
 	ud->m_data = static_cast<void*>(&ret);
 	ud->m_gc = false;
-	ud->m_sig = -2220074417980276571;
+	ud->m_sig = 1297776805;
 	
 	return 1;
 }
@@ -1348,7 +1339,7 @@ static const char* classnamePointLight = "PointLight";
 template<>
 I64 LuaBinder::getWrappedTypeSignature<PointLight>()
 {
-	return 3561037663389896020;
+	return 1042566484;
 }
 
 template<>
@@ -1369,7 +1360,7 @@ static inline int pwrapPointLightgetSceneNodeBase(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnamePointLight, 3561037663389896020, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnamePointLight, 1042566484, ud)) return -1;
 	PointLight* self = static_cast<PointLight*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1382,7 +1373,7 @@ static inline int pwrapPointLightgetSceneNodeBase(lua_State* l)
 	luaL_setmetatable(l, "SceneNode");
 	ud->m_data = static_cast<void*>(&ret);
 	ud->m_gc = false;
-	ud->m_sig = -2220074417980276571;
+	ud->m_sig = 1297776805;
 	
 	return 1;
 }
@@ -1409,7 +1400,7 @@ static inline int pwrapPointLightloadLensFlare(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnamePointLight, 3561037663389896020, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnamePointLight, 1042566484, ud)) return -1;
 	PointLight* self = static_cast<PointLight*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1462,7 +1453,7 @@ static const char* classnameSpotLight = "SpotLight";
 template<>
 I64 LuaBinder::getWrappedTypeSignature<SpotLight>()
 {
-	return 7940385212889719421;
+	return -99720579;
 }
 
 template<>
@@ -1483,7 +1474,7 @@ static inline int pwrapSpotLightgetSceneNodeBase(lua_State* l)
 	LuaBinder::checkArgsCount(l, 1);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameSpotLight, 7940385212889719421, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameSpotLight, -99720579, ud)) return -1;
 	SpotLight* self = static_cast<SpotLight*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1496,7 +1487,7 @@ static inline int pwrapSpotLightgetSceneNodeBase(lua_State* l)
 	luaL_setmetatable(l, "SceneNode");
 	ud->m_data = static_cast<void*>(&ret);
 	ud->m_gc = false;
-	ud->m_sig = -2220074417980276571;
+	ud->m_sig = 1297776805;
 	
 	return 1;
 }
@@ -1530,7 +1521,7 @@ static const char* classnameSceneGraph = "SceneGraph";
 template<>
 I64 LuaBinder::getWrappedTypeSignature<SceneGraph>()
 {
-	return -7754439619132389154;
+	return 1298532574;
 }
 
 template<>
@@ -1551,7 +1542,7 @@ static inline int pwrapSceneGraphnewModelNode(lua_State* l)
 	LuaBinder::checkArgsCount(l, 3);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameSceneGraph, -7754439619132389154, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameSceneGraph, 1298532574, ud)) return -1;
 	SceneGraph* self = static_cast<SceneGraph*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1577,7 +1568,7 @@ static inline int pwrapSceneGraphnewModelNode(lua_State* l)
 	luaL_setmetatable(l, "ModelNode");
 	ud->m_data = static_cast<void*>(ret);
 	ud->m_gc = false;
-	ud->m_sig = -1856316251880904290;
+	ud->m_sig = 1071294878;
 	
 	return 1;
 }
@@ -1604,7 +1595,7 @@ static inline int pwrapSceneGraphnewInstanceNode(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameSceneGraph, -7754439619132389154, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameSceneGraph, 1298532574, ud)) return -1;
 	SceneGraph* self = static_cast<SceneGraph*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1627,7 +1618,7 @@ static inline int pwrapSceneGraphnewInstanceNode(lua_State* l)
 	luaL_setmetatable(l, "InstanceNode");
 	ud->m_data = static_cast<void*>(ret);
 	ud->m_gc = false;
-	ud->m_sig = -2063375830923741403;
+	ud->m_sig = 799668005;
 	
 	return 1;
 }
@@ -1654,7 +1645,7 @@ static inline int pwrapSceneGraphnewPointLight(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameSceneGraph, -7754439619132389154, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameSceneGraph, 1298532574, ud)) return -1;
 	SceneGraph* self = static_cast<SceneGraph*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1677,7 +1668,7 @@ static inline int pwrapSceneGraphnewPointLight(lua_State* l)
 	luaL_setmetatable(l, "PointLight");
 	ud->m_data = static_cast<void*>(ret);
 	ud->m_gc = false;
-	ud->m_sig = 3561037663389896020;
+	ud->m_sig = 1042566484;
 	
 	return 1;
 }
@@ -1704,7 +1695,7 @@ static inline int pwrapSceneGraphnewSpotLight(lua_State* l)
 	LuaBinder::checkArgsCount(l, 2);
 	
 	// Get "this" as "self"
-	if(LuaBinder::checkUserData(l, 1, classnameSceneGraph, -7754439619132389154, ud)) return -1;
+	if(LuaBinder::checkUserData(l, 1, classnameSceneGraph, 1298532574, ud)) return -1;
 	SceneGraph* self = static_cast<SceneGraph*>(ud->m_data);
 	ANKI_ASSERT(self != nullptr);
 	
@@ -1727,7 +1718,7 @@ static inline int pwrapSceneGraphnewSpotLight(lua_State* l)
 	luaL_setmetatable(l, "SpotLight");
 	ud->m_data = static_cast<void*>(ret);
 	ud->m_gc = false;
-	ud->m_sig = 7940385212889719421;
+	ud->m_sig = -99720579;
 	
 	return 1;
 }
@@ -1780,7 +1771,7 @@ static inline int pwrapgetSceneGraph(lua_State* l)
 	luaL_setmetatable(l, "SceneGraph");
 	ud->m_data = static_cast<void*>(ret);
 	ud->m_gc = false;
-	ud->m_sig = -7754439619132389154;
+	ud->m_sig = 1298532574;
 	
 	return 1;
 }

src/script/Scene.xml

@@ -153,7 +153,6 @@ static SceneGraph* getSceneGraph(lua_State* l)
 					<args>
 						<arg>SceneNode*</arg>
 					</args>
-					<return>Error</return>
 				</method>
 				<method name="tryGetComponent&lt;MoveComponent&gt;" alias="getMoveComponent">
 					<return>MoveComponent*</return>

src/util/File.cpp

@@ -669,12 +669,8 @@ Error File::readAllText(
 
 	if(size != 0)
 	{
-		err = out.create(alloc, '?', size);
-
-		if(!err)
-		{
-			err = read(&out[0], size);
-		}
+		out.create(alloc, '?', size);
+		err = read(&out[0], size);
 	}
 	else
 	{

src/util/Filesystem.cpp

@@ -8,10 +8,9 @@
 namespace anki {
 
 //==============================================================================
-Error getFileExtension(
+void getFileExtension(
 	const CString& filename, GenericMemoryPoolAllocator<U8> alloc, String& out)
 {
-	Error err = ErrorCode::NONE;
 	const char* pc = std::strrchr(&filename[0], '.');
 
 	out.destroy(alloc);
@@ -25,11 +24,9 @@ Error getFileExtension(
 		++pc;
 		if(*pc != '\0')
 		{
-			err = out.create(alloc, CString(pc));
+			out.create(alloc, CString(pc));
 		}
 	}
-
-	return err;
 }
 
 } // end namespace anki

src/util/FilesystemPosix.cpp

@@ -123,7 +123,8 @@ Error getHomeDirectory(GenericMemoryPoolAllocator<U8> alloc, String& out)
 		return ErrorCode::FUNCTION_FAILED;
 	}
 
-	return out.create(alloc, home);
+	out.create(alloc, home);
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/util/Memory.cpp

@@ -36,6 +36,8 @@ static Signature computeSignature(void* ptr)
 }
 #endif
 
+#define ANKI_OOM_ACTION() ANKI_LOGF("Out of memory")
+
 //==============================================================================
 // Other                                                                       =
 //==============================================================================
@@ -212,7 +214,7 @@ HeapMemoryPool::~HeapMemoryPool()
 }
 
 //==============================================================================
-Error HeapMemoryPool::create(
+void HeapMemoryPool::create(
 	AllocAlignedCallback allocCb, void* allocCbUserData)
 {
 	ANKI_ASSERT(!isCreated());
@@ -225,8 +227,6 @@ Error HeapMemoryPool::create(
 	m_signature = computeSignature(this);
 	m_headerSize = getAlignedRoundUp(MAX_ALIGNMENT, sizeof(Signature));
 #endif
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -254,7 +254,7 @@ void* HeapMemoryPool::allocate(PtrSize size, PtrSize alignment)
 	}
 	else
 	{
-		ANKI_LOGE("Out of memory");
+		ANKI_OOM_ACTION();
 	}
 
 	return mem;
@@ -302,7 +302,7 @@ StackMemoryPool::~StackMemoryPool()
 }
 
 //==============================================================================
-Error StackMemoryPool::create(
+void StackMemoryPool::create(
 	AllocAlignedCallback allocCb, void* allocCbUserData,
 	PtrSize size, Bool ignoreDeallocationErrors, PtrSize alignmentBytes)
 {
@@ -311,8 +311,6 @@ Error StackMemoryPool::create(
 	ANKI_ASSERT(size > 0);
 	ANKI_ASSERT(alignmentBytes > 0);
 
-	Error error = ErrorCode::NONE;
-
 	m_allocCb = allocCb;
 	m_allocCbUserData = allocCbUserData;
 	m_alignmentBytes = alignmentBytes;
@@ -338,11 +336,8 @@ Error StackMemoryPool::create(
 	}
 	else
 	{
-		ANKI_LOGE("Out of memory");
-		error = ErrorCode::OUT_OF_MEMORY;
+		ANKI_OOM_ACTION();
 	}
-
-	return error;
 }
 
 //==============================================================================
@@ -382,7 +377,7 @@ void* StackMemoryPool::allocate(PtrSize size, PtrSize alignment)
 	}
 	else
 	{
-		ANKI_LOGE("Out of memory");
+		ANKI_OOM_ACTION();
 		out = nullptr;
 	}
 
@@ -506,7 +501,7 @@ ChainMemoryPool::~ChainMemoryPool()
 }
 
 //==============================================================================
-Error ChainMemoryPool::create(
+void ChainMemoryPool::create(
 	AllocAlignedCallback allocCb, 
 	void* allocCbUserData,
 	PtrSize initialChunkSize,
@@ -531,8 +526,7 @@ Error ChainMemoryPool::create(
 		m_allocCbUserData, nullptr, sizeof(SpinLock), alignof(SpinLock)));
 	if(!m_lock)
 	{
-		ANKI_LOGE("Out of memory");
-		return ErrorCode::OUT_OF_MEMORY;
+		ANKI_OOM_ACTION();
 	}
 	construct(m_lock);
 
@@ -557,8 +551,6 @@ Error ChainMemoryPool::create(
 	{
 		ANKI_ASSERT(m_initSize < m_maxSize && "Wrong arg");
 	}
-
-	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -784,7 +776,7 @@ ChainMemoryPool::Chunk* ChainMemoryPool::createNewChunk(PtrSize size)
 		}
 		else
 		{
-			ANKI_LOGE("Out of memory");
+			ANKI_OOM_ACTION();
 			destruct(chunk);
 			m_allocCb(m_allocCbUserData, chunk, 0, 0);
 			chunk = nullptr;
@@ -792,7 +784,7 @@ ChainMemoryPool::Chunk* ChainMemoryPool::createNewChunk(PtrSize size)
 	}
 	else
 	{
-		ANKI_LOGE("Out of memory");
+		ANKI_OOM_ACTION();
 	}
 	
 	return chunk;