Migración del Renderer al nuevo sistema de Drawables.

El Renderer extrae los datos de los drawables, eliminando la clase DrawCall.
Los Drawables utilizan los nuevos Drawables. Aunque falta pulir la forma en que lo hacen.

GenProject.bat

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

UberEngine/src/Assets/AssetManager.h

@@ -19,15 +19,16 @@ 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
 ///      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
 {
@@ -109,8 +110,11 @@ namespace UE
         //Elimina una textura del mapa a partir de su nombre.
         void RemoveTexture(std::string name);
 
-        //Obtiene una textura del mapa a partir de su nombre.
+        /*
-        //inline SDL_Texture* getTexture(std::string textureName) { return _textures.at(textureName); }
+            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).
+        */
         inline Texture* getTexture(std::string textureName) { return _textures.at(textureName); }
 
         //inline std::vector<SDL_Rect>* getTexureRects(std::string textureName) { return &_textureRects.at(textureName); }

UberEngine/src/Assets/Texture.cpp

@@ -23,6 +23,22 @@ SDL_Rect* UE::Texture::GetTextureRect(int i)
 
 }
 
+
+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);

UberEngine/src/Assets/Texture.h

@@ -8,7 +8,7 @@
 
 namespace UE
 {
-
+    //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:
@@ -19,9 +19,19 @@ namespace UE
         Texture(std::string dataPath, SDL_Renderer* renderer)
             : _dataPath(dataPath), _SDL_Renderer(renderer)
         {
+            //REWORK -> En el Loader, estaría bien poder saber si se ha cargado o no. 
+            //  Para no añadirla al mapa de texturas y hacer fallback en la por defecto.
             InitTexture();
         }
 
+        //HACK Texture() -> Lo utilizaremos únicamente para poder crear Texture vacias, hasta que separemos el loader.
+        Texture()
+        {
+            //Creo que no es necesario nada...
+            _dataPath = "";
+            _txPath = "";
+        }
+
         ~Texture()
         {
             CleanTexture();
@@ -48,7 +58,20 @@ namespace UE
         * @param i : �ndice del rect.
         * @return El SDL_Rect* solicitado (o el por defecto en caso de error).
         */
-        SDL_Rect* GetTextureRect(int i);
+        SDL_Rect* GetTextureRect(int i); // -> Devolver un SDL_Rect, el Ptr ocupa incluso más.
+
+
+        //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);
+
+
+        /*
+            M�todo que a�ade un SDL_Rect al vector correspondiente.
+            @param newRect : Nuevo Rect que a�adir al vector de Rects.
+            NOTA para REWORK -> Estaba en privado. Lo he movido aquí porque será público, pero no modificable si es const.
+        */
+        void AddRect(SDL_Rect newRect);
 
 
     private:
@@ -67,11 +90,6 @@ namespace UE
         */
         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 ------

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,86 @@
+#pragma once
+
+#include "Interfaces/Transformable.h"
+
+#include <SDL_rect.h>
+
+namespace UE
+{
+    class Renderer;
+    class Texture;
+
+    /*
+    * Clase base para renderizar objetos en el mundo.
+    * El renderer extrae los datos necesarios de esta clase para renderizar el objeto.
+    */
+    class Drawable : public Transformable
+    {
+    public:
+
+        Drawable() {}
+
+        ~Drawable() {}
+
+
+        ////////////////////////////////////////////////////////
+
+
+        //Get-Set del renderLayer.
+        inline void SetLayer(int newLayer) { _renderLayer = newLayer; }
+        inline int GetLayer() { return _renderLayer; }
+
+
+        ////////////////////////////////////////////////////////
+
+
+        inline bool IsActive() { return isActive; }
+        inline void SetActive(bool active) { isActive = active; }
+
+
+        //¿Añadir funciones para cambiar las variables? ¿Al menos, para actualizar el actualRect de alguna forma?
+
+
+    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 Drawables.
+        * Sirve para actualizar la información que hay en el drawable para hacer el rendering.
+        * Constituye la primera parte del draw. En la que se actualizan los datos del Drawable.
+        * La segunda parte, ocurre en el renderer, que extraerá los datos del Drawable.
+        */
+        virtual void Draw(Renderer* renderer) = 0;
+
+
+    protected:
+        
+        //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;
+
+        //UE::Texture contiene una lista de rects, con esto, podemos seleccionar el rect que queramos.
+        //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;
+        
+        
+        ////////////////////////////////////////////////////////
+
+
+        //Indica en qué layer del renderer está el objeto (z order).
+        int _renderLayer = 0;
+
+
+        ////////////////////////////////////////////////////////
+
+
+        //Permite activar o desactivar el Drawable. Si está desactivado, no se debería de renderizar/ejecutar.
+        bool isActive = true;
+
+    };
+}

UberEngine/src/Drawables/Sprite.cpp

@@ -9,31 +9,21 @@
 
 void UE::Sprite::SetTextureRect(int textureID)
 {
-    SDL_Rect* newRect = _texture->GetTextureRect(textureID);
+    _txRectID = textureID;
+    SDL_Rect* newRect = _tx->GetTextureRect(textureID);
 
     if (newRect != nullptr)
     {
-        _actualTxRect = newRect;
+        _txRect = *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;
@@ -42,12 +32,6 @@ void UE::Sprite::Draw(Renderer* renderer)
     //destination.h = _size.y;
 
     //std::cout << "Sprite Rendered to: " << destination.x << "-" << destination.y << std::endl;
-    renderer->QueueDrawCall(_renderLayer, position, _texture->GetTexture(), *_actualTxRect);
+    //renderer->QueueDrawCall(_renderLayer, position, _tx->GetTexture(), _txRect);
-}
-
-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.
 //
 //
@@ -23,7 +23,7 @@ namespace UE
 {
     class Renderer;
 
-    class Sprite : public Drawable, public Transformable
+    class Sprite : public Drawable
     {
 
 
@@ -35,26 +35,29 @@ namespace UE
         // --------------
         */
 
+        //NOTA: Hay que implementar una textura por defecto, que será la que se usará cuando no se indique nada.
+        // De esta forma, podemos tener constructores por defecto.
+
         /*
-            Se establecen todos los par�metos.
+            Se establecen todos los parámetos.
             La textura es obligatoria, y puede ha de darse:
-                - En SDL_Texture* -> Sin m�s, se entiende.
+                - 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.
-            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.
+            \param textureRectID: El número de Rect del conjunto de rects. Por defecto será 0 (La textura completa).
-            \param textureRectID: El n�mero de Rect del conjunto de rects.
+            \param renderLayer: La Layer en que se renderizará.
-            \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))
-
-            : _texture(texture)
         {
+            _tx = texture;
+
             SetTextureRect(textureRectID);
 
             SetLayer(renderLayer);
@@ -63,36 +66,35 @@ namespace UE
             SetSize(size);
         }
 
-
         ~Sprite() {}
 
 
+        ////////////////////////////////////////////////////////
+
+
         //-----------
-        //- Setters -
+        //- Methods -
         //-----------
 
 
         void SetTextureRect(int textureID);
 
-        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;
-
 
     };
 

UberEngine/src/Drawables/TextBox.cpp

@@ -1,8 +1,11 @@
 #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;
@@ -34,31 +37,30 @@ 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)
+    if (_tx->GetTexture() == 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.
-    SDL_Rect dest = { _pos.x, _pos.y, _size.x, _size.y };
+    // Ya no es necesario....
+    //SDL_Texture* tx = _textTexture.GetTexture();
 
-    renderer->QueueDrawCall(_renderLayer, dest, _textTexture);
+    //renderer->QueueDrawCall(_renderLayer, dest, _textTexture);
+    
+    //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.
     SDL_Color color = { _textColor.x,_textColor.y, _textColor.z, _textColor.w };
@@ -74,8 +76,8 @@ void UE::TextBox::RenderTextTexture()
         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}",
             _text, SDL_GetError());
@@ -86,4 +88,22 @@ void UE::TextBox::RenderTextTexture()
 
     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,18 +5,20 @@
 #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;
 
-    class TextBox : public Drawable, public Transformable
+
+    class TextBox : public Drawable
     {
 
     public:
@@ -30,6 +32,15 @@ namespace UE
             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);
@@ -38,28 +49,90 @@ namespace UE
             RenderTextTexture();
         }
 
+
+        ~TextBox()
+        {
+            //Hay que limpiar lo que ocupamos.
+            //delete _textTexture;
+            delete _tx;
+        }
+
+
+        // Si se realiza una copia, necesitamos que esta utilice su propia textura.
+        // Así, si queremos copiar una para luego modificarla, no se modifican las dos.
+        // (Y si una se borra no se lleva consigo los ptrs de las 2).
+        TextBox(const TextBox& c)
+            : _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;
+        UE_Color _textColor = {255, 255, 255, 255};
+
+
+        ////////////////////////////////////////////////////////
+
+
+        //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;
 
-        SDL_Texture* _textTexture = nullptr;
 
         //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.

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/Render/Camera.h

@@ -6,6 +6,7 @@
 // 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.
 //
 
 

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

@@ -9,6 +9,7 @@
 
 
 #include "Renderer.h"
+#include "Assets/Texture.h"
 #include "Logging/Logger.h"
 
 namespace UE
@@ -36,43 +37,42 @@ namespace UE
         SDL_SetRenderDrawColor(main_Renderer, 0xFF, 0xFF, 0xFF, 0xFF);
 
 
-#pragma region ImGui.
 
+        //Inicializamos Dear ImGui con el SDL_Renderer.
         IMGUI_CHECKVERSION();
         ImGui::CreateContext();
         ImGuiIO& io = ImGui::GetIO(); 
-        (void)io;  //Evita que de un Warning por variable no usada.
+        (void)io;  //Evita que de un Warning por variable no usada. Este C++ es demasiado avanzado.
 
         ImGui::StyleColorsDark();
 
         ImGui_ImplSDL2_InitForSDLRenderer(_window, main_Renderer);
         ImGui_ImplSDLRenderer_Init(main_Renderer);
 
-#pragma endregion
 
 
-        //Init layers.
+        //Init layers for World Rendering.
         for (int i = 0; i <= LAYER_AMOUNT; i++)
         {
-            renderLayers.push_back(std::vector<DrawCall>());
+            worldLayers.push_back(std::vector<Drawable*>());
         }
 
     }
 
     void Renderer::CleanRenderer()
     {
-        renderQueue.empty();
+        //Limpiamos ImGui
-
         ImGui_ImplSDLRenderer_Shutdown();
         ImGui_ImplSDL2_Shutdown();
         ImGui::DestroyContext();
 
+        //Limpiamos SDL.
         SDL_DestroyRenderer(main_Renderer);
         SDL_DestroyWindow(_window);
     }
 
 
-
+    //NOTA No sé para qué sirve el método RenderFrame(), es privado. ¿Eliminar método?
     void Renderer::RenderFrame()
     {
         NewFrame();
@@ -89,9 +89,13 @@ namespace UE
         ImGui_ImplSDL2_NewFrame();
         ImGui::NewFrame();
 
-        //Quiz�s deber�amos limpiar la cola y las Layers aqu� para eliminar residuos...
+
-        //callCounter = 0;
+        //Comprobamos que la cámara sigue existiendo.
-        //rendererCounter = 0;
+        if (activeCam == nullptr)
+        {
+            //Si no existe la cámara activa, utilizamos la por defecto.
+            ResetCamera();
+        }
 
         //Actualizamos el rect que representa la pantalla.
         glm::ivec2 camPos = activeCam->GetCamPosition();
@@ -100,40 +104,38 @@ namespace UE
 
     void Renderer::RenderData()
     {
-        //Add items to their layer.
+
-        for (int i = 0; i < renderQueue.size(); i++)
+        //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++)
         {
-            DrawCall item = renderQueue.at(i);
+            //Extract layer j.
+            std::vector<Drawable*>& layer = worldLayers.at(j);
 
-            //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);
+                //Extract Drawable k
-                if (item.fullTexture)
+                Drawable* item = layer.at(k);
-                {
+
-                    SDL_RenderCopy(main_Renderer, item.tx, NULL, &item.pos_rect);
+                SDL_Texture* tx = item->_tx->GetTexture();
-                    continue;
+
-                }
+                //Los están en WorldCoords. Convertimos la posición a ScreenCoords.
-                SDL_RenderCopy(main_Renderer, item.tx, &item.tx_rect, &item.pos_rect);
+                // NOTA: Se deberá transformar todo el Rect en función de la cam, no sólo la pos.
+                glm::ivec2 screenCoords = 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.
+        ImGui::Render();
+        ImGui_ImplSDLRenderer_RenderDrawData(ImGui::GetDrawData());
+    
     }
 
     void Renderer::EndFrame()
@@ -141,9 +143,6 @@ namespace UE
         //SDL_UpdateWindowSurface(window);
         //SDL_RenderPresent(main_Renderer);
         //SDL_RenderClear(main_Renderer);
-        ImGui::Render();
-        
-        ImGui_ImplSDLRenderer_RenderDrawData(ImGui::GetDrawData());
 
         SDL_RenderPresent(main_Renderer);
 
@@ -151,6 +150,31 @@ namespace UE
     }
 
 
+    void Renderer::Render(Drawable& drawable)
+    {
+        drawable.Draw(this);
+
+        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;
+        }
+        // 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);
+
+    }
 
 
 
@@ -187,7 +211,7 @@ namespace UE
         return fPos;
     }
 
-    //CREO QUE ESTE M�TODO NO FUNCIONA.
+    //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)
     {
@@ -209,45 +233,4 @@ namespace UE
     }
 
 
-
-    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.
-        // if(!IsObjectVisible(&drawCall.pos_rect))
-        // {
-        //     //Si no es visible, no lo renderizaríamos.
-        //     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,12 +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.
 //
@@ -20,9 +19,6 @@
 
 namespace UE
 {
-    struct DrawCall;
-
-
     class Renderer
     {
 
@@ -36,59 +32,119 @@ namespace UE
         {
             screenSize.x = windowWidth;
             screenSize.y = windowHeight;
+            activeCam = &defaultCam;
             //UE_LOG_INFO("Game Renderer Created.");
         }
 
 
+        ////////////////////////////////////////////////////////
+
+
         /* Inicializa los componentes necesarios: 
-            - Inicializa SDL
             - Crea la ventana.
             - Crea el renderer.
-            - ...
+            - Inicia ImGUI.
+            - Genera las layers.
         */
         int InitRenderer();
 
-        /* Limpia todo antes de salir. */
+        /* Limpia todo antes de salir. 
+        *   - Apaga ImGui.
+        *   - Destruye el renderer.
+        *   - Destruye la ventana.
+        */
         void CleanRenderer();
 
 
+        ////////////////////////////////////////////////////////
 
 
-        //Hace el SDL_RenderClear() para limpiar el buffer al principio de un nuevo frame.
+        /*
+        * Hace el SDL_RenderClear() para limpiar el buffer al principio de un nuevo frame.
+        */
         void NewFrame();
 
-        //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.
+        * 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.
+        /*
+        * Hace el swap del render buffer (tras dibujar todos los objetos). 
+        * Termina el renderizado.
+        */
         void EndFrame();
 
 
-        //A�ade un DrawCall al renderQueue.
+        /*
-        void QueueDrawCall(DrawCall drawCall);
+        * Rendiriza el Objeto indicado.
-        void QueueDrawCall(int layer, SDL_Rect& position, SDL_Texture* texture, SDL_Rect& texture_position);
+        * El proceso consta de dos partes:
-        void QueueDrawCall(int layer, SDL_Rect & position, SDL_Texture* texture);
+        *   - 1º: El objeto hará las modificaciones necesarias a sus datos.
-
+        *   - 2º: El Renderer extraerá los datos de Drawable y lo renderizará.
-        //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; }
 
+        ///////////////////////////////////////////////////////
+
+
+        /* Get SDL Renderer. */
+        inline SDL_Renderer* GetSDLRenderer() { return main_Renderer; }
+
+
+        ////////////////////////////////////////////////////////
+
+
+        /*
+        * Get windows/screen size.
+        */
         inline glm::ivec2 GetScreenSize() { return screenSize; }
+
+        /*
+        * 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);
 
-        //Permite cambiar el color de fondo.
+        
+        ////////////////////////////////////////////////////////
+
+
+        /*
+        * Cambiar el color del fondo.
+        */
         void SetDrawingColor(SDL_Color& newColor);
 
-        //Cambia la cámara que se utiliza en el renderizado.
+
+        ////////////////////////////////////////////////////////
+
+
+        /*
+        * Set the active cámera.
+        */
         inline void SetCamera(Camera* newCam) { activeCam = newCam; }
+
+        /*
+        * Get a ptr to the active camera.
+        */
         inline Camera* GetCamera() { return activeCam; }
 
 
+        /*
+        * Cambia la cámara activa a la cámara por defecto.
+        * Utilizado el eliminar una cámara o cuando la activeCam ya no existe.
+        */
+        inline void ResetCamera() { activeCam = &defaultCam; }
+
+
+        ////////////////////////////////////////////////////////
+
+
         /* M�todos para transformar las coordenadas entre Screen y Wolrd. */
         //WorldCoords = ScreenPos + CamPos -> ScreenPos = WorldCoords - CamPos;
 
@@ -97,11 +153,18 @@ namespace UE
         //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);
@@ -110,36 +173,42 @@ namespace UE
     private:
         //Realizar RenderClear(), RenderDraw() y RenderUpdate();
         //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:
         /* 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;
+        std::vector<std::vector<Drawable*>> worldLayers;
 
 
-        //int screenWidth = 640;
+        ////////////////////////////////////////////////////////
-        //int screenHeight = 480;
+
 
         glm::ivec2 screenSize{ 640,480 };
 
+        SDL_Rect _screenRect{ 0, 0, screenSize.x, screenSize.y };
+
+        
+        ////////////////////////////////////////////////////////
+
+
         //glm::ivec2 camPosition{ 0,0 };
         Camera* activeCam;
+        Camera defaultCam = Camera(0, 0);
 
-        SDL_Rect _screenRect{ 0, 0, screenSize.x, screenSize.y};
 
 
         //DEBUG
@@ -148,37 +217,4 @@ namespace UE
 
     };
 
-    /* 
-        Contiene los valores necesarios para realizar el renderizado con SDL_RenderCopy();
-        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)
-        {}
-
-        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;
-
-        SDL_Texture* tx;
-        SDL_Rect tx_rect;
-
-        SDL_Rect pos_rect;
-    };
-
 }

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.h

@@ -3,10 +3,7 @@
 #include <string>
 #include <iostream>
 
-///
+
-///	TODO:
-/// 
-/// 
 union SDL_Event;
 
 namespace UE

UberEngine/src/Scene/SceneManager.h

@@ -8,8 +8,13 @@
 
 //
 // TODO:
-//  - Se podría plantear un sistema de carga asincrona para las escenas.
+// - 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.
+// - Añadir un método para recargar la escena actual. La descarga entera y la vuelve a cargar.
+// - La variable "loaded" de las escenas no tiene mucha utilidad en este momento.
+
+
+// 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
 {
@@ -41,7 +46,7 @@ namespace UE
          * 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.
+         * 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);
 

UberGame1/Main.cpp

@@ -14,6 +14,7 @@
 #include "Scenes/MainScene.hpp"
 #include "Scenes/TestScene2.hpp"
 
+
 static bool _quit = false;
 
 int Init();

UberGame1/Scenes/MainScene.hpp

@@ -63,8 +63,10 @@ public:
 
 		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);
 	}
 

UberGame1/Scenes/TestScene2.hpp

@@ -112,7 +112,7 @@ 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;
@@ -195,8 +195,8 @@ private:
 	}
 
 private:
-	const int vAmount = 10;
+	const int vAmount = 256;
-	const int hAmount = 10;
+	const int hAmount = 256;
 
 
 	std::vector<UE::Sprite> sprites = {};