From 17b8ffac48643040cddfb0a51025bab62245326f Mon Sep 17 00:00:00 2001 From: skal Date: Sat, 7 Feb 2026 09:20:19 +0100 Subject: refactor: Move platform files to src/platform/ subdirectory MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reorganized platform windowing code into dedicated subdirectory for better organization and consistency with other subsystems (audio/, gpu/, 3d/). Changes: - Created src/platform/ directory - Moved src/platform.{h,cc} → src/platform/platform.{h,cc} - Updated 11 include paths: "platform.h" → "platform/platform.h" - src/main.cc, src/test_demo.cc - src/gpu/gpu.{h,cc} - src/platform/platform.cc (self-include) - 6 test files - Updated CMakeLists.txt PLATFORM_SOURCES variable Verification: ✓ All targets build successfully (demo64k, test_demo, test_platform) ✓ test_platform passes (70% coverage maintained) ✓ demo64k smoke test passed This completes the platform code reorganization side quest. No functional changes, purely organizational. --- src/platform/platform.cc | 131 +++++++++++++++++++++++++++++++++++++++++++++++ src/platform/platform.h | 100 ++++++++++++++++++++++++++++++++++++ 2 files changed, 231 insertions(+) create mode 100644 src/platform/platform.cc create mode 100644 src/platform/platform.h (limited to 'src/platform') diff --git a/src/platform/platform.cc b/src/platform/platform.cc new file mode 100644 index 0000000..29b3af3 --- /dev/null +++ b/src/platform/platform.cc @@ -0,0 +1,131 @@ +// This file is part of the 64k demo project. +// It implements platform-specific windowing and input using GLFW. +// Handles fullscreen toggling and native surface creation for WebGPU. + +#include "platform/platform.h" +#include "glfw3webgpu.h" +#include + +// --- Callbacks --- + +static void framebuffer_size_callback(GLFWwindow* window, int width, + int height) { + PlatformState* state = (PlatformState*)glfwGetWindowUserPointer(window); + if (state) { + state->width = width; + state->height = height; + if (height > 0) { + state->aspect_ratio = (float)width / (float)height; + } + } +} + +static void glfw_key_callback(GLFWwindow* window, int key, int scancode, + int action, int mods) { + PlatformState* state = (PlatformState*)glfwGetWindowUserPointer(window); + if (action == GLFW_PRESS) { + if (key == GLFW_KEY_ESCAPE || key == GLFW_KEY_Q) { + glfwSetWindowShouldClose(window, GLFW_TRUE); + } else if (key == GLFW_KEY_F) { + if (state) + platform_toggle_fullscreen(state); + } + } +} + +// --- Public API Implementation --- + +PlatformState platform_init(bool fullscreen, int width, int height) { + PlatformState state = {}; + state.width = width; + state.height = height; + state.is_fullscreen = fullscreen; + + glfwInit(); + glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); + state.window = + glfwCreateWindow(state.width, state.height, "demo64k", nullptr, nullptr); + + // Immediately query the actual framebuffer size for high-DPI displays + glfwGetFramebufferSize(state.window, &state.width, &state.height); + if (state.height > 0) { + state.aspect_ratio = (float)state.width / (float)state.height; + } + + // Store our state in a static pointer or use the window pointer? + // We'll use a pointer to a persistent state. + // For this demo, we can assume the PlatformState persists in main(). + // But we return by value. This is a bit tricky with callbacks. + // We'll fix the callbacks in platform_poll if needed, or just let main pass + // the pointer back. + + glfwSetWindowUserPointer(state.window, + nullptr); // Will be set in main's state + + glfwSetKeyCallback(state.window, glfw_key_callback); + glfwSetFramebufferSizeCallback(state.window, framebuffer_size_callback); + + if (fullscreen) { + glfwGetWindowPos(state.window, &state.windowed_x, &state.windowed_y); + glfwGetWindowSize(state.window, &state.windowed_w, &state.windowed_h); + + GLFWmonitor* monitor = glfwGetPrimaryMonitor(); + const GLFWvidmode* mode = glfwGetVideoMode(monitor); + glfwSetWindowMonitor(state.window, monitor, 0, 0, mode->width, mode->height, + mode->refreshRate); + } + + state.time = glfwGetTime(); + + return state; +} + +void platform_shutdown(PlatformState* state) { + if (state->window) { + glfwDestroyWindow(state->window); + } + glfwTerminate(); +} + +void platform_poll(PlatformState* state) { + // Ensure the window has the current state pointer for callbacks + if (glfwGetWindowUserPointer(state->window) != state) { + glfwSetWindowUserPointer(state->window, state); + } + + glfwPollEvents(); + state->time = glfwGetTime(); + if (state->height > 0) { + state->aspect_ratio = (float)state->width / (float)state->height; + } +} + +bool platform_should_close(PlatformState* state) { + return glfwWindowShouldClose(state->window); +} + +void platform_toggle_fullscreen(PlatformState* state) { + state->is_fullscreen = !state->is_fullscreen; + if (state->is_fullscreen) { + glfwGetWindowPos(state->window, &state->windowed_x, &state->windowed_y); + glfwGetWindowSize(state->window, &state->windowed_w, &state->windowed_h); + + GLFWmonitor* monitor = glfwGetPrimaryMonitor(); + const GLFWvidmode* mode = glfwGetVideoMode(monitor); + glfwSetWindowMonitor(state->window, monitor, 0, 0, mode->width, + mode->height, mode->refreshRate); + } else { + glfwSetWindowMonitor(state->window, nullptr, state->windowed_x, + state->windowed_y, state->windowed_w, + state->windowed_h, 0); + } +} + +WGPUSurface platform_create_wgpu_surface(WGPUInstance instance, + PlatformState* state) { + return glfwCreateWindowWGPUSurface(instance, state->window); +} + +double platform_get_time() { + return glfwGetTime(); +} \ No newline at end of file diff --git a/src/platform/platform.h b/src/platform/platform.h new file mode 100644 index 0000000..0a98850 --- /dev/null +++ b/src/platform/platform.h @@ -0,0 +1,100 @@ +// Handles windowing, input, and native surface creation. +// Consolidates platform-specific shims for WebGPU. + +#pragma once + +#include +#include + +// WebGPU specific headers and shims +#if defined(DEMO_CROSS_COMPILE_WIN32) +#include +#include + +#define WGPUOptionalBool_True true +#define WGPUOptionalBool_False false +#define WGPUSType_ShaderSourceWGSL WGPUSType_ShaderModuleWGSLDescriptor +#define WGPU_DEPTH_SLICE_UNDEFINED 0xffffffff +#define WGPUSurfaceGetCurrentTextureStatus_SuccessOptimal \ + WGPUSurfaceGetCurrentTextureStatus_Success +#define WGPUSurfaceGetCurrentTextureStatus_SuccessSuboptimal \ + WGPUSurfaceGetCurrentTextureStatus_Success +#define WGPUCallbackMode_WaitAnyOnly 0 + +typedef WGPUShaderModuleWGSLDescriptor WGPUShaderSourceWGSL; + +static inline const char* str_view(const char* str) { + return str; +} +static inline const char* label_view(const char* str) { + return str; +} + +static inline void platform_wgpu_wait_any(WGPUInstance instance) { + wgpuInstanceProcessEvents(instance); +} +static inline void +platform_wgpu_set_error_callback(WGPUDevice device, + WGPUErrorCallback callback) { + wgpuDeviceSetUncapturedErrorCallback(device, callback, nullptr); +} + +#else +#include +#include + +static inline WGPUStringView str_view(const char* str) { + if (!str) + return {nullptr, 0}; + return {str, strlen(str)}; +} + +static inline WGPUStringView label_view(const char* str) { +#if !defined(STRIP_ALL) + if (!str) + return {nullptr, 0}; + return {str, strlen(str)}; +#else + (void)str; + return {nullptr, 0}; +#endif +} + +static inline void platform_wgpu_wait_any(WGPUInstance instance) { + wgpuInstanceWaitAny(instance, 0, nullptr, 0); +} +static inline void +platform_wgpu_set_error_callback(WGPUDevice device, + WGPUUncapturedErrorCallback callback) { + // Handled in descriptor for new API, but provided for compatibility if needed + // elsewhere +} +#endif + +// Forward declare GLFWwindow to avoid including the full header here. +struct GLFWwindow; + +struct PlatformState { + GLFWwindow* window = nullptr; + int width = 1280; + int height = 720; + float aspect_ratio = 1.0f; + double time = 0.0; + bool is_fullscreen = false; + // Store windowed geometry for fullscreen toggle + int windowed_x = 0, windowed_y = 0, windowed_w = 0, windowed_h = 0; +}; + +// Refactored platform API +PlatformState platform_init(bool fullscreen, int width, int height); +void platform_shutdown(PlatformState* state); +void platform_poll(PlatformState* state); +bool platform_should_close(PlatformState* state); +void platform_toggle_fullscreen(PlatformState* state); + +// WebGPU specific surface creation +WGPUSurface platform_create_wgpu_surface(WGPUInstance instance, + PlatformState* state); + +// Global time query (if needed without state) +double platform_get_time(); \ No newline at end of file -- cgit v1.2.3