Texture2DShader.h

/****************************************************************************
 * Platform Abstraction Layer (WUT driver)
 * Daryl Borth 2026
 * Texture2DShader.h
 ***************************************************************************/
#ifndef WUT_TEXTURE_2D_SHADER_H_
#define WUT_TEXTURE_2D_SHADER_H_
 
#include "VertexShader.h"
#include "PixelShader.h"
#include "FetchShader.h"
#include <gx2r/buffer.h>
#include <gx2r/draw.h>
#include <gx2r/resource.h>

class Texture2DShader : public Shader
{
    private:
        Texture2DShader();
        virtual ~Texture2DShader();
 
        static const uint32_t cuAttributeCount = 2;
        static const uint32_t ciPositionVtxsSize = 4 * cuVertexAttrSize;
        static const uint32_t ciTexCoordsVtxsSize = 4 * cuTexCoordAttrSize;
 
        static Texture2DShader * shaderInstance;
 
        FetchShader * fetchShader;
        VertexShader vertexShader;
        PixelShader pixelShader;
 
        float * posVtxs;
        float * texCoords;
 
        // Rotated quads are positioned on the CPU (see WutImageRenderer::drawTexture)
        // and drawn with an identity transform, because the compiled vertex
        // shader's rotation assumes a 16:9 canvas and warps on a 4:3 one.
        // Each rotated draw needs its own vertex slot: GX2 draws are
        // asynchronous, so a single shared buffer would be overwritten while
        // an earlier draw this frame is still queued (same reasoning as
        // ColorShader's per-draw color slots). Slots are padded to
        // GX2_VERTEX_BUFFER_ALIGNMENT so every slot offset stays aligned.
        static const uint32_t cuMaxRotatedDraws = 64;
        static const uint32_t cuRotatedSlotSize = GX2_VERTEX_BUFFER_ALIGNMENT;
        static_assert(4 * cuVertexAttrSize <= cuRotatedSlotSize, "rotated quad must fit in one slot");
        GX2RBuffer rotatedBuffer;
        uint32_t rotatedSlot;
 
        uint32_t angleLocation;
        uint32_t offsetLocation;
        uint32_t scaleLocation;
        uint32_t colorIntensityLocation;
        uint32_t blurLocation;
        uint32_t samplerLocation;
        uint32_t positionLocation;
        uint32_t texCoordLocation;
 
    public:
        static Texture2DShader * instance()
        {
            if(!shaderInstance)
                shaderInstance = new Texture2DShader();
            return shaderInstance;
        }

        static void destroyInstance()
        {
            delete shaderInstance;
            shaderInstance = nullptr;
        }

        void setShaders() const
        {
            fetchShader->setShader();
            vertexShader.setShader();
            pixelShader.setShader();
        }

        void setAttributeBuffer() const
        {
            VertexShader::setAttributeBuffer(0, ciPositionVtxsSize, cuVertexAttrSize, posVtxs);
            VertexShader::setAttributeBuffer(1, ciTexCoordsVtxsSize, cuTexCoordAttrSize, texCoords);
        }

        void resetFrame()
        {
            rotatedSlot = 0;
        }

        bool uploadRotatedQuad(const float ndcCorners[8], uint32_t & slotOut)
        {
            if(!GX2RBufferExists(&rotatedBuffer) || rotatedSlot >= cuMaxRotatedDraws)
                return false;
 
            float * dst = static_cast<float *>(GX2RLockBufferEx(&rotatedBuffer, GX2R_RESOURCE_USAGE_CPU_WRITE));
            if(!dst)
                return false;
 
            slotOut = rotatedSlot++;
            dst += slotOut * (cuRotatedSlotSize / sizeof(float));
            for(int i = 0; i < 4; i++)
            {
                dst[i * 3 + 0] = ndcCorners[i * 2 + 0];
                dst[i * 3 + 1] = ndcCorners[i * 2 + 1];
                dst[i * 3 + 2] = 0.0f;
            }
            GX2RUnlockBufferEx(&rotatedBuffer, GX2R_RESOURCE_USAGE_CPU_WRITE);
            return true;
        }

        void setRotatedAttributeBuffer(uint32_t slot) const
        {
            GX2RSetAttributeBuffer(const_cast<GX2RBuffer *>(&rotatedBuffer), 0, cuVertexAttrSize, slot * cuRotatedSlotSize);
            VertexShader::setAttributeBuffer(1, ciTexCoordsVtxsSize, cuTexCoordAttrSize, texCoords);
        }

        void setAngle(float angleRadians)
        {
            VertexShader::setUniformReg(angleLocation, 4, &angleRadians);
        }

        void setOffset(const float offset[3])
        {
            VertexShader::setUniformReg(offsetLocation, 4, offset);
        }

        void setScale(const float scale[3])
        {
            VertexShader::setUniformReg(scaleLocation, 4, scale);
        }

        void setColorIntensity(const float colorIntensity[4])
        {
            PixelShader::setUniformReg(colorIntensityLocation, 4, colorIntensity);
        }

        void setTextureAndSampler(const GX2Texture * texture, const GX2Sampler * sampler) const
        {
            GX2SetPixelTexture(texture, samplerLocation);
            GX2SetPixelSampler(sampler, samplerLocation);
        }

        void clearBlur() const
        {
            static const float zero[3] = {0.0f, 0.0f, 0.0f};
            PixelShader::setUniformReg(blurLocation, 4, zero);
        }
};
 
#endif // WUT_TEXTURE_2D_SHADER_H_