游戏引擎

开发平台：

Delphi

Direct3D8.pas：源码内容

{******************************************************************************}
{* *}
{* *}
{* Files: d3d8types.h d3d8caps.h d3d8.h *}
{* Content: Direct3D8 include files *}
{* *}
{* DirectX 8.1 Delphi adaptation by Alexey Barkovoy *}
{* E-Mail: clootie@reactor.ru *}
{* *}
{* Modified: 26-Jan-2003 *}
{* *}
{* Partly based upon : *}
{* DirectX 7.0 Object Pascal adaptation by *}
{* Erik Unger, e-Mail: DelphiDirectX@next-reality.com *}
{* DirectXGraphics 8.0 ObjectPascal adaptation by *}
{* Tim Baumgarten, e-Mail: ampaze@gmx.net *}
{* *}
{* Latest version can be downloaded from: *}
{* http://clootie.narod.ru/delphi *}
{* *}
{* This File contains only Direct3D 8.x definitions. *}
{* If you want to use older versions of D3D use Direct3D.pas from Erik Unger *}
{* *}
{******************************************************************************}
{ }
{ 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 Direct3D8;
interface
// Global level dynamic loading support
{$IFDEF DYNAMIC_LINK_ALL}
{$DEFINE DIRECT3D8_DYNAMIC_LINK}
{$ENDIF}
{$IFDEF DYNAMIC_LINK_EXPLICIT_ALL}
{$DEFINE DIRECT3D8_DYNAMIC_LINK_EXPLICIT}
{$ENDIF}
// Remove "dots" below to force some kind of dynamic linking
{.$DEFINE DIRECT3D8_DYNAMIC_LINK}
{.$DEFINE DIRECT3D8_DYNAMIC_LINK_EXPLICIT}
{$NOINCLUDE DXTypes}
(*$HPPEMIT '#include <d3d8types.h>' *)
(*$HPPEMIT '#include <d3d8caps.h>' *)
(*$HPPEMIT '#include <d3d8.h>' *)
uses Windows, DXTypes;
///// Helper constants (for use in SetRenderState) /////
const
iTrue = DWORD(True);
iFalse = DWORD(False);
(*==========================================================================;
*
*
* File: d3d8types.h
* Content: Direct3D capabilities include file
*
***************************************************************************)
type
// D3DCOLOR is equivalent to D3DFMT_A8R8G8B8
D3DCOLOR = DXTypes.D3DCOLOR;
{$EXTERNALSYM D3DCOLOR}
TD3DColor = DXTypes.TD3DColor;
{$NODEFINE TD3DColor}
{$HPPEMIT 'typedef D3DCOLOR 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;
{$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;
{$EXTERNALSYM D3DCOLOR_RGBA}
// #define D3DCOLOR_XRGB(r,g,b) D3DCOLOR_ARGB(0xff,r,g,b)
function D3DCOLOR_XRGB(r,g,b: DWord): TD3DColor;
{$EXTERNALSYM D3DCOLOR_XRGB}
// 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;
{$EXTERNALSYM D3DCOLOR_COLORVALUE}
type
_D3DVECTOR = DXTypes._D3DVECTOR;
{$EXTERNALSYM _D3DVECTOR}
D3DVECTOR = DXTypes.D3DVECTOR;
{$EXTERNALSYM D3DVECTOR}
TD3DVector = DXTypes.TD3DVector;
{$NODEFINE TD3DVector}
PD3DVector = DXTypes.PD3DVector;
{$NODEFINE PD3DVector}
{$HPPEMIT 'typedef _D3DVECTOR TD3DVector;'}
{$HPPEMIT 'typedef _D3DVECTOR *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;
PD3DViewport8 = ^TD3DViewport8;
_D3DVIEWPORT8 = 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 {_D3DVIEWPORT8};
{$EXTERNALSYM _D3DVIEWPORT8}
D3DVIEWPORT8 = _D3DVIEWPORT8;
{$EXTERNALSYM D3DVIEWPORT8}
TD3DViewport8 = _D3DVIEWPORT8;
(*
* 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 D3DCLIPSTATUS8
//
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
PD3DClipStatus8 = ^TD3DClipStatus8;
_D3DCLIPSTATUS8 = packed record
ClipUnion: DWord;
ClipIntersection: DWord;
end {_D3DCLIPSTATUS8};
{$EXTERNALSYM _D3DCLIPSTATUS8}
D3DCLIPSTATUS8 = _D3DCLIPSTATUS8;
{$EXTERNALSYM D3DCLIPSTATUS8}
TD3DClipStatus8 = _D3DCLIPSTATUS8;
PD3DMaterial8 = ^TD3DMaterial8;
_D3DMATERIAL8 = 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 {_D3DMATERIAL8};
{$EXTERNALSYM _D3DMATERIAL8}
D3DMATERIAL8 = _D3DMATERIAL8;
{$EXTERNALSYM D3DMATERIAL8}
TD3DMaterial8 = _D3DMATERIAL8;
_D3DLIGHTTYPE = (
{$IFNDEF COMPILER6_UP}
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;
PD3DLight8 = ^TD3DLight8;
_D3DLIGHT8 = 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 {_D3DLIGHT8};
{$EXTERNALSYM _D3DLIGHT8}
D3DLIGHT8 = _D3DLIGHT8;
{$EXTERNALSYM D3DLIGHT8}
TD3DLight8 = _D3DLIGHT8;
(*
* 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
PD3DLinePattern = ^TD3DLinePattern;
_D3DLINEPATTERN = packed record
wRepeatFactor: Word;
wLinePattern: Word;
end {_D3DLINEPATTERN};
{$EXTERNALSYM _D3DLINEPATTERN}
D3DLINEPATTERN = _D3DLINEPATTERN;
{$EXTERNALSYM D3DLINEPATTERN}
TD3DLinePattern = _D3DLINEPATTERN;
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}
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 COMPILER6_UP}
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 COMPILER6_UP}
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 = (
{$IFDEF BCB}
D3DTS_DUMMY
{$ELSE}
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,
D3DTS_FORCE_DWORD = $7fffffff (* force 32-bit size enum *)
{$ENDIF}
);
{$ENDIF}
{$EXTERNALSYM _D3DTRANSFORMSTATETYPE}
D3DTRANSFORMSTATETYPE = _D3DTRANSFORMSTATETYPE;
{$EXTERNALSYM D3DTRANSFORMSTATETYPE}
TD3DTransformStateType = _D3DTRANSFORMSTATETYPE;
// #define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256)
function D3DTS_WORLDMATRIX(index: Byte): TD3DTransformStateType;
{$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 COMPILER6_UP}
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_LINEPATTERN = TD3DRenderStateType(10); { D3DLINEPATTERN }
{$EXTERNALSYM D3DRS_LINEPATTERN}
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_ZVISIBLE = TD3DRenderStateType(30); { TRUE to enable z checking }
{$EXTERNALSYM D3DRS_ZVISIBLE}
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_EDGEANTIALIAS = TD3DRenderStateType(40); { TRUE to enable edge antialiasing }
{$EXTERNALSYM D3DRS_EDGEANTIALIAS}
D3DRS_ZBIAS = TD3DRenderStateType(47); { LONG Z bias }
{$EXTERNALSYM D3DRS_ZBIAS}
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_SOFTWAREVERTEXPROCESSING = TD3DRenderStateType(153);
{$EXTERNALSYM D3DRS_SOFTWAREVERTEXPROCESSING}
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_PATCHSEGMENTS = TD3DRenderStateType(164); // Number of segments per edge when drawing patches
{$EXTERNALSYM D3DRS_PATCHSEGMENTS}
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_POSITIONORDER = TD3DRenderStateType(172); // NPatch position interpolation order. D3DORDER_LINEAR or D3DORDER_CUBIC (default)
{$EXTERNALSYM D3DRS_POSITIONORDER}
D3DRS_NORMALORDER = TD3DRenderStateType(173); // NPatch normal interpolation order. D3DORDER_LINEAR (default) or D3DORDER_QUADRATIC
{$EXTERNALSYM D3DRS_NORMALORDER}
D3DRS_FORCE_DWORD = TD3DRenderStateType($7fffffff); { force 32-bit size enum }
{$EXTERNALSYM D3DRS_FORCE_DWORD}
{$ELSE}
type
_D3DRENDERSTATETYPE = (
{$IFDEF BCB}
D3DRS_DUMMY
{$ELSE}
D3DRS_ZENABLE = 7, (* D3DZBUFFERTYPE (or TRUE/FALSE for legacy) *)
D3DRS_FILLMODE = 8, (* D3DFILLMODE *)
D3DRS_SHADEMODE = 9, (* D3DSHADEMODE *)
D3DRS_LINEPATTERN = 10, (* D3DLINEPATTERN *)
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_ZVISIBLE = 30, (* TRUE to enable z checking *)
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_EDGEANTIALIAS = 40, (* TRUE to enable edge antialiasing *)
D3DRS_ZBIAS = 47, (* LONG Z bias *)
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_SOFTWAREVERTEXPROCESSING = 153,
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_PATCHSEGMENTS = 164, // Number of segments per edge when drawing patches
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_POSITIONORDER = 172, // NPatch position interpolation order. D3DORDER_LINEAR or D3DORDER_CUBIC (default)
D3DRS_NORMALORDER = 173, // NPatch normal interpolation order. D3DORDER_LINEAR (default) or D3DORDER_QUADRATIC
D3DRS_FORCE_DWORD = $7fffffff (* force 32-bit size enum *)
{$ENDIF}
);
{$EXTERNALSYM _D3DRENDERSTATETYPE}
D3DRENDERSTATETYPE = _D3DRENDERSTATETYPE;
{$EXTERNALSYM D3DRENDERSTATETYPE}
TD3DRenderStateType = _D3DRENDERSTATETYPE;
{$ENDIF}
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 texture processing.
*)
type
_D3DTEXTURESTAGESTATETYPE = (
{$IFNDEF COMPILER6_UP}
D3DTSS_INVALID_0 {= 0 }, // Invalid value
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_invalid_12 , // invalid value of 12
D3DTSS_ADDRESSU {= 13}, { D3DTEXTUREADDRESS for U coordinate }
D3DTSS_ADDRESSV {= 14}, { D3DTEXTUREADDRESS for V coordinate }
D3DTSS_BORDERCOLOR {= 15}, { D3DCOLOR }
D3DTSS_MAGFILTER {= 16}, { D3DTEXTUREFILTER filter to use for magnification }
D3DTSS_MINFILTER {= 17}, { D3DTEXTUREFILTER filter to use for minification }
D3DTSS_MIPFILTER {= 18}, { D3DTEXTUREFILTER filter to use between mipmaps during minification }
D3DTSS_MIPMAPLODBIAS {= 19}, { float Mipmap LOD bias }
D3DTSS_MAXMIPLEVEL {= 20}, { DWORD 0..(n-1) LOD index of largest map to use (0 == largest) }
D3DTSS_MAXANISOTROPY {= 21}, { DWORD maximum anisotropy }
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_ADDRESSW {= 25}, { D3DTEXTUREADDRESS for W coordinate }
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) }
{$ELSE}
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_ADDRESSU = 13, { D3DTEXTUREADDRESS for U coordinate }
D3DTSS_ADDRESSV = 14, { D3DTEXTUREADDRESS for V coordinate }
D3DTSS_BORDERCOLOR = 15, { D3DCOLOR }
D3DTSS_MAGFILTER = 16, { D3DTEXTUREFILTER filter to use for magnification }
D3DTSS_MINFILTER = 17, { D3DTEXTUREFILTER filter to use for minification }
D3DTSS_MIPFILTER = 18, { D3DTEXTUREFILTER filter to use between mipmaps during minification }
D3DTSS_MIPMAPLODBIAS = 19, { float Mipmap LOD bias }
D3DTSS_MAXMIPLEVEL = 20, { DWORD 0..(n-1) LOD index of largest map to use (0 == largest) }
D3DTSS_MAXANISOTROPY = 21, { DWORD maximum anisotropy }
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_ADDRESSW = 25, { D3DTEXTUREADDRESS for W coordinate }
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) }
{$ENDIF}
);
{$EXTERNALSYM _D3DTEXTURESTAGESTATETYPE}
D3DTEXTURESTAGESTATETYPE = _D3DTEXTURESTAGESTATETYPE;
{$EXTERNALSYM D3DTEXTURESTAGESTATETYPE}
TD3DTextureStageStateType = _D3DTEXTURESTAGESTATETYPE;
const
// Values, used with D3DTSS_TEXCOORDINDEX, to specify that the vertex data(position
// and normal in the camera space) should be taken as texture coordinates
// Low 16 bits are used to specify texture coordinate index, to take the WRAP mode from
//
D3DTSS_TCI_PASSTHRU = $00000000;
{$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}
(*
* 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_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 D3DTSS_***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_FLATCUBIC = 4; // cubic
{$EXTERNALSYM D3DTEXF_FLATCUBIC}
D3DTEXF_GAUSSIANCUBIC = 5; // different cubic kernel
{$EXTERNALSYM D3DTEXF_GAUSSIANCUBIC}
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 = $00E;
{$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_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_RESERVED2 = $E000; // 4 reserved bits
{$EXTERNALSYM D3DFVF_RESERVED2}
//---------------------------------------------------------------------
// Vertex Shaders
//
{
Vertex Shader Declaration
The declaration portion of a vertex shader defines the static external
interface of the shader. The information in the declaration includes:
- Assignments of vertex shader input registers to data streams. These
assignments bind a specific vertex register to a single component within a
vertex stream. A vertex stream element is identified by a byte offset
within the stream and a type. The type specifies the arithmetic data type
plus the dimensionality (1, 2, 3, or 4 values). Stream data which is
less than 4 values are always expanded out to 4 values with zero or more
0.F values and one 1.F value.
- Assignment of vertex shader input registers to implicit data from the
primitive tessellator. This controls the loading of vertex data which is
not loaded from a stream, but rather is generated during primitive
tessellation prior to the vertex shader.
- Loading data into the constant memory at the time a shader is set as the
current shader. Each token specifies values for one or more contiguous 4
DWORD constant registers. This allows the shader to update an arbitrary
subset of the constant memory, overwriting the device state (which
contains the current values of the constant memory). Note that these
values can be subsequently overwritten (between DrawPrimitive calls)
during the time a shader is bound to a device via the
SetVertexShaderConstant method.
Declaration arrays are single-dimensional arrays of DWORDs composed of
multiple tokens each of which is one or more DWORDs. The single-DWORD
token value 0xFFFFFFFF is a special token used to indicate the end of the
declaration array. The single DWORD token value 0x00000000 is a NOP token
with is ignored during the declaration parsing. Note that 0x00000000 is a
valid value for DWORDs following the first DWORD for multiple word tokens.
[31:29] TokenType
0x0 - NOP (requires all DWORD bits to be zero)
0x1 - stream selector
0x2 - stream data definition (map to vertex input memory)
0x3 - vertex input memory from tessellator
0x4 - constant memory from shader
0x5 - extension
0x6 - reserved
0x7 - end-of-array (requires all DWORD bits to be 1)
NOP Token (single DWORD token)
[31:29] 0x0
[28:00] 0x0
Stream Selector (single DWORD token)
[31:29] 0x1
[28] indicates whether this is a tessellator stream
[27:04] 0x0
[03:00] stream selector (0..15)
Stream Data Definition (single DWORD token)
Vertex Input Register Load
[31:29] 0x2
[28] 0x0
[27:20] 0x0
[19:16] type (dimensionality and data type)
[15:04] 0x0
[03:00] vertex register address (0..15)
Data Skip (no register load)
[31:29] 0x2
[28] 0x1
[27:20] 0x0
[19:16] count of DWORDS to skip over (0..15)
[15:00] 0x0
Vertex Input Memory from Tessellator Data (single DWORD token)
[31:29] 0x3
[28] indicates whether data is normals or u/v
[27:24] 0x0
[23:20] vertex register address (0..15)
[19:16] type (dimensionality)
[15:04] 0x0
[03:00] vertex register address (0..15)
Constant Memory from Shader (multiple DWORD token)
[31:29] 0x4
[28:25] count of 4*DWORD constants to load (0..15)
[24:07] 0x0
[06:00] constant memory address (0..95)
Extension Token (single or multiple DWORD token)
[31:29] 0x5
[28:24] count of additional DWORDs in token (0..31)
[23:00] extension-specific information
End-of-array token (single DWORD token)
[31:29] 0x7
[28:00] 0x1fffffff
The stream selector token must be immediately followed by a contiguous set of stream data definition tokens. This token sequence fully defines that stream, including the set of elements within the stream, the order in which the elements appear, the type of each element, and the vertex register into which to load an element.
Streams are allowed to include data which is not loaded into a vertex register, thus allowing data which is not used for this shader to exist in the vertex stream. This skipped data is defined only by a count of DWORDs to skip over, since the type information is irrelevant.
The token sequence:
Stream Select: stream=0
Stream Data Definition (Load): type=FLOAT3; register=3
Stream Data Definition (Load): type=FLOAT3; register=4
Stream Data Definition (Skip): count=2
Stream Data Definition (Load): type=FLOAT2; register=7
defines stream zero to consist of 4 elements, 3 of which are loaded into registers and the fourth skipped over. Register 3 is loaded with the first three DWORDs in each vertex interpreted as FLOAT data. Register 4 is loaded with the 4th, 5th, and 6th DWORDs interpreted as FLOAT data. The next two DWORDs (7th and 8th) are skipped over and not loaded into any vertex input register. Register 7 is loaded with the 9th and 10th DWORDS interpreted as FLOAT data.
Placing of tokens other than NOPs between the Stream Selector and Stream Data Definition tokens is disallowed.
}
type
_D3DVSD_TOKENTYPE = (
{$IFNDEF COMPILER6_UP}
D3DVSD_TOKEN_NOP {= 0}, // NOP or extension
D3DVSD_TOKEN_STREAM, // stream selector
D3DVSD_TOKEN_STREAMDATA, // stream data definition (map to vertex input memory)
D3DVSD_TOKEN_TESSELLATOR, // vertex input memory from tessellator
D3DVSD_TOKEN_CONSTMEM, // constant memory from shader
D3DVSD_TOKEN_EXT, // extension
D3DVSD_INVALID_6, // Invalid token inserted to fill the gap (in Object Pascal translation)
D3DVSD_TOKEN_END {= 7} // end-of-array (requires all DWORD bits to be 1)
{$ELSE}
D3DVSD_TOKEN_NOP = 0, // NOP or extension
D3DVSD_TOKEN_STREAM, // stream selector
D3DVSD_TOKEN_STREAMDATA, // stream data definition (map to vertex input memory)
D3DVSD_TOKEN_TESSELLATOR, // vertex input memory from tessellator
D3DVSD_TOKEN_CONSTMEM, // constant memory from shader
D3DVSD_TOKEN_EXT, // extension
D3DVSD_TOKEN_END = 7 // end-of-array (requires all DWORD bits to be 1)
{$ENDIF}
);
{$EXTERNALSYM _D3DVSD_TOKENTYPE}
D3DVSD_TOKENTYPE = _D3DVSD_TOKENTYPE;
{$EXTERNALSYM D3DVSD_TOKENTYPE}
TD3DVSDTokenType = _D3DVSD_TOKENTYPE;
const
D3DVSD_TOKENTYPESHIFT = 29;
{$EXTERNALSYM D3DVSD_TOKENTYPESHIFT}
D3DVSD_TOKENTYPEMASK = (7 shl D3DVSD_TOKENTYPESHIFT);
{$EXTERNALSYM D3DVSD_TOKENTYPEMASK}
D3DVSD_STREAMNUMBERSHIFT = 0;
{$EXTERNALSYM D3DVSD_STREAMNUMBERSHIFT}
D3DVSD_STREAMNUMBERMASK = ($F shl D3DVSD_STREAMNUMBERSHIFT);
{$EXTERNALSYM D3DVSD_STREAMNUMBERMASK}
D3DVSD_DATALOADTYPESHIFT = 28;
{$EXTERNALSYM D3DVSD_DATALOADTYPESHIFT}
D3DVSD_DATALOADTYPEMASK = ($1 shl D3DVSD_DATALOADTYPESHIFT);
{$EXTERNALSYM D3DVSD_DATALOADTYPEMASK}
D3DVSD_DATATYPESHIFT = 16;
{$EXTERNALSYM D3DVSD_DATATYPESHIFT}
D3DVSD_DATATYPEMASK = ($F shl D3DVSD_DATATYPESHIFT);
{$EXTERNALSYM D3DVSD_DATATYPEMASK}
D3DVSD_SKIPCOUNTSHIFT = 16;
{$EXTERNALSYM D3DVSD_SKIPCOUNTSHIFT}
D3DVSD_SKIPCOUNTMASK = ($F shl D3DVSD_SKIPCOUNTSHIFT);
{$EXTERNALSYM D3DVSD_SKIPCOUNTMASK}
D3DVSD_VERTEXREGSHIFT = 0;
{$EXTERNALSYM D3DVSD_VERTEXREGSHIFT}
D3DVSD_VERTEXREGMASK = ($1F shl D3DVSD_VERTEXREGSHIFT);
{$EXTERNALSYM D3DVSD_VERTEXREGMASK}
{$EXTERNALSYM D3DVSD_VERTEXREGMASK}
D3DVSD_VERTEXREGINSHIFT = 20;
{$EXTERNALSYM D3DVSD_VERTEXREGINSHIFT}
D3DVSD_VERTEXREGINMASK = ($F shl D3DVSD_VERTEXREGINSHIFT);
{$EXTERNALSYM D3DVSD_VERTEXREGINMASK}
D3DVSD_CONSTCOUNTSHIFT = 25;
{$EXTERNALSYM D3DVSD_CONSTCOUNTSHIFT}
D3DVSD_CONSTCOUNTMASK = ($F shl D3DVSD_CONSTCOUNTSHIFT);
{$EXTERNALSYM D3DVSD_CONSTCOUNTMASK}
D3DVSD_CONSTADDRESSSHIFT = 0;
{$EXTERNALSYM D3DVSD_CONSTADDRESSSHIFT}
D3DVSD_CONSTADDRESSMASK = ($7F shl D3DVSD_CONSTADDRESSSHIFT);
{$EXTERNALSYM D3DVSD_CONSTADDRESSMASK}
D3DVSD_CONSTRSSHIFT = 16;
{$EXTERNALSYM D3DVSD_CONSTRSSHIFT}
D3DVSD_CONSTRSMASK = ($1FFF shl D3DVSD_CONSTRSSHIFT);
{$EXTERNALSYM D3DVSD_CONSTRSMASK}
D3DVSD_EXTCOUNTSHIFT = 24;
{$EXTERNALSYM D3DVSD_EXTCOUNTSHIFT}
D3DVSD_EXTCOUNTMASK = ($1F shl D3DVSD_EXTCOUNTSHIFT);
{$EXTERNALSYM D3DVSD_EXTCOUNTMASK}
D3DVSD_EXTINFOSHIFT = 0;
{$EXTERNALSYM D3DVSD_EXTINFOSHIFT}
D3DVSD_EXTINFOMASK = ($FFFFFF shl D3DVSD_EXTINFOSHIFT);
{$EXTERNALSYM D3DVSD_EXTINFOMASK}
// D3DVSD_MAKETOKENTYPE(tokenType) ((tokenType << D3DVSD_TOKENTYPESHIFT) & D3DVSD_TOKENTYPEMASK)
function D3DVSD_MAKETOKENTYPE(tokenType: TD3DVSDTokenType): DWord;
{$EXTERNALSYM D3DVSD_MAKETOKENTYPE}
// macros for generation of CreateVertexShader Declaration token array
// Set current stream
// _StreamNumber [0..(MaxStreams-1)] stream to get data from
//
//#define D3DVSD_STREAM( _StreamNumber )
// (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAM) | (_StreamNumber))
function D3DVSD_STREAM(_StreamNumber: DWord): DWord;
{$EXTERNALSYM D3DVSD_STREAM}
const
// Set tessellator stream
//
D3DVSD_STREAMTESSSHIFT = 28;
{$EXTERNALSYM D3DVSD_STREAMTESSSHIFT}
D3DVSD_STREAMTESSMASK = (1 shl D3DVSD_STREAMTESSSHIFT);
{$EXTERNALSYM D3DVSD_STREAMTESSMASK}
// #define D3DVSD_STREAM_TESS( )
// (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAM) | (D3DVSD_STREAMTESSMASK))
// !!! - macro just rolled out in pascal (not converted to function)
D3DVSD_STREAM_TESS = ((DWord(D3DVSD_TOKEN_STREAM) shl D3DVSD_TOKENTYPESHIFT) and
D3DVSD_TOKENTYPEMASK) or D3DVSD_STREAMTESSMASK;
{$EXTERNALSYM D3DVSD_STREAM_TESS}
// bind single vertex register to vertex element from vertex stream
//
// _VertexRegister [0..15] address of the vertex register
// _Type [D3DVSDT_*] dimensionality and arithmetic data type
//#define D3DVSD_REG( _VertexRegister, _Type )
// (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAMDATA) |
// ((_Type) << D3DVSD_DATATYPESHIFT) | (_VertexRegister))
function D3DVSD_REG(_VertexRegister, _Type: DWord): DWord;
{$EXTERNALSYM D3DVSD_REG}
// Skip _DWORDCount DWORDs in vertex
//
//#define D3DVSD_SKIP( _DWORDCount )
// (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAMDATA) | 0x10000000 |
// ((_DWORDCount) << D3DVSD_SKIPCOUNTSHIFT))
function D3DVSD_SKIP(_DWORDCount: DWord): DWord;
{$EXTERNALSYM D3DVSD_SKIP}
// load data into vertex shader constant memory
//
// _ConstantAddress [0..95] - address of constant array to begin filling data
// _Count [0..15] - number of constant vectors to load (4 DWORDs each)
// followed by 4*_Count DWORDS of data
//
//#define D3DVSD_CONST( _ConstantAddress, _Count )
// (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_CONSTMEM) |
// ((_Count) << D3DVSD_CONSTCOUNTSHIFT) | (_ConstantAddress))
function D3DVSD_CONST(_ConstantAddress, _Count: DWord): DWord;
{$EXTERNALSYM D3DVSD_CONST}
// enable tessellator generated normals
//
// _VertexRegisterIn [0..15] address of vertex register whose input stream
// will be used in normal computation
// _VertexRegisterOut [0..15] address of vertex register to output the normal to
//
//#define D3DVSD_TESSNORMAL( _VertexRegisterIn, _VertexRegisterOut )
// (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_TESSELLATOR) |
// ((_VertexRegisterIn) << D3DVSD_VERTEXREGINSHIFT) |
// ((0x02) << D3DVSD_DATATYPESHIFT) | (_VertexRegisterOut))
function D3DVSD_TESSNORMAL(_VertexRegisterIn, _VertexRegisterOut: DWord): DWord;
{$EXTERNALSYM D3DVSD_TESSNORMAL}
// enable tessellator generated surface parameters
//
// _VertexRegister [0..15] address of vertex register to output parameters
//
//#define D3DVSD_TESSUV( _VertexRegister )
// (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_TESSELLATOR) | 0x10000000 |
// ((0x01) << D3DVSD_DATATYPESHIFT) | (_VertexRegister))
function D3DVSD_TESSUV(_VertexRegister: DWord): DWord;
{$EXTERNALSYM D3DVSD_TESSUV}
const
// Generates END token
//
D3DVSD_END = $FFFFFFFF;
{$EXTERNALSYM D3DVSD_END}
// Generates NOP token
D3DVSD_NOP = $00000000;
{$EXTERNALSYM D3DVSD_NOP}
// bit declarations for _Type fields
D3DVSDT_FLOAT1 = $00; // 1D float expanded to (value; 0.; 0.; 1.)
{$EXTERNALSYM D3DVSDT_FLOAT1}
D3DVSDT_FLOAT2 = $01; // 2D float expanded to (value; value; 0.; 1.)
{$EXTERNALSYM D3DVSDT_FLOAT2}
D3DVSDT_FLOAT3 = $02; // 3D float expanded to (value; value; value; 1.)
{$EXTERNALSYM D3DVSDT_FLOAT3}
D3DVSDT_FLOAT4 = $03; // 4D float
{$EXTERNALSYM D3DVSDT_FLOAT4}
D3DVSDT_D3DCOLOR = $04; // 4D packed unsigned bytes mapped to 0. to 1. range
{$EXTERNALSYM D3DVSDT_D3DCOLOR}
// Input is in D3DCOLOR format (ARGB) expanded to (R; G; B; A)
D3DVSDT_UBYTE4 = $05; // 4D unsigned byte
{$EXTERNALSYM D3DVSDT_UBYTE4}
D3DVSDT_SHORT2 = $06; // 2D signed short expanded to (value; value; 0.; 1.)
{$EXTERNALSYM D3DVSDT_SHORT2}
D3DVSDT_SHORT4 = $07; // 4D signed short
{$EXTERNALSYM D3DVSDT_SHORT4}
// assignments of vertex input registers for fixed function vertex shader
//
D3DVSDE_POSITION = 0;
{$EXTERNALSYM D3DVSDE_POSITION}
D3DVSDE_BLENDWEIGHT = 1;
{$EXTERNALSYM D3DVSDE_BLENDWEIGHT}
D3DVSDE_BLENDINDICES = 2;
{$EXTERNALSYM D3DVSDE_BLENDINDICES}
D3DVSDE_NORMAL = 3;
{$EXTERNALSYM D3DVSDE_NORMAL}
D3DVSDE_PSIZE = 4;
{$EXTERNALSYM D3DVSDE_PSIZE}
D3DVSDE_DIFFUSE = 5;
{$EXTERNALSYM D3DVSDE_DIFFUSE}
D3DVSDE_SPECULAR = 6;
{$EXTERNALSYM D3DVSDE_SPECULAR}
D3DVSDE_TEXCOORD0 = 7;
{$EXTERNALSYM D3DVSDE_TEXCOORD0}
D3DVSDE_TEXCOORD1 = 8;
{$EXTERNALSYM D3DVSDE_TEXCOORD1}
D3DVSDE_TEXCOORD2 = 9;
{$EXTERNALSYM D3DVSDE_TEXCOORD2}
D3DVSDE_TEXCOORD3 = 10;
{$EXTERNALSYM D3DVSDE_TEXCOORD3}
D3DVSDE_TEXCOORD4 = 11;
{$EXTERNALSYM D3DVSDE_TEXCOORD4}
D3DVSDE_TEXCOORD5 = 12;
{$EXTERNALSYM D3DVSDE_TEXCOORD5}
D3DVSDE_TEXCOORD6 = 13;
{$EXTERNALSYM D3DVSDE_TEXCOORD6}
D3DVSDE_TEXCOORD7 = 14;
{$EXTERNALSYM D3DVSDE_TEXCOORD7}
D3DVSDE_POSITION2 = 15;
{$EXTERNALSYM D3DVSDE_POSITION2}
D3DVSDE_NORMAL2 = 16;
{$EXTERNALSYM D3DVSDE_NORMAL2}
// Maximum supported number of texture coordinate sets
D3DDP_MAXTEXCOORD = 8;
{$EXTERNALSYM D3DDP_MAXTEXCOORD}
//
// Instruction Token Bit Definitions
//
D3DSI_OPCODE_MASK = $0000FFFF;
{$EXTERNALSYM D3DSI_OPCODE_MASK}
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; // PS/VS
{$EXTERNALSYM D3DSIO_NOP}
D3DSIO_MOV = 1; // PS/VS
{$EXTERNALSYM D3DSIO_MOV}
D3DSIO_ADD = 2; // PS/VS
{$EXTERNALSYM D3DSIO_ADD}
D3DSIO_SUB = 3; // PS
{$EXTERNALSYM D3DSIO_SUB}
D3DSIO_MAD = 4; // PS/VS
{$EXTERNALSYM D3DSIO_MAD}
D3DSIO_MUL = 5; // PS/VS
{$EXTERNALSYM D3DSIO_MUL}
D3DSIO_RCP = 6; // VS
{$EXTERNALSYM D3DSIO_RCP}
D3DSIO_RSQ = 7; // VS
{$EXTERNALSYM D3DSIO_RSQ}
D3DSIO_DP3 = 8; // PS/VS
{$EXTERNALSYM D3DSIO_DP3}
D3DSIO_DP4 = 9; // PS/VS
{$EXTERNALSYM D3DSIO_DP4}
D3DSIO_MIN = 10; // VS
{$EXTERNALSYM D3DSIO_MIN}
D3DSIO_MAX = 11; // VS
{$EXTERNALSYM D3DSIO_MAX}
D3DSIO_SLT = 12; // VS
{$EXTERNALSYM D3DSIO_SLT}
D3DSIO_SGE = 13; // VS
{$EXTERNALSYM D3DSIO_SGE}
D3DSIO_EXP = 14; // VS
{$EXTERNALSYM D3DSIO_EXP}
D3DSIO_LOG = 15; // VS
{$EXTERNALSYM D3DSIO_LOG}
D3DSIO_LIT = 16; // VS
{$EXTERNALSYM D3DSIO_LIT}
D3DSIO_DST = 17; // VS
{$EXTERNALSYM D3DSIO_DST}
D3DSIO_LRP = 18; // PS
{$EXTERNALSYM D3DSIO_LRP}
D3DSIO_FRC = 19; // VS
{$EXTERNALSYM D3DSIO_FRC}
D3DSIO_M4x4 = 20; // VS
{$EXTERNALSYM D3DSIO_M4x4}
D3DSIO_M4x3 = 21; // VS
{$EXTERNALSYM D3DSIO_M4x3}
D3DSIO_M3x4 = 22; // VS
{$EXTERNALSYM D3DSIO_M3x4}
D3DSIO_M3x3 = 23; // VS
{$EXTERNALSYM D3DSIO_M3x3}
D3DSIO_M3x2 = 24; // VS
{$EXTERNALSYM D3DSIO_M3x2}
D3DSIO_TEXCOORD = 64; // PS
{$EXTERNALSYM D3DSIO_TEXCOORD}
D3DSIO_TEXKILL = 65; // PS
{$EXTERNALSYM D3DSIO_TEXKILL}
D3DSIO_TEX = 66; // PS
{$EXTERNALSYM D3DSIO_TEX}
D3DSIO_TEXBEM = 67; // PS
{$EXTERNALSYM D3DSIO_TEXBEM}
D3DSIO_TEXBEML = 68; // PS
{$EXTERNALSYM D3DSIO_TEXBEML}
D3DSIO_TEXREG2AR = 69; // PS
{$EXTERNALSYM D3DSIO_TEXREG2AR}
D3DSIO_TEXREG2GB = 70; // PS
{$EXTERNALSYM D3DSIO_TEXREG2GB}
D3DSIO_TEXM3x2PAD = 71; // PS
{$EXTERNALSYM D3DSIO_TEXM3x2PAD}
D3DSIO_TEXM3x2TEX = 72; // PS
{$EXTERNALSYM D3DSIO_TEXM3x2TEX}
D3DSIO_TEXM3x3PAD = 73; // PS
{$EXTERNALSYM D3DSIO_TEXM3x3PAD}
D3DSIO_TEXM3x3TEX = 74; // PS
{$EXTERNALSYM D3DSIO_TEXM3x3TEX}
D3DSIO_TEXM3x3DIFF = 75; // PS
{$EXTERNALSYM D3DSIO_TEXM3x3DIFF}
D3DSIO_TEXM3x3SPEC = 76; // PS
{$EXTERNALSYM D3DSIO_TEXM3x3SPEC}
D3DSIO_TEXM3x3VSPEC = 77; // PS
{$EXTERNALSYM D3DSIO_TEXM3x3VSPEC}
D3DSIO_EXPP = 78; // VS
{$EXTERNALSYM D3DSIO_EXPP}
D3DSIO_LOGP = 79; // VS
{$EXTERNALSYM D3DSIO_LOGP}
D3DSIO_CND = 80; // PS
{$EXTERNALSYM D3DSIO_CND}
D3DSIO_DEF = 81; // PS
{$EXTERNALSYM D3DSIO_DEF}
D3DSIO_TEXREG2RGB = 82; // PS
{$EXTERNALSYM D3DSIO_TEXREG2RGB}
D3DSIO_TEXDP3TEX = 83; // PS
{$EXTERNALSYM D3DSIO_TEXDP3TEX}
D3DSIO_TEXM3x2DEPTH = 84; // PS
{$EXTERNALSYM D3DSIO_TEXM3x2DEPTH}
D3DSIO_TEXDP3 = 85; // PS
{$EXTERNALSYM D3DSIO_TEXDP3}
D3DSIO_TEXM3x3 = 86; // PS
{$EXTERNALSYM D3DSIO_TEXM3x3}
D3DSIO_TEXDEPTH = 87; // PS
{$EXTERNALSYM D3DSIO_TEXDEPTH}
D3DSIO_CMP = 88; // PS
{$EXTERNALSYM D3DSIO_CMP}
D3DSIO_BEM = 89; // PS
{$EXTERNALSYM D3DSIO_BEM}
D3DSIO_PHASE = $FFFD;
{$EXTERNALSYM D3DSIO_PHASE}
D3DSIO_COMMENT = $FFFE;
{$EXTERNALSYM D3DSIO_COMMENT}
D3DSIO_END = $FFFF;
{$EXTERNALSYM D3DSIO_END}
//
// 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}
//
// Parameter Token Bit Definitions
//
D3DSP_REGNUM_MASK = $00001FFF;
{$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}
type
_D3DSHADER_PARAM_DSTMOD_TYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DSHADER_PARAM_DSTMOD_TYPE}
D3DSHADER_PARAM_DSTMOD_TYPE = _D3DSHADER_PARAM_DSTMOD_TYPE;
{$EXTERNALSYM D3DSHADER_PARAM_DSTMOD_TYPE}
TD3DShaderParamDSTModType = _D3DSHADER_PARAM_DSTMOD_TYPE;
const
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_FORCE_DWORD = $7fffffff; // force 32-bit size enum
{$EXTERNALSYM D3DSPDM_FORCE_DWORD}
// 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_MASK = $70000000;
{$EXTERNALSYM D3DSP_REGTYPE_MASK}
type
_D3DSHADER_PARAM_REGISTER_TYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord;
{$EXTERNALSYM _D3DSHADER_PARAM_REGISTER_TYPE}
D3DSHADER_PARAM_REGISTER_TYPE = _D3DSHADER_PARAM_REGISTER_TYPE;
{$EXTERNALSYM D3DSHADER_PARAM_REGISTER_TYPE}
TD3DShaderParamRegisterType = _D3DSHADER_PARAM_REGISTER_TYPE;
const
D3DSPR_TEMP = 0 shl D3DSP_REGTYPE_SHIFT; // Temporary Register File
{$EXTERNALSYM D3DSPR_TEMP}
D3DSPR_INPUT = 1 shl D3DSP_REGTYPE_SHIFT; // Input Register File
{$EXTERNALSYM D3DSPR_INPUT}
D3DSPR_CONST = 2 shl D3DSP_REGTYPE_SHIFT; // Constant Register File
{$EXTERNALSYM D3DSPR_CONST}
D3DSPR_ADDR = 3 shl D3DSP_REGTYPE_SHIFT; // Address Register (VS)
{$EXTERNALSYM D3DSPR_ADDR}
D3DSPR_TEXTURE = 3 shl D3DSP_REGTYPE_SHIFT; // Texture Register File (PS)
{$EXTERNALSYM D3DSPR_TEXTURE}
D3DSPR_RASTOUT = 4 shl D3DSP_REGTYPE_SHIFT; // Rasterizer Register File
{$EXTERNALSYM D3DSPR_RASTOUT}
D3DSPR_ATTROUT = 5 shl D3DSP_REGTYPE_SHIFT; // Attribute Output Register File
{$EXTERNALSYM D3DSPR_ATTROUT}
D3DSPR_TEXCRDOUT = 6 shl D3DSP_REGTYPE_SHIFT; // Texture Coordinate Output Register File
{$EXTERNALSYM D3DSPR_TEXCRDOUT}
D3DSPR_FORCE_DWORD = $7fffffff; // force 32-bit size enum
{$EXTERNALSYM D3DSPR_FORCE_DWORD}
type
// 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; // Relative to register A0
{$EXTERNALSYM D3DVS_ADDRMODE_RELATIVE}
D3DVS_ADDRMODE_FORCE_DWORD = $7fffffff; // force 32-bit size enum
{$EXTERNALSYM D3DVS_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_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;
{$EXTERNALSYM D3DPS_VERSION}
// vertex shader version token
//#define D3DVS_VERSION(_Major,_Minor) (0xFFFE0000|((_Major)<<8)|(_Minor))
function D3DVS_VERSION(_Major, _Minor: DWord): DWord;
{$EXTERNALSYM D3DVS_VERSION}
// extract major/minor from version cap
//#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF)
function D3DSHADER_VERSION_MAJOR(_Version: DWord): DWord;
{$EXTERNALSYM D3DSHADER_VERSION_MAJOR}
//#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF)
function D3DSHADER_VERSION_MINOR(_Version: DWord): DWord;
{$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;
{$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_INTERPOLATE {= 2}
);
{$EXTERNALSYM _D3DBASISTYPE}
D3DBASISTYPE = _D3DBASISTYPE;
{$EXTERNALSYM D3DBASISTYPE}
TD3DBasisType = _D3DBASISTYPE;
_D3DORDERTYPE = (
{$IFNDEF COMPILER6_UP}
D3DORDER_invalid_0 {= 0},
D3DORDER_LINEAR {= 1},
D3DORDER_QUADRATIC {= 2},
D3DORDER_CUBIC {= 3},
D3DORDER_invalid_4 {= 4},
D3DORDER_QUINTIC {= 5}
{$ELSE}
D3DORDER_LINEAR = 1,
D3DORDER_QUADRATIC = 2,
D3DORDER_CUBIC = 3,
D3DORDER_QUINTIC = 5
{$ENDIF}
);
{$EXTERNALSYM _D3DORDERTYPE}
D3DORDERTYPE = _D3DORDERTYPE;
{$EXTERNALSYM D3DORDERTYPE}
TD3DOrderType = _D3DORDERTYPE;
_D3DPATCHEDGESTYLE = (
D3DPATCHEDGE_DISCRETE {= 0},
D3DPATCHEDGE_CONTINUOUS {= 1}
);
{$EXTERNALSYM _D3DPATCHEDGESTYLE}
D3DPATCHEDGESTYLE = _D3DPATCHEDGESTYLE;
{$EXTERNALSYM D3DPATCHEDGESTYLE}
TD3DPatchEdgeStyle = _D3DPATCHEDGESTYLE;
_D3DSTATEBLOCKTYPE = (
{$IFNDEF COMPILER6_UP}
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;
{$EXTERNALSYM D3DFVF_TEXCOORDSIZE3}
//#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2)
function D3DFVF_TEXCOORDSIZE2(CoordIndex: DWord): DWord;
{$EXTERNALSYM D3DFVF_TEXCOORDSIZE2}
//#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE4(CoordIndex: DWord): DWord;
{$EXTERNALSYM D3DFVF_TEXCOORDSIZE4}
//#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE1(CoordIndex: DWord): DWord;