InternalCommandBuffer.h

#pragma once
 
namespace SharpKmyGfx
{
    ref class Shader;
    ref class Texture;
 
    public enum class PrimitiveType{
        Points,
        Lines,
        LineStrip,
        Triangles,
        TriangleStrip,
        TriangleFan,
    };
 
    public enum class IndexType{
        U8,
        U16,
        U32,
    };
 
    public enum class BlendFactor{
        Zero,
        One,
        SrcColor,
        OneMinusSrcColor,
        DstColor,
        OneMinusDstColor,
        SrcAlpha,
        OneMinusSrcAlpha,
        DstAlpha,
        OneMinusDstAlpha,
    };
 
    public enum class EquationType {
        Add,
        Subtract,
        ReverseSubtract,
        Min,
        Max,
    };
 
    public value struct BlendInfo
    {
    public:
        bool blend;
        BlendFactor srcColor, dstColor;
        EquationType colorEquation;
        BlendFactor srcAlpha, dstAlpha;
        EquationType alphaEquation;
 
        static BlendInfo noBlend()
        {
            BlendInfo r;
            r.blend = false;
            r.srcColor = BlendFactor::One;
            r.dstColor = BlendFactor::Zero;
            r.colorEquation = EquationType::Add;
            r.srcAlpha = BlendFactor::One;
            r.dstAlpha = BlendFactor::Zero;
            r.alphaEquation = EquationType::Add;
            return r;
        }
 
        static BlendInfo alphaBlend()
        {
            BlendInfo r;
            r.blend = true;
            r.srcColor = BlendFactor::SrcAlpha;
            r.dstColor = BlendFactor::OneMinusSrcAlpha;
            r.colorEquation = EquationType::Add;
            r.srcAlpha = BlendFactor::One;
            r.dstAlpha = BlendFactor::One;
            r.alphaEquation = EquationType::Add;
            return r;
        }
    };
 
    public enum class CullType {
        Back,
        None,
        Front,
        Double,
    };
 
    public enum class PolygonMode{
        Point,
        Line,
        Fill,
    };
 
    public ref class Framebuffer
    {
    public:
        kmyGfx::Framebuffer* _obj = nullptr;
    };
 
    public value struct StateInfo
    {
    public:
        FUNCTYPE depthFunc;//
        FUNCTYPE stencilFunc;//
        STENCILOP stencilOpFail;//
        STENCILOP stencilOpDepthFail;//
        STENCILOP stencilOpPass;//
        bool colorWriteR;
        bool colorWriteG;
        bool colorWriteB;
        bool colorWriteA;
        bool depthTest;//
        bool depthWrite;//
        bool stencilTest;//
        u32 stencilRef;//
        u32 stencilMask;//
 
        static StateInfo standard()
        {
            StateInfo r;
            r.depthFunc = FUNCTYPE::kLEQUAL;
            r.stencilFunc = FUNCTYPE::kALWAYS;
            r.stencilOpFail = STENCILOP::kKEEP;
            r.stencilOpDepthFail = STENCILOP::kKEEP;
            r.stencilOpPass = STENCILOP::kKEEP;
            r.depthTest = true;
            r.depthWrite = true;
            r.stencilTest = false;
            r.stencilRef = 0;
            r.stencilMask = 0;
            r.colorWriteR = true;
            r.colorWriteG = true;
            r.colorWriteB = true;
            r.colorWriteA = true;
            return r;
        };
    };
 
    public ref class UniformWriter
    {
    public:
        kmyGfx::Shader* shd;
        void *ptr;
        int materialBufferIndex = 0;
 
        void write(String^ name, float v);
        void write(String^ name, float x, float y);
        void write(String^ name, float x, float y, float z);
        void write(String^ name, float x, float y, float z, float w);
    };
 
    public ref class InternalCommandList
    {
    public:
        kmyGfx::GameViewDrawCommand* _cmd = nullptr;
        InternalCommandList(kmyGfx::GameViewDrawCommand* cmd) {
            _cmd = cmd;
        }
    };
 
    public ref class ICBMaterial
    {
    public:
        ICBMaterial();
        ~ICBMaterial();
        
        void writeUniform(String^ name, float v);
        void writeUniform(String^ name, float x, float y);
        void writeUniform(String^ name, float x, float y, float z);
        void writeUniform(String^ name, float x, float y, float z, float w);
 
        Shader^ _shader = nullptr;
        BlendInfo _bi;
        StateInfo _si;
        CullType _cull;
        PolygonMode _pm;
        float _lineWidth = 1.0f;
 
        char* _materialUniform = nullptr;
    };
 
    public ref class InternalCommandBuffer
    {
    public:
        kmyGfx::GameViewDrawCommandBuffer* _obj = nullptr;
 
        InternalCommandBuffer();
        ~InternalCommandBuffer();
        void drawVertices(PrimitiveType prim, ICBMaterial^ mtl, SharpKmyMath::Matrix4 transform, VertexBuffer^ vb);
        void drawVertices(PrimitiveType prim, ICBMaterial^ mtl, SharpKmyMath::Matrix4 transform, array<SharpKmyMath::Vector3>^ data);
        void drawVertices(PrimitiveType prim, ICBMaterial^ mtl, SharpKmyMath::Matrix4 transform, array<VertexPositionColor>^ data);
        void drawVertices(PrimitiveType prim, ICBMaterial^ mtl, SharpKmyMath::Matrix4 transform, array<VertexPositionTextureColor>^ data);
        /*
        void bindShader(Shader^ shader, bool skinned);
        void setTexture(int index, Texture^ t);
        void setTransformUniform(int materialBufferIndex, SharpKmyMath::Matrix4 mtx4);
        void drawVertices(PrimitiveType prim, int count, int instancenum);
        void drawVertices(VertexBuffer^ vb);
        void drawIndices(PrimitiveType prim, u32 count, u32 offset, IndexType itype, u32 instanceNum);
        void bindBlend(BlendInfo bi);
        void enableBlend(bool enable);
        void bindFramebuffer(Framebuffer^ fb);
        void viewport(u16 x, u16 y, u16 w, u16 h);
        void clear(bool color, bool depth, bool stencil);
        void clearColor(float r, float g, float b, float a);
        void bindPolygonState(CullType cull, PolygonMode polygonmode);
        void bindState(StateInfo si);
        void getVertexAndDraw(PrimitiveType prim, int materialBufferIndex, SharpKmyMath::Matrix4 mtx4, array<SharpKmyMath::Vector3> ^data);
        void getVertexAndDraw(PrimitiveType prim, int materialBufferIndex, SharpKmyMath::Matrix4 mtx4, array<VertexPositionTextureColor> ^data);
        void setLineWidth(float width);
        UniformWriter^ getUniformWriter(Shader^ shd);
        */
        void execBuffer(InternalCommandList^ icb);
        InternalCommandList^ getCommandList();
        void copyFramebuffer(Texture^ tex, int x, int y, int w, int h);
        void clearFramebuffer(float r, float g, float b, float a, bool color, bool depth, bool stencil);
    };
}