Late Night Codig Time (21/11/21)

UberEngine/src/Assets/Asset.h

@@ -9,27 +9,32 @@ namespace UE
 	/* All types of Assets that can be loadedand stored by an AssetManager */
 	enum class AssetType
 	{
-		Texture = 0, Sound, Other, Unvalid = 15
+		Texture = 0, SpriteSheet, Sound, Other, Unvalid = 15
 	};
-
+	
 	/* Asset struct. Contains info regarding Assets para ser cargados. */
 	struct Asset
 	{
 		Asset() {};
-		Asset(std::string name, std::string path, AssetType type)
+
+		Asset(std::string name, 
+			  std::string path, 
+			  AssetType type)
 			: _name(name), _path(path), _type(type) {}
 
+
 		std::string _name = "";
 		std::string _path = "";
 
+
 		int _ID = NULL;
 		AssetType _type = AssetType::Unvalid;
 	};
 
 	/* Conversión de una struct Asset a JSON */
-	inline void to_json(json& j, const Asset& as)
+	inline void to_json(nlohmann::ordered_json& j, const Asset& as)
 	{
-		j = json
+		j = nlohmann::ordered_json
 		{
 			{"name", as._name},
 			{"Path", as._path},
@@ -39,7 +44,7 @@ namespace UE
 	}
 
 	/* Conversión de un JSON a una struct Asset */
-	inline void from_json(const json& j, Asset& as)
+	inline void from_json(const nlohmann::ordered_json& j, Asset& as)
 	{
 		j.at("name").get_to(as._name);
 		j.at("Path").get_to(as._path);

UberEngine/src/Assets/AssetManager.cpp

@@ -38,6 +38,7 @@ namespace UE
 		//Load Asset data from JSON.
 		json jread = json::parse(file);
 		json Textures = jread["Textures"];
+		json SpriteSheets = jread["SpriteSheets"];
 		json Sounds = jread["Sounds"];
 		json Others = jread["Others"];
 
@@ -45,6 +46,10 @@ namespace UE
 		for (int i = 0; i < Textures.size(); i++) {
 			_assets.push_back(Textures.at(i));
 		}
+		for (int i = 0; i < SpriteSheets.size(); i++)
+		{
+			_assets.push_back(SpriteSheets.at(i));
+		}
 		for (int i = 0; i < Sounds.size(); i++) {
 			_assets.push_back(Sounds.at(i));
 		}
@@ -69,6 +74,11 @@ namespace UE
 					AddTexture(as._name, as._path);
 					break;
 				}
+				case UE::AssetType::SpriteSheet:
+				{
+
+					break;
+				}
 				default:
 				{
 					std::cout << "Can't load Assets." << std::endl;
@@ -106,6 +116,24 @@ namespace UE
 		return _textures.at(TextureName);
 	}
 
+	void AssetManager::AddSpriteSheet(std::string name, std::string spPath)
+	{
+		std::fstream file(spPath.c_str());
+		json jread = json::parse(file);
+
+		int amount = jread.at("TextureAmount").get<int>();
+		int width = jread.at("TextureWidth").get<int>();
+		int height = jread.at("TextureHeight").get<int>();
+		SpriteSheet sp(name, getTexture(name), amount, width, height);
+		_SpriteSheets.insert(std::make_pair(name, sp));
+		_SpriteSheets.at(name).CalculateRects();
+	}
+
+	SpriteSheet& AssetManager::getSpriteSheet(std::string name)
+	{
+		return _SpriteSheets.at(name);
+	}
+
 
 
 

UberEngine/src/Assets/AssetManager.h

@@ -11,7 +11,8 @@
 #include <SDL_image.h>
 
 /*UberEngine Includes*/
-#include <Assets\Asset.h>
+#include "Assets\Asset.h"
+#include "Assets\SpriteSheet.h"
 
 
 ///
@@ -30,7 +31,8 @@ namespace UE
 	{
 	public:
 		/* Constructor. */
-		AssetManager(SDL_Renderer * SDLrenderer, std::string AssetPath = "")
+		AssetManager(SDL_Renderer* SDLrenderer, 
+					 std::string AssetPath = "")
 			: _mainRenderer(SDLrenderer) {}
 
 
@@ -39,7 +41,7 @@ namespace UE
 		*/
 		int AssetManagerInit();
 
-		/* Clean AssetManager Data 
+		/* Clean AssetManager Data on exit
 			- Elimina todos los assets de sus contenedores.
 			- Descarga SDL_IMG
 		*/
@@ -54,12 +56,30 @@ namespace UE
 		int LoadAssetQueue();								//Procesa la queue de carga.
 
 
-		/* Métodos para manejar las SDL_Texture* almacenados. */
+		/* 
+			Métodos para manejar las SDL_Texture* almacenados. 
+		*/
+		//Crea una textura de SDL y la añade al mapa de texturas identificada por su nombre.
 		void AddTexture(std::string name, std::string txPath);
+
+		//Elimina una textura del mapa a partir de su nombre.
 		int RemoveTexture(std::string name);
+
+		//Obtiene una textura del mapa a partir de su nombre.
 		SDL_Texture* getTexture(std::string TextureName);
 
 
+		/*
+			Métodos para manejar los SpriteSheets.
+		*/
+		//Crea un SpriteSheet y lo almacena en el mapa de SpriteSheets, identificado por su nombre.
+		void AddSpriteSheet(std::string name, std::string spPath);
+		//Elimina un SpriteSheet del mapa a partir de su nombre.
+		int RemoveSpriteSheet(std::string name);
+		//Obtiene un SpriteSheet del mapa a partir de su nombre.
+		SpriteSheet& getSpriteSheet(std::string name);
+
+
 		///////DEBUG////////
 		void PrintAssetInfo();
 		///////////////////
@@ -70,7 +90,11 @@ namespace UE
 		std::vector<UE::Asset> _assets = {};
 
 		/* Almacenes de asssets */
+		//Almacén de SDL_Texture* (ptrs).
 		std::unordered_map<std::string, SDL_Texture*> _textures = {};
+		//Almacén de SpriteSheets.
+		std::unordered_map<std::string, SpriteSheet> _SpriteSheets = {};
+
 
 		//Necesario para crear las SDL_Texture a partir de SDL_Surface.
 		SDL_Renderer* _mainRenderer = NULL;

UberEngine/src/Assets/SpriteSheet.h

@@ -0,0 +1,64 @@
+#pragma once
+#include <SDL_render.h>
+#include <vector>
+#include <string>
+
+#include <json.hpp>
+using json = nlohmann::ordered_json;
+
+
+namespace UE
+{
+	//Tipo de Asset que contiene los datos de un SpriteSheet.
+	// Contiene los SDL_Rect de origen y un ptr a la textura correspondiente. 
+	// No almacena su propia textura; está todo en el AssetManager.
+	//Se carga desde un archivo JSON. (Se incluye también un método para guardarlo)
+	class SpriteSheet
+	{
+	public:
+		SpriteSheet(std::string name, 
+					SDL_Texture* texture, 
+					int textureAmount, 
+					int textureWidth, 
+					int textureHeight)
+		: _spriteSheetName(name), _texture(texture), 
+			_textureAmount(textureAmount), _textureWidth(textureWidth), _textureHeight(textureHeight) 
+		{}
+		
+		//Calcula los rects y los almacena en un vector. 
+		//De tal forma que los objetos almacenen un ptr a ese vector en vez de calcular de continuo.
+		void CalculateRects();
+		
+		//Debe coincicidir con el nombre de la textura a la que se asocia.
+		std::string _spriteSheetName = "";
+		int _textureAmount = 1;
+		int _textureWidth = 16;
+		int _textureHeight = 16;
+
+	private:
+		SDL_Texture* _texture = NULL;
+		std::vector<SDL_Rect> _txRects = {};
+
+	};
+
+	inline void to_json(nlohmann::ordered_json& j, const SpriteSheet& sp)
+	{
+		j = nlohmann::ordered_json
+		{
+			{"TextureName", sp._spriteSheetName},
+			{"TextureAmount", sp._textureAmount},
+			{"TextureWidth", sp._textureWidth},
+			{"TextureHeight", sp._textureHeight}
+		};
+	}
+
+	inline void from_json(nlohmann::ordered_json& j, const SpriteSheet& sp)
+	{
+		j.at("TextureName").get_to(sp._spriteSheetName);
+		j.at("TextureAmount").get_to(sp._textureAmount);
+		j.at("TextureWidth").get_to(sp._textureWidth);
+		j.at("TextureHeight").get_to(sp._textureHeight);
+	}
+
+
+}

UberEngine/src/Drawables/Sprite.cpp

@@ -44,15 +44,21 @@ void UE::Sprite::SetLayer(int newLayer)
 
 void UE::Sprite::Draw(Renderer* renderer)
 {
-	SDL_Rect destination;
+	SDL_Rect position = { _pos.x, _pos.y, _size.x, _size.y };
-	destination.x = _pos.x;
+	//destination.x = _pos.x;
-	destination.y = _pos.y;
+	//destination.y = _pos.y;
-
+	//
-	destination.w = _size.x;
+	//destination.w = _size.x;
-	destination.h = _size.y;
+	//destination.h = _size.y;
 
 	//std::cout << "Sprite Rendered to: " << destination.x << "-" << destination.y << std::endl;
-
+	if (_txRect == nullptr)
-	renderer->QueueDrawCall(_layer, _spriteTx, destination);
+	{
+		renderer->QueueDrawCall(_layer, position, _spriteTx);
+	}
+	else
+	{
+		renderer->QueueDrawCall(_layer, position, _spriteTx, *_txRect);
+	}
 }
 

UberEngine/src/Drawables/Sprite.h

@@ -7,6 +7,12 @@
 
 #include "Render\Drawable.h"
 
+//
+// TODO:
+//  - Implementar soporte para SpriteSheets en los constructores.
+//
+//
+//
 
 namespace UE
 {
@@ -34,20 +40,28 @@ namespace UE
 			Los demás parámetros tienen un valor por defecto.
 		*/
 
-		Sprite(std::string texture_Name, AssetManager* assetManager, int renderLayer = 1,
+		Sprite(std::string texture_Name, 
-			glm::vec2 position = glm::vec2(0, 0), glm::vec2 size = glm::vec2(100, 100))
+				AssetManager* assetManager, 
+				int renderLayer = 1,
+				glm::vec2 position = glm::vec2(0, 0), 
+				glm::vec2 size = glm::vec2(100, 100))
+
 			: _layer(renderLayer), _pos(position), _size(size)
 		{
 			SetTexturePtr(texture_Name, assetManager);
 		}
 
-		Sprite(SDL_Texture* texture, int renderLayer = 1,
+		Sprite(SDL_Texture* texture, 
-			glm::vec2 position = glm::vec2(0, 0), glm::vec2 size = glm::vec2(100, 100))
+				int renderLayer = 1,
+				glm::vec2 position = glm::vec2(0, 0), 
+				glm::vec2 size = glm::vec2(100, 100))
+
 			: _layer(renderLayer), _pos(position), _size(size)
 		{
 			SetTexturePtr(texture);
 		}
 
+
 		~Sprite() {}
 
 
@@ -83,6 +97,7 @@ namespace UE
 
 	private:
 		SDL_Texture* _spriteTx = nullptr;
+		SDL_Rect* _txRect = NULL;
 
 		glm::vec<2, float> _pos = glm::vec2(25, 25);
 		glm::vec<2, float> _size = glm::vec2(100, 100);

UberEngine/src/Game.cpp

@@ -1,3 +1,5 @@
+#include <iostream>
+
 #include "Game.h"
 #include "Render\Renderer.h"
 
@@ -56,21 +58,67 @@ int UE::Game::GameLoop()
 
 #pragma endregion
 
-    while (true)
+#pragma region TEMP_FPS_Timer
+
+    Uint32 startTime = SDL_GetTicks();
+    Uint16 countedFrames = 0;
+    double deltaTime = 0;
+    const int FPS = 60;
+    const int MS_PER_FRAME = 1000 / FPS;
+
+#pragma endregion
+
+
+    while (!_quit)
     {
+        startTime = SDL_GetTicks();
+        //TEMP Event Handler:
+        SDL_Event eventHandler;
+        while (SDL_PollEvent(&eventHandler) != 0)
+        {
+            if (eventHandler.type == SDL_QUIT)
+            {
+                _quit = true;
+            }
+        }
+
+        const Uint8* keyStates = SDL_GetKeyboardState(NULL);
+        if (keyStates[SDL_SCANCODE_W])
+        {
+            DestR2.y += 25 * deltaTime;
+        }
+        if(keyStates[SDL_SCANCODE_S])
+        {
+            DestR2.y -= (25 * deltaTime);
+        }
+        if (keyStates[SDL_SCANCODE_ESCAPE])
+        {
+            _quit = true;
+        }
 
-        SDL_RenderClear(renderer->GetSDLRenderer());
         //FRAME PHYSICS
         //TICK ALL OBJECTS.
-        renderer->QueueDrawCall(6, test1, DestR2);
+        renderer->QueueDrawCall(6, DestR2, test1);
-        renderer->QueueDrawCall(1, background, DestR);
+        renderer->QueueDrawCall(1, DestR, background);
 
         renderer->Render(sp1);
         sp2.Draw(renderer);
         //sp3.Draw(renderer);
 
-        renderer->RenderDraw();
+        renderer->RenderFrame();
-        renderer->RenderUpdate();
+        Uint32 frameTime = SDL_GetTicks() - startTime;
+        deltaTime = frameTime / 1000.f;
+        //Frames totales / segundos totales.
+        float avgFPS = countedFrames /  (SDL_GetTicks() / 1000.f);
+        std::cout << "FPS: " << avgFPS << " / " << "dT: " << deltaTime << std::endl;
+
+        //FPS CAP
+        if (frameTime < MS_PER_FRAME)
+        {
+            SDL_Delay(MS_PER_FRAME - frameTime);
+        }
+
+        ++countedFrames;
 
     }
     return 0;

UberEngine/src/Game.h

@@ -49,11 +49,20 @@ namespace UE
         int GameClean();    //Deja todo limpio y brillante por parte del motor. 
                             //Suponemos que con eso limpia también el juego.
 
+
+        /*----Métodos del GameLoop----
+        // Conjunto de métodos que se ejecutan en el GameLoop.
+        */
+        
+        void GameLoopRender();
+        void GameLoopEvents();
+
         /* UE Elements */
         Renderer* renderer;     // To get SDL Renderer use: renderer.getSDLRenderer();
         AssetManager* assetManager;
 
         /* TEMP STUFF */
+        bool _quit = false;
 
         //SceneManager SM;
 

UberEngine/src/Render/Renderer.cpp

@@ -14,14 +14,14 @@ int UE::Renderer::RenderInit()
 		return 1;
 	}
 
-	window = SDL_CreateWindow("UberGame1", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
+	_window = SDL_CreateWindow("UberGame1", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
-	if (window == NULL)
+	if (_window == NULL)
 	{
 		printf("Window could not be created! SDL_Error: %s\n", SDL_GetError());
 		return 1;
 	}
 
-	main_Renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+	main_Renderer = SDL_CreateRenderer(_window, -1, SDL_RENDERER_ACCELERATED);
 	if (main_Renderer == NULL)
 	{
 		printf("Unable to create renderer %s \n", SDL_GetError());
@@ -40,6 +40,30 @@ int UE::Renderer::RenderInit()
 	}
 }
 
+void UE::Renderer::RendererClean()
+{
+	renderQueue.empty();
+
+	SDL_DestroyRenderer(main_Renderer);
+	SDL_DestroyWindow(_window);
+}
+
+
+
+void UE::Renderer::RenderFrame()
+{
+	RenderClear();
+	RenderDraw();
+	RenderUpdate();
+}
+
+
+void UE::Renderer::RenderClear()
+{
+	SDL_RenderClear(main_Renderer);
+
+}
+
 void UE::Renderer::RenderDraw()
 {
 	//Add items to their layer.
@@ -77,6 +101,7 @@ void UE::Renderer::RenderDraw()
 	
 }
 
+
 void UE::Renderer::RenderUpdate()
 {
 	//SDL_UpdateWindowSurface(window);
@@ -84,13 +109,8 @@ void UE::Renderer::RenderUpdate()
 	//SDL_RenderClear(main_Renderer);
 }
 
-void UE::Renderer::RendererClean()
-{
-	renderQueue.empty();
 
-	SDL_DestroyRenderer(main_Renderer);
+
-	SDL_DestroyWindow(window);
-}
 
 void UE::Renderer::DrawObject(SDL_Rect* position, SDL_Rect* texture_pos, SDL_Texture* texture)
 {
@@ -104,13 +124,13 @@ void UE::Renderer::QueueDrawCall(DrawCall drawCall)
 	renderQueue.push_back(drawCall);
 }
 
-void UE::Renderer::QueueDrawCall(int layer, SDL_Texture* texture, SDL_Rect & texture_position, SDL_Rect & position)
+void UE::Renderer::QueueDrawCall(int layer, SDL_Rect & position, SDL_Texture* texture, SDL_Rect & texture_position)
 {
 	DrawCall dc = DrawCall(layer, position, texture, texture_position, false);
 	renderQueue.push_back(dc);
 }
 
-void UE::Renderer::QueueDrawCall(int layer, SDL_Texture* texture, SDL_Rect & position)
+void UE::Renderer::QueueDrawCall(int layer, SDL_Rect & position, SDL_Texture* texture)
 {
 	//std::cout << "Drawable added to queue";
 	DrawCall dc = DrawCall(layer, position, texture);

UberEngine/src/Render/Renderer.h

@@ -7,6 +7,13 @@
 
 #include "Drawable.h"
 
+//
+// TODO:
+//  - Optimizar RenderDraw moviendo la ordenación por capas a Queue, quitando renderQueue.
+//
+//
+//
+
 namespace UE
 {
 	struct DrawCall;
@@ -17,7 +24,10 @@ namespace UE
 
 	public:
 		/* Constructor */
-		Renderer(int windowWidth, int windowHeight, int renderingLayers = 10)
+		Renderer(int windowWidth, 
+				 int windowHeight, 
+				 int renderingLayers = 10)
+
 			: SCREEN_WIDTH(windowWidth), SCREEN_HEIGHT(windowHeight), LAYER_AMOUNT(renderingLayers)
 		{
 			printf("Renderer Created");
@@ -32,23 +42,19 @@ namespace UE
 		*/
 		int RenderInit();
 
-		//Ordena por layer todos los objetos de la renderQueue y los dibuja en orden.
-		//Se puede mover el proceso de ordenado a otra función, con el objeto de ir vaciando la Queue.
-		void RenderDraw();
-
-		//Hace el swap del render buffer (tras dibujar todos los objetos). Termina el renderizado.
-		void RenderUpdate();
-
 		/* Limpia todo antes de salir. */
 		void RendererClean();
 
-		//Función para renderizar un objeto un objeto en concreto.
+
-		void DrawObject(SDL_Rect* position, SDL_Rect* texture_pos, SDL_Texture* texture);
+		//Realizar RenderClear(), RenderDraw() y RenderUpdate();
+		//Es decir, todo lo necesario para renderizar un frame.
+		void RenderFrame();
+
 
 		//Añade un DrawCall al renderQueue.
 		void QueueDrawCall(DrawCall drawCall);
-		void QueueDrawCall(int layer, SDL_Texture* texture, SDL_Rect& texture_position, SDL_Rect& position);
+		void QueueDrawCall(int layer, SDL_Rect& position, SDL_Texture* texture, SDL_Rect& texture_position);
-		void QueueDrawCall(int layer, SDL_Texture* texture, SDL_Rect & position);
+		void QueueDrawCall(int layer, SDL_Rect & position, SDL_Texture* texture);
 
 		//Le pasamos el este renderer al Drawable para que haga lo que quiera.
 		//Como si quiere usar el SDL_Renderer, es libre.
@@ -57,9 +63,28 @@ namespace UE
 		/* Get SDL Renderer. */
 		SDL_Renderer* GetSDLRenderer() { return main_Renderer; }
 
+
+		//DEBUG
+		//Función para renderizar un objeto un objeto en concreto.
+		void DrawObject(SDL_Rect* position, SDL_Rect* texture_pos, SDL_Texture* texture);
+
+
+	private:
+		//Hace el SDL_RenderClear() para limpiar el buffer al principio de un nuevo frame.
+		void RenderClear();
+
+		//Ordena por layer todos los objetos de la renderQueue y los dibuja en orden.
+		//Se puede mover el proceso de ordenado a otra función, con el objeto de ir vaciando la Queue.
+		void RenderDraw();
+
+		//Hace el swap del render buffer (tras dibujar todos los objetos). Termina el renderizado.
+		void RenderUpdate();
+
+
+
 	private:
 		/* Objetos de SDL para el rendering. */
-		SDL_Window* window = NULL;
+		SDL_Window* _window = NULL;
 		SDL_Surface* screenSurface = NULL;
 		SDL_Renderer* main_Renderer = NULL;
 
@@ -84,7 +109,12 @@ namespace UE
 	*/
 	struct DrawCall
 	{
-		DrawCall(int layer, SDL_Rect position, SDL_Texture* texture, SDL_Rect texture_position = SDL_Rect(), bool renderFullTexture = true)
+		DrawCall(int layer, 
+			SDL_Rect position, 
+			SDL_Texture* texture, 
+			SDL_Rect texture_position = SDL_Rect(),
+			bool renderFullTexture = true)
+
 			: layer(layer), fullTexture(renderFullTexture), tx(texture), tx_rect(texture_position), pos_rect(position) 
 		{}
 

resources/AssetList/MainAssets.json

@@ -30,5 +30,10 @@
             "Type": 0,
             "ID": 5
         }
-    ]
+    ],
+	"SpriteSheets": [
+		{
+			
+		},
+	]
 }

resources/AssetList/spriteSheet1.json

@@ -0,0 +1,3 @@
+{
+	
+}