Nuevo Render flow para los Drawables y mejoras.

Nuevo flujo de render para los drawables, que ahora tiene más sentido.
Investigado e implementado finalmente un sistema para no renderizar objetos no visibles.
Optimizaciones varias.
Constructor por defecto para Sprite, utilizando los assets por defecto.

GenProject.bat

@@ -1,2 +1,2 @@
-call premake\premake5.exe vs2019
+call premake\premake5.exe vs2022
 PAUSE

README.md

@@ -38,4 +38,7 @@ Repositorio principal de UberEngine. Sin mucho más.
  - [X] AssetManager: Creo que también hay que limpiar las fonts cargadas....
 
 ### JSON / AssetManager 
- - [ ] Crear un sistema sencillo (un método o algo común para todas las veces que sea necesario) para añadir seguridad al parse y uso de los JSON. De tal forma que se devuelva el error por consola pero no salten exepciones ni mierdas.
+ - [ ] Crear un sistema sencillo (un método o algo común para todas las veces que sea necesario) para añadir seguridad al parse y uso de los JSON. De tal forma que se devuelva el error por consola pero no salten exepciones ni mierdas.
+
+### Sistema de Escenas.
+ - [ ] Revisar los métodos para carga/descarga y de cambio de escenas. Creo que se pueden estructurar mejor.

UberEngine/src/Assets/Asset.h

@@ -9,48 +9,48 @@ using json = nlohmann::ordered_json;
 namespace UE
 {
 
-	/* All types of Assets that can be loadedand stored by an AssetManager */
+    /* All types of Assets that can be loadedand stored by an AssetManager */
-	enum class AssetType
+    enum class AssetType
-	{
+    {
-		Texture = 0, Font, Sound, Other, Unvalid = 15
+        Texture = 0, Font, Sound, Other, Unvalid = 15
-	};
+    };
-	
+    
-	/* Asset struct. Contains info regarding Assets para ser cargados. */
+    /* Asset struct. Contains info regarding Assets para ser cargados. */
-	struct Asset
+    struct Asset
-	{
+    {
-	public:
+    public:
-		Asset() {};
+        Asset() {};
 
-		Asset(std::string name, 
+        Asset(std::string name, 
-			  std::string path, 
+              std::string path, 
-			  AssetType type)
+              AssetType type)
-			: _name(name), _path(path), _type(type) {}
+            : _name(name), _path(path), _type(type) {}
 
-		
+        
-		std::string _name = "";
+        std::string _name = "";
-		std::string _path = "";
+        std::string _path = "";
 
-		AssetType _type = AssetType::Unvalid;
+        AssetType _type = AssetType::Unvalid;
-	};
+    };
 
-	/* Conversi�n de una struct Asset a JSON */
+    /* Conversi�n de una struct Asset a JSON */
-	inline void to_json(nlohmann::ordered_json& j, const Asset& as)
+    inline void to_json(nlohmann::ordered_json& j, const Asset& as)
-	{
+    {
-		j = nlohmann::ordered_json
+        j = nlohmann::ordered_json
-		{
+        {
-			{"name", as._name},
+            {"name", as._name},
-			{"Path", as._path},
+            {"Path", as._path},
-			{"Type", as._type},
+            {"Type", as._type},
-		};
+        };
-	}
+    }
 
-	/* Conversi�n de un JSON a una struct Asset */
+    /* Conversi�n de un JSON a una struct Asset */
-	inline void from_json(const nlohmann::ordered_json& j, Asset& as)
+    inline void from_json(const nlohmann::ordered_json& j, Asset& as)
-	{
+    {
-		j.at("name").get_to(as._name);
+        j.at("name").get_to(as._name);
-		j.at("Path").get_to(as._path);
+        j.at("Path").get_to(as._path);
-		j.at("Type").get_to(as._type);
+        j.at("Type").get_to(as._type);
-	}
+    }
 
 }
 
@@ -62,20 +62,20 @@ namespace UE
 /* Conversi�n de un Struct SDL_Rect a JSON */
 inline void to_json(nlohmann::ordered_json& j, const SDL_Rect& rect)
 {
-	j = nlohmann::ordered_json
+    j = nlohmann::ordered_json
-	{
+    {
-		{"posX", rect.x},
+        {"posX", rect.x},
-		{"posY", rect.y},
+        {"posY", rect.y},
-		{"sizeX", rect.w},
+        {"sizeX", rect.w},
-		{"sizeY", rect.h}
+        {"sizeY", rect.h}
-	};
+    };
 }
 
 /* Conversi�n de un JSON a un struct SDL_Rect */
 inline void from_json(const nlohmann::ordered_json& j, SDL_Rect& rect)
 {
-	j.at("posX").get_to(rect.x);
+    j.at("posX").get_to(rect.x);
-	j.at("posY").get_to(rect.y);
+    j.at("posY").get_to(rect.y);
-	j.at("sizeX").get_to(rect.w);
+    j.at("sizeX").get_to(rect.w);
-	j.at("sizeY").get_to(rect.h);
+    j.at("sizeY").get_to(rect.h);
 }

UberEngine/src/Assets/AssetManager.cpp

@@ -1,4 +1,4 @@
-#include <fstream>
+#include <fstream>
 #include <iostream>
 
 #include "Logging/Logger.h"
@@ -10,209 +10,209 @@
 namespace UE
 {
 
-	void AssetManager::InitAssetManager()
+    void AssetManager::InitAssetManager()
-	{
+    {
-		if (IMG_Init(IMG_INIT_PNG))
+        UE_LOG_INFO("AssetManager Iniciado con éxito.");
-		{
-			UE_LOG_INFO("SDL_Image Init.");
-		}
-		else
-		{
-			UE_LOG_ERROR("SDL_Image - Error al inicarse: {0}", IMG_GetError());
-		}
 
-		if (!TTF_Init()) //Retorna 0 si está correcto.
+        //Crear una textura por defecto.
-		{
+    }
-			UE_LOG_INFO("SDL_TTF se ha inicializado correctamente.");
-		}
-		else
-		{
-			UE_LOG_ERROR("SDL_TTF - Error al inicarse: {0}", TTF_GetError());
-		}
-
-		UE_LOG_INFO("AssetManager Iniciado con éxito.");
-	}
-
-	void AssetManager::CleanAssetManager()
-	{
-		//Destruye todas las texturas de SDL.
-		for (auto i = _textures.begin(); i != _textures.end(); i++)
-		{
-			i->second->~Texture();
-		}
-
-		//Limpiamos las fuentes.
-		for (auto i = _fonts.begin(); i != _fonts.end(); i++)
-		{
-			//Limpiamos las fuentes.
-			delete i->second;
-		}
-
-		//CPP se debería de encargar de ellos, pero bueno.
-		_assetQueue.clear();
-		_textures.clear();
 
 
-		IMG_Quit();
+    void AssetManager::CleanAssetManager()
+    {
+        //Destruye todas las texturas de SDL.
+        for (auto i = _textures.begin(); i != _textures.end(); i++)
+        {
+            i->second->~Texture();
+        }
 
-		UE_LOG_INFO("AssetManager Cleaned");
+        //Limpiamos las fuentes.
-	}
+        for (auto i = _fonts.begin(); i != _fonts.end(); i++)
+        {
+            //Limpiamos las fuentes.
+            delete i->second;
+        }
+
+        //CPP se debería de encargar de ellos, pero bueno.
+        _assetQueue.clear();
+        _textures.clear();
+
+        UE_LOG_INFO("AssetManager Cleaned");
+    }
+
+
+
+    void AssetManager::LoadAssetsFromFile(std::string filePath)
+    {
+        std::fstream file(filePath.c_str());
+
+        if (!file.is_open())
+        {
+            UE_LOG_ERROR("No se ha podido abrir la lista de assets: {0}", filePath);
+        }
+
+        //Load Asset data from JSON.
+        json jread = json::parse(file);
+
+        json Textures = jread["Textures"];
+        json Fonts = jread["Fonts"];
+        json Sounds = jread["Sounds"];
+        json Others = jread["Others"];
+
+        /* Add assets struct to asset map. */
+        for (int i = 0; i < Textures.size(); i++)
+        {
+            _assetQueue.push_back(Textures.at(i));
+        }
+        for (int i = 0; i < Fonts.size(); i++)
+        {
+            _assetQueue.push_back(Fonts.at(i));
+        }
+        for (int i = 0; i < Sounds.size(); i++)
+        {
+            _assetQueue.push_back(Sounds.at(i));
+        }
+        for (int i = 0; i < Others.size(); i++)
+        {
+            _assetQueue.push_back(Others.at(i));
+        }
+
+
+        file.close();
+    }
+
+
+    void AssetManager::LoadAsset(Asset& as)
+    {
+        _assetQueue.push_back(as);
+    }
+
+
+    void AssetManager::ProcessAssetQueue(int amount)
+    {
+        int cantidad = amount;
+
+        if (amount == -1 || cantidad >= _assetQueue.size())
+            cantidad = _assetQueue.size();
+
+        //Load Assets from files, depending on the type.
+        for (int i = 0; i < cantidad; i++)
+        {
+            Asset& as = _assetQueue.front();
+            switch (as._type)
+            {
+                case AssetType::Texture:
+                {
+                    LoadTexture(as._name, as._path);
+                    break;
+                }
+                case AssetType::Font:
+                {
+                    LoadFont(as._name, as._path);
+                    break;
+                }
+                default:
+                {
+                    UE_LOG_WARN("Asset {0}, Type {1} Cannot be loaded from {2}", as._name, as._type, as._path);
+                    break;
+                }
+            }
+            _assetQueue.pop_front();
+        }
+    }
+
+
+
+    void AssetManager::LoadTexture(std::string name, std::string txPath)
+    {
+        Texture* tx = new Texture(txPath, _SDL_Renderer);
+        _textures.insert(std::make_pair(name, tx));
+    }
+
+
+    void AssetManager::RemoveTexture(std::string name)
+    {
+        //Se supone que el erase del map llama al destructor del objeto...
+        //Pero no lo he comprobado del todo.
+        _textures.erase(name);
+    }
+
+
+    Texture* AssetManager::getTexture(std::string textureName)
+    {
+        Texture* txPtr;
+        try
+        {
+            //Obtenemos la tx indicada.
+             txPtr = _textures.at(textureName);
+        }
+        catch (const std::out_of_range&)
+        {
+            //Si no existe, usamos la por defecto.
+            txPtr = _textures.at(defaultAsset);
+        }
+
+        return txPtr;
+        
+    }
+
+
+    Texture* AssetManager::getDefaultTexture()
+    {
+        return _textures.at(defaultAsset);
+    }
 
 
 
 
-	void AssetManager::LoadAssetsFromFile(std::string filePath)
+    void AssetManager::LoadFont(std::string name, std::string fontPath)
-	{
+    {
-		std::fstream file(filePath.c_str());
+        Font* fo = new Font(fontPath);
-
+        _fonts.insert(std::make_pair(name, fo));
-		if (!file.is_open())
+    }
-		{
-			UE_LOG_ERROR("No se ha podido abrir la lista de assets: {0}", filePath);
-		}
-
-		//Load Asset data from JSON.
-		json jread = json::parse(file);
-
-		json Textures = jread["Textures"];
-		json Fonts = jread["Fonts"];
-		json Sounds = jread["Sounds"];
-		json Others = jread["Others"];
-
-		/* Add assets struct to asset map. */
-		for (int i = 0; i < Textures.size(); i++)
-		{
-			_assetQueue.push_back(Textures.at(i));
-		}
-		for (int i = 0; i < Fonts.size(); i++)
-		{
-			_assetQueue.push_back(Fonts.at(i));
-		}
-		for (int i = 0; i < Sounds.size(); i++)
-		{
-			_assetQueue.push_back(Sounds.at(i));
-		}
-		for (int i = 0; i < Others.size(); i++)
-		{
-			_assetQueue.push_back(Others.at(i));
-		}
 
 
-		file.close();
+    void AssetManager::RemoveFont(std::string name)
-	}
+    {
+        //Se supone que el erase del map llama al destructor del objeto...
+        //Pero no lo he comprobado del todo.
+        _fonts.erase(name);
+    }
 
 
-	void AssetManager::LoadAsset(Asset& as)
+    Font* AssetManager::GetFont(std::string fontName)
-	{
+    {
-		_assetQueue.push_back(as);
+        Font* fontPtr;
-	}
+        try
+        {
+            //Obtenemos la tx indicada.
+            fontPtr = _fonts.at(fontName);
+        }
+        catch (const std::out_of_range&)
+        {
+            //Si no existe, usamos la por defecto.
+            fontPtr = _fonts.at(defaultAsset);
+        }
+
+        return fontPtr;
+    }
 
 
-	void AssetManager::ProcessAssetQueue(int amount)
+    Font* AssetManager::getDefaultFont()
-	{
+    {
-		int cantidad = amount;
+        return _fonts.at(defaultAsset);
+    }
 
-		if (amount == -1 || cantidad >= _assetQueue.size())
+    //////////DEBUG//////////
-			cantidad = _assetQueue.size();
-
-		//Load Assets from files, depending on the type.
-		for (int i = 0; i < cantidad; i++)
-		{
-			Asset& as = _assetQueue.front();
-			switch (as._type)
-			{
-				case AssetType::Texture:
-				{
-					LoadTexture(as._name, as._path);
-					break;
-				}
-				case AssetType::Font:
-				{
-					LoadFont(as._name, as._path);
-					break;
-				}
-				default:
-				{
-					UE_LOG_WARN("Asset {0}, Type {1} Cannot be loaded from {2}", as._name, as._type, as._path);
-					break;
-				}
-			}
-			_assetQueue.pop_front();
-		}
-	}
 
 
+    void AssetManager::PrintAssetInfo()
+    {
+        std::cout << "AM - Debug INFO: " << std::endl;
+        for (int i = 0; i < _assetQueue.size(); i++) {
+            std::cout << _assetQueue[i]._name << " - " << _assetQueue[i]._path << std::endl;
+        }
+    }
 
-
+    /////////////////////////
-	void AssetManager::LoadTexture(std::string name, std::string txPath)
-	{
-		Texture* tx = new Texture(txPath, _SDL_Renderer);
-		_textures.insert(std::make_pair(name, tx));
-
-		//std::fstream file(txPath.c_str());
-
-		//json jread = json::parse(file);
-		//std::string path = jread["TexturePath"];
-
-		////Cargamos la textura.
-		//SDL_Surface* loadSurface = IMG_Load(path.c_str());
-		//SDL_Texture* tx = SDL_CreateTextureFromSurface(_mainRenderer, loadSurface);
-		//_textures.insert(std::make_pair(name, tx));
-		//SDL_FreeSurface(loadSurface);
-
-		////Almacenamos los Rects (sprites) de esa textura.
-		//json textureRects = jread["TextureRects"];
-
-		//_textureRects.insert(std::make_pair(name, std::vector<SDL_Rect>()));
-		//std::vector<SDL_Rect>& vector = _textureRects.at(name);
-
-		//for (int i = 0; i < textureRects.size(); i++)
-		//{
-		//	//json rectData = textureRects.at(i);
-		//	//SDL_Rect rect;
-		//	//rect.x = rectData.at()
-
-		//	vector.push_back(textureRects.at(i).get<SDL_Rect>());
-		//}
-
-
-		//file.close();
-	}
-
-
-	void AssetManager::RemoveTexture(std::string name)
-	{
-		//Se supone que el erase del map llama al destructor del objeto...
-		//Pero no lo he comprobado del todo.
-		_textures.erase(name);
-	}
-
-
-	void AssetManager::LoadFont(std::string name, std::string fontPath)
-	{
-		Font* fo = new Font(fontPath);
-		_fonts.insert(std::make_pair(name, fo));
-
-	}
-
-
-	void AssetManager::RemoveFont(std::string name)
-	{
-		//Se supone que el erase del map llama al destructor del objeto...
-		//Pero no lo he comprobado del todo.
-		_fonts.erase(name);
-	}
-
-
-	//////////DEBUG//////////
-
-
-	void AssetManager::PrintAssetInfo()
-	{
-		std::cout << "AM - Debug INFO: " << std::endl;
-		for (int i = 0; i < _assetQueue.size(); i++) {
-			std::cout << _assetQueue[i]._name << " - " << _assetQueue[i]._path << std::endl;
-		}
-	}
-
-	/////////////////////////
 }

UberEngine/src/Assets/AssetManager.h

@@ -11,173 +11,242 @@
 #include <SDL_image.h>
 
 /*UberEngine Includes*/
-//#include "Assets\Asset.h"
+#include "Assets/Asset.h"
 #include "Assets/Texture.h"
 #include "Assets/Font.h"
-#include "Assets/Asset.h"
 
 using json = nlohmann::ordered_json;
 
 
 ///
-///	TODO:
+/// TODO AssetManager:
 ///  - Modificar las funciones de Carga para quitar la queue o implementar una que tenga sentido.
-///		 Por ejemplo, se puede crear una cola (std::deque) y cargar un asset cada gameLoop en vez de
+///      Por ejemplo, se puede crear una cola (std::deque) y cargar un asset cada gameLoop en vez de
-///		 procesar toda la cola de golpe. Optimizar�a la carga de assets.
+///      procesar toda la cola de golpe. Optimizar�a la carga de assets.
-///	 - Terminar la implementaci�n del tipo de carga (queue/now).
+///  - Terminar la implementación del tipo de carga (queue/now). (O quizás no...)
 ///  - Modificar los for en la carga de archivo, as� como la estructura del archivo JSON. El tipo de Asset est� repetido.
 ///  - Logging.
 ///  - ERROR HANDLING
 ///  - More asset types.
+///  - ¡¡Texturas y assets por defecto. Texturas completas en el txRect 0 y demás seguridad!!
 
 namespace UE
 {
 
-	/* Gestiona todos assets primitivos, almacenando sus ptrs en un lugar seguro. */
+    /* Gestiona todos assets primitivos, almacenando sus ptrs en un lugar seguro. */
-	class AssetManager
+    class AssetManager
-	{
+    {
-	public:
+    public:
-		/* Constructor. */
+        /* Constructor. */
-		AssetManager(SDL_Renderer* SDLrenderer)
+        AssetManager(SDL_Renderer* SDLrenderer)
-			: _SDL_Renderer(SDLrenderer) {}
+            : _SDL_Renderer(SDLrenderer) {}
 
 
-		/** 
+        ////////////////////////////////////////////////////////
-		 *	Init AssetManager y todo lo necesario para funcionar correctamente.
-		 *	- Inicia SDL_IMG.
-		 */
-		void InitAssetManager();
-
-		/**
-		 * 
-		 * Clean AssetManager Data on exit
-		 *	- Elimina todos los assets de sus contenedores.
-		 *	- Descarga SDL_IMG
-		 */
-		void CleanAssetManager();
 
 
-		/* Carga de Assets */
+        /** 
-	
+         *  Init AssetManager y todo lo necesario para funcionar correctamente.
-		/**
+         *  - Inicia SDL_IMG.
-		 * Carga los datos de los Assets desde un fichero JSON seg�n par�metros.
+         */
-		 * 
+        void InitAssetManager();
-		 * \param filePath: Ubicaci�n del archivo JSON.
-		 * \param loadMethod: Forma de carga. Procesado al momento o a�adido a la cola de carga.
-		 * 
-		 */
-		void LoadAssetsFromFile(std::string filePath);
 
-		/**
+        /**
-		 * Carga el Asset pasado por par�metro.
+         * 
-		 * 
+         * Clean AssetManager Data on exit
-		 * \param as: Asset que cargar.
+         *  - Elimina todos los assets de sus contenedores.
-		 * \param loadMethod: Forma de carga. Procesado al momento o a�adido a la cola de carga.
+         *  - Descarga SDL_IMG
-		 * 
+         */
-		 */
+        void CleanAssetManager();
-		void LoadAsset(Asset& as);
 
 
-		/**
+        ////////////////////////////////////////////////////////
-		 * Procesa la cola de carga de Assets.
-		 *
-		 * \param Amount: N�mero de Assets de la cola a procesar. Si vale -1 se procesar�n todos.
-		 *
-		 */
-		void ProcessAssetQueue(int amount = -1);
-
-		/**
-		 * Devuelve la cantidad de Assets que quedan sin procesar en la cola.
-		 * De esta forma, se puede hacer un bucle hasta que la cola sea <= 0.
-		 * 
-		 */
-		inline int GetAssetQueueSize() { return _assetQueue.size(); }
-
-		/// <summary>
-		/// Comprueba si la cola de carga de Assets est� vac�a.
-		/// </summary>
-		/// <returns>El resultado de la cola.</returns>
-		inline bool IsAssetQueueEmpty() { return _assetQueue.empty(); }
 
 
-		/*--------------------------------------/
+        /* Carga de Assets */
-		*	M�todos para manejar las texturas.  *
+    
-		*--------------------------------------*/
+        /**
+         * Carga los datos de los Assets desde un fichero JSON seg�n par�metros.
+         * 
+         * \param filePath: Ubicaci�n del archivo JSON.
+         * \param loadMethod: Forma de carga. Procesado al momento o a�adido a la cola de carga.
+         * 
+         */
+        void LoadAssetsFromFile(std::string filePath);
 
-		//Crea una textura de SDL y la a�ade al mapa de texturas identificada por su nombre.
+        /**
-		void LoadTexture(std::string name, std::string txPath);
+         * Carga el Asset pasado por par�metro.
-
+         * 
-		//Elimina una textura del mapa a partir de su nombre.
+         * \param as: Asset que cargar.
-		void RemoveTexture(std::string name);
+         * \param loadMethod: Forma de carga. Procesado al momento o a�adido a la cola de carga.
-
+         * 
-		//Obtiene una textura del mapa a partir de su nombre.
+         */
-		//inline SDL_Texture* getTexture(std::string textureName) { return _textures.at(textureName); }
+        void LoadAsset(Asset& as);
-		inline Texture* getTexture(std::string textureName) { return _textures.at(textureName); }
-
-		//inline std::vector<SDL_Rect>* getTexureRects(std::string textureName) { return &_textureRects.at(textureName); }
 
 
-		/*------------------------------------/
+        ////////////////////////////////////////////////////////
-		*	M�todos para manejar las fuentes. *
-		*------------------------------------*/
 
-		/**
-		* Crea un objeto UE:Font y lo a�ade al mapa de fuentes.
-		*
-		* @param name : Nombre del asset (key para el mapa de fuentes).
-		* @param fontPath : Ubicaci�n del archivo de datos sobre la fuente.
-		*
-		*/
-		void LoadFont(std::string name, std::string fontPath);
 
-		/**
+        /**
-		* Elimina una fuente (y en teor�a limpia la fuente) dado su nombre de Asset.
+         * Procesa la cola de carga de Assets.
-		*
+         *
-		* @param name : Nombre del Asset (key del mapa de fuentes).
+         * \param Amount: N�mero de Assets de la cola a procesar. Si vale -1 se procesar�n todos.
-		*
+         *
-		*/
+         */
-		void RemoveFont(std::string name);
+        void ProcessAssetQueue(int amount = -1);
 
-		/**
+        /**
-		* Obtiene y devuelve el ptr a una fuente dado su nombre de asset.
+         * Devuelve la cantidad de Assets que quedan sin procesar en la cola.
-		* 
+         * De esta forma, se puede hacer un bucle hasta que la cola sea <= 0.
-		* @param fontName : Nombre del Asset.
+         * 
-		* @return UE::Font* : El ptr a la fuente solicitada.
+         */
-		* 
+        inline int GetAssetQueueSize() { return _assetQueue.size(); }
-		*/
+
-		inline Font* GetFont(std::string fontName) { return _fonts.at(fontName); }
+        /**
+        * Permite saber si la cola de carga de Assets está vacía.
+        * 
+        * @return True si está vacía; false si hay algún Asset.
+        */
+        inline bool IsAssetQueueEmpty() { return _assetQueue.empty(); }
+
+
+        ////////////////////////////////////////////////////////
+
+
+        /*--------------------------------------/
+        *   Métodos para manejar las texturas.  *
+        *--------------------------------------*/
+
+        /**
+        * Carga una textura dado su nombre y su Path.
+        * 
+        * @param name: Nombre identificador de la tx.
+        * @param txPath: Ubicación de la tx que se quiere cargar.
+        */
+        void LoadTexture(std::string name, std::string txPath);
+
+        
+        /**
+        * Descarga la textura con el nombre identificador indicado.
+        * NOTA AssetManager: Quizás queramos cambiar el nombre de los métodos de descarga: RemoveAsset -> UnloadAsset.
+        * 
+        * @param name: Nombre identificador.
+        */
+        void RemoveTexture(std::string name);
 
 
 
-		///////DEBUG////////
+        /**
-		void PrintAssetInfo();
+        * Obtiene una textura del mapa a partir de su nombre.
-		///////////////////
+        * 
+        * NOTA REWORK getTexture() -> La tx que se retorna habrá de ser const para evitar que modifiquen datos comunes.
+        *   Así el TextureLoader o quien la cree podrá modificar lo que desee, pero no una vez metida aquí (hecha común).
+        * 
+        * @param textureName: Nombre de la textura que se quiere.
+        * 
+        * @return Ptr a la tx solicitada.
+        */
+        Texture* getTexture(std::string textureName);
 
-	private:
+        /**
-		
+        * Devuelve un Ptr a la textura por defecto.
-		//----------------------
+        * Utilizado cuando no exista una textura específica.
-		//VARIABLES
+        * 
-		//---------------------
+        * @return Ptr a la textura por defecto.
+        */
+        Texture* getDefaultTexture();
+
+        //inline std::vector<SDL_Rect>* getTexureRects(std::string textureName) { return &_textureRects.at(textureName); }
 
 
-		//std::string _assetPath;
+        ////////////////////////////////////////////////////////
-		
-		//std::vector<UE::Asset> _assets = {};
-		std::deque<UE::Asset> _assetQueue = {};
 
-		/* Almacenes de asssets */
 
-		//Almac�n de SDL_Texture* (ptrs, pues lo gestiona SDL).
+        /*------------------------------------/
-		//std::unordered_map<std::string, SDL_Texture*> _textures = {};
+        *   M�todos para manejar las fuentes. *
-		//std::unordered_map<std::string, std::vector<SDL_Rect>> _textureRects = {};
+        *------------------------------------*/
-		std::unordered_map <std::string, Texture*> _textures = {};
 
-		//Almacen de TTF_Fonts* (Para las fuentes de SDL_TTF).
+        /**
-		std::unordered_map<std::string, Font*> _fonts = {};
+        * Crea un objeto UE:Font y lo a�ade al mapa de fuentes.
-		
+        *
+        * @param name : Nombre del asset (key para el mapa de fuentes).
+        * @param fontPath : Ubicaci�n del archivo de datos sobre la fuente.
+        */
+        void LoadFont(std::string name, std::string fontPath);
 
-		//Necesario para crear las SDL_Texture a partir de SDL_Surface.
+        /**
-		SDL_Renderer* _SDL_Renderer = NULL;
+        * Elimina una fuente dado su nombre identificador.
-	};
+        *
+        * @param name : Nombre del Asset (key del mapa de fuentes).
+        */
+        void RemoveFont(std::string name);
+
+        /**
+        * Obtiene y devuelve el ptr a una fuente dado su nombre de asset.
+        * 
+        * @param fontName : Nombre del Asset.
+        * 
+        * @return UE::Font* : El ptr a la fuente solicitada.
+        */
+        Font* GetFont(std::string fontName);
+
+        /**
+        * Devuelve un Ptr a la fuente por defecto.
+        * Utilizado cuando no exista o no se indique una fuente específica.
+        *
+        * @return Ptr a la fuente por defecto.
+        */
+        Font* getDefaultFont();
+
+
+        ////////////////////////////////////////////////////////
+
+
+        ///////DEBUG////////
+        void PrintAssetInfo();
+        ///////////////////
+
+    private:
+        
+        //----------------------
+        //VARIABLES
+        //---------------------
+
+
+        /**
+        * Nombre de los Assets por defecto. 
+        * Sustituirá a un Asset no disponible.
+        * NOTA: UberEngine debería traer Assets por defecto para esta funcionalidad.
+        */
+        const std::string defaultAsset = "default";
+        
+
+        ////////////////////////////////////////////////////////
+
+        
+        //std::vector<UE::Asset> _assets = {};
+        std::deque<UE::Asset> _assetQueue = {};
+
+
+        ////////////////////////////////////////////////////////
+
+
+        /* Almacenes de asssets */
+
+        //Almac�n de SDL_Texture* (ptrs, pues lo gestiona SDL).
+        //std::unordered_map<std::string, SDL_Texture*> _textures = {};
+        //std::unordered_map<std::string, std::vector<SDL_Rect>> _textureRects = {};
+        std::unordered_map <std::string, Texture*> _textures = {};
+
+        //Almacen de TTF_Fonts* (Para las fuentes de SDL_TTF).
+        std::unordered_map<std::string, Font*> _fonts = {};
+        
+
+        ////////////////////////////////////////////////////////
+
+
+        //Necesario para crear las SDL_Texture a partir de SDL_Surface.
+        SDL_Renderer* _SDL_Renderer = NULL;
+    };
 
 }

UberEngine/src/Assets/Font.cpp

@@ -10,70 +10,70 @@ using json = nlohmann::ordered_json;
 
 TTF_Font* UE::Font::GetFont(int size)
 {
-	TTF_Font* font;
+    TTF_Font* font;
 
-	auto it = _fonts.find(size);
+    auto it = _fonts.find(size);
-	if (it == _fonts.end())
+    if (it == _fonts.end())
-	{
+    {
-		//El tama�o pedido no est� disponible.
+        //El font size pedido no está disponible.
-		//La creamos nueva.
+        //Creamos el nuevo size.
-		font = CreateFontSize(size);
+        font = CreateFontSize(size);
-		return font;
+        return font;
-	}
+    }
-	//En caso de estar disponible, lo retornamos.
+    //En caso de estar disponible, lo retornamos.
-	font = it->second;
+    font = it->second;
-	return font;
+    return font;
-	
+    
 }
 
 void UE::Font::InitFont()
 {
-	//Cargamos los datos desde el archivo.
+    //Cargamos los datos desde el archivo.
-	std::fstream file(_dataPath.c_str());
+    std::fstream file(_dataPath.c_str());
 
-	if (!file.is_open())
+    if (!file.is_open())
-	{
+    {
-		UE_LOG_ERROR("No se ha podido abrir el archivo de datos de fuente: {0}", _fontPath);
+        UE_LOG_ERROR("No se ha podido abrir el archivo de datos de fuente: {0}", _fontPath);
-		return;
+        return;
-	}
+    }
 
-	json jread = json::parse(file);
+    json jread = json::parse(file);
 
-	_fontPath = jread["FontPath"].get<std::string>();
+    _fontPath = jread["FontPath"].get<std::string>();
 
-	//Obtenemos los tama�os que crear de inicio.
+    //Obtenemos los tama�os que crear de inicio.
-	std::vector<int> vect = jread["FontSizes"].get<std::vector<int>>();
+    std::vector<int> vect = jread["FontSizes"].get<std::vector<int>>();
-	for (auto it : vect)
+    for (auto it : vect)
-	{
+    {
-		CreateFontSize(it);
+        CreateFontSize(it);
-	}
+    }
 
-	file.close();
+    file.close();
 }
 
 void UE::Font::CleanFont()
 {
-	//Eliminamos todos los tama�os de las fuentes.
+    //Eliminamos todos los tama�os de las fuentes.
-	for (auto i = _fonts.begin(); i != _fonts.end(); i++)
+    for (auto i = _fonts.begin(); i != _fonts.end(); i++)
-	{
+    {
-		TTF_CloseFont(i->second);
+        TTF_CloseFont(i->second);
-	}
+    }
 }
 
 TTF_Font* UE::Font::CreateFontSize(int size)
 {
-	//Creamos la fuente del tama�o requerido.
+    //Creamos la font size requerida.
-	TTF_Font* font = TTF_OpenFont(_fontPath.c_str(), size);
+    TTF_Font* font = TTF_OpenFont(_fontPath.c_str(), size);
-	if (font == nullptr)
+    if (font == nullptr)
-	{
+    {
-		UE_LOG_ERROR("No se ha podido crear la fuente: {0} - Size: {1}", _fontPath, size);
+        UE_LOG_ERROR("Font - No se ha podido crear la fuente: {0} - Size: {1}", _fontPath, size);
-		return nullptr;
+        return nullptr;
-	}
+    }
 
-	//La a�adimos al mapa.
+    //Add to the map
-	_fonts.insert(std::make_pair(size, font));
+    _fonts.insert(std::make_pair(size, font));
 
-	UE_LOG_TRACE("Font: {0} se ha creado con tamanho: {1}", _fontPath, size);
+    UE_LOG_TRACE("Font: {0} se ha creado el Size: {1}", _fontPath, size);
 
-	return font;
+    return font;
 }

UberEngine/src/Assets/Font.h

@@ -7,79 +7,94 @@
 
 namespace UE
 {
-	/** 
+    /** 
-	* Clase Wrapper para las SDL_Fonts.
+    * Clase Wrapper para las SDL_Fonts.
-	* También sirve de "cache" para los diferentes tamaños de la fuente, de esta forma
+    * Dada una fuente ttf, carga los glyphos con los tamaños indicados y almacena el TTF_Font del tamaño correspondiente.
-	*	reducimos las veces que generamos las fuentes y podemos utilizar múltiples tamaños de forma sencilla.
+    * Esta clase contiene todos los tamaños cargados.
-	* 
+    * En caso de pedir un tamaño no cargado, lo cargará desde el archivo.
-	*/
+    * REWORK Font -> Quizás se pueda sacar el loader a otro lado (Como en UE::Texture). Aunque en este caso, como es una especie de FontManager, no sé.
-	class Font
+    */
-	{
+    class Font
-	public:
+    {
-		//-----------------------
+    public:
-		//----- Constructor -----
+        //-----------------------
-		//-----------------------
+        //----- Constructor -----
+        //-----------------------
 
-		Font(std::string dataPath)
+        Font(std::string dataPath)
-			: _dataPath(dataPath)
+            : _dataPath(dataPath)
-		{
+        {
-			InitFont();
+            InitFont();
-		}
+        }
 
-		~Font()
+        ~Font()
-		{
+        {
-			CleanFont();
+            CleanFont();
-		}
+        }
-
-		//-----------------------
-		//------- Methods -------
-		//-----------------------
 
 
-		/**
+        ////////////////////////////////////////////////////////
-		* Devuelve la fuente del tamaño pedido.
-		* En caso de no estar disponible, la genera y la añade al cache antes de devolverla.
-		* 
-		* @param size : tamaño de la fuente.
-		* @return TTF_Font* : Fuente del tamaño solicitado.
-		*/
-		TTF_Font* GetFont(int size);
 
 
-	private:
+        //-----------------------
-		/**
+        //------- Methods -------
-		* Crea la fuente a partir del archivo de datos.
+        //-----------------------
-		*/
-		void InitFont();
-
-		/**
-		* Limpia la fuente, eliminando todos sus tamaños y vaciando toda la memoria.
-		*/
-		void CleanFont();
-
-		/**
-		* Se encarga de generar el tamaño de fuente deseado.
-		* 
-		* @param size : tamaño a generar.
-		* @return TTF_Font* : Ptr al nuevo tamaño generado. Hay que guardarlo en algún sitio.
-		*/
-		TTF_Font* CreateFontSize(int size);
 
 
-		//-----------------------
+        /**
-		//------ Variables ------
+        * Devuelve la fuente del size pedido.
-		//-----------------------
+        * En caso de no estar disponible, la genera y la añade al cache antes de devolverla.
+        * 
+        * @param size : tama�o de la fuente.
+        * @return TTF_Font* : Fuente del size solicitado. En caso de error, devuelve un nullptr.
+        */
+        TTF_Font* GetFont(int size);
 
-	private:
-		//Ubicación del archivo de datos (.json).
-		std::string _dataPath = "";
 
-		//Ubicación de la tipografía (.ttf).
+        ////////////////////////////////////////////////////////
-		std::string _fontPath = "";
 
-		//Caché de los diferentes tamaños de la fuente.
-		std::unordered_map<int, TTF_Font*> _fonts = {};
 
-	};
+    private:
+        /**
+        * Crea la clase a partir del archivo de datos.
+        */
+        void InitFont();
+
+        /**
+        * Limpia la clase, eliminando todos los font sizes y vaciando toda la memoria.
+        */
+        void CleanFont();
+
+
+        ////////////////////////////////////////////////////////
+
+
+        /**
+        * Se encarga de generar el Font Size de fuente deseado.
+        * 
+        * @param size : Font Size a generar.
+        * @return TTF_Font* : Ptr al nuevo Font Size generado.
+        */
+        TTF_Font* CreateFontSize(int size);
+
+
+        ////////////////////////////////////////////////////////
+
+
+    private:
+        //-----------------------
+        //------ Variables ------
+        //-----------------------
+
+
+        //Path del archivo de datos (.json).
+        std::string _dataPath = "";
+        //Path de la tipografía (.ttf).
+        std::string _fontPath = "";
+
+        //Cache de los diferentes Font Sizes (glyphos).
+        std::unordered_map<int, TTF_Font*> _fonts = {};
+
+    };
 
 }

UberEngine/src/Assets/Texture.cpp

@@ -8,63 +8,116 @@
 #include <json/json.hpp>
 using json = nlohmann::ordered_json;
 
-SDL_Rect* UE::Texture::GetTextureRect(int i)
+SDL_Rect UE::Texture::GetTextureRect(int i)
 {
-	try
+    try
-	{
+    {
-		SDL_Rect* rect = &_txRects.at(i);
+        SDL_Rect rect = _txRects.at(i);
-		return rect;
+        return rect;
-	}
+    }
-	catch (const std::out_of_range&)
+    catch (const std::out_of_range&)
-	{
+    {
-		UE_LOG_ERROR("La textura {0} no tiene rect {1}", _txPath, i);
+        UE_LOG_WARN("La textura {0} no tiene rect {1}", _txPath, i);
-		return &_txRects.at(0);
+        return _txRects.at(0);
-	}
+    }
 
 }
 
+
+void UE::Texture::SetTexture(SDL_Texture* newTexture)
+{
+    //Destruimos la tx antigua. Esperomos no se haya hecho antes...
+    //Algo me dice que este if tiene más bien poco sentido...
+    if (_texture != nullptr)
+    {
+        SDL_DestroyTexture(_texture);
+    }
+
+    //Cambiamos la tx por la nueva.
+    _texture = newTexture;
+
+}
+
+
 void UE::Texture::InitTexture()
 {
-	std::fstream file(_dataPath);
+    std::fstream file(_dataPath);
-	//Comprobamos si el archivo se ha abierto.
+    //Comprobamos si el archivo se ha abierto.
-	if (!file.is_open())
+    if (!file.is_open())
-	{
+    {
-		UE_LOG_ERROR("No se ha podido abrir el archivo de datos de textura: {0}", _dataPath);
+        UE_LOG_ERROR("Texture - No se ha podido abrir el archivo de datos de textura: {0}", _dataPath);
-		return;
+        return;
-	}
+    }
 
-	json jread = json::parse(file);
+    json jread = json::parse(file);
-	_txPath = jread["TexturePath"].get<std::string>();
+    _txPath = jread["TexturePath"].get<std::string>();
 
-	//Creamos la textura.
+    //Creamos la textura.
-	CreateTexture();
+    if (int error = CreateTexture() < 0)
+    {
+        UE_LOG_ERROR("Texture {0}: La textura no se ha cargado. Se esperan excepciones. Error {1}",
+            _txPath,
+            error);
 
-	//Cargamos los Rects.
+        //En principio, los Rects se pueden cargar. Por tanto, continuamos.
-	json textureRects = jread["TextureRects"];
+    }
 
-	for (int i = 0; i < textureRects.size(); i++)
+    //Cargamos los Rects.
-	{
+    json textureRects = jread["TextureRects"];
-		AddRect(textureRects.at(i).get<SDL_Rect>());
-	}
 
-	file.close();
+    //Por defecto, el Rect 0 es la textura completa.
+    AddRect(SDL_Rect{ 0, 0, txSizeX, txSizeY });
+
+    //Este bucle debe empezar en 0, pues iteramos por los valores del JSON, no los de la textura.
+    for (int i = 0; i < textureRects.size(); i++)
+    {
+        AddRect(textureRects.at(i).get<SDL_Rect>());
+    }
+
+    file.close();
 
 }
 
 void UE::Texture::CleanTexture()
 {
-	SDL_DestroyTexture(_texture);
+    SDL_DestroyTexture(_texture);
-	_txRects.clear();
+    _txRects.clear();
 }
 
-void UE::Texture::CreateTexture()
+int UE::Texture::CreateTexture()
 {
-	SDL_Surface* loadSurface = IMG_Load(_txPath.c_str());
+    SDL_Surface* loadSurface = IMG_Load(_txPath.c_str());
-	_texture = SDL_CreateTextureFromSurface(_SDL_Renderer, loadSurface);
+    if (loadSurface == NULL)
-	SDL_FreeSurface(loadSurface);
+    {
+        UE_LOG_ERROR("Texture - No se ha podido cargar la tx en {0}: {1}",
+            _txPath,
+            IMG_GetError()
+        );
+
+        return -1;
+    }
+
+    //Extraemos el Size de la tx.
+    txSizeX = loadSurface->w;
+    txSizeY = loadSurface->h;
+
+    _texture = SDL_CreateTextureFromSurface(_SDL_Renderer, loadSurface);
+    if (_texture == NULL)
+    {
+        UE_LOG_ERROR("Texture - No se ha podido crear la tx {0}: {1}",
+            _txPath,
+            SDL_GetError()
+        );
+
+        return -2;
+    }
+
+    SDL_FreeSurface(loadSurface);
+
+    return 0;
 }
 
-void UE::Texture::AddRect(SDL_Rect newRect)
+void UE::Texture::AddRect(SDL_Rect& newRect)
 {
-	_txRects.push_back(newRect);
+    _txRects.push_back(newRect);
 }

UberEngine/src/Assets/Texture.h

@@ -8,94 +8,155 @@
 
 namespace UE
 {
+    /**
+    * Wrapper para SDL_Texture permitiendo Texturas "animadas" o "SpriteSheets".
+    * Contiene una SDL_Texture y un conjunto de SDL_Rects, indicando las distintas partes de la textura.
+    * El SDL_Rect index 0 indica la textura completa.
+    * 
+    * REWORK Texture -> Separar los datos (sdl_tx, rects, ...) del loader. No me gusta que una textura se tenga que cargar a si misma.
+    */
+    class Texture
+    {
+    public:
+        //-----------------------
+        //----- Constructor -----
+        //-----------------------
 
-	class Texture
+        Texture(std::string dataPath, SDL_Renderer* renderer)
-	{
+            : _dataPath(dataPath), _SDL_Renderer(renderer)
-	public:
+        {
-		//-----------------------
+            //REWORK -> En el Loader, estaría bien poder saber si se ha cargado o no. 
-		//----- Constructor -----
+            //  Para no añadirla al mapa de texturas y hacer fallback en la por defecto.
-		//-----------------------
+            InitTexture();
-
+        }
-		Texture(std::string dataPath, SDL_Renderer* renderer)
-			: _dataPath(dataPath), _SDL_Renderer(renderer)
-		{
-			InitTexture();
-		}
-
-		~Texture()
-		{
-			CleanTexture();
-		}
-
-		//-----------------------
-		//------- Methods -------
-		//-----------------------
-
-		/**
-		* Retorna la textura.
-		*/
-		inline SDL_Texture* GetTexture() { return _texture; }
-
-		/**
-		* Retorna los Rects de la textura.
-		*/
-		inline std::vector<SDL_Rect>* GetRectsVector() { return &_txRects; }
-
-		/**
-		* Retorna el Rect pedido. Comprobando que está disponible.
-		* Si no está disponible, devuelve el rect de index 0 (que debería ser el por defecto).
-		*
-		* @param i : Índice del rect.
-		* @return El SDL_Rect* solicitado (o el por defecto en caso de error).
-		*/
-		SDL_Rect* GetTextureRect(int i);
 
 
-	private:
+        //HACK Texture() -> Lo utilizaremos únicamente para poder crear Texture vacias, hasta que separemos el loader.
-		/**
+        Texture() {}
-		* Carga los datos desde el archivo de datos y crea la textura y sus rects.
-		*/
-		void InitTexture();
 
-		/**
+        ~Texture()
-		* Limpia todos los datos guardados.
+        {
-		*/
+            CleanTexture();
-		void CleanTexture();
+        }
-
-		/**
-		* Método encargado de generar la textura a partir de los valores de la clase.
-		*/
-		void CreateTexture();
-
-		/**
-		* Método que añade un SDL_Rect al vector correspondiente.
-		* @param newRect : Nuevo Rect que añadir al vector de Rects.
-		*/
-		void AddRect(SDL_Rect newRect);
-
-		//-----------------------
-		//------ Variables ------
-		//-----------------------
-
-	private:
-		//Ubicación del archivo de datos (.json).
-		std::string _dataPath = "";
-
-		//El propio renderer de SDL. Es necesario para crear y operar con las SDL_Textures.
-		SDL_Renderer* _SDL_Renderer = nullptr;
-
-		//Ubicación de la textura (.png).
-		std::string _txPath = "";
-
-		//La propia textura.
-		SDL_Texture* _texture = nullptr;
-		//Conjunto de rects que hay en la textura.
-		std::vector<SDL_Rect> _txRects = {};
 
 
+        ////////////////////////////////////////////////////////
 
 
-	};
+        //-----------------------
+        //------- Methods -------
+        //-----------------------
+
+
+        /**
+        * Retorna la textura interna.
+        * 
+        * @return Ptr a la SDL_Texture que contiene.
+        */
+        inline SDL_Texture* GetTexture() { return _texture; }
+
+
+        /**
+        * Retorna los Rects de la textura.
+        * 
+        * @return Vector con todos los Rects de la textura.
+        */
+        inline std::vector<SDL_Rect>* GetRectsVector() { return &_txRects; }
+
+
+        /**
+        * Retorna el Rect indicado, comprobando que esté disponible.
+        * Si no está disponible, devuelve el rect de index 0.
+        *
+        * @param i : index del rect. (El index 0 es la textura completa).
+        * @return El SDL_Rect solicitado (o el por defecto si no está disponible).
+        */
+        SDL_Rect GetTextureRect(int i);
+
+
+        ////////////////////////////////////////////////////////
+
+
+        //HACK Tiene que ser posible hacer un SetTexture. Será necesario cuando no cree su propia textura.
+        //  Pero habrá que pasarlo como const desde el AssetManager, para evitar modificar datos "comunes".
+        void SetTexture(SDL_Texture* newTexture);
+
+
+        ////////////////////////////////////////////////////////
+
+
+        /**
+        * Add a SDL_Rect to the Rect Array.
+        * 
+        * NOTA para REWORK -> Estaba en privado. Lo he movido aquí porque será público, pero no modificable si es const.
+        * 
+        * @param newRect: New Rect to add. Lo enviamos como referencia para ahorrar copias. IDK if is better...
+        */
+        void AddRect(SDL_Rect& newRect);
+
+
+        ////////////////////////////////////////////////////////
+
+
+    private:
+        /**
+        * Carga los datos desde el archivo de datos y crea la textura y sus rects.
+        */
+        void InitTexture();
+
+        /**
+        * Limpia todos los datos guardados.
+        */
+        void CleanTexture();
+
+
+        ////////////////////////////////////////////////////////
+
+
+        /**
+        * Genera la textura a partir de los valores de la clase.
+        */
+        int CreateTexture();
+
+
+        ////////////////////////////////////////////////////////
+
+
+    private:
+        //-----------------------
+        //------ Variables ------
+        //-----------------------
+
+        //Path del archivo de datos (.json).
+        std::string _dataPath = "";
+        //Path de la textura (.png o formato de la imagen).
+        std::string _txPath = "";
+
+        ////////////////////////////////////////////////////////
+
+
+        //La propia textura.
+        SDL_Texture* _texture = nullptr;
+        //Conjunto de rects que hay en la textura.
+        std::vector<SDL_Rect> _txRects = {};
+
+
+        ////////////////////////////////////////////////////////
+
+        //Size de la SDL_Texture. Por si se necesita para algo...
+        //NOTA Texture Size vars: Quizás haya que implementar algún método para estas vars.
+        int txSizeX = 0;
+        int txSizeY = 0;
+
+        ////////////////////////////////////////////////////////
+
+
+        //El propio renderer de SDL. Es necesario para crear y operar con las SDL_Textures.
+        //NOTA Texture: Para quitarlo de aquí, tenemos que mover el proceso de carga.
+        SDL_Renderer* _SDL_Renderer = nullptr;
+
+
+    };
 
 
 }

UberEngine/src/Drawables/Drawable.cpp

@@ -0,0 +1,11 @@
+#include "Drawable.h"
+
+#include "Assets/Texture.h"
+#include "Logging/Logger.h"
+
+namespace UE
+{
+
+
+
+}

UberEngine/src/Drawables/Drawable.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "Interfaces/Transformable.h"
+
+#include <SDL_rect.h>
+
+namespace UE
+{
+    class Renderer;
+    class Texture;
+
+    /*
+    * Clase base para renderizar objetos en el mundo.
+    */
+    class Drawable
+    {
+    protected:
+
+        Drawable() {}
+
+        ~Drawable() {}
+
+    protected:
+
+        //Esto permite acceder a este método desde el Renderer, pero no será accesible desde fuera.
+        //  de esta forma, me aseguro que ocurren las dos etapas del rendering.
+        friend class Renderer;
+
+        /*
+        * Esta función ha de ser sobrecargada por los Sprites especificos.
+        * Se deberá realizar el render en esta etapa.
+        */
+        virtual void Draw(Renderer* renderer) = 0;
+
+
+        ////////////////////////////////////////////////////////
+
+
+    public:
+
+        //Get-Set del renderLayer.
+        inline void SetLayer(int newLayer) { _renderLayer = newLayer; }
+        inline int GetLayer() { return _renderLayer; }
+
+        inline void SetVisible(bool visible) { _visible = visible; }
+        inline bool IsVisible() { return _visible; }
+
+
+
+    protected:
+
+        //Indica en qué layer está el objeto (z order).
+        int _renderLayer = 0;
+
+        bool _visible = true;
+
+    };
+}

UberEngine/src/Drawables/Sprite.cpp

@@ -2,52 +2,49 @@
 
 #include "Render/Renderer.h"
 #include "Assets/AssetManager.h"
+#include "Engine.h"
 
 #include "Logging/Logger.h"
 
 #include <iostream>
 
-void UE::Sprite::SetTextureRect(int textureID)
+
+namespace UE
 {
-	SDL_Rect* newRect = _texture->GetTextureRect(textureID);
+    Sprite::Sprite()
+    {
+        AssetManager* as = Engine::GetAssetManager();
+        _tx = as->getDefaultTexture();
+
+        SetTextureRect(0);
+        SetLayer(1);
+        SetPosition(0, 0);
+
+        SDL_Rect txSize = _tx->GetTextureRect(_txRectID);
+        SetSize(txSize.w, txSize.h);
+
+    }
+
+    void Sprite::SetTextureRect(int textureID)
+    {
+        _txRectID = textureID;
+    
+        //Sabemos que en caso de no estar disponible, no devolverá el Rect 0 (Textura completa).
+        _txRect = _tx->GetTextureRect(textureID);
+    }
+
+
+
+    void Sprite::Draw(Renderer* renderer)
+    {
+        //Comprobar si es visible.
+        if (!renderer->IsObjectVisible(&GetTransformRect()))
+        {
+            return;
+        }
+
+        renderer->DrawTextureOnWorld(_tx, _txRectID, GetTransformRect());
+    }
+
 
-	if (newRect != nullptr)
-	{
-		_actualTxRect = newRect;
-	}
 }
-
-void UE::Sprite::SetActive(bool active)
-{
-	isActive = active;
-}
-
-bool UE::Sprite::IsActive()
-{
-	return isActive;
-}
-
-
-void UE::Sprite::Draw(Renderer* renderer)
-{
-	//Convertimos a ScreenCoords.
-	glm::ivec2 screenCoords = renderer->WorldToSreenCoords(_pos);
-
-	SDL_Rect position = { screenCoords.x, screenCoords.y, _size.x, _size.y };
-
-	//destination.x = _pos.x;
-	//destination.y = _pos.y;
-	//
-	//destination.w = _size.x;
-	//destination.h = _size.y;
-
-	//std::cout << "Sprite Rendered to: " << destination.x << "-" << destination.y << std::endl;
-	renderer->QueueDrawCall(_renderLayer, position, _texture->GetTexture(), *_actualTxRect);
-}
-
-SDL_Rect UE::Sprite::getPositionRect()
-{
-	SDL_Rect position = { _pos.x, _pos.y, _size.x, _size.y };
-	return position;
-}
-

UberEngine/src/Drawables/Sprite.h

@@ -8,12 +8,12 @@
 #include <glm/vec2.hpp>
 
 
-#include "Render/Drawable.h"
+#include "Drawables/Drawable.h"
-#include "Render/Transformable.h"
+#include "Interfaces/Transformable.h"
 #include "Assets/Texture.h"
 
 //
-// TODO:
+// TODO Sprite:
 //  - Implementar soporte para SpriteSheets en los constructores.
 //
 //
@@ -21,80 +21,107 @@
 
 namespace UE
 {
-	class Renderer;
+    class Renderer;
 
-	class Sprite : public Drawable, public Transformable
+    class Sprite : public Drawable, public Transformable
-	{
+    {
 
 
-	public:
+    public:
 
-		/*
+        /*
-		// --------------
+        // --------------
-		// Constructores.
+        // Constructores.
-		// --------------
+        // --------------
-		*/
+        */
 
-		/*
+        //NOTA: Hay que implementar una textura por defecto, que será la que se usará cuando no se indique nada.
-			Se establecen todos los par�metos.
+        // De esta forma, podemos tener constructores por defecto.
-			La textura es obligatoria, y puede ha de darse:
-				- En SDL_Texture* -> Sin m�s, se entiende.
-				En ambos casos se llama al m�todo SetTexturePtr.
-			Los dem�s par�metros tienen un valor por defecto.
 
-			\param texturePtr: El pointer a la textura de SDL.
+        /*
-			\param textureRects: El pointer al conjunto de SDL_Rects de la textura.
+            Se establecen todos los parámetos.
-			\param textureRectID: El n�mero de Rect del conjunto de rects.
+            La textura es obligatoria, y puede ha de darse:
-			\param renderLayer: La Layer en que se renderizar�.
+                - En SDL_Texture* -> Sin más, se entiende.
-		*/
+            Los demás parámetros tienen un valor por defecto.
-		Sprite(UE::Texture* texture,
-			int textureRectID = 0,
-			int renderLayer = 1,
-			glm::vec2 position = glm::vec2(0, 0),
-			glm::vec2 size = glm::vec2(100, 100))
 
-			: _texture(texture)
+            \param texturePtr: El pointer a la textura de SDL.
-		{
+            \param textureRectID: El número de Rect del conjunto de rects. Por defecto será 0 (La textura completa).
-			SetTextureRect(textureRectID);
+            \param renderLayer: La Layer en que se renderizará.
+            \param position: Posición del Sprite.
+            \param size: Tamaño del Sprite.
+        */
+        Sprite(UE::Texture* texture,
+            int textureRectID = 0,
+            int renderLayer = 1,
+            glm::vec2 position = glm::vec2(0, 0),
+            glm::vec2 size = glm::vec2(100, 100))
+        {
+            _tx = texture;
 
-			SetLayer(renderLayer);
+            SetTextureRect(textureRectID);
 
-			SetPosition(position);
+            SetLayer(renderLayer);
-			SetSize(size);
+
-		}
+            SetPosition(position);
+            SetSize(size);
+        }
+
+        Sprite();
 
 
-		~Sprite() {}
+        ~Sprite() {}
 
 
-		//-----------
+        ////////////////////////////////////////////////////////
-		//- Setters -
-		//-----------
 
 
-		void SetTextureRect(int textureID);
+        //-----------
-
+        //- Methods -
-		void SetActive(bool active);
+        //-----------
-		bool IsActive();
-
-		//Implementa el Draw de Drawable.
-		void Draw(Renderer* renderer) override;
-
-		SDL_Rect getPositionRect();
-
-	private:
-
-		//Datos de la textura. Sirven para pedirla al AssetManager.
-
-		UE::Texture* _texture = nullptr;
-
-		//El que se va a renderizar.
-		SDL_Rect* _actualTxRect = nullptr;
-
-		bool isActive = true;
 
 
-	};
+        void SetTextureRect(int textureID);
+
+
+
+        ////////////////////////////////////////////////////////
+
+
+        inline bool IsActive() { return isActive; }
+        inline void SetActive(bool active) { isActive = active; }
+
+
+        ////////////////////////////////////////////////////////
+
+
+
+        //Implementa el Draw de Drawable.
+        void Draw(Renderer* renderer) override;
+
+
+    private:
+
+        //Ptr a la textura y los datos que está utilizando.
+        UE::Texture* _tx = nullptr;
+
+        //Sección de la textura que se utilizará.
+        SDL_Rect _txRect{ 0, 0, 0, 0 };
+
+        //UE::Texture contiene una lista de rects, con esto, podemos seleccionar el rect que queramos.
+        //FIX: Pero es redundante con _txRect y para que sea seguro habría que encapsular todo.
+        //¿Es necesario que esté aquí? ¿Puedo simplemente tenerlo en aquellos Drawables en que lo necesite (animated ones)?
+        int _txRectID = 0;
+
+
+        ////////////////////////////////////////////////////////
+
+
+        //Permite activar o desactivar el Drawable. Si está desactivado, no se debería de renderizar/ejecutar.
+        //NOTA: Se puede mover al Sprite para detener también el Update.
+        bool isActive = true;
+
+
+    };
 
 
 }

UberEngine/src/Drawables/TextBox.cpp

@@ -1,32 +1,35 @@
 #include "TextBox.h"
 
+#include "Engine.h"
 #include "Logging/Logger.h"
 #include "Render/Renderer.h"
 
+#include <SDL_render.h>
+
 void UE::TextBox::SetText(std::string newText)
 {
-	_text = newText;
+    _text = newText;
-	RenderTextTexture();
+    RenderTextTexture();
 }
 
 void UE::TextBox::SetSize(int newSize)
 {
-	_textSize = newSize;
+    _textSize = newSize;
-	RenderTextTexture();
+    RenderTextTexture();
 }
 
 
 void UE::TextBox::SetColor(UE_Color newColor)
 {
-	_textColor = newColor;
+    _textColor = newColor;
-	RenderTextTexture();
+    RenderTextTexture();
 }
 
 void UE::TextBox::SetColor(int r, int g, int b, int a)
 {
-	UE_Color c = UE_Color(r, g, b, a);
+    UE_Color c = UE_Color(r, g, b, a);
-	_textColor = c;
+    _textColor = c;
-	RenderTextTexture();
+    RenderTextTexture();
 }
 
 
@@ -34,56 +37,74 @@ void UE::TextBox::SetColor(int r, int g, int b, int a)
 
 void UE::TextBox::Draw(Renderer* renderer)
 {
-	//Si a�n no tenemos renderer, lo guardamos y procesamos.
-	if (_sdlRenderer == nullptr)
-	{
-		_sdlRenderer = renderer->GetSDLRenderer();
-		RenderTextTexture();
-	}
-	if (_textTexture == nullptr)
-	{
-		UE_LOG_WARN("El texto: {0} ; No se est� renderizando. La textura no existe.", _text);
-		return;
-	}
 
-	//Generamos el SDL_Rect destino.
+    if (_tx->GetTexture() == nullptr)
-	SDL_Rect dest = { _pos.x, _pos.y, _size.x, _size.y };
+    {
+        UE_LOG_WARN("El texto: {0} ; No se está renderizando. La textura no existe.", _text);
+        return;
+    }
 
-	renderer->QueueDrawCall(_renderLayer, dest, _textTexture);
+    //Generamos el SDL_Rect destino.
+    // Ya no es necesario....
+    //SDL_Texture* tx = _textTexture.GetTexture();
+
+    //renderer->QueueDrawCall(_renderLayer, dest, _textTexture);
+    renderer->DrawTextureOnScreen(_tx, 0, GetTransformRect());
+    
+    //Actualizamos en cada frame el ptr a la textura que tiene que usar el drawable.
+    //no vaya a ser que se invalide por algo.
 
 }
 
 void UE::TextBox::RenderTextTexture()
 {
-	//No podemos continuar hasta que no tengamos un renderer.
+    // No podemos continuar sin un SDL_Renderer.
-	if (_sdlRenderer == nullptr) { return; }
+    // Si no hay SDL_Renderer, lo buscamos en el Engine.
+    if (_sdlRenderer == nullptr) { GetSDL_Renderer(); }
 
-	SDL_DestroyTexture(_textTexture);
 
-	//Creamos el SDL_Color a partir del vec4 que contiene el color.
+    //Creamos el SDL_Color a partir del vec4 que contiene el color.
-	SDL_Color color = { _textColor.x,_textColor.y, _textColor.z, _textColor.w };
+    SDL_Color color = { _textColor.x,_textColor.y, _textColor.z, _textColor.w };
 
-	//Tomamos la TTF_Font del tama�o que queremos de UE::Font.
+    //Tomamos la TTF_Font del tama�o que queremos de UE::Font.
-	TTF_Font* fn = _font->GetFont(_textSize);
+    TTF_Font* fn = _font->GetFont(_textSize);
 
-	SDL_Surface* loader = TTF_RenderText_Solid(fn, _text.c_str(), color);
+    SDL_Surface* loader = TTF_RenderText_Solid(fn, _text.c_str(), color);
-	if (loader == NULL)
+    if (loader == NULL)
-	{
+    {
-		UE_LOG_ERROR("No se ha podido crear el texto: {0} ; Error: {1}", 
+        UE_LOG_ERROR("No se ha podido crear el texto: {0} ; Error: {1}", 
-			_text, TTF_GetError());
+            _text, TTF_GetError());
-		return;
+        return;
-	}
+    }
 
-	_textTexture = SDL_CreateTextureFromSurface(_sdlRenderer, loader);
+    SDL_Texture* newTextTexture = SDL_CreateTextureFromSurface(_sdlRenderer, loader);
-	if (_textTexture == NULL)
+    if (newTextTexture == NULL)
-	{
+    {
-		UE_LOG_ERROR("No se ha podido crear la textura del texto: {0} ; Error: {1}",
+        UE_LOG_ERROR("No se ha podido crear la textura del texto: {0} ; Error: {1}",
-			_text, SDL_GetError());
+            _text, SDL_GetError());
-		return;
+        return;
-	}
+    }
-	_size.x = loader->w;
+    _size.x = loader->w;
-	_size.y = loader->h;
+    _size.y = loader->h;
 
-	SDL_FreeSurface(loader);
+    SDL_FreeSurface(loader);
 
+    //Actualizamos la SDL_Texture en la Texture.
+    _tx->SetTexture(newTextTexture);
+
+
+    //Limpiamos los Rects antiguos.
+    _tx->GetRectsVector()->clear();
+    //Añadimos el Rect correspondiente.
+    SDL_Rect newRect = { 0, 0, _size.x, _size.y };
+    _tx->AddRect(newRect);
+
+    //Actualizamos el Rect en el Drawable.
+    _txRect = newRect;
+}
+
+
+void UE::TextBox::GetSDL_Renderer()
+{
+    _sdlRenderer = Engine::GetRenderer()->GetSDLRenderer();
 }

UberEngine/src/Drawables/TextBox.h

@@ -5,66 +5,143 @@
 #include <glm/vec4.hpp>
 
 
-#include "Render/Drawable.h"
+#include "Drawable.h"
-#include "Render/Transformable.h"
+#include "Interfaces/Transformable.h"
 
 #include "Assets/Font.h"
+#include "Assets/Texture.h"
 
 
 namespace UE
 {
-
+    //NOTA: hay que mover esto a la lista de definiciones (defs.h). Algún día, lo crearemos.
-	typedef glm::tvec4<int> UE_Color;
+    typedef glm::tvec4<int> UE_Color;
-
-	class TextBox : public Drawable, public Transformable
-	{
-
-	public:
-		
-
-		TextBox(UE::Font* font,
-			std::string text = "Texto por defecto",
-			int textSize = 18,
-			UE_Color textColor = UE_Color(0, 0, 0, 255),
-			int renderLayer = 1,
-			glm::vec2 position = glm::vec2(0, 0))
-			: _font(font), _text(text), _textSize(textSize)
-		{
-			SetColor(textColor);
-
-			SetLayer(renderLayer);
-			SetPosition(position);
-
-			RenderTextTexture();
-		}
-
-		//Se generar� una textura y todo eso...
-		void SetText(std::string newText);
-		void SetSize(int newSize);
-
-		void SetColor(UE_Color newColor);
-		void SetColor(int r, int g, int b, int a);
 
 
-		//Implementa el Draw de Drawable.
+    class TextBox : public Drawable, public Transformable
-		void Draw(Renderer* renderer) override;
+    {
 
-	private:
+    public:
-		void RenderTextTexture();
+        
+
+        TextBox(UE::Font* font,
+            std::string text = "Texto por defecto",
+            int textSize = 18,
+            UE_Color textColor = UE_Color(0, 0, 0, 255),
+            int renderLayer = 1,
+            glm::vec2 position = glm::vec2(0, 0))
+            : _font(font), _text(text), _textSize(textSize)
+        {
+            //Obtenemos el SDL_Renderer que necesitamos.
+            GetSDL_Renderer();
+
+            //Creamos la texture.
+            //_textTexture = new Texture();
+
+            //Le decimos al Drawable cual es la textura que tiene que usar.
+            _tx = new Texture();
+
+            SetColor(textColor);
+
+            SetLayer(renderLayer);
+            SetPosition(position);
+
+            RenderTextTexture();
+        }
 
 
-	private:
+        ~TextBox()
-		UE::Font* _font = nullptr;
+        {
-		std::string _text = "Texto por defecto";
+            //Hay que limpiar lo que ocupamos.
-		int _textSize = 18;
+            //delete _textTexture;
-		UE_Color _textColor;
+            delete _tx;
+        }
 
-		SDL_Texture* _textTexture = nullptr;
 
-		//Esto est� muy mal hecho, no deber�a de ser as�.
+        // Si se realiza una copia, necesitamos que esta utilice su propia textura.
-		//Necesito un renderer para crear la textura del texto, pero no puedo conseguirlo con la arquitectura actual.
+        // Así, si queremos copiar una para luego modificarla, no se modifican las dos.
-		//No quiero regenerar la textura en cada frame de forma innecesaria...
+        // (Y si una se borra no se lleva consigo los ptrs de las 2).
-		//Por ello, me toca forzar un poco el sistema.
+        TextBox(const TextBox& c)
-		SDL_Renderer* _sdlRenderer = nullptr;
+            : _font(c._font), _text(c._text), _textSize(c._textSize), _textColor(c._textColor)
-	};
+        {
+            //Le decimos al Drawable cual es la textura que tiene que usar.
+            _tx = new Texture();
+
+            SetLayer(c._renderLayer);
+            SetPosition(c._pos);
+
+            this->RenderTextTexture();
+        }
+
+        //TODO: Eliminar constructores de Copy y demás. No se debería permitir el copiar... Rompen la _textTexture.
+        //NOTA: Quizás, la solución esté en los Smart Pointers...
+        //  Se me ocurre lo siguiente:
+        //      Añadimos un almacén "estático" para texturas en algún sitio. Le puedes pedir que te de una textura,
+        //      y te la almacena ahí. Tú recibes un ptr y lo conservas. Tendrás acceso a la tx mientras tengas el ptr a la misma.
+        //      El sistema eliminará los ptrs que no se usen (smart pointers) porque no tengan referencias.
+        //
+
+        ////////////////////////////////////////////////////////
+
+
+        //Se generar� una textura y todo eso...
+        void SetText(std::string newText);
+        void SetSize(int newSize);
+
+
+        ////////////////////////////////////////////////////////
+
+
+        void SetColor(UE_Color newColor);
+        void SetColor(int r, int g, int b, int a);
+
+        
+        ////////////////////////////////////////////////////////
+
+
+        //Implementa el Draw de Drawable.
+        void Draw(Renderer* renderer) override;
+
+
+
+    private:
+        void RenderTextTexture();
+
+        
+        ////////////////////////////////////////////////////////
+
+
+        /*
+            Obtiene el SDL_Renderer desde el Engine. (Magia estática).
+        */
+        void GetSDL_Renderer();
+
+
+    private:
+        UE::Font* _font = nullptr;
+        std::string _text = "Texto por defecto";
+        int _textSize = 18;
+        UE_Color _textColor = {255, 255, 255, 255};
+
+
+        UE::Texture* _tx;
+        SDL_Rect _txRect;
+
+
+        ////////////////////////////////////////////////////////
+
+
+        //Creamos su propia textura, que le pasamos al Drawable.
+        //El Drawable no almacena una textura, sino un ptr (normalmente sacado del AssetManager). 
+        //En este caso, esta es la textura a la que debe apuntar.
+        // Pero podemos, simplemente, crear la textura en el heap y apuntar ahí el ptr.
+        //Texture* _textTexture;
+
+
+        //Esto est� muy mal hecho, no deber�a de ser as�.
+        //Necesito un renderer para crear la textura del texto, pero no puedo conseguirlo con la arquitectura actual.
+        //No quiero regenerar la textura en cada frame de forma innecesaria...
+        //Por ello, me toca forzar un poco el sistema.
+        SDL_Renderer* _sdlRenderer = nullptr;
+    };
 }

UberEngine/src/Engine.cpp

@@ -0,0 +1,152 @@
+#include "Engine.h"
+
+#include "Logging/Logger.h"
+
+#include "Render/Renderer.h"
+#include "Assets/AssetManager.h"
+#include "Scene/SceneManager.h"
+
+namespace UE
+{
+    //Le decimos a C++ que son objetos static y que los cree cuando vea.
+    
+    Renderer* Engine::_renderer;
+    AssetManager* Engine::_assetManager;
+    SceneManager* Engine::_sceneManager;
+
+
+    int Engine::Init()
+    {
+        //Lo primero, es iniciar el Logger, para poder imprimir errores.
+        UE::Logger::InitLogger();
+
+
+        //Etapa de carga de librerías.
+        if(InitLibs() < 0) //Retorna negativos en caso de error.
+        {
+            UE_LOG_CRITICAL("Engine - Error al inicial las librerías");
+            return -1;
+        }
+
+        //Iniciamos los sistemas del motor.
+        if(InitRenderer() < 0)
+        {
+            UE_LOG_CRITICAL("Engine - Error al iniciar el renderer.");
+            return -2;
+        }
+
+        if(InitAssetManager() < 0)
+        {
+            UE_LOG_CRITICAL("Engine - Error al inicial el AssetManager.");
+            return -3;
+        }
+
+        if(InitSceneManager() < 0)
+        {
+            UE_LOG_CRITICAL("Engine - Error al inicial el SceneManager.");
+            return -4;
+        }
+
+        UE_LOG_INFO("Engine - El motor se ha iniciado correctamente.");
+
+        return 0;
+    }
+
+    void Engine::Clean()
+    {
+        //Etapa para limpiar los sistemas del motor.
+        _sceneManager->CleanSceneManager();
+        delete _sceneManager;
+
+        _assetManager->CleanAssetManager();
+        delete _assetManager;
+
+        _renderer->CleanRenderer();
+        delete _renderer;
+
+        //Etapa para desactivar y limpiar todas las librerías.
+        QuitLibs();
+    }
+
+
+    int Engine::InitLibs()
+    {
+        //Iniciamos SDL.
+		SDL_HINT_RENDER_DRIVER "opengl";
+
+		Uint32 SDL_Flags = SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_EVENTS;
+		if (SDL_Init(SDL_Flags) < 0)
+		{
+			UE_LOG_CRITICAL("Engine - SDL: Error al iniciar SDL: {0}", SDL_GetError());
+			return -1;
+		}
+        UE_LOG_TRACE("Engine - SDL se ha iniciado correctamente");
+
+        //Iniciamos SDL_Image
+		if (IMG_Init(IMG_INIT_PNG) == 0) //Retorna 0 en caso de fallo.
+		{
+			UE_LOG_ERROR("Engine - SDL_Image: Error al iniciarse: {0}", IMG_GetError());
+            return -2;
+		}
+        UE_LOG_TRACE("Engine - SDL_Image se ha iniciado correctamente");
+
+        //Iniciamos el SDL_TTF
+		if (TTF_Init() < 0) //Retorna -1 en caso de error.
+		{
+			UE_LOG_ERROR("Engine - SDL_TTF: Error al inicarse: {0}", TTF_GetError());
+            return -3;
+		}
+        UE_LOG_TRACE("Engine - SDL_TTF se ha iniciado correctamente");
+
+        return 0;
+    }
+
+
+    int Engine::InitRenderer()
+    {
+        //Cargamos el Renderer.
+        //Hay que implementar un sistema de flags o 
+        //  una struct de configuración para la inicialización del renderer.
+        _renderer = new UE::Renderer(640, 480, 5);
+        if(_renderer->InitRenderer() < 0)
+        {
+            return -1;
+        }
+        UE_LOG_TRACE("Engine - Renderer: Se ha iniciado correctamente");
+        return 0;
+    }
+
+    int Engine::InitAssetManager()
+    {
+        //Cargamos el AssetManager
+        //Faltaría control de errores en caso de haberlo.
+        _assetManager = new UE::AssetManager(_renderer->GetSDLRenderer());
+        _assetManager->InitAssetManager();
+
+        
+        UE_LOG_TRACE("Engine - AssetManager: Se ha iniciado correctamente");
+        return 0;
+    }
+
+    int Engine::InitSceneManager()
+    {
+        //Cargamos el SceneManager
+        //Faltaría control de errores en caso de haberlo.
+        _sceneManager = new UE::SceneManager();
+
+        UE_LOG_TRACE("Engine - SceneManager: Se ha iniciado correctamente.");
+        return 0;
+    }
+
+
+    int Engine::QuitLibs()
+    {
+        TTF_Quit();
+		IMG_Quit();
+
+        SDL_Quit();
+
+        return 0;
+    }
+
+}

UberEngine/src/Engine.h

@@ -0,0 +1,80 @@
+#pragma once
+
+namespace UE
+{
+    //Declaraciones de clases de UberEngine
+
+    class Renderer;
+    class AssetManager;
+    class SceneManager;
+
+    /* Clase Principal del motor.
+     * Carga todas los sistemas y librerías al inicio y los descarga al final.
+     * Contiene ptrs a los sistemas principales.
+    */
+    class Engine
+    {
+    public:
+        /* 
+         * Inicia todos los sistemas y librerías necesarias.
+         * Retornará 0 o un código de error negativo.
+         */
+        static int Init();
+
+        /* 
+         * Limpia todas las cosas del motor.
+         */
+        static void Clean();
+
+        inline static UE::Renderer* GetRenderer() { return _renderer; }
+        inline static UE::AssetManager* GetAssetManager() { return _assetManager; }
+        inline static UE::SceneManager* GetSceneManager() { return _sceneManager;  }
+
+
+    private:
+
+        //Vamos a crear un método para la inicialización de cada sistema.
+        //  de esta forma, debería ser más fácil modificar la inicialización cuando sea necesario.
+
+        /*
+         * Inicializa las librerías de SDL.
+         * Retorna códigos de error negativos.
+         */
+        static int InitLibs();
+
+        /*
+         * Inicializa el renderer.
+         * En un futuro, debería ser configurable, además de soportar distintos backends.
+         */
+        static int InitRenderer();
+
+        /*
+         * Inicializa el AssetManager.
+         * Es necesario iniciar primero el Renderer para poder acceder al SDL_Renderer.
+         *      (al menos, mientras usemos el SDL_Renderer.)
+         */
+        static int InitAssetManager();
+
+
+        /*
+         * Inicializa el SceneManager.
+         */
+        static int InitSceneManager();
+
+
+        /*
+         * Al igual que se inician, hay que limpiar las libs.
+         */
+        static int QuitLibs();
+
+
+        /*
+         *  Ptrs de los sistemas.
+         */
+
+        static Renderer* _renderer;
+        static AssetManager* _assetManager;
+        static SceneManager* _sceneManager;
+
+    };
+}

UberEngine/src/Interfaces/Transformable.cpp

@@ -0,0 +1,55 @@
+#include "Transformable.h"
+
+#include "Logging/Logger.h"
+
+#include <SDL_rect.h>
+
+
+namespace UE
+{
+
+    void Transformable::SetPosition(float x, float y)
+    {
+         _pos.x = x;
+         _pos.y = y;
+    }
+
+    void Transformable::SetPosition(glm::vec<2, float> newPosition)
+    {
+        _pos = newPosition;
+    }
+
+    void Transformable::SetSize(float x, float y)
+    {
+        _size.x = x;
+        _size.y = y;
+    }
+
+    void Transformable::SetSize(glm::vec<2, float> newSize)
+    {
+        _size = newSize;
+    }
+
+    void Transformable::Move(float x, float y)
+    {
+        _pos.x += x;
+        _pos.y += y;
+    }
+
+    void Transformable::Resize(float x, float y)
+    {
+        _size.x += x;
+        _size.y += y;
+    }
+
+    SDL_Rect Transformable::GetTransformRect()
+    {
+        SDL_Rect rect = { _pos.x, _pos.y, _size.x, _size.y };
+        return rect;
+    }
+
+
+
+
+
+}

UberEngine/src/Interfaces/Transformable.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <glm/vec2.hpp>
+
+
+struct SDL_Rect;
+
+namespace UE
+{
+    /*
+        Almacena una posición y un tamaño.
+        Utilizado para representar objetos en algún espacio.
+    */
+    class Transformable
+    {
+    public:
+
+
+        //-----------
+        //- Setters -
+        //-----------
+
+
+        /*
+        * Establece una nueva posición para el objeto.
+        * Dados dos floats como nueva posición.
+        */
+        void SetPosition(float x, float y);
+
+        /*
+        * Establece una nueva posición para el objeto.
+        * Dado un vector como nueva posición.
+        */
+        void SetPosition(glm::vec<2, float> newPosition);
+
+
+        /*
+        * Establece un nuevo tamaño para el objeto (En principio, en pixeles).
+        * Dados dos floats como nuevo tamaño.
+        */
+        void SetSize(float x, float y);
+
+        /*
+        * Establece un nuevo tamaño para el objeto (En principio, en pixeles).
+        * Dado un vector como nuevo tamaño.
+        */
+        void SetSize(glm::vec<2, float> newSize);
+
+
+
+        //-----------
+        //- Getters -
+        //-----------
+
+        inline glm::vec2 GetPosition() { return _pos; }
+        inline glm::vec2 GetSize() { return _size; }
+
+
+        //-----------
+        //- Methods -
+        //-----------
+
+        /*
+        * Mueve el objeto el offset indicado.
+        */
+        void Move(float x, float y);
+
+        /*
+        * Cambia el tamaño la cantidad indicada.
+        */
+        void Resize(float x, float y);
+
+        /*
+        * Devuelve el rect que representa/ocupa el objeto.
+        */
+        SDL_Rect GetTransformRect();
+
+
+    protected:
+        //Almacenamos la posición y el tamaño del objeto. Esto representa un SDL_Rect.
+        glm::vec<2, float> _pos;
+        glm::vec<2, float> _size;
+    };
+
+
+}

UberEngine/src/Logging/Logger.cpp

@@ -5,18 +5,18 @@
 
 namespace UE
 {
-	std::shared_ptr<spdlog::logger> Logger::_engineLogger;
+    std::shared_ptr<spdlog::logger> Logger::_engineLogger;
-	std::shared_ptr<spdlog::logger> Logger::_gameLogger;
+    std::shared_ptr<spdlog::logger> Logger::_gameLogger;
 
-	void Logger::InitLogger()
+    void Logger::InitLogger()
-	{
+    {
-		spdlog::set_pattern("%^[%T]: %l - %n: %v %$");
+        spdlog::set_pattern("%^[%T]: %l - %n: %v %$");
 
-		_engineLogger = spdlog::stdout_color_mt("UberEngine");
+        _engineLogger = spdlog::stdout_color_mt("UberEngine");
-		_engineLogger->set_level(spdlog::level::trace);
+        _engineLogger->set_level(spdlog::level::trace);
 
-		_gameLogger = spdlog::stdout_color_mt("UberGame1");
+        _gameLogger = spdlog::stdout_color_mt("UberGame1");
-		_gameLogger->set_level(spdlog::level::trace);
+        _gameLogger->set_level(spdlog::level::trace);
 
-	}
+    }
 }

UberEngine/src/Logging/Logger.h

@@ -7,35 +7,35 @@
 namespace UE
 {
 
-	class Logger
+    class Logger
-	{
+    {
-	public:	
+    public:
-		static void InitLogger();
+        static void InitLogger();
 
-		inline static std::shared_ptr<spdlog::logger>& GetGameLogger() { return _gameLogger; }
+        inline static std::shared_ptr<spdlog::logger>& GetGameLogger() { return _gameLogger; }
-		inline static std::shared_ptr<spdlog::logger>& GetEngineLogger() { return _engineLogger; }
+        inline static std::shared_ptr<spdlog::logger>& GetEngineLogger() { return _engineLogger; }
 
 
-	private:
+    private:
-		static std::shared_ptr<spdlog::logger> _engineLogger;
+        static std::shared_ptr<spdlog::logger> _engineLogger;
-		static std::shared_ptr<spdlog::logger> _gameLogger;
+        static std::shared_ptr<spdlog::logger> _gameLogger;
 
-	};
+    };
 
 
-//Macros para el Logging. Es m�s c�modo que estar poniendo la l�nea entera cada vez...
+//Macros para el Logging. Es más cómodo que estar poniendo la línea entera cada vez...
-#define UE_LOG_TRACE(...)			::UE::Logger::GetEngineLogger()->trace(__VA_ARGS__)
+#define UE_LOG_TRACE(...)           ::UE::Logger::GetEngineLogger()->trace(__VA_ARGS__)
-#define UE_LOG_DEBUG(...)			::UE::Logger::GetEngineLogger()->debug(__VA_ARGS__)
+#define UE_LOG_DEBUG(...)           ::UE::Logger::GetEngineLogger()->debug(__VA_ARGS__)
-#define UE_LOG_INFO(...)			::UE::Logger::GetEngineLogger()->info(__VA_ARGS__)
+#define UE_LOG_INFO(...)            ::UE::Logger::GetEngineLogger()->info(__VA_ARGS__)
-#define UE_LOG_WARN(...)			::UE::Logger::GetEngineLogger()->warn(__VA_ARGS__)
+#define UE_LOG_WARN(...)            ::UE::Logger::GetEngineLogger()->warn(__VA_ARGS__)
-#define UE_LOG_ERROR(...)			::UE::Logger::GetEngineLogger()->error(__VA_ARGS__)
+#define UE_LOG_ERROR(...)           ::UE::Logger::GetEngineLogger()->error(__VA_ARGS__)
-#define UE_LOG_CRITICAL(...)		::UE::Logger::GetEngineLogger()->critical(__VA_ARGS__)
+#define UE_LOG_CRITICAL(...)        ::UE::Logger::GetEngineLogger()->critical(__VA_ARGS__)
-									
+                                    
-#define GAME_LOG_TRACE(...)			::UE::Logger::GetEngineLogger()->trace(__VA_ARGS__)
+#define GAME_LOG_TRACE(...)         ::UE::Logger::GetEngineLogger()->trace(__VA_ARGS__)
-#define GAME_LOG_DEBUG(...)			::UE::Logger::GetEngineLogger()->debug(__VA_ARGS__)
+#define GAME_LOG_DEBUG(...)         ::UE::Logger::GetEngineLogger()->debug(__VA_ARGS__)
-#define GAME_LOG_INFO(...)			::UE::Logger::GetEngineLogger()->info(__VA_ARGS__)
+#define GAME_LOG_INFO(...)          ::UE::Logger::GetEngineLogger()->info(__VA_ARGS__)
-#define GAME_LOG_WARN(...)			::UE::Logger::GetEngineLogger()->warn(__VA_ARGS__)
+#define GAME_LOG_WARN(...)          ::UE::Logger::GetEngineLogger()->warn(__VA_ARGS__)
-#define GAME_LOG_ERROR(...)			::UE::Logger::GetEngineLogger()->error(__VA_ARGS__)
+#define GAME_LOG_ERROR(...)         ::UE::Logger::GetEngineLogger()->error(__VA_ARGS__)
-#define GAME_LOG_CRITICAL(...)		::UE::Logger::GetEngineLogger()->critical(__VA_ARGS__)
+#define GAME_LOG_CRITICAL(...)      ::UE::Logger::GetEngineLogger()->critical(__VA_ARGS__)
 
 }

UberEngine/src/Render/Camera.cpp

@@ -0,0 +1,46 @@
+#include "Camera.h"
+#include "Logging/Logger.h"
+
+#include <SDL_rect.h>
+
+namespace UE
+{
+    glm::vec2 Camera::WorldToSreenCoords(glm::vec<2, float> worldCoord)
+    {
+        //Convertimos las coordenas de WorldCoords a ScreenCoords relativas a la camPosition.
+        glm::ivec2 fPos = worldCoord - _pos;
+
+        return fPos;
+    }
+
+    glm::vec2 Camera::ScreenToWorldCoords(glm::vec<2, float> screenCoord)
+    {
+        //Convertimos las coordenas de ScreenCoords a WorldCoords relativas a la camPosition.
+        glm::ivec2 fPos = screenCoord + _pos;
+
+        return fPos;
+    }
+
+    SDL_Rect Camera::WorldToScreenRect(SDL_Rect worldRect)
+    {
+        glm::ivec2 worldCoords = glm::ivec2(worldRect.x, worldRect.y);
+        glm::ivec2 screenCoords = WorldToSreenCoords(worldCoords);
+        SDL_Rect screenRect = worldRect;
+        screenRect.x = screenCoords.x;
+        screenRect.y = screenCoords.y;
+
+        return screenRect;
+    }
+
+    SDL_Rect Camera::ScreenToWorldRect(SDL_Rect screenRect)
+    {
+        glm::ivec2 screenCoords = glm::ivec2(screenRect.x, screenRect.y);
+        glm::ivec2 worldCoords = ScreenToWorldCoords(screenCoords);
+        SDL_Rect worldRect = screenRect;
+        worldRect.x = worldCoords.x;
+        worldRect.y = worldCoords.y;
+
+        return worldRect;
+    }
+
+}

UberEngine/src/Render/Camera.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <glm/vec2.hpp>
+
+#include "Interfaces/Transformable.h"
+
+//
+// ToDO:
+//  - La cámara debería tener un tamaño definido.
+//      para hacer zoom y esas cosas.
+//  - Pasará a utilizar transformable para almacenar su posición y su tamaño.
+//
+
+
+namespace UE
+{
+    class Camera : public Transformable
+    {
+    public:
+
+        Camera() {}
+
+        Camera(int posX, int posY)
+        {
+            _pos = { posX, posY };
+            _size = { 100, 100 };
+        }
+
+        Camera(int posX, int posY, int sizeX, int sizeY)
+        {
+            _pos = { posX, posY };
+            _size = { sizeX, sizeY };
+        }
+
+
+        ////////////////////////////////////////////////////////
+
+
+        /* Métodos para transformar y proyectar coordenadas en función de la Camera. */
+        //WorldCoords = ScreenPos + CamPos -> ScreenPos = WorldCoords - CamPos;
+
+        //Proyecta las coordenadas de mundo a coordenadas de pantalla.
+        glm::vec2 WorldToSreenCoords(glm::vec<2, float> worldCoord);
+
+        //Proyecta coordenadas de pantalla al mundo.
+        glm::vec2 ScreenToWorldCoords(glm::vec<2, float> screenCoord);
+
+
+        SDL_Rect WorldToScreenRect(SDL_Rect worldRect);
+        SDL_Rect ScreenToWorldRect(SDL_Rect screenRect);
+
+
+
+    private:
+
+        //glm::ivec2 camSize { 0, 0 };
+
+    };
+}

UberEngine/src/Render/Drawable.h

@@ -1,27 +0,0 @@
-#pragma once
-
-namespace UE
-{
-	class Renderer;
-
-	class Drawable
-	{
-
-	public:
-		Drawable() {}
-		virtual ~Drawable() {};
-
-		//Get-Set del renderLayer.
-		inline void SetLayer(int newLayer) { _renderLayer = newLayer; }
-		inline int GetLayer() { return _renderLayer; }
-
-	public:
-		virtual void Draw(Renderer* renderer) = 0;
-		
-
-	protected:
-		//renderLayer usada en el renderer como "profundidad".
-		int _renderLayer = 0;
-	};
-
-}

UberEngine/src/Render/Renderer.cpp

@@ -3,267 +3,243 @@
 #include <ImGui/imgui.h>
 #include <ImGui/imgui_impl_sdl.h>
 #include <ImGui/imgui_impl_sdlrenderer.h>
-//#include <ImGui\imgui_impl_opengl3.h>
+//#include <ImGui/imgui_impl_opengl3.h>
 
 #include <SDL_opengl.h>
 
 
 #include "Renderer.h"
+#include "Assets/Texture.h"
 #include "Logging/Logger.h"
 
 namespace UE
 {
-	//class Game;
+    int Renderer::InitRenderer()
+    {
+        //Configuramos los par�metros de la ventana de SDL.
+        Uint32 windowFlags = (SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_RESIZABLE);
 
-	int Renderer::InitRenderer()
+        //Creamos la ventana de SDL.
-	{
+        _window = SDL_CreateWindow("UberGame1", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, screenSize.x, screenSize.y, windowFlags);
-		//Iniciamos SDL.
+        if (_window == NULL)
-		SDL_HINT_RENDER_DRIVER "opengl";
+        {
+            UE_LOG_CRITICAL("Renderer - CreateWindow: No se ha podido crear la ventana con OpenGL: {0}", SDL_GetError());
+            return -1;
+        }
 
-		Uint32 SDL_Flags = SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_EVENTS;
+        //Creamos el Renderer de SDL.
-		if (SDL_Init(SDL_Flags) < 0)
+        main_Renderer = SDL_CreateRenderer(_window, -1, SDL_RENDERER_ACCELERATED);
-		{
+        if (main_Renderer == NULL)
-			UE_LOG_CRITICAL("No se ha podido iniciar SDL, sufre mam�n: {0}", SDL_GetError());
+        {
-			return 1;
+            UE_LOG_CRITICAL("Renderer - SDL_Renderer: No se ha podido crear el Renderer de SDL: {0}", SDL_GetError());
-		}
+            return -2;
-
+        }
-		//Configuramos los par�metros de la ventana de SDL.
+        SDL_SetRenderDrawColor(main_Renderer, 0xFF, 0xFF, 0xFF, 0xFF);
-		Uint32 windowFlags = (SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_RESIZABLE);
-
-		//Creamos la ventana de SDL.
-		_window = SDL_CreateWindow("UberGame1", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, screenSize.x, screenSize.y, windowFlags);
-		if (_window == NULL)
-		{
-			UE_LOG_CRITICAL("No se ha podido crear la ventana de SDL con OpenGL y esas mierdas: {0}", SDL_GetError());
-			return 1;
-		}
-
-		//Creamos el Renderer de SDL.
-		main_Renderer = SDL_CreateRenderer(_window, -1, SDL_RENDERER_ACCELERATED);
-		if (main_Renderer == NULL)
-		{
-			UE_LOG_CRITICAL("No se ha podido crear el Renderer de SDL: {0}", SDL_GetError());
-		}
-		SDL_SetRenderDrawColor(main_Renderer, 0xFF, 0xFF, 0xFF, 0xFF);
-
-
-#pragma region ImGui.
-
-		IMGUI_CHECKVERSION();
-		ImGui::CreateContext();
-		ImGuiIO& io = ImGui::GetIO(); 
-		(void)io;  //Evita que de un Warning por variable no usada.
-
-		ImGui::StyleColorsDark();
-
-		ImGui_ImplSDL2_InitForSDLRenderer(_window, main_Renderer);
-		ImGui_ImplSDLRenderer_Init(main_Renderer);
-
-#pragma endregion
-
-
-		//Init layers.
-		for (int i = 0; i < LAYER_AMOUNT; i++)
-		{
-			renderLayers.push_back(std::vector<DrawCall>());
-		}
-	}
-
-	void Renderer::CleanRenderer()
-	{
-		renderQueue.empty();
-
-		ImGui_ImplSDLRenderer_Shutdown();
-		ImGui_ImplSDL2_Shutdown();
-		ImGui::DestroyContext();
-
-		SDL_DestroyRenderer(main_Renderer);
-		SDL_DestroyWindow(_window);
-	}
 
 
 
-	void Renderer::RenderFrame()
+        //Inicializamos Dear ImGui con el SDL_Renderer.
-	{
+        IMGUI_CHECKVERSION();
-		NewFrame();
+        ImGui::CreateContext();
-		RenderData();
+        ImGuiIO& io = ImGui::GetIO(); 
-		EndFrame();
+        (void)io;  //Evita que de un Warning por variable no usada. Este C++ es demasiado avanzado.
-	}
 
+        ImGui::StyleColorsDark();
 
-	void Renderer::NewFrame()
+        ImGui_ImplSDL2_InitForSDLRenderer(_window, main_Renderer);
-	{
+        ImGui_ImplSDLRenderer_Init(main_Renderer);
-		SDL_RenderClear(main_Renderer);
-
-		ImGui_ImplSDLRenderer_NewFrame();
-		ImGui_ImplSDL2_NewFrame();
-		ImGui::NewFrame();
-
-		//Quiz�s deber�amos limpiar la cola y las Layers aqu� para eliminar residuos...
-		//callCounter = 0;
-		//rendererCounter = 0;
-	}
-
-	void Renderer::RenderData()
-	{
-		//Add items to their layer.
-		for (int i = 0; i < renderQueue.size(); i++)
-		{
-			DrawCall item = renderQueue.at(i);
-
-			//Add item i to layer number i.layer.
-			if (item.layer > LAYER_AMOUNT)
-			{
-				UE_LOG_ERROR("Error rendering data: Can't render item to Layer {0} -> out of range\n", item.layer);
-				return;
-			}
-			renderLayers.at(item.layer).push_back(item);
-		
-		}
-		renderQueue.clear();
-
-		//Iterate layers.
-		for (int j = 0; j < renderLayers.size(); j++)
-		{
-			std::vector<DrawCall>& layer = renderLayers.at(j);
-			//Render items from layer j.
-			for (int k = 0; k < layer.size(); k++)
-			{
-				DrawCall item = layer.at(k);
-				if (item.fullTexture)
-				{
-					SDL_RenderCopy(main_Renderer, item.tx, NULL, &item.pos_rect);
-					continue;
-				}
-				SDL_RenderCopy(main_Renderer, item.tx, &item.tx_rect, &item.pos_rect);
-			}
-			layer.clear();
-		}
-	
-	}
-
-
-	void Renderer::EndFrame()
-	{
-		//SDL_UpdateWindowSurface(window);
-		//SDL_RenderPresent(main_Renderer);
-		//SDL_RenderClear(main_Renderer);
-		ImGui::Render();
-		
-		ImGui_ImplSDLRenderer_RenderDrawData(ImGui::GetDrawData());
-
-		SDL_RenderPresent(main_Renderer);
-
-		//UE_LOG_INFO("CallCounter: {0} ; Renderer: {1}", callCounter, rendererCounter);
-	}
 
 
 
+        //Init layers for World Rendering.
+        for (int i = 0; i <= LAYER_AMOUNT; i++)
+        {
+            worldLayers.push_back(std::vector<Drawable*>());
+        }
+
+    }
+
+    void Renderer::CleanRenderer()
+    {
+        //Limpiamos ImGui
+        ImGui_ImplSDLRenderer_Shutdown();
+        ImGui_ImplSDL2_Shutdown();
+        ImGui::DestroyContext();
+
+        //Limpiamos SDL.
+        SDL_DestroyRenderer(main_Renderer);
+        SDL_DestroyWindow(_window);
+    }
 
 
-	void Renderer::SetScreenSize(int newWidth, int newHeight)
+    //NOTA No sé para qué sirve el método RenderFrame(), es privado. ¿Eliminar método?
-	{
+    void Renderer::RenderFrame()
-		screenSize.x = newWidth;
+    {
-		screenSize.y = newHeight;
+        NewFrame();
-		SDL_SetWindowSize(_window, newWidth, newHeight);
+        RenderData();
-		glViewport(0, 0, newWidth, newHeight);
+        EndFrame();
+    }
 
-		UE_LOG_TRACE("Screen size chaged to: {0}x{1}", newWidth, newHeight);
-	}
 
-	void Renderer::SetCamPosition(int posX, int posY)
+    void Renderer::NewFrame()
-	{
+    {
-		camPosition.x = posX;
+        SDL_RenderClear(main_Renderer);
-		camPosition.y = posY;
+
-		//UE_LOG_TRACE("Cam position chaged to: {0}x{1}", posX, posY);
+        ImGui_ImplSDLRenderer_NewFrame();
-	}
+        ImGui_ImplSDL2_NewFrame();
+        ImGui::NewFrame();
+
+
+        //Comprobamos que la cámara sigue existiendo.
+        if (activeCam == nullptr)
+        {
+            //Si no existe la cámara activa, utilizamos la por defecto.
+            ResetCamera();
+        }
+
+        //Actualizamos el rect de la cámara.
+        activeCamRect = activeCam->GetTransformRect();
+        
+    }
+
+    void Renderer::RenderData()
+    {
+
+        //REWORK Probablemente sea más bonito separar en métodos el World Render del UI Render.
+        //Iterate world layers.
+        for (int j = 0; j < worldLayers.size(); j++)
+        {
+            //Extract layer j.
+            std::vector<Drawable*>& layer = worldLayers.at(j);
+
+            //Render items from layer j.
+            for (int k = 0; k < layer.size(); k++)
+            {
+                //Extract Drawable k
+                Drawable* item = layer.at(k);
+                item->Draw(this);
+
+                /*// FIX: Cuando la tx sea nullptr o salte except. -> Log y usar default tx.
+                //  En definitiva, añadir seguridad aquí, se puede usar la tx default.
+                SDL_Texture* tx = item->_tx->GetTexture();
+
+                //Los están en WorldCoords. Convertimos la posición a ScreenCoords.
+                // NOTA: Se deberá transformar todo el Rect en función de la cam, no sólo la pos.
+                glm::ivec2 screenCoords = activeCam->WorldToSreenCoords(item->_pos);
+                SDL_Rect screenRect = { screenCoords.x, screenCoords.y, item->_size.x, item->_size.y };
+
+                //Le pasamos todo al SDL_Renderer.
+                SDL_RenderCopy(main_Renderer, item->_tx->GetTexture(), &(item->_txRect), &screenRect);*/
+
+
+            }
+            layer.clear();
+        }
+
+
+        //Renderizado de ImGui.
+        //TODO: Mover a otro método para cambiar el nombre a RenderDrawables.
+        ImGui::Render();
+        ImGui_ImplSDLRenderer_RenderDrawData(ImGui::GetDrawData());
+    
+    }
+
+    void Renderer::EndFrame()
+    {
+        //SDL_UpdateWindowSurface(window);
+        //SDL_RenderPresent(main_Renderer);
+        //SDL_RenderClear(main_Renderer);
+
+        SDL_RenderPresent(main_Renderer);
+
+        //UE_LOG_INFO("CallCounter: {0} ; Renderer: {1}", callCounter, rendererCounter);
+    }
+
+
+    void Renderer::Render(Drawable& drawable)
+    {
+        int layer = drawable.GetLayer();
+
+        //Check Layer.
+        if (layer > LAYER_AMOUNT)
+        {
+            UE_LOG_ERROR("Can't add DrawCall to Layer {0} -> out of range\n", layer);
+            return;
+        }
+
+        if (!drawable.IsVisible())
+        {
+            return;
+        }
+        // FIX Comprobamos si el objeto es visible.
+        // if(!IsObjectVisible(&drawCall.pos_rect))
+        // {
+        //     //Si no es visible, no lo renderizaríamos.
+        //     return;
+        // }
+        //SDL_Texture* tx = drawable._tx->GetTexture();
+
+        //Add Item to Layer for being rendered.
+        worldLayers.at(layer).push_back(&drawable);
+
+    }
+
+
+    void Renderer::DrawTextureOnWorld(UE::Texture* tx, int txRectID, SDL_Rect worldRect)
+    {
+        //TODO: Añadir seguridad.
+
+        //Si el objeto no es visible, no lo renderizamos.
+        if (!IsObjectVisible(&worldRect))
+        {
+            return;
+        }
+
+
+        //Convertir WorldPos to ScreenPos.
+        // FIX: Usar Floats en vez de ints.
+        SDL_Rect screenRect = activeCam->WorldToScreenRect(worldRect);
+
+        SDL_RenderCopy(main_Renderer, tx->GetTexture(), &tx->GetTextureRect(txRectID), &screenRect);
+    }
+
+
+    void Renderer::DrawTextureOnScreen(UE::Texture* tx, int txRectID, SDL_Rect screenRect)
+    {
+        SDL_RenderCopy(main_Renderer, tx->GetTexture(), &tx->GetTextureRect(txRectID), &screenRect);
+    }
+
+
+    void Renderer::SetScreenSize(int newWidth, int newHeight)
+    {
+        screenSize.x = newWidth;
+        screenSize.y = newHeight;
+        SDL_SetWindowSize(_window, newWidth, newHeight);
+        glViewport(0, 0, newWidth, newHeight);
+
+        defaultCam.SetSize(newWidth, newHeight);
+
+        UE_LOG_TRACE("Screen size chaged to: {0}x{1}", newWidth, newHeight);
+    }
+
+    void Renderer::SetDrawingColor(SDL_Color& newColor)
+    {
+        SDL_SetRenderDrawColor(main_Renderer, newColor.r, newColor.g, newColor.b, newColor.a);
+    }
+
+
+    bool Renderer::IsObjectVisible(SDL_Rect* objectRect)
+    {
+        return SDL_HasIntersection(objectRect, &activeCamRect);
+    }
 
 
 
-	glm::ivec2 Renderer::WorldToSreenCoords(glm::ivec2 worldCoord)
+    //�Deber�amos operar la posici�n para que tenga en cuenta la c�mara?
-	{
+    void Renderer::DrawObject(SDL_Rect* position, SDL_Rect* texture_pos, SDL_Texture* texture)
-		//Convertimos las coordenas de WorldCoords a ScreenCoords relativas a la camPosition.
+    {
-		glm::ivec2 fPos = worldCoord - camPosition;
+        SDL_RenderCopy(main_Renderer, texture, texture_pos, position);
-
+    }
-		return fPos;
-	}
-
-	glm::ivec2 Renderer::ScreenToWorldCoords(glm::ivec2 screenCoord)
-	{
-		//Convertimos las coordenas de ScreenCoords a WorldCoords relativas a la camPosition.
-		glm::ivec2 fPos = screenCoord + camPosition;
-
-		return fPos;
-	}
-
-	//CREO QUE ESTE M�TODO NO FUNCIONA.
-	//LAS COORDS QUE USAMOS EN LA COMPROBACI�N NO SON LAS ADECUADAS.
-	bool Renderer::IsObjectVisible(SDL_Rect* objectRect)
-	{
-
-		//Generamos un rect que representa la pantalla.
-		SDL_Rect screen{ camPosition.x, camPosition.y, screenSize.x, screenSize.y };
-		//Comprobamos si hay intersecci�n entre ambos.
-		if (!SDL_HasIntersection(&screen, objectRect))
-		{
-			//UE_LOG_TRACE("Se omite el renderizado de un objeto al estar fuera de la c�mara.");
-			return false;
-		}
-		return true;
-	}
-
-
-
-	//�Deber�amos operar la posici�n para que tenga en cuenta la c�mara?
-	void Renderer::DrawObject(SDL_Rect* position, SDL_Rect* texture_pos, SDL_Texture* texture)
-	{
-		SDL_RenderCopy(main_Renderer, texture, texture_pos, position);
-	}
-
-
-
-	void Renderer::QueueDrawCall(DrawCall drawCall)
-	{
-		//callCounter++;
-		//Add item i to layer number i.layer.
-		if (drawCall.layer > LAYER_AMOUNT)
-		{
-			UE_LOG_ERROR("Can't add DrawCall to Layer {0} -> out of range\n", drawCall.layer);
-			return;
-		}
-		//Comprobamos si el objeto es visible.
-		// 
-		//Generamos un rect que representa la pantalla.
-		SDL_Rect screen{ 0, 0, screenSize.x, screenSize.y };
-		//Comprobamos si hay intersecci�n entre ambos.
-		if (!SDL_HasIntersection(&screen, &drawCall.pos_rect))
-		{
-			//UE_LOG_TRACE("Se omite el renderizado de un objeto al estar fuera de la c�mara.");
-			return;
-		}
-
-		renderLayers.at(drawCall.layer).push_back(drawCall);
-		//rendererCounter++;
-		//renderQueue.push_back(drawCall);
-	}
-
-	void Renderer::QueueDrawCall(int layer, SDL_Rect& position, SDL_Texture* texture, SDL_Rect& texture_position)
-	{
-		DrawCall dc = DrawCall(layer, position, texture, texture_position);
-		QueueDrawCall(dc);
-	}
-
-	void Renderer::QueueDrawCall(int layer, SDL_Rect & position, SDL_Texture* texture)
-	{
-		//std::cout << "Drawable added to queue";
-		DrawCall dc = DrawCall(layer, position, texture);
-		QueueDrawCall(dc);
-	}
-
-	void Renderer::Render(Drawable& drawable)
-	{
-		drawable.Draw(this);
-	}
 
 
 }

UberEngine/src/Render/Renderer.h

@@ -7,11 +7,11 @@
 #include <SDL.h>
 #include <glm/vec2.hpp>
 
-#include "Drawable.h"
+#include "Drawables/Drawable.h"
+#include "Camera.h"
 
 //
-// TODO:
+// TODO Renderer:
-//  - Optimizar RenderDraw moviendo la ordenaci�n por capas a Queue, quitando renderQueue.
 //  - Limpiar las funciones moviendo c�digo a otras funciones.
 //  - �Podr�a moverse todo a static? De esta forma, ya no har�an falta instancias.
 //
@@ -19,155 +19,196 @@
 
 namespace UE
 {
-	struct DrawCall;
+    class Renderer
+    {
+
+    public:
+        /* Constructor */
+        Renderer(int windowWidth, 
+                 int windowHeight, 
+                 int renderingLayers = 10)
+
+            : LAYER_AMOUNT(renderingLayers)
+        {
+            screenSize.x = windowWidth;
+            screenSize.y = windowHeight;
+            activeCam = &defaultCam;
+            //UE_LOG_INFO("Game Renderer Created.");
+        }
 
 
-	class Renderer
+        ////////////////////////////////////////////////////////
-	{
-
-	public:
-		/* Constructor */
-		Renderer(int windowWidth, 
-				 int windowHeight, 
-				 int renderingLayers = 10)
-
-			: LAYER_AMOUNT(renderingLayers)
-		{
-			screenSize.x = windowWidth;
-			screenSize.y = windowHeight;
-			//UE_LOG_INFO("Game Renderer Created.");
-		}
 
 
-		/* Inicializa los componentes necesarios: 
+        /* Inicializa los componentes necesarios: 
-			- Inicializa SDL
+            - Crea la ventana.
-			- Crea la ventana.
+            - Crea el renderer.
-			- Crea el renderer.
+            - Inicia ImGUI.
-			- ...
+            - Genera las layers.
-		*/
+        */
-		int InitRenderer();
+        int InitRenderer();
 
-		/* Limpia todo antes de salir. */
+        /* Limpia todo antes de salir. 
-		void CleanRenderer();
+        *   - Apaga ImGui.
+        *   - Destruye el renderer.
+        *   - Destruye la ventana.
+        */
+        void CleanRenderer();
+
+
+        ////////////////////////////////////////////////////////
+
+
+        /*
+        * Hace el SDL_RenderClear() para limpiar el buffer al principio de un nuevo frame.
+        */
+        void NewFrame();
+
+        /*
+        * Realiza el renderizado de los objetos.
+        *   - Renderiza las layers.
+        *   - Renderiza la UI.
+        *   - Renderiza ImGui.
+        */
+        void RenderData();
+
+
+        /*
+        * Hace el swap del render buffer (tras dibujar todos los objetos). 
+        * Termina el renderizado.
+        */
+        void EndFrame();
+
+
+        ////////////////////////////////////////////////////////
+
+
+        /*
+        * Rendiriza el Objeto indicado.
+        * El proceso consta de dos partes:
+        *   - 1º: El objeto hará las modificaciones necesarias a sus datos.
+        *   - 2º: El Renderer extraerá los datos de Drawable y lo renderizará.
+        */
+        void Render(Drawable& drawable);
+
+
+        /*
+        * Renderizar una textura dado su rect en WorldCoords.
+        * Se ha de utilizar en las implementaciones del método Draw de la clase Drawable.
+        */
+        void DrawTextureOnWorld(UE::Texture* tx, int txRectID, SDL_Rect worldRect);
+
+
+        void DrawTextureOnScreen(UE::Texture* tx, int txRectID, SDL_Rect screenRect);
+
+
+        ///////////////////////////////////////////////////////
+
+
+        /* Get SDL Renderer. */
+        inline SDL_Renderer* GetSDLRenderer() { return main_Renderer; }
 
 
 
+        /*
+        * Get windows/screen size.
+        */
+        inline glm::ivec2 GetScreenSize() { return screenSize; }
 
-		//Hace el SDL_RenderClear() para limpiar el buffer al principio de un nuevo frame.
+        /*
-		void NewFrame();
+        * Permite cambiar el tamaño de la ventana.
+        * REWORK: Hay que mirar los métodos de SDL y aprender cómo funcionan las ventanas.
+        *   Quizás, incluso, abstraer la ventana a su propia clase para facilitar Fullscreen y esas cosas.
+        */
+        void SetScreenSize(int newWidth, int newHeight);
 
-		//Ordena por layer todos los objetos de la renderQueue y los dibuja en orden.
+        
-		//Se puede mover el proceso de ordenado a otra funci�n, con el objeto de ir vaciando la Queue.
+
-		void RenderData();
+        /*
+        * Cambiar el color del fondo.
+        */
+        void SetDrawingColor(SDL_Color& newColor);
 
 
-		//Hace el swap del render buffer (tras dibujar todos los objetos). Termina el renderizado.
+
-		void EndFrame();
+        /*
+        * Set the active cámera.
+        */
+        inline void SetCamera(Camera* newCam) { activeCam = newCam; }
+
+        /*
+        * Get a ptr to the active camera.
+        */
+        inline Camera* GetCamera() { return activeCam; }
 
 
-		//A�ade un DrawCall al renderQueue.
+        /*
-		void QueueDrawCall(DrawCall drawCall);
+        * Cambia la cámara activa a la cámara por defecto.
-		void QueueDrawCall(int layer, SDL_Rect& position, SDL_Texture* texture, SDL_Rect& texture_position);
+        * Utilizado el eliminar una cámara o cuando la activeCam ya no existe.
-		void QueueDrawCall(int layer, SDL_Rect & position, SDL_Texture* texture);
+        */
-
+        inline void ResetCamera() { activeCam = &defaultCam; }
-		//Le pasamos este renderer al Drawable para que haga lo que quiera.
-		//Como si quiere usar el SDL_Renderer, es libre.
-		void Render(Drawable& drawable);
-
-		/* Get SDL Renderer. */
-		SDL_Renderer* GetSDLRenderer() { return main_Renderer; }
-
-		inline glm::ivec2 GetScreenSize() { return screenSize; }
-		void SetScreenSize(int newWidth, int newHeight);
-
-		inline glm::ivec2 GetCamPosition() { return camPosition; }
-		void SetCamPosition(int posX, int posY);
-
-		/* M�todos para transformar las coordenadas entre Screen y Wolrd. */
-		//WorldCoords = ScreenPos + CamPos -> ScreenPos = WorldCoords - CamPos;
-		//Convierte coordenadas de mundo a la pantalla (en funci�n de la c�mara).
-		glm::ivec2 WorldToSreenCoords(glm::ivec2 worldCoord);
-		//Convierte coordenadas de la pantalla al mundo.
-		glm::ivec2 ScreenToWorldCoords(glm::ivec2 screenCoord);
-
-		//Comprueba si un objeto est� dentro del rect�ngulo de la c�mara.
-		//Usada para saber si un objeto se deber�a de renderizar o no.
-		bool IsObjectVisible(SDL_Rect* objectRect);
 
 
-		//DEBUG
+        ////////////////////////////////////////////////////////
-		//Funci�n para renderizar un objeto un objeto en concreto directamente en el SDL_Renderer.
-		void DrawObject(SDL_Rect* position, SDL_Rect* texture_pos, SDL_Texture* texture);
 
 
-	private:
+        /*
-		//Realizar RenderClear(), RenderDraw() y RenderUpdate();
+        * Check if an object is currently visible on Screen.
-		//Es decir, todo lo necesario para renderizar un frame.
+        */
-		void RenderFrame();
+        bool IsObjectVisible(SDL_Rect* objectRect);
 
 
-	private:
+        ////////////////////////////////////////////////////////
-		/* Objetos de SDL para el rendering. */
-		SDL_Window* _window = nullptr;
-		SDL_Surface* screenSurface = nullptr;
-		SDL_Renderer* main_Renderer = nullptr;
-
-		//SDL_GLContext _glContext = nullptr;
-
-		//Almacena todas las "draw calls" para luego ordenar los objetos por layers y dibujarlos.
-		//Se podr�a sustituir por un std::queue o std::deque si fuera necesario.
-		std::vector<DrawCall> renderQueue;
-		
-		//Las capas en las que se organizan los diferentes objetos.
-		//Permite dibujar unos sprites sobre otros.
-		const int LAYER_AMOUNT = 10;
-		std::vector<std::vector<DrawCall>> renderLayers;
 
 
-		//int screenWidth = 640;
+        //DEBUG
-		//int screenHeight = 480;
+        //Funci�n para renderizar un objeto un objeto en concreto directamente en el SDL_Renderer.
-
+        void DrawObject(SDL_Rect* position, SDL_Rect* texture_pos, SDL_Texture* texture);
-		glm::ivec2 screenSize{ 640,480 };
-		glm::ivec2 camPosition{ 0,0 };
 
 
-		//DEBUG
+    private:
-		int callCounter = 0;
+        //Realizar RenderClear(), RenderDraw() y RenderUpdate();
-		int rendererCounter = 0;
+        //Es decir, todo lo necesario para renderizar un frame.
+        //NOTA RenderFrame() es privado, por lo que no puede ser usado. En el renderer, tampoco se usa.
+        void RenderFrame();
 
-	};
 
-	/* 
+    private:
-		Contiene los valores necesarios para realizar el renderizado con SDL_RenderCopy();
+        /* Objetos de SDL para el rendering. */
-		Se almacena en la renderQueue y luego son ordenados por las renderLayers.
-	*/
-	struct DrawCall
-	{
-		DrawCall(int layer, 
-			SDL_Rect position, 
-			SDL_Texture* texture, 
-			SDL_Rect texture_position)
 
-			: layer(layer), tx(texture), tx_rect(texture_position), pos_rect(position)
+        SDL_Window* _window = nullptr;
-		{}
+        SDL_Surface* screenSurface = nullptr;
+        SDL_Renderer* main_Renderer = nullptr;
 
-		DrawCall(int layer,
-			SDL_Rect position,
-			SDL_Texture* texture)
-			: layer(layer), tx(texture), pos_rect(position)
-		{
-			tx_rect = SDL_Rect();
-			fullTexture = true;
-		}
 
-		int layer;
+        ////////////////////////////////////////////////////////
 
-		bool fullTexture = false;
+        
+        //Las capas en las que se organizan los diferentes objetos.
+        //Permite dibujar unos sprites sobre otros.
+        const int LAYER_AMOUNT = 10;
+        std::vector<std::vector<Drawable*>> worldLayers;
 
-		SDL_Texture* tx;
-		SDL_Rect tx_rect;
 
-		SDL_Rect pos_rect;
+        ////////////////////////////////////////////////////////
-	};
+
+
+        glm::ivec2 screenSize{ 640,480 };
+
+        
+        ////////////////////////////////////////////////////////
+
+
+        //glm::ivec2 camPosition{ 0,0 };
+        Camera* activeCam;
+        Camera defaultCam = Camera(0, 0, screenSize.x, screenSize.y);
+        SDL_Rect activeCamRect{ 0, 0, screenSize.x, screenSize.y };
+
+
+        //DEBUG
+        int callCounter = 0;
+        int rendererCounter = 0;
+
+    };
 
 }

UberEngine/src/Render/Transformable.h

@@ -1,47 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include <glm/vec2.hpp>
-
-namespace UE
-{
-	/*
-		Clase que contiene lo necesario para crear un objeto con posici�n en el espacio y modificarlo.
-	*/
-	class Transformable
-	{
-	public:
-
-
-		//-----------
-		//- Setters -
-		//-----------
-
-
-		//Modifica la posici�n del Objeto.
-		inline void SetPosition(float x, float y) { _pos = glm::vec<2, float>(x, y); }
-		inline void SetPosition(glm::vec<2, float> newPosition) { _pos = newPosition; }
-
-		//Modifica la escala de Objeto.
-		inline void SetSize(float x, float y) { _size = glm::vec<2, float>(x, y); }
-		inline void SetSize(glm::vec<2, float> newSize) { _size = newSize; }
-
-		//-----------
-		//- Getters -
-		//-----------
-
-		inline glm::vec2 GetPosition() { return _pos; }
-		inline glm::vec2 GetSize() { return _size; }
-
-
-
-	protected:
-		//Se almacena la posici�n y el tama�o del objeto. Con esto se puede crear un SDL_Rect.
-		glm::vec<2, float> _pos;
-		glm::vec<2, float> _size;
-	};
-
-
-}

UberEngine/src/Scene/Scene.cpp

@@ -1,23 +1,25 @@
 #include "Scene.h"
 
+#include "Logging/Logger.h"
+
 #include <iostream>
 
 namespace UE
 {
 
-	void Scene::SceneInit()
+    void Scene::SceneInit()
-	{
+    {
-		//id = currentID++;
+        UE_LOG_TRACE("Scene {0} has been init!", _sceneName);
-		std::cout << "Scene has been init!" << std::endl;
+    }
-	}
 
-	void Scene::SceneClean()
+    void Scene::SceneClean()
-	{
+    {
-		std::cout << "Scene has been cleaned!" << std::endl;
+        UE_LOG_TRACE("Scene {0} has been Cleaned!", _sceneName);
-		if (loaded)
+
-		{
+        if (loaded)
-			SceneUnload();
+        {
-		}
+            SceneUnload();
-	}
+        }
+    }
 
 }

UberEngine/src/Scene/Scene.h

@@ -3,59 +3,87 @@
 #include <string>
 #include <iostream>
 
-///
+
-///	TODO:
-///  - Scene debería ser serializable y cargable desde archivos, al menos para las clases derivadas. ( o quizás no....)
-/// 
-/// 
 union SDL_Event;
 
 namespace UE
 {
 
-	/* 
+    /* 
-		Estructura básica de una escena. Almacena los datos mínimos.
+        Estructura básica de una escena.
-		Se utilizará como clase base para las clases Scene específicas.
+        Se utiliza como clase base para las clases Scene específicas del Game.
-		Esta clase será heredada por las escenas del usuario.
+        Esta clase será heredada por las escenas del usuario.
-	*/ 
+    */ 
-	class Scene
+    class Scene
-	{
+    {
-	public:
+    public:
 
-		Scene(std::string name) 
+        Scene(std::string name)
-			: _sceneName(name)
+            : _sceneName(name)
-		{}
+        {
+            SceneInit();
+        }
 
-		/* Funciones "internas" de la clase para inicialización y cierre. */
+        ~Scene()
-		void SceneInit();		//Te calienta y prepara la casa al llegar.
+        {
-		void SceneClean();		//Te deja todo limpio y reluciente al salir.
+            SceneClean();
+        }
 
 
-		/* Funciones que habrán de sobrecargar las escenas del usuario. */
+        /* Funciones "internas" de la clase para inicialización y cierre. */
-		virtual void SceneLoad() { std::cout << "EMPTY SCENE CREATED" << std::endl; }
+        void SceneInit();		//Te calienta y prepara la casa al llegar.
-		virtual void SceneRender() {}
+        void SceneClean();		//Te deja todo limpio y reluciente al salir.
-		virtual void SceneUpdate() {}
-		virtual void SceneHandleEvents(SDL_Event* event) {}
-		virtual void SceneUnload() { std::cout << "EMPTY SCENE DESCARGADA" << std::endl; }
 
-		// ¿Esto sirve para algo?
+        /* 
-		//void loadDataFromFile(std::string path);
+        Métodos de los estados de la escena.
+        Habrán de ser sobrecargardos por las escenas del usuario. 
+        */
+
+        //Se crean todos los objetos y se carga todo lo necesario para la escena.
+        virtual void SceneLoad() = 0;
+
+        /* 
+         * Render de los objetos de la escena.
+         * Se ejecuta en cada frame.
+         */
+        virtual void SceneRender() = 0;
+
+        /* 
+         * Update para los objetos de la escena.
+         * Utilizado para las físicas y otros componentes similares.
+         * Se ejecuta en cada frame.
+         */
+        virtual void SceneUpdate() = 0;
+
+        /*
+         * Gestor de eventos para la escena.
+         * Utilizado para capturar los eventos que necesita la escena.
+         */
+        virtual void SceneHandleEvents(SDL_Event* event) = 0;
+
+        /*
+         * Descarga y limpia todos los elementos de la escena.
+         * Utilizado también para guardado o lo que sea conveniente.
+         */
+        virtual void SceneUnload() = 0;
+
+        //Obtener el nombre de la escena.
+        inline std::string GetName() { return _sceneName; }
+
+        /*
+         * Permite comprobar si la escena está cargada o no.
+         * TODO: Útil si queremos hacer carga asincrona o similar. Al menos para assets o algo.
+         */
+        inline bool IsLoaded() { return loaded; }
 
 
-		inline std::string GetName() { return _sceneName; }
+    protected:
 
-		inline bool IsLoaded() { return loaded; }
+        //Nombre de la escena. Para identificarla en el SceneManager.
+        std::string _sceneName = "NullScene";
 
+        bool loaded = false;
 
-	protected:
+    };
-		//Almacena el ID actual, permitiendo generar un ID nuevo para cada Scene que se instancie.
-		//static uint16_t currentID;
-
-		std::string _sceneName;
-		//std::vector<Entity> _entidades;
-
-		bool loaded = false;
-
-	};
 
 }

UberEngine/src/Scene/SceneBuilder.h

@@ -1,18 +0,0 @@
-#pragma once
-
-namespace UE
-{
-	class Scene;
-
-	/*
-		Será sobrecargado por el juego, de tal forma que cuando se le pida crear una escena, sepa qué objeto crear.
-	*/
-	class SceneBuilder
-	{
-	public:
-		virtual inline Scene* InstanciateScene(int sceneID) { return nullptr; }
-
-	};
-
-
-}

UberEngine/src/Scene/SceneManager.cpp

@@ -1,8 +1,5 @@
 #include "SceneManager.h"
 
-#include "Scene.h"
-#include "SceneBuilder.h"
-
 #include "Logging/Logger.h"
 
 #include <iostream>
@@ -10,91 +7,136 @@
 namespace UE
 {
 
-	void SceneManager::InitSceneManager(SceneBuilder* sceneBuilder)
+    void SceneManager::InitSceneManager()
-	{
+    {
-		_sceneBuilder = sceneBuilder;
+        UE_LOG_INFO("Se ha inicializado el SceneManager.");
+    }
 
-		UE_LOG_INFO("Se ha inicializado el SceneManager.");
+    void SceneManager::CleanSceneManager()
-	}
+    {
+        for (auto& it : _loadedScenes)
+        {
+            Scene* sc = it.second;
+            sc->SceneClean();
+            delete sc;
+        }
 
-	void SceneManager::CleanSceneManager()
+        _loadedScenes.clear();
-	{
-		if (_currentScene != nullptr)
-		{
-			_currentScene->SceneUnload();
-			delete _currentScene;
-		}
 
-		//for (auto& it : _scenes)
+        if (_currentScene != nullptr)
-		//{
+        {
-		//	Scene* sc = it.second;
+            _currentScene = nullptr;
-		//	sc->SceneClean();
+        }
-		//	delete sc;
-		//}
 
-		//_scenes.clear();
+        UE_LOG_INFO("El ScenenManager se ha descargado correctamente.");
+    }
+
+    void SceneManager::LoadScene(Scene* sceneToLoad)
+    {
+        std::string name = sceneToLoad->GetName();
+        //Comprobamos si la escena ya está cargada en la lista.
+        if(IsSceneLoaded(name))
+        {
+            //Si lo está, la descargamos para volverla a cargar.
+            //En caso de no estar activa, claro está.
+            UnloadScene(name);
+        }
+        //Cargamos la escena en cuestión.
+        sceneToLoad->SceneLoad();
+
+        //Añadimos la escena a la lista de escenas cargadas.
+        _loadedScenes.insert(std::make_pair(name, sceneToLoad));
+
+    }
+
+    void SceneManager::LoadAndSwitchScene(Scene* sceneToLoad)
+    {
+        LoadScene(sceneToLoad);
+        SwitchScene(sceneToLoad->GetName());
+    }
+
+    void SceneManager::SwitchScene(std::string name)
+    {
+        //Comprobamos si existe la escena indicada.
+        if(!IsSceneLoaded(name))
+        {
+            UE_LOG_WARN("SceneManager: Scene {0}, No se puede cambiar de escena. No está cargada.", name);
+            return;
+        }
+
+        //Cambiamos la escena actual por la indicada.
+        _currentScene = _loadedScenes.at(name);
+    }
+
+    void SceneManager::SwitchAndUnloadScene(std::string name)
+    {
+        //Comprobamos si existe la escena indicada.
+        if(!IsSceneLoaded(name))
+        {
+            UE_LOG_WARN("SceneManager: Scene {0}, No se puede cambiar de escena. No está cargada.", name);
+            return;
+        }
+
+        //Descargamos la escena anterior en caso de haberla.
+        if(_currentScene != nullptr && IsSceneLoaded(_currentScene->GetName()))
+        {
+            _currentScene->SceneUnload();
+        }
+
+        //Cambiamos la escena activa por la nueva.
+        _currentScene = _loadedScenes.at(name);
+    }
+    
+
+    void SceneManager::UnloadScene(std::string name)
+    {
+        //Comprobamos si existe la escena indicada.
+        if(!IsSceneLoaded(name))
+        {
+            UE_LOG_WARN("SceneManager: Scene {0}, no se puede descargar. No está cargada.", name);
+            return;
+        }
+        //Comprobamos si se trata de la escena actual.
+        if(GetCurrentSceneName() == name)
+        {
+            //No hacemos nada, no se puede recargar la escena actual así como así.
+            UE_LOG_WARN("SceneManager: Scene {0}, no se puede descargar. Es la escena actual.", name);
+            return;
+        }
+
+        //Si todo está correcto.
+        //Si tenemos campo libre, pista libre, punto rojo.
+        //Descargamos.
+        _loadedScenes.at(name)->SceneUnload();
+        _loadedScenes.erase(name);
+    }
 
 
-	}
+    bool SceneManager::IsSceneLoaded(std::string name)
+    {
+        //Comprobamos si existe la escena indicada.
+        if(_loadedScenes.find(name) != _loadedScenes.end())
+        {
+            //Si la encontramos, existe.
+            return true;
+        }
+        return false;
+    }
 
 
+    std::string SceneManager::GetCurrentSceneName()
+    {
+        return _currentScene->GetName();
+    }
 
-	//void SceneManager::AddScene(Scene* sceneToAdd)
+    Scene* SceneManager::GetCurrentScenePtr() 
-	//{
+    { 
-	//	_scenes.insert(std::make_pair(sceneToAdd->GetName(), sceneToAdd));
+        return _currentScene;
-	//	sceneToAdd->SceneInit();
+    }
 
-	//	UE_LOG_INFO("Se ha a�adido la escena {0} al SceneManager.", sceneToAdd->GetName());
+    void SceneManager::UpdateScene()
-	//}
+    {
-
+        _currentScene->SceneUpdate();
-
+    }
-
-	//Scene* SceneManager::GetScenePtr(std::string sceneName)
-	//{
-	//	if (_scenes.find(sceneName) == _scenes.end())
-	//	{
-	//		UE_LOG_ERROR("No se ha encontrado la escena indicada.");
-	//		return nullptr;
-	//	}
-	//	return _scenes.at(sceneName);
-	//}
-
-
-
-	std::string SceneManager::GetActiveSceneName()
-	{
-		return _currentScene->GetName();
-	}
-
-	//void SceneManager::LoadScene(std::string sceneName)
-	//{
-	//	if (_currentScene != nullptr)
-	//	{
-	//		_currentScene->SceneUnload();
-	//		delete _currentScene;
-	//	}
-
-	//	_currentScene = _scenes.at(sceneName);
-
-	//	_currentScene->SceneLoad();
-	//}
-
-	void SceneManager::NewLoadScene(int sceneID)
-	{
-		if (_currentScene != nullptr)
-		{
-			_currentScene->SceneUnload();
-			delete _currentScene;
-		}
-
-		_currentScene = _sceneBuilder->InstanciateScene(sceneID);
-
-		_currentScene->SceneLoad();
-	}
-
-	void SceneManager::UpdateScene()
-	{
-		_currentScene->SceneUpdate();
-	}
 
 }

UberEngine/src/Scene/SceneManager.h

@@ -1,72 +1,116 @@
 #pragma once
+
+#include "Scene/Scene.h"
+
 #include <string>
 #include <vector>
 #include <unordered_map>
 
-// 
+//
-// Habría que implemetar un sistema para cambiar de escena.
+// TODO:
-// La cuestión sería almecenar el ID actual o algo así.
+// - Se podría plantear un sistema de carga asincrona para las escenas.
-// Las escenas que no están cargadas se pueden mantener construidas en el vector, pues el espacio que ocupan en memoria debería ser mínimo.
+// - Añadir un método para recargar la escena actual. La descarga entera y la vuelve a cargar.
-// Cuando cargas una escena, se descarga la anterior mediante Scene.unload y se carga la nueva con Scene.Load. De esta forma,
+// - La variable "loaded" de las escenas no tiene mucha utilidad en este momento.
-//		si cada escena gestiona bien sus recursos en la carga y descarga, no debería generar ningún problema y no ocupar espacio cuando esté descargada.
-//		Quizás se puede añadir una opción para mantener cargada una escena o algo.
-// 
-// Quizás es innecesaria la ID interna de la escena....
-// 
 
 
+// ERROR SceneLoader: No se hace bien la carga y descarga de escenas. No parece estar limpiándose la memoria.
+//  Parece que no funciona lo de no recargar la escena en la que estás.
+
 namespace UE
 {
-	class Scene;
-	class SceneBuilder;
 
-	/* Gestiona todas escenas. Las carga, descargar y ejecuta. */
+    /* Gestiona todas escenas. Las carga, descargar y ejecuta. */
-	class SceneManager
+    class SceneManager
-	{
+    {
 
-	public:
+    public:
-		/* Constructor */
-		SceneManager() {}
 
-		void InitSceneManager(SceneBuilder* sceneBuilder);
+        /* Constructor */
-		void CleanSceneManager();
+        SceneManager() 
+        {
+            InitSceneManager();
+        }
 
-		//Añade una escena a la lista y retorna su ID. Son Ptrs, por lo que poco importa donde los almacenamos.
+        ~SceneManager()
-		//void AddScene(Scene* sceneToAdd);
+        {
+            CleanSceneManager();
+        }
+        
+        
+        //Inicializa el ScenenManager (En caso de haber algo que iniciar.)
+        void InitSceneManager();
+        //Limpia los contenedores de Scenes y descarga las escenas cargadas.
+        void CleanSceneManager();
 
-		//Devuelve un ptr a la escena del ID especificado.
+        /*
-		//Scene* GetScenePtr(std::string sceneName);
+         * Carga una nueva escena.
-		std::string GetActiveSceneName();
+         * Se almacena en la lista de escenas cargadas.
+         * Para cambiar de escena, usar SwitchScene();
+         * Si la escena ya estuvise cargada, se descargará la anterior y se cargará la nueva, siempre que no sea la activa.
+         */
+        void LoadScene(Scene* sceneToLoad);
 
-		//Devuelve la escena activa.
+        /*
-		inline Scene* GetActiveScenePtr() { return _currentScene; }
+         * Cambia la escena activa por la indicada.
+         * Si la indicada no está cargada, no hace nada.
+         */
+        void SwitchScene(std::string name);
 
-		//Descarga la escena activa y carga la escena indicada.
+        /*
-		//void LoadScene(std::string sceneName);
+         * Carga la escena indicada.
+         * Cambia la escena actual por la nueva escena.
+         */
+        void LoadAndSwitchScene(Scene* sceneToLoad);
 
-		//Descarga la escena activa y carga la escena indicada. Para ello llama al builder que tiene y este le devuelve un ptr a la nueva escena.
+        /*
-		void NewLoadScene(int sceneID);
+         * Cambia la escena activa por la indicada.
-
+         * Descarga completamente la escena activa anterior.
-		//Pasa el Update a la escena actual.
+         * Si la escena indicada no está cargarda, no hace nada.
-		//¿Necesita hacer algo más?
+         * Si no hay una escena activa, no la descarga.
-		void UpdateScene();
+         */
-
+        void SwitchAndUnloadScene(std::string name);
-		// ¿Esto sirve para algo?
-		//void LoadSceneDataFromFile(std::string filePath);
 
 
-	private:
+        /*
-		Scene* _currentScene = nullptr;
+         * Descarga la escena con el nombre indicado.
+         * Si la escena no está en la lista, no hace nada.
+         */
+        void UnloadScene(std::string name);
 
-		SceneBuilder* _sceneBuilder = nullptr;
+        /*
-
+         * Comprueba si la escena indicada está en la lista de escenas cargadas.
-		//Almacenamos un ptr a las diferentes escenas disponibles. 
+         * Retorna true si está cargada, false si no.
-		//Otra opción es trabajar con Templates para instanciar la clase pretinente sin necesidad de almacenar nada.
+         */
-		//De cualquier forma, son ptr en el Stack y deberían de eliminar todo al hacer scene.Unload().
+        bool IsSceneLoaded(std::string name);
-		//std::unordered_map<std::string, Scene*> _scenes;
-		//std::vector<Scene*> _scenes;
 
 
-	};
+        /*
+         * Devuelve el nombre de la escena activa.
+         */
+        std::string GetCurrentSceneName();
+
+        /*
+         * Devuelve el ptr de la escena activa.
+         */
+        Scene* GetCurrentScenePtr();
+
+        /*
+         * Update para la escena activa.
+         * Se ha de llamar en cada frame para pasar el update a la escena activa.
+         * TODO: No se usa... O añadimos para las otras fases o quitamos esta.
+         */
+        void UpdateScene();
+
+
+
+    private:
+        //Ptr a la escena que está activa en ese momento.
+        Scene* _currentScene = nullptr;
+
+        //Almacenamos un ptr a todas las escenas cargadas en ese momento.
+        //o, al menos, lo intentamos.
+        std::unordered_map<std::string, Scene*> _loadedScenes;
+
+    };
 
 }

UberEngine/src/Time/Time.cpp

@@ -8,36 +8,36 @@ uint32_t UE::Time::_startTime;
 
 void UE::Time::StartFrame()
 {
-	_startTime = SDL_GetTicks();
+    _startTime = SDL_GetTicks();
 }
 
 void UE::Time::EndFrame()
 {
-	// Calculamos el tiempo que llevamos de Frame, para que si nos quedamos cortos, esperemos.
+    // Calculamos el tiempo que llevamos de Frame, para que si nos quedamos cortos, esperemos.
-	
+    
-	//FrameTime es el tiempo que ha tardado el frame (el deltaTime) en MS.
+    //FrameTime es el tiempo que ha tardado el frame (el deltaTime) en MS.
-	uint32_t frameTime = SDL_GetTicks() - _startTime;
+    uint32_t frameTime = SDL_GetTicks() - _startTime;
 
 
-	//Frames totales / segundos totales.
+    //Frames totales / segundos totales.
-	//_avgFPS = countedFrames / (SDL_GetTicks() / 1000.f);
+    //_avgFPS = countedFrames / (SDL_GetTicks() / 1000.f);
-	//std::cout << "FPS: " << avgFPS << " / " << "dT: " << deltaTime << std::endl;
+    //std::cout << "FPS: " << avgFPS << " / " << "dT: " << deltaTime << std::endl;
 
-	//Limitamos los FPS haciendo esperar al programa el tiempo extra que quede. 
+    //Limitamos los FPS haciendo esperar al programa el tiempo extra que quede. 
-	//En vez de sólo esperar, se podrían hacer tareas como cargar Assets o realizar cálculos pesados.
+    //En vez de s�lo esperar, se podr�an hacer tareas como cargar Assets o realizar c�lculos pesados.
-	if (frameTime < MS_PER_FRAME)
+    if (frameTime < MS_PER_FRAME)
-	{
+    {
-		SDL_Delay(MS_PER_FRAME - frameTime);
+        SDL_Delay(MS_PER_FRAME - frameTime);
-	}
+    }
 
-	//Calculamos el deltaTime, que sí será el tiempo real que ha pasado, pues hemos esperado.
+    //Calculamos el deltaTime, que s� ser� el tiempo real que ha pasado, pues hemos esperado.
 
-	frameTime = SDL_GetTicks() - _startTime;
+    frameTime = SDL_GetTicks() - _startTime;
 
-	//Convertimos deltaTime a segundos pues es lo usado en los cálculos.
+    //Convertimos deltaTime a segundos pues es lo usado en los c�lculos.
-	deltaTime = frameTime / 1000.0f;
+    deltaTime = frameTime / 1000.0f;
 
 
-	//++countedFrames;
+    //++countedFrames;
 }
 

UberEngine/src/Time/Time.h

@@ -2,42 +2,42 @@
 #include <cstdint>
 
 /*
-	TODO:
+    TODO:
-		- Buscar una mejor forma de calcular la media de FPS.
+        - Buscar una mejor forma de calcular la media de FPS.
 
 */
 
 namespace UE
 {
 
-	class Time
+    class Time
-	{
+    {
-	public:
+    public:
 
-		//-------------------
+        //-------------------
-		//---- Métodos ------
+        //---- Métodos ------
-		//-------------------
+        //-------------------
-		static void StartFrame();
+        static void StartFrame();
 
 
-		static void EndFrame();
+        static void EndFrame();
 
-		//-------------------
+        //-------------------
-		//---- Variables ----
+        //---- Variables ----
-		//-------------------
+        //-------------------
-		static double deltaTime;
+        static double deltaTime;
 
 
 
-	private:
+    private:
-		static uint32_t _startTime;
+        static uint32_t _startTime;
-		//uint16_t countedFrames = 0;
+        //uint16_t countedFrames = 0;
-		float _avgFPS;
+        float _avgFPS;
 
 
-		static const int FPS = 60;
+        static const int FPS = 60;
-		//Milisegundos que tiene que tener un frame para poder hacer el número de FPS por segundo.
+        //Milisegundos que tiene que tener un frame para poder hacer el número de FPS por segundo.
-		static const int MS_PER_FRAME = 1000 / FPS;
+        static const int MS_PER_FRAME = 1000 / FPS;
-	};
+    };
 
 }

UberEngine/src/UberEngine.h

@@ -3,6 +3,8 @@
 #include "Logging/Logger.h"
 
 #include "Render/Renderer.h"
+#include "Render/Camera.h"
+
 #include "Drawables/Sprite.h"
 
 #include "Assets/AssetManager.h"

UberEngine/src/defs.h

@@ -0,0 +1,7 @@
+/*
+
+Aquí habrá que definir los tipos custom para UberEngine.
+Por ejemplo:
+ - glm::ivec2 -> UE_Vec2
+
+*/

UberGame1/GameScenes.hpp

@@ -1,48 +0,0 @@
-#pragma once
-
-#include "Scene/SceneBuilder.h"
-#include "Scene/Scene.h"
-
-#include "Scenes/MainScene.hpp"
-#include "Scenes/TestScene2.hpp"
-
-//#include "Logging\Logger.h"
-
-
-enum LasEscenas
-{
-	mainMenu = 0, nivel1
-};
-
-
-class GameScenes : public UE::SceneBuilder
-{
-public:
-	GameScenes()
-	{
-		
-	}
-
-	UE::Scene* InstanciateScene(int sceneID) override
-	{
-		switch (sceneID)
-		{
-		case LasEscenas::mainMenu:
-		{
-			UE::Scene* sc = new MainScene("Main");
-			return sc;
-			break;
-		}
-		case LasEscenas::nivel1:
-		{
-			UE::Scene* sc = new TestScene2("Test2");
-			return sc;
-			break;
-		}
-		default:
-			return nullptr;
-			break;
-		}
-	}
-
-};

UberGame1/Main.cpp

@@ -6,18 +6,18 @@
 #include <ImGui/imgui_impl_sdl.h>
 #include <ImGui/imgui_impl_opengl3.h>
 
-#include "UberGame1.h"
-#include "GameScenes.hpp"
 
+#include "Engine.h"
 #include "UberEngine.h"
 
 
 #include "Scenes/MainScene.hpp"
 #include "Scenes/TestScene2.hpp"
 
+
 static bool _quit = false;
 
-void Init();
+int Init();
 void Load();
 void Loop();
 void Clean();
@@ -25,7 +25,9 @@ void Clean();
 int main(int argc, char* args[])
 {
 
-    Init();
+    //Si falla la inicialización, terminamos el juego.
+    if(Init() < 0) { return -1; }
+
     Load();
     Loop();
     Clean();
@@ -33,25 +35,28 @@ int main(int argc, char* args[])
     return 0;
 }
 
-
+int Init()
-void Init()
 {
-    UE::Logger::InitLogger();
+    if(UE::Engine::Init() < 0)
-    
+    {
-    Game::InitGame();
+        GAME_LOG_CRITICAL("No se ha podido cargar el motor.");
+        return -1;
+    }
 
+    return 0;
 }
 
 void Load()
 {
-    Game::GetAssetManager()->LoadAssetsFromFile("resources/AssetList/MainAssets.json");
+    UE::Engine::GetAssetManager()->LoadAssetsFromFile("resources/AssetList/MainAssets.json");
-    Game::GetAssetManager()->ProcessAssetQueue();
+    UE::Engine::GetAssetManager()->ProcessAssetQueue();
 
 
     //Cargamos la escena que queramos tras tener todos los Assets pertinentes cargados.
     //Si la escena contiene su propio AssetManager y los carga ella misma, no ser� necesario.
     //Game::GetSceneManager()->LoadScene("Main");
-    Game::GetSceneManager()->NewLoadScene(LasEscenas::mainMenu);
+    UE::Engine::GetSceneManager()->LoadScene(new MainScene());
+    UE::Engine::GetSceneManager()->SwitchScene("MainScene");
 }
 
 
@@ -83,10 +88,17 @@ void Loop()
 #pragma endregion
 
 
+    //Almacenamos el renderer para ya tenerlo por aquí.
+    UE::Renderer* UE_Renderer = UE::Engine::GetRenderer();
+
+
     while (!_quit)
     {
         UE::Time::StartFrame();
 
+        //Almacenamos la escena actual.
+        UE::Scene* currentScene = UE::Engine::GetSceneManager()->GetCurrentScenePtr();
+
         //TEMP Event Handler:
         SDL_Event eventHandler;
         while (SDL_PollEvent(&eventHandler) != 0)
@@ -98,25 +110,25 @@ void Loop()
             if (io.WantCaptureMouse) { continue; }
 
 
-            Game::GetSceneManager()->GetActiveScenePtr()->SceneHandleEvents(&eventHandler);
+            currentScene->SceneHandleEvents(&eventHandler);
             if (eventHandler.type == SDL_QUIT)
             {
                 _quit = true;
             }
             if (eventHandler.type == SDL_WINDOWEVENT && eventHandler.window.event == SDL_WINDOWEVENT_RESIZED)
             {
-                //GAME_LOG_CRITICAL("Window Size chaged {0}x{1}", eventHandler.window.data1, eventHandler.window.data2);
+                GAME_LOG_INFO("Window Size chaged {0}x{1}", eventHandler.window.data1, eventHandler.window.data2);
-                Game::GetRenderer()->SetScreenSize(eventHandler.window.data1, eventHandler.window.data2);
+                UE_Renderer->SetScreenSize(eventHandler.window.data1, eventHandler.window.data2);
             }
             if (eventHandler.type == SDL_KEYDOWN)
             {
                 switch (eventHandler.key.keysym.sym)
                 {
                 case SDLK_1:
-                    Game::GetSceneManager()->NewLoadScene(LasEscenas::mainMenu);
+                    UE::Engine::GetSceneManager()->LoadAndSwitchScene(new MainScene());
                     break;
                 case SDLK_2:
-                    Game::GetSceneManager()->NewLoadScene(LasEscenas::nivel1);
+                    UE::Engine::GetSceneManager()->LoadAndSwitchScene(new TestScene2());
                     break;
                 default:
                     break;
@@ -134,32 +146,34 @@ void Loop()
             GAME_LOG_TRACE("FPS: NULL / dT: {1}", UE::Time::deltaTime);
         }
 
+
+        UE::Camera* cam = UE_Renderer->GetCamera();
         if (keyStates[SDL_SCANCODE_W])
         {
-            glm::ivec2 camPos = Game::GetRenderer()->GetCamPosition();
+            glm::ivec2 camPos = cam->GetPosition();
             camPos.y -= 5;
-            Game::GetRenderer()->SetCamPosition(camPos.x, camPos.y);
+            cam->SetPosition(camPos.x, camPos.y);
         }
         if (keyStates[SDL_SCANCODE_S])
         {
-            glm::ivec2 camPos = Game::GetRenderer()->GetCamPosition();
+            glm::ivec2 camPos = cam->GetPosition();
             camPos.y += 5;
-            Game::GetRenderer()->SetCamPosition(camPos.x, camPos.y);
+            cam->SetPosition(camPos.x, camPos.y);
         }
         if (keyStates[SDL_SCANCODE_D])
         {
-            glm::ivec2 camPos = Game::GetRenderer()->GetCamPosition();
+            glm::ivec2 camPos = cam->GetPosition();
             camPos.x += 5;
-            Game::GetRenderer()->SetCamPosition(camPos.x, camPos.y);
+            cam->SetPosition(camPos.x, camPos.y);
         }
         if (keyStates[SDL_SCANCODE_A])
         {
-            glm::ivec2 camPos = Game::GetRenderer()->GetCamPosition();
+            glm::ivec2 camPos = cam->GetPosition();
             camPos.x -= 5;
-            Game::GetRenderer()->SetCamPosition(camPos.x, camPos.y);
+            cam->SetPosition(camPos.x, camPos.y);
         }
 
-        Game::GetSceneManager()->GetActiveScenePtr()->SceneUpdate();
+        currentScene->SceneUpdate();
 
         //Game::GetRenderer()->QueueDrawCall(4, DestR2, test1);
         //Game::GetRenderer()->QueueDrawCall(1, DestR, background);
@@ -170,20 +184,20 @@ void Loop()
         // 
 
         //Iniciamos un nuevo Frame.
-        Game::GetRenderer()->NewFrame();
+        UE_Renderer->NewFrame();
 
         //Renderiza la escena.
-        Game::GetSceneManager()->GetActiveScenePtr()->SceneRender();
+        currentScene->SceneRender();
 
         //As� podemos renderizar cosas de ImGui cuando estemos entre NewFrame y EndFrame.
         bool show = true;
         ImGui::ShowDemoWindow(&show);
 
         //Dibuja las cosas del Renderer.
-        Game::GetRenderer()->RenderData();
+        UE_Renderer->RenderData();
 
         //Terminamos el Frame.
-        Game::GetRenderer()->EndFrame();
+        UE_Renderer->EndFrame();
 
         UE::Time::EndFrame();
 
@@ -194,7 +208,5 @@ void Loop()
 
 void Clean()
 {
-    Game::CleanGame();
+    UE::Engine::Clean();
-
-    SDL_Quit();
 }

UberGame1/Scenes/MainScene.hpp

@@ -1,6 +1,7 @@
 //#include "UberEngine.h"
 #pragma once
 
+#include "Engine.h"
 #include "Scene/Scene.h"
 #include "Render/Renderer.h"
 #include "Assets/AssetManager.h"
@@ -23,37 +24,52 @@ class MainScene : public UE::Scene
 {
 public:
 
-	MainScene(std::string sceneName) : Scene(sceneName) {}
+	MainScene() : Scene("MainScene")
+	{
+		//_sceneName = "MainScene";
+	}
 
 
 	void SceneLoad() override
 	{
 		UE_LOG_INFO("Escena {0} ha sido cargada", _sceneName);
 
-		UE::AssetManager* as = Game::GetAssetManager();
+		//Configuramos las cosas del Renderer.
+		//UE::Engine::GetRenderer()->SetCamPosition(150, 25);
+
+		SDL_Color newColor{40, 160, 195, 255};
+		UE::Engine::GetRenderer()->SetDrawingColor(newColor);
+
+
+		UE::AssetManager* as = UE::Engine::GetAssetManager();
 		UE::Texture* test1Texture = as->getTexture("test1");
 
 		UE::Sprite sp1(test1Texture, 0, 2, glm::vec2(55, 60), glm::vec2(100, 100));
 
 		UE::Sprite sp2(test1Texture, 0, 1, glm::vec2(50, 45), glm::vec2(145, 145));
 
-		UE::Sprite bg(as->getTexture("bg1"), 1, 0, glm::vec2(0, 0), Game::GetRenderer()->GetScreenSize());
+		UE::Sprite bg(as->getTexture("bg1"), 1, 0, glm::vec2(0, 0), UE::Engine::GetRenderer()->GetScreenSize());
 
-		UE::Sprite mapSP(as->getTexture("PruebaMap"), 0, 2, glm::vec2(50, 45), glm::vec2(145, 145));
+		UE::Sprite mapSP(as->getTexture("PruebaMap"), 1, 2, glm::vec2(50, 45), glm::vec2(145, 145));
+
+		UE::Sprite default1;
 
 
 		sprites.push_back(sp1);
 		sprites.push_back(sp2);
 		sprites.push_back(bg);
 		sprites.push_back(mapSP);
+		sprites.push_back(default1);
 
 		UE::Font* OP_Regular = as->GetFont("OpenSans_Regular");
 		//TTF_Font* OP_Bold = as->GetFont("OpenSans_Bold");
 
 		UE::TextBox text1(OP_Regular);
 		//UE::TextBox text2(OP_Bold, "Otro texto");
+		//UE::TextBox(OP_Regular)
 
-		texts.push_back(text1);
+		texts.push_back(text1); //Copiamos el text1.
+		//texts.emplace_back(OP_Regular); //Construimos el text1.
 		//texts.push_back(text2);
 	}
 
@@ -62,9 +78,9 @@ public:
 		//UE_LOG_INFO("Escena {0} UPDATE", _sceneName);
 
 		UE::Renderer* renderer;
-		renderer = Game::GetRenderer();
+		renderer = UE::Engine::GetRenderer();
 
-		glm::vec2 screenSize = Game::GetRenderer()->GetScreenSize();
+		glm::vec2 screenSize = UE::Engine::GetRenderer()->GetScreenSize();
 
 		UE::Sprite& sp1 = sprites.at(0);
 		glm::vec2 pos = sp1.GetPosition();
@@ -78,7 +94,7 @@ public:
 	void SceneRender() override 
 	{
 		UE::Renderer* renderer;
-		renderer = Game::GetRenderer();
+		renderer = UE::Engine::GetRenderer();
 
 		for (UE::Sprite& sp : sprites)
 		{
@@ -236,7 +252,7 @@ private:
 
 	void AssetMngGUI() 
 	{
-		UE::AssetManager* asmng = Game::GetAssetManager();
+		UE::AssetManager* asmng = UE::Engine::GetAssetManager();
 
 		ImGui::Begin("Asset Manager Inspector", &assetMngGUI);
 		

UberGame1/Scenes/TestScene2.hpp

@@ -8,6 +8,7 @@
 #include "Assets/Texture.h"
 
 #include "Drawables/Sprite.h"
+#include "Render/Camera.h"
 
 
 #include <iostream>
@@ -18,7 +19,12 @@ class TestScene2 : public UE::Scene
 {
 public:
 
-	TestScene2(std::string sceneName) : Scene(sceneName) {}
+	UE::Camera sceneCam;
+
+	TestScene2() : Scene("TestScene")
+	{
+		//_sceneName = "TestScene";
+	}
 
 	void SceneLoad() override
 	{
@@ -26,8 +32,11 @@ public:
 
 		srand(255);
 
-		UE::AssetManager* as = Game::GetAssetManager();
+		glm::ivec2 screenSize = UE::Engine::GetRenderer()->GetScreenSize();
+		sceneCam = UE::Camera(0, 0, screenSize.x, screenSize.y);
+		UE::Engine::GetRenderer()->SetCamera(&sceneCam);
 
+		UE::AssetManager* as = UE::Engine::GetAssetManager();
 		UE::Texture* tx = as->getTexture("PruebaMap");
 
 		for (int y = 0; y < vAmount; y++)
@@ -39,7 +48,7 @@ public:
 				glm::vec2 size(100, 100);
 				glm::vec2 pos = size * i;
 
-				UE::Sprite sp(tx, rand()%5, 1, pos, size);
+				UE::Sprite sp(tx, (rand()%4)+1, 1, pos, size);
 				sprites.push_back(sp);
 			}
 
@@ -55,7 +64,7 @@ public:
 	void SceneRender() override
 	{
 		UE::Renderer* renderer;
-		renderer = Game::GetRenderer();
+		renderer = UE::Engine::GetRenderer();
 
 		for (UE::Sprite& sp : sprites)
 		{
@@ -85,9 +94,9 @@ public:
 		}
 		if (event->type == SDL_MOUSEBUTTONDOWN)
 		{
-			UE::Renderer* rend = Game::GetRenderer();
+			UE::Renderer* rend = UE::Engine::GetRenderer();
 			glm::ivec2 mPos(event->button.x, event->button.y);
-			glm::ivec2 wPos = rend->ScreenToWorldCoords(mPos);
+			glm::ivec2 wPos = rend->GetCamera()->ScreenToWorldCoords(mPos);
 			GAME_LOG_TRACE("Posicion del raton: \n\tPantalla: {0}x{1}, Mundo: {2}x{3}: ", mPos.x, mPos.y, wPos.x, wPos.y);
 			ModificarSprite(wPos);
 		}
@@ -109,10 +118,10 @@ private:
 		for (int i = 0; i < sprites.size(); i++)
 		{
 			UE::Sprite& sp = sprites.at(i);
-			SDL_Rect sp_Pos = sp.getPositionRect();
+			SDL_Rect sp_Pos = sp.GetTransformRect();
 			if (SDL_HasIntersection(&mouseRect, &sp_Pos))
 			{
-				int i = rand() % 5;
+				int i = rand() % 4 +1;
 				sp.SetTextureRect(i);
 				break;
 			}
@@ -192,8 +201,8 @@ private:
 	}
 
 private:
-	const int vAmount = 10;
+	const int vAmount = 128;
-	const int hAmount = 10;
+	const int hAmount = 128;
 
 
 	std::vector<UE::Sprite> sprites = {};

UberGame1/UberGame1.cpp

@@ -1,49 +0,0 @@
-#include "UberGame1.h"
-
-#include "Logging/Logger.h"
-#include "Render/Renderer.h"
-#include "Assets/AssetManager.h"
-
-#include "Scene/SceneManager.h"
-#include "Scene/SceneBuilder.h"
-
-#include "GameScenes.hpp"
-
-//Sobrecarga de SceneBuilder que devuelve las escenas correctas para este juego.
-//#include "GameScenes.hpp" 
-
-UE::Renderer* Game::mainRenderer;
-UE::AssetManager* Game::asManager;
-UE::SceneManager* Game::scManager;
-
-GameScenes Game::_sceneBuilder;
-
-void Game::InitGame()
-{
-    mainRenderer = new UE::Renderer(640, 480, 5);
-    mainRenderer->InitRenderer();
-
-    UE_LOG_INFO("Renderer Created.");
-
-    asManager = new UE::AssetManager(mainRenderer->GetSDLRenderer());
-    asManager->InitAssetManager();
-    UE_LOG_INFO("AssetManager Created.");
-
-    //Creamos el SceneBuilder de este juego.
-    _sceneBuilder = GameScenes();
-
-    scManager = new UE::SceneManager();
-    scManager->InitSceneManager(&_sceneBuilder);
-}
-
-void Game::CleanGame()
-{
-    asManager->CleanAssetManager();
-    delete asManager;
-
-    mainRenderer->CleanRenderer();
-    delete mainRenderer;
-
-    scManager->CleanSceneManager();
-    delete scManager;
-}

UberGame1/UberGame1.h

@@ -1,30 +0,0 @@
-#pragma once
-
-namespace UE
-{
-	class Renderer;
-	class AssetManager;
-	class SceneManager;
-	class SceneBuilder;
-}
-
-class GameScenes;
-
-class Game
-{
-public:
-	static void InitGame();
-	static void CleanGame();
-
-	inline static UE::Renderer* GetRenderer() { return mainRenderer; }
-	inline static UE::AssetManager* GetAssetManager() { return asManager; }
-	inline static UE::SceneManager* GetSceneManager() { return scManager;  }
-
-
-private:
-	static UE::Renderer* mainRenderer;
-	static UE::AssetManager* asManager;
-	static UE::SceneManager* scManager;
-
-	static GameScenes _sceneBuilder;
-};

premake5.lua

@@ -13,6 +13,7 @@ workspace (""..GameName.."")
 project (""..GameName.."")
     kind      "ConsoleApp"
     language  "C++"
+    cppdialect "C++17"
 
     location  ""
 
@@ -44,19 +45,35 @@ project (""..GameName.."")
 
     }
 
-    cppdialect "C++17"
 
 
     filter "configurations:Debug"
         defines { "DEBUG" }
         symbols "On"
+        postbuildcommands 
+        { 
+            "{COPYDIR} UberEngine/vendor/SDL/lib/x64/*.dll bin/Debug/",
+            "{COPYDIR} UberEngine/vendor/SDL2_image/lib/x64/*.dll bin/Debug/",
+            "{COPYDIR} UberEngine/vendor/SDL2_ttf/lib/x64/*.dll bin/Debug/",
+            "{COPYDIR} resources/ bin/Debug/resources/"
+        }
+
 
     filter "configurations:Release"
         defines { "NDEBUG" }
         optimize "On"
+        postbuildcommands 
+        { 
+            "{COPYDIR} UberEngine/vendor/SDL/lib/x64/*.dll bin/Release/",
+            "{COPYDIR} UberEngine/vendor/SDL2_image/lib/x64/*.dll bin/Release/",
+            "{COPYDIR} UberEngine/vendor/SDL2_ttf/lib/x64/*.dll bin/Release/",
+            "{COPYDIR} resources/ bin/Release/resources/"
+        }
 
 
+    -------------------------------------------------
     -- Opciones de Windows.
+    -------------------------------------------------
     filter "system:windows"
         systemversion "latest"
         includedirs  
@@ -70,26 +87,10 @@ project (""..GameName.."")
         links        { "opengl32.lib", "SDL2.lib", "SDL2main.lib", "SDL2_image.lib", "SDL2_ttf.lib" }
         defines      { "SDL_VIDEO_DRIVER_WINDOWS" }
 
-    filter { "system:windows", "configurations:Debug" }
-        postbuildcommands 
-        { 
-            "xcopy UberEngine\\vendor\\SDL\\lib\\x64\\*.dll bin\\Debug\\ /y /f",
-            "xcopy UberEngine\\vendor\\SDL2_image\\lib\\x64\\*.dll bin\\Debug\\ /y /f",
-            "xcopy UberEngine\\vendor\\SDL2_ttf\\lib\\x64\\*.dll bin\\Debug\\ /y /f",
-            "xcopy resources\\ bin\\Debug\\resources\\ /e /y /f"
-        }
-
-
-    filter { "system:windows", "configurations:Release" }
-        postbuildcommands 
-        { 
-            "xcopy UberEngine\\vendor\\SDL\\lib\\x64\\*.dll bin\\Release\\ /y /f",
-            "xcopy UberEngine\\vendor\\SDL2_image\\lib\\x64\\*.dll bin\\Release\\ /y /f",
-            "xcopy UberEngine\\vendor\\SDL2_ttf\\lib\\x64\\*.dll bin\\Release\\ /y /f",
-            "xcopy resources\\ bin\\Release\\resources\\ /e /y /f"
-        }
 
+    -------------------------------------------------
     -- Opciones de Linux.
+    -------------------------------------------------
     filter "system:linux"
         includedirs  
         {
@@ -98,22 +99,3 @@ project (""..GameName.."")
 
         links        { "SDL2", "SDL2main", "SDL2_image", "SDL2_ttf", "dl", "GL", "GLEW"}
         defines      { "SDL_VIDEO_DRIVER_X11" }
-
-    filter { "system:linux", "configurations:Debug" }
-        postbuildcommands 
-        { 
-            -- "cp UberEngine/vendor/SDL/lib/x64/*.dll bin/Debug/",
-            -- "cp UberEngine/vendor/SDL2_image/lib/x64/*.dll bin/Debug/",
-            -- "cp UberEngine/vendor/SDL2_ttf/lib/x64/*.dll bin/Debug/",
-            "cp -r resources/ bin/Debug/resources/"
-        }
-
-
-    filter { "system:linux", "configurations:Release" }
-        postbuildcommands 
-        { 
-            -- "cp UberEngine/vendor/SDL/lib/x64/*.dll bin/Release/",
-            -- "cp UberEngine/vendor/SDL2_image/lib/x64/*.dll bin/Release/",
-            -- "cp UberEngine/vendor/SDL2_ttf/lib/x64/*.dll bin/Release/",
-            "cp -r resources/ bin/Release/resources/"
-        }

resources/AssetList/MainAssets.json

@@ -1,5 +1,10 @@
 {
     "Textures": [
+		{
+			"name": "default",
+            "Path": "resources/Sprites/Data/TX_default.json",
+            "Type": 0
+		},
 		{
 			"name": "bg1",
             "Path": "resources/Sprites/Data/TX_bg1.json",
@@ -37,6 +42,11 @@
         }
     ],
 	"Fonts": [
+		{
+			"name": "default",
+            "Path": "resources/AssetsData/FontsData/OpenSansRegular.json",
+            "Type": 1
+		},
 		{
 			"name": "OpenSans_Regular",
             "Path": "resources/AssetsData/FontsData/OpenSansRegular.json",

resources/Sprites/Data/TX_Player.json

@@ -1,17 +1,5 @@
 {
 	"TexturePath": "resources/Sprites/Textures/Player.png",
 	"TextureRects": [
-		{
-			"posX": 0,
-			"posY": 0,
-			"sizeX": 16,
-			"sizeY": 16
-		},
-		{
-			"posX": 16,
-			"posY": 0,
-			"sizeX": 16,
-			"sizeY": 16
-		}
 	]
 }

resources/Sprites/Data/TX_bg1.json

@@ -1,12 +1,6 @@
 {
 	"TexturePath": "resources/Sprites/Textures/bc.png",
 	"TextureRects": [
-		{
-			"posX": 0,
-			"posY": 0,
-			"sizeX": 320,
-			"sizeY": 240
-		},
 		{
 			"posX": 80,
 			"posY": 60,

resources/Sprites/Data/TX_default.json

@@ -0,0 +1,5 @@
+{
+	"TexturePath": "resources/Sprites/Textures/noTexture.png",
+	"TextureRects": [
+	]
+}