include/vd3drmdef.h

   1 /*==========================================================================;
   2  *
   3  *  Copyright (C) 1995-1997 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 "vd3dtypes.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
  99 typedef enum _D3DRMTEXTUREQUALITY
 100 {   D3DRMTEXTURE_NEAREST,               /* choose nearest texel */
 101     D3DRMTEXTURE_LINEAR,                /* interpolate 4 texels */
 102     D3DRMTEXTURE_MIPNEAREST,            /* nearest texel in nearest mipmap  */
 103     D3DRMTEXTURE_MIPLINEAR,             /* interpolate 2 texels from 2 mipmaps */
 104     D3DRMTEXTURE_LINEARMIPNEAREST,      /* interpolate 4 texels in nearest mipmap */
 105     D3DRMTEXTURE_LINEARMIPLINEAR        /* interpolate 8 texels from 2 mipmaps */
 106 } D3DRMTEXTUREQUALITY, *LPD3DRMTEXTUREQUALITY;
 107
 108 typedef enum _D3DRMCOMBINETYPE
 109 {   D3DRMCOMBINE_REPLACE,
 110     D3DRMCOMBINE_BEFORE,
 111     D3DRMCOMBINE_AFTER
 112 } D3DRMCOMBINETYPE, *LPD3DRMCOMBINETYPE;
 113
 114 typedef D3DCOLORMODEL D3DRMCOLORMODEL, *LPD3DRMCOLORMODEL;
 115
 116 typedef enum _D3DRMPALETTEFLAGS
 117 {   D3DRMPALETTE_FREE,                  /* renderer may use this entry freely */
 118     D3DRMPALETTE_READONLY,              /* fixed but may be used by renderer */
 119     D3DRMPALETTE_RESERVED               /* may not be used by renderer */
 120 } D3DRMPALETTEFLAGS, *LPD3DRMPALETTEFLAGS;
 121
 122 typedef struct _D3DRMPALETTEENTRY
 123 {   unsigned char red;          /* 0 .. 255 */
 124     unsigned char green;        /* 0 .. 255 */
 125     unsigned char blue;         /* 0 .. 255 */
 126     unsigned char flags;        /* one of D3DRMPALETTEFLAGS */
 127 } D3DRMPALETTEENTRY, *LPD3DRMPALETTEENTRY;
 128
 129 typedef struct _D3DRMIMAGE
 130 {   int width, height;          /* width and height in pixels */
 131     int aspectx, aspecty;       /* aspect ratio for non-square pixels */
 132     int depth;                  /* bits per pixel */
 133     int rgb;                    /* if false, pixels are indices into a
 134                                    palette otherwise, pixels encode
 135                                    RGB values. */
 136     int bytes_per_line;         /* number of bytes of memory for a
 137                                    scanline. This must be a multiple
 138                                    of 4. */
 139     void* buffer1;              /* memory to render into (first buffer). */
 140     void* buffer2;              /* second rendering buffer for double
 141                                    buffering, set to NULL for single
 142                                    buffering. */
 143     unsigned long red_mask;
 144     unsigned long green_mask;
 145     unsigned long blue_mask;
 146     unsigned long alpha_mask;   /* if rgb is true, these are masks for
 147                                    the red, green and blue parts of a
 148                                    pixel.  Otherwise, these are masks
 149                                    for the significant bits of the
 150                                    red, green and blue elements in the
 151                                    palette.  For instance, most SVGA
 152                                    displays use 64 intensities of red,
 153                                    green and blue, so the masks should
 154                                    all be set to 0xfc. */
 155     int palette_size;           /* number of entries in palette */
 156     D3DRMPALETTEENTRY* palette; /* description of the palette (only if
 157                                    rgb is false).  Must be (1<<depth)
 158                                    elements. */
 159 } D3DRMIMAGE, *LPD3DRMIMAGE;
 160
 161 typedef enum _D3DRMWRAPTYPE
 162 {   D3DRMWRAP_FLAT,
 163     D3DRMWRAP_CYLINDER,
 164     D3DRMWRAP_SPHERE,
 165     D3DRMWRAP_CHROME
 166 } D3DRMWRAPTYPE, *LPD3DRMWRAPTYPE;
 167
 168 #define D3DRMWIREFRAME_CULL             1 /* cull backfaces */
 169 #define D3DRMWIREFRAME_HIDDENLINE       2 /* lines are obscured by closer objects */
 170
 171 typedef enum _D3DRMPROJECTIONTYPE
 172 {   D3DRMPROJECT_PERSPECTIVE,
 173     D3DRMPROJECT_ORTHOGRAPHIC,
 174     D3DRMPROJECT_RIGHTHANDPERSPECTIVE,
 175     D3DRMPROJECT_RIGHTHANDORTHOGRAPHIC
 176 } D3DRMPROJECTIONTYPE, *LPD3DRMPROJECTIONTYPE;
 177
 178 typedef enum _D3DRMXOFFORMAT
 179 {   D3DRMXOF_BINARY,
 180     D3DRMXOF_COMPRESSED,
 181     D3DRMXOF_TEXT
 182 } D3DRMXOFFORMAT, *LPD3DRMXOFFORMAT;
 183
 184 typedef DWORD D3DRMSAVEOPTIONS;
 185 #define D3DRMXOFSAVE_NORMALS 1
 186 #define D3DRMXOFSAVE_TEXTURECOORDINATES 2
 187 #define D3DRMXOFSAVE_MATERIALS 4
 188 #define D3DRMXOFSAVE_TEXTURENAMES 8
 189 #define D3DRMXOFSAVE_ALL 15
 190 #define D3DRMXOFSAVE_TEMPLATES 16
 191 #define D3DRMXOFSAVE_TEXTURETOPOLOGY 32
 192
 193 typedef enum _D3DRMCOLORSOURCE
 194 {   D3DRMCOLOR_FROMFACE,
 195     D3DRMCOLOR_FROMVERTEX
 196 } D3DRMCOLORSOURCE, *LPD3DRMCOLORSOURCE;
 197
 198 typedef enum _D3DRMFRAMECONSTRAINT
 199 {   D3DRMCONSTRAIN_Z,           /* use only X and Y rotations */
 200     D3DRMCONSTRAIN_Y,           /* use only X and Z rotations */
 201     D3DRMCONSTRAIN_X            /* use only Y and Z rotations */
 202 } D3DRMFRAMECONSTRAINT, *LPD3DRMFRAMECONSTRAINT;
 203
 204 typedef enum _D3DRMMATERIALMODE
 205 {   D3DRMMATERIAL_FROMMESH,
 206     D3DRMMATERIAL_FROMPARENT,
 207     D3DRMMATERIAL_FROMFRAME
 208 } D3DRMMATERIALMODE, *LPD3DRMMATERIALMODE;
 209
 210 typedef enum _D3DRMFOGMODE
 211 {   D3DRMFOG_LINEAR,            /* linear between start and end */
 212     D3DRMFOG_EXPONENTIAL,       /* density * exp(-distance) */
 213     D3DRMFOG_EXPONENTIALSQUARED /* density * exp(-distance*distance) */
 214 } D3DRMFOGMODE, *LPD3DRMFOGMODE;
 215
 216 typedef enum _D3DRMZBUFFERMODE {
 217     D3DRMZBUFFER_FROMPARENT,    /* default */
 218     D3DRMZBUFFER_ENABLE,        /* enable zbuffering */
 219     D3DRMZBUFFER_DISABLE        /* disable zbuffering */
 220 } D3DRMZBUFFERMODE, *LPD3DRMZBUFFERMODE;
 221
 222 typedef enum _D3DRMSORTMODE {
 223     D3DRMSORT_FROMPARENT,       /* default */
 224     D3DRMSORT_NONE,             /* don't sort child frames */
 225     D3DRMSORT_FRONTTOBACK,      /* sort child frames front-to-back */
 226     D3DRMSORT_BACKTOFRONT       /* sort child frames back-to-front */
 227 } D3DRMSORTMODE, *LPD3DRMSORTMODE;
 228
 229 /*
 230  * Values for flags in Frame2::AddMoveCallback.
 231  */
 232 #define D3DRMCALLBACK_PREORDER          0
 233 #define D3DRMCALLBACK_POSTORDER         1
 234
 235 /*
 236  * Values for flags in MeshBuilder2::RayPick.
 237  */
 238 #define D3DRMRAYPICK_ONLYBOUNDINGBOXES          1
 239 #define D3DRMRAYPICK_IGNOREFURTHERPRIMITIVES    2
 240 #define D3DRMRAYPICK_INTERPOLATEUV              4
 241 #define D3DRMRAYPICK_INTERPOLATECOLOR           8
 242 #define D3DRMRAYPICK_INTERPOLATENORMAL          0x10
 243
 244 /*
 245  * Values for flags in MeshBuilder2::GenerateNormals.
 246  */
 247 #define D3DRMGENERATENORMALS_PRECOMPACT         1
 248 #define D3DRMGENERATENORMALS_USECREASEANGLE     2
 249
 250 typedef DWORD D3DRMANIMATIONOPTIONS;
 251 #define D3DRMANIMATION_OPEN 0x01L
 252 #define D3DRMANIMATION_CLOSED 0x02L
 253 #define D3DRMANIMATION_LINEARPOSITION 0x04L
 254 #define D3DRMANIMATION_SPLINEPOSITION 0x08L
 255 #define D3DRMANIMATION_SCALEANDROTATION 0x00000010L
 256 #define D3DRMANIMATION_POSITION 0x00000020L
 257
 258 typedef DWORD D3DRMINTERPOLATIONOPTIONS;
 259 #define D3DRMINTERPOLATION_OPEN 0x01L
 260 #define D3DRMINTERPOLATION_CLOSED 0x02L
 261 #define D3DRMINTERPOLATION_NEAREST 0x0100L
 262 #define D3DRMINTERPOLATION_LINEAR 0x04L
 263 #define D3DRMINTERPOLATION_SPLINE 0x08L
 264 #define D3DRMINTERPOLATION_VERTEXCOLOR 0x40L
 265 #define D3DRMINTERPOLATION_SLERPNORMALS 0x80L
 266
 267 typedef DWORD D3DRMLOADOPTIONS;
 268
 269 #define D3DRMLOAD_FROMFILE  0x00L
 270 #define D3DRMLOAD_FROMRESOURCE 0x01L
 271 #define D3DRMLOAD_FROMMEMORY 0x02L
 272 #define D3DRMLOAD_FROMSTREAM 0x04L
 273 #define D3DRMLOAD_FROMURL 0x08L
 274
 275 #define D3DRMLOAD_BYNAME 0x10L
 276 #define D3DRMLOAD_BYPOSITION 0x20L
 277 #define D3DRMLOAD_BYGUID 0x40L
 278 #define D3DRMLOAD_FIRST 0x80L
 279
 280 #define D3DRMLOAD_INSTANCEBYREFERENCE 0x100L
 281 #define D3DRMLOAD_INSTANCEBYCOPYING 0x200L
 282
 283 #define D3DRMLOAD_ASYNCHRONOUS 0x400L
 284
 285 typedef struct _D3DRMLOADRESOURCE {
 286   HMODULE hModule;
 287   LPCTSTR lpName;
 288   LPCTSTR lpType;
 289 } D3DRMLOADRESOURCE, *LPD3DRMLOADRESOURCE;
 290
 291 typedef struct _D3DRMLOADMEMORY {
 292   LPVOID lpMemory;
 293   DWORD dSize;
 294 } D3DRMLOADMEMORY, *LPD3DRMLOADMEMORY;
 295
 296 #define D3DRMPMESHSTATUS_VALID 0x01L
 297 #define D3DRMPMESHSTATUS_INTERRUPTED 0x02L
 298 #define D3DRMPMESHSTATUS_BASEMESHCOMPLETE 0x04L
 299 #define D3DRMPMESHSTATUS_COMPLETE 0x08L
 300 #define D3DRMPMESHSTATUS_RENDERABLE 0x10L
 301
 302 #define D3DRMPMESHEVENT_BASEMESH 0x01L
 303 #define D3DRMPMESHEVENT_COMPLETE 0x02L
 304
 305 typedef struct _D3DRMPMESHLOADSTATUS {
 306   DWORD dwSize;            // Size of this structure
 307   DWORD dwPMeshSize;       // Total Size (bytes)
 308   DWORD dwBaseMeshSize;    // Total Size of the Base Mesh
 309   DWORD dwBytesLoaded;     // Total bytes loaded
 310   DWORD dwVerticesLoaded;  // Number of vertices loaded
 311   DWORD dwFacesLoaded;     // Number of faces loaded
 312   HRESULT dwLoadResult;    // Result of the load operation
 313   DWORD dwFlags;
 314 } D3DRMPMESHLOADSTATUS, *LPD3DRMPMESHLOADSTATUS;
 315
 316 typedef enum _D3DRMUSERVISUALREASON {
 317     D3DRMUSERVISUAL_CANSEE,
 318     D3DRMUSERVISUAL_RENDER
 319 } D3DRMUSERVISUALREASON, *LPD3DRMUSERVISUALREASON;
 320
 321
 322 typedef DWORD D3DRMMAPPING, D3DRMMAPPINGFLAG, *LPD3DRMMAPPING;
 323 static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPU = 1;
 324 static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPV = 2;
 325 static const D3DRMMAPPINGFLAG D3DRMMAP_PERSPCORRECT = 4;
 326
 327 typedef struct _D3DRMVERTEX
 328 {   D3DVECTOR       position;
 329     D3DVECTOR       normal;
 330     D3DVALUE        tu, tv;
 331     D3DCOLOR        color;
 332 } D3DRMVERTEX, *LPD3DRMVERTEX;
 333
 334 typedef LONG D3DRMGROUPINDEX; /* group indexes begin a 0 */
 335 static const D3DRMGROUPINDEX D3DRMGROUP_ALLGROUPS = -1;
 336
 337 /*
 338  * Create a color from three components in the range 0-1 inclusive.
 339  */
 340 extern D3DCOLOR D3DRMAPI        D3DRMCreateColorRGB(D3DVALUE red,
 341                                           D3DVALUE green,
 342                                           D3DVALUE blue);
 343
 344 /*
 345  * Create a color from four components in the range 0-1 inclusive.
 346  */
 347 extern D3DCOLOR D3DRMAPI        D3DRMCreateColorRGBA(D3DVALUE red,
 348                                                  D3DVALUE green,
 349                                                  D3DVALUE blue,
 350                                                  D3DVALUE alpha);
 351
 352 /*
 353  * Get the red component of a color.
 354  */
 355 extern D3DVALUE                 D3DRMAPI D3DRMColorGetRed(D3DCOLOR);
 356
 357 /*
 358  * Get the green component of a color.
 359  */
 360 extern D3DVALUE                 D3DRMAPI D3DRMColorGetGreen(D3DCOLOR);
 361
 362 /*
 363  * Get the blue component of a color.
 364  */
 365 extern D3DVALUE                 D3DRMAPI D3DRMColorGetBlue(D3DCOLOR);
 366
 367 /*
 368  * Get the alpha component of a color.
 369  */
 370 extern D3DVALUE                 D3DRMAPI D3DRMColorGetAlpha(D3DCOLOR);
 371
 372 /*
 373  * Add two vectors.  Returns its first argument.
 374  */
 375 extern LPD3DVECTOR      D3DRMAPI D3DRMVectorAdd(LPD3DVECTOR d,
 376                                           LPD3DVECTOR s1,
 377                                           LPD3DVECTOR s2);
 378
 379 /*
 380  * Subtract two vectors.  Returns its first argument.
 381  */
 382 extern LPD3DVECTOR      D3DRMAPI D3DRMVectorSubtract(LPD3DVECTOR d,
 383                                                LPD3DVECTOR s1,
 384                                                LPD3DVECTOR s2);
 385 /*
 386  * Reflect a ray about a given normal.  Returns its first argument.
 387  */
 388 extern LPD3DVECTOR      D3DRMAPI D3DRMVectorReflect(LPD3DVECTOR d,
 389                                               LPD3DVECTOR ray,
 390                                               LPD3DVECTOR norm);
 391
 392 /*
 393  * Calculate the vector cross product.  Returns its first argument.
 394  */
 395 extern LPD3DVECTOR      D3DRMAPI D3DRMVectorCrossProduct(LPD3DVECTOR d,
 396                                                    LPD3DVECTOR s1,
 397                                                    LPD3DVECTOR s2);
 398 /*
 399  * Return the vector dot product.
 400  */
 401 extern D3DVALUE                 D3DRMAPI D3DRMVectorDotProduct(LPD3DVECTOR s1,
 402                                                  LPD3DVECTOR s2);
 403
 404 /*
 405  * Scale a vector so that its modulus is 1.  Returns its argument or
 406  * NULL if there was an error (e.g. a zero vector was passed).
 407  */
 408 extern LPD3DVECTOR      D3DRMAPI D3DRMVectorNormalize(LPD3DVECTOR);
 409 #define D3DRMVectorNormalise D3DRMVectorNormalize
 410
 411 /*
 412  * Return the length of a vector (e.g. sqrt(x*x + y*y + z*z)).
 413  */
 414 extern D3DVALUE                 D3DRMAPI D3DRMVectorModulus(LPD3DVECTOR v);
 415
 416 /*
 417  * Set the rotation part of a matrix to be a rotation of theta radians
 418  * around the given axis.
 419  */
 420
 421 extern LPD3DVECTOR      D3DRMAPI D3DRMVectorRotate(LPD3DVECTOR r, LPD3DVECTOR v, LPD3DVECTOR axis, D3DVALUE theta);
 422
 423 /*
 424  * Scale a vector uniformly in all three axes
 425  */
 426 extern LPD3DVECTOR      D3DRMAPI D3DRMVectorScale(LPD3DVECTOR d, LPD3DVECTOR s, D3DVALUE factor);
 427
 428 /*
 429  * Return a random unit vector
 430  */
 431 extern LPD3DVECTOR      D3DRMAPI D3DRMVectorRandom(LPD3DVECTOR d);
 432
 433 /*
 434  * Returns a unit quaternion that represents a rotation of theta radians
 435  * around the given axis.
 436  */
 437
 438 extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionFromRotation(LPD3DRMQUATERNION quat,
 439                                                               LPD3DVECTOR v,
 440                                                               D3DVALUE theta);
 441
 442 /*
 443  * Calculate the product of two quaternions
 444  */
 445 extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionMultiply(LPD3DRMQUATERNION q,
 446                                                           LPD3DRMQUATERNION a,
 447                                                           LPD3DRMQUATERNION b);
 448
 449 /*
 450  * Interpolate between two quaternions
 451  */
 452 extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionSlerp(LPD3DRMQUATERNION q,
 453                                                        LPD3DRMQUATERNION a,
 454                                                        LPD3DRMQUATERNION b,
 455                                                        D3DVALUE alpha);
 456
 457 /*
 458  * Calculate the matrix for the rotation that a unit quaternion represents
 459  */
 460 extern void             D3DRMAPI D3DRMMatrixFromQuaternion(D3DRMMATRIX4D dmMat, LPD3DRMQUATERNION lpDqQuat);
 461
 462 /*
 463  * Calculate the quaternion that corresponds to a rotation matrix
 464  */
 465 extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionFromMatrix(LPD3DRMQUATERNION, D3DRMMATRIX4D);
 466
 467
 468 #if defined(__cplusplus)
 469 };
 470 #endif
 471
 472 #endif
 473