From 39312a23ddbaddffc03527d0e927b7ee45a95bb1 Mon Sep 17 00:00:00 2001
From: spartanj <none@none>
Date: Fri, 30 Jul 2010 00:59:49 -0300
Subject: [PATCH] Optimized tSoundManager. Added tSoundLoader, a template used
 for the ResourceLoader. Fixed PushText on the Console. Added loading from
 memory on shaders. Added FileExtension to get file extension. Added to Packs
 ExtractToFile and Add using pointers instead of std::vectors ( to give
 flexibility ). And fixed some minor bugs.

---
 ee.linux.cbp                     |   2 +
 src/audio/csound.cpp             |   2 +-
 src/audio/csoundbuffer.cpp       |   2 +-
 src/audio/tsoundloader.hpp       | 166 +++++++++++++++++++++++++++++++
 src/audio/tsoundmanager.hpp      |  50 +++++++---
 src/ee.h                         |   1 +
 src/graphics/cconsole.cpp        |  58 +++++------
 src/graphics/cshader.cpp         |  74 ++++++++++----
 src/graphics/cshader.hpp         |  20 ++--
 src/graphics/cshaderprogram.cpp  |  27 ++++-
 src/graphics/cshaderprogram.hpp  |   5 +-
 src/graphics/cshapemanager.cpp   |  16 +--
 src/graphics/cshapemanager.hpp   |   3 +-
 src/graphics/ctexturefactory.cpp |   8 +-
 src/graphics/ctextureloader.cpp  |   2 +-
 src/graphics/ctextureloader.hpp  |   2 +-
 src/system/cobjectloader.hpp     |   1 +
 src/system/cpack.hpp             |  12 ++-
 src/system/cpak.cpp              |  36 +++++--
 src/system/cpak.hpp              |   6 ++
 src/system/czip.cpp              |  33 +++++-
 src/system/czip.hpp              |   6 ++
 src/test/ee.cpp                  |  18 ++--
 src/utils/string.cpp             |   4 +
 src/utils/utils.cpp              |   6 ++
 src/utils/utils.hpp              |   3 +
 26 files changed, 452 insertions(+), 111 deletions(-)
 create mode 100644 src/audio/tsoundloader.hpp

diff --git a/ee.linux.cbp b/ee.linux.cbp
index 194ce59d1..3e9abc251 100644
--- a/ee.linux.cbp
+++ b/ee.linux.cbp
@@ -13,6 +13,7 @@
 				<Option compiler="gcc" />
 				<Compiler>
 					<Add option="-g" />
+					<Add option="-DEE_DEBUG" />
 				</Compiler>
 			</Target>
 			<Target title="Release">
@@ -63,6 +64,7 @@
 		<Unit filename="src/audio/csoundstream.cpp" />
 		<Unit filename="src/audio/csoundstream.hpp" />
 		<Unit filename="src/audio/openal.hpp" />
+		<Unit filename="src/audio/tsoundloader.hpp" />
 		<Unit filename="src/audio/tsoundmanager.hpp" />
 		<Unit filename="src/base.hpp" />
 		<Unit filename="src/ee.h" />
diff --git a/src/audio/csound.cpp b/src/audio/csound.cpp
index ae9264f12..035aa4426 100755
--- a/src/audio/csound.cpp
+++ b/src/audio/csound.cpp
@@ -75,7 +75,7 @@ void cSound::Position( const eeFloat& X, const eeFloat& Y, const eeFloat& Z ) {
 }
 
 void cSound::Position( const Vector3AL& Position ) {
-	this->Position(Position.x, Position.y, Position.z);
+	this->Position( Position.x, Position.y, Position.z );
 }
 
 void cSound::MinDistance( const eeFloat& MinDistance ) {
diff --git a/src/audio/csoundbuffer.cpp b/src/audio/csoundbuffer.cpp
index e41975cf6..10502ec77 100755
--- a/src/audio/csoundbuffer.cpp
+++ b/src/audio/csoundbuffer.cpp
@@ -85,7 +85,7 @@ bool cSoundBuffer::LoadFromMemory( const char* Data, std::size_t SizeInBytes ) {
 			cLog::instance()->Write( "Failed to read audio data from file in memory" );
 			return false;
 		}
-	}else {
+	} else {
 		cLog::instance()->Write( "Failed to load sound buffer from file in memory" );
 		return false;
 	}
diff --git a/src/audio/tsoundloader.hpp b/src/audio/tsoundloader.hpp
new file mode 100644
index 000000000..9dd44b635
--- /dev/null
+++ b/src/audio/tsoundloader.hpp
@@ -0,0 +1,166 @@
+#ifndef EE_AUDIOTSOUNDLOADER_HPP
+#define EE_AUDIOTSOUNDLOADER_HPP
+
+#include "base.hpp"
+#include "tsoundmanager.hpp"
+#include "../system/cobjectloader.hpp"
+
+namespace EE { namespace Audio {
+
+#define SND_LT_PATH 	(1)
+#define SND_LT_MEM 		(2)
+#define SND_LT_PACK 	(3)
+#define SND_LT_SAMPLES	(4)
+
+template <typename T>
+class EE_API tSoundLoader : public cObjectLoader {
+	public:
+		tSoundLoader( tSoundManager<T> * SndMngr, const T& id, const std::string& filepath );
+
+		tSoundLoader( tSoundManager<T> * SndMngr, const T& id, const char* Data, std::size_t SizeInBytes );
+
+		tSoundLoader( tSoundManager<T> * SndMngr, const T& id, const Int16* Samples, std::size_t SamplesCount, unsigned int ChannelsCount, unsigned int SampleRate );
+
+		tSoundLoader( tSoundManager<T> * SndMngr, const T& id, cPack* Pack, const std::string& FilePackPath );
+
+		~tSoundLoader();
+
+		void 					Update();
+
+		const T&				Id() const;
+	protected:
+		Uint32					mLoadType;
+		tSoundManager<T> *		mSndMngr;
+		T						mId;
+		std::string 			mFilepath;
+		const char * 			mData;
+		Uint32					mDataSize;
+		const Int16 *			mSamples;
+		Uint32					mSamplesCount;
+		Uint32					mChannelsCount;
+		Uint32					mSampleRate;
+		cPack *					mPack;
+
+		void 					Start();
+	private:
+		void 					LoadFromPath();
+		void					LoadFromMemory();
+		void					LoadFromPack();
+		void 					LoadFromSamples();
+};
+
+template <typename T>
+tSoundLoader<T>::tSoundLoader( tSoundManager<T> * SndMngr,
+	const T& id,
+	const std::string& filepath
+) : cObjectLoader( cObjectLoader::SoundLoader ),
+	mLoadType(SND_LT_PATH),
+	mSndMngr(SndMngr),
+	mId(id),
+	mFilepath(filepath)
+{
+}
+
+template <typename T>
+tSoundLoader<T>::tSoundLoader( tSoundManager<T> * SndMngr,
+	const T& id,
+	const char * Data,
+	std::size_t SizeInBytes
+) : cObjectLoader( cObjectLoader::SoundLoader ),
+	mLoadType(SND_LT_MEM),
+	mSndMngr(SndMngr),
+	mId(id),
+	mData(Data),
+	mDataSize(SizeInBytes)
+{
+}
+
+template <typename T>
+tSoundLoader<T>::tSoundLoader( tSoundManager<T> * SndMngr,
+	const T& id,
+	const Int16* Samples,
+	std::size_t SamplesCount,
+	unsigned int ChannelsCount,
+	unsigned int SampleRate
+) : cObjectLoader( cObjectLoader::SoundLoader ),
+	mLoadType(SND_LT_SAMPLES),
+	mSndMngr(SndMngr),
+	mId(id),
+	mSamples(Samples),
+	mSamplesCount(SamplesCount),
+	mChannelsCount(ChannelsCount),
+	mSampleRate(SampleRate)
+{
+}
+
+template <typename T>
+tSoundLoader<T>::tSoundLoader( tSoundManager<T> * SndMngr,
+	const T& id, cPack* Pack,
+	const std::string& FilePackPath
+) : cObjectLoader( cObjectLoader::SoundLoader ),
+	mLoadType(SND_LT_PACK),
+	mSndMngr(SndMngr),
+	mId(id),
+	mFilepath(FilePackPath),
+	mPack(Pack)
+{
+}
+
+template <typename T>
+tSoundLoader<T>::~tSoundLoader() {
+
+}
+
+template <typename T>
+void tSoundLoader<T>::Update() {
+
+}
+
+template <typename T>
+void tSoundLoader<T>::Start() {
+	if ( NULL != mSndMngr ) {
+		cObjectLoader::Start();
+
+		if ( SND_LT_PATH == mLoadType )
+			LoadFromPath();
+		else if ( SND_LT_MEM == mLoadType )
+			LoadFromMemory();
+		else if ( SND_LT_PACK == mLoadType )
+			LoadFromPack();
+		else if ( SND_LT_SAMPLES == mLoadType )
+			LoadFromSamples();
+
+		SetLoaded();
+	}
+}
+
+template <typename T>
+void tSoundLoader<T>::LoadFromPath() {
+	mSndMngr->LoadFromFile( mId, mFilepath );
+}
+
+template <typename T>
+void tSoundLoader<T>::LoadFromMemory() {
+	mSndMngr->LoadFromMemory( mId, mData, mDataSize );
+}
+
+template <typename T>
+void tSoundLoader<T>::LoadFromPack() {
+	mSndMngr->LoadFromPack( mId, mPack, mFilepath );
+}
+
+template <typename T>
+void tSoundLoader<T>::LoadFromSamples() {
+	mSndMngr->LoadFromSamples( mId, mSamples, mSamplesCount, mChannelsCount, mSampleRate );
+}
+
+template <typename T>
+const T& tSoundLoader<T>::Id() const {
+	return mId;
+}
+
+typedef tSoundLoader<std::string>	cSoundLoader;
+
+}}
+
+#endif
diff --git a/src/audio/tsoundmanager.hpp b/src/audio/tsoundmanager.hpp
index 8090d1544..944753f4c 100755
--- a/src/audio/tsoundmanager.hpp
+++ b/src/audio/tsoundmanager.hpp
@@ -15,7 +15,7 @@ class EE_API tSoundManager{
 		bool LoadFromMemory( const T& id, const char* Data, std::size_t SizeInBytes );
 		bool LoadFromSamples( const T& id, const Int16* Samples, std::size_t SamplesCount, unsigned int ChannelsCount, unsigned int SampleRate );
 		bool LoadFromPack( const T& id, cPack* Pack, const std::string& FilePackPath );
-		
+
 		cSoundBuffer& GetBuffer( const T& id );
 
 		/** This method will open a new channel if the channel seted for the sound is playing. */
@@ -37,44 +37,56 @@ class EE_API tSoundManager{
 template <typename T>
 bool tSoundManager<T>::LoadFromPack( const T& id, cPack* Pack, const std::string& FilePackPath ) {
 	if ( tSounds.find( id ) == tSounds.end() ) { // if id doesn't exists
-		if ( tSounds[id].Buf.LoadFromPack( Pack, FilePackPath ) ) {
-			tSounds[id].Snd.push_back( cSound( tSounds[id].Buf ) );
+		sSound * tSound = &tSounds[id];
+
+		if ( tSound->Buf.LoadFromPack( Pack, FilePackPath ) ) {
+			tSound->Snd.push_back( cSound( tSound->Buf ) );
 			return true;
 		}
 	}
+
 	return false;
 }
 
 template <typename T>
 bool tSoundManager<T>::LoadFromFile( const T& id, const std::string& filepath ) {
 	if ( tSounds.find( id ) == tSounds.end() ) { // if id doesn't exists
-		if ( tSounds[id].Buf.LoadFromFile( filepath ) ) {
-			tSounds[id].Snd.push_back( cSound( tSounds[id].Buf ) );
+		sSound * tSound = &tSounds[id];
+
+		if ( tSound->Buf.LoadFromFile( filepath ) ) {
+			tSound->Snd.push_back( cSound( tSound->Buf ) );
 			return true;
 		}
 	}
+
 	return false;
 }
 
 template <typename T>
 bool tSoundManager<T>::LoadFromMemory( const T& id, const char* Data, std::size_t SizeInBytes ) {
 	if ( tSounds.find( id ) == tSounds.end() ) { // if id doesn't exists
-		if ( tSounds[id].Buf.LoadFromMemory( Data, SizeInBytes ) ) {
-			tSounds[id].Snd.push_back( cSound( tSounds[id].Buf ) );
+		sSound * tSound = &tSounds[id];
+
+		if ( tSound->Buf.LoadFromMemory( Data, SizeInBytes ) ) {
+			tSound->Snd.push_back( cSound( tSound->Buf ) );
 			return true;
 		}
 	}
+
 	return false;
 }
 
 template <typename T>
 bool tSoundManager<T>::LoadFromSamples( const T& id, const Int16* Samples, std::size_t SamplesCount, unsigned int ChannelsCount, unsigned int SampleRate ) {
 	if ( tSounds.find( id ) == tSounds.end() ) { // if id doesn't exists
-		if ( tSounds[id].Buf.LoadFromSamples( Samples, SamplesCount, ChannelsCount, SampleRate ) ) {
-			tSounds[id].Snd.push_back( cSound( tSounds[id].Buf ) );
+		sSound * tSound = &tSounds[id];
+
+		if ( tSound->Buf.LoadFromSamples( Samples, SamplesCount, ChannelsCount, SampleRate ) ) {
+			tSound->Snd.push_back( cSound( tSound->Buf ) );
 			return true;
 		}
 	}
+
 	return false;
 }
 
@@ -94,24 +106,30 @@ cSound& tSoundManager<T>::operator[] ( const T& id ) {
 
 template <typename T>
 void tSoundManager<T>::Play( const T& id ) {
-	if ( tSounds.find( id ) != tSounds.end() ) {
-		for ( Uint32 i = 0; i < tSounds[id].Snd.size(); i++ ) {
+	typename std::map<T, sSound>::iterator it = tSounds.find( id );
+
+	if ( it != tSounds.end() ) {
+		sSound * tSound = &it->second;
+		Uint32 tSize = tSound->Snd.size();
+
+		for ( Uint32 i = 0; i < tSize; i++ ) {
 			// If there is a free slot, use it.
-			if ( tSounds[id].Snd[i].GetState() != SOUND_PLAYING ) {
-				tSounds[id].Snd[i].Play();
+			if ( tSound->Snd[i].GetState() != SOUND_PLAYING ) {
+				tSound->Snd[i].Play();
 				return;
 			}
 		}
 
 		// Otherwise create a new one and play it.
-		tSounds[id].Snd.push_back( cSound( tSounds[id].Buf ) );
-		tSounds[id].Snd[ tSounds[id].Snd.size() - 1 ].Play();
+		tSound->Snd.push_back( cSound( tSound->Buf ) );
+		tSound->Snd[ tSize ].Play();
 	}
 }
 
 template <typename T>
 tSoundManager<T>::~tSoundManager() {
 	typename std::map<T, sSound>::iterator itr;
+
 	for (itr = tSounds.begin(); itr != tSounds.end(); itr++)
 		itr->second.Snd.clear();
 
@@ -124,10 +142,12 @@ bool tSoundManager<T>::Remove( const T& id ) {
 		tSounds.erase( id );
 		return true;
 	}
+
 	return false;
 }
 
 typedef tSoundManager<std::string> cSoundManager;
+
 }}
 
 #endif
diff --git a/src/ee.h b/src/ee.h
index 3a1514940..91fdb82ed 100755
--- a/src/ee.h
+++ b/src/ee.h
@@ -72,6 +72,7 @@
 	#include "audio/csoundbuffer.hpp"
 	#include "audio/csoundstream.hpp"
 	#include "audio/cmusic.hpp"
+	#include "audio/tsoundloader.hpp"
 	#include "audio/tsoundmanager.hpp"
 	using namespace EE::Audio;
 
diff --git a/src/graphics/cconsole.cpp b/src/graphics/cconsole.cpp
index 6b99a43ea..dfe110024 100755
--- a/src/graphics/cconsole.cpp
+++ b/src/graphics/cconsole.cpp
@@ -203,44 +203,38 @@ void cConsole::PushText( const std::string& str ) {
 	PrivPushText( toWStr( str ) );
 }
 
-void cConsole::PushText( const char* format, ... ) {
-	char buf[256];
+void cConsole::PushText( const char * format, ... ) {
+	int n, size = 256;
+	std::string tstr( size, '\0' );
 
-	va_list( args );
+	va_list args;
 
-	va_start( args, format );
+	while (1) {
+		va_start( args, format );
 
-	#ifdef EE_COMPILER_MSVC
-	int nb = _vsnprintf_s( buf, 256, 256, format, args );
-	#else
-	int nb = vsnprintf(buf, 256, format, args);
-	#endif
+		#ifdef EE_COMPILER_MSVC
+			n = _vsnprintf_s( &tstr[0], size, size, format, args );
+		#else
+			n = vsnprintf( &tstr[0], size, format, args );
+		#endif
 
-	va_end( args );
+		va_end( args );
 
-	if ( nb < 256 ) {
-		PrivPushText( toWStr( std::string( buf ) ) );
-		return;
+		if ( n > -1 && n < size ) {
+			tstr.resize( n );
+
+			PushText( tstr );
+
+			return;
+		}
+
+		if ( n > -1 )	// glibc 2.1
+			size = n+1; // precisely what is needed
+		else			// glibc 2.0
+			size *= 2;	// twice the old size
+
+		tstr.resize( size, '\0' );
 	}
-
-	// The static size was not big enough, try again with a dynamic allocation.
-	++nb;
-
-	char * buf2 = new char[nb];
-
-	va_start( args, format );
-
-	#ifdef EE_COMPILER_MSVC
-	_vsnprintf_s( buf2, nb, nb, format, args );
-	#else
-	vsnprintf( buf2, nb, format, args );
-	#endif
-
-	va_end( args );
-
-	PrivPushText( toWStr( std::string( buf2 ) ) );
-
-	delete [] buf2;
 }
 
 void cConsole::Toggle() {
diff --git a/src/graphics/cshader.cpp b/src/graphics/cshader.cpp
index d2b07bea2..9b398e06b 100644
--- a/src/graphics/cshader.cpp
+++ b/src/graphics/cshader.cpp
@@ -28,21 +28,28 @@ cShader::cShader( const Uint32& Type, const std::string& Filename ) {
     Compile();
 }
 
+cShader::cShader( const Uint32& Type, const Uint8 * Data, const Uint32& DataSize ) {
+	Init( Type );
+
+	SetSource( Data, DataSize );
+
+	Compile();
+}
+
 cShader::~cShader() {
-	glDeleteShader( GetId() );
+	if ( 0 != mGLId )
+		glDeleteShader( mGLId );
 }
 
 void cShader::Init( const Uint32& Type ) {
-	mType = Type;
-	mValid = false;
-	mCompiled = false;
-	mGLId = glCreateShader( mType );
+	mType 		= Type;
+	mValid 		= false;
+	mCompiled 	= false;
+	mGLId 		= glCreateShader( mType );
 }
 
 void cShader::Reload() {
-	mValid = false;
-	mCompiled = false;
-	mGLId = glCreateShader( mType );
+	Init( mType );
 
 	SetSource( mSource );
 
@@ -51,12 +58,18 @@ void cShader::Reload() {
 
 void cShader::SetSource( const std::string& Source ) {
 	std::vector<char> _dst( Source.size(), 0 );
-	std::string _src( Source.size(), 0 );
-	_src = Source;
 
-	memcpy( reinterpret_cast<char*>( &_dst[0] ), reinterpret_cast<char*>( &_src[0] ), Source.size() );
+	memcpy( reinterpret_cast<char*>( &_dst[0] ), reinterpret_cast<const void*>( &Source[0] ), Source.size() );
 
-	SetSource( _src );
+	SetSource( _dst );
+}
+
+void cShader::SetSource( const Uint8 * Data, const Uint32& DataSize ) {
+	std::vector<char> _dst( DataSize, 0 );
+
+	memcpy( reinterpret_cast<char*>( &_dst[0] ), reinterpret_cast<const void*>( &Data[0] ), DataSize );
+
+	SetSource( _dst );
 }
 
 void cShader::SetSource( const std::vector<char>& Source ) {
@@ -67,9 +80,9 @@ void cShader::SetSource( const std::vector<char>& Source ) {
 
     mSource = Source;
 
-	const char* src = &Source[0];
+	const char * src = &Source[0];
 
-	glShaderSource( GetId(), 1, &src, NULL );
+	glShaderSource( mGLId, 1, &src, NULL );
 }
 
 bool cShader::Compile() {
@@ -102,9 +115,34 @@ bool cShader::Compile() {
 	return mValid;
 }
 
-cVertexShader::cVertexShader() : cShader( GL_VERTEX_SHADER ) {}
-cVertexShader::cVertexShader( const std::string& Filename ) : cShader( GL_VERTEX_SHADER, Filename ) {}
-cFragmentShader::cFragmentShader() : cShader(GL_FRAGMENT_SHADER) {}
-cFragmentShader::cFragmentShader( const std::string& Filename ) : cShader( GL_FRAGMENT_SHADER, Filename ) {}
+cVertexShader::cVertexShader() :
+	cShader( GL_VERTEX_SHADER )
+{
+}
+
+cVertexShader::cVertexShader( const std::string& Filename ) :
+	cShader( GL_VERTEX_SHADER, Filename )
+{
+}
+
+cVertexShader::cVertexShader( const Uint8 * Data, const Uint32& DataSize ) :
+	cShader( GL_VERTEX_SHADER, Data, DataSize )
+{
+}
+
+cFragmentShader::cFragmentShader() :
+	cShader(GL_FRAGMENT_SHADER)
+{
+}
+
+cFragmentShader::cFragmentShader( const std::string& Filename ) :
+	cShader( GL_FRAGMENT_SHADER, Filename )
+{
+}
+
+cFragmentShader::cFragmentShader( const Uint8 * Data, const Uint32& DataSize ) :
+	cShader( GL_FRAGMENT_SHADER, Data, DataSize )
+{
+}
 
 }}
diff --git a/src/graphics/cshader.hpp b/src/graphics/cshader.hpp
index 83b029c1b..d4b18886a 100644
--- a/src/graphics/cshader.hpp
+++ b/src/graphics/cshader.hpp
@@ -14,6 +14,9 @@ class EE_API cShader {
     	/** Create a type of shader and load the shader from a file, and compile it. */
     	cShader( const Uint32& Type, const std::string& Filename );
 
+    	/** Create a type of shader from memory, and compile it. */
+    	cShader( const Uint32& Type, const Uint8 * Data, const Uint32& DataSize );
+
     	virtual ~cShader();
 
     	/** Set the shader source */
@@ -22,6 +25,9 @@ class EE_API cShader {
     	/** Set the shader source */
     	void SetSource( const std::vector<char>& Source );
 
+    	/** Set the shader source */
+    	void SetSource( const Uint8 * Data, const Uint32& DataSize );
+
     	/** Compile the shader */
     	bool Compile();
 
@@ -43,12 +49,12 @@ class EE_API cShader {
     	/** Reloads the Shader. */
     	void Reload();
     protected:
-    	GLuint mGLId;
-    	GLenum mType;
-    	bool mValid;
-    	bool mCompiled;
-    	std::string mCompileLog;
-        std::vector<char> mSource;
+    	GLuint 				mGLId;
+    	GLenum 				mType;
+    	bool 				mValid;
+    	bool 				mCompiled;
+    	std::string 		mCompileLog;
+        std::vector<char> 	mSource;
 
     	void Init( const Uint32& Type );
 };
@@ -58,6 +64,7 @@ class EE_API cVertexShader : public cShader {
 	public:
     	cVertexShader();
     	cVertexShader( const std::string& Filename );
+    	cVertexShader( const Uint8 * Data, const Uint32& DataSize );
 };
 
 /** @brief Prebuild Fragment Shader class */
@@ -65,6 +72,7 @@ class EE_API cFragmentShader : public cShader {
 	public:
     	cFragmentShader();
     	cFragmentShader( const std::string& Filename );
+    	cFragmentShader( const Uint8 * Data, const Uint32& DataSize );
 };
 
 }}
diff --git a/src/graphics/cshaderprogram.cpp b/src/graphics/cshaderprogram.cpp
index 450c749bc..9eb0c1316 100644
--- a/src/graphics/cshaderprogram.cpp
+++ b/src/graphics/cshaderprogram.cpp
@@ -34,8 +34,29 @@ cShaderProgram::cShaderProgram( const std::string& VertexShaderFile, const std::
 	cFragmentShader * fs = new cFragmentShader( FragmentShaderFile );
 
 	if ( !vs->IsValid() || !fs->IsValid() ) {
-		delete vs;
-		delete fs;
+		eeSAFE_DELETE( vs );
+		eeSAFE_DELETE( fs );
+		return;
+	}
+
+	AddShader( vs );
+	AddShader( fs );
+
+	Link();
+}
+
+cShaderProgram::cShaderProgram( const Uint8 * VertexShaderData, const Uint32& VertexShaderDataSize, const Uint8 * FragmentShaderData, const Uint32& FragmentShaderDataSize, const std::string& name ) :
+	mGLId(0)
+{
+	AddToManager( name );
+	Init();
+
+	cVertexShader * vs = new cVertexShader( VertexShaderData, VertexShaderDataSize );
+	cFragmentShader * fs = new cFragmentShader( FragmentShaderData, FragmentShaderDataSize );
+
+	if ( !vs->IsValid() || !fs->IsValid() ) {
+		eeSAFE_DELETE( vs );
+		eeSAFE_DELETE( fs );
 		return;
 	}
 
@@ -53,7 +74,7 @@ cShaderProgram::~cShaderProgram() {
     mAttributeLocations.clear();
 
 	for ( eeUint i = 0; i < mShaders.size(); i++ )
-		delete mShaders[i];
+		eeSAFE_DELETE( mShaders[i] );
 }
 
 void cShaderProgram::AddToManager( const std::string& name ) {
diff --git a/src/graphics/cshaderprogram.hpp b/src/graphics/cshaderprogram.hpp
index 127561ae4..17ebf3b73 100644
--- a/src/graphics/cshaderprogram.hpp
+++ b/src/graphics/cshaderprogram.hpp
@@ -17,9 +17,12 @@ class EE_API cShaderProgram {
 		/** Construct a program shader with a vector of shaders and link them. */
 		cShaderProgram( const std::vector<cShader*>& Shaders, const std::string& name = "" );
 
-		/** Constructor that creates a VertexShader from file and a Fragment Shader from file, and Link them. */
+		/** Constructor that creates a VertexShader from file and a Fragment Shader from file, and link them. */
 		cShaderProgram( const std::string& VertexShaderFile, const std::string& FragmentShaderFile, const std::string& name = "" );
 
+		/** Constructor that creates a VertexShader from memory and a Fragment Shader from memory, and link them. */
+		cShaderProgram( const Uint8 * VertexShaderData, const Uint32& VertexShaderDataSize, const Uint8 * FragmentShaderData, const Uint32& FragmentShaderDataSize, const std::string& name = "" );
+
 		virtual ~cShaderProgram();
 
 		/** Add a new shader */
diff --git a/src/graphics/cshapemanager.cpp b/src/graphics/cshapemanager.cpp
index 3a366d38d..bd89d6ccf 100644
--- a/src/graphics/cshapemanager.cpp
+++ b/src/graphics/cshapemanager.cpp
@@ -78,14 +78,14 @@ bool cShapeManager::Remove( const std::string& Name ) {
 }
 
 cShape * cShapeManager::Add( cShape * Shape ) {
-	//assert null shape
-
-	if ( mCount < mShapes.size() ) {
-		mShapes[ mCount ] = Shape;
-		mCount++;
-	} else {
-		mShapes.push_back( Shape );
-		mCount++;
+	if ( NULL != Shape ) {
+		if ( mCount < mShapes.size() ) {
+			mShapes[ mCount ] = Shape;
+			mCount++;
+		} else {
+			mShapes.push_back( Shape );
+			mCount++;
+		}
 	}
 
 	return Shape;
diff --git a/src/graphics/cshapemanager.hpp b/src/graphics/cshapemanager.hpp
index 0596603cf..bc4496c43 100644
--- a/src/graphics/cshapemanager.hpp
+++ b/src/graphics/cshapemanager.hpp
@@ -32,7 +32,7 @@ class EE_API cShapeManager : public cSingleton<cShapeManager> {
 		bool Remove( const std::string& Name );
 
 		cShape * Add( cShape * Shape );
-		
+
 		cShape * Add( const Uint32& TexId, const std::string& Name = "" );
 
 		cShape * Add( const Uint32& TexId, const eeRecti& SrcRect, const std::string& Name = "" );
@@ -46,6 +46,7 @@ class EE_API cShapeManager : public cSingleton<cShapeManager> {
 		Uint32 Count();
 	protected:
 		std::vector<cShape*> mShapes;
+
 		Uint32 mCount;
 };
 
diff --git a/src/graphics/ctexturefactory.cpp b/src/graphics/ctexturefactory.cpp
index ab36c901e..c51714c7c 100755
--- a/src/graphics/ctexturefactory.cpp
+++ b/src/graphics/ctexturefactory.cpp
@@ -29,25 +29,25 @@ Uint32 cTextureFactory::CreateEmptyTexture( const eeUint& Width, const eeUint& H
 Uint32 cTextureFactory::LoadFromPixels( const unsigned char * Pixels, const eeUint& Width, const eeUint& Height, const eeUint& Channels, const bool& Mipmap, const eeRGB& ColorKey, const EE_CLAMP_MODE& ClampMode, const bool& CompressTexture, const bool& KeepLocalCopy, const std::string& FileName ) {
 	cTextureLoader myTex( Pixels, Width, Height, Channels, Mipmap, ColorKey, ClampMode, CompressTexture, KeepLocalCopy, FileName );
 	myTex.Load();
-	return myTex.TexId();
+	return myTex.Id();
 }
 
 Uint32 cTextureFactory::LoadFromPack( cPack* Pack, const std::string& FilePackPath, const bool& Mipmap, const eeRGB& ColorKey, const EE_CLAMP_MODE& ClampMode, const bool& CompressTexture, const bool& KeepLocalCopy  ) {
 	cTextureLoader myTex( Pack, FilePackPath, Mipmap, ColorKey, ClampMode, CompressTexture, KeepLocalCopy );
 	myTex.Load();
-	return myTex.TexId();
+	return myTex.Id();
 }
 
 Uint32 cTextureFactory::LoadFromMemory( const unsigned char * ImagePtr, const eeUint& Size, const bool& Mipmap, const eeRGB& ColorKey, const EE_CLAMP_MODE& ClampMode, const bool& CompressTexture, const bool& KeepLocalCopy ) {
 	cTextureLoader myTex( ImagePtr, Size, Mipmap, ColorKey, ClampMode, CompressTexture, KeepLocalCopy );
 	myTex.Load();
-	return myTex.TexId();
+	return myTex.Id();
 }
 
 Uint32 cTextureFactory::Load( const std::string& Filepath, const bool& Mipmap, const eeRGB& ColorKey, const EE_CLAMP_MODE& ClampMode, const bool& CompressTexture, const bool& KeepLocalCopy ) {
 	cTextureLoader myTex( Filepath, Mipmap, ColorKey, ClampMode, CompressTexture, KeepLocalCopy );
 	myTex.Load();
-	return myTex.TexId();
+	return myTex.Id();
 }
 
 Uint32 cTextureFactory::PushTexture( const std::string& Filepath, const Uint32& TexId, const eeUint& Width, const eeUint& Height, const eeUint& ImgWidth, const eeUint& ImgHeight, const bool& Mipmap, const eeUint& Channels, const eeRGB& ColorKey, const EE_CLAMP_MODE& ClampMode, const bool& CompressTexture, const bool& LocalCopy ) {
diff --git a/src/graphics/ctextureloader.cpp b/src/graphics/ctextureloader.cpp
index 952ad51e7..d84cd2cca 100644
--- a/src/graphics/ctextureloader.cpp
+++ b/src/graphics/ctextureloader.cpp
@@ -208,7 +208,7 @@ void cTextureLoader::Update() {
 	LoadFromPixels();
 }
 
-const Uint32& cTextureLoader::TexId() const {
+const Uint32& cTextureLoader::Id() const {
 	return mTexId;
 }
 
diff --git a/src/graphics/ctextureloader.hpp b/src/graphics/ctextureloader.hpp
index 77aaab872..9add6e7d4 100644
--- a/src/graphics/ctextureloader.hpp
+++ b/src/graphics/ctextureloader.hpp
@@ -25,7 +25,7 @@ class cTextureLoader : public cObjectLoader {
 
 		void 			Update();
 
-		const Uint32& 	TexId() const;
+		const Uint32& 	Id() const;
 	protected:
 		Uint32			mLoadType; 	// From memory, from path, from pack
 		Uint8 * 		mPixels;	// Texture Info
diff --git a/src/system/cobjectloader.hpp b/src/system/cobjectloader.hpp
index a65605513..cda389cbb 100644
--- a/src/system/cobjectloader.hpp
+++ b/src/system/cobjectloader.hpp
@@ -12,6 +12,7 @@ class cObjectLoader : cThread {
 
 		enum ObjLoaderType {
 			TextureLoader = 1,
+			SoundLoader = 2,
 			UserObjLoader
 		};
 
diff --git a/src/system/cpack.hpp b/src/system/cpack.hpp
index f259c8185..660f67268 100755
--- a/src/system/cpack.hpp
+++ b/src/system/cpack.hpp
@@ -29,6 +29,12 @@ class EE_API cPack : protected cMutex {
 		*/
 		virtual bool AddFile( const std::string& path, const std::string& inpack ) = 0;
 
+		/** Add a new file from memory */
+		virtual bool AddFile( std::vector<Uint8>& data, const std::string& inpack ) = 0;
+
+		/** Add a new file from memory */
+		virtual bool AddFile( const Uint8 * data, const Uint32& dataSize, const std::string& inpack ) = 0;
+
 		/** Add a map of files to the pack file ( myMap[ myFilepath ] = myInPackFilepath ) */
 		virtual bool AddFiles( std::map<std::string, std::string> paths ) = 0;
 
@@ -44,6 +50,9 @@ class EE_API cPack : protected cMutex {
 		/** Extract a file to memory from the pack file */
 		virtual bool ExtractFileToMemory( const std::string& path, std::vector<Uint8>& data ) = 0;
 
+		/** Extract a file to memory from the pack file */
+		virtual bool ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* dataSize ) = 0;
+
 		/** Check if a file exists in the pack file and return the number of the file, otherwise return -1. */
 		virtual Int32 Exists( const std::string& path ) = 0;
 
@@ -55,9 +64,6 @@ class EE_API cPack : protected cMutex {
 
 		/** @return If the pack file is open */
 		virtual bool IsOpen() const;
-
-		/** Add a new file from memory */
-		virtual bool AddFile( std::vector<Uint8>& data, const std::string& inpack ) = 0;
 	protected:
 		bool mIsOpen;
 };
diff --git a/src/system/cpak.cpp b/src/system/cpak.cpp
index f15da3afc..8c2fa0092 100755
--- a/src/system/cpak.cpp
+++ b/src/system/cpak.cpp
@@ -141,11 +141,33 @@ bool cPak::ExtractFileToMemory( const std::string& path, std::vector<Uint8>& dat
 	return Ret;
 }
 
-bool cPak::AddFile( std::vector<Uint8>& data, const std::string& inpack ) {
-	if ( data.size() < 1 )
+bool cPak::ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* dataSize ) {
+	Lock();
+
+	bool Ret = false;
+
+	Int32 Pos = Exists( path );
+
+	if ( Pos != -1 ) {
+		*dataSize = pakFiles[Pos].file_length;
+		*data = new Uint8[ (*dataSize) ];
+
+		myPak.fs.seekg( pakFiles[Pos].file_position, ios::beg );
+		myPak.fs.read( reinterpret_cast<char*> ( *data ), pakFiles[Pos].file_length );
+
+		Ret = true;
+	}
+
+	Unlock();
+
+	return Ret;
+}
+
+bool cPak::AddFile( const Uint8 * data, const Uint32& dataSize, const std::string& inpack ) {
+	if ( dataSize < 1 )
 		return false;
 
-	Uint32 fsize = data.size();
+	Uint32 fsize = dataSize;
 
 	if ( myPak.fs.is_open() ) {
 		if ( myPak.header.dir_length == 1 ) {
@@ -168,8 +190,6 @@ bool cPak::AddFile( std::vector<Uint8>& data, const std::string& inpack ) {
 
 			pakFiles.push_back( newFile );
 
-			data.clear();
-
 			return true;
 		} else {
 			if ( Exists( inpack ) != -1 ) // If the file already exists exit
@@ -206,15 +226,19 @@ bool cPak::AddFile( std::vector<Uint8>& data, const std::string& inpack ) {
 			pakFiles.push_back( pakE[ myPak.pakFilesNum ] );
 			myPak.pakFilesNum += 1;
 
-			data.clear();
 			pakE.clear();
 
 			return true;
 		}
 	}
+
 	return false;
 }
 
+bool cPak::AddFile( std::vector<Uint8>& data, const std::string& inpack ) {
+	return AddFile( reinterpret_cast<const Uint8*> ( &data[0] ), (Uint32)data.size(), inpack );
+}
+
 bool cPak::AddFile( const std::string& path, const std::string& inpack ) {
 	if ( path.size() > 56 )
 		return false;
diff --git a/src/system/cpak.hpp b/src/system/cpak.hpp
index 09c56246d..aee9978b5 100755
--- a/src/system/cpak.hpp
+++ b/src/system/cpak.hpp
@@ -32,6 +32,9 @@ class EE_API cPak : public cPack {
 		/** Add a new file from memory */
 		bool AddFile( std::vector<Uint8>& data, const std::string& inpack );
 
+		/** Add a new file from memory */
+		bool AddFile( const Uint8 * data, const Uint32& dataSize, const std::string& inpack );
+
 		/** Add a map of files to the pakFile ( myMap[ myFilepath ] = myInPakFilepath ) */
 		bool AddFiles( std::map<std::string, std::string> paths );
 
@@ -47,6 +50,9 @@ class EE_API cPak : public cPack {
 		/** Extract a file to memory from the pakFile */
 		bool ExtractFileToMemory( const std::string& path, std::vector<Uint8>& data );
 
+		/** Extract a file to memory from the pakFile */
+		bool ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* dataSize );
+
 		/** Check if a file exists in the pakFile and return the number of the file, otherwise return -1. */
 		Int32 Exists( const std::string& path );
 
diff --git a/src/system/czip.cpp b/src/system/czip.cpp
index 2bcc87aa7..c2356ecbf 100644
--- a/src/system/czip.cpp
+++ b/src/system/czip.cpp
@@ -87,10 +87,10 @@ bool cZip::AddFile( const std::string& path, const std::string& inpack ) {
 	return AddFile( file, inpack );
 }
 
-bool cZip::AddFile( std::vector<Uint8>& data, const std::string& inpack ) {
+bool cZip::AddFile( const Uint8 * data, const Uint32& dataSize, const std::string& inpack ) {
 	if ( 0 == CheckPack() ) {
 		if ( ZIP_CREATED == mState ) {
-			Int32 Result = ZipAdd( mZip , inpack.c_str(), reinterpret_cast<void*> (&data[0]), (unsigned int)data.size() );
+			Int32 Result = ZipAdd( mZip , inpack.c_str(), const_cast<Uint8*>( data ), (unsigned int)dataSize );
 
 			if ( ZR_OK == Result )
 				return true;
@@ -107,7 +107,7 @@ bool cZip::AddFile( std::vector<Uint8>& data, const std::string& inpack ) {
 					Zip.AddFile( tdata, zipFiles[i].name );
 				}
 
-				Zip.AddFile( data, inpack );
+				Zip.AddFile( data, dataSize, inpack );
 
 				Zip.Close();
 
@@ -130,6 +130,10 @@ bool cZip::AddFile( std::vector<Uint8>& data, const std::string& inpack ) {
 	return false;
 }
 
+bool cZip::AddFile( std::vector<Uint8>& data, const std::string& inpack ) {
+	return AddFile( reinterpret_cast<const Uint8*> ( &data[0] ), (Uint32)data.size(), inpack );
+}
+
 bool cZip::AddFiles( std::map<std::string, std::string> paths ) {
 	for( std::map<std::string, std::string>::iterator itr = paths.begin(); itr != paths.end(); itr++)
 		if ( !AddFile( itr->first, itr->second ) )
@@ -246,6 +250,29 @@ bool cZip::ExtractFileToMemory( const std::string& path, std::vector<Uint8>& dat
 	return Ret;
 }
 
+bool cZip::ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* dataSize ) {
+	Lock();
+
+	bool Ret = false;
+	Int32 Pos = Exists( path );
+	Uint32 Result = 0;
+
+	if ( 0 == CheckPack() && -1 != Pos ) {
+		*dataSize = zipFiles[Pos].unc_size;
+		*data = new Uint8[ (*dataSize) ];
+
+		Result = UnzipItem( mZip, Pos, reinterpret_cast<void*> ( *data ), (unsigned int)zipFiles[Pos].unc_size );
+
+		if ( ZR_OK == Result ) {
+			Ret = true;
+		}
+	}
+
+	Unlock();
+
+	return Ret;
+}
+
 Int32 cZip::Exists( const std::string& path ) {
 	for ( Uint32 i = 0; i < zipFiles.size(); i++ )
 		if ( strcmp( path.c_str(), zipFiles[i].name ) == 0 )
diff --git a/src/system/czip.hpp b/src/system/czip.hpp
index 7571de0b7..ec0ca6ad8 100644
--- a/src/system/czip.hpp
+++ b/src/system/czip.hpp
@@ -31,6 +31,9 @@ class EE_API cZip : public cPack {
 		*/
 		bool AddFile( const std::string& path, const std::string& inpack );
 
+		/** Add a new file from memory */
+		bool AddFile( const Uint8 * data, const Uint32& dataSize, const std::string& inpack );
+
 		/** Add a map of files to the pack file ( myMap[ myFilepath ] = myInPackFilepath ) */
 		bool AddFiles( std::map<std::string, std::string> paths );
 
@@ -46,6 +49,9 @@ class EE_API cZip : public cPack {
 		/** Extract a file to memory from the pack file */
 		bool ExtractFileToMemory( const std::string& path, std::vector<Uint8>& data );
 
+		/** Extract a file to memory from the pakFile */
+		bool ExtractFileToMemory( const std::string& path, Uint8** data, Uint32* dataSize );
+
 		/** Check if a file exists in the pack file and return the number of the file, otherwise return -1. */
 		Int32 Exists( const std::string& path );
 
diff --git a/src/test/ee.cpp b/src/test/ee.cpp
index c5b921e77..6fbd57aee 100644
--- a/src/test/ee.cpp
+++ b/src/test/ee.cpp
@@ -1,7 +1,8 @@
 #include "../ee.h"
 
 /**
-@TODO Create a asynchronous resource loader ( at least for textures ).
+@TODO Add async loader for fonts.
+@TODO Create a Global Shape Manager containing one default shape manager and with the possibility to add new shape managers.
 @TODO Add support for Joysticks.
 @TODO Create a Vertex Buffer Object class ( with and without GL_ARB_vertex_buffer_object ).
 @TODO Add support for Frame Buffer Object and to switch rendering to FBO and Screen.
@@ -11,6 +12,8 @@
 @TODO Encapsulate SDL and OpenGL ( and remove unnecessary dependencies ).
 @TODO Add some Surface Grid class, to create special effects ( waved texture, and stuff like that ).
 @TODO Support color cursors ( not only black and white cursors, that really sucks ) - Imposible with SDL 1.2
+@TODO Add Scripting support.
+@TODO Add 2D physics support ( Box2D or Chipmunk wrapper ).
 */
 
 class cUITest : public cUIControlAnim {
@@ -237,10 +240,6 @@ void cEETest::Init() {
 
 		LoadTextures();
 
-		if ( SndMng.LoadFromPack( "mysound", &PAK, "sound.ogg" ) )
-			SndMng["mysound"].Play();
-
-
 		if ( Mus.OpenFromPack( &PAK, "music.ogg" ) ) {
 			Mus.Loop(true);
 			Mus.Play();
@@ -373,6 +372,7 @@ void cEETest::CmdSetPartsNum ( const std::vector < std::wstring >& params ) {
 
 void cEETest::OnTextureLoaded( cResourceLoader * ResLoaded ) {
 	mTextureLoaded = true;
+	SndMng.Play( "mysound" );
 }
 
 void cEETest::LoadTextures() {
@@ -386,8 +386,12 @@ void cEETest::LoadTextures() {
 
 	std::vector<std::string> files = PakTest.GetFileList();
 
-	for ( i = 0; i < files.size(); i++ )
-		mResLoad.Add( new cTextureLoader( &PakTest, files[i] ) );
+	for ( i = 0; i < files.size(); i++ ) {
+		if ( "jpg" == FileExtension( files[i] ) )
+			mResLoad.Add( new cTextureLoader( &PakTest, files[i] ) );
+	}
+
+	mResLoad.Add( new cSoundLoader( &SndMng, "mysound", &PAK, "sound.ogg" ) );
 
 	mResLoad.Load( boost::bind( &cEETest::OnTextureLoaded, this, _1 ) );
 
diff --git a/src/utils/string.cpp b/src/utils/string.cpp
index 4ee77fa9a..ca2db7eac 100644
--- a/src/utils/string.cpp
+++ b/src/utils/string.cpp
@@ -70,7 +70,11 @@ std::vector < std::wstring > SplitString ( const std::wstring& str, const Uint32
 	std::wstring tmpstr;
 
 	for ( eeUint i = 0; i < str.size(); i++ ) {
+		#ifdef EE_COMPILER_MSVC
 		if ( str[i] == splitchar ) {
+		#else
+		if ( str[i] == (Int32)splitchar ) {
+		#endif
 			tmp.push_back(tmpstr);
 			tmpstr = L"";
 		} else {
diff --git a/src/utils/utils.cpp b/src/utils/utils.cpp
index b73c2f9f3..c33b300c7 100755
--- a/src/utils/utils.cpp
+++ b/src/utils/utils.cpp
@@ -328,6 +328,12 @@ bool FileCopy( const std::string& src, const std::string& dst ) {
 	return false;
 }
 
+std::string FileExtension( const std::string& filepath ) {
+	std::string tstr( filepath.substr( filepath.find_last_of(".") + 1 ) );
+	toLower( tstr );
+	return tstr;
+}
+
 eeInt GetNumCPUs() {
 	eeInt nprocs = -1;
 
diff --git a/src/utils/utils.hpp b/src/utils/utils.hpp
index dd9069431..e5f895807 100755
--- a/src/utils/utils.hpp
+++ b/src/utils/utils.hpp
@@ -57,6 +57,9 @@ namespace EE { namespace Utils {
 	*/
 	bool FileCopy( const std::string& src, const std::string& dst );
 
+	/** @return The file extension */
+	std::string FileExtension( const std::string& filepath );
+
 	/** @return The Number of CPUs of the system. */
 	eeInt GetNumCPUs();
 }