mirror of https://git.rip/DMCA_FUCKER/re3.git
1766 lines
55 KiB
C++
1766 lines
55 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// File: d3dx9math.h
|
|
// Content: D3DX math types and functions
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "d3dx9.h"
|
|
|
|
#ifndef __D3DX9MATH_H__
|
|
#define __D3DX9MATH_H__
|
|
|
|
#include <math.h>
|
|
#if _MSC_VER >= 1200
|
|
#pragma warning(push)
|
|
#endif
|
|
#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))
|
|
|
|
|
|
|
|
//===========================================================================
|
|
//
|
|
// 16 bit floating point numbers
|
|
//
|
|
//===========================================================================
|
|
|
|
#define D3DX_16F_DIG 3 // # of decimal digits of precision
|
|
#define D3DX_16F_EPSILON 4.8875809e-4f // smallest such that 1.0 + epsilon != 1.0
|
|
#define D3DX_16F_MANT_DIG 11 // # of bits in mantissa
|
|
#define D3DX_16F_MAX 6.550400e+004 // max value
|
|
#define D3DX_16F_MAX_10_EXP 4 // max decimal exponent
|
|
#define D3DX_16F_MAX_EXP 15 // max binary exponent
|
|
#define D3DX_16F_MIN 6.1035156e-5f // min positive value
|
|
#define D3DX_16F_MIN_10_EXP (-4) // min decimal exponent
|
|
#define D3DX_16F_MIN_EXP (-12) // min binary exponent
|
|
#define D3DX_16F_RADIX 2 // exponent radix
|
|
#define D3DX_16F_ROUNDS 1 // addition rounding: near
|
|
|
|
|
|
typedef struct D3DXFLOAT16
|
|
{
|
|
#ifdef __cplusplus
|
|
public:
|
|
D3DXFLOAT16() {};
|
|
D3DXFLOAT16( FLOAT );
|
|
D3DXFLOAT16( CONST D3DXFLOAT16& );
|
|
|
|
// casting
|
|
operator FLOAT ();
|
|
|
|
// binary operators
|
|
BOOL operator == ( CONST D3DXFLOAT16& ) const;
|
|
BOOL operator != ( CONST D3DXFLOAT16& ) const;
|
|
|
|
protected:
|
|
#endif //__cplusplus
|
|
WORD value;
|
|
} D3DXFLOAT16, *LPD3DXFLOAT16;
|
|
|
|
|
|
|
|
//===========================================================================
|
|
//
|
|
// Vectors
|
|
//
|
|
//===========================================================================
|
|
|
|
|
|
//--------------------------
|
|
// 2D Vector
|
|
//--------------------------
|
|
typedef struct D3DXVECTOR2
|
|
{
|
|
#ifdef __cplusplus
|
|
public:
|
|
D3DXVECTOR2() {};
|
|
D3DXVECTOR2( CONST FLOAT * );
|
|
D3DXVECTOR2( CONST D3DXFLOAT16 * );
|
|
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;
|
|
|
|
|
|
|
|
//--------------------------
|
|
// 2D Vector (16 bit)
|
|
//--------------------------
|
|
|
|
typedef struct D3DXVECTOR2_16F
|
|
{
|
|
#ifdef __cplusplus
|
|
public:
|
|
D3DXVECTOR2_16F() {};
|
|
D3DXVECTOR2_16F( CONST FLOAT * );
|
|
D3DXVECTOR2_16F( CONST D3DXFLOAT16 * );
|
|
D3DXVECTOR2_16F( CONST D3DXFLOAT16 &x, CONST D3DXFLOAT16 &y );
|
|
|
|
// casting
|
|
operator D3DXFLOAT16* ();
|
|
operator CONST D3DXFLOAT16* () const;
|
|
|
|
// binary operators
|
|
BOOL operator == ( CONST D3DXVECTOR2_16F& ) const;
|
|
BOOL operator != ( CONST D3DXVECTOR2_16F& ) const;
|
|
|
|
public:
|
|
#endif //__cplusplus
|
|
D3DXFLOAT16 x, y;
|
|
|
|
} D3DXVECTOR2_16F, *LPD3DXVECTOR2_16F;
|
|
|
|
|
|
|
|
//--------------------------
|
|
// 3D Vector
|
|
//--------------------------
|
|
#ifdef __cplusplus
|
|
typedef struct D3DXVECTOR3 : public D3DVECTOR
|
|
{
|
|
public:
|
|
D3DXVECTOR3() {};
|
|
D3DXVECTOR3( CONST FLOAT * );
|
|
D3DXVECTOR3( CONST D3DVECTOR& );
|
|
D3DXVECTOR3( CONST D3DXFLOAT16 * );
|
|
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
|
|
|
|
|
|
|
|
//--------------------------
|
|
// 3D Vector (16 bit)
|
|
//--------------------------
|
|
typedef struct D3DXVECTOR3_16F
|
|
{
|
|
#ifdef __cplusplus
|
|
public:
|
|
D3DXVECTOR3_16F() {};
|
|
D3DXVECTOR3_16F( CONST FLOAT * );
|
|
D3DXVECTOR3_16F( CONST D3DVECTOR& );
|
|
D3DXVECTOR3_16F( CONST D3DXFLOAT16 * );
|
|
D3DXVECTOR3_16F( CONST D3DXFLOAT16 &x, CONST D3DXFLOAT16 &y, CONST D3DXFLOAT16 &z );
|
|
|
|
// casting
|
|
operator D3DXFLOAT16* ();
|
|
operator CONST D3DXFLOAT16* () const;
|
|
|
|
// binary operators
|
|
BOOL operator == ( CONST D3DXVECTOR3_16F& ) const;
|
|
BOOL operator != ( CONST D3DXVECTOR3_16F& ) const;
|
|
|
|
public:
|
|
#endif //__cplusplus
|
|
D3DXFLOAT16 x, y, z;
|
|
|
|
} D3DXVECTOR3_16F, *LPD3DXVECTOR3_16F;
|
|
|
|
|
|
|
|
//--------------------------
|
|
// 4D Vector
|
|
//--------------------------
|
|
typedef struct D3DXVECTOR4
|
|
{
|
|
#ifdef __cplusplus
|
|
public:
|
|
D3DXVECTOR4() {};
|
|
D3DXVECTOR4( CONST FLOAT* );
|
|
D3DXVECTOR4( CONST D3DXFLOAT16* );
|
|
D3DXVECTOR4( CONST D3DVECTOR& xyz, FLOAT w );
|
|
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;
|
|
|
|
|
|
//--------------------------
|
|
// 4D Vector (16 bit)
|
|
//--------------------------
|
|
typedef struct D3DXVECTOR4_16F
|
|
{
|
|
#ifdef __cplusplus
|
|
public:
|
|
D3DXVECTOR4_16F() {};
|
|
D3DXVECTOR4_16F( CONST FLOAT * );
|
|
D3DXVECTOR4_16F( CONST D3DXFLOAT16* );
|
|
D3DXVECTOR4_16F( CONST D3DXVECTOR3_16F& xyz, CONST D3DXFLOAT16& w );
|
|
D3DXVECTOR4_16F( CONST D3DXFLOAT16& x, CONST D3DXFLOAT16& y, CONST D3DXFLOAT16& z, CONST D3DXFLOAT16& w );
|
|
|
|
// casting
|
|
operator D3DXFLOAT16* ();
|
|
operator CONST D3DXFLOAT16* () const;
|
|
|
|
// binary operators
|
|
BOOL operator == ( CONST D3DXVECTOR4_16F& ) const;
|
|
BOOL operator != ( CONST D3DXVECTOR4_16F& ) const;
|
|
|
|
public:
|
|
#endif //__cplusplus
|
|
D3DXFLOAT16 x, y, z, w;
|
|
|
|
} D3DXVECTOR4_16F, *LPD3DXVECTOR4_16F;
|
|
|
|
|
|
|
|
//===========================================================================
|
|
//
|
|
// Matrices
|
|
//
|
|
//===========================================================================
|
|
#ifdef __cplusplus
|
|
typedef struct D3DXMATRIX : public D3DMATRIX
|
|
{
|
|
public:
|
|
D3DXMATRIX() {};
|
|
D3DXMATRIX( CONST FLOAT * );
|
|
D3DXMATRIX( CONST D3DMATRIX& );
|
|
D3DXMATRIX( CONST D3DXFLOAT16 * );
|
|
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 * );
|
|
_D3DXMATRIXA16( CONST D3DMATRIX& );
|
|
_D3DXMATRIXA16( CONST D3DXFLOAT16 * );
|
|
_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 );
|
|
|
|
// new operators
|
|
void* operator new ( size_t );
|
|
void* operator new[] ( size_t );
|
|
|
|
// delete operators
|
|
void operator delete ( void* ); // These are NOT virtual; Do not
|
|
void operator delete[] ( void* ); // cast to D3DXMATRIX and delete.
|
|
|
|
// assignment operators
|
|
_D3DXMATRIXA16& operator = ( CONST D3DXMATRIX& );
|
|
|
|
} _D3DXMATRIXA16;
|
|
|
|
#else //!__cplusplus
|
|
typedef D3DXMATRIX _D3DXMATRIXA16;
|
|
#endif //!__cplusplus
|
|
|
|
|
|
|
|
#if _MSC_VER >= 1300 // VC7
|
|
#define D3DX_ALIGN16 __declspec(align(16))
|
|
#else
|
|
#define D3DX_ALIGN16 // Earlier compiler may not understand this, do nothing.
|
|
#endif
|
|
|
|
typedef D3DX_ALIGN16 _D3DXMATRIXA16 D3DXMATRIXA16, *LPD3DXMATRIXA16;
|
|
|
|
|
|
|
|
//===========================================================================
|
|
//
|
|
// Quaternions
|
|
//
|
|
//===========================================================================
|
|
typedef struct D3DXQUATERNION
|
|
{
|
|
#ifdef __cplusplus
|
|
public:
|
|
D3DXQUATERNION() {}
|
|
D3DXQUATERNION( CONST FLOAT * );
|
|
D3DXQUATERNION( CONST D3DXFLOAT16 * );
|
|
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( CONST D3DXFLOAT16* );
|
|
D3DXPLANE( FLOAT a, FLOAT b, FLOAT c, FLOAT d );
|
|
|
|
// casting
|
|
operator FLOAT* ();
|
|
operator CONST FLOAT* () const;
|
|
|
|
// assignment operators
|
|
D3DXPLANE& operator *= ( FLOAT );
|
|
D3DXPLANE& operator /= ( FLOAT );
|
|
|
|
// unary operators
|
|
D3DXPLANE operator + () const;
|
|
D3DXPLANE operator - () const;
|
|
|
|
// binary operators
|
|
D3DXPLANE operator * ( FLOAT ) const;
|
|
D3DXPLANE operator / ( FLOAT ) const;
|
|
|
|
friend D3DXPLANE operator * ( FLOAT, CONST D3DXPLANE& );
|
|
|
|
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 D3DXFLOAT16 * );
|
|
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.
|
|
//
|
|
//===========================================================================
|
|
|
|
//--------------------------
|
|
// Float16
|
|
//--------------------------
|
|
|
|
// non-inline
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
// Converts an array 32-bit floats to 16-bit floats
|
|
D3DXFLOAT16* WINAPI D3DXFloat32To16Array
|
|
( D3DXFLOAT16 *pOut, CONST FLOAT *pIn, UINT n );
|
|
|
|
// Converts an array 16-bit floats to 32-bit floats
|
|
FLOAT* WINAPI D3DXFloat16To32Array
|
|
( FLOAT *pOut, CONST D3DXFLOAT16 *pIn, UINT n );
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
//--------------------------
|
|
// 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 );
|
|
|
|
// Transform Array (x, y, 0, 1) by matrix.
|
|
D3DXVECTOR4* WINAPI D3DXVec2TransformArray
|
|
( D3DXVECTOR4 *pOut, UINT OutStride, CONST D3DXVECTOR2 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n);
|
|
|
|
// Transform Array (x, y, 0, 1) by matrix, project result back into w=1.
|
|
D3DXVECTOR2* WINAPI D3DXVec2TransformCoordArray
|
|
( D3DXVECTOR2 *pOut, UINT OutStride, CONST D3DXVECTOR2 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n );
|
|
|
|
// Transform Array (x, y, 0, 0) by matrix.
|
|
D3DXVECTOR2* WINAPI D3DXVec2TransformNormalArray
|
|
( D3DXVECTOR2 *pOut, UINT OutStride, CONST D3DXVECTOR2 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n );
|
|
|
|
|
|
|
|
#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 );
|
|
|
|
|
|
// Transform Array (x, y, z, 1) by matrix.
|
|
D3DXVECTOR4* WINAPI D3DXVec3TransformArray
|
|
( D3DXVECTOR4 *pOut, UINT OutStride, CONST D3DXVECTOR3 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n );
|
|
|
|
// Transform Array (x, y, z, 1) by matrix, project result back into w=1.
|
|
D3DXVECTOR3* WINAPI D3DXVec3TransformCoordArray
|
|
( D3DXVECTOR3 *pOut, UINT OutStride, CONST D3DXVECTOR3 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n );
|
|
|
|
// 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 D3DXVec3TransformNormalArray
|
|
( D3DXVECTOR3 *pOut, UINT OutStride, CONST D3DXVECTOR3 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n );
|
|
|
|
// Project vector from object space into screen space
|
|
D3DXVECTOR3* WINAPI D3DXVec3Project
|
|
( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DVIEWPORT9 *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 D3DVIEWPORT9 *pViewport,
|
|
CONST D3DXMATRIX *pProjection, CONST D3DXMATRIX *pView, CONST D3DXMATRIX *pWorld);
|
|
|
|
// Project vector Array from object space into screen space
|
|
D3DXVECTOR3* WINAPI D3DXVec3ProjectArray
|
|
( D3DXVECTOR3 *pOut, UINT OutStride,CONST D3DXVECTOR3 *pV, UINT VStride,CONST D3DVIEWPORT9 *pViewport,
|
|
CONST D3DXMATRIX *pProjection, CONST D3DXMATRIX *pView, CONST D3DXMATRIX *pWorld, UINT n);
|
|
|
|
// Project vector Array from screen space into object space
|
|
D3DXVECTOR3* WINAPI D3DXVec3UnprojectArray
|
|
( D3DXVECTOR3 *pOut, UINT OutStride, CONST D3DXVECTOR3 *pV, UINT VStride, CONST D3DVIEWPORT9 *pViewport,
|
|
CONST D3DXMATRIX *pProjection, CONST D3DXMATRIX *pView, CONST D3DXMATRIX *pWorld, UINT n);
|
|
|
|
|
|
#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 );
|
|
|
|
// Transform vector array by matrix.
|
|
D3DXVECTOR4* WINAPI D3DXVec4TransformArray
|
|
( D3DXVECTOR4 *pOut, UINT OutStride, CONST D3DXVECTOR4 *pV, UINT VStride, CONST D3DXMATRIX *pM, UINT n );
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
//--------------------------
|
|
// 4D Matrix
|
|
//--------------------------
|
|
|
|
// inline
|
|
|
|
D3DXMATRIX* D3DXMatrixIdentity
|
|
( D3DXMATRIX *pOut );
|
|
|
|
BOOL D3DXMatrixIsIdentity
|
|
( CONST D3DXMATRIX *pM );
|
|
|
|
|
|
// non-inline
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
FLOAT WINAPI D3DXMatrixDeterminant
|
|
( CONST D3DXMATRIX *pM );
|
|
|
|
HRESULT WINAPI D3DXMatrixDecompose
|
|
( D3DXVECTOR3 *pOutScale, D3DXQUATERNION *pOutRotation,
|
|
D3DXVECTOR3 *pOutTranslation, 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 2D transformation matrix in XY plane. NULL arguments are treated as identity.
|
|
// Mout = Msc-1 * Msr-1 * Ms * Msr * Msc * Mrc-1 * Mr * Mrc * Mt
|
|
D3DXMATRIX* WINAPI D3DXMatrixTransformation2D
|
|
( D3DXMATRIX *pOut, CONST D3DXVECTOR2* pScalingCenter,
|
|
FLOAT ScalingRotation, CONST D3DXVECTOR2* pScaling,
|
|
CONST D3DXVECTOR2* pRotationCenter, FLOAT Rotation,
|
|
CONST D3DXVECTOR2* 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 2D affine transformation matrix in XY plane. NULL arguments are treated as identity.
|
|
// Mout = Ms * Mrc-1 * Mr * Mrc * Mt
|
|
D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation2D
|
|
( D3DXMATRIX *pOut, FLOAT Scaling, CONST D3DXVECTOR2* pRotationCenter,
|
|
FLOAT Rotation, CONST D3DXVECTOR2* 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);
|
|
|
|
D3DXPLANE* D3DXPlaneScale
|
|
(D3DXPLANE *pOut, CONST D3DXPLANE *pP, FLOAT s);
|
|
|
|
// 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 );
|
|
|
|
// Transform an array of planes by a matrix. The vectors (a,b,c) must be normal.
|
|
// M should be the inverse transpose of the transformation desired.
|
|
D3DXPLANE* WINAPI D3DXPlaneTransformArray
|
|
( D3DXPLANE *pOut, UINT OutStride, CONST D3DXPLANE *pP, UINT PStride, CONST D3DXMATRIX *pM, UINT n );
|
|
|
|
#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;
|
|
|
|
// {C7885BA7-F990-4fe7-922D-8515E477DD85}
|
|
DEFINE_GUID(IID_ID3DXMatrixStack,
|
|
0xc7885ba7, 0xf990, 0x4fe7, 0x92, 0x2d, 0x85, 0x15, 0xe4, 0x77, 0xdd, 0x85);
|
|
|
|
|
|
#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
|
|
|
|
//===========================================================================
|
|
//
|
|
// Spherical Harmonic Runtime Routines
|
|
//
|
|
// NOTE:
|
|
// * Most of these functions can take the same object as in and out parameters.
|
|
// The exceptions are the rotation functions.
|
|
//
|
|
// * Out parameters are typically also returned as return values, so that
|
|
// the output of one function may be used as a parameter to another.
|
|
//
|
|
//============================================================================
|
|
|
|
|
|
// non-inline
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
//============================================================================
|
|
//
|
|
// Basic Spherical Harmonic math routines
|
|
//
|
|
//============================================================================
|
|
|
|
#define D3DXSH_MINORDER 2
|
|
#define D3DXSH_MAXORDER 6
|
|
|
|
//============================================================================
|
|
//
|
|
// D3DXSHEvalDirection:
|
|
// --------------------
|
|
// Evaluates the Spherical Harmonic basis functions
|
|
//
|
|
// Parameters:
|
|
// pOut
|
|
// Output SH coefficients - basis function Ylm is stored at l*l + m+l
|
|
// This is the pointer that is returned.
|
|
// Order
|
|
// Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
|
|
// pDir
|
|
// Direction to evaluate in - assumed to be normalized
|
|
//
|
|
//============================================================================
|
|
|
|
FLOAT* WINAPI D3DXSHEvalDirection
|
|
( FLOAT *pOut, UINT Order, CONST D3DXVECTOR3 *pDir );
|
|
|
|
//============================================================================
|
|
//
|
|
// D3DXSHRotate:
|
|
// --------------------
|
|
// Rotates SH vector by a rotation matrix
|
|
//
|
|
// Parameters:
|
|
// pOut
|
|
// Output SH coefficients - basis function Ylm is stored at l*l + m+l
|
|
// This is the pointer that is returned (should not alias with pIn.)
|
|
// Order
|
|
// Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
|
|
// pMatrix
|
|
// Matrix used for rotation - rotation sub matrix should be orthogonal
|
|
// and have a unit determinant.
|
|
// pIn
|
|
// Input SH coeffs (rotated), incorect results if this is also output.
|
|
//
|
|
//============================================================================
|
|
|
|
FLOAT* WINAPI D3DXSHRotate
|
|
( FLOAT *pOut, UINT Order, CONST D3DXMATRIX *pMatrix, CONST FLOAT *pIn );
|
|
|
|
//============================================================================
|
|
//
|
|
// D3DXSHRotateZ:
|
|
// --------------------
|
|
// Rotates the SH vector in the Z axis by an angle
|
|
//
|
|
// Parameters:
|
|
// pOut
|
|
// Output SH coefficients - basis function Ylm is stored at l*l + m+l
|
|
// This is the pointer that is returned (should not alias with pIn.)
|
|
// Order
|
|
// Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
|
|
// Angle
|
|
// Angle in radians to rotate around the Z axis.
|
|
// pIn
|
|
// Input SH coeffs (rotated), incorect results if this is also output.
|
|
//
|
|
//============================================================================
|
|
|
|
|
|
FLOAT* WINAPI D3DXSHRotateZ
|
|
( FLOAT *pOut, UINT Order, FLOAT Angle, CONST FLOAT *pIn );
|
|
|
|
//============================================================================
|
|
//
|
|
// D3DXSHAdd:
|
|
// --------------------
|
|
// Adds two SH vectors, pOut[i] = pA[i] + pB[i];
|
|
//
|
|
// Parameters:
|
|
// pOut
|
|
// Output SH coefficients - basis function Ylm is stored at l*l + m+l
|
|
// This is the pointer that is returned.
|
|
// Order
|
|
// Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
|
|
// pA
|
|
// Input SH coeffs.
|
|
// pB
|
|
// Input SH coeffs (second vector.)
|
|
//
|
|
//============================================================================
|
|
|
|
FLOAT* WINAPI D3DXSHAdd
|
|
( FLOAT *pOut, UINT Order, CONST FLOAT *pA, CONST FLOAT *pB );
|
|
|
|
//============================================================================
|
|
//
|
|
// D3DXSHScale:
|
|
// --------------------
|
|
// Adds two SH vectors, pOut[i] = pA[i]*Scale;
|
|
//
|
|
// Parameters:
|
|
// pOut
|
|
// Output SH coefficients - basis function Ylm is stored at l*l + m+l
|
|
// This is the pointer that is returned.
|
|
// Order
|
|
// Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
|
|
// pIn
|
|
// Input SH coeffs.
|
|
// Scale
|
|
// Scale factor.
|
|
//
|
|
//============================================================================
|
|
|
|
FLOAT* WINAPI D3DXSHScale
|
|
( FLOAT *pOut, UINT Order, CONST FLOAT *pIn, CONST FLOAT Scale );
|
|
|
|
//============================================================================
|
|
//
|
|
// D3DXSHDot:
|
|
// --------------------
|
|
// Computes the dot product of two SH vectors
|
|
//
|
|
// Parameters:
|
|
// Order
|
|
// Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
|
|
// pA
|
|
// Input SH coeffs.
|
|
// pB
|
|
// Second set of input SH coeffs.
|
|
//
|
|
//============================================================================
|
|
|
|
FLOAT WINAPI D3DXSHDot
|
|
( UINT Order, CONST FLOAT *pA, CONST FLOAT *pB );
|
|
|
|
//============================================================================
|
|
//
|
|
// Basic Spherical Harmonic lighting routines
|
|
//
|
|
//============================================================================
|
|
|
|
//============================================================================
|
|
//
|
|
// D3DXSHEvalDirectionalLight:
|
|
// --------------------
|
|
// Evaluates a directional light and returns spectral SH data. The output
|
|
// vector is computed so that if the intensity of R/G/B is unit the resulting
|
|
// exit radiance of a point directly under the light on a diffuse object with
|
|
// an albedo of 1 would be 1.0. This will compute 3 spectral samples, pROut
|
|
// has to be specified, while pGout and pBout are optional.
|
|
//
|
|
// Parameters:
|
|
// Order
|
|
// Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
|
|
// pDir
|
|
// Direction light is coming from (assumed to be normalized.)
|
|
// RIntensity
|
|
// Red intensity of light.
|
|
// GIntensity
|
|
// Green intensity of light.
|
|
// BIntensity
|
|
// Blue intensity of light.
|
|
// pROut
|
|
// Output SH vector for Red.
|
|
// pGOut
|
|
// Output SH vector for Green (optional.)
|
|
// pBOut
|
|
// Output SH vector for Blue (optional.)
|
|
//
|
|
//============================================================================
|
|
|
|
HRESULT WINAPI D3DXSHEvalDirectionalLight
|
|
( UINT Order, CONST D3DXVECTOR3 *pDir,
|
|
FLOAT RIntensity, FLOAT GIntensity, FLOAT BIntensity,
|
|
FLOAT *pROut, FLOAT *pGOut, FLOAT *pBOut );
|
|
|
|
//============================================================================
|
|
//
|
|
// D3DXSHEvalSphericalLight:
|
|
// --------------------
|
|
// Evaluates a spherical light and returns spectral SH data. There is no
|
|
// normalization of the intensity of the light like there is for directional
|
|
// lights, care has to be taken when specifiying the intensities. This will
|
|
// compute 3 spectral samples, pROut has to be specified, while pGout and
|
|
// pBout are optional.
|
|
//
|
|
// Parameters:
|
|
// Order
|
|
// Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
|
|
// pPos
|
|
// Position of light - reciever is assumed to be at the origin.
|
|
// Radius
|
|
// Radius of the spherical light source.
|
|
// RIntensity
|
|
// Red intensity of light.
|
|
// GIntensity
|
|
// Green intensity of light.
|
|
// BIntensity
|
|
// Blue intensity of light.
|
|
// pROut
|
|
// Output SH vector for Red.
|
|
// pGOut
|
|
// Output SH vector for Green (optional.)
|
|
// pBOut
|
|
// Output SH vector for Blue (optional.)
|
|
//
|
|
//============================================================================
|
|
|
|
HRESULT WINAPI D3DXSHEvalSphericalLight
|
|
( UINT Order, CONST D3DXVECTOR3 *pPos, FLOAT Radius,
|
|
FLOAT RIntensity, FLOAT GIntensity, FLOAT BIntensity,
|
|
FLOAT *pROut, FLOAT *pGOut, FLOAT *pBOut );
|
|
|
|
//============================================================================
|
|
//
|
|
// D3DXSHEvalConeLight:
|
|
// --------------------
|
|
// Evaluates a light that is a cone of constant intensity and returns spectral
|
|
// SH data. The output vector is computed so that if the intensity of R/G/B is
|
|
// unit the resulting exit radiance of a point directly under the light oriented
|
|
// in the cone direction on a diffuse object with an albedo of 1 would be 1.0.
|
|
// This will compute 3 spectral samples, pROut has to be specified, while pGout
|
|
// and pBout are optional.
|
|
//
|
|
// Parameters:
|
|
// Order
|
|
// Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
|
|
// pDir
|
|
// Direction light is coming from (assumed to be normalized.)
|
|
// Radius
|
|
// Radius of cone in radians.
|
|
// RIntensity
|
|
// Red intensity of light.
|
|
// GIntensity
|
|
// Green intensity of light.
|
|
// BIntensity
|
|
// Blue intensity of light.
|
|
// pROut
|
|
// Output SH vector for Red.
|
|
// pGOut
|
|
// Output SH vector for Green (optional.)
|
|
// pBOut
|
|
// Output SH vector for Blue (optional.)
|
|
//
|
|
//============================================================================
|
|
|
|
HRESULT WINAPI D3DXSHEvalConeLight
|
|
( UINT Order, CONST D3DXVECTOR3 *pDir, FLOAT Radius,
|
|
FLOAT RIntensity, FLOAT GIntensity, FLOAT BIntensity,
|
|
FLOAT *pROut, FLOAT *pGOut, FLOAT *pBOut );
|
|
|
|
//============================================================================
|
|
//
|
|
// D3DXSHEvalHemisphereLight:
|
|
// --------------------
|
|
// Evaluates a light that is a linear interpolant between two colors over the
|
|
// sphere. The interpolant is linear along the axis of the two points, not
|
|
// over the surface of the sphere (ie: if the axis was (0,0,1) it is linear in
|
|
// Z, not in the azimuthal angle.) The resulting spherical lighting function
|
|
// is normalized so that a point on a perfectly diffuse surface with no
|
|
// shadowing and a normal pointed in the direction pDir would result in exit
|
|
// radiance with a value of 1 if the top color was white and the bottom color
|
|
// was black. This is a very simple model where Top represents the intensity
|
|
// of the "sky" and Bottom represents the intensity of the "ground".
|
|
//
|
|
// Parameters:
|
|
// Order
|
|
// Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
|
|
// pDir
|
|
// Axis of the hemisphere.
|
|
// Top
|
|
// Color of the upper hemisphere.
|
|
// Bottom
|
|
// Color of the lower hemisphere.
|
|
// pROut
|
|
// Output SH vector for Red.
|
|
// pGOut
|
|
// Output SH vector for Green
|
|
// pBOut
|
|
// Output SH vector for Blue
|
|
//
|
|
//============================================================================
|
|
|
|
HRESULT WINAPI D3DXSHEvalHemisphereLight
|
|
( UINT Order, CONST D3DXVECTOR3 *pDir, D3DXCOLOR Top, D3DXCOLOR Bottom,
|
|
FLOAT *pROut, FLOAT *pGOut, FLOAT *pBOut );
|
|
|
|
//============================================================================
|
|
//
|
|
// Basic Spherical Harmonic projection routines
|
|
//
|
|
//============================================================================
|
|
|
|
//============================================================================
|
|
//
|
|
// D3DXSHProjectCubeMap:
|
|
// --------------------
|
|
// Projects a function represented on a cube map into spherical harmonics.
|
|
//
|
|
// Parameters:
|
|
// Order
|
|
// Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
|
|
// pCubeMap
|
|
// CubeMap that is going to be projected into spherical harmonics
|
|
// pROut
|
|
// Output SH vector for Red.
|
|
// pGOut
|
|
// Output SH vector for Green
|
|
// pBOut
|
|
// Output SH vector for Blue
|
|
//
|
|
//============================================================================
|
|
|
|
HRESULT WINAPI D3DXSHProjectCubeMap
|
|
( UINT uOrder, LPDIRECT3DCUBETEXTURE9 pCubeMap,
|
|
FLOAT *pROut, FLOAT *pGOut, FLOAT *pBOut );
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
#include "d3dx9math.inl"
|
|
|
|
#if _MSC_VER >= 1200
|
|
#pragma warning(pop)
|
|
#else
|
|
#pragma warning(default:4201)
|
|
#endif
|
|
|
|
#endif // __D3DX9MATH_H__
|
|
|