Preparando la interfaz

source/ui/Application.cpp

@@ -0,0 +1,242 @@
+#include "ui/Application.hpp"
+
+#include <raylib.h>
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdio>
+#include <string>
+
+#include "core/Constants.hpp"
+#include "editor/Tool.hpp"
+#include "ui/Theme.hpp"
+
+namespace tahgibu {
+namespace {
+
+constexpr int kInitialWidth = 1280;
+constexpr int kInitialHeight = 800;
+constexpr int kMinWidth = 1000;
+constexpr int kMinHeight = 640;
+constexpr int kUiTargetFps = 60;  // FPS de la interfaz; no tiene relación con los FPS de la animación
+
+constexpr int kFontSize = 16;
+constexpr int kSmallFontSize = 14;
+constexpr int kButtonPadding = 10;
+constexpr float kButtonGap = 4.0f;
+constexpr float kPanelHeaderHeight = 24.0f;
+
+constexpr std::array<const char*, 7> kMenus = {
+    "Archivo", "Editar", "Animación", "Sprite", "Audio", "Ver", "Lua"};
+
+int px(float value) {
+    return static_cast<int>(value);
+}
+
+void drawTextVCentered(const char* text, float x, const Rectangle& area, int size, Color color) {
+    DrawText(text, px(x), px(area.y + (area.height - static_cast<float>(size)) / 2.0f), size, color);
+}
+
+void drawPanelHeader(const Rectangle& panel, const char* title) {
+    DrawRectangle(px(panel.x), px(panel.y), px(panel.width), px(kPanelHeaderHeight), theme::kPanelHeader);
+    DrawText(title, px(panel.x + 12.0f), px(panel.y + 4.0f), kFontSize, theme::kText);
+}
+
+std::array<Rectangle, kToolCount> computeToolButtons(const Rectangle& bar) {
+    std::array<Rectangle, kToolCount> rects{};
+    float x = bar.x + 8.0f;
+    for (std::size_t i = 0; i < kToolCount; ++i) {
+        const float w = static_cast<float>(MeasureText(kToolInfos[i].label, kFontSize) + 2 * kButtonPadding);
+        rects[i] = {x, bar.y + 6.0f, w, bar.height - 12.0f};
+        x += w + kButtonGap;
+    }
+    return rects;
+}
+
+std::array<Rectangle, kMenus.size()> computeMenuRects(const Rectangle& bar) {
+    std::array<Rectangle, kMenus.size()> rects{};
+    float x = bar.x + 6.0f;
+    for (std::size_t i = 0; i < kMenus.size(); ++i) {
+        const float w = static_cast<float>(MeasureText(kMenus[i], kFontSize) + 2 * kButtonPadding);
+        rects[i] = {x, bar.y + 2.0f, w, bar.height - 4.0f};
+        x += w + 2.0f;
+    }
+    return rects;
+}
+
+}  // namespace
+
+Application::Application() {
+    SetConfigFlags(FLAG_WINDOW_RESIZABLE);
+    const std::string title = std::string(kAppName) + " " + kAppVersion;
+    InitWindow(kInitialWidth, kInitialHeight, title.c_str());
+    if (!IsWindowReady()) {
+        return;
+    }
+    SetWindowMinSize(kMinWidth, kMinHeight);
+    SetExitKey(KEY_NULL);  // Esc no debe cerrar el editor
+    SetTargetFPS(kUiTargetFps);
+    layout_ = Layout::compute(GetScreenWidth(), GetScreenHeight());
+}
+
+Application::~Application() {
+    if (IsWindowReady()) {
+        CloseWindow();
+    }
+}
+
+int Application::run() {
+    if (!IsWindowReady()) {
+        std::fprintf(stderr, "No se pudo crear la ventana (¿hay entorno gráfico y OpenGL disponible?).\n");
+        return 1;
+    }
+    while (!WindowShouldClose()) {
+        update();
+        draw();
+    }
+    return 0;
+}
+
+void Application::update() {
+    layout_ = Layout::compute(GetScreenWidth(), GetScreenHeight());
+
+    if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) {
+        const Vector2 mouse = GetMousePosition();
+        const auto rects = computeToolButtons(layout_.toolBar);
+        for (std::size_t i = 0; i < kToolCount; ++i) {
+            if (CheckCollisionPointRec(mouse, rects[i])) {
+                state_.activeTool = kToolInfos[i].id;
+                break;
+            }
+        }
+    }
+}
+
+void Application::draw() const {
+    BeginDrawing();
+    ClearBackground(theme::kWindowBg);
+    drawCanvas();
+    drawProperties();
+    drawTimeline();
+    drawToolBar();
+    drawMenuBar();
+    EndDrawing();
+}
+
+void Application::drawMenuBar() const {
+    const Rectangle& bar = layout_.menuBar;
+    DrawRectangleRec(bar, theme::kPanelHeader);
+
+    const Vector2 mouse = GetMousePosition();
+    const auto rects = computeMenuRects(bar);
+    for (std::size_t i = 0; i < kMenus.size(); ++i) {
+        if (CheckCollisionPointRec(mouse, rects[i])) {
+            DrawRectangleRec(rects[i], theme::kHover);
+        }
+        drawTextVCentered(kMenus[i], rects[i].x + static_cast<float>(kButtonPadding), rects[i], kFontSize,
+                          theme::kText);
+    }
+}
+
+void Application::drawToolBar() const {
+    const Rectangle& bar = layout_.toolBar;
+    DrawRectangleRec(bar, theme::kPanelBg);
+    DrawRectangle(px(bar.x), px(bar.y + bar.height - 1.0f), px(bar.width), 1, theme::kBorder);
+
+    const Vector2 mouse = GetMousePosition();
+    const auto rects = computeToolButtons(bar);
+    for (std::size_t i = 0; i < kToolCount; ++i) {
+        const bool active = state_.activeTool == kToolInfos[i].id;
+        const bool hover = CheckCollisionPointRec(mouse, rects[i]);
+        const Color background = active ? theme::kAccent : (hover ? theme::kHover : theme::kPanelHeader);
+        DrawRectangleRec(rects[i], background);
+        drawTextVCentered(kToolInfos[i].label, rects[i].x + static_cast<float>(kButtonPadding), rects[i],
+                          kFontSize, active ? theme::kWindowBg : theme::kText);
+    }
+}
+
+void Application::drawCanvas() const {
+    const Rectangle& area = layout_.canvas;
+    DrawRectangleRec(area, theme::kCanvasBg);
+
+    // Escenario del tamaño del proyecto, ajustado al área disponible.
+    constexpr float kMargin = 32.0f;
+    const float projectW = static_cast<float>(project_.width());
+    const float projectH = static_cast<float>(project_.height());
+    const float availableW = std::max(1.0f, area.width - 2.0f * kMargin);
+    const float availableH = std::max(1.0f, area.height - 2.0f * kMargin);
+    const float scale = std::min(availableW / projectW, availableH / projectH);
+    const float w = projectW * scale;
+    const float h = projectH * scale;
+    const Rectangle stage{area.x + (area.width - w) / 2.0f, area.y + (area.height - h) / 2.0f, w, h};
+
+    DrawRectangleRec(stage, theme::kStage);
+    DrawRectangleLinesEx(stage, 1.0f, theme::kBorder);
+
+    char caption[96];
+    std::snprintf(caption, sizeof caption, "Escenario %d x %d", project_.width(), project_.height());
+    DrawText(caption, px(area.x + 10.0f), px(area.y + 8.0f), kSmallFontSize, theme::kTextDim);
+}
+
+void Application::drawProperties() const {
+    const Rectangle& panel = layout_.properties;
+    DrawRectangleRec(panel, theme::kPanelBg);
+    drawPanelHeader(panel, "Propiedades");
+    DrawRectangle(px(panel.x), px(panel.y), 1, px(panel.height), theme::kBorder);
+
+    const std::size_t index = std::min(state_.currentFrame, project_.frameCount() - 1);
+    const Frame& frame = project_.frame(index);
+
+    float y = panel.y + kPanelHeaderHeight + 12.0f;
+    const float x = panel.x + 12.0f;
+    char line[128];
+    auto put = [&](Color color) {
+        DrawText(line, px(x), px(y), kFontSize, color);
+        y += 24.0f;
+    };
+
+    std::snprintf(line, sizeof line, "Proyecto: %s", project_.name().c_str());
+    put(theme::kText);
+    std::snprintf(line, sizeof line, "Resolución: %d x %d", project_.width(), project_.height());
+    put(theme::kText);
+    std::snprintf(line, sizeof line, "FPS base: %.1f (máx. %.0f)", static_cast<double>(project_.baseFps()),
+                  static_cast<double>(kMaxFps));
+    put(theme::kText);
+    std::snprintf(line, sizeof line, "Frame: %zu / %zu", index + 1, project_.frameCount());
+    put(theme::kText);
+    std::snprintf(line, sizeof line, "FPS del frame: %.1f %s",
+                  static_cast<double>(frame.effectiveFps(project_.baseFps())),
+                  frame.hasFpsOverride() ? "(propio)" : "(base)");
+    put(theme::kText);
+    std::snprintf(line, sizeof line, "Herramienta: %s", toolLabel(state_.activeTool));
+    put(theme::kText);
+
+    y += 8.0f;
+    std::snprintf(line, sizeof line, "Sprites y vértices: etapas 4 y 8");
+    put(theme::kTextDim);
+}
+
+void Application::drawTimeline() const {
+    const Rectangle& panel = layout_.timeline;
+    DrawRectangleRec(panel, theme::kPanelBg);
+    drawPanelHeader(panel, "Timeline");
+    DrawRectangle(px(panel.x), px(panel.y), px(panel.width), 1, theme::kBorder);
+
+    constexpr std::array<const char*, 3> kTracks = {"Fondo", "Sprite", "Audio"};
+    constexpr float kLaneHeight = 32.0f;
+    constexpr float kLabelWidth = 90.0f;
+
+    float y = panel.y + kPanelHeaderHeight + 12.0f;
+    for (const char* name : kTracks) {
+        DrawText(name, px(panel.x + 12.0f), px(y + (kLaneHeight - static_cast<float>(kFontSize)) / 2.0f),
+                 kFontSize, theme::kText);
+        const Rectangle lane{panel.x + kLabelWidth, y, panel.width - kLabelWidth - 12.0f, kLaneHeight - 4.0f};
+        DrawRectangleRec(lane, theme::kPanelHeader);
+        y += kLaneHeight;
+    }
+    DrawText("La timeline se implementa en la etapa 3", px(panel.x + 12.0f), px(y + 8.0f), kSmallFontSize,
+             theme::kTextDim);
+}
+
+}  // namespace tahgibu

source/ui/Application.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "core/Project.hpp"
+#include "editor/EditorState.hpp"
+#include "ui/Layout.hpp"
+
+namespace tahgibu {
+
+// Ventana principal: crea la ventana de raylib, ejecuta el bucle y dibuja las zonas.
+// La lógica del programa vive en core/ y editor/, no aquí.
+class Application {
+public:
+    Application();
+    ~Application();
+    Application(const Application&) = delete;
+    Application& operator=(const Application&) = delete;
+
+    // Devuelve el código de salida del proceso.
+    int run();
+
+private:
+    void update();
+    void draw() const;
+    void drawMenuBar() const;
+    void drawToolBar() const;
+    void drawCanvas() const;
+    void drawProperties() const;
+    void drawTimeline() const;
+
+    Project project_;
+    EditorState state_;
+    Layout layout_;
+};
+
+}  // namespace tahgibu

source/ui/Layout.cpp

@@ -0,0 +1,35 @@
+#include "ui/Layout.hpp"
+
+#include <algorithm>
+
+namespace tahgibu {
+namespace {
+
+constexpr float kMenuBarHeight = 26.0f;
+constexpr float kToolBarHeight = 40.0f;
+constexpr float kPropertiesWidth = 280.0f;
+constexpr float kTimelineHeight = 200.0f;
+constexpr float kMinCanvasWidth = 400.0f;
+constexpr float kMinCanvasHeight = 200.0f;
+
+}  // namespace
+
+Layout Layout::compute(int windowWidth, int windowHeight) {
+    const float w = static_cast<float>(windowWidth);
+    const float h = static_cast<float>(windowHeight);
+    const float top = kMenuBarHeight + kToolBarHeight;
+
+    const float timelineH = std::min(kTimelineHeight, std::max(0.0f, h - top - kMinCanvasHeight));
+    const float propertiesW = std::min(kPropertiesWidth, std::max(0.0f, w - kMinCanvasWidth));
+    const float middleH = std::max(0.0f, h - top - timelineH);
+
+    Layout layout;
+    layout.menuBar = {0.0f, 0.0f, w, kMenuBarHeight};
+    layout.toolBar = {0.0f, kMenuBarHeight, w, kToolBarHeight};
+    layout.canvas = {0.0f, top, w - propertiesW, middleH};
+    layout.properties = {w - propertiesW, top, propertiesW, middleH};
+    layout.timeline = {0.0f, top + middleH, w, timelineH};
+    return layout;
+}
+
+}  // namespace tahgibu

source/ui/Layout.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <raylib.h>
+
+namespace tahgibu {
+
+// Reparto de la ventana en zonas. Función pura del tamaño de la ventana.
+struct Layout {
+    Rectangle menuBar{};
+    Rectangle toolBar{};
+    Rectangle canvas{};
+    Rectangle properties{};
+    Rectangle timeline{};
+
+    static Layout compute(int windowWidth, int windowHeight);
+};
+
+}  // namespace tahgibu

source/ui/Theme.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <raylib.h>
+
+namespace tahgibu::theme {
+
+inline constexpr Color kWindowBg{24, 24, 28, 255};
+inline constexpr Color kPanelBg{34, 34, 40, 255};
+inline constexpr Color kPanelHeader{44, 44, 52, 255};
+inline constexpr Color kBorder{14, 14, 18, 255};
+inline constexpr Color kHover{62, 62, 74, 255};
+inline constexpr Color kText{225, 225, 230, 255};
+inline constexpr Color kTextDim{140, 140, 152, 255};
+inline constexpr Color kAccent{255, 140, 60, 255};
+inline constexpr Color kCanvasBg{18, 18, 22, 255};
+inline constexpr Color kStage{245, 245, 245, 255};
+
+}  // namespace tahgibu::theme