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    2024-10-31
// Version V1.1.0
//##################################################################################################
 
#pragma once
 
#include "../variant/variant.h"
#include "../variant/box.h"
#include "../variant/color.h"
#include "../variant/image.h"
#include "../variant/integer.h"
#include "../variant/matrix.h"
#include "../variant/minmax.h"
#include "../variant/plane.h"
#include "../variant/quaternion.h"
#include "../variant/ray.h"
#include "../variant/real.h"
#include "../variant/source.h"
#include "../variant/tuple.h"
#include "../variant/typedarray.h"
#include "../variant/vector.h"
 
#include <memory>
 
namespace cil
{
    // box2i
    std::shared_ptr<Box2i> _box2i();
    std::shared_ptr<Box2i> _box2i(int xmin, int xmax, int ymin, int ymax);
    std::shared_ptr<Box2i> _box2i(const Vector2i& min, const Vector2i& max);
    std::shared_ptr<Box2i> _box2i(const Box2i& other);
 
    // box2f
    std::shared_ptr<Box2f> _box2f();
    std::shared_ptr<Box2f> _box2f(float xmin, float xmax, float ymin, float ymax);
    std::shared_ptr<Box2f> _box2f(const Vector2f& min, const Vector2f& max);
    std::shared_ptr<Box2f> _box2f(const Box2f& other);
 
    // box3i
    std::shared_ptr<Box3i> _box3i();
    std::shared_ptr<Box3i> _box3i(int xmin, int xmax, int ymin, int ymax, int zmin, int zmax);
    std::shared_ptr<Box3i> _box3i(const Vector3i& min, const Vector3i& max);
    std::shared_ptr<Box3i> _box3i(const Box3i& other);
 
    // box3f
    std::shared_ptr<Box3f> _box3f();
    std::shared_ptr<Box3f> _box3f(float xmin, float xmax, float ymin, float ymax, float zmin, float zmax);
    std::shared_ptr<Box3f> _box3f(const Vector3f& min, const Vector3f& max);
    std::shared_ptr<Box3f> _box3f(const Box3f& other);
 
    // boundingbox
    std::shared_ptr<BoundingBox> _bbox();
    std::shared_ptr<BoundingBox> _bbox(float xmin, float xmax, float ymin, float ymax, float zmin, float zmax);
    std::shared_ptr<BoundingBox> _bbox(const Vector3f& min, const Vector3f& max);
    std::shared_ptr<BoundingBox> _bbox(const BoundingBox& other);
 
    // clr3
    std::shared_ptr<Color3f> _clr3();
    std::shared_ptr<Color3f> _clr3(float r, float g, float b);
    std::shared_ptr<Color3f> _clr3(const Color3f& other);
    std::shared_ptr<Color3f> _clr3(const Color3ub& other);
    std::shared_ptr<Color3f> _clr3(const Color4f& other);
    std::shared_ptr<Color3f> _clr3(const Color4ub& other);
 
    // clr3ub
    std::shared_ptr<Color3ub> _clr3ub();
    std::shared_ptr<Color3ub> _clr3ub(unsigned char r, unsigned char g, unsigned char b);
    std::shared_ptr<Color3ub> _clr3ub(const Color3f& other);
    std::shared_ptr<Color3ub> _clr3ub(const Color3ub& other);
    std::shared_ptr<Color3ub> _clr3ub(const Color4f& other);
    std::shared_ptr<Color3ub> _clr3ub(const Color4ub& other);
 
    // clr4
    std::shared_ptr<Color4f> _clr4();
    std::shared_ptr<Color4f> _clr4(float r, float g, float b, float a);
    std::shared_ptr<Color4f> _clr4(const Color3f& other);
    std::shared_ptr<Color4f> _clr4(const Color3ub& other);
    std::shared_ptr<Color4f> _clr4(const Color4f& other);
    std::shared_ptr<Color4f> _clr4(const Color4ub& other);
 
    // clr4ub
    std::shared_ptr<Color4ub> _clr4ub();
    std::shared_ptr<Color4ub> _clr4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
    std::shared_ptr<Color4ub> _clr4ub(const Color3f& other);
    std::shared_ptr<Color4ub> _clr4ub(const Color3ub& other);
    std::shared_ptr<Color4ub> _clr4ub(const Color4f& other);
    std::shared_ptr<Color4ub> _clr4ub(const Color4ub& other);
 
    // image2d
    std::shared_ptr<Image2D> _image2d(int width, int height, unsigned char* data = nullptr);
 
    // imageCube
    std::shared_ptr<ImageCube> _imageCube(const std::vector<Image2D>& images);
 
    // integer
    std::shared_ptr<Integer> _integer();
    std::shared_ptr<Integer> _integer(int v);
    std::shared_ptr<Integer> _integer(const Integer& other);
 
    // mat2
    std::shared_ptr<Matrix2f> _mat2();
    std::shared_ptr<Matrix2f> _mat2(float e00, float e01,
        float e10, float e11);
    std::shared_ptr<Matrix2f> _mat2(const Vector2f& c0,
        const Vector2f& c1);
    std::shared_ptr<Matrix2f> _mat2(const Matrix2f& other);
    std::shared_ptr<Matrix2f> _mat2(const Matrix3f& other);
    std::shared_ptr<Matrix2f> _mat2(const Matrix4f& other);
 
    // mat3
    std::shared_ptr<Matrix3f> _mat3();
    std::shared_ptr<Matrix3f> _mat3(float e00, float e01, float e02,
        float e10, float e11, float e12,
        float e20, float e21, float e22);
    std::shared_ptr<Matrix3f> _mat3(const Vector3f& c0,
        const Vector3f& c1,
        const Vector3f& c2);
    std::shared_ptr<Matrix3f> _mat3(const Matrix2f& other);
    std::shared_ptr<Matrix3f> _mat3(const Matrix3f& other);
    std::shared_ptr<Matrix3f> _mat3(const Matrix4f& other);
 
    // mat4
    std::shared_ptr<Matrix4f> _mat4();
    std::shared_ptr<Matrix4f> _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);
    std::shared_ptr<Matrix4f> _mat4(const Vector4f& c0,
        const Vector4f& c1,
        const Vector4f& c2,
        const Vector4f& c3);
    std::shared_ptr<Matrix4f> _mat4(const Matrix2f& other);
    std::shared_ptr<Matrix4f> _mat4(const Matrix3f& other);
    std::shared_ptr<Matrix4f> _mat4(const Matrix4f& other);
 
    // minmax
    std::shared_ptr<MinMax> _minmax();
    std::shared_ptr<MinMax> _minmax(float min, float max);
    std::shared_ptr<MinMax> _minmax(const MinMax& other);
 
    // plane
    std::shared_ptr<Plane> _plane();
    std::shared_ptr<Plane> _plane(float x, float y, float z, float w);
    std::shared_ptr<Plane> _plane(const Vector3f& origin, const Vector3f& normal);
    std::shared_ptr<Plane> _plane(const Plane& other);
 
    // quat
    std::shared_ptr<Quaternion> _quat();
    std::shared_ptr<Quaternion> _quat(float x, float y, float z, float w);
    std::shared_ptr<Quaternion> _quat(const Vector3f& axis, float angle);
    std::shared_ptr<Quaternion> _quat(const Quaternion& other);
 
    // ray
    std::shared_ptr<Ray> _ray();
    std::shared_ptr<Ray> _ray(const Vector3f& origin, const Vector3f& normal);
    std::shared_ptr<Ray> _ray(const Ray& other);
 
    // real
    std::shared_ptr<Real> _real();
    std::shared_ptr<Real> _real(float v);
    std::shared_ptr<Real> _real(const Real& other);
 
    // source
    std::shared_ptr<VertexSource> _vert(const std::string& text);
    std::shared_ptr<FragmentSource> _frag(const std::string& text);
    std::shared_ptr<GeometrySource> _geom(const std::string& text);
 
    // i8array
    std::shared_ptr<Int8Array> _i8array(int size = 0, char* data = nullptr, bool copy = true);
    std::shared_ptr<Int8Array> _i8array(const std::initializer_list<char>& array);
 
    // u8array
    std::shared_ptr<Uint8Array> _u8array(int size = 0, unsigned char* data = nullptr, bool copy = true);
    std::shared_ptr<Uint8Array> _u8array(const std::initializer_list<unsigned char>& array);
 
    // i16array
    std::shared_ptr<Int16Array> _i16array(int size = 0, short* data = nullptr, bool copy = true);
    std::shared_ptr<Int16Array> _i16array(const std::initializer_list<short>& array);
 
    // u16array
    std::shared_ptr<Uint16Array> _u16array(int size = 0, unsigned short* data = nullptr, bool copy = true);
    std::shared_ptr<Uint16Array> _u16array(const std::initializer_list<unsigned short>& array);
 
    // i32array
    std::shared_ptr<Int32Array> _i32array(int size = 0, int* data = nullptr, bool copy = true);
    std::shared_ptr<Int32Array> _i32array(const std::initializer_list<int>& array);
 
    // u32array
    std::shared_ptr<Uint32Array> _u32array(int size = 0, unsigned int* data = nullptr, bool copy = true);
    std::shared_ptr<Uint32Array> _u32array(const std::initializer_list<unsigned int>& array);
 
    // f32array
    std::shared_ptr<Float32Array> _f32array(int size = 0, float* data = nullptr, bool copy = true);
    std::shared_ptr<Float32Array> _f32array(const std::initializer_list<float>& array);
 
    // f64array
    std::shared_ptr<Float64Array> _f64array(int size = 0, double* data = nullptr, bool copy = true);
    std::shared_ptr<Float64Array> _f64array(const std::initializer_list<double>& array);
 
    // ivec2
    std::shared_ptr<Vector2i> _ivec2();
    std::shared_ptr<Vector2i> _ivec2(int x, int y);
    std::shared_ptr<Vector2i> _ivec2(const Vector2i& other);
    std::shared_ptr<Vector2i> _ivec2(const Vector3i& other);
    std::shared_ptr<Vector2i> _ivec2(const Vector4i& other);
 
    // vec2
    std::shared_ptr<Vector2f> _vec2();
    std::shared_ptr<Vector2f> _vec2(float x, float y);
    std::shared_ptr<Vector2f> _vec2(const Vector2f& other);
    std::shared_ptr<Vector2f> _vec2(const Vector3f& other);
    std::shared_ptr<Vector2f> _vec2(const Vector4f& other);
 
    // ivec3
    std::shared_ptr<Vector3i> _ivec3();
    std::shared_ptr<Vector3i> _ivec3(int x, int y, int z);
    std::shared_ptr<Vector3i> _ivec3(const Vector2i& other, int z = 0);
    std::shared_ptr<Vector3i> _ivec3(const Vector3i& other);
    std::shared_ptr<Vector3i> _ivec3(const Vector4i& other);
 
    // vec3
    std::shared_ptr<Vector3f> _vec3();
    std::shared_ptr<Vector3f> _vec3(float x, float y, float z);
    std::shared_ptr<Vector3f> _vec3(const Vector2f& other, float z = 0);
    std::shared_ptr<Vector3f> _vec3(const Vector3f& other);
    std::shared_ptr<Vector3f> _vec3(const Vector4f& other);
 
    // ivec4
    std::shared_ptr<Vector4i> _ivec4();
    std::shared_ptr<Vector4i> _ivec4(int x, int y, int z, int w);
    std::shared_ptr<Vector4i> _ivec4(const Vector2i& other, int z = 0, int w = 0);
    std::shared_ptr<Vector4i> _ivec4(const Vector3i& other, int w = 0);
    std::shared_ptr<Vector4i> _ivec4(const Vector4i& other);
 
    // vec4
    std::shared_ptr<Vector4f> _vec4();
    std::shared_ptr<Vector4f> _vec4(float x, float y, float z, float w);
    std::shared_ptr<Vector4f> _vec4(const Vector2f& other, float z = 0, float w = 0);
    std::shared_ptr<Vector4f> _vec4(const Vector3f& other, float w = 0);
    std::shared_ptr<Vector4f> _vec4(const Vector4f& other);
}