#include "config.h"
#include "wine/port.h"
#include "d3dx9_private.h"

Include dependency graph for math.c:

Classes
struct	ID3DXMatrixStackImpl

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d3dx)

D3DXCOLOR *WINAPI	D3DXColorAdjustContrast (D3DXCOLOR pout, const D3DXCOLOR pc, FLOAT s)

D3DXCOLOR *WINAPI	D3DXColorAdjustSaturation (D3DXCOLOR pout, const D3DXCOLOR pc, FLOAT s)

FLOAT WINAPI	D3DXFresnelTerm (FLOAT costheta, FLOAT refractionindex)

D3DXMATRIX *WINAPI	D3DXMatrixAffineTransformation (D3DXMATRIX out, FLOAT scaling, const D3DXVECTOR3 rotationcenter, const D3DXQUATERNION rotation, const D3DXVECTOR3 translation)

D3DXMATRIX *WINAPI	D3DXMatrixAffineTransformation2D (D3DXMATRIX out, FLOAT scaling, const D3DXVECTOR2 rotationcenter, FLOAT rotation, const D3DXVECTOR2 *translation)

HRESULT WINAPI	D3DXMatrixDecompose (D3DXVECTOR3 poutscale, D3DXQUATERNION poutrotation, D3DXVECTOR3 pouttranslation, const D3DXMATRIX pm)

FLOAT WINAPI	D3DXMatrixDeterminant (const D3DXMATRIX *pm)

D3DXMATRIX *WINAPI	D3DXMatrixInverse (D3DXMATRIX pout, FLOAT pdeterminant, const D3DXMATRIX *pm)

D3DXMATRIX *WINAPI	D3DXMatrixLookAtLH (D3DXMATRIX out, const D3DXVECTOR3 eye, const D3DXVECTOR3 at, const D3DXVECTOR3 up)

D3DXMATRIX *WINAPI	D3DXMatrixLookAtRH (D3DXMATRIX out, const D3DXVECTOR3 eye, const D3DXVECTOR3 at, const D3DXVECTOR3 up)

D3DXMATRIX *WINAPI	D3DXMatrixMultiply (D3DXMATRIX pout, const D3DXMATRIX pm1, const D3DXMATRIX *pm2)

D3DXMATRIX *WINAPI	D3DXMatrixMultiplyTranspose (D3DXMATRIX pout, const D3DXMATRIX pm1, const D3DXMATRIX *pm2)

D3DXMATRIX *WINAPI	D3DXMatrixOrthoLH (D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)

D3DXMATRIX *WINAPI	D3DXMatrixOrthoOffCenterLH (D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)

D3DXMATRIX *WINAPI	D3DXMatrixOrthoOffCenterRH (D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)

D3DXMATRIX *WINAPI	D3DXMatrixOrthoRH (D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)

D3DXMATRIX *WINAPI	D3DXMatrixPerspectiveFovLH (D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf)

D3DXMATRIX *WINAPI	D3DXMatrixPerspectiveFovRH (D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf)

D3DXMATRIX *WINAPI	D3DXMatrixPerspectiveLH (D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)

D3DXMATRIX *WINAPI	D3DXMatrixPerspectiveOffCenterLH (D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)

D3DXMATRIX *WINAPI	D3DXMatrixPerspectiveOffCenterRH (D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)

D3DXMATRIX *WINAPI	D3DXMatrixPerspectiveRH (D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)

D3DXMATRIX *WINAPI	D3DXMatrixReflect (D3DXMATRIX pout, const D3DXPLANE pplane)

D3DXMATRIX *WINAPI	D3DXMatrixRotationAxis (D3DXMATRIX out, const D3DXVECTOR3 v, FLOAT angle)

D3DXMATRIX *WINAPI	D3DXMatrixRotationQuaternion (D3DXMATRIX pout, const D3DXQUATERNION pq)

D3DXMATRIX *WINAPI	D3DXMatrixRotationX (D3DXMATRIX *pout, FLOAT angle)

D3DXMATRIX *WINAPI	D3DXMatrixRotationY (D3DXMATRIX *pout, FLOAT angle)

D3DXMATRIX *WINAPI	D3DXMatrixRotationYawPitchRoll (D3DXMATRIX *out, FLOAT yaw, FLOAT pitch, FLOAT roll)

D3DXMATRIX *WINAPI	D3DXMatrixRotationZ (D3DXMATRIX *pout, FLOAT angle)

D3DXMATRIX *WINAPI	D3DXMatrixScaling (D3DXMATRIX *pout, FLOAT sx, FLOAT sy, FLOAT sz)

D3DXMATRIX *WINAPI	D3DXMatrixShadow (D3DXMATRIX pout, const D3DXVECTOR4 plight, const D3DXPLANE *pplane)

D3DXMATRIX *WINAPI	D3DXMatrixTransformation (D3DXMATRIX pout, const D3DXVECTOR3 pscalingcenter, const D3DXQUATERNION pscalingrotation, const D3DXVECTOR3 pscaling, const D3DXVECTOR3 protationcenter, const D3DXQUATERNION protation, const D3DXVECTOR3 *ptranslation)

D3DXMATRIX *WINAPI	D3DXMatrixTransformation2D (D3DXMATRIX pout, const D3DXVECTOR2 pscalingcenter, FLOAT scalingrotation, const D3DXVECTOR2 pscaling, const D3DXVECTOR2 protationcenter, FLOAT rotation, const D3DXVECTOR2 *ptranslation)

D3DXMATRIX *WINAPI	D3DXMatrixTranslation (D3DXMATRIX *pout, FLOAT x, FLOAT y, FLOAT z)

D3DXMATRIX *WINAPI	D3DXMatrixTranspose (D3DXMATRIX pout, const D3DXMATRIX pm)

static struct ID3DXMatrixStackImpl *	impl_from_ID3DXMatrixStack (ID3DXMatrixStack *iface)

static HRESULT WINAPI	ID3DXMatrixStackImpl_QueryInterface (ID3DXMatrixStack iface, REFIID riid, void *out)

static ULONG WINAPI	ID3DXMatrixStackImpl_AddRef (ID3DXMatrixStack *iface)

static ULONG WINAPI	ID3DXMatrixStackImpl_Release (ID3DXMatrixStack *iface)

static D3DXMATRIX *WINAPI	ID3DXMatrixStackImpl_GetTop (ID3DXMatrixStack *iface)

static HRESULT WINAPI	ID3DXMatrixStackImpl_LoadIdentity (ID3DXMatrixStack *iface)

static HRESULT WINAPI	ID3DXMatrixStackImpl_LoadMatrix (ID3DXMatrixStack iface, const D3DXMATRIX pm)

static HRESULT WINAPI	ID3DXMatrixStackImpl_MultMatrix (ID3DXMatrixStack iface, const D3DXMATRIX pm)

static HRESULT WINAPI	ID3DXMatrixStackImpl_MultMatrixLocal (ID3DXMatrixStack iface, const D3DXMATRIX pm)

static HRESULT WINAPI	ID3DXMatrixStackImpl_Pop (ID3DXMatrixStack *iface)

static HRESULT WINAPI	ID3DXMatrixStackImpl_Push (ID3DXMatrixStack *iface)

static HRESULT WINAPI	ID3DXMatrixStackImpl_RotateAxis (ID3DXMatrixStack iface, const D3DXVECTOR3 pv, FLOAT angle)

static HRESULT WINAPI	ID3DXMatrixStackImpl_RotateAxisLocal (ID3DXMatrixStack iface, const D3DXVECTOR3 pv, FLOAT angle)

static HRESULT WINAPI	ID3DXMatrixStackImpl_RotateYawPitchRoll (ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)

static HRESULT WINAPI	ID3DXMatrixStackImpl_RotateYawPitchRollLocal (ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)

static HRESULT WINAPI	ID3DXMatrixStackImpl_Scale (ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)

static HRESULT WINAPI	ID3DXMatrixStackImpl_ScaleLocal (ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)

static HRESULT WINAPI	ID3DXMatrixStackImpl_Translate (ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)

static HRESULT WINAPI	ID3DXMatrixStackImpl_TranslateLocal (ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)

HRESULT WINAPI	D3DXCreateMatrixStack (DWORD flags, ID3DXMatrixStack **stack)

D3DXPLANE *WINAPI	D3DXPlaneFromPointNormal (D3DXPLANE pout, const D3DXVECTOR3 pvpoint, const D3DXVECTOR3 *pvnormal)

D3DXPLANE *WINAPI	D3DXPlaneFromPoints (D3DXPLANE pout, const D3DXVECTOR3 pv1, const D3DXVECTOR3 pv2, const D3DXVECTOR3 pv3)

D3DXVECTOR3 *WINAPI	D3DXPlaneIntersectLine (D3DXVECTOR3 pout, const D3DXPLANE pp, const D3DXVECTOR3 pv1, const D3DXVECTOR3 pv2)

D3DXPLANE *WINAPI	D3DXPlaneNormalize (D3DXPLANE out, const D3DXPLANE p)

D3DXPLANE *WINAPI	D3DXPlaneTransform (D3DXPLANE pout, const D3DXPLANE pplane, const D3DXMATRIX *pm)

D3DXPLANE *WINAPI	D3DXPlaneTransformArray (D3DXPLANE out, UINT outstride, const D3DXPLANE in, UINT instride, const D3DXMATRIX *matrix, UINT elements)

D3DXQUATERNION *WINAPI	D3DXQuaternionBaryCentric (D3DXQUATERNION pout, const D3DXQUATERNION pq1, const D3DXQUATERNION pq2, const D3DXQUATERNION pq3, FLOAT f, FLOAT g)

D3DXQUATERNION *WINAPI	D3DXQuaternionExp (D3DXQUATERNION out, const D3DXQUATERNION q)

D3DXQUATERNION *WINAPI	D3DXQuaternionInverse (D3DXQUATERNION pout, const D3DXQUATERNION pq)

D3DXQUATERNION *WINAPI	D3DXQuaternionLn (D3DXQUATERNION out, const D3DXQUATERNION q)

D3DXQUATERNION *WINAPI	D3DXQuaternionMultiply (D3DXQUATERNION pout, const D3DXQUATERNION pq1, const D3DXQUATERNION *pq2)

D3DXQUATERNION *WINAPI	D3DXQuaternionNormalize (D3DXQUATERNION out, const D3DXQUATERNION q)

D3DXQUATERNION *WINAPI	D3DXQuaternionRotationAxis (D3DXQUATERNION out, const D3DXVECTOR3 v, FLOAT angle)

D3DXQUATERNION *WINAPI	D3DXQuaternionRotationMatrix (D3DXQUATERNION out, const D3DXMATRIX m)

D3DXQUATERNION *WINAPI	D3DXQuaternionRotationYawPitchRoll (D3DXQUATERNION *out, FLOAT yaw, FLOAT pitch, FLOAT roll)

D3DXQUATERNION *WINAPI	D3DXQuaternionSlerp (D3DXQUATERNION out, const D3DXQUATERNION q1, const D3DXQUATERNION *q2, FLOAT t)

D3DXQUATERNION *WINAPI	D3DXQuaternionSquad (D3DXQUATERNION pout, const D3DXQUATERNION pq1, const D3DXQUATERNION pq2, const D3DXQUATERNION pq3, const D3DXQUATERNION *pq4, FLOAT t)

static D3DXQUATERNION	add_diff (const D3DXQUATERNION q1, const D3DXQUATERNION q2, const FLOAT add)

void WINAPI	D3DXQuaternionSquadSetup (D3DXQUATERNION paout, D3DXQUATERNION pbout, D3DXQUATERNION pcout, const D3DXQUATERNION pq0, const D3DXQUATERNION pq1, const D3DXQUATERNION pq2, const D3DXQUATERNION *pq3)

void WINAPI	D3DXQuaternionToAxisAngle (const D3DXQUATERNION pq, D3DXVECTOR3 paxis, FLOAT *pangle)

D3DXVECTOR2 *WINAPI	D3DXVec2BaryCentric (D3DXVECTOR2 pout, const D3DXVECTOR2 pv1, const D3DXVECTOR2 pv2, const D3DXVECTOR2 pv3, FLOAT f, FLOAT g)

D3DXVECTOR2 *WINAPI	D3DXVec2CatmullRom (D3DXVECTOR2 pout, const D3DXVECTOR2 pv0, const D3DXVECTOR2 pv1, const D3DXVECTOR2 pv2, const D3DXVECTOR2 *pv3, FLOAT s)

D3DXVECTOR2 *WINAPI	D3DXVec2Hermite (D3DXVECTOR2 pout, const D3DXVECTOR2 pv1, const D3DXVECTOR2 pt1, const D3DXVECTOR2 pv2, const D3DXVECTOR2 *pt2, FLOAT s)

D3DXVECTOR2 *WINAPI	D3DXVec2Normalize (D3DXVECTOR2 pout, const D3DXVECTOR2 pv)

D3DXVECTOR4 *WINAPI	D3DXVec2Transform (D3DXVECTOR4 pout, const D3DXVECTOR2 pv, const D3DXMATRIX *pm)

D3DXVECTOR4 *WINAPI	D3DXVec2TransformArray (D3DXVECTOR4 out, UINT outstride, const D3DXVECTOR2 in, UINT instride, const D3DXMATRIX *matrix, UINT elements)

D3DXVECTOR2 *WINAPI	D3DXVec2TransformCoord (D3DXVECTOR2 pout, const D3DXVECTOR2 pv, const D3DXMATRIX *pm)

D3DXVECTOR2 *WINAPI	D3DXVec2TransformCoordArray (D3DXVECTOR2 out, UINT outstride, const D3DXVECTOR2 in, UINT instride, const D3DXMATRIX *matrix, UINT elements)

D3DXVECTOR2 *WINAPI	D3DXVec2TransformNormal (D3DXVECTOR2 pout, const D3DXVECTOR2 pv, const D3DXMATRIX *pm)

D3DXVECTOR2 *WINAPI	D3DXVec2TransformNormalArray (D3DXVECTOR2 out, UINT outstride, const D3DXVECTOR2 in, UINT instride, const D3DXMATRIX *matrix, UINT elements)

D3DXVECTOR3 *WINAPI	D3DXVec3BaryCentric (D3DXVECTOR3 pout, const D3DXVECTOR3 pv1, const D3DXVECTOR3 pv2, const D3DXVECTOR3 pv3, FLOAT f, FLOAT g)

D3DXVECTOR3 *WINAPI	D3DXVec3CatmullRom (D3DXVECTOR3 pout, const D3DXVECTOR3 pv0, const D3DXVECTOR3 pv1, const D3DXVECTOR3 pv2, const D3DXVECTOR3 *pv3, FLOAT s)

D3DXVECTOR3 *WINAPI	D3DXVec3Hermite (D3DXVECTOR3 pout, const D3DXVECTOR3 pv1, const D3DXVECTOR3 pt1, const D3DXVECTOR3 pv2, const D3DXVECTOR3 *pt2, FLOAT s)

D3DXVECTOR3 *WINAPI	D3DXVec3Normalize (D3DXVECTOR3 pout, const D3DXVECTOR3 pv)

D3DXVECTOR3 *WINAPI	D3DXVec3Project (D3DXVECTOR3 pout, const D3DXVECTOR3 pv, const D3DVIEWPORT9 pviewport, const D3DXMATRIX pprojection, const D3DXMATRIX pview, const D3DXMATRIX pworld)

D3DXVECTOR3 *WINAPI	D3DXVec3ProjectArray (D3DXVECTOR3 out, UINT outstride, const D3DXVECTOR3 in, UINT instride, const D3DVIEWPORT9 viewport, const D3DXMATRIX projection, const D3DXMATRIX view, const D3DXMATRIX world, UINT elements)

D3DXVECTOR4 *WINAPI	D3DXVec3Transform (D3DXVECTOR4 pout, const D3DXVECTOR3 pv, const D3DXMATRIX *pm)

D3DXVECTOR4 *WINAPI	D3DXVec3TransformArray (D3DXVECTOR4 out, UINT outstride, const D3DXVECTOR3 in, UINT instride, const D3DXMATRIX *matrix, UINT elements)

D3DXVECTOR3 *WINAPI	D3DXVec3TransformCoord (D3DXVECTOR3 pout, const D3DXVECTOR3 pv, const D3DXMATRIX *pm)

D3DXVECTOR3 *WINAPI	D3DXVec3TransformCoordArray (D3DXVECTOR3 out, UINT outstride, const D3DXVECTOR3 in, UINT instride, const D3DXMATRIX *matrix, UINT elements)

D3DXVECTOR3 *WINAPI	D3DXVec3TransformNormal (D3DXVECTOR3 pout, const D3DXVECTOR3 pv, const D3DXMATRIX *pm)

D3DXVECTOR3 *WINAPI	D3DXVec3TransformNormalArray (D3DXVECTOR3 out, UINT outstride, const D3DXVECTOR3 in, UINT instride, const D3DXMATRIX *matrix, UINT elements)

D3DXVECTOR3 *WINAPI	D3DXVec3Unproject (D3DXVECTOR3 out, const D3DXVECTOR3 v, const D3DVIEWPORT9 viewport, const D3DXMATRIX projection, const D3DXMATRIX view, const D3DXMATRIX world)

D3DXVECTOR3 *WINAPI	D3DXVec3UnprojectArray (D3DXVECTOR3 out, UINT outstride, const D3DXVECTOR3 in, UINT instride, const D3DVIEWPORT9 viewport, const D3DXMATRIX projection, const D3DXMATRIX view, const D3DXMATRIX world, UINT elements)

D3DXVECTOR4 *WINAPI	D3DXVec4BaryCentric (D3DXVECTOR4 pout, const D3DXVECTOR4 pv1, const D3DXVECTOR4 pv2, const D3DXVECTOR4 pv3, FLOAT f, FLOAT g)

D3DXVECTOR4 *WINAPI	D3DXVec4CatmullRom (D3DXVECTOR4 pout, const D3DXVECTOR4 pv0, const D3DXVECTOR4 pv1, const D3DXVECTOR4 pv2, const D3DXVECTOR4 *pv3, FLOAT s)

D3DXVECTOR4 *WINAPI	D3DXVec4Cross (D3DXVECTOR4 pout, const D3DXVECTOR4 pv1, const D3DXVECTOR4 pv2, const D3DXVECTOR4 pv3)

D3DXVECTOR4 *WINAPI	D3DXVec4Hermite (D3DXVECTOR4 pout, const D3DXVECTOR4 pv1, const D3DXVECTOR4 pt1, const D3DXVECTOR4 pv2, const D3DXVECTOR4 *pt2, FLOAT s)

D3DXVECTOR4 *WINAPI	D3DXVec4Normalize (D3DXVECTOR4 pout, const D3DXVECTOR4 pv)

D3DXVECTOR4 *WINAPI	D3DXVec4Transform (D3DXVECTOR4 pout, const D3DXVECTOR4 pv, const D3DXMATRIX *pm)

D3DXVECTOR4 *WINAPI	D3DXVec4TransformArray (D3DXVECTOR4 out, UINT outstride, const D3DXVECTOR4 in, UINT instride, const D3DXMATRIX *matrix, UINT elements)

unsigned short	float_32_to_16 (const float in)

D3DXFLOAT16 *WINAPI	D3DXFloat32To16Array (D3DXFLOAT16 pout, const FLOAT pin, UINT n)

float	float_16_to_32 (const unsigned short in)

FLOAT *WINAPI	D3DXFloat16To32Array (FLOAT pout, const D3DXFLOAT16 pin, UINT n)

FLOAT *WINAPI	D3DXSHAdd (FLOAT out, UINT order, const FLOAT a, const FLOAT *b)

FLOAT WINAPI	D3DXSHDot (UINT order, const FLOAT a, const FLOAT b)

static void	weightedcapintegrale (FLOAT *out, UINT order, FLOAT angle)

HRESULT WINAPI	D3DXSHEvalConeLight (UINT order, const D3DXVECTOR3 dir, FLOAT radius, FLOAT Rintensity, FLOAT Gintensity, FLOAT Bintensity, FLOAT rout, FLOAT gout, FLOAT bout)

FLOAT *WINAPI	D3DXSHEvalDirection (FLOAT out, UINT order, const D3DXVECTOR3 dir)

HRESULT WINAPI	D3DXSHEvalDirectionalLight (UINT order, const D3DXVECTOR3 dir, FLOAT Rintensity, FLOAT Gintensity, FLOAT Bintensity, FLOAT Rout, FLOAT Gout, FLOAT Bout)

HRESULT WINAPI	D3DXSHEvalHemisphereLight (UINT order, const D3DXVECTOR3 dir, D3DXCOLOR top, D3DXCOLOR bottom, FLOAT rout, FLOAT gout, FLOAT bout)

HRESULT WINAPI	D3DXSHEvalSphericalLight (UINT order, const D3DXVECTOR3 dir, FLOAT radius, FLOAT Rintensity, FLOAT Gintensity, FLOAT Bintensity, FLOAT rout, FLOAT gout, FLOAT bout)

FLOAT *WINAPI	D3DXSHMultiply2 (FLOAT out, const FLOAT a, const FLOAT *b)

FLOAT *WINAPI	D3DXSHMultiply3 (FLOAT out, const FLOAT a, const FLOAT *b)

FLOAT *WINAPI	D3DXSHMultiply4 (FLOAT out, const FLOAT a, const FLOAT *b)

static void	rotate_X (FLOAT out, UINT order, FLOAT a, FLOAT in)

FLOAT *WINAPI	D3DXSHRotate (FLOAT out, UINT order, const D3DXMATRIX matrix, const FLOAT *in)

FLOAT *WINAPI	D3DXSHRotateZ (FLOAT out, UINT order, FLOAT angle, const FLOAT in)

FLOAT *WINAPI	D3DXSHScale (FLOAT out, UINT order, const FLOAT a, const FLOAT scale)

Variables
static const unsigned int	INITIAL_STACK_SIZE = 32

static const ID3DXMatrixStackVtbl	ID3DXMatrixStack_Vtbl

Function Documentation

◆ add_diff()

static D3DXQUATERNION add_diff	(	const D3DXQUATERNION *	q1,
		const D3DXQUATERNION *	q2,
		const FLOAT	add
	)

static

Definition at line 1585 of file math.c.

 {
     D3DXQUATERNION temp;
 
     temp.x = q1->x + add * q2->x;
     temp.y = q1->y + add * q2->y;
     temp.z = q1->z + add * q2->z;
     temp.w = q1->w + add * q2->w;
 
     return temp;
 }

Referenced by D3DXQuaternionSquadSetup().

◆ D3DXColorAdjustContrast()

D3DXCOLOR* WINAPI D3DXColorAdjustContrast	(	D3DXCOLOR *	pout,
		const D3DXCOLOR *	pc,
		FLOAT	s
	)

Definition at line 46 of file math.c.

 {
     TRACE("pout %p, pc %p, s %f\n", pout, pc, s);
 
     pout->r = 0.5f + s * (pc->r - 0.5f);
     pout->g = 0.5f + s * (pc->g - 0.5f);
     pout->b = 0.5f + s * (pc->b - 0.5f);
     pout->a = pc->a;
     return pout;
 }

◆ D3DXColorAdjustSaturation()

D3DXCOLOR* WINAPI D3DXColorAdjustSaturation	(	D3DXCOLOR *	pout,
		const D3DXCOLOR *	pc,
		FLOAT	s
	)

Definition at line 57 of file math.c.

 {
     FLOAT grey;
 
     TRACE("pout %p, pc %p, s %f\n", pout, pc, s);
 
     grey = pc->r * 0.2125f + pc->g * 0.7154f + pc->b * 0.0721f;
     pout->r = grey + s * (pc->r - grey);
     pout->g = grey + s * (pc->g - grey);
     pout->b = grey + s * (pc->b - grey);
     pout->a = pc->a;
     return pout;
 }

◆ D3DXCreateMatrixStack()

HRESULT WINAPI D3DXCreateMatrixStack	(	DWORD	flags,
		ID3DXMatrixStack **	stack
	)

Definition at line 1215 of file math.c.

 {
     struct ID3DXMatrixStackImpl *object;
 
     TRACE("flags %#x, stack %p.\n", flags, stack);
 
     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
     {
         *stack = NULL;
         return E_OUTOFMEMORY;
     }
     object->ID3DXMatrixStack_iface.lpVtbl = &ID3DXMatrixStack_Vtbl;
     object->ref = 1;
 
     if (!(object->stack = HeapAlloc(GetProcessHeap(), 0, INITIAL_STACK_SIZE * sizeof(*object->stack))))
     {
         HeapFree(GetProcessHeap(), 0, object);
         *stack = NULL;
         return E_OUTOFMEMORY;
     }
 
     object->current = 0;
     object->stack_size = INITIAL_STACK_SIZE;
     D3DXMatrixIdentity(&object->stack[0]);
 
     TRACE("Created matrix stack %p.\n", object);
 
     *stack = &object->ID3DXMatrixStack_iface;
     return D3D_OK;
 }

◆ D3DXFloat16To32Array()

FLOAT* WINAPI D3DXFloat16To32Array	(	FLOAT *	pout,
		const D3DXFLOAT16 *	pin,
		UINT	n
	)

Definition at line 2265 of file math.c.

 {
     unsigned int i;
 
     TRACE("pout %p, pin %p, n %u\n", pout, pin, n);
 
     for (i = 0; i < n; ++i)
     {
         pout[i] = float_16_to_32(pin[i].value);
     }
 
     return pout;
 }

Referenced by convert_component(), weld_float16_2(), and weld_float16_4().

◆ D3DXFloat32To16Array()

D3DXFLOAT16* WINAPI D3DXFloat32To16Array	(	D3DXFLOAT16 *	pout,
		const FLOAT *	pin,
		UINT	n
	)

Definition at line 2231 of file math.c.

 {
     unsigned int i;
 
     TRACE("pout %p, pin %p, n %u\n", pout, pin, n);
 
     for (i = 0; i < n; ++i)
     {
         pout[i].value = float_32_to_16(pin[i]);
     }
 
     return pout;
 }

Referenced by convert_float4().

◆ D3DXFresnelTerm()

FLOAT WINAPI D3DXFresnelTerm	(	FLOAT	costheta,
		FLOAT	refractionindex
	)

Definition at line 73 of file math.c.

 {
     FLOAT a, d, g, result;
 
     TRACE("costheta %f, refractionindex %f\n", costheta, refractionindex);
 
     g = sqrtf(refractionindex * refractionindex + costheta * costheta - 1.0f);
     a = g + costheta;
     d = g - costheta;
     result = (costheta * a - 1.0f) * (costheta * a - 1.0f) / ((costheta * d + 1.0f) * (costheta * d + 1.0f)) + 1.0f;
     result *= 0.5f * d * d / (a * a);
 
     return result;
 }

◆ D3DXMatrixAffineTransformation()

D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation	(	D3DXMATRIX *	out,
		FLOAT	scaling,
		const D3DXVECTOR3 *	rotationcenter,
		const D3DXQUATERNION *	rotation,
		const D3DXVECTOR3 *	translation
	)

Definition at line 90 of file math.c.

 {
     TRACE("out %p, scaling %f, rotationcenter %p, rotation %p, translation %p\n",
             out, scaling, rotationcenter, rotation, translation);
 
     D3DXMatrixIdentity(out);
 
     if (rotation)
     {
         FLOAT temp00, temp01, temp02, temp10, temp11, temp12, temp20, temp21, temp22;
 
         temp00 = 1.0f - 2.0f * (rotation->y * rotation->y + rotation->z * rotation->z);
         temp01 = 2.0f * (rotation->x * rotation->y + rotation->z * rotation->w);
         temp02 = 2.0f * (rotation->x * rotation->z - rotation->y * rotation->w);
         temp10 = 2.0f * (rotation->x * rotation->y - rotation->z * rotation->w);
         temp11 = 1.0f - 2.0f * (rotation->x * rotation->x + rotation->z * rotation->z);
         temp12 = 2.0f * (rotation->y * rotation->z + rotation->x * rotation->w);
         temp20 = 2.0f * (rotation->x * rotation->z + rotation->y * rotation->w);
         temp21 = 2.0f * (rotation->y * rotation->z - rotation->x * rotation->w);
         temp22 = 1.0f - 2.0f * (rotation->x * rotation->x + rotation->y * rotation->y);
 
         out->u.m[0][0] = scaling * temp00;
         out->u.m[0][1] = scaling * temp01;
         out->u.m[0][2] = scaling * temp02;
         out->u.m[1][0] = scaling * temp10;
         out->u.m[1][1] = scaling * temp11;
         out->u.m[1][2] = scaling * temp12;
         out->u.m[2][0] = scaling * temp20;
         out->u.m[2][1] = scaling * temp21;
         out->u.m[2][2] = scaling * temp22;
 
         if (rotationcenter)
         {
             out->u.m[3][0] = rotationcenter->x * (1.0f - temp00) - rotationcenter->y * temp10
                     - rotationcenter->z * temp20;
             out->u.m[3][1] = rotationcenter->y * (1.0f - temp11) - rotationcenter->x * temp01
                     - rotationcenter->z * temp21;
             out->u.m[3][2] = rotationcenter->z * (1.0f - temp22) - rotationcenter->x * temp02
                     - rotationcenter->y * temp12;
         }
     }
     else
     {
         out->u.m[0][0] = scaling;
         out->u.m[1][1] = scaling;
         out->u.m[2][2] = scaling;
     }
 
     if (translation)
     {
         out->u.m[3][0] += translation->x;
         out->u.m[3][1] += translation->y;
         out->u.m[3][2] += translation->z;
     }
 
     return out;
 }

◆ D3DXMatrixAffineTransformation2D()

D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation2D	(	D3DXMATRIX *	out,
		FLOAT	scaling,
		const D3DXVECTOR2 *	rotationcenter,
		FLOAT	rotation,
		const D3DXVECTOR2 *	translation
	)

Definition at line 149 of file math.c.

 {
     FLOAT tmp1, tmp2, s;
 
     TRACE("out %p, scaling %f, rotationcenter %p, rotation %f, translation %p\n",
             out, scaling, rotationcenter, rotation, translation);
 
     s = sinf(rotation / 2.0f);
     tmp1 = 1.0f - 2.0f * s * s;
     tmp2 = 2.0f * s * cosf(rotation / 2.0f);
 
     D3DXMatrixIdentity(out);
     out->u.m[0][0] = scaling * tmp1;
     out->u.m[0][1] = scaling * tmp2;
     out->u.m[1][0] = -scaling * tmp2;
     out->u.m[1][1] = scaling * tmp1;
 
     if (rotationcenter)
     {
         FLOAT x, y;
 
         x = rotationcenter->x;
         y = rotationcenter->y;
 
         out->u.m[3][0] = y * tmp2 - x * tmp1 + x;
         out->u.m[3][1] = -x * tmp2 - y * tmp1 + y;
     }
 
     if (translation)
     {
         out->u.m[3][0] += translation->x;
         out->u.m[3][1] += translation->y;
     }
 
     return out;
 }

◆ D3DXMatrixDecompose()

HRESULT WINAPI D3DXMatrixDecompose	(	D3DXVECTOR3 *	poutscale,
		D3DXQUATERNION *	poutrotation,
		D3DXVECTOR3 *	pouttranslation,
		const D3DXMATRIX *	pm
	)

Definition at line 187 of file math.c.

 {
     D3DXMATRIX normalized;
     D3DXVECTOR3 vec;
 
     TRACE("poutscale %p, poutrotation %p, pouttranslation %p, pm %p\n", poutscale, poutrotation, pouttranslation, pm);
 
     /*Compute the scaling part.*/
     vec.x=pm->u.m[0][0];
     vec.y=pm->u.m[0][1];
     vec.z=pm->u.m[0][2];
     poutscale->x=D3DXVec3Length(&vec);
 
     vec.x=pm->u.m[1][0];
     vec.y=pm->u.m[1][1];
     vec.z=pm->u.m[1][2];
     poutscale->y=D3DXVec3Length(&vec);
 
     vec.x=pm->u.m[2][0];
     vec.y=pm->u.m[2][1];
     vec.z=pm->u.m[2][2];
     poutscale->z=D3DXVec3Length(&vec);
 
     /*Compute the translation part.*/
     pouttranslation->x=pm->u.m[3][0];
     pouttranslation->y=pm->u.m[3][1];
     pouttranslation->z=pm->u.m[3][2];
 
     /*Let's calculate the rotation now*/
     if ( (poutscale->x == 0.0f) || (poutscale->y == 0.0f) || (poutscale->z == 0.0f) ) return D3DERR_INVALIDCALL;
 
     normalized.u.m[0][0]=pm->u.m[0][0]/poutscale->x;
     normalized.u.m[0][1]=pm->u.m[0][1]/poutscale->x;
     normalized.u.m[0][2]=pm->u.m[0][2]/poutscale->x;
     normalized.u.m[1][0]=pm->u.m[1][0]/poutscale->y;
     normalized.u.m[1][1]=pm->u.m[1][1]/poutscale->y;
     normalized.u.m[1][2]=pm->u.m[1][2]/poutscale->y;
     normalized.u.m[2][0]=pm->u.m[2][0]/poutscale->z;
     normalized.u.m[2][1]=pm->u.m[2][1]/poutscale->z;
     normalized.u.m[2][2]=pm->u.m[2][2]/poutscale->z;
 
     D3DXQuaternionRotationMatrix(poutrotation,&normalized);
     return S_OK;
 }

◆ D3DXMatrixDeterminant()

FLOAT WINAPI D3DXMatrixDeterminant ( const D3DXMATRIX * pm )

Definition at line 232 of file math.c.

 {
     FLOAT t[3], v[4];
 
     TRACE("pm %p\n", pm);
 
     t[0] = pm->u.m[2][2] * pm->u.m[3][3] - pm->u.m[2][3] * pm->u.m[3][2];
     t[1] = pm->u.m[1][2] * pm->u.m[3][3] - pm->u.m[1][3] * pm->u.m[3][2];
     t[2] = pm->u.m[1][2] * pm->u.m[2][3] - pm->u.m[1][3] * pm->u.m[2][2];
     v[0] = pm->u.m[1][1] * t[0] - pm->u.m[2][1] * t[1] + pm->u.m[3][1] * t[2];
     v[1] = -pm->u.m[1][0] * t[0] + pm->u.m[2][0] * t[1] - pm->u.m[3][0] * t[2];
 
     t[0] = pm->u.m[1][0] * pm->u.m[2][1] - pm->u.m[2][0] * pm->u.m[1][1];
     t[1] = pm->u.m[1][0] * pm->u.m[3][1] - pm->u.m[3][0] * pm->u.m[1][1];
     t[2] = pm->u.m[2][0] * pm->u.m[3][1] - pm->u.m[3][0] * pm->u.m[2][1];
     v[2] = pm->u.m[3][3] * t[0] - pm->u.m[2][3] * t[1] + pm->u.m[1][3] * t[2];
     v[3] = -pm->u.m[3][2] * t[0] + pm->u.m[2][2] * t[1] - pm->u.m[1][2] * t[2];
 
     return pm->u.m[0][0] * v[0] + pm->u.m[0][1] * v[1] +
         pm->u.m[0][2] * v[2] + pm->u.m[0][3] * v[3];
 }

◆ D3DXMatrixInverse()

D3DXMATRIX* WINAPI D3DXMatrixInverse	(	D3DXMATRIX *	pout,
		FLOAT *	pdeterminant,
		const D3DXMATRIX *	pm
	)

Definition at line 254 of file math.c.

 {
     FLOAT det, t[3], v[16];
     UINT i, j;
 
     TRACE("pout %p, pdeterminant %p, pm %p\n", pout, pdeterminant, pm);
 
     t[0] = pm->u.m[2][2] * pm->u.m[3][3] - pm->u.m[2][3] * pm->u.m[3][2];
     t[1] = pm->u.m[1][2] * pm->u.m[3][3] - pm->u.m[1][3] * pm->u.m[3][2];
     t[2] = pm->u.m[1][2] * pm->u.m[2][3] - pm->u.m[1][3] * pm->u.m[2][2];
     v[0] = pm->u.m[1][1] * t[0] - pm->u.m[2][1] * t[1] + pm->u.m[3][1] * t[2];
     v[4] = -pm->u.m[1][0] * t[0] + pm->u.m[2][0] * t[1] - pm->u.m[3][0] * t[2];
 
     t[0] = pm->u.m[1][0] * pm->u.m[2][1] - pm->u.m[2][0] * pm->u.m[1][1];
     t[1] = pm->u.m[1][0] * pm->u.m[3][1] - pm->u.m[3][0] * pm->u.m[1][1];
     t[2] = pm->u.m[2][0] * pm->u.m[3][1] - pm->u.m[3][0] * pm->u.m[2][1];
     v[8] = pm->u.m[3][3] * t[0] - pm->u.m[2][3] * t[1] + pm->u.m[1][3] * t[2];
     v[12] = -pm->u.m[3][2] * t[0] + pm->u.m[2][2] * t[1] - pm->u.m[1][2] * t[2];
 
     det = pm->u.m[0][0] * v[0] + pm->u.m[0][1] * v[4] +
         pm->u.m[0][2] * v[8] + pm->u.m[0][3] * v[12];
     if (det == 0.0f)
         return NULL;
     if (pdeterminant)
         *pdeterminant = det;
 
     t[0] = pm->u.m[2][2] * pm->u.m[3][3] - pm->u.m[2][3] * pm->u.m[3][2];
     t[1] = pm->u.m[0][2] * pm->u.m[3][3] - pm->u.m[0][3] * pm->u.m[3][2];
     t[2] = pm->u.m[0][2] * pm->u.m[2][3] - pm->u.m[0][3] * pm->u.m[2][2];
     v[1] = -pm->u.m[0][1] * t[0] + pm->u.m[2][1] * t[1] - pm->u.m[3][1] * t[2];
     v[5] = pm->u.m[0][0] * t[0] - pm->u.m[2][0] * t[1] + pm->u.m[3][0] * t[2];
 
     t[0] = pm->u.m[0][0] * pm->u.m[2][1] - pm->u.m[2][0] * pm->u.m[0][1];
     t[1] = pm->u.m[3][0] * pm->u.m[0][1] - pm->u.m[0][0] * pm->u.m[3][1];
     t[2] = pm->u.m[2][0] * pm->u.m[3][1] - pm->u.m[3][0] * pm->u.m[2][1];
     v[9] = -pm->u.m[3][3] * t[0] - pm->u.m[2][3] * t[1]- pm->u.m[0][3] * t[2];
     v[13] = pm->u.m[3][2] * t[0] + pm->u.m[2][2] * t[1] + pm->u.m[0][2] * t[2];
 
     t[0] = pm->u.m[1][2] * pm->u.m[3][3] - pm->u.m[1][3] * pm->u.m[3][2];
     t[1] = pm->u.m[0][2] * pm->u.m[3][3] - pm->u.m[0][3] * pm->u.m[3][2];
     t[2] = pm->u.m[0][2] * pm->u.m[1][3] - pm->u.m[0][3] * pm->u.m[1][2];
     v[2] = pm->u.m[0][1] * t[0] - pm->u.m[1][1] * t[1] + pm->u.m[3][1] * t[2];
     v[6] = -pm->u.m[0][0] * t[0] + pm->u.m[1][0] * t[1] - pm->u.m[3][0] * t[2];
 
     t[0] = pm->u.m[0][0] * pm->u.m[1][1] - pm->u.m[1][0] * pm->u.m[0][1];
     t[1] = pm->u.m[3][0] * pm->u.m[0][1] - pm->u.m[0][0] * pm->u.m[3][1];
     t[2] = pm->u.m[1][0] * pm->u.m[3][1] - pm->u.m[3][0] * pm->u.m[1][1];
     v[10] = pm->u.m[3][3] * t[0] + pm->u.m[1][3] * t[1] + pm->u.m[0][3] * t[2];
     v[14] = -pm->u.m[3][2] * t[0] - pm->u.m[1][2] * t[1] - pm->u.m[0][2] * t[2];
 
     t[0] = pm->u.m[1][2] * pm->u.m[2][3] - pm->u.m[1][3] * pm->u.m[2][2];
     t[1] = pm->u.m[0][2] * pm->u.m[2][3] - pm->u.m[0][3] * pm->u.m[2][2];
     t[2] = pm->u.m[0][2] * pm->u.m[1][3] - pm->u.m[0][3] * pm->u.m[1][2];
     v[3] = -pm->u.m[0][1] * t[0] + pm->u.m[1][1] * t[1] - pm->u.m[2][1] * t[2];
     v[7] = pm->u.m[0][0] * t[0] - pm->u.m[1][0] * t[1] + pm->u.m[2][0] * t[2];
 
     v[11] = -pm->u.m[0][0] * (pm->u.m[1][1] * pm->u.m[2][3] - pm->u.m[1][3] * pm->u.m[2][1]) +
         pm->u.m[1][0] * (pm->u.m[0][1] * pm->u.m[2][3] - pm->u.m[0][3] * pm->u.m[2][1]) -
         pm->u.m[2][0] * (pm->u.m[0][1] * pm->u.m[1][3] - pm->u.m[0][3] * pm->u.m[1][1]);
 
     v[15] = pm->u.m[0][0] * (pm->u.m[1][1] * pm->u.m[2][2] - pm->u.m[1][2] * pm->u.m[2][1]) -
         pm->u.m[1][0] * (pm->u.m[0][1] * pm->u.m[2][2] - pm->u.m[0][2] * pm->u.m[2][1]) +
         pm->u.m[2][0] * (pm->u.m[0][1] * pm->u.m[1][2] - pm->u.m[0][2] * pm->u.m[1][1]);
 
     det = 1.0f / det;
 
     for (i = 0; i < 4; i++)
         for (j = 0; j < 4; j++)
             pout->u.m[i][j] = v[4 * i + j] * det;
 
     return pout;
 }

Referenced by d3dx9_skin_info_UpdateSkinnedMesh(), D3DXIntersectTri(), and D3DXVec3Unproject().

◆ D3DXMatrixLookAtLH()

D3DXMATRIX* WINAPI D3DXMatrixLookAtLH	(	D3DXMATRIX *	out,
		const D3DXVECTOR3 *	eye,
		const D3DXVECTOR3 *	at,
		const D3DXVECTOR3 *	up
	)

Definition at line 327 of file math.c.

 {
     D3DXVECTOR3 right, upn, vec;
 
     TRACE("out %p, eye %p, at %p, up %p\n", out, eye, at, up);
 
     D3DXVec3Subtract(&vec, at, eye);
     D3DXVec3Normalize(&vec, &vec);
     D3DXVec3Cross(&right, up, &vec);
     D3DXVec3Cross(&upn, &vec, &right);
     D3DXVec3Normalize(&right, &right);
     D3DXVec3Normalize(&upn, &upn);
     out->u.m[0][0] = right.x;
     out->u.m[1][0] = right.y;
     out->u.m[2][0] = right.z;
     out->u.m[3][0] = -D3DXVec3Dot(&right, eye);
     out->u.m[0][1] = upn.x;
     out->u.m[1][1] = upn.y;
     out->u.m[2][1] = upn.z;
     out->u.m[3][1] = -D3DXVec3Dot(&upn, eye);
     out->u.m[0][2] = vec.x;
     out->u.m[1][2] = vec.y;
     out->u.m[2][2] = vec.z;
     out->u.m[3][2] = -D3DXVec3Dot(&vec, eye);
     out->u.m[0][3] = 0.0f;
     out->u.m[1][3] = 0.0f;
     out->u.m[2][3] = 0.0f;
     out->u.m[3][3] = 1.0f;
 
     return out;
 }

◆ D3DXMatrixLookAtRH()

D3DXMATRIX* WINAPI D3DXMatrixLookAtRH	(	D3DXMATRIX *	out,
		const D3DXVECTOR3 *	eye,
		const D3DXVECTOR3 *	at,
		const D3DXVECTOR3 *	up
	)

Definition at line 360 of file math.c.

 {
     D3DXVECTOR3 right, upn, vec;
 
     TRACE("out %p, eye %p, at %p, up %p\n", out, eye, at, up);
 
     D3DXVec3Subtract(&vec, at, eye);
     D3DXVec3Normalize(&vec, &vec);
     D3DXVec3Cross(&right, up, &vec);
     D3DXVec3Cross(&upn, &vec, &right);
     D3DXVec3Normalize(&right, &right);
     D3DXVec3Normalize(&upn, &upn);
     out->u.m[0][0] = -right.x;
     out->u.m[1][0] = -right.y;
     out->u.m[2][0] = -right.z;
     out->u.m[3][0] = D3DXVec3Dot(&right, eye);
     out->u.m[0][1] = upn.x;
     out->u.m[1][1] = upn.y;
     out->u.m[2][1] = upn.z;
     out->u.m[3][1] = -D3DXVec3Dot(&upn, eye);
     out->u.m[0][2] = -vec.x;
     out->u.m[1][2] = -vec.y;
     out->u.m[2][2] = -vec.z;
     out->u.m[3][2] = D3DXVec3Dot(&vec, eye);
     out->u.m[0][3] = 0.0f;
     out->u.m[1][3] = 0.0f;
     out->u.m[2][3] = 0.0f;
     out->u.m[3][3] = 1.0f;
 
     return out;
 }

◆ D3DXMatrixMultiply()

D3DXMATRIX* WINAPI D3DXMatrixMultiply	(	D3DXMATRIX *	pout,
		const D3DXMATRIX *	pm1,
		const D3DXMATRIX *	pm2
	)

Definition at line 393 of file math.c.

 {
     D3DXMATRIX out;
     int i,j;
 
     TRACE("pout %p, pm1 %p, pm2 %p\n", pout, pm1, pm2);
 
     for (i=0; i<4; i++)
     {
         for (j=0; j<4; j++)
         {
             out.u.m[i][j] = pm1->u.m[i][0] * pm2->u.m[0][j] + pm1->u.m[i][1] * pm2->u.m[1][j] + pm1->u.m[i][2] * pm2->u.m[2][j] + pm1->u.m[i][3] * pm2->u.m[3][j];
         }
     }
 
     *pout = out;
     return pout;
 }

◆ D3DXMatrixMultiplyTranspose()

D3DXMATRIX* WINAPI D3DXMatrixMultiplyTranspose	(	D3DXMATRIX *	pout,
		const D3DXMATRIX *	pm1,
		const D3DXMATRIX *	pm2
	)

Definition at line 412 of file math.c.

 {
     D3DXMATRIX temp;
     int i, j;
 
     TRACE("pout %p, pm1 %p, pm2 %p\n", pout, pm1, pm2);
 
     for (i = 0; i < 4; i++)
         for (j = 0; j < 4; j++)
             temp.u.m[j][i] = pm1->u.m[i][0] * pm2->u.m[0][j] + pm1->u.m[i][1] * pm2->u.m[1][j] + pm1->u.m[i][2] * pm2->u.m[2][j] + pm1->u.m[i][3] * pm2->u.m[3][j];
 
     *pout = temp;
     return pout;
 }

◆ D3DXMatrixOrthoLH()

D3DXMATRIX* WINAPI D3DXMatrixOrthoLH	(	D3DXMATRIX *	pout,
		FLOAT	w,
		FLOAT	h,
		FLOAT	zn,
		FLOAT	zf
	)

Definition at line 427 of file math.c.

 {
     TRACE("pout %p, w %f, h %f, zn %f, zf %f\n", pout, w, h, zn, zf);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 2.0f / w;
     pout->u.m[1][1] = 2.0f / h;
     pout->u.m[2][2] = 1.0f / (zf - zn);
     pout->u.m[3][2] = zn / (zn - zf);
     return pout;
 }

◆ D3DXMatrixOrthoOffCenterLH()

D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterLH	(	D3DXMATRIX *	pout,
		FLOAT	l,
		FLOAT	r,
		FLOAT	b,
		FLOAT	t,
		FLOAT	zn,
		FLOAT	zf
	)

Definition at line 439 of file math.c.

 {
     TRACE("pout %p, l %f, r %f, b %f, t %f, zn %f, zf %f\n", pout, l, r, b, t, zn, zf);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 2.0f / (r - l);
     pout->u.m[1][1] = 2.0f / (t - b);
     pout->u.m[2][2] = 1.0f / (zf -zn);
     pout->u.m[3][0] = -1.0f -2.0f *l / (r - l);
     pout->u.m[3][1] = 1.0f + 2.0f * t / (b - t);
     pout->u.m[3][2] = zn / (zn -zf);
     return pout;
 }

Referenced by d3dx9_line_Begin(), and set_states().

◆ D3DXMatrixOrthoOffCenterRH()

D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterRH	(	D3DXMATRIX *	pout,
		FLOAT	l,
		FLOAT	r,
		FLOAT	b,
		FLOAT	t,
		FLOAT	zn,
		FLOAT	zf
	)

Definition at line 453 of file math.c.

 {
     TRACE("pout %p, l %f, r %f, b %f, t %f, zn %f, zf %f\n", pout, l, r, b, t, zn, zf);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 2.0f / (r - l);
     pout->u.m[1][1] = 2.0f / (t - b);
     pout->u.m[2][2] = 1.0f / (zn -zf);
     pout->u.m[3][0] = -1.0f -2.0f *l / (r - l);
     pout->u.m[3][1] = 1.0f + 2.0f * t / (b - t);
     pout->u.m[3][2] = zn / (zn -zf);
     return pout;
 }

◆ D3DXMatrixOrthoRH()

D3DXMATRIX* WINAPI D3DXMatrixOrthoRH	(	D3DXMATRIX *	pout,
		FLOAT	w,
		FLOAT	h,
		FLOAT	zn,
		FLOAT	zf
	)

Definition at line 467 of file math.c.

 {
     TRACE("pout %p, w %f, h %f, zn %f, zf %f\n", pout, w, h, zn, zf);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 2.0f / w;
     pout->u.m[1][1] = 2.0f / h;
     pout->u.m[2][2] = 1.0f / (zn - zf);
     pout->u.m[3][2] = zn / (zn - zf);
     return pout;
 }

◆ D3DXMatrixPerspectiveFovLH()

D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovLH	(	D3DXMATRIX *	pout,
		FLOAT	fovy,
		FLOAT	aspect,
		FLOAT	zn,
		FLOAT	zf
	)

Definition at line 479 of file math.c.

 {
     TRACE("pout %p, fovy %f, aspect %f, zn %f, zf %f\n", pout, fovy, aspect, zn, zf);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 1.0f / (aspect * tanf(fovy/2.0f));
     pout->u.m[1][1] = 1.0f / tanf(fovy/2.0f);
     pout->u.m[2][2] = zf / (zf - zn);
     pout->u.m[2][3] = 1.0f;
     pout->u.m[3][2] = (zf * zn) / (zn - zf);
     pout->u.m[3][3] = 0.0f;
     return pout;
 }

◆ D3DXMatrixPerspectiveFovRH()

D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovRH	(	D3DXMATRIX *	pout,
		FLOAT	fovy,
		FLOAT	aspect,
		FLOAT	zn,
		FLOAT	zf
	)

Definition at line 493 of file math.c.

 {
     TRACE("pout %p, fovy %f, aspect %f, zn %f, zf %f\n", pout, fovy, aspect, zn, zf);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 1.0f / (aspect * tanf(fovy/2.0f));
     pout->u.m[1][1] = 1.0f / tanf(fovy/2.0f);
     pout->u.m[2][2] = zf / (zn - zf);
     pout->u.m[2][3] = -1.0f;
     pout->u.m[3][2] = (zf * zn) / (zn - zf);
     pout->u.m[3][3] = 0.0f;
     return pout;
 }

◆ D3DXMatrixPerspectiveLH()

D3DXMATRIX* WINAPI D3DXMatrixPerspectiveLH	(	D3DXMATRIX *	pout,
		FLOAT	w,
		FLOAT	h,
		FLOAT	zn,
		FLOAT	zf
	)

Definition at line 507 of file math.c.

 {
     TRACE("pout %p, w %f, h %f, zn %f, zf %f\n", pout, w, h, zn, zf);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 2.0f * zn / w;
     pout->u.m[1][1] = 2.0f * zn / h;
     pout->u.m[2][2] = zf / (zf - zn);
     pout->u.m[3][2] = (zn * zf) / (zn - zf);
     pout->u.m[2][3] = 1.0f;
     pout->u.m[3][3] = 0.0f;
     return pout;
 }

◆ D3DXMatrixPerspectiveOffCenterLH()

D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterLH	(	D3DXMATRIX *	pout,
		FLOAT	l,
		FLOAT	r,
		FLOAT	b,
		FLOAT	t,
		FLOAT	zn,
		FLOAT	zf
	)

Definition at line 521 of file math.c.

 {
     TRACE("pout %p, l %f, r %f, b %f, t %f, zn %f, zf %f\n", pout, l, r, b, t, zn, zf);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 2.0f * zn / (r - l);
     pout->u.m[1][1] = -2.0f * zn / (b - t);
     pout->u.m[2][0] = -1.0f - 2.0f * l / (r - l);
     pout->u.m[2][1] = 1.0f + 2.0f * t / (b - t);
     pout->u.m[2][2] = - zf / (zn - zf);
     pout->u.m[3][2] = (zn * zf) / (zn -zf);
     pout->u.m[2][3] = 1.0f;
     pout->u.m[3][3] = 0.0f;
     return pout;
 }

◆ D3DXMatrixPerspectiveOffCenterRH()

D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterRH	(	D3DXMATRIX *	pout,
		FLOAT	l,
		FLOAT	r,
		FLOAT	b,
		FLOAT	t,
		FLOAT	zn,
		FLOAT	zf
	)

Definition at line 537 of file math.c.

 {
     TRACE("pout %p, l %f, r %f, b %f, t %f, zn %f, zf %f\n", pout, l, r, b, t, zn, zf);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 2.0f * zn / (r - l);
     pout->u.m[1][1] = -2.0f * zn / (b - t);
     pout->u.m[2][0] = 1.0f + 2.0f * l / (r - l);
     pout->u.m[2][1] = -1.0f -2.0f * t / (b - t);
     pout->u.m[2][2] = zf / (zn - zf);
     pout->u.m[3][2] = (zn * zf) / (zn -zf);
     pout->u.m[2][3] = -1.0f;
     pout->u.m[3][3] = 0.0f;
     return pout;
 }

◆ D3DXMatrixPerspectiveRH()

D3DXMATRIX* WINAPI D3DXMatrixPerspectiveRH	(	D3DXMATRIX *	pout,
		FLOAT	w,
		FLOAT	h,
		FLOAT	zn,
		FLOAT	zf
	)

Definition at line 553 of file math.c.

 {
     TRACE("pout %p, w %f, h %f, zn %f, zf %f\n", pout, w, h, zn, zf);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 2.0f * zn / w;
     pout->u.m[1][1] = 2.0f * zn / h;
     pout->u.m[2][2] = zf / (zn - zf);
     pout->u.m[3][2] = (zn * zf) / (zn - zf);
     pout->u.m[2][3] = -1.0f;
     pout->u.m[3][3] = 0.0f;
     return pout;
 }

◆ D3DXMatrixReflect()

D3DXMATRIX* WINAPI D3DXMatrixReflect	(	D3DXMATRIX *	pout,
		const D3DXPLANE *	pplane
	)

Definition at line 567 of file math.c.

 {
     D3DXPLANE Nplane;
 
     TRACE("pout %p, pplane %p\n", pout, pplane);
 
     D3DXPlaneNormalize(&Nplane, pplane);
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 1.0f - 2.0f * Nplane.a * Nplane.a;
     pout->u.m[0][1] = -2.0f * Nplane.a * Nplane.b;
     pout->u.m[0][2] = -2.0f * Nplane.a * Nplane.c;
     pout->u.m[1][0] = -2.0f * Nplane.a * Nplane.b;
     pout->u.m[1][1] = 1.0f - 2.0f * Nplane.b * Nplane.b;
     pout->u.m[1][2] = -2.0f * Nplane.b * Nplane.c;
     pout->u.m[2][0] = -2.0f * Nplane.c * Nplane.a;
     pout->u.m[2][1] = -2.0f * Nplane.c * Nplane.b;
     pout->u.m[2][2] = 1.0f - 2.0f * Nplane.c * Nplane.c;
     pout->u.m[3][0] = -2.0f * Nplane.d * Nplane.a;
     pout->u.m[3][1] = -2.0f * Nplane.d * Nplane.b;
     pout->u.m[3][2] = -2.0f * Nplane.d * Nplane.c;
     return pout;
 }

◆ D3DXMatrixRotationAxis()

D3DXMATRIX* WINAPI D3DXMatrixRotationAxis	(	D3DXMATRIX *	out,
		const D3DXVECTOR3 *	v,
		FLOAT	angle
	)

Definition at line 590 of file math.c.

 {
     D3DXVECTOR3 nv;
     FLOAT sangle, cangle, cdiff;
 
     TRACE("out %p, v %p, angle %f\n", out, v, angle);
 
     D3DXVec3Normalize(&nv, v);
     sangle = sinf(angle);
     cangle = cosf(angle);
     cdiff = 1.0f - cangle;
 
     out->u.m[0][0] = cdiff * nv.x * nv.x + cangle;
     out->u.m[1][0] = cdiff * nv.x * nv.y - sangle * nv.z;
     out->u.m[2][0] = cdiff * nv.x * nv.z + sangle * nv.y;
     out->u.m[3][0] = 0.0f;
     out->u.m[0][1] = cdiff * nv.y * nv.x + sangle * nv.z;
     out->u.m[1][1] = cdiff * nv.y * nv.y + cangle;
     out->u.m[2][1] = cdiff * nv.y * nv.z - sangle * nv.x;
     out->u.m[3][1] = 0.0f;
     out->u.m[0][2] = cdiff * nv.z * nv.x - sangle * nv.y;
     out->u.m[1][2] = cdiff * nv.z * nv.y + sangle * nv.x;
     out->u.m[2][2] = cdiff * nv.z * nv.z + cangle;
     out->u.m[3][2] = 0.0f;
     out->u.m[0][3] = 0.0f;
     out->u.m[1][3] = 0.0f;
     out->u.m[2][3] = 0.0f;
     out->u.m[3][3] = 1.0f;
 
     return out;
 }

Referenced by ID3DXMatrixStackImpl_RotateAxis(), and ID3DXMatrixStackImpl_RotateAxisLocal().

◆ D3DXMatrixRotationQuaternion()

D3DXMATRIX* WINAPI D3DXMatrixRotationQuaternion	(	D3DXMATRIX *	pout,
		const D3DXQUATERNION *	pq
	)

Definition at line 622 of file math.c.

 {
     TRACE("pout %p, pq %p\n", pout, pq);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = 1.0f - 2.0f * (pq->y * pq->y + pq->z * pq->z);
     pout->u.m[0][1] = 2.0f * (pq->x *pq->y + pq->z * pq->w);
     pout->u.m[0][2] = 2.0f * (pq->x * pq->z - pq->y * pq->w);
     pout->u.m[1][0] = 2.0f * (pq->x * pq->y - pq->z * pq->w);
     pout->u.m[1][1] = 1.0f - 2.0f * (pq->x * pq->x + pq->z * pq->z);
     pout->u.m[1][2] = 2.0f * (pq->y *pq->z + pq->x *pq->w);
     pout->u.m[2][0] = 2.0f * (pq->x * pq->z + pq->y * pq->w);
     pout->u.m[2][1] = 2.0f * (pq->y *pq->z - pq->x *pq->w);
     pout->u.m[2][2] = 1.0f - 2.0f * (pq->x * pq->x + pq->y * pq->y);
     return pout;
 }

Referenced by D3DXMatrixTransformation().

◆ D3DXMatrixRotationX()

D3DXMATRIX* WINAPI D3DXMatrixRotationX	(	D3DXMATRIX *	pout,
		FLOAT	angle
	)

Definition at line 639 of file math.c.

 {
     TRACE("pout %p, angle %f\n", pout, angle);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[1][1] = cosf(angle);
     pout->u.m[2][2] = cosf(angle);
     pout->u.m[1][2] = sinf(angle);
     pout->u.m[2][1] = -sinf(angle);
     return pout;
 }

◆ D3DXMatrixRotationY()

D3DXMATRIX* WINAPI D3DXMatrixRotationY	(	D3DXMATRIX *	pout,
		FLOAT	angle
	)

Definition at line 651 of file math.c.

 {
     TRACE("pout %p, angle %f\n", pout, angle);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = cosf(angle);
     pout->u.m[2][2] = cosf(angle);
     pout->u.m[0][2] = -sinf(angle);
     pout->u.m[2][0] = sinf(angle);
     return pout;
 }

◆ D3DXMatrixRotationYawPitchRoll()

D3DXMATRIX* WINAPI D3DXMatrixRotationYawPitchRoll	(	D3DXMATRIX *	out,
		FLOAT	yaw,
		FLOAT	pitch,
		FLOAT	roll
	)

Definition at line 663 of file math.c.

 {
     FLOAT sroll, croll, spitch, cpitch, syaw, cyaw;
 
     TRACE("out %p, yaw %f, pitch %f, roll %f\n", out, yaw, pitch, roll);
 
     sroll = sinf(roll);
     croll = cosf(roll);
     spitch = sinf(pitch);
     cpitch = cosf(pitch);
     syaw = sinf(yaw);
     cyaw = cosf(yaw);
 
     out->u.m[0][0] = sroll * spitch * syaw + croll * cyaw;
     out->u.m[0][1] = sroll * cpitch;
     out->u.m[0][2] = sroll * spitch * cyaw - croll * syaw;
     out->u.m[0][3] = 0.0f;
     out->u.m[1][0] = croll * spitch * syaw - sroll * cyaw;
     out->u.m[1][1] = croll * cpitch;
     out->u.m[1][2] = croll * spitch * cyaw + sroll * syaw;
     out->u.m[1][3] = 0.0f;
     out->u.m[2][0] = cpitch * syaw;
     out->u.m[2][1] = -spitch;
     out->u.m[2][2] = cpitch * cyaw;
     out->u.m[2][3] = 0.0f;
     out->u.m[3][0] = 0.0f;
     out->u.m[3][1] = 0.0f;
     out->u.m[3][2] = 0.0f;
     out->u.m[3][3] = 1.0f;
 
     return out;
 }

Referenced by ID3DXMatrixStackImpl_RotateYawPitchRoll(), and ID3DXMatrixStackImpl_RotateYawPitchRollLocal().

◆ D3DXMatrixRotationZ()

D3DXMATRIX* WINAPI D3DXMatrixRotationZ	(	D3DXMATRIX *	pout,
		FLOAT	angle
	)

Definition at line 696 of file math.c.

 {
     TRACE("pout %p, angle %f\n", pout, angle);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = cosf(angle);
     pout->u.m[1][1] = cosf(angle);
     pout->u.m[0][1] = sinf(angle);
     pout->u.m[1][0] = -sinf(angle);
     return pout;
 }

◆ D3DXMatrixScaling()

D3DXMATRIX* WINAPI D3DXMatrixScaling	(	D3DXMATRIX *	pout,
		FLOAT	sx,
		FLOAT	sy,
		FLOAT	sz
	)

Definition at line 708 of file math.c.

 {
     TRACE("pout %p, sx %f, sy %f, sz %f\n", pout, sx, sy, sz);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[0][0] = sx;
     pout->u.m[1][1] = sy;
     pout->u.m[2][2] = sz;
     return pout;
 }

Referenced by D3DXMatrixTransformation(), ID3DXMatrixStackImpl_Scale(), and ID3DXMatrixStackImpl_ScaleLocal().

◆ D3DXMatrixShadow()

D3DXMATRIX* WINAPI D3DXMatrixShadow	(	D3DXMATRIX *	pout,
		const D3DXVECTOR4 *	plight,
		const D3DXPLANE *	pplane
	)

Definition at line 719 of file math.c.

 {
     D3DXPLANE Nplane;
     FLOAT dot;
 
     TRACE("pout %p, plight %p, pplane %p\n", pout, plight, pplane);
 
     D3DXPlaneNormalize(&Nplane, pplane);
     dot = D3DXPlaneDot(&Nplane, plight);
     pout->u.m[0][0] = dot - Nplane.a * plight->x;
     pout->u.m[0][1] = -Nplane.a * plight->y;
     pout->u.m[0][2] = -Nplane.a * plight->z;
     pout->u.m[0][3] = -Nplane.a * plight->w;
     pout->u.m[1][0] = -Nplane.b * plight->x;
     pout->u.m[1][1] = dot - Nplane.b * plight->y;
     pout->u.m[1][2] = -Nplane.b * plight->z;
     pout->u.m[1][3] = -Nplane.b * plight->w;
     pout->u.m[2][0] = -Nplane.c * plight->x;
     pout->u.m[2][1] = -Nplane.c * plight->y;
     pout->u.m[2][2] = dot - Nplane.c * plight->z;
     pout->u.m[2][3] = -Nplane.c * plight->w;
     pout->u.m[3][0] = -Nplane.d * plight->x;
     pout->u.m[3][1] = -Nplane.d * plight->y;
     pout->u.m[3][2] = -Nplane.d * plight->z;
     pout->u.m[3][3] = dot - Nplane.d * plight->w;
     return pout;
 }

◆ D3DXMatrixTransformation()

D3DXMATRIX* WINAPI D3DXMatrixTransformation	(	D3DXMATRIX *	pout,
		const D3DXVECTOR3 *	pscalingcenter,
		const D3DXQUATERNION *	pscalingrotation,
		const D3DXVECTOR3 *	pscaling,
		const D3DXVECTOR3 *	protationcenter,
		const D3DXQUATERNION *	protation,
		const D3DXVECTOR3 *	ptranslation
	)

Definition at line 747 of file math.c.

 {
     D3DXMATRIX m1, m2, m3, m4, m5, m6, m7;
     D3DXQUATERNION prc;
     D3DXVECTOR3 psc, pt;
 
     TRACE("pout %p, pscalingcenter %p, pscalingrotation %p, pscaling %p, protationcentr %p, protation %p, ptranslation %p\n",
         pout, pscalingcenter, pscalingrotation, pscaling, protationcenter, protation, ptranslation);
 
     if ( !pscalingcenter )
     {
         psc.x = 0.0f;
         psc.y = 0.0f;
         psc.z = 0.0f;
     }
     else
     {
         psc.x = pscalingcenter->x;
         psc.y = pscalingcenter->y;
         psc.z = pscalingcenter->z;
     }
 
     if ( !protationcenter )
     {
         prc.x = 0.0f;
         prc.y = 0.0f;
         prc.z = 0.0f;
     }
     else
     {
         prc.x = protationcenter->x;
         prc.y = protationcenter->y;
         prc.z = protationcenter->z;
     }
 
     if ( !ptranslation )
     {
         pt.x = 0.0f;
         pt.y = 0.0f;
         pt.z = 0.0f;
     }
     else
     {
         pt.x = ptranslation->x;
         pt.y = ptranslation->y;
         pt.z = ptranslation->z;
     }
 
     D3DXMatrixTranslation(&m1, -psc.x, -psc.y, -psc.z);
 
     if ( !pscalingrotation || !pscaling )
     {
         D3DXMatrixIdentity(&m2);
         D3DXMatrixIdentity(&m4);
     }
     else
     {
         D3DXQUATERNION temp;
 
         D3DXMatrixRotationQuaternion(&m4, pscalingrotation);
         temp.w =  pscalingrotation->w;
         temp.x = -pscalingrotation->x;
         temp.y = -pscalingrotation->y;
         temp.z = -pscalingrotation->z;
         D3DXMatrixRotationQuaternion(&m2, &temp);
     }
 
     if ( !pscaling )
         D3DXMatrixIdentity(&m3);
     else
         D3DXMatrixScaling(&m3, pscaling->x, pscaling->y, pscaling->z);
 
     if ( !protation )
         D3DXMatrixIdentity(&m6);
     else
         D3DXMatrixRotationQuaternion(&m6, protation);
 
     D3DXMatrixTranslation(&m5, psc.x - prc.x, psc.y - prc.y, psc.z - prc.z);
     D3DXMatrixTranslation(&m7, prc.x + pt.x, prc.y + pt.y, prc.z + pt.z);
     D3DXMatrixMultiply(&m1, &m1, &m2);
     D3DXMatrixMultiply(&m1, &m1, &m3);
     D3DXMatrixMultiply(&m1, &m1, &m4);
     D3DXMatrixMultiply(&m1, &m1, &m5);
     D3DXMatrixMultiply(&m1, &m1, &m6);
     D3DXMatrixMultiply(pout, &m1, &m7);
     return pout;
 }

Referenced by D3DXMatrixTransformation2D().

◆ D3DXMatrixTransformation2D()

D3DXMATRIX* WINAPI D3DXMatrixTransformation2D	(	D3DXMATRIX *	pout,
		const D3DXVECTOR2 *	pscalingcenter,
		FLOAT	scalingrotation,
		const D3DXVECTOR2 *	pscaling,
		const D3DXVECTOR2 *	protationcenter,
		FLOAT	rotation,
		const D3DXVECTOR2 *	ptranslation
	)

Definition at line 835 of file math.c.

 {
     D3DXQUATERNION rot, sca_rot;
     D3DXVECTOR3 rot_center, sca, sca_center, trans;
 
     TRACE("pout %p, pscalingcenter %p, scalingrotation %f, pscaling %p, protztioncenter %p, rotation %f, ptranslation %p\n",
         pout, pscalingcenter, scalingrotation, pscaling, protationcenter, rotation, ptranslation);
 
     if ( pscalingcenter )
     {
         sca_center.x=pscalingcenter->x;
         sca_center.y=pscalingcenter->y;
         sca_center.z=0.0f;
     }
     else
     {
         sca_center.x=0.0f;
         sca_center.y=0.0f;
         sca_center.z=0.0f;
     }
 
     if ( pscaling )
     {
         sca.x=pscaling->x;
         sca.y=pscaling->y;
         sca.z=1.0f;
     }
     else
     {
         sca.x=1.0f;
         sca.y=1.0f;
         sca.z=1.0f;
     }
 
     if ( protationcenter )
     {
         rot_center.x=protationcenter->x;
         rot_center.y=protationcenter->y;
         rot_center.z=0.0f;
     }
     else
     {
         rot_center.x=0.0f;
         rot_center.y=0.0f;
         rot_center.z=0.0f;
     }
 
     if ( ptranslation )
     {
         trans.x=ptranslation->x;
         trans.y=ptranslation->y;
         trans.z=0.0f;
     }
     else
     {
         trans.x=0.0f;
         trans.y=0.0f;
         trans.z=0.0f;
     }
 
     rot.w=cosf(rotation/2.0f);
     rot.x=0.0f;
     rot.y=0.0f;
     rot.z=sinf(rotation/2.0f);
 
     sca_rot.w=cosf(scalingrotation/2.0f);
     sca_rot.x=0.0f;
     sca_rot.y=0.0f;
     sca_rot.z=sinf(scalingrotation/2.0f);
 
     D3DXMatrixTransformation(pout, &sca_center, &sca_rot, &sca, &rot_center, &rot, &trans);
 
     return pout;
 }

◆ D3DXMatrixTranslation()

D3DXMATRIX* WINAPI D3DXMatrixTranslation	(	D3DXMATRIX *	pout,
		FLOAT	x,
		FLOAT	y,
		FLOAT	z
	)

Definition at line 910 of file math.c.

 {
     TRACE("pout %p, x %f, y %f, z %f\n", pout, x, y, z);
 
     D3DXMatrixIdentity(pout);
     pout->u.m[3][0] = x;
     pout->u.m[3][1] = y;
     pout->u.m[3][2] = z;
     return pout;
 }

Referenced by D3DXMatrixTransformation(), ID3DXMatrixStackImpl_Translate(), and ID3DXMatrixStackImpl_TranslateLocal().

◆ D3DXMatrixTranspose()

D3DXMATRIX* WINAPI D3DXMatrixTranspose	(	D3DXMATRIX *	pout,
		const D3DXMATRIX *	pm
	)

Definition at line 921 of file math.c.

 {
     const D3DXMATRIX m = *pm;
     int i,j;
 
     TRACE("pout %p, pm %p\n", pout, pm);
 
     for (i=0; i<4; i++)
         for (j=0; j<4; j++) pout->u.m[i][j] = m.u.m[j][i];
 
     return pout;
 }

Referenced by set().

◆ D3DXPlaneFromPointNormal()

D3DXPLANE* WINAPI D3DXPlaneFromPointNormal	(	D3DXPLANE *	pout,
		const D3DXVECTOR3 *	pvpoint,
		const D3DXVECTOR3 *	pvnormal
	)

Definition at line 1248 of file math.c.

 {
     TRACE("pout %p, pvpoint %p, pvnormal %p\n", pout, pvpoint, pvnormal);
 
     pout->a = pvnormal->x;
     pout->b = pvnormal->y;
     pout->c = pvnormal->z;
     pout->d = -D3DXVec3Dot(pvpoint, pvnormal);
     return pout;
 }

Referenced by D3DXPlaneFromPoints().

◆ D3DXPlaneFromPoints()

D3DXPLANE* WINAPI D3DXPlaneFromPoints	(	D3DXPLANE *	pout,
		const D3DXVECTOR3 *	pv1,
		const D3DXVECTOR3 *	pv2,
		const D3DXVECTOR3 *	pv3
	)

Definition at line 1259 of file math.c.

 {
     D3DXVECTOR3 edge1, edge2, normal, Nnormal;
 
     TRACE("pout %p, pv1 %p, pv2 %p, pv3 %p\n", pout, pv1, pv2, pv3);
 
     edge1.x = 0.0f; edge1.y = 0.0f; edge1.z = 0.0f;
     edge2.x = 0.0f; edge2.y = 0.0f; edge2.z = 0.0f;
     D3DXVec3Subtract(&edge1, pv2, pv1);
     D3DXVec3Subtract(&edge2, pv3, pv1);
     D3DXVec3Cross(&normal, &edge1, &edge2);
     D3DXVec3Normalize(&Nnormal, &normal);
     D3DXPlaneFromPointNormal(pout, pv1, &Nnormal);
     return pout;
 }

◆ D3DXPlaneIntersectLine()

D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine	(	D3DXVECTOR3 *	pout,
		const D3DXPLANE *	pp,
		const D3DXVECTOR3 *	pv1,
		const D3DXVECTOR3 *	pv2
	)

Definition at line 1275 of file math.c.

 {
     D3DXVECTOR3 direction, normal;
     FLOAT dot, temp;
 
     TRACE("pout %p, pp %p, pv1 %p, pv2 %p\n", pout, pp, pv1, pv2);
 
     normal.x = pp->a;
     normal.y = pp->b;
     normal.z = pp->c;
     direction.x = pv2->x - pv1->x;
     direction.y = pv2->y - pv1->y;
     direction.z = pv2->z - pv1->z;
     dot = D3DXVec3Dot(&normal, &direction);
     if ( !dot ) return NULL;
     temp = ( pp->d + D3DXVec3Dot(&normal, pv1) ) / dot;
     pout->x = pv1->x - temp * direction.x;
     pout->y = pv1->y - temp * direction.y;
     pout->z = pv1->z - temp * direction.z;
     return pout;
 }

◆ D3DXPlaneNormalize()

D3DXPLANE* WINAPI D3DXPlaneNormalize	(	D3DXPLANE *	out,
		const D3DXPLANE *	p
	)

Definition at line 1297 of file math.c.

 {
     FLOAT norm;
 
     TRACE("out %p, p %p\n", out, p);
 
     norm = sqrtf(p->a * p->a + p->b * p->b + p->c * p->c);
     if (norm)
     {
         out->a = p->a / norm;
         out->b = p->b / norm;
         out->c = p->c / norm;
         out->d = p->d / norm;
     }
     else
     {
         out->a = 0.0f;
         out->b = 0.0f;
         out->c = 0.0f;
         out->d = 0.0f;
     }
 
     return out;
 }

Referenced by D3DXMatrixReflect(), and D3DXMatrixShadow().

◆ D3DXPlaneTransform()

D3DXPLANE* WINAPI D3DXPlaneTransform	(	D3DXPLANE *	pout,
		const D3DXPLANE *	pplane,
		const D3DXMATRIX *	pm
	)

Definition at line 1322 of file math.c.

 {
     const D3DXPLANE plane = *pplane;
 
     TRACE("pout %p, pplane %p, pm %p\n", pout, pplane, pm);
 
     pout->a = pm->u.m[0][0] * plane.a + pm->u.m[1][0] * plane.b + pm->u.m[2][0] * plane.c + pm->u.m[3][0] * plane.d;
     pout->b = pm->u.m[0][1] * plane.a + pm->u.m[1][1] * plane.b + pm->u.m[2][1] * plane.c + pm->u.m[3][1] * plane.d;
     pout->c = pm->u.m[0][2] * plane.a + pm->u.m[1][2] * plane.b + pm->u.m[2][2] * plane.c + pm->u.m[3][2] * plane.d;
     pout->d = pm->u.m[0][3] * plane.a + pm->u.m[1][3] * plane.b + pm->u.m[2][3] * plane.c + pm->u.m[3][3] * plane.d;
     return pout;
 }

Referenced by D3DXPlaneTransformArray().

◆ D3DXPlaneTransformArray()

D3DXPLANE* WINAPI D3DXPlaneTransformArray	(	D3DXPLANE *	out,
		UINT	outstride,
		const D3DXPLANE *	in,
		UINT	instride,
		const D3DXMATRIX *	matrix,
		UINT	elements
	)

Definition at line 1335 of file math.c.

 {
     UINT i;
 
     TRACE("out %p, outstride %u, in %p, instride %u, matrix %p, elements %u\n", out, outstride, in, instride, matrix, elements);
 
     for (i = 0; i < elements; ++i) {
         D3DXPlaneTransform(
             (D3DXPLANE*)((char*)out + outstride * i),
             (const D3DXPLANE*)((const char*)in + instride * i),
             matrix);
     }
     return out;
 }

◆ D3DXQuaternionBaryCentric()

D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric	(	D3DXQUATERNION *	pout,
		const D3DXQUATERNION *	pq1,
		const D3DXQUATERNION *	pq2,
		const D3DXQUATERNION *	pq3,
		FLOAT	f,
		FLOAT	g
	)

Definition at line 1352 of file math.c.

 {
     D3DXQUATERNION temp1, temp2;
 
      TRACE("pout %p, pq1 %p, pq2 %p, pq3 %p, f %f, g %f\n", pout, pq1, pq2, pq3, f, g);
 
     D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq2, f + g), D3DXQuaternionSlerp(&temp2, pq1, pq3, f+g), g / (f + g));
     return pout;
 }

◆ D3DXQuaternionExp()

D3DXQUATERNION* WINAPI D3DXQuaternionExp	(	D3DXQUATERNION *	out,
		const D3DXQUATERNION *	q
	)

Definition at line 1362 of file math.c.

 {
     FLOAT norm;
 
     TRACE("out %p, q %p\n", out, q);
 
     norm = sqrtf(q->x * q->x + q->y * q->y + q->z * q->z);
     if (norm)
     {
         out->x = sinf(norm) * q->x / norm;
         out->y = sinf(norm) * q->y / norm;
         out->z = sinf(norm) * q->z / norm;
         out->w = cosf(norm);
     }
     else
     {
         out->x = 0.0f;
         out->y = 0.0f;
         out->z = 0.0f;
         out->w = 1.0f;
     }
 
     return out;
 }

Referenced by D3DXQuaternionSquadSetup().

◆ D3DXQuaternionInverse()

D3DXQUATERNION* WINAPI D3DXQuaternionInverse	(	D3DXQUATERNION *	pout,
		const D3DXQUATERNION *	pq
	)

Definition at line 1387 of file math.c.

 {
     FLOAT norm;
 
     TRACE("pout %p, pq %p\n", pout, pq);
 
     norm = D3DXQuaternionLengthSq(pq);
 
     pout->x = -pq->x / norm;
     pout->y = -pq->y / norm;
     pout->z = -pq->z / norm;
     pout->w = pq->w / norm;
     return pout;
 }

Referenced by D3DXQuaternionSquadSetup().

◆ D3DXQuaternionLn()

D3DXQUATERNION* WINAPI D3DXQuaternionLn	(	D3DXQUATERNION *	out,
		const D3DXQUATERNION *	q
	)

Definition at line 1402 of file math.c.

 {
     FLOAT t;
 
     TRACE("out %p, q %p\n", out, q);
 
     if ((q->w >= 1.0f) || (q->w == -1.0f))
         t = 1.0f;
     else
         t = acosf(q->w) / sqrtf(1.0f - q->w * q->w);
 
     out->x = t * q->x;
     out->y = t * q->y;
     out->z = t * q->z;
     out->w = 0.0f;
 
     return out;
 }

Referenced by D3DXQuaternionSquadSetup().

◆ D3DXQuaternionMultiply()

D3DXQUATERNION* WINAPI D3DXQuaternionMultiply	(	D3DXQUATERNION *	pout,
		const D3DXQUATERNION *	pq1,
		const D3DXQUATERNION *	pq2
	)

Definition at line 1421 of file math.c.

 {
     D3DXQUATERNION out;
 
     TRACE("pout %p, pq1 %p, pq2 %p\n", pout, pq1, pq2);
 
     out.x = pq2->w * pq1->x + pq2->x * pq1->w + pq2->y * pq1->z - pq2->z * pq1->y;
     out.y = pq2->w * pq1->y - pq2->x * pq1->z + pq2->y * pq1->w + pq2->z * pq1->x;
     out.z = pq2->w * pq1->z + pq2->x * pq1->y - pq2->y * pq1->x + pq2->z * pq1->w;
     out.w = pq2->w * pq1->w - pq2->x * pq1->x - pq2->y * pq1->y - pq2->z * pq1->z;
     *pout = out;
     return pout;
 }

Referenced by D3DXQuaternionSquadSetup().

◆ D3DXQuaternionNormalize()

D3DXQUATERNION* WINAPI D3DXQuaternionNormalize	(	D3DXQUATERNION *	out,
		const D3DXQUATERNION *	q
	)

Definition at line 1435 of file math.c.

 {
     FLOAT norm;
 
     TRACE("out %p, q %p\n", out, q);
 
     norm = D3DXQuaternionLength(q);
 
     out->x = q->x / norm;
     out->y = q->y / norm;
     out->z = q->z / norm;
     out->w = q->w / norm;
 
     return out;
 }

◆ D3DXQuaternionRotationAxis()

D3DXQUATERNION* WINAPI D3DXQuaternionRotationAxis	(	D3DXQUATERNION *	out,
		const D3DXVECTOR3 *	v,
		FLOAT	angle
	)

Definition at line 1451 of file math.c.

 {
     D3DXVECTOR3 temp;
 
     TRACE("out %p, v %p, angle %f\n", out, v, angle);
 
     D3DXVec3Normalize(&temp, v);
 
     out->x = sinf(angle / 2.0f) * temp.x;
     out->y = sinf(angle / 2.0f) * temp.y;
     out->z = sinf(angle / 2.0f) * temp.z;
     out->w = cosf(angle / 2.0f);
 
     return out;
 }

◆ D3DXQuaternionRotationMatrix()

D3DXQUATERNION* WINAPI D3DXQuaternionRotationMatrix	(	D3DXQUATERNION *	out,
		const D3DXMATRIX *	m
	)

Definition at line 1467 of file math.c.

 {
     FLOAT s, trace;
 
     TRACE("out %p, m %p\n", out, m);
 
     trace = m->u.m[0][0] + m->u.m[1][1] + m->u.m[2][2] + 1.0f;
     if (trace > 1.0f)
     {
         s = 2.0f * sqrtf(trace);
         out->x = (m->u.m[1][2] - m->u.m[2][1]) / s;
         out->y = (m->u.m[2][0] - m->u.m[0][2]) / s;
         out->z = (m->u.m[0][1] - m->u.m[1][0]) / s;
         out->w = 0.25f * s;
     }
     else
     {
         int i, maxi = 0;
 
         for (i = 1; i < 3; i++)
         {
             if (m->u.m[i][i] > m->u.m[maxi][maxi])
                 maxi = i;
         }
 
         switch (maxi)
         {
             case 0:
                 s = 2.0f * sqrtf(1.0f + m->u.m[0][0] - m->u.m[1][1] - m->u.m[2][2]);
                 out->x = 0.25f * s;
                 out->y = (m->u.m[0][1] + m->u.m[1][0]) / s;
                 out->z = (m->u.m[0][2] + m->u.m[2][0]) / s;
                 out->w = (m->u.m[1][2] - m->u.m[2][1]) / s;
                 break;
 
             case 1:
                 s = 2.0f * sqrtf(1.0f + m->u.m[1][1] - m->u.m[0][0] - m->u.m[2][2]);
                 out->x = (m->u.m[0][1] + m->u.m[1][0]) / s;
                 out->y = 0.25f * s;
                 out->z = (m->u.m[1][2] + m->u.m[2][1]) / s;
                 out->w = (m->u.m[2][0] - m->u.m[0][2]) / s;
                 break;
 
             case 2:
                 s = 2.0f * sqrtf(1.0f + m->u.m[2][2] - m->u.m[0][0] - m->u.m[1][1]);
                 out->x = (m->u.m[0][2] + m->u.m[2][0]) / s;
                 out->y = (m->u.m[1][2] + m->u.m[2][1]) / s;
                 out->z = 0.25f * s;
                 out->w = (m->u.m[0][1] - m->u.m[1][0]) / s;
                 break;
         }
     }
 
     return out;
 }

Referenced by D3DXMatrixDecompose().

◆ D3DXQuaternionRotationYawPitchRoll()

D3DXQUATERNION* WINAPI D3DXQuaternionRotationYawPitchRoll	(	D3DXQUATERNION *	out,
		FLOAT	yaw,
		FLOAT	pitch,
		FLOAT	roll
	)

Definition at line 1523 of file math.c.

 {
     FLOAT syaw, cyaw, spitch, cpitch, sroll, croll;
 
     TRACE("out %p, yaw %f, pitch %f, roll %f\n", out, yaw, pitch, roll);
 
     syaw = sinf(yaw / 2.0f);
     cyaw = cosf(yaw / 2.0f);
     spitch = sinf(pitch / 2.0f);
     cpitch = cosf(pitch / 2.0f);
     sroll = sinf(roll / 2.0f);
     croll = cosf(roll / 2.0f);
 
     out->x = syaw * cpitch * sroll + cyaw * spitch * croll;
     out->y = syaw * cpitch * croll - cyaw * spitch * sroll;
     out->z = cyaw * cpitch * sroll - syaw * spitch * croll;
     out->w = cyaw * cpitch * croll + syaw * spitch * sroll;
 
     return out;
 }

◆ D3DXQuaternionSlerp()

D3DXQUATERNION* WINAPI D3DXQuaternionSlerp	(	D3DXQUATERNION *	out,
		const D3DXQUATERNION *	q1,
		const D3DXQUATERNION *	q2,
		FLOAT	t
	)

Definition at line 1544 of file math.c.

 {
     FLOAT dot, temp;
 
     TRACE("out %p, q1 %p, q2 %p, t %f\n", out, q1, q2, t);
 
     temp = 1.0f - t;
     dot = D3DXQuaternionDot(q1, q2);
     if (dot < 0.0f)
     {
         t = -t;
         dot = -dot;
     }
 
     if (1.0f - dot > 0.001f)
     {
         FLOAT theta = acosf(dot);
 
         temp = sinf(theta * temp) / sinf(theta);
         t = sinf(theta * t) / sinf(theta);
     }
 
     out->x = temp * q1->x + t * q2->x;
     out->y = temp * q1->y + t * q2->y;
     out->z = temp * q1->z + t * q2->z;
     out->w = temp * q1->w + t * q2->w;
 
     return out;
 }

Referenced by D3DXQuaternionBaryCentric(), and D3DXQuaternionSquad().

◆ D3DXQuaternionSquad()

D3DXQUATERNION* WINAPI D3DXQuaternionSquad	(	D3DXQUATERNION *	pout,
		const D3DXQUATERNION *	pq1,
		const D3DXQUATERNION *	pq2,
		const D3DXQUATERNION *	pq3,
		const D3DXQUATERNION *	pq4,
		FLOAT	t
	)

Definition at line 1575 of file math.c.

 {
     D3DXQUATERNION temp1, temp2;
 
     TRACE("pout %p, pq1 %p, pq2 %p, pq3 %p, pq4 %p, t %f\n", pout, pq1, pq2, pq3, pq4, t);
 
     D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq4, t), D3DXQuaternionSlerp(&temp2, pq2, pq3, t), 2.0f * t * (1.0f - t));
     return pout;
 }

◆ D3DXQuaternionSquadSetup()

void WINAPI D3DXQuaternionSquadSetup	(	D3DXQUATERNION *	paout,
		D3DXQUATERNION *	pbout,
		D3DXQUATERNION *	pcout,
		const D3DXQUATERNION *	pq0,
		const D3DXQUATERNION *	pq1,
		const D3DXQUATERNION *	pq2,
		const D3DXQUATERNION *	pq3
	)

Definition at line 1597 of file math.c.

 {
     D3DXQUATERNION q, temp1, temp2, temp3, zero;
     D3DXQUATERNION aout, cout;
 
     TRACE("paout %p, pbout %p, pcout %p, pq0 %p, pq1 %p, pq2 %p, pq3 %p\n", paout, pbout, pcout, pq0, pq1, pq2, pq3);
 
     zero.x = 0.0f;
     zero.y = 0.0f;
     zero.z = 0.0f;
     zero.w = 0.0f;
 
     if (D3DXQuaternionDot(pq0, pq1) < 0.0f)
         temp2 = add_diff(&zero, pq0, -1.0f);
     else
         temp2 = *pq0;
 
     if (D3DXQuaternionDot(pq1, pq2) < 0.0f)
         cout = add_diff(&zero, pq2, -1.0f);
     else
         cout = *pq2;
 
     if (D3DXQuaternionDot(&cout, pq3) < 0.0f)
         temp3 = add_diff(&zero, pq3, -1.0f);
     else
         temp3 = *pq3;
 
     D3DXQuaternionInverse(&temp1, pq1);
     D3DXQuaternionMultiply(&temp2, &temp1, &temp2);
     D3DXQuaternionLn(&temp2, &temp2);
     D3DXQuaternionMultiply(&q, &temp1, &cout);
     D3DXQuaternionLn(&q, &q);
     temp1 = add_diff(&temp2, &q, 1.0f);
     temp1.x *= -0.25f;
     temp1.y *= -0.25f;
     temp1.z *= -0.25f;
     temp1.w *= -0.25f;
     D3DXQuaternionExp(&temp1, &temp1);
     D3DXQuaternionMultiply(&aout, pq1, &temp1);
 
     D3DXQuaternionInverse(&temp1, &cout);
     D3DXQuaternionMultiply(&temp2, &temp1, pq1);
     D3DXQuaternionLn(&temp2, &temp2);
     D3DXQuaternionMultiply(&q, &temp1, &temp3);
     D3DXQuaternionLn(&q, &q);
     temp1 = add_diff(&temp2, &q, 1.0f);
     temp1.x *= -0.25f;
     temp1.y *= -0.25f;
     temp1.z *= -0.25f;
     temp1.w *= -0.25f;
     D3DXQuaternionExp(&temp1, &temp1);
     D3DXQuaternionMultiply(pbout, &cout, &temp1);
     *paout = aout;
     *pcout = cout;
 }

◆ D3DXQuaternionToAxisAngle()

void WINAPI D3DXQuaternionToAxisAngle	(	const D3DXQUATERNION *	pq,
		D3DXVECTOR3 *	paxis,
		FLOAT *	pangle
	)

Definition at line 1653 of file math.c.

 {
     TRACE("pq %p, paxis %p, pangle %p\n", pq, paxis, pangle);
 
     if (paxis)
     {
         paxis->x = pq->x;
         paxis->y = pq->y;
         paxis->z = pq->z;
     }
     if (pangle)
         *pangle = 2.0f * acosf(pq->w);
 }

◆ D3DXSHAdd()

FLOAT* WINAPI D3DXSHAdd	(	FLOAT *	out,
		UINT	order,
		const FLOAT *	a,
		const FLOAT *	b
	)

Definition at line 2281 of file math.c.

 {
     UINT i;
 
     TRACE("out %p, order %u, a %p, b %p\n", out, order, a, b);
 
     for (i = 0; i < order * order; i++)
         out[i] = a[i] + b[i];
 
     return out;
 }

◆ D3DXSHDot()

FLOAT WINAPI D3DXSHDot	(	UINT	order,
		const FLOAT *	a,
		const FLOAT *	b
	)

Definition at line 2293 of file math.c.

 {
     FLOAT s;
     UINT i;
 
     TRACE("order %u, a %p, b %p\n", order, a, b);
 
     s = a[0] * b[0];
     for (i = 1; i < order * order; i++)
         s += a[i] * b[i];
 
     return s;
 }

Referenced by D3DXSHMultiply2().

◆ D3DXSHEvalConeLight()

HRESULT WINAPI D3DXSHEvalConeLight	(	UINT	order,
		const D3DXVECTOR3 *	dir,
		FLOAT	radius,
		FLOAT	Rintensity,
		FLOAT	Gintensity,
		FLOAT	Bintensity,
		FLOAT *	rout,
		FLOAT *	gout,
		FLOAT *	bout
	)

Definition at line 2336 of file math.c.

 {
     FLOAT cap[6], clamped_angle, norm, scale, temp;
     UINT i, index, j;
 
     TRACE("order %u, dir %p, radius %f, red %f, green %f, blue %f, rout %p, gout %p, bout %p\n",
         order, dir, radius, Rintensity, Gintensity, Bintensity, rout, gout, bout);
 
     if (radius <= 0.0f)
         return D3DXSHEvalDirectionalLight(order, dir, Rintensity, Gintensity, Bintensity, rout, gout, bout);
 
     clamped_angle = (radius > D3DX_PI / 2.0f) ? (D3DX_PI / 2.0f) : radius;
     norm = sinf(clamped_angle) * sinf(clamped_angle);
 
     if (order > D3DXSH_MAXORDER)
     {
         WARN("Order clamped at D3DXSH_MAXORDER\n");
         order = D3DXSH_MAXORDER;
     }
 
     weightedcapintegrale(cap, order, radius);
     D3DXSHEvalDirection(rout, order, dir);
 
     for (i = 0; i < order; i++)
     {
         scale = cap[i] / norm;
 
         for (j = 0; j < 2 * i + 1; j++)
         {
             index = i * i + j;
             temp = rout[index] * scale;
 
             rout[index] = temp * Rintensity;
             if (gout)
                 gout[index] = temp * Gintensity;
             if (bout)
                 bout[index] = temp * Bintensity;
         }
     }
 
     return D3D_OK;
 }

◆ D3DXSHEvalDirection()

FLOAT* WINAPI D3DXSHEvalDirection	(	FLOAT *	out,
		UINT	order,
		const D3DXVECTOR3 *	dir
	)

Definition at line 2380 of file math.c.

 {
     const FLOAT dirxx = dir->x * dir->x;
     const FLOAT dirxy = dir->x * dir->y;
     const FLOAT dirxz = dir->x * dir->z;
     const FLOAT diryy = dir->y * dir->y;
     const FLOAT diryz = dir->y * dir->z;
     const FLOAT dirzz = dir->z * dir->z;
     const FLOAT dirxxxx = dirxx * dirxx;
     const FLOAT diryyyy = diryy * diryy;
     const FLOAT dirzzzz = dirzz * dirzz;
     const FLOAT dirxyxy = dirxy * dirxy;
 
     TRACE("out %p, order %u, dir %p\n", out, order, dir);
 
     if ((order < D3DXSH_MINORDER) || (order > D3DXSH_MAXORDER))
         return out;
 
     out[0] = 0.5f / sqrtf(D3DX_PI);
     out[1] = -0.5f / sqrtf(D3DX_PI / 3.0f) * dir->y;
     out[2] = 0.5f / sqrtf(D3DX_PI / 3.0f) * dir->z;
     out[3] = -0.5f / sqrtf(D3DX_PI / 3.0f) * dir->x;
     if (order == 2)
         return out;
 
     out[4] = 0.5f / sqrtf(D3DX_PI / 15.0f) * dirxy;
     out[5] = -0.5f / sqrtf(D3DX_PI / 15.0f) * diryz;
     out[6] = 0.25f / sqrtf(D3DX_PI / 5.0f) * (3.0f * dirzz - 1.0f);
     out[7] = -0.5f / sqrtf(D3DX_PI / 15.0f) * dirxz;
     out[8] = 0.25f / sqrtf(D3DX_PI / 15.0f) * (dirxx - diryy);
     if (order == 3)
         return out;
 
     out[9] = -sqrtf(70.0f / D3DX_PI) / 8.0f * dir->y * (3.0f * dirxx - diryy);
     out[10] = sqrtf(105.0f / D3DX_PI) / 2.0f * dirxy * dir->z;
     out[11] = -sqrtf(42.0f / D3DX_PI) / 8.0f * dir->y * (-1.0f + 5.0f * dirzz);
     out[12] = sqrtf(7.0f / D3DX_PI) / 4.0f * dir->z * (5.0f * dirzz - 3.0f);
     out[13] = sqrtf(42.0f / D3DX_PI) / 8.0f * dir->x * (1.0f - 5.0f * dirzz);
     out[14] = sqrtf(105.0f / D3DX_PI) / 4.0f * dir->z * (dirxx - diryy);
     out[15] = -sqrtf(70.0f / D3DX_PI) / 8.0f * dir->x * (dirxx - 3.0f * diryy);
     if (order == 4)
         return out;
 
     out[16] = 0.75f * sqrtf(35.0f / D3DX_PI) * dirxy * (dirxx - diryy);
     out[17] = 3.0f * dir->z * out[9];
     out[18] = 0.75f * sqrtf(5.0f / D3DX_PI) * dirxy * (7.0f * dirzz - 1.0f);
     out[19] = 0.375f * sqrtf(10.0f / D3DX_PI) * diryz * (3.0f - 7.0f * dirzz);
     out[20] = 3.0f / (16.0f * sqrtf(D3DX_PI)) * (35.0f * dirzzzz - 30.f * dirzz + 3.0f);
     out[21] = 0.375f * sqrtf(10.0f / D3DX_PI) * dirxz * (3.0f - 7.0f * dirzz);
     out[22] = 0.375f * sqrtf(5.0f / D3DX_PI) * (dirxx - diryy) * (7.0f * dirzz - 1.0f);
     out[23] = 3.0f * dir->z * out[15];
     out[24] = 3.0f / 16.0f * sqrtf(35.0f / D3DX_PI) * (dirxxxx - 6.0f * dirxyxy + diryyyy);
     if (order == 5)
         return out;
 
     out[25] = -3.0f/ 32.0f * sqrtf(154.0f / D3DX_PI) * dir->y * (5.0f * dirxxxx - 10.0f * dirxyxy + diryyyy);
     out[26] = 0.75f * sqrtf(385.0f / D3DX_PI) * dirxy * dir->z * (dirxx - diryy);
     out[27] = sqrtf(770.0f / D3DX_PI) / 32.0f * dir->y * (3.0f * dirxx - diryy) * (1.0f - 9.0f * dirzz);
     out[28] = sqrtf(1155.0f / D3DX_PI) / 4.0f * dirxy * dir->z * (3.0f * dirzz - 1.0f);
     out[29] = sqrtf(165.0f / D3DX_PI) / 16.0f * dir->y * (14.0f * dirzz - 21.0f * dirzzzz - 1.0f);
     out[30] = sqrtf(11.0f / D3DX_PI) / 16.0f * dir->z * (63.0f * dirzzzz - 70.0f * dirzz + 15.0f);
     out[31] = sqrtf(165.0f / D3DX_PI) / 16.0f * dir->x * (14.0f * dirzz - 21.0f * dirzzzz - 1.0f);
     out[32] = sqrtf(1155.0f / D3DX_PI) / 8.0f * dir->z * (dirxx - diryy) * (3.0f * dirzz - 1.0f);
     out[33] = sqrtf(770.0f / D3DX_PI) / 32.0f * dir->x * (dirxx - 3.0f * diryy) * (1.0f - 9.0f * dirzz);
     out[34] = 3.0f / 16.0f * sqrtf(385.0f / D3DX_PI) * dir->z * (dirxxxx - 6.0f * dirxyxy + diryyyy);
     out[35] = -3.0f/ 32.0f * sqrtf(154.0f / D3DX_PI) * dir->x * (dirxxxx - 10.0f * dirxyxy + 5.0f * diryyyy);
 
     return out;
 }

Referenced by D3DXSHEvalConeLight(), D3DXSHEvalDirectionalLight(), D3DXSHEvalHemisphereLight(), and D3DXSHEvalSphericalLight().

◆ D3DXSHEvalDirectionalLight()

HRESULT WINAPI D3DXSHEvalDirectionalLight	(	UINT	order,
		const D3DXVECTOR3 *	dir,
		FLOAT	Rintensity,
		FLOAT	Gintensity,
		FLOAT	Bintensity,
		FLOAT *	Rout,
		FLOAT *	Gout,
		FLOAT *	Bout
	)

Definition at line 2450 of file math.c.

 {
     FLOAT s, temp;
     UINT j;
 
     TRACE("Order %u, Vector %p, Red %f, Green %f, Blue %f, Rout %p, Gout %p, Bout %p\n", order, dir, Rintensity, Gintensity, Bintensity, Rout, Gout, Bout);
 
     s = 0.75f;
     if ( order > 2 )
         s += 5.0f / 16.0f;
     if ( order > 4 )
         s -= 3.0f / 32.0f;
     s /= D3DX_PI;
 
     D3DXSHEvalDirection(Rout, order, dir);
     for (j = 0; j < order * order; j++)
     {
         temp = Rout[j] / s;
 
         Rout[j] = Rintensity * temp;
         if ( Gout )
             Gout[j] = Gintensity * temp;
         if ( Bout )
             Bout[j] = Bintensity * temp;
     }
 
     return D3D_OK;
 }

Referenced by D3DXSHEvalConeLight().

◆ D3DXSHEvalHemisphereLight()

HRESULT WINAPI D3DXSHEvalHemisphereLight	(	UINT	order,
		const D3DXVECTOR3 *	dir,
		D3DXCOLOR	top,
		D3DXCOLOR	bottom,
		FLOAT *	rout,
		FLOAT *	gout,
		FLOAT *	bout
	)

Definition at line 2479 of file math.c.

 {
     FLOAT a[2], temp[4];
     UINT i, j;
 
     TRACE("order %u, dir %p, rout %p, gout %p, bout %p\n", order, dir, rout, gout, bout);
 
     D3DXSHEvalDirection(temp, 2, dir);
 
     a[0] = (top.r + bottom.r) * 3.0f * D3DX_PI;
     a[1] = (top.r - bottom.r) * D3DX_PI;
     for (i = 0; i < order; i++)
         for (j = 0; j < 2 * i + 1; j++)
             if (i < 2)
                 rout[i * i + j] = temp[i * i + j] * a[i];
             else
                 rout[i * i + j] = 0.0f;
 
     if (gout)
     {
         a[0] = (top.g + bottom.g) * 3.0f * D3DX_PI;
         a[1] = (top.g - bottom.g) * D3DX_PI;
         for (i = 0; i < order; i++)
             for (j = 0; j < 2 * i + 1; j++)
                 if (i < 2)
                     gout[i * i + j] = temp[i * i + j] * a[i];
                 else
                     gout[i * i + j] = 0.0f;
     }
 
     if (bout)
     {
         a[0] = (top.b + bottom.b) * 3.0f * D3DX_PI;
         a[1] = (top.b - bottom.b) * D3DX_PI;
         for (i = 0; i < order; i++)
             for (j = 0; j < 2 * i + 1; j++)
                 if (i < 2)
                     bout[i * i + j] = temp[i * i + j] * a[i];
                 else
                     bout[i * i + j] = 0.0f;
     }
 
     return D3D_OK;
 }

◆ D3DXSHEvalSphericalLight()

HRESULT WINAPI D3DXSHEvalSphericalLight	(	UINT	order,
		const D3DXVECTOR3 *	dir,
		FLOAT	radius,
		FLOAT	Rintensity,
		FLOAT	Gintensity,
		FLOAT	Bintensity,
		FLOAT *	rout,
		FLOAT *	gout,
		FLOAT *	bout
	)

Definition at line 2525 of file math.c.

 {
     D3DXVECTOR3 normal;
     FLOAT cap[6], clamped_angle, dist, temp;
     UINT i, index, j;
 
     TRACE("order %u, dir %p, radius %f, red %f, green %f, blue %f, rout %p, gout %p, bout %p\n",
         order, dir, radius, Rintensity, Gintensity, Bintensity, rout, gout, bout);
 
     if (order > D3DXSH_MAXORDER)
     {
         WARN("Order clamped at D3DXSH_MAXORDER\n");
         order = D3DXSH_MAXORDER;
     }
 
     if (radius < 0.0f)
         radius = -radius;
 
     dist = D3DXVec3Length(dir);
     clamped_angle = (dist <= radius) ? D3DX_PI / 2.0f : asinf(radius / dist);
 
     weightedcapintegrale(cap, order, clamped_angle);
     D3DXVec3Normalize(&normal, dir);
     D3DXSHEvalDirection(rout, order, &normal);
 
     for (i = 0; i < order; i++)
         for (j = 0; j < 2 * i + 1; j++)
         {
             index = i * i + j;
             temp = rout[index] * cap[i];
 
             rout[index] = temp * Rintensity;
             if (gout)
                 gout[index] = temp * Gintensity;
             if (bout)
                 bout[index] = temp * Bintensity;
         }
 
     return D3D_OK;
 }

◆ D3DXSHMultiply2()

FLOAT* WINAPI D3DXSHMultiply2	(	FLOAT *	out,
		const FLOAT *	a,
		const FLOAT *	b
	)

Definition at line 2567 of file math.c.

 {
     FLOAT ta, tb;
 
     TRACE("out %p, a %p, b %p\n", out, a, b);
 
     ta = 0.28209479f * a[0];
     tb = 0.28209479f * b[0];
 
     out[0] = 0.28209479f * D3DXSHDot(2, a, b);
     out[1] = ta * b[1] + tb * a[1];
     out[2] = ta * b[2] + tb * a[2];
     out[3] = ta * b[3] + tb * a[3];
 
     return out;
 }

◆ D3DXSHMultiply3()

FLOAT* WINAPI D3DXSHMultiply3	(	FLOAT *	out,
		const FLOAT *	a,
		const FLOAT *	b
	)

Definition at line 2584 of file math.c.

 {
     FLOAT t, ta, tb;
 
     TRACE("out %p, a %p, b %p\n", out, a, b);
 
     out[0] = 0.28209479f * a[0] * b[0];
 
     ta = 0.28209479f * a[0] - 0.12615663f * a[6] - 0.21850969f * a[8];
     tb = 0.28209479f * b[0] - 0.12615663f * b[6] - 0.21850969f * b[8];
     out[1] = ta * b[1] + tb * a[1];
     t = a[1] * b[1];
     out[0] += 0.28209479f * t;
     out[6] = -0.12615663f * t;
     out[8] = -0.21850969f * t;
 
     ta = 0.21850969f * a[5];
     tb = 0.21850969f * b[5];
     out[1] += ta * b[2] + tb * a[2];
     out[2] = ta * b[1] + tb * a[1];
     t = a[1] * b[2] +a[2] * b[1];
     out[5] = 0.21850969f * t;
 
     ta = 0.21850969f * a[4];
     tb = 0.21850969f * b[4];
     out[1] += ta * b[3] + tb * a[3];
     out[3]  = ta * b[1] + tb * a[1];
     t = a[1] * b[3] + a[3] * b[1];
     out[4] = 0.21850969f * t;
 
     ta = 0.28209480f * a[0] + 0.25231326f * a[6];
     tb = 0.28209480f * b[0] + 0.25231326f * b[6];
     out[2] += ta * b[2] + tb * a[2];
     t = a[2] * b[2];
     out[0] += 0.28209480f * t;
     out[6] += 0.25231326f * t;
 
     ta = 0.21850969f * a[7];
     tb = 0.21850969f * b[7];
     out[2] += ta * b[3] + tb * a[3];
     out[3] += ta * b[2] + tb * a[2];
     t = a[2] * b[3] + a[3] * b[2];
     out[7] = 0.21850969f * t;
 
     ta = 0.28209479f * a[0] - 0.12615663f * a[6] + 0.21850969f * a[8];
     tb = 0.28209479f * b[0] - 0.12615663f * b[6] + 0.21850969f * b[8];
     out[3] += ta * b[3] + tb * a[3];
     t = a[3] * b[3];
     out[0] += 0.28209479f * t;
     out[6] -= 0.12615663f * t;
     out[8] += 0.21850969f * t;
 
     ta = 0.28209479f * a[0] - 0.18022375f * a[6];
     tb = 0.28209479f * b[0] - 0.18022375f * b[6];
     out[4] += ta * b[4] + tb * a[4];
     t = a[4] * b[4];
     out[0] += 0.28209479f * t;
     out[6] -= 0.18022375f * t;
 
     ta = 0.15607835f * a[7];
     tb = 0.15607835f * b[7];
     out[4] += ta * b[5] + tb * a[5];
     out[5] += ta * b[4] + tb * a[4];
     t = a[4] * b[5] + a[5] * b[4];
     out[7] += 0.15607835f * t;
 
     ta = 0.28209479f * a[0] + 0.09011188f * a[6] - 0.15607835f * a[8];
     tb = 0.28209479f * b[0] + 0.09011188f * b[6] - 0.15607835f * b[8];
     out[5] += ta * b[5] + tb * a[5];
     t = a[5] * b[5];
     out[0] += 0.28209479f * t;
     out[6] += 0.09011188f * t;
     out[8] -= 0.15607835f * t;
 
     ta = 0.28209480f * a[0];
     tb = 0.28209480f * b[0];
     out[6] += ta * b[6] + tb * a[6];
     t = a[6] * b[6];
     out[0] += 0.28209480f * t;
     out[6] += 0.18022376f * t;
 
     ta = 0.28209479f * a[0] + 0.09011188f * a[6] + 0.15607835f * a[8];
     tb = 0.28209479f * b[0] + 0.09011188f * b[6] + 0.15607835f * b[8];
     out[7] += ta * b[7] + tb * a[7];
     t = a[7] * b[7];
     out[0] += 0.28209479f * t;
     out[6] += 0.09011188f * t;
     out[8] += 0.15607835f * t;
 
     ta = 0.28209479f * a[0] - 0.18022375f * a[6];
     tb = 0.28209479f * b[0] - 0.18022375f * b[6];
     out[8] += ta * b[8] + tb * a[8];
     t = a[8] * b[8];
     out[0] += 0.28209479f * t;
     out[6] -= 0.18022375f * t;
 
     return out;
 }

◆ D3DXSHMultiply4()

FLOAT* WINAPI D3DXSHMultiply4	(	FLOAT *	out,
		const FLOAT *	a,
		const FLOAT *	b
	)

Definition at line 2683 of file math.c.

 {
     FLOAT ta, tb, t;
 
     TRACE("out %p, a %p, b %p\n", out, a, b);
 
     out[0] = 0.28209479f * a[0] * b[0];
 
     ta = 0.28209479f * a[0] - 0.12615663f * a[6] - 0.21850969f * a[8];
     tb = 0.28209479f * b[0] - 0.12615663f * b[6] - 0.21850969f * b[8];
     out[1] = ta * b[1] + tb * a[1];
     t = a[1] * b[1];
     out[0] += 0.28209479f * t;
     out[6] = -0.12615663f * t;
     out[8] = -0.21850969f * t;
 
     ta = 0.21850969f * a[3] - 0.05839917f * a[13] - 0.22617901f * a[15];
     tb = 0.21850969f * b[3] - 0.05839917f * b[13] - 0.22617901f * b[15];
     out[1] += ta * b[4] + tb * a[4];
     out[4] = ta * b[1] + tb * a[1];
     t = a[1] * b[4] + a[4] * b[1];
     out[3] = 0.21850969f * t;
     out[13] = -0.05839917f * t;
     out[15] = -0.22617901f * t;
 
     ta = 0.21850969f * a[2] - 0.14304817f * a[12] - 0.18467439f * a[14];
     tb = 0.21850969f * b[2] - 0.14304817f * b[12] - 0.18467439f * b[14];
     out[1] += ta * b[5] + tb * a[5];
     out[5] = ta * b[1] + tb * a[1];
     t = a[1] * b[5] + a[5] * b[1];
     out[2] = 0.21850969f * t;
     out[12] = -0.14304817f * t;
     out[14] = -0.18467439f * t;
 
     ta = 0.20230066f * a[11];
     tb = 0.20230066f * b[11];
     out[1] += ta * b[6] + tb * a[6];
     out[6] += ta * b[1] + tb * a[1];
     t = a[1] * b[6] + a[6] * b[1];
     out[11] = 0.20230066f * t;
 
     ta = 0.22617901f * a[9] + 0.05839917f * a[11];
     tb = 0.22617901f * b[9] + 0.05839917f * b[11];
     out[1] += ta * b[8] + tb * a[8];
     out[8] += ta * b[1] + tb * a[1];
     t = a[1] * b[8] + a[8] * b[1];
     out[9] = 0.22617901f * t;
     out[11] += 0.05839917f * t;
 
     ta = 0.28209480f * a[0] + 0.25231326f * a[6];
     tb = 0.28209480f * b[0] + 0.25231326f * b[6];
     out[2] += ta * b[2] + tb * a[2];
     t = a[2] * b[2];
     out[0] += 0.28209480f * t;
     out[6] += 0.25231326f * t;
 
     ta = 0.24776671f * a[12];
     tb = 0.24776671f * b[12];
     out[2] += ta * b[6] + tb * a[6];
     out[6] += ta * b[2] + tb * a[2];
     t = a[2] * b[6] + a[6] * b[2];
     out[12] += 0.24776671f * t;
 
     ta = 0.28209480f * a[0] - 0.12615663f * a[6] + 0.21850969f * a[8];
     tb = 0.28209480f * b[0] - 0.12615663f * b[6] + 0.21850969f * b[8];
     out[3] += ta * b[3] + tb * a[3];
     t = a[3] * b[3];
     out[0] += 0.28209480f * t;
     out[6] -= 0.12615663f * t;
     out[8] += 0.21850969f * t;
 
     ta = 0.20230066f * a[13];
     tb = 0.20230066f * b[13];
     out[3] += ta * b[6] + tb * a[6];
     out[6] += ta * b[3] + tb * a[3];
     t = a[3] * b[6] + a[6] * b[3];
     out[13] += 0.20230066f * t;
 
     ta = 0.21850969f * a[2] - 0.14304817f * a[12] + 0.18467439f * a[14];
     tb = 0.21850969f * b[2] - 0.14304817f * b[12] + 0.18467439f * b[14];
     out[3] += ta * b[7] + tb * a[7];
     out[7] = ta * b[3] + tb * a[3];
     t = a[3] * b[7] + a[7] * b[3];
     out[2] += 0.21850969f * t;
     out[12] -= 0.14304817f * t;
     out[14] += 0.18467439f * t;
 
     ta = -0.05839917f * a[13] + 0.22617901f * a[15];
     tb = -0.05839917f * b[13] + 0.22617901f * b[15];
     

Classes

Functions

Variables

Function Documentation

◆ add_diff()

◆ D3DXColorAdjustContrast()

◆ D3DXColorAdjustSaturation()

◆ D3DXCreateMatrixStack()

◆ D3DXFloat16To32Array()

◆ D3DXFloat32To16Array()

◆ D3DXFresnelTerm()

◆ D3DXMatrixAffineTransformation()

◆ D3DXMatrixAffineTransformation2D()

◆ D3DXMatrixDecompose()

◆ D3DXMatrixDeterminant()

◆ D3DXMatrixInverse()

◆ D3DXMatrixLookAtLH()

◆ D3DXMatrixLookAtRH()

◆ D3DXMatrixMultiply()

◆ D3DXMatrixMultiplyTranspose()

◆ D3DXMatrixOrthoLH()

◆ D3DXMatrixOrthoOffCenterLH()

◆ D3DXMatrixOrthoOffCenterRH()

◆ D3DXMatrixOrthoRH()

◆ D3DXMatrixPerspectiveFovLH()

◆ D3DXMatrixPerspectiveFovRH()

◆ D3DXMatrixPerspectiveLH()

◆ D3DXMatrixPerspectiveOffCenterLH()

◆ D3DXMatrixPerspectiveOffCenterRH()

◆ D3DXMatrixPerspectiveRH()

◆ D3DXMatrixReflect()

◆ D3DXMatrixRotationAxis()

◆ D3DXMatrixRotationQuaternion()

◆ D3DXMatrixRotationX()

◆ D3DXMatrixRotationY()

◆ D3DXMatrixRotationYawPitchRoll()

◆ D3DXMatrixRotationZ()

◆ D3DXMatrixScaling()

◆ D3DXMatrixShadow()

◆ D3DXMatrixTransformation()

◆ D3DXMatrixTransformation2D()

◆ D3DXMatrixTranslation()

◆ D3DXMatrixTranspose()

◆ D3DXPlaneFromPointNormal()

◆ D3DXPlaneFromPoints()

◆ D3DXPlaneIntersectLine()

◆ D3DXPlaneNormalize()

◆ D3DXPlaneTransform()

◆ D3DXPlaneTransformArray()

◆ D3DXQuaternionBaryCentric()

◆ D3DXQuaternionExp()

◆ D3DXQuaternionInverse()

◆ D3DXQuaternionLn()

◆ D3DXQuaternionMultiply()

◆ D3DXQuaternionNormalize()

◆ D3DXQuaternionRotationAxis()

◆ D3DXQuaternionRotationMatrix()

◆ D3DXQuaternionRotationYawPitchRoll()

◆ D3DXQuaternionSlerp()

◆ D3DXQuaternionSquad()

◆ D3DXQuaternionSquadSetup()

◆ D3DXQuaternionToAxisAngle()

◆ D3DXSHAdd()

◆ D3DXSHDot()

◆ D3DXSHEvalConeLight()

◆ D3DXSHEvalDirection()

◆ D3DXSHEvalDirectionalLight()

◆ D3DXSHEvalHemisphereLight()

◆ D3DXSHEvalSphericalLight()

◆ D3DXSHMultiply2()

◆ D3DXSHMultiply3()

◆ D3DXSHMultiply4()