doc/api/_gx_struct_8h_source.html

//===========================================================================

//===========================================================================

#pragma once


GX_CORE_NAMESPACE_BEGIN()


struct GxFloat3;

struct GxFloat4;


//===========================================================================

//===========================================================================


struct GxFloat2

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_FORCE_INLINE GxFloat2(void){}

    GX_FORCE_INLINE GxFloat2(f32 x, f32 y) : _x(x), _y(y) {}

    GX_FORCE_INLINE GxFloat2(const GxFloat3& float3);

    GX_FORCE_INLINE GxFloat2(const GxFloat4& float4);

    GX_FORCE_INLINE GxFloat2(const GxVector2& vector);

    GX_FORCE_INLINE GxFloat2(const GxVector3& vector);

    GX_FORCE_INLINE GxFloat2(const GxVector4& vector);

    GX_FORCE_INLINE GxFloat2(const GxPoint2& point);


    GX_FORCE_INLINE GxFloat2(const GxFloat2& float2) : _x(float2._x), _y(float2._y){}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxFloat2& operator = (const GxFloat2& float2);

    GX_FORCE_INLINE GxFloat2& operator = (const GxVector2& vector);

    GX_FORCE_INLINE GxFloat2& operator = (const GxVector3& vector);

    GX_FORCE_INLINE GxFloat2& operator = (const GxVector4& vector);

    GX_FORCE_INLINE operator f32* (void){ return reinterpret_cast<f32*>(this); }

    GX_FORCE_INLINE operator const f32* (void) const { return reinterpret_cast<const f32*>(this); }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    union

    {

        f32     _x;

        f32     _u;

    };

    union

    {

        f32     _y;

        f32     _v;

    };


};


//===========================================================================

//===========================================================================


struct GxFloat3

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_FORCE_INLINE GxFloat3(void) : _x(0.f), _y(0.f), _z(0.f){}

    GX_FORCE_INLINE GxFloat3(f32 x, f32 y, f32 z) : _x(x), _y(y), _z(z){}

    GX_FORCE_INLINE GxFloat3(const GxFloat4& float4);

    GX_FORCE_INLINE GxFloat3(const GxVector3& vector);

    GX_FORCE_INLINE GxFloat3(const GxVector4& vector);


    GX_FORCE_INLINE GxFloat3(const GxFloat3& float3) : _x(float3._x), _y(float3._y), _z(float3._z){}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxFloat3& operator = (const GxVector3& vector);

    GX_FORCE_INLINE GxFloat3& operator = (const GxVector4& vector);

    GX_FORCE_INLINE operator f32* (void){ return reinterpret_cast<f32*>(this); }

    GX_FORCE_INLINE operator const f32* (void) const { return reinterpret_cast<const f32*>(this); }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

#if GX_DEVELOP

    // 書き込み

    b32 write(GxStreamWriter& writer);

#endif //GX_DEVELOP


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    f32     _x;

    f32     _y;

    f32     _z;


};


//===========================================================================

//===========================================================================


struct GxFloat4

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_FORCE_INLINE GxFloat4(void) : _x(0.f), _y(0.f), _z(0.f), _w(0.f){}

    GX_FORCE_INLINE GxFloat4(f32 x, f32 y, f32 z, f32 w) : _x(x), _y(y), _z(z), _w(w) {}

    GX_FORCE_INLINE GxFloat4(const GxVector4& vector);

    GX_FORCE_INLINE GxFloat4(const GxQuaternion& quaternion);


    GX_FORCE_INLINE GxFloat4(const GxFloat4& float4) : _x(float4._x), _y(float4._y), _z(float4._z), _w(float4._w) {}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxFloat4& operator = (const GxVector4& vector);

    GX_FORCE_INLINE GxFloat4& operator = (const GxQuaternion& quaternion);

    GX_FORCE_INLINE operator f32* (void){ return reinterpret_cast<f32*>(this); }

    GX_FORCE_INLINE operator const f32* (void) const { return reinterpret_cast<const f32*>(this); }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    f32     _x;

    f32     _y;

    f32     _z;

    f32     _w;


};


struct GxDouble3;

struct GxDouble4;


//===========================================================================

//===========================================================================


struct GxDouble2

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_FORCE_INLINE GxDouble2(void) : _x(0), _y(0) {}

    GX_FORCE_INLINE GxDouble2(f64 x, f64 y) : _x(x), _y(y) {}

    GX_FORCE_INLINE GxDouble2(const GxDouble3& double3);

    GX_FORCE_INLINE GxDouble2(const GxDouble4& double4);

    GX_FORCE_INLINE GxDouble2(const GxVector2d& vector);

    GX_FORCE_INLINE GxDouble2(const GxVector3d& vector);

    GX_FORCE_INLINE GxDouble2(const GxVector4d& vector);

    GX_FORCE_INLINE GxDouble2(const GxPoint2& point);


    GX_FORCE_INLINE GxDouble2(const GxDouble2& double2) : _x(double2._x), _y(double2._y) {}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxDouble2& operator = (const GxDouble2& double2);

    GX_FORCE_INLINE GxDouble2& operator = (const GxVector2d& vector);

    GX_FORCE_INLINE GxDouble2& operator = (const GxVector3d& vector);

    GX_FORCE_INLINE GxDouble2& operator = (const GxVector4d& vector);

    GX_FORCE_INLINE operator f64* (void) { return reinterpret_cast<f64*>(this); }

    GX_FORCE_INLINE operator const f64* (void) const { return reinterpret_cast<const f64*>(this); }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    union

    {

        f64     _x;

        f64     _u;

    };

    union

    {

        f64     _y;

        f64     _v;

    };


};


//===========================================================================

//===========================================================================


struct GxDouble3

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_FORCE_INLINE GxDouble3(void) : _x(0), _y(0), _z(0) {}

    GX_FORCE_INLINE GxDouble3(f64 x, f64 y, f64 z) : _x(x), _y(y), _z(z) {}

    GX_FORCE_INLINE GxDouble3(const GxDouble4& double4);

    GX_FORCE_INLINE GxDouble3(const GxVector3d& vector);

    GX_FORCE_INLINE GxDouble3(const GxVector4d& vector);


    GX_FORCE_INLINE GxDouble3(const GxDouble3& double3) : _x(double3._x), _y(double3._y), _z(double3._z) {}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxDouble3& operator = (const GxVector3d& vector);

    GX_FORCE_INLINE GxDouble3& operator = (const GxVector4d& vector);

    GX_FORCE_INLINE operator f64* (void) { return reinterpret_cast<f64*>(this); }

    GX_FORCE_INLINE operator const f64* (void) const { return reinterpret_cast<const f64*>(this); }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

#if GX_DEVELOP

    // 書き込み

    b32 write(GxStreamWriter& writer);

#endif //GX_DEVELOP


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    f64     _x;

    f64     _y;

    f64     _z;


};


//===========================================================================

//===========================================================================


struct GxDouble4

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_FORCE_INLINE GxDouble4(void) : _x(0), _y(0), _z(0), _w(0) {}

    GX_FORCE_INLINE GxDouble4(f64 x, f64 y, f64 z, f64 w) : _x(x), _y(y), _z(z), _w(w) {}

    GX_FORCE_INLINE GxDouble4(const GxVector4d& vector);


    GX_FORCE_INLINE GxDouble4(const GxDouble4& double4) : _x(double4._x), _y(double4._y), _z(double4._z), _w(double4._w) {}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxDouble4& operator = (const GxVector4d& vector);

    GX_FORCE_INLINE operator f64* (void) { return reinterpret_cast<f64*>(this); }

    GX_FORCE_INLINE operator const f64* (void) const { return reinterpret_cast<const f64*>(this); }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    f64     _x;

    f64     _y;

    f64     _z;

    f64     _w;


};


//===========================================================================

// GxFloat16という名前にすると GxFloat4などとややこしいのでGxF16になっています

//===========================================================================


struct GxF16

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_INLINE GxF16(void);

    GX_INLINE GxF16(f32 valueF32);

    GX_INLINE GxF16(const GxF16& valueF16);


    GX_FORCE_INLINE operator f32() const;


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    static GX_FORCE_INLINE GxF16    f32ToF16(f32 valueF32);

    static GX_FORCE_INLINE f32      f16ToF32(GxF16 valueF16);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    constexpr u16   getValueU16(void) const { return _value; }

    constexpr void  setValueU16(u16 setValue) { _value = setValue; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


private:

    u16 _value;


};


//===========================================================================

//===========================================================================


struct GxF16x2

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxF16x2(void){}

    GX_INLINE GxF16x2(const GxF16x2& value) { *this = value; }

    GX_INLINE GxF16x2(const GxFloat2& value) { *this = value; }

    GX_INLINE GxF16x2(const GxVector2& value) { *this = value; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxF16x2& operator = (const GxF16x2& value);

    GX_FORCE_INLINE GxF16x2& operator = (const GxFloat2& value);

    GX_FORCE_INLINE GxF16x2& operator = (const GxVector2& value);


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxF16   _value[2];


};


//===========================================================================

//===========================================================================


struct GxF16x4

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxF16x4(void){}

    GX_INLINE GxF16x4(const GxF16x4& value) { *this = value; }

    GX_INLINE GxF16x4(const GxFloat3& value) { *this = GxFloat4(value._x, value._y, value._z, 0.0f); }

    GX_INLINE GxF16x4(const GxFloat4& value) { *this = value; }

    GX_INLINE GxF16x4(const GxVector3& value) { *this = GxVector4(value._x, value._y, value._z, 0.0f); }

    GX_INLINE GxF16x4(const GxVector4& value) { *this = value; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxF16x4& operator = (const GxF16x4& value);

    GX_FORCE_INLINE GxF16x4& operator = (const GxFloat4& value);

    GX_FORCE_INLINE GxF16x4& operator = (const GxVector4& value);


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxF16   _value[4];


};


//===========================================================================

//===========================================================================


struct GxU8N

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_INLINE GxU8N(void);

    GX_INLINE GxU8N(f32 valueF32);

    GX_INLINE GxU8N(const GxU8N& valueF16);


    GX_FORCE_INLINE operator f32() const;


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    static GX_FORCE_INLINE GxU8N    f32ToU8N(f32 valueF32);

    static GX_FORCE_INLINE f32      u8NToF32(GxU8N valueU8N);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    constexpr u8    getValueU8(void) const { return _value; }

    constexpr void  setValueU8(u8 setValue) { _value = setValue; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    u8 _value;


};


//===========================================================================

//===========================================================================


struct GxU8Nx4

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    static constexpr u32 DIMENSION = 4;


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxU8Nx4(void){}

    GX_INLINE GxU8Nx4(const GxU8Nx4& value) { *this = value; }

    GX_INLINE GxU8Nx4(const GxFloat4& value) { *this = value; }

    GX_INLINE GxU8Nx4(const GxVector4& value) { *this = value; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxU8Nx4& operator = (const GxU8Nx4& value);

    GX_FORCE_INLINE GxU8Nx4& operator = (const GxFloat4& value);

    GX_FORCE_INLINE GxU8Nx4& operator = (const GxVector4& value);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE const GxU8N& operator[](u32 i) const { return _value[i]; }

    GX_FORCE_INLINE GxU8N& operator[](u32 i) { return _value[i]; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    GxU8N   _value[DIMENSION];


};


//===========================================================================

//===========================================================================


struct GxPackedNx3

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    static constexpr u32 DIMENSION = 3;

    static constexpr u32 SHIFT_X = 0;

    static constexpr u32 SHIFT_Y = 11;

    static constexpr u32 SHIFT_Z = 22;


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxPackedNx3(void){}

    GX_INLINE GxPackedNx3(const GxPackedNx3& value) { *this = value; }

    GX_INLINE GxPackedNx3(const GxFloat3& value) { *this = value; }

    GX_INLINE GxPackedNx3(const GxVector3& value) { *this = value; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxPackedNx3& operator = (const GxPackedNx3& value) { _value = value._value; return *this; }

    GX_FORCE_INLINE GxPackedNx3& operator = (const GxFloat3& value);

    GX_FORCE_INLINE GxPackedNx3& operator = (const GxVector3& value);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    static GX_FORCE_INLINE u32      f32ToS10N(f32 valueF32);

    static GX_FORCE_INLINE f32      s10NTof32(u32 valueS10N);

    static GX_FORCE_INLINE u32      f32ToS11N(f32 valueF32);

    static GX_FORCE_INLINE f32      s11NTof32(u32 valueS11N);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE f32     getValueF32(u32 index) const;

    GX_FORCE_INLINE void    setValueF32(u32 index, f32 setValue);


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    u32     _value;


};


//===========================================================================

//===========================================================================


struct GxSize : public GxStructBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_STRUCT(GxSize)


    static const GxSize MIN;

    static const GxSize MAX;

    static const GxSize ZERO;


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxSize(void) : _width(0), _height(0){}

    GX_FORCE_INLINE GxSize(s32 width, s32 height);

    GX_FORCE_INLINE GxSize(const GxRect& rect);


    GX_FORCE_INLINE GxSize(const GxSize& size);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxSize& operator = (const GxSize& size);

    GX_FORCE_INLINE GxSize& operator += (s32 scalar);

    GX_FORCE_INLINE GxSize& operator -= (s32 scalar);

    GX_FORCE_INLINE GxSize& operator *= (s32 scalar);

    GX_FORCE_INLINE GxSize& operator /= (s32 scalar);

    GX_FORCE_INLINE GxSize& operator += (const GxSize& size);

    GX_FORCE_INLINE GxSize& operator -= (const GxSize& size);

    GX_FORCE_INLINE GxSize& operator &= (const GxSize& size);

    GX_FORCE_INLINE GxSize& operator |= (const GxSize& size);

    friend GX_FORCE_INLINE const GxSize operator + (const GxSize& size, s32 scalar);

    friend GX_FORCE_INLINE const GxSize operator - (const GxSize& size, s32 scalar);

    friend GX_FORCE_INLINE const GxSize operator * (const GxSize& size, s32 scalar);

    friend GX_FORCE_INLINE const GxSize operator * (s32 scalar, const GxSize& size);

    friend GX_FORCE_INLINE const GxSize operator / (const GxSize& size, s32 scalar);

    friend GX_FORCE_INLINE const GxSize operator + (const GxSize& size0, const GxSize& size1);

    friend GX_FORCE_INLINE const GxSize operator - (const GxSize& size0, const GxSize& size1);

    friend GX_FORCE_INLINE const GxSize operator & (const GxSize& size0, const GxSize& size1);

    friend GX_FORCE_INLINE const GxSize operator | (const GxSize& size0, const GxSize& size1);

    friend GX_FORCE_INLINE b32 operator == (const GxSize& size0, const GxSize& size1);

    friend GX_FORCE_INLINE b32 operator != (const GxSize& size0, const GxSize& size1);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    static GX_FORCE_INLINE const GxSize&    getAddScalar(GxSize& dst, const GxSize& size, s32 scalar);

    static GX_FORCE_INLINE const GxSize&    getSubScalar(GxSize& dst, const GxSize& size, s32 scalar);

    static GX_FORCE_INLINE const GxSize&    getMulScalar(GxSize& dst, const GxSize& size, s32 scalar);

    static GX_FORCE_INLINE const GxSize&    getDivScalar(GxSize& dst, const GxSize& size, s32 scalar);

    static GX_FORCE_INLINE const GxSize&    getAddSize(GxSize& dst, const GxSize& size0, const GxSize& size1);

    static GX_FORCE_INLINE const GxSize&    getSubSize(GxSize& dst, const GxSize& size0, const GxSize& size1);


    GX_INLINE b32 isIncluding(const GxPoint2& point) const;


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE const GxSize&           addScalar(s32 scalar);

    GX_FORCE_INLINE const GxSize&           subScalar(s32 scalar);

    GX_FORCE_INLINE const GxSize&           mulScalar(s32 scalar);

    GX_FORCE_INLINE const GxSize&           divScalar(s32 scalar);

    GX_FORCE_INLINE const GxSize&           addSize(const GxSize& size);

    GX_FORCE_INLINE const GxSize&           subSize(const GxSize& size);

    GX_FORCE_INLINE const GxSize&           mulSize(const GxSize& size);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    s32 _width;

    s32 _height;


};


//===========================================================================

//===========================================================================


struct GxPoint2 : public GxStructBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_STRUCT(GxPoint2)


    static const GxPoint2   ZERO;


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxPoint2(void) : _x(0), _y(0){}

    GX_FORCE_INLINE GxPoint2(s32 x, s32 y);

    GX_FORCE_INLINE GxPoint2(const GxPoint2& point);

    GX_FORCE_INLINE GxPoint2(const GxVector2& vector);


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE GxPoint2& operator = (const GxPoint2& point);

    GX_FORCE_INLINE GxPoint2& operator += (const GxPoint2& point);

    GX_FORCE_INLINE GxPoint2& operator -= (const GxPoint2& point);

    GX_FORCE_INLINE GxPoint2& operator += (const GxSize& size);

    GX_FORCE_INLINE GxPoint2& operator -= (const GxSize& size);

    friend GX_FORCE_INLINE const GxPoint2 operator + (const GxPoint2& point){ return point; }

    friend GX_FORCE_INLINE const GxPoint2 operator - (const GxPoint2& point){ return GxPoint2( -point._x,-point._y ); }

    friend GX_FORCE_INLINE const GxPoint2 operator + (const GxPoint2& point0, const GxPoint2& point1);

    friend GX_FORCE_INLINE const GxPoint2 operator - (const GxPoint2& point0, const GxPoint2& point1);

    friend GX_FORCE_INLINE const GxPoint2 operator + (const GxPoint2& point, const GxSize& size);

    friend GX_FORCE_INLINE const GxPoint2 operator - (const GxPoint2& point, const GxSize& size);

    friend GX_FORCE_INLINE b32 operator == (const GxPoint2& point0, const GxPoint2& point1);

    friend GX_FORCE_INLINE b32 operator != (const GxPoint2& point0, const GxPoint2& point1);


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    f32 getSquareDistanceToSegment(GxPoint2 segmentStart, GxPoint2 segmentEnd) const;


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    s32 _x;

    s32 _y;


};


//===========================================================================

//===========================================================================


struct GxRect : public GxStructBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_STRUCT(GxRect)


    static const GxRect MIN;

    static const GxRect MAX;

    static const GxRect ZERO;


    enum class BASE

    {

        TOP_LEFT,

        TOP_RIGHT,

        BOTTOM_LEFT,

        BOTTOM_RIGHT

    };


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxRect(void) : _left(0), _top(0), _right(0), _bottom(0){}

    GX_FORCE_INLINE GxRect(const s32 left, const s32 top, const s32 right, const s32 bottom) : _left(left), _top(top), _right(right), _bottom(bottom){}

    GX_FORCE_INLINE GxRect(const GxSize& size) : _left(0), _top(0), _right(size._width), _bottom(size._height){}

    GX_FORCE_INLINE GxRect(const GxPoint2& leftTop, const GxSize& size) : _left(leftTop._x), _top(leftTop._y), _right(leftTop._x+size._width), _bottom(leftTop._y+size._height){}

    GX_FORCE_INLINE GxRect(const GxPoint2& leftTop, const GxPoint2& rightBottom) : _left(leftTop._x), _top(leftTop._y), _right(rightBottom._x), _bottom(rightBottom._y){}


    GX_FORCE_INLINE GxRect(const GxRect& rect) : _left(rect._left), _top(rect._top), _right(rect._right), _bottom(rect._bottom){}

    GX_FORCE_INLINE void initialize(s32 left, s32 top, s32 right, s32 bottom){ _left = left; _top = top; _right = right; _bottom = bottom; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE GxRect& operator = (const GxRect& rect);

    GX_FORCE_INLINE GxRect& operator += (const GxRect& rect);

    GX_FORCE_INLINE GxRect& operator -= (const GxRect& rect);

    GX_FORCE_INLINE GxRect& operator += (const GxPoint2& point);

    GX_FORCE_INLINE GxRect& operator -= (const GxPoint2& point);

    GX_FORCE_INLINE GxRect& operator &= (const GxRect& rect);

    GX_FORCE_INLINE GxRect& operator |= (const GxRect& rect);

    friend GX_FORCE_INLINE const GxRect operator + (const GxRect& rect);

    friend GX_FORCE_INLINE const GxRect operator - (const GxRect& rect);

    friend GX_FORCE_INLINE const GxRect operator + (const GxRect& rect0, const GxRect& rect1);

    friend GX_FORCE_INLINE const GxRect operator - (const GxRect& rect0, const GxRect& rect1);

    friend GX_FORCE_INLINE const GxRect operator + (const GxRect& rect, const GxPoint2& point);

    friend GX_FORCE_INLINE const GxRect operator - (const GxRect& rect, const GxPoint2& point);

    friend GX_FORCE_INLINE const GxRect operator & (const GxRect& rect0, const GxRect& rect1);

    friend GX_FORCE_INLINE const GxRect operator | (const GxRect& rect0, const GxRect& rect1);

    friend GX_FORCE_INLINE b32 operator == (const GxRect& rect0, const GxRect& rect1);

    friend GX_FORCE_INLINE b32 operator != (const GxRect& rect0, const GxRect& rect1);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    constexpr s32 getWidth(void) const { return _right - _left; }

    constexpr s32 getHeight(void) const { return _bottom - _top; }

    GX_INLINE GxSize getSize(void) const { return GxSize(_right - _left, _bottom - _top); }

    GX_INLINE void setSize(const GxSize& size, BASE base = BASE::TOP_LEFT);


    GX_INLINE GxPoint2 getLeftTop(void) const { return GxPoint2( _left,_top ); }

    GX_INLINE GxPoint2 getRightTop(void) const { return GxPoint2( _right,_top ); }

    GX_INLINE GxPoint2 getLeftBottom(void) const { return GxPoint2( _left,_bottom ); }

    GX_INLINE GxPoint2 getRightBottom(void) const { return GxPoint2( _right,_bottom ); }

    GX_INLINE GxPoint2 getCenter(void) const { return GxPoint2( (_left + _right) >> 1, (_top + _bottom) >> 1 ); }


    GX_INLINE b32 isHit(const GxRect& rect) const;

    GX_INLINE b32 isIncluding(const GxRect& rect) const;

    GX_INLINE b32 isIncluding(const GxPoint2& point) const;


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    constexpr void add(s32 x, s32 y){ _left -= x; _right += x; _top -= y; _bottom += y; }

    constexpr void add(s32 value){ _left -= value; _right += value; _top -= value; _bottom += value; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    s32 _left;

    s32 _top;

    s32 _right;

    s32 _bottom;


};


//===========================================================================

//===========================================================================


struct GxRectF : public GxStructBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_STRUCT(GxRectF)


    static const GxRectF ZERO;


    enum class BASE

    {

        TOP_LEFT,

        TOP_RIGHT,

        BOTTOM_LEFT,

        BOTTOM_RIGHT

    };


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxRectF(void) : _left(0), _top(0), _right(0), _bottom(0){}

    GX_FORCE_INLINE GxRectF(const f32 left, const f32 top, const f32 right, const f32 bottom) : _left(left), _top(top), _right(right), _bottom(bottom){}

    GX_FORCE_INLINE GxRectF(const GxVector2& leftTop, const GxVector2& rightBottom) : _left(leftTop._x), _top(leftTop._y), _right(rightBottom._x), _bottom(rightBottom._y){}


    GX_FORCE_INLINE GxRectF(const GxRectF& rect) : _left(rect._left), _top(rect._top), _right(rect._right), _bottom(rect._bottom){}

    GX_FORCE_INLINE void initialize(f32 left, f32 top, f32 right, f32 bottom){ _left = left; _top = top; _right = right; _bottom = bottom; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE GxRectF& operator = (const GxRectF& rect);

    GX_FORCE_INLINE GxRectF& operator += (const GxRectF& rect);

    GX_FORCE_INLINE GxRectF& operator -= (const GxRectF& rect);

    GX_FORCE_INLINE GxRectF& operator += (const GxVector2& point);

    GX_FORCE_INLINE GxRectF& operator -= (const GxVector2& point);

    GX_FORCE_INLINE GxRectF& operator &= (const GxRectF& rect);

    GX_FORCE_INLINE GxRectF& operator |= (const GxRectF& rect);

    friend GX_FORCE_INLINE const GxRectF operator + (const GxRectF& rect);

    friend GX_FORCE_INLINE const GxRectF operator - (const GxRectF& rect);

    friend GX_FORCE_INLINE const GxRectF operator + (const GxRectF& rect0, const GxRectF& rect1);

    friend GX_FORCE_INLINE const GxRectF operator - (const GxRectF& rect0, const GxRectF& rect1);

    friend GX_FORCE_INLINE const GxRectF operator + (const GxRectF& rect, const GxVector2& point);

    friend GX_FORCE_INLINE const GxRectF operator - (const GxRectF& rect, const GxVector2& point);

    friend GX_FORCE_INLINE const GxRectF operator & (const GxRectF& rect0, const GxRectF& rect1);

    friend GX_FORCE_INLINE const GxRectF operator | (const GxRectF& rect0, const GxRectF& rect1);

    friend GX_FORCE_INLINE b32 operator == (const GxRectF& rect0, const GxRectF& rect1);

    friend GX_FORCE_INLINE b32 operator != (const GxRectF& rect0, const GxRectF& rect1);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    constexpr f32 getWidth(void) const { return _right - _left; }

    constexpr f32 getHeight(void) const { return _bottom - _top; }

    GX_INLINE GxSize getSize(void) const { return GxSize( s32(_right - _left), s32(_bottom - _top)); }

    GX_INLINE void setSize(const GxSize& size, BASE base = BASE::TOP_LEFT);

    GX_FORCE_INLINE const GxRectF& setGxRect(const GxRect& rect);


    GX_INLINE GxVector2 getLeftTop(void) const { return GxVector2(_left, _top); }

    GX_INLINE GxVector2 getRightTop(void) const { return GxVector2(_right, _top); }

    GX_INLINE GxVector2 getLeftBottom(void) const { return GxVector2(_left, _bottom); }

    GX_INLINE GxVector2 getRightBottom(void) const { return GxVector2(_right, _bottom); }

    GX_INLINE GxVector2 getCenter(void) const { return GxVector2((_left + _right) / 2, (_top + _bottom) / 2); }


    GX_INLINE b32 isHit(const GxRectF& rect) const;

    GX_INLINE b32 isIncluding(const GxRectF& rect) const;

    GX_INLINE b32 isIncluding(const GxVector2& point) const;


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    constexpr void add(f32 x, f32 y){ _left -= x; _right += x; _top -= y; _bottom += y; }

    constexpr void add(f32 value){ _left -= value; _right += value; _top -= value; _bottom += value; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    f32 _left;

    f32 _top;

    f32 _right;

    f32 _bottom;


};


//===========================================================================

//===========================================================================


struct GxFlag32Base : public GxStructBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_STRUCT(GxFlag32Base)


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxFlag32Base(void) : _flag(0){}

    GxFlag32Base(u32 flag) : _flag(flag){}

#if GX_DEVELOP

    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index = 0);

#endif //GX_DEVELOP


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    constexpr u32 getFlag(void) const { return _flag; }

    constexpr void setFlag(u32 flag){ _flag = flag; }

    constexpr void clear(void){ _flag = 0; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

protected:

    u32 _flag;


};


//===========================================================================

//===========================================================================


template<typename T> struct GxFlag32Index : public GxFlag32Base

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxFlag32Index(void) : GxFlag32Base(0){}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE GxFlag32Index<T>& operator &= (const GxFlag32Index<T>& flag) { _flag &= flag._flag; return *this; }

    GX_FORCE_INLINE GxFlag32Index<T>& operator |= (const GxFlag32Index<T>& flag) { _flag |= flag._flag; return *this; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE b32 isFlag(T index) const { return (_flag & (1 << static_cast<s32>(index))) ? true : false; }


    GX_FORCE_INLINE void setFlag(T index, b32 enable)

    {

        GX_ASSERT((static_cast<s32>(index) >= 0) && (static_cast<s32>(index) < 32), "flag index error");

        enable ? _flag |= (1 << static_cast<s32>(index)) : _flag &= ~(1 << static_cast<s32>(index));

    }


};


//===========================================================================

//===========================================================================


struct GxFlag32Bit : public GxFlag32Base

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxFlag32Bit(u32 flag = 0) : GxFlag32Base(flag){}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE b32 isFlag(u32 flag) const { return (_flag & flag) ? true : false; }

    GX_FORCE_INLINE void setFlag(u32 flag, b32 enable){ enable ? _flag |= flag : _flag &= ~flag; }


};


//===========================================================================

//===========================================================================


struct GxFlag32Array : public GxStructBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    // RTTI宣言

    GX_RTTI_STRUCT(GxFlag32Array)


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GxFlag32Array(u32* pFlag = nullptr, u32 count = 0) : _pFlag(pFlag), _count(count){}

    void initialize(u32* pFlagArray, u32 count){ _pFlag = pFlagArray; _count = count; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    void getPropertyFlag(void* const pValue, u32 index){ *( static_cast<b32* const>(pValue) ) = isFlag(index); }

    void setPropertyFlag(const void* const pValue, u32 index){ setFlag(index, *( static_cast<const b32* const>(pValue) ) ); }

    constexpr u32 getPropertyFlagCount(void) const { return _count; }

    constexpr void setPropertyFlagCount(u32){}


    GX_FORCE_INLINE void clear(void){ clear(_pFlag, _count); }

    GX_FORCE_INLINE void setFlag(u32 flagIndex, b32 enable = true){ if( flagIndex < _count ){ setFlag(_pFlag, flagIndex, enable); } }


    GX_FORCE_INLINE b32 isFlag(u32 flagIndex) const { if( flagIndex < _count ){ return isFlag(_pFlag, flagIndex); } return false; }

    GX_FORCE_INLINE u32 getSize(void) const { return getSize( _count ); }

    constexpr u32 getCount(void) const { return _count; }


    static void clear(u32* pFlags, u32 flagCount);

    static void setFlag(u32* pFlags, u32 flagIndex, b32 enable);

    static b32 isFlag(const u32* pFlags, u32 flagIndex);

    static u32* getValuePointer(const u32* pFlags, u32 flagIndex);

    static u32 getSize(u32 count);


    //-------------------------------------------------------------

    //-------------------------------------------------------------

protected:

    u32* _pFlag;

    u32 _count;


};


GX_CORE_NAMESPACE_END()


#include "GxStruct.inl"

#include "GxVector.inl"

#include "GxVectord.inl"

#include "GxMatrix.inl"

#include "GxQuaternion.inl"

#include "GxColor.inl"

GxColor.inl
カラー

GxTypedObject
void GxTypedObject
その他
Definition GxDefine.h:213

GxMatrix.inl
行列

GxQuaternion.inl
クォータニオン

GxVector.inl
ベクトル

GxVectord.inl
ベクトル(倍精度)

GxProperty
プロパティクラス
Definition GxProperty.h:48

GxRtti
実行時型情報クラス
Definition GxRtti.h:154

GxStreamWriter
ストリーム書き込みクラス
Definition GxStreamWriter.h:19

GxDouble2
2次元浮動小数点数(倍精度)クラス
Definition GxStruct.h:207

GxDouble2::GxDouble2
GX_FORCE_INLINE GxDouble2(f64 x, f64 y)
コンストラクタ
Definition GxStruct.h:216

GxDouble2::GxDouble2
GX_FORCE_INLINE GxDouble2(void)
デフォルトコンストラクタ
Definition GxStruct.h:214

GxDouble2::_x
f64 _x
X値
Definition GxStruct.h:260

GxDouble2::operator=
GX_FORCE_INLINE GxDouble2 & operator=(const GxDouble2 &double2)
代入
Definition GxStruct.inl:322

GxDouble2::_v
f64 _v
V値
Definition GxStruct.h:266

GxDouble2::_y
f64 _y
Y値
Definition GxStruct.h:265

GxDouble2::GxDouble2
GX_FORCE_INLINE GxDouble2(const GxDouble2 &double2)
コピーコンストラクタ
Definition GxStruct.h:231

GxDouble2::_u
f64 _u
U値
Definition GxStruct.h:261

GxDouble3
3次元浮動小数点数(倍精度)クラス
Definition GxStruct.h:276

GxDouble3::GxDouble3
GX_FORCE_INLINE GxDouble3(void)
デフォルトコンストラクタ
Definition GxStruct.h:283

GxDouble3::_x
f64 _x
X値
Definition GxStruct.h:327

GxDouble3::_z
f64 _z
Z値
Definition GxStruct.h:329

GxDouble3::_y
f64 _y
Y値
Definition GxStruct.h:328

GxDouble3::GxDouble3
GX_FORCE_INLINE GxDouble3(f64 x, f64 y, f64 z)
コンストラクタ
Definition GxStruct.h:285

GxDouble3::GxDouble3
GX_FORCE_INLINE GxDouble3(const GxDouble3 &double3)
コピーコンストラクタ
Definition GxStruct.h:294

GxDouble3::operator=
GX_FORCE_INLINE GxDouble3 & operator=(const GxVector3d &vector)
代入
Definition GxStruct.inl:394

GxDouble4
4次元浮動小数点数(倍精度)クラス
Definition GxStruct.h:338

GxDouble4::GxDouble4
GX_FORCE_INLINE GxDouble4(void)
デフォルトコンストラクタ
Definition GxStruct.h:345

GxDouble4::_z
f64 _z
Z値
Definition GxStruct.h:375

GxDouble4::_w
f64 _w
W値
Definition GxStruct.h:376

GxDouble4::_x
f64 _x
X値
Definition GxStruct.h:373

GxDouble4::operator=
GX_FORCE_INLINE GxDouble4 & operator=(const GxVector4d &vector)
代入
Definition GxStruct.inl:435

GxDouble4::_y
f64 _y
Y値
Definition GxStruct.h:374

GxDouble4::GxDouble4
GX_FORCE_INLINE GxDouble4(const GxDouble4 &double4)
コピーコンストラクタ
Definition GxStruct.h:352

GxDouble4::GxDouble4
GX_FORCE_INLINE GxDouble4(f64 x, f64 y, f64 z, f64 w)
コンストラクタ
Definition GxStruct.h:347

GxF16
16bit浮動小数
Definition GxStruct.h:386

GxF16::f16ToF32
static GX_FORCE_INLINE f32 f16ToF32(GxF16 valueF16)
16ビットから32ビットの変換
Definition GxStruct.inl:547

GxF16::setValueU16
constexpr void setValueU16(u16 setValue)
u16で値を設定
Definition GxStruct.h:422

GxF16::f32ToF16
static GX_FORCE_INLINE GxF16 f32ToF16(f32 valueF32)
32ビットから16ビットの変換
Definition GxStruct.inl:486

GxF16::GxF16
GX_INLINE GxF16(void)
デフォルトコンストラクタ
Definition GxStruct.inl:450

GxF16::getValueU16
constexpr u16 getValueU16(void) const
u16で値を取得
Definition GxStruct.h:420

GxF16x2
16bit浮動小数2次元ベクトル
Definition GxStruct.h:440

GxF16x2::_value
GxF16 _value[2]
値
Definition GxStruct.h:474

GxF16x2::GxF16x2
GX_INLINE GxF16x2(const GxFloat2 &value)
コンストラクタ
Definition GxStruct.h:451

GxF16x2::GxF16x2
GX_INLINE GxF16x2(const GxF16x2 &value)
コンストラクタ
Definition GxStruct.h:449

GxF16x2::operator=
GX_FORCE_INLINE GxF16x2 & operator=(const GxF16x2 &value)
代入
Definition GxStruct.inl:577

GxF16x2::GxF16x2
GX_INLINE GxF16x2(const GxVector2 &value)
コンストラクタ
Definition GxStruct.h:453

GxF16x2::GxF16x2
GxF16x2(void)
デフォルトコンストラクタ
Definition GxStruct.h:447

GxF16x4
16bit浮動小数4次元ベクトル
Definition GxStruct.h:483

GxF16x4::GxF16x4
GX_INLINE GxF16x4(const GxFloat4 &value)
コンストラクタ
Definition GxStruct.h:496

GxF16x4::GxF16x4
GX_INLINE GxF16x4(const GxVector4 &value)
コンストラクタ
Definition GxStruct.h:500

GxF16x4::GxF16x4
GX_INLINE GxF16x4(const GxFloat3 &value)
コンストラクタ
Definition GxStruct.h:494

GxF16x4::GxF16x4
GxF16x4(void)
デフォルトコンストラクタ
Definition GxStruct.h:490

GxF16x4::_value
GxF16 _value[4]
値
Definition GxStruct.h:521

GxF16x4::GxF16x4
GX_INLINE GxF16x4(const GxF16x4 &value)
コンストラクタ
Definition GxStruct.h:492

GxF16x4::GxF16x4
GX_INLINE GxF16x4(const GxVector3 &value)
コンストラクタ
Definition GxStruct.h:498

GxF16x4::operator=
GX_FORCE_INLINE GxF16x4 & operator=(const GxF16x4 &value)
代入
Definition GxStruct.inl:619

GxFlag32Array
32ビットフラグ配列の操作
Definition GxStruct.h:1365

GxFlag32Array::initialize
void initialize(u32 *pFlagArray, u32 count)
初期化
Definition GxStruct.h:1383

GxFlag32Array::_pFlag
u32 * _pFlag
フラグデータ
Definition GxStruct.h:1429

GxFlag32Array::getValuePointer
static u32 * getValuePointer(const u32 *pFlags, u32 flagIndex)
フラグのポインタを取得(static関数)
Definition GxStruct.cpp:238

GxFlag32Array::isFlag
GX_FORCE_INLINE b32 isFlag(u32 flagIndex) const
フラグを判定
Definition GxStruct.h:1406

GxFlag32Array::_count
u32 _count
フラグ数
Definition GxStruct.h:1430

GxFlag32Array::getPropertyFlagCount
constexpr u32 getPropertyFlagCount(void) const
プロパティ用フラグ数取得
Definition GxStruct.h:1396

GxFlag32Array::setPropertyFlagCount
constexpr void setPropertyFlagCount(u32)
プロパティ用フラグ数設定(Dummy)
Definition GxStruct.h:1398

GxFlag32Array::setPropertyFlag
void setPropertyFlag(const void *const pValue, u32 index)
プロパティ用フラグ設定
Definition GxStruct.h:1394

GxFlag32Array::getCount
constexpr u32 getCount(void) const
フラグ数を取得
Definition GxStruct.h:1410

GxFlag32Array::setFlag
GX_FORCE_INLINE void setFlag(u32 flagIndex, b32 enable=true)
フラグを設定
Definition GxStruct.h:1403

GxFlag32Array::clear
GX_FORCE_INLINE void clear(void)
クリア
Definition GxStruct.h:1401

GxFlag32Array::GxFlag32Array
GxFlag32Array(u32 *pFlag=nullptr, u32 count=0)
コンストラクタ
Definition GxStruct.h:1381

GxFlag32Array::getSize
GX_FORCE_INLINE u32 getSize(void) const
サイズを取得
Definition GxStruct.h:1408

GxFlag32Array::getPropertyFlag
void getPropertyFlag(void *const pValue, u32 index)
プロパティ用フラグ取得
Definition GxStruct.h:1392

GxFlag32Base
フラグ
Definition GxStruct.h:1243

GxFlag32Base::_flag
u32 _flag
フラグ
Definition GxStruct.h:1285

GxFlag32Base::getFlag
constexpr u32 getFlag(void) const
フラグ直取得
Definition GxStruct.h:1273

GxFlag32Base::clear
constexpr void clear(void)
フラグ値のクリア
Definition GxStruct.h:1277

GxFlag32Base::GxFlag32Base
GxFlag32Base(u32 flag)
コンストラクタ
Definition GxStruct.h:1260

GxFlag32Base::setFlag
constexpr void setFlag(u32 flag)
フラグ直設定
Definition GxStruct.h:1275

GxFlag32Bit
ビット指定型フラグ
Definition GxStruct.h:1338

GxFlag32Bit::isFlag
GX_FORCE_INLINE b32 isFlag(u32 flag) const
フラグ判定
Definition GxStruct.h:1354

GxFlag32Bit::setFlag
GX_FORCE_INLINE void setFlag(u32 flag, b32 enable)
フラグ設定
Definition GxStruct.h:1356

GxFlag32Bit::GxFlag32Bit
GxFlag32Bit(u32 flag=0)
コンストラクタ
Definition GxStruct.h:1345

GxFlag32Index
インデックス指定型フラグ
Definition GxStruct.h:1294

GxFlag32Index::setFlag
GX_FORCE_INLINE void setFlag(T index, b32 enable)
Definition GxStruct.h:1325

GxFlag32Index::isFlag
GX_FORCE_INLINE b32 isFlag(T index) const
フラグ直取得
Definition GxStruct.h:1321

GxFlag32Index::operator&=
GX_FORCE_INLINE GxFlag32Index< T > & operator&=(const GxFlag32Index< T > &flag)
論理積
Definition GxStruct.h:1310

GxFlag32Index::operator|=
GX_FORCE_INLINE GxFlag32Index< T > & operator|=(const GxFlag32Index< T > &flag)
論理和
Definition GxStruct.h:1312

GxFlag32Index::GxFlag32Index
GxFlag32Index(void)
コンストラクタ
Definition GxStruct.h:1301

GxFloat2
2次元浮動小数点数クラス
Definition GxStruct.h:22

GxFloat2::_u
f32 _u
U値
Definition GxStruct.h:76

GxFloat2::GxFloat2
GX_FORCE_INLINE GxFloat2(void)
デフォルトコンストラクタ
Definition GxStruct.h:29

GxFloat2::_x
f32 _x
X値
Definition GxStruct.h:75

GxFloat2::_y
f32 _y
Y値
Definition GxStruct.h:80

GxFloat2::GxFloat2
GX_FORCE_INLINE GxFloat2(f32 x, f32 y)
コンストラクタ
Definition GxStruct.h:31

GxFloat2::_v
f32 _v
V値
Definition GxStruct.h:81

GxFloat2::GxFloat2
GX_FORCE_INLINE GxFloat2(const GxFloat2 &float2)
コピーコンストラクタ
Definition GxStruct.h:46

GxFloat3
3次元浮動小数点数クラス
Definition GxStruct.h:91

GxFloat3::GxFloat3
GX_FORCE_INLINE GxFloat3(const GxFloat3 &float3)
コピーコンストラクタ
Definition GxStruct.h:109

GxFloat3::GxFloat3
GX_FORCE_INLINE GxFloat3(f32 x, f32 y, f32 z)
コンストラクタ
Definition GxStruct.h:100

GxFloat3::_y
f32 _y
Y値
Definition GxStruct.h:143

GxFloat3::_x
f32 _x
X値
Definition GxStruct.h:142

GxFloat3::GxFloat3
GX_FORCE_INLINE GxFloat3(void)
デフォルトコンストラクタ
Definition GxStruct.h:98

GxFloat3::operator=
GX_FORCE_INLINE GxFloat3 & operator=(const GxVector3 &vector)
代入
Definition GxStruct.inl:166

GxFloat3::_z
f32 _z
Z値
Definition GxStruct.h:144

GxFloat4
4次元浮動小数点数クラス
Definition GxStruct.h:153

GxFloat4::operator=
GX_FORCE_INLINE GxFloat4 & operator=(const GxVector4 &vector)
代入
Definition GxStruct.inl:219

GxFloat4::_x
f32 _x
X値
Definition GxStruct.h:192

GxFloat4::_y
f32 _y
Y値
Definition GxStruct.h:193

GxFloat4::_z
f32 _z
Z値
Definition GxStruct.h:194

GxFloat4::GxFloat4
GX_FORCE_INLINE GxFloat4(void)
デフォルトコンストラクタ
Definition GxStruct.h:160

GxFloat4::GxFloat4
GX_FORCE_INLINE GxFloat4(f32 x, f32 y, f32 z, f32 w)
コンストラクタ
Definition GxStruct.h:162

GxFloat4::_w
f32 _w
W値
Definition GxStruct.h:195

GxFloat4::GxFloat4
GX_FORCE_INLINE GxFloat4(const GxFloat4 &float4)
コピーコンストラクタ
Definition GxStruct.h:169

GxPackedNx3
32bit[-1, 1]正規化小数3次元ベクトル(11:11:10)
Definition GxStruct.h:646

GxPackedNx3::getValueF32
GX_FORCE_INLINE f32 getValueF32(u32 index) const
f32で値を取得
Definition GxStruct.inl:902

GxPackedNx3::operator=
GX_FORCE_INLINE GxPackedNx3 & operator=(const GxPackedNx3 &value)
代入
Definition GxStruct.h:683

GxPackedNx3::s10NTof32
static GX_FORCE_INLINE f32 s10NTof32(u32 valueS10N)
10ビットから32ビットの変換
Definition GxStruct.inl:829

GxPackedNx3::SHIFT_Y
static constexpr u32 SHIFT_Y
Y成分シフト量
Definition GxStruct.h:657

GxPackedNx3::f32ToS10N
static GX_FORCE_INLINE u32 f32ToS10N(f32 valueF32)
32ビットから10ビットの変換
Definition GxStruct.inl:804

GxPackedNx3::SHIFT_X
static constexpr u32 SHIFT_X
X成分シフト量
Definition GxStruct.h:655

GxPackedNx3::DIMENSION
static constexpr u32 DIMENSION
次元数
Definition GxStruct.h:653

GxPackedNx3::GxPackedNx3
GxPackedNx3(void)
デフォルトコンストラクタ
Definition GxStruct.h:668

GxPackedNx3::GxPackedNx3
GX_INLINE GxPackedNx3(const GxPackedNx3 &value)
コンストラクタ
Definition GxStruct.h:670

GxPackedNx3::setValueF32
GX_FORCE_INLINE void setValueF32(u32 index, f32 setValue)
f32で値を設定
Definition GxStruct.inl:939

GxPackedNx3::GxPackedNx3
GX_INLINE GxPackedNx3(const GxVector3 &value)
コンストラクタ
Definition GxStruct.h:674

GxPackedNx3::s11NTof32
static GX_FORCE_INLINE f32 s11NTof32(u32 valueS11N)
11ビットから32ビットの変換
Definition GxStruct.inl:878

GxPackedNx3::GxPackedNx3
GX_INLINE GxPackedNx3(const GxFloat3 &value)
コンストラクタ
Definition GxStruct.h:672

GxPackedNx3::SHIFT_Z
static constexpr u32 SHIFT_Z
Z成分シフト量
Definition GxStruct.h:659

GxPackedNx3::f32ToS11N
static GX_FORCE_INLINE u32 f32ToS11N(f32 valueF32)
32ビットから11ビットの変換
Definition GxStruct.inl:853

GxPoint2
座標
Definition GxStruct.h:867

GxPoint2::_y
s32 _y
Y値
Definition GxStruct.h:942

GxPoint2::operator-=
GX_FORCE_INLINE GxPoint2 & operator-=(const GxPoint2 &point)
減算代入
Definition GxStruct.inl:1475

GxPoint2::operator=
GX_FORCE_INLINE GxPoint2 & operator=(const GxPoint2 &point)
代入
Definition GxStruct.inl:1451

GxPoint2::operator==
friend GX_FORCE_INLINE b32 operator==(const GxPoint2 &point0, const GxPoint2 &point1)
一致
Definition GxStruct.inl:1556

GxPoint2::operator-
friend GX_FORCE_INLINE const GxPoint2 operator-(const GxPoint2 &point)
負ベクトル
Definition GxStruct.h:912

GxPoint2::GxPoint2
GX_FORCE_INLINE GxPoint2(void)
コンストラクタ
Definition GxStruct.h:885

GxPoint2::operator+
friend GX_FORCE_INLINE const GxPoint2 operator+(const GxPoint2 &point)
正ベクトル
Definition GxStruct.h:910

GxPoint2::operator!=
friend GX_FORCE_INLINE b32 operator!=(const GxPoint2 &point0, const GxPoint2 &point1)
不一致
Definition GxStruct.inl:1567

GxPoint2::getSquareDistanceToSegment
f32 getSquareDistanceToSegment(GxPoint2 segmentStart, GxPoint2 segmentEnd) const
線分との距離の2乗を取得
Definition GxStruct.cpp:128

GxPoint2::ZERO
static const GxPoint2 ZERO
原点座標
Definition GxStruct.h:876

GxPoint2::_x
s32 _x
X値
Definition GxStruct.h:941

GxPoint2::operator+=
GX_FORCE_INLINE GxPoint2 & operator+=(const GxPoint2 &point)
加算代入
Definition GxStruct.inl:1463

GxQuaternion
クォータニオン
Definition GxQuaternion.h:19

GxRectF
実数矩形
Definition GxStruct.h:1100

GxRectF::operator!=
friend GX_FORCE_INLINE b32 operator!=(const GxRectF &rect0, const GxRectF &rect1)
不一致
Definition GxStruct.inl:2056

GxRectF::_left
f32 _left
左辺
Definition GxStruct.h:1231

GxRectF::getLeftBottom
GX_INLINE GxVector2 getLeftBottom(void) const
左下を取得
Definition GxStruct.h:1201

GxRectF::isHit
GX_INLINE b32 isHit(const GxRectF &rect) const
衝突判定
Definition GxStruct.inl:2066

GxRectF::getCenter
GX_INLINE GxVector2 getCenter(void) const
中央を取得
Definition GxStruct.h:1205

GxRectF::operator==
friend GX_FORCE_INLINE b32 operator==(const GxRectF &rect0, const GxRectF &rect1)
一致
Definition GxStruct.inl:2045

GxRectF::GxRectF
GX_FORCE_INLINE GxRectF(const f32 left, const f32 top, const f32 right, const f32 bottom)
コンストラクタ
Definition GxStruct.h:1129

GxRectF::GxRectF
GX_FORCE_INLINE GxRectF(void)
デフォルトコンストラクタ
Definition GxStruct.h:1127

GxRectF::operator+=
GX_FORCE_INLINE GxRectF & operator+=(const GxRectF &rect)
加算
Definition GxStruct.inl:1874

GxRectF::_bottom
f32 _bottom
底辺
Definition GxStruct.h:1234

GxRectF::_top
f32 _top
上辺
Definition GxStruct.h:1232

GxRectF::isIncluding
GX_INLINE b32 isIncluding(const GxRectF &rect) const
内包判定
Definition GxStruct.inl:2081

GxRectF::operator-
friend GX_FORCE_INLINE const GxRectF operator-(const GxRectF &rect)
負
Definition GxStruct.inl:1968

GxRectF::getHeight
constexpr f32 getHeight(void) const
高さを取得
Definition GxStruct.h:1188

GxRectF::setGxRect
GX_FORCE_INLINE const GxRectF & setGxRect(const GxRect &rect)
GxRect型をセット(セット後に自身を返す)
Definition GxStruct.inl:2136

GxRectF::operator-=
GX_FORCE_INLINE GxRectF & operator-=(const GxRectF &rect)
減算
Definition GxStruct.inl:1888

GxRectF::BASE
BASE
基準位置
Definition GxStruct.h:1113

GxRectF::BASE::BOTTOM_RIGHT
@ BOTTOM_RIGHT
右下

GxRectF::BASE::TOP_LEFT
@ TOP_LEFT
左上

GxRectF::BASE::BOTTOM_LEFT
@ BOTTOM_LEFT
左下

GxRectF::BASE::TOP_RIGHT
@ TOP_RIGHT
右上

GxRectF::operator&
friend GX_FORCE_INLINE const GxRectF operator&(const GxRectF &rect0, const GxRectF &rect1)
論理積
Definition GxStruct.inl:2023

GxRectF::getLeftTop
GX_INLINE GxVector2 getLeftTop(void) const
左上を取得
Definition GxStruct.h:1197

GxRectF::GxRectF
GX_FORCE_INLINE GxRectF(const GxRectF &rect)
コピーコンストラクタ
Definition GxStruct.h:1134

GxRectF::operator+
friend GX_FORCE_INLINE const GxRectF operator+(const GxRectF &rect)
正
Definition GxStruct.inl:1958

GxRectF::_right
f32 _right
右辺
Definition GxStruct.h:1233

GxRectF::setSize
GX_INLINE void setSize(const GxSize &size, BASE base=BASE::TOP_LEFT)
サイズの変更
Definition GxStruct.inl:2108

GxRectF::operator|=
GX_FORCE_INLINE GxRectF & operator|=(const GxRectF &rect)
論理和
Definition GxStruct.inl:1944

GxRectF::getRightBottom
GX_INLINE GxVector2 getRightBottom(void) const
右下を取得
Definition GxStruct.h:1203

GxRectF::operator=
GX_FORCE_INLINE GxRectF & operator=(const GxRectF &rect)
代入
Definition GxStruct.inl:1860

GxRectF::getRightTop
GX_INLINE GxVector2 getRightTop(void) const
右上を取得
Definition GxStruct.h:1199

GxRectF::add
constexpr void add(f32 value)
拡大・縮小
Definition GxStruct.h:1223

GxRectF::getWidth
constexpr f32 getWidth(void) const
幅を取得
Definition GxStruct.h:1186

GxRectF::add
constexpr void add(f32 x, f32 y)
拡大・縮小
Definition GxStruct.h:1221

GxRectF::operator&=
GX_FORCE_INLINE GxRectF & operator&=(const GxRectF &rect)
論理積
Definition GxStruct.inl:1930

GxRectF::initialize
GX_FORCE_INLINE void initialize(f32 left, f32 top, f32 right, f32 bottom)
初期化
Definition GxStruct.h:1136

GxRectF::GxRectF
GX_FORCE_INLINE GxRectF(const GxVector2 &leftTop, const GxVector2 &rightBottom)
コンストラクタ
Definition GxStruct.h:1131

GxRectF::getSize
GX_INLINE GxSize getSize(void) const
サイズを取得
Definition GxStruct.h:1190

GxRectF::operator|
friend GX_FORCE_INLINE const GxRectF operator|(const GxRectF &rect0, const GxRectF &rect1)
論理和
Definition GxStruct.inl:2034

GxRectF::ZERO
static const GxRectF ZERO
(0, 0, 0, 0)
Definition GxStruct.h:1109

GxRect
矩形
Definition GxStruct.h:951

GxRect::MIN
static const GxRect MIN
(max, max, min, min)
Definition GxStruct.h:960

GxRect::add
constexpr void add(s32 value)
拡大・縮小
Definition GxStruct.h:1080

GxRect::operator!=
friend GX_FORCE_INLINE b32 operator!=(const GxRect &rect0, const GxRect &rect1)
不一致
Definition GxStruct.inl:1776

GxRect::GxRect
GX_FORCE_INLINE GxRect(const GxPoint2 &leftTop, const GxPoint2 &rightBottom)
コンストラクタ
Definition GxStruct.h:990

GxRect::operator+=
GX_FORCE_INLINE GxRect & operator+=(const GxRect &rect)
加算
Definition GxStruct.inl:1594

GxRect::getLeftBottom
GX_INLINE GxPoint2 getLeftBottom(void) const
左下を取得
Definition GxStruct.h:1058

GxRect::operator&
friend GX_FORCE_INLINE const GxRect operator&(const GxRect &rect0, const GxRect &rect1)
論理積
Definition GxStruct.inl:1743

GxRect::GxRect
GX_FORCE_INLINE GxRect(const GxSize &size)
コンストラクタ
Definition GxStruct.h:986

GxRect::operator|=
GX_FORCE_INLINE GxRect & operator|=(const GxRect &rect)
論理和
Definition GxStruct.inl:1664

GxRect::getLeftTop
GX_INLINE GxPoint2 getLeftTop(void) const
左上を取得
Definition GxStruct.h:1054

GxRect::operator&=
GX_FORCE_INLINE GxRect & operator&=(const GxRect &rect)
論理積
Definition GxStruct.inl:1650

GxRect::initialize
GX_FORCE_INLINE void initialize(s32 left, s32 top, s32 right, s32 bottom)
初期化
Definition GxStruct.h:995

GxRect::operator-=
GX_FORCE_INLINE GxRect & operator-=(const GxRect &rect)
減算
Definition GxStruct.inl:1608

GxRect::operator+
friend GX_FORCE_INLINE const GxRect operator+(const GxRect &rect)
正
Definition GxStruct.inl:1678

GxRect::MAX
static const GxRect MAX
(min, min, max, max)
Definition GxStruct.h:962

GxRect::_bottom
s32 _bottom
底辺
Definition GxStruct.h:1091

GxRect::isIncluding
GX_INLINE b32 isIncluding(const GxRect &rect) const
内包判定
Definition GxStruct.inl:1801

GxRect::operator-
friend GX_FORCE_INLINE const GxRect operator-(const GxRect &rect)
負
Definition GxStruct.inl:1688

GxRect::getSize
GX_INLINE GxSize getSize(void) const
サイズを取得
Definition GxStruct.h:1049

GxRect::getRightBottom
GX_INLINE GxPoint2 getRightBottom(void) const
右下を取得
Definition GxStruct.h:1060

GxRect::operator|
friend GX_FORCE_INLINE const GxRect operator|(const GxRect &rect0, const GxRect &rect1)
論理和
Definition GxStruct.inl:1754

GxRect::ZERO
static const GxRect ZERO
(0, 0, 0, 0)
Definition GxStruct.h:964

GxRect::operator==
friend GX_FORCE_INLINE b32 operator==(const GxRect &rect0, const GxRect &rect1)
一致
Definition GxStruct.inl:1765

GxRect::operator=
GX_FORCE_INLINE GxRect & operator=(const GxRect &rect)
代入
Definition GxStruct.inl:1580

GxRect::setSize
GX_INLINE void setSize(const GxSize &size, BASE base=BASE::TOP_LEFT)
サイズの変更
Definition GxStruct.inl:1829

GxRect::GxRect
GX_FORCE_INLINE GxRect(void)
デフォルトコンストラクタ
Definition GxStruct.h:982

GxRect::GxRect
GX_FORCE_INLINE GxRect(const s32 left, const s32 top, const s32 right, const s32 bottom)
コンストラクタ
Definition GxStruct.h:984

GxRect::add
constexpr void add(s32 x, s32 y)
拡大・縮小
Definition GxStruct.h:1078

GxRect::getRightTop
GX_INLINE GxPoint2 getRightTop(void) const
右上を取得
Definition GxStruct.h:1056

GxRect::GxRect
GX_FORCE_INLINE GxRect(const GxPoint2 &leftTop, const GxSize &size)
コンストラクタ
Definition GxStruct.h:988

GxRect::isHit
GX_INLINE b32 isHit(const GxRect &rect) const
衝突判定
Definition GxStruct.inl:1786

GxRect::BASE
BASE
基準位置
Definition GxStruct.h:968

GxRect::BASE::BOTTOM_RIGHT
@ BOTTOM_RIGHT
右下

GxRect::BASE::TOP_LEFT
@ TOP_LEFT
左上

GxRect::BASE::BOTTOM_LEFT
@ BOTTOM_LEFT
左下

GxRect::BASE::TOP_RIGHT
@ TOP_RIGHT
右上

GxRect::getCenter
GX_INLINE GxPoint2 getCenter(void) const
中央を取得
Definition GxStruct.h:1062

GxRect::getWidth
constexpr s32 getWidth(void) const
幅を取得
Definition GxStruct.h:1045

GxRect::getHeight
constexpr s32 getHeight(void) const
高さを取得
Definition GxStruct.h:1047

GxRect::GxRect
GX_FORCE_INLINE GxRect(const GxRect &rect)
コピーコンストラクタ
Definition GxStruct.h:993

GxRect::_top
s32 _top
上辺
Definition GxStruct.h:1089

GxRect::_left
s32 _left
左辺
Definition GxStruct.h:1088

GxRect::_right
s32 _right
右辺
Definition GxStruct.h:1090

GxSize
サイズ
Definition GxStruct.h:730

GxSize::subScalar
GX_FORCE_INLINE const GxSize & subScalar(s32 scalar)
スカラ減算
Definition GxStruct.inl:1338

GxSize::operator+=
GX_FORCE_INLINE GxSize & operator+=(s32 scalar)
スカラ加算代入
Definition GxStruct.inl:1017

GxSize::operator=
GX_FORCE_INLINE GxSize & operator=(const GxSize &size)
代入
Definition GxStruct.inl:1005

GxSize::operator&
friend GX_FORCE_INLINE const GxSize operator&(const GxSize &size0, const GxSize &size1)
論理積
Definition GxStruct.inl:1192

GxSize::operator/
friend GX_FORCE_INLINE const GxSize operator/(const GxSize &size, s32 scalar)
スカラ除算
Definition GxStruct.inl:1156

GxSize::operator|
friend GX_FORCE_INLINE const GxSize operator|(const GxSize &size0, const GxSize &size1)
論理和
Definition GxStruct.inl:1203

GxSize::operator&=
GX_FORCE_INLINE GxSize & operator&=(const GxSize &size)
論理積
Definition GxStruct.inl:1083

GxSize::operator-=
GX_FORCE_INLINE GxSize & operator-=(s32 scalar)
スカラ減算代入
Definition GxStruct.inl:1028

GxSize::mulScalar
GX_FORCE_INLINE const GxSize & mulScalar(s32 scalar)
スカラ乗算
Definition GxStruct.inl:1351

GxSize::MIN
static const GxSize MIN
最小
Definition GxStruct.h:739

GxSize::GxSize
GX_FORCE_INLINE GxSize(void)
デフォルトコンストラクタ
Definition GxStruct.h:752

GxSize::operator|=
GX_FORCE_INLINE GxSize & operator|=(const GxSize &size)
論理和
Definition GxStruct.inl:1095

GxSize::getSubScalar
static GX_FORCE_INLINE const GxSize & getSubScalar(GxSize &dst, const GxSize &size, s32 scalar)
スカラ減算を取得
Definition GxStruct.inl:1252

GxSize::isIncluding
GX_INLINE b32 isIncluding(const GxPoint2 &point) const
内包判定
Definition GxStruct.inl:1403

GxSize::ZERO
static const GxSize ZERO
0
Definition GxStruct.h:743

GxSize::operator*=
GX_FORCE_INLINE GxSize & operator*=(s32 scalar)
スカラ乗算代入
Definition GxStruct.inl:1039

GxSize::subSize
GX_FORCE_INLINE const GxSize & subSize(const GxSize &size)
サイズ減算
Definition GxStruct.inl:1390

GxSize::_width
s32 _width
幅
Definition GxStruct.h:857

GxSize::getDivScalar
static GX_FORCE_INLINE const GxSize & getDivScalar(GxSize &dst, const GxSize &size, s32 scalar)
スカラ除算を取得
Definition GxStruct.inl:1282

GxSize::_height
s32 _height
高さ
Definition GxStruct.h:858

GxSize::getAddSize
static GX_FORCE_INLINE const GxSize & getAddSize(GxSize &dst, const GxSize &size0, const GxSize &size1)
サイズ加算を取得
Definition GxStruct.inl:1297

GxSize::operator/=
GX_FORCE_INLINE GxSize & operator/=(s32 scalar)
スカラ除算代入
Definition GxStruct.inl:1050

GxSize::addSize
GX_FORCE_INLINE const GxSize & addSize(const GxSize &size)
サイズ加算
Definition GxStruct.inl:1377

GxSize::mulSize
GX_FORCE_INLINE const GxSize & mulSize(const GxSize &size)
サイズ乗算

GxSize::addScalar
GX_FORCE_INLINE const GxSize & addScalar(s32 scalar)
スカラ加算
Definition GxStruct.inl:1325

GxSize::getSubSize
static GX_FORCE_INLINE const GxSize & getSubSize(GxSize &dst, const GxSize &size0, const GxSize &size1)
サイズ減算を取得
Definition GxStruct.inl:1312

GxSize::getMulScalar
static GX_FORCE_INLINE const GxSize & getMulScalar(GxSize &dst, const GxSize &size, s32 scalar)
スカラ乗算を取得
Definition GxStruct.inl:1267

GxSize::operator*
friend GX_FORCE_INLINE const GxSize operator*(const GxSize &size, s32 scalar)
スカラ乗算
Definition GxStruct.inl:1132

GxSize::operator+
friend GX_FORCE_INLINE const GxSize operator+(const GxSize &size, s32 scalar)
スカラ加算
Definition GxStruct.inl:1108

GxSize::getAddScalar
static GX_FORCE_INLINE const GxSize & getAddScalar(GxSize &dst, const GxSize &size, s32 scalar)
スカラ加算を取得
Definition GxStruct.inl:1237

GxSize::operator!=
friend GX_FORCE_INLINE b32 operator!=(const GxSize &size0, const GxSize &size1)
不一致
Definition GxStruct.inl:1225

GxSize::operator-
friend GX_FORCE_INLINE const GxSize operator-(const GxSize &size, s32 scalar)
スカラ減算
Definition GxStruct.inl:1120

GxSize::operator==
friend GX_FORCE_INLINE b32 operator==(const GxSize &size0, const GxSize &size1)
一致
Definition GxStruct.inl:1214

GxSize::divScalar
GX_FORCE_INLINE const GxSize & divScalar(s32 scalar)
スカラ除算
Definition GxStruct.inl:1364

GxSize::MAX
static const GxSize MAX
最大
Definition GxStruct.h:741

GxStructBase
Definition GxBase.h:24

GxU8N
8bit[0, 1]正規化小数
Definition GxStruct.h:530

GxU8N::u8NToF32
static GX_FORCE_INLINE f32 u8NToF32(GxU8N valueU8N)
8ビットから32ビットの変換
Definition GxStruct.inl:715

GxU8N::f32ToU8N
static GX_FORCE_INLINE GxU8N f32ToU8N(f32 valueF32)
32ビットから8ビットの変換
Definition GxStruct.inl:700

GxU8N::getValueU8
constexpr u8 getValueU8(void) const
u8で値を取得する
Definition GxStruct.h:564

GxU8N::setValueU8
constexpr void setValueU8(u8 setValue)
u8で値を設定する
Definition GxStruct.h:566

GxU8N::GxU8N
GX_INLINE GxU8N(void)
デフォルトコンストラクタ
Definition GxStruct.inl:665

GxU8Nx4
32bit[0, 1]正規化小数4次元ベクトル(8:8:8:8)
Definition GxStruct.h:583

GxU8Nx4::GxU8Nx4
GX_INLINE GxU8Nx4(const GxVector4 &value)
コンストラクタ
Definition GxStruct.h:605

GxU8Nx4::GxU8Nx4
GxU8Nx4(void)
デフォルトコンストラクタ
Definition GxStruct.h:599

GxU8Nx4::operator[]
GX_FORCE_INLINE const GxU8N & operator[](u32 i) const
const配列
Definition GxStruct.h:627

GxU8Nx4::operator[]
GX_FORCE_INLINE GxU8N & operator[](u32 i)
配列
Definition GxStruct.h:629

GxU8Nx4::GxU8Nx4
GX_INLINE GxU8Nx4(const GxFloat4 &value)
コンストラクタ
Definition GxStruct.h:603

GxU8Nx4::operator=
GX_FORCE_INLINE GxU8Nx4 & operator=(const GxU8Nx4 &value)
代入
Definition GxStruct.inl:728

GxU8Nx4::DIMENSION
static constexpr u32 DIMENSION
次元数
Definition GxStruct.h:590

GxU8Nx4::GxU8Nx4
GX_INLINE GxU8Nx4(const GxU8Nx4 &value)
コンストラクタ
Definition GxStruct.h:601

GxVector2
2次元ベクトル
Definition GxVector.h:34

GxVector2d
2次元ベクトル(倍精度)
Definition GxVectord.h:25

GxVector3
3次元ベクトル
Definition GxVector.h:245

GxVector3::_z
f32 _z
Z値
Definition GxVector.h:572

GxVector3::_y
f32 _y
Y値
Definition GxVector.h:571

GxVector3::_x
f32 _x
X値
Definition GxVector.h:570

GxVector3d
3次元ベクトル(倍精度)
Definition GxVectord.h:235

GxVector4
4次元ベクトル
Definition GxVector.h:582

GxVector4d
4次元ベクトル(倍精度)
Definition GxVectord.h:497

b32
32bitブーリアン
Definition GxDefine.h:173