Material

shaders/Final.glsl

@@ -1,10 +1,10 @@
 // The final pass
 
-#pragma anki vertShaderBegins
+#pragma anki start vertexShader
 
 #pragma anki include "shaders/SimpleVert.glsl"
 
-#pragma anki fragShaderBegins
+#pragma anki start fragmentShader
 
 uniform sampler2D rasterImage;
 in vec2 vTexCoords;

shaders/IsAp.glsl

@@ -1,11 +1,11 @@
 /// @file
 /// Illumination stage ambient pass shader program
 
-#pragma anki vertShaderBegins
+#pragma anki start vertexShader
 
 #pragma anki include "shaders/SimpleVert.glsl"
 
-#pragma anki fragShaderBegins
+#pragma anki start fragmentShader
 
 uniform vec3 ambientCol;
 uniform sampler2D sceneColMap;

shaders/IsLpGeneric.glsl

@@ -24,14 +24,10 @@ uniform vec3 lightPos; ///< Light pos in eye space
 uniform float lightRadius;
 uniform vec3 lightDiffuseCol;
 uniform vec3 lightSpecularCol;
-#if defined(SPOT_LIGHT_ENABLED)
 uniform sampler2D lightTex;
 uniform mat4 texProjectionMat;
-#	if defined(SHADOW_ENABLED)
 uniform sampler2DShadow shadowMap;
 uniform float shadowMapSize;
-#	endif
-#endif
 /// @}
 
 /// @name Varyings
@@ -242,9 +238,9 @@ void main()
 	vec3 fragPosVspace = getFragPosVSpace();
 
 #if defined(POINT_LIGHT_ENABLED)
-	fColor = doPointLight(fragLightDist);
+	fColor = doPointLight(fragPosVspace);
 #elif defined(SPOT_LIGHT_ENABLED)
-	fColor = doSpotLight(fragLightDist);
+	fColor = doSpotLight(fragPosVspace);
 #endif // spot light
 
 	

shaders/IsSmo.glsl

@@ -2,7 +2,7 @@
 ///
 /// Ilunimation stage stencil masking optimizations shader program
 
-#pragma anki vertShaderBegins
+#pragma anki start vertexShader
 
 layout(location = 0) in vec3 position;
 
@@ -13,7 +13,7 @@ void main()
 	gl_Position = modelViewProjectionMat * vec4(position, 1.0);
 }
 
-#pragma anki fragShaderBegins
+#pragma anki start fragmentShader
 
 void main()
 {

shaders/PpsSsao.glsl

@@ -1,8 +1,8 @@
-#pragma anki vertShaderBegins
+#pragma anki start vertexShader
 
 #pragma anki include "shaders/SimpleVert.glsl"
 
-#pragma anki fragShaderBegins
+#pragma anki start fragmentShader
 
 #pragma anki include "shaders/Pack.glsl"
 

src/Main.cpp

@@ -463,11 +463,11 @@ int main(int argc, char* argv[])
 {
 	try
 	{
-		Material2 mtl;
+		/*Material2 mtl;
 		mtl.load("lala.mtl");
 
 
-		return 0;
+		return 0;*/
 
 		AppSingleton::getInstance().init(argc, argv);
 		init();
@@ -480,7 +480,7 @@ int main(int argc, char* argv[])
 	}
 	catch(std::exception& e)
 	{
-		ERROR("Aborting: " << e.what());
+		//ERROR("Aborting: " << e.what());
 		std::cerr << "Aborting: " << e.what() << std::endl;
 		//abort();
 		return 1;

src/Renderer/Bl.cpp

@@ -104,8 +104,8 @@ void Bl::runSideBlur()
 	glBlendFunc(GL_ONE, GL_ONE);
 
 	sideBlurSProg->bind();
-	sideBlurSProg->findUniVar("tex")->set(*sideBlurMap, 0);
-	sideBlurSProg->findUniVar("factor")->set(&sideBlurFactor);
+	sideBlurSProg->getUniformVariable("tex").set(*sideBlurMap, 0);
+	sideBlurSProg->getUniformVariable("factor").set(&sideBlurFactor);
 
 	r.drawQuad();
 }
@@ -124,10 +124,12 @@ void Bl::runBlur()
 		hBlurFbo.bind();
 
 		hBlurSProg->bind();
-		hBlurSProg->findUniVar("img")->set(r.getPps().getPostPassFai(), 0);
-		hBlurSProg->findUniVar("msNormalFai")->set(r.getMs().getNormalFai(), 1);
+		hBlurSProg->getUniformVariable("img").set(
+			r.getPps().getPostPassFai(), 0);
+		hBlurSProg->getUniformVariable("msNormalFai").set(
+			r.getMs().getNormalFai(), 1);
 		float tmp = r.getWidth();
-		hBlurSProg->findUniVar("imgDimension")->set(&tmp);
+		hBlurSProg->getUniformVariable("imgDimension").set(&tmp);
 
 		r.drawQuad();
 
@@ -135,10 +137,11 @@ void Bl::runBlur()
 		vBlurFbo.bind();
 
 		vBlurSProg->bind();
-		vBlurSProg->findUniVar("img")->set(blurFai, 0);
-		vBlurSProg->findUniVar("msNormalFai")->set(r.getMs().getNormalFai(), 1);
+		vBlurSProg->getUniformVariable("img").set(blurFai, 0);
+		vBlurSProg->getUniformVariable("msNormalFai").set(
+			r.getMs().getNormalFai(), 1);
 		tmp = r.getHeight();
-		vBlurSProg->findUniVar("imgDimension")->set(&tmp);
+		vBlurSProg->getUniformVariable("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->findUniVar("modelViewProjectionMat")->set(&pmv);
+	sProg->getUniformVariable("modelViewProjectionMat").set(&pmv);
 
 	vao.bind();
 	glDrawArrays(GL_LINES, 0, pointIndex);

src/Renderer/Hdr.cpp

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

src/Renderer/Is.cpp

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

src/Renderer/MainRenderer.cpp

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

src/Renderer/Pps.cpp

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

src/Renderer/SkinsDeformer.cpp

@@ -49,10 +49,10 @@ void SkinsDeformer::deform(SkinPatchNode& node)
 	sProg->bind();
 
 	// Uniforms
-	sProg->findUniVar("skinningRotations")->set(
+	sProg->getUniformVariable("skinningRotations").set(
 		&skinNode->getBoneRotations()[0], skinNode->getBoneRotations().size());
 
-	sProg->findUniVar("skinningTranslations")->set(
+	sProg->getUniformVariable("skinningTranslations").set(
 		&skinNode->getBoneTranslations()[0],
 		skinNode->getBoneTranslations().size());
 

src/Renderer/Smo.cpp

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

src/Renderer/Ssao.cpp

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

src/Resources/Material.cpp

@@ -264,7 +264,7 @@ void Material::load(const char* filename)
 					userDefinedVarTree.get<std::string>("name");
 
 				// check if the uniform exists
-				if(!shaderProg->uniVarExists(varName.c_str()))
+				if(!shaderProg->uniformVariableExists(varName.c_str()))
 				{
 					throw EXCEPTION("The variable \"" + varName +
 						"\" is not an active uniform");
@@ -273,7 +273,7 @@ void Material::load(const char* filename)
 				const ptree& valueTree = userDefinedVarTree.get_child("value");
 
 				const SProgUniVar& uni =
-					*shaderProg->findUniVar(varName.c_str());
+					shaderProg->getUniformVariable(varName.c_str());
 
 				// read the values
 				switch(uni.getGlDataType())
@@ -382,14 +382,14 @@ void Material::initStdShaderVars()
 	for(uint i = 0; i < SAV_NUM; i++)
 	{
 		// if the var is not in the sProg then... bye
-		if(!shaderProg->attribVarExists(stdAttribVarInfos[i].varName))
+		if(!shaderProg->attributeVariableExists(stdAttribVarInfos[i].varName))
 		{
 			stdAttribVars[i] = NULL;
 			continue;
 		}
 
 		// set the std var
-		stdAttribVars[i] = shaderProg->findAttribVar(
+		stdAttribVars[i] = &shaderProg->getAttributeVariable(
 			stdAttribVarInfos[i].varName);
 
 		// check if the shader has different GL data type from that it suppose
@@ -406,14 +406,15 @@ void Material::initStdShaderVars()
 	for(uint i = 0; i < SUV_NUM; i++)
 	{
 		// if the var is not in the sProg then... bye
-		if(!shaderProg->uniVarExists(stdUniVarInfos[i].varName))
+		if(!shaderProg->uniformVariableExists(stdUniVarInfos[i].varName))
 		{
 			stdUniVars[i] = NULL;
 			continue;
 		}
 
 		// set the std var
-		stdUniVars[i] = shaderProg->findUniVar(stdUniVarInfos[i].varName);
+		stdUniVars[i] =
+			&shaderProg->getUniformVariable(stdUniVarInfos[i].varName);
 
 		// check if the shader has different GL data type from that it
 		// suppose to have

src/Resources/Material2.cpp

@@ -4,6 +4,7 @@
 #include "MaterialShaderProgramCreator.h"
 #include "Core/App.h"
 #include "Core/Globals.h"
+#include "ShaderProg.h"
 #include <boost/foreach.hpp>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
@@ -151,8 +152,11 @@ void Material2::parseMaterialTag(const boost::property_tree::ptree& pt)
 	const std::string& cpSrc = mspc.getShaderProgramSource();
 	std::string dpSrc = "#define DEPTH_PASS\n" + cpSrc;
 
-	createShaderProgSourceToCache(cpSrc);
-	createShaderProgSourceToCache(dpSrc);
+	std::string cfile = createShaderProgSourceToCache(cpSrc);
+	std::string dfile = createShaderProgSourceToCache(dpSrc);
+
+	cpShaderProg.loadRsrc(cfile.c_str());
+	dpShaderProg.loadRsrc(dfile.c_str());
 }
 
 
@@ -166,11 +170,9 @@ std::string Material2::createShaderProgSourceToCache(const std::string& source)
 	std::size_t h = stringHash(source);
 	std::string prefix = boost::lexical_cast<std::string>(h);
 
-	// Create path XXX
-	/*boost::filesystem::path newfPathName =
-		AppSingleton::getInstance().getCachePath() / (prefix + ".glsl");*/
+	// Create path
 	boost::filesystem::path newfPathName =
-		boost::filesystem::path("/users/panoscc/.anki/cache") / (prefix + ".glsl");
+		AppSingleton::getInstance().getCachePath() / (prefix + ".glsl");
 
 
 	// If file not exists write it
@@ -209,3 +211,10 @@ void Material2::load(const char* filename)
 	}
 }
 
+
+//==============================================================================
+// getVariables                                                                =
+//==============================================================================
+void Material2::getVariables()
+{
+}

src/Resources/Material2.h

@@ -101,6 +101,19 @@ struct MaterialProperties
 class Material2: private MaterialProperties
 {
 	public:
+		//======================================================================
+		// Nested                                                              =
+		//======================================================================
+
+		typedef boost::ptr_vector<MaterialVariable> VarsContainer;
+
+		typedef boost::unordered_map<BuildinMaterialVariable::BuildinVariable,
+			BuildinMaterialVariable*> BuildinEnumToBuildinHashMap;
+
+		//======================================================================
+		// Methods                                                             =
+		//======================================================================
+
 		/// Initialize with default values
 		Material2();
 
@@ -114,8 +127,8 @@ class Material2: private MaterialProperties
 		GETTER_R_BY_VAL(int, blendingDfactor, getBlendingDfactor)
 		GETTER_R_BY_VAL(bool, depthTesting, isDepthTestingEnabled)
 		GETTER_R_BY_VAL(bool, wireframe, isWireframeEnabled)
-		GETTER_R(boost::ptr_vector<MaterialVariable>, mtlVars,
-			getMaterialVariables)
+
+		GETTER_R(VarsContainer, mtlVars, getMaterialVariables)
 
 		/// Access the base class just for copying in other classes
 		GETTER_R(MaterialProperties, *this, accessMaterialPropertiesBaseClass)
@@ -140,12 +153,11 @@ class Material2: private MaterialProperties
 		//======================================================================
 
 		/// All the material variables. Both buildins and user
-		boost::ptr_vector<MaterialVariable> mtlVars;
+		VarsContainer mtlVars;
 
-		boost::unordered_map<BuildinMaterialVariable::BuildinVariable,
-			BuildinMaterialVariable*> enumToBuildinMtlVar;
+		BuildinEnumToBuildinHashMap enumToBuildinMtlVar; ///< To find
 
-		Vec<UserMaterialVariable*> userMtlVars;
+		Vec<UserMaterialVariable*> userMtlVars; ///< To find
 
 		/// The most important aspect of materials. Shader program for color
 		/// passes
@@ -166,6 +178,9 @@ class Material2: private MaterialProperties
 
 		/// XXX
 		std::string createShaderProgSourceToCache(const std::string& source);
+
+		/// XXX
+		void getVariables();
 };
 
 

src/Resources/ShaderProg.cpp

@@ -13,7 +13,8 @@
 #include "Core/Globals.h"
 
 
-#define SPROG_EXCEPTION(x) EXCEPTION("Shader prog \"" + rsrcFilename + "\": " + x)
+#define SPROG_EXCEPTION(x) EXCEPTION("Shader prog \"" + rsrcFilename + \
+	"\": " + x)
 
 
 //==============================================================================
@@ -65,11 +66,12 @@ uint ShaderProg::createAndCompileShader(const char* sourceCode,
 		// print info log
 		int infoLen = 0;
 		int charsWritten = 0;
-		std::string infoLog;
+		Vec<char> infoLog;
 
 		glGetShaderiv(glId, GL_INFO_LOG_LENGTH, &infoLen);
 		infoLog.resize(infoLen + 1);
 		glGetShaderInfoLog(glId, infoLen, &charsWritten, &infoLog[0]);
+		infoLog[charsWritten] = '\0';
 		
 		const char* shaderType = "*dummy*";
 		switch(type)
@@ -83,8 +85,10 @@ uint ShaderProg::createAndCompileShader(const char* sourceCode,
 			default:
 				ASSERT(0); // Not supported
 		}
-		throw SPROG_EXCEPTION(shaderType + " compiler error log follows:\n" +
-			infoLog);
+		throw SPROG_EXCEPTION(shaderType + " compiler error log follows:\n"
+			"===================================\n" +
+			&infoLog[0] +
+			"\n===================================\n" + sourceCode);
 	}
 
 	return glId;
@@ -149,14 +153,14 @@ void ShaderProg::getUniAndAttribVars()
 		}
 
 		SProgAttribVar* var = new SProgAttribVar(loc, &name_[0], type, *this);
-		attribVars.push_back(var);
-		attribNameToVar[attribVars.back().getName().c_str()] = var;
+		vars.push_back(var);
+		nameToVar[var->getName().c_str()] = var;
+		nameToAttribVar[var->getName().c_str()] = var;
 	}
 
 
 	// uni locations
 	glGetProgramiv(glId, GL_ACTIVE_UNIFORMS, &num);
-	uniVars.reserve(num);
 	for(int i=0; i<num; i++) // loop all uniforms
 	{
 		glGetActiveUniform(glId, i, sizeof(name_) / sizeof(char), &length,
@@ -174,8 +178,9 @@ void ShaderProg::getUniAndAttribVars()
 		}
 
 		SProgUniVar* var = new SProgUniVar(loc, &name_[0], type, *this);
-		uniVars.push_back(var);
-		uniNameToVar[uniVars.back().getName().c_str()] = var;
+		vars.push_back(var);
+		nameToVar[var->getName().c_str()] = var;
+		nameToUniVar[var->getName().c_str()] = var;
 	}
 }
 
@@ -233,50 +238,74 @@ void ShaderProg::load(const char* filename)
 
 
 //==============================================================================
-// findUniVar                                                                  =
+// getVariable                                                                 =
 //==============================================================================
-const SProgUniVar* ShaderProg::findUniVar(const char* name) const
+const SProgVar& ShaderProg::getVariable(const char* name) const
 {
-	NameToSProgUniVarIterator it = uniNameToVar.find(name);
-	if(it == uniNameToVar.end())
+	VarsHashMap::const_iterator it = nameToVar.find(name);
+	if(it == nameToVar.end())
 	{
-		throw SPROG_EXCEPTION("Cannot get uniform loc \"" + name + '\"');
+		throw SPROG_EXCEPTION("Cannot get variable: " + name);
 	}
-	return it->second;
+	return *(it->second);
 }
 
 
 //==============================================================================
-// findAttribVar                                                               =
+// getAttributeVariable                                                        =
 //==============================================================================
-const SProgAttribVar* ShaderProg::findAttribVar(const char* name) const
+const SProgAttribVar& ShaderProg::getAttributeVariable(const char* name) const
 {
-	NameToSProgAttribVarIterator it = attribNameToVar.find(name);
-	if(it == attribNameToVar.end())
+	AttribVarsHashMap::const_iterator it = nameToAttribVar.find(name);
+	if(it == nameToAttribVar.end())
 	{
-		throw SPROG_EXCEPTION("Cannot get attribute loc \"" + name + '\"');
+		throw SPROG_EXCEPTION("Cannot get attribute loc: " + name);
 	}
-	return it->second;
+	return *(it->second);
 }
 
 
 //==============================================================================
-// uniVarExists                                                                =
+// getUniformVariable                                                          =
 //==============================================================================
-bool ShaderProg::uniVarExists(const char* name) const
+const SProgUniVar& ShaderProg::getUniformVariable(const char* name) const
 {
-	NameToSProgUniVarIterator it = uniNameToVar.find(name);
-	return it != uniNameToVar.end();
+	UniVarsHashMap::const_iterator it = nameToUniVar.find(name);
+	if(it == nameToUniVar.end())
+	{
+		throw SPROG_EXCEPTION("Cannot get uniform loc: " + name);
+	}
+	return *(it->second);
 }
 
 
 //==============================================================================
-// attribVarExists                                                             =
+// variableExists                                                              =
 //==============================================================================
-bool ShaderProg::attribVarExists(const char* name) const
+bool ShaderProg::variableExists(const char* name) const
 {
-	NameToSProgAttribVarIterator it = attribNameToVar.find(name);
-	return it != attribNameToVar.end();
+	VarsHashMap::const_iterator it = nameToVar.find(name);
+	return it != nameToVar.end();
+}
+
+
+//==============================================================================
+// uniformVariableExists                                                       =
+//==============================================================================
+bool ShaderProg::uniformVariableExists(const char* name) const
+{
+	UniVarsHashMap::const_iterator it = nameToUniVar.find(name);
+	return it != nameToUniVar.end();
+}
+
+
+//==============================================================================
+// attributeVariableExists                                                     =
+//==============================================================================
+bool ShaderProg::attributeVariableExists(const char* name) const
+{
+	AttribVarsHashMap::const_iterator it = nameToAttribVar.find(name);
+	return it != nameToAttribVar.end();
 }
 
 
@@ -329,16 +358,18 @@ std::string ShaderProg::getShaderInfoString() const
 {
 	std::stringstream ss;
 
-	ss << "Uniform vars:\n";
-	BOOST_FOREACH(const SProgUniVar& var, uniVars)
-	{
-		ss << var.getName() << " " << var.getLoc() << "\n";
-	}
-
-	ss << "\nAttribute vars:\n";
-	BOOST_FOREACH(const SProgAttribVar& var, attribVars)
+	ss << "Variables:\n";
+	BOOST_FOREACH(const SProgVar& var, vars)
 	{
-		ss << var.getName() << " " << var.getLoc() << "\n";
+		ss << var.getName() << " " << var.getLoc() << " ";
+		if(var.getType() == SProgVar::SVT_ATTRIBUTE)
+		{
+			ss << "attribute";
+		}
+		else
+		{
+			ss << "uniform";
+		}
 	}
 
 	return ss.str();

src/Resources/ShaderProg.h

@@ -32,8 +32,7 @@ class ShaderProg
 		/// @name Accessors
 		/// @{
 		GLuint getGlId() const;
-		/*GETTER_R(boost::ptr_vector<SProgUniVar>, uniVars, getUniVars)
-		GETTER_R(boost::ptr_vector<SProgAttribVar>, attribVars, getAttribVars)*/
+		GETTER_R(boost::ptr_vector<SProgVar>, vars, getVariables)
 		/// @}
 
 		/// Resource load
@@ -41,32 +40,23 @@ class ShaderProg
 
 		/// Bind the shader program
 		void bind() const;
-		
-		/// Unbind all shader programs
-		//static void unbind() {glUseProgram(0);}
-
-		/// Query the GL driver for the current shader program GL ID
-		/// @return Shader program GL id
-		//static uint getCurrentProgramGlId();
-
-		/// 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 SProgUniVar* findUniVar(const char* varName) const;
-
-		/// Find Attribute variable
-		/// @see findUniVar
-		const SProgAttribVar* findAttribVar(const char* varName) const;
 
-		/// Uniform variable exits
-		/// @return True if uniform variable exits
-		bool uniVarExists(const char* varName) const;
+		/// @name Variable getters
+		/// Used to find and return the variable. They throw exception if
+		/// variable not found so ask if the variable with that name exists
+		/// prior using any of these
+		/// @{
+		const SProgVar& getVariable(const char* varName) const;
+		const SProgUniVar& getUniformVariable(const char* varName) const;
+		const SProgAttribVar& getAttributeVariable(const char* varName) const;
+		/// @}
 
-		/// Attribute variable exits
-		/// @return True if attribute variable exits
-		bool attribVarExists(const char* varName) const;
+		/// @name Check for variable existance
+		/// @{
+		bool variableExists(const char* varName) const;
+		bool uniformVariableExists(const char* varName) const;
+		bool attributeVariableExists(const char* varName) const;
+		/// @}
 
 		/// Used by @ref Material and @ref Renderer to create custom shaders in
 		/// the cache
@@ -79,35 +69,35 @@ class ShaderProg
 		static std::string createSrcCodeToCache(const char* sProgFPathName,
 			const char* preAppendedSrcCode);
 
-		/// Relink the program. Used in transform feedback
-		void relink() const {link();}
-
 		/// For debuging
 		std::string getShaderInfoString() const;
 
 	private:
-		/// Uniform variable name to variable iterator
-		typedef ConstCharPtrHashMap<SProgUniVar*>::Type::const_iterator
-			NameToSProgUniVarIterator;
-		/// Attribute variable name to variable iterator
-		typedef ConstCharPtrHashMap<SProgAttribVar*>::Type::const_iterator
-			NameToSProgAttribVarIterator;
+		/// XXX
+		typedef ConstCharPtrHashMap<SProgVar*>::Type VarsHashMap;
+
+		/// XXX
+		typedef ConstCharPtrHashMap<SProgUniVar*>::Type UniVarsHashMap;
+
+		/// XXX
+		typedef ConstCharPtrHashMap<SProgAttribVar*>::Type AttribVarsHashMap;
 
 		std::string rsrcFilename;
 		GLuint glId; ///< The OpenGL ID of the shader program
 		GLuint vertShaderGlId; ///< Vertex shader OpenGL id
 		GLuint geomShaderGlId; ///< Geometry shader OpenGL id
 		GLuint fragShaderGlId; ///< Fragment shader OpenGL id
+
 		/// Shader source that is used in ALL shader programs
 		static std::string stdSourceCode;
-		/// All the uniform variables
-		boost::ptr_vector<SProgUniVar> uniVars;
-		/// All the attribute variables
-		boost::ptr_vector<SProgAttribVar> attribVars;
-		/// A UnorderedMap for fast variable searching
-		ConstCharPtrHashMap<SProgUniVar*>::Type uniNameToVar;
-		///< @see uniNameToVar
-		ConstCharPtrHashMap<SProgAttribVar*>::Type attribNameToVar;
+
+		/// @name Containers
+		/// @{
+		boost::ptr_vector<SProgVar> vars; ///< All the vars
+		VarsHashMap nameToVar; ///< Variable searching
+		UniVarsHashMap nameToUniVar; ///< Uniform searching
+		AttribVarsHashMap nameToAttribVar; ///< Attribute searching
+		/// @}
 
 		/// Query the driver to get the vars. After the linking of the shader
 		/// prog is done gather all the vars in custom containers
@@ -148,12 +138,4 @@ inline void ShaderProg::bind() const
 }
 
 
-/*inline uint ShaderProg::getCurrentProgramGlId()
-{
-	int i;
-	glGetIntegerv(GL_CURRENT_PROGRAM, &i);
-	return i;
-}*/
-
-
 #endif

src/Ui/Painter.cpp

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