- Removing the friends from Material

- Refactoring the renderer
- Moving SMO to gl 3.3 core

src/Renderer/Bs.cpp

@@ -18,7 +18,8 @@ void Bs::createFbo()
 
 		fbo.setNumOfColorAttachements(1);
 
-		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, r.getPps().prePassFai.getGlId(), 0);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+		                       r.getPps().getPrePassFai().getGlId(), 0);
 		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
 		                       r.getMs().getDepthFai().getGlId(), 0);
 
@@ -91,13 +92,13 @@ void Bs::run()
 			throw EXCEPTION("Mesh \"" + meshNode->mesh->getRsrcName() + "\" doesnt have material" );
 		}
 
-		if(!meshNode->mesh->material->blends)
+		if(!meshNode->mesh->material->renderInBlendingStage())
 		{
 			continue;
 		}
 
 		// refracts
-		if(meshNode->mesh->material->stdUniVars[Material::SUV_PPS_PRE_PASS_FAI])
+		if(meshNode->mesh->material->getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI))
 		{
 			// render to the temp FAI
 			refractFbo.bind();
@@ -117,13 +118,15 @@ void Bs::run()
 			glStencilFunc(GL_EQUAL, 0x1, 0x1);
 			glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 
-			if(meshNode->mesh->material->blends)
+			if(meshNode->mesh->material->renderInBlendingStage())
 			{
 				glEnable(GL_BLEND);
-				glBlendFunc(meshNode->mesh->material->blendingSfactor, meshNode->mesh->material->blendingDfactor);
+				glBlendFunc(meshNode->mesh->material->getBlendingSfactor(), meshNode->mesh->material->getBlendingDfactor());
 			}
 			else
+			{
 				glDisable(GL_BLEND);
+			}
 
 			refractSProg->bind();
 			refractSProg->findUniVar("fai")->setTexture(refractFai, 0);

src/Renderer/Dbg.cpp

@@ -202,7 +202,8 @@ void Dbg::init(const RendererInitializer& initializer)
 
 		fbo.setNumOfColorAttachements(1);
 
-		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, r.getPps().postPassFai.getGlId(), 0);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+		                       r.getPps().getPostPassFai().getGlId(), 0);
 		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,  GL_TEXTURE_2D, r.getMs().getDepthFai().getGlId(), 0);
 
 		fbo.checkIfGood();

src/Renderer/Ez.cpp

@@ -62,14 +62,14 @@ void Ez::run()
 	for(Vec<MeshNode*>::iterator it=app->getScene().meshNodes.begin(); it!=app->getScene().meshNodes.end(); it++)
 	{
 		MeshNode* meshNode = (*it);
-		if(meshNode->mesh->material->blends)
+		if(meshNode->mesh->material->renderInBlendingStage())
 		{
 			continue;
 		}
 
-		RASSERT_THROW_EXCEPTION(meshNode->mesh->material->dpMtl.get() == NULL);
+		//RASSERT_THROW_EXCEPTION(meshNode->mesh->material->getDepthMtl() == NULL);
 
-		r.setupMaterial(*meshNode->mesh->material->dpMtl, *meshNode, r.getCamera());
+		r.setupMaterial(meshNode->mesh->material->getDepthMtl(), *meshNode, r.getCamera());
 		meshNode->renderDepth();
 	}
 

src/Renderer/Hdr.cpp

@@ -96,7 +96,7 @@ void Hdr::run()
 	toneFbo.bind();
 	toneSProg->bind();
 	toneSProg->findUniVar("exposure")->setFloat(exposure);
-	toneSProg->findUniVar("fai")->setTexture(r.getPps().prePassFai, 0);
+	toneSProg->findUniVar("fai")->setTexture(r.getPps().getPrePassFai(), 0);
 	r.drawQuad();
 
 

src/Renderer/Ms.cpp

@@ -106,7 +106,7 @@ void Ms::run()
 			throw EXCEPTION("Mesh \"" + meshNode->mesh->getRsrcName() + "\" doesnt have material");
 		}
 
-		if(meshNode->mesh->material->blends)
+		if(meshNode->mesh->material->renderInBlendingStage())
 		{
 			continue;
 		}

src/Renderer/Pps.h

@@ -17,10 +17,10 @@ class ShaderProg;
 /// This stage is divided into 2 two parts. The first happens before blending stage and the second after.
 class Pps: private RenderingPass
 {
-	public:
-		Texture prePassFai;
-		Texture postPassFai;
+	PROPERTY_R(Texture, prePassFai, getPrePassFai)
+	PROPERTY_R(Texture, postPassFai, getPostPassFai)
 
+	public:
 		Pps(Renderer& r_, Object* parent);
 		void init(const RendererInitializer& initializer);
 		void runPrePass();

src/Renderer/Renderer.cpp

@@ -94,17 +94,17 @@ void Renderer::drawQuad()
 //======================================================================================================================
 void Renderer::setupMaterial(const Material& mtl, const SceneNode& sceneNode, const Camera& cam)
 {
-	mtl.shaderProg->bind();
+	mtl.getShaderProg().bind();
 	uint textureUnit = 0;
 
 	//
 	// FFP stuff
 	//
-	if(mtl.blends)
+	if(mtl.isBlendingEnabled())
 	{
 		glEnable(GL_BLEND);
 		//glDisable(GL_BLEND);
-		glBlendFunc(mtl.blendingSfactor, mtl.blendingDfactor);
+		glBlendFunc(mtl.getBlendingSfactor(), mtl.getBlendingDfactor());
 	}
 	else
 	{
@@ -112,7 +112,7 @@ void Renderer::setupMaterial(const Material& mtl, const SceneNode& sceneNode, co
 	}
 
 
-	if(mtl.depthTesting)
+	if(mtl.isDepthTestingEnabled())
 	{
 		glEnable(GL_DEPTH_TEST);
 	}
@@ -121,7 +121,7 @@ void Renderer::setupMaterial(const Material& mtl, const SceneNode& sceneNode, co
 		glDisable(GL_DEPTH_TEST);
 	}
 
-	if(mtl.wireframe)
+	if(mtl.isWireframeEnabled())
 	{
 		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 	}
@@ -142,113 +142,113 @@ void Renderer::setupMaterial(const Material& mtl, const SceneNode& sceneNode, co
 	Mat4 modelViewProjectionMat;
 
 	// should I calculate the modelViewMat ?
-	if(mtl.stdUniVars[Material::SUV_MODELVIEW_MAT] ||
-	   mtl.stdUniVars[Material::SUV_MODELVIEWPROJECTION_MAT] ||
-	   mtl.stdUniVars[Material::SUV_NORMAL_MAT])
+	if(mtl.getStdUniVar(Material::SUV_MODELVIEW_MAT) ||
+	   mtl.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT) ||
+	   mtl.getStdUniVar(Material::SUV_NORMAL_MAT))
 	{
 		modelViewMat = Mat4::combineTransformations(viewMat, modelMat);
 	}
 
 	// set matrices
-	if(mtl.stdUniVars[Material::SUV_MODEL_MAT])
+	if(mtl.getStdUniVar(Material::SUV_MODEL_MAT))
 	{
-		mtl.stdUniVars[Material::SUV_MODEL_MAT]->setMat4(&modelMat);
+		mtl.getStdUniVar(Material::SUV_MODEL_MAT)->setMat4(&modelMat);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_VIEW_MAT])
+	if(mtl.getStdUniVar(Material::SUV_VIEW_MAT))
 	{
-		mtl.stdUniVars[Material::SUV_VIEW_MAT]->setMat4(&viewMat);
+		mtl.getStdUniVar(Material::SUV_VIEW_MAT)->setMat4(&viewMat);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_PROJECTION_MAT])
+	if(mtl.getStdUniVar(Material::SUV_PROJECTION_MAT))
 	{
-		mtl.stdUniVars[Material::SUV_PROJECTION_MAT]->setMat4(&projectionMat);
+		mtl.getStdUniVar(Material::SUV_PROJECTION_MAT)->setMat4(&projectionMat);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_MODELVIEW_MAT])
+	if(mtl.getStdUniVar(Material::SUV_MODELVIEW_MAT))
 	{
-		mtl.stdUniVars[Material::SUV_MODELVIEW_MAT]->setMat4(&modelViewMat);
+		mtl.getStdUniVar(Material::SUV_MODELVIEW_MAT)->setMat4(&modelViewMat);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_VIEWPROJECTION_MAT])
+	if(mtl.getStdUniVar(Material::SUV_VIEWPROJECTION_MAT))
 	{
-		mtl.stdUniVars[Material::SUV_VIEWPROJECTION_MAT]->setMat4(&viewProjectionMat);
+		mtl.getStdUniVar(Material::SUV_VIEWPROJECTION_MAT)->setMat4(&viewProjectionMat);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_NORMAL_MAT])
+	if(mtl.getStdUniVar(Material::SUV_NORMAL_MAT))
 	{
 		normalMat = modelViewMat.getRotationPart();
-		mtl.stdUniVars[Material::SUV_NORMAL_MAT]->setMat3(&normalMat);
+		mtl.getStdUniVar(Material::SUV_NORMAL_MAT)->setMat3(&normalMat);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_MODELVIEWPROJECTION_MAT])
+	if(mtl.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT))
 	{
 		modelViewProjectionMat = projectionMat * modelViewMat;
-		mtl.stdUniVars[Material::SUV_MODELVIEWPROJECTION_MAT]->setMat4(&modelViewProjectionMat);
+		mtl.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT)->setMat4(&modelViewProjectionMat);
 	}
 
 
 	//
 	// FAis
 	//
-	if(mtl.stdUniVars[Material::SUV_MS_NORMAL_FAI])
+	if(mtl.getStdUniVar(Material::SUV_MS_NORMAL_FAI))
 	{
-		mtl.stdUniVars[Material::SUV_MS_NORMAL_FAI]->setTexture(ms->getNormalFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_MS_NORMAL_FAI)->setTexture(ms->getNormalFai(), textureUnit++);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_MS_DIFFUSE_FAI])
+	if(mtl.getStdUniVar(Material::SUV_MS_DIFFUSE_FAI))
 	{
-		mtl.stdUniVars[Material::SUV_MS_DIFFUSE_FAI]->setTexture(ms->getDiffuseFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_MS_DIFFUSE_FAI)->setTexture(ms->getDiffuseFai(), textureUnit++);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_MS_SPECULAR_FAI])
+	if(mtl.getStdUniVar(Material::SUV_MS_SPECULAR_FAI))
 	{
-		mtl.stdUniVars[Material::SUV_MS_SPECULAR_FAI]->setTexture(ms->getSpecularFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_MS_SPECULAR_FAI)->setTexture(ms->getSpecularFai(), textureUnit++);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_MS_DEPTH_FAI])
+	if(mtl.getStdUniVar(Material::SUV_MS_DEPTH_FAI))
 	{
-		mtl.stdUniVars[Material::SUV_MS_DEPTH_FAI]->setTexture(ms->getDepthFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_MS_DEPTH_FAI)->setTexture(ms->getDepthFai(), textureUnit++);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_IS_FAI])
+	if(mtl.getStdUniVar(Material::SUV_IS_FAI))
 	{
-		mtl.stdUniVars[Material::SUV_IS_FAI]->setTexture(is->getFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_IS_FAI)->setTexture(is->getFai(), textureUnit++);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_PPS_PRE_PASS_FAI])
+	if(mtl.getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI))
 	{
-		mtl.stdUniVars[Material::SUV_PPS_PRE_PASS_FAI]->setTexture(pps->prePassFai, textureUnit++);
+		mtl.getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI)->setTexture(pps->getPrePassFai(), textureUnit++);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_PPS_POST_PASS_FAI])
+	if(mtl.getStdUniVar(Material::SUV_PPS_POST_PASS_FAI))
 	{
-		mtl.stdUniVars[Material::SUV_PPS_POST_PASS_FAI]->setTexture(pps->postPassFai, textureUnit++);
+		mtl.getStdUniVar(Material::SUV_PPS_POST_PASS_FAI)->setTexture(pps->getPostPassFai(), textureUnit++);
 	}
 
 
 	//
 	// Other
 	//
-	if(mtl.stdUniVars[Material::SUV_RENDERER_SIZE])
+	if(mtl.getStdUniVar(Material::SUV_RENDERER_SIZE))
 	{
 		Vec2 v(width, height);
-		mtl.stdUniVars[Material::SUV_RENDERER_SIZE]->setVec2(&v);
+		mtl.getStdUniVar(Material::SUV_RENDERER_SIZE)->setVec2(&v);
 	}
 
-	if(mtl.stdUniVars[Material::SUV_SCENE_AMBIENT_COLOR])
+	if(mtl.getStdUniVar(Material::SUV_SCENE_AMBIENT_COLOR))
 	{
 		Vec3 col(app->getScene().getAmbientCol());
-		mtl.stdUniVars[Material::SUV_SCENE_AMBIENT_COLOR]->setVec3(&col);
+		mtl.getStdUniVar(Material::SUV_SCENE_AMBIENT_COLOR)->setVec3(&col);
 	}
 
 
 	//
 	// set user defined vars
 	//
-	for(uint i=0; i<mtl.userDefinedVars.size(); i++)
+	for(uint i=0; i<mtl.getUserDefinedVars().size(); i++)
 	{
-		const Material::UserDefinedUniVar* udv = &mtl.userDefinedVars[i];
+		const Material::UserDefinedUniVar* udv = &mtl.getUserDefinedVars()[i];
 		switch(udv->sProgVar->getGlDataType())
 		{
 			// texture

src/Renderer/Sm.cpp

@@ -96,14 +96,14 @@ void Sm::run(const Camera& cam)
 	for(Vec<MeshNode*>::iterator it=app->getScene().meshNodes.begin(); it!=app->getScene().meshNodes.end(); it++)
 	{
 		MeshNode* meshNode = (*it);
-		if(meshNode->mesh->material->blends)
+		if(meshNode->mesh->material->renderInBlendingStage())
 		{
 			continue;
 		}
 
-		RASSERT_THROW_EXCEPTION(meshNode->mesh->material->dpMtl.get() == NULL);
+		//RASSERT_THROW_EXCEPTION(meshNode->mesh->material->dpMtl.get() == NULL);
 
-		r.setupMaterial(*meshNode->mesh->material->dpMtl, *meshNode, cam);
+		r.setupMaterial(meshNode->mesh->material->getDepthMtl(), *meshNode, cam);
 		meshNode->renderDepth();
 	}
 

src/Renderer/Smo.cpp

@@ -22,12 +22,38 @@ void Smo::init(const RendererInitializer& /*initializer*/)
 {
 	sProg.loadRsrc("shaders/IsSmo.glsl");
 
+	//
 	// Geometry stuff
-	sphereVbo = new Vbo(GL_ARRAY_BUFFER, sizeof(sMOUvSCoords), sMOUvSCoords, GL_STATIC_DRAW, this);
+	//
+
+	// Sphere
+	//
+	spherePositionsVbo = new Vbo(GL_ARRAY_BUFFER, sizeof(sMOUvSCoords), sMOUvSCoords, GL_STATIC_DRAW, this);
 	sphereVao = new Vao(this);
-	sphereVao->attachArrayBufferVbo(*sphereVbo, *sProg->findAttribVar("position"), 3, GL_FLOAT, false, 0, NULL);
+	sphereVao->attachArrayBufferVbo(*spherePositionsVbo, *sProg->findAttribVar("position"), 3, GL_FLOAT, false, 0, NULL);
+
+	// Camera
+	//
+
+	// 4 vertex positions: eye, top-right, top-left, bottom-left, bottom-right
+	cameraPositionsVbo = new Vbo(GL_ARRAY_BUFFER, sizeof(float) * 3 * 5, NULL, GL_DYNAMIC_DRAW, this);
+
+	// The vert indeces
+	enum {EYE, TR, TL, BL, BR}; // Vert positions
+
+	ushort vertIndeces[6][3] = {
+		{EYE, BR, TR}, // Right triangle
+		{EYE, TR, TL}, // Top
+		{EYE, TL, BL}, // Left
+		{EYE, BL, BR}, // Bottom
+		{BR, BL, TL}, {TL, TR, BR} // Front
+	};
 
-	//cameraVbo = new Vbo(GL_ARRAY_BUFFER, sizeof(float) * 3 * 3 * 6, sMOUvSCoords, GL_STATIC_DRAW, this);
+	cameraVertIndecesVbo = new Vbo(GL_ELEMENT_ARRAY_BUFFER, sizeof(vertIndeces), vertIndeces, GL_STATIC_DRAW, this);
+
+	cameraVao = new Vao(this);
+	cameraVao->attachArrayBufferVbo(*cameraPositionsVbo, *sProg->findAttribVar("position"), 3, GL_FLOAT, false, 0, NULL);
+	cameraVao->attachElementArrayBufferVbo(*cameraVertIndecesVbo);
 }
 
 
@@ -70,6 +96,8 @@ void Smo::run(const PointLight& light)
 //======================================================================================================================
 void Smo::run(const SpotLight& light)
 {
+	const Camera& lcam = light.getCamera();
+
 	// set GL state
 	glStencilFunc(GL_ALWAYS, 0x1, 0x1);
 	glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
@@ -78,35 +106,34 @@ void Smo::run(const SpotLight& light)
 	glColorMask(false, false, false, false);
 	glDisable(GL_CULL_FACE);
 
+	// shader prog
+	sProg->bind();
+	Mat4 modelMat = Mat4(lcam.getWorldTransform());
+	Mat4 trf = r.getViewProjectionMat() * modelMat;
+	sProg->findUniVar("modelViewProjectionMat")->setMat4(&trf);
+
+	//
+	// Render
+	//
+
 	// calc camera shape
-	const Camera& lcam = light.getCamera();
 	float x = lcam.getZFar() / tan((PI-lcam.getFovX())/2);
 	float y = tan(lcam.getFovY()/2) * lcam.getZFar();
 	float z = -lcam.getZFar();
 
-	const int TRIS_NUM = 6;
-
-	float verts[TRIS_NUM][3][3] = {
-		{{0.0, 0.0, 0.0}, {x, -y, z}, {x,  y, z}}, // right triangle
-		{{0.0, 0.0, 0.0}, {x,  y, z}, {-x,  y, z}}, // top
-		{{0.0, 0.0, 0.0}, {-x,  y, z}, {-x, -y, z}}, // left
-		{{0.0, 0.0, 0.0}, {-x, -y, z}, {x, -y, z}}, // bottom
-		{{x, -y, z}, {-x,  y, z}, {x,  y, z}}, // front up right
-		{{x, -y, z}, {-x, -y, z}, {-x,  y, z}}, // front bottom left
+	float vertPositions[5][3] = {
+		{0.0, 0.0, 0.0}, // Eye
+		{x, y, z}, // Top right
+		{-x, y, z}, // Top left
+		{-x, -y, z}, // Bottom left
+		{x, -y, z} // Bottom right
 	};
 
-	// shader prog
-	sProg->bind();
-	Mat4 modelMat = Mat4(lcam.getWorldTransform());
-	Mat4 trf = r.getCamera().getProjectionMatrix() * Mat4::combineTransformations(r.getCamera().getViewMatrix(), modelMat);
-	sProg->findUniVar("modelViewProjectionMat")->setMat4(&trf);
-
 	// render camera shape to stencil buffer
-	const int loc = 0;
-	glEnableVertexAttribArray(loc);
-	glVertexAttribPointer(loc, 3, GL_FLOAT, false, 0, verts);
-	glDrawArrays(GL_TRIANGLES, 0, TRIS_NUM * 3);
-	glDisableVertexAttribArray(loc);
+	cameraPositionsVbo->write(vertPositions, sizeof(vertPositions));
+	cameraVao->bind();
+	glDrawElements(GL_TRIANGLES, 6 * 3, GL_UNSIGNED_SHORT, 0);
+	cameraVao->unbind();
 
 	// restore GL state
 	glEnable(GL_CULL_FACE);

src/Renderer/Smo.h

@@ -23,11 +23,20 @@ class Smo: public RenderingPass
 		void run(const SpotLight& light);
 
 	private:
+		/// @name UV sphere stuff
+		/// @{
 		static float sMOUvSCoords[]; ///< Illumination stage stencil masking optimizations UV sphere vertex positions
-		Vbo* sphereVbo; ///< Illumination stage stencil masking optimizations UV sphere VBO
+		Vbo* spherePositionsVbo; ///< Illumination stage stencil masking optimizations UV sphere VBO
 		Vao* sphereVao; ///< And a VAO
-		Vbo* cameraVbo; ///< A camera shape
+		/// @}
+
+		/// @name Camera shape stuff
+		/// @{
+		Vbo* cameraPositionsVbo; ///< A camera shape
+		Vbo* cameraVertIndecesVbo; ///< The vertex indeces
 		Vao* cameraVao; ///< And another VAO
+		/// @}
+
 		RsrcPtr<ShaderProg> sProg;
 };
 

src/Resources/Material.cpp

@@ -122,7 +122,7 @@ static bool searchBlendEnum(const char* str, int& gl_enum)
 Material::Material():
 	Resource(RT_MATERIAL)
 {
-	blends = false;
+	blendingStage = false;
 	blendingSfactor = GL_ONE;
 	blendingDfactor = GL_ZERO;
 	depthTesting = true;
@@ -214,7 +214,7 @@ void Material::load(const char* filename)
 		//
 		else if(Parser::isIdentifier(token, "blendingStage"))
 		{
-			blends = Parser::parseBool(scanner);
+			blendingStage = Parser::parseBool(scanner);
 		}
 		//
 		// blendFuncs

src/Resources/Material.h

@@ -62,22 +62,21 @@ class Scanner;
 /// @endcode
 class Material: public Resource
 {
-	friend class Renderer; ///< For setupMaterial
-	friend class Ez;
-	friend class Sm;
-	friend class Ms;
-	friend class Bs;
-	friend class Mesh;
-	friend class MeshNode;
+	/// Used in depth passes of shadowmapping and not in other depth passes like EarlyZ
+	PROPERTY_R(bool, castsShadow, isShadowCaster)
 
-	public:
-		/// Initialize with default values
-		Material();
+	/// The entities with blending are being rendered in blending stage and those without in material stage
+	PROPERTY_R(bool, blendingStage, renderInBlendingStage)
 
-		/// @see Resource::load
-		void load(const char* filename);
+	PROPERTY_R(int, blendingSfactor, getBlendingSfactor) ///< Default GL_ONE
+	PROPERTY_R(int, blendingDfactor, getBlendingDfactor) ///< Default GL_ZERO
+	PROPERTY_R(bool, depthTesting, isDepthTestingEnabled)
+	PROPERTY_R(bool, wireframe, isWireframeEnabled)
 
-	private:
+	//====================================================================================================================
+	// Nested                                                                                                            =
+	//====================================================================================================================
+	public:
 		/// Standard attribute variables that are acceptable inside the material stage @ref ShaderProg
 		enum StdAttribVars
 		{
@@ -91,13 +90,6 @@ class Material: public Resource
 			SAV_NUM
 		};
 
-		/// A simple pair-like structure
-		struct PreprocDefines
-		{
-			const char* switchName;
-			const char prefix;
-		};
-
 		/// Standard uniform variables. The Renderer sees what are applicable and sets them
 		/// After changing the enum update also:
 		/// - Some statics in Material.cpp
@@ -131,13 +123,6 @@ class Material: public Resource
 			SUV_NUM ///< The number of standard uniform variables
 		};
 
-		/// Information for the standard shader program variables
-		struct StdVarNameAndGlDataTypePair
-		{
-			const char* varName;
-			GLenum dataType; ///< aka GL data type
-		};
-
 		/// Class for user defined material variables that will be passes in to the shader
 		struct UserDefinedUniVar
 		{
@@ -155,6 +140,48 @@ class Material: public Resource
 			const ShaderProg::UniVar* sProgVar;
 		}; // end UserDefinedVar
 
+	//====================================================================================================================
+	// Public                                                                                                            =
+	//====================================================================================================================
+	public:
+		/// Initialize with default values
+		Material();
+
+		/// @see Resource::load
+		void load(const char* filename);
+
+		/// @name Accessors
+		/// @{
+		const ShaderProg::AttribVar* getStdAttribVar(StdAttribVars id) const {return stdAttribVars[id];}
+		const ShaderProg::UniVar* getStdUniVar(StdUniVars id) const {return stdUniVars[id];}
+		const ShaderProg& getShaderProg() const {return *shaderProg.get();}
+		const Material& getDepthMtl() const {return *dpMtl.get();}
+		const boost::ptr_vector<UserDefinedUniVar>& 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;}
+
+		bool isBlendingEnabled() const {return blendingSfactor != GL_ONE || blendingDfactor != GL_ZERO;}
+
+	//====================================================================================================================
+	// Private                                                                                                           =
+	//====================================================================================================================
+	private:
+		/// A simple pair-like structure
+		struct PreprocDefines
+		{
+			const char* switchName;
+			const char prefix;
+		};
+
+		/// Information for the standard shader program variables
+		struct StdVarNameAndGlDataTypePair
+		{
+			const char* varName;
+			GLenum dataType; ///< aka GL data type
+		};
+
 		static PreprocDefines msGenericDefines[]; ///< Material stage defines accepted in MsGeneric.glsl
 		static PreprocDefines dpGenericDefines[]; ///< Depth pass defines accepted in DpGeneric.glsl
 		static StdVarNameAndGlDataTypePair stdAttribVarInfos[SAV_NUM];
@@ -164,21 +191,13 @@ class Material: public Resource
 		RsrcPtr<ShaderProg> shaderProg; ///< The most important aspect of materials
 		RsrcPtr<Material> dpMtl; ///< The material for depth passes. To be removed when skinning is done using transform feedback
 		boost::ptr_vector<UserDefinedUniVar> userDefinedVars;
-		bool blends; ///< The entities with blending are being rendered in blending stage and those without in material stage
-		int blendingSfactor;
-		int blendingDfactor;
-		bool depthTesting;
-		bool wireframe;
-		bool castsShadow; ///< Used in depth passes of shadowmapping and not in other depth passes like EarlyZ
 
 		/// The func sweeps all the variables of the shader program to find standard shader program variables. It updates
 		/// the stdAttribVars and stdUniVars arrays.
 		/// @exception Exception
 		void initStdShaderVars();
 
-		bool hasHWSkinning() const {return stdAttribVars[SAV_VERT_WEIGHT_BONES_NUM] != NULL;}
-
-		/// Parses the iostream for expressions like customMsSProg and customDpSProg in order to feed them into the
+		/// Parses the file for expressions like customMsSProg and customDpSProg in order to feed them into the
 		/// @ref ShaderProg::createSrcCodeToCache
 		/// @param[in] defines The available defines and their prefixes
 		/// @param[in,out] scanner The Scanner from to parse from

src/Resources/Mesh.cpp

@@ -33,23 +33,23 @@ void Mesh::load(const char* filename)
 			}
 
 			// shader needs text coords and mesh does not have any
-			if(material->stdAttribVars[Material::SAV_TEX_COORDS] != NULL && meshData.getTexCoords().size() < 1)
+			if(material->getStdAttribVar(Material::SAV_TEX_COORDS) != NULL && meshData.getTexCoords().size() < 1)
 			{
-				throw EXCEPTION("The shader program (\"" + material->shaderProg->getRsrcName() +
+				throw EXCEPTION("The shader program (\"" + material->getShaderProg().getRsrcName() +
 												"\") needs texture coord information that the mesh doesn't have");
 			}
 
 			// shader has HW skinning and mesh does not have vert weights
 			if(material->hasHWSkinning() && meshData.getVertWeights().size() < 1)
 			{
-				throw EXCEPTION("The shader program (\"" + material->shaderProg->getRsrcName() +
+				throw EXCEPTION("The shader program (\"" + material->getShaderProg().getRsrcName() +
 												"\") needs vertex weights that the mesh doesn't have");
 			}
 
 
 			createVbos(meshData);
 			createVao(mainVao, *material.get());
-			createVao(depthVao, *material->dpMtl.get());
+			createVao(depthVao, material->getDepthMtl());
 		}
 	}
 	catch(std::exception& e)
@@ -110,45 +110,45 @@ void Mesh::createVao(Vao*& vao, const Material& mtl)
 {
 	vao = new Vao(this);
 
-	if(mtl.stdAttribVars[Material::SAV_POSITION] != NULL)
+	if(mtl.getStdAttribVar(Material::SAV_POSITION) != NULL)
 	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_POSITIONS], *mtl.stdAttribVars[Material::SAV_POSITION], 3, GL_FLOAT,
+		vao->attachArrayBufferVbo(*vbos[VBO_VERT_POSITIONS], *mtl.getStdAttribVar(Material::SAV_POSITION), 3, GL_FLOAT,
 		                          GL_FALSE, 0, NULL);
 	}
 
-	if(mtl.stdAttribVars[Material::SAV_NORMAL] != NULL)
+	if(mtl.getStdAttribVar(Material::SAV_NORMAL) != NULL)
 	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_NORMALS], *mtl.stdAttribVars[Material::SAV_NORMAL], 3, GL_FLOAT,
+		vao->attachArrayBufferVbo(*vbos[VBO_VERT_NORMALS], *mtl.getStdAttribVar(Material::SAV_NORMAL), 3, GL_FLOAT,
 		                          GL_FALSE, 0, NULL);
 	}
 
-	if(mtl.stdAttribVars[Material::SAV_TANGENT] != NULL)
+	if(mtl.getStdAttribVar(Material::SAV_TANGENT) != NULL)
 	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_TANGENTS], *mtl.stdAttribVars[Material::SAV_TANGENT], 4, GL_FLOAT,
+		vao->attachArrayBufferVbo(*vbos[VBO_VERT_TANGENTS], *mtl.getStdAttribVar(Material::SAV_TANGENT), 4, GL_FLOAT,
 		                          GL_FALSE, 0, NULL);
 	}
 
-	if(mtl.stdAttribVars[Material::SAV_TEX_COORDS] != NULL)
+	if(mtl.getStdAttribVar(Material::SAV_TEX_COORDS) != NULL)
 	{
-		vao->attachArrayBufferVbo(*vbos[VBO_TEX_COORDS], *mtl.stdAttribVars[Material::SAV_TEX_COORDS], 2, GL_FLOAT,
+		vao->attachArrayBufferVbo(*vbos[VBO_TEX_COORDS], *mtl.getStdAttribVar(Material::SAV_TEX_COORDS), 2, GL_FLOAT,
 		                          GL_FALSE, 0, NULL);
 	}
 
-	if(mtl.stdAttribVars[Material::SAV_VERT_WEIGHT_BONES_NUM] != NULL)
+	if(mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_BONES_NUM) != NULL)
 	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_WEIGHTS], *mtl.stdAttribVars[Material::SAV_VERT_WEIGHT_BONES_NUM], 1,
+		vao->attachArrayBufferVbo(*vbos[VBO_VERT_WEIGHTS], *mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_BONES_NUM), 1,
 		                          GL_FLOAT, GL_FALSE, sizeof(MeshData::VertexWeight), BUFFER_OFFSET(0));
 	}
 
-	if(mtl.stdAttribVars[Material::SAV_VERT_WEIGHT_BONE_IDS] != NULL)
+	if(mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_BONE_IDS) != NULL)
 	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_WEIGHTS], *mtl.stdAttribVars[Material::SAV_VERT_WEIGHT_BONE_IDS], 4,
+		vao->attachArrayBufferVbo(*vbos[VBO_VERT_WEIGHTS], *mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_BONE_IDS), 4,
 		                          GL_FLOAT, GL_FALSE, sizeof(MeshData::VertexWeight), BUFFER_OFFSET(4));
 	}
 
-	if(mtl.stdAttribVars[Material::SAV_VERT_WEIGHT_WEIGHTS] != NULL)
+	if(mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_WEIGHTS) != NULL)
 	{
-		vao->attachArrayBufferVbo(*vbos[VBO_VERT_WEIGHTS], *mtl.stdAttribVars[Material::SAV_VERT_WEIGHT_WEIGHTS], 4,
+		vao->attachArrayBufferVbo(*vbos[VBO_VERT_WEIGHTS], *mtl.getStdAttribVar(Material::SAV_VERT_WEIGHT_WEIGHTS), 4,
 		                          GL_FLOAT, GL_FALSE, sizeof(MeshData::VertexWeight), BUFFER_OFFSET(20));
 	}
 

src/Scene/MeshNode.cpp

@@ -34,11 +34,11 @@ void MeshNode::render(const Material& mtl, const Vao& vao) const
 		RASSERT_THROW_EXCEPTION(!mtl.hasHWSkinning()); // it has skel controller but no skinning
 
 		// first the uniforms
-		mtl.stdUniVars[Material::SUV_SKINNING_ROTATIONS]->setMat3(&meshSkelCtrl->skelNode->boneRotations[0],
-		                                                          meshSkelCtrl->skelNode->skeleton->bones.size());
+		mtl.getStdUniVar(Material::SUV_SKINNING_ROTATIONS)->setMat3(&meshSkelCtrl->skelNode->boneRotations[0],
+		                                                            meshSkelCtrl->skelNode->skeleton->bones.size());
 
-		mtl.stdUniVars[Material::SUV_SKINNING_TRANSLATIONS]->setVec3(&meshSkelCtrl->skelNode->boneTranslations[0],
-		                                                             meshSkelCtrl->skelNode->skeleton->bones.size());
+		mtl.getStdUniVar(Material::SUV_SKINNING_TRANSLATIONS)->setVec3(&meshSkelCtrl->skelNode->boneTranslations[0],
+		                                                               meshSkelCtrl->skelNode->skeleton->bones.size());
 	}
 
 

src/Scene/MeshNode.h

@@ -25,7 +25,7 @@ class MeshNode: public SceneNode
 		// funcs
 		MeshNode();
 		virtual void render() { render(*mesh->material.get(), *mesh->getVao()); }
-		virtual void renderDepth() { render(*mesh->material->dpMtl.get(), *mesh->getDepthVao()); }
+		virtual void renderDepth() { render(mesh->material->getDepthMtl(), *mesh->getDepthVao()); }
 		void init(const char* filename);
 };