Primera versión del sistema de escenas (probablemente sea una aproximación bastante incorrecta. Además, no se han realizado apenas pruebas).

Sistema de Logging (¡Al fin!).

UberEngine/src/Assets/AssetManager.cpp

@@ -80,7 +80,7 @@ namespace UE
 		//Load Assets from files, depending on the type.
 		for (int i = 0; i < cantidad; i++)
 		{
-			Asset& as = _assets.at(i);
+			Asset& as = _assets.at(0);
 			switch (as._type)
 			{
 				case AssetType::Texture:
@@ -99,8 +99,8 @@ namespace UE
 					break;
 				}
 			}
+			_assets.erase(_assets.begin());
 		}
-		_assets.clear();
 	}
 
 
@@ -127,6 +127,11 @@ namespace UE
 		return _textures.at(TextureName);
 	}
 
+	int AssetManager::GetAssetQueueSize()
+	{
+		return _assets.size();
+	}
+
 
 
 	void AssetManager::AddSpriteSheet(std::string name, std::string spPath)

UberEngine/src/Assets/AssetManager.h

@@ -48,14 +48,17 @@ namespace UE
 			: _mainRenderer(SDLrenderer) {}
 
 
-		/* Init AssetManager y todo lo necesario para funcionar correctamente. 
+		/** 
-			- Inicia SDL_IMG.
+		 *	Init AssetManager y todo lo necesario para funcionar correctamente.
+		 *	- Inicia SDL_IMG.
 		 */
 		int InitAssetManager();
 
-		/* Clean AssetManager Data on exit
+		/**
-			- Elimina todos los assets de sus contenedores.
+		 * 
-			- Descarga SDL_IMG
+		 * Clean AssetManager Data on exit
+		 *	- Elimina todos los assets de sus contenedores.
+		 *	- Descarga SDL_IMG
 		 */
 		int CleanAssetManager();
 
@@ -89,6 +92,12 @@ namespace UE
 		 */
 		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.
+		 * 
+		 */
+		int GetAssetQueueSize();
 
 
 		/* 

UberEngine/src/Logging/Logger.cpp

@@ -0,0 +1,22 @@
+#include "Logger.h"
+
+#include "spdlog\sinks\stdout_color_sinks.h"
+
+
+namespace UE
+{
+	std::shared_ptr<spdlog::logger> Logger::_engineLogger;
+	std::shared_ptr<spdlog::logger> Logger::_gameLogger;
+
+	void Logger::InitLogger()
+	{
+		spdlog::set_pattern("%^[%T]: %l - %n: %v %$");
+
+		_engineLogger = spdlog::stdout_color_mt("UberEngine");
+		_engineLogger->set_level(spdlog::level::trace);
+
+		_gameLogger = spdlog::stdout_color_mt("UberGame1");
+		_gameLogger->set_level(spdlog::level::trace);
+
+	}
+}

UberEngine/src/Logging/Logger.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "spdlog\spdlog.h"
+
+#include <memory>
+
+namespace UE
+{
+
+	class Logger
+	{
+	public:	
+		static void InitLogger();
+
+		inline static std::shared_ptr<spdlog::logger>& GetGameLogger() { return _gameLogger; }
+		inline static std::shared_ptr<spdlog::logger>& GetEngineLogger() { return _engineLogger; }
+
+
+	private:
+		static std::shared_ptr<spdlog::logger> _engineLogger;
+		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...
+#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__)
+#define UE_LOG_WARN(...)			::UE::Logger::GetEngineLogger()->warn(__VA_ARGS__)
+#define UE_LOG_ERROR(...)			::UE::Logger::GetEngineLogger()->error(__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_DEBUG(...)			::UE::Logger::GetEngineLogger()->debug(__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_ERROR(...)			::UE::Logger::GetEngineLogger()->error(__VA_ARGS__)
+#define GAME_LOG_CRITICAL(...)		::UE::Logger::GetEngineLogger()->critical(__VA_ARGS__)
+
+}

UberEngine/src/Render/Renderer.cpp

@@ -133,7 +133,7 @@ namespace UE
 		//renderQueue.push_back(drawCall);
 	}
 
-	void Renderer::QueueDrawCall(int layer, SDL_Rect & position, SDL_Texture* texture, SDL_Rect & texture_position)
+	void Renderer::QueueDrawCall(int layer, SDL_Rect& position, SDL_Texture* texture, SDL_Rect& texture_position)
 	{
 		DrawCall dc = DrawCall(layer, position, texture, texture_position, false);
 

UberEngine/src/Scene/Scene.cpp

@@ -0,0 +1,29 @@
+#include "Scene.h"
+
+#include <iostream>
+
+namespace UE
+{
+
+	void Scene::SceneInit()
+	{
+		//id = currentID++;
+		std::cout << "Scene has been init!" << std::endl;
+	}
+
+	void Scene::SceneClean()
+	{
+		std::cout << "Scene has been cleaned!" << std::endl;
+	}
+
+	int Scene::GetID()
+	{
+		return id;
+	}
+
+	void Scene::SetID(int newID)
+	{
+		id = newID;
+	}
+
+}

UberEngine/src/Scene/Scene.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <iostream>
 
 ///
 ///	TODO:
@@ -28,16 +29,23 @@ namespace UE
 		void SceneClean();		//Te deja todo limpio y reluciente al salir.
 
 
-		/* Funciones que habrán de overlodear las escenas del usuario. */
+		/* Funciones que habrán de sobrecargar las escenas del usuario. */
-		virtual void SceneLoad();
+		virtual void SceneLoad() { std::cout << "EMPTY SCENE CREATED" << std::endl; }
-		virtual void SceneUpdate();
+		virtual void SceneUpdate() {}
-		virtual void SceneUnload();
+		virtual void SceneUnload() {}
+
+		// ¿Esto sirve para algo?
+		//void loadDataFromFile(std::string path);
+
+		//Retorna el ID de la Scene.
+		int GetID();
+		void SetID(int newID);
 
 
-		void loadDataFromFile(std::string path);
+	protected:
+		//Almacena el ID actual, permitiendo generar un ID nuevo para cada Scene que se instancie.
+		//static uint16_t currentID;
 
-
-	private:
 		int id = 0;
 		//std::vector<Entity> _entidades;
 

UberEngine/src/Scene/SceneManager.cpp

@@ -0,0 +1,77 @@
+#include "SceneManager.h"
+
+#include <iostream>
+
+namespace UE
+{
+
+
+
+
+	void SceneManager::InitSceneManager()
+	{
+		std::cout << "SceneManager Inicializado!" << std::endl;
+	}
+
+	void SceneManager::CleanSceneManager()
+	{
+		if (_currentScene != nullptr)
+		{
+			_currentScene->SceneUnload();
+		}
+
+		for (int i = 0; i < _scenes.size(); i++)
+		{
+			Scene* sc = _scenes.at(i);
+			sc->SceneClean();
+			delete sc;
+		}
+
+		_scenes.clear();
+	}
+
+	int SceneManager::AddScene(Scene* sceneToAdd)
+	{
+		_scenes.push_back(sceneToAdd);
+		sceneToAdd->SceneInit();
+		sceneToAdd->SetID(_scenes.size() - 1);
+		return sceneToAdd->GetID();
+	}
+
+	Scene* SceneManager::GetScenePtr(int ID)
+	{
+		if (ID >= _scenes.size())
+		{
+			std::cout << "El ID de Scene no existe (demasiado grande)." << std::endl;
+			return nullptr;
+		}
+		return _scenes.at(ID);
+	}
+
+	int SceneManager::GetActiveSceneID()
+	{
+		return 0;
+	}
+
+	Scene* SceneManager::GetActiveScenePtr()
+	{
+		return _currentScene;
+	}
+
+	void SceneManager::LoadScene(int ID)
+	{
+		if (_currentScene != nullptr)
+		{
+			_currentScene->SceneUnload();
+		}
+		_currentScene = _scenes.at(ID);
+
+		_currentScene->SceneLoad();
+	}
+
+	void SceneManager::UpdateScene()
+	{
+		_currentScene->SceneUpdate();
+	}
+
+}

UberEngine/src/Scene/SceneManager.h

@@ -1,5 +1,18 @@
 #pragma once
 #include <string>
+#include <vector>
+#include "Scene.h"
+
+// 
+// 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....
+// 
 
 
 namespace UE
@@ -12,13 +25,38 @@ namespace UE
 		/* Constructor */
 		SceneManager() {}
 
-		void SceneManagerInit();
+		void InitSceneManager();
-		void SceneManagerClean();
+		void CleanSceneManager();
 
-		void LoadSceneDataFromFile(std::string filePath);
+		//Añade una escena a la lista y retorna su ID. Son Ptrs, por lo que poco importa donde los almacenamos.
+		int AddScene(Scene* sceneToAdd);
+
+		//Devuelve un ptr a la escena del ID especificado.
+		Scene* GetScenePtr(int ID);
+
+		//Devuelve la escena activa.
+		int GetActiveSceneID();			//NOT WORKING YET!
+		Scene* GetActiveScenePtr();
+
+		//Descarga la escena activa y carga la escena indicada.
+		void LoadScene(int ID);
+
+		//Pasa el Update a la escena actual.
+		//¿Necesita hacer algo más?
+		void UpdateScene();
+
+		// ¿Esto sirve para algo?
+		//void LoadSceneDataFromFile(std::string filePath);
 
 
 	private:
+		Scene* _currentScene = 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::vector<Scene*> _scenes;
+
 
 	};
 

UberEngine/src/UberEngine.h

@@ -1,6 +1,10 @@
 #pragma once
 
-#include "Game.h"
-
 #include "Render\Renderer.h"
+#include "Drawables\Sprite.h"
+
 #include "Assets\AssetManager.h"
+
+#include "Scene\SceneManager.h"
+
+#include "Logging\Logger.h"

UberGame1/Main.cpp

@@ -2,13 +2,15 @@
 
 #include <glm\glm.hpp>
 
-#include "Render\Renderer.h"
+
-#include "Drawables\Sprite.h"
 #include "UberEngine.h"
 
+#include "Scenes\MainScene.hpp"
+#include "Scenes\TestScene2.hpp"
 
 static UE::Renderer* mainRenderer;
 static UE::AssetManager* asManager;
+static UE::SceneManager* scManager;
 
 static bool _quit = false;
 
@@ -25,25 +27,44 @@ int main(int argc, char* args[])
     Loop();
     Clean();
 
-    
-
     return 0;
 }
 
 
 void Init()
 {
+    UE::Logger::InitLogger();
+
     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.");
+
+    scManager = new UE::SceneManager();
+    scManager->InitSceneManager();
+
+    //Añadimos todas las escenas al Manager. No pasa nada, porque el Manager lo iniciamos después 
+    MainScene* scene1 = new MainScene();
+    TestScene2* scene2 = new TestScene2();
+    scManager->AddScene(scene1);
+    scManager->AddScene(scene2);
+
 }
 
 void Load()
 {
     asManager->LoadAssetsFromFile("resources\\AssetList\\MainAssets.json");
     asManager->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.
+    scManager->LoadScene(0);
+    //scManager->LoadScene(0);
 }
 
 
@@ -87,6 +108,7 @@ void Loop()
     double deltaTime = 0;
     const int FPS = 60;
     const int MS_PER_FRAME = 1000 / FPS;
+    float avgFPS;
 
 #pragma endregion
 
@@ -118,6 +140,10 @@ void Loop()
         {
             _quit = true;
         }
+        if (keyStates[SDL_SCANCODE_F])
+        {
+            GAME_LOG_TRACE("FPS: {0} / dT: {1}", avgFPS, deltaTime);
+        }
 
         //FRAME PHYSICS
         //TICK ALL OBJECTS.
@@ -132,8 +158,8 @@ void Loop()
         Uint32 frameTime = SDL_GetTicks() - startTime;
         deltaTime = frameTime / 1000.f;
         //Frames totales / segundos totales.
-        float 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;
 
         //FPS CAP
         if (frameTime < MS_PER_FRAME)
@@ -155,5 +181,7 @@ void Clean()
     mainRenderer->CleanRenderer();
     delete mainRenderer;
 
+    scManager->CleanSceneManager();
+
     SDL_Quit();
 }

UberGame1/Scenes/MainScene.hpp

@@ -0,0 +1,27 @@
+#include "Scene\Scene.h"
+
+#include <iostream>
+
+class MainScene : public UE::Scene
+{
+
+	void SceneLoad() override
+	{
+		std::cout << "Hey! MainScene! - ID: " << id << std::endl;
+	}
+
+	void SceneUpdate() override
+	{
+		std::cout << "MainScene actualizandose! - ID: " << id << std::endl;
+	}
+
+	void SceneUnload() override
+	{
+		std::cout << "MainScene descnsando! - ID: " << id << std::endl;
+	}
+
+
+private:
+	
+
+};

UberGame1/Scenes/TestScene2.hpp

@@ -0,0 +1,24 @@
+#include "Scene\Scene.h"
+
+#include <iostream>
+
+
+class TestScene2 : public UE::Scene
+{
+
+	void SceneLoad() override
+	{
+		std::cout << "Scena de prueba 2 cargada" << id << std::endl;
+	}
+
+	void SceneUpdate() override
+	{
+		std::cout << "TestScene2 actualizandose!" << id << std::endl;
+	}
+
+	void SceneUnload() override
+	{
+		std::cout << "Scene2 descansando." << id << std::endl;
+	}
+
+};