GitHub-Mirror/G940LEDControl
1
0
Fork 0
mirror of synced 2024-11-22 01:53:50 +00:00
Code Issues Projects Releases Wiki Activity
57037928ca
G940LEDControl/DirectX/Direct3D9.pas

5615 lines
234 KiB
ObjectPascal
Raw Blame History

{******************************************************************************}
{* *}
{* Copyright (C) Microsoft Corporation. All Rights Reserved. *}
{* *}
{* Files: d3d9types.h d3d9caps.h d3d9.h *}
{* Content: Direct3D9 include files *}
{* *}
{* DirectX 9.0 Delphi / FreePascal adaptation by Alexey Barkovoy *}
{* E-Mail: directx@clootie.ru *}
{* *}
{* Latest version can be downloaded from: *}
{* http://clootie.ru *}
{* http://sourceforge.net/projects/delphi-dx9sdk *}
{* *}
{*----------------------------------------------------------------------------*}
{* $Id: Direct3D9.pas,v 1.13 2006/10/22 22:00:33 clootie Exp $ }
{******************************************************************************}
{ }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
{ }
{ The contents of this file are used with permission, subject to the Mozilla }
{ Public License Version 1.1 (the "License"); you may not use this file except }
{ in compliance with the License. You may obtain a copy of the License at }
{ http://www.mozilla.org/MPL/MPL-1.1.html }
{ }
{ Software distributed under the License is distributed on an "AS IS" basis, }
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
{ the specific language governing rights and limitations under the License. }
{ }
{ Alternatively, the contents of this file may be used under the terms of the }
{ GNU Lesser General Public License (the "LGPL License"), in which case the }
{ provisions of the LGPL License are applicable instead of those above. }
{ If you wish to allow use of your version of this file only under the terms }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting the provisions above and }
{ replace them with the notice and other provisions required by the LGPL }
{ License. If you do not delete the provisions above, a recipient may use }
{ your version of this file under either the MPL or the LGPL License. }
{ }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{ }
{******************************************************************************}
{$I DirectX.inc}
unit Direct3D9;
interface
// Global level dynamic loading support
{$IFDEF DYNAMIC_LINK_ALL}
{$DEFINE DIRECT3D9_DYNAMIC_LINK}
{$ENDIF}
{$IFDEF DYNAMIC_LINK_EXPLICIT_ALL}
{$DEFINE DIRECT3D9_DYNAMIC_LINK_EXPLICIT}
{$ENDIF}
// Remove "dots" below to force some kind of dynamic linking
{.$DEFINE DIRECT3D9_DYNAMIC_LINK}
{.$DEFINE DIRECT3D9_DYNAMIC_LINK_EXPLICIT}
(*$HPPEMIT '#include "d3d9.h"' *)
(*$HPPEMIT '#include "d3d9types.h"' *)
(*$HPPEMIT '#include "d3d9caps.h"' *)
uses Windows, DXTypes;
///// Helper constants (for use in SetRenderState) /////
const
iTrue = DWORD(True);
iFalse = DWORD(False);
(*==========================================================================;
*
* Copyright (C) Microsoft Corporation. All Rights Reserved.
*
* File: d3d9types.h
* Content: Direct3D capabilities include file
*
***************************************************************************)
type
// D3DCOLOR is equivalent to D3DFMT_A8R8G8B8
D3DCOLOR = DXTypes.D3DCOLOR;
{$EXTERNALSYM D3DCOLOR}
TD3DColor = DXTypes.TD3DColor;
// maps unsigned 8 bits/channel to D3DCOLOR
// #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;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DCOLOR_ARGB}
// #define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b)
function D3DCOLOR_RGBA(r,g,b,a: DWord): TD3DColor;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DCOLOR_RGBA}
// #define D3DCOLOR_XRGB(r,g,b) D3DCOLOR_ARGB(0xff,r,g,b)
function D3DCOLOR_XRGB(r,g,b: DWord): TD3DColor;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DCOLOR_XRGB}
// #define D3DCOLOR_XYUV(y,u,v) D3DCOLOR_ARGB(0xff,y,u,v)
function D3DCOLOR_XYUV(y,u,v: DWord): TD3DColor;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DCOLOR_XYUV}
// #define D3DCOLOR_AYUV(a,y,u,v) D3DCOLOR_ARGB(a,y,u,v)
function D3DCOLOR_AYUV(a,y,u,v: DWord): TD3DColor;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DCOLOR_AYUV}
// maps floating point channels (0.f to 1.f range) to D3DCOLOR
// #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;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DCOLOR_COLORVALUE}
type
_D3DVECTOR = DXTypes._D3DVECTOR;
{$EXTERNALSYM _D3DVECTOR}
D3DVECTOR = DXTypes.D3DVECTOR;
{$EXTERNALSYM D3DVECTOR}
TD3DVector = DXTypes.TD3DVector;
PD3DVector = DXTypes.PD3DVector;
PD3DColorValue = ^TD3DColorValue;
_D3DCOLORVALUE = packed record
r: Single;
g: Single;
b: Single;
a: Single;
end {_D3DCOLORVALUE};
{$EXTERNALSYM _D3DCOLORVALUE}
D3DCOLORVALUE = _D3DCOLORVALUE;
{$EXTERNALSYM D3DCOLORVALUE}
TD3DColorValue = _D3DCOLORVALUE;
PD3DRect = ^TD3DRect;
_D3DRECT = packed record
x1: LongInt;
y1: LongInt;
x2: LongInt;
y2: LongInt;
end {_D3DRECT};
{$EXTERNALSYM _D3DRECT}
D3DRECT = _D3DRECT;
{$EXTERNALSYM D3DRECT}
TD3DRect = _D3DRECT;
PD3DMatrix = ^TD3DMatrix;
_D3DMATRIX = packed record
case integer of
0 : (_11, _12, _13, _14: Single;
_21, _22, _23, _24: Single;
_31, _32, _33, _34: Single;
_41, _42, _43, _44: Single);
1 : (m : array [0..3, 0..3] of Single);
end {_D3DMATRIX};
{$EXTERNALSYM _D3DMATRIX}
D3DMATRIX = _D3DMATRIX;
{$EXTERNALSYM D3DMATRIX}
TD3DMatrix = _D3DMATRIX;
PD3DViewport9 = ^TD3DViewport9;
_D3DVIEWPORT9 = packed record
X: DWord;
Y: DWord; { Viewport Top left }
Width: DWord;
Height: DWord; { Viewport Dimensions }
MinZ: Single; { Min/max of clip Volume }
MaxZ: Single;
end {_D3DVIEWPORT9};
{$EXTERNALSYM _D3DVIEWPORT9}
D3DVIEWPORT9 = _D3DVIEWPORT9;
{$EXTERNALSYM D3DVIEWPORT9}
TD3DViewport9 = _D3DVIEWPORT9;
(*
* Values for clip fields.
*)
const
// Max number of user clipping planes, supported in D3D.
D3DMAXUSERCLIPPLANES = 32;
{$EXTERNALSYM D3DMAXUSERCLIPPLANES}
// These bits could be ORed together to use with D3DRS_CLIPPLANEENABLE
//
D3DCLIPPLANE0 = (1 shl 0);
{$EXTERNALSYM D3DCLIPPLANE0}
D3DCLIPPLANE1 = (1 shl 1);
{$EXTERNALSYM D3DCLIPPLANE1}
D3DCLIPPLANE2 = (1 shl 2);
{$EXTERNALSYM D3DCLIPPLANE2}
D3DCLIPPLANE3 = (1 shl 3);
{$EXTERNALSYM D3DCLIPPLANE3}
D3DCLIPPLANE4 = (1 shl 4);
{$EXTERNALSYM D3DCLIPPLANE4}
D3DCLIPPLANE5 = (1 shl 5);
{$EXTERNALSYM D3DCLIPPLANE5}
// The following bits are used in the ClipUnion and ClipIntersection
// members of the D3DCLIPSTATUS9
//
D3DCS_LEFT = $00000001;
{$EXTERNALSYM D3DCS_LEFT}
D3DCS_RIGHT = $00000002;
{$EXTERNALSYM D3DCS_RIGHT}
D3DCS_TOP = $00000004;
{$EXTERNALSYM D3DCS_TOP}
D3DCS_BOTTOM = $00000008;
{$EXTERNALSYM D3DCS_BOTTOM}
D3DCS_FRONT = $00000010;
{$EXTERNALSYM D3DCS_FRONT}
D3DCS_BACK = $00000020;
{$EXTERNALSYM D3DCS_BACK}
D3DCS_PLANE0 = $00000040;
{$EXTERNALSYM D3DCS_PLANE0}
D3DCS_PLANE1 = $00000080;
{$EXTERNALSYM D3DCS_PLANE1}
D3DCS_PLANE2 = $00000100;
{$EXTERNALSYM D3DCS_PLANE2}
D3DCS_PLANE3 = $00000200;
{$EXTERNALSYM D3DCS_PLANE3}
D3DCS_PLANE4 = $00000400;
{$EXTERNALSYM D3DCS_PLANE4}
D3DCS_PLANE5 = $00000800;
{$EXTERNALSYM D3DCS_PLANE5}
D3DCS_ALL = D3DCS_LEFT or
D3DCS_RIGHT or
D3DCS_TOP or
D3DCS_BOTTOM or
D3DCS_FRONT or
D3DCS_BACK or
D3DCS_PLANE0 or
D3DCS_PLANE1 or
D3DCS_PLANE2 or
D3DCS_PLANE3 or
D3DCS_PLANE4 or
D3DCS_PLANE5;
{$EXTERNALSYM D3DCS_ALL}
type
PD3DClipStatus9 = ^TD3DClipStatus9;
_D3DCLIPSTATUS9 = packed record
ClipUnion: DWord;
ClipIntersection: DWord;
end {_D3DCLIPSTATUS9};
{$EXTERNALSYM _D3DCLIPSTATUS9}
D3DCLIPSTATUS9 = _D3DCLIPSTATUS9;
{$EXTERNALSYM D3DCLIPSTATUS9}
TD3DClipStatus9 = _D3DCLIPSTATUS9;
PD3DMaterial9 = ^TD3DMaterial9;
_D3DMATERIAL9 = packed record
Diffuse: TD3DColorValue; { Diffuse color RGBA }
Ambient: TD3DColorValue; { Ambient color RGB }
Specular: TD3DColorValue; { Specular 'shininess' }
Emissive: TD3DColorValue; { Emissive color RGB }
Power: Single; { Sharpness if specular highlight }
end {_D3DMATERIAL9};
{$EXTERNALSYM _D3DMATERIAL9}
D3DMATERIAL9 = _D3DMATERIAL9;
{$EXTERNALSYM D3DMATERIAL9}
TD3DMaterial9 = _D3DMATERIAL9;
_D3DLIGHTTYPE = (
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DLIGHT_INVALID_0, {= 0}
D3DLIGHT_POINT, {= 1}
D3DLIGHT_SPOT, {= 2}
D3DLIGHT_DIRECTIONAL{= 3}
{$ELSE}
D3DLIGHT_POINT = 1,
D3DLIGHT_SPOT = 2,
D3DLIGHT_DIRECTIONAL = 3
{$ENDIF}
);
{$EXTERNALSYM _D3DLIGHTTYPE}
D3DLIGHTTYPE = _D3DLIGHTTYPE;
{$EXTERNALSYM D3DLIGHTTYPE}
TD3DLightType = _D3DLIGHTTYPE;
PD3DLight9 = ^TD3DLight9;
_D3DLIGHT9 = packed record
_Type: TD3DLightType; { Type of light source }
Diffuse: TD3DColorValue; { Diffuse color of light }
Specular: TD3DColorValue; { Specular color of light }
Ambient: TD3DColorValue; { Ambient color of light }
Position: TD3DVector; { Position in world space }
Direction: TD3DVector; { Direction in world space }
Range: Single; { Cutoff range }
Falloff: Single; { Falloff }
Attenuation0: Single; { Constant attenuation }
Attenuation1: Single; { Linear attenuation }
Attenuation2: Single; { Quadratic attenuation }
Theta: Single; { Inner angle of spotlight cone }
Phi: Single; { Outer angle of spotlight cone }
end {_D3DLIGHT9};
{$EXTERNALSYM _D3DLIGHT9}
D3DLIGHT9 = _D3DLIGHT9;
{$EXTERNALSYM D3DLIGHT9}
TD3DLight9 = _D3DLIGHT9;
(*
* Options for clearing
*)
const
D3DCLEAR_TARGET = $00000001; { Clear target surface }
{$EXTERNALSYM D3DCLEAR_TARGET}
D3DCLEAR_ZBUFFER = $00000002; { Clear target z buffer }
{$EXTERNALSYM D3DCLEAR_ZBUFFER}
D3DCLEAR_STENCIL = $00000004; { Clear stencil planes }
{$EXTERNALSYM D3DCLEAR_STENCIL}
(*
* The following defines the rendering states
*)
type
_D3DSHADEMODE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DSHADEMODE}
D3DSHADEMODE = _D3DSHADEMODE;
{$EXTERNALSYM D3DSHADEMODE}
TD3DShadeMode = _D3DSHADEMODE;
const
D3DSHADE_FLAT = 1;
{$EXTERNALSYM D3DSHADE_FLAT}
D3DSHADE_GOURAUD = 2;
{$EXTERNALSYM D3DSHADE_GOURAUD}
D3DSHADE_PHONG = 3;
{$EXTERNALSYM D3DSHADE_PHONG}
type
_D3DFILLMODE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DFILLMODE}
D3DFILLMODE = _D3DFILLMODE;
{$EXTERNALSYM D3DFILLMODE}
TD3DFillMode = _D3DFILLMODE;
const
D3DFILL_POINT = 1;
{$EXTERNALSYM D3DFILL_POINT}
D3DFILL_WIREFRAME = 2;
{$EXTERNALSYM D3DFILL_WIREFRAME}
D3DFILL_SOLID = 3;
{$EXTERNALSYM D3DFILL_SOLID}
type
_D3DBLEND = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DBLEND}
D3DBLEND = _D3DBLEND;
{$EXTERNALSYM D3DBLEND}
TD3DBlend = _D3DBLEND;
const
D3DBLEND_ZERO = 1;
{$EXTERNALSYM D3DBLEND_ZERO}
D3DBLEND_ONE = 2;
{$EXTERNALSYM D3DBLEND_ONE}
D3DBLEND_SRCCOLOR = 3;
{$EXTERNALSYM D3DBLEND_SRCCOLOR}
D3DBLEND_INVSRCCOLOR = 4;
{$EXTERNALSYM D3DBLEND_INVSRCCOLOR}
D3DBLEND_SRCALPHA = 5;
{$EXTERNALSYM D3DBLEND_SRCALPHA}
D3DBLEND_INVSRCALPHA = 6;
{$EXTERNALSYM D3DBLEND_INVSRCALPHA}
D3DBLEND_DESTALPHA = 7;
{$EXTERNALSYM D3DBLEND_DESTALPHA}
D3DBLEND_INVDESTALPHA = 8;
{$EXTERNALSYM D3DBLEND_INVDESTALPHA}
D3DBLEND_DESTCOLOR = 9;
{$EXTERNALSYM D3DBLEND_DESTCOLOR}
D3DBLEND_INVDESTCOLOR = 10;
{$EXTERNALSYM D3DBLEND_INVDESTCOLOR}
D3DBLEND_SRCALPHASAT = 11;
{$EXTERNALSYM D3DBLEND_SRCALPHASAT}
D3DBLEND_BOTHSRCALPHA = 12;
{$EXTERNALSYM D3DBLEND_BOTHSRCALPHA}
D3DBLEND_BOTHINVSRCALPHA = 13;
{$EXTERNALSYM D3DBLEND_BOTHINVSRCALPHA}
D3DBLEND_BLENDFACTOR = 14; (* Only supported if D3DPBLENDCAPS_BLENDFACTOR is on *)
{$EXTERNALSYM D3DBLEND_BLENDFACTOR}
D3DBLEND_INVBLENDFACTOR = 15; (* Only supported if D3DPBLENDCAPS_BLENDFACTOR is on *)
{$EXTERNALSYM D3DBLEND_INVBLENDFACTOR}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
D3DBLEND_SRCCOLOR2 = 16;
{$EXTERNALSYM D3DBLEND_SRCCOLOR2}
D3DBLEND_INVSRCCOLOR2 = 17;
{$EXTERNALSYM D3DBLEND_INVSRCCOLOR2}
{$ENDIF}
type
_D3DBLENDOP = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DBLENDOP}
D3DBLENDOP = _D3DBLENDOP;
{$EXTERNALSYM D3DBLENDOP}
TD3DBlendOp = _D3DBLENDOP;
const
D3DBLENDOP_ADD = 1;
{$EXTERNALSYM D3DBLENDOP_ADD}
D3DBLENDOP_SUBTRACT = 2;
{$EXTERNALSYM D3DBLENDOP_SUBTRACT}
D3DBLENDOP_REVSUBTRACT = 3;
{$EXTERNALSYM D3DBLENDOP_REVSUBTRACT}
D3DBLENDOP_MIN = 4;
{$EXTERNALSYM D3DBLENDOP_MIN}
D3DBLENDOP_MAX = 5;
{$EXTERNALSYM D3DBLENDOP_MAX}
type
_D3DTEXTUREADDRESS = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DTEXTUREADDRESS}
D3DTEXTUREADDRESS = _D3DTEXTUREADDRESS;
{$EXTERNALSYM D3DTEXTUREADDRESS}
TD3DTextureAddress = _D3DTEXTUREADDRESS;
const
D3DTADDRESS_WRAP = 1;
{$EXTERNALSYM D3DTADDRESS_WRAP}
D3DTADDRESS_MIRROR = 2;
{$EXTERNALSYM D3DTADDRESS_MIRROR}
D3DTADDRESS_CLAMP = 3;
{$EXTERNALSYM D3DTADDRESS_CLAMP}
D3DTADDRESS_BORDER = 4;
{$EXTERNALSYM D3DTADDRESS_BORDER}
D3DTADDRESS_MIRRORONCE = 5;
{$EXTERNALSYM D3DTADDRESS_MIRRORONCE}
type
_D3DCULL = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DCULL}
D3DCULL = _D3DCULL;
{$EXTERNALSYM D3DCULL}
TD3DCull = _D3DCULL;
const
D3DCULL_NONE = 1;
{$EXTERNALSYM D3DCULL_NONE}
D3DCULL_CW = 2;
{$EXTERNALSYM D3DCULL_CW}
D3DCULL_CCW = 3;
{$EXTERNALSYM D3DCULL_CCW}
type
_D3DCMPFUNC = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DCMPFUNC}
D3DCMPFUNC = _D3DCMPFUNC;
{$EXTERNALSYM D3DCMPFUNC}
TD3DCmpFunc = _D3DCMPFUNC;
const
D3DCMP_NEVER = 1;
{$EXTERNALSYM D3DCMP_NEVER}
D3DCMP_LESS = 2;
{$EXTERNALSYM D3DCMP_LESS}
D3DCMP_EQUAL = 3;
{$EXTERNALSYM D3DCMP_EQUAL}
D3DCMP_LESSEQUAL = 4;
{$EXTERNALSYM D3DCMP_LESSEQUAL}
D3DCMP_GREATER = 5;
{$EXTERNALSYM D3DCMP_GREATER}
D3DCMP_NOTEQUAL = 6;
{$EXTERNALSYM D3DCMP_NOTEQUAL}
D3DCMP_GREATEREQUAL = 7;
{$EXTERNALSYM D3DCMP_GREATEREQUAL}
D3DCMP_ALWAYS = 8;
{$EXTERNALSYM D3DCMP_ALWAYS}
type
_D3DSTENCILOP = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DSTENCILOP}
D3DSTENCILOP = _D3DSTENCILOP;
{$EXTERNALSYM D3DSTENCILOP}
TD3DStencilOp = _D3DSTENCILOP;
const
D3DSTENCILOP_KEEP = 1;
{$EXTERNALSYM D3DSTENCILOP_KEEP}
D3DSTENCILOP_ZERO = 2;
{$EXTERNALSYM D3DSTENCILOP_ZERO}
D3DSTENCILOP_REPLACE = 3;
{$EXTERNALSYM D3DSTENCILOP_REPLACE}
D3DSTENCILOP_INCRSAT = 4;
{$EXTERNALSYM D3DSTENCILOP_INCRSAT}
D3DSTENCILOP_DECRSAT = 5;
{$EXTERNALSYM D3DSTENCILOP_DECRSAT}
D3DSTENCILOP_INVERT = 6;
{$EXTERNALSYM D3DSTENCILOP_INVERT}
D3DSTENCILOP_INCR = 7;
{$EXTERNALSYM D3DSTENCILOP_INCR}
D3DSTENCILOP_DECR = 8;
{$EXTERNALSYM D3DSTENCILOP_DECR}
type
_D3DFOGMODE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DFOGMODE}
D3DFOGMODE = _D3DFOGMODE;
{$EXTERNALSYM D3DFOGMODE}
TD3DFogMode = _D3DFOGMODE;
const
D3DFOG_NONE = 0;
{$EXTERNALSYM D3DFOG_NONE}
D3DFOG_EXP = 1;
{$EXTERNALSYM D3DFOG_EXP}
D3DFOG_EXP2 = 2;
{$EXTERNALSYM D3DFOG_EXP2}
D3DFOG_LINEAR = 3;
{$EXTERNALSYM D3DFOG_LINEAR}
type
_D3DZBUFFERTYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DZBUFFERTYPE}
D3DZBUFFERTYPE = _D3DZBUFFERTYPE;
{$EXTERNALSYM D3DZBUFFERTYPE}
TD3DZBufferType = _D3DZBUFFERTYPE;
const
D3DZB_FALSE = 0;
{$EXTERNALSYM D3DZB_FALSE}
D3DZB_TRUE = 1;
{$EXTERNALSYM D3DZB_TRUE}
D3DZB_USEW = 2;
{$EXTERNALSYM D3DZB_USEW}
type
// Primitives supported by draw-primitive API
_D3DPRIMITIVETYPE = (
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DPT_INVALID_0 {= 0},
D3DPT_POINTLIST {= 1},
D3DPT_LINELIST {= 2},
D3DPT_LINESTRIP {= 3},
D3DPT_TRIANGLELIST {= 4},
D3DPT_TRIANGLESTRIP{= 5},
D3DPT_TRIANGLEFAN {= 6}
{$ELSE}
D3DPT_POINTLIST = 1,
D3DPT_LINELIST = 2,
D3DPT_LINESTRIP = 3,
D3DPT_TRIANGLELIST = 4,
D3DPT_TRIANGLESTRIP = 5,
D3DPT_TRIANGLEFAN = 6
{$ENDIF}
);
{$EXTERNALSYM _D3DPRIMITIVETYPE}
D3DPRIMITIVETYPE = _D3DPRIMITIVETYPE;
{$EXTERNALSYM D3DPRIMITIVETYPE}
TD3DPrimitiveType = _D3DPRIMITIVETYPE;
{$IFNDEF SUPPORTS_EXPL_ENUMS}
const
D3DTS_VIEW = 2;
{$EXTERNALSYM D3DTS_VIEW}
D3DTS_PROJECTION = 3;
{$EXTERNALSYM D3DTS_PROJECTION}
D3DTS_TEXTURE0 = 16;
{$EXTERNALSYM D3DTS_TEXTURE0}
D3DTS_TEXTURE1 = 17;
{$EXTERNALSYM D3DTS_TEXTURE1}
D3DTS_TEXTURE2 = 18;
{$EXTERNALSYM D3DTS_TEXTURE2}
D3DTS_TEXTURE3 = 19;
{$EXTERNALSYM D3DTS_TEXTURE3}
D3DTS_TEXTURE4 = 20;
{$EXTERNALSYM D3DTS_TEXTURE4}
D3DTS_TEXTURE5 = 21;
{$EXTERNALSYM D3DTS_TEXTURE5}
D3DTS_TEXTURE6 = 22;
{$EXTERNALSYM D3DTS_TEXTURE6}
D3DTS_TEXTURE7 = 23;
{$EXTERNALSYM D3DTS_TEXTURE7}
D3DTS_FORCE_DWORD = $7fffffff; (* force 32-bit size enum *)
{$EXTERNALSYM D3DTS_FORCE_DWORD}
type
_D3DTRANSFORMSTATETYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$ELSE}
type
_D3DTRANSFORMSTATETYPE = (
D3DTS_VIEW = 2,
D3DTS_PROJECTION = 3,
D3DTS_TEXTURE0 = 16,
D3DTS_TEXTURE1 = 17,
D3DTS_TEXTURE2 = 18,
D3DTS_TEXTURE3 = 19,
D3DTS_TEXTURE4 = 20,
D3DTS_TEXTURE5 = 21,
D3DTS_TEXTURE6 = 22,
D3DTS_TEXTURE7 = 23
);
{$ENDIF}
{$EXTERNALSYM _D3DTRANSFORMSTATETYPE}
D3DTRANSFORMSTATETYPE = _D3DTRANSFORMSTATETYPE;
{$EXTERNALSYM D3DTRANSFORMSTATETYPE}
TD3DTransformStateType = _D3DTRANSFORMSTATETYPE;
// #define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256)
function D3DTS_WORLDMATRIX(index: Byte): TD3DTransformStateType;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DTS_WORLDMATRIX}
const
D3DTS_WORLD = TD3DTransformStateType(0 + 256); // #define D3DTS_WORLD D3DTS_WORLDMATRIX(0)
{$EXTERNALSYM D3DTS_WORLD}
D3DTS_WORLD1 = TD3DTransformStateType(1 + 256); // #define D3DTS_WORLD1 D3DTS_WORLDMATRIX(1)
{$EXTERNALSYM D3DTS_WORLD1}
D3DTS_WORLD2 = TD3DTransformStateType(2 + 256); // #define D3DTS_WORLD2 D3DTS_WORLDMATRIX(2)
{$EXTERNALSYM D3DTS_WORLD2}
D3DTS_WORLD3 = TD3DTransformStateType(3 + 256); // #define D3DTS_WORLD3 D3DTS_WORLDMATRIX(3)
{$EXTERNALSYM D3DTS_WORLD3}
{$IFNDEF SUPPORTS_EXPL_ENUMS}
type
_D3DRENDERSTATETYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DRENDERSTATETYPE}
D3DRENDERSTATETYPE = _D3DRENDERSTATETYPE;
{$EXTERNALSYM D3DRENDERSTATETYPE}
TD3DRenderStateType = _D3DRENDERSTATETYPE;
const
D3DRS_ZENABLE = TD3DRenderStateType(7); { D3DZBUFFERTYPE (or TRUE/FALSE for legacy) }
{$EXTERNALSYM D3DRS_ZENABLE}
D3DRS_FILLMODE = TD3DRenderStateType(8); { D3DFILLMODE }
{$EXTERNALSYM D3DRS_FILLMODE}
D3DRS_SHADEMODE = TD3DRenderStateType(9); { D3DSHADEMODE }
{$EXTERNALSYM D3DRS_SHADEMODE}
D3DRS_ZWRITEENABLE = TD3DRenderStateType(14); { TRUE to enable z writes }
{$EXTERNALSYM D3DRS_ZWRITEENABLE}
D3DRS_ALPHATESTENABLE = TD3DRenderStateType(15); { TRUE to enable alpha tests }
{$EXTERNALSYM D3DRS_ALPHATESTENABLE}
D3DRS_LASTPIXEL = TD3DRenderStateType(16); { TRUE for last-pixel on lines }
{$EXTERNALSYM D3DRS_LASTPIXEL}
D3DRS_SRCBLEND = TD3DRenderStateType(19); { D3DBLEND }
{$EXTERNALSYM D3DRS_SRCBLEND}
D3DRS_DESTBLEND = TD3DRenderStateType(20); { D3DBLEND }
{$EXTERNALSYM D3DRS_DESTBLEND}
D3DRS_CULLMODE = TD3DRenderStateType(22); { D3DCULL }
{$EXTERNALSYM D3DRS_CULLMODE}
D3DRS_ZFUNC = TD3DRenderStateType(23); { D3DCMPFUNC }
{$EXTERNALSYM D3DRS_ZFUNC}
D3DRS_ALPHAREF = TD3DRenderStateType(24); { D3DFIXED }
{$EXTERNALSYM D3DRS_ALPHAREF}
D3DRS_ALPHAFUNC = TD3DRenderStateType(25); { D3DCMPFUNC }
{$EXTERNALSYM D3DRS_ALPHAFUNC}
D3DRS_DITHERENABLE = TD3DRenderStateType(26); { TRUE to enable dithering }
{$EXTERNALSYM D3DRS_DITHERENABLE}
D3DRS_ALPHABLENDENABLE = TD3DRenderStateType(27); { TRUE to enable alpha blending }
{$EXTERNALSYM D3DRS_ALPHABLENDENABLE}
D3DRS_FOGENABLE = TD3DRenderStateType(28); { TRUE to enable fog blending }
{$EXTERNALSYM D3DRS_FOGENABLE}
D3DRS_SPECULARENABLE = TD3DRenderStateType(29); { TRUE to enable specular }
{$EXTERNALSYM D3DRS_SPECULARENABLE}
D3DRS_FOGCOLOR = TD3DRenderStateType(34); { D3DCOLOR }
{$EXTERNALSYM D3DRS_FOGCOLOR}
D3DRS_FOGTABLEMODE = TD3DRenderStateType(35); { D3DFOGMODE }
{$EXTERNALSYM D3DRS_FOGTABLEMODE}
D3DRS_FOGSTART = TD3DRenderStateType(36); { Fog start (for both vertex and pixel fog) }
{$EXTERNALSYM D3DRS_FOGSTART}
D3DRS_FOGEND = TD3DRenderStateType(37); { Fog end }
{$EXTERNALSYM D3DRS_FOGEND}
D3DRS_FOGDENSITY = TD3DRenderStateType(38); { Fog density }
{$EXTERNALSYM D3DRS_FOGDENSITY}
D3DRS_RANGEFOGENABLE = TD3DRenderStateType(48); { Enables range-based fog }
{$EXTERNALSYM D3DRS_RANGEFOGENABLE}
D3DRS_STENCILENABLE = TD3DRenderStateType(52); { BOOL enable/disable stenciling }
{$EXTERNALSYM D3DRS_STENCILENABLE}
D3DRS_STENCILFAIL = TD3DRenderStateType(53); { D3DSTENCILOP to do if stencil test fails }
{$EXTERNALSYM D3DRS_STENCILFAIL}
D3DRS_STENCILZFAIL = TD3DRenderStateType(54); { D3DSTENCILOP to do if stencil test passes and Z test fails }
{$EXTERNALSYM D3DRS_STENCILZFAIL}
D3DRS_STENCILPASS = TD3DRenderStateType(55); { D3DSTENCILOP to do if both stencil and Z tests pass }
{$EXTERNALSYM D3DRS_STENCILPASS}
D3DRS_STENCILFUNC = TD3DRenderStateType(56); { D3DCMPFUNC fn. Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true }
{$EXTERNALSYM D3DRS_STENCILFUNC}
D3DRS_STENCILREF = TD3DRenderStateType(57); { Reference value used in stencil test }
{$EXTERNALSYM D3DRS_STENCILREF}
D3DRS_STENCILMASK = TD3DRenderStateType(58); { Mask value used in stencil test }
{$EXTERNALSYM D3DRS_STENCILMASK}
D3DRS_STENCILWRITEMASK = TD3DRenderStateType(59); { Write mask applied to values written to stencil buffer }
{$EXTERNALSYM D3DRS_STENCILWRITEMASK}
D3DRS_TEXTUREFACTOR = TD3DRenderStateType(60); { D3DCOLOR used for multi-texture blend }
{$EXTERNALSYM D3DRS_TEXTUREFACTOR}
D3DRS_WRAP0 = TD3DRenderStateType(128); { wrap for 1st texture coord. set }
{$EXTERNALSYM D3DRS_WRAP0}
D3DRS_WRAP1 = TD3DRenderStateType(129); { wrap for 2nd texture coord. set }
{$EXTERNALSYM D3DRS_WRAP1}
D3DRS_WRAP2 = TD3DRenderStateType(130); { wrap for 3rd texture coord. set }
{$EXTERNALSYM D3DRS_WRAP2}
D3DRS_WRAP3 = TD3DRenderStateType(131); { wrap for 4th texture coord. set }
{$EXTERNALSYM D3DRS_WRAP3}
D3DRS_WRAP4 = TD3DRenderStateType(132); { wrap for 5th texture coord. set }
{$EXTERNALSYM D3DRS_WRAP4}
D3DRS_WRAP5 = TD3DRenderStateType(133); { wrap for 6th texture coord. set }
{$EXTERNALSYM D3DRS_WRAP5}
D3DRS_WRAP6 = TD3DRenderStateType(134); { wrap for 7th texture coord. set }
{$EXTERNALSYM D3DRS_WRAP6}
D3DRS_WRAP7 = TD3DRenderStateType(135); { wrap for 8th texture coord. set }
{$EXTERNALSYM D3DRS_WRAP7}
D3DRS_CLIPPING = TD3DRenderStateType(136);
{$EXTERNALSYM D3DRS_CLIPPING}
D3DRS_LIGHTING = TD3DRenderStateType(137);
{$EXTERNALSYM D3DRS_LIGHTING}
D3DRS_AMBIENT = TD3DRenderStateType(139);
{$EXTERNALSYM D3DRS_AMBIENT}
D3DRS_FOGVERTEXMODE = TD3DRenderStateType(140);
{$EXTERNALSYM D3DRS_FOGVERTEXMODE}
D3DRS_COLORVERTEX = TD3DRenderStateType(141);
{$EXTERNALSYM D3DRS_COLORVERTEX}
D3DRS_LOCALVIEWER = TD3DRenderStateType(142);
{$EXTERNALSYM D3DRS_LOCALVIEWER}
D3DRS_NORMALIZENORMALS = TD3DRenderStateType(143);
{$EXTERNALSYM D3DRS_NORMALIZENORMALS}
D3DRS_DIFFUSEMATERIALSOURCE = TD3DRenderStateType(145);
{$EXTERNALSYM D3DRS_DIFFUSEMATERIALSOURCE}
D3DRS_SPECULARMATERIALSOURCE = TD3DRenderStateType(146);
{$EXTERNALSYM D3DRS_SPECULARMATERIALSOURCE}
D3DRS_AMBIENTMATERIALSOURCE = TD3DRenderStateType(147);
{$EXTERNALSYM D3DRS_AMBIENTMATERIALSOURCE}
D3DRS_EMISSIVEMATERIALSOURCE = TD3DRenderStateType(148);
{$EXTERNALSYM D3DRS_EMISSIVEMATERIALSOURCE}
D3DRS_VERTEXBLEND = TD3DRenderStateType(151);
{$EXTERNALSYM D3DRS_VERTEXBLEND}
D3DRS_CLIPPLANEENABLE = TD3DRenderStateType(152);
{$EXTERNALSYM D3DRS_CLIPPLANEENABLE}
D3DRS_POINTSIZE = TD3DRenderStateType(154); { float point size }
{$EXTERNALSYM D3DRS_POINTSIZE}
D3DRS_POINTSIZE_MIN = TD3DRenderStateType(155); { float point size min threshold }
{$EXTERNALSYM D3DRS_POINTSIZE_MIN}
D3DRS_POINTSPRITEENABLE = TD3DRenderStateType(156); { BOOL point texture coord control }
{$EXTERNALSYM D3DRS_POINTSPRITEENABLE}
D3DRS_POINTSCALEENABLE = TD3DRenderStateType(157); { BOOL point size scale enable }
{$EXTERNALSYM D3DRS_POINTSCALEENABLE}
D3DRS_POINTSCALE_A = TD3DRenderStateType(158); { float point attenuation A value }
{$EXTERNALSYM D3DRS_POINTSCALE_A}
D3DRS_POINTSCALE_B = TD3DRenderStateType(159); { float point attenuation B value }
{$EXTERNALSYM D3DRS_POINTSCALE_B}
D3DRS_POINTSCALE_C = TD3DRenderStateType(160); { float point attenuation C value }
{$EXTERNALSYM D3DRS_POINTSCALE_C}
D3DRS_MULTISAMPLEANTIALIAS = TD3DRenderStateType(161); // BOOL - set to do FSAA with multisample buffer
{$EXTERNALSYM D3DRS_MULTISAMPLEANTIALIAS}
D3DRS_MULTISAMPLEMASK = TD3DRenderStateType(162); // DWORD - per-sample enable/disable
{$EXTERNALSYM D3DRS_MULTISAMPLEMASK}
D3DRS_PATCHEDGESTYLE = TD3DRenderStateType(163); // Sets whether patch edges will use float style tessellation
{$EXTERNALSYM D3DRS_PATCHEDGESTYLE}
D3DRS_DEBUGMONITORTOKEN = TD3DRenderStateType(165); // DEBUG ONLY - token to debug monitor
{$EXTERNALSYM D3DRS_DEBUGMONITORTOKEN}
D3DRS_POINTSIZE_MAX = TD3DRenderStateType(166); { float point size max threshold }
{$EXTERNALSYM D3DRS_POINTSIZE_MAX}
D3DRS_INDEXEDVERTEXBLENDENABLE = TD3DRenderStateType(167);
{$EXTERNALSYM D3DRS_INDEXEDVERTEXBLENDENABLE}
D3DRS_COLORWRITEENABLE = TD3DRenderStateType(168); // per-channel write enable
{$EXTERNALSYM D3DRS_COLORWRITEENABLE}
D3DRS_TWEENFACTOR = TD3DRenderStateType(170); // float tween factor
{$EXTERNALSYM D3DRS_TWEENFACTOR}
D3DRS_BLENDOP = TD3DRenderStateType(171); // D3DBLENDOP setting
{$EXTERNALSYM D3DRS_BLENDOP}
D3DRS_POSITIONDEGREE = TD3DRenderStateType(172); // NPatch position interpolation degree. D3DDEGREE_LINEAR or D3DDEGREE_CUBIC (default)
{$EXTERNALSYM D3DRS_POSITIONDEGREE}
D3DRS_NORMALDEGREE = TD3DRenderStateType(173); // NPatch normal interpolation degree. D3DDEGREE_LINEAR (default) or D3DDEGREE_QUADRATIC
{$EXTERNALSYM D3DRS_NORMALDEGREE}
D3DRS_SCISSORTESTENABLE = TD3DRenderStateType(174);
{$EXTERNALSYM D3DRS_SCISSORTESTENABLE}
D3DRS_SLOPESCALEDEPTHBIAS = TD3DRenderStateType(175);
{$EXTERNALSYM D3DRS_SLOPESCALEDEPTHBIAS}
D3DRS_ANTIALIASEDLINEENABLE = TD3DRenderStateType(176);
{$EXTERNALSYM D3DRS_ANTIALIASEDLINEENABLE}
D3DRS_MINTESSELLATIONLEVEL = TD3DRenderStateType(178);
{$EXTERNALSYM D3DRS_MINTESSELLATIONLEVEL}
D3DRS_MAXTESSELLATIONLEVEL = TD3DRenderStateType(179);
{$EXTERNALSYM D3DRS_MAXTESSELLATIONLEVEL}
D3DRS_ADAPTIVETESS_X = TD3DRenderStateType(180);
{$EXTERNALSYM D3DRS_ADAPTIVETESS_X}
D3DRS_ADAPTIVETESS_Y = TD3DRenderStateType(181);
{$EXTERNALSYM D3DRS_ADAPTIVETESS_Y}
D3DRS_ADAPTIVETESS_Z = TD3DRenderStateType(182);
{$EXTERNALSYM D3DRS_ADAPTIVETESS_Z}
D3DRS_ADAPTIVETESS_W = TD3DRenderStateType(183);
{$EXTERNALSYM D3DRS_ADAPTIVETESS_W}
D3DRS_ENABLEADAPTIVETESSELLATION = TD3DRenderStateType(184);
{$EXTERNALSYM D3DRS_ENABLEADAPTIVETESSELLATION}
D3DRS_TWOSIDEDSTENCILMODE = TD3DRenderStateType(185); (* BOOL enable/disable 2 sided stenciling *)
{$EXTERNALSYM D3DRS_TWOSIDEDSTENCILMODE}
D3DRS_CCW_STENCILFAIL = TD3DRenderStateType(186); (* D3DSTENCILOP to do if ccw stencil test fails *)
{$EXTERNALSYM D3DRS_CCW_STENCILFAIL}
D3DRS_CCW_STENCILZFAIL = TD3DRenderStateType(187); (* D3DSTENCILOP to do if ccw stencil test passes and Z test fails *)
{$EXTERNALSYM D3DRS_CCW_STENCILZFAIL}
D3DRS_CCW_STENCILPASS = TD3DRenderStateType(188); (* D3DSTENCILOP to do if both ccw stencil and Z tests pass *)
{$EXTERNALSYM D3DRS_CCW_STENCILPASS}
D3DRS_CCW_STENCILFUNC = TD3DRenderStateType(189); (* D3DCMPFUNC fn. ccw Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true *)
{$EXTERNALSYM D3DRS_CCW_STENCILFUNC}
D3DRS_COLORWRITEENABLE1 = TD3DRenderStateType(190); (* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS *)
{$EXTERNALSYM D3DRS_COLORWRITEENABLE1}
D3DRS_COLORWRITEENABLE2 = TD3DRenderStateType(191); (* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS *)
{$EXTERNALSYM D3DRS_COLORWRITEENABLE2}
D3DRS_COLORWRITEENABLE3 = TD3DRenderStateType(192); (* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS *)
{$EXTERNALSYM D3DRS_COLORWRITEENABLE3}
D3DRS_BLENDFACTOR = TD3DRenderStateType(193); (* D3DCOLOR used for a constant blend factor during alpha blending for devices that support D3DPBLENDCAPS_BLENDFACTOR *)
{$EXTERNALSYM D3DRS_BLENDFACTOR}
D3DRS_SRGBWRITEENABLE = TD3DRenderStateType(194); (* Enable rendertarget writes to be DE-linearized to SRGB (for formats that expose D3DUSAGE_QUERY_SRGBWRITE) *)
{$EXTERNALSYM D3DRS_SRGBWRITEENABLE}
D3DRS_DEPTHBIAS = TD3DRenderStateType(195);
{$EXTERNALSYM D3DRS_DEPTHBIAS}
D3DRS_WRAP8 = TD3DRenderStateType(198); (* Additional wrap states for vs_3_0+ attributes with D3DDECLUSAGE_TEXCOORD *)
{$EXTERNALSYM D3DRS_WRAP8}
D3DRS_WRAP9 = TD3DRenderStateType(199);
{$EXTERNALSYM D3DRS_WRAP9}
D3DRS_WRAP10 = TD3DRenderStateType(200);
{$EXTERNALSYM D3DRS_WRAP10}
D3DRS_WRAP11 = TD3DRenderStateType(201);
{$EXTERNALSYM D3DRS_WRAP11}
D3DRS_WRAP12 = TD3DRenderStateType(202);
{$EXTERNALSYM D3DRS_WRAP12}
D3DRS_WRAP13 = TD3DRenderStateType(203);
{$EXTERNALSYM D3DRS_WRAP13}
D3DRS_WRAP14 = TD3DRenderStateType(204);
{$EXTERNALSYM D3DRS_WRAP14}
D3DRS_WRAP15 = TD3DRenderStateType(205);
{$EXTERNALSYM D3DRS_WRAP15}
D3DRS_SEPARATEALPHABLENDENABLE = TD3DRenderStateType(206); (* TRUE to enable a separate blending function for the alpha channel *)
{$EXTERNALSYM D3DRS_SEPARATEALPHABLENDENABLE}
D3DRS_SRCBLENDALPHA = TD3DRenderStateType(207); (* SRC blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE *)
{$EXTERNALSYM D3DRS_SRCBLENDALPHA}
D3DRS_DESTBLENDALPHA = TD3DRenderStateType(208); (* DST blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE *)
{$EXTERNALSYM D3DRS_DESTBLENDALPHA}
D3DRS_BLENDOPALPHA = TD3DRenderStateType(209); (* Blending operation for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE *)
{$EXTERNALSYM D3DRS_BLENDOPALPHA}
D3DRS_FORCE_DWORD = TD3DRenderStateType($7fffffff); { force 32-bit size enum }
{$EXTERNALSYM D3DRS_FORCE_DWORD}
{$ELSE}
type
_D3DRENDERSTATETYPE = (
D3DRS_ZENABLE = 7, (* D3DZBUFFERTYPE (or TRUE/FALSE for legacy) *)
D3DRS_FILLMODE = 8, (* D3DFILLMODE *)
D3DRS_SHADEMODE = 9, (* D3DSHADEMODE *)
D3DRS_ZWRITEENABLE = 14, (* TRUE to enable z writes *)
D3DRS_ALPHATESTENABLE = 15, (* TRUE to enable alpha tests *)
D3DRS_LASTPIXEL = 16, (* TRUE for last-pixel on lines *)
D3DRS_SRCBLEND = 19, (* D3DBLEND *)
D3DRS_DESTBLEND = 20, (* D3DBLEND *)
D3DRS_CULLMODE = 22, (* D3DCULL *)
D3DRS_ZFUNC = 23, (* D3DCMPFUNC *)
D3DRS_ALPHAREF = 24, (* D3DFIXED *)
D3DRS_ALPHAFUNC = 25, (* D3DCMPFUNC *)
D3DRS_DITHERENABLE = 26, (* TRUE to enable dithering *)
D3DRS_ALPHABLENDENABLE = 27, (* TRUE to enable alpha blending *)
D3DRS_FOGENABLE = 28, (* TRUE to enable fog blending *)
D3DRS_SPECULARENABLE = 29, (* TRUE to enable specular *)
D3DRS_FOGCOLOR = 34, (* D3DCOLOR *)
D3DRS_FOGTABLEMODE = 35, (* D3DFOGMODE *)
D3DRS_FOGSTART = 36, (* Fog start (for both vertex and pixel fog) *)
D3DRS_FOGEND = 37, (* Fog end *)
D3DRS_FOGDENSITY = 38, (* Fog density *)
D3DRS_RANGEFOGENABLE = 48, (* Enables range-based fog *)
D3DRS_STENCILENABLE = 52, (* BOOL enable/disable stenciling *)
D3DRS_STENCILFAIL = 53, (* D3DSTENCILOP to do if stencil test fails *)
D3DRS_STENCILZFAIL = 54, (* D3DSTENCILOP to do if stencil test passes and Z test fails *)
D3DRS_STENCILPASS = 55, (* D3DSTENCILOP to do if both stencil and Z tests pass *)
D3DRS_STENCILFUNC = 56, (* D3DCMPFUNC fn. Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true *)
D3DRS_STENCILREF = 57, (* Reference value used in stencil test *)
D3DRS_STENCILMASK = 58, (* Mask value used in stencil test *)
D3DRS_STENCILWRITEMASK = 59, (* Write mask applied to values written to stencil buffer *)
D3DRS_TEXTUREFACTOR = 60, (* D3DCOLOR used for multi-texture blend *)
D3DRS_WRAP0 = 128, (* wrap for 1st texture coord. set *)
D3DRS_WRAP1 = 129, (* wrap for 2nd texture coord. set *)
D3DRS_WRAP2 = 130, (* wrap for 3rd texture coord. set *)
D3DRS_WRAP3 = 131, (* wrap for 4th texture coord. set *)
D3DRS_WRAP4 = 132, (* wrap for 5th texture coord. set *)
D3DRS_WRAP5 = 133, (* wrap for 6th texture coord. set *)
D3DRS_WRAP6 = 134, (* wrap for 7th texture coord. set *)
D3DRS_WRAP7 = 135, (* wrap for 8th texture coord. set *)
D3DRS_CLIPPING = 136,
D3DRS_LIGHTING = 137,
D3DRS_AMBIENT = 139,
D3DRS_FOGVERTEXMODE = 140,
D3DRS_COLORVERTEX = 141,
D3DRS_LOCALVIEWER = 142,
D3DRS_NORMALIZENORMALS = 143,
D3DRS_DIFFUSEMATERIALSOURCE = 145,
D3DRS_SPECULARMATERIALSOURCE = 146,
D3DRS_AMBIENTMATERIALSOURCE = 147,
D3DRS_EMISSIVEMATERIALSOURCE = 148,
D3DRS_VERTEXBLEND = 151,
D3DRS_CLIPPLANEENABLE = 152,
D3DRS_POINTSIZE = 154, (* float point size *)
D3DRS_POINTSIZE_MIN = 155, (* float point size min threshold *)
D3DRS_POINTSPRITEENABLE = 156, (* BOOL point texture coord control *)
D3DRS_POINTSCALEENABLE = 157, (* BOOL point size scale enable *)
D3DRS_POINTSCALE_A = 158, (* float point attenuation A value *)
D3DRS_POINTSCALE_B = 159, (* float point attenuation B value *)
D3DRS_POINTSCALE_C = 160, (* float point attenuation C value *)
D3DRS_MULTISAMPLEANTIALIAS = 161, // BOOL - set to do FSAA with multisample buffer
D3DRS_MULTISAMPLEMASK = 162, // DWORD - per-sample enable/disable
D3DRS_PATCHEDGESTYLE = 163, // Sets whether patch edges will use float style tessellation
D3DRS_DEBUGMONITORTOKEN = 165, // DEBUG ONLY - token to debug monitor
D3DRS_POINTSIZE_MAX = 166, (* float point size max threshold *)
D3DRS_INDEXEDVERTEXBLENDENABLE = 167,
D3DRS_COLORWRITEENABLE = 168, // per-channel write enable
D3DRS_TWEENFACTOR = 170, // float tween factor
D3DRS_BLENDOP = 171, // D3DBLENDOP setting
D3DRS_POSITIONDEGREE = 172, // NPatch position interpolation degree. D3DDEGREE_LINEAR or D3DDEGREE_CUBIC (default)
D3DRS_NORMALDEGREE = 173, // NPatch normal interpolation degree. D3DDEGREE_LINEAR (default) or D3DDEGREE_QUADRATIC
D3DRS_SCISSORTESTENABLE = 174,
D3DRS_SLOPESCALEDEPTHBIAS = 175,
D3DRS_ANTIALIASEDLINEENABLE = 176,
D3DRS_MINTESSELLATIONLEVEL = 178,
D3DRS_MAXTESSELLATIONLEVEL = 179,
D3DRS_ADAPTIVETESS_X = 180,
D3DRS_ADAPTIVETESS_Y = 181,
D3DRS_ADAPTIVETESS_Z = 182,
D3DRS_ADAPTIVETESS_W = 183,
D3DRS_ENABLEADAPTIVETESSELLATION = 184,
D3DRS_TWOSIDEDSTENCILMODE = 185, (* BOOL enable/disable 2 sided stenciling *)
D3DRS_CCW_STENCILFAIL = 186, (* D3DSTENCILOP to do if ccw stencil test fails *)
D3DRS_CCW_STENCILZFAIL = 187, (* D3DSTENCILOP to do if ccw stencil test passes and Z test fails *)
D3DRS_CCW_STENCILPASS = 188, (* D3DSTENCILOP to do if both ccw stencil and Z tests pass *)
D3DRS_CCW_STENCILFUNC = 189, (* D3DCMPFUNC fn. ccw Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true *)
D3DRS_COLORWRITEENABLE1 = 190, (* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS *)
D3DRS_COLORWRITEENABLE2 = 191, (* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS *)
D3DRS_COLORWRITEENABLE3 = 192, (* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS *)
D3DRS_BLENDFACTOR = 193, (* D3DCOLOR used for a constant blend factor during alpha blending for devices that support D3DPBLENDCAPS_BLENDFACTOR *)
D3DRS_SRGBWRITEENABLE = 194, (* Enable rendertarget writes to be DE-linearized to SRGB (for formats that expose D3DUSAGE_QUERY_SRGBWRITE) *)
D3DRS_DEPTHBIAS = 195,
D3DRS_WRAP8 = 198, (* Additional wrap states for vs_3_0+ attributes with D3DDECLUSAGE_TEXCOORD *)
D3DRS_WRAP9 = 199,
D3DRS_WRAP10 = 200,
D3DRS_WRAP11 = 201,
D3DRS_WRAP12 = 202,
D3DRS_WRAP13 = 203,
D3DRS_WRAP14 = 204,
D3DRS_WRAP15 = 205,
D3DRS_SEPARATEALPHABLENDENABLE = 206, (* TRUE to enable a separate blending function for the alpha channel *)
D3DRS_SRCBLENDALPHA = 207, (* SRC blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE *)
D3DRS_DESTBLENDALPHA = 208, (* DST blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE *)
D3DRS_BLENDOPALPHA = 209 (* Blending operation for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE *)
);
{$EXTERNALSYM _D3DRENDERSTATETYPE}
D3DRENDERSTATETYPE = _D3DRENDERSTATETYPE;
{$EXTERNALSYM D3DRENDERSTATETYPE}
TD3DRenderStateType = _D3DRENDERSTATETYPE;
{$ENDIF}
const
// Maximum number of simultaneous render targets D3D supports
D3D_MAX_SIMULTANEOUS_RENDERTARGETS = 4;
{$EXTERNALSYM D3D_MAX_SIMULTANEOUS_RENDERTARGETS}
type
// Values for material source
_D3DMATERIALCOLORSOURCE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DMATERIALCOLORSOURCE}
D3DMATERIALCOLORSOURCE = _D3DMATERIALCOLORSOURCE;
{$EXTERNALSYM D3DMATERIALCOLORSOURCE}
TD3DMaterialSource = _D3DMATERIALCOLORSOURCE;
const
D3DMCS_MATERIAL = TD3DMaterialSource(0); // Color from material is used
{$EXTERNALSYM D3DMCS_MATERIAL}
D3DMCS_COLOR1 = TD3DMaterialSource(1); // Diffuse vertex color is used
{$EXTERNALSYM D3DMCS_COLOR1}
D3DMCS_COLOR2 = TD3DMaterialSource(2); // Specular vertex color is used
{$EXTERNALSYM D3DMCS_COLOR2}
D3DMCS_FORCE_DWORD = TD3DMaterialSource($7fffffff); // force 32-bit size enum
{$EXTERNALSYM D3DMCS_FORCE_DWORD}
// Bias to apply to the texture coordinate set to apply a wrap to.
D3DRENDERSTATE_WRAPBIAS = DWORD(128);
{$EXTERNALSYM D3DRENDERSTATE_WRAPBIAS}
{ Flags to construct the WRAP render states }
D3DWRAP_U = $00000001;
{$EXTERNALSYM D3DWRAP_U}
D3DWRAP_V = $00000002;
{$EXTERNALSYM D3DWRAP_V}
D3DWRAP_W = $00000004;
{$EXTERNALSYM D3DWRAP_W}
{ Flags to construct the WRAP render states for 1D thru 4D texture coordinates }
D3DWRAPCOORD_0 = $00000001; // same as D3DWRAP_U
{$EXTERNALSYM D3DWRAPCOORD_0}
D3DWRAPCOORD_1 = $00000002; // same as D3DWRAP_V
{$EXTERNALSYM D3DWRAPCOORD_1}
D3DWRAPCOORD_2 = $00000004; // same as D3DWRAP_W
{$EXTERNALSYM D3DWRAPCOORD_2}
D3DWRAPCOORD_3 = $00000008;
{$EXTERNALSYM D3DWRAPCOORD_3}
{ Flags to construct D3DRS_COLORWRITEENABLE }
D3DCOLORWRITEENABLE_RED = (1 shl 0);
{$EXTERNALSYM D3DCOLORWRITEENABLE_RED}
D3DCOLORWRITEENABLE_GREEN = (1 shl 1);
{$EXTERNALSYM D3DCOLORWRITEENABLE_GREEN}
D3DCOLORWRITEENABLE_BLUE = (1 shl 2);
{$EXTERNALSYM D3DCOLORWRITEENABLE_BLUE}
D3DCOLORWRITEENABLE_ALPHA = (1 shl 3);
{$EXTERNALSYM D3DCOLORWRITEENABLE_ALPHA}
(*
* State enumerants for per-stage processing of fixed function pixel processing
* Two of these affect fixed function vertex processing as well: TEXTURETRANSFORMFLAGS and TEXCOORDINDEX.
*)
{$IFNDEF SUPPORTS_EXPL_ENUMS}
type
_D3DTEXTURESTAGESTATETYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DTEXTURESTAGESTATETYPE}
D3DTEXTURESTAGESTATETYPE = _D3DTEXTURESTAGESTATETYPE;
{$EXTERNALSYM D3DTEXTURESTAGESTATETYPE}
TD3DTextureStageStateType = _D3DTEXTURESTAGESTATETYPE;
const
D3DTSS_COLOROP = TD3DTextureStageStateType( 1); { D3DTEXTUREOP - per-stage blending controls for color channels }
{$EXTERNALSYM D3DTSS_COLOROP}
D3DTSS_COLORARG1 = TD3DTextureStageStateType( 2); { D3DTA_* (texture arg) }
{$EXTERNALSYM D3DTSS_COLORARG1}
D3DTSS_COLORARG2 = TD3DTextureStageStateType( 3); { D3DTA_* (texture arg) }
{$EXTERNALSYM D3DTSS_COLORARG2}
D3DTSS_ALPHAOP = TD3DTextureStageStateType( 4); { D3DTEXTUREOP - per-stage blending controls for alpha channel }
{$EXTERNALSYM D3DTSS_ALPHAOP}
D3DTSS_ALPHAARG1 = TD3DTextureStageStateType( 5); { D3DTA_* (texture arg) }
{$EXTERNALSYM D3DTSS_ALPHAARG1}
D3DTSS_ALPHAARG2 = TD3DTextureStageStateType( 6); { D3DTA_* (texture arg) }
{$EXTERNALSYM D3DTSS_ALPHAARG2}
D3DTSS_BUMPENVMAT00 = TD3DTextureStageStateType( 7); { float (bump mapping matrix) }
{$EXTERNALSYM D3DTSS_BUMPENVMAT00}
D3DTSS_BUMPENVMAT01 = TD3DTextureStageStateType( 8); { float (bump mapping matrix) }
{$EXTERNALSYM D3DTSS_BUMPENVMAT01}
D3DTSS_BUMPENVMAT10 = TD3DTextureStageStateType( 9); { float (bump mapping matrix) }
{$EXTERNALSYM D3DTSS_BUMPENVMAT10}
D3DTSS_BUMPENVMAT11 = TD3DTextureStageStateType(10); { float (bump mapping matrix) }
{$EXTERNALSYM D3DTSS_BUMPENVMAT11}
D3DTSS_TEXCOORDINDEX = TD3DTextureStageStateType(11); { identifies which set of texture coordinates index this texture }
{$EXTERNALSYM D3DTSS_TEXCOORDINDEX}
D3DTSS_BUMPENVLSCALE = TD3DTextureStageStateType(22); { float scale for bump map luminance }
{$EXTERNALSYM D3DTSS_BUMPENVLSCALE}
D3DTSS_BUMPENVLOFFSET = TD3DTextureStageStateType(23); { float offset for bump map luminance }
{$EXTERNALSYM D3DTSS_BUMPENVLOFFSET}
D3DTSS_TEXTURETRANSFORMFLAGS = TD3DTextureStageStateType(24); { D3DTEXTURETRANSFORMFLAGS controls texture transform }
{$EXTERNALSYM D3DTSS_TEXTURETRANSFORMFLAGS}
D3DTSS_COLORARG0 = TD3DTextureStageStateType(26); { D3DTA_* third arg for triadic ops }
{$EXTERNALSYM D3DTSS_COLORARG0}
D3DTSS_ALPHAARG0 = TD3DTextureStageStateType(27); { D3DTA_* third arg for triadic ops }
{$EXTERNALSYM D3DTSS_ALPHAARG0}
D3DTSS_RESULTARG = TD3DTextureStageStateType(28); { D3DTA_* arg for result (CURRENT or TEMP) }
{$EXTERNALSYM D3DTSS_RESULTARG}
D3DTSS_CONSTANT = TD3DTextureStageStateType(32); { Per-stage constant D3DTA_CONSTANT }
{$EXTERNALSYM D3DTSS_CONSTANT}
D3DTSS_FORCE_DWORD = TD3DTextureStageStateType($7fffffff); { force 32-bit size enum }
{$EXTERNALSYM D3DTSS_FORCE_DWORD}
{$ELSE}
type
_D3DTEXTURESTAGESTATETYPE = (
D3DTSS_COLOROP = 1, { D3DTEXTUREOP - per-stage blending controls for color channels }
D3DTSS_COLORARG1 = 2, { D3DTA_* (texture arg) }
D3DTSS_COLORARG2 = 3, { D3DTA_* (texture arg) }
D3DTSS_ALPHAOP = 4, { D3DTEXTUREOP - per-stage blending controls for alpha channel }
D3DTSS_ALPHAARG1 = 5, { D3DTA_* (texture arg) }
D3DTSS_ALPHAARG2 = 6, { D3DTA_* (texture arg) }
D3DTSS_BUMPENVMAT00 = 7, { float (bump mapping matrix) }
D3DTSS_BUMPENVMAT01 = 8, { float (bump mapping matrix) }
D3DTSS_BUMPENVMAT10 = 9, { float (bump mapping matrix) }
D3DTSS_BUMPENVMAT11 = 10, { float (bump mapping matrix) }
D3DTSS_TEXCOORDINDEX = 11, { identifies which set of texture coordinates index this texture }
D3DTSS_BUMPENVLSCALE = 22, { float scale for bump map luminance }
D3DTSS_BUMPENVLOFFSET = 23, { float offset for bump map luminance }
D3DTSS_TEXTURETRANSFORMFLAGS = 24, { D3DTEXTURETRANSFORMFLAGS controls texture transform }
D3DTSS_COLORARG0 = 26, { D3DTA_* third arg for triadic ops }
D3DTSS_ALPHAARG0 = 27, { D3DTA_* third arg for triadic ops }
D3DTSS_RESULTARG = 28, { D3DTA_* arg for result (CURRENT or TEMP) }
D3DTSS_CONSTANT = 32 { Per-stage constant D3DTA_CONSTANT }
);
{$EXTERNALSYM _D3DTEXTURESTAGESTATETYPE}
D3DTEXTURESTAGESTATETYPE = _D3DTEXTURESTAGESTATETYPE;
{$EXTERNALSYM D3DTEXTURESTAGESTATETYPE}
TD3DTextureStageStateType = _D3DTEXTURESTAGESTATETYPE;
{$ENDIF}
type
(*
* State enumerants for per-sampler texture processing.
*)
_D3DSAMPLERSTATETYPE = (
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DSAMP_invalid_0 {= 0},
D3DSAMP_ADDRESSU {= 1}, { D3DTEXTUREADDRESS for U coordinate }
D3DSAMP_ADDRESSV {= 2}, { D3DTEXTUREADDRESS for V coordinate }
D3DSAMP_ADDRESSW {= 3}, { D3DTEXTUREADDRESS for W coordinate }
D3DSAMP_BORDERCOLOR {= 4}, { D3DCOLOR }
D3DSAMP_MAGFILTER {= 5}, { D3DTEXTUREFILTER filter to use for magnification }
D3DSAMP_MINFILTER {= 6}, { D3DTEXTUREFILTER filter to use for minification }
D3DSAMP_MIPFILTER {= 7}, { D3DTEXTUREFILTER filter to use between mipmaps during minification }
D3DSAMP_MIPMAPLODBIAS {= 8}, { float Mipmap LOD bias }
D3DSAMP_MAXMIPLEVEL {= 9}, { DWORD 0..(n-1) LOD index of largest map to use (0 == largest) }
D3DSAMP_MAXANISOTROPY {= 10}, { DWORD maximum anisotropy }
D3DSAMP_SRGBTEXTURE {= 11}, { Default = 0 (which means Gamma 1.0,
no correction required.) else correct for
Gamma = 2.2 }
D3DSAMP_ELEMENTINDEX {= 12}, { When multi-element texture is assigned to sampler, this
indicates which element index to use. Default = 0. }
D3DSAMP_DMAPOFFSET {= 13} { Offset in vertices in the pre-sampled displacement map.
Only valid for D3DDMAPSAMPLER sampler }
{$ELSE}
D3DSAMP_ADDRESSU = 1, { D3DTEXTUREADDRESS for U coordinate }
D3DSAMP_ADDRESSV = 2, { D3DTEXTUREADDRESS for V coordinate }
D3DSAMP_ADDRESSW = 3, { D3DTEXTUREADDRESS for W coordinate }
D3DSAMP_BORDERCOLOR = 4, { D3DCOLOR }
D3DSAMP_MAGFILTER = 5, { D3DTEXTUREFILTER filter to use for magnification }
D3DSAMP_MINFILTER = 6, { D3DTEXTUREFILTER filter to use for minification }
D3DSAMP_MIPFILTER = 7, { D3DTEXTUREFILTER filter to use between mipmaps during minification }
D3DSAMP_MIPMAPLODBIAS = 8, { float Mipmap LOD bias }
D3DSAMP_MAXMIPLEVEL = 9, { DWORD 0..(n-1) LOD index of largest map to use (0 == largest) }
D3DSAMP_MAXANISOTROPY = 10, { DWORD maximum anisotropy }
D3DSAMP_SRGBTEXTURE = 11, { Default = 0 (which means Gamma 1.0,
no correction required.) else correct for
Gamma = 2.2 }
D3DSAMP_ELEMENTINDEX = 12, { When multi-element texture is assigned to sampler, this
indicates which element index to use. Default = 0. }
D3DSAMP_DMAPOFFSET = 13 { Offset in vertices in the pre-sampled displacement map.
Only valid for D3DDMAPSAMPLER sampler }
{$ENDIF}
);
{$EXTERNALSYM _D3DSAMPLERSTATETYPE}
D3DSAMPLERSTATETYPE = _D3DSAMPLERSTATETYPE;
{$EXTERNALSYM D3DSAMPLERSTATETYPE}
TD3DSamplerStateType = _D3DSAMPLERSTATETYPE;
const
{ Special sampler which is used in the tesselator }
D3DDMAPSAMPLER = 256;
{$EXTERNALSYM D3DDMAPSAMPLER}
// Samplers used in vertex shaders
D3DVERTEXTEXTURESAMPLER0 = (D3DDMAPSAMPLER+1);
{$EXTERNALSYM D3DVERTEXTEXTURESAMPLER0}
D3DVERTEXTEXTURESAMPLER1 = (D3DDMAPSAMPLER+2);
{$EXTERNALSYM D3DVERTEXTEXTURESAMPLER1}
D3DVERTEXTEXTURESAMPLER2 = (D3DDMAPSAMPLER+3);
{$EXTERNALSYM D3DVERTEXTEXTURESAMPLER2}
D3DVERTEXTEXTURESAMPLER3 = (D3DDMAPSAMPLER+4);
{$EXTERNALSYM D3DVERTEXTEXTURESAMPLER3}
// Values, used with D3DTSS_TEXCOORDINDEX, to specify that the vertex data(position
// and normal in the camera space) should be taken as texture coordinates
// Low 16 bits are used to specify texture coordinate index, to take the WRAP mode from
//
D3DTSS_TCI_PASSTHRU = $00000000;
{$EXTERNALSYM D3DTSS_TCI_PASSTHRU}
D3DTSS_TCI_CAMERASPACENORMAL = $00010000;
{$EXTERNALSYM D3DTSS_TCI_CAMERASPACENORMAL}
D3DTSS_TCI_CAMERASPACEPOSITION = $00020000;
{$EXTERNALSYM D3DTSS_TCI_CAMERASPACEPOSITION}
D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR = $00030000;
{$EXTERNALSYM D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR}
D3DTSS_TCI_SPHEREMAP = $00040000;
{$EXTERNALSYM D3DTSS_TCI_SPHEREMAP}
(*
* Enumerations for COLOROP and ALPHAOP texture blending operations set in
* texture processing stage controls in D3DTSS.
*)
type
_D3DTEXTUREOP = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DTEXTUREOP}
D3DTEXTUREOP = _D3DTEXTUREOP;
{$EXTERNALSYM D3DTEXTUREOP}
TD3DTextureOp = _D3DTEXTUREOP;
const
// Control
D3DTOP_DISABLE = 1; // disables stage
{$EXTERNALSYM D3DTOP_DISABLE}
D3DTOP_SELECTARG1 = 2; // the default
{$EXTERNALSYM D3DTOP_SELECTARG1}
D3DTOP_SELECTARG2 = 3;
{$EXTERNALSYM D3DTOP_SELECTARG2}
// Modulate
D3DTOP_MODULATE = 4; // multiply args together
{$EXTERNALSYM D3DTOP_MODULATE}
D3DTOP_MODULATE2X = 5; // multiply and 1 bit
{$EXTERNALSYM D3DTOP_MODULATE2X}
D3DTOP_MODULATE4X = 6; // multiply and 2 bits
{$EXTERNALSYM D3DTOP_MODULATE4X}
// Add
D3DTOP_ADD = 7; // add arguments together
{$EXTERNALSYM D3DTOP_ADD}
D3DTOP_ADDSIGNED = 8; // add with -0.5 bias
{$EXTERNALSYM D3DTOP_ADDSIGNED}
D3DTOP_ADDSIGNED2X = 9; // as above but left 1 bit
{$EXTERNALSYM D3DTOP_ADDSIGNED2X}
D3DTOP_SUBTRACT = 10; // Arg1 - Arg2, with no saturation
{$EXTERNALSYM D3DTOP_SUBTRACT}
D3DTOP_ADDSMOOTH = 11; // add 2 args, subtract product
// Arg1 + Arg2 - Arg1*Arg2
// = Arg1 + (1-Arg1)*Arg2
{$EXTERNALSYM D3DTOP_ADDSMOOTH}
// Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha)
D3DTOP_BLENDDIFFUSEALPHA = 12; // iterated alpha
{$EXTERNALSYM D3DTOP_BLENDDIFFUSEALPHA}
D3DTOP_BLENDTEXTUREALPHA = 13; // texture alpha
{$EXTERNALSYM D3DTOP_BLENDTEXTUREALPHA}
D3DTOP_BLENDFACTORALPHA = 14; // alpha from D3DRS_TEXTUREFACTOR
{$EXTERNALSYM D3DTOP_BLENDFACTORALPHA}
// Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha)
D3DTOP_BLENDTEXTUREALPHAPM = 15; // texture alpha
{$EXTERNALSYM D3DTOP_BLENDTEXTUREALPHAPM}
D3DTOP_BLENDCURRENTALPHA = 16; // by alpha of current color
{$EXTERNALSYM D3DTOP_BLENDCURRENTALPHA}
// Specular mapping
D3DTOP_PREMODULATE = 17; // modulate with next texture before use
{$EXTERNALSYM D3DTOP_PREMODULATE}
D3DTOP_MODULATEALPHA_ADDCOLOR = 18; // Arg1.RGB + Arg1.A*Arg2.RGB
// COLOROP only
{$EXTERNALSYM D3DTOP_MODULATEALPHA_ADDCOLOR}
D3DTOP_MODULATECOLOR_ADDALPHA = 19; // Arg1.RGB*Arg2.RGB + Arg1.A
// COLOROP only
{$EXTERNALSYM D3DTOP_MODULATECOLOR_ADDALPHA}
D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20; // (1-Arg1.A)*Arg2.RGB + Arg1.RGB
// COLOROP only
{$EXTERNALSYM D3DTOP_MODULATEINVALPHA_ADDCOLOR}
D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21; // (1-Arg1.RGB)*Arg2.RGB + Arg1.A
// COLOROP only
{$EXTERNALSYM D3DTOP_MODULATEINVCOLOR_ADDALPHA}
// Bump mapping
D3DTOP_BUMPENVMAP = 22; // per pixel env map perturbation
{$EXTERNALSYM D3DTOP_BUMPENVMAP}
D3DTOP_BUMPENVMAPLUMINANCE = 23; // with luminance channel
{$EXTERNALSYM D3DTOP_BUMPENVMAPLUMINANCE}
// This can do either diffuse or specular bump mapping with correct input.
// Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G + Arg1.B*Arg2.B)
// where each component has been scaled and offset to make it signed.
// The result is replicated into all four (including alpha) channels.
// This is a valid COLOROP only.
D3DTOP_DOTPRODUCT3 = 24;
{$EXTERNALSYM D3DTOP_DOTPRODUCT3}
// Triadic ops
D3DTOP_MULTIPLYADD = 25; // Arg0 + Arg1*Arg2
{$EXTERNALSYM D3DTOP_MULTIPLYADD}
D3DTOP_LERP = 26; // (Arg0)*Arg1 + (1-Arg0)*Arg2
{$EXTERNALSYM D3DTOP_LERP}
(*
* Values for COLORARG0,1,2, ALPHAARG0,1,2, and RESULTARG texture blending
* operations set in texture processing stage controls in D3DRENDERSTATE.
*)
const
D3DTA_SELECTMASK = $0000000f; // mask for arg selector
{$EXTERNALSYM D3DTA_SELECTMASK}
D3DTA_DIFFUSE = $00000000; // select diffuse color (read only)
{$EXTERNALSYM D3DTA_DIFFUSE}
D3DTA_CURRENT = $00000001; // select stage destination register (read/write)
{$EXTERNALSYM D3DTA_CURRENT}
D3DTA_TEXTURE = $00000002; // select texture color (read only)
{$EXTERNALSYM D3DTA_TEXTURE}
D3DTA_TFACTOR = $00000003; // select D3DRS_TEXTUREFACTOR (read only)
{$EXTERNALSYM D3DTA_TFACTOR}
D3DTA_SPECULAR = $00000004; // select specular color (read only)
{$EXTERNALSYM D3DTA_SPECULAR}
D3DTA_TEMP = $00000005; // select temporary register color (read/write)
{$EXTERNALSYM D3DTA_TEMP}
D3DTA_CONSTANT = $00000006; // select texture stage constant
{$EXTERNALSYM D3DTA_CONSTANT}
D3DTA_COMPLEMENT = $00000010; // take 1.0 - x (read modifier)
{$EXTERNALSYM D3DTA_COMPLEMENT}
D3DTA_ALPHAREPLICATE = $00000020; // replicate alpha to color components (read modifier)
{$EXTERNALSYM D3DTA_ALPHAREPLICATE}
type
//
// Values for D3DSAMP_***FILTER texture stage states
//
_D3DTEXTUREFILTERTYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DTEXTUREFILTERTYPE}
D3DTEXTUREFILTERTYPE = _D3DTEXTUREFILTERTYPE;
{$EXTERNALSYM D3DTEXTUREFILTERTYPE}
TD3DTextureFilterType = _D3DTEXTUREFILTERTYPE;
const
D3DTEXF_NONE = 0; // filtering disabled (valid for mip filter only)
{$EXTERNALSYM D3DTEXF_NONE}
D3DTEXF_POINT = 1; // nearest
{$EXTERNALSYM D3DTEXF_POINT}
D3DTEXF_LINEAR = 2; // linear interpolation
{$EXTERNALSYM D3DTEXF_LINEAR}
D3DTEXF_ANISOTROPIC = 3; // anisotropic
{$EXTERNALSYM D3DTEXF_ANISOTROPIC}
D3DTEXF_PYRAMIDALQUAD = 6; // 4-sample tent
{$EXTERNALSYM D3DTEXF_PYRAMIDALQUAD}
D3DTEXF_GAUSSIANQUAD = 7; // 4-sample gaussian
{$EXTERNALSYM D3DTEXF_GAUSSIANQUAD}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
D3DTEXF_CONVOLUTIONMONO = 8; // Convolution filter for monochrome textures
{$EXTERNALSYM D3DTEXF_CONVOLUTIONMONO}
{$ENDIF}
const
{ Bits for Flags in ProcessVertices call }
D3DPV_DONOTCOPYDATA = (1 shl 0);
{$EXTERNALSYM D3DPV_DONOTCOPYDATA}
//-------------------------------------------------------------------
// Flexible vertex format bits
//
D3DFVF_RESERVED0 = $001;
{$EXTERNALSYM D3DFVF_RESERVED0}
D3DFVF_POSITION_MASK = $400E;
{$EXTERNALSYM D3DFVF_POSITION_MASK}
D3DFVF_XYZ = $002;
{$EXTERNALSYM D3DFVF_XYZ}
D3DFVF_XYZRHW = $004;
{$EXTERNALSYM D3DFVF_XYZRHW}
D3DFVF_XYZB1 = $006;
{$EXTERNALSYM D3DFVF_XYZB1}
D3DFVF_XYZB2 = $008;
{$EXTERNALSYM D3DFVF_XYZB2}
D3DFVF_XYZB3 = $00a;
{$EXTERNALSYM D3DFVF_XYZB3}
D3DFVF_XYZB4 = $00c;
{$EXTERNALSYM D3DFVF_XYZB4}
D3DFVF_XYZB5 = $00e;
{$EXTERNALSYM D3DFVF_XYZB5}
D3DFVF_XYZW = $4002;
{$EXTERNALSYM D3DFVF_XYZW}
D3DFVF_NORMAL = $010;
{$EXTERNALSYM D3DFVF_NORMAL}
D3DFVF_PSIZE = $020;
{$EXTERNALSYM D3DFVF_PSIZE}
D3DFVF_DIFFUSE = $040;
{$EXTERNALSYM D3DFVF_DIFFUSE}
D3DFVF_SPECULAR = $080;
{$EXTERNALSYM D3DFVF_SPECULAR}
D3DFVF_TEXCOUNT_MASK = $f00;
{$EXTERNALSYM D3DFVF_TEXCOUNT_MASK}
D3DFVF_TEXCOUNT_SHIFT = 8;
{$EXTERNALSYM D3DFVF_TEXCOUNT_SHIFT}
D3DFVF_TEX0 = $000;
{$EXTERNALSYM D3DFVF_TEX0}
D3DFVF_TEX1 = $100;
{$EXTERNALSYM D3DFVF_TEX1}
D3DFVF_TEX2 = $200;
{$EXTERNALSYM D3DFVF_TEX2}
D3DFVF_TEX3 = $300;
{$EXTERNALSYM D3DFVF_TEX3}
D3DFVF_TEX4 = $400;
{$EXTERNALSYM D3DFVF_TEX4}
D3DFVF_TEX5 = $500;
{$EXTERNALSYM D3DFVF_TEX5}
D3DFVF_TEX6 = $600;
{$EXTERNALSYM D3DFVF_TEX6}
D3DFVF_TEX7 = $700;
{$EXTERNALSYM D3DFVF_TEX7}
D3DFVF_TEX8 = $800;
{$EXTERNALSYM D3DFVF_TEX8}
D3DFVF_LASTBETA_UBYTE4 = $1000;
{$EXTERNALSYM D3DFVF_LASTBETA_UBYTE4}
D3DFVF_LASTBETA_D3DCOLOR = $8000;
{$EXTERNALSYM D3DFVF_LASTBETA_D3DCOLOR}
D3DFVF_RESERVED2 = $6000; // 2 reserved bits
{$EXTERNALSYM D3DFVF_RESERVED2}
//---------------------------------------------------------------------
// Vertex Shaders
//
// Vertex shader declaration
// Forces TD3DDeclUsage, TD3DDeclMethod, TD3DDeclType be 1 byte enums
{$MINENUMSIZE 1}
type
// Vertex element semantics
//
_D3DDECLUSAGE = (
D3DDECLUSAGE_POSITION, // = 0
D3DDECLUSAGE_BLENDWEIGHT, // 1
D3DDECLUSAGE_BLENDINDICES, // 2
D3DDECLUSAGE_NORMAL, // 3
D3DDECLUSAGE_PSIZE, // 4
D3DDECLUSAGE_TEXCOORD, // 5
D3DDECLUSAGE_TANGENT, // 6
D3DDECLUSAGE_BINORMAL, // 7
D3DDECLUSAGE_TESSFACTOR, // 8
D3DDECLUSAGE_POSITIONT, // 9
D3DDECLUSAGE_COLOR, // 10
D3DDECLUSAGE_FOG, // 11
D3DDECLUSAGE_DEPTH, // 12
D3DDECLUSAGE_SAMPLE // 13
);
{$EXTERNALSYM _D3DDECLUSAGE}
D3DDECLUSAGE = _D3DDECLUSAGE;
{$EXTERNALSYM D3DDECLUSAGE}
TD3DDeclUsage = _D3DDECLUSAGE;
const
MAXD3DDECLUSAGE = DWORD(D3DDECLUSAGE_SAMPLE);
{$EXTERNALSYM MAXD3DDECLUSAGE}
MAXD3DDECLUSAGEINDEX = 15;
{$EXTERNALSYM MAXD3DDECLUSAGEINDEX}
MAXD3DDECLLENGTH = 64; // does not include "end" marker vertex element
{$EXTERNALSYM MAXD3DDECLLENGTH}
type
_D3DDECLMETHOD = (
D3DDECLMETHOD_DEFAULT, // = 0,
D3DDECLMETHOD_PARTIALU,
D3DDECLMETHOD_PARTIALV,
D3DDECLMETHOD_CROSSUV, // Normal
D3DDECLMETHOD_UV,
D3DDECLMETHOD_LOOKUP, // Lookup a displacement map
D3DDECLMETHOD_LOOKUPPRESAMPLED // Lookup a pre-sampled displacement map
);
{$EXTERNALSYM _D3DDECLMETHOD}
D3DDECLMETHOD = _D3DDECLMETHOD;
{$EXTERNALSYM D3DDECLMETHOD}
TD3DDeclMethod = _D3DDECLMETHOD;
const
MAXD3DDECLMETHOD = DWORD(D3DDECLMETHOD_LOOKUPPRESAMPLED);
{$EXTERNALSYM MAXD3DDECLMETHOD}
type
// Declarations for _Type fields
//
_D3DDECLTYPE = (
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DDECLTYPE_FLOAT1 {= 0}, // 1D float expanded to (value, 0., 0., 1.)
D3DDECLTYPE_FLOAT2 {= 1}, // 2D float expanded to (value, value, 0., 1.)
D3DDECLTYPE_FLOAT3 {= 2}, // 3D float expanded to (value, value, value, 1.)
D3DDECLTYPE_FLOAT4 {= 3}, // 4D float
D3DDECLTYPE_D3DCOLOR {= 4}, // 4D packed unsigned bytes mapped to 0. to 1. range
// Input is in D3DCOLOR format (ARGB) expanded to (R, G, B, A)
D3DDECLTYPE_UBYTE4 {= 5}, // 4D unsigned byte
D3DDECLTYPE_SHORT2 {= 6}, // 2D signed short expanded to (value, value, 0., 1.)
D3DDECLTYPE_SHORT4 {= 7}, // 4D signed short
// The following types are valid only with vertex shaders >= 2.0
D3DDECLTYPE_UBYTE4N {= 8}, // Each of 4 bytes is normalized by dividing to 255.0
D3DDECLTYPE_SHORT2N {= 9}, // 2D signed short normalized (v[0]/32767.0,v[1]/32767.0,0,1)
D3DDECLTYPE_SHORT4N {= 10}, // 4D signed short normalized (v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0)
D3DDECLTYPE_USHORT2N {= 11}, // 2D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,0,1)
D3DDECLTYPE_USHORT4N {= 12}, // 4D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0)
D3DDECLTYPE_UDEC3 {= 13}, // 3D unsigned 10 10 10 format expanded to (value, value, value, 1)
D3DDECLTYPE_DEC3N {= 14}, // 3D signed 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)
D3DDECLTYPE_FLOAT16_2{= 15}, // Two 16-bit floating point values, expanded to (value, value, 0, 1)
D3DDECLTYPE_FLOAT16_4{= 16}, // Four 16-bit floating point values
D3DDECLTYPE_UNUSED {= 17} // When the type field in a decl is unused.
{$ELSE}
D3DDECLTYPE_FLOAT1 = 0, // 1D float expanded to (value, 0., 0., 1.)
D3DDECLTYPE_FLOAT2 = 1, // 2D float expanded to (value, value, 0., 1.)
D3DDECLTYPE_FLOAT3 = 2, // 3D float expanded to (value, value, value, 1.)
D3DDECLTYPE_FLOAT4 = 3, // 4D float
D3DDECLTYPE_D3DCOLOR = 4, // 4D packed unsigned bytes mapped to 0. to 1. range
// Input is in D3DCOLOR format (ARGB) expanded to (R, G, B, A)
D3DDECLTYPE_UBYTE4 = 5, // 4D unsigned byte
D3DDECLTYPE_SHORT2 = 6, // 2D signed short expanded to (value, value, 0., 1.)
D3DDECLTYPE_SHORT4 = 7, // 4D signed short
// The following types are valid only with vertex shaders >= 2.0
D3DDECLTYPE_UBYTE4N = 8, // Each of 4 bytes is normalized by dividing to 255.0
D3DDECLTYPE_SHORT2N = 9, // 2D signed short normalized (v[0]/32767.0,v[1]/32767.0,0,1)
D3DDECLTYPE_SHORT4N = 10, // 4D signed short normalized (v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0)
D3DDECLTYPE_USHORT2N = 11, // 2D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,0,1)
D3DDECLTYPE_USHORT4N = 12, // 4D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0)
D3DDECLTYPE_UDEC3 = 13, // 3D unsigned 10 10 10 format expanded to (value, value, value, 1)
D3DDECLTYPE_DEC3N = 14, // 3D signed 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)
D3DDECLTYPE_FLOAT16_2 = 15, // Two 16-bit floating point values, expanded to (value, value, 0, 1)
D3DDECLTYPE_FLOAT16_4 = 16, // Four 16-bit floating point values
D3DDECLTYPE_UNUSED = 17 // When the type field in a decl is unused.
{$ENDIF}
);
{$EXTERNALSYM _D3DDECLTYPE}
D3DDECLTYPE = _D3DDECLTYPE;
{$EXTERNALSYM D3DDECLTYPE}
TD3DDeclType = _D3DDECLTYPE;
// Restores enums to be 4 byte in size
{$MINENUMSIZE 4}
const
MAXD3DDECLTYPE = DWORD(D3DDECLTYPE_UNUSED);
{$EXTERNALSYM MAXD3DDECLTYPE}
type
PD3DVertexElement9 = ^TD3DVertexElement9;
_D3DVERTEXELEMENT9 = packed record
Stream: Word; // Stream index
Offset: Word; // Offset in the stream in bytes
_Type: TD3DDeclType{Byte}; // Data type
Method: TD3DDeclMethod{Byte}; // Processing method
Usage: TD3DDeclUsage{Byte}; // Semantics
UsageIndex: Byte; // Semantic index
end;
{$EXTERNALSYM _D3DVERTEXELEMENT9}
D3DVERTEXELEMENT9 = _D3DVERTEXELEMENT9;
{$EXTERNALSYM D3DVERTEXELEMENT9}
TD3DVertexElement9 = _D3DVERTEXELEMENT9;
// This is used to initialize the last vertex element in a vertex declaration
// array
//
const
D3DDECL_END: TD3DVertexElement9 = (Stream : $FF;
Offset : 0;
_Type : D3DDECLTYPE_UNUSED;
Method : TD3DDeclMethod(0);
Usage : TD3DDeclUsage(0);
UsageIndex : 0);
{$EXTERNALSYM D3DDECL_END}
// Maximum supported number of texture coordinate sets
const
D3DDP_MAXTEXCOORD = 8;
{$EXTERNALSYM D3DDP_MAXTEXCOORD}
//---------------------------------------------------------------------
// Values for IDirect3DDevice9::SetStreamSourceFreq's Setting parameter
//---------------------------------------------------------------------
D3DSTREAMSOURCE_INDEXEDDATA = LongWord(1 shl 30);
{$EXTERNALSYM D3DSTREAMSOURCE_INDEXEDDATA}
D3DSTREAMSOURCE_INSTANCEDATA = LongWord(2 shl 30);
{$EXTERNALSYM D3DSTREAMSOURCE_INSTANCEDATA}
//---------------------------------------------------------------------
//
// The internal format of Pixel Shader (PS) & Vertex Shader (VS)
// Instruction Tokens is defined in the Direct3D Device Driver Kit
//
//---------------------------------------------------------------------
//
// Instruction Token Bit Definitions
//
D3DSI_OPCODE_MASK = $0000FFFF;
{$EXTERNALSYM D3DSI_OPCODE_MASK}
D3DSI_INSTLENGTH_MASK = $0F000000;
{$EXTERNALSYM D3DSI_INSTLENGTH_MASK}
D3DSI_INSTLENGTH_SHIFT = 24;
{$EXTERNALSYM D3DSI_INSTLENGTH_SHIFT}
type
_D3DSHADER_INSTRUCTION_OPCODE_TYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DSHADER_INSTRUCTION_OPCODE_TYPE}
D3DSHADER_INSTRUCTION_OPCODE_TYPE = _D3DSHADER_INSTRUCTION_OPCODE_TYPE;
{$EXTERNALSYM D3DSHADER_INSTRUCTION_OPCODE_TYPE}
TD3DShaderInstructionOpcodeType = _D3DSHADER_INSTRUCTION_OPCODE_TYPE;
const
D3DSIO_NOP = 0;
{$EXTERNALSYM D3DSIO_NOP}
D3DSIO_MOV = 1;
{$EXTERNALSYM D3DSIO_MOV}
D3DSIO_ADD = 2;
{$EXTERNALSYM D3DSIO_ADD}
D3DSIO_SUB = 3;
{$EXTERNALSYM D3DSIO_SUB}
D3DSIO_MAD = 4;
{$EXTERNALSYM D3DSIO_MAD}
D3DSIO_MUL = 5;
{$EXTERNALSYM D3DSIO_MUL}
D3DSIO_RCP = 6;
{$EXTERNALSYM D3DSIO_RCP}
D3DSIO_RSQ = 7;
{$EXTERNALSYM D3DSIO_RSQ}
D3DSIO_DP3 = 8;
{$EXTERNALSYM D3DSIO_DP3}
D3DSIO_DP4 = 9;
{$EXTERNALSYM D3DSIO_DP4}
D3DSIO_MIN = 10;
{$EXTERNALSYM D3DSIO_MIN}
D3DSIO_MAX = 11;
{$EXTERNALSYM D3DSIO_MAX}
D3DSIO_SLT = 12;
{$EXTERNALSYM D3DSIO_SLT}
D3DSIO_SGE = 13;
{$EXTERNALSYM D3DSIO_SGE}
D3DSIO_EXP = 14;
{$EXTERNALSYM D3DSIO_EXP}
D3DSIO_LOG = 15;
{$EXTERNALSYM D3DSIO_LOG}
D3DSIO_LIT = 16;
{$EXTERNALSYM D3DSIO_LIT}
D3DSIO_DST = 17;
{$EXTERNALSYM D3DSIO_DST}
D3DSIO_LRP = 18;
{$EXTERNALSYM D3DSIO_LRP}
D3DSIO_FRC = 19;
{$EXTERNALSYM D3DSIO_FRC}
D3DSIO_M4x4 = 20;
{$EXTERNALSYM D3DSIO_M4x4}
D3DSIO_M4x3 = 21;
{$EXTERNALSYM D3DSIO_M4x3}
D3DSIO_M3x4 = 22;
{$EXTERNALSYM D3DSIO_M3x4}
D3DSIO_M3x3 = 23;
{$EXTERNALSYM D3DSIO_M3x3}
D3DSIO_M3x2 = 24;
{$EXTERNALSYM D3DSIO_M3x2}
D3DSIO_CALL = 25;
{$EXTERNALSYM D3DSIO_CALL}
D3DSIO_CALLNZ = 26;
{$EXTERNALSYM D3DSIO_CALLNZ}
D3DSIO_LOOP = 27;
{$EXTERNALSYM D3DSIO_LOOP}
D3DSIO_RET = 28;
{$EXTERNALSYM D3DSIO_RET}
D3DSIO_ENDLOOP = 29;
{$EXTERNALSYM D3DSIO_ENDLOOP}
D3DSIO_LABEL = 30;
{$EXTERNALSYM D3DSIO_LABEL}
D3DSIO_DCL = 31;
{$EXTERNALSYM D3DSIO_DCL}
D3DSIO_POW = 32;
{$EXTERNALSYM D3DSIO_POW}
D3DSIO_CRS = 33;
{$EXTERNALSYM D3DSIO_CRS}
D3DSIO_SGN = 34;
{$EXTERNALSYM D3DSIO_SGN}
D3DSIO_ABS = 35;
{$EXTERNALSYM D3DSIO_ABS}
D3DSIO_NRM = 36;
{$EXTERNALSYM D3DSIO_NRM}
D3DSIO_SINCOS = 37;
{$EXTERNALSYM D3DSIO_SINCOS}
D3DSIO_REP = 38;
{$EXTERNALSYM D3DSIO_REP}
D3DSIO_ENDREP = 39;
{$EXTERNALSYM D3DSIO_ENDREP}
D3DSIO_IF = 40;
{$EXTERNALSYM D3DSIO_IF}
D3DSIO_IFC = 41;
{$EXTERNALSYM D3DSIO_IFC}
D3DSIO_ELSE = 42;
{$EXTERNALSYM D3DSIO_ELSE}
D3DSIO_ENDIF = 43;
{$EXTERNALSYM D3DSIO_ENDIF}
D3DSIO_BREAK = 44;
{$EXTERNALSYM D3DSIO_BREAK}
D3DSIO_BREAKC = 45;
{$EXTERNALSYM D3DSIO_BREAKC}
D3DSIO_MOVA = 46;
{$EXTERNALSYM D3DSIO_MOVA}
D3DSIO_DEFB = 47;
{$EXTERNALSYM D3DSIO_DEFB}
D3DSIO_DEFI = 48;
{$EXTERNALSYM D3DSIO_DEFI}
D3DSIO_TEXCOORD = 64;
{$EXTERNALSYM D3DSIO_TEXCOORD}
D3DSIO_TEXKILL = 65;
{$EXTERNALSYM D3DSIO_TEXKILL}
D3DSIO_TEX = 66;
{$EXTERNALSYM D3DSIO_TEX}
D3DSIO_TEXBEM = 67;
{$EXTERNALSYM D3DSIO_TEXBEM}
D3DSIO_TEXBEML = 68;
{$EXTERNALSYM D3DSIO_TEXBEML}
D3DSIO_TEXREG2AR = 69;
{$EXTERNALSYM D3DSIO_TEXREG2AR}
D3DSIO_TEXREG2GB = 70;
{$EXTERNALSYM D3DSIO_TEXREG2GB}
D3DSIO_TEXM3x2PAD = 71;
{$EXTERNALSYM D3DSIO_TEXM3x2PAD}
D3DSIO_TEXM3x2TEX = 72;
{$EXTERNALSYM D3DSIO_TEXM3x2TEX}
D3DSIO_TEXM3x3PAD = 73;
{$EXTERNALSYM D3DSIO_TEXM3x3PAD}
D3DSIO_TEXM3x3TEX = 74;
{$EXTERNALSYM D3DSIO_TEXM3x3TEX}
D3DSIO_RESERVED0 = 75;
{$EXTERNALSYM D3DSIO_RESERVED0}
D3DSIO_TEXM3x3SPEC = 76;
{$EXTERNALSYM D3DSIO_TEXM3x3SPEC}
D3DSIO_TEXM3x3VSPEC = 77;
{$EXTERNALSYM D3DSIO_TEXM3x3VSPEC}
D3DSIO_EXPP = 78;
{$EXTERNALSYM D3DSIO_EXPP}
D3DSIO_LOGP = 79;
{$EXTERNALSYM D3DSIO_LOGP}
D3DSIO_CND = 80;
{$EXTERNALSYM D3DSIO_CND}
D3DSIO_DEF = 81;
{$EXTERNALSYM D3DSIO_DEF}
D3DSIO_TEXREG2RGB = 82;
{$EXTERNALSYM D3DSIO_TEXREG2RGB}
D3DSIO_TEXDP3TEX = 83;
{$EXTERNALSYM D3DSIO_TEXDP3TEX}
D3DSIO_TEXM3x2DEPTH = 84;
{$EXTERNALSYM D3DSIO_TEXM3x2DEPTH}
D3DSIO_TEXDP3 = 85;
{$EXTERNALSYM D3DSIO_TEXDP3}
D3DSIO_TEXM3x3 = 86;
{$EXTERNALSYM D3DSIO_TEXM3x3}
D3DSIO_TEXDEPTH = 87;
{$EXTERNALSYM D3DSIO_TEXDEPTH}
D3DSIO_CMP = 88;
{$EXTERNALSYM D3DSIO_CMP}
D3DSIO_BEM = 89;
{$EXTERNALSYM D3DSIO_BEM}
D3DSIO_DP2ADD = 90;
{$EXTERNALSYM D3DSIO_DP2ADD}
D3DSIO_DSX = 91;
{$EXTERNALSYM D3DSIO_DSX}
D3DSIO_DSY = 92;
{$EXTERNALSYM D3DSIO_DSY}
D3DSIO_TEXLDD = 93;
{$EXTERNALSYM D3DSIO_TEXLDD}
D3DSIO_SETP = 94;
{$EXTERNALSYM D3DSIO_SETP}
D3DSIO_TEXLDL = 95;
{$EXTERNALSYM D3DSIO_TEXLDL}
D3DSIO_BREAKP = 96;
{$EXTERNALSYM D3DSIO_BREAKP}
D3DSIO_PHASE = $FFFD;
{$EXTERNALSYM D3DSIO_PHASE}
D3DSIO_COMMENT = $FFFE;
{$EXTERNALSYM D3DSIO_COMMENT}
D3DSIO_END = $FFFF;
{$EXTERNALSYM D3DSIO_END}
//---------------------------------------------------------------------
// Use these constants with D3DSIO_SINCOS macro as SRC2, SRC3
//
//#define D3DSINCOSCONST1 -1.5500992e-006f, -2.1701389e-005f, 0.0026041667f, 0.00026041668f
//#define D3DSINCOSCONST2 -0.020833334f, -0.12500000f, 1.0f, 0.50000000f
//---------------------------------------------------------------------
// Co-Issue Instruction Modifier - if set then this instruction is to be
// issued in parallel with the previous instruction(s) for which this bit
// is not set.
//
D3DSI_COISSUE = $40000000;
{$EXTERNALSYM D3DSI_COISSUE}
//---------------------------------------------------------------------
// Opcode specific controls
D3DSP_OPCODESPECIFICCONTROL_MASK = $00ff0000;
{$EXTERNALSYM D3DSP_OPCODESPECIFICCONTROL_MASK}
D3DSP_OPCODESPECIFICCONTROL_SHIFT = 16;
{$EXTERNALSYM D3DSP_OPCODESPECIFICCONTROL_SHIFT}
// ps_2_0 texld controls
D3DSI_TEXLD_PROJECT = ($01 shl D3DSP_OPCODESPECIFICCONTROL_SHIFT);
{$EXTERNALSYM D3DSI_TEXLD_PROJECT}
D3DSI_TEXLD_BIAS = ($02 shl D3DSP_OPCODESPECIFICCONTROL_SHIFT);
{$EXTERNALSYM D3DSI_TEXLD_BIAS}
type
// Comparison for dynamic conditional instruction opcodes (i.e. if, breakc)
{$MINENUMSIZE 1} // Forces TD3DShaderComparison be 1 byte enum
_D3DSHADER_COMPARISON = (
// < = >
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DSPC_RESERVED0{= 0}, // 0 0 0
D3DSPC_GT {= 1}, // 0 0 1
D3DSPC_EQ {= 2}, // 0 1 0
D3DSPC_GE {= 3}, // 0 1 1
D3DSPC_LT {= 4}, // 1 0 0
D3DSPC_NE {= 5}, // 1 0 1
D3DSPC_LE {= 6}, // 1 1 0
D3DSPC_RESERVED1{= 7} // 1 1 1
{$ELSE}
D3DSPC_RESERVED0= 0, // 0 0 0
D3DSPC_GT = 1, // 0 0 1
D3DSPC_EQ = 2, // 0 1 0
D3DSPC_GE = 3, // 0 1 1
D3DSPC_LT = 4, // 1 0 0
D3DSPC_NE = 5, // 1 0 1
D3DSPC_LE = 6, // 1 1 0
D3DSPC_RESERVED1= 7 // 1 1 1
{$ENDIF}
);
{$EXTERNALSYM _D3DSHADER_COMPARISON}
D3DSHADER_COMPARISON = _D3DSHADER_COMPARISON;
{$EXTERNALSYM D3DSHADER_COMPARISON}
TD3DShaderComparison = _D3DSHADER_COMPARISON;
{$MINENUMSIZE 4} // Restores enums to be 4 byte in size
const
// Comparison is part of instruction opcode token:
D3DSHADER_COMPARISON_SHIFT = D3DSP_OPCODESPECIFICCONTROL_SHIFT;
{$EXTERNALSYM D3DSHADER_COMPARISON_SHIFT}
D3DSHADER_COMPARISON_MASK = ($7 shl D3DSHADER_COMPARISON_SHIFT);
{$EXTERNALSYM D3DSHADER_COMPARISON_MASK}
//---------------------------------------------------------------------
// Predication flags on instruction token
D3DSHADER_INSTRUCTION_PREDICATED = ($1 shl 28);
{$EXTERNALSYM D3DSHADER_INSTRUCTION_PREDICATED}
//---------------------------------------------------------------------
// DCL Info Token Controls
// For dcl info tokens requiring a semantic (usage + index)
D3DSP_DCL_USAGE_SHIFT = 0;
{$EXTERNALSYM D3DSP_DCL_USAGE_SHIFT}
D3DSP_DCL_USAGE_MASK = $0000000f;
{$EXTERNALSYM D3DSP_DCL_USAGE_MASK}
D3DSP_DCL_USAGEINDEX_SHIFT = 16;
{$EXTERNALSYM D3DSP_DCL_USAGEINDEX_SHIFT}
D3DSP_DCL_USAGEINDEX_MASK = $000f0000;
{$EXTERNALSYM D3DSP_DCL_USAGEINDEX_MASK}
// DCL pixel shader sampler info token.
D3DSP_TEXTURETYPE_SHIFT = 27;
{$EXTERNALSYM D3DSP_TEXTURETYPE_SHIFT}
D3DSP_TEXTURETYPE_MASK = $78000000;
{$EXTERNALSYM D3DSP_TEXTURETYPE_MASK}
{$IFNDEF SUPPORTS_EXPL_ENUMS_except_BCB6}
type
_D3DSAMPLER_TEXTURE_TYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DSAMPLER_TEXTURE_TYPE}
D3DSAMPLER_TEXTURE_TYPE = _D3DSAMPLER_TEXTURE_TYPE;
{$EXTERNALSYM D3DSAMPLER_TEXTURE_TYPE}
TD3DSamplerTextureType = _D3DSAMPLER_TEXTURE_TYPE;
const
D3DSTT_UNKNOWN = 0 shl D3DSP_TEXTURETYPE_SHIFT; // uninitialized value
{$EXTERNALSYM D3DSTT_UNKNOWN}
D3DSTT_2D = 2 shl D3DSP_TEXTURETYPE_SHIFT; // dcl_2d s# (for declaring a 2-D texture)
{$EXTERNALSYM D3DSTT_2D}
D3DSTT_CUBE = 3 shl D3DSP_TEXTURETYPE_SHIFT; // dcl_cube s# (for declaring a cube texture)
{$EXTERNALSYM D3DSTT_CUBE}
D3DSTT_VOLUME = 4 shl D3DSP_TEXTURETYPE_SHIFT; // dcl_volume s# (for declaring a volume texture)
{$EXTERNALSYM D3DSTT_VOLUME}
D3DSTT_FORCE_DWORD = $7fffffff; // force 32-bit size enum
{$EXTERNALSYM D3DSTT_FORCE_DWORD}
{$ELSE}
type
_D3DSAMPLER_TEXTURE_TYPE = (
D3DSTT_UNKNOWN = 0 shl D3DSP_TEXTURETYPE_SHIFT, // uninitialized value
D3DSTT_2D = 2 shl D3DSP_TEXTURETYPE_SHIFT, // dcl_2d s# (for declaring a 2-D texture)
D3DSTT_CUBE = 3 shl D3DSP_TEXTURETYPE_SHIFT, // dcl_cube s# (for declaring a cube texture)
D3DSTT_VOLUME = 4 shl D3DSP_TEXTURETYPE_SHIFT, // dcl_volume s# (for declaring a volume texture)
D3DSTT_FORCE_DWORD = $7fffffff // force 32-bit size enum
);
{$EXTERNALSYM _D3DSAMPLER_TEXTURE_TYPE}
D3DSAMPLER_TEXTURE_TYPE = _D3DSAMPLER_TEXTURE_TYPE;
{$EXTERNALSYM D3DSAMPLER_TEXTURE_TYPE}
TD3DSamplerTextureType = _D3DSAMPLER_TEXTURE_TYPE;
{$ENDIF}
const
//---------------------------------------------------------------------
// Parameter Token Bit Definitions
//
D3DSP_REGNUM_MASK = $000007FF;
{$EXTERNALSYM D3DSP_REGNUM_MASK}
// destination parameter write mask
D3DSP_WRITEMASK_0 = $00010000; // Component 0 (X;Red)
{$EXTERNALSYM D3DSP_WRITEMASK_0}
D3DSP_WRITEMASK_1 = $00020000; // Component 1 (Y;Green)
{$EXTERNALSYM D3DSP_WRITEMASK_1}
D3DSP_WRITEMASK_2 = $00040000; // Component 2 (Z;Blue)
{$EXTERNALSYM D3DSP_WRITEMASK_2}
D3DSP_WRITEMASK_3 = $00080000; // Component 3 (W;Alpha)
{$EXTERNALSYM D3DSP_WRITEMASK_3}
D3DSP_WRITEMASK_ALL = $000F0000; // All Components
{$EXTERNALSYM D3DSP_WRITEMASK_ALL}
// destination parameter modifiers
D3DSP_DSTMOD_SHIFT = 20;
{$EXTERNALSYM D3DSP_DSTMOD_SHIFT}
D3DSP_DSTMOD_MASK = $00F00000;
{$EXTERNALSYM D3DSP_DSTMOD_MASK}
// Bit masks for destination parameter modifiers
D3DSPDM_NONE = (0 shl D3DSP_DSTMOD_SHIFT); // nop
{$EXTERNALSYM D3DSPDM_NONE}
D3DSPDM_SATURATE = (1 shl D3DSP_DSTMOD_SHIFT); // clamp to 0. to 1. range
{$EXTERNALSYM D3DSPDM_SATURATE}
D3DSPDM_PARTIALPRECISION = (2 shl D3DSP_DSTMOD_SHIFT); // Partial precision hint
{$EXTERNALSYM D3DSPDM_PARTIALPRECISION}
D3DSPDM_MSAMPCENTROID = (4 shl D3DSP_DSTMOD_SHIFT); // Relevant to multisampling only:
{$EXTERNALSYM D3DSPDM_MSAMPCENTROID}
// When the pixel center is not covered, sample
// attribute or compute gradients/LOD
// using multisample "centroid" location.
// "Centroid" is some location within the covered
// region of the pixel.
// destination parameter
D3DSP_DSTSHIFT_SHIFT = 24;
{$EXTERNALSYM D3DSP_DSTSHIFT_SHIFT}
D3DSP_DSTSHIFT_MASK = $0F000000;
{$EXTERNALSYM D3DSP_DSTSHIFT_MASK}
// destination/source parameter register type
D3DSP_REGTYPE_SHIFT = 28;
{$EXTERNALSYM D3DSP_REGTYPE_SHIFT}
D3DSP_REGTYPE_SHIFT2 = 8;
{$EXTERNALSYM D3DSP_REGTYPE_SHIFT2}
D3DSP_REGTYPE_MASK = $70000000;
{$EXTERNALSYM D3DSP_REGTYPE_MASK}
D3DSP_REGTYPE_MASK2 = $00001800;
{$EXTERNALSYM D3DSP_REGTYPE_MASK2}
{$IFNDEF SUPPORTS_EXPL_ENUMS}
const
D3DSPR_TEMP = 0; // Temporary Register File
{$EXTERNALSYM D3DSPR_TEMP}
D3DSPR_INPUT = 1; // Input Register File
{$EXTERNALSYM D3DSPR_INPUT}
D3DSPR_CONST = 2; // Constant Register File
{$EXTERNALSYM D3DSPR_CONST}
D3DSPR_ADDR = 3; // Address Register (VS)
{$EXTERNALSYM D3DSPR_ADDR}
D3DSPR_TEXTURE = 3; // Texture Register File (PS)
{$EXTERNALSYM D3DSPR_TEXTURE}
D3DSPR_RASTOUT = 4; // Rasterizer Register File
{$EXTERNALSYM D3DSPR_RASTOUT}
D3DSPR_ATTROUT = 5; // Attribute Output Register File
{$EXTERNALSYM D3DSPR_ATTROUT}
D3DSPR_TEXCRDOUT = 6; // Texture Coordinate Output Register File
{$EXTERNALSYM D3DSPR_TEXCRDOUT}
D3DSPR_OUTPUT = 6; // Output register file for VS3.0+
{$EXTERNALSYM D3DSPR_OUTPUT}
D3DSPR_CONSTINT = 7; // Constant Integer Vector Register File
{$EXTERNALSYM D3DSPR_CONSTINT}
D3DSPR_COLOROUT = 8; // Color Output Register File
{$EXTERNALSYM D3DSPR_COLOROUT}
D3DSPR_DEPTHOUT = 9; // Depth Output Register File
{$EXTERNALSYM D3DSPR_DEPTHOUT}
D3DSPR_SAMPLER = 10; // Sampler State Register File
{$EXTERNALSYM D3DSPR_SAMPLER}
D3DSPR_CONST2 = 11; // Constant Register File 2048 - 4095
{$EXTERNALSYM D3DSPR_CONST2}
D3DSPR_CONST3 = 12; // Constant Register File 4096 - 6143
{$EXTERNALSYM D3DSPR_CONST3}
D3DSPR_CONST4 = 13; // Constant Register File 6144 - 8191
{$EXTERNALSYM D3DSPR_CONST4}
D3DSPR_CONSTBOOL = 14; // Constant Boolean register file
{$EXTERNALSYM D3DSPR_CONSTBOOL}
D3DSPR_LOOP = 15; // Loop counter register file
{$EXTERNALSYM D3DSPR_LOOP}
D3DSPR_TEMPFLOAT16 = 16; // 16-bit float temp register file
{$EXTERNALSYM D3DSPR_TEMPFLOAT16}
D3DSPR_MISCTYPE = 17; // Miscellaneous (single) registers.
{$EXTERNALSYM D3DSPR_MISCTYPE}
D3DSPR_LABEL = 18; // Label
{$EXTERNALSYM D3DSPR_LABEL}
D3DSPR_PREDICATE = 19; // Predicate register
{$EXTERNALSYM D3DSPR_PREDICATE}
type
_D3DSHADER_PARAM_REGISTER_TYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$ELSE}
type
_D3DSHADER_PARAM_REGISTER_TYPE = (
D3DSPR_TEMP = 0, // Temporary Register File
D3DSPR_INPUT = 1, // Input Register File
D3DSPR_CONST = 2, // Constant Register File
D3DSPR_ADDR = 3, // Address Register (VS)
D3DSPR_TEXTURE = 3, // Texture Register File (PS)
D3DSPR_RASTOUT = 4, // Rasterizer Register File
D3DSPR_ATTROUT = 5, // Attribute Output Register File
D3DSPR_TEXCRDOUT = 6, // Texture Coordinate Output Register File
D3DSPR_OUTPUT = 6, // Output register file for VS3.0+
D3DSPR_CONSTINT = 7, // Constant Integer Vector Register File
D3DSPR_COLOROUT = 8, // Color Output Register File
D3DSPR_DEPTHOUT = 9, // Depth Output Register File
D3DSPR_SAMPLER = 10, // Sampler State Register File
D3DSPR_CONST2 = 11, // Constant Register File 2048 - 4095
D3DSPR_CONST3 = 12, // Constant Register File 4096 - 6143
D3DSPR_CONST4 = 13, // Constant Register File 6144 - 8191
D3DSPR_CONSTBOOL = 14, // Constant Boolean register file
D3DSPR_LOOP = 15, // Loop counter register file
D3DSPR_TEMPFLOAT16 = 16, // 16-bit float temp register file
D3DSPR_MISCTYPE = 17, // Miscellaneous (single) registers.
D3DSPR_LABEL = 18, // Label
D3DSPR_PREDICATE = 19 // Predicate register
);
{$ENDIF}
{$EXTERNALSYM _D3DSHADER_PARAM_REGISTER_TYPE}
D3DSHADER_PARAM_REGISTER_TYPE = _D3DSHADER_PARAM_REGISTER_TYPE;
{$EXTERNALSYM D3DSHADER_PARAM_REGISTER_TYPE}
TD3DShaderParamRegisterType = _D3DSHADER_PARAM_REGISTER_TYPE;
// The miscellaneous register file (D3DSPR_MISCTYPES)
// contains register types for which there is only ever one
// register (i.e. the register # is not needed).
// Rather than use up additional register types for such
// registers, they are defined
// as particular offsets into the misc. register file:
{$MINENUMSIZE 1} // Forces TD3DShaderMiscTypeOffsets be 1 byte enum
_D3DSHADER_MISCTYPE_OFFSETS = (
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DSMO_POSITION {= 0}, // Input position x,y,z,rhw (PS)
D3DSMO_FACE {= 1} // Floating point primitive area (PS)
{$ELSE}
D3DSMO_POSITION = 0, // Input position x,y,z,rhw (PS)
D3DSMO_FACE = 1 // Floating point primitive area (PS)
{$ENDIF}
);
{$EXTERNALSYM _D3DSHADER_MISCTYPE_OFFSETS}
D3DSHADER_MISCTYPE_OFFSETS = _D3DSHADER_MISCTYPE_OFFSETS;
{$EXTERNALSYM D3DSHADER_MISCTYPE_OFFSETS}
TD3DShaderMiscTypeOffsets = _D3DSHADER_MISCTYPE_OFFSETS;
{$MINENUMSIZE 4} // Restores enums to be 4 byte in size
// Register offsets in the Rasterizer Register File
//
_D3DVS_RASTOUT_OFFSETS = (
D3DSRO_POSITION, // = 0,
D3DSRO_FOG,
D3DSRO_POINT_SIZE
);
{$EXTERNALSYM _D3DVS_RASTOUT_OFFSETS}
D3DVS_RASTOUT_OFFSETS = _D3DVS_RASTOUT_OFFSETS;
{$EXTERNALSYM D3DVS_RASTOUT_OFFSETS}
TD3DVSRastoutOffsets = _D3DVS_RASTOUT_OFFSETS;
// Source operand addressing modes
const
D3DVS_ADDRESSMODE_SHIFT = 13;
{$EXTERNALSYM D3DVS_ADDRESSMODE_SHIFT}
D3DVS_ADDRESSMODE_MASK = 1 shl D3DVS_ADDRESSMODE_SHIFT;
{$EXTERNALSYM D3DVS_ADDRESSMODE_MASK}
type
_D3DVS_ADDRESSMODE_TYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DVS_ADDRESSMODE_TYPE}
D3DVS_ADDRESSMODE_TYPE = _D3DVS_ADDRESSMODE_TYPE;
{$EXTERNALSYM D3DVS_ADDRESSMODE_TYPE}
TD3DVSAddressModeType = _D3DVS_ADDRESSMODE_TYPE;
const
D3DVS_ADDRMODE_ABSOLUTE = 0 shl D3DVS_ADDRESSMODE_SHIFT;
{$EXTERNALSYM D3DVS_ADDRMODE_ABSOLUTE}
D3DVS_ADDRMODE_RELATIVE = 1 shl D3DVS_ADDRESSMODE_SHIFT;
{$EXTERNALSYM D3DVS_ADDRMODE_RELATIVE}
D3DVS_ADDRMODE_FORCE_DWORD = $7fffffff; // force 32-bit size enum
{$EXTERNALSYM D3DVS_ADDRMODE_FORCE_DWORD}
const
D3DSHADER_ADDRESSMODE_SHIFT = 13;
{$EXTERNALSYM D3DSHADER_ADDRESSMODE_SHIFT}
D3DSHADER_ADDRESSMODE_MASK = (1 shl D3DSHADER_ADDRESSMODE_SHIFT);
{$EXTERNALSYM D3DSHADER_ADDRESSMODE_MASK}
type
_D3DSHADER_ADDRESSMODE_TYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DSHADER_ADDRESSMODE_TYPE}
D3DSHADER_ADDRESSMODE_TYPE = _D3DSHADER_ADDRESSMODE_TYPE;
{$EXTERNALSYM D3DSHADER_ADDRESSMODE_TYPE}
TD3DShaderAddressModeType = _D3DSHADER_ADDRESSMODE_TYPE;
const
D3DSHADER_ADDRMODE_ABSOLUTE = (0 shl D3DSHADER_ADDRESSMODE_SHIFT);
{$EXTERNALSYM D3DSHADER_ADDRMODE_ABSOLUTE}
D3DSHADER_ADDRMODE_RELATIVE = (1 shl D3DSHADER_ADDRESSMODE_SHIFT);
{$EXTERNALSYM D3DSHADER_ADDRMODE_RELATIVE}
D3DSHADER_ADDRMODE_FORCE_DWORD = $7fffffff; // force 32-bit size enum
{$EXTERNALSYM D3DSHADER_ADDRMODE_FORCE_DWORD}
// Source operand swizzle definitions
//
D3DVS_SWIZZLE_SHIFT = 16;
{$EXTERNALSYM D3DVS_SWIZZLE_SHIFT}
D3DVS_SWIZZLE_MASK = $00FF0000;
{$EXTERNALSYM D3DVS_SWIZZLE_MASK}
// The following bits define where to take component X from:
D3DVS_X_X = 0 shl D3DVS_SWIZZLE_SHIFT;
{$EXTERNALSYM D3DVS_X_X}
D3DVS_X_Y = 1 shl D3DVS_SWIZZLE_SHIFT;
{$EXTERNALSYM D3DVS_X_Y}
D3DVS_X_Z = 2 shl D3DVS_SWIZZLE_SHIFT;
{$EXTERNALSYM D3DVS_X_Z}
D3DVS_X_W = 3 shl D3DVS_SWIZZLE_SHIFT;
{$EXTERNALSYM D3DVS_X_W}
// The following bits define where to take component Y from:
D3DVS_Y_X = 0 shl (D3DVS_SWIZZLE_SHIFT + 2);
{$EXTERNALSYM D3DVS_Y_X}
D3DVS_Y_Y = 1 shl (D3DVS_SWIZZLE_SHIFT + 2);
{$EXTERNALSYM D3DVS_Y_Y}
D3DVS_Y_Z = 2 shl (D3DVS_SWIZZLE_SHIFT + 2);
{$EXTERNALSYM D3DVS_Y_Z}
D3DVS_Y_W = 3 shl (D3DVS_SWIZZLE_SHIFT + 2);
{$EXTERNALSYM D3DVS_Y_W}
// The following bits define where to take component Z from:
D3DVS_Z_X = 0 shl (D3DVS_SWIZZLE_SHIFT + 4);
{$EXTERNALSYM D3DVS_Z_X}
D3DVS_Z_Y = 1 shl (D3DVS_SWIZZLE_SHIFT + 4);
{$EXTERNALSYM D3DVS_Z_Y}
D3DVS_Z_Z = 2 shl (D3DVS_SWIZZLE_SHIFT + 4);
{$EXTERNALSYM D3DVS_Z_Z}
D3DVS_Z_W = 3 shl (D3DVS_SWIZZLE_SHIFT + 4);
{$EXTERNALSYM D3DVS_Z_W}
// The following bits define where to take component W from:
D3DVS_W_X = 0 shl (D3DVS_SWIZZLE_SHIFT + 6);
{$EXTERNALSYM D3DVS_W_X}
D3DVS_W_Y = 1 shl (D3DVS_SWIZZLE_SHIFT + 6);
{$EXTERNALSYM D3DVS_W_Y}
D3DVS_W_Z = 2 shl (D3DVS_SWIZZLE_SHIFT + 6);
{$EXTERNALSYM D3DVS_W_Z}
D3DVS_W_W = 3 shl (D3DVS_SWIZZLE_SHIFT + 6);
{$EXTERNALSYM D3DVS_W_W}
// Value when there is no swizzle (X is taken from X, Y is taken from Y,
// Z is taken from Z, W is taken from W
//
D3DVS_NOSWIZZLE = D3DVS_X_X or D3DVS_Y_Y or D3DVS_Z_Z or D3DVS_W_W;
{$EXTERNALSYM D3DVS_NOSWIZZLE}
// source parameter swizzle
D3DSP_SWIZZLE_SHIFT = 16;
{$EXTERNALSYM D3DSP_SWIZZLE_SHIFT}
D3DSP_SWIZZLE_MASK = $00FF0000;
{$EXTERNALSYM D3DSP_SWIZZLE_MASK}
D3DSP_NOSWIZZLE =
(0 shl (D3DSP_SWIZZLE_SHIFT + 0)) or
(1 shl (D3DSP_SWIZZLE_SHIFT + 2)) or
(2 shl (D3DSP_SWIZZLE_SHIFT + 4)) or
(3 shl (D3DSP_SWIZZLE_SHIFT + 6));
{$EXTERNALSYM D3DSP_NOSWIZZLE}
// pixel-shader swizzle ops
D3DSP_REPLICATERED =
(0 shl (D3DSP_SWIZZLE_SHIFT + 0)) or
(0 shl (D3DSP_SWIZZLE_SHIFT + 2)) or
(0 shl (D3DSP_SWIZZLE_SHIFT + 4)) or
(0 shl (D3DSP_SWIZZLE_SHIFT + 6));
{$EXTERNALSYM D3DSP_REPLICATERED}
D3DSP_REPLICATEGREEN =
(1 shl (D3DSP_SWIZZLE_SHIFT + 0)) or
(1 shl (D3DSP_SWIZZLE_SHIFT + 2)) or
(1 shl (D3DSP_SWIZZLE_SHIFT + 4)) or
(1 shl (D3DSP_SWIZZLE_SHIFT + 6));
{$EXTERNALSYM D3DSP_REPLICATEGREEN}
D3DSP_REPLICATEBLUE =
(2 shl (D3DSP_SWIZZLE_SHIFT + 0)) or
(2 shl (D3DSP_SWIZZLE_SHIFT + 2)) or
(2 shl (D3DSP_SWIZZLE_SHIFT + 4)) or
(2 shl (D3DSP_SWIZZLE_SHIFT + 6));
{$EXTERNALSYM D3DSP_REPLICATEBLUE}
D3DSP_REPLICATEALPHA =
(3 shl (D3DSP_SWIZZLE_SHIFT + 0)) or
(3 shl (D3DSP_SWIZZLE_SHIFT + 2)) or
(3 shl (D3DSP_SWIZZLE_SHIFT + 4)) or
(3 shl (D3DSP_SWIZZLE_SHIFT + 6));
{$EXTERNALSYM D3DSP_REPLICATEALPHA}
// source parameter modifiers
D3DSP_SRCMOD_SHIFT = 24;
{$EXTERNALSYM D3DSP_SRCMOD_SHIFT}
D3DSP_SRCMOD_MASK = $0F000000;
{$EXTERNALSYM D3DSP_SRCMOD_MASK}
type
_D3DSHADER_PARAM_SRCMOD_TYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DSHADER_PARAM_SRCMOD_TYPE}
D3DSHADER_PARAM_SRCMOD_TYPE = _D3DSHADER_PARAM_SRCMOD_TYPE;
{$EXTERNALSYM D3DSHADER_PARAM_SRCMOD_TYPE}
TD3DShaderParamSRCModType = _D3DSHADER_PARAM_SRCMOD_TYPE;
const
D3DSPSM_NONE = 0 shl D3DSP_SRCMOD_SHIFT; // nop
{$EXTERNALSYM D3DSPSM_NONE}
D3DSPSM_NEG = 1 shl D3DSP_SRCMOD_SHIFT; // negate
{$EXTERNALSYM D3DSPSM_NEG}
D3DSPSM_BIAS = 2 shl D3DSP_SRCMOD_SHIFT; // bias
{$EXTERNALSYM D3DSPSM_BIAS}
D3DSPSM_BIASNEG = 3 shl D3DSP_SRCMOD_SHIFT; // bias and negate
{$EXTERNALSYM D3DSPSM_BIASNEG}
D3DSPSM_SIGN = 4 shl D3DSP_SRCMOD_SHIFT; // sign
{$EXTERNALSYM D3DSPSM_SIGN}
D3DSPSM_SIGNNEG = 5 shl D3DSP_SRCMOD_SHIFT; // sign and negate
{$EXTERNALSYM D3DSPSM_SIGNNEG}
D3DSPSM_COMP = 6 shl D3DSP_SRCMOD_SHIFT; // complement
{$EXTERNALSYM D3DSPSM_COMP}
D3DSPSM_X2 = 7 shl D3DSP_SRCMOD_SHIFT; // *2
{$EXTERNALSYM D3DSPSM_X2}
D3DSPSM_X2NEG = 8 shl D3DSP_SRCMOD_SHIFT; // *2 and negate
{$EXTERNALSYM D3DSPSM_X2NEG}
D3DSPSM_DZ = 9 shl D3DSP_SRCMOD_SHIFT; // divide through by z component
{$EXTERNALSYM D3DSPSM_DZ}
D3DSPSM_DW = 10 shl D3DSP_SRCMOD_SHIFT; // divide through by w component
{$EXTERNALSYM D3DSPSM_DW}
D3DSPSM_ABS = 11 shl D3DSP_SRCMOD_SHIFT; // abs()
{$EXTERNALSYM D3DSPSM_ABS}
D3DSPSM_ABSNEG = 12 shl D3DSP_SRCMOD_SHIFT; // -abs()
{$EXTERNALSYM D3DSPSM_ABSNEG}
D3DSPSM_NOT = 13 shl D3DSP_SRCMOD_SHIFT; // for predicate register: "!p0"
{$EXTERNALSYM D3DSPSM_NOT}
D3DSPSM_FORCE_DWORD = $7fffffff; // force 32-bit size enum
{$EXTERNALSYM D3DSPSM_FORCE_DWORD}
// pixel shader version token
//#define D3DPS_VERSION(_Major,_Minor) (0xFFFF0000|((_Major)<<8)|(_Minor))
function D3DPS_VERSION(_Major, _Minor: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DPS_VERSION}
// vertex shader version token
//#define D3DVS_VERSION(_Major,_Minor) (0xFFFE0000|((_Major)<<8)|(_Minor))
function D3DVS_VERSION(_Major, _Minor: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DVS_VERSION}
// extract major/minor from version cap
//#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF)
function D3DSHADER_VERSION_MAJOR(_Version: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DSHADER_VERSION_MAJOR}
//#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF)
function D3DSHADER_VERSION_MINOR(_Version: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DSHADER_VERSION_MINOR}
const
// destination/source parameter register type
D3DSI_COMMENTSIZE_SHIFT = 16;
{$EXTERNALSYM D3DSI_COMMENTSIZE_SHIFT}
D3DSI_COMMENTSIZE_MASK = $7FFF0000;
{$EXTERNALSYM D3DSI_COMMENTSIZE_MASK}
//#define D3DSHADER_COMMENT(_DWordSize) \
// ((((_DWordSize)<<D3DSI_COMMENTSIZE_SHIFT)&D3DSI_COMMENTSIZE_MASK)|D3DSIO_COMMENT)
function D3DSHADER_COMMENT(_DWordSize: DWord) : DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DSHADER_COMMENT}
const
// pixel/vertex shader end token
D3DPS_END = $0000FFFF;
{$EXTERNALSYM D3DPS_END}
D3DVS_END = $0000FFFF;
{$EXTERNALSYM D3DVS_END}
//---------------------------------------------------------------------
type
// High order surfaces
//
_D3DBASISTYPE = (
D3DBASIS_BEZIER {= 0},
D3DBASIS_BSPLINE {= 1},
D3DBASIS_CATMULL_ROM {= 2} { In D3D8 this used to be D3DBASIS_INTERPOLATE }
);
{$EXTERNALSYM _D3DBASISTYPE}
D3DBASISTYPE = _D3DBASISTYPE;
{$EXTERNALSYM D3DBASISTYPE}
TD3DBasisType = _D3DBASISTYPE;
_D3DDEGREETYPE = (
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DDEGREE_invalid_0 {= 0},
D3DDEGREE_LINEAR {= 1},
D3DDEGREE_QUADRATIC {= 2},
D3DDEGREE_CUBIC {= 3},
D3DDEGREE_invalid_4 {= 4},
D3DDEGREE_QUINTIC {= 5}
{$ELSE}
D3DDEGREE_LINEAR = 1,
D3DDEGREE_QUADRATIC = 2,
D3DDEGREE_CUBIC = 3,
D3DDEGREE_QUINTIC = 5
{$ENDIF}
);
{$EXTERNALSYM _D3DDEGREETYPE}
D3DDEGREETYPE = _D3DDEGREETYPE;
{$EXTERNALSYM D3DDEGREETYPE}
TD3DDegreeType = _D3DDEGREETYPE;
_D3DPATCHEDGESTYLE = (
D3DPATCHEDGE_DISCRETE {= 0},
D3DPATCHEDGE_CONTINUOUS {= 1}
);
{$EXTERNALSYM _D3DPATCHEDGESTYLE}
D3DPATCHEDGESTYLE = _D3DPATCHEDGESTYLE;
{$EXTERNALSYM D3DPATCHEDGESTYLE}
TD3DPatchEdgeStyle = _D3DPATCHEDGESTYLE;
_D3DSTATEBLOCKTYPE = (
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DSBT_INVALID_0,
D3DSBT_ALL {= 1}, // capture all state
D3DSBT_PIXELSTATE {= 2}, // capture pixel state
D3DSBT_VERTEXSTATE {= 3} // capture vertex state
{$ELSE}
D3DSBT_ALL = 1, // capture all state
D3DSBT_PIXELSTATE = 2, // capture pixel state
D3DSBT_VERTEXSTATE = 3 // capture vertex state
{$ENDIF}
);
{$EXTERNALSYM _D3DSTATEBLOCKTYPE}
D3DSTATEBLOCKTYPE = _D3DSTATEBLOCKTYPE;
{$EXTERNALSYM D3DSTATEBLOCKTYPE}
TD3DStateBlockType = _D3DSTATEBLOCKTYPE;
type
// The D3DVERTEXBLENDFLAGS type is used with D3DRS_VERTEXBLEND state.
//
_D3DVERTEXBLENDFLAGS = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DVERTEXBLENDFLAGS}
D3DVERTEXBLENDFLAGS = _D3DVERTEXBLENDFLAGS;
{$EXTERNALSYM D3DVERTEXBLENDFLAGS}
TD3DVertexBlendFlags = _D3DVERTEXBLENDFLAGS;
const
D3DVBF_DISABLE = 0; // Disable vertex blending
{$EXTERNALSYM D3DVBF_DISABLE}
D3DVBF_1WEIGHTS = 1; // 2 matrix blending
{$EXTERNALSYM D3DVBF_1WEIGHTS}
D3DVBF_2WEIGHTS = 2; // 3 matrix blending
{$EXTERNALSYM D3DVBF_2WEIGHTS}
D3DVBF_3WEIGHTS = 3; // 4 matrix blending
{$EXTERNALSYM D3DVBF_3WEIGHTS}
D3DVBF_TWEENING = 255; // blending using D3DRS_TWEENFACTOR
{$EXTERNALSYM D3DVBF_TWEENING}
D3DVBF_0WEIGHTS = 256; // one matrix is used with weight 1.0
{$EXTERNALSYM D3DVBF_0WEIGHTS}
D3DVBF_FORCE_DWORD = $7fffffff; // force 32-bit size enum
{$EXTERNALSYM D3DVBF_FORCE_DWORD}
type
_D3DTEXTURETRANSFORMFLAGS = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DTEXTURETRANSFORMFLAGS}
D3DTEXTURETRANSFORMFLAGS = _D3DTEXTURETRANSFORMFLAGS;
{$EXTERNALSYM D3DTEXTURETRANSFORMFLAGS}
TD3DTextureTransformFlags = _D3DTEXTURETRANSFORMFLAGS;
const
D3DTTFF_DISABLE = 0; // texture coordinates are passed directly
{$EXTERNALSYM D3DTTFF_DISABLE}
D3DTTFF_COUNT1 = 1; // rasterizer should expect 1-D texture coords
{$EXTERNALSYM D3DTTFF_COUNT1}
D3DTTFF_COUNT2 = 2; // rasterizer should expect 2-D texture coords
{$EXTERNALSYM D3DTTFF_COUNT2}
D3DTTFF_COUNT3 = 3; // rasterizer should expect 3-D texture coords
{$EXTERNALSYM D3DTTFF_COUNT3}
D3DTTFF_COUNT4 = 4; // rasterizer should expect 4-D texture coords
{$EXTERNALSYM D3DTTFF_COUNT4}
D3DTTFF_PROJECTED = 256; // texcoords to be divided by COUNTth element
{$EXTERNALSYM D3DTTFF_PROJECTED}
D3DTTFF_FORCE_DWORD = $7fffffff;
{$EXTERNALSYM D3DTTFF_FORCE_DWORD}
const
// Macros to set texture coordinate format bits in the FVF id
D3DFVF_TEXTUREFORMAT2 = 0; // Two floating point values
{$EXTERNALSYM D3DFVF_TEXTUREFORMAT2}
D3DFVF_TEXTUREFORMAT1 = 3; // One floating point value
{$EXTERNALSYM D3DFVF_TEXTUREFORMAT1}
D3DFVF_TEXTUREFORMAT3 = 1; // Three floating point values
{$EXTERNALSYM D3DFVF_TEXTUREFORMAT3}
D3DFVF_TEXTUREFORMAT4 = 2; // Four floating point values
{$EXTERNALSYM D3DFVF_TEXTUREFORMAT4}
//#define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE3(CoordIndex: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DFVF_TEXCOORDSIZE3}
//#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2)
function D3DFVF_TEXCOORDSIZE2(CoordIndex: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DFVF_TEXCOORDSIZE2}
//#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE4(CoordIndex: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DFVF_TEXCOORDSIZE4}
//#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE1(CoordIndex: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM D3DFVF_TEXCOORDSIZE1}
//---------------------------------------------------------------------
type
{ Direct3D9 Device types }
_D3DDEVTYPE = (
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DDEVTYPE_INVALID_0,
D3DDEVTYPE_HAL {= 1},
D3DDEVTYPE_REF {= 2},
D3DDEVTYPE_SW {= 3},
D3DDEVTYPE_NULLREF {= 4}
{$ELSE}
D3DDEVTYPE_HAL = 1,
D3DDEVTYPE_REF = 2,
D3DDEVTYPE_SW = 3,
D3DDEVTYPE_NULLREF = 4
{$ENDIF}
);
{$EXTERNALSYM _D3DDEVTYPE}
D3DDEVTYPE = _D3DDEVTYPE;
{$EXTERNALSYM D3DDEVTYPE}
TD3DDevType = _D3DDEVTYPE;
{ Multi-Sample buffer types }
_D3DMULTISAMPLE_TYPE = (
{$IFNDEF SUPPORTS_EXPL_ENUMS}
D3DMULTISAMPLE_NONE {= 0},
D3DMULTISAMPLE_NONMASKABLE {= 1},
D3DMULTISAMPLE_2_SAMPLES {= 2},
D3DMULTISAMPLE_3_SAMPLES {= 3},
D3DMULTISAMPLE_4_SAMPLES {= 4},
D3DMULTISAMPLE_5_SAMPLES {= 5},
D3DMULTISAMPLE_6_SAMPLES {= 6},
D3DMULTISAMPLE_7_SAMPLES {= 7},
D3DMULTISAMPLE_8_SAMPLES {= 8},
D3DMULTISAMPLE_9_SAMPLES {= 9},
D3DMULTISAMPLE_10_SAMPLES {= 10},
D3DMULTISAMPLE_11_SAMPLES {= 11},
D3DMULTISAMPLE_12_SAMPLES {= 12},
D3DMULTISAMPLE_13_SAMPLES {= 13},
D3DMULTISAMPLE_14_SAMPLES {= 14},
D3DMULTISAMPLE_15_SAMPLES {= 15},
D3DMULTISAMPLE_16_SAMPLES {= 16}
{$ELSE}
D3DMULTISAMPLE_NONE = 0,
D3DMULTISAMPLE_NONMASKABLE = 1,
D3DMULTISAMPLE_2_SAMPLES = 2,
D3DMULTISAMPLE_3_SAMPLES = 3,
D3DMULTISAMPLE_4_SAMPLES = 4,
D3DMULTISAMPLE_5_SAMPLES = 5,
D3DMULTISAMPLE_6_SAMPLES = 6,
D3DMULTISAMPLE_7_SAMPLES = 7,
D3DMULTISAMPLE_8_SAMPLES = 8,
D3DMULTISAMPLE_9_SAMPLES = 9,
D3DMULTISAMPLE_10_SAMPLES = 10,
D3DMULTISAMPLE_11_SAMPLES = 11,
D3DMULTISAMPLE_12_SAMPLES = 12,
D3DMULTISAMPLE_13_SAMPLES = 13,
D3DMULTISAMPLE_14_SAMPLES = 14,
D3DMULTISAMPLE_15_SAMPLES = 15,
D3DMULTISAMPLE_16_SAMPLES = 16
{$ENDIF}
);
{$EXTERNALSYM _D3DMULTISAMPLE_TYPE}
D3DMULTISAMPLE_TYPE = _D3DMULTISAMPLE_TYPE;
{$EXTERNALSYM D3DMULTISAMPLE_TYPE}
TD3DMultiSampleType = _D3DMULTISAMPLE_TYPE;
(* Formats
* Most of these names have the following convention:
* A = Alpha
* R = Red
* G = Green
* B = Blue
* X = Unused Bits
* P = Palette
* L = Luminance
* U = dU coordinate for BumpMap
* V = dV coordinate for BumpMap
* S = Stencil
* D = Depth (e.g. Z or W buffer)
* C = Computed from other channels (typically on certain read operations)
*
* Further, the order of the pieces are from MSB first; hence
* D3DFMT_A8L8 indicates that the high byte of this two byte
* format is alpha.
*
* D3DFMT_D16_LOCKABLE indicates:
* - An integer 16-bit value.
* - An app-lockable surface.
*
* D3DFMT_D32F_LOCKABLE indicates:
* - An IEEE 754 floating-point value.
* - An app-lockable surface.
*
* All Depth/Stencil formats except D3DFMT_D16_LOCKABLE and D3DFMT_D32F_LOCKABLE indicate:
* - no particular bit ordering per pixel, and
* - are not app lockable, and
* - the driver is allowed to consume more than the indicated
* number of bits per Depth channel (but not Stencil channel).
*)
// #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;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM MAKEFOURCC}
{$IFNDEF SUPPORTS_EXPL_ENUMS_except_BCB6}
const
D3DFMT_UNKNOWN = 0;
{$EXTERNALSYM D3DFMT_UNKNOWN}
D3DFMT_R8G8B8 = 20;
{$EXTERNALSYM D3DFMT_R8G8B8}
D3DFMT_A8R8G8B8 = 21;
{$EXTERNALSYM D3DFMT_A8R8G8B8}
D3DFMT_X8R8G8B8 = 22;
{$EXTERNALSYM D3DFMT_X8R8G8B8}
D3DFMT_R5G6B5 = 23;
{$EXTERNALSYM D3DFMT_R5G6B5}
D3DFMT_X1R5G5B5 = 24;
{$EXTERNALSYM D3DFMT_X1R5G5B5}
D3DFMT_A1R5G5B5 = 25;
{$EXTERNALSYM D3DFMT_A1R5G5B5}
D3DFMT_A4R4G4B4 = 26;
{$EXTERNALSYM D3DFMT_A4R4G4B4}
D3DFMT_R3G3B2 = 27;
{$EXTERNALSYM D3DFMT_R3G3B2}
D3DFMT_A8 = 28;
{$EXTERNALSYM D3DFMT_A8}
D3DFMT_A8R3G3B2 = 29;
{$EXTERNALSYM D3DFMT_A8R3G3B2}
D3DFMT_X4R4G4B4 = 30;
{$EXTERNALSYM D3DFMT_X4R4G4B4}
D3DFMT_A2B10G10R10 = 31;
{$EXTERNALSYM D3DFMT_A2B10G10R10}
D3DFMT_A8B8G8R8 = 32;
{$EXTERNALSYM D3DFMT_A8B8G8R8}
D3DFMT_X8B8G8R8 = 33;
{$EXTERNALSYM D3DFMT_X8B8G8R8}
D3DFMT_G16R16 = 34;
{$EXTERNALSYM D3DFMT_G16R16}
D3DFMT_A2R10G10B10 = 35;
{$EXTERNALSYM D3DFMT_A2R10G10B10}
D3DFMT_A16B16G16R16 = 36;
{$EXTERNALSYM D3DFMT_A16B16G16R16}
D3DFMT_A8P8 = 40;
{$EXTERNALSYM D3DFMT_A8P8}
D3DFMT_P8 = 41;
{$EXTERNALSYM D3DFMT_P8}
D3DFMT_L8 = 50;
{$EXTERNALSYM D3DFMT_L8}
D3DFMT_A8L8 = 51;
{$EXTERNALSYM D3DFMT_A8L8}
D3DFMT_A4L4 = 52;
{$EXTERNALSYM D3DFMT_A4L4}
D3DFMT_V8U8 = 60;
{$EXTERNALSYM D3DFMT_V8U8}
D3DFMT_L6V5U5 = 61;
{$EXTERNALSYM D3DFMT_L6V5U5}
D3DFMT_X8L8V8U8 = 62;
{$EXTERNALSYM D3DFMT_X8L8V8U8}
D3DFMT_Q8W8V8U8 = 63;
{$EXTERNALSYM D3DFMT_Q8W8V8U8}
D3DFMT_V16U16 = 64;
{$EXTERNALSYM D3DFMT_V16U16}
D3DFMT_A2W10V10U10 = 67;
{$EXTERNALSYM D3DFMT_A2W10V10U10}
// D3DFMT_UYVY = MAKEFOURCC('U', 'Y', 'V', 'Y');
D3DFMT_UYVY = Byte('U') or (Byte('Y') shl 8) or (Byte('V') shl 16) or (Byte('Y') shl 24);
{$EXTERNALSYM D3DFMT_UYVY}
// D3DFMT_R8G8_B8G8 = MAKEFOURCC('R', 'G', 'B', 'G'),
D3DFMT_R8G8_B8G8 = Byte('R') or (Byte('G') shl 8) or (Byte('B') shl 16) or (Byte('G') shl 24);
{$EXTERNALSYM D3DFMT_R8G8_B8G8}
// D3DFMT_YUY2 = MAKEFOURCC('Y', 'U', 'Y', '2'),
D3DFMT_YUY2 = Byte('Y') or (Byte('U') shl 8) or (Byte('Y') shl 16) or (Byte('2') shl 24);
{$EXTERNALSYM D3DFMT_YUY2}
// D3DFMT_G8R8_G8B8 = MAKEFOURCC('G', 'R', 'G', 'B'),
D3DFMT_G8R8_G8B8 = Byte('G') or (Byte('R') shl 8) or (Byte('G') shl 16) or (Byte('B') shl 24);
{$EXTERNALSYM D3DFMT_G8R8_G8B8}
// D3DFMT_DXT1 = MAKEFOURCC('D', 'X', 'T', '1'),
D3DFMT_DXT1 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('1') shl 24);
{$EXTERNALSYM D3DFMT_DXT1}
// D3DFMT_DXT2 = MAKEFOURCC('D', 'X', 'T', '2'),
D3DFMT_DXT2 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('2') shl 24);
{$EXTERNALSYM D3DFMT_DXT2}
// D3DFMT_DXT3 = MAKEFOURCC('D', 'X', 'T', '3'),
D3DFMT_DXT3 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('3') shl 24);
{$EXTERNALSYM D3DFMT_DXT3}
// D3DFMT_DXT4 = MAKEFOURCC('D', 'X', 'T', '4'),
D3DFMT_DXT4 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('4') shl 24);
{$EXTERNALSYM D3DFMT_DXT4}
// D3DFMT_DXT5 = MAKEFOURCC('D', 'X', 'T', '5'),
D3DFMT_DXT5 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('5') shl 24);
{$EXTERNALSYM D3DFMT_DXT5}
D3DFMT_D16_LOCKABLE = 70;
{$EXTERNALSYM D3DFMT_D16_LOCKABLE}
D3DFMT_D32 = 71;
{$EXTERNALSYM D3DFMT_D32}
D3DFMT_D15S1 = 73;
{$EXTERNALSYM D3DFMT_D15S1}
D3DFMT_D24S8 = 75;
{$EXTERNALSYM D3DFMT_D24S8}
D3DFMT_D24X8 = 77;
{$EXTERNALSYM D3DFMT_D24X8}
D3DFMT_D24X4S4 = 79;
{$EXTERNALSYM D3DFMT_D24X4S4}
D3DFMT_D16 = 80;
{$EXTERNALSYM D3DFMT_D16}
D3DFMT_D32F_LOCKABLE = 82;
{$EXTERNALSYM D3DFMT_D32F_LOCKABLE}
D3DFMT_D24FS8 = 83;
{$EXTERNALSYM D3DFMT_D24FS8}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
(* Z-Stencil formats valid for CPU access *)
D3DFMT_D32_LOCKABLE = 84;
{$EXTERNALSYM D3DFMT_D32_LOCKABLE}
D3DFMT_S8_LOCKABLE = 85;
{$EXTERNALSYM D3DFMT_S8_LOCKABLE}
{$ENDIF}
D3DFMT_L16 = 81;
{$EXTERNALSYM D3DFMT_L16}
D3DFMT_VERTEXDATA =100;
{$EXTERNALSYM D3DFMT_VERTEXDATA}
D3DFMT_INDEX16 =101;
{$EXTERNALSYM D3DFMT_INDEX16}
D3DFMT_INDEX32 =102;
{$EXTERNALSYM D3DFMT_INDEX32}
D3DFMT_Q16W16V16U16 =110;
{$EXTERNALSYM D3DFMT_Q16W16V16U16}
// D3DFMT_MULTI2_ARGB8 = MAKEFOURCC('M','E','T','1'),
D3DFMT_MULTI2_ARGB8 = Byte('M') or (Byte('E') shl 8) or (Byte('T') shl 16) or (Byte('1') shl 24);
{$EXTERNALSYM D3DFMT_MULTI2_ARGB8}
// Floating point surface formats
// s10e5 formats (16-bits per channel)
D3DFMT_R16F = 111;
{$EXTERNALSYM D3DFMT_R16F}
D3DFMT_G16R16F = 112;
{$EXTERNALSYM D3DFMT_G16R16F}
D3DFMT_A16B16G16R16F = 113;
{$EXTERNALSYM D3DFMT_A16B16G16R16F}
// IEEE s23e8 formats (32-bits per channel)
D3DFMT_R32F = 114;
{$EXTERNALSYM D3DFMT_R32F}
D3DFMT_G32R32F = 115;
{$EXTERNALSYM D3DFMT_G32R32F}
D3DFMT_A32B32G32R32F = 116;
{$EXTERNALSYM D3DFMT_A32B32G32R32F}
D3DFMT_CxV8U8 = 117;
{$EXTERNALSYM D3DFMT_CxV8U8}
{$IFDEF DIRECT3D_VERSION_9_VISTA}
// Monochrome 1 bit per pixel format
D3DFMT_A1 = 118;
{$EXTERNALSYM D3DFMT_A1}
// Binary format indicating that the data has no inherent type
D3DFMT_BINARYBUFFER = 199;
{$EXTERNALSYM D3DFMT_BINARYBUFFER}
{$ENDIF}
// ATI - 3Dc/ATI2N texture format
// D3DFMT_ATI2 = MAKEFOURCC('A', 'T', 'I', '2'),
D3DFMT_ATI2 = Byte('A') or (Byte('T') shl 8) or (Byte('I') shl 16) or (Byte('2') shl 24);
//{$EXTERNALSYM D3DFMT_ATI2} //Clootie: - this is not defined in original SDK headers
D3DFMT_FORCE_DWORD = $7fffffff;
{$EXTERNALSYM D3DFMT_FORCE_DWORD}
type
_D3DFORMAT = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$ELSE}
type
_D3DFORMAT = (
D3DFMT_UNKNOWN = 0,
D3DFMT_R8G8B8 = 20,
D3DFMT_A8R8G8B8 = 21,
D3DFMT_X8R8G8B8 = 22,
D3DFMT_R5G6B5 = 23,
D3DFMT_X1R5G5B5 = 24,
D3DFMT_A1R5G5B5 = 25,
D3DFMT_A4R4G4B4 = 26,
D3DFMT_R3G3B2 = 27,
D3DFMT_A8 = 28,
D3DFMT_A8R3G3B2 = 29,
D3DFMT_X4R4G4B4 = 30,
D3DFMT_A2B10G10R10 = 31,
D3DFMT_A8B8G8R8 = 32,
D3DFMT_X8B8G8R8 = 33,
D3DFMT_G16R16 = 34,
D3DFMT_A2R10G10B10 = 35,
D3DFMT_A16B16G16R16 = 36,
D3DFMT_A8P8 = 40,
D3DFMT_P8 = 41,
D3DFMT_L8 = 50,
D3DFMT_A8L8 = 51,
D3DFMT_A4L4 = 52,
D3DFMT_V8U8 = 60,
D3DFMT_L6V5U5 = 61,
D3DFMT_X8L8V8U8 = 62,
D3DFMT_Q8W8V8U8 = 63,
D3DFMT_V16U16 = 64,
D3DFMT_A2W10V10U10 = 67,
D3DFMT_A8X8V8U8 = 68,
D3DFMT_L8X8V8U8 = 69,
// D3DFMT_UYVY = MAKEFOURCC('U', 'Y', 'V', 'Y'),
D3DFMT_UYVY = Byte('U') or (Byte('Y') shl 8) or (Byte('V') shl 16) or (Byte('Y') shl 24),
// D3DFMT_RGBG = MAKEFOURCC('R', 'G', 'B', 'G'),
D3DFMT_RGBG = Byte('R') or (Byte('G') shl 8) or (Byte('B') shl 16) or (Byte('G') shl 24),
// D3DFMT_YUY2 = MAKEFOURCC('Y', 'U', 'Y', '2'),
D3DFMT_YUY2 = Byte('Y') or (Byte('U') shl 8) or (Byte('Y') shl 16) or (Byte('2') shl 24),
// D3DFMT_GRGB = MAKEFOURCC('G', 'R', 'G', 'B'),
D3DFMT_GRGB = Byte('G') or (Byte('R') shl 8) or (Byte('G') shl 16) or (Byte('B') shl 24),
// D3DFMT_DXT1 = MAKEFOURCC('D', 'X', 'T', '1'),
D3DFMT_DXT1 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('1') shl 24),
// D3DFMT_DXT2 = MAKEFOURCC('D', 'X', 'T', '2'),
D3DFMT_DXT2 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('2') shl 24),
// D3DFMT_DXT3 = MAKEFOURCC('D', 'X', 'T', '3'),
D3DFMT_DXT3 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('3') shl 24),
// D3DFMT_DXT4 = MAKEFOURCC('D', 'X', 'T', '4'),
D3DFMT_DXT4 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('4') shl 24),
// D3DFMT_DXT5 = MAKEFOURCC('D', 'X', 'T', '5'),
D3DFMT_DXT5 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('5') shl 24),
D3DFMT_D16_LOCKABLE = 70,
D3DFMT_D32 = 71,
D3DFMT_D15S1 = 73,
D3DFMT_D24S8 = 75,
D3DFMT_D24X8 = 77,
D3DFMT_D24X4S4 = 79,
D3DFMT_D16 = 80,
D3DFMT_D32F_LOCKABLE = 82,
D3DFMT_D24FS8 = 83,
{$IFDEF DIRECT3D_VERSION_9_VISTA}
(* Z-Stencil formats valid for CPU access *)
D3DFMT_D32_LOCKABLE = 84,
D3DFMT_S8_LOCKABLE = 85,
{$ENDIF}
D3DFMT_L16 = 81,
D3DFMT_VERTEXDATA =100,
D3DFMT_INDEX16 =101,
D3DFMT_INDEX32 =102,
D3DFMT_Q16W16V16U16 =110,
// D3DFMT_MULTI2_ARGB8 = MAKEFOURCC('M','E','T','1'),
D3DFMT_MULTI2_ARGB8 = Byte('M') or (Byte('E') shl 8) or (Byte('T') shl 16) or (Byte('1') shl 24),
// Floating point surface formats
// s10e5 formats (16-bits per channel)
D3DFMT_R16F = 111,
D3DFMT_G16R16F = 112,
D3DFMT_A16B16G16R16F = 113,
// IEEE s23e8 formats (32-bits per channel)
D3DFMT_R32F = 114,
D3DFMT_G32R32F = 115,
D3DFMT_A32B32G32R32F = 116,
D3DFMT_CxV8U8 = 117,
{$IFDEF DIRECT3D_VERSION_9_VISTA}
// Monochrome 1 bit per pixel format
D3DFMT_A1 = 118,
// Binary format indicating that the data has no inherent type
D3DFMT_BINARYBUFFER = 199,
{$ENDIF}
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}
(*==========================================================================;
*
* Copyright (C) Microsoft Corporation. All Rights Reserved.
*
* 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}
(*==========================================================================;
*
* Copyright (C) Microsoft Corporation. All Rights Reserved.
*
* 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.
Reference in New Issue View Git Blame Copy Permalink