mtx.h File Reference

#include <dolphin/types.h>

Go to the source code of this file.

Data Structures
struct	Vec2
struct	Vec
struct	S8Vec3
struct	U8Vec4
struct	S16Vec
struct	IntVec2
struct	S32Vec2
struct	IntVec3
struct	S32Vec
struct	Quaternion
struct	MTXStack

Macros
#define	MTXDegToRad(a)
#define	MTXRadToDeg(a)
#define	VECSquareMag   PSVECSquareMag
#define	VECNormalize   PSVECNormalize
#define	VECAdd   PSVECAdd
#define	VECSubtract   PSVECSubtract
#define	VECMag   PSVECMag
#define	VECDotProduct   PSVECDotProduct
#define	VECSquareDistance   PSVECSquareDistance
#define	VECCrossProduct   PSVECCrossProduct
#define	VECScale   PSVECScale
#define	MTXMultVec   PSMTXMultVec
#define	MTXMultVecSR   PSMTXMultVecSR
#define	MTXMultVecArray   PSMTXMultVecArray
#define	MTXCopy   PSMTXCopy
#define	MTXConcat   PSMTXConcat
#define	MTXInverse   PSMTXInverse
#define	MTXTrans   PSMTXTrans
#define	MTXTranspose   PSMTXTranspose
#define	MTXScale   PSMTXScale
#define	MTXRotAxisRad   PSMTXRotAxisRad
#define	MTXRotTrig   PSMTXRotTrig
#define	MTXQuat   PSMTXQuat
#define	MTXIdentity   PSMTXIdentity
#define	MTXReorder   PSMTXReorder
#define	MTXROMultVecArray   PSMTXROMultVecArray
#define	MTXROSkin2VecArray   PSMTXROSkin2VecArray
#define	MTXROMultS16VecArray   PSMTXROMultS16VecArray
#define	MTXMultS16VecArray   PSMTXMultS16VecArray

Typedefs
typedef struct Vec2 *	Vec2Ptr
typedef struct Vec2	Point2d
typedef struct Vec2 *	Point2dPtr
typedef struct Vec	Vec3
typedef struct Vec *	VecPtr
typedef struct Vec	Point3d
typedef struct Vec *	Point3dPtr
typedef struct S8Vec3	S8Vec
typedef struct S8Vec3 *	S8Vec3Ptr
typedef struct S8Vec3 *	S8VecPtr
typedef struct U8Vec4 *	U8Vec4Ptr
typedef struct S16Vec	S16Vec3
typedef struct S16Vec *	S16VecPtr
typedef struct S16Vec *	S16Vec3Ptr
typedef struct IntVec2 *	IntVec2Ptr
typedef struct S32Vec2 *	S32Vec2Ptr
typedef struct IntVec3 *	IntVec3Ptr
typedef struct S32Vec	S32Vec3
typedef struct S32Vec *	S32VecPtr
typedef struct S32Vec *	S32Vec3Ptr
typedef struct Quaternion	Vec4
typedef struct Quaternion *	QuaternionPtr
typedef struct Quaternion	Qtrn
typedef struct Quaternion *	QtrnPtr
typedef f32	Mtx[3][4]
typedef f32	Mtx44[4][4]
typedef f32(*	MtxPtr)[4]
typedef f32(*	Mtx44Ptr)[4]
typedef f32	ROMtx[4][3]
typedef f32(*	ROMtxPtr)[3]

Functions
void	MTXFrustum (Mtx m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 f)
void	MTXPerspective (Mtx m, f32 fovY, f32 aspect, f32 n, f32 f)
void	MTXOrtho (Mtx m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 f)
void	MTXPerspective (Mtx44 m, f32 fovY, f32 aspect, f32 n, f32 f)
void	C_MTXLookAt (Mtx m, Point3dPtr camPos, VecPtr camUp, Point3dPtr target)
void	MTXRotRad (Mtx m, char axis, f32 rad)
void	MTXTrans (Mtx m, f32 xT, f32 yT, f32 zT)
void	MTXTransApply (Mtx src, Mtx dst, f32 xT, f32 yT, f32 zT)
void	MTXScaleApply (Mtx src, Mtx dst, f32 xS, f32 yS, f32 zS)
void	MTXReflect (Mtx m, Vec *p, Vec *n)
void	MTXLookAt (Mtx m, Vec *camPos, Vec *camUp, Vec *target)
void	MTXLightFrustum (Mtx m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 scaleS, f32 scaleT, f32 transS, f32 transT)
void	MTXLightPerspective (Mtx m, f32 fovY, f32 aspect, f32 scaleS, f32 scaleT, f32 transS, f32 transT)
void	MTXLightOrtho (Mtx m, f32 t, f32 b, f32 l, f32 r, f32 scaleS, f32 scaleT, f32 transS, f32 transT)
void	C_MTXIdentity (Mtx m)
void	C_MTXCopy (Mtx src, Mtx dst)
void	C_MTXConcat (Mtx a, Mtx b, Mtx ab)
void	C_MTXTranspose (Mtx src, Mtx xPose)
void	C_MTXScale (Mtx m, f32 xS, f32 yS, f32 zS)
void	C_MTXRotAxisRad (Mtx m, Vec *axis, f32 rad)
void	C_MTXRotTrig (Mtx m, char axis, f32 sinA, f32 cosA)
void	C_MTXQuat (Mtx m, QuaternionPtr q)
u32	C_MTXInverse (Mtx src, Mtx inv)
u32	C_MTXInvXpose (Mtx src, Mtx invX)
void	PSMTXIdentity (Mtx m)
void	PSMTXCopy (Mtx src, Mtx dst)
void	PSMTXConcat (Mtx mA, Mtx mB, Mtx mAB)
void	PSMTXTranspose (Mtx src, Mtx xPose)
void	PSMTXScale (Mtx m, f32 xS, f32 yS, f32 zS)
void	PSMTXRotAxisRad (Mtx m, Vec *axis, f32 rad)
void	PSMTXRotTrig (Mtx m, char axis, f32 sinA, f32 cosA)
void	PSMTXQuat (Mtx m, QuaternionPtr q)
u32	PSMTXInverse (Mtx src, Mtx inv)
u32	PSMTXInvXpose (Mtx src, Mtx invX)
void	MTXInitStack (MTXStack *sPtr, u32 numMtx)
Mtx *	MTXPush (MTXStack *sPtr, Mtx m)
Mtx *	MTXPushFwd (MTXStack *sPtr, Mtx m)
Mtx *	MTXPushInv (MTXStack *sPtr, Mtx m)
Mtx *	MTXPushInvXpose (MTXStack *sPtr, Mtx m)
Mtx *	MTXPop (MTXStack *sPtr)
Mtx *	MTXGetStackPtr (MTXStack *sPtr)
void	C_MTXMultVecSR (Mtx44 m, Vec *src, Vec *dst)
void	PSMTXMultVecSR (Mtx44 m, Vec *src, Vec *dst)
void	MTXMultVecArraySR (Mtx44 m, Vec *srcBase, Vec *dstBase, u32 count)
void	C_MTXMultVec (Mtx44 m, Vec *src, Vec *dst)
void	C_MTXMultVecArray (Mtx m, Vec *srcBase, Vec *dstBase, u32 count)
void	PSMTXMultVec (Mtx44 m, Vec *src, Vec *dst)
void	PSMTXMultVecArray (Mtx m, Vec *srcBase, Vec *dstBase, u32 count)
void	PSMTXReorder (Mtx src, ROMtx dest)
void	PSMTXROMultVecArray (ROMtx *m, Vec *srcBase, Vec *dstBase, u32 count)
void	PSMTXROSkin2VecArray (ROMtx *m0, ROMtx *m1, f32 *wtBase, Vec *srcBase, Vec *dstBase, u32 count)
void	PSMTXROMultS16VecArray (ROMtx *m, S16Vec *srcBase, Vec *dstBase, u32 count)
void	PSMTXMultS16VecArray (Mtx44 *m, S16Vec *srcBase, Vec *dstBase, u32 count)
f32	C_VECMag (Vec *v)
f32	PSVECMag (Vec *v)
void	VECHalfAngle (Vec *a, Vec *b, Vec *half)
void	VECReflect (Vec *src, Vec *normal, Vec *dst)
f32	VECDistance (Vec *a, Vec *b)
void	C_VECAdd (Vec *a, Vec *b, Vec *c)
void	C_VECSubtract (Vec *a, Vec *b, Vec *c)
void	C_VECScale (Vec *src, Vec *dst, f32 scale)
void	C_VECNormalize (Vec *src, Vec *unit)
f32	C_VECSquareMag (Vec *v)
f32	C_VECDotProduct (Vec *a, Vec *b)
void	C_VECCrossProduct (Vec *a, Vec *b, Vec *axb)
f32	C_VECSquareDistance (Vec *a, Vec *b)
void	PSVECAdd (Vec *a, Vec *b, Vec *c)
void	PSVECSubtract (Vec *a, Vec *b, Vec *c)
void	PSVECScale (Vec *src, Vec *dst, f32 scale)
void	PSVECNormalize (Vec *vec1, Vec *dst)
f32	PSVECSquareMag (Vec *vec1)
f32	PSVECDotProduct (Vec *vec1, Vec *vec2)
void	PSVECCrossProduct (Vec *vec1, Vec *vec2, Vec *dst)
f32	PSVECSquareDistance (Vec *vec1, Vec *vec2)

Macro Definition Documentation

MTXDegToRad

#define MTXDegToRad

(

a

)

Value:

((a) * 0.01745329252f)

MTXRadToDeg

#define MTXRadToDeg

(

a

)

Value:

((a) * 57.29577951f)

VECSquareMag

#define VECSquareMag   PSVECSquareMag

VECNormalize

#define VECNormalize   PSVECNormalize

VECAdd

#define VECAdd   PSVECAdd

VECSubtract

#define VECSubtract   PSVECSubtract

VECMag

#define VECMag   PSVECMag

VECDotProduct

#define VECDotProduct   PSVECDotProduct

VECSquareDistance

#define VECSquareDistance   PSVECSquareDistance

VECCrossProduct

#define VECCrossProduct   PSVECCrossProduct

VECScale

#define VECScale   PSVECScale

MTXMultVec

#define MTXMultVec   PSMTXMultVec

MTXMultVecSR

#define MTXMultVecSR   PSMTXMultVecSR

MTXMultVecArray

#define MTXMultVecArray   PSMTXMultVecArray

MTXCopy

#define MTXCopy   PSMTXCopy

MTXConcat

#define MTXConcat   PSMTXConcat

MTXInverse

#define MTXInverse   PSMTXInverse

MTXTrans

#define MTXTrans   PSMTXTrans

MTXTranspose

#define MTXTranspose   PSMTXTranspose

MTXScale

#define MTXScale   PSMTXScale

MTXRotAxisRad

#define MTXRotAxisRad   PSMTXRotAxisRad

MTXRotTrig

#define MTXRotTrig   PSMTXRotTrig

MTXQuat

#define MTXQuat   PSMTXQuat

MTXIdentity

#define MTXIdentity   PSMTXIdentity

MTXReorder

#define MTXReorder   PSMTXReorder

MTXROMultVecArray

#define MTXROMultVecArray   PSMTXROMultVecArray

MTXROSkin2VecArray

#define MTXROSkin2VecArray   PSMTXROSkin2VecArray

MTXROMultS16VecArray

#define MTXROMultS16VecArray   PSMTXROMultS16VecArray

MTXMultS16VecArray

#define MTXMultS16VecArray   PSMTXMultS16VecArray

Typedef Documentation

Vec2Ptr

typedef struct Vec2 * Vec2Ptr

Point2d

typedef struct Vec2 Point2d

Point2dPtr

typedef struct Vec2 * Point2dPtr

Vec3

typedef struct Vec Vec3

VecPtr

typedef struct Vec * VecPtr

Point3d

typedef struct Vec Point3d

Point3dPtr

typedef struct Vec * Point3dPtr

S8Vec

typedef struct S8Vec3 S8Vec

S8Vec3Ptr

typedef struct S8Vec3 * S8Vec3Ptr

S8VecPtr

typedef struct S8Vec3 * S8VecPtr

U8Vec4Ptr

typedef struct U8Vec4 * U8Vec4Ptr

S16Vec3

typedef struct S16Vec S16Vec3

S16VecPtr

typedef struct S16Vec * S16VecPtr

S16Vec3Ptr

typedef struct S16Vec * S16Vec3Ptr

IntVec2Ptr

typedef struct IntVec2 * IntVec2Ptr

S32Vec2Ptr

typedef struct S32Vec2 * S32Vec2Ptr

IntVec3Ptr

typedef struct IntVec3 * IntVec3Ptr

S32Vec3

typedef struct S32Vec S32Vec3

S32VecPtr

typedef struct S32Vec * S32VecPtr

S32Vec3Ptr

typedef struct S32Vec * S32Vec3Ptr

Vec4

typedef struct Quaternion Vec4

QuaternionPtr

typedef struct Quaternion * QuaternionPtr

Qtrn

typedef struct Quaternion Qtrn

QtrnPtr

typedef struct Quaternion * QtrnPtr

Mtx

typedef f32 Mtx[3][4]

Mtx44

typedef f32 Mtx44[4][4]

MtxPtr

typedef f32(* MtxPtr)[4]

Mtx44Ptr

typedef f32(* Mtx44Ptr)[4]

ROMtx

typedef f32 ROMtx[4][3]

ROMtxPtr

typedef f32(* ROMtxPtr)[3]

Function Documentation

MTXFrustum()

void MTXFrustum	(	Mtx	m,
		f32	t,
		f32	b,
		f32	l,
		f32	r,
		f32	n,
		f32	f )

MTXPerspective() [1/2]

void MTXPerspective	(	Mtx	m,
		f32	fovY,
		f32	aspect,
		f32	n,
		f32	f )

MTXOrtho()

void MTXOrtho	(	Mtx	m,
		f32	t,
		f32	b,
		f32	l,
		f32	r,
		f32	n,
		f32	f )

MTXPerspective() [2/2]

void MTXPerspective	(	Mtx44	m,
		f32	fovY,
		f32	aspect,
		f32	n,
		f32	f )

C_MTXLookAt()

void C_MTXLookAt	(	Mtx	m,
		Point3dPtr	camPos,
		VecPtr	camUp,
		Point3dPtr	target )

MTXRotRad()

void MTXRotRad	(	Mtx	m,
		char	axis,
		f32	rad )

MTXTrans()

void MTXTrans	(	Mtx	m,
		f32	xT,
		f32	yT,
		f32	zT )

MTXTransApply()

void MTXTransApply	(	Mtx	src,
		Mtx	dst,
		f32	xT,
		f32	yT,
		f32	zT )

MTXScaleApply()

void MTXScaleApply	(	Mtx	src,
		Mtx	dst,
		f32	xS,
		f32	yS,
		f32	zS )

MTXReflect()

void MTXReflect	(	Mtx	m,
		Vec *	p,
		Vec *	n )

MTXLookAt()

void MTXLookAt	(	Mtx	m,
		Vec *	camPos,
		Vec *	camUp,
		Vec *	target )

MTXLightFrustum()

void MTXLightFrustum	(	Mtx	m,
		f32	t,
		f32	b,
		f32	l,
		f32	r,
		f32	n,
		f32	scaleS,
		f32	scaleT,
		f32	transS,
		f32	transT )

MTXLightPerspective()

void MTXLightPerspective	(	Mtx	m,
		f32	fovY,
		f32	aspect,
		f32	scaleS,
		f32	scaleT,
		f32	transS,
		f32	transT )

MTXLightOrtho()

void MTXLightOrtho	(	Mtx	m,
		f32	t,
		f32	b,
		f32	l,
		f32	r,
		f32	scaleS,
		f32	scaleT,
		f32	transS,
		f32	transT )

C_MTXIdentity()

void C_MTXIdentity

(

Mtx

m

)

C_MTXCopy()

void C_MTXCopy	(	Mtx	src,
		Mtx	dst )

C_MTXConcat()

void C_MTXConcat	(	Mtx	a,
		Mtx	b,
		Mtx	ab )

C_MTXTranspose()

void C_MTXTranspose	(	Mtx	src,
		Mtx	xPose )

C_MTXScale()

void C_MTXScale	(	Mtx	m,
		f32	xS,
		f32	yS,
		f32	zS )

C_MTXRotAxisRad()

void C_MTXRotAxisRad	(	Mtx	m,
		Vec *	axis,
		f32	rad )

C_MTXRotTrig()

void C_MTXRotTrig	(	Mtx	m,
		char	axis,
		f32	sinA,
		f32	cosA )

C_MTXQuat()

void C_MTXQuat	(	Mtx	m,
		QuaternionPtr	q )

C_MTXInverse()

u32 C_MTXInverse	(	Mtx	src,
		Mtx	inv )

C_MTXInvXpose()

u32 C_MTXInvXpose	(	Mtx	src,
		Mtx	invX )

PSMTXIdentity()

void PSMTXIdentity

(

Mtx

m

)

PSMTXCopy()

void PSMTXCopy	(	Mtx	src,
		Mtx	dst )

PSMTXConcat()

void PSMTXConcat	(	Mtx	mA,
		Mtx	mB,
		Mtx	mAB )

PSMTXTranspose()

void PSMTXTranspose	(	Mtx	src,
		Mtx	xPose )

PSMTXScale()

void PSMTXScale	(	Mtx	m,
		f32	xS,
		f32	yS,
		f32	zS )

PSMTXRotAxisRad()

void PSMTXRotAxisRad	(	Mtx	m,
		Vec *	axis,
		f32	rad )

PSMTXRotTrig()

void PSMTXRotTrig	(	Mtx	m,
		char	axis,
		f32	sinA,
		f32	cosA )

PSMTXQuat()

void PSMTXQuat	(	Mtx	m,
		QuaternionPtr	q )

PSMTXInverse()

u32 PSMTXInverse	(	Mtx	src,
		Mtx	inv )

PSMTXInvXpose()

u32 PSMTXInvXpose	(	Mtx	src,
		Mtx	invX )

MTXInitStack()

void MTXInitStack	(	MTXStack *	sPtr,
		u32	numMtx )

MTXPush()

Mtx * MTXPush	(	MTXStack *	sPtr,
		Mtx	m )

MTXPushFwd()

Mtx * MTXPushFwd	(	MTXStack *	sPtr,
		Mtx	m )

MTXPushInv()

Mtx * MTXPushInv	(	MTXStack *	sPtr,
		Mtx	m )

MTXPushInvXpose()

Mtx * MTXPushInvXpose	(	MTXStack *	sPtr,
		Mtx	m )

MTXPop()

Mtx * MTXPop

(

MTXStack *

sPtr

)

MTXGetStackPtr()

Mtx * MTXGetStackPtr

(

MTXStack *

sPtr

)

C_MTXMultVecSR()

void C_MTXMultVecSR	(	Mtx44	m,
		Vec *	src,
		Vec *	dst )

PSMTXMultVecSR()

void PSMTXMultVecSR	(	Mtx44	m,
		Vec *	src,
		Vec *	dst )

MTXMultVecArraySR()

void MTXMultVecArraySR	(	Mtx44	m,
		Vec *	srcBase,
		Vec *	dstBase,
		u32	count )

C_MTXMultVec()

void C_MTXMultVec	(	Mtx44	m,
		Vec *	src,
		Vec *	dst )

C_MTXMultVecArray()

void C_MTXMultVecArray	(	Mtx	m,
		Vec *	srcBase,
		Vec *	dstBase,
		u32	count )

PSMTXMultVec()

void PSMTXMultVec	(	Mtx44	m,
		Vec *	src,
		Vec *	dst )

PSMTXMultVecArray()

void PSMTXMultVecArray	(	Mtx	m,
		Vec *	srcBase,
		Vec *	dstBase,
		u32	count )

PSMTXReorder()

void PSMTXReorder	(	Mtx	src,
		ROMtx	dest )

PSMTXROMultVecArray()

void PSMTXROMultVecArray	(	ROMtx *	m,
		Vec *	srcBase,
		Vec *	dstBase,
		u32	count )

PSMTXROSkin2VecArray()

void PSMTXROSkin2VecArray	(	ROMtx *	m0,
		ROMtx *	m1,
		f32 *	wtBase,
		Vec *	srcBase,
		Vec *	dstBase,
		u32	count )

PSMTXROMultS16VecArray()

void PSMTXROMultS16VecArray	(	ROMtx *	m,
		S16Vec *	srcBase,
		Vec *	dstBase,
		u32	count )

PSMTXMultS16VecArray()

void PSMTXMultS16VecArray	(	Mtx44 *	m,
		S16Vec *	srcBase,
		Vec *	dstBase,
		u32	count )

C_VECMag()

f32 C_VECMag

(

Vec *

v

)

PSVECMag()

f32 PSVECMag

(

Vec *

v

)

VECHalfAngle()

void VECHalfAngle	(	Vec *	a,
		Vec *	b,
		Vec *	half )

VECReflect()

void VECReflect	(	Vec *	src,
		Vec *	normal,
		Vec *	dst )

VECDistance()

f32 VECDistance	(	Vec *	a,
		Vec *	b )

C_VECAdd()

void C_VECAdd	(	Vec *	a,
		Vec *	b,
		Vec *	c )

C_VECSubtract()

void C_VECSubtract	(	Vec *	a,
		Vec *	b,
		Vec *	c )

C_VECScale()

void C_VECScale	(	Vec *	src,
		Vec *	dst,
		f32	scale )

C_VECNormalize()

void C_VECNormalize	(	Vec *	src,
		Vec *	unit )

C_VECSquareMag()

f32 C_VECSquareMag

(

Vec *

v

)

C_VECDotProduct()

f32 C_VECDotProduct	(	Vec *	a,
		Vec *	b )

C_VECCrossProduct()

void C_VECCrossProduct	(	Vec *	a,
		Vec *	b,
		Vec *	axb )

C_VECSquareDistance()

f32 C_VECSquareDistance	(	Vec *	a,
		Vec *	b )

PSVECAdd()

void PSVECAdd	(	Vec *	a,
		Vec *	b,
		Vec *	c )

PSVECSubtract()

void PSVECSubtract	(	Vec *	a,
		Vec *	b,
		Vec *	c )

PSVECScale()

void PSVECScale	(	Vec *	src,
		Vec *	dst,
		f32	scale )

PSVECNormalize()

void PSVECNormalize	(	Vec *	vec1,
		Vec *	dst )

PSVECSquareMag()

f32 PSVECSquareMag

(

Vec *

vec1

)

PSVECDotProduct()

f32 PSVECDotProduct	(	Vec *	vec1,
		Vec *	vec2 )

PSVECCrossProduct()

void PSVECCrossProduct	(	Vec *	vec1,
		Vec *	vec2,
		Vec *	dst )

PSVECSquareDistance()

f32 PSVECSquareDistance	(	Vec *	vec1,
		Vec *	vec2 )