The main release package of Ashita v3. Contains all the needed files for users to get up and running. Used by the launcher/injector to auto-update as well.
https://ashitaxi.com/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1215 lines
37 KiB
1215 lines
37 KiB
////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// Copyright (C) Microsoft Corporation. All Rights Reserved. |
|
// |
|
// File: d3dx8math.h |
|
// Content: D3DX math types and functions |
|
// |
|
////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include "d3dx8.h" |
|
|
|
#ifndef __D3DX8MATH_H__ |
|
#define __D3DX8MATH_H__ |
|
|
|
#include <math.h> |
|
#pragma warning(disable:4201) // anonymous unions warning |
|
|
|
|
|
|
|
//=========================================================================== |
|
// |
|
// General purpose utilities |
|
// |
|
//=========================================================================== |
|
#define D3DX_PI ((FLOAT) 3.141592654f) |
|
#define D3DX_1BYPI ((FLOAT) 0.318309886f) |
|
|
|
#define D3DXToRadian( degree ) ((degree) * (D3DX_PI / 180.0f)) |
|
#define D3DXToDegree( radian ) ((radian) * (180.0f / D3DX_PI)) |
|
|
|
|
|
|
|
//=========================================================================== |
|
// |
|
// Vectors |
|
// |
|
//=========================================================================== |
|
|
|
//-------------------------- |
|
// 2D Vector |
|
//-------------------------- |
|
typedef struct D3DXVECTOR2 |
|
{ |
|
#ifdef __cplusplus |
|
public: |
|
D3DXVECTOR2() {}; |
|
D3DXVECTOR2( CONST FLOAT * ); |
|
D3DXVECTOR2( FLOAT x, FLOAT y ); |
|
|
|
// casting |
|
operator FLOAT* (); |
|
operator CONST FLOAT* () const; |
|
|
|
// assignment operators |
|
D3DXVECTOR2& operator += ( CONST D3DXVECTOR2& ); |
|
D3DXVECTOR2& operator -= ( CONST D3DXVECTOR2& ); |
|
D3DXVECTOR2& operator *= ( FLOAT ); |
|
D3DXVECTOR2& operator /= ( FLOAT ); |
|
|
|
// unary operators |
|
D3DXVECTOR2 operator + () const; |
|
D3DXVECTOR2 operator - () const; |
|
|
|
// binary operators |
|
D3DXVECTOR2 operator + ( CONST D3DXVECTOR2& ) const; |
|
D3DXVECTOR2 operator - ( CONST D3DXVECTOR2& ) const; |
|
D3DXVECTOR2 operator * ( FLOAT ) const; |
|
D3DXVECTOR2 operator / ( FLOAT ) const; |
|
|
|
friend D3DXVECTOR2 operator * ( FLOAT, CONST D3DXVECTOR2& ); |
|
|
|
BOOL operator == ( CONST D3DXVECTOR2& ) const; |
|
BOOL operator != ( CONST D3DXVECTOR2& ) const; |
|
|
|
|
|
public: |
|
#endif //__cplusplus |
|
FLOAT x, y; |
|
} D3DXVECTOR2, *LPD3DXVECTOR2; |
|
|
|
|
|
//-------------------------- |
|
// 3D Vector |
|
//-------------------------- |
|
#ifdef __cplusplus |
|
typedef struct D3DXVECTOR3 : public D3DVECTOR |
|
{ |
|
public: |
|
D3DXVECTOR3() {}; |
|
D3DXVECTOR3( CONST FLOAT * ); |
|
D3DXVECTOR3( CONST D3DVECTOR& ); |
|
D3DXVECTOR3( FLOAT x, FLOAT y, FLOAT z ); |
|
|
|
// casting |
|
operator FLOAT* (); |
|
operator CONST FLOAT* () const; |
|
|
|
// assignment operators |
|
D3DXVECTOR3& operator += ( CONST D3DXVECTOR3& ); |
|
D3DXVECTOR3& operator -= ( CONST D3DXVECTOR3& ); |
|
D3DXVECTOR3& operator *= ( FLOAT ); |
|
D3DXVECTOR3& operator /= ( FLOAT ); |
|
|
|
// unary operators |
|
D3DXVECTOR3 operator + () const; |
|
D3DXVECTOR3 operator - () const; |
|
|
|
// binary operators |
|
D3DXVECTOR3 operator + ( CONST D3DXVECTOR3& ) const; |
|
D3DXVECTOR3 operator - ( CONST D3DXVECTOR3& ) const; |
|
D3DXVECTOR3 operator * ( FLOAT ) const; |
|
D3DXVECTOR3 operator / ( FLOAT ) const; |
|
|
|
friend D3DXVECTOR3 operator * ( FLOAT, CONST struct D3DXVECTOR3& ); |
|
|
|
BOOL operator == ( CONST D3DXVECTOR3& ) const; |
|
BOOL operator != ( CONST D3DXVECTOR3& ) const; |
|
|
|
} D3DXVECTOR3, *LPD3DXVECTOR3; |
|
|
|
#else //!__cplusplus |
|
typedef struct _D3DVECTOR D3DXVECTOR3, *LPD3DXVECTOR3; |
|
#endif //!__cplusplus |
|
|
|
|
|
//-------------------------- |
|
// 4D Vector |
|
//-------------------------- |
|
typedef struct D3DXVECTOR4 |
|
{ |
|
#ifdef __cplusplus |
|
public: |
|
D3DXVECTOR4() {}; |
|
D3DXVECTOR4( CONST FLOAT* ); |
|
D3DXVECTOR4( FLOAT x, FLOAT y, FLOAT z, FLOAT w ); |
|
|
|
// casting |
|
operator FLOAT* (); |
|
operator CONST FLOAT* () const; |
|
|
|
// assignment operators |
|
D3DXVECTOR4& operator += ( CONST D3DXVECTOR4& ); |
|
D3DXVECTOR4& operator -= ( CONST D3DXVECTOR4& ); |
|
D3DXVECTOR4& operator *= ( FLOAT ); |
|
D3DXVECTOR4& operator /= ( FLOAT ); |
|
|
|
// unary operators |
|
D3DXVECTOR4 operator + () const; |
|
D3DXVECTOR4 operator - () const; |
|
|
|
// binary operators |
|
D3DXVECTOR4 operator + ( CONST D3DXVECTOR4& ) const; |
|
D3DXVECTOR4 operator - ( CONST D3DXVECTOR4& ) const; |
|
D3DXVECTOR4 operator * ( FLOAT ) const; |
|
D3DXVECTOR4 operator / ( FLOAT ) const; |
|
|
|
friend D3DXVECTOR4 operator * ( FLOAT, CONST D3DXVECTOR4& ); |
|
|
|
BOOL operator == ( CONST D3DXVECTOR4& ) const; |
|
BOOL operator != ( CONST D3DXVECTOR4& ) const; |
|
|
|
public: |
|
#endif //__cplusplus |
|
FLOAT x, y, z, w; |
|
} D3DXVECTOR4, *LPD3DXVECTOR4; |
|
|
|
|
|
//=========================================================================== |
|
// |
|
// Matrices |
|
// |
|
//=========================================================================== |
|
#ifdef __cplusplus |
|
typedef struct D3DXMATRIX : public D3DMATRIX |
|
{ |
|
public: |
|
D3DXMATRIX() {}; |
|
D3DXMATRIX( CONST FLOAT * ); |
|
D3DXMATRIX( CONST D3DMATRIX& ); |
|
D3DXMATRIX( FLOAT _11, FLOAT _12, FLOAT _13, FLOAT _14, |
|
FLOAT _21, FLOAT _22, FLOAT _23, FLOAT _24, |
|
FLOAT _31, FLOAT _32, FLOAT _33, FLOAT _34, |
|
FLOAT _41, FLOAT _42, FLOAT _43, FLOAT _44 ); |
|
|
|
|
|
// access grants |
|
FLOAT& operator () ( UINT Row, UINT Col ); |
|
FLOAT operator () ( UINT Row, UINT Col ) const; |
|
|
|
// casting operators |
|
operator FLOAT* (); |
|
operator CONST FLOAT* () const; |
|
|
|
// assignment operators |
|
D3DXMATRIX& operator *= ( CONST D3DXMATRIX& ); |
|
D3DXMATRIX& operator += ( CONST D3DXMATRIX& ); |
|
D3DXMATRIX& operator -= ( CONST D3DXMATRIX& ); |
|
D3DXMATRIX& operator *= ( FLOAT ); |
|
D3DXMATRIX& operator /= ( FLOAT ); |
|
|
|
// unary operators |
|
D3DXMATRIX operator + () const; |
|
D3DXMATRIX operator - () const; |
|
|
|
// binary operators |
|
D3DXMATRIX operator * ( CONST D3DXMATRIX& ) const; |
|
D3DXMATRIX operator + ( CONST D3DXMATRIX& ) const; |
|
D3DXMATRIX operator - ( CONST D3DXMATRIX& ) const; |
|
D3DXMATRIX operator * ( FLOAT ) const; |
|
D3DXMATRIX operator / ( FLOAT ) const; |
|
|
|
friend D3DXMATRIX operator * ( FLOAT, CONST D3DXMATRIX& ); |
|
|
|
BOOL operator == ( CONST D3DXMATRIX& ) const; |
|
BOOL operator != ( CONST D3DXMATRIX& ) const; |
|
|
|
} D3DXMATRIX, *LPD3DXMATRIX; |
|
|
|
#else //!__cplusplus |
|
typedef struct _D3DMATRIX D3DXMATRIX, *LPD3DXMATRIX; |
|
#endif //!__cplusplus |
|
|
|
//=========================================================================== |
|
// |
|
// Aligned Matrices |
|
// |
|
// This class helps keep matrices 16-byte aligned as preferred by P4 cpus. |
|
// It aligns matrices on the stack and on the heap or in global scope. |
|
// It does this using __declspec(align(16)) which works on VC7 and on VC 6 |
|
// with the processor pack. Unfortunately there is no way to detect the |
|
// latter so this is turned on only on VC7. On other compilers this is the |
|
// the same as D3DXMATRIX. |
|
// Using this class on a compiler that does not actually do the alignment |
|
// can be dangerous since it will not expose bugs that ignore alignment. |
|
// E.g if an object of this class in inside a struct or class, and some code |
|
// memcopys data in it assuming tight packing. This could break on a compiler |
|
// that eventually start aligning the matrix. |
|
// |
|
//=========================================================================== |
|
#ifdef __cplusplus |
|
typedef struct _D3DXMATRIXA16 : public D3DXMATRIX |
|
{ |
|
_D3DXMATRIXA16() {} |
|
_D3DXMATRIXA16( CONST FLOAT * f): D3DXMATRIX(f) {} |
|
_D3DXMATRIXA16( CONST D3DMATRIX& m): D3DXMATRIX(m) {} |
|
_D3DXMATRIXA16( FLOAT _11, FLOAT _12, FLOAT _13, FLOAT _14, |
|
FLOAT _21, FLOAT _22, FLOAT _23, FLOAT _24, |
|
FLOAT _31, FLOAT _32, FLOAT _33, FLOAT _34, |
|
FLOAT _41, FLOAT _42, FLOAT _43, FLOAT _44 ) : |
|
D3DXMATRIX(_11, _12, _13, _14, |
|
_21, _22, _23, _24, |
|
_31, _32, _33, _34, |
|
_41, _42, _43, _44) {} |
|
void* operator new(size_t s) |
|
{ |
|
LPBYTE p = ::new BYTE[s + 16]; |
|
if (p) |
|
{ |
|
BYTE offset = (BYTE)(16 - ((UINT_PTR)p & 15)); |
|
p += offset; |
|
p[-1] = offset; |
|
} |
|
return p; |
|
}; |
|
|
|
void* operator new[](size_t s) |
|
{ |
|
LPBYTE p = ::new BYTE[s + 16]; |
|
if (p) |
|
{ |
|
BYTE offset = (BYTE)(16 - ((UINT_PTR)p & 15)); |
|
p += offset; |
|
p[-1] = offset; |
|
} |
|
return p; |
|
}; |
|
|
|
// This is NOT a virtual operator. If you cast |
|
// to D3DXMATRIX, do not delete using that |
|
void operator delete(void* p) |
|
{ |
|
if(p) |
|
{ |
|
BYTE* pb = static_cast<BYTE*>(p); |
|
pb -= pb[-1]; |
|
::delete [] pb; |
|
} |
|
}; |
|
|
|
// This is NOT a virtual operator. If you cast |
|
// to D3DXMATRIX, do not delete using that |
|
void operator delete[](void* p) |
|
{ |
|
if(p) |
|
{ |
|
BYTE* pb = static_cast<BYTE*>(p); |
|
pb -= pb[-1]; |
|
::delete [] pb; |
|
} |
|
}; |
|
|
|
struct _D3DXMATRIXA16& operator=(CONST D3DXMATRIX& rhs) |
|
{ |
|
memcpy(&_11, &rhs, sizeof(D3DXMATRIX)); |
|
return *this; |
|
}; |
|
} _D3DXMATRIXA16; |
|
|
|
#else //!__cplusplus |
|
typedef D3DXMATRIX _D3DXMATRIXA16; |
|
#endif //!__cplusplus |
|
|
|
#if _MSC_VER >= 1300 // VC7 |
|
#define _ALIGN_16 __declspec(align(16)) |
|
#else |
|
#define _ALIGN_16 // Earlier compiler may not understand this, do nothing. |
|
#endif |
|
|
|
#define D3DXMATRIXA16 _ALIGN_16 _D3DXMATRIXA16 |
|
|
|
typedef D3DXMATRIXA16 *LPD3DXMATRIXA16; |
|
|
|
//=========================================================================== |
|
// |
|
// Quaternions |
|
// |
|
//=========================================================================== |
|
typedef struct D3DXQUATERNION |
|
{ |
|
#ifdef __cplusplus |
|
public: |
|
D3DXQUATERNION() {} |
|
D3DXQUATERNION( CONST FLOAT * ); |
|
D3DXQUATERNION( FLOAT x, FLOAT y, FLOAT z, FLOAT w ); |
|
|
|
// casting |
|
operator FLOAT* (); |
|
operator CONST FLOAT* () const; |
|
|
|
// assignment operators |
|
D3DXQUATERNION& operator += ( CONST D3DXQUATERNION& ); |
|
D3DXQUATERNION& operator -= ( CONST D3DXQUATERNION& ); |
|
D3DXQUATERNION& operator *= ( CONST D3DXQUATERNION& ); |
|
D3DXQUATERNION& operator *= ( FLOAT ); |
|
D3DXQUATERNION& operator /= ( FLOAT ); |
|
|
|
// unary operators |
|
D3DXQUATERNION operator + () const; |
|
D3DXQUATERNION operator - () const; |
|
|
|
// binary operators |
|
D3DXQUATERNION operator + ( CONST D3DXQUATERNION& ) const; |
|
D3DXQUATERNION operator - ( CONST D3DXQUATERNION& ) const; |
|
D3DXQUATERNION operator * ( CONST D3DXQUATERNION& ) const; |
|
D3DXQUATERNION operator * ( FLOAT ) const; |
|
D3DXQUATERNION operator / ( FLOAT ) const; |
|
|
|
friend D3DXQUATERNION operator * (FLOAT, CONST D3DXQUATERNION& ); |
|
|
|
BOOL operator == ( CONST D3DXQUATERNION& ) const; |
|
BOOL operator != ( CONST D3DXQUATERNION& ) const; |
|
|
|
#endif //__cplusplus |
|
FLOAT x, y, z, w; |
|
} D3DXQUATERNION, *LPD3DXQUATERNION; |
|
|
|
|
|
//=========================================================================== |
|
// |
|
// Planes |
|
// |
|
//=========================================================================== |
|
typedef struct D3DXPLANE |
|
{ |
|
#ifdef __cplusplus |
|
public: |
|
D3DXPLANE() {} |
|
D3DXPLANE( CONST FLOAT* ); |
|
D3DXPLANE( FLOAT a, FLOAT b, FLOAT c, FLOAT d ); |
|
|
|
// casting |
|
operator FLOAT* (); |
|
operator CONST FLOAT* () const; |
|
|
|
// unary operators |
|
D3DXPLANE operator + () const; |
|
D3DXPLANE operator - () const; |
|
|
|
// binary operators |
|
BOOL operator == ( CONST D3DXPLANE& ) const; |
|
BOOL operator != ( CONST D3DXPLANE& ) const; |
|
|
|
#endif //__cplusplus |
|
FLOAT a, b, c, d; |
|
} D3DXPLANE, *LPD3DXPLANE; |
|
|
|
|
|
//=========================================================================== |
|
// |
|
// Colors |
|
// |
|
//=========================================================================== |
|
|
|
typedef struct D3DXCOLOR |
|
{ |
|
#ifdef __cplusplus |
|
public: |
|
D3DXCOLOR() {} |
|
D3DXCOLOR( DWORD argb ); |
|
D3DXCOLOR( CONST FLOAT * ); |
|
D3DXCOLOR( CONST D3DCOLORVALUE& ); |
|
D3DXCOLOR( FLOAT r, FLOAT g, FLOAT b, FLOAT a ); |
|
|
|
// casting |
|
operator DWORD () const; |
|
|
|
operator FLOAT* (); |
|
operator CONST FLOAT* () const; |
|
|
|
operator D3DCOLORVALUE* (); |
|
operator CONST D3DCOLORVALUE* () const; |
|
|
|
operator D3DCOLORVALUE& (); |
|
operator CONST D3DCOLORVALUE& () const; |
|
|
|
// assignment operators |
|
D3DXCOLOR& operator += ( CONST D3DXCOLOR& ); |
|
D3DXCOLOR& operator -= ( CONST D3DXCOLOR& ); |
|
D3DXCOLOR& operator *= ( FLOAT ); |
|
D3DXCOLOR& operator /= ( FLOAT ); |
|
|
|
// unary operators |
|
D3DXCOLOR operator + () const; |
|
D3DXCOLOR operator - () const; |
|
|
|
// binary operators |
|
D3DXCOLOR operator + ( CONST D3DXCOLOR& ) const; |
|
D3DXCOLOR operator - ( CONST D3DXCOLOR& ) const; |
|
D3DXCOLOR operator * ( FLOAT ) const; |
|
D3DXCOLOR operator / ( FLOAT ) const; |
|
|
|
friend D3DXCOLOR operator * (FLOAT, CONST D3DXCOLOR& ); |
|
|
|
BOOL operator == ( CONST D3DXCOLOR& ) const; |
|
BOOL operator != ( CONST D3DXCOLOR& ) const; |
|
|
|
#endif //__cplusplus |
|
FLOAT r, g, b, a; |
|
} D3DXCOLOR, *LPD3DXCOLOR; |
|
|
|
|
|
|
|
//=========================================================================== |
|
// |
|
// D3DX math functions: |
|
// |
|
// NOTE: |
|
// * All these functions can take the same object as in and out parameters. |
|
// |
|
// * Out parameters are typically also returned as return values, so that |
|
// the output of one function may be used as a parameter to another. |
|
// |
|
//=========================================================================== |
|
|
|
//-------------------------- |
|
// 2D Vector |
|
//-------------------------- |
|
|
|
// inline |
|
|
|
FLOAT D3DXVec2Length |
|
( CONST D3DXVECTOR2 *pV ); |
|
|
|
FLOAT D3DXVec2LengthSq |
|
( CONST D3DXVECTOR2 *pV ); |
|
|
|
FLOAT D3DXVec2Dot |
|
( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); |
|
|
|
// Z component of ((x1,y1,0) cross (x2,y2,0)) |
|
FLOAT D3DXVec2CCW |
|
( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); |
|
|
|
D3DXVECTOR2* D3DXVec2Add |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); |
|
|
|
D3DXVECTOR2* D3DXVec2Subtract |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); |
|
|
|
// Minimize each component. x = min(x1, x2), y = min(y1, y2) |
|
D3DXVECTOR2* D3DXVec2Minimize |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); |
|
|
|
// Maximize each component. x = max(x1, x2), y = max(y1, y2) |
|
D3DXVECTOR2* D3DXVec2Maximize |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 ); |
|
|
|
D3DXVECTOR2* D3DXVec2Scale |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, FLOAT s ); |
|
|
|
// Linear interpolation. V1 + s(V2-V1) |
|
D3DXVECTOR2* D3DXVec2Lerp |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2, |
|
FLOAT s ); |
|
|
|
// non-inline |
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
D3DXVECTOR2* WINAPI D3DXVec2Normalize |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV ); |
|
|
|
// Hermite interpolation between position V1, tangent T1 (when s == 0) |
|
// and position V2, tangent T2 (when s == 1). |
|
D3DXVECTOR2* WINAPI D3DXVec2Hermite |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pT1, |
|
CONST D3DXVECTOR2 *pV2, CONST D3DXVECTOR2 *pT2, FLOAT s ); |
|
|
|
// CatmullRom interpolation between V1 (when s == 0) and V2 (when s == 1) |
|
D3DXVECTOR2* WINAPI D3DXVec2CatmullRom |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV0, CONST D3DXVECTOR2 *pV1, |
|
CONST D3DXVECTOR2 *pV2, CONST D3DXVECTOR2 *pV3, FLOAT s ); |
|
|
|
// Barycentric coordinates. V1 + f(V2-V1) + g(V3-V1) |
|
D3DXVECTOR2* WINAPI D3DXVec2BaryCentric |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2, |
|
CONST D3DXVECTOR2 *pV3, FLOAT f, FLOAT g); |
|
|
|
// Transform (x, y, 0, 1) by matrix. |
|
D3DXVECTOR4* WINAPI D3DXVec2Transform |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR2 *pV, CONST D3DXMATRIX *pM ); |
|
|
|
// Transform (x, y, 0, 1) by matrix, project result back into w=1. |
|
D3DXVECTOR2* WINAPI D3DXVec2TransformCoord |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, CONST D3DXMATRIX *pM ); |
|
|
|
// Transform (x, y, 0, 0) by matrix. |
|
D3DXVECTOR2* WINAPI D3DXVec2TransformNormal |
|
( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, CONST D3DXMATRIX *pM ); |
|
|
|
#ifdef __cplusplus |
|
} |
|
#endif |
|
|
|
|
|
//-------------------------- |
|
// 3D Vector |
|
//-------------------------- |
|
|
|
// inline |
|
|
|
FLOAT D3DXVec3Length |
|
( CONST D3DXVECTOR3 *pV ); |
|
|
|
FLOAT D3DXVec3LengthSq |
|
( CONST D3DXVECTOR3 *pV ); |
|
|
|
FLOAT D3DXVec3Dot |
|
( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); |
|
|
|
D3DXVECTOR3* D3DXVec3Cross |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); |
|
|
|
D3DXVECTOR3* D3DXVec3Add |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); |
|
|
|
D3DXVECTOR3* D3DXVec3Subtract |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); |
|
|
|
// Minimize each component. x = min(x1, x2), y = min(y1, y2), ... |
|
D3DXVECTOR3* D3DXVec3Minimize |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); |
|
|
|
// Maximize each component. x = max(x1, x2), y = max(y1, y2), ... |
|
D3DXVECTOR3* D3DXVec3Maximize |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 ); |
|
|
|
D3DXVECTOR3* D3DXVec3Scale |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, FLOAT s); |
|
|
|
// Linear interpolation. V1 + s(V2-V1) |
|
D3DXVECTOR3* D3DXVec3Lerp |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2, |
|
FLOAT s ); |
|
|
|
// non-inline |
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
D3DXVECTOR3* WINAPI D3DXVec3Normalize |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV ); |
|
|
|
// Hermite interpolation between position V1, tangent T1 (when s == 0) |
|
// and position V2, tangent T2 (when s == 1). |
|
D3DXVECTOR3* WINAPI D3DXVec3Hermite |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pT1, |
|
CONST D3DXVECTOR3 *pV2, CONST D3DXVECTOR3 *pT2, FLOAT s ); |
|
|
|
// CatmullRom interpolation between V1 (when s == 0) and V2 (when s == 1) |
|
D3DXVECTOR3* WINAPI D3DXVec3CatmullRom |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV0, CONST D3DXVECTOR3 *pV1, |
|
CONST D3DXVECTOR3 *pV2, CONST D3DXVECTOR3 *pV3, FLOAT s ); |
|
|
|
// Barycentric coordinates. V1 + f(V2-V1) + g(V3-V1) |
|
D3DXVECTOR3* WINAPI D3DXVec3BaryCentric |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2, |
|
CONST D3DXVECTOR3 *pV3, FLOAT f, FLOAT g); |
|
|
|
// Transform (x, y, z, 1) by matrix. |
|
D3DXVECTOR4* WINAPI D3DXVec3Transform |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM ); |
|
|
|
// Transform (x, y, z, 1) by matrix, project result back into w=1. |
|
D3DXVECTOR3* WINAPI D3DXVec3TransformCoord |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM ); |
|
|
|
// Transform (x, y, z, 0) by matrix. If you transforming a normal by a |
|
// non-affine matrix, the matrix you pass to this function should be the |
|
// transpose of the inverse of the matrix you would use to transform a coord. |
|
D3DXVECTOR3* WINAPI D3DXVec3TransformNormal |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM ); |
|
|
|
// Project vector from object space into screen space |
|
D3DXVECTOR3* WINAPI D3DXVec3Project |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DVIEWPORT8 *pViewport, |
|
CONST D3DXMATRIX *pProjection, CONST D3DXMATRIX *pView, CONST D3DXMATRIX *pWorld); |
|
|
|
// Project vector from screen space into object space |
|
D3DXVECTOR3* WINAPI D3DXVec3Unproject |
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DVIEWPORT8 *pViewport, |
|
CONST D3DXMATRIX *pProjection, CONST D3DXMATRIX *pView, CONST D3DXMATRIX *pWorld); |
|
|
|
#ifdef __cplusplus |
|
} |
|
#endif |
|
|
|
|
|
|
|
//-------------------------- |
|
// 4D Vector |
|
//-------------------------- |
|
|
|
// inline |
|
|
|
FLOAT D3DXVec4Length |
|
( CONST D3DXVECTOR4 *pV ); |
|
|
|
FLOAT D3DXVec4LengthSq |
|
( CONST D3DXVECTOR4 *pV ); |
|
|
|
FLOAT D3DXVec4Dot |
|
( CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2 ); |
|
|
|
D3DXVECTOR4* D3DXVec4Add |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2); |
|
|
|
D3DXVECTOR4* D3DXVec4Subtract |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2); |
|
|
|
// Minimize each component. x = min(x1, x2), y = min(y1, y2), ... |
|
D3DXVECTOR4* D3DXVec4Minimize |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2); |
|
|
|
// Maximize each component. x = max(x1, x2), y = max(y1, y2), ... |
|
D3DXVECTOR4* D3DXVec4Maximize |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2); |
|
|
|
D3DXVECTOR4* D3DXVec4Scale |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, FLOAT s); |
|
|
|
// Linear interpolation. V1 + s(V2-V1) |
|
D3DXVECTOR4* D3DXVec4Lerp |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2, |
|
FLOAT s ); |
|
|
|
// non-inline |
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
// Cross-product in 4 dimensions. |
|
D3DXVECTOR4* WINAPI D3DXVec4Cross |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2, |
|
CONST D3DXVECTOR4 *pV3); |
|
|
|
D3DXVECTOR4* WINAPI D3DXVec4Normalize |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV ); |
|
|
|
// Hermite interpolation between position V1, tangent T1 (when s == 0) |
|
// and position V2, tangent T2 (when s == 1). |
|
D3DXVECTOR4* WINAPI D3DXVec4Hermite |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pT1, |
|
CONST D3DXVECTOR4 *pV2, CONST D3DXVECTOR4 *pT2, FLOAT s ); |
|
|
|
// CatmullRom interpolation between V1 (when s == 0) and V2 (when s == 1) |
|
D3DXVECTOR4* WINAPI D3DXVec4CatmullRom |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV0, CONST D3DXVECTOR4 *pV1, |
|
CONST D3DXVECTOR4 *pV2, CONST D3DXVECTOR4 *pV3, FLOAT s ); |
|
|
|
// Barycentric coordinates. V1 + f(V2-V1) + g(V3-V1) |
|
D3DXVECTOR4* WINAPI D3DXVec4BaryCentric |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2, |
|
CONST D3DXVECTOR4 *pV3, FLOAT f, FLOAT g); |
|
|
|
// Transform vector by matrix. |
|
D3DXVECTOR4* WINAPI D3DXVec4Transform |
|
( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, CONST D3DXMATRIX *pM ); |
|
|
|
#ifdef __cplusplus |
|
} |
|
#endif |
|
|
|
|
|
//-------------------------- |
|
// 4D Matrix |
|
//-------------------------- |
|
|
|
// inline |
|
|
|
D3DXMATRIX* D3DXMatrixIdentity |
|
( D3DXMATRIX *pOut ); |
|
|
|
BOOL D3DXMatrixIsIdentity |
|
( CONST D3DXMATRIX *pM ); |
|
|
|
|
|
// non-inline |
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
FLOAT WINAPI D3DXMatrixfDeterminant |
|
( CONST D3DXMATRIX *pM ); |
|
|
|
D3DXMATRIX* WINAPI D3DXMatrixTranspose |
|
( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM ); |
|
|
|
// Matrix multiplication. The result represents the transformation M2 |
|
// followed by the transformation M1. (Out = M1 * M2) |
|
D3DXMATRIX* WINAPI D3DXMatrixMultiply |
|
( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 ); |
|
|
|
// Matrix multiplication, followed by a transpose. (Out = T(M1 * M2)) |
|
D3DXMATRIX* WINAPI D3DXMatrixMultiplyTranspose |
|
( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 ); |
|
|
|
// Calculate inverse of matrix. Inversion my fail, in which case NULL will |
|
// be returned. The determinant of pM is also returned it pfDeterminant |
|
// is non-NULL. |
|
D3DXMATRIX* WINAPI D3DXMatrixInverse |
|
( D3DXMATRIX *pOut, FLOAT *pDeterminant, CONST D3DXMATRIX *pM ); |
|
|
|
// Build a matrix which scales by (sx, sy, sz) |
|
D3DXMATRIX* WINAPI D3DXMatrixScaling |
|
( D3DXMATRIX *pOut, FLOAT sx, FLOAT sy, FLOAT sz ); |
|
|
|
// Build a matrix which translates by (x, y, z) |
|
D3DXMATRIX* WINAPI D3DXMatrixTranslation |
|
( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z ); |
|
|
|
// Build a matrix which rotates around the X axis |
|
D3DXMATRIX* WINAPI D3DXMatrixRotationX |
|
( D3DXMATRIX *pOut, FLOAT Angle ); |
|
|
|
// Build a matrix which rotates around the Y axis |
|
D3DXMATRIX* WINAPI D3DXMatrixRotationY |
|
( D3DXMATRIX *pOut, FLOAT Angle ); |
|
|
|
// Build a matrix which rotates around the Z axis |
|
D3DXMATRIX* WINAPI D3DXMatrixRotationZ |
|
( D3DXMATRIX *pOut, FLOAT Angle ); |
|
|
|
// Build a matrix which rotates around an arbitrary axis |
|
D3DXMATRIX* WINAPI D3DXMatrixRotationAxis |
|
( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pV, FLOAT Angle ); |
|
|
|
// Build a matrix from a quaternion |
|
D3DXMATRIX* WINAPI D3DXMatrixRotationQuaternion |
|
( D3DXMATRIX *pOut, CONST D3DXQUATERNION *pQ); |
|
|
|
// Yaw around the Y axis, a pitch around the X axis, |
|
// and a roll around the Z axis. |
|
D3DXMATRIX* WINAPI D3DXMatrixRotationYawPitchRoll |
|
( D3DXMATRIX *pOut, FLOAT Yaw, FLOAT Pitch, FLOAT Roll ); |
|
|
|
|
|
// Build transformation matrix. NULL arguments are treated as identity. |
|
// Mout = Msc-1 * Msr-1 * Ms * Msr * Msc * Mrc-1 * Mr * Mrc * Mt |
|
D3DXMATRIX* WINAPI D3DXMatrixTransformation |
|
( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pScalingCenter, |
|
CONST D3DXQUATERNION *pScalingRotation, CONST D3DXVECTOR3 *pScaling, |
|
CONST D3DXVECTOR3 *pRotationCenter, CONST D3DXQUATERNION *pRotation, |
|
CONST D3DXVECTOR3 *pTranslation); |
|
|
|
// Build affine transformation matrix. NULL arguments are treated as identity. |
|
// Mout = Ms * Mrc-1 * Mr * Mrc * Mt |
|
D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation |
|
( D3DXMATRIX *pOut, FLOAT Scaling, CONST D3DXVECTOR3 *pRotationCenter, |
|
CONST D3DXQUATERNION *pRotation, CONST D3DXVECTOR3 *pTranslation); |
|
|
|
// Build a lookat matrix. (right-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixLookAtRH |
|
( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pEye, CONST D3DXVECTOR3 *pAt, |
|
CONST D3DXVECTOR3 *pUp ); |
|
|
|
// Build a lookat matrix. (left-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixLookAtLH |
|
( D3DXMATRIX *pOut, CONST D3DXVECTOR3 *pEye, CONST D3DXVECTOR3 *pAt, |
|
CONST D3DXVECTOR3 *pUp ); |
|
|
|
// Build a perspective projection matrix. (right-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixPerspectiveRH |
|
( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf ); |
|
|
|
// Build a perspective projection matrix. (left-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixPerspectiveLH |
|
( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf ); |
|
|
|
// Build a perspective projection matrix. (right-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovRH |
|
( D3DXMATRIX *pOut, FLOAT fovy, FLOAT Aspect, FLOAT zn, FLOAT zf ); |
|
|
|
// Build a perspective projection matrix. (left-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovLH |
|
( D3DXMATRIX *pOut, FLOAT fovy, FLOAT Aspect, FLOAT zn, FLOAT zf ); |
|
|
|
// Build a perspective projection matrix. (right-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterRH |
|
( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, |
|
FLOAT zf ); |
|
|
|
// Build a perspective projection matrix. (left-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterLH |
|
( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, |
|
FLOAT zf ); |
|
|
|
// Build an ortho projection matrix. (right-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixOrthoRH |
|
( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf ); |
|
|
|
// Build an ortho projection matrix. (left-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixOrthoLH |
|
( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf ); |
|
|
|
// Build an ortho projection matrix. (right-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterRH |
|
( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, |
|
FLOAT zf ); |
|
|
|
// Build an ortho projection matrix. (left-handed) |
|
D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterLH |
|
( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, |
|
FLOAT zf ); |
|
|
|
// Build a matrix which flattens geometry into a plane, as if casting |
|
// a shadow from a light. |
|
D3DXMATRIX* WINAPI D3DXMatrixShadow |
|
( D3DXMATRIX *pOut, CONST D3DXVECTOR4 *pLight, |
|
CONST D3DXPLANE *pPlane ); |
|
|
|
// Build a matrix which reflects the coordinate system about a plane |
|
D3DXMATRIX* WINAPI D3DXMatrixReflect |
|
( D3DXMATRIX *pOut, CONST D3DXPLANE *pPlane ); |
|
|
|
#ifdef __cplusplus |
|
} |
|
#endif |
|
|
|
|
|
//-------------------------- |
|
// Quaternion |
|
//-------------------------- |
|
|
|
// inline |
|
|
|
FLOAT D3DXQuaternionLength |
|
( CONST D3DXQUATERNION *pQ ); |
|
|
|
// Length squared, or "norm" |
|
FLOAT D3DXQuaternionLengthSq |
|
( CONST D3DXQUATERNION *pQ ); |
|
|
|
FLOAT D3DXQuaternionDot |
|
( CONST D3DXQUATERNION *pQ1, CONST D3DXQUATERNION *pQ2 ); |
|
|
|
// (0, 0, 0, 1) |
|
D3DXQUATERNION* D3DXQuaternionIdentity |
|
( D3DXQUATERNION *pOut ); |
|
|
|
BOOL D3DXQuaternionIsIdentity |
|
( CONST D3DXQUATERNION *pQ ); |
|
|
|
// (-x, -y, -z, w) |
|
D3DXQUATERNION* D3DXQuaternionConjugate |
|
( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ ); |
|
|
|
|
|
// non-inline |
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
// Compute a quaternin's axis and angle of rotation. Expects unit quaternions. |
|
void WINAPI D3DXQuaternionToAxisAngle |
|
( CONST D3DXQUATERNION *pQ, D3DXVECTOR3 *pAxis, FLOAT *pAngle ); |
|
|
|
// Build a quaternion from a rotation matrix. |
|
D3DXQUATERNION* WINAPI D3DXQuaternionRotationMatrix |
|
( D3DXQUATERNION *pOut, CONST D3DXMATRIX *pM); |
|
|
|
// Rotation about arbitrary axis. |
|
D3DXQUATERNION* WINAPI D3DXQuaternionRotationAxis |
|
( D3DXQUATERNION *pOut, CONST D3DXVECTOR3 *pV, FLOAT Angle ); |
|
|
|
// Yaw around the Y axis, a pitch around the X axis, |
|
// and a roll around the Z axis. |
|
D3DXQUATERNION* WINAPI D3DXQuaternionRotationYawPitchRoll |
|
( D3DXQUATERNION *pOut, FLOAT Yaw, FLOAT Pitch, FLOAT Roll ); |
|
|
|
// Quaternion multiplication. The result represents the rotation Q2 |
|
// followed by the rotation Q1. (Out = Q2 * Q1) |
|
D3DXQUATERNION* WINAPI D3DXQuaternionMultiply |
|
( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1, |
|
CONST D3DXQUATERNION *pQ2 ); |
|
|
|
D3DXQUATERNION* WINAPI D3DXQuaternionNormalize |
|
( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ ); |
|
|
|
// Conjugate and re-norm |
|
D3DXQUATERNION* WINAPI D3DXQuaternionInverse |
|
( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ ); |
|
|
|
// Expects unit quaternions. |
|
// if q = (cos(theta), sin(theta) * v); ln(q) = (0, theta * v) |
|
D3DXQUATERNION* WINAPI D3DXQuaternionLn |
|
( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ ); |
|
|
|
// Expects pure quaternions. (w == 0) w is ignored in calculation. |
|
// if q = (0, theta * v); exp(q) = (cos(theta), sin(theta) * v) |
|
D3DXQUATERNION* WINAPI D3DXQuaternionExp |
|
( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ ); |
|
|
|
// Spherical linear interpolation between Q1 (t == 0) and Q2 (t == 1). |
|
// Expects unit quaternions. |
|
D3DXQUATERNION* WINAPI D3DXQuaternionSlerp |
|
( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1, |
|
CONST D3DXQUATERNION *pQ2, FLOAT t ); |
|
|
|
// Spherical quadrangle interpolation. |
|
// Slerp(Slerp(Q1, C, t), Slerp(A, B, t), 2t(1-t)) |
|
D3DXQUATERNION* WINAPI D3DXQuaternionSquad |
|
( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1, |
|
CONST D3DXQUATERNION *pA, CONST D3DXQUATERNION *pB, |
|
CONST D3DXQUATERNION *pC, FLOAT t ); |
|
|
|
// Setup control points for spherical quadrangle interpolation |
|
// from Q1 to Q2. The control points are chosen in such a way |
|
// to ensure the continuity of tangents with adjacent segments. |
|
void WINAPI D3DXQuaternionSquadSetup |
|
( D3DXQUATERNION *pAOut, D3DXQUATERNION *pBOut, D3DXQUATERNION *pCOut, |
|
CONST D3DXQUATERNION *pQ0, CONST D3DXQUATERNION *pQ1, |
|
CONST D3DXQUATERNION *pQ2, CONST D3DXQUATERNION *pQ3 ); |
|
|
|
// Barycentric interpolation. |
|
// Slerp(Slerp(Q1, Q2, f+g), Slerp(Q1, Q3, f+g), g/(f+g)) |
|
D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric |
|
( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ1, |
|
CONST D3DXQUATERNION *pQ2, CONST D3DXQUATERNION *pQ3, |
|
FLOAT f, FLOAT g ); |
|
|
|
#ifdef __cplusplus |
|
} |
|
#endif |
|
|
|
|
|
//-------------------------- |
|
// Plane |
|
//-------------------------- |
|
|
|
// inline |
|
|
|
// ax + by + cz + dw |
|
FLOAT D3DXPlaneDot |
|
( CONST D3DXPLANE *pP, CONST D3DXVECTOR4 *pV); |
|
|
|
// ax + by + cz + d |
|
FLOAT D3DXPlaneDotCoord |
|
( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV); |
|
|
|
// ax + by + cz |
|
FLOAT D3DXPlaneDotNormal |
|
( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV); |
|
|
|
// non-inline |
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
// Normalize plane (so that |a,b,c| == 1) |
|
D3DXPLANE* WINAPI D3DXPlaneNormalize |
|
( D3DXPLANE *pOut, CONST D3DXPLANE *pP); |
|
|
|
// Find the intersection between a plane and a line. If the line is |
|
// parallel to the plane, NULL is returned. |
|
D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine |
|
( D3DXVECTOR3 *pOut, CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV1, |
|
CONST D3DXVECTOR3 *pV2); |
|
|
|
// Construct a plane from a point and a normal |
|
D3DXPLANE* WINAPI D3DXPlaneFromPointNormal |
|
( D3DXPLANE *pOut, CONST D3DXVECTOR3 *pPoint, CONST D3DXVECTOR3 *pNormal); |
|
|
|
// Construct a plane from 3 points |
|
D3DXPLANE* WINAPI D3DXPlaneFromPoints |
|
( D3DXPLANE *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2, |
|
CONST D3DXVECTOR3 *pV3); |
|
|
|
// Transform a plane by a matrix. The vector (a,b,c) must be normal. |
|
// M should be the inverse transpose of the transformation desired. |
|
D3DXPLANE* WINAPI D3DXPlaneTransform |
|
( D3DXPLANE *pOut, CONST D3DXPLANE *pP, CONST D3DXMATRIX *pM ); |
|
|
|
#ifdef __cplusplus |
|
} |
|
#endif |
|
|
|
|
|
//-------------------------- |
|
// Color |
|
//-------------------------- |
|
|
|
// inline |
|
|
|
// (1-r, 1-g, 1-b, a) |
|
D3DXCOLOR* D3DXColorNegative |
|
(D3DXCOLOR *pOut, CONST D3DXCOLOR *pC); |
|
|
|
D3DXCOLOR* D3DXColorAdd |
|
(D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2); |
|
|
|
D3DXCOLOR* D3DXColorSubtract |
|
(D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2); |
|
|
|
D3DXCOLOR* D3DXColorScale |
|
(D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT s); |
|
|
|
// (r1*r2, g1*g2, b1*b2, a1*a2) |
|
D3DXCOLOR* D3DXColorModulate |
|
(D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2); |
|
|
|
// Linear interpolation of r,g,b, and a. C1 + s(C2-C1) |
|
D3DXCOLOR* D3DXColorLerp |
|
(D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2, FLOAT s); |
|
|
|
// non-inline |
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
// Interpolate r,g,b between desaturated color and color. |
|
// DesaturatedColor + s(Color - DesaturatedColor) |
|
D3DXCOLOR* WINAPI D3DXColorAdjustSaturation |
|
(D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT s); |
|
|
|
// Interpolate r,g,b between 50% grey and color. Grey + s(Color - Grey) |
|
D3DXCOLOR* WINAPI D3DXColorAdjustContrast |
|
(D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT c); |
|
|
|
#ifdef __cplusplus |
|
} |
|
#endif |
|
|
|
|
|
|
|
|
|
//-------------------------- |
|
// Misc |
|
//-------------------------- |
|
|
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
// Calculate Fresnel term given the cosine of theta (likely obtained by |
|
// taking the dot of two normals), and the refraction index of the material. |
|
FLOAT WINAPI D3DXFresnelTerm |
|
(FLOAT CosTheta, FLOAT RefractionIndex); |
|
|
|
#ifdef __cplusplus |
|
} |
|
#endif |
|
|
|
|
|
|
|
//=========================================================================== |
|
// |
|
// Matrix Stack |
|
// |
|
//=========================================================================== |
|
|
|
typedef interface ID3DXMatrixStack ID3DXMatrixStack; |
|
typedef interface ID3DXMatrixStack *LPD3DXMATRIXSTACK; |
|
|
|
// {E3357330-CC5E-11d2-A434-00A0C90629A8} |
|
DEFINE_GUID( IID_ID3DXMatrixStack, |
|
0xe3357330, 0xcc5e, 0x11d2, 0xa4, 0x34, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0xa8); |
|
|
|
|
|
#undef INTERFACE |
|
#define INTERFACE ID3DXMatrixStack |
|
|
|
DECLARE_INTERFACE_(ID3DXMatrixStack, IUnknown) |
|
{ |
|
// |
|
// IUnknown methods |
|
// |
|
STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; |
|
STDMETHOD_(ULONG,AddRef)(THIS) PURE; |
|
STDMETHOD_(ULONG,Release)(THIS) PURE; |
|
|
|
// |
|
// ID3DXMatrixStack methods |
|
// |
|
|
|
// Pops the top of the stack, returns the current top |
|
// *after* popping the top. |
|
STDMETHOD(Pop)(THIS) PURE; |
|
|
|
// Pushes the stack by one, duplicating the current matrix. |
|
STDMETHOD(Push)(THIS) PURE; |
|
|
|
// Loads identity in the current matrix. |
|
STDMETHOD(LoadIdentity)(THIS) PURE; |
|
|
|
// Loads the given matrix into the current matrix |
|
STDMETHOD(LoadMatrix)(THIS_ CONST D3DXMATRIX* pM ) PURE; |
|
|
|
// Right-Multiplies the given matrix to the current matrix. |
|
// (transformation is about the current world origin) |
|
STDMETHOD(MultMatrix)(THIS_ CONST D3DXMATRIX* pM ) PURE; |
|
|
|
// Left-Multiplies the given matrix to the current matrix |
|
// (transformation is about the local origin of the object) |
|
STDMETHOD(MultMatrixLocal)(THIS_ CONST D3DXMATRIX* pM ) PURE; |
|
|
|
// Right multiply the current matrix with the computed rotation |
|
// matrix, counterclockwise about the given axis with the given angle. |
|
// (rotation is about the current world origin) |
|
STDMETHOD(RotateAxis) |
|
(THIS_ CONST D3DXVECTOR3* pV, FLOAT Angle) PURE; |
|
|
|
// Left multiply the current matrix with the computed rotation |
|
// matrix, counterclockwise about the given axis with the given angle. |
|
// (rotation is about the local origin of the object) |
|
STDMETHOD(RotateAxisLocal) |
|
(THIS_ CONST D3DXVECTOR3* pV, FLOAT Angle) PURE; |
|
|
|
// Right multiply the current matrix with the computed rotation |
|
// matrix. All angles are counterclockwise. (rotation is about the |
|
// current world origin) |
|
|
|
// The rotation is composed of a yaw around the Y axis, a pitch around |
|
// the X axis, and a roll around the Z axis. |
|
STDMETHOD(RotateYawPitchRoll) |
|
(THIS_ FLOAT Yaw, FLOAT Pitch, FLOAT Roll) PURE; |
|
|
|
// Left multiply the current matrix with the computed rotation |
|
// matrix. All angles are counterclockwise. (rotation is about the |
|
// local origin of the object) |
|
|
|
// The rotation is composed of a yaw around the Y axis, a pitch around |
|
// the X axis, and a roll around the Z axis. |
|
STDMETHOD(RotateYawPitchRollLocal) |
|
(THIS_ FLOAT Yaw, FLOAT Pitch, FLOAT Roll) PURE; |
|
|
|
// Right multiply the current matrix with the computed scale |
|
// matrix. (transformation is about the current world origin) |
|
STDMETHOD(Scale)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE; |
|
|
|
// Left multiply the current matrix with the computed scale |
|
// matrix. (transformation is about the local origin of the object) |
|
STDMETHOD(ScaleLocal)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE; |
|
|
|
// Right multiply the current matrix with the computed translation |
|
// matrix. (transformation is about the current world origin) |
|
STDMETHOD(Translate)(THIS_ FLOAT x, FLOAT y, FLOAT z ) PURE; |
|
|
|
// Left multiply the current matrix with the computed translation |
|
// matrix. (transformation is about the local origin of the object) |
|
STDMETHOD(TranslateLocal)(THIS_ FLOAT x, FLOAT y, FLOAT z) PURE; |
|
|
|
// Obtain the current matrix at the top of the stack |
|
STDMETHOD_(D3DXMATRIX*, GetTop)(THIS) PURE; |
|
}; |
|
|
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
HRESULT WINAPI |
|
D3DXCreateMatrixStack( |
|
DWORD Flags, |
|
LPD3DXMATRIXSTACK* ppStack); |
|
|
|
#ifdef __cplusplus |
|
} |
|
#endif |
|
|
|
#include "d3dx8math.inl" |
|
|
|
#pragma warning(default:4201) |
|
|
|
#endif // __D3DX8MATH_H__
|
|
|