Removing exceptions

include/anki/resource/Material.h

@@ -108,7 +108,7 @@ template<typename TData>
 class MaterialVariableTemplate: public MaterialVariable
 {
 public:
-	typedef TData Type;
+	using Type = TData;
 
 	/// @name Constructors/Destructor
 	/// @{

include/anki/scene/FrustumComponent.h

@@ -114,22 +114,25 @@ public:
 
 	/// Called when the component gets updated. It should be overriden, by 
 	/// default it does nothing.
-	virtual void onFrustumComponentUpdate(
+	virtual ANKI_USE_RESULT Error onFrustumComponentUpdate(
 		SceneNode& node, F32 prevTime, F32 crntTime)
-	{}
+	{
+		return ErrorCode::NONE;
+	}
 
 	/// @name SceneComponent overrides
 	/// @{
-	Bool update(SceneNode&, F32, F32) override
+	ANKI_USE_RESULT Error update(SceneNode&, F32, F32, Bool& updated) override
 	{
-		Bool out = m_markedForUpdate;
+		updated = m_markedForUpdate;
 		m_markedForUpdate = false;
-		return out;
+		return ErrorCode::NONE;
 	}
 
-	void onUpdate(SceneNode& node, F32 prevTime, F32 crntTime) final
+	ANKI_USE_RESULT Error onUpdate(
+		SceneNode& node, F32 prevTime, F32 crntTime) final
 	{
-		onFrustumComponentUpdate(node, prevTime, crntTime);
+		return onFrustumComponentUpdate(node, prevTime, crntTime);
 	}
 
 	void reset() override

include/anki/scene/MoveComponent.h

@@ -101,9 +101,11 @@ public:
 	}
 
 	/// Called when there is an update in the world transformation.
-	virtual void onMoveComponentUpdate(
+	virtual ANKI_USE_RESULT Error onMoveComponentUpdate(
 		SceneNode& node, F32 prevTime, F32 crntTime)
-	{}
+	{
+		return ErrorCode::NONE;
+	}
 
 	/// @name SceneComponent overrides
 	/// @{
@@ -113,11 +115,12 @@ public:
 	/// @note Don't update if child because we start from roots and go to
 	///       children and we don't want a child to be updated before the
 	///       parent
-	Bool update(SceneNode&, F32, F32) override;
+	ANKI_USE_RESULT Error update(SceneNode&, F32, F32, Bool& updated) override;
 
-	void onUpdate(SceneNode& node, F32 prevTime, F32 crntTime) final
+	ANKI_USE_RESULT Error onUpdate(
+		SceneNode& node, F32 prevTime, F32 crntTime) final
 	{
-		onMoveComponentUpdate(node, prevTime, crntTime);
+		return onMoveComponentUpdate(node, prevTime, crntTime);
 	}
 	/// @}
 

include/anki/scene/RenderComponent.h

@@ -121,7 +121,7 @@ public:
 	}
 
 	/// A custom cleanup method
-	virtual void cleanup(SceneAllocator<U8> alloc) = 0;
+	virtual void destroy(SceneAllocator<U8> alloc) = 0;
 
 protected:
 	const MaterialVariable* m_mvar = nullptr;
@@ -195,7 +195,7 @@ public:
 	}
 
 	/// Call that manually
-	void cleanup(SceneAllocator<U8> alloc)
+	void destroy(SceneAllocator<U8> alloc)
 	{
 		if(m_copy)
 		{
@@ -223,18 +223,19 @@ public:
 class RenderComponent: public SceneComponent
 {
 public:
-	typedef SceneVector<RenderComponentVariable*> Variables;
+	typedef SceneDArray<RenderComponentVariable*> Variables;
 
 	/// @param node Pass node to steal it's allocator
 	RenderComponent(SceneNode* node);
 
 	~RenderComponent();
 
-	Variables::iterator getVariablesBegin()
+	Variables::Iterator getVariablesBegin()
 	{
 		return m_vars.begin();
 	}
-	Variables::iterator getVariablesEnd()
+
+	Variables::Iterator getVariablesEnd()
 	{
 		return m_vars.end();
 	}
@@ -242,7 +243,7 @@ public:
 	/// Build up the rendering.
 	/// Given an array of submeshes that are visible append jobs to the GL
 	/// job chain
-	virtual void buildRendering(RenderingBuildData& data) = 0;
+	virtual ANKI_USE_RESULT Error buildRendering(RenderingBuildData& data) = 0;
 
 	/// Access the material
 	virtual const Material& getMaterial() = 0;
@@ -271,12 +272,16 @@ public:
 
 	/// Iterate variables using a lambda
 	template<typename Func>
-	void iterateVariables(Func func)
+	ANKI_USE_RESULT Error iterateVariables(Func func)
 	{
-		for(auto var : m_vars)
+		Error err = ErrorCode::NONE;
+		Variables::Iterator it = m_vars.getBegin();
+		for(; it != m_vars.getEnd() && !err; it++)
 		{
-			func(*var);
+			err = func(*(*it));
 		}
+
+		return err;
 	}
 
 	static constexpr Type getClassType()
@@ -285,9 +290,10 @@ public:
 	}
 
 protected:
-	void init();
+	ANKI_USE_RESULT Error create();
 
 private:
+	SceneAllocator<U8> m_alloc;
 	Variables m_vars;
 };
 /// @}

include/anki/scene/SceneObject.h

@@ -36,7 +36,7 @@ struct SceneObjectCallbackCollection
 
 /// The base of all scene related objects
 class SceneObject: 
-	private Object<SceneObject, SceneAllocator<SceneObject>, 
+	public Object<SceneObject, SceneAllocator<SceneObject>, 
 	SceneObjectCallbackCollection>
 {
 public:
@@ -57,12 +57,6 @@ public:
 
 	virtual ~SceneObject();
 
-	// Methods that SceneObject can use from it's base.
-	using Base::getParent;
-	using Base::visitChildren;
-	using Base::visitThisAndChildren;
-	using Base::visitChildrenMaxDepth;
-
 	Type getType() const
 	{
 		return m_bits & Type::_TYPE_MASK;

include/anki/scene/SpatialComponent.h

@@ -87,17 +87,20 @@ public:
 
 	/// Called when the component gets updated. It should be overriden, by 
 	/// default it does nothing.
-	virtual void onSpatialComponentUpdate(
+	virtual ANKI_USE_RESULT Error onSpatialComponentUpdate(
 		SceneNode& node, F32 prevTime, F32 crntTime)
-	{}
+	{
+		return ErrorCode::NONE;
+	}
 
 	/// @name SceneComponent overrides
 	/// @{
-	Bool update(SceneNode&, F32, F32) override;
+	ANKI_USE_RESULT Error update(SceneNode&, F32, F32, Bool& updated) override;
 
-	void onUpdate(SceneNode& node, F32 prevTime, F32 crntTime) final
+	ANKI_USE_RESULT Error onUpdate(
+		SceneNode& node, F32 prevTime, F32 crntTime) final
 	{
-		onSpatialComponentUpdate(node, prevTime, crntTime);
+		return onSpatialComponentUpdate(node, prevTime, crntTime);
 	}
 
 	/// Disable some flags

include/anki/util/DArray.h

@@ -68,51 +68,75 @@ public:
 	}
 
 	/// Make it compatible with the C++11 range based for loop.
-	Iterator begin()
+	Iterator getBegin()
 	{
 		return &m_data[0];
 	}
 
 	/// Make it compatible with the C++11 range based for loop.
-	ConstIterator begin() const
+	ConstIterator getBegin() const
 	{
 		return &m_data[0];
 	}
 
 	/// Make it compatible with the C++11 range based for loop.
-	Iterator end()
+	Iterator getEnd()
 	{
 		return &m_data[0] + m_size;
 	}
 
 	/// Make it compatible with the C++11 range based for loop.
-	ConstIterator end() const
+	ConstIterator getEnd() const
 	{
 		return &m_data[0] + m_size;
 	}
 
-	/// Make it compatible with STL.
-	Reference front() 
+	/// Make it compatible with the C++11 range based for loop.
+	Iterator begin()
+	{
+		return getBegin();
+	}
+
+	/// Make it compatible with the C++11 range based for loop.
+	ConstIterator begin() const
+	{
+		return getBegin();
+	}
+
+	/// Make it compatible with the C++11 range based for loop.
+	Iterator end()
+	{
+		return getEnd();
+	}
+
+	/// Make it compatible with the C++11 range based for loop.
+	ConstIterator end() const
+	{
+		return getEnd();
+	}
+
+	/// Get first element.
+	Reference getFront() 
 	{
 		return m_data[0];
 	}
 
-	/// Make it compatible with STL.
-	ConstReference front() const
+	/// Get first element.
+	ConstReference getFront() const
 	{
 		return m_data[0];
 	}
 
-	/// Make it compatible with STL.
-	Reference back() 
+	/// Get last element.
+	Reference getBack() 
 	{
 		return m_data[m_size - 1];
 	}
 
-	/// Make it compatible with STL.
+	/// Get last element.
 	ConstReference back() const
 	{
-		return m_data[m_size - 1];
+		return getBack[m_size - 1];
 	}
 
 	PtrSize getSize() const

include/anki/util/Visitor.h

@@ -254,18 +254,18 @@ public:
 
 	/// Apply mutable visitor
 	template<typename TVisitor>
-	void acceptVisitor(TVisitor& v)
+	ANKI_USE_RESULT Error acceptVisitor(TVisitor& v)
 	{
 		ANKI_ASSERT(m_what != -1);
-		acceptVisitorInternal<TVisitor, Types...>(v);
+		return acceptVisitorInternal<TVisitor, Types...>(v);
 	}
 
 	/// Apply const visitor
 	template<typename TVisitor>
-	void acceptVisitor(TVisitor& v) const
+	ANKI_USE_RESULT Error acceptVisitor(TVisitor& v) const
 	{
 		ANKI_ASSERT(m_what != -1);
-		acceptVisitorInternalConst<TVisitor, Types...>(v);
+		return acceptVisitorInternalConst<TVisitor, Types...>(v);
 	}
 
 	/// Setup the type ID
@@ -282,8 +282,10 @@ private:
 	/// @name Accept visitor template methods
 	/// @{
 	template<typename TVisitor, typename TFirst>
-	void acceptVisitorInternal(TVisitor& v)
+	ANKI_USE_RESULT Error acceptVisitorInternal(TVisitor& v)
 	{
+		Error err = ErrorCode::NONE;
+
 		switch(m_what)
 		{
 		case 0:
@@ -294,19 +296,22 @@ private:
 #else
 				TFirst* base = static_cast<TFirst*>(this);
 #endif
-				v.template visit(*base);
+				err = v.template visit(*base);
 			}
 			break;
 		default:
 			ANKI_ASSERT(0 && "Wrong type ID");
 			break;
 		}
+
+		return err;
 	}
 
 	template<typename TVisitor, typename TFirst, typename TSecond, 
 		typename... Types_>
-	void acceptVisitorInternal(TVisitor& v)
+	ANKI_USE_RESULT Error acceptVisitorInternal(TVisitor& v)
 	{
+		Error err = ErrorCode::NONE;
 		constexpr I i = sizeof...(Types) - sizeof...(Types_) - 1;
 
 		switch(m_what)
@@ -319,18 +324,22 @@ private:
 #else
 				TSecond* base = static_cast<TSecond*>(this);
 #endif
-				v.template visit(*base);
+				err = v.template visit(*base);
 			}
 			break;
 		default:
-			acceptVisitorInternal<TVisitor, TFirst, Types_...>(v);
+			err = acceptVisitorInternal<TVisitor, TFirst, Types_...>(v);
 			break;
 		}
+		
+		return err;
 	}
 
 	template<typename TVisitor, typename TFirst>
-	void acceptVisitorInternalConst(TVisitor& v) const
+	ANKI_USE_RESULT Error acceptVisitorInternalConst(TVisitor& v) const
 	{
+		Error err = ErrorCode::NONE;
+
 		switch(m_what)
 		{
 		case 0:
@@ -341,19 +350,22 @@ private:
 #else
 				const TFirst* base = static_cast<const TFirst*>(this);
 #endif
-				v.template visit(*base);
+				err = v.template visit(*base);
 			}
 			break;
 		default:
 			ANKI_ASSERT(0 && "Wrong type ID");
 			break;
 		}
+		
+		return err;
 	}
 
 	template<typename TVisitor, typename TFirst, typename TSecond, 
 		typename... Types_>
-	void acceptVisitorInternalConst(TVisitor& v) const
+	ANKI_USE_RESULT Error acceptVisitorInternalConst(TVisitor& v) const
 	{
+		Error err = ErrorCode::NONE;
 		constexpr I i = sizeof...(Types) - sizeof...(Types_) - 1;
 
 		switch(m_what)
@@ -366,13 +378,15 @@ private:
 #else
 				const TSecond* base = static_cast<const TSecond*>(this);
 #endif
-				v.template visit(*base);
+				err = v.template visit(*base);
 			}
 			break;
 		default:
-			acceptVisitorInternalConst<TVisitor, TFirst, Types_...>(v);
+			err = acceptVisitorInternalConst<TVisitor, TFirst, Types_...>(v);
 			break;
 		}
+		
+		return err;
 	}
 	/// @}
 };

src/scene/MoveComponent.cpp

@@ -22,10 +22,10 @@ MoveComponent::~MoveComponent()
 {}
 
 //==============================================================================
-Bool MoveComponent::update(SceneNode& node, F32, F32)
+Error MoveComponent::update(SceneNode& node, F32, F32, Bool& updated)
 {
-	Bool updated = updateWorldTransform(node);
-	return updated;
+	updated = updateWorldTransform(node);
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -79,8 +79,8 @@ Bool MoveComponent::updateWorldTransform(SceneNode& node)
 	// whole tree because you will re-walk it later
 	if(dirty)
 	{
-		node.visitChildrenMaxDepth(1, [](SceneObject& obj) -> Error
-		{
+		Error err = node.visitChildrenMaxDepth(1, [](SceneObject& obj) -> Error
+		{ 
 			if(obj.getType() == SceneNode::getClassType())
 			{
 				SceneNode& childNode = obj.downCast<SceneNode>();
@@ -94,6 +94,8 @@ Bool MoveComponent::updateWorldTransform(SceneNode& node)
 
 			return ErrorCode::NONE;
 		});
+
+		(void)err;
 	}
 
 	return dirty;

src/scene/RenderComponent.cpp

@@ -18,19 +18,25 @@ namespace anki {
 struct CreateNewRenderComponentVariableVisitor
 {
 	const MaterialVariable* m_mvar = nullptr;
-	RenderComponent::Variables* m_vars = nullptr;
+	mutable RenderComponent::Variables* m_vars = nullptr;
+	mutable U32* m_count = nullptr;
+	mutable SceneAllocator<U8> m_alloc;
 
 	template<typename TMaterialVariableTemplate>
-	void visit(const TMaterialVariableTemplate&) const
+	Error visit(const TMaterialVariableTemplate&) const
 	{
-		typedef typename TMaterialVariableTemplate::Type Type;
-
-		SceneAllocator<U8> alloc = m_vars->get_allocator();
+		using Type = typename TMaterialVariableTemplate::Type;
 
 		RenderComponentVariableTemplate<Type>* rvar =
-			alloc.newInstance<RenderComponentVariableTemplate<Type>>(m_mvar);
+			m_alloc.newInstance<RenderComponentVariableTemplate<Type>>(m_mvar);
+
+		if(rvar)
+		{
+			(*m_vars)[(*m_count)++] = rvar;
+			return ErrorCode::NONE;
+		}
 
-		m_vars->push_back(rvar);
+		return ErrorCode::OUT_OF_MEMORY;
 	}
 };
 
@@ -90,37 +96,45 @@ RenderComponentVariable::~RenderComponentVariable()
 //==============================================================================
 RenderComponent::RenderComponent(SceneNode* node)
 :	SceneComponent(Type::RENDER, node), 
-	m_vars(node->getSceneAllocator())
+	m_alloc(node->getSceneAllocator())
 {}
 
 //==============================================================================
 RenderComponent::~RenderComponent()
 {
-	SceneAllocator<U8> alloc = m_vars.get_allocator();
-
 	for(RenderComponentVariable* var : m_vars)
 	{
-		var->cleanup(alloc);
-		alloc.deleteInstance(var);
+		var->destroy(m_alloc);
+		m_alloc.deleteInstance(var);
 	}
+
+	m_vars.destroy(m_alloc);
 }
 
 //==============================================================================
-void RenderComponent::init()
+Error RenderComponent::create()
 {
 	const Material& mtl = getMaterial();
 
 	// Create the material variables using a visitor
 	CreateNewRenderComponentVariableVisitor vis;
+	U32 count = 0;
 	vis.m_vars = &m_vars;
+	vis.m_count = &count;
+	vis.m_alloc = m_alloc;
 
-	m_vars.reserve(mtl.getVariables().getSize());
+	Error err = m_vars.create(m_alloc, mtl.getVariables().getSize());
 
-	for(const MaterialVariable* mv : mtl.getVariables())
+	auto it = mtl.getVariables().getBegin();
+	auto end = mtl.getVariables().getEnd();
+	for(; !err && it != end; it++)
 	{
+		const MaterialVariable* mv = (*it);
 		vis.m_mvar = mv;
-		mv->acceptVisitor(vis);
+		err = mv->acceptVisitor(vis);
 	}
+
+	return err;
 }
 
 }  // end namespace anki

src/scene/SceneObject.cpp

@@ -12,7 +12,7 @@ namespace anki {
 SceneObject::SceneObject(Type type, SceneGraph* scene)
 :	Base(),
 	m_scene(scene),
-	m_bits(static_cast<U8>(type))
+	m_bits(type)
 {
 	ANKI_ASSERT(m_scene);
 }
@@ -44,15 +44,17 @@ void SceneObject::markForDeletion()
 	// want to increase the counter again
 	if(!isMarkedForDeletion())
 	{
-		m_bits |= enumToType(Flag::MARKED_FOR_DELETION);
+		m_bits |= Type::_MARKED_FOR_DELETION	;
 		m_scene->increaseObjectsMarkedForDeletion();
 	}
 
-	visitChildren([](SceneObject& obj) -> Error
+	Error err = visitChildren([](SceneObject& obj) -> Error
 	{
 		obj.markForDeletion();
 		return ErrorCode::NONE;
 	});
+
+	(void)err;
 }
 
 } // end namespace anki

src/scene/SpatialComponent.cpp

@@ -21,9 +21,9 @@ SpatialComponent::~SpatialComponent()
 {}
 
 //==============================================================================
-Bool SpatialComponent::update(SceneNode&, F32, F32)
+Error SpatialComponent::update(SceneNode&, F32, F32, Bool& updated)
 {
-	Bool updated = false;
+	updated = false;
 
 	updated = bitsEnabled(Flag::MARKED_FOR_UPDATE);
 	if(updated)
@@ -32,7 +32,7 @@ Bool SpatialComponent::update(SceneNode&, F32, F32)
 		disableBits(Flag::MARKED_FOR_UPDATE);
 	}
 
-	return updated;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================