Childs

imgui_sdl_simple_example/imgui_sdl_simple_example/imgui_sdl_simple_example.vcxproj

@@ -107,6 +107,7 @@
       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <AdditionalIncludeDirectories>..\..\sdl2_simple_example\sdl2_simple_example\</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>

sdl2_simple_example/sdl2_simple_example/Config.cpp

@@ -0,0 +1,103 @@
+#include "Config.h"
+
+
+Config::Config(MyWindow* window) : _myWindow(window) {}
+Config::~Config() {}
+
+void Config::draw(SDL_Window* _window, Renderer renderer, float fps) {
+    ImGui::Begin("Config");
+    ImGui::Text("Configuracion general del sistema");
+
+    // Secci�n de resoluci�n de pantalla
+    ImGui::Text("Resoluci�n de pantalla:");
+
+    struct ResolutionItem {
+        ivec2 resolution;
+        std::string name;
+    };
+
+    std::vector<ResolutionItem> resolutions = {
+        { {800, 600}, "800 x 600" },
+        { {1024, 768}, "1024 x 768" },
+        { {1280, 720}, "1280 x 720" },
+        { {1360, 768}, "1360 x 768" },
+        { {1366, 768}, "1366 x 768" },
+        { {1440, 900}, "1440 x 900" },
+        { {1600, 900}, "1600 x 900" },
+        { {1920, 1080}, "1920 x 1080" }
+    };
+
+    static int selectedResolutionIndex = 0;
+    if (ImGui::Combo("Resolucion", &selectedResolutionIndex, [](void* data, int idx, const char** out_text) {
+        const std::vector<ResolutionItem>* resolutions = static_cast<const std::vector<ResolutionItem>*>(data);
+        *out_text = resolutions->at(idx).name.c_str(); // Return resolution name
+        return true;
+        }, (void*)&resolutions, resolutions.size())) {
+        selectedResolution = resolutions[selectedResolutionIndex].resolution;
+
+        // Update window size
+        SDL_SetWindowSize(_window, selectedResolution.x, selectedResolution.y);
+
+        // Ensure we apply the new projection and viewport
+        if (!isFullscreen) {
+            renderer.applyProjectionAndViewport(selectedResolution); // Aplica la resoluci�n seleccionada
+        }
+    }
+
+    // Secci�n de pantalla completa
+    if (ImGui::Checkbox("Pantalla completa", &isFullscreen)) {
+        if (isFullscreen) {
+            SDL_SetWindowFullscreen(_window, SDL_WINDOW_FULLSCREEN_DESKTOP);
+            _myWindow->logMessage("Pantalla completa activada.");
+        }
+        else {
+            SDL_SetWindowFullscreen(_window, 0);  // 0 means windowed mode
+            _myWindow->logMessage("Pantalla completa desactivada.");
+        }
+
+        // Get the current window size dynamically after changing fullscreen mode
+        int windowWidth, windowHeight;
+        SDL_GetWindowSize(_window, &windowWidth, &windowHeight);
+
+        // Apply the new window size for projection and viewport
+        renderer.applyProjectionAndViewport(ivec2(windowWidth, windowHeight));
+    }
+
+    ImGui::Text("Grafico FPS");
+    static float values[90] = {};
+    static int values_offset = 0;
+    values[values_offset] = fps; // Ejemplo fijo de FPS
+    values_offset = (values_offset + 1) % 90;
+    char fpsText[16];
+    sprintf_s(fpsText, "%d fps", static_cast<int>(fps));
+    ImGui::PlotLines("FPS", values, IM_ARRAYSIZE(values), values_offset, fpsText, 0.0f, 100.0f, ImVec2(0, 80));
+
+    ImGui::Text("Consumo de Memoria: ");
+    try {
+        MemoryInfo memInfo = MemoryUsage::getMemoryInfo();
+        ImGui::Separator();
+        ImGui::Text("Consumo de Memoria:");
+        ImGui::Text("Memoria Total: %llu MB", memInfo.totalMemory);
+        ImGui::Text("Memoria Libre: %llu MB", memInfo.freeMemory);
+        ImGui::Text("Memoria Usada: %llu MB", memInfo.usedMemory);
+        static float totalMemoryValues[90];
+        static float freeMemoryValues[90];
+        static float usedMemoryValues[90];
+        static int memValuesOffset = 0;
+
+        totalMemoryValues[memValuesOffset] = memInfo.totalMemory;
+        freeMemoryValues[memValuesOffset] = memInfo.freeMemory;
+        usedMemoryValues[memValuesOffset] = memInfo.usedMemory;
+        memValuesOffset = (values_offset + 1) % 90;
+
+        ImGui::PlotLines("TotalMem", totalMemoryValues, IM_ARRAYSIZE(totalMemoryValues), memValuesOffset, "TotalMem", 0.0f, 100.0f, ImVec2(0, 80));
+        ImGui::PlotLines("freeMem", freeMemoryValues, IM_ARRAYSIZE(freeMemoryValues), memValuesOffset, "FreeMem", 0.0f, 100.0f, ImVec2(0, 80));
+        ImGui::PlotLines("UsedMem", usedMemoryValues, IM_ARRAYSIZE(usedMemoryValues), memValuesOffset, "UsedMem", 0.0f, 100.0f, ImVec2(0, 80));
+    }
+    catch (const std::exception& e) {
+        ImGui::Text("Error obteniendo memoria: %s", e.what());
+    }
+    ImGui::Text("Deteccion de maquinaria i versions de programario:");
+    ImGui::Text("SDL, OpenGL, DevIL");
+    ImGui::End();
+}

sdl2_simple_example/sdl2_simple_example/Config.h

@@ -0,0 +1,25 @@
+#pragma once
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include <string>
+#include <vector>
+#include <imgui.h>
+#include "MyWindow.h"
+#include "MemoryUsage.h"
+
+
+class Config {
+public:
+	Config(MyWindow* window);
+	~Config();
+
+	void draw(SDL_Window* _window, Renderer renderer, float fps);
+private:
+	MyWindow* _myWindow;
+	glm::ivec2 selectedResolution;
+	bool isFullscreen = false;
+};
+
+
+#endif // CONFIG_H

sdl2_simple_example/sdl2_simple_example/Consola.cpp

@@ -0,0 +1,12 @@
+#include "Consola.h"
+
+Consola::Consola(){}
+Consola::~Consola(){}
+
+void Consola::draw(std::vector<std::string> logMessage) {
+    ImGui::Begin("Consola");
+    for (const auto& msg : logMessage) {
+        ImGui::Text("%s", msg.c_str());
+    }
+    ImGui::End();
+}

sdl2_simple_example/sdl2_simple_example/Consola.h

@@ -0,0 +1,19 @@
+#pragma once
+#ifndef CONSOLA_H
+#define CONSOLA_H
+
+#include <string>
+#include <vector>
+#include <imgui.h>
+
+class Consola {
+public:
+	Consola();
+	~Consola();
+
+	static void draw(std::vector<std::string> logMessage);
+private:
+
+};
+
+#endif // CONSOLA_H

sdl2_simple_example/sdl2_simple_example/CustomFormatUtils.h

@@ -0,0 +1,42 @@
+#pragma once
+#include <vector>
+#include <string>
+#include <fstream>
+
+void saveCustomFormat(const std::string& path, const std::vector<float>& vertices, const std::vector<float>& uvs, const std::vector<unsigned int>& indices) {
+    std::ofstream file(path, std::ios::binary);
+
+    size_t vertexCount = vertices.size();
+    size_t uvCount = uvs.size();
+    size_t indexCount = indices.size();
+
+    file.write(reinterpret_cast<const char*>(&vertexCount), sizeof(size_t));
+    file.write(reinterpret_cast<const char*>(vertices.data()), vertices.size() * sizeof(float));
+
+    file.write(reinterpret_cast<const char*>(&uvCount), sizeof(size_t));
+    file.write(reinterpret_cast<const char*>(uvs.data()), uvs.size() * sizeof(float));
+
+    file.write(reinterpret_cast<const char*>(&indexCount), sizeof(size_t));
+    file.write(reinterpret_cast<const char*>(indices.data()), indices.size() * sizeof(unsigned int));
+
+    file.close();
+}
+
+void loadCustomFormat(const std::string& path, std::vector<float>& vertices, std::vector<float>& uvs, std::vector<unsigned int>& indices) {
+    std::ifstream file(path, std::ios::binary);
+
+    size_t vertexCount, uvCount, indexCount;
+    file.read(reinterpret_cast<char*>(&vertexCount), sizeof(size_t));
+    vertices.resize(vertexCount);
+    file.read(reinterpret_cast<char*>(vertices.data()), vertexCount * sizeof(float));
+
+    file.read(reinterpret_cast<char*>(&uvCount), sizeof(size_t));
+    uvs.resize(uvCount);
+    file.read(reinterpret_cast<char*>(uvs.data()), uvCount * sizeof(float));
+
+    file.read(reinterpret_cast<char*>(&indexCount), sizeof(size_t));
+    indices.resize(indexCount);
+    file.read(reinterpret_cast<char*>(indices.data()), indexCount * sizeof(unsigned int));
+
+    file.close();
+}

sdl2_simple_example/sdl2_simple_example/Escena.cpp

@@ -0,0 +1,24 @@
+#include "Escena.h"
+
+extern Renderer renderer;
+
+Escena::Escena(){}
+Escena::~Escena(){}
+
+void Escena::draw(GLuint textureColorbuffer) {
+    ImGui::Begin("Scene");
+    if (textureColorbuffer) {
+
+        ImGui::Image((void*)(intptr_t)textureColorbuffer, ImVec2(renderer._WINDOW_SIZE.x, renderer._WINDOW_SIZE.y));
+
+        if (ImGui::BeginDragDropTarget()) {
+            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("FILE_PATH")) {
+                const char* filePath = (const char*)payload->Data;
+
+                handleFileDrop(filePath); // Procesar archivo arrastrado
+            }
+            ImGui::EndDragDropTarget();
+        }
+    }
+    ImGui::End();
+}

sdl2_simple_example/sdl2_simple_example/Escena.h

@@ -0,0 +1,18 @@
+#pragma once
+#ifndef ESCENA_H
+#define ESCENA_H
+
+#include <imgui.h>
+#include "MyWindow.h"
+
+
+class Escena {
+public:
+	Escena();
+	~Escena();
+	static void draw(GLuint texturecolorbuffer);
+private:
+
+};
+
+#endif // ESCENA_H

sdl2_simple_example/sdl2_simple_example/FileExplorer.cpp

@@ -0,0 +1,111 @@
+#include "FileExplorer.h"
+
+Explorer::Explorer(){}
+Explorer::~Explorer(){}
+
+
+void Explorer::UpdateDirectoryContents() {
+    try {
+        directoryContents.clear();
+
+        if (fs::exists(currentDirectory) && fs::is_directory(currentDirectory)) {
+            for (const auto& entry : fs::directory_iterator(currentDirectory)) {
+                directoryContents.push_back(entry.path().string());
+            }
+            // Asegurarnos de que el �ndice seleccionado sea v�lido
+            if (selectedFileIndex >= directoryContents.size()) {
+                selectedFileIndex = -1;
+            }
+        }
+    }
+    catch (const fs::filesystem_error& e) {
+        std::cerr << "Error listing directory: " << e.what() << std::endl;
+        selectedFileIndex = -1;
+    }
+}
+void Explorer::deleteSelectedFile() {
+    if (selectedFileIndex < 0 || selectedFileIndex >= directoryContents.size()) {
+        return;
+    }
+
+    try {
+        std::string filePath = directoryContents[selectedFileIndex];
+        if (!fs::is_directory(filePath) && fs::exists(filePath)) {
+            if (fs::remove(filePath)) {
+                selectedFileIndex = -1;
+                UpdateDirectoryContents();
+            }
+        }
+    }
+    catch (const fs::filesystem_error& e) {
+        std::cerr << "Error deleting file: " << e.what() << std::endl;
+    }
+}
+void Explorer::draw() {
+    ImGui::Begin("File Explorer");
+
+    // Mostrar directorio actual
+    ImGui::Text("Current Directory: %s", currentDirectory.c_str());
+
+    // Bot�n para subir un nivel
+    if (ImGui::Button(".. (Go Up)")) {
+        try {
+            fs::path parent = fs::path(currentDirectory).parent_path();
+            if (fs::exists(parent)) {
+                currentDirectory = parent.string();
+                selectedFileIndex = -1;  // Reset selection when changing directory
+                UpdateDirectoryContents();
+            }
+        }
+        catch (const fs::filesystem_error& e) {
+            std::cerr << "Error accessing parent directory: " << e.what() << std::endl;
+        }
+    }
+
+    // Lista de archivos y directorios
+    ImGui::BeginChild("Files", ImVec2(0, -30), true);
+    for (size_t i = 0; i < directoryContents.size(); ++i) {
+        try {
+            fs::path entry(directoryContents[i]);
+            if (!fs::exists(entry)) continue;  // Skip if file no longer exists
+
+            std::string displayName = FileSystemUtils::getFileName(entry.string());
+            bool isSelected = (i == selectedFileIndex);
+
+            if (fs::is_directory(entry)) {
+                // Directorios como botones
+                if (ImGui::Button(displayName.c_str())) {
+                    currentDirectory = entry.string();
+                    selectedFileIndex = -1;
+                    UpdateDirectoryContents();
+                }
+            }
+            else {
+                // Archivos como seleccionables
+                if (ImGui::Selectable(displayName.c_str(), isSelected)) {
+                    selectedFileIndex = i;
+                }
+
+                // Drag & Drop solo para archivos
+                if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_None)) {
+                    const char* filePath = entry.string().c_str();
+                    ImGui::SetDragDropPayload("FILE_PATH", filePath, strlen(filePath) + 1);
+                    ImGui::Text("Dragging: %s", displayName.c_str());
+                    ImGui::EndDragDropSource();
+                }
+            }
+        }
+        catch (const fs::filesystem_error& e) {
+            std::cerr << "Error processing file: " << e.what() << std::endl;
+        }
+    }
+    ImGui::EndChild();
+
+    // Manejar borrado con tecla Delete
+    if (ImGui::IsKeyPressed(ImGuiKey_Delete) && selectedFileIndex >= 0) {
+        deleteSelectedFile();
+    }
+
+    ImGui::End();
+}
+