OpenGL 3.3 core profile

src/Physics/DebugDrawer.cpp

@@ -10,7 +10,7 @@
 //======================================================================================================================
 void DebugDrawer::drawLine(const btVector3& from, const btVector3& to, const btVector3& color)
 {
-	app->getMainRenderer().dbg.drawLine(toAnki(from), toAnki(to), Vec4(toAnki(color), 1.0));
+	app->getMainRenderer().getDbg().drawLine(toAnki(from), toAnki(to), Vec4(toAnki(color), 1.0));
 }
 
 
@@ -19,7 +19,7 @@ void DebugDrawer::drawLine(const btVector3& from, const btVector3& to, const btV
 //======================================================================================================================
 void DebugDrawer::drawSphere(btScalar radius, const btTransform& transform, const btVector3& color)
 {
-	app->getMainRenderer().dbg.drawSphere(radius, Transform(toAnki(transform)), Vec4(toAnki(color), 1.0));
+	app->getMainRenderer().getDbg().drawSphere(radius, Transform(toAnki(transform)), Vec4(toAnki(color), 1.0));
 }
 
 
@@ -35,9 +35,9 @@ void DebugDrawer::drawBox(const btVector3& min, const btVector3& max, const btVe
 	trf(0, 3) = (max.getX() + min.getX()) / 2.0;
 	trf(1, 3) = (max.getY() + min.getY()) / 2.0;
 	trf(2, 3) = (max.getZ() + min.getZ()) / 2.0;
-	app->getMainRenderer().dbg.setModelMat(trf);
-	app->getMainRenderer().dbg.setColor(Vec4(toAnki(color), 1.0));
-	app->getMainRenderer().dbg.drawCube(1.0);
+	app->getMainRenderer().getDbg().setModelMat(trf);
+	app->getMainRenderer().getDbg().setColor(Vec4(toAnki(color), 1.0));
+	app->getMainRenderer().getDbg().drawCube(1.0);
 }
 
 
@@ -54,9 +54,9 @@ void DebugDrawer::drawBox(const btVector3& min, const btVector3& max, const btTr
 	trf(1, 3) = (max.getY() + min.getY()) / 2.0;
 	trf(2, 3) = (max.getZ() + min.getZ()) / 2.0;
 	trf = Mat4::combineTransformations(Mat4(toAnki(trans)), trf);
-	app->getMainRenderer().dbg.setModelMat(trf);
-	app->getMainRenderer().dbg.setColor(Vec4(toAnki(color), 1.0));
-	app->getMainRenderer().dbg.drawCube(1.0);
+	app->getMainRenderer().getDbg().setModelMat(trf);
+	app->getMainRenderer().getDbg().setColor(Vec4(toAnki(color), 1.0));
+	app->getMainRenderer().getDbg().drawCube(1.0);
 }
 
 

src/Renderer/Bs.cpp

@@ -126,7 +126,7 @@ void Bs::run()
 			refractSProg->bind();
 			refractSProg->findUniVar("fai")->setTexture(refractFai, 0);
 
-			Renderer::drawQuad(0);
+			Renderer::drawQuad();
 
 			// cleanup
 			glStencilFunc(GL_ALWAYS, 0x1, 0x1);

src/Renderer/Bs.h

@@ -1,7 +1,7 @@
 #ifndef BS_H
 #define BS_H
 
-#include "RenderingStage.h"
+#include "RenderingPass.h"
 #include "Fbo.h"
 #include "RsrcPtr.h"
 #include "Texture.h"
@@ -12,10 +12,10 @@ class ShaderProg;
 
 /// Blending stage.
 /// The objects that blend must be handled differently
-class Bs: public RenderingStage
+class Bs: public RenderingPass
 {
 	public:
-		Bs(Renderer& r_): RenderingStage(r_) {}
+		Bs(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
 		void init(const RendererInitializer& initializer);
 		void run();
 

src/Renderer/BufferObjects/BufferObject.cpp

@@ -1,3 +1,4 @@
+#include <cstring>
 #include "BufferObject.h"
 #include "GlException.h"
 
@@ -5,7 +6,7 @@
 //======================================================================================================================
 // create                                                                                                              =
 //======================================================================================================================
-void BufferObject::create(GLenum target_, uint sizeInBytes, const void* dataPtr, GLenum usage_)
+void BufferObject::create(GLenum target_, uint sizeInBytes_, const void* dataPtr, GLenum usage_)
 {
 	// unacceptable usage_
 	RASSERT_THROW_EXCEPTION(usage_ != GL_STREAM_DRAW && usage_ != GL_STATIC_DRAW && usage_ != GL_DYNAMIC_DRAW);
@@ -13,6 +14,7 @@ void BufferObject::create(GLenum target_, uint sizeInBytes, const void* dataPtr,
 
 	usage = usage_;
 	target = target_;
+	sizeInBytes = sizeInBytes_;
 
 	glGenBuffers(1, &glId);
 	bind();
@@ -30,3 +32,29 @@ void BufferObject::create(GLenum target_, uint sizeInBytes, const void* dataPtr,
 	unbind();
 	ON_GL_FAIL_THROW_EXCEPTION();
 }
+
+
+//======================================================================================================================
+// write                                                                                                               =
+//======================================================================================================================
+void BufferObject::write(void* buff, size_t size)
+{
+	if(usage == GL_STATIC_DRAW)
+	{
+		throw EXCEPTION("Its not recomended to map GL_STATIC_DRAW BOs");
+	}
+
+	bind();
+
+	int bufferSize = 0;
+	glGetBufferParameteriv(target, GL_BUFFER_SIZE, &bufferSize);
+	if(size != uint(bufferSize))
+	{
+		throw EXCEPTION("Data size mismatch");
+	}
+
+	void* mapped = glMapBuffer(target, GL_WRITE_ONLY);
+	memcpy(mapped, buff, size);
+	glUnmapBuffer(target);
+	unbind();
+}

src/Renderer/BufferObjects/BufferObject.h

@@ -26,13 +26,21 @@ class BufferObject: public Object
 		/// It deletes the BO from the GL context
 		virtual ~BufferObject() {deleteBuff();}
 
-		/// Bind BO. Throws exception if BO is not created
-		/// @exception Exception
-		void bind() const;
+		/// Bind BO
+		void bind() const {glBindBuffer(target, glId);}
 
-		/// Unbind BO. Throws exception if BO is not created
-		/// @exception Exception
-		void unbind() const;
+		/// Unbind BO
+		void unbind() const {glBindBuffer(target, 0);}
+
+		/// Write data to buffer. This means that maps the BO to local memory, writes the local memory and unmaps it.
+		/// Throws exception if the given size and the BO size are not equal. It throws an exception if the usage is
+		/// GL_STATIC_DRAW
+		/// @param[in] buff The buffer to copy to BO
+		/// @param[in] size The size in bytes we want to write
+		void write(void* buff, size_t size);
+
+	protected:
+		size_t sizeInBytes;
 
 	private:
 		/// Creates a new BO with the given parameters and checks if everything went OK. Throws exception if fails
@@ -44,7 +52,6 @@ class BufferObject: public Object
 		void create(GLenum target, uint sizeInBytes, const void* dataPtr, GLenum usage);
 
 		/// Delete the BO
-		/// @exception Exception
 		void deleteBuff();
 };
 
@@ -54,27 +61,19 @@ class BufferObject: public Object
 //======================================================================================================================
 
 inline BufferObject::BufferObject(GLenum target, uint sizeInBytes, const void* dataPtr, GLenum usage, Object* parent):
-	Object(parent)
+	Object(parent),
+	glId(0)
 {
 	create(target, sizeInBytes, dataPtr, usage);
 }
 
 
-inline void BufferObject::bind() const
-{
-	glBindBuffer(target, glId);
-}
-
-
-inline void BufferObject::unbind() const
-{
-	glBindBuffer(target, 0);
-}
-
-
 inline void BufferObject::deleteBuff()
 {
-	glDeleteBuffers(1, &glId);
+	if(glId != 0)
+	{
+		glDeleteBuffers(1, &glId);
+	}
 	glId = 0;
 }
 

src/Renderer/BufferObjects/Vao.cpp

@@ -17,6 +17,7 @@ void Vao::attachArrayBufferVbo(const Vbo& vbo, uint attribVarLocation, GLint siz
 	vbo.bind();
 	glVertexAttribPointer(attribVarLocation, size, type, normalized, stride, pointer);
 	glEnableVertexAttribArray(attribVarLocation);
+	vbo.unbind();
 	unbind();
 
 	ON_GL_FAIL_THROW_EXCEPTION();

src/Renderer/Dbg.cpp

@@ -11,8 +11,8 @@
 //======================================================================================================================
 // Constructor                                                                                                         =
 //======================================================================================================================
-Dbg::Dbg(Renderer& r_):
-	RenderingStage(r_),
+Dbg::Dbg(Renderer& r_, Object* parent):
+	RenderingPass(r_, parent),
 	showAxisEnabled(false),
 	showLightsEnabled(true),
 	showSkeletonsEnabled(true),

src/Renderer/Dbg.h

@@ -1,7 +1,7 @@
 #ifndef DBG_H
 #define DBG_H
 
-#include "RenderingStage.h"
+#include "RenderingPass.h"
 #include "Fbo.h"
 #include "ShaderProg.h"
 #include "RsrcPtr.h"
@@ -9,10 +9,10 @@
 
 
 /// Debugging stage
-class Dbg: public RenderingStage
+class Dbg: public RenderingPass
 {
 	public:
-		Dbg(Renderer& r_);
+		Dbg(Renderer& r_, Object* parent);
 		void init(const RendererInitializer& initializer);
 		void run();
 		void renderGrid();

src/Renderer/Ez.h

@@ -1,17 +1,17 @@
 #ifndef EZ_H
 #define EZ_H
 
-#include "RenderingStage.h"
+#include "RenderingPass.h"
 #include "Fbo.h"
 
 
 /**
  * Material stage EarlyZ pass
  */
-class Ez: public RenderingStage
+class Ez: public RenderingPass
 {
 	public:
-		Ez(Renderer& r_): RenderingStage(r_) {}
+		Ez(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
 		bool isEnabled() const {return enabled;}
 		void init(const RendererInitializer& initializer);
 		void run();

src/Renderer/Hdr.cpp

@@ -97,7 +97,7 @@ void Hdr::run()
 	toneSProg->bind();
 	toneSProg->findUniVar("exposure")->setFloat(exposure);
 	toneSProg->findUniVar("fai")->setTexture(r.pps.prePassFai, 0);
-	Renderer::drawQuad(0);
+	Renderer::drawQuad();
 
 
 	// blurring passes
@@ -118,7 +118,7 @@ void Hdr::run()
 		}
 		hblurSProg->findUniVar("imgDimension")->setFloat(w);
 		hblurSProg->findUniVar("blurringDist")->setFloat(blurringDist / w);
-		Renderer::drawQuad(0);
+		Renderer::drawQuad();
 
 		// vpass
 		vblurFbo.bind();
@@ -126,7 +126,7 @@ void Hdr::run()
 		vblurSProg->findUniVar("img")->setTexture(hblurFai, 0);
 		vblurSProg->findUniVar("imgDimension")->setFloat(h);
 		vblurSProg->findUniVar("blurringDist")->setFloat(blurringDist / h);
-		Renderer::drawQuad(0);
+		Renderer::drawQuad();
 	}
 
 	// end

src/Renderer/Hdr.h

@@ -1,7 +1,7 @@
 #ifndef HDR_H
 #define HDR_H
 
-#include "RenderingStage.h"
+#include "RenderingPass.h"
 #include "Fbo.h"
 #include "Texture.h"
 #include "RsrcPtr.h"
@@ -9,14 +9,14 @@
 
 
 /// High dynamic range lighting pass
-class Hdr: private RenderingStage
+class Hdr: private RenderingPass
 {
 	public:
 		Texture toneFai; ///< Vertical blur pass FAI
 		Texture hblurFai; ///< pass0Fai with the horizontal blur FAI
 		Texture fai; ///< The final FAI
 
-		Hdr(Renderer& r_): RenderingStage(r_) {}
+		Hdr(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
 		void init(const RendererInitializer& initializer);
 		void run();
 

src/Renderer/Is.cpp

@@ -10,6 +10,19 @@
 #include "Scene.h"
 #include "LightData.h"
 #include "Collision.h"
+#include "Vao.h"
+#include "Sm.h"
+#include "Smo.h"
+
+
+//======================================================================================================================
+// Constructor                                                                                                         =
+//======================================================================================================================
+Is::Is(Renderer& r_, Object* parent):
+	RenderingPass(r_, parent),
+	sm(new Sm(r_, this)),
+	smo(new Smo(r_, this))
+{}
 
 
 //======================================================================================================================
@@ -17,6 +30,8 @@
 //======================================================================================================================
 void Is::calcViewVectors()
 {
+	Vec3 viewVectors[4];
+
 	const Camera& cam = r.getCamera();
 
 	const uint& w = r.getWidth();
@@ -44,6 +59,8 @@ void Is::calcViewVectors()
 		viewVectors[i] = vec.getTransformed(cam.getInvProjectionMatrix());
 		// end of optimized code
 	}
+
+	viewVectorsVbo->write(viewVectors, sizeof(viewVectors));
 }
 
 
@@ -105,13 +122,11 @@ void Is::initFbo()
 void Is::init(const RendererInitializer& initializer)
 {
 	// init passes
-	smo.init(initializer);
-	sm.init(initializer);
+	smo->init(initializer);
+	sm->init(initializer);
 
 	// load the shaders
 	ambientPassSProg.loadRsrc("shaders/IsAp.glsl");
-	ambientColUniVar = ambientPassSProg->findUniVar("ambientCol");
-	sceneColMapUniVar = ambientPassSProg->findUniVar("sceneColMap");
 
 	// point light
 	pointLightSProg.loadRsrc(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl", "#define POINT_LIGHT_ENABLED\n",
@@ -124,9 +139,9 @@ void Is::init(const RendererInitializer& initializer)
 
 	// spot light w/t shadow
 	std::string pps = std::string("\n#define SPOT_LIGHT_ENABLED\n#define SHADOW_ENABLED\n") +
-	                              "#define SHADOWMAP_SIZE " + boost::lexical_cast<std::string>(sm.getResolution()) + "\n";
-	std::string prefix = "SpotShadowSmSize" + boost::lexical_cast<std::string>(sm.getResolution());
-	if(sm.isPcfEnabled())
+	                              "#define SHADOWMAP_SIZE " + boost::lexical_cast<std::string>(sm->getResolution()) + "\n";
+	std::string prefix = "SpotShadowSmSize" + boost::lexical_cast<std::string>(sm->getResolution());
+	if(sm->isPcfEnabled())
 	{
 		pps += "#define PCF_ENABLED\n";
 		prefix += "Pcf";
@@ -136,6 +151,31 @@ void Is::init(const RendererInitializer& initializer)
 
 	// init the rest
 	initFbo();
+
+	// The VBOs and VAOs
+	float quadVertCoords[][2] = {{1.0, 1.0}, {0.0, 1.0}, {0.0, 0.0}, {1.0, 0.0}};
+	quadPositionsVbo = new Vbo(GL_ARRAY_BUFFER, sizeof(quadVertCoords), quadVertCoords, GL_STATIC_DRAW, this);
+
+	ushort quadVertIndeces[2][3] = {{0, 1, 3}, {1, 2, 3}};
+	quadVertIndecesVbo = new Vbo(GL_ELEMENT_ARRAY_BUFFER, sizeof(quadVertIndeces), quadVertIndeces, GL_STATIC_DRAW, this);
+
+	viewVectorsVbo = new Vbo(GL_ARRAY_BUFFER, 4 * sizeof(Vec3), NULL, GL_DYNAMIC_DRAW, this);
+
+	vao = new Vao(this);
+	vao->attachArrayBufferVbo(*quadPositionsVbo, 0, 3, GL_FLOAT, false, 0, NULL);
+	vao->attachArrayBufferVbo(*viewVectorsVbo, 1, 3, GL_FLOAT, false, 0, NULL);
+	vao->attachElementArrayBufferVbo(*quadVertIndecesVbo);
+}
+
+
+//======================================================================================================================
+// drawLightPassQuad                                                                                                   =
+//======================================================================================================================
+void Is::drawLightPassQuad() const
+{
+	vao->bind();
+	glDrawElements(GL_TRIANGLES, 2 * 3, GL_UNSIGNED_SHORT, 0);
+	vao->unbind();
 }
 
 
@@ -154,7 +194,7 @@ void Is::ambientPass(const Vec3& color)
 	ambientPassSProg->findUniVar("sceneColMap")->setTexture(r.ms.diffuseFai, 0);
 
 	// Draw quad
-	Renderer::drawQuad(0);
+	Renderer::drawQuad();
 }
 
 
@@ -173,7 +213,7 @@ void Is::pointLightPass(const PointLight& light)
 	}
 
 	// stencil optimization
-	smo.run(light);
+	smo->run(light);
 
 	// shader prog
 	const ShaderProg& shader = *pointLightSProg; // ensure the const-ness
@@ -191,16 +231,7 @@ void Is::pointLightPass(const PointLight& light)
 	shader.findUniVar("lightSpecularCol")->setVec3(&light.lightData->getSpecularCol());
 
 	// render quad
-	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);
+	drawLightPassQuad();
 }
 
 
@@ -218,9 +249,9 @@ void Is::spotLightPass(const SpotLight& light)
 	}
 
 	// shadow mapping
-	if(light.castsShadow() && sm.isEnabled())
+	if(light.castsShadow() && sm->isEnabled())
 	{
-		sm.run(light.getCamera());
+		sm->run(light.getCamera());
 
 		// restore the IS FBO
 		fbo.bind();
@@ -233,7 +264,7 @@ void Is::spotLightPass(const SpotLight& light)
 	}
 
 	// stencil optimization
-	smo.run(light);
+	smo->run(light);
 
 	// set the texture
 	light.lightData->getTexture().setRepeat(false);
@@ -241,7 +272,7 @@ void Is::spotLightPass(const SpotLight& light)
 	// shader prog
 	const ShaderProg* shdr;
 
-	if(light.castsShadow() && sm.isEnabled())
+	if(light.castsShadow() && sm->isEnabled())
 	{
 		shdr = spotLightShadowSProg.get();
 	}
@@ -278,22 +309,13 @@ void Is::spotLightPass(const SpotLight& light)
 	shdr->findUniVar("texProjectionMat")->setMat4(&texProjectionMat);
 
 	// the shadowmap
-	if(light.castsShadow() && sm.isEnabled())
+	if(light.castsShadow() && sm->isEnabled())
 	{
-		shdr->findUniVar("shadowMap")->setTexture(sm.shadowMap, 5);
+		shdr->findUniVar("shadowMap")->setTexture(sm->shadowMap, 5);
 	}
 
 	// render quad
-	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);
+	drawLightPassQuad();
 }
 
 

src/Renderer/Is.h

@@ -1,30 +1,35 @@
 #ifndef IS_H
 #define IS_H
 
-#include "RenderingStage.h"
+#include "RenderingPass.h"
 #include "Fbo.h"
-#include "Sm.h"
-#include "Smo.h"
 #include "Texture.h"
+#include "RsrcPtr.h"
+#include "ShaderProg.h"
+#include "Math.h"
 
 
 class PointLight;
 class SpotLight;
+class Vao;
+class Sm;
+class Smo;
+class Vbo;
 
 
 /// Illumination stage
-class Is: private RenderingStage
+class Is: private RenderingPass
 {
 	public:
-		Sm sm;
-		Smo smo;
 		Texture fai;
 
-		Is(Renderer& r_): RenderingStage(r_), sm(r_), smo(r_) {}
+		Is(Renderer& r_, Object* parent);
 		void init(const RendererInitializer& initializer);
 		void run();
 
 	private:
+		Sm* sm;
+		Smo* smo;
 		Fbo fbo; ///< This FBO writes to the Is::fai
 		uint stencilRb; ///< Illumination stage stencil buffer
 		RsrcPtr<ShaderProg> ambientPassSProg; ///< Illumination stage ambient pass shader program
@@ -32,16 +37,21 @@ class Is: private RenderingStage
 		RsrcPtr<ShaderProg> spotLightNoShadowSProg; ///< Illumination stage spot light w/o shadow shader program
 		RsrcPtr<ShaderProg> spotLightShadowSProg; ///< Illumination stage spot light w/ shadow shader program
 
-		/// @name Ptrs to uniform variables
+		/// @name For the quad drawing in light passes
 		/// @{
-		const ShaderProg::UniVar* ambientColUniVar;
-		const ShaderProg::UniVar* sceneColMapUniVar;
+		Vbo* quadPositionsVbo; ///< The VBO for quad positions
+		Vbo* viewVectorsVbo; ///< The VBO to pass the @ref viewVectors.
+		Vbo* quadVertIndecesVbo; ///< The VBO for quad array buffer elements
+		Vao* vao; ///< This VAO is used in light passes only
 		/// @}
 
-		Vec3 viewVectors[4];
-		Vec2 planes;
+		Vec2 planes; ///< Used to to calculate the frag pos in view space inside tha shader program
 
-		/// Calc the view vector that we will use inside the shader to calculate the frag pos in view space
+		/// Draws the vao that has attached the viewVectorsVbo as well. Used in light passes
+		void drawLightPassQuad() const;
+
+		/// Calc the view vector that we will use inside the shader to calculate the frag pos in view space. This calculates
+		/// the view vectors and updates the @ref viewVectorsVbo
 		void calcViewVectors();
 
 		/// Calc the planes that we will use inside the shader to calculate the frag pos in view space

src/Renderer/MainRenderer.cpp

@@ -104,7 +104,7 @@ void MainRenderer::render(Camera& cam_)
 	sProg->bind();
 	sProg->findUniVar("rasterImage")->setTexture(ms.diffuseFai, 0);
 	//sProg->findUniVar("rasterImage")->setTexture(pps.postPassFai, 0);
-	drawQuad(0);
+	drawQuad();
 }
 
 

src/Renderer/MainRenderer.h

@@ -8,8 +8,6 @@
 class MainRenderer: public Renderer
 {
 	public:
-		Dbg dbg; ///< Debugging rendering stage. Only the main renderer has it
-
 		MainRenderer(Object* parent);
 
 		~MainRenderer() throw() {}
@@ -19,6 +17,7 @@ class MainRenderer: public Renderer
 		int& getScreenshotJpegQuality() {return screenshotJpegQuality;}
 		void setScreenshotJpegQuality(int i) {screenshotJpegQuality = i;}
 		float getRenderingQuality() const {return renderingQuality;}
+		Dbg& getDbg() {return *dbg;}
 		/// @}
 
 		/// The same as Renderer::init but with additional initialization. @see Renderer::init
@@ -33,6 +32,11 @@ class MainRenderer: public Renderer
 		void takeScreenshot(const char* filename);
 
 	private:
+		/// @name Passes
+		/// @{
+		Dbg* dbg; ///< Debugging rendering stage. Only the main renderer has it
+		/// @}
+
 		RsrcPtr<ShaderProg> sProg; ///< Final pass' shader program
 		int screenshotJpegQuality; ///< The quality of the JPEG screenshots. From 0 to 100
 
@@ -48,7 +52,7 @@ class MainRenderer: public Renderer
 
 inline MainRenderer::MainRenderer(Object* parent):
 	Renderer(parent),
-	dbg(*this),
+	dbg(new Dbg(*this, this)),
 	screenshotJpegQuality(90)
 {}
 

src/Renderer/Ms.cpp

@@ -4,6 +4,16 @@
 #include "Scene.h"
 #include "Camera.h"
 #include "MeshNode.h"
+#include "Ez.h"
+
+
+//======================================================================================================================
+// Constructor                                                                                                         =
+//======================================================================================================================
+Ms::Ms(Renderer& r_, Object* parent):
+	RenderingPass(r_, parent),
+	ez(new Ez(r_, this))
+{}
 
 
 //======================================================================================================================
@@ -51,7 +61,7 @@ void Ms::init(const RendererInitializer& initializer)
 		throw EXCEPTION("Cannot create deferred shading material stage FBO: " + e.what());
 	}
 
-	ez.init(initializer);
+	ez->init(initializer);
 }
 
 
@@ -62,14 +72,14 @@ void Ms::run()
 {
 	const Camera& cam = r.getCamera();
 
-	if(ez.isEnabled())
+	if(ez->isEnabled())
 	{
-		ez.run();
+		ez->run();
 	}
 
 	fbo.bind();
 
-	if(!ez.isEnabled())
+	if(!ez->isEnabled())
 	{
 		glClear(GL_DEPTH_BUFFER_BIT);
 	}
@@ -81,7 +91,7 @@ void Ms::run()
 	//glDepthFunc(GL_LEQUAL);
 
 	// if ez then change the default depth test and disable depth writing
-	if(ez.isEnabled())
+	if(ez->isEnabled())
 	{
 		glDepthMask(false);
 		glDepthFunc(GL_EQUAL);
@@ -108,7 +118,7 @@ void Ms::run()
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // the rendering above fucks the polygon mode
 
 	// restore depth
-	if(ez.isEnabled())
+	if(ez->isEnabled())
 	{
 		glDepthMask(true);
 		glDepthFunc(GL_LESS);

src/Renderer/Ms.h

@@ -1,31 +1,30 @@
 #ifndef MS_H
 #define MS_H
 
-#include "RenderingStage.h"
-#include "Ez.h"
+#include "RenderingPass.h"
 #include "Texture.h"
+#include "Fbo.h"
 
 
 class RendererInitializer;
+class Ez;
 
 
-/**
- * Material stage
- */
-class Ms: public RenderingStage
+/// Material stage
+class Ms: public RenderingPass
 {
 	public:
-		Ez ez;
 		Texture normalFai;
 		Texture diffuseFai;
 		Texture specularFai;
 		Texture depthFai;
 
-		Ms(Renderer& r_): RenderingStage(r_), ez(r_) {}
+		Ms(Renderer& r_, Object* parent);
 		void init(const RendererInitializer& initializer);
 		void run();
 
 	private:
+		Ez* ez;
 		Fbo fbo;
 };
 

src/Renderer/Pps.cpp

@@ -1,5 +1,17 @@
 #include "Pps.h"
 #include "Renderer.h"
+#include "Hdr.h"
+#include "Ssao.h"
+
+
+//======================================================================================================================
+// Constructor                                                                                                         =
+//======================================================================================================================
+Pps::Pps(Renderer& r_, Object* parent):
+	RenderingPass(r_, parent),
+	hdr(new Hdr(r_, this)),
+	ssao(new Ssao(r_, this))
+{}
 
 
 //======================================================================================================================
@@ -31,7 +43,7 @@ void Pps::initPrePassSProg()
 	std::string pps = "";
 	std::string prefix = "";
 
-	if(ssao.isEnabled())
+	if(ssao->isEnabled())
 	{
 		pps += "#define SSAO_ENABLED\n";
 		prefix += "Ssao";
@@ -51,7 +63,7 @@ void Pps::initPostPassSProg()
 	std::string pps = "";
 	std::string prefix = "";
 
-	if(hdr.isEnabled())
+	if(hdr->isEnabled())
 	{
 		pps += "#define HDR_ENABLED\n";
 		prefix += "Hdr";
@@ -68,8 +80,8 @@ void Pps::initPostPassSProg()
 //======================================================================================================================
 void Pps::init(const RendererInitializer& initializer)
 {
-	ssao.init(initializer);
-	hdr.init(initializer);
+	ssao->init(initializer);
+	hdr->init(initializer);
 
 	try
 	{
@@ -99,9 +111,9 @@ void Pps::init(const RendererInitializer& initializer)
 //======================================================================================================================
 void Pps::runPrePass()
 {
-	if(ssao.isEnabled())
+	if(ssao->isEnabled())
 	{
-		ssao.run();
+		ssao->run();
 	}
 
 	prePassFbo.bind();
@@ -113,12 +125,12 @@ void Pps::runPrePass()
 	prePassSProg->bind();
 	prePassSProg->findUniVar("isFai")->setTexture(r.is.fai, 0);
 
-	if(ssao.isEnabled())
+	if(ssao->isEnabled())
 	{
-		prePassSProg->findUniVar("ppsSsaoFai")->setTexture(ssao.fai, 1);
+		prePassSProg->findUniVar("ppsSsaoFai")->setTexture(ssao->fai, 1);
 	}
 
-	Renderer::drawQuad(0);
+	Renderer::drawQuad();
 
 	Fbo::unbind();
 }
@@ -129,9 +141,9 @@ void Pps::runPrePass()
 //======================================================================================================================
 void Pps::runPostPass()
 {
-	if(hdr.isEnabled())
+	if(hdr->isEnabled())
 	{
-		hdr.run();
+		hdr->run();
 	}
 
 	postPassFbo.bind();
@@ -143,12 +155,12 @@ void Pps::runPostPass()
 	postPassSProg->bind();
 	postPassSProg->findUniVar("ppsPrePassFai")->setTexture(prePassFai, 0);
 
-	if(hdr.isEnabled())
+	if(hdr->isEnabled())
 	{
-		postPassSProg->findUniVar("ppsHdrFai")->setTexture(hdr.fai, 1);
+		postPassSProg->findUniVar("ppsHdrFai")->setTexture(hdr->fai, 1);
 	}
 
-	Renderer::drawQuad(0);
+	Renderer::drawQuad();
 
 	Fbo::unbind();
 }

src/Renderer/Pps.h

@@ -1,29 +1,43 @@
 #ifndef PPS_H
 #define PPS_H
 
-#include "RenderingStage.h"
+#include "RenderingPass.h"
 #include "Fbo.h"
-#include "Hdr.h"
-#include "Ssao.h"
+#include "Texture.h"
+#include "RsrcPtr.h"
+
+
+class Hdr;
+class Ssao;
+class ShaderProg;
 
 
 /// Post-processing stage.
 ///
 /// This stage is divided into 2 two parts. The first happens before blending stage and the second after.
-class Pps: private RenderingStage
+class Pps: private RenderingPass
 {
 	public:
-		Hdr hdr;
-		Ssao ssao;
 		Texture prePassFai;
 		Texture postPassFai;
 
-		Pps(Renderer& r_): RenderingStage(r_), hdr(r_), ssao(r_) {}
+		Pps(Renderer& r_, Object* parent);
 		void init(const RendererInitializer& initializer);
 		void runPrePass();
 		void runPostPass();
 
+		/// @name Accessors
+		/// @{
+		Hdr& getHdr() {return *hdr;}
+		/// @}
+
 	private:
+		/// @name Passes
+		/// @{
+		Hdr* hdr;
+		Ssao* ssao;
+		/// @}
+
 		Fbo prePassFbo;
 		Fbo postPassFbo;
 		RsrcPtr<ShaderProg> prePassSProg;

src/Renderer/Renderer.cpp

@@ -25,10 +25,10 @@ Renderer::Renderer(Object* parent):
 	Object(parent),
 	width(640),
 	height(480),
-	ms(*this),
-	is(*this),
-	pps(*this),
-	bs(*this)
+	ms(*this, this),
+	is(*this, this),
+	pps(*this, this),
+	bs(*this, this)
 {}
 
 
@@ -62,11 +62,11 @@ void Renderer::init(const RendererInitializer& initializer)
 		float quadVertCoords[][2] = {{1.0, 1.0}, {0.0, 1.0}, {0.0, 0.0}, {1.0, 0.0}};
 		quadPositionsVbo = new Vbo(GL_ARRAY_BUFFER, sizeof(quadVertCoords), quadVertCoords, GL_STATIC_DRAW);
 
-		ushort quadVertIndeces[2][3] = {{0, 1, 2}, {1, 2, 3}};
+		ushort quadVertIndeces[2][3] = {{0, 1, 3}, {1, 2, 3}}; // 2 triangles
 		quadVertIndecesVbo = new Vbo(GL_ELEMENT_ARRAY_BUFFER, sizeof(quadVertIndeces), quadVertIndeces, GL_STATIC_DRAW);
 
 		globalVao = new Vao();
-		globalVao->attachArrayBufferVbo(*quadPositionsVbo, 0, 4, GL_FLOAT, false, 0, NULL);
+		globalVao->attachArrayBufferVbo(*quadPositionsVbo, 0, 3, GL_FLOAT, false, 0, NULL);
 		globalVao->attachElementArrayBufferVbo(*quadVertIndecesVbo);
 	}
 }
@@ -83,7 +83,6 @@ void Renderer::render(Camera& cam_)
 
 	ms.run();
 
-	globalVao->bind();
 	/*is.run();
 	pps.runPrePass();
 	bs.run();
@@ -96,10 +95,11 @@ void Renderer::render(Camera& cam_)
 //======================================================================================================================
 // drawQuad                                                                                                            =
 //======================================================================================================================
-void Renderer::drawQuad(int vertCoordsAttribLoc)
+void Renderer::drawQuad()
 {
-	RASSERT_THROW_EXCEPTION(vertCoordsAttribLoc == -1);
+	globalVao->bind();
 	glDrawElements(GL_TRIANGLES, 2 * 3, GL_UNSIGNED_SHORT, 0);
+	globalVao->unbind();
 	ON_GL_FAIL_THROW_EXCEPTION();
 }
 
@@ -297,7 +297,7 @@ void Renderer::setupMaterial(const Material& mtl, const SceneNode& sceneNode, co
 // unproject                                                                                                           =
 //======================================================================================================================
 Vec3 Renderer::unproject(const Vec3& windowCoords, const Mat4& modelViewMat, const Mat4& projectionMat,
-                          const int view[4])
+                         const int view[4])
 {
 	Mat4 invPm = projectionMat * modelViewMat;
 	invPm.invert();

src/Renderer/Renderer.h

@@ -99,7 +99,7 @@ class Renderer: public Object
 
 		/// Draws a quad. Actually it draws 2 triangles because OpenGL will no longer support quads
 		/// @param vertCoordsAttribLoc The attribute location of the vertex positions
-		static void drawQuad(int vertCoordsAttribLoc);
+		static void drawQuad();
 
 	//====================================================================================================================
 	// Protected                                                                                                         =
@@ -122,4 +122,5 @@ class Renderer: public Object
 		/// @}
 };
 
+
 #endif

src/Renderer/RenderingPass.h

@@ -0,0 +1,31 @@
+#ifndef RENDERING_PASS_H
+#define RENDERING_PASS_H
+
+#include "Object.h"
+
+
+class Renderer;
+class RendererInitializer;
+
+
+/// Rendering pass
+class RenderingPass: public Object
+{
+	public:
+		RenderingPass(Renderer& r_, Object* parent = NULL);
+
+		/// All passes should have an init
+		virtual void init(const RendererInitializer& initializer) = 0;
+
+	protected:
+		Renderer& r; ///< Know your father
+};
+
+
+inline RenderingPass::RenderingPass(Renderer& r_, Object* parent):
+	Object(parent),
+	r(r_)
+{}
+
+
+#endif

src/Renderer/RenderingStage.h

@@ -1,21 +0,0 @@
-#ifndef RENDERING_STAGE_H
-#define RENDERING_STAGE_H
-
-
-class Renderer;
-class RendererInitializer;
-
-
-/// Rendering stage
-class RenderingStage
-{
-	public:
-		RenderingStage(Renderer& r_): r(r_) {}
-		virtual void init(const RendererInitializer& initializer) = 0;
-
-	protected:
-		Renderer& r; ///< Know your father
-};
-
-
-#endif

src/Renderer/Sm.h

@@ -1,7 +1,7 @@
 #ifndef SM_H
 #define SM_H
 
-#include "RenderingStage.h"
+#include "RenderingPass.h"
 #include "Fbo.h"
 #include "Texture.h"
 
@@ -9,22 +9,18 @@
 class Camera;
 
 
-/**
- * Shadowmapping pass
- */
-class Sm: private RenderingStage
+/// Shadowmapping pass
+class Sm: private RenderingPass
 {
 	public:
 		Texture shadowMap;
 
-		Sm(Renderer& r_): RenderingStage(r_) {}
+		Sm(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
 
 		void init(const RendererInitializer& initializer);
 
-		/**
-		 * Render the scene only with depth and store the result in the shadowMap
-		 * @param cam The light camera
-		 */
+		/// Render the scene only with depth and store the result in the shadowMap
+		/// @param[in] cam The light camera
 		void run(const Camera& cam);
 
 		bool isEnabled() const {return enabled;}

src/Renderer/Smo.h

@@ -1,7 +1,7 @@
 #ifndef SMO_H
 #define SMO_H
 
-#include "RenderingStage.h"
+#include "RenderingPass.h"
 #include "Fbo.h"
 #include "Vbo.h"
 #include "ShaderProg.h"
@@ -12,13 +12,11 @@ class PointLight;
 class SpotLight;
 
 
-/**
- * Stencil masking optimizations
- */
-class Smo: public RenderingStage
+/// Stencil masking optimizations
+class Smo: public RenderingPass
 {
 	public:
-		Smo(Renderer& r_): RenderingStage(r_) {}
+		Smo(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
 		void init(const RendererInitializer& initializer);
 		void run(const PointLight& light);
 		void run(const SpotLight& light);

src/Renderer/Ssao.cpp

@@ -123,7 +123,7 @@ void Ssao::run()
 	ssaoSProg->findUniVar("msDepthFai")->setTexture(r.ms.depthFai, 0);
 	ssaoSProg->findUniVar("noiseMap")->setTexture(*noiseMap, 1);
 	ssaoSProg->findUniVar("msNormalFai")->setTexture(r.ms.normalFai, 2);
-	Renderer::drawQuad(0);
+	Renderer::drawQuad();
 
 
 	// blurring passes
@@ -143,14 +143,14 @@ void Ssao::run()
 			hblurSProg->findUniVar("img")->setTexture(fai, 0);
 		}
 		hblurSProg->findUniVar("imgDimension")->setFloat(width);
-		Renderer::drawQuad(0);
+		Renderer::drawQuad();
 
 		// vpass
 		vblurFbo.bind();
 		vblurSProg->bind();
 		vblurSProg->findUniVar("img")->setTexture(hblurFai, 0);
 		vblurSProg->findUniVar("imgDimension")->setFloat(height);
-		Renderer::drawQuad(0);
+		Renderer::drawQuad();
 	}
 
 	// end

src/Renderer/Ssao.h

@@ -1,39 +1,35 @@
 #ifndef SSAO_H
 #define SSAO_H
 
-#include "RenderingStage.h"
+#include "RenderingPass.h"
 #include "Fbo.h"
 #include "Texture.h"
 #include "ShaderProg.h"
 #include "RsrcPtr.h"
 
 
-/**
- * Screen space ambient occlusion pass
- *
- * Three passes:
- * 1) Calc ssao factor
- * 2) Blur vertically
- * 3) Blur horizontally repeat 2, 3
- */
-class Ssao: private RenderingStage
+/// Screen space ambient occlusion pass
+///
+/// Three passes:
+/// 1) Calc ssao factor
+/// 2) Blur vertically
+/// 3) Blur horizontally repeat 2, 3
+class Ssao: private RenderingPass
 {
 	public:
 		Texture ssaoFai; ///< It contains the unblurred SSAO factor
 		Texture hblurFai;
 		Texture fai;  ///< AKA vblurFai The final FAI
 
-		Ssao(Renderer& r_): RenderingStage(r_) {}
+		Ssao(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
 		void init(const RendererInitializer& initializer);
 		void run();
 
-		/**
-		 * @name Setters & getters
-		 */
-		/**@{*/
+		/// @name Setters & getters
+		/// @{
 		bool isEnabled() const {return enabled;}
 		float getRenderingQuality() const {return renderingQuality;}
-		/**@}*/
+		/// @}
 
 	private:
 		bool enabled;

src/Scene/Camera.cpp

@@ -22,8 +22,8 @@ void Camera::setAll(float fovx_, float fovy_, float znear_, float zfar_)
 //======================================================================================================================
 void Camera::render()
 {
-	app->getMainRenderer().dbg.setColor(Vec4(1.0, 0.0, 1.0, 1.0));
-	app->getMainRenderer().dbg.setModelMat(Mat4(getWorldTransform()));
+	app->getMainRenderer().getDbg().setColor(Vec4(1.0, 0.0, 1.0, 1.0));
+	app->getMainRenderer().getDbg().setModelMat(Mat4(getWorldTransform()));
 
 	const float camLen = 1.0;
 	float tmp0 = camLen / tan((M::PI - fovX)*0.5) + 0.001;

src/Scene/Controllers/SkelAnimCtrl.cpp

@@ -168,7 +168,7 @@ void SkelAnimCtrl::update(float)
 
 	interpolate(*skelAnim, frame);
 	updateBoneTransforms();
-	if(app->getMainRenderer().dbg.isEnabled() && app->getMainRenderer().dbg.isShowSkeletonsEnabled())
+	if(app->getMainRenderer().getDbg().isEnabled() && app->getMainRenderer().getDbg().isShowSkeletonsEnabled())
 	{
 		deform();
 	}

src/Scene/Light.cpp

@@ -22,6 +22,6 @@ void Light::init(const char* filename)
 //======================================================================================================================
 void Light::render()
 {
-	app->getMainRenderer().dbg.drawSphere(0.1, getWorldTransform(), Vec4(lightData->getDiffuseCol(), 1.0));
+	app->getMainRenderer().getDbg().drawSphere(0.1, getWorldTransform(), Vec4(lightData->getDiffuseCol(), 1.0));
 }
 

src/Scene/ParticleEmitter.cpp

@@ -217,8 +217,8 @@ void ParticleEmitter::update()
 void ParticleEmitter::render()
 {
 	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-	app->getMainRenderer().dbg.setColor(Vec4(1.0));
-	app->getMainRenderer().dbg.setModelMat(Mat4(getWorldTransform()));
-	app->getMainRenderer().dbg.drawCube();
+	app->getMainRenderer().getDbg().setColor(Vec4(1.0));
+	app->getMainRenderer().getDbg().setModelMat(Mat4(getWorldTransform()));
+	app->getMainRenderer().getDbg().drawCube();
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 }

src/Scene/SkelNode.cpp

@@ -32,14 +32,14 @@ void SkelNode::init(const char* filename)
 //======================================================================================================================
 void SkelNode::render()
 {
-	app->getMainRenderer().dbg.setModelMat(Mat4(getWorldTransform()));
-	app->getMainRenderer().dbg.setColor(Vec4(1.0, 0.0, 0.0, 1.0));
-	app->getMainRenderer().dbg.setModelMat(Mat4(getWorldTransform()));
+	app->getMainRenderer().getDbg().setModelMat(Mat4(getWorldTransform()));
+	app->getMainRenderer().getDbg().setColor(Vec4(1.0, 0.0, 0.0, 1.0));
+	app->getMainRenderer().getDbg().setModelMat(Mat4(getWorldTransform()));
 
 	Vec<Vec3> positions;
 
 	for(uint i=0; i<skeleton->bones.size(); i++)
 	{
-		app->getMainRenderer().dbg.drawLine(heads[i], tails[i], Vec4(1.0));
+		app->getMainRenderer().getDbg().drawLine(heads[i], tails[i], Vec4(1.0));
 	}
 }

src/Scripting/Renderer/MainRenderer.bpi.cpp

@@ -6,6 +6,6 @@
 WRAP(MainRenderer)
 {
 	class_<MainRenderer, bases<Renderer>, noncopyable>("MainRenderer", no_init)
-		.def_readonly("dbg", &MainRenderer::dbg)
+		.def("getDbg", &MainRenderer::getDbg, return_value_policy<reference_existing_object>())
 	;
 }

src/Scripting/Renderer/Pps.bpi.cpp

@@ -6,6 +6,6 @@
 WRAP(Pps)
 {
 	class_<Pps, noncopyable>("Pps", no_init)
-		.def_readonly("hdr", &Pps::hdr)
+		.def("getHdr", &Pps::getHdr, return_value_policy<reference_existing_object>())
 	;
 }