Trying to make it compile

src/GfxApi/BufferObjects/Vao.cpp

@@ -1,7 +1,7 @@
 #include "Vao.h"
 #include "Vbo.h"
 #include "Util/Exception.h"
-#include "Resources/AttributeShaderProgramVariable.h"
+#include "Resources/ShaderProgramAttributeVariable.h"
 
 
 //==============================================================================
@@ -47,7 +47,7 @@ void Vao::attachArrayBufferVbo(const Vbo& vbo, uint attribVarLocation,
 // attachArrayBufferVbo                                                        =
 //==============================================================================
 void Vao::attachArrayBufferVbo(const Vbo& vbo,
-	const AttributeShaderProgramVariable& attribVar,
+	const ShaderProgramAttributeVariable& attribVar,
 	GLint size, GLenum type, GLboolean normalized, GLsizei stride,
 	const GLvoid* pointer)
 {

src/GfxApi/BufferObjects/Vao.h

@@ -8,7 +8,7 @@
 
 
 class Vbo;
-class AttributeShaderProgramVariable;
+class ShaderProgramAttributeVariable;
 
 
 /// Vertex array object
@@ -46,7 +46,7 @@ class Vao
 		/// first generic vertex attribute in the array
 		void attachArrayBufferVbo(
 			const Vbo& vbo,
-			const AttributeShaderProgramVariable& attribVar,
+			const ShaderProgramAttributeVariable& attribVar,
 			GLint size,
 			GLenum type,
 			GLboolean normalized,

src/Renderer/Bl.cpp

@@ -104,8 +104,8 @@ void Bl::runSideBlur()
 	glBlendFunc(GL_ONE, GL_ONE);
 
 	sideBlurSProg->bind();
-	sideBlurSProg->getUniformVariable("tex").set(*sideBlurMap, 0);
-	sideBlurSProg->getUniformVariable("factor").set(&sideBlurFactor);
+	sideBlurSProg->getUniformVariableByName("tex").set(*sideBlurMap, 0);
+	sideBlurSProg->getUniformVariableByName("factor").set(&sideBlurFactor);
 
 	r.drawQuad();
 }
@@ -124,12 +124,12 @@ void Bl::runBlur()
 		hBlurFbo.bind();
 
 		hBlurSProg->bind();
-		hBlurSProg->getUniformVariable("img").set(
+		hBlurSProg->getUniformVariableByName("img").set(
 			r.getPps().getPostPassFai(), 0);
-		hBlurSProg->getUniformVariable("msNormalFai").set(
+		hBlurSProg->getUniformVariableByName("msNormalFai").set(
 			r.getMs().getNormalFai(), 1);
 		float tmp = r.getWidth();
-		hBlurSProg->getUniformVariable("imgDimension").set(&tmp);
+		hBlurSProg->getUniformVariableByName("imgDimension").set(&tmp);
 
 		r.drawQuad();
 
@@ -137,11 +137,11 @@ void Bl::runBlur()
 		vBlurFbo.bind();
 
 		vBlurSProg->bind();
-		vBlurSProg->getUniformVariable("img").set(blurFai, 0);
-		vBlurSProg->getUniformVariable("msNormalFai").set(
+		vBlurSProg->getUniformVariableByName("img").set(blurFai, 0);
+		vBlurSProg->getUniformVariableByName("msNormalFai").set(
 			r.getMs().getNormalFai(), 1);
 		tmp = r.getHeight();
-		vBlurSProg->getUniformVariable("imgDimension").set(&tmp);
+		vBlurSProg->getUniformVariableByName("imgDimension").set(&tmp);
 
 		r.drawQuad();
 	}

src/Renderer/Dbg.cpp

@@ -403,7 +403,7 @@ void Dbg::end()
 	colorsVbo.write(&colors[0], 0, sizeof(Vec3) * pointIndex);
 
 	Mat4 pmv = r.getViewProjectionMat() * modelMat;
-	sProg->getUniformVariable("modelViewProjectionMat").set(&pmv);
+	sProg->getUniformVariableByName("modelViewProjectionMat").set(&pmv);
 
 	vao.bind();
 	glDrawArrays(GL_LINES, 0, pointIndex);

src/Renderer/Deformer.cpp

@@ -56,8 +56,8 @@ void Deformer::deform(SkinPatchNode& node) const
 	const ShaderProgram* sProg;
 	const Material& mtl = node.getModelPatchRsrc().getMaterial();
 
-	if(mtl.buildinVariableExits(MaterialBuildinVariable::NORMAL) &&
-	   mtl.buildinVariableExits(MaterialBuildinVariable::TANGENT))
+	if(mtl.buildinVariableExits(MaterialBuildinVariable::MV_NORMAL) &&
+	   mtl.buildinVariableExits(MaterialBuildinVariable::MV_TANGENT))
 	{
 		sProg = tfHwSkinningAllSProg.get();
 	}
@@ -69,10 +69,10 @@ void Deformer::deform(SkinPatchNode& node) const
 	sProg->bind();
 
 	// Uniforms
-	sProg->getUniformVariable("skinningRotations").set(
+	sProg->getUniformVariableByName("skinningRotations").set(
 		&skinNode->getBoneRotations()[0], skinNode->getBoneRotations().size());
 
-	sProg->getUniformVariable("skinningTranslations").set(
+	sProg->getUniformVariableByName("skinningTranslations").set(
 		&skinNode->getBoneTranslations()[0],
 		skinNode->getBoneTranslations().size());
 

src/Renderer/Drawers/SceneDrawer.cpp

@@ -7,6 +7,7 @@
 #include "Core/App.h"
 #include "Scene/Scene.h"
 #include "Scene/MaterialRuntime.h"
+#include "Scene/MaterialRuntimeVariable.h"
 #include "GfxApi/GlStateMachine.h"
 
 
@@ -17,10 +18,11 @@ namespace R {
 // Constructor                                                                 =
 //==============================================================================
 SceneDrawer::UsrDefVarVisitor::UsrDefVarVisitor(
-	const MaterialRuntimeUserDefinedVar& udvr_,
-	const Renderer& r_, uint& texUnit_)
+	const MaterialRuntimeVariable& udvr_,
+	const Renderer& r_, PassType pt_, uint& texUnit_)
 :	udvr(udvr_),
 	r(r_),
+	pt(pt_),
 	texUnit(texUnit_)
 {}
 
@@ -32,16 +34,16 @@ SceneDrawer::UsrDefVarVisitor::UsrDefVarVisitor(
 template<typename Type>
 void SceneDrawer::UsrDefVarVisitor::operator()(const Type& x) const
 {
-	udvr.getUniVar().set(&x);
+	udvr.getMaterialUserVariable().getShaderProgramUniformVariable(pt).set(&x);
 }
 
 
-template<>
 void SceneDrawer::UsrDefVarVisitor::operator()(const RsrcPtr<Texture>* x) const
 {
 	const RsrcPtr<Texture>& texPtr = *x;
 	texPtr->setRepeat(true);
-	udvr.getUniVar().set(*texPtr, texUnit);
+	udvr.getMaterialUserVariable().getShaderProgramUniformVariable(pt).
+		set(*texPtr, texUnit);
 	++texUnit;
 }
 
@@ -49,16 +51,19 @@ void SceneDrawer::UsrDefVarVisitor::operator()(const RsrcPtr<Texture>* x) const
 //==============================================================================
 // setupShaderProg                                                             =
 //==============================================================================
-void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr,
-	PassType passType,
-	const Transform& nodeWorldTransform, const Camera& cam,
-	const Renderer& r, float blurring)
+void SceneDrawer::setupShaderProg(
+	const MaterialRuntime& mtlr,
+	PassType pt,
+	const Transform& nodeWorldTransform,
+	const Camera& cam,
+	const Renderer& r,
+	float blurring)
 {
 	typedef MaterialBuildinVariable Mvb; // Short name
 	uint textureUnit = 0;
 	GlStateMachine& gl = GlStateMachineSingleton::getInstance();
 	const Material& mtl = mtlr.getMaterial();
-	const ShaderProgram& sprog = mtl.getShaderProgram(passType);
+	const ShaderProgram& sprog = mtl.getShaderProgram(pt);
 
 	sprog.bind();
 
@@ -84,7 +89,7 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr,
 
 
 	//
-	// calc needed matrices
+	// Calc needed matrices
 	//
 	Mat4 modelMat(nodeWorldTransform);
 	const Mat4& projectionMat = cam.getProjectionMatrix();
@@ -94,9 +99,9 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr,
 	Mat4 modelViewProjectionMat;
 
 	// should I calculate the modelViewMat ?
-	if(mtl.buildinVariableExits(Mvb::MV_MODELVIEW_MAT, passType) ||
-		mtl.buildinVariableExits(Mvb::MV_MODELVIEWPROJECTION_MAT, passType) ||
-		mtl.buildinVariableExits(Mvb::MV_NORMAL_MAT, passType))
+	if(mtl.buildinVariableExits(Mvb::MV_MODELVIEW_MAT, pt) ||
+		mtl.buildinVariableExits(Mvb::MV_MODELVIEWPROJECTION_MAT, pt) ||
+		mtl.buildinVariableExits(Mvb::MV_NORMAL_MAT, pt))
 	{
 		// Optimization
 		modelViewMat = (modelMat == Mat4::getIdentity()) ? viewMat :
@@ -104,91 +109,102 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr,
 	}
 
 	// set matrices
-	if(mtl.buildinVariableExits(Mvb::MV_MODEL_MAT, passType))
+	if(mtl.buildinVariableExits(Mvb::MV_MODEL_MAT, pt))
 	{
 		mtl.getBuildinVariable(Mvb::MV_MODEL_MAT).
-			getShaderProgramUniformVariable(passType).set(&modelMat);
+			getShaderProgramUniformVariable(pt).set(&modelMat);
 	}
 
-	/// XXX
-
-	if(mtlr.getStdUniVar(Mvb::MV_VIEW_MAT))
+	if(mtl.buildinVariableExits(Mvb::MV_VIEW_MAT, pt))
 	{
-		mtlr.getStdUniVar(Mvb::MV_VIEW_MAT)->set(&viewMat);
+		mtl.getBuildinVariable(Mvb::MV_VIEW_MAT).
+			getShaderProgramUniformVariable(pt).set(&viewMat);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_PROJECTION_MAT))
+	if(mtl.buildinVariableExits(Mvb::MV_PROJECTION_MAT, pt))
 	{
-		mtlr.getStdUniVar(Mvb::MV_PROJECTION_MAT)->set(&projectionMat);
+		mtl.getBuildinVariable(Mvb::MV_PROJECTION_MAT).
+			getShaderProgramUniformVariable(pt).set(&projectionMat);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_MODELVIEW_MAT))
+	if(mtl.buildinVariableExits(Mvb::MV_MODELVIEW_MAT, pt))
 	{
-		mtlr.getStdUniVar(Mvb::MV_MODELVIEW_MAT)->set(&modelViewMat);
+		mtl.getBuildinVariable(Mvb::MV_MODELVIEW_MAT).
+			getShaderProgramUniformVariable(pt).set(&modelViewMat);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_VIEWPROJECTION_MAT))
+	if(mtl.buildinVariableExits(Mvb::MV_VIEWPROJECTION_MAT, pt))
 	{
-		mtlr.getStdUniVar(Mvb::MV_VIEWPROJECTION_MAT)->set(
-			&r.getViewProjectionMat());
+		mtl.getBuildinVariable(Mvb::MV_VIEWPROJECTION_MAT).
+			getShaderProgramUniformVariable(pt).set(&r.getViewProjectionMat());
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_NORMAL_MAT))
+	if(mtl.buildinVariableExits(Mvb::MV_NORMAL_MAT, pt))
 	{
 		normalMat = modelViewMat.getRotationPart();
-		mtlr.getStdUniVar(Mvb::MV_NORMAL_MAT)->set(&normalMat);
+
+		mtl.getBuildinVariable(Mvb::MV_NORMAL_MAT).
+			getShaderProgramUniformVariable(pt).set(&normalMat);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_MODELVIEWPROJECTION_MAT))
+	if(mtl.buildinVariableExits(Mvb::MV_MODELVIEWPROJECTION_MAT, pt))
 	{
 		modelViewProjectionMat = projectionMat * modelViewMat;
-		mtlr.getStdUniVar(Mvb::MV_MODELVIEWPROJECTION_MAT)->set(
-			&modelViewProjectionMat);
+
+		mtl.getBuildinVariable(Mvb::MV_MODELVIEWPROJECTION_MAT).
+			getShaderProgramUniformVariable(pt).set(&modelViewProjectionMat);
 	}
 
 
 	//
 	// FAis
 	//
-	if(mtlr.getStdUniVar(Mvb::MV_MS_NORMAL_FAI))
+	if(mtl.buildinVariableExits(Mvb::MV_MS_NORMAL_FAI, pt))
 	{
-		mtlr.getStdUniVar(Mvb::MV_MS_NORMAL_FAI)->set(
+		mtl.getBuildinVariable(Mvb::MV_MS_NORMAL_FAI).
+			getShaderProgramUniformVariable(pt).set(
 			r.getMs().getNormalFai(), textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_MS_DIFFUSE_FAI))
+	if(mtl.buildinVariableExits(Mvb::MV_MS_DIFFUSE_FAI, pt))
 	{
-		mtlr.getStdUniVar(Mvb::MV_MS_DIFFUSE_FAI)->set(
+		mtl.getBuildinVariable(Mvb::MV_MS_DIFFUSE_FAI).
+			getShaderProgramUniformVariable(pt).set(
 			r.getMs().getDiffuseFai(), textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_MS_SPECULAR_FAI))
+	if(mtl.buildinVariableExits(Mvb::MV_MS_SPECULAR_FAI, pt))
 	{
-		mtlr.getStdUniVar(Mvb::MV_MS_SPECULAR_FAI)->set(
+		mtl.getBuildinVariable(Mvb::MV_MS_SPECULAR_FAI).
+			getShaderProgramUniformVariable(pt).set(
 			r.getMs().getSpecularFai(), textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_MS_DEPTH_FAI))
+	if(mtl.buildinVariableExits(Mvb::MV_MS_DEPTH_FAI, pt))
 	{
-		mtlr.getStdUniVar(Mvb::MV_MS_DEPTH_FAI)->set(
+		mtl.getBuildinVariable(Mvb::MV_MS_DEPTH_FAI).
+			getShaderProgramUniformVariable(pt).set(
 			r.getMs().getDepthFai(), textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_IS_FAI))
+	if(mtl.buildinVariableExits(Mvb::MV_IS_FAI, pt))
 	{
-		mtlr.getStdUniVar(Mvb::MV_IS_FAI)->set(r.getIs().getFai(),
-			textureUnit++);
+		mtl.getBuildinVariable(Mvb::MV_IS_FAI).
+			getShaderProgramUniformVariable(pt).set(
+			r.getIs().getFai(), textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_PPS_PRE_PASS_FAI))
+	if(mtl.buildinVariableExits(Mvb::MV_PPS_PRE_PASS_FAI, pt))
 	{
-		mtlr.getStdUniVar(Mvb::MV_PPS_PRE_PASS_FAI)->set(
+		mtl.getBuildinVariable(Mvb::MV_PPS_PRE_PASS_FAI).
+			getShaderProgramUniformVariable(pt).set(
 			r.getPps().getPrePassFai(), textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_PPS_POST_PASS_FAI))
+	if(mtl.buildinVariableExits(Mvb::MV_PPS_POST_PASS_FAI, pt))
 	{
-		mtlr.getStdUniVar(Mvb::MV_PPS_POST_PASS_FAI)->set(
+		mtl.getBuildinVariable(Mvb::MV_PPS_POST_PASS_FAI).
+			getShaderProgramUniformVariable(pt).set(
 			r.getPps().getPostPassFai(), textureUnit++);
 	}
 
@@ -196,34 +212,36 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr,
 	//
 	// Other
 	//
-	if(mtlr.getStdUniVar(Mvb::MV_RENDERER_SIZE))
+	if(mtl.buildinVariableExits(Mvb::MV_RENDERER_SIZE, pt))
 	{
 		Vec2 v(r.getWidth(), r.getHeight());
-		mtlr.getStdUniVar(Mvb::MV_RENDERER_SIZE)->set(&v);
+		mtl.getBuildinVariable(Mvb::MV_RENDERER_SIZE).
+			getShaderProgramUniformVariable(pt).set(&v);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_SCENE_AMBIENT_COLOR))
+	if(mtl.buildinVariableExits(Mvb::MV_SCENE_AMBIENT_COLOR, pt))
 	{
 		Vec3 col(SceneSingleton::getInstance().getAmbientCol());
-		mtlr.getStdUniVar(Mvb::MV_SCENE_AMBIENT_COLOR)->set(&col);
+		mtl.getBuildinVariable(Mvb::MV_SCENE_AMBIENT_COLOR).
+			getShaderProgramUniformVariable(pt).set(&col);
 	}
 
-	if(mtlr.getStdUniVar(Mvb::MV_BLURRING))
+	if(mtl.buildinVariableExits(Mvb::MV_BLURRING, pt))
 	{
 		/*blurring *= 10.0;
 		INFO(blurring);*/
 		float b = blurring;
-		mtlr.getStdUniVar(Mvb::MV_BLURRING)->set(&b);
+		mtl.getBuildinVariable(Mvb::MV_BLURRING).
+			getShaderProgramUniformVariable(pt).set(&b);
 	}
 
 
 	//
 	// set user defined vars
 	//
-	BOOST_FOREACH(const MaterialRuntimeUserDefinedVar& udvr,
-		mtlr.getUserDefinedVars())
+	BOOST_FOREACH(const MaterialRuntimeVariable& udvr, mtlr.getVariables())
 	{
-		boost::apply_visitor(UsrDefVarVisitor(udvr, r, textureUnit),
+		boost::apply_visitor(UsrDefVarVisitor(udvr, r, pt, textureUnit),
 			udvr.getDataVariant());
 	}
 
@@ -234,36 +252,29 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr,
 //==============================================================================
 // renderRenderableNode                                                        =
 //==============================================================================
-void SceneDrawer::renderRenderableNode(const RenderableNode& renderable,
-	const Camera& cam, RenderingPassType rtype) const
+void SceneDrawer::renderRenderableNode(const RenderableNode& node,
+	const Camera& cam, PassType pt) const
 {
-	const MaterialRuntime* mtlr;
-	const Vao* vao;
 	float blurring = 0.0;
+	const MaterialRuntime& mtlr = node.getMaterialRuntime();
+	const Material& mtl = mtlr.getMaterial();
 
-	switch(rtype)
+	// Calc the blur if needed
+	if(mtl.buildinVariableExits(MaterialBuildinVariable::MV_BLURRING, pt))
 	{
-		case RPT_COLOR:
-			mtlr = &renderable.getCpMtlRun();
-			vao = &renderable.getCpVao();
-
-			blurring = (renderable.getWorldTransform().getOrigin() -
-				renderable.getPrevWorldTransform().getOrigin()).getLength();
+		float prev = (node.getPrevWorldTransform().getOrigin() -
+			cam.getPrevWorldTransform().getOrigin()).getLength();
 
-			break;
+		float crnt = (node.getWorldTransform().getOrigin() -
+			cam.getWorldTransform().getOrigin()).getLength();
 
-		case RPT_DEPTH:
-			mtlr = &renderable.getDpMtlRun();
-			vao = &renderable.getDpVao();
-			break;
+		blurring = abs(crnt - prev);
 	}
 
-	setupShaderProg(*mtlr, renderable.getWorldTransform(), cam, r, blurring);
-
-	vao->bind();
-	glDrawElements(GL_TRIANGLES, renderable.getVertIdsNum(),
-		GL_UNSIGNED_SHORT, 0);
-	vao->unbind();
+	setupShaderProg(mtlr, pt, node.getWorldTransform(), cam, r, blurring);
+	node.getVao(pt).bind();
+	glDrawElements(GL_TRIANGLES, node.getVertIdsNum(), GL_UNSIGNED_SHORT, 0);
+	node.getVao(pt).unbind();
 }
 
 

src/Renderer/Drawers/SceneDrawer.h

@@ -3,6 +3,7 @@
 
 #include "Math/Math.h"
 #include "Resources/MaterialCommon.h"
+#include "Resources/RsrcPtr.h"
 #include <boost/variant.hpp>
 
 
@@ -36,14 +37,18 @@ class SceneDrawer
 			public:
 				const MaterialRuntimeVariable& udvr;
 				const Renderer& r;
+				PassType pt;
 				uint& texUnit;
 
 				UsrDefVarVisitor(const MaterialRuntimeVariable& udvr,
-					const Renderer& r, uint& texUnit);
+					const Renderer& r, PassType pt, uint& texUnit);
 
-				/// Functor. Its specialized for the texture case
+				/// Functor
 				template<typename Type>
 				void operator()(const Type& x) const;
+
+				/// Functor
+				void operator()(const RsrcPtr<Texture>* x) const;
 		};
 
 		const Renderer& r; ///< Keep it here cause the class wants a few stuff
@@ -58,9 +63,13 @@ class SceneDrawer
 		/// shader
 		/// @param cam Needed for some matrices (view & projection)
 		/// @param r The renderer, needed for some FAIs and some matrices
-		static void setupShaderProg(const MaterialRuntime& mtlr,
+		static void setupShaderProg(
+			const MaterialRuntime& mtlr,
+			PassType pt,
 			const Transform& nodeWorldTransform,
-			const Camera& cam, const Renderer& r, float blurring = 0.0);
+			const Camera& cam,
+			const Renderer& r,
+			float blurring);
 };
 
 

src/Renderer/Ez.cpp

@@ -69,8 +69,7 @@ void Ez::run()
 
 	BOOST_FOREACH(const RenderableNode* node, cam.getVisibleMsRenderableNodes())
 	{
-		r.getSceneDrawer().renderRenderableNode(*node, cam,
-			SceneDrawer::RPT_DEPTH);
+		r.getSceneDrawer().renderRenderableNode(*node, cam, DEPTH_PASS);
 	}
 
 	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

src/Renderer/Hdr.cpp

@@ -119,8 +119,8 @@ void Hdr::run()
 	// pass 0
 	toneFbo.bind();
 	toneSProg->bind();
-	toneSProg->getUniformVariable("exposure").set(&exposure);
-	toneSProg->getUniformVariable("fai").set(r.getPps().getPrePassFai(), 0);
+	toneSProg->getUniformVariableByName("exposure").set(&exposure);
+	toneSProg->getUniformVariableByName("fai").set(r.getPps().getPrePassFai(), 0);
 	r.drawQuad();
 
 	// blurring passes
@@ -133,26 +133,26 @@ void Hdr::run()
 		hblurSProg->bind();
 		if(i == 0)
 		{
-			hblurSProg->getUniformVariable("img").set(toneFai, 0);
+			hblurSProg->getUniformVariableByName("img").set(toneFai, 0);
 		}
 		else
 		{
-			hblurSProg->getUniformVariable("img").set(fai, 0);
+			hblurSProg->getUniformVariableByName("img").set(fai, 0);
 		}
 		float tmp = float(w);
-		hblurSProg->getUniformVariable("imgDimension").set(&tmp);
+		hblurSProg->getUniformVariableByName("imgDimension").set(&tmp);
 		tmp = blurringDist / w;
-		hblurSProg->getUniformVariable("blurringDist").set(&tmp);
+		hblurSProg->getUniformVariableByName("blurringDist").set(&tmp);
 		r.drawQuad();
 
 		// vpass
 		vblurFbo.bind();
 		vblurSProg->bind();
-		vblurSProg->getUniformVariable("img").set(hblurFai, 0);
+		vblurSProg->getUniformVariableByName("img").set(hblurFai, 0);
 		tmp = float(h);
-		vblurSProg->getUniformVariable("imgDimension").set(&tmp);
+		vblurSProg->getUniformVariableByName("imgDimension").set(&tmp);
 		tmp = blurringDist / h;
-		vblurSProg->getUniformVariable("blurringDist").set(&tmp);
+		vblurSProg->getUniformVariableByName("blurringDist").set(&tmp);
 		r.drawQuad();
 	}
 

src/Renderer/Is.cpp

@@ -148,8 +148,8 @@ void Is::ambientPass(const Vec3& color)
 	ambientPassSProg->bind();
 
 	// set the uniforms
-	ambientPassSProg->getUniformVariable("ambientCol").set(&color);
-	ambientPassSProg->getUniformVariable("sceneColMap").set(
+	ambientPassSProg->getUniformVariableByName("ambientCol").set(&color);
+	ambientPassSProg->getUniformVariableByName("sceneColMap").set(
 		r.getMs().getDiffuseFai(), 0);
 
 	// Draw quad
@@ -172,26 +172,26 @@ void Is::pointLightPass(const PointLight& light)
 	const ShaderProgram& shader = *pointLightSProg; // ensure the const-ness
 	shader.bind();
 
-	shader.getUniformVariable("msNormalFai").set(
+	shader.getUniformVariableByName("msNormalFai").set(
 		r.getMs().getNormalFai(), 0);
-	shader.getUniformVariable("msDiffuseFai").set(
+	shader.getUniformVariableByName("msDiffuseFai").set(
 		r.getMs().getDiffuseFai(), 1);
-	shader.getUniformVariable("msSpecularFai").set(
+	shader.getUniformVariableByName("msSpecularFai").set(
 		r.getMs().getSpecularFai(), 2);
-	shader.getUniformVariable("msDepthFai").set(r.getMs().getDepthFai(), 3);
-	shader.getUniformVariable("planes").set(&r.getPlanes());
-	shader.getUniformVariable("limitsOfNearPlane").set(
+	shader.getUniformVariableByName("msDepthFai").set(r.getMs().getDepthFai(), 3);
+	shader.getUniformVariableByName("planes").set(&r.getPlanes());
+	shader.getUniformVariableByName("limitsOfNearPlane").set(
 		&r.getLimitsOfNearPlane());
-	shader.getUniformVariable("limitsOfNearPlane2").set(
+	shader.getUniformVariableByName("limitsOfNearPlane2").set(
 		&r.getLimitsOfNearPlane2());
 	float zNear = cam.getZNear();
-	shader.getUniformVariable("zNear").set(&zNear);
+	shader.getUniformVariableByName("zNear").set(&zNear);
 	const Vec3& origin = light.getWorldTransform().getOrigin();
 	Vec3 lightPosEyeSpace = origin.getTransformed(cam.getViewMatrix());
-	shader.getUniformVariable("lightPos").set(&lightPosEyeSpace);
-	shader.getUniformVariable("lightRadius").set(&light.getRadius());
-	shader.getUniformVariable("lightDiffuseCol").set(&light.getDiffuseCol());
-	shader.getUniformVariable("lightSpecularCol").set(&light.getSpecularCol());
+	shader.getUniformVariableByName("lightPos").set(&lightPosEyeSpace);
+	shader.getUniformVariableByName("lightRadius").set(&light.getRadius());
+	shader.getUniformVariableByName("lightDiffuseCol").set(&light.getDiffuseCol());
+	shader.getUniformVariableByName("lightSpecularCol").set(&light.getSpecularCol());
 
 	// render quad
 	r.drawQuad();
@@ -251,32 +251,32 @@ void Is::spotLightPass(const SpotLight& light)
 	shdr->bind();
 
 	// bind the FAIs
-	shdr->getUniformVariable("msNormalFai").set(
+	shdr->getUniformVariableByName("msNormalFai").set(
 		r.getMs().getNormalFai(), 0);
-	shdr->getUniformVariable("msDiffuseFai").set(
+	shdr->getUniformVariableByName("msDiffuseFai").set(
 		r.getMs().getDiffuseFai(), 1);
-	shdr->getUniformVariable("msSpecularFai").set(
+	shdr->getUniformVariableByName("msSpecularFai").set(
 		r.getMs().getSpecularFai(), 2);
-	shdr->getUniformVariable("msDepthFai").set(r.getMs().getDepthFai(), 3);
+	shdr->getUniformVariableByName("msDepthFai").set(r.getMs().getDepthFai(), 3);
 
 	// the ???
-	shdr->getUniformVariable("planes").set(&r.getPlanes());
-	shdr->getUniformVariable("limitsOfNearPlane").set(
+	shdr->getUniformVariableByName("planes").set(&r.getPlanes());
+	shdr->getUniformVariableByName("limitsOfNearPlane").set(
 		&r.getLimitsOfNearPlane());
-	shdr->getUniformVariable("limitsOfNearPlane2").set(
+	shdr->getUniformVariableByName("limitsOfNearPlane2").set(
 		&r.getLimitsOfNearPlane2());
 	float zNear = cam.getZNear();
-	shdr->getUniformVariable("zNear").set(&zNear);
+	shdr->getUniformVariableByName("zNear").set(&zNear);
 
 	// the light params
 	const Vec3& origin = light.getWorldTransform().getOrigin();
 	Vec3 lightPosEyeSpace = origin.getTransformed(cam.getViewMatrix());
-	shdr->getUniformVariable("lightPos").set(&lightPosEyeSpace);
+	shdr->getUniformVariableByName("lightPos").set(&lightPosEyeSpace);
 	float tmp = light.getDistance();
-	shdr->getUniformVariable("lightRadius").set(&tmp);
-	shdr->getUniformVariable("lightDiffuseCol").set(&light.getDiffuseCol());
-	shdr->getUniformVariable("lightSpecularCol").set(&light.getSpecularCol());
-	shdr->getUniformVariable("lightTex").set(light.getTexture(), 4);
+	shdr->getUniformVariableByName("lightRadius").set(&tmp);
+	shdr->getUniformVariableByName("lightDiffuseCol").set(&light.getDiffuseCol());
+	shdr->getUniformVariableByName("lightSpecularCol").set(&light.getSpecularCol());
+	shdr->getUniformVariableByName("lightTex").set(light.getTexture(), 4);
 
 	// set texture matrix for texture & shadowmap projection
 	// Bias * P_light * V_light * inv(V_cam)
@@ -286,14 +286,14 @@ void Is::spotLightPass(const SpotLight& light)
 	texProjectionMat = biasMat4 * light.getCamera().getProjectionMatrix() *
 		Mat4::combineTransformations(light.getCamera().getViewMatrix(),
 		Mat4(cam.getWorldTransform()));
-	shdr->getUniformVariable("texProjectionMat").set(&texProjectionMat);
+	shdr->getUniformVariableByName("texProjectionMat").set(&texProjectionMat);
 
 	// the shadowmap
 	if(light.castsShadow() && sm.isEnabled())
 	{
-		shdr->getUniformVariable("shadowMap").set(sm.getShadowMap(), 5);
+		shdr->getUniformVariableByName("shadowMap").set(sm.getShadowMap(), 5);
 		float smSize = sm.getShadowMap().getWidth();
-		shdr->getUniformVariable("shadowMapSize").set(&smSize);
+		shdr->getUniformVariableByName("shadowMapSize").set(&smSize);
 	}
 
 	// render quad

src/Renderer/MainRenderer.cpp

@@ -139,9 +139,9 @@ void MainRenderer::render(Camera& cam_)
 	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
 	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 	sProg->bind();
-	//sProg->getUniformVariable("rasterImage")->set(ms.getNormalFai(), 0);
-	//sProg->getUniformVariable("rasterImage")->set(pps.getSsao().getFai(), 0);
-	sProg->getUniformVariable("rasterImage").set(pps.getPostPassFai(), 0);
+	//sProg->getUniformVariableByName("rasterImage")->set(ms.getNormalFai(), 0);
+	//sProg->getUniformVariableByName("rasterImage")->set(pps.getSsao().getFai(), 0);
+	sProg->getUniformVariableByName("rasterImage").set(pps.getPostPassFai(), 0);
 	drawQuad();
 }
 

src/Renderer/Ms.cpp

@@ -120,7 +120,7 @@ void Ms::run()
 		r.getCamera().getVisibleMsRenderableNodes())
 	{
 		r.getSceneDrawer().renderRenderableNode(*node, r.getCamera(),
-			SceneDrawer::RPT_COLOR);
+			COLOR_PASS);
 	}
 
 	// restore depth

src/Renderer/Pps.cpp

@@ -126,11 +126,11 @@ void Pps::runPrePass()
 		r.getWidth(), r.getHeight());
 
 	prePassSProg->bind();
-	prePassSProg->getUniformVariable("isFai").set(r.getIs().getFai(), 0);
+	prePassSProg->getUniformVariableByName("isFai").set(r.getIs().getFai(), 0);
 
 	if(ssao.isEnabled())
 	{
-		prePassSProg->getUniformVariable("ppsSsaoFai").set(ssao.getFai(), 1);
+		prePassSProg->getUniformVariableByName("ppsSsaoFai").set(ssao.getFai(), 1);
 	}
 
 	r.drawQuad();
@@ -158,10 +158,10 @@ void Pps::runPostPass()
 		r.getWidth(), r.getHeight());
 
 	postPassSProg->bind();
-	postPassSProg->getUniformVariable("ppsPrePassFai").set(prePassFai, 0);
+	postPassSProg->getUniformVariableByName("ppsPrePassFai").set(prePassFai, 0);
 	if(hdr.isEnabled())
 	{
-		postPassSProg->getUniformVariable("ppsHdrFai").set(hdr.getFai(), 1);
+		postPassSProg->getUniformVariableByName("ppsHdrFai").set(hdr.getFai(), 1);
 	}
 
 	r.drawQuad();

src/Renderer/Renderer.cpp

@@ -70,8 +70,6 @@ void Renderer::init(const RendererInitializer& initializer)
 	quadVao.attachElementArrayBufferVbo(quadVertIndecesVbo);
 
 	// Other
-	skinsDeformer.init();
-
 	msTq.reset(new TimeQuery);
 	isTq.reset(new TimeQuery);
 	ppsTq.reset(new TimeQuery);

src/Renderer/Renderer.h

@@ -15,7 +15,6 @@
 #include "Dbg.h"
 #include "GfxApi/GlException.h"
 #include "Drawers/SceneDrawer.h"
-#include "SkinsDeformer.h"
 #include "GfxApi/GlStateMachine.h"
 #include "GfxApi/TimeQuery.h"
 #include <boost/scoped_ptr.hpp>
@@ -58,7 +57,6 @@ class Renderer
 		GETTER_R(Mat4, viewProjectionMat, getViewProjectionMat)
 		const Camera& getCamera() const {return *cam;}
 		GETTER_RW(SceneDrawer, sceneDrawer, getSceneDrawer)
-		GETTER_RW(SkinsDeformer, skinsDeformer, getSkinsDeformer)
 		GETTER_R(Vec2, planes, getPlanes)
 		GETTER_R(Vec2, limitsOfNearPlane, getLimitsOfNearPlane)
 		GETTER_R(Vec2, limitsOfNearPlane2, getLimitsOfNearPlane2)
@@ -140,7 +138,6 @@ class Renderer
 		/// Max color attachments an FBO can accept
 		static int maxColorAtachments;
 		SceneDrawer sceneDrawer;
-		SkinsDeformer skinsDeformer;
 
 		/// @name Optimization vars
 		/// Used in other stages

src/Renderer/Sm.cpp

@@ -152,7 +152,7 @@ void Sm::run(const Light& light, float distance)
 			{
 				const SpotLight& sl = static_cast<const SpotLight&>(light);
 				r.getSceneDrawer().renderRenderableNode(*node, sl.getCamera(),
-					SceneDrawer::RPT_DEPTH);
+					DEPTH_PASS);
 				break;
 			}
 

src/Renderer/Smo.cpp

@@ -53,7 +53,7 @@ void Smo::init(const RendererInitializer& /*initializer*/)
 	sphereGeom.vao.create();
 	sphereGeom.vao.attachArrayBufferVbo(
 		sphereGeom.mesh->getVbo(Mesh::VBO_VERT_POSITIONS),
-		sProg->getAttributeVariable("position"), 3, GL_FLOAT,
+		sProg->getAttributeVariableByName("position"), 3, GL_FLOAT,
 		GL_FALSE, 0, NULL);
 	sphereGeom.vao.attachElementArrayBufferVbo(
 		sphereGeom.mesh->getVbo(Mesh::VBO_VERT_INDECES));
@@ -77,7 +77,7 @@ void Smo::initCamGeom()
 		camGeom[i].vao.create();
 		camGeom[i].vao.attachArrayBufferVbo(
 			camGeom[i].mesh->getVbo(Mesh::VBO_VERT_POSITIONS),
-			sProg->getAttributeVariable("position"), 3, GL_FLOAT,
+			sProg->getAttributeVariableByName("position"), 3, GL_FLOAT,
 			GL_FALSE, 0, NULL);
 		camGeom[i].vao.attachElementArrayBufferVbo(
 			camGeom[i].mesh->getVbo(Mesh::VBO_VERT_INDECES));
@@ -147,7 +147,7 @@ void Smo::run(const PointLight& light)
 	Mat4 modelMat = Mat4(light.getWorldTransform().getOrigin(),
 		Mat3::getIdentity(), light.getRadius() * SCALE);
 	Mat4 trf = r.getViewProjectionMat() * modelMat;
-	sProg->getUniformVariable("modelViewProjectionMat").set(&trf);
+	sProg->getUniformVariableByName("modelViewProjectionMat").set(&trf);
 
 	// render sphere to the stencil buffer
 	sphereGeom.vao.bind();
@@ -227,7 +227,7 @@ void Smo::run(const SpotLight& light)
 	Mat4 modelMat = Mat4(lcam.getWorldTransform());
 
 	Mat4 trf = r.getViewProjectionMat() * modelMat * localMat;
-	sProg->getUniformVariable("modelViewProjectionMat").set(&trf);
+	sProg->getUniformVariableByName("modelViewProjectionMat").set(&trf);
 
 	//
 	// Render

src/Renderer/Ssao.cpp

@@ -122,36 +122,36 @@ void Ssao::run()
 	ssaoSProg->bind();
 	
 	// planes
-	ssaoSProg->getUniformVariable("planes").set(&r.getPlanes());
+	ssaoSProg->getUniformVariableByName("planes").set(&r.getPlanes());
 
 	// limitsOfNearPlane
-	ssaoSProg->getUniformVariable("limitsOfNearPlane").set(
+	ssaoSProg->getUniformVariableByName("limitsOfNearPlane").set(
 		&r.getLimitsOfNearPlane());
 
 	// limitsOfNearPlane2
-	ssaoSProg->getUniformVariable("limitsOfNearPlane2").set(
+	ssaoSProg->getUniformVariableByName("limitsOfNearPlane2").set(
 		&r.getLimitsOfNearPlane2());
 
 	// zNear
 	float zNear = cam.getZNear();
-	ssaoSProg->getUniformVariable("zNear").set(&zNear);
+	ssaoSProg->getUniformVariableByName("zNear").set(&zNear);
 
 	// msDepthFai
-	ssaoSProg->getUniformVariable("msDepthFai").set(r.getMs().getDepthFai(), 0);
+	ssaoSProg->getUniformVariableByName("msDepthFai").set(r.getMs().getDepthFai(), 0);
 
 	// noiseMap
-	ssaoSProg->getUniformVariable("noiseMap").set(*noiseMap, 1);
+	ssaoSProg->getUniformVariableByName("noiseMap").set(*noiseMap, 1);
 
 	// noiseMapSize
 	float noiseMapSize = noiseMap->getWidth();
-	ssaoSProg->getUniformVariable("noiseMapSize").set(&noiseMapSize);
+	ssaoSProg->getUniformVariableByName("noiseMapSize").set(&noiseMapSize);
 
 	// screenSize
 	Vec2 screenSize(width * 2, height * 2);
-	ssaoSProg->getUniformVariable("screenSize").set(&screenSize);
+	ssaoSProg->getUniformVariableByName("screenSize").set(&screenSize);
 
 	// msNormalFai
-	ssaoSProg->getUniformVariable("msNormalFai").set(
+	ssaoSProg->getUniformVariableByName("msNormalFai").set(
 		r.getMs().getNormalFai(), 2);
 
 	r.drawQuad();
@@ -169,22 +169,22 @@ void Ssao::run()
 		hblurSProg->bind();
 		if(i == 0)
 		{
-			hblurSProg->getUniformVariable("img").set(ssaoFai, 0);
+			hblurSProg->getUniformVariableByName("img").set(ssaoFai, 0);
 		}
 		else
 		{
-			hblurSProg->getUniformVariable("img").set(fai, 0);
+			hblurSProg->getUniformVariableByName("img").set(fai, 0);
 		}
 		float tmp = width;
-		hblurSProg->getUniformVariable("imgDimension").set(&tmp);
+		hblurSProg->getUniformVariableByName("imgDimension").set(&tmp);
 		r.drawQuad();
 
 		// vpass
 		vblurFbo.bind();
 		vblurSProg->bind();
-		vblurSProg->getUniformVariable("img").set(hblurFai, 0);
+		vblurSProg->getUniformVariableByName("img").set(hblurFai, 0);
 		tmp = height;
-		vblurSProg->getUniformVariable("imgDimension").set(&tmp);
+		vblurSProg->getUniformVariableByName("imgDimension").set(&tmp);
 		r.drawQuad();
 	}
 

src/Resources/Material.h

@@ -79,7 +79,7 @@ class ShaderProgram;
 /// @endcode
 /// *: For if the value is not set then the in variable will be build in or
 ///    standard varying
-class Material: private MaterialProperties
+class Material: public MaterialProperties
 {
 	public:
 		//======================================================================

src/Resources/MaterialVariable.cpp

@@ -20,17 +20,17 @@ MaterialVariable::MaterialVariable(
 	{
 		if(shaderProgsArr[i]->variableExists(shaderProgVarName))
 		{
-			sProgsVars[i] = &shaderProgsArr[i]->getVariableByName(
+			sProgVars[i] = &shaderProgsArr[i]->getVariableByName(
 				shaderProgVarName);
 
 			if(!oneSProgVar)
 			{
-				oneSProgVar = sProgsVars[i];
+				oneSProgVar = sProgVars[i];
 			}
 
 			// All the sprog vars need to have same GL data type
-			if(oneSProgVar->getGlDataType() != sProgsVars[i]->getGlDataType() ||
-				oneSProgVar->getType() != sProgsVars[i]->getType())
+			if(oneSProgVar->getGlDataType() != sProgVars[i]->getGlDataType() ||
+				oneSProgVar->getType() != sProgVars[i]->getType())
 			{
 				throw EXCEPTION("Incompatible shader program variables: " +
 					shaderProgVarName);

src/Resources/MaterialVariable.h

@@ -47,7 +47,7 @@ class MaterialVariable
 			PassType p) const;
 
 		/// XXX
-		bool inPass(PassType p) const {return sProgsVars[p] != NULL;}
+		bool inPass(PassType p) const {return sProgVars[p] != NULL;}
 
 		/// Get the GL data type of all the shader program variables
 		GLenum getGlDataType() const {return oneSProgVar->getGlDataType();}
@@ -62,7 +62,7 @@ class MaterialVariable
 
 	private:
 		Type type;
-		ShaderProgramVariables sProgsVars;
+		ShaderProgramVariables sProgVars;
 
 		/// Keep one ShaderProgramVariable here for easy access of the common
 		/// variable stuff like name or GL data type etc
@@ -74,7 +74,7 @@ inline const ShaderProgramVariable& MaterialVariable::getShaderProgramVariable(
 	PassType p) const
 {
 	ASSERT(inPass(p));
-	return *sProgsVars[p];
+	return *sProgVars[p];
 }
 
 

src/Scene/MaterialRuntime.h

@@ -12,7 +12,7 @@ class MaterialRuntimeVariable;
 
 
 /// One layer above material resource
-class MaterialRuntime: private MaterialProperties
+class MaterialRuntime: public MaterialProperties
 {
 	public:
 		/// A type

src/Ui/Painter.cpp

@@ -76,8 +76,8 @@ void Painter::drawText(const char* text)
 	// SProg (some)
 	sProg->bind();
 
-	sProg->getUniformVariable("texture").set(font->getMap(), 0);
-	sProg->getUniformVariable("color").set(&col);
+	sProg->getUniformVariableByName("texture").set(font->getMap(), 0);
+	sProg->getUniformVariableByName("color").set(&col);
 
 	// Vao
 	qVao.bind();
@@ -117,8 +117,8 @@ void Painter::drawText(const char* text)
 			trfM(1, 2) = p.y() + 2.0 * (font->getGlyphBearingY(cc) -
 				int(font->getGlyphHeight(cc))) / deviceSize.y();
 
-			sProg->getUniformVariable("transformation").set(&trfM);
-			sProg->getUniformVariable("textureTranformation").set(
+			sProg->getUniformVariableByName("transformation").set(&trfM);
+			sProg->getUniformVariableByName("textureTranformation").set(
 				&font->getGlyphTextureMatrix(cc));
 
 			// Render