|
0
|
1 /*==========================================================================;
|
|
|
2 *
|
|
|
3 * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
4 *
|
|
|
5 * File: d3drm.h
|
|
|
6 * Content: Direct3DRM include file
|
|
|
7 *
|
|
|
8 ***************************************************************************/
|
|
|
9
|
|
|
10 #ifndef __D3DRMDEFS_H__
|
|
|
11 #define __D3DRMDEFS_H__
|
|
|
12
|
|
|
13 #include <stddef.h>
|
|
|
14 #include "d3dtypes.h"
|
|
|
15
|
|
|
16 #ifdef WIN32
|
|
|
17 #define D3DRMAPI __stdcall
|
|
|
18 #else
|
|
|
19 #define D3DRMAPI
|
|
|
20 #endif
|
|
|
21
|
|
|
22 #if defined(__cplusplus)
|
|
|
23 extern "C" {
|
|
|
24 #endif
|
|
|
25
|
|
|
26 #ifndef TRUE
|
|
|
27 #define FALSE 0
|
|
|
28 #define TRUE 1
|
|
|
29 #endif
|
|
|
30
|
|
|
31 typedef struct _D3DRMVECTOR4D
|
|
|
32 { D3DVALUE x, y, z, w;
|
|
|
33 } D3DRMVECTOR4D, *LPD3DRMVECTOR4D;
|
|
|
34
|
|
|
35 typedef D3DVALUE D3DRMMATRIX4D[4][4];
|
|
|
36
|
|
|
37 typedef struct _D3DRMQUATERNION
|
|
|
38 { D3DVALUE s;
|
|
|
39 D3DVECTOR v;
|
|
|
40 } D3DRMQUATERNION, *LPD3DRMQUATERNION;
|
|
|
41
|
|
|
42 typedef struct _D3DRMRAY
|
|
|
43 { D3DVECTOR dvDir;
|
|
|
44 D3DVECTOR dvPos;
|
|
|
45 } D3DRMRAY, *LPD3DRMRAY;
|
|
|
46
|
|
|
47 typedef struct _D3DRMBOX
|
|
|
48 { D3DVECTOR min, max;
|
|
|
49 } D3DRMBOX, *LPD3DRMBOX;
|
|
|
50
|
|
|
51 typedef void (*D3DRMWRAPCALLBACK)
|
|
|
52 (LPD3DVECTOR, int* u, int* v, LPD3DVECTOR a, LPD3DVECTOR b, LPVOID);
|
|
|
53
|
|
|
54 typedef enum _D3DRMLIGHTTYPE
|
|
|
55 { D3DRMLIGHT_AMBIENT,
|
|
|
56 D3DRMLIGHT_POINT,
|
|
|
57 D3DRMLIGHT_SPOT,
|
|
|
58 D3DRMLIGHT_DIRECTIONAL,
|
|
|
59 D3DRMLIGHT_PARALLELPOINT
|
|
|
60 } D3DRMLIGHTTYPE, *LPD3DRMLIGHTTYPE;
|
|
|
61
|
|
|
62 typedef enum _D3DRMSHADEMODE {
|
|
|
63 D3DRMSHADE_FLAT = 0,
|
|
|
64 D3DRMSHADE_GOURAUD = 1,
|
|
|
65 D3DRMSHADE_PHONG = 2,
|
|
|
66
|
|
|
67 D3DRMSHADE_MASK = 7,
|
|
|
68 D3DRMSHADE_MAX = 8
|
|
|
69 } D3DRMSHADEMODE, *LPD3DRMSHADEMODE;
|
|
|
70
|
|
|
71 typedef enum _D3DRMLIGHTMODE {
|
|
|
72 D3DRMLIGHT_OFF = 0 * D3DRMSHADE_MAX,
|
|
|
73 D3DRMLIGHT_ON = 1 * D3DRMSHADE_MAX,
|
|
|
74
|
|
|
75 D3DRMLIGHT_MASK = 7 * D3DRMSHADE_MAX,
|
|
|
76 D3DRMLIGHT_MAX = 8 * D3DRMSHADE_MAX
|
|
|
77 } D3DRMLIGHTMODE, *LPD3DRMLIGHTMODE;
|
|
|
78
|
|
|
79 typedef enum _D3DRMFILLMODE {
|
|
|
80 D3DRMFILL_POINTS = 0 * D3DRMLIGHT_MAX,
|
|
|
81 D3DRMFILL_WIREFRAME = 1 * D3DRMLIGHT_MAX,
|
|
|
82 D3DRMFILL_SOLID = 2 * D3DRMLIGHT_MAX,
|
|
|
83
|
|
|
84 D3DRMFILL_MASK = 7 * D3DRMLIGHT_MAX,
|
|
|
85 D3DRMFILL_MAX = 8 * D3DRMLIGHT_MAX
|
|
|
86 } D3DRMFILLMODE, *LPD3DRMFILLMODE;
|
|
|
87
|
|
|
88 typedef DWORD D3DRMRENDERQUALITY, *LPD3DRMRENDERQUALITY;
|
|
|
89
|
|
|
90 #define D3DRMRENDER_WIREFRAME (D3DRMSHADE_FLAT+D3DRMLIGHT_OFF+D3DRMFILL_WIREFRAME)
|
|
|
91 #define D3DRMRENDER_UNLITFLAT (D3DRMSHADE_FLAT+D3DRMLIGHT_OFF+D3DRMFILL_SOLID)
|
|
|
92 #define D3DRMRENDER_FLAT (D3DRMSHADE_FLAT+D3DRMLIGHT_ON+D3DRMFILL_SOLID)
|
|
|
93 #define D3DRMRENDER_GOURAUD (D3DRMSHADE_GOURAUD+D3DRMLIGHT_ON+D3DRMFILL_SOLID)
|
|
|
94 #define D3DRMRENDER_PHONG (D3DRMSHADE_PHONG+D3DRMLIGHT_ON+D3DRMFILL_SOLID)
|
|
|
95
|
|
|
96 #define D3DRMRENDERMODE_BLENDEDTRANSPARENCY 1
|
|
|
97 #define D3DRMRENDERMODE_SORTEDTRANSPARENCY 2
|
|
|
98 #define D3DRMRENDERMODE_LIGHTINMODELSPACE 8
|
|
|
99 #define D3DRMRENDERMODE_VIEWDEPENDENTSPECULAR 16
|
|
|
100 #define D3DRMRENDERMODE_DISABLESORTEDALPHAZWRITE 32
|
|
|
101
|
|
|
102 typedef enum _D3DRMTEXTUREQUALITY
|
|
|
103 { D3DRMTEXTURE_NEAREST, /* choose nearest texel */
|
|
|
104 D3DRMTEXTURE_LINEAR, /* interpolate 4 texels */
|
|
|
105 D3DRMTEXTURE_MIPNEAREST, /* nearest texel in nearest mipmap */
|
|
|
106 D3DRMTEXTURE_MIPLINEAR, /* interpolate 2 texels from 2 mipmaps */
|
|
|
107 D3DRMTEXTURE_LINEARMIPNEAREST, /* interpolate 4 texels in nearest mipmap */
|
|
|
108 D3DRMTEXTURE_LINEARMIPLINEAR /* interpolate 8 texels from 2 mipmaps */
|
|
|
109 } D3DRMTEXTUREQUALITY, *LPD3DRMTEXTUREQUALITY;
|
|
|
110
|
|
|
111 /*
|
|
|
112 * Texture flags
|
|
|
113 */
|
|
|
114 #define D3DRMTEXTURE_FORCERESIDENT 0x00000001 /* texture should be kept in video memory */
|
|
|
115 #define D3DRMTEXTURE_STATIC 0x00000002 /* texture will not change */
|
|
|
116 #define D3DRMTEXTURE_DOWNSAMPLEPOINT 0x00000004 /* point filtering should be used when downsampling */
|
|
|
117 #define D3DRMTEXTURE_DOWNSAMPLEBILINEAR 0x00000008 /* bilinear filtering should be used when downsampling */
|
|
|
118 #define D3DRMTEXTURE_DOWNSAMPLEREDUCEDEPTH 0x00000010 /* reduce bit depth when downsampling */
|
|
|
119 #define D3DRMTEXTURE_DOWNSAMPLENONE 0x00000020 /* texture should never be downsampled */
|
|
|
120 #define D3DRMTEXTURE_CHANGEDPIXELS 0x00000040 /* pixels have changed */
|
|
|
121 #define D3DRMTEXTURE_CHANGEDPALETTE 0x00000080 /* palette has changed */
|
|
|
122 #define D3DRMTEXTURE_INVALIDATEONLY 0x00000100 /* dirty regions are invalid */
|
|
|
123
|
|
|
124 /*
|
|
|
125 * Shadow flags
|
|
|
126 */
|
|
|
127 #define D3DRMSHADOW_TRUEALPHA 0x00000001 /* shadow should render without artifacts when true alpha is on */
|
|
|
128
|
|
|
129 typedef enum _D3DRMCOMBINETYPE
|
|
|
130 { D3DRMCOMBINE_REPLACE,
|
|
|
131 D3DRMCOMBINE_BEFORE,
|
|
|
132 D3DRMCOMBINE_AFTER
|
|
|
133 } D3DRMCOMBINETYPE, *LPD3DRMCOMBINETYPE;
|
|
|
134
|
|
|
135 typedef D3DCOLORMODEL D3DRMCOLORMODEL, *LPD3DRMCOLORMODEL;
|
|
|
136
|
|
|
137 typedef enum _D3DRMPALETTEFLAGS
|
|
|
138 { D3DRMPALETTE_FREE, /* renderer may use this entry freely */
|
|
|
139 D3DRMPALETTE_READONLY, /* fixed but may be used by renderer */
|
|
|
140 D3DRMPALETTE_RESERVED /* may not be used by renderer */
|
|
|
141 } D3DRMPALETTEFLAGS, *LPD3DRMPALETTEFLAGS;
|
|
|
142
|
|
|
143 typedef struct _D3DRMPALETTEENTRY
|
|
|
144 { unsigned char red; /* 0 .. 255 */
|
|
|
145 unsigned char green; /* 0 .. 255 */
|
|
|
146 unsigned char blue; /* 0 .. 255 */
|
|
|
147 unsigned char flags; /* one of D3DRMPALETTEFLAGS */
|
|
|
148 } D3DRMPALETTEENTRY, *LPD3DRMPALETTEENTRY;
|
|
|
149
|
|
|
150 typedef struct _D3DRMIMAGE
|
|
|
151 { int width, height; /* width and height in pixels */
|
|
|
152 int aspectx, aspecty; /* aspect ratio for non-square pixels */
|
|
|
153 int depth; /* bits per pixel */
|
|
|
154 int rgb; /* if false, pixels are indices into a
|
|
|
155 palette otherwise, pixels encode
|
|
|
156 RGB values. */
|
|
|
157 int bytes_per_line; /* number of bytes of memory for a
|
|
|
158 scanline. This must be a multiple
|
|
|
159 of 4. */
|
|
|
160 void* buffer1; /* memory to render into (first buffer). */
|
|
|
161 void* buffer2; /* second rendering buffer for double
|
|
|
162 buffering, set to NULL for single
|
|
|
163 buffering. */
|
|
|
164 unsigned long red_mask;
|
|
|
165 unsigned long green_mask;
|
|
|
166 unsigned long blue_mask;
|
|
|
167 unsigned long alpha_mask; /* if rgb is true, these are masks for
|
|
|
168 the red, green and blue parts of a
|
|
|
169 pixel. Otherwise, these are masks
|
|
|
170 for the significant bits of the
|
|
|
171 red, green and blue elements in the
|
|
|
172 palette. For instance, most SVGA
|
|
|
173 displays use 64 intensities of red,
|
|
|
174 green and blue, so the masks should
|
|
|
175 all be set to 0xfc. */
|
|
|
176 int palette_size; /* number of entries in palette */
|
|
|
177 D3DRMPALETTEENTRY* palette; /* description of the palette (only if
|
|
|
178 rgb is false). Must be (1<<depth)
|
|
|
179 elements. */
|
|
|
180 } D3DRMIMAGE, *LPD3DRMIMAGE;
|
|
|
181
|
|
|
182 typedef enum _D3DRMWRAPTYPE
|
|
|
183 { D3DRMWRAP_FLAT,
|
|
|
184 D3DRMWRAP_CYLINDER,
|
|
|
185 D3DRMWRAP_SPHERE,
|
|
|
186 D3DRMWRAP_CHROME,
|
|
|
187 D3DRMWRAP_SHEET,
|
|
|
188 D3DRMWRAP_BOX
|
|
|
189 } D3DRMWRAPTYPE, *LPD3DRMWRAPTYPE;
|
|
|
190
|
|
|
191 #define D3DRMWIREFRAME_CULL 1 /* cull backfaces */
|
|
|
192 #define D3DRMWIREFRAME_HIDDENLINE 2 /* lines are obscured by closer objects */
|
|
|
193
|
|
|
194 /*
|
|
|
195 * Do not use righthanded perspective in Viewport2::SetProjection().
|
|
|
196 * Set up righthanded mode by using IDirect3DRM3::SetOptions().
|
|
|
197 */
|
|
|
198 typedef enum _D3DRMPROJECTIONTYPE
|
|
|
199 { D3DRMPROJECT_PERSPECTIVE,
|
|
|
200 D3DRMPROJECT_ORTHOGRAPHIC,
|
|
|
201 D3DRMPROJECT_RIGHTHANDPERSPECTIVE, /* Only valid pre-DX6 */
|
|
|
202 D3DRMPROJECT_RIGHTHANDORTHOGRAPHIC /* Only valid pre-DX6 */
|
|
|
203 } D3DRMPROJECTIONTYPE, *LPD3DRMPROJECTIONTYPE;
|
|
|
204
|
|
|
205 #define D3DRMOPTIONS_LEFTHANDED 0x00000001L /* Default */
|
|
|
206 #define D3DRMOPTIONS_RIGHTHANDED 0x00000002L
|
|
|
207
|
|
|
208 typedef enum _D3DRMXOFFORMAT
|
|
|
209 { D3DRMXOF_BINARY,
|
|
|
210 D3DRMXOF_COMPRESSED,
|
|
|
211 D3DRMXOF_TEXT
|
|
|
212 } D3DRMXOFFORMAT, *LPD3DRMXOFFORMAT;
|
|
|
213
|
|
|
214 typedef DWORD D3DRMSAVEOPTIONS;
|
|
|
215 #define D3DRMXOFSAVE_NORMALS 1
|
|
|
216 #define D3DRMXOFSAVE_TEXTURECOORDINATES 2
|
|
|
217 #define D3DRMXOFSAVE_MATERIALS 4
|
|
|
218 #define D3DRMXOFSAVE_TEXTURENAMES 8
|
|
|
219 #define D3DRMXOFSAVE_ALL 15
|
|
|
220 #define D3DRMXOFSAVE_TEMPLATES 16
|
|
|
221 #define D3DRMXOFSAVE_TEXTURETOPOLOGY 32
|
|
|
222
|
|
|
223 typedef enum _D3DRMCOLORSOURCE
|
|
|
224 { D3DRMCOLOR_FROMFACE,
|
|
|
225 D3DRMCOLOR_FROMVERTEX
|
|
|
226 } D3DRMCOLORSOURCE, *LPD3DRMCOLORSOURCE;
|
|
|
227
|
|
|
228 typedef enum _D3DRMFRAMECONSTRAINT
|
|
|
229 { D3DRMCONSTRAIN_Z, /* use only X and Y rotations */
|
|
|
230 D3DRMCONSTRAIN_Y, /* use only X and Z rotations */
|
|
|
231 D3DRMCONSTRAIN_X /* use only Y and Z rotations */
|
|
|
232 } D3DRMFRAMECONSTRAINT, *LPD3DRMFRAMECONSTRAINT;
|
|
|
233
|
|
|
234 typedef enum _D3DRMMATERIALMODE
|
|
|
235 { D3DRMMATERIAL_FROMMESH,
|
|
|
236 D3DRMMATERIAL_FROMPARENT,
|
|
|
237 D3DRMMATERIAL_FROMFRAME
|
|
|
238 } D3DRMMATERIALMODE, *LPD3DRMMATERIALMODE;
|
|
|
239
|
|
|
240 typedef enum _D3DRMFOGMODE
|
|
|
241 { D3DRMFOG_LINEAR, /* linear between start and end */
|
|
|
242 D3DRMFOG_EXPONENTIAL, /* density * exp(-distance) */
|
|
|
243 D3DRMFOG_EXPONENTIALSQUARED /* density * exp(-distance*distance) */
|
|
|
244 } D3DRMFOGMODE, *LPD3DRMFOGMODE;
|
|
|
245
|
|
|
246 typedef enum _D3DRMZBUFFERMODE {
|
|
|
247 D3DRMZBUFFER_FROMPARENT, /* default */
|
|
|
248 D3DRMZBUFFER_ENABLE, /* enable zbuffering */
|
|
|
249 D3DRMZBUFFER_DISABLE /* disable zbuffering */
|
|
|
250 } D3DRMZBUFFERMODE, *LPD3DRMZBUFFERMODE;
|
|
|
251
|
|
|
252 typedef enum _D3DRMSORTMODE {
|
|
|
253 D3DRMSORT_FROMPARENT, /* default */
|
|
|
254 D3DRMSORT_NONE, /* don't sort child frames */
|
|
|
255 D3DRMSORT_FRONTTOBACK, /* sort child frames front-to-back */
|
|
|
256 D3DRMSORT_BACKTOFRONT /* sort child frames back-to-front */
|
|
|
257 } D3DRMSORTMODE, *LPD3DRMSORTMODE;
|
|
|
258
|
|
|
259 typedef struct _D3DRMMATERIALOVERRIDE
|
|
|
260 {
|
|
|
261 DWORD dwSize; /* Size of this structure */
|
|
|
262 DWORD dwFlags; /* Indicate which fields are valid */
|
|
|
263 D3DCOLORVALUE dcDiffuse; /* RGBA */
|
|
|
264 D3DCOLORVALUE dcAmbient; /* RGB */
|
|
|
265 D3DCOLORVALUE dcEmissive; /* RGB */
|
|
|
266 D3DCOLORVALUE dcSpecular; /* RGB */
|
|
|
267 D3DVALUE dvPower;
|
|
|
268 LPUNKNOWN lpD3DRMTex;
|
|
|
269 } D3DRMMATERIALOVERRIDE, *LPD3DRMMATERIALOVERRIDE;
|
|
|
270
|
|
|
271 #define D3DRMMATERIALOVERRIDE_DIFFUSE_ALPHAONLY 0x00000001L
|
|
|
272 #define D3DRMMATERIALOVERRIDE_DIFFUSE_RGBONLY 0x00000002L
|
|
|
273 #define D3DRMMATERIALOVERRIDE_DIFFUSE 0x00000003L
|
|
|
274 #define D3DRMMATERIALOVERRIDE_AMBIENT 0x00000004L
|
|
|
275 #define D3DRMMATERIALOVERRIDE_EMISSIVE 0x00000008L
|
|
|
276 #define D3DRMMATERIALOVERRIDE_SPECULAR 0x00000010L
|
|
|
277 #define D3DRMMATERIALOVERRIDE_POWER 0x00000020L
|
|
|
278 #define D3DRMMATERIALOVERRIDE_TEXTURE 0x00000040L
|
|
|
279 #define D3DRMMATERIALOVERRIDE_DIFFUSE_ALPHAMULTIPLY 0x00000080L
|
|
|
280 #define D3DRMMATERIALOVERRIDE_ALL 0x000000FFL
|
|
|
281
|
|
|
282 #define D3DRMFPTF_ALPHA 0x00000001L
|
|
|
283 #define D3DRMFPTF_NOALPHA 0x00000002L
|
|
|
284 #define D3DRMFPTF_PALETTIZED 0x00000004L
|
|
|
285 #define D3DRMFPTF_NOTPALETTIZED 0x00000008L
|
|
|
286
|
|
|
287 #define D3DRMSTATECHANGE_UPDATEONLY 0x000000001L
|
|
|
288 #define D3DRMSTATECHANGE_VOLATILE 0x000000002L
|
|
|
289 #define D3DRMSTATECHANGE_NONVOLATILE 0x000000004L
|
|
|
290 #define D3DRMSTATECHANGE_RENDER 0x000000020L
|
|
|
291 #define D3DRMSTATECHANGE_LIGHT 0x000000040L
|
|
|
292
|
|
|
293 /*
|
|
|
294 * Values for flags in RM3::CreateDeviceFromSurface
|
|
|
295 */
|
|
|
296 #define D3DRMDEVICE_NOZBUFFER 0x00000001L
|
|
|
297
|
|
|
298 /*
|
|
|
299 * Values for flags in Object2::SetClientData
|
|
|
300 */
|
|
|
301 #define D3DRMCLIENTDATA_NONE 0x00000001L
|
|
|
302 #define D3DRMCLIENTDATA_LOCALFREE 0x00000002L
|
|
|
303 #define D3DRMCLIENTDATA_IUNKNOWN 0x00000004L
|
|
|
304
|
|
|
305 /*
|
|
|
306 * Values for flags in Frame2::AddMoveCallback.
|
|
|
307 */
|
|
|
308 #define D3DRMCALLBACK_PREORDER 0
|
|
|
309 #define D3DRMCALLBACK_POSTORDER 1
|
|
|
310
|
|
|
311 /*
|
|
|
312 * Values for flags in MeshBuilder2::RayPick.
|
|
|
313 */
|
|
|
314 #define D3DRMRAYPICK_ONLYBOUNDINGBOXES 1
|
|
|
315 #define D3DRMRAYPICK_IGNOREFURTHERPRIMITIVES 2
|
|
|
316 #define D3DRMRAYPICK_INTERPOLATEUV 4
|
|
|
317 #define D3DRMRAYPICK_INTERPOLATECOLOR 8
|
|
|
318 #define D3DRMRAYPICK_INTERPOLATENORMAL 0x10
|
|
|
319
|
|
|
320 /*
|
|
|
321 * Values for flags in MeshBuilder3::AddFacesIndexed.
|
|
|
322 */
|
|
|
323 #define D3DRMADDFACES_VERTICESONLY 1
|
|
|
324
|
|
|
325 /*
|
|
|
326 * Values for flags in MeshBuilder2::GenerateNormals.
|
|
|
327 */
|
|
|
328 #define D3DRMGENERATENORMALS_PRECOMPACT 1
|
|
|
329 #define D3DRMGENERATENORMALS_USECREASEANGLE 2
|
|
|
330
|
|
|
331 /*
|
|
|
332 * Values for MeshBuilder3::GetParentMesh
|
|
|
333 */
|
|
|
334 #define D3DRMMESHBUILDER_DIRECTPARENT 1
|
|
|
335 #define D3DRMMESHBUILDER_ROOTMESH 2
|
|
|
336
|
|
|
337 /*
|
|
|
338 * Flags for MeshBuilder3::Enable
|
|
|
339 */
|
|
|
340 #define D3DRMMESHBUILDER_RENDERENABLE 0x00000001L
|
|
|
341 #define D3DRMMESHBUILDER_PICKENABLE 0x00000002L
|
|
|
342
|
|
|
343 /*
|
|
|
344 * Flags for MeshBuilder3::AddMeshBuilder
|
|
|
345 */
|
|
|
346 #define D3DRMADDMESHBUILDER_DONTCOPYAPPDATA 1
|
|
|
347 #define D3DRMADDMESHBUILDER_FLATTENSUBMESHES 2
|
|
|
348 #define D3DRMADDMESHBUILDER_NOSUBMESHES 4
|
|
|
349
|
|
|
350 /*
|
|
|
351 * Flags for Object2::GetAge when used with MeshBuilders
|
|
|
352 */
|
|
|
353 #define D3DRMMESHBUILDERAGE_GEOMETRY 0x00000001L
|
|
|
354 #define D3DRMMESHBUILDERAGE_MATERIALS 0x00000002L
|
|
|
355 #define D3DRMMESHBUILDERAGE_TEXTURES 0x00000004L
|
|
|
356
|
|
|
357 /*
|
|
|
358 * Format flags for MeshBuilder3::AddTriangles.
|
|
|
359 */
|
|
|
360 #define D3DRMFVF_TYPE 0x00000001L
|
|
|
361 #define D3DRMFVF_NORMAL 0x00000002L
|
|
|
362 #define D3DRMFVF_COLOR 0x00000004L
|
|
|
363 #define D3DRMFVF_TEXTURECOORDS 0x00000008L
|
|
|
364
|
|
|
365 #define D3DRMVERTEX_STRIP 0x00000001L
|
|
|
366 #define D3DRMVERTEX_FAN 0x00000002L
|
|
|
367 #define D3DRMVERTEX_LIST 0x00000004L
|
|
|
368
|
|
|
369 /*
|
|
|
370 * Values for flags in Viewport2::Clear2
|
|
|
371 */
|
|
|
372 #define D3DRMCLEAR_TARGET 0x00000001L
|
|
|
373 #define D3DRMCLEAR_ZBUFFER 0x00000002L
|
|
|
374 #define D3DRMCLEAR_DIRTYRECTS 0x00000004L
|
|
|
375 #define D3DRMCLEAR_ALL (D3DRMCLEAR_TARGET | \
|
|
|
376 D3DRMCLEAR_ZBUFFER | \
|
|
|
377 D3DRMCLEAR_DIRTYRECTS)
|
|
|
378
|
|
|
379 /*
|
|
|
380 * Values for flags in Frame3::SetSceneFogMethod
|
|
|
381 */
|
|
|
382 #define D3DRMFOGMETHOD_VERTEX 0x00000001L
|
|
|
383 #define D3DRMFOGMETHOD_TABLE 0x00000002L
|
|
|
384 #define D3DRMFOGMETHOD_ANY 0x00000004L
|
|
|
385
|
|
|
386 /*
|
|
|
387 * Values for flags in Frame3::SetTraversalOptions
|
|
|
388 */
|
|
|
389 #define D3DRMFRAME_RENDERENABLE 0x00000001L
|
|
|
390 #define D3DRMFRAME_PICKENABLE 0x00000002L
|
|
|
391
|
|
|
392 typedef DWORD D3DRMANIMATIONOPTIONS;
|
|
|
393 #define D3DRMANIMATION_OPEN 0x01L
|
|
|
394 #define D3DRMANIMATION_CLOSED 0x02L
|
|
|
395 #define D3DRMANIMATION_LINEARPOSITION 0x04L
|
|
|
396 #define D3DRMANIMATION_SPLINEPOSITION 0x08L
|
|
|
397 #define D3DRMANIMATION_SCALEANDROTATION 0x00000010L
|
|
|
398 #define D3DRMANIMATION_POSITION 0x00000020L
|
|
|
399
|
|
|
400 typedef DWORD D3DRMINTERPOLATIONOPTIONS;
|
|
|
401 #define D3DRMINTERPOLATION_OPEN 0x01L
|
|
|
402 #define D3DRMINTERPOLATION_CLOSED 0x02L
|
|
|
403 #define D3DRMINTERPOLATION_NEAREST 0x0100L
|
|
|
404 #define D3DRMINTERPOLATION_LINEAR 0x04L
|
|
|
405 #define D3DRMINTERPOLATION_SPLINE 0x08L
|
|
|
406 #define D3DRMINTERPOLATION_VERTEXCOLOR 0x40L
|
|
|
407 #define D3DRMINTERPOLATION_SLERPNORMALS 0x80L
|
|
|
408
|
|
|
409 typedef DWORD D3DRMLOADOPTIONS;
|
|
|
410
|
|
|
411 #define D3DRMLOAD_FROMFILE 0x00L
|
|
|
412 #define D3DRMLOAD_FROMRESOURCE 0x01L
|
|
|
413 #define D3DRMLOAD_FROMMEMORY 0x02L
|
|
|
414 #define D3DRMLOAD_FROMSTREAM 0x04L
|
|
|
415 #define D3DRMLOAD_FROMURL 0x08L
|
|
|
416
|
|
|
417 #define D3DRMLOAD_BYNAME 0x10L
|
|
|
418 #define D3DRMLOAD_BYPOSITION 0x20L
|
|
|
419 #define D3DRMLOAD_BYGUID 0x40L
|
|
|
420 #define D3DRMLOAD_FIRST 0x80L
|
|
|
421
|
|
|
422 #define D3DRMLOAD_INSTANCEBYREFERENCE 0x100L
|
|
|
423 #define D3DRMLOAD_INSTANCEBYCOPYING 0x200L
|
|
|
424
|
|
|
425 #define D3DRMLOAD_ASYNCHRONOUS 0x400L
|
|
|
426
|
|
|
427 typedef struct _D3DRMLOADRESOURCE {
|
|
|
428 HMODULE hModule;
|
|
|
429 LPCTSTR lpName;
|
|
|
430 LPCTSTR lpType;
|
|
|
431 } D3DRMLOADRESOURCE, *LPD3DRMLOADRESOURCE;
|
|
|
432
|
|
|
433 typedef struct _D3DRMLOADMEMORY {
|
|
|
434 LPVOID lpMemory;
|
|
|
435 DWORD dSize;
|
|
|
436 } D3DRMLOADMEMORY, *LPD3DRMLOADMEMORY;
|
|
|
437
|
|
|
438 #define D3DRMPMESHSTATUS_VALID 0x01L
|
|
|
439 #define D3DRMPMESHSTATUS_INTERRUPTED 0x02L
|
|
|
440 #define D3DRMPMESHSTATUS_BASEMESHCOMPLETE 0x04L
|
|
|
441 #define D3DRMPMESHSTATUS_COMPLETE 0x08L
|
|
|
442 #define D3DRMPMESHSTATUS_RENDERABLE 0x10L
|
|
|
443
|
|
|
444 #define D3DRMPMESHEVENT_BASEMESH 0x01L
|
|
|
445 #define D3DRMPMESHEVENT_COMPLETE 0x02L
|
|
|
446
|
|
|
447 typedef struct _D3DRMPMESHLOADSTATUS {
|
|
|
448 DWORD dwSize; // Size of this structure
|
|
|
449 DWORD dwPMeshSize; // Total Size (bytes)
|
|
|
450 DWORD dwBaseMeshSize; // Total Size of the Base Mesh
|
|
|
451 DWORD dwBytesLoaded; // Total bytes loaded
|
|
|
452 DWORD dwVerticesLoaded; // Number of vertices loaded
|
|
|
453 DWORD dwFacesLoaded; // Number of faces loaded
|
|
|
454 HRESULT dwLoadResult; // Result of the load operation
|
|
|
455 DWORD dwFlags;
|
|
|
456 } D3DRMPMESHLOADSTATUS, *LPD3DRMPMESHLOADSTATUS;
|
|
|
457
|
|
|
458 typedef enum _D3DRMUSERVISUALREASON {
|
|
|
459 D3DRMUSERVISUAL_CANSEE,
|
|
|
460 D3DRMUSERVISUAL_RENDER
|
|
|
461 } D3DRMUSERVISUALREASON, *LPD3DRMUSERVISUALREASON;
|
|
|
462
|
|
|
463
|
|
|
464 typedef struct _D3DRMANIMATIONKEY
|
|
|
465 {
|
|
|
466 DWORD dwSize;
|
|
|
467 DWORD dwKeyType;
|
|
|
468 D3DVALUE dvTime;
|
|
|
469 DWORD dwID;
|
|
|
470 #if (!defined __cplusplus) || (!defined D3D_OVERLOADS)
|
|
|
471 union
|
|
|
472 {
|
|
|
473 D3DRMQUATERNION dqRotateKey;
|
|
|
474 D3DVECTOR dvScaleKey;
|
|
|
475 D3DVECTOR dvPositionKey;
|
|
|
476 };
|
|
|
477 #else
|
|
|
478 /*
|
|
|
479 * We do this as D3D_OVERLOADS defines constructors for D3DVECTOR,
|
|
|
480 * this can then not be used in a union. Use the inlines provided
|
|
|
481 * to extract and set the required component.
|
|
|
482 */
|
|
|
483 D3DVALUE dvK[4];
|
|
|
484 #endif
|
|
|
485 } D3DRMANIMATIONKEY;
|
|
|
486 typedef D3DRMANIMATIONKEY *LPD3DRMANIMATIONKEY;
|
|
|
487
|
|
|
488 #if (defined __cplusplus) && (defined D3D_OVERLOADS)
|
|
|
489 inline VOID
|
|
|
490 D3DRMAnimationGetRotateKey(const D3DRMANIMATIONKEY& rmKey,
|
|
|
491 D3DRMQUATERNION& rmQuat)
|
|
|
492 {
|
|
|
493 rmQuat.s = rmKey.dvK[0];
|
|
|
494 rmQuat.v = D3DVECTOR(rmKey.dvK[1], rmKey.dvK[2], rmKey.dvK[3]);
|
|
|
495 }
|
|
|
496
|
|
|
497 inline VOID
|
|
|
498 D3DRMAnimationGetScaleKey(const D3DRMANIMATIONKEY& rmKey,
|
|
|
499 D3DVECTOR& dvVec)
|
|
|
500 {
|
|
|
501 dvVec = D3DVECTOR(rmKey.dvK[0], rmKey.dvK[1], rmKey.dvK[2]);
|
|
|
502 }
|
|
|
503
|
|
|
504 inline VOID
|
|
|
505 D3DRMAnimationGetPositionKey(const D3DRMANIMATIONKEY& rmKey,
|
|
|
506 D3DVECTOR& dvVec)
|
|
|
507 {
|
|
|
508 dvVec = D3DVECTOR(rmKey.dvK[0], rmKey.dvK[1], rmKey.dvK[2]);
|
|
|
509 }
|
|
|
510 inline VOID
|
|
|
511 D3DRMAnimationSetRotateKey(D3DRMANIMATIONKEY& rmKey,
|
|
|
512 const D3DRMQUATERNION& rmQuat)
|
|
|
513 {
|
|
|
514 rmKey.dvK[0] = rmQuat.s;
|
|
|
515 rmKey.dvK[1] = rmQuat.v.x;
|
|
|
516 rmKey.dvK[2] = rmQuat.v.y;
|
|
|
517 rmKey.dvK[3] = rmQuat.v.z;
|
|
|
518 }
|
|
|
519
|
|
|
520 inline VOID
|
|
|
521 D3DRMAnimationSetScaleKey(D3DRMANIMATIONKEY& rmKey,
|
|
|
522 const D3DVECTOR& dvVec)
|
|
|
523 {
|
|
|
524 rmKey.dvK[0] = dvVec.x;
|
|
|
525 rmKey.dvK[1] = dvVec.y;
|
|
|
526 rmKey.dvK[2] = dvVec.z;
|
|
|
527 }
|
|
|
528
|
|
|
529 inline VOID
|
|
|
530 D3DRMAnimationSetPositionKey(D3DRMANIMATIONKEY& rmKey,
|
|
|
531 const D3DVECTOR& dvVec)
|
|
|
532 {
|
|
|
533 rmKey.dvK[0] = dvVec.x;
|
|
|
534 rmKey.dvK[1] = dvVec.y;
|
|
|
535 rmKey.dvK[2] = dvVec.z;
|
|
|
536 }
|
|
|
537 #endif
|
|
|
538
|
|
|
539 #define D3DRMANIMATION_ROTATEKEY 0x01
|
|
|
540 #define D3DRMANIMATION_SCALEKEY 0x02
|
|
|
541 #define D3DRMANIMATION_POSITIONKEY 0x03
|
|
|
542
|
|
|
543
|
|
|
544 typedef DWORD D3DRMMAPPING, D3DRMMAPPINGFLAG, *LPD3DRMMAPPING;
|
|
|
545 static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPU = 1;
|
|
|
546 static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPV = 2;
|
|
|
547 static const D3DRMMAPPINGFLAG D3DRMMAP_PERSPCORRECT = 4;
|
|
|
548
|
|
|
549 typedef struct _D3DRMVERTEX
|
|
|
550 { D3DVECTOR position;
|
|
|
551 D3DVECTOR normal;
|
|
|
552 D3DVALUE tu, tv;
|
|
|
553 D3DCOLOR color;
|
|
|
554 } D3DRMVERTEX, *LPD3DRMVERTEX;
|
|
|
555
|
|
|
556 typedef LONG D3DRMGROUPINDEX; /* group indexes begin a 0 */
|
|
|
557 static const D3DRMGROUPINDEX D3DRMGROUP_ALLGROUPS = -1;
|
|
|
558
|
|
|
559 /*
|
|
|
560 * Create a color from three components in the range 0-1 inclusive.
|
|
|
561 */
|
|
|
562 extern D3DCOLOR D3DRMAPI D3DRMCreateColorRGB(D3DVALUE red,
|
|
|
563 D3DVALUE green,
|
|
|
564 D3DVALUE blue);
|
|
|
565
|
|
|
566 /*
|
|
|
567 * Create a color from four components in the range 0-1 inclusive.
|
|
|
568 */
|
|
|
569 extern D3DCOLOR D3DRMAPI D3DRMCreateColorRGBA(D3DVALUE red,
|
|
|
570 D3DVALUE green,
|
|
|
571 D3DVALUE blue,
|
|
|
572 D3DVALUE alpha);
|
|
|
573
|
|
|
574 /*
|
|
|
575 * Get the red component of a color.
|
|
|
576 */
|
|
|
577 extern D3DVALUE D3DRMAPI D3DRMColorGetRed(D3DCOLOR);
|
|
|
578
|
|
|
579 /*
|
|
|
580 * Get the green component of a color.
|
|
|
581 */
|
|
|
582 extern D3DVALUE D3DRMAPI D3DRMColorGetGreen(D3DCOLOR);
|
|
|
583
|
|
|
584 /*
|
|
|
585 * Get the blue component of a color.
|
|
|
586 */
|
|
|
587 extern D3DVALUE D3DRMAPI D3DRMColorGetBlue(D3DCOLOR);
|
|
|
588
|
|
|
589 /*
|
|
|
590 * Get the alpha component of a color.
|
|
|
591 */
|
|
|
592 extern D3DVALUE D3DRMAPI D3DRMColorGetAlpha(D3DCOLOR);
|
|
|
593
|
|
|
594 /*
|
|
|
595 * Add two vectors. Returns its first argument.
|
|
|
596 */
|
|
|
597 extern LPD3DVECTOR D3DRMAPI D3DRMVectorAdd(LPD3DVECTOR d,
|
|
|
598 LPD3DVECTOR s1,
|
|
|
599 LPD3DVECTOR s2);
|
|
|
600
|
|
|
601 /*
|
|
|
602 * Subtract two vectors. Returns its first argument.
|
|
|
603 */
|
|
|
604 extern LPD3DVECTOR D3DRMAPI D3DRMVectorSubtract(LPD3DVECTOR d,
|
|
|
605 LPD3DVECTOR s1,
|
|
|
606 LPD3DVECTOR s2);
|
|
|
607 /*
|
|
|
608 * Reflect a ray about a given normal. Returns its first argument.
|
|
|
609 */
|
|
|
610 extern LPD3DVECTOR D3DRMAPI D3DRMVectorReflect(LPD3DVECTOR d,
|
|
|
611 LPD3DVECTOR ray,
|
|
|
612 LPD3DVECTOR norm);
|
|
|
613
|
|
|
614 /*
|
|
|
615 * Calculate the vector cross product. Returns its first argument.
|
|
|
616 */
|
|
|
617 extern LPD3DVECTOR D3DRMAPI D3DRMVectorCrossProduct(LPD3DVECTOR d,
|
|
|
618 LPD3DVECTOR s1,
|
|
|
619 LPD3DVECTOR s2);
|
|
|
620 /*
|
|
|
621 * Return the vector dot product.
|
|
|
622 */
|
|
|
623 extern D3DVALUE D3DRMAPI D3DRMVectorDotProduct(LPD3DVECTOR s1,
|
|
|
624 LPD3DVECTOR s2);
|
|
|
625
|
|
|
626 /*
|
|
|
627 * Scale a vector so that its modulus is 1. Returns its argument or
|
|
|
628 * NULL if there was an error (e.g. a zero vector was passed).
|
|
|
629 */
|
|
|
630 extern LPD3DVECTOR D3DRMAPI D3DRMVectorNormalize(LPD3DVECTOR);
|
|
|
631 #define D3DRMVectorNormalise D3DRMVectorNormalize
|
|
|
632
|
|
|
633 /*
|
|
|
634 * Return the length of a vector (e.g. sqrt(x*x + y*y + z*z)).
|
|
|
635 */
|
|
|
636 extern D3DVALUE D3DRMAPI D3DRMVectorModulus(LPD3DVECTOR v);
|
|
|
637
|
|
|
638 /*
|
|
|
639 * Set the rotation part of a matrix to be a rotation of theta radians
|
|
|
640 * around the given axis.
|
|
|
641 */
|
|
|
642
|
|
|
643 extern LPD3DVECTOR D3DRMAPI D3DRMVectorRotate(LPD3DVECTOR r, LPD3DVECTOR v, LPD3DVECTOR axis, D3DVALUE theta);
|
|
|
644
|
|
|
645 /*
|
|
|
646 * Scale a vector uniformly in all three axes
|
|
|
647 */
|
|
|
648 extern LPD3DVECTOR D3DRMAPI D3DRMVectorScale(LPD3DVECTOR d, LPD3DVECTOR s, D3DVALUE factor);
|
|
|
649
|
|
|
650 /*
|
|
|
651 * Return a random unit vector
|
|
|
652 */
|
|
|
653 extern LPD3DVECTOR D3DRMAPI D3DRMVectorRandom(LPD3DVECTOR d);
|
|
|
654
|
|
|
655 /*
|
|
|
656 * Returns a unit quaternion that represents a rotation of theta radians
|
|
|
657 * around the given axis.
|
|
|
658 */
|
|
|
659
|
|
|
660 extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionFromRotation(LPD3DRMQUATERNION quat,
|
|
|
661 LPD3DVECTOR v,
|
|
|
662 D3DVALUE theta);
|
|
|
663
|
|
|
664 /*
|
|
|
665 * Calculate the product of two quaternions
|
|
|
666 */
|
|
|
667 extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionMultiply(LPD3DRMQUATERNION q,
|
|
|
668 LPD3DRMQUATERNION a,
|
|
|
669 LPD3DRMQUATERNION b);
|
|
|
670
|
|
|
671 /*
|
|
|
672 * Interpolate between two quaternions
|
|
|
673 */
|
|
|
674 extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionSlerp(LPD3DRMQUATERNION q,
|
|
|
675 LPD3DRMQUATERNION a,
|
|
|
676 LPD3DRMQUATERNION b,
|
|
|
677 D3DVALUE alpha);
|
|
|
678
|
|
|
679 /*
|
|
|
680 * Calculate the matrix for the rotation that a unit quaternion represents
|
|
|
681 */
|
|
|
682 extern void D3DRMAPI D3DRMMatrixFromQuaternion(D3DRMMATRIX4D dmMat, LPD3DRMQUATERNION lpDqQuat);
|
|
|
683
|
|
|
684 /*
|
|
|
685 * Calculate the quaternion that corresponds to a rotation matrix
|
|
|
686 */
|
|
|
687 extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionFromMatrix(LPD3DRMQUATERNION, D3DRMMATRIX4D);
|
|
|
688
|
|
|
689
|
|
|
690 #if defined(__cplusplus)
|
|
|
691 };
|
|
|
692 #endif
|
|
|
693
|
|
|
694 #endif
|
|
|
695
|
