1 /*==========================================================================; 2 * 3 * Copyright (C) Microsoft Corporation. All Rights Reserved. 4 * 5 * File: d3dtypes.h 6 * Content: Direct3D types include file 7 * 8 ***************************************************************************/ 9 10 #ifndef _D3DTYPES_H_ 11 #define _D3DTYPES_H_ 12 13 #ifndef DIRECT3D_VERSION 14 #define DIRECT3D_VERSION 0x0700 15 #endif 16 17 #if (DIRECT3D_VERSION >= 0x0800) 18 #pragma message("should not include d3dtypes.h when compiling for DX8 or newer interfaces") 19 #endif 20 21 #include <windows.h> 22 23 #include <float.h> 24 #include "ddraw.h" 25 26 #pragma warning(disable:4201) // anonymous unions warning 27 #if defined(_X86_) || defined(_IA64_) 28 #pragma pack(4) 29 #endif 30 31 32 /* D3DVALUE is the fundamental Direct3D fractional data type */ 33 34 #define D3DVALP(val, prec) ((float)(val)) 35 #define D3DVAL(val) ((float)(val)) 36 37 #ifndef DX_SHARED_DEFINES 38 39 /* 40 * This definition is shared with other DirectX components whose header files 41 * might already have defined it. Therefore, we don't define this type if 42 * someone else already has (as indicated by the definition of 43 * DX_SHARED_DEFINES). We don't set DX_SHARED_DEFINES here as there are 44 * other types in this header that are also shared. The last of these 45 * shared defines in this file will set DX_SHARED_DEFINES. 46 */ 47 typedef float D3DVALUE, *LPD3DVALUE; 48 49 #endif /* DX_SHARED_DEFINES */ 50 51 #define D3DDivide(a, b) (float)((double) (a) / (double) (b)) 52 #define D3DMultiply(a, b) ((a) * (b)) 53 54 typedef LONG D3DFIXED; 55 56 #ifndef RGB_MAKE 57 /* 58 * Format of CI colors is 59 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 60 * | alpha | color index | fraction | 61 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 62 */ 63 #define CI_GETALPHA(ci) ((ci) >> 24) 64 #define CI_GETINDEX(ci) (((ci) >> 8) & 0xffff) 65 #define CI_GETFRACTION(ci) ((ci) & 0xff) 66 #define CI_ROUNDINDEX(ci) CI_GETINDEX((ci) + 0x80) 67 #define CI_MASKALPHA(ci) ((ci) & 0xffffff) 68 #define CI_MAKE(a, i, f) (((a) << 24) | ((i) << 8) | (f)) 69 70 /* 71 * Format of RGBA colors is 72 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 73 * | alpha | red | green | blue | 74 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 75 */ 76 #define RGBA_GETALPHA(rgb) ((rgb) >> 24) 77 #define RGBA_GETRED(rgb) (((rgb) >> 16) & 0xff) 78 #define RGBA_GETGREEN(rgb) (((rgb) >> 8) & 0xff) 79 #define RGBA_GETBLUE(rgb) ((rgb) & 0xff) 80 #define RGBA_MAKE(r, g, b, a) ((D3DCOLOR) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))) 81 82 /* D3DRGB and D3DRGBA may be used as initialisers for D3DCOLORs 83 * The float values must be in the range 0..1 84 */ 85 #define D3DRGB(r, g, b) \ 86 (0xff000000L | ( ((long)((r) * 255)) << 16) | (((long)((g) * 255)) << 8) | (long)((b) * 255)) 87 #define D3DRGBA(r, g, b, a) \ 88 ( (((long)((a) * 255)) << 24) | (((long)((r) * 255)) << 16) \ 89 | (((long)((g) * 255)) << 8) | (long)((b) * 255) \ 90 ) 91 92 /* 93 * Format of RGB colors is 94 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 95 * | ignored | red | green | blue | 96 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 97 */ 98 #define RGB_GETRED(rgb) (((rgb) >> 16) & 0xff) 99 #define RGB_GETGREEN(rgb) (((rgb) >> 8) & 0xff) 100 #define RGB_GETBLUE(rgb) ((rgb) & 0xff) 101 #define RGBA_SETALPHA(rgba, x) (((x) << 24) | ((rgba) & 0x00ffffff)) 102 #define RGB_MAKE(r, g, b) ((D3DCOLOR) (((r) << 16) | ((g) << 8) | (b))) 103 #define RGBA_TORGB(rgba) ((D3DCOLOR) ((rgba) & 0xffffff)) 104 #define RGB_TORGBA(rgb) ((D3DCOLOR) ((rgb) | 0xff000000)) 105 106 #endif 107 108 /* 109 * Flags for Enumerate functions 110 */ 111 112 /* 113 * Stop the enumeration 114 */ 115 #define D3DENUMRET_CANCEL DDENUMRET_CANCEL 116 117 /* 118 * Continue the enumeration 119 */ 120 #define D3DENUMRET_OK DDENUMRET_OK 121 122 typedef HRESULT (CALLBACK* LPD3DVALIDATECALLBACK)(LPVOID lpUserArg, DWORD dwOffset); 123 typedef HRESULT (CALLBACK* LPD3DENUMTEXTUREFORMATSCALLBACK)(LPDDSURFACEDESC lpDdsd, LPVOID lpContext); 124 typedef HRESULT (CALLBACK* LPD3DENUMPIXELFORMATSCALLBACK)(LPDDPIXELFORMAT lpDDPixFmt, LPVOID lpContext); 125 126 #ifndef DX_SHARED_DEFINES 127 128 /* 129 * This definition is shared with other DirectX components whose header files 130 * might already have defined it. Therefore, we don't define this type if 131 * someone else already has (as indicated by the definition of 132 * DX_SHARED_DEFINES). We don't set DX_SHARED_DEFINES here as there are 133 * other types in this header that are also shared. The last of these 134 * shared defines in this file will set DX_SHARED_DEFINES. 135 */ 136 #ifndef D3DCOLOR_DEFINED 137 typedef DWORD D3DCOLOR; 138 #define D3DCOLOR_DEFINED 139 #endif 140 typedef DWORD *LPD3DCOLOR; 141 142 #endif /* DX_SHARED_DEFINES */ 143 144 typedef DWORD D3DMATERIALHANDLE, *LPD3DMATERIALHANDLE; 145 typedef DWORD D3DTEXTUREHANDLE, *LPD3DTEXTUREHANDLE; 146 typedef DWORD D3DMATRIXHANDLE, *LPD3DMATRIXHANDLE; 147 148 #ifndef D3DCOLORVALUE_DEFINED 149 typedef struct _D3DCOLORVALUE { 150 union { 151 D3DVALUE r; 152 D3DVALUE dvR; 153 }; 154 union { 155 D3DVALUE g; 156 D3DVALUE dvG; 157 }; 158 union { 159 D3DVALUE b; 160 D3DVALUE dvB; 161 }; 162 union { 163 D3DVALUE a; 164 D3DVALUE dvA; 165 }; 166 } D3DCOLORVALUE; 167 #define D3DCOLORVALUE_DEFINED 168 #endif 169 typedef struct _D3DCOLORVALUE *LPD3DCOLORVALUE; 170 171 #ifndef D3DRECT_DEFINED 172 typedef struct _D3DRECT { 173 union { 174 LONG x1; 175 LONG lX1; 176 }; 177 union { 178 LONG y1; 179 LONG lY1; 180 }; 181 union { 182 LONG x2; 183 LONG lX2; 184 }; 185 union { 186 LONG y2; 187 LONG lY2; 188 }; 189 } D3DRECT; 190 #define D3DRECT_DEFINED 191 #endif 192 typedef struct _D3DRECT *LPD3DRECT; 193 194 #ifndef DX_SHARED_DEFINES 195 196 /* 197 * This definition is shared with other DirectX components whose header files 198 * might already have defined it. Therefore, we don't define this type if 199 * someone else already has (as indicated by the definition of 200 * DX_SHARED_DEFINES). 201 */ 202 203 #ifndef D3DVECTOR_DEFINED 204 typedef struct _D3DVECTOR { 205 union { 206 D3DVALUE x; 207 D3DVALUE dvX; 208 }; 209 union { 210 D3DVALUE y; 211 D3DVALUE dvY; 212 }; 213 union { 214 D3DVALUE z; 215 D3DVALUE dvZ; 216 }; 217 #if(DIRECT3D_VERSION >= 0x0500) 218 #if (defined __cplusplus) && (defined D3D_OVERLOADS) 219 220 public: 221 222 // ===================================== 223 // Constructors 224 // ===================================== 225 _D3DVECTOR_D3DVECTOR226 _D3DVECTOR() { } 227 _D3DVECTOR(D3DVALUE f); 228 _D3DVECTOR(D3DVALUE _x, D3DVALUE _y, D3DVALUE _z); 229 _D3DVECTOR(const D3DVALUE f[3]); 230 231 // ===================================== 232 // Access grants 233 // ===================================== 234 235 const D3DVALUE&operator[](int i) const; 236 D3DVALUE&operator[](int i); 237 238 // ===================================== 239 // Assignment operators 240 // ===================================== 241 242 _D3DVECTOR& operator += (const _D3DVECTOR& v); 243 _D3DVECTOR& operator -= (const _D3DVECTOR& v); 244 _D3DVECTOR& operator *= (const _D3DVECTOR& v); 245 _D3DVECTOR& operator /= (const _D3DVECTOR& v); 246 _D3DVECTOR& operator *= (D3DVALUE s); 247 _D3DVECTOR& operator /= (D3DVALUE s); 248 249 // ===================================== 250 // Unary operators 251 // ===================================== 252 253 friend _D3DVECTOR operator + (const _D3DVECTOR& v); 254 friend _D3DVECTOR operator - (const _D3DVECTOR& v); 255 256 257 // ===================================== 258 // Binary operators 259 // ===================================== 260 261 // Addition and subtraction 262 friend _D3DVECTOR operator + (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 263 friend _D3DVECTOR operator - (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 264 // Scalar multiplication and division 265 friend _D3DVECTOR operator * (const _D3DVECTOR& v, D3DVALUE s); 266 friend _D3DVECTOR operator * (D3DVALUE s, const _D3DVECTOR& v); 267 friend _D3DVECTOR operator / (const _D3DVECTOR& v, D3DVALUE s); 268 // Memberwise multiplication and division 269 friend _D3DVECTOR operator * (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 270 friend _D3DVECTOR operator / (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 271 272 // Vector dominance 273 friend int operator < (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 274 friend int operator <= (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 275 276 // Bitwise equality 277 friend int operator == (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 278 279 // Length-related functions 280 friend D3DVALUE SquareMagnitude (const _D3DVECTOR& v); 281 friend D3DVALUE Magnitude (const _D3DVECTOR& v); 282 283 // Returns vector with same direction and unit length 284 friend _D3DVECTOR Normalize (const _D3DVECTOR& v); 285 286 // Return min/max component of the input vector 287 friend D3DVALUE Min (const _D3DVECTOR& v); 288 friend D3DVALUE Max (const _D3DVECTOR& v); 289 290 // Return memberwise min/max of input vectors 291 friend _D3DVECTOR Minimize (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 292 friend _D3DVECTOR Maximize (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 293 294 // Dot and cross product 295 friend D3DVALUE DotProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 296 friend _D3DVECTOR CrossProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 297 298 #endif 299 #endif /* DIRECT3D_VERSION >= 0x0500 */ 300 } D3DVECTOR; 301 #define D3DVECTOR_DEFINED 302 #endif 303 typedef struct _D3DVECTOR *LPD3DVECTOR; 304 305 /* 306 * As this is the last of the shared defines to be defined we now set 307 * D3D_SHARED_DEFINES to flag that fact that this header has defined these 308 * types. 309 */ 310 #define DX_SHARED_DEFINES 311 312 #endif /* DX_SHARED_DEFINES */ 313 314 /* 315 * Vertex data types supported in an ExecuteBuffer. 316 */ 317 318 /* 319 * Homogeneous vertices 320 */ 321 322 typedef struct _D3DHVERTEX { 323 DWORD dwFlags; /* Homogeneous clipping flags */ 324 union { 325 D3DVALUE hx; 326 D3DVALUE dvHX; 327 }; 328 union { 329 D3DVALUE hy; 330 D3DVALUE dvHY; 331 }; 332 union { 333 D3DVALUE hz; 334 D3DVALUE dvHZ; 335 }; 336 } D3DHVERTEX, *LPD3DHVERTEX; 337 338 /* 339 * Transformed/lit vertices 340 */ 341 typedef struct _D3DTLVERTEX { 342 union { 343 D3DVALUE sx; /* Screen coordinates */ 344 D3DVALUE dvSX; 345 }; 346 union { 347 D3DVALUE sy; 348 D3DVALUE dvSY; 349 }; 350 union { 351 D3DVALUE sz; 352 D3DVALUE dvSZ; 353 }; 354 union { 355 D3DVALUE rhw; /* Reciprocal of homogeneous w */ 356 D3DVALUE dvRHW; 357 }; 358 union { 359 D3DCOLOR color; /* Vertex color */ 360 D3DCOLOR dcColor; 361 }; 362 union { 363 D3DCOLOR specular; /* Specular component of vertex */ 364 D3DCOLOR dcSpecular; 365 }; 366 union { 367 D3DVALUE tu; /* Texture coordinates */ 368 D3DVALUE dvTU; 369 }; 370 union { 371 D3DVALUE tv; 372 D3DVALUE dvTV; 373 }; 374 #if(DIRECT3D_VERSION >= 0x0500) 375 #if (defined __cplusplus) && (defined D3D_OVERLOADS) _D3DTLVERTEX_D3DTLVERTEX376 _D3DTLVERTEX() { } _D3DTLVERTEX_D3DTLVERTEX377 _D3DTLVERTEX(const D3DVECTOR& v, float _rhw, 378 D3DCOLOR _color, D3DCOLOR _specular, 379 float _tu, float _tv) 380 { sx = v.x; sy = v.y; sz = v.z; rhw = _rhw; 381 color = _color; specular = _specular; 382 tu = _tu; tv = _tv; 383 } 384 #endif 385 #endif /* DIRECT3D_VERSION >= 0x0500 */ 386 } D3DTLVERTEX, *LPD3DTLVERTEX; 387 388 /* 389 * Untransformed/lit vertices 390 */ 391 typedef struct _D3DLVERTEX { 392 union { 393 D3DVALUE x; /* Homogeneous coordinates */ 394 D3DVALUE dvX; 395 }; 396 union { 397 D3DVALUE y; 398 D3DVALUE dvY; 399 }; 400 union { 401 D3DVALUE z; 402 D3DVALUE dvZ; 403 }; 404 DWORD dwReserved; 405 union { 406 D3DCOLOR color; /* Vertex color */ 407 D3DCOLOR dcColor; 408 }; 409 union { 410 D3DCOLOR specular; /* Specular component of vertex */ 411 D3DCOLOR dcSpecular; 412 }; 413 union { 414 D3DVALUE tu; /* Texture coordinates */ 415 D3DVALUE dvTU; 416 }; 417 union { 418 D3DVALUE tv; 419 D3DVALUE dvTV; 420 }; 421 #if(DIRECT3D_VERSION >= 0x0500) 422 #if (defined __cplusplus) && (defined D3D_OVERLOADS) _D3DLVERTEX_D3DLVERTEX423 _D3DLVERTEX() { } _D3DLVERTEX_D3DLVERTEX424 _D3DLVERTEX(const D3DVECTOR& v, 425 D3DCOLOR _color, D3DCOLOR _specular, 426 float _tu, float _tv) 427 { x = v.x; y = v.y; z = v.z; dwReserved = 0; 428 color = _color; specular = _specular; 429 tu = _tu; tv = _tv; 430 } 431 #endif 432 #endif /* DIRECT3D_VERSION >= 0x0500 */ 433 } D3DLVERTEX, *LPD3DLVERTEX; 434 435 /* 436 * Untransformed/unlit vertices 437 */ 438 439 typedef struct _D3DVERTEX { 440 union { 441 D3DVALUE x; /* Homogeneous coordinates */ 442 D3DVALUE dvX; 443 }; 444 union { 445 D3DVALUE y; 446 D3DVALUE dvY; 447 }; 448 union { 449 D3DVALUE z; 450 D3DVALUE dvZ; 451 }; 452 union { 453 D3DVALUE nx; /* Normal */ 454 D3DVALUE dvNX; 455 }; 456 union { 457 D3DVALUE ny; 458 D3DVALUE dvNY; 459 }; 460 union { 461 D3DVALUE nz; 462 D3DVALUE dvNZ; 463 }; 464 union { 465 D3DVALUE tu; /* Texture coordinates */ 466 D3DVALUE dvTU; 467 }; 468 union { 469 D3DVALUE tv; 470 D3DVALUE dvTV; 471 }; 472 #if(DIRECT3D_VERSION >= 0x0500) 473 #if (defined __cplusplus) && (defined D3D_OVERLOADS) _D3DVERTEX_D3DVERTEX474 _D3DVERTEX() { } _D3DVERTEX_D3DVERTEX475 _D3DVERTEX(const D3DVECTOR& v, const D3DVECTOR& n, float _tu, float _tv) 476 { x = v.x; y = v.y; z = v.z; 477 nx = n.x; ny = n.y; nz = n.z; 478 tu = _tu; tv = _tv; 479 } 480 #endif 481 #endif /* DIRECT3D_VERSION >= 0x0500 */ 482 } D3DVERTEX, *LPD3DVERTEX; 483 484 485 /* 486 * Matrix, viewport, and tranformation structures and definitions. 487 */ 488 489 #ifndef D3DMATRIX_DEFINED 490 typedef struct _D3DMATRIX { 491 #if(DIRECT3D_VERSION >= 0x0500) 492 #if (defined __cplusplus) && (defined D3D_OVERLOADS) 493 union { 494 struct { 495 #endif 496 497 #endif /* DIRECT3D_VERSION >= 0x0500 */ 498 D3DVALUE _11, _12, _13, _14; 499 D3DVALUE _21, _22, _23, _24; 500 D3DVALUE _31, _32, _33, _34; 501 D3DVALUE _41, _42, _43, _44; 502 503 #if(DIRECT3D_VERSION >= 0x0500) 504 #if (defined __cplusplus) && (defined D3D_OVERLOADS) 505 }; 506 D3DVALUE m[4][4]; 507 }; _D3DMATRIX_D3DMATRIX508 _D3DMATRIX() { } _D3DMATRIX_D3DMATRIX509 _D3DMATRIX( D3DVALUE _m00, D3DVALUE _m01, D3DVALUE _m02, D3DVALUE _m03, 510 D3DVALUE _m10, D3DVALUE _m11, D3DVALUE _m12, D3DVALUE _m13, 511 D3DVALUE _m20, D3DVALUE _m21, D3DVALUE _m22, D3DVALUE _m23, 512 D3DVALUE _m30, D3DVALUE _m31, D3DVALUE _m32, D3DVALUE _m33 513 ) 514 { 515 m[0][0] = _m00; m[0][1] = _m01; m[0][2] = _m02; m[0][3] = _m03; 516 m[1][0] = _m10; m[1][1] = _m11; m[1][2] = _m12; m[1][3] = _m13; 517 m[2][0] = _m20; m[2][1] = _m21; m[2][2] = _m22; m[2][3] = _m23; 518 m[3][0] = _m30; m[3][1] = _m31; m[3][2] = _m32; m[3][3] = _m33; 519 } 520 operator_D3DMATRIX521 D3DVALUE& operator()(int iRow, int iColumn) { return m[iRow][iColumn]; } operator_D3DMATRIX522 const D3DVALUE& operator()(int iRow, int iColumn) const { return m[iRow][iColumn]; } 523 #if(DIRECT3D_VERSION >= 0x0600) 524 friend _D3DMATRIX operator* (const _D3DMATRIX&, const _D3DMATRIX&); 525 #endif /* DIRECT3D_VERSION >= 0x0600 */ 526 #endif 527 #endif /* DIRECT3D_VERSION >= 0x0500 */ 528 } D3DMATRIX; 529 #define D3DMATRIX_DEFINED 530 #endif 531 typedef struct _D3DMATRIX *LPD3DMATRIX; 532 533 #if (defined __cplusplus) && (defined D3D_OVERLOADS) 534 #include "d3dvec.inl" 535 #endif 536 537 typedef struct _D3DVIEWPORT { 538 DWORD dwSize; 539 DWORD dwX; 540 DWORD dwY; /* Top left */ 541 DWORD dwWidth; 542 DWORD dwHeight; /* Dimensions */ 543 D3DVALUE dvScaleX; /* Scale homogeneous to screen */ 544 D3DVALUE dvScaleY; /* Scale homogeneous to screen */ 545 D3DVALUE dvMaxX; /* Min/max homogeneous x coord */ 546 D3DVALUE dvMaxY; /* Min/max homogeneous y coord */ 547 D3DVALUE dvMinZ; 548 D3DVALUE dvMaxZ; /* Min/max homogeneous z coord */ 549 } D3DVIEWPORT, *LPD3DVIEWPORT; 550 551 #if(DIRECT3D_VERSION >= 0x0500) 552 typedef struct _D3DVIEWPORT2 { 553 DWORD dwSize; 554 DWORD dwX; 555 DWORD dwY; /* Viewport Top left */ 556 DWORD dwWidth; 557 DWORD dwHeight; /* Viewport Dimensions */ 558 D3DVALUE dvClipX; /* Top left of clip volume */ 559 D3DVALUE dvClipY; 560 D3DVALUE dvClipWidth; /* Clip Volume Dimensions */ 561 D3DVALUE dvClipHeight; 562 D3DVALUE dvMinZ; /* Min/max of clip Volume */ 563 D3DVALUE dvMaxZ; 564 } D3DVIEWPORT2, *LPD3DVIEWPORT2; 565 #endif /* DIRECT3D_VERSION >= 0x0500 */ 566 567 #if(DIRECT3D_VERSION >= 0x0700) 568 typedef struct _D3DVIEWPORT7 { 569 DWORD dwX; 570 DWORD dwY; /* Viewport Top left */ 571 DWORD dwWidth; 572 DWORD dwHeight; /* Viewport Dimensions */ 573 D3DVALUE dvMinZ; /* Min/max of clip Volume */ 574 D3DVALUE dvMaxZ; 575 } D3DVIEWPORT7, *LPD3DVIEWPORT7; 576 #endif /* DIRECT3D_VERSION >= 0x0700 */ 577 578 /* 579 * Values for clip fields. 580 */ 581 582 #if(DIRECT3D_VERSION >= 0x0700) 583 584 // Max number of user clipping planes, supported in D3D. 585 #define D3DMAXUSERCLIPPLANES 32 586 587 // These bits could be ORed together to use with D3DRENDERSTATE_CLIPPLANEENABLE 588 // 589 #define D3DCLIPPLANE0 (1 << 0) 590 #define D3DCLIPPLANE1 (1 << 1) 591 #define D3DCLIPPLANE2 (1 << 2) 592 #define D3DCLIPPLANE3 (1 << 3) 593 #define D3DCLIPPLANE4 (1 << 4) 594 #define D3DCLIPPLANE5 (1 << 5) 595 596 #endif /* DIRECT3D_VERSION >= 0x0700 */ 597 598 #define D3DCLIP_LEFT 0x00000001L 599 #define D3DCLIP_RIGHT 0x00000002L 600 #define D3DCLIP_TOP 0x00000004L 601 #define D3DCLIP_BOTTOM 0x00000008L 602 #define D3DCLIP_FRONT 0x00000010L 603 #define D3DCLIP_BACK 0x00000020L 604 #define D3DCLIP_GEN0 0x00000040L 605 #define D3DCLIP_GEN1 0x00000080L 606 #define D3DCLIP_GEN2 0x00000100L 607 #define D3DCLIP_GEN3 0x00000200L 608 #define D3DCLIP_GEN4 0x00000400L 609 #define D3DCLIP_GEN5 0x00000800L 610 611 /* 612 * Values for d3d status. 613 */ 614 #define D3DSTATUS_CLIPUNIONLEFT D3DCLIP_LEFT 615 #define D3DSTATUS_CLIPUNIONRIGHT D3DCLIP_RIGHT 616 #define D3DSTATUS_CLIPUNIONTOP D3DCLIP_TOP 617 #define D3DSTATUS_CLIPUNIONBOTTOM D3DCLIP_BOTTOM 618 #define D3DSTATUS_CLIPUNIONFRONT D3DCLIP_FRONT 619 #define D3DSTATUS_CLIPUNIONBACK D3DCLIP_BACK 620 #define D3DSTATUS_CLIPUNIONGEN0 D3DCLIP_GEN0 621 #define D3DSTATUS_CLIPUNIONGEN1 D3DCLIP_GEN1 622 #define D3DSTATUS_CLIPUNIONGEN2 D3DCLIP_GEN2 623 #define D3DSTATUS_CLIPUNIONGEN3 D3DCLIP_GEN3 624 #define D3DSTATUS_CLIPUNIONGEN4 D3DCLIP_GEN4 625 #define D3DSTATUS_CLIPUNIONGEN5 D3DCLIP_GEN5 626 627 #define D3DSTATUS_CLIPINTERSECTIONLEFT 0x00001000L 628 #define D3DSTATUS_CLIPINTERSECTIONRIGHT 0x00002000L 629 #define D3DSTATUS_CLIPINTERSECTIONTOP 0x00004000L 630 #define D3DSTATUS_CLIPINTERSECTIONBOTTOM 0x00008000L 631 #define D3DSTATUS_CLIPINTERSECTIONFRONT 0x00010000L 632 #define D3DSTATUS_CLIPINTERSECTIONBACK 0x00020000L 633 #define D3DSTATUS_CLIPINTERSECTIONGEN0 0x00040000L 634 #define D3DSTATUS_CLIPINTERSECTIONGEN1 0x00080000L 635 #define D3DSTATUS_CLIPINTERSECTIONGEN2 0x00100000L 636 #define D3DSTATUS_CLIPINTERSECTIONGEN3 0x00200000L 637 #define D3DSTATUS_CLIPINTERSECTIONGEN4 0x00400000L 638 #define D3DSTATUS_CLIPINTERSECTIONGEN5 0x00800000L 639 #define D3DSTATUS_ZNOTVISIBLE 0x01000000L 640 /* Do not use 0x80000000 for any status flags in future as it is reserved */ 641 642 #define D3DSTATUS_CLIPUNIONALL ( \ 643 D3DSTATUS_CLIPUNIONLEFT | \ 644 D3DSTATUS_CLIPUNIONRIGHT | \ 645 D3DSTATUS_CLIPUNIONTOP | \ 646 D3DSTATUS_CLIPUNIONBOTTOM | \ 647 D3DSTATUS_CLIPUNIONFRONT | \ 648 D3DSTATUS_CLIPUNIONBACK | \ 649 D3DSTATUS_CLIPUNIONGEN0 | \ 650 D3DSTATUS_CLIPUNIONGEN1 | \ 651 D3DSTATUS_CLIPUNIONGEN2 | \ 652 D3DSTATUS_CLIPUNIONGEN3 | \ 653 D3DSTATUS_CLIPUNIONGEN4 | \ 654 D3DSTATUS_CLIPUNIONGEN5 \ 655 ) 656 657 #define D3DSTATUS_CLIPINTERSECTIONALL ( \ 658 D3DSTATUS_CLIPINTERSECTIONLEFT | \ 659 D3DSTATUS_CLIPINTERSECTIONRIGHT | \ 660 D3DSTATUS_CLIPINTERSECTIONTOP | \ 661 D3DSTATUS_CLIPINTERSECTIONBOTTOM | \ 662 D3DSTATUS_CLIPINTERSECTIONFRONT | \ 663 D3DSTATUS_CLIPINTERSECTIONBACK | \ 664 D3DSTATUS_CLIPINTERSECTIONGEN0 | \ 665 D3DSTATUS_CLIPINTERSECTIONGEN1 | \ 666 D3DSTATUS_CLIPINTERSECTIONGEN2 | \ 667 D3DSTATUS_CLIPINTERSECTIONGEN3 | \ 668 D3DSTATUS_CLIPINTERSECTIONGEN4 | \ 669 D3DSTATUS_CLIPINTERSECTIONGEN5 \ 670 ) 671 672 #define D3DSTATUS_DEFAULT ( \ 673 D3DSTATUS_CLIPINTERSECTIONALL | \ 674 D3DSTATUS_ZNOTVISIBLE) 675 676 677 /* 678 * Options for direct transform calls 679 */ 680 #define D3DTRANSFORM_CLIPPED 0x00000001l 681 #define D3DTRANSFORM_UNCLIPPED 0x00000002l 682 683 typedef struct _D3DTRANSFORMDATA { 684 DWORD dwSize; 685 LPVOID lpIn; /* Input vertices */ 686 DWORD dwInSize; /* Stride of input vertices */ 687 LPVOID lpOut; /* Output vertices */ 688 DWORD dwOutSize; /* Stride of output vertices */ 689 LPD3DHVERTEX lpHOut; /* Output homogeneous vertices */ 690 DWORD dwClip; /* Clipping hint */ 691 DWORD dwClipIntersection; 692 DWORD dwClipUnion; /* Union of all clip flags */ 693 D3DRECT drExtent; /* Extent of transformed vertices */ 694 } D3DTRANSFORMDATA, *LPD3DTRANSFORMDATA; 695 696 /* 697 * Structure defining position and direction properties for lighting. 698 */ 699 typedef struct _D3DLIGHTINGELEMENT { 700 D3DVECTOR dvPosition; /* Lightable point in model space */ 701 D3DVECTOR dvNormal; /* Normalised unit vector */ 702 } D3DLIGHTINGELEMENT, *LPD3DLIGHTINGELEMENT; 703 704 /* 705 * Structure defining material properties for lighting. 706 */ 707 typedef struct _D3DMATERIAL { 708 DWORD dwSize; 709 union { 710 D3DCOLORVALUE diffuse; /* Diffuse color RGBA */ 711 D3DCOLORVALUE dcvDiffuse; 712 }; 713 union { 714 D3DCOLORVALUE ambient; /* Ambient color RGB */ 715 D3DCOLORVALUE dcvAmbient; 716 }; 717 union { 718 D3DCOLORVALUE specular; /* Specular 'shininess' */ 719 D3DCOLORVALUE dcvSpecular; 720 }; 721 union { 722 D3DCOLORVALUE emissive; /* Emissive color RGB */ 723 D3DCOLORVALUE dcvEmissive; 724 }; 725 union { 726 D3DVALUE power; /* Sharpness if specular highlight */ 727 D3DVALUE dvPower; 728 }; 729 D3DTEXTUREHANDLE hTexture; /* Handle to texture map */ 730 DWORD dwRampSize; 731 } D3DMATERIAL, *LPD3DMATERIAL; 732 733 #if(DIRECT3D_VERSION >= 0x0700) 734 735 typedef struct _D3DMATERIAL7 { 736 union { 737 D3DCOLORVALUE diffuse; /* Diffuse color RGBA */ 738 D3DCOLORVALUE dcvDiffuse; 739 }; 740 union { 741 D3DCOLORVALUE ambient; /* Ambient color RGB */ 742 D3DCOLORVALUE dcvAmbient; 743 }; 744 union { 745 D3DCOLORVALUE specular; /* Specular 'shininess' */ 746 D3DCOLORVALUE dcvSpecular; 747 }; 748 union { 749 D3DCOLORVALUE emissive; /* Emissive color RGB */ 750 D3DCOLORVALUE dcvEmissive; 751 }; 752 union { 753 D3DVALUE power; /* Sharpness if specular highlight */ 754 D3DVALUE dvPower; 755 }; 756 } D3DMATERIAL7, *LPD3DMATERIAL7; 757 758 #endif /* DIRECT3D_VERSION >= 0x0700 */ 759 760 #if(DIRECT3D_VERSION < 0x0800) 761 762 typedef enum _D3DLIGHTTYPE { 763 D3DLIGHT_POINT = 1, 764 D3DLIGHT_SPOT = 2, 765 D3DLIGHT_DIRECTIONAL = 3, 766 // Note: The following light type (D3DLIGHT_PARALLELPOINT) 767 // is no longer supported from D3D for DX7 onwards. 768 D3DLIGHT_PARALLELPOINT = 4, 769 #if(DIRECT3D_VERSION < 0x0500) // For backward compatible headers 770 D3DLIGHT_GLSPOT = 5, 771 #endif 772 D3DLIGHT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 773 } D3DLIGHTTYPE; 774 775 #else 776 typedef enum _D3DLIGHTTYPE D3DLIGHTTYPE; 777 #define D3DLIGHT_PARALLELPOINT (D3DLIGHTTYPE)4 778 #define D3DLIGHT_GLSPOT (D3DLIGHTTYPE)5 779 780 #endif //(DIRECT3D_VERSION < 0x0800) 781 782 /* 783 * Structure defining a light source and its properties. 784 */ 785 typedef struct _D3DLIGHT { 786 DWORD dwSize; 787 D3DLIGHTTYPE dltType; /* Type of light source */ 788 D3DCOLORVALUE dcvColor; /* Color of light */ 789 D3DVECTOR dvPosition; /* Position in world space */ 790 D3DVECTOR dvDirection; /* Direction in world space */ 791 D3DVALUE dvRange; /* Cutoff range */ 792 D3DVALUE dvFalloff; /* Falloff */ 793 D3DVALUE dvAttenuation0; /* Constant attenuation */ 794 D3DVALUE dvAttenuation1; /* Linear attenuation */ 795 D3DVALUE dvAttenuation2; /* Quadratic attenuation */ 796 D3DVALUE dvTheta; /* Inner angle of spotlight cone */ 797 D3DVALUE dvPhi; /* Outer angle of spotlight cone */ 798 } D3DLIGHT, *LPD3DLIGHT; 799 800 #if(DIRECT3D_VERSION >= 0x0700) 801 802 typedef struct _D3DLIGHT7 { 803 D3DLIGHTTYPE dltType; /* Type of light source */ 804 D3DCOLORVALUE dcvDiffuse; /* Diffuse color of light */ 805 D3DCOLORVALUE dcvSpecular; /* Specular color of light */ 806 D3DCOLORVALUE dcvAmbient; /* Ambient color of light */ 807 D3DVECTOR dvPosition; /* Position in world space */ 808 D3DVECTOR dvDirection; /* Direction in world space */ 809 D3DVALUE dvRange; /* Cutoff range */ 810 D3DVALUE dvFalloff; /* Falloff */ 811 D3DVALUE dvAttenuation0; /* Constant attenuation */ 812 D3DVALUE dvAttenuation1; /* Linear attenuation */ 813 D3DVALUE dvAttenuation2; /* Quadratic attenuation */ 814 D3DVALUE dvTheta; /* Inner angle of spotlight cone */ 815 D3DVALUE dvPhi; /* Outer angle of spotlight cone */ 816 } D3DLIGHT7, *LPD3DLIGHT7; 817 818 #endif /* DIRECT3D_VERSION >= 0x0700 */ 819 820 #if(DIRECT3D_VERSION >= 0x0500) 821 /* 822 * Structure defining a light source and its properties. 823 */ 824 825 /* flags bits */ 826 #define D3DLIGHT_ACTIVE 0x00000001 827 #define D3DLIGHT_NO_SPECULAR 0x00000002 828 #define D3DLIGHT_ALL (D3DLIGHT_ACTIVE | D3DLIGHT_NO_SPECULAR) 829 830 /* maximum valid light range */ 831 #define D3DLIGHT_RANGE_MAX ((float)sqrt(FLT_MAX)) 832 833 typedef struct _D3DLIGHT2 { 834 DWORD dwSize; 835 D3DLIGHTTYPE dltType; /* Type of light source */ 836 D3DCOLORVALUE dcvColor; /* Color of light */ 837 D3DVECTOR dvPosition; /* Position in world space */ 838 D3DVECTOR dvDirection; /* Direction in world space */ 839 D3DVALUE dvRange; /* Cutoff range */ 840 D3DVALUE dvFalloff; /* Falloff */ 841 D3DVALUE dvAttenuation0; /* Constant attenuation */ 842 D3DVALUE dvAttenuation1; /* Linear attenuation */ 843 D3DVALUE dvAttenuation2; /* Quadratic attenuation */ 844 D3DVALUE dvTheta; /* Inner angle of spotlight cone */ 845 D3DVALUE dvPhi; /* Outer angle of spotlight cone */ 846 DWORD dwFlags; 847 } D3DLIGHT2, *LPD3DLIGHT2; 848 849 #endif /* DIRECT3D_VERSION >= 0x0500 */ 850 typedef struct _D3DLIGHTDATA { 851 DWORD dwSize; 852 LPD3DLIGHTINGELEMENT lpIn; /* Input positions and normals */ 853 DWORD dwInSize; /* Stride of input elements */ 854 LPD3DTLVERTEX lpOut; /* Output colors */ 855 DWORD dwOutSize; /* Stride of output colors */ 856 } D3DLIGHTDATA, *LPD3DLIGHTDATA; 857 858 #if(DIRECT3D_VERSION >= 0x0500) 859 /* 860 * Before DX5, these values were in an enum called 861 * D3DCOLORMODEL. This was not correct, since they are 862 * bit flags. A driver can surface either or both flags 863 * in the dcmColorModel member of D3DDEVICEDESC. 864 */ 865 #define D3DCOLOR_MONO 1 866 #define D3DCOLOR_RGB 2 867 868 typedef DWORD D3DCOLORMODEL; 869 #endif /* DIRECT3D_VERSION >= 0x0500 */ 870 871 /* 872 * Options for clearing 873 */ 874 #define D3DCLEAR_TARGET 0x00000001l /* Clear target surface */ 875 #define D3DCLEAR_ZBUFFER 0x00000002l /* Clear target z buffer */ 876 #if(DIRECT3D_VERSION >= 0x0600) 877 #define D3DCLEAR_STENCIL 0x00000004l /* Clear stencil planes */ 878 #endif /* DIRECT3D_VERSION >= 0x0600 */ 879 880 /* 881 * Execute buffers are allocated via Direct3D. These buffers may then 882 * be filled by the application with instructions to execute along with 883 * vertex data. 884 */ 885 886 /* 887 * Supported op codes for execute instructions. 888 */ 889 typedef enum _D3DOPCODE { 890 D3DOP_POINT = 1, 891 D3DOP_LINE = 2, 892 D3DOP_TRIANGLE = 3, 893 D3DOP_MATRIXLOAD = 4, 894 D3DOP_MATRIXMULTIPLY = 5, 895 D3DOP_STATETRANSFORM = 6, 896 D3DOP_STATELIGHT = 7, 897 D3DOP_STATERENDER = 8, 898 D3DOP_PROCESSVERTICES = 9, 899 D3DOP_TEXTURELOAD = 10, 900 D3DOP_EXIT = 11, 901 D3DOP_BRANCHFORWARD = 12, 902 D3DOP_SPAN = 13, 903 D3DOP_SETSTATUS = 14, 904 #if(DIRECT3D_VERSION >= 0x0500) 905 D3DOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 906 #endif /* DIRECT3D_VERSION >= 0x0500 */ 907 } D3DOPCODE; 908 909 typedef struct _D3DINSTRUCTION { 910 BYTE bOpcode; /* Instruction opcode */ 911 BYTE bSize; /* Size of each instruction data unit */ 912 WORD wCount; /* Count of instruction data units to follow */ 913 } D3DINSTRUCTION, *LPD3DINSTRUCTION; 914 915 /* 916 * Structure for texture loads 917 */ 918 typedef struct _D3DTEXTURELOAD { 919 D3DTEXTUREHANDLE hDestTexture; 920 D3DTEXTUREHANDLE hSrcTexture; 921 } D3DTEXTURELOAD, *LPD3DTEXTURELOAD; 922 923 /* 924 * Structure for picking 925 */ 926 typedef struct _D3DPICKRECORD { 927 BYTE bOpcode; 928 BYTE bPad; 929 DWORD dwOffset; 930 D3DVALUE dvZ; 931 } D3DPICKRECORD, *LPD3DPICKRECORD; 932 933 /* 934 * The following defines the rendering states which can be set in the 935 * execute buffer. 936 */ 937 938 #if(DIRECT3D_VERSION < 0x0800) 939 940 typedef enum _D3DSHADEMODE { 941 D3DSHADE_FLAT = 1, 942 D3DSHADE_GOURAUD = 2, 943 D3DSHADE_PHONG = 3, 944 #if(DIRECT3D_VERSION >= 0x0500) 945 D3DSHADE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 946 #endif /* DIRECT3D_VERSION >= 0x0500 */ 947 } D3DSHADEMODE; 948 949 typedef enum _D3DFILLMODE { 950 D3DFILL_POINT = 1, 951 D3DFILL_WIREFRAME = 2, 952 D3DFILL_SOLID = 3, 953 #if(DIRECT3D_VERSION >= 0x0500) 954 D3DFILL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 955 #endif /* DIRECT3D_VERSION >= 0x0500 */ 956 } D3DFILLMODE; 957 958 typedef struct _D3DLINEPATTERN { 959 WORD wRepeatFactor; 960 WORD wLinePattern; 961 } D3DLINEPATTERN; 962 963 #endif //(DIRECT3D_VERSION < 0x0800) 964 965 typedef enum _D3DTEXTUREFILTER { 966 D3DFILTER_NEAREST = 1, 967 D3DFILTER_LINEAR = 2, 968 D3DFILTER_MIPNEAREST = 3, 969 D3DFILTER_MIPLINEAR = 4, 970 D3DFILTER_LINEARMIPNEAREST = 5, 971 D3DFILTER_LINEARMIPLINEAR = 6, 972 #if(DIRECT3D_VERSION >= 0x0500) 973 D3DFILTER_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 974 #endif /* DIRECT3D_VERSION >= 0x0500 */ 975 } D3DTEXTUREFILTER; 976 977 #if(DIRECT3D_VERSION < 0x0800) 978 979 typedef enum _D3DBLEND { 980 D3DBLEND_ZERO = 1, 981 D3DBLEND_ONE = 2, 982 D3DBLEND_SRCCOLOR = 3, 983 D3DBLEND_INVSRCCOLOR = 4, 984 D3DBLEND_SRCALPHA = 5, 985 D3DBLEND_INVSRCALPHA = 6, 986 D3DBLEND_DESTALPHA = 7, 987 D3DBLEND_INVDESTALPHA = 8, 988 D3DBLEND_DESTCOLOR = 9, 989 D3DBLEND_INVDESTCOLOR = 10, 990 D3DBLEND_SRCALPHASAT = 11, 991 D3DBLEND_BOTHSRCALPHA = 12, 992 D3DBLEND_BOTHINVSRCALPHA = 13, 993 #if(DIRECT3D_VERSION >= 0x0500) 994 D3DBLEND_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 995 #endif /* DIRECT3D_VERSION >= 0x0500 */ 996 } D3DBLEND; 997 998 #endif //(DIRECT3D_VERSION < 0x0800) 999 1000 typedef enum _D3DTEXTUREBLEND { 1001 D3DTBLEND_DECAL = 1, 1002 D3DTBLEND_MODULATE = 2, 1003 D3DTBLEND_DECALALPHA = 3, 1004 D3DTBLEND_MODULATEALPHA = 4, 1005 D3DTBLEND_DECALMASK = 5, 1006 D3DTBLEND_MODULATEMASK = 6, 1007 D3DTBLEND_COPY = 7, 1008 #if(DIRECT3D_VERSION >= 0x0500) 1009 D3DTBLEND_ADD = 8, 1010 D3DTBLEND_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1011 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1012 } D3DTEXTUREBLEND; 1013 1014 #if(DIRECT3D_VERSION < 0x0800) 1015 1016 typedef enum _D3DTEXTUREADDRESS { 1017 D3DTADDRESS_WRAP = 1, 1018 D3DTADDRESS_MIRROR = 2, 1019 D3DTADDRESS_CLAMP = 3, 1020 #if(DIRECT3D_VERSION >= 0x0500) 1021 D3DTADDRESS_BORDER = 4, 1022 D3DTADDRESS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1023 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1024 } D3DTEXTUREADDRESS; 1025 1026 typedef enum _D3DCULL { 1027 D3DCULL_NONE = 1, 1028 D3DCULL_CW = 2, 1029 D3DCULL_CCW = 3, 1030 #if(DIRECT3D_VERSION >= 0x0500) 1031 D3DCULL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1032 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1033 } D3DCULL; 1034 1035 typedef enum _D3DCMPFUNC { 1036 D3DCMP_NEVER = 1, 1037 D3DCMP_LESS = 2, 1038 D3DCMP_EQUAL = 3, 1039 D3DCMP_LESSEQUAL = 4, 1040 D3DCMP_GREATER = 5, 1041 D3DCMP_NOTEQUAL = 6, 1042 D3DCMP_GREATEREQUAL = 7, 1043 D3DCMP_ALWAYS = 8, 1044 #if(DIRECT3D_VERSION >= 0x0500) 1045 D3DCMP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1046 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1047 } D3DCMPFUNC; 1048 1049 #if(DIRECT3D_VERSION >= 0x0600) 1050 typedef enum _D3DSTENCILOP { 1051 D3DSTENCILOP_KEEP = 1, 1052 D3DSTENCILOP_ZERO = 2, 1053 D3DSTENCILOP_REPLACE = 3, 1054 D3DSTENCILOP_INCRSAT = 4, 1055 D3DSTENCILOP_DECRSAT = 5, 1056 D3DSTENCILOP_INVERT = 6, 1057 D3DSTENCILOP_INCR = 7, 1058 D3DSTENCILOP_DECR = 8, 1059 D3DSTENCILOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1060 } D3DSTENCILOP; 1061 #endif /* DIRECT3D_VERSION >= 0x0600 */ 1062 1063 typedef enum _D3DFOGMODE { 1064 D3DFOG_NONE = 0, 1065 D3DFOG_EXP = 1, 1066 D3DFOG_EXP2 = 2, 1067 #if(DIRECT3D_VERSION >= 0x0500) 1068 D3DFOG_LINEAR = 3, 1069 D3DFOG_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1070 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1071 } D3DFOGMODE; 1072 1073 #if(DIRECT3D_VERSION >= 0x0600) 1074 typedef enum _D3DZBUFFERTYPE { 1075 D3DZB_FALSE = 0, 1076 D3DZB_TRUE = 1, // Z buffering 1077 D3DZB_USEW = 2, // W buffering 1078 D3DZB_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1079 } D3DZBUFFERTYPE; 1080 #endif /* DIRECT3D_VERSION >= 0x0600 */ 1081 1082 #endif //(DIRECT3D_VERSION < 0x0800) 1083 1084 #if(DIRECT3D_VERSION >= 0x0500) 1085 typedef enum _D3DANTIALIASMODE { 1086 D3DANTIALIAS_NONE = 0, 1087 D3DANTIALIAS_SORTDEPENDENT = 1, 1088 D3DANTIALIAS_SORTINDEPENDENT = 2, 1089 D3DANTIALIAS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1090 } D3DANTIALIASMODE; 1091 1092 // Vertex types supported by Direct3D 1093 typedef enum _D3DVERTEXTYPE { 1094 D3DVT_VERTEX = 1, 1095 D3DVT_LVERTEX = 2, 1096 D3DVT_TLVERTEX = 3, 1097 D3DVT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1098 } D3DVERTEXTYPE; 1099 1100 #if(DIRECT3D_VERSION < 0x0800) 1101 1102 // Primitives supported by draw-primitive API 1103 typedef enum _D3DPRIMITIVETYPE { 1104 D3DPT_POINTLIST = 1, 1105 D3DPT_LINELIST = 2, 1106 D3DPT_LINESTRIP = 3, 1107 D3DPT_TRIANGLELIST = 4, 1108 D3DPT_TRIANGLESTRIP = 5, 1109 D3DPT_TRIANGLEFAN = 6, 1110 D3DPT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1111 } D3DPRIMITIVETYPE; 1112 1113 #endif //(DIRECT3D_VERSION < 0x0800) 1114 1115 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1116 /* 1117 * Amount to add to a state to generate the override for that state. 1118 */ 1119 #define D3DSTATE_OVERRIDE_BIAS 256 1120 1121 /* 1122 * A state which sets the override flag for the specified state type. 1123 */ 1124 #define D3DSTATE_OVERRIDE(type) (D3DRENDERSTATETYPE)(((DWORD) (type) + D3DSTATE_OVERRIDE_BIAS)) 1125 1126 #if(DIRECT3D_VERSION < 0x0800) 1127 1128 typedef enum _D3DTRANSFORMSTATETYPE { 1129 D3DTRANSFORMSTATE_WORLD = 1, 1130 D3DTRANSFORMSTATE_VIEW = 2, 1131 D3DTRANSFORMSTATE_PROJECTION = 3, 1132 #if(DIRECT3D_VERSION >= 0x0700) 1133 D3DTRANSFORMSTATE_WORLD1 = 4, // 2nd matrix to blend 1134 D3DTRANSFORMSTATE_WORLD2 = 5, // 3rd matrix to blend 1135 D3DTRANSFORMSTATE_WORLD3 = 6, // 4th matrix to blend 1136 D3DTRANSFORMSTATE_TEXTURE0 = 16, 1137 D3DTRANSFORMSTATE_TEXTURE1 = 17, 1138 D3DTRANSFORMSTATE_TEXTURE2 = 18, 1139 D3DTRANSFORMSTATE_TEXTURE3 = 19, 1140 D3DTRANSFORMSTATE_TEXTURE4 = 20, 1141 D3DTRANSFORMSTATE_TEXTURE5 = 21, 1142 D3DTRANSFORMSTATE_TEXTURE6 = 22, 1143 D3DTRANSFORMSTATE_TEXTURE7 = 23, 1144 #endif /* DIRECT3D_VERSION >= 0x0700 */ 1145 #if(DIRECT3D_VERSION >= 0x0500) 1146 D3DTRANSFORMSTATE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1147 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1148 } D3DTRANSFORMSTATETYPE; 1149 1150 #else 1151 1152 // 1153 // legacy transform state names 1154 // 1155 typedef enum _D3DTRANSFORMSTATETYPE D3DTRANSFORMSTATETYPE; 1156 #define D3DTRANSFORMSTATE_WORLD (D3DTRANSFORMSTATETYPE)1 1157 #define D3DTRANSFORMSTATE_VIEW (D3DTRANSFORMSTATETYPE)2 1158 #define D3DTRANSFORMSTATE_PROJECTION (D3DTRANSFORMSTATETYPE)3 1159 #define D3DTRANSFORMSTATE_WORLD1 (D3DTRANSFORMSTATETYPE)4 1160 #define D3DTRANSFORMSTATE_WORLD2 (D3DTRANSFORMSTATETYPE)5 1161 #define D3DTRANSFORMSTATE_WORLD3 (D3DTRANSFORMSTATETYPE)6 1162 #define D3DTRANSFORMSTATE_TEXTURE0 (D3DTRANSFORMSTATETYPE)16 1163 #define D3DTRANSFORMSTATE_TEXTURE1 (D3DTRANSFORMSTATETYPE)17 1164 #define D3DTRANSFORMSTATE_TEXTURE2 (D3DTRANSFORMSTATETYPE)18 1165 #define D3DTRANSFORMSTATE_TEXTURE3 (D3DTRANSFORMSTATETYPE)19 1166 #define D3DTRANSFORMSTATE_TEXTURE4 (D3DTRANSFORMSTATETYPE)20 1167 #define D3DTRANSFORMSTATE_TEXTURE5 (D3DTRANSFORMSTATETYPE)21 1168 #define D3DTRANSFORMSTATE_TEXTURE6 (D3DTRANSFORMSTATETYPE)22 1169 #define D3DTRANSFORMSTATE_TEXTURE7 (D3DTRANSFORMSTATETYPE)23 1170 1171 #endif //(DIRECT3D_VERSION < 0x0800) 1172 1173 typedef enum _D3DLIGHTSTATETYPE { 1174 D3DLIGHTSTATE_MATERIAL = 1, 1175 D3DLIGHTSTATE_AMBIENT = 2, 1176 D3DLIGHTSTATE_COLORMODEL = 3, 1177 D3DLIGHTSTATE_FOGMODE = 4, 1178 D3DLIGHTSTATE_FOGSTART = 5, 1179 D3DLIGHTSTATE_FOGEND = 6, 1180 D3DLIGHTSTATE_FOGDENSITY = 7, 1181 #if(DIRECT3D_VERSION >= 0x0600) 1182 D3DLIGHTSTATE_COLORVERTEX = 8, 1183 #endif /* DIRECT3D_VERSION >= 0x0600 */ 1184 #if(DIRECT3D_VERSION >= 0x0500) 1185 D3DLIGHTSTATE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1186 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1187 } D3DLIGHTSTATETYPE; 1188 1189 #if(DIRECT3D_VERSION < 0x0800) 1190 1191 typedef enum _D3DRENDERSTATETYPE { 1192 D3DRENDERSTATE_ANTIALIAS = 2, /* D3DANTIALIASMODE */ 1193 D3DRENDERSTATE_TEXTUREPERSPECTIVE = 4, /* TRUE for perspective correction */ 1194 D3DRENDERSTATE_ZENABLE = 7, /* D3DZBUFFERTYPE (or TRUE/FALSE for legacy) */ 1195 D3DRENDERSTATE_FILLMODE = 8, /* D3DFILL_MODE */ 1196 D3DRENDERSTATE_SHADEMODE = 9, /* D3DSHADEMODE */ 1197 D3DRENDERSTATE_LINEPATTERN = 10, /* D3DLINEPATTERN */ 1198 D3DRENDERSTATE_ZWRITEENABLE = 14, /* TRUE to enable z writes */ 1199 D3DRENDERSTATE_ALPHATESTENABLE = 15, /* TRUE to enable alpha tests */ 1200 D3DRENDERSTATE_LASTPIXEL = 16, /* TRUE for last-pixel on lines */ 1201 D3DRENDERSTATE_SRCBLEND = 19, /* D3DBLEND */ 1202 D3DRENDERSTATE_DESTBLEND = 20, /* D3DBLEND */ 1203 D3DRENDERSTATE_CULLMODE = 22, /* D3DCULL */ 1204 D3DRENDERSTATE_ZFUNC = 23, /* D3DCMPFUNC */ 1205 D3DRENDERSTATE_ALPHAREF = 24, /* D3DFIXED */ 1206 D3DRENDERSTATE_ALPHAFUNC = 25, /* D3DCMPFUNC */ 1207 D3DRENDERSTATE_DITHERENABLE = 26, /* TRUE to enable dithering */ 1208 #if(DIRECT3D_VERSION >= 0x0500) 1209 D3DRENDERSTATE_ALPHABLENDENABLE = 27, /* TRUE to enable alpha blending */ 1210 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1211 D3DRENDERSTATE_FOGENABLE = 28, /* TRUE to enable fog blending */ 1212 D3DRENDERSTATE_SPECULARENABLE = 29, /* TRUE to enable specular */ 1213 D3DRENDERSTATE_ZVISIBLE = 30, /* TRUE to enable z checking */ 1214 D3DRENDERSTATE_STIPPLEDALPHA = 33, /* TRUE to enable stippled alpha (RGB device only) */ 1215 D3DRENDERSTATE_FOGCOLOR = 34, /* D3DCOLOR */ 1216 D3DRENDERSTATE_FOGTABLEMODE = 35, /* D3DFOGMODE */ 1217 #if(DIRECT3D_VERSION >= 0x0700) 1218 D3DRENDERSTATE_FOGSTART = 36, /* Fog start (for both vertex and pixel fog) */ 1219 D3DRENDERSTATE_FOGEND = 37, /* Fog end */ 1220 D3DRENDERSTATE_FOGDENSITY = 38, /* Fog density */ 1221 #endif /* DIRECT3D_VERSION >= 0x0700 */ 1222 #if(DIRECT3D_VERSION >= 0x0500) 1223 D3DRENDERSTATE_EDGEANTIALIAS = 40, /* TRUE to enable edge antialiasing */ 1224 D3DRENDERSTATE_COLORKEYENABLE = 41, /* TRUE to enable source colorkeyed textures */ 1225 D3DRENDERSTATE_ZBIAS = 47, /* LONG Z bias */ 1226 D3DRENDERSTATE_RANGEFOGENABLE = 48, /* Enables range-based fog */ 1227 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1228 1229 #if(DIRECT3D_VERSION >= 0x0600) 1230 D3DRENDERSTATE_STENCILENABLE = 52, /* BOOL enable/disable stenciling */ 1231 D3DRENDERSTATE_STENCILFAIL = 53, /* D3DSTENCILOP to do if stencil test fails */ 1232 D3DRENDERSTATE_STENCILZFAIL = 54, /* D3DSTENCILOP to do if stencil test passes and Z test fails */ 1233 D3DRENDERSTATE_STENCILPASS = 55, /* D3DSTENCILOP to do if both stencil and Z tests pass */ 1234 D3DRENDERSTATE_STENCILFUNC = 56, /* D3DCMPFUNC fn. Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */ 1235 D3DRENDERSTATE_STENCILREF = 57, /* Reference value used in stencil test */ 1236 D3DRENDERSTATE_STENCILMASK = 58, /* Mask value used in stencil test */ 1237 D3DRENDERSTATE_STENCILWRITEMASK = 59, /* Write mask applied to values written to stencil buffer */ 1238 D3DRENDERSTATE_TEXTUREFACTOR = 60, /* D3DCOLOR used for multi-texture blend */ 1239 #endif /* DIRECT3D_VERSION >= 0x0600 */ 1240 1241 #if(DIRECT3D_VERSION >= 0x0600) 1242 1243 /* 1244 * 128 values [128, 255] are reserved for texture coordinate wrap flags. 1245 * These are constructed with the D3DWRAP_U and D3DWRAP_V macros. Using 1246 * a flags word preserves forward compatibility with texture coordinates 1247 * that are >2D. 1248 */ 1249 D3DRENDERSTATE_WRAP0 = 128, /* wrap for 1st texture coord. set */ 1250 D3DRENDERSTATE_WRAP1 = 129, /* wrap for 2nd texture coord. set */ 1251 D3DRENDERSTATE_WRAP2 = 130, /* wrap for 3rd texture coord. set */ 1252 D3DRENDERSTATE_WRAP3 = 131, /* wrap for 4th texture coord. set */ 1253 D3DRENDERSTATE_WRAP4 = 132, /* wrap for 5th texture coord. set */ 1254 D3DRENDERSTATE_WRAP5 = 133, /* wrap for 6th texture coord. set */ 1255 D3DRENDERSTATE_WRAP6 = 134, /* wrap for 7th texture coord. set */ 1256 D3DRENDERSTATE_WRAP7 = 135, /* wrap for 8th texture coord. set */ 1257 #endif /* DIRECT3D_VERSION >= 0x0600 */ 1258 #if(DIRECT3D_VERSION >= 0x0700) 1259 D3DRENDERSTATE_CLIPPING = 136, 1260 D3DRENDERSTATE_LIGHTING = 137, 1261 D3DRENDERSTATE_EXTENTS = 138, 1262 D3DRENDERSTATE_AMBIENT = 139, 1263 D3DRENDERSTATE_FOGVERTEXMODE = 140, 1264 D3DRENDERSTATE_COLORVERTEX = 141, 1265 D3DRENDERSTATE_LOCALVIEWER = 142, 1266 D3DRENDERSTATE_NORMALIZENORMALS = 143, 1267 D3DRENDERSTATE_COLORKEYBLENDENABLE = 144, 1268 D3DRENDERSTATE_DIFFUSEMATERIALSOURCE = 145, 1269 D3DRENDERSTATE_SPECULARMATERIALSOURCE = 146, 1270 D3DRENDERSTATE_AMBIENTMATERIALSOURCE = 147, 1271 D3DRENDERSTATE_EMISSIVEMATERIALSOURCE = 148, 1272 D3DRENDERSTATE_VERTEXBLEND = 151, 1273 D3DRENDERSTATE_CLIPPLANEENABLE = 152, 1274 1275 #endif /* DIRECT3D_VERSION >= 0x0700 */ 1276 1277 // 1278 // retired renderstates - not supported for DX7 interfaces 1279 // 1280 D3DRENDERSTATE_TEXTUREHANDLE = 1, /* Texture handle for legacy interfaces (Texture,Texture2) */ 1281 D3DRENDERSTATE_TEXTUREADDRESS = 3, /* D3DTEXTUREADDRESS */ 1282 D3DRENDERSTATE_WRAPU = 5, /* TRUE for wrapping in u */ 1283 D3DRENDERSTATE_WRAPV = 6, /* TRUE for wrapping in v */ 1284 D3DRENDERSTATE_MONOENABLE = 11, /* TRUE to enable mono rasterization */ 1285 D3DRENDERSTATE_ROP2 = 12, /* ROP2 */ 1286 D3DRENDERSTATE_PLANEMASK = 13, /* DWORD physical plane mask */ 1287 D3DRENDERSTATE_TEXTUREMAG = 17, /* D3DTEXTUREFILTER */ 1288 D3DRENDERSTATE_TEXTUREMIN = 18, /* D3DTEXTUREFILTER */ 1289 D3DRENDERSTATE_TEXTUREMAPBLEND = 21, /* D3DTEXTUREBLEND */ 1290 D3DRENDERSTATE_SUBPIXEL = 31, /* TRUE to enable subpixel correction */ 1291 D3DRENDERSTATE_SUBPIXELX = 32, /* TRUE to enable correction in X only */ 1292 D3DRENDERSTATE_STIPPLEENABLE = 39, /* TRUE to enable stippling */ 1293 #if(DIRECT3D_VERSION >= 0x0500) 1294 D3DRENDERSTATE_BORDERCOLOR = 43, /* Border color for texturing w/border */ 1295 D3DRENDERSTATE_TEXTUREADDRESSU = 44, /* Texture addressing mode for U coordinate */ 1296 D3DRENDERSTATE_TEXTUREADDRESSV = 45, /* Texture addressing mode for V coordinate */ 1297 D3DRENDERSTATE_MIPMAPLODBIAS = 46, /* D3DVALUE Mipmap LOD bias */ 1298 D3DRENDERSTATE_ANISOTROPY = 49, /* Max. anisotropy. 1 = no anisotropy */ 1299 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1300 D3DRENDERSTATE_FLUSHBATCH = 50, /* Explicit flush for DP batching (DX5 Only) */ 1301 #if(DIRECT3D_VERSION >= 0x0600) 1302 D3DRENDERSTATE_TRANSLUCENTSORTINDEPENDENT=51, /* BOOL enable sort-independent transparency */ 1303 #endif /* DIRECT3D_VERSION >= 0x0600 */ 1304 D3DRENDERSTATE_STIPPLEPATTERN00 = 64, /* Stipple pattern 01... */ 1305 D3DRENDERSTATE_STIPPLEPATTERN01 = 65, 1306 D3DRENDERSTATE_STIPPLEPATTERN02 = 66, 1307 D3DRENDERSTATE_STIPPLEPATTERN03 = 67, 1308 D3DRENDERSTATE_STIPPLEPATTERN04 = 68, 1309 D3DRENDERSTATE_STIPPLEPATTERN05 = 69, 1310 D3DRENDERSTATE_STIPPLEPATTERN06 = 70, 1311 D3DRENDERSTATE_STIPPLEPATTERN07 = 71, 1312 D3DRENDERSTATE_STIPPLEPATTERN08 = 72, 1313 D3DRENDERSTATE_STIPPLEPATTERN09 = 73, 1314 D3DRENDERSTATE_STIPPLEPATTERN10 = 74, 1315 D3DRENDERSTATE_STIPPLEPATTERN11 = 75, 1316 D3DRENDERSTATE_STIPPLEPATTERN12 = 76, 1317 D3DRENDERSTATE_STIPPLEPATTERN13 = 77, 1318 D3DRENDERSTATE_STIPPLEPATTERN14 = 78, 1319 D3DRENDERSTATE_STIPPLEPATTERN15 = 79, 1320 D3DRENDERSTATE_STIPPLEPATTERN16 = 80, 1321 D3DRENDERSTATE_STIPPLEPATTERN17 = 81, 1322 D3DRENDERSTATE_STIPPLEPATTERN18 = 82, 1323 D3DRENDERSTATE_STIPPLEPATTERN19 = 83, 1324 D3DRENDERSTATE_STIPPLEPATTERN20 = 84, 1325 D3DRENDERSTATE_STIPPLEPATTERN21 = 85, 1326 D3DRENDERSTATE_STIPPLEPATTERN22 = 86, 1327 D3DRENDERSTATE_STIPPLEPATTERN23 = 87, 1328 D3DRENDERSTATE_STIPPLEPATTERN24 = 88, 1329 D3DRENDERSTATE_STIPPLEPATTERN25 = 89, 1330 D3DRENDERSTATE_STIPPLEPATTERN26 = 90, 1331 D3DRENDERSTATE_STIPPLEPATTERN27 = 91, 1332 D3DRENDERSTATE_STIPPLEPATTERN28 = 92, 1333 D3DRENDERSTATE_STIPPLEPATTERN29 = 93, 1334 D3DRENDERSTATE_STIPPLEPATTERN30 = 94, 1335 D3DRENDERSTATE_STIPPLEPATTERN31 = 95, 1336 1337 // 1338 // retired renderstate names - the values are still used under new naming conventions 1339 // 1340 D3DRENDERSTATE_FOGTABLESTART = 36, /* Fog table start */ 1341 D3DRENDERSTATE_FOGTABLEEND = 37, /* Fog table end */ 1342 D3DRENDERSTATE_FOGTABLEDENSITY = 38, /* Fog table density */ 1343 1344 #if(DIRECT3D_VERSION >= 0x0500) 1345 D3DRENDERSTATE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1346 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1347 } D3DRENDERSTATETYPE; 1348 1349 #else 1350 1351 typedef enum _D3DRENDERSTATETYPE D3DRENDERSTATETYPE; 1352 1353 // 1354 // legacy renderstate names 1355 // 1356 #define D3DRENDERSTATE_TEXTUREPERSPECTIVE (D3DRENDERSTATETYPE)4 1357 #define D3DRENDERSTATE_ZENABLE (D3DRENDERSTATETYPE)7 1358 #define D3DRENDERSTATE_FILLMODE (D3DRENDERSTATETYPE)8 1359 #define D3DRENDERSTATE_SHADEMODE (D3DRENDERSTATETYPE)9 1360 #define D3DRENDERSTATE_LINEPATTERN (D3DRENDERSTATETYPE)10 1361 #define D3DRENDERSTATE_ZWRITEENABLE (D3DRENDERSTATETYPE)14 1362 #define D3DRENDERSTATE_ALPHATESTENABLE (D3DRENDERSTATETYPE)15 1363 #define D3DRENDERSTATE_LASTPIXEL (D3DRENDERSTATETYPE)16 1364 #define D3DRENDERSTATE_SRCBLEND (D3DRENDERSTATETYPE)19 1365 #define D3DRENDERSTATE_DESTBLEND (D3DRENDERSTATETYPE)20 1366 #define D3DRENDERSTATE_CULLMODE (D3DRENDERSTATETYPE)22 1367 #define D3DRENDERSTATE_ZFUNC (D3DRENDERSTATETYPE)23 1368 #define D3DRENDERSTATE_ALPHAREF (D3DRENDERSTATETYPE)24 1369 #define D3DRENDERSTATE_ALPHAFUNC (D3DRENDERSTATETYPE)25 1370 #define D3DRENDERSTATE_DITHERENABLE (D3DRENDERSTATETYPE)26 1371 #define D3DRENDERSTATE_ALPHABLENDENABLE (D3DRENDERSTATETYPE)27 1372 #define D3DRENDERSTATE_FOGENABLE (D3DRENDERSTATETYPE)28 1373 #define D3DRENDERSTATE_SPECULARENABLE (D3DRENDERSTATETYPE)29 1374 #define D3DRENDERSTATE_ZVISIBLE (D3DRENDERSTATETYPE)30 1375 #define D3DRENDERSTATE_STIPPLEDALPHA (D3DRENDERSTATETYPE)33 1376 #define D3DRENDERSTATE_FOGCOLOR (D3DRENDERSTATETYPE)34 1377 #define D3DRENDERSTATE_FOGTABLEMODE (D3DRENDERSTATETYPE)35 1378 #define D3DRENDERSTATE_FOGSTART (D3DRENDERSTATETYPE)36 1379 #define D3DRENDERSTATE_FOGEND (D3DRENDERSTATETYPE)37 1380 #define D3DRENDERSTATE_FOGDENSITY (D3DRENDERSTATETYPE)38 1381 #define D3DRENDERSTATE_EDGEANTIALIAS (D3DRENDERSTATETYPE)40 1382 #define D3DRENDERSTATE_ZBIAS (D3DRENDERSTATETYPE)47 1383 #define D3DRENDERSTATE_RANGEFOGENABLE (D3DRENDERSTATETYPE)48 1384 #define D3DRENDERSTATE_STENCILENABLE (D3DRENDERSTATETYPE)52 1385 #define D3DRENDERSTATE_STENCILFAIL (D3DRENDERSTATETYPE)53 1386 #define D3DRENDERSTATE_STENCILZFAIL (D3DRENDERSTATETYPE)54 1387 #define D3DRENDERSTATE_STENCILPASS (D3DRENDERSTATETYPE)55 1388 #define D3DRENDERSTATE_STENCILFUNC (D3DRENDERSTATETYPE)56 1389 #define D3DRENDERSTATE_STENCILREF (D3DRENDERSTATETYPE)57 1390 #define D3DRENDERSTATE_STENCILMASK (D3DRENDERSTATETYPE)58 1391 #define D3DRENDERSTATE_STENCILWRITEMASK (D3DRENDERSTATETYPE)59 1392 #define D3DRENDERSTATE_TEXTUREFACTOR (D3DRENDERSTATETYPE)60 1393 #define D3DRENDERSTATE_WRAP0 (D3DRENDERSTATETYPE)128 1394 #define D3DRENDERSTATE_WRAP1 (D3DRENDERSTATETYPE)129 1395 #define D3DRENDERSTATE_WRAP2 (D3DRENDERSTATETYPE)130 1396 #define D3DRENDERSTATE_WRAP3 (D3DRENDERSTATETYPE)131 1397 #define D3DRENDERSTATE_WRAP4 (D3DRENDERSTATETYPE)132 1398 #define D3DRENDERSTATE_WRAP5 (D3DRENDERSTATETYPE)133 1399 #define D3DRENDERSTATE_WRAP6 (D3DRENDERSTATETYPE)134 1400 #define D3DRENDERSTATE_WRAP7 (D3DRENDERSTATETYPE)135 1401 1402 #define D3DRENDERSTATE_CLIPPING (D3DRENDERSTATETYPE)136 1403 #define D3DRENDERSTATE_LIGHTING (D3DRENDERSTATETYPE)137 1404 #define D3DRENDERSTATE_EXTENTS (D3DRENDERSTATETYPE)138 1405 #define D3DRENDERSTATE_AMBIENT (D3DRENDERSTATETYPE)139 1406 #define D3DRENDERSTATE_FOGVERTEXMODE (D3DRENDERSTATETYPE)140 1407 #define D3DRENDERSTATE_COLORVERTEX (D3DRENDERSTATETYPE)141 1408 #define D3DRENDERSTATE_LOCALVIEWER (D3DRENDERSTATETYPE)142 1409 #define D3DRENDERSTATE_NORMALIZENORMALS (D3DRENDERSTATETYPE)143 1410 #define D3DRENDERSTATE_COLORKEYBLENDENABLE (D3DRENDERSTATETYPE)144 1411 #define D3DRENDERSTATE_DIFFUSEMATERIALSOURCE (D3DRENDERSTATETYPE)145 1412 #define D3DRENDERSTATE_SPECULARMATERIALSOURCE (D3DRENDERSTATETYPE)146 1413 #define D3DRENDERSTATE_AMBIENTMATERIALSOURCE (D3DRENDERSTATETYPE)147 1414 #define D3DRENDERSTATE_EMISSIVEMATERIALSOURCE (D3DRENDERSTATETYPE)148 1415 #define D3DRENDERSTATE_VERTEXBLEND (D3DRENDERSTATETYPE)151 1416 #define D3DRENDERSTATE_CLIPPLANEENABLE (D3DRENDERSTATETYPE)152 1417 1418 // 1419 // retired renderstates - not supported for DX7 interfaces 1420 // 1421 #define D3DRENDERSTATE_TEXTUREHANDLE (D3DRENDERSTATETYPE)1 1422 #define D3DRENDERSTATE_ANTIALIAS (D3DRENDERSTATETYPE)2 1423 #define D3DRENDERSTATE_TEXTUREADDRESS (D3DRENDERSTATETYPE)3 1424 #define D3DRENDERSTATE_WRAPU (D3DRENDERSTATETYPE)5 1425 #define D3DRENDERSTATE_WRAPV (D3DRENDERSTATETYPE)6 1426 #define D3DRENDERSTATE_MONOENABLE (D3DRENDERSTATETYPE)11 1427 #define D3DRENDERSTATE_ROP2 (D3DRENDERSTATETYPE)12 1428 #define D3DRENDERSTATE_PLANEMASK (D3DRENDERSTATETYPE)13 1429 #define D3DRENDERSTATE_TEXTUREMAG (D3DRENDERSTATETYPE)17 1430 #define D3DRENDERSTATE_TEXTUREMIN (D3DRENDERSTATETYPE)18 1431 #define D3DRENDERSTATE_TEXTUREMAPBLEND (D3DRENDERSTATETYPE)21 1432 #define D3DRENDERSTATE_SUBPIXEL (D3DRENDERSTATETYPE)31 1433 #define D3DRENDERSTATE_SUBPIXELX (D3DRENDERSTATETYPE)32 1434 #define D3DRENDERSTATE_STIPPLEENABLE (D3DRENDERSTATETYPE)39 1435 #define D3DRENDERSTATE_OLDALPHABLENDENABLE (D3DRENDERSTATETYPE)42 1436 #define D3DRENDERSTATE_BORDERCOLOR (D3DRENDERSTATETYPE)43 1437 #define D3DRENDERSTATE_TEXTUREADDRESSU (D3DRENDERSTATETYPE)44 1438 #define D3DRENDERSTATE_TEXTUREADDRESSV (D3DRENDERSTATETYPE)45 1439 #define D3DRENDERSTATE_MIPMAPLODBIAS (D3DRENDERSTATETYPE)46 1440 #define D3DRENDERSTATE_ANISOTROPY (D3DRENDERSTATETYPE)49 1441 #define D3DRENDERSTATE_FLUSHBATCH (D3DRENDERSTATETYPE)50 1442 #define D3DRENDERSTATE_TRANSLUCENTSORTINDEPENDENT (D3DRENDERSTATETYPE)51 1443 #define D3DRENDERSTATE_STIPPLEPATTERN00 (D3DRENDERSTATETYPE)64 1444 #define D3DRENDERSTATE_STIPPLEPATTERN01 (D3DRENDERSTATETYPE)65 1445 #define D3DRENDERSTATE_STIPPLEPATTERN02 (D3DRENDERSTATETYPE)66 1446 #define D3DRENDERSTATE_STIPPLEPATTERN03 (D3DRENDERSTATETYPE)67 1447 #define D3DRENDERSTATE_STIPPLEPATTERN04 (D3DRENDERSTATETYPE)68 1448 #define D3DRENDERSTATE_STIPPLEPATTERN05 (D3DRENDERSTATETYPE)69 1449 #define D3DRENDERSTATE_STIPPLEPATTERN06 (D3DRENDERSTATETYPE)70 1450 #define D3DRENDERSTATE_STIPPLEPATTERN07 (D3DRENDERSTATETYPE)71 1451 #define D3DRENDERSTATE_STIPPLEPATTERN08 (D3DRENDERSTATETYPE)72 1452 #define D3DRENDERSTATE_STIPPLEPATTERN09 (D3DRENDERSTATETYPE)73 1453 #define D3DRENDERSTATE_STIPPLEPATTERN10 (D3DRENDERSTATETYPE)74 1454 #define D3DRENDERSTATE_STIPPLEPATTERN11 (D3DRENDERSTATETYPE)75 1455 #define D3DRENDERSTATE_STIPPLEPATTERN12 (D3DRENDERSTATETYPE)76 1456 #define D3DRENDERSTATE_STIPPLEPATTERN13 (D3DRENDERSTATETYPE)77 1457 #define D3DRENDERSTATE_STIPPLEPATTERN14 (D3DRENDERSTATETYPE)78 1458 #define D3DRENDERSTATE_STIPPLEPATTERN15 (D3DRENDERSTATETYPE)79 1459 #define D3DRENDERSTATE_STIPPLEPATTERN16 (D3DRENDERSTATETYPE)80 1460 #define D3DRENDERSTATE_STIPPLEPATTERN17 (D3DRENDERSTATETYPE)81 1461 #define D3DRENDERSTATE_STIPPLEPATTERN18 (D3DRENDERSTATETYPE)82 1462 #define D3DRENDERSTATE_STIPPLEPATTERN19 (D3DRENDERSTATETYPE)83 1463 #define D3DRENDERSTATE_STIPPLEPATTERN20 (D3DRENDERSTATETYPE)84 1464 #define D3DRENDERSTATE_STIPPLEPATTERN21 (D3DRENDERSTATETYPE)85 1465 #define D3DRENDERSTATE_STIPPLEPATTERN22 (D3DRENDERSTATETYPE)86 1466 #define D3DRENDERSTATE_STIPPLEPATTERN23 (D3DRENDERSTATETYPE)87 1467 #define D3DRENDERSTATE_STIPPLEPATTERN24 (D3DRENDERSTATETYPE)88 1468 #define D3DRENDERSTATE_STIPPLEPATTERN25 (D3DRENDERSTATETYPE)89 1469 #define D3DRENDERSTATE_STIPPLEPATTERN26 (D3DRENDERSTATETYPE)90 1470 #define D3DRENDERSTATE_STIPPLEPATTERN27 (D3DRENDERSTATETYPE)91 1471 #define D3DRENDERSTATE_STIPPLEPATTERN28 (D3DRENDERSTATETYPE)92 1472 #define D3DRENDERSTATE_STIPPLEPATTERN29 (D3DRENDERSTATETYPE)93 1473 #define D3DRENDERSTATE_STIPPLEPATTERN30 (D3DRENDERSTATETYPE)94 1474 #define D3DRENDERSTATE_STIPPLEPATTERN31 (D3DRENDERSTATETYPE)95 1475 1476 // 1477 // retired renderstates - not supported for DX8 interfaces 1478 // 1479 #define D3DRENDERSTATE_COLORKEYENABLE (D3DRENDERSTATETYPE)41 1480 #define D3DRENDERSTATE_COLORKEYBLENDENABLE (D3DRENDERSTATETYPE)144 1481 1482 // 1483 // retired renderstate names - the values are still used under new naming conventions 1484 // 1485 #define D3DRENDERSTATE_BLENDENABLE (D3DRENDERSTATETYPE)27 1486 #define D3DRENDERSTATE_FOGTABLESTART (D3DRENDERSTATETYPE)36 1487 #define D3DRENDERSTATE_FOGTABLEEND (D3DRENDERSTATETYPE)37 1488 #define D3DRENDERSTATE_FOGTABLEDENSITY (D3DRENDERSTATETYPE)38 1489 1490 #endif //(DIRECT3D_VERSION < 0x0800) 1491 1492 1493 #if(DIRECT3D_VERSION < 0x0800) 1494 1495 // Values for material source 1496 typedef enum _D3DMATERIALCOLORSOURCE 1497 { 1498 D3DMCS_MATERIAL = 0, // Color from material is used 1499 D3DMCS_COLOR1 = 1, // Diffuse vertex color is used 1500 D3DMCS_COLOR2 = 2, // Specular vertex color is used 1501 D3DMCS_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 1502 } D3DMATERIALCOLORSOURCE; 1503 1504 1505 #if(DIRECT3D_VERSION >= 0x0500) 1506 // For back-compatibility with legacy compilations 1507 #define D3DRENDERSTATE_BLENDENABLE D3DRENDERSTATE_ALPHABLENDENABLE 1508 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1509 1510 #if(DIRECT3D_VERSION >= 0x0600) 1511 1512 // Bias to apply to the texture coordinate set to apply a wrap to. 1513 #define D3DRENDERSTATE_WRAPBIAS 128UL 1514 1515 /* Flags to construct the WRAP render states */ 1516 #define D3DWRAP_U 0x00000001L 1517 #define D3DWRAP_V 0x00000002L 1518 1519 #endif /* DIRECT3D_VERSION >= 0x0600 */ 1520 1521 #if(DIRECT3D_VERSION >= 0x0700) 1522 1523 /* Flags to construct the WRAP render states for 1D thru 4D texture coordinates */ 1524 #define D3DWRAPCOORD_0 0x00000001L // same as D3DWRAP_U 1525 #define D3DWRAPCOORD_1 0x00000002L // same as D3DWRAP_V 1526 #define D3DWRAPCOORD_2 0x00000004L 1527 #define D3DWRAPCOORD_3 0x00000008L 1528 1529 #endif /* DIRECT3D_VERSION >= 0x0700 */ 1530 1531 #endif //(DIRECT3D_VERSION < 0x0800) 1532 1533 #define D3DRENDERSTATE_STIPPLEPATTERN(y) (D3DRENDERSTATE_STIPPLEPATTERN00 + (y)) 1534 1535 typedef struct _D3DSTATE { 1536 union { 1537 #if(DIRECT3D_VERSION < 0x0800) 1538 D3DTRANSFORMSTATETYPE dtstTransformStateType; 1539 #endif //(DIRECT3D_VERSION < 0x0800) 1540 D3DLIGHTSTATETYPE dlstLightStateType; 1541 D3DRENDERSTATETYPE drstRenderStateType; 1542 }; 1543 union { 1544 DWORD dwArg[1]; 1545 D3DVALUE dvArg[1]; 1546 }; 1547 } D3DSTATE, *LPD3DSTATE; 1548 1549 1550 /* 1551 * Operation used to load matrices 1552 * hDstMat = hSrcMat 1553 */ 1554 typedef struct _D3DMATRIXLOAD { 1555 D3DMATRIXHANDLE hDestMatrix; /* Destination matrix */ 1556 D3DMATRIXHANDLE hSrcMatrix; /* Source matrix */ 1557 } D3DMATRIXLOAD, *LPD3DMATRIXLOAD; 1558 1559 /* 1560 * Operation used to multiply matrices 1561 * hDstMat = hSrcMat1 * hSrcMat2 1562 */ 1563 typedef struct _D3DMATRIXMULTIPLY { 1564 D3DMATRIXHANDLE hDestMatrix; /* Destination matrix */ 1565 D3DMATRIXHANDLE hSrcMatrix1; /* First source matrix */ 1566 D3DMATRIXHANDLE hSrcMatrix2; /* Second source matrix */ 1567 } D3DMATRIXMULTIPLY, *LPD3DMATRIXMULTIPLY; 1568 1569 /* 1570 * Operation used to transform and light vertices. 1571 */ 1572 typedef struct _D3DPROCESSVERTICES { 1573 DWORD dwFlags; /* Do we transform or light or just copy? */ 1574 WORD wStart; /* Index to first vertex in source */ 1575 WORD wDest; /* Index to first vertex in local buffer */ 1576 DWORD dwCount; /* Number of vertices to be processed */ 1577 DWORD dwReserved; /* Must be zero */ 1578 } D3DPROCESSVERTICES, *LPD3DPROCESSVERTICES; 1579 1580 #define D3DPROCESSVERTICES_TRANSFORMLIGHT 0x00000000L 1581 #define D3DPROCESSVERTICES_TRANSFORM 0x00000001L 1582 #define D3DPROCESSVERTICES_COPY 0x00000002L 1583 #define D3DPROCESSVERTICES_OPMASK 0x00000007L 1584 1585 #define D3DPROCESSVERTICES_UPDATEEXTENTS 0x00000008L 1586 #define D3DPROCESSVERTICES_NOCOLOR 0x00000010L 1587 1588 1589 #if(DIRECT3D_VERSION >= 0x0600) 1590 1591 1592 #if(DIRECT3D_VERSION < 0x0800) 1593 1594 /* 1595 * State enumerants for per-stage texture processing. 1596 */ 1597 typedef enum _D3DTEXTURESTAGESTATETYPE 1598 { 1599 D3DTSS_COLOROP = 1, /* D3DTEXTUREOP - per-stage blending controls for color channels */ 1600 D3DTSS_COLORARG1 = 2, /* D3DTA_* (texture arg) */ 1601 D3DTSS_COLORARG2 = 3, /* D3DTA_* (texture arg) */ 1602 D3DTSS_ALPHAOP = 4, /* D3DTEXTUREOP - per-stage blending controls for alpha channel */ 1603 D3DTSS_ALPHAARG1 = 5, /* D3DTA_* (texture arg) */ 1604 D3DTSS_ALPHAARG2 = 6, /* D3DTA_* (texture arg) */ 1605 D3DTSS_BUMPENVMAT00 = 7, /* D3DVALUE (bump mapping matrix) */ 1606 D3DTSS_BUMPENVMAT01 = 8, /* D3DVALUE (bump mapping matrix) */ 1607 D3DTSS_BUMPENVMAT10 = 9, /* D3DVALUE (bump mapping matrix) */ 1608 D3DTSS_BUMPENVMAT11 = 10, /* D3DVALUE (bump mapping matrix) */ 1609 D3DTSS_TEXCOORDINDEX = 11, /* identifies which set of texture coordinates index this texture */ 1610 D3DTSS_ADDRESS = 12, /* D3DTEXTUREADDRESS for both coordinates */ 1611 D3DTSS_ADDRESSU = 13, /* D3DTEXTUREADDRESS for U coordinate */ 1612 D3DTSS_ADDRESSV = 14, /* D3DTEXTUREADDRESS for V coordinate */ 1613 D3DTSS_BORDERCOLOR = 15, /* D3DCOLOR */ 1614 D3DTSS_MAGFILTER = 16, /* D3DTEXTUREMAGFILTER filter to use for magnification */ 1615 D3DTSS_MINFILTER = 17, /* D3DTEXTUREMINFILTER filter to use for minification */ 1616 D3DTSS_MIPFILTER = 18, /* D3DTEXTUREMIPFILTER filter to use between mipmaps during minification */ 1617 D3DTSS_MIPMAPLODBIAS = 19, /* D3DVALUE Mipmap LOD bias */ 1618 D3DTSS_MAXMIPLEVEL = 20, /* DWORD 0..(n-1) LOD index of largest map to use (0 == largest) */ 1619 D3DTSS_MAXANISOTROPY = 21, /* DWORD maximum anisotropy */ 1620 D3DTSS_BUMPENVLSCALE = 22, /* D3DVALUE scale for bump map luminance */ 1621 D3DTSS_BUMPENVLOFFSET = 23, /* D3DVALUE offset for bump map luminance */ 1622 #if(DIRECT3D_VERSION >= 0x0700) 1623 D3DTSS_TEXTURETRANSFORMFLAGS = 24, /* D3DTEXTURETRANSFORMFLAGS controls texture transform */ 1624 #endif /* DIRECT3D_VERSION >= 0x0700 */ 1625 D3DTSS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 1626 } D3DTEXTURESTAGESTATETYPE; 1627 1628 #if(DIRECT3D_VERSION >= 0x0700) 1629 // Values, used with D3DTSS_TEXCOORDINDEX, to specify that the vertex data(position 1630 // and normal in the camera space) should be taken as texture coordinates 1631 // Low 16 bits are used to specify texture coordinate index, to take the WRAP mode from 1632 // 1633 #define D3DTSS_TCI_PASSTHRU 0x00000000 1634 #define D3DTSS_TCI_CAMERASPACENORMAL 0x00010000 1635 #define D3DTSS_TCI_CAMERASPACEPOSITION 0x00020000 1636 #define D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR 0x00030000 1637 #endif /* DIRECT3D_VERSION >= 0x0700 */ 1638 1639 /* 1640 * Enumerations for COLOROP and ALPHAOP texture blending operations set in 1641 * texture processing stage controls in D3DRENDERSTATE. 1642 */ 1643 typedef enum _D3DTEXTUREOP 1644 { 1645 // Control 1646 D3DTOP_DISABLE = 1, // disables stage 1647 D3DTOP_SELECTARG1 = 2, // the default 1648 D3DTOP_SELECTARG2 = 3, 1649 1650 // Modulate 1651 D3DTOP_MODULATE = 4, // multiply args together 1652 D3DTOP_MODULATE2X = 5, // multiply and 1 bit 1653 D3DTOP_MODULATE4X = 6, // multiply and 2 bits 1654 1655 // Add 1656 D3DTOP_ADD = 7, // add arguments together 1657 D3DTOP_ADDSIGNED = 8, // add with -0.5 bias 1658 D3DTOP_ADDSIGNED2X = 9, // as above but left 1 bit 1659 D3DTOP_SUBTRACT = 10, // Arg1 - Arg2, with no saturation 1660 D3DTOP_ADDSMOOTH = 11, // add 2 args, subtract product 1661 // Arg1 + Arg2 - Arg1*Arg2 1662 // = Arg1 + (1-Arg1)*Arg2 1663 1664 // Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha) 1665 D3DTOP_BLENDDIFFUSEALPHA = 12, // iterated alpha 1666 D3DTOP_BLENDTEXTUREALPHA = 13, // texture alpha 1667 D3DTOP_BLENDFACTORALPHA = 14, // alpha from D3DRENDERSTATE_TEXTUREFACTOR 1668 // Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha) 1669 D3DTOP_BLENDTEXTUREALPHAPM = 15, // texture alpha 1670 D3DTOP_BLENDCURRENTALPHA = 16, // by alpha of current color 1671 1672 // Specular mapping 1673 D3DTOP_PREMODULATE = 17, // modulate with next texture before use 1674 D3DTOP_MODULATEALPHA_ADDCOLOR = 18, // Arg1.RGB + Arg1.A*Arg2.RGB 1675 // COLOROP only 1676 D3DTOP_MODULATECOLOR_ADDALPHA = 19, // Arg1.RGB*Arg2.RGB + Arg1.A 1677 // COLOROP only 1678 D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, // (1-Arg1.A)*Arg2.RGB + Arg1.RGB 1679 // COLOROP only 1680 D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, // (1-Arg1.RGB)*Arg2.RGB + Arg1.A 1681 // COLOROP only 1682 1683 // Bump mapping 1684 D3DTOP_BUMPENVMAP = 22, // per pixel env map perturbation 1685 D3DTOP_BUMPENVMAPLUMINANCE = 23, // with luminance channel 1686 // This can do either diffuse or specular bump mapping with correct input. 1687 // Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G + Arg1.B*Arg2.B) 1688 // where each component has been scaled and offset to make it signed. 1689 // The result is replicated into all four (including alpha) channels. 1690 // This is a valid COLOROP only. 1691 D3DTOP_DOTPRODUCT3 = 24, 1692 1693 D3DTOP_FORCE_DWORD = 0x7fffffff, 1694 } D3DTEXTUREOP; 1695 1696 /* 1697 * Values for COLORARG1,2 and ALPHAARG1,2 texture blending operations 1698 * set in texture processing stage controls in D3DRENDERSTATE. 1699 */ 1700 #define D3DTA_SELECTMASK 0x0000000f // mask for arg selector 1701 #define D3DTA_DIFFUSE 0x00000000 // select diffuse color 1702 #define D3DTA_CURRENT 0x00000001 // select result of previous stage 1703 #define D3DTA_TEXTURE 0x00000002 // select texture color 1704 #define D3DTA_TFACTOR 0x00000003 // select RENDERSTATE_TEXTUREFACTOR 1705 #if(DIRECT3D_VERSION >= 0x0700) 1706 #define D3DTA_SPECULAR 0x00000004 // select specular color 1707 #endif /* DIRECT3D_VERSION >= 0x0700 */ 1708 #define D3DTA_COMPLEMENT 0x00000010 // take 1.0 - x 1709 #define D3DTA_ALPHAREPLICATE 0x00000020 // replicate alpha to color components 1710 1711 #endif //(DIRECT3D_VERSION < 0x0800) 1712 1713 /* 1714 * IDirect3DTexture2 State Filter Types 1715 */ 1716 typedef enum _D3DTEXTUREMAGFILTER 1717 { 1718 D3DTFG_POINT = 1, // nearest 1719 D3DTFG_LINEAR = 2, // linear interpolation 1720 D3DTFG_FLATCUBIC = 3, // cubic 1721 D3DTFG_GAUSSIANCUBIC = 4, // different cubic kernel 1722 D3DTFG_ANISOTROPIC = 5, // 1723 #if(DIRECT3D_VERSION >= 0x0700) 1724 #endif /* DIRECT3D_VERSION >= 0x0700 */ 1725 D3DTFG_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 1726 } D3DTEXTUREMAGFILTER; 1727 1728 typedef enum _D3DTEXTUREMINFILTER 1729 { 1730 D3DTFN_POINT = 1, // nearest 1731 D3DTFN_LINEAR = 2, // linear interpolation 1732 D3DTFN_ANISOTROPIC = 3, // 1733 D3DTFN_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 1734 } D3DTEXTUREMINFILTER; 1735 1736 typedef enum _D3DTEXTUREMIPFILTER 1737 { 1738 D3DTFP_NONE = 1, // mipmapping disabled (use MAG filter) 1739 D3DTFP_POINT = 2, // nearest 1740 D3DTFP_LINEAR = 3, // linear interpolation 1741 D3DTFP_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 1742 } D3DTEXTUREMIPFILTER; 1743 1744 #endif /* DIRECT3D_VERSION >= 0x0600 */ 1745 1746 /* 1747 * Triangle flags 1748 */ 1749 1750 /* 1751 * Tri strip and fan flags. 1752 * START loads all three vertices 1753 * EVEN and ODD load just v3 with even or odd culling 1754 * START_FLAT contains a count from 0 to 29 that allows the 1755 * whole strip or fan to be culled in one hit. 1756 * e.g. for a quad len = 1 1757 */ 1758 #define D3DTRIFLAG_START 0x00000000L 1759 #define D3DTRIFLAG_STARTFLAT(len) (len) /* 0 < len < 30 */ 1760 #define D3DTRIFLAG_ODD 0x0000001eL 1761 #define D3DTRIFLAG_EVEN 0x0000001fL 1762 1763 /* 1764 * Triangle edge flags 1765 * enable edges for wireframe or antialiasing 1766 */ 1767 #define D3DTRIFLAG_EDGEENABLE1 0x00000100L /* v0-v1 edge */ 1768 #define D3DTRIFLAG_EDGEENABLE2 0x00000200L /* v1-v2 edge */ 1769 #define D3DTRIFLAG_EDGEENABLE3 0x00000400L /* v2-v0 edge */ 1770 #define D3DTRIFLAG_EDGEENABLETRIANGLE \ 1771 (D3DTRIFLAG_EDGEENABLE1 | D3DTRIFLAG_EDGEENABLE2 | D3DTRIFLAG_EDGEENABLE3) 1772 1773 /* 1774 * Primitive structures and related defines. Vertex offsets are to types 1775 * D3DVERTEX, D3DLVERTEX, or D3DTLVERTEX. 1776 */ 1777 1778 /* 1779 * Triangle list primitive structure 1780 */ 1781 typedef struct _D3DTRIANGLE { 1782 union { 1783 WORD v1; /* Vertex indices */ 1784 WORD wV1; 1785 }; 1786 union { 1787 WORD v2; 1788 WORD wV2; 1789 }; 1790 union { 1791 WORD v3; 1792 WORD wV3; 1793 }; 1794 WORD wFlags; /* Edge (and other) flags */ 1795 } D3DTRIANGLE, *LPD3DTRIANGLE; 1796 1797 /* 1798 * Line list structure. 1799 * The instruction count defines the number of line segments. 1800 */ 1801 typedef struct _D3DLINE { 1802 union { 1803 WORD v1; /* Vertex indices */ 1804 WORD wV1; 1805 }; 1806 union { 1807 WORD v2; 1808 WORD wV2; 1809 }; 1810 } D3DLINE, *LPD3DLINE; 1811 1812 /* 1813 * Span structure 1814 * Spans join a list of points with the same y value. 1815 * If the y value changes, a new span is started. 1816 */ 1817 typedef struct _D3DSPAN { 1818 WORD wCount; /* Number of spans */ 1819 WORD wFirst; /* Index to first vertex */ 1820 } D3DSPAN, *LPD3DSPAN; 1821 1822 /* 1823 * Point structure 1824 */ 1825 typedef struct _D3DPOINT { 1826 WORD wCount; /* number of points */ 1827 WORD wFirst; /* index to first vertex */ 1828 } D3DPOINT, *LPD3DPOINT; 1829 1830 1831 /* 1832 * Forward branch structure. 1833 * Mask is logically anded with the driver status mask 1834 * if the result equals 'value', the branch is taken. 1835 */ 1836 typedef struct _D3DBRANCH { 1837 DWORD dwMask; /* Bitmask against D3D status */ 1838 DWORD dwValue; 1839 BOOL bNegate; /* TRUE to negate comparison */ 1840 DWORD dwOffset; /* How far to branch forward (0 for exit)*/ 1841 } D3DBRANCH, *LPD3DBRANCH; 1842 1843 /* 1844 * Status used for set status instruction. 1845 * The D3D status is initialised on device creation 1846 * and is modified by all execute calls. 1847 */ 1848 typedef struct _D3DSTATUS { 1849 DWORD dwFlags; /* Do we set extents or status */ 1850 DWORD dwStatus; /* D3D status */ 1851 D3DRECT drExtent; 1852 } D3DSTATUS, *LPD3DSTATUS; 1853 1854 #define D3DSETSTATUS_STATUS 0x00000001L 1855 #define D3DSETSTATUS_EXTENTS 0x00000002L 1856 #define D3DSETSTATUS_ALL (D3DSETSTATUS_STATUS | D3DSETSTATUS_EXTENTS) 1857 1858 #if(DIRECT3D_VERSION >= 0x0500) 1859 typedef struct _D3DCLIPSTATUS { 1860 DWORD dwFlags; /* Do we set 2d extents, 3D extents or status */ 1861 DWORD dwStatus; /* Clip status */ 1862 float minx, maxx; /* X extents */ 1863 float miny, maxy; /* Y extents */ 1864 float minz, maxz; /* Z extents */ 1865 } D3DCLIPSTATUS, *LPD3DCLIPSTATUS; 1866 1867 #define D3DCLIPSTATUS_STATUS 0x00000001L 1868 #define D3DCLIPSTATUS_EXTENTS2 0x00000002L 1869 #define D3DCLIPSTATUS_EXTENTS3 0x00000004L 1870 1871 #endif /* DIRECT3D_VERSION >= 0x0500 */ 1872 /* 1873 * Statistics structure 1874 */ 1875 typedef struct _D3DSTATS { 1876 DWORD dwSize; 1877 DWORD dwTrianglesDrawn; 1878 DWORD dwLinesDrawn; 1879 DWORD dwPointsDrawn; 1880 DWORD dwSpansDrawn; 1881 DWORD dwVerticesProcessed; 1882 } D3DSTATS, *LPD3DSTATS; 1883 1884 /* 1885 * Execute options. 1886 * When calling using D3DEXECUTE_UNCLIPPED all the primitives 1887 * inside the buffer must be contained within the viewport. 1888 */ 1889 #define D3DEXECUTE_CLIPPED 0x00000001l 1890 #define D3DEXECUTE_UNCLIPPED 0x00000002l 1891 1892 typedef struct _D3DEXECUTEDATA { 1893 DWORD dwSize; 1894 DWORD dwVertexOffset; 1895 DWORD dwVertexCount; 1896 DWORD dwInstructionOffset; 1897 DWORD dwInstructionLength; 1898 DWORD dwHVertexOffset; 1899 D3DSTATUS dsStatus; /* Status after execute */ 1900 } D3DEXECUTEDATA, *LPD3DEXECUTEDATA; 1901 1902 /* 1903 * Palette flags. 1904 * This are or'ed with the peFlags in the PALETTEENTRYs passed to DirectDraw. 1905 */ 1906 #define D3DPAL_FREE 0x00 /* Renderer may use this entry freely */ 1907 #define D3DPAL_READONLY 0x40 /* Renderer may not set this entry */ 1908 #define D3DPAL_RESERVED 0x80 /* Renderer may not use this entry */ 1909 1910 1911 #if(DIRECT3D_VERSION >= 0x0600) 1912 1913 typedef struct _D3DVERTEXBUFFERDESC { 1914 DWORD dwSize; 1915 DWORD dwCaps; 1916 DWORD dwFVF; 1917 DWORD dwNumVertices; 1918 } D3DVERTEXBUFFERDESC, *LPD3DVERTEXBUFFERDESC; 1919 1920 #define D3DVBCAPS_SYSTEMMEMORY 0x00000800l 1921 #define D3DVBCAPS_WRITEONLY 0x00010000l 1922 #define D3DVBCAPS_OPTIMIZED 0x80000000l 1923 #define D3DVBCAPS_DONOTCLIP 0x00000001l 1924 1925 /* Vertex Operations for ProcessVertices */ 1926 #define D3DVOP_LIGHT (1 << 10) 1927 #define D3DVOP_TRANSFORM (1 << 0) 1928 #define D3DVOP_CLIP (1 << 2) 1929 #define D3DVOP_EXTENTS (1 << 3) 1930 1931 1932 #if(DIRECT3D_VERSION < 0x0800) 1933 1934 /* The maximum number of vertices user can pass to any d3d 1935 drawing function or to create vertex buffer with 1936 */ 1937 #define D3DMAXNUMVERTICES ((1<<16) - 1) 1938 /* The maximum number of primitives user can pass to any d3d 1939 drawing function. 1940 */ 1941 #define D3DMAXNUMPRIMITIVES ((1<<16) - 1) 1942 1943 #if(DIRECT3D_VERSION >= 0x0700) 1944 1945 /* Bits for dwFlags in ProcessVertices call */ 1946 #define D3DPV_DONOTCOPYDATA (1 << 0) 1947 1948 #endif /* DIRECT3D_VERSION >= 0x0700 */ 1949 1950 #endif //(DIRECT3D_VERSION < 0x0800) 1951 1952 //------------------------------------------------------------------- 1953 1954 #if(DIRECT3D_VERSION < 0x0800) 1955 1956 // Flexible vertex format bits 1957 // 1958 #define D3DFVF_RESERVED0 0x001 1959 #define D3DFVF_POSITION_MASK 0x00E 1960 #define D3DFVF_XYZ 0x002 1961 #define D3DFVF_XYZRHW 0x004 1962 #if(DIRECT3D_VERSION >= 0x0700) 1963 #define D3DFVF_XYZB1 0x006 1964 #define D3DFVF_XYZB2 0x008 1965 #define D3DFVF_XYZB3 0x00a 1966 #define D3DFVF_XYZB4 0x00c 1967 #define D3DFVF_XYZB5 0x00e 1968 1969 #endif /* DIRECT3D_VERSION >= 0x0700 */ 1970 #define D3DFVF_NORMAL 0x010 1971 #define D3DFVF_RESERVED1 0x020 1972 #define D3DFVF_DIFFUSE 0x040 1973 #define D3DFVF_SPECULAR 0x080 1974 1975 #define D3DFVF_TEXCOUNT_MASK 0xf00 1976 #define D3DFVF_TEXCOUNT_SHIFT 8 1977 #define D3DFVF_TEX0 0x000 1978 #define D3DFVF_TEX1 0x100 1979 #define D3DFVF_TEX2 0x200 1980 #define D3DFVF_TEX3 0x300 1981 #define D3DFVF_TEX4 0x400 1982 #define D3DFVF_TEX5 0x500 1983 #define D3DFVF_TEX6 0x600 1984 #define D3DFVF_TEX7 0x700 1985 #define D3DFVF_TEX8 0x800 1986 1987 #define D3DFVF_RESERVED2 0xf000 // 4 reserved bits 1988 1989 #else 1990 #define D3DFVF_RESERVED1 0x020 1991 #endif //(DIRECT3D_VERSION < 0x0800) 1992 1993 #define D3DFVF_VERTEX ( D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 ) 1994 #define D3DFVF_LVERTEX ( D3DFVF_XYZ | D3DFVF_RESERVED1 | D3DFVF_DIFFUSE | \ 1995 D3DFVF_SPECULAR | D3DFVF_TEX1 ) 1996 #define D3DFVF_TLVERTEX ( D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | \ 1997 D3DFVF_TEX1 ) 1998 1999 2000 typedef struct _D3DDP_PTRSTRIDE 2001 { 2002 LPVOID lpvData; 2003 DWORD dwStride; 2004 } D3DDP_PTRSTRIDE; 2005 2006 #define D3DDP_MAXTEXCOORD 8 2007 2008 typedef struct _D3DDRAWPRIMITIVESTRIDEDDATA 2009 { 2010 D3DDP_PTRSTRIDE position; 2011 D3DDP_PTRSTRIDE normal; 2012 D3DDP_PTRSTRIDE diffuse; 2013 D3DDP_PTRSTRIDE specular; 2014 D3DDP_PTRSTRIDE textureCoords[D3DDP_MAXTEXCOORD]; 2015 } D3DDRAWPRIMITIVESTRIDEDDATA, *LPD3DDRAWPRIMITIVESTRIDEDDATA; 2016 //--------------------------------------------------------------------- 2017 // ComputeSphereVisibility return values 2018 // 2019 #define D3DVIS_INSIDE_FRUSTUM 0 2020 #define D3DVIS_INTERSECT_FRUSTUM 1 2021 #define D3DVIS_OUTSIDE_FRUSTUM 2 2022 #define D3DVIS_INSIDE_LEFT 0 2023 #define D3DVIS_INTERSECT_LEFT (1 << 2) 2024 #define D3DVIS_OUTSIDE_LEFT (2 << 2) 2025 #define D3DVIS_INSIDE_RIGHT 0 2026 #define D3DVIS_INTERSECT_RIGHT (1 << 4) 2027 #define D3DVIS_OUTSIDE_RIGHT (2 << 4) 2028 #define D3DVIS_INSIDE_TOP 0 2029 #define D3DVIS_INTERSECT_TOP (1 << 6) 2030 #define D3DVIS_OUTSIDE_TOP (2 << 6) 2031 #define D3DVIS_INSIDE_BOTTOM 0 2032 #define D3DVIS_INTERSECT_BOTTOM (1 << 8) 2033 #define D3DVIS_OUTSIDE_BOTTOM (2 << 8) 2034 #define D3DVIS_INSIDE_NEAR 0 2035 #define D3DVIS_INTERSECT_NEAR (1 << 10) 2036 #define D3DVIS_OUTSIDE_NEAR (2 << 10) 2037 #define D3DVIS_INSIDE_FAR 0 2038 #define D3DVIS_INTERSECT_FAR (1 << 12) 2039 #define D3DVIS_OUTSIDE_FAR (2 << 12) 2040 2041 #define D3DVIS_MASK_FRUSTUM (3 << 0) 2042 #define D3DVIS_MASK_LEFT (3 << 2) 2043 #define D3DVIS_MASK_RIGHT (3 << 4) 2044 #define D3DVIS_MASK_TOP (3 << 6) 2045 #define D3DVIS_MASK_BOTTOM (3 << 8) 2046 #define D3DVIS_MASK_NEAR (3 << 10) 2047 #define D3DVIS_MASK_FAR (3 << 12) 2048 2049 #endif /* DIRECT3D_VERSION >= 0x0600 */ 2050 2051 #if(DIRECT3D_VERSION < 0x0800) 2052 2053 #if(DIRECT3D_VERSION >= 0x0700) 2054 2055 // To be used with GetInfo() 2056 #define D3DDEVINFOID_TEXTUREMANAGER 1 2057 #define D3DDEVINFOID_D3DTEXTUREMANAGER 2 2058 #define D3DDEVINFOID_TEXTURING 3 2059 2060 typedef enum _D3DSTATEBLOCKTYPE 2061 { 2062 D3DSBT_ALL = 1, // capture all state 2063 D3DSBT_PIXELSTATE = 2, // capture pixel state 2064 D3DSBT_VERTEXSTATE = 3, // capture vertex state 2065 D3DSBT_FORCE_DWORD = 0xffffffff 2066 } D3DSTATEBLOCKTYPE; 2067 2068 // The D3DVERTEXBLENDFLAGS type is used with D3DRENDERSTATE_VERTEXBLEND state. 2069 // 2070 typedef enum _D3DVERTEXBLENDFLAGS 2071 { 2072 D3DVBLEND_DISABLE = 0, // Disable vertex blending 2073 D3DVBLEND_1WEIGHT = 1, // blend between 2 matrices 2074 D3DVBLEND_2WEIGHTS = 2, // blend between 3 matrices 2075 D3DVBLEND_3WEIGHTS = 3, // blend between 4 matrices 2076 } D3DVERTEXBLENDFLAGS; 2077 2078 typedef enum _D3DTEXTURETRANSFORMFLAGS { 2079 D3DTTFF_DISABLE = 0, // texture coordinates are passed directly 2080 D3DTTFF_COUNT1 = 1, // rasterizer should expect 1-D texture coords 2081 D3DTTFF_COUNT2 = 2, // rasterizer should expect 2-D texture coords 2082 D3DTTFF_COUNT3 = 3, // rasterizer should expect 3-D texture coords 2083 D3DTTFF_COUNT4 = 4, // rasterizer should expect 4-D texture coords 2084 D3DTTFF_PROJECTED = 256, // texcoords to be divided by COUNTth element 2085 D3DTTFF_FORCE_DWORD = 0x7fffffff, 2086 } D3DTEXTURETRANSFORMFLAGS; 2087 2088 // Macros to set texture coordinate format bits in the FVF id 2089 2090 #define D3DFVF_TEXTUREFORMAT2 0 // Two floating point values 2091 #define D3DFVF_TEXTUREFORMAT1 3 // One floating point value 2092 #define D3DFVF_TEXTUREFORMAT3 1 // Three floating point values 2093 #define D3DFVF_TEXTUREFORMAT4 2 // Four floating point values 2094 2095 #define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16)) 2096 #define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2) 2097 #define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16)) 2098 #define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16)) 2099 2100 2101 #endif /* DIRECT3D_VERSION >= 0x0700 */ 2102 2103 #else 2104 // 2105 // legacy vertex blend names 2106 // 2107 typedef enum _D3DVERTEXBLENDFLAGS D3DVERTEXBLENDFLAGS; 2108 #define D3DVBLEND_DISABLE (D3DVERTEXBLENDFLAGS)0 2109 #define D3DVBLEND_1WEIGHT (D3DVERTEXBLENDFLAGS)1 2110 #define D3DVBLEND_2WEIGHTS (D3DVERTEXBLENDFLAGS)2 2111 #define D3DVBLEND_3WEIGHTS (D3DVERTEXBLENDFLAGS)3 2112 2113 #endif //(DIRECT3D_VERSION < 0x0800) 2114 2115 #pragma pack() 2116 #pragma warning(default:4201) 2117 2118 #endif /* _D3DTYPES_H_ */ 2119 2120