[DXSDK]
authorAmine Khaldi <amine.khaldi@reactos.org>
Sat, 19 Apr 2014 18:48:40 +0000 (18:48 +0000)
committerAmine Khaldi <amine.khaldi@reactos.org>
Sat, 19 Apr 2014 18:48:40 +0000 (18:48 +0000)
* Sync the d3dx9 headers with Wine 1.7.17.
CORE-8080

svn path=/trunk/; revision=62817

reactos/include/dxsdk/d3dx9anim.h
reactos/include/dxsdk/d3dx9core.h
reactos/include/dxsdk/d3dx9effect.h
reactos/include/dxsdk/d3dx9math.h
reactos/include/dxsdk/d3dx9math.inl
reactos/include/dxsdk/d3dx9mesh.h
reactos/include/dxsdk/d3dx9shader.h
reactos/include/dxsdk/d3dx9tex.h
reactos/include/dxsdk/d3dx9xof.h

index 2ae780d..b5f2232 100644 (file)
@@ -92,7 +92,7 @@ typedef struct _D3DXMESHDATA
 
 typedef struct _D3DXMESHCONTAINER
 {
-    LPSTR Name;
+    char *Name;
     D3DXMESHDATA MeshData;
     LPD3DXMATERIAL pMaterials;
     LPD3DXEFFECTINSTANCE pEffects;
@@ -104,7 +104,7 @@ typedef struct _D3DXMESHCONTAINER
 
 typedef struct _D3DXFRAME
 {
-    LPSTR Name;
+    char *Name;
     D3DXMATRIX TransformationMatrix;
     LPD3DXMESHCONTAINER pMeshContainer;
     struct _D3DXFRAME *pFrameSibling;
@@ -125,8 +125,8 @@ typedef struct _D3DXKEY_QUATERNION
 
 typedef struct _D3DXKEY_CALLBACK
 {
-    FLOAT Time;
-    LPVOID pCallbackData;
+    float Time;
+    void *pCallbackData;
 } D3DXKEY_CALLBACK, *LPD3DXKEY_CALLBACK;
 
 typedef struct _D3DXTRACK_DESC
@@ -170,7 +170,7 @@ typedef interface ID3DXAnimationController *LPD3DXANIMATIONCONTROLLER;
 #define INTERFACE ID3DXAllocateHierarchy
 DECLARE_INTERFACE(ID3DXAllocateHierarchy)
 {
-    STDMETHOD(CreateFrame)(THIS_ LPCSTR Name, LPD3DXFRAME *new_frame) PURE;
+    STDMETHOD(CreateFrame)(THIS_ const char *name, D3DXFRAME **new_frame) PURE;
     STDMETHOD(CreateMeshContainer)(THIS_ const char *name, const D3DXMESHDATA *mesh_data,
             const D3DXMATERIAL *materials, const D3DXEFFECTINSTANCE *effect_instances,
             DWORD num_materials, const DWORD *adjacency, ID3DXSkinInfo *skin_info,
@@ -207,20 +207,20 @@ DECLARE_INTERFACE(ID3DXSaveUserData)
 DECLARE_INTERFACE_(ID3DXAnimationSet, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXAnimationSet methods ***/
-    STDMETHOD_(LPCSTR, GetName)(THIS) PURE;
+    STDMETHOD_(const char *, GetName)(THIS) PURE;
     STDMETHOD_(DOUBLE, GetPeriod)(THIS) PURE;
     STDMETHOD_(DOUBLE, GetPeriodicPosition)(THIS_ DOUBLE position) PURE;
     STDMETHOD_(UINT, GetNumAnimations)(THIS) PURE;
-    STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT index, LPCSTR *name) PURE;
-    STDMETHOD(GetAnimationIndexByName)(THIS_ LPCSTR name, UINT *index) PURE;
+    STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT index, const char **name) PURE;
+    STDMETHOD(GetAnimationIndexByName)(THIS_ const char *name, UINT *index) PURE;
     STDMETHOD(GetSRT)(THIS_ DOUBLE periodic_position, UINT animation, D3DXVECTOR3 *scale,
             D3DXQUATERNION *rotation, D3DXVECTOR3 *translation) PURE;
-    STDMETHOD(GetCallback)(THIS_ DOUBLE position, DWORD flags, DOUBLE *callback_position,
-            LPVOID *callback_data) PURE;
+    STDMETHOD(GetCallback)(THIS_ double position, DWORD flags, double *callback_position,
+            void **callback_data) PURE;
 };
 #undef INTERFACE
 
@@ -228,20 +228,20 @@ DECLARE_INTERFACE_(ID3DXAnimationSet, IUnknown)
 DECLARE_INTERFACE_(ID3DXKeyframedAnimationSet, ID3DXAnimationSet)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXAnimationSet methods ***/
-    STDMETHOD_(LPCSTR, GetName)(THIS) PURE;
+    STDMETHOD_(const char *, GetName)(THIS) PURE;
     STDMETHOD_(DOUBLE, GetPeriod)(THIS) PURE;
     STDMETHOD_(DOUBLE, GetPeriodicPosition)(THIS_ DOUBLE position) PURE;
     STDMETHOD_(UINT, GetNumAnimations)(THIS) PURE;
-    STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT index, LPCSTR *name) PURE;
-    STDMETHOD(GetAnimationIndexByName)(THIS_ LPCSTR name, UINT *index) PURE;
+    STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT index, const char **name) PURE;
+    STDMETHOD(GetAnimationIndexByName)(THIS_ const char *name, UINT *index) PURE;
     STDMETHOD(GetSRT)(THIS_ DOUBLE periodic_position, UINT animation, D3DXVECTOR3 *scale,
             D3DXQUATERNION *rotation, D3DXVECTOR3 *translation) PURE;
-    STDMETHOD(GetCallback)(THIS_ DOUBLE position, DWORD flags, DOUBLE *callback_position,
-            LPVOID *callback_data) PURE;
+    STDMETHOD(GetCallback)(THIS_ double position, DWORD flags, double *callback_position,
+            void **callback_data) PURE;
     /*** ID3DXKeyframedAnimationSet methods ***/
     STDMETHOD_(D3DXPLAYBACK_TYPE, GetPlaybackType)(THIS) PURE;
     STDMETHOD_(DOUBLE, GetSourceTicksPerSecond)(THIS) PURE;
@@ -264,9 +264,9 @@ DECLARE_INTERFACE_(ID3DXKeyframedAnimationSet, ID3DXAnimationSet)
     STDMETHOD(UnregisterScaleKey)(THIS_ UINT animation, UINT key) PURE;
     STDMETHOD(UnregisterRotationKey)(THIS_ UINT animation, UINT key) PURE;
     STDMETHOD(UnregisterTranslationKey)(THIS_ UINT animation, UINT key) PURE;
-    STDMETHOD(RegisterAnimationSRTKeys)(THIS_ LPCSTR name, UINT num_scale_keys,
-            UINT num_rotation_keys, UINT num_translation_keys, CONST D3DXKEY_VECTOR3 *scale_keys,
-            CONST D3DXKEY_QUATERNION *rotation_keys, CONST D3DXKEY_VECTOR3 *translation_keys,
+    STDMETHOD(RegisterAnimationSRTKeys)(THIS_ const char *name, UINT num_scale_keys,
+            UINT num_rotation_keys, UINT num_translation_keys, const D3DXKEY_VECTOR3 *scale_keys,
+            const D3DXKEY_QUATERNION *rotation_keys, const D3DXKEY_VECTOR3 *translation_keys,
             DWORD *animation_index) PURE;
     STDMETHOD(Compress)(THIS_ DWORD flags, float lossiness, D3DXFRAME *hierarchy,
             ID3DXBuffer **compressed_data) PURE;
@@ -278,20 +278,20 @@ DECLARE_INTERFACE_(ID3DXKeyframedAnimationSet, ID3DXAnimationSet)
 DECLARE_INTERFACE_(ID3DXCompressedAnimationSet, ID3DXAnimationSet)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXAnimationSet methods ***/
-    STDMETHOD_(LPCSTR, GetName)(THIS) PURE;
+    STDMETHOD_(const char *, GetName)(THIS) PURE;
     STDMETHOD_(DOUBLE, GetPeriod)(THIS) PURE;
     STDMETHOD_(DOUBLE, GetPeriodicPosition)(THIS_ DOUBLE position) PURE;
     STDMETHOD_(UINT, GetNumAnimations)(THIS) PURE;
-    STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT index, LPCSTR *name) PURE;
-    STDMETHOD(GetAnimationIndexByName)(THIS_ LPCSTR name, UINT *index) PURE;
+    STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT index, const char **name) PURE;
+    STDMETHOD(GetAnimationIndexByName)(THIS_ const char *name, UINT *index) PURE;
     STDMETHOD(GetSRT)(THIS_ DOUBLE periodic_position, UINT animation, D3DXVECTOR3 *scale,
             D3DXQUATERNION *rotation, D3DXVECTOR3 *translation) PURE;
-    STDMETHOD(GetCallback)(THIS_ DOUBLE position, DWORD flags, DOUBLE *callback_position,
-            LPVOID *callback_data) PURE;
+    STDMETHOD(GetCallback)(THIS_ double position, DWORD flags, double *callback_position,
+            void **callback_data) PURE;
     /*** ID3DXCompressedAnimationSet methods ***/
     STDMETHOD_(D3DXPLAYBACK_TYPE, GetPlaybackType)(THIS) PURE;
     STDMETHOD_(DOUBLE, GetSourceTicksPerSecond)(THIS) PURE;
@@ -304,7 +304,7 @@ DECLARE_INTERFACE_(ID3DXCompressedAnimationSet, ID3DXAnimationSet)
 #define INTERFACE ID3DXAnimationCallbackHandler
 DECLARE_INTERFACE(ID3DXAnimationCallbackHandler)
 {
-    STDMETHOD(HandleCallback)(THIS_ UINT track, LPVOID callback_data) PURE;
+    STDMETHOD(HandleCallback)(THIS_ UINT track, void *callback_data) PURE;
 };
 #undef INTERFACE
 
@@ -312,7 +312,7 @@ DECLARE_INTERFACE(ID3DXAnimationCallbackHandler)
 DECLARE_INTERFACE_(ID3DXAnimationController, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXAnimationController methods ***/
@@ -320,7 +320,7 @@ DECLARE_INTERFACE_(ID3DXAnimationController, IUnknown)
     STDMETHOD_(UINT, GetMaxNumAnimationSets)(THIS) PURE;
     STDMETHOD_(UINT, GetMaxNumTracks)(THIS) PURE;
     STDMETHOD_(UINT, GetMaxNumEvents)(THIS) PURE;
-    STDMETHOD(RegisterAnimationOutput)(THIS_ LPCSTR name, D3DXMATRIX *matrix,
+    STDMETHOD(RegisterAnimationOutput)(THIS_ const char *name, D3DXMATRIX *matrix,
             D3DXVECTOR3 *scale, D3DXQUATERNION *rotation, D3DXVECTOR3 *translation) PURE;
     STDMETHOD(RegisterAnimationSet)(THIS_ ID3DXAnimationSet *anim_set) PURE;
     STDMETHOD(UnregisterAnimationSet)(THIS_ ID3DXAnimationSet *anim_set) PURE;
@@ -386,11 +386,12 @@ HRESULT WINAPI D3DXSaveMeshHierarchyToFileW(const WCHAR *filename, DWORD format,
         ID3DXSaveUserData *user_data_saver);
 #define D3DXSaveMeshHierarchyToFile WINELIB_NAME_AW(D3DXSaveMeshHierarchyToFile)
 HRESULT WINAPI D3DXFrameDestroy(D3DXFRAME *frame_root, ID3DXAllocateHierarchy *alloc);
-HRESULT WINAPI D3DXFrameAppendChild(LPD3DXFRAME, CONST D3DXFRAME*);
-LPD3DXFRAME WINAPI D3DXFrameFind(CONST D3DXFRAME*, LPCSTR);
+HRESULT WINAPI D3DXFrameAppendChild(D3DXFRAME *parent, const D3DXFRAME *child);
+D3DXFRAME * WINAPI D3DXFrameFind(const D3DXFRAME *root, const char *name);
 HRESULT WINAPI D3DXFrameRegisterNamedMatrices(D3DXFRAME *frame_root, ID3DXAnimationController *animation_controller);
-UINT WINAPI D3DXFrameNumNamedMatrices(CONST D3DXFRAME *frame_root);
-HRESULT WINAPI D3DXFrameCalculateBoundingSphere(CONST D3DXFRAME*, LPD3DXVECTOR3, FLOAT*);
+UINT WINAPI D3DXFrameNumNamedMatrices(const D3DXFRAME *frame_root);
+HRESULT WINAPI D3DXFrameCalculateBoundingSphere(const D3DXFRAME *frame_root, D3DXVECTOR3 *center,
+        FLOAT *radius);
 HRESULT WINAPI D3DXCreateKeyframedAnimationSet(const char *name, double ticks_per_second,
         D3DXPLAYBACK_TYPE playback_type, UINT animation_count, UINT callback_key_count,
         const D3DXKEY_CALLBACK *callback_keys, ID3DXKeyframedAnimationSet **animation_set);
index c28fe71..5233317 100644 (file)
@@ -27,7 +27,9 @@
 /* D3DX_VERSION will be completely ignored since we are
     implementing all dlls from d3dx9_24 to d3dx9_36 */
 #define D3DX_VERSION 0x0902
+#ifndef D3DX_SDK_VERSION
 #define D3DX_SDK_VERSION 36
+#endif
 #define D3DXSPRITE_DONOTSAVESTATE          0x00000001
 #define D3DXSPRITE_DONOTMODIFY_RENDERSTATE 0x00000002
 #define D3DXSPRITE_OBJECTSPACE             0x00000004
@@ -65,11 +67,11 @@ typedef struct ID3DXSprite *LPD3DXSPRITE;
 DECLARE_INTERFACE_(ID3DXBuffer, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID *object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXBuffer methods ***/
-    STDMETHOD_(LPVOID, GetBufferPointer)(THIS) PURE;
+    STDMETHOD_(void *, GetBufferPointer)(THIS) PURE;
     STDMETHOD_(DWORD, GetBufferSize)(THIS) PURE;
 };
 #undef INTERFACE
@@ -127,7 +129,7 @@ DECL_WINELIB_TYPE_AW(LPD3DXFONT_DESC)
 DECLARE_INTERFACE_(ID3DXFont, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID *object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXFont methods ***/
@@ -143,7 +145,7 @@ DECLARE_INTERFACE_(ID3DXFont, IUnknown)
 
     STDMETHOD(PreloadCharacters)(THIS_ UINT first, UINT last) PURE;
     STDMETHOD(PreloadGlyphs)(THIS_ UINT first, UINT last) PURE;
-    STDMETHOD(PreloadTextA)(THIS_ LPCSTR string, INT count) PURE;
+    STDMETHOD(PreloadTextA)(THIS_ const char *string, INT count) PURE;
     STDMETHOD(PreloadTextW)(THIS_ const WCHAR *string, INT count) PURE;
 
     STDMETHOD_(INT, DrawTextA)(THIS_ struct ID3DXSprite *sprite, const char *string,
@@ -209,7 +211,7 @@ DECLARE_INTERFACE_(ID3DXFont, IUnknown)
 DECLARE_INTERFACE_(ID3DXLine, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID *object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
 
@@ -217,9 +219,9 @@ DECLARE_INTERFACE_(ID3DXLine, IUnknown)
     STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE;
 
     STDMETHOD(Begin)(THIS) PURE;
-    STDMETHOD(Draw)(THIS_ CONST D3DXVECTOR2 *vertexlist, DWORD vertexlistcount, D3DCOLOR color) PURE;
-    STDMETHOD(DrawTransform)(THIS_ CONST D3DXVECTOR3 *vertexlist, DWORD vertexlistcount,
-                             CONST D3DXMATRIX *transform, D3DCOLOR color) PURE;
+    STDMETHOD(Draw)(THIS_ const D3DXVECTOR2 *vertexlist, DWORD vertexlistcount, D3DCOLOR color) PURE;
+    STDMETHOD(DrawTransform)(THIS_ const D3DXVECTOR3 *vertexlist, DWORD vertexlistcount,
+            const D3DXMATRIX *transform, D3DCOLOR color) PURE;
     STDMETHOD(SetPattern)(THIS_ DWORD pattern) PURE;
     STDMETHOD_(DWORD, GetPattern)(THIS) PURE;
     STDMETHOD(SetPatternScale)(THIS_ FLOAT scale) PURE;
@@ -298,7 +300,7 @@ typedef struct _D3DXRTE_DESC
 DECLARE_INTERFACE_(ID3DXRenderToEnvMap, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID *object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
 
@@ -366,7 +368,7 @@ typedef struct _D3DXRTS_DESC
 DECLARE_INTERFACE_(ID3DXRenderToSurface, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID *object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXRenderToSurface methods ***/
@@ -411,16 +413,16 @@ DECLARE_INTERFACE_(ID3DXRenderToSurface, IUnknown)
 DECLARE_INTERFACE_(ID3DXSprite, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID *object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **object) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXSprite methods ***/
     STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE;
 
     STDMETHOD(GetTransform)(THIS_ D3DXMATRIX *transform) PURE;
-    STDMETHOD(SetTransform)(THIS_ CONST D3DXMATRIX *transform) PURE;
-    STDMETHOD(SetWorldViewRH)(THIS_ CONST D3DXMATRIX *world, CONST D3DXMATRIX *view) PURE;
-    STDMETHOD(SetWorldViewLH)(THIS_ CONST D3DXMATRIX *world, CONST D3DXMATRIX *view) PURE;
+    STDMETHOD(SetTransform)(THIS_ const D3DXMATRIX *transform) PURE;
+    STDMETHOD(SetWorldViewRH)(THIS_ const D3DXMATRIX *world, const D3DXMATRIX *view) PURE;
+    STDMETHOD(SetWorldViewLH)(THIS_ const D3DXMATRIX *world, const D3DXMATRIX *view) PURE;
 
     STDMETHOD(Begin)(THIS_ DWORD flags) PURE;
     STDMETHOD(Draw)(THIS_ struct IDirect3DTexture9 *texture, const RECT *rect,
index 0fd27ff..25d1fd2 100644 (file)
 #define D3DX_PARAMETER_LITERAL      2
 #define D3DX_PARAMETER_ANNOTATION   4
 
-typedef struct _D3DXEFFECT_DESC {
-    LPCSTR Creator;
+typedef struct _D3DXEFFECT_DESC
+{
+    const char *Creator;
     UINT Parameters;
     UINT Techniques;
     UINT Functions;
 } D3DXEFFECT_DESC;
 
-typedef struct _D3DXPARAMETER_DESC {
-    LPCSTR Name;
-    LPCSTR Semantic;
+typedef struct _D3DXPARAMETER_DESC
+{
+    const char *Name;
+    const char *Semantic;
     D3DXPARAMETER_CLASS Class;
     D3DXPARAMETER_TYPE Type;
     UINT Rows;
@@ -52,21 +54,24 @@ typedef struct _D3DXPARAMETER_DESC {
     UINT Bytes;
 } D3DXPARAMETER_DESC;
 
-typedef struct _D3DXTECHNIQUE_DESC {
-    LPCSTR Name;
+typedef struct _D3DXTECHNIQUE_DESC
+{
+    const char *Name;
     UINT Passes;
     UINT Annotations;
 } D3DXTECHNIQUE_DESC;
 
-typedef struct _D3DXPASS_DESC {
-    LPCSTR Name;
+typedef struct _D3DXPASS_DESC
+{
+    const char *Name;
     UINT Annotations;
-    CONST DWORD *pVertexShaderFunction;
-    CONST DWORD *pPixelShaderFunction;
+    const DWORD *pVertexShaderFunction;
+    const DWORD *pPixelShaderFunction;
 } D3DXPASS_DESC;
 
-typedef struct _D3DXFUNCTION_DESC {
-    LPCSTR Name;
+typedef struct _D3DXFUNCTION_DESC
+{
+    const char *Name;
     UINT Annotations;
 } D3DXFUNCTION_DESC;
 
@@ -80,7 +85,7 @@ DEFINE_GUID(IID_ID3DXEffectPool, 0x9537ab04, 0x3250, 0x412e, 0x82, 0x13, 0xfc, 0
 DECLARE_INTERFACE_(ID3DXEffectPool, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
 };
@@ -95,7 +100,7 @@ DEFINE_GUID(IID_ID3DXBaseEffect, 0x17c18ac, 0x103f, 0x4417, 0x8c, 0x51, 0x6b, 0x
 DECLARE_INTERFACE_(ID3DXBaseEffect, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXBaseEffect methods ***/
@@ -105,49 +110,49 @@ DECLARE_INTERFACE_(ID3DXBaseEffect, IUnknown)
     STDMETHOD(GetPassDesc)(THIS_ D3DXHANDLE pass, D3DXPASS_DESC* desc) PURE;
     STDMETHOD(GetFunctionDesc)(THIS_ D3DXHANDLE shader, D3DXFUNCTION_DESC* desc) PURE;
     STDMETHOD_(D3DXHANDLE, GetParameter)(THIS_ D3DXHANDLE parameter, UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetParameterByName)(THIS_ D3DXHANDLE parameter, LPCSTR name) PURE;
-    STDMETHOD_(D3DXHANDLE, GetParameterBySemantic)(THIS_ D3DXHANDLE parameter, LPCSTR semantic) PURE;
+    STDMETHOD_(D3DXHANDLE, GetParameterByName)(THIS_ D3DXHANDLE parameter, const char *name) PURE;
+    STDMETHOD_(D3DXHANDLE, GetParameterBySemantic)(THIS_ D3DXHANDLE parameter, const char *semantic) PURE;
     STDMETHOD_(D3DXHANDLE, GetParameterElement)(THIS_ D3DXHANDLE parameter, UINT index) PURE;
     STDMETHOD_(D3DXHANDLE, GetTechnique)(THIS_ UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetTechniqueByName)(THIS_ LPCSTR name) PURE;
+    STDMETHOD_(D3DXHANDLE, GetTechniqueByName)(THIS_ const char *name) PURE;
     STDMETHOD_(D3DXHANDLE, GetPass)(THIS_ D3DXHANDLE technique, UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetPassByName)(THIS_ D3DXHANDLE technique, LPCSTR name) PURE;
+    STDMETHOD_(D3DXHANDLE, GetPassByName)(THIS_ D3DXHANDLE technique, const char *name) PURE;
     STDMETHOD_(D3DXHANDLE, GetFunction)(THIS_ UINT index);
-    STDMETHOD_(D3DXHANDLE, GetFunctionByName)(THIS_ LPCSTR name);
+    STDMETHOD_(D3DXHANDLE, GetFunctionByName)(THIS_ const char *name);
     STDMETHOD_(D3DXHANDLE, GetAnnotation)(THIS_ D3DXHANDLE object, UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetAnnotationByName)(THIS_ D3DXHANDLE object, LPCSTR name) PURE;
-    STDMETHOD(SetValue)(THIS_ D3DXHANDLE parameter, LPCVOID data, UINT bytes) PURE;
-    STDMETHOD(GetValue)(THIS_ D3DXHANDLE parameter, LPVOID data, UINT bytes) PURE;
+    STDMETHOD_(D3DXHANDLE, GetAnnotationByName)(THIS_ D3DXHANDLE object, const char *name) PURE;
+    STDMETHOD(SetValue)(THIS_ D3DXHANDLE parameter, const void *data, UINT bytes) PURE;
+    STDMETHOD(GetValue)(THIS_ D3DXHANDLE parameter, void *data, UINT bytes) PURE;
     STDMETHOD(SetBool)(THIS_ D3DXHANDLE parameter, BOOL b) PURE;
     STDMETHOD(GetBool)(THIS_ D3DXHANDLE parameter, BOOL* b) PURE;
-    STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE parameter, CONST BOOL* b, UINT count) PURE;
+    STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE parameter, const BOOL *b, UINT count) PURE;
     STDMETHOD(GetBoolArray)(THIS_ D3DXHANDLE parameter, BOOL* b, UINT count) PURE;
     STDMETHOD(SetInt)(THIS_ D3DXHANDLE parameter, INT n) PURE;
     STDMETHOD(GetInt)(THIS_ D3DXHANDLE parameter, INT* n) PURE;
-    STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE parameter, CONST INT* n, UINT count) PURE;
+    STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE parameter, const INT *n, UINT count) PURE;
     STDMETHOD(GetIntArray)(THIS_ D3DXHANDLE parameter, INT* n, UINT count) PURE;
     STDMETHOD(SetFloat)(THIS_ D3DXHANDLE parameter, FLOAT f) PURE;
     STDMETHOD(GetFloat)(THIS_ D3DXHANDLE parameter, FLOAT* f) PURE;
-    STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE parameter, CONST FLOAT* f, UINT count) PURE;
+    STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE parameter, const FLOAT *f, UINT count) PURE;
     STDMETHOD(GetFloatArray)(THIS_ D3DXHANDLE parameter, FLOAT* f, UINT count) PURE;
-    STDMETHOD(SetVector)(THIS_ D3DXHANDLE parameter, CONST D3DXVECTOR4* vector) PURE;
+    STDMETHOD(SetVector)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector) PURE;
     STDMETHOD(GetVector)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector) PURE;
-    STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE parameter, CONST D3DXVECTOR4* vector, UINT count) PURE;
+    STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector, UINT count) PURE;
     STDMETHOD(GetVectorArray)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector, UINT count) PURE;
-    STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix) PURE;
+    STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE;
     STDMETHOD(GetMatrix)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE;
-    STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE;
     STDMETHOD(GetMatrixArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE;
-    STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX** matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE;
     STDMETHOD(GetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE;
-    STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix) PURE;
+    STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE;
     STDMETHOD(GetMatrixTranspose)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE;
-    STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE;
     STDMETHOD(GetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE;
-    STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX** matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE;
     STDMETHOD(GetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE;
-    STDMETHOD(SetString)(THIS_ D3DXHANDLE parameter, LPCSTR string) PURE;
-    STDMETHOD(GetString)(THIS_ D3DXHANDLE parameter, LPCSTR* string) PURE;
+    STDMETHOD(SetString)(THIS_ D3DXHANDLE parameter, const char *string) PURE;
+    STDMETHOD(GetString)(THIS_ D3DXHANDLE parameter, const char **string) PURE;
     STDMETHOD(SetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 *texture) PURE;
     STDMETHOD(GetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 **texture) PURE;
     STDMETHOD(GetPixelShader)(THIS_ D3DXHANDLE parameter, struct IDirect3DPixelShader9 **shader) PURE;
@@ -165,13 +170,13 @@ DEFINE_GUID(IID_ID3DXEffectStateManager, 0x79aab587, 0x6dbc, 0x4fa7, 0x82, 0xde,
 DECLARE_INTERFACE_(ID3DXEffectStateManager, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXEffectStateManager methods ***/
-    STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, CONST D3DMATRIX* matrix) PURE;
-    STDMETHOD(SetMaterial)(THIS_ CONST D3DMATERIAL9* material) PURE;
-    STDMETHOD(SetLight)(THIS_ DWORD index, CONST D3DLIGHT9* light) PURE;
+    STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) PURE;
+    STDMETHOD(SetMaterial)(THIS_ const D3DMATERIAL9 *material) PURE;
+    STDMETHOD(SetLight)(THIS_ DWORD index, const D3DLIGHT9 *light) PURE;
     STDMETHOD(LightEnable)(THIS_ DWORD index, BOOL enable) PURE;
     STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE state, DWORD value) PURE;
     STDMETHOD(SetTexture)(THIS_ DWORD stage, struct IDirect3DBaseTexture9 *texture) PURE;
@@ -180,13 +185,13 @@ DECLARE_INTERFACE_(ID3DXEffectStateManager, IUnknown)
     STDMETHOD(SetNPatchMode)(THIS_ FLOAT num_segments) PURE;
     STDMETHOD(SetFVF)(THIS_ DWORD format) PURE;
     STDMETHOD(SetVertexShader)(THIS_ struct IDirect3DVertexShader9 *shader) PURE;
-    STDMETHOD(SetVertexShaderConstantF)(THIS_ UINT register_index, CONST FLOAT* constant_data, UINT register_count) PURE;
-    STDMETHOD(SetVertexShaderConstantI)(THIS_ UINT register_index, CONST INT* constant_data, UINT register_count) PURE;
-    STDMETHOD(SetVertexShaderConstantB)(THIS_ UINT register_index, CONST BOOL* constant_data, UINT register_count) PURE;
+    STDMETHOD(SetVertexShaderConstantF)(THIS_ UINT register_index, const FLOAT *constant_data, UINT register_count) PURE;
+    STDMETHOD(SetVertexShaderConstantI)(THIS_ UINT register_index, const INT *constant_data, UINT register_count) PURE;
+    STDMETHOD(SetVertexShaderConstantB)(THIS_ UINT register_index, const BOOL *constant_data, UINT register_count) PURE;
     STDMETHOD(SetPixelShader)(THIS_ struct IDirect3DPixelShader9 *shader) PURE;
-    STDMETHOD(SetPixelShaderConstantF)(THIS_ UINT register_index, CONST FLOAT* constant_data, UINT register_count) PURE;
-    STDMETHOD(SetPixelShaderConstantI)(THIS_ UINT register_index, CONST INT * constant_data, UINT register_count) PURE;
-    STDMETHOD(SetPixelShaderConstantB)(THIS_ UINT register_index, CONST BOOL* constant_data, UINT register_count) PURE;
+    STDMETHOD(SetPixelShaderConstantF)(THIS_ UINT register_index, const FLOAT *constant_data, UINT register_count) PURE;
+    STDMETHOD(SetPixelShaderConstantI)(THIS_ UINT register_index, const INT *constant_data, UINT register_count) PURE;
+    STDMETHOD(SetPixelShaderConstantB)(THIS_ UINT register_index, const BOOL *constant_data, UINT register_count) PURE;
 };
 #undef INTERFACE
 
@@ -199,7 +204,7 @@ DEFINE_GUID(IID_ID3DXEffect, 0xf6ceb4b3, 0x4e4c, 0x40dd, 0xb8, 0x83, 0x8d, 0x8d,
 DECLARE_INTERFACE_(ID3DXEffect, ID3DXBaseEffect)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXBaseEffect methods ***/
@@ -209,49 +214,49 @@ DECLARE_INTERFACE_(ID3DXEffect, ID3DXBaseEffect)
     STDMETHOD(GetPassDesc)(THIS_ D3DXHANDLE pass, D3DXPASS_DESC* desc) PURE;
     STDMETHOD(GetFunctionDesc)(THIS_ D3DXHANDLE shader, D3DXFUNCTION_DESC* desc) PURE;
     STDMETHOD_(D3DXHANDLE, GetParameter)(THIS_ D3DXHANDLE parameter, UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetParameterByName)(THIS_ D3DXHANDLE parameter, LPCSTR name) PURE;
-    STDMETHOD_(D3DXHANDLE, GetParameterBySemantic)(THIS_ D3DXHANDLE parameter, LPCSTR semantic) PURE;
+    STDMETHOD_(D3DXHANDLE, GetParameterByName)(THIS_ D3DXHANDLE parameter, const char *name) PURE;
+    STDMETHOD_(D3DXHANDLE, GetParameterBySemantic)(THIS_ D3DXHANDLE parameter, const char *semantic) PURE;
     STDMETHOD_(D3DXHANDLE, GetParameterElement)(THIS_ D3DXHANDLE parameter, UINT index) PURE;
     STDMETHOD_(D3DXHANDLE, GetTechnique)(THIS_ UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetTechniqueByName)(THIS_ LPCSTR name) PURE;
+    STDMETHOD_(D3DXHANDLE, GetTechniqueByName)(THIS_ const char *name) PURE;
     STDMETHOD_(D3DXHANDLE, GetPass)(THIS_ D3DXHANDLE technique, UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetPassByName)(THIS_ D3DXHANDLE technique, LPCSTR name) PURE;
+    STDMETHOD_(D3DXHANDLE, GetPassByName)(THIS_ D3DXHANDLE technique, const char *name) PURE;
     STDMETHOD_(D3DXHANDLE, GetFunction)(THIS_ UINT index);
-    STDMETHOD_(D3DXHANDLE, GetFunctionByName)(THIS_ LPCSTR name);
+    STDMETHOD_(D3DXHANDLE, GetFunctionByName)(THIS_ const char *name);
     STDMETHOD_(D3DXHANDLE, GetAnnotation)(THIS_ D3DXHANDLE object, UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetAnnotationByName)(THIS_ D3DXHANDLE object, LPCSTR name) PURE;
-    STDMETHOD(SetValue)(THIS_ D3DXHANDLE parameter, LPCVOID data, UINT bytes) PURE;
-    STDMETHOD(GetValue)(THIS_ D3DXHANDLE parameter, LPVOID data, UINT bytes) PURE;
+    STDMETHOD_(D3DXHANDLE, GetAnnotationByName)(THIS_ D3DXHANDLE object, const char *name) PURE;
+    STDMETHOD(SetValue)(THIS_ D3DXHANDLE parameter, const void *data, UINT bytes) PURE;
+    STDMETHOD(GetValue)(THIS_ D3DXHANDLE parameter, void *data, UINT bytes) PURE;
     STDMETHOD(SetBool)(THIS_ D3DXHANDLE parameter, BOOL b) PURE;
     STDMETHOD(GetBool)(THIS_ D3DXHANDLE parameter, BOOL* b) PURE;
-    STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE parameter, CONST BOOL* b, UINT count) PURE;
+    STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE parameter, const BOOL *b, UINT count) PURE;
     STDMETHOD(GetBoolArray)(THIS_ D3DXHANDLE parameter, BOOL* b, UINT count) PURE;
     STDMETHOD(SetInt)(THIS_ D3DXHANDLE parameter, INT n) PURE;
     STDMETHOD(GetInt)(THIS_ D3DXHANDLE parameter, INT* n) PURE;
-    STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE parameter, CONST INT* n, UINT count) PURE;
+    STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE parameter, const INT *n, UINT count) PURE;
     STDMETHOD(GetIntArray)(THIS_ D3DXHANDLE parameter, INT* n, UINT count) PURE;
     STDMETHOD(SetFloat)(THIS_ D3DXHANDLE parameter, FLOAT f) PURE;
     STDMETHOD(GetFloat)(THIS_ D3DXHANDLE parameter, FLOAT* f) PURE;
-    STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE parameter, CONST FLOAT* f, UINT count) PURE;
+    STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE parameter, const FLOAT *f, UINT count) PURE;
     STDMETHOD(GetFloatArray)(THIS_ D3DXHANDLE parameter, FLOAT* f, UINT count) PURE;
-    STDMETHOD(SetVector)(THIS_ D3DXHANDLE parameter, CONST D3DXVECTOR4* vector) PURE;
+    STDMETHOD(SetVector)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector) PURE;
     STDMETHOD(GetVector)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector) PURE;
-    STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE parameter, CONST D3DXVECTOR4* vector, UINT count) PURE;
+    STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector, UINT count) PURE;
     STDMETHOD(GetVectorArray)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector, UINT count) PURE;
-    STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix) PURE;
+    STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE;
     STDMETHOD(GetMatrix)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE;
-    STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE;
     STDMETHOD(GetMatrixArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE;
-    STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX** matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE;
     STDMETHOD(GetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE;
-    STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix) PURE;
+    STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE;
     STDMETHOD(GetMatrixTranspose)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE;
-    STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE;
     STDMETHOD(GetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE;
-    STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX** matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE;
     STDMETHOD(GetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE;
-    STDMETHOD(SetString)(THIS_ D3DXHANDLE parameter, LPCSTR string) PURE;
-    STDMETHOD(GetString)(THIS_ D3DXHANDLE parameter, LPCSTR* string) PURE;
+    STDMETHOD(SetString)(THIS_ D3DXHANDLE parameter, const char *string) PURE;
+    STDMETHOD(GetString)(THIS_ D3DXHANDLE parameter, const char **string) PURE;
     STDMETHOD(SetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 *texture) PURE;
     STDMETHOD(GetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 **texture) PURE;
     STDMETHOD(GetPixelShader)(THIS_ D3DXHANDLE parameter, struct IDirect3DPixelShader9 **shader) PURE;
@@ -279,7 +284,7 @@ DECLARE_INTERFACE_(ID3DXEffect, ID3DXBaseEffect)
     STDMETHOD(ApplyParameterBlock)(THIS_ D3DXHANDLE parameter_block) PURE;
     STDMETHOD(DeleteParameterBlock)(THIS_ D3DXHANDLE parameter_block) PURE;
     STDMETHOD(CloneEffect)(THIS_ struct IDirect3DDevice9 *device, struct ID3DXEffect **effect) PURE;
-    STDMETHOD(SetRawValue)(THIS_ D3DXHANDLE parameter, LPCVOID data, UINT byte_offset, UINT bytes) PURE;
+    STDMETHOD(SetRawValue)(THIS_ D3DXHANDLE parameter, const void *data, UINT byte_offset, UINT bytes) PURE;
 };
 #undef INTERFACE
 
@@ -292,7 +297,7 @@ DEFINE_GUID(IID_ID3DXEffectCompiler, 0x51b8a949, 0x1a31, 0x47e6, 0xbe, 0xa0, 0x4
 DECLARE_INTERFACE_(ID3DXEffectCompiler, ID3DXBaseEffect)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXBaseEffect methods ***/
@@ -302,49 +307,49 @@ DECLARE_INTERFACE_(ID3DXEffectCompiler, ID3DXBaseEffect)
     STDMETHOD(GetPassDesc)(THIS_ D3DXHANDLE pass, D3DXPASS_DESC* desc) PURE;
     STDMETHOD(GetFunctionDesc)(THIS_ D3DXHANDLE shader, D3DXFUNCTION_DESC* desc) PURE;
     STDMETHOD_(D3DXHANDLE, GetParameter)(THIS_ D3DXHANDLE parameter, UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetParameterByName)(THIS_ D3DXHANDLE parameter, LPCSTR name) PURE;
-    STDMETHOD_(D3DXHANDLE, GetParameterBySemantic)(THIS_ D3DXHANDLE parameter, LPCSTR semantic) PURE;
+    STDMETHOD_(D3DXHANDLE, GetParameterByName)(THIS_ D3DXHANDLE parameter, const char *name) PURE;
+    STDMETHOD_(D3DXHANDLE, GetParameterBySemantic)(THIS_ D3DXHANDLE parameter, const char *semantic) PURE;
     STDMETHOD_(D3DXHANDLE, GetParameterElement)(THIS_ D3DXHANDLE parameter, UINT index) PURE;
     STDMETHOD_(D3DXHANDLE, GetTechnique)(THIS_ UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetTechniqueByName)(THIS_ LPCSTR name) PURE;
+    STDMETHOD_(D3DXHANDLE, GetTechniqueByName)(THIS_ const char *name) PURE;
     STDMETHOD_(D3DXHANDLE, GetPass)(THIS_ D3DXHANDLE technique, UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetPassByName)(THIS_ D3DXHANDLE technique, LPCSTR name) PURE;
+    STDMETHOD_(D3DXHANDLE, GetPassByName)(THIS_ D3DXHANDLE technique, const char *name) PURE;
     STDMETHOD_(D3DXHANDLE, GetFunction)(THIS_ UINT index);
-    STDMETHOD_(D3DXHANDLE, GetFunctionByName)(THIS_ LPCSTR name);
+    STDMETHOD_(D3DXHANDLE, GetFunctionByName)(THIS_ const char *name);
     STDMETHOD_(D3DXHANDLE, GetAnnotation)(THIS_ D3DXHANDLE object, UINT index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetAnnotationByName)(THIS_ D3DXHANDLE object, LPCSTR name) PURE;
-    STDMETHOD(SetValue)(THIS_ D3DXHANDLE parameter, LPCVOID data, UINT bytes) PURE;
-    STDMETHOD(GetValue)(THIS_ D3DXHANDLE parameter, LPVOID data, UINT bytes) PURE;
+    STDMETHOD_(D3DXHANDLE, GetAnnotationByName)(THIS_ D3DXHANDLE object, const char *name) PURE;
+    STDMETHOD(SetValue)(THIS_ D3DXHANDLE parameter, const void *data, UINT bytes) PURE;
+    STDMETHOD(GetValue)(THIS_ D3DXHANDLE parameter, void *data, UINT bytes) PURE;
     STDMETHOD(SetBool)(THIS_ D3DXHANDLE parameter, BOOL b) PURE;
     STDMETHOD(GetBool)(THIS_ D3DXHANDLE parameter, BOOL* b) PURE;
-    STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE parameter, CONST BOOL* b, UINT count) PURE;
+    STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE parameter, const BOOL *b, UINT count) PURE;
     STDMETHOD(GetBoolArray)(THIS_ D3DXHANDLE parameter, BOOL* b, UINT count) PURE;
     STDMETHOD(SetInt)(THIS_ D3DXHANDLE parameter, INT n) PURE;
     STDMETHOD(GetInt)(THIS_ D3DXHANDLE parameter, INT* n) PURE;
-    STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE parameter, CONST INT* n, UINT count) PURE;
+    STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE parameter, const INT *n, UINT count) PURE;
     STDMETHOD(GetIntArray)(THIS_ D3DXHANDLE parameter, INT* n, UINT count) PURE;
     STDMETHOD(SetFloat)(THIS_ D3DXHANDLE parameter, FLOAT f) PURE;
     STDMETHOD(GetFloat)(THIS_ D3DXHANDLE parameter, FLOAT* f) PURE;
-    STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE parameter, CONST FLOAT* f, UINT count) PURE;
+    STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE parameter, const FLOAT *f, UINT count) PURE;
     STDMETHOD(GetFloatArray)(THIS_ D3DXHANDLE parameter, FLOAT* f, UINT count) PURE;
-    STDMETHOD(SetVector)(THIS_ D3DXHANDLE parameter, CONST D3DXVECTOR4* vector) PURE;
+    STDMETHOD(SetVector)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector) PURE;
     STDMETHOD(GetVector)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector) PURE;
-    STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE parameter, CONST D3DXVECTOR4* vector, UINT count) PURE;
+    STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE parameter, const D3DXVECTOR4 *vector, UINT count) PURE;
     STDMETHOD(GetVectorArray)(THIS_ D3DXHANDLE parameter, D3DXVECTOR4* vector, UINT count) PURE;
-    STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix) PURE;
+    STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE;
     STDMETHOD(GetMatrix)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE;
-    STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE;
     STDMETHOD(GetMatrixArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE;
-    STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX** matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE;
     STDMETHOD(GetMatrixPointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE;
-    STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix) PURE;
+    STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix) PURE;
     STDMETHOD(GetMatrixTranspose)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix) PURE;
-    STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX* matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count) PURE;
     STDMETHOD(GetMatrixTransposeArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX* matrix, UINT count) PURE;
-    STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, CONST D3DXMATRIX** matrix, UINT count) PURE;
+    STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count) PURE;
     STDMETHOD(GetMatrixTransposePointerArray)(THIS_ D3DXHANDLE parameter, D3DXMATRIX** matrix, UINT count) PURE;
-    STDMETHOD(SetString)(THIS_ D3DXHANDLE parameter, LPCSTR string) PURE;
-    STDMETHOD(GetString)(THIS_ D3DXHANDLE parameter, LPCSTR* string) PURE;
+    STDMETHOD(SetString)(THIS_ D3DXHANDLE parameter, const char *string) PURE;
+    STDMETHOD(GetString)(THIS_ D3DXHANDLE parameter, const char **string) PURE;
     STDMETHOD(SetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 *texture) PURE;
     STDMETHOD(GetTexture)(THIS_ D3DXHANDLE parameter, struct IDirect3DBaseTexture9 **texture) PURE;
     STDMETHOD(GetPixelShader)(THIS_ D3DXHANDLE parameter, struct IDirect3DPixelShader9 **shader) PURE;
index 36c9df0..2c41b73 100644 (file)
@@ -414,7 +414,7 @@ DEFINE_GUID(IID_ID3DXMatrixStack,
 
 DECLARE_INTERFACE_(ID3DXMatrixStack, IUnknown)
 {
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
     STDMETHOD_(ULONG,Release)(THIS) PURE;
     STDMETHOD(Pop)(THIS) PURE;
index 84c0c62..ee2f82b 100644 (file)
@@ -27,7 +27,7 @@ inline D3DXVECTOR2::D3DXVECTOR2()
 {
 }
 
-inline D3DXVECTOR2::D3DXVECTOR2(CONST FLOAT *pf)
+inline D3DXVECTOR2::D3DXVECTOR2(const FLOAT *pf)
 {
     if(!pf) return;
     x = pf[0];
@@ -45,19 +45,19 @@ inline D3DXVECTOR2::operator FLOAT* ()
     return (FLOAT*)&x;
 }
 
-inline D3DXVECTOR2::operator CONST FLOAT* () const
+inline D3DXVECTOR2::operator const FLOAT* () const
 {
-    return (CONST FLOAT*)&x;
+    return (const FLOAT*)&x;
 }
 
-inline D3DXVECTOR2& D3DXVECTOR2::operator += (CONST D3DXVECTOR2& v)
+inline D3DXVECTOR2& D3DXVECTOR2::operator += (const D3DXVECTOR2& v)
 {
     x += v.x;
     y += v.y;
     return *this;
 }
 
-inline D3DXVECTOR2& D3DXVECTOR2::operator -= (CONST D3DXVECTOR2& v)
+inline D3DXVECTOR2& D3DXVECTOR2::operator -= (const D3DXVECTOR2& v)
 {
     x -= v.x;
     y -= v.y;
@@ -88,12 +88,12 @@ inline D3DXVECTOR2 D3DXVECTOR2::operator - () const
     return D3DXVECTOR2(-x, -y);
 }
 
-inline D3DXVECTOR2 D3DXVECTOR2::operator + (CONST D3DXVECTOR2& v) const
+inline D3DXVECTOR2 D3DXVECTOR2::operator + (const D3DXVECTOR2& v) const
 {
     return D3DXVECTOR2(x + v.x, y + v.y);
 }
 
-inline D3DXVECTOR2 D3DXVECTOR2::operator - (CONST D3DXVECTOR2& v) const
+inline D3DXVECTOR2 D3DXVECTOR2::operator - (const D3DXVECTOR2& v) const
 {
     return D3DXVECTOR2(x - v.x, y - v.y);
 }
@@ -108,17 +108,17 @@ inline D3DXVECTOR2 D3DXVECTOR2::operator / (FLOAT f) const
     return D3DXVECTOR2(x / f, y / f);
 }
 
-inline D3DXVECTOR2 operator * (FLOAT f, CONST D3DXVECTOR2& v)
+inline D3DXVECTOR2 operator * (FLOAT f, const D3DXVECTOR2& v)
 {
     return D3DXVECTOR2(f * v.x, f * v.y);
 }
 
-inline BOOL D3DXVECTOR2::operator == (CONST D3DXVECTOR2& v) const
+inline BOOL D3DXVECTOR2::operator == (const D3DXVECTOR2& v) const
 {
     return x == v.x && y == v.y;
 }
 
-inline BOOL D3DXVECTOR2::operator != (CONST D3DXVECTOR2& v) const
+inline BOOL D3DXVECTOR2::operator != (const D3DXVECTOR2& v) const
 {
     return x != v.x || y != v.y;
 }
@@ -127,7 +127,7 @@ inline D3DXVECTOR3::D3DXVECTOR3()
 {
 }
 
-inline D3DXVECTOR3::D3DXVECTOR3(CONST FLOAT *pf)
+inline D3DXVECTOR3::D3DXVECTOR3(const FLOAT *pf)
 {
     if(!pf) return;
     x = pf[0];
@@ -135,7 +135,7 @@ inline D3DXVECTOR3::D3DXVECTOR3(CONST FLOAT *pf)
     z = pf[2];
 }
 
-inline D3DXVECTOR3::D3DXVECTOR3(CONST D3DVECTOR& v)
+inline D3DXVECTOR3::D3DXVECTOR3(const D3DVECTOR& v)
 {
     x = v.x;
     y = v.y;
@@ -154,12 +154,12 @@ inline D3DXVECTOR3::operator FLOAT* ()
     return (FLOAT*)&x;
 }
 
-inline D3DXVECTOR3::operator CONST FLOAT* () const
+inline D3DXVECTOR3::operator const FLOAT* () const
 {
-    return (CONST FLOAT*)&x;
+    return (const FLOAT*)&x;
 }
 
-inline D3DXVECTOR3& D3DXVECTOR3::operator += (CONST D3DXVECTOR3& v)
+inline D3DXVECTOR3& D3DXVECTOR3::operator += (const D3DXVECTOR3& v)
 {
     x += v.x;
     y += v.y;
@@ -167,7 +167,7 @@ inline D3DXVECTOR3& D3DXVECTOR3::operator += (CONST D3DXVECTOR3& v)
     return *this;
 }
 
-inline D3DXVECTOR3& D3DXVECTOR3::operator -= (CONST D3DXVECTOR3& v)
+inline D3DXVECTOR3& D3DXVECTOR3::operator -= (const D3DXVECTOR3& v)
 {
     x -= v.x;
     y -= v.y;
@@ -201,12 +201,12 @@ inline D3DXVECTOR3 D3DXVECTOR3::operator - () const
     return D3DXVECTOR3(-x, -y, -z);
 }
 
-inline D3DXVECTOR3 D3DXVECTOR3::operator + (CONST D3DXVECTOR3& v) const
+inline D3DXVECTOR3 D3DXVECTOR3::operator + (const D3DXVECTOR3& v) const
 {
     return D3DXVECTOR3(x + v.x, y + v.y, z + v.z);
 }
 
-inline D3DXVECTOR3 D3DXVECTOR3::operator - (CONST D3DXVECTOR3& v) const
+inline D3DXVECTOR3 D3DXVECTOR3::operator - (const D3DXVECTOR3& v) const
 {
     return D3DXVECTOR3(x - v.x, y - v.y, z - v.z);
 }
@@ -221,17 +221,17 @@ inline D3DXVECTOR3 D3DXVECTOR3::operator / (FLOAT f) const
     return D3DXVECTOR3(x / f, y / f, z / f);
 }
 
-inline D3DXVECTOR3 operator * (FLOAT f, CONST D3DXVECTOR3& v)
+inline D3DXVECTOR3 operator * (FLOAT f, const D3DXVECTOR3& v)
 {
     return D3DXVECTOR3(f * v.x, f * v.y, f * v.z);
 }
 
-inline BOOL D3DXVECTOR3::operator == (CONST D3DXVECTOR3& v) const
+inline BOOL D3DXVECTOR3::operator == (const D3DXVECTOR3& v) const
 {
     return x == v.x && y == v.y && z == v.z;
 }
 
-inline BOOL D3DXVECTOR3::operator != (CONST D3DXVECTOR3& v) const
+inline BOOL D3DXVECTOR3::operator != (const D3DXVECTOR3& v) const
 {
     return x != v.x || y != v.y || z != v.z;
 }
@@ -240,7 +240,7 @@ inline D3DXVECTOR4::D3DXVECTOR4()
 {
 }
 
-inline D3DXVECTOR4::D3DXVECTOR4(CONST FLOAT *pf)
+inline D3DXVECTOR4::D3DXVECTOR4(const FLOAT *pf)
 {
     if(!pf) return;
     x = pf[0];
@@ -262,12 +262,12 @@ inline D3DXVECTOR4::operator FLOAT* ()
     return (FLOAT*)&x;
 }
 
-inline D3DXVECTOR4::operator CONST FLOAT* () const
+inline D3DXVECTOR4::operator const FLOAT* () const
 {
-    return (CONST FLOAT*)&x;
+    return (const FLOAT*)&x;
 }
 
-inline D3DXVECTOR4& D3DXVECTOR4::operator += (CONST D3DXVECTOR4& v)
+inline D3DXVECTOR4& D3DXVECTOR4::operator += (const D3DXVECTOR4& v)
 {
     x += v.x;
     y += v.y;
@@ -276,7 +276,7 @@ inline D3DXVECTOR4& D3DXVECTOR4::operator += (CONST D3DXVECTOR4& v)
     return *this;
 }
 
-inline D3DXVECTOR4& D3DXVECTOR4::operator -= (CONST D3DXVECTOR4& v)
+inline D3DXVECTOR4& D3DXVECTOR4::operator -= (const D3DXVECTOR4& v)
 {
     x -= v.x;
     y -= v.y;
@@ -313,12 +313,12 @@ inline D3DXVECTOR4 D3DXVECTOR4::operator - () const
     return D3DXVECTOR4(-x, -y, -z, -w);
 }
 
-inline D3DXVECTOR4 D3DXVECTOR4::operator + (CONST D3DXVECTOR4& v) const
+inline D3DXVECTOR4 D3DXVECTOR4::operator + (const D3DXVECTOR4& v) const
 {
     return D3DXVECTOR4(x + v.x, y + v.y, z + v.z, w + v.w);
 }
 
-inline D3DXVECTOR4 D3DXVECTOR4::operator - (CONST D3DXVECTOR4& v) const
+inline D3DXVECTOR4 D3DXVECTOR4::operator - (const D3DXVECTOR4& v) const
 {
     return D3DXVECTOR4(x - v.x, y - v.y, z - v.z, w - v.w);
 }
@@ -333,17 +333,17 @@ inline D3DXVECTOR4 D3DXVECTOR4::operator / (FLOAT f) const
     return D3DXVECTOR4(x / f, y / f, z / f, w / f);
 }
 
-inline D3DXVECTOR4 operator * (FLOAT f, CONST D3DXVECTOR4& v)
+inline D3DXVECTOR4 operator * (FLOAT f, const D3DXVECTOR4& v)
 {
     return D3DXVECTOR4(f * v.x, f * v.y, f * v.z, f * v.w);
 }
 
-inline BOOL D3DXVECTOR4::operator == (CONST D3DXVECTOR4& v) const
+inline BOOL D3DXVECTOR4::operator == (const D3DXVECTOR4& v) const
 {
     return x == v.x && y == v.y && z == v.z && w == v.w;
 }
 
-inline BOOL D3DXVECTOR4::operator != (CONST D3DXVECTOR4& v) const
+inline BOOL D3DXVECTOR4::operator != (const D3DXVECTOR4& v) const
 {
     return x != v.x || y != v.y || z != v.z || w != v.w;
 }
@@ -352,13 +352,13 @@ inline D3DXMATRIX::D3DXMATRIX()
 {
 }
 
-inline D3DXMATRIX::D3DXMATRIX(CONST FLOAT *pf)
+inline D3DXMATRIX::D3DXMATRIX(const FLOAT *pf)
 {
     if(!pf) return;
     memcpy(&_11, pf, sizeof(D3DXMATRIX));
 }
 
-inline D3DXMATRIX::D3DXMATRIX(CONST D3DMATRIX& mat)
+inline D3DXMATRIX::D3DXMATRIX(const D3DMATRIX& mat)
 {
     memcpy(&_11, &mat, sizeof(D3DXMATRIX));
 }
@@ -389,18 +389,18 @@ inline D3DXMATRIX::operator FLOAT* ()
     return (FLOAT*)&_11;
 }
 
-inline D3DXMATRIX::operator CONST FLOAT* () const
+inline D3DXMATRIX::operator const FLOAT* () const
 {
-    return (CONST FLOAT*)&_11;
+    return (const FLOAT*)&_11;
 }
 
-inline D3DXMATRIX& D3DXMATRIX::operator *= (CONST D3DXMATRIX& mat)
+inline D3DXMATRIX& D3DXMATRIX::operator *= (const D3DXMATRIX& mat)
 {
     D3DXMatrixMultiply(this, this, &mat);
     return *this;
 }
 
-inline D3DXMATRIX& D3DXMATRIX::operator += (CONST D3DXMATRIX& mat)
+inline 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;
@@ -409,7 +409,7 @@ inline D3DXMATRIX& D3DXMATRIX::operator += (CONST D3DXMATRIX& mat)
     return *this;
 }
 
-inline D3DXMATRIX& D3DXMATRIX::operator -= (CONST D3DXMATRIX& mat)
+inline 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;
@@ -450,14 +450,14 @@ inline D3DXMATRIX D3DXMATRIX::operator - () const
                       -_41, -_42, -_43, -_44);
 }
 
-inline D3DXMATRIX D3DXMATRIX::operator * (CONST D3DXMATRIX& mat) const
+inline D3DXMATRIX D3DXMATRIX::operator * (const D3DXMATRIX& mat) const
 {
     D3DXMATRIX buf;
     D3DXMatrixMultiply(&buf, this, &mat);
     return buf;
 }
 
-inline D3DXMATRIX D3DXMATRIX::operator + (CONST D3DXMATRIX& mat) const
+inline 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,
@@ -465,7 +465,7 @@ inline D3DXMATRIX D3DXMATRIX::operator + (CONST D3DXMATRIX& mat) const
                       _41 + mat._41, _42 + mat._42, _43 + mat._43, _44 + mat._44);
 }
 
-inline D3DXMATRIX D3DXMATRIX::operator - (CONST D3DXMATRIX& mat) const
+inline 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,
@@ -490,7 +490,7 @@ inline D3DXMATRIX D3DXMATRIX::operator / (FLOAT f) const
                       _41 * inv, _42 * inv, _43 * inv, _44 * inv);
 }
 
-inline D3DXMATRIX operator * (FLOAT f, CONST D3DXMATRIX& mat)
+inline 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,
@@ -498,12 +498,12 @@ inline D3DXMATRIX operator * (FLOAT f, CONST D3DXMATRIX& mat)
                       f * mat._41, f * mat._42, f * mat._43, f * mat._44);
 }
 
-inline BOOL D3DXMATRIX::operator == (CONST D3DXMATRIX& mat) const
+inline BOOL D3DXMATRIX::operator == (const D3DXMATRIX& mat) const
 {
     return (memcmp(this, &mat, sizeof(D3DXMATRIX)) == 0);
 }
 
-inline BOOL D3DXMATRIX::operator != (CONST D3DXMATRIX& mat) const
+inline BOOL D3DXMATRIX::operator != (const D3DXMATRIX& mat) const
 {
     return (memcmp(this, &mat, sizeof(D3DXMATRIX)) != 0);
 }
@@ -512,7 +512,7 @@ inline D3DXQUATERNION::D3DXQUATERNION()
 {
 }
 
-inline D3DXQUATERNION::D3DXQUATERNION(CONST FLOAT *pf)
+inline D3DXQUATERNION::D3DXQUATERNION(const FLOAT *pf)
 {
     if(!pf) return;
     x = pf[0];
@@ -534,12 +534,12 @@ inline D3DXQUATERNION::operator FLOAT* ()
     return (FLOAT*)&x;
 }
 
-inline D3DXQUATERNION::operator CONST FLOAT* () const
+inline D3DXQUATERNION::operator const FLOAT* () const
 {
-    return (CONST FLOAT*)&x;
+    return (const FLOAT*)&x;
 }
 
-inline D3DXQUATERNION& D3DXQUATERNION::operator += (CONST D3DXQUATERNION& quat)
+inline D3DXQUATERNION& D3DXQUATERNION::operator += (const D3DXQUATERNION& quat)
 {
     x += quat.x;
     y += quat.y;
@@ -548,7 +548,7 @@ inline D3DXQUATERNION& D3DXQUATERNION::operator += (CONST D3DXQUATERNION& quat)
     return *this;
 }
 
-inline D3DXQUATERNION& D3DXQUATERNION::operator -= (CONST D3DXQUATERNION& quat)
+inline D3DXQUATERNION& D3DXQUATERNION::operator -= (const D3DXQUATERNION& quat)
 {
     x -= quat.x;
     y -= quat.y;
@@ -557,7 +557,7 @@ inline D3DXQUATERNION& D3DXQUATERNION::operator -= (CONST D3DXQUATERNION& quat)
     return *this;
 }
 
-inline D3DXQUATERNION& D3DXQUATERNION::operator *= (CONST D3DXQUATERNION& quat)
+inline D3DXQUATERNION& D3DXQUATERNION::operator *= (const D3DXQUATERNION& quat)
 {
     D3DXQuaternionMultiply(this, this, &quat);
     return *this;
@@ -592,17 +592,17 @@ inline D3DXQUATERNION D3DXQUATERNION::operator - () const
     return D3DXQUATERNION(-x, -y, -z, -w);
 }
 
-inline D3DXQUATERNION D3DXQUATERNION::operator + (CONST D3DXQUATERNION& quat) const
+inline D3DXQUATERNION D3DXQUATERNION::operator + (const D3DXQUATERNION& quat) const
 {
     return D3DXQUATERNION(x + quat.x, y + quat.y, z + quat.z, w + quat.w);
 }
 
-inline D3DXQUATERNION D3DXQUATERNION::operator - (CONST D3DXQUATERNION& quat) const
+inline D3DXQUATERNION D3DXQUATERNION::operator - (const D3DXQUATERNION& quat) const
 {
     return D3DXQUATERNION(x - quat.x, y - quat.y, z - quat.z, w - quat.w);
 }
 
-inline D3DXQUATERNION D3DXQUATERNION::operator * (CONST D3DXQUATERNION& quat) const
+inline D3DXQUATERNION D3DXQUATERNION::operator * (const D3DXQUATERNION& quat) const
 {
     D3DXQUATERNION buf;
     D3DXQuaternionMultiply(&buf, this, &quat);
@@ -620,17 +620,17 @@ inline D3DXQUATERNION D3DXQUATERNION::operator / (FLOAT f) const
     return D3DXQUATERNION(x * inv, y * inv, z * inv, w * inv);
 }
 
-inline D3DXQUATERNION operator * (FLOAT f, CONST D3DXQUATERNION& quat)
+inline D3DXQUATERNION operator * (FLOAT f, const D3DXQUATERNION& quat)
 {
     return D3DXQUATERNION(f * quat.x, f * quat.y, f * quat.z, f * quat.w);
 }
 
-inline BOOL D3DXQUATERNION::operator == (CONST D3DXQUATERNION& quat) const
+inline BOOL D3DXQUATERNION::operator == (const D3DXQUATERNION& quat) const
 {
     return x == quat.x && y == quat.y && z == quat.z && w == quat.w;
 }
 
-inline BOOL D3DXQUATERNION::operator != (CONST D3DXQUATERNION& quat) const
+inline BOOL D3DXQUATERNION::operator != (const D3DXQUATERNION& quat) const
 {
     return x != quat.x || y != quat.y || z != quat.z || w != quat.w;
 }
@@ -639,7 +639,7 @@ inline D3DXPLANE::D3DXPLANE()
 {
 }
 
-inline D3DXPLANE::D3DXPLANE(CONST FLOAT *pf)
+inline D3DXPLANE::D3DXPLANE(const FLOAT *pf)
 {
     if(!pf) return;
     a = pf[0];
@@ -661,9 +661,9 @@ inline D3DXPLANE::operator FLOAT* ()
     return (FLOAT*)&a;
 }
 
-inline D3DXPLANE::operator CONST FLOAT* () const
+inline D3DXPLANE::operator const FLOAT* () const
 {
-    return (CONST FLOAT*)&a;
+    return (const FLOAT*)&a;
 }
 
 inline D3DXPLANE D3DXPLANE::operator + () const
@@ -676,12 +676,12 @@ inline D3DXPLANE D3DXPLANE::operator - () const
     return D3DXPLANE(-a, -b, -c, -d);
 }
 
-inline BOOL D3DXPLANE::operator == (CONST D3DXPLANE& pl) const
+inline BOOL D3DXPLANE::operator == (const D3DXPLANE& pl) const
 {
     return a == pl.a && b == pl.b && c == pl.c && d == pl.d;
 }
 
-inline BOOL D3DXPLANE::operator != (CONST D3DXPLANE& pl) const
+inline BOOL D3DXPLANE::operator != (const D3DXPLANE& pl) const
 {
     return a != pl.a || b != pl.b || c != pl.c || d != pl.d;
 }
@@ -692,14 +692,14 @@ inline D3DXCOLOR::D3DXCOLOR()
 
 inline D3DXCOLOR::D3DXCOLOR(DWORD col)
 {
-    CONST FLOAT f = 1.0f / 255.0f;
+    const FLOAT f = 1.0f / 255.0f;
     r = f * (FLOAT)(unsigned char)(col >> 16);
     g = f * (FLOAT)(unsigned char)(col >>  8);
     b = f * (FLOAT)(unsigned char)col;
     a = f * (FLOAT)(unsigned char)(col >> 24);
 }
 
-inline D3DXCOLOR::D3DXCOLOR(CONST FLOAT *pf)
+inline D3DXCOLOR::D3DXCOLOR(const FLOAT *pf)
 {
     if(!pf) return;
     r = pf[0];
@@ -708,7 +708,7 @@ inline D3DXCOLOR::D3DXCOLOR(CONST FLOAT *pf)
     a = pf[3];
 }
 
-inline D3DXCOLOR::D3DXCOLOR(CONST D3DCOLORVALUE& col)
+inline D3DXCOLOR::D3DXCOLOR(const D3DCOLORVALUE& col)
 {
     r = col.r;
     g = col.g;
@@ -739,9 +739,9 @@ inline D3DXCOLOR::operator FLOAT * ()
     return (FLOAT*)&r;
 }
 
-inline D3DXCOLOR::operator CONST FLOAT * () const
+inline D3DXCOLOR::operator const FLOAT * () const
 {
-    return (CONST FLOAT*)&r;
+    return (const FLOAT*)&r;
 }
 
 inline D3DXCOLOR::operator D3DCOLORVALUE * ()
@@ -749,9 +749,9 @@ inline D3DXCOLOR::operator D3DCOLORVALUE * ()
     return (D3DCOLORVALUE*)&r;
 }
 
-inline D3DXCOLOR::operator CONST D3DCOLORVALUE * () const
+inline D3DXCOLOR::operator const D3DCOLORVALUE * () const
 {
-    return (CONST D3DCOLORVALUE*)&r;
+    return (const D3DCOLORVALUE*)&r;
 }
 
 inline D3DXCOLOR::operator D3DCOLORVALUE& ()
@@ -759,12 +759,12 @@ inline D3DXCOLOR::operator D3DCOLORVALUE& ()
     return *((D3DCOLORVALUE*)&r);
 }
 
-inline D3DXCOLOR::operator CONST D3DCOLORVALUE& () const
+inline D3DXCOLOR::operator const D3DCOLORVALUE& () const
 {
-    return *((CONST D3DCOLORVALUE*)&r);
+    return *((const D3DCOLORVALUE*)&r);
 }
 
-inline D3DXCOLOR& D3DXCOLOR::operator += (CONST D3DXCOLOR& col)
+inline D3DXCOLOR& D3DXCOLOR::operator += (const D3DXCOLOR& col)
 {
     r += col.r;
     g += col.g;
@@ -773,7 +773,7 @@ inline D3DXCOLOR& D3DXCOLOR::operator += (CONST D3DXCOLOR& col)
     return *this;
 }
 
-inline D3DXCOLOR& D3DXCOLOR::operator -= (CONST D3DXCOLOR& col)
+inline D3DXCOLOR& D3DXCOLOR::operator -= (const D3DXCOLOR& col)
 {
     r -= col.r;
     g -= col.g;
@@ -811,12 +811,12 @@ inline D3DXCOLOR D3DXCOLOR::operator - () const
     return D3DXCOLOR(-r, -g, -b, -a);
 }
 
-inline D3DXCOLOR D3DXCOLOR::operator + (CONST D3DXCOLOR& col) const
+inline D3DXCOLOR D3DXCOLOR::operator + (const D3DXCOLOR& col) const
 {
     return D3DXCOLOR(r + col.r, g + col.g, b + col.b, a + col.a);
 }
 
-inline D3DXCOLOR D3DXCOLOR::operator - (CONST D3DXCOLOR& col) const
+inline D3DXCOLOR D3DXCOLOR::operator - (const D3DXCOLOR& col) const
 {
     return D3DXCOLOR(r - col.r, g - col.g, b - col.b, a - col.a);
 }
@@ -832,17 +832,17 @@ inline D3DXCOLOR D3DXCOLOR::operator / (FLOAT f) const
     return D3DXCOLOR(r * inv, g * inv, b * inv, a * inv);
 }
 
-inline D3DXCOLOR operator * (FLOAT f, CONST D3DXCOLOR& col)
+inline D3DXCOLOR operator * (FLOAT f, const D3DXCOLOR& col)
 {
     return D3DXCOLOR(f * col.r, f * col.g, f * col.b, f * col.a);
 }
 
-inline BOOL D3DXCOLOR::operator == (CONST D3DXCOLOR& col) const
+inline BOOL D3DXCOLOR::operator == (const D3DXCOLOR& col) const
 {
     return r == col.r && g == col.g && b == col.b && a == col.a;
 }
 
-inline BOOL D3DXCOLOR::operator != (CONST D3DXCOLOR& col) const
+inline BOOL D3DXCOLOR::operator != (const D3DXCOLOR& col) const
 {
     return r != col.r || g != col.g || b != col.b || a != col.a;
 }
@@ -856,7 +856,7 @@ inline D3DXFLOAT16::D3DXFLOAT16(FLOAT f)
     D3DXFloat32To16Array(this, &f, 1);
 }
 
-inline D3DXFLOAT16::D3DXFLOAT16(CONST D3DXFLOAT16 &f)
+inline D3DXFLOAT16::D3DXFLOAT16(const D3DXFLOAT16 &f)
 {
     value = f.value;
 }
@@ -868,12 +868,12 @@ inline D3DXFLOAT16::operator FLOAT ()
     return f;
 }
 
-inline BOOL D3DXFLOAT16::operator == (CONST D3DXFLOAT16 &f) const
+inline BOOL D3DXFLOAT16::operator == (const D3DXFLOAT16 &f) const
 {
     return value == f.value;
 }
 
-inline BOOL D3DXFLOAT16::operator != (CONST D3DXFLOAT16 &f) const
+inline BOOL D3DXFLOAT16::operator != (const D3DXFLOAT16 &f) const
 {
     return value != f.value;
 }
@@ -882,7 +882,7 @@ inline BOOL D3DXFLOAT16::operator != (CONST D3DXFLOAT16 &f) const
 
 /*_______________D3DXCOLOR_____________________*/
 
-static inline D3DXCOLOR* D3DXColorAdd(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2)
+static inline D3DXCOLOR* D3DXColorAdd(D3DXCOLOR *pout, const D3DXCOLOR *pc1, const D3DXCOLOR *pc2)
 {
     if ( !pout || !pc1 || !pc2 ) return NULL;
     pout->r = (pc1->r) + (pc2->r);
@@ -892,7 +892,7 @@ static inline D3DXCOLOR* D3DXColorAdd(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CON
     return pout;
 }
 
-static inline D3DXCOLOR* D3DXColorLerp(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2, FLOAT s)
+static inline D3DXCOLOR* D3DXColorLerp(D3DXCOLOR *pout, const D3DXCOLOR *pc1, const D3DXCOLOR *pc2, FLOAT s)
 {
     if ( !pout || !pc1 || !pc2 ) return NULL;
     pout->r = (1-s) * (pc1->r) + s *(pc2->r);
@@ -902,7 +902,7 @@ static inline D3DXCOLOR* D3DXColorLerp(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CO
     return pout;
 }
 
-static inline D3DXCOLOR* D3DXColorModulate(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2)
+static inline D3DXCOLOR* D3DXColorModulate(D3DXCOLOR *pout, const D3DXCOLOR *pc1, const D3DXCOLOR *pc2)
 {
     if ( !pout || !pc1 || !pc2 ) return NULL;
     pout->r = (pc1->r) * (pc2->r);
@@ -912,7 +912,7 @@ static inline D3DXCOLOR* D3DXColorModulate(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1
     return pout;
 }
 
-static inline D3DXCOLOR* D3DXColorNegative(D3DXCOLOR *pout, CONST D3DXCOLOR *pc)
+static inline D3DXCOLOR* D3DXColorNegative(D3DXCOLOR *pout, const D3DXCOLOR *pc)
 {
     if ( !pout || !pc ) return NULL;
     pout->r = 1.0f - pc->r;
@@ -922,7 +922,7 @@ static inline D3DXCOLOR* D3DXColorNegative(D3DXCOLOR *pout, CONST D3DXCOLOR *pc)
     return pout;
 }
 
-static inline D3DXCOLOR* D3DXColorScale(D3DXCOLOR *pout, CONST D3DXCOLOR *pc, FLOAT s)
+static inline D3DXCOLOR* D3DXColorScale(D3DXCOLOR *pout, const D3DXCOLOR *pc, FLOAT s)
 {
     if ( !pout || !pc ) return NULL;
     pout->r = s* (pc->r);
@@ -932,7 +932,7 @@ static inline D3DXCOLOR* D3DXColorScale(D3DXCOLOR *pout, CONST D3DXCOLOR *pc, FL
     return pout;
 }
 
-static inline D3DXCOLOR* D3DXColorSubtract(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1, CONST D3DXCOLOR *pc2)
+static inline D3DXCOLOR* D3DXColorSubtract(D3DXCOLOR *pout, const D3DXCOLOR *pc1, const D3DXCOLOR *pc2)
 {
     if ( !pout || !pc1 || !pc2 ) return NULL;
     pout->r = (pc1->r) - (pc2->r);
@@ -944,7 +944,7 @@ static inline D3DXCOLOR* D3DXColorSubtract(D3DXCOLOR *pout, CONST D3DXCOLOR *pc1
 
 /*_______________D3DXVECTOR2________________________*/
 
-static inline D3DXVECTOR2* D3DXVec2Add(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
+static inline D3DXVECTOR2* D3DXVec2Add(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x + pv2->x;
@@ -952,31 +952,31 @@ static inline D3DXVECTOR2* D3DXVec2Add(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1
     return pout;
 }
 
-static inline FLOAT D3DXVec2CCW(CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
+static inline FLOAT D3DXVec2CCW(const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
 {
     if ( !pv1 || !pv2) return 0.0f;
     return ( (pv1->x) * (pv2->y) - (pv1->y) * (pv2->x) );
 }
 
-static inline FLOAT D3DXVec2Dot(CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
+static inline FLOAT D3DXVec2Dot(const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
 {
     if ( !pv1 || !pv2) return 0.0f;
     return ( (pv1->x * pv2->x + pv1->y * pv2->y) );
 }
 
-static inline FLOAT D3DXVec2Length(CONST D3DXVECTOR2 *pv)
+static inline FLOAT D3DXVec2Length(const D3DXVECTOR2 *pv)
 {
     if (!pv) return 0.0f;
     return sqrtf( pv->x * pv->x + pv->y * pv->y );
 }
 
-static inline FLOAT D3DXVec2LengthSq(CONST D3DXVECTOR2 *pv)
+static inline FLOAT D3DXVec2LengthSq(const D3DXVECTOR2 *pv)
 {
     if (!pv) return 0.0f;
     return( (pv->x) * (pv->x) + (pv->y) * (pv->y) );
 }
 
-static inline D3DXVECTOR2* D3DXVec2Lerp(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, FLOAT s)
+static inline D3DXVECTOR2* D3DXVec2Lerp(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2, FLOAT s)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = (1-s) * (pv1->x) + s * (pv2->x);
@@ -984,7 +984,7 @@ static inline D3DXVECTOR2* D3DXVec2Lerp(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv
     return pout;
 }
 
-static inline D3DXVECTOR2* D3DXVec2Maximize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
+static inline D3DXVECTOR2* D3DXVec2Maximize(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
@@ -992,7 +992,7 @@ static inline D3DXVECTOR2* D3DXVec2Maximize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2
     return pout;
 }
 
-static inline D3DXVECTOR2* D3DXVec2Minimize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
+static inline D3DXVECTOR2* D3DXVec2Minimize(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
@@ -1000,7 +1000,7 @@ static inline D3DXVECTOR2* D3DXVec2Minimize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2
     return pout;
 }
 
-static inline D3DXVECTOR2* D3DXVec2Scale(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, FLOAT s)
+static inline D3DXVECTOR2* D3DXVec2Scale(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv, FLOAT s)
 {
     if ( !pout || !pv) return NULL;
     pout->x = s * (pv->x);
@@ -1008,7 +1008,7 @@ static inline D3DXVECTOR2* D3DXVec2Scale(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *p
     return pout;
 }
 
-static inline D3DXVECTOR2* D3DXVec2Subtract(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2)
+static inline D3DXVECTOR2* D3DXVec2Subtract(D3DXVECTOR2 *pout, const D3DXVECTOR2 *pv1, const D3DXVECTOR2 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x - pv2->x;
@@ -1018,7 +1018,7 @@ static inline D3DXVECTOR2* D3DXVec2Subtract(D3DXVECTOR2 *pout, CONST D3DXVECTOR2
 
 /*__________________D3DXVECTOR3_______________________*/
 
-static inline D3DXVECTOR3* D3DXVec3Add(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
+static inline D3DXVECTOR3* D3DXVec3Add(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x + pv2->x;
@@ -1027,7 +1027,7 @@ static inline D3DXVECTOR3* D3DXVec3Add(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1
     return pout;
 }
 
-static inline D3DXVECTOR3* D3DXVec3Cross(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
+static inline D3DXVECTOR3* D3DXVec3Cross(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
 {
     D3DXVECTOR3 temp;
 
@@ -1039,25 +1039,25 @@ static inline D3DXVECTOR3* D3DXVec3Cross(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *p
     return pout;
 }
 
-static inline FLOAT D3DXVec3Dot(CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
+static inline FLOAT D3DXVec3Dot(const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
 {
     if ( !pv1 || !pv2 ) return 0.0f;
     return (pv1->x) * (pv2->x) + (pv1->y) * (pv2->y) + (pv1->z) * (pv2->z);
 }
 
-static inline FLOAT D3DXVec3Length(CONST D3DXVECTOR3 *pv)
+static inline FLOAT D3DXVec3Length(const D3DXVECTOR3 *pv)
 {
     if (!pv) return 0.0f;
     return sqrtf( pv->x * pv->x + pv->y * pv->y + pv->z * pv->z );
 }
 
-static inline FLOAT D3DXVec3LengthSq(CONST D3DXVECTOR3 *pv)
+static inline FLOAT D3DXVec3LengthSq(const D3DXVECTOR3 *pv)
 {
     if (!pv) return 0.0f;
     return (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z);
 }
 
-static inline D3DXVECTOR3* D3DXVec3Lerp(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, FLOAT s)
+static inline D3DXVECTOR3* D3DXVec3Lerp(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2, FLOAT s)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = (1-s) * (pv1->x) + s * (pv2->x);
@@ -1066,7 +1066,7 @@ static inline D3DXVECTOR3* D3DXVec3Lerp(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv
     return pout;
 }
 
-static inline D3DXVECTOR3* D3DXVec3Maximize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
+static inline D3DXVECTOR3* D3DXVec3Maximize(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
@@ -1075,7 +1075,7 @@ static inline D3DXVECTOR3* D3DXVec3Maximize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3
     return pout;
 }
 
-static inline D3DXVECTOR3* D3DXVec3Minimize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
+static inline D3DXVECTOR3* D3DXVec3Minimize(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
@@ -1084,7 +1084,7 @@ static inline D3DXVECTOR3* D3DXVec3Minimize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3
     return pout;
 }
 
-static inline D3DXVECTOR3* D3DXVec3Scale(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, FLOAT s)
+static inline D3DXVECTOR3* D3DXVec3Scale(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv, FLOAT s)
 {
     if ( !pout || !pv) return NULL;
     pout->x = s * (pv->x);
@@ -1093,7 +1093,7 @@ static inline D3DXVECTOR3* D3DXVec3Scale(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *p
     return pout;
 }
 
-static inline D3DXVECTOR3* D3DXVec3Subtract(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
+static inline D3DXVECTOR3* D3DXVec3Subtract(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv1, const D3DXVECTOR3 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x - pv2->x;
@@ -1103,7 +1103,7 @@ static inline D3DXVECTOR3* D3DXVec3Subtract(D3DXVECTOR3 *pout, CONST D3DXVECTOR3
 }
 /*__________________D3DXVECTOR4_______________________*/
 
-static inline D3DXVECTOR4* D3DXVec4Add(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
+static inline D3DXVECTOR4* D3DXVec4Add(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x + pv2->x;
@@ -1113,25 +1113,25 @@ static inline D3DXVECTOR4* D3DXVec4Add(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1
     return pout;
 }
 
-static inline FLOAT D3DXVec4Dot(CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
+static inline FLOAT D3DXVec4Dot(const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2)
 {
     if (!pv1 || !pv2 ) return 0.0f;
     return (pv1->x) * (pv2->x) + (pv1->y) * (pv2->y) + (pv1->z) * (pv2->z) + (pv1->w) * (pv2->w);
 }
 
-static inline FLOAT D3DXVec4Length(CONST D3DXVECTOR4 *pv)
+static inline FLOAT D3DXVec4Length(const D3DXVECTOR4 *pv)
 {
     if (!pv) return 0.0f;
     return sqrtf( pv->x * pv->x + pv->y * pv->y + pv->z * pv->z + pv->w * pv->w );
 }
 
-static inline FLOAT D3DXVec4LengthSq(CONST D3DXVECTOR4 *pv)
+static inline FLOAT D3DXVec4LengthSq(const D3DXVECTOR4 *pv)
 {
     if (!pv) return 0.0f;
     return (pv->x) * (pv->x) + (pv->y) * (pv->y) + (pv->z) * (pv->z) + (pv->w) * (pv->w);
 }
 
-static inline D3DXVECTOR4* D3DXVec4Lerp(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, FLOAT s)
+static inline D3DXVECTOR4* D3DXVec4Lerp(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2, FLOAT s)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = (1-s) * (pv1->x) + s * (pv2->x);
@@ -1142,7 +1142,7 @@ static inline D3DXVECTOR4* D3DXVec4Lerp(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv
 }
 
 
-static inline D3DXVECTOR4* D3DXVec4Maximize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
+static inline D3DXVECTOR4* D3DXVec4Maximize(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x > pv2->x ? pv1->x : pv2->x;
@@ -1152,7 +1152,7 @@ static inline D3DXVECTOR4* D3DXVec4Maximize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4
     return pout;
 }
 
-static inline D3DXVECTOR4* D3DXVec4Minimize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
+static inline D3DXVECTOR4* D3DXVec4Minimize(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x < pv2->x ? pv1->x : pv2->x;
@@ -1162,7 +1162,7 @@ static inline D3DXVECTOR4* D3DXVec4Minimize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4
     return pout;
 }
 
-static inline D3DXVECTOR4* D3DXVec4Scale(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, FLOAT s)
+static inline D3DXVECTOR4* D3DXVec4Scale(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv, FLOAT s)
 {
     if ( !pout || !pv) return NULL;
     pout->x = s * (pv->x);
@@ -1172,7 +1172,7 @@ static inline D3DXVECTOR4* D3DXVec4Scale(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *p
     return pout;
 }
 
-static inline D3DXVECTOR4* D3DXVec4Subtract(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2)
+static inline D3DXVECTOR4* D3DXVec4Subtract(D3DXVECTOR4 *pout, const D3DXVECTOR4 *pv1, const D3DXVECTOR4 *pv2)
 {
     if ( !pout || !pv1 || !pv2) return NULL;
     pout->x = pv1->x - pv2->x;
@@ -1231,19 +1231,19 @@ static inline BOOL D3DXMatrixIsIdentity(D3DXMATRIX *pm)
 
 /*__________________D3DXPLANE____________________*/
 
-static inline FLOAT D3DXPlaneDot(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
+static inline FLOAT D3DXPlaneDot(const D3DXPLANE *pp, const D3DXVECTOR4 *pv)
 {
     if ( !pp || !pv ) return 0.0f;
     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) + (pp->d) * (pv->w) );
 }
 
-static inline FLOAT D3DXPlaneDotCoord(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
+static inline FLOAT D3DXPlaneDotCoord(const D3DXPLANE *pp, const D3DXVECTOR4 *pv)
 {
     if ( !pp || !pv ) return 0.0f;
     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) + (pp->d) );
 }
 
-static inline FLOAT D3DXPlaneDotNormal(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *pv)
+static inline FLOAT D3DXPlaneDotNormal(const D3DXPLANE *pp, const D3DXVECTOR4 *pv)
 {
     if ( !pp || !pv ) return 0.0f;
     return ( (pp->a) * (pv->x) + (pp->b) * (pv->y) + (pp->c) * (pv->z) );
@@ -1251,7 +1251,7 @@ static inline FLOAT D3DXPlaneDotNormal(CONST D3DXPLANE *pp, CONST D3DXVECTOR4 *p
 
 /*__________________D3DXQUATERNION____________________*/
 
-static inline D3DXQUATERNION* D3DXQuaternionConjugate(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
+static inline D3DXQUATERNION* D3DXQuaternionConjugate(D3DXQUATERNION *pout, const D3DXQUATERNION *pq)
 {
     if ( !pout || !pq) return NULL;
     pout->x = -pq->x;
@@ -1261,7 +1261,7 @@ static inline D3DXQUATERNION* D3DXQuaternionConjugate(D3DXQUATERNION *pout, CONS
     return pout;
 }
 
-static inline FLOAT D3DXQuaternionDot(CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2)
+static inline FLOAT D3DXQuaternionDot(const D3DXQUATERNION *pq1, const D3DXQUATERNION *pq2)
 {
     if ( !pq1 || !pq2 ) return 0.0f;
     return (pq1->x) * (pq2->x) + (pq1->y) * (pq2->y) + (pq1->z) * (pq2->z) + (pq1->w) * (pq2->w);
@@ -1283,13 +1283,13 @@ static inline BOOL D3DXQuaternionIsIdentity(D3DXQUATERNION *pq)
     return ( (pq->x == 0.0f) && (pq->y == 0.0f) && (pq->z == 0.0f) && (pq->w == 1.0f) );
 }
 
-static inline FLOAT D3DXQuaternionLength(CONST D3DXQUATERNION *pq)
+static inline FLOAT D3DXQuaternionLength(const D3DXQUATERNION *pq)
 {
     if (!pq) return 0.0f;
     return sqrtf( pq->x * pq->x + pq->y * pq->y + pq->z * pq->z + pq->w * pq->w );
 }
 
-static inline FLOAT D3DXQuaternionLengthSq(CONST D3DXQUATERNION *pq)
+static inline FLOAT D3DXQuaternionLengthSq(const D3DXQUATERNION *pq)
 {
     if (!pq) return 0.0f;
     return (pq->x) * (pq->x) + (pq->y) * (pq->y) + (pq->z) * (pq->z) + (pq->w) * (pq->w);
index 1347a79..1dcc244 100644 (file)
@@ -193,20 +193,20 @@ typedef D3DXATTRIBUTERANGE* LPD3DXATTRIBUTERANGE;
 typedef struct _D3DXMATERIAL
 {
     D3DMATERIAL9 MatD3D;
-    LPSTR pTextureFilename;
+    char *pTextureFilename;
 } D3DXMATERIAL, *LPD3DXMATERIAL;
 
 typedef struct _D3DXEFFECTDEFAULT
 {
-    LPSTR pParamName;
+    char *pParamName;
     D3DXEFFECTDEFAULTTYPE Type;
     DWORD NumBytes;
-    LPVOID pValue;
+    void *pValue;
 } D3DXEFFECTDEFAULT, *LPD3DXEFFECTDEFAULT;
 
 typedef struct _D3DXEFFECTINSTANCE
 {
-    LPSTR pEffectFilename;
+    char *pEffectFilename;
     DWORD NumDefaults;
     LPD3DXEFFECTDEFAULT pDefaults;
 } D3DXEFFECTINSTANCE, *LPD3DXEFFECTINSTANCE;
@@ -297,9 +297,9 @@ typedef struct _XFILECOMPRESSEDANIMATIONSET
     DWORD BufferLength;
 } XFILECOMPRESSEDANIMATIONSET;
 
-typedef HRESULT (WINAPI *LPD3DXUVATLASCB)(FLOAT, LPVOID);
-typedef HRESULT (WINAPI *LPD3DXIMTSIGNALCALLBACK)(CONST D3DXVECTOR2 *, UINT, UINT, VOID *, FLOAT *);
-typedef HRESULT (WINAPI *LPD3DXSHPRTSIMCB)(float, LPVOID);
+typedef HRESULT (WINAPI *LPD3DXUVATLASCB)(float complete, void *ctx);
+typedef HRESULT (WINAPI *LPD3DXIMTSIGNALCALLBACK)(const D3DXVECTOR2 *, UINT, UINT, void *, FLOAT *);
+typedef HRESULT (WINAPI *LPD3DXSHPRTSIMCB)(float complete, void *ctx);
 
 #undef INTERFACE
 #define INTERFACE ID3DXBaseMesh
@@ -307,7 +307,7 @@ typedef HRESULT (WINAPI *LPD3DXSHPRTSIMCB)(float, LPVOID);
 DECLARE_INTERFACE_(ID3DXBaseMesh, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXBaseMesh ***/
@@ -325,13 +325,13 @@ DECLARE_INTERFACE_(ID3DXBaseMesh, IUnknown)
             struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh) PURE;
     STDMETHOD(GetVertexBuffer)(THIS_ struct IDirect3DVertexBuffer9 **vertex_buffer) PURE;
     STDMETHOD(GetIndexBuffer)(THIS_ struct IDirect3DIndexBuffer9 **index_buffer) PURE;
-    STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, LPVOID* data) PURE;
+    STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, void **data) PURE;
     STDMETHOD(UnlockVertexBuffer)(THIS) PURE;
-    STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, LPVOID* data) PURE;
+    STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, void **data) PURE;
     STDMETHOD(UnlockIndexBuffer)(THIS) PURE;
     STDMETHOD(GetAttributeTable)(THIS_ D3DXATTRIBUTERANGE* attrib_table, DWORD* attrib_table_size) PURE;
-    STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ CONST DWORD* point_reps, DWORD* adjacency) PURE;
-    STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ CONST DWORD* adjacency, DWORD* point_reps) PURE;
+    STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ const DWORD *point_reps, DWORD *adjacency) PURE;
+    STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ const DWORD *adjacency, DWORD *point_reps) PURE;
     STDMETHOD(GenerateAdjacency)(THIS_ FLOAT epsilon, DWORD* adjacency) PURE;
     STDMETHOD(UpdateSemantics)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE;
 };
@@ -341,7 +341,7 @@ DECLARE_INTERFACE_(ID3DXBaseMesh, IUnknown)
 DECLARE_INTERFACE_(ID3DXMesh, ID3DXBaseMesh)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXBaseMesh ***/
@@ -359,13 +359,13 @@ DECLARE_INTERFACE_(ID3DXMesh, ID3DXBaseMesh)
             struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh) PURE;
     STDMETHOD(GetVertexBuffer)(THIS_ struct IDirect3DVertexBuffer9 **vertex_buffer) PURE;
     STDMETHOD(GetIndexBuffer)(THIS_ struct IDirect3DIndexBuffer9 **index_buffer) PURE;
-    STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, LPVOID* data) PURE;
+    STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, void **data) PURE;
     STDMETHOD(UnlockVertexBuffer)(THIS) PURE;
-    STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, LPVOID* data) PURE;
+    STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, void **data) PURE;
     STDMETHOD(UnlockIndexBuffer)(THIS) PURE;
     STDMETHOD(GetAttributeTable)(THIS_ D3DXATTRIBUTERANGE* attrib_table, DWORD* attrib_table_size) PURE;
-    STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ CONST DWORD* point_reps, DWORD* adjacency) PURE;
-    STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ CONST DWORD* adjacency, DWORD* point_reps) PURE;
+    STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ const DWORD *point_reps, DWORD *adjacency) PURE;
+    STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ const DWORD *adjacency, DWORD *point_reps) PURE;
     STDMETHOD(GenerateAdjacency)(THIS_ FLOAT epsilon, DWORD* adjacency) PURE;
     STDMETHOD(UpdateSemantics)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE;
     /*** ID3DXMesh ***/
@@ -375,7 +375,8 @@ DECLARE_INTERFACE_(ID3DXMesh, ID3DXBaseMesh)
             DWORD *face_remap, ID3DXBuffer **vertex_remap, ID3DXMesh **opt_mesh) PURE;
     STDMETHOD(OptimizeInplace)(THIS_ DWORD flags, const DWORD *adjacency_in, DWORD *adjacency_out,
                      DWORD *face_remap, ID3DXBuffer **vertex_remap) PURE;
-    STDMETHOD(SetAttributeTable)(THIS_ CONST D3DXATTRIBUTERANGE* attrib_table, DWORD attrib_table_size) PURE;
+    STDMETHOD(SetAttributeTable)(THIS_ const D3DXATTRIBUTERANGE *attrib_table,
+            DWORD attrib_table_size) PURE;
 };
 #undef INTERFACE
 
@@ -383,7 +384,7 @@ DECLARE_INTERFACE_(ID3DXMesh, ID3DXBaseMesh)
 DECLARE_INTERFACE_(ID3DXPMesh, ID3DXBaseMesh)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXBaseMesh ***/
@@ -401,13 +402,13 @@ DECLARE_INTERFACE_(ID3DXPMesh, ID3DXBaseMesh)
             struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh) PURE;
     STDMETHOD(GetVertexBuffer)(THIS_ struct IDirect3DVertexBuffer9 **vertex_buffer) PURE;
     STDMETHOD(GetIndexBuffer)(THIS_ struct IDirect3DIndexBuffer9 **index_buffer) PURE;
-    STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, LPVOID* data) PURE;
+    STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, void **data) PURE;
     STDMETHOD(UnlockVertexBuffer)(THIS) PURE;
-    STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, LPVOID* data) PURE;
+    STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, void **data) PURE;
     STDMETHOD(UnlockIndexBuffer)(THIS) PURE;
     STDMETHOD(GetAttributeTable)(THIS_ D3DXATTRIBUTERANGE* attrib_table, DWORD* attrib_table_size) PURE;
-    STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ CONST DWORD* point_reps, DWORD* adjacency) PURE;
-    STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ CONST DWORD* adjacency, DWORD* point_reps) PURE;
+    STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ const DWORD *point_reps, DWORD *adjacency) PURE;
+    STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ const DWORD *adjacency, DWORD *point_reps) PURE;
     STDMETHOD(GenerateAdjacency)(THIS_ FLOAT epsilon, DWORD* adjacency) PURE;
     STDMETHOD(UpdateSemantics)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE;
     /*** ID3DXPMesh ***/
@@ -421,7 +422,8 @@ DECLARE_INTERFACE_(ID3DXPMesh, ID3DXBaseMesh)
     STDMETHOD_(DWORD, GetMinFaces)(THIS) PURE;
     STDMETHOD_(DWORD, GetMaxVertices)(THIS) PURE;
     STDMETHOD_(DWORD, GetMinVertices)(THIS) PURE;
-    STDMETHOD(Save)(THIS_ IStream *stream, CONST D3DXMATERIAL* material, CONST D3DXEFFECTINSTANCE* effect_instance, DWORD num_materials) PURE;
+    STDMETHOD(Save)(THIS_ IStream *stream, const D3DXMATERIAL *material,
+            const D3DXEFFECTINSTANCE *effect_instance, DWORD num_materials) PURE;
     STDMETHOD(Optimize)(THIS_ DWORD flags, DWORD *adjacency_out, DWORD *face_remap,
             ID3DXBuffer **vertex_remap, ID3DXMesh **opt_mesh) PURE;
     STDMETHOD(OptimizeBaseLOD)(THIS_ DWORD flags, DWORD* face_remap) PURE;
@@ -436,7 +438,7 @@ DECLARE_INTERFACE_(ID3DXPMesh, ID3DXBaseMesh)
 DECLARE_INTERFACE_(ID3DXSPMesh, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXSPMesh ***/
@@ -471,7 +473,7 @@ DECLARE_INTERFACE_(ID3DXSPMesh, IUnknown)
 DECLARE_INTERFACE_(ID3DXPatchMesh, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXPatchMesh ***/
@@ -484,9 +486,9 @@ DECLARE_INTERFACE_(ID3DXPatchMesh, IUnknown)
     STDMETHOD(GetPatchInfo)(THIS_ LPD3DXPATCHINFO patch_info) PURE;
     STDMETHOD(GetVertexBuffer)(THIS_ struct IDirect3DVertexBuffer9 **vertex_buffer) PURE;
     STDMETHOD(GetIndexBuffer)(THIS_ struct IDirect3DIndexBuffer9 **index_buffer) PURE;
-    STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, LPVOID* data) PURE;
+    STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, void **data) PURE;
     STDMETHOD(UnlockVertexBuffer)(THIS) PURE;
-    STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, LPVOID* data) PURE;
+    STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, void **data) PURE;
     STDMETHOD(UnlockIndexBuffer)(THIS) PURE;
     STDMETHOD(LockAttributeBuffer)(THIS_ DWORD flags, DWORD** data) PURE;
     STDMETHOD(UnlockAttributeBuffer)(THIS) PURE;
@@ -510,11 +512,12 @@ DECLARE_INTERFACE_(ID3DXPatchMesh, IUnknown)
 DECLARE_INTERFACE_(ID3DXSkinInfo, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXSkinInfo ***/
-    STDMETHOD(SetBoneInfluence)(THIS_ DWORD bone, DWORD num_influences, CONST DWORD* vertices, CONST FLOAT* weights) PURE;
+    STDMETHOD(SetBoneInfluence)(THIS_ DWORD bone, DWORD num_influences, const DWORD *vertices,
+            const FLOAT *weights) PURE;
     STDMETHOD(SetBoneVertexInfluence)(THIS_ DWORD bone_num, DWORD influence_num, float weight) PURE;
     STDMETHOD_(DWORD, GetNumBoneInfluences)(THIS_ DWORD bone) PURE;
     STDMETHOD(GetBoneInfluence)(THIS_ DWORD bone, DWORD* vertices, FLOAT* weights) PURE;
@@ -526,18 +529,18 @@ DECLARE_INTERFACE_(ID3DXSkinInfo, IUnknown)
             DWORD num_faces, DWORD *max_face_influences) PURE;
     STDMETHOD(SetMinBoneInfluence)(THIS_ FLOAT min_influence) PURE;
     STDMETHOD_(FLOAT, GetMinBoneInfluence)(THIS) PURE;
-    STDMETHOD(SetBoneName)(THIS_ DWORD bone, LPCSTR name) PURE;
-    STDMETHOD_(LPCSTR, GetBoneName)(THIS_ DWORD bone) PURE;
-    STDMETHOD(SetBoneOffsetMatrix)(THIS_ DWORD bone, CONST D3DXMATRIX* bone_transform) PURE;
+    STDMETHOD(SetBoneName)(THIS_ DWORD bone_idx, const char *name) PURE;
+    STDMETHOD_(const char *, GetBoneName)(THIS_ DWORD bone_idx) PURE;
+    STDMETHOD(SetBoneOffsetMatrix)(THIS_ DWORD bone, const D3DXMATRIX *bone_transform) PURE;
     STDMETHOD_(D3DXMATRIX *, GetBoneOffsetMatrix)(THIS_ DWORD bone) PURE;
     STDMETHOD(Clone)(THIS_ ID3DXSkinInfo **skin_info) PURE;
     STDMETHOD(Remap)(THIS_ DWORD num_vertices, DWORD* vertex_remap) PURE;
     STDMETHOD(SetFVF)(THIS_ DWORD FVF) PURE;
-    STDMETHOD(SetDeclaration)(THIS_ CONST D3DVERTEXELEMENT9* declaration) PURE;
+    STDMETHOD(SetDeclaration)(THIS_ const D3DVERTEXELEMENT9 *declaration) PURE;
     STDMETHOD_(DWORD, GetFVF)(THIS) PURE;
     STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE]) PURE;
-    STDMETHOD(UpdateSkinnedMesh)(THIS_ CONST D3DXMATRIX* bone_transforms,
-        CONST D3DXMATRIX* bone_inv_transpose_transforms, LPCVOID vertices_src, PVOID vertices_dest) PURE;
+    STDMETHOD(UpdateSkinnedMesh)(THIS_ const D3DXMATRIX *bone_transforms,
+            const D3DXMATRIX *bone_inv_transpose_transforms, const void *src_vertices, void *dst_vertices) PURE;
     STDMETHOD(ConvertToBlendedMesh)(THIS_ ID3DXMesh *mesh_in, DWORD options, const DWORD *adjacency_in,
             DWORD *adjacency_out, DWORD *face_remap, ID3DXBuffer **vertex_remap, DWORD *max_face_infl,
             DWORD *num_bone_combinations, ID3DXBuffer **bone_combination_table, ID3DXMesh **mesh_out) PURE;
@@ -551,7 +554,7 @@ DECLARE_INTERFACE_(ID3DXSkinInfo, IUnknown)
 DECLARE_INTERFACE_(ID3DXPRTBuffer, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXPRTBuffer methods ***/
@@ -580,7 +583,7 @@ DECLARE_INTERFACE_(ID3DXPRTBuffer, IUnknown)
 DECLARE_INTERFACE_(ID3DXPRTCompBuffer, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXPRTCompBuffer methods ***/
@@ -605,7 +608,7 @@ DECLARE_INTERFACE_(ID3DXPRTCompBuffer, IUnknown)
 DECLARE_INTERFACE_(ID3DXTextureGutterHelper, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXTextureGutterHelper methods ***/
@@ -632,13 +635,13 @@ DECLARE_INTERFACE_(ID3DXTextureGutterHelper, IUnknown)
 DECLARE_INTERFACE_(ID3DXPRTEngine, IUnknown)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* object) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXPRTEngine methods ***/
-    STDMETHOD(SetMeshMaterials)(THIS_ CONST D3DXSHMATERIAL **materials, UINT num_meshes,
+    STDMETHOD(SetMeshMaterials)(THIS_ const D3DXSHMATERIAL **materials, UINT num_meshes,
         UINT num_channels, BOOL set_albedo, FLOAT length_scale) PURE;
-    STDMETHOD(SetPerVertexAlbedo)(THIS_ CONST VOID *data_in, UINT num_channels, UINT stride) PURE;
+    STDMETHOD(SetPerVertexAlbedo)(THIS_ const void *data_in, UINT num_channels, UINT stride) PURE;
     STDMETHOD(SetPerTexelAlbedo)(THIS_ struct IDirect3DTexture9 *albedo_texture,
             UINT num_channels, struct ID3DXTextureGutterHelper *gh) PURE;
     STDMETHOD(GetVertexAlbedo)(THIS_ D3DXCOLOR *vert_colors, UINT num_verts) PURE;
@@ -681,10 +684,11 @@ DECLARE_INTERFACE_(ID3DXPRTEngine, IUnknown)
             ID3DXPRTBuffer *data_out) PURE;
     STDMETHOD(ScaleMeshChunk)(THIS_ UINT mesh_chunk, float scale, ID3DXPRTBuffer *data_out) PURE;
     STDMETHOD(MultiplyAlbedo)(THIS_ ID3DXPRTBuffer *data_out) PURE;
-    STDMETHOD(SetCallback)(THIS_ LPD3DXSHPRTSIMCB cb, FLOAT frequency, LPVOID user_context) PURE;
-    STDMETHOD_(BOOL, ShadowRayIntersects)(THIS_ CONST D3DXVECTOR3 *ray_pos, CONST D3DXVECTOR3 *ray_dir) PURE;
-    STDMETHOD_(BOOL, ClosestRayIntersects)(THIS_ CONST D3DXVECTOR3 *ray_pos, CONST D3DXVECTOR3 *ray_dir,
-        DWORD *face_index, FLOAT *u, FLOAT *v, FLOAT *dist) PURE;
+    STDMETHOD(SetCallback)(THIS_ LPD3DXSHPRTSIMCB cb, float frequency, void *user_context) PURE;
+    STDMETHOD_(BOOL, ShadowRayIntersects)(THIS_ const D3DXVECTOR3 *ray_pos,
+            const D3DXVECTOR3 *ray_dir) PURE;
+    STDMETHOD_(BOOL, ClosestRayIntersects)(THIS_ const D3DXVECTOR3 *ray_pos,
+            const D3DXVECTOR3 *ray_dir, DWORD *face_index, FLOAT *u, FLOAT *v, FLOAT *dist) PURE;
 };
 #undef INTERFACE
 
@@ -762,15 +766,19 @@ HRESULT WINAPI D3DXSavePRTCompBufferToFileW(const WCHAR *filename, ID3DXPRTCompB
 UINT    WINAPI D3DXGetDeclLength(const D3DVERTEXELEMENT9 *decl);
 UINT    WINAPI D3DXGetDeclVertexSize(const D3DVERTEXELEMENT9 *decl, DWORD stream_idx);
 UINT    WINAPI D3DXGetFVFVertexSize(DWORD);
-BOOL    WINAPI D3DXBoxBoundProbe(CONST D3DXVECTOR3 *, CONST D3DXVECTOR3 *, CONST D3DXVECTOR3 *, CONST D3DXVECTOR3 *);
-BOOL    WINAPI D3DXSphereBoundProbe(CONST D3DXVECTOR3 *,FLOAT,CONST D3DXVECTOR3 *,CONST D3DXVECTOR3 *);
+BOOL WINAPI D3DXBoxBoundProbe(const D3DXVECTOR3 *vmin, const D3DXVECTOR3 *vmax,
+        const D3DXVECTOR3 *ray_pos, const D3DXVECTOR3 *ray_dir);
+BOOL WINAPI D3DXSphereBoundProbe(const D3DXVECTOR3 *center, FLOAT radius,
+        const D3DXVECTOR3 *ray_pos, const D3DXVECTOR3 *ray_dir);
 HRESULT WINAPI D3DXCleanMesh(D3DXCLEANTYPE clean_type, ID3DXMesh *mesh_in, const DWORD *adjacency_in,
         ID3DXMesh **mesh_out, DWORD *adjacency_out, ID3DXBuffer **errors);
 HRESULT WINAPI D3DXConcatenateMeshes(struct ID3DXMesh **meshes, UINT mesh_count, DWORD flags,
         const D3DXMATRIX *geometry_matrices, const D3DXMATRIX *texture_matrices,
         const D3DVERTEXELEMENT9 *declaration, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh);
-HRESULT WINAPI D3DXComputeBoundingBox(CONST D3DXVECTOR3 *, DWORD, DWORD, D3DXVECTOR3 *, D3DXVECTOR3 *);
-HRESULT WINAPI D3DXComputeBoundingSphere(CONST D3DXVECTOR3 *, DWORD, DWORD, D3DXVECTOR3 *, FLOAT *);
+HRESULT WINAPI D3DXComputeBoundingBox(const D3DXVECTOR3 *first_pos, DWORD num_vertices,
+        DWORD stride, D3DXVECTOR3 *vmin, D3DXVECTOR3 *vmax);
+HRESULT WINAPI D3DXComputeBoundingSphere(const D3DXVECTOR3 *first_pos, DWORD num_vertices,
+        DWORD stride, D3DXVECTOR3 *center, FLOAT *radius);
 HRESULT WINAPI D3DXComputeIMTFromPerTexelSignal(ID3DXMesh *mesh, DWORD texture_idx, float *texel_signal,
         UINT width, UINT height, UINT signal_dimension, UINT component_count, DWORD flags,
         LPD3DXUVATLASCB cb, void *ctx, ID3DXBuffer **buffer);
@@ -797,7 +805,7 @@ HRESULT WINAPI D3DXConvertMeshSubsetToStrips(struct ID3DXBaseMesh *mesh_in, DWOR
         struct ID3DXBuffer **strip_lengths, DWORD *strip_count);
 HRESULT WINAPI D3DXDeclaratorFromFVF(DWORD, D3DVERTEXELEMENT9[MAX_FVF_DECL_SIZE]);
 HRESULT WINAPI D3DXFVFFromDeclarator(const D3DVERTEXELEMENT9 *decl, DWORD *fvf);
-HRESULT WINAPI D3DXGenerateOutputDecl(D3DVERTEXELEMENT9 *, CONST D3DVERTEXELEMENT9 *);
+HRESULT WINAPI D3DXGenerateOutputDecl(D3DVERTEXELEMENT9 *decl_out, const D3DVERTEXELEMENT9 *decl_in);
 HRESULT WINAPI D3DXGeneratePMesh(ID3DXMesh *mesh, const DWORD *adjacency,
         const D3DXATTRIBUTEWEIGHTS *attribute_weights, const float *vertex_weights,
         DWORD min_value, DWORD flags, ID3DXPMesh **pmesh);
@@ -806,10 +814,15 @@ HRESULT WINAPI D3DXIntersect(ID3DXBaseMesh *mesh, const D3DXVECTOR3 *ray_positio
 HRESULT WINAPI D3DXIntersectSubset(ID3DXBaseMesh *mesh, DWORD attribute_id, const D3DXVECTOR3 *ray_position,
         const D3DXVECTOR3 *ray_direction, BOOL *hit, DWORD *face_idx, float *u, float *v, float *distance,
         ID3DXBuffer **hits, DWORD *hit_count);
-BOOL    WINAPI D3DXIntersectTri(CONST D3DXVECTOR3 *, CONST D3DXVECTOR3 *, CONST D3DXVECTOR3 *, CONST D3DXVECTOR3 *, CONST D3DXVECTOR3*, FLOAT *, FLOAT *, FLOAT *);
-HRESULT WINAPI D3DXOptimizeFaces(LPCVOID, UINT, UINT, BOOL, DWORD *);
-HRESULT WINAPI D3DXOptimizeVertices(LPCVOID, UINT, UINT, BOOL, DWORD *);
-HRESULT WINAPI D3DXRectPatchSize(CONST FLOAT *, DWORD *, DWORD *);
+BOOL WINAPI D3DXIntersectTri(const D3DXVECTOR3 *vtx0, const D3DXVECTOR3 *vtx1,
+        const D3DXVECTOR3 *vtx2, const D3DXVECTOR3 *ray_pos, const D3DXVECTOR3 *ray_dir, FLOAT *u,
+        FLOAT *v, FLOAT *dist);
+HRESULT WINAPI D3DXOptimizeFaces(const void *indices, UINT face_count,
+        UINT vertex_count, BOOL idx_32bit, DWORD *face_remap);
+HRESULT WINAPI D3DXOptimizeVertices(const void *indices, UINT face_count,
+        UINT vertex_count, BOOL idx_32bit, DWORD *vertex_remap);
+HRESULT WINAPI D3DXRectPatchSize(const FLOAT *segment_count, DWORD *num_triangles,
+        DWORD *num_vertices);
 HRESULT WINAPI D3DXSHPRTCompSuperCluster(UINT *cluster_ids, ID3DXMesh *scene, UINT max_cluster_count,
         UINT cluster_count, UINT *scluster_ids, UINT *scluster_count);
 HRESULT WINAPI D3DXSHPRTCompSplitMeshSC(UINT *cluster_idx, UINT vertex_count, UINT cluster_count, UINT *scluster_ids,
@@ -828,7 +841,8 @@ HRESULT WINAPI D3DXTesselateRectPatch(struct IDirect3DVertexBuffer9 *buffer, con
         const D3DVERTEXELEMENT9 *declaration, const D3DRECTPATCH_INFO *patch_info, struct ID3DXMesh *mesh);
 HRESULT WINAPI D3DXTesselateTriPatch(struct IDirect3DVertexBuffer9 *buffer, const float *segment_count,
         const D3DVERTEXELEMENT9 *declaration, const D3DTRIPATCH_INFO *patch_info, struct ID3DXMesh *mesh);
-HRESULT WINAPI D3DXTriPatchSize(CONST FLOAT *, DWORD *, DWORD *);
+HRESULT WINAPI D3DXTriPatchSize(const FLOAT *segment_count, DWORD *num_triangles,
+        DWORD *num_vertices);
 HRESULT WINAPI D3DXUVAtlasCreate(ID3DXMesh *mesh_in, UINT max_chart_count, float max_stretch_in,
         UINT width, UINT height, float gutter, DWORD texture_idx, const DWORD *adjacency, const DWORD *false_edges,
         const float *imt_array, LPD3DXUVATLASCB cb, float cb_freq, void *ctx, DWORD flags, ID3DXMesh **mesh_out,
index 0b30519..d665f72 100644 (file)
@@ -1,5 +1,6 @@
 /*
  * Copyright 2008 Luis Busquets
+ * Copyright 2014 Kai Tietz
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
 
 #define D3DXSHADER_USE_LEGACY_D3DX9_31_DLL        0x10000
 
-typedef LPCSTR D3DXHANDLE;
+#define D3DXCONSTTABLE_LARGEADDRESSAWARE          0x20000
+
+typedef const char *D3DXHANDLE;
+typedef D3DXHANDLE *LPD3DXHANDLE;
 
 typedef enum _D3DXREGISTER_SET
 {
@@ -91,14 +95,14 @@ typedef enum D3DXPARAMETER_TYPE
 
 typedef struct _D3DXCONSTANTTABLE_DESC
 {
-    LPCSTR Creator;
+    const char *Creator;
     DWORD Version;
     UINT Constants;
 } D3DXCONSTANTTABLE_DESC, *LPD3DXCONSTANTTABLE_DESC;
 
 typedef struct _D3DXCONSTANT_DESC
 {
-    LPCSTR Name;
+    const char *Name;
     D3DXREGISTER_SET RegisterSet;
     UINT RegisterIndex;
     UINT RegisterCount;
@@ -109,10 +113,14 @@ typedef struct _D3DXCONSTANT_DESC
     UINT Elements;
     UINT StructMembers;
     UINT Bytes;
-    LPCVOID DefaultValue;
+    const void *DefaultValue;
 } D3DXCONSTANT_DESC, *LPD3DXCONSTANT_DESC;
 
+#if D3DX_SDK_VERSION < 43
 DEFINE_GUID(IID_ID3DXConstantTable, 0x9dca3190, 0x38b9, 0x4fc3, 0x92, 0xe3, 0x39, 0xc6, 0xdd, 0xfb, 0x35, 0x8b);
+#else
+DEFINE_GUID(IID_ID3DXConstantTable, 0xab3c758f, 0x093e, 0x4356, 0xb7, 0x62, 0x4d, 0xb1, 0x8f, 0x1b, 0x3a, 0x01);
+#endif
 
 #undef INTERFACE
 #define INTERFACE ID3DXConstantTable
@@ -120,18 +128,18 @@ DEFINE_GUID(IID_ID3DXConstantTable, 0x9dca3190, 0x38b9, 0x4fc3, 0x92, 0xe3, 0x39
 DECLARE_INTERFACE_(ID3DXConstantTable, ID3DXBuffer)
 {
     /*** IUnknown methods ***/
-    STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE;
     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
     STDMETHOD_(ULONG, Release)(THIS) PURE;
     /*** ID3DXBuffer methods ***/
-    STDMETHOD_(LPVOID, GetBufferPointer)(THIS) PURE;
+    STDMETHOD_(void *, GetBufferPointer)(THIS) PURE;
     STDMETHOD_(DWORD, GetBufferSize)(THIS) PURE;
     /*** ID3DXConstantTable methods ***/
     STDMETHOD(GetDesc)(THIS_ D3DXCONSTANTTABLE_DESC *pDesc) PURE;
     STDMETHOD(GetConstantDesc)(THIS_ D3DXHANDLE hConstant, D3DXCONSTANT_DESC *pConstantDesc, UINT *pCount) PURE;
     STDMETHOD_(UINT, GetSamplerIndex)(THIS_ D3DXHANDLE hConstant) PURE;
     STDMETHOD_(D3DXHANDLE, GetConstant)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;
-    STDMETHOD_(D3DXHANDLE, GetConstantByName)(THIS_ D3DXHANDLE hConstant, LPCSTR pName) PURE;
+    STDMETHOD_(D3DXHANDLE, GetConstantByName)(THIS_ D3DXHANDLE constant, const char *name) PURE;
     STDMETHOD_(D3DXHANDLE, GetConstantElement)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;
     STDMETHOD(SetDefaults)(THIS_ struct IDirect3DDevice9 *device) PURE;
     STDMETHOD(SetValue)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant,
@@ -228,9 +236,46 @@ DECLARE_INTERFACE_(ID3DXConstantTable, ID3DXBuffer)
 
 typedef struct ID3DXConstantTable *LPD3DXCONSTANTTABLE;
 
-typedef struct _D3DXMACRO {
-    LPCSTR Name;
-    LPCSTR Definition;
+typedef interface ID3DXTextureShader *LPD3DXTEXTURESHADER;
+
+DEFINE_GUID(IID_ID3DXTextureShader, 0x3e3d67f8, 0xaa7a, 0x405d, 0xa8, 0x57, 0xba, 0x1, 0xd4, 0x75, 0x84, 0x26);
+
+#define INTERFACE ID3DXTextureShader
+DECLARE_INTERFACE_(ID3DXTextureShader, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+    STDMETHOD(GetFunction)(THIS_ struct ID3DXBuffer **ppFunction) PURE;
+    STDMETHOD(GetConstantBuffer)(THIS_ struct ID3DXBuffer **ppConstantBuffer) PURE;
+    STDMETHOD(GetDesc)(THIS_ D3DXCONSTANTTABLE_DESC *pDesc) PURE;
+    STDMETHOD(GetConstantDesc)(THIS_ D3DXHANDLE hConstant, D3DXCONSTANT_DESC *pConstantDesc, UINT *pCount) PURE;
+    STDMETHOD_(D3DXHANDLE, GetConstant)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;
+    STDMETHOD_(D3DXHANDLE, GetConstantByName)(THIS_ D3DXHANDLE hConstant, const char *pName) PURE;
+    STDMETHOD_(D3DXHANDLE, GetConstantElement)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;
+    STDMETHOD(SetDefaults)(THIS) PURE;
+    STDMETHOD(SetValue)(THIS_ D3DXHANDLE hConstant, const void *pData, UINT Bytes) PURE;
+    STDMETHOD(SetBool)(THIS_ D3DXHANDLE hConstant, BOOL b) PURE;
+    STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE hConstant, const BOOL *pb, UINT Count) PURE;
+    STDMETHOD(SetInt)(THIS_ D3DXHANDLE hConstant, INT n) PURE;
+    STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE hConstant, const INT *pn, UINT Count) PURE;
+    STDMETHOD(SetFloat)(THIS_ D3DXHANDLE hConstant, FLOAT f) PURE;
+    STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE hConstant, const FLOAT *pf, UINT Count) PURE;
+    STDMETHOD(SetVector)(THIS_ D3DXHANDLE hConstant, const D3DXVECTOR4 *pVector) PURE;
+    STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE hConstant, const D3DXVECTOR4 *pVector, UINT Count) PURE;
+    STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix) PURE;
+    STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix, UINT Count) PURE;
+    STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX **ppMatrix, UINT Count) PURE;
+    STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix) PURE;
+    STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix, UINT Count) PURE;
+    STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX **ppMatrix, UINT Count) PURE;
+};
+#undef INTERFACE
+
+typedef struct _D3DXMACRO
+{
+    const char *Name;
+    const char *Definition;
 } D3DXMACRO, *LPD3DXMACRO;
 
 typedef struct _D3DXSEMANTIC {
@@ -249,8 +294,9 @@ typedef enum _D3DXINCLUDE_TYPE
 
 DECLARE_INTERFACE(ID3DXInclude)
 {
-    STDMETHOD(Open)(THIS_ D3DXINCLUDE_TYPE include_type, LPCSTR filename, LPCVOID parent_data, LPCVOID *data, UINT *bytes) PURE;
-    STDMETHOD(Close)(THIS_ LPCVOID data) PURE;
+    STDMETHOD(Open)(THIS_ D3DXINCLUDE_TYPE include_type, const char *filename,
+            const void *parent_data, const void **data, UINT *bytes) PURE;
+    STDMETHOD(Close)(THIS_ const void *data) PURE;
 };
 #undef INTERFACE
 
@@ -267,8 +313,8 @@ const char * WINAPI D3DXGetPixelShaderProfile(struct IDirect3DDevice9 *device);
 UINT WINAPI D3DXGetShaderSize(const DWORD *byte_code);
 DWORD WINAPI D3DXGetShaderVersion(const DWORD *byte_code);
 const char * WINAPI D3DXGetVertexShaderProfile(struct IDirect3DDevice9 *device);
-HRESULT WINAPI D3DXFindShaderComment(CONST DWORD* byte_code, DWORD fourcc, LPCVOID* data, UINT* size);
-HRESULT WINAPI D3DXGetShaderSamplers(CONST DWORD *byte_code, LPCSTR *samplers, UINT *count);
+HRESULT WINAPI D3DXFindShaderComment(const DWORD *byte_code, DWORD fourcc, const void **data, UINT *size);
+HRESULT WINAPI D3DXGetShaderSamplers(const DWORD *byte_code, const char **samplers, UINT *count);
 
 HRESULT WINAPI D3DXAssembleShaderFromFileA(const char *filename, const D3DXMACRO *defines,
         ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages);
@@ -289,6 +335,8 @@ HRESULT WINAPI D3DXCompileShader(const char *src_data, UINT data_len, const D3DX
         ID3DXInclude *include, const char *function_name, const char *profile, DWORD flags,
         ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table);
 
+HRESULT WINAPI D3DXDisassembleShader(const DWORD *pShader, BOOL EnableColorCode, const char *pComments, struct ID3DXBuffer **ppDisassembly);
+
 HRESULT WINAPI D3DXCompileShaderFromFileA(const char *filename, const D3DXMACRO *defines,
         ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags,
         ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table);
@@ -324,6 +372,11 @@ HRESULT WINAPI D3DXGetShaderConstantTableEx(const DWORD *byte_code, DWORD flags,
 
 HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table);
 
+HRESULT WINAPI D3DXGetShaderInputSemantics(const DWORD *pFunction, D3DXSEMANTIC *pSemantics, UINT *pCount);
+HRESULT WINAPI D3DXGetShaderOutputSemantics(const DWORD *pFunction, D3DXSEMANTIC *pSemantics, UINT *pCount);
+
+HRESULT WINAPI D3DXCreateTextureShader(const DWORD *pFunction, ID3DXTextureShader **ppTextureShader);
+
 #ifdef __cplusplus
 }
 #endif
index 295a324..542460f 100644 (file)
 #define D3DX_FILTER_SRGB_OUT             0x00400000
 #define D3DX_FILTER_SRGB                 0x00600000
 
+#define D3DX_SKIP_DDS_MIP_LEVELS_MASK    0x1f
+#define D3DX_SKIP_DDS_MIP_LEVELS_SHIFT   26
+#define D3DX_SKIP_DDS_MIP_LEVELS(l, f)   ((((l) & D3DX_SKIP_DDS_MIP_LEVELS_MASK) \
+        << D3DX_SKIP_DDS_MIP_LEVELS_SHIFT) | ((f) == D3DX_DEFAULT ? D3DX_FILTER_BOX : (f)))
+
 #define D3DX_NORMALMAP_MIRROR_U          0x00010000
 #define D3DX_NORMALMAP_MIRROR_V          0x00020000
 #define D3DX_NORMALMAP_MIRROR            0x00030000
@@ -83,8 +88,10 @@ typedef struct _D3DXIMAGE_INFO
  ****************** Functions *****************
  **********************************************/
 /* Typedefs for callback functions */
-typedef VOID (WINAPI *LPD3DXFILL2D)(D3DXVECTOR4 *out, CONST D3DXVECTOR2 *texcoord, CONST D3DXVECTOR2 *texelsize, LPVOID data);
-typedef VOID (WINAPI *LPD3DXFILL3D)(D3DXVECTOR4 *out, CONST D3DXVECTOR3 *texcoord, CONST D3DXVECTOR3 *texelsize, LPVOID data);
+typedef void (WINAPI *LPD3DXFILL2D)(D3DXVECTOR4 *out, const D3DXVECTOR2 *texcoord,
+        const D3DXVECTOR2 *texelsize, void *data);
+typedef void (WINAPI *LPD3DXFILL3D)(D3DXVECTOR4 *out, const D3DXVECTOR3 *texcoord,
+        const D3DXVECTOR3 *texelsize, void *data);
 
 #ifdef __cplusplus
 extern "C" {
@@ -92,15 +99,15 @@ extern "C" {
 
 
 /* Image Information */
-HRESULT WINAPI D3DXGetImageInfoFromFileA(LPCSTR file, D3DXIMAGE_INFO *info);
+HRESULT WINAPI D3DXGetImageInfoFromFileA(const char *file, D3DXIMAGE_INFO *info);
 HRESULT WINAPI D3DXGetImageInfoFromFileW(const WCHAR *file, D3DXIMAGE_INFO *info);
 #define        D3DXGetImageInfoFromFile WINELIB_NAME_AW(D3DXGetImageInfoFromFile)
 
-HRESULT WINAPI D3DXGetImageInfoFromResourceA(HMODULE module, LPCSTR resource, D3DXIMAGE_INFO *info);
+HRESULT WINAPI D3DXGetImageInfoFromResourceA(HMODULE module, const char *resource, D3DXIMAGE_INFO *info);
 HRESULT WINAPI D3DXGetImageInfoFromResourceW(HMODULE module, const WCHAR *resource, D3DXIMAGE_INFO *info);
 #define        D3DXGetImageInfoFromResource WINELIB_NAME_AW(D3DXGetImageInfoFromResource)
 
-HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(LPCVOID data, UINT datasize, D3DXIMAGE_INFO *info);
+HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(const void *data, UINT data_size, D3DXIMAGE_INFO *info);
 
 
 /* Surface Loading/Saving */
index 785bc1c..35019f2 100644 (file)
@@ -40,14 +40,16 @@ typedef DWORD D3DXF_FILELOADOPTIONS;
 #define D3DXF_FILELOAD_FROMRESOURCE 0x02
 #define D3DXF_FILELOAD_FROMMEMORY   0x03
 
-typedef struct _D3DXF_FILELOADRESOURCE {
+typedef struct _D3DXF_FILELOADRESOURCE
+{
     HMODULE hModule;
-    LPCSTR lpName;
-    LPCSTR lpType;
+    const char *lpName;
+    const char *lpType;
 } D3DXF_FILELOADRESOURCE;
 
-typedef struct _D3DXF_FILELOADMEMORY {
-    LPVOID lpMemory;
+typedef struct _D3DXF_FILELOADMEMORY
+{
+    void *lpMemory;
     SIZE_T dSize;
 } D3DXF_FILELOADMEMORY;
 
@@ -72,7 +74,7 @@ STDAPI D3DXFileCreate(struct ID3DXFile **file);
 DECLARE_INTERFACE_IID_(ID3DXFile,IUnknown,"cef08cf9-7b4f-4429-9624-2a690a933201")
 {
     /*** IUnknown methods ***/
-    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID, LPVOID*) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE;
     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
     STDMETHOD_(ULONG,Release)(THIS) PURE;
     /*** ID3DXFile methods ***/
@@ -80,7 +82,7 @@ DECLARE_INTERFACE_IID_(ID3DXFile,IUnknown,"cef08cf9-7b4f-4429-9624-2a690a933201"
             struct ID3DXFileEnumObject **enum_obj) PURE;
     STDMETHOD(CreateSaveObject)(THIS_ const void *data, D3DXF_FILESAVEOPTIONS flags,
             D3DXF_FILEFORMAT format, struct ID3DXFileSaveObject **save_obj) PURE;
-    STDMETHOD(RegisterTemplates)(THIS_ LPCVOID, SIZE_T) PURE;
+    STDMETHOD(RegisterTemplates)(THIS_ const void *data, SIZE_T data_size) PURE;
     STDMETHOD(RegisterEnumTemplates)(THIS_ struct ID3DXFileEnumObject *enum_obj) PURE;
 };
 #undef INTERFACE
@@ -89,7 +91,7 @@ DECLARE_INTERFACE_IID_(ID3DXFile,IUnknown,"cef08cf9-7b4f-4429-9624-2a690a933201"
 DECLARE_INTERFACE_IID_(ID3DXFileSaveObject,IUnknown,"cef08cfa-7b4f-4429-9624-2a690a933201")
 {
     /*** IUnknown methods ***/
-    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID, LPVOID*) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE;
     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
     STDMETHOD_(ULONG,Release)(THIS) PURE;
     /*** ID3DXFileSaveObject methods ***/
@@ -104,17 +106,17 @@ DECLARE_INTERFACE_IID_(ID3DXFileSaveObject,IUnknown,"cef08cfa-7b4f-4429-9624-2a6
 DECLARE_INTERFACE_IID_(ID3DXFileSaveData,IUnknown,"cef08cfb-7b4f-4429-9624-2a690a933201")
 {
     /*** IUnknown methods ***/
-    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID, LPVOID*) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE;
     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
     STDMETHOD_(ULONG,Release)(THIS) PURE;
     /*** ID3DXFileSaveObject methods ***/
     STDMETHOD(GetSave)(THIS_ ID3DXFileSaveObject **save_obj) PURE;
-    STDMETHOD(GetName)(THIS_ LPSTR, SIZE_T*) PURE;
+    STDMETHOD(GetName)(THIS_ char *name, SIZE_T *size) PURE;
     STDMETHOD(GetId)(THIS_ LPGUID) PURE;
     STDMETHOD(GetType)(THIS_ GUID*) PURE;
     STDMETHOD(AddDataObject)(THIS_ REFGUID template_guid, const char *name, const GUID *guid,
             SIZE_T data_size, const void *data, ID3DXFileSaveData **obj) PURE;
-    STDMETHOD(AddDataReference)(THIS_ LPCSTR, CONST GUID*) PURE;
+    STDMETHOD(AddDataReference)(THIS_ const char *name, const GUID *id) PURE;
 };
 #undef INTERFACE
 
@@ -123,7 +125,7 @@ DECLARE_INTERFACE_IID_(ID3DXFileSaveData,IUnknown,"cef08cfb-7b4f-4429-9624-2a690
 DECLARE_INTERFACE_IID_(ID3DXFileEnumObject,IUnknown,"cef08cfc-7b4f-4429-9624-2a690a933201")
 {
     /*** IUnknown methods ***/
-    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID, LPVOID*) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE;
     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
     STDMETHOD_(ULONG,Release)(THIS) PURE;
     /*** ID3DXFileEnumObject methods ***/
@@ -139,14 +141,14 @@ DECLARE_INTERFACE_IID_(ID3DXFileEnumObject,IUnknown,"cef08cfc-7b4f-4429-9624-2a6
 DECLARE_INTERFACE_IID_(ID3DXFileData,IUnknown,"cef08cfd-7b4f-4429-9624-2a690a933201")
 {
     /*** IUnknown methods ***/
-    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID, LPVOID*) PURE;
+    STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE;
     STDMETHOD_(ULONG,AddRef)(THIS) PURE;
     STDMETHOD_(ULONG,Release)(THIS) PURE;
     /*** ID3DXFileData methods ***/
     STDMETHOD(GetEnum)(THIS_ ID3DXFileEnumObject **enum_obj) PURE;
-    STDMETHOD(GetName)(THIS_ LPSTR, SIZE_T*) PURE;
+    STDMETHOD(GetName)(THIS_ char *name, SIZE_T *size) PURE;
     STDMETHOD(GetId)(THIS_ LPGUID) PURE;
-    STDMETHOD(Lock)(THIS_ SIZE_T*, LPCVOID*) PURE;
+    STDMETHOD(Lock)(THIS_ SIZE_T *data_size, const void **data) PURE;
     STDMETHOD(Unlock)(THIS) PURE;
     STDMETHOD(GetType)(THIS_ GUID*) PURE;
     STDMETHOD_(BOOL,IsReference)(THIS) PURE;