Many changes in the resource management (Need to add unit tests)

.cproject

@@ -20,7 +20,7 @@
 					<folderInfo id="cdt.managedbuild.config.gnu.exe.debug.1658841075." name="/" resourcePath="">
 						<toolChain id="cdt.managedbuild.toolchain.gnu.exe.debug.125369737" name="Linux GCC" superClass="cdt.managedbuild.toolchain.gnu.exe.debug">
 							<targetPlatform id="cdt.managedbuild.target.gnu.platform.exe.debug.986626863" name="Debug Platform" superClass="cdt.managedbuild.target.gnu.platform.exe.debug"/>
-							<builder arguments="-j3" buildPath="${workspace_loc:/anki/build/debug}" command="make" id="cdt.managedbuild.target.gnu.builder.exe.debug.843151237" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="cdt.managedbuild.target.gnu.builder.exe.debug"/>
+							<builder arguments="make -j3" buildPath="${workspace_loc:/anki/build/debug}" command="nice" id="cdt.managedbuild.target.gnu.builder.exe.debug.843151237" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="cdt.managedbuild.target.gnu.builder.exe.debug"/>
 							<tool id="cdt.managedbuild.tool.gnu.archiver.base.1916040063" name="GCC Archiver" superClass="cdt.managedbuild.tool.gnu.archiver.base"/>
 							<tool id="cdt.managedbuild.tool.gnu.cpp.compiler.exe.debug.851455675" name="GCC C++ Compiler" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.exe.debug">
 								<option id="gnu.cpp.compiler.exe.debug.option.optimization.level.1618169758" name="Optimization Level" superClass="gnu.cpp.compiler.exe.debug.option.optimization.level" value="gnu.cpp.compiler.optimization.level.none" valueType="enumerated"/>

.project

@@ -23,11 +23,11 @@
 				</dictionary>
 				<dictionary>
 					<key>org.eclipse.cdt.make.core.buildArguments</key>
-					<value>-j3</value>
+					<value>make -j3</value>
 				</dictionary>
 				<dictionary>
 					<key>org.eclipse.cdt.make.core.buildCommand</key>
-					<value>make</value>
+					<value>nice</value>
 				</dictionary>
 				<dictionary>
 					<key>org.eclipse.cdt.make.core.buildLocation</key>

build/debug/gen.cfg.py

@@ -1,4 +1,4 @@
-sourcePaths = ["../../src/Math/", "../../src/Util/Tokenizer/", "../../src/Misc/", "../../src/", "../../src/Renderer/", "../../src/Scene/", "../../src/Ui/", "../../src/Resources/", "../../src/Util/", "../../src/Scene/Controllers/", "../../src/Physics/", "../../src/Renderer/BufferObjects/", "../../src/Resources/Helpers/"]
+sourcePaths = ["../../src/Math/", "../../src/Util/Tokenizer/", "../../src/Misc/", "../../src/", "../../src/Renderer/", "../../src/Scene/", "../../src/Ui/", "../../src/Resources/", "../../src/Util/", "../../src/Scene/Controllers/", "../../src/Physics/", "../../src/Renderer/BufferObjects/", "../../src/Resources/Helpers/", "../../src/Resources/Core/"]
 
 includePaths = []
 includePaths.append("./")

license

@@ -0,0 +1,23 @@
+AnKi 3D Engine
+Copyright (c) 2009, 2010 Panagiotis Christopoulos-Charitos
+All rights reserved.
+
+AnKi 3D Engine source code is available under dual license. GPLv3 and commercial
+license. The commercial license applies in cases where this source code or parts
+of this source code will be used in software that won't be licensed under GPLv3.
+To use the commercial license contact Panagiotis Christopoulos-Charitos
+
+THIS SOFTWARE IS PROVIDED BY PANAGIOTIS CHRISTOPOULOS-CHARITOS ''AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL PANAGIOTIS CHRISTOPOULOS-CHARITOS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+

src/Main.cpp

@@ -35,6 +35,7 @@
 #include "Renderer.h"
 #include "RendererInitializer.h"
 #include "MainRenderer.h"
+#include "RsrcMngr.h"
 
 App* app = NULL; ///< The only global var. App constructor sets it
 
@@ -260,7 +261,7 @@ void init()
 	imp = new SkelModelNode();
 	imp->init("models/imp/imp.smdl");
 	imp->setLocalTransform(Transform(Vec3(0.0, 2.11, 0.0), Mat3(Euler(-M::PI/2, 0.0, 0.0)), 0.7));
-	imp->meshNodes[0]->meshSkelCtrl->skelNode->skelAnimCtrl->skelAnim = Resource::skelAnims.load("models/imp/walk.imp.anim");
+	imp->meshNodes[0]->meshSkelCtrl->skelNode->skelAnimCtrl->skelAnim = RsrcMngr::skelAnims.load("models/imp/walk.imp.anim");
 	imp->meshNodes[0]->meshSkelCtrl->skelNode->skelAnimCtrl->step = 0.8;
 
 	// particle emitter
@@ -276,7 +277,7 @@ void init()
 
 	//
 	//floor_ = new floor_t;
-	//floor_->material = Resource::materials.load("materials/default.mtl");
+	//floor_->material = RsrcMngr::materials.load("materials/default.mtl");
 
 	const char* skybox_fnames [] = { "textures/env/hellsky4_forward.tga", "textures/env/hellsky4_back.tga", "textures/env/hellsky4_left.tga",
 																	 "textures/env/hellsky4_right.tga", "textures/env/hellsky4_up.tga", "textures/env/hellsky4_down.tga" };

src/Misc/map.cpp

@@ -197,7 +197,7 @@ bool map_t::load(const char* filename)
 		// strings is what we want in this case... please let it be G-Strings
 		if(token->getCode() == Scanner::TC_STRING)
 		{
-			RsrcPtr<Mesh> mesh = Resource::meshes.load(token->getValue().getString());
+			RsrcPtr<Mesh> mesh = RsrcMngr::meshes.load(token->getValue().getString());
 			if(!mesh.get()) return false;
 
 			meshes.push_back(mesh);

src/Misc/skybox.cpp

@@ -6,6 +6,7 @@
 #include "Scene.h"
 #include "App.h"
 #include "MainRenderer.h"
+#include "RsrcMngr.h"
 
 
 static float coords [][4][3] =
@@ -35,14 +36,14 @@ bool Skybox::load(const char* filenames[6])
 {
 	for(int i=0; i<6; i++)
 	{
-		textures[i] = Resource::textures.load(filenames[i]);
+		textures[i] = RsrcMngr::textures.load(filenames[i]);
 	}
 
-	noise = Resource::textures.load("gfx/noise2.tga");
+	noise = RsrcMngr::textures.load("gfx/noise2.tga");
 	noise->setTexParameter(GL_TEXTURE_WRAP_S, GL_REPEAT);
 	noise->setTexParameter(GL_TEXTURE_WRAP_T, GL_REPEAT);
 
-	shader = Resource::shaders.load("shaders/ms_mp_skybox.glsl");
+	shader = RsrcMngr::shaders.load("shaders/ms_mp_skybox.glsl");
 
 	return true;
 }

src/Misc/skybox.h

@@ -5,8 +5,7 @@
 #include "Texture.h"
 #include "Math.h"
 #include "RsrcPtr.h"
-
-class ShaderProg;
+#include "ShaderProg.h"
 
 class Skybox
 {

src/Renderer/Bs.cpp

@@ -2,6 +2,7 @@
 #include "App.h"
 #include "Scene.h"
 #include "MeshNode.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -53,7 +54,7 @@ void Renderer::Bs::init()
 	refractFai.createEmpty2D(r.width, r.height, GL_RGBA8, GL_RGBA, GL_FLOAT, false);
 	createRefractFbo();
 
-	refractSProg = Resource::shaders.load("shaders/BsRefract.glsl");
+	refractSProg = RsrcMngr::shaders.load("shaders/BsRefract.glsl");
 }
 
 
@@ -70,7 +71,13 @@ void Renderer::Bs::run()
 	for(Vec<MeshNode*>::iterator it=app->getScene()->meshNodes.begin(); it!=app->getScene()->meshNodes.end(); it++)
 	{
 		MeshNode* meshNode = (*it);
-		DEBUG_ERR(meshNode->material == NULL);
+
+		if(meshNode->material.get() == NULL)
+		{
+			ERROR("Mesh \"" << meshNode->mesh->getRsrcName() << "\" doesnt have material" );
+			continue;
+		}
+
 		if(!meshNode->material->blends) continue;
 
 		// refracts

src/Renderer/Dbg.cpp

@@ -9,6 +9,8 @@
 #include "Scene.h"
 #include "SkelNode.h"
 #include "Camera.h"
+#include "LightProps.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -200,7 +202,7 @@ void Renderer::Dbg::init()
 	// shader
 	if(sProg.get() == NULL)
 	{
-		sProg = Resource::shaders.load("shaders/Dbg.glsl");
+		sProg = RsrcMngr::shaders.load("shaders/Dbg.glsl");
 	}
 
 }

src/Renderer/Ez.cpp

@@ -54,7 +54,7 @@ void Renderer::Ms::Ez::run()
 		MeshNode* meshNode = (*it);
 		if(meshNode->material->blends) continue;
 
-		DEBUG_ERR(meshNode->material->dpMtl == NULL);
+		DEBUG_ERR(meshNode->material->dpMtl.get() == NULL);
 
 		r.setupMaterial(*meshNode->material->dpMtl, *meshNode, *r.cam);
 		meshNode->renderDepth();

src/Renderer/Hdr.cpp

@@ -1,10 +1,11 @@
 /**
  * @file
  *
- * Post-processing stage hight dynamic range lighting pass
+ * Post-processing stage high dynamic range lighting pass
  */
 
 #include "Renderer.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -61,19 +62,19 @@ void Renderer::Pps::Hdr::init()
 
 	pps = "#define _PPS_HDR_PASS_0_\n#define IS_FAI_WIDTH " + Util::floatToStr(r.width) + "\n";
 	prefix = "Pass0IsFaiWidth" + Util::floatToStr(r.width);
-	pass0SProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache(shaderFname, pps.c_str(),
+	pass0SProg = RsrcMngr::shaders.load(ShaderProg::createSrcCodeToCache(shaderFname, pps.c_str(),
 	                                                                     prefix.c_str()).c_str());
 	pass0SProgFaiUniVar = pass0SProg->findUniVar("fai");
 
 	pps = "#define _PPS_HDR_PASS_1_\n#define PASS0_HEIGHT " + Util::floatToStr(height) + "\n";
 	prefix = "Pass1Pass0Height" + Util::floatToStr(height);
-	pass1SProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache(shaderFname, pps.c_str(),
+	pass1SProg = RsrcMngr::shaders.load(ShaderProg::createSrcCodeToCache(shaderFname, pps.c_str(),
 	                                                                     prefix.c_str()).c_str());
 	pass1SProgFaiUniVar = pass1SProg->findUniVar("fai");
 
 	pps = "#define _PPS_HDR_PASS_2_\n";
 	prefix = "Pass2";
-	pass2SProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache(shaderFname, pps.c_str(),
+	pass2SProg = RsrcMngr::shaders.load(ShaderProg::createSrcCodeToCache(shaderFname, pps.c_str(),
 	                                                                     prefix.c_str()).c_str());
 	pass2SProgFaiUniVar = pass2SProg->findUniVar("fai");
 }

src/Renderer/Is.cpp

@@ -10,6 +10,8 @@
 #include "LightProps.h"
 #include "App.h"
 #include "Scene.h"
+#include "LightProps.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -101,12 +103,12 @@ void Renderer::Is::initFbo()
 void Renderer::Is::init()
 {
 	// load the shaders
-	ambientPassSProg = Resource::shaders.load("shaders/IsAp.glsl");
+	ambientPassSProg = RsrcMngr::shaders.load("shaders/IsAp.glsl");
 	ambientColUniVar = ambientPassSProg->findUniVar("ambientCol");
 	sceneColMapUniVar = ambientPassSProg->findUniVar("sceneColMap");
 
 	// point light
-	pointLightSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
+	pointLightSProg = RsrcMngr::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
 	                                                                          "#define POINT_LIGHT_ENABLED\n",
 	                                                                          "Point").c_str());
 	pointLightSProgUniVars.msNormalFai = pointLightSProg->findUniVar("msNormalFai");
@@ -121,7 +123,7 @@ void Renderer::Is::init()
 
 
 	// spot light no shadow
-	spotLightNoShadowSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
+	spotLightNoShadowSProg = RsrcMngr::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
 	                                                                                 "#define SPOT_LIGHT_ENABLED\n",
 	                                                                                 "SpotNoShadow").c_str());
 	spotLightNoShadowSProgUniVars.msNormalFai = spotLightNoShadowSProg->findUniVar("msNormalFai");
@@ -146,7 +148,7 @@ void Renderer::Is::init()
 		pps += "#define PCF_ENABLED\n";
 		prefix += "Pcf";
 	}
-	spotLightShadowSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
+	spotLightShadowSProg = RsrcMngr::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
 	                                                                                pps.c_str(),
 	                                                                                prefix.c_str()).c_str());
 	spotLightShadowSProgUniVars.msNormalFai = spotLightShadowSProg->findUniVar("msNormalFai");
@@ -199,7 +201,7 @@ void Renderer::Is::pointLightPass(const PointLight& light)
 	const Camera& cam = *r.cam;
 
 	// frustum test
-	bsphere_t sphere(light.getWorldTransform().getOrigin(), light.radius);
+	bsphere_t sphere(light.getWorldTransform().getOrigin(), light.getRadius());
 	if(!cam.insideFrustum(sphere)) return;
 
 	// stencil optimization
@@ -216,7 +218,8 @@ void Renderer::Is::pointLightPass(const PointLight& light)
 	pointLightSProgUniVars.planes->setVec2(&planes);
 	Vec3 lightPosEyeSpace = light.getWorldTransform().getOrigin().getTransformed(cam.getViewMatrix());
 	pointLightSProgUniVars.lightPos->setVec3(&lightPosEyeSpace);
-	pointLightSProgUniVars.lightInvRadius->setFloat(1.0/light.radius);
+	pointLightSProgUniVars.lightInvRadius->setFloat(1.0/light.getRadius());
+	Vec3 ll = light.lightProps->getDiffuseColor();
 	pointLightSProgUniVars.lightDiffuseCol->setVec3(&light.lightProps->getDiffuseColor());
 	pointLightSProgUniVars.lightSpecularCol->setVec3(&light.lightProps->getSpecularColor());
 

src/Renderer/MainRenderer.cpp

@@ -5,6 +5,7 @@
 #include "MainRenderer.h"
 #include "App.h"
 #include "RendererInitializer.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -16,7 +17,7 @@ void MainRenderer::init(const RendererInitializer& initializer_)
 
 	initGl();
 
-	sProg = Resource::shaders.load("shaders/final.glsl");
+	sProg = RsrcMngr::shaders.load("shaders/final.glsl");
 
 	//
 	// init the offscreen Renderer

src/Renderer/Ms.cpp

@@ -91,7 +91,11 @@ void Renderer::Ms::run()
 	for(Vec<MeshNode*>::iterator it=app->getScene()->meshNodes.begin(); it!=app->getScene()->meshNodes.end(); it++)
 	{
 		MeshNode* meshNode = (*it);
-		DEBUG_ERR(meshNode->material == NULL);
+		if(meshNode->material.get() == NULL)
+		{
+			ERROR("Mesh \"" << meshNode->mesh->getRsrcName() << "\" doesnt have material" );
+			continue;
+		}
 		if(meshNode->material->blends) continue;
 
 		r.setupMaterial(*meshNode->material, *meshNode, cam);

src/Renderer/Pps.cpp

@@ -5,6 +5,7 @@
  */
 
 #include "Renderer.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -43,7 +44,7 @@ void Renderer::Pps::initPrePassSProg()
 		prefix += "Ssao";
 	}
 
-	prePassSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsPrePass.glsl", pps.c_str(),
+	prePassSProg = RsrcMngr::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsPrePass.glsl", pps.c_str(),
 	                                                                       prefix.c_str()).c_str());
 	prePassSProg->bind();
 
@@ -70,7 +71,7 @@ void Renderer::Pps::initPostPassSProg()
 		prefix += "Hdr";
 	}
 
-	postPassSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsPostPass.glsl", pps.c_str(),
+	postPassSProg = RsrcMngr::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsPostPass.glsl", pps.c_str(),
 	                                                                         prefix.c_str()).c_str());
 	postPassSProg->bind();
 

src/Renderer/Renderer.h

@@ -448,7 +448,7 @@ class Renderer
 		Mat4 viewProjectionMat; ///< In case anyone needs it
 
 		static void drawQuad(int vertCoordsUniLoc);
-		void setupMaterial(const Material& mtl, const SceneNode& sceneNode, const Camera& cam);
+		void setupMaterial(const class Material& mtl, const SceneNode& sceneNode, const Camera& cam);
 		static void setViewport(uint x, uint y, uint w, uint h) { glViewport(x,y,w,h); }
 
 		// to be removed

src/Renderer/Sm.cpp

@@ -8,6 +8,7 @@
 #include "App.h"
 #include "Scene.h"
 #include "MeshNode.h"
+#include "LightProps.h"
 
 
 //======================================================================================================================
@@ -81,7 +82,7 @@ void Renderer::Is::Sm::run(const Camera& cam)
 		MeshNode* meshNode = (*it);
 		if(meshNode->material->blends) continue;
 
-		DEBUG_ERR(meshNode->material->dpMtl == NULL);
+		DEBUG_ERR(meshNode->material->dpMtl.get() == NULL);
 
 		r.setupMaterial(*meshNode->material->dpMtl, *meshNode, cam);
 		meshNode->renderDepth();

src/Renderer/Smo.cpp

@@ -5,6 +5,8 @@
  */
 #include "Renderer.h"
 #include "Light.h"
+#include "LightProps.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -19,7 +21,7 @@ Vbo Renderer::Is::Smo::sMOUvSVbo;
 //======================================================================================================================
 void Renderer::Is::Smo::init()
 {
-	sProg = Resource::shaders.load("shaders/IsSmo.glsl");
+	sProg = RsrcMngr::shaders.load("shaders/IsSmo.glsl");
 	modelViewProjectionMatUniVar = sProg->findUniVar("modelViewProjectionMat");
 
 	if(!sMOUvSVbo.isCreated())
@@ -45,7 +47,7 @@ void Renderer::Is::Smo::run(const PointLight& light)
 	// set shared prog
 	const float scale = 1.2; // we scale the sphere a little
 	sProg->bind();
-	Mat4 modelMat = Mat4(light.getWorldTransform().getOrigin(), Mat3::getIdentity(), light.radius*scale);
+	Mat4 modelMat = Mat4(light.getWorldTransform().getOrigin(), Mat3::getIdentity(), light.getRadius()*scale);
 	Mat4 trf = r.cam->getProjectionMatrix() * Mat4::combineTransformations(r.cam->getViewMatrix(), modelMat);
 	modelViewProjectionMatUniVar->setMat4(&trf);
 

src/Renderer/Ssao.cpp

@@ -6,6 +6,7 @@
 
 #include "Renderer.h"
 #include "Camera.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -82,17 +83,17 @@ void Renderer::Pps::Ssao::init()
 	// Shaders
 	//
 
-	ssaoSProg = Resource::shaders.load("shaders/PpsSsao.glsl");
+	ssaoSProg = RsrcMngr::shaders.load("shaders/PpsSsao.glsl");
 
 	string pps = "#define _PPS_SSAO_PASS_0_\n#define PASS0_FAI_WIDTH " + Util::floatToStr(width) + "\n";
 	string prefix = "Pass0Width" + Util::floatToStr(width);
-	blurSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsSsaoBlur.glsl", pps.c_str(),
+	blurSProg = RsrcMngr::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsSsaoBlur.glsl", pps.c_str(),
 	                                                                     prefix.c_str()).c_str());
 
 
 	pps = "#define _PPS_SSAO_PASS_1_\n#define PASS1_FAI_HEIGHT " + Util::floatToStr(bheight) + "\n";
 	prefix = "Pass1Height" + Util::floatToStr(bheight);
-	blurSProg2 = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsSsaoBlur.glsl", pps.c_str(),
+	blurSProg2 = RsrcMngr::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsSsaoBlur.glsl", pps.c_str(),
 	                                                                      prefix.c_str()).c_str());
 
 	camerarangeUniVar = ssaoSProg->findUniVar("camerarange");
@@ -113,7 +114,7 @@ void Renderer::Pps::Ssao::init()
 	bool mipmaping = Texture::mipmappingEnabled;
 	Texture::compressionEnabled = false;
 	Texture::mipmappingEnabled = true;
-	noiseMap = Resource::textures.load("gfx/noise3.tga");
+	noiseMap = RsrcMngr::textures.load("gfx/noise3.tga");
 	noiseMap->setTexParameter(GL_TEXTURE_WRAP_S, GL_REPEAT);
 	noiseMap->setTexParameter(GL_TEXTURE_WRAP_T, GL_REPEAT);
 	//noise_map->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_NEAREST);

src/Resources/Core/Resource.cpp

@@ -0,0 +1,50 @@
+#include "Resource.h"
+#include "Texture.h"
+#include "Material.h"
+#include "ShaderProg.h"
+#include "Mesh.h"
+#include "Skeleton.h"
+#include "SkelAnim.h"
+#include "LightProps.h"
+#include "RsrcMngr.h"
+
+
+//======================================================================================================================
+// tryToUnoadMe                                                                                                        =
+//======================================================================================================================
+void Resource::tryToUnoadMe()
+{
+	switch(getRsrcType())
+	{
+		case RT_TEXTURE:
+			RsrcMngr::textures.unload(static_cast<Texture*>(this));
+			break;
+
+		case RT_SHADER_PROG:
+			RsrcMngr::shaders.unload(static_cast<ShaderProg*>(this));
+			break;
+
+		case RT_MATERIAL:
+			RsrcMngr::materials.unload(static_cast<Material*>(this));
+			break;
+
+		case RT_MESH:
+			RsrcMngr::meshes.unload(static_cast<Mesh*>(this));
+			break;
+
+		case RT_SKELETON:
+			RsrcMngr::skeletons.unload(static_cast<Skeleton*>(this));
+			break;
+
+		case RT_SKEL_ANIM:
+			RsrcMngr::skelAnims.unload(static_cast<SkelAnim*>(this));
+			break;
+
+		case RT_LIGHT_PROPS:
+			RsrcMngr::lightProps.unload(static_cast<LightProps*>(this));
+			break;
+
+		case RT_EXTENSION:
+			break;
+	}
+}

src/Resources/Resource.h → src/Resources/Core/Resource.h

@@ -3,29 +3,21 @@
 
 #include "Common.h"
 #include "Util.h"
-#include "ResourceContainer.h"
+#include "RsrcContainer.h"
 
 
-class Texture;
-class Material;
-class ShaderProg;
-class Mesh;
-class Skeleton;
-class SkelAnim;
-class LightProps;
-
 template<typename Type>
 class Rsrc;
 
 
 /**
  * Every class that it is considered a resource should be derived by this one. This step is not necessary because of the
- * ResourceContainer template but ensures that loading will be made by the resource manager and not the class itself
+ * RsrcContainer template but ensures that loading will be made by the resource manager and not the class itself
  */
 class Resource
 {
 	template<typename Type>
-	friend class ResourceContainer;
+	friend class RsrcContainer;
 
 	// to be able to call tryToUnoadMe
 	template<typename Type>
@@ -50,14 +42,6 @@ class Resource
 	PROPERTY_R(ResourceType, type, getRsrcType);
 
 	public:
-		static ResourceContainer<Texture>    textures;
-		static ResourceContainer<ShaderProg> shaders;
-		static ResourceContainer<Material>   materials;
-		static ResourceContainer<Mesh>       meshes;
-		static ResourceContainer<Skeleton>   skeletons;
-		static ResourceContainer<SkelAnim>   skelAnims;
-		static ResourceContainer<LightProps> lightProps;
-
 		Resource(const ResourceType& type_);
 		virtual ~Resource();
 

src/Resources/ResourceContainer.h → src/Resources/Core/RsrcContainer.h

@@ -2,6 +2,7 @@
 #define RESOURCECONTAINER_H
 
 #include "Common.h"
+#include "Vec.h"
 #include "RsrcPtr.h"
 
 
@@ -9,7 +10,7 @@
  * Resource container template class
  */
 template<typename Type>
-class ResourceContainer: public Vec<Type*>
+class RsrcContainer: public Vec<Type*>
 {
 	friend class Resource;
 
@@ -58,6 +59,6 @@ class ResourceContainer: public Vec<Type*>
 };
 
 
-#include "ResourceContainer.inl.h"
+#include "RsrcContainer.inl.h"
 
 #endif

src/Resources/ResourceContainer.inl.h → src/Resources/Core/RsrcContainer.inl.h

@@ -1,12 +1,12 @@
 #include <boost/filesystem.hpp>
-#include "ResourceContainer.h"
+#include "RsrcContainer.h"
 
 
 //======================================================================================================================
 // findByName                                                                                                          =
 //======================================================================================================================
 template<typename Type>
-typename ResourceContainer<Type>::Iterator ResourceContainer<Type>::findByName(const char* name)
+typename RsrcContainer<Type>::Iterator RsrcContainer<Type>::findByName(const char* name)
 {
 	Iterator it = BaseClass::begin();
 	while(it != BaseClass::end())
@@ -24,7 +24,7 @@ typename ResourceContainer<Type>::Iterator ResourceContainer<Type>::findByName(c
 // findByNameAndPath                                                                                                   =
 //======================================================================================================================
 template<typename Type>
-typename ResourceContainer<Type>::Iterator ResourceContainer<Type>::findByNameAndPath(const char* name,
+typename RsrcContainer<Type>::Iterator RsrcContainer<Type>::findByNameAndPath(const char* name,
                                                                                       const char* path)
 {
 	Iterator it = BaseClass::begin();
@@ -43,7 +43,7 @@ typename ResourceContainer<Type>::Iterator ResourceContainer<Type>::findByNameAn
 // findByPtr                                                                                                           =
 //======================================================================================================================
 template<typename Type>
-typename ResourceContainer<Type>::Iterator ResourceContainer<Type>::findByPtr(Type* ptr)
+typename RsrcContainer<Type>::Iterator RsrcContainer<Type>::findByPtr(Type* ptr)
 {
 	Iterator it = BaseClass::begin();
 	while(it != BaseClass::end())
@@ -61,7 +61,7 @@ typename ResourceContainer<Type>::Iterator ResourceContainer<Type>::findByPtr(Ty
 // load2                                                                                                               =
 //======================================================================================================================
 template<typename Type>
-Type* ResourceContainer<Type>::load2(const char* fname)
+Type* RsrcContainer<Type>::load2(const char* fname)
 {
 	filesystem::path fpathname = filesystem::path(fname);
 	string name = fpathname.filename();
@@ -97,7 +97,7 @@ Type* ResourceContainer<Type>::load2(const char* fname)
 // load                                                                                                                =
 //======================================================================================================================
 template<typename Type>
-RsrcPtr<Type> ResourceContainer<Type>::load(const char* fname)
+RsrcPtr<Type> RsrcContainer<Type>::load(const char* fname)
 {
 	Type* p = load2(fname);
 
@@ -115,7 +115,7 @@ RsrcPtr<Type> ResourceContainer<Type>::load(const char* fname)
 // unload                                                                                                              =
 //======================================================================================================================
 template<typename Type>
-void ResourceContainer<Type>::unload(Type* x)
+void RsrcContainer<Type>::unload(Type* x)
 {
 	Iterator it = findByPtr(x);
 	if(it == BaseClass::end())

src/Resources/Core/RsrcMngr.cpp

@@ -0,0 +1,22 @@
+#include "RsrcMngr.h"
+#include "RsrcContainer.h"
+#include "Texture.h"
+#include "Material.h"
+#include "ShaderProg.h"
+#include "Mesh.h"
+#include "Skeleton.h"
+#include "SkelAnim.h"
+#include "LightProps.h"
+
+
+namespace RsrcMngr {
+
+RsrcContainer<Texture>    textures;
+RsrcContainer<ShaderProg> shaders;
+RsrcContainer<Material>   materials;
+RsrcContainer<Mesh>       meshes;
+RsrcContainer<Skeleton>   skeletons;
+RsrcContainer<SkelAnim>   skelAnims;
+RsrcContainer<LightProps> lightProps;
+
+}

src/Resources/Core/RsrcMngr.h

@@ -0,0 +1,29 @@
+#ifndef RSRCMNGR_H
+#define RSRCMNGR_H
+
+#include "Common.h"
+#include "RsrcContainer.h"
+
+class Texture;
+class Material;
+class ShaderProg;
+class Mesh;
+class Skeleton;
+class SkelAnim;
+class LightProps;
+
+
+namespace RsrcMngr {
+
+extern RsrcContainer<Texture>    textures;
+extern RsrcContainer<ShaderProg> shaders;
+extern RsrcContainer<Material>   materials;
+extern RsrcContainer<Mesh>       meshes;
+extern RsrcContainer<Skeleton>   skeletons;
+extern RsrcContainer<SkelAnim>   skelAnims;
+extern RsrcContainer<LightProps> lightProps;
+
+}
+
+
+#endif

src/Resources/RsrcPtr.h → src/Resources/Core/RsrcPtr.h

@@ -2,21 +2,15 @@
 #define RSRCPTR_H
 
 #include "Common.h"
-#include "Resource.h"
-
-
-template <typename T>
-class ResourceContainer;
 
 
 /**
- * @todo
+ * This is a special pointer to a resource. Its not smart or anything, the only difference is that when its out of scope
+ * it tries to unload the resource
  */
 template<typename Type>
 class RsrcPtr
 {
-	friend class ResourceContainer<Type>;
-
 	public:
 		RsrcPtr();
 
@@ -25,18 +19,23 @@ class RsrcPtr
 		 */
 		RsrcPtr(const RsrcPtr& a);
 
+		/**
+		 * This constructor is for resource container only
+		 */
+		RsrcPtr(Type* p_);
+
 		~RsrcPtr();
 
 		RsrcPtr<Type>& operator=(const RsrcPtr<Type>& a);
 		Type& operator*();
+		const Type& operator*() const;
 		Type* operator->();
+		const Type* operator->() const;
 		Type* get();
+		const Type* get() const;
 
 	private:
-		/**
-		 * This constructor is for resource container only
-		 */
-		RsrcPtr(Type* p_);
+
 
 		Type* p;
 };
@@ -90,16 +89,38 @@ Type& RsrcPtr<Type>::operator*()
 }
 
 
+template<typename Type>
+const Type& RsrcPtr<Type>::operator*() const
+{
+	return *p;
+}
+
+
 template<typename Type>
 Type* RsrcPtr<Type>::operator->()
 {
 	return p;
 }
 
+
+template<typename Type>
+const Type* RsrcPtr<Type>::operator->() const
+{
+	return p;
+}
+
+
 template<typename Type>
 Type* RsrcPtr<Type>::get()
 {
 	return p;
 }
 
+
+template<typename Type>
+const Type* RsrcPtr<Type>::get() const
+{
+	return p;
+}
+
 #endif

src/Resources/LightProps.cpp

@@ -2,6 +2,7 @@
 #include "LightProps.h"
 #include "Parser.h"
 #include "Texture.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -38,7 +39,8 @@ bool LightProps::load(const char* filename)
 				return false;
 			}
 
-			radius = (token->getDataType() == Scanner::DT_FLOAT) ? token->getValue().getFloat() : float(token->getValue().getInt());
+			radius = (token->getDataType() == Scanner::DT_FLOAT) ? token->getValue().getFloat() :
+			                                                       float(token->getValue().getInt());
 		}
 		//** CASTS_SHADOW **
 		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "CASTS_SHADOW"))
@@ -62,7 +64,8 @@ bool LightProps::load(const char* filename)
 				return false;
 			}
 
-			distance = (token->getDataType() == Scanner::DT_FLOAT) ? token->getValue().getFloat() : float(token->getValue().getInt());
+			distance = (token->getDataType() == Scanner::DT_FLOAT) ? token->getValue().getFloat() :
+			                                                         float(token->getValue().getInt());
 		}
 		//** FOV_X **
 		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "FOV_X"))
@@ -74,7 +77,8 @@ bool LightProps::load(const char* filename)
 				return false;
 			}
 
-			fovX = (token->getDataType() == Scanner::DT_FLOAT) ? token->getValue().getFloat() : float(token->getValue().getInt());
+			fovX = (token->getDataType() == Scanner::DT_FLOAT) ? token->getValue().getFloat() :
+			                                                     float(token->getValue().getInt());
 		}
 		//** FOV_Y **
 		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "FOV_Y"))
@@ -86,7 +90,8 @@ bool LightProps::load(const char* filename)
 				return false;
 			}
 
-			fovY = (token->getDataType() == Scanner::DT_FLOAT) ? token->getValue().getFloat() : float(token->getValue().getInt());
+			fovY = (token->getDataType() == Scanner::DT_FLOAT) ? token->getValue().getFloat() :
+			                                                     float(token->getValue().getInt());
 		}
 		//** TEXTURE **
 		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "TEXTURE"))
@@ -98,7 +103,7 @@ bool LightProps::load(const char* filename)
 				return false;
 			}
 				
-			texture = Resource::textures.load(token->getValue().getString());
+			texture = RsrcMngr::textures.load(token->getValue().getString());
 			texture->setRepeat(false);
 			texture->setTexParameter(GL_TEXTURE_MAX_ANISOTROPY_EXT, 0);
 			texture->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@@ -120,13 +125,3 @@ bool LightProps::load(const char* filename)
 	
 	return true;
 }
-
-
-//======================================================================================================================
-// unload                                                                                                              =
-//======================================================================================================================
-void LightProps::unload()
-{
-	/*if(texture != NULL)
-		Resource::textures.unload(texture);*/
-}

src/Resources/LightProps.h

@@ -4,13 +4,12 @@
 #include "Common.h"
 #include "Resource.h"
 #include "Math.h"
-
-
-class Texture;
+#include "RsrcPtr.h"
+#include "Texture.h"
 
 
 /**
- * Light properties @ref Resource resource
+ * Light properties @ref Resource
  */
 class LightProps: public Resource
 {
@@ -24,13 +23,13 @@ class LightProps: public Resource
 		
 	public:
 		LightProps();
-		virtual ~LightProps() { /* ToDo */ }
+		virtual ~LightProps() {}
 		bool load(const char* filename);
-		void unload();
+		void unload() {};
 		const Texture* getTexture() const;
 
 	private:
-		Texture* texture; ///< For spot lights
+		RsrcPtr<Texture> texture; ///< For spot lights
 };
 
 
@@ -42,14 +41,14 @@ inline LightProps::LightProps():
 	castsShadow_(false),
 	distance(3.0),
 	fovX(M::PI/4.0),
-	fovY(M::PI/4.0),
-	texture(NULL)
+	fovY(M::PI/4.0)
 {}
 
 
 inline const Texture* LightProps::getTexture() const
 {
-	DEBUG_ERR(texture==NULL); return texture;
+	DEBUG_ERR(texture.get() == NULL);
+	return texture.get();
 }
 
 #endif

src/Resources/Material.cpp

@@ -1,4 +1,4 @@
-#include <string.h>
+#include <cstring>
 #include "Material.h"
 #include "Resource.h"
 #include "Scanner.h"
@@ -7,6 +7,7 @@
 #include "ShaderProg.h"
 #include "App.h"
 #include "MainRenderer.h"
+#include "RsrcMngr.h"
 
 
 /// Customized @ref ERROR used in @ref Material class
@@ -107,7 +108,8 @@ bool Material::load(const char* filename)
 		//** SHADER_PROG **
 		if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "SHADER_PROG"))
 		{
-			if(shaderProg) ERROR("Shader program already loaded");
+			if(shaderProg.get())
+				ERROR("Shader program already loaded");
 
 			token = &scanner.getNextToken();
 			if(token->getCode() != Scanner::TC_STRING)
@@ -115,12 +117,13 @@ bool Material::load(const char* filename)
 				PARSE_ERR_EXPECTED("string");
 				return false;
 			}
-			shaderProg = Resource::shaders.load(token->getValue().getString());
+			shaderProg = RsrcMngr::shaders.load(token->getValue().getString());
 		}
 		//** DEPTH_MATERIAL **
 		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "DEPTH_PASS_MATERIAL"))
 		{
-			if(dpMtl) ERROR("Depth material already loaded");
+			if(dpMtl.get())
+				ERROR("Depth material already loaded");
 
 			token = &scanner.getNextToken();
 			if(token->getCode() != Scanner::TC_STRING)
@@ -128,7 +131,7 @@ bool Material::load(const char* filename)
 				PARSE_ERR_EXPECTED("string");
 				return false;
 			}
-			dpMtl = Resource::materials.load(token->getValue().getString());
+			dpMtl = RsrcMngr::materials.load(token->getValue().getString());
 		}
 		//** BLENDS **
 		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "BLENDS"))
@@ -212,7 +215,7 @@ bool Material::load(const char* filename)
 		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "USER_DEFINED_VARS"))
 		{
 			// first check if the shader is defined
-			if(shaderProg == NULL)
+			if(shaderProg.get() == NULL)
 			{
 				PARSE_ERR("You have to define the shader program before the user defined vars");
 				return false;
@@ -261,8 +264,8 @@ bool Material::load(const char* filename)
 						token = &scanner.getNextToken();
 						if(token->getCode() == Scanner::TC_STRING)
 						{
-							var.value.texture = Resource::textures.load(token->getValue().getString());
-							if(var.value.texture == NULL)
+							var.value.texture = RsrcMngr::textures.load(token->getValue().getString());
+							if(var.value.texture.get() == NULL)
 								return false;
 						}
 						else
@@ -328,7 +331,7 @@ bool Material::load(const char* filename)
 bool Material::initStdShaderVars()
 {
 	// sanity checks
-	if(!shaderProg)
+	if(!shaderProg.get())
 	{
 		MTL_ERROR("Without shader is like cake without sugar (missing SHADER_PROG)");
 		return false;
@@ -390,27 +393,11 @@ bool Material::initStdShaderVars()
 Material::Material():
 	Resource(RT_MATERIAL)
 {
-	shaderProg = NULL;
 	blends = false;
 	blendingSfactor = GL_ONE;
 	blendingDfactor = GL_ZERO;
 	depthTesting = true;
 	wireframe = false;
 	castsShadow = true;
-	dpMtl = NULL;
-}
-
-//======================================================================================================================
-// unload                                                                                                              =
-//======================================================================================================================
-void Material::unload()
-{
-	//Resource::shaders.unload(shaderProg);
-
-	// loop all user defined vars and unload the textures
-	/*for(uint i=0; i<userDefinedVars.size(); i++)
-	{
-		Resource::textures.unload(userDefinedVars[i].value.texture);
-	}*/
 }
 

src/Resources/Material.h

@@ -5,6 +5,8 @@
 #include "Math.h"
 #include "Resource.h"
 #include "ShaderProg.h"
+#include "Texture.h"
+#include "RsrcPtr.h"
 
 
 /**
@@ -96,13 +98,11 @@ class Material: public Resource
 			 */
 			struct Value
 			{
-				Texture* texture;
+				RsrcPtr<Texture> texture;
 				float float_;
 				Vec2 vec2;
 				Vec3 vec3;
 				Vec4 vec4;
-
-				Value(): texture(NULL) {}
 			};
 
 			Value value;
@@ -114,8 +114,8 @@ class Material: public Resource
 		static StdVarInfo stdUniVarInfos[SUV_NUM];
 		const ShaderProg::AttribVar* stdAttribVars[SAV_NUM];
 		const ShaderProg::UniVar* stdUniVars[SUV_NUM];
-		ShaderProg* shaderProg; ///< The most important aspect of materials
-		Material* dpMtl; ///< The material for depth passes. To be removed when skinning is done using transform feedback
+		RsrcPtr<ShaderProg> shaderProg; ///< The most important aspect of materials
+		RsrcPtr<Material> dpMtl; ///< The material for depth passes. To be removed when skinning is done using transform feedback
 		Vec<UserDefinedUniVar> userDefinedVars;
 		bool blends; ///< The entities with blending are being rendered in blending stage and those without in material stage
 		int blendingSfactor;
@@ -137,7 +137,7 @@ class Material: public Resource
 	public:
 		Material();
 		bool load(const char* filename);
-		void unload();
+		void unload() {};
 };
 
 
@@ -149,7 +149,7 @@ inline bool Material::hasHWSkinning() const
 
 inline bool Material::hasAlphaTesting() const
 {
-	return dpMtl!=NULL && dpMtl->stdAttribVars[SAV_TEX_COORDS] != NULL;
+	return dpMtl.get()!=NULL && dpMtl->stdAttribVars[SAV_TEX_COORDS] != NULL;
 }
 
 

src/Resources/Mesh.h

@@ -32,7 +32,6 @@ class Mesh: public Resource
 				Vec3 normal;
 		};
 
-
 		struct
 		{
 			Vbo vertCoords;
@@ -43,17 +42,6 @@ class Mesh: public Resource
 			Vbo vertWeights;
 		} vbos;
 
-
-	// funcs
-	protected:
-		void createFaceNormals();
-		void createVertNormals();
-		void createAllNormals() { createFaceNormals(); createVertNormals(); }
-		void createVertTangents();
-		void createVertIndeces();
-		void createVbos();
-		void calcBSphere();
-
 	public:
 		Vec<Vec3>         vertCoords;
 		Vec<Vec3>         vertNormals;
@@ -66,9 +54,18 @@ class Mesh: public Resource
 		bsphere_t         bsphere;
 
 		Mesh();
-		virtual ~Mesh() { /*ToDo*/ }
+		~Mesh() {}
 		bool load(const char* filename);
 		void unload();
+
+	protected:
+		void createFaceNormals();
+		void createVertNormals();
+		void createAllNormals() { createFaceNormals(); createVertNormals(); }
+		void createVertTangents();
+		void createVertIndeces();
+		void createVbos();
+		void calcBSphere();
 };
 
 

src/Resources/Resource.cpp

@@ -1,62 +0,0 @@
-#include "Resource.h"
-#include "Texture.h"
-#include "Material.h"
-#include "ShaderProg.h"
-#include "Mesh.h"
-#include "Skeleton.h"
-#include "SkelAnim.h"
-#include "LightProps.h"
-
-
-//======================================================================================================================
-// Statics                                                                                                             =
-//======================================================================================================================
-
-ResourceContainer<Texture>    Resource::textures;
-ResourceContainer<ShaderProg> Resource::shaders;
-ResourceContainer<Material>   Resource::materials;
-ResourceContainer<Mesh>       Resource::meshes;
-ResourceContainer<Skeleton>   Resource::skeletons;
-ResourceContainer<SkelAnim>   Resource::skelAnims;
-ResourceContainer<LightProps> Resource::lightProps;
-
-
-//======================================================================================================================
-// tryToUnoadMe                                                                                                        =
-//======================================================================================================================
-void Resource::tryToUnoadMe()
-{
-	switch(getRsrcType())
-	{
-		case RT_TEXTURE:
-			textures.unload(static_cast<Texture*>(this));
-			break;
-
-		case RT_SHADER_PROG:
-			shaders.unload(static_cast<ShaderProg*>(this));
-			break;
-
-		case RT_MATERIAL:
-			materials.unload(static_cast<Material*>(this));
-			break;
-
-		case RT_MESH:
-			meshes.unload(static_cast<Mesh*>(this));
-			break;
-
-		case RT_SKELETON:
-			skeletons.unload(static_cast<Skeleton*>(this));
-			break;
-
-		case RT_SKEL_ANIM:
-			skelAnims.unload(static_cast<SkelAnim*>(this));
-			break;
-
-		case RT_LIGHT_PROPS:
-			lightProps.unload(static_cast<LightProps*>(this));
-			break;
-
-		case RT_EXTENSION:
-			break;
-	}
-}

src/Resources/ShaderProg.h

@@ -9,6 +9,7 @@
 #include "Math.h"
 
 
+
 /**
  * Shader program @ref Resource
  *
@@ -19,7 +20,7 @@
 class ShaderProg: public Resource
 {
 	friend class Material;
-	friend class ResourceContainer<ShaderProg>;
+	friend class RsrcContainer<ShaderProg>;
 
 	//====================================================================================================================
 	// Nested                                                                                                            =
@@ -67,7 +68,7 @@ class ShaderProg: public Resource
 				void setVec4(const Vec4 v4[], uint size = 1) const;
 				void setMat3(const Mat3 m3[], uint size = 1) const;
 				void setMat4(const Mat4 m4[], uint size = 1) const;
-				void setTexture(const Texture& tex, uint texUnit) const;
+				void setTexture(const class Texture& tex, uint texUnit) const;
 		};
 
 		/**

src/Resources/Texture.h

@@ -1,5 +1,5 @@
-#ifndef _TEXTURE_H_
-#define _TEXTURE_H_
+#ifndef TEXTURE_H
+#define TEXTURE_H
 
 #include <GL/glew.h>
 #include <limits>
@@ -43,12 +43,13 @@ class Texture: public Resource
 		static bool mipmappingEnabled;
 		static bool compressionEnabled;
 		static int  anisotropyLevel;
-}; // end class Texture
+};
 
 
 inline GLuint Texture::getGlId() const
 {
-	DEBUG_ERR(glId==numeric_limits<uint>::max()); return glId;
+	DEBUG_ERR(glId==numeric_limits<uint>::max());
+	return glId;
 }
 
 

src/Scene/Controllers/SkelAnimCtrl.cpp

@@ -135,7 +135,7 @@ void SkelAnimCtrl::updateBoneTransforms()
 //======================================================================================================================
 void SkelAnimCtrl::deform()
 {
-	Skeleton* skeleton = skelNode->skeleton;
+	Skeleton* skeleton = skelNode->skeleton.get();
 
 	for(uint i=0; i<skeleton->bones.size(); i++)
 	{
@@ -159,7 +159,7 @@ void SkelAnimCtrl::update(float)
 		frame = 0.0;
 	}
 
-	interpolate(skelAnim, frame);
+	interpolate(skelAnim.get(), frame);
 	updateBoneTransforms();
 	if(app->getMainRenderer()->dbg.isShowSkeletonsEnabled())
 	{

src/Scene/Light.cpp

@@ -3,6 +3,7 @@
 #include "LightProps.h"
 #include "App.h"
 #include "MainRenderer.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -10,7 +11,7 @@
 //======================================================================================================================
 void PointLight::init(const char* filename)
 {
-	lightProps = Resource::lightProps.load(filename);
+	lightProps = RsrcMngr::lightProps.load(filename);
 	radius = lightProps->getRadius();
 }
 
@@ -20,7 +21,7 @@ void PointLight::init(const char* filename)
 //======================================================================================================================
 void SpotLight::init(const char* filename)
 {
-	lightProps = Resource::lightProps.load(filename);
+	lightProps = RsrcMngr::lightProps.load(filename);
 	camera.setAll(lightProps->getFovX(), lightProps->getFovY(), 0.2, lightProps->getDistance());
 	castsShadow = lightProps->castsShadow();
 	if(lightProps->getTexture() == NULL)
@@ -36,7 +37,7 @@ void SpotLight::init(const char* filename)
 //======================================================================================================================
 void Light::deinit()
 {
-	//Resource::lightProps.unload(lightProps);
+	//RsrcMngr::lightProps.unload(lightProps);
 }
 
 

src/Scene/Light.h

@@ -22,22 +22,23 @@ Specular intensity of material: Sm
 #include "SceneNode.h"
 #include "Camera.h"
 #include "RsrcPtr.h"
-
-
-class LightProps;
+#include "LightProps.h"
 
 
 /// Light scene node (Abstract)
 class Light: public SceneNode
 {
 	public:
-		enum Type { LT_POINT, LT_SPOT };
+		enum Type
+		{
+			LT_POINT,
+			LT_SPOT
+		};
 
 		Type type;
 		RsrcPtr<LightProps> lightProps; ///< Later we will add a controller
 	
-		Light(Type type_): SceneNode(NT_LIGHT), type(type_) {}
-		//void init(const char*);
+		Light(Type type_);
 		void deinit();
 		void render();
 };
@@ -46,10 +47,10 @@ class Light: public SceneNode
 /// PointLight scene node
 class PointLight: public Light
 {
-	public:
-		float radius;
+	PROPERTY_RW(float, radius, setRadius, getRadius)
 
-		PointLight(): Light(LT_POINT) {}
+	public:
+		PointLight();
 		void init(const char*);
 };
 
@@ -61,11 +62,45 @@ class SpotLight: public Light
 		Camera camera;
 		bool castsShadow;
 
-		SpotLight(): Light(LT_SPOT), castsShadow(false) { addChild(&camera); }
-		float getDistance() const { return camera.getZFar(); }
-		void setDistance(float d) { camera.setZFar(d); }
+		SpotLight();
+		float getDistance() const;
+		void setDistance(float d);
 		void init(const char*);
 };
 
 
+//======================================================================================================================
+// Inlines                                                                                                             =
+//======================================================================================================================
+
+inline Light::Light(Type type_):
+	SceneNode(NT_LIGHT),
+	type(type_)
+{}
+
+
+inline PointLight::PointLight():
+	Light(LT_POINT)
+{}
+
+
+inline SpotLight::SpotLight():
+	Light(LT_SPOT),
+	castsShadow(false)
+{
+	addChild(&camera);
+}
+
+
+inline float SpotLight::getDistance() const
+{
+	return camera.getZFar();
+}
+
+
+inline void SpotLight::setDistance(float d)
+{
+	camera.setZFar(d);
+}
+
 #endif

src/Scene/MeshNode.cpp

@@ -8,6 +8,7 @@
 #include "SkelAnimCtrl.h"
 #include "App.h"
 #include "MainRenderer.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -15,8 +16,8 @@
 //======================================================================================================================
 void MeshNode::init(const char* filename)
 {
-	mesh = Resource::meshes.load(filename);
-	material = Resource::materials.load(mesh->materialName.c_str());
+	mesh = RsrcMngr::meshes.load(filename);
+	material = RsrcMngr::materials.load(mesh->materialName.c_str());
 
 	// sanity checks
 	if(material->stdAttribVars[Material::SAV_TEX_COORDS]!=NULL && mesh->vbos.texCoords.getGlId()==0)
@@ -33,8 +34,8 @@ void MeshNode::init(const char* filename)
 //======================================================================================================================
 void MeshNode::deinit()
 {
-	//Resource::meshes.unload(mesh);
-	//Resource::materials.unload(material);
+	//RsrcMngr::meshes.unload(mesh);
+	//RsrcMngr::materials.unload(material);
 }
 
 

src/Scene/MeshNode.h

@@ -4,9 +4,9 @@
 #include "Common.h"
 #include "SceneNode.h"
 #include "Material.h"
-
-class MeshSkelNodeCtrl;
-class Mesh;
+#include "RsrcPtr.h"
+#include "Mesh.h"
+#include "MeshSkelNodeCtrl.h"
 
 
 /// Mesh scene node
@@ -17,18 +17,24 @@ class MeshNode: public SceneNode
 
 	public:
 		// resources
-		Mesh* mesh;
-		Material* material;
-		Material* dpMaterial; ///< Depth pass material
+		RsrcPtr<Mesh> mesh;
+		RsrcPtr<Material> material;
+		RsrcPtr<Material> dpMaterial; ///< Depth pass material
 		// controllers
 		MeshSkelNodeCtrl* meshSkelCtrl;
 		// funcs
-		MeshNode(): SceneNode(NT_MESH), material(NULL), dpMaterial(NULL), meshSkelCtrl(NULL) {}
-		virtual void render() { render(material); }
-		virtual void renderDepth() { render(material->dpMtl); }
+		MeshNode();
+		virtual void render() { render(material.get()); }
+		virtual void renderDepth() { render(material->dpMtl.get()); }
 		void init(const char* filename);
 		void deinit();
 };
 
 
+inline MeshNode::MeshNode():
+	SceneNode(NT_MESH),
+	meshSkelCtrl(NULL)
+{}
+
+
 #endif

src/Scene/SkelModelNode.h

@@ -17,7 +17,7 @@ class SkelModelNode: public SceneNode
 {
 	public:
 		Vec<MeshNode*> meshNodes;
-		SkelNode*   skelNode;
+		SkelNode* skelNode;
 		
 		SkelModelNode(): SceneNode(NT_SKEL_MODEL), skelNode(NULL) { isCompound = true; }
 		void init(const char* filename);

src/Scene/SkelNode.cpp

@@ -4,6 +4,7 @@
 #include "SkelAnimCtrl.h"
 #include "App.h"
 #include "MainRenderer.h"
+#include "RsrcMngr.h"
 
 
 //======================================================================================================================
@@ -21,7 +22,7 @@ SkelNode::SkelNode():
 //======================================================================================================================
 void SkelNode::init(const char* filename)
 {
-	skeleton = Resource::skeletons.load(filename);
+	skeleton = RsrcMngr::skeletons.load(filename);
 	skelAnimCtrl = new SkelAnimCtrl(this);
 }
 
@@ -31,7 +32,7 @@ void SkelNode::init(const char* filename)
 //======================================================================================================================
 void SkelNode::deinit()
 {
-	//Resource::skeletons.unload(skeleton);
+	//RsrcMngr::skeletons.unload(skeleton);
 }
 
 

src/Scene/SkelNode.h

@@ -3,12 +3,9 @@
 
 #include "Common.h"
 #include "SceneNode.h"
-#include "Controller.h"
-#include "Math.h"
+#include "SkelAnimCtrl.h"
 #include "RsrcPtr.h"
-
-
-class SkelAnimCtrl;
+#include "Skeleton.h"
 
 
 /**
@@ -17,8 +14,8 @@ class SkelAnimCtrl;
 class SkelNode: public SceneNode
 {
 	public:
-		class Skeleton* skeleton; ///< The skeleton resource
-		RsrcPtr<SkelAnimCtrl> skelAnimCtrl; ///< Hold the controller here as well
+		RsrcPtr<Skeleton> skeleton; ///< The skeleton resource
+		SkelAnimCtrl* skelAnimCtrl; ///< Hold the controller here as well @todo make it reference
 
 		SkelNode();
 		void render();

src/Ui/Ui.cpp

@@ -5,6 +5,9 @@
 #include "App.h"
 #include "Texture.h"
 #include "Resource.h"
+#include "RsrcPtr.h"
+#include "RsrcMngr.h"
+
 
 namespace Ui {
 
@@ -14,9 +17,9 @@ namespace Ui {
 data members                                                                                                           =
 =======================================================================================================================================
 */
-static Texture* fontMap;
+static RsrcPtr<Texture> fontMap;
 
-static ShaderProg* shader;
+static RsrcPtr<ShaderProg> shader;
 
 static float  initialX;
 static float  fontW;
@@ -159,10 +162,10 @@ non static funcs
 // exec after init SDL
 void init()
 {
-	fontMap = Resource::textures.load("gfx/fontmapa.tga");
+	fontMap = RsrcMngr::textures.load("gfx/fontmapa.tga");
 	fontMap->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 	//font_map->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-	shader = Resource::shaders.load("shaders/txt.glsl");
+	shader = RsrcMngr::shaders.load("shaders/txt.glsl");
 	setPos(0.0, 0.0);
 	setFontWidth(0.05);
 	setColor(Vec4(1.0, 1.0, 1.0, 1.0));