- Making a few nested classes seperate

- The static models are getting rendered correctly
- WIP on the tranform feedback skinning

shaders/MsMpGeneric.glsl

@@ -4,8 +4,7 @@
 /// in all the buffers
 /// 
 /// Control defines:
-/// DIFFUSE_MAPPING, NORMAL_MAPPING, SPECULAR_MAPPING, PARALLAX_MAPPING, ENVIRONMENT_MAPPING, ALPHA_TESTING,
-/// HARDWARE_SKINNING
+/// DIFFUSE_MAPPING, NORMAL_MAPPING, SPECULAR_MAPPING, PARALLAX_MAPPING, ENVIRONMENT_MAPPING, ALPHA_TESTING
  
 #if defined(ALPHA_TESTING) && !defined(DIFFUSE_MAPPING)
 	#error "Cannot have ALPHA_TESTING without DIFFUSE_MAPPING"
@@ -27,10 +26,6 @@
 
 #pragma anki vertShaderBegins
 
-#if defined(HARDWARE_SKINNING)
-	#pragma anki include "shaders/hw_skinning.glsl"
-#endif
-
 /// @name Attributes
 /// @{
 in vec3 position;
@@ -70,34 +65,13 @@ out vec3 vVertPosViewSpace; ///< For env mapping. AKA view vector
 void main()
 {
 	// calculate the vert pos, normal and tangent
+	vNormal = normalMat * normal;
 
-	// if we have hardware skinning then:
-	#if defined(HARDWARE_SKINNING)
-		mat3 _rot_;
-		vec3 _tsl_;
-
-		HWSkinning(_rot_, _tsl_);
-
-		vNormal = normalMat * (_rot_ * normal);
-
-		#if NEEDS_TANGENT
-			vTangent = normalMat * (_rot_ * vec3(tangent));
-		#endif
-
-		vec3 _posLocalSpace_ = (_rot_ * position) + _tsl_;
-		gl_Position =  modelViewProjectionMat * vec4(_posLocalSpace_, 1.0);
-
-	// if DONT have hardware skinning
-	#else
-		vNormal = normalMat * normal;
-
-		#if NEEDS_TANGENT
-			vTangent = normalMat * vec3(tangent);
-		#endif
-
-		gl_Position = modelViewProjectionMat * vec4(position, 1.0);
+	#if NEEDS_TANGENT
+		vTangent = normalMat * vec3(tangent);
 	#endif
 
+	gl_Position = modelViewProjectionMat * vec4(position, 1.0);
 
 	// calculate the rest
 

src/Main.cpp

@@ -176,11 +176,11 @@ void init()
 
 
 	// Imp
-	imp = new ModelNode();
+	/*imp = new ModelNode();
 	imp->init("models/imp/imp.mdl");
 	imp->skelAnimModelNodeCtrl = new SkelAnimModelNodeCtrl(*imp);
 	imp->skelAnimModelNodeCtrl->set(imp->getModel().getSkelAnims()[0].get());
-	imp->skelAnimModelNodeCtrl->setStep(0.8);
+	imp->skelAnimModelNodeCtrl->setStep(0.8);*/
 
 	return;
 

src/Renderer/Bs.cpp

@@ -91,18 +91,18 @@ void Bs::run()
 	for(; it != app->getScene().modelNodes.end(); ++it)
 	{
 		const ModelNode& mn = *(*it);
-		boost::ptr_vector<Model::SubModel>::const_iterator it = mn.getModel().getSubModels().begin();
-		for(; it != mn.getModel().getSubModels().end(); it++)
+		boost::ptr_vector<ModelNodePatch>::const_iterator it = mn.getModelNodePatches().begin();
+		for(; it != mn.getModelNodePatches().end(); it++)
 		{
-			const Model::SubModel& sm = *it;
+			const ModelNodePatch& sm = *it;
 
-			if(!sm.getMaterial().renderInBlendingStage())
+			if(!sm.getCpMtl().renderInBlendingStage())
 			{
 				continue;
 			}
 
 			// refracts ?
-			if(sm.getMaterial().getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI))
+			if(sm.getCpMtl().getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI))
 			{
 				//
 				// Stage 0: Render to the temp FAI
@@ -114,12 +114,12 @@ void Bs::run()
 				glStencilFunc(GL_ALWAYS, 0x1, 0x1);
 				glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 
-				r.setupShaderProg(sm.getMaterial(), mn, r.getCamera());
+				r.setupShaderProg(sm.getCpMtl(), mn, r.getCamera());
 				glDisable(GL_BLEND); // a hack
 
-				sm.getVao().bind();
-				glDrawElements(GL_TRIANGLES, sm.getMesh().getVertIdsNum(), GL_UNSIGNED_SHORT, 0);
-				sm.getVao().unbind();
+				sm.getCpVao().bind();
+				glDrawElements(GL_TRIANGLES, sm.getModelPatchRsrc().getMesh().getVertIdsNum(), GL_UNSIGNED_SHORT, 0);
+				sm.getCpVao().unbind();
 
 				//
 				// Stage 1: Render the temp FAI to prePassFai
@@ -129,10 +129,10 @@ void Bs::run()
 				glStencilFunc(GL_EQUAL, 0x1, 0x1);
 				glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 
-				if(sm.getMaterial().isBlendingEnabled())
+				if(sm.getCpMtl().isBlendingEnabled())
 				{
 					glEnable(GL_BLEND);
-					glBlendFunc(sm.getMaterial().getBlendingSfactor(), sm.getMaterial().getBlendingDfactor());
+					glBlendFunc(sm.getCpMtl().getBlendingSfactor(), sm.getCpMtl().getBlendingDfactor());
 				}
 				else
 				{
@@ -153,11 +153,11 @@ void Bs::run()
 			// no rafraction
 			else
 			{
-				r.setupShaderProg(sm.getMaterial(), mn, r.getCamera());
+				r.setupShaderProg(sm.getCpMtl(), mn, r.getCamera());
 
-				sm.getVao().bind();
-				glDrawElements(GL_TRIANGLES, sm.getMesh().getVertIdsNum(), GL_UNSIGNED_SHORT, 0);
-				sm.getVao().unbind();
+				sm.getCpVao().bind();
+				glDrawElements(GL_TRIANGLES, sm.getModelPatchRsrc().getMesh().getVertIdsNum(), GL_UNSIGNED_SHORT, 0);
+				sm.getCpVao().unbind();
 			}
 		} // end for all subModels
 	} // end for all modelNodes

src/Renderer/BufferObjects/Vao.cpp

@@ -28,7 +28,7 @@ void Vao::attachArrayBufferVbo(const Vbo& vbo, uint attribVarLocation, GLint siz
 //======================================================================================================================
 // attachArrayBufferVbo                                                                                                =
 //======================================================================================================================
-void Vao::attachArrayBufferVbo(const Vbo& vbo, const ShaderProg::AttribVar& attribVar, GLint size, GLenum type,
+void Vao::attachArrayBufferVbo(const Vbo& vbo, const SProgAttribVar& attribVar, GLint size, GLenum type,
 		                           GLboolean normalized, GLsizei stride, const GLvoid* pointer)
 {
 	attachArrayBufferVbo(vbo, attribVar.getLoc(), size, type, normalized, stride, pointer);

src/Renderer/BufferObjects/Vao.h

@@ -38,7 +38,7 @@ class Vao
 		/// @param normalized Specifies whether fixed-point data values should be normalized
 		/// @param stride Specifies the byte offset between consecutive generic vertex attributes
 		/// @param pointer Specifies a offset of the first component of the first generic vertex attribute in the array
-		void attachArrayBufferVbo(const Vbo& vbo, const ShaderProg::AttribVar& attribVar, GLint size, GLenum type,
+		void attachArrayBufferVbo(const Vbo& vbo, const SProgAttribVar& attribVar, GLint size, GLenum type,
 		                          GLboolean normalized, GLsizei stride, const GLvoid* pointer);
 
 		/// Attach an array buffer VBO. See @link http://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribPointer.xml
@@ -75,6 +75,7 @@ inline void Vao::create()
 	ON_GL_FAIL_THROW_EXCEPTION();
 }
 
+
 inline Vao::~Vao()
 {
 	if(isCreated())

src/Renderer/Renderer.cpp

@@ -250,10 +250,10 @@ void Renderer::setupShaderProg(const Material& mtl, const ModelNode& modelNode,
 	//
 	// set user defined vars
 	//
-	boost::ptr_vector<Material::UserDefinedUniVar>::const_iterator it = mtl.getUserDefinedVars().begin();
+	boost::ptr_vector<MtlUserDefinedVar>::const_iterator it = mtl.getUserDefinedVars().begin();
 	for(; it !=  mtl.getUserDefinedVars().end(); it++)
 	{
-		const Material::UserDefinedUniVar& udv = *it;
+		const MtlUserDefinedVar& udv = *it;
 
 		switch(udv.getUniVar().getGlDataType())
 		{
@@ -267,16 +267,16 @@ void Renderer::setupShaderProg(const Material& mtl, const ModelNode& modelNode,
 				{
 					switch(udv.getFai())
 					{
-						case Material::MS_DEPTH_FAI:
+						case MtlUserDefinedVar::MS_DEPTH_FAI:
 							udv.getUniVar().setTexture(ms->getDepthFai(), textureUnit);
 							break;
-						case Material::IS_FAI:
+						case MtlUserDefinedVar::IS_FAI:
 							udv.getUniVar().setTexture(is->getFai(), textureUnit);
 							break;
-						case Material::PPS_PRE_PASS_FAI:
+						case MtlUserDefinedVar::PPS_PRE_PASS_FAI:
 							udv.getUniVar().setTexture(pps->getPrePassFai(), textureUnit);
 							break;
-						case Material::PPS_POST_PASS_FAI:
+						case MtlUserDefinedVar::PPS_POST_PASS_FAI:
 							udv.getUniVar().setTexture(pps->getPostPassFai(), textureUnit);
 							break;
 						default:
@@ -304,21 +304,6 @@ void Renderer::setupShaderProg(const Material& mtl, const ModelNode& modelNode,
 		}
 	}
 
-	//
-	// Set the bone transformations
-	//
-	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(&modelNode.getBoneTranslations()[0],
-		                                                               modelNode.getBoneTranslations().size());
-	}
-
 	ON_GL_FAIL_THROW_EXCEPTION();
 }
 
@@ -328,14 +313,14 @@ void Renderer::setupShaderProg(const Material& mtl, const ModelNode& modelNode,
 //======================================================================================================================
 void Renderer::renderModelNode(const ModelNode& modelNode, const Camera& cam, ModelNodeRenderType type) const
 {
-	boost::ptr_vector<Model::SubModel>::const_iterator it = modelNode.getModel().getSubModels().begin();
-	for(; it != modelNode.getModel().getSubModels().end(); it++)
+	boost::ptr_vector<ModelNodePatch>::const_iterator it = modelNode.getModelNodePatches().begin();
+	for(; it != modelNode.getModelNodePatches().end(); it++)
 	{
-		const Model::SubModel& subModel = *it;
+		const ModelNodePatch& modelNodePatch = *it;
 
-		if((type == MNRT_MS && subModel.getMaterial().renderInBlendingStage()) ||
-		   (type == MNRT_BS && !subModel.getMaterial().renderInBlendingStage()) ||
-		   (type == MNRT_DP && subModel.getMaterial().renderInBlendingStage()))
+		if((type == MNRT_MS && modelNodePatch.getCpMtl().renderInBlendingStage()) ||
+		   (type == MNRT_BS && !modelNodePatch.getCpMtl().renderInBlendingStage()) ||
+		   (type == MNRT_DP && modelNodePatch.getDpMtl().renderInBlendingStage()))
 		{
 			continue;
 		}
@@ -344,20 +329,20 @@ void Renderer::renderModelNode(const ModelNode& modelNode, const Camera& cam, Mo
 		const Vao* vao;
 		if(type == MNRT_MS || type == MNRT_BS)
 		{
-			mtl = &subModel.getMaterial();
-			vao = &subModel.getVao();
+			mtl = &modelNodePatch.getCpMtl();
+			vao = &modelNodePatch.getCpVao();
 		}
 		else
 		{
-			mtl = &subModel.getDpMaterial();
-			vao = &subModel.getDpVao();
+			mtl = &modelNodePatch.getDpMtl();
+			vao = &modelNodePatch.getDpVao();
 		}
 
 		// Shader
 		setupShaderProg(*mtl, modelNode, cam);
 
 		vao->bind();
-		glDrawElements(GL_TRIANGLES, subModel.getMesh().getVertIdsNum(), GL_UNSIGNED_SHORT, 0);
+		glDrawElements(GL_TRIANGLES, modelNodePatch.getModelPatchRsrc().getMesh().getVertIdsNum(), GL_UNSIGNED_SHORT, 0);
 		vao->unbind();
 	}
 }

src/Renderer/SkinsDeformer.h

@@ -4,6 +4,9 @@
 #include "RsrcPtr.h"
 
 
+class ShaderProg;
+
+
 ///
 class SkinsDeformer
 {

src/Resources/Core/Resource.h

@@ -34,7 +34,8 @@ class Resource
 			RT_EXTENSION,
 			RT_PARTICLE_EMITTER_PROPS,
 			RT_SCRIPT,
-			RT_MODEL
+			RT_MODEL,
+			RT_SKIN
 		};
 
 	PROPERTY_R(std::string, path, getRsrcPath);

src/Resources/Core/RsrcContainers.cpp

@@ -9,6 +9,7 @@
 #include "ParticleEmitterProps.h"
 #include "Script.h"
 #include "Model.h"
+#include "Skin.h"
 
 
 namespace RsrcContainers {
@@ -23,5 +24,6 @@ RsrcContainer<LightData> lightProps;
 RsrcContainer<ParticleEmitterProps> particleEmitterProps;
 RsrcContainer<Script> scripts;
 RsrcContainer<Model> models;
+RsrcContainer<Skin> skins;
 
 }

src/Resources/Core/RsrcPtr.cpp

@@ -1,8 +1,8 @@
 #include "RsrcPtr.h"
 #include "RsrcContainer.h"
 #include "Texture.h"
-#include "Material.h"
 #include "ShaderProg.h"
+#include "Material.h"
 #include "Mesh.h"
 #include "Skeleton.h"
 #include "SkelAnim.h"
@@ -10,6 +10,7 @@
 #include "ParticleEmitterProps.h"
 #include "Script.h"
 #include "Model.h"
+#include "Skin.h"
 
 
 namespace RsrcContainers {
@@ -24,6 +25,7 @@ extern RsrcContainer<LightData> lightProps;
 extern RsrcContainer<ParticleEmitterProps> particleEmitterProps;
 extern RsrcContainer<Script> scripts;
 extern RsrcContainer<Model> models;
+extern RsrcContainer<Skin> skins;
 
 }
 
@@ -141,6 +143,17 @@ bool RsrcPtr<Model>::loadRsrc(const char* filename)
 }
 
 
+//======================================================================================================================
+// loadRsrc <Skin>                                                                                                    =
+//======================================================================================================================
+template<>
+bool RsrcPtr<Skin>::loadRsrc(const char* filename)
+{
+	LOAD_RSRC(skins);
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+
 //======================================================================================================================
 // unload <Texture>                                                                                                    =
 //======================================================================================================================
@@ -240,3 +253,13 @@ void RsrcPtr<Model>::unload()
 {
 	UNLOAD_RSRC(models);
 }
+
+
+//======================================================================================================================
+// unload <Skin>                                                                                                      =
+//======================================================================================================================
+template<>
+void RsrcPtr<Skin>::unload()
+{
+	UNLOAD_RSRC(skins);
+}

src/Resources/Core/RsrcPtr.h

@@ -3,10 +3,6 @@
 
 #include "Exception.h"
 
-#ifndef NULL
-	#define NULL 0
-#endif
-
 
 /// This is a special smart pointer that points to Resource derivatives. It looks like auto_ptr but the main difference
 /// is that when its out of scope it tries to unload the resource.

src/Resources/Material.cpp

@@ -9,20 +9,9 @@
 #include "Texture.h"
 #include "ShaderProg.h"
 #include "App.h"
-#include "MainRenderer.h"
 #include "PropertyTree.h"
 
 
-//======================================================================================================================
-// Constructor                                                                                                         =
-//======================================================================================================================
-Material::UserDefinedUniVar::UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, const char* texFilename):
-	sProgVar(sProgVar)
-{
-	texture.loadRsrc(texFilename);
-}
-
-
 //======================================================================================================================
 // Statics                                                                                                             =
 //======================================================================================================================
@@ -31,16 +20,11 @@ Material::StdVarNameAndGlDataTypePair Material::stdAttribVarInfos[SAV_NUM] =
 	{"position", GL_FLOAT_VEC3},
 	{"tangent", GL_FLOAT_VEC4},
 	{"normal", GL_FLOAT_VEC3},
-	{"texCoords", GL_FLOAT_VEC2},
-	{"vertWeightBonesNum", GL_FLOAT},
-	{"vertWeightBoneIds", GL_FLOAT_VEC4},
-	{"vertWeightWeights", GL_FLOAT_VEC4}
+	{"texCoords", GL_FLOAT_VEC2}
 };
 
 Material::StdVarNameAndGlDataTypePair Material::stdUniVarInfos[SUV_NUM] =
 {
-	{"skinningRotations", GL_FLOAT_MAT3},
-	{"skinningTranslations", GL_FLOAT_VEC3},
 	{"modelMat", GL_FLOAT_MAT4},
 	{"viewMat", GL_FLOAT_MAT4},
 	{"projectionMat", GL_FLOAT_MAT4},
@@ -67,14 +51,12 @@ Material::PreprocDefines Material::msGenericDefines [] =
 	{"PARALLAX_MAPPING", 'p'},
 	{"ENVIRONMENT_MAPPING", 'e'},
 	{"ALPHA_TESTING", 'a'},
-	{"HARDWARE_SKINNING", 'h'},
 	{NULL, NULL}
 };
 
 Material::PreprocDefines Material::dpGenericDefines [] =
 {
 	{"ALPHA_TESTING", 'a'},
-	{"HARDWARE_SKINNING", 'h'},
 	{NULL, NULL}
 };
 
@@ -274,7 +256,7 @@ void Material::load(const char* filename)
 
 				const ptree& valueTree = userDefinedVarTree.get_child("value");
 
-				const ShaderProg::UniVar& uni = *shaderProg->findUniVar(varName.c_str());
+				const SProgUniVar& uni = *shaderProg->findUniVar(varName.c_str());
 
 				// read the values
 				switch(uni.getGlDataType())
@@ -287,25 +269,25 @@ void Material::load(const char* filename)
 
 						if(texture)
 						{
-							userDefinedVars.push_back(new UserDefinedUniVar(uni, texture.get().c_str()));
+							userDefinedVars.push_back(new MtlUserDefinedVar(uni, texture.get().c_str()));
 						}
 						else if(fai)
 						{
 							if(fai.get() == "msDepthFai")
 							{
-								userDefinedVars.push_back(new UserDefinedUniVar(uni, MS_DEPTH_FAI));
+								userDefinedVars.push_back(new MtlUserDefinedVar(uni, MtlUserDefinedVar::MS_DEPTH_FAI));
 							}
 							else if(fai.get() == "isFai")
 							{
-								userDefinedVars.push_back(new UserDefinedUniVar(uni, IS_FAI));
+								userDefinedVars.push_back(new MtlUserDefinedVar(uni, MtlUserDefinedVar::IS_FAI));
 							}
 							else if(fai.get() == "ppsPrePassFai")
 							{
-								userDefinedVars.push_back(new UserDefinedUniVar(uni, PPS_PRE_PASS_FAI));
+								userDefinedVars.push_back(new MtlUserDefinedVar(uni, MtlUserDefinedVar::PPS_PRE_PASS_FAI));
 							}
 							else if(fai.get() == "ppsPostPassFai")
 							{
-								userDefinedVars.push_back(new UserDefinedUniVar(uni, PPS_POST_PASS_FAI));
+								userDefinedVars.push_back(new MtlUserDefinedVar(uni, MtlUserDefinedVar::PPS_POST_PASS_FAI));
 							}
 							else
 							{
@@ -321,19 +303,19 @@ void Material::load(const char* filename)
 					}
 					// float
 					case GL_FLOAT:
-						userDefinedVars.push_back(new UserDefinedUniVar(uni, PropertyTree::getFloat(valueTree)));
+						userDefinedVars.push_back(new MtlUserDefinedVar(uni, PropertyTree::getFloat(valueTree)));
 						break;
 						// vec2
 					case GL_FLOAT_VEC2:
-						userDefinedVars.push_back(new UserDefinedUniVar(uni, PropertyTree::getVec2(valueTree)));
+						userDefinedVars.push_back(new MtlUserDefinedVar(uni, PropertyTree::getVec2(valueTree)));
 						break;
 						// vec3
 					case GL_FLOAT_VEC3:
-						userDefinedVars.push_back(new UserDefinedUniVar(uni, PropertyTree::getVec3(valueTree)));
+						userDefinedVars.push_back(new MtlUserDefinedVar(uni, PropertyTree::getVec3(valueTree)));
 						break;
 						// vec4
 					case GL_FLOAT_VEC4:
-						userDefinedVars.push_back(new UserDefinedUniVar(uni, PropertyTree::getVec4(valueTree)));
+						userDefinedVars.push_back(new MtlUserDefinedVar(uni, PropertyTree::getVec4(valueTree)));
 						break;
 				};
 			} // end for all userDefinedVars

src/Resources/Material.h

@@ -6,8 +6,8 @@
 #include "Math.h"
 #include "Resource.h"
 #include "ShaderProg.h"
-#include "Texture.h"
 #include "RsrcPtr.h"
+#include "MtlUserDefinedVar.h"
 
 
 /// Mesh material Resource
@@ -73,16 +73,13 @@ class Material: public Resource
 	// Nested                                                                                                            =
 	//====================================================================================================================
 	public:
-		/// Standard attribute variables that are acceptable inside the material stage @ref ShaderProg
+		/// Standard attribute variables that are acceptable inside the @ref ShaderProg
 		enum StdAttribVars
 		{
 			SAV_POSITION,
 			SAV_TANGENT,
 			SAV_NORMAL,
 			SAV_TEX_COORDS,
-			SAV_VERT_WEIGHT_BONES_NUM,
-			SAV_VERT_WEIGHT_BONE_IDS,
-			SAV_VERT_WEIGHT_WEIGHTS,
 			SAV_NUM
 		};
 
@@ -93,9 +90,6 @@ class Material: public Resource
 		/// - The generic material GLSL shader (maybe)
 		enum StdUniVars
 		{
-			// Skinning
-			SUV_SKINNING_ROTATIONS,
-			SUV_SKINNING_TRANSLATIONS,
 			// Matrices
 			SUV_MODEL_MAT,
 			SUV_VIEW_MAT,
@@ -119,40 +113,6 @@ class Material: public Resource
 			SUV_NUM ///< The number of standard uniform variables
 		};
 
-		/// The renderer's FAIs
-		enum Fai
-		{
-			MS_DEPTH_FAI, ///< Avoid it in MS
-			IS_FAI, ///< Use it anywhere
-			PPS_PRE_PASS_FAI, ///< Avoid it in BS
-			PPS_POST_PASS_FAI ///< Use it anywhere
-		};
-
-		/// Class for user defined material variables that will be passes in to the shader
-		class UserDefinedUniVar
-		{
-			PROPERTY_R(float, float_, getFloat)
-			PROPERTY_R(Vec2, vec2, getVec2)
-			PROPERTY_R(Vec3, vec3, getVec3)
-			PROPERTY_R(Vec4, vec4, getVec4)
-			PROPERTY_R(Fai, fai, getFai)
-
-			public:
-				UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, const char* texFilename);
-				UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, Fai fai);
-				UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, float f);
-				UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, const Vec2& v);
-				UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, const Vec3& v);
-				UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, const Vec4& v);
-
-				const ShaderProg::UniVar& getUniVar() const {return sProgVar;}
-				const Texture* getTexture() const {return texture.get();}
-
-			private:
-				const ShaderProg::UniVar& sProgVar;
-				RsrcPtr<Texture> texture;
-		}; // end UserDefinedVar
-
 	//====================================================================================================================
 	// Properties                                                                                                        =
 	//====================================================================================================================
@@ -179,15 +139,12 @@ class Material: public Resource
 
 		/// @name Accessors
 		/// @{
-		const ShaderProg::AttribVar* getStdAttribVar(StdAttribVars id) const {return stdAttribVars[id];}
-		const ShaderProg::UniVar* getStdUniVar(StdUniVars id) const {return stdUniVars[id];}
+		const SProgAttribVar* getStdAttribVar(StdAttribVars id) const {return stdAttribVars[id];}
+		const SProgUniVar* getStdUniVar(StdUniVars id) const {return stdUniVars[id];}
 		const ShaderProg& getShaderProg() const {return *shaderProg.get();}
-		const boost::ptr_vector<UserDefinedUniVar>& getUserDefinedVars() const {return userDefinedVars;}
+		const boost::ptr_vector<MtlUserDefinedVar>& getUserDefinedVars() const {return userDefinedVars;}
 		/// @}
 
-		/// @return Return true if the shader has references to hardware skinning
-		bool hasHwSkinning() const {return stdAttribVars[SAV_VERT_WEIGHT_BONES_NUM] != NULL;}
-
 		/// @return Return true if the shader has references to texture coordinates
 		bool hasTexCoords() const {return stdAttribVars[SAV_TEX_COORDS] != NULL;}
 
@@ -215,10 +172,10 @@ class Material: public Resource
 		static PreprocDefines dpGenericDefines[]; ///< Depth pass defines accepted in DpGeneric.glsl
 		static StdVarNameAndGlDataTypePair stdAttribVarInfos[SAV_NUM];
 		static StdVarNameAndGlDataTypePair stdUniVarInfos[SUV_NUM];
-		const ShaderProg::AttribVar* stdAttribVars[SAV_NUM];
-		const ShaderProg::UniVar* stdUniVars[SUV_NUM];
+		const SProgAttribVar* stdAttribVars[SAV_NUM];
+		const SProgUniVar* stdUniVars[SUV_NUM];
 		RsrcPtr<ShaderProg> shaderProg; ///< The most important aspect of materials
-		boost::ptr_vector<UserDefinedUniVar> userDefinedVars;
+		boost::ptr_vector<MtlUserDefinedVar> userDefinedVars;
 
 		/// The func sweeps all the variables of the shader program to find standard shader program variables. It updates
 		/// the stdAttribVars and stdUniVars arrays.
@@ -235,38 +192,4 @@ class Material: public Resource
 };
 
 
-//======================================================================================================================
-// Inlines                                                                                                             =
-//======================================================================================================================
-
-inline Material::UserDefinedUniVar::UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, Fai fai_):
-	fai(fai_),
-	sProgVar(sProgVar)
-{}
-
-
-inline Material::UserDefinedUniVar::UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, float f):
-	float_(f),
-	sProgVar(sProgVar)
-{}
-
-
-inline Material::UserDefinedUniVar::UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, const Vec2& v):
-	vec2(v),
-	sProgVar(sProgVar)
-{}
-
-
-inline Material::UserDefinedUniVar::UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, const Vec3& v):
-	vec3(v),
-	sProgVar(sProgVar)
-{}
-
-
-inline Material::UserDefinedUniVar::UserDefinedUniVar(const ShaderProg::UniVar& sProgVar, const Vec4& v):
-	vec4(v),
-	sProgVar(sProgVar)
-{}
-
-
 #endif

src/Resources/Mesh.h

@@ -9,7 +9,6 @@
 #include "Vbo.h"
 
 
-class Material;
 class MeshData;
 
 

src/Resources/Model.cpp

@@ -27,14 +27,6 @@ void Model::load(const char* filename)
 
   	const ptree& pt = pt_.get_child("model");
 
-  	// skeleton
-  	// NOTE: Always read that first
-  	boost::optional<std::string> skelName = pt.get_optional<std::string>("skeleton");
-  	if(skelName)
-  	{
-  		skeleton.loadRsrc(skelName.get().c_str());
-  	}
-
   	// modelPatches
   	BOOST_FOREACH(const ptree::value_type& v, pt.get_child("modelPatches"))
   	{
@@ -46,56 +38,6 @@ void Model::load(const char* filename)
   		modelPatches.push_back(sub);
   		sub->load(mesh.c_str(), material.c_str(), dpMaterial.c_str());
   	}
-
-  	// Anims
-  	boost::optional<const ptree&> skelAnimsTree = pt.get_child_optional("skelAnims");
-  	if(skelAnimsTree)
-  	{
-  		BOOST_FOREACH(const ptree::value_type& v, skelAnimsTree.get())
-  		{
-  			if(v.first != "skelAnim")
-  			{
-  				throw EXCEPTION("Expected skelAnim and no " + v.first);
-  			}
-
-  			const std::string& name = v.second.data();
-  			skelAnims.push_back(RsrcPtr<SkelAnim>());
-				skelAnims.back().loadRsrc(name.c_str());
-  		}
-  	}
-
-  	//
-  	// Sanity checks
-  	//
-
-  	// Anims require skeleton
-		if(skelAnims.size() > 0 && !hasSkeleton())
-		{
-			throw EXCEPTION("You have skeleton animations but no skeleton");
-		}
-
-		// Anims and skel bones size check
-		for(uint i = 0; i < skelAnims.size(); i++)
-		{
-			// Bone number problem
-			if(skelAnims[i]->bones.size() != skeleton->bones.size())
-			{
-				throw EXCEPTION("Skeleton animation \"" + skelAnims[i]->getRsrcName() + "\" and skeleton \"" +
-				                skeleton->getRsrcName() + "\" dont have equal bone count");
-			}
-		}
-
-		// if skeleton present then ModelPatches should support HW skinning
-		if(hasSkeleton())
-		{
-			for(uint i = 0; i < modelPatches.size(); i++)
-			{
-				if(!modelPatches[i].supportsHardwareSkinning())
-				{
-					throw EXCEPTION("Mesh " + modelPatches[i].getMesh().getRsrcName() + " does not support HW skinning");
-				}
-			}
-		}
 	}
 	catch(std::exception& e)
 	{

src/Resources/Model.h

@@ -4,18 +4,10 @@
 #include <boost/ptr_container/ptr_vector.hpp>
 #include "Resource.h"
 #include "RsrcPtr.h"
-#include "Object.h"
 #include "Vao.h"
 #include "ModelPatch.h"
 
 
-class Mesh;
-class Material;
-class Skeleton;
-class SkelAnim;
-class Scanner;
-
-
 /// Model is an entity that acts as a container for other resources. Models are all the non static objects in a map.
 ///
 /// XML file format:
@@ -30,12 +22,6 @@ class Scanner;
 /// 		...
 /// 		<modelPatch>...</modelPatch>
 /// 	</modelPatches>
-/// 	<skeleton>path/to/skeleton.skel</skeleton>
-/// 	<skelAnims>
-/// 		<skelAnim>path/to/anim0.sanim</skelAnim>
-/// 		...
-/// 		<skelAnim>...</skelAnim>
-/// 	</skelAnims>
 /// </model>
 /// @endcode
 ///
@@ -53,24 +39,11 @@ class Model: public Resource
 		/// @name Accessors
 		/// @{
 		const boost::ptr_vector<ModelPatch>& getModelPatches() const {return modelPatches;}
-		const Skeleton& getSkeleton() const;
-		const Vec<RsrcPtr<SkelAnim> >& getSkelAnims() const {return skelAnims;}
 		/// @}
 
-		bool hasSkeleton() const {return skeleton.get() != NULL;}
-
 	private:
 		boost::ptr_vector<ModelPatch> modelPatches; ///< The vector of ModelPatch
-		RsrcPtr<Skeleton> skeleton; ///< The skeleton. It can be empty
-		Vec<RsrcPtr<SkelAnim> > skelAnims; ///< The standard skeleton animations
 };
 
 
-inline const Skeleton& Model::getSkeleton() const
-{
-	RASSERT_THROW_EXCEPTION(!hasSkeleton());
-	return *skeleton;
-}
-
-
 #endif

src/Resources/ModelPatch.h

@@ -25,10 +25,10 @@ class ModelPatch
 		/// This only checks the mesh for vertex weights
 		bool supportsHwSkinning() const;
 
-		/// This checks if any of the materials needs normals
+		/// This checks if any of the materials need normals
 		bool supportsNormals() const;
 
-		/// This checks if any of the materials needs tangents
+		/// This checks if any of the materials need tangents
 		bool supportsTangents() const;
 
 	private:
@@ -36,6 +36,7 @@ class ModelPatch
 		RsrcPtr<Material> cpMtl; ///< Material for MS and BS
 		RsrcPtr<Material> dpMtl; ///< Material for depth passes
 
+		/// Checks if a mesh and a material are compatible
 		static void doMeshAndMtlSanityChecks(const Mesh& mesh, const Material& mtl);
 };
 

src/Resources/MtlUserDefinedVar.cpp

@@ -0,0 +1,11 @@
+#include "MtlUserDefinedVar.h"
+
+
+//======================================================================================================================
+// Constructor                                                                                                         =
+//======================================================================================================================
+MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const char* texFilename):
+	sProgVar(sProgVar)
+{
+	texture.loadRsrc(texFilename);
+}

src/Resources/MtlUserDefinedVar.h

@@ -0,0 +1,79 @@
+#ifndef MTL_USER_DEFINED_VAR_H
+#define MTL_USER_DEFINED_VAR_H
+
+#include "Properties.h"
+#include "Math.h"
+#include "SProgUniVar.h"
+#include "RsrcPtr.h"
+
+
+class Texture;
+
+
+/// Class for user defined material variables that will be passes in to the shader
+class MtlUserDefinedVar
+{
+	public:
+		/// The renderer's FAIs
+		enum Fai
+		{
+			MS_DEPTH_FAI, ///< Avoid it in MS
+			IS_FAI, ///< Use it anywhere
+			PPS_PRE_PASS_FAI, ///< Avoid it in BS
+			PPS_POST_PASS_FAI ///< Use it anywhere
+		};
+
+	PROPERTY_R(float, float_, getFloat)
+	PROPERTY_R(Vec2, vec2, getVec2)
+	PROPERTY_R(Vec3, vec3, getVec3)
+	PROPERTY_R(Vec4, vec4, getVec4)
+	PROPERTY_R(Fai, fai, getFai)
+
+	public:
+		MtlUserDefinedVar(const SProgUniVar& sProgVar, const char* texFilename);
+		MtlUserDefinedVar(const SProgUniVar& sProgVar, Fai fai);
+		MtlUserDefinedVar(const SProgUniVar& sProgVar, float f);
+		MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec2& v);
+		MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec3& v);
+		MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec4& v);
+
+		const SProgUniVar& getUniVar() const {return sProgVar;}
+		const Texture* getTexture() const {return texture.get();}
+
+	private:
+		const SProgUniVar& sProgVar;
+		RsrcPtr<Texture> texture;
+};
+
+
+inline MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, Fai fai_):
+	fai(fai_),
+	sProgVar(sProgVar)
+{}
+
+
+inline MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, float f):
+	float_(f),
+	sProgVar(sProgVar)
+{}
+
+
+inline MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec2& v):
+	vec2(v),
+	sProgVar(sProgVar)
+{}
+
+
+inline MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec3& v):
+	vec3(v),
+	sProgVar(sProgVar)
+{}
+
+
+inline MtlUserDefinedVar::MtlUserDefinedVar(const SProgUniVar& sProgVar, const Vec4& v):
+	vec4(v),
+	sProgVar(sProgVar)
+{}
+
+
+#endif

src/Resources/SProgAttribVar.h

@@ -0,0 +1,22 @@
+#ifndef S_PROG_ATTRIB_VAR_H
+#define S_PROG_ATTRIB_VAR_H
+
+#include "SProgVar.h"
+
+
+/// Attribute shader variable
+class SProgAttribVar: public SProgVar
+{
+	public:
+		SProgAttribVar(int loc_, const char* name_, GLenum glDataType_, const ShaderProg* fatherSProg_);
+		SProgAttribVar(const SProgAttribVar& var): SProgVar(var) {}
+};
+
+
+inline SProgAttribVar::SProgAttribVar(int loc_, const char* name_, GLenum glDataType_,
+                                      const ShaderProg* fatherSProg_):
+	SProgVar(loc_, name_, glDataType_, SVT_UNIFORM, fatherSProg_)
+{}
+
+
+#endif

src/Resources/SProgUniVar.cpp

@@ -0,0 +1,74 @@
+#include "SProgUniVar.h"
+#include "ShaderProg.h"
+#include "Texture.h"
+
+
+//======================================================================================================================
+// set uniforms                                                                                                        =
+//======================================================================================================================
+/// Standard set uniform checks
+/// - Check if initialized
+/// - if the current shader program is the var's shader program
+/// - if the GL driver gives the same location as the one the var has
+#define STD_SET_UNI_CHECK() \
+	RASSERT_THROW_EXCEPTION(getLoc() == -1); \
+	RASSERT_THROW_EXCEPTION(ShaderProg::getCurrentProgramGlId() != getFatherSProg().getGlId()); \
+	RASSERT_THROW_EXCEPTION(glGetUniformLocation(getFatherSProg().getGlId(), getName().c_str()) != getLoc());
+
+
+void SProgUniVar::setFloat(float f) const
+{
+	STD_SET_UNI_CHECK();
+	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT);
+	glUniform1f(getLoc(), f);
+}
+
+void SProgUniVar::setFloatVec(float f[], uint size) const
+{
+	STD_SET_UNI_CHECK();
+	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT);
+	glUniform1fv(getLoc(), size, f);
+}
+
+void SProgUniVar::setVec2(const Vec2 v2[], uint size) const
+{
+	STD_SET_UNI_CHECK();
+	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_VEC2);
+	glUniform2fv(getLoc(), size, &(const_cast<Vec2&>(v2[0]))[0]);
+}
+
+void SProgUniVar::setVec3(const Vec3 v3[], uint size) const
+{
+	STD_SET_UNI_CHECK();
+	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_VEC3);
+	glUniform3fv(getLoc(), size, &(const_cast<Vec3&>(v3[0]))[0]);
+}
+
+void SProgUniVar::setVec4(const Vec4 v4[], uint size) const
+{
+	STD_SET_UNI_CHECK();
+	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_VEC4);
+	glUniform4fv(getLoc(), size, &(const_cast<Vec4&>(v4[0]))[0]);
+}
+
+void SProgUniVar::setMat3(const Mat3 m3[], uint size) const
+{
+	STD_SET_UNI_CHECK();
+	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_MAT3);
+	glUniformMatrix3fv(getLoc(), size, true, &(m3[0])[0]);
+}
+
+void SProgUniVar::setMat4(const Mat4 m4[], uint size) const
+{
+	STD_SET_UNI_CHECK();
+	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_MAT4);
+	glUniformMatrix4fv(getLoc(), size, true, &(m4[0])[0]);
+}
+
+void SProgUniVar::setTexture(const Texture& tex, uint texUnit) const
+{
+	STD_SET_UNI_CHECK();
+	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_SAMPLER_2D && getGlDataType() != GL_SAMPLER_2D_SHADOW);
+	tex.bind(texUnit);
+	glUniform1i(getLoc(), texUnit);
+}

src/Resources/SProgUniVar.h

@@ -0,0 +1,37 @@
+#ifndef S_PROG_UNI_VAR_H
+#define S_PROG_UNI_VAR_H
+
+#include "SProgVar.h"
+#include "Math.h"
+
+
+class Texture;
+
+
+/// Uniform shader variable
+class SProgUniVar: public SProgVar
+{
+	public:
+		SProgUniVar(int loc_, const char* name_, GLenum glDataType_, const ShaderProg* fatherSProg_);
+		SProgUniVar(const SProgUniVar& var): SProgVar(var) {}
+
+		/// @name Set the var
+		/// @{
+		void setFloat(float f) const;
+		void setFloatVec(float f[], uint size = 1) const;
+		void setVec2(const Vec2 v2[], uint size = 1) const;
+		void setVec3(const Vec3 v3[], uint size = 1) const;
+		void setVec4(const Vec4 v4[], uint size = 1) const;
+		void setMat3(const Mat3 m3[], uint size = 1) const;
+		void setMat4(const Mat4 m4[], uint size = 1) const;
+		void setTexture(const Texture& tex, uint texUnit) const;
+		/// @}
+};
+
+
+inline SProgUniVar::SProgUniVar(int loc_, const char* name_, GLenum glDataType_, const ShaderProg* fatherSProg_):
+	SProgVar(loc_, name_, glDataType_, SVT_UNIFORM, fatherSProg_)
+{}
+
+
+#endif

src/Resources/SProgVar.h

@@ -0,0 +1,58 @@
+#ifndef S_PROG_VAR_H
+#define S_PROG_VAR_H
+
+#include <GL/glew.h>
+#include <string>
+#include "Properties.h"
+
+
+class ShaderProg;
+
+
+/// Shader program variable. The type is attribute or uniform
+class SProgVar
+{
+	public:
+		/// Shader var types
+		enum ShaderVarType
+		{
+			SVT_ATTRIBUTE, ///< SVT_ATTRIBUTE
+			SVT_UNIFORM    ///< SVT_UNIFORM
+		};
+
+	PROPERTY_R(GLint, loc, getLoc) ///< GL location
+	PROPERTY_R(std::string, name, getName) ///< The name inside the shader program
+	/// GL_FLOAT, GL_FLOAT_VEC2 etc. See http://www.opengl.org/sdk/docs/man/xhtml/glGetActiveUniform.xml
+	PROPERTY_R(GLenum, glDataType, getGlDataType)
+	PROPERTY_R(ShaderVarType, type, getType) ///< @ref SVT_ATTRIBUTE or @ref SVT_UNIFORM
+
+	public:
+		SProgVar(GLint loc_, const char* name_, GLenum glDataType_, ShaderVarType type_, const ShaderProg* fatherSProg_);
+		SProgVar(const SProgVar& var);
+		const ShaderProg& getFatherSProg() const {return *fatherSProg;}
+
+	private:
+		const ShaderProg* fatherSProg; ///< We need the ShaderProg of this variable mainly for sanity checks
+};
+
+
+inline SProgVar::SProgVar(GLint loc_, const char* name_, GLenum glDataType_, ShaderVarType type_,
+                          const ShaderProg* fatherSProg_):
+	loc(loc_),
+	name(name_),
+	glDataType(glDataType_),
+	type(type_),
+	fatherSProg(fatherSProg_)
+{}
+
+
+inline SProgVar::SProgVar(const SProgVar& var):
+	loc(var.loc),
+	name(var.name),
+	glDataType(var.glDataType),
+	type(var.type),
+	fatherSProg(var.fatherSProg)
+{}
+
+
+#endif

src/Resources/ShaderProg.cpp

@@ -3,7 +3,6 @@
 #include <fstream>
 #include "ShaderProg.h"
 #include "ShaderPrePreprocessor.h"
-#include "Texture.h" // For certain setters
 #include "App.h" // To get cache dir
 #include "GlException.h"
 #include "Messaging.h"
@@ -24,77 +23,6 @@ std::string ShaderProg::stdSourceCode(
 );
 
 
-//======================================================================================================================
-// set uniforms                                                                                                        =
-//======================================================================================================================
-/// Standard set uniform checks
-/// - Check if initialized
-/// - if the current shader program is the var's shader program
-/// - if the GL driver gives the same location as the one the var has
-#define STD_SET_UNI_CHECK() \
-	RASSERT_THROW_EXCEPTION(getLoc() == -1); \
-	RASSERT_THROW_EXCEPTION(ShaderProg::getCurrentProgramGlId() != fatherSProg->getGlId()); \
-	RASSERT_THROW_EXCEPTION(glGetUniformLocation(fatherSProg->getGlId(), getName().c_str()) != getLoc());
-
-
-void ShaderProg::UniVar::setFloat(float f) const
-{
-	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT);
-	glUniform1f(getLoc(), f);
-}
-
-void ShaderProg::UniVar::setFloatVec(float f[], uint size) const
-{
-	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT);
-	glUniform1fv(getLoc(), size, f);
-}
-
-void ShaderProg::UniVar::setVec2(const Vec2 v2[], uint size) const
-{
-	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_VEC2);
-	glUniform2fv(getLoc(), size, &(const_cast<Vec2&>(v2[0]))[0]);
-}
-
-void ShaderProg::UniVar::setVec3(const Vec3 v3[], uint size) const
-{
-	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_VEC3);
-	glUniform3fv(getLoc(), size, &(const_cast<Vec3&>(v3[0]))[0]);
-}
-
-void ShaderProg::UniVar::setVec4(const Vec4 v4[], uint size) const
-{
-	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_VEC4);
-	glUniform4fv(getLoc(), size, &(const_cast<Vec4&>(v4[0]))[0]);
-}
-
-void ShaderProg::UniVar::setMat3(const Mat3 m3[], uint size) const
-{
-	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_MAT3);
-	glUniformMatrix3fv(getLoc(), size, true, &(m3[0])[0]);
-}
-
-void ShaderProg::UniVar::setMat4(const Mat4 m4[], uint size) const
-{
-	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_MAT4);
-	glUniformMatrix4fv(getLoc(), size, true, &(m4[0])[0]);
-}
-
-void ShaderProg::UniVar::setTexture(const Texture& tex, uint texUnit) const
-{
-	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_SAMPLER_2D && getGlDataType() != GL_SAMPLER_2D_SHADOW);
-	tex.bind(texUnit);
-	glUniform1i(getLoc(), texUnit);
-}
-
-
 //======================================================================================================================
 // createAndCompileShader                                                                                              =
 //======================================================================================================================
@@ -150,7 +78,7 @@ uint ShaderProg::createAndCompileShader(const char* sourceCode, const char* prep
 //======================================================================================================================
 // link                                                                                                                =
 //======================================================================================================================
-void ShaderProg::link()
+void ShaderProg::link() const
 {
 	// link
 	glLinkProgram(glId);
@@ -202,7 +130,7 @@ void ShaderProg::getUniAndAttribVars()
 			continue;
 		}
 
-		attribVars.push_back(AttribVar(loc, name_, type, this));
+		attribVars.push_back(SProgAttribVar(loc, name_, type, this));
 		attribNameToVar[attribVars.back().getName().c_str()] = &attribVars.back();
 	}
 
@@ -223,7 +151,7 @@ void ShaderProg::getUniAndAttribVars()
 			continue;
 		}
 
-		uniVars.push_back(UniVar(loc, name_, type, this));
+		uniVars.push_back(SProgUniVar(loc, name_, type, this));
 		uniNameToVar[uniVars.back().getName().c_str()] = &uniVars.back();
 	}
 }
@@ -305,9 +233,9 @@ void ShaderProg::load(const char* filename)
 //======================================================================================================================
 // findUniVar                                                                                                          =
 //======================================================================================================================
-const ShaderProg::UniVar* ShaderProg::findUniVar(const char* name) const
+const SProgUniVar* ShaderProg::findUniVar(const char* name) const
 {
-	NameToUniVarIterator it = uniNameToVar.find(name);
+	NameToSProgUniVarIterator it = uniNameToVar.find(name);
 	if(it == uniNameToVar.end())
 	{
 		throw SPROG_EXCEPTION("Cannot get uniform loc \"" + name + '\"');
@@ -319,9 +247,9 @@ const ShaderProg::UniVar* ShaderProg::findUniVar(const char* name) const
 //======================================================================================================================
 // findAttribVar                                                                                                       =
 //======================================================================================================================
-const ShaderProg::AttribVar* ShaderProg::findAttribVar(const char* name) const
+const SProgAttribVar* ShaderProg::findAttribVar(const char* name) const
 {
-	NameToAttribVarIterator it = attribNameToVar.find(name);
+	NameToSProgAttribVarIterator it = attribNameToVar.find(name);
 	if(it == attribNameToVar.end())
 	{
 		throw SPROG_EXCEPTION("Cannot get attribute loc \"" + name + '\"');
@@ -335,7 +263,7 @@ const ShaderProg::AttribVar* ShaderProg::findAttribVar(const char* name) const
 //======================================================================================================================
 bool ShaderProg::uniVarExists(const char* name) const
 {
-	NameToUniVarIterator it = uniNameToVar.find(name);
+	NameToSProgUniVarIterator it = uniNameToVar.find(name);
 	return it != uniNameToVar.end();
 }
 
@@ -345,7 +273,7 @@ bool ShaderProg::uniVarExists(const char* name) const
 //======================================================================================================================
 bool ShaderProg::attribVarExists(const char* name) const
 {
-	NameToAttribVarIterator it = attribNameToVar.find(name);
+	NameToSProgAttribVarIterator it = attribNameToVar.find(name);
 	return it != attribNameToVar.end();
 }
 

src/Resources/ShaderProg.h

@@ -4,9 +4,10 @@
 #include <GL/glew.h>
 #include <limits>
 #include "Resource.h"
-#include "Math.h"
 #include "CharPtrHashMap.h"
 #include "Exception.h"
+#include "SProgUniVar.h"
+#include "SProgAttribVar.h"
 
 
 /// Shader program @ref Resource
@@ -18,67 +19,12 @@ class ShaderProg: public Resource
 {
 	friend class Material;
 	friend class RsrcContainer<ShaderProg>;
-
-	//====================================================================================================================
-	// Nested                                                                                                            =
-	//====================================================================================================================
-	public:
-		/// Shader program variable. The type is attribute or uniform
-		class Var
-		{
-			public:
-				/// Shader var types
-				enum ShaderVarType
-				{
-					SVT_ATTRIBUTE, ///< SVT_ATTRIBUTE
-					SVT_UNIFORM    ///< SVT_UNIFORM
-				};
-
-				Var(GLint loc_, const char* name_, GLenum glDataType_, ShaderVarType type_, const ShaderProg* fatherSProg_);
-				Var(const Var& var);
-				GLint getLoc() const {return loc;}
-				const std::string& getName() const {return name;}
-				GLenum getGlDataType() const {return glDataType;}
-				ShaderVarType getType() const {return type;}
-
-			protected:
-				GLint loc; ///< GL location
-				std::string name; ///< The name inside the shader program
-				GLenum glDataType; ///< GL_FLOAT, GL_FLOAT_VEC2 etc. See http://www.opengl.org/sdk/docs/man/xhtml/glGetActiveUniform.xml
-				ShaderVarType type; ///< @ref SVT_ATTRIBUTE or @ref SVT_UNIFORM
-				const ShaderProg* fatherSProg; ///< We need the ShaderProg of this variable mainly for sanity checks
-		};
-
-		/// Uniform shader variable
-		class UniVar: public Var
-		{
-			public:
-				UniVar(int loc_, const char* name_, GLenum glDataType_, const ShaderProg* fatherSProg_);
-				UniVar(const UniVar& var): Var(var) {}
-
-				void setFloat(float f) const;
-				void setFloatVec(float f[], uint size = 1) const;
-				void setVec2(const Vec2 v2[], uint size = 1) const;
-				void setVec3(const Vec3 v3[], uint size = 1) const;
-				void setVec4(const Vec4 v4[], uint size = 1) const;
-				void setMat3(const Mat3 m3[], uint size = 1) const;
-				void setMat4(const Mat4 m4[], uint size = 1) const;
-				void setTexture(const class Texture& tex, uint texUnit) const;
-		};
-
-		/// Attribute shader variable
-		class AttribVar: public Var
-		{
-			public:
-				AttribVar(int loc_, const char* name_, GLenum glDataType_, const ShaderProg* fatherSProg_);
-				AttribVar(const AttribVar& var): Var(var) {}
-		};
 		
 	private:
 		/// Uniform variable name to variable iterator
-		typedef CharPtrHashMap<UniVar*>::const_iterator NameToUniVarIterator;
+		typedef CharPtrHashMap<SProgUniVar*>::const_iterator NameToSProgUniVarIterator;
 		/// Attribute variable name to variable iterator
-		typedef CharPtrHashMap<AttribVar*>::const_iterator NameToAttribVarIterator;
+		typedef CharPtrHashMap<SProgAttribVar*>::const_iterator NameToSProgAttribVarIterator;
 
 	//====================================================================================================================
 	// Public                                                                                                            =
@@ -101,20 +47,20 @@ class ShaderProg: public Resource
 		static uint getCurrentProgramGlId();
 
 		/// Accessor to uniform vars vector
-		const Vec<UniVar>& getUniVars() const { return uniVars; }
+		const Vec<SProgUniVar>& getUniVars() const {return uniVars;}
 
 		/// Accessor to attribute vars vector
-		const Vec<AttribVar>& getAttribVars() const { return attribVars; }
+		const Vec<SProgAttribVar>& getAttribVars() const {return attribVars;}
 
 		/// Find uniform variable. On failure it throws an exception so use @ref uniVarExists to check if var exists
 		/// @param varName The name of the var
 		/// @return It returns a uniform variable
 		/// @exception Exception
-		const UniVar* findUniVar(const char* varName) const;
+		const SProgUniVar* findUniVar(const char* varName) const;
 
 		/// Find Attribute variable
 		/// @see findUniVar
-		const AttribVar* findAttribVar(const char* varName) const;
+		const SProgAttribVar* findAttribVar(const char* varName) const;
 
 		/// Uniform variable exits
 		/// @return True if uniform variable exits
@@ -144,10 +90,10 @@ class ShaderProg: public Resource
 		GLuint geomShaderGlId; ///< Geometry shader OpenGL id
 		GLuint fragShaderGlId; ///< Fragment shader OpenGL id
 		static std::string stdSourceCode; ///< Shader source that is used in ALL shader programs
-		Vec<UniVar> uniVars; ///< All the uniform variables
-		Vec<AttribVar> attribVars; ///< All the attribute variables
-		CharPtrHashMap<UniVar*> uniNameToVar;  ///< A UnorderedMap for fast variable searching
-		CharPtrHashMap<AttribVar*> attribNameToVar; ///< @see uniNameToVar
+		Vec<SProgUniVar> uniVars; ///< All the uniform variables
+		Vec<SProgAttribVar> attribVars; ///< All the attribute variables
+		CharPtrHashMap<SProgUniVar*> uniNameToVar;  ///< A UnorderedMap for fast variable searching
+		CharPtrHashMap<SProgAttribVar*> attribNameToVar; ///< @see uniNameToVar
 
 		/// Query the driver to get the vars. After the linking of the shader prog is done gather all the vars in custom
 		/// containers
@@ -175,36 +121,6 @@ class ShaderProg: public Resource
 // Inlines                                                                                                             =
 //======================================================================================================================
 
-inline ShaderProg::Var::Var(GLint loc_, const char* name_, GLenum glDataType_, ShaderVarType type_,
-                            const ShaderProg* fatherSProg_):
-	loc(loc_),
-	name(name_),
-	glDataType(glDataType_),
-	type(type_),
-	fatherSProg(fatherSProg_)
-{}
-
-
-inline ShaderProg::Var::Var(const Var& var):
-	loc(var.loc),
-	name(var.name),
-	glDataType(var.glDataType),
-	type(var.type),
-	fatherSProg(var.fatherSProg)
-{}
-
-
-inline ShaderProg::UniVar::UniVar(int loc_, const char* name_, GLenum glDataType_, const ShaderProg* fatherSProg_):
-	Var(loc_, name_, glDataType_, SVT_UNIFORM, fatherSProg_)
-{}
-
-
-inline ShaderProg::AttribVar::AttribVar(int loc_, const char* name_, GLenum glDataType_,
-                                        const ShaderProg* fatherSProg_):
-	Var(loc_, name_, glDataType_, SVT_UNIFORM, fatherSProg_)
-{}
-
-
 inline ShaderProg::ShaderProg():
 	Resource(RT_SHADER_PROG),
 	glId(std::numeric_limits<uint>::max())

src/Resources/Skin.cpp

@@ -0,0 +1,80 @@
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/foreach.hpp>
+#include "Skin.h"
+#include "Model.h"
+#include "Skeleton.h"
+#include "SkelAnim.h"
+#include "Mesh.h"
+#include "ModelPatch.h"
+
+
+//======================================================================================================================
+// load                                                                                                                =
+//======================================================================================================================
+void Skin::load(const char* filename)
+{
+	try
+  {
+		//
+		// Load
+		//
+		using namespace boost::property_tree;
+		ptree pt_;
+  	read_xml(filename, pt_);
+
+  	const ptree& pt = pt_.get_child("skin");
+
+  	// model
+  	model.loadRsrc(pt.get<std::string>("model").c_str());
+
+  	// skeleton
+  	skeleton.loadRsrc(pt.get<std::string>("skeleton").c_str());
+
+  	// Anims
+  	boost::optional<const ptree&> skelAnimsTree = pt.get_child_optional("skelAnims");
+  	if(skelAnimsTree)
+  	{
+  		BOOST_FOREACH(const ptree::value_type& v, skelAnimsTree.get())
+  		{
+  			if(v.first != "skelAnim")
+  			{
+  				throw EXCEPTION("Expected skelAnim and no " + v.first);
+  			}
+
+  			const std::string& name = v.second.data();
+  			skelAnims.push_back(RsrcPtr<SkelAnim>());
+				skelAnims.back().loadRsrc(name.c_str());
+  		}
+  	}
+
+  	//
+  	// Sanity checks
+  	//
+
+  	// Anims and skel bones num check
+		for(uint i = 0; i < skelAnims.size(); i++)
+		{
+			// Bone number problem
+			if(skelAnims[i]->bones.size() != skeleton->bones.size())
+			{
+				throw EXCEPTION("Skeleton animation \"" + skelAnims[i]->getRsrcName() + "\" and skeleton \"" +
+				                skeleton->getRsrcName() + "\" dont have equal bone count");
+			}
+		}
+
+		// All meshes should have vert weights
+		for(uint i = 0; i < model->getModelPatches().size(); i++)
+		{
+			if(!model->getModelPatches()[i].supportsHwSkinning())
+			{
+				throw EXCEPTION("Mesh " + model->getModelPatches()[i].getMesh().getRsrcName() +
+				                " does not support HW skinning");
+			}
+		}
+  }
+	catch(std::exception& e)
+	{
+		throw EXCEPTION("Skin \"" + filename + "\": " + e.what());
+	}
+}

src/Resources/Skin.h

@@ -0,0 +1,48 @@
+#ifndef SKIN_H
+#define SKIN_H
+
+#include "Resource.h"
+#include "RsrcPtr.h"
+#include "Model.h"
+
+
+class Skeleton;
+class SkelAnim;
+
+
+/// XML file format:
+/// @code
+/// <skin>
+/// 	<model>path/to/model.mdl</model>
+/// 	<skeleton>path/to/skeleton.skel</skeleton>
+/// 	<skelAnims>
+/// 		<skelAnim>path/to/anim0.sanim</skelAnim>
+/// 		...
+/// 		<skelAnim>...</skelAnim>
+/// 	</skelAnims>
+/// </skin>
+/// @endcode
+class Skin: public Resource
+{
+	public:
+		/// Nothing special
+		Skin(): Resource(RT_SKIN) {}
+
+		/// Implements Resource::load
+		void load(const char*);
+
+		/// @name Accessors
+		/// @{
+		const boost::ptr_vector<ModelPatch>& getModelPatches() const {return model->getModelPatches();}
+		const Skeleton& getSkeleton() const;
+		const Vec<RsrcPtr<SkelAnim> >& getSkelAnims() const {return skelAnims;}
+		/// @}
+
+	private:
+		RsrcPtr<Model> model;
+		RsrcPtr<Skeleton> skeleton; ///< The skeleton
+		Vec<RsrcPtr<SkelAnim> > skelAnims; ///< The standard skeleton animations
+};
+
+
+#endif

src/Resources/Texture.h

@@ -91,4 +91,5 @@ inline bool Texture::isLoaded() const
 	return glId != std::numeric_limits<uint>::max();
 }
 
+
 #endif

src/Scene/Controllers/SkelAnimModelNodeCtrl.cpp

@@ -156,7 +156,7 @@ void SkelAnimModelNodeCtrl::deform(const Skeleton& skeleton, const Vec<Vec3>& bo
 //======================================================================================================================
 void SkelAnimModelNodeCtrl::update(float)
 {
-	frame += step;
+	/*frame += step;
 	if(frame > skelAnim->framesNum) // if the crnt is finished then play the next or loop the crnt
 	{
 		frame = 0.0;
@@ -168,5 +168,5 @@ void SkelAnimModelNodeCtrl::update(float)
 	{
 		deform(modelNode.getModel().getSkeleton(), modelNode.getBoneTranslations(), modelNode.getBoneRotations(),
 		       modelNode.getHeads(), modelNode.getTails());
-	}
+	}*/
 }

src/Scene/ModelNode.cpp

@@ -1,7 +1,6 @@
 #include "ModelNode.h"
 #include "Model.h"
 #include "Skeleton.h"
-#include "ModelNodePatch.h"
 
 
 //======================================================================================================================
@@ -11,17 +10,8 @@ void ModelNode::init(const char* filename)
 {
 	model.loadRsrc(filename);
 
-	if(model->hasSkeleton())
-	{
-		heads.resize(model->getSkeleton().bones.size());
-		tails.resize(model->getSkeleton().bones.size());
-		boneRotations.resize(model->getSkeleton().bones.size());
-		boneTranslations.resize(model->getSkeleton().bones.size());
-
-	}
-
 	for(uint i = 0; i < model->getModelPatches().size(); i++)
 	{
-		patches.push_back(new ModelNodePatch(model->getModelPatches()[i], model->hasSkeleton()));
+		patches.push_back(new ModelNodePatch(model->getModelPatches()[i]));
 	}
 }

src/Scene/ModelNode.h

@@ -6,24 +6,16 @@
 #include "SceneNode.h"
 #include "RsrcPtr.h"
 #include "Properties.h"
+#include "ModelNodePatch.h"
 
 
 class Model;
-class SkelAnimModelNodeCtrl;
-class ModelNodePatch;
 
 
 /// The model scene node
 class ModelNode: public SceneNode
 {
-	PROPERTY_RW(Vec<Vec3>, heads, getHeads, setHeads)
-	PROPERTY_RW(Vec<Vec3>, tails, getTails, setTails)
-	PROPERTY_RW(Vec<Mat3>, boneRotations, getBoneRotations, setBoneRotations)
-	PROPERTY_RW(Vec<Vec3>, boneTranslations, getBoneTranslations, setBoneTranslations)
-
 	public:
-		SkelAnimModelNodeCtrl* skelAnimModelNodeCtrl; ///< @todo Clean this
-
 		ModelNode(): SceneNode(SNT_MODEL) {}
 
 		/// @name Accessors
@@ -31,15 +23,15 @@ class ModelNode: public SceneNode
 		const Model& getModel() const {return *model;}
 		/// @}
 
-		/// @return True if the model support skeleton animation
-		bool hasSkeleton() const {return boneRotations.size() > 0;}
-
 		/// Initialize the node
 		/// - Load the resource
-		/// - Create the bone transformations
-		/// - Create the patches
 		void init(const char* filename);
 
+		/// @name Accessors
+		/// @{
+		const boost::ptr_vector<ModelNodePatch>& getModelNodePatches() const {return patches;}
+		/// @}
+
 	private:
 		RsrcPtr<Model> model;
 		boost::ptr_vector<ModelNodePatch> patches;

src/Scene/ModelNodePatch.cpp

@@ -1,97 +1,25 @@
+#include <boost/array.hpp>
 #include "ModelNodePatch.h"
 #include "Material.h"
 #include "MeshData.h"
 #include "ModelPatch.h"
 
 
-#define BUFFER_OFFSET(i) ((char *)NULL + (i))
-
-
 //======================================================================================================================
 // Constructor                                                                                                         =
 //======================================================================================================================
-ModelNodePatch::ModelNodePatch(const ModelPatch& modelPatch_, bool isSkinPatch):
+ModelNodePatch::ModelNodePatch(const ModelPatch& modelPatch_):
 	modelPatchRsrc(modelPatch_)
 {
-	RASSERT_THROW_EXCEPTION(isSkinPatch && !modelPatchRsrc.supportsHwSkinning());
+	boost::array<const Vbo*, Mesh::VBOS_NUM> vboArr;
 
-	if(!isSkinPatch)
-	{
-		for(uint i = 0; i < Mesh::VBOS_NUM; i++)
-		{
-			vbos[i] = &modelPatchRsrc.getMesh().getVbo((Mesh::Vbos)i);
-		}
-	}
-	else
+	for(uint i = 0; i < Mesh::VBOS_NUM; i++)
 	{
-		//
-		// Create the TF VBOs
-		//
-		tfVbos[TF_VBO_POSITIONS].create(GL_ARRAY_BUFFER,
-		                                modelPatchRsrc.getMesh().getVbo(Mesh::VBO_VERT_POSITIONS).getSizeInBytes(),
-		                                NULL,
-		                                GL_STATIC_DRAW);
-
-		if(modelPatchRsrc.supportsNormals())
-		{
-			tfVbos[TF_VBO_NORMALS].create(GL_ARRAY_BUFFER,
-			                              modelPatchRsrc.getMesh().getVbo(Mesh::VBO_VERT_NORMALS).getSizeInBytes(),
-			                              NULL,
-			                              GL_STATIC_DRAW);
-		}
-
-		if(modelPatchRsrc.supportsTangents())
-		{
-			tfVbos[TF_VBO_TANGENTS].create(GL_ARRAY_BUFFER,
-			                               modelPatchRsrc.getMesh().getVbo(Mesh::VBO_VERT_TANGENTS).getSizeInBytes(),
-			                               NULL,
-			                               GL_STATIC_DRAW);
-		}
-
-		//
-		// Set the new VBOs array
-		//
-		for(uint i = 0; i < Mesh::VBOS_NUM; i++)
-		{
-			vbos[i] = &modelPatchRsrc.getMesh().getVbo((Mesh::Vbos)i);
-		}
-
-		vbos[Mesh::VBO_VERT_POSITIONS] = &tfVbos[TF_VBO_POSITIONS];
-
-		if(modelPatchRsrc.supportsNormals())
-		{
-			vbos[Mesh::VBO_VERT_NORMALS] = &tfVbos[TF_VBO_NORMALS];
-		}
-
-		if(modelPatchRsrc.supportsTangents())
-		{
-			vbos[Mesh::VBO_VERT_TANGENTS] = &tfVbos[TF_VBO_TANGENTS];
-		}
-
-		//
-		// Create the TF VAO
-		//
-		tfVao.create();
-		const Vbo* tmpVbo = &modelPatchRsrc.getMesh().getVbo(Mesh::VBO_VERT_POSITIONS);
-		tfVao.attachArrayBufferVbo(*tmpVbo, 0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
-
-		if(modelPatchRsrc.supportsNormals())
-		{
-			tmpVbo = &modelPatchRsrc.getMesh().getVbo(Mesh::VBO_VERT_NORMALS);
-			tfVao.attachArrayBufferVbo(*tmpVbo, 1, 3, GL_FLOAT, GL_FALSE, 0, NULL);
-		}
-
-		if(modelPatchRsrc.supportsTangents())
-		{
-			tmpVbo = &modelPatchRsrc.getMesh().getVbo(Mesh::VBO_VERT_TANGENTS);
-			tfVao.attachArrayBufferVbo(*tmpVbo, 2, 4, GL_FLOAT, GL_FALSE, 0, NULL);
-		}
-
-		tfVao.attachElementArrayBufferVbo(modelPatchRsrc.getMesh().getVbo(Mesh::VBO_VERT_INDECES));
+		vboArr[i] = &modelPatchRsrc.getMesh().getVbo((Mesh::Vbos)i);
 	}
 
-	createVao(modelPatchRsrc.getCpMtl(), vbos, cpVao);
-	createVao(modelPatchRsrc.getDpMtl(), vbos, dpVao);
+	createVao(modelPatchRsrc.getCpMtl(), vboArr, cpVao);
+	createVao(modelPatchRsrc.getDpMtl(), vboArr, dpVao);
 }
 
 
@@ -126,26 +54,5 @@ void ModelNodePatch::createVao(const Material& mtl, const boost::array<const Vbo
 		                         2, GL_FLOAT, GL_FALSE, 0, NULL);
 	}
 
-	/*if(mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_BONES_NUM) != NULL)
-	{
-		vao.attachArrayBufferVbo(*vbos[Mesh::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[Mesh::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[Mesh::VBO_VERT_WEIGHTS],
-		                         *mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_WEIGHTS), 4,
-		                         GL_FLOAT, GL_FALSE, sizeof(MeshData::VertexWeight), BUFFER_OFFSET(20));
-	}*/
-
 	vao.attachElementArrayBufferVbo(*vbos[Mesh::VBO_VERT_INDECES]);
 }

src/Scene/ModelNodePatch.h

@@ -1,12 +1,12 @@
 #ifndef MODEL_NODE_PATCH_H
 #define MODEL_NODE_PATCH_H
 
-#include <boost/array.hpp>
 #include "Vao.h"
 #include "Vbo.h"
 #include "Mesh.h" // For the Vbos enum
 #include "RsrcPtr.h"
 #include "ModelPatch.h"
+#include "Properties.h"
 
 
 class Material;
@@ -15,32 +15,24 @@ class Material;
 /// A fragment of the ModelNode
 class ModelNodePatch
 {
-	public:
-		ModelNodePatch(const ModelPatch& modelPatch, bool isSkinPatch);
+	/// VAO for MS and BS. All VBOs could be attached except for the vert weights
+	PROPERTY_R(Vao, cpVao, getCpVao)
+
+	/// VAO for depth passes. All VBOs could be attached except for the vert weights
+	PROPERTY_R(Vao, dpVao, getDpVao)
 
-		/// Transform feedback VBOs
-		enum TfVbos
-		{
-			TF_VBO_POSITIONS,
-			TF_VBO_NORMALS,
-			TF_VBO_TANGENTS,
-			TF_VBOS_NUM
-		};
+	public:
+		ModelNodePatch(const ModelPatch& modelPatch);
 
+		/// @name Accessors
+		/// @{
 		const Material& getCpMtl() const {return modelPatchRsrc.getCpMtl();}
 		const Material& getDpMtl() const {return modelPatchRsrc.getDpMtl();}
-		const Vbo& getTfVbo(TfVbos i) const {return tfVbos[i];}
-		const Vao& getTfVao() const {return tfVao;}
+		const ModelPatch& getModelPatchRsrc() const {return modelPatchRsrc;}
+		/// @}
 
-	private:
+	protected:
 		const ModelPatch& modelPatchRsrc;
-		boost::array<Vbo, TF_VBOS_NUM> tfVbos;
-		boost::array<const Vbo*, Mesh::VBOS_NUM> vbos;
-		Vao cpVao; ///< VAO for MS and BS. All VBOs could be attached except for the vert weights
-		Vao dpVao; ///< VAO for depth passes. All VBOs could be attached except for the vert weights
-		/// VAO for transform feedback pass. We attach only the original mesh's positions, normals (optional) and tangents
-		/// (optional) VBOs
-		Vao tfVao;
 
 		static void createVao(const Material& material, const boost::array<const Vbo*, Mesh::VBOS_NUM>& vbos, Vao& vao);
 };