primitivemaker.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    2025-08-05
// Version V2.1.0
//##################################################################################################
 
#pragma once
 
#include "variantmaker.h"
#include "../variant/types.h"
#include "../primitive/types.h"
#include "../primitive/indices.h"
#include "../primitive/sampler.h"
#include "../primitive/state.h"
 
#include <memory>
#include <map>
 
namespace cil
{
    // _indices
    ArrayIndicesPtr _arrayIndices(Indices::Mode mode, int count, int first = 0, int primCount = 0);
    ArrayIndicesPtr _triangles(int count, int first = 0, int primCount = 0);
    ArrayIndicesPtr _triangle_fan(int count, int first = 0, int primCount = 0);
    ArrayIndicesPtr _triangle_strip(int count, int first = 0, int primCount = 0);
    ArrayIndicesPtr _lines(int count, int first = 0, int primCount = 0);
    ArrayIndicesPtr _line_strip(int count, int first = 0, int primCount = 0);
    ArrayIndicesPtr _line_loop(int count, int first = 0, int primCount = 0);
    ArrayIndicesPtr _points(int count, int first = 0, int primCount = 0);
 
    ElementIndicesPtr _elementIndices(Indices::Mode mode, const Uint8ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _elementIndices(Indices::Mode mode, const Uint16ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _elementIndices(Indices::Mode mode, const Uint32ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
 
    ElementIndicesPtr _triangles(const Uint8ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _triangles(const Uint16ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _triangles(const Uint32ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _triangles(const std::initializer_list<unsigned int>& array, int count = -1, int offset = 0, int primCount = 0);
 
    ElementIndicesPtr _triangle_fan(const Uint8ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _triangle_fan(const Uint16ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _triangle_fan(const Uint32ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _triangle_fan(const std::initializer_list<unsigned int>& array, int count = -1, int offset = 0, int primCount = 0);
 
    ElementIndicesPtr _triangle_strip(const Uint8ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _triangle_strip(const Uint16ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _triangle_strip(const Uint32ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _triangle_strip(const std::initializer_list<unsigned int>& array, int count = -1, int offset = 0, int primCount = 0);
 
    ElementIndicesPtr _lines(const Uint8ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _lines(const Uint16ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _lines(const Uint32ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _lines(const std::initializer_list<unsigned int>& array, int count = -1, int offset = 0, int primCount = 0);
 
    ElementIndicesPtr _line_strip(const Uint8ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _line_strip(const Uint16ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _line_strip(const Uint32ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _line_strip(const std::initializer_list<unsigned int>& array, int count = -1, int offset = 0, int primCount = 0);
 
    ElementIndicesPtr _line_loop(const Uint8ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _line_loop(const Uint16ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _line_loop(const Uint32ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _line_loop(const std::initializer_list<unsigned int>& array, int count = -1, int offset = 0, int primCount = 0);
 
    ElementIndicesPtr _points(const Uint8ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _points(const Uint16ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _points(const Uint32ArrayPtr& buffer, int count = -1, int offset = 0, int primCount = 0);
    ElementIndicesPtr _points(const std::initializer_list<unsigned int>& array, int count = -1, int offset = 0, int primCount = 0);
 
    // _vertices
    VerticesPtr _vertices(const Float32ArrayPtr& buffer, int offset = 0, unsigned int stride = 0, unsigned int divisor = 0);
    VerticesPtr _vertices(const Int32ArrayPtr& buffer, int offset = 0, unsigned int stride = 0, unsigned int divisor = 0);
    VerticesPtr _vertices(const std::initializer_list<float>& array, int offset = 0, unsigned int stride = 0, unsigned int divisor = 0);
 
    // _verticesSet
    std::shared_ptr<std::map<std::string, VerticesPtr>> _verticesSet(const std::map<std::string, VerticesPtr>& verticesMap = {});
 
    // _geometry
    GeometryPtr _geometry(const std::shared_ptr<std::map<std::string, VerticesPtr>>& verticesSet = _verticesSet(),
        const IndicesPtr& indices = nullptr,
        const BoundingBoxPtr& boundingBox = nullptr);
    GeometryPtr _geometry(std::map<std::string, VerticesPtr> verticesSet,
        const IndicesPtr& indices = nullptr,
        const BoundingBoxPtr& boundingBox = nullptr);
    GeometryPtr _geometry(const IndicesPtr& indices,
        const BoundingBoxPtr& boundingBox = nullptr);
 
    // _blend
    BlendPtr _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);
 
    // _colorMask
    ColorMaskPtr _colorMask(bool red = true,
        bool green = true,
        bool blue = true,
        bool alpha = true);
 
    // _culling
    CullingPtr _culling(bool enabled = false,
        Culling::Face face = Culling::Face::CCW,
        Culling::Mode mode = Culling::Mode::BACK);
 
    // _depth
    DepthPtr _depth(bool enabled = false,
        Depth::Function func = Depth::Function::LESS,
        bool writeMask = true);
 
    // _line
    LinePtr _line(float width = 1.0f);
 
    // _point
    PointPtr _point(float size = 1.0f,
        bool programmable = false);
 
    // _polygon
    PolygonPtr _polygon(Polygon::Mode mode = Polygon::Mode::FILL);
 
    // _polygonOffset
    PolygonOffsetPtr _polygonOffset(bool enabled = false,
        float factor = 0.0f,
        float units = 0.0f);
 
    // _scissor
    ScissorPtr _scissor(bool enabled = false,
        int x = 0,
        int y = 0,
        int width = 0,
        int height = 0);
 
    // _stencil
    StencilPtr _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);
 
    // _sampler
    SamplerPtr _sampler(
        Sampler::Filter minFilter = Sampler::Filter::LINEAR_MIPMAP_NEAREST,
        Sampler::Filter magFilter = Sampler::Filter::LINEAR,
        Sampler::WrapMode wrapS = Sampler::WrapMode::REPEAT,
        Sampler::WrapMode wrapT = Sampler::WrapMode::REPEAT);
    SamplerPtr _samplerClamp();
    SamplerPtr _samplerRepeat();
    SamplerPtr _samplerMirror();
    SamplerPtr _samplerCube();
 
    // _texture
    TexturePtr _texture(int unit,
        const ImagePtr& image,
        const SamplerPtr& sampler = nullptr);
    TexturePtr _texture0(const ImagePtr& image, const SamplerPtr& sampler = nullptr);
    TexturePtr _texture1(const ImagePtr& image, const SamplerPtr& sampler = nullptr);
    TexturePtr _texture2(const ImagePtr& image, const SamplerPtr& sampler = nullptr);
    TexturePtr _texture3(const ImagePtr& image, const SamplerPtr& sampler = nullptr);
    TexturePtr _texture4(const ImagePtr& image, const SamplerPtr& sampler = nullptr);
    TexturePtr _texture5(const ImagePtr& image, const SamplerPtr& sampler = nullptr);
    TexturePtr _texture6(const ImagePtr& image, const SamplerPtr& sampler = nullptr);
    TexturePtr _texture7(const ImagePtr& image, const SamplerPtr& sampler = nullptr);
 
    // _program
    ProgramPtr _program(
        const VertexSourcePtr& vertex = nullptr,
        const FragmentSourcePtr& fragment = nullptr,
        const GeometrySourcePtr& geometry = nullptr);
    ProgramPtr _program(
        const FragmentSourcePtr& fragment,
        const GeometrySourcePtr& geometry = nullptr);
    ProgramPtr _program(
        const GeometrySourcePtr& geometry);
    ProgramPtr _program(const std::string& vertexString);
    ProgramPtr _program(const std::string& vertexString, const std::string& fragmentString);
    ProgramPtr _program(const std::string& vertexString, const std::string& fragmentString, const std::string& geometryString);
 
    // _parameters
    std::shared_ptr<std::map<std::string, VariantPtr>> _parameters(const std::map<std::string, VariantPtr>& parameters = {});
 
    // _states
    std::shared_ptr<std::vector<StatePtr>> _states(const std::vector<StatePtr>& states = {});
 
    // _material
    MaterialPtr _material(
        const ProgramPtr& program = nullptr,
        const std::shared_ptr<std::map<std::string, VariantPtr>>& parameters = nullptr,
        const std::shared_ptr<std::vector<StatePtr>>& states = nullptr);
    MaterialPtr _material(
        const ProgramPtr& program,
        const std::shared_ptr<std::vector<StatePtr>>& states);
    MaterialPtr _material(
        const std::shared_ptr<std::map<std::string, VariantPtr>>& parameters,
        const std::shared_ptr<std::vector<StatePtr>>& states = nullptr);
 
    MaterialPtr _material(
        const std::vector<SourcePtr>& sources,
        const std::map<std::string, VariantPtr>& parameters,
        const std::vector<StatePtr>& states);
    MaterialPtr _material(
        const std::vector<SourcePtr>& sources,
        const std::map<std::string, VariantPtr>& parameters);
    MaterialPtr _material(
        const std::vector<SourcePtr>& sources,
        const std::vector<StatePtr>& states);
    MaterialPtr _material(
        const std::vector<SourcePtr>& sources);
 
    MaterialPtr _material(
        const ProgramPtr& program,
        const std::map<std::string, VariantPtr>& parameters,
        const std::vector<StatePtr>& states);
    MaterialPtr _material(
        const ProgramPtr& program,
        const std::map<std::string, VariantPtr>& parameters);
    MaterialPtr _material(
        const ProgramPtr& program,
        const std::vector<StatePtr>& states);
    MaterialPtr _material(
        const std::map<std::string, VariantPtr>& parameters,
        const std::vector<StatePtr>& states);
    MaterialPtr _material(
        const std::map<std::string, VariantPtr>& parameters);
    MaterialPtr _material(
        const std::vector<StatePtr>& states);
 
    // _background
    BackgroundPtr _background(const Vector2iPtr& size,
        const Color4fPtr& colorMask = nullptr,
        const RealPtr& depthMask = nullptr,
        const IntegerPtr& stencilMask = nullptr,
        const Vector2iPtr& coordinate = _ivec2());
    BackgroundPtr _simpleBackground(const Vector2iPtr& size,
        const Color4fPtr& colorMask = _clr4(0.7, 0.7, 0.7, 1.0),
        const RealPtr& depthMask = _real(1.0),
        const IntegerPtr& stencilMask = nullptr,
        const Vector2iPtr& coordinate = _ivec2());
 
    // _colorBuf
    ImageBufferPtr _colorBuf();
 
    // _target
    TargetPtr _target();
    TargetPtr _target(const std::vector<ImageBufferPtr>& array);
 
    // _primitive
    PrimitivePtr _primitive(
        const GeometryPtr& geometry = nullptr,
        const MaterialPtr& material = nullptr,
        int priority = 0);
    PrimitivePtr _primitive(
        const MaterialPtr& material,
        int priority = 0);
}