12 files changed, 690 insertions, 690 deletions

diff --git a/src/libjin/common/array.hpp b/src/libjin/common/array.hpp
index 8a5cbf1..49ed8ac 100644
--- a/src/libjin/common/array.hpp
+++ b/src/libjin/common/array.hpp
@@ -4,119 +4,119 @@
 namespace JinEngine
 {
 
-    ///
-    /// A array created on heap.
-    ///
-    template<typename T>
-    class Array
-    {
-    public:
-        ///
-        /// Array constructor.
-        ///
-        Array() 
-            : length(0)
-            , data(nullptr) 
-        {
-        }
+	///
+	/// A array created on heap.
+	///
+	template<typename T>
+	class Array
+	{
+	public:
+		///
+		/// Array constructor.
+		///
+		Array() 
+			: length(0)
+			, data(nullptr) 
+		{
+		}
 
-        ///
-        /// Array constructor.
-        ///
-        /// @param l Length of array.
-        ///
-        Array(int l)
-        {
-            length = l;
-            data = new T[l];
-        }
+		///
+		/// Array constructor.
+		///
+		/// @param l Length of array.
+		///
+		Array(int l)
+		{
+			length = l;
+			data = new T[l];
+		}
 
-        ///
-        /// Array destructor.
-        ///
-        ~Array()
-        {
-            delete[] data;
-            length = 0;
-        }
+		///
+		/// Array destructor.
+		///
+		~Array()
+		{
+			delete[] data;
+			length = 0;
+		}
 
-        ///
-        /// Get address of data.
-        /// 
-        /// @return Address of data.
-        ///
-        T* operator &()
-        {
-            return data;
-        }
+		///
+		/// Get address of data.
+		/// 
+		/// @return Address of data.
+		///
+		T* operator &()
+		{
+			return data;
+		}
 
-        ///
-        /// Get specific element of array.
-        /// 
-        /// @return Element of array.
-        ///
-        T& operator[](int index)
-        {
-            return data[index];
-        }
+		///
+		/// Get specific element of array.
+		/// 
+		/// @return Element of array.
+		///
+		T& operator[](int index)
+		{
+			return data[index];
+		}
 
-        ///
-        /// Bind data with given data.
-        ///
-        /// @param data Data pointer.
-        /// @param length Length of data.
-        ///
-        void bind(T* data, int length)
-        {
-            if (data != nullptr)
-                delete data; 
-            this->data = data;
-            this->length = length;
-        }
+		///
+		/// Bind data with given data.
+		///
+		/// @param data Data pointer.
+		/// @param length Length of data.
+		///
+		void bind(T* data, int length)
+		{
+			if (data != nullptr)
+				delete data; 
+			this->data = data;
+			this->length = length;
+		}
 
-        ///
-        /// Add an element.
-        /// 
-        /// @param v Value of element.
-        ///
-        void add(T value)
-        {
-            int len = length + 1;
-            T* d = new T[len];
-            memcpy(d, data, size());
-            d[length] = value;
-            bind(d, len);
-        }
+		///
+		/// Add an element.
+		/// 
+		/// @param v Value of element.
+		///
+		void add(T value)
+		{
+			int len = length + 1;
+			T* d = new T[len];
+			memcpy(d, data, size());
+			d[length] = value;
+			bind(d, len);
+		}
  
-        ///
-        /// Get size of data in byte.
-        /// 
-        /// @return Size of data in byte.
-        ///
-        int size()
-        {
-            return sizeof(T) * length;
-        }
+		///
+		/// Get size of data in byte.
+		/// 
+		/// @return Size of data in byte.
+		///
+		int size()
+		{
+			return sizeof(T) * length;
+		}
 
-        ///
-        /// Get length of data. 
-        /// 
-        /// @return Count of data.
-        ///
-        int count()
-        {
-            return length;
-        }
+		///
+		/// Get length of data. 
+		/// 
+		/// @return Count of data.
+		///
+		int count()
+		{
+			return length;
+		}
 
-    private:
-        // Disable new and delete.
-        void* operator new(size_t t);
-        void operator delete(void* ptr);
+	private:
+		// Disable new and delete.
+		void* operator new(size_t t);
+		void operator delete(void* ptr);
 
-        T * data;
-        unsigned int length;
+		T * data;
+		unsigned int length;
 
-    };
+	};
 
 } // namespace JinEngine
 
diff --git a/src/libjin/common/exception.cpp b/src/libjin/common/exception.cpp
index dc4e6ac..3f53132 100644
--- a/src/libjin/common/exception.cpp
+++ b/src/libjin/common/exception.cpp
@@ -5,42 +5,42 @@
 namespace JinEngine
 {
 
-    Exception::Exception(const char *fmt, ...)
-    {
-        va_list args;
-        int size_buffer = 256, size_out;
-        char *buffer;
-        while (true)
-        {
-            buffer = new char[size_buffer];
-            memset(buffer, 0, size_buffer);
-
-            va_start(args, fmt);
-            size_out = vsnprintf(buffer, size_buffer, fmt, args);
-            va_end(args);
-
-            // see http://perfec.to/vsnprintf/pasprintf.c
-            // if size_out ...
-            //      == -1             --> output was truncated
-            //      == size_buffer    --> output was truncated
-            //      == size_buffer-1  --> ambiguous, /may/ have been truncated
-            //       > size_buffer    --> output was truncated, and size_out
-            //                            bytes would have been written
-            if (size_out == size_buffer || size_out == -1 || size_out == size_buffer - 1)
-                size_buffer *= 2;
-            else if (size_out > size_buffer)
-                size_buffer = size_out + 2; // to avoid the ambiguous case
-            else
-                break;
-
-            delete[] buffer;
-        }
-        mMessage = std::string(buffer);
-        delete[] buffer;
-    }
-
-    Exception::~Exception() throw()
-    {
-    }
+	Exception::Exception(const char *fmt, ...)
+	{
+		va_list args;
+		int size_buffer = 256, size_out;
+		char *buffer;
+		while (true)
+		{
+			buffer = new char[size_buffer];
+			memset(buffer, 0, size_buffer);
+
+			va_start(args, fmt);
+			size_out = vsnprintf(buffer, size_buffer, fmt, args);
+			va_end(args);
+
+			// see http://perfec.to/vsnprintf/pasprintf.c
+			// if size_out ...
+			//	  == -1			 --> output was truncated
+			//	  == size_buffer	--> output was truncated
+			//	  == size_buffer-1  --> ambiguous, /may/ have been truncated
+			//	   > size_buffer	--> output was truncated, and size_out
+			//							bytes would have been written
+			if (size_out == size_buffer || size_out == -1 || size_out == size_buffer - 1)
+				size_buffer *= 2;
+			else if (size_out > size_buffer)
+				size_buffer = size_out + 2; // to avoid the ambiguous case
+			else
+				break;
+
+			delete[] buffer;
+		}
+		mMessage = std::string(buffer);
+		delete[] buffer;
+	}
+
+	Exception::~Exception() throw()
+	{
+	}
 
 } // namespace JinEngine
\ No newline at end of file
diff --git a/src/libjin/common/exception.h b/src/libjin/common/exception.h
index 0dee14c..f46b607 100644
--- a/src/libjin/common/exception.h
+++ b/src/libjin/common/exception.h
@@ -9,37 +9,37 @@
 namespace JinEngine
 {
 
-    ///
-    /// Jin Exception.
-    ///
-    class Exception : public Object, public std::exception
-    {
-    public:
-        /// 
-        /// Creates a new Exception according to printf-rules.
-        ///
-        /// @param fmt The format string (see printf).
-        /// 
-        Exception(const char *fmt, ...);
-        virtual ~Exception() throw();
-
-        /// 
-        /// Returns a string containing reason for the exception.
-        /// 
-        /// @return A description of the exception.
-        /// 
-        inline virtual const char *what() const throw()
-        {
-            return mMessage.c_str();
-        }
-
-    private:
-        ///
-        /// Exception message.
-        ///
-        std::string mMessage;
-
-    };
+	///
+	/// Jin Exception.
+	///
+	class Exception : public Object, public std::exception
+	{
+	public:
+		/// 
+		/// Creates a new Exception according to printf-rules.
+		///
+		/// @param fmt The format string (see printf).
+		/// 
+		Exception(const char *fmt, ...);
+		virtual ~Exception() throw();
+
+		/// 
+		/// Returns a string containing reason for the exception.
+		/// 
+		/// @return A description of the exception.
+		/// 
+		inline virtual const char *what() const throw()
+		{
+			return mMessage.c_str();
+		}
+
+	private:
+		///
+		/// Exception message.
+		///
+		std::string mMessage;
+
+	};
 
 } // namespace JinEngine
 
diff --git a/src/libjin/common/noncopyable.h b/src/libjin/common/noncopyable.h
index ddde7a1..2a9a71e 100644
--- a/src/libjin/common/noncopyable.h
+++ b/src/libjin/common/noncopyable.h
@@ -6,20 +6,20 @@
 namespace JinEngine
 {
 
-    ///
-    /// Class inherites this could not be copied.
-    ///
-    class Noncopyable : public Object
-    {
-    public:
-        Noncopyable(void) { }
-        virtual ~Noncopyable(void) { }
+	///
+	/// Class inherites this could not be copied.
+	///
+	class Noncopyable : public Object
+	{
+	public:
+		Noncopyable(void) { }
+		virtual ~Noncopyable(void) { }
 
-    private:
-        Noncopyable(const Noncopyable& other);
-        Noncopyable& operator=(const Noncopyable& other);
+	private:
+		Noncopyable(const Noncopyable& other);
+		Noncopyable& operator=(const Noncopyable& other);
 
-    };
+	};
 
 } // namespace JinEngine
 
diff --git a/src/libjin/common/object.h b/src/libjin/common/object.h
index 581500f..860a7ab 100644
--- a/src/libjin/common/object.h
+++ b/src/libjin/common/object.h
@@ -4,15 +4,15 @@
 namespace JinEngine
 {
 
-    ///
-    /// Base class of all classes in libjin.
-    ///
-    class Object
-    {
-    public:
-        virtual ~Object() {};
+	///
+	/// Base class of all classes in libjin.
+	///
+	class Object
+	{
+	public:
+		virtual ~Object() {};
 
-    };
+	};
 
 } // namespace JinEngine
 
diff --git a/src/libjin/common/pool.hpp b/src/libjin/common/pool.hpp
index 356ff87..262bc07 100644
--- a/src/libjin/common/pool.hpp
+++ b/src/libjin/common/pool.hpp
@@ -12,165 +12,165 @@
 namespace JinEngine
 {
 
-    class DefaultMemoryAllocator : public Object
-    {
-    public:
-        static inline void *Allocate(size_t size)
-        {
-            return ::operator new(size, ::std::nothrow);
-        }
-        static inline void Deallocate(void *pointer, size_t size)
-        {
-            ::operator delete(pointer);
-        }
-    };
-
-    template<typename T, class TMemoryAllocator = DefaultMemoryAllocator>
-    class Pool : public Object
-    {
-    private:
-        struct _Node
-        {
-            void *_memory;
-            size_t _capacity;
-            _Node *_nextNode;
-
-            _Node(size_t capacity)
-            {
-                if (capacity < 1)
-                    throw std::invalid_argument("capacity must be at least 1.");
-
-                _memory = TMemoryAllocator::Allocate(_itemSize * capacity);
-                if (_memory == NULL)
-                    throw std::bad_alloc();
-
-                _capacity = capacity;
-                _nextNode = NULL;
-            }
-            ~_Node()
-            {
-                TMemoryAllocator::Deallocate(_memory, _itemSize * _capacity);
-            }
-        };
-
-        void *_nodeMemory;
-        T *_firstDeleted;
-        size_t _countInNode;
-        size_t _nodeCapacity;
-        _Node _firstNode;
-        _Node *_lastNode;
-        size_t _maxBlockLength;
-
-        static const size_t _itemSize;
-
-        Pool(const Pool<T, TMemoryAllocator> &source);
-        void operator = (const Pool<T, TMemoryAllocator> &source);
-
-        void _AllocateNewNode()
-        {
-            size_t size = _countInNode;
-            if (size >= _maxBlockLength)
-                size = _maxBlockLength;
-            else
-            {
-                size *= 2;
-
-                if (size < _countInNode)
-                    throw std::overflow_error("size became too big.");
-
-                if (size >= _maxBlockLength)
-                    size = _maxBlockLength;
-            }
-
-            _Node *newNode = new _Node(size);
-            _lastNode->_nextNode = newNode;
-            _lastNode = newNode;
-            _nodeMemory = newNode->_memory;
-            _countInNode = 0;
-            _nodeCapacity = size;
-        }
-
-    public:
-        explicit Pool(size_t initialCapacity = 32, size_t maxBlockLength = 1000000) 
-            : _firstDeleted(NULL)
-            , _countInNode(0)
-            , _nodeCapacity(initialCapacity)
-            , _firstNode(initialCapacity)
-            , _maxBlockLength(maxBlockLength)
-        {
-            if (maxBlockLength < 1)
-                throw std::invalid_argument("maxBlockLength must be at least 1.");
-
-            _nodeMemory = _firstNode._memory;
-            _lastNode = &_firstNode;
-        }
-        ~Pool()
-        {
-            _Node *node = _firstNode._nextNode;
-            while (node)
-            {
-                _Node *nextNode = node->_nextNode;
-                delete node;
-                node = nextNode;
-            }
-        }
-
-        T *New()
-        {
-            if (_firstDeleted)
-            {
-                T *result = _firstDeleted;
-                _firstDeleted = *((T **)_firstDeleted);
-                new(result) T();
-                return result;
-            }
-
-            if (_countInNode >= _nodeCapacity)
-                _AllocateNewNode();
-
-            char *address = (char *)_nodeMemory;
-            address += _countInNode * _itemSize;
-            T *result = new(address) T();
-            _countInNode++;
-            return result;
-        }
-
-        // This method is useful if you want to call a non-default constructor.
-        // It should be used like this:
-        // new (pool.GetNextWithoutInitializing()) ObjectType(... parameters ...);
-        T *GetNextWithoutInitializing()
-        {
-            if (_firstDeleted)
-            {
-                T *result = (T *)_firstDeleted;
-                _firstDeleted = *((T **)_firstDeleted);
-                return result;
-            }
-
-            if (_countInNode >= _nodeCapacity)
-                _AllocateNewNode();
-
-            char *address = (char *)_nodeMemory;
-            address += _countInNode * _itemSize;
-            _countInNode++;
-            return (T *)address;
-        }
-        void Delete(T *content)
-        {
-            content->~T();
-
-            *((T **)content) = _firstDeleted;
-            _firstDeleted = content;
-        }
-        void DeleteWithoutDestroying(T *content)
-        {
-            *((T **)content) = _firstDeleted;
-            _firstDeleted = content;
-        }
-    };
-
-    template<typename T, class TMemoryAllocator>
-    const size_t Pool<T, TMemoryAllocator>::_itemSize = ((sizeof(T) + sizeof(void *) - 1) / sizeof(void *)) * sizeof(void *);
+	class DefaultMemoryAllocator : public Object
+	{
+	public:
+		static inline void *Allocate(size_t size)
+		{
+			return ::operator new(size, ::std::nothrow);
+		}
+		static inline void Deallocate(void *pointer, size_t size)
+		{
+			::operator delete(pointer);
+		}
+	};
+
+	template<typename T, class TMemoryAllocator = DefaultMemoryAllocator>
+	class Pool : public Object
+	{
+	private:
+		struct _Node
+		{
+			void *_memory;
+			size_t _capacity;
+			_Node *_nextNode;
+
+			_Node(size_t capacity)
+			{
+				if (capacity < 1)
+					throw std::invalid_argument("capacity must be at least 1.");
+
+				_memory = TMemoryAllocator::Allocate(_itemSize * capacity);
+				if (_memory == NULL)
+					throw std::bad_alloc();
+
+				_capacity = capacity;
+				_nextNode = NULL;
+			}
+			~_Node()
+			{
+				TMemoryAllocator::Deallocate(_memory, _itemSize * _capacity);
+			}
+		};
+
+		void *_nodeMemory;
+		T *_firstDeleted;
+		size_t _countInNode;
+		size_t _nodeCapacity;
+		_Node _firstNode;
+		_Node *_lastNode;
+		size_t _maxBlockLength;
+
+		static const size_t _itemSize;
+
+		Pool(const Pool<T, TMemoryAllocator> &source);
+		void operator = (const Pool<T, TMemoryAllocator> &source);
+
+		void _AllocateNewNode()
+		{
+			size_t size = _countInNode;
+			if (size >= _maxBlockLength)
+				size = _maxBlockLength;
+			else
+			{
+				size *= 2;
+
+				if (size < _countInNode)
+					throw std::overflow_error("size became too big.");
+
+				if (size >= _maxBlockLength)
+					size = _maxBlockLength;
+			}
+
+			_Node *newNode = new _Node(size);
+			_lastNode->_nextNode = newNode;
+			_lastNode = newNode;
+			_nodeMemory = newNode->_memory;
+			_countInNode = 0;
+			_nodeCapacity = size;
+		}
+
+	public:
+		explicit Pool(size_t initialCapacity = 32, size_t maxBlockLength = 1000000) 
+			: _firstDeleted(NULL)
+			, _countInNode(0)
+			, _nodeCapacity(initialCapacity)
+			, _firstNode(initialCapacity)
+			, _maxBlockLength(maxBlockLength)
+		{
+			if (maxBlockLength < 1)
+				throw std::invalid_argument("maxBlockLength must be at least 1.");
+
+			_nodeMemory = _firstNode._memory;
+			_lastNode = &_firstNode;
+		}
+		~Pool()
+		{
+			_Node *node = _firstNode._nextNode;
+			while (node)
+			{
+				_Node *nextNode = node->_nextNode;
+				delete node;
+				node = nextNode;
+			}
+		}
+
+		T *New()
+		{
+			if (_firstDeleted)
+			{
+				T *result = _firstDeleted;
+				_firstDeleted = *((T **)_firstDeleted);
+				new(result) T();
+				return result;
+			}
+
+			if (_countInNode >= _nodeCapacity)
+				_AllocateNewNode();
+
+			char *address = (char *)_nodeMemory;
+			address += _countInNode * _itemSize;
+			T *result = new(address) T();
+			_countInNode++;
+			return result;
+		}
+
+		// This method is useful if you want to call a non-default constructor.
+		// It should be used like this:
+		// new (pool.GetNextWithoutInitializing()) ObjectType(... parameters ...);
+		T *GetNextWithoutInitializing()
+		{
+			if (_firstDeleted)
+			{
+				T *result = (T *)_firstDeleted;
+				_firstDeleted = *((T **)_firstDeleted);
+				return result;
+			}
+
+			if (_countInNode >= _nodeCapacity)
+				_AllocateNewNode();
+
+			char *address = (char *)_nodeMemory;
+			address += _countInNode * _itemSize;
+			_countInNode++;
+			return (T *)address;
+		}
+		void Delete(T *content)
+		{
+			content->~T();
+
+			*((T **)content) = _firstDeleted;
+			_firstDeleted = content;
+		}
+		void DeleteWithoutDestroying(T *content)
+		{
+			*((T **)content) = _firstDeleted;
+			_firstDeleted = content;
+		}
+	};
+
+	template<typename T, class TMemoryAllocator>
+	const size_t Pool<T, TMemoryAllocator>::_itemSize = ((sizeof(T) + sizeof(void *) - 1) / sizeof(void *)) * sizeof(void *);
 
 } // namespace JinEngine
 
diff --git a/src/libjin/common/singleton.hpp b/src/libjin/common/singleton.hpp
index 015c9b0..f66d6e6 100644
--- a/src/libjin/common/singleton.hpp
+++ b/src/libjin/common/singleton.hpp
@@ -7,77 +7,77 @@
 namespace JinEngine
 {
 
-    ///
-    /// Singleton base class.
-    ///
-    template<class T>
-    class Singleton : public Object
-    {
-    public:
-        ///
-        /// Get singleton. 
-        /// 
-        /// @param Singleton instance of class.
-        ///
-        static T* get()
-        {
-            if (_instance == nullptr)
-                _instance = new T;
-            return _instance;
-        }
+	///
+	/// Singleton base class.
+	///
+	template<class T>
+	class Singleton : public Object
+	{
+	public:
+		///
+		/// Get singleton. 
+		/// 
+		/// @param Singleton instance of class.
+		///
+		static T* get()
+		{
+			if (_instance == nullptr)
+				_instance = new T;
+			return _instance;
+		}
 
-        ///
-        /// Destroy instance of singleton.
-        ///
-        static void destroy()
-        {
-            delete _instance;
-            _instance = nullptr;
-        }
+		///
+		/// Destroy instance of singleton.
+		///
+		static void destroy()
+		{
+			delete _instance;
+			_instance = nullptr;
+		}
 
-    protected:
-        ///
-        /// Singleton constructor.
-        ///
-        Singleton() 
-        {
-            // Check singleton.
-            if (_instance)
-                throw Exception("This is a singleton.");
-        };
+	protected:
+		///
+		/// Singleton constructor.
+		///
+		Singleton() 
+		{
+			// Check singleton.
+			if (_instance)
+				throw Exception("This is a singleton.");
+		};
 
-        ///
-        /// Singleton destructor.
-        ///
-        virtual ~Singleton() {};
+		///
+		/// Singleton destructor.
+		///
+		virtual ~Singleton() {};
 
-        ///
-        /// Singleton instance.
-        ///
-        static T* _instance;
+		///
+		/// Singleton instance.
+		///
+		static T* _instance;
 
-    private:
-        ///
-        /// Singleton copy constructor.
-        ///
-        /// @param singleton Singleton of class.
-        ///
-        Singleton(const Singleton& singleton);
+	private:
+		///
+		/// Singleton copy constructor.
+		///
+		/// @param singleton Singleton of class.
+		///
+		Singleton(const Singleton& singleton);
 
-        ///
-        /// Singleton assignment.
-        ///
-        /// @param singleton Singleton of class.
-        ///
-        Singleton& operator = (const Singleton& singleton);
+		///
+		/// Singleton assignment.
+		///
+		/// @param singleton Singleton of class.
+		///
+		Singleton& operator = (const Singleton& singleton);
 
-    };
+	};
 
-    ///
-    /// Singleton instance.
-    ///
-    template<class T> 
-    T* Singleton<T>::_instance = nullptr;
+	///
+	/// Singleton instance.
+	///
+	template<class T> 
+	T* Singleton<T>::_instance = nullptr;
 
 } // namespace JinEngine
 
diff --git a/src/libjin/common/string.h b/src/libjin/common/string.h
index 4e46f17..cecdbc2 100644
--- a/src/libjin/common/string.h
+++ b/src/libjin/common/string.h
@@ -6,66 +6,66 @@
 namespace JinEngine
 {
 
-    class String : public std::string
-    {
-    public: 
-        inline String() 
-            : std::string() 
-        {
-        }
-
-        inline String(const std::string& str)
-            : std::string(str)
-        {
-        }
-
-        inline String(const String& str)
-            : std::string(str)
-        {
-        }
-
-        inline String(const char* str)
-            : std::string(str)
-        {
-        }
-
-        inline String& operator = (const String& str)
-        {
-            std::string::operator=(str);
-            return *this;
-        }
-
-        inline operator const char* () const 
-        {
-            return this->c_str();
-        }
-
-        inline const char* str() const 
-        {
-            return this->c_str();
-        }
-
-        inline String(const String& s2, size_type pos2, size_type len2) 
-            : std::string(s2, pos2, len2) 
-        {
-        }
-
-        inline String(const char* buf, size_type bufsize) 
-            : std::string(buf, bufsize) 
-        {
-        }
-
-        inline String(size_type repetitions, char c) 
-            : std::string(repetitions, c) 
-        {
-        }
-
-        inline int length() const
-        {
-            return size();
-        }
-
-    };
+	class String : public std::string
+	{
+	public: 
+		inline String() 
+			: std::string() 
+		{
+		}
+
+		inline String(const std::string& str)
+			: std::string(str)
+		{
+		}
+
+		inline String(const String& str)
+			: std::string(str)
+		{
+		}
+
+		inline String(const char* str)
+			: std::string(str)
+		{
+		}
+
+		inline String& operator = (const String& str)
+		{
+			std::string::operator=(str);
+			return *this;
+		}
+
+		inline operator const char* () const 
+		{
+			return this->c_str();
+		}
+
+		inline const char* str() const 
+		{
+			return this->c_str();
+		}
+
+		inline String(const String& s2, size_type pos2, size_type len2) 
+			: std::string(s2, pos2, len2) 
+		{
+		}
+
+		inline String(const char* buf, size_type bufsize) 
+			: std::string(buf, bufsize) 
+		{
+		}
+
+		inline String(size_type repetitions, char c) 
+			: std::string(repetitions, c) 
+		{
+		}
+
+		inline int length() const
+		{
+			return size();
+		}
+
+	};
 
 }
 
diff --git a/src/libjin/common/stringmap.hpp b/src/libjin/common/stringmap.hpp
index 1db798e..ecd6fdc 100644
--- a/src/libjin/common/stringmap.hpp
+++ b/src/libjin/common/stringmap.hpp
@@ -6,139 +6,139 @@
 namespace JinEngine
 {
 
-    template<typename T, unsigned SIZE>
-    class StringMap : public Object
-    {
-    private:
-
-        struct Record
-        {
-            const char * key;
-            T value;
-            bool set;
-            Record() : set(false) {}
-        };
-
-        const static unsigned MAX = SIZE * 2;
-
-        Record records[MAX];
-        const char * reverse[SIZE];
-
-    public:
-
-        struct Entry
-        {
-            const char * key;
-            T value;
-        };
-
-        StringMap(Entry * entries, unsigned num)
-        {
-
-            for (unsigned i = 0; i < SIZE; ++i)
-                reverse[i] = 0;
-
-            unsigned n = num / sizeof(Entry);
-
-            for (unsigned i = 0; i < n; ++i)
-            {
-                add(entries[i].key, entries[i].value);
-            }
-        }
-
-        bool streq(const char * a, const char * b)
-        {
-            while (*a != 0 && *b != 0)
-            {
-                if (*a != *b)
-                    return false;
-                ++a;
-                ++b;
-            }
-
-            return (*a == 0 && *b == 0);
-        }
-
-        bool find(const char * key, T & t)
-        {
-            //unsigned str_hash = djb2(key);
-
-            for (unsigned i = 0; i < MAX; ++i)
-            {
-                //unsigned str_i = (str_hash + i) % MAX; //this isn't used, is this intentional?
-
-                if (records[i].set && streq(records[i].key, key))
-                {
-                    t = records[i].value;
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        bool find(T key, const char *& str)
-        {
-            unsigned index = (unsigned)key;
-
-            if (index >= SIZE)
-                return false;
-
-            if (reverse[index] != 0)
-            {
-                str = reverse[index];
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-
-        bool add(const char * key, T value)
-        {
-            unsigned str_hash = djb2(key);
-            bool inserted = false;
-
-            for (unsigned i = 0; i < MAX; ++i)
-            {
-                unsigned str_i = (str_hash + i) % MAX;
-
-                if (!records[str_i].set)
-                {
-                    inserted = true;
-                    records[str_i].set = true;
-                    records[str_i].key = key;
-                    records[str_i].value = value;
-                    break;
-                }
-            }
-
-            unsigned index = (unsigned)value;
-
-            if (index >= SIZE)
-            {
-                printf("\nConstant %s out of bounds with %i!\n", key, index);
-                return false;
-            }
-
-            reverse[index] = key;
-
-            return inserted;
-        }
-
-        unsigned djb2(const char * key)
-        {
-            unsigned hash = 5381;
-            int c;
-
-            while ((c = *key++))
-                hash = ((hash << 5) + hash) + c;
-
-            return hash;
-        }
-
-    }; // StringMap
+	template<typename T, unsigned SIZE>
+	class StringMap : public Object
+	{
+	private:
+
+		struct Record
+		{
+			const char * key;
+			T value;
+			bool set;
+			Record() : set(false) {}
+		};
+
+		const static unsigned MAX = SIZE * 2;
+
+		Record records[MAX];
+		const char * reverse[SIZE];
+
+	public:
+
+		struct Entry
+		{
+			const char * key;
+			T value;
+		};
+
+		StringMap(Entry * entries, unsigned num)
+		{
+
+			for (unsigned i = 0; i < SIZE; ++i)
+				reverse[i] = 0;
+
+			unsigned n = num / sizeof(Entry);
+
+			for (unsigned i = 0; i < n; ++i)
+			{
+				add(entries[i].key, entries[i].value);
+			}
+		}
+
+		bool streq(const char * a, const char * b)
+		{
+			while (*a != 0 && *b != 0)
+			{
+				if (*a != *b)
+					return false;
+				++a;
+				++b;
+			}
+
+			return (*a == 0 && *b == 0);
+		}
+
+		bool find(const char * key, T & t)
+		{
+			//unsigned str_hash = djb2(key);
+
+			for (unsigned i = 0; i < MAX; ++i)
+			{
+				//unsigned str_i = (str_hash + i) % MAX; //this isn't used, is this intentional?
+
+				if (records[i].set && streq(records[i].key, key))
+				{
+					t = records[i].value;
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		bool find(T key, const char *& str)
+		{
+			unsigned index = (unsigned)key;
+
+			if (index >= SIZE)
+				return false;
+
+			if (reverse[index] != 0)
+			{
+				str = reverse[index];
+				return true;
+			}
+			else
+			{
+				return false;
+			}
+		}
+
+		bool add(const char * key, T value)
+		{
+			unsigned str_hash = djb2(key);
+			bool inserted = false;
+
+			for (unsigned i = 0; i < MAX; ++i)
+			{
+				unsigned str_i = (str_hash + i) % MAX;
+
+				if (!records[str_i].set)
+				{
+					inserted = true;
+					records[str_i].set = true;
+					records[str_i].key = key;
+					records[str_i].value = value;
+					break;
+				}
+			}
+
+			unsigned index = (unsigned)value;
+
+			if (index >= SIZE)
+			{
+				printf("\nConstant %s out of bounds with %i!\n", key, index);
+				return false;
+			}
+
+			reverse[index] = key;
+
+			return inserted;
+		}
+
+		unsigned djb2(const char * key)
+		{
+			unsigned hash = 5381;
+			int c;
+
+			while ((c = *key++))
+				hash = ((hash << 5) + hash) + c;
+
+			return hash;
+		}
+
+	}; // StringMap
 
 } // namespace JinEngine
 
diff --git a/src/libjin/common/subsystem.hpp b/src/libjin/common/subsystem.hpp
index 9828c40..2f3a4a4 100644
--- a/src/libjin/common/subsystem.hpp
+++ b/src/libjin/common/subsystem.hpp
@@ -8,66 +8,66 @@
 namespace JinEngine
 {
 
-    ///
-    /// Subsystem class.
-    ///
-    template<class System>
-    class Subsystem : public Singleton<System>
-    {
-    public: 
-        ///
-        /// Subsystem setting.
-        ///
-        struct Setting 
-        {
-        }; 
+	///
+	/// Subsystem class.
+	///
+	template<class System>
+	class Subsystem : public Singleton<System>
+	{
+	public: 
+		///
+		/// Subsystem setting.
+		///
+		struct Setting 
+		{
+		}; 
 
-        typedef Setting SettingBase; 
+		typedef Setting SettingBase; 
 
-        ///
-        /// Initialize subsystem.
-        /// 
-        /// @param setting Subsystem setting.
-        /// @return True if initialize sucessful, otherwise return false.
-        ///
-        bool start(const SettingBase* setting = nullptr)
-        {
-            static bool success = startSystem(setting);
-            return success;
-        }
+		///
+		/// Initialize subsystem.
+		/// 
+		/// @param setting Subsystem setting.
+		/// @return True if initialize sucessful, otherwise return false.
+		///
+		bool start(const SettingBase* setting = nullptr)
+		{
+			static bool success = startSystem(setting);
+			return success;
+		}
 
-        ///
-        /// Quit subsystem.
-        ///
-        void quit()
-        {
-            // Call only once.
-            static char __dummy__ = (quitSystem(), 1);
-            Singleton<System>::destroy();
-        }
+		///
+		/// Quit subsystem.
+		///
+		void quit()
+		{
+			// Call only once.
+			static char __dummy__ = (quitSystem(), 1);
+			Singleton<System>::destroy();
+		}
 
-        ///
-        /// Subsystem constructor.
-        ///
-        Subsystem() {};
+		///
+		/// Subsystem constructor.
+		///
+		Subsystem() {};
 
-        /// 
-        /// Subsystem destructor.
-        ///
-        virtual ~Subsystem() {}
+		/// 
+		/// Subsystem destructor.
+		///
+		virtual ~Subsystem() {}
 
-    protected:
-        ///
-        /// Initializer callback.
-        ///
-        virtual bool startSystem(const Setting* setting) = 0;
+	protected:
+		///
+		/// Initializer callback.
+		///
+		virtual bool startSystem(const Setting* setting) = 0;
 
-        ///
-        /// Quit subsystem callback.
-        ///
-        virtual void quitSystem() = 0;
+		///
+		/// Quit subsystem callback.
+		///
+		virtual void quitSystem() = 0;
 
-    };
+	};
 
 } // namespace JinEngine
 
diff --git a/src/libjin/common/temporary.h b/src/libjin/common/temporary.h
index 3f02b2b..9152c33 100644
--- a/src/libjin/common/temporary.h
+++ b/src/libjin/common/temporary.h
@@ -5,28 +5,28 @@
 
 namespace JinEngine
 {
-    
-    ///
-    /// Class inherites this clound only be created on stack or static zone.
-    ///
-    class Temporary : public Object
-    {
-    public:
-        Temporary() {};
-        virtual ~Temporary() {};
+	
+	///
+	/// Class inherites this clound only be created on stack or static zone.
+	///
+	class Temporary : public Object
+	{
+	public:
+		Temporary() {};
+		virtual ~Temporary() {};
 /*
-    protected:
-        void operator delete(void* t)
-        {
-            if(t != nullptr)
-                free(t);
-        }
+	protected:
+		void operator delete(void* t)
+		{
+			if(t != nullptr)
+				free(t);
+		}
 */
-    private:
-        // Disable new operands.
-        void* operator new(size_t);
+	private:
+		// Disable new operands.
+		void* operator new(size_t);
 
-    };
+	};
 
 } // namespace JinEngine
 
diff --git a/src/libjin/common/types.h b/src/libjin/common/types.h
index e31ce5e..921a327 100644
--- a/src/libjin/common/types.h
+++ b/src/libjin/common/types.h
@@ -7,23 +7,23 @@
 namespace JinEngine
 {
 
-    typedef int8_t   int8;   ///< Signed integer with a size of 8 bits. Supports values from -128 to 127
-    typedef uint8_t  uint8;  ///< Unsigned integer with a size of 8 bits. Supports values from 0 to 255.
-    typedef uint8    byte;   ///< Unsigned integer with 8 bits (1 byte). Supports 256 values from 0 to 255.
-    typedef int16_t  int16;  ///< Signed integer with a size of 16 bits. Supports values from -32768 to 32767
-    typedef uint16_t uint16; ///< Unsigned integer with a size of 16 bits. Supports values from 0 to 65535.
-    typedef int32_t  int32;  ///< Signed integer with a size of 32 bits. Supports values from -2147483648 to 2147483647.
-    typedef uint32_t uint32; ///< Unsigned integer with a size of 32 bits. Supports values from 0 to 4294967295, (2^32 - 1).
-    typedef int64_t  int64;  ///< Signed integer with a size of 64 bits. Supports values from -(2^63) to (2^63 - 1).
-    typedef uint64_t uint64; ///< Unsigned integer with a size of 64 bits, Supports values from 0 to (2^64 - 1).
+	typedef int8_t   int8;   ///< Signed integer with a size of 8 bits. Supports values from -128 to 127
+	typedef uint8_t  uint8;  ///< Unsigned integer with a size of 8 bits. Supports values from 0 to 255.
+	typedef uint8	byte;   ///< Unsigned integer with 8 bits (1 byte). Supports 256 values from 0 to 255.
+	typedef int16_t  int16;  ///< Signed integer with a size of 16 bits. Supports values from -32768 to 32767
+	typedef uint16_t uint16; ///< Unsigned integer with a size of 16 bits. Supports values from 0 to 65535.
+	typedef int32_t  int32;  ///< Signed integer with a size of 32 bits. Supports values from -2147483648 to 2147483647.
+	typedef uint32_t uint32; ///< Unsigned integer with a size of 32 bits. Supports values from 0 to 4294967295, (2^32 - 1).
+	typedef int64_t  int64;  ///< Signed integer with a size of 64 bits. Supports values from -(2^63) to (2^63 - 1).
+	typedef uint64_t uint64; ///< Unsigned integer with a size of 64 bits, Supports values from 0 to (2^64 - 1).
 
-    typedef uint32_t uint;
-    typedef int32_t  sint;
+	typedef uint32_t uint;
+	typedef int32_t  sint;
 
 #define Union(name, ...) \
-union _Ctor{                                    \
-    _Ctor() { memset(this, 0, sizeof(*this)); } \
-    __VA_ARGS__;                                \
+union _Ctor{									\
+	_Ctor() { memset(this, 0, sizeof(*this)); } \
+	__VA_ARGS__;								\
 } name;
 
 #define Struct(name, ...) \