Unificar Encoding.

Revisado que todos los archivos son UTF-8 y espacios como indentación.

README.md

@@ -39,3 +39,6 @@ Repositorio principal de UberEngine. Sin mucho más.
 
 ### 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.
+
+### Sistema de Escenas.
+ - [ ] Revisar los métodos para carga/descarga y de cambio de escenas. Creo que se pueden estructurar mejor.

UberEngine/src/Assets/AssetManager.cpp

@@ -1,4 +1,4 @@
-#include <fstream>
+#include <fstream>
 #include <iostream>
 
 #include "Logging/Logger.h"
@@ -12,24 +12,6 @@ namespace UE
 
     void AssetManager::InitAssetManager()
     {
-		if (IMG_Init(IMG_INIT_PNG))
-		{
-			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.
-		{
-			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.");
     }
 
@@ -52,15 +34,10 @@ namespace UE
         _assetQueue.clear();
         _textures.clear();
 
-
-		IMG_Quit();
-
         UE_LOG_INFO("AssetManager Cleaned");
     }
 
 
-
-
     void AssetManager::LoadAssetsFromFile(std::string filePath)
     {
         std::fstream file(filePath.c_str());

UberEngine/src/Assets/AssetManager.h

@@ -11,10 +11,9 @@
 #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;
 

UberEngine/src/Assets/Font.h

@@ -9,8 +9,8 @@ namespace UE
 {
     /** 
     * Clase Wrapper para las SDL_Fonts.
-	* También sirve de "cache" para los diferentes tamaños de la fuente, de esta forma
-	*	reducimos las veces que generamos las fuentes y podemos utilizar múltiples tamaños de forma sencilla.
+    * Tambi�n sirve de "cache" para los diferentes tama�os de la fuente, de esta forma
+    *   reducimos las veces que generamos las fuentes y podemos utilizar m�ltiples tama�os de forma sencilla.
     * 
     */
     class Font
@@ -37,11 +37,11 @@ namespace UE
 
 
         /**
-		* Devuelve la fuente del tamaño pedido.
-		* En caso de no estar disponible, la genera y la añade al cache antes de devolverla.
+        * 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.
+        * @param size : tama�o de la fuente.
+        * @return TTF_Font* : Fuente del tama�o solicitado.
         */
         TTF_Font* GetFont(int size);
 
@@ -53,15 +53,15 @@ namespace UE
         void InitFont();
 
         /**
-		* Limpia la fuente, eliminando todos sus tamaños y vaciando toda la memoria.
+        * 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.
+        * 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.
+        * @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);
 
@@ -71,13 +71,13 @@ namespace UE
         //-----------------------
 
     private:
-		//Ubicación del archivo de datos (.json).
+        //Ubicaci�n del archivo de datos (.json).
         std::string _dataPath = "";
 
-		//Ubicación de la tipografía (.ttf).
+        //Ubicaci�n de la tipograf�a (.ttf).
         std::string _fontPath = "";
 
-		//Caché de los diferentes tamaños de la fuente.
+        //Cach� de los diferentes tama�os de la fuente.
         std::unordered_map<int, TTF_Font*> _fonts = {};
 
     };

UberEngine/src/Assets/Texture.h

@@ -42,10 +42,10 @@ namespace UE
         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).
+        * 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.
+        * @param i : �ndice del rect.
         * @return El SDL_Rect* solicitado (o el por defecto en caso de error).
         */
         SDL_Rect* GetTextureRect(int i);
@@ -63,13 +63,13 @@ namespace UE
         void CleanTexture();
 
         /**
-		* Método encargado de generar la textura a partir de los valores de la clase.
+        * 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.
+        * 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);
 
@@ -78,13 +78,13 @@ namespace UE
         //-----------------------
 
     private:
-		//Ubicación del archivo de datos (.json).
+        //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).
+        //Ubicaci�n de la textura (.png).
         std::string _txPath = "";
 
         //La propia textura.

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/Logging/Logger.h

@@ -23,7 +23,7 @@ namespace UE
     };
 
 
-//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_DEBUG(...)           ::UE::Logger::GetEngineLogger()->debug(__VA_ARGS__)
 #define UE_LOG_INFO(...)            ::UE::Logger::GetEngineLogger()->info(__VA_ARGS__)

UberEngine/src/Render/Renderer.cpp

@@ -3,7 +3,7 @@
 #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>
 
@@ -13,20 +13,8 @@
 
 namespace UE
 {
-	//class Game;
-
     int Renderer::InitRenderer()
     {
-		//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("No se ha podido iniciar SDL, sufre mam�n: {0}", SDL_GetError());
-			return 1;
-		}
-
         //Configuramos los par�metros de la ventana de SDL.
         Uint32 windowFlags = (SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_RESIZABLE);
 
@@ -34,15 +22,16 @@ namespace UE
         _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;
+            UE_LOG_CRITICAL("Renderer - CreateWindow: No se ha podido crear la ventana con OpenGL: {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());
+            UE_LOG_CRITICAL("Renderer - SDL_Renderer: No se ha podido crear el Renderer de SDL: {0}", SDL_GetError());
+            return -2;
         }
         SDL_SetRenderDrawColor(main_Renderer, 0xFF, 0xFF, 0xFF, 0xFF);
 
@@ -63,7 +52,7 @@ namespace UE
 
 
         //Init layers.
-		for (int i = 0; i < LAYER_AMOUNT; i++)
+        for (int i = 0; i <= LAYER_AMOUNT; i++)
         {
             renderLayers.push_back(std::vector<DrawCall>());
         }

UberEngine/src/Scene/Scene.cpp

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

UberEngine/src/Scene/Scene.h

@@ -5,7 +5,6 @@
 
 ///
 ///	TODO:
-///  - Scene debería ser serializable y cargable desde archivos, al menos para las clases derivadas. ( o quizás no....)
 /// 
 /// 
 union SDL_Event;
@@ -14,9 +13,9 @@ namespace UE
 {
 
     /* 
-		Estructura básica de una escena. Almacena los datos mínimos.
-		Se utilizará como clase base para las clases Scene específicas.
-		Esta clase será heredada por las escenas del usuario.
+        Estructura básica de una escena.
+        Se utiliza como clase base para las clases Scene específicas del Game.
+        Esta clase será heredada por las escenas del usuario.
     */ 
     class Scene
     {
@@ -24,35 +23,67 @@ namespace UE
 
         Scene(std::string name)
             : _sceneName(name)
-		{}
+        {
+            SceneInit();
+        }
 
-		/* Funciones "internas" de la clase para inicialización y cierre. */
+        ~Scene()
+        {
+            SceneClean();
+        }
+
+
+        /* Funciones "internas" de la clase para inicialización y cierre. */
         void SceneInit();		//Te calienta y prepara la casa al llegar.
         void SceneClean();		//Te deja todo limpio y reluciente al salir.
 
+        /* 
+        Métodos de los estados de la escena.
+        Habrán de ser sobrecargardos por las escenas del usuario. 
+        */
 
-		/* Funciones que habrán de sobrecargar las escenas del usuario. */
-		virtual void SceneLoad() { std::cout << "EMPTY SCENE CREATED" << std::endl; }
-		virtual void SceneRender() {}
-		virtual void SceneUpdate() {}
-		virtual void SceneHandleEvents(SDL_Event* event) {}
-		virtual void SceneUnload() { std::cout << "EMPTY SCENE DESCARGADA" << std::endl; }
+        //Se crean todos los objetos y se carga todo lo necesario para la escena.
+        virtual void SceneLoad() = 0;
 
-		// ¿Esto sirve para algo?
-		//void loadDataFromFile(std::string path);
+        /* 
+         * 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; }
 
 
     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;
+        //Nombre de la escena. Para identificarla en el SceneManager.
+        std::string _sceneName = "NullScene";
 
         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,86 +7,131 @@
 namespace UE
 {
 
-	void SceneManager::InitSceneManager(SceneBuilder* sceneBuilder)
+    void SceneManager::InitSceneManager()
     {
-		_sceneBuilder = sceneBuilder;
-
         UE_LOG_INFO("Se ha inicializado el SceneManager.");
     }
 
     void SceneManager::CleanSceneManager()
     {
+        for (auto& it : _loadedScenes)
+        {
+            Scene* sc = it.second;
+            sc->SceneClean();
+            delete sc;
+        }
+
+        _loadedScenes.clear();
+
         if (_currentScene != nullptr)
+        {
+            _currentScene = nullptr;
+        }
+
+        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();
-			delete _currentScene;
         }
 
-		//for (auto& it : _scenes)
-		//{
-		//	Scene* sc = it.second;
-		//	sc->SceneClean();
-		//	delete sc;
-		//}
-
-		//_scenes.clear();
-
-
+        //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;
+        }
 
-	//void SceneManager::AddScene(Scene* sceneToAdd)
-	//{
-	//	_scenes.insert(std::make_pair(sceneToAdd->GetName(), sceneToAdd));
-	//	sceneToAdd->SceneInit();
-
-	//	UE_LOG_INFO("Se ha a�adido la escena {0} al SceneManager.", sceneToAdd->GetName());
-	//}
+        //Si todo está correcto.
+        //Si tenemos campo libre, pista libre, punto rojo.
+        //Descargamos.
+        _loadedScenes.at(name)->SceneUnload();
+        _loadedScenes.erase(name);
+    }
 
 
-
-	//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);
-	//}
+    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::GetActiveSceneName()
+    std::string SceneManager::GetCurrentSceneName()
     {
         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)
+    Scene* SceneManager::GetCurrentScenePtr() 
     { 
-		if (_currentScene != nullptr)
-		{
-			_currentScene->SceneUnload();
-			delete _currentScene;
-		}
-
-		_currentScene = _sceneBuilder->InstanciateScene(sceneID);
-
-		_currentScene->SceneLoad();
+        return _currentScene;
     }
 
     void SceneManager::UpdateScene()

UberEngine/src/Scene/SceneManager.h

@@ -1,71 +1,110 @@
 #pragma once
+
+#include "Scene/Scene.h"
+
 #include <string>
 #include <vector>
 #include <unordered_map>
 
 //
-// Habría que implemetar un sistema para cambiar de escena.
-// La cuestión sería almecenar el ID actual o algo así.
-// 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.
-// Cuando cargas una escena, se descarga la anterior mediante Scene.unload y se carga la nueva con Scene.Load. De esta forma,
-//		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....
-// 
-
+// TODO:
+//  - Se podría plantear un sistema de carga asincrona para las escenas.
+//  - La variable "loaded" de las escenas no tiene mucha utilidad en este momento.
 
 namespace UE
 {
-	class Scene;
-	class SceneBuilder;
 
     /* Gestiona todas escenas. Las carga, descargar y ejecuta. */
     class SceneManager
     {
 
     public:
-		/* Constructor */
-		SceneManager() {}
 
-		void InitSceneManager(SceneBuilder* sceneBuilder);
+        /* Constructor */
+        SceneManager() 
+        {
+            InitSceneManager();
+        }
+
+        ~SceneManager()
+        {
+            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();
 
-		//Añade una escena a la lista y retorna su ID. Son Ptrs, por lo que poco importa donde los almacenamos.
-		//void AddScene(Scene* sceneToAdd);
+        /*
+         * Carga una nueva escena.
+         * 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.
+         */
+        void LoadScene(Scene* sceneToLoad);
 
-		//Devuelve un ptr a la escena del ID especificado.
-		//Scene* GetScenePtr(std::string sceneName);
-		std::string GetActiveSceneName();
+        /*
+         * Cambia la escena activa por la indicada.
+         * Si la indicada no está cargada, no hace nada.
+         */
+        void SwitchScene(std::string name);
 
-		//Devuelve la escena activa.
-		inline Scene* GetActiveScenePtr() { return _currentScene; }
+        /*
+         * 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.
-		//void LoadScene(std::string sceneName);
+        /*
+         * Cambia la escena activa por la indicada.
+         * Descarga completamente la escena activa anterior.
+         * Si la escena indicada no está cargarda, no hace nada.
+         * Si no hay una escena activa, no la descarga.
+         */
+        void SwitchAndUnloadScene(std::string name);
 
-		//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);
 
-		//Pasa el Update a la escena actual.
-		//¿Necesita hacer algo más?
+        /*
+         * Descarga la escena con el nombre indicado.
+         * Si la escena no está en la lista, no hace nada.
+         */
+        void UnloadScene(std::string name);
+
+        /*
+         * Comprueba si la escena indicada está en la lista de escenas cargadas.
+         * Retorna true si está cargada, false si no.
+         */
+        bool IsSceneLoaded(std::string name);
+
+
+        /*
+         * 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();
 
-		// ¿Esto sirve para algo?
-		//void LoadSceneDataFromFile(std::string filePath);
 
 
     private:
+        //Ptr a la escena que está activa en ese momento.
         Scene* _currentScene = nullptr;
 
-		SceneBuilder* _sceneBuilder = nullptr;
-
-		//Almacenamos un ptr a las diferentes escenas disponibles. 
-		//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().
-		//std::unordered_map<std::string, Scene*> _scenes;
-		//std::vector<Scene*> _scenes;
-
+        //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

@@ -24,17 +24,17 @@ void UE::Time::EndFrame()
     //std::cout << "FPS: " << avgFPS << " / " << "dT: " << deltaTime << std::endl;
 
     //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)
     {
         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;
 
-	//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;
 
 

UberEngine/src/Time/Time.h

@@ -15,7 +15,7 @@ namespace UE
     public:
 
         //-------------------
-		//---- Métodos ------
+        //---- Métodos ------
         //-------------------
         static void StartFrame();
 
@@ -36,7 +36,7 @@ namespace UE
 
 
         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;
     };
 

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,9 +6,8 @@
 #include <ImGui/imgui_impl_sdl.h>
 #include <ImGui/imgui_impl_opengl3.h>
 
-#include "UberGame1.h"
-#include "GameScenes.hpp"
 
+#include "Engine.h"
 #include "UberEngine.h"
 
 
@@ -17,7 +16,7 @@
 
 static bool _quit = false;
 
-void Init();
+int Init();
 void Load();
 void Loop();
 void Clean();
@@ -25,7 +24,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 +34,28 @@ int main(int argc, char* args[])
     return 0;
 }
 
-
-void Init()
+int Init()
 {
-    UE::Logger::InitLogger();
-    
-    Game::InitGame();
+    if(UE::Engine::Init() < 0)
+    {
+        GAME_LOG_CRITICAL("No se ha podido cargar el motor.");
+        return -1;
+    }
 
+    return 0;
 }
 
 void Load()
 {
-    Game::GetAssetManager()->LoadAssetsFromFile("resources/AssetList/MainAssets.json");
-    Game::GetAssetManager()->ProcessAssetQueue();
+    UE::Engine::GetAssetManager()->LoadAssetsFromFile("resources/AssetList/MainAssets.json");
+    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 +87,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,7 +109,7 @@ void Loop()
             if (io.WantCaptureMouse) { continue; }
 
 
-            Game::GetSceneManager()->GetActiveScenePtr()->SceneHandleEvents(&eventHandler);
+            currentScene->SceneHandleEvents(&eventHandler);
             if (eventHandler.type == SDL_QUIT)
             {
                 _quit = true;
@@ -106,17 +117,17 @@ void Loop()
             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::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 +145,33 @@ void Loop()
             GAME_LOG_TRACE("FPS: NULL / dT: {1}", UE::Time::deltaTime);
         }
 
+
         if (keyStates[SDL_SCANCODE_W])
         {
-            glm::ivec2 camPos = Game::GetRenderer()->GetCamPosition();
+            glm::ivec2 camPos = UE_Renderer->GetCamPosition();
             camPos.y -= 5;
-            Game::GetRenderer()->SetCamPosition(camPos.x, camPos.y);
+            UE_Renderer->SetCamPosition(camPos.x, camPos.y);
         }
         if (keyStates[SDL_SCANCODE_S])
         {
-            glm::ivec2 camPos = Game::GetRenderer()->GetCamPosition();
+            glm::ivec2 camPos = UE_Renderer->GetCamPosition();
             camPos.y += 5;
-            Game::GetRenderer()->SetCamPosition(camPos.x, camPos.y);
+            UE_Renderer->SetCamPosition(camPos.x, camPos.y);
         }
         if (keyStates[SDL_SCANCODE_D])
         {
-            glm::ivec2 camPos = Game::GetRenderer()->GetCamPosition();
+            glm::ivec2 camPos = UE_Renderer->GetCamPosition();
             camPos.x += 5;
-            Game::GetRenderer()->SetCamPosition(camPos.x, camPos.y);
+            UE_Renderer->SetCamPosition(camPos.x, camPos.y);
         }
         if (keyStates[SDL_SCANCODE_A])
         {
-            glm::ivec2 camPos = Game::GetRenderer()->GetCamPosition();
+            glm::ivec2 camPos = UE_Renderer->GetCamPosition();
             camPos.x -= 5;
-            Game::GetRenderer()->SetCamPosition(camPos.x, camPos.y);
+            UE_Renderer->SetCamPosition(camPos.x, camPos.y);
         }
 
-        Game::GetSceneManager()->GetActiveScenePtr()->SceneUpdate();
+        currentScene->SceneUpdate();
 
         //Game::GetRenderer()->QueueDrawCall(4, DestR2, test1);
         //Game::GetRenderer()->QueueDrawCall(1, DestR, background);
@@ -170,20 +182,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 +206,5 @@ void Loop()
 
 void Clean()
 {
-    Game::CleanGame();
-
-    SDL_Quit();
+    UE::Engine::Clean();
 }

UberGame1/Scenes/MainScene.hpp

@@ -23,21 +23,24 @@ 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();
+		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));
 
@@ -62,9 +65,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 +81,7 @@ public:
 	void SceneRender() override 
 	{
 		UE::Renderer* renderer;
-		renderer = Game::GetRenderer();
+		renderer = UE::Engine::GetRenderer();
 
 		for (UE::Sprite& sp : sprites)
 		{
@@ -236,7 +239,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

@@ -18,7 +18,10 @@ class TestScene2 : public UE::Scene
 {
 public:
 
-	TestScene2(std::string sceneName) : Scene(sceneName) {}
+	TestScene2() : Scene("TestScene")
+	{
+		//_sceneName = "TestScene";
+	}
 
 	void SceneLoad() override
 	{
@@ -26,7 +29,7 @@ public:
 
 		srand(255);
 
-		UE::AssetManager* as = Game::GetAssetManager();
+		UE::AssetManager* as = UE::Engine::GetAssetManager();
 
 		UE::Texture* tx = as->getTexture("PruebaMap");
 
@@ -55,7 +58,7 @@ public:
 	void SceneRender() override
 	{
 		UE::Renderer* renderer;
-		renderer = Game::GetRenderer();
+		renderer = UE::Engine::GetRenderer();
 
 		for (UE::Sprite& sp : sprites)
 		{
@@ -85,7 +88,7 @@ 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);
 			GAME_LOG_TRACE("Posicion del raton: \n\tPantalla: {0}x{1}, Mundo: {2}x{3}: ", mPos.x, mPos.y, wPos.x, wPos.y);

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;
-};