doc/api/_gx_matrix_8h_source.html

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

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

#pragma once


GX_CORE_NAMESPACE_BEGIN()


#define GX_MATRIX_SAFE_MODE 0


struct GxFloat2;

struct GxFloat3;

struct GxFloat4;

struct GxSize;

struct GxPoint2;

struct GxRect;

struct GxVector2;

struct GxVector3;

struct GxVector4;

struct GxMatrixAffine;

struct GxMatrixAffineGpu;

struct GxMatrix44;

struct GxQuaternion;

struct GxColorHDR;

class GxStreamWriter;


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

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


GX_ALIGN16_BEGIN struct GxMatrix22 : public GxStructBase

{

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

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

public:

    GX_RTTI_STRUCT(GxMatrix22)


    static const GxMatrix22 ZERO;

    static const GxMatrix22 IDENTITY;


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

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


    GxMatrix22(void) {}

    GX_INLINE GxMatrix22(f32 m00, f32 m01,

                        f32 m10, f32 m11);


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

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


    GX_FORCE_INLINE GxMatrix22& operator = (const GxMatrix22& matrix);

    GX_FORCE_INLINE GxMatrix22& operator *= (f32 scalar);

    GX_FORCE_INLINE GxMatrix22& operator /= (f32 scalar);

    GX_FORCE_INLINE GxMatrix22& operator += (const GxMatrix22& matrix);

    GX_FORCE_INLINE GxMatrix22& operator *= (const GxMatrix22& matrix);

    friend GX_FORCE_INLINE const GxMatrix22 operator * (const GxMatrix22& matrix, f32 scalar);

    friend GX_FORCE_INLINE const GxMatrix22 operator / (const GxMatrix22& matrix, f32 scalar);

    friend GX_FORCE_INLINE const GxMatrix22 operator + (const GxMatrix22& matrix0, const GxMatrix22& matrix1);

    friend GX_FORCE_INLINE const GxMatrix22 operator * (const GxMatrix22& matrix0, const GxMatrix22& matrix1);

    GX_FORCE_INLINE b32 operator == (const GxMatrix22& matrix);

    GX_FORCE_INLINE b32 operator != (const GxMatrix22& matrix);


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

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


    GX_FORCE_INLINE void                        setIdentity(void);

    GX_FORCE_INLINE const GxVector2&            getRow(u32 row) const;

    GX_FORCE_INLINE void                        setRow(u32 row, const GxVector2& vector);

    GX_FORCE_INLINE GxVector2                   getColumn(u32 column) const;

    GX_FORCE_INLINE void                        setColumn(u32 column, const GxVector2& vector);

    GX_FORCE_INLINE f32                         getValue(u32 row, u32 column) const;

    GX_FORCE_INLINE void                        setValue(u32 row, u32 column, f32 value);

    GX_FORCE_INLINE f32&                        getReference(u32 row, u32 column);

    GX_FORCE_INLINE const f32&                  getReference(u32 row, u32 column) const;

    GX_FORCE_INLINE f32                         getDeterminant(void) const;

    GX_FORCE_INLINE GxMatrix22                  getInverse(void) const;

    GX_FORCE_INLINE GxMatrix22                  getTranspose(void) const;


    static GX_FORCE_INLINE const GxMatrix22&    getMulScalar(GxMatrix22& dst, const GxMatrix22& matrix, f32 scalar);

    static GX_FORCE_INLINE const GxMatrix22&    getDivScalar(GxMatrix22& dst, const GxMatrix22& matrix, f32 scalar);

    static GX_FORCE_INLINE const GxMatrix22&    getAddMatrix(GxMatrix22& dst, const GxMatrix22& matrix0, const GxMatrix22& matrix1);

    static GX_FORCE_INLINE const GxMatrix22&    getMulMatrix(GxMatrix22& dst, const GxMatrix22& matrix0, const GxMatrix22& matrix1);

    static GX_FORCE_INLINE const GxMatrix22&    getInverse(GxMatrix22& dst, const GxMatrix22& matrix);

    static GX_FORCE_INLINE const GxMatrix22&    getTranspose(GxMatrix22& dst, const GxMatrix22& matrix);


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

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


    GX_FORCE_INLINE const GxMatrix22&           mulScalar(f32 scalar);

    GX_FORCE_INLINE const GxMatrix22&           divScalar(f32 scalar);

    GX_FORCE_INLINE const GxMatrix22&           addMatrix(const GxMatrix22& matrix);

    GX_FORCE_INLINE const GxMatrix22&           mulMatrix(const GxMatrix22& matrix);

    GX_FORCE_INLINE const GxMatrix22&           inverse(void);

    GX_FORCE_INLINE const GxMatrix22&           transpose(void);


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

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


    f32         _m[2][4];


} GX_ALIGN16_END;


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

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


GX_ALIGN16_BEGIN struct GxMatrix33 : public GxStructBase

{

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

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

public:

    GX_RTTI_STRUCT(GxMatrix33)


    static const GxMatrix33 ZERO;

    static const GxMatrix33 IDENTITY;


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

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


    GxMatrix33(void) {}

    GX_INLINE GxMatrix33(f32 m00, f32 m01, f32 m02,

                        f32 m10, f32 m11, f32 m12,

                        f32 m20, f32 m21, f32 m22);


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

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


    GX_FORCE_INLINE GxMatrix33& operator = (const GxMatrix33& matrix);

    GX_FORCE_INLINE GxMatrix33& operator *= (f32 scalar);

    GX_FORCE_INLINE GxMatrix33& operator /= (f32 scalar);

    GX_FORCE_INLINE GxMatrix33& operator += (const GxMatrix33& matrix);

    GX_FORCE_INLINE GxMatrix33& operator *= (const GxMatrix33& matrix);

    friend GX_FORCE_INLINE const GxMatrix33 operator * (const GxMatrix33& matrix, f32 scalar);

    friend GX_FORCE_INLINE const GxMatrix33 operator / (const GxMatrix33& matrix, f32 scalar);

    friend GX_FORCE_INLINE const GxMatrix33 operator + (const GxMatrix33& matrix0, const GxMatrix44& matrix1);

    friend GX_FORCE_INLINE const GxMatrix33 operator * (const GxMatrix33& matrix0, const GxMatrix44& matrix1);

    GX_FORCE_INLINE b32 operator == (const GxMatrix33& matrix);

    GX_FORCE_INLINE b32 operator != (const GxMatrix33& matrix);


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

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


    GX_FORCE_INLINE void                        setIdentity(void);

    GX_FORCE_INLINE void                        setRotate(f32 sinValue, f32 cosValue);

    GX_FORCE_INLINE void                        setRotate(f32 radian) { setRotate(sinf(radian), cosf(radian)); }

    GX_FORCE_INLINE void                        setTranslate(const GxVector2& vector);

    GX_FORCE_INLINE void                        setTranslate(f32 x, f32 y);

    GX_FORCE_INLINE const GxVector2&            getPosition(void) const { return *reinterpret_cast<const GxVector2*>(&_m[2][0]); }

    GX_FORCE_INLINE void                        setPosition(const GxVector2& position);

    GX_FORCE_INLINE void                        setPosition(f32 x, f32 y);

    GX_FORCE_INLINE void                        setScale(const GxVector2& vector);

    GX_FORCE_INLINE void                        setScale(f32 x, f32 y);

    GX_FORCE_INLINE const GxVector3&            getRow(u32 row) const;

    GX_FORCE_INLINE void                        setRow(u32 row, const GxVector3& vector);

    GX_FORCE_INLINE GxVector3                   getColumn(u32 column) const;

    GX_FORCE_INLINE void                        setColumn(u32 column, const GxVector3& vector);

    GX_FORCE_INLINE f32                         getValue(u32 row, u32 column) const;

    GX_FORCE_INLINE void                        setValue(u32 row, u32 column, f32 value);

    GX_FORCE_INLINE f32&                        getReference(u32 row, u32 column);

    GX_FORCE_INLINE const f32&                  getReference(u32 row, u32 column) const;

    GX_FORCE_INLINE f32                         getDeterminant(void) const;

    GX_FORCE_INLINE GxMatrix33                  getInverse(void) const;

    GX_FORCE_INLINE GxMatrix33                  getTranspose(void) const;


    static GX_FORCE_INLINE const GxMatrix33&    getMulScalar(GxMatrix33& dst, const GxMatrix33& matrix, f32 scalar);

    static GX_FORCE_INLINE const GxMatrix33&    getDivScalar(GxMatrix33& dst, const GxMatrix33& matrix, f32 scalar);

    static GX_FORCE_INLINE const GxMatrix33&    getAddMatrix(GxMatrix33& dst, const GxMatrix33& matrix0, const GxMatrix33& matrix1);

    static GX_FORCE_INLINE const GxMatrix33&    getMulMatrix(GxMatrix33& dst, const GxMatrix33& matrix0, const GxMatrix33& matrix1);

    static GX_FORCE_INLINE const GxMatrix33&    getInverse(GxMatrix33& dst, const GxMatrix33& matrix);

    static GX_FORCE_INLINE const GxMatrix33&    getTranspose(GxMatrix33& dst, const GxMatrix33& matrix);


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

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


    GX_FORCE_INLINE const GxMatrix33&           mulScalar(f32 scalar);

    GX_FORCE_INLINE const GxMatrix33&           divScalar(f32 scalar);

    GX_FORCE_INLINE const GxMatrix33&           addMatrix(const GxMatrix33& matrix);

    GX_FORCE_INLINE const GxMatrix33&           mulMatrix(const GxMatrix33& matrix);

    GX_FORCE_INLINE const GxMatrix33&           mulRotate(f32 radian);

    GX_FORCE_INLINE const GxMatrix33&           mulTranslate(const GxVector2& vector);

    GX_FORCE_INLINE const GxMatrix33&           mulTranslate(f32 x, f32 y);

    GX_FORCE_INLINE const GxMatrix33&           mulScale(const GxVector2& vector);

    GX_FORCE_INLINE const GxMatrix33&           mulScale(f32 x, f32 y);

    GX_FORCE_INLINE const GxMatrix33&           inverse(void);

    GX_FORCE_INLINE const GxMatrix33&           transpose(void);


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

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


    f32         _m[3][4];


} GX_ALIGN16_END;


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

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


GX_ALIGN16_BEGIN struct GxMatrixAffine : public GxStructBase

{

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

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

public:

    GX_RTTI_STRUCT(GxMatrixAffine)


    static const GxMatrixAffine ZERO;

    static const GxMatrixAffine IDENTITY;


    friend struct GxMatrix44;

    friend struct GxMatrixAffineGpu;


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

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


    GxMatrixAffine(void) { setZero(); }

    GX_INLINE GxMatrixAffine(INIT initType);

    GX_INLINE GxMatrixAffine(const GxQuaternion& quaternion, const GxVector3& position);

    GX_INLINE GxMatrixAffine(const GxQuaternion& quaternion);

    GX_INLINE GxMatrixAffine(const GxVector3& position);

    GX_INLINE GxMatrixAffine(   f32 m00, f32 m01, f32 m02,

                                f32 m10, f32 m11, f32 m12,

                                f32 m20, f32 m21, f32 m22,

                                f32 m30, f32 m31, f32 m32);

    GX_INLINE GxMatrixAffine(const GxMatrix44& matrix);

    GX_INLINE GxMatrixAffine(const GxVector3& position, const GxMatrix33& orientation);

    GX_INLINE GxMatrixAffine(const GxMatrixAffine& matrix);

    GX_FORCE_INLINE void initialize(const GxQuaternion& quaternion, const GxVector3& position);


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

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


    GX_FORCE_INLINE GxMatrixAffine& operator = (const GxMatrixAffine& matrix);

    GX_FORCE_INLINE GxMatrixAffine& operator *= (f32 scalar);

    GX_FORCE_INLINE GxMatrixAffine& operator /= (f32 scalar);

    GX_FORCE_INLINE GxMatrixAffine& operator += (const GxMatrixAffine& matrix);

    GX_FORCE_INLINE GxMatrixAffine& operator *= (const GxMatrixAffine& matrix);

    friend GX_FORCE_INLINE const GxMatrixAffine operator * (const GxMatrixAffine& matrix, f32 scalar);

    friend GX_FORCE_INLINE const GxMatrixAffine operator / (const GxMatrixAffine& matrix, f32 scalar);

    friend GX_FORCE_INLINE const GxMatrixAffine operator + (const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1);

    friend GX_FORCE_INLINE const GxMatrixAffine operator * (const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1);

    GX_FORCE_INLINE b32 operator == (const GxMatrixAffine& matrix);

    GX_FORCE_INLINE b32 operator != (const GxMatrixAffine& matrix);


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

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


    GX_FORCE_INLINE void                            setIdentity(void);

    GX_FORCE_INLINE void                            setRotateX(f32 sinValue, f32 cosValue);

    GX_FORCE_INLINE void                            setRotateX(f32 radian) { setRotateX(sinf(radian), cosf(radian)); }

    GX_FORCE_INLINE void                            setRotateY(f32 sinValue, f32 cosValue);

    GX_FORCE_INLINE void                            setRotateY(f32 radian) { setRotateY(sinf(radian), cosf(radian)); }

    GX_FORCE_INLINE void                            setRotateZ(f32 sinValue, f32 cosValue);

    GX_FORCE_INLINE void                            setRotateZ(f32 radian) { setRotateZ(sinf(radian), cosf(radian)); }

    GX_FORCE_INLINE GxVector3                       getRotateXYZ(void) const;

    GX_FORCE_INLINE void                            setRotateXYZ(f32 x, f32 y, f32 z) { setRotateX(x); mulRotateY(y); mulRotateZ(z); }

    GX_FORCE_INLINE GxVector3                       getRotateXZY(void) const;

    GX_FORCE_INLINE void                            setRotateXZY(f32 x, f32 y, f32 z) { setRotateX(x); mulRotateZ(z); mulRotateY(y); }

    GX_FORCE_INLINE GxVector3                       getRotateYXZ(void) const;

    GX_FORCE_INLINE void                            setRotateYXZ(f32 x, f32 y, f32 z) { setRotateY(y); mulRotateX(x); mulRotateZ(z); }

    GX_FORCE_INLINE GxVector3                       getRotateYZX(void) const;

    GX_FORCE_INLINE void                            setRotateYZX(f32 x, f32 y, f32 z) { setRotateY(y); mulRotateZ(z); mulRotateX(x); }

    GX_FORCE_INLINE GxVector3                       getRotateZXY(void) const;

    GX_FORCE_INLINE void                            setRotateZXY(f32 x, f32 y, f32 z) { setRotateZ(z); mulRotateX(x); mulRotateY(y); }

    GX_FORCE_INLINE GxVector3                       getRotateZYX(void) const;

    GX_FORCE_INLINE void                            setRotateZYX(f32 x, f32 y, f32 z) { setRotateZ(z); mulRotateY(y); mulRotateX(x); }

    GX_FORCE_INLINE void                            setTranslate(const GxVector3& vector);

    GX_FORCE_INLINE void                            setTranslate(f32 x, f32 y, f32 z);

    GX_FORCE_INLINE const GxVector3&                getPosition(void) const { return *reinterpret_cast<const GxVector3*>(&_m[3][0]); }

    GX_FORCE_INLINE const GxVector3&                getXAxis(void) const { return *reinterpret_cast<const GxVector3*>(&_m[0][0]); }

    GX_FORCE_INLINE const GxVector3&                getYAxis(void) const { return *reinterpret_cast<const GxVector3*>(&_m[1][0]); }

    GX_FORCE_INLINE const GxVector3&                getZAxis(void) const { return *reinterpret_cast<const GxVector3*>(&_m[2][0]); }


    GX_FORCE_INLINE void                            setPosition(const GxVector3& position);

    GX_FORCE_INLINE void                            setPosition(f32 x, f32 y, f32 z);

    GX_FORCE_INLINE GxVector3                       getScale(void) const;

    GX_FORCE_INLINE void                            setScale(const GxVector3& vector);

    GX_FORCE_INLINE void                            setScale(f32 x, f32 y, f32 z);

    GX_FORCE_INLINE void                            setRotateAxis(const GxVector3& vector, f32 radian);

    GX_FORCE_INLINE void                            setRotate(const GxQuaternion& quaternion);

    GX_FORCE_INLINE const GxVector4&                getRow(u32 row) const;

    GX_FORCE_INLINE const f32*                      getRowPtr(u32 row) const;

    GX_FORCE_INLINE void                            setRow(u32 row, const GxVector4& vector);

    GX_FORCE_INLINE void                            setRow(u32 row, const GxVector3& vector);

    GX_FORCE_INLINE GxVector4                       getColumn(u32 column) const;

    GX_FORCE_INLINE void                            setColumn(u32 column, const GxVector4& vector);

    GX_FORCE_INLINE f32                             getValue(u32 row, u32 column) const;

    GX_FORCE_INLINE void                            setValue(u32 row, u32 column, f32 value);

    GX_FORCE_INLINE f32&                            getReference(u32 row, u32 column);

    GX_FORCE_INLINE const f32&                      getReference(u32 row, u32 column) const;

    void                                            setLookAtRH(const GxVector3& eyePosition, const GxVector3& atPosition, const GxVector3& up);

    void                                            setLookAtLH(const GxVector3& eyePosition, const GxVector3& atPosition, const GxVector3& up);

    GX_FORCE_INLINE f32                             getDeterminant(void) const;

    GX_FORCE_INLINE GxMatrixAffine                  getInverse(void) const;

    GX_FORCE_INLINE GxMatrixAffine                  getTranspose(void) const;

    GX_FORCE_INLINE GxMatrixAffine                  getNormalizeAxes(void) const;

    static GxMatrixAffine                           getMatrix(AXIS axis0, const GxVector3& vector0, AXIS axis1, const GxVector3& vector1);


    static GX_FORCE_INLINE const GxMatrixAffine&    getMulScalar(GxMatrixAffine& dst, const GxMatrixAffine& matrix, f32 scalar);

    static GX_FORCE_INLINE const GxMatrixAffine&    getDivScalar(GxMatrixAffine& dst, const GxMatrixAffine& matrix, f32 scalar);

    static GX_FORCE_INLINE const GxMatrixAffine&    getAddMatrix(GxMatrixAffine& dst, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1);

    static GX_FORCE_INLINE const GxMatrixAffine&    getMulMatrix(GxMatrixAffine& dst, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1);

    static GX_FORCE_INLINE const GxMatrixAffineGpu& getMulMatrix(GxMatrixAffineGpu& dst, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1);

    static GX_FORCE_INLINE const GxMatrixAffine&    getInverse(GxMatrixAffine& dst, const GxMatrixAffine& matrix);

    static GX_FORCE_INLINE const GxMatrixAffine&    getTranspose(GxMatrixAffine& dst, const GxMatrixAffine& matrix);

    static GX_FORCE_INLINE void getFastMulMatrix(GxMatrixAffine& dst, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1);

    static GX_FORCE_INLINE b32 isSimdAlignment(const GxMatrixAffine& matrix);


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

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


    GX_FORCE_INLINE const GxMatrixAffine&           mulScalar(f32 scalar);

    GX_FORCE_INLINE const GxMatrixAffine&           divScalar(f32 scalar);

    GX_FORCE_INLINE const GxMatrixAffine&           addMatrix(const GxMatrixAffine& matrix);

    GX_FORCE_INLINE const GxMatrixAffine&           mulMatrix(const GxMatrixAffine& matrix);

    GX_FORCE_INLINE const GxMatrixAffine&           mulRotateX(f32 radian);

    GX_FORCE_INLINE const GxMatrixAffine&           mulRotateY(f32 radian);

    GX_FORCE_INLINE const GxMatrixAffine&           mulRotateZ(f32 radian);

    GX_FORCE_INLINE const GxMatrixAffine&           mulQuaternionFront(const GxQuaternion& quaternion);

    GX_FORCE_INLINE const GxMatrixAffine&           mulQuaternionBack(const GxQuaternion& quaternion);

    GX_FORCE_INLINE void                            setScaleQuaternion( const GxVector3 &scale, const GxQuaternion& quaternion );

    GX_FORCE_INLINE const GxMatrixAffine&           mulTranslate(const GxVector3& vector);

    GX_FORCE_INLINE const GxMatrixAffine&           mulTranslate(f32 x, f32 y, f32 z);

    GX_FORCE_INLINE const GxMatrixAffine&           mulScale(const GxVector3& vector);

    GX_FORCE_INLINE const GxMatrixAffine&           mulScale(f32 x, f32 y, f32 z);

    GX_FORCE_INLINE const GxMatrixAffine&           inverse(void);

    GX_FORCE_INLINE const GxMatrixAffine&           transpose(void);

    GX_FORCE_INLINE void setZero(void);


#if GX_DEVELOP

    // 書き込み

    b32 write(GxStreamWriter& writer);

#endif //GX_DEVELOP

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

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

public:


#if defined(GX_USE_SSE2)

    union

    {

        struct

        {

            f32 _m11, _m12, _m13, _m14;

            f32 _m21, _m22, _m23, _m24;

            f32 _m31, _m32, _m33, _m34;

            f32 _m41, _m42, _m43, _m44;

        };

        f32 _m[4][4];

        __m128  _r[4];

    };

#else //GX_USE_SSE2

    f32         _m[4][4];

#endif // !GX_USE_SSE2


} GX_ALIGN16_END;


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

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


GX_ALIGN16_BEGIN struct GxMatrix44 : public GxStructBase

{

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

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

public:

    GX_RTTI_STRUCT(GxMatrix44)


    static const GxMatrix44 ZERO;

    static const GxMatrix44 IDENTITY;


    friend struct GxMatrixAffine;

    friend struct GxMatrix44Gpu;


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

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


    GxMatrix44(void) {}

    GX_INLINE GxMatrix44(INIT initType);

    GX_INLINE GxMatrix44(const GxQuaternion& quaternion, const GxVector3& position);

    GX_INLINE GxMatrix44(const GxQuaternion& quaternion);

    GX_INLINE GxMatrix44(const GxVector3& position);

    GX_INLINE GxMatrix44(f32 m00, f32 m01, f32 m02, f32 m03,

                        f32 m10, f32 m11, f32 m12, f32 m13,

                        f32 m20, f32 m21, f32 m22, f32 m23,

                        f32 m30, f32 m31, f32 m32, f32 m33);

    GX_INLINE GxMatrix44(const GxMatrixAffine& matrix);

    GX_INLINE GxMatrix44(const GxMatrix44& matrix);

    GX_FORCE_INLINE void initialize(const GxQuaternion& quaternion, const GxVector3& position);


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

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


    GX_FORCE_INLINE GxMatrix44& operator = (const GxMatrix44& matrix);

    GX_FORCE_INLINE GxMatrix44& operator *= (f32 scalar);

    GX_FORCE_INLINE GxMatrix44& operator /= (f32 scalar);

    GX_FORCE_INLINE GxMatrix44& operator += (const GxMatrix44& matrix);

    GX_FORCE_INLINE GxMatrix44& operator *= (const GxMatrix44& matrix);

    friend GX_FORCE_INLINE const GxMatrix44 operator * (const GxMatrix44& matrix, f32 scalar);

    friend GX_FORCE_INLINE const GxMatrix44 operator / (const GxMatrix44& matrix, f32 scalar);

    friend GX_FORCE_INLINE const GxMatrix44 operator + (const GxMatrix44& matrix0, const GxMatrix44& matrix1);

    friend GX_FORCE_INLINE const GxMatrix44 operator * (const GxMatrix44& matrix0, const GxMatrix44& matrix1);

    GX_FORCE_INLINE b32 operator == (const GxMatrix44& matrix);

    GX_FORCE_INLINE b32 operator != (const GxMatrix44& matrix);


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

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


    GX_FORCE_INLINE void                        setIdentity(void);

    GX_FORCE_INLINE void                        setRotateX(f32 sinValue, f32 cosValue);

    GX_FORCE_INLINE void                        setRotateX(f32 radian) { setRotateX(sinf(radian), cosf(radian)); }

    GX_FORCE_INLINE void                        setRotateY(f32 sinValue, f32 cosValue);

    GX_FORCE_INLINE void                        setRotateY(f32 radian) { setRotateY(sinf(radian), cosf(radian)); }

    GX_FORCE_INLINE void                        setRotateZ(f32 sinValue, f32 cosValue);

    GX_FORCE_INLINE void                        setRotateZ(f32 radian) { setRotateZ(sinf(radian), cosf(radian)); }

    GX_FORCE_INLINE GxVector3                   getRotateXYZ(void) const;

    GX_FORCE_INLINE void                        setRotateXYZ(f32 x, f32 y, f32 z) { setRotateX(x); mulRotateY(y); mulRotateZ(z); }

    GX_FORCE_INLINE GxVector3                   getRotateXZY(void) const;

    GX_FORCE_INLINE void                        setRotateXZY(f32 x, f32 y, f32 z) { setRotateX(x); mulRotateZ(z); mulRotateY(y); }

    GX_FORCE_INLINE GxVector3                   getRotateYXZ(void) const;

    GX_FORCE_INLINE void                        setRotateYXZ(f32 x, f32 y, f32 z) { setRotateY(y); mulRotateX(x); mulRotateZ(z); }

    GX_FORCE_INLINE GxVector3                   getRotateYZX(void) const;

    GX_FORCE_INLINE void                        setRotateYZX(f32 x, f32 y, f32 z) { setRotateY(y); mulRotateZ(z); mulRotateX(x); }

    GX_FORCE_INLINE GxVector3                   getRotateZXY(void) const;

    GX_FORCE_INLINE void                        setRotateZXY(f32 x, f32 y, f32 z) { setRotateZ(z); mulRotateX(x); mulRotateY(y); }

    GX_FORCE_INLINE GxVector3                   getRotateZYX(void) const;

    GX_FORCE_INLINE void                        setRotateZYX(f32 x, f32 y, f32 z) { setRotateZ(z); mulRotateY(y); mulRotateX(x); }

    GX_FORCE_INLINE void                        setTranslate(const GxVector3& vector);

    GX_FORCE_INLINE void                        setTranslate(f32 x, f32 y, f32 z);

    GX_FORCE_INLINE const GxVector3&            getPosition(void) const { return *reinterpret_cast<const GxVector3*>(&_m[3][0]); }

    GX_FORCE_INLINE void                        setPosition(const GxVector3& position);

    GX_FORCE_INLINE void                        setPosition(f32 x, f32 y, f32 z);

    GX_FORCE_INLINE void                        setScale(const GxVector3& vector);

    GX_FORCE_INLINE void                        setScale(f32 x, f32 y, f32 z);

    GX_FORCE_INLINE void                        setRotateAxis(const GxVector3& vector, f32 radian);

    GX_FORCE_INLINE void                        setRotate(const GxQuaternion& quaternion);

    GX_FORCE_INLINE const GxVector4&            getRow(u32 row) const;

    GX_FORCE_INLINE void                        setRow(u32 row, const GxVector4& vector);

    GX_FORCE_INLINE GxVector4                   getColumn(u32 column) const;

    GX_FORCE_INLINE void                        setColumn(u32 column, const GxVector4& vector);

    GX_FORCE_INLINE f32                         getValue(u32 row, u32 column) const;

    GX_FORCE_INLINE void                        setValue(u32 row, u32 column, f32 value);

    GX_FORCE_INLINE f32&                        getReference(u32 row, u32 column);

    GX_FORCE_INLINE const f32&                  getReference(u32 row, u32 column) const;

    void                                        setLookAtRH(const GxVector3& eyePosition,const GxVector3& atPosition,const GxVector3& up);

    void                                        setLookAtLH(const GxVector3& eyePosition,const GxVector3& atPosition,const GxVector3& up);

    void                                        setPerspectiveFovRH(f32 nearZ, f32 farZ, f32 fov, f32 aspect);

    void                                        setPerspectiveFovRH(f32 nearZ, f32 farZ, f32 fov, f32 aspect, const GxVector2& pixelOffset, const GxSize& viewportSize);

    void                                        setPerspectiveFovLH(f32 nearZ, f32 farZ, f32 fov, f32 aspect);

    void                                        setFrustumRH(f32 left, f32 right, f32 top, f32 bottom, f32 nearZ, f32 farZ);

    void                                        setFrustumLH(f32 left, f32 right, f32 top, f32 bottom, f32 nearZ, f32 farZ);

    void                                        setOrthoRH(f32 left, f32 right, f32 top, f32 bottom, f32 nearZ, f32 farZ);

    void                                        setOrthoRH(f32 left, f32 right, f32 top, f32 bottom, f32 nearZ, f32 farZ, const GxVector2& pixelOffset, const GxSize& viewportSize);

    void                                        setOrthoLH(f32 left, f32 right, f32 top, f32 bottom, f32 nearZ, f32 farZ);

    void                                        setOrthoLH(f32 left, f32 right, f32 top, f32 bottom, f32 nearZ, f32 farZ, const GxVector2& pixelOffset, const GxSize& viewportSize);

    GX_FORCE_INLINE f32                         getDeterminant(void) const;

    GX_FORCE_INLINE GxMatrix44                  getInverse(void) const;

    GX_FORCE_INLINE GxMatrix44                  getTranspose(void) const;

    GX_FORCE_INLINE GxMatrix44                  getNormalizeAxes(void) const;

    static GxMatrix44                           getMatrix(AXIS axis0, const GxVector3& vector0, AXIS axis1, const GxVector3& vector1);


    static GX_FORCE_INLINE const GxMatrix44&    getMulScalar(GxMatrix44& dst, const GxMatrix44& matrix, f32 scalar);

    static GX_FORCE_INLINE const GxMatrix44&    getDivScalar(GxMatrix44& dst, const GxMatrix44& matrix, f32 scalar);

    static GX_FORCE_INLINE const GxMatrix44&    getAddMatrix(GxMatrix44& dst, const GxMatrix44& matrix0, const GxMatrix44& matrix1);

    static GX_FORCE_INLINE const GxMatrix44&    getMulMatrix(GxMatrix44& dst, const GxMatrix44& matrix0, const GxMatrix44& matrix1);

    static GX_FORCE_INLINE const GxMatrix44&    getInverse(GxMatrix44& dst, const GxMatrix44& matrix);

    static GX_FORCE_INLINE const GxMatrix44&    getTranspose(GxMatrix44& dst, const GxMatrix44& matrix);


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

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


    GX_FORCE_INLINE const GxMatrix44&           mulScalar(f32 scalar);

    GX_FORCE_INLINE const GxMatrix44&           divScalar(f32 scalar);

    GX_FORCE_INLINE const GxMatrix44&           addMatrix(const GxMatrix44& matrix);

    GX_FORCE_INLINE const GxMatrix44&           mulMatrix(const GxMatrix44& matrix);

    GX_FORCE_INLINE const GxMatrix44&           mulRotateX(f32 radian);

    GX_FORCE_INLINE const GxMatrix44&           mulRotateY(f32 radian);

    GX_FORCE_INLINE const GxMatrix44&           mulRotateZ(f32 radian);

    GX_FORCE_INLINE const GxMatrix44&           mulQuaternionFront(const GxQuaternion& quaternion);

    GX_FORCE_INLINE const GxMatrix44&           mulQuaternionBack(const GxQuaternion& quaternion);

    GX_FORCE_INLINE const GxMatrix44&           mulTranslate(const GxVector3& vector);

    GX_FORCE_INLINE const GxMatrix44&           mulTranslate(f32 x, f32 y, f32 z);

    GX_FORCE_INLINE const GxMatrix44&           mulScale(const GxVector3& vector);

    GX_FORCE_INLINE const GxMatrix44&           mulScale(f32 x, f32 y, f32 z);

    GX_FORCE_INLINE const GxMatrix44&           inverse(void);

    GX_FORCE_INLINE const GxMatrix44&           transpose(void);

    GX_FORCE_INLINE void setZero(void);


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

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


public:

#if defined(GX_USE_SSE2)

    union

    {

        struct

        {

            f32 _m11, _m12, _m13, _m14;

            f32 _m21, _m22, _m23, _m24;

            f32 _m31, _m32, _m33, _m34;

            f32 _m41, _m42, _m43, _m44;

        };

        f32 _m[4][4];

        __m128  _r[4];

    };

#else //GX_USE_SSE2

    f32         _m[4][4];

#endif // !GX_USE_SSE2


} GX_ALIGN16_END;


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

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


GX_ALIGN16_BEGIN struct GxMatrixAffineGpu

{

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

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


    friend struct GxMatrixAffine;


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

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


    GxMatrixAffineGpu(void) {}

    GX_INLINE GxMatrixAffineGpu(const GxMatrixAffine& matrix);

    GX_INLINE GxMatrixAffineGpu(f32 m00, f32 m01, f32 m02, f32 m03,

                                f32 m10, f32 m11, f32 m12, f32 m13,

                                f32 m20, f32 m21, f32 m22, f32 m23);

    GX_INLINE GxMatrixAffineGpu(const GxMatrixAffineGpu& matrix);


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

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


public:

    f32         _m[3][4];


} GX_ALIGN16_END;


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

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


GX_ALIGN16_BEGIN struct GxMatrix44Gpu

{

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

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


    GxMatrix44Gpu(void) {}

    GX_INLINE GxMatrix44Gpu(const GxMatrix44& matrix);

    GX_INLINE GxMatrix44Gpu(f32 m00, f32 m01, f32 m02, f32 m03,

                            f32 m10, f32 m11, f32 m12, f32 m13,

                            f32 m20, f32 m21, f32 m22, f32 m23,

                            f32 m30, f32 m31, f32 m32, f32 m33);

    GX_INLINE GxMatrix44Gpu(const GxMatrix44Gpu& matrix);


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

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


private:

    f32         _m[4][4];


} GX_ALIGN16_END;


GX_CORE_NAMESPACE_END()

INIT
INIT
初期化タイプ
Definition GxMath.h:53

AXIS
AXIS
軸方向
Definition GxMath.h:37

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

GxColorHDR
色(HDR)
Definition GxColor.h:241

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

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

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

GxMatrix22
2×2行列(行優先)
Definition GxMatrix.h:37

GxMatrix22::operator+
friend GX_FORCE_INLINE const GxMatrix22 operator+(const GxMatrix22 &matrix0, const GxMatrix22 &matrix1)
行列加算
Definition GxMatrix.inl:139

GxMatrix22::operator!=
GX_FORCE_INLINE b32 operator!=(const GxMatrix22 &matrix)
不一致
Definition GxMatrix.inl:173

GxMatrix22::getMulScalar
static GX_FORCE_INLINE const GxMatrix22 & getMulScalar(GxMatrix22 &dst, const GxMatrix22 &matrix, f32 scalar)
スカラ乗算を取得
Definition GxMatrix.inl:327

GxMatrix22::getDivScalar
static GX_FORCE_INLINE const GxMatrix22 & getDivScalar(GxMatrix22 &dst, const GxMatrix22 &matrix, f32 scalar)
スカラ除算を取得
Definition GxMatrix.inl:345

GxMatrix22::addMatrix
GX_FORCE_INLINE const GxMatrix22 & addMatrix(const GxMatrix22 &matrix)
行列加算
Definition GxMatrix.inl:488

GxMatrix22::mulScalar
GX_FORCE_INLINE const GxMatrix22 & mulScalar(f32 scalar)
スカラ乗算
Definition GxMatrix.inl:454

GxMatrix22::GxMatrix22
GxMatrix22(void)
コンストラクタ
Definition GxMatrix.h:57

GxMatrix22::getDeterminant
GX_FORCE_INLINE f32 getDeterminant(void) const
行列式の値を取得
Definition GxMatrix.inl:295

GxMatrix22::getTranspose
GX_FORCE_INLINE GxMatrix22 getTranspose(void) const
転置行列を取得
Definition GxMatrix.inl:314

GxMatrix22::getColumn
GX_FORCE_INLINE GxVector2 getColumn(u32 column) const
列を取得
Definition GxMatrix.inl:219

GxMatrix22::ZERO
static const GxMatrix22 ZERO
0行列
Definition GxMatrix.h:46

GxMatrix22::operator==
GX_FORCE_INLINE b32 operator==(const GxMatrix22 &matrix)
一致
Definition GxMatrix.inl:162

GxMatrix22::divScalar
GX_FORCE_INLINE const GxMatrix22 & divScalar(f32 scalar)
スカラ除算
Definition GxMatrix.inl:470

GxMatrix22::operator*=
GX_FORCE_INLINE GxMatrix22 & operator*=(f32 scalar)
スカラ乗算代入
Definition GxMatrix.inl:66

GxMatrix22::getMulMatrix
static GX_FORCE_INLINE const GxMatrix22 & getMulMatrix(GxMatrix22 &dst, const GxMatrix22 &matrix0, const GxMatrix22 &matrix1)
行列乗算を取得
Definition GxMatrix.inl:383

GxMatrix22::_m
f32 _m[2][4]
値
Definition GxMatrix.h:160

GxMatrix22::operator+=
GX_FORCE_INLINE GxMatrix22 & operator+=(const GxMatrix22 &matrix)
行列加算代入
Definition GxMatrix.inl:90

GxMatrix22::mulMatrix
GX_FORCE_INLINE const GxMatrix22 & mulMatrix(const GxMatrix22 &matrix)
行列乗算
Definition GxMatrix.inl:504

GxMatrix22::operator/=
GX_FORCE_INLINE GxMatrix22 & operator/=(f32 scalar)
スカラ除算代入
Definition GxMatrix.inl:78

GxMatrix22::setValue
GX_FORCE_INLINE void setValue(u32 row, u32 column, f32 value)
値を設定
Definition GxMatrix.inl:258

GxMatrix22::transpose
GX_FORCE_INLINE const GxMatrix22 & transpose(void)
転置する
Definition GxMatrix.inl:548

GxMatrix22::setColumn
GX_FORCE_INLINE void setColumn(u32 column, const GxVector2 &vector)
列を設定
Definition GxMatrix.inl:231

GxMatrix22::operator=
GX_FORCE_INLINE GxMatrix22 & operator=(const GxMatrix22 &matrix)
代入
Definition GxMatrix.inl:50

GxMatrix22::getRow
GX_FORCE_INLINE const GxVector2 & getRow(u32 row) const
行を取得
Definition GxMatrix.inl:195

GxMatrix22::operator/
friend GX_FORCE_INLINE const GxMatrix22 operator/(const GxMatrix22 &matrix, f32 scalar)
スカラ除算
Definition GxMatrix.inl:127

GxMatrix22::getValue
GX_FORCE_INLINE f32 getValue(u32 row, u32 column) const
値を取得
Definition GxMatrix.inl:244

GxMatrix22::getInverse
GX_FORCE_INLINE GxMatrix22 getInverse(void) const
逆行列を取得
Definition GxMatrix.inl:304

GxMatrix22::operator*
friend GX_FORCE_INLINE const GxMatrix22 operator*(const GxMatrix22 &matrix, f32 scalar)
スカラ乗算
Definition GxMatrix.inl:115

GxMatrix22::getAddMatrix
static GX_FORCE_INLINE const GxMatrix22 & getAddMatrix(GxMatrix22 &dst, const GxMatrix22 &matrix0, const GxMatrix22 &matrix1)
行列加算を取得
Definition GxMatrix.inl:365

GxMatrix22::IDENTITY
static const GxMatrix22 IDENTITY
単位行列
Definition GxMatrix.h:48

GxMatrix22::inverse
GX_FORCE_INLINE const GxMatrix22 & inverse(void)
逆行列にする
Definition GxMatrix.inl:525

GxMatrix22::getReference
GX_FORCE_INLINE f32 & getReference(u32 row, u32 column)
参照を取得
Definition GxMatrix.inl:271

GxMatrix22::setRow
GX_FORCE_INLINE void setRow(u32 row, const GxVector2 &vector)
行を設定
Definition GxMatrix.inl:207

GxMatrix22::setIdentity
GX_FORCE_INLINE void setIdentity(void)
単位行列に設定
Definition GxMatrix.inl:181

GxMatrix33
3×3行列(行優先)
Definition GxMatrix.h:169

GxMatrix33::mulScalar
GX_FORCE_INLINE const GxMatrix33 & mulScalar(f32 scalar)
スカラ乗算
Definition GxMatrix.inl:1201

GxMatrix33::setRow
GX_FORCE_INLINE void setRow(u32 row, const GxVector3 &vector)
行を設定
Definition GxMatrix.inl:895

GxMatrix33::getReference
GX_FORCE_INLINE f32 & getReference(u32 row, u32 column)
参照を取得
Definition GxMatrix.inl:960

GxMatrix33::getMulMatrix
static GX_FORCE_INLINE const GxMatrix33 & getMulMatrix(GxMatrix33 &dst, const GxMatrix33 &matrix0, const GxMatrix33 &matrix1)
行列乗算を取得
Definition GxMatrix.inl:1093

GxMatrix33::operator=
GX_FORCE_INLINE GxMatrix33 & operator=(const GxMatrix33 &matrix)
代入
Definition GxMatrix.inl:592

GxMatrix33::mulRotate
GX_FORCE_INLINE const GxMatrix33 & mulRotate(f32 radian)
回転乗算
Definition GxMatrix.inl:1303

GxMatrix33::operator+=
GX_FORCE_INLINE GxMatrix33 & operator+=(const GxMatrix33 &matrix)
行列加算代入
Definition GxMatrix.inl:638

GxMatrix33::operator+
friend GX_FORCE_INLINE const GxMatrix33 operator+(const GxMatrix33 &matrix0, const GxMatrix44 &matrix1)
行列加算

GxMatrix33::operator*
friend GX_FORCE_INLINE const GxMatrix33 operator*(const GxMatrix33 &matrix, f32 scalar)
スカラ乗算
Definition GxMatrix.inl:663

GxMatrix33::setTranslate
GX_FORCE_INLINE void setTranslate(const GxVector2 &vector)
平行移動行列を設定
Definition GxMatrix.inl:779

GxMatrix33::setRotate
GX_FORCE_INLINE void setRotate(f32 radian)
回転行列を設定
Definition GxMatrix.h:235

GxMatrix33::getColumn
GX_FORCE_INLINE GxVector3 getColumn(u32 column) const
列を取得
Definition GxMatrix.inl:908

GxMatrix33::getMulScalar
static GX_FORCE_INLINE const GxMatrix33 & getMulScalar(GxMatrix33 &dst, const GxMatrix33 &matrix, f32 scalar)
スカラ乗算を取得
Definition GxMatrix.inl:1019

GxMatrix33::operator/
friend GX_FORCE_INLINE const GxMatrix33 operator/(const GxMatrix33 &matrix, f32 scalar)
スカラ除算
Definition GxMatrix.inl:677

GxMatrix33::getRow
GX_FORCE_INLINE const GxVector3 & getRow(u32 row) const
行を取得
Definition GxMatrix.inl:884

GxMatrix33::mulTranslate
GX_FORCE_INLINE const GxMatrix33 & mulTranslate(const GxVector2 &vector)
平行移動乗算
Definition GxMatrix.inl:1317

GxMatrix33::operator*=
GX_FORCE_INLINE GxMatrix33 & operator*=(f32 scalar)
スカラ乗算代入
Definition GxMatrix.inl:614

GxMatrix33::inverse
GX_FORCE_INLINE const GxMatrix33 & inverse(void)
逆行列にする
Definition GxMatrix.inl:1406

GxMatrix33::operator/=
GX_FORCE_INLINE GxMatrix33 & operator/=(f32 scalar)
スカラ除算代入
Definition GxMatrix.inl:626

GxMatrix33::getPosition
GX_FORCE_INLINE const GxVector2 & getPosition(void) const
平行移動量を取得
Definition GxMatrix.h:241

GxMatrix33::setPosition
GX_FORCE_INLINE void setPosition(const GxVector2 &position)
平行移動量のみを設定
Definition GxMatrix.inl:820

GxMatrix33::_m
f32 _m[3][4]
値
Definition GxMatrix.h:321

GxMatrix33::setColumn
GX_FORCE_INLINE void setColumn(u32 column, const GxVector3 &vector)
列を設定
Definition GxMatrix.inl:919

GxMatrix33::getInverse
GX_FORCE_INLINE GxMatrix33 getInverse(void) const
逆行列を取得
Definition GxMatrix.inl:995

GxMatrix33::setRotate
GX_FORCE_INLINE void setRotate(f32 sinValue, f32 cosValue)
回転行列を設定
Definition GxMatrix.inl:759

GxMatrix33::divScalar
GX_FORCE_INLINE const GxMatrix33 & divScalar(f32 scalar)
スカラ除算
Definition GxMatrix.inl:1223

GxMatrix33::operator!=
GX_FORCE_INLINE b32 operator!=(const GxMatrix33 &matrix)
不一致
Definition GxMatrix.inl:730

GxMatrix33::GxMatrix33
GxMatrix33(void)
コンストラクタ
Definition GxMatrix.h:189

GxMatrix33::IDENTITY
static const GxMatrix33 IDENTITY
単位行列
Definition GxMatrix.h:180

GxMatrix33::getValue
GX_FORCE_INLINE f32 getValue(u32 row, u32 column) const
値を取得
Definition GxMatrix.inl:933

GxMatrix33::getDeterminant
GX_FORCE_INLINE f32 getDeterminant(void) const
行列式の値を取得
Definition GxMatrix.inl:984

GxMatrix33::setIdentity
GX_FORCE_INLINE void setIdentity(void)
単位行列に設定
Definition GxMatrix.inl:738

GxMatrix33::ZERO
static const GxMatrix33 ZERO
0行列
Definition GxMatrix.h:178

GxMatrix33::addMatrix
GX_FORCE_INLINE const GxMatrix33 & addMatrix(const GxMatrix33 &matrix)
行列加算
Definition GxMatrix.inl:1247

GxMatrix33::setValue
GX_FORCE_INLINE void setValue(u32 row, u32 column, f32 value)
値を設定
Definition GxMatrix.inl:947

GxMatrix33::getAddMatrix
static GX_FORCE_INLINE const GxMatrix33 & getAddMatrix(GxMatrix33 &dst, const GxMatrix33 &matrix0, const GxMatrix33 &matrix1)
行列加算を取得
Definition GxMatrix.inl:1069

GxMatrix33::operator==
GX_FORCE_INLINE b32 operator==(const GxMatrix33 &matrix)
一致
Definition GxMatrix.inl:718

GxMatrix33::getTranspose
GX_FORCE_INLINE GxMatrix33 getTranspose(void) const
転置行列を取得
Definition GxMatrix.inl:1005

GxMatrix33::transpose
GX_FORCE_INLINE const GxMatrix33 & transpose(void)
転置する
Definition GxMatrix.inl:1441

GxMatrix33::getDivScalar
static GX_FORCE_INLINE const GxMatrix33 & getDivScalar(GxMatrix33 &dst, const GxMatrix33 &matrix, f32 scalar)
スカラ除算を取得
Definition GxMatrix.inl:1043

GxMatrix33::setScale
GX_FORCE_INLINE void setScale(const GxVector2 &vector)
スケール行列を設定
Definition GxMatrix.inl:843

GxMatrix33::mulMatrix
GX_FORCE_INLINE const GxMatrix33 & mulMatrix(const GxMatrix33 &matrix)
行列乗算
Definition GxMatrix.inl:1269

GxMatrix33::mulScale
GX_FORCE_INLINE const GxMatrix33 & mulScale(const GxVector2 &vector)
スケール乗算
Definition GxMatrix.inl:1356

GxMatrix44Gpu
4×4行列(GPU用)
Definition GxMatrix.h:915

GxMatrix44Gpu::GxMatrix44Gpu
GxMatrix44Gpu(void)
デフォルトコンストラクタ
Definition GxMatrix.h:922

GxMatrix44
4×4行列(行優先)
Definition GxMatrix.h:607

GxMatrix44::setRotateY
GX_FORCE_INLINE void setRotateY(f32 radian)
回転行列を設定(Y軸回転)
Definition GxMatrix.h:695

GxMatrix44::setRotateYXZ
GX_FORCE_INLINE void setRotateYXZ(f32 x, f32 y, f32 z)
回転行列を設定(YXZ軸回転)
Definition GxMatrix.h:711

GxMatrix44::operator==
GX_FORCE_INLINE b32 operator==(const GxMatrix44 &matrix)
一致
Definition GxMatrix.inl:3697

GxMatrix44::getRotateZXY
GX_FORCE_INLINE GxVector3 getRotateZXY(void) const
ZXY軸回転角を取得
Definition GxMatrix.inl:3961

GxMatrix44::getInverse
GX_FORCE_INLINE GxMatrix44 getInverse(void) const
逆行列を取得
Definition GxMatrix.inl:4347

GxMatrix44::setLookAtLH
void setLookAtLH(const GxVector3 &eyePosition, const GxVector3 &atPosition, const GxVector3 &up)
左手座標系・視点行列を設定
Definition GxMatrix.cpp:297

GxMatrix44::IDENTITY
static const GxMatrix44 IDENTITY
単位行列
Definition GxMatrix.h:618

GxMatrix44::mulTranslate
GX_FORCE_INLINE const GxMatrix44 & mulTranslate(const GxVector3 &vector)
平行移動乗算
Definition GxMatrix.inl:4890

GxMatrix44::getRow
GX_FORCE_INLINE const GxVector4 & getRow(u32 row) const
行を取得
Definition GxMatrix.inl:4232

GxMatrix44::setRotate
GX_FORCE_INLINE void setRotate(const GxQuaternion &quaternion)
回転行列を設定
Definition GxMatrix.inl:4204

GxMatrix44::setRotateAxis
GX_FORCE_INLINE void setRotateAxis(const GxVector3 &vector, f32 radian)
回転行列を設定
Definition GxMatrix.inl:4173

GxMatrix44::mulRotateY
GX_FORCE_INLINE const GxMatrix44 & mulRotateY(f32 radian)
Y軸回転乗算
Definition GxMatrix.inl:4790

GxMatrix44::initialize
GX_FORCE_INLINE void initialize(const GxQuaternion &quaternion, const GxVector3 &position)
初期化
Definition GxMatrix.inl:3560

GxMatrix44::GxMatrix44
GxMatrix44(void)
デフォルトコンストラクタ(要素は初期化されない)
Definition GxMatrix.h:630

GxMatrix44::getMulScalar
static GX_FORCE_INLINE const GxMatrix44 & getMulScalar(GxMatrix44 &dst, const GxMatrix44 &matrix, f32 scalar)
スカラ乗算を取得
Definition GxMatrix.inl:4402

GxMatrix44::mulQuaternionFront
GX_FORCE_INLINE const GxMatrix44 & mulQuaternionFront(const GxQuaternion &quaternion)
クォータニオンによる回転乗算(前から乗算)
Definition GxMatrix.inl:4818

GxMatrix44::mulMatrix
GX_FORCE_INLINE const GxMatrix44 & mulMatrix(const GxMatrix44 &matrix)
行列乗算
Definition GxMatrix.inl:4765

GxMatrix44::setRotateZ
GX_FORCE_INLINE void setRotateZ(f32 sinValue, f32 cosValue)
回転行列を設定(Z軸回転)
Definition GxMatrix.inl:3805

GxMatrix44::getRotateXZY
GX_FORCE_INLINE GxVector3 getRotateXZY(void) const
XZY軸回転角を取得
Definition GxMatrix.inl:3865

GxMatrix44::setPerspectiveFovRH
void setPerspectiveFovRH(f32 nearZ, f32 farZ, f32 fov, f32 aspect)
右手座標系・射影変換行列を設定
Definition GxMatrix.cpp:338

GxMatrix44::setLookAtRH
void setLookAtRH(const GxVector3 &eyePosition, const GxVector3 &atPosition, const GxVector3 &up)
右手座標系・視点行列を設定
Definition GxMatrix.cpp:257

GxMatrix44::getDivScalar
static GX_FORCE_INLINE const GxMatrix44 & getDivScalar(GxMatrix44 &dst, const GxMatrix44 &matrix, f32 scalar)
スカラ除算を取得
Definition GxMatrix.inl:4434

GxMatrix44::operator/=
GX_FORCE_INLINE GxMatrix44 & operator/=(f32 scalar)
スカラ除算代入
Definition GxMatrix.inl:3613

GxMatrix44::operator!=
GX_FORCE_INLINE b32 operator!=(const GxMatrix44 &matrix)
不一致
Definition GxMatrix.inl:3710

GxMatrix44::setFrustumRH
void setFrustumRH(f32 left, f32 right, f32 top, f32 bottom, f32 nearZ, f32 farZ)
右手座標系・射影変換行列を設定
Definition GxMatrix.cpp:403

GxMatrix44::operator*=
GX_FORCE_INLINE GxMatrix44 & operator*=(f32 scalar)
スカラ乗算代入
Definition GxMatrix.inl:3601

GxMatrix44::setRotateZXY
GX_FORCE_INLINE void setRotateZXY(f32 x, f32 y, f32 z)
回転行列を設定(ZXY軸回転)
Definition GxMatrix.h:719

GxMatrix44::setTranslate
GX_FORCE_INLINE void setTranslate(const GxVector3 &vector)
平行移動行列を設定
Definition GxMatrix.inl:4028

GxMatrix44::operator*
friend GX_FORCE_INLINE const GxMatrix44 operator*(const GxMatrix44 &matrix, f32 scalar)
スカラ乗算
Definition GxMatrix.inl:3650

GxMatrix44::mulRotateZ
GX_FORCE_INLINE const GxMatrix44 & mulRotateZ(f32 radian)
Z軸回転乗算
Definition GxMatrix.inl:4804

GxMatrix44::getColumn
GX_FORCE_INLINE GxVector4 getColumn(u32 column) const
列を取得
Definition GxMatrix.inl:4257

GxMatrix44::divScalar
GX_FORCE_INLINE const GxMatrix44 & divScalar(f32 scalar)
スカラ除算
Definition GxMatrix.inl:4703

GxMatrix44::getRotateYXZ
GX_FORCE_INLINE GxVector3 getRotateYXZ(void) const
YXZ軸回転角を取得
Definition GxMatrix.inl:3897

GxMatrix44::setZero
GX_FORCE_INLINE void setZero(void)
0を設定
Definition GxMatrix.inl:5120

GxMatrix44::getReference
GX_FORCE_INLINE f32 & getReference(u32 row, u32 column)
参照を取得
Definition GxMatrix.inl:4311

GxMatrix44::getNormalizeAxes
GX_FORCE_INLINE GxMatrix44 getNormalizeAxes(void) const
位置以外の各軸を正規化したものを取得
Definition GxMatrix.inl:4369

GxMatrix44::operator+
friend GX_FORCE_INLINE const GxMatrix44 operator+(const GxMatrix44 &matrix0, const GxMatrix44 &matrix1)
行列加算
Definition GxMatrix.inl:3674

GxMatrix44::setRotateZ
GX_FORCE_INLINE void setRotateZ(f32 radian)
回転行列を設定(Z軸回転)
Definition GxMatrix.h:699

GxMatrix44::getTranspose
GX_FORCE_INLINE GxMatrix44 getTranspose(void) const
転置行列を取得
Definition GxMatrix.inl:4357

GxMatrix44::inverse
GX_FORCE_INLINE const GxMatrix44 & inverse(void)
逆行列を計算する
Definition GxMatrix.inl:5021

GxMatrix44::getRotateYZX
GX_FORCE_INLINE GxVector3 getRotateYZX(void) const
YZX軸回転角を取得
Definition GxMatrix.inl:3929

GxMatrix44::mulScale
GX_FORCE_INLINE const GxMatrix44 & mulScale(const GxVector3 &vector)
スケール乗算
Definition GxMatrix.inl:4956

GxMatrix44::setRotateYZX
GX_FORCE_INLINE void setRotateYZX(f32 x, f32 y, f32 z)
回転行列を設定(YZX軸回転)
Definition GxMatrix.h:715

GxMatrix44::operator/
friend GX_FORCE_INLINE const GxMatrix44 operator/(const GxMatrix44 &matrix, f32 scalar)
スカラ除算
Definition GxMatrix.inl:3662

GxMatrix44::setRow
GX_FORCE_INLINE void setRow(u32 row, const GxVector4 &vector)
行を設定
Definition GxMatrix.inl:4243

GxMatrix44::getDeterminant
GX_FORCE_INLINE f32 getDeterminant(void) const
行列式の値を取得
Definition GxMatrix.inl:4335

GxMatrix44::getPosition
GX_FORCE_INLINE const GxVector3 & getPosition(void) const
平行移動量を取得
Definition GxMatrix.h:729

GxMatrix44::getValue
GX_FORCE_INLINE f32 getValue(u32 row, u32 column) const
値を取得
Definition GxMatrix.inl:4284

GxMatrix44::setFrustumLH
void setFrustumLH(f32 left, f32 right, f32 top, f32 bottom, f32 nearZ, f32 farZ)
左手座標系・射影変換行列を設定
Definition GxMatrix.cpp:428

GxMatrix44::transpose
GX_FORCE_INLINE const GxMatrix44 & transpose(void)
転置する
Definition GxMatrix.inl:5072

GxMatrix44::setColumn
GX_FORCE_INLINE void setColumn(u32 column, const GxVector4 &vector)
列を設定
Definition GxMatrix.inl:4269

GxMatrix44::setIdentity
GX_FORCE_INLINE void setIdentity(void)
単位行列に設定
Definition GxMatrix.inl:3718

GxMatrix44::_m
f32 _m[4][4]
値
Definition GxMatrix.h:864

GxMatrix44::setRotateXYZ
GX_FORCE_INLINE void setRotateXYZ(f32 x, f32 y, f32 z)
回転行列を設定(XYZ軸回転)
Definition GxMatrix.h:703

GxMatrix44::setValue
GX_FORCE_INLINE void setValue(u32 row, u32 column, f32 value)
値を設定
Definition GxMatrix.inl:4298

GxMatrix44::mulQuaternionBack
GX_FORCE_INLINE const GxMatrix44 & mulQuaternionBack(const GxQuaternion &quaternion)
クォータニオンによる回転乗算(後ろから乗算)
Definition GxMatrix.inl:4831

GxMatrix44::getAddMatrix
static GX_FORCE_INLINE const GxMatrix44 & getAddMatrix(GxMatrix44 &dst, const GxMatrix44 &matrix0, const GxMatrix44 &matrix1)
行列加算を取得
Definition GxMatrix.inl:4468

GxMatrix44::setPerspectiveFovLH
void setPerspectiveFovLH(f32 nearZ, f32 farZ, f32 fov, f32 aspect)
左手座標系・射影変換行列を設定
Definition GxMatrix.cpp:378

GxMatrix44::setRotateY
GX_FORCE_INLINE void setRotateY(f32 sinValue, f32 cosValue)
回転行列を設定(Y軸回転)
Definition GxMatrix.inl:3776

GxMatrix44::getRotateXYZ
GX_FORCE_INLINE GxVector3 getRotateXYZ(void) const
XYZ軸回転角を取得
Definition GxMatrix.inl:3832

GxMatrix44::setRotateZYX
GX_FORCE_INLINE void setRotateZYX(f32 x, f32 y, f32 z)
回転行列を設定(ZYX軸回転)
Definition GxMatrix.h:723

GxMatrix44::setOrthoRH
void setOrthoRH(f32 left, f32 right, f32 top, f32 bottom, f32 nearZ, f32 farZ)
右手座標系・正射影変換行列を設定
Definition GxMatrix.cpp:453

GxMatrix44::operator+=
GX_FORCE_INLINE GxMatrix44 & operator+=(const GxMatrix44 &matrix)
行列加算代入
Definition GxMatrix.inl:3625

GxMatrix44::mulScalar
GX_FORCE_INLINE const GxMatrix44 & mulScalar(f32 scalar)
スカラ乗算
Definition GxMatrix.inl:4673

GxMatrix44::setRotateX
GX_FORCE_INLINE void setRotateX(f32 sinValue, f32 cosValue)
回転行列を設定(X軸回転)
Definition GxMatrix.inl:3747

GxMatrix44::operator=
GX_FORCE_INLINE GxMatrix44 & operator=(const GxMatrix44 &matrix)
代入
Definition GxMatrix.inl:3571

GxMatrix44::setScale
GX_FORCE_INLINE void setScale(const GxVector3 &vector)
スケール行列を設定
Definition GxMatrix.inl:4114

GxMatrix44::getMatrix
static GxMatrix44 getMatrix(AXIS axis0, const GxVector3 &vector0, AXIS axis1, const GxVector3 &vector1)
２つの軸とベクトルから行列を取得
Definition GxMatrix.cpp:564

GxMatrix44::mulRotateX
GX_FORCE_INLINE const GxMatrix44 & mulRotateX(f32 radian)
X軸回転乗算
Definition GxMatrix.inl:4776

GxMatrix44::setRotateXZY
GX_FORCE_INLINE void setRotateXZY(f32 x, f32 y, f32 z)
回転行列を設定(XZY軸回転)
Definition GxMatrix.h:707

GxMatrix44::addMatrix
GX_FORCE_INLINE const GxMatrix44 & addMatrix(const GxMatrix44 &matrix)
行列加算
Definition GxMatrix.inl:4735

GxMatrix44::ZERO
static const GxMatrix44 ZERO
0行列
Definition GxMatrix.h:616

GxMatrix44::setOrthoLH
void setOrthoLH(f32 left, f32 right, f32 top, f32 bottom, f32 nearZ, f32 farZ)
左手座標系・正射影変換行列を設定
Definition GxMatrix.cpp:509

GxMatrix44::getMulMatrix
static GX_FORCE_INLINE const GxMatrix44 & getMulMatrix(GxMatrix44 &dst, const GxMatrix44 &matrix0, const GxMatrix44 &matrix1)
行列乗算を取得
Definition GxMatrix.inl:4500

GxMatrix44::setRotateX
GX_FORCE_INLINE void setRotateX(f32 radian)
回転行列を設定(X軸回転)
Definition GxMatrix.h:691

GxMatrix44::setPosition
GX_FORCE_INLINE void setPosition(const GxVector3 &position)
平行移動量のみを設定
Definition GxMatrix.inl:4086

GxMatrix44::getRotateZYX
GX_FORCE_INLINE GxVector3 getRotateZYX(void) const
ZYX軸回転角を取得
Definition GxMatrix.inl:3994

GxMatrixAffineGpu
アフィン変換行列(GPU用)
Definition GxMatrix.h:874

GxMatrixAffineGpu::_m
f32 _m[3][4]
値
Definition GxMatrix.h:906

GxMatrixAffineGpu::GxMatrixAffineGpu
GxMatrixAffineGpu(void)
デフォルトコンストラクタ
Definition GxMatrix.h:889

GxMatrixAffine
アフィン変換行列(行優先)
Definition GxMatrix.h:330

GxMatrixAffine::ZERO
static const GxMatrixAffine ZERO
0行列
Definition GxMatrix.h:339

GxMatrixAffine::setRotateZYX
GX_FORCE_INLINE void setRotateZYX(f32 x, f32 y, f32 z)
回転行列を設定(ZYX軸回転)
Definition GxMatrix.h:448

GxMatrixAffine::getZAxis
GX_FORCE_INLINE const GxVector3 & getZAxis(void) const
平行移動量を取得
Definition GxMatrix.h:460

GxMatrixAffine::setRotateZ
GX_FORCE_INLINE void setRotateZ(f32 radian)
回転行列を設定(Z軸回転)
Definition GxMatrix.h:424

GxMatrixAffine::setRotateXYZ
GX_FORCE_INLINE void setRotateXYZ(f32 x, f32 y, f32 z)
回転行列を設定(XYZ軸回転)
Definition GxMatrix.h:428

GxMatrixAffine::setZero
GX_FORCE_INLINE void setZero(void)
0を設定
Definition GxMatrix.inl:1619

GxMatrixAffine::getInverse
GX_FORCE_INLINE GxMatrixAffine getInverse(void) const
逆行列を取得
Definition GxMatrix.inl:2430

GxMatrixAffine::_m
f32 _m[4][4]
値
Definition GxMatrix.h:597

GxMatrixAffine::mulRotateY
GX_FORCE_INLINE const GxMatrixAffine & mulRotateY(f32 radian)
Y軸回転乗算
Definition GxMatrix.inl:3045

GxMatrixAffine::setRotateZXY
GX_FORCE_INLINE void setRotateZXY(f32 x, f32 y, f32 z)
回転行列を設定(ZXY軸回転)
Definition GxMatrix.h:444

GxMatrixAffine::IDENTITY
static const GxMatrixAffine IDENTITY
単位行列
Definition GxMatrix.h:341

GxMatrixAffine::operator!=
GX_FORCE_INLINE b32 operator!=(const GxMatrixAffine &matrix)
不一致
Definition GxMatrix.inl:1789

GxMatrixAffine::getRow
GX_FORCE_INLINE const GxVector4 & getRow(u32 row) const
行を取得
Definition GxMatrix.inl:2281

GxMatrixAffine::getDeterminant
GX_FORCE_INLINE f32 getDeterminant(void) const
行列式の値を取得
Definition GxMatrix.inl:2419

GxMatrixAffine::mulTranslate
GX_FORCE_INLINE const GxMatrixAffine & mulTranslate(const GxVector3 &vector)
平行移動乗算
Definition GxMatrix.inl:3270

GxMatrixAffine::inverse
GX_FORCE_INLINE const GxMatrixAffine & inverse(void)
逆行列にする
Definition GxMatrix.inl:3377

GxMatrixAffine::getReference
GX_FORCE_INLINE f32 & getReference(u32 row, u32 column)
参照を取得
Definition GxMatrix.inl:2395

GxMatrixAffine::operator*
friend GX_FORCE_INLINE const GxMatrixAffine operator*(const GxMatrixAffine &matrix, f32 scalar)
スカラ乗算
Definition GxMatrix.inl:1729

GxMatrixAffine::operator/=
GX_FORCE_INLINE GxMatrixAffine & operator/=(f32 scalar)
スカラ除算代入
Definition GxMatrix.inl:1692

GxMatrixAffine::mulQuaternionFront
GX_FORCE_INLINE const GxMatrixAffine & mulQuaternionFront(const GxQuaternion &quaternion)
クォータニオンによる回転乗算(前から乗算)
Definition GxMatrix.inl:3073

GxMatrixAffine::operator*=
GX_FORCE_INLINE GxMatrixAffine & operator*=(f32 scalar)
スカラ乗算代入
Definition GxMatrix.inl:1680

GxMatrixAffine::getRotateZXY
GX_FORCE_INLINE GxVector3 getRotateZXY(void) const
ZXY軸回転角を取得
Definition GxMatrix.inl:2024

GxMatrixAffine::setScale
GX_FORCE_INLINE void setScale(const GxVector3 &vector)
スケール行列を設定
Definition GxMatrix.inl:2179

GxMatrixAffine::getAddMatrix
static GX_FORCE_INLINE const GxMatrixAffine & getAddMatrix(GxMatrixAffine &dst, const GxMatrixAffine &matrix0, const GxMatrixAffine &matrix1)
行列加算を取得
Definition GxMatrix.inl:2532

GxMatrixAffine::mulScale
GX_FORCE_INLINE const GxMatrixAffine & mulScale(const GxVector3 &vector)
スケール乗算
Definition GxMatrix.inl:3312

GxMatrixAffine::setTranslate
GX_FORCE_INLINE void setTranslate(const GxVector3 &vector)
平行移動行列を設定
Definition GxMatrix.inl:2091

GxMatrixAffine::setIdentity
GX_FORCE_INLINE void setIdentity(void)
単位行列に設定
Definition GxMatrix.inl:1797

GxMatrixAffine::setRotateX
GX_FORCE_INLINE void setRotateX(f32 radian)
回転行列を設定(X軸回転)
Definition GxMatrix.h:416

GxMatrixAffine::transpose
GX_FORCE_INLINE const GxMatrixAffine & transpose(void)
転置する
Definition GxMatrix.inl:3386

GxMatrixAffine::getMulMatrix
static GX_FORCE_INLINE const GxMatrixAffine & getMulMatrix(GxMatrixAffine &dst, const GxMatrixAffine &matrix0, const GxMatrixAffine &matrix1)
行列乗算を取得
Definition GxMatrix.inl:2560

GxMatrixAffine::setRow
GX_FORCE_INLINE void setRow(u32 row, const GxVector4 &vector)
行を設定
Definition GxMatrix.inl:2304

GxMatrixAffine::setRotate
GX_FORCE_INLINE void setRotate(const GxQuaternion &quaternion)
回転行列を設定
Definition GxMatrix.inl:2257

GxMatrixAffine::initialize
GX_FORCE_INLINE void initialize(const GxQuaternion &quaternion, const GxVector3 &position)
初期化
Definition GxMatrix.inl:1643

GxMatrixAffine::getRotateYXZ
GX_FORCE_INLINE GxVector3 getRotateYXZ(void) const
YXZ軸回転角を取得
Definition GxMatrix.inl:1960

GxMatrixAffine::setColumn
GX_FORCE_INLINE void setColumn(u32 column, const GxVector4 &vector)
列を設定
Definition GxMatrix.inl:2343

GxMatrixAffine::setRotateY
GX_FORCE_INLINE void setRotateY(f32 sinValue, f32 cosValue)
回転行列を設定(Y軸回転)
Definition GxMatrix.inl:1847

GxMatrixAffine::mulQuaternionBack
GX_FORCE_INLINE const GxMatrixAffine & mulQuaternionBack(const GxQuaternion &quaternion)
クォータニオンによる回転乗算(後ろから乗算)
Definition GxMatrix.inl:3086

GxMatrixAffine::operator=
GX_FORCE_INLINE GxMatrixAffine & operator=(const GxMatrixAffine &matrix)
代入
Definition GxMatrix.inl:1654

GxMatrixAffine::getXAxis
GX_FORCE_INLINE const GxVector3 & getXAxis(void) const
平行移動量を取得
Definition GxMatrix.h:456

GxMatrixAffine::operator==
GX_FORCE_INLINE b32 operator==(const GxMatrixAffine &matrix)
一致
Definition GxMatrix.inl:1776

GxMatrixAffine::getScale
GX_FORCE_INLINE GxVector3 getScale(void) const
スケールを取得
Definition GxMatrix.inl:2165

GxMatrixAffine::mulRotateX
GX_FORCE_INLINE const GxMatrixAffine & mulRotateX(f32 radian)
X軸回転乗算
Definition GxMatrix.inl:3031

GxMatrixAffine::operator+
friend GX_FORCE_INLINE const GxMatrixAffine operator+(const GxMatrixAffine &matrix0, const GxMatrixAffine &matrix1)
行列加算
Definition GxMatrix.inl:1753

GxMatrixAffine::getNormalizeAxes
GX_FORCE_INLINE GxMatrixAffine getNormalizeAxes(void) const
位置以外の各軸を正規化したものを取得
Definition GxMatrix.inl:2452

GxMatrixAffine::getRotateXZY
GX_FORCE_INLINE GxVector3 getRotateXZY(void) const
XZY軸回転角を取得
Definition GxMatrix.inl:1928

GxMatrixAffine::getRotateZYX
GX_FORCE_INLINE GxVector3 getRotateZYX(void) const
ZYX軸回転角を取得
Definition GxMatrix.inl:2057

GxMatrixAffine::getFastMulMatrix
static GX_FORCE_INLINE void getFastMulMatrix(GxMatrixAffine &dst, const GxMatrixAffine &matrix0, const GxMatrixAffine &matrix1)
高速版。dst と matrix0, matrix1 は重なってなならない。アドレスは simd 用にアライメントされななければならない。
Definition GxMatrix.inl:2644

GxMatrixAffine::isSimdAlignment
static GX_FORCE_INLINE b32 isSimdAlignment(const GxMatrixAffine &matrix)
simd 用にアライメントされているか調べる
Definition GxMatrix.inl:2704

GxMatrixAffine::getValue
GX_FORCE_INLINE f32 getValue(u32 row, u32 column) const
値を取得
Definition GxMatrix.inl:2361

GxMatrixAffine::setRotateZ
GX_FORCE_INLINE void setRotateZ(f32 sinValue, f32 cosValue)
回転行列を設定(Z軸回転)
Definition GxMatrix.inl:1872

GxMatrixAffine::getRotateXYZ
GX_FORCE_INLINE GxVector3 getRotateXYZ(void) const
XYZ軸回転角を取得
Definition GxMatrix.inl:1895

GxMatrixAffine::setLookAtLH
void setLookAtLH(const GxVector3 &eyePosition, const GxVector3 &atPosition, const GxVector3 &up)
左手座標系・視点行列を設定
Definition GxMatrix.cpp:138

GxMatrixAffine::setRotateAxis
GX_FORCE_INLINE void setRotateAxis(const GxVector3 &vector, f32 radian)
回転行列を設定
Definition GxMatrix.inl:2230

GxMatrixAffine::getRotateYZX
GX_FORCE_INLINE GxVector3 getRotateYZX(void) const
YZX軸回転角を取得
Definition GxMatrix.inl:1992

GxMatrixAffine::addMatrix
GX_FORCE_INLINE const GxMatrixAffine & addMatrix(const GxMatrixAffine &matrix)
行列加算
Definition GxMatrix.inl:2994

GxMatrixAffine::mulMatrix
GX_FORCE_INLINE const GxMatrixAffine & mulMatrix(const GxMatrixAffine &matrix)
行列乗算
Definition GxMatrix.inl:3020

GxMatrixAffine::mulScalar
GX_FORCE_INLINE const GxMatrixAffine & mulScalar(f32 scalar)
スカラ乗算
Definition GxMatrix.inl:2940

GxMatrixAffine::getColumn
GX_FORCE_INLINE GxVector4 getColumn(u32 column) const
列を取得
Definition GxMatrix.inl:2331

GxMatrixAffine::setRotateX
GX_FORCE_INLINE void setRotateX(f32 sinValue, f32 cosValue)
回転行列を設定(X軸回転)
Definition GxMatrix.inl:1822

GxMatrixAffine::getMulScalar
static GX_FORCE_INLINE const GxMatrixAffine & getMulScalar(GxMatrixAffine &dst, const GxMatrixAffine &matrix, f32 scalar)
スカラ乗算を取得
Definition GxMatrix.inl:2474

GxMatrixAffine::setRotateXZY
GX_FORCE_INLINE void setRotateXZY(f32 x, f32 y, f32 z)
回転行列を設定(XZY軸回転)
Definition GxMatrix.h:432

GxMatrixAffine::operator+=
GX_FORCE_INLINE GxMatrixAffine & operator+=(const GxMatrixAffine &matrix)
行列加算代入
Definition GxMatrix.inl:1704

GxMatrixAffine::getTranspose
GX_FORCE_INLINE GxMatrixAffine getTranspose(void) const
転置行列を取得
Definition GxMatrix.inl:2440

GxMatrixAffine::setRotateYZX
GX_FORCE_INLINE void setRotateYZX(f32 x, f32 y, f32 z)
回転行列を設定(YZX軸回転)
Definition GxMatrix.h:440

GxMatrixAffine::divScalar
GX_FORCE_INLINE const GxMatrixAffine & divScalar(f32 scalar)
スカラ除算
Definition GxMatrix.inl:2966

GxMatrixAffine::getDivScalar
static GX_FORCE_INLINE const GxMatrixAffine & getDivScalar(GxMatrixAffine &dst, const GxMatrixAffine &matrix, f32 scalar)
スカラ除算を取得
Definition GxMatrix.inl:2502

GxMatrixAffine::getMatrix
static GxMatrixAffine getMatrix(AXIS axis0, const GxVector3 &vector0, AXIS axis1, const GxVector3 &vector1)
２つの軸とベクトルから行列を取得
Definition GxMatrix.cpp:179

GxMatrixAffine::mulRotateZ
GX_FORCE_INLINE const GxMatrixAffine & mulRotateZ(f32 radian)
Z軸回転乗算
Definition GxMatrix.inl:3059

GxMatrixAffine::getRowPtr
GX_FORCE_INLINE const f32 * getRowPtr(u32 row) const
行を取得
Definition GxMatrix.inl:2293

GxMatrixAffine::getPosition
GX_FORCE_INLINE const GxVector3 & getPosition(void) const
平行移動量を取得
Definition GxMatrix.h:454

GxMatrixAffine::setValue
GX_FORCE_INLINE void setValue(u32 row, u32 column, f32 value)
値を設定
Definition GxMatrix.inl:2379

GxMatrixAffine::operator/
friend GX_FORCE_INLINE const GxMatrixAffine operator/(const GxMatrixAffine &matrix, f32 scalar)
スカラ除算
Definition GxMatrix.inl:1741

GxMatrixAffine::getYAxis
GX_FORCE_INLINE const GxVector3 & getYAxis(void) const
平行移動量を取得
Definition GxMatrix.h:458

GxMatrixAffine::setScaleQuaternion
GX_FORCE_INLINE void setScaleQuaternion(const GxVector3 &scale, const GxQuaternion &quaternion)
スケール行列を設定し、クォータニオンによる回転乗算(後ろから乗算)を行う
Definition GxMatrix.inl:3205

GxMatrixAffine::GxMatrixAffine
GxMatrixAffine(void)
デフォルトコンストラクタ(要素は全て0で初期化される)
Definition GxMatrix.h:353

GxMatrixAffine::setRotateY
GX_FORCE_INLINE void setRotateY(f32 radian)
回転行列を設定(Y軸回転)
Definition GxMatrix.h:420

GxMatrixAffine::setPosition
GX_FORCE_INLINE void setPosition(const GxVector3 &position)
平行移動量のみを設定
Definition GxMatrix.inl:2141

GxMatrixAffine::setLookAtRH
void setLookAtRH(const GxVector3 &eyePosition, const GxVector3 &atPosition, const GxVector3 &up)
右手座標系・視点行列を設定
Definition GxMatrix.cpp:99

GxMatrixAffine::setRotateYXZ
GX_FORCE_INLINE void setRotateYXZ(f32 x, f32 y, f32 z)
回転行列を設定(YXZ軸回転)
Definition GxMatrix.h:436

GxPoint2
座標
Definition GxStruct.h:867

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

GxRect
矩形
Definition GxStruct.h:951

GxSize
サイズ
Definition GxStruct.h:730

GxStructBase
Definition GxBase.h:24

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

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

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

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