- Commit before the renderer's switch

src/Renderer2/Hdr.cpp

@@ -54,15 +54,15 @@ void Renderer::Pps::Hdr::init()
 
 	if( !pass0SProg.customLoad( shaderFname, ("#define _PPS_HDR_PASS_0_\n#define IS_FAI_WIDTH " + Util::floatToStr(r.width) + "\n").c_str() ) )
 		FATAL( "See prev error" );
-	uniLocs.pass0SProg.fai = pass0SProg.findUniVar("fai")->getLoc();
+	pass0SProg.uniVars.fai = pass0SProg.findUniVar("fai");
 
 	if( !pass1SProg.customLoad( shaderFname, ("#define _PPS_HDR_PASS_1_\n#define PASS0_HEIGHT " + Util::floatToStr(height) + "\n").c_str() ) )
 		FATAL( "See prev error" );
-	uniLocs.pass1SProg.fai = pass1SProg.findUniVar("fai")->getLoc();
+	pass1SProg.uniVars.fai = pass1SProg.findUniVar("fai");
 
 	if( !pass2SProg.customLoad( shaderFname, "#define _PPS_HDR_PASS_2_\n" ) )
 		FATAL( "See prev error" );
-	uniLocs.pass2SProg.fai = pass2SProg.findUniVar("fai")->getLoc();
+	pass2SProg.uniVars.fai = pass2SProg.findUniVar("fai");
 }
 
 
@@ -82,21 +82,21 @@ void Renderer::Pps::Hdr::run()
 	// pass 0
 	pass0Fbo.bind();
 	pass0SProg.bind();
-	pass0SProg.locTexUnit( uniLocs.pass0SProg.fai, r.is.fai, 0 );
+	pass0SProg.uniVars.fai->setTexture( r.is.fai, 0 );
 	r.drawQuad( 0 );
 
 
 	// pass 1
 	pass1Fbo.bind();
 	pass1SProg.bind();
-	pass1SProg.locTexUnit( uniLocs.pass1SProg.fai, pass0Fai, 0 );
+	pass1SProg.uniVars.fai->setTexture( pass0Fai, 0 );
 	r.drawQuad( 0 );
 
 
 	// pass 2
 	pass2Fbo.bind();
 	pass2SProg.bind();
-	pass2SProg.locTexUnit( uniLocs.pass2SProg.fai, pass1Fai, 0 );
+	pass2SProg.uniVars.fai->setTexture( pass1Fai, 0 );
 	r.drawQuad( 0 );
 
 	// end

src/Renderer2/MainRenderer.cpp

@@ -37,6 +37,10 @@ void MainRenderer::init( const RendererInitializer& initializer )
 	if( !glewIsSupported("GL_ARB_vertex_buffer_object") )
 		WARNING( "Vertex Buffer Objects not supported. The application may crash (and burn)" );
 
+
+	// get max texture units
+	glGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &Texture::textureUnitsNum );
+
 	//
 	// Set default OpenGL
 	//

src/Renderer2/Pps.cpp

@@ -30,25 +30,25 @@ void Renderer::Pps::init()
 	sProg.customLoad( "shaders/Pps.glsl" );
 	sProg.bind();
 
-	sProg.uniLocs.isFai = sProg.findUniVar( "isFai" )->getLoc();
+	sProg.uniVars.isFai = sProg.findUniVar( "isFai" );
 
 	if( ssao.enabled )
 	{
 		ssao.init();
-		sProg.uniLocs.ppsSsaoFai = sProg.findUniVar( "ppsSsaoFai" )->getLoc();
+		sProg.uniVars.ppsSsaoFai = sProg.findUniVar( "ppsSsaoFai" );
 	}
 
 	if( hdr.enabled )
 	{
 		hdr.init();
-		sProg.uniLocs.hdrFai = sProg.findUniVar( "ppsHdrFai" )->getLoc();
+		sProg.uniVars.hdrFai = sProg.findUniVar( "ppsHdrFai" );
 	}
 
 	/// @ todo enable lscatt
 	/*if( R::Pps::Lscatt::enabled )
 	{
 		R::Pps::Lscatt::init();
-		sProg.uniLocs.lscattFai = sProg.findUniVar( "ppsLscattFai" )->getLoc();
+		sProg.uniVars.lscattFai = sProg.findUniVar( "ppsLscattFai" )->getLoc();
 	}*/
 
 }
@@ -75,17 +75,16 @@ void Renderer::Pps::run()
 
 	// set shader
 	sProg.bind();
-
-	sProg.locTexUnit( sProg.uniLocs.isFai, r.is.fai, 0 ); // the IS FAI
+	sProg.uniVars.isFai->setTexture( r.is.fai, 0 );
 
 	if( hdr.enabled )
 	{
-		sProg.locTexUnit( sProg.uniLocs.hdrFai, hdr.fai, 1 );
+		sProg.uniVars.hdrFai->setTexture( hdr.fai, 1 );
 	}
 
 	if( ssao.enabled )
 	{
-		sProg.locTexUnit( sProg.uniLocs.ppsSsaoFai, ssao.fai, 2 );
+		sProg.uniVars.ppsSsaoFai->setTexture( ssao.fai, 2 );
 	}
 
 	// draw quad

src/Renderer2/Renderer.hpp

@@ -30,13 +30,12 @@ class Renderer
 		class RenderingStage
 		{
 			protected:
-				Renderer& r;
+				Renderer& r; ///< Just so that the stage can know the father class
 
 			public:
 				RenderingStage( Renderer& r_ ): r(r_) {}
 		};
 
-
 		/**
 		 * Material stage
 		 */
@@ -97,9 +96,6 @@ class Renderer
 				}; // end Sm
 
 			private:
-				Fbo fbo;
-				uint stencilRb; ///< Illumination stage stencil buffer
-				// shader stuff
 				/// Illumination stage ambient pass shader program
 				class AmbientShaderProg: public ShaderProg
 				{
@@ -110,6 +106,7 @@ class Renderer
 							const ShaderProg::UniVar* sceneColMap;
 						} uniVars;
 				};
+
 				/// Illumination stage light pass shader program
 				class LightShaderProg: public ShaderProg
 				{
@@ -130,11 +127,13 @@ class Renderer
 							const ShaderProg::UniVar* shadowMap;
 						} uniVars;
 				};
+
+				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
-				// other
 				Vec3 viewVectors[4];
 				Vec2 planes;
 				static float sMOUvSCoords []; ///< Illumination stage stencil masking optimizations UV sphere vertex coords
@@ -186,22 +185,15 @@ class Renderer
 
 					private:
 						Fbo pass0Fbo, pass1Fbo, pass2Fbo;
-						ShaderProg pass0SProg, pass1SProg, pass2SProg;
-						struct
+						class HdrShaderProg: public ShaderProg
 						{
-							struct
-							{
-								int fai;
-							} pass0SProg;
-							struct
-							{
-								int fai;
-							} pass1SProg;
-							struct
-							{
-								int fai;
-							} pass2SProg;
-						} uniLocs;
+							public:
+								struct
+								{
+									const ShaderProg::UniVar* fai;
+								} uniVars;
+						};
+						HdrShaderProg pass0SProg, pass1SProg, pass2SProg;
 
 						void initFbos( Fbo& fbo, Texture& fai, int internalFormat );
 						void init();
@@ -236,21 +228,29 @@ class Renderer
 						Fbo pass0Fbo, pass1Fbo, pass2Fbo;
 						uint width, height, bwidth, bheight;
 						Texture* noiseMap;
-						struct
+
+						class SsaoShaderProg: public ShaderProg
 						{
-							struct
-							{
-								int camerarange, msDepthFai, noiseMap, msNormalFai;
-							} pass0SProg;
-							struct
-							{
-								int fai;
-							} pass1SProg;
-							struct
-							{
-								int fai;
-							} pass2SProg;
-						} uniLocs;
+							public:
+								struct
+								{
+									const ShaderProg::UniVar* camerarange;
+									const ShaderProg::UniVar* msDepthFai;
+									const ShaderProg::UniVar* noiseMap;
+									const ShaderProg::UniVar* msNormalFai;
+								} uniVars;
+						};
+						SsaoShaderProg ssaoSProg;
+
+						class BlurSProg: public ShaderProg
+						{
+							public:
+								struct
+								{
+									const ShaderProg::UniVar* fai;
+								} uniVars;
+						};
+						BlurSProg blurSProg, blurSProg2;
 
 						void initBlurFbo( Fbo& fbo, Texture& fai );
 						void init();
@@ -258,7 +258,6 @@ class Renderer
 
 					public:
 						Texture pass0Fai, pass1Fai, fai /** The final FAI */;
-						ShaderProg ssaoSProg, blurSProg, blurSProg2;
 
 						Ssao( Renderer& r_ ): RenderingStage(r_) {}
 				}; // end Ssao
@@ -269,8 +268,13 @@ class Renderer
 						public:
 							struct
 							{
-								int isFai, ppsSsaoFai, msNormalFai, hdrFai, lscattFai;
-							} uniLocs;
+								const ShaderProg::UniVar* isFai;
+								const ShaderProg::UniVar* ppsSsaoFai;
+								const ShaderProg::UniVar* msNormalFai;
+								const ShaderProg::UniVar* hdrFai;
+								const ShaderProg::UniVar* lscattFai;
+
+							} uniVars;
 					};
 					PpsShaderProg sProg;
 					Fbo fbo;
@@ -396,7 +400,7 @@ class Renderer
 
 		static void setProjectionMatrix( const Camera& cam );
 		static void setViewMatrix( const Camera& cam );
-		static void noShaders() { ShaderProg::unbind(); } ///< unbind shaders @todo remove this. From now on the will be only shaders
+		static void noShaders() { ShaderProg::unbind(); } ///< unbind shaders @todo remove this. From now on there will be only shaders
 		static void setProjectionViewMatrices( const Camera& cam ) { setProjectionMatrix(cam); setViewMatrix(cam); }
 		static void setViewport( uint x, uint y, uint w, uint h ) { glViewport(x,y,w,h); }
 		static void multMatrix( const Mat4& m4 ) { glMultMatrixf( &(m4.getTransposed())(0,0) ); } ///< OpenGL wrapper

src/Renderer2/Ssao.cpp

@@ -80,12 +80,12 @@ void Renderer::Pps::Ssao::init()
 	blurSProg.customLoad( "shaders/PpsSsaoBlur.glsl", ("#define _PPS_SSAO_PASS_0_\n#define PASS0_FAI_WIDTH " + Util::floatToStr(width) + "\n").c_str() );
 	blurSProg2.customLoad( "shaders/PpsSsaoBlur.glsl", ("#define _PPS_SSAO_PASS_1_\n#define PASS1_FAI_HEIGHT " + Util::floatToStr(bheight) + "\n").c_str() );
 
-	uniLocs.pass0SProg.camerarange = ssaoSProg.findUniVar("camerarange")->getLoc();
-	uniLocs.pass0SProg.msDepthFai = ssaoSProg.findUniVar("msDepthFai")->getLoc();
-	uniLocs.pass0SProg.noiseMap = ssaoSProg.findUniVar("noiseMap")->getLoc();
-	uniLocs.pass0SProg.msNormalFai = ssaoSProg.findUniVar("msNormalFai")->getLoc();
-	uniLocs.pass1SProg.fai = blurSProg.findUniVar("tex")->getLoc(); /// @todo rename the tex in the shader
-	uniLocs.pass2SProg.fai = blurSProg2.findUniVar("tex")->getLoc(); /// @todo rename the tex in the shader
+	ssaoSProg.uniVars.camerarange = ssaoSProg.findUniVar("camerarange");
+	ssaoSProg.uniVars.msDepthFai = ssaoSProg.findUniVar("msDepthFai");
+	ssaoSProg.uniVars.noiseMap = ssaoSProg.findUniVar("noiseMap");
+	ssaoSProg.uniVars.msNormalFai = ssaoSProg.findUniVar("msNormalFai");
+	blurSProg.uniVars.fai = blurSProg.findUniVar("tex"); /// @todo rename the tex in the shader
+	blurSProg2.uniVars.fai = blurSProg2.findUniVar("tex"); /// @todo rename the tex in the shader
 
 
 	//
@@ -123,10 +123,11 @@ void Renderer::Pps::Ssao::run()
 	r.setViewport( 0, 0, width, height );
 	pass0Fbo.bind();
 	ssaoSProg.bind();
-	glUniform2fv( uniLocs.pass0SProg.camerarange, 1, &(Vec2(cam.getZNear(), cam.getZFar()))[0] );
-	ssaoSProg.locTexUnit( uniLocs.pass0SProg.msDepthFai, r.ms.depthFai, 0 );
-	ssaoSProg.locTexUnit( uniLocs.pass0SProg.noiseMap, *noiseMap, 1 );
-	ssaoSProg.locTexUnit( uniLocs.pass0SProg.msNormalFai, r.ms.normalFai, 2 );
+	Vec2 camRange( cam.getZNear(), cam.getZFar() );
+	ssaoSProg.uniVars.camerarange->setVec2( &camRange );
+	ssaoSProg.uniVars.msDepthFai->setTexture( r.ms.depthFai, 0 );
+	ssaoSProg.uniVars.noiseMap->setTexture( *noiseMap, 1 );
+	ssaoSProg.uniVars.msNormalFai->setTexture( r.ms.normalFai, 2 );
 	r.drawQuad( 0 );
 
 	// for 2nd and 3rd passes
@@ -135,13 +136,13 @@ void Renderer::Pps::Ssao::run()
 	// 2nd pass
 	pass1Fbo.bind();
 	blurSProg.bind();
-	blurSProg.locTexUnit( uniLocs.pass1SProg.fai, pass0Fai, 0 );
+	blurSProg.uniVars.fai->setTexture( pass0Fai, 0 );
 	r.drawQuad( 0 );
 
 	// 3rd pass
 	pass2Fbo.bind();
 	blurSProg2.bind();
-	blurSProg2.locTexUnit( uniLocs.pass2SProg.fai, pass1Fai, 0 );
+	blurSProg2.uniVars.fai->setTexture( pass1Fai, 0 );
 	r.drawQuad( 0 );
 
 	// end

src/Resources/ShaderProg.cpp

@@ -7,6 +7,12 @@
 #define SHADER_ERROR( x ) ERROR( "Shader (" << getRsrcName() << "): " << x )
 #define SHADER_WARNING( x ) WARNING( "Shader (" << getRsrcName() << "): " << x )
 
+string ShaderProg::stdSourceCode(
+	"#version 150 compatibility\n \
+	precision lowp float;\n \
+	#pragma optimize(on)\n \
+	#pragma debug(off)\n"
+);
 
 //=====================================================================================================================================
 // set uniforms                                                                                                                       =

src/Resources/ShaderProg.h

@@ -94,6 +94,7 @@ class ShaderProg: public Resource
 		};
 
 	private:
+		static string stdSourceCode;
 		Vec<UniVar> uniVars; ///< All the uniform variables
 		Vec<AttribVar> attribVars; ///< All the attribute variables
 		map<string,UniVar*> uniNameToVar;  ///< A map for quick variable searching

src/Resources/Texture.cpp

@@ -3,6 +3,21 @@
 #include "Image.h"
 
 
+int Texture::textureUnitsNum = -1;
+bool Texture::mipmappingEnabled = true;
+bool Texture::compressionEnabled = true;
+int Texture::anisotropyLevel = 16;
+
+
+//=====================================================================================================================================
+// Constructor                                                                                                                        =
+//=====================================================================================================================================
+Texture::Texture():
+	glId(numeric_limits<uint>::max()),
+	type(GL_TEXTURE_2D)
+{
+}
+
 //=====================================================================================================================================
 // load                                                                                                                               =
 //=====================================================================================================================================
@@ -22,8 +37,14 @@ bool Texture::load( const char* filename )
 	// bind the texture
 	glGenTextures( 1, &glId );
 	bind(0);
-	if( R::mipmapping ) glTexParameteri( type, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
-	else                glTexParameteri( type, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	if( R::mipmapping )
+	{
+		glTexParameteri( type, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
+	}
+	else
+	{
+		glTexParameteri( type, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	}
 
 	glTexParameteri( type, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
 
@@ -35,15 +56,22 @@ bool Texture::load( const char* filename )
 
 	int format = (img.bpp==32) ? GL_RGBA : GL_RGB;
 
-	int int_format; // the internal format of the image
+	int intFormat; // the internal format of the image
 	if( R::textureCompression )
+	{
 		//int_format = (img.bpp==32) ? GL_COMPRESSED_RGBA_S3TC_DXT1_EXT : GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
-		int_format = (img.bpp==32) ? GL_COMPRESSED_RGBA : GL_COMPRESSED_RGB;
+		intFormat = (img.bpp==32) ? GL_COMPRESSED_RGBA : GL_COMPRESSED_RGB;
+	}
 	else
-		int_format = (img.bpp==32) ? GL_RGBA : GL_RGB;
+	{
+		intFormat = (img.bpp==32) ? GL_RGBA : GL_RGB;
+	}
 
-	glTexImage2D( type, 0, int_format, img.width, img.height, 0, format, GL_UNSIGNED_BYTE, img.data );
-	if( R::mipmapping ) glGenerateMipmap(type);
+	glTexImage2D( type, 0, intFormat, img.width, img.height, 0, format, GL_UNSIGNED_BYTE, img.data );
+	if( R::mipmapping )
+	{
+		glGenerateMipmap(type);
+	}
 
 	img.unload();
 	return true;

src/Resources/Texture.h

@@ -15,16 +15,18 @@
  */
 class Texture: public Resource
 {
+	friend class MainRenderer;
+
 	protected:
 		uint   glId; ///< Identification for OGL
 		GLenum type; ///< GL_TEXTURE_2D, GL_TEXTURE_3D... etc
-		static int  textureUnitsNum;
+		static int  textureUnitsNum; ///< This needs to be filled after the main renderer initialization
 		static bool mipmappingEnabled;
 		static bool compressionEnabled;
 		static int  anisotropyLevel;
 
 	public:
-		 Texture(): glId(numeric_limits<uint>::max()), type(GL_TEXTURE_2D) {}
+		 Texture();
 		~Texture() {}
 
 		inline uint getGlId() const { DEBUG_ERR(glId==numeric_limits<uint>::max()); return glId; }