include/dx/d3drmdef.h

   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