variantmaker.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 "../variant/types.h"
 
#include <string>
 
namespace cil
{
    // box2i
    Box2iPtr _box2i();
    Box2iPtr _box2i(int xmin, int xmax, int ymin, int ymax);
    Box2iPtr _box2i(const Vector2i& min, const Vector2i& max);
    Box2iPtr _box2i(const Box2i& other);
 
    // box2f
    Box2fPtr _box2f();
    Box2fPtr _box2f(float xmin, float xmax, float ymin, float ymax);
    Box2fPtr _box2f(const Vector2f& min, const Vector2f& max);
    Box2fPtr _box2f(const Box2f& other);
 
    // box3i
    Box3iPtr _box3i();
    Box3iPtr _box3i(int xmin, int xmax, int ymin, int ymax, int zmin, int zmax);
    Box3iPtr _box3i(const Vector3i& min, const Vector3i& max);
    Box3iPtr _box3i(const Box3i& other);
 
    // box3f
    Box3fPtr _box3f();
    Box3fPtr _box3f(float xmin, float xmax, float ymin, float ymax, float zmin, float zmax);
    Box3fPtr _box3f(const Vector3f& min, const Vector3f& max);
    Box3fPtr _box3f(const Box3f& other);
 
    // boundingbox
    BoundingBoxPtr _bbox();
    BoundingBoxPtr _bbox(float xmin, float xmax, float ymin, float ymax, float zmin, float zmax);
    BoundingBoxPtr _bbox(const Vector3f& min, const Vector3f& max);
    BoundingBoxPtr _bbox(const BoundingBox& other);
 
    // clr3
    Color3fPtr _clr3();
    Color3fPtr _clr3(float r, float g, float b);
    Color3fPtr _clr3(const Color3f& other);
    Color3fPtr _clr3(const Color3ub& other);
    Color3fPtr _clr3(const Color4f& other);
    Color3fPtr _clr3(const Color4ub& other);
 
    // clr3ub
    Color3ubPtr _clr3ub();
    Color3ubPtr _clr3ub(unsigned char r, unsigned char g, unsigned char b);
    Color3ubPtr _clr3ub(const Color3f& other);
    Color3ubPtr _clr3ub(const Color3ub& other);
    Color3ubPtr _clr3ub(const Color4f& other);
    Color3ubPtr _clr3ub(const Color4ub& other);
 
    // clr4
    Color4fPtr _clr4();
    Color4fPtr _clr4(float r, float g, float b, float a);
    Color4fPtr _clr4(const Color3f& other);
    Color4fPtr _clr4(const Color3ub& other);
    Color4fPtr _clr4(const Color4f& other);
    Color4fPtr _clr4(const Color4ub& other);
 
    // clr4ub
    Color4ubPtr _clr4ub();
    Color4ubPtr _clr4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
    Color4ubPtr _clr4ub(const Color3f& other);
    Color4ubPtr _clr4ub(const Color3ub& other);
    Color4ubPtr _clr4ub(const Color4f& other);
    Color4ubPtr _clr4ub(const Color4ub& other);
 
    // image2d
    Image2DPtr _image2d(int width, int height, unsigned char* data = nullptr);
 
    // imageCube
    ImageCubePtr _imageCube(const std::vector<Image2D>& images);
 
    // integer
    IntegerPtr _integer();
    IntegerPtr _integer(int v);
    IntegerPtr _integer(const Integer& other);
 
    // mat2
    Matrix2fPtr _mat2();
    Matrix2fPtr _mat2(float e00, float e01,
        float e10, float e11);
    Matrix2fPtr _mat2(const Vector2f& c0,
        const Vector2f& c1);
    Matrix2fPtr _mat2(const Matrix2f& other);
    Matrix2fPtr _mat2(const Matrix3f& other);
    Matrix2fPtr _mat2(const Matrix4f& other);
 
    // mat3
    Matrix3fPtr _mat3();
    Matrix3fPtr _mat3(float e00, float e01, float e02,
        float e10, float e11, float e12,
        float e20, float e21, float e22);
    Matrix3fPtr _mat3(const Vector3f& c0,
        const Vector3f& c1,
        const Vector3f& c2);
    Matrix3fPtr _mat3(const Matrix2f& other);
    Matrix3fPtr _mat3(const Matrix3f& other);
    Matrix3fPtr _mat3(const Matrix4f& other);
 
    // mat4
    Matrix4fPtr _mat4();
    Matrix4fPtr _mat4(float e00, float e01, float e02, float e03,
        float e10, float e11, float e12, float e13,
        float e20, float e21, float e22, float e23,
        float e30, float e31, float e32, float e33);
    Matrix4fPtr _mat4(const Vector4f& c0,
        const Vector4f& c1,
        const Vector4f& c2,
        const Vector4f& c3);
    Matrix4fPtr _mat4(const Matrix2f& other);
    Matrix4fPtr _mat4(const Matrix3f& other);
    Matrix4fPtr _mat4(const Matrix4f& other);
 
    // minmax
    MinMaxPtr _minmax();
    MinMaxPtr _minmax(float min, float max);
    MinMaxPtr _minmax(const MinMax& other);
 
    // plane
    PlanePtr _plane();
    PlanePtr _plane(float x, float y, float z, float w);
    PlanePtr _plane(const Vector3f& origin, const Vector3f& normal);
    PlanePtr _plane(const Plane& other);
 
    // quat
    QuaternionPtr _quat();
    QuaternionPtr _quat(float x, float y, float z, float w);
    QuaternionPtr _quat(const Vector3f& axis, float angle);
    QuaternionPtr _quat(const Quaternion& other);
 
    // ray
    RayPtr _ray();
    RayPtr _ray(const Vector3f& origin, const Vector3f& normal);
    RayPtr _ray(const Ray& other);
 
    // real
    RealPtr _real();
    RealPtr _real(float v);
    RealPtr _real(const Real& other);
 
    // source
    VertexSourcePtr _vert(const std::string& text);
    FragmentSourcePtr _frag(const std::string& text);
    GeometrySourcePtr _geom(const std::string& text);
 
    // i8array
    Int8ArrayPtr _i8array(int size = 0, char* data = nullptr, bool copy = true);
    Int8ArrayPtr _i8array(const std::initializer_list<char>& array);
 
    // u8array
    Uint8ArrayPtr _u8array(int size = 0, unsigned char* data = nullptr, bool copy = true);
    Uint8ArrayPtr _u8array(const std::initializer_list<unsigned char>& array);
 
    // i16array
    Int16ArrayPtr _i16array(int size = 0, short* data = nullptr, bool copy = true);
    Int16ArrayPtr _i16array(const std::initializer_list<short>& array);
 
    // u16array
    Uint16ArrayPtr _u16array(int size = 0, unsigned short* data = nullptr, bool copy = true);
    Uint16ArrayPtr _u16array(const std::initializer_list<unsigned short>& array);
 
    // i32array
    Int32ArrayPtr _i32array(int size = 0, int* data = nullptr, bool copy = true);
    Int32ArrayPtr _i32array(const std::initializer_list<int>& array);
 
    // u32array
    Uint32ArrayPtr _u32array(int size = 0, unsigned int* data = nullptr, bool copy = true);
    Uint32ArrayPtr _u32array(const std::initializer_list<unsigned int>& array);
 
    // f32array
    Float32ArrayPtr _f32array(int size = 0, float* data = nullptr, bool copy = true);
    Float32ArrayPtr _f32array(const std::initializer_list<float>& array);
 
    // f64array
    Float64ArrayPtr _f64array(int size = 0, double* data = nullptr, bool copy = true);
    Float64ArrayPtr _f64array(const std::initializer_list<double>& array);
 
    // ivec2
    Vector2iPtr _ivec2();
    Vector2iPtr _ivec2(int x, int y);
    Vector2iPtr _ivec2(const Vector2i& other);
    Vector2iPtr _ivec2(const Vector3i& other);
    Vector2iPtr _ivec2(const Vector4i& other);
 
    // vec2
    Vector2fPtr _vec2();
    Vector2fPtr _vec2(float x, float y);
    Vector2fPtr _vec2(const Vector2f& other);
    Vector2fPtr _vec2(const Vector3f& other);
    Vector2fPtr _vec2(const Vector4f& other);
 
    // ivec3
    Vector3iPtr _ivec3();
    Vector3iPtr _ivec3(int x, int y, int z);
    Vector3iPtr _ivec3(const Vector2i& other, int z = 0);
    Vector3iPtr _ivec3(const Vector3i& other);
    Vector3iPtr _ivec3(const Vector4i& other);
 
    // vec3
    Vector3fPtr _vec3();
    Vector3fPtr _vec3(float x, float y, float z);
    Vector3fPtr _vec3(const Vector2f& other, float z = 0);
    Vector3fPtr _vec3(const Vector3f& other);
    Vector3fPtr _vec3(const Vector4f& other);
 
    // ivec4
    Vector4iPtr _ivec4();
    Vector4iPtr _ivec4(int x, int y, int z, int w);
    Vector4iPtr _ivec4(const Vector2i& other, int z = 0, int w = 0);
    Vector4iPtr _ivec4(const Vector3i& other, int w = 0);
    Vector4iPtr _ivec4(const Vector4i& other);
 
    // vec4
    Vector4fPtr _vec4();
    Vector4fPtr _vec4(float x, float y, float z, float w);
    Vector4fPtr _vec4(const Vector2f& other, float z = 0, float w = 0);
    Vector4fPtr _vec4(const Vector3f& other, float w = 0);
    Vector4fPtr _vec4(const Vector4f& other);
}