2D图形编程

开发平台：

Delphi

Direct3D9.pas：源码内容

D3DFMT_FORCE_DWORD = $7fffffff
);
{$ENDIF}
{$EXTERNALSYM _D3DFORMAT}
D3DFORMAT = _D3DFORMAT;
{$EXTERNALSYM D3DFORMAT}
PD3DFormat = ^TD3DFormat;
TD3DFormat = _D3DFORMAT;
{ Display Modes }
PD3DDisplayMode = ^TD3DDisplayMode;
_D3DDISPLAYMODE = packed record
Width: LongWord;
Height: LongWord;
RefreshRate: LongWord;
Format: TD3DFormat;
end {_D3DDISPLAYMODE};
{$EXTERNALSYM _D3DDISPLAYMODE}
D3DDISPLAYMODE = _D3DDISPLAYMODE;
{$EXTERNALSYM D3DDISPLAYMODE}
TD3DDisplayMode = _D3DDISPLAYMODE;
{ Creation Parameters }
PD3DDeviceCreationParameters = ^TD3DDeviceCreationParameters;
_D3DDEVICE_CREATION_PARAMETERS = packed record
AdapterOrdinal: LongWord;
DeviceType: TD3DDevType;
hFocusWindow: HWND;
BehaviorFlags: LongInt;
end {_D3DDEVICE_CREATION_PARAMETERS};
{$EXTERNALSYM _D3DDEVICE_CREATION_PARAMETERS}
D3DDEVICE_CREATION_PARAMETERS = _D3DDEVICE_CREATION_PARAMETERS;
{$EXTERNALSYM D3DDEVICE_CREATION_PARAMETERS}
TD3DDeviceCreationParameters = _D3DDEVICE_CREATION_PARAMETERS;
{ SwapEffects }
_D3DSWAPEFFECT = (
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DSWAPEFFECT_INVALID_0 {= 0},
D3DSWAPEFFECT_DISCARD {= 1},
D3DSWAPEFFECT_FLIP {= 2},
D3DSWAPEFFECT_COPY {= 3}
{$ELSE}
D3DSWAPEFFECT_DISCARD = 1,
D3DSWAPEFFECT_FLIP = 2,
D3DSWAPEFFECT_COPY = 3
{$ENDIF}
);
{$EXTERNALSYM _D3DSWAPEFFECT}
D3DSWAPEFFECT = _D3DSWAPEFFECT;
{$EXTERNALSYM D3DSWAPEFFECT}
TD3DSwapEffect = _D3DSWAPEFFECT;
{ Pool types }
_D3DPOOL = (
D3DPOOL_DEFAULT {= 0},
D3DPOOL_MANAGED {= 1},
D3DPOOL_SYSTEMMEM {= 2},
D3DPOOL_SCRATCH {= 3}
);
{$EXTERNALSYM _D3DPOOL}
D3DPOOL = _D3DPOOL;
{$EXTERNALSYM D3DPOOL}
TD3DPool = _D3DPOOL;
const
{ RefreshRate pre-defines }
D3DPRESENT_RATE_DEFAULT = $00000000;
{$EXTERNALSYM D3DPRESENT_RATE_DEFAULT}
type
{ Resize Optional Parameters }
PD3DPresentParameters = ^TD3DPresentParameters;
_D3DPRESENT_PARAMETERS_ = packed record
BackBufferWidth: LongWord;
BackBufferHeight: LongWord;
BackBufferFormat: TD3DFormat;
BackBufferCount: LongWord;
MultiSampleType: TD3DMultiSampleType;
MultiSampleQuality: DWORD;
SwapEffect: TD3DSwapEffect;
hDeviceWindow: HWND;
Windowed: Bool;
EnableAutoDepthStencil: Bool;
AutoDepthStencilFormat: TD3DFormat;
Flags: LongInt;
{ FullScreen_RefreshRateInHz must be zero for Windowed mode }
FullScreen_RefreshRateInHz: LongWord;
PresentationInterval: LongWord;
end {_D3DPRESENT_PARAMETERS_};
{$EXTERNALSYM _D3DPRESENT_PARAMETERS_}
D3DPRESENT_PARAMETERS = _D3DPRESENT_PARAMETERS_;
{$EXTERNALSYM D3DPRESENT_PARAMETERS}
TD3DPresentParameters = _D3DPRESENT_PARAMETERS_;
// Values for D3DPRESENT_PARAMETERS.Flags
const
D3DPRESENTFLAG_LOCKABLE_BACKBUFFER = $00000001;
{$EXTERNALSYM D3DPRESENTFLAG_LOCKABLE_BACKBUFFER}
D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL = $00000002;
{$EXTERNALSYM D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL}
D3DPRESENTFLAG_DEVICECLIP = $00000004;
{$EXTERNALSYM D3DPRESENTFLAG_DEVICECLIP}
D3DPRESENTFLAG_VIDEO = $00000010;
{$EXTERNALSYM D3DPRESENTFLAG_VIDEO}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
D3DPRESENTFLAG_NOAUTOROTATE = $00000020;
{$EXTERNALSYM D3DPRESENTFLAG_NOAUTOROTATE}
D3DPRESENTFLAG_UNPRUNEDMODE = $00000040;
{$EXTERNALSYM D3DPRESENTFLAG_UNPRUNEDMODE}
{$ENDIF}
{ Gamma Ramp: Same as DX7 }
type
PD3DGammaRamp = ^TD3DGammaRamp;
_D3DGAMMARAMP = packed record
red : array [0..255] of Word;
green : array [0..255] of Word;
blue : array [0..255] of Word;
end;
{$EXTERNALSYM _D3DGAMMARAMP}
D3DGAMMARAMP = _D3DGAMMARAMP;
{$EXTERNALSYM D3DGAMMARAMP}
TD3DGammaRamp = _D3DGAMMARAMP;
{ Back buffer types }
_D3DBACKBUFFER_TYPE = (
D3DBACKBUFFER_TYPE_MONO {= 0},
D3DBACKBUFFER_TYPE_LEFT {= 1},
D3DBACKBUFFER_TYPE_RIGHT {= 2}
);
{$EXTERNALSYM _D3DBACKBUFFER_TYPE}
D3DBACKBUFFER_TYPE = _D3DBACKBUFFER_TYPE;
{$EXTERNALSYM D3DBACKBUFFER_TYPE}
TD3DBackbufferType = _D3DBACKBUFFER_TYPE;
{ Types }
_D3DRESOURCETYPE = (
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DRTYPE_INVALID_0 {= 0},
D3DRTYPE_SURFACE {= 1},
D3DRTYPE_VOLUME {= 2},
D3DRTYPE_TEXTURE {= 3},
D3DRTYPE_VOLUMETEXTURE {= 4},
D3DRTYPE_CUBETEXTURE {= 5},
D3DRTYPE_VERTEXBUFFER {= 6},
D3DRTYPE_INDEXBUFFER {= 7} //if this changes, change _D3DDEVINFO_RESOURCEMANAGER definition
{$ELSE}
D3DRTYPE_SURFACE = 1,
D3DRTYPE_VOLUME = 2,
D3DRTYPE_TEXTURE = 3,
D3DRTYPE_VOLUMETEXTURE = 4,
D3DRTYPE_CUBETEXTURE = 5,
D3DRTYPE_VERTEXBUFFER = 6,
D3DRTYPE_INDEXBUFFER = 7 //if this changes, change _D3DDEVINFO_RESOURCEMANAGER definition
{$ENDIF}
);
{$EXTERNALSYM _D3DRESOURCETYPE}
D3DRESOURCETYPE = _D3DRESOURCETYPE;
{$EXTERNALSYM D3DRESOURCETYPE}
TD3DResourceType = _D3DRESOURCETYPE;
const
{ Usages }
D3DUSAGE_RENDERTARGET = $00000001;
{$EXTERNALSYM D3DUSAGE_RENDERTARGET}
D3DUSAGE_DEPTHSTENCIL = $00000002;
{$EXTERNALSYM D3DUSAGE_DEPTHSTENCIL}
D3DUSAGE_DYNAMIC = $00000200;
{$EXTERNALSYM D3DUSAGE_DYNAMIC}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
D3DUSAGE_NONSECURE = $00800000;
{$EXTERNALSYM D3DUSAGE_NONSECURE}
{$ENDIF}
// When passed to CheckDeviceFormat, D3DUSAGE_AUTOGENMIPMAP may return
// D3DOK_NOAUTOGEN if the device doesn't support autogeneration for that format.
// D3DOK_NOAUTOGEN is a success code, not a failure code... the SUCCEEDED and FAILED macros
// will return true and false respectively for this code.
D3DUSAGE_AUTOGENMIPMAP = $00000400;
{$EXTERNALSYM D3DUSAGE_AUTOGENMIPMAP}
D3DUSAGE_DMAP = $00004000;
{$EXTERNALSYM D3DUSAGE_DMAP}
// The following usages are valid only for querying CheckDeviceFormat
D3DUSAGE_QUERY_LEGACYBUMPMAP = $00008000;
{$EXTERNALSYM D3DUSAGE_QUERY_LEGACYBUMPMAP}
D3DUSAGE_QUERY_SRGBREAD = $00010000;
{$EXTERNALSYM D3DUSAGE_QUERY_SRGBREAD}
D3DUSAGE_QUERY_FILTER = $00020000;
{$EXTERNALSYM D3DUSAGE_QUERY_FILTER}
D3DUSAGE_QUERY_SRGBWRITE = $00040000;
{$EXTERNALSYM D3DUSAGE_QUERY_SRGBWRITE}
D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING = $00080000;
{$EXTERNALSYM D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING}
D3DUSAGE_QUERY_VERTEXTEXTURE = $00100000;
{$EXTERNALSYM D3DUSAGE_QUERY_VERTEXTEXTURE}
D3DUSAGE_QUERY_WRAPANDMIP = $00200000;
{$EXTERNALSYM D3DUSAGE_QUERY_WRAPANDMIP}
{ Usages for Vertex/Index buffers }
D3DUSAGE_WRITEONLY = $00000008;
{$EXTERNALSYM D3DUSAGE_WRITEONLY}
D3DUSAGE_SOFTWAREPROCESSING = $00000010;
{$EXTERNALSYM D3DUSAGE_SOFTWAREPROCESSING}
D3DUSAGE_DONOTCLIP = $00000020;
{$EXTERNALSYM D3DUSAGE_DONOTCLIP}
D3DUSAGE_POINTS = $00000040;
{$EXTERNALSYM D3DUSAGE_POINTS}
D3DUSAGE_RTPATCHES = $00000080;
{$EXTERNALSYM D3DUSAGE_RTPATCHES}
D3DUSAGE_NPATCHES = $00000100;
{$EXTERNALSYM D3DUSAGE_NPATCHES}
type
{ CubeMap Face identifiers }
_D3DCUBEMAP_FACES = (
D3DCUBEMAP_FACE_POSITIVE_X {= 0},
D3DCUBEMAP_FACE_NEGATIVE_X {= 1},
D3DCUBEMAP_FACE_POSITIVE_Y {= 2},
D3DCUBEMAP_FACE_NEGATIVE_Y {= 3},
D3DCUBEMAP_FACE_POSITIVE_Z {= 4},
D3DCUBEMAP_FACE_NEGATIVE_Z {= 5}
);
{$EXTERNALSYM _D3DCUBEMAP_FACES}
D3DCUBEMAP_FACES = _D3DCUBEMAP_FACES;
{$EXTERNALSYM D3DCUBEMAP_FACES}
TD3DCubemapFaces = _D3DCUBEMAP_FACES;
const
{ Lock flags }
D3DLOCK_READONLY = $00000010;
{$EXTERNALSYM D3DLOCK_READONLY}
D3DLOCK_DISCARD = $00002000;
{$EXTERNALSYM D3DLOCK_DISCARD}
D3DLOCK_NOOVERWRITE = $00001000;
{$EXTERNALSYM D3DLOCK_NOOVERWRITE}
D3DLOCK_NOSYSLOCK = $00000800;
{$EXTERNALSYM D3DLOCK_NOSYSLOCK}
D3DLOCK_DONOTWAIT = $00004000;
{$EXTERNALSYM D3DLOCK_DONOTWAIT}
D3DLOCK_NO_DIRTY_UPDATE = $00008000;
{$EXTERNALSYM D3DLOCK_NO_DIRTY_UPDATE}
type
{ Vertex Buffer Description }
PD3DVertexBufferDesc = ^TD3DVertexBufferDesc;
_D3DVERTEXBUFFER_DESC = packed record
Format : TD3DFormat;
_Type : TD3DResourceType;
Usage : DWord;
Pool : TD3DPool;
Size : LongWord;
FVF : DWord;
end;
{$EXTERNALSYM _D3DVERTEXBUFFER_DESC}
D3DVERTEXBUFFER_DESC = _D3DVERTEXBUFFER_DESC;
{$EXTERNALSYM D3DVERTEXBUFFER_DESC}
TD3DVertexBufferDesc = _D3DVERTEXBUFFER_DESC;
{ Index Buffer Description }
PD3DIndexBufferDesc = ^TD3DIndexBufferDesc;
_D3DINDEXBUFFER_DESC = packed record
Format : TD3DFormat;
_Type : TD3DResourceType;
Usage : DWord;
Pool : TD3DPool;
Size : LongWord;
end {_D3DINDEXBUFFER_DESC};
{$EXTERNALSYM _D3DINDEXBUFFER_DESC}
D3DINDEXBUFFER_DESC = _D3DINDEXBUFFER_DESC;
{$EXTERNALSYM D3DINDEXBUFFER_DESC}
TD3DIndexBufferDesc = _D3DINDEXBUFFER_DESC;
{ Surface Description }
PD3DSurfaceDesc = ^TD3DSurfaceDesc;
_D3DSURFACE_DESC = packed record
Format : TD3DFormat;
_Type : TD3DResourceType;
Usage : DWord;
Pool : TD3DPool;
MultiSampleType: TD3DMultiSampleType;
MultiSampleQuality: DWORD;
Width : LongWord;
Height : LongWord;
end {_D3DSURFACE_DESC};
{$EXTERNALSYM _D3DSURFACE_DESC}
D3DSURFACE_DESC = _D3DSURFACE_DESC;
{$EXTERNALSYM D3DSURFACE_DESC}
TD3DSurfaceDesc = _D3DSURFACE_DESC;
PD3DVolumeDesc = ^TD3DVolumeDesc;
_D3DVOLUME_DESC = packed record
Format : TD3DFormat;
_Type : TD3DResourceType;
Usage : DWord;
Pool : TD3DPool;
Width : LongWord;
Height : LongWord;
Depth : LongWord;
end {_D3DVOLUME_DESC};
{$EXTERNALSYM _D3DVOLUME_DESC}
D3DVOLUME_DESC = _D3DVOLUME_DESC;
{$EXTERNALSYM D3DVOLUME_DESC}
TD3DVolumeDesc = _D3DVOLUME_DESC;
{ Structure for LockRect }
PD3DLockedRect = ^TD3DLockedRect;
_D3DLOCKED_RECT = packed record
Pitch: Integer;
pBits: Pointer; // void*
end {_D3DLOCKED_RECT};
{$EXTERNALSYM _D3DLOCKED_RECT}
D3DLOCKED_RECT = _D3DLOCKED_RECT;
{$EXTERNALSYM D3DLOCKED_RECT}
TD3DLockedRect = _D3DLOCKED_RECT;
{ Structures for LockBox }
PD3DBox = ^TD3DBox;
_D3DBOX = packed record
Left : LongWord;
Top : LongWord;
Right : LongWord;
Bottom : LongWord;
Front : LongWord;
Back : LongWord;
end {_D3DBOX};
{$EXTERNALSYM _D3DBOX}
D3DBOX = _D3DBOX;
{$EXTERNALSYM D3DBOX}
TD3DBox = _D3DBOX;
PD3DLockedBox = ^TD3DLockedBox;
_D3DLOCKED_BOX = packed record
RowPitch : Integer;
SlicePitch : Integer;
pBits : Pointer; // void*
end {_D3DLOCKED_BOX};
{$EXTERNALSYM _D3DLOCKED_BOX}
D3DLOCKED_BOX = _D3DLOCKED_BOX;
{$EXTERNALSYM D3DLOCKED_BOX}
TD3DLockedBox = _D3DLOCKED_BOX;
{ Structures for LockRange }
PD3DRange = ^TD3DRange;
_D3DRANGE = packed record
Offset : LongWord;
Size : LongWord;
end {_D3DRANGE};
{$EXTERNALSYM _D3DRANGE}
D3DRANGE = _D3DRANGE;
{$EXTERNALSYM D3DRANGE}
TD3DRange = _D3DRANGE;
{ Structures for high order primitives }
PD3DRectPatchInfo = ^TD3DRectPatchInfo;
_D3DRECTPATCH_INFO = packed record
StartVertexOffsetWidth : LongWord;
StartVertexOffsetHeight : LongWord;
Width : LongWord;
Height : LongWord;
Stride : LongWord;
Basis : TD3DBasisType;
Degree : TD3DDegreeType;
end;
{$EXTERNALSYM _D3DRECTPATCH_INFO}
D3DRECTPATCH_INFO = _D3DRECTPATCH_INFO;
{$EXTERNALSYM D3DRECTPATCH_INFO}
TD3DRectPatchInfo = _D3DRECTPATCH_INFO;
PD3DTriPatchInfo = ^TD3DTriPatchInfo;
_D3DTRIPATCH_INFO = packed record
StartVertexOffset : LongWord;
NumVertices : LongWord;
Basis : TD3DBasisType;
Degree : TD3DDegreeType;
end;
{$EXTERNALSYM _D3DTRIPATCH_INFO}
D3DTRIPATCH_INFO = _D3DTRIPATCH_INFO;
{$EXTERNALSYM D3DTRIPATCH_INFO}
TD3DTriPatchInfo = _D3DTRIPATCH_INFO;
const
{ Adapter Identifier }
MAX_DEVICE_IDENTIFIER_STRING = 512;
{$EXTERNALSYM MAX_DEVICE_IDENTIFIER_STRING}
type
PD3DAdapterIdentifier9 = ^TD3DAdapterIdentifier9;
_D3DADAPTER_IDENTIFIER9 = packed record
Driver : array [0..MAX_DEVICE_IDENTIFIER_STRING-1] of Char;
Description : array [0..MAX_DEVICE_IDENTIFIER_STRING-1] of Char;
DeviceName : array [0..31] of Char; { Device name for GDI (ex. \.DISPLAY1) }
{$IFDEF WIN32}
DriverVersion : Int64; { Defined for 32 bit components }
{$ELSE}
DriverVersionLowPart : DWord; { Defined for 16 bit driver components }
DriverVersionHighPart : DWord;
{$ENDIF}
VendorId : DWord;
DeviceId : DWord;
SubSysId : DWord;
Revision : DWord;
DeviceIdentifier : TGUID;
WHQLLevel : DWord;
end;
{$EXTERNALSYM _D3DADAPTER_IDENTIFIER9}
D3DADAPTER_IDENTIFIER9 = _D3DADAPTER_IDENTIFIER9;
{$EXTERNALSYM D3DADAPTER_IDENTIFIER9}
TD3DAdapterIdentifier9 = _D3DADAPTER_IDENTIFIER9;
{ Raster Status structure returned by GetRasterStatus }
PD3DRasterStatus = ^TD3DRasterStatus;
_D3DRASTER_STATUS = packed record
InVBlank : Bool;
ScanLine : LongWord;
end;
{$EXTERNALSYM _D3DRASTER_STATUS}
D3DRASTER_STATUS = _D3DRASTER_STATUS;
{$EXTERNALSYM D3DRASTER_STATUS}
TD3DRasterStatus = _D3DRASTER_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.
}
_D3DDEBUGMONITORTOKENS = DWord;
{$EXTERNALSYM _D3DDEBUGMONITORTOKENS}
D3DDEBUGMONITORTOKENS = _D3DDEBUGMONITORTOKENS;
{$EXTERNALSYM D3DDEBUGMONITORTOKENS}
TD3DDebugMonitorTokens = _D3DDEBUGMONITORTOKENS;
const
D3DDMT_ENABLE = 0; // enable debug monitor
{$EXTERNALSYM D3DDMT_ENABLE}
D3DDMT_DISABLE = 1; // disable debug monitor
{$EXTERNALSYM D3DDMT_DISABLE}
{$IFNDEF SUPPORTS_EXPL_ENUMS}
const
// Async feedback
D3DQUERYTYPE_VCACHE = 4; { D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_VCACHE}
D3DQUERYTYPE_RESOURCEMANAGER = 5; { D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_RESOURCEMANAGER}
D3DQUERYTYPE_VERTEXSTATS = 6; { D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_VERTEXSTATS}
D3DQUERYTYPE_EVENT = 8; { D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_EVENT}
D3DQUERYTYPE_OCCLUSION = 9; { D3DISSUE_BEGIN, D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_OCCLUSION}
D3DQUERYTYPE_TIMESTAMP = 10; { D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_TIMESTAMP}
D3DQUERYTYPE_TIMESTAMPDISJOINT = 11; { D3DISSUE_BEGIN, D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_TIMESTAMPDISJOINT}
D3DQUERYTYPE_TIMESTAMPFREQ = 12; { D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_TIMESTAMPFREQ}
D3DQUERYTYPE_PIPELINETIMINGS = 13; { D3DISSUE_BEGIN, D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_PIPELINETIMINGS}
D3DQUERYTYPE_INTERFACETIMINGS = 14; { D3DISSUE_BEGIN, D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_INTERFACETIMINGS}
D3DQUERYTYPE_VERTEXTIMINGS = 15; { D3DISSUE_BEGIN, D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_VERTEXTIMINGS}
D3DQUERYTYPE_PIXELTIMINGS = 16; { D3DISSUE_BEGIN, D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_PIXELTIMINGS}
D3DQUERYTYPE_BANDWIDTHTIMINGS = 17; { D3DISSUE_BEGIN, D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_BANDWIDTHTIMINGS}
D3DQUERYTYPE_CACHEUTILIZATION = 18; { D3DISSUE_BEGIN, D3DISSUE_END }
{$EXTERNALSYM D3DQUERYTYPE_CACHEUTILIZATION}
type
_D3DQUERYTYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$ELSE}
type
// Async feedback
{$MINENUMSIZE 1} // Forces TD3DQueryType be 1 byte enum
_D3DQUERYTYPE = (
D3DQUERYTYPE_VCACHE = 4, { D3DISSUE_END }
D3DQUERYTYPE_RESOURCEMANAGER = 5, { D3DISSUE_END }
D3DQUERYTYPE_VERTEXSTATS = 6, { D3DISSUE_END }
D3DQUERYTYPE_EVENT = 8, { D3DISSUE_END }
D3DQUERYTYPE_OCCLUSION = 9, { D3DISSUE_BEGIN, D3DISSUE_END }
D3DQUERYTYPE_TIMESTAMP = 10, { D3DISSUE_END }
D3DQUERYTYPE_TIMESTAMPDISJOINT = 11, { D3DISSUE_BEGIN, D3DISSUE_END }
D3DQUERYTYPE_TIMESTAMPFREQ = 12, { D3DISSUE_END }
D3DQUERYTYPE_PIPELINETIMINGS = 13, { D3DISSUE_BEGIN, D3DISSUE_END }
D3DQUERYTYPE_INTERFACETIMINGS = 14, { D3DISSUE_BEGIN, D3DISSUE_END }
D3DQUERYTYPE_VERTEXTIMINGS = 15, { D3DISSUE_BEGIN, D3DISSUE_END }
D3DQUERYTYPE_PIXELTIMINGS = 16, { D3DISSUE_BEGIN, D3DISSUE_END }
D3DQUERYTYPE_BANDWIDTHTIMINGS = 17, { D3DISSUE_BEGIN, D3DISSUE_END }
D3DQUERYTYPE_CACHEUTILIZATION = 18 { D3DISSUE_BEGIN, D3DISSUE_END }
);
{$MINENUMSIZE 4} // Restores enums to be 4 byte in size
{$ENDIF}
{$EXTERNALSYM _D3DQUERYTYPE}
D3DQUERYTYPE = _D3DQUERYTYPE;
{$EXTERNALSYM D3DQUERYTYPE}
TD3DQueryType = _D3DQUERYTYPE;
const
// Flags field for Issue
D3DISSUE_END = (1 shl 0); // Tells the runtime to issue the end of a query, changing it's state to "non-signaled".
{$EXTERNALSYM D3DISSUE_END}
D3DISSUE_BEGIN = (1 shl 1); // Tells the runtime to issue the beginng of a query.
{$EXTERNALSYM D3DISSUE_BEGIN}
// Flags field for GetData
D3DGETDATA_FLUSH = (1 shl 0); // Tells the runtime to flush if the query is outstanding.
{$EXTERNALSYM D3DGETDATA_FLUSH}
type
PD3DResourceStats = ^TD3DResourceStats;
_D3DRESOURCESTATS = packed record
// Data collected since last Present()
bThrashing : BOOL; (* indicates if thrashing *)
ApproxBytesDownloaded : DWORD; (* Approximate number of bytes downloaded by resource manager *)
NumEvicts : DWORD; (* number of objects evicted *)
NumVidCreates : DWORD; (* number of objects created in video memory *)
LastPri : DWORD; (* priority of last object evicted *)
NumUsed : DWORD; (* number of objects set to the device *)
NumUsedInVidMem : DWORD; (* number of objects set to the device, which are already in video memory *)
// Persistent data
WorkingSet : DWORD; (* number of objects in video memory *)
WorkingSetBytes : DWORD; (* number of bytes in video memory *)
TotalManaged : DWORD; (* total number of managed objects *)
TotalBytes : DWORD; (* total number of bytes of managed objects *)
end;
{$EXTERNALSYM _D3DRESOURCESTATS}
D3DRESOURCESTATS = _D3DRESOURCESTATS;
{$EXTERNALSYM D3DRESOURCESTATS}
TD3DResourceStats = _D3DRESOURCESTATS;
const
D3DRTYPECOUNT = (DWORD(D3DRTYPE_INDEXBUFFER) + 1);
{$EXTERNALSYM D3DRTYPECOUNT}
type
PD3DDevInfoResourceManager = ^TD3DDevInfoResourceManager;
_D3DDEVINFO_RESOURCEMANAGER = packed record
//#ifndef WOW64_ENUM_WORKAROUND
stats: array [0..D3DRTYPECOUNT-1] of TD3DResourceStats;
//#else
// stats: array[0..7] of TD3DResourceStats;
//#endif
end;
{$EXTERNALSYM _D3DDEVINFO_RESOURCEMANAGER}
D3DDEVINFO_RESOURCEMANAGER = _D3DDEVINFO_RESOURCEMANAGER;
{$EXTERNALSYM D3DDEVINFO_RESOURCEMANAGER}
TD3DDevInfoResourceManager = _D3DDEVINFO_RESOURCEMANAGER;
PD3DDevInfoD3DVertexStats = ^TD3DDevInfoD3DVertexStats;
_D3DDEVINFO_D3DVERTEXSTATS = packed record
NumRenderedTriangles : DWORD; (* total number of triangles that are not clipped in this frame *)
NumExtraClippingTriangles : DWORD; (* Number of new triangles generated by clipping *)
end;
{$EXTERNALSYM _D3DDEVINFO_D3DVERTEXSTATS}
D3DDEVINFO_D3DVERTEXSTATS = _D3DDEVINFO_D3DVERTEXSTATS;
{$EXTERNALSYM D3DDEVINFO_D3DVERTEXSTATS}
TD3DDevInfoD3DVertexStats = _D3DDEVINFO_D3DVERTEXSTATS;
PD3DDevInfoVCache = ^TD3DDevInfoVCache;
_D3DDEVINFO_VCACHE = packed record
Pattern : DWORD; (* bit pattern, return value must be FOUR_CC('C', 'A', 'C', 'H') *)
OptMethod : DWORD; (* optimization method 0 means longest strips, 1 means vertex cache based *)
CacheSize : DWORD; (* cache size to optimize for (only required if type is 1) *)
MagicNumber : DWORD; (* used to determine when to restart strips (only required if type is 1)*)
end;
{$EXTERNALSYM _D3DDEVINFO_VCACHE}
D3DDEVINFO_VCACHE = _D3DDEVINFO_VCACHE;
{$EXTERNALSYM D3DDEVINFO_VCACHE}
TD3DDevInfoVCache = _D3DDEVINFO_VCACHE;
PD3DDevInfoD3D9PipelineTimings = ^TD3DDevInfoD3D9PipelineTimings;
_D3DDEVINFO_D3D9PIPELINETIMINGS = packed record
VertexProcessingTimePercent: Single;
PixelProcessingTimePercent: Single;
OtherGPUProcessingTimePercent: Single;
GPUIdleTimePercent: Single;
end;
{$EXTERNALSYM _D3DDEVINFO_D3D9PIPELINETIMINGS}
D3DDEVINFO_D3D9PIPELINETIMINGS = _D3DDEVINFO_D3D9PIPELINETIMINGS;
{$EXTERNALSYM D3DDEVINFO_D3D9PIPELINETIMINGS}
TD3DDevInfoD3D9PipelineTimings = _D3DDEVINFO_D3D9PIPELINETIMINGS;
PD3DDevInfoD3D9InterfaceTimings = ^TD3DDevInfoD3D9InterfaceTimings;
_D3DDEVINFO_D3D9INTERFACETIMINGS = packed record
WaitingForGPUToUseApplicationResourceTimePercent: Single;
WaitingForGPUToAcceptMoreCommandsTimePercent: Single;
WaitingForGPUToStayWithinLatencyTimePercent: Single;
WaitingForGPUExclusiveResourceTimePercent: Single;
WaitingForGPUOtherTimePercent: Single;
end;
{$EXTERNALSYM _D3DDEVINFO_D3D9INTERFACETIMINGS}
D3DDEVINFO_D3D9INTERFACETIMINGS = _D3DDEVINFO_D3D9INTERFACETIMINGS;
{$EXTERNALSYM D3DDEVINFO_D3D9INTERFACETIMINGS}
TD3DDevInfoD3D9InterfaceTimings = _D3DDEVINFO_D3D9INTERFACETIMINGS;
PD3DDevInfoD3D9StageTimings = ^TD3DDevInfoD3D9StageTimings;
_D3DDEVINFO_D3D9STAGETIMINGS = packed record
MemoryProcessingPercent: Single;
ComputationProcessingPercent: Single;
end;
{$EXTERNALSYM _D3DDEVINFO_D3D9STAGETIMINGS}
D3DDEVINFO_D3D9STAGETIMINGS = _D3DDEVINFO_D3D9STAGETIMINGS;
{$EXTERNALSYM D3DDEVINFO_D3D9STAGETIMINGS}
TD3DDevInfoD3D9StageTimings = _D3DDEVINFO_D3D9STAGETIMINGS;
PD3DDevInfoD3D9BandwidthTimings = ^TD3DDevInfoD3D9BandwidthTimings;
_D3DDEVINFO_D3D9BANDWIDTHTIMINGS = packed record
MaxBandwidthUtilized: Single;
FrontEndUploadMemoryUtilizedPercent: Single;
VertexRateUtilizedPercent: Single;
TriangleSetupRateUtilizedPercent: Single;
FillRateUtilizedPercent: Single;
end;
{$EXTERNALSYM _D3DDEVINFO_D3D9BANDWIDTHTIMINGS}
D3DDEVINFO_D3D9BANDWIDTHTIMINGS = _D3DDEVINFO_D3D9BANDWIDTHTIMINGS;
{$EXTERNALSYM D3DDEVINFO_D3D9BANDWIDTHTIMINGS}
TD3DDevInfoD3D9BandwidthTimings = _D3DDEVINFO_D3D9BANDWIDTHTIMINGS;
PD3DDevInfoD3D9CacheUtilization = ^TD3DDevInfoD3D9CacheUtilization;
_D3DDEVINFO_D3D9CACHEUTILIZATION = packed record
TextureCacheHitRate: Single; // Percentage of cache hits
PostTransformVertexCacheHitRate: Single;
end;
{$EXTERNALSYM _D3DDEVINFO_D3D9CACHEUTILIZATION}
D3DDEVINFO_D3D9CACHEUTILIZATION = _D3DDEVINFO_D3D9CACHEUTILIZATION;
{$EXTERNALSYM D3DDEVINFO_D3D9CACHEUTILIZATION}
TD3DDevInfoD3D9CacheUtilization = _D3DDEVINFO_D3D9CACHEUTILIZATION;
{$IFDEF DIRECT3D_VERSION_9_VISTA}
PD3DComposeRectsOp = ^TD3DComposeRectsOp;
_D3DCOMPOSERECTSOP =
(
D3DCOMPOSERECTS_INVALID_0,
D3DCOMPOSERECTS_COPY {= 1},
D3DCOMPOSERECTS_OR {= 2},
D3DCOMPOSERECTS_AND {= 3},
D3DCOMPOSERECTS_NEG {= 4}
);
{$EXTERNALSYM _D3DCOMPOSERECTSOP}
D3DCOMPOSERECTSOP = _D3DCOMPOSERECTSOP;
{$EXTERNALSYM D3DCOMPOSERECTSOP}
TD3DComposeRectsOp = _D3DCOMPOSERECTSOP;
PD3DComposeRectDesc = ^TD3DComposeRectDesc;
_D3DCOMPOSERECTDESC = record
X, Y: Word; // Top-left coordinates of a rect in the source surface
Width, Height: Word; // Dimensions of the rect
end;
{$EXTERNALSYM _D3DCOMPOSERECTDESC}
D3DCOMPOSERECTDESC = _D3DCOMPOSERECTDESC;
{$EXTERNALSYM D3DCOMPOSERECTDESC}
TD3DComposeRectDesc = _D3DCOMPOSERECTDESC;
PD3DComposeRectDestination = ^TD3DComposeRectDestination;
_D3DCOMPOSERECTDESTINATION = record
SrcRectIndex: Word; // Index of D3DCOMPOSERECTDESC
Reserved: Word; // For alignment
X, Y: Smallint; // Top-left coordinates of the rect in the destination surface
end;
{$EXTERNALSYM _D3DCOMPOSERECTDESTINATION}
D3DCOMPOSERECTDESTINATION = _D3DCOMPOSERECTDESTINATION;
{$EXTERNALSYM D3DCOMPOSERECTDESTINATION}
TD3DComposeRectDestination = _D3DCOMPOSERECTDESTINATION;
const
D3DCOMPOSERECTS_MAXNUMRECTS = $FFFF;
{$EXTERNALSYM D3DCOMPOSERECTS_MAXNUMRECTS}
D3DCONVOLUTIONMONO_MAXWIDTH = 7;
{$EXTERNALSYM D3DCONVOLUTIONMONO_MAXWIDTH}
D3DCONVOLUTIONMONO_MAXHEIGHT = D3DCONVOLUTIONMONO_MAXWIDTH;
{$EXTERNALSYM D3DCONVOLUTIONMONO_MAXHEIGHT}
D3DFMT_A1_SURFACE_MAXWIDTH = 8192;
{$EXTERNALSYM D3DFMT_A1_SURFACE_MAXWIDTH}
D3DFMT_A1_SURFACE_MAXHEIGHT = 2048;
{$EXTERNALSYM D3DFMT_A1_SURFACE_MAXHEIGHT}
type
PD3DPresentStats = ^TD3DPresentStats;
_D3DPRESENTSTATS = record
PresentCount: LongWord;
PresentRefreshCount: LongWord;
SyncRefreshCount: LongWord;
SyncQPCTime: LARGE_INTEGER;
SyncGPUTime: LARGE_INTEGER;
end;
{$EXTERNALSYM _D3DPRESENTSTATS}
D3DPRESENTSTATS = _D3DPRESENTSTATS;
{$EXTERNALSYM D3DPRESENTSTATS}
TD3DPresentStats = _D3DPRESENTSTATS;
PD3DScanlineOrdering = ^TD3DScanlineOrdering;
D3DSCANLINEORDERING = (
D3DSCANLINEORDERING_INVALID_0,
D3DSCANLINEORDERING_PROGRESSIVE {= 1},
D3DSCANLINEORDERING_INTERLACED {= 2}
);
{$EXTERNALSYM D3DSCANLINEORDERING}
TD3DScanlineOrdering = D3DSCANLINEORDERING;
PD3DDisplayModeEx = ^TD3DDisplayModeEx;
D3DDISPLAYMODEEX = record
Size: LongWord;
Width: LongWord;
Height: LongWord;
RefreshRate: LongWord;
Format: TD3DFormat;
ScanLineOrdering: TD3DScanlineOrdering;
end;
{$EXTERNALSYM D3DDISPLAYMODEEX}
TD3DDisplayModeEx = D3DDISPLAYMODEEX;
PD3DDisplayModeFilter = ^TD3DDisplayModeFilter;
D3DDISPLAYMODEFILTER = record
Size: LongWord;
Format: TD3DFormat;
ScanLineOrdering: TD3DScanlineOrdering;
end;
{$EXTERNALSYM D3DDISPLAYMODEFILTER}
TD3DDisplayModeFilter = D3DDISPLAYMODEFILTER;
PD3DDisplayRotation = ^TD3DDisplayRotation;
D3DDISPLAYROTATION =
(
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DDISPLAYROTATION_INVALID_0,
D3DDISPLAYROTATION_IDENTITY {= 1}, // No rotation.
D3DDISPLAYROTATION_90 {= 2}, // Rotated 90 degrees.
D3DDISPLAYROTATION_180 {= 3}, // Rotated 180 degrees.
D3DDISPLAYROTATION_270 {= 4} // Rotated 270 degrees.
{$ELSE}
D3DDISPLAYROTATION_IDENTITY = 1, // No rotation.
D3DDISPLAYROTATION_90 = 2, // Rotated 90 degrees.
D3DDISPLAYROTATION_180 = 3, // Rotated 180 degrees.
D3DDISPLAYROTATION_270 = 4 // Rotated 270 degrees.
{$ENDIF}
);
{$EXTERNALSYM D3DDISPLAYROTATION}
TD3DDisplayRotation = D3DDISPLAYROTATION;
{$ENDIF}
(*==========================================================================;
*
*
* File: d3d9caps.h
* Content: Direct3D capabilities include file
*
***************************************************************************)
type
PD3DVShaderCaps2_0 = ^TD3DVShaderCaps2_0;
_D3DVSHADERCAPS2_0 = packed record
Caps: DWORD;
DynamicFlowControlDepth: Integer;
NumTemps: Integer;
StaticFlowControlDepth: Integer;
end;
{$EXTERNALSYM _D3DVSHADERCAPS2_0}
D3DVSHADERCAPS2_0 = _D3DVSHADERCAPS2_0;
{$EXTERNALSYM D3DVSHADERCAPS2_0}
TD3DVShaderCaps2_0 = _D3DVSHADERCAPS2_0;
const
D3DVS20CAPS_PREDICATION = (1 shl 0);
{$EXTERNALSYM D3DVS20CAPS_PREDICATION}
D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH = 24;
{$EXTERNALSYM D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH}
D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0;
{$EXTERNALSYM D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH}
D3DVS20_MAX_NUMTEMPS = 32;
{$EXTERNALSYM D3DVS20_MAX_NUMTEMPS}
D3DVS20_MIN_NUMTEMPS = 12;
{$EXTERNALSYM D3DVS20_MIN_NUMTEMPS}
D3DVS20_MAX_STATICFLOWCONTROLDEPTH = 4;
{$EXTERNALSYM D3DVS20_MAX_STATICFLOWCONTROLDEPTH}
D3DVS20_MIN_STATICFLOWCONTROLDEPTH = 1;
{$EXTERNALSYM D3DVS20_MIN_STATICFLOWCONTROLDEPTH}
type
PD3DPShaderCaps2_0 = ^TD3DPShaderCaps2_0;
_D3DPSHADERCAPS2_0 = packed record
Caps: DWORD;
DynamicFlowControlDepth: Integer;
NumTemps: Integer;
StaticFlowControlDepth: Integer;
NumInstructionSlots: Integer;
end;
{$EXTERNALSYM _D3DPSHADERCAPS2_0}
D3DPSHADERCAPS2_0 = _D3DPSHADERCAPS2_0;
{$EXTERNALSYM D3DPSHADERCAPS2_0}
TD3DPShaderCaps2_0 = _D3DPSHADERCAPS2_0;
const
D3DPS20CAPS_ARBITRARYSWIZZLE = (1 shl 0);
{$EXTERNALSYM D3DPS20CAPS_ARBITRARYSWIZZLE}
D3DPS20CAPS_GRADIENTINSTRUCTIONS = (1 shl 1);
{$EXTERNALSYM D3DPS20CAPS_GRADIENTINSTRUCTIONS}
D3DPS20CAPS_PREDICATION = (1 shl 2);
{$EXTERNALSYM D3DPS20CAPS_PREDICATION}
D3DPS20CAPS_NODEPENDENTREADLIMIT = (1 shl 3);
{$EXTERNALSYM D3DPS20CAPS_NODEPENDENTREADLIMIT}
D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT = (1 shl 4);
{$EXTERNALSYM D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT}
D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH = 24;
{$EXTERNALSYM D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH}
D3DPS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0;
{$EXTERNALSYM D3DPS20_MIN_DYNAMICFLOWCONTROLDEPTH}
D3DPS20_MAX_NUMTEMPS = 32;
{$EXTERNALSYM D3DPS20_MAX_NUMTEMPS}
D3DPS20_MIN_NUMTEMPS = 12;
{$EXTERNALSYM D3DPS20_MIN_NUMTEMPS}
D3DPS20_MAX_STATICFLOWCONTROLDEPTH = 4;
{$EXTERNALSYM D3DPS20_MAX_STATICFLOWCONTROLDEPTH}
D3DPS20_MIN_STATICFLOWCONTROLDEPTH = 0;
{$EXTERNALSYM D3DPS20_MIN_STATICFLOWCONTROLDEPTH}
D3DPS20_MAX_NUMINSTRUCTIONSLOTS = 512;
{$EXTERNALSYM D3DPS20_MAX_NUMINSTRUCTIONSLOTS}
D3DPS20_MIN_NUMINSTRUCTIONSLOTS = 96;
{$EXTERNALSYM D3DPS20_MIN_NUMINSTRUCTIONSLOTS}
D3DMIN30SHADERINSTRUCTIONS = 512;
{$EXTERNALSYM D3DMIN30SHADERINSTRUCTIONS}
D3DMAX30SHADERINSTRUCTIONS = 32768;
{$EXTERNALSYM D3DMAX30SHADERINSTRUCTIONS}
type
PD3DCaps9 = ^TD3DCaps9;
_D3DCAPS9 = record
(* Device Info *)
DeviceType: TD3DDevType;
AdapterOrdinal: DWord;
(* Caps from DX7 Draw *)
Caps: DWord;
Caps2: DWord;
Caps3: DWord;
PresentationIntervals: DWord;
(* Cursor Caps *)
CursorCaps: DWORD;
(* 3D Device Caps *)
DevCaps: DWord;
PrimitiveMiscCaps: DWord;
RasterCaps: DWord;
ZCmpCaps: DWord;
SrcBlendCaps: DWord;
DestBlendCaps: DWord;
AlphaCmpCaps: DWord;
ShadeCaps: DWord;
TextureCaps: DWord;
TextureFilterCaps: DWord; // D3DPTFILTERCAPS for IDirect3DTexture9's
CubeTextureFilterCaps: DWord; // D3DPTFILTERCAPS for IDirect3DCubeTexture9's
VolumeTextureFilterCaps: DWord; // D3DPTFILTERCAPS for IDirect3DVolumeTexture9's
TextureAddressCaps: DWord; // D3DPTADDRESSCAPS for IDirect3DTexture9's
VolumeTextureAddressCaps: DWord; // D3DPTADDRESSCAPS for IDirect3DVolumeTexture9's
LineCaps: DWord; // D3DLINECAPS
MaxTextureWidth, MaxTextureHeight: DWord;
MaxVolumeExtent: DWord;
MaxTextureRepeat: DWord;
MaxTextureAspectRatio: DWord;
MaxAnisotropy: DWord;
MaxVertexW: Single;
GuardBandLeft: Single;
GuardBandTop: Single;
GuardBandRight: Single;
GuardBandBottom: Single;
ExtentsAdjust: Single;
StencilCaps: DWord;
FVFCaps: DWord;
TextureOpCaps: DWord;
MaxTextureBlendStages: DWord;
MaxSimultaneousTextures: DWord;
VertexProcessingCaps: DWord;
MaxActiveLights: DWord;
MaxUserClipPlanes: DWord;
MaxVertexBlendMatrices: DWord;
MaxVertexBlendMatrixIndex: DWord;
MaxPointSize: Single;
MaxPrimitiveCount: DWord; // max number of primitives per DrawPrimitive call
MaxVertexIndex: DWord;
MaxStreams: DWord;
MaxStreamStride: DWord; // max stride for SetStreamSource
VertexShaderVersion: DWord;
MaxVertexShaderConst: DWord; // number of vertex shader constant registers
PixelShaderVersion: DWord;
PixelShader1xMaxValue: Single; // max value storable in registers of ps.1.x shaders
// Here are the DX9 specific ones
DevCaps2: DWORD;
MaxNpatchTessellationLevel: Single;
Reserved5: DWORD;
MasterAdapterOrdinal: LongWord; // ordinal of master adaptor for adapter group
AdapterOrdinalInGroup: LongWord; // ordinal inside the adapter group
NumberOfAdaptersInGroup: LongWord; // number of adapters in this adapter group (only if master)
DeclTypes: DWORD; // Data types, supported in vertex declarations
NumSimultaneousRTs: DWORD; // Will be at least 1
StretchRectFilterCaps: DWORD; // Filter caps supported by StretchRect
VS20Caps: TD3DVShaderCaps2_0;
PS20Caps: TD3DPShaderCaps2_0;
VertexTextureFilterCaps: DWORD; // D3DPTFILTERCAPS for IDirect3DTexture9's for texture, used in vertex shaders
MaxVShaderInstructionsExecuted: DWORD; // maximum number of vertex shader instructions that can be executed
MaxPShaderInstructionsExecuted: DWORD; // maximum number of pixel shader instructions that can be executed
MaxVertexShader30InstructionSlots: DWORD;
MaxPixelShader30InstructionSlots: DWORD;
end {D3DCAPS9};
{$EXTERNALSYM _D3DCAPS9}
D3DCAPS9 = _D3DCAPS9;
{$EXTERNALSYM D3DCAPS9}
TD3DCaps9 = _D3DCAPS9;
//
// BIT DEFINES FOR D3DCAPS9 DWORD MEMBERS
//
const
//
// Caps
//
D3DCAPS_READ_SCANLINE = $00020000;
{$EXTERNALSYM D3DCAPS_READ_SCANLINE}
//
// Caps2
//
D3DCAPS2_FULLSCREENGAMMA = $00020000;
{$EXTERNALSYM D3DCAPS2_FULLSCREENGAMMA}
D3DCAPS2_CANCALIBRATEGAMMA = $00100000;
{$EXTERNALSYM D3DCAPS2_CANCALIBRATEGAMMA}
D3DCAPS2_RESERVED = $02000000;
{$EXTERNALSYM D3DCAPS2_RESERVED}
D3DCAPS2_CANMANAGERESOURCE = $10000000;
{$EXTERNALSYM D3DCAPS2_CANMANAGERESOURCE}
D3DCAPS2_DYNAMICTEXTURES = $20000000;
{$EXTERNALSYM D3DCAPS2_DYNAMICTEXTURES}
D3DCAPS2_CANAUTOGENMIPMAP = $40000000;
{$EXTERNALSYM D3DCAPS2_CANAUTOGENMIPMAP}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
D3DCAPS2_CANSHARERESOURCE = $80000000;
{$EXTERNALSYM D3DCAPS2_CANSHARERESOURCE}
{$ENDIF}
//
// Caps3
//
D3DCAPS3_RESERVED = $8000001F;
{$EXTERNALSYM D3DCAPS3_RESERVED}
// 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;
{$EXTERNALSYM D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD}
// Indicates that the device can perform a gamma correction from
// a windowed back buffer containing linear content to the sRGB desktop.
D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION = $00000080;
{$EXTERNALSYM D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION}
D3DCAPS3_COPY_TO_VIDMEM = $00000100; { Device can acclerate copies from sysmem to local vidmem }
{$EXTERNALSYM D3DCAPS3_COPY_TO_VIDMEM}
D3DCAPS3_COPY_TO_SYSTEMMEM = $00000200; { Device can acclerate copies from local vidmem to sysmem }
{$EXTERNALSYM D3DCAPS3_COPY_TO_SYSTEMMEM}
//
// PresentationIntervals
//
D3DPRESENT_INTERVAL_DEFAULT = $00000000;
{$EXTERNALSYM D3DPRESENT_INTERVAL_DEFAULT}
D3DPRESENT_INTERVAL_ONE = $00000001;
{$EXTERNALSYM D3DPRESENT_INTERVAL_ONE}
D3DPRESENT_INTERVAL_TWO = $00000002;
{$EXTERNALSYM D3DPRESENT_INTERVAL_TWO}
D3DPRESENT_INTERVAL_THREE = $00000004;
{$EXTERNALSYM D3DPRESENT_INTERVAL_THREE}
D3DPRESENT_INTERVAL_FOUR = $00000008;
{$EXTERNALSYM D3DPRESENT_INTERVAL_FOUR}
D3DPRESENT_INTERVAL_IMMEDIATE = $80000000;
{$EXTERNALSYM D3DPRESENT_INTERVAL_IMMEDIATE}
//
// CursorCaps
//
// Driver supports HW color cursor in at least hi-res modes(height >=400)
D3DCURSORCAPS_COLOR = $00000001;
{$EXTERNALSYM D3DCURSORCAPS_COLOR}
// Driver supports HW cursor also in low-res modes(height < 400)
D3DCURSORCAPS_LOWRES = $00000002;
{$EXTERNALSYM D3DCURSORCAPS_LOWRES}
//
// DevCaps
//
D3DDEVCAPS_EXECUTESYSTEMMEMORY = $00000010; { Device can use execute buffers from system memory }
{$EXTERNALSYM D3DDEVCAPS_EXECUTESYSTEMMEMORY}
D3DDEVCAPS_EXECUTEVIDEOMEMORY = $00000020; { Device can use execute buffers from video memory }
{$EXTERNALSYM D3DDEVCAPS_EXECUTEVIDEOMEMORY}
D3DDEVCAPS_TLVERTEXSYSTEMMEMORY = $00000040; { Device can use TL buffers from system memory }
{$EXTERNALSYM D3DDEVCAPS_TLVERTEXSYSTEMMEMORY}
D3DDEVCAPS_TLVERTEXVIDEOMEMORY = $00000080; { Device can use TL buffers from video memory }
{$EXTERNALSYM D3DDEVCAPS_TLVERTEXVIDEOMEMORY}
D3DDEVCAPS_TEXTURESYSTEMMEMORY = $00000100; { Device can texture from system memory }
{$EXTERNALSYM D3DDEVCAPS_TEXTURESYSTEMMEMORY}
D3DDEVCAPS_TEXTUREVIDEOMEMORY = $00000200; { Device can texture from device memory }
{$EXTERNALSYM D3DDEVCAPS_TEXTUREVIDEOMEMORY}
D3DDEVCAPS_DRAWPRIMTLVERTEX = $00000400; { Device can draw TLVERTEX primitives }
{$EXTERNALSYM D3DDEVCAPS_DRAWPRIMTLVERTEX}
D3DDEVCAPS_CANRENDERAFTERFLIP = $00000800; { Device can render without waiting for flip to complete }
{$EXTERNALSYM D3DDEVCAPS_CANRENDERAFTERFLIP}
D3DDEVCAPS_TEXTURENONLOCALVIDMEM = $00001000; { Device can texture from nonlocal video memory }
{$EXTERNALSYM D3DDEVCAPS_TEXTURENONLOCALVIDMEM}
D3DDEVCAPS_DRAWPRIMITIVES2 = $00002000; { Device can support DrawPrimitives2 }
{$EXTERNALSYM D3DDEVCAPS_DRAWPRIMITIVES2}
D3DDEVCAPS_SEPARATETEXTUREMEMORIES = $00004000; { Device is texturing from separate memory pools }
{$EXTERNALSYM D3DDEVCAPS_SEPARATETEXTUREMEMORIES}
D3DDEVCAPS_DRAWPRIMITIVES2EX = $00008000; { Device can support Extended DrawPrimitives2 i.e. DX7 compliant driver }
{$EXTERNALSYM D3DDEVCAPS_DRAWPRIMITIVES2EX}
D3DDEVCAPS_HWTRANSFORMANDLIGHT = $00010000; { Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also }
{$EXTERNALSYM D3DDEVCAPS_HWTRANSFORMANDLIGHT}
D3DDEVCAPS_CANBLTSYSTONONLOCAL = $00020000; { Device supports a Tex Blt from system memory to non-local vidmem }
{$EXTERNALSYM D3DDEVCAPS_CANBLTSYSTONONLOCAL}
D3DDEVCAPS_HWRASTERIZATION = $00080000; { Device has HW acceleration for rasterization }
{$EXTERNALSYM D3DDEVCAPS_HWRASTERIZATION}
D3DDEVCAPS_PUREDEVICE = $00100000; { Device supports D3DCREATE_PUREDEVICE }
{$EXTERNALSYM D3DDEVCAPS_PUREDEVICE}
D3DDEVCAPS_QUINTICRTPATCHES = $00200000; { Device supports quintic Beziers and BSplines }
{$EXTERNALSYM D3DDEVCAPS_QUINTICRTPATCHES}
D3DDEVCAPS_RTPATCHES = $00400000; { Device supports Rect and Tri patches }
{$EXTERNALSYM D3DDEVCAPS_RTPATCHES}
D3DDEVCAPS_RTPATCHHANDLEZERO = $00800000; { Indicates that RT Patches may be drawn efficiently using handle 0 }
{$EXTERNALSYM D3DDEVCAPS_RTPATCHHANDLEZERO}
D3DDEVCAPS_NPATCHES = $01000000; { Device supports N-Patches }
{$EXTERNALSYM D3DDEVCAPS_NPATCHES}
//
// PrimitiveMiscCaps
//
D3DPMISCCAPS_MASKZ = $00000002;
{$EXTERNALSYM D3DPMISCCAPS_MASKZ}
D3DPMISCCAPS_CULLNONE = $00000010;
{$EXTERNALSYM D3DPMISCCAPS_CULLNONE}
D3DPMISCCAPS_CULLCW = $00000020;
{$EXTERNALSYM D3DPMISCCAPS_CULLCW}
D3DPMISCCAPS_CULLCCW = $00000040;
{$EXTERNALSYM D3DPMISCCAPS_CULLCCW}
D3DPMISCCAPS_COLORWRITEENABLE = $00000080;
{$EXTERNALSYM D3DPMISCCAPS_COLORWRITEENABLE}
D3DPMISCCAPS_CLIPPLANESCALEDPOINTS = $00000100; { Device correctly clips scaled points to clip planes }
{$EXTERNALSYM D3DPMISCCAPS_CLIPPLANESCALEDPOINTS}
D3DPMISCCAPS_CLIPTLVERTS = $00000200; { device will clip post-transformed vertex primitives }
{$EXTERNALSYM D3DPMISCCAPS_CLIPTLVERTS}
D3DPMISCCAPS_TSSARGTEMP = $00000400; { device supports D3DTA_TEMP for temporary register }
{$EXTERNALSYM D3DPMISCCAPS_TSSARGTEMP}
D3DPMISCCAPS_BLENDOP = $00000800; { device supports D3DRS_BLENDOP }
{$EXTERNALSYM D3DPMISCCAPS_BLENDOP}
D3DPMISCCAPS_NULLREFERENCE = $00001000; { Reference Device that doesnt render }
{$EXTERNALSYM D3DPMISCCAPS_NULLREFERENCE}
D3DPMISCCAPS_INDEPENDENTWRITEMASKS = $00004000; { Device supports independent write masks for MET or MRT }
{$EXTERNALSYM D3DPMISCCAPS_INDEPENDENTWRITEMASKS}
D3DPMISCCAPS_PERSTAGECONSTANT = $00008000; { Device supports per-stage constants }
{$EXTERNALSYM D3DPMISCCAPS_PERSTAGECONSTANT}
D3DPMISCCAPS_FOGANDSPECULARALPHA = $00010000; { Device supports separate fog and specular alpha (many devices
use the specular alpha channel to store fog factor) }
{$EXTERNALSYM D3DPMISCCAPS_FOGANDSPECULARALPHA}
D3DPMISCCAPS_SEPARATEALPHABLEND = $00020000; { Device supports separate blend settings for the alpha channel }
{$EXTERNALSYM D3DPMISCCAPS_SEPARATEALPHABLEND}
D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS = $00040000; { Device supports different bit depths for MRT }
{$EXTERNALSYM D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS}
D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING = $00080000; { Device supports post-pixel shader operations for MRT }
{$EXTERNALSYM D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING}
D3DPMISCCAPS_FOGVERTEXCLAMPED = $00100000; { Device clamps fog blend factor per vertex }
{$EXTERNALSYM D3DPMISCCAPS_FOGVERTEXCLAMPED}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
D3DPMISCCAPS_POSTBLENDSRGBCONVERT = $00200000; { Indicates device can perform conversion to sRGB after blending. }
{$EXTERNALSYM D3DPMISCCAPS_POSTBLENDSRGBCONVERT}
{$ENDIF}
//
// LineCaps
//
D3DLINECAPS_TEXTURE = $00000001;
{$EXTERNALSYM D3DLINECAPS_TEXTURE}
D3DLINECAPS_ZTEST = $00000002;
{$EXTERNALSYM D3DLINECAPS_ZTEST}
D3DLINECAPS_BLEND = $00000004;
{$EXTERNALSYM D3DLINECAPS_BLEND}
D3DLINECAPS_ALPHACMP = $00000008;
{$EXTERNALSYM D3DLINECAPS_ALPHACMP}
D3DLINECAPS_FOG = $00000010;
{$EXTERNALSYM D3DLINECAPS_FOG}
D3DLINECAPS_ANTIALIAS = $00000020;
{$EXTERNALSYM D3DLINECAPS_ANTIALIAS}
//
// RasterCaps
//
D3DPRASTERCAPS_DITHER = $00000001;
{$EXTERNALSYM D3DPRASTERCAPS_DITHER}
D3DPRASTERCAPS_ZTEST = $00000010;
{$EXTERNALSYM D3DPRASTERCAPS_ZTEST}
D3DPRASTERCAPS_FOGVERTEX = $00000080;
{$EXTERNALSYM D3DPRASTERCAPS_FOGVERTEX}
D3DPRASTERCAPS_FOGTABLE = $00000100;
{$EXTERNALSYM D3DPRASTERCAPS_FOGTABLE}
D3DPRASTERCAPS_MIPMAPLODBIAS = $00002000;
{$EXTERNALSYM D3DPRASTERCAPS_MIPMAPLODBIAS}
D3DPRASTERCAPS_ZBUFFERLESSHSR = $00008000;
{$EXTERNALSYM D3DPRASTERCAPS_ZBUFFERLESSHSR}
D3DPRASTERCAPS_FOGRANGE = $00010000;
{$EXTERNALSYM D3DPRASTERCAPS_FOGRANGE}
D3DPRASTERCAPS_ANISOTROPY = $00020000;
{$EXTERNALSYM D3DPRASTERCAPS_ANISOTROPY}
D3DPRASTERCAPS_WBUFFER = $00040000;
{$EXTERNALSYM D3DPRASTERCAPS_WBUFFER}
D3DPRASTERCAPS_WFOG = $00100000;
{$EXTERNALSYM D3DPRASTERCAPS_WFOG}
D3DPRASTERCAPS_ZFOG = $00200000;
{$EXTERNALSYM D3DPRASTERCAPS_ZFOG}
D3DPRASTERCAPS_COLORPERSPECTIVE = $00400000; { Device iterates colors perspective correct }
{$EXTERNALSYM D3DPRASTERCAPS_COLORPERSPECTIVE}
D3DPRASTERCAPS_SCISSORTEST = $01000000;
{$EXTERNALSYM D3DPRASTERCAPS_SCISSORTEST}
D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS = $02000000;
{$EXTERNALSYM D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS}
D3DPRASTERCAPS_DEPTHBIAS = $04000000;
{$EXTERNALSYM D3DPRASTERCAPS_DEPTHBIAS}
D3DPRASTERCAPS_MULTISAMPLE_TOGGLE = $08000000;
{$EXTERNALSYM D3DPRASTERCAPS_MULTISAMPLE_TOGGLE}
//
// ZCmpCaps, AlphaCmpCaps
//
D3DPCMPCAPS_NEVER = $00000001;
{$EXTERNALSYM D3DPCMPCAPS_NEVER}
D3DPCMPCAPS_LESS = $00000002;
{$EXTERNALSYM D3DPCMPCAPS_LESS}
D3DPCMPCAPS_EQUAL = $00000004;
{$EXTERNALSYM D3DPCMPCAPS_EQUAL}
D3DPCMPCAPS_LESSEQUAL = $00000008;
{$EXTERNALSYM D3DPCMPCAPS_LESSEQUAL}
D3DPCMPCAPS_GREATER = $00000010;
{$EXTERNALSYM D3DPCMPCAPS_GREATER}
D3DPCMPCAPS_NOTEQUAL = $00000020;
{$EXTERNALSYM D3DPCMPCAPS_NOTEQUAL}
D3DPCMPCAPS_GREATEREQUAL = $00000040;
{$EXTERNALSYM D3DPCMPCAPS_GREATEREQUAL}
D3DPCMPCAPS_ALWAYS = $00000080;
{$EXTERNALSYM D3DPCMPCAPS_ALWAYS}
//
// SourceBlendCaps, DestBlendCaps
//
D3DPBLENDCAPS_ZERO = $00000001;
{$EXTERNALSYM D3DPBLENDCAPS_ZERO}
D3DPBLENDCAPS_ONE = $00000002;
{$EXTERNALSYM D3DPBLENDCAPS_ONE}
D3DPBLENDCAPS_SRCCOLOR = $00000004;
{$EXTERNALSYM D3DPBLENDCAPS_SRCCOLOR}
D3DPBLENDCAPS_INVSRCCOLOR = $00000008;
{$EXTERNALSYM D3DPBLENDCAPS_INVSRCCOLOR}
D3DPBLENDCAPS_SRCALPHA = $00000010;
{$EXTERNALSYM D3DPBLENDCAPS_SRCALPHA}
D3DPBLENDCAPS_INVSRCALPHA = $00000020;
{$EXTERNALSYM D3DPBLENDCAPS_INVSRCALPHA}
D3DPBLENDCAPS_DESTALPHA = $00000040;
{$EXTERNALSYM D3DPBLENDCAPS_DESTALPHA}
D3DPBLENDCAPS_INVDESTALPHA = $00000080;
{$EXTERNALSYM D3DPBLENDCAPS_INVDESTALPHA}
D3DPBLENDCAPS_DESTCOLOR = $00000100;
{$EXTERNALSYM D3DPBLENDCAPS_DESTCOLOR}
D3DPBLENDCAPS_INVDESTCOLOR = $00000200;
{$EXTERNALSYM D3DPBLENDCAPS_INVDESTCOLOR}
D3DPBLENDCAPS_SRCALPHASAT = $00000400;
{$EXTERNALSYM D3DPBLENDCAPS_SRCALPHASAT}
D3DPBLENDCAPS_BOTHSRCALPHA = $00000800;
{$EXTERNALSYM D3DPBLENDCAPS_BOTHSRCALPHA}
D3DPBLENDCAPS_BOTHINVSRCALPHA = $00001000;
{$EXTERNALSYM D3DPBLENDCAPS_BOTHINVSRCALPHA}
D3DPBLENDCAPS_BLENDFACTOR = $00002000; { Supports both D3DBLEND_BLENDFACTOR and D3DBLEND_INVBLENDFACTOR }
{$EXTERNALSYM D3DPBLENDCAPS_BLENDFACTOR}
//
// ShadeCaps
//
D3DPSHADECAPS_COLORGOURAUDRGB = $00000008;
{$EXTERNALSYM D3DPSHADECAPS_COLORGOURAUDRGB}
D3DPSHADECAPS_SPECULARGOURAUDRGB = $00000200;
{$EXTERNALSYM D3DPSHADECAPS_SPECULARGOURAUDRGB}
D3DPSHADECAPS_ALPHAGOURAUDBLEND = $00004000;
{$EXTERNALSYM D3DPSHADECAPS_ALPHAGOURAUDBLEND}
D3DPSHADECAPS_FOGGOURAUD = $00080000;
{$EXTERNALSYM D3DPSHADECAPS_FOGGOURAUD}
//
// TextureCaps
//
D3DPTEXTURECAPS_PERSPECTIVE = $00000001; { Perspective-correct texturing is supported }
{$EXTERNALSYM D3DPTEXTURECAPS_PERSPECTIVE}
D3DPTEXTURECAPS_POW2 = $00000002; { Power-of-2 texture dimensions are required - applies to non-Cube/Volume textures only. }
{$EXTERNALSYM D3DPTEXTURECAPS_POW2}
D3DPTEXTURECAPS_ALPHA = $00000004; { Alpha in texture pixels is supported }
{$EXTERNALSYM D3DPTEXTURECAPS_ALPHA}
D3DPTEXTURECAPS_SQUAREONLY = $00000020; { Only square textures are supported }
{$EXTERNALSYM D3DPTEXTURECAPS_SQUAREONLY}
D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE = $00000040; { Texture indices are not scaled by the texture size prior to interpolation }
{$EXTERNALSYM D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE}
D3DPTEXTURECAPS_ALPHAPALETTE = $00000080; { Device can draw alpha from texture palettes }
{$EXTERNALSYM D3DPTEXTURECAPS_ALPHAPALETTE}
// 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;
{$EXTERNALSYM D3DPTEXTURECAPS_NONPOW2CONDITIONAL}
D3DPTEXTURECAPS_PROJECTED = $00000400; { Device can do D3DTTFF_PROJECTED }
{$EXTERNALSYM D3DPTEXTURECAPS_PROJECTED}
D3DPTEXTURECAPS_CUBEMAP = $00000800; { Device can do cubemap textures }
{$EXTERNALSYM D3DPTEXTURECAPS_CUBEMAP}
D3DPTEXTURECAPS_VOLUMEMAP = $00002000; { Device can do volume textures }
{$EXTERNALSYM D3DPTEXTURECAPS_VOLUMEMAP}
D3DPTEXTURECAPS_MIPMAP = $00004000; { Device can do mipmapped textures }
{$EXTERNALSYM D3DPTEXTURECAPS_MIPMAP}
D3DPTEXTURECAPS_MIPVOLUMEMAP = $00008000; { Device can do mipmapped volume textures }
{$EXTERNALSYM D3DPTEXTURECAPS_MIPVOLUMEMAP}
D3DPTEXTURECAPS_MIPCUBEMAP = $00010000; { Device can do mipmapped cube maps }
{$EXTERNALSYM D3DPTEXTURECAPS_MIPCUBEMAP}
D3DPTEXTURECAPS_CUBEMAP_POW2 = $00020000; { Device requires that cubemaps be power-of-2 dimension }
{$EXTERNALSYM D3DPTEXTURECAPS_CUBEMAP_POW2}
D3DPTEXTURECAPS_VOLUMEMAP_POW2 = $00040000; { Device requires that volume maps be power-of-2 dimension }
{$EXTERNALSYM D3DPTEXTURECAPS_VOLUMEMAP_POW2}
D3DPTEXTURECAPS_NOPROJECTEDBUMPENV = $00200000; { Device does not support projected bump env lookup operation
in programmable and fixed function pixel shaders }
{$EXTERNALSYM D3DPTEXTURECAPS_NOPROJECTEDBUMPENV}
//
// TextureFilterCaps, StretchRectFilterCaps
//
D3DPTFILTERCAPS_MINFPOINT = $00000100; { Min Filter }
{$EXTERNALSYM D3DPTFILTERCAPS_MINFPOINT}
D3DPTFILTERCAPS_MINFLINEAR = $00000200;
{$EXTERNALSYM D3DPTFILTERCAPS_MINFLINEAR}
D3DPTFILTERCAPS_MINFANISOTROPIC = $00000400;
{$EXTERNALSYM D3DPTFILTERCAPS_MINFANISOTROPIC}
D3DPTFILTERCAPS_MINFPYRAMIDALQUAD = $00000800;
{$EXTERNALSYM D3DPTFILTERCAPS_MINFPYRAMIDALQUAD}
D3DPTFILTERCAPS_MINFGAUSSIANQUAD = $00001000;
{$EXTERNALSYM D3DPTFILTERCAPS_MINFGAUSSIANQUAD}
D3DPTFILTERCAPS_MIPFPOINT = $00010000; { Mip Filter }
{$EXTERNALSYM D3DPTFILTERCAPS_MIPFPOINT}
D3DPTFILTERCAPS_MIPFLINEAR = $00020000;
{$EXTERNALSYM D3DPTFILTERCAPS_MIPFLINEAR}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
D3DPTFILTERCAPS_CONVOLUTIONMONO = $00040000; { Min and Mag for the convolution mono filter }
{$EXTERNALSYM D3DPTFILTERCAPS_CONVOLUTIONMONO}
{$ENDIF}
D3DPTFILTERCAPS_MAGFPOINT = $01000000; { Mag Filter }
{$EXTERNALSYM D3DPTFILTERCAPS_MAGFPOINT}
D3DPTFILTERCAPS_MAGFLINEAR = $02000000;
{$EXTERNALSYM D3DPTFILTERCAPS_MAGFLINEAR}
D3DPTFILTERCAPS_MAGFANISOTROPIC = $04000000;
{$EXTERNALSYM D3DPTFILTERCAPS_MAGFANISOTROPIC}
D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD = $08000000;
{$EXTERNALSYM D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD}
D3DPTFILTERCAPS_MAGFGAUSSIANQUAD = $10000000;
{$EXTERNALSYM D3DPTFILTERCAPS_MAGFGAUSSIANQUAD}
//
// TextureAddressCaps
//
D3DPTADDRESSCAPS_WRAP = $00000001;
{$EXTERNALSYM D3DPTADDRESSCAPS_WRAP}
D3DPTADDRESSCAPS_MIRROR = $00000002;
{$EXTERNALSYM D3DPTADDRESSCAPS_MIRROR}
D3DPTADDRESSCAPS_CLAMP = $00000004;
{$EXTERNALSYM D3DPTADDRESSCAPS_CLAMP}
D3DPTADDRESSCAPS_BORDER = $00000008;
{$EXTERNALSYM D3DPTADDRESSCAPS_BORDER}
D3DPTADDRESSCAPS_INDEPENDENTUV = $00000010;
{$EXTERNALSYM D3DPTADDRESSCAPS_INDEPENDENTUV}
D3DPTADDRESSCAPS_MIRRORONCE = $00000020;
{$EXTERNALSYM D3DPTADDRESSCAPS_MIRRORONCE}
//
// StencilCaps
//
D3DSTENCILCAPS_KEEP = $00000001;
{$EXTERNALSYM D3DSTENCILCAPS_KEEP}
D3DSTENCILCAPS_ZERO = $00000002;
{$EXTERNALSYM D3DSTENCILCAPS_ZERO}
D3DSTENCILCAPS_REPLACE = $00000004;
{$EXTERNALSYM D3DSTENCILCAPS_REPLACE}
D3DSTENCILCAPS_INCRSAT = $00000008;
{$EXTERNALSYM D3DSTENCILCAPS_INCRSAT}
D3DSTENCILCAPS_DECRSAT = $00000010;
{$EXTERNALSYM D3DSTENCILCAPS_DECRSAT}
D3DSTENCILCAPS_INVERT = $00000020;
{$EXTERNALSYM D3DSTENCILCAPS_INVERT}
D3DSTENCILCAPS_INCR = $00000040;
{$EXTERNALSYM D3DSTENCILCAPS_INCR}
D3DSTENCILCAPS_DECR = $00000080;
{$EXTERNALSYM D3DSTENCILCAPS_DECR}
D3DSTENCILCAPS_TWOSIDED = $00000100;
{$EXTERNALSYM D3DSTENCILCAPS_TWOSIDED}
//
// TextureOpCaps
//
D3DTEXOPCAPS_DISABLE = $00000001;
{$EXTERNALSYM D3DTEXOPCAPS_DISABLE}
D3DTEXOPCAPS_SELECTARG1 = $00000002;
{$EXTERNALSYM D3DTEXOPCAPS_SELECTARG1}
D3DTEXOPCAPS_SELECTARG2 = $00000004;
{$EXTERNALSYM D3DTEXOPCAPS_SELECTARG2}
D3DTEXOPCAPS_MODULATE = $00000008;
{$EXTERNALSYM D3DTEXOPCAPS_MODULATE}
D3DTEXOPCAPS_MODULATE2X = $00000010;
{$EXTERNALSYM D3DTEXOPCAPS_MODULATE2X}
D3DTEXOPCAPS_MODULATE4X = $00000020;
{$EXTERNALSYM D3DTEXOPCAPS_MODULATE4X}
D3DTEXOPCAPS_ADD = $00000040;
{$EXTERNALSYM D3DTEXOPCAPS_ADD}
D3DTEXOPCAPS_ADDSIGNED = $00000080;
{$EXTERNALSYM D3DTEXOPCAPS_ADDSIGNED}
D3DTEXOPCAPS_ADDSIGNED2X = $00000100;
{$EXTERNALSYM D3DTEXOPCAPS_ADDSIGNED2X}
D3DTEXOPCAPS_SUBTRACT = $00000200;
{$EXTERNALSYM D3DTEXOPCAPS_SUBTRACT}
D3DTEXOPCAPS_ADDSMOOTH = $00000400;
{$EXTERNALSYM D3DTEXOPCAPS_ADDSMOOTH}
D3DTEXOPCAPS_BLENDDIFFUSEALPHA = $00000800;
{$EXTERNALSYM D3DTEXOPCAPS_BLENDDIFFUSEALPHA}
D3DTEXOPCAPS_BLENDTEXTUREALPHA = $00001000;
{$EXTERNALSYM D3DTEXOPCAPS_BLENDTEXTUREALPHA}
D3DTEXOPCAPS_BLENDFACTORALPHA = $00002000;
{$EXTERNALSYM D3DTEXOPCAPS_BLENDFACTORALPHA}
D3DTEXOPCAPS_BLENDTEXTUREALPHAPM = $00004000;
{$EXTERNALSYM D3DTEXOPCAPS_BLENDTEXTUREALPHAPM}
D3DTEXOPCAPS_BLENDCURRENTALPHA = $00008000;
{$EXTERNALSYM D3DTEXOPCAPS_BLENDCURRENTALPHA}
D3DTEXOPCAPS_PREMODULATE = $00010000;
{$EXTERNALSYM D3DTEXOPCAPS_PREMODULATE}
D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR = $00020000;
{$EXTERNALSYM D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR}
D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA = $00040000;
{$EXTERNALSYM D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA}
D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR = $00080000;
{$EXTERNALSYM D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR}
D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA = $00100000;
{$EXTERNALSYM D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA}
D3DTEXOPCAPS_BUMPENVMAP = $00200000;
{$EXTERNALSYM D3DTEXOPCAPS_BUMPENVMAP}
D3DTEXOPCAPS_BUMPENVMAPLUMINANCE = $00400000;
{$EXTERNALSYM D3DTEXOPCAPS_BUMPENVMAPLUMINANCE}
D3DTEXOPCAPS_DOTPRODUCT3 = $00800000;
{$EXTERNALSYM D3DTEXOPCAPS_DOTPRODUCT3}
D3DTEXOPCAPS_MULTIPLYADD = $01000000;
{$EXTERNALSYM D3DTEXOPCAPS_MULTIPLYADD}
D3DTEXOPCAPS_LERP = $02000000;
{$EXTERNALSYM D3DTEXOPCAPS_LERP}
//
// FVFCaps
//
D3DFVFCAPS_TEXCOORDCOUNTMASK = $0000ffff; { mask for texture coordinate count field }
{$EXTERNALSYM D3DFVFCAPS_TEXCOORDCOUNTMASK}
D3DFVFCAPS_DONOTSTRIPELEMENTS = $00080000; { Device prefers that vertex elements not be stripped }
{$EXTERNALSYM D3DFVFCAPS_DONOTSTRIPELEMENTS}
D3DFVFCAPS_PSIZE = $00100000; { Device can receive point size }
{$EXTERNALSYM D3DFVFCAPS_PSIZE}
//
// VertexProcessingCaps
//
D3DVTXPCAPS_TEXGEN = $00000001; { device can do texgen }
{$EXTERNALSYM D3DVTXPCAPS_TEXGEN}
D3DVTXPCAPS_MATERIALSOURCE7 = $00000002; { device can do DX7-level colormaterialsource ops }
{$EXTERNALSYM D3DVTXPCAPS_MATERIALSOURCE7}
D3DVTXPCAPS_DIRECTIONALLIGHTS = $00000008; { device can do directional lights }
{$EXTERNALSYM D3DVTXPCAPS_DIRECTIONALLIGHTS}
D3DVTXPCAPS_POSITIONALLIGHTS = $00000010; { device can do positional lights (includes point and spot) }
{$EXTERNALSYM D3DVTXPCAPS_POSITIONALLIGHTS}
D3DVTXPCAPS_LOCALVIEWER = $00000020; { device can do local viewer }
{$EXTERNALSYM D3DVTXPCAPS_LOCALVIEWER}
D3DVTXPCAPS_TWEENING = $00000040; { device can do vertex tweening }
{$EXTERNALSYM D3DVTXPCAPS_TWEENING}
D3DVTXPCAPS_TEXGEN_SPHEREMAP = $00000100; { device supports D3DTSS_TCI_SPHEREMAP }
{$EXTERNALSYM D3DVTXPCAPS_TEXGEN_SPHEREMAP}
D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER = $00000200; { device does not support TexGen in non-local
viewer mode }
{$EXTERNALSYM D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER}
//
// DevCaps2
//
D3DDEVCAPS2_STREAMOFFSET = $00000001; { Device supports offsets in streams. Must be set by DX9 drivers }
{$EXTERNALSYM D3DDEVCAPS2_STREAMOFFSET}
D3DDEVCAPS2_DMAPNPATCH = $00000002; { Device supports displacement maps for N-Patches}
{$EXTERNALSYM D3DDEVCAPS2_DMAPNPATCH}
D3DDEVCAPS2_ADAPTIVETESSRTPATCH = $00000004; { Device supports adaptive tesselation of RT-patches}
{$EXTERNALSYM D3DDEVCAPS2_ADAPTIVETESSRTPATCH}
D3DDEVCAPS2_ADAPTIVETESSNPATCH = $00000008; { Device supports adaptive tesselation of N-patches}
{$EXTERNALSYM D3DDEVCAPS2_ADAPTIVETESSNPATCH}
D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES = $00000010; { Device supports StretchRect calls with a texture as the source}
{$EXTERNALSYM D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES}
D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH = $00000020; { Device supports presampled displacement maps for N-Patches }
{$EXTERNALSYM D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH}
D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET = $00000040; { Vertex elements in a vertex declaration can share the same stream offset }
{$EXTERNALSYM D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET}
//
// DeclTypes
//
D3DDTCAPS_UBYTE4 = $00000001;
{$EXTERNALSYM D3DDTCAPS_UBYTE4}
D3DDTCAPS_UBYTE4N = $00000002;
{$EXTERNALSYM D3DDTCAPS_UBYTE4N}
D3DDTCAPS_SHORT2N = $00000004;
{$EXTERNALSYM D3DDTCAPS_SHORT2N}
D3DDTCAPS_SHORT4N = $00000008;
{$EXTERNALSYM D3DDTCAPS_SHORT4N}
D3DDTCAPS_USHORT2N = $00000010;
{$EXTERNALSYM D3DDTCAPS_USHORT2N}
D3DDTCAPS_USHORT4N = $00000020;
{$EXTERNALSYM D3DDTCAPS_USHORT4N}
D3DDTCAPS_UDEC3 = $00000040;
{$EXTERNALSYM D3DDTCAPS_UDEC3}
D3DDTCAPS_DEC3N = $00000080;
{$EXTERNALSYM D3DDTCAPS_DEC3N}
D3DDTCAPS_FLOAT16_2 = $00000100;
{$EXTERNALSYM D3DDTCAPS_FLOAT16_2}
D3DDTCAPS_FLOAT16_4 = $00000200;
{$EXTERNALSYM D3DDTCAPS_FLOAT16_4}
(*==========================================================================;
*
*
* File: d3d9.h
* Content: Direct3D include file
*
****************************************************************************)
(* This identifier is passed to Direct3DCreate9 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, Direct3DCreate9 will fail.
* (The number itself has no meaning.)*)
const
D3D_SDK_VERSION = (32 or $80000000);
D3D9b_SDK_VERSION = (31 or $80000000);
{$EXTERNALSYM D3D_SDK_VERSION}
{$EXTERNALSYM D3D9b_SDK_VERSION}
type
HMONITOR = THandle;
{$EXTERNALSYM HMONITOR}
(*
* Direct3D interfaces
*)
// forward interfaces declaration
IDirect3D9 = interface;
IDirect3DDevice9 = interface;
{$IFDEF DIRECT3D_VERSION_9_VISTA}
IDirect3DDevice9Ex = interface;
{$ENDIF}
IDirect3DStateBlock9 = interface;
IDirect3DVertexDeclaration9 = interface;
IDirect3DVertexShader9 = interface;
IDirect3DPixelShader9 = interface;
IDirect3DResource9 = interface;
IDirect3DBaseTexture9 = interface;
IDirect3DTexture9 = interface;
IDirect3DVolumeTexture9 = interface;
IDirect3DCubeTexture9 = interface;
IDirect3DVertexBuffer9 = interface;
IDirect3DIndexBuffer9 = interface;
IDirect3DSurface9 = interface;
IDirect3DVolume9 = interface;
IDirect3DSwapChain9 = interface;
IDirect3DQuery9 = interface;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3D9);'}
{$EXTERNALSYM IDirect3D9}
IDirect3D9 = interface(IUnknown)
['{81BDCBCA-64D4-426d-AE8D-AD0147F4275C}']
(*** IDirect3D9 methods ***)
function RegisterSoftwareDevice(pInitializeFunction: Pointer): HResult; stdcall;
function GetAdapterCount: LongWord; stdcall;
function GetAdapterIdentifier(Adapter: LongWord; Flags: DWord; out pIdentifier: TD3DAdapterIdentifier9): HResult; stdcall;
function GetAdapterModeCount(Adapter: LongWord; Format: TD3DFormat): LongWord; stdcall;
function EnumAdapterModes(Adapter: LongWord; Format: TD3DFormat; Mode: LongWord; out pMode: TD3DDisplayMode): HResult; stdcall;
function GetAdapterDisplayMode(Adapter: LongWord; out pMode: TD3DDisplayMode): HResult; stdcall;
function CheckDeviceType(Adapter: LongWord; CheckType: TD3DDevType; AdapterFormat, BackBufferFormat: TD3DFormat; Windowed: BOOL): HResult; stdcall;
function CheckDeviceFormat(Adapter: LongWord; DeviceType: TD3DDevType; AdapterFormat: TD3DFormat; Usage: DWord; RType: TD3DResourceType; CheckFormat: TD3DFormat): HResult; stdcall;
function CheckDeviceMultiSampleType(Adapter: LongWord; DeviceType: TD3DDevType; SurfaceFormat: TD3DFormat; Windowed: BOOL; MultiSampleType: TD3DMultiSampleType; pQualityLevels: PDWORD): HResult; stdcall;
function CheckDepthStencilMatch(Adapter: LongWord; DeviceType: TD3DDevType; AdapterFormat, RenderTargetFormat, DepthStencilFormat: TD3DFormat): HResult; stdcall;
function CheckDeviceFormatConversion(Adapter: LongWord; DeviceType: TD3DDevType; SourceFormat, TargetFormat: TD3DFormat): HResult; stdcall;
function GetDeviceCaps(Adapter: LongWord; DeviceType: TD3DDevType; out pCaps: TD3DCaps9): HResult; stdcall;
function GetAdapterMonitor(Adapter: LongWord): HMONITOR; stdcall;
function CreateDevice(Adapter: LongWord; DeviceType: TD3DDevType; hFocusWindow: HWND; BehaviorFlags: DWord; pPresentationParameters: PD3DPresentParameters; out ppReturnedDeviceInterface: IDirect3DDevice9): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3D9Helper}
IDirect3D9Helper = class
(*** helper information ***)
szVersionString: PWideChar;
end;
{$IFDEF DIRECT3D_VERSION_9_VISTA}
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3D9Ex);'}
{$EXTERNALSYM IDirect3D9Ex}
IDirect3D9Ex = interface(IDirect3D9)
['{02177241-69FC-400C-8FF1-93A44DF6861D}']
(*** IDirect3D9Ex methods ***)
function GetAdapterModeCountEx(Adapter: LongWord; const pFilter: PD3DDisplayModeFilter): LongWord; stdcall;
function EnumAdapterModesEx(Adapter: LongWord; const pFilter: PD3DDisplayModeFilter; Mode: LongWord; pMode: PD3DDisplayModeEx): HResult; stdcall;
function GetAdapterDisplayModeEx(Adapter: LongWord; pMode: PD3DDisplayModeEx; pRotation: PD3DDisplayRotation): HResult; stdcall;
function CreateDeviceEx(Adapter: LongWord; DeviceType: TD3DDevType; hFocusWindow: HWND; BehaviorFlags: DWORD; pPresentationParameters: PD3DPresentParameters; pFullscreenDisplayMode: PD3DDisplayModeEx; out ppReturnedDeviceInterface: IDirect3DDevice9Ex): HResult; stdcall;
function GetAdapterLUID(Adapter: LongWord; pLUID: PLargeInteger{*LUID}): HResult; stdcall;
end;
{$ENDIF}
{ SwapChain }
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DDevice9);'}
{$EXTERNALSYM IDirect3DDevice9}
IDirect3DDevice9 = interface(IUnknown)
['{D0223B96-BF7A-43fd-92BD-A43B0D82B9EB}']
(*** IDirect3DDevice9 methods ***)
function TestCooperativeLevel: HResult; stdcall;
function GetAvailableTextureMem: LongWord; stdcall;
function EvictManagedResources: HResult; stdcall;
function GetDirect3D(out ppD3D9: IDirect3D9): HResult; stdcall;
function GetDeviceCaps(out pCaps: TD3DCaps9): HResult; stdcall;
function GetDisplayMode(iSwapChain: LongWord; out pMode: TD3DDisplayMode): HResult; stdcall;
function GetCreationParameters(out pParameters: TD3DDeviceCreationParameters): HResult; stdcall;
function SetCursorProperties(XHotSpot, YHotSpot: LongWord; pCursorBitmap: IDirect3DSurface9): HResult; stdcall;
procedure SetCursorPosition(XScreenSpace, YScreenSpace: LongWord; Flags: DWord); stdcall;
function ShowCursor(bShow: BOOL): BOOL; stdcall;
function CreateAdditionalSwapChain(const pPresentationParameters: TD3DPresentParameters; out pSwapChain: IDirect3DSwapChain9): HResult; stdcall;
function GetSwapChain(iSwapChain: LongWord; out pSwapChain: IDirect3DSwapChain9): HResult; stdcall;
function GetNumberOfSwapChains: LongWord; stdcall;
function Reset(const pPresentationParameters: TD3DPresentParameters): HResult; stdcall;
function Present(pSourceRect, pDestRect: PRect; hDestWindowOverride: HWND; pDirtyRegion: PRgnData): HResult; stdcall;
function GetBackBuffer(iSwapChain: LongWord; iBackBuffer: LongWord; _Type: TD3DBackBufferType; out ppBackBuffer: IDirect3DSurface9): HResult; stdcall;
function GetRasterStatus(iSwapChain: LongWord; out pRasterStatus: TD3DRasterStatus): HResult; stdcall;
function SetDialogBoxMode(bEnableDialogs: BOOL): HResult; stdcall;
procedure SetGammaRamp(iSwapChain: LongWord; Flags: DWord; const pRamp: TD3DGammaRamp); stdcall;
procedure GetGammaRamp(iSwapChain: LongWord; out pRamp: TD3DGammaRamp); stdcall;
function CreateTexture(Width, Height, Levels: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppTexture: IDirect3DTexture9; pSharedHandle: PHandle): HResult; stdcall;
function CreateVolumeTexture(Width, Height, Depth, Levels: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppVolumeTexture: IDirect3DVolumeTexture9; pSharedHandle: PHandle): HResult; stdcall;
function CreateCubeTexture(EdgeLength, Levels: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppCubeTexture: IDirect3DCubeTexture9; pSharedHandle: PHandle): HResult; stdcall;
function CreateVertexBuffer(Length: LongWord; Usage, FVF: DWord; Pool: TD3DPool; out ppVertexBuffer: IDirect3DVertexBuffer9; pSharedHandle: PHandle): HResult; stdcall;
function CreateIndexBuffer(Length: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppIndexBuffer: IDirect3DIndexBuffer9; pSharedHandle: PHandle): HResult; stdcall;
function CreateRenderTarget(Width, Height: LongWord; Format: TD3DFormat; MultiSample: TD3DMultiSampleType; MultisampleQuality: DWORD; Lockable: BOOL; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle): HResult; stdcall;
function CreateDepthStencilSurface(Width, Height: LongWord; Format: TD3DFormat; MultiSample: TD3DMultiSampleType; MultisampleQuality: DWORD; Discard: BOOL; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle): HResult; stdcall;
function UpdateSurface(pSourceSurface: IDirect3DSurface9; pSourceRect: PRect; pDestinationSurface: IDirect3DSurface9; pDestPoint: PPoint): HResult; stdcall;
function UpdateTexture(pSourceTexture, pDestinationTexture: IDirect3DBaseTexture9): HResult; stdcall;
function GetRenderTargetData(pRenderTarget, pDestSurface: IDirect3DSurface9): HResult; stdcall;
function GetFrontBufferData(iSwapChain: LongWord; pDestSurface: IDirect3DSurface9): HResult; stdcall;
function StretchRect(pSourceSurface: IDirect3DSurface9; pSourceRect: PRect; pDestSurface: IDirect3DSurface9; pDestRect: PRect; Filter: TD3DTextureFilterType): HResult; stdcall;
function ColorFill(pSurface: IDirect3DSurface9; pRect: PRect; color: TD3DColor): HResult; stdcall;
function CreateOffscreenPlainSurface(Width, Height: LongWord; Format: TD3DFormat; Pool: TD3DPool; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle): HResult; stdcall;
function SetRenderTarget(RenderTargetIndex: DWORD; pRenderTarget: IDirect3DSurface9): HResult; stdcall;
function GetRenderTarget(RenderTargetIndex: DWORD; out ppRenderTarget: IDirect3DSurface9): HResult; stdcall;
function SetDepthStencilSurface(pNewZStencil: IDirect3DSurface9): HResult; stdcall;
function GetDepthStencilSurface(out ppZStencilSurface: IDirect3DSurface9): HResult; stdcall;
function BeginScene: HResult; stdcall;
function EndScene: HResult; stdcall;
function Clear(Count: DWord; pRects: PD3DRect; Flags: DWord; Color: TD3DColor; Z: Single; Stencil: DWord): HResult; stdcall;
function SetTransform(State: TD3DTransformStateType; const pMatrix: TD3DMatrix): HResult; stdcall;
function GetTransform(State: TD3DTransformStateType; out pMatrix: TD3DMatrix): HResult; stdcall;
function MultiplyTransform(State: TD3DTransformStateType; const pMatrix: TD3DMatrix): HResult; stdcall;
function SetViewport(const pViewport: TD3DViewport9): HResult; stdcall;
function GetViewport(out pViewport: TD3DViewport9): HResult; stdcall;
function SetMaterial(const pMaterial: TD3DMaterial9): HResult; stdcall;
function GetMaterial(out pMaterial: TD3DMaterial9): HResult; stdcall;
function SetLight(Index: DWord; const pLight: TD3DLight9): HResult; stdcall;
function GetLight(Index: DWord; out pLight: TD3DLight9): HResult; stdcall;
function LightEnable(Index: DWord; Enable: BOOL): HResult; stdcall;
function GetLightEnable(Index: DWord; out pEnable: BOOL): HResult; stdcall;
function SetClipPlane(Index: DWord; pPlane: PSingle): HResult; stdcall;
function GetClipPlane(Index: DWord; pPlane: PSingle): HResult; stdcall;
function SetRenderState(State: TD3DRenderStateType; Value: DWord): HResult; stdcall;
function GetRenderState(State: TD3DRenderStateType; out pValue: DWord): HResult; stdcall;
function CreateStateBlock(_Type: TD3DStateBlockType; out ppSB: IDirect3DStateBlock9): HResult; stdcall;
function BeginStateBlock: HResult; stdcall;
function EndStateBlock(out ppSB: IDirect3DStateBlock9): HResult; stdcall;
function SetClipStatus(const pClipStatus: TD3DClipStatus9): HResult; stdcall;
function GetClipStatus(out pClipStatus: TD3DClipStatus9): HResult; stdcall;
function GetTexture(Stage: DWord; out ppTexture: IDirect3DBaseTexture9): HResult; stdcall;
function SetTexture(Stage: DWord; pTexture: IDirect3DBaseTexture9): HResult; stdcall;
function GetTextureStageState(Stage: DWord; _Type: TD3DTextureStageStateType; out pValue: DWord): HResult; stdcall;
function SetTextureStageState(Stage: DWord; _Type: TD3DTextureStageStateType; Value: DWord): HResult; stdcall;
function GetSamplerState(Sampler: DWORD; _Type: TD3DSamplerStateType; out pValue: DWORD): HResult; stdcall;
function SetSamplerState(Sampler: DWORD; _Type: TD3DSamplerStateType; Value: DWORD): HResult; stdcall;
function ValidateDevice(out pNumPasses: DWord): HResult; stdcall;
function SetPaletteEntries(PaletteNumber: LongWord; pEntries: pPaletteEntry): HResult; stdcall;
function GetPaletteEntries(PaletteNumber: LongWord; pEntries: pPaletteEntry): HResult; stdcall;
function SetCurrentTexturePalette(PaletteNumber: LongWord): HResult; stdcall;
function GetCurrentTexturePalette(out PaletteNumber: LongWord): HResult; stdcall;
function SetScissorRect(pRect: PRect): HResult; stdcall;
function GetScissorRect(out pRect: TRect): HResult; stdcall;
function SetSoftwareVertexProcessing(bSoftware: BOOL): HResult; stdcall;
function GetSoftwareVertexProcessing: BOOL; stdcall;
function SetNPatchMode(nSegments: Single): HResult; stdcall;
function GetNPatchMode: Single; stdcall;
function DrawPrimitive(PrimitiveType: TD3DPrimitiveType; StartVertex, PrimitiveCount: LongWord): HResult; stdcall;
function DrawIndexedPrimitive(_Type: TD3DPrimitiveType; BaseVertexIndex: Integer; MinVertexIndex, NumVertices, startIndex, primCount: LongWord): HResult; stdcall;
function DrawPrimitiveUP(PrimitiveType: TD3DPrimitiveType; PrimitiveCount: LongWord; const pVertexStreamZeroData; VertexStreamZeroStride: LongWord): HResult; stdcall;
function DrawIndexedPrimitiveUP(PrimitiveType: TD3DPrimitiveType; MinVertexIndex, NumVertice, PrimitiveCount: LongWord; const pIndexData; IndexDataFormat: TD3DFormat; const pVertexStreamZeroData; VertexStreamZeroStride: LongWord): HResult; stdcall;
function ProcessVertices(SrcStartIndex, DestIndex, VertexCount: LongWord; pDestBuffer: IDirect3DVertexBuffer9; pVertexDecl: IDirect3DVertexDeclaration9; Flags: DWord): HResult; stdcall;
function CreateVertexDeclaration(pVertexElements: PD3DVertexElement9; out ppDecl: IDirect3DVertexDeclaration9): HResult; stdcall;
function SetVertexDeclaration(pDecl: IDirect3DVertexDeclaration9): HResult; stdcall;
function GetVertexDeclaration(out ppDecl: IDirect3DVertexDeclaration9): HResult; stdcall;
function SetFVF(FVF: DWORD): HResult; stdcall;
function GetFVF(out FVF: DWORD): HResult; stdcall;
function CreateVertexShader(pFunction: PDWord; out ppShader: IDirect3DVertexShader9): HResult; stdcall;
function SetVertexShader(pShader: IDirect3DVertexShader9): HResult; stdcall;
function GetVertexShader(out ppShader: IDirect3DVertexShader9): HResult; stdcall;
function SetVertexShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall;
function GetVertexShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall;
function SetVertexShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall;
function GetVertexShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall;
function SetVertexShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall;
function GetVertexShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall;
function SetStreamSource(StreamNumber: LongWord; pStreamData: IDirect3DVertexBuffer9; OffsetInBytes, Stride: LongWord): HResult; stdcall;
function GetStreamSource(StreamNumber: LongWord; out ppStreamData: IDirect3DVertexBuffer9; out pOffsetInBytes, pStride: LongWord): HResult; stdcall;
function SetStreamSourceFreq(StreamNumber: LongWord; Setting: LongWord): HResult; stdcall;
function GetStreamSourceFreq(StreamNumber: LongWord; out Setting: LongWord): HResult; stdcall;
function SetIndices(pIndexData: IDirect3DIndexBuffer9): HResult; stdcall;
function GetIndices(out ppIndexData: IDirect3DIndexBuffer9): HResult; stdcall;
function CreatePixelShader(pFunction: PDWord; out ppShader: IDirect3DPixelShader9): HResult; stdcall;
function SetPixelShader(pShader: IDirect3DPixelShader9): HResult; stdcall;
function GetPixelShader(out ppShader: IDirect3DPixelShader9): HResult; stdcall;
function SetPixelShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall;
function GetPixelShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall;
function SetPixelShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall;
function GetPixelShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall;
function SetPixelShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall;
function GetPixelShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall;
function DrawRectPatch(Handle: LongWord; pNumSegs: PSingle; pTriPatchInfo: PD3DRectPatchInfo): HResult; stdcall;
function DrawTriPatch(Handle: LongWord; pNumSegs: PSingle; pTriPatchInfo: PD3DTriPatchInfo): HResult; stdcall;
function DeletePatch(Handle: LongWord): HResult; stdcall;
function CreateQuery(_Type: TD3DQueryType; out ppQuery: IDirect3DQuery9): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DDevice9Helper}
IDirect3DDevice9Helper = class
(*** helper information ***)
CreationParameters: TD3DDeviceCreationParameters;
PresentParameters: TD3DPresentParameters;
DisplayMode: TD3DDisplayMode;
Caps: TD3DCaps9;
AvailableTextureMem: LongWord;
SwapChains: LongWord;
Textures: LongWord;
VertexBuffers: LongWord;
IndexBuffers: LongWord;
VertexShaders: LongWord;
PixelShaders: LongWord;
Viewport: TD3DViewport9;
ProjectionMatrix: TD3DMatrix;
ViewMatrix: TD3DMatrix;
WorldMatrix: TD3DMatrix;
TextureMatrices: array[0..7] of TD3DMatrix;
FVF: DWORD;
VertexSize: LongWord;
VertexShaderVersion: DWORD;
PixelShaderVersion: DWORD;
SoftwareVertexProcessing: BOOL;
Material: TD3DMaterial9;
Lights: array[0..15] of TD3DLight9;
LightsEnabled: array[0..15] of BOOL;
GammaRamp: TD3DGammaRamp;
ScissorRect: TRect;
DialogBoxMode: BOOL;
end;
{$IFDEF DIRECT3D_VERSION_9_VISTA}
PIDirect3DResource9 = ^IDirect3DResource9;
{$EXTERNALSYM PIDirect3DResource9}
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DDevice9Ex);'}
{$EXTERNALSYM IDirect3DDevice9Ex}
IDirect3DDevice9Ex = interface(IDirect3DDevice9)
['{B18B10CE-2649-405a-870F-95F777D4313A}']
(*** IDirect3DDevice9Ex methods ***)
function SetConvolutionMonoKernel(Width, Height: LongWord; rows, columns: PSingle): HResult; stdcall;
function ComposeRects(pSrc, pDst: IDirect3DSurface9; pSrcRectDescs: IDirect3DVertexBuffer9; NumRects: LongWord; pDstRectDescs: IDirect3DVertexBuffer9; Operation: TD3DComposeRectsOp; Xoffset, Yoffset: Integer): HResult; stdcall;
function PresentEx(const pSourceRect, pDestRect: PRect; hDestWindowOverride: HWND; const pDirtyRegion: PRgnData; dwFlags: DWORD): HResult; stdcall;
function GetGPUThreadPriority(out pPriority: Integer): HResult; stdcall;
function SetGPUThreadPriority(Priority: Integer): HResult; stdcall;
function WaitForVBlank(iSwapChain: LongWord): HResult; stdcall;
function CheckResourceResidency(pResourceArray: PIDirect3DResource9; NumResources: LongWord): HResult; stdcall;
function SetMaximumFrameLatency(MaxLatency: LongWord): HResult; stdcall;
function GetMaximumFrameLatency(out pMaxLatency: LongWord): HResult; stdcall;
function CheckDeviceState(hDestinationWindow: HWND): HResult; stdcall;
function CreateRenderTargetEx(Width, Height: LongWord; Format: TD3DFormat; MultiSample: TD3DMultiSampleType; MultisampleQuality: DWORD; Lockable: BOOL; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle; Usage: DWORD): HResult; stdcall;
function CreateOffscreenPlainSurfaceEx(Width, Height: LongWord; Format: TD3DFormat; Pool: TD3DPool; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle; Usage: DWORD): HResult; stdcall;
function CreateDepthStencilSurfaceEx(Width, Height: LongWord; Format: TD3DFormat; MultiSample: TD3DMultiSampleType; MultisampleQuality: DWORD; Discard: BOOL; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle; Usage: DWORD): HResult; stdcall;
function ResetEx(const pPresentationParameters: TD3DPresentParameters; const pFullscreenDisplayMode: TD3DDisplayModeEx): HResult; stdcall;
function GetDisplayModeEx(iSwapChain: LongWord; pMode: PD3DDisplayModeEx; pRotation: PD3DDisplayRotation): HResult; stdcall;
end;
{$ENDIF}
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DStateBlock9);'}
{$EXTERNALSYM IDirect3DStateBlock9}
IDirect3DStateBlock9 = interface(IUnknown)
['{B07C4FE5-310D-4ba8-A23C-4F0F206F218B}']
(*** IDirect3DStateBlock9 methods ***)
function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall;
function Capture: HResult; stdcall;
function Apply: HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DStateBlock9Helper}
IDirect3DStateBlock9Helper = class
(*** helper information ***)
CreationCallStack: PWideChar;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DSwapChain9);'}
{$EXTERNALSYM IDirect3DSwapChain9}
IDirect3DSwapChain9 = interface(IUnknown)
['{794950F2-ADFC-458a-905E-10A10B0B503B}']
(*** IDirect3DSwapChain9 methods ***)
function Present(pSourceRect, pDestRect: PRect; hDestWindowOverride: HWND; pDirtyRegion: PRgnData; dwFlags: DWORD): HResult; stdcall;
function GetFrontBufferData(pDestSurface: IDirect3DSurface9): HResult; stdcall;
function GetBackBuffer(iBackBuffer: LongWord; _Type: TD3DBackBufferType; out ppBackBuffer: IDirect3DSurface9): HResult; stdcall;
function GetRasterStatus(out pRasterStatus: TD3DRasterStatus): HResult; stdcall;
function GetDisplayMode(out pMode: TD3DDisplayMode): HResult; stdcall;
function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall;
function GetPresentParameters(out pPresentationParameters: TD3DPresentParameters): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DSwapChain9Helper}
IDirect3DSwapChain9Helper = class
(*** helper information ***)
PresentParameters: TD3DPresentParameters;
DisplayMode: TD3DDisplayMode;
CreationCallStack: PWideChar;
end;
{$IFDEF DIRECT3D_VERSION_9_VISTA}
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DSwapChain9Ex);'}
{$EXTERNALSYM IDirect3DSwapChain9Ex}
IDirect3DSwapChain9Ex = interface(IDirect3DSwapChain9)
['{91886CAF-1C3D-4d2e-A0AB-3E4C7D8D3303}']
(*** IDirect3DSwapChain9Ex methods ***)
function GetLastPresentCount(out pLastPresentCount: LongWord): HResult; stdcall;
function GetPresentStats(out pPresentationStatistics: TD3DPresentStats): HResult; stdcall;
function GetDisplayModeEx(pMode: PD3DDisplayModeEx; pRotation: PD3DDisplayRotation): HResult; stdcall;
end;
{$ENDIF}
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DResource9);'}
{$EXTERNALSYM IDirect3DResource9}
IDirect3DResource9 = interface(IUnknown)
['{05EEC05D-8F7D-4362-B999-D1BAF357C704}']
(*** IDirect3DResource9 methods ***)
function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall;
function SetPrivateData(const refguid: TGUID; const pData: Pointer; SizeOfData, Flags: DWord): HResult; stdcall;
function GetPrivateData(const refguid: TGUID; pData: Pointer; out pSizeOfData: DWord): HResult; stdcall;
function FreePrivateData(const refguid: TGUID): HResult; stdcall;
function SetPriority(PriorityNew: DWord): DWord; stdcall;
function GetPriority: DWord; stdcall;
procedure PreLoad; stdcall;
function GetType: TD3DResourceType; stdcall;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DVertexDeclaration9);'}
{$EXTERNALSYM IDirect3DVertexDeclaration9}
IDirect3DVertexDeclaration9 = interface(IUnknown)
['{DD13C59C-36FA-4098-A8FB-C7ED39DC8546}']
(*** IDirect3DVertexDeclaration9 methods ***)
function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall;
function GetDeclaration(pElement: PD3DVertexElement9; out pNumElements: LongWord): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DVertexDeclaration9Helper}
IDirect3DVertexDeclaration9Helper = class
(*** helper information ***)
CreationCallStack: PWideChar;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DVertexShader9);'}
{$EXTERNALSYM IDirect3DVertexShader9}
IDirect3DVertexShader9 = interface(IUnknown)
['{EFC5557E-6265-4613-8A94-43857889EB36}']
(*** IDirect3DVertexShader9 methods ***)
function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall;
function GetFunction(pData: Pointer; out pSizeOfData: LongWord): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DVertexShader9Helper}
IDirect3DVertexShader9Helper = class
(*** helper information ***)
Version: DWORD;
CreationCallStack: PWideChar;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DPixelShader9);'}
{$EXTERNALSYM IDirect3DPixelShader9}
IDirect3DPixelShader9 = interface(IUnknown)
['{6D3BDBDC-5B02-4415-B852-CE5E8BCCB289}']
(*** IDirect3DPixelShader9 methods ***)
function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall;
function GetFunction(pData: Pointer; out pSizeOfData: LongWord): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DPixelShader9Helper}
IDirect3DPixelShader9Helper = class
(*** helper information ***)
Version: DWORD;
CreationCallStack: PWideChar;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DBaseTexture9);'}
{$EXTERNALSYM IDirect3DBaseTexture9}
IDirect3DBaseTexture9 = interface(IDirect3DResource9)
['{580CA87E-1D3C-4d54-991D-B7D3E3C298CE}']
(*** IDirect3DBaseTexture9 methods ***)
function SetLOD(LODNew: DWord): DWord; stdcall;
function GetLOD: DWord; stdcall;
function GetLevelCount: DWord; stdcall;
function SetAutoGenFilterType(FilterType: TD3DTextureFilterType): HResult; stdcall;
function GetAutoGenFilterType: TD3DTextureFilterType; stdcall;
procedure GenerateMipSubLevels; stdcall;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DTexture9);'}
{$EXTERNALSYM IDirect3DTexture9}
IDirect3DTexture9 = interface(IDirect3DBaseTexture9)
['{85C31227-3DE5-4f00-9B3A-F11AC38C18B5}']
(*** IDirect3DTexture9 methods ***)
function GetLevelDesc(Level: LongWord; out pDesc: TD3DSurfaceDesc): HResult; stdcall;
function GetSurfaceLevel(Level: LongWord; out ppSurfaceLevel: IDirect3DSurface9): HResult; stdcall;
function LockRect(Level: LongWord; out pLockedRect: TD3DLockedRect; pRect: PRect; Flags: DWord): HResult; stdcall;
function UnlockRect(Level: LongWord): HResult; stdcall;
function AddDirtyRect(pDirtyRect: PRect): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DTexture9Helper}
IDirect3DTexture9Helper = class
(*** helper information ***)
Name: PWideChar;
Width: LongWord;
Height: LongWord;
Levels: LongWord;
Usage: DWORD;
Format: TD3DFormat;
Pool: TD3DPool;
Priority: DWORD;
LOD: DWORD;
FilterType: TD3DTextureFilterType;
LockCount: LongWord;
CreationCallStack: PWideChar;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DVolumeTexture9);'}
{$EXTERNALSYM IDirect3DVolumeTexture9}
IDirect3DVolumeTexture9 = interface(IDirect3DBaseTexture9)
['{2518526C-E789-4111-A7B9-47EF328D13E6}']
(*** IDirect3DVolumeTexture9 methods ***)
function GetLevelDesc(Level: LongWord; out pDesc: TD3DVolumeDesc): HResult; stdcall;
function GetVolumeLevel(Level: LongWord; out ppVolumeLevel: IDirect3DVolume9): HResult; stdcall;
function LockBox(Level: LongWord; out pLockedVolume: TD3DLockedBox; pBox: PD3DBox; Flags: DWord): HResult; stdcall;
function UnlockBox(Level: LongWord): HResult; stdcall;
function AddDirtyBox(pDirtyBox: PD3DBox): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DVolumeTexture9Helper}
IDirect3DVolumeTexture9Helper = class
(*** helper information ***)
Name: PWideChar;
Width: LongWord;
Height: LongWord;
Depth: LongWord;
Levels: LongWord;
Usage: DWORD;
Format: TD3DFormat;
Pool: TD3DPool;
Priority: DWORD;
LOD: DWORD;
FilterType: TD3DTextureFilterType;
LockCount: LongWord;
CreationCallStack: PWideChar;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DCubeTexture9);'}
{$EXTERNALSYM IDirect3DCubeTexture9}
IDirect3DCubeTexture9 = interface(IDirect3DBaseTexture9)
['{FFF32F81-D953-473a-9223-93D652ABA93F}']
(*** IDirect3DCubeTexture9 methods ***)
function GetLevelDesc(Level: LongWord; out pDesc: TD3DSurfaceDesc): HResult; stdcall;
function GetCubeMapSurface(FaceType: TD3DCubeMapFaces; Level: LongWord; out ppCubeMapSurface: IDirect3DSurface9): HResult; stdcall;
function LockRect(FaceType: TD3DCubeMapFaces; Level: LongWord; out pLockedRect: TD3DLockedRect; pRect: PRect; Flags: DWord): HResult; stdcall;
function UnlockRect(FaceType: TD3DCubeMapFaces; Level: LongWord): HResult; stdcall;
function AddDirtyRect(FaceType: TD3DCubeMapFaces; pDirtyRect: PRect): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DCubeTexture9Helper}
IDirect3DCubeTexture9Helper = class
(*** helper information ***)
Name: PWideChar;
Width: LongWord;
Height: LongWord;
Depth: LongWord;
Levels: LongWord;
Usage: DWORD;
Format: TD3DFormat;
Pool: TD3DPool;
Priority: DWORD;
LOD: DWORD;
FilterType: TD3DTextureFilterType;
LockCount: LongWord;
CreationCallStack: PWideChar;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DVertexBuffer9);'}
{$EXTERNALSYM IDirect3DVertexBuffer9}
IDirect3DVertexBuffer9 = interface(IDirect3DResource9)
['{B64BB1B5-FD70-4df6-BF91-19D0A12455E3}']
(*** IDirect3DVertexBuffer9 methods ***)
function Lock(OffsetToLock, SizeToLock: LongWord; out ppbData: Pointer; Flags: DWord): HResult; stdcall;
function Unlock: HResult; stdcall;
function GetDesc(out pDesc: TD3DVertexBufferDesc): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DVertexBuffer9Helper}
IDirect3DVertexBuffer9Helper = class
(*** helper information ***)
Name: PWideChar;
Length: LongWord;
Usage: DWORD;
FVF: DWORD;
Pool: TD3DPool;
Priority: DWORD;
LockCount: LongWord;
CreationCallStack: PWideChar;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DIndexBuffer9);'}
{$EXTERNALSYM IDirect3DIndexBuffer9}
IDirect3DIndexBuffer9 = interface(IDirect3DResource9)
['{7C9DD65E-D3F7-4529-ACEE-785830ACDE35}']
(*** IDirect3DIndexBuffer9 methods ***)
function Lock(OffsetToLock, SizeToLock: DWord; out ppbData: Pointer; Flags: DWord): HResult; stdcall;
function Unlock: HResult; stdcall;
function GetDesc(out pDesc: TD3DIndexBufferDesc): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DIndexBuffer9Helper}
IDirect3DIndexBuffer9Helper = class
(*** helper information ***)
Name: PWideChar;
Length: LongWord;
Usage: DWORD;
Format: TD3DFormat;
Pool: TD3DPool;
Priority: DWORD;
LockCount: LongWord;
CreationCallStack: PWideChar;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DSurface9);'}
{$EXTERNALSYM IDirect3DSurface9}
IDirect3DSurface9 = interface(IDirect3DResource9)
['{0CFBAF3A-9FF6-429a-99B3-A2796AF8B89B}']
(*** IDirect3DSurface9 methods ***)
function GetContainer(const riid: TGUID; out ppContainer{: Pointer}): HResult; stdcall;
function GetDesc(out pDesc: TD3DSurfaceDesc): HResult; stdcall;
function LockRect(out pLockedRect: TD3DLockedRect; pRect: PRect; Flags: DWord): HResult; stdcall;
function UnlockRect: HResult; stdcall;
function GetDC(out phdc: HDC): HResult; stdcall;
function ReleaseDC(hdc: HDC): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DSurface9Helper}
IDirect3DSurface9Helper = class
(*** helper information ***)
Name: PWideChar;
Width: LongWord;
Height: LongWord;
Usage: DWORD;
Format: TD3DFormat;
Pool: TD3DPool;
MultiSampleType: TD3DMultiSampleType;
MultiSampleQuality: DWORD;
Priority: DWORD;
LockCount: LongWord;
DCCount: LongWord;
CreationCallStack: PWideChar;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DVolume9);'}
{$EXTERNALSYM IDirect3DVolume9}
IDirect3DVolume9 = interface (IUnknown)
['{24F416E6-1F67-4aa7-B88E-D33F6F3128A1}']
(*** IDirect3DVolume9 methods ***)
function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall;
function SetPrivateData(const refguid: TGUID; const pData; SizeOfData, Flags: DWord): HResult; stdcall;
function GetPrivateData(const refguid: TGUID; pData: Pointer; out pSizeOfData: DWord): HResult; stdcall;
function FreePrivateData(const refguid: TGUID): HResult; stdcall;
function GetContainer(const riid: TGUID; var ppContainer: Pointer): HResult; stdcall;
function GetDesc(out pDesc: TD3DVolumeDesc): HResult; stdcall;
function LockBox(out pLockedVolume: TD3DLockedBox; pBox: PD3DBox; Flags: DWord): HResult; stdcall;
function UnlockBox: HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DVolume9Helper}
IDirect3DVolume9Helper = class
(*** helper information ***)
Name: PWideChar;
Width: LongWord;
Height: LongWord;
Depth: LongWord;
Usage: DWORD;
Format: TD3DFormat;
Pool: TD3DPool;
LockCount: LongWord;
CreationCallStack: PWideChar;
end;
{$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DQuery9);'}
{$EXTERNALSYM IDirect3DQuery9}
IDirect3DQuery9 = interface(IUnknown)
['{d9771460-a695-4f26-bbd3-27b840b541cc}']
(*** IDirect3DQuery9 methods ***)
function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall;
function GetType: TD3DQueryType; stdcall;
function GetDataSize: DWORD; stdcall;
function Issue(dwIssueFlags: DWORD): HResult; stdcall;
function GetData(pData: Pointer; dwSize: DWORD; dwGetDataFlags: DWORD): HResult; stdcall;
end;
{$EXTERNALSYM IDirect3DQuery9Helper}
IDirect3DQuery9Helper = class
(*** helper information ***)
_Type: TD3DQueryType;
DataSize: DWORD;
CreationCallStack: PWideChar;
end;
(*
* Interface IID's
*)
type
IID_IDirect3D9 = IDirect3D9;
{$EXTERNALSYM IID_IDirect3D9}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
IID_IDirect3D9Ex = IDirect3D9Ex;
{$EXTERNALSYM IID_IDirect3D9Ex}
{$ENDIF}
IID_IDirect3DDevice9 = IDirect3DDevice9;
{$EXTERNALSYM IID_IDirect3DDevice9}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
IID_IDirect3DDevice9Ex = IDirect3DDevice9Ex;
{$EXTERNALSYM IID_IDirect3DDevice9Ex}
{$ENDIF}
IID_IDirect3DResource9 = IDirect3DResource9;
{$EXTERNALSYM IID_IDirect3DResource9}
IID_IDirect3DBaseTexture9 = IDirect3DBaseTexture9;
{$EXTERNALSYM IID_IDirect3DBaseTexture9}
IID_IDirect3DTexture9 = IDirect3DTexture9;
{$EXTERNALSYM IID_IDirect3DTexture9}
IID_IDirect3DCubeTexture9 = IDirect3DCubeTexture9;
{$EXTERNALSYM IID_IDirect3DCubeTexture9}
IID_IDirect3DVolumeTexture9 = IDirect3DVolumeTexture9;
{$EXTERNALSYM IID_IDirect3DVolumeTexture9}
IID_IDirect3DVertexBuffer9 = IDirect3DVertexBuffer9;
{$EXTERNALSYM IID_IDirect3DVertexBuffer9}
IID_IDirect3DIndexBuffer9 = IDirect3DIndexBuffer9;
{$EXTERNALSYM IID_IDirect3DIndexBuffer9}
IID_IDirect3DSurface9 = IDirect3DSurface9;
{$EXTERNALSYM IID_IDirect3DSurface9}
IID_IDirect3DVolume9 = IDirect3DVolume9;
{$EXTERNALSYM IID_IDirect3DVolume9}
IID_IDirect3DSwapChain9 = IDirect3DSwapChain9;
{$EXTERNALSYM IID_IDirect3DSwapChain9}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
IID_IDirect3DSwapChain9Ex = IDirect3DSwapChain9Ex;
{$EXTERNALSYM IID_IDirect3DSwapChain9Ex}
{$ENDIF}
IID_IDirect3DVertexDeclaration9 = IDirect3DVertexDeclaration9;
{$EXTERNALSYM IID_IDirect3DVertexDeclaration9}
IID_IDirect3DVertexShader9 = IDirect3DVertexShader9;
{$EXTERNALSYM IID_IDirect3DVertexShader9}
IID_IDirect3DPixelShader9 = IDirect3DPixelShader9;
{$EXTERNALSYM IID_IDirect3DPixelShader9}
IID_IDirect3DStateBlock9 = IDirect3DStateBlock9;
{$EXTERNALSYM IID_IDirect3DStateBlock9}
IID_IDirect3DQuery9 = IDirect3DQuery9;
{$EXTERNALSYM IID_IDirect3DQuery9}
const
IID_HelperName : TGUID = '{E4A36723-FDFE-4b22-B146-3C04C07F4CC8}';
{$EXTERNALSYM IID_HelperName}
const
{****************************************************************************
* Flags for SetPrivateData method on all D3D9 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 D3D9 object is freed.
****************************************************************************}
D3DSPD_IUNKNOWN = $00000001;
{$EXTERNALSYM D3DSPD_IUNKNOWN}
(****************************************************************************
*
* Flags for IDirect3D9::CreateDevice's BehaviorFlags
*
****************************************************************************)
D3DCREATE_FPU_PRESERVE = $00000002;
{$EXTERNALSYM D3DCREATE_FPU_PRESERVE}
D3DCREATE_MULTITHREADED = $00000004;
{$EXTERNALSYM D3DCREATE_MULTITHREADED}
D3DCREATE_PUREDEVICE = $00000010;
{$EXTERNALSYM D3DCREATE_PUREDEVICE}
D3DCREATE_SOFTWARE_VERTEXPROCESSING = $00000020;
{$EXTERNALSYM D3DCREATE_SOFTWARE_VERTEXPROCESSING}
D3DCREATE_HARDWARE_VERTEXPROCESSING = $00000040;
{$EXTERNALSYM D3DCREATE_HARDWARE_VERTEXPROCESSING}
D3DCREATE_MIXED_VERTEXPROCESSING = $00000080;
{$EXTERNALSYM D3DCREATE_MIXED_VERTEXPROCESSING}
D3DCREATE_DISABLE_DRIVER_MANAGEMENT = $00000100;
{$EXTERNALSYM D3DCREATE_DISABLE_DRIVER_MANAGEMENT}
D3DCREATE_ADAPTERGROUP_DEVICE = $00000200;
{$EXTERNALSYM D3DCREATE_ADAPTERGROUP_DEVICE}
D3DCREATE_DISABLE_DRIVER_MANAGEMENT_EX = $00000400;
{$EXTERNALSYM D3DCREATE_DISABLE_DRIVER_MANAGEMENT_EX}
// This flag causes the D3D runtime not to alter the focus
// window in any way. Use with caution- the burden of supporting
// focus management events (alt-tab, etc.) falls on the
// application, and appropriate responses (switching display
// mode, etc.) should be coded.
D3DCREATE_NOWINDOWCHANGES = $00000800;
{$EXTERNALSYM D3DCREATE_NOWINDOWCHANGES}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
// Disable multithreading for software vertex processing
D3DCREATE_DISABLE_PSGP_THREADING = $00002000;
{$EXTERNALSYM D3DCREATE_DISABLE_PSGP_THREADING}
// This flag enables present statistics on device.
D3DCREATE_ENABLE_PRESENTSTATS = $00004000;
{$EXTERNALSYM D3DCREATE_ENABLE_PRESENTSTATS}
// This flag disables printscreen support in the runtime for this device
D3DCREATE_DISABLE_PRINTSCREEN = $00008000;
{$EXTERNALSYM D3DCREATE_DISABLE_PRINTSCREEN}
D3DCREATE_SCREENSAVER = $10000000;
{$EXTERNALSYM D3DCREATE_SCREENSAVER}
{$ENDIF}
(****************************************************************************
*
* Parameter for IDirect3D9::CreateDevice's Adapter argument
*
****************************************************************************)
D3DADAPTER_DEFAULT = 0;
{$EXTERNALSYM D3DADAPTER_DEFAULT}
(****************************************************************************
*
* Flags for IDirect3D9::EnumAdapters
*
****************************************************************************)
{$IFDEF DIRECT3D_VERSION_9_VISTA}
(*
* The D3DENUM_WHQL_LEVEL value has been retired for this and future versions.
* See the DirectX SDK for sample code on discovering driver signatures.
*)
(* NO_DRIVERVERSION will not fill out the DriverVersion field, nor will the
DriverVersion be incorporated into the DeviceIdentifier GUID. WINNT only *)
D3DENUM_NO_DRIVERVERSION = $00000004;
{$EXTERNALSYM D3DENUM_NO_DRIVERVERSION}
{$ELSE}
D3DENUM_WHQL_LEVEL = $00000002;
{$EXTERNALSYM D3DENUM_WHQL_LEVEL}
{$ENDIF}
(****************************************************************************
*
* Maximum number of back-buffers supported in DX9
*
****************************************************************************)
D3DPRESENT_BACK_BUFFERS_MAX = 3;
{$EXTERNALSYM D3DPRESENT_BACK_BUFFERS_MAX}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
(****************************************************************************
*
* Maximum number of back-buffers supported when apps use CreateDeviceEx
*
****************************************************************************)
D3DPRESENT_BACK_BUFFERS_MAX_EX = 30;
{$EXTERNALSYM D3DPRESENT_BACK_BUFFERS_MAX_EX}
{$ENDIF}
(****************************************************************************
*
* Flags for IDirect3DDevice9::SetGammaRamp
*
****************************************************************************)
D3DSGR_NO_CALIBRATION = $00000000;
{$EXTERNALSYM D3DSGR_NO_CALIBRATION}
D3DSGR_CALIBRATE = $00000001;
{$EXTERNALSYM D3DSGR_CALIBRATE}
(****************************************************************************
*
* Flags for IDirect3DDevice9::SetCursorPosition
*
****************************************************************************)
D3DCURSOR_IMMEDIATE_UPDATE = $00000001;
{$EXTERNALSYM D3DCURSOR_IMMEDIATE_UPDATE}
(****************************************************************************
*
* Flags for IDirect3DSwapChain9::Present
*
****************************************************************************)
D3DPRESENT_DONOTWAIT = $00000001;
{$EXTERNALSYM D3DPRESENT_DONOTWAIT}
D3DPRESENT_LINEAR_CONTENT = $00000002;
{$EXTERNALSYM D3DPRESENT_LINEAR_CONTENT}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
D3DPRESENT_DONOTFLIP = $00000004;
{$EXTERNALSYM D3DPRESENT_DONOTFLIP}
D3DPRESENT_FLIPRESTART = $00000008;
{$EXTERNALSYM D3DPRESENT_FLIPRESTART}
{$ENDIF}
(****************************************************************************
*
* Flags for DrawPrimitive/DrawIndexedPrimitive
* Also valid for Begin/BeginIndexed
* Also valid for VertexBuffer::CreateVertexBuffer
****************************************************************************)
(*
* DirectDraw error codes
*)
_FACD3D = $876;
{$EXTERNALSYM _FACD3D}
//#define MAKE_D3DHRESULT( code ) MAKE_HRESULT( 1, _FACD3D, code )
function MAKE_D3DHRESULT(Code: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM MAKE_D3DHRESULT}
//#define MAKE_D3DSTATUS( code ) MAKE_HRESULT( 0, _FACD3D, code )
function MAKE_D3DSTATUS(Code: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM MAKE_D3DSTATUS}
const
MAKE_D3DHRESULT_R = (1 shl 31) or (_FACD3D shl 16);
MAKE_D3DSTATUS_R = (0 shl 31) or (_FACD3D shl 16);
(*
* Direct3D Errors
*)
D3D_OK = S_OK;
{$EXTERNALSYM D3D_OK}
D3DERR_WRONGTEXTUREFORMAT = HResult(MAKE_D3DHRESULT_R or 2072);
{$EXTERNALSYM D3DERR_WRONGTEXTUREFORMAT}
D3DERR_UNSUPPORTEDCOLOROPERATION = HResult(MAKE_D3DHRESULT_R or 2073);
{$EXTERNALSYM D3DERR_UNSUPPORTEDCOLOROPERATION}
D3DERR_UNSUPPORTEDCOLORARG = HResult(MAKE_D3DHRESULT_R or 2074);
{$EXTERNALSYM D3DERR_UNSUPPORTEDCOLORARG}
D3DERR_UNSUPPORTEDALPHAOPERATION = HResult(MAKE_D3DHRESULT_R or 2075);
{$EXTERNALSYM D3DERR_UNSUPPORTEDALPHAOPERATION}
D3DERR_UNSUPPORTEDALPHAARG = HResult(MAKE_D3DHRESULT_R or 2076);
{$EXTERNALSYM D3DERR_UNSUPPORTEDALPHAARG}
D3DERR_TOOMANYOPERATIONS = HResult(MAKE_D3DHRESULT_R or 2077);
{$EXTERNALSYM D3DERR_TOOMANYOPERATIONS}
D3DERR_CONFLICTINGTEXTUREFILTER = HResult(MAKE_D3DHRESULT_R or 2078);
{$EXTERNALSYM D3DERR_CONFLICTINGTEXTUREFILTER}
D3DERR_UNSUPPORTEDFACTORVALUE = HResult(MAKE_D3DHRESULT_R or 2079);
{$EXTERNALSYM D3DERR_UNSUPPORTEDFACTORVALUE}
D3DERR_CONFLICTINGRENDERSTATE = HResult(MAKE_D3DHRESULT_R or 2081);
{$EXTERNALSYM D3DERR_CONFLICTINGRENDERSTATE}
D3DERR_UNSUPPORTEDTEXTUREFILTER = HResult(MAKE_D3DHRESULT_R or 2082);
{$EXTERNALSYM D3DERR_UNSUPPORTEDTEXTUREFILTER}
D3DERR_CONFLICTINGTEXTUREPALETTE = HResult(MAKE_D3DHRESULT_R or 2086);
{$EXTERNALSYM D3DERR_CONFLICTINGTEXTUREPALETTE}
D3DERR_DRIVERINTERNALERROR = HResult(MAKE_D3DHRESULT_R or 2087);
{$EXTERNALSYM D3DERR_DRIVERINTERNALERROR}
D3DERR_NOTFOUND = HResult(MAKE_D3DHRESULT_R or 2150);
{$EXTERNALSYM D3DERR_NOTFOUND}
D3DERR_MOREDATA = HResult(MAKE_D3DHRESULT_R or 2151);
{$EXTERNALSYM D3DERR_MOREDATA}
D3DERR_DEVICELOST = HResult(MAKE_D3DHRESULT_R or 2152);
{$EXTERNALSYM D3DERR_DEVICELOST}
D3DERR_DEVICENOTRESET = HResult(MAKE_D3DHRESULT_R or 2153);
{$EXTERNALSYM D3DERR_DEVICENOTRESET}
D3DERR_NOTAVAILABLE = HResult(MAKE_D3DHRESULT_R or 2154);
{$EXTERNALSYM D3DERR_NOTAVAILABLE}
D3DERR_OUTOFVIDEOMEMORY = HResult(MAKE_D3DHRESULT_R or 380);
{$EXTERNALSYM D3DERR_OUTOFVIDEOMEMORY}
D3DERR_INVALIDDEVICE = HResult(MAKE_D3DHRESULT_R or 2155);
{$EXTERNALSYM D3DERR_INVALIDDEVICE}
D3DERR_INVALIDCALL = HResult(MAKE_D3DHRESULT_R or 2156);
{$EXTERNALSYM D3DERR_INVALIDCALL}
D3DERR_DRIVERINVALIDCALL = HResult(MAKE_D3DHRESULT_R or 2157);
{$EXTERNALSYM D3DERR_DRIVERINVALIDCALL}
D3DERR_WASSTILLDRAWING = HResult(MAKE_D3DHRESULT_R or 540);
{$EXTERNALSYM D3DERR_WASSTILLDRAWING}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
D3DERR_DEVICEREMOVED = HResult(MAKE_D3DHRESULT_R or 2160);
{$EXTERNALSYM D3DERR_DEVICEREMOVED}
{$ENDIF}
D3DOK_NOAUTOGEN = HResult(MAKE_D3DSTATUS_R or 2159);
{$EXTERNALSYM D3DOK_NOAUTOGEN}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
S_NOT_RESIDENT = HResult(MAKE_D3DSTATUS_R or 2165);
{$EXTERNALSYM S_NOT_RESIDENT}
S_RESIDENT_IN_SHARED_MEMORY = HResult(MAKE_D3DSTATUS_R or 2166);
{$EXTERNALSYM S_RESIDENT_IN_SHARED_MEMORY}
S_PRESENT_MODE_CHANGED = HResult(MAKE_D3DSTATUS_R or 2167);
{$EXTERNALSYM S_PRESENT_MODE_CHANGED}
S_PRESENT_OCCLUDED = HResult(MAKE_D3DSTATUS_R or 2168);
{$EXTERNALSYM S_PRESENT_OCCLUDED}
D3DERR_DEVICEHUNG = HResult(MAKE_D3DHRESULT_R or 2164);
{$EXTERNALSYM D3DERR_DEVICEHUNG}
{$ENDIF}
(*
* DLL Function for creating a Direct3D9 object. This object supports
* enumeration and allows the creation of Direct3DDevice9 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 Direct3D9Loaded: Boolean;
function LoadDirect3D9: Boolean;
function UnLoadDirect3D9: Boolean;
const
Direct3D9dll = 'd3d9.dll';
// Due to the way Object Pascal handles functions resulting in 'native' interface
// pointer we should declare result not as interface but as usial pointer
{$IFDEF DIRECT3D9_DYNAMIC_LINK}
type
TDirect3DCreate9 = function (SDKVersion: LongWord): Pointer; stdcall;
{$IFDEF DIRECT3D_VERSION_9_VISTA}
TDirect3DCreate9Ex = function (SDKVersion: LongWord; out d3d9ex: IDirect3D9Ex): HRESULT; stdcall;
{$ENDIF}
var
_Direct3DCreate9: TDirect3DCreate9 = nil;
{$IFDEF DIRECT3D_VERSION_9_VISTA}
Direct3DCreate9Ex: TDirect3DCreate9Ex = nil;
{$ENDIF}
{$ELSE}
function _Direct3DCreate9(SDKVersion: LongWord): Pointer; stdcall;
{$ENDIF}
function Direct3DCreate9(SDKVersion: LongWord): IDirect3D9; stdcall;
{$EXTERNALSYM Direct3DCreate9}
{$IFNDEF DIRECT3D9_DYNAMIC_LINK}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
function Direct3DCreate9Ex(SDKVersion: LongWord; out d3d9ex: IDirect3D9Ex): HRESULT; stdcall;
{$EXTERNALSYM Direct3DCreate9Ex}
{$ENDIF}
{$ENDIF}
(*
* Stubs for graphics profiling.
*)
function D3DPERF_BeginEvent(col: TD3DColor; wszName: PWideChar): Integer; stdcall; external Direct3D9dll;
{$EXTERNALSYM D3DPERF_BeginEvent}
function D3DPERF_EndEvent: Integer; stdcall; external Direct3D9dll;
{$EXTERNALSYM D3DPERF_EndEvent}
procedure D3DPERF_SetMarker(col: TD3DColor; wszName: PWideChar); stdcall; external Direct3D9dll;
{$EXTERNALSYM D3DPERF_SetMarker}
procedure D3DPERF_SetRegion(col: TD3DColor; wszName: PWideChar); stdcall; external Direct3D9dll;
{$EXTERNALSYM D3DPERF_SetRegion}
function D3DPERF_QueryRepeatFrame: BOOL; stdcall; external Direct3D9dll;
{$EXTERNALSYM D3DPERF_QueryRepeatFrame}
procedure D3DPERF_SetOptions(dwOptions: DWORD); stdcall; external Direct3D9dll;
{$EXTERNALSYM D3DPERF_SetOptions}
function D3DPERF_GetStatus: DWORD; stdcall; external Direct3D9dll;
{$EXTERNALSYM D3DPERF_GetStatus}
//********************************************************************
// Introduced types for compatibility with non-Borland compliant translation
// by Ampaze (Tim Baumgarten) from http://www.crazyentertainment.net
type
PD3DAdapter_Identifier9 = PD3DAdapterIdentifier9;
PD3DDevice_Creation_Parameters = PD3DDeviceCreationParameters;
PD3DDevInfo_D3DVertexStats = PD3DDevInfoD3DVertexStats;
PD3DDevInfo_ResourceManager = PD3DDevInfoResourceManager;
PD3DDevInfo_VCache = PD3DDevInfoVCache;
PD3DIndexBuffer_Desc = PD3DIndexBufferDesc;
PD3DLocked_Box = PD3DLockedBox;
PD3DLocked_Rect = PD3DLockedRect;
PD3DPresent_Parameters = PD3DPresentParameters;
PD3DRaster_Status = PD3DRasterStatus;
PD3DRectPatch_Info = PD3DRectPatchInfo;
PD3DSurface_Desc = PD3DSurfaceDesc;
PD3DTriPatch_Info = PD3DTriPatchInfo;
PD3DVertexBuffer_Desc = PD3DVertexBufferDesc;
PD3DVolume_Desc = PD3DVolumeDesc;
TD3DAdapter_Identifier9 = TD3DAdapterIdentifier9;
TD3DBackBuffer_Type = TD3DBackBufferType;
TD3DCubeMap_Faces = TD3DCubeMapFaces;
TD3DDevice_Creation_Parameters = TD3DDeviceCreationParameters;
TD3DDevInfo_D3DVertexStats = TD3DDevInfoD3DVertexStats;
TD3DDevInfo_ResourceManager = TD3DDevInfoResourceManager;
TD3DDevInfo_VCache = TD3DDevInfoVCache;
TD3DIndexBuffer_Desc = TD3DIndexBufferDesc;
TD3DLocked_Box = TD3DLockedBox;
TD3DLocked_Rect = TD3DLockedRect;
TD3DMultiSample_Type = TD3DMultiSampleType;
TD3DPresent_Parameters = TD3DPresentParameters;
TD3DRaster_Status = TD3DRasterStatus;
TD3DRectPatch_Info = TD3DRectPatchInfo;
TD3DSampler_Texture_Type = TD3DSamplerTextureType;
TD3DShader_AddressMode_Type = TD3DShaderAddressModeType;
TD3DShader_Comparison = TD3DShaderComparison;
TD3DShader_Instruction_Opcode_Type = TD3DShaderInstructionOpcodeType;
TD3DShader_MiscType_Offsets = TD3DShaderMiscTypeOffsets;
TD3DShader_Param_Register_Type = TD3DShaderParamRegisterType;
TD3DShader_Param_SRCMod_Type = TD3DShaderParamSRCModType;
TD3DSurface_Desc = TD3DSurfaceDesc;
TD3DTriPatch_Info = TD3DTriPatchInfo;
TD3DVertexBuffer_Desc = TD3DVertexBufferDesc;
TD3DVolume_Desc = TD3DVolumeDesc;
TD3DVS_AddressMode_Type = TD3DVSAddressModeType;
TD3DVS_RastOut_Offsets = TD3DVSRastOutOffsets;
implementation
(*==========================================================================;
* File: d3d9types.h
* Content: Direct3D capabilities include file
***************************************************************************)
// #define D3DCOLOR_ARGB(a,r,g,b)
// ((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))
function D3DCOLOR_ARGB(a,r,g,b: DWord): TD3DColor;
begin
Result := (a shl 24) or (r shl 16) or (g shl 8) or b;
end;
// #define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b)
function D3DCOLOR_RGBA(r,g,b,a: DWord): TD3DColor;
begin
Result := (a shl 24) or (r shl 16) or (g shl 8) or b;
end;
// #define D3DCOLOR_XRGB(r,g,b) D3DCOLOR_ARGB(0xff,r,g,b)
function D3DCOLOR_XRGB(r,g,b: DWord): TD3DColor;
begin
Result := DWORD($FF shl 24) or (r shl 16) or (g shl 8) or b;
end;
// #define D3DCOLOR_XYUV(y,u,v) D3DCOLOR_ARGB(0xff,y,u,v)
function D3DCOLOR_XYUV(y,u,v: DWord): TD3DColor;
begin
Result := DWORD($FF shl 24) or (y shl 16) or (u shl 8) or v;
end;
// #define D3DCOLOR_AYUV(a,y,u,v) D3DCOLOR_ARGB(a,y,u,v)
function D3DCOLOR_AYUV(a,y,u,v: DWord): TD3DColor;
begin
Result := (a shl 24) or (y shl 16) or (u shl 8) or v;
end;
// #define D3DCOLOR_COLORVALUE(r,g,b,a)
// D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWORD)((a)*255.f))
function D3DCOLOR_COLORVALUE(r,g,b,a: Single): TD3DColor;
begin
Result := (round(a * 255) shl 24) or
(round(r * 255) shl 16) or
(round(g * 255) shl 8) or
(round(b * 255));
end;
// #define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256)
function D3DTS_WORLDMATRIX(index: Byte): TD3DTransformStateType;
begin
Result:= TD3DTransformStateType(index + 256);
end;
//#define D3DPS_VERSION(_Major,_Minor) (0xFFFF0000|((_Major)<<8)|(_Minor))
function D3DPS_VERSION(_Major, _Minor : Cardinal) : Cardinal;
begin
Result:= $FFFF0000 or (_Major shl 8 ) or _Minor;
end;
//#define D3DVS_VERSION(_Major,_Minor) (0xFFFE0000|((_Major)<<8)|(_Minor))
function D3DVS_VERSION(_Major, _Minor : Cardinal) : Cardinal;
begin
Result:= $FFFE0000 or (_Major shl 8 ) or _Minor;
end;
//#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF)
function D3DSHADER_VERSION_MAJOR(_Version : Cardinal) : Cardinal;
begin
Result:= (_Version shr 8 ) and $FF;
end;
//#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF)
function D3DSHADER_VERSION_MINOR(_Version : Cardinal) : Cardinal;
begin
Result:= (_Version shr 0) and $FF;
end;
//#define D3DSHADER_COMMENT(_DWordSize)
// ((((_DWordSize)<<D3DSI_COMMENTSIZE_SHIFT)&D3DSI_COMMENTSIZE_MASK)|D3DSIO_COMMENT)
function D3DSHADER_COMMENT(_DWordSize: DWord) : DWord;
begin
Result:= ((_DWordSize shl D3DSI_COMMENTSIZE_SHIFT) and D3DSI_COMMENTSIZE_MASK) or D3DSIO_COMMENT;
end;
//#define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE3(CoordIndex: DWord): DWord;
begin
Result:= D3DFVF_TEXTUREFORMAT3 shl (CoordIndex * 2 + 16)
end;
//#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2)
function D3DFVF_TEXCOORDSIZE2(CoordIndex: DWord): DWord;
begin
Result:= D3DFVF_TEXTUREFORMAT2;
end;
//#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE4(CoordIndex: DWord): DWord;
begin
Result:= D3DFVF_TEXTUREFORMAT4 shl (CoordIndex * 2 + 16)
end;
//#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE1(CoordIndex: DWord): DWord;
begin
Result:= D3DFVF_TEXTUREFORMAT1 shl (CoordIndex * 2 + 16)
end;
// #define MAKEFOURCC(ch0, ch1, ch2, ch3)
// ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |
// ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
function MAKEFOURCC(ch0, ch1, ch2, ch3: Char): DWord;
begin
Result:= Byte(ch0) or (Byte(ch1) shl 8) or (Byte(ch2) shl 16) or (Byte(ch3) shl 24 );
end;
(*==========================================================================;
* File: d3d9.h
* Content: Direct3D include file
****************************************************************************)
//#define MAKE_D3DHRESULT( code ) MAKE_HRESULT( 1, _FACD3D, code )
function MAKE_D3DHRESULT(Code: DWord): DWord;
begin
Result:= DWord((1 shl 31) or (_FACD3D shl 16)) or Code;
end;
//#define MAKE_D3DSTATUS( code ) MAKE_HRESULT( 0, _FACD3D, code )
function MAKE_D3DSTATUS(Code: DWord): DWord;
begin
Result:= DWord((0 shl 31) or (_FACD3D shl 16)) or Code;
end;
{$IFDEF DIRECT3D9_DYNAMIC_LINK}
var
Direct3D9Lib: THandle = 0;
function Direct3D9Loaded: Boolean;
begin
Result:= Direct3D9Lib <> 0;
end;
function UnLoadDirect3D9: Boolean;
begin
Result:= True;
if Direct3D9Loaded then
begin
Result:= FreeLibrary(Direct3D9Lib);
_Direct3DCreate9:= nil;
Direct3D9Lib:= 0;
end;
end;
function LoadDirect3D9: Boolean;
const
ProcName = 'Direct3DCreate9';
ProcNameEx = 'Direct3DCreate9Ex';
begin
Result:= Direct3D9Loaded;
if (not Result) then
begin
Direct3D9Lib:= LoadLibrary(Direct3D9dll);
if Direct3D9Loaded then
begin
_Direct3DCreate9:= GetProcAddress(Direct3D9Lib, ProcName);
Result:= Assigned(_Direct3DCreate9);
if not Result then UnLoadDirect3D9;
{$IFDEF DIRECT3D_VERSION_9_VISTA}
Direct3DCreate9Ex:= GetProcAddress(Direct3D9Lib, ProcNameEx);
{$ENDIF}
end;
end;
end;
{$ELSE}
function Direct3D9Loaded: Boolean;
begin // Stub function for static linking
Result:= True;
end;
function UnLoadDirect3D9: Boolean;
begin // Stub function for static linking
Result:= True; // should emulate "normal" behaviour
end;
function LoadDirect3D9: Boolean;
begin // Stub function for static linking
Result:= True;
end;
function _Direct3DCreate9(SDKVersion: LongWord): Pointer; external Direct3D9dll name 'Direct3DCreate9';
{$IFDEF DIRECT3D_VERSION_9_VISTA}
function Direct3DCreate9Ex(SDKVersion: LongWord; out d3d9ex: IDirect3D9Ex): HRESULT; stdcall; external Direct3D9dll;
{$ENDIF}
{$ENDIF}
function Direct3DCreate9(SDKVersion: LongWord): IDirect3D9; stdcall;
begin
{$IFDEF DIRECT3D9_DYNAMIC_LINK}
{$IFDEF DIRECT3D9_DYNAMIC_LINK_EXPLICIT}
LoadDirect3D9;
{$ENDIF}
{$ENDIF}
Result:= IDirect3D9(_Direct3DCreate9(SDKVersion));
if Assigned(Result) then Result._Release; // Delphi autoincrement reference count
end;
{$IFDEF DIRECT3D9_DYNAMIC_LINK}
initialization
{$IFNDEF DIRECT3D9_DYNAMIC_LINK_EXPLICIT}
LoadDirect3D9;
{$ENDIF}
finalization
UnLoadDirect3D9;
{$ENDIF}
end.