root/trunk/win32/directx/d3dx9.d

Revision 262, 79.2 kB (checked in by korDen, 4 years ago)

d3dx9, dinput8 and dsound8 bindings added alongside with a .def files

Line 
1 // D3DX Types and Constants ---------------------------------------------------------------------------------------
2
3 module win32.directx.d3dx9;
4
5 public import win32.directx.d3d9;
6 public import win32.windows;
7
8 alias D3DMATRIX D3DXMATRIX;
9
10 const uint MAXD3DDECLLENGTH = 64;
11 const uint MAX_FVF_DECL_SIZE = MAXD3DDECLLENGTH + 1;
12
13 align(4) struct D3DXATTRIBUTERANGE
14 {
15     DWORD AttribId;
16     DWORD FaceStart;
17     DWORD FaceCount;
18     DWORD VertexStart;
19     DWORD VertexCount;
20 }
21
22 align(4) struct D3DXVECTOR2
23 {
24     float x = 0, y = 0;
25
26     static D3DXVECTOR2 opCall(float x, float y)
27     {
28         D3DXVECTOR2 v;
29         v.x = x;
30         v.y = y;
31         return v;
32     }
33 }
34
35 alias D3DVECTOR D3DXVECTOR3;
36
37 align(4) struct D3DXVECTOR4
38 {
39     float x = 0, y = 0, z = 0, w = 0;
40
41     static D3DXVECTOR4 opCall(float x, float y, float z, float w)
42     {
43         D3DXVECTOR4 v;
44         v.x = x;
45         v.y = y;
46         v.z = z;
47         v.w = w;
48         return v;
49     }
50 }
51
52 align(4) struct D3DXQUATERNION
53 {
54     float x = 0, y = 0, z = 0, w = 0;
55 }
56
57 align(4) struct D3DXFRAME
58 {
59     LPSTR                   Name;
60     D3DXMATRIX              TransformationMatrix;
61
62     D3DXMESHCONTAINER*     pMeshContainer;
63
64     D3DXFRAME       *pFrameSibling;
65     D3DXFRAME       *pFrameFirstChild;
66 }
67
68 align(4) struct D3DXMESHCONTAINER
69 {
70     LPSTR                   Name;
71
72     D3DXMESHDATA            MeshData;
73
74     D3DXMATERIAL*          pMaterials;
75     D3DXEFFECTINSTANCE*    pEffects;
76     DWORD                   NumMaterials;
77     DWORD                  *pAdjacency;
78
79     ID3DXSkinInfo          pSkinInfo;
80
81     D3DXMESHCONTAINER* pNextMeshContainer;
82 }
83
84 align(4) struct D3DXMESHDATA
85 {
86     D3DXMESHDATATYPE Type;
87
88     // current mesh data interface
89     union
90     {
91         ID3DXMesh              pMesh;
92         ID3DXPMesh             pPMesh;
93         ID3DXPatchMesh         pPatchMesh;
94     }
95 }
96
97 alias uint D3DXMESHDATATYPE;
98 enum : uint
99 {
100     D3DXMESHTYPE_MESH      = 0x001,             // Normal ID3DXMesh data
101     D3DXMESHTYPE_PMESH     = 0x002,             // Progressive Mesh - ID3DXPMesh
102     D3DXMESHTYPE_PATCHMESH = 0x003             // Patch Mesh - ID3DXPatchMesh
103 }
104
105 align(4) struct D3DXMATERIAL
106 {
107     D3DMATERIAL9  MatD3D;
108     LPSTR         pTextureFilename;
109 }
110
111 alias uint D3DXEFFECTDEFAULTTYPE;
112 enum : uint
113 {
114     D3DXEDT_STRING = 0x1,       // pValue points to a null terminated ASCII string
115     D3DXEDT_FLOATS = 0x2,       // pValue points to an array of floats - number of floats is NumBytes / sizeof(float)
116     D3DXEDT_DWORD  = 0x3       // pValue points to a DWORD
117 }
118
119 align(4) struct D3DXEFFECTDEFAULT
120 {
121     LPSTR                 pParamName;
122     D3DXEFFECTDEFAULTTYPE Type;           // type of the data pointed to by pValue
123     DWORD                 NumBytes;       // size in bytes of the data pointed to by pValue
124     LPVOID                pValue;         // data for the default of the effect
125 }
126
127 align(4) struct D3DXEFFECTINSTANCE
128 {
129     LPSTR               pEffectFilename;
130     DWORD               NumDefaults;
131     D3DXEFFECTDEFAULT* pDefaults;
132 }
133
134 alias uint D3DXPATCHMESHTYPE;
135 enum : uint
136 {
137     D3DXPATCHMESH_RECT   = 0x001,
138     D3DXPATCHMESH_TRI    = 0x002,
139     D3DXPATCHMESH_NPATCH = 0x003
140 }
141
142 align(4) struct D3DXPATCHINFO
143 {
144     D3DXPATCHMESHTYPE PatchType;
145     D3DDEGREETYPE Degree;
146     D3DBASISTYPE Basis;
147 }
148
149 const uint LF_FACESIZE = 32;
150
151 align(4) struct D3DXFONT_DESCA
152 {
153     INT Height;
154     UINT Width;
155     UINT Weight;
156     UINT MipLevels;
157     BOOL Italic;
158     BYTE CharSet;
159     BYTE OutputPrecision;
160     BYTE Quality;
161     BYTE PitchAndFamily;
162     CHAR FaceName[LF_FACESIZE];
163 }
164
165 align(4) struct D3DXFONT_DESCW
166 {
167     INT Height;
168     UINT Width;
169     UINT Weight;
170     UINT MipLevels;
171     BOOL Italic;
172     BYTE CharSet;
173     BYTE OutputPrecision;
174     BYTE Quality;
175     BYTE PitchAndFamily;
176     WCHAR FaceName[LF_FACESIZE];
177 }
178
179 align(4) struct TEXTMETRICA
180 {
181     LONG        tmHeight;
182     LONG        tmAscent;
183     LONG        tmDescent;
184     LONG        tmInternalLeading;
185     LONG        tmExternalLeading;
186     LONG        tmAveCharWidth;
187     LONG        tmMaxCharWidth;
188     LONG        tmWeight;
189     LONG        tmOverhang;
190     LONG        tmDigitizedAspectX;
191     LONG        tmDigitizedAspectY;
192     BYTE        tmFirstChar;
193     BYTE        tmLastChar;
194     BYTE        tmDefaultChar;
195     BYTE        tmBreakChar;
196     BYTE        tmItalic;
197     BYTE        tmUnderlined;
198     BYTE        tmStruckOut;
199     BYTE        tmPitchAndFamily;
200     BYTE        tmCharSet;
201 }
202
203 align(4) struct TEXTMETRICW
204 {
205     LONG        tmHeight;
206     LONG        tmAscent;
207     LONG        tmDescent;
208     LONG        tmInternalLeading;
209     LONG        tmExternalLeading;
210     LONG        tmAveCharWidth;
211     LONG        tmMaxCharWidth;
212     LONG        tmWeight;
213     LONG        tmOverhang;
214     LONG        tmDigitizedAspectX;
215     LONG        tmDigitizedAspectY;
216     WCHAR       tmFirstChar;
217     WCHAR       tmLastChar;
218     WCHAR       tmDefaultChar;
219     WCHAR       tmBreakChar;
220     BYTE        tmItalic;
221     BYTE        tmUnderlined;
222     BYTE        tmStruckOut;
223     BYTE        tmPitchAndFamily;
224     BYTE        tmCharSet;
225 }
226
227 align(4) struct D3DXEFFECT_DESC
228 {
229     LPCSTR Creator;                     // Creator string
230     UINT Parameters;                    // Number of parameters
231     UINT Techniques;                    // Number of techniques
232     UINT Functions;                     // Number of function entrypoints
233 }
234
235 alias char* D3DXHANDLE;
236
237 align(4) struct D3DXPARAMETER_DESC
238 {
239     LPCSTR Name;                        // Parameter name
240     LPCSTR Semantic;                    // Parameter semantic
241     D3DXPARAMETER_CLASS Class;          // Class
242     D3DXPARAMETER_TYPE Type;            // Component type
243     UINT Rows;                          // Number of rows
244     UINT Columns;                       // Number of columns
245     UINT Elements;                      // Number of array elements
246     UINT Annotations;                   // Number of annotations
247     UINT StructMembers;                 // Number of structure member sub-parameters
248     DWORD Flags;                        // D3DX_PARAMETER_* flags
249     UINT Bytes;                         // Parameter size, in bytes
250 }
251
252 alias uint D3DXPARAMETER_CLASS;
253 enum : uint
254 {
255     D3DXPC_SCALAR,
256     D3DXPC_VECTOR,
257     D3DXPC_MATRIX_ROWS,
258     D3DXPC_MATRIX_COLUMNS,
259     D3DXPC_OBJECT,
260     D3DXPC_STRUCT
261 }
262
263 alias uint D3DXPARAMETER_TYPE;
264 enum : uint
265 {
266     D3DXPT_VOID,
267     D3DXPT_BOOL,
268     D3DXPT_INT,
269     D3DXPT_FLOAT,
270     D3DXPT_STRING,
271     D3DXPT_TEXTURE,
272     D3DXPT_TEXTURE1D,
273     D3DXPT_TEXTURE2D,
274     D3DXPT_TEXTURE3D,
275     D3DXPT_TEXTURECUBE,
276     D3DXPT_SAMPLER,
277     D3DXPT_SAMPLER1D,
278     D3DXPT_SAMPLER2D,
279     D3DXPT_SAMPLER3D,
280     D3DXPT_SAMPLERCUBE,
281     D3DXPT_PIXELSHADER,
282     D3DXPT_VERTEXSHADER,
283     D3DXPT_PIXELFRAGMENT,
284     D3DXPT_VERTEXFRAGMENT
285 }
286
287 align(4) struct D3DXTECHNIQUE_DESC
288 {
289     LPCSTR Name;                        // Technique name
290     UINT Passes;                        // Number of passes
291     UINT Annotations;                   // Number of annotations
292 }
293
294 align(4) struct D3DXPASS_DESC
295 {
296     LPCSTR Name;                        // Pass name
297     UINT Annotations;                   // Number of annotations
298
299     DWORD *pVertexShaderFunction; // Vertex shader function
300     DWORD *pPixelShaderFunction;  // Pixel shader function
301 }
302
303 align(4) struct D3DXFUNCTION_DESC
304 {
305     LPCSTR Name;                        // Function name
306     UINT Annotations;                   // Number of annotations
307 }
308
309 struct D3DXTRACK_DESC
310 {
311     DWORD Priority;
312     FLOAT Weight = 0;
313     FLOAT Speed = 0;
314     double Position = 0;
315     BOOL Enable;
316 }
317
318 align(4) struct D3DXEVENT_DESC
319 {
320     DWORD      Type;
321     UINT                Track;
322     double              StartTime = 0;
323     double              Duration = 0;
324     DWORD Transition;
325     union
326     {
327         FLOAT           Weight = 0;
328         FLOAT           Speed;
329         double          Position;
330         BOOL            Enable;
331     };
332 }
333
334 align(4) struct D3DXKEY_VECTOR3
335 {
336     FLOAT Time = 0;
337     D3DXVECTOR3 Value;
338 }
339
340 align(4) struct D3DXKEY_QUATERNION
341 {
342     FLOAT Time = 0;
343     D3DXQUATERNION Value;
344 }
345
346 align(4) struct D3DXKEY_CALLBACK
347 {
348     FLOAT Time = 0;
349     LPVOID pCallbackData;
350 }
351
352 align(4) struct D3DXIMAGE_INFO
353 {
354     UINT                    Width;
355     UINT                    Height;
356     UINT                    Depth;
357     UINT                    MipLevels;
358     D3DFORMAT               Format;
359     D3DRESOURCETYPE         ResourceType;
360     D3DXIMAGE_FILEFORMAT    ImageFileFormat;
361 }
362
363 alias uint D3DXIMAGE_FILEFORMAT;
364 enum : uint
365 {
366     D3DXIFF_BMP         = 0,
367     D3DXIFF_JPG         = 1,
368     D3DXIFF_TGA         = 2,
369     D3DXIFF_PNG         = 3,
370     D3DXIFF_DDS         = 4,
371     D3DXIFF_PPM         = 5,
372     D3DXIFF_DIB         = 6,
373 }
374
375 align(4) struct D3DXATTRIBUTEWEIGHTS
376 {
377     FLOAT Position = 0;
378     FLOAT Boundary = 0;
379     FLOAT Normal = 0;
380     FLOAT Diffuse = 0;
381     FLOAT Specular = 0;
382     FLOAT Texcoord[8] = 0;
383     FLOAT Tangent = 0;
384     FLOAT Binormal = 0;
385 }
386
387 align(4) struct D3DXPLANE
388 {
389     FLOAT a = 0, b = 0, c = 0, d = 0;
390 }
391
392 alias uint D3DXMESH;
393 enum : uint
394 {
395     D3DXMESH_32BIT                  = 0x001,
396     D3DXMESH_DONOTCLIP              = 0x002,
397     D3DXMESH_POINTS                 = 0x004,
398     D3DXMESH_RTPATCHES              = 0x008,
399     D3DXMESH_NPATCHES               = 0x4000,
400     D3DXMESH_VB_SYSTEMMEM           = 0x010,
401     D3DXMESH_VB_MANAGED             = 0x020,
402     D3DXMESH_VB_WRITEONLY           = 0x040,
403     D3DXMESH_VB_DYNAMIC             = 0x080,
404     D3DXMESH_VB_SOFTWAREPROCESSING = 0x8000,
405     D3DXMESH_IB_SYSTEMMEM           = 0x100,
406     D3DXMESH_IB_MANAGED             = 0x200,
407     D3DXMESH_IB_WRITEONLY           = 0x400,
408     D3DXMESH_IB_DYNAMIC             = 0x800,
409     D3DXMESH_IB_SOFTWAREPROCESSING= 0x10000,
410     D3DXMESH_VB_SHARE               = 0x1000,
411     D3DXMESH_USEHWONLY              = 0x2000,
412     D3DXMESH_SYSTEMMEM              = 0x110,
413     D3DXMESH_MANAGED                = 0x220,
414     D3DXMESH_WRITEONLY              = 0x440,
415     D3DXMESH_DYNAMIC                = 0x880,
416     D3DXMESH_SOFTWAREPROCESSING   = 0x18000,
417 }
418
419 align(4) struct D3DXMACRO
420 {
421     LPCSTR Name;
422     LPCSTR Definition;
423 }
424
425 align(4) struct D3DXSEMANTIC
426 {
427     UINT Usage;
428     UINT UsageIndex;
429 }
430
431 alias uint D3DXINCLUDE_TYPE;
432 enum : uint
433 {
434     D3DXINC_LOCAL,
435     D3DXINC_SYSTEM,
436 }
437
438 enum : uint
439 {
440     D3DXFX_DONOTSAVESTATE         = (1 << 0),
441     D3DXFX_DONOTSAVESHADERSTATE   = (1 << 1),
442     D3DXFX_DONOTSAVESAMPLERSTATE  = (1 << 2),
443     D3DXFX_NOT_CLONEABLE          = (1 << 11)
444 }
445
446 alias uint D3DXMESHSIMP;
447 enum : uint
448 {
449     D3DXMESHSIMP_VERTEX   = 0x1,
450     D3DXMESHSIMP_FACE     = 0x2
451 }
452
453 enum : uint
454 {
455     DT_TOP                      = 0x00000000,
456     DT_LEFT                     = 0x00000000,
457     DT_CENTER                   = 0x00000001,
458     DT_RIGHT                    = 0x00000002,
459     DT_VCENTER                  = 0x00000004,
460     DT_BOTTOM                   = 0x00000008,
461     DT_WORDBREAK                = 0x00000010,
462     DT_SINGLELINE               = 0x00000020,
463     DT_EXPANDTABS               = 0x00000040,
464     DT_TABSTOP                  = 0x00000080,
465     DT_NOCLIP                   = 0x00000100,
466     DT_EXTERNALLEADING          = 0x00000200,
467     DT_CALCRECT                 = 0x00000400,
468     DT_NOPREFIX                 = 0x00000800,
469     DT_INTERNAL                 = 0x00001000
470 }
471
472 enum : uint
473 {
474     D3DXSPRITE_DONOTSAVESTATE               = (1 << 0),
475     D3DXSPRITE_DONOTMODIFY_RENDERSTATE      = (1 << 1),
476     D3DXSPRITE_OBJECTSPACE                  = (1 << 2),
477     D3DXSPRITE_BILLBOARD                    = (1 << 3),
478     D3DXSPRITE_ALPHABLEND                   = (1 << 4),
479     D3DXSPRITE_SORT_TEXTURE                 = (1 << 5),
480     D3DXSPRITE_SORT_DEPTH_FRONTTOBACK       = (1 << 6),
481     D3DXSPRITE_SORT_DEPTH_BACKTOFRONT       = (1 << 7)
482 }
483
484 enum : uint
485 {
486     D3DX_FILTER_NONE             = (1 << 0),
487     D3DX_FILTER_POINT            = (2 << 0),
488     D3DX_FILTER_LINEAR           = (3 << 0),
489     D3DX_FILTER_TRIANGLE         = (4 << 0),
490     D3DX_FILTER_BOX              = (5 << 0),
491     D3DX_FILTER_MIRROR_U         = (1 << 16),
492     D3DX_FILTER_MIRROR_V         = (2 << 16),
493     D3DX_FILTER_MIRROR_W         = (4 << 16),
494     D3DX_FILTER_MIRROR           = (7 << 16),
495     D3DX_FILTER_DITHER           = (1 << 19),
496     D3DX_FILTER_DITHER_DIFFUSION = (2 << 19),
497     D3DX_FILTER_SRGB_IN          = (1 << 21),
498     D3DX_FILTER_SRGB_OUT         = (2 << 21),
499     D3DX_FILTER_SRGB             = (3 << 21)
500 }
501
502 const uint D3DX_DEFAULT            = cast(UINT) -1;
503
504 alias uint D3DXMESHOPT;
505 enum : uint
506 {
507     D3DXMESHOPT_COMPACT       = 0x01000000,
508     D3DXMESHOPT_ATTRSORT      = 0x02000000,
509     D3DXMESHOPT_VERTEXCACHE   = 0x04000000,
510     D3DXMESHOPT_STRIPREORDER  = 0x08000000,
511     D3DXMESHOPT_IGNOREVERTS   = 0x10000000,  // optimize faces only, don't touch vertices
512     D3DXMESHOPT_DONOTSPLIT    = 0x20000000,  // do not split vertices shared between attribute groups when attribute sorting
513     D3DXMESHOPT_DEVICEINDEPENDENT = 0x00400000  // Only affects VCache.  uses a static known good cache size for all cards
514 }
515
516 enum : uint
517 {
518     D3DXPLAY_LOOP = 0,
519     D3DXPLAY_ONCE = 1,
520     D3DXPLAY_PINGPONG = 2
521 }
522 alias uint D3DXPLAYBACK_TYPE;
523
524
525 // D3DX Interfaces ---------------------------------------------------------------------------------------
526
527 interface ID3DXSkinInfo : IUnknown
528 {
529     extern(Windows):
530
531     // Specify the which vertices do each bones influence and by how much
532     HRESULT SetBoneInfluence(DWORD bone, DWORD numInfluences, DWORD* vertices, FLOAT* weights);
533     HRESULT SetBoneVertexInfluence(DWORD boneNum, DWORD influenceNum, float weight);
534     DWORD GetNumBoneInfluences(DWORD bone);
535     HRESULT GetBoneInfluence(DWORD bone, DWORD* vertices, FLOAT* weights);
536     HRESULT GetBoneVertexInfluence(DWORD boneNum, DWORD influenceNum, float *pWeight, DWORD *pVertexNum);
537     HRESULT GetMaxVertexInfluences(DWORD* maxVertexInfluences);
538     DWORD GetNumBones();
539     HRESULT FindBoneVertexInfluenceIndex(DWORD boneNum, DWORD vertexNum, DWORD *pInfluenceIndex);
540
541     // This gets the max face influences based on a triangle mesh with the specified index buffer
542     HRESULT GetMaxFaceInfluences(IDirect3DIndexBuffer9 pIB, DWORD NumFaces, DWORD* maxFaceInfluences);
543
544     // Set min bone influence. Bone influences that are smaller than this are ignored
545     HRESULT SetMinBoneInfluence(FLOAT MinInfl);
546     // Get min bone influence.
547     FLOAT GetMinBoneInfluence();
548
549     // Bone names are returned by D3DXLoadSkinMeshFromXof. They are not used by any other method of this object
550     HRESULT SetBoneName(DWORD Bone, LPCSTR pName); // pName is copied to an internal string buffer
551     LPCSTR GetBoneName(DWORD Bone); // A pointer to an internal string buffer is returned. Do not free this.
552
553     // Bone offset matrices are returned by D3DXLoadSkinMeshFromXof. They are not used by any other method of this object
554     HRESULT SetBoneOffsetMatrix(DWORD Bone, D3DXMATRIX *pBoneTransform); // pBoneTransform is copied to an internal buffer
555     D3DXMATRIX* GetBoneOffsetMatrix(DWORD Bone); // A pointer to an internal matrix is returned. Do not free this.
556
557     // Clone a skin info object
558     HRESULT Clone(ID3DXSkinInfo* ppSkinInfo);
559
560     // Update bone influence information to match vertices after they are reordered. This should be called
561     // if the target vertex buffer has been reordered externally.
562     HRESULT Remap(DWORD NumVertices, DWORD* pVertexRemap);
563
564     // These methods enable the modification of the vertex layout of the vertices that will be skinned
565     HRESULT SetFVF(DWORD FVF);
566     HRESULT SetDeclaration(D3DVERTEXELEMENT9 *pDeclaration);
567     DWORD GetFVF();
568     HRESULT GetDeclaration(D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]);
569
570     // Apply SW skinning based on current pose matrices to the target vertices.
571     HRESULT UpdateSkinnedMesh(
572         D3DXMATRIX* pBoneTransforms,
573         D3DXMATRIX* pBoneInvTransposeTransforms,
574         LPCVOID pVerticesSrc,
575         PVOID pVerticesDst);
576
577     // Takes a mesh and returns a new mesh with per vertex blend weights and a bone combination
578     // table that describes which bones affect which subsets of the mesh
579     HRESULT ConvertToBlendedMesh(
580         ID3DXMesh pMesh,
581         DWORD Options,
582         DWORD *pAdjacencyIn,
583         LPDWORD pAdjacencyOut,
584         DWORD* pFaceRemap,
585         ID3DXBuffer* ppVertexRemap,
586         DWORD* pMaxFaceInfl,
587         DWORD* pNumBoneCombinations,
588         ID3DXBuffer* ppBoneCombinationTable,
589         ID3DXMesh* ppMesh);
590
591     // Takes a mesh and returns a new mesh with per vertex blend weights and indices
592     // and a bone combination table that describes which bones palettes affect which subsets of the mesh
593     HRESULT ConvertToIndexedBlendedMesh(
594         ID3DXMesh pMesh,
595         DWORD Options,
596         DWORD paletteSize,
597         DWORD *pAdjacencyIn,
598         LPDWORD pAdjacencyOut,
599         DWORD* pFaceRemap,
600         ID3DXBuffer* ppVertexRemap,
601         DWORD* pMaxVertexInfl,
602         DWORD *pNumBoneCombinations,
603         ID3DXBuffer* ppBoneCombinationTable,
604         ID3DXMesh* ppMesh);
605 }
606
607 interface ID3DXBaseMesh : IUnknown
608 {
609     extern(Windows):
610
611     // ID3DXBaseMesh
612     HRESULT DrawSubset( DWORD AttribId) ;
613     DWORD GetNumFaces() ;
614     DWORD GetNumVertices() ;
615     DWORD GetFVF() ;
616     HRESULT GetDeclaration( D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) ;
617     DWORD GetNumBytesPerVertex() ;
618     DWORD GetOptions() ;
619     HRESULT GetDevice( IDirect3DDevice9* ppDevice) ;
620     HRESULT CloneMeshFVF( DWORD Options,
621                 DWORD FVF, IDirect3DDevice9 pD3DDevice, ID3DXMesh* ppCloneMesh) ;
622     HRESULT CloneMesh( DWORD Options,
623                  D3DVERTEXELEMENT9 *pDeclaration, IDirect3DDevice9 pD3DDevice, ID3DXMesh* ppCloneMesh) ;
624     HRESULT GetVertexBuffer( IDirect3DVertexBuffer9* ppVB) ;
625     HRESULT GetIndexBuffer( IDirect3DIndexBuffer9* ppIB) ;
626     HRESULT LockVertexBuffer( DWORD Flags, LPVOID *ppData) ;
627     HRESULT UnlockVertexBuffer() ;
628     HRESULT LockIndexBuffer( DWORD Flags, LPVOID *ppData) ;
629     HRESULT UnlockIndexBuffer() ;
630     HRESULT GetAttributeTable(
631                  D3DXATTRIBUTERANGE *pAttribTable, DWORD* pAttribTableSize) ;
632
633     HRESULT ConvertPointRepsToAdjacency(  DWORD* pPRep, DWORD* pAdjacency) ;
634     HRESULT ConvertAdjacencyToPointReps(  DWORD* pAdjacency, DWORD* pPRep) ;
635     HRESULT GenerateAdjacency( FLOAT Epsilon, DWORD* pAdjacency) ;
636
637     HRESULT UpdateSemantics( D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) ;
638 }
639
640 interface ID3DXMesh : ID3DXBaseMesh
641 {
642     extern(Windows):
643
644     // ID3DXMesh
645     HRESULT LockAttributeBuffer( DWORD Flags, DWORD** ppData) ;
646     HRESULT UnlockAttributeBuffer() ;
647     HRESULT Optimize( DWORD Flags,  DWORD* pAdjacencyIn, DWORD* pAdjacencyOut,
648                      DWORD* pFaceRemap, ID3DXBuffer *ppVertexRemap,
649                      ID3DXMesh* ppOptMesh) ;
650     HRESULT OptimizeInplace( DWORD Flags,  DWORD* pAdjacencyIn, DWORD* pAdjacencyOut,
651                      DWORD* pFaceRemap, ID3DXBuffer *ppVertexRemap) ;
652     HRESULT SetAttributeTable(  D3DXATTRIBUTERANGE *pAttribTable, DWORD cAttribTableSize) ;
653 }
654
655 interface ID3DXBuffer : IUnknown
656 {
657     extern(Windows):
658
659     // ID3DXBuffer
660     LPVOID GetBufferPointer();
661     DWORD GetBufferSize();
662 }
663
664 interface ID3DXPMesh : ID3DXBaseMesh
665 {
666     extern(Windows):
667
668     // ID3DXPMesh
669     HRESULT ClonePMeshFVF( DWORD Options,
670                 DWORD FVF, IDirect3DDevice9 pD3DDevice, ID3DXPMesh* ppCloneMesh) ;
671     HRESULT ClonePMesh( DWORD Options,
672                  D3DVERTEXELEMENT9 *pDeclaration, IDirect3DDevice9 pD3DDevice, ID3DXPMesh* ppCloneMesh) ;
673     HRESULT SetNumFaces( DWORD Faces) ;
674     HRESULT SetNumVertices( DWORD Vertices) ;
675     DWORD GetMaxFaces() ;
676     DWORD GetMinFaces() ;
677     DWORD GetMaxVertices() ;
678     DWORD GetMinVertices() ;
679     HRESULT Save( void *pStream,  D3DXMATERIAL* pMaterials,  D3DXEFFECTINSTANCE* pEffectInstances, DWORD NumMaterials) ;
680
681     HRESULT Optimize( DWORD Flags, DWORD* pAdjacencyOut,
682                      DWORD* pFaceRemap, ID3DXBuffer *ppVertexRemap,
683                      ID3DXMesh* ppOptMesh) ;
684
685     HRESULT OptimizeBaseLOD( DWORD Flags, DWORD* pFaceRemap) ;
686     HRESULT TrimByFaces( DWORD NewFacesMin, DWORD NewFacesMax, DWORD *rgiFaceRemap, DWORD *rgiVertRemap) ;
687     HRESULT TrimByVertices( DWORD NewVerticesMin, DWORD NewVerticesMax, DWORD *rgiFaceRemap, DWORD *rgiVertRemap) ;
688
689     HRESULT GetAdjacency( DWORD* pAdjacency) ;
690
691     //  Used to generate the immediate "ancestor" for each vertex when it is removed by a vsplit.  Allows generation of geomorphs
692     //     Vertex buffer must be equal to or greater than the maximum number of vertices in the pmesh
693     HRESULT GenerateVertexHistory( DWORD* pVertexHistory) ;
694 }
695
696 interface ID3DXPatchMesh : IUnknown
697 {
698     extern(Windows):
699
700     // ID3DXPatchMesh
701
702     // Return creation parameters
703     DWORD GetNumPatches() ;
704     DWORD GetNumVertices() ;
705     HRESULT GetDeclaration( D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) ;
706     DWORD GetControlVerticesPerPatch() ;
707     DWORD GetOptions() ;
708     HRESULT GetDevice( IDirect3DDevice9 *ppDevice) ;
709     HRESULT GetPatchInfo( D3DXPATCHINFO* PatchInfo) ;
710
711     // Control mesh access
712     HRESULT GetVertexBuffer( IDirect3DVertexBuffer9* ppVB) ;
713     HRESULT GetIndexBuffer( IDirect3DIndexBuffer9* ppIB) ;
714     HRESULT LockVertexBuffer( DWORD flags, LPVOID *ppData) ;
715     HRESULT UnlockVertexBuffer() ;
716     HRESULT LockIndexBuffer( DWORD flags, LPVOID *ppData) ;
717     HRESULT UnlockIndexBuffer() ;
718     HRESULT LockAttributeBuffer( DWORD flags, DWORD** ppData) ;
719     HRESULT UnlockAttributeBuffer() ;
720
721     //  function returns the size of the tessellated mesh given a tessellation level.
722     //  assumes uniform tessellation. For adaptive tessellation the Adaptive parameter must
723     // be set to TRUE and TessellationLevel should be the max tessellation.
724     //  will result in the max mesh size necessary for adaptive tessellation.
725     HRESULT GetTessSize( FLOAT fTessLevel,DWORD Adaptive, DWORD *NumTriangles,DWORD *NumVertices) ;
726
727     //GenerateAdjacency determines which patches are adjacent with provided tolerance
728     // information is used internally to optimize tessellation
729     HRESULT GenerateAdjacency( FLOAT Tolerance) ;
730
731     //CloneMesh Creates a new patchmesh with the specified decl, and converts the vertex buffer
732     //to the new decl. Entries in the new decl which are new are set to 0. If the current mesh
733     //has adjacency, the new mesh will also have adjacency
734     HRESULT CloneMesh( DWORD Options,  D3DVERTEXELEMENT9 *pDecl, ID3DXPatchMesh *pMesh) ;
735
736     // Optimizes the patchmesh for efficient tessellation.  function is designed
737     // to perform one time optimization for patch meshes that need to be tessellated
738     // repeatedly by calling the Tessellate() method. The optimization performed is
739     // independent of the actual tessellation level used.
740     // Currently Flags is unused.
741     // If vertices are changed, Optimize must be called again
742     HRESULT Optimize( DWORD flags) ;
743
744     //gets and sets displacement parameters
745     //displacement maps can only be 2D textures MIP-MAPPING is ignored for non adapative tessellation
746     HRESULT SetDisplaceParam( IDirect3DBaseTexture9 Texture,
747                               D3DTEXTUREFILTERTYPE MinFilter,
748                               D3DTEXTUREFILTERTYPE MagFilter,
749                               D3DTEXTUREFILTERTYPE MipFilter,
750                               D3DTEXTUREADDRESS Wrap,
751                               DWORD dwLODBias) ;
752
753     HRESULT GetDisplaceParam( IDirect3DBaseTexture9 *Texture,
754                                 D3DTEXTUREFILTERTYPE *MinFilter,
755                                 D3DTEXTUREFILTERTYPE *MagFilter,
756                                 D3DTEXTUREFILTERTYPE *MipFilter,
757                                 D3DTEXTUREADDRESS *Wrap,
758                                 DWORD *dwLODBias) ;
759
760     // Performs the uniform tessellation based on the tessellation level.
761     //  function will perform more efficiently if the patch mesh has been optimized using the Optimize() call.
762     HRESULT Tessellate( FLOAT fTessLevel,ID3DXMesh pMesh) ;
763
764     // Performs adaptive tessellation based on the Z based adaptive tessellation criterion.
765     // pTrans specifies a 4D vector that is dotted with the vertices to get the per vertex
766     // adaptive tessellation amount. Each edge is tessellated to the average of the criterion
767     // at the 2 vertices it connects.
768     // MaxTessLevel specifies the upper limit for adaptive tesselation.
769     //  function will perform more efficiently if the patch mesh has been optimized using the Optimize() call.
770     HRESULT TessellateAdaptive(
771          D3DXVECTOR4 *pTrans,
772         DWORD dwMaxTessLevel,
773         DWORD dwMinTessLevel,
774         ID3DXMesh pMesh) ;
775
776 }
777
778 interface ID3DXFont : IUnknown
779 {
780     extern(Windows):
781
782     // ID3DXFont
783     HRESULT GetDevice( IDirect3DDevice9 *ppDevice) ;
784     HRESULT GetDescA( D3DXFONT_DESCA *pDesc) ;
785     HRESULT GetDescW( D3DXFONT_DESCW *pDesc) ;
786     BOOL GetTextMetricsA( TEXTMETRICA *pTextMetrics) ;
787     BOOL GetTextMetricsW( TEXTMETRICW *pTextMetrics) ;
788
789     HDC GetDC() ;
790     HRESULT GetGlyphData( UINT Glyph, IDirect3DTexture9 *ppTexture, RECT *pBlackBox, POINT *pCellInc) ;
791
792     HRESULT PreloadCharacters( UINT First, UINT Last) ;
793     HRESULT PreloadGlyphs( UINT First, UINT Last) ;
794     HRESULT PreloadTextA( LPCSTR pString, INT Count) ;
795     HRESULT PreloadTextW( LPCWSTR pString, INT Count) ;
796
797     INT DrawTextA( ID3DXSprite pSprite, LPCSTR pString, INT Count, LPRECT pRect, DWORD Format, D3DCOLOR Color) ;
798     INT DrawTextW( ID3DXSprite pSprite, LPCWSTR pString, INT Count, LPRECT pRect, DWORD Format, D3DCOLOR Color) ;
799
800     HRESULT OnLostDevice() ;
801     HRESULT OnResetDevice() ;
802 }
803
804 interface ID3DXSprite : IUnknown
805 {
806     extern(Windows):
807
808     // ID3DXSprite
809     HRESULT GetDevice( IDirect3DDevice9* ppDevice) ;
810
811     HRESULT GetTransform( D3DXMATRIX *pTransform) ;
812     HRESULT SetTransform(  D3DXMATRIX *pTransform) ;
813
814     HRESULT SetWorldViewRH(  D3DXMATRIX *pWorld,  D3DXMATRIX *pView) ;
815     HRESULT SetWorldViewLH(  D3DXMATRIX *pWorld,  D3DXMATRIX *pView) ;
816
817     HRESULT Begin( DWORD Flags) ;
818     HRESULT Draw( IDirect3DTexture9 pTexture,  RECT *pSrcRect,  D3DXVECTOR3 *pCenter,  D3DXVECTOR3 *pPosition, D3DCOLOR Color) ;
819     HRESULT Flush() ;
820     HRESULT End() ;
821
822     HRESULT OnLostDevice() ;
823     HRESULT OnResetDevice() ;
824 }
825
826 interface ID3DXBaseEffect : IUnknown
827 {
828     extern(Windows):
829
830     // Descs
831     HRESULT GetDesc( D3DXEFFECT_DESC* pDesc) ;
832     HRESULT GetParameterDesc( D3DXHANDLE hParameter, D3DXPARAMETER_DESC* pDesc) ;
833     HRESULT GetTechniqueDesc( D3DXHANDLE hTechnique, D3DXTECHNIQUE_DESC* pDesc) ;
834     HRESULT GetPassDesc( D3DXHANDLE hPass, D3DXPASS_DESC* pDesc) ;
835     HRESULT GetFunctionDesc( D3DXHANDLE hShader, D3DXFUNCTION_DESC* pDesc) ;
836
837     // Handle operations
838     D3DXHANDLE GetParameter( D3DXHANDLE hParameter, UINT Index) ;
839     D3DXHANDLE GetParameterByName( D3DXHANDLE hParameter, LPCSTR pName) ;
840     D3DXHANDLE GetParameterBySemantic( D3DXHANDLE hParameter, LPCSTR pSemantic) ;
841     D3DXHANDLE GetParameterElement( D3DXHANDLE hParameter, UINT Index) ;
842     D3DXHANDLE GetTechnique( UINT Index) ;
843     D3DXHANDLE GetTechniqueByName( LPCSTR pName) ;
844     D3DXHANDLE GetPass( D3DXHANDLE hTechnique, UINT Index) ;
845     D3DXHANDLE GetPassByName( D3DXHANDLE hTechnique, LPCSTR pName) ;
846     D3DXHANDLE GetFunction( UINT Index) ;
847     D3DXHANDLE GetFunctionByName( LPCSTR pName) ;
848     D3DXHANDLE GetAnnotation( D3DXHANDLE hObject, UINT Index) ;
849     D3DXHANDLE GetAnnotationByName( D3DXHANDLE hObject, LPCSTR pName) ;
850
851     // Get/Set Parameters
852     HRESULT SetValue( D3DXHANDLE hParameter, LPCVOID pData, UINT Bytes) ;
853     HRESULT GetValue( D3DXHANDLE hParameter, LPVOID pData, UINT Bytes) ;
854     HRESULT SetBool( D3DXHANDLE hParameter, BOOL b) ;
855     HRESULT GetBool( D3DXHANDLE hParameter, BOOL* pb) ;
856     HRESULT SetBoolArray( D3DXHANDLE hParameter,  BOOL* pb, UINT Count) ;
857     HRESULT GetBoolArray( D3DXHANDLE hParameter, BOOL* pb, UINT Count) ;
858     HRESULT SetInt( D3DXHANDLE hParameter, INT n) ;
859     HRESULT GetInt( D3DXHANDLE hParameter, INT* pn) ;
860     HRESULT SetIntArray( D3DXHANDLE hParameter,  INT* pn, UINT Count) ;
861     HRESULT GetIntArray( D3DXHANDLE hParameter, INT* pn, UINT Count) ;
862     HRESULT SetFloat( D3DXHANDLE hParameter, FLOAT f) ;
863     HRESULT GetFloat( D3DXHANDLE hParameter, FLOAT* pf) ;
864     HRESULT SetFloatArray( D3DXHANDLE hParameter,  FLOAT* pf, UINT Count) ;
865     HRESULT GetFloatArray( D3DXHANDLE hParameter, FLOAT* pf, UINT Count) ;
866     HRESULT SetVector( D3DXHANDLE hParameter,  D3DXVECTOR4* pVector) ;
867     HRESULT GetVector( D3DXHANDLE hParameter, D3DXVECTOR4* pVector) ;
868     HRESULT SetVectorArray( D3DXHANDLE hParameter,  D3DXVECTOR4* pVector, UINT Count) ;
869     HRESULT GetVectorArray( D3DXHANDLE hParameter, D3DXVECTOR4* pVector, UINT Count) ;
870     HRESULT SetMatrix( D3DXHANDLE hParameter,  D3DXMATRIX* pMatrix) ;
871     HRESULT GetMatrix( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix) ;
872     HRESULT SetMatrixArray( D3DXHANDLE hParameter,  D3DXMATRIX* pMatrix, UINT Count) ;
873     HRESULT GetMatrixArray( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix, UINT Count) ;
874     HRESULT SetMatrixPointerArray( D3DXHANDLE hParameter,  D3DXMATRIX** ppMatrix, UINT Count) ;
875     HRESULT GetMatrixPointerArray( D3DXHANDLE hParameter, D3DXMATRIX** ppMatrix, UINT Count) ;
876     HRESULT SetMatrixTranspose( D3DXHANDLE hParameter,  D3DXMATRIX* pMatrix) ;
877     HRESULT GetMatrixTranspose( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix) ;
878     HRESULT SetMatrixTransposeArray( D3DXHANDLE hParameter,  D3DXMATRIX* pMatrix, UINT Count) ;
879     HRESULT GetMatrixTransposeArray( D3DXHANDLE hParameter, D3DXMATRIX* pMatrix, UINT Count) ;
880     HRESULT SetMatrixTransposePointerArray( D3DXHANDLE hParameter,  D3DXMATRIX** ppMatrix, UINT Count) ;
881     HRESULT GetMatrixTransposePointerArray( D3DXHANDLE hParameter, D3DXMATRIX** ppMatrix, UINT Count) ;
882     HRESULT SetString( D3DXHANDLE hParameter, LPCSTR pString) ;
883     HRESULT GetString( D3DXHANDLE hParameter, LPCSTR* ppString) ;
884     HRESULT SetTexture( D3DXHANDLE hParameter, IDirect3DBaseTexture9 pTexture) ;
885     HRESULT GetTexture( D3DXHANDLE hParameter, IDirect3DBaseTexture9 *ppTexture) ;
886     HRESULT GetPixelShader( D3DXHANDLE hParameter, IDirect3DPixelShader9 *ppPShader) ;
887     HRESULT GetVertexShader( D3DXHANDLE hParameter, IDirect3DVertexShader9 *ppVShader) ;
888
889     //Set Range of an Array to pass to device
890     //Useful for sending only a subrange of an array down to the device
891     HRESULT SetArrayRange( D3DXHANDLE hParameter, UINT uStart, UINT uEnd) ;
892
893 }
894
895 interface ID3DXEffect : ID3DXBaseEffect
896 {
897     extern(Windows):
898
899     // Pool
900     HRESULT GetPool( ID3DXEffectPool* ppPool) ;
901
902     // Selecting and setting a technique
903     HRESULT SetTechnique( D3DXHANDLE hTechnique) ;
904     D3DXHANDLE GetCurrentTechnique() ;
905     HRESULT ValidateTechnique( D3DXHANDLE hTechnique) ;
906     HRESULT FindNextValidTechnique( D3DXHANDLE hTechnique, D3DXHANDLE *pTechnique) ;
907     BOOL IsParameterUsed( D3DXHANDLE hParameter, D3DXHANDLE hTechnique) ;
908
909     // Using current technique
910     // Begin           starts active technique
911     // BeginPass       begins a pass
912     // CommitChanges   updates changes to any set calls in the pass.  should be called before
913     //                 any DrawPrimitive call to d3d
914     // EndPass         ends a pass
915     // End             ends active technique
916     HRESULT Begin( UINT *pPasses, DWORD Flags) ;
917     HRESULT BeginPass( UINT Pass) ;
918     HRESULT CommitChanges() ;
919     HRESULT EndPass() ;
920     HRESULT End() ;
921
922     // Managing D3D Device
923     HRESULT GetDevice( IDirect3DDevice9* ppDevice) ;
924     HRESULT OnLostDevice() ;
925     HRESULT OnResetDevice() ;
926
927     // Logging device calls
928     HRESULT SetStateManager( ID3DXEffectStateManager pManager) ;
929     HRESULT GetStateManager( ID3DXEffectStateManager *ppManager) ;
930
931     // Parameter blocks
932     HRESULT BeginParameterBlock() ;
933     D3DXHANDLE EndParameterBlock() ;
934     HRESULT ApplyParameterBlock( D3DXHANDLE hParameterBlock) ;
935     HRESULT DeleteParameterBlock( D3DXHANDLE hParameterBlock) ;
936
937     // Cloning
938     HRESULT CloneEffect( IDirect3DDevice9 pDevice, ID3DXEffect* ppEffect) ;
939 }
940
941 interface ID3DXEffectPool : IUnknown
942 {
943     extern(Windows):
944
945     // No public methods
946 }
947
948 interface ID3DXEffectStateManager : IUnknown
949 {
950     extern(Windows):
951
952     // The following methods are called by the Effect when it wants to make
953     // the corresponding device call.  Note that:
954     // 1. Users manage the state and are therefore responsible for making the
955     //    the corresponding device calls themselves inside their callbacks.
956     // 2. Effects pay attention to the return values of the callbacks, and so
957     //    users must pay attention to what they return in their callbacks.
958
959     HRESULT SetTransform( D3DTRANSFORMSTATETYPE State,  D3DMATRIX *pMatrix) ;
960     HRESULT SetMaterial(  D3DMATERIAL9 *pMaterial) ;
961     HRESULT SetLight( DWORD Index,  D3DLIGHT9 *pLight) ;
962     HRESULT LightEnable( DWORD Index, BOOL Enable) ;
963     HRESULT SetRenderState( D3DRENDERSTATETYPE State, DWORD Value) ;
964     HRESULT SetTexture( DWORD Stage, IDirect3DBaseTexture9 pTexture) ;
965     HRESULT SetTextureStageState( DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) ;
966     HRESULT SetSamplerState( DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value) ;
967     HRESULT SetNPatchMode( FLOAT NumSegments) ;
968     HRESULT SetFVF( DWORD FVF) ;
969     HRESULT SetVertexShader( IDirect3DVertexShader9 pShader) ;
970     HRESULT SetVertexShaderConstantF( UINT RegisterIndex,  FLOAT *pConstantData, UINT RegisterCount) ;
971     HRESULT SetVertexShaderConstantI( UINT RegisterIndex,  INT *pConstantData, UINT RegisterCount) ;
972     HRESULT SetVertexShaderConstantB( UINT RegisterIndex,  BOOL *pConstantData, UINT RegisterCount) ;
973     HRESULT SetPixelShader( IDirect3DPixelShader9 pShader) ;
974     HRESULT SetPixelShaderConstantF( UINT RegisterIndex,  FLOAT *pConstantData, UINT RegisterCount) ;
975     HRESULT SetPixelShaderConstantI( UINT RegisterIndex,  INT *pConstantData, UINT RegisterCount) ;
976     HRESULT SetPixelShaderConstantB( UINT RegisterIndex,  BOOL *pConstantData, UINT RegisterCount) ;
977 }
978
979 interface ID3DXInclude
980 {
981     HRESULT Open(D3DXINCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes);
982     HRESULT Close(LPCVOID pData);
983 }
984
985 // D3DX Functions ---------------------------------------------------------------------------------------
986 extern(Windows)
987 {
988     uint D3DXGetShaderVersion(uint* pFunction);
989
990     HRESULT D3DXCheckTextureRequirements(
991             IDirect3DDevice9         pDevice,
992             UINT*                     pWidth,
993             UINT*                     pHeight,
994             UINT*                     pNumMipLevels,
995             DWORD                     Usage,
996             D3DFORMAT*                pFormat,
997             D3DPOOL                   Pool) ;
998
999     HRESULT D3DXCreateTexture(
1000             IDirect3DDevice9         pDevice,
1001             UINT                      Width,
1002             UINT                      Height,
1003             UINT                      MipLevels,
1004             DWORD                     Usage,
1005             D3DFORMAT                 Format,
1006             D3DPOOL                   Pool,
1007             IDirect3DTexture9*       ppTexture);
1008
1009     HRESULT D3DXCreateCubeTexture(
1010             IDirect3DDevice9         pDevice,
1011             UINT                      Size,
1012             UINT                      MipLevels,
1013             DWORD                     Usage,
1014             D3DFORMAT                 Format,
1015             D3DPOOL                   Pool,
1016             IDirect3DCubeTexture9*   ppCubeTexture);
1017            
1018     HRESULT D3DXCreateTextureFromFileA(
1019             LPDIRECT3DDEVICE9 pDevice,
1020             LPCTSTR pSrcFile,
1021             LPDIRECT3DTEXTURE9 * ppTexture);
1022
1023     HRESULT D3DXCreateTextureFromFileExA(
1024             IDirect3DDevice9         pDevice,
1025             LPCSTR                    pSrcFile,
1026             UINT                      Width,
1027             UINT                      Height,
1028             UINT                      MipLevels,
1029             DWORD                     Usage,
1030             D3DFORMAT                 Format,
1031             D3DPOOL                   Pool,
1032             DWORD                     Filter,
1033             DWORD                     MipFilter,
1034             D3DCOLOR                  ColorKey,
1035             D3DXIMAGE_INFO*           pSrcInfo,
1036             PALETTEENTRY*             pPalette,
1037             IDirect3DTexture9*       ppTexture);
1038
1039     HRESULT D3DXCreateCubeTextureFromFileExA(
1040             IDirect3DDevice9         pDevice,
1041             LPCSTR                    pSrcFile,
1042             UINT                      Size,
1043             UINT                      MipLevels,
1044             DWORD                     Usage,
1045             D3DFORMAT                 Format,
1046             D3DPOOL                   Pool,
1047             DWORD                     Filter,
1048             DWORD                     MipFilter,
1049             D3DCOLOR                  ColorKey,
1050             D3DXIMAGE_INFO*           pSrcInfo,
1051             PALETTEENTRY*             pPalette,
1052             IDirect3DCubeTexture9*   ppCubeTexture);
1053
1054     HRESULT D3DXSimplifyMesh(
1055             ID3DXMesh pMesh,
1056              DWORD* pAdjacency,
1057              D3DXATTRIBUTEWEIGHTS *pVertexAttributeWeights,
1058              FLOAT *pVertexWeights,
1059             DWORD MinValue,
1060             DWORD Options,
1061             ID3DXMesh* ppMesh);
1062
1063     HRESULT D3DXCreateSkinInfoFVF(
1064             DWORD NumVertices,
1065             DWORD FVF,
1066             DWORD NumBones,
1067             ID3DXSkinInfo* ppSkinInfo);
1068
1069     D3DXVECTOR2* D3DXVec2TransformCoord( D3DXVECTOR2 *pOut, D3DXVECTOR2 *pV, D3DXMATRIX *pM );
1070
1071     D3DXVECTOR4* D3DXVec3Transform( D3DXVECTOR4 *pOut, D3DXVECTOR3 *pV, D3DXMATRIX *pM );
1072
1073     D3DXVECTOR3* D3DXVec3TransformCoord( D3DXVECTOR3 *pOut, D3DXVECTOR3 *pV, D3DXMATRIX *pM );
1074
1075     D3DXVECTOR4* D3DXVec4Transform( D3DXVECTOR4 *pOut, D3DXVECTOR4 *pV, D3DXMATRIX *pM );
1076
1077     D3DXMATRIX* D3DXMatrixTranspose( D3DXMATRIX *pOut, D3DXMATRIX *pM );
1078
1079     D3DXMATRIX* D3DXMatrixMultiply( D3DXMATRIX *pOut, D3DXMATRIX *pM1, D3DXMATRIX *pM2 );
1080
1081     D3DXMATRIX* D3DXMatrixInverse( D3DXMATRIX *pOut, FLOAT *pDeterminant, D3DXMATRIX *pM );
1082
1083     D3DXMATRIX* D3DXMatrixScaling( D3DXMATRIX *pOut, FLOAT sx, FLOAT sy, FLOAT sz );
1084
1085     D3DXMATRIX* D3DXMatrixTranslation( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z );
1086
1087     D3DXMATRIX* D3DXMatrixRotationX( D3DXMATRIX *pOut, FLOAT Angle );
1088
1089     D3DXMATRIX* D3DXMatrixRotationY( D3DXMATRIX *pOut, FLOAT Angle );
1090
1091     D3DXMATRIX* D3DXMatrixRotationZ( D3DXMATRIX *pOut, FLOAT Angle );
1092
1093     D3DXMATRIX* D3DXMatrixRotationQuaternion( D3DXMATRIX *pOut, D3DXQUATERNION *pQ);
1094
1095     D3DXMATRIX* D3DXMatrixRotationYawPitchRoll( D3DXMATRIX *pOut, FLOAT Yaw, FLOAT Pitch, FLOAT Roll );
1096
1097     D3DXMATRIX* D3DXMatrixAffineTransformation2D( D3DXMATRIX *pOut, FLOAT Scaling, D3DXVECTOR2 *pRotationCenter,
1098           float Rotation, D3DXVECTOR2 *pTranslation);
1099
1100     D3DXMATRIX* D3DXMatrixPerspectiveFovLH( D3DXMATRIX *pOut, FLOAT fovy, FLOAT Aspect, FLOAT zn, FLOAT zf );
1101
1102     D3DXMATRIX* D3DXMatrixOrthoLH( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf );
1103
1104     D3DXMATRIX* D3DXMatrixOrthoOffCenterLH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,
1105           FLOAT zf );
1106
1107     void D3DXQuaternionToAxisAngle( D3DXQUATERNION *pQ, D3DXVECTOR3 *pAxis, FLOAT *pAngle );
1108
1109     D3DXQUATERNION* D3DXQuaternionRotationMatrix( D3DXQUATERNION *pOut, D3DXMATRIX *pM);
1110
1111     D3DXQUATERNION* D3DXQuaternionNormalize( D3DXQUATERNION *pOut, D3DXQUATERNION *pQ );
1112
1113     D3DXPLANE* D3DXPlaneNormalize( D3DXPLANE *pOut, D3DXPLANE *pP);
1114
1115     char* DXGetErrorDescription9A(HRESULT hr);
1116
1117     HRESULT D3DXCreateEffectFromFileA(
1118             IDirect3DDevice9               pDevice,
1119             LPCSTR                          pSrcFile,
1120              D3DXMACRO*                pDefines,
1121             ID3DXInclude                   pInclude,
1122             DWORD                           Flags,
1123             ID3DXEffectPool                pPool,
1124             ID3DXEffect*                   ppEffect,
1125             ID3DXBuffer*                   ppCompilationErrors);
1126
1127     D3DXMATRIX* D3DXMatrixTransformation2D( D3DXMATRIX *pOut, D3DXVECTOR2 *pScalingCenter,
1128       float *pScalingRotation, D3DXVECTOR2 *pScaling,
1129       D3DXVECTOR2 *pRotationCenter, float Rotation,
1130       D3DXVECTOR2 *pTranslation);
1131
1132     HRESULT D3DXLoadMeshFromXA(
1133         LPCSTR pFilename,
1134         DWORD Options,
1135         IDirect3DDevice9 pD3D,
1136         ID3DXBuffer *ppAdjacency,
1137         ID3DXBuffer *ppMaterials,
1138         ID3DXBuffer *ppEffectInstances,
1139         DWORD *pNumMaterials,
1140         ID3DXMesh *ppMesh);
1141
1142     HRESULT D3DXCreatePolygon(
1143         IDirect3DDevice9   pDevice,
1144         FLOAT               Length,
1145         UINT                Sides,
1146         ID3DXMesh*         ppMesh,
1147         ID3DXBuffer*       ppAdjacency);
1148
1149     HRESULT D3DXCreateBox(
1150             IDirect3DDevice9   pDevice,
1151             FLOAT               Width,
1152             FLOAT               Height,
1153             FLOAT               Depth,
1154             ID3DXMesh*         ppMesh,
1155             ID3DXBuffer*       ppAdjacency);
1156
1157     HRESULT D3DXCreateCylinder(
1158             IDirect3DDevice9   pDevice,
1159             FLOAT               Radius1,
1160             FLOAT               Radius2,
1161             FLOAT               Length,
1162             UINT                Slices,
1163             UINT                Stacks,
1164             ID3DXMesh*         ppMesh,
1165             ID3DXBuffer*       ppAdjacency);
1166
1167     HRESULT D3DXCreateSphere(
1168             IDirect3DDevice9  pDevice,
1169             FLOAT              Radius,
1170             UINT               Slices,
1171             UINT               Stacks,
1172             ID3DXMesh*        ppMesh,
1173             ID3DXBuffer*      ppAdjacency);
1174
1175     HRESULT D3DXCreateTorus(
1176             IDirect3DDevice9   pDevice,
1177             FLOAT               InnerRadius,
1178             FLOAT               OuterRadius,
1179             UINT                Sides,
1180             UINT                Rings,
1181             ID3DXMesh*         ppMesh,
1182             ID3DXBuffer*       ppAdjacency);
1183
1184     HRESULT D3DXCreateTeapot(
1185             IDirect3DDevice9   pDevice,
1186             ID3DXMesh*         ppMesh,
1187             ID3DXBuffer*       ppAdjacency);
1188
1189     HRESULT D3DXCreateFontA(
1190         IDirect3DDevice9 pDevice,
1191         UINT Height,
1192         UINT Width,
1193         UINT Weight,
1194         UINT MipLevels,
1195         BOOL Italic,
1196         DWORD CharSet,
1197         DWORD OutputPrecision,
1198         DWORD Quality,
1199         DWORD PitchAndFamily,
1200         LPCTSTR pFacename,
1201         ID3DXFont *ppFont);
1202
1203     HRESULT D3DXCreateSprite(
1204         IDirect3DDevice9   pDevice,
1205         ID3DXSprite*       ppSprite) ;
1206
1207     HRESULT D3DXCreateEffect(
1208         IDirect3DDevice9                pDevice,
1209         LPCVOID                         pSrcData,
1210         UINT                            SrcDataLen,
1211         D3DXMACRO*                      pDefines,
1212         ID3DXInclude                    pInclude,
1213         DWORD                           Flags,
1214         ID3DXEffectPool                 pPool,
1215         ID3DXEffect*                    ppEffect,
1216         ID3DXBuffer*                    ppCompilationErrors);
1217
1218     HRESULT D3DXCreateEffectPool(
1219         ID3DXEffectPool* pEffectPool);
1220
1221     HRESULT D3DXGetShaderInputSemantics(
1222         DWORD* pFunction,
1223         D3DXSEMANTIC* pSemantics,
1224         UINT* pCount);
1225
1226     HRESULT
1227     D3DXCreateMeshFVF(
1228         DWORD NumFaces,
1229         DWORD NumVertices,
1230         DWORD Options,
1231         DWORD FVF,
1232         IDirect3DDevice9 pD3DDevice,
1233         ID3DXMesh* ppMesh);
1234
1235     UINT D3DXGetFVFVertexSize(DWORD FVF);
1236
1237     HRESULT D3DXFileCreate(ID3DXFile* lplpDirectXFile);
1238
1239     HRESULT D3DXLoadMeshFromXof(
1240         ID3DXFileData pxofMesh,
1241         DWORD Options,
1242         IDirect3DDevice9 pD3DDevice,
1243         ID3DXBuffer *ppAdjacency,
1244         ID3DXBuffer *ppMaterials,
1245         ID3DXBuffer *ppEffectInstances,
1246         DWORD *pNumMaterials,
1247         ID3DXMesh *ppMesh);
1248
1249     HRESULT D3DXConcatenateMeshes(
1250         ID3DXMesh * ppMeshes,
1251         UINT NumMeshes,
1252         DWORD Options,
1253         D3DXMATRIX * pGeomXForms,
1254         D3DXMATRIX * pTextureXForms,
1255         D3DVERTEXELEMENT9 * pDecl,
1256         IDirect3DDevice9 pD3DDevice,
1257         ID3DXMesh * ppMeshOut);
1258
1259     HRESULT D3DXDeclaratorFromFVF(DWORD FVF, D3DVERTEXELEMENT9* Declaration);
1260
1261     D3DXQUATERNION* D3DXQuaternionSlerp(D3DXQUATERNION* pOut, D3DXQUATERNION* pQ1, D3DXQUATERNION* pQ2, float t);
1262
1263     D3DXVECTOR3* D3DXVec3CatmullRom(D3DXVECTOR3 *pOut, D3DXVECTOR3 *pV0, D3DXVECTOR3 *pV1, D3DXVECTOR3 *pV2, D3DXVECTOR3 *pV3, float s);
1264
1265     void D3DXQuaternionSquadSetup(  D3DXQUATERNION *pAOut,
1266                                     D3DXQUATERNION *pBOut,
1267                                     D3DXQUATERNION *pCOut,
1268                                     D3DXQUATERNION *pQ0,
1269                                     D3DXQUATERNION *pQ1,
1270                                     D3DXQUATERNION *pQ2,
1271                                     D3DXQUATERNION *pQ3);
1272
1273     D3DXQUATERNION* D3DXQuaternionSquad(D3DXQUATERNION *pOut,
1274                                         D3DXQUATERNION *pQ1,
1275                                         D3DXQUATERNION *pA,
1276                                         D3DXQUATERNION *pB,
1277                                         D3DXQUATERNION *pC,
1278                                         float t);
1279
1280     HRESULT D3DXMatrixDecompose(D3DXVECTOR3 *pOutScale,
1281                                 D3DXQUATERNION *pOutRotation,
1282                                 D3DXVECTOR3 *pOutTranslation,
1283                                 D3DXMATRIX *pM
1284                                 );
1285
1286     D3DXQUATERNION* D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION *pOut,
1287                                                             FLOAT Yaw,
1288                                                             FLOAT Pitch,
1289                                                             FLOAT Roll
1290                                                         );
1291
1292     UINT D3DXGetDeclVertexSize(D3DVERTEXELEMENT9 *pDecl, DWORD Stream );
1293 } // extern(Windows)
1294
1295 D3DXMATRIX* D3DXMatrixIdentity( D3DXMATRIX *pOut )
1296 {
1297     pOut.m[0][1] = pOut.m[0][2] = pOut.m[0][3] =
1298     pOut.m[1][0] = pOut.m[1][2] = pOut.m[1][3] =
1299     pOut.m[2][0] = pOut.m[2][1] = pOut.m[2][3] =
1300     pOut.m[3][0] = pOut.m[3][1] = pOut.m[3][2] = 0.0f;
1301
1302     pOut.m[0][0] = pOut.m[1][1] = pOut.m[2][2] = pOut.m[3][3] = 1.0f;
1303     return pOut;
1304 }
1305
1306 FLOAT D3DXVec3LengthSq(D3DXVECTOR3* v)
1307 {
1308     return (v.x * v.x) + (v.y * v.y) + (v.z * v.z);
1309 }
1310
1311 template DEFINE_GUID(uint d1, ushort d2, ushort d3, ubyte d4, ubyte d5, ubyte d6, ubyte d7, ubyte d8, ubyte d9, ubyte d10, ubyte d11)
1312 {
1313     const GUID DEFINE_GUID = {d1, d2, d3, [d4, d5, d6, d7, d8, d9, d10, d11]};
1314 }
1315
1316 const GUID TID_D3DRMInfo = DEFINE_GUID!(0x2b957100, 0x9e9a, 0x11cf, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1317 const GUID TID_D3DRMMesh = DEFINE_GUID!(0x3d82ab44, 0x62da, 0x11cf, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1318 const GUID TID_D3DRMVector = DEFINE_GUID!(0x3d82ab5e, 0x62da, 0x11cf, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1319 const GUID TID_D3DRMMeshFace = DEFINE_GUID!(0x3d82ab5f, 0x62da, 0x11cf, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1320 const GUID TID_D3DRMMaterial = DEFINE_GUID!(0x3d82ab4d, 0x62da, 0x11cf, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1321 const GUID TID_D3DRMMaterialArray = DEFINE_GUID!(0x35ff44e1, 0x6c7c, 0x11cf, 0x8F, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1322 const GUID TID_D3DRMFrame = DEFINE_GUID!(0x3d82ab46, 0x62da, 0x11cf, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1323 const GUID TID_D3DRMFrameTransformMatrix = DEFINE_GUID!(0xf6f23f41, 0x7686, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1324 const GUID TID_D3DRMMeshMaterialList = DEFINE_GUID!(0xf6f23f42, 0x7686, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1325 const GUID TID_D3DRMMeshTextureCoords = DEFINE_GUID!(0xf6f23f40, 0x7686, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1326 const GUID TID_D3DRMMeshNormals = DEFINE_GUID!(0xf6f23f43, 0x7686, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1327 const GUID TID_D3DRMCoords2d = DEFINE_GUID!(0xf6f23f44, 0x7686, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1328 const GUID TID_D3DRMMatrix4x4 = DEFINE_GUID!(0xf6f23f45, 0x7686, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1329 const GUID TID_D3DRMAnimation = DEFINE_GUID!(0x3d82ab4f, 0x62da, 0x11cf, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1330 const GUID TID_D3DRMAnimationSet = DEFINE_GUID!(0x3d82ab50, 0x62da, 0x11cf, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1331 const GUID TID_D3DRMAnimationKey = DEFINE_GUID!(0x10dd46a8, 0x775b, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xA3);
1332 const GUID TID_D3DRMFloatKeys = DEFINE_GUID!(0x10dd46a9, 0x775b, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xA3);
1333 const GUID TID_D3DRMMaterialAmbientColor = DEFINE_GUID!(0x01411840, 0x7786, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xA3);
1334 const GUID TID_D3DRMMaterialDiffuseColor = DEFINE_GUID!(0x01411841, 0x7786, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xA3);
1335 const GUID TID_D3DRMMaterialSpecularColor = DEFINE_GUID!(0x01411842, 0x7786, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xA3);
1336 const GUID TID_D3DRMMaterialEmissiveColor = DEFINE_GUID!(0xd3e16e80, 0x7835, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1337 const GUID TID_D3DRMMaterialPower = DEFINE_GUID!(0x01411843, 0x7786, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xA3);
1338 const GUID TID_D3DRMColorRGBA = DEFINE_GUID!(0x35ff44e0, 0x6c7c, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xA3);
1339 const GUID TID_D3DRMColorRGB = DEFINE_GUID!(0xd3e16e81, 0x7835, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1340 const GUID TID_D3DRMGuid = DEFINE_GUID!(0xa42790e0, 0x7810, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1341 const GUID TID_D3DRMTextureFilename = DEFINE_GUID!(0xa42790e1, 0x7810, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1342 const GUID TID_D3DRMTextureReference = DEFINE_GUID!(0xa42790e2, 0x7810, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1343 const GUID TID_D3DRMIndexedColor = DEFINE_GUID!(0x1630b820, 0x7842, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1344 const GUID TID_D3DRMMeshVertexColors = DEFINE_GUID!(0x1630b821, 0x7842, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1345 const GUID TID_D3DRMMaterialWrap = DEFINE_GUID!(0x4885ae60, 0x78e8, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1346 const GUID TID_D3DRMBoolean = DEFINE_GUID!(0x537da6a0, 0xca37, 0x11d0, 0x94, 0x1c, 0x0, 0x80, 0xc8, 0xc, 0xfa, 0x7b);
1347 const GUID TID_D3DRMMeshFaceWraps = DEFINE_GUID!(0xed1ec5c0, 0xc0a8, 0x11d0, 0x94, 0x1c, 0x0, 0x80, 0xc8, 0xc, 0xfa, 0x7b);
1348 const GUID TID_D3DRMBoolean2d = DEFINE_GUID!(0x4885ae63, 0x78e8, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1349 const GUID TID_D3DRMTimedFloatKeys = DEFINE_GUID!(0xf406b180, 0x7b3b, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1350 const GUID TID_D3DRMAnimationOptions = DEFINE_GUID!(0xe2bf56c0, 0x840f, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1351 const GUID TID_D3DRMFramePosition = DEFINE_GUID!(0xe2bf56c1, 0x840f, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1352 const GUID TID_D3DRMFrameVelocity = DEFINE_GUID!(0xe2bf56c2, 0x840f, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1353 const GUID TID_D3DRMFrameRotation = DEFINE_GUID!(0xe2bf56c3, 0x840f, 0x11cf, 0x8f, 0x52, 0x0, 0x40, 0x33, 0x35, 0x94, 0xa3);
1354 const GUID TID_D3DRMLight = DEFINE_GUID!(0x3d82ab4a, 0x62da, 0x11cf, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1355 const GUID TID_D3DRMCamera = DEFINE_GUID!(0x3d82ab51, 0x62da, 0x11cf, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1356 const GUID TID_D3DRMAppData = DEFINE_GUID!(0xe5745280, 0xb24f, 0x11cf, 0x9d, 0xd5, 0x0, 0xaa, 0x0, 0xa7, 0x1a, 0x2f);
1357 const GUID TID_D3DRMLightUmbra = DEFINE_GUID!(0xaed22740, 0xb31f, 0x11cf, 0x9d, 0xd5, 0x0, 0xaa, 0x0, 0xa7, 0x1a, 0x2f);
1358 const GUID TID_D3DRMLightRange = DEFINE_GUID!(0xaed22742, 0xb31f, 0x11cf, 0x9d, 0xd5, 0x0, 0xaa, 0x0, 0xa7, 0x1a, 0x2f);
1359 const GUID TID_D3DRMLightPenumbra = DEFINE_GUID!(0xaed22741, 0xb31f, 0x11cf, 0x9d, 0xd5, 0x0, 0xaa, 0x0, 0xa7, 0x1a, 0x2f);
1360 const GUID TID_D3DRMLightAttenuation = DEFINE_GUID!(0xa8a98ba0, 0xc5e5, 0x11cf, 0xb9, 0x41, 0x0, 0x80, 0xc8, 0xc, 0xfa, 0x7b);
1361 const GUID TID_D3DRMInlineData = DEFINE_GUID!(0x3a23eea0, 0x94b1, 0x11d0, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1362 const GUID TID_D3DRMUrl = DEFINE_GUID!(0x3a23eea1, 0x94b1, 0x11d0, 0xab, 0x39, 0x0, 0x20, 0xaf, 0x71, 0xe4, 0x33);
1363 const GUID TID_D3DRMProgressiveMesh = DEFINE_GUID!(0x8A63C360, 0x997D, 0x11d0, 0x94, 0x1C, 0x0, 0x80, 0xC8, 0x0C, 0xFA, 0x7B);
1364 const GUID TID_D3DRMExternalVisual = DEFINE_GUID!(0x98116AA0, 0xBDBA, 0x11d1, 0x82, 0xC0, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x71);
1365 const GUID TID_D3DRMStringProperty = DEFINE_GUID!(0x7f0f21e0, 0xbfe1, 0x11d1, 0x82, 0xc0, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x71);
1366 const GUID TID_D3DRMPropertyBag = DEFINE_GUID!(0x7f0f21e1, 0xbfe1, 0x11d1, 0x82, 0xc0, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x71);
1367 const GUID TID_D3DRMRightHanded = DEFINE_GUID!(0x7f5d5ea0, 0xd53a, 0x11d1, 0x82, 0xc0, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x71);
1368
1369 ubyte D3DRM_XTEMPLATES[] =
1370 [
1371     0x78, 0x6f, 0x66, 0x20, 0x30, 0x33, 0x30, 0x32, 0x62,
1372     0x69, 0x6e, 0x20, 0x30, 0x30, 0x36, 0x34, 0x1f, 0, 0x1,
1373     0, 0x6, 0, 0, 0, 0x48, 0x65, 0x61, 0x64, 0x65,
1374     0x72, 0xa, 0, 0x5, 0, 0x43, 0xab, 0x82, 0x3d, 0xda,
1375     0x62, 0xcf, 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4,
1376     0x33, 0x28, 0, 0x1, 0, 0x5, 0, 0, 0, 0x6d,
1377     0x61, 0x6a, 0x6f, 0x72, 0x14, 0, 0x28, 0, 0x1, 0,
1378     0x5, 0, 0, 0, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x14,
1379     0, 0x29, 0, 0x1, 0, 0x5, 0, 0, 0, 0x66,
1380     0x6c, 0x61, 0x67, 0x73, 0x14, 0, 0xb, 0, 0x1f, 0,
1381     0x1, 0, 0x6, 0, 0, 0, 0x56, 0x65, 0x63, 0x74,
1382     0x6f, 0x72, 0xa, 0, 0x5, 0, 0x5e, 0xab, 0x82, 0x3d,
1383     0xda, 0x62, 0xcf, 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71,
1384     0xe4, 0x33, 0x2a, 0, 0x1, 0, 0x1, 0, 0, 0,
1385     0x78, 0x14, 0, 0x2a, 0, 0x1, 0, 0x1, 0, 0,
1386     0, 0x79, 0x14, 0, 0x2a, 0, 0x1, 0, 0x1, 0,
1387     0, 0, 0x7a, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1,
1388     0, 0x8, 0, 0, 0, 0x43, 0x6f, 0x6f, 0x72, 0x64,
1389     0x73, 0x32, 0x64, 0xa, 0, 0x5, 0, 0x44, 0x3f, 0xf2,
1390     0xf6, 0x86, 0x76, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33,
1391     0x35, 0x94, 0xa3, 0x2a, 0, 0x1, 0, 0x1, 0, 0,
1392     0, 0x75, 0x14, 0, 0x2a, 0, 0x1, 0, 0x1, 0,
1393     0, 0, 0x76, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1,
1394     0, 0x9, 0, 0, 0, 0x4d, 0x61, 0x74, 0x72, 0x69,
1395     0x78, 0x34, 0x78, 0x34, 0xa, 0, 0x5, 0, 0x45, 0x3f,
1396     0xf2, 0xf6, 0x86, 0x76, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40,
1397     0x33, 0x35, 0x94, 0xa3, 0x34, 0, 0x2a, 0, 0x1, 0,
1398     0x6, 0, 0, 0, 0x6d, 0x61, 0x74, 0x72, 0x69, 0x78,
1399     0xe, 0, 0x3, 0, 0x10, 0, 0, 0, 0xf, 0,
1400     0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0, 0x9, 0,
1401     0, 0, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x52, 0x47, 0x42,
1402     0x41, 0xa, 0, 0x5, 0, 0xe0, 0x44, 0xff, 0x35, 0x7c,
1403     0x6c, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94,
1404     0xa3, 0x2a, 0, 0x1, 0, 0x3, 0, 0, 0, 0x72,
1405     0x65, 0x64, 0x14, 0, 0x2a, 0, 0x1, 0, 0x5, 0,
1406     0, 0, 0x67, 0x72, 0x65, 0x65, 0x6e, 0x14, 0, 0x2a,
1407     0, 0x1, 0, 0x4, 0, 0, 0, 0x62, 0x6c, 0x75,
1408     0x65, 0x14, 0, 0x2a, 0, 0x1, 0, 0x5, 0, 0,
1409     0, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x14, 0, 0xb, 0,
1410     0x1f, 0, 0x1, 0, 0x8, 0, 0, 0, 0x43, 0x6f,
1411     0x6c, 0x6f, 0x72, 0x52, 0x47, 0x42, 0xa, 0, 0x5, 0,
1412     0x81, 0x6e, 0xe1, 0xd3, 0x35, 0x78, 0xcf, 0x11, 0x8f, 0x52,
1413     0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x2a, 0, 0x1, 0,
1414     0x3, 0, 0, 0, 0x72, 0x65, 0x64, 0x14, 0, 0x2a,
1415     0, 0x1, 0, 0x5, 0, 0, 0, 0x67, 0x72, 0x65,
1416     0x65, 0x6e, 0x14, 0, 0x2a, 0, 0x1, 0, 0x4, 0,
1417     0, 0, 0x62, 0x6c, 0x75, 0x65, 0x14, 0, 0xb, 0,
1418     0x1f, 0, 0x1, 0, 0xc, 0, 0, 0, 0x49, 0x6e,
1419     0x64, 0x65, 0x78, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6f, 0x72,
1420     0xa, 0, 0x5, 0, 0x20, 0xb8, 0x30, 0x16, 0x42, 0x78,
1421     0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3,
1422     0x29, 0, 0x1, 0, 0x5, 0, 0, 0, 0x69, 0x6e,
1423     0x64, 0x65, 0x78, 0x14, 0, 0x1, 0, 0x9, 0, 0,
1424     0, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x52, 0x47, 0x42, 0x41,
1425     0x1, 0, 0xa, 0, 0, 0, 0x69, 0x6e, 0x64, 0x65,
1426     0x78, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x14, 0, 0xb, 0,
1427     0x1f, 0, 0x1, 0, 0x7, 0, 0, 0, 0x42, 0x6f,
1428     0x6f, 0x6c, 0x65, 0x61, 0x6e, 0xa, 0, 0x5, 0, 0xa0,
1429     0xa6, 0x7d, 0x53, 0x37, 0xca, 0xd0, 0x11, 0x94, 0x1c, 0,
1430     0x80, 0xc8, 0xc, 0xfa, 0x7b, 0x29, 0, 0x1, 0, 0x9,
1431     0, 0, 0, 0x74, 0x72, 0x75, 0x65, 0x66, 0x61, 0x6c,
1432     0x73, 0x65, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0,
1433     0x9, 0, 0, 0, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61,
1434     0x6e, 0x32, 0x64, 0xa, 0, 0x5, 0, 0x63, 0xae, 0x85,
1435     0x48, 0xe8, 0x78, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33,
1436     0x35, 0x94, 0xa3, 0x1, 0, 0x7, 0, 0, 0, 0x42,
1437     0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x1, 0, 0x1, 0,
1438     0, 0, 0x75, 0x14, 0, 0x1, 0, 0x7, 0, 0,
1439     0, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x1, 0,
1440     0x1, 0, 0, 0, 0x76, 0x14, 0, 0xb, 0, 0x1f,
1441     0, 0x1, 0, 0xc, 0, 0, 0, 0x4d, 0x61, 0x74,
1442     0x65, 0x72, 0x69, 0x61, 0x6c, 0x57, 0x72, 0x61, 0x70, 0xa,
1443     0, 0x5, 0, 0x60, 0xae, 0x85, 0x48, 0xe8, 0x78, 0xcf,
1444     0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x1,
1445     0, 0x7, 0, 0, 0, 0x42, 0x6f, 0x6f, 0x6c, 0x65,
1446     0x61, 0x6e, 0x1, 0, 0x1, 0, 0, 0, 0x75, 0x14,
1447     0, 0x1, 0, 0x7, 0, 0, 0, 0x42, 0x6f, 0x6f,
1448     0x6c, 0x65, 0x61, 0x6e, 0x1, 0, 0x1, 0, 0, 0,
1449     0x76, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0, 0xf,
1450     0, 0, 0, 0x54, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65,
1451     0x46, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0xa, 0,
1452     0x5, 0, 0xe1, 0x90, 0x27, 0xa4, 0x10, 0x78, 0xcf, 0x11,
1453     0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x31, 0,
1454     0x1, 0, 0x8, 0, 0, 0, 0x66, 0x69, 0x6c, 0x65,
1455     0x6e, 0x61, 0x6d, 0x65, 0x14, 0, 0xb, 0, 0x1f, 0,
1456     0x1, 0, 0x8, 0, 0, 0, 0x4d, 0x61, 0x74, 0x65,
1457     0x72, 0x69, 0x61, 0x6c, 0xa, 0, 0x5, 0, 0x4d, 0xab,
1458     0x82, 0x3d, 0xda, 0x62, 0xcf, 0x11, 0xab, 0x39, 0, 0x20,
1459     0xaf, 0x71, 0xe4, 0x33, 0x1, 0, 0x9, 0, 0, 0,
1460     0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x52, 0x47, 0x42, 0x41, 0x1,
1461     0, 0x9, 0, 0, 0, 0x66, 0x61, 0x63, 0x65, 0x43,
1462     0x6f, 0x6c, 0x6f, 0x72, 0x14, 0, 0x2a, 0, 0x1, 0,
1463     0x5, 0, 0, 0, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x14,
1464     0, 0x1, 0, 0x8, 0, 0, 0, 0x43, 0x6f, 0x6c,
1465     0x6f, 0x72, 0x52, 0x47, 0x42, 0x1, 0, 0xd, 0, 0,
1466     0, 0x73, 0x70, 0x65, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x43,
1467     0x6f, 0x6c, 0x6f, 0x72, 0x14, 0, 0x1, 0, 0x8, 0,
1468     0, 0, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x52, 0x47, 0x42,
1469     0x1, 0, 0xd, 0, 0, 0, 0x65, 0x6d, 0x69, 0x73,
1470     0x73, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x14,
1471     0, 0xe, 0, 0x12, 0, 0x12, 0, 0x12, 0, 0xf,
1472     0, 0xb, 0, 0x1f, 0, 0x1, 0, 0x8, 0, 0,
1473     0, 0x4d, 0x65, 0x73, 0x68, 0x46, 0x61, 0x63, 0x65, 0xa,
1474     0, 0x5, 0, 0x5f, 0xab, 0x82, 0x3d, 0xda, 0x62, 0xcf,
1475     0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33, 0x29,
1476     0, 0x1, 0, 0x12, 0, 0, 0, 0x6e, 0x46, 0x61,
1477     0x63, 0x65, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x49, 0x6e,
1478     0x64, 0x69, 0x63, 0x65, 0x73, 0x14, 0, 0x34, 0, 0x29,
1479     0, 0x1, 0, 0x11, 0, 0, 0, 0x66, 0x61, 0x63,
1480     0x65, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x49, 0x6e, 0x64,
1481     0x69, 0x63, 0x65, 0x73, 0xe, 0, 0x1, 0, 0x12, 0,
1482     0, 0, 0x6e, 0x46, 0x61, 0x63, 0x65, 0x56, 0x65, 0x72,
1483     0x74, 0x65, 0x78, 0x49, 0x6e, 0x64, 0x69, 0x63, 0x65, 0x73,
1484     0xf, 0, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0,
1485     0xd, 0, 0, 0, 0x4d, 0x65, 0x73, 0x68, 0x46, 0x61,
1486     0x63, 0x65, 0x57, 0x72, 0x61, 0x70, 0x73, 0xa, 0, 0x5,
1487     0, 0xc0, 0xc5, 0x1e, 0xed, 0xa8, 0xc0, 0xd0, 0x11, 0x94,
1488     0x1c, 0, 0x80, 0xc8, 0xc, 0xfa, 0x7b, 0x29, 0, 0x1,
1489     0, 0xf, 0, 0, 0, 0x6e, 0x46, 0x61, 0x63, 0x65,
1490     0x57, 0x72, 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73,
1491     0x14, 0, 0x34, 0, 0x1, 0, 0x9, 0, 0, 0,
1492     0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x32, 0x64, 0x1,
1493     0, 0xe, 0, 0, 0, 0x66, 0x61, 0x63, 0x65, 0x57,
1494     0x72, 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0xe,
1495     0, 0x1, 0, 0xf, 0, 0, 0, 0x6e, 0x46, 0x61,
1496     0x63, 0x65, 0x57, 0x72, 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75,
1497     0x65, 0x73, 0xf, 0, 0x14, 0, 0xb, 0, 0x1f, 0,
1498     0x1, 0, 0x11, 0, 0, 0, 0x4d, 0x65, 0x73, 0x68,
1499     0x54, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x43, 0x6f, 0x6f,
1500     0x72, 0x64, 0x73, 0xa, 0, 0x5, 0, 0x40, 0x3f, 0xf2,
1501     0xf6, 0x86, 0x76, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33,
1502     0x35, 0x94, 0xa3, 0x29, 0, 0x1, 0, 0xe, 0, 0,
1503     0, 0x6e, 0x54, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x43,
1504     0x6f, 0x6f, 0x72, 0x64, 0x73, 0x14, 0, 0x34, 0, 0x1,
1505     0, 0x8, 0, 0, 0, 0x43, 0x6f, 0x6f, 0x72, 0x64,
1506     0x73, 0x32, 0x64, 0x1, 0, 0xd, 0, 0, 0, 0x74,
1507     0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x43, 0x6f, 0x6f, 0x72,
1508     0x64, 0x73, 0xe, 0, 0x1, 0, 0xe, 0, 0, 0,
1509     0x6e, 0x54, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x43, 0x6f,
1510     0x6f, 0x72, 0x64, 0x73, 0xf, 0, 0x14, 0, 0xb, 0,
1511     0x1f, 0, 0x1, 0, 0x10, 0, 0, 0, 0x4d, 0x65,
1512     0x73, 0x68, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c,
1513     0x4c, 0x69, 0x73, 0x74, 0xa, 0, 0x5, 0, 0x42, 0x3f,
1514     0xf2, 0xf6, 0x86, 0x76, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40,
1515     0x33, 0x35, 0x94, 0xa3, 0x29, 0, 0x1, 0, 0xa, 0,
1516     0, 0, 0x6e, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61,
1517     0x6c, 0x73, 0x14, 0, 0x29, 0, 0x1, 0, 0xc, 0,
1518     0, 0, 0x6e, 0x46, 0x61, 0x63, 0x65, 0x49, 0x6e, 0x64,
1519     0x65, 0x78, 0x65, 0x73, 0x14, 0, 0x34, 0, 0x29, 0,
1520     0x1, 0, 0xb, 0, 0, 0, 0x66, 0x61, 0x63, 0x65,
1521     0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0xe, 0, 0x1,
1522     0, 0xc, 0, 0, 0, 0x6e, 0x46, 0x61, 0x63, 0x65,
1523     0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0xf, 0, 0x14,
1524     0, 0xe, 0, 0x1, 0, 0x8, 0, 0, 0, 0x4d,
1525     0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0xf, 0, 0xb,
1526     0, 0x1f, 0, 0x1, 0, 0xb, 0, 0, 0, 0x4d,
1527     0x65, 0x73, 0x68, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x73,
1528     0xa, 0, 0x5, 0, 0x43, 0x3f, 0xf2, 0xf6, 0x86, 0x76,
1529     0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3,
1530     0x29, 0, 0x1, 0, 0x8, 0, 0, 0, 0x6e, 0x4e,
1531     0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x73, 0x14, 0, 0x34, 0,
1532     0x1, 0, 0x6, 0, 0, 0, 0x56, 0x65, 0x63, 0x74,
1533     0x6f, 0x72, 0x1, 0, 0x7, 0, 0, 0, 0x6e, 0x6f,
1534     0x72, 0x6d, 0x61, 0x6c, 0x73, 0xe, 0, 0x1, 0, 0x8,
1535     0, 0, 0, 0x6e, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6c,
1536     0x73, 0xf, 0, 0x14, 0, 0x29, 0, 0x1, 0, 0xc,
1537     0, 0, 0, 0x6e, 0x46, 0x61, 0x63, 0x65, 0x4e, 0x6f,
1538     0x72, 0x6d, 0x61, 0x6c, 0x73, 0x14, 0, 0x34, 0, 0x1,
1539     0, 0x8, 0, 0, 0, 0x4d, 0x65, 0x73, 0x68, 0x46,
1540     0x61, 0x63, 0x65, 0x1, 0, 0xb, 0, 0, 0, 0x66,
1541     0x61, 0x63, 0x65, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x73,
1542     0xe, 0, 0x1, 0, 0xc, 0, 0, 0, 0x6e, 0x46,
1543     0x61, 0x63, 0x65, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x73,
1544     0xf, 0, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0,
1545     0x10, 0, 0, 0, 0x4d, 0x65, 0x73, 0x68, 0x56, 0x65,
1546     0x72, 0x74, 0x65, 0x78, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x73,
1547     0xa, 0, 0x5, 0, 0x21, 0xb8, 0x30, 0x16, 0x42, 0x78,
1548     0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3,
1549     0x29, 0, 0x1, 0, 0xd, 0, 0, 0, 0x6e, 0x56,
1550     0x65, 0x72, 0x74, 0x65, 0x78, 0x43, 0x6f, 0x6c, 0x6f, 0x72,
1551     0x73, 0x14, 0, 0x34, 0, 0x1, 0, 0xc, 0, 0,
1552     0, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x64, 0x43, 0x6f,
1553     0x6c, 0x6f, 0x72, 0x1, 0, 0xc, 0, 0, 0, 0x76,
1554     0x65, 0x72, 0x74, 0x65, 0x78, 0x43, 0x6f, 0x6c, 0x6f, 0x72,
1555     0x73, 0xe, 0, 0x1, 0, 0xd, 0, 0, 0, 0x6e,
1556     0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x43, 0x6f, 0x6c, 0x6f,
1557     0x72, 0x73, 0xf, 0, 0x14, 0, 0xb, 0, 0x1f, 0,
1558     0x1, 0, 0x4, 0, 0, 0, 0x4d, 0x65, 0x73, 0x68,
1559     0xa, 0, 0x5, 0, 0x44, 0xab, 0x82, 0x3d, 0xda, 0x62,
1560     0xcf, 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33,
1561     0x29, 0, 0x1, 0, 0x9, 0, 0, 0, 0x6e, 0x56,
1562     0x65, 0x72, 0x74, 0x69, 0x63, 0x65, 0x73, 0x14, 0, 0x34,
1563     0, 0x1, 0, 0x6, 0, 0, 0, 0x56, 0x65, 0x63,
1564     0x74, 0x6f, 0x72, 0x1, 0, 0x8, 0, 0, 0, 0x76,
1565     0x65, 0x72, 0x74, 0x69, 0x63, 0x65, 0x73, 0xe, 0, 0x1,
1566     0, 0x9, 0, 0, 0, 0x6e, 0x56, 0x65, 0x72, 0x74,
1567     0x69, 0x63, 0x65, 0x73, 0xf, 0, 0x14, 0, 0x29, 0,
1568     0x1, 0, 0x6, 0, 0, 0, 0x6e, 0x46, 0x61, 0x63,
1569     0x65, 0x73, 0x14, 0, 0x34, 0, 0x1, 0, 0x8, 0,
1570     0, 0, 0x4d, 0x65, 0x73, 0x68, 0x46, 0x61, 0x63, 0x65,
1571     0x1, 0, 0x5, 0, 0, 0, 0x66, 0x61, 0x63, 0x65,
1572     0x73, 0xe, 0, 0x1, 0, 0x6, 0, 0, 0, 0x6e,
1573     0x46, 0x61, 0x63, 0x65, 0x73, 0xf, 0, 0x14, 0, 0xe,
1574     0, 0x12, 0, 0x12, 0, 0x12, 0, 0xf, 0, 0xb,
1575     0, 0x1f, 0, 0x1, 0, 0x14, 0, 0, 0, 0x46,
1576     0x72, 0x61, 0x6d, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66,
1577     0x6f, 0x72, 0x6d, 0x4d, 0x61, 0x74, 0x72, 0x69, 0x78, 0xa,
1578     0, 0x5, 0, 0x41, 0x3f, 0xf2, 0xf6, 0x86, 0x76, 0xcf,
1579     0x11, 0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x1,
1580     0, 0x9, 0, 0, 0, 0x4d, 0x61, 0x74, 0x72, 0x69,
1581     0x78, 0x34, 0x78, 0x34, 0x1, 0, 0xb, 0, 0, 0,
1582     0x66, 0x72, 0x61, 0x6d, 0x65, 0x4d, 0x61, 0x74, 0x72, 0x69,
1583     0x78, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1, 0, 0x5,
1584     0, 0, 0, 0x46, 0x72, 0x61, 0x6d, 0x65, 0xa, 0,
1585     0x5, 0, 0x46, 0xab, 0x82, 0x3d, 0xda, 0x62, 0xcf, 0x11,
1586     0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33, 0xe, 0,
1587     0x12, 0, 0x12, 0, 0x12, 0, 0xf, 0, 0xb, 0,
1588     0x1f, 0, 0x1, 0, 0x9, 0, 0, 0, 0x46, 0x6c,
1589     0x6f, 0x61, 0x74, 0x4b, 0x65, 0x79, 0x73, 0xa, 0, 0x5,
1590     0, 0xa9, 0x46, 0xdd, 0x10, 0x5b, 0x77, 0xcf, 0x11, 0x8f,
1591     0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x29, 0, 0x1,
1592     0, 0x7, 0, 0, 0, 0x6e, 0x56, 0x61, 0x6c, 0x75,
1593     0x65, 0x73, 0x14, 0, 0x34, 0, 0x2a, 0, 0x1, 0,
1594     0x6, 0, 0, 0, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73,
1595     0xe, 0, 0x1, 0, 0x7, 0, 0, 0, 0x6e, 0x56,
1596     0x61, 0x6c, 0x75, 0x65, 0x73, 0xf, 0, 0x14, 0, 0xb,
1597     0, 0x1f, 0, 0x1, 0, 0xe, 0, 0, 0, 0x54,
1598     0x69, 0x6d, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4b,
1599     0x65, 0x79, 0x73, 0xa, 0, 0x5, 0, 0x80, 0xb1, 0x6,
1600     0xf4, 0x3b, 0x7b, 0xcf, 0x11, 0x8f, 0x52, 0, 0x40, 0x33,
1601     0x35, 0x94, 0xa3, 0x29, 0, 0x1, 0, 0x4, 0, 0,
1602     0, 0x74, 0x69, 0x6d, 0x65, 0x14, 0, 0x1, 0, 0x9,
1603     0, 0, 0, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4b, 0x65,
1604     0x79, 0x73, 0x1, 0, 0x6, 0, 0, 0, 0x74, 0x66,
1605     0x6b, 0x65, 0x79, 0x73, 0x14, 0, 0xb, 0, 0x1f, 0,
1606     0x1, 0, 0xc, 0, 0, 0, 0x41, 0x6e, 0x69, 0x6d,
1607     0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0xa, 0,
1608     0x5, 0, 0xa8, 0x46, 0xdd, 0x10, 0x5b, 0x77, 0xcf, 0x11,
1609     0x8f, 0x52, 0, 0x40, 0x33, 0x35, 0x94, 0xa3, 0x29, 0,
1610     0x1, 0, 0x7, 0, 0, 0, 0x6b, 0x65, 0x79, 0x54,
1611     0x79, 0x70, 0x65, 0x14, 0, 0x29, 0, 0x1, 0, 0x5,
1612     0, 0, 0, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x14, 0,
1613     0x34, 0, 0x1, 0, 0xe, 0, 0, 0, 0x54, 0x69,
1614     0x6d, 0x65, 0x64, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4b, 0x65,
1615     0x79, 0x73, 0x1, 0, 0x4, 0, 0, 0, 0x6b, 0x65,
1616     0x79, 0x73, 0xe, 0, 0x1, 0, 0x5, 0, 0, 0,
1617     0x6e, 0x4b, 0x65, 0x79, 0x73, 0xf, 0, 0x14, 0, 0xb,
1618     0, 0x1f, 0, 0x1, 0, 0x10, 0, 0, 0, 0x41,
1619     0x6e, 0x69, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x70,
1620     0x74, 0x69, 0x6f, 0x6e, 0x73, 0xa, 0, 0x5, 0, 0xc0,
1621     0x56, 0xbf, 0xe2, 0xf, 0x84, 0xcf, 0x11, 0x8f, 0x52, 0,
1622     0x40, 0x33, 0x35, 0x94, 0xa3, 0x29, 0, 0x1, 0, 0xa,
1623     0, 0, 0, 0x6f, 0x70, 0x65, 0x6e, 0x63, 0x6c, 0x6f,
1624     0x73, 0x65, 0x64, 0x14, 0, 0x29, 0, 0x1, 0, 0xf,
1625     0, 0, 0, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
1626     0x6e, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x14, 0,
1627     0xb, 0, 0x1f, 0, 0x1, 0, 0x9, 0, 0, 0,
1628     0x41, 0x6e, 0x69, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0xa,
1629     0, 0x5, 0, 0x4f, 0xab, 0x82, 0x3d, 0xda, 0x62, 0xcf,
1630     0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33, 0xe,
1631     0, 0x12, 0, 0x12, 0, 0x12, 0, 0xf, 0, 0xb,
1632     0, 0x1f, 0, 0x1, 0, 0xc, 0, 0, 0, 0x41,
1633     0x6e, 0x69, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65,
1634     0x74, 0xa, 0, 0x5, 0, 0x50, 0xab, 0x82, 0x3d, 0xda,
1635     0x62, 0xcf, 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4,
1636     0x33, 0xe, 0, 0x1, 0, 0x9, 0, 0, 0, 0x41,
1637     0x6e, 0x69, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0xf, 0,
1638     0xb, 0, 0x1f, 0, 0x1, 0, 0xa, 0, 0, 0,
1639     0x49, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61,
1640     0xa, 0, 0x5, 0, 0xa0, 0xee, 0x23, 0x3a, 0xb1, 0x94,
1641     0xd0, 0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33,
1642     0xe, 0, 0x1, 0, 0x6, 0, 0, 0, 0x42, 0x49,
1643     0x4e, 0x41, 0x52, 0x59, 0xf, 0, 0xb, 0, 0x1f, 0,
1644     0x1, 0, 0x3, 0, 0, 0, 0x55, 0x72, 0x6c, 0xa,
1645     0, 0x5, 0, 0xa1, 0xee, 0x23, 0x3a, 0xb1, 0x94, 0xd0,
1646     0x11, 0xab, 0x39, 0, 0x20, 0xaf, 0x71, 0xe4, 0x33, 0x29,
1647     0, 0x1, 0, 0x5, 0, 0, 0, 0x6e, 0x55, 0x72,
1648     0x6c, 0x73, 0x14, 0, 0x34, 0, 0x31, 0, 0x1, 0,
1649     0x4, 0, 0, 0, 0x75, 0x72, 0x6c, 0x73, 0xe, 0,
1650     0x1, 0, 0x5, 0, 0, 0, 0x6e, 0x55, 0x72, 0x6c,
1651     0x73, 0xf, 0, 0x14, 0, 0xb, 0, 0x1f, 0, 0x1,
1652     0, 0xf, 0, 0, 0, 0x50, 0x72, 0x6f, 0x67, 0x72,
1653     0x65, 0x73, 0x73, 0x69, 0x76, 0x65, 0x4d, 0x65, 0x73, 0x68,
1654     0xa, 0, 0x5, 0, 0x60, 0xc3, 0x63, 0x8a, 0x7d, 0x99,
1655     0xd0, 0x11, 0x94, 0x1c, 0, 0x80, 0xc8, 0xc, 0xfa, 0x7b,
1656     0xe, 0, 0x1, 0, 0x3, 0, 0, 0, 0x55, 0x72,
1657     0x6c, 0x13, 0, 0x1, 0, 0xa, 0, 0, 0, 0x49,
1658     0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0xf,
1659     0, 0xb, 0, 0x1f, 0, 0x1, 0, 0x4, 0, 0,
1660     0, 0x47, 0x75, 0x69, 0x64, 0xa, 0, 0x5, 0, 0xe0,
1661     0x90, 0x27, 0xa4, 0x10, 0x78, 0xcf, 0x11, 0x8f, 0x52, 0,
1662     0x40, 0x33, 0x35, 0x94, 0xa3, 0x29, 0, 0x1, 0, 0x5,
1663     0, 0, 0, 0x64, 0x61, 0x74, 0x61, 0x31, 0x14, 0,
1664     0x28, 0, 0x1, 0, 0x5, 0, 0, 0, 0x64, 0x61,
1665     0x74, 0x61, 0x32, 0x14, 0, 0x28, 0, 0x1, 0, 0x5,
1666     0, 0, 0, 0x64, 0x61, 0x74, 0x61, 0x33, 0x14, 0,
1667     0x34, 0, 0x2d, 0, 0x1, 0, 0x5, 0, 0, 0,
1668     0x64, 0x61, 0x74, 0x61, 0x34, 0xe, 0, 0x3, 0, 0x8,
1669     0, 0, 0, 0xf, 0, 0x14, 0, 0xb, 0, 0x1f,
1670     0, 0x1, 0, 0xe, 0, 0, 0, 0x53, 0x74, 0x72,
1671     0x69, 0x6e, 0x67, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74,
1672     0x79, 0xa, 0, 0x5, 0, 0xe0, 0x21, 0xf, 0x7f, 0xe1,
1673     0xbf, 0xd1, 0x11, 0x82, 0xc0, 0, 0xa0, 0xc9, 0x69, 0x72,
1674     0x71, 0x31, 0, 0x1, 0, 0x3, 0, 0, 0, 0x6b,
1675     0x65, 0x79, 0x14, 0, 0x31, 0, 0x1, 0, 0x5, 0,
1676     0, 0, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x14, 0, 0xb,
1677     0, 0x1f, 0, 0x1, 0, 0xb, 0, 0, 0, 0x50,
1678     0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x42, 0x61, 0x67,
1679     0xa, 0, 0x5, 0, 0xe1, 0x21, 0xf, 0x7f, 0xe1, 0xbf,
1680     0xd1, 0x11, 0x82, 0xc0, 0, 0xa0, 0xc9, 0x69, 0x72, 0x71,
1681     0xe, 0, 0x1, 0, 0xe, 0, 0, 0, 0x53, 0x74,
1682     0x72, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72,
1683     0x74, 0x79, 0xf, 0, 0xb, 0, 0x1f, 0, 0x1, 0,
1684     0xe, 0, 0, 0, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e,
1685     0x61, 0x6c, 0x56, 0x69, 0x73, 0x75, 0x61, 0x6c, 0xa, 0,
1686     0x5, 0, 0xa0, 0x6a, 0x11, 0x98, 0xba, 0xbd, 0xd1, 0x11,
1687     0x82, 0xc0, 0, 0xa0, 0xc9, 0x69, 0x72, 0x71, 0x1, 0,
1688     0x4, 0, 0, 0, 0x47, 0x75, 0x69, 0x64, 0x1, 0,
1689     0x12, 0, 0, 0, 0x67, 0x75, 0x69, 0x64, 0x45, 0x78,
1690     0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x56, 0x69, 0x73, 0x75,
1691     0x61, 0x6c, 0x14, 0, 0xe, 0, 0x12, 0, 0x12, 0,
1692     0x12, 0, 0xf, 0, 0xb, 0, 0x1f, 0, 0x1, 0,
1693     0xb, 0, 0, 0, 0x52, 0x69, 0x67, 0x68, 0x74, 0x48,
1694     0x61, 0x6e, 0x64, 0x65, 0x64, 0xa, 0, 0x5, 0, 0xa0,
1695     0x5e, 0x5d, 0x7f, 0x3a, 0xd5, 0xd1, 0x11, 0x82, 0xc0, 0,
1696     0xa0, 0xc9, 0x69, 0x72, 0x71, 0x29, 0, 0x1, 0, 0xc,
1697     0, 0, 0, 0x62, 0x52, 0x69, 0x67, 0x68, 0x74, 0x48,
1698     0x61, 0x6e, 0x64, 0x65, 0x64, 0x14, 0, 0xb, 0
1699 ];
1700
1701 const GUID DXFILEOBJ_XSkinMeshHeader = DEFINE_GUID!(0x3cf169ce, 0xff7c, 0x44ab, 0x93, 0xc0, 0xf7, 0x8f, 0x62, 0xd1, 0x72, 0xe2);
1702 const GUID DXFILEOBJ_VertexDuplicationIndices = DEFINE_GUID!(0xb8d65549, 0xd7c9, 0x4995, 0x89, 0xcf, 0x53, 0xa9, 0xa8, 0xb0, 0x31, 0xe3);
1703 const GUID DXFILEOBJ_FaceAdjacency = DEFINE_GUID!(0xa64c844a, 0xe282, 0x4756, 0x8b, 0x80, 0x25, 0xc, 0xde, 0x4, 0x39, 0x8c);
1704 const GUID DXFILEOBJ_SkinWeights = DEFINE_GUID!(0x6f0d123b, 0xbad2, 0x4167, 0xa0, 0xd0, 0x80, 0x22, 0x4f, 0x25, 0xfa, 0xbb);
1705 const GUID DXFILEOBJ_Patch = DEFINE_GUID!(0xa3eb5d44, 0xfc22, 0x429d, 0x9a, 0xfb, 0x32, 0x21, 0xcb, 0x97, 0x19, 0xa6);
1706 const GUID DXFILEOBJ_PatchMesh = DEFINE_GUID!(0xd02c95cc, 0xedba, 0x4305, 0x9b, 0x5d, 0x18, 0x20, 0xd7, 0x70, 0x4b, 0xbf);
1707 const GUID DXFILEOBJ_PatchMesh9 = DEFINE_GUID!(0xb9ec94e1, 0xb9a6, 0x4251, 0xba, 0x18, 0x94, 0x89, 0x3f, 0x2, 0xc0, 0xea);
1708 const GUID DXFILEOBJ_PMInfo = DEFINE_GUID!(0xb6c3e656, 0xec8b, 0x4b92, 0x9b, 0x62, 0x68, 0x16, 0x59, 0x52, 0x29, 0x47);
1709 const GUID DXFILEOBJ_PMAttributeRange = DEFINE_GUID!(0x917e0427, 0xc61e, 0x4a14, 0x9c, 0x64, 0xaf, 0xe6, 0x5f, 0x9e, 0x98, 0x44);
1710 const GUID DXFILEOBJ_PMVSplitRecord = DEFINE_GUID!(0x574ccc14, 0xf0b3, 0x4333, 0x82, 0x2d, 0x93, 0xe8, 0xa8, 0xa0, 0x8e, 0x4c);
1711 const GUID DXFILEOBJ_FVFData = DEFINE_GUID!(0xb6e70a0e, 0x8ef9, 0x4e83, 0x94, 0xad, 0xec, 0xc8, 0xb0, 0xc0, 0x48, 0x97);
1712 const GUID DXFILEOBJ_VertexElement = DEFINE_GUID!(0xf752461c, 0x1e23, 0x48f6, 0xb9, 0xf8, 0x83, 0x50, 0x85, 0xf, 0x33, 0x6f);
1713 const GUID DXFILEOBJ_DeclData = DEFINE_GUID!(0xbf22e553, 0x292c, 0x4781, 0x9f, 0xea, 0x62, 0xbd, 0x55, 0x4b, 0xdd, 0x93);
1714 const GUID DXFILEOBJ_EffectFloats = DEFINE_GUID!(0xf1cfe2b3, 0xde3, 0x4e28, 0xaf, 0xa1, 0x15, 0x5a, 0x75, 0xa, 0x28, 0x2d);
1715 const GUID DXFILEOBJ_EffectString = DEFINE_GUID!(0xd55b097e, 0xbdb6, 0x4c52, 0xb0, 0x3d, 0x60, 0x51, 0xc8, 0x9d, 0xe, 0x42);
1716 const GUID DXFILEOBJ_EffectDWord = DEFINE_GUID!(0x622c0ed0, 0x956e, 0x4da9, 0x90, 0x8a, 0x2a, 0xf9, 0x4f, 0x3c, 0xe7, 0x16);
1717 const GUID DXFILEOBJ_EffectParamFloats = DEFINE_GUID!(0x3014b9a0, 0x62f5, 0x478c, 0x9b, 0x86, 0xe4, 0xac, 0x9f, 0x4e, 0x41, 0x8b);
1718 const GUID DXFILEOBJ_EffectParamString = DEFINE_GUID!(0x1dbc4c88, 0x94c1, 0x46ee, 0x90, 0x76, 0x2c, 0x28, 0x81, 0x8c, 0x94, 0x81);
1719 const GUID DXFILEOBJ_EffectParamDWord = DEFINE_GUID!(0xe13963bc, 0xae51, 0x4c5d, 0xb0, 0xf, 0xcf, 0xa3, 0xa9, 0xd9, 0x7c, 0xe5);
1720 const GUID DXFILEOBJ_EffectInstance = DEFINE_GUID!(0xe331f7e4, 0x559, 0x4cc2, 0x8e, 0x99, 0x1c, 0xec, 0x16, 0x57, 0x92, 0x8f);
1721 const GUID DXFILEOBJ_AnimTicksPerSecond = DEFINE_GUID!(0x9e415a43, 0x7ba6, 0x4a73, 0x87, 0x43, 0xb7, 0x3d, 0x47, 0xe8, 0x84, 0x76);
1722 const GUID DXFILEOBJ_CompressedAnimationSet = DEFINE_GUID!(0x7f9b00b3, 0xf125, 0x4890, 0x87, 0x6e, 0x1c, 0x42, 0xbf, 0x69, 0x7c, 0x4d);
1723
1724 align(1) struct XFILECOMPRESSEDANIMATIONSET
1725 {
1726     DWORD CompressedBlockSize;
1727     FLOAT TicksPerSec;
1728     DWORD PlaybackType;
1729     DWORD BufferLength;
1730 }
1731
1732 const char[] XSKINEXP_TEMPLATES =
1733         "xof 0303txt 0032
1734         template XSkinMeshHeader
1735         {
1736             <3CF169CE-FF7C-44ab-93C0-F78F62D172E2>
1737             WORD nMaxSkinWeightsPerVertex;
1738             WORD nMaxSkinWeightsPerFace;
1739             WORD nBones;
1740         }
1741         template VertexDuplicationIndices
1742         {
1743             <B8D65549-D7C9-4995-89CF-53A9A8B031E3>
1744             DWORD nIndices;
1745             DWORD nOriginalVertices;
1746             array DWORD indices[nIndices];
1747         }
1748         template FaceAdjacency
1749         {
1750             <A64C844A-E282-4756-8B80-250CDE04398C>
1751             DWORD nIndices;
1752             array DWORD indices[nIndices];
1753         }
1754         template SkinWeights
1755         {
1756             <6F0D123B-BAD2-4167-A0D0-80224F25FABB>
1757             STRING transformNodeName;
1758             DWORD nWeights;
1759             array DWORD vertexIndices[nWeights];
1760             array float weights[nWeights];
1761             Matrix4x4 matrixOffset;
1762         }
1763         template Patch
1764         {
1765             <A3EB5D44-FC22-429D-9AFB-3221CB9719A6>
1766             DWORD nControlIndices;
1767             array DWORD controlIndices[nControlIndices];
1768         }
1769         template PatchMesh
1770         {
1771             <D02C95CC-EDBA-4305-9B5D-1820D7704BBF>
1772             DWORD nVertices;
1773             array Vector vertices[nVertices];
1774             DWORD nPatches;
1775             array Patch patches[nPatches];
1776             [ ... ]
1777         }
1778         template PatchMesh9
1779         {
1780             <B9EC94E1-B9A6-4251-BA18-94893F02C0EA>
1781             DWORD Type;
1782             DWORD Degree;
1783             DWORD Basis;
1784             DWORD nVertices;
1785             array Vector vertices[nVertices];
1786             DWORD nPatches;
1787             array Patch patches[nPatches];
1788             [ ... ]
1789         } "
1790         "template EffectFloats
1791         {
1792             <F1CFE2B3-0DE3-4e28-AFA1-155A750A282D>
1793             DWORD nFloats;
1794             array float Floats[nFloats];
1795         }
1796         template EffectString
1797         {
1798             <D55B097E-BDB6-4c52-B03D-6051C89D0E42>
1799             STRING Value;
1800         }
1801         template EffectDWord
1802         {
1803             <622C0ED0-956E-4da9-908A-2AF94F3CE716>
1804             DWORD Value;
1805         } "
1806         "template EffectParamFloats
1807         {
1808             <3014B9A0-62F5-478c-9B86-E4AC9F4E418B>
1809             STRING ParamName;
1810             DWORD nFloats;
1811             array float Floats[nFloats];
1812         } "
1813         "template EffectParamString
1814         {
1815             <1DBC4C88-94C1-46ee-9076-2C28818C9481>
1816             STRING ParamName;
1817             STRING Value;
1818         }
1819         template EffectParamDWord
1820         {
1821             <E13963BC-AE51-4c5d-B00F-CFA3A9D97CE5>
1822             STRING ParamName;
1823             DWORD Value;
1824         }
1825         template EffectInstance
1826         {
1827             <E331F7E4-0559-4cc2-8E99-1CEC1657928F>
1828             STRING EffectFilename;
1829             [ ... ]
1830         } "
1831         "template AnimTicksPerSecond
1832         {
1833             <9E415A43-7BA6-4a73-8743-B73D47E88476>
1834             DWORD AnimTicksPerSecond;
1835         }
1836         template CompressedAnimationSet
1837         {
1838             <7F9B00B3-F125-4890-876E-1C42BF697C4D>
1839             DWORD CompressedBlockSize;
1840             FLOAT TicksPerSec;
1841             DWORD PlaybackType;
1842             DWORD BufferLength;
1843             array DWORD CompressedData[BufferLength];
1844         } ";
1845
1846 const char[] XEXTENSIONS_TEMPLATES =
1847         "xof 0303txt 0032
1848         template FVFData
1849         {
1850             <B6E70A0E-8EF9-4e83-94AD-ECC8B0C04897>
1851             DWORD dwFVF;
1852             DWORD nDWords;
1853             array DWORD data[nDWords];
1854         }
1855         template VertexElement
1856         {
1857             <F752461C-1E23-48f6-B9F8-8350850F336F>
1858             DWORD Type;
1859             DWORD Method;
1860             DWORD Usage;
1861             DWORD UsageIndex;
1862         }
1863         template DeclData
1864         {
1865             <BF22E553-292C-4781-9FEA-62BD554BDD93>
1866             DWORD nElements;
1867             array VertexElement Elements[nElements];
1868             DWORD nDWords;
1869             array DWORD data[nDWords];
1870         }
1871         template PMAttributeRange
1872         {
1873             <917E0427-C61E-4a14-9C64-AFE65F9E9844>
1874             DWORD iFaceOffset;
1875             DWORD nFacesMin;
1876             DWORD nFacesMax;
1877             DWORD iVertexOffset;
1878             DWORD nVerticesMin;
1879             DWORD nVerticesMax;
1880         }
1881         template PMVSplitRecord
1882         {
1883             <574CCC14-F0B3-4333-822D-93E8A8A08E4C>
1884             DWORD iFaceCLW;
1885             DWORD iVlrOffset;
1886             DWORD iCode;
1887         }
1888         template PMInfo
1889         {
1890             <B6C3E656-EC8B-4b92-9B62-681659522947>
1891             DWORD nAttributes;
1892             array PMAttributeRange attributeRanges[nAttributes];
1893             DWORD nMaxValence;
1894             DWORD nMinLogicalVertices;
1895             DWORD nMaxLogicalVertices;
1896             DWORD nVSplits;
1897             array PMVSplitRecord splitRecords[nVSplits];
1898             DWORD nAttributeMispredicts;
1899             array DWORD attributeMispredicts[nAttributeMispredicts];
1900         } ";
1901
1902 enum : uint
1903 {
1904     D3DXF_FILEFORMAT_BINARY          = 0,
1905     D3DXF_FILEFORMAT_TEXT            = 1,
1906     D3DXF_FILEFORMAT_COMPRESSED      = 2
1907 }
1908 alias uint D3DXF_FILEFORMAT;
1909
1910 enum : uint
1911 {
1912     D3DXF_FILESAVE_TOFILE     = 0x00L,
1913     D3DXF_FILESAVE_TOWFILE    = 0x01L
1914 }
1915 alias uint D3DXF_FILESAVEOPTIONS;
1916
1917 enum : uint
1918 {
1919     D3DXF_FILELOAD_FROMFILE     = 0x00L,
1920     D3DXF_FILELOAD_FROMWFILE    = 0x01L,
1921     D3DXF_FILELOAD_FROMRESOURCE = 0x02L,
1922     D3DXF_FILELOAD_FROMMEMORY   = 0x03L
1923 }
1924 alias uint D3DXF_FILELOADOPTIONS;
1925
1926 struct D3DXF_FILELOADRESOURCE
1927 {
1928     HMODULE hModule; // Desc
1929     LPCSTR lpName;  // Desc
1930     LPCSTR lpType;  // Desc
1931 }
1932
1933 struct D3DXF_FILELOADMEMORY
1934 {
1935     LPCVOID lpMemory; // Desc
1936     size_t  dSize;     // Desc
1937 }
1938
1939 const GUID IID_ID3DXFile = DEFINE_GUID!(0xcef08cf9, 0x7b4f, 0x4429, 0x96, 0x24, 0x2a, 0x69, 0x0a, 0x93, 0x32, 0x01 );
1940 const GUID IID_ID3DXFileSaveObject = DEFINE_GUID!(0xcef08cfa, 0x7b4f, 0x4429, 0x96, 0x24, 0x2a, 0x69, 0x0a, 0x93, 0x32, 0x01 );
1941 const GUID IID_ID3DXFileSaveData = DEFINE_GUID!(0xcef08cfb, 0x7b4f, 0x4429, 0x96, 0x24, 0x2a, 0x69, 0x0a, 0x93, 0x32, 0x01 );
1942 const GUID IID_ID3DXFileEnumObject = DEFINE_GUID!(0xcef08cfc, 0x7b4f, 0x4429, 0x96, 0x24, 0x2a, 0x69, 0x0a, 0x93, 0x32, 0x01 );
1943 const GUID IID_ID3DXFileData = DEFINE_GUID!(0xcef08cfd, 0x7b4f, 0x4429, 0x96, 0x24, 0x2a, 0x69, 0x0a, 0x93, 0x32, 0x01 );
1944
1945 interface ID3DXFile : IUnknown
1946 {
1947     HRESULT CreateEnumObject(LPCVOID, D3DXF_FILELOADOPTIONS, ID3DXFileEnumObject*);
1948     HRESULT CreateSaveObject(LPCVOID, D3DXF_FILESAVEOPTIONS, D3DXF_FILEFORMAT, ID3DXFileSaveObject*);
1949     HRESULT RegisterTemplates(LPCVOID, size_t);
1950     HRESULT RegisterEnumTemplates(ID3DXFileEnumObject);
1951 }
1952
1953 interface ID3DXFileSaveObject : IUnknown
1954 {
1955     HRESULT GetFile(ID3DXFile*);
1956     HRESULT AddDataObject(GUID*, LPCSTR, GUID*, size_t, LPCVOID, ID3DXFileSaveData*);
1957     HRESULT Save();
1958 }
1959
1960 interface ID3DXFileSaveData : IUnknown
1961 {
1962     HRESULT GetSave(ID3DXFileSaveObject*);
1963     HRESULT GetName(LPSTR, size_t*);
1964     HRESULT GetId(GUID*);
1965     HRESULT GetType(GUID*);
1966     HRESULT AddDataObject(GUID*, LPCSTR, GUID*, size_t, LPCVOID, ID3DXFileSaveData*);
1967     HRESULT AddDataReference(LPCSTR, GUID* );
1968 }
1969
1970 interface ID3DXFileEnumObject : IUnknown
1971 {
1972     HRESULT GetFile(ID3DXFile*);
1973     HRESULT GetChildren(size_t*);
1974     HRESULT GetChild(size_t, ID3DXFileData*);
1975     HRESULT GetDataObjectById(REFGUID, ID3DXFileData*);
1976     HRESULT GetDataObjectByName(LPCSTR, ID3DXFileData*);
1977 }
1978
1979 interface ID3DXFileData : IUnknown
1980 {
1981     HRESULT GetEnum(ID3DXFileEnumObject*);
1982     HRESULT GetName(LPSTR, size_t*);
1983     HRESULT GetId(GUID*);
1984     HRESULT Lock(size_t*, LPCVOID*);
1985     HRESULT Unlock();
1986     HRESULT GetType(GUID*);
1987     BOOL IsReference();
1988     HRESULT GetChildren(size_t*);
1989     HRESULT GetChild(size_t, ID3DXFileData*);
1990 }
Note: See TracBrowser for help on using the browser.