Removing exceptions

include/anki/scene/InstanceNode.h

@@ -40,12 +40,16 @@ public:
 
 	ANKI_USE_RESULT Error create(const CString& name)
 	{
-		Error err = SceneNode::create(name, 2);
+		Error err = SceneNode::create(name);
 
 		if(!err)
 		{
-			addComponent(static_cast<MoveComponent*>(this));
-			addComponent(static_cast<InstanceComponent*>(this));
+			err = addComponent(static_cast<MoveComponent*>(this));
+		}
+
+		if(!err)
+		{
+			err = addComponent(static_cast<InstanceComponent*>(this));
 		}
 
 		return err;

include/anki/scene/ModelNode.h

@@ -29,11 +29,12 @@ class ModelPatchNode: public SceneNode,
 	friend class ModelNode;
 
 public:
-	ModelPatchNode(SceneGraph* scene, const ModelPatchBase* modelPatch);
+	ModelPatchNode(SceneGraph* scene);
 
 	~ModelPatchNode();
 
-	ANKI_USE_RESULT Error create(const CString& name);
+	ANKI_USE_RESULT Error create(
+		const CString& name, const ModelPatchBase* modelPatch);
 
 	/// @name RenderComponent virtuals
 	/// @{
@@ -83,28 +84,29 @@ class ModelNode: public SceneNode, public MoveComponent
 	friend class ModelPatchNode;
 
 public:
-	ModelNode(
-		const CString& name, SceneGraph* scene, // SceneNode
-		const CString& modelFname); // Self
+	ModelNode(SceneGraph* scene);
 
 	virtual ~ModelNode();
 
+	ANKI_USE_RESULT Error create(
+		const CString& name, const CString& modelFname);
+
 	const Model& getModel() const
 	{
 		return *m_model;
 	}
 
 	/// Override SceneNode::frameUpdate
-	void frameUpdate(F32, F32) override;
+	ANKI_USE_RESULT Error frameUpdate(F32, F32) override;
 
 	/// Override MoveComponent::onMoveComponentUpdate
-	void onMoveComponentUpdate(
+	ANKI_USE_RESULT Error onMoveComponentUpdate(
 		SceneNode& node, F32 prevTime, F32 crntTime) override;
 
 private:
 	ModelResourcePointer m_model; ///< The resource
-	SceneVector<ModelPatchNode*> m_modelPatches;
-	SceneVector<Transform> m_transforms; ///< Cache the transforms of instances
+	SceneDArray<ModelPatchNode*> m_modelPatches;
+	SceneDArray<Transform> m_transforms; ///< Cache the transforms of instances
 	Timestamp m_transformsTimestamp;
 };
 

include/anki/scene/SceneGraph.h

@@ -155,14 +155,34 @@ public:
 
 	/// Create a new SceneNode
 	template<typename Node, typename... Args>
-	Node* newSceneNode(const CString& name, Args&&... args)
+	ANKI_USE_RESULT Error newSceneNode(
+		const CString& name, Node*& node, Args&&... args)
 	{
-		Node* node;
+		Error err = ErrorCode::NONE;
 		SceneAllocator<Node> al = m_alloc;
-		node = al.template newInstance<Node>(
-			name, this, std::forward<Args>(args)...);
-		registerNode(node);
-		return node;
+
+		node = al.template newInstance<Node>(this);
+		if(node)
+		{
+			err = node->create(name, std::forward<Args>(args)...);
+		}
+		else
+		{
+			err = ErrorCode::OUT_OF_MEMORY;
+		}
+
+		if(!err)
+		{
+			err = registerNode(node);
+		}
+
+		if(err && node)
+		{
+			al.deleteInstance(node);
+			node = nullptr;
+		}
+
+		return err;
 	}
 
 	/// Delete a scene node. It actualy marks it for deletion
@@ -217,7 +237,7 @@ private:
 	AtomicU32 m_objectsMarkedForDeletionCount;
 
 	/// Put a node in the appropriate containers
-	void registerNode(SceneNode* node);
+	ANKI_USE_RESULT Error registerNode(SceneNode* node);
 	void unregisterNode(SceneNode* node);
 
 	/// Delete the nodes that are marked for deletion

include/anki/scene/SceneNode.h

@@ -29,11 +29,8 @@ public:
 	virtual ~SceneNode();
 
 	/// @param name The unique name of the node. If it's nullptr the the node
-	///             is not searchable
-	/// @param scene The scene that will register it
-	ANKI_USE_RESULT Error create(
-		const CString& name, 
-		U32 maxComponents);
+	///             is not searchable.
+	ANKI_USE_RESULT Error create(const CString& name);
 
 	/// Return the name. It may be empty for nodes that we don't want to track
 	CString getName() const
@@ -41,6 +38,11 @@ public:
 		return (!m_name.isEmpty()) ? m_name.toCString() : CString();
 	}
 
+	U32 getComponentsCount() const
+	{
+		return m_componentsCount;
+	}
+
 	/// This is called by the scene every frame after logic and before
 	/// rendering. By default it does nothing
 	/// @param prevUpdateTime Timestamp of the previous update
@@ -60,11 +62,10 @@ public:
 	ANKI_USE_RESULT Error iterateComponents(Func func) const
 	{
 		Error err = ErrorCode::NONE;
-		auto it = m_components.getBegin();
-		auto end = m_components.getEnd();
-		for(; !err && it != end; it++)
+		U count = m_componentsCount;
+		while(!err && count-- != 0)
 		{
-			err = func(*(*it));
+			err = func(*m_components[count]);
 		}
 
 		return err;
@@ -76,13 +77,12 @@ public:
 	{
 		Error err = ErrorCode::NONE;
 		SceneComponent::Type type = Component::getClassType();
-		auto it = m_components.getBegin();
-		auto end = m_components.getEnd();
-		for(; !err && it != end; it++)
+		U count = m_componentsCount;
+		while(!err && count-- != 0)
 		{
-			if((*it)->getType() == type)
+			if(m_components[count]->getType() == type)
 			{
-				err = func((*it)->downCast<Component>());
+				err = func(m_components[count]->downCast<Component>());
 			}
 		}
 
@@ -94,11 +94,12 @@ public:
 	Component* tryGetComponent()
 	{
 		SceneComponent::Type type = Component::getClassType();
-		for(auto comp : m_components)
+		U count = m_componentsCount;
+		while(count-- != 0)
 		{
-			if(comp->getType() == type)
+			if(m_components[count]->getType() == type)
 			{
-				return &comp->downCast<Component>();
+				return &m_components[count]->downCast<Component>();
 			}
 		}
 		return nullptr;
@@ -109,11 +110,12 @@ public:
 	const Component* tryGetComponent() const
 	{
 		SceneComponent::Type type = Component::getClassType();
-		for(auto comp : m_components)
+		U count = m_componentsCount;
+		while(count-- != 0)
 		{
-			if(comp->getType() == type)
+			if(m_components[count]->getType() == type)
 			{
-				return &comp->downCast<Component>();
+				return &m_components[count]->downCast<Component>();
 			}
 		}
 		return nullptr;
@@ -145,7 +147,7 @@ public:
 protected:
 	/// Append a component to the components container. The SceneNode will not
 	/// take ownership
-	void addComponent(SceneComponent* comp);
+	ANKI_USE_RESULT Error addComponent(SceneComponent* comp);
 
 	/// Remove a component from the container
 	void removeComponent(SceneComponent* comp);

include/anki/util/Allocator.h

@@ -228,23 +228,31 @@ public:
 		typename rebind<U>::other alloc(*this);
 
 		U* x = alloc.allocate(1);
-		alloc.construct(x, std::forward<Args>(args)...);
+		if(x)
+		{
+			alloc.construct(x, std::forward<Args>(args)...);
+		}
+
 		return x;
 	}
 
 	/// Allocate a new array of objects and call their constructor
 	/// @note This is AnKi specific
-	template<typename U, typename... Args>
-	U* newArray(size_type n, Args&&... args)
+	template<typename U>
+	U* newArray(size_type n, const U& v = U())
 	{
 		typename rebind<U>::other alloc(*this);
 
 		U* x = alloc.allocate(n);
-		// Call the constuctors
-		for(size_type i = 0; i < n; i++)
+		if(x)
 		{
-			alloc.construct(&x[i], std::forward<Args>(args)...);
+			// Call the constuctors
+			for(size_type i = 0; i < n; i++)
+			{
+				alloc.construct(&x[i], v);
+			}
 		}
+
 		return x;
 	}
 
@@ -271,6 +279,7 @@ public:
 		{
 			alloc.destroy(&x[i]);
 		}
+
 		alloc.deallocate(x, n);
 	}
 

include/anki/util/DArray.h

@@ -155,8 +155,8 @@ public:
 	}
 
 	/// Create the array.
-	template<typename... TArgs>
-	ANKI_USE_RESULT Error create(Allocator alloc, PtrSize size, TArgs... args)
+	ANKI_USE_RESULT Error create(Allocator alloc, PtrSize size, 
+		const Value& v = Value())
 	{
 		ANKI_ASSERT(m_data == nullptr && m_size == 0);
 		Error err = ErrorCode::NONE;
@@ -165,7 +165,7 @@ public:
 
 		if(size > 0)
 		{
-			m_data = alloc.template newArray<Value>(size, args...);
+			m_data = alloc.template newArray<Value>(size, v);
 			if(m_data)
 			{
 				m_size = size;
@@ -188,7 +188,7 @@ public:
 
 		if(!err)
 		{
-			U minSize = std::min(size, m_size);
+			PtrSize minSize = std::min<PtrSize>(size, m_size);
 			for(U i = 0; i < minSize; i++)
 			{
 				newArr[i] = (*this)[i];

src/scene/ModelNode.cpp

@@ -18,25 +18,33 @@ namespace anki {
 //==============================================================================
 
 //==============================================================================
-ModelPatchNode::ModelPatchNode(
-	SceneGraph* scene,
-	const ModelPatchBase* modelPatch)
+ModelPatchNode::ModelPatchNode(SceneGraph* scene)
 :	SceneNode(scene),
 	RenderComponent(this),
-	SpatialComponent(this), 
-	m_modelPatch(modelPatch)
+	SpatialComponent(this)
 {}
 
 //==============================================================================
-Error ModelPatchNode::create(const CString& name)
+Error ModelPatchNode::create(const CString& name, 
+	const ModelPatchBase* modelPatch)
 {
-	err = SceneNode::create(name, 2);
+	ANKI_ASSERT(modelPatch);
+	Error err = SceneNode::create(name);
+
+	m_modelPatch = modelPatch;
+
+	if(!err)
+	{
+		err = addComponent(static_cast<RenderComponent*>(this));
+	}
 
 	if(!err)
 	{
-		addComponent(static_cast<RenderComponent*>(this));
-		addComponent(static_cast<SpatialComponent*>(this));
+		err = addComponent(static_cast<SpatialComponent*>(this));
+	}
 
+	if(!err)
+	{
 		err = RenderComponent::create();
 	}
 
@@ -69,30 +77,25 @@ Error ModelPatchNode::buildRendering(RenderingBuildData& data)
 		data.m_key, vertJobs, ppline, 
 		nullptr, 0,
 		indicesCountArray, indicesOffsetArray, drawcallCount);
-	if(err)
-	{
-		return err;
-	}
-
-	// Cannot accept multi-draw
-	ANKI_ASSERT(drawcallCount == 1);
 
-	// Set jobs
-	ppline.bind(data.m_jobs);
-	err = data.m_jobs.pushBackOtherCommandBuffer(vertJobs);
-	if(err)
+	if(!err)
 	{
-		return err;
+		// Cannot accept multi-draw
+		ANKI_ASSERT(drawcallCount == 1);
+
+		// Set jobs
+		ppline.bind(data.m_jobs);
+		data.m_jobs.pushBackOtherCommandBuffer(vertJobs);
+
+		// Drawcall
+		U32 offset = indicesOffsetArray[0] / sizeof(U16);
+		data.m_jobs.drawElements(
+			data.m_key.m_tessellation ? GL_PATCHES : GL_TRIANGLES,
+			sizeof(U16),
+			indicesCountArray[0],
+			instancesCount,
+			offset);
 	}
-	
-	// Drawcall
-	U32 offset = indicesOffsetArray[0] / sizeof(U16);
-	err = data.m_jobs.drawElements(
-		data.m_key.m_tessellation ? GL_PATCHES : GL_TRIANGLES,
-		sizeof(U16),
-		indicesCountArray[0],
-		instancesCount,
-		offset);
 
 	return err;
 }
@@ -117,7 +120,7 @@ void ModelPatchNode::getRenderWorldTransform(U index, Transform& trf)
 		ModelNode* mnode = staticCastPtr<ModelNode*>(parent);
 
 		--index;
-		ANKI_ASSERT(index < mnode->m_transforms.size());
+		ANKI_ASSERT(index < mnode->m_transforms.getSize());
 		trf = mnode->m_transforms[index];
 	}
 }
@@ -155,12 +158,16 @@ Error ModelPatchNode::updateInstanceSpatials(
 				return ErrorCode::OUT_OF_MEMORY;
 			}
 
-			addComponent(newSpatial);
+			err = addComponent(newSpatial);
+			if(err)
+			{
+				return err;
+			}
 
 			m_spatials[index++] = newSpatial;
 		}
 	}
-	else if(m_spatials.size() > instanceMoves.size())
+	else if(oldSize > newSize)
 	{
 		// Need to remove spatials
 
@@ -193,28 +200,66 @@ Error ModelPatchNode::updateInstanceSpatials(
 //==============================================================================
 
 //==============================================================================
-ModelNode::ModelNode(
-	const CString& name, SceneGraph* scene,
-	const CString& modelFname)
-: 	SceneNode(name, scene),
+ModelNode::ModelNode(SceneGraph* scene)
+: 	SceneNode(scene),
 	MoveComponent(this),
-	m_modelPatches(getSceneAllocator()),
-	m_transforms(getSceneAllocator()),
 	m_transformsTimestamp(0)
+{}
+
+//==============================================================================
+ModelNode::~ModelNode()
+{
+	m_modelPatches.destroy(getSceneAllocator());
+	m_transforms.destroy(getSceneAllocator());
+#if 0
+	RigidBody* body = tryGetComponent<RigidBody>();
+	if(body)
+	{
+		getSceneGraph().getPhysics().deletePhysicsObject(body);
+	}
+#endif
+}
+
+//==============================================================================
+Error ModelNode::create(const CString& name, const CString& modelFname)
 {
-	addComponent(static_cast<MoveComponent*>(this));
+	Error err = ErrorCode::NONE;
 
-	m_model.load(modelFname, &getResourceManager());
-	m_modelPatches.reserve(m_model->getModelPatches().getSize());
+	err = SceneNode::create(name);
 
-	for(const ModelPatchBase* patch : m_model->getModelPatches())
+	if(!err)
 	{
-		ModelPatchNode* mpn = 
-			getSceneGraph().newSceneNode<ModelPatchNode>(CString(), patch);
+		err = addComponent(static_cast<MoveComponent*>(this));
+	}
 
-		m_modelPatches.push_back(mpn);
+	if(!err)
+	{
+		err = m_model.load(modelFname, &getResourceManager());
+	}
+
+	if(!err)
+	{
+		err = m_modelPatches.create(
+			getSceneAllocator(), m_model->getModelPatches().getSize());
+	}
+
+	if(!err)
+	{
+		U count = 0;
+		auto it = m_model->getModelPatches().getBegin();
+		auto end = m_model->getModelPatches().getEnd();
+		for(; !err && it != end; it++)
+		{
+			ModelPatchNode* mpn;
+			err = getSceneGraph().newSceneNode(CString(), mpn, *it);
+
+			if(!err)
+			{
+				m_modelPatches[count++] = mpn;
 
-		SceneObject::addChild(mpn);
+				err = SceneObject::addChild(mpn);
+			}
+		}
 	}
 
 	// Load rigid body
@@ -234,27 +279,27 @@ ModelNode::ModelNode(
 		addComponent(static_cast<RigidBody*>(body));
 	}
 #endif
-}
 
-//==============================================================================
-ModelNode::~ModelNode()
-{
-#if 0
-	RigidBody* body = tryGetComponent<RigidBody>();
-	if(body)
-	{
-		getSceneGraph().getPhysics().deletePhysicsObject(body);
-	}
-#endif
+	return err;
 }
 
 //==============================================================================
-void ModelNode::frameUpdate(F32, F32)
+Error ModelNode::frameUpdate(F32, F32)
 {
+	Error err = ErrorCode::NONE;
+
 	// Gather the move components of the instances
-	SceneFrameVector<MoveComponent*> instanceMoves(getSceneFrameAllocator());
+	SceneFrameDArray<MoveComponent*> instanceMoves;
+	U instanceMovesCount = 0;
 	Timestamp instancesTimestamp = 0;
-	SceneObject::visitChildren([&](SceneObject& obj) -> Error
+
+	err = instanceMoves.create(getSceneFrameAllocator(), 64);
+	if(err)
+	{
+		return err;
+	}
+
+	err = SceneObject::visitChildren([&](SceneObject& obj) -> Error
 	{
 		if(obj.getType() == SceneNode::getClassType())
 		{
@@ -263,7 +308,7 @@ void ModelNode::frameUpdate(F32, F32)
 			{
 				MoveComponent& move = sn.getComponent<MoveComponent>();
 
-				instanceMoves.push_back(&move);
+				instanceMoves[instanceMovesCount++] = &move;
 
 				instancesTimestamp = 
 					std::max(instancesTimestamp, move.getTimestamp());
@@ -274,36 +319,46 @@ void ModelNode::frameUpdate(F32, F32)
 	});
 
 	// If having instances
-	if(instanceMoves.size() != 0)
+	if(instanceMovesCount > 0)
 	{
 		Bool fullUpdate = false;
 
-		if(instanceMoves.size() != m_transforms.size())
+		if(instanceMovesCount != m_transforms.getSize())
 		{
 			fullUpdate = true;
-			m_transforms.resize(instanceMoves.size());
+			err = m_transforms.resize(getSceneAllocator(), instanceMovesCount);
 		}
 
-		if(fullUpdate || m_transformsTimestamp < instancesTimestamp)
+		if(!err && (fullUpdate || m_transformsTimestamp < instancesTimestamp))
 		{
 			m_transformsTimestamp = instancesTimestamp;
 
-			for(U i = 0; i < instanceMoves.size(); i++)
+			U count = 0;
+			for(const MoveComponent* instanceMove : instanceMoves)
 			{
-				m_transforms[i] = instanceMoves[i]->getWorldTransform();
+				m_transforms[count++] = instanceMove->getWorldTransform();
 			}
 		}
 
 		// Update children
-		for(ModelPatchNode* child : m_modelPatches)
+		if(!err)
 		{
-			child->updateInstanceSpatials(instanceMoves);
+			auto it = m_modelPatches.getBegin();
+			auto end = m_modelPatches.getEnd();
+			for(; it != end && !err; ++it)
+			{
+				err = (*it)->updateInstanceSpatials(instanceMoves);
+			}
 		}
 	}
+
+	instanceMoves.destroy(getSceneFrameAllocator());
+
+	return err;
 }
 
 //==============================================================================
-void ModelNode::onMoveComponentUpdate(SceneNode&, F32, F32)
+Error ModelNode::onMoveComponentUpdate(SceneNode&, F32, F32)
 {
 	// Inform the children about the moves
 	for(ModelPatchNode* child : m_modelPatches)
@@ -313,6 +368,8 @@ void ModelNode::onMoveComponentUpdate(SceneNode&, F32, F32)
 
 		child->SpatialComponent::markForUpdate();
 	}
+
+	return ErrorCode::NONE;
 }
 
 } // end namespace anki

src/scene/SceneNode.cpp

@@ -14,21 +14,9 @@ SceneNode::SceneNode(SceneGraph* scene)
 {}
 
 //==============================================================================
-Error SceneNode::create(const CString& name, U32 maxComponents)
+Error SceneNode::create(const CString& name)
 {
-	Error err = ErrorCode::NONE;
-	
-	if(maxComponents)
-	{
-		err = m_components.create(getSceneAllocator(), maxComponents);
-	}
-
-	if(!err && !name.isEmpty())
-	{
-		err = m_name.create(getSceneAllocator(), name);
-	}
-
-	return err;
+	return m_name.create(getSceneAllocator(), name);
 }
 
 //==============================================================================
@@ -56,10 +44,25 @@ U32 SceneNode::getLastUpdateFrame() const
 }
 
 //==============================================================================
-void SceneNode::addComponent(SceneComponent* comp)
+Error SceneNode::addComponent(SceneComponent* comp)
 {
 	ANKI_ASSERT(comp);
-	m_components[m_componentsCount++] = comp;
+	Error err = ErrorCode::NONE;
+
+	if(m_components.getSize() < m_componentsCount + 1)
+	{
+		// Not enough room
+		const U extra = 2;
+		err = m_components.resize(
+			getSceneAllocator(), m_componentsCount + 1 + extra);
+	}
+
+	if(!err)
+	{
+		m_components[m_componentsCount++] = comp;
+	}
+
+	return err;
 }
 
 //==============================================================================