treballant en postfx

source/core/rendering/sdl3gpu/sdl3gpu_shader.cpp

@@ -0,0 +1,419 @@
+#include "core/rendering/sdl3gpu/sdl3gpu_shader.hpp"
+
+#include <SDL3/SDL_log.h>
+
+#include <cstring>  // memcpy, strlen
+
+#ifndef __APPLE__
+#include "core/rendering/sdl3gpu/postfx_frag_spv.h"
+#include "core/rendering/sdl3gpu/postfx_vert_spv.h"
+#endif
+
+#ifdef __APPLE__
+// ============================================================================
+// MSL shaders (Metal Shading Language) — macOS
+// ============================================================================
+
+// NOLINTBEGIN(readability-identifier-naming)
+static const char* POSTFX_VERT_MSL = R"(
+#include <metal_stdlib>
+using namespace metal;
+
+struct PostVOut {
+    float4 pos [[position]];
+    float2 uv;
+};
+
+vertex PostVOut postfx_vs(uint vid [[vertex_id]]) {
+    const float2 positions[3] = { {-1.0, -1.0}, {3.0, -1.0}, {-1.0, 3.0} };
+    const float2 uvs[3]       = { { 0.0,  1.0}, {2.0,  1.0}, { 0.0,-1.0} };
+    PostVOut out;
+    out.pos = float4(positions[vid], 0.0, 1.0);
+    out.uv  = uvs[vid];
+    return out;
+}
+)";
+
+static const char* POSTFX_FRAG_MSL = R"(
+#include <metal_stdlib>
+using namespace metal;
+
+struct PostVOut {
+    float4 pos [[position]];
+    float2 uv;
+};
+
+struct PostFXUniforms {
+    float vignette_strength;
+    float chroma_strength;
+    float scanline_strength;
+    float screen_height;
+};
+
+fragment float4 postfx_fs(PostVOut                 in    [[stage_in]],
+                           texture2d<float>         scene [[texture(0)]],
+                           sampler                  samp  [[sampler(0)]],
+                           constant PostFXUniforms& u     [[buffer(0)]]) {
+    float ca = u.chroma_strength * 0.005;
+    float4 color;
+    color.r = scene.sample(samp, in.uv + float2( ca, 0.0)).r;
+    color.g = scene.sample(samp, in.uv).g;
+    color.b = scene.sample(samp, in.uv - float2( ca, 0.0)).b;
+    color.a = scene.sample(samp, in.uv).a;
+
+    float scan = 0.85 + 0.15 * sin(in.uv.y * 3.14159265 * u.screen_height);
+    color.rgb *= mix(1.0, scan, u.scanline_strength);
+
+    float2 d = in.uv - float2(0.5, 0.5);
+    float vignette = 1.0 - dot(d, d) * u.vignette_strength;
+    color.rgb *= clamp(vignette, 0.0, 1.0);
+
+    return color;
+}
+)";
+// NOLINTEND(readability-identifier-naming)
+
+#endif  // __APPLE__
+
+namespace Rendering {
+
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+SDL3GPUShader::~SDL3GPUShader() {
+    cleanup();
+}
+
+// ---------------------------------------------------------------------------
+// init
+// ---------------------------------------------------------------------------
+auto SDL3GPUShader::init(SDL_Window* window,
+    SDL_Texture* texture,
+    const std::string& /*vertex_source*/,
+    const std::string& /*fragment_source*/) -> bool {
+    // Si ya estaba inicializado, limpiar antes de reinicializar (p.ej. al cambiar borde)
+    if (is_initialized_) {
+        cleanup();
+    }
+
+    window_ = window;
+
+    // Dimensions from the SDL_Texture placeholder
+    float fw = 0.0F;
+    float fh = 0.0F;
+    SDL_GetTextureSize(texture, &fw, &fh);
+    tex_width_ = static_cast<int>(fw);
+    tex_height_ = static_cast<int>(fh);
+    uniforms_.screen_height = fh;
+
+    // ----------------------------------------------------------------
+    // 1. Create GPU device
+    // ----------------------------------------------------------------
+#ifdef __APPLE__
+    const SDL_GPUShaderFormat PREFERRED = SDL_GPU_SHADERFORMAT_MSL | SDL_GPU_SHADERFORMAT_METALLIB;
+#else
+    const SDL_GPUShaderFormat PREFERRED = SDL_GPU_SHADERFORMAT_SPIRV;
+#endif
+    device_ = SDL_CreateGPUDevice(PREFERRED, false, nullptr);
+    if (device_ == nullptr) {
+        SDL_Log("SDL3GPUShader: SDL_CreateGPUDevice failed: %s", SDL_GetError());
+        return false;
+    }
+    SDL_Log("SDL3GPUShader: driver = %s", SDL_GetGPUDeviceDriver(device_));
+
+    // ----------------------------------------------------------------
+    // 2. Claim window (GPU device owns the swapchain from now on)
+    // ----------------------------------------------------------------
+    if (!SDL_ClaimWindowForGPUDevice(device_, window_)) {
+        SDL_Log("SDL3GPUShader: SDL_ClaimWindowForGPUDevice failed: %s", SDL_GetError());
+        SDL_DestroyGPUDevice(device_);
+        device_ = nullptr;
+        return false;
+    }
+    SDL_SetGPUSwapchainParameters(device_, window_,
+        SDL_GPU_SWAPCHAINCOMPOSITION_SDR,
+        SDL_GPU_PRESENTMODE_VSYNC);
+
+    // ----------------------------------------------------------------
+    // 3. Create scene texture (upload target + sampler source)
+    //    Format: B8G8R8A8_UNORM matches SDL ARGB8888 byte layout on LE
+    // ----------------------------------------------------------------
+    SDL_GPUTextureCreateInfo tex_info = {};
+    tex_info.type = SDL_GPU_TEXTURETYPE_2D;
+    tex_info.format = SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM;
+    tex_info.usage = SDL_GPU_TEXTUREUSAGE_SAMPLER;
+    tex_info.width = static_cast<Uint32>(tex_width_);
+    tex_info.height = static_cast<Uint32>(tex_height_);
+    tex_info.layer_count_or_depth = 1;
+    tex_info.num_levels = 1;
+    scene_texture_ = SDL_CreateGPUTexture(device_, &tex_info);
+    if (scene_texture_ == nullptr) {
+        SDL_Log("SDL3GPUShader: failed to create scene texture: %s", SDL_GetError());
+        cleanup();
+        return false;
+    }
+
+    // ----------------------------------------------------------------
+    // 4. Create upload transfer buffer (CPU → GPU, size = w*h*4 bytes)
+    // ----------------------------------------------------------------
+    SDL_GPUTransferBufferCreateInfo tb_info = {};
+    tb_info.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
+    tb_info.size = static_cast<Uint32>(tex_width_ * tex_height_ * 4);
+    upload_buffer_ = SDL_CreateGPUTransferBuffer(device_, &tb_info);
+    if (upload_buffer_ == nullptr) {
+        SDL_Log("SDL3GPUShader: failed to create upload buffer: %s", SDL_GetError());
+        cleanup();
+        return false;
+    }
+
+    // ----------------------------------------------------------------
+    // 5. Create nearest-neighbour sampler (retro pixel art)
+    // ----------------------------------------------------------------
+    SDL_GPUSamplerCreateInfo samp_info = {};
+    samp_info.min_filter = SDL_GPU_FILTER_NEAREST;
+    samp_info.mag_filter = SDL_GPU_FILTER_NEAREST;
+    samp_info.mipmap_mode = SDL_GPU_SAMPLERMIPMAPMODE_NEAREST;
+    samp_info.address_mode_u = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
+    samp_info.address_mode_v = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
+    samp_info.address_mode_w = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
+    sampler_ = SDL_CreateGPUSampler(device_, &samp_info);
+    if (sampler_ == nullptr) {
+        SDL_Log("SDL3GPUShader: failed to create sampler: %s", SDL_GetError());
+        cleanup();
+        return false;
+    }
+
+    // ----------------------------------------------------------------
+    // 6. Create PostFX graphics pipeline
+    // ----------------------------------------------------------------
+    if (!createPipeline()) {
+        cleanup();
+        return false;
+    }
+
+    is_initialized_ = true;
+    SDL_Log("SDL3GPUShader: initialized OK (%dx%d)", tex_width_, tex_height_);
+    return true;
+}
+
+// ---------------------------------------------------------------------------
+// createPipeline
+// ---------------------------------------------------------------------------
+auto SDL3GPUShader::createPipeline() -> bool {
+    const SDL_GPUTextureFormat SWAPCHAIN_FMT = SDL_GetGPUSwapchainTextureFormat(device_, window_);
+
+#ifdef __APPLE__
+    SDL_GPUShader* vert = createShaderMSL(device_, POSTFX_VERT_MSL, "postfx_vs",
+        SDL_GPU_SHADERSTAGE_VERTEX, 0, 0);
+    SDL_GPUShader* frag = createShaderMSL(device_, POSTFX_FRAG_MSL, "postfx_fs",
+        SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 1);
+#else
+    SDL_GPUShader* vert = createShaderSPIRV(device_, kpostfx_vert_spv, kpostfx_vert_spv_size,
+        "main", SDL_GPU_SHADERSTAGE_VERTEX, 0, 0);
+    SDL_GPUShader* frag = createShaderSPIRV(device_, kpostfx_frag_spv, kpostfx_frag_spv_size,
+        "main", SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 1);
+#endif
+
+    if ((vert == nullptr) || (frag == nullptr)) {
+        SDL_Log("SDL3GPUShader: failed to compile PostFX shaders");
+        if (vert != nullptr) { SDL_ReleaseGPUShader(device_, vert); }
+        if (frag != nullptr) { SDL_ReleaseGPUShader(device_, frag); }
+        return false;
+    }
+
+    SDL_GPUColorTargetBlendState no_blend = {};
+    no_blend.enable_blend = false;
+    no_blend.enable_color_write_mask = false;
+
+    SDL_GPUColorTargetDescription color_target = {};
+    color_target.format = SWAPCHAIN_FMT;
+    color_target.blend_state = no_blend;
+
+    SDL_GPUVertexInputState no_input = {};
+
+    SDL_GPUGraphicsPipelineCreateInfo pipe_info = {};
+    pipe_info.vertex_shader = vert;
+    pipe_info.fragment_shader = frag;
+    pipe_info.vertex_input_state = no_input;
+    pipe_info.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
+    pipe_info.target_info.num_color_targets = 1;
+    pipe_info.target_info.color_target_descriptions = &color_target;
+
+    pipeline_ = SDL_CreateGPUGraphicsPipeline(device_, &pipe_info);
+
+    SDL_ReleaseGPUShader(device_, vert);
+    SDL_ReleaseGPUShader(device_, frag);
+
+    if (pipeline_ == nullptr) {
+        SDL_Log("SDL3GPUShader: pipeline creation failed: %s", SDL_GetError());
+        return false;
+    }
+    return true;
+}
+
+// ---------------------------------------------------------------------------
+// uploadPixels — copies ARGB8888 CPU pixels into the GPU transfer buffer
+// ---------------------------------------------------------------------------
+void SDL3GPUShader::uploadPixels(const Uint32* pixels, int width, int height) {
+    if (!is_initialized_ || (upload_buffer_ == nullptr)) { return; }
+
+    void* mapped = SDL_MapGPUTransferBuffer(device_, upload_buffer_, false);
+    if (mapped == nullptr) {
+        SDL_Log("SDL3GPUShader: SDL_MapGPUTransferBuffer failed: %s", SDL_GetError());
+        return;
+    }
+    std::memcpy(mapped, pixels, static_cast<size_t>(width * height * 4));
+    SDL_UnmapGPUTransferBuffer(device_, upload_buffer_);
+}
+
+// ---------------------------------------------------------------------------
+// render — upload scene texture + PostFX pass → swapchain
+// ---------------------------------------------------------------------------
+void SDL3GPUShader::render() {
+    if (!is_initialized_) { return; }
+
+    SDL_GPUCommandBuffer* cmd = SDL_AcquireGPUCommandBuffer(device_);
+    if (cmd == nullptr) {
+        SDL_Log("SDL3GPUShader: SDL_AcquireGPUCommandBuffer failed: %s", SDL_GetError());
+        return;
+    }
+
+    // ---- Copy pass: transfer buffer → scene texture ----
+    SDL_GPUCopyPass* copy = SDL_BeginGPUCopyPass(cmd);
+    if (copy != nullptr) {
+        SDL_GPUTextureTransferInfo src = {};
+        src.transfer_buffer = upload_buffer_;
+        src.offset = 0;
+        src.pixels_per_row = static_cast<Uint32>(tex_width_);
+        src.rows_per_layer = static_cast<Uint32>(tex_height_);
+
+        SDL_GPUTextureRegion dst = {};
+        dst.texture = scene_texture_;
+        dst.w = static_cast<Uint32>(tex_width_);
+        dst.h = static_cast<Uint32>(tex_height_);
+        dst.d = 1;
+
+        SDL_UploadToGPUTexture(copy, &src, &dst, false);
+        SDL_EndGPUCopyPass(copy);
+    }
+
+    // ---- Acquire swapchain texture ----
+    SDL_GPUTexture* swapchain = nullptr;
+    Uint32 sw = 0;
+    Uint32 sh = 0;
+    if (!SDL_AcquireGPUSwapchainTexture(cmd, window_, &swapchain, &sw, &sh)) {
+        SDL_Log("SDL3GPUShader: SDL_AcquireGPUSwapchainTexture failed: %s", SDL_GetError());
+        SDL_SubmitGPUCommandBuffer(cmd);
+        return;
+    }
+    if (swapchain == nullptr) {
+        // Window minimized — skip frame
+        SDL_SubmitGPUCommandBuffer(cmd);
+        return;
+    }
+
+    // ---- Render pass: PostFX → swapchain ----
+    SDL_GPUColorTargetInfo color_target = {};
+    color_target.texture = swapchain;
+    color_target.load_op = SDL_GPU_LOADOP_CLEAR;
+    color_target.store_op = SDL_GPU_STOREOP_STORE;
+    color_target.clear_color = {.r = 0.0F, .g = 0.0F, .b = 0.0F, .a = 1.0F};
+
+    SDL_GPURenderPass* pass = SDL_BeginGPURenderPass(cmd, &color_target, 1, nullptr);
+    if (pass != nullptr) {
+        SDL_BindGPUGraphicsPipeline(pass, pipeline_);
+
+        SDL_GPUTextureSamplerBinding binding = {};
+        binding.texture = scene_texture_;
+        binding.sampler = sampler_;
+        SDL_BindGPUFragmentSamplers(pass, 0, &binding, 1);
+
+        SDL_PushGPUFragmentUniformData(cmd, 0, &uniforms_, sizeof(PostFXUniforms));
+
+        SDL_DrawGPUPrimitives(pass, 3, 1, 0, 0);
+        SDL_EndGPURenderPass(pass);
+    }
+
+    SDL_SubmitGPUCommandBuffer(cmd);
+}
+
+// ---------------------------------------------------------------------------
+// cleanup
+// ---------------------------------------------------------------------------
+void SDL3GPUShader::cleanup() {
+    is_initialized_ = false;
+
+    if (device_ != nullptr) {
+        SDL_WaitForGPUIdle(device_);
+
+        if (pipeline_ != nullptr) {
+            SDL_ReleaseGPUGraphicsPipeline(device_, pipeline_);
+            pipeline_ = nullptr;
+        }
+        if (scene_texture_ != nullptr) {
+            SDL_ReleaseGPUTexture(device_, scene_texture_);
+            scene_texture_ = nullptr;
+        }
+        if (upload_buffer_ != nullptr) {
+            SDL_ReleaseGPUTransferBuffer(device_, upload_buffer_);
+            upload_buffer_ = nullptr;
+        }
+        if (sampler_ != nullptr) {
+            SDL_ReleaseGPUSampler(device_, sampler_);
+            sampler_ = nullptr;
+        }
+
+        SDL_ReleaseWindowFromGPUDevice(device_, window_);
+        SDL_DestroyGPUDevice(device_);
+        device_ = nullptr;
+    }
+    window_ = nullptr;
+}
+
+// ---------------------------------------------------------------------------
+// Shader creation helpers
+// ---------------------------------------------------------------------------
+auto SDL3GPUShader::createShaderMSL(SDL_GPUDevice* device,
+    const char* msl_source,
+    const char* entrypoint,
+    SDL_GPUShaderStage stage,
+    Uint32 num_samplers,
+    Uint32 num_uniform_buffers) -> SDL_GPUShader* {
+    SDL_GPUShaderCreateInfo info = {};
+    info.code = reinterpret_cast<const Uint8*>(msl_source);
+    info.code_size = std::strlen(msl_source) + 1;
+    info.entrypoint = entrypoint;
+    info.format = SDL_GPU_SHADERFORMAT_MSL;
+    info.stage = stage;
+    info.num_samplers = num_samplers;
+    info.num_uniform_buffers = num_uniform_buffers;
+    SDL_GPUShader* shader = SDL_CreateGPUShader(device, &info);
+    if (shader == nullptr) {
+        SDL_Log("SDL3GPUShader: MSL shader '%s' failed: %s", entrypoint, SDL_GetError());
+    }
+    return shader;
+}
+
+auto SDL3GPUShader::createShaderSPIRV(SDL_GPUDevice* device,
+    const uint8_t* spv_code,
+    size_t spv_size,
+    const char* entrypoint,
+    SDL_GPUShaderStage stage,
+    Uint32 num_samplers,
+    Uint32 num_uniform_buffers) -> SDL_GPUShader* {
+    SDL_GPUShaderCreateInfo info = {};
+    info.code = spv_code;
+    info.code_size = spv_size;
+    info.entrypoint = entrypoint;
+    info.format = SDL_GPU_SHADERFORMAT_SPIRV;
+    info.stage = stage;
+    info.num_samplers = num_samplers;
+    info.num_uniform_buffers = num_uniform_buffers;
+    SDL_GPUShader* shader = SDL_CreateGPUShader(device, &info);
+    if (shader == nullptr) {
+        SDL_Log("SDL3GPUShader: SPIRV shader '%s' failed: %s", entrypoint, SDL_GetError());
+    }
+    return shader;
+}
+
+}  // namespace Rendering

source/core/rendering/sdl3gpu/sdl3gpu_shader.hpp

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_gpu.h>
+
+#include "core/rendering/shader_backend.hpp"
+
+// PostFX uniforms pushed to fragment stage each frame.
+// Must match the MSL struct and GLSL uniform block layout.
+struct PostFXUniforms {
+        float vignette_strength;  // 0 = none, ~0.8 = subtle
+        float chroma_strength;    // 0 = off, ~0.2 = subtle chromatic aberration
+        float scanline_strength;  // 0 = off, 1 = full
+        float screen_height;      // logical height in pixels (for resolution-independent scanlines)
+};
+
+namespace Rendering {
+
+/**
+ * @brief Backend de shaders usando SDL3 GPU API (Metal en macOS, Vulkan/SPIR-V en Win/Linux)
+ *
+ * Reemplaza el backend OpenGL para que los shaders PostFX funcionen en macOS.
+ * Pipeline: Surface pixels (CPU) → SDL_GPUTransferBuffer → SDL_GPUTexture (scene)
+ *           → PostFX render pass → swapchain → present
+ */
+class SDL3GPUShader : public ShaderBackend {
+    public:
+        SDL3GPUShader() = default;
+        ~SDL3GPUShader() override;
+
+        auto init(SDL_Window* window,
+            SDL_Texture* texture,
+            const std::string& vertex_source,
+            const std::string& fragment_source) -> bool override;
+
+        void render() override;
+        void setTextureSize(float width, float height) override {}
+        void cleanup() override;
+        [[nodiscard]] auto isHardwareAccelerated() const -> bool override { return is_initialized_; }
+
+        // Sube píxeles ARGB8888 desde CPU; llamado antes de render()
+        void uploadPixels(const Uint32* pixels, int width, int height) override;
+
+    private:
+        static auto createShaderMSL(SDL_GPUDevice* device,
+            const char* msl_source,
+            const char* entrypoint,
+            SDL_GPUShaderStage stage,
+            Uint32 num_samplers,
+            Uint32 num_uniform_buffers) -> SDL_GPUShader*;
+
+        static auto createShaderSPIRV(SDL_GPUDevice* device,
+            const uint8_t* spv_code,
+            size_t spv_size,
+            const char* entrypoint,
+            SDL_GPUShaderStage stage,
+            Uint32 num_samplers,
+            Uint32 num_uniform_buffers) -> SDL_GPUShader*;
+
+        auto createPipeline() -> bool;
+
+        SDL_Window* window_ = nullptr;
+        SDL_GPUDevice* device_ = nullptr;
+        SDL_GPUGraphicsPipeline* pipeline_ = nullptr;
+        SDL_GPUTexture* scene_texture_ = nullptr;
+        SDL_GPUTransferBuffer* upload_buffer_ = nullptr;
+        SDL_GPUSampler* sampler_ = nullptr;
+
+        PostFXUniforms uniforms_{.vignette_strength = 0.6F, .chroma_strength = 0.15F, .scanline_strength = 0.7F, .screen_height = 192.0F};
+
+        int tex_width_ = 0;
+        int tex_height_ = 0;
+        bool is_initialized_ = false;
+};
+
+}  // namespace Rendering