1/*==========================================================================; 2 * 3 * Copyright (C) Microsoft Corporation. All Rights Reserved. 4 * 5 * File: d3d8types.h 6 * Content: Direct3D capabilities include file 7 * 8 ***************************************************************************/ 9 10#ifndef _D3D8TYPES_H_ 11#define _D3D8TYPES_H_ 12 13#ifndef DIRECT3D_VERSION 14#define DIRECT3D_VERSION 0x0800 15#endif //DIRECT3D_VERSION 16 17// include this file content only if compiling for DX8 interfaces 18#if(DIRECT3D_VERSION >= 0x0800) 19 20#include <float.h> 21 22#if _MSC_VER >= 1200 23#pragma warning(push) 24#endif 25#pragma warning(disable:4201) // anonymous unions warning 26#if defined(_X86_) || defined(_IA64_) 27#pragma pack(4) 28#endif 29 30// D3DCOLOR is equivalent to D3DFMT_A8R8G8B8 31#ifndef D3DCOLOR_DEFINED 32typedef DWORD D3DCOLOR; 33#define D3DCOLOR_DEFINED 34#endif 35 36// maps unsigned 8 bits/channel to D3DCOLOR 37#define D3DCOLOR_ARGB(a,r,g,b) \ 38 ((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff))) 39#define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b) 40#define D3DCOLOR_XRGB(r,g,b) D3DCOLOR_ARGB(0xff,r,g,b) 41 42// maps floating point channels (0.f to 1.f range) to D3DCOLOR 43#define D3DCOLOR_COLORVALUE(r,g,b,a) \ 44 D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWORD)((a)*255.f)) 45 46 47#ifndef D3DVECTOR_DEFINED 48typedef struct _D3DVECTOR { 49 float x; 50 float y; 51 float z; 52} D3DVECTOR; 53#define D3DVECTOR_DEFINED 54#endif 55 56#ifndef D3DCOLORVALUE_DEFINED 57typedef struct _D3DCOLORVALUE { 58 float r; 59 float g; 60 float b; 61 float a; 62} D3DCOLORVALUE; 63#define D3DCOLORVALUE_DEFINED 64#endif 65 66#ifndef D3DRECT_DEFINED 67typedef struct _D3DRECT { 68 LONG x1; 69 LONG y1; 70 LONG x2; 71 LONG y2; 72} D3DRECT; 73#define D3DRECT_DEFINED 74#endif 75 76#ifndef D3DMATRIX_DEFINED 77typedef struct _D3DMATRIX { 78 union { 79 struct { 80 float _11, _12, _13, _14; 81 float _21, _22, _23, _24; 82 float _31, _32, _33, _34; 83 float _41, _42, _43, _44; 84 85 }; 86 float m[4][4]; 87 }; 88} D3DMATRIX; 89#define D3DMATRIX_DEFINED 90#endif 91 92typedef struct _D3DVIEWPORT8 { 93 DWORD X; 94 DWORD Y; /* Viewport Top left */ 95 DWORD Width; 96 DWORD Height; /* Viewport Dimensions */ 97 float MinZ; /* Min/max of clip Volume */ 98 float MaxZ; 99} D3DVIEWPORT8; 100 101/* 102 * Values for clip fields. 103 */ 104 105// Max number of user clipping planes, supported in D3D. 106#define D3DMAXUSERCLIPPLANES 32 107 108// These bits could be ORed together to use with D3DRS_CLIPPLANEENABLE 109// 110#define D3DCLIPPLANE0 (1 << 0) 111#define D3DCLIPPLANE1 (1 << 1) 112#define D3DCLIPPLANE2 (1 << 2) 113#define D3DCLIPPLANE3 (1 << 3) 114#define D3DCLIPPLANE4 (1 << 4) 115#define D3DCLIPPLANE5 (1 << 5) 116 117// The following bits are used in the ClipUnion and ClipIntersection 118// members of the D3DCLIPSTATUS8 119// 120 121#define D3DCS_LEFT 0x00000001L 122#define D3DCS_RIGHT 0x00000002L 123#define D3DCS_TOP 0x00000004L 124#define D3DCS_BOTTOM 0x00000008L 125#define D3DCS_FRONT 0x00000010L 126#define D3DCS_BACK 0x00000020L 127#define D3DCS_PLANE0 0x00000040L 128#define D3DCS_PLANE1 0x00000080L 129#define D3DCS_PLANE2 0x00000100L 130#define D3DCS_PLANE3 0x00000200L 131#define D3DCS_PLANE4 0x00000400L 132#define D3DCS_PLANE5 0x00000800L 133 134#define D3DCS_ALL (D3DCS_LEFT | \ 135 D3DCS_RIGHT | \ 136 D3DCS_TOP | \ 137 D3DCS_BOTTOM | \ 138 D3DCS_FRONT | \ 139 D3DCS_BACK | \ 140 D3DCS_PLANE0 | \ 141 D3DCS_PLANE1 | \ 142 D3DCS_PLANE2 | \ 143 D3DCS_PLANE3 | \ 144 D3DCS_PLANE4 | \ 145 D3DCS_PLANE5) 146 147typedef struct _D3DCLIPSTATUS8 { 148 DWORD ClipUnion; 149 DWORD ClipIntersection; 150} D3DCLIPSTATUS8; 151 152typedef struct _D3DMATERIAL8 { 153 D3DCOLORVALUE Diffuse; /* Diffuse color RGBA */ 154 D3DCOLORVALUE Ambient; /* Ambient color RGB */ 155 D3DCOLORVALUE Specular; /* Specular 'shininess' */ 156 D3DCOLORVALUE Emissive; /* Emissive color RGB */ 157 float Power; /* Sharpness if specular highlight */ 158} D3DMATERIAL8; 159 160typedef enum _D3DLIGHTTYPE { 161 D3DLIGHT_POINT = 1, 162 D3DLIGHT_SPOT = 2, 163 D3DLIGHT_DIRECTIONAL = 3, 164 D3DLIGHT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 165} D3DLIGHTTYPE; 166 167typedef struct _D3DLIGHT8 { 168 D3DLIGHTTYPE Type; /* Type of light source */ 169 D3DCOLORVALUE Diffuse; /* Diffuse color of light */ 170 D3DCOLORVALUE Specular; /* Specular color of light */ 171 D3DCOLORVALUE Ambient; /* Ambient color of light */ 172 D3DVECTOR Position; /* Position in world space */ 173 D3DVECTOR Direction; /* Direction in world space */ 174 float Range; /* Cutoff range */ 175 float Falloff; /* Falloff */ 176 float Attenuation0; /* Constant attenuation */ 177 float Attenuation1; /* Linear attenuation */ 178 float Attenuation2; /* Quadratic attenuation */ 179 float Theta; /* Inner angle of spotlight cone */ 180 float Phi; /* Outer angle of spotlight cone */ 181} D3DLIGHT8; 182 183/* 184 * Options for clearing 185 */ 186#define D3DCLEAR_TARGET 0x00000001l /* Clear target surface */ 187#define D3DCLEAR_ZBUFFER 0x00000002l /* Clear target z buffer */ 188#define D3DCLEAR_STENCIL 0x00000004l /* Clear stencil planes */ 189 190/* 191 * The following defines the rendering states 192 */ 193 194typedef enum _D3DSHADEMODE { 195 D3DSHADE_FLAT = 1, 196 D3DSHADE_GOURAUD = 2, 197 D3DSHADE_PHONG = 3, 198 D3DSHADE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 199} D3DSHADEMODE; 200 201typedef enum _D3DFILLMODE { 202 D3DFILL_POINT = 1, 203 D3DFILL_WIREFRAME = 2, 204 D3DFILL_SOLID = 3, 205 D3DFILL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 206} D3DFILLMODE; 207 208typedef struct _D3DLINEPATTERN { 209 WORD wRepeatFactor; 210 WORD wLinePattern; 211} D3DLINEPATTERN; 212 213typedef enum _D3DBLEND { 214 D3DBLEND_ZERO = 1, 215 D3DBLEND_ONE = 2, 216 D3DBLEND_SRCCOLOR = 3, 217 D3DBLEND_INVSRCCOLOR = 4, 218 D3DBLEND_SRCALPHA = 5, 219 D3DBLEND_INVSRCALPHA = 6, 220 D3DBLEND_DESTALPHA = 7, 221 D3DBLEND_INVDESTALPHA = 8, 222 D3DBLEND_DESTCOLOR = 9, 223 D3DBLEND_INVDESTCOLOR = 10, 224 D3DBLEND_SRCALPHASAT = 11, 225 D3DBLEND_BOTHSRCALPHA = 12, 226 D3DBLEND_BOTHINVSRCALPHA = 13, 227 D3DBLEND_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 228} D3DBLEND; 229 230typedef enum _D3DBLENDOP { 231 D3DBLENDOP_ADD = 1, 232 D3DBLENDOP_SUBTRACT = 2, 233 D3DBLENDOP_REVSUBTRACT = 3, 234 D3DBLENDOP_MIN = 4, 235 D3DBLENDOP_MAX = 5, 236 D3DBLENDOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 237} D3DBLENDOP; 238 239typedef enum _D3DTEXTUREADDRESS { 240 D3DTADDRESS_WRAP = 1, 241 D3DTADDRESS_MIRROR = 2, 242 D3DTADDRESS_CLAMP = 3, 243 D3DTADDRESS_BORDER = 4, 244 D3DTADDRESS_MIRRORONCE = 5, 245 D3DTADDRESS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 246} D3DTEXTUREADDRESS; 247 248typedef enum _D3DCULL { 249 D3DCULL_NONE = 1, 250 D3DCULL_CW = 2, 251 D3DCULL_CCW = 3, 252 D3DCULL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 253} D3DCULL; 254 255typedef enum _D3DCMPFUNC { 256 D3DCMP_NEVER = 1, 257 D3DCMP_LESS = 2, 258 D3DCMP_EQUAL = 3, 259 D3DCMP_LESSEQUAL = 4, 260 D3DCMP_GREATER = 5, 261 D3DCMP_NOTEQUAL = 6, 262 D3DCMP_GREATEREQUAL = 7, 263 D3DCMP_ALWAYS = 8, 264 D3DCMP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 265} D3DCMPFUNC; 266 267typedef enum _D3DSTENCILOP { 268 D3DSTENCILOP_KEEP = 1, 269 D3DSTENCILOP_ZERO = 2, 270 D3DSTENCILOP_REPLACE = 3, 271 D3DSTENCILOP_INCRSAT = 4, 272 D3DSTENCILOP_DECRSAT = 5, 273 D3DSTENCILOP_INVERT = 6, 274 D3DSTENCILOP_INCR = 7, 275 D3DSTENCILOP_DECR = 8, 276 D3DSTENCILOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 277} D3DSTENCILOP; 278 279typedef enum _D3DFOGMODE { 280 D3DFOG_NONE = 0, 281 D3DFOG_EXP = 1, 282 D3DFOG_EXP2 = 2, 283 D3DFOG_LINEAR = 3, 284 D3DFOG_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 285} D3DFOGMODE; 286 287typedef enum _D3DZBUFFERTYPE { 288 D3DZB_FALSE = 0, 289 D3DZB_TRUE = 1, // Z buffering 290 D3DZB_USEW = 2, // W buffering 291 D3DZB_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 292} D3DZBUFFERTYPE; 293 294// Primitives supported by draw-primitive API 295typedef enum _D3DPRIMITIVETYPE { 296 D3DPT_POINTLIST = 1, 297 D3DPT_LINELIST = 2, 298 D3DPT_LINESTRIP = 3, 299 D3DPT_TRIANGLELIST = 4, 300 D3DPT_TRIANGLESTRIP = 5, 301 D3DPT_TRIANGLEFAN = 6, 302 D3DPT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 303} D3DPRIMITIVETYPE; 304 305typedef enum _D3DTRANSFORMSTATETYPE { 306 D3DTS_VIEW = 2, 307 D3DTS_PROJECTION = 3, 308 D3DTS_TEXTURE0 = 16, 309 D3DTS_TEXTURE1 = 17, 310 D3DTS_TEXTURE2 = 18, 311 D3DTS_TEXTURE3 = 19, 312 D3DTS_TEXTURE4 = 20, 313 D3DTS_TEXTURE5 = 21, 314 D3DTS_TEXTURE6 = 22, 315 D3DTS_TEXTURE7 = 23, 316 D3DTS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 317} D3DTRANSFORMSTATETYPE; 318 319#define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256) 320#define D3DTS_WORLD D3DTS_WORLDMATRIX(0) 321#define D3DTS_WORLD1 D3DTS_WORLDMATRIX(1) 322#define D3DTS_WORLD2 D3DTS_WORLDMATRIX(2) 323#define D3DTS_WORLD3 D3DTS_WORLDMATRIX(3) 324 325typedef enum _D3DRENDERSTATETYPE { 326 D3DRS_ZENABLE = 7, /* D3DZBUFFERTYPE (or TRUE/FALSE for legacy) */ 327 D3DRS_FILLMODE = 8, /* D3DFILLMODE */ 328 D3DRS_SHADEMODE = 9, /* D3DSHADEMODE */ 329 D3DRS_LINEPATTERN = 10, /* D3DLINEPATTERN */ 330 D3DRS_ZWRITEENABLE = 14, /* TRUE to enable z writes */ 331 D3DRS_ALPHATESTENABLE = 15, /* TRUE to enable alpha tests */ 332 D3DRS_LASTPIXEL = 16, /* TRUE for last-pixel on lines */ 333 D3DRS_SRCBLEND = 19, /* D3DBLEND */ 334 D3DRS_DESTBLEND = 20, /* D3DBLEND */ 335 D3DRS_CULLMODE = 22, /* D3DCULL */ 336 D3DRS_ZFUNC = 23, /* D3DCMPFUNC */ 337 D3DRS_ALPHAREF = 24, /* D3DFIXED */ 338 D3DRS_ALPHAFUNC = 25, /* D3DCMPFUNC */ 339 D3DRS_DITHERENABLE = 26, /* TRUE to enable dithering */ 340 D3DRS_ALPHABLENDENABLE = 27, /* TRUE to enable alpha blending */ 341 D3DRS_FOGENABLE = 28, /* TRUE to enable fog blending */ 342 D3DRS_SPECULARENABLE = 29, /* TRUE to enable specular */ 343 D3DRS_ZVISIBLE = 30, /* TRUE to enable z checking */ 344 D3DRS_FOGCOLOR = 34, /* D3DCOLOR */ 345 D3DRS_FOGTABLEMODE = 35, /* D3DFOGMODE */ 346 D3DRS_FOGSTART = 36, /* Fog start (for both vertex and pixel fog) */ 347 D3DRS_FOGEND = 37, /* Fog end */ 348 D3DRS_FOGDENSITY = 38, /* Fog density */ 349 D3DRS_EDGEANTIALIAS = 40, /* TRUE to enable edge antialiasing */ 350 D3DRS_ZBIAS = 47, /* LONG Z bias */ 351 D3DRS_RANGEFOGENABLE = 48, /* Enables range-based fog */ 352 D3DRS_STENCILENABLE = 52, /* BOOL enable/disable stenciling */ 353 D3DRS_STENCILFAIL = 53, /* D3DSTENCILOP to do if stencil test fails */ 354 D3DRS_STENCILZFAIL = 54, /* D3DSTENCILOP to do if stencil test passes and Z test fails */ 355 D3DRS_STENCILPASS = 55, /* D3DSTENCILOP to do if both stencil and Z tests pass */ 356 D3DRS_STENCILFUNC = 56, /* D3DCMPFUNC fn. Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */ 357 D3DRS_STENCILREF = 57, /* Reference value used in stencil test */ 358 D3DRS_STENCILMASK = 58, /* Mask value used in stencil test */ 359 D3DRS_STENCILWRITEMASK = 59, /* Write mask applied to values written to stencil buffer */ 360 D3DRS_TEXTUREFACTOR = 60, /* D3DCOLOR used for multi-texture blend */ 361 D3DRS_WRAP0 = 128, /* wrap for 1st texture coord. set */ 362 D3DRS_WRAP1 = 129, /* wrap for 2nd texture coord. set */ 363 D3DRS_WRAP2 = 130, /* wrap for 3rd texture coord. set */ 364 D3DRS_WRAP3 = 131, /* wrap for 4th texture coord. set */ 365 D3DRS_WRAP4 = 132, /* wrap for 5th texture coord. set */ 366 D3DRS_WRAP5 = 133, /* wrap for 6th texture coord. set */ 367 D3DRS_WRAP6 = 134, /* wrap for 7th texture coord. set */ 368 D3DRS_WRAP7 = 135, /* wrap for 8th texture coord. set */ 369 D3DRS_CLIPPING = 136, 370 D3DRS_LIGHTING = 137, 371 D3DRS_AMBIENT = 139, 372 D3DRS_FOGVERTEXMODE = 140, 373 D3DRS_COLORVERTEX = 141, 374 D3DRS_LOCALVIEWER = 142, 375 D3DRS_NORMALIZENORMALS = 143, 376 D3DRS_DIFFUSEMATERIALSOURCE = 145, 377 D3DRS_SPECULARMATERIALSOURCE = 146, 378 D3DRS_AMBIENTMATERIALSOURCE = 147, 379 D3DRS_EMISSIVEMATERIALSOURCE = 148, 380 D3DRS_VERTEXBLEND = 151, 381 D3DRS_CLIPPLANEENABLE = 152, 382 D3DRS_SOFTWAREVERTEXPROCESSING = 153, 383 D3DRS_POINTSIZE = 154, /* float point size */ 384 D3DRS_POINTSIZE_MIN = 155, /* float point size min threshold */ 385 D3DRS_POINTSPRITEENABLE = 156, /* BOOL point texture coord control */ 386 D3DRS_POINTSCALEENABLE = 157, /* BOOL point size scale enable */ 387 D3DRS_POINTSCALE_A = 158, /* float point attenuation A value */ 388 D3DRS_POINTSCALE_B = 159, /* float point attenuation B value */ 389 D3DRS_POINTSCALE_C = 160, /* float point attenuation C value */ 390 D3DRS_MULTISAMPLEANTIALIAS = 161, // BOOL - set to do FSAA with multisample buffer 391 D3DRS_MULTISAMPLEMASK = 162, // DWORD - per-sample enable/disable 392 D3DRS_PATCHEDGESTYLE = 163, // Sets whether patch edges will use float style tessellation 393 D3DRS_PATCHSEGMENTS = 164, // Number of segments per edge when drawing patches 394 D3DRS_DEBUGMONITORTOKEN = 165, // DEBUG ONLY - token to debug monitor 395 D3DRS_POINTSIZE_MAX = 166, /* float point size max threshold */ 396 D3DRS_INDEXEDVERTEXBLENDENABLE = 167, 397 D3DRS_COLORWRITEENABLE = 168, // per-channel write enable 398 D3DRS_TWEENFACTOR = 170, // float tween factor 399 D3DRS_BLENDOP = 171, // D3DBLENDOP setting 400 D3DRS_POSITIONORDER = 172, // NPatch position interpolation order. D3DORDER_LINEAR or D3DORDER_CUBIC (default) 401 D3DRS_NORMALORDER = 173, // NPatch normal interpolation order. D3DORDER_LINEAR (default) or D3DORDER_QUADRATIC 402 403 D3DRS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 404} D3DRENDERSTATETYPE; 405 406// Values for material source 407typedef enum _D3DMATERIALCOLORSOURCE 408{ 409 D3DMCS_MATERIAL = 0, // Color from material is used 410 D3DMCS_COLOR1 = 1, // Diffuse vertex color is used 411 D3DMCS_COLOR2 = 2, // Specular vertex color is used 412 D3DMCS_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 413} D3DMATERIALCOLORSOURCE; 414 415// Bias to apply to the texture coordinate set to apply a wrap to. 416#define D3DRENDERSTATE_WRAPBIAS 128UL 417 418/* Flags to construct the WRAP render states */ 419#define D3DWRAP_U 0x00000001L 420#define D3DWRAP_V 0x00000002L 421#define D3DWRAP_W 0x00000004L 422 423/* Flags to construct the WRAP render states for 1D thru 4D texture coordinates */ 424#define D3DWRAPCOORD_0 0x00000001L // same as D3DWRAP_U 425#define D3DWRAPCOORD_1 0x00000002L // same as D3DWRAP_V 426#define D3DWRAPCOORD_2 0x00000004L // same as D3DWRAP_W 427#define D3DWRAPCOORD_3 0x00000008L 428 429/* Flags to construct D3DRS_COLORWRITEENABLE */ 430#define D3DCOLORWRITEENABLE_RED (1L<<0) 431#define D3DCOLORWRITEENABLE_GREEN (1L<<1) 432#define D3DCOLORWRITEENABLE_BLUE (1L<<2) 433#define D3DCOLORWRITEENABLE_ALPHA (1L<<3) 434 435/* 436 * State enumerants for per-stage texture processing. 437 */ 438typedef enum _D3DTEXTURESTAGESTATETYPE 439{ 440 D3DTSS_COLOROP = 1, /* D3DTEXTUREOP - per-stage blending controls for color channels */ 441 D3DTSS_COLORARG1 = 2, /* D3DTA_* (texture arg) */ 442 D3DTSS_COLORARG2 = 3, /* D3DTA_* (texture arg) */ 443 D3DTSS_ALPHAOP = 4, /* D3DTEXTUREOP - per-stage blending controls for alpha channel */ 444 D3DTSS_ALPHAARG1 = 5, /* D3DTA_* (texture arg) */ 445 D3DTSS_ALPHAARG2 = 6, /* D3DTA_* (texture arg) */ 446 D3DTSS_BUMPENVMAT00 = 7, /* float (bump mapping matrix) */ 447 D3DTSS_BUMPENVMAT01 = 8, /* float (bump mapping matrix) */ 448 D3DTSS_BUMPENVMAT10 = 9, /* float (bump mapping matrix) */ 449 D3DTSS_BUMPENVMAT11 = 10, /* float (bump mapping matrix) */ 450 D3DTSS_TEXCOORDINDEX = 11, /* identifies which set of texture coordinates index this texture */ 451 D3DTSS_ADDRESSU = 13, /* D3DTEXTUREADDRESS for U coordinate */ 452 D3DTSS_ADDRESSV = 14, /* D3DTEXTUREADDRESS for V coordinate */ 453 D3DTSS_BORDERCOLOR = 15, /* D3DCOLOR */ 454 D3DTSS_MAGFILTER = 16, /* D3DTEXTUREFILTER filter to use for magnification */ 455 D3DTSS_MINFILTER = 17, /* D3DTEXTUREFILTER filter to use for minification */ 456 D3DTSS_MIPFILTER = 18, /* D3DTEXTUREFILTER filter to use between mipmaps during minification */ 457 D3DTSS_MIPMAPLODBIAS = 19, /* float Mipmap LOD bias */ 458 D3DTSS_MAXMIPLEVEL = 20, /* DWORD 0..(n-1) LOD index of largest map to use (0 == largest) */ 459 D3DTSS_MAXANISOTROPY = 21, /* DWORD maximum anisotropy */ 460 D3DTSS_BUMPENVLSCALE = 22, /* float scale for bump map luminance */ 461 D3DTSS_BUMPENVLOFFSET = 23, /* float offset for bump map luminance */ 462 D3DTSS_TEXTURETRANSFORMFLAGS = 24, /* D3DTEXTURETRANSFORMFLAGS controls texture transform */ 463 D3DTSS_ADDRESSW = 25, /* D3DTEXTUREADDRESS for W coordinate */ 464 D3DTSS_COLORARG0 = 26, /* D3DTA_* third arg for triadic ops */ 465 D3DTSS_ALPHAARG0 = 27, /* D3DTA_* third arg for triadic ops */ 466 D3DTSS_RESULTARG = 28, /* D3DTA_* arg for result (CURRENT or TEMP) */ 467 D3DTSS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ 468} D3DTEXTURESTAGESTATETYPE; 469 470// Values, used with D3DTSS_TEXCOORDINDEX, to specify that the vertex data(position 471// and normal in the camera space) should be taken as texture coordinates 472// Low 16 bits are used to specify texture coordinate index, to take the WRAP mode from 473// 474#define D3DTSS_TCI_PASSTHRU 0x00000000 475#define D3DTSS_TCI_CAMERASPACENORMAL 0x00010000 476#define D3DTSS_TCI_CAMERASPACEPOSITION 0x00020000 477#define D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR 0x00030000 478 479/* 480 * Enumerations for COLOROP and ALPHAOP texture blending operations set in 481 * texture processing stage controls in D3DTSS. 482 */ 483typedef enum _D3DTEXTUREOP 484{ 485 // Control 486 D3DTOP_DISABLE = 1, // disables stage 487 D3DTOP_SELECTARG1 = 2, // the default 488 D3DTOP_SELECTARG2 = 3, 489 490 // Modulate 491 D3DTOP_MODULATE = 4, // multiply args together 492 D3DTOP_MODULATE2X = 5, // multiply and 1 bit 493 D3DTOP_MODULATE4X = 6, // multiply and 2 bits 494 495 // Add 496 D3DTOP_ADD = 7, // add arguments together 497 D3DTOP_ADDSIGNED = 8, // add with -0.5 bias 498 D3DTOP_ADDSIGNED2X = 9, // as above but left 1 bit 499 D3DTOP_SUBTRACT = 10, // Arg1 - Arg2, with no saturation 500 D3DTOP_ADDSMOOTH = 11, // add 2 args, subtract product 501 // Arg1 + Arg2 - Arg1*Arg2 502 // = Arg1 + (1-Arg1)*Arg2 503 504 // Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha) 505 D3DTOP_BLENDDIFFUSEALPHA = 12, // iterated alpha 506 D3DTOP_BLENDTEXTUREALPHA = 13, // texture alpha 507 D3DTOP_BLENDFACTORALPHA = 14, // alpha from D3DRS_TEXTUREFACTOR 508 509 // Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha) 510 D3DTOP_BLENDTEXTUREALPHAPM = 15, // texture alpha 511 D3DTOP_BLENDCURRENTALPHA = 16, // by alpha of current color 512 513 // Specular mapping 514 D3DTOP_PREMODULATE = 17, // modulate with next texture before use 515 D3DTOP_MODULATEALPHA_ADDCOLOR = 18, // Arg1.RGB + Arg1.A*Arg2.RGB 516 // COLOROP only 517 D3DTOP_MODULATECOLOR_ADDALPHA = 19, // Arg1.RGB*Arg2.RGB + Arg1.A 518 // COLOROP only 519 D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, // (1-Arg1.A)*Arg2.RGB + Arg1.RGB 520 // COLOROP only 521 D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, // (1-Arg1.RGB)*Arg2.RGB + Arg1.A 522 // COLOROP only 523 524 // Bump mapping 525 D3DTOP_BUMPENVMAP = 22, // per pixel env map perturbation 526 D3DTOP_BUMPENVMAPLUMINANCE = 23, // with luminance channel 527 528 // This can do either diffuse or specular bump mapping with correct input. 529 // Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G + Arg1.B*Arg2.B) 530 // where each component has been scaled and offset to make it signed. 531 // The result is replicated into all four (including alpha) channels. 532 // This is a valid COLOROP only. 533 D3DTOP_DOTPRODUCT3 = 24, 534 535 // Triadic ops 536 D3DTOP_MULTIPLYADD = 25, // Arg0 + Arg1*Arg2 537 D3DTOP_LERP = 26, // (Arg0)*Arg1 + (1-Arg0)*Arg2 538 539 D3DTOP_FORCE_DWORD = 0x7fffffff, 540} D3DTEXTUREOP; 541 542/* 543 * Values for COLORARG0,1,2, ALPHAARG0,1,2, and RESULTARG texture blending 544 * operations set in texture processing stage controls in D3DRENDERSTATE. 545 */ 546#define D3DTA_SELECTMASK 0x0000000f // mask for arg selector 547#define D3DTA_DIFFUSE 0x00000000 // select diffuse color (read only) 548#define D3DTA_CURRENT 0x00000001 // select stage destination register (read/write) 549#define D3DTA_TEXTURE 0x00000002 // select texture color (read only) 550#define D3DTA_TFACTOR 0x00000003 // select D3DRS_TEXTUREFACTOR (read only) 551#define D3DTA_SPECULAR 0x00000004 // select specular color (read only) 552#define D3DTA_TEMP 0x00000005 // select temporary register color (read/write) 553#define D3DTA_COMPLEMENT 0x00000010 // take 1.0 - x (read modifier) 554#define D3DTA_ALPHAREPLICATE 0x00000020 // replicate alpha to color components (read modifier) 555 556// 557// Values for D3DTSS_***FILTER texture stage states 558// 559typedef enum _D3DTEXTUREFILTERTYPE 560{ 561 D3DTEXF_NONE = 0, // filtering disabled (valid for mip filter only) 562 D3DTEXF_POINT = 1, // nearest 563 D3DTEXF_LINEAR = 2, // linear interpolation 564 D3DTEXF_ANISOTROPIC = 3, // anisotropic 565 D3DTEXF_FLATCUBIC = 4, // cubic 566 D3DTEXF_GAUSSIANCUBIC = 5, // different cubic kernel 567 D3DTEXF_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 568} D3DTEXTUREFILTERTYPE; 569 570/* Bits for Flags in ProcessVertices call */ 571 572#define D3DPV_DONOTCOPYDATA (1 << 0) 573 574//------------------------------------------------------------------- 575 576// Flexible vertex format bits 577// 578#define D3DFVF_RESERVED0 0x001 579#define D3DFVF_POSITION_MASK 0x00E 580#define D3DFVF_XYZ 0x002 581#define D3DFVF_XYZRHW 0x004 582#define D3DFVF_XYZB1 0x006 583#define D3DFVF_XYZB2 0x008 584#define D3DFVF_XYZB3 0x00a 585#define D3DFVF_XYZB4 0x00c 586#define D3DFVF_XYZB5 0x00e 587 588#define D3DFVF_NORMAL 0x010 589#define D3DFVF_PSIZE 0x020 590#define D3DFVF_DIFFUSE 0x040 591#define D3DFVF_SPECULAR 0x080 592 593#define D3DFVF_TEXCOUNT_MASK 0xf00 594#define D3DFVF_TEXCOUNT_SHIFT 8 595#define D3DFVF_TEX0 0x000 596#define D3DFVF_TEX1 0x100 597#define D3DFVF_TEX2 0x200 598#define D3DFVF_TEX3 0x300 599#define D3DFVF_TEX4 0x400 600#define D3DFVF_TEX5 0x500 601#define D3DFVF_TEX6 0x600 602#define D3DFVF_TEX7 0x700 603#define D3DFVF_TEX8 0x800 604 605#define D3DFVF_LASTBETA_UBYTE4 0x1000 606 607#define D3DFVF_RESERVED2 0xE000 // 4 reserved bits 608 609//--------------------------------------------------------------------- 610// Vertex Shaders 611// 612 613/* 614 615Vertex Shader Declaration 616 617The declaration portion of a vertex shader defines the static external 618interface of the shader. The information in the declaration includes: 619 620- Assignments of vertex shader input registers to data streams. These 621assignments bind a specific vertex register to a single component within a 622vertex stream. A vertex stream element is identified by a byte offset 623within the stream and a type. The type specifies the arithmetic data type 624plus the dimensionality (1, 2, 3, or 4 values). Stream data which is 625less than 4 values are always expanded out to 4 values with zero or more 6260.F values and one 1.F value. 627 628- Assignment of vertex shader input registers to implicit data from the 629primitive tessellator. This controls the loading of vertex data which is 630not loaded from a stream, but rather is generated during primitive 631tessellation prior to the vertex shader. 632 633- Loading data into the constant memory at the time a shader is set as the 634current shader. Each token specifies values for one or more contiguous 4 635DWORD constant registers. This allows the shader to update an arbitrary 636subset of the constant memory, overwriting the device state (which 637contains the current values of the constant memory). Note that these 638values can be subsequently overwritten (between DrawPrimitive calls) 639during the time a shader is bound to a device via the 640SetVertexShaderConstant method. 641 642 643Declaration arrays are single-dimensional arrays of DWORDs composed of 644multiple tokens each of which is one or more DWORDs. The single-DWORD 645token value 0xFFFFFFFF is a special token used to indicate the end of the 646declaration array. The single DWORD token value 0x00000000 is a NOP token 647with is ignored during the declaration parsing. Note that 0x00000000 is a 648valid value for DWORDs following the first DWORD for multiple word tokens. 649 650[31:29] TokenType 651 0x0 - NOP (requires all DWORD bits to be zero) 652 0x1 - stream selector 653 0x2 - stream data definition (map to vertex input memory) 654 0x3 - vertex input memory from tessellator 655 0x4 - constant memory from shader 656 0x5 - extension 657 0x6 - reserved 658 0x7 - end-of-array (requires all DWORD bits to be 1) 659 660NOP Token (single DWORD token) 661 [31:29] 0x0 662 [28:00] 0x0 663 664Stream Selector (single DWORD token) 665 [31:29] 0x1 666 [28] indicates whether this is a tessellator stream 667 [27:04] 0x0 668 [03:00] stream selector (0..15) 669 670Stream Data Definition (single DWORD token) 671 Vertex Input Register Load 672 [31:29] 0x2 673 [28] 0x0 674 [27:20] 0x0 675 [19:16] type (dimensionality and data type) 676 [15:04] 0x0 677 [03:00] vertex register address (0..15) 678 Data Skip (no register load) 679 [31:29] 0x2 680 [28] 0x1 681 [27:20] 0x0 682 [19:16] count of DWORDS to skip over (0..15) 683 [15:00] 0x0 684 Vertex Input Memory from Tessellator Data (single DWORD token) 685 [31:29] 0x3 686 [28] indicates whether data is normals or u/v 687 [27:24] 0x0 688 [23:20] vertex register address (0..15) 689 [19:16] type (dimensionality) 690 [15:04] 0x0 691 [03:00] vertex register address (0..15) 692 693Constant Memory from Shader (multiple DWORD token) 694 [31:29] 0x4 695 [28:25] count of 4*DWORD constants to load (0..15) 696 [24:07] 0x0 697 [06:00] constant memory address (0..95) 698 699Extension Token (single or multiple DWORD token) 700 [31:29] 0x5 701 [28:24] count of additional DWORDs in token (0..31) 702 [23:00] extension-specific information 703 704End-of-array token (single DWORD token) 705 [31:29] 0x7 706 [28:00] 0x1fffffff 707 708The stream selector token must be immediately followed by a contiguous set of stream data definition tokens. This token sequence fully defines that stream, including the set of elements within the stream, the order in which the elements appear, the type of each element, and the vertex register into which to load an element. 709Streams are allowed to include data which is not loaded into a vertex register, thus allowing data which is not used for this shader to exist in the vertex stream. This skipped data is defined only by a count of DWORDs to skip over, since the type information is irrelevant. 710The token sequence: 711Stream Select: stream=0 712Stream Data Definition (Load): type=FLOAT3; register=3 713Stream Data Definition (Load): type=FLOAT3; register=4 714Stream Data Definition (Skip): count=2 715Stream Data Definition (Load): type=FLOAT2; register=7 716 717defines stream zero to consist of 4 elements, 3 of which are loaded into registers and the fourth skipped over. Register 3 is loaded with the first three DWORDs in each vertex interpreted as FLOAT data. Register 4 is loaded with the 4th, 5th, and 6th DWORDs interpreted as FLOAT data. The next two DWORDs (7th and 8th) are skipped over and not loaded into any vertex input register. Register 7 is loaded with the 9th and 10th DWORDS interpreted as FLOAT data. 718Placing of tokens other than NOPs between the Stream Selector and Stream Data Definition tokens is disallowed. 719 720*/ 721 722typedef enum _D3DVSD_TOKENTYPE 723{ 724 D3DVSD_TOKEN_NOP = 0, // NOP or extension 725 D3DVSD_TOKEN_STREAM, // stream selector 726 D3DVSD_TOKEN_STREAMDATA, // stream data definition (map to vertex input memory) 727 D3DVSD_TOKEN_TESSELLATOR, // vertex input memory from tessellator 728 D3DVSD_TOKEN_CONSTMEM, // constant memory from shader 729 D3DVSD_TOKEN_EXT, // extension 730 D3DVSD_TOKEN_END = 7, // end-of-array (requires all DWORD bits to be 1) 731 D3DVSD_FORCE_DWORD = 0x7fffffff,// force 32-bit size enum 732} D3DVSD_TOKENTYPE; 733 734#define D3DVSD_TOKENTYPESHIFT 29 735#define D3DVSD_TOKENTYPEMASK (7 << D3DVSD_TOKENTYPESHIFT) 736 737#define D3DVSD_STREAMNUMBERSHIFT 0 738#define D3DVSD_STREAMNUMBERMASK (0xF << D3DVSD_STREAMNUMBERSHIFT) 739 740#define D3DVSD_DATALOADTYPESHIFT 28 741#define D3DVSD_DATALOADTYPEMASK (0x1 << D3DVSD_DATALOADTYPESHIFT) 742 743#define D3DVSD_DATATYPESHIFT 16 744#define D3DVSD_DATATYPEMASK (0xF << D3DVSD_DATATYPESHIFT) 745 746#define D3DVSD_SKIPCOUNTSHIFT 16 747#define D3DVSD_SKIPCOUNTMASK (0xF << D3DVSD_SKIPCOUNTSHIFT) 748 749#define D3DVSD_VERTEXREGSHIFT 0 750#define D3DVSD_VERTEXREGMASK (0x1F << D3DVSD_VERTEXREGSHIFT) 751 752#define D3DVSD_VERTEXREGINSHIFT 20 753#define D3DVSD_VERTEXREGINMASK (0xF << D3DVSD_VERTEXREGINSHIFT) 754 755#define D3DVSD_CONSTCOUNTSHIFT 25 756#define D3DVSD_CONSTCOUNTMASK (0xF << D3DVSD_CONSTCOUNTSHIFT) 757 758#define D3DVSD_CONSTADDRESSSHIFT 0 759#define D3DVSD_CONSTADDRESSMASK (0x7F << D3DVSD_CONSTADDRESSSHIFT) 760 761#define D3DVSD_CONSTRSSHIFT 16 762#define D3DVSD_CONSTRSMASK (0x1FFF << D3DVSD_CONSTRSSHIFT) 763 764#define D3DVSD_EXTCOUNTSHIFT 24 765#define D3DVSD_EXTCOUNTMASK (0x1F << D3DVSD_EXTCOUNTSHIFT) 766 767#define D3DVSD_EXTINFOSHIFT 0 768#define D3DVSD_EXTINFOMASK (0xFFFFFF << D3DVSD_EXTINFOSHIFT) 769 770#define D3DVSD_MAKETOKENTYPE(tokenType) ((tokenType << D3DVSD_TOKENTYPESHIFT) & D3DVSD_TOKENTYPEMASK) 771 772// macros for generation of CreateVertexShader Declaration token array 773 774// Set current stream 775// _StreamNumber [0..(MaxStreams-1)] stream to get data from 776// 777#define D3DVSD_STREAM( _StreamNumber ) \ 778 (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAM) | (_StreamNumber)) 779 780// Set tessellator stream 781// 782#define D3DVSD_STREAMTESSSHIFT 28 783#define D3DVSD_STREAMTESSMASK (1 << D3DVSD_STREAMTESSSHIFT) 784#define D3DVSD_STREAM_TESS( ) \ 785 (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAM) | (D3DVSD_STREAMTESSMASK)) 786 787// bind single vertex register to vertex element from vertex stream 788// 789// _VertexRegister [0..15] address of the vertex register 790// _Type [D3DVSDT_*] dimensionality and arithmetic data type 791 792#define D3DVSD_REG( _VertexRegister, _Type ) \ 793 (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAMDATA) | \ 794 ((_Type) << D3DVSD_DATATYPESHIFT) | (_VertexRegister)) 795 796// Skip _DWORDCount DWORDs in vertex 797// 798#define D3DVSD_SKIP( _DWORDCount ) \ 799 (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAMDATA) | 0x10000000 | \ 800 ((_DWORDCount) << D3DVSD_SKIPCOUNTSHIFT)) 801 802// load data into vertex shader constant memory 803// 804// _ConstantAddress [0..95] - address of constant array to begin filling data 805// _Count [0..15] - number of constant vectors to load (4 DWORDs each) 806// followed by 4*_Count DWORDS of data 807// 808#define D3DVSD_CONST( _ConstantAddress, _Count ) \ 809 (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_CONSTMEM) | \ 810 ((_Count) << D3DVSD_CONSTCOUNTSHIFT) | (_ConstantAddress)) 811 812// enable tessellator generated normals 813// 814// _VertexRegisterIn [0..15] address of vertex register whose input stream 815// will be used in normal computation 816// _VertexRegisterOut [0..15] address of vertex register to output the normal to 817// 818#define D3DVSD_TESSNORMAL( _VertexRegisterIn, _VertexRegisterOut ) \ 819 (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_TESSELLATOR) | \ 820 ((_VertexRegisterIn) << D3DVSD_VERTEXREGINSHIFT) | \ 821 ((0x02) << D3DVSD_DATATYPESHIFT) | (_VertexRegisterOut)) 822 823// enable tessellator generated surface parameters 824// 825// _VertexRegister [0..15] address of vertex register to output parameters 826// 827#define D3DVSD_TESSUV( _VertexRegister ) \ 828 (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_TESSELLATOR) | 0x10000000 | \ 829 ((0x01) << D3DVSD_DATATYPESHIFT) | (_VertexRegister)) 830 831// Generates END token 832// 833#define D3DVSD_END() 0xFFFFFFFF 834 835// Generates NOP token 836#define D3DVSD_NOP() 0x00000000 837 838// bit declarations for _Type fields 839#define D3DVSDT_FLOAT1 0x00 // 1D float expanded to (value, 0., 0., 1.) 840#define D3DVSDT_FLOAT2 0x01 // 2D float expanded to (value, value, 0., 1.) 841#define D3DVSDT_FLOAT3 0x02 // 3D float expanded to (value, value, value, 1.) 842#define D3DVSDT_FLOAT4 0x03 // 4D float 843#define D3DVSDT_D3DCOLOR 0x04 // 4D packed unsigned bytes mapped to 0. to 1. range 844 // Input is in D3DCOLOR format (ARGB) expanded to (R, G, B, A) 845#define D3DVSDT_UBYTE4 0x05 // 4D unsigned byte 846#define D3DVSDT_SHORT2 0x06 // 2D signed short expanded to (value, value, 0., 1.) 847#define D3DVSDT_SHORT4 0x07 // 4D signed short 848 849// assignments of vertex input registers for fixed function vertex shader 850// 851#define D3DVSDE_POSITION 0 852#define D3DVSDE_BLENDWEIGHT 1 853#define D3DVSDE_BLENDINDICES 2 854#define D3DVSDE_NORMAL 3 855#define D3DVSDE_PSIZE 4 856#define D3DVSDE_DIFFUSE 5 857#define D3DVSDE_SPECULAR 6 858#define D3DVSDE_TEXCOORD0 7 859#define D3DVSDE_TEXCOORD1 8 860#define D3DVSDE_TEXCOORD2 9 861#define D3DVSDE_TEXCOORD3 10 862#define D3DVSDE_TEXCOORD4 11 863#define D3DVSDE_TEXCOORD5 12 864#define D3DVSDE_TEXCOORD6 13 865#define D3DVSDE_TEXCOORD7 14 866#define D3DVSDE_POSITION2 15 867#define D3DVSDE_NORMAL2 16 868 869// Maximum supported number of texture coordinate sets 870#define D3DDP_MAXTEXCOORD 8 871 872 873// 874// Instruction Token Bit Definitions 875// 876#define D3DSI_OPCODE_MASK 0x0000FFFF 877 878typedef enum _D3DSHADER_INSTRUCTION_OPCODE_TYPE 879{ 880 D3DSIO_NOP = 0, // PS/VS 881 D3DSIO_MOV , // PS/VS 882 D3DSIO_ADD , // PS/VS 883 D3DSIO_SUB , // PS 884 D3DSIO_MAD , // PS/VS 885 D3DSIO_MUL , // PS/VS 886 D3DSIO_RCP , // VS 887 D3DSIO_RSQ , // VS 888 D3DSIO_DP3 , // PS/VS 889 D3DSIO_DP4 , // PS/VS 890 D3DSIO_MIN , // VS 891 D3DSIO_MAX , // VS 892 D3DSIO_SLT , // VS 893 D3DSIO_SGE , // VS 894 D3DSIO_EXP , // VS 895 D3DSIO_LOG , // VS 896 D3DSIO_LIT , // VS 897 D3DSIO_DST , // VS 898 D3DSIO_LRP , // PS 899 D3DSIO_FRC , // VS 900 D3DSIO_M4x4 , // VS 901 D3DSIO_M4x3 , // VS 902 D3DSIO_M3x4 , // VS 903 D3DSIO_M3x3 , // VS 904 D3DSIO_M3x2 , // VS 905 906 D3DSIO_TEXCOORD = 64, // PS 907 D3DSIO_TEXKILL , // PS 908 D3DSIO_TEX , // PS 909 D3DSIO_TEXBEM , // PS 910 D3DSIO_TEXBEML , // PS 911 D3DSIO_TEXREG2AR , // PS 912 D3DSIO_TEXREG2GB , // PS 913 D3DSIO_TEXM3x2PAD , // PS 914 D3DSIO_TEXM3x2TEX , // PS 915 D3DSIO_TEXM3x3PAD , // PS 916 D3DSIO_TEXM3x3TEX , // PS 917 D3DSIO_TEXM3x3DIFF , // PS 918 D3DSIO_TEXM3x3SPEC , // PS 919 D3DSIO_TEXM3x3VSPEC , // PS 920 D3DSIO_EXPP , // VS 921 D3DSIO_LOGP , // VS 922 D3DSIO_CND , // PS 923 D3DSIO_DEF , // PS 924 D3DSIO_TEXREG2RGB , // PS 925 D3DSIO_TEXDP3TEX , // PS 926 D3DSIO_TEXM3x2DEPTH , // PS 927 D3DSIO_TEXDP3 , // PS 928 D3DSIO_TEXM3x3 , // PS 929 D3DSIO_TEXDEPTH , // PS 930 D3DSIO_CMP , // PS 931 D3DSIO_BEM , // PS 932 933 D3DSIO_PHASE = 0xFFFD, 934 D3DSIO_COMMENT = 0xFFFE, 935 D3DSIO_END = 0xFFFF, 936 937 D3DSIO_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 938} D3DSHADER_INSTRUCTION_OPCODE_TYPE; 939 940// 941// Co-Issue Instruction Modifier - if set then this instruction is to be 942// issued in parallel with the previous instruction(s) for which this bit 943// is not set. 944// 945#define D3DSI_COISSUE 0x40000000 946 947// 948// Parameter Token Bit Definitions 949// 950#define D3DSP_REGNUM_MASK 0x00001FFF 951 952// destination parameter write mask 953#define D3DSP_WRITEMASK_0 0x00010000 // Component 0 (X;Red) 954#define D3DSP_WRITEMASK_1 0x00020000 // Component 1 (Y;Green) 955#define D3DSP_WRITEMASK_2 0x00040000 // Component 2 (Z;Blue) 956#define D3DSP_WRITEMASK_3 0x00080000 // Component 3 (W;Alpha) 957#define D3DSP_WRITEMASK_ALL 0x000F0000 // All Components 958 959// destination parameter modifiers 960#define D3DSP_DSTMOD_SHIFT 20 961#define D3DSP_DSTMOD_MASK 0x00F00000 962 963typedef enum _D3DSHADER_PARAM_DSTMOD_TYPE 964{ 965 D3DSPDM_NONE = 0<<D3DSP_DSTMOD_SHIFT, // nop 966 D3DSPDM_SATURATE= 1<<D3DSP_DSTMOD_SHIFT, // clamp to 0. to 1. range 967 D3DSPDM_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 968} D3DSHADER_PARAM_DSTMOD_TYPE; 969 970// destination parameter 971#define D3DSP_DSTSHIFT_SHIFT 24 972#define D3DSP_DSTSHIFT_MASK 0x0F000000 973 974// destination/source parameter register type 975#define D3DSP_REGTYPE_SHIFT 28 976#define D3DSP_REGTYPE_MASK 0x70000000 977 978typedef enum _D3DSHADER_PARAM_REGISTER_TYPE 979{ 980 D3DSPR_TEMP = 0<<D3DSP_REGTYPE_SHIFT, // Temporary Register File 981 D3DSPR_INPUT = 1<<D3DSP_REGTYPE_SHIFT, // Input Register File 982 D3DSPR_CONST = 2<<D3DSP_REGTYPE_SHIFT, // Constant Register File 983 D3DSPR_ADDR = 3<<D3DSP_REGTYPE_SHIFT, // Address Register (VS) 984 D3DSPR_TEXTURE = 3<<D3DSP_REGTYPE_SHIFT, // Texture Register File (PS) 985 D3DSPR_RASTOUT = 4<<D3DSP_REGTYPE_SHIFT, // Rasterizer Register File 986 D3DSPR_ATTROUT = 5<<D3DSP_REGTYPE_SHIFT, // Attribute Output Register File 987 D3DSPR_TEXCRDOUT= 6<<D3DSP_REGTYPE_SHIFT, // Texture Coordinate Output Register File 988 D3DSPR_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 989} D3DSHADER_PARAM_REGISTER_TYPE; 990 991// Register offsets in the Rasterizer Register File 992// 993typedef enum _D3DVS_RASTOUT_OFFSETS 994{ 995 D3DSRO_POSITION = 0, 996 D3DSRO_FOG, 997 D3DSRO_POINT_SIZE, 998 D3DSRO_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 999} D3DVS_RASTOUT_OFFSETS; 1000 1001// Source operand addressing modes 1002 1003#define D3DVS_ADDRESSMODE_SHIFT 13 1004#define D3DVS_ADDRESSMODE_MASK (1 << D3DVS_ADDRESSMODE_SHIFT) 1005 1006typedef enum _D3DVS_ADDRESSMODE_TYPE 1007{ 1008 D3DVS_ADDRMODE_ABSOLUTE = (0 << D3DVS_ADDRESSMODE_SHIFT), 1009 D3DVS_ADDRMODE_RELATIVE = (1 << D3DVS_ADDRESSMODE_SHIFT), // Relative to register A0 1010 D3DVS_ADDRMODE_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 1011} D3DVS_ADDRESSMODE_TYPE; 1012 1013// Source operand swizzle definitions 1014// 1015#define D3DVS_SWIZZLE_SHIFT 16 1016#define D3DVS_SWIZZLE_MASK 0x00FF0000 1017 1018// The following bits define where to take component X from: 1019 1020#define D3DVS_X_X (0 << D3DVS_SWIZZLE_SHIFT) 1021#define D3DVS_X_Y (1 << D3DVS_SWIZZLE_SHIFT) 1022#define D3DVS_X_Z (2 << D3DVS_SWIZZLE_SHIFT) 1023#define D3DVS_X_W (3 << D3DVS_SWIZZLE_SHIFT) 1024 1025// The following bits define where to take component Y from: 1026 1027#define D3DVS_Y_X (0 << (D3DVS_SWIZZLE_SHIFT + 2)) 1028#define D3DVS_Y_Y (1 << (D3DVS_SWIZZLE_SHIFT + 2)) 1029#define D3DVS_Y_Z (2 << (D3DVS_SWIZZLE_SHIFT + 2)) 1030#define D3DVS_Y_W (3 << (D3DVS_SWIZZLE_SHIFT + 2)) 1031 1032// The following bits define where to take component Z from: 1033 1034#define D3DVS_Z_X (0 << (D3DVS_SWIZZLE_SHIFT + 4)) 1035#define D3DVS_Z_Y (1 << (D3DVS_SWIZZLE_SHIFT + 4)) 1036#define D3DVS_Z_Z (2 << (D3DVS_SWIZZLE_SHIFT + 4)) 1037#define D3DVS_Z_W (3 << (D3DVS_SWIZZLE_SHIFT + 4)) 1038 1039// The following bits define where to take component W from: 1040 1041#define D3DVS_W_X (0 << (D3DVS_SWIZZLE_SHIFT + 6)) 1042#define D3DVS_W_Y (1 << (D3DVS_SWIZZLE_SHIFT + 6)) 1043#define D3DVS_W_Z (2 << (D3DVS_SWIZZLE_SHIFT + 6)) 1044#define D3DVS_W_W (3 << (D3DVS_SWIZZLE_SHIFT + 6)) 1045 1046// Value when there is no swizzle (X is taken from X, Y is taken from Y, 1047// Z is taken from Z, W is taken from W 1048// 1049#define D3DVS_NOSWIZZLE (D3DVS_X_X | D3DVS_Y_Y | D3DVS_Z_Z | D3DVS_W_W) 1050 1051// source parameter swizzle 1052#define D3DSP_SWIZZLE_SHIFT 16 1053#define D3DSP_SWIZZLE_MASK 0x00FF0000 1054 1055#define D3DSP_NOSWIZZLE \ 1056 ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) | \ 1057 (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | \ 1058 (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | \ 1059 (3 << (D3DSP_SWIZZLE_SHIFT + 6)) ) 1060 1061// pixel-shader swizzle ops 1062#define D3DSP_REPLICATERED \ 1063 ( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) | \ 1064 (0 << (D3DSP_SWIZZLE_SHIFT + 2)) | \ 1065 (0 << (D3DSP_SWIZZLE_SHIFT + 4)) | \ 1066 (0 << (D3DSP_SWIZZLE_SHIFT + 6)) ) 1067 1068#define D3DSP_REPLICATEGREEN \ 1069 ( (1 << (D3DSP_SWIZZLE_SHIFT + 0)) | \ 1070 (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | \ 1071 (1 << (D3DSP_SWIZZLE_SHIFT + 4)) | \ 1072 (1 << (D3DSP_SWIZZLE_SHIFT + 6)) ) 1073 1074#define D3DSP_REPLICATEBLUE \ 1075 ( (2 << (D3DSP_SWIZZLE_SHIFT + 0)) | \ 1076 (2 << (D3DSP_SWIZZLE_SHIFT + 2)) | \ 1077 (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | \ 1078 (2 << (D3DSP_SWIZZLE_SHIFT + 6)) ) 1079 1080#define D3DSP_REPLICATEALPHA \ 1081 ( (3 << (D3DSP_SWIZZLE_SHIFT + 0)) | \ 1082 (3 << (D3DSP_SWIZZLE_SHIFT + 2)) | \ 1083 (3 << (D3DSP_SWIZZLE_SHIFT + 4)) | \ 1084 (3 << (D3DSP_SWIZZLE_SHIFT + 6)) ) 1085 1086// source parameter modifiers 1087#define D3DSP_SRCMOD_SHIFT 24 1088#define D3DSP_SRCMOD_MASK 0x0F000000 1089 1090typedef enum _D3DSHADER_PARAM_SRCMOD_TYPE 1091{ 1092 D3DSPSM_NONE = 0<<D3DSP_SRCMOD_SHIFT, // nop 1093 D3DSPSM_NEG = 1<<D3DSP_SRCMOD_SHIFT, // negate 1094 D3DSPSM_BIAS = 2<<D3DSP_SRCMOD_SHIFT, // bias 1095 D3DSPSM_BIASNEG = 3<<D3DSP_SRCMOD_SHIFT, // bias and negate 1096 D3DSPSM_SIGN = 4<<D3DSP_SRCMOD_SHIFT, // sign 1097 D3DSPSM_SIGNNEG = 5<<D3DSP_SRCMOD_SHIFT, // sign and negate 1098 D3DSPSM_COMP = 6<<D3DSP_SRCMOD_SHIFT, // complement 1099 D3DSPSM_X2 = 7<<D3DSP_SRCMOD_SHIFT, // *2 1100 D3DSPSM_X2NEG = 8<<D3DSP_SRCMOD_SHIFT, // *2 and negate 1101 D3DSPSM_DZ = 9<<D3DSP_SRCMOD_SHIFT, // divide through by z component 1102 D3DSPSM_DW = 10<<D3DSP_SRCMOD_SHIFT, // divide through by w component 1103 D3DSPSM_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 1104} D3DSHADER_PARAM_SRCMOD_TYPE; 1105 1106// pixel shader version token 1107#define D3DPS_VERSION(_Major,_Minor) (0xFFFF0000|((_Major)<<8)|(_Minor)) 1108 1109// vertex shader version token 1110#define D3DVS_VERSION(_Major,_Minor) (0xFFFE0000|((_Major)<<8)|(_Minor)) 1111 1112// extract major/minor from version cap 1113#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF) 1114#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF) 1115 1116// destination/source parameter register type 1117#define D3DSI_COMMENTSIZE_SHIFT 16 1118#define D3DSI_COMMENTSIZE_MASK 0x7FFF0000 1119#define D3DSHADER_COMMENT(_DWordSize) \ 1120 ((((_DWordSize)<<D3DSI_COMMENTSIZE_SHIFT)&D3DSI_COMMENTSIZE_MASK)|D3DSIO_COMMENT) 1121 1122// pixel/vertex shader end token 1123#define D3DPS_END() 0x0000FFFF 1124#define D3DVS_END() 0x0000FFFF 1125 1126//--------------------------------------------------------------------- 1127 1128// High order surfaces 1129// 1130typedef enum _D3DBASISTYPE 1131{ 1132 D3DBASIS_BEZIER = 0, 1133 D3DBASIS_BSPLINE = 1, 1134 D3DBASIS_INTERPOLATE = 2, 1135 D3DBASIS_FORCE_DWORD = 0x7fffffff, 1136} D3DBASISTYPE; 1137 1138typedef enum _D3DORDERTYPE 1139{ 1140 D3DORDER_LINEAR = 1, 1141 D3DORDER_QUADRATIC = 2, 1142 D3DORDER_CUBIC = 3, 1143 D3DORDER_QUINTIC = 5, 1144 D3DORDER_FORCE_DWORD = 0x7fffffff, 1145} D3DORDERTYPE; 1146 1147typedef enum _D3DPATCHEDGESTYLE 1148{ 1149 D3DPATCHEDGE_DISCRETE = 0, 1150 D3DPATCHEDGE_CONTINUOUS = 1, 1151 D3DPATCHEDGE_FORCE_DWORD = 0x7fffffff, 1152} D3DPATCHEDGESTYLE; 1153 1154typedef enum _D3DSTATEBLOCKTYPE 1155{ 1156 D3DSBT_ALL = 1, // capture all state 1157 D3DSBT_PIXELSTATE = 2, // capture pixel state 1158 D3DSBT_VERTEXSTATE = 3, // capture vertex state 1159 D3DSBT_FORCE_DWORD = 0x7fffffff, 1160} D3DSTATEBLOCKTYPE; 1161 1162// The D3DVERTEXBLENDFLAGS type is used with D3DRS_VERTEXBLEND state. 1163// 1164typedef enum _D3DVERTEXBLENDFLAGS 1165{ 1166 D3DVBF_DISABLE = 0, // Disable vertex blending 1167 D3DVBF_1WEIGHTS = 1, // 2 matrix blending 1168 D3DVBF_2WEIGHTS = 2, // 3 matrix blending 1169 D3DVBF_3WEIGHTS = 3, // 4 matrix blending 1170 D3DVBF_TWEENING = 255, // blending using D3DRS_TWEENFACTOR 1171 D3DVBF_0WEIGHTS = 256, // one matrix is used with weight 1.0 1172 D3DVBF_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum 1173} D3DVERTEXBLENDFLAGS; 1174 1175typedef enum _D3DTEXTURETRANSFORMFLAGS { 1176 D3DTTFF_DISABLE = 0, // texture coordinates are passed directly 1177 D3DTTFF_COUNT1 = 1, // rasterizer should expect 1-D texture coords 1178 D3DTTFF_COUNT2 = 2, // rasterizer should expect 2-D texture coords 1179 D3DTTFF_COUNT3 = 3, // rasterizer should expect 3-D texture coords 1180 D3DTTFF_COUNT4 = 4, // rasterizer should expect 4-D texture coords 1181 D3DTTFF_PROJECTED = 256, // texcoords to be divided by COUNTth element 1182 D3DTTFF_FORCE_DWORD = 0x7fffffff, 1183} D3DTEXTURETRANSFORMFLAGS; 1184 1185// Macros to set texture coordinate format bits in the FVF id 1186 1187#define D3DFVF_TEXTUREFORMAT2 0 // Two floating point values 1188#define D3DFVF_TEXTUREFORMAT1 3 // One floating point value 1189#define D3DFVF_TEXTUREFORMAT3 1 // Three floating point values 1190#define D3DFVF_TEXTUREFORMAT4 2 // Four floating point values 1191 1192#define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16)) 1193#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2) 1194#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16)) 1195#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16)) 1196 1197 1198//--------------------------------------------------------------------- 1199 1200/* Direct3D8 Device types */ 1201typedef enum _D3DDEVTYPE 1202{ 1203 D3DDEVTYPE_HAL = 1, 1204 D3DDEVTYPE_REF = 2, 1205 D3DDEVTYPE_SW = 3, 1206 1207 D3DDEVTYPE_FORCE_DWORD = 0x7fffffff 1208} D3DDEVTYPE; 1209 1210/* Multi-Sample buffer types */ 1211typedef enum _D3DMULTISAMPLE_TYPE 1212{ 1213 D3DMULTISAMPLE_NONE = 0, 1214 D3DMULTISAMPLE_2_SAMPLES = 2, 1215 D3DMULTISAMPLE_3_SAMPLES = 3, 1216 D3DMULTISAMPLE_4_SAMPLES = 4, 1217 D3DMULTISAMPLE_5_SAMPLES = 5, 1218 D3DMULTISAMPLE_6_SAMPLES = 6, 1219 D3DMULTISAMPLE_7_SAMPLES = 7, 1220 D3DMULTISAMPLE_8_SAMPLES = 8, 1221 D3DMULTISAMPLE_9_SAMPLES = 9, 1222 D3DMULTISAMPLE_10_SAMPLES = 10, 1223 D3DMULTISAMPLE_11_SAMPLES = 11, 1224 D3DMULTISAMPLE_12_SAMPLES = 12, 1225 D3DMULTISAMPLE_13_SAMPLES = 13, 1226 D3DMULTISAMPLE_14_SAMPLES = 14, 1227 D3DMULTISAMPLE_15_SAMPLES = 15, 1228 D3DMULTISAMPLE_16_SAMPLES = 16, 1229 1230 D3DMULTISAMPLE_FORCE_DWORD = 0x7fffffff 1231} D3DMULTISAMPLE_TYPE; 1232 1233/* Formats 1234 * Most of these names have the following convention: 1235 * A = Alpha 1236 * R = Red 1237 * G = Green 1238 * B = Blue 1239 * X = Unused Bits 1240 * P = Palette 1241 * L = Luminance 1242 * U = dU coordinate for BumpMap 1243 * V = dV coordinate for BumpMap 1244 * S = Stencil 1245 * D = Depth (e.g. Z or W buffer) 1246 * 1247 * Further, the order of the pieces are from MSB first; hence 1248 * D3DFMT_A8L8 indicates that the high byte of this two byte 1249 * format is alpha. 1250 * 1251 * D16 indicates: 1252 * - An integer 16-bit value. 1253 * - An app-lockable surface. 1254 * 1255 * All Depth/Stencil formats except D3DFMT_D16_LOCKABLE indicate: 1256 * - no particular bit ordering per pixel, and 1257 * - are not app lockable, and 1258 * - the driver is allowed to consume more than the indicated 1259 * number of bits per Depth channel (but not Stencil channel). 1260 */ 1261#ifndef MAKEFOURCC 1262 #define MAKEFOURCC(ch0, ch1, ch2, ch3) \ 1263 ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \ 1264 ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 )) 1265#endif /* defined(MAKEFOURCC) */ 1266 1267 1268typedef enum _D3DFORMAT 1269{ 1270 D3DFMT_UNKNOWN = 0, 1271 1272 D3DFMT_R8G8B8 = 20, 1273 D3DFMT_A8R8G8B8 = 21, 1274 D3DFMT_X8R8G8B8 = 22, 1275 D3DFMT_R5G6B5 = 23, 1276 D3DFMT_X1R5G5B5 = 24, 1277 D3DFMT_A1R5G5B5 = 25, 1278 D3DFMT_A4R4G4B4 = 26, 1279 D3DFMT_R3G3B2 = 27, 1280 D3DFMT_A8 = 28, 1281 D3DFMT_A8R3G3B2 = 29, 1282 D3DFMT_X4R4G4B4 = 30, 1283 D3DFMT_A2B10G10R10 = 31, 1284 D3DFMT_G16R16 = 34, 1285 1286 D3DFMT_A8P8 = 40, 1287 D3DFMT_P8 = 41, 1288 1289 D3DFMT_L8 = 50, 1290 D3DFMT_A8L8 = 51, 1291 D3DFMT_A4L4 = 52, 1292 1293 D3DFMT_V8U8 = 60, 1294 D3DFMT_L6V5U5 = 61, 1295 D3DFMT_X8L8V8U8 = 62, 1296 D3DFMT_Q8W8V8U8 = 63, 1297 D3DFMT_V16U16 = 64, 1298 D3DFMT_W11V11U10 = 65, 1299 D3DFMT_A2W10V10U10 = 67, 1300 1301 D3DFMT_UYVY = MAKEFOURCC('U', 'Y', 'V', 'Y'), 1302 D3DFMT_YUY2 = MAKEFOURCC('Y', 'U', 'Y', '2'), 1303 D3DFMT_DXT1 = MAKEFOURCC('D', 'X', 'T', '1'), 1304 D3DFMT_DXT2 = MAKEFOURCC('D', 'X', 'T', '2'), 1305 D3DFMT_DXT3 = MAKEFOURCC('D', 'X', 'T', '3'), 1306 D3DFMT_DXT4 = MAKEFOURCC('D', 'X', 'T', '4'), 1307 D3DFMT_DXT5 = MAKEFOURCC('D', 'X', 'T', '5'), 1308 1309 D3DFMT_D16_LOCKABLE = 70, 1310 D3DFMT_D32 = 71, 1311 D3DFMT_D15S1 = 73, 1312 D3DFMT_D24S8 = 75, 1313 D3DFMT_D16 = 80, 1314 D3DFMT_D24X8 = 77, 1315 D3DFMT_D24X4S4 = 79, 1316 1317 1318 D3DFMT_VERTEXDATA =100, 1319 D3DFMT_INDEX16 =101, 1320 D3DFMT_INDEX32 =102, 1321 1322 D3DFMT_FORCE_DWORD =0x7fffffff 1323} D3DFORMAT; 1324 1325/* Display Modes */ 1326typedef struct _D3DDISPLAYMODE 1327{ 1328 UINT Width; 1329 UINT Height; 1330 UINT RefreshRate; 1331 D3DFORMAT Format; 1332} D3DDISPLAYMODE; 1333 1334/* Creation Parameters */ 1335typedef struct _D3DDEVICE_CREATION_PARAMETERS 1336{ 1337 UINT AdapterOrdinal; 1338 D3DDEVTYPE DeviceType; 1339 HWND hFocusWindow; 1340 DWORD BehaviorFlags; 1341} D3DDEVICE_CREATION_PARAMETERS; 1342 1343 1344/* SwapEffects */ 1345typedef enum _D3DSWAPEFFECT 1346{ 1347 D3DSWAPEFFECT_DISCARD = 1, 1348 D3DSWAPEFFECT_FLIP = 2, 1349 D3DSWAPEFFECT_COPY = 3, 1350 D3DSWAPEFFECT_COPY_VSYNC = 4, 1351 1352 D3DSWAPEFFECT_FORCE_DWORD = 0x7fffffff 1353} D3DSWAPEFFECT; 1354 1355/* Pool types */ 1356typedef enum _D3DPOOL { 1357 D3DPOOL_DEFAULT = 0, 1358 D3DPOOL_MANAGED = 1, 1359 D3DPOOL_SYSTEMMEM = 2, 1360 D3DPOOL_SCRATCH = 3, 1361 1362 D3DPOOL_FORCE_DWORD = 0x7fffffff 1363} D3DPOOL; 1364 1365 1366/* RefreshRate pre-defines */ 1367#define D3DPRESENT_RATE_DEFAULT 0x00000000 1368#define D3DPRESENT_RATE_UNLIMITED 0x7fffffff 1369 1370 1371/* Resize Optional Parameters */ 1372typedef struct _D3DPRESENT_PARAMETERS_ 1373{ 1374 UINT BackBufferWidth; 1375 UINT BackBufferHeight; 1376 D3DFORMAT BackBufferFormat; 1377 UINT BackBufferCount; 1378 1379 D3DMULTISAMPLE_TYPE MultiSampleType; 1380 1381 D3DSWAPEFFECT SwapEffect; 1382 HWND hDeviceWindow; 1383 BOOL Windowed; 1384 BOOL EnableAutoDepthStencil; 1385 D3DFORMAT AutoDepthStencilFormat; 1386 DWORD Flags; 1387 1388 /* Following elements must be zero for Windowed mode */ 1389 UINT FullScreen_RefreshRateInHz; 1390 UINT FullScreen_PresentationInterval; 1391 1392} D3DPRESENT_PARAMETERS; 1393 1394// Values for D3DPRESENT_PARAMETERS.Flags 1395 1396#define D3DPRESENTFLAG_LOCKABLE_BACKBUFFER 0x00000001 1397 1398 1399/* Gamma Ramp: Same as DX7 */ 1400 1401typedef struct _D3DGAMMARAMP 1402{ 1403 WORD red [256]; 1404 WORD green[256]; 1405 WORD blue [256]; 1406} D3DGAMMARAMP; 1407 1408/* Back buffer types */ 1409typedef enum _D3DBACKBUFFER_TYPE 1410{ 1411 D3DBACKBUFFER_TYPE_MONO = 0, 1412 D3DBACKBUFFER_TYPE_LEFT = 1, 1413 D3DBACKBUFFER_TYPE_RIGHT = 2, 1414 1415 D3DBACKBUFFER_TYPE_FORCE_DWORD = 0x7fffffff 1416} D3DBACKBUFFER_TYPE; 1417 1418 1419/* Types */ 1420typedef enum _D3DRESOURCETYPE { 1421 D3DRTYPE_SURFACE = 1, 1422 D3DRTYPE_VOLUME = 2, 1423 D3DRTYPE_TEXTURE = 3, 1424 D3DRTYPE_VOLUMETEXTURE = 4, 1425 D3DRTYPE_CUBETEXTURE = 5, 1426 D3DRTYPE_VERTEXBUFFER = 6, 1427 D3DRTYPE_INDEXBUFFER = 7, 1428 1429 1430 D3DRTYPE_FORCE_DWORD = 0x7fffffff 1431} D3DRESOURCETYPE; 1432 1433/* Usages */ 1434#define D3DUSAGE_RENDERTARGET (0x00000001L) 1435#define D3DUSAGE_DEPTHSTENCIL (0x00000002L) 1436 1437/* Usages for Vertex/Index buffers */ 1438#define D3DUSAGE_WRITEONLY (0x00000008L) 1439#define D3DUSAGE_SOFTWAREPROCESSING (0x00000010L) 1440#define D3DUSAGE_DONOTCLIP (0x00000020L) 1441#define D3DUSAGE_POINTS (0x00000040L) 1442#define D3DUSAGE_RTPATCHES (0x00000080L) 1443#define D3DUSAGE_NPATCHES (0x00000100L) 1444#define D3DUSAGE_DYNAMIC (0x00000200L) 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454/* CubeMap Face identifiers */ 1455typedef enum _D3DCUBEMAP_FACES 1456{ 1457 D3DCUBEMAP_FACE_POSITIVE_X = 0, 1458 D3DCUBEMAP_FACE_NEGATIVE_X = 1, 1459 D3DCUBEMAP_FACE_POSITIVE_Y = 2, 1460 D3DCUBEMAP_FACE_NEGATIVE_Y = 3, 1461 D3DCUBEMAP_FACE_POSITIVE_Z = 4, 1462 D3DCUBEMAP_FACE_NEGATIVE_Z = 5, 1463 1464 D3DCUBEMAP_FACE_FORCE_DWORD = 0x7fffffff 1465} D3DCUBEMAP_FACES; 1466 1467 1468/* Lock flags */ 1469 1470#define D3DLOCK_READONLY 0x00000010L 1471#define D3DLOCK_DISCARD 0x00002000L 1472#define D3DLOCK_NOOVERWRITE 0x00001000L 1473#define D3DLOCK_NOSYSLOCK 0x00000800L 1474 1475#define D3DLOCK_NO_DIRTY_UPDATE 0x00008000L 1476 1477 1478 1479 1480 1481 1482/* Vertex Buffer Description */ 1483typedef struct _D3DVERTEXBUFFER_DESC 1484{ 1485 D3DFORMAT Format; 1486 D3DRESOURCETYPE Type; 1487 DWORD Usage; 1488 D3DPOOL Pool; 1489 UINT Size; 1490 1491 DWORD FVF; 1492 1493} D3DVERTEXBUFFER_DESC; 1494 1495/* Index Buffer Description */ 1496typedef struct _D3DINDEXBUFFER_DESC 1497{ 1498 D3DFORMAT Format; 1499 D3DRESOURCETYPE Type; 1500 DWORD Usage; 1501 D3DPOOL Pool; 1502 UINT Size; 1503} D3DINDEXBUFFER_DESC; 1504 1505 1506/* Surface Description */ 1507typedef struct _D3DSURFACE_DESC 1508{ 1509 D3DFORMAT Format; 1510 D3DRESOURCETYPE Type; 1511 DWORD Usage; 1512 D3DPOOL Pool; 1513 UINT Size; 1514 1515 D3DMULTISAMPLE_TYPE MultiSampleType; 1516 UINT Width; 1517 UINT Height; 1518} D3DSURFACE_DESC; 1519 1520typedef struct _D3DVOLUME_DESC 1521{ 1522 D3DFORMAT Format; 1523 D3DRESOURCETYPE Type; 1524 DWORD Usage; 1525 D3DPOOL Pool; 1526 UINT Size; 1527 1528 UINT Width; 1529 UINT Height; 1530 UINT Depth; 1531} D3DVOLUME_DESC; 1532 1533/* Structure for LockRect */ 1534typedef struct _D3DLOCKED_RECT 1535{ 1536 INT Pitch; 1537 void* pBits; 1538} D3DLOCKED_RECT; 1539 1540/* Structures for LockBox */ 1541typedef struct _D3DBOX 1542{ 1543 UINT Left; 1544 UINT Top; 1545 UINT Right; 1546 UINT Bottom; 1547 UINT Front; 1548 UINT Back; 1549} D3DBOX; 1550 1551typedef struct _D3DLOCKED_BOX 1552{ 1553 INT RowPitch; 1554 INT SlicePitch; 1555 void* pBits; 1556} D3DLOCKED_BOX; 1557 1558/* Structures for LockRange */ 1559typedef struct _D3DRANGE 1560{ 1561 UINT Offset; 1562 UINT Size; 1563} D3DRANGE; 1564 1565/* Structures for high order primitives */ 1566typedef struct _D3DRECTPATCH_INFO 1567{ 1568 UINT StartVertexOffsetWidth; 1569 UINT StartVertexOffsetHeight; 1570 UINT Width; 1571 UINT Height; 1572 UINT Stride; 1573 D3DBASISTYPE Basis; 1574 D3DORDERTYPE Order; 1575} D3DRECTPATCH_INFO; 1576 1577typedef struct _D3DTRIPATCH_INFO 1578{ 1579 UINT StartVertexOffset; 1580 UINT NumVertices; 1581 D3DBASISTYPE Basis; 1582 D3DORDERTYPE Order; 1583} D3DTRIPATCH_INFO; 1584 1585/* Adapter Identifier */ 1586 1587#define MAX_DEVICE_IDENTIFIER_STRING 512 1588typedef struct _D3DADAPTER_IDENTIFIER8 1589{ 1590 char Driver[MAX_DEVICE_IDENTIFIER_STRING]; 1591 char Description[MAX_DEVICE_IDENTIFIER_STRING]; 1592 1593#ifdef _WIN32 1594 LARGE_INTEGER DriverVersion; /* Defined for 32 bit components */ 1595#else 1596 DWORD DriverVersionLowPart; /* Defined for 16 bit driver components */ 1597 DWORD DriverVersionHighPart; 1598#endif 1599 1600 DWORD VendorId; 1601 DWORD DeviceId; 1602 DWORD SubSysId; 1603 DWORD Revision; 1604 1605 GUID DeviceIdentifier; 1606 1607 DWORD WHQLLevel; 1608 1609} D3DADAPTER_IDENTIFIER8; 1610 1611 1612/* Raster Status structure returned by GetRasterStatus */ 1613typedef struct _D3DRASTER_STATUS 1614{ 1615 BOOL InVBlank; 1616 UINT ScanLine; 1617} D3DRASTER_STATUS; 1618 1619 1620 1621/* Debug monitor tokens (DEBUG only) 1622 1623 Note that if D3DRS_DEBUGMONITORTOKEN is set, the call is treated as 1624 passing a token to the debug monitor. For example, if, after passing 1625 D3DDMT_ENABLE/DISABLE to D3DRS_DEBUGMONITORTOKEN other token values 1626 are passed in, the enabled/disabled state of the debug 1627 monitor will still persist. 1628 1629 The debug monitor defaults to enabled. 1630 1631 Calling GetRenderState on D3DRS_DEBUGMONITORTOKEN is not of any use. 1632*/ 1633typedef enum _D3DDEBUGMONITORTOKENS { 1634 D3DDMT_ENABLE = 0, // enable debug monitor 1635 D3DDMT_DISABLE = 1, // disable debug monitor 1636 D3DDMT_FORCE_DWORD = 0x7fffffff, 1637} D3DDEBUGMONITORTOKENS; 1638 1639// GetInfo IDs 1640 1641#define D3DDEVINFOID_RESOURCEMANAGER 5 /* Used with D3DDEVINFO_RESOURCEMANAGER */ 1642#define D3DDEVINFOID_VERTEXSTATS 6 /* Used with D3DDEVINFO_D3DVERTEXSTATS */ 1643 1644typedef struct _D3DRESOURCESTATS 1645{ 1646// Data collected since last Present() 1647 BOOL bThrashing; /* indicates if thrashing */ 1648 DWORD ApproxBytesDownloaded; /* Approximate number of bytes downloaded by resource manager */ 1649 DWORD NumEvicts; /* number of objects evicted */ 1650 DWORD NumVidCreates; /* number of objects created in video memory */ 1651 DWORD LastPri; /* priority of last object evicted */ 1652 DWORD NumUsed; /* number of objects set to the device */ 1653 DWORD NumUsedInVidMem; /* number of objects set to the device, which are already in video memory */ 1654// Persistent data 1655 DWORD WorkingSet; /* number of objects in video memory */ 1656 DWORD WorkingSetBytes; /* number of bytes in video memory */ 1657 DWORD TotalManaged; /* total number of managed objects */ 1658 DWORD TotalBytes; /* total number of bytes of managed objects */ 1659} D3DRESOURCESTATS; 1660 1661#define D3DRTYPECOUNT (D3DRTYPE_INDEXBUFFER+1) 1662 1663typedef struct _D3DDEVINFO_RESOURCEMANAGER 1664{ 1665 D3DRESOURCESTATS stats[D3DRTYPECOUNT]; 1666} D3DDEVINFO_RESOURCEMANAGER, *LPD3DDEVINFO_RESOURCEMANAGER; 1667 1668typedef struct _D3DDEVINFO_D3DVERTEXSTATS 1669{ 1670 DWORD NumRenderedTriangles; /* total number of triangles that are not clipped in this frame */ 1671 DWORD NumExtraClippingTriangles; /* Number of new triangles generated by clipping */ 1672} D3DDEVINFO_D3DVERTEXSTATS, *LPD3DDEVINFO_D3DVERTEXSTATS; 1673 1674 1675#pragma pack() 1676#if _MSC_VER >= 1200 1677#pragma warning(pop) 1678#else 1679#pragma warning(default:4201) 1680#endif 1681 1682#endif /* (DIRECT3D_VERSION >= 0x0800) */ 1683#endif /* _D3D8TYPES(P)_H_ */ 1684 1685