Refactoring

docs/doxyfile

@@ -793,7 +793,7 @@ ALPHABETICAL_INDEX     = YES
 # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
 # in which this list will be split (can be a number in the range [1..20])
 
-COLS_IN_ALPHA_INDEX    = 1
+COLS_IN_ALPHA_INDEX    = 2
 
 # In case all classes in a project start with a common prefix, all 
 # classes will be put under the same header in the alphabetical index. 

src/cln/Collision.h

@@ -1,5 +1,5 @@
-#ifndef COLLISION_H
-#define COLLISION_H
+#ifndef CLN_COLLISION_H
+#define CLN_COLLISION_H
 
 #include "Plane.h"
 #include "Sphere.h"

src/cln/CollisionShape.h

@@ -2,6 +2,7 @@
 #define CLN_COLLISION_SHAPE
 
 
+/// Contains collision detection classes
 namespace cln {
 
 

src/event/Event.h

@@ -5,6 +5,7 @@
 #include "util/Accessors.h"
 
 
+/// Events namespace
 namespace event {
 
 

src/gl/BufferObject.cpp

@@ -4,6 +4,9 @@
 #include "util/Exception.h"
 
 
+namespace gl {
+
+
 //==============================================================================
 // Destructor                                                                  =
 //==============================================================================
@@ -82,3 +85,6 @@ void BufferObject::write(void* buff, size_t offset, size_t size)
 	glUnmapBuffer(target);
 	unbind();
 }
+
+
+} // end namespace

src/gl/BufferObject.h

@@ -1,11 +1,15 @@
-#ifndef BUFFER_OBJECT_H
-#define BUFFER_OBJECT_H
+#ifndef GL_BUFFER_OBJECT_H
+#define GL_BUFFER_OBJECT_H
 
 #include <GL/glew.h>
 #include "util/Assert.h"
 #include "util/StdTypes.h"
 
 
+/// Contains OpenGL wrappers
+namespace gl {
+
+
 /// A wrapper for OpenGL buffer objects (vertex arrays, texture buffers etc)
 /// to prevent us from making idiotic errors
 class BufferObject
@@ -141,4 +145,7 @@ inline void BufferObject::deleteBuff()
 }
 
 
+} // end namespace
+
+
 #endif

src/gl/Fbo.cpp

@@ -2,6 +2,9 @@
 #include <boost/lexical_cast.hpp>
 
 
+namespace gl {
+
+
 //==============================================================================
 // Destructor                                                                  =
 //==============================================================================
@@ -67,3 +70,6 @@ uint Fbo::getCurrentFbo()
 	glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fboGlId);
 	return (uint)fboGlId;
 }
+
+
+} // end namespace

src/gl/Fbo.h

@@ -1,5 +1,5 @@
-#ifndef FBO_H
-#define FBO_H
+#ifndef GL_FBO_H
+#define GL_FBO_H
 
 #include <GL/glew.h>
 #include "util/Assert.h"
@@ -7,6 +7,9 @@
 #include "util/Exception.h"
 
 
+namespace gl {
+
+
 /// The class is actually a wrapper to avoid common mistakes
 class Fbo
 {
@@ -92,4 +95,7 @@ inline void Fbo::destroy()
 }
 
 
+} // end namespace
+
+
 #endif

src/gl/TimeQuery.cpp

@@ -3,6 +3,9 @@
 #include "GlException.h"
 
 
+namespace gl {
+
+
 //==============================================================================
 // Constructor                                                                 =
 //==============================================================================
@@ -61,3 +64,6 @@ double TimeQuery::end()
 
 	return (timerEnd - timerStart) / 1000000000.0;
 }
+
+
+} // end namespace

src/gl/TimeQuery.h

@@ -1,10 +1,13 @@
-#ifndef TIME_QUERY_H
-#define TIME_QUERY_H
+#ifndef GL_TIME_QUERY_H
+#define GL_TIME_QUERY_H
 
 #include <GL/glew.h>
 #include <boost/array.hpp>
 
 
+namespace gl {
+
+
 /// Used to profile the GPU. It gets the time elapsed from when the begin() is
 /// called until the endAndGetTimeElapsed() method. The query causes
 /// synchronization issues because it waits for the GL commands to finish. For
@@ -36,4 +39,7 @@ class TimeQuery
 };
 
 
+} // end namespace
+
+
 #endif

src/gl/Vao.cpp

@@ -4,6 +4,9 @@
 #include "rsrc/ShaderProgramAttributeVariable.h"
 
 
+namespace gl {
+
+
 //==============================================================================
 // Destructor                                                                  =
 //==============================================================================
@@ -72,3 +75,6 @@ void Vao::attachElementArrayBufferVbo(const Vbo& vbo)
 	unbind();
 	ON_GL_FAIL_THROW_EXCEPTION();
 }
+
+
+} // end namespace

src/gl/Vao.h

@@ -1,5 +1,5 @@
-#ifndef VAO_H
-#define VAO_H
+#ifndef GL_VAO_H
+#define GL_VAO_H
 
 #include <GL/glew.h>
 #include "util/StdTypes.h"
@@ -7,10 +7,15 @@
 #include "GlException.h"
 
 
-class Vbo;
 class ShaderProgramAttributeVariable;
 
 
+namespace gl {
+
+
+class Vbo;
+
+
 /// Vertex array object
 class Vao
 {
@@ -114,4 +119,7 @@ inline uint Vao::getGlId() const
 }
 
 
+} // end namespace
+
+
 #endif

src/gl/Vbo.h

@@ -1,9 +1,12 @@
-#ifndef VBO_H
-#define VBO_H
+#ifndef GL_VBO_H
+#define GL_VBO_H
 
 #include "BufferObject.h"
 
 
+namespace gl {
+
+
 /// This is a wrapper for Vertex Buffer Objects to prevent us from making
 /// idiotic errors
 class Vbo: public BufferObject
@@ -50,4 +53,7 @@ inline void Vbo::unbindAllTargets()
 }
 
 
+} // end namespace
+
+
 #endif

src/m/Funcs.h

@@ -4,6 +4,7 @@
 #include "Common.h"
 
 
+/// Math library namespace
 namespace m {
 
 

src/m/Math.h

@@ -1,5 +1,5 @@
-#ifndef MATH_H
-#define MATH_H
+#ifndef M_MATH_H
+#define M_MATH_H
 
 
 #include <math.h>

src/misc/Parser.h

@@ -8,7 +8,7 @@
 
 /// It contains some functions and macros that are used pretty often while
 /// parsing
-namespace Parser {
+namespace parser {
 
 /// Parser macros
 #define PARSER_EXCEPTION(x) \
@@ -66,7 +66,7 @@ extern bool isIdentifier(const scanner::Token& token, const char* str);
 extern std::string parseString(scanner::Scanner& scanner);
 
 
-} // end namespace Parser
+} // end namespace
 
 
 #include "Parser.inl.h"

src/misc/Parser.inl.h

@@ -3,7 +3,7 @@
 #include "util/Exception.h"
 
 
-namespace Parser {
+namespace parser {
 
 
 //==============================================================================
@@ -256,4 +256,4 @@ inline std::string parseString(scanner::Scanner& scanner)
 }
 
 
-} // End namespace Parser
+} // End namespace

src/r/Bl.h

@@ -31,9 +31,9 @@ class Bl: private RenderingPass
 		/// @}
 
 	private:
-		Fbo hBlurFbo; ///< Fbo that writes to blurFai
-		Fbo vBlurFbo; ///< Fbo that writes to postPassSProg
-		Fbo sideBlurFbo;
+		gl::Fbo hBlurFbo; ///< Fbo that writes to blurFai
+		gl::Fbo vBlurFbo; ///< Fbo that writes to postPassSProg
+		gl::Fbo sideBlurFbo;
 
 		RsrcPtr<ShaderProgram> hBlurSProg;
 		RsrcPtr<ShaderProgram> vBlurSProg;

src/r/Bs.h

@@ -25,8 +25,8 @@ class Bs: public RenderingPass
 		void run();
 
 	private:
-		Fbo fbo; ///< Writes to Pps::prePassFai
-		Fbo refractFbo; ///< Writes to refractFai
+		gl::Fbo fbo; ///< Writes to Pps::prePassFai
+		gl::Fbo refractFbo; ///< Writes to refractFai
 		RsrcPtr<ShaderProgram> refractSProg;
 		Texture refractFai;
 

src/r/Dbg.h

@@ -58,7 +58,7 @@ class Dbg: public RenderingPass
 		bool showSkeletonsEnabled;
 		bool showCamerasEnabled;
 		bool showVisibilityBoundingShapesFlag;
-		Fbo fbo;
+		gl::Fbo fbo;
 		RsrcPtr<ShaderProgram> sProg;
 		static const uint MAX_POINTS_PER_DRAW = 256;
 		boost::array<Vec3, MAX_POINTS_PER_DRAW> positions;
@@ -66,9 +66,9 @@ class Dbg: public RenderingPass
 		Mat4 modelMat;
 		uint pointIndex;
 		Vec3 crntCol;
-		Vbo positionsVbo;
-		Vbo colorsVbo;
-		Vao vao;
+		gl::Vbo positionsVbo;
+		gl::Vbo colorsVbo;
+		gl::Vao vao;
 		SceneDbgDrawer sceneDbgDrawer;
 		CollisionDbgDrawer collisionDbgDrawer;
 

src/r/Ez.h

@@ -21,7 +21,7 @@ class Ez: public RenderingPass
 		void run();
 
 	private:
-		Fbo fbo; ///< Writes to MS depth FAI
+		gl::Fbo fbo; ///< Writes to MS depth FAI
 		bool enabled;
 };
 

src/r/Hdr.cpp

@@ -25,7 +25,7 @@ Hdr::~Hdr()
 //==============================================================================
 // initFbo                                                                    =
 //==============================================================================
-void Hdr::initFbo(Fbo& fbo, Texture& fai)
+void Hdr::initFbo(gl::Fbo& fbo, Texture& fai)
 {
 	try
 	{

src/r/Hdr.h

@@ -44,9 +44,9 @@ class Hdr: private RenderingPass
 		uint blurringIterationsNum; ///< The blurring iterations of the tone map
 		float blurringDist; ///< Distance in blurring
 		float renderingQuality;
-		Fbo toneFbo;
-		Fbo hblurFbo;
-		Fbo vblurFbo;
+		gl::Fbo toneFbo;
+		gl::Fbo hblurFbo;
+		gl::Fbo vblurFbo;
 		RsrcPtr<ShaderProgram> toneSProg;
 		RsrcPtr<ShaderProgram> hblurSProg;
 		RsrcPtr<ShaderProgram> vblurSProg;
@@ -54,7 +54,7 @@ class Hdr: private RenderingPass
 		Texture hblurFai; ///< pass0Fai with the horizontal blur FAI
 		Texture fai; ///< The final FAI
 
-		void initFbo(Fbo& fbo, Texture& fai);
+		void initFbo(gl::Fbo& fbo, Texture& fai);
 };
 
 

src/r/Is.h

@@ -36,12 +36,12 @@ class Is: private RenderingPass
 	private:
 		Sm sm; ///< Shadowmapping pass
 		Smo smo; /// Stencil masking optimizations pass
-		Fbo fbo; ///< This FBO writes to the Is::fai
+		gl::Fbo fbo; ///< This FBO writes to the Is::fai
 		Texture fai; ///< The one and only FAI
 		uint stencilRb; ///< Illumination stage stencil buffer
 		Texture copyMsDepthFai;
-		Fbo readFbo;
-		Fbo writeFbo;
+		gl::Fbo readFbo;
+		gl::Fbo writeFbo;
 		/// Illumination stage ambient pass shader program
 		RsrcPtr<ShaderProgram> ambientPassSProg;
 		/// Illumination stage point light shader program

src/r/MainRenderer.cpp

@@ -43,7 +43,7 @@ void MainRenderer::init(const RendererInitializer& initializer_)
 
 	sProg.loadRsrc("shaders/Final.glsl");
 
-	dbgTq.reset(new TimeQuery);
+	dbgTq.reset(new gl::TimeQuery);
 
 	//
 	// init the offscreen Renderer

src/r/MainRenderer.h

@@ -52,7 +52,7 @@ class MainRenderer: public Renderer
 		/// @name Profiling stuff
 		/// @{
 		double dbgTime;
-		boost::scoped_ptr<TimeQuery> dbgTq;
+		boost::scoped_ptr<gl::TimeQuery> dbgTq;
 		/// @}
 
 		RsrcPtr<ShaderProgram> sProg; ///< Final pass' shader program

src/r/Ms.h

@@ -31,7 +31,7 @@ class Ms: public RenderingPass
 
 	private:
 		Ez ez; /// EarlyZ pass
-		Fbo fbo;
+		gl::Fbo fbo;
 		Texture normalFai; ///< The FAI for normals
 		Texture diffuseFai; ///< The FAI for diffuse color
 		Texture specularFai; ///< The FAI for specular color and shininess

src/r/Pps.h

@@ -46,8 +46,8 @@ class Pps: private RenderingPass
 		Bl bl;
 		/// @}
 
-		Fbo prePassFbo;
-		Fbo postPassFbo;
+		gl::Fbo prePassFbo;
+		gl::Fbo postPassFbo;
 
 		RsrcPtr<ShaderProgram> prePassSProg;
 		RsrcPtr<ShaderProgram> postPassSProg;

src/r/Renderer.cpp

@@ -70,10 +70,10 @@ void Renderer::init(const RendererInitializer& initializer)
 	quadVao.attachElementArrayBufferVbo(quadVertIndecesVbo);
 
 	// Other
-	msTq.reset(new TimeQuery);
-	isTq.reset(new TimeQuery);
-	ppsTq.reset(new TimeQuery);
-	bsTq.reset(new TimeQuery);
+	msTq.reset(new gl::TimeQuery);
+	isTq.reset(new gl::TimeQuery);
+	ppsTq.reset(new gl::TimeQuery);
+	bsTq.reset(new gl::TimeQuery);
 }
 
 

src/r/Renderer.h

@@ -24,6 +24,8 @@ class Camera;
 struct RendererInitializer;
 class ModelNode;
 
+
+/// Renderer namespace
 namespace r {
 
 
@@ -125,7 +127,7 @@ class Renderer
 		/// @name Profiling stuff
 		/// @{
 		double msTime, isTime, ppsTime, bsTime;
-		boost::scoped_ptr<TimeQuery> msTq, isTq, ppsTq, bsTq;
+		boost::scoped_ptr<gl::TimeQuery> msTq, isTq, ppsTq, bsTq;
 		bool enableStagesProfilingFlag;
 		/// @}
 
@@ -160,9 +162,9 @@ class Renderer
 
 		/// @name For drawing a quad into the active framebuffer
 		/// @{
-		Vbo quadPositionsVbo; ///< The VBO for quad positions
-		Vbo quadVertIndecesVbo; ///< The VBO for quad array buffer elements
-		Vao quadVao; ///< This VAO is used everywhere except material stage
+		gl::Vbo quadPositionsVbo; ///< The VBO for quad positions
+		gl::Vbo quadVertIndecesVbo; ///< The VBO for quad array buffer elements
+		gl::Vao quadVao; ///< This VAO is used everywhere except material stage
 		/// @}
 };
 

src/r/Sm.h

@@ -46,7 +46,7 @@ class Sm: private RenderingPass
 		/// used
 		struct Level
 		{
-			Fbo fbo; ///< Illumination stage shadowmapping FBO
+			gl::Fbo fbo; ///< Illumination stage shadowmapping FBO
 			Texture shadowMap; ///< The shadowmap for that level
 			uint resolution; ///< The shadowmap's resolution
 			bool bilinear; ///< Enable bilinar filtering in shadowmap

src/r/Smo.h

@@ -35,7 +35,7 @@ class Smo: public RenderingPass
 			~Geom();
 
 			RsrcPtr<Mesh> mesh;
-			Vao vao;
+			gl::Vao vao;
 		};
 
 		Geom sphereGeom;

src/r/Ssao.cpp

@@ -12,7 +12,7 @@ namespace r {
 //==============================================================================
 // createFbo                                                                   =
 //==============================================================================
-void Ssao::createFbo(Fbo& fbo, Texture& fai)
+void Ssao::createFbo(gl::Fbo& fbo, Texture& fai)
 {
 	try
 	{

src/r/Ssao.h

@@ -40,15 +40,15 @@ class Ssao: private RenderingPass
 		bool enabled;
 		float renderingQuality;
 		float blurringIterationsNum;
-		Fbo ssaoFbo;
-		Fbo hblurFbo;
-		Fbo vblurFbo;
+		gl::Fbo ssaoFbo;
+		gl::Fbo hblurFbo;
+		gl::Fbo vblurFbo;
 		RsrcPtr<Texture> noiseMap;
 		RsrcPtr<ShaderProgram> ssaoSProg;
 		RsrcPtr<ShaderProgram> hblurSProg;
 		RsrcPtr<ShaderProgram> vblurSProg;
 
-		void createFbo(Fbo& fbo, Texture& fai);
+		void createFbo(gl::Fbo& fbo, Texture& fai);
 };
 
 

src/rsrc/Mesh.h

@@ -36,7 +36,7 @@ class Mesh
 
 		/// @name Accessors
 		/// @{
-		const Vbo& getVbo(Vbos id) const {return vbos[id];}
+		const gl::Vbo& getVbo(Vbos id) const {return vbos[id];}
 		GETTER_R_BY_VAL(uint, vertIdsNum, getVertIdsNum)
 		GETTER_R(cln::Obb, visibilityShape, getVisibilityShape)
 		GETTER_R_BY_VAL(uint, vertsNum, getVertsNum)
@@ -53,7 +53,7 @@ class Mesh
 		/// @}
 
 	private:
-		boost::array<Vbo, VBOS_NUM> vbos; ///< The vertex buffer objects
+		boost::array<gl::Vbo, VBOS_NUM> vbos; ///< The vertex buffer objects
 		uint vertIdsNum; ///< The number of vertex IDs
 		cln::Obb visibilityShape;
 		uint vertsNum;

src/rsrc/ShaderProgramPrePreprocessor.cpp

@@ -67,25 +67,25 @@ void ShaderProgramPrePreprocessor::parseFileForPragmas(
 		{
 			token = &scanner.getNextToken();
 			// pragma
-			if(Parser::isIdentifier(*token, "pragma"))
+			if(parser::isIdentifier(*token, "pragma"))
 			{
 				token = &scanner.getNextToken();
 				// anki
-				if(Parser::isIdentifier(*token, "anki"))
+				if(parser::isIdentifier(*token, "anki"))
 				{
 					// start
 					token = &scanner.getNextToken();
-					if(Parser::isIdentifier(*token, "start"))
+					if(parser::isIdentifier(*token, "start"))
 					{
 						parseStartPragma(scanner, filename, depth, lines);
 					}
 					// include
-					else if(Parser::isIdentifier(*token, "include"))
+					else if(parser::isIdentifier(*token, "include"))
 					{
 						parseIncludePragma(scanner, filename, depth, lines);
 					}
 					// transformFeedbackVarying
-					else if(Parser::isIdentifier(*token,
+					else if(parser::isIdentifier(*token,
 						"transformFeedbackVarying"))
 					{
 						parseTrffbVarying(scanner, filename, depth, lines);
@@ -236,7 +236,7 @@ void ShaderProgramPrePreprocessor::parseStartPragma(scanner::Scanner& scanner,
 
 	for(uint i = 0; i < ST_NUM; i++)
 	{
-		if(Parser::isIdentifier(*token, startTokens[i]))
+		if(parser::isIdentifier(*token, startTokens[i]))
 		{
 			cbp = &shaderStarts[i];
 			name = startTokens[i];

src/rsrc/SkelAnim.cpp

@@ -19,7 +19,7 @@ void SkelAnim::load(const char* filename)
 	}
 	keyframes.resize(token->getValue().getInt());
 
-	Parser::parseArrOfNumbers(scanner, false, false, keyframes.size(),
+	parser::parseArrOfNumbers(scanner, false, false, keyframes.size(),
 		&keyframes[0]);
 
 	// bones num
@@ -49,11 +49,11 @@ void SkelAnim::load(const char* filename)
 			{
 				// parse the quat
 				float tmp[4];
-				Parser::parseArrOfNumbers(scanner, false, true, 4, &tmp[0]);
+				parser::parseArrOfNumbers(scanner, false, true, 4, &tmp[0]);
 
 				// parse the vec3
 				Vec3 trs;
-				Parser::parseArrOfNumbers(scanner, false, true, 3, &trs[0]);
+				parser::parseArrOfNumbers(scanner, false, true, 3, &trs[0]);
 
 				boneAnims[i].bonePoses.push_back(BonePose(Quat(tmp[1], tmp[2],
 					tmp[3], tmp[0]), trs));

src/scene/ModelPatchNode.cpp

@@ -14,7 +14,7 @@ ModelPatchNode::ModelPatchNode(const ModelPatch& modelPatch_,
 	ModelNode* parent)
 :	PatchNode(modelPatch_, parent)
 {
-	boost::array<const Vbo*, Mesh::VBOS_NUM> vboArr;
+	VboArray vboArr;
 
 	for(uint i = 0; i < Mesh::VBOS_NUM; i++)
 	{

src/scene/PatchNode.cpp

@@ -16,8 +16,8 @@ PatchNode::PatchNode(const ModelPatch& modelPatch, SceneNode* parent)
 //==============================================================================
 // createVao                                                                   =
 //==============================================================================
-void PatchNode::createVao(const Material& mtl, const boost::array<const Vbo*,
-	Mesh::VBOS_NUM>& vbos, Vao& vao)
+void PatchNode::createVao(const Material& mtl, const VboArray& vbos,
+	gl::Vao& vao)
 {
 	vao.create();
 

src/scene/PatchNode.h

@@ -20,6 +20,8 @@ class Material;
 class PatchNode: public RenderableNode
 {
 	public:
+		typedef boost::array<const gl::Vbo*, Mesh::VBOS_NUM> VboArray;
+
 		PatchNode(const ModelPatch& modelPatch, SceneNode* parent);
 
 		/// Do nothing
@@ -29,7 +31,7 @@ class PatchNode: public RenderableNode
 		/// @{
 
 		/// Implements RenderableNode::getVao
-		const Vao& getVao(PassType p) const {return vaos[p];}
+		const gl::Vao& getVao(PassType p) const {return vaos[p];}
 
 		/// Implements RenderableNode::getVertIdsNum
 		uint getVertIdsNum() const {return rsrc.getMesh().getVertIdsNum();}
@@ -51,7 +53,7 @@ class PatchNode: public RenderableNode
 		const ModelPatch& rsrc;
 
 		/// The VAOs. All VBOs could be attached except for the vertex weights
-		boost::array<Vao, PASS_TYPES_NUM> vaos;
+		boost::array<gl::Vao, PASS_TYPES_NUM> vaos;
 
 		boost::scoped_ptr<MaterialRuntime> mtlRun; ///< Material runtime
 
@@ -59,7 +61,8 @@ class PatchNode: public RenderableNode
 		/// The location of the uniform variables are hard coded. See
 		/// MaterialVertex.glsl
 		static void createVao(const Material& material,
-			const boost::array<const Vbo*, Mesh::VBOS_NUM>& vbos, Vao& vao);
+			const VboArray& vbos,
+			gl::Vao& vao);
 };
 
 

src/scene/RenderableNode.h

@@ -5,7 +5,9 @@
 #include "rsrc/MaterialCommon.h"
 
 
+namespace gl {
 class Vao;
+}
 class Material;
 class MaterialRuntime;
 
@@ -19,7 +21,7 @@ class RenderableNode: public SceneNode
 		virtual ~RenderableNode();
 
 		/// Get VAO depending the rendering pass
-		virtual const Vao& getVao(PassType p) const = 0;
+		virtual const gl::Vao& getVao(PassType p) const = 0;
 
 		/// Get vert ids number for rendering
 		virtual uint getVertIdsNum() const = 0;

src/scene/SkinPatchNode.cpp

@@ -11,7 +11,7 @@
 SkinPatchNode::SkinPatchNode(const ModelPatch& modelPatch_, SkinNode* parent)
 :	PatchNode(modelPatch_, parent)
 {
-	boost::array<const Vbo*, Mesh::VBOS_NUM> vboArr;
+	VboArray vboArr;
 
 	for(uint i = 0; i < Mesh::VBOS_NUM; i++)
 	{

src/scene/SkinPatchNode.h

@@ -37,14 +37,14 @@ class SkinPatchNode: public PatchNode
 
 		/// @name Accessors
 		/// @{
-		GETTER_R(Vao, tfVao, getTfVao)
-		const Vbo& getTfVbo(uint i) const {return tfVbos[i];}
+		GETTER_R(gl::Vao, tfVao, getTfVao)
+		const gl::Vbo& getTfVbo(uint i) const {return tfVbos[i];}
 		/// @}
 
 	private:
 		/// VBOs that contain the deformed vertex attributes
-		boost::array<Vbo, TFV_NUM> tfVbos;
-		Vao tfVao; ///< For TF passes
+		boost::array<gl::Vbo, TFV_NUM> tfVbos;
+		gl::Vao tfVao; ///< For TF passes
 };
 
 

src/ui/Painter.h

@@ -44,9 +44,9 @@ class Painter
 		Vec4 col;
 		uint tabSize;
 
-		Vbo qPositionsVbo;
-		Vbo qIndecesVbo;
-		Vao qVao;
+		gl::Vbo qPositionsVbo;
+		gl::Vbo qIndecesVbo;
+		gl::Vao qVao;
 
 		Vec2 deviceSize; ///< The size of the device in pixels
 		/// @}

src/ui/PainterDevice.cpp

@@ -27,7 +27,7 @@ Vec2 PainterDevice::getSize() const
 //==============================================================================
 void PainterDevice::create()
 {
-	Fbo::create();
+	gl::Fbo::create();
 	bind();
 
 	setNumOfColorAttachements(1);

src/ui/PainterDevice.h

@@ -13,7 +13,7 @@ namespace ui {
 
 
 /// This actually and FBO but with size info
-class PainterDevice: public Fbo
+class PainterDevice: public gl::Fbo
 {
 	public:
 		/// Constructor

src/util/Util.h

@@ -32,4 +32,5 @@ extern Vec<std::string> getFileLines(const char* filename);
 
 }
 
+
 #endif