Removing MeshNode and SkelNode and combining them in ModelNode WIP

src/Main.cpp

@@ -18,13 +18,8 @@
 #include "Scanner.h"
 #include "skybox.h"
 #include "map.h"
-#include "MeshNode.h"
-#include "SkelModelNode.h"
-#include "MeshNode.h"
 #include "SkelAnim.h"
 #include "MeshSkelNodeCtrl.h"
-#include "SkelAnimCtrl.h"
-#include "SkelNode.h"
 #include "LightData.h"
 #include "Parser.h"
 #include "ParticleEmitter.h"

src/Renderer/Bs.cpp

@@ -2,7 +2,6 @@
 #include "Renderer.h"
 #include "App.h"
 #include "Scene.h"
-#include "MeshNode.h"
 #include "ShaderProg.h"
 
 
@@ -83,7 +82,8 @@ void Bs::run()
 	glDepthMask(false);
 
 	// render the meshes
-	for(Vec<MeshNode*>::iterator it=app->getScene().meshNodes.begin(); it!=app->getScene().meshNodes.end(); it++)
+	/// @todo Uncomment this
+	/*for(Vec<MeshNode*>::iterator it=app->getScene().meshNodes.begin(); it!=app->getScene().meshNodes.end(); it++)
 	{
 		MeshNode* meshNode = (*it);
 
@@ -145,7 +145,7 @@ void Bs::run()
 			r.setupMaterial(*meshNode->mesh->material, *meshNode, r.getCamera());
 			meshNode->render();
 		}
-	}
+	}*/
 
 	glDepthMask(true);
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // the rendering above fucks the polygon mode

src/Renderer/Dbg.cpp

@@ -2,7 +2,6 @@
 #include "Renderer.h"
 #include "App.h"
 #include "Scene.h"
-#include "SkelNode.h"
 #include "Camera.h"
 #include "LightData.h"
 #include "RendererInitializer.h"

src/Renderer/Ez.cpp

@@ -1,7 +1,6 @@
 #include "Ez.h"
 #include "Renderer.h"
 #include "App.h"
-#include "MeshNode.h"
 #include "Scene.h"
 #include "RendererInitializer.h"
 
@@ -59,7 +58,8 @@ void Ez::run()
 	glEnable(GL_DEPTH_TEST);
 	glDisable(GL_BLEND);
 
-	for(Vec<MeshNode*>::iterator it=app->getScene().meshNodes.begin(); it!=app->getScene().meshNodes.end(); it++)
+	/// @todo Uncomment
+	/*for(Vec<MeshNode*>::iterator it=app->getScene().meshNodes.begin(); it!=app->getScene().meshNodes.end(); it++)
 	{
 		MeshNode* meshNode = (*it);
 		if(meshNode->mesh->material->renderInBlendingStage())
@@ -71,7 +71,7 @@ void Ez::run()
 
 		r.setupMaterial(meshNode->mesh->material->getDepthMtl(), *meshNode, r.getCamera());
 		meshNode->renderDepth();
-	}
+	}*/
 
 	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 }

src/Renderer/Ms.cpp

@@ -3,7 +3,6 @@
 #include "App.h"
 #include "Scene.h"
 #include "Camera.h"
-#include "MeshNode.h"
 #include "Ez.h"
 
 
@@ -98,7 +97,8 @@ void Ms::run()
 	}
 
 	// render the meshes
-	for(Vec<MeshNode*>::iterator it=app->getScene().meshNodes.begin(); it!=app->getScene().meshNodes.end(); it++)
+	/// @todo Uncomment
+	/*for(Vec<MeshNode*>::iterator it=app->getScene().meshNodes.begin(); it!=app->getScene().meshNodes.end(); it++)
 	{
 		MeshNode* meshNode = (*it);
 		if(meshNode->mesh->material.get() == NULL)
@@ -113,7 +113,7 @@ void Ms::run()
 
 		r.setupMaterial(*meshNode->mesh->material, *meshNode, cam);
 		meshNode->render();
-	}
+	}*/
 
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // the rendering above fucks the polygon mode
 

src/Renderer/Renderer.cpp

@@ -5,6 +5,7 @@
 #include "App.h"
 #include "Scene.h"
 #include "Exception.h"
+#include "ModelNode.h"
 
 
 //======================================================================================================================
@@ -278,6 +279,54 @@ void Renderer::setupMaterial(const Material& mtl, const SceneNode& sceneNode, co
 }
 
 
+//======================================================================================================================
+// renderModelNode                                                                                                     =
+//======================================================================================================================
+void Renderer::renderModelNode(const ModelNode& modelNode, const Camera& cam, ModelNodeRenderType type) const
+{
+	const Material* mtl;
+	const Vao* vao;
+
+	for(uint i = 0; i < modelNode.getModel().getSubModels().size(); i++)
+	{
+		Model::SubModel& subModel = modelNode.getModel().getSubModels()[i];
+
+		const Material* mtl;
+		const Vao* vao;
+		if(type == MNRT_NORMAL)
+		{
+			mtl = subModel.getMaterial();
+			vao = subModel.getVao();
+		}
+		else
+		{
+			mtl = subModel.getDpMaterial();
+			vao = subModel.getDpVao();
+		}
+
+		// Material
+		setupMaterial(*mtl, modelNode, cam);
+
+		// Render
+		if(modelNode.hasSkeleton())
+		{
+			RASSERT_THROW_EXCEPTION(!mtl->hasHWSkinning()); // it has skel controller but no skinning
+
+			// first the uniforms
+			mtl->getStdUniVar(Material::SUV_SKINNING_ROTATIONS)->setMat3(&modelNode.getBoneRotations()[0],
+			                                                             modelNode.getBoneRotations().size());
+
+			mtl->getStdUniVar(Material::SUV_SKINNING_TRANSLATIONS)->setVec3(&meshSkelCtrl.getBoneTranslations()[0],
+			                                                                meshSkelCtrl.getBoneTranslations().size());
+		}
+
+		vao->bind();
+		glDrawElements(GL_TRIANGLES, subModel.getMesh().getVertIdsNum(), GL_UNSIGNED_SHORT, 0);
+		vao->unbind();
+	}
+}
+
+
 //======================================================================================================================
 // unproject                                                                                                           =
 //======================================================================================================================

src/Renderer/Renderer.h

@@ -20,6 +20,7 @@
 class Camera;
 class RendererInitializer;
 class SceneNode;
+class ModelNode;
 
 
 /// Offscreen renderer
@@ -38,6 +39,13 @@ class Renderer: public Object
 	// Public                                                                                                            =
 	//====================================================================================================================
 	public:
+		/// The two types of rendering a ModelNode
+		enum ModelNodeRenderType
+		{
+			MNRT_NORMAL,
+			MNRT_DEPTH
+		};
+
 		Renderer(Object* parent);
 
 		~Renderer() throw() {}
@@ -91,6 +99,10 @@ class Renderer: public Object
 		/// @param cam Needed for some matrices
 		void setupMaterial(const class Material& mtl, const SceneNode& sceneNode, const Camera& cam);
 
+
+		/// Render ModelNode. The method sets up the shader and renders the geometry
+		void renderModelNode(const ModelNode& modelNod, const Camera& cam, ModelNodeRenderType type) const;
+
 		/// Draws a quad. Actually it draws 2 triangles because OpenGL will no longer support quads
 		/// @param vertCoordsAttribLoc The attribute location of the vertex positions
 		void drawQuad();

src/Renderer/Sm.cpp

@@ -2,7 +2,6 @@
 #include "Renderer.h"
 #include "App.h"
 #include "Scene.h"
-#include "MeshNode.h"
 #include "LightData.h"
 #include "Camera.h"
 #include "RendererInitializer.h"
@@ -93,7 +92,8 @@ void Sm::run(const Camera& cam)
 	glEnable(GL_POLYGON_OFFSET_FILL);
 
 	// render all meshes
-	for(Vec<MeshNode*>::iterator it=app->getScene().meshNodes.begin(); it!=app->getScene().meshNodes.end(); it++)
+	/// @todo Uncomment
+	/*for(Vec<MeshNode*>::iterator it=app->getScene().meshNodes.begin(); it!=app->getScene().meshNodes.end(); it++)
 	{
 		MeshNode* meshNode = (*it);
 		if(meshNode->mesh->material->renderInBlendingStage())
@@ -105,7 +105,7 @@ void Sm::run(const Camera& cam)
 
 		r.setupMaterial(meshNode->mesh->material->getDepthMtl(), *meshNode, cam);
 		meshNode->renderDepth();
-	}
+	}*/
 
 	// restore GL
 	glDisable(GL_POLYGON_OFFSET_FILL);

src/Resources/Helpers/MeshData.cpp

@@ -34,9 +34,6 @@ void MeshData::load(const char* filename)
 		// Mesh name
 		std::string meshName = bs.readString();
 
-		// Material name
-		materialName = bs.readString();
-
 		// Verts num
 		uint vertsNum = bs.readUint();
 		vertCoords.resize(vertsNum);
@@ -105,7 +102,7 @@ void MeshData::load(const char* filename)
 			{
 				uint tmp = VertexWeight::MAX_BONES_PER_VERT;
 				throw EXCEPTION("Cannot have more than " +
-				                     boost::lexical_cast<std::string>(tmp) + " bones per vertex");
+				                boost::lexical_cast<std::string>(tmp) + " bones per vertex");
 			}
 			vertWeights[i].bonesNum = boneConnections;
 

src/Resources/Helpers/MeshData.h

@@ -22,6 +22,9 @@
 /// <uint:facesNum>
 /// <uint:tri[0].vertIds[0]> <uint:tri[0].vertIds[1]> <uint:tri[0].vertIds[2]> ...
 /// <uint:tri[facesNum-1].vertIds[0]> <uint:tri[facesNum-1].vertIds[1]> <uint:tri[facesNum-1].vertIds[2]>
+/// <uint:texCoordsNum>
+/// <float:texCoord[0].x><float:texCoord[0].y> ...
+/// <float:texCoord[texCoordsNum-1].x><float:texCoord[texCoordsNum-1].y>
 /// @endcode
 class MeshData
 {
@@ -54,7 +57,6 @@ class MeshData
 	PROPERTY_R(Vec<VertexWeight>, vertWeights, getVertWeights) ///< Optional
 	PROPERTY_R(Vec<Triangle>, tris, getTris) ///< Required
 	PROPERTY_R(Vec<ushort>, vertIndeces, getVertIndeces) ///< Generated. Used for vertex arrays & VBOs
-	PROPERTY_R(std::string, materialName, getMaterialName) ///< Required. If empty then mesh not renderable
 
 	public:
 		MeshData(const char* filename) {load(filename);}

src/Resources/Mesh.cpp

@@ -3,9 +3,18 @@
 #include "Mesh.h"
 #include "Material.h"
 #include "MeshData.h"
+#include "Vbo.h"
 
 
-#define BUFFER_OFFSET(i) ((char *)NULL + (i))
+//======================================================================================================================
+// Constructor                                                                                                         =
+//======================================================================================================================
+Mesh::Mesh():
+	Resource(RT_MESH),
+	Object(NULL)
+{
+	memset(vbos, NULL, sizeof(vbos));
+}
 
 
 //======================================================================================================================
@@ -19,38 +28,30 @@ void Mesh::load(const char* filename)
 
 	try
 	{
-		material.loadRsrc(meshData.getMaterialName().c_str());
-
-		if(isRenderable())
+		/*//
+		// Sanity checks
+		//
+		if(meshData.getVertIndeces().size() < 1 || meshData.getVertCoords().size() < 1 ||
+			 meshData.getVertNormals().size() < 1)
 		{
-			//
-			// Sanity checks
-			//
-			if(meshData.getVertIndeces().size() < 1 || meshData.getVertCoords().size() < 1 ||
-			   meshData.getVertNormals().size() < 1)
-			{
-				throw EXCEPTION("Empty required arrays");
-			}
-
-			// shader needs text coords and mesh does not have any
-			if(material->getStdAttribVar(Material::SAV_TEX_COORDS) != NULL && meshData.getTexCoords().size() < 1)
-			{
-				throw EXCEPTION("The shader program (\"" + material->getShaderProg().getRsrcName() +
-												"\") needs texture coord information that the mesh doesn't have");
-			}
+			throw EXCEPTION("Empty required arrays");
+		}
 
-			// shader has HW skinning and mesh does not have vert weights
-			if(material->hasHWSkinning() && meshData.getVertWeights().size() < 1)
-			{
-				throw EXCEPTION("The shader program (\"" + material->getShaderProg().getRsrcName() +
-												"\") needs vertex weights that the mesh doesn't have");
-			}
+		// shader needs text coords and mesh does not have any
+		if(material->getStdAttribVar(Material::SAV_TEX_COORDS) != NULL && meshData.getTexCoords().size() < 1)
+		{
+			throw EXCEPTION("The shader program (\"" + material->getShaderProg().getRsrcName() +
+											"\") needs texture coord information that the mesh doesn't have");
+		}
 
+		// shader has HW skinning and mesh does not have vert weights
+		if(material->hasHWSkinning() && meshData.getVertWeights().size() < 1)
+		{
+			throw EXCEPTION("The shader program (\"" + material->getShaderProg().getRsrcName() +
+											"\") needs vertex weights that the mesh doesn't have");
+		}*/
 
-			createVbos(meshData);
-			createVao(mainVao, *material.get());
-			createVao(depthVao, material->getDepthMtl());
-		}
+		createVbos(meshData);
 	}
 	catch(std::exception& e)
 	{
@@ -101,65 +102,3 @@ void Mesh::createVbos(const MeshData& meshData)
 		vbos[VBO_VERT_WEIGHTS] = NULL;
 	}
 }
-
-
-//======================================================================================================================
-// createVao                                                                                                           =
-//======================================================================================================================
-void Mesh::createVao(Vao*& vao, const Material& mtl)
-{
-	vao = new Vao(this);
-
-	if(mtl.getStdAttribVar(Material::SAV_POSITION) != NULL)
-	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_POSITIONS], *mtl.getStdAttribVar(Material::SAV_POSITION), 3, GL_FLOAT,
-		                          GL_FALSE, 0, NULL);
-	}
-
-	if(mtl.getStdAttribVar(Material::SAV_NORMAL) != NULL)
-	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_NORMALS], *mtl.getStdAttribVar(Material::SAV_NORMAL), 3, GL_FLOAT,
-		                          GL_FALSE, 0, NULL);
-	}
-
-	if(mtl.getStdAttribVar(Material::SAV_TANGENT) != NULL)
-	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_TANGENTS], *mtl.getStdAttribVar(Material::SAV_TANGENT), 4, GL_FLOAT,
-		                          GL_FALSE, 0, NULL);
-	}
-
-	if(mtl.getStdAttribVar(Material::SAV_TEX_COORDS) != NULL)
-	{
-		vao->attachArrayBufferVbo(*vbos[VBO_TEX_COORDS], *mtl.getStdAttribVar(Material::SAV_TEX_COORDS), 2, GL_FLOAT,
-		                          GL_FALSE, 0, NULL);
-	}
-
-	if(mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_BONES_NUM) != NULL)
-	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_WEIGHTS], *mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_BONES_NUM), 1,
-		                          GL_FLOAT, GL_FALSE, sizeof(MeshData::VertexWeight), BUFFER_OFFSET(0));
-	}
-
-	if(mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_BONE_IDS) != NULL)
-	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_WEIGHTS], *mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_BONE_IDS), 4,
-		                          GL_FLOAT, GL_FALSE, sizeof(MeshData::VertexWeight), BUFFER_OFFSET(4));
-	}
-
-	if(mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_WEIGHTS) != NULL)
-	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_WEIGHTS], *mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_WEIGHTS), 4,
-		                          GL_FLOAT, GL_FALSE, sizeof(MeshData::VertexWeight), BUFFER_OFFSET(20));
-	}
-
-	vao->attachElementArrayBufferVbo(*vbos[VBO_VERT_INDECES]);
-}
-
-
-//======================================================================================================================
-// isRenderable                                                                                                        =
-//======================================================================================================================
-bool Mesh::isRenderable() const
-{
-	return material.get() != NULL;
-}

src/Resources/Mesh.h

@@ -2,8 +2,6 @@
 #define MESH_H
 
 #include "Math.h"
-#include "Vbo.h"
-#include "Vao.h"
 #include "Resource.h"
 #include "RsrcPtr.h"
 #include "Object.h"
@@ -11,13 +9,14 @@
 
 class Material;
 class MeshData;
+class Vbo;
 
 
-/// Mesh Resource. If the material name is empty then the mesh wont be rendered and no VBOs will be created
+/// Mesh Resource. It contains the geometry packed in VBOs
 class Mesh: public Resource, public Object
 {
 	public:
-		/// Used in @ref vao array
+		/// Used in @ref vbos array
 		enum Vbos
 		{
 			VBO_VERT_POSITIONS,
@@ -32,37 +31,23 @@ class Mesh: public Resource, public Object
 	PROPERTY_R(uint, vertIdsNum, getVertIdsNum)
 
 	public:
-		RsrcPtr<Material> material; ///< Required. If empty then mesh not renderable
-
-		/// @name Accessors
-		/// @{
-		const Vao* getVao() const {return mainVao;}
-		const Vao* getDepthVao() const {return depthVao;}
-		const Vbo* getVbo(Vbos id) const {return vbos[id];}
-		/// @}
-
 		/// Default constructor
-		Mesh(): Resource(RT_MESH), Object(NULL) {}
+		Mesh();
 
 		/// Does nothing
 		~Mesh() {}
 
+		/// Accessor
+		const Vbo* getVbo(Vbos id) const {return vbos[id];}
+
 		/// Implements @ref Resource::load
 		void load(const char* filename);
 
-		/// The mesh is renderable when the material is loaded
-		bool isRenderable() const;
-
 	private:
 		Vbo* vbos[VBOS_NUM]; ///< The vertex buffer objects
-		Vao* mainVao; ///< Vertex array object
-		Vao* depthVao; ///< Vertex array object for the depth material
 
 		/// Create the VBOs
 		void createVbos(const MeshData& meshData);
-
-		/// Create a VAO. Called more than one
-		void createVao(Vao*& vao, const Material& mtl);
 };
 
 

src/Resources/Model.cpp

@@ -123,7 +123,7 @@ void Model::load(const char* filename)
 	//
 	for(Vec<SubModel>::iterator it = subModels.begin(); it != subModels.end(); it++)
 	{
-		createVao(*it->material, *it->mesh, *it, it->normVao);
+		createVao(*it->material, *it->mesh, *it, it->vao);
 		createVao(*it->dpMaterial, *it->mesh, *it, it->dpVao);
 	}
 }

src/Resources/Model.h

@@ -41,7 +41,7 @@ class Scanner;
 class Model: public Resource
 {
 	public:
-		///
+		/// This is basicaly a container around mesh and materials. It also has the VAOs.
 		class SubModel: public Object
 		{
 			friend class Model;
@@ -54,7 +54,7 @@ class Model: public Resource
 				const Mesh& getMesh() const {return *mesh;}
 				const Material& getMaterial() const {return *material;}
 				const Material& getDpMaterial() const {return *dpMaterial;}
-				const Vao& getVao() const {return *normVao;}
+				const Vao& getVao() const {return *vao;}
 				const Vao& getDpVao() const {return *dpVao;}
 				/// @}
 
@@ -62,7 +62,7 @@ class Model: public Resource
 				RsrcPtr<Mesh> mesh; ///< The geometry
 				RsrcPtr<Material> material; ///< Material for MS ans BS
 				RsrcPtr<Material> dpMaterial; ///< Material for depth passes
-				Vao* normVao; ///< Normal VAO for MS ans BS
+				Vao* vao; ///< Normal VAO for MS ans BS
 				Vao* dpVao; ///< Depth pass VAO for SM and EarlyZ
 		};
 
@@ -70,6 +70,14 @@ class Model: public Resource
 
 		void load(const char* filename);
 
+		/// @name Accessors
+		/// @{
+		const Vec<SubModel>& getSubModels() const {return subModels;}
+		const Skeleton& getSkeleton() const;
+		/// @}
+
+		bool hasSkeleton() const {return skeleton.get() != NULL;}
+
 	private:
 		Vec<SubModel> subModels; ///< The vector of submodels
 		RsrcPtr<Skeleton> skeleton; ///< The skeleton. It can be empty
@@ -83,4 +91,11 @@ class Model: public Resource
 };
 
 
+inline const Skeleton& Model::getSkeleton() const
+{
+	RASSERT_THROW_EXCEPTION(!hasSkeleton());
+	return *skeleton;
+}
+
+
 #endif

src/Scene/Controllers/SkelAnimCtrl.h

@@ -1,37 +0,0 @@
-#ifndef SKEL_ANIM_CTRL_H
-#define SKEL_ANIM_CTRL_H
-
-#include "Vec.h"
-#include "Controller.h"
-#include "Math.h"
-#include "RsrcPtr.h"
-
-class Skeleton;
-class SkelAnim;
-class SkelNode;
-
-
-/// Skeleton animation controller
-class SkelAnimCtrl: public Controller
-{
-	public:
-		RsrcPtr<SkelAnim> skelAnim; ///< Skeleton animation resource
-		float step;
-		float frame;
-
-		SkelAnimCtrl(SkelNode& skelNode_);
-		void update(float time);
-
-	private:
-		SkelNode& skelNode;
-
-		/// @name The 3 steps of skeletal animation in 3 funcs
-		/// @{
-		void interpolate(const SkelAnim& animation, float frame);
-		void updateBoneTransforms();
-		void deform();  ///< Now with HW skinning it deforms only the debug skeleton
-		/// @}
-};
-
-
-#endif

src/Scene/Controllers/SkelAnimCtrl.cpp → src/Scene/Controllers/SkelAnimModelNodeCtrl.cpp

@@ -1,24 +1,26 @@
-#include "SkelAnimCtrl.h"
+#include "SkelAnimModelNodeCtrl.h"
 #include "SkelAnim.h"
-#include "SkelNode.h"
 #include "Skeleton.h"
 #include "App.h"
+#include "ModelNode.h"
+#include "Model.h"
 #include "MainRenderer.h"
 
 
 //======================================================================================================================
-// SkelAnimCtrl                                                                                              =
+// SkelAnimModelNodeCtrl                                                                                               =
 //======================================================================================================================
-SkelAnimCtrl::SkelAnimCtrl(SkelNode& skelNode_):
+SkelAnimModelNodeCtrl::SkelAnimModelNodeCtrl(ModelNode& modelNode_):
 	Controller(CT_SKEL_ANIM),
-	skelNode(skelNode_)
+	modelNode(modelNode_)
 {}
 
 
 //======================================================================================================================
 // interpolate                                                                                                         =
 //======================================================================================================================
-void SkelAnimCtrl::interpolate(const SkelAnim& animation, float frame)
+void SkelAnimModelNodeCtrl::interpolate(const SkelAnim& animation, float frame,
+                                        Vec<Vec3>& boneTranslations, Vec<Mat3>& boneRotations)
 {
 	RASSERT_THROW_EXCEPTION(frame >= animation.framesNum);
 
@@ -44,12 +46,8 @@ void SkelAnimCtrl::interpolate(const SkelAnim& animation, float frame)
 		}
 	}
 
-
 	// now for all bones update bone's poses
-	Vec<Mat3>& boneRotations = skelNode.boneRotations;
-	Vec<Vec3>& boneTranslations = skelNode.boneTranslations;
-
-	RASSERT_THROW_EXCEPTION(boneRotations.size()<1);
+	RASSERT_THROW_EXCEPTION(boneRotations.size() < 1);
 	for(uint i=0; i<boneRotations.size(); i++)
 	{
 		const SkelAnim::BoneAnim& banim = animation.bones[i];
@@ -86,18 +84,16 @@ void SkelAnimCtrl::interpolate(const SkelAnim& animation, float frame)
 //======================================================================================================================
 // updateBoneTransforms                                                                                                =
 //======================================================================================================================
-void SkelAnimCtrl::updateBoneTransforms()
+void SkelAnimModelNodeCtrl::updateBoneTransforms(const Skeleton& skeleton,
+                                                 Vec<Vec3>& boneTranslations, Vec<Mat3>& boneRotations)
 {
 	uint queue[128];
 	uint head = 0, tail = 0;
 
-	Vec<Mat3>& boneRotations = skelNode.boneRotations;
-	Vec<Vec3>& boneTranslations = skelNode.boneTranslations;
-
 	// put the roots
-	for(uint i=0; i<skelNode.skeleton->bones.size(); i++)
+	for(uint i=0; i<skeleton.bones.size(); i++)
 	{
-		if(skelNode.skeleton->bones[i].parent == NULL)
+		if(skeleton.bones[i].parent == NULL)
 		{
 			queue[tail++] = i; // queue push
 		}
@@ -107,7 +103,7 @@ void SkelAnimCtrl::updateBoneTransforms()
 	while(head != tail) // while queue not empty
 	{
 		uint boneId = queue[head++]; // queue pop
-		const Skeleton::Bone& boned = skelNode.skeleton->bones[boneId];
+		const Skeleton::Bone& boned = skeleton.bones[boneId];
 
 		// bone.final_transform = MA * ANIM * MAi
 		// where MA is bone matrix at armature space and ANIM the interpolated transformation.
@@ -140,17 +136,16 @@ void SkelAnimCtrl::updateBoneTransforms()
 //======================================================================================================================
 // deform                                                                                                              =
 //======================================================================================================================
-void SkelAnimCtrl::deform()
+void SkelAnimModelNodeCtrl::deform(const Skeleton& skeleton, const Vec<Vec3>& boneTranslations,
+                                   const Vec<Mat3>& boneRotations, Vec<Vec3>& heads, Vec<Vec3>& tails)
 {
-	const Skeleton& skeleton = *skelNode.skeleton;
-
 	for(uint i=0; i<skeleton.bones.size(); i++)
 	{
-		const Mat3& rot = skelNode.boneRotations[i];
-		const Vec3& transl = skelNode.boneTranslations[i];
+		const Mat3& rot = boneRotations[i];
+		const Vec3& transl = boneTranslations[i];
 
-		skelNode.heads[i] = skeleton.bones[i].getHead().getTransformed(transl, rot);
-		skelNode.tails[i] = skeleton.bones[i].getTail().getTransformed(transl, rot);
+		heads[i] = skeleton.bones[i].getHead().getTransformed(transl, rot);
+		tails[i] = skeleton.bones[i].getTail().getTransformed(transl, rot);
 	}
 }
 
@@ -158,7 +153,7 @@ void SkelAnimCtrl::deform()
 //======================================================================================================================
 // update                                                                                                              =
 //======================================================================================================================
-void SkelAnimCtrl::update(float)
+void SkelAnimModelNodeCtrl::update(float)
 {
 	frame += step;
 	if(frame > skelAnim->framesNum) // if the crnt is finished then play the next or loop the crnt
@@ -166,10 +161,11 @@ void SkelAnimCtrl::update(float)
 		frame = 0.0;
 	}
 
-	interpolate(*skelAnim, frame);
-	updateBoneTransforms();
+	interpolate(*skelAnim, frame, modelNode.getBoneTranslations(), modelNode.getBoneRotations());
+	updateBoneTransforms(modelNode.getModel().getSkeleton(), modelNode.getBoneTranslations(), modelNode.getBoneRotations());
 	if(app->getMainRenderer().getDbg().isEnabled() && app->getMainRenderer().getDbg().isShowSkeletonsEnabled())
 	{
-		deform();
+		deform(modelNode.getModel().getSkeleton(), modelNode.getBoneTranslations(), modelNode.getBoneRotations(),
+		       modelNode.getHeads(), modelNode.getTails());
 	}
 }

src/Scene/Controllers/SkelAnimModelNodeCtrl.h

@@ -0,0 +1,48 @@
+#ifndef SKEL_ANIM_MODEL_NODE_CTRL_H
+#define SKEL_ANIM_MODEL_NODE_CTRL_H
+
+#include "Vec.h"
+#include "Controller.h"
+#include "Math.h"
+#include "RsrcPtr.h"
+
+
+class Skeleton;
+class SkelAnim;
+class ModelNode;
+
+
+/// SkelAnim controls a ModelNode
+class SkelAnimModelNodeCtrl: public Controller
+{
+	public:
+		SkelAnimModelNodeCtrl(ModelNode& skelNode_);
+		void update(float time);
+		void set(const SkelAnim* skelAnim_) {skelAnim = skelAnim_;}
+
+	private:
+		float step;
+		float frame;
+		const SkelAnim* skelAnim; ///< The active skeleton animation
+		ModelNode& modelNode; ///< Know your father
+
+		/// @name The 3 steps of skeletal animation in 3 methods
+		/// @{
+
+		/// Interpolate
+		/// @param[in] animation Animation
+		/// @param[in] frame Frame
+		/// @param[out] translations Translations vector
+		/// @param[out] rotations Rotations vector
+		static void interpolate(const SkelAnim& animation, float frame, Vec<Vec3>& translations, Vec<Mat3>& rotations);
+
+		static void updateBoneTransforms(const Skeleton& skel, Vec<Vec3>& translations, Vec<Mat3>& rotations);
+
+		/// Now with HW skinning it deforms only the debug skeleton
+		static void deform(const Skeleton& skel, const Vec<Vec3>& translations, const Vec<Mat3>& rotations,
+		                   Vec<Vec3>& heads, Vec<Vec3>& tails);
+		/// @}
+};
+
+
+#endif

src/Scene/MeshNode.cpp

@@ -1,48 +0,0 @@
-#include "MeshNode.h"
-#include "Resource.h"
-#include "Mesh.h"
-#include "Material.h"
-#include "SkelNode.h"
-#include "Skeleton.h"
-#include "MeshSkelNodeCtrl.h"
-#include "SkelAnimCtrl.h"
-#include "App.h"
-#include "MainRenderer.h"
-#include "MeshData.h" // For some sizeof
-
-
-#define BUFFER_OFFSET(i) ((char *)NULL + (i))
-
-
-//======================================================================================================================
-// init                                                                                                                =
-//======================================================================================================================
-void MeshNode::init(const char* filename)
-{
-	mesh.loadRsrc(filename);
-}
-
-
-//======================================================================================================================
-// render                                                                                                              =
-//======================================================================================================================
-void MeshNode::render(const Material& mtl, const Vao& vao) const
-{
-	// if we have skeleton controller
-	if(meshSkelCtrl)
-	{
-		RASSERT_THROW_EXCEPTION(!mtl.hasHWSkinning()); // it has skel controller but no skinning
-
-		// first the uniforms
-		mtl.getStdUniVar(Material::SUV_SKINNING_ROTATIONS)->setMat3(&meshSkelCtrl->skelNode->boneRotations[0],
-		                                                            meshSkelCtrl->skelNode->skeleton->bones.size());
-
-		mtl.getStdUniVar(Material::SUV_SKINNING_TRANSLATIONS)->setVec3(&meshSkelCtrl->skelNode->boneTranslations[0],
-		                                                               meshSkelCtrl->skelNode->skeleton->bones.size());
-	}
-
-
-	vao.bind();
-	glDrawElements(GL_TRIANGLES, mesh->getVertIdsNum(), GL_UNSIGNED_SHORT, 0);
-	vao.unbind();
-}

src/Scene/MeshNode.h

@@ -1,39 +0,0 @@
-#ifndef MESH_NODE_H
-#define MESH_NODE_H
-
-#include "SceneNode.h"
-#include "Material.h"
-#include "RsrcPtr.h"
-#include "Mesh.h"
-#include "MeshSkelNodeCtrl.h"
-
-
-class Vao;
-
-
-/// Mesh scene node
-class MeshNode: public SceneNode
-{
-	private:
-		void render(const Material& mtl, const Vao& vao) const; ///< Common code for render() and renderDepth()
-
-	public:
-		// resources
-		RsrcPtr<Mesh> mesh;
-		// controllers
-		MeshSkelNodeCtrl* meshSkelCtrl;
-		// funcs
-		MeshNode();
-		virtual void render() { render(*mesh->material.get(), *mesh->getVao()); }
-		virtual void renderDepth() { render(mesh->material->getDepthMtl(), *mesh->getDepthVao()); }
-		void init(const char* filename);
-};
-
-
-inline MeshNode::MeshNode():
-	SceneNode(SNT_MESH),
-	meshSkelCtrl(NULL)
-{}
-
-
-#endif

src/Scene/ModelNode.cpp

@@ -0,0 +1,2 @@
+#include "ModelNode.h"
+

src/Scene/ModelNode.h

@@ -0,0 +1,45 @@
+#ifndef MODEL_NODE_H
+#define MODEL_NODE_H
+
+#include "SceneNode.h"
+#include "RsrcPtr.h"
+#include "Properties.h"
+
+
+class Model;
+class SkelAnimModelNodeCtrl;
+
+
+/// The model scene node
+class ModelNode: public SceneNode
+{
+	public:
+		SkelAnimModelNodeCtrl* skelAnimModelNodeCtrl;
+
+		ModelNode(): SceneNode(SNT_MODEL) {}
+
+		/// @name Accessors
+		/// @{
+		const Model& getModel() const {return *model;}
+		Vec<Vec3>& getHeads() {return heads;}
+		Vec<Vec3>& getTails() {return tails;}
+		Vec<Mat3>& getBoneRotations() {return boneRotations;}
+		Vec<Vec3>& getBoneTranslations() {return boneTranslations;}
+		/// @}
+
+		/// @return True if the model support skeleton animation
+		bool hasSkeleton() const {return boneRotations.size() > 0;}
+
+		/// @todo write this sucker
+		void init(const char* filename) {}
+
+	private:
+		RsrcPtr<Model> model;
+		Vec<Vec3> heads;
+		Vec<Vec3> tails;
+		Vec<Mat3> boneRotations;
+		Vec<Vec3> boneTranslations;
+};
+
+
+#endif

src/Scene/ParticleEmitter.h

@@ -4,7 +4,6 @@
 #include <boost/ptr_container/ptr_vector.hpp>
 #include <memory>
 #include "SceneNode.h"
-#include "MeshNode.h"
 #include "GhostNode.h"
 #include "ParticleEmitterProps.h"
 

src/Scene/Scene.cpp

@@ -1,9 +1,7 @@
 #include <algorithm>
 #include "Exception.h"
 #include "Scene.h"
-#include "SkelNode.h"
 #include "Camera.h"
-#include "MeshNode.h"
 #include "Light.h"
 #include "Controller.h"
 #include "Material.h"

src/Scene/Scene.h

@@ -10,8 +10,6 @@
 class SceneNode;
 class Light;
 class Camera;
-class MeshNode;
-class SkelNode;
 class Controller;
 class ParticleEmitter;
 
@@ -32,8 +30,6 @@ class Scene: public Object
 		Container<SceneNode> nodes;
 		Container<Light> lights;
 		Container<Camera> cameras;
-		Container<MeshNode> meshNodes;
-		Container<SkelNode> skelNodes;
 		Container<Controller> controllers;
 		Container<ParticleEmitter> particleEmitters;
 		Skybox skybox; // ToDo to be removed

src/Scene/SceneNode.h

@@ -23,10 +23,8 @@ class SceneNode: public Object
 			SNT_GHOST,
 			SNT_LIGHT,
 			SNT_CAMERA,
-			SNT_MESH,
-			SNT_SKELETON,
-			SNT_SKEL_MODEL,
-			SNT_PARTICLE_EMITTER
+			SNT_PARTICLE_EMITTER,
+			SNT_MODEL
 		};
 
 	PROPERTY_RW(Transform, localTransform, setLocalTransform, getLocalTransform) ///< The transformation in local space

src/Scene/SkelModelNode.cpp

@@ -1,63 +0,0 @@
-#include <cstring>
-#include "SkelModelNode.h"
-#include "Parser.h"
-#include "SkelNode.h"
-#include "MeshSkelNodeCtrl.h"
-
-/// Create a skelNode and N meshNodes that have a meshSkelCtrl
-void SkelModelNode::init(const char* filename)
-{
-	Scanner scanner(filename);
-	const Scanner::Token* token;
-
-	//** SKELETON **
-	token = &scanner.getNextToken();
-	if(!(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "SKELETON")))
-	{
-		throw PARSER_EXCEPTION_EXPECTED("identifier SKELETON");
-		return;
-	}
-	
-	token = &scanner.getNextToken();
-	if(token->getCode() != Scanner::TC_STRING)
-	{
-		throw PARSER_EXCEPTION_EXPECTED("string");
-		return;
-	}
-
-	skelNode = new SkelNode;
-	skelNode->init(token->getValue().getString());
-	addChild(skelNode);
-
-	//** MESHES **
-	token = &scanner.getNextToken();
-	if(!(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "MESHES_NUM")))
-	{
-		throw PARSER_EXCEPTION_EXPECTED("identifier MESHES_NUM");
-		return;
-	}
-
-	token = &scanner.getNextToken();
-	if(token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT)
-	{
-		throw PARSER_EXCEPTION_EXPECTED("integer");
-		return;
-	}
-
-	meshNodes.resize(token->getValue().getInt());
-
-	for(uint i=0; i<meshNodes.size(); ++i)
-	{
-		token = &scanner.getNextToken();
-		if(token->getCode() != Scanner::TC_STRING)
-		{
-			throw PARSER_EXCEPTION_EXPECTED("string");
-			return;
-		}
-
-		meshNodes[i] = new MeshNode;
-		meshNodes[i]->init(token->getValue().getString());
-		skelNode->addChild(meshNodes[i]);
-		meshNodes[i]->meshSkelCtrl = new MeshSkelNodeCtrl(skelNode, meshNodes[i]);
-	}
-}

src/Scene/SkelModelNode.h

@@ -1,26 +0,0 @@
-#ifndef SKEL_MODEL_NODE_H
-#define SKEL_MODEL_NODE_H
-
-#include "MeshNode.h" 
-
-
-class MeshNode;
-class SkelNode;
-
-
-/** 
- * Skeleton model Scene node
- * It is just a group node with a derived init
- */
-class SkelModelNode: public SceneNode
-{
-	public:
-		Vec<MeshNode*> meshNodes;
-		SkelNode* skelNode;
-		
-		SkelModelNode(): SceneNode(SNT_SKEL_MODEL), skelNode(NULL) { isCompound = true; }
-		void init(const char* filename);
-		void render() {} ///< Do nothing
-};
-
-#endif

src/Scene/SkelNode.cpp

@@ -1,45 +0,0 @@
-#include "SkelNode.h"
-#include "SkelAnim.h"
-#include "Skeleton.h"
-#include "SkelAnimCtrl.h"
-#include "App.h"
-#include "MainRenderer.h"
-
-
-//======================================================================================================================
-// SkelNode                                                                                                         =
-//======================================================================================================================
-SkelNode::SkelNode(): 
-	SceneNode(SNT_SKELETON)
-{}
-
-
-//======================================================================================================================
-// init                                                                                                                =
-//======================================================================================================================
-void SkelNode::init(const char* filename)
-{
-	skeleton.loadRsrc(filename);
-	heads.resize(skeleton->bones.size());
-	tails.resize(skeleton->bones.size());
-	boneRotations.resize(skeleton->bones.size());
-	boneTranslations.resize(skeleton->bones.size());
-}
-
-
-//======================================================================================================================
-// render                                                                                                              =
-//======================================================================================================================
-void SkelNode::render()
-{
-	app->getMainRenderer().getDbg().setModelMat(Mat4(getWorldTransform()));
-	app->getMainRenderer().getDbg().setColor(Vec4(1.0, 0.0, 0.0, 1.0));
-	app->getMainRenderer().getDbg().setModelMat(Mat4(getWorldTransform()));
-
-	Vec<Vec3> positions;
-
-	for(uint i=0; i<skeleton->bones.size(); i++)
-	{
-		app->getMainRenderer().getDbg().drawLine(heads[i], tails[i], Vec4(1.0));
-	}
-}

src/Scene/SkelNode.h

@@ -1,30 +0,0 @@
-#ifndef SKEL_NODE_H
-#define SKEL_NODE_H
-
-#include <memory>
-#include "SceneNode.h"
-#include "SkelAnimCtrl.h"
-#include "RsrcPtr.h"
-#include "Skeleton.h"
-
-
-/**
- * Scene node that extends the Skeleton resource
- */
-class SkelNode: public SceneNode
-{
-	public:
-		RsrcPtr<Skeleton> skeleton; ///< The skeleton resource
-		Vec<Vec3> heads;
-		Vec<Vec3> tails;
-		Vec<Mat3> boneRotations;
-		Vec<Vec3> boneTranslations;
-
-		SkelNode();
-		void render();
-		void init(const char* filename);
-
-};
-
-
-#endif