aboutsummaryrefslogtreecommitdiff
path: root/external/D3D11/include
diff options
context:
space:
mode:
authorMiles Macklin <[email protected]>2017-03-10 14:51:31 +1300
committerMiles Macklin <[email protected]>2017-03-10 14:51:31 +1300
commitad3d90fafe5ee79964bdfe1f1e0704c3ffcdfd5f (patch)
tree4cc6f3288363889d7342f7f8407c0251e6904819 /external/D3D11/include
downloadflex-ad3d90fafe5ee79964bdfe1f1e0704c3ffcdfd5f.tar.xz
flex-ad3d90fafe5ee79964bdfe1f1e0704c3ffcdfd5f.zip
Initial 1.1.0 binary release
Diffstat (limited to 'external/D3D11/include')
-rw-r--r--external/D3D11/include/D3DX10.h72
-rw-r--r--external/D3D11/include/D3DX10core.h444
-rw-r--r--external/D3D11/include/D3DX10math.h1866
-rw-r--r--external/D3D11/include/D3DX10math.inl2228
-rw-r--r--external/D3D11/include/D3DX10mesh.h286
-rw-r--r--external/D3D11/include/D3DX10tex.h766
-rw-r--r--external/D3D11/include/D3DX11.h74
-rw-r--r--external/D3D11/include/D3DX11async.h164
-rw-r--r--external/D3D11/include/D3DX11core.h128
-rw-r--r--external/D3D11/include/D3DX11tex.h772
-rw-r--r--external/D3D11/include/d3dx10async.h290
11 files changed, 7090 insertions, 0 deletions
diff --git a/external/D3D11/include/D3DX10.h b/external/D3D11/include/D3DX10.h
new file mode 100644
index 0000000..5cdcd51
--- /dev/null
+++ b/external/D3D11/include/D3DX10.h
@@ -0,0 +1,72 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) Microsoft Corporation. All Rights Reserved.
+//
+// File: d3dx10.h
+// Content: D3DX10 utility library
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef __D3DX10_INTERNAL__
+#error Incorrect D3DX10 header used
+#endif
+
+#ifndef __D3DX10_H__
+#define __D3DX10_H__
+
+
+// Defines
+#include <limits.h>
+#include <float.h>
+
+#define D3DX10_DEFAULT ((UINT) -1)
+#define D3DX10_FROM_FILE ((UINT) -3)
+#define DXGI_FORMAT_FROM_FILE ((DXGI_FORMAT) -3)
+
+#ifndef D3DX10INLINE
+#ifdef _MSC_VER
+ #if (_MSC_VER >= 1200)
+ #define D3DX10INLINE __forceinline
+ #else
+ #define D3DX10INLINE __inline
+ #endif
+#else
+ #ifdef __cplusplus
+ #define D3DX10INLINE inline
+ #else
+ #define D3DX10INLINE
+ #endif
+#endif
+#endif
+
+
+
+// Includes
+#include "d3d10.h"
+#include "d3dx10.h"
+#include "d3dx10math.h"
+#include "d3dx10core.h"
+#include "d3dx10tex.h"
+#include "d3dx10mesh.h"
+#include "d3dx10async.h"
+
+
+// Errors
+#define _FACDD 0x876
+#define MAKE_DDHRESULT( code ) MAKE_HRESULT( 1, _FACDD, code )
+
+enum _D3DX10_ERR {
+ D3DX10_ERR_CANNOT_MODIFY_INDEX_BUFFER = MAKE_DDHRESULT(2900),
+ D3DX10_ERR_INVALID_MESH = MAKE_DDHRESULT(2901),
+ D3DX10_ERR_CANNOT_ATTR_SORT = MAKE_DDHRESULT(2902),
+ D3DX10_ERR_SKINNING_NOT_SUPPORTED = MAKE_DDHRESULT(2903),
+ D3DX10_ERR_TOO_MANY_INFLUENCES = MAKE_DDHRESULT(2904),
+ D3DX10_ERR_INVALID_DATA = MAKE_DDHRESULT(2905),
+ D3DX10_ERR_LOADED_MESH_HAS_NO_DATA = MAKE_DDHRESULT(2906),
+ D3DX10_ERR_DUPLICATE_NAMED_FRAGMENT = MAKE_DDHRESULT(2907),
+ D3DX10_ERR_CANNOT_REMOVE_LAST_ITEM = MAKE_DDHRESULT(2908),
+};
+
+
+#endif //__D3DX10_H__
+
diff --git a/external/D3D11/include/D3DX10core.h b/external/D3D11/include/D3DX10core.h
new file mode 100644
index 0000000..290a004
--- /dev/null
+++ b/external/D3D11/include/D3DX10core.h
@@ -0,0 +1,444 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) Microsoft Corporation. All Rights Reserved.
+//
+// File: d3dx10core.h
+// Content: D3DX10 core types and functions
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "d3dx10.h"
+
+#ifndef __D3DX10CORE_H__
+#define __D3DX10CORE_H__
+
+// Current name of the DLL shipped in the same SDK as this header.
+
+
+#define D3DX10_DLL_W L"d3dx10_43.dll"
+#define D3DX10_DLL_A "d3dx10_43.dll"
+
+#ifdef UNICODE
+ #define D3DX10_DLL D3DX10_DLL_W
+#else
+ #define D3DX10_DLL D3DX10_DLL_A
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+///////////////////////////////////////////////////////////////////////////
+// D3DX10_SDK_VERSION:
+// -----------------
+// This identifier is passed to D3DX10CheckVersion in order to ensure that an
+// application was built against the correct header files and lib files.
+// This number is incremented whenever a header (or other) change would
+// require applications to be rebuilt. If the version doesn't match,
+// D3DX10CreateVersion will return FALSE. (The number itself has no meaning.)
+///////////////////////////////////////////////////////////////////////////
+
+
+#define D3DX10_SDK_VERSION 43
+
+
+///////////////////////////////////////////////////////////////////////////
+// D3DX10CreateDevice
+// D3DX10CreateDeviceAndSwapChain
+// D3DX10GetFeatureLevel1
+///////////////////////////////////////////////////////////////////////////
+HRESULT WINAPI D3DX10CreateDevice(IDXGIAdapter *pAdapter,
+ D3D10_DRIVER_TYPE DriverType,
+ HMODULE Software,
+ UINT Flags,
+ ID3D10Device **ppDevice);
+
+HRESULT WINAPI D3DX10CreateDeviceAndSwapChain(IDXGIAdapter *pAdapter,
+ D3D10_DRIVER_TYPE DriverType,
+ HMODULE Software,
+ UINT Flags,
+ DXGI_SWAP_CHAIN_DESC *pSwapChainDesc,
+ IDXGISwapChain **ppSwapChain,
+ ID3D10Device **ppDevice);
+
+typedef interface ID3D10Device1 ID3D10Device1;
+HRESULT WINAPI D3DX10GetFeatureLevel1(ID3D10Device *pDevice, ID3D10Device1 **ppDevice1);
+
+
+#ifdef D3D_DIAG_DLL
+BOOL WINAPI D3DX10DebugMute(BOOL Mute);
+#endif
+HRESULT WINAPI D3DX10CheckVersion(UINT D3DSdkVersion, UINT D3DX10SdkVersion);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+
+//////////////////////////////////////////////////////////////////////////////
+// D3DX10_SPRITE flags:
+// -----------------
+// D3DX10_SPRITE_SAVE_STATE
+// Specifies device state should be saved and restored in Begin/End.
+// D3DX10SPRITE_SORT_TEXTURE
+// Sprites are sorted by texture prior to drawing. This is recommended when
+// drawing non-overlapping sprites of uniform depth. For example, drawing
+// screen-aligned text with ID3DX10Font.
+// D3DX10SPRITE_SORT_DEPTH_FRONT_TO_BACK
+// Sprites are sorted by depth front-to-back prior to drawing. This is
+// recommended when drawing opaque sprites of varying depths.
+// D3DX10SPRITE_SORT_DEPTH_BACK_TO_FRONT
+// Sprites are sorted by depth back-to-front prior to drawing. This is
+// recommended when drawing transparent sprites of varying depths.
+// D3DX10SPRITE_ADDREF_TEXTURES
+// AddRef/Release all textures passed in to DrawSpritesBuffered
+//////////////////////////////////////////////////////////////////////////////
+
+typedef enum _D3DX10_SPRITE_FLAG
+{
+ D3DX10_SPRITE_SORT_TEXTURE = 0x01,
+ D3DX10_SPRITE_SORT_DEPTH_BACK_TO_FRONT = 0x02,
+ D3DX10_SPRITE_SORT_DEPTH_FRONT_TO_BACK = 0x04,
+ D3DX10_SPRITE_SAVE_STATE = 0x08,
+ D3DX10_SPRITE_ADDREF_TEXTURES = 0x10,
+} D3DX10_SPRITE_FLAG;
+
+typedef struct _D3DX10_SPRITE
+{
+ D3DXMATRIX matWorld;
+
+ D3DXVECTOR2 TexCoord;
+ D3DXVECTOR2 TexSize;
+
+ D3DXCOLOR ColorModulate;
+
+ ID3D10ShaderResourceView *pTexture;
+ UINT TextureIndex;
+} D3DX10_SPRITE;
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX10Sprite:
+// ------------
+// This object intends to provide an easy way to drawing sprites using D3D.
+//
+// Begin -
+// Prepares device for drawing sprites.
+//
+// Draw -
+// Draws a sprite
+//
+// Flush -
+// Forces all batched sprites to submitted to the device.
+//
+// End -
+// Restores device state to how it was when Begin was called.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3DX10Sprite ID3DX10Sprite;
+typedef interface ID3DX10Sprite *LPD3DX10SPRITE;
+
+
+// {BA0B762D-8D28-43ec-B9DC-2F84443B0614}
+DEFINE_GUID(IID_ID3DX10Sprite,
+0xba0b762d, 0x8d28, 0x43ec, 0xb9, 0xdc, 0x2f, 0x84, 0x44, 0x3b, 0x6, 0x14);
+
+
+#undef INTERFACE
+#define INTERFACE ID3DX10Sprite
+
+DECLARE_INTERFACE_(ID3DX10Sprite, IUnknown)
+{
+ // IUnknown
+ STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
+ STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+ // ID3DX10Sprite
+ STDMETHOD(Begin)(THIS_ UINT flags) PURE;
+
+ STDMETHOD(DrawSpritesBuffered)(THIS_ D3DX10_SPRITE *pSprites, UINT cSprites) PURE;
+ STDMETHOD(Flush)(THIS) PURE;
+
+ STDMETHOD(DrawSpritesImmediate)(THIS_ D3DX10_SPRITE *pSprites, UINT cSprites, UINT cbSprite, UINT flags) PURE;
+ STDMETHOD(End)(THIS) PURE;
+
+ STDMETHOD(GetViewTransform)(THIS_ D3DXMATRIX *pViewTransform) PURE;
+ STDMETHOD(SetViewTransform)(THIS_ D3DXMATRIX *pViewTransform) PURE;
+ STDMETHOD(GetProjectionTransform)(THIS_ D3DXMATRIX *pProjectionTransform) PURE;
+ STDMETHOD(SetProjectionTransform)(THIS_ D3DXMATRIX *pProjectionTransform) PURE;
+
+ STDMETHOD(GetDevice)(THIS_ ID3D10Device** ppDevice) PURE;
+};
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+HRESULT WINAPI
+ D3DX10CreateSprite(
+ ID3D10Device* pDevice,
+ UINT cDeviceBufferSize,
+ LPD3DX10SPRITE* ppSprite);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX10ThreadPump:
+//////////////////////////////////////////////////////////////////////////////
+
+#undef INTERFACE
+#define INTERFACE ID3DX10DataLoader
+
+DECLARE_INTERFACE(ID3DX10DataLoader)
+{
+ STDMETHOD(Load)(THIS) PURE;
+ STDMETHOD(Decompress)(THIS_ void **ppData, SIZE_T *pcBytes) PURE;
+ STDMETHOD(Destroy)(THIS) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE ID3DX10DataProcessor
+
+DECLARE_INTERFACE(ID3DX10DataProcessor)
+{
+ STDMETHOD(Process)(THIS_ void *pData, SIZE_T cBytes) PURE;
+ STDMETHOD(CreateDeviceObject)(THIS_ void **ppDataObject) PURE;
+ STDMETHOD(Destroy)(THIS) PURE;
+};
+
+// {C93FECFA-6967-478a-ABBC-402D90621FCB}
+DEFINE_GUID(IID_ID3DX10ThreadPump,
+0xc93fecfa, 0x6967, 0x478a, 0xab, 0xbc, 0x40, 0x2d, 0x90, 0x62, 0x1f, 0xcb);
+
+#undef INTERFACE
+#define INTERFACE ID3DX10ThreadPump
+
+DECLARE_INTERFACE_(ID3DX10ThreadPump, IUnknown)
+{
+ // IUnknown
+ STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
+ STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+ // ID3DX10ThreadPump
+ STDMETHOD(AddWorkItem)(THIS_ ID3DX10DataLoader *pDataLoader, ID3DX10DataProcessor *pDataProcessor, HRESULT *pHResult, void **ppDeviceObject) PURE;
+ STDMETHOD_(UINT, GetWorkItemCount)(THIS) PURE;
+
+ STDMETHOD(WaitForAllItems)(THIS) PURE;
+ STDMETHOD(ProcessDeviceWorkItems)(THIS_ UINT iWorkItemCount);
+
+ STDMETHOD(PurgeAllItems)(THIS) PURE;
+ STDMETHOD(GetQueueStatus)(THIS_ UINT *pIoQueue, UINT *pProcessQueue, UINT *pDeviceQueue) PURE;
+
+};
+
+HRESULT WINAPI D3DX10CreateThreadPump(UINT cIoThreads, UINT cProcThreads, ID3DX10ThreadPump **ppThreadPump);
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX10Font:
+// ----------
+// Font objects contain the textures and resources needed to render a specific
+// font on a specific device.
+//
+// GetGlyphData -
+// Returns glyph cache data, for a given glyph.
+//
+// PreloadCharacters/PreloadGlyphs/PreloadText -
+// Preloads glyphs into the glyph cache textures.
+//
+// DrawText -
+// Draws formatted text on a D3D device. Some parameters are
+// surprisingly similar to those of GDI's DrawText function. See GDI
+// documentation for a detailed description of these parameters.
+// If pSprite is NULL, an internal sprite object will be used.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+typedef struct _D3DX10_FONT_DESCA
+{
+ INT Height;
+ UINT Width;
+ UINT Weight;
+ UINT MipLevels;
+ BOOL Italic;
+ BYTE CharSet;
+ BYTE OutputPrecision;
+ BYTE Quality;
+ BYTE PitchAndFamily;
+ CHAR FaceName[LF_FACESIZE];
+
+} D3DX10_FONT_DESCA, *LPD3DX10_FONT_DESCA;
+
+typedef struct _D3DX10_FONT_DESCW
+{
+ INT Height;
+ UINT Width;
+ UINT Weight;
+ UINT MipLevels;
+ BOOL Italic;
+ BYTE CharSet;
+ BYTE OutputPrecision;
+ BYTE Quality;
+ BYTE PitchAndFamily;
+ WCHAR FaceName[LF_FACESIZE];
+
+} D3DX10_FONT_DESCW, *LPD3DX10_FONT_DESCW;
+
+#ifdef UNICODE
+typedef D3DX10_FONT_DESCW D3DX10_FONT_DESC;
+typedef LPD3DX10_FONT_DESCW LPD3DX10_FONT_DESC;
+#else
+typedef D3DX10_FONT_DESCA D3DX10_FONT_DESC;
+typedef LPD3DX10_FONT_DESCA LPD3DX10_FONT_DESC;
+#endif
+
+
+typedef interface ID3DX10Font ID3DX10Font;
+typedef interface ID3DX10Font *LPD3DX10FONT;
+
+
+// {D79DBB70-5F21-4d36-BBC2-FF525C213CDC}
+DEFINE_GUID(IID_ID3DX10Font,
+0xd79dbb70, 0x5f21, 0x4d36, 0xbb, 0xc2, 0xff, 0x52, 0x5c, 0x21, 0x3c, 0xdc);
+
+
+#undef INTERFACE
+#define INTERFACE ID3DX10Font
+
+DECLARE_INTERFACE_(ID3DX10Font, IUnknown)
+{
+ // IUnknown
+ STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
+ STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+ // ID3DX10Font
+ STDMETHOD(GetDevice)(THIS_ ID3D10Device** ppDevice) PURE;
+ STDMETHOD(GetDescA)(THIS_ D3DX10_FONT_DESCA *pDesc) PURE;
+ STDMETHOD(GetDescW)(THIS_ D3DX10_FONT_DESCW *pDesc) PURE;
+ STDMETHOD_(BOOL, GetTextMetricsA)(THIS_ TEXTMETRICA *pTextMetrics) PURE;
+ STDMETHOD_(BOOL, GetTextMetricsW)(THIS_ TEXTMETRICW *pTextMetrics) PURE;
+
+ STDMETHOD_(HDC, GetDC)(THIS) PURE;
+ STDMETHOD(GetGlyphData)(THIS_ UINT Glyph, ID3D10ShaderResourceView** ppTexture, RECT *pBlackBox, POINT *pCellInc) PURE;
+
+ STDMETHOD(PreloadCharacters)(THIS_ UINT First, UINT Last) PURE;
+ STDMETHOD(PreloadGlyphs)(THIS_ UINT First, UINT Last) PURE;
+ STDMETHOD(PreloadTextA)(THIS_ LPCSTR pString, INT Count) PURE;
+ STDMETHOD(PreloadTextW)(THIS_ LPCWSTR pString, INT Count) PURE;
+
+ STDMETHOD_(INT, DrawTextA)(THIS_ LPD3DX10SPRITE pSprite, LPCSTR pString, INT Count, LPRECT pRect, UINT Format, D3DXCOLOR Color) PURE;
+ STDMETHOD_(INT, DrawTextW)(THIS_ LPD3DX10SPRITE pSprite, LPCWSTR pString, INT Count, LPRECT pRect, UINT Format, D3DXCOLOR Color) PURE;
+
+#ifdef __cplusplus
+#ifdef UNICODE
+ HRESULT WINAPI_INLINE GetDesc(D3DX10_FONT_DESCW *pDesc) { return GetDescW(pDesc); }
+ HRESULT WINAPI_INLINE PreloadText(LPCWSTR pString, INT Count) { return PreloadTextW(pString, Count); }
+#else
+ HRESULT WINAPI_INLINE GetDesc(D3DX10_FONT_DESCA *pDesc) { return GetDescA(pDesc); }
+ HRESULT WINAPI_INLINE PreloadText(LPCSTR pString, INT Count) { return PreloadTextA(pString, Count); }
+#endif
+#endif //__cplusplus
+};
+
+#ifndef GetTextMetrics
+#ifdef UNICODE
+#define GetTextMetrics GetTextMetricsW
+#else
+#define GetTextMetrics GetTextMetricsA
+#endif
+#endif
+
+#ifndef DrawText
+#ifdef UNICODE
+#define DrawText DrawTextW
+#else
+#define DrawText DrawTextA
+#endif
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+
+HRESULT WINAPI
+ D3DX10CreateFontA(
+ ID3D10Device* pDevice,
+ INT Height,
+ UINT Width,
+ UINT Weight,
+ UINT MipLevels,
+ BOOL Italic,
+ UINT CharSet,
+ UINT OutputPrecision,
+ UINT Quality,
+ UINT PitchAndFamily,
+ LPCSTR pFaceName,
+ LPD3DX10FONT* ppFont);
+
+HRESULT WINAPI
+ D3DX10CreateFontW(
+ ID3D10Device* pDevice,
+ INT Height,
+ UINT Width,
+ UINT Weight,
+ UINT MipLevels,
+ BOOL Italic,
+ UINT CharSet,
+ UINT OutputPrecision,
+ UINT Quality,
+ UINT PitchAndFamily,
+ LPCWSTR pFaceName,
+ LPD3DX10FONT* ppFont);
+
+#ifdef UNICODE
+#define D3DX10CreateFont D3DX10CreateFontW
+#else
+#define D3DX10CreateFont D3DX10CreateFontA
+#endif
+
+
+HRESULT WINAPI
+ D3DX10CreateFontIndirectA(
+ ID3D10Device* pDevice,
+ CONST D3DX10_FONT_DESCA* pDesc,
+ LPD3DX10FONT* ppFont);
+
+HRESULT WINAPI
+ D3DX10CreateFontIndirectW(
+ ID3D10Device* pDevice,
+ CONST D3DX10_FONT_DESCW* pDesc,
+ LPD3DX10FONT* ppFont);
+
+#ifdef UNICODE
+#define D3DX10CreateFontIndirect D3DX10CreateFontIndirectW
+#else
+#define D3DX10CreateFontIndirect D3DX10CreateFontIndirectA
+#endif
+
+HRESULT WINAPI D3DX10UnsetAllDeviceObjects(ID3D10Device *pDevice);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+///////////////////////////////////////////////////////////////////////////
+
+#define _FACD3D 0x876
+#define MAKE_D3DHRESULT( code ) MAKE_HRESULT( 1, _FACD3D, code )
+#define MAKE_D3DSTATUS( code ) MAKE_HRESULT( 0, _FACD3D, code )
+
+#define D3DERR_INVALIDCALL MAKE_D3DHRESULT(2156)
+#define D3DERR_WASSTILLDRAWING MAKE_D3DHRESULT(540)
+
+#endif //__D3DX10CORE_H__
+
diff --git a/external/D3D11/include/D3DX10math.h b/external/D3D11/include/D3DX10math.h
new file mode 100644
index 0000000..a4b8e2d
--- /dev/null
+++ b/external/D3D11/include/D3DX10math.h
@@ -0,0 +1,1866 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) Microsoft Corporation. All Rights Reserved.
+//
+// File: D3DX10math.h
+// Content: D3DX10 math types and functions
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include "D3DX10.h"
+
+// D3DX10 and D3DX9 math look the same. You can include either one into your project.
+// We are intentionally using the header define from D3DX9 math to prevent double-inclusion.
+#ifndef __D3DX9MATH_H__
+#define __D3DX9MATH_H__
+
+#include <math.h>
+#if _MSC_VER >= 1200
+#pragma warning(push)
+#endif
+#pragma warning(disable:4201) // anonymous unions warning
+
+//===========================================================================
+//
+// Type definitions from D3D9
+//
+//===========================================================================
+
+#ifndef D3DVECTOR_DEFINED
+typedef struct _D3DVECTOR {
+ float x;
+ float y;
+ float z;
+} D3DVECTOR;
+#define D3DVECTOR_DEFINED
+#endif
+
+#ifndef D3DMATRIX_DEFINED
+typedef struct _D3DMATRIX {
+ union {
+ struct {
+ float _11, _12, _13, _14;
+ float _21, _22, _23, _24;
+ float _31, _32, _33, _34;
+ float _41, _42, _43, _44;
+
+ };
+ float m[4][4];
+ };
+} D3DMATRIX;
+#define D3DMATRIX_DEFINED
+#endif
+
+//===========================================================================
+//
+// General purpose utilities
+//
+//===========================================================================
+#define D3DX_PI (3.14159265358979323846)
+#define D3DX_1BYPI ( 1.0 / D3DX_PI )
+
+#define D3DXToRadian( degree ) ((degree) * (D3DX_PI / 180.0))
+#define D3DXToDegree( radian ) ((radian) * (180.0 / 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 (-14) // min binary exponent
+#define D3DX_16F_RADIX 2 // exponent radix
+#define D3DX_16F_ROUNDS 1 // addition rounding: near
+#define D3DX_16F_SIGN_MASK 0x8000
+#define D3DX_16F_EXP_MASK 0x7C00
+#define D3DX_16F_FRAC_MASK 0x03FF
+
+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( UINT argb );
+ D3DXCOLOR( CONST FLOAT * );
+ D3DXCOLOR( CONST D3DXFLOAT16 * );
+ D3DXCOLOR( FLOAT r, FLOAT g, FLOAT b, FLOAT a );
+
+ // casting
+ operator UINT () const;
+
+ operator FLOAT* ();
+ operator CONST FLOAT* () 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
+ ( __out_ecount(n) FLOAT *pOut, __in_ecount(n) 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 D3D10_VIEWPORT *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 D3D10_VIEWPORT *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 D3D10_VIEWPORT *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 D3D10_VIEWPORT *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(
+ UINT Flags,
+ LPD3DXMATRIXSTACK* ppStack);
+
+#ifdef __cplusplus
+}
+#endif
+
+// 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
+ ( __out_ecount(Order*Order) 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
+ ( __out_ecount(Order*Order) 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
+ ( __out_ecount(Order*Order) 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 );
+
+//============================================================================
+//
+// D3DXSHMultiply[O]:
+// --------------------
+// Computes the product of two functions represented using SH (f and g), where:
+// pOut[i] = int(y_i(s) * f(s) * g(s)), where y_i(s) is the ith SH basis
+// function, f(s) and g(s) are SH functions (sum_i(y_i(s)*c_i)). The order O
+// determines the lengths of the arrays, where there should always be O^2
+// coefficients. In general the product of two SH functions of order O generates
+// and SH function of order 2*O - 1, but we truncate the result. This means
+// that the product commutes (f*g == g*f) but doesn't associate
+// (f*(g*h) != (f*g)*h.
+//
+// Parameters:
+// pOut
+// Output SH coefficients - basis function Ylm is stored at l*l + m+l
+// This is the pointer that is returned.
+// pF
+// Input SH coeffs for first function.
+// pG
+// Second set of input SH coeffs.
+//
+//============================================================================
+
+__out_ecount(4) FLOAT* WINAPI D3DXSHMultiply2(__out_ecount(4) FLOAT *pOut,__in_ecount(4) CONST FLOAT *pF,__in_ecount(4) CONST FLOAT *pG);
+__out_ecount(9) FLOAT* WINAPI D3DXSHMultiply3(__out_ecount(9) FLOAT *pOut,__in_ecount(9) CONST FLOAT *pF,__in_ecount(9) CONST FLOAT *pG);
+__out_ecount(16) FLOAT* WINAPI D3DXSHMultiply4(__out_ecount(16) FLOAT *pOut,__in_ecount(16) CONST FLOAT *pF,__in_ecount(16) CONST FLOAT *pG);
+__out_ecount(25) FLOAT* WINAPI D3DXSHMultiply5(__out_ecount(25) FLOAT *pOut,__in_ecount(25) CONST FLOAT *pF,__in_ecount(25) CONST FLOAT *pG);
+__out_ecount(36) FLOAT* WINAPI D3DXSHMultiply6(__out_ecount(36) FLOAT *pOut,__in_ecount(36) CONST FLOAT *pF,__in_ecount(36) CONST FLOAT *pG);
+
+
+//============================================================================
+//
+// 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,
+ __out_ecount_opt(Order*Order) FLOAT *pROut,
+ __out_ecount_opt(Order*Order) FLOAT *pGOut,
+ __out_ecount_opt(Order*Order) 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,
+ __out_ecount_opt(Order*Order) FLOAT *pROut,
+ __out_ecount_opt(Order*Order) FLOAT *pGOut,
+ __out_ecount_opt(Order*Order) 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,
+ __out_ecount_opt(Order*Order) FLOAT *pROut,
+ __out_ecount_opt(Order*Order) FLOAT *pGOut,
+ __out_ecount_opt(Order*Order) 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,
+ __out_ecount_opt(Order*Order) FLOAT *pROut,
+ __out_ecount_opt(Order*Order) FLOAT *pGOut,
+ __out_ecount_opt(Order*Order) FLOAT *pBOut );
+
+// Math intersection functions
+
+BOOL WINAPI D3DXIntersectTri
+(
+ CONST D3DXVECTOR3 *p0, // Triangle vertex 0 position
+ CONST D3DXVECTOR3 *p1, // Triangle vertex 1 position
+ CONST D3DXVECTOR3 *p2, // Triangle vertex 2 position
+ CONST D3DXVECTOR3 *pRayPos, // Ray origin
+ CONST D3DXVECTOR3 *pRayDir, // Ray direction
+ FLOAT *pU, // Barycentric Hit Coordinates
+ FLOAT *pV, // Barycentric Hit Coordinates
+ FLOAT *pDist); // Ray-Intersection Parameter Distance
+
+BOOL WINAPI
+ D3DXSphereBoundProbe(
+ CONST D3DXVECTOR3 *pCenter,
+ FLOAT Radius,
+ CONST D3DXVECTOR3 *pRayPosition,
+ CONST D3DXVECTOR3 *pRayDirection);
+
+BOOL WINAPI
+ D3DXBoxBoundProbe(
+ CONST D3DXVECTOR3 *pMin,
+ CONST D3DXVECTOR3 *pMax,
+ CONST D3DXVECTOR3 *pRayPosition,
+ CONST D3DXVECTOR3 *pRayDirection);
+
+HRESULT WINAPI
+ D3DXComputeBoundingSphere(
+ CONST D3DXVECTOR3 *pFirstPosition, // pointer to first position
+ DWORD NumVertices,
+ DWORD dwStride, // count in bytes to subsequent position vectors
+ D3DXVECTOR3 *pCenter,
+ FLOAT *pRadius);
+
+HRESULT WINAPI
+ D3DXComputeBoundingBox(
+ CONST D3DXVECTOR3 *pFirstPosition, // pointer to first position
+ DWORD NumVertices,
+ DWORD dwStride, // count in bytes to subsequent position vectors
+ D3DXVECTOR3 *pMin,
+ D3DXVECTOR3 *pMax);
+
+
+///////////////////////////////////////////////////////////////////////////
+// CPU Optimization:
+///////////////////////////////////////////////////////////////////////////
+
+//-------------------------------------------------------------------------
+// D3DX_CPU_OPTIMIZATION flags:
+// ----------------------------
+// D3DX_NOT_OPTIMIZED Use Intel Pentium optimizations
+// D3DX_3DNOW_OPTIMIZED Use AMD 3DNow optimizations
+// D3DX_SSE_OPTIMIZED Use Intel Pentium III SSE optimizations
+// D3DX_SSE2_OPTIMIZED Use Intel Pentium IV SSE2 optimizations
+//-------------------------------------------------------------------------
+
+
+typedef enum _D3DX_CPU_OPTIMIZATION
+{
+ D3DX_NOT_OPTIMIZED = 0,
+ D3DX_3DNOW_OPTIMIZED,
+ D3DX_SSE2_OPTIMIZED,
+ D3DX_SSE_OPTIMIZED
+} D3DX_CPU_OPTIMIZATION;
+
+
+//-------------------------------------------------------------------------
+// D3DXCpuOptimizations:
+// ---------------------
+// Enables or disables CPU optimizations. Returns the type of CPU, which
+// was detected, and for which optimizations exist.
+//
+// Parameters:
+// Enable
+// TRUE to enable CPU optimizations. FALSE to disable.
+//-------------------------------------------------------------------------
+
+D3DX_CPU_OPTIMIZATION WINAPI
+ D3DXCpuOptimizations(BOOL Enable);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#include "D3DX10math.inl"
+
+#if _MSC_VER >= 1200
+#pragma warning(pop)
+#else
+#pragma warning(default:4201)
+#endif
+
+#endif // __D3DX9MATH_H__
+
diff --git a/external/D3D11/include/D3DX10math.inl b/external/D3D11/include/D3DX10math.inl
new file mode 100644
index 0000000..56f1163
--- /dev/null
+++ b/external/D3D11/include/D3DX10math.inl
@@ -0,0 +1,2228 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) Microsoft Corporation. All Rights Reserved.
+//
+// File: d3dx10math.inl
+// Content: D3DX10 math inline functions
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3DXMATH_INL__
+#define __D3DXMATH_INL__
+
+
+//===========================================================================
+//
+// Inline Class Methods
+//
+//===========================================================================
+
+#ifdef __cplusplus
+
+//--------------------------
+// Float16
+//--------------------------
+
+D3DX10INLINE
+D3DXFLOAT16::D3DXFLOAT16( FLOAT f )
+{
+ D3DXFloat32To16Array(this, &f, 1);
+}
+
+D3DX10INLINE
+D3DXFLOAT16::D3DXFLOAT16( CONST D3DXFLOAT16& f )
+{
+ value = f.value;
+}
+
+// casting
+D3DX10INLINE
+D3DXFLOAT16::operator FLOAT ()
+{
+ FLOAT f;
+ D3DXFloat16To32Array(&f, this, 1);
+ return f;
+}
+
+// binary operators
+D3DX10INLINE BOOL
+D3DXFLOAT16::operator == ( CONST D3DXFLOAT16& f ) const
+{
+ // At least one is NaN
+ if(((value & D3DX_16F_EXP_MASK) == D3DX_16F_EXP_MASK && (value & D3DX_16F_FRAC_MASK))
+ || ((f.value & D3DX_16F_EXP_MASK) == D3DX_16F_EXP_MASK && (f.value & D3DX_16F_FRAC_MASK)))
+ return false;
+ // +/- Zero
+ else if((value & ~D3DX_16F_SIGN_MASK) == 0 && (f.value & ~D3DX_16F_SIGN_MASK) == 0)
+ return true;
+ else
+ return value == f.value;
+}
+
+D3DX10INLINE BOOL
+D3DXFLOAT16::operator != ( CONST D3DXFLOAT16& f ) const
+{
+ // At least one is NaN
+ if(((value & D3DX_16F_EXP_MASK) == D3DX_16F_EXP_MASK && (value & D3DX_16F_FRAC_MASK))
+ || ((f.value & D3DX_16F_EXP_MASK) == D3DX_16F_EXP_MASK && (f.value & D3DX_16F_FRAC_MASK)))
+ return true;
+ // +/- Zero
+ else if((value & ~D3DX_16F_SIGN_MASK) == 0 && (f.value & ~D3DX_16F_SIGN_MASK) == 0)
+ return false;
+ else
+ return value != f.value;
+}
+
+
+//--------------------------
+// 2D Vector
+//--------------------------
+
+D3DX10INLINE
+D3DXVECTOR2::D3DXVECTOR2( CONST FLOAT *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ x = pf[0];
+ y = pf[1];
+}
+
+D3DX10INLINE
+D3DXVECTOR2::D3DXVECTOR2( CONST D3DXFLOAT16 *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ D3DXFloat16To32Array(&x, pf, 2);
+}
+
+D3DX10INLINE
+D3DXVECTOR2::D3DXVECTOR2( FLOAT fx, FLOAT fy )
+{
+ x = fx;
+ y = fy;
+}
+
+
+// casting
+D3DX10INLINE
+D3DXVECTOR2::operator FLOAT* ()
+{
+ return (FLOAT *) &x;
+}
+
+D3DX10INLINE
+D3DXVECTOR2::operator CONST FLOAT* () const
+{
+ return (CONST FLOAT *) &x;
+}
+
+
+// assignment operators
+D3DX10INLINE D3DXVECTOR2&
+D3DXVECTOR2::operator += ( CONST D3DXVECTOR2& v )
+{
+ x += v.x;
+ y += v.y;
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR2&
+D3DXVECTOR2::operator -= ( CONST D3DXVECTOR2& v )
+{
+ x -= v.x;
+ y -= v.y;
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR2&
+D3DXVECTOR2::operator *= ( FLOAT f )
+{
+ x *= f;
+ y *= f;
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR2&
+D3DXVECTOR2::operator /= ( FLOAT f )
+{
+ FLOAT fInv = 1.0f / f;
+ x *= fInv;
+ y *= fInv;
+ return *this;
+}
+
+
+// unary operators
+D3DX10INLINE D3DXVECTOR2
+D3DXVECTOR2::operator + () const
+{
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR2
+D3DXVECTOR2::operator - () const
+{
+ return D3DXVECTOR2(-x, -y);
+}
+
+
+// binary operators
+D3DX10INLINE D3DXVECTOR2
+D3DXVECTOR2::operator + ( CONST D3DXVECTOR2& v ) const
+{
+ return D3DXVECTOR2(x + v.x, y + v.y);
+}
+
+D3DX10INLINE D3DXVECTOR2
+D3DXVECTOR2::operator - ( CONST D3DXVECTOR2& v ) const
+{
+ return D3DXVECTOR2(x - v.x, y - v.y);
+}
+
+D3DX10INLINE D3DXVECTOR2
+D3DXVECTOR2::operator * ( FLOAT f ) const
+{
+ return D3DXVECTOR2(x * f, y * f);
+}
+
+D3DX10INLINE D3DXVECTOR2
+D3DXVECTOR2::operator / ( FLOAT f ) const
+{
+ FLOAT fInv = 1.0f / f;
+ return D3DXVECTOR2(x * fInv, y * fInv);
+}
+
+D3DX10INLINE D3DXVECTOR2
+operator * ( FLOAT f, CONST D3DXVECTOR2& v )
+{
+ return D3DXVECTOR2(f * v.x, f * v.y);
+}
+
+D3DX10INLINE BOOL
+D3DXVECTOR2::operator == ( CONST D3DXVECTOR2& v ) const
+{
+ return x == v.x && y == v.y;
+}
+
+D3DX10INLINE BOOL
+D3DXVECTOR2::operator != ( CONST D3DXVECTOR2& v ) const
+{
+ return x != v.x || y != v.y;
+}
+
+
+
+//--------------------------
+// 2D Vector (16 bit)
+//--------------------------
+
+D3DX10INLINE
+D3DXVECTOR2_16F::D3DXVECTOR2_16F( CONST FLOAT *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ D3DXFloat32To16Array(&x, pf, 2);
+}
+
+D3DX10INLINE
+D3DXVECTOR2_16F::D3DXVECTOR2_16F( CONST D3DXFLOAT16 *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ *((UINT *) &x) = *((UINT *) &pf[0]);
+}
+
+D3DX10INLINE
+D3DXVECTOR2_16F::D3DXVECTOR2_16F( CONST D3DXFLOAT16 &fx, CONST D3DXFLOAT16 &fy )
+{
+ x = fx;
+ y = fy;
+}
+
+
+// casting
+D3DX10INLINE
+D3DXVECTOR2_16F::operator D3DXFLOAT16* ()
+{
+ return (D3DXFLOAT16*) &x;
+}
+
+D3DX10INLINE
+D3DXVECTOR2_16F::operator CONST D3DXFLOAT16* () const
+{
+ return (CONST D3DXFLOAT16*) &x;
+}
+
+
+// binary operators
+D3DX10INLINE BOOL
+D3DXVECTOR2_16F::operator == ( CONST D3DXVECTOR2_16F &v ) const
+{
+ return x == v.x && y == v.y;
+}
+
+D3DX10INLINE BOOL
+D3DXVECTOR2_16F::operator != ( CONST D3DXVECTOR2_16F &v ) const
+{
+ return x != v.x || y != v.y;
+}
+
+
+//--------------------------
+// 3D Vector
+//--------------------------
+D3DX10INLINE
+D3DXVECTOR3::D3DXVECTOR3( CONST FLOAT *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ x = pf[0];
+ y = pf[1];
+ z = pf[2];
+}
+
+D3DX10INLINE
+D3DXVECTOR3::D3DXVECTOR3( CONST D3DVECTOR& v )
+{
+ x = v.x;
+ y = v.y;
+ z = v.z;
+}
+
+D3DX10INLINE
+D3DXVECTOR3::D3DXVECTOR3( CONST D3DXFLOAT16 *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ D3DXFloat16To32Array(&x, pf, 3);
+}
+
+D3DX10INLINE
+D3DXVECTOR3::D3DXVECTOR3( FLOAT fx, FLOAT fy, FLOAT fz )
+{
+ x = fx;
+ y = fy;
+ z = fz;
+}
+
+
+// casting
+D3DX10INLINE
+D3DXVECTOR3::operator FLOAT* ()
+{
+ return (FLOAT *) &x;
+}
+
+D3DX10INLINE
+D3DXVECTOR3::operator CONST FLOAT* () const
+{
+ return (CONST FLOAT *) &x;
+}
+
+
+// assignment operators
+D3DX10INLINE D3DXVECTOR3&
+D3DXVECTOR3::operator += ( CONST D3DXVECTOR3& v )
+{
+ x += v.x;
+ y += v.y;
+ z += v.z;
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR3&
+D3DXVECTOR3::operator -= ( CONST D3DXVECTOR3& v )
+{
+ x -= v.x;
+ y -= v.y;
+ z -= v.z;
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR3&
+D3DXVECTOR3::operator *= ( FLOAT f )
+{
+ x *= f;
+ y *= f;
+ z *= f;
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR3&
+D3DXVECTOR3::operator /= ( FLOAT f )
+{
+ FLOAT fInv = 1.0f / f;
+ x *= fInv;
+ y *= fInv;
+ z *= fInv;
+ return *this;
+}
+
+
+// unary operators
+D3DX10INLINE D3DXVECTOR3
+D3DXVECTOR3::operator + () const
+{
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR3
+D3DXVECTOR3::operator - () const
+{
+ return D3DXVECTOR3(-x, -y, -z);
+}
+
+
+// binary operators
+D3DX10INLINE D3DXVECTOR3
+D3DXVECTOR3::operator + ( CONST D3DXVECTOR3& v ) const
+{
+ return D3DXVECTOR3(x + v.x, y + v.y, z + v.z);
+}
+
+D3DX10INLINE D3DXVECTOR3
+D3DXVECTOR3::operator - ( CONST D3DXVECTOR3& v ) const
+{
+ return D3DXVECTOR3(x - v.x, y - v.y, z - v.z);
+}
+
+D3DX10INLINE D3DXVECTOR3
+D3DXVECTOR3::operator * ( FLOAT f ) const
+{
+ return D3DXVECTOR3(x * f, y * f, z * f);
+}
+
+D3DX10INLINE D3DXVECTOR3
+D3DXVECTOR3::operator / ( FLOAT f ) const
+{
+ FLOAT fInv = 1.0f / f;
+ return D3DXVECTOR3(x * fInv, y * fInv, z * fInv);
+}
+
+
+D3DX10INLINE D3DXVECTOR3
+operator * ( FLOAT f, CONST struct D3DXVECTOR3& v )
+{
+ return D3DXVECTOR3(f * v.x, f * v.y, f * v.z);
+}
+
+
+D3DX10INLINE BOOL
+D3DXVECTOR3::operator == ( CONST D3DXVECTOR3& v ) const
+{
+ return x == v.x && y == v.y && z == v.z;
+}
+
+D3DX10INLINE BOOL
+D3DXVECTOR3::operator != ( CONST D3DXVECTOR3& v ) const
+{
+ return x != v.x || y != v.y || z != v.z;
+}
+
+
+
+//--------------------------
+// 3D Vector (16 bit)
+//--------------------------
+
+D3DX10INLINE
+D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST FLOAT *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ D3DXFloat32To16Array(&x, pf, 3);
+}
+
+D3DX10INLINE
+D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST D3DVECTOR& v )
+{
+ D3DXFloat32To16Array(&x, &v.x, 1);
+ D3DXFloat32To16Array(&y, &v.y, 1);
+ D3DXFloat32To16Array(&z, &v.z, 1);
+}
+
+D3DX10INLINE
+D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST D3DXFLOAT16 *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ *((UINT *) &x) = *((UINT *) &pf[0]);
+ *((WORD *) &z) = *((WORD *) &pf[2]);
+}
+
+D3DX10INLINE
+D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST D3DXFLOAT16 &fx, CONST D3DXFLOAT16 &fy, CONST D3DXFLOAT16 &fz )
+{
+ x = fx;
+ y = fy;
+ z = fz;
+}
+
+
+// casting
+D3DX10INLINE
+D3DXVECTOR3_16F::operator D3DXFLOAT16* ()
+{
+ return (D3DXFLOAT16*) &x;
+}
+
+D3DX10INLINE
+D3DXVECTOR3_16F::operator CONST D3DXFLOAT16* () const
+{
+ return (CONST D3DXFLOAT16*) &x;
+}
+
+
+// binary operators
+D3DX10INLINE BOOL
+D3DXVECTOR3_16F::operator == ( CONST D3DXVECTOR3_16F &v ) const
+{
+ return x == v.x && y == v.y && z == v.z;
+}
+
+D3DX10INLINE BOOL
+D3DXVECTOR3_16F::operator != ( CONST D3DXVECTOR3_16F &v ) const
+{
+ return x != v.x || y != v.y || z != v.z;
+}
+
+
+//--------------------------
+// 4D Vector
+//--------------------------
+D3DX10INLINE
+D3DXVECTOR4::D3DXVECTOR4( CONST FLOAT *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ x = pf[0];
+ y = pf[1];
+ z = pf[2];
+ w = pf[3];
+}
+
+D3DX10INLINE
+D3DXVECTOR4::D3DXVECTOR4( CONST D3DXFLOAT16 *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ D3DXFloat16To32Array(&x, pf, 4);
+}
+
+D3DX10INLINE
+D3DXVECTOR4::D3DXVECTOR4( CONST D3DVECTOR& v, FLOAT f )
+{
+ x = v.x;
+ y = v.y;
+ z = v.z;
+ w = f;
+}
+
+D3DX10INLINE
+D3DXVECTOR4::D3DXVECTOR4( FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw )
+{
+ x = fx;
+ y = fy;
+ z = fz;
+ w = fw;
+}
+
+
+// casting
+D3DX10INLINE
+D3DXVECTOR4::operator FLOAT* ()
+{
+ return (FLOAT *) &x;
+}
+
+D3DX10INLINE
+D3DXVECTOR4::operator CONST FLOAT* () const
+{
+ return (CONST FLOAT *) &x;
+}
+
+
+// assignment operators
+D3DX10INLINE D3DXVECTOR4&
+D3DXVECTOR4::operator += ( CONST D3DXVECTOR4& v )
+{
+ x += v.x;
+ y += v.y;
+ z += v.z;
+ w += v.w;
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR4&
+D3DXVECTOR4::operator -= ( CONST D3DXVECTOR4& v )
+{
+ x -= v.x;
+ y -= v.y;
+ z -= v.z;
+ w -= v.w;
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR4&
+D3DXVECTOR4::operator *= ( FLOAT f )
+{
+ x *= f;
+ y *= f;
+ z *= f;
+ w *= f;
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR4&
+D3DXVECTOR4::operator /= ( FLOAT f )
+{
+ FLOAT fInv = 1.0f / f;
+ x *= fInv;
+ y *= fInv;
+ z *= fInv;
+ w *= fInv;
+ return *this;
+}
+
+
+// unary operators
+D3DX10INLINE D3DXVECTOR4
+D3DXVECTOR4::operator + () const
+{
+ return *this;
+}
+
+D3DX10INLINE D3DXVECTOR4
+D3DXVECTOR4::operator - () const
+{
+ return D3DXVECTOR4(-x, -y, -z, -w);
+}
+
+
+// binary operators
+D3DX10INLINE D3DXVECTOR4
+D3DXVECTOR4::operator + ( CONST D3DXVECTOR4& v ) const
+{
+ return D3DXVECTOR4(x + v.x, y + v.y, z + v.z, w + v.w);
+}
+
+D3DX10INLINE D3DXVECTOR4
+D3DXVECTOR4::operator - ( CONST D3DXVECTOR4& v ) const
+{
+ return D3DXVECTOR4(x - v.x, y - v.y, z - v.z, w - v.w);
+}
+
+D3DX10INLINE D3DXVECTOR4
+D3DXVECTOR4::operator * ( FLOAT f ) const
+{
+ return D3DXVECTOR4(x * f, y * f, z * f, w * f);
+}
+
+D3DX10INLINE D3DXVECTOR4
+D3DXVECTOR4::operator / ( FLOAT f ) const
+{
+ FLOAT fInv = 1.0f / f;
+ return D3DXVECTOR4(x * fInv, y * fInv, z * fInv, w * fInv);
+}
+
+D3DX10INLINE D3DXVECTOR4
+operator * ( FLOAT f, CONST D3DXVECTOR4& v )
+{
+ return D3DXVECTOR4(f * v.x, f * v.y, f * v.z, f * v.w);
+}
+
+
+D3DX10INLINE BOOL
+D3DXVECTOR4::operator == ( CONST D3DXVECTOR4& v ) const
+{
+ return x == v.x && y == v.y && z == v.z && w == v.w;
+}
+
+D3DX10INLINE BOOL
+D3DXVECTOR4::operator != ( CONST D3DXVECTOR4& v ) const
+{
+ return x != v.x || y != v.y || z != v.z || w != v.w;
+}
+
+
+
+//--------------------------
+// 4D Vector (16 bit)
+//--------------------------
+
+D3DX10INLINE
+D3DXVECTOR4_16F::D3DXVECTOR4_16F( CONST FLOAT *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ D3DXFloat32To16Array(&x, pf, 4);
+}
+
+D3DX10INLINE
+D3DXVECTOR4_16F::D3DXVECTOR4_16F( CONST D3DXFLOAT16 *pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ *((UINT *) &x) = *((UINT *) &pf[0]);
+ *((UINT *) &z) = *((UINT *) &pf[2]);
+}
+
+D3DX10INLINE
+D3DXVECTOR4_16F::D3DXVECTOR4_16F( CONST D3DXVECTOR3_16F& v, CONST D3DXFLOAT16& f )
+{
+ x = v.x;
+ y = v.y;
+ z = v.z;
+ w = f;
+}
+
+D3DX10INLINE
+D3DXVECTOR4_16F::D3DXVECTOR4_16F( CONST D3DXFLOAT16 &fx, CONST D3DXFLOAT16 &fy, CONST D3DXFLOAT16 &fz, CONST D3DXFLOAT16 &fw )
+{
+ x = fx;
+ y = fy;
+ z = fz;
+ w = fw;
+}
+
+
+// casting
+D3DX10INLINE
+D3DXVECTOR4_16F::operator D3DXFLOAT16* ()
+{
+ return (D3DXFLOAT16*) &x;
+}
+
+D3DX10INLINE
+D3DXVECTOR4_16F::operator CONST D3DXFLOAT16* () const
+{
+ return (CONST D3DXFLOAT16*) &x;
+}
+
+
+// binary operators
+D3DX10INLINE BOOL
+D3DXVECTOR4_16F::operator == ( CONST D3DXVECTOR4_16F &v ) const
+{
+ return x == v.x && y == v.y && z == v.z && w == v.w;
+}
+
+D3DX10INLINE BOOL
+D3DXVECTOR4_16F::operator != ( CONST D3DXVECTOR4_16F &v ) const
+{
+ return x != v.x || y != v.y || z != v.z || w != v.w;
+}
+
+
+//--------------------------
+// Matrix
+//--------------------------
+D3DX10INLINE
+D3DXMATRIX::D3DXMATRIX( CONST FLOAT* pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ memcpy(&_11, pf, sizeof(D3DXMATRIX));
+}
+
+D3DX10INLINE
+D3DXMATRIX::D3DXMATRIX( CONST D3DMATRIX& mat )
+{
+ memcpy(&_11, &mat, sizeof(D3DXMATRIX));
+}
+
+D3DX10INLINE
+D3DXMATRIX::D3DXMATRIX( CONST D3DXFLOAT16* pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ D3DXFloat16To32Array(&_11, pf, 16);
+}
+
+D3DX10INLINE
+D3DXMATRIX::D3DXMATRIX( FLOAT f11, FLOAT f12, FLOAT f13, FLOAT f14,
+ FLOAT f21, FLOAT f22, FLOAT f23, FLOAT f24,
+ FLOAT f31, FLOAT f32, FLOAT f33, FLOAT f34,
+ FLOAT f41, FLOAT f42, FLOAT f43, FLOAT f44 )
+{
+ _11 = f11; _12 = f12; _13 = f13; _14 = f14;
+ _21 = f21; _22 = f22; _23 = f23; _24 = f24;
+ _31 = f31; _32 = f32; _33 = f33; _34 = f34;
+ _41 = f41; _42 = f42; _43 = f43; _44 = f44;
+}
+
+
+
+// access grants
+D3DX10INLINE FLOAT&
+D3DXMATRIX::operator () ( UINT iRow, UINT iCol )
+{
+ return m[iRow][iCol];
+}
+
+D3DX10INLINE FLOAT
+D3DXMATRIX::operator () ( UINT iRow, UINT iCol ) const
+{
+ return m[iRow][iCol];
+}
+
+
+// casting operators
+D3DX10INLINE
+D3DXMATRIX::operator FLOAT* ()
+{
+ return (FLOAT *) &_11;
+}
+
+D3DX10INLINE
+D3DXMATRIX::operator CONST FLOAT* () const
+{
+ return (CONST FLOAT *) &_11;
+}
+
+
+// assignment operators
+D3DX10INLINE D3DXMATRIX&
+D3DXMATRIX::operator *= ( CONST D3DXMATRIX& mat )
+{
+ D3DXMatrixMultiply(this, this, &mat);
+ return *this;
+}
+
+D3DX10INLINE D3DXMATRIX&
+D3DXMATRIX::operator += ( CONST D3DXMATRIX& mat )
+{
+ _11 += mat._11; _12 += mat._12; _13 += mat._13; _14 += mat._14;
+ _21 += mat._21; _22 += mat._22; _23 += mat._23; _24 += mat._24;
+ _31 += mat._31; _32 += mat._32; _33 += mat._33; _34 += mat._34;
+ _41 += mat._41; _42 += mat._42; _43 += mat._43; _44 += mat._44;
+ return *this;
+}
+
+D3DX10INLINE D3DXMATRIX&
+D3DXMATRIX::operator -= ( CONST D3DXMATRIX& mat )
+{
+ _11 -= mat._11; _12 -= mat._12; _13 -= mat._13; _14 -= mat._14;
+ _21 -= mat._21; _22 -= mat._22; _23 -= mat._23; _24 -= mat._24;
+ _31 -= mat._31; _32 -= mat._32; _33 -= mat._33; _34 -= mat._34;
+ _41 -= mat._41; _42 -= mat._42; _43 -= mat._43; _44 -= mat._44;
+ return *this;
+}
+
+D3DX10INLINE D3DXMATRIX&
+D3DXMATRIX::operator *= ( FLOAT f )
+{
+ _11 *= f; _12 *= f; _13 *= f; _14 *= f;
+ _21 *= f; _22 *= f; _23 *= f; _24 *= f;
+ _31 *= f; _32 *= f; _33 *= f; _34 *= f;
+ _41 *= f; _42 *= f; _43 *= f; _44 *= f;
+ return *this;
+}
+
+D3DX10INLINE D3DXMATRIX&
+D3DXMATRIX::operator /= ( FLOAT f )
+{
+ FLOAT fInv = 1.0f / f;
+ _11 *= fInv; _12 *= fInv; _13 *= fInv; _14 *= fInv;
+ _21 *= fInv; _22 *= fInv; _23 *= fInv; _24 *= fInv;
+ _31 *= fInv; _32 *= fInv; _33 *= fInv; _34 *= fInv;
+ _41 *= fInv; _42 *= fInv; _43 *= fInv; _44 *= fInv;
+ return *this;
+}
+
+
+// unary operators
+D3DX10INLINE D3DXMATRIX
+D3DXMATRIX::operator + () const
+{
+ return *this;
+}
+
+D3DX10INLINE D3DXMATRIX
+D3DXMATRIX::operator - () const
+{
+ return D3DXMATRIX(-_11, -_12, -_13, -_14,
+ -_21, -_22, -_23, -_24,
+ -_31, -_32, -_33, -_34,
+ -_41, -_42, -_43, -_44);
+}
+
+
+// binary operators
+D3DX10INLINE D3DXMATRIX
+D3DXMATRIX::operator * ( CONST D3DXMATRIX& mat ) const
+{
+ D3DXMATRIX matT;
+ D3DXMatrixMultiply(&matT, this, &mat);
+ return matT;
+}
+
+D3DX10INLINE D3DXMATRIX
+D3DXMATRIX::operator + ( CONST D3DXMATRIX& mat ) const
+{
+ return D3DXMATRIX(_11 + mat._11, _12 + mat._12, _13 + mat._13, _14 + mat._14,
+ _21 + mat._21, _22 + mat._22, _23 + mat._23, _24 + mat._24,
+ _31 + mat._31, _32 + mat._32, _33 + mat._33, _34 + mat._34,
+ _41 + mat._41, _42 + mat._42, _43 + mat._43, _44 + mat._44);
+}
+
+D3DX10INLINE D3DXMATRIX
+D3DXMATRIX::operator - ( CONST D3DXMATRIX& mat ) const
+{
+ return D3DXMATRIX(_11 - mat._11, _12 - mat._12, _13 - mat._13, _14 - mat._14,
+ _21 - mat._21, _22 - mat._22, _23 - mat._23, _24 - mat._24,
+ _31 - mat._31, _32 - mat._32, _33 - mat._33, _34 - mat._34,
+ _41 - mat._41, _42 - mat._42, _43 - mat._43, _44 - mat._44);
+}
+
+D3DX10INLINE D3DXMATRIX
+D3DXMATRIX::operator * ( FLOAT f ) const
+{
+ return D3DXMATRIX(_11 * f, _12 * f, _13 * f, _14 * f,
+ _21 * f, _22 * f, _23 * f, _24 * f,
+ _31 * f, _32 * f, _33 * f, _34 * f,
+ _41 * f, _42 * f, _43 * f, _44 * f);
+}
+
+D3DX10INLINE D3DXMATRIX
+D3DXMATRIX::operator / ( FLOAT f ) const
+{
+ FLOAT fInv = 1.0f / f;
+ return D3DXMATRIX(_11 * fInv, _12 * fInv, _13 * fInv, _14 * fInv,
+ _21 * fInv, _22 * fInv, _23 * fInv, _24 * fInv,
+ _31 * fInv, _32 * fInv, _33 * fInv, _34 * fInv,
+ _41 * fInv, _42 * fInv, _43 * fInv, _44 * fInv);
+}
+
+
+D3DX10INLINE D3DXMATRIX
+operator * ( FLOAT f, CONST D3DXMATRIX& mat )
+{
+ return D3DXMATRIX(f * mat._11, f * mat._12, f * mat._13, f * mat._14,
+ f * mat._21, f * mat._22, f * mat._23, f * mat._24,
+ f * mat._31, f * mat._32, f * mat._33, f * mat._34,
+ f * mat._41, f * mat._42, f * mat._43, f * mat._44);
+}
+
+
+D3DX10INLINE BOOL
+D3DXMATRIX::operator == ( CONST D3DXMATRIX& mat ) const
+{
+ return 0 == memcmp(this, &mat, sizeof(D3DXMATRIX));
+}
+
+D3DX10INLINE BOOL
+D3DXMATRIX::operator != ( CONST D3DXMATRIX& mat ) const
+{
+ return 0 != memcmp(this, &mat, sizeof(D3DXMATRIX));
+}
+
+
+
+//--------------------------
+// Aligned Matrices
+//--------------------------
+
+D3DX10INLINE
+_D3DXMATRIXA16::_D3DXMATRIXA16( CONST FLOAT* f ) :
+ D3DXMATRIX( f )
+{
+}
+
+D3DX10INLINE
+_D3DXMATRIXA16::_D3DXMATRIXA16( CONST D3DMATRIX& m ) :
+ D3DXMATRIX( m )
+{
+}
+
+D3DX10INLINE
+_D3DXMATRIXA16::_D3DXMATRIXA16( CONST D3DXFLOAT16* f ) :
+ D3DXMATRIX( f )
+{
+}
+
+D3DX10INLINE
+_D3DXMATRIXA16::_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)
+{
+}
+
+#ifndef SIZE_MAX
+#define SIZE_MAX ((SIZE_T)-1)
+#endif
+
+D3DX10INLINE void*
+_D3DXMATRIXA16::operator new( size_t s )
+{
+ if (s > (SIZE_MAX-16))
+ return NULL;
+ LPBYTE p = ::new BYTE[s + 16];
+ if (p)
+ {
+ BYTE offset = (BYTE)(16 - ((UINT_PTR)p & 15));
+ p += offset;
+ p[-1] = offset;
+ }
+ return p;
+}
+
+D3DX10INLINE void*
+_D3DXMATRIXA16::operator new[]( size_t s )
+{
+ if (s > (SIZE_MAX-16))
+ return NULL;
+ LPBYTE p = ::new BYTE[s + 16];
+ if (p)
+ {
+ BYTE offset = (BYTE)(16 - ((UINT_PTR)p & 15));
+ p += offset;
+ p[-1] = offset;
+ }
+ return p;
+}
+
+D3DX10INLINE void
+_D3DXMATRIXA16::operator delete(void* p)
+{
+ if(p)
+ {
+ BYTE* pb = static_cast<BYTE*>(p);
+ pb -= pb[-1];
+ ::delete [] pb;
+ }
+}
+
+D3DX10INLINE void
+_D3DXMATRIXA16::operator delete[](void* p)
+{
+ if(p)
+ {
+ BYTE* pb = static_cast<BYTE*>(p);
+ pb -= pb[-1];
+ ::delete [] pb;
+ }
+}
+
+D3DX10INLINE _D3DXMATRIXA16&
+_D3DXMATRIXA16::operator=(CONST D3DXMATRIX& rhs)
+{
+ memcpy(&_11, &rhs, sizeof(D3DXMATRIX));
+ return *this;
+}
+
+
+//--------------------------
+// Quaternion
+//--------------------------
+
+D3DX10INLINE
+D3DXQUATERNION::D3DXQUATERNION( CONST FLOAT* pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ x = pf[0];
+ y = pf[1];
+ z = pf[2];
+ w = pf[3];
+}
+
+D3DX10INLINE
+D3DXQUATERNION::D3DXQUATERNION( CONST D3DXFLOAT16* pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ D3DXFloat16To32Array(&x, pf, 4);
+}
+
+D3DX10INLINE
+D3DXQUATERNION::D3DXQUATERNION( FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw )
+{
+ x = fx;
+ y = fy;
+ z = fz;
+ w = fw;
+}
+
+
+// casting
+D3DX10INLINE
+D3DXQUATERNION::operator FLOAT* ()
+{
+ return (FLOAT *) &x;
+}
+
+D3DX10INLINE
+D3DXQUATERNION::operator CONST FLOAT* () const
+{
+ return (CONST FLOAT *) &x;
+}
+
+
+// assignment operators
+D3DX10INLINE D3DXQUATERNION&
+D3DXQUATERNION::operator += ( CONST D3DXQUATERNION& q )
+{
+ x += q.x;
+ y += q.y;
+ z += q.z;
+ w += q.w;
+ return *this;
+}
+
+D3DX10INLINE D3DXQUATERNION&
+D3DXQUATERNION::operator -= ( CONST D3DXQUATERNION& q )
+{
+ x -= q.x;
+ y -= q.y;
+ z -= q.z;
+ w -= q.w;
+ return *this;
+}
+
+D3DX10INLINE D3DXQUATERNION&
+D3DXQUATERNION::operator *= ( CONST D3DXQUATERNION& q )
+{
+ D3DXQuaternionMultiply(this, this, &q);
+ return *this;
+}
+
+D3DX10INLINE D3DXQUATERNION&
+D3DXQUATERNION::operator *= ( FLOAT f )
+{
+ x *= f;
+ y *= f;
+ z *= f;
+ w *= f;
+ return *this;
+}
+
+D3DX10INLINE D3DXQUATERNION&
+D3DXQUATERNION::operator /= ( FLOAT f )
+{
+ FLOAT fInv = 1.0f / f;
+ x *= fInv;
+ y *= fInv;
+ z *= fInv;
+ w *= fInv;
+ return *this;
+}
+
+
+// unary operators
+D3DX10INLINE D3DXQUATERNION
+D3DXQUATERNION::operator + () const
+{
+ return *this;
+}
+
+D3DX10INLINE D3DXQUATERNION
+D3DXQUATERNION::operator - () const
+{
+ return D3DXQUATERNION(-x, -y, -z, -w);
+}
+
+
+// binary operators
+D3DX10INLINE D3DXQUATERNION
+D3DXQUATERNION::operator + ( CONST D3DXQUATERNION& q ) const
+{
+ return D3DXQUATERNION(x + q.x, y + q.y, z + q.z, w + q.w);
+}
+
+D3DX10INLINE D3DXQUATERNION
+D3DXQUATERNION::operator - ( CONST D3DXQUATERNION& q ) const
+{
+ return D3DXQUATERNION(x - q.x, y - q.y, z - q.z, w - q.w);
+}
+
+D3DX10INLINE D3DXQUATERNION
+D3DXQUATERNION::operator * ( CONST D3DXQUATERNION& q ) const
+{
+ D3DXQUATERNION qT;
+ D3DXQuaternionMultiply(&qT, this, &q);
+ return qT;
+}
+
+D3DX10INLINE D3DXQUATERNION
+D3DXQUATERNION::operator * ( FLOAT f ) const
+{
+ return D3DXQUATERNION(x * f, y * f, z * f, w * f);
+}
+
+D3DX10INLINE D3DXQUATERNION
+D3DXQUATERNION::operator / ( FLOAT f ) const
+{
+ FLOAT fInv = 1.0f / f;
+ return D3DXQUATERNION(x * fInv, y * fInv, z * fInv, w * fInv);
+}
+
+
+D3DX10INLINE D3DXQUATERNION
+operator * (FLOAT f, CONST D3DXQUATERNION& q )
+{
+ return D3DXQUATERNION(f * q.x, f * q.y, f * q.z, f * q.w);
+}
+
+
+D3DX10INLINE BOOL
+D3DXQUATERNION::operator == ( CONST D3DXQUATERNION& q ) const
+{
+ return x == q.x && y == q.y && z == q.z && w == q.w;
+}
+
+D3DX10INLINE BOOL
+D3DXQUATERNION::operator != ( CONST D3DXQUATERNION& q ) const
+{
+ return x != q.x || y != q.y || z != q.z || w != q.w;
+}
+
+
+
+//--------------------------
+// Plane
+//--------------------------
+
+D3DX10INLINE
+D3DXPLANE::D3DXPLANE( CONST FLOAT* pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ a = pf[0];
+ b = pf[1];
+ c = pf[2];
+ d = pf[3];
+}
+
+D3DX10INLINE
+D3DXPLANE::D3DXPLANE( CONST D3DXFLOAT16* pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ D3DXFloat16To32Array(&a, pf, 4);
+}
+
+D3DX10INLINE
+D3DXPLANE::D3DXPLANE( FLOAT fa, FLOAT fb, FLOAT fc, FLOAT fd )
+{
+ a = fa;
+ b = fb;
+ c = fc;
+ d = fd;
+}
+
+
+// casting
+D3DX10INLINE
+D3DXPLANE::operator FLOAT* ()
+{
+ return (FLOAT *) &a;
+}
+
+D3DX10INLINE
+D3DXPLANE::operator CONST FLOAT* () const
+{
+ return (CONST FLOAT *) &a;
+}
+
+
+// assignment operators
+D3DX10INLINE D3DXPLANE&
+D3DXPLANE::operator *= ( FLOAT f )
+{
+ a *= f;
+ b *= f;
+ c *= f;
+ d *= f;
+ return *this;
+}
+
+D3DX10INLINE D3DXPLANE&
+D3DXPLANE::operator /= ( FLOAT f )
+{
+ FLOAT fInv = 1.0f / f;
+ a *= fInv;
+ b *= fInv;
+ c *= fInv;
+ d *= fInv;
+ return *this;
+}
+
+
+// unary operators
+D3DX10INLINE D3DXPLANE
+D3DXPLANE::operator + () const
+{
+ return *this;
+}
+
+D3DX10INLINE D3DXPLANE
+D3DXPLANE::operator - () const
+{
+ return D3DXPLANE(-a, -b, -c, -d);
+}
+
+
+// binary operators
+D3DX10INLINE D3DXPLANE
+D3DXPLANE::operator * ( FLOAT f ) const
+{
+ return D3DXPLANE(a * f, b * f, c * f, d * f);
+}
+
+D3DX10INLINE D3DXPLANE
+D3DXPLANE::operator / ( FLOAT f ) const
+{
+ FLOAT fInv = 1.0f / f;
+ return D3DXPLANE(a * fInv, b * fInv, c * fInv, d * fInv);
+}
+
+D3DX10INLINE D3DXPLANE
+operator * (FLOAT f, CONST D3DXPLANE& p )
+{
+ return D3DXPLANE(f * p.a, f * p.b, f * p.c, f * p.d);
+}
+
+D3DX10INLINE BOOL
+D3DXPLANE::operator == ( CONST D3DXPLANE& p ) const
+{
+ return a == p.a && b == p.b && c == p.c && d == p.d;
+}
+
+D3DX10INLINE BOOL
+D3DXPLANE::operator != ( CONST D3DXPLANE& p ) const
+{
+ return a != p.a || b != p.b || c != p.c || d != p.d;
+}
+
+
+
+
+//--------------------------
+// Color
+//--------------------------
+
+D3DX10INLINE
+D3DXCOLOR::D3DXCOLOR( UINT dw )
+{
+ CONST FLOAT f = 1.0f / 255.0f;
+ r = f * (FLOAT) (unsigned char) (dw >> 16);
+ g = f * (FLOAT) (unsigned char) (dw >> 8);
+ b = f * (FLOAT) (unsigned char) (dw >> 0);
+ a = f * (FLOAT) (unsigned char) (dw >> 24);
+}
+
+D3DX10INLINE
+D3DXCOLOR::D3DXCOLOR( CONST FLOAT* pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ r = pf[0];
+ g = pf[1];
+ b = pf[2];
+ a = pf[3];
+}
+
+D3DX10INLINE
+D3DXCOLOR::D3DXCOLOR( CONST D3DXFLOAT16* pf )
+{
+#ifdef D3DX10_DEBUG
+ if(!pf)
+ return;
+#endif
+
+ D3DXFloat16To32Array(&r, pf, 4);
+}
+
+D3DX10INLINE
+D3DXCOLOR::D3DXCOLOR( FLOAT fr, FLOAT fg, FLOAT fb, FLOAT fa )
+{
+ r = fr;
+ g = fg;
+ b = fb;
+ a = fa;
+}
+
+
+// casting
+D3DX10INLINE
+D3DXCOLOR::operator UINT () const
+{
+ UINT dwR = r >= 1.0f ? 0xff : r <= 0.0f ? 0x00 : (UINT) (r * 255.0f + 0.5f);
+ UINT dwG = g >= 1.0f ? 0xff : g <= 0.0f ? 0x00 : (UINT) (g * 255.0f + 0.5f);
+ UINT dwB = b >= 1.0f ? 0xff : b <= 0.0f ? 0x00 : (UINT) (b * 255.0f + 0.5f);
+ UINT dwA = a >= 1.0f ? 0xff : a <= 0.0f ? 0x00 : (UINT) (a * 255.0f + 0.5f);
+
+ return (dwA << 24) | (dwR << 16) | (dwG << 8) | (dwB << 0);
+}
+
+
+D3DX10INLINE
+D3DXCOLOR::operator FLOAT * ()
+{
+ return (FLOAT *) &r;
+}
+
+D3DX10INLINE
+D3DXCOLOR::operator CONST FLOAT * () const
+{
+ return (CONST FLOAT *) &r;
+}
+
+// assignment operators
+D3DX10INLINE D3DXCOLOR&
+D3DXCOLOR::operator += ( CONST D3DXCOLOR& c )
+{
+ r += c.r;
+ g += c.g;
+ b += c.b;
+ a += c.a;
+ return *this;
+}
+
+D3DX10INLINE D3DXCOLOR&
+D3DXCOLOR::operator -= ( CONST D3DXCOLOR& c )
+{
+ r -= c.r;
+ g -= c.g;
+ b -= c.b;
+ a -= c.a;
+ return *this;
+}
+
+D3DX10INLINE D3DXCOLOR&
+D3DXCOLOR::operator *= ( FLOAT f )
+{
+ r *= f;
+ g *= f;
+ b *= f;
+ a *= f;
+ return *this;
+}
+
+D3DX10INLINE D3DXCOLOR&
+D3DXCOLOR::operator /= ( FLOAT f )
+{
+ FLOAT fInv = 1.0f / f;
+ r *= fInv;
+ g *= fInv;
+ b *= fInv;
+ a *= fInv;
+ return *this;
+}
+
+
+// unary operators
+D3DX10INLINE D3DXCOLOR
+D3DXCOLOR::operator + () const
+{
+ return *this;
+}
+
+D3DX10INLINE D3DXCOLOR
+D3DXCOLOR::operator - () const
+{
+ return D3DXCOLOR(-r, -g, -b, -a);
+}
+
+
+// binary operators
+D3DX10INLINE D3DXCOLOR
+D3DXCOLOR::operator + ( CONST D3DXCOLOR& c ) const
+{
+ return D3DXCOLOR(r + c.r, g + c.g, b + c.b, a + c.a);
+}
+
+D3DX10INLINE D3DXCOLOR
+D3DXCOLOR::operator - ( CONST D3DXCOLOR& c ) const
+{
+ return D3DXCOLOR(r - c.r, g - c.g, b - c.b, a - c.a);
+}
+
+D3DX10INLINE D3DXCOLOR
+D3DXCOLOR::operator * ( FLOAT f ) const
+{
+ return D3DXCOLOR(r * f, g * f, b * f, a * f);
+}
+
+D3DX10INLINE D3DXCOLOR
+D3DXCOLOR::operator / ( FLOAT f ) const
+{
+ FLOAT fInv = 1.0f / f;
+ return D3DXCOLOR(r * fInv, g * fInv, b * fInv, a * fInv);
+}
+
+
+D3DX10INLINE D3DXCOLOR
+operator * (FLOAT f, CONST D3DXCOLOR& c )
+{
+ return D3DXCOLOR(f * c.r, f * c.g, f * c.b, f * c.a);
+}
+
+
+D3DX10INLINE BOOL
+D3DXCOLOR::operator == ( CONST D3DXCOLOR& c ) const
+{
+ return r == c.r && g == c.g && b == c.b && a == c.a;
+}
+
+D3DX10INLINE BOOL
+D3DXCOLOR::operator != ( CONST D3DXCOLOR& c ) const
+{
+ return r != c.r || g != c.g || b != c.b || a != c.a;
+}
+
+
+#endif //__cplusplus
+
+
+
+//===========================================================================
+//
+// Inline functions
+//
+//===========================================================================
+
+
+//--------------------------
+// 2D Vector
+//--------------------------
+
+D3DX10INLINE FLOAT D3DXVec2Length
+ ( CONST D3DXVECTOR2 *pV )
+{
+#ifdef D3DX10_DEBUG
+ if(!pV)
+ return 0.0f;
+#endif
+
+#ifdef __cplusplus
+ return sqrtf(pV->x * pV->x + pV->y * pV->y);
+#else
+ return (FLOAT) sqrt(pV->x * pV->x + pV->y * pV->y);
+#endif
+}
+
+D3DX10INLINE FLOAT D3DXVec2LengthSq
+ ( CONST D3DXVECTOR2 *pV )
+{
+#ifdef D3DX10_DEBUG
+ if(!pV)
+ return 0.0f;
+#endif
+
+ return pV->x * pV->x + pV->y * pV->y;
+}
+
+D3DX10INLINE FLOAT D3DXVec2Dot
+ ( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pV1 || !pV2)
+ return 0.0f;
+#endif
+
+ return pV1->x * pV2->x + pV1->y * pV2->y;
+}
+
+D3DX10INLINE FLOAT D3DXVec2CCW
+ ( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pV1 || !pV2)
+ return 0.0f;
+#endif
+
+ return pV1->x * pV2->y - pV1->y * pV2->x;
+}
+
+D3DX10INLINE D3DXVECTOR2* D3DXVec2Add
+ ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x + pV2->x;
+ pOut->y = pV1->y + pV2->y;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR2* D3DXVec2Subtract
+ ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x - pV2->x;
+ pOut->y = pV1->y - pV2->y;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR2* D3DXVec2Minimize
+ ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
+ pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR2* D3DXVec2Maximize
+ ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
+ pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR2* D3DXVec2Scale
+ ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, FLOAT s )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV)
+ return NULL;
+#endif
+
+ pOut->x = pV->x * s;
+ pOut->y = pV->y * s;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR2* D3DXVec2Lerp
+ ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2,
+ FLOAT s )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x + s * (pV2->x - pV1->x);
+ pOut->y = pV1->y + s * (pV2->y - pV1->y);
+ return pOut;
+}
+
+
+//--------------------------
+// 3D Vector
+//--------------------------
+
+D3DX10INLINE FLOAT D3DXVec3Length
+ ( CONST D3DXVECTOR3 *pV )
+{
+#ifdef D3DX10_DEBUG
+ if(!pV)
+ return 0.0f;
+#endif
+
+#ifdef __cplusplus
+ return sqrtf(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z);
+#else
+ return (FLOAT) sqrt(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z);
+#endif
+}
+
+D3DX10INLINE FLOAT D3DXVec3LengthSq
+ ( CONST D3DXVECTOR3 *pV )
+{
+#ifdef D3DX10_DEBUG
+ if(!pV)
+ return 0.0f;
+#endif
+
+ return pV->x * pV->x + pV->y * pV->y + pV->z * pV->z;
+}
+
+D3DX10INLINE FLOAT D3DXVec3Dot
+ ( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pV1 || !pV2)
+ return 0.0f;
+#endif
+
+ return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z;
+}
+
+D3DX10INLINE D3DXVECTOR3* D3DXVec3Cross
+ ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+ D3DXVECTOR3 v;
+
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ v.x = pV1->y * pV2->z - pV1->z * pV2->y;
+ v.y = pV1->z * pV2->x - pV1->x * pV2->z;
+ v.z = pV1->x * pV2->y - pV1->y * pV2->x;
+
+ *pOut = v;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR3* D3DXVec3Add
+ ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x + pV2->x;
+ pOut->y = pV1->y + pV2->y;
+ pOut->z = pV1->z + pV2->z;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR3* D3DXVec3Subtract
+ ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x - pV2->x;
+ pOut->y = pV1->y - pV2->y;
+ pOut->z = pV1->z - pV2->z;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR3* D3DXVec3Minimize
+ ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
+ pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
+ pOut->z = pV1->z < pV2->z ? pV1->z : pV2->z;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR3* D3DXVec3Maximize
+ ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
+ pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
+ pOut->z = pV1->z > pV2->z ? pV1->z : pV2->z;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR3* D3DXVec3Scale
+ ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, FLOAT s)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV)
+ return NULL;
+#endif
+
+ pOut->x = pV->x * s;
+ pOut->y = pV->y * s;
+ pOut->z = pV->z * s;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR3* D3DXVec3Lerp
+ ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2,
+ FLOAT s )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x + s * (pV2->x - pV1->x);
+ pOut->y = pV1->y + s * (pV2->y - pV1->y);
+ pOut->z = pV1->z + s * (pV2->z - pV1->z);
+ return pOut;
+}
+
+
+//--------------------------
+// 4D Vector
+//--------------------------
+
+D3DX10INLINE FLOAT D3DXVec4Length
+ ( CONST D3DXVECTOR4 *pV )
+{
+#ifdef D3DX10_DEBUG
+ if(!pV)
+ return 0.0f;
+#endif
+
+#ifdef __cplusplus
+ return sqrtf(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w);
+#else
+ return (FLOAT) sqrt(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w);
+#endif
+}
+
+D3DX10INLINE FLOAT D3DXVec4LengthSq
+ ( CONST D3DXVECTOR4 *pV )
+{
+#ifdef D3DX10_DEBUG
+ if(!pV)
+ return 0.0f;
+#endif
+
+ return pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w;
+}
+
+D3DX10INLINE FLOAT D3DXVec4Dot
+ ( CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pV1 || !pV2)
+ return 0.0f;
+#endif
+
+ return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z + pV1->w * pV2->w;
+}
+
+D3DX10INLINE D3DXVECTOR4* D3DXVec4Add
+ ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x + pV2->x;
+ pOut->y = pV1->y + pV2->y;
+ pOut->z = pV1->z + pV2->z;
+ pOut->w = pV1->w + pV2->w;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR4* D3DXVec4Subtract
+ ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x - pV2->x;
+ pOut->y = pV1->y - pV2->y;
+ pOut->z = pV1->z - pV2->z;
+ pOut->w = pV1->w - pV2->w;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR4* D3DXVec4Minimize
+ ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
+ pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
+ pOut->z = pV1->z < pV2->z ? pV1->z : pV2->z;
+ pOut->w = pV1->w < pV2->w ? pV1->w : pV2->w;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR4* D3DXVec4Maximize
+ ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
+ pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
+ pOut->z = pV1->z > pV2->z ? pV1->z : pV2->z;
+ pOut->w = pV1->w > pV2->w ? pV1->w : pV2->w;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR4* D3DXVec4Scale
+ ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, FLOAT s)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV)
+ return NULL;
+#endif
+
+ pOut->x = pV->x * s;
+ pOut->y = pV->y * s;
+ pOut->z = pV->z * s;
+ pOut->w = pV->w * s;
+ return pOut;
+}
+
+D3DX10INLINE D3DXVECTOR4* D3DXVec4Lerp
+ ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2,
+ FLOAT s )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pV1 || !pV2)
+ return NULL;
+#endif
+
+ pOut->x = pV1->x + s * (pV2->x - pV1->x);
+ pOut->y = pV1->y + s * (pV2->y - pV1->y);
+ pOut->z = pV1->z + s * (pV2->z - pV1->z);
+ pOut->w = pV1->w + s * (pV2->w - pV1->w);
+ return pOut;
+}
+
+
+//--------------------------
+// 4D Matrix
+//--------------------------
+
+D3DX10INLINE D3DXMATRIX* D3DXMatrixIdentity
+ ( D3DXMATRIX *pOut )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut)
+ return NULL;
+#endif
+
+ pOut->m[0][1] = pOut->m[0][2] = pOut->m[0][3] =
+ pOut->m[1][0] = pOut->m[1][2] = pOut->m[1][3] =
+ pOut->m[2][0] = pOut->m[2][1] = pOut->m[2][3] =
+ pOut->m[3][0] = pOut->m[3][1] = pOut->m[3][2] = 0.0f;
+
+ pOut->m[0][0] = pOut->m[1][1] = pOut->m[2][2] = pOut->m[3][3] = 1.0f;
+ return pOut;
+}
+
+
+D3DX10INLINE BOOL D3DXMatrixIsIdentity
+ ( CONST D3DXMATRIX *pM )
+{
+#ifdef D3DX10_DEBUG
+ if(!pM)
+ return FALSE;
+#endif
+
+ return pM->m[0][0] == 1.0f && pM->m[0][1] == 0.0f && pM->m[0][2] == 0.0f && pM->m[0][3] == 0.0f &&
+ pM->m[1][0] == 0.0f && pM->m[1][1] == 1.0f && pM->m[1][2] == 0.0f && pM->m[1][3] == 0.0f &&
+ pM->m[2][0] == 0.0f && pM->m[2][1] == 0.0f && pM->m[2][2] == 1.0f && pM->m[2][3] == 0.0f &&
+ pM->m[3][0] == 0.0f && pM->m[3][1] == 0.0f && pM->m[3][2] == 0.0f && pM->m[3][3] == 1.0f;
+}
+
+
+//--------------------------
+// Quaternion
+//--------------------------
+
+D3DX10INLINE FLOAT D3DXQuaternionLength
+ ( CONST D3DXQUATERNION *pQ )
+{
+#ifdef D3DX10_DEBUG
+ if(!pQ)
+ return 0.0f;
+#endif
+
+#ifdef __cplusplus
+ return sqrtf(pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w);
+#else
+ return (FLOAT) sqrt(pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w);
+#endif
+}
+
+D3DX10INLINE FLOAT D3DXQuaternionLengthSq
+ ( CONST D3DXQUATERNION *pQ )
+{
+#ifdef D3DX10_DEBUG
+ if(!pQ)
+ return 0.0f;
+#endif
+
+ return pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w;
+}
+
+D3DX10INLINE FLOAT D3DXQuaternionDot
+ ( CONST D3DXQUATERNION *pQ1, CONST D3DXQUATERNION *pQ2 )
+{
+#ifdef D3DX10_DEBUG
+ if(!pQ1 || !pQ2)
+ return 0.0f;
+#endif
+
+ return pQ1->x * pQ2->x + pQ1->y * pQ2->y + pQ1->z * pQ2->z + pQ1->w * pQ2->w;
+}
+
+
+D3DX10INLINE D3DXQUATERNION* D3DXQuaternionIdentity
+ ( D3DXQUATERNION *pOut )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut)
+ return NULL;
+#endif
+
+ pOut->x = pOut->y = pOut->z = 0.0f;
+ pOut->w = 1.0f;
+ return pOut;
+}
+
+D3DX10INLINE BOOL D3DXQuaternionIsIdentity
+ ( CONST D3DXQUATERNION *pQ )
+{
+#ifdef D3DX10_DEBUG
+ if(!pQ)
+ return FALSE;
+#endif
+
+ return pQ->x == 0.0f && pQ->y == 0.0f && pQ->z == 0.0f && pQ->w == 1.0f;
+}
+
+
+D3DX10INLINE D3DXQUATERNION* D3DXQuaternionConjugate
+ ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ )
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pQ)
+ return NULL;
+#endif
+
+ pOut->x = -pQ->x;
+ pOut->y = -pQ->y;
+ pOut->z = -pQ->z;
+ pOut->w = pQ->w;
+ return pOut;
+}
+
+
+//--------------------------
+// Plane
+//--------------------------
+
+D3DX10INLINE FLOAT D3DXPlaneDot
+ ( CONST D3DXPLANE *pP, CONST D3DXVECTOR4 *pV)
+{
+#ifdef D3DX10_DEBUG
+ if(!pP || !pV)
+ return 0.0f;
+#endif
+
+ return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z + pP->d * pV->w;
+}
+
+D3DX10INLINE FLOAT D3DXPlaneDotCoord
+ ( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV)
+{
+#ifdef D3DX10_DEBUG
+ if(!pP || !pV)
+ return 0.0f;
+#endif
+
+ return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z + pP->d;
+}
+
+D3DX10INLINE FLOAT D3DXPlaneDotNormal
+ ( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV)
+{
+#ifdef D3DX10_DEBUG
+ if(!pP || !pV)
+ return 0.0f;
+#endif
+
+ return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z;
+}
+
+D3DX10INLINE D3DXPLANE* D3DXPlaneScale
+ (D3DXPLANE *pOut, CONST D3DXPLANE *pP, FLOAT s)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pP)
+ return NULL;
+#endif
+
+ pOut->a = pP->a * s;
+ pOut->b = pP->b * s;
+ pOut->c = pP->c * s;
+ pOut->d = pP->d * s;
+ return pOut;
+}
+
+
+//--------------------------
+// Color
+//--------------------------
+
+D3DX10INLINE D3DXCOLOR* D3DXColorNegative
+ (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pC)
+ return NULL;
+#endif
+
+ pOut->r = 1.0f - pC->r;
+ pOut->g = 1.0f - pC->g;
+ pOut->b = 1.0f - pC->b;
+ pOut->a = pC->a;
+ return pOut;
+}
+
+D3DX10INLINE D3DXCOLOR* D3DXColorAdd
+ (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pC1 || !pC2)
+ return NULL;
+#endif
+
+ pOut->r = pC1->r + pC2->r;
+ pOut->g = pC1->g + pC2->g;
+ pOut->b = pC1->b + pC2->b;
+ pOut->a = pC1->a + pC2->a;
+ return pOut;
+}
+
+D3DX10INLINE D3DXCOLOR* D3DXColorSubtract
+ (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pC1 || !pC2)
+ return NULL;
+#endif
+
+ pOut->r = pC1->r - pC2->r;
+ pOut->g = pC1->g - pC2->g;
+ pOut->b = pC1->b - pC2->b;
+ pOut->a = pC1->a - pC2->a;
+ return pOut;
+}
+
+D3DX10INLINE D3DXCOLOR* D3DXColorScale
+ (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT s)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pC)
+ return NULL;
+#endif
+
+ pOut->r = pC->r * s;
+ pOut->g = pC->g * s;
+ pOut->b = pC->b * s;
+ pOut->a = pC->a * s;
+ return pOut;
+}
+
+D3DX10INLINE D3DXCOLOR* D3DXColorModulate
+ (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pC1 || !pC2)
+ return NULL;
+#endif
+
+ pOut->r = pC1->r * pC2->r;
+ pOut->g = pC1->g * pC2->g;
+ pOut->b = pC1->b * pC2->b;
+ pOut->a = pC1->a * pC2->a;
+ return pOut;
+}
+
+D3DX10INLINE D3DXCOLOR* D3DXColorLerp
+ (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2, FLOAT s)
+{
+#ifdef D3DX10_DEBUG
+ if(!pOut || !pC1 || !pC2)
+ return NULL;
+#endif
+
+ pOut->r = pC1->r + s * (pC2->r - pC1->r);
+ pOut->g = pC1->g + s * (pC2->g - pC1->g);
+ pOut->b = pC1->b + s * (pC2->b - pC1->b);
+ pOut->a = pC1->a + s * (pC2->a - pC1->a);
+ return pOut;
+}
+
+
+#endif // __D3DXMATH_INL__
+
diff --git a/external/D3D11/include/D3DX10mesh.h b/external/D3D11/include/D3DX10mesh.h
new file mode 100644
index 0000000..e5fed8f
--- /dev/null
+++ b/external/D3D11/include/D3DX10mesh.h
@@ -0,0 +1,286 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) Microsoft Corporation. All Rights Reserved.
+//
+// File: d3dx10mesh.h
+// Content: D3DX10 mesh types and functions
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include "d3dx10.h"
+
+#ifndef __D3DX10MESH_H__
+#define __D3DX10MESH_H__
+
+// {7ED943DD-52E8-40b5-A8D8-76685C406330}
+DEFINE_GUID(IID_ID3DX10BaseMesh,
+0x7ed943dd, 0x52e8, 0x40b5, 0xa8, 0xd8, 0x76, 0x68, 0x5c, 0x40, 0x63, 0x30);
+
+// {04B0D117-1041-46b1-AA8A-3952848BA22E}
+DEFINE_GUID(IID_ID3DX10MeshBuffer,
+0x4b0d117, 0x1041, 0x46b1, 0xaa, 0x8a, 0x39, 0x52, 0x84, 0x8b, 0xa2, 0x2e);
+
+// {4020E5C2-1403-4929-883F-E2E849FAC195}
+DEFINE_GUID(IID_ID3DX10Mesh,
+0x4020e5c2, 0x1403, 0x4929, 0x88, 0x3f, 0xe2, 0xe8, 0x49, 0xfa, 0xc1, 0x95);
+
+// {8875769A-D579-4088-AAEB-534D1AD84E96}
+DEFINE_GUID(IID_ID3DX10PMesh,
+0x8875769a, 0xd579, 0x4088, 0xaa, 0xeb, 0x53, 0x4d, 0x1a, 0xd8, 0x4e, 0x96);
+
+// {667EA4C7-F1CD-4386-B523-7C0290B83CC5}
+DEFINE_GUID(IID_ID3DX10SPMesh,
+0x667ea4c7, 0xf1cd, 0x4386, 0xb5, 0x23, 0x7c, 0x2, 0x90, 0xb8, 0x3c, 0xc5);
+
+// {3CE6CC22-DBF2-44f4-894D-F9C34A337139}
+DEFINE_GUID(IID_ID3DX10PatchMesh,
+0x3ce6cc22, 0xdbf2, 0x44f4, 0x89, 0x4d, 0xf9, 0xc3, 0x4a, 0x33, 0x71, 0x39);
+
+
+// Mesh options - lower 3 bytes only, upper byte used by _D3DX10MESHOPT option flags
+enum _D3DX10_MESH {
+ D3DX10_MESH_32_BIT = 0x001, // If set, then use 32 bit indices, if not set use 16 bit indices.
+ D3DX10_MESH_GS_ADJACENCY = 0x004, // If set, mesh contains GS adjacency info. Not valid on input.
+
+};
+
+typedef struct _D3DX10_ATTRIBUTE_RANGE
+{
+ UINT AttribId;
+ UINT FaceStart;
+ UINT FaceCount;
+ UINT VertexStart;
+ UINT VertexCount;
+} D3DX10_ATTRIBUTE_RANGE;
+
+typedef D3DX10_ATTRIBUTE_RANGE* LPD3DX10_ATTRIBUTE_RANGE;
+
+typedef enum _D3DX10_MESH_DISCARD_FLAGS
+{
+ D3DX10_MESH_DISCARD_ATTRIBUTE_BUFFER = 0x01,
+ D3DX10_MESH_DISCARD_ATTRIBUTE_TABLE = 0x02,
+ D3DX10_MESH_DISCARD_POINTREPS = 0x04,
+ D3DX10_MESH_DISCARD_ADJACENCY = 0x08,
+ D3DX10_MESH_DISCARD_DEVICE_BUFFERS = 0x10,
+
+} D3DX10_MESH_DISCARD_FLAGS;
+
+typedef struct _D3DX10_WELD_EPSILONS
+{
+ FLOAT Position; // NOTE: This does NOT replace the epsilon in GenerateAdjacency
+ // in general, it should be the same value or greater than the one passed to GeneratedAdjacency
+ FLOAT BlendWeights;
+ FLOAT Normal;
+ FLOAT PSize;
+ FLOAT Specular;
+ FLOAT Diffuse;
+ FLOAT Texcoord[8];
+ FLOAT Tangent;
+ FLOAT Binormal;
+ FLOAT TessFactor;
+} D3DX10_WELD_EPSILONS;
+
+typedef D3DX10_WELD_EPSILONS* LPD3DX10_WELD_EPSILONS;
+
+typedef struct _D3DX10_INTERSECT_INFO
+{
+ UINT FaceIndex; // index of face intersected
+ FLOAT U; // Barycentric Hit Coordinates
+ FLOAT V; // Barycentric Hit Coordinates
+ FLOAT Dist; // Ray-Intersection Parameter Distance
+} D3DX10_INTERSECT_INFO, *LPD3DX10_INTERSECT_INFO;
+
+// ID3DX10MeshBuffer is used by D3DX10Mesh vertex and index buffers
+#undef INTERFACE
+#define INTERFACE ID3DX10MeshBuffer
+
+DECLARE_INTERFACE_(ID3DX10MeshBuffer, IUnknown)
+{
+ // IUnknown
+ STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
+ STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+ // ID3DX10MeshBuffer
+ STDMETHOD(Map)(THIS_ void **ppData, SIZE_T *pSize) PURE;
+ STDMETHOD(Unmap)(THIS) PURE;
+ STDMETHOD_(SIZE_T, GetSize)(THIS) PURE;
+};
+
+// D3DX10 Mesh interfaces
+#undef INTERFACE
+#define INTERFACE ID3DX10Mesh
+
+DECLARE_INTERFACE_(ID3DX10Mesh, IUnknown)
+{
+ // IUnknown
+ STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
+ STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+ // ID3DX10Mesh
+ STDMETHOD_(UINT, GetFaceCount)(THIS) PURE;
+ STDMETHOD_(UINT, GetVertexCount)(THIS) PURE;
+ STDMETHOD_(UINT, GetVertexBufferCount)(THIS) PURE;
+ STDMETHOD_(UINT, GetFlags)(THIS) PURE;
+ STDMETHOD(GetVertexDescription)(THIS_ CONST D3D10_INPUT_ELEMENT_DESC **ppDesc, UINT *pDeclCount) PURE;
+
+ STDMETHOD(SetVertexData)(THIS_ UINT iBuffer, CONST void *pData) PURE;
+ STDMETHOD(GetVertexBuffer)(THIS_ UINT iBuffer, ID3DX10MeshBuffer **ppVertexBuffer) PURE;
+
+ STDMETHOD(SetIndexData)(THIS_ CONST void *pData, UINT cIndices) PURE;
+ STDMETHOD(GetIndexBuffer)(THIS_ ID3DX10MeshBuffer **ppIndexBuffer) PURE;
+
+ STDMETHOD(SetAttributeData)(THIS_ CONST UINT *pData) PURE;
+ STDMETHOD(GetAttributeBuffer)(THIS_ ID3DX10MeshBuffer **ppAttributeBuffer) PURE;
+
+ STDMETHOD(SetAttributeTable)(THIS_ CONST D3DX10_ATTRIBUTE_RANGE *pAttribTable, UINT cAttribTableSize) PURE;
+ STDMETHOD(GetAttributeTable)(THIS_ D3DX10_ATTRIBUTE_RANGE *pAttribTable, UINT *pAttribTableSize) PURE;
+
+ STDMETHOD(GenerateAdjacencyAndPointReps)(THIS_ FLOAT Epsilon) PURE;
+ STDMETHOD(GenerateGSAdjacency)(THIS) PURE;
+
+ STDMETHOD(SetAdjacencyData)(THIS_ CONST UINT *pAdjacency) PURE;
+ STDMETHOD(GetAdjacencyBuffer)(THIS_ ID3DX10MeshBuffer **ppAdjacency) PURE;
+
+ STDMETHOD(SetPointRepData)(THIS_ CONST UINT *pPointReps) PURE;
+ STDMETHOD(GetPointRepBuffer)(THIS_ ID3DX10MeshBuffer **ppPointReps) PURE;
+
+ STDMETHOD(Discard)(THIS_ D3DX10_MESH_DISCARD_FLAGS dwDiscard) PURE;
+ STDMETHOD(CloneMesh)(THIS_ UINT Flags, LPCSTR pPosSemantic, CONST D3D10_INPUT_ELEMENT_DESC *pDesc, UINT DeclCount, ID3DX10Mesh** ppCloneMesh) PURE;
+
+ STDMETHOD(Optimize)(THIS_ UINT Flags, UINT * pFaceRemap, LPD3D10BLOB *ppVertexRemap) PURE;
+ STDMETHOD(GenerateAttributeBufferFromTable)(THIS) PURE;
+
+ STDMETHOD(Intersect)(THIS_ D3DXVECTOR3 *pRayPos, D3DXVECTOR3 *pRayDir,
+ UINT *pHitCount, UINT *pFaceIndex, float *pU, float *pV, float *pDist, ID3D10Blob **ppAllHits);
+ STDMETHOD(IntersectSubset)(THIS_ UINT AttribId, D3DXVECTOR3 *pRayPos, D3DXVECTOR3 *pRayDir,
+ UINT *pHitCount, UINT *pFaceIndex, float *pU, float *pV, float *pDist, ID3D10Blob **ppAllHits);
+
+ // ID3DX10Mesh - Device functions
+ STDMETHOD(CommitToDevice)(THIS) PURE;
+ STDMETHOD(DrawSubset)(THIS_ UINT AttribId) PURE;
+ STDMETHOD(DrawSubsetInstanced)(THIS_ UINT AttribId, UINT InstanceCount, UINT StartInstanceLocation) PURE;
+
+ STDMETHOD(GetDeviceVertexBuffer)(THIS_ UINT iBuffer, ID3D10Buffer **ppVertexBuffer) PURE;
+ STDMETHOD(GetDeviceIndexBuffer)(THIS_ ID3D10Buffer **ppIndexBuffer) PURE;
+};
+
+
+// Flat API
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+HRESULT WINAPI
+ D3DX10CreateMesh(
+ ID3D10Device *pDevice,
+ CONST D3D10_INPUT_ELEMENT_DESC *pDeclaration,
+ UINT DeclCount,
+ LPCSTR pPositionSemantic,
+ UINT VertexCount,
+ UINT FaceCount,
+ UINT Options,
+ ID3DX10Mesh **ppMesh);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+
+// ID3DX10Mesh::Optimize options - upper byte only, lower 3 bytes used from _D3DX10MESH option flags
+enum _D3DX10_MESHOPT {
+ D3DX10_MESHOPT_COMPACT = 0x01000000,
+ D3DX10_MESHOPT_ATTR_SORT = 0x02000000,
+ D3DX10_MESHOPT_VERTEX_CACHE = 0x04000000,
+ D3DX10_MESHOPT_STRIP_REORDER = 0x08000000,
+ D3DX10_MESHOPT_IGNORE_VERTS = 0x10000000, // optimize faces only, don't touch vertices
+ D3DX10_MESHOPT_DO_NOT_SPLIT = 0x20000000, // do not split vertices shared between attribute groups when attribute sorting
+ D3DX10_MESHOPT_DEVICE_INDEPENDENT = 0x00400000, // Only affects VCache. uses a static known good cache size for all cards
+
+ // D3DX10_MESHOPT_SHAREVB has been removed, please use D3DX10MESH_VB_SHARE instead
+
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+// ID3DXSkinInfo
+//////////////////////////////////////////////////////////////////////////
+
+// {420BD604-1C76-4a34-A466-E45D0658A32C}
+DEFINE_GUID(IID_ID3DX10SkinInfo,
+0x420bd604, 0x1c76, 0x4a34, 0xa4, 0x66, 0xe4, 0x5d, 0x6, 0x58, 0xa3, 0x2c);
+
+// scaling modes for ID3DX10SkinInfo::Compact() & ID3DX10SkinInfo::UpdateMesh()
+#define D3DX10_SKININFO_NO_SCALING 0
+#define D3DX10_SKININFO_SCALE_TO_1 1
+#define D3DX10_SKININFO_SCALE_TO_TOTAL 2
+
+typedef struct _D3DX10_SKINNING_CHANNEL
+{
+ UINT SrcOffset;
+ UINT DestOffset;
+ BOOL IsNormal;
+} D3DX10_SKINNING_CHANNEL;
+
+#undef INTERFACE
+#define INTERFACE ID3DX10SkinInfo
+
+typedef struct ID3DX10SkinInfo *LPD3DX10SKININFO;
+
+DECLARE_INTERFACE_(ID3DX10SkinInfo, IUnknown)
+{
+ // IUnknown
+ STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
+ STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+ STDMETHOD_(UINT , GetNumVertices)(THIS) PURE;
+ STDMETHOD_(UINT , GetNumBones)(THIS) PURE;
+ STDMETHOD_(UINT , GetMaxBoneInfluences)(THIS) PURE;
+
+ STDMETHOD(AddVertices)(THIS_ UINT Count) PURE;
+ STDMETHOD(RemapVertices)(THIS_ UINT NewVertexCount, UINT *pVertexRemap) PURE;
+
+ STDMETHOD(AddBones)(THIS_ UINT Count) PURE;
+ STDMETHOD(RemoveBone)(THIS_ UINT Index) PURE;
+ STDMETHOD(RemapBones)(THIS_ UINT NewBoneCount, UINT *pBoneRemap) PURE;
+
+ STDMETHOD(AddBoneInfluences)(THIS_ UINT BoneIndex, UINT InfluenceCount, UINT *pIndices, float *pWeights) PURE;
+ STDMETHOD(ClearBoneInfluences)(THIS_ UINT BoneIndex) PURE;
+ STDMETHOD_(UINT , GetBoneInfluenceCount)(THIS_ UINT BoneIndex) PURE;
+ STDMETHOD(GetBoneInfluences)(THIS_ UINT BoneIndex, UINT Offset, UINT Count, UINT *pDestIndices, float *pDestWeights) PURE;
+ STDMETHOD(FindBoneInfluenceIndex)(THIS_ UINT BoneIndex, UINT VertexIndex, UINT *pInfluenceIndex) PURE;
+ STDMETHOD(SetBoneInfluence)(THIS_ UINT BoneIndex, UINT InfluenceIndex, float Weight) PURE;
+ STDMETHOD(GetBoneInfluence)(THIS_ UINT BoneIndex, UINT InfluenceIndex, float *pWeight) PURE;
+
+ STDMETHOD(Compact)(THIS_ UINT MaxPerVertexInfluences, UINT ScaleMode, float MinWeight) PURE;
+ STDMETHOD(DoSoftwareSkinning)(UINT StartVertex, UINT VertexCount, void *pSrcVertices, UINT SrcStride, void *pDestVertices, UINT DestStride, D3DXMATRIX *pBoneMatrices, D3DXMATRIX *pInverseTransposeBoneMatrices, D3DX10_SKINNING_CHANNEL *pChannelDescs, UINT NumChannels) PURE;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+HRESULT WINAPI
+ D3DX10CreateSkinInfo(LPD3DX10SKININFO* ppSkinInfo);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+typedef struct _D3DX10_ATTRIBUTE_WEIGHTS
+{
+ FLOAT Position;
+ FLOAT Boundary;
+ FLOAT Normal;
+ FLOAT Diffuse;
+ FLOAT Specular;
+ FLOAT Texcoord[8];
+ FLOAT Tangent;
+ FLOAT Binormal;
+} D3DX10_ATTRIBUTE_WEIGHTS, *LPD3DX10_ATTRIBUTE_WEIGHTS;
+
+#endif //__D3DX10MESH_H__
+
+
diff --git a/external/D3D11/include/D3DX10tex.h b/external/D3D11/include/D3DX10tex.h
new file mode 100644
index 0000000..a6d8bb9
--- /dev/null
+++ b/external/D3D11/include/D3DX10tex.h
@@ -0,0 +1,766 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) Microsoft Corporation. All Rights Reserved.
+//
+// File: d3dx10tex.h
+// Content: D3DX10 texturing APIs
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include "d3dx10.h"
+
+#ifndef __D3DX10TEX_H__
+#define __D3DX10TEX_H__
+
+
+//----------------------------------------------------------------------------
+// D3DX10_FILTER flags:
+// ------------------
+//
+// A valid filter must contain one of these values:
+//
+// D3DX10_FILTER_NONE
+// No scaling or filtering will take place. Pixels outside the bounds
+// of the source image are assumed to be transparent black.
+// D3DX10_FILTER_POINT
+// Each destination pixel is computed by sampling the nearest pixel
+// from the source image.
+// D3DX10_FILTER_LINEAR
+// Each destination pixel is computed by linearly interpolating between
+// the nearest pixels in the source image. This filter works best
+// when the scale on each axis is less than 2.
+// D3DX10_FILTER_TRIANGLE
+// Every pixel in the source image contributes equally to the
+// destination image. This is the slowest of all the filters.
+// D3DX10_FILTER_BOX
+// Each pixel is computed by averaging a 2x2(x2) box pixels from
+// the source image. Only works when the dimensions of the
+// destination are half those of the source. (as with mip maps)
+//
+// And can be OR'd with any of these optional flags:
+//
+// D3DX10_FILTER_MIRROR_U
+// Indicates that pixels off the edge of the texture on the U-axis
+// should be mirrored, not wraped.
+// D3DX10_FILTER_MIRROR_V
+// Indicates that pixels off the edge of the texture on the V-axis
+// should be mirrored, not wraped.
+// D3DX10_FILTER_MIRROR_W
+// Indicates that pixels off the edge of the texture on the W-axis
+// should be mirrored, not wraped.
+// D3DX10_FILTER_MIRROR
+// Same as specifying D3DX10_FILTER_MIRROR_U | D3DX10_FILTER_MIRROR_V |
+// D3DX10_FILTER_MIRROR_V
+// D3DX10_FILTER_DITHER
+// Dithers the resulting image using a 4x4 order dither pattern.
+// D3DX10_FILTER_SRGB_IN
+// Denotes that the input data is in sRGB (gamma 2.2) colorspace.
+// D3DX10_FILTER_SRGB_OUT
+// Denotes that the output data is in sRGB (gamma 2.2) colorspace.
+// D3DX10_FILTER_SRGB
+// Same as specifying D3DX10_FILTER_SRGB_IN | D3DX10_FILTER_SRGB_OUT
+//
+//----------------------------------------------------------------------------
+
+typedef enum D3DX10_FILTER_FLAG
+{
+ D3DX10_FILTER_NONE = (1 << 0),
+ D3DX10_FILTER_POINT = (2 << 0),
+ D3DX10_FILTER_LINEAR = (3 << 0),
+ D3DX10_FILTER_TRIANGLE = (4 << 0),
+ D3DX10_FILTER_BOX = (5 << 0),
+
+ D3DX10_FILTER_MIRROR_U = (1 << 16),
+ D3DX10_FILTER_MIRROR_V = (2 << 16),
+ D3DX10_FILTER_MIRROR_W = (4 << 16),
+ D3DX10_FILTER_MIRROR = (7 << 16),
+
+ D3DX10_FILTER_DITHER = (1 << 19),
+ D3DX10_FILTER_DITHER_DIFFUSION= (2 << 19),
+
+ D3DX10_FILTER_SRGB_IN = (1 << 21),
+ D3DX10_FILTER_SRGB_OUT = (2 << 21),
+ D3DX10_FILTER_SRGB = (3 << 21),
+} D3DX10_FILTER_FLAG;
+
+//----------------------------------------------------------------------------
+// D3DX10_NORMALMAP flags:
+// ---------------------
+// These flags are used to control how D3DX10ComputeNormalMap generates normal
+// maps. Any number of these flags may be OR'd together in any combination.
+//
+// D3DX10_NORMALMAP_MIRROR_U
+// Indicates that pixels off the edge of the texture on the U-axis
+// should be mirrored, not wraped.
+// D3DX10_NORMALMAP_MIRROR_V
+// Indicates that pixels off the edge of the texture on the V-axis
+// should be mirrored, not wraped.
+// D3DX10_NORMALMAP_MIRROR
+// Same as specifying D3DX10_NORMALMAP_MIRROR_U | D3DX10_NORMALMAP_MIRROR_V
+// D3DX10_NORMALMAP_INVERTSIGN
+// Inverts the direction of each normal
+// D3DX10_NORMALMAP_COMPUTE_OCCLUSION
+// Compute the per pixel Occlusion term and encodes it into the alpha.
+// An Alpha of 1 means that the pixel is not obscured in anyway, and
+// an alpha of 0 would mean that the pixel is completly obscured.
+//
+//----------------------------------------------------------------------------
+
+typedef enum D3DX10_NORMALMAP_FLAG
+{
+ D3DX10_NORMALMAP_MIRROR_U = (1 << 16),
+ D3DX10_NORMALMAP_MIRROR_V = (2 << 16),
+ D3DX10_NORMALMAP_MIRROR = (3 << 16),
+ D3DX10_NORMALMAP_INVERTSIGN = (8 << 16),
+ D3DX10_NORMALMAP_COMPUTE_OCCLUSION = (16 << 16),
+} D3DX10_NORMALMAP_FLAG;
+
+//----------------------------------------------------------------------------
+// D3DX10_CHANNEL flags:
+// -------------------
+// These flags are used by functions which operate on or more channels
+// in a texture.
+//
+// D3DX10_CHANNEL_RED
+// Indicates the red channel should be used
+// D3DX10_CHANNEL_BLUE
+// Indicates the blue channel should be used
+// D3DX10_CHANNEL_GREEN
+// Indicates the green channel should be used
+// D3DX10_CHANNEL_ALPHA
+// Indicates the alpha channel should be used
+// D3DX10_CHANNEL_LUMINANCE
+// Indicates the luminaces of the red green and blue channels should be
+// used.
+//
+//----------------------------------------------------------------------------
+
+typedef enum D3DX10_CHANNEL_FLAG
+{
+ D3DX10_CHANNEL_RED = (1 << 0),
+ D3DX10_CHANNEL_BLUE = (1 << 1),
+ D3DX10_CHANNEL_GREEN = (1 << 2),
+ D3DX10_CHANNEL_ALPHA = (1 << 3),
+ D3DX10_CHANNEL_LUMINANCE = (1 << 4),
+} D3DX10_CHANNEL_FLAG;
+
+
+
+//----------------------------------------------------------------------------
+// D3DX10_IMAGE_FILE_FORMAT:
+// ---------------------
+// This enum is used to describe supported image file formats.
+//
+//----------------------------------------------------------------------------
+
+typedef enum D3DX10_IMAGE_FILE_FORMAT
+{
+ D3DX10_IFF_BMP = 0,
+ D3DX10_IFF_JPG = 1,
+ D3DX10_IFF_PNG = 3,
+ D3DX10_IFF_DDS = 4,
+ D3DX10_IFF_TIFF = 10,
+ D3DX10_IFF_GIF = 11,
+ D3DX10_IFF_WMP = 12,
+ D3DX10_IFF_FORCE_DWORD = 0x7fffffff
+
+} D3DX10_IMAGE_FILE_FORMAT;
+
+
+//----------------------------------------------------------------------------
+// D3DX10_SAVE_TEXTURE_FLAG:
+// ---------------------
+// This enum is used to support texture saving options.
+//
+//----------------------------------------------------------------------------
+
+typedef enum D3DX10_SAVE_TEXTURE_FLAG
+{
+ D3DX10_STF_USEINPUTBLOB = 0x0001,
+} D3DX10_SAVE_TEXTURE_FLAG;
+
+
+
+//----------------------------------------------------------------------------
+// D3DX10_IMAGE_INFO:
+// ---------------
+// This structure is used to return a rough description of what the
+// the original contents of an image file looked like.
+//
+// Width
+// Width of original image in pixels
+// Height
+// Height of original image in pixels
+// Depth
+// Depth of original image in pixels
+// ArraySize
+// Array size in textures
+// MipLevels
+// Number of mip levels in original image
+// MiscFlags
+// Miscellaneous flags
+// Format
+// D3D format which most closely describes the data in original image
+// ResourceDimension
+// D3D10_RESOURCE_DIMENSION representing the dimension of texture stored in the file.
+// D3D10_RESOURCE_DIMENSION_TEXTURE1D, 2D, 3D
+// ImageFileFormat
+// D3DX10_IMAGE_FILE_FORMAT representing the format of the image file.
+//----------------------------------------------------------------------------
+
+typedef struct D3DX10_IMAGE_INFO
+{
+ UINT Width;
+ UINT Height;
+ UINT Depth;
+ UINT ArraySize;
+ UINT MipLevels;
+ UINT MiscFlags;
+ DXGI_FORMAT Format;
+ D3D10_RESOURCE_DIMENSION ResourceDimension;
+ D3DX10_IMAGE_FILE_FORMAT ImageFileFormat;
+} D3DX10_IMAGE_INFO;
+
+
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Image File APIs ///////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX10_IMAGE_LOAD_INFO:
+// ---------------
+// This structure can be optionally passed in to texture loader APIs to
+// control how textures get loaded. Pass in D3DX10_DEFAULT for any of these
+// to have D3DX automatically pick defaults based on the source file.
+//
+// Width
+// Rescale texture to Width texels wide
+// Height
+// Rescale texture to Height texels high
+// Depth
+// Rescale texture to Depth texels deep
+// FirstMipLevel
+// First mip level to load
+// MipLevels
+// Number of mip levels to load after the first level
+// Usage
+// D3D10_USAGE flag for the new texture
+// BindFlags
+// D3D10 Bind flags for the new texture
+// CpuAccessFlags
+// D3D10 CPU Access flags for the new texture
+// MiscFlags
+// Reserved. Must be 0
+// Format
+// Resample texture to the specified format
+// Filter
+// Filter the texture using the specified filter (only when resampling)
+// MipFilter
+// Filter the texture mip levels using the specified filter (only if
+// generating mips)
+// pSrcInfo
+// (optional) pointer to a D3DX10_IMAGE_INFO structure that will get
+// populated with source image information
+//----------------------------------------------------------------------------
+
+
+typedef struct D3DX10_IMAGE_LOAD_INFO
+{
+ UINT Width;
+ UINT Height;
+ UINT Depth;
+ UINT FirstMipLevel;
+ UINT MipLevels;
+ D3D10_USAGE Usage;
+ UINT BindFlags;
+ UINT CpuAccessFlags;
+ UINT MiscFlags;
+ DXGI_FORMAT Format;
+ UINT Filter;
+ UINT MipFilter;
+ D3DX10_IMAGE_INFO* pSrcInfo;
+
+#ifdef __cplusplus
+ D3DX10_IMAGE_LOAD_INFO()
+ {
+ Width = D3DX10_DEFAULT;
+ Height = D3DX10_DEFAULT;
+ Depth = D3DX10_DEFAULT;
+ FirstMipLevel = D3DX10_DEFAULT;
+ MipLevels = D3DX10_DEFAULT;
+ Usage = (D3D10_USAGE) D3DX10_DEFAULT;
+ BindFlags = D3DX10_DEFAULT;
+ CpuAccessFlags = D3DX10_DEFAULT;
+ MiscFlags = D3DX10_DEFAULT;
+ Format = DXGI_FORMAT_FROM_FILE;
+ Filter = D3DX10_DEFAULT;
+ MipFilter = D3DX10_DEFAULT;
+ pSrcInfo = NULL;
+ }
+#endif
+
+} D3DX10_IMAGE_LOAD_INFO;
+
+//-------------------------------------------------------------------------------
+// GetImageInfoFromFile/Resource/Memory:
+// ------------------------------
+// Fills in a D3DX10_IMAGE_INFO struct with information about an image file.
+//
+// Parameters:
+// pSrcFile
+// File name of the source image.
+// pSrcModule
+// Module where resource is located, or NULL for module associated
+// with image the os used to create the current process.
+// pSrcResource
+// Resource name.
+// pSrcData
+// Pointer to file in memory.
+// SrcDataSize
+// Size in bytes of file in memory.
+// pPump
+// Optional pointer to a thread pump object to use.
+// pSrcInfo
+// Pointer to a D3DX10_IMAGE_INFO structure to be filled in with the
+// description of the data in the source image file.
+// pHResult
+// Pointer to a memory location to receive the return value upon completion.
+// Maybe NULL if not needed.
+// If pPump != NULL, pHResult must be a valid memory location until the
+// the asynchronous execution completes.
+//-------------------------------------------------------------------------------
+
+HRESULT WINAPI
+ D3DX10GetImageInfoFromFileA(
+ LPCSTR pSrcFile,
+ ID3DX10ThreadPump* pPump,
+ D3DX10_IMAGE_INFO* pSrcInfo,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX10GetImageInfoFromFileW(
+ LPCWSTR pSrcFile,
+ ID3DX10ThreadPump* pPump,
+ D3DX10_IMAGE_INFO* pSrcInfo,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX10GetImageInfoFromFile D3DX10GetImageInfoFromFileW
+#else
+#define D3DX10GetImageInfoFromFile D3DX10GetImageInfoFromFileA
+#endif
+
+
+HRESULT WINAPI
+ D3DX10GetImageInfoFromResourceA(
+ HMODULE hSrcModule,
+ LPCSTR pSrcResource,
+ ID3DX10ThreadPump* pPump,
+ D3DX10_IMAGE_INFO* pSrcInfo,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX10GetImageInfoFromResourceW(
+ HMODULE hSrcModule,
+ LPCWSTR pSrcResource,
+ ID3DX10ThreadPump* pPump,
+ D3DX10_IMAGE_INFO* pSrcInfo,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX10GetImageInfoFromResource D3DX10GetImageInfoFromResourceW
+#else
+#define D3DX10GetImageInfoFromResource D3DX10GetImageInfoFromResourceA
+#endif
+
+
+HRESULT WINAPI
+ D3DX10GetImageInfoFromMemory(
+ LPCVOID pSrcData,
+ SIZE_T SrcDataSize,
+ ID3DX10ThreadPump* pPump,
+ D3DX10_IMAGE_INFO* pSrcInfo,
+ HRESULT* pHResult);
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Create/Save Texture APIs //////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX10CreateTextureFromFile/Resource/Memory:
+// D3DX10CreateShaderResourceViewFromFile/Resource/Memory:
+// -----------------------------------
+// Create a texture object from a file or resource.
+//
+// Parameters:
+//
+// pDevice
+// The D3D device with which the texture is going to be used.
+// pSrcFile
+// File name.
+// hSrcModule
+// Module handle. if NULL, current module will be used.
+// pSrcResource
+// Resource name in module
+// pvSrcData
+// Pointer to file in memory.
+// SrcDataSize
+// Size in bytes of file in memory.
+// pLoadInfo
+// Optional pointer to a D3DX10_IMAGE_LOAD_INFO structure that
+// contains additional loader parameters.
+// pPump
+// Optional pointer to a thread pump object to use.
+// ppTexture
+// [out] Created texture object.
+// ppShaderResourceView
+// [out] Shader resource view object created.
+// pHResult
+// Pointer to a memory location to receive the return value upon completion.
+// Maybe NULL if not needed.
+// If pPump != NULL, pHResult must be a valid memory location until the
+// the asynchronous execution completes.
+//
+//----------------------------------------------------------------------------
+
+
+// FromFile
+
+HRESULT WINAPI
+ D3DX10CreateShaderResourceViewFromFileA(
+ ID3D10Device* pDevice,
+ LPCSTR pSrcFile,
+ D3DX10_IMAGE_LOAD_INFO *pLoadInfo,
+ ID3DX10ThreadPump* pPump,
+ ID3D10ShaderResourceView** ppShaderResourceView,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX10CreateShaderResourceViewFromFileW(
+ ID3D10Device* pDevice,
+ LPCWSTR pSrcFile,
+ D3DX10_IMAGE_LOAD_INFO *pLoadInfo,
+ ID3DX10ThreadPump* pPump,
+ ID3D10ShaderResourceView** ppShaderResourceView,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX10CreateShaderResourceViewFromFile D3DX10CreateShaderResourceViewFromFileW
+#else
+#define D3DX10CreateShaderResourceViewFromFile D3DX10CreateShaderResourceViewFromFileA
+#endif
+
+HRESULT WINAPI
+ D3DX10CreateTextureFromFileA(
+ ID3D10Device* pDevice,
+ LPCSTR pSrcFile,
+ D3DX10_IMAGE_LOAD_INFO *pLoadInfo,
+ ID3DX10ThreadPump* pPump,
+ ID3D10Resource** ppTexture,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX10CreateTextureFromFileW(
+ ID3D10Device* pDevice,
+ LPCWSTR pSrcFile,
+ D3DX10_IMAGE_LOAD_INFO *pLoadInfo,
+ ID3DX10ThreadPump* pPump,
+ ID3D10Resource** ppTexture,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX10CreateTextureFromFile D3DX10CreateTextureFromFileW
+#else
+#define D3DX10CreateTextureFromFile D3DX10CreateTextureFromFileA
+#endif
+
+
+// FromResource (resources in dll/exes)
+
+HRESULT WINAPI
+ D3DX10CreateShaderResourceViewFromResourceA(
+ ID3D10Device* pDevice,
+ HMODULE hSrcModule,
+ LPCSTR pSrcResource,
+ D3DX10_IMAGE_LOAD_INFO* pLoadInfo,
+ ID3DX10ThreadPump* pPump,
+ ID3D10ShaderResourceView** ppShaderResourceView,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX10CreateShaderResourceViewFromResourceW(
+ ID3D10Device* pDevice,
+ HMODULE hSrcModule,
+ LPCWSTR pSrcResource,
+ D3DX10_IMAGE_LOAD_INFO* pLoadInfo,
+ ID3DX10ThreadPump* pPump,
+ ID3D10ShaderResourceView** ppShaderResourceView,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX10CreateShaderResourceViewFromResource D3DX10CreateShaderResourceViewFromResourceW
+#else
+#define D3DX10CreateShaderResourceViewFromResource D3DX10CreateShaderResourceViewFromResourceA
+#endif
+
+HRESULT WINAPI
+ D3DX10CreateTextureFromResourceA(
+ ID3D10Device* pDevice,
+ HMODULE hSrcModule,
+ LPCSTR pSrcResource,
+ D3DX10_IMAGE_LOAD_INFO *pLoadInfo,
+ ID3DX10ThreadPump* pPump,
+ ID3D10Resource** ppTexture,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX10CreateTextureFromResourceW(
+ ID3D10Device* pDevice,
+ HMODULE hSrcModule,
+ LPCWSTR pSrcResource,
+ D3DX10_IMAGE_LOAD_INFO* pLoadInfo,
+ ID3DX10ThreadPump* pPump,
+ ID3D10Resource** ppTexture,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX10CreateTextureFromResource D3DX10CreateTextureFromResourceW
+#else
+#define D3DX10CreateTextureFromResource D3DX10CreateTextureFromResourceA
+#endif
+
+
+// FromFileInMemory
+
+HRESULT WINAPI
+ D3DX10CreateShaderResourceViewFromMemory(
+ ID3D10Device* pDevice,
+ LPCVOID pSrcData,
+ SIZE_T SrcDataSize,
+ D3DX10_IMAGE_LOAD_INFO* pLoadInfo,
+ ID3DX10ThreadPump* pPump,
+ ID3D10ShaderResourceView** ppShaderResourceView,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX10CreateTextureFromMemory(
+ ID3D10Device* pDevice,
+ LPCVOID pSrcData,
+ SIZE_T SrcDataSize,
+ D3DX10_IMAGE_LOAD_INFO* pLoadInfo,
+ ID3DX10ThreadPump* pPump,
+ ID3D10Resource** ppTexture,
+ HRESULT* pHResult);
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Misc Texture APIs /////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX10_TEXTURE_LOAD_INFO:
+// ------------------------
+//
+//----------------------------------------------------------------------------
+
+typedef struct _D3DX10_TEXTURE_LOAD_INFO
+{
+ D3D10_BOX *pSrcBox;
+ D3D10_BOX *pDstBox;
+ UINT SrcFirstMip;
+ UINT DstFirstMip;
+ UINT NumMips;
+ UINT SrcFirstElement;
+ UINT DstFirstElement;
+ UINT NumElements;
+ UINT Filter;
+ UINT MipFilter;
+
+#ifdef __cplusplus
+ _D3DX10_TEXTURE_LOAD_INFO()
+ {
+ pSrcBox = NULL;
+ pDstBox = NULL;
+ SrcFirstMip = 0;
+ DstFirstMip = 0;
+ NumMips = D3DX10_DEFAULT;
+ SrcFirstElement = 0;
+ DstFirstElement = 0;
+ NumElements = D3DX10_DEFAULT;
+ Filter = D3DX10_DEFAULT;
+ MipFilter = D3DX10_DEFAULT;
+ }
+#endif
+
+} D3DX10_TEXTURE_LOAD_INFO;
+
+
+//----------------------------------------------------------------------------
+// D3DX10LoadTextureFromTexture:
+// ----------------------------
+// Load a texture from a texture.
+//
+// Parameters:
+//
+//----------------------------------------------------------------------------
+
+
+HRESULT WINAPI
+ D3DX10LoadTextureFromTexture(
+ ID3D10Resource *pSrcTexture,
+ D3DX10_TEXTURE_LOAD_INFO *pLoadInfo,
+ ID3D10Resource *pDstTexture);
+
+
+//----------------------------------------------------------------------------
+// D3DX10FilterTexture:
+// ------------------
+// Filters mipmaps levels of a texture.
+//
+// Parameters:
+// pBaseTexture
+// The texture object to be filtered
+// SrcLevel
+// The level whose image is used to generate the subsequent levels.
+// MipFilter
+// D3DX10_FILTER flags controlling how each miplevel is filtered.
+// Or D3DX10_DEFAULT for D3DX10_FILTER_BOX,
+//
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+ D3DX10FilterTexture(
+ ID3D10Resource *pTexture,
+ UINT SrcLevel,
+ UINT MipFilter);
+
+
+//----------------------------------------------------------------------------
+// D3DX10SaveTextureToFile:
+// ----------------------
+// Save a texture to a file.
+//
+// Parameters:
+// pDestFile
+// File name of the destination file
+// DestFormat
+// D3DX10_IMAGE_FILE_FORMAT specifying file format to use when saving.
+// pSrcTexture
+// Source texture, containing the image to be saved
+//
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+ D3DX10SaveTextureToFileA(
+ ID3D10Resource *pSrcTexture,
+ D3DX10_IMAGE_FILE_FORMAT DestFormat,
+ LPCSTR pDestFile);
+
+HRESULT WINAPI
+ D3DX10SaveTextureToFileW(
+ ID3D10Resource *pSrcTexture,
+ D3DX10_IMAGE_FILE_FORMAT DestFormat,
+ LPCWSTR pDestFile);
+
+#ifdef UNICODE
+#define D3DX10SaveTextureToFile D3DX10SaveTextureToFileW
+#else
+#define D3DX10SaveTextureToFile D3DX10SaveTextureToFileA
+#endif
+
+
+//----------------------------------------------------------------------------
+// D3DX10SaveTextureToMemory:
+// ----------------------
+// Save a texture to a blob.
+//
+// Parameters:
+// pSrcTexture
+// Source texture, containing the image to be saved
+// DestFormat
+// D3DX10_IMAGE_FILE_FORMAT specifying file format to use when saving.
+// ppDestBuf
+// address of a d3dxbuffer pointer to return the image data
+// Flags
+// optional flags
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+ D3DX10SaveTextureToMemory(
+ ID3D10Resource* pSrcTexture,
+ D3DX10_IMAGE_FILE_FORMAT DestFormat,
+ LPD3D10BLOB* ppDestBuf,
+ UINT Flags);
+
+
+//----------------------------------------------------------------------------
+// D3DX10ComputeNormalMap:
+// ---------------------
+// Converts a height map into a normal map. The (x,y,z) components of each
+// normal are mapped to the (r,g,b) channels of the output texture.
+//
+// Parameters
+// pSrcTexture
+// Pointer to the source heightmap texture
+// Flags
+// D3DX10_NORMALMAP flags
+// Channel
+// D3DX10_CHANNEL specifying source of height information
+// Amplitude
+// The constant value which the height information is multiplied by.
+// pDestTexture
+// Pointer to the destination texture
+//---------------------------------------------------------------------------
+
+HRESULT WINAPI
+ D3DX10ComputeNormalMap(
+ ID3D10Texture2D *pSrcTexture,
+ UINT Flags,
+ UINT Channel,
+ FLOAT Amplitude,
+ ID3D10Texture2D *pDestTexture);
+
+
+//----------------------------------------------------------------------------
+// D3DX10SHProjectCubeMap:
+// ----------------------
+// Projects a function represented in 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
+ D3DX10SHProjectCubeMap(
+ __in_range(2,6) UINT Order,
+ ID3D10Texture2D *pCubeMap,
+ __out_ecount(Order*Order) FLOAT *pROut,
+ __out_ecount_opt(Order*Order) FLOAT *pGOut,
+ __out_ecount_opt(Order*Order) FLOAT *pBOut);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+#endif //__D3DX10TEX_H__
+
diff --git a/external/D3D11/include/D3DX11.h b/external/D3D11/include/D3DX11.h
new file mode 100644
index 0000000..103c782
--- /dev/null
+++ b/external/D3D11/include/D3DX11.h
@@ -0,0 +1,74 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) Microsoft Corporation. All Rights Reserved.
+//
+// File: d3dx11.h
+// Content: D3DX11 utility library
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef __D3DX11_INTERNAL__
+#error Incorrect D3DX11 header used
+#endif
+
+#ifndef __D3DX11_H__
+#define __D3DX11_H__
+
+
+// Defines
+#include <limits.h>
+#include <float.h>
+
+#ifdef ALLOW_THROWING_NEW
+#include <new>
+#endif
+
+#define D3DX11_DEFAULT ((UINT) -1)
+#define D3DX11_FROM_FILE ((UINT) -3)
+#define DXGI_FORMAT_FROM_FILE ((DXGI_FORMAT) -3)
+
+#ifndef D3DX11INLINE
+#ifdef _MSC_VER
+ #if (_MSC_VER >= 1200)
+ #define D3DX11INLINE __forceinline
+ #else
+ #define D3DX11INLINE __inline
+ #endif
+#else
+ #ifdef __cplusplus
+ #define D3DX11INLINE inline
+ #else
+ #define D3DX11INLINE
+ #endif
+#endif
+#endif
+
+
+
+// Includes
+#include "d3d11.h"
+#include "d3dx11.h"
+#include "d3dx11core.h"
+#include "d3dx11tex.h"
+#include "d3dx11async.h"
+
+
+// Errors
+#define _FACDD 0x876
+#define MAKE_DDHRESULT( code ) MAKE_HRESULT( 1, _FACDD, code )
+
+enum _D3DX11_ERR {
+ D3DX11_ERR_CANNOT_MODIFY_INDEX_BUFFER = MAKE_DDHRESULT(2900),
+ D3DX11_ERR_INVALID_MESH = MAKE_DDHRESULT(2901),
+ D3DX11_ERR_CANNOT_ATTR_SORT = MAKE_DDHRESULT(2902),
+ D3DX11_ERR_SKINNING_NOT_SUPPORTED = MAKE_DDHRESULT(2903),
+ D3DX11_ERR_TOO_MANY_INFLUENCES = MAKE_DDHRESULT(2904),
+ D3DX11_ERR_INVALID_DATA = MAKE_DDHRESULT(2905),
+ D3DX11_ERR_LOADED_MESH_HAS_NO_DATA = MAKE_DDHRESULT(2906),
+ D3DX11_ERR_DUPLICATE_NAMED_FRAGMENT = MAKE_DDHRESULT(2907),
+ D3DX11_ERR_CANNOT_REMOVE_LAST_ITEM = MAKE_DDHRESULT(2908),
+};
+
+
+#endif //__D3DX11_H__
+
diff --git a/external/D3D11/include/D3DX11async.h b/external/D3D11/include/D3DX11async.h
new file mode 100644
index 0000000..4586c55
--- /dev/null
+++ b/external/D3D11/include/D3DX11async.h
@@ -0,0 +1,164 @@
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// File: D3DX11Async.h
+// Content: D3DX11 Asynchronous Shader loaders / compilers
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3DX11ASYNC_H__
+#define __D3DX11ASYNC_H__
+
+#include "d3dx11.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+
+//----------------------------------------------------------------------------
+// D3DX11Compile:
+// ------------------
+// Compiles an effect or shader.
+//
+// Parameters:
+// pSrcFile
+// Source file name.
+// hSrcModule
+// Module handle. if NULL, current module will be used.
+// pSrcResource
+// Resource name in module.
+// pSrcData
+// Pointer to source code.
+// SrcDataLen
+// Size of source code, in bytes.
+// pDefines
+// Optional NULL-terminated array of preprocessor macro definitions.
+// pInclude
+// Optional interface pointer to use for handling #include directives.
+// If this parameter is NULL, #includes will be honored when compiling
+// from file, and will error when compiling from resource or memory.
+// pFunctionName
+// Name of the entrypoint function where execution should begin.
+// pProfile
+// Instruction set to be used when generating code. Currently supported
+// profiles are "vs_1_1", "vs_2_0", "vs_2_a", "vs_2_sw", "vs_3_0",
+// "vs_3_sw", "vs_4_0", "vs_4_1",
+// "ps_2_0", "ps_2_a", "ps_2_b", "ps_2_sw", "ps_3_0",
+// "ps_3_sw", "ps_4_0", "ps_4_1",
+// "gs_4_0", "gs_4_1",
+// "tx_1_0",
+// "fx_4_0", "fx_4_1"
+// Note that this entrypoint does not compile fx_2_0 targets, for that
+// you need to use the D3DX9 function.
+// Flags1
+// See D3D10_SHADER_xxx flags.
+// Flags2
+// See D3D10_EFFECT_xxx flags.
+// ppShader
+// Returns a buffer containing the created shader. This buffer contains
+// the compiled shader code, as well as any embedded debug and symbol
+// table info. (See D3D10GetShaderConstantTable)
+// ppErrorMsgs
+// Returns a buffer containing a listing of errors and warnings that were
+// encountered during the compile. If you are running in a debugger,
+// these are the same messages you will see in your debug output.
+// pHResult
+// Pointer to a memory location to receive the return value upon completion.
+// Maybe NULL if not needed.
+// If pPump != NULL, pHResult must be a valid memory location until the
+// the asynchronous execution completes.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3DX11CompileFromFileA(LPCSTR pSrcFile,CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2, ID3DX11ThreadPump* pPump, ID3D10Blob** ppShader, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX11CompileFromFileW(LPCWSTR pSrcFile, CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2, ID3DX11ThreadPump* pPump, ID3D10Blob** ppShader, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX11CompileFromFile D3DX11CompileFromFileW
+#else
+#define D3DX11CompileFromFile D3DX11CompileFromFileA
+#endif
+
+HRESULT WINAPI D3DX11CompileFromResourceA(HMODULE hSrcModule, LPCSTR pSrcResource, LPCSTR pSrcFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2, ID3DX11ThreadPump* pPump, ID3D10Blob** ppShader, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX11CompileFromResourceW(HMODULE hSrcModule, LPCWSTR pSrcResource, LPCWSTR pSrcFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2, ID3DX11ThreadPump* pPump, ID3D10Blob** ppShader, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX11CompileFromResource D3DX11CompileFromResourceW
+#else
+#define D3DX11CompileFromResource D3DX11CompileFromResourceA
+#endif
+
+HRESULT WINAPI D3DX11CompileFromMemory(LPCSTR pSrcData, SIZE_T SrcDataLen, LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2, ID3DX11ThreadPump* pPump, ID3D10Blob** ppShader, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX11PreprocessShaderFromFileA(LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, ID3DX11ThreadPump *pPump, ID3D10Blob** ppShaderText, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX11PreprocessShaderFromFileW(LPCWSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, ID3DX11ThreadPump *pPump, ID3D10Blob** ppShaderText, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX11PreprocessShaderFromMemory(LPCSTR pSrcData, SIZE_T SrcDataSize, LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, ID3DX11ThreadPump *pPump, ID3D10Blob** ppShaderText, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX11PreprocessShaderFromResourceA(HMODULE hModule, LPCSTR pResourceName, LPCSTR pSrcFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, ID3DX11ThreadPump *pPump, ID3D10Blob** ppShaderText, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX11PreprocessShaderFromResourceW(HMODULE hModule, LPCWSTR pResourceName, LPCWSTR pSrcFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, ID3DX11ThreadPump *pPump, ID3D10Blob** ppShaderText, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX11PreprocessShaderFromFile D3DX11PreprocessShaderFromFileW
+#define D3DX11PreprocessShaderFromResource D3DX11PreprocessShaderFromResourceW
+#else
+#define D3DX11PreprocessShaderFromFile D3DX11PreprocessShaderFromFileA
+#define D3DX11PreprocessShaderFromResource D3DX11PreprocessShaderFromResourceA
+#endif
+
+//----------------------------------------------------------------------------
+// Async processors
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3DX11CreateAsyncCompilerProcessor(LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2,
+ ID3D10Blob **ppCompiledShader, ID3D10Blob **ppErrorBuffer, ID3DX11DataProcessor **ppProcessor);
+
+HRESULT WINAPI D3DX11CreateAsyncShaderPreprocessProcessor(LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ ID3D10Blob** ppShaderText, ID3D10Blob **ppErrorBuffer, ID3DX11DataProcessor **ppProcessor);
+
+//----------------------------------------------------------------------------
+// D3DX11 Asynchronous texture I/O (advanced mode)
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3DX11CreateAsyncFileLoaderW(LPCWSTR pFileName, ID3DX11DataLoader **ppDataLoader);
+HRESULT WINAPI D3DX11CreateAsyncFileLoaderA(LPCSTR pFileName, ID3DX11DataLoader **ppDataLoader);
+HRESULT WINAPI D3DX11CreateAsyncMemoryLoader(LPCVOID pData, SIZE_T cbData, ID3DX11DataLoader **ppDataLoader);
+HRESULT WINAPI D3DX11CreateAsyncResourceLoaderW(HMODULE hSrcModule, LPCWSTR pSrcResource, ID3DX11DataLoader **ppDataLoader);
+HRESULT WINAPI D3DX11CreateAsyncResourceLoaderA(HMODULE hSrcModule, LPCSTR pSrcResource, ID3DX11DataLoader **ppDataLoader);
+
+#ifdef UNICODE
+#define D3DX11CreateAsyncFileLoader D3DX11CreateAsyncFileLoaderW
+#define D3DX11CreateAsyncResourceLoader D3DX11CreateAsyncResourceLoaderW
+#else
+#define D3DX11CreateAsyncFileLoader D3DX11CreateAsyncFileLoaderA
+#define D3DX11CreateAsyncResourceLoader D3DX11CreateAsyncResourceLoaderA
+#endif
+
+HRESULT WINAPI D3DX11CreateAsyncTextureProcessor(ID3D11Device *pDevice, D3DX11_IMAGE_LOAD_INFO *pLoadInfo, ID3DX11DataProcessor **ppDataProcessor);
+HRESULT WINAPI D3DX11CreateAsyncTextureInfoProcessor(D3DX11_IMAGE_INFO *pImageInfo, ID3DX11DataProcessor **ppDataProcessor);
+HRESULT WINAPI D3DX11CreateAsyncShaderResourceViewProcessor(ID3D11Device *pDevice, D3DX11_IMAGE_LOAD_INFO *pLoadInfo, ID3DX11DataProcessor **ppDataProcessor);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+#endif //__D3DX11ASYNC_H__
+
+
diff --git a/external/D3D11/include/D3DX11core.h b/external/D3D11/include/D3DX11core.h
new file mode 100644
index 0000000..18e9935
--- /dev/null
+++ b/external/D3D11/include/D3DX11core.h
@@ -0,0 +1,128 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) Microsoft Corporation. All Rights Reserved.
+//
+// File: d3dx11core.h
+// Content: D3DX11 core types and functions
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "d3dx11.h"
+
+#ifndef __D3DX11CORE_H__
+#define __D3DX11CORE_H__
+
+// Current name of the DLL shipped in the same SDK as this header.
+
+
+#define D3DX11_DLL_W L"d3dx11_43.dll"
+#define D3DX11_DLL_A "d3dx11_43.dll"
+
+#ifdef UNICODE
+ #define D3DX11_DLL D3DX11_DLL_W
+#else
+ #define D3DX11_DLL D3DX11_DLL_A
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+///////////////////////////////////////////////////////////////////////////
+// D3DX11_SDK_VERSION:
+// -----------------
+// This identifier is passed to D3DX11CheckVersion in order to ensure that an
+// application was built against the correct header files and lib files.
+// This number is incremented whenever a header (or other) change would
+// require applications to be rebuilt. If the version doesn't match,
+// D3DX11CreateVersion will return FALSE. (The number itself has no meaning.)
+///////////////////////////////////////////////////////////////////////////
+
+
+#define D3DX11_SDK_VERSION 43
+
+
+#ifdef D3D_DIAG_DLL
+BOOL WINAPI D3DX11DebugMute(BOOL Mute);
+#endif
+HRESULT WINAPI D3DX11CheckVersion(UINT D3DSdkVersion, UINT D3DX11SdkVersion);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+// ID3DX11ThreadPump:
+//////////////////////////////////////////////////////////////////////////////
+
+#undef INTERFACE
+#define INTERFACE ID3DX11DataLoader
+
+DECLARE_INTERFACE(ID3DX11DataLoader)
+{
+ STDMETHOD(Load)(THIS) PURE;
+ STDMETHOD(Decompress)(THIS_ void **ppData, SIZE_T *pcBytes) PURE;
+ STDMETHOD(Destroy)(THIS) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE ID3DX11DataProcessor
+
+DECLARE_INTERFACE(ID3DX11DataProcessor)
+{
+ STDMETHOD(Process)(THIS_ void *pData, SIZE_T cBytes) PURE;
+ STDMETHOD(CreateDeviceObject)(THIS_ void **ppDataObject) PURE;
+ STDMETHOD(Destroy)(THIS) PURE;
+};
+
+// {C93FECFA-6967-478a-ABBC-402D90621FCB}
+DEFINE_GUID(IID_ID3DX11ThreadPump,
+0xc93fecfa, 0x6967, 0x478a, 0xab, 0xbc, 0x40, 0x2d, 0x90, 0x62, 0x1f, 0xcb);
+
+#undef INTERFACE
+#define INTERFACE ID3DX11ThreadPump
+
+DECLARE_INTERFACE_(ID3DX11ThreadPump, IUnknown)
+{
+ // IUnknown
+ STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
+ STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+ // ID3DX11ThreadPump
+ STDMETHOD(AddWorkItem)(THIS_ ID3DX11DataLoader *pDataLoader, ID3DX11DataProcessor *pDataProcessor, HRESULT *pHResult, void **ppDeviceObject) PURE;
+ STDMETHOD_(UINT, GetWorkItemCount)(THIS) PURE;
+
+ STDMETHOD(WaitForAllItems)(THIS) PURE;
+ STDMETHOD(ProcessDeviceWorkItems)(THIS_ UINT iWorkItemCount);
+
+ STDMETHOD(PurgeAllItems)(THIS) PURE;
+ STDMETHOD(GetQueueStatus)(THIS_ UINT *pIoQueue, UINT *pProcessQueue, UINT *pDeviceQueue) PURE;
+
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+HRESULT WINAPI D3DX11CreateThreadPump(UINT cIoThreads, UINT cProcThreads, ID3DX11ThreadPump **ppThreadPump);
+
+HRESULT WINAPI D3DX11UnsetAllDeviceObjects(ID3D11DeviceContext *pContext);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+///////////////////////////////////////////////////////////////////////////
+
+#define _FACD3D 0x876
+#define MAKE_D3DHRESULT( code ) MAKE_HRESULT( 1, _FACD3D, code )
+#define MAKE_D3DSTATUS( code ) MAKE_HRESULT( 0, _FACD3D, code )
+
+#define D3DERR_INVALIDCALL MAKE_D3DHRESULT(2156)
+#define D3DERR_WASSTILLDRAWING MAKE_D3DHRESULT(540)
+
+#endif //__D3DX11CORE_H__
+
diff --git a/external/D3D11/include/D3DX11tex.h b/external/D3D11/include/D3DX11tex.h
new file mode 100644
index 0000000..16c0409
--- /dev/null
+++ b/external/D3D11/include/D3DX11tex.h
@@ -0,0 +1,772 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) Microsoft Corporation. All Rights Reserved.
+//
+// File: d3dx11tex.h
+// Content: D3DX11 texturing APIs
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include "d3dx11.h"
+
+#ifndef __D3DX11TEX_H__
+#define __D3DX11TEX_H__
+
+
+//----------------------------------------------------------------------------
+// D3DX11_FILTER flags:
+// ------------------
+//
+// A valid filter must contain one of these values:
+//
+// D3DX11_FILTER_NONE
+// No scaling or filtering will take place. Pixels outside the bounds
+// of the source image are assumed to be transparent black.
+// D3DX11_FILTER_POINT
+// Each destination pixel is computed by sampling the nearest pixel
+// from the source image.
+// D3DX11_FILTER_LINEAR
+// Each destination pixel is computed by linearly interpolating between
+// the nearest pixels in the source image. This filter works best
+// when the scale on each axis is less than 2.
+// D3DX11_FILTER_TRIANGLE
+// Every pixel in the source image contributes equally to the
+// destination image. This is the slowest of all the filters.
+// D3DX11_FILTER_BOX
+// Each pixel is computed by averaging a 2x2(x2) box pixels from
+// the source image. Only works when the dimensions of the
+// destination are half those of the source. (as with mip maps)
+//
+// And can be OR'd with any of these optional flags:
+//
+// D3DX11_FILTER_MIRROR_U
+// Indicates that pixels off the edge of the texture on the U-axis
+// should be mirrored, not wraped.
+// D3DX11_FILTER_MIRROR_V
+// Indicates that pixels off the edge of the texture on the V-axis
+// should be mirrored, not wraped.
+// D3DX11_FILTER_MIRROR_W
+// Indicates that pixels off the edge of the texture on the W-axis
+// should be mirrored, not wraped.
+// D3DX11_FILTER_MIRROR
+// Same as specifying D3DX11_FILTER_MIRROR_U | D3DX11_FILTER_MIRROR_V |
+// D3DX11_FILTER_MIRROR_V
+// D3DX11_FILTER_DITHER
+// Dithers the resulting image using a 4x4 order dither pattern.
+// D3DX11_FILTER_SRGB_IN
+// Denotes that the input data is in sRGB (gamma 2.2) colorspace.
+// D3DX11_FILTER_SRGB_OUT
+// Denotes that the output data is in sRGB (gamma 2.2) colorspace.
+// D3DX11_FILTER_SRGB
+// Same as specifying D3DX11_FILTER_SRGB_IN | D3DX11_FILTER_SRGB_OUT
+//
+//----------------------------------------------------------------------------
+
+typedef enum D3DX11_FILTER_FLAG
+{
+ D3DX11_FILTER_NONE = (1 << 0),
+ D3DX11_FILTER_POINT = (2 << 0),
+ D3DX11_FILTER_LINEAR = (3 << 0),
+ D3DX11_FILTER_TRIANGLE = (4 << 0),
+ D3DX11_FILTER_BOX = (5 << 0),
+
+ D3DX11_FILTER_MIRROR_U = (1 << 16),
+ D3DX11_FILTER_MIRROR_V = (2 << 16),
+ D3DX11_FILTER_MIRROR_W = (4 << 16),
+ D3DX11_FILTER_MIRROR = (7 << 16),
+
+ D3DX11_FILTER_DITHER = (1 << 19),
+ D3DX11_FILTER_DITHER_DIFFUSION= (2 << 19),
+
+ D3DX11_FILTER_SRGB_IN = (1 << 21),
+ D3DX11_FILTER_SRGB_OUT = (2 << 21),
+ D3DX11_FILTER_SRGB = (3 << 21),
+} D3DX11_FILTER_FLAG;
+
+//----------------------------------------------------------------------------
+// D3DX11_NORMALMAP flags:
+// ---------------------
+// These flags are used to control how D3DX11ComputeNormalMap generates normal
+// maps. Any number of these flags may be OR'd together in any combination.
+//
+// D3DX11_NORMALMAP_MIRROR_U
+// Indicates that pixels off the edge of the texture on the U-axis
+// should be mirrored, not wraped.
+// D3DX11_NORMALMAP_MIRROR_V
+// Indicates that pixels off the edge of the texture on the V-axis
+// should be mirrored, not wraped.
+// D3DX11_NORMALMAP_MIRROR
+// Same as specifying D3DX11_NORMALMAP_MIRROR_U | D3DX11_NORMALMAP_MIRROR_V
+// D3DX11_NORMALMAP_INVERTSIGN
+// Inverts the direction of each normal
+// D3DX11_NORMALMAP_COMPUTE_OCCLUSION
+// Compute the per pixel Occlusion term and encodes it into the alpha.
+// An Alpha of 1 means that the pixel is not obscured in anyway, and
+// an alpha of 0 would mean that the pixel is completly obscured.
+//
+//----------------------------------------------------------------------------
+
+typedef enum D3DX11_NORMALMAP_FLAG
+{
+ D3DX11_NORMALMAP_MIRROR_U = (1 << 16),
+ D3DX11_NORMALMAP_MIRROR_V = (2 << 16),
+ D3DX11_NORMALMAP_MIRROR = (3 << 16),
+ D3DX11_NORMALMAP_INVERTSIGN = (8 << 16),
+ D3DX11_NORMALMAP_COMPUTE_OCCLUSION = (16 << 16),
+} D3DX11_NORMALMAP_FLAG;
+
+//----------------------------------------------------------------------------
+// D3DX11_CHANNEL flags:
+// -------------------
+// These flags are used by functions which operate on or more channels
+// in a texture.
+//
+// D3DX11_CHANNEL_RED
+// Indicates the red channel should be used
+// D3DX11_CHANNEL_BLUE
+// Indicates the blue channel should be used
+// D3DX11_CHANNEL_GREEN
+// Indicates the green channel should be used
+// D3DX11_CHANNEL_ALPHA
+// Indicates the alpha channel should be used
+// D3DX11_CHANNEL_LUMINANCE
+// Indicates the luminaces of the red green and blue channels should be
+// used.
+//
+//----------------------------------------------------------------------------
+
+typedef enum D3DX11_CHANNEL_FLAG
+{
+ D3DX11_CHANNEL_RED = (1 << 0),
+ D3DX11_CHANNEL_BLUE = (1 << 1),
+ D3DX11_CHANNEL_GREEN = (1 << 2),
+ D3DX11_CHANNEL_ALPHA = (1 << 3),
+ D3DX11_CHANNEL_LUMINANCE = (1 << 4),
+} D3DX11_CHANNEL_FLAG;
+
+
+
+//----------------------------------------------------------------------------
+// D3DX11_IMAGE_FILE_FORMAT:
+// ---------------------
+// This enum is used to describe supported image file formats.
+//
+//----------------------------------------------------------------------------
+
+typedef enum D3DX11_IMAGE_FILE_FORMAT
+{
+ D3DX11_IFF_BMP = 0,
+ D3DX11_IFF_JPG = 1,
+ D3DX11_IFF_PNG = 3,
+ D3DX11_IFF_DDS = 4,
+ D3DX11_IFF_TIFF = 10,
+ D3DX11_IFF_GIF = 11,
+ D3DX11_IFF_WMP = 12,
+ D3DX11_IFF_FORCE_DWORD = 0x7fffffff
+
+} D3DX11_IMAGE_FILE_FORMAT;
+
+
+//----------------------------------------------------------------------------
+// D3DX11_SAVE_TEXTURE_FLAG:
+// ---------------------
+// This enum is used to support texture saving options.
+//
+//----------------------------------------------------------------------------
+
+typedef enum D3DX11_SAVE_TEXTURE_FLAG
+{
+ D3DX11_STF_USEINPUTBLOB = 0x0001,
+} D3DX11_SAVE_TEXTURE_FLAG;
+
+
+//----------------------------------------------------------------------------
+// D3DX11_IMAGE_INFO:
+// ---------------
+// This structure is used to return a rough description of what the
+// the original contents of an image file looked like.
+//
+// Width
+// Width of original image in pixels
+// Height
+// Height of original image in pixels
+// Depth
+// Depth of original image in pixels
+// ArraySize
+// Array size in textures
+// MipLevels
+// Number of mip levels in original image
+// MiscFlags
+// Miscellaneous flags
+// Format
+// D3D format which most closely describes the data in original image
+// ResourceDimension
+// D3D11_RESOURCE_DIMENSION representing the dimension of texture stored in the file.
+// D3D11_RESOURCE_DIMENSION_TEXTURE1D, 2D, 3D
+// ImageFileFormat
+// D3DX11_IMAGE_FILE_FORMAT representing the format of the image file.
+//----------------------------------------------------------------------------
+
+typedef struct D3DX11_IMAGE_INFO
+{
+ UINT Width;
+ UINT Height;
+ UINT Depth;
+ UINT ArraySize;
+ UINT MipLevels;
+ UINT MiscFlags;
+ DXGI_FORMAT Format;
+ D3D11_RESOURCE_DIMENSION ResourceDimension;
+ D3DX11_IMAGE_FILE_FORMAT ImageFileFormat;
+} D3DX11_IMAGE_INFO;
+
+
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Image File APIs ///////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX11_IMAGE_LOAD_INFO:
+// ---------------
+// This structure can be optionally passed in to texture loader APIs to
+// control how textures get loaded. Pass in D3DX11_DEFAULT for any of these
+// to have D3DX automatically pick defaults based on the source file.
+//
+// Width
+// Rescale texture to Width texels wide
+// Height
+// Rescale texture to Height texels high
+// Depth
+// Rescale texture to Depth texels deep
+// FirstMipLevel
+// First mip level to load
+// MipLevels
+// Number of mip levels to load after the first level
+// Usage
+// D3D11_USAGE flag for the new texture
+// BindFlags
+// D3D11 Bind flags for the new texture
+// CpuAccessFlags
+// D3D11 CPU Access flags for the new texture
+// MiscFlags
+// Reserved. Must be 0
+// Format
+// Resample texture to the specified format
+// Filter
+// Filter the texture using the specified filter (only when resampling)
+// MipFilter
+// Filter the texture mip levels using the specified filter (only if
+// generating mips)
+// pSrcInfo
+// (optional) pointer to a D3DX11_IMAGE_INFO structure that will get
+// populated with source image information
+//----------------------------------------------------------------------------
+
+
+typedef struct D3DX11_IMAGE_LOAD_INFO
+{
+ UINT Width;
+ UINT Height;
+ UINT Depth;
+ UINT FirstMipLevel;
+ UINT MipLevels;
+ D3D11_USAGE Usage;
+ UINT BindFlags;
+ UINT CpuAccessFlags;
+ UINT MiscFlags;
+ DXGI_FORMAT Format;
+ UINT Filter;
+ UINT MipFilter;
+ D3DX11_IMAGE_INFO* pSrcInfo;
+
+#ifdef __cplusplus
+ D3DX11_IMAGE_LOAD_INFO()
+ {
+ Width = D3DX11_DEFAULT;
+ Height = D3DX11_DEFAULT;
+ Depth = D3DX11_DEFAULT;
+ FirstMipLevel = D3DX11_DEFAULT;
+ MipLevels = D3DX11_DEFAULT;
+ Usage = (D3D11_USAGE) D3DX11_DEFAULT;
+ BindFlags = D3DX11_DEFAULT;
+ CpuAccessFlags = D3DX11_DEFAULT;
+ MiscFlags = D3DX11_DEFAULT;
+ Format = DXGI_FORMAT_FROM_FILE;
+ Filter = D3DX11_DEFAULT;
+ MipFilter = D3DX11_DEFAULT;
+ pSrcInfo = NULL;
+ }
+#endif
+
+} D3DX11_IMAGE_LOAD_INFO;
+
+//-------------------------------------------------------------------------------
+// GetImageInfoFromFile/Resource/Memory:
+// ------------------------------
+// Fills in a D3DX11_IMAGE_INFO struct with information about an image file.
+//
+// Parameters:
+// pSrcFile
+// File name of the source image.
+// pSrcModule
+// Module where resource is located, or NULL for module associated
+// with image the os used to create the current process.
+// pSrcResource
+// Resource name.
+// pSrcData
+// Pointer to file in memory.
+// SrcDataSize
+// Size in bytes of file in memory.
+// pPump
+// Optional pointer to a thread pump object to use.
+// pSrcInfo
+// Pointer to a D3DX11_IMAGE_INFO structure to be filled in with the
+// description of the data in the source image file.
+// pHResult
+// Pointer to a memory location to receive the return value upon completion.
+// Maybe NULL if not needed.
+// If pPump != NULL, pHResult must be a valid memory location until the
+// the asynchronous execution completes.
+//-------------------------------------------------------------------------------
+
+HRESULT WINAPI
+ D3DX11GetImageInfoFromFileA(
+ LPCSTR pSrcFile,
+ ID3DX11ThreadPump* pPump,
+ D3DX11_IMAGE_INFO* pSrcInfo,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX11GetImageInfoFromFileW(
+ LPCWSTR pSrcFile,
+ ID3DX11ThreadPump* pPump,
+ D3DX11_IMAGE_INFO* pSrcInfo,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX11GetImageInfoFromFile D3DX11GetImageInfoFromFileW
+#else
+#define D3DX11GetImageInfoFromFile D3DX11GetImageInfoFromFileA
+#endif
+
+
+HRESULT WINAPI
+ D3DX11GetImageInfoFromResourceA(
+ HMODULE hSrcModule,
+ LPCSTR pSrcResource,
+ ID3DX11ThreadPump* pPump,
+ D3DX11_IMAGE_INFO* pSrcInfo,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX11GetImageInfoFromResourceW(
+ HMODULE hSrcModule,
+ LPCWSTR pSrcResource,
+ ID3DX11ThreadPump* pPump,
+ D3DX11_IMAGE_INFO* pSrcInfo,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX11GetImageInfoFromResource D3DX11GetImageInfoFromResourceW
+#else
+#define D3DX11GetImageInfoFromResource D3DX11GetImageInfoFromResourceA
+#endif
+
+
+HRESULT WINAPI
+ D3DX11GetImageInfoFromMemory(
+ LPCVOID pSrcData,
+ SIZE_T SrcDataSize,
+ ID3DX11ThreadPump* pPump,
+ D3DX11_IMAGE_INFO* pSrcInfo,
+ HRESULT* pHResult);
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Create/Save Texture APIs //////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX11CreateTextureFromFile/Resource/Memory:
+// D3DX11CreateShaderResourceViewFromFile/Resource/Memory:
+// -----------------------------------
+// Create a texture object from a file or resource.
+//
+// Parameters:
+//
+// pDevice
+// The D3D device with which the texture is going to be used.
+// pSrcFile
+// File name.
+// hSrcModule
+// Module handle. if NULL, current module will be used.
+// pSrcResource
+// Resource name in module
+// pvSrcData
+// Pointer to file in memory.
+// SrcDataSize
+// Size in bytes of file in memory.
+// pLoadInfo
+// Optional pointer to a D3DX11_IMAGE_LOAD_INFO structure that
+// contains additional loader parameters.
+// pPump
+// Optional pointer to a thread pump object to use.
+// ppTexture
+// [out] Created texture object.
+// ppShaderResourceView
+// [out] Shader resource view object created.
+// pHResult
+// Pointer to a memory location to receive the return value upon completion.
+// Maybe NULL if not needed.
+// If pPump != NULL, pHResult must be a valid memory location until the
+// the asynchronous execution completes.
+//
+//----------------------------------------------------------------------------
+
+
+// FromFile
+
+HRESULT WINAPI
+ D3DX11CreateShaderResourceViewFromFileA(
+ ID3D11Device* pDevice,
+ LPCSTR pSrcFile,
+ D3DX11_IMAGE_LOAD_INFO *pLoadInfo,
+ ID3DX11ThreadPump* pPump,
+ ID3D11ShaderResourceView** ppShaderResourceView,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX11CreateShaderResourceViewFromFileW(
+ ID3D11Device* pDevice,
+ LPCWSTR pSrcFile,
+ D3DX11_IMAGE_LOAD_INFO *pLoadInfo,
+ ID3DX11ThreadPump* pPump,
+ ID3D11ShaderResourceView** ppShaderResourceView,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX11CreateShaderResourceViewFromFile D3DX11CreateShaderResourceViewFromFileW
+#else
+#define D3DX11CreateShaderResourceViewFromFile D3DX11CreateShaderResourceViewFromFileA
+#endif
+
+HRESULT WINAPI
+ D3DX11CreateTextureFromFileA(
+ ID3D11Device* pDevice,
+ LPCSTR pSrcFile,
+ D3DX11_IMAGE_LOAD_INFO *pLoadInfo,
+ ID3DX11ThreadPump* pPump,
+ ID3D11Resource** ppTexture,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX11CreateTextureFromFileW(
+ ID3D11Device* pDevice,
+ LPCWSTR pSrcFile,
+ D3DX11_IMAGE_LOAD_INFO *pLoadInfo,
+ ID3DX11ThreadPump* pPump,
+ ID3D11Resource** ppTexture,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX11CreateTextureFromFile D3DX11CreateTextureFromFileW
+#else
+#define D3DX11CreateTextureFromFile D3DX11CreateTextureFromFileA
+#endif
+
+
+// FromResource (resources in dll/exes)
+
+HRESULT WINAPI
+ D3DX11CreateShaderResourceViewFromResourceA(
+ ID3D11Device* pDevice,
+ HMODULE hSrcModule,
+ LPCSTR pSrcResource,
+ D3DX11_IMAGE_LOAD_INFO* pLoadInfo,
+ ID3DX11ThreadPump* pPump,
+ ID3D11ShaderResourceView** ppShaderResourceView,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX11CreateShaderResourceViewFromResourceW(
+ ID3D11Device* pDevice,
+ HMODULE hSrcModule,
+ LPCWSTR pSrcResource,
+ D3DX11_IMAGE_LOAD_INFO* pLoadInfo,
+ ID3DX11ThreadPump* pPump,
+ ID3D11ShaderResourceView** ppShaderResourceView,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX11CreateShaderResourceViewFromResource D3DX11CreateShaderResourceViewFromResourceW
+#else
+#define D3DX11CreateShaderResourceViewFromResource D3DX11CreateShaderResourceViewFromResourceA
+#endif
+
+HRESULT WINAPI
+ D3DX11CreateTextureFromResourceA(
+ ID3D11Device* pDevice,
+ HMODULE hSrcModule,
+ LPCSTR pSrcResource,
+ D3DX11_IMAGE_LOAD_INFO *pLoadInfo,
+ ID3DX11ThreadPump* pPump,
+ ID3D11Resource** ppTexture,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX11CreateTextureFromResourceW(
+ ID3D11Device* pDevice,
+ HMODULE hSrcModule,
+ LPCWSTR pSrcResource,
+ D3DX11_IMAGE_LOAD_INFO* pLoadInfo,
+ ID3DX11ThreadPump* pPump,
+ ID3D11Resource** ppTexture,
+ HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX11CreateTextureFromResource D3DX11CreateTextureFromResourceW
+#else
+#define D3DX11CreateTextureFromResource D3DX11CreateTextureFromResourceA
+#endif
+
+
+// FromFileInMemory
+
+HRESULT WINAPI
+ D3DX11CreateShaderResourceViewFromMemory(
+ ID3D11Device* pDevice,
+ LPCVOID pSrcData,
+ SIZE_T SrcDataSize,
+ D3DX11_IMAGE_LOAD_INFO* pLoadInfo,
+ ID3DX11ThreadPump* pPump,
+ ID3D11ShaderResourceView** ppShaderResourceView,
+ HRESULT* pHResult);
+
+HRESULT WINAPI
+ D3DX11CreateTextureFromMemory(
+ ID3D11Device* pDevice,
+ LPCVOID pSrcData,
+ SIZE_T SrcDataSize,
+ D3DX11_IMAGE_LOAD_INFO* pLoadInfo,
+ ID3DX11ThreadPump* pPump,
+ ID3D11Resource** ppTexture,
+ HRESULT* pHResult);
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Misc Texture APIs /////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------------
+// D3DX11_TEXTURE_LOAD_INFO:
+// ------------------------
+//
+//----------------------------------------------------------------------------
+
+typedef struct _D3DX11_TEXTURE_LOAD_INFO
+{
+ D3D11_BOX *pSrcBox;
+ D3D11_BOX *pDstBox;
+ UINT SrcFirstMip;
+ UINT DstFirstMip;
+ UINT NumMips;
+ UINT SrcFirstElement;
+ UINT DstFirstElement;
+ UINT NumElements;
+ UINT Filter;
+ UINT MipFilter;
+
+#ifdef __cplusplus
+ _D3DX11_TEXTURE_LOAD_INFO()
+ {
+ pSrcBox = NULL;
+ pDstBox = NULL;
+ SrcFirstMip = 0;
+ DstFirstMip = 0;
+ NumMips = D3DX11_DEFAULT;
+ SrcFirstElement = 0;
+ DstFirstElement = 0;
+ NumElements = D3DX11_DEFAULT;
+ Filter = D3DX11_DEFAULT;
+ MipFilter = D3DX11_DEFAULT;
+ }
+#endif
+
+} D3DX11_TEXTURE_LOAD_INFO;
+
+
+//----------------------------------------------------------------------------
+// D3DX11LoadTextureFromTexture:
+// ----------------------------
+// Load a texture from a texture.
+//
+// Parameters:
+//
+//----------------------------------------------------------------------------
+
+
+HRESULT WINAPI
+ D3DX11LoadTextureFromTexture(
+ ID3D11DeviceContext *pContext,
+ ID3D11Resource *pSrcTexture,
+ D3DX11_TEXTURE_LOAD_INFO *pLoadInfo,
+ ID3D11Resource *pDstTexture);
+
+
+//----------------------------------------------------------------------------
+// D3DX11FilterTexture:
+// ------------------
+// Filters mipmaps levels of a texture.
+//
+// Parameters:
+// pBaseTexture
+// The texture object to be filtered
+// SrcLevel
+// The level whose image is used to generate the subsequent levels.
+// MipFilter
+// D3DX11_FILTER flags controlling how each miplevel is filtered.
+// Or D3DX11_DEFAULT for D3DX11_FILTER_BOX,
+//
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+ D3DX11FilterTexture(
+ ID3D11DeviceContext *pContext,
+ ID3D11Resource *pTexture,
+ UINT SrcLevel,
+ UINT MipFilter);
+
+
+//----------------------------------------------------------------------------
+// D3DX11SaveTextureToFile:
+// ----------------------
+// Save a texture to a file.
+//
+// Parameters:
+// pDestFile
+// File name of the destination file
+// DestFormat
+// D3DX11_IMAGE_FILE_FORMAT specifying file format to use when saving.
+// pSrcTexture
+// Source texture, containing the image to be saved
+//
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+ D3DX11SaveTextureToFileA(
+ ID3D11DeviceContext *pContext,
+ ID3D11Resource *pSrcTexture,
+ D3DX11_IMAGE_FILE_FORMAT DestFormat,
+ LPCSTR pDestFile);
+
+HRESULT WINAPI
+ D3DX11SaveTextureToFileW(
+ ID3D11DeviceContext *pContext,
+ ID3D11Resource *pSrcTexture,
+ D3DX11_IMAGE_FILE_FORMAT DestFormat,
+ LPCWSTR pDestFile);
+
+#ifdef UNICODE
+#define D3DX11SaveTextureToFile D3DX11SaveTextureToFileW
+#else
+#define D3DX11SaveTextureToFile D3DX11SaveTextureToFileA
+#endif
+
+
+//----------------------------------------------------------------------------
+// D3DX11SaveTextureToMemory:
+// ----------------------
+// Save a texture to a blob.
+//
+// Parameters:
+// pSrcTexture
+// Source texture, containing the image to be saved
+// DestFormat
+// D3DX11_IMAGE_FILE_FORMAT specifying file format to use when saving.
+// ppDestBuf
+// address of a d3dxbuffer pointer to return the image data
+// Flags
+// optional flags
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI
+ D3DX11SaveTextureToMemory(
+ ID3D11DeviceContext *pContext,
+ ID3D11Resource* pSrcTexture,
+ D3DX11_IMAGE_FILE_FORMAT DestFormat,
+ ID3D10Blob** ppDestBuf,
+ UINT Flags);
+
+
+//----------------------------------------------------------------------------
+// D3DX11ComputeNormalMap:
+// ---------------------
+// Converts a height map into a normal map. The (x,y,z) components of each
+// normal are mapped to the (r,g,b) channels of the output texture.
+//
+// Parameters
+// pSrcTexture
+// Pointer to the source heightmap texture
+// Flags
+// D3DX11_NORMALMAP flags
+// Channel
+// D3DX11_CHANNEL specifying source of height information
+// Amplitude
+// The constant value which the height information is multiplied by.
+// pDestTexture
+// Pointer to the destination texture
+//---------------------------------------------------------------------------
+
+HRESULT WINAPI
+ D3DX11ComputeNormalMap(
+ ID3D11DeviceContext *pContext,
+ ID3D11Texture2D *pSrcTexture,
+ UINT Flags,
+ UINT Channel,
+ FLOAT Amplitude,
+ ID3D11Texture2D *pDestTexture);
+
+
+//----------------------------------------------------------------------------
+// D3DX11SHProjectCubeMap:
+// ----------------------
+// Projects a function represented in 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
+ D3DX11SHProjectCubeMap(
+ ID3D11DeviceContext *pContext,
+ __in_range(2,6) UINT Order,
+ ID3D11Texture2D *pCubeMap,
+ __out_ecount(Order*Order) FLOAT *pROut,
+ __out_ecount_opt(Order*Order) FLOAT *pGOut,
+ __out_ecount_opt(Order*Order) FLOAT *pBOut);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+#endif //__D3DX11TEX_H__
+
diff --git a/external/D3D11/include/d3dx10async.h b/external/D3D11/include/d3dx10async.h
new file mode 100644
index 0000000..d1b1fc5
--- /dev/null
+++ b/external/D3D11/include/d3dx10async.h
@@ -0,0 +1,290 @@
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// File: D3DX10Async.h
+// Content: D3DX10 Asynchronous Effect / Shader loaders / compilers
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3DX10ASYNC_H__
+#define __D3DX10ASYNC_H__
+
+#include "d3dx10.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+
+//----------------------------------------------------------------------------
+// D3DX10Compile:
+// ------------------
+// Compiles an effect or shader.
+//
+// Parameters:
+// pSrcFile
+// Source file name.
+// hSrcModule
+// Module handle. if NULL, current module will be used.
+// pSrcResource
+// Resource name in module.
+// pSrcData
+// Pointer to source code.
+// SrcDataLen
+// Size of source code, in bytes.
+// pDefines
+// Optional NULL-terminated array of preprocessor macro definitions.
+// pInclude
+// Optional interface pointer to use for handling #include directives.
+// If this parameter is NULL, #includes will be honored when compiling
+// from file, and will error when compiling from resource or memory.
+// pFunctionName
+// Name of the entrypoint function where execution should begin.
+// pProfile
+// Instruction set to be used when generating code. Currently supported
+// profiles are "vs_1_1", "vs_2_0", "vs_2_a", "vs_2_sw", "vs_3_0",
+// "vs_3_sw", "vs_4_0", "vs_4_1",
+// "ps_2_0", "ps_2_a", "ps_2_b", "ps_2_sw", "ps_3_0",
+// "ps_3_sw", "ps_4_0", "ps_4_1",
+// "gs_4_0", "gs_4_1",
+// "tx_1_0",
+// "fx_4_0", "fx_4_1"
+// Note that this entrypoint does not compile fx_2_0 targets, for that
+// you need to use the D3DX9 function.
+// Flags1
+// See D3D10_SHADER_xxx flags.
+// Flags2
+// See D3D10_EFFECT_xxx flags.
+// ppShader
+// Returns a buffer containing the created shader. This buffer contains
+// the compiled shader code, as well as any embedded debug and symbol
+// table info. (See D3D10GetShaderConstantTable)
+// ppErrorMsgs
+// Returns a buffer containing a listing of errors and warnings that were
+// encountered during the compile. If you are running in a debugger,
+// these are the same messages you will see in your debug output.
+// pHResult
+// Pointer to a memory location to receive the return value upon completion.
+// Maybe NULL if not needed.
+// If pPump != NULL, pHResult must be a valid memory location until the
+// the asynchronous execution completes.
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3DX10CompileFromFileA(LPCSTR pSrcFile,CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2, ID3DX10ThreadPump* pPump, ID3D10Blob** ppShader, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10CompileFromFileW(LPCWSTR pSrcFile, CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2, ID3DX10ThreadPump* pPump, ID3D10Blob** ppShader, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX10CompileFromFile D3DX10CompileFromFileW
+#else
+#define D3DX10CompileFromFile D3DX10CompileFromFileA
+#endif
+
+HRESULT WINAPI D3DX10CompileFromResourceA(HMODULE hSrcModule, LPCSTR pSrcResource, LPCSTR pSrcFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2, ID3DX10ThreadPump* pPump, ID3D10Blob** ppShader, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10CompileFromResourceW(HMODULE hSrcModule, LPCWSTR pSrcResource, LPCWSTR pSrcFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2, ID3DX10ThreadPump* pPump, ID3D10Blob** ppShader, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX10CompileFromResource D3DX10CompileFromResourceW
+#else
+#define D3DX10CompileFromResource D3DX10CompileFromResourceA
+#endif
+
+HRESULT WINAPI D3DX10CompileFromMemory(LPCSTR pSrcData, SIZE_T SrcDataLen, LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2, ID3DX10ThreadPump* pPump, ID3D10Blob** ppShader, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+//----------------------------------------------------------------------------
+// D3DX10CreateEffectFromXXXX:
+// --------------------------
+// Creates an effect from a binary effect or file
+//
+// Parameters:
+//
+// [in]
+//
+//
+// pFileName
+// Name of the ASCII (uncompiled) or binary (compiled) Effect file to load
+//
+// hModule
+// Handle to the module containing the resource to compile from
+// pResourceName
+// Name of the resource within hModule to compile from
+//
+// pData
+// Blob of effect data, either ASCII (uncompiled) or binary (compiled)
+// DataLength
+// Length of the data blob
+//
+// pDefines
+// Optional NULL-terminated array of preprocessor macro definitions.
+// pInclude
+// Optional interface pointer to use for handling #include directives.
+// If this parameter is NULL, #includes will be honored when compiling
+// from file, and will error when compiling from resource or memory.
+// pProfile
+// Profile to use when compiling the effect.
+// HLSLFlags
+// Compilation flags pertaining to shaders and data types, honored by
+// the HLSL compiler
+// FXFlags
+// Compilation flags pertaining to Effect compilation, honored
+// by the Effect compiler
+// pDevice
+// Pointer to the D3D10 device on which to create Effect resources
+// pEffectPool
+// Pointer to an Effect pool to share variables with or NULL
+//
+// [out]
+//
+// ppEffect
+// Address of the newly created Effect interface
+// ppEffectPool
+// Address of the newly created Effect pool interface
+// ppErrors
+// If non-NULL, address of a buffer with error messages that occurred
+// during parsing or compilation
+// pHResult
+// Pointer to a memory location to receive the return value upon completion.
+// Maybe NULL if not needed.
+// If pPump != NULL, pHResult must be a valid memory location until the
+// the asynchronous execution completes.
+//----------------------------------------------------------------------------
+
+
+HRESULT WINAPI D3DX10CreateEffectFromFileA(LPCSTR pFileName, CONST D3D10_SHADER_MACRO *pDefines,
+ ID3D10Include *pInclude, LPCSTR pProfile, UINT HLSLFlags, UINT FXFlags, ID3D10Device *pDevice,
+ ID3D10EffectPool *pEffectPool, ID3DX10ThreadPump* pPump, ID3D10Effect **ppEffect, ID3D10Blob **ppErrors, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10CreateEffectFromFileW(LPCWSTR pFileName, CONST D3D10_SHADER_MACRO *pDefines,
+ ID3D10Include *pInclude, LPCSTR pProfile, UINT HLSLFlags, UINT FXFlags, ID3D10Device *pDevice,
+ ID3D10EffectPool *pEffectPool, ID3DX10ThreadPump* pPump, ID3D10Effect **ppEffect, ID3D10Blob **ppErrors, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10CreateEffectFromMemory(LPCVOID pData, SIZE_T DataLength, LPCSTR pSrcFileName, CONST D3D10_SHADER_MACRO *pDefines,
+ ID3D10Include *pInclude, LPCSTR pProfile, UINT HLSLFlags, UINT FXFlags, ID3D10Device *pDevice,
+ ID3D10EffectPool *pEffectPool, ID3DX10ThreadPump* pPump, ID3D10Effect **ppEffect, ID3D10Blob **ppErrors, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10CreateEffectFromResourceA(HMODULE hModule, LPCSTR pResourceName, LPCSTR pSrcFileName, CONST D3D10_SHADER_MACRO *pDefines,
+ ID3D10Include *pInclude, LPCSTR pProfile, UINT HLSLFlags, UINT FXFlags, ID3D10Device *pDevice,
+ ID3D10EffectPool *pEffectPool, ID3DX10ThreadPump* pPump, ID3D10Effect **ppEffect, ID3D10Blob **ppErrors, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10CreateEffectFromResourceW(HMODULE hModule, LPCWSTR pResourceName, LPCWSTR pSrcFileName, CONST D3D10_SHADER_MACRO *pDefines,
+ ID3D10Include *pInclude, LPCSTR pProfile, UINT HLSLFlags, UINT FXFlags, ID3D10Device *pDevice,
+ ID3D10EffectPool *pEffectPool, ID3DX10ThreadPump* pPump, ID3D10Effect **ppEffect, ID3D10Blob **ppErrors, HRESULT* pHResult);
+
+
+#ifdef UNICODE
+#define D3DX10CreateEffectFromFile D3DX10CreateEffectFromFileW
+#define D3DX10CreateEffectFromResource D3DX10CreateEffectFromResourceW
+#else
+#define D3DX10CreateEffectFromFile D3DX10CreateEffectFromFileA
+#define D3DX10CreateEffectFromResource D3DX10CreateEffectFromResourceA
+#endif
+
+HRESULT WINAPI D3DX10CreateEffectPoolFromFileA(LPCSTR pFileName, CONST D3D10_SHADER_MACRO *pDefines,
+ ID3D10Include *pInclude, LPCSTR pProfile, UINT HLSLFlags, UINT FXFlags, ID3D10Device *pDevice, ID3DX10ThreadPump* pPump,
+ ID3D10EffectPool **ppEffectPool, ID3D10Blob **ppErrors, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10CreateEffectPoolFromFileW(LPCWSTR pFileName, CONST D3D10_SHADER_MACRO *pDefines,
+ ID3D10Include *pInclude, LPCSTR pProfile, UINT HLSLFlags, UINT FXFlags, ID3D10Device *pDevice, ID3DX10ThreadPump* pPump,
+ ID3D10EffectPool **ppEffectPool, ID3D10Blob **ppErrors, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10CreateEffectPoolFromMemory(LPCVOID pData, SIZE_T DataLength, LPCSTR pSrcFileName, CONST D3D10_SHADER_MACRO *pDefines,
+ ID3D10Include *pInclude, LPCSTR pProfile, UINT HLSLFlags, UINT FXFlags, ID3D10Device *pDevice,
+ ID3DX10ThreadPump* pPump, ID3D10EffectPool **ppEffectPool, ID3D10Blob **ppErrors, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10CreateEffectPoolFromResourceA(HMODULE hModule, LPCSTR pResourceName, LPCSTR pSrcFileName, CONST D3D10_SHADER_MACRO *pDefines,
+ ID3D10Include *pInclude, LPCSTR pProfile, UINT HLSLFlags, UINT FXFlags, ID3D10Device *pDevice,
+ ID3DX10ThreadPump* pPump, ID3D10EffectPool **ppEffectPool, ID3D10Blob **ppErrors, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10CreateEffectPoolFromResourceW(HMODULE hModule, LPCWSTR pResourceName, LPCWSTR pSrcFileName, CONST D3D10_SHADER_MACRO *pDefines,
+ ID3D10Include *pInclude, LPCSTR pProfile, UINT HLSLFlags, UINT FXFlags, ID3D10Device *pDevice,
+ ID3DX10ThreadPump* pPump, ID3D10EffectPool **ppEffectPool, ID3D10Blob **ppErrors, HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX10CreateEffectPoolFromFile D3DX10CreateEffectPoolFromFileW
+#define D3DX10CreateEffectPoolFromResource D3DX10CreateEffectPoolFromResourceW
+#else
+#define D3DX10CreateEffectPoolFromFile D3DX10CreateEffectPoolFromFileA
+#define D3DX10CreateEffectPoolFromResource D3DX10CreateEffectPoolFromResourceA
+#endif
+
+HRESULT WINAPI D3DX10PreprocessShaderFromFileA(LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, ID3DX10ThreadPump *pPump, ID3D10Blob** ppShaderText, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10PreprocessShaderFromFileW(LPCWSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, ID3DX10ThreadPump *pPump, ID3D10Blob** ppShaderText, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10PreprocessShaderFromMemory(LPCSTR pSrcData, SIZE_T SrcDataSize, LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, ID3DX10ThreadPump *pPump, ID3D10Blob** ppShaderText, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10PreprocessShaderFromResourceA(HMODULE hModule, LPCSTR pResourceName, LPCSTR pSrcFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, ID3DX10ThreadPump *pPump, ID3D10Blob** ppShaderText, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+HRESULT WINAPI D3DX10PreprocessShaderFromResourceW(HMODULE hModule, LPCWSTR pResourceName, LPCWSTR pSrcFileName, CONST D3D10_SHADER_MACRO* pDefines,
+ LPD3D10INCLUDE pInclude, ID3DX10ThreadPump *pPump, ID3D10Blob** ppShaderText, ID3D10Blob** ppErrorMsgs, HRESULT* pHResult);
+
+#ifdef UNICODE
+#define D3DX10PreprocessShaderFromFile D3DX10PreprocessShaderFromFileW
+#define D3DX10PreprocessShaderFromResource D3DX10PreprocessShaderFromResourceW
+#else
+#define D3DX10PreprocessShaderFromFile D3DX10PreprocessShaderFromFileA
+#define D3DX10PreprocessShaderFromResource D3DX10PreprocessShaderFromResourceA
+#endif
+
+//----------------------------------------------------------------------------
+// Async processors
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3DX10CreateAsyncCompilerProcessor(LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags1, UINT Flags2,
+ ID3D10Blob **ppCompiledShader, ID3D10Blob **ppErrorBuffer, ID3DX10DataProcessor **ppProcessor);
+
+HRESULT WINAPI D3DX10CreateAsyncEffectCreateProcessor(LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ LPCSTR pProfile, UINT Flags, UINT FXFlags, ID3D10Device *pDevice,
+ ID3D10EffectPool *pPool, ID3D10Blob **ppErrorBuffer, ID3DX10DataProcessor **ppProcessor);
+
+HRESULT WINAPI D3DX10CreateAsyncEffectPoolCreateProcessor(LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ LPCSTR pProfile, UINT Flags, UINT FXFlags, ID3D10Device *pDevice,
+ ID3D10Blob **ppErrorBuffer, ID3DX10DataProcessor **ppProcessor);
+
+HRESULT WINAPI D3DX10CreateAsyncShaderPreprocessProcessor(LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,
+ ID3D10Blob** ppShaderText, ID3D10Blob **ppErrorBuffer, ID3DX10DataProcessor **ppProcessor);
+
+
+
+//----------------------------------------------------------------------------
+// D3DX10 Asynchronous texture I/O (advanced mode)
+//----------------------------------------------------------------------------
+
+HRESULT WINAPI D3DX10CreateAsyncFileLoaderW(LPCWSTR pFileName, ID3DX10DataLoader **ppDataLoader);
+HRESULT WINAPI D3DX10CreateAsyncFileLoaderA(LPCSTR pFileName, ID3DX10DataLoader **ppDataLoader);
+HRESULT WINAPI D3DX10CreateAsyncMemoryLoader(LPCVOID pData, SIZE_T cbData, ID3DX10DataLoader **ppDataLoader);
+HRESULT WINAPI D3DX10CreateAsyncResourceLoaderW(HMODULE hSrcModule, LPCWSTR pSrcResource, ID3DX10DataLoader **ppDataLoader);
+HRESULT WINAPI D3DX10CreateAsyncResourceLoaderA(HMODULE hSrcModule, LPCSTR pSrcResource, ID3DX10DataLoader **ppDataLoader);
+
+#ifdef UNICODE
+#define D3DX10CreateAsyncFileLoader D3DX10CreateAsyncFileLoaderW
+#define D3DX10CreateAsyncResourceLoader D3DX10CreateAsyncResourceLoaderW
+#else
+#define D3DX10CreateAsyncFileLoader D3DX10CreateAsyncFileLoaderA
+#define D3DX10CreateAsyncResourceLoader D3DX10CreateAsyncResourceLoaderA
+#endif
+
+HRESULT WINAPI D3DX10CreateAsyncTextureProcessor(ID3D10Device *pDevice, D3DX10_IMAGE_LOAD_INFO *pLoadInfo, ID3DX10DataProcessor **ppDataProcessor);
+HRESULT WINAPI D3DX10CreateAsyncTextureInfoProcessor(D3DX10_IMAGE_INFO *pImageInfo, ID3DX10DataProcessor **ppDataProcessor);
+HRESULT WINAPI D3DX10CreateAsyncShaderResourceViewProcessor(ID3D10Device *pDevice, D3DX10_IMAGE_LOAD_INFO *pLoadInfo, ID3DX10DataProcessor **ppDataProcessor);
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+
+#endif //__D3DX10ASYNC_H__
+
+
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-11 17:19:02 +0000