2D图形编程

开发平台：

Delphi

Direct3D9.pas：源码内容

{******************************************************************************}
{* *}
{* *}
{* 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);
(*==========================================================================;
*
*
* 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}