Fixing bugs

shaders/is_lp_generic.glsl

@@ -216,7 +216,7 @@ vec3 Phong( in vec3 _frag_pos_vspace, out float _frag_light_dist )
 	return _color;
 }
 
-
+uniform sampler2D tex;
 
 /*
 =======================================================================================================================================
@@ -224,7 +224,7 @@ main
 =======================================================================================================================================
 */
 void main()
-{
+{
 	// get frag pos in view space
 	vec3 _frag_pos_vspace = FragPosVSpace();
 

shaders/simple_texturing.glsl

@@ -18,7 +18,7 @@ void main()
 
 #pragma anki include "shaders/pack.glsl"
 
-uniform sampler2D diffuseMap, noise_map;
+uniform sampler2D isFai, noise_map;
 //varying vec2 texCoords_v2f;
 varying vec3 normal_v2f;
 uniform vec2 rendererSize;
@@ -29,8 +29,8 @@ void main()
 	_noise = _noise * 2 - 1;
 	_noise *= 7.0;*/
 
-	vec4 _texel = texture2D( diffuseMap, (gl_FragCoord.xy+(normal_v2f.z*50))*vec2( 1.0/rendererSize.x, 1.0/rendererSize.y ) ) * 0.75;
-	//vec4 _texel = texture2D( diffuseMap, gl_FragCoord.xy*vec2( 1.0/R_W, 1.0/R_H ) );
+	vec4 _texel = texture2D( isFai, (gl_FragCoord.xy+(normal_v2f.z*50))*vec2( 1.0/rendererSize.x, 1.0/rendererSize.y ) ) * 0.75;
+	//vec4 _texel = texture2D( isFai, gl_FragCoord.xy*vec2( 1.0/R_W, 1.0/R_H ) );
 
 	gl_FragData[0] = _texel;
 

src/Main.cpp

@@ -203,8 +203,8 @@ void init()
 	uint ticks = app->getTicks();
 
 	RendererInitializer initializer;
-	initializer.width = 1280;
-	initializer.height = 800;
+	initializer.width = app->getWindowWidth();
+	initializer.height = app->getWindowHeight();
 	initializer.ms.earlyZ.enabled = false;
 	initializer.dbg.enabled = true;
 	initializer.is.sm.bilinearEnabled = true;
@@ -231,7 +231,7 @@ void init()
 	point_lights[0] = new PointLight();
 	point_lights[0]->init( "maps/temple/light0.light" );
 	point_lights[0]->setLocalTransform( Transform( Vec3( -1.0, 2.4, 1.0 ), Mat3::getIdentity(), 1.0 ) );
-	point_lights[1] = new PointLight();
+	/*point_lights[1] = new PointLight();
 	point_lights[1]->init( "maps/temple/light1.light" );
 	point_lights[1]->setLocalTransform( Transform( Vec3( 2.5, 1.4, 1.0 ), Mat3::getIdentity(), 1.0 ) );
 
@@ -240,7 +240,7 @@ void init()
 	spot_lights[0]->setLocalTransform( Transform( Vec3( 1.3, 4.3, 3.0 ), Mat3( Euler(toRad(-20), toRad(20), 0.0) ), 1.0 ) );
 	spot_lights[1] = new SpotLight();
 	spot_lights[1]->init( "maps/temple/light3.light" );
-	spot_lights[1]->setLocalTransform( Transform( Vec3( -2.3, 6.3, 2.9 ), Mat3( Euler(toRad(-70), toRad(-20), 0.0) ), 1.0 ) );
+	spot_lights[1]->setLocalTransform( Transform( Vec3( -2.3, 6.3, 2.9 ), Mat3( Euler(toRad(-70), toRad(-20), 0.0) ), 1.0 ) );*/
 
 	// horse
 	horse = new MeshNode();
@@ -297,8 +297,6 @@ void init()
 //=====================================================================================================================================
 int main( int argc, char* argv[] )
 {
-	App::printAppInfo();
-
 	app = new App( argc, argv );
 	init();
 

src/Renderer/EarlyZ.cpp

@@ -9,6 +9,8 @@
 //=====================================================================================================================================
 void Renderer::Ms::EarlyZ::init()
 {
+	DEBUG_ERR( !enabled );
+
 	//
 	// init FBO
 	//
@@ -31,6 +33,8 @@ void Renderer::Ms::EarlyZ::init()
 //=====================================================================================================================================
 void Renderer::Ms::EarlyZ::run()
 {
+	DEBUG_ERR( !enabled );
+
 	fbo.bind();
 
 	Renderer::setViewport( 0, 0, r.width, r.height );
@@ -47,7 +51,7 @@ void Renderer::Ms::EarlyZ::run()
 		DEBUG_ERR( meshNode->material->dpMtl == NULL );
 
 		r.setupMaterial( *meshNode->material->dpMtl, *meshNode, *r.cam );
-		meshNode->render();
+		meshNode->renderDepth();
 	}
 
 	glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );

src/Renderer/Is.cpp

@@ -34,6 +34,7 @@ void Renderer::Is::renderSMOUvS( const PointLight& light )
 	const float scale = 1.2;
 
 	/// @todo Replace the rendering code. Use shader prog
+	Renderer::noShaders();
 
 	r.multMatrix( Mat4( light.getWorldTransform().getOrigin(), Mat3::getIdentity(), light.radius*scale ) );
 	Renderer::noShaders();
@@ -58,16 +59,18 @@ void Renderer::Is::calcViewVector()
 
 	int w = r.width;
 	int h = r.height;
-	int pixels[4][2]={ {w,h}, {0,h}, { 0,0 }, {w,0} }; // from righ up and CC wise to right down, Just like we render the quad
+	int pixels[4][2]={ {w,h}, {0,h}, {0,0}, {w,0} }; // from right up and CC wise to right down, Just like we render the quad
 	int viewport[4]={ 0, 0, w, h };
 
 	for( int i=0; i<4; i++ )
 	{
-		/* Original Code:
-		R::UnProject( pixels[i][0], pixels[i][1], 10, cam.getViewMatrix(), cam.getProjectionMatrix(), viewport,
-		              view_vectors[i].x, view_vectors[i].y, view_vectors[i].z );
-		view_vectors[i] = cam.getViewMatrix() * view_vectors[i];
-		The original code is the above 3 lines. The optimized follows:*/
+		/*
+		 * Original Code:
+		 * Renderer::unProject( pixels[i][0], pixels[i][1], 10, cam.getViewMatrix(), cam.getProjectionMatrix(), viewport,
+		 *                      viewVectors[i].x, viewVectors[i].y, viewVectors[i].z );
+		 * viewVectors[i] = cam.getViewMatrix() * viewVectors[i];
+		 * The original code is the above 3 lines. The optimized follows:
+		 */
 
 		Vec3 vec;
 		vec.x = (2.0*(pixels[i][0]-viewport[0]))/viewport[2] - 1.0;
@@ -324,7 +327,7 @@ void Renderer::Is::pointLightPass( const PointLight& light )
 	if( !cam.insideFrustum( sphere ) ) return;
 
 	// stencil optimization
-	setStencilMask( light );
+	//setStencilMask( light );
 
 	// bind the shader
 	const LightShaderProg& shader = pointLightSProg; // I dont want to type
@@ -343,6 +346,7 @@ void Renderer::Is::pointLightPass( const PointLight& light )
 	shader.uniVars.lightDiffuseCol->setVec3( &light.lightProps->getDiffuseColor() );
 	shader.uniVars.lightSpecularCol->setVec3( &light.lightProps->getSpecularColor() );
 
+
 	// render quad
 	glEnableVertexAttribArray( 0 );
 	glEnableVertexAttribArray( 1 );
@@ -506,6 +510,18 @@ void Renderer::Is::run()
 			{
 				const PointLight& pointl = static_cast<const PointLight&>(light);
 				pointLightPass( pointl );
+
+
+				/*pointLightSProg.bind();
+				pointLightSProg.findUniVar( "msNormalFai" )->setTexture( r.ms.diffuseFai, 1 );
+				glEnableVertexAttribArray( 0 );
+				glEnableVertexAttribArray( 1 );
+				glVertexAttribPointer( 0, 2, GL_FLOAT, false, 0, &Renderer::quadVertCoords[0] );
+				glVertexAttribPointer( 1, 3, GL_FLOAT, false, 0, &viewVectors[0] );
+				glDrawArrays( GL_QUADS, 0, 4 );
+				glDisableVertexAttribArray( 0 );
+				glDisableVertexAttribArray( 1 );*/
+
 				break;
 			}
 

src/Renderer/MainRenderer.cpp

@@ -76,7 +76,7 @@ void MainRenderer::init( const RendererInitializer& initializer_ )
 
 
 //=====================================================================================================================================
-//                                                                                                                                    =
+// render                                                                                                                             =
 //=====================================================================================================================================
 void MainRenderer::render( Camera& cam_ )
 {
@@ -89,7 +89,7 @@ void MainRenderer::render( Camera& cam_ )
 	glDisable( GL_DEPTH_TEST );
 	glDisable( GL_BLEND );
 	sProg.bind();
-	sProg.locTexUnit( sProg.findUniVar("rasterImage")->getLoc(), pps.fai, 0 );
+	sProg.findUniVar("rasterImage")->setTexture( is.fai, 0 );
 	drawQuad( 0 );
 }
 

src/Renderer/Ms.cpp

@@ -43,9 +43,8 @@ void Renderer::Ms::init()
 	// unbind
 	fbo.unbind();
 
-#if defined( _EARLY_Z_ )
-	r.Ms::earlyz::init();
-#endif
+	if( earlyZ.enabled )
+		earlyZ.init();
 }
 
 
@@ -75,7 +74,7 @@ void Renderer::Ms::run()
 	app->getScene()->skybox.Render( cam.getViewMatrix().getRotationPart() );
 	//glDepthFunc( GL_LEQUAL );
 
-	// if earlyZ then change the default depth test and disable depth writting
+	// if earlyZ then change the default depth test and disable depth writing
 	if( earlyZ.enabled )
 	{
 		glDepthMask( false );
@@ -83,9 +82,9 @@ void Renderer::Ms::run()
 	}
 
 	// render the meshes
-	for( uint i=0; i<app->getScene()->meshNodes.size(); i++ )
+	for( Vec<MeshNode*>::iterator it=app->getScene()->meshNodes.begin(); it!=app->getScene()->meshNodes.end(); it++ )
 	{
-		MeshNode* meshNode = app->getScene()->meshNodes[i];
+		MeshNode* meshNode = (*it);
 		DEBUG_ERR( meshNode->material == NULL );
 		if( meshNode->material->blends || meshNode->material->refracts ) continue;
 

src/Renderer/Renderer.cpp

@@ -68,8 +68,8 @@ void Renderer::render( Camera& cam_ )
 
 	ms.run();
 	is.run();
-	pps.run();
-	dbg.run();
+	/*pps.run();
+	dbg.run();*/
 
 	++framesNum;
 }

src/Renderer/Sm.cpp

@@ -78,15 +78,15 @@ void Renderer::Is::Sm::run( const Camera& cam )
 	glEnable( GL_POLYGON_OFFSET_FILL );
 
 	// render all meshes
-	for( uint i=0; i<app->getScene()->meshNodes.size(); i++ )
+	for( Vec<MeshNode*>::iterator it=app->getScene()->meshNodes.begin(); it!=app->getScene()->meshNodes.end(); it++ )
 	{
-		MeshNode* meshNode = app->getScene()->meshNodes[i];
+		MeshNode* meshNode = (*it);
 		if( meshNode->material->blends || meshNode->material->refracts ) continue;
 
 		DEBUG_ERR( meshNode->material->dpMtl == NULL );
 
 		r.setupMaterial( *meshNode->material->dpMtl, *meshNode, cam );
-		meshNode->render();
+		meshNode->renderDepth();
 	}
 
 	glDisable( GL_POLYGON_OFFSET_FILL );

src/Resources/Material.cpp

@@ -37,12 +37,12 @@ Material::StdVarInfo Material::stdUniVarInfos[ SUV_NUM ] =
 	{ "modelViewMat", GL_FLOAT_MAT4 },
 	{ "normalMat", GL_FLOAT_MAT3 },
 	{ "modelViewProjectionMat", GL_FLOAT_MAT4 },
-	{ "msNormalFai", GL_TEXTURE_2D },
-	{ "msDiffuseFai", GL_TEXTURE_2D },
-	{ "msSpecularFai", GL_TEXTURE_2D },
-	{ "msDepthFai", GL_TEXTURE_2D },
-	{ "isFai", GL_TEXTURE_2D },
-	{ "ppsFai", GL_TEXTURE_2D },
+	{ "msNormalFai", GL_SAMPLER_2D },
+	{ "msDiffuseFai", GL_SAMPLER_2D },
+	{ "msSpecularFai", GL_SAMPLER_2D },
+	{ "msDepthFai", GL_SAMPLER_2D },
+	{ "isFai", GL_SAMPLER_2D },
+	{ "ppsFai", GL_SAMPLER_2D },
 	{ "rendererSize", GL_FLOAT_VEC2 }
 };
 

src/Resources/ShaderProg.cpp

@@ -20,7 +20,8 @@ string ShaderProg::stdSourceCode(
 /**
  * Standard set uniform check
  */
-#define STD_SET_UNI_CHECK() DEBUG_ERR( getLoc() == -1 || ShaderProg::getCurrentProgramGlId() != fatherSProg->getGlId() );
+#define STD_SET_UNI_CHECK() DEBUG_ERR( getLoc() == -1 ); \
+                            DEBUG_ERR( ShaderProg::getCurrentProgramGlId() != fatherSProg->getGlId() );
 
 
 void ShaderProg::UniVar::setFloat( float f ) const
@@ -75,7 +76,7 @@ void ShaderProg::UniVar::setMat4( const Mat4 m4[], uint size ) const
 void ShaderProg::UniVar::setTexture( const Texture& tex, uint texUnit ) const
 {
 	STD_SET_UNI_CHECK();
-	DEBUG_ERR( getGlDataType() != GL_TEXTURE_2D );
+	DEBUG_ERR( getGlDataType() != GL_SAMPLER_2D && getGlDataType() != GL_SAMPLER_2D_SHADOW );
 	tex.bind( texUnit );
 	glUniform1i( getLoc(), texUnit );
 }
@@ -355,12 +356,12 @@ bool ShaderProg::attribVarExists( const char* name ) const
 //=====================================================================================================================================
 // locTexUnit                                                                                                                         =
 //=====================================================================================================================================
-void ShaderProg::locTexUnit( int loc, const Texture& tex, uint tex_unit ) const
+void ShaderProg::locTexUnit( int loc, const Texture& tex, uint texUnit ) const
 {
 	DEBUG_ERR( loc == -1 );
 	DEBUG_ERR( getCurrentProgramGlId() != glId );
-	tex.bind( tex_unit );
-	glUniform1i( loc, tex_unit );
+	tex.bind( texUnit );
+	glUniform1i( loc, texUnit );
 }
 
 void ShaderProg::locTexUnit( const char* loc, const Texture& tex, uint tex_unit ) const

src/Resources/Texture.cpp

@@ -8,8 +8,8 @@
 //=====================================================================================================================================
 int Texture::textureUnitsNum = -1;
 bool Texture::mipmappingEnabled = true;
-bool Texture::compressionEnabled = true;
-int Texture::anisotropyLevel = 16;
+bool Texture::compressionEnabled = false;
+int Texture::anisotropyLevel = 8;
 
 
 //=====================================================================================================================================

src/Scene/MeshNode.cpp

@@ -19,9 +19,11 @@ void MeshNode::init( const char* filename )
 	material = Rsrc::materials.load( mesh->materialName.c_str() );
 
 	// sanity checks
-	if( material->stdAttribVars[Material::SAV_TEX_COORDS]==NULL && mesh->vbos.texCoords.getGlId() == 0 )
+	if( material->stdAttribVars[Material::SAV_TEX_COORDS]!=NULL && mesh->vbos.texCoords.getGlId()==0 )
 	{
-		ERROR( "The shader program needs information that the mesh do not have" );
+		ERROR( "The shader program (\"" << material->shaderProg->getRsrcName() <<
+		       "\") needs texture coord information that the mesh (\"" <<
+		       mesh->getRsrcName() << "\") doesn't have" );
 	}
 }
 

src/Util/App.cpp

@@ -7,11 +7,40 @@
 
 bool App::isCreated = false;
 
+//=====================================================================================================================================
+// parseCommandLineArgs                                                                                                               =
+//=====================================================================================================================================
+void App::parseCommandLineArgs( int argc, char* argv[] )
+{
+	for( int i=1; i<argc; i++ )
+	{
+		char* arg = argv[ i ];
+		if( strcmp( arg, "--terminal-coloring" ) == 0 )
+		{
+			terminalColoringEnabled = true;
+		}
+		else if( strcmp( arg, "--no-terminal-coloring" ) == 0 )
+		{
+			terminalColoringEnabled = false;
+		}
+		else
+		{
+			FATAL( "Incorrect command line argument \"" << arg << "\"" );
+		}
+	}
+
+}
+
+
 //=====================================================================================================================================
 // Constructor                                                                                                                        =
 //=====================================================================================================================================
-App::App( int /*argc*/, char* /*argv*/[] )
+App::App( int argc, char* argv[] )
 {
+	parseCommandLineArgs( argc, argv );
+
+	printAppInfo();
+
 	if( isCreated )
 		FATAL( "You cannot create a second App instance" )
 
@@ -28,7 +57,7 @@ App::App( int /*argc*/, char* /*argv*/[] )
 
 	fullScreenFlag = false;
 
-	terminalColoringEnabled = true;
+	terminalColoringEnabled = false;
 
 	timerTick = 1000/40; // in ms. 1000/Hz
 	time = 0;

src/Util/App.h

@@ -27,6 +27,8 @@ class App
 		SDL_Surface* iconImage;
 		bool fullScreenFlag;
 
+		void parseCommandLineArgs( int argc, char* argv[] );
+
 	public:
 		uint timerTick;