
// generated from codegen/templates/_vectortype.hpp

#ifndef E_MATH_VECTORTYPE_HPP
#define E_MATH_VECTORTYPE_HPP

// python
#define PY_SSIZE_T_CLEAN
#include <Python.h>
// glm
#include <glm/glm.hpp>
#include <glm/ext.hpp>



typedef glm::vec<1, bool, glm::defaultp> BVector1Glm;

struct BVector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    BVector1Glm *glm;
};

static BVector1 *
create_BVector1_from_glm(const BVector1Glm& glm);


struct BVector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    BVector1Glm *glm;
};



typedef glm::vec<1, double, glm::defaultp> DVector1Glm;

struct DVector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    DVector1Glm *glm;
};

static DVector1 *
create_DVector1_from_glm(const DVector1Glm& glm);


struct DVector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    DVector1Glm *glm;
};



typedef glm::vec<1, float, glm::defaultp> FVector1Glm;

struct FVector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    FVector1Glm *glm;
};

static FVector1 *
create_FVector1_from_glm(const FVector1Glm& glm);


struct FVector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    FVector1Glm *glm;
};



typedef glm::vec<1, int8_t, glm::defaultp> I8Vector1Glm;

struct I8Vector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    I8Vector1Glm *glm;
};

static I8Vector1 *
create_I8Vector1_from_glm(const I8Vector1Glm& glm);


struct I8Vector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I8Vector1Glm *glm;
};



typedef glm::vec<1, uint8_t, glm::defaultp> U8Vector1Glm;

struct U8Vector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    U8Vector1Glm *glm;
};

static U8Vector1 *
create_U8Vector1_from_glm(const U8Vector1Glm& glm);


struct U8Vector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U8Vector1Glm *glm;
};



typedef glm::vec<1, int16_t, glm::defaultp> I16Vector1Glm;

struct I16Vector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    I16Vector1Glm *glm;
};

static I16Vector1 *
create_I16Vector1_from_glm(const I16Vector1Glm& glm);


struct I16Vector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I16Vector1Glm *glm;
};



typedef glm::vec<1, uint16_t, glm::defaultp> U16Vector1Glm;

struct U16Vector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    U16Vector1Glm *glm;
};

static U16Vector1 *
create_U16Vector1_from_glm(const U16Vector1Glm& glm);


struct U16Vector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U16Vector1Glm *glm;
};



typedef glm::vec<1, int32_t, glm::defaultp> I32Vector1Glm;

struct I32Vector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    I32Vector1Glm *glm;
};

static I32Vector1 *
create_I32Vector1_from_glm(const I32Vector1Glm& glm);


struct I32Vector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I32Vector1Glm *glm;
};



typedef glm::vec<1, uint32_t, glm::defaultp> U32Vector1Glm;

struct U32Vector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    U32Vector1Glm *glm;
};

static U32Vector1 *
create_U32Vector1_from_glm(const U32Vector1Glm& glm);


struct U32Vector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U32Vector1Glm *glm;
};



typedef glm::vec<1, int, glm::defaultp> IVector1Glm;

struct IVector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    IVector1Glm *glm;
};

static IVector1 *
create_IVector1_from_glm(const IVector1Glm& glm);


struct IVector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    IVector1Glm *glm;
};



typedef glm::vec<1, unsigned int, glm::defaultp> UVector1Glm;

struct UVector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    UVector1Glm *glm;
};

static UVector1 *
create_UVector1_from_glm(const UVector1Glm& glm);


struct UVector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    UVector1Glm *glm;
};



typedef glm::vec<1, int64_t, glm::defaultp> I64Vector1Glm;

struct I64Vector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    I64Vector1Glm *glm;
};

static I64Vector1 *
create_I64Vector1_from_glm(const I64Vector1Glm& glm);


struct I64Vector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I64Vector1Glm *glm;
};



typedef glm::vec<1, uint64_t, glm::defaultp> U64Vector1Glm;

struct U64Vector1
{
    PyObject_HEAD
    PyObject *weakreflist;
    U64Vector1Glm *glm;
};

static U64Vector1 *
create_U64Vector1_from_glm(const U64Vector1Glm& glm);


struct U64Vector1Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U64Vector1Glm *glm;
};



typedef glm::vec<2, bool, glm::defaultp> BVector2Glm;

struct BVector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    BVector2Glm *glm;
};

static BVector2 *
create_BVector2_from_glm(const BVector2Glm& glm);


struct BVector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    BVector2Glm *glm;
};



typedef glm::vec<2, double, glm::defaultp> DVector2Glm;

struct DVector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    DVector2Glm *glm;
};

static DVector2 *
create_DVector2_from_glm(const DVector2Glm& glm);


struct DVector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    DVector2Glm *glm;
};



typedef glm::vec<2, float, glm::defaultp> FVector2Glm;

struct FVector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    FVector2Glm *glm;
};

static FVector2 *
create_FVector2_from_glm(const FVector2Glm& glm);


struct FVector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    FVector2Glm *glm;
};



typedef glm::vec<2, int8_t, glm::defaultp> I8Vector2Glm;

struct I8Vector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    I8Vector2Glm *glm;
};

static I8Vector2 *
create_I8Vector2_from_glm(const I8Vector2Glm& glm);


struct I8Vector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I8Vector2Glm *glm;
};



typedef glm::vec<2, uint8_t, glm::defaultp> U8Vector2Glm;

struct U8Vector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    U8Vector2Glm *glm;
};

static U8Vector2 *
create_U8Vector2_from_glm(const U8Vector2Glm& glm);


struct U8Vector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U8Vector2Glm *glm;
};



typedef glm::vec<2, int16_t, glm::defaultp> I16Vector2Glm;

struct I16Vector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    I16Vector2Glm *glm;
};

static I16Vector2 *
create_I16Vector2_from_glm(const I16Vector2Glm& glm);


struct I16Vector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I16Vector2Glm *glm;
};



typedef glm::vec<2, uint16_t, glm::defaultp> U16Vector2Glm;

struct U16Vector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    U16Vector2Glm *glm;
};

static U16Vector2 *
create_U16Vector2_from_glm(const U16Vector2Glm& glm);


struct U16Vector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U16Vector2Glm *glm;
};



typedef glm::vec<2, int32_t, glm::defaultp> I32Vector2Glm;

struct I32Vector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    I32Vector2Glm *glm;
};

static I32Vector2 *
create_I32Vector2_from_glm(const I32Vector2Glm& glm);


struct I32Vector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I32Vector2Glm *glm;
};



typedef glm::vec<2, uint32_t, glm::defaultp> U32Vector2Glm;

struct U32Vector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    U32Vector2Glm *glm;
};

static U32Vector2 *
create_U32Vector2_from_glm(const U32Vector2Glm& glm);


struct U32Vector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U32Vector2Glm *glm;
};



typedef glm::vec<2, int, glm::defaultp> IVector2Glm;

struct IVector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    IVector2Glm *glm;
};

static IVector2 *
create_IVector2_from_glm(const IVector2Glm& glm);


struct IVector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    IVector2Glm *glm;
};



typedef glm::vec<2, unsigned int, glm::defaultp> UVector2Glm;

struct UVector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    UVector2Glm *glm;
};

static UVector2 *
create_UVector2_from_glm(const UVector2Glm& glm);


struct UVector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    UVector2Glm *glm;
};



typedef glm::vec<2, int64_t, glm::defaultp> I64Vector2Glm;

struct I64Vector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    I64Vector2Glm *glm;
};

static I64Vector2 *
create_I64Vector2_from_glm(const I64Vector2Glm& glm);


struct I64Vector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I64Vector2Glm *glm;
};



typedef glm::vec<2, uint64_t, glm::defaultp> U64Vector2Glm;

struct U64Vector2
{
    PyObject_HEAD
    PyObject *weakreflist;
    U64Vector2Glm *glm;
};

static U64Vector2 *
create_U64Vector2_from_glm(const U64Vector2Glm& glm);


struct U64Vector2Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U64Vector2Glm *glm;
};



typedef glm::vec<3, bool, glm::defaultp> BVector3Glm;

struct BVector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    BVector3Glm *glm;
};

static BVector3 *
create_BVector3_from_glm(const BVector3Glm& glm);


struct BVector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    BVector3Glm *glm;
};



typedef glm::vec<3, double, glm::defaultp> DVector3Glm;

struct DVector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    DVector3Glm *glm;
};

static DVector3 *
create_DVector3_from_glm(const DVector3Glm& glm);


struct DVector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    DVector3Glm *glm;
};



typedef glm::vec<3, float, glm::defaultp> FVector3Glm;

struct FVector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    FVector3Glm *glm;
};

static FVector3 *
create_FVector3_from_glm(const FVector3Glm& glm);


struct FVector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    FVector3Glm *glm;
};



typedef glm::vec<3, int8_t, glm::defaultp> I8Vector3Glm;

struct I8Vector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    I8Vector3Glm *glm;
};

static I8Vector3 *
create_I8Vector3_from_glm(const I8Vector3Glm& glm);


struct I8Vector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I8Vector3Glm *glm;
};



typedef glm::vec<3, uint8_t, glm::defaultp> U8Vector3Glm;

struct U8Vector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    U8Vector3Glm *glm;
};

static U8Vector3 *
create_U8Vector3_from_glm(const U8Vector3Glm& glm);


struct U8Vector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U8Vector3Glm *glm;
};



typedef glm::vec<3, int16_t, glm::defaultp> I16Vector3Glm;

struct I16Vector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    I16Vector3Glm *glm;
};

static I16Vector3 *
create_I16Vector3_from_glm(const I16Vector3Glm& glm);


struct I16Vector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I16Vector3Glm *glm;
};



typedef glm::vec<3, uint16_t, glm::defaultp> U16Vector3Glm;

struct U16Vector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    U16Vector3Glm *glm;
};

static U16Vector3 *
create_U16Vector3_from_glm(const U16Vector3Glm& glm);


struct U16Vector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U16Vector3Glm *glm;
};



typedef glm::vec<3, int32_t, glm::defaultp> I32Vector3Glm;

struct I32Vector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    I32Vector3Glm *glm;
};

static I32Vector3 *
create_I32Vector3_from_glm(const I32Vector3Glm& glm);


struct I32Vector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I32Vector3Glm *glm;
};



typedef glm::vec<3, uint32_t, glm::defaultp> U32Vector3Glm;

struct U32Vector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    U32Vector3Glm *glm;
};

static U32Vector3 *
create_U32Vector3_from_glm(const U32Vector3Glm& glm);


struct U32Vector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U32Vector3Glm *glm;
};



typedef glm::vec<3, int, glm::defaultp> IVector3Glm;

struct IVector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    IVector3Glm *glm;
};

static IVector3 *
create_IVector3_from_glm(const IVector3Glm& glm);


struct IVector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    IVector3Glm *glm;
};



typedef glm::vec<3, unsigned int, glm::defaultp> UVector3Glm;

struct UVector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    UVector3Glm *glm;
};

static UVector3 *
create_UVector3_from_glm(const UVector3Glm& glm);


struct UVector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    UVector3Glm *glm;
};



typedef glm::vec<3, int64_t, glm::defaultp> I64Vector3Glm;

struct I64Vector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    I64Vector3Glm *glm;
};

static I64Vector3 *
create_I64Vector3_from_glm(const I64Vector3Glm& glm);


struct I64Vector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I64Vector3Glm *glm;
};



typedef glm::vec<3, uint64_t, glm::defaultp> U64Vector3Glm;

struct U64Vector3
{
    PyObject_HEAD
    PyObject *weakreflist;
    U64Vector3Glm *glm;
};

static U64Vector3 *
create_U64Vector3_from_glm(const U64Vector3Glm& glm);


struct U64Vector3Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U64Vector3Glm *glm;
};



typedef glm::vec<4, bool, glm::defaultp> BVector4Glm;

struct BVector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    BVector4Glm *glm;
};

static BVector4 *
create_BVector4_from_glm(const BVector4Glm& glm);


struct BVector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    BVector4Glm *glm;
};



typedef glm::vec<4, double, glm::defaultp> DVector4Glm;

struct DVector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    DVector4Glm *glm;
};

static DVector4 *
create_DVector4_from_glm(const DVector4Glm& glm);


struct DVector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    DVector4Glm *glm;
};



typedef glm::vec<4, float, glm::defaultp> FVector4Glm;

struct FVector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    FVector4Glm *glm;
};

static FVector4 *
create_FVector4_from_glm(const FVector4Glm& glm);


struct FVector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    FVector4Glm *glm;
};



typedef glm::vec<4, int8_t, glm::defaultp> I8Vector4Glm;

struct I8Vector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    I8Vector4Glm *glm;
};

static I8Vector4 *
create_I8Vector4_from_glm(const I8Vector4Glm& glm);


struct I8Vector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I8Vector4Glm *glm;
};



typedef glm::vec<4, uint8_t, glm::defaultp> U8Vector4Glm;

struct U8Vector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    U8Vector4Glm *glm;
};

static U8Vector4 *
create_U8Vector4_from_glm(const U8Vector4Glm& glm);


struct U8Vector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U8Vector4Glm *glm;
};



typedef glm::vec<4, int16_t, glm::defaultp> I16Vector4Glm;

struct I16Vector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    I16Vector4Glm *glm;
};

static I16Vector4 *
create_I16Vector4_from_glm(const I16Vector4Glm& glm);


struct I16Vector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I16Vector4Glm *glm;
};



typedef glm::vec<4, uint16_t, glm::defaultp> U16Vector4Glm;

struct U16Vector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    U16Vector4Glm *glm;
};

static U16Vector4 *
create_U16Vector4_from_glm(const U16Vector4Glm& glm);


struct U16Vector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U16Vector4Glm *glm;
};



typedef glm::vec<4, int32_t, glm::defaultp> I32Vector4Glm;

struct I32Vector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    I32Vector4Glm *glm;
};

static I32Vector4 *
create_I32Vector4_from_glm(const I32Vector4Glm& glm);


struct I32Vector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I32Vector4Glm *glm;
};



typedef glm::vec<4, uint32_t, glm::defaultp> U32Vector4Glm;

struct U32Vector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    U32Vector4Glm *glm;
};

static U32Vector4 *
create_U32Vector4_from_glm(const U32Vector4Glm& glm);


struct U32Vector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U32Vector4Glm *glm;
};



typedef glm::vec<4, int, glm::defaultp> IVector4Glm;

struct IVector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    IVector4Glm *glm;
};

static IVector4 *
create_IVector4_from_glm(const IVector4Glm& glm);


struct IVector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    IVector4Glm *glm;
};



typedef glm::vec<4, unsigned int, glm::defaultp> UVector4Glm;

struct UVector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    UVector4Glm *glm;
};

static UVector4 *
create_UVector4_from_glm(const UVector4Glm& glm);


struct UVector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    UVector4Glm *glm;
};



typedef glm::vec<4, int64_t, glm::defaultp> I64Vector4Glm;

struct I64Vector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    I64Vector4Glm *glm;
};

static I64Vector4 *
create_I64Vector4_from_glm(const I64Vector4Glm& glm);


struct I64Vector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    I64Vector4Glm *glm;
};



typedef glm::vec<4, uint64_t, glm::defaultp> U64Vector4Glm;

struct U64Vector4
{
    PyObject_HEAD
    PyObject *weakreflist;
    U64Vector4Glm *glm;
};

static U64Vector4 *
create_U64Vector4_from_glm(const U64Vector4Glm& glm);


struct U64Vector4Array
{
    PyObject_HEAD
    PyObject *weakreflist;
    size_t length;
    U64Vector4Glm *glm;
};



#endif
