state.h

//##################################################################################################
//
// Copyright (c) 2024 Beijing Qiongqi Tech Co.,Ltd. All rights reserved. 
 
// This source code is confidential and proprietary to Beijing Qiongqi Tech Co.,Ltd(The Holder). 
// Any unauthorized use, copying, modification, or distribution of the code is strictly prohibited. 
// Any user shall obtain authorizaition from the Holder before modifying the source code. And the user shall not
// sublicense, sell, distribute, or transfer the source code, whether in original or modified form, to any third party
// without the prior written consent of the Holder.
 
// This copyright notice and permission grant shall be included in all copies or substantial portions of the source code.
 
// Author  Cumulia Illustrator
// Date    2024-10-31
// Version V1.1.0
//##################################################################################################
 
#pragma once
 
#include "../variant/image.h"
#include "../object/object.h"
#include "sampler.h"
 
#include <memory>
#include <vector>
#include <map>
 
namespace cil
{
    class State : public Object
    {
    protected:
        std::string m_className;
 
    public:
        State();
 
        const std::string& className() const;
    };
 
    class Blend : public State
    {
    public:
        enum class Function
        {
            ZERO,
            ONE,
            SRC_COLOR,
            ONE_MINUS_SRC_COLOR,
            DST_COLOR,
            ONE_MINUS_DST_COLOR,
            SRC_ALPHA,
            ONE_MINUS_SRC_ALPHA,
            DST_ALPHA,
            ONE_MINUS_DST_ALPHA,
            CONSTANT_COLOR,
            ONE_MINUS_CONSTANT_COLOR,
            CONSTANT_ALPHA,
            ONE_MINUS_CONSTANT_ALPHA,
            SRC_ALPHA_SATURATE
        };
 
        enum class Equation
        {
            FUNC_ADD,
            FUNC_SUBTRACT,
            FUNC_REVERSE_SUBTRACT,
            MIN,
            MAX
        };
 
        bool enabled; 
        Function srcFunc;
        Function dstFunc;
        Equation equation;
 
        Blend(bool enabled = false,
            Blend::Function srcFunc = Blend::Function::SRC_ALPHA,
            Blend::Function dstFunc = Blend::Function::ONE_MINUS_SRC_ALPHA,
            Blend::Equation equation = Blend::Equation::FUNC_ADD);
    };
 
    class ColorMask : public State
    {
    public:
        bool red; 
        bool green; 
        bool blue; 
        bool alpha; 
 
        ColorMask(bool red = true,
            bool green = true,
            bool blue = true,
            bool alpha = true);
    };
 
    class Culling : public State
    {
    public:
        enum class Mode
        {
            BACK,
            FRONT,
            FRONT_AND_BACK
        };
        enum class Face
        {
            CCW,
            CW
        };
 
        bool enabled;
        Face face;
        Mode mode;
 
        Culling(bool enabled = false,
            Culling::Face face = Culling::Face::CCW,
            Culling::Mode mode = Culling::Mode::BACK);
    };
 
    class Depth : public State
    {
    public:
        enum class Function
        {
            NEVER,
            LESS,
            LEQUAL,
            EQUAL,
            NOTEQUAL,
            GEQUAL,
            GREATER,
            ALWAYS
        };
 
        bool enabled; 
        Function func;
        bool writeMask;
 
        Depth(bool enabled = false,
            Depth::Function func = Depth::Function::LESS,
            bool writeMask = true);
    };
 
    class Line : public State
    {
    public:
        float width;
 
        Line(float width = 1.0f);
    };
 
    class Point : public State
    {
    public:
        float size;
        bool programmable;
 
        Point(float size = 1.0f,
            bool programmable = false);
    };
 
    class Polygon : public State
    {
    public:
        enum class Mode
        {
            POINT,
            LINE,
            FILL
        };
 
        Mode mode;
 
        Polygon(Mode mode = Polygon::Mode::FILL);
    };
 
    class PolygonOffset : public State
    {
    public:
        bool enabled;
        float factor;
        float units;
 
        PolygonOffset(bool enabled = false,
            float factor = 0.0f,
            float units = 0.0f);
    };
 
    class Scissor : public State
    {
    public:
        bool enabled;
        int x;
        int y;
        int width;
        int height;
 
        Scissor(bool enabled = false,
            int x = 0,
            int y = 0,
            int width = 0,
            int height = 0);
    };
 
    class Stencil : public State
    {
    public:
 
        enum class Function
        {
            NEVER,
            LESS,
            LEQUAL,
            EQUAL,
            NOTEQUAL,
            GEQUAL,
            GREATER,
            ALWAYS
        };
 
        enum class Operation
        {
            KEEP,
            ZERO,
            REPLACE,
            INCR,
            DECR,
            INVERT,
            INCR_WRAP,
            DECR_WRAP
        };
 
        bool enabled;
 
        Operation sfail; 
        Operation dpfail; 
        Operation dppass; 
 
        Function func;
        int ref; 
        int mask;
 
        Stencil(bool enabled = false,
            Stencil::Operation sfail = Stencil::Operation::KEEP,
            Stencil::Operation dpfail = Stencil::Operation::KEEP,
            Stencil::Operation dppass = Stencil::Operation::KEEP,
            Stencil::Function func = Stencil::Function::ALWAYS,
            int ref = 0,
            int mask = 0xFF);
    };
 
    class Texture : public State
    {
    public:
        int unit;
        std::shared_ptr<Image> image;
        std::shared_ptr<Sampler> sampler;
 
        Texture(int unit,
            std::shared_ptr<Image> image,
            std::shared_ptr<Sampler> sampler);
    };
}