denuvo-ref/cheat-engine
1
0
Fork 0
mirror of https://github.com/cheat-engine/cheat-engine synced 2026-08-15 02:26:08 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
cheat-engine/DirectXHook/DirectXGraphics.pas
cheatengine@gmail.com 4d297adfd2
2011-07-04 19:52:19 +00:00

2737 lines
133 KiB
ObjectPascal
Raw Permalink Blame History

(*)
[------------------------------------------------------------------------------
[ DirectXGraphics 8[.1] Delphi Adaptation (c) by Tim Baumgarten
[------------------------------------------------------------------------------
[ Files : d3d8types.h
[ d3d8caps.h
[ d3d8.h
[ Modified : 10-Nov-2001
[ E-Mail : Ampaze@gmx.net
[ Download : http://www.crazyentertainment.net
[------------------------------------------------------------------------------
(*)
(*)
[------------------------------------------------------------------------------
[ History :
[----------
[ 10-Nov-2001 (Tim Baumgarten) : Added DX 8.1, and still testing,
[ Define DX8 to make it work with dx8 runtime.
[------------------------------------------------------------------------------
[ 05-Nov-2001 (Tim Baumgarten) : Changed the EnumTypes for D6, so you might
[ have to typecast to LongWord in some cases.
[------------------------------------------------------------------------------
[ 28-Jul-2001 (Tim Baumgarten) : Changed "var pDestinationSurface : IDirect3DSurface8" to
[ "const pDestinationSurface : IDirect3DSurface8" in
[ IDirect3DDevice8.CopyRects
[------------------------------------------------------------------------------
[ 14-Mar-2001 (Tim Baumgarten) : Changed CreateVertexShader as pFunction can
[ be nil.
[------------------------------------------------------------------------------
[ 28-Jan-2001 (Tim Baumgarten) : Added TD3DMultiSampleType = TD3DMultiSample_Type;
[------------------------------------------------------------------------------
[ 23-Dec-2000 (Tim Baumgarten) : Changed all types that are declared as UInt
[ in C to be Cardinal in Delphi
[------------------------------------------------------------------------------
[ 23-Dec-2000 (Tim Baumgarten) : Changed all types that are declared as DWord
[ in C to be LongWord in Delphi
[------------------------------------------------------------------------------
[ 14-Dec-2000 (Tim Baumgarten) : Changed some parameters of IDirect3DDevice8.DrawRectPatch
[ and IDirect3DDevice8.DrawTriPatch to Pointers.
[------------------------------------------------------------------------------
[ 14-Dec-2000 (Tim Baumgarten) : Added versions without underlines of some structures
[------------------------------------------------------------------------------
[ 14-Dec-2000 (Tim Baumgarten) : Added "Pointer to Structure" (PStructure = ^TStructure)
[ to all structures.
[------------------------------------------------------------------------------
[ 26-Nov-2000 (Tim Baumgarten) : Returncodes are now typecasted with HResult
[------------------------------------------------------------------------------
(*)
unit DirectXGraphics;
{$MINENUMSIZE 4}
{$ALIGN ON}
//Remove dot to make all enums to be const's
{$DEFINE NOENUMS}
//Remove dot to revert to dx8
{.$DEFINE DX8}
//Remove dot to enable static linking, your app will halt with a error message
//when the d3d8.dll cannot be found.
{$DEFINE STATIC_LINKING}
{$IFDEF VER140}
{$DEFINE DELPHI6}
{$ENDIF}
{$IFDEF DELPHI6}
{$DEFINE DELPHI6_AND_HIGHER}
{$DEFINE D6UP}
{$ENDIF}
{$IFNDEF DELPHI6_AND_HIGHER}
{$DEFINE NOENUMS}
{$ENDIF}
interface
uses
Windows;
{$IFNDEF STATIC_LINKING}
var D3D8DLL : HMODULE = 0;
{$ENDIF}
const D3D8DLLName = 'd3d8.dll';
(*==========================================================================;
*
* Copyright (C) 1995-2000 Microsoft Corporation. All Rights Reserved.
*
* File: d3d8types.h
* Content: Direct3D capabilities include file
*
***************************************************************************)
const DIRECT3D_VERSION = $0800;
const iTrue = DWord(True);
iFalse = DWord(False);
type TD3DColor = type LongWord;
// maps unsigned 8 bits/channel to D3DCOLOR
function D3DCOLOR_ARGB(a, r, g, b : Cardinal) : TD3DColor; // ((D3DCOLOR)((((a)&= $ff)<<24)|(((r)&= $ff)<<16)|(((g)&= $ff)<<8)|((b)&= $ff)))
function D3DCOLOR_RGBA(r, g, b, a : Cardinal) : TD3DColor; // D3DCOLOR_ARGB(a;r;g;b)
function D3DCOLOR_XRGB(r, g, b : Cardinal) : TD3DColor; // D3DCOLOR_ARGB(= $ff;r;g;b)
// maps floating point channels (0.f to 1.f range) to D3DCOLOR
function D3DCOLOR_COLORVALUE(r, g, b, a : Single) : TD3DColor; // D3DCOLOR_RGBA((DWORD)((r)*255.f);(DWORD)((g)*255.f);(DWORD)((b)*255.f);(DWORD)((a)*255.f))
type
PD3DVector = ^TD3DVector;
TD3DVector = packed record
x : Single;
y : Single;
z : Single;
end;
PD3DColorValue = ^TD3DColorValue;
TD3DColorValue = packed record
r : Single;
g : Single;
b : Single;
a : Single;
end;
PD3DRect = ^TD3DRect;
TD3DRect = packed record
x1 : LongInt;
y1 : LongInt;
x2 : LongInt;
y2 : LongInt;
end;
PD3DMatrix = ^TD3DMatrix;
TD3DMatrix = packed record
case Integer of
0 : (_11, _12, _13, _14 : Single;
_21, _22, _23, _24 : Single;
_31, _32, _33, _34 : Single;
_41, _42, _43, _44 : Single);
1 : (m : array [0..3, 0..3] of Single);
end;
PD3DViewport8 = ^TD3DViewport8;
TD3DViewport8 = packed record
X : LongWord;
Y : LongWord; (* Viewport Top left *)
Width : LongWord;
Height : LongWord; (* Viewport Dimensions *)
MinZ : Single; (* Min/max of clip Volume *)
MaxZ : Single
end;
(* Values for clip fields.*)
// Max number of user clipping planes; supported in D3D.
const
D3DMAXUSERCLIPPLANES = 32;
// These bits could be ORed together to use with D3DRS_CLIPPLANEENABLE
D3DCLIPPLANE0 = 1; // (1 << 0)
D3DCLIPPLANE1 = 2; // (1 << 1)
D3DCLIPPLANE2 = 4; // (1 << 2)
D3DCLIPPLANE3 = 8; // (1 << 3)
D3DCLIPPLANE4 = 16; // (1 << 4)
D3DCLIPPLANE5 = 32; // (1 << 5)
// The following bits are used in the ClipUnion and ClipIntersection
// members of the D3DCLIPSTATUS8
D3DCS_LEFT = $00000001;
D3DCS_RIGHT = $00000002;
D3DCS_TOP = $00000004;
D3DCS_BOTTOM = $00000008;
D3DCS_FRONT = $00000010;
D3DCS_BACK = $00000020;
D3DCS_PLANE0 = $00000040;
D3DCS_PLANE1 = $00000080;
D3DCS_PLANE2 = $00000100;
D3DCS_PLANE3 = $00000200;
D3DCS_PLANE4 = $00000400;
D3DCS_PLANE5 = $00000800;
D3DCS_ALL = (D3DCS_LEFT or D3DCS_RIGHT or D3DCS_TOP or
D3DCS_BOTTOM or D3DCS_FRONT or D3DCS_BACK or
D3DCS_PLANE0 or D3DCS_PLANE1 or D3DCS_PLANE2 or
D3DCS_PLANE3 or D3DCS_PLANE4 or D3DCS_PLANE5);
type
PD3DClipStatus8 = ^TD3DClipStatus8;
TD3DClipStatus8 = packed record
ClipUnion : LongWord;
ClipIntersection : LongWord;
end;
PD3DMaterial8 = ^TD3DMaterial8;
TD3DMaterial8 = packed record
Diffuse : TD3DColorValue; (* Diffuse color RGBA *)
Ambient : TD3DColorValue; (* Ambient color RGB *)
Specular : TD3DColorValue; (* Specular 'shininess' *)
Emissive : TD3DColorValue; (* Emissive color RGB *)
Power : Single; (* Sharpness if specular highlight *)
end;
//{$IFDEF D6UP}({$ELSE}LongWord;{$ENDIF}
type TD3DLightType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DLIGHT_POINT = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DLIGHT_SPOT = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DLIGHT_DIRECTIONAL = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DLIGHT_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
type
PD3DLight8 = ^TD3DLight8;
TD3DLight8 = packed record
_Type : TD3DLightType; (* Type of light source *) //D3DLIGHTTYPE
Diffuse : TD3DColorValue; (* Diffuse color of light *)
Specular : TD3DColorValue; (* Specular color of light *)
Ambient : TD3DColorValue; (* Ambient color of light *)
Position : TD3DVector; (* Position in world space *)
Direction : TD3DVector; (* Direction in world space *)
Range : Single; (* Cutoff range *)
Falloff : Single; (* Falloff *)
Attenuation0 : Single; (* Constant attenuation *)
Attenuation1 : Single; (* Linear attenuation *)
Attenuation2 : Single; (* Quadratic attenuation *)
Theta : Single; (* Inner angle of spotlight cone *)
Phi : Single; (* Outer angle of spotlight cone *)
end;
(* Options for clearing *)
const
D3DCLEAR_TARGET = $00000001; (* Clear target surface *)
D3DCLEAR_ZBUFFER = $00000002; (* Clear target z buffer *)
D3DCLEAR_STENCIL = $00000004; (* Clear stencil planes *)
(* The following defines the rendering states *)
type TD3DShadeMode = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DSHADE_FLAT = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSHADE_GOURAUD = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSHADE_PHONG = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSHADE_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
type TD3DFillMode = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DFILL_POINT = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFILL_WIREFRAME = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFILL_SOLID = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFILL_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
type
PD3DLinePattern = ^TD3DLinePattern;
TD3DLinePattern = packed record
wRepeatFactor : Word;
wLinePattern : Word;
end;
type TD3DBlend = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DBLEND_ZERO = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_ONE = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_SRCCOLOR = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_INVSRCCOLOR = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_SRCALPHA = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_INVSRCALPHA = 6{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_DESTALPHA = 7{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_INVDESTALPHA = 8{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_DESTCOLOR = 9{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_INVDESTCOLOR = 10{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_SRCALPHASAT = 11{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_BOTHSRCALPHA = 12{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_BOTHINVSRCALPHA = 13{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLEND_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
type TD3DBLendOp = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DBLENDOP_ADD = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLENDOP_SUBTRACT = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLENDOP_REVSUBTRACT = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLENDOP_MIN = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLENDOP_MAX = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBLENDOP_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
type TD3DTextureAddress = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DTADDRESS_WRAP = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTADDRESS_MIRROR = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTADDRESS_CLAMP = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTADDRESS_BORDER = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTADDRESS_MIRRORONCE = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTADDRESS_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
type TD3DCull = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DCULL_NONE = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCULL_CW = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCULL_CCW = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCULL_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
type TD3DCmpFunc = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DCMP_NEVER = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCMP_LESS = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCMP_EQUAL = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCMP_LESSEQUAL = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCMP_GREATER = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCMP_NOTEQUAL = 6{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCMP_GREATEREQUAL = 7{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCMP_ALWAYS = 8{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCMP_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
type TD3DStencilOp = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DSTENCILOP_KEEP = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSTENCILOP_ZERO = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSTENCILOP_REPLACE = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSTENCILOP_INCRSAT = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSTENCILOP_DECRSAT = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSTENCILOP_INVERT = 6{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSTENCILOP_INCR = 7{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSTENCILOP_DECR = 8{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSTENCILOP_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
type TD3DFogMode = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DFOG_NONE = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFOG_EXP = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFOG_EXP2 = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFOG_LINEAR = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFOG_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
type TD3DZBufferType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DZB_FALSE = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DZB_TRUE = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Z buffering
D3DZB_USEW = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // W buffering
D3DZB_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
// Primitives supported by draw-primitive API
type TD3DPrimitiveType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DPT_POINTLIST = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DPT_LINELIST = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DPT_LINESTRIP = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DPT_TRIANGLELIST = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DPT_TRIANGLESTRIP = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DPT_TRIANGLEFAN = 6{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DPT_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
type TD3DTransformStateType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DTS_VIEW = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTS_PROJECTION = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTS_TEXTURE0 = 16{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTS_TEXTURE1 = 17{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTS_TEXTURE2 = 18{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTS_TEXTURE3 = 19{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTS_TEXTURE4 = 20{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTS_TEXTURE5 = 21{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTS_TEXTURE6 = 22{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTS_TEXTURE7 = 23{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DTS_WORLD = 0 + 256{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // D3DTS_WORLDMATRIX(0)
D3DTS_WORLD1 = 1 + 256{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // D3DTS_WORLDMATRIX(1)
D3DTS_WORLD2 = 2 + 256{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // D3DTS_WORLDMATRIX(2)
D3DTS_WORLD3 = 3 + 256{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // D3DTS_WORLDMATRIX(3)
D3DTS_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
function D3DTS_WORLDMATRIX(index : LongWord) : TD3DTransformStateType; // (D3DTRANSFORMSTATETYPE)(index + 256)
type TD3DRenderStateType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DRS_ZENABLE = 7{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DZBUFFERTYPE (or TRUE/FALSE for legacy) *)
D3DRS_FILLMODE = 8{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DFILL_MODE *)
D3DRS_SHADEMODE = 9{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DSHADEMODE *)
D3DRS_LINEPATTERN = 10{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DLINEPATTERN *)
D3DRS_ZWRITEENABLE = 14{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* TRUE to enable z writes *)
D3DRS_ALPHATESTENABLE = 15{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* TRUE to enable alpha tests *)
D3DRS_LASTPIXEL = 16{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* TRUE for last-pixel on lines *)
D3DRS_SRCBLEND = 19{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DBLEND *)
D3DRS_DESTBLEND = 20{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DBLEND *)
D3DRS_CULLMODE = 22{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DCULL *)
D3DRS_ZFUNC = 23{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DCMPFUNC *)
D3DRS_ALPHAREF = 24{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DFIXED *)
D3DRS_ALPHAFUNC = 25{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DCMPFUNC *)
D3DRS_DITHERENABLE = 26{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* TRUE to enable dithering *)
D3DRS_ALPHABLENDENABLE = 27{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* TRUE to enable alpha blending *)
D3DRS_FOGENABLE = 28{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* TRUE to enable fog blending *)
D3DRS_SPECULARENABLE = 29{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* TRUE to enable specular *)
D3DRS_ZVISIBLE = 30{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* TRUE to enable z checking *)
D3DRS_FOGCOLOR = 34{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DCOLOR *)
D3DRS_FOGTABLEMODE = 35{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DFOGMODE *)
D3DRS_FOGSTART = 36{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* Fog start (for both vertex and pixel fog) *)
D3DRS_FOGEND = 37{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* Fog end *)
D3DRS_FOGDENSITY = 38{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* Fog density *)
D3DRS_EDGEANTIALIAS = 40{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* TRUE to enable edge antialiasing *)
D3DRS_ZBIAS = 47{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* LONG Z bias *)
D3DRS_RANGEFOGENABLE = 48{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* Enables range-based fog *)
D3DRS_STENCILENABLE = 52{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* BOOL enable/disable stenciling *)
D3DRS_STENCILFAIL = 53{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DSTENCILOP to do if stencil test fails *)
D3DRS_STENCILZFAIL = 54{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DSTENCILOP to do if stencil test passes and Z test fails *)
D3DRS_STENCILPASS = 55{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DSTENCILOP to do if both stencil and Z tests pass *)
D3DRS_STENCILFUNC = 56{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DCMPFUNC fn. Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true *)
D3DRS_STENCILREF = 57{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* Reference value used in stencil test *)
D3DRS_STENCILMASK = 58{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* Mask value used in stencil test *)
D3DRS_STENCILWRITEMASK = 59{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* Write mask applied to values written to stencil buffer *)
D3DRS_TEXTUREFACTOR = 60{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DCOLOR used for multi-texture blend *)
D3DRS_WRAP0 = 128{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* wrap for 1st texture coord. set *)
D3DRS_WRAP1 = 129{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* wrap for 2nd texture coord. set *)
D3DRS_WRAP2 = 130{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* wrap for 3rd texture coord. set *)
D3DRS_WRAP3 = 131{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* wrap for 4th texture coord. set *)
D3DRS_WRAP4 = 132{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* wrap for 5th texture coord. set *)
D3DRS_WRAP5 = 133{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* wrap for 6th texture coord. set *)
D3DRS_WRAP6 = 134{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* wrap for 7th texture coord. set *)
D3DRS_WRAP7 = 135{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* wrap for 8th texture coord. set *)
D3DRS_CLIPPING = 136{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_LIGHTING = 137{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_AMBIENT = 139{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_FOGVERTEXMODE = 140{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_COLORVERTEX = 141{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_LOCALVIEWER = 142{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_NORMALIZENORMALS = 143{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_DIFFUSEMATERIALSOURCE = 145{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_SPECULARMATERIALSOURCE = 146{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_AMBIENTMATERIALSOURCE = 147{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_EMISSIVEMATERIALSOURCE = 148{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_VERTEXBLEND = 151{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_CLIPPLANEENABLE = 152{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_SOFTWAREVERTEXPROCESSING = 153{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_POINTSIZE = 154{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float point size *)
D3DRS_POINTSIZE_MIN = 155{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float point size min threshold *)
D3DRS_POINTSPRITEENABLE = 156{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* BOOL point texture coord control *)
D3DRS_POINTSCALEENABLE = 157{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* BOOL point size scale enable *)
D3DRS_POINTSCALE_A = 158{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float point attenuation A value *)
D3DRS_POINTSCALE_B = 159{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float point attenuation B value *)
D3DRS_POINTSCALE_C = 160{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float point attenuation C value *)
D3DRS_MULTISAMPLEANTIALIAS = 161{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // BOOL - set to do FSAA with multisample buffer *)
D3DRS_MULTISAMPLEMASK = 162{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // DWORD - per-sample enable/disable
D3DRS_PATCHEDGESTYLE = 163{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Sets whether patch edges will use float style tessellation
D3DRS_PATCHSEGMENTS = 164{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Number of segments per edge when drawing patches
D3DRS_DEBUGMONITORTOKEN = 165{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // DEBUG ONLY - token to debug monitor
D3DRS_POINTSIZE_MAX = 166{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float point size max threshold *)
D3DRS_INDEXEDVERTEXBLENDENABLE = 167{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRS_COLORWRITEENABLE = 168{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // per-channel write enable
D3DRS_TWEENFACTOR = 170{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // float tween factor
D3DRS_BLENDOP = 171{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // D3DBLENDOP setting
{$IFNDEF DX8}
D3DRS_POSITIONORDER = 172{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // NPatch position interpolation order. D3DORDER_LINEAR or D3DORDER_CUBIC (default)
D3DRS_NORMALORDER = 173{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // NPatch normal interpolation order. D3DORDER_LINEAR (default) or D3DORDER_QUADRATIC
{$ENDIF}
D3DRS_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
// Values for material source
type TD3DMaterialColorSource = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DMCS_MATERIAL = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Color from material is used
D3DMCS_COLOR1 = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Diffuse vertex color is used
D3DMCS_COLOR2 = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Specular vertex color is used
D3DMCS_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; // force 32-bit size enum
const
// Bias to apply to the texture coordinate set to apply a wrap to.
D3DRENDERSTATE_WRAPBIAS = 128;
(* Flags to construct the WRAP render states *)
D3DWRAP_U = $00000001;
D3DWRAP_V = $00000002;
D3DWRAP_W = $00000004;
(* Flags to construct the WRAP render states for 1D thru 4D texture coordinates *)
D3DWRAPCOORD_0 = $00000001; // same as D3DWRAP_U
D3DWRAPCOORD_1 = $00000002; // same as D3DWRAP_V
D3DWRAPCOORD_2 = $00000004; // same as D3DWRAP_W
D3DWRAPCOORD_3 = $00000008;
(* Flags to construct D3DRS_COLORWRITEENABLE *)
D3DCOLORWRITEENABLE_RED = 1; // (1L<<0)
D3DCOLORWRITEENABLE_GREEN = 2; // (1L<<1)
D3DCOLORWRITEENABLE_BLUE = 4; // (1L<<2)
D3DCOLORWRITEENABLE_ALPHA = 8; // (1L<<3)
(*
* State enumerants for per-stage texture processing.
*)
type TD3DTextureStageStateType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DTSS_COLOROP = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTEXTUREOP - per-stage blending controls for color channels *)
D3DTSS_COLORARG1 = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTA_* (texture arg) *)
D3DTSS_COLORARG2 = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTA_* (texture arg) *)
D3DTSS_ALPHAOP = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTEXTUREOP - per-stage blending controls for alpha channel *)
D3DTSS_ALPHAARG1 = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTA_* (texture arg) *)
D3DTSS_ALPHAARG2 = 6{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTA_* (texture arg) *)
D3DTSS_BUMPENVMAT00 = 7{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float (bump mapping matrix) *)
D3DTSS_BUMPENVMAT01 = 8{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float (bump mapping matrix) *)
D3DTSS_BUMPENVMAT10 = 9{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float (bump mapping matrix) *)
D3DTSS_BUMPENVMAT11 = 10{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float (bump mapping matrix) *)
D3DTSS_TEXCOORDINDEX = 11{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* identifies which set of texture coordinates index this texture *)
D3DTSS_ADDRESSU = 13{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTEXTUREADDRESS for U coordinate *)
D3DTSS_ADDRESSV = 14{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTEXTUREADDRESS for V coordinate *)
D3DTSS_BORDERCOLOR = 15{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DCOLOR *)
D3DTSS_MAGFILTER = 16{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTEXTUREFILTER filter to use for magnification *)
D3DTSS_MINFILTER = 17{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTEXTUREFILTER filter to use for minification *)
D3DTSS_MIPFILTER = 18{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTEXTUREFILTER filter to use between mipmaps during minification *)
D3DTSS_MIPMAPLODBIAS = 19{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float Mipmap LOD bias *)
D3DTSS_MAXMIPLEVEL = 20{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* DWORD 0..(n-1) LOD index of largest map to use (0 == largest) *)
D3DTSS_MAXANISOTROPY = 21{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* DWORD maximum anisotropy *)
D3DTSS_BUMPENVLSCALE = 22{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float scale for bump map luminance *)
D3DTSS_BUMPENVLOFFSET = 23{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* float offset for bump map luminance *)
D3DTSS_TEXTURETRANSFORMFLAGS = 24{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTEXTURETRANSFORMFLAGS controls texture transform *)
D3DTSS_ADDRESSW = 25{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTEXTUREADDRESS for W coordinate *)
D3DTSS_COLORARG0 = 26{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTA_* third arg for triadic ops *)
D3DTSS_ALPHAARG0 = 27{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTA_* third arg for triadic ops *)
D3DTSS_RESULTARG = 28{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} (* D3DTA_* arg for result (CURRENT or TEMP) *)
D3DTSS_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; (* force 32-bit size enum *)
const
// Values; used with D3DTSS_TEXCOORDINDEX; to specify that the vertex data(position
// and normal in the camera space) should be taken as texture coordinates
// Low 16 bits are used to specify texture coordinate index; to take the WRAP mode from
D3DTSS_TCI_PASSTHRU = $00000000;
D3DTSS_TCI_CAMERASPACENORMAL = $00010000;
D3DTSS_TCI_CAMERASPACEPOSITION = $00020000;
D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR = $00030000;
(* Enumerations for COLOROP and ALPHAOP texture blending operations set in
* texture processing stage controls in D3DTSS. *)
type TD3DTextureOp = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
// Control
D3DTOP_DISABLE = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // disables stage
D3DTOP_SELECTARG1 = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // the default
D3DTOP_SELECTARG2 = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
// Modulate
D3DTOP_MODULATE = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // multiply args together
D3DTOP_MODULATE2X = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // multiply and 1 bit
D3DTOP_MODULATE4X = 6{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // multiply and 2 bits
// Add
D3DTOP_ADD = 7{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // add arguments together
D3DTOP_ADDSIGNED = 8{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // add with -0.5 bias
D3DTOP_ADDSIGNED2X = 9{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // as above but left 1 bit
D3DTOP_SUBTRACT = 10{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Arg1 - Arg2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} with no saturation
D3DTOP_ADDSMOOTH = 11{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // add 2 args{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} subtract product
// Arg1 + Arg2 - Arg1*Arg2
// = Arg1 + (1-Arg1)*Arg2
// Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha)
D3DTOP_BLENDDIFFUSEALPHA = 12{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // iterated alpha
D3DTOP_BLENDTEXTUREALPHA = 13{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // texture alpha
D3DTOP_BLENDFACTORALPHA = 14{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // alpha from D3DRS_TEXTUREFACTOR
// Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha)
D3DTOP_BLENDTEXTUREALPHAPM = 15{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // texture alpha
D3DTOP_BLENDCURRENTALPHA = 16{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // by alpha of current color
// Specular mapping
D3DTOP_PREMODULATE = 17{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // modulate with next texture before use
D3DTOP_MODULATEALPHA_ADDCOLOR = 18{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Arg1.RGB + Arg1.A*Arg2.RGB
// COLOROP only
D3DTOP_MODULATECOLOR_ADDALPHA = 19{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Arg1.RGB*Arg2.RGB + Arg1.A
// COLOROP only
D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // (1-Arg1.A)*Arg2.RGB + Arg1.RGB
// COLOROP only
D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // (1-Arg1.RGB)*Arg2.RGB + Arg1.A
// COLOROP only
// Bump mapping
D3DTOP_BUMPENVMAP = 22{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // per pixel env map perturbation
D3DTOP_BUMPENVMAPLUMINANCE = 23{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // with luminance channel
// This can do either diffuse or specular bump mapping with correct input.
// Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G + Arg1.B*Arg2.B)
// where each component has been scaled and offset to make it signed.
// The result is replicated into all four (including alpha) channels.
// This is a valid COLOROP only.
D3DTOP_DOTPRODUCT3 = 24{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
// Triadic ops
D3DTOP_MULTIPLYADD = 25{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Arg0 + Arg1*Arg2
D3DTOP_LERP = 26{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // (Arg0)*Arg1 + (1-Arg0)*Arg2
D3DTOP_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
const
(* Values for COLORARG0;1;2; ALPHAARG0;1;2; and RESULTARG texture blending
* operations set in texture processing stage controls in D3DRENDERSTATE. *)
D3DTA_SELECTMASK = $0000000f; // mask for arg selector
D3DTA_DIFFUSE = $00000000; // select diffuse color (read only)
D3DTA_CURRENT = $00000001; // select stage destination register (read/write)
D3DTA_TEXTURE = $00000002; // select texture color (read only)
D3DTA_TFACTOR = $00000003; // select D3DRS_TEXTUREFACTOR (read only)
D3DTA_SPECULAR = $00000004; // select specular color (read only)
D3DTA_TEMP = $00000005; // select temporary register color (read/write)
D3DTA_COMPLEMENT = $00000010; // take 1.0 - x (read modifier)
D3DTA_ALPHAREPLICATE = $00000020; // replicate alpha to color components (read modifier)
// Values for D3DTSS_***FILTER texture stage states
type TD3DTextureFilterType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DTEXF_NONE = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // filtering disabled (valid for mip filter only)
D3DTEXF_POINT = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // nearest
D3DTEXF_LINEAR = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // linear interpolation
D3DTEXF_ANISOTROPIC = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // anisotropic
D3DTEXF_FLATCUBIC = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // cubic
D3DTEXF_GAUSSIANCUBIC = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // different cubic kernel
D3DTEXF_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; // force 32-bit size enum
const
(* Bits for Flags in ProcessVertices call *)
D3DPV_DONOTCOPYDATA = 1 shl 0;
//-------------------------------------------------------------------
// Flexible vertex format bits
//
D3DFVF_RESERVED0 = $001;
D3DFVF_POSITION_MASK = $00E;
D3DFVF_XYZ = $002;
D3DFVF_XYZRHW = $004;
D3DFVF_XYZB1 = $006;
D3DFVF_XYZB2 = $008;
D3DFVF_XYZB3 = $00a;
D3DFVF_XYZB4 = $00c;
D3DFVF_XYZB5 = $00e;
D3DFVF_NORMAL = $010;
D3DFVF_PSIZE = $020;
D3DFVF_DIFFUSE = $040;
D3DFVF_SPECULAR = $080;
D3DFVF_TEXCOUNT_MASK = $f00;
D3DFVF_TEXCOUNT_SHIFT = 8;
D3DFVF_TEX0 = $000;
D3DFVF_TEX1 = $100;
D3DFVF_TEX2 = $200;
D3DFVF_TEX3 = $300;
D3DFVF_TEX4 = $400;
D3DFVF_TEX5 = $500;
D3DFVF_TEX6 = $600;
D3DFVF_TEX7 = $700;
D3DFVF_TEX8 = $800;
D3DFVF_LASTBETA_UBYTE4 = $1000;
D3DFVF_RESERVED2 = $E000; // 4 reserved bits
//---------------------------------------------------------------------
// Vertex Shaders
//
(*
Vertex Shader Declaration
The declaration portion of a vertex shader defines the static external
interface of the shader. The information in the declaration includes:
- Assignments of vertex shader input registers to data streams. These
assignments bind a specific vertex register to a single component within a
vertex stream. A vertex stream element is identified by a byte offset
within the stream and a type. The type specifies the arithmetic data type
plus the dimensionality (1; 2; 3; or 4 values). Stream data which is
less than 4 values are always expanded out to 4 values with zero or more
0.F values and one 1.F value.
- Assignment of vertex shader input registers to implicit data from the
primitive tessellator. This controls the loading of vertex data which is
not loaded from a stream; but rather is generated during primitive
tessellation prior to the vertex shader.
- Loading data into the constant memory at the time a shader is set as the
current shader. Each token specifies values for one or more contiguous 4
DWORD constant registers. This allows the shader to update an arbitrary
subset of the constant memory; overwriting the device state (which
contains the current values of the constant memory). Note that these
values can be subsequently overwritten (between DrawPrimitive calls)
during the time a shader is bound to a device via the
SetVertexShaderConstant method.
Declaration arrays are single-dimensional arrays of DWORDs composed of
multiple tokens each of which is one or more DWORDs. The single-DWORD
token value = $FFFFFFFF is a special token used to indicate the end of the
declaration array. The single DWORD token value = $00000000 is a NOP token
with is ignored during the declaration parsing. Note that = $00000000 is a
valid value for DWORDs following the first DWORD for multiple word tokens.
[31:29] TokenType
= $0 - NOP (requires all DWORD bits to be zero)
= $1 - stream selector
= $2 - stream data definition (map to vertex input memory)
= $3 - vertex input memory from tessellator
= $4 - constant memory from shader
= $5 - extension
= $6 - reserved
= $7 - end-of-array (requires all DWORD bits to be 1)
NOP Token (single DWORD token)
[31:29] = $0
[28:00] = $0
Stream Selector (single DWORD token)
[31:29] = $1
[28] indicates whether this is a tessellator stream
[27:04] = $0
[03:00] stream selector (0..15)
Stream Data Definition (single DWORD token)
Vertex Input Register Load
[31:29] = $2
[28] = $0
[27:20] = $0
[19:16] type (dimensionality and data type)
[15:04] = $0
[03:00] vertex register address (0..15)
Data Skip (no register load)
[31:29] = $2
[28] = $1
[27:20] = $0
[19:16] count of DWORDS to skip over (0..15)
[15:00] = $0
Vertex Input Memory from Tessellator Data (single DWORD token)
[31:29] = $3
[28] indicates whether data is normals or u/v
[27:24] = $0
[23:20] vertex register address (0..15)
[19:16] type (dimensionality)
[15:04] = $0
[03:00] vertex register address (0..15)
Constant Memory from Shader (multiple DWORD token)
[31:29] = $4
[28:25] count of 4*DWORD constants to load (0..15)
[24:07] = $0
[06:00] constant memory address (0..95)
Extension Token (single or multiple DWORD token)
[31:29] = $5
[28:24] count of additional DWORDs in token (0..31)
[23:00] extension-specific information
End-of-array token (single DWORD token)
[31:29] = $7
[28:00] = $1fffffff
The 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.
Streams 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.
The token sequence:
Stream Select: stream=0
Stream Data Definition (Load): type=FLOAT3; register=3
Stream Data Definition (Load): type=FLOAT3; register=4
Stream Data Definition (Skip): count=2
Stream Data Definition (Load): type=FLOAT2; register=7
defines 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.
Placing of tokens other than NOPs between the Stream Selector and Stream Data Definition tokens is disallowed.
*)
type TD3DVSDTokenType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DVSD_TOKEN_NOP = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // NOP or extension
D3DVSD_TOKEN_STREAM = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // stream selector
D3DVSD_TOKEN_STREAMDATA = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // stream data definition (map to vertex input memory)
D3DVSD_TOKEN_TESSELLATOR = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // vertex input memory from tessellator
D3DVSD_TOKEN_CONSTMEM = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // constant memory from shader
D3DVSD_TOKEN_EXT = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // extension
D3DVSD_TOKEN_END = 7{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // end-of-array (requires all DWORD bits to be 1)
D3DVSD_TOKENTYPESHIFT = 29{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_TOKENTYPEMASK = 7 shl D3DVSD_TOKENTYPESHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_STREAMNUMBERSHIFT = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_STREAMNUMBERMASK = $F shl D3DVSD_STREAMNUMBERSHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_DATALOADTYPESHIFT = 28{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_DATALOADTYPEMASK = $1 shl D3DVSD_DATALOADTYPESHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_DATATYPESHIFT = 16{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_DATATYPEMASK = $F shl D3DVSD_DATATYPESHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_SKIPCOUNTSHIFT = 16{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_SKIPCOUNTMASK = $F shl D3DVSD_SKIPCOUNTSHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_VERTEXREGSHIFT = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_VERTEXREGMASK = $1F shl D3DVSD_VERTEXREGSHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_VERTEXREGINSHIFT = 20{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_VERTEXREGINMASK = $F shl D3DVSD_VERTEXREGINSHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_CONSTCOUNTSHIFT = 25{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_CONSTCOUNTMASK = $F shl D3DVSD_CONSTCOUNTSHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_CONSTADDRESSSHIFT = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_CONSTADDRESSMASK = $7F shl D3DVSD_CONSTADDRESSSHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_CONSTRSSHIFT = 16{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_CONSTRSMASK = $1FFF shl D3DVSD_CONSTRSSHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_EXTCOUNTSHIFT = 24{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_EXTCOUNTMASK = $1F shl D3DVSD_EXTCOUNTSHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_EXTINFOSHIFT = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_EXTINFOMASK = $FFFFFF shl D3DVSD_EXTINFOSHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
// Set tessellator stream
D3DVSD_STREAMTESSSHIFT = 28{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_STREAMTESSMASK = 1 shl D3DVSD_STREAMTESSSHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_STREAM_TESS = ((D3DVSD_TOKEN_STREAM shl D3DVSD_TOKENTYPESHIFT) and D3DVSD_TOKENTYPEMASK) or D3DVSD_STREAMTESSMASK{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVSD_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; // force 32-bit size enum
function D3DVSD_MAKETOKENTYPE(tokenType : TD3DVSDTokenType) : TD3DVSDTokenType;
// macros for generation of CreateVertexShader Declaration token array
// Set current stream
// _StreamNumber [0..(MaxStreams-1)] stream to get data from
//
function D3DVSD_STREAM(_StreamNumber : LongWord) : TD3DVSDTokenType;
type TD3DVSD_TokenType = TD3DVSDTokenType;
// bind single vertex register to vertex element from vertex stream
//
// _VertexRegister [0..15] address of the vertex register
// _Type [D3DVSDT_*] dimensionality and arithmetic data type
function D3DVSD_REG( _VertexRegister, _Type : LongWord) : TD3DVSDTokenType;
// Skip _DWORDCount DWORDs in vertex
//
function D3DVSD_SKIP(_DWORDCount : LongWord) : TD3DVSDTokenType;
// load data into vertex shader constant memory
//
// _ConstantAddress [0..95] - address of constant array to begin filling data
// _Count [0..15] - number of constant vectors to load (4 DWORDs each)
// followed by 4*_Count DWORDS of data
//
function D3DVSD_CONST( _ConstantAddress, _Count : LongWord) : TD3DVSDTokenType;
// enable tessellator generated normals
//
// _VertexRegisterIn [0..15] address of vertex register whose input stream
// will be used in normal computation
// _VertexRegisterOut [0..15] address of vertex register to output the normal to
//
function D3DVSD_TESSNORMAL( _VertexRegisterIn, _VertexRegisterOut : LongWord) : TD3DVSDTokenType;
// enable tessellator generated surface parameters
//
// _VertexRegister [0..15] address of vertex register to output parameters
//
function D3DVSD_TESSUV( _VertexRegister : LongWord) : TD3DVSDTokenType;
// Generates END token
//
const
D3DVSD_END = $FFFFFFFF;
// Generates NOP token
D3DVSD_NOP = $00000000;
// bit declarations for _Type fields
D3DVSDT_FLOAT1 = $00; // 1D float expanded to (value; 0.; 0.; 1.)
D3DVSDT_FLOAT2 = $01; // 2D float expanded to (value; value; 0.; 1.)
D3DVSDT_FLOAT3 = $02; // 3D float expanded to (value; value; value; 1.)
D3DVSDT_FLOAT4 = $03; // 4D float
D3DVSDT_D3DCOLOR = $04; // 4D packed unsigned bytes mapped to 0. to 1. range
// Input is in D3DCOLOR format (ARGB) expanded to (R; G; B; A)
D3DVSDT_UBYTE4 = $05; // 4D unsigned byte
D3DVSDT_SHORT2 = $06; // 2D signed short expanded to (value; value; 0.; 1.)
D3DVSDT_SHORT4 = $07; // 4D signed short
// assignments of vertex input registers for fixed function vertex shader
//
D3DVSDE_POSITION = 0;
D3DVSDE_BLENDWEIGHT = 1;
D3DVSDE_BLENDINDICES = 2;
D3DVSDE_NORMAL = 3;
D3DVSDE_PSIZE = 4;
D3DVSDE_DIFFUSE = 5;
D3DVSDE_SPECULAR = 6;
D3DVSDE_TEXCOORD0 = 7;
D3DVSDE_TEXCOORD1 = 8;
D3DVSDE_TEXCOORD2 = 9;
D3DVSDE_TEXCOORD3 = 10;
D3DVSDE_TEXCOORD4 = 11;
D3DVSDE_TEXCOORD5 = 12;
D3DVSDE_TEXCOORD6 = 13;
D3DVSDE_TEXCOORD7 = 14;
D3DVSDE_POSITION2 = 15;
D3DVSDE_NORMAL2 = 16;
// Maximum supported number of texture coordinate sets
D3DDP_MAXTEXCOORD = 8;
//
// Instruction Token Bit Definitions
//
D3DSI_OPCODE_MASK = $0000FFFF;
type
TD3DShaderInstructionOpcodeType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DSIO_NOP = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS/VS
D3DSIO_MOV = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS/VS
D3DSIO_ADD = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS/VS
D3DSIO_SUB = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_MAD = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS/VS
D3DSIO_MUL = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS/VS
D3DSIO_RCP = 6{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_RSQ = 7{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_DP3 = 8{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS/VS
D3DSIO_DP4 = 9{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS/VS
D3DSIO_MIN = 10{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_MAX = 11{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_SLT = 12{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_SGE = 13{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_EXP = 14{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_LOG = 15{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_LIT = 16{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_DST = 17{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_LRP = 18{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_FRC = 19{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_M4x4 = 20{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_M4x3 = 21{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_M3x4 = 22{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_M3x3 = 23{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_M3x2 = 24{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_TEXCOORD = 64{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXKILL = 65{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEX = 66{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXBEM = 67{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXBEML = 68{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXREG2AR = 69{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXREG2GB = 70{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXM3x2PAD = 71{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXM3x2TEX = 72{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXM3x3PAD = 73{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXM3x3TEX = 74{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXM3x3DIFF = 75{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXM3x3SPEC = 76{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXM3x3VSPEC = 77{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_EXPP = 78{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_LOGP = 79{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // VS
D3DSIO_CND = 80{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_DEF = 81{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
{$IFNDEF DX8}
D3DSIO_TEXREG2RGB = 82{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXDP3TEX = 83{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXM3x2DEPTH = 84{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXDP3 = 85{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXM3x3 = 86{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_TEXDEPTH = 87{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_CMP = 88{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_BEM = 89{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // PS
D3DSIO_PHASE = $FFFD{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
{$ENDIF}
D3DSIO_COMMENT = $FFFE{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSIO_END = $FFFF{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSIO_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; // force 32-bit size enum
type TD3DShader_Instruction_Opcode_Type = TD3DShaderInstructionOpcodeType;
// Co-Issue Instruction Modifier - if set then this instruction is to be
// issued in parallel with the previous instruction(s) for which this bit
// is not set.
const
D3DSI_COISSUE = $40000000;
//
// Parameter Token Bit Definitions
//
{$IFDEF DX8}
D3DSP_REGNUM_MASK = $00000FFF;
{$ELSE}
D3DSP_REGNUM_MASK = $00001FFF;
{$ENDIF}
// destination parameter write mask
D3DSP_WRITEMASK_0 = $00010000; // Component 0 (X;Red)
D3DSP_WRITEMASK_1 = $00020000; // Component 1 (Y;Green)
D3DSP_WRITEMASK_2 = $00040000; // Component 2 (Z;Blue)
D3DSP_WRITEMASK_3 = $00080000; // Component 3 (W;Alpha)
D3DSP_WRITEMASK_ALL = $000F0000; // All Components
// destination parameter modifiers
D3DSP_DSTMOD_SHIFT = 20;
D3DSP_DSTMOD_MASK = $00F00000;
type TD3DShaderParamDSTModType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DSPDM_NONE = 0 shl D3DSP_DSTMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // nop
D3DSPDM_SATURATE = 1 shl D3DSP_DSTMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // clamp to 0. to 1. range
// destination parameter
D3DSP_DSTSHIFT_SHIFT = 24{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSP_DSTSHIFT_MASK = $0F000000{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
// destination/source parameter register type
D3DSP_REGTYPE_SHIFT = 28{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSP_REGTYPE_MASK = $70000000{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSPDM_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; // force 32-bit size enum
type TD3DShader_Param_DSTMod_Type = TD3DShaderParamDSTModType;
type TD3DShaderParamRegisterType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DSPR_TEMP = 0 shl LongWord(D3DSP_REGTYPE_SHIFT){$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Temporary Register File
D3DSPR_INPUT = 1 shl LongWord(D3DSP_REGTYPE_SHIFT){$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Input Register File
D3DSPR_CONST = 2 shl LongWord(D3DSP_REGTYPE_SHIFT){$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Constant Register File
D3DSPR_ADDR = 3 shl LongWord(D3DSP_REGTYPE_SHIFT){$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Address Register (VS)
D3DSPR_TEXTURE = 3 shl LongWord(D3DSP_REGTYPE_SHIFT){$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Texture Register File (PS)
D3DSPR_RASTOUT = 4 shl LongWord(D3DSP_REGTYPE_SHIFT){$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Rasterizer Register File
D3DSPR_ATTROUT = 5 shl LongWord(D3DSP_REGTYPE_SHIFT){$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Attribute Output Register File
D3DSPR_TEXCRDOUT = 6 shl LongWord(D3DSP_REGTYPE_SHIFT){$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Texture Coordinate Output Register File
D3DSPR_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; // force 32-bit size enum
type TD3DShader_Param_Register_Type = TD3DShaderParamRegisterType;
// Register offsets in the Rasterizer Register File
type TD3DVSRastOutOffsets = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DSRO_POSITION = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSRO_FOG = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSRO_POINT_SIZE = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSRO_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; // force 32-bit size enum
type TD3DVS_RastOut_Offsets = TD3DVSRastOutOffsets;
// Source operand addressing modes
const
D3DVS_ADDRESSMODE_SHIFT = 13;
D3DVS_ADDRESSMODE_MASK = 1 shl D3DVS_ADDRESSMODE_SHIFT;
type TD3DVSAddressModeType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DVS_ADDRMODE_ABSOLUTE = 0 shl D3DVS_ADDRESSMODE_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DVS_ADDRMODE_RELATIVE = 1 shl D3DVS_ADDRESSMODE_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Relative to register A0
D3DVS_ADDRMODE_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; // force 32-bit size enum
type TD3DVS_AddressMode_Type = TD3DVSAddressModeType;
const
// Source operand swizzle definitions
//
D3DVS_SWIZZLE_SHIFT = 16;
D3DVS_SWIZZLE_MASK = $00FF0000;
// The following bits define where to take component X from:
D3DVS_X_X = 0 shl D3DVS_SWIZZLE_SHIFT;
D3DVS_X_Y = 1 shl D3DVS_SWIZZLE_SHIFT;
D3DVS_X_Z = 2 shl D3DVS_SWIZZLE_SHIFT;
D3DVS_X_W = 3 shl D3DVS_SWIZZLE_SHIFT;
// The following bits define where to take component Y from:
D3DVS_Y_X = 0 shl (D3DVS_SWIZZLE_SHIFT + 2);
D3DVS_Y_Y = 1 shl (D3DVS_SWIZZLE_SHIFT + 2);
D3DVS_Y_Z = 2 shl (D3DVS_SWIZZLE_SHIFT + 2);
D3DVS_Y_W = 3 shl (D3DVS_SWIZZLE_SHIFT + 2);
// The following bits define where to take component Z from:
D3DVS_Z_X = 0 shl (D3DVS_SWIZZLE_SHIFT + 4);
D3DVS_Z_Y = 1 shl (D3DVS_SWIZZLE_SHIFT + 4);
D3DVS_Z_Z = 2 shl (D3DVS_SWIZZLE_SHIFT + 4);
D3DVS_Z_W = 3 shl (D3DVS_SWIZZLE_SHIFT + 4);
// The following bits define where to take component W from:
D3DVS_W_X = 0 shl (D3DVS_SWIZZLE_SHIFT + 6);
D3DVS_W_Y = 1 shl (D3DVS_SWIZZLE_SHIFT + 6);
D3DVS_W_Z = 2 shl (D3DVS_SWIZZLE_SHIFT + 6);
D3DVS_W_W = 3 shl (D3DVS_SWIZZLE_SHIFT + 6);
// Value when there is no swizzle (X is taken from X; Y is taken from Y;
// Z is taken from Z; W is taken from W
//
D3DVS_NOSWIZZLE = D3DVS_X_X or D3DVS_Y_Y or D3DVS_Z_Z or D3DVS_W_W;
// source parameter swizzle
D3DSP_SWIZZLE_SHIFT = 16;
D3DSP_SWIZZLE_MASK = $00FF0000;
D3DSP_NOSWIZZLE = (0 shl (D3DSP_SWIZZLE_SHIFT + 0)) or
(1 shl (D3DSP_SWIZZLE_SHIFT + 2)) or
(2 shl (D3DSP_SWIZZLE_SHIFT + 4)) or
(3 shl (D3DSP_SWIZZLE_SHIFT + 6));
// pixel-shader swizzle ops
{$IFNDEF DX8}
D3DSP_REPLICATERED = (0 shl (D3DSP_SWIZZLE_SHIFT + 0)) or
(0 shl (D3DSP_SWIZZLE_SHIFT + 2)) or
(0 shl (D3DSP_SWIZZLE_SHIFT + 4)) or
(0 shl (D3DSP_SWIZZLE_SHIFT + 6));
D3DSP_REPLICATEGREEN = (1 shl (D3DSP_SWIZZLE_SHIFT + 0)) or
(1 shl (D3DSP_SWIZZLE_SHIFT + 2)) or
(1 shl (D3DSP_SWIZZLE_SHIFT + 4)) or
(1 shl (D3DSP_SWIZZLE_SHIFT + 6));
D3DSP_REPLICATEBLUE = (2 shl (D3DSP_SWIZZLE_SHIFT + 0)) or
(2 shl (D3DSP_SWIZZLE_SHIFT + 2)) or
(2 shl (D3DSP_SWIZZLE_SHIFT + 4)) or
(2 shl (D3DSP_SWIZZLE_SHIFT + 6));
{$ENDIF}
D3DSP_REPLICATEALPHA = (3 shl (D3DSP_SWIZZLE_SHIFT + 0)) or
(3 shl (D3DSP_SWIZZLE_SHIFT + 2)) or
(3 shl (D3DSP_SWIZZLE_SHIFT + 4)) or
(3 shl (D3DSP_SWIZZLE_SHIFT + 6));
// source parameter modifiers
D3DSP_SRCMOD_SHIFT = 24;
D3DSP_SRCMOD_MASK = $0F000000;
type TD3DShaderParamSRCModType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DSPSM_NONE = 0 shl D3DSP_SRCMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // nop
D3DSPSM_NEG = 1 shl D3DSP_SRCMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // negate
D3DSPSM_BIAS = 2 shl D3DSP_SRCMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // bias
D3DSPSM_BIASNEG = 3 shl D3DSP_SRCMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // bias and negate
D3DSPSM_SIGN = 4 shl D3DSP_SRCMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // sign
D3DSPSM_SIGNNEG = 5 shl D3DSP_SRCMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // sign and negate
D3DSPSM_COMP = 6 shl D3DSP_SRCMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // complement
{$IFNDEF DX8}
D3DSPSM_X2 = 7 shl D3DSP_SRCMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // *2
D3DSPSM_X2NEG = 8 shl D3DSP_SRCMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // *2 and negate
D3DSPSM_DZ = 9 shl D3DSP_SRCMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // divide through by z component
D3DSPSM_DW = 10 shl D3DSP_SRCMOD_SHIFT{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // divide through by w component
{$ENDIF}
D3DSPSM_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; // force 32-bit size enum
type TD3DShader_Param_SRCMod_Type = TD3DShaderParamSRCModType;
// pixel shader version token
function D3DPS_VERSION(_Major, _Minor : LongWord) : LongWord;
// vertex shader version token
function D3DVS_VERSION(_Major, _Minor : LongWord) : LongWord;
// extract major/minor from version cap
function D3DSHADER_VERSION_MAJOR(_Version : LongWord) : LongWord;
function D3DSHADER_VERSION_MINOR(_Version : LongWord) : LongWord;
// destination/source parameter register type
const
D3DSI_COMMENTSIZE_SHIFT = 16;
D3DSI_COMMENTSIZE_MASK = $7FFF0000;
function D3DSHADER_COMMENT(_DWordSize : LongWord) : LongWord;
// pixel/vertex shader end token
const
D3DPS_END = $0000FFFF;
D3DVS_END = $0000FFFF;
//---------------------------------------------------------------------
// High order surfaces
//
type TD3DBasisType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DBASIS_BEZIER = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBASIS_BSPLINE = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBASIS_INTERPOLATE = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBASIS_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
type TD3DOrderType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DORDER_LINEAR = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
{$IFNDEF DX8}
D3DORDER_QUADRATIC = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
{$ENDIF}
D3DORDER_CUBIC = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DORDER_QUINTIC = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DORDER_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
type TD3DPatchEdgeStyle = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DPATCHEDGE_DISCRETE = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DPATCHEDGE_CONTINUOUS = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DPATCHEDGE_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
type TD3DStateBlockType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DSBT_ALL = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // capture all state
D3DSBT_PIXELSTATE = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // capture pixel state
D3DSBT_VERTEXSTATE = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // capture vertex state
D3DSBT_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
// The D3DVERTEXBLENDFLAGS type is used with D3DRS_VERTEXBLEND state.
//
type TD3DVertexBlendFlags = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DVBF_DISABLE = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // Disable vertex blending
D3DVBF_1WEIGHTS = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // 2 matrix blending
D3DVBF_2WEIGHTS = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // 3 matrix blending
D3DVBF_3WEIGHTS = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // 4 matrix blending
D3DVBF_TWEENING = 255{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // blending using D3DRS_TWEENFACTOR
D3DVBF_0WEIGHTS = 256{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // one matrix is used with weight 1.0
D3DVBF_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF}; // force 32-bit size enum
type TD3DTextureTransformFlags = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DTTFF_DISABLE = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // texture coordinates are passed directly
D3DTTFF_COUNT1 = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // rasterizer should expect 1-D texture coords
D3DTTFF_COUNT2 = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // rasterizer should expect 2-D texture coords
D3DTTFF_COUNT3 = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // rasterizer should expect 3-D texture coords
D3DTTFF_COUNT4 = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // rasterizer should expect 4-D texture coords
D3DTTFF_PROJECTED = 256{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // texcoords to be divided by COUNTth element
D3DTTFF_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
// Macros to set texture coordinate format bits in the FVF id
const
D3DFVF_TEXTUREFORMAT2 = 0; // Two floating point values
D3DFVF_TEXTUREFORMAT1 = 3; // One floating point value
D3DFVF_TEXTUREFORMAT3 = 1; // Three floating point values
D3DFVF_TEXTUREFORMAT4 = 2; // Four floating point values
function D3DFVF_TEXCOORDSIZE3(CoordIndex : LongWord) : LongWord;
function D3DFVF_TEXCOORDSIZE2(CoordIndex : LongWord) : LongWord;
function D3DFVF_TEXCOORDSIZE4(CoordIndex : LongWord) : LongWord;
function D3DFVF_TEXCOORDSIZE1(CoordIndex : LongWord) : LongWord;
//---------------------------------------------------------------------
(* Direct3D8 Device types *)
type TD3DDevType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DDEVTYPE_HAL = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DDEVTYPE_REF = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DDEVTYPE_SW = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DDEVTYPE_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
(* Multi-Sample buffer types *)
type TD3DMultiSampleType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DMULTISAMPLE_NONE = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_2_SAMPLES = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_3_SAMPLES = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_4_SAMPLES = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_5_SAMPLES = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_6_SAMPLES = 6{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_7_SAMPLES = 7{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_8_SAMPLES = 8{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_9_SAMPLES = 9{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_10_SAMPLES = 10{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_11_SAMPLES = 11{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_12_SAMPLES = 12{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_13_SAMPLES = 13{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_14_SAMPLES = 14{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_15_SAMPLES = 15{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_16_SAMPLES = 16{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DMULTISAMPLE_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
type TD3DMultiSample_Type = TD3DMultiSampleType;
(* Formats
* Most of these names have the following convention:
* A = Alpha
* R = Red
* G = Green
* B = Blue
* X = Unused Bits
* P = Palette
* L = Luminance
* U = dU coordinate for BumpMap
* V = dV coordinate for BumpMap
* S = Stencil
* D = Depth (e.g. Z or W buffer)
*
* Further; the order of the pieces are from MSB first; hence
* D3DFMT_A8L8 indicates that the high byte of this two byte
* format is alpha.
*
* D16 indicates:
* - An integer 16-bit value.
* - An app-lockable surface.
*
* All Depth/Stencil formats except D3DFMT_D16_LOCKABLE indicate:
* - no particular bit ordering per pixel; and
* - are not app lockable; and
* - the driver is allowed to consume more than the indicated
* number of bits per Depth channel (but not Stencil channel).
*)
function MAKEFOURCC(ch0, ch1, ch2, ch3 : Char) : LongWord;
type PD3DFormat = ^TD3DFormat;
TD3DFormat = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DFMT_UNKNOWN = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_R8G8B8 = 20{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_A8R8G8B8 = 21{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_X8R8G8B8 = 22{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_R5G6B5 = 23{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_X1R5G5B5 = 24{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_A1R5G5B5 = 25{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_A4R4G4B4 = 26{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_R3G3B2 = 27{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_A8 = 28{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_A8R3G3B2 = 29{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_X4R4G4B4 = 30{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
{$IFNDEF DX8}
D3DFMT_A2B10G10R10 = 31{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_G16R16 = 34{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
{$ENDIF}
D3DFMT_A8P8 = 40{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_P8 = 41{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_L8 = 50{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_A8L8 = 51{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_A4L4 = 52{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_V8U8 = 60{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_L6V5U5 = 61{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_X8L8V8U8 = 62{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_Q8W8V8U8 = 63{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_V16U16 = 64{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_W11V11U10 = 65{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
{$IFNDEF DX8}
D3DFMT_A2W10V10U10 = 67{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
{$ENDIF}
D3DFMT_UYVY = Byte('U') or (Byte('Y') shl 8) or (Byte('V') shl 16) or (Byte('Y') shl 24 ){$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_YUY2 = Byte('Y') or (Byte('U') shl 8) or (Byte('Y') shl 16) or (Byte('2') shl 24 ){$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_DXT1 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('1') shl 24 ){$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_DXT2 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('2') shl 24 ){$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_DXT3 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('3') shl 24 ){$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_DXT4 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('4') shl 24 ){$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_DXT5 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('5') shl 24 ){$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_D16_LOCKABLE = 70{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_D32 = 71{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_D15S1 = 73{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_D24S8 = 75{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_D16 = 80{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_D24X8 = 77{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_D24X4S4 = 79{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_VERTEXDATA = 100{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_INDEX16 = 101{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_INDEX32 = 102{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DFMT_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
(* Display Modes *)
type
PD3DDisplayMode = ^TD3DDisplayMode;
TD3DDisplayMode = packed record
Width : Cardinal;
Height : Cardinal;
RefreshRate : Cardinal;
Format : TD3DFormat;
end;
(* Creation Parameters *)
PD3DDevice_Creation_Parameters = ^TD3DDevice_Creation_Parameters;
TD3DDevice_Creation_Parameters = packed record
AdapterOrdinal : Cardinal;
DeviceType : TD3DDevType;
hFocusWindow : HWND;
BehaviorFlags : LongWord;
end;
PD3DDeviceCreationParameters = ^TD3DDeviceCreationParameters;
TD3DDeviceCreationParameters = TD3DDevice_Creation_Parameters;
(* SwapEffects *)
type TD3DSwapEffect = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DSWAPEFFECT_DISCARD = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSWAPEFFECT_FLIP = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSWAPEFFECT_COPY = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSWAPEFFECT_COPY_VSYNC = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DSWAPEFFECT_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
(* Pool types *)
type TD3DPool = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DPOOL_DEFAULT = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DPOOL_MANAGED = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DPOOL_SYSTEMMEM = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
{$IFNDEF DX8}
D3DPOOL_SCRATCH = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
{$ENDIF}
D3DPOOL_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
const
(* RefreshRate pre-defines *)
D3DPRESENT_RATE_DEFAULT = $00000000;
D3DPRESENT_RATE_UNLIMITED = $7fffffff;
(* Resize Optional Parameters *)
type
PD3DPresent_Parameters = ^TD3DPresent_Parameters;
TD3DPresent_Parameters = packed record
BackBufferWidth : Cardinal;
BackBufferHeight : Cardinal;
BackBufferFormat : TD3DFormat;
BackBufferCount : Cardinal;
MultiSampleType : TD3DMultiSample_Type;
SwapEffect : TD3DSwapEffect;
hDeviceWindow : HWND;
Windowed : BOOL;
EnableAutoDepthStencil : BOOL;
AutoDepthStencilFormat : TD3DFormat;
Flags : LongWord;
(* Following elements must be zero for Windowed mode *)
FullScreen_RefreshRateInHz : Cardinal;
FullScreen_PresentationInterval : Cardinal;
end;
PD3DPresentParameters = ^TD3DPresentParameters;
TD3DPresentParameters = TD3DPresent_Parameters;
// Values for D3DPRESENT_PARAMETERS.Flags
const
D3DPRESENTFLAG_LOCKABLE_BACKBUFFER = $00000001;
(* Gamma Ramp: Same as DX7 *)
type
PD3DGammaRamp = ^TD3DGammaRamp;
TD3DGammaRamp = packed record
red : array [0..255] of Word;
green : array [0..255] of Word;
blue : array [0..255] of Word;
end;
(* Back buffer types *)
type TD3DBackBufferType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DBACKBUFFER_TYPE_MONO = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBACKBUFFER_TYPE_LEFT = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBACKBUFFER_TYPE_RIGHT = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DBACKBUFFER_TYPE_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
type TD3DBackBuffer_Type = TD3DBackBufferType;
(* Types *)
type TD3DResourceType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DRTYPE_SURFACE = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRTYPE_VOLUME = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRTYPE_TEXTURE = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRTYPE_VOLUMETEXTURE = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRTYPE_CUBETEXTURE = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRTYPE_VERTEXBUFFER = 6{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRTYPE_INDEXBUFFER = 7{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DRTYPE_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
const
(* Usages *)
D3DUSAGE_RENDERTARGET = $00000001;
D3DUSAGE_DEPTHSTENCIL = $00000002;
(* Usages for Vertex/Index buffers *)
D3DUSAGE_WRITEONLY = $00000008;
D3DUSAGE_SOFTWAREPROCESSING = $00000010;
D3DUSAGE_DONOTCLIP = $00000020;
D3DUSAGE_POINTS = $00000040;
D3DUSAGE_RTPATCHES = $00000080;
D3DUSAGE_NPATCHES = $00000100;
D3DUSAGE_DYNAMIC = $00000200;
(* CubeMap Face identifiers *)
type TD3DCubeMapFaces = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DCUBEMAP_FACE_POSITIVE_X = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCUBEMAP_FACE_NEGATIVE_X = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCUBEMAP_FACE_POSITIVE_Y = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCUBEMAP_FACE_NEGATIVE_Y = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCUBEMAP_FACE_POSITIVE_Z = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCUBEMAP_FACE_NEGATIVE_Z = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}
D3DCUBEMAP_FACE_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
type TD3DCubeMap_Faces = TD3DCubeMapFaces;
const
(* Lock flags *)
D3DLOCK_READONLY = $00000010;
D3DLOCK_DISCARD = $00002000;
D3DLOCK_NOOVERWRITE = $00001000;
D3DLOCK_NOSYSLOCK = $00000800;
D3DLOCK_NO_DIRTY_UPDATE = $00008000;
(* Vertex Buffer Description *)
type
PD3DVertexBuffer_Desc = ^TD3DVertexBuffer_Desc;
TD3DVertexBuffer_Desc = packed record
Format : TD3DFormat;
_Type : TD3DResourceType;
Usage : LongWord;
Pool : TD3DPool;
Size : Cardinal;
FVF : LongWord;
end;
PD3DVertexBufferDesc = ^TD3DVertexBufferDesc;
TD3DVertexBufferDesc = TD3DVertexBuffer_Desc;
(* Index Buffer Description *)
PTD3DIndexBuffer_Desc = ^TD3DIndexBuffer_Desc;
TD3DIndexBuffer_Desc = packed record
Format : TD3DFormat;
_Type : TD3DResourceType;
Usage : LongWord;
Pool : TD3DPool;
Size : Cardinal;
end;
PTD3DIndexBufferDesc = ^TD3DIndexBufferDesc;
TD3DIndexBufferDesc = TD3DIndexBuffer_Desc;
(* Surface Description *)
PD3DSurface_Desc = ^TD3DSurface_Desc;
TD3DSurface_Desc = packed record
Format : TD3DFormat;
_Type : TD3DResourceType;
Usage : LongWord;
Pool : TD3DPool;
Size : Cardinal;
MultiSampleType : TD3DMultiSample_Type;
Width : Cardinal;
Height : Cardinal;
end;
PD3DSurfaceDesc = ^TD3DSurfaceDesc;
TD3DSurfaceDesc = TD3DSurface_Desc;
PD3DVolume_Desc = ^TD3DVolume_Desc;
TD3DVolume_Desc = packed record
Format : TD3DFormat;
_Type : TD3DResourceType;
Usage : LongWord;
Pool : TD3DPool;
Size : Cardinal;
Width : Cardinal;
Height : Cardinal;
Depth : Cardinal;
end;
PD3DVolumeDesc = ^TD3DVolumeDesc;
TD3DVolumeDesc = TD3DVolume_Desc;
(* Structure for LockRect *)
PD3DLocked_Rect = ^TD3DLocked_Rect;
TD3DLocked_Rect = packed record
Pitch : Integer;
pBits : Pointer;//void*
end;
PD3DLockedRect = ^TD3DLockedRect;
TD3DLockedRect = TD3DLocked_Rect;
(* Structures for LockBox *)
PD3DBox = ^TD3DBox;
TD3DBox = packed record
Left : Cardinal;
Top : Cardinal;
Right : Cardinal;
Bottom : Cardinal;
Front : Cardinal;
Back : Cardinal;
end;
PD3DLocked_Box = ^TD3DLocked_Box;
TD3DLocked_Box = packed record
RowPitch : Integer;
SlicePitch : Integer;
pBits : Pointer;
end;
PD3DLockedBox = ^TD3DLockedBox;
TD3DLockedBox = TD3DLocked_Box;
(* Structures for LockRange *)
PD3DRange = ^TD3DRange;
TD3DRange = packed record
Offset : Cardinal;
Size : Cardinal;
end;
(* Structures for high order primitives *)
PD3DRectPatch_Info = ^TD3DRectPatch_Info;
TD3DRectPatch_Info = packed record
StartVertexOffsetWidth : Cardinal;
StartVertexOffsetHeight : Cardinal;
Width : Cardinal;
Height : Cardinal;
Stride : Cardinal;
Basis : TD3DBasisType;
Order : TD3DOrderType;
end;
PD3DRectPatchInfo = ^TD3DRectPatchInfo;
TD3DRectPatchInfo = TD3DRectPatch_Info;
PD3DTriPatch_Info = ^TD3DTriPatch_Info;
TD3DTriPatch_Info = packed record
StartVertexOffset : Cardinal;
NumVertices : Cardinal;
Basis : TD3DBasisType;
Order : TD3DOrderType;
end;
PD3DTriPatchInfo = ^TD3DTriPatchInfo;
TD3DTriPatchInfo = TD3DTriPatch_Info;
(* Adapter Identifier *)
const
MAX_DEVICE_IDENTIFIER_STRING = 512;
type
PD3DAdapter_Identifier8 = ^TD3DAdapter_Identifier8;
TD3DAdapter_Identifier8 = packed record
Driver : array [0..MAX_DEVICE_IDENTIFIER_STRING - 1] of Char;
Description : array [0..MAX_DEVICE_IDENTIFIER_STRING - 1] of Char;
DriverVersionLowPart : LongWord; (* Defined for 16 bit driver components *)
DriverVersionHighPart : LongWord;
VendorId : LongWord;
DeviceId : LongWord;
SubSysId : LongWord;
Revision : LongWord;
DeviceIdentifier : TGUID;
WHQLLevel : LongWord;
end;
PD3DAdapterIdentifier8 = ^TD3DAdapterIdentifier8;
TD3DAdapterIdentifier8 = TD3DAdapter_Identifier8;
(* Raster Status structure returned by GetRasterStatus *)
PD3DRaster_Status = ^TD3DRaster_Status;
TD3DRaster_Status = packed record
InVBlank : Bool;
ScanLine : Cardinal;
end;
PD3DRasterStatus = ^TD3DRasterStatus;
TD3DRasterStatus = TD3DRaster_Status;
(* Debug monitor tokens (DEBUG only)
Note that if D3DRS_DEBUGMONITORTOKEN is set; the call is treated as
passing a token to the debug monitor. For example; if; after passing
D3DDMT_ENABLE/DISABLE to D3DRS_DEBUGMONITORTOKEN other token values
are passed in; the enabled/disabled state of the debug
monitor will still persist.
The debug monitor defaults to enabled.
Calling GetRenderState on D3DRS_DEBUGMONITORTOKEN is not of any use.
*)
type TD3DDebugMonitorTokens = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
D3DDMT_ENABLE = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // enable debug monitor
D3DDMT_DISABLE = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF} // disable debug monitor
D3DDMT_FORCE_DWORD = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};
{$IFNDEF DX8}
// GetInfo IDs
const
D3DDEVINFOID_RESOURCEMANAGER = 5; (* Used with D3DDEVINFO_RESOURCEMANAGER *)
D3DDEVINFOID_VERTEXSTATS = 6; (* Used with D3DDEVINFO_D3DVERTEXSTATS *)
type
PD3DResourceStats = ^TD3DResourceStats;
TD3DResourceStats = packed record
// Data collected since last Present()
bThrashing : LongBool; (* indicates if thrashing *)
ApproxBytesDownloaded : LongWord; (* Approximate number of bytes downloaded by resource manager *)
NumEvicts : LongWord; (* number of objects evicted *)
NumVidCreates : LongWord; (* number of objects created in video memory *)
LastPri : LongWord; (* priority of last object evicted *)
NumUsed : LongWord; (* number of objects set to the device *)
NumUsedInVidMem : LongWord; (* number of objects set to the device, which are already in video memory *)
// Persistent data
WorkingSet : LongWord; (* number of objects in video memory *)
WorkingSetBytes : LongWord; (* number of bytes in video memory *)
TotalManaged : LongWord; (* total number of managed objects *)
TotalBytes : LongWord; (* total number of bytes of managed objects *)
end;
const D3DRTYPECOUNT = LongWord(D3DRTYPE_INDEXBUFFER) + 1;
type
PD3DDevInfo_ResourceManager = ^TD3DDevInfo_ResourceManager;
TD3DDevInfo_ResourceManager = packed record
stats : array [0..D3DRTYPECOUNT - 1] of TD3DResourceStats;
end;
PD3DDevInfoResourceManager = ^TD3DDevInfoResourceManager;
TD3DDevInfoResourceManager = TD3DDevInfo_ResourceManager;
type
PD3DDevInfo_D3DVertexStats = ^TD3DDevInfo_D3DVertexStats;
TD3DDevInfo_D3DVertexStats = packed record
NumRenderedTriangles : LongWord; (* total number of triangles that are not clipped in this frame *)
NumExtraClippingTriangles : LongWord; (* Number of new triangles generated by clipping *)
end;
PD3DDevInfoD3DVertexStats = ^TD3DDevInfoD3DVertexStats;
TD3DDevInfoD3DVertexStats = TD3DDevInfo_D3DVertexStats;
{$ENDIF}
(*==========================================================================;
*
* Copyright (C) 1995-2000 Microsoft Corporation. All Rights Reserved.
*
* File: d3d8caps.h
* Content: Direct3D capabilities include file
*
***************************************************************************)
type
PD3DCaps8 = ^TD3DCaps8;
TD3DCaps8 = packed record
(* Device Info *)
DeviceType : TD3DDevType;
AdapterOrdinal : LongWord;
(* Caps from DX7 Draw *)
Caps : LongWord;
Caps2 : LongWord;
Caps3 : LongWord;
PresentationIntervals : LongWord;
(* Cursor Caps *)
CursorCaps : LongWord;
(* 3D Device Caps *)
DevCaps : LongWord;
PrimitiveMiscCaps : LongWord;
RasterCaps : LongWord;
ZCmpCaps : LongWord;
SrcBlendCaps : LongWord;
DestBlendCaps : LongWord;
AlphaCmpCaps : LongWord;
ShadeCaps : LongWord;
TextureCaps : LongWord;
TextureFilterCaps : LongWord; // D3DPTFILTERCAPS for IDirect3DTexture8's
CubeTextureFilterCaps : LongWord; // D3DPTFILTERCAPS for IDirect3DCubeTexture8's
VolumeTextureFilterCaps : LongWord; // D3DPTFILTERCAPS for IDirect3DVolumeTexture8's
TextureAddressCaps : LongWord; // D3DPTADDRESSCAPS for IDirect3DTexture8's
VolumeTextureAddressCaps : LongWord; // D3DPTADDRESSCAPS for IDirect3DVolumeTexture8's
LineCaps : LongWord; // D3DLINECAPS
MaxTextureWidth : LongWord;
MaxTextureHeight : LongWord;
MaxVolumeExtent : LongWord;
MaxTextureRepeat : LongWord;
MaxTextureAspectRatio : LongWord;
MaxAnisotropy : LongWord;
MaxVertexW : Single;
GuardBandLeft : Single;
GuardBandTop : Single;
GuardBandRight : Single;
GuardBandBottom : Single;
ExtentsAdjust : Single;
StencilCaps : LongWord;
FVFCaps : LongWord;
TextureOpCaps : LongWord;
MaxTextureBlendStages : LongWord;
MaxSimultaneousTextures : LongWord;
VertexProcessingCaps : LongWord;
MaxActiveLights : LongWord;
MaxUserClipPlanes : LongWord;
MaxVertexBlendMatrices : LongWord;
MaxVertexBlendMatrixIndex : LongWord;
MaxPointSize : Single;
MaxPrimitiveCount : LongWord; // max number of primitives per DrawPrimitive call
MaxVertexIndex : LongWord;
MaxStreams : LongWord;
MaxStreamStride : LongWord; // max stride for SetStreamSource
VertexShaderVersion : LongWord;
MaxVertexShaderConst : LongWord; // number of vertex shader constant registers
PixelShaderVersion : LongWord;
MaxPixelShaderValue : Single; // max value of pixel shader arithmetic component
end;
//
// BIT DEFINES FOR D3DCAPS8 DWORD MEMBERS
//
//
// Caps
//
const
D3DCAPS_READ_SCANLINE = $00020000;
//
// Caps2
//
D3DCAPS2_NO2DDURING3DSCENE = $00000002;
D3DCAPS2_FULLSCREENGAMMA = $00020000;
D3DCAPS2_CANRENDERWINDOWED = $00080000;
D3DCAPS2_CANCALIBRATEGAMMA = $00100000;
D3DCAPS2_RESERVED = $02000000;
{$IFNDEF DX8}
D3DCAPS2_CANMANAGERESOURCE = $10000000;
D3DCAPS2_DYNAMICTEXTURES = $20000000;
{$ENDIF}
//
// Caps3
//
D3DCAPS3_RESERVED = $8000001f;
{$IFNDEF DX8}
// Indicates that the device can respect the ALPHABLENDENABLE render state
// when fullscreen while using the FLIP or DISCARD swap effect.
// COPY and COPYVSYNC swap effects work whether or not this flag is set.
D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD = $00000020;
{$ENDIF}
//
// PresentationIntervals
//
D3DPRESENT_INTERVAL_DEFAULT = $00000000;
D3DPRESENT_INTERVAL_ONE = $00000001;
D3DPRESENT_INTERVAL_TWO = $00000002;
D3DPRESENT_INTERVAL_THREE = $00000004;
D3DPRESENT_INTERVAL_FOUR = $00000008;
D3DPRESENT_INTERVAL_IMMEDIATE = $80000000;
//
// CursorCaps
//
// Driver supports HW color cursor in at least hi-res modes(height >=400)
D3DCURSORCAPS_COLOR = $00000001;
// Driver supports HW cursor also in low-res modes(height < 400)
D3DCURSORCAPS_LOWRES = $00000002;
//
// DevCaps
//
D3DDEVCAPS_EXECUTESYSTEMMEMORY = $00000010; (* Device can use execute buffers from system memory *)
D3DDEVCAPS_EXECUTEVIDEOMEMORY = $00000020; (* Device can use execute buffers from video memory *)
D3DDEVCAPS_TLVERTEXSYSTEMMEMORY = $00000040; (* Device can use TL buffers from system memory *)
D3DDEVCAPS_TLVERTEXVIDEOMEMORY = $00000080; (* Device can use TL buffers from video memory *)
D3DDEVCAPS_TEXTURESYSTEMMEMORY = $00000100; (* Device can texture from system memory *)
D3DDEVCAPS_TEXTUREVIDEOMEMORY = $00000200; (* Device can texture from device memory *)
D3DDEVCAPS_DRAWPRIMTLVERTEX = $00000400; (* Device can draw TLVERTEX primitives *)
D3DDEVCAPS_CANRENDERAFTERFLIP = $00000800; (* Device can render without waiting for flip to complete *)
D3DDEVCAPS_TEXTURENONLOCALVIDMEM = $00001000; (* Device can texture from nonlocal video memory *)
D3DDEVCAPS_DRAWPRIMITIVES2 = $00002000; (* Device can support DrawPrimitives2 *)
D3DDEVCAPS_SEPARATETEXTUREMEMORIES = $00004000; (* Device is texturing from separate memory pools *)
D3DDEVCAPS_DRAWPRIMITIVES2EX = $00008000; (* Device can support Extended DrawPrimitives2 i.e. DX7 compliant driver*)
D3DDEVCAPS_HWTRANSFORMANDLIGHT = $00010000; (* Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also *)
D3DDEVCAPS_CANBLTSYSTONONLOCAL = $00020000; (* Device supports a Tex Blt from system memory to non-local vidmem *)
D3DDEVCAPS_HWRASTERIZATION = $00080000; (* Device has HW acceleration for rasterization *)
D3DDEVCAPS_PUREDEVICE = $00100000; (* Device supports D3DCREATE_PUREDEVICE *)
D3DDEVCAPS_QUINTICRTPATCHES = $00200000; (* Device supports quintic Beziers and BSplines *)
D3DDEVCAPS_RTPATCHES = $00400000; (* Device supports Rect and Tri patches *)
D3DDEVCAPS_RTPATCHHANDLEZERO = $00800000; (* Indicates that RT Patches may be drawn efficiently using handle 0 *)
D3DDEVCAPS_NPATCHES = $01000000; (* Device supports N-Patches *)
//
// PrimitiveMiscCaps
//
D3DPMISCCAPS_MASKZ = $00000002;
D3DPMISCCAPS_LINEPATTERNREP = $00000004;
D3DPMISCCAPS_CULLNONE = $00000010;
D3DPMISCCAPS_CULLCW = $00000020;
D3DPMISCCAPS_CULLCCW = $00000040;
D3DPMISCCAPS_COLORWRITEENABLE = $00000080;
D3DPMISCCAPS_CLIPPLANESCALEDPOINTS = $00000100; (* Device correctly clips scaled points to clip planes *)
D3DPMISCCAPS_CLIPTLVERTS = $00000200; (* device will clip post-transformed vertex primitives *)
D3DPMISCCAPS_TSSARGTEMP = $00000400; (* device supports D3DTA_TEMP for temporary register *)
D3DPMISCCAPS_BLENDOP = $00000800; (* device supports D3DRS_BLENDOP *)
{$IFNDEF DX8}
D3DPMISCCAPS_NULLREFERENCE = $00001000; (* Reference Device that doesnt render *)
{$ENDIF}
//
// LineCaps
//
D3DLINECAPS_TEXTURE = $00000001;
D3DLINECAPS_ZTEST = $00000002;
D3DLINECAPS_BLEND = $00000004;
D3DLINECAPS_ALPHACMP = $00000008;
D3DLINECAPS_FOG = $00000010;
//
// RasterCaps
//
D3DPRASTERCAPS_DITHER = $00000001;
D3DPRASTERCAPS_PAT = $00000008;
D3DPRASTERCAPS_ZTEST = $00000010;
D3DPRASTERCAPS_FOGVERTEX = $00000080;
D3DPRASTERCAPS_FOGTABLE = $00000100;
D3DPRASTERCAPS_ANTIALIASEDGES = $00001000;
D3DPRASTERCAPS_MIPMAPLODBIAS = $00002000;
D3DPRASTERCAPS_ZBIAS = $00004000;
D3DPRASTERCAPS_ZBUFFERLESSHSR = $00008000;
D3DPRASTERCAPS_FOGRANGE = $00010000;
D3DPRASTERCAPS_ANISOTROPY = $00020000;
D3DPRASTERCAPS_WBUFFER = $00040000;
D3DPRASTERCAPS_WFOG = $00100000;
D3DPRASTERCAPS_ZFOG = $00200000;
D3DPRASTERCAPS_COLORPERSPECTIVE = $00400000; (* Device iterates colors perspective correct *)
D3DPRASTERCAPS_STRETCHBLTMULTISAMPLE = $00800000;
//
// ZCmpCaps, AlphaCmpCaps
//
D3DPCMPCAPS_NEVER = $00000001;
D3DPCMPCAPS_LESS = $00000002;
D3DPCMPCAPS_EQUAL = $00000004;
D3DPCMPCAPS_LESSEQUAL = $00000008;
D3DPCMPCAPS_GREATER = $00000010;
D3DPCMPCAPS_NOTEQUAL = $00000020;
D3DPCMPCAPS_GREATEREQUAL = $00000040;
D3DPCMPCAPS_ALWAYS = $00000080;
//
// SourceBlendCaps, DestBlendCaps
//
D3DPBLENDCAPS_ZERO = $00000001;
D3DPBLENDCAPS_ONE = $00000002;
D3DPBLENDCAPS_SRCCOLOR = $00000004;
D3DPBLENDCAPS_INVSRCCOLOR = $00000008;
D3DPBLENDCAPS_SRCALPHA = $00000010;
D3DPBLENDCAPS_INVSRCALPHA = $00000020;
D3DPBLENDCAPS_DESTALPHA = $00000040;
D3DPBLENDCAPS_INVDESTALPHA = $00000080;
D3DPBLENDCAPS_DESTCOLOR = $00000100;
D3DPBLENDCAPS_INVDESTCOLOR = $00000200;
D3DPBLENDCAPS_SRCALPHASAT = $00000400;
D3DPBLENDCAPS_BOTHSRCALPHA = $00000800;
D3DPBLENDCAPS_BOTHINVSRCALPHA = $00001000;
//
// ShadeCaps
//
D3DPSHADECAPS_COLORGOURAUDRGB = $00000008;
D3DPSHADECAPS_SPECULARGOURAUDRGB = $00000200;
D3DPSHADECAPS_ALPHAGOURAUDBLEND = $00004000;
D3DPSHADECAPS_FOGGOURAUD = $00080000;
//
// TextureCaps
//
D3DPTEXTURECAPS_PERSPECTIVE = $00000001; (* Perspective-correct texturing is supported *)
D3DPTEXTURECAPS_POW2 = $00000002; (* Power-of-2 texture dimensions are required - applies to non-Cube/Volume textures only. *)
D3DPTEXTURECAPS_ALPHA = $00000004; (* Alpha in texture pixels is supported *)
D3DPTEXTURECAPS_SQUAREONLY = $00000020; (* Only square textures are supported *)
D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE = $00000040; (* Texture indices are not scaled by the texture size prior to interpolation *)
D3DPTEXTURECAPS_ALPHAPALETTE = $00000080; (* Device can draw alpha from texture palettes *)
// Device can use non-POW2 textures if:
// 1) D3DTEXTURE_ADDRESS is set to CLAMP for this texture's stage
// 2) D3DRS_WRAP(N) is zero for this texture's coordinates
// 3) mip mapping is not enabled (use magnification filter only)
D3DPTEXTURECAPS_NONPOW2CONDITIONAL = $00000100;
D3DPTEXTURECAPS_PROJECTED = $00000400; (* Device can do D3DTTFF_PROJECTED *)
D3DPTEXTURECAPS_CUBEMAP = $00000800; (* Device can do cubemap textures *)
D3DPTEXTURECAPS_VOLUMEMAP = $00002000; (* Device can do volume textures *)
D3DPTEXTURECAPS_MIPMAP = $00004000; (* Device can do mipmapped textures *)
D3DPTEXTURECAPS_MIPVOLUMEMAP = $00008000; (* Device can do mipmapped volume textures *)
D3DPTEXTURECAPS_MIPCUBEMAP = $00010000; (* Device can do mipmapped cube maps *)
D3DPTEXTURECAPS_CUBEMAP_POW2 = $00020000; (* Device requires that cubemaps be power-of-2 dimension *)
D3DPTEXTURECAPS_VOLUMEMAP_POW2 = $00040000; (* Device requires that volume maps be power-of-2 dimension *)
//
// TextureFilterCaps
//
D3DPTFILTERCAPS_MINFPOINT = $00000100; (* Min Filter *)
D3DPTFILTERCAPS_MINFLINEAR = $00000200;
D3DPTFILTERCAPS_MINFANISOTROPIC = $00000400;
D3DPTFILTERCAPS_MIPFPOINT = $00010000; (* Mip Filter *)
D3DPTFILTERCAPS_MIPFLINEAR = $00020000;
D3DPTFILTERCAPS_MAGFPOINT = $01000000; (* Mag Filter *)
D3DPTFILTERCAPS_MAGFLINEAR = $02000000;
D3DPTFILTERCAPS_MAGFANISOTROPIC = $04000000;
D3DPTFILTERCAPS_MAGFAFLATCUBIC = $08000000;
D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC = $10000000;
//
// TextureAddressCaps
//
D3DPTADDRESSCAPS_WRAP = $00000001;
D3DPTADDRESSCAPS_MIRROR = $00000002;
D3DPTADDRESSCAPS_CLAMP = $00000004;
D3DPTADDRESSCAPS_BORDER = $00000008;
D3DPTADDRESSCAPS_INDEPENDENTUV = $00000010;
D3DPTADDRESSCAPS_MIRRORONCE = $00000020;
//
// StencilCaps
//
D3DSTENCILCAPS_KEEP = $00000001;
D3DSTENCILCAPS_ZERO = $00000002;
D3DSTENCILCAPS_REPLACE = $00000004;
D3DSTENCILCAPS_INCRSAT = $00000008;
D3DSTENCILCAPS_DECRSAT = $00000010;
D3DSTENCILCAPS_INVERT = $00000020;
D3DSTENCILCAPS_INCR = $00000040;
D3DSTENCILCAPS_DECR = $00000080;
//
// TextureOpCaps
//
D3DTEXOPCAPS_DISABLE = $00000001;
D3DTEXOPCAPS_SELECTARG1 = $00000002;
D3DTEXOPCAPS_SELECTARG2 = $00000004;
D3DTEXOPCAPS_MODULATE = $00000008;
D3DTEXOPCAPS_MODULATE2X = $00000010;
D3DTEXOPCAPS_MODULATE4X = $00000020;
D3DTEXOPCAPS_ADD = $00000040;
D3DTEXOPCAPS_ADDSIGNED = $00000080;
D3DTEXOPCAPS_ADDSIGNED2X = $00000100;
D3DTEXOPCAPS_SUBTRACT = $00000200;
D3DTEXOPCAPS_ADDSMOOTH = $00000400;
D3DTEXOPCAPS_BLENDDIFFUSEALPHA = $00000800;
D3DTEXOPCAPS_BLENDTEXTUREALPHA = $00001000;
D3DTEXOPCAPS_BLENDFACTORALPHA = $00002000;
D3DTEXOPCAPS_BLENDTEXTUREALPHAPM = $00004000;
D3DTEXOPCAPS_BLENDCURRENTALPHA = $00008000;
D3DTEXOPCAPS_PREMODULATE = $00010000;
D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR = $00020000;
D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA = $00040000;
D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR = $00080000;
D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA = $00100000;
D3DTEXOPCAPS_BUMPENVMAP = $00200000;
D3DTEXOPCAPS_BUMPENVMAPLUMINANCE = $00400000;
D3DTEXOPCAPS_DOTPRODUCT3 = $00800000;
D3DTEXOPCAPS_MULTIPLYADD = $01000000;
D3DTEXOPCAPS_LERP = $02000000;
//
// FVFCaps
//
D3DFVFCAPS_TEXCOORDCOUNTMASK = $0000ffff; (* mask for texture coordinate count field *)
D3DFVFCAPS_DONOTSTRIPELEMENTS = $00080000; (* Device prefers that vertex elements not be stripped *)
D3DFVFCAPS_PSIZE = $00100000; (* Device can receive point size *)
//
// VertexProcessingCaps
//
D3DVTXPCAPS_TEXGEN = $00000001; (* device can do texgen *)
D3DVTXPCAPS_MATERIALSOURCE7 = $00000002; (* device can do DX7-level colormaterialsource ops *)
D3DVTXPCAPS_DIRECTIONALLIGHTS = $00000008; (* device can do directional lights *)
D3DVTXPCAPS_POSITIONALLIGHTS = $00000010; (* device can do positional lights (includes point and spot) *)
D3DVTXPCAPS_LOCALVIEWER = $00000020; (* device can do local viewer *)
D3DVTXPCAPS_TWEENING = $00000040; (* device can do vertex tweening *)
D3DVTXPCAPS_NO_VSDT_UBYTE4 = $00000080; (* device does not support D3DVSDT_UBYTE4 *)
(*==========================================================================;
*
*
* File: d3d8.h
* Content: Direct3D include file
*
****************************************************************************)
(* This identifier is passed to Direct3DCreate8 in order to ensure that an
* application was built against the correct header files. This number is
* incremented whenever a header (or other) change would require applications
* to be rebuilt. If the version doesn't match, Direct3DCreate8 will fail.
* (The number itself has no meaning.)*)
const
{$IFDEF DX8}
D3D_SDK_VERSION = 120;
{$ELSE}
D3D_SDK_VERSION = 220;
{$ENDIF}
type
HMonitor = THandle;
const
IID_IDirect3D8 : TGUID = '{1DD9E8DA-1C77-4d40-B0CF-98FEFDFF9512}';
IID_IDirect3DDevice8 : TGUID = '{7385E5DF-8FE8-41D5-86B6-D7B48547B6CF}';
IID_IDirect3DResource8 : TGUID = '{1B36BB7B-09B7-410a-B445-7D1430D7B33F}';
IID_IDirect3DBaseTexture8 : TGUID = '{B4211CFA-51B9-4a9f-AB78-DB99B2BB678E}';
IID_IDirect3DTexture8 : TGUID = '{E4CDD575-2866-4f01-B12E-7EECE1EC9358}';
IID_IDirect3DCubeTexture8 : TGUID = '{3EE5B968-2ACA-4c34-8BB5-7E0C3D19B750}';
IID_IDirect3DVolumeTexture8 : TGUID = '{4B8AAAFA-140F-42ba-9131-597EAFAA2EAD}';
IID_IDirect3DVertexBuffer8 : TGUID = '{8AEEEAC7-05F9-44d4-B591-000B0DF1CB95}';
IID_IDirect3DIndexBuffer8 : TGUID = '{0E689C9A-053D-44a0-9D92-DB0E3D750F86}';
IID_IDirect3DSurface8 : TGUID = '{B96EEBCA-B326-4ea5-882F-2FF5BAE021DD}';
IID_IDirect3DVolume8 : TGUID = '{BD7349F5-14F1-42e4-9C79-972380DB40C0}';
IID_IDirect3DSwapChain8 : TGUID = '{928C088B-76B9-4C6B-A536-A590853876CD}';
(*
* Direct3D interfaces
*)
type
IDirect3D8 = interface;
IDirect3DDevice8 = interface;
IDirect3DResource8 = interface;
IDirect3DBaseTexture8 = interface;
IDirect3DTexture8 = interface;
IDirect3DVolumeTexture8 = interface;
IDirect3DCubeTexture8 = interface;
IDirect3DVertexBuffer8 = interface;
IDirect3DIndexBuffer8 = interface;
IDirect3DSurface8 = interface;
IDirect3DVolume8 = interface;
IDirect3DSwapChain8 = interface;
IDirect3D8 = interface (IUnknown)
['{1DD9E8DA-1C77-4d40-B0CF-98FEFDFF9512}']
(*** IDirect3D8 methods ***)
function RegisterSoftwareDevice(pInitializeFunction : Pointer) : HResult; stdcall;
function GetAdapterCount : Cardinal; stdcall;
function GetAdapterIdentifier(const Adapter : Cardinal; const Flags : LongWord; out pIdentifier : TD3DAdapter_Identifier8) : HResult; stdcall;
function GetAdapterModeCount(Adapter : Cardinal) : Cardinal; stdcall;
function EnumAdapterModes(const Adapter, Mode : Cardinal; var pMode : TD3DDisplayMode) : HResult; stdcall;
function GetAdapterDisplayMode(const Adapter : Cardinal; var pMode : TD3DDisplayMode) : HResult; stdcall;
function CheckDeviceType(const Adapter : Cardinal; const CheckType : TD3DDevType; const DisplayFormat, BackBufferFormat : TD3DFormat; const Windowed : BOOL) : HResult; stdcall;
function CheckDeviceFormat(const Adapter : Cardinal; const DeviceType : TD3DDevType; const AdapterFormat : TD3DFormat; const Usage : LongWord; const RType : TD3DResourceType; const CheckFormat : TD3DFormat) : HResult; stdcall;
function CheckDeviceMultiSampleType(const Adapter : Cardinal; const DeviceType : TD3DDevType; const SurfaceFormat : TD3DFormat; const Windowed : BOOL; const MultiSampleType : TD3DMultiSample_Type) : HResult; stdcall;
function CheckDepthStencilMatch(const Adapter : Cardinal; const DeviceType : TD3DDevType; const AdapterFormat, RenderTargetFormat, DepthStencilFormat : TD3DFormat) : HResult; stdcall;
function GetDeviceCaps(const Adapter : Cardinal; const DeviceType : TD3DDevType; out pCaps : TD3DCaps8) : HResult; stdcall;
function GetAdapterMonitor(const Adapter : Cardinal) : HMONITOR; stdcall;
function CreateDevice(const Adapter : Cardinal; const DeviceType : TD3DDevType; hFocusWindow : HWND; BehaviorFlags : LongWord; var pPresentationParameters : TD3DPresent_Parameters; out ppReturnedDeviceInterface : IDirect3DDevice8) : HResult; stdcall;
end;
IDirect3DDevice8 = interface (IUnknown)
['{7385E5DF-8FE8-41D5-86B6-D7B48547B6CF}']
(*** IDirect3DDevice8 methods ***)
function TestCooperativeLevel : HResult; stdcall;
function GetAvailableTextureMem : Cardinal; stdcall;
function ResourceManagerDiscardBytes(const Bytes : LongWord) : HResult; stdcall;
function GetDirect3D(out ppD3D8 : IDirect3D8) : HResult; stdcall;
function GetDeviceCaps(out pCaps : TD3DCaps8) : HResult; stdcall;
function GetDisplayMode(out pMode : TD3DDisplayMode) : HResult; stdcall;
function GetCreationParameters(out pParameters : TD3DDevice_Creation_Parameters) : HResult; stdcall;
function SetCursorProperties(const XHotSpot, YHotSpot : Cardinal; const pCursorBitmap : IDirect3DSurface8) : HResult; stdcall;
procedure SetCursorPosition(const XScreenSpace, YScreenSpace : Cardinal; const Flags : LongWord); stdcall;
function ShowCursor(const bShow : BOOL) : BOOL; stdcall;
function CreateAdditionalSwapChain(var pPresentationParameters : TD3DPresent_Parameters; out pSwapChain : IDirect3DSwapChain8) : HResult; stdcall;
function Reset(var pPresentationParameters : TD3DPresent_Parameters) : HResult; stdcall;
function Present(pSourceRect, pDestRect : PRect; const hDestWindowOverride : HWND; pDirtyRegion : PRgnData) : HResult; stdcall;
function GetBackBuffer(const BackBuffer : Cardinal; const _Type : TD3DBackBuffer_Type; out ppBackBuffer : IDirect3DSurface8) : HResult; stdcall;
function GetRasterStatus(out pRasterStatus : TD3DRaster_Status) : HResult; stdcall;
procedure SetGammaRamp(Flags : LongWord; var pRamp : TD3DGammaRamp); stdcall;
procedure GetGammaRamp(out pRamp : TD3DGammaRamp); stdcall;
function CreateTexture(const Width, Height, Levels : Cardinal; const Usage : LongWord; const Format : TD3DFormat; const Pool : TD3DPool; out ppTexture : IDirect3DTexture8) : HResult; stdcall;
function CreateVolumeTexture(const Width, Height, Depth, Levels : Cardinal; const Usage : LongWord; const Format : TD3DFormat; const Pool : TD3DPool; out ppVolumeTexture : IDirect3DVolumeTexture8) : HResult; stdcall;
function CreateCubeTexture(const EdgeLength, Levels : Cardinal; const Usage : LongWord; const Format : TD3DFormat; const Pool : TD3DPool; out ppCubeTexture : IDirect3DCubeTexture8) : HResult; stdcall;
function CreateVertexBuffer(const Length : Cardinal; const Usage, FVF : LongWord; const Pool : TD3DPool; out ppVertexBuffer : IDirect3DVertexBuffer8) : HResult; stdcall;
function CreateIndexBuffer(const Length : Cardinal; Usage : LongWord; const Format : TD3DFormat; Pool : TD3DPool; out ppIndexBuffer : IDirect3DIndexBuffer8) : HResult; stdcall;
function CreateRenderTarget(const Width, Height : Cardinal; const Format : TD3DFormat; const MultiSample : TD3DMultiSample_Type; const Lockable : BOOL; out ppSurface : IDirect3DSurface8) : HResult; stdcall;
function CreateDepthStencilSurface(const Width, Height : Cardinal; const Format : TD3DFormat; const MultiSample : TD3DMultiSample_Type; out ppSurface : IDirect3DSurface8) : HResult; stdcall;
function CreateImageSurface(const Width, Height : Cardinal; const Format : TD3DFormat; out ppSurface : IDirect3DSurface8) : HResult; stdcall;
function CopyRects(const pSourceSurface : IDirect3DSurface8; pSourceRectsArray : PRect; const cRects : Cardinal; const pDestinationSurface : IDirect3DSurface8; pDestPointsArray : PPoint) : HResult; stdcall;
function UpdateTexture(pSourceTexture, pDestinationTexture : IDirect3DBaseTexture8) : HResult; stdcall;
function GetFrontBuffer(pDestSurface : IDirect3DSurface8) : HResult; stdcall;
function SetRenderTarget(pRenderTarget, pNewZStencil : IDirect3DSurface8) : HResult; stdcall;
function GetRenderTarget(out ppRenderTarget : IDirect3DSurface8) : HResult; stdcall;
function GetDepthStencilSurface(out ppZStencilSurface : IDirect3DSurface8) : HResult; stdcall;
function BeginScene : HResult; stdcall;
function EndScene : HResult; stdcall;
function Clear(const Count : LongWord; pRects : PD3DRect; const Flags : LongWord; const Color : TD3DColor; const Z : Single; const Stencil : LongWord) : HResult; stdcall;
function SetTransform(const State : TD3DTransformStateType; const pMatrix : TD3DMatrix) : HResult; stdcall;
function GetTransform(const State : TD3DTransformStateType; out pMatrix : TD3DMatrix) : HResult; stdcall;
function MultiplyTransform(const State : TD3DTransformStateType; const pMatrix : TD3DMatrix) : HResult; stdcall;
function SetViewport(var pViewport : TD3DViewport8) : HResult; stdcall;
function GetViewport(out pViewport : TD3DViewport8) : HResult; stdcall;
function SetMaterial(var pMaterial : TD3DMaterial8) : HResult; stdcall;
function GetMaterial(out pMaterial : TD3DMaterial8) : HResult; stdcall;
function SetLight(const Index : LongWord; var pLight : TD3DLight8) : HResult; stdcall;
function GetLight(const Index : LongWord; out pLight : TD3DLight8) : HResult; stdcall;
function LightEnable(const Index : LongWord; const Enable : BOOL) : HResult; stdcall;
function GetLightEnable(const Index : LongWord; out pEnable : BOOL) : HResult; stdcall;
function SetClipPlane(const Index : LongWord; pPlane : PSingle) : HResult; stdcall;
function GetClipPlane(const Index : LongWord; out pPlane : Single) : HResult; stdcall;
function SetRenderState(const State : TD3DRenderStateType; const Value : LongWord) : HResult; stdcall;
function GetRenderState(const State : TD3DRenderStateType; out pValue : LongWord) : HResult; stdcall;
function BeginStateBlock : HResult; stdcall;
function EndStateBlock(out pToken : LongWord) : HResult; stdcall;
function ApplyStateBlock(const Token : LongWord) : HResult; stdcall;
function CaptureStateBlock(const Token : LongWord) : HResult; stdcall;
function DeleteStateBlock(const Token : LongWord) : HResult; stdcall;
function CreateStateBlock(const _Type : TD3DStateBlockType; out Token : LongWord) : HResult; stdcall;
function SetClipStatus(var pClipStatus : TD3DClipStatus8) : HResult; stdcall;
function GetClipStatus(out pClipStatus : TD3DClipStatus8) : HResult; stdcall;
function GetTexture(const Stage : LongWord; out ppTexture : IDirect3DBaseTexture8) : HResult; stdcall;
function SetTexture(const Stage : LongWord; pTexture : IDirect3DBaseTexture8) : HResult; stdcall;
function GetTextureStageState(const Stage : LongWord; const _Type : TD3DTextureStageStateType; out pValue : LongWord) : HResult; stdcall;
function SetTextureStageState(const Stage : LongWord; const _Type : TD3DTextureStageStateType; const Value : LongWord) : HResult; stdcall;
function ValidateDevice(out pNumPasses : LongWord) : HResult; stdcall;
function GetInfo(const DevInfoID : LongWord; pDevInfoStruct : Pointer; const DevInfoStructSize : LongWord) : HResult; stdcall;
function SetPaletteEntries(const PaletteNumber : Cardinal; var pEntries : TPaletteEntry) : HResult; stdcall;
function GetPaletteEntries(const PaletteNumber : Cardinal; out pEntries : TPaletteEntry) : HResult; stdcall;
function SetCurrentTexturePalette(const PaletteNumber : Cardinal) : HResult; stdcall;
function GetCurrentTexturePalette(out PaletteNumber : Cardinal) : HResult; stdcall;
function DrawPrimitive(const PrimitiveType : TD3DPrimitiveType; const StartVertex, PrimitiveCount : Cardinal) : HResult; stdcall;
function DrawIndexedPrimitive(const _Type : TD3DPrimitiveType; const minIndex, NumVertices, startIndex, primCount : Cardinal) : HResult; stdcall;
function DrawPrimitiveUP(const PrimitiveType : TD3DPrimitiveType; const PrimitiveCount : Cardinal; pVertexStreamZeroData : Pointer; const VertexStreamZeroStride : Cardinal) : HResult; stdcall;
function DrawIndexedPrimitiveUP(const PrimitiveType : TD3DPrimitiveType; const MinVertexIndex, NumVertexIndices, PrimitiveCount : Cardinal; pIndexData : Pointer; IndexDataFormat : TD3DFormat; pVertexStreamZeroData : Pointer; const VertexStreamZeroStride : Cardinal) : HResult; stdcall;
function ProcessVertices(const SrcStartIndex, DestIndex, VertexCount : Cardinal; pDestBuffer : IDirect3DVertexBuffer8; const Flags : LongWord) : HResult; stdcall;
// function CreateVertexShader(var pDeclaration, pFunction : LongWord; var pHandle : LongWord; const Usage : LongWord) : HResult; stdcall;
function CreateVertexShader(var pDeclaration : LongWord; pFunction : PLongWord; var pHandle : LongWord; const Usage : LongWord) : HResult; stdcall;
// function CreateVertexShader(pDeclaration, pFunction : PLongWord; var pHandle : LongWord; const Usage : LongWord) : HResult; stdcall;
function SetVertexShader(const Handle : LongWord) : HResult; stdcall;
function GetVertexShader(out pHandle : LongWord) : HResult; stdcall;
function DeleteVertexShader(const Handle : LongWord) : HResult; stdcall;
function SetVertexShaderConstant(const _Register : LongWord; {const} pConstantData : Pointer; const ConstantCount : LongWord) : HResult; stdcall;
function GetVertexShaderConstant(const _Register : LongWord; {out} pConstantData : Pointer; const ConstantCount : LongWord) : HResult; stdcall;
function GetVertexShaderDeclaration(const Handle : LongWord; {const} pData : Pointer; var pSizeOfData : LongWord) : HResult; stdcall;
function GetVertexShaderFunction(const Handle : LongWord; {out} pData : Pointer; var pSizeOfData : LongWord) : HResult; stdcall;
function SetStreamSource(const StreamNumber : Cardinal; const pStreamData : IDirect3DVertexBuffer8; const Stride : Cardinal) : HResult; stdcall;
function GetStreamSource(const StreamNumber : Cardinal; out ppStreamData : IDirect3DVertexBuffer8; var pStride : Cardinal) : HResult; stdcall;
function SetIndices(const pIndexData : IDirect3DIndexBuffer8; const BaseVertexIndex : Cardinal) : HResult; stdcall;
function GetIndices(out ppIndexData : IDirect3DIndexBuffer8; out pBaseVertexIndex : Cardinal) : HResult; stdcall;
function CreatePixelShader(var pFunction : LongWord; out pHandle : LongWord) : HResult; stdcall;
function SetPixelShader(const Handle : LongWord) : HResult; stdcall;
function GetPixelShader(out Handle : LongWord) : HResult; stdcall;
function DeletePixelShader(const Handle : LongWord) : HResult; stdcall;
function SetPixelShaderConstant(const _Register : LongWord; {const} pConstantData : Pointer; const ConstantCount : LongWord) : HResult; stdcall;
function GetPixelShaderConstant(const _Register : LongWord; {out} pConstantData : Pointer; const ConstantCount : LongWord) : HResult; stdcall;
function GetPixelShaderFunction(const Handle : LongWord; pData : Pointer; var pSizeOfData : LongWord) : HResult; stdcall;
function DrawRectPatch(const Handle : Cardinal; pNumSegs : PSingle; pRectPatchInfo : PD3DRectPatch_Info) : HResult; stdcall;
function DrawTriPatch(const Handle : Cardinal; pNumSegs : PSingle; pTriPatchInfo : PD3DTriPatch_Info) : HResult; stdcall;
function DeletePatch(const Handle : Cardinal) : HResult; stdcall;
end;
IDirect3DSwapChain8 = interface (IUnknown)
['{928C088B-76B9-4C6B-A536-A590853876CD}']
(*** IDirect3DSwapChain8 methods ***)
function Present(pSourceRect, pDestRect : PRect; const hDestWindowOverride : HWND; pDirtyRegion : PRgnData) : HResult; stdcall;
function GetBackBuffer(const BackBuffer : Cardinal; const _Type : TD3DBackBuffer_Type; out ppBackBuffer : IDirect3DSurface8) : HResult; stdcall;
end;
IDirect3DResource8 = interface (IUnknown)
['{1B36BB7B-09B7-410a-B445-7D1430D7B33F}']
(*** IDirect3DResource8 methods ***)
function GetDevice(out ppDevice : IDirect3DDevice8) : HResult; stdcall;
function SetPrivateData(const refguid : TGUID; {const} pData : Pointer; const SizeOfData, Flags : LongWord) : HResult; stdcall;
function GetPrivateData(const refguid : TGUID; {out} pData : Pointer; out pSizeOfData : LongWord) : HResult; stdcall;
function FreePrivateData(const refguid : TGUID) : HResult; stdcall;
function SetPriority(const PriorityNew : LongWord) : LongWord; stdcall;
function GetPriority : LongWord; stdcall;
procedure PreLoad stdcall;
function GetType : TD3DResourceType; stdcall;
end;
IDirect3DBaseTexture8 = interface (IDirect3DResource8)
['{B4211CFA-51B9-4a9f-AB78-DB99B2BB678E}']
(*** IDirect3DBaseTexture8 methods ***)
function SetLOD(const LODNew : LongWord) : LongWord; stdcall;
function GetLOD : LongWord; stdcall;
function GetLevelCount : LongWord; stdcall;
end;
IDirect3DTexture8 = interface (IDirect3DBaseTexture8)
['{E4CDD575-2866-4f01-B12E-7EECE1EC9358}']
(*** IDirect3DTexture8 methods ***)
function GetLevelDesc(const Level : Cardinal; out pDesc : TD3DSurface_Desc) : HResult; stdcall;
function GetSurfaceLevel(const Level : Cardinal; out ppSurfaceLevel : IDirect3DSurface8) : HResult; stdcall;
function LockRect(const Level : Cardinal; out pLockedRect : TD3DLocked_Rect; pRect : PRect; const Flags : LongWord) : HResult; stdcall;
function UnlockRect(const Level : Cardinal) : HResult; stdcall;
function AddDirtyRect(pDirtyRect : PRect) : HResult; stdcall;
end;
IDirect3DVolumeTexture8 = interface (IDirect3DBaseTexture8)
['{E4CDD575-2866-4f01-B12E-7EECE1EC9358}']
(*** IDirect3DVolumeTexture8 methods ***)
function GetLevelDesc(const Level : Cardinal; out pDesc : TD3DVolume_Desc) : HResult; stdcall;
function GetVolumeLevel(const Level : Cardinal; out ppVolumeLevel : IDirect3DVolume8) : HResult; stdcall;
function LockBox(const Level : Cardinal; out pLockedVolume : TD3DLocked_Box; pBox : PD3DBox; const Flags : LongWord) : HResult; stdcall;
function UnlockBox(const Level : Cardinal) : HResult; stdcall;
function AddDirtyBox(pDirtyBox : PD3DBox) : HResult; stdcall;
end;
IDirect3DCubeTexture8 = interface (IDirect3DBaseTexture8)
['{3EE5B968-2ACA-4c34-8BB5-7E0C3D19B750}']
(*** IDirect3DCubeTexture8 methods ***)
function GetLevelDesc(const Level : Cardinal; out pDesc : TD3DSurface_Desc) : HResult; stdcall;
function GetCubeMapSurface(const FaceType : TD3DCubeMap_Faces; const Level : Cardinal; out ppCubeMapSurface : IDirect3DSurface8) : HResult; stdcall;
function LockRect(const FaceType : TD3DCubeMap_Faces; const Level : Cardinal; out pLockedRect : TD3DLocked_Rect; pRect : PRect; const Flags : LongWord) : HResult; stdcall;
function UnlockRect(const FaceType : TD3DCubeMap_Faces; const Level : Cardinal) : HResult; stdcall;
function AddDirtyRect(const FaceType : TD3DCubeMap_Faces; pDirtyRect : PRect) : HResult; stdcall;
end;
IDirect3DVertexBuffer8 = interface (IDirect3DResource8)
['{8AEEEAC7-05F9-44d4-B591-000B0DF1CB95}']
(*** IDirect3DVertexBuffer8 methods ***)
function Lock(const OffsetToLock, SizeToLock : Cardinal; var ppbData : PByte; const Flags : LongWord) : HResult; stdcall;
function Unlock : HResult; stdcall;
function GetDesc(out pDesc : TD3DVertexBuffer_Desc) : HResult; stdcall;
end;
IDirect3DIndexBuffer8 = interface (IDirect3DResource8)
['{0E689C9A-053D-44a0-9D92-DB0E3D750F86}']
(*** IDirect3DIndexBuffer8 methods ***)
function Lock(const OffsetToLock, SizeToLock : LongWord; var ppbData : PByte; const Flags : LongWord) : HResult; stdcall;
function Unlock : HResult; stdcall;
function GetDesc(out pDesc : TD3DIndexBuffer_Desc) : HResult; stdcall;
end;
IDirect3DSurface8 = interface (IUnknown)
['{B96EEBCA-B326-4ea5-882F-2FF5BAE021DD}']
(*** IDirect3DSurface8 methods ***)
function GetDevice(out ppDevice : IDirect3DDevice8) : HResult; stdcall;
function SetPrivateData(const refguid : TGUID; {const} pData : Pointer; const SizeOfData, Flags : LongWord) : HResult; stdcall;
function GetPrivateData(const refguid : TGUID; {out} pData : Pointer; out pSizeOfData : LongWord) : HResult; stdcall;
function FreePrivateData(const refguid : TGUID) : HResult; stdcall;
function GetContainer(const riid : TGUID; var ppContainer : Pointer) : HResult; stdcall;
function GetDesc(out pDesc : TD3DSurface_Desc) : HResult; stdcall;
function LockRect(out pLockedRect : TD3DLocked_Rect; pRect : PRect; const Flags : LongWord) : HResult; stdcall;
function UnlockRect : HResult; stdcall;
end;
IDirect3DVolume8 = interface (IUnknown)
['{BD7349F5-14F1-42e4-9C79-972380DB40C0}']
(*** IDirect3DVolume8 methods ***)
function GetDevice(out ppDevice : IDirect3DDevice8) : HResult; stdcall;
function SetPrivateData(const refguid : TGUID; {const} pData : Pointer; const SizeOfData, Flags : LongWord) : HResult; stdcall;
function GetPrivateData(const refguid : TGUID; {out} pData : Pointer; out pSizeOfData : LongWord) : HResult; stdcall;
function FreePrivateData(const refguid : TGUID) : HResult; stdcall;
function GetContainer(const riid : TGUID; var ppContainer : Pointer) : HResult; stdcall;
function GetDesc(out pDesc : TD3DVolume_Desc) : HResult; stdcall;
function LockBox(out pLockedVolume : TD3DLocked_Box; pBox : PD3DBox; const Flags : LongWord) : HResult; stdcall;
function UnlockBox : HResult; stdcall;
end;
(****************************************************************************
* Flags for SetPrivateData method on all D3D8 interfaces
*
* The passed pointer is an IUnknown ptr. The SizeOfData argument to SetPrivateData
* must be set to sizeof( IUnknown* ). Direct3D will call AddRef through this
* pointer and Release when the private data is destroyed. The data will be
* destroyed when another SetPrivateData with the same GUID is set, when
* FreePrivateData is called, or when the D3D8 object is freed.
****************************************************************************)
const
D3DSPD_IUNKNOWN = $00000001;
(****************************************************************************
*
* Parameter for IDirect3D8 Enum and GetCaps8 functions to get the info for
* the current mode only.
*
****************************************************************************)
D3DCURRENT_DISPLAY_MODE = $00EFFFFF;
(****************************************************************************
*
* Flags for IDirect3D8::CreateDevice's BehaviorFlags
*
****************************************************************************)
D3DCREATE_FPU_PRESERVE = $00000002;
D3DCREATE_MULTITHREADED = $00000004;
D3DCREATE_PUREDEVICE = $00000010;
D3DCREATE_SOFTWARE_VERTEXPROCESSING = $00000020;
D3DCREATE_HARDWARE_VERTEXPROCESSING = $00000040;
D3DCREATE_MIXED_VERTEXPROCESSING = $00000080;
{$IFNDEF DX8}
D3DCREATE_DISABLE_DRIVER_MANAGEMENT = $00000100;
{$ENDIF}
(****************************************************************************
*
* Parameter for IDirect3D8::CreateDevice's iAdapter
*
****************************************************************************)
D3DADAPTER_DEFAULT = 0;
(****************************************************************************
*
* Flags for IDirect3D8::EnumAdapters
*
****************************************************************************)
D3DENUM_NO_WHQL_LEVEL = $00000002;
(****************************************************************************
*
* Maximum number of back-buffers supported in DX8
*
****************************************************************************)
D3DPRESENT_BACK_BUFFERS_MAX = 3;
(****************************************************************************
*
* Flags for IDirect3DDevice8::SetGammaRamp
*
****************************************************************************)
D3DSGR_NO_CALIBRATION = $00000000;
D3DSGR_CALIBRATE = $00000001;
(****************************************************************************
*
* Flags for IDirect3DDevice8::SetCursorPosition
*
****************************************************************************)
D3DCURSOR_IMMEDIATE_UPDATE = $00000001;
(****************************************************************************
*
* Flags for DrawPrimitive/DrawIndexedPrimitive
* Also valid for Begin/BeginIndexed
* Also valid for VertexBuffer::CreateVertexBuffer
****************************************************************************)
(*
* DirectDraw error codes
*)
const
_FACD3D = $876;
MAKE_D3DHRESULT = (1 shl 31) or (_FACD3D shl 16);
(*
* Direct3D Errors
*)
D3D_OK = S_OK;
D3DERR_WRONGTEXTUREFORMAT = HResult(MAKE_D3DHRESULT + 2072);
D3DERR_UNSUPPORTEDCOLOROPERATION = HResult(MAKE_D3DHRESULT + 2073);
D3DERR_UNSUPPORTEDCOLORARG = HResult(MAKE_D3DHRESULT + 2074);
D3DERR_UNSUPPORTEDALPHAOPERATION = HResult(MAKE_D3DHRESULT + 2075);
D3DERR_UNSUPPORTEDALPHAARG = HResult(MAKE_D3DHRESULT + 2076);
D3DERR_TOOMANYOPERATIONS = HResult(MAKE_D3DHRESULT + 2077);
D3DERR_CONFLICTINGTEXTUREFILTER = HResult(MAKE_D3DHRESULT + 2078);
D3DERR_UNSUPPORTEDFACTORVALUE = HResult(MAKE_D3DHRESULT + 2079);
D3DERR_CONFLICTINGRENDERSTATE = HResult(MAKE_D3DHRESULT + 2081);
D3DERR_UNSUPPORTEDTEXTUREFILTER = HResult(MAKE_D3DHRESULT + 2082);
D3DERR_CONFLICTINGTEXTUREPALETTE = HResult(MAKE_D3DHRESULT + 2086);
D3DERR_DRIVERINTERNALERROR = HResult(MAKE_D3DHRESULT + 2087);
D3DERR_NOTFOUND = HResult(MAKE_D3DHRESULT + 2150);
D3DERR_MOREDATA = HResult(MAKE_D3DHRESULT + 2151);
D3DERR_DEVICELOST = HResult(MAKE_D3DHRESULT + 2152);
D3DERR_DEVICENOTRESET = HResult(MAKE_D3DHRESULT + 2153);
D3DERR_NOTAVAILABLE = HResult(MAKE_D3DHRESULT + 2154);
D3DERR_OUTOFVIDEOMEMORY = HResult(MAKE_D3DHRESULT + 380);
D3DERR_INVALIDDEVICE = HResult(MAKE_D3DHRESULT + 2155);
D3DERR_INVALIDCALL = HResult(MAKE_D3DHRESULT + 2156);
D3DERR_DRIVERINVALIDCALL = HResult(MAKE_D3DHRESULT + 2157);
(*
* DLL Function for creating a Direct3D8 object. This object supports
* enumeration and allows the creation of Direct3DDevice8 objects.
* Pass the value of the constant D3D_SDK_VERSION to this function, so
* that the run-time can validate that your application was compiled
* against the right headers.
*)
function Direct3DCreate8(SDKVersion : Cardinal) : IDirect3D8;
{$IFNDEF STATIC_LINKING}
var _Direct3DCreate8 : function (SDKVersion : Cardinal) : Pointer; stdcall;
{$ENDIF}
function DXGErrorString(ErrorValue : HResult) : string;
implementation
uses DXCommon;
function D3DCOLOR_ARGB(a, r, g, b : Cardinal) : TD3DColor;
begin
Result := (a shl 24) or (r shl 16) or (g shl 8) or b;
end;
function D3DCOLOR_RGBA(r, g, b, a : Cardinal) : TD3DColor;
begin
Result := D3DCOLOR_ARGB(a, r, g, b);
end;
function D3DCOLOR_XRGB(r, g, b : Cardinal) : TD3DColor;
begin
Result := D3DCOLOR_ARGB($ff, r, g, b);
end;
function D3DCOLOR_COLORVALUE(r, g, b, a : Single) : TD3DColor;
begin
Result := D3DCOLOR_RGBA(Byte(Round(r * 255)), Byte(Round(g * 255)), Byte(Round(b * 255)), Byte(Round(a * 255)))
end;
function D3DTS_WORLDMATRIX(index : LongWord) : TD3DTransformStateType;
begin
Result := TD3DTransformStateType(index + 256);
end;
function D3DVSD_MAKETOKENTYPE(tokenType : TD3DVSDTokenType) : TD3DVSDTokenType;
begin
Result := TD3DVSDTokenType((LongWord(tokenType) shl LongWord(D3DVSD_TOKENTYPESHIFT)) and LongWord(D3DVSD_TOKENTYPEMASK));
end;
function D3DVSD_STREAM(_StreamNumber : LongWord) : TD3DVSDTokenType;
begin
Result := TD3DVSDTokenType(LongWord(D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAM)) or _StreamNumber);
end;
function D3DVSD_REG( _VertexRegister, _Type : LongWord) : TD3DVSDTokenType;
begin
Result := TD3DVSDTokenType(LongWord(D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAMDATA)) or ((_Type shl LongWord(D3DVSD_DATATYPESHIFT)) or _VertexRegister))
end;
function D3DVSD_SKIP( _DWORDCount : LongWord) : TD3DVSDTokenType;
begin
Result := TD3DVSDTokenType(LongWord(D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAMDATA)) or $10000000 or (_DWORDCount shl LongWord(D3DVSD_SKIPCOUNTSHIFT)))
end;
function D3DVSD_CONST( _ConstantAddress, _Count : LongWord) : TD3DVSDTokenType;
begin
Result := TD3DVSDTokenType(LongWord(D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_CONSTMEM)) or (_Count shl LongWord(D3DVSD_CONSTCOUNTSHIFT)) or _ConstantAddress)
end;
function D3DVSD_TESSNORMAL( _VertexRegisterIn, _VertexRegisterOut : LongWord) : TD3DVSDTokenType;
begin
Result := TD3DVSDTokenType(LongWord(D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_TESSELLATOR)) or
(_VertexRegisterIn shl LongWord(D3DVSD_VERTEXREGINSHIFT)) or
($02 shl LongWord(D3DVSD_DATATYPESHIFT)) or _VertexRegisterOut);
end;
function D3DVSD_TESSUV( _VertexRegister : LongWord) : TD3DVSDTokenType;
begin
Result := TD3DVSDTokenType(LongWord(D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_TESSELLATOR)) or $10000000 or
($01 shl LongWord(D3DVSD_DATATYPESHIFT)) or _VertexRegister);
end;
function D3DPS_VERSION(_Major, _Minor : LongWord) : LongWord;
begin
Result := $FFFF0000 or (_Major shl 8 ) or _Minor;
end;
function D3DVS_VERSION(_Major, _Minor : LongWord) : LongWord;
begin
Result := $FFFE0000 or (_Major shl 8 ) or _Minor;
end;
function D3DSHADER_VERSION_MAJOR(_Version : LongWord) : LongWord;
begin
Result := (_Version shr 8 ) and $FF;
end;
function D3DSHADER_VERSION_MINOR(_Version : LongWord) : LongWord;
begin
Result := (_Version shr 0) and $FF;
end;
function D3DSHADER_COMMENT(_DWordSize : LongWord) : LongWord;
begin
Result := ((_DWordSize shl D3DSI_COMMENTSIZE_SHIFT) and D3DSI_COMMENTSIZE_MASK) or LongWord(D3DSIO_COMMENT);
end;
function D3DFVF_TEXCOORDSIZE3(CoordIndex : LongWord) : LongWord;
begin
Result := D3DFVF_TEXTUREFORMAT3 shl (CoordIndex * 2 + 16)
end;
function D3DFVF_TEXCOORDSIZE2(CoordIndex : LongWord) : LongWord;
begin
Result := D3DFVF_TEXTUREFORMAT2;
end;
function D3DFVF_TEXCOORDSIZE4(CoordIndex : LongWord) : LongWord;
begin
Result := D3DFVF_TEXTUREFORMAT4 shl (CoordIndex * 2 + 16)
end;
function D3DFVF_TEXCOORDSIZE1(CoordIndex : LongWord) : LongWord;
begin
Result := D3DFVF_TEXTUREFORMAT1 shl (CoordIndex * 2 + 16)
end;
function MAKEFOURCC(ch0, ch1, ch2, ch3 : Char) : LongWord;
begin
Result := Byte(ch0) or (Byte(ch1) shl 8) or (Byte(ch2) shl 16) or (Byte(ch3) shl 24 );
end;
function DXGErrorString(ErrorValue : HResult) : string;
begin
//You should better use D3DXErrorString
case ErrorValue of
HResult(D3D_OK) : Result := 'No error occurred.';
HResult(D3DERR_CONFLICTINGRENDERSTATE) : Result := 'The currently set render states cannot be used together.';
HResult(D3DERR_CONFLICTINGTEXTUREFILTER) : Result := 'The current texture filters cannot be used together.';
HResult(D3DERR_CONFLICTINGTEXTUREPALETTE) : Result := 'The current textures cannot be used simultaneously. This generally occurs when a multitexture device requires that all palletized textures simultaneously enabled also share the same palette.';
HResult(D3DERR_DEVICELOST) : Result := 'The device is lost and cannot be restored at the current time, so rendering is not possible.';
HResult(D3DERR_DEVICENOTRESET) : Result := 'The device cannot be reset.';
HResult(D3DERR_DRIVERINTERNALERROR) : Result := 'Internal driver error.';
HResult(D3DERR_INVALIDCALL) : Result := 'The method call is invalid. For example, a method''s parameter may have an invalid value.';
HResult(D3DERR_INVALIDDEVICE) : Result := 'The requested device type is not valid.';
HResult(D3DERR_MOREDATA) : Result := 'There is more data available than the specified buffer size can hold.';
HResult(D3DERR_NOTAVAILABLE) : Result := 'This device does not support the queried technique.';
HResult(D3DERR_NOTFOUND) : Result := 'The requested item was not found.';
HResult(D3DERR_OUTOFVIDEOMEMORY) : Result := 'Direct3D does not have enough display memory to perform the operation.';
HResult(D3DERR_TOOMANYOPERATIONS) : Result := 'The application is requesting more texture-filtering operations than the device';
HResult(D3DERR_UNSUPPORTEDALPHAARG) : Result := 'The device does not support a specified texture-blending argument for the alpha channel.';
HResult(D3DERR_UNSUPPORTEDALPHAOPERATION) : Result := 'The device does not support a specified texture-blending operation for the alpha channel.';
HResult(D3DERR_UNSUPPORTEDCOLORARG) : Result := 'The device does not support a specified texture-blending argument for color values.';
HResult(D3DERR_UNSUPPORTEDCOLOROPERATION) : Result := 'The device does not support a specified texture-blending operation for color values.';
HResult(D3DERR_UNSUPPORTEDFACTORVALUE) : Result := 'The device does not support the specified texture factor value.';
HResult(D3DERR_UNSUPPORTEDTEXTUREFILTER) : Result := 'The device does not support the specified texture filter.';
HResult(D3DERR_WRONGTEXTUREFORMAT) : Result := 'The pixel format of the texture surface is not valid.';
HResult(E_FAIL) : Result := 'An undetermined error occurred inside the Direct3D subsystem.';
HResult(E_INVALIDARG) : Result := 'An invalid parameter was passed to the returning function';
// HResult(E_INVALIDCALL) : Result := 'The method call is invalid. For example, a method''s parameter may have an invalid value.';
HResult(E_OUTOFMEMORY) : Result := 'Direct3D could not allocate sufficient memory to complete the call.';
else Result := 'Unknown Error';
end;
end;
{$IFDEF STATIC_LINKING}
function _Direct3DCreate8(SDKVersion : Cardinal) : Pointer; stdcall; external D3D8DLLName name 'Direct3DCreate8';
{$ENDIF}
function Direct3DCreate8(SDKVersion : Cardinal) : IDirect3D8;
begin
{$IFNDEF STATIC_LINKING}
if Assigned(_Direct3DCreate8) then
begin
{$ENDIF}
Result := IDirect3D8(_Direct3DCreate8(SDKVersion));
if Result <> nil then Result._Release;
{$IFNDEF STATIC_LINKING}
end else Result := nil;
{$ENDIF}
end;
{$IFNDEF STATIC_LINKING}
initialization
begin
if not IsNTandDelphiRunning then
begin
D3D8DLL := LoadLibrary(D3D8DLLName);
if D3D8DLL <> 0 then
_Direct3DCreate8 := GetProcAddress(D3D8DLL, 'Direct3DCreate8')
else _Direct3DCreate8 := nil;
end;
end;
finalization
begin
FreeLibrary(D3D8DLL);
end;
{$ENDIF}
end.
Reference in a new issue View git blame Copy permalink