UberElectron/UberEngine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Nuevo sistema de Escenas.

Browse Source 
Nos quitamos del medio la cosa rara del SceneBuilder.
Simplificamos la estructura y la hacemos más o menos segura.
This commit is contained in:
Daniel-Garmig
2022-08-11 12:57:40 +02:00
parent ce1886d3db
commit b2d6a31275
14 changed files with 316 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+3
View File
@@ -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/Scene/Scene.cpp
+5 -3
View File
@@ -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
+49 -18
View File
@@ -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.cpp
View File
UberEngine/src/Scene/SceneBuilder.h
-18
View File
@@ -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
+101 -59
View File
@@ -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
+77 -38
View File
@@ -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.h
+2 -2
View File
@@ -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
-48
View File
@@ -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
+7 -8
View File
@@ -7,7 +7,6 @@
#include <ImGui/imgui_impl_opengl3.h>
#include "UberGame1.h"
#include "GameScenes.hpp"
#include "UberEngine.h"
@@ -33,7 +32,6 @@ int main(int argc, char* args[])
return 0;
}
void Init()
{
UE::Logger::InitLogger();
@@ -51,7 +49,8 @@ void Load()
//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);
Game::GetSceneManager()->LoadScene(new MainScene());
Game::GetSceneManager()->SwitchScene("MainScene");
}
@@ -98,7 +97,7 @@ void Loop()
if (io.WantCaptureMouse) { continue; }
Game::GetSceneManager()->GetActiveScenePtr()->SceneHandleEvents(&eventHandler);
Game::GetSceneManager()->GetCurrentScenePtr()->SceneHandleEvents(&eventHandler);
if (eventHandler.type == SDL_QUIT)
{
_quit = true;
@@ -113,10 +112,10 @@ void Loop()
switch (eventHandler.key.keysym.sym)
{
case SDLK_1:
Game::GetSceneManager()->NewLoadScene(LasEscenas::mainMenu);
Game::GetSceneManager()->LoadAndSwitchScene(new MainScene());
break;
case SDLK_2:
Game::GetSceneManager()->NewLoadScene(LasEscenas::nivel1);
Game::GetSceneManager()->LoadAndSwitchScene(new TestScene2());
break;
default:
break;
@@ -159,7 +158,7 @@ void Loop()
Game::GetRenderer()->SetCamPosition(camPos.x, camPos.y);
}
Game::GetSceneManager()->GetActiveScenePtr()->SceneUpdate();
Game::GetSceneManager()->GetCurrentScenePtr()->SceneUpdate();
//Game::GetRenderer()->QueueDrawCall(4, DestR2, test1);
//Game::GetRenderer()->QueueDrawCall(1, DestR, background);
@@ -173,7 +172,7 @@ void Loop()
Game::GetRenderer()->NewFrame();
//Renderiza la escena.
Game::GetSceneManager()->GetActiveScenePtr()->SceneRender();
Game::GetSceneManager()->GetCurrentScenePtr()->SceneRender();
//As� podemos renderizar cosas de ImGui cuando estemos entre NewFrame y EndFrame.
bool show = true;
UberGame1/Scenes/MainScene.hpp
+4 -1
View File
@@ -23,7 +23,10 @@ class MainScene : public UE::Scene
{
public:
MainScene(std::string sceneName) : Scene(sceneName) {}
MainScene() : Scene("MainScene")
{
//_sceneName = "MainScene";
}
void SceneLoad() override
UberGame1/Scenes/TestScene2.hpp
+4 -1
View File
@@ -18,7 +18,10 @@ class TestScene2 : public UE::Scene
{
public:
TestScene2(std::string sceneName) : Scene(sceneName) {}
TestScene2() : Scene("TestScene")
{
//_sceneName = "TestScene";
}
void SceneLoad() override
{
UberGame1/UberGame1.cpp
+5 -9
View File
@@ -5,9 +5,6 @@
#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"
@@ -16,24 +13,23 @@ UE::Renderer* Game::mainRenderer;
UE::AssetManager* Game::asManager;
UE::SceneManager* Game::scManager;
GameScenes Game::_sceneBuilder;
void Game::InitGame()
{
//Cargamos el Renderer.
//Hay que implementar un sistema de flags o
// una struct de configuración para la inicialización del renderer.
mainRenderer = new UE::Renderer(640, 480, 5);
mainRenderer->InitRenderer();
UE_LOG_INFO("Renderer Created.");
//Cargamos el AssetManager
asManager = new UE::AssetManager(mainRenderer->GetSDLRenderer());
asManager->InitAssetManager();
UE_LOG_INFO("AssetManager Created.");
//Creamos el SceneBuilder de este juego.
_sceneBuilder = GameScenes();
//Cargamos el SceneManager
scManager = new UE::SceneManager();
scManager->InitSceneManager(&_sceneBuilder);
}
void Game::CleanGame()
UberGame1/UberGame1.h
-5
View File
@@ -5,11 +5,8 @@ namespace UE
class Renderer;
class AssetManager;
class SceneManager;
class SceneBuilder;
}
class GameScenes;
class Game
{
public:
@@ -25,6 +22,4 @@ private:
static UE::Renderer* mainRenderer;
static UE::AssetManager* asManager;
static UE::SceneManager* scManager;
static GameScenes _sceneBuilder;
};