Event Handlers para Escenas y pruebas con Dear ImGui.

Se a añadido un nuevo método a las escenas que permite pasar eventos para procesarlos.
He realizado pruebas varias con Dear ImGui.

UberEngine/src/Drawables/Sprite.cpp

@@ -3,6 +3,7 @@
 #include "Render\Renderer.h"
 #include "Assets\AssetManager.h"
 
+#include "Logging\Logger.h"
 
 #include <iostream>
 
@@ -11,6 +12,16 @@ void UE::Sprite::SetTextureRect(int textureID)
 	_actualTxRect = &_txRects->at(textureID);
 }
 
+void UE::Sprite::SetActive(bool active)
+{
+	isActive = active;
+}
+
+bool UE::Sprite::IsActive()
+{
+	return isActive;
+}
+
 
 void UE::Sprite::Draw(Renderer* renderer)
 {

UberEngine/src/Drawables/Sprite.h

@@ -73,6 +73,9 @@ namespace UE
 
 		void SetTextureRect(int textureID);
 
+		void SetActive(bool active);
+		bool IsActive();
+
 		//Implementa el Draw de Drawable.
 		void Draw(Renderer* renderer) override;
 
@@ -87,6 +90,8 @@ namespace UE
 		//El que se va a renderizar.
 		SDL_Rect* _actualTxRect = nullptr;
 
+		bool isActive = true;
+
 
 	};
 

UberEngine/src/Render/Renderer.cpp

@@ -169,7 +169,7 @@ namespace UE
 	{
 		camPosition.x = posX;
 		camPosition.y = posY;
-		UE_LOG_TRACE("Cam position chaged to: {0}x{1}", posX, posY);
+		//UE_LOG_TRACE("Cam position chaged to: {0}x{1}", posX, posY);
 	}
 
 	//¿Deberíamos operar la posición para que tenga en cuenta la cámara?
@@ -189,6 +189,14 @@ namespace UE
 			return;
 		}
 		
+		//Comprobamos si el objeto es visible (está dentro de la cámara). En caso contrario, no tiene sentido renderizarlo.
+		SDL_Rect screen{ camPosition.x, camPosition.y, screenSize.x, screenSize.y };
+		if (!SDL_HasIntersection(&screen, &drawCall.pos_rect))
+		{
+			//UE_LOG_TRACE("Se omite el renderizado de un objeto al estar fuera de la cámara.");
+			return;
+		}
+
 		//Convertimos la posición del objeto de WorldCoords y ScreenCoords relativas a la camPosition.
 		//Únicamente cambiamos las coords. Se podría añadir un modificador para el tamaño en relación al tamaño de la cam o algo así.
 		//WorldCoords = ScreenPos + CamPos -> ScreenPos = WorldCoords - CamPos;

UberEngine/src/Scene/Scene.h

@@ -8,7 +8,7 @@
 ///  - Scene debería ser serializable y cargable desde archivos, al menos para las clases derivadas. ( o quizás no....)
 /// 
 /// 
-
+union SDL_Event;
 
 namespace UE
 {
@@ -33,8 +33,9 @@ namespace UE
 
 		/* Funciones que habrán de sobrecargar las escenas del usuario. */
 		virtual void SceneLoad() { std::cout << "EMPTY SCENE CREATED" << std::endl; }
-		virtual void SceneRender() { std::cout << "EMPTY SCENE IS BEING RENDERED" << std::endl; }
+		virtual void SceneRender() {}
 		virtual void SceneUpdate() {}
+		virtual void SceneHandleEvents(SDL_Event* event) {}
 		virtual void SceneUnload() { std::cout << "EMPTY SCENE DESCARGADA" << std::endl; }
 
 		// ¿Esto sirve para algo?

UberGame1/Main.cpp

@@ -92,6 +92,7 @@ void Loop()
         while (SDL_PollEvent(&eventHandler) != 0)
         {
             ImGui_ImplSDL2_ProcessEvent(&eventHandler);
+            Game::GetSceneManager()->GetActiveScenePtr()->SceneHandleEvents(&eventHandler);
             if (eventHandler.type == SDL_QUIT)
             {
                 _quit = true;

UberGame1/Scenes/MainScene.hpp

@@ -14,6 +14,8 @@
 #include <vector>
 #include <SDL.h>
 
+#include <ImGui\imgui.h>
+
 class MainScene : public UE::Scene
 {
 public:
@@ -63,21 +65,154 @@ public:
 		UE::Renderer* renderer;
 		renderer = Game::GetRenderer();
 
-		for (UE::Sprite sp : sprites)
+		for (UE::Sprite& sp : sprites)
+		{
+			//Si el obj. no está activo, lo saltamos.
+			if (sp.IsActive()) 
 			{
 				renderer->Render(sp);
 			}
 		}
 
+		ImguiRender();
+	}
+
+	void SceneHandleEvents(SDL_Event* event)
+	{
+		if (event->type == SDL_KEYDOWN)
+		{
+			switch (event->key.keysym.sym)
+			{
+			case SDLK_p:
+				sprites.at(_selectedSprite).SetActive(false);
+				break;
+			case SDLK_o:
+				sprites.at(_selectedSprite).SetActive(true);
+				break;
+			case SDLK_i:
+			{
+				sprites.at(_selectedSprite).SetSize(125, 185);
+				break;
+			}
+			case SDLK_F2:
+				debugGUI = !debugGUI;
+			default:
+				break;
+			}
+		}
+	}
+
+
 	void SceneUnload() override
 	{
 		UE_LOG_INFO("Escena {0} se ha descargado.", _sceneName);
 		sprites.clear();
 	}
 
+private:
+	void ImguiRender()
+	{
+		ImGui::Begin("DEBUG Stuff", &debugGUI);
+
+		ImGui::Checkbox("AssetManager Inspector: ", &assetMngGUI);
+		ImGui::Checkbox("Renderer Inspector: ", &rendererGUI);
+		ImGui::Checkbox("SceneManager Inspector: ", &sceneMngGUI);
+
+
+		ImGui::End();
+
+		if (debugGUI) { TestGUI(); }
+		if(assetMngGUI) {}
+	}
+
+	void TestGUI()
+	{
+		ImGui::Begin("MainScene Test Stuff", &_windowOpen);
+
+		ImGui::Text("En esta escena, hacemos pruebas del funcionamiento de UberEngine.");
+
+		//ImVec4 buttonColor;
+		//if(ImGui::ColorEdit4("TestColor", &buttonColor.x)) {}
+
+		ImGui::Text("Elementos del vector Sprites: ");
+
+		if (ImGui::TreeNode("Sprites"))
+		{
+			//Generamos un Selectable para cada Sprite en el vector.
+			for (int i = 0; i < sprites.size(); i++)
+			{
+				//Creamos el texto.
+				char buf[32];
+				sprintf(buf, "Sprite %d", i);
+				if (ImGui::Selectable(buf, _selectedSprite == i))
+				{
+					_selectedSprite = i;
+				}
+			}
+			ImGui::TreePop();
+		}
+
+		if (ImGui::TreeNode("Selected Sprite Settings"))
+		{
+			if (_selectedSprite != -1)
+			{
+				UE::Sprite& sp = sprites.at(_selectedSprite);
+
+				ImGui::Text("Status: ");
+				const char* st = (sp.IsActive() ? "Sprite Activado" : "Sprite Desactivado");
+				ImGui::Text("El Sprite esta: %s", st);
+
+				if (ImGui::Button("Activar Sprite")) { sp.SetActive(true); }
+				ImGui::SameLine();
+				if (ImGui::Button("desactivar Sprite")) { sp.SetActive(false); }
+
+				ImGui::Text("Transform: ");
+				glm::vec2 pos = sp.GetPosition();
+				glm::vec2 size = sp.GetSize();
+				if (ImGui::SliderFloat2("Sprite Position", &pos.x, -5000, 5000))
+				{
+					sp.SetPosition(pos);
+				}
+				if (ImGui::SliderFloat2("Sprite Size", &size.x, -2000, 2000))
+				{
+					sp.SetSize(size);
+				}
+
+				ImGui::Text("Rendering: ");
+				ImGui::Text("El sprite esta en la layer: %d", sp.GetLayer());
+				//Añadir un input para modificar la layer.
+
+			}
+
+			ImGui::TreePop();
+		}
+
+		ImGui::End();
+	}
+
+	void AssetMngGUI() 
+	{
+		UE::AssetManager* asmng = Game::GetAssetManager();
+
+		ImGui::Begin("Asset Manager Inspector", &assetMngGUI);
+		
+
+
+		ImGui::End();
+	}
 
 private:
 
 	std::vector<UE::Sprite> sprites;
 
+	//ImGui:
+	bool _windowOpen = true;
+	int _selectedSprite = 0;
+
+	bool debugGUI = false;
+
+	bool assetMngGUI = false;
+	bool rendererGUI = false;
+	bool sceneMngGUI = false;
+
 };