Changes in the resource management

WARNING: It wont compile

src/Main.cpp

@@ -411,14 +411,6 @@ int main(int argc, char* argv[])
 {
 	new App(argc, argv);
 
-	{
-		RsrcPtr<LightProps> t(Resource::lightProps.load_("/users/panoscc/Desktop/"));
-		{
-			RsrcPtr<LightProps> t2(Resource::lightProps.load_("/users/panoscc/Desktop/"));
-			INFO("lala");
-		}
-	}
-
 	init();
 
 	mainLoop();

src/Misc/map.cpp

@@ -1,3 +1,4 @@
+/*
 #include <limits>
 #include "map.h"
 #include "Mesh.h"
@@ -7,11 +8,11 @@
 #include "Camera.h"
 
 
-/*
+
 =======================================================================================================================================
 CreateRoot                                                                                                             =
 =======================================================================================================================================
-*/
+
 void octree_t::CreateRoot(const Vec<Mesh*>& meshes)
 {
 	DEBUG_ERR(root); // root should be NULL
@@ -70,11 +71,11 @@ void octree_t::CreateRoot(const Vec<Mesh*>& meshes)
 
 
 
-/*
+
 =======================================================================================================================================
 GetFacesNum                                                                                                            =
 =======================================================================================================================================
-*/
+
 uint octree_t::node_t::GetFacesNum() const
 {
 	int count = 0;
@@ -86,13 +87,13 @@ uint octree_t::node_t::GetFacesNum() const
 }
 
 
-/*
+
 =======================================================================================================================================
 IsSubdivHeuristicMet                                                                                                   =
 returns true when the used difined heuristic is met that sais that we can subdivide the node. Long story short it returns true when   =
 we can subdivide the node further                                                                                      =
 =======================================================================================================================================
-*/
+
 bool octree_t::IsSubdivHeuristicMet(node_t* node) const
 {
 	if(node->GetFacesNum() < 100) return false;
@@ -102,12 +103,12 @@ bool octree_t::IsSubdivHeuristicMet(node_t* node) const
 
 
 
-/*
+
 =======================================================================================================================================
 SubdivideNode                                                                                                          =
 subdivides the node and creates max 8 children and then subdivides the children                                        =
 =======================================================================================================================================
-*/
+
 void octree_t::SubdivideNode(node_t* node)
 {
 	if(!IsSubdivHeuristicMet(node)) return;
@@ -122,11 +123,11 @@ void octree_t::SubdivideNode(node_t* node)
 }
 
 
-/*
+
 =======================================================================================================================================
 CreateTree                                                                                                             =
 =======================================================================================================================================
-*/
+
 void octree_t::CreateTree(const Vec<Mesh*>& meshes)
 {
 	CreateRoot(meshes);
@@ -134,13 +135,13 @@ void octree_t::CreateTree(const Vec<Mesh*>& meshes)
 }
 
 
-/*
+
 =======================================================================================================================================
 CheckNodeAgainstFrustum                                                                                                =
 the func checks the node and returns if its inside the cameras fruntum. It returns 0 if the cube is not inside, 1 if partialy         =
 inside and 2 if totaly inside                                                                                          =
 =======================================================================================================================================
-*/
+
 uint octree_t::CheckNodeAgainstFrustum(node_t* node, const Camera& cam) const
 {
 	int points_outside_frustum_num = 0;
@@ -169,18 +170,18 @@ uint octree_t::CheckNodeAgainstFrustum(node_t* node, const Camera& cam) const
 
 
 
-/*
+
 =======================================================================================================================================
 map                                                                                                                    =
 =======================================================================================================================================
-*/
 
 
-/*
+
+
 =======================================================================================================================================
 load                                                                                                                   =
 =======================================================================================================================================
-*/
+
 bool map_t::load(const char* filename)
 {
 	DEBUG_ERR(meshes.size() != 0); // meshes vector should be empty
@@ -196,8 +197,8 @@ 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)
 		{
-			Mesh* mesh = Resource::meshes.load(token->getValue().getString());
-			if(!mesh) return false;
+			RsrcPtr<Mesh> mesh = Resource::meshes.load(token->getValue().getString());
+			if(!mesh.get()) return false;
 
 			meshes.push_back(mesh);
 		}
@@ -218,3 +219,4 @@ bool map_t::load(const char* filename)
 	return true;
 }
 
+*/

src/Misc/map.h

@@ -1,19 +1,21 @@
+/*
 #ifndef _MAP_H_
 #define _MAP_H_
 
 #include "Common.h"
 #include "collision.h"
 #include "Vec.h"
+#include "RsrcPtr.h"
 
 class Mesh;
 class Camera;
 
 
-/*
+
 =======================================================================================================================================
 octree_t                                                                                                               =
 =======================================================================================================================================
-*/
+
 class octree_t
 {
 	public:
@@ -25,12 +27,12 @@ class octree_t
 				node_t* childs[8];
 				aabb_t  bounding_box;
 
-				Vec<Mesh*>   meshes;
+				Vec<RsrcPtr<Mesh> >   meshes;
 				Vec< Vec<uint> > vertIds;
 				Vec< Vec<uint> > face_ids;
 
 				node_t() {}
-				~node_t() { /*ToDo: when class is finalized add code*/ }
+				~node_t() { ToDo: when class is finalized add code }
 
 				uint GetMeshesNum() const { return meshes.size(); }
 				uint GetFacesNum() const;
@@ -53,11 +55,11 @@ class octree_t
 };
 
 
-/*
+
 =======================================================================================================================================
 map_t                                                                                                                  =
 =======================================================================================================================================
-*/
+
 class map_t
 {
 	public:
@@ -70,3 +72,4 @@ class map_t
 
 
 #endif
+*/

src/Misc/skybox.h

@@ -4,6 +4,7 @@
 #include "Common.h"
 #include "Texture.h"
 #include "Math.h"
+#include "RsrcPtr.h"
 
 class ShaderProg;
 
@@ -20,9 +21,9 @@ class Skybox
 			DOWN
 		};
 
-		Texture* textures[6];
-		Texture* noise;
-		ShaderProg* shader;
+		RsrcPtr<Texture> textures[6];
+		RsrcPtr<Texture> noise;
+		RsrcPtr<ShaderProg> shader;
 
 		float rotation_ang;
 

src/Renderer/Bs.cpp

@@ -53,7 +53,7 @@ void Renderer::Bs::init()
 	refractFai.createEmpty2D(r.width, r.height, GL_RGBA8, GL_RGBA, GL_FLOAT, false);
 	createRefractFbo();
 
-	refractSProg.reset(Resource::shaders.load("shaders/BsRefract.glsl"));
+	refractSProg = Resource::shaders.load("shaders/BsRefract.glsl");
 }
 
 

src/Renderer/Dbg.cpp

@@ -14,7 +14,7 @@
 //======================================================================================================================
 // Statics                                                                                                             =
 //======================================================================================================================
-ShaderProg* Renderer::Dbg::sProg = NULL;
+RsrcPtr<ShaderProg> Renderer::Dbg::sProg;
 Mat4 Renderer::Dbg::viewProjectionMat;
 
 
@@ -198,7 +198,7 @@ void Renderer::Dbg::init()
 	fbo.unbind();
 
 	// shader
-	if(sProg == NULL)
+	if(sProg.get() == NULL)
 	{
 		sProg = Resource::shaders.load("shaders/Dbg.glsl");
 	}

src/Renderer/Hdr.cpp

@@ -61,20 +61,20 @@ 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.reset(Resource::shaders.load(ShaderProg::createSrcCodeToCache(shaderFname, pps.c_str(),
-	                                                                         prefix.c_str()).c_str()));
+	pass0SProg = Resource::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.reset(Resource::shaders.load(ShaderProg::createSrcCodeToCache(shaderFname, pps.c_str(),
-	                                                                         prefix.c_str()).c_str()));
+	pass1SProg = Resource::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.reset(Resource::shaders.load(ShaderProg::createSrcCodeToCache(shaderFname, pps.c_str(),
-	                                                                         prefix.c_str()).c_str()));
+	pass2SProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache(shaderFname, pps.c_str(),
+	                                                                     prefix.c_str()).c_str());
 	pass2SProgFaiUniVar = pass2SProg->findUniVar("fai");
 }
 

src/Renderer/Is.cpp

@@ -101,14 +101,14 @@ void Renderer::Is::initFbo()
 void Renderer::Is::init()
 {
 	// load the shaders
-	ambientPassSProg.reset(Resource::shaders.load("shaders/IsAp.glsl"));
+	ambientPassSProg = Resource::shaders.load("shaders/IsAp.glsl");
 	ambientColUniVar = ambientPassSProg->findUniVar("ambientCol");
 	sceneColMapUniVar = ambientPassSProg->findUniVar("sceneColMap");
 
 	// point light
-	pointLightSProg.reset(Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
-	                                                                             "#define POINT_LIGHT_ENABLED\n",
-	                                                                             "Point").c_str()));
+	pointLightSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
+	                                                                          "#define POINT_LIGHT_ENABLED\n",
+	                                                                          "Point").c_str());
 	pointLightSProgUniVars.msNormalFai = pointLightSProg->findUniVar("msNormalFai");
 	pointLightSProgUniVars.msDiffuseFai = pointLightSProg->findUniVar("msDiffuseFai");
 	pointLightSProgUniVars.msSpecularFai = pointLightSProg->findUniVar("msSpecularFai");
@@ -121,9 +121,9 @@ void Renderer::Is::init()
 
 
 	// spot light no shadow
-	spotLightNoShadowSProg.reset(Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
-	                                                                                     "#define SPOT_LIGHT_ENABLED\n",
-	                                                                                     "SpotNoShadow").c_str()));
+	spotLightNoShadowSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
+	                                                                                 "#define SPOT_LIGHT_ENABLED\n",
+	                                                                                 "SpotNoShadow").c_str());
 	spotLightNoShadowSProgUniVars.msNormalFai = spotLightNoShadowSProg->findUniVar("msNormalFai");
 	spotLightNoShadowSProgUniVars.msDiffuseFai = spotLightNoShadowSProg->findUniVar("msDiffuseFai");
 	spotLightNoShadowSProgUniVars.msSpecularFai = spotLightNoShadowSProg->findUniVar("msSpecularFai");
@@ -146,9 +146,9 @@ void Renderer::Is::init()
 		pps += "#define PCF_ENABLED\n";
 		prefix += "Pcf";
 	}
-	spotLightShadowSProg.reset(Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
-	                                                                                   pps.c_str(),
-	                                                                                   prefix.c_str()).c_str()));
+	spotLightShadowSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/IsLpGeneric.glsl",
+	                                                                                pps.c_str(),
+	                                                                                prefix.c_str()).c_str());
 	spotLightShadowSProgUniVars.msNormalFai = spotLightShadowSProg->findUniVar("msNormalFai");
 	spotLightShadowSProgUniVars.msDiffuseFai = spotLightShadowSProg->findUniVar("msDiffuseFai");
 	spotLightShadowSProgUniVars.msSpecularFai = spotLightShadowSProg->findUniVar("msSpecularFai");

src/Renderer/MainRenderer.cpp

@@ -16,7 +16,7 @@ void MainRenderer::init(const RendererInitializer& initializer_)
 
 	initGl();
 
-	sProg.reset(Resource::shaders.load("shaders/final.glsl"));
+	sProg = Resource::shaders.load("shaders/final.glsl");
 
 	//
 	// init the offscreen Renderer

src/Renderer/MainRenderer.h

@@ -42,7 +42,7 @@ class MainRenderer: public Renderer
 		void takeScreenshot(const char* filename);
 
 	private:
-		auto_ptr<ShaderProg> sProg; ///< Final pass' shader program
+		RsrcPtr<ShaderProg> sProg; ///< Final pass' shader program
 
 		bool takeScreenshotTga(const char* filename);
 		bool takeScreenshotJpeg(const char* filename);

src/Renderer/Pps.cpp

@@ -43,9 +43,8 @@ void Renderer::Pps::initPrePassSProg()
 		prefix += "Ssao";
 	}
 
-	prePassSProg.reset(Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsPrePass.glsl",
-	                                                                           pps.c_str(),
-	                                                                           prefix.c_str()).c_str()));
+	prePassSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsPrePass.glsl", pps.c_str(),
+	                                                                       prefix.c_str()).c_str());
 	prePassSProg->bind();
 
 	if(ssao.enabled)
@@ -71,9 +70,8 @@ void Renderer::Pps::initPostPassSProg()
 		prefix += "Hdr";
 	}
 
-	postPassSProg.reset(Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsPostPass.glsl",
-	                                                                            pps.c_str(),
-	                                                                            prefix.c_str()).c_str()));
+	postPassSProg = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsPostPass.glsl", pps.c_str(),
+	                                                                         prefix.c_str()).c_str());
 	postPassSProg->bind();
 
 	if(hdr.enabled)

src/Renderer/Renderer.h

@@ -7,6 +7,8 @@
 #include "Texture.h"
 #include "ShaderProg.h"
 #include "Vbo.h"
+#include "RsrcPtr.h"
+
 
 class Camera;
 class PointLight;
@@ -135,7 +137,7 @@ class Renderer
 					private:
 						static float sMOUvSCoords[]; ///< Illumination stage stencil masking optimizations UV sphere vertex positions
 						static Vbo sMOUvSVbo; ///< Illumination stage stencil masking optimizations UV sphere VBO
-						auto_ptr<ShaderProg> sProg;
+						RsrcPtr<ShaderProg> sProg;
 						const ShaderProg::UniVar* modelViewProjectionMatUniVar;
 
 						void init();
@@ -171,10 +173,10 @@ class Renderer
 				Texture fai;
 				Fbo fbo; ///< This FBO writes to the Is::fai
 				uint stencilRb; ///< Illumination stage stencil buffer
-				auto_ptr<ShaderProg> ambientPassSProg; ///< Illumination stage ambient pass shader program
-				auto_ptr<ShaderProg> pointLightSProg; ///< Illumination stage point light shader program
-				auto_ptr<ShaderProg> spotLightNoShadowSProg; ///< Illumination stage spot light w/o shadow shader program
-				auto_ptr<ShaderProg> spotLightShadowSProg; ///< Illumination stage spot light w/ shadow shader program
+				RsrcPtr<ShaderProg> ambientPassSProg; ///< Illumination stage ambient pass shader program
+				RsrcPtr<ShaderProg> pointLightSProg; ///< Illumination stage point light shader program
+				RsrcPtr<ShaderProg> spotLightNoShadowSProg; ///< Illumination stage spot light w/o shadow shader program
+				RsrcPtr<ShaderProg> spotLightShadowSProg; ///< Illumination stage spot light w/ shadow shader program
 				const ShaderProg::UniVar* ambientColUniVar;
 				const ShaderProg::UniVar* sceneColMapUniVar;
 				UniVars pointLightSProgUniVars;
@@ -226,9 +228,9 @@ class Renderer
 						Fbo pass0Fbo;
 						Fbo pass1Fbo;
 						Fbo pass2Fbo;
-						auto_ptr<ShaderProg> pass0SProg;
-						auto_ptr<ShaderProg> pass1SProg;
-						auto_ptr<ShaderProg> pass2SProg;
+						RsrcPtr<ShaderProg> pass0SProg;
+						RsrcPtr<ShaderProg> pass1SProg;
+						RsrcPtr<ShaderProg> pass2SProg;
 						const ShaderProg::UniVar* pass0SProgFaiUniVar;
 						const ShaderProg::UniVar* pass1SProgFaiUniVar;
 						const ShaderProg::UniVar* pass2SProgFaiUniVar;
@@ -267,10 +269,10 @@ class Renderer
 						Fbo pass1Fbo;
 						Fbo pass2Fbo;
 						uint width, height, bwidth, bheight;
-						auto_ptr<Texture> noiseMap;
-						auto_ptr<ShaderProg> ssaoSProg;
-						auto_ptr<ShaderProg> blurSProg;
-						auto_ptr<ShaderProg> blurSProg2;
+						RsrcPtr<Texture> noiseMap;
+						RsrcPtr<ShaderProg> ssaoSProg;
+						RsrcPtr<ShaderProg> blurSProg;
+						RsrcPtr<ShaderProg> blurSProg2;
 						const ShaderProg::UniVar* camerarangeUniVar;
 						const ShaderProg::UniVar* msDepthFaiUniVar;
 						const ShaderProg::UniVar* noiseMapUniVar;
@@ -312,8 +314,8 @@ class Renderer
 				Texture postPassFai;
 				Fbo prePassFbo;
 				Fbo postPassFbo;
-				auto_ptr<ShaderProg> prePassSProg;
-				auto_ptr<ShaderProg> postPassSProg;
+				RsrcPtr<ShaderProg> prePassSProg;
+				RsrcPtr<ShaderProg> postPassSProg;
 				UniVars prePassSProgUniVars;
 				UniVars postPassSProgUniVars;
 
@@ -339,7 +341,7 @@ class Renderer
 			private:
 				Fbo fbo;
 				Fbo refractFbo;
-				auto_ptr<ShaderProg> refractSProg;
+				RsrcPtr<ShaderProg> refractSProg;
 				Texture refractFai;
 
 				void createFbo();
@@ -372,7 +374,7 @@ class Renderer
 
 			private:
 				Fbo fbo;
-				static ShaderProg* sProg;
+				static RsrcPtr<ShaderProg> sProg;
 				static Mat4 viewProjectionMat;
 
 				void init();

src/Renderer/Smo.cpp

@@ -19,7 +19,7 @@ Vbo Renderer::Is::Smo::sMOUvSVbo;
 //======================================================================================================================
 void Renderer::Is::Smo::init()
 {
-	sProg.reset(Resource::shaders.load("shaders/IsSmo.glsl"));
+	sProg = Resource::shaders.load("shaders/IsSmo.glsl");
 	modelViewProjectionMatUniVar = sProg->findUniVar("modelViewProjectionMat");
 
 	if(!sMOUvSVbo.isCreated())

src/Renderer/Ssao.cpp

@@ -82,18 +82,18 @@ void Renderer::Pps::Ssao::init()
 	// Shaders
 	//
 
-	ssaoSProg.reset(Resource::shaders.load("shaders/PpsSsao.glsl"));
+	ssaoSProg = Resource::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.reset(Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsSsaoBlur.glsl", pps.c_str(),
-	                                                                        prefix.c_str()).c_str()));
+	blurSProg = Resource::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.reset(Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsSsaoBlur.glsl", pps.c_str(),
-	                                                                         prefix.c_str()).c_str()));
+	blurSProg2 = Resource::shaders.load(ShaderProg::createSrcCodeToCache("shaders/PpsSsaoBlur.glsl", pps.c_str(),
+	                                                                      prefix.c_str()).c_str());
 
 	camerarangeUniVar = ssaoSProg->findUniVar("camerarange");
 	msDepthFaiUniVar = ssaoSProg->findUniVar("msDepthFai");
@@ -113,7 +113,7 @@ void Renderer::Pps::Ssao::init()
 	bool mipmaping = Texture::mipmappingEnabled;
 	Texture::compressionEnabled = false;
 	Texture::mipmappingEnabled = true;
-	noiseMap.reset(Resource::textures.load("gfx/noise3.tga"));
+	noiseMap = Resource::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/ResourceContainer.h

@@ -18,15 +18,15 @@ class ResourceContainer: public Vec<Type*>
 		typedef typename BaseClass::iterator Iterator; ///< Just to save me time from typing
 
 	public:
-		RsrcPtr<Type> load_(const char* fname);
+		RsrcPtr<Type> load(const char* fname);
 
-	public:
+	private:
 		/**
 		 * load an object and register it. If its already loaded return its pointer
 		 * @param fname The filename that initializes the object
 		 * @return A pointer of a new resource or NULL on fail
 		 */
-		Type* load(const char* fname);
+		Type* load2(const char* fname);
 
 		/**
 		 * unload item. If nobody else uses it then delete it completely

src/Resources/ResourceContainer.inl.h

@@ -58,10 +58,10 @@ typename ResourceContainer<Type>::Iterator ResourceContainer<Type>::findByPtr(Ty
 
 
 //======================================================================================================================
-// load                                                                                                                =
+// load2                                                                                                               =
 //======================================================================================================================
 template<typename Type>
-Type* ResourceContainer<Type>::load(const char* fname)
+Type* ResourceContainer<Type>::load2(const char* fname)
 {
 	filesystem::path fpathname = filesystem::path(fname);
 	string name = fpathname.filename();
@@ -97,9 +97,9 @@ Type* ResourceContainer<Type>::load(const char* fname)
 // load                                                                                                                =
 //======================================================================================================================
 template<typename Type>
-RsrcPtr<Type> ResourceContainer<Type>::load_(const char* fname)
+RsrcPtr<Type> ResourceContainer<Type>::load(const char* fname)
 {
-	Type* p = load(fname);
+	Type* p = load2(fname);
 
 	if(!p)
 	{

src/Resources/RsrcPtr.h

@@ -27,9 +27,10 @@ class RsrcPtr
 
 		~RsrcPtr();
 
-		RsrcPtr<Type>& operator=(RsrcPtr<Type>& a);
+		RsrcPtr<Type>& operator=(const RsrcPtr<Type>& a);
 		Type& operator*();
 		Type* operator->();
+		Type* get();
 
 	private:
 		/**
@@ -74,13 +75,14 @@ RsrcPtr<Type>::~RsrcPtr()
 
 
 template<typename Type>
-RsrcPtr<Type>& RsrcPtr<Type>::operator=(RsrcPtr<Type>& a)
+RsrcPtr<Type>& RsrcPtr<Type>::operator=(const RsrcPtr<Type>& a)
 {
 	DEBUG_ERR(p != NULL);
 	p = a.p;
 	return *this;
 }
 
+
 template<typename Type>
 Type& RsrcPtr<Type>::operator*()
 {
@@ -94,5 +96,10 @@ Type* RsrcPtr<Type>::operator->()
 	return p;
 }
 
+template<typename Type>
+Type* RsrcPtr<Type>::get()
+{
+	return p;
+}
 
 #endif

src/Resources/Texture.cpp

@@ -17,7 +17,7 @@ int Texture::anisotropyLevel = 8;
 // Constructor                                                                                                         =
 //======================================================================================================================
 Texture::Texture():
-	Resource(RT_MATERIAL),
+	Resource(RT_TEXTURE),
 	glId(numeric_limits<uint>::max()),
 	target(GL_TEXTURE_2D)
 {
@@ -143,6 +143,7 @@ bool Texture::createEmpty2DMsaa(int samplesNum, int internalFormat, int width_,
 void Texture::unload()
 {
 	glDeleteTextures(1, &glId);
+	INFO("ASFD");
 }
 
 

src/Scene/Controllers/SkelAnimCtrl.h

@@ -5,6 +5,7 @@
 #include "Vec.h"
 #include "Controller.h"
 #include "Math.h"
+#include "RsrcPtr.h"
 
 class Skeleton;
 class SkelAnim;
@@ -21,7 +22,7 @@ class SkelAnimCtrl: public Controller
 		void deform();  ///< Now with HW skinning it deforms only the debug skeleton
 
 	public:
-		SkelAnim* skelAnim; ///< Skeleton animation resource
+		RsrcPtr<SkelAnim> skelAnim; ///< Skeleton animation resource
 		SkelNode* skelNode;
 		Vec<Vec3> heads;
 		Vec<Vec3> tails;

src/Scene/Light.h

@@ -21,6 +21,8 @@ Specular intensity of material: Sm
 #include "Texture.h"
 #include "SceneNode.h"
 #include "Camera.h"
+#include "RsrcPtr.h"
+
 
 class LightProps;
 
@@ -32,7 +34,7 @@ class Light: public SceneNode
 		enum Type { LT_POINT, LT_SPOT };
 
 		Type type;
-		LightProps* lightProps; ///< Later we will add a controller
+		RsrcPtr<LightProps> lightProps; ///< Later we will add a controller
 	
 		Light(Type type_): SceneNode(NT_LIGHT), type(type_) {}
 		//void init(const char*);

src/Scene/SkelNode.h

@@ -5,6 +5,10 @@
 #include "SceneNode.h"
 #include "Controller.h"
 #include "Math.h"
+#include "RsrcPtr.h"
+
+
+class SkelAnimCtrl;
 
 
 /**
@@ -14,7 +18,7 @@ class SkelNode: public SceneNode
 {
 	public:
 		class Skeleton* skeleton; ///< The skeleton resource
-		class SkelAnimCtrl* skelAnimCtrl; ///< Hold the controller here as well
+		RsrcPtr<SkelAnimCtrl> skelAnimCtrl; ///< Hold the controller here as well
 
 		SkelNode();
 		void render();