WutVideoDriver.h

/****************************************************************************
 * Platform Abstraction Layer (WUT driver)
 * Daryl Borth 2026
 * WutVideoDriver.h
 ***************************************************************************/
#pragma once
 
#include <vector>
#include <coreinit/time.h>
#include <gx2/sampler.h>
#include <gx2/texture.h>
#include "../VideoDriver.h"
#include "../Mutex.h"

enum class OutputTarget
{
    TV = 0,
    DRC = 1
};
 
static const int OUTPUT_TARGET_COUNT = 2;

struct WutMesh
{
    float * positions;     
    uint8_t * colors;     
    uint32_t count;            
    WutMesh * next;          
};

struct WutDrawCmd
{
    enum class Kind : uint8_t
    {
        Texture,        
        TextureRotated, 
        Color,          
        Mesh,           
        MeshInstance    
    };
 
    Kind kind;
    uint32_t slot;                
    const GX2Texture * texture;   
    const GX2Sampler * sampler;   
    float angle;                  
    float offset[3];              
    float scale[3];               
    float colorIntensity[4];
    uint32_t first;          
    uint32_t count;          
    const WutMesh * mesh;    
};

class WutVideoDriver : public VideoDriver
{
    public:
        WutVideoDriver();
        ~WutVideoDriver() override;
 
        void init(int width, int height) override;
        void shutdown() override;
        void render() override;
        void clearScreen(const PixelColor& color) override;
 
        int getScreenWidth() const override { return screenWidth; }
        int getScreenHeight() const override { return screenHeight; }
        uint32_t getFrameTimer() override;
 
        int getRefreshRate() const override;
        float getDeltaTime() const override;
        float getUIScale() const override { return uiScale; }

        int getTargetWidth(OutputTarget target) const { return targetWidth[(int)target]; }
        int getTargetHeight(OutputTarget target) const { return targetHeight[(int)target]; }
 
        ImageRenderer* getImageRenderer() override { return imageRenderer; }
        GlyphRenderer* getGlyphRenderer() override { return glyphRenderer; }

        bool isForeground() const;
 
        // Copies the drawn TV/DRC contents to their scan buffers and submits
        // the flip. Always pipelined: submits and returns without waiting for
        // the GPU to finish (that wait is prepareFrame()'s job, below). The
        // one wait done here is for the *previous* submit's flip, since the
        // copy above can't safely land on a scan buffer the display hasn't
        // finished swapping away from yet.
        void presentBuffer();

        void queueDraw(const WutDrawCmd& cmd);

        void queueMesh(const MeshVertex* vertices, size_t count);

        void queueMeshInstance(const WutMesh* mesh, float x, float y, float scaleX, float scaleY);

        void retireMesh(WutMesh* mesh);

        void flushDrawQueue();

        static const unsigned kAllTargets = 3;
        void setUiTargets(unsigned mask) { uiTargets = mask; }

        void waitForIdle();
 
        // Binds the TV context state and resets the per-frame render state
        // (viewport/scissor/blend/depth/cull) that WHBGfxInit() doesn't set
        // on its own, and rewinds the shared shader slot counters (see
        // ColorShader::resetFrame() / Texture2DShader::resetFrame()).
        // `targets` (a bit per OutputTarget, as for setUiTargets()) says which
        // outputs are cleared and rebound; an output left out keeps what it
        // shows now, and that is what presentBuffer() will send to it again.
        void prepareFrame(unsigned targets = kAllTargets);

        bool isPresentPending() const;
    private:
        static const size_t cuMaxQueuedDraws = 4096;
        std::vector<WutDrawCmd> drawQueue;
 
        // Vertex arena for Mesh draws. Written when a mesh is queued, made visible to the
        // GPU in flushDrawQueue(), read by both the TV and GamePad replays, and rewound
        // once per frame in prepareFrame() - never mid-frame, because a draw submitted
        // earlier in the frame may still be reading it (same rule as ColorShader's slots).
        static const uint32_t cuMeshArenaVertices = 1u << 18;
        float * meshPositions = nullptr;    // 3 floats (NDC x, y, 0) per vertex
        uint8_t * meshColors = nullptr;     // RGBA8 per vertex
        uint32_t meshUsed = 0;              // vertices written this frame
        uint32_t meshFlushed = 0;           // vertices already invalidated for the GPU
 
        // Meshes whose owners let go of them, waiting for the GPU to finish with them
        Mutex * retireLock = nullptr;
        WutMesh * retiredMeshes = nullptr;
        void freeRetiredMeshes();
        void replayDrawQueue() const; // draws drawQueue into whichever context is currently bound
 
        unsigned uiTargets = kAllTargets;
        bool gpuFramesInFlight = false;   // a pipelined frame was submitted and not yet retired/drained
        OSTime lastSubmitTimeStamp = 0;   // GX2 timestamp of that submit
 
        // Queries GX2's current TV scan mode/aspect ratio and derives the
        // physical TV and DRC target dims
        void computeUIScale();
 
        int screenWidth;
        int screenHeight;
        float uiScale = 1.0f;
        int targetWidth[OUTPUT_TARGET_COUNT] = { 0, 0 };
        int targetHeight[OUTPUT_TARGET_COUNT] = { 0, 0 };
        PixelColor clearColor;
 
        ImageRenderer * imageRenderer;
        GlyphRenderer * glyphRenderer;
};

class WutImageRenderer : public ImageRenderer
{
    public:
        WutImageRenderer(WutVideoDriver * driver);
 
        void * createTexture(int width, int height) override;
        void loadTextureData(void * texture, const uint8_t * rgba, int width, int height) override;
        bool canReuseTexture(int allocWidth, int allocHeight, int width, int height) const override;
        void destroyTexture(void * texture) override;
        void drawTexture(void * texture, float xpos, float ypos, uint16_t width, uint16_t height, float degrees, float scaleX, float scaleY, uint8_t alpha) override;
        void drawRectangle(float x, float y, float width, float height, PixelColor color) override;
        void drawMesh(const MeshVertex* vertices, size_t count) override;
        void* createMesh(const MeshVertex* vertices, size_t count) override;
        void destroyMesh(void* mesh) override;
        void drawMeshInstance(void* mesh, float x, float y, float scaleX, float scaleY) override;
 
    private:
        WutVideoDriver * driver;
        GX2Sampler sampler;
};

class WutGlyphRenderer : public GlyphRenderer
{
    public:
        WutGlyphRenderer(WutVideoDriver * driver);
 
        void* createTexture(uint16_t width, uint16_t height) override;
        void loadTextureData(void* texture, FT_Bitmap* bitmap) override;
        void destroyTexture(void* texture) override;
 
        void drawQuad(void* texture, int16_t screenX, int16_t screenY, uint16_t width, uint16_t height, const PixelColor& color) override;
        void drawFeature(int16_t screenX, int16_t screenY, uint16_t width, uint16_t height, const PixelColor& color) override;
 
    private:
        WutVideoDriver * driver;
        GX2Sampler sampler;
};