Nothing worth mentioning

src/Main.cpp

@@ -412,6 +412,8 @@ int main(int argc, char* argv[])
 {
 	new App(argc, argv);
 
+	INFO(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl", "miafora k enan kairo\n", "Prefix"));
+	return 0;
 	init();
 
 	mainLoop();

src/Renderer/Is.cpp

@@ -98,50 +98,66 @@ void Renderer::Is::initFbo()
 void Renderer::Is::init()
 {
 	// load the shaders
-	ambientPassSProg.customLoad("shaders/IsAp.glsl");
-	ambientPassSProg.uniVars.ambientCol = ambientPassSProg.findUniVar("ambientCol");
-	ambientPassSProg.uniVars.sceneColMap = ambientPassSProg.findUniVar("sceneColMap");
-
-	pointLightSProg.customLoad("shaders/IsLpGeneric.glsl", "#define POINT_LIGHT_ENABLED\n");
-	pointLightSProg.uniVars.msNormalFai = pointLightSProg.findUniVar("msNormalFai");
-	pointLightSProg.uniVars.msDiffuseFai = pointLightSProg.findUniVar("msDiffuseFai");
-	pointLightSProg.uniVars.msSpecularFai = pointLightSProg.findUniVar("msSpecularFai");
-	pointLightSProg.uniVars.msDepthFai = pointLightSProg.findUniVar("msDepthFai");
-	pointLightSProg.uniVars.planes = pointLightSProg.findUniVar("planes");
-	pointLightSProg.uniVars.lightPos = pointLightSProg.findUniVar("lightPos");
-	pointLightSProg.uniVars.lightInvRadius = pointLightSProg.findUniVar("lightInvRadius");
-	pointLightSProg.uniVars.lightDiffuseCol = pointLightSProg.findUniVar("lightDiffuseCol");
-	pointLightSProg.uniVars.lightSpecularCol = pointLightSProg.findUniVar("lightSpecularCol");
-
-	spotLightNoShadowSProg.customLoad("shaders/IsLpGeneric.glsl", "#define SPOT_LIGHT_ENABLED\n");
-	spotLightNoShadowSProg.uniVars.msNormalFai = spotLightNoShadowSProg.findUniVar("msNormalFai");
-	spotLightNoShadowSProg.uniVars.msDiffuseFai = spotLightNoShadowSProg.findUniVar("msDiffuseFai");
-	spotLightNoShadowSProg.uniVars.msSpecularFai = spotLightNoShadowSProg.findUniVar("msSpecularFai");
-	spotLightNoShadowSProg.uniVars.msDepthFai = spotLightNoShadowSProg.findUniVar("msDepthFai");
-	spotLightNoShadowSProg.uniVars.planes = spotLightNoShadowSProg.findUniVar("planes");
-	spotLightNoShadowSProg.uniVars.lightPos = spotLightNoShadowSProg.findUniVar("lightPos");
-	spotLightNoShadowSProg.uniVars.lightInvRadius = spotLightNoShadowSProg.findUniVar("lightInvRadius");
-	spotLightNoShadowSProg.uniVars.lightDiffuseCol = spotLightNoShadowSProg.findUniVar("lightDiffuseCol");
-	spotLightNoShadowSProg.uniVars.lightSpecularCol = spotLightNoShadowSProg.findUniVar("lightSpecularCol");
-	spotLightNoShadowSProg.uniVars.lightTex = spotLightNoShadowSProg.findUniVar("lightTex");
-	spotLightNoShadowSProg.uniVars.texProjectionMat = spotLightNoShadowSProg.findUniVar("texProjectionMat");
-
-	string pps = "#define SHADOWMAP_SIZE " + Util::intToStr(sm.resolution) + "\n#define SPOT_LIGHT_ENABLED\n#define SHADOW_ENABLED\n";
+	ambientPassSProg = Resource::shaders.load("shaders/IsAp.glsl");
+	ambientColUniVar = ambientPassSProg->findUniVar("ambientCol");
+	sceneColMapUniVar = ambientPassSProg->findUniVar("sceneColMap");
+
+	// point light
+	pointLightSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
+	                                                                          "#define POINT_LIGHT_ENABLED\n",
+	                                                                          "Point").c_str());
+	pointLightSProgUniVars.msNormalFai = pointLightSProg->findUniVar("msNormalFai");
+	pointLightSProgUniVars.msDiffuseFai = pointLightSProg->findUniVar("msDiffuseFai");
+	pointLightSProgUniVars.msSpecularFai = pointLightSProg->findUniVar("msSpecularFai");
+	pointLightSProgUniVars.msDepthFai = pointLightSProg->findUniVar("msDepthFai");
+	pointLightSProgUniVars.planes = pointLightSProg->findUniVar("planes");
+	pointLightSProgUniVars.lightPos = pointLightSProg->findUniVar("lightPos");
+	pointLightSProgUniVars.lightInvRadius = pointLightSProg->findUniVar("lightInvRadius");
+	pointLightSProgUniVars.lightDiffuseCol = pointLightSProg->findUniVar("lightDiffuseCol");
+	pointLightSProgUniVars.lightSpecularCol = pointLightSProg->findUniVar("lightSpecularCol");
+
+
+	// spot light no shadow
+	spotLightNoShadowSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
+	                                                                                 "#define SPOT_LIGHT_ENABLED\n",
+	                                                                                 "SpotNoShadow").c_str());
+	spotLightNoShadowSProgUniVars.msNormalFai = spotLightNoShadowSProg->findUniVar("msNormalFai");
+	spotLightNoShadowSProgUniVars.msDiffuseFai = spotLightNoShadowSProg->findUniVar("msDiffuseFai");
+	spotLightNoShadowSProgUniVars.msSpecularFai = spotLightNoShadowSProg->findUniVar("msSpecularFai");
+	spotLightNoShadowSProgUniVars.msDepthFai = spotLightNoShadowSProg->findUniVar("msDepthFai");
+	spotLightNoShadowSProgUniVars.planes = spotLightNoShadowSProg->findUniVar("planes");
+	spotLightNoShadowSProgUniVars.lightPos = spotLightNoShadowSProg->findUniVar("lightPos");
+	spotLightNoShadowSProgUniVars.lightInvRadius = spotLightNoShadowSProg->findUniVar("lightInvRadius");
+	spotLightNoShadowSProgUniVars.lightDiffuseCol = spotLightNoShadowSProg->findUniVar("lightDiffuseCol");
+	spotLightNoShadowSProgUniVars.lightSpecularCol = spotLightNoShadowSProg->findUniVar("lightSpecularCol");
+	spotLightNoShadowSProgUniVars.lightTex = spotLightNoShadowSProg->findUniVar("lightTex");
+	spotLightNoShadowSProgUniVars.texProjectionMat = spotLightNoShadowSProg->findUniVar("texProjectionMat");
+
+
+	// spot light w/t shadow
+	string pps = string("\n#define SPOT_LIGHT_ENABLED\n#define SHADOW_ENABLED\n") +
+	             "#define SHADOWMAP_SIZE " + Util::intToStr(sm.resolution);
+	string prefix = "SpotShadowSms" + Util::intToStr(sm.resolution);
 	if(sm.pcfEnabled)
+	{
 		pps += "#define PCF_ENABLED";
-	spotLightShadowSProg.customLoad("shaders/IsLpGeneric.glsl", pps.c_str());
-	spotLightShadowSProg.uniVars.msNormalFai = spotLightShadowSProg.findUniVar("msNormalFai");
-	spotLightShadowSProg.uniVars.msDiffuseFai = spotLightShadowSProg.findUniVar("msDiffuseFai");
-	spotLightShadowSProg.uniVars.msSpecularFai = spotLightShadowSProg.findUniVar("msSpecularFai");
-	spotLightShadowSProg.uniVars.msDepthFai = spotLightShadowSProg.findUniVar("msDepthFai");
-	spotLightShadowSProg.uniVars.planes = spotLightShadowSProg.findUniVar("planes");
-	spotLightShadowSProg.uniVars.lightPos = spotLightShadowSProg.findUniVar("lightPos");
-	spotLightShadowSProg.uniVars.lightInvRadius = spotLightShadowSProg.findUniVar("lightInvRadius");
-	spotLightShadowSProg.uniVars.lightDiffuseCol = spotLightShadowSProg.findUniVar("lightDiffuseCol");
-	spotLightShadowSProg.uniVars.lightSpecularCol = spotLightShadowSProg.findUniVar("lightSpecularCol");
-	spotLightShadowSProg.uniVars.lightTex = spotLightShadowSProg.findUniVar("lightTex");
-	spotLightShadowSProg.uniVars.texProjectionMat = spotLightShadowSProg.findUniVar("texProjectionMat");
-	spotLightShadowSProg.uniVars.shadowMap = spotLightShadowSProg.findUniVar("shadowMap");
+		prefix += "Pcf";
+	}
+	spotLightShadowSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
+	                                                                               pps.c_str(),
+	                                                                               prefix.c_str()).c_str());
+	spotLightShadowSProgUniVars.msNormalFai = spotLightShadowSProg->findUniVar("msNormalFai");
+	spotLightShadowSProgUniVars.msDiffuseFai = spotLightShadowSProg->findUniVar("msDiffuseFai");
+	spotLightShadowSProgUniVars.msSpecularFai = spotLightShadowSProg->findUniVar("msSpecularFai");
+	spotLightShadowSProgUniVars.msDepthFai = spotLightShadowSProg->findUniVar("msDepthFai");
+	spotLightShadowSProgUniVars.planes = spotLightShadowSProg->findUniVar("planes");
+	spotLightShadowSProgUniVars.lightPos = spotLightShadowSProg->findUniVar("lightPos");
+	spotLightShadowSProgUniVars.lightInvRadius = spotLightShadowSProg->findUniVar("lightInvRadius");
+	spotLightShadowSProgUniVars.lightDiffuseCol = spotLightShadowSProg->findUniVar("lightDiffuseCol");
+	spotLightShadowSProgUniVars.lightSpecularCol = spotLightShadowSProg->findUniVar("lightSpecularCol");
+	spotLightShadowSProgUniVars.lightTex = spotLightShadowSProg->findUniVar("lightTex");
+	spotLightShadowSProgUniVars.texProjectionMat = spotLightShadowSProg->findUniVar("texProjectionMat");
+	spotLightShadowSProgUniVars.shadowMap = spotLightShadowSProg->findUniVar("shadowMap");
 
 
 	// init the rest
@@ -161,11 +177,11 @@ void Renderer::Is::ambientPass(const Vec3& color)
 	glDisable(GL_BLEND);
 
 	// set the shader
-	ambientPassSProg.bind();
+	ambientPassSProg->bind();
 
 	// set the uniforms
-	ambientPassSProg.uniVars.ambientCol->setVec3(&color);
-	ambientPassSProg.uniVars.sceneColMap->setTexture(r.ms.diffuseFai, 0);
+	ambientColUniVar->setVec3(&color);
+	sceneColMapUniVar->setTexture(r.ms.diffuseFai, 0);
 
 	// Draw quad
 	Renderer::drawQuad(0);
@@ -187,19 +203,19 @@ void Renderer::Is::pointLightPass(const PointLight& light)
 	smo.run(light);
 
 	// shader prog
-	const LightShaderProg& shader = pointLightSProg; // ensure the const-ness
+	const ShaderProg& shader = *pointLightSProg; // ensure the const-ness
 	shader.bind();
 
-	shader.uniVars.msNormalFai->setTexture(r.ms.normalFai, 0);
-	shader.uniVars.msDiffuseFai->setTexture(r.ms.diffuseFai, 1);
-	shader.uniVars.msSpecularFai->setTexture(r.ms.specularFai, 2);
-	shader.uniVars.msDepthFai->setTexture(r.ms.depthFai, 3);
-	shader.uniVars.planes->setVec2(&planes);
+	pointLightSProgUniVars.msNormalFai->setTexture(r.ms.normalFai, 0);
+	pointLightSProgUniVars.msDiffuseFai->setTexture(r.ms.diffuseFai, 1);
+	pointLightSProgUniVars.msSpecularFai->setTexture(r.ms.specularFai, 2);
+	pointLightSProgUniVars.msDepthFai->setTexture(r.ms.depthFai, 3);
+	pointLightSProgUniVars.planes->setVec2(&planes);
 	Vec3 lightPosEyeSpace = light.getWorldTransform().getOrigin().getTransformed(cam.getViewMatrix());
-	shader.uniVars.lightPos->setVec3(&lightPosEyeSpace);
-	shader.uniVars.lightInvRadius->setFloat(1.0/light.radius);
-	shader.uniVars.lightDiffuseCol->setVec3(&light.lightProps->getDiffuseColor());
-	shader.uniVars.lightSpecularCol->setVec3(&light.lightProps->getSpecularColor());
+	pointLightSProgUniVars.lightPos->setVec3(&lightPosEyeSpace);
+	pointLightSProgUniVars.lightInvRadius->setFloat(1.0/light.radius);
+	pointLightSProgUniVars.lightDiffuseCol->setVec3(&light.lightProps->getDiffuseColor());
+	pointLightSProgUniVars.lightSpecularCol->setVec3(&light.lightProps->getSpecularColor());
 
 
 	// render quad
@@ -254,31 +270,38 @@ void Renderer::Is::spotLightPass(const SpotLight& light)
 	light.lightProps->getTexture()->setRepeat(false);
 
 	// shader prog
-	const LightShaderProg* shdr; // because of the huge name
+	const ShaderProg* shdr; // because of the huge name
+	const UniVars* uniVars;
 
 	if(light.castsShadow && sm.enabled)
-		shdr = &spotLightShadowSProg;
+	{
+		shdr = spotLightShadowSProg;
+		uniVars = &spotLightShadowSProgUniVars;
+	}
 	else
-		shdr = &spotLightNoShadowSProg;
+	{
+		shdr = spotLightNoShadowSProg;
+		uniVars = &spotLightNoShadowSProgUniVars;
+	}
 
 	shdr->bind();
 
 	// bind the FAIs
-	shdr->uniVars.msNormalFai->setTexture(r.ms.normalFai, 0);
-	shdr->uniVars.msDiffuseFai->setTexture(r.ms.diffuseFai, 1);
-	shdr->uniVars.msSpecularFai->setTexture(r.ms.specularFai, 2);
-	shdr->uniVars.msDepthFai->setTexture(r.ms.depthFai, 3);
+	uniVars->msNormalFai->setTexture(r.ms.normalFai, 0);
+	uniVars->msDiffuseFai->setTexture(r.ms.diffuseFai, 1);
+	uniVars->msSpecularFai->setTexture(r.ms.specularFai, 2);
+	uniVars->msDepthFai->setTexture(r.ms.depthFai, 3);
 
 	// the planes
-	shdr->uniVars.planes->setVec2(&planes);
+	uniVars->planes->setVec2(&planes);
 
 	// the light params
 	Vec3 lightPosEyeSpace = light.getWorldTransform().getOrigin().getTransformed(cam.getViewMatrix());
-	shdr->uniVars.lightPos->setVec3(&lightPosEyeSpace);
-	shdr->uniVars.lightInvRadius->setFloat(1.0/light.getDistance());
-	shdr->uniVars.lightDiffuseCol->setVec3(&light.lightProps->getDiffuseColor());
-	shdr->uniVars.lightSpecularCol->setVec3(&light.lightProps->getSpecularColor());
-	shdr->uniVars.lightTex->setTexture(*light.lightProps->getTexture(), 4);
+	uniVars->lightPos->setVec3(&lightPosEyeSpace);
+	uniVars->lightInvRadius->setFloat(1.0/light.getDistance());
+	uniVars->lightDiffuseCol->setVec3(&light.lightProps->getDiffuseColor());
+	uniVars->lightSpecularCol->setVec3(&light.lightProps->getSpecularColor());
+	uniVars->lightTex->setTexture(*light.lightProps->getTexture(), 4);
 
 	// set texture matrix for texture & shadowmap projection
 	// Bias * P_light * V_light * inv(V_cam)
@@ -286,12 +309,12 @@ void Renderer::Is::spotLightPass(const SpotLight& light)
 	Mat4 texProjectionMat;
 	texProjectionMat = biasMat4 * light.camera.getProjectionMatrix() *
 	                   Mat4::combineTransformations(light.camera.getViewMatrix(), Mat4(cam.getWorldTransform()));
-	shdr->uniVars.texProjectionMat->setMat4(&texProjectionMat);
+	uniVars->texProjectionMat->setMat4(&texProjectionMat);
 
 	// the shadowmap
 	if(light.castsShadow && sm.enabled)
 	{
-		shdr->uniVars.shadowMap->setTexture(sm.shadowMap, 5);
+		uniVars->shadowMap->setTexture(sm.shadowMap, 5);
 	}
 
 	// render quad

src/Renderer/Renderer.h

@@ -129,23 +129,14 @@ class Renderer
 					friend class Is;
 					friend class Renderer;
 
-					private:
-						class SmoShaderProg: public ShaderProg
-						{
-							public:
-								struct
-								{
-									const ShaderProg::UniVar* modelViewProjectionMat;
-								} uniVars;
-						};
-
 					public:
 						Smo(Renderer& r_): RenderingStage(r_) {}
 
 					private:
 						static float sMOUvSCoords[]; ///< Illumination stage stencil masking optimizations UV sphere vertex positions
 						static Vbo sMOUvSVbo; ///< Illumination stage stencil masking optimizations UV sphere VBO
-						static SmoShaderProg sProg;
+						ShaderProg* sProg;
+						const ShaderProg::UniVar* modelViewProjectionMatUniVar;
 
 						void init();
 						void run(const PointLight& light);
@@ -153,36 +144,21 @@ class Renderer
 				}; // end Smo
 
 			private:
-				/// Illumination stage ambient pass shader program
-				class AmbientShaderProg: public ShaderProg
+				/// Illumination stage light pass uniform variables (opt)
+				struct UniVars
 				{
-					public:
-						struct
-						{
-							const ShaderProg::UniVar* ambientCol;
-							const ShaderProg::UniVar* sceneColMap;
-						} uniVars;
-				};
-
-				/// Illumination stage light pass shader program
-				class LightShaderProg: public ShaderProg
-				{
-					public:
-						struct
-						{
-							const ShaderProg::UniVar* msNormalFai;
-							const ShaderProg::UniVar* msDiffuseFai;
-							const ShaderProg::UniVar* msSpecularFai;
-							const ShaderProg::UniVar* msDepthFai;
-							const ShaderProg::UniVar* planes;
-							const ShaderProg::UniVar* lightPos;
-							const ShaderProg::UniVar* lightInvRadius;
-							const ShaderProg::UniVar* lightDiffuseCol;
-							const ShaderProg::UniVar* lightSpecularCol;
-							const ShaderProg::UniVar* lightTex;
-							const ShaderProg::UniVar* texProjectionMat;
-							const ShaderProg::UniVar* shadowMap;
-						} uniVars;
+					const ShaderProg::UniVar* msNormalFai;
+					const ShaderProg::UniVar* msDiffuseFai;
+					const ShaderProg::UniVar* msSpecularFai;
+					const ShaderProg::UniVar* msDepthFai;
+					const ShaderProg::UniVar* planes;
+					const ShaderProg::UniVar* lightPos;
+					const ShaderProg::UniVar* lightInvRadius;
+					const ShaderProg::UniVar* lightDiffuseCol;
+					const ShaderProg::UniVar* lightSpecularCol;
+					const ShaderProg::UniVar* lightTex;
+					const ShaderProg::UniVar* texProjectionMat;
+					const ShaderProg::UniVar* shadowMap;
 				};
 
 			public:
@@ -195,10 +171,15 @@ class Renderer
 				Texture fai;
 				Fbo fbo; ///< This FBO writes to the Is::fai
 				uint stencilRb; ///< Illumination stage stencil buffer
-				AmbientShaderProg ambientPassSProg; ///< Illumination stage ambient pass shader program
-				LightShaderProg pointLightSProg; ///< Illumination stage point light shader program
-				LightShaderProg spotLightNoShadowSProg; ///< Illumination stage spot light w/o shadow shader program
-				LightShaderProg spotLightShadowSProg; ///< Illumination stage spot light w/ shadow shader program
+				ShaderProg* ambientPassSProg; ///< Illumination stage ambient pass shader program
+				ShaderProg* pointLightSProg; ///< Illumination stage point light shader program
+				ShaderProg* spotLightNoShadowSProg; ///< Illumination stage spot light w/o shadow shader program
+				ShaderProg* spotLightShadowSProg; ///< Illumination stage spot light w/ shadow shader program
+				const ShaderProg::UniVar* ambientColUniVar;
+				const ShaderProg::UniVar* sceneColMapUniVar;
+				UniVars pointLightSProgUniVars;
+				UniVars spotLightNoShadowSProgUniVars;
+				UniVars spotLightShadowSProgUniVars;
 				Vec3 viewVectors[4];
 				Vec2 planes;
 

src/Resources/ShaderProg.cpp

@@ -380,29 +380,31 @@ bool ShaderProg::attribVarExists(const char* name) const
 
 
 //======================================================================================================================
-// writeSrcCodeToCache                                                                                                 =
+// createSrcCodeToCache                                                                                                =
 //======================================================================================================================
-bool ShaderProg::writeSrcCodeToCache(const char* filename, const char* extraSource, const char* newFName)
+string ShaderProg::createSrcCodeToCache(const char* sProgFPathName, const char* preAppendedSrcCode,
+                                        const char* newFNamePrefix)
 {
-	filesystem::path fName_ = app->getCachePath() / newFName;
+	filesystem::path newfPathName = app->getCachePath() /
+	                                (string(newFNamePrefix) + "_" + filesystem::path(sProgFPathName).filename());
 
-	if(filesystem::exists(fName_))
+	if(filesystem::exists(newfPathName))
 	{
-		return true;
+		return newfPathName.string();
 	}
 
-	string src_ = Util::readFile(filename);
+	string src_ = Util::readFile(sProgFPathName);
 	DEBUG_ERR(src_ == "");
-	string src = extraSource + src_;
+	string src = preAppendedSrcCode + src_;
 
-	ofstream f(fName_.file_string().c_str());
+	ofstream f(newfPathName.string().c_str());
 	if(!f.good())
 	{
-		ERROR("Cannot open file for writing \"" << fName_.file_string() << "\"");
-		return false;
+		ERROR("Cannot open file for writing \"" << newfPathName.string() << "\"");
+		return newfPathName.string();
 	}
 
 	f.write(src.c_str(), src.length());
 
-	return false;
+	return newfPathName.string();
 }

src/Resources/ShaderProg.h

@@ -153,7 +153,15 @@ class ShaderProg: public Resource
 		bool uniVarExists(const char* varName) const;
 		bool attribVarExists(const char* varName) const;
 
-		static bool writeSrcCodeToCache(const char* filename, const char* extraSource, const char* newFName);
+		/**
+		 * @todo
+		 * @param sProgFPathName The file pathname of the shader prog
+		 * @param preAppendedSrcCode The source code we want to write on top of the shader prog
+		 * @param newFNamePrefix The prefix of the new shader prog
+		 * @return The file pathname of the new shader prog. Its $HOME/.anki/cache/newFNamePrefix_fName
+		 */
+		static string createSrcCodeToCache(const char* sProgFPathName, const char* preAppendedSrcCode,
+		                                   const char* newFNamePrefix);
 
 	//====================================================================================================================
 	// Private                                                                                                           =

src/Util/Tokenizer/Scanner.h

@@ -1,5 +1,5 @@
-#ifndef _SCANNER_H_
-#define _SCANNER_H_
+#ifndef SCANNER_H
+#define SCANNER_H
 
 #include <sstream>
 #include <fstream>
@@ -40,7 +40,7 @@ class Scanner
 			TC_KEYWOR,
 			TC_KEYWORD,
 
-			// operators
+			// operators (in 5s)
 			TC_SCOPERESOLUTION, TC_LSQBRACKET, TC_RSQBRACKET, TC_LPAREN, TC_RPAREN,
 			TC_DOT, TC_POINTERTOMEMBER, TC_LBRACKET, TC_RBRACKET, TC_COMMA,
 			TC_PERIOD, TC_UPDOWNDOT, TC_QUESTIONMARK, TC_SHARP, TC_EQUAL,