Getting Started with Window

This guide demonstrates window creation and input handling.

Creating a Window

Basic window creation:

#include "window/window.hpp"

// Window parameters
WindowID id = 0;
std::string title = "My Game";
int width = 1920;
int height = 1080;
bool headless = false;

// Create window instance
Ref<Window> window = Window::create(id, title, width, height, headless);

// Initialize OpenGL context and callbacks
window->start();

Event Handling

Listen for keyboard and mouse events using the event system:

#include "events/key-event.hpp"
#include "events/mouse-event.hpp"
#include "window/managers/window-manager.hpp"

// Subscribe to keyboard events
auto keyboard_listener = std::make_shared<input::KeyboardListener>([](Event* event) {
    if (event->get_event_type() == EventType::KeyPressed) {
        auto* key_event = static_cast<input::KeyPressedEvent*>(event);
        OnKeyPressed(key_event->key_code);
    } else if (event->get_event_type() == EventType::KeyReleased) {
        auto* key_event = static_cast<input::KeyReleasedEvent*>(event);
        OnKeyReleased(key_event->key_code);
    }
});
event_dispatcher()->subscribe(keyboard_listener);

// Subscribe to mouse movement events
auto mouse_listener = std::make_shared<MouseListener>([](Event* event) {
    auto* mouse_event = static_cast<MouseEvent*>(event);
    OnMouseMove(mouse_event->x, mouse_event->y);
});
event_dispatcher()->subscribe(mouse_listener);

Input Polling

Check input state during update:

#include "window/managers/window-manager.hpp"
#include "window/events/key-codes.hpp"

void Update(float deltaTime) {
    // Keyboard input polling
    if (input::IS_KEY_DOWN(input::KeyCode::W)) {
        camera.MoveForward(deltaTime);
    }
    if (input::IS_KEY_DOWN(input::KeyCode::S)) {
        camera.MoveBackward(deltaTime);
    }
    if (input::IS_KEY_DOWN(input::KeyCode::A)) {
        camera.MoveLeft(deltaTime);
    }
    if (input::IS_KEY_DOWN(input::KeyCode::D)) {
        camera.MoveRight(deltaTime);
    }

    // Mouse movement delta
    if (input::HAS_MOUSE_MOVED()) {
        auto delta = input::MOUSE_DELTA();
        camera.Rotate(delta.x, delta.y);
    }
}

Main Loop

Basic window update loop:

#include "window/time.hpp"

// Initialize time tracking
Time::init();

while (window->is_open()) {
    // Update time and calculate delta
    Time::get()->update();
    float deltaTime = Time::get()->get_deltatime();

    // Update window and poll events
    window->update();

    // Update game logic
    Update(deltaTime);

    // Render
    Render();

    // Swap buffers and reset per-frame input state
    window->swap();
}

Window Dimensions

Query window dimensions:

// Get window size
int w = window->width();
int h = window->height();

// Or use macros for active window
int activeWidth = ACTIVE_WINDOW_WIDTH();
int activeHeight = ACTIVE_WINDOW_HEIGHT();

Multi-Window Management

The WindowManager singleton manages multiple windows:

#include "window/managers/window-manager.hpp"

// Load multiple windows
window_manager()->load_windows({window1, window2});

// Get window by ID
Ref<Window> win = window_manager()->get_window_by_id(windowId);

// Set active window for input queries
window_manager()->set_active_window_by_id(windowId);

// Check if any window is open
bool anyOpen = window_manager()->is_open();

// Update all windows
window_manager()->update();
window_manager()->swap();

Mouse Input

The window module tracks mouse position and movement:

#include "window/managers/window-manager.hpp"

// Get mouse delta (movement since last frame)
auto delta = input::MOUSE_DELTA();

// Check if mouse has moved this frame
if (input::HAS_MOUSE_MOVED()) {
    // Handle camera rotation, etc.
}

// Set mouse position programmatically
input::Mouse::Position newPos{400.0, 300.0};
input::SET_MOUSE_POSITION(newPos);

Note: Cursor visibility is toggled internally by pressing the Escape key (switches between disabled/normal modes).

Window Lifecycle

Complete window setup and teardown:

#include "window/window.hpp"
#include "window/managers/window-manager.hpp"

// Create window
WindowID id = 0;
std::string title = "My Game";
int width = 1920;
int height = 1080;
bool headless = false;

Ref<Window> window = Window::create(id, title, width, height, headless);

// Load into manager
window_manager()->load_window(window);

// Initialize OpenGL context and callbacks
window->start();

// Main loop
while (window->is_open()) {
    window->update();
    // ... render and logic ...
    window->swap();
}

// Cleanup
window->close();
window_manager()->end();

Next Steps

• Learn about Application for main loop coordination
• Explore Renderer for graphics rendering
• Review Editor for editor integration