Making a few classes singletons

src/Core/App.cpp

@@ -7,6 +7,7 @@
 #include <boost/algorithm/string.hpp>
 #include "App.h"
 #include "Scene.h"
+#include "RendererInitializer.h"
 #include "MainRenderer.h"
 #include "ScriptingEngine.h"
 #include "StdinListener.h"
@@ -14,18 +15,11 @@
 #include "Logger.h"
 
 
-App* app = NULL; ///< The only global var. App constructor sets it
-
-
-bool App::isCreated = false;
-
-
 //======================================================================================================================
 // handleMessageHanlderMsgs                                                                                            =
 //======================================================================================================================
 void App::handleMessageHanlderMsgs(const char* file, int line, const char* func, const char* msg)
 {
-	//printf("gooooooooot.....\n");
 	if(boost::find_first(msg, "Warning") || boost::find_first(msg, "Error"))
 	{
 		std::cerr << "(" << file << ":" << line << " "<< func << ") " << msg << std::flush;
@@ -63,51 +57,29 @@ void App::parseCommandLineArgs(int argc, char* argv[])
 
 
 //======================================================================================================================
-// Constructor                                                                                                         =
+// init                                                                                                                =
 //======================================================================================================================
-App::App(int argc, char* argv[], Object* parent):
-	Object(parent),
-	windowW(1280),
-	windowH(720),
-	terminalColoringEnabled(true),
-	fullScreenFlag(false)
+void App::init(int argc, char* argv[])
 {
-	app = this;
-
-	parseCommandLineArgs(argc, argv);
+	windowW = 1280;
+	windowH = 720;
+	terminalColoringEnabled = true,
+	fullScreenFlag = false;
 
 	// send output to handleMessageHanlderMsgs
-	LoggerSingleton::getInstance().getSignal().connect(boost::bind(&App::handleMessageHanlderMsgs, this, _1, _2, _3, _4));
+	LoggerSingleton::getInstance().getSignal().connect(boost::bind(&App::handleMessageHanlderMsgs,
+	                                                               this, _1, _2, _3, _4));
 
-	printAppInfo();
+	INFO("Initializing the engine...");
 
-	if(isCreated)
-	{
-		throw EXCEPTION("You cannot init a second App instance");
-	}
+	parseCommandLineArgs(argc, argv);
 
-	isCreated = true;
+	printAppInfo();
 
 	// dirs
-	settingsPath = boost::filesystem::path(getenv("HOME")) / ".anki";
-	if(!boost::filesystem::exists(settingsPath))
-	{
-		INFO("Creating settings dir \"" << settingsPath.string() << "\"");
-		boost::filesystem::create_directory(settingsPath);
-	}
-
-	cachePath = settingsPath / "cache";
-	if(boost::filesystem::exists(cachePath))
-	{
-		INFO("Deleting dir \"" << cachePath.string() << "\"");
-		boost::filesystem::remove_all(cachePath);
-	}
-
-	INFO("Creating cache dir \"" << cachePath.string() << "\"");
-	boost::filesystem::create_directory(cachePath);
+	initDirs();
 
 	// create the subsystems. WATCH THE ORDER
-	ScriptingEngine::getInstance().exposeVar("app", this);
 	const char* commonPythonCode =
 	"import sys\n"
 	"from Anki import *\n"
@@ -122,24 +94,28 @@ App::App(int argc, char* argv[], Object* parent):
 	"\n"
 	"class StderrCatcher:\n"
 	"\tdef write(self, str_):\n"
-	"\t\tline = sys._getframe(2).f_lineno\n"
-	"\t\tfile = sys._getframe(2).f_code.co_filename\n"
-	"\t\tfunc = sys._getframe(2).f_code.co_name\n"
+	"\t\tline = sys._getframe(1).f_lineno\n"
+	"\t\tfile = sys._getframe(1).f_code.co_filename\n"
+	"\t\tfunc = sys._getframe(1).f_code.co_name\n"
 	"\t\tLoggerSingleton.getInstance().write(file, line, func, str_)\n"
 	"\n"
 	"sys.stdout = StdoutCatcher()\n"
 	"sys.stderr = StderrCatcher()\n";
-	ScriptingEngine::getInstance().execScript(commonPythonCode);
+	ScriptingEngineSingleton::getInstance().execScript(commonPythonCode);
 
-	mainRenderer = new MainRenderer(this);
-	scene = new Scene(this);
+	scene = new Scene(NULL);
 
 	StdinListenerSingleton::getInstance().start();
 
+	initWindow();
+	initRenderer();
+
 	// other
 	activeCam = NULL;
 	timerTick = 1000 / 40; // in ms. 1000/Hz
 	time = 0;
+
+	INFO("Engine initialization ends");
 }
 
 
@@ -199,6 +175,55 @@ void App::initWindow()
 }
 
 
+//======================================================================================================================
+// initDirs                                                                                                            =
+//======================================================================================================================
+void App::initDirs()
+{
+	settingsPath = boost::filesystem::path(getenv("HOME")) / ".anki";
+	if(!boost::filesystem::exists(settingsPath))
+	{
+		INFO("Creating settings dir \"" << settingsPath.string() << "\"");
+		boost::filesystem::create_directory(settingsPath);
+	}
+
+	cachePath = settingsPath / "cache";
+	if(boost::filesystem::exists(cachePath))
+	{
+		INFO("Deleting dir \"" << cachePath.string() << "\"");
+		boost::filesystem::remove_all(cachePath);
+	}
+
+	INFO("Creating cache dir \"" << cachePath.string() << "\"");
+	boost::filesystem::create_directory(cachePath);
+}
+
+
+//======================================================================================================================
+// initRenderer                                                                                                        =
+//======================================================================================================================
+void App::initRenderer()
+{
+	RendererInitializer initializer;
+	initializer.ms.ez.enabled = false;
+	initializer.dbg.enabled = true;
+	initializer.is.sm.bilinearEnabled = true;
+	initializer.is.sm.enabled = true;
+	initializer.is.sm.pcfEnabled = true;
+	initializer.is.sm.resolution = 512;
+	initializer.pps.hdr.enabled = true;
+	initializer.pps.hdr.renderingQuality = 0.25;
+	initializer.pps.hdr.blurringDist = 1.0;
+	initializer.pps.hdr.blurringIterationsNum = 2;
+	initializer.pps.hdr.exposure = 4.0;
+	initializer.pps.ssao.blurringIterationsNum = 2;
+	initializer.pps.ssao.enabled = true;
+	initializer.pps.ssao.renderingQuality = 0.5;
+	initializer.mainRendererQuality = 1.0;
+	MainRendererSingleton::getInstance().init(initializer);
+}
+
+
 //======================================================================================================================
 // togleFullScreen                                                                                                     =
 //======================================================================================================================
@@ -335,7 +360,7 @@ void App::execStdinScpripts()
 
 		try
 		{
-			ScriptingEngine::getInstance().execScript(cmd.c_str(), "command line input");
+			ScriptingEngineSingleton::getInstance().execScript(cmd.c_str(), "command line input");
 		}
 		catch(Exception& e)
 		{

src/Core/App.h

@@ -3,26 +3,21 @@
 
 #include <SDL/SDL.h>
 #include <boost/filesystem.hpp>
-#include "Object.h"
 #include "StdTypes.h"
 #include "Properties.h"
 #include "Exception.h"
+#include "Singleton.h"
 
 
 class StdinListener;
 class Scene;
-class MainRenderer;
 class Camera;
 class Input;
 
 
-/// The one and only global variable
-extern class App* app;
-
-
 /// This class holds all the global objects of the application and its also responsible for some of the SDL stuff.
 /// It should be singleton
-class App: public Object
+class App
 {
 	PROPERTY_R(uint, windowW, getWindowWidth) ///< The main window width
 	PROPERTY_R(uint, windowH, getWindowHeight) ///< The main window height
@@ -32,9 +27,9 @@ class App: public Object
 	public:
 		uint timerTick;
 
-		App(int argc, char* argv[], Object* parent = NULL);
+		App() {}
 		~App() {}
-		void initWindow();
+		void init(int argc, char* argv[]);
 		void quit(int code);
 		void waitForNextFrame();
 		void togleFullScreen();
@@ -53,7 +48,6 @@ class App: public Object
 		/// @{
 		bool isTerminalColoringEnabled() const;
 		Scene& getScene();
-		MainRenderer& getMainRenderer();
 		Camera* getActiveCam() {return activeCam;}
 		void setActiveCam(Camera* cam) {activeCam = cam;}
 		/// @}
@@ -62,7 +56,6 @@ class App: public Object
 		static uint getTicks();
 
 	private:
-		static bool isCreated; ///< A flag to ensure one @ref App instance
 		bool terminalColoringEnabled; ///< Terminal coloring for Unix terminals. Default on
 		uint time;
 		SDL_WindowID windowId;
@@ -74,13 +67,16 @@ class App: public Object
 		/// @name Pointers to serious subsystems
 		/// @{
 		Scene* scene;
-		MainRenderer* mainRenderer;
 		/// @}
 
 		void parseCommandLineArgs(int argc, char* argv[]);
 
 		/// A slot to handle the messageHandler's signal
 		void handleMessageHanlderMsgs(const char* file, int line, const char* func, const char* msg);
+
+		void initWindow();
+		void initDirs();
+		void initRenderer();
 };
 
 
@@ -97,11 +93,7 @@ inline Scene& App::getScene()
 }
 
 
-inline MainRenderer& App::getMainRenderer()
-{
-	RASSERT_THROW_EXCEPTION(mainRenderer == NULL);
-	return *mainRenderer;
-}
+typedef Singleton<App> AppSingleton;
 
 
 #endif

src/Core/StdinListener.h

@@ -5,7 +5,7 @@
 #include <boost/thread/mutex.hpp>
 #include <string>
 #include <queue>
-#include <Singleton.h>
+#include "Singleton.h"
 
 
 /// The listener of the stdin.

src/Input/Input.cpp

@@ -55,7 +55,6 @@ void Input::handleEvents()
 
 
 	mouseVelocity = Vec2(0.0);
-	App* app_ = app;
 
 	SDL_Event event_;
 	while(SDL_PollEvent(&event_))
@@ -85,8 +84,8 @@ void Input::handleEvents()
 				mousePos.x = event_.button.x;
 				mousePos.y = event_.button.y;
 
-				mousePosNdc.x = (2.0 * mousePos.x) / (float)app_->getWindowWidth() - 1.0;
-				mousePosNdc.y = 1.0 - (2.0 * mousePos.y) / (float)app_->getWindowHeight();
+				mousePosNdc.x = (2.0 * mousePos.x) / (float)AppSingleton::getInstance().getWindowWidth() - 1.0;
+				mousePosNdc.y = 1.0 - (2.0 * mousePos.y) / (float)AppSingleton::getInstance().getWindowHeight();
 
 				if(warpMouse)
 				{
@@ -95,7 +94,8 @@ void Input::handleEvents()
 					if(mousePosNdc == Vec2(0.0))
 						break;
 
-					SDL_WarpMouse(app->getWindowWidth()/2, app->getWindowHeight()/2);
+					SDL_WarpMouse(AppSingleton::getInstance().getWindowWidth() / 2,
+					              AppSingleton::getInstance().getWindowHeight() / 2);
 				}
 
 				mouseVelocity = mousePosNdc - prevMousePosNdc;
@@ -103,7 +103,7 @@ void Input::handleEvents()
 			}
 
 			case SDL_QUIT:
-				app_->quit(1);
+				AppSingleton::getInstance().quit(1);
 				break;
 		}
 	}

src/Main.cpp

@@ -73,7 +73,7 @@ void initPhysics()
 	init.shape = groundShape;
 	init.startTrf = groundTransform;
 
-	new RigidBody(app->getScene().getPhysics(), init);
+	new RigidBody(AppSingleton::getInstance().getScene().getPhysics(), init);
 
 
 	/*{
@@ -109,39 +109,21 @@ void initPhysics()
 //======================================================================================================================
 void init()
 {
-	INFO("Engine initializing...");
+	INFO("Other init...");
 
 	srand(unsigned(time(NULL)));
 	mathSanityChecks();
 
-	app->initWindow();
-	uint ticks = app->getTicks();
-
-	RendererInitializer initializer;
-	initializer.ms.ez.enabled = false;
-	initializer.dbg.enabled = true;
-	initializer.is.sm.bilinearEnabled = true;
-	initializer.is.sm.enabled = true;
-	initializer.is.sm.pcfEnabled = true;
-	initializer.is.sm.resolution = 512;
-	initializer.pps.hdr.enabled = true;
-	initializer.pps.hdr.renderingQuality = 0.25;
-	initializer.pps.hdr.blurringDist = 1.0;
-	initializer.pps.hdr.blurringIterationsNum = 2;
-	initializer.pps.hdr.exposure = 4.0;
-	initializer.pps.ssao.blurringIterationsNum = 2;
-	initializer.pps.ssao.enabled = true;
-	initializer.pps.ssao.renderingQuality = 0.5;
-	initializer.mainRendererQuality = 1.0;
-	app->getMainRenderer().init(initializer);
+	uint ticks = AppSingleton::getInstance().getTicks();
+
 	//Ui::init();
 
 	// camera
-	Camera* cam = new Camera(app->getMainRenderer().getAspectRatio()*toRad(60.0), toRad(60.0), 0.5, 200.0);
+	Camera* cam = new Camera(MainRendererSingleton::getInstance().getAspectRatio()*toRad(60.0), toRad(60.0), 0.5, 200.0);
 	cam->moveLocalY(3.0);
 	cam->moveLocalZ(5.7);
 	cam->moveLocalX(-0.3);
-	app->setActiveCam(cam);
+	AppSingleton::getInstance().setActiveCam(cam);
 
 	// lights
 	point_lights[0] = new PointLight();
@@ -234,7 +216,7 @@ void init()
 	/*PhyCharacter::Initializer init;
 	init.sceneNode = imp;
 	init.startTrf = Transform(Vec3(0, 40, 0), Mat3::getIdentity(), 1.0);
-	character = new PhyCharacter(app->getScene().getPhysics(), init);*/
+	character = new PhyCharacter(AppSingleton::getInstance().getScene().getPhysics(), init);*/
 
 	// crate
 	/*crate = new MeshNode;
@@ -271,9 +253,9 @@ void mainLoop()
 		float scale = 0.01;
 
 		// move the camera
-		static SceneNode* mover = app->getActiveCam();
+		static SceneNode* mover = AppSingleton::getInstance().getActiveCam();
 
-		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_1)) mover = app->getActiveCam();
+		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_1)) mover = AppSingleton::getInstance().getActiveCam();
 		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_2)) mover = point_lights[0];
 		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_3)) mover = spot_lights[0];
 		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_4)) mover = point_lights[1];
@@ -305,7 +287,7 @@ void mainLoop()
 		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_PAGEUP)) mover->getLocalTransform().scale += scale ;
 		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_PAGEDOWN)) mover->getLocalTransform().scale -= scale ;
 
-		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_K)) app->getActiveCam()->lookAtPoint(point_lights[0]->getWorldTransform().origin);
+		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_K)) AppSingleton::getInstance().getActiveCam()->lookAtPoint(point_lights[0]->getWorldTransform().origin);
 
 		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_I))
 			character->moveForward(0.1);
@@ -323,18 +305,17 @@ void mainLoop()
 		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_Y) == 1)
 		{
 			INFO("Exec script");
-			ScriptingEngine::getInstance().exposeVar("app", app);
-			ScriptingEngine::getInstance().execScript(Util::readFile("test.py").c_str());
+			ScriptingEngineSingleton::getInstance().execScript(Util::readFile("test.py").c_str());
 		}
 
 		mover->getLocalTransform().rotation.reorthogonalize();
 
-		app->execStdinScpripts();
-		app->getScene().getPhysics().update(crntTime);
-		app->getScene().updateAllControllers();
-		app->getScene().updateAllWorldStuff();
+		AppSingleton::getInstance().execStdinScpripts();
+		AppSingleton::getInstance().getScene().getPhysics().update(crntTime);
+		AppSingleton::getInstance().getScene().updateAllControllers();
+		AppSingleton::getInstance().getScene().updateAllWorldStuff();
 
-		app->getMainRenderer().render(*app->getActiveCam());
+		MainRendererSingleton::getInstance().render(*AppSingleton::getInstance().getActiveCam());
 
 		//map.octree.root->bounding_box.render();
 
@@ -342,7 +323,7 @@ void mainLoop()
 		/*Ui::setColor(Vec4(1.0, 1.0, 1.0, 1.0));
 		Ui::setPos(-0.98, 0.95);
 		Ui::setFontWidth(0.03);*/
-		//Ui::printf("frame:%d fps:%dms\n", app->getMainRenderer().getFramesNum(), (App::getTicks()-ticks_));
+		//Ui::printf("frame:%d fps:%dms\n", AppSingleton::getInstance().getMainRenderer().getFramesNum(), (App::getTicks()-ticks_));
 		//Ui::print("Movement keys: arrows,w,a,s,d,q,e,shift,space\nSelect objects: keys 1 to 5\n");
 		/*Ui::printf("Mover: Pos(%.2f %.2f %.2f) Angs(%.2f %.2f %.2f)", mover->translationWspace.x, mover->translationWspace.y, mover->translationWspace.z,
 								 toDegrees(Euler(mover->rotationWspace).x), toDegrees(Euler(mover->rotationWspace).y), toDegrees(Euler(mover->rotationWspace).z));*/
@@ -350,25 +331,25 @@ void mainLoop()
 		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_ESCAPE))
 			break;
 		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_F11))
-			app->togleFullScreen();
+			AppSingleton::getInstance().togleFullScreen();
 		if(InputSingleton::getInstance().getKey(SDL_SCANCODE_F12) == 1)
-			app->getMainRenderer().takeScreenshot("gfx/screenshot.jpg");
+			MainRendererSingleton::getInstance().takeScreenshot("gfx/screenshot.jpg");
 
 		/*char str[128];
-		static string scrFile = (app->getSettingsPath() / "capt" / "%06d.jpg").string();
-		sprintf(str, scrFile.c_str(), app->getMainRenderer().getFramesNum());
-		app->getMainRenderer().takeScreenshot(str);*/
+		static string scrFile = (AppSingleton::getInstance().getSettingsPath() / "capt" / "%06d.jpg").string();
+		sprintf(str, scrFile.c_str(), AppSingleton::getInstance().getMainRenderer().getFramesNum());
+		AppSingleton::getInstance().getMainRenderer().takeScreenshot(str);*/
 
 		// std stuff follow
-		app->swapBuffers();
+		AppSingleton::getInstance().swapBuffers();
 		if(1)
 		{
-			//if(app->getMainRenderer().getFramesNum() == 100) app->getMainRenderer().takeScreenshot("gfx/screenshot.tga");
-			app->waitForNextFrame();
+			//if(AppSingleton::getInstance().getMainRenderer().getFramesNum() == 100) AppSingleton::getInstance().getMainRenderer().takeScreenshot("gfx/screenshot.tga");
+			AppSingleton::getInstance().waitForNextFrame();
 		}
 		else
 		{
-			if(app->getMainRenderer().getFramesNum() == 5000)
+			if(MainRendererSingleton::getInstance().getFramesNum() == 5000)
 			{
 				break;
 			}
@@ -386,13 +367,13 @@ int main(int argc, char* argv[])
 {
 	try
 	{
-		new App(argc, argv);
+		AppSingleton::getInstance().init(argc, argv);
 		init();
 
 		mainLoop();
 
 		INFO("Exiting...");
-		app->quit(EXIT_SUCCESS);
+		AppSingleton::getInstance().quit(EXIT_SUCCESS);
 		return 0;
 	}
 	catch(std::exception& e)

src/Renderer/Bs.cpp

@@ -87,8 +87,8 @@ void Bs::run()
 	glDepthMask(false);
 
 	// render the models
-	Vec<ModelNode*>::const_iterator it = app->getScene().modelNodes.begin();
-	for(; it != app->getScene().modelNodes.end(); ++it)
+	Vec<ModelNode*>::const_iterator it = AppSingleton::getInstance().getScene().modelNodes.begin();
+	for(; it != AppSingleton::getInstance().getScene().modelNodes.end(); ++it)
 	{
 		const ModelNode& mn = *(*it);
 		boost::ptr_vector<ModelNodePatch>::const_iterator it = mn.getModelNodePatches().begin();

src/Renderer/Bs.h

@@ -15,7 +15,7 @@ class ShaderProg;
 class Bs: public RenderingPass
 {
 	public:
-		Bs(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
+		Bs(Renderer& r_): RenderingPass(r_) {}
 		void init(const RendererInitializer& initializer);
 		void run();
 

src/Renderer/Dbg.cpp

@@ -12,12 +12,13 @@
 //======================================================================================================================
 // Constructor                                                                                                         =
 //======================================================================================================================
-Dbg::Dbg(Renderer& r_, Object* parent):
-	RenderingPass(r_, parent),
+Dbg::Dbg(Renderer& r_):
+	RenderingPass(r_),
 	showAxisEnabled(false),
 	showLightsEnabled(true),
 	showSkeletonsEnabled(true),
-	showCamerasEnabled(true)
+	showCamerasEnabled(true),
+	sceneDbgDrawer(*this)
 {}
 
 
@@ -244,7 +245,6 @@ void Dbg::init(const RendererInitializer& initializer)
 	ON_GL_FAIL_THROW_EXCEPTION();
 	modelMat.setIdentity();
 	crntCol = Vec3(1.0, 0.0, 0.0);
-	sceneDbgDrawer = new SceneDbgDrawer(*this, this);
 }
 
 
@@ -269,21 +269,21 @@ void Dbg::run()
 	setModelMat(Mat4::getIdentity());
 	renderGrid();
 
-	Vec<SceneNode*>::const_iterator it = app->getScene().nodes.begin();
-	for(; it != app->getScene().nodes.end(); ++it)
+	Vec<SceneNode*>::const_iterator it = AppSingleton::getInstance().getScene().nodes.begin();
+	for(; it != AppSingleton::getInstance().getScene().nodes.end(); ++it)
 	{
 		const SceneNode& node = *(*it);
 
 		switch(node.type)
 		{
 			case SceneNode::SNT_CAMERA:
-				sceneDbgDrawer->drawCamera(static_cast<const Camera&>(node));
+				sceneDbgDrawer.drawCamera(static_cast<const Camera&>(node));
 				break;
 			case SceneNode::SNT_LIGHT:
-				sceneDbgDrawer->drawLight(static_cast<const Light&>(node));
+				sceneDbgDrawer.drawLight(static_cast<const Light&>(node));
 				break;
 			case SceneNode::SNT_PARTICLE_EMITTER:
-				sceneDbgDrawer->drawParticleEmitter(static_cast<const ParticleEmitter&>(node));
+				sceneDbgDrawer.drawParticleEmitter(static_cast<const ParticleEmitter&>(node));
 				break;
 			default:
 				break;

src/Renderer/Dbg.h

@@ -9,16 +9,14 @@
 #include "Math.h"
 #include "Vbo.h"
 #include "Vao.h"
-
-
-class SceneDbgDrawer;
+#include "SceneDbgDrawer.h"
 
 
 /// Debugging stage
 class Dbg: public RenderingPass
 {
 	public:
-		Dbg(Renderer& r_, Object* parent);
+		Dbg(Renderer& r_);
 		void init(const RendererInitializer& initializer);
 		void run();
 
@@ -63,7 +61,7 @@ class Dbg: public RenderingPass
 		Vbo positionsVbo;
 		Vbo colorsVbo;
 		Vao vao;
-		SceneDbgDrawer* sceneDbgDrawer;
+		SceneDbgDrawer sceneDbgDrawer;
 };
 
 

src/Renderer/Ez.h

@@ -11,7 +11,7 @@
 class Ez: public RenderingPass
 {
 	public:
-		Ez(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
+		Ez(Renderer& r_): RenderingPass(r_) {}
 		bool isEnabled() const {return enabled;}
 		void init(const RendererInitializer& initializer);
 		void run();

src/Renderer/Hdr.h

@@ -25,7 +25,7 @@ class Hdr: private RenderingPass
 	PROPERTY_RW(float, blurringDist, getBlurringDist, setBlurringDist)
 
 	public:
-		Hdr(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
+		Hdr(Renderer& r_): RenderingPass(r_) {}
 		void init(const RendererInitializer& initializer);
 		void run();
 

src/Renderer/Is.cpp

@@ -17,10 +17,10 @@
 //======================================================================================================================
 // Constructor                                                                                                         =
 //======================================================================================================================
-Is::Is(Renderer& r_, Object* parent):
-	RenderingPass(r_, parent),
-	sm(new Sm(r_, this)),
-	smo(new Smo(r_, this))
+Is::Is(Renderer& r_):
+	RenderingPass(r_),
+	sm(r_),
+	smo(r_)
 {}
 
 
@@ -122,8 +122,8 @@ 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");
@@ -139,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";
@@ -214,7 +214,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
@@ -250,9 +250,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();
@@ -265,7 +265,7 @@ void Is::spotLightPass(const SpotLight& light)
 	}
 
 	// stencil optimization
-	smo->run(light);
+	smo.run(light);
 
 	// set the texture
 	light.lightData->getTexture().setRepeat(false);
@@ -273,7 +273,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();
 	}
@@ -310,9 +310,9 @@ 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
@@ -334,7 +334,7 @@ void Is::run()
 	glDisable(GL_DEPTH_TEST);
 
 	// ambient pass
-	ambientPass(app->getScene().getAmbientCol());
+	ambientPass(AppSingleton::getInstance().getScene().getAmbientCol());
 
 	// light passes
 	glEnable(GL_BLEND);
@@ -345,9 +345,9 @@ void Is::run()
 	calcPlanes();
 
 	// for all lights
-	for(uint i=0; i<app->getScene().lights.size(); i++)
+	for(uint i=0; i<AppSingleton::getInstance().getScene().lights.size(); i++)
 	{
-		const Light& light = *app->getScene().lights[i];
+		const Light& light = *AppSingleton::getInstance().getScene().lights[i];
 		switch(light.getType())
 		{
 			case Light::LT_POINT:

src/Renderer/Is.h

@@ -10,12 +10,12 @@
 #include "Properties.h"
 #include "Vbo.h"
 #include "Vao.h"
+#include "Sm.h"
+#include "Smo.h"
 
 
 class PointLight;
 class SpotLight;
-class Sm;
-class Smo;
 
 
 /// Illumination stage
@@ -24,13 +24,13 @@ class Is: private RenderingPass
 	PROPERTY_R(Texture, fai, getFai) ///< The one and only FAI
 
 	public:
-		Is(Renderer& r_, Object* parent);
+		Is(Renderer& r_);
 		void init(const RendererInitializer& initializer);
 		void run();
 
 	private:
-		Sm* sm; ///< Shadowmapping pass
-		Smo* smo; /// Stencil masking optimizations pass
+		Sm sm; ///< Shadowmapping pass
+		Smo smo; /// Stencil masking optimizations pass
 		Fbo fbo; ///< This FBO writes to the Is::fai
 		uint stencilRb; ///< Illumination stage stencil buffer
 		RsrcPtr<ShaderProg> ambientPassSProg; ///< Illumination stage ambient pass shader program

src/Renderer/MainRenderer.cpp

@@ -17,6 +17,7 @@
 //======================================================================================================================
 void MainRenderer::init(const RendererInitializer& initializer_)
 {
+	INFO("Initializing main renderer...");
 	initGl();
 
 	sProg.loadRsrc("shaders/Final.glsl");
@@ -26,10 +27,11 @@ void MainRenderer::init(const RendererInitializer& initializer_)
 	//
 	RendererInitializer initializer = initializer_;
 	renderingQuality = initializer.mainRendererQuality;
-	initializer.width = app->getWindowWidth() * renderingQuality;
-	initializer.height = app->getWindowHeight() * renderingQuality;
+	initializer.width = AppSingleton::getInstance().getWindowWidth() * renderingQuality;
+	initializer.height = AppSingleton::getInstance().getWindowHeight() * renderingQuality;
 	Renderer::init(initializer);
-	dbg->init(initializer);
+	dbg.init(initializer);
+	INFO("Main renderer initialized");
 }
 
 
@@ -88,18 +90,18 @@ void MainRenderer::initGl()
 void MainRenderer::render(Camera& cam_)
 {
 	Renderer::render(cam_);
-	dbg->run();
+	dbg.run();
 
 	//
 	// Render the PPS FAI to the framebuffer
 	//
 	Fbo::unbind();
-	setViewport(0, 0, app->getWindowWidth(), app->getWindowHeight());
+	setViewport(0, 0, AppSingleton::getInstance().getWindowWidth(), AppSingleton::getInstance().getWindowHeight());
 	glDisable(GL_DEPTH_TEST);
 	glDisable(GL_BLEND);
 	sProg->bind();
 	//sProg->findUniVar("rasterImage")->setTexture(pps->getSsao().getFai(), 0);
-	sProg->findUniVar("rasterImage")->setTexture(pps->getPostPassFai(), 0);
+	sProg->findUniVar("rasterImage")->setTexture(pps.getPostPassFai(), 0);
 	drawQuad();
 }
 

src/Renderer/MainRenderer.h

@@ -2,13 +2,14 @@
 #define MAIN_RENDERER_H
 
 #include "Renderer.h"
+#include "Singleton.h"
 
 
 /// Main onscreen renderer
 class MainRenderer: public Renderer
 {
 	public:
-		MainRenderer(Object* parent);
+		MainRenderer();
 
 		~MainRenderer() throw() {}
 
@@ -17,7 +18,7 @@ class MainRenderer: public Renderer
 		int& getScreenshotJpegQuality() {return screenshotJpegQuality;}
 		void setScreenshotJpegQuality(int i) {screenshotJpegQuality = i;}
 		float getRenderingQuality() const {return renderingQuality;}
-		Dbg& getDbg() {return *dbg;}
+		Dbg& getDbg() {return dbg;}
 		/// @}
 
 		/// The same as Renderer::init but with additional initialization. @see Renderer::init
@@ -34,7 +35,7 @@ class MainRenderer: public Renderer
 	private:
 		/// @name Passes
 		/// @{
-		Dbg* dbg; ///< Debugging rendering stage. Only the main renderer has it
+		Dbg dbg; ///< Debugging rendering stage. Only the main renderer has it
 		/// @}
 
 		RsrcPtr<ShaderProg> sProg; ///< Final pass' shader program
@@ -50,10 +51,13 @@ class MainRenderer: public Renderer
 };
 
 
-inline MainRenderer::MainRenderer(Object* parent):
-	Renderer(parent),
-	dbg(new Dbg(*this, this)),
+inline MainRenderer::MainRenderer():
+	dbg(*this),
 	screenshotJpegQuality(90)
 {}
 
+
+typedef Singleton<MainRenderer> MainRendererSingleton; ///< Make the MainRenderer singleton class
+
+
 #endif

src/Renderer/Ms.cpp

@@ -8,9 +8,9 @@
 //======================================================================================================================
 // Constructor                                                                                                         =
 //======================================================================================================================
-Ms::Ms(Renderer& r_, Object* parent):
-	RenderingPass(r_, parent),
-	ez(new Ez(r_, this))
+Ms::Ms(Renderer& r_):
+	RenderingPass(r_),
+	ez(r_)
 {}
 
 
@@ -59,7 +59,7 @@ void Ms::init(const RendererInitializer& initializer)
 		throw EXCEPTION("Cannot create deferred shading material stage FBO: " + e.what());
 	}
 
-	ez->init(initializer);
+	ez.init(initializer);
 }
 
 
@@ -68,14 +68,14 @@ void Ms::init(const RendererInitializer& initializer)
 //======================================================================================================================
 void Ms::run()
 {
-	if(ez->isEnabled())
+	if(ez.isEnabled())
 	{
-		ez->run();
+		ez.run();
 	}
 
 	fbo.bind();
 
-	if(!ez->isEnabled())
+	if(!ez.isEnabled())
 	{
 		glClear(GL_DEPTH_BUFFER_BIT);
 	}
@@ -87,7 +87,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);
@@ -97,7 +97,7 @@ void Ms::run()
 	r.renderAllModelNodes(r.getCamera(), Renderer::MNRT_MS);
 
 	// restore depth
-	if(ez->isEnabled())
+	if(ez.isEnabled())
 	{
 		glDepthMask(true);
 		glDepthFunc(GL_LESS);

src/Renderer/Ms.h

@@ -5,10 +5,10 @@
 #include "Texture.h"
 #include "Fbo.h"
 #include "Properties.h"
+#include "Ez.h"
 
 
 class RendererInitializer;
-class Ez;
 
 
 /// Material stage
@@ -20,12 +20,12 @@ class Ms: public RenderingPass
 	PROPERTY_R(Texture, depthFai, getDepthFai) ///< The FAI for depth
 
 	public:
-		Ms(Renderer& r_, Object* parent);
+		Ms(Renderer& r_);
 		void init(const RendererInitializer& initializer);
 		void run();
 
 	private:
-		Ez* ez;
+		Ez ez;
 		Fbo fbo;
 };
 

src/Renderer/PhyDbgDrawer.cpp

@@ -1,6 +1,5 @@
 #include "PhyDbgDrawer.h"
 #include "MainRenderer.h"
-#include "App.h"
 #include "BtAndAnkiConvertors.h"
 #include "Logger.h"
 
@@ -10,7 +9,7 @@
 //======================================================================================================================
 void PhyDbgDrawer::drawLine(const btVector3& from, const btVector3& to, const btVector3& color)
 {
-	app->getMainRenderer().getDbg().drawLine(toAnki(from), toAnki(to), Vec4(toAnki(color), 1.0));
+	MainRendererSingleton::getInstance().getDbg().drawLine(toAnki(from), toAnki(to), Vec4(toAnki(color), 1.0));
 }
 
 
@@ -19,9 +18,9 @@ void PhyDbgDrawer::drawLine(const btVector3& from, const btVector3& to, const bt
 //======================================================================================================================
 void PhyDbgDrawer::drawSphere(btScalar radius, const btTransform& transform, const btVector3& color)
 {
-	app->getMainRenderer().getDbg().setColor(toAnki(color));
-	app->getMainRenderer().getDbg().setModelMat(Mat4(toAnki(transform)));
-	app->getMainRenderer().getDbg().drawSphere(radius);
+	MainRendererSingleton::getInstance().getDbg().setColor(toAnki(color));
+	MainRendererSingleton::getInstance().getDbg().setModelMat(Mat4(toAnki(transform)));
+	MainRendererSingleton::getInstance().getDbg().drawSphere(radius);
 }
 
 
@@ -37,9 +36,9 @@ void PhyDbgDrawer::drawBox(const btVector3& min, const btVector3& max, const btV
 	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().getDbg().setModelMat(trf);
-	app->getMainRenderer().getDbg().setColor(toAnki(color));
-	app->getMainRenderer().getDbg().drawCube(1.0);
+	MainRendererSingleton::getInstance().getDbg().setModelMat(trf);
+	MainRendererSingleton::getInstance().getDbg().setColor(toAnki(color));
+	MainRendererSingleton::getInstance().getDbg().drawCube(1.0);
 }
 
 
@@ -56,9 +55,9 @@ void PhyDbgDrawer::drawBox(const btVector3& min, const btVector3& max, const btT
 	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().getDbg().setModelMat(trf);
-	app->getMainRenderer().getDbg().setColor(toAnki(color));
-	app->getMainRenderer().getDbg().drawCube(1.0);
+	MainRendererSingleton::getInstance().getDbg().setModelMat(trf);
+	MainRendererSingleton::getInstance().getDbg().setColor(toAnki(color));
+	MainRendererSingleton::getInstance().getDbg().drawCube(1.0);
 }
 
 

src/Renderer/Pps.cpp

@@ -7,10 +7,10 @@
 //======================================================================================================================
 // Constructor                                                                                                         =
 //======================================================================================================================
-Pps::Pps(Renderer& r_, Object* parent):
-	RenderingPass(r_, parent),
-	hdr(new Hdr(r_, this)),
-	ssao(new Ssao(r_, this))
+Pps::Pps(Renderer& r_):
+	RenderingPass(r_),
+	hdr(r_),
+	ssao(r_)
 {}
 
 
@@ -43,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";
@@ -63,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";
@@ -80,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
 	{
@@ -111,9 +111,9 @@ void Pps::init(const RendererInitializer& initializer)
 //======================================================================================================================
 void Pps::runPrePass()
 {
-	if(ssao->isEnabled())
+	if(ssao.isEnabled())
 	{
-		ssao->run();
+		ssao.run();
 	}
 
 	prePassFbo.bind();
@@ -125,9 +125,9 @@ void Pps::runPrePass()
 	prePassSProg->bind();
 	prePassSProg->findUniVar("isFai")->setTexture(r.getIs().getFai(), 0);
 
-	if(ssao->isEnabled())
+	if(ssao.isEnabled())
 	{
-		prePassSProg->findUniVar("ppsSsaoFai")->setTexture(ssao->getFai(), 1);
+		prePassSProg->findUniVar("ppsSsaoFai")->setTexture(ssao.getFai(), 1);
 	}
 
 	r.drawQuad();
@@ -141,9 +141,9 @@ void Pps::runPrePass()
 //======================================================================================================================
 void Pps::runPostPass()
 {
-	if(hdr->isEnabled())
+	if(hdr.isEnabled())
 	{
-		hdr->run();
+		hdr.run();
 	}
 
 	postPassFbo.bind();
@@ -155,9 +155,9 @@ void Pps::runPostPass()
 	postPassSProg->bind();
 	postPassSProg->findUniVar("ppsPrePassFai")->setTexture(prePassFai, 0);
 
-	if(hdr->isEnabled())
+	if(hdr.isEnabled())
 	{
-		postPassSProg->findUniVar("ppsHdrFai")->setTexture(hdr->getFai(), 1);
+		postPassSProg->findUniVar("ppsHdrFai")->setTexture(hdr.getFai(), 1);
 	}
 
 	r.drawQuad();

src/Renderer/Pps.h

@@ -5,10 +5,10 @@
 #include "Fbo.h"
 #include "Texture.h"
 #include "RsrcPtr.h"
+#include "Hdr.h"
+#include "Ssao.h"
 
 
-class Hdr;
-class Ssao;
 class ShaderProg;
 
 
@@ -21,22 +21,22 @@ class Pps: private RenderingPass
 	PROPERTY_R(Texture, postPassFai, getPostPassFai)
 
 	public:
-		Pps(Renderer& r_, Object* parent);
+		Pps(Renderer& r_);
 		void init(const RendererInitializer& initializer);
 		void runPrePass();
 		void runPostPass();
 
 		/// @name Accessors
 		/// @{
-		Hdr& getHdr() {return *hdr;}
-		Ssao& getSsao() {return *ssao;}
+		Hdr& getHdr() {return hdr;}
+		Ssao& getSsao() {return ssao;}
 		/// @}
 
 	private:
 		/// @name Passes
 		/// @{
-		Hdr* hdr;
-		Ssao* ssao;
+		Hdr hdr;
+		Ssao ssao;
 		/// @}
 
 		Fbo prePassFbo;

src/Renderer/Renderer.cpp

@@ -14,14 +14,13 @@
 //======================================================================================================================
 // Constructor                                                                                                         =
 //======================================================================================================================
-Renderer::Renderer(Object* parent):
-	Object(parent),
+Renderer::Renderer():
 	width(640),
 	height(480),
-	ms(new Ms(*this, this)),
-	is(new Is(*this, this)),
-	pps(new Pps(*this, this)),
-	bs(new Bs(*this, this))
+	ms(*this),
+	is(*this),
+	pps(*this),
+	bs(*this)
 {}
 
 
@@ -44,10 +43,10 @@ void Renderer::init(const RendererInitializer& initializer)
 	}
 
 	// init the stages. Careful with the order!!!!!!!!!!
-	ms->init(initializer);
-	is->init(initializer);
-	pps->init(initializer);
-	bs->init(initializer);
+	ms.init(initializer);
+	is.init(initializer);
+	pps.init(initializer);
+	bs.init(initializer);
 
 	// quad VBOs and VAO
 	float quadVertCoords[][2] = {{1.0, 1.0}, {0.0, 1.0}, {0.0, 0.0}, {1.0, 0.0}};
@@ -71,11 +70,11 @@ void Renderer::render(Camera& cam_)
 
 	viewProjectionMat = cam->getProjectionMatrix() * cam->getViewMatrix();
 
-	ms->run();
-	is->run();
-	pps->runPrePass();
-	bs->run();
-	pps->runPostPass();
+	ms.run();
+	is.run();
+	pps.runPrePass();
+	bs.run();
+	pps.runPostPass();
 
 	++framesNum;
 }
@@ -197,37 +196,37 @@ void Renderer::setupShaderProg(const Material& mtl, const ModelNode& modelNode,
 	//
 	if(mtl.getStdUniVar(Material::SUV_MS_NORMAL_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_MS_NORMAL_FAI)->setTexture(ms->getNormalFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_MS_NORMAL_FAI)->setTexture(ms.getNormalFai(), textureUnit++);
 	}
 
 	if(mtl.getStdUniVar(Material::SUV_MS_DIFFUSE_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_MS_DIFFUSE_FAI)->setTexture(ms->getDiffuseFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_MS_DIFFUSE_FAI)->setTexture(ms.getDiffuseFai(), textureUnit++);
 	}
 
 	if(mtl.getStdUniVar(Material::SUV_MS_SPECULAR_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_MS_SPECULAR_FAI)->setTexture(ms->getSpecularFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_MS_SPECULAR_FAI)->setTexture(ms.getSpecularFai(), textureUnit++);
 	}
 
 	if(mtl.getStdUniVar(Material::SUV_MS_DEPTH_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_MS_DEPTH_FAI)->setTexture(ms->getDepthFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_MS_DEPTH_FAI)->setTexture(ms.getDepthFai(), textureUnit++);
 	}
 
 	if(mtl.getStdUniVar(Material::SUV_IS_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_IS_FAI)->setTexture(is->getFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_IS_FAI)->setTexture(is.getFai(), textureUnit++);
 	}
 
 	if(mtl.getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI)->setTexture(pps->getPrePassFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI)->setTexture(pps.getPrePassFai(), textureUnit++);
 	}
 
 	if(mtl.getStdUniVar(Material::SUV_PPS_POST_PASS_FAI))
 	{
-		mtl.getStdUniVar(Material::SUV_PPS_POST_PASS_FAI)->setTexture(pps->getPostPassFai(), textureUnit++);
+		mtl.getStdUniVar(Material::SUV_PPS_POST_PASS_FAI)->setTexture(pps.getPostPassFai(), textureUnit++);
 	}
 
 
@@ -242,7 +241,7 @@ void Renderer::setupShaderProg(const Material& mtl, const ModelNode& modelNode,
 
 	if(mtl.getStdUniVar(Material::SUV_SCENE_AMBIENT_COLOR))
 	{
-		Vec3 col(app->getScene().getAmbientCol());
+		Vec3 col(AppSingleton::getInstance().getScene().getAmbientCol());
 		mtl.getStdUniVar(Material::SUV_SCENE_AMBIENT_COLOR)->setVec3(&col);
 	}
 
@@ -268,16 +267,16 @@ void Renderer::setupShaderProg(const Material& mtl, const ModelNode& modelNode,
 					switch(udv.getFai())
 					{
 						case MtlUserDefinedVar::MS_DEPTH_FAI:
-							udv.getUniVar().setTexture(ms->getDepthFai(), textureUnit);
+							udv.getUniVar().setTexture(ms.getDepthFai(), textureUnit);
 							break;
 						case MtlUserDefinedVar::IS_FAI:
-							udv.getUniVar().setTexture(is->getFai(), textureUnit);
+							udv.getUniVar().setTexture(is.getFai(), textureUnit);
 							break;
 						case MtlUserDefinedVar::PPS_PRE_PASS_FAI:
-							udv.getUniVar().setTexture(pps->getPrePassFai(), textureUnit);
+							udv.getUniVar().setTexture(pps.getPrePassFai(), textureUnit);
 							break;
 						case MtlUserDefinedVar::PPS_POST_PASS_FAI:
-							udv.getUniVar().setTexture(pps->getPostPassFai(), textureUnit);
+							udv.getUniVar().setTexture(pps.getPostPassFai(), textureUnit);
 							break;
 						default:
 							RASSERT_THROW_EXCEPTION("WTF?");
@@ -353,8 +352,8 @@ void Renderer::renderModelNode(const ModelNode& modelNode, const Camera& cam, Mo
 //======================================================================================================================
 void Renderer::renderAllModelNodes(const Camera& cam, ModelNodeRenderType type) const
 {
-	Vec<ModelNode*>::const_iterator it = app->getScene().modelNodes.begin();
-	for(; it != app->getScene().modelNodes.end(); ++it)
+	Vec<ModelNode*>::const_iterator it = AppSingleton::getInstance().getScene().modelNodes.begin();
+	for(; it != AppSingleton::getInstance().getScene().modelNodes.end(); ++it)
 	{
 		const ModelNode& md = *(*it);
 		renderModelNode(md, cam, type);

src/Renderer/Renderer.h

@@ -25,7 +25,7 @@ class ModelNode;
 
 /// Offscreen renderer
 /// It is a class and not a namespace because we may need external renderers for security cameras for example
-class Renderer: public Object
+class Renderer
 {
 	//====================================================================================================================
 	// Properties                                                                                                        =
@@ -47,7 +47,7 @@ class Renderer: public Object
 			MNRT_BS  ///< In blending stage
 		};
 
-		Renderer(Object* parent);
+		Renderer();
 
 		~Renderer() throw() {}
 
@@ -67,9 +67,9 @@ class Renderer: public Object
 		/// @name Accessors
 		/// @{
 		uint getFramesNum() const {return framesNum;}
-		Ms& getMs() {return *ms;}
-		Is& getIs() {return *is;}
-		Pps& getPps() {return *pps;}
+		Ms& getMs() {return ms;}
+		Is& getIs() {return is;}
+		Pps& getPps() {return pps;}
 		/// @}
 
 		/// My version of gluUnproject
@@ -119,10 +119,10 @@ class Renderer: public Object
 	protected:
 		/// @name Rendering stages
 		/// @{
-		Ms* ms; ///< Material rendering stage
-		Is* is; ///< Illumination rendering stage
-		Pps* pps; ///< Postprocessing rendering stage
-		Bs* bs; ///< Blending stage
+		Ms ms; ///< Material rendering stage
+		Is is; ///< Illumination rendering stage
+		Pps pps; ///< Postprocessing rendering stage
+		Bs bs; ///< Blending stage
 		/// @}
 
 		uint framesNum; ///< Frame number

src/Renderer/RenderingPass.h

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

src/Renderer/SceneDbgDrawer.h

@@ -1,9 +1,6 @@
 #ifndef SCENE_DBG_DRAWER_H
 #define SCENE_DBG_DRAWER_H
 
-#include "Object.h"
-
-
 class Dbg;
 class Camera;
 class Light;
@@ -11,11 +8,11 @@ class ParticleEmitter;
 
 
 /// This is a drawer for some scene nodes that need debug
-class SceneDbgDrawer: public Object
+class SceneDbgDrawer
 {
 	public:
 		/// Constructor
-		SceneDbgDrawer(Dbg& dbg_, Object* parent);
+		SceneDbgDrawer(Dbg& dbg_);
 
 		/// Draw a Camera
 		virtual void drawCamera(const Camera& cam) const;
@@ -31,8 +28,7 @@ class SceneDbgDrawer: public Object
 };
 
 
-inline SceneDbgDrawer::SceneDbgDrawer(Dbg& dbg_, Object* parent):
-	Object(parent),
+inline SceneDbgDrawer::SceneDbgDrawer(Dbg& dbg_):
 	dbg(dbg_)
 {}
 

src/Renderer/Sm.h

@@ -20,7 +20,7 @@ class Sm: private RenderingPass
 	public:
 		Texture shadowMap;
 
-		Sm(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
+		Sm(Renderer& r_): RenderingPass(r_) {}
 
 		void init(const RendererInitializer& initializer);
 

src/Renderer/Smo.h

@@ -17,7 +17,7 @@ class SpotLight;
 class Smo: public RenderingPass
 {
 	public:
-		Smo(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
+		Smo(Renderer& r_): RenderingPass(r_) {}
 		void init(const RendererInitializer& initializer);
 		void run(const PointLight& light);
 		void run(const SpotLight& light);

src/Renderer/Ssao.h

@@ -17,7 +17,7 @@
 class Ssao: private RenderingPass
 {
 	public:
-		Ssao(Renderer& r_, Object* parent): RenderingPass(r_, parent) {}
+		Ssao(Renderer& r_): RenderingPass(r_) {}
 		void init(const RendererInitializer& initializer);
 		void run();
 

src/Resources/ShaderProg.cpp

@@ -289,7 +289,7 @@ std::string ShaderProg::createSrcCodeToCache(const char* sProgFPathName, const c
 		return sProgFPathName;
 	}
 
-	boost::filesystem::path newfPathName = app->getCachePath() /
+	boost::filesystem::path newfPathName = AppSingleton::getInstance().getCachePath() /
 			(std::string(newFNamePrefix) + "_" + boost::filesystem::path(sProgFPathName).filename());
 
 	if(boost::filesystem::exists(newfPathName))

src/Scene/Controllers/Controller.cpp

@@ -9,7 +9,7 @@
 Controller::Controller(ControllerType type_):
 	type(type_) 
 {
-	app->getScene().registerController(this);
+	AppSingleton::getInstance().getScene().registerController(this);
 }
 
 
@@ -18,5 +18,5 @@ Controller::Controller(ControllerType type_):
 //======================================================================================================================
 Controller::~Controller()
 {
-	app->getScene().unregisterController(this);
+	AppSingleton::getInstance().getScene().unregisterController(this);
 }

src/Scene/ParticleEmitter.cpp

@@ -58,7 +58,7 @@ void ParticleEmitter::init(const char* filename)
 		init.sceneNode = particle;
 		init.group = Physics::CG_PARTICLE;
 		init.mask = Physics::CG_ALL ^ Physics::CG_PARTICLE;
-		RigidBody* body = new RigidBody(app->getScene().getPhysics(), init);
+		RigidBody* body = new RigidBody(AppSingleton::getInstance().getScene().getPhysics(), init);
 
 		body->forceActivationState(DISABLE_SIMULATION);
 
@@ -72,7 +72,7 @@ void ParticleEmitter::init(const char* filename)
 //======================================================================================================================
 void ParticleEmitter::update()
 {
-	float crntTime = app->getTicks() / 1000.0;
+	float crntTime = AppSingleton::getInstance().getTicks() / 1000.0;
 
 	// Opt: We dont have to make extra calculations if the ParticleEmitter's rotation is the identity
 	bool identRot = getWorldTransform().rotation == Mat3::getIdentity();

src/Scene/SceneNode.cpp

@@ -16,7 +16,7 @@ void SceneNode::commonConstructorCode()
 	getWorldTransform().setIdentity();
 	getLocalTransform().setIdentity();
 
-	app->getScene().registerNode(this);
+	AppSingleton::getInstance().getScene().registerNode(this);
 }
 
 
@@ -25,7 +25,7 @@ void SceneNode::commonConstructorCode()
 //======================================================================================================================
 SceneNode::~SceneNode()
 {
-	app->getScene().unregisterNode(this);
+	AppSingleton::getInstance().getScene().unregisterNode(this);
 }
 
 

src/Scripting/BoostPythonInterfaces.cpp

@@ -21,6 +21,7 @@ BOOST_PYTHON_MODULE(Anki)
 	CALL_WRAP(Renderer);
 	CALL_WRAP(Dbg);
 	CALL_WRAP(MainRenderer);
+	CALL_WRAP(MainRendererSingleton);
 
 	CALL_WRAP(App);
 }

src/Scripting/Core/App.bpi.cpp

@@ -8,7 +8,6 @@ WRAP(App)
 {
 	class_<App, noncopyable>("App", no_init)
 		.def("getScene", &App::getScene, return_value_policy<reference_existing_object>())
-		.def("getMainRenderer", &App::getMainRenderer, return_value_policy<reference_existing_object>())
 		.def("quit", &App::quit)
 	;
 }

src/Scripting/Renderer/MainRenderer.bpi.cpp

@@ -9,3 +9,6 @@ WRAP(MainRenderer)
 		.def("getDbg", &MainRenderer::getDbg, return_value_policy<reference_existing_object>())
 	;
 }
+
+
+WRAP_SINGLETON(MainRendererSingleton)

src/Scripting/ScriptingEngine.h

@@ -2,14 +2,14 @@
 #define SCRIPTING_ENGINE_H
 
 #include <boost/python.hpp>
+#include "Singleton.h"
 
 
 /// The scripting engine using Python
 class ScriptingEngine
 {
 	public:
-		/// Singleton stuff
-		static ScriptingEngine& getInstance();
+		ScriptingEngine() {init();}
 
 		/// Execute python script
 		/// @param script Script source
@@ -28,28 +28,10 @@ class ScriptingEngine
 		boost::python::object ankiModule;
 		boost::python::object mainNamespace;
 
-		/// @name Ensure its singleton
-		/// @{
-		ScriptingEngine() {init();}
-		ScriptingEngine(const ScriptingEngine&) {init();}
-		void operator=(const ScriptingEngine&) {}
-		/// @}
-
-		/// Init python and modules
 		void init();
 };
 
 
-inline ScriptingEngine& ScriptingEngine::getInstance()
-{
-	if(instance == NULL)
-	{
-		instance = new ScriptingEngine();
-	}
-	return *instance;
-}
-
-
 template<typename Type>
 inline void ScriptingEngine::exposeVar(const char* varName, Type* var)
 {
@@ -57,4 +39,7 @@ inline void ScriptingEngine::exposeVar(const char* varName, Type* var)
 }
 
 
+typedef Singleton<ScriptingEngine> ScriptingEngineSingleton;
+
+
 #endif