From 65ddad359ed3b9b739215ec89a7645455ae10dce Mon Sep 17 00:00:00 2001 From: brunzelchen Date: Tue, 5 Oct 2010 18:28:42 +0000 Subject: - added webcam support - faster program start - faster sorting (mergesort) - sync lyrics to music - some new backgrounds and credits graphics (thx to MezzoX) - own thread for video decoding - finished 6-Player-on-one-screen-mode - changqed player-colors - fixed some bugs... git-svn-id: svn://svn.code.sf.net/p/ultrastardx/svn/branches/1.0.1 Challenge MOD@2637 b956fd51-792f-4845-bead-9b4dfca2ff2c --- Game/Code/lib/DSPack/DirectX9/Direct3D9.pas | 4943 +++++++++++++++++++++++++++ 1 file changed, 4943 insertions(+) create mode 100644 Game/Code/lib/DSPack/DirectX9/Direct3D9.pas (limited to 'Game/Code/lib/DSPack/DirectX9/Direct3D9.pas') diff --git a/Game/Code/lib/DSPack/DirectX9/Direct3D9.pas b/Game/Code/lib/DSPack/DirectX9/Direct3D9.pas new file mode 100644 index 00000000..fa50c448 --- /dev/null +++ b/Game/Code/lib/DSPack/DirectX9/Direct3D9.pas @@ -0,0 +1,4943 @@ +{******************************************************************************} +{* *} +{* Copyright (C) Microsoft Corporation. All Rights Reserved. *} +{* *} +{* Files: d3d9types.h d3d9caps.h d3d9.h *} +{* Content: Direct3D9 include files *} +{* *} +{* DirectX 9.0 Delphi adaptation by Alexey Barkovoy *} +{* E-Mail: clootie@reactor.ru *} +{* *} +{* Modified: 26-Jan-2003 *} +{* *} +{* Latest version can be downloaded from: *} +{* http://clootie.narod.ru/delphi *} +{* *} +{* This File contains only Direct3D 9.0 definitions. *} +{* If you want to use previous versions - use Direct3D.pas and Direct3D8.pas *} +{* *} +{******************************************************************************} +{ } +{ 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} + +{$NOINCLUDE DXTypes} +(*$HPPEMIT '#include "d3d9.h"' *) +(*$HPPEMIT '#include "d3d9types.h"' *) +(*$HPPEMIT '#include "d3d9caps.h"' *) + +uses Windows, DXTypes; + +///// Helper constants (for use in SetRenderState) ///// +const + iTrue = DWORD(True); + iFalse = DWORD(False); + + + + +(*==========================================================================; + * + * Copyright (C) Microsoft Corporation. All Rights Reserved. + * + * File: d3d9types.h + * Content: Direct3D capabilities include file + * + ***************************************************************************) + +type + // D3DCOLOR is equivalent to D3DFMT_A8R8G8B8 + D3DCOLOR = DXTypes.D3DCOLOR; + {$EXTERNALSYM D3DCOLOR} + TD3DColor = DXTypes.TD3DColor; + {$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} + +// #define D3DCOLOR_XYUV(y,u,v) D3DCOLOR_ARGB(0xff,y,u,v) +function D3DCOLOR_XYUV(y,u,v: DWord): TD3DColor; +{$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; +{$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; +{$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; + + 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 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; + + 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} + +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 = ( + 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; +{$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_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 COMPILER6_UP} +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 COMPILER6_UP} + 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} + +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 COMPILER6_UP} + 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} + + +//--------------------------------------------------------------------- +// +// 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 COMPILER6_UP} + 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 COMPILER6_UP} +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 = ( + {$IFDEF BCB} + D3DSTT_DUMMY + {$ELSE} + 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 + {$ENDIF} + ); + {$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 COMPILER6_UP} +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 COMPILER6_UP} + 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; +{$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)<=400) + D3DCURSORCAPS_COLOR = $00000001; + {$EXTERNALSYM D3DCURSORCAPS_COLOR} + // Driver supports HW cursor also in low-res modes(height < 400) + D3DCURSORCAPS_LOWRES = $00000002; + {$EXTERNALSYM D3DCURSORCAPS_LOWRES} + + // + // DevCaps + // + D3DDEVCAPS_EXECUTESYSTEMMEMORY = $00000010; { Device can use execute buffers from system memory } + {$EXTERNALSYM D3DDEVCAPS_EXECUTESYSTEMMEMORY} + D3DDEVCAPS_EXECUTEVIDEOMEMORY = $00000020; { Device can use execute buffers from video memory } + {$EXTERNALSYM D3DDEVCAPS_EXECUTEVIDEOMEMORY} + D3DDEVCAPS_TLVERTEXSYSTEMMEMORY = $00000040; { Device can use TL buffers from system memory } + {$EXTERNALSYM D3DDEVCAPS_TLVERTEXSYSTEMMEMORY} + D3DDEVCAPS_TLVERTEXVIDEOMEMORY = $00000080; { Device can use TL buffers from video memory } + {$EXTERNALSYM D3DDEVCAPS_TLVERTEXVIDEOMEMORY} + D3DDEVCAPS_TEXTURESYSTEMMEMORY = $00000100; { Device can texture from system memory } + {$EXTERNALSYM D3DDEVCAPS_TEXTURESYSTEMMEMORY} + D3DDEVCAPS_TEXTUREVIDEOMEMORY = $00000200; { Device can texture from device memory } + {$EXTERNALSYM D3DDEVCAPS_TEXTUREVIDEOMEMORY} + D3DDEVCAPS_DRAWPRIMTLVERTEX = $00000400; { Device can draw TLVERTEX primitives } + {$EXTERNALSYM D3DDEVCAPS_DRAWPRIMTLVERTEX} + D3DDEVCAPS_CANRENDERAFTERFLIP = $00000800; { Device can render without waiting for flip to complete } + {$EXTERNALSYM D3DDEVCAPS_CANRENDERAFTERFLIP} + D3DDEVCAPS_TEXTURENONLOCALVIDMEM = $00001000; { Device can texture from nonlocal video memory } + {$EXTERNALSYM D3DDEVCAPS_TEXTURENONLOCALVIDMEM} + D3DDEVCAPS_DRAWPRIMITIVES2 = $00002000; { Device can support DrawPrimitives2 } + {$EXTERNALSYM D3DDEVCAPS_DRAWPRIMITIVES2} + D3DDEVCAPS_SEPARATETEXTUREMEMORIES = $00004000; { Device is texturing from separate memory pools } + {$EXTERNALSYM D3DDEVCAPS_SEPARATETEXTUREMEMORIES} + D3DDEVCAPS_DRAWPRIMITIVES2EX = $00008000; { Device can support Extended DrawPrimitives2 i.e. DX7 compliant driver } + {$EXTERNALSYM D3DDEVCAPS_DRAWPRIMITIVES2EX} + D3DDEVCAPS_HWTRANSFORMANDLIGHT = $00010000; { Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also } + {$EXTERNALSYM D3DDEVCAPS_HWTRANSFORMANDLIGHT} + D3DDEVCAPS_CANBLTSYSTONONLOCAL = $00020000; { Device supports a Tex Blt from system memory to non-local vidmem } + {$EXTERNALSYM D3DDEVCAPS_CANBLTSYSTONONLOCAL} + D3DDEVCAPS_HWRASTERIZATION = $00080000; { Device has HW acceleration for rasterization } + {$EXTERNALSYM D3DDEVCAPS_HWRASTERIZATION} + D3DDEVCAPS_PUREDEVICE = $00100000; { Device supports D3DCREATE_PUREDEVICE } + {$EXTERNALSYM D3DDEVCAPS_PUREDEVICE} + D3DDEVCAPS_QUINTICRTPATCHES = $00200000; { Device supports quintic Beziers and BSplines } + {$EXTERNALSYM D3DDEVCAPS_QUINTICRTPATCHES} + D3DDEVCAPS_RTPATCHES = $00400000; { Device supports Rect and Tri patches } + {$EXTERNALSYM D3DDEVCAPS_RTPATCHES} + D3DDEVCAPS_RTPATCHHANDLEZERO = $00800000; { Indicates that RT Patches may be drawn efficiently using handle 0 } + {$EXTERNALSYM D3DDEVCAPS_RTPATCHHANDLEZERO} + D3DDEVCAPS_NPATCHES = $01000000; { Device supports N-Patches } + {$EXTERNALSYM D3DDEVCAPS_NPATCHES} + + // + // PrimitiveMiscCaps + // + D3DPMISCCAPS_MASKZ = $00000002; + {$EXTERNALSYM D3DPMISCCAPS_MASKZ} + D3DPMISCCAPS_CULLNONE = $00000010; + {$EXTERNALSYM D3DPMISCCAPS_CULLNONE} + D3DPMISCCAPS_CULLCW = $00000020; + {$EXTERNALSYM D3DPMISCCAPS_CULLCW} + D3DPMISCCAPS_CULLCCW = $00000040; + {$EXTERNALSYM D3DPMISCCAPS_CULLCCW} + D3DPMISCCAPS_COLORWRITEENABLE = $00000080; + {$EXTERNALSYM D3DPMISCCAPS_COLORWRITEENABLE} + D3DPMISCCAPS_CLIPPLANESCALEDPOINTS = $00000100; { Device correctly clips scaled points to clip planes } + {$EXTERNALSYM D3DPMISCCAPS_CLIPPLANESCALEDPOINTS} + D3DPMISCCAPS_CLIPTLVERTS = $00000200; { device will clip post-transformed vertex primitives } + {$EXTERNALSYM D3DPMISCCAPS_CLIPTLVERTS} + D3DPMISCCAPS_TSSARGTEMP = $00000400; { device supports D3DTA_TEMP for temporary register } + {$EXTERNALSYM D3DPMISCCAPS_TSSARGTEMP} + D3DPMISCCAPS_BLENDOP = $00000800; { device supports D3DRS_BLENDOP } + {$EXTERNALSYM D3DPMISCCAPS_BLENDOP} + D3DPMISCCAPS_NULLREFERENCE = $00001000; { Reference Device that doesnt render } + {$EXTERNALSYM D3DPMISCCAPS_NULLREFERENCE} + D3DPMISCCAPS_INDEPENDENTWRITEMASKS = $00004000; { Device supports independent write masks for MET or MRT } + {$EXTERNALSYM D3DPMISCCAPS_INDEPENDENTWRITEMASKS} + D3DPMISCCAPS_PERSTAGECONSTANT = $00008000; { Device supports per-stage constants } + {$EXTERNALSYM D3DPMISCCAPS_PERSTAGECONSTANT} + D3DPMISCCAPS_FOGANDSPECULARALPHA = $00010000; { Device supports separate fog and specular alpha (many devices + use the specular alpha channel to store fog factor) } + {$EXTERNALSYM D3DPMISCCAPS_FOGANDSPECULARALPHA} + D3DPMISCCAPS_SEPARATEALPHABLEND = $00020000; { Device supports separate blend settings for the alpha channel } + {$EXTERNALSYM D3DPMISCCAPS_SEPARATEALPHABLEND} + D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS = $00040000; { Device supports different bit depths for MRT } + {$EXTERNALSYM D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS} + D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING = $00080000; { Device supports post-pixel shader operations for MRT } + {$EXTERNALSYM D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING} + D3DPMISCCAPS_FOGVERTEXCLAMPED = $00100000; { Device clamps fog blend factor per vertex } + {$EXTERNALSYM D3DPMISCCAPS_FOGVERTEXCLAMPED} + + // + // LineCaps + // + D3DLINECAPS_TEXTURE = $00000001; + {$EXTERNALSYM D3DLINECAPS_TEXTURE} + D3DLINECAPS_ZTEST = $00000002; + {$EXTERNALSYM D3DLINECAPS_ZTEST} + D3DLINECAPS_BLEND = $00000004; + {$EXTERNALSYM D3DLINECAPS_BLEND} + D3DLINECAPS_ALPHACMP = $00000008; + {$EXTERNALSYM D3DLINECAPS_ALPHACMP} + D3DLINECAPS_FOG = $00000010; + {$EXTERNALSYM D3DLINECAPS_FOG} + D3DLINECAPS_ANTIALIAS = $00000020; + {$EXTERNALSYM D3DLINECAPS_ANTIALIAS} + + // + // RasterCaps + // + D3DPRASTERCAPS_DITHER = $00000001; + {$EXTERNALSYM D3DPRASTERCAPS_DITHER} + D3DPRASTERCAPS_ZTEST = $00000010; + {$EXTERNALSYM D3DPRASTERCAPS_ZTEST} + D3DPRASTERCAPS_FOGVERTEX = $00000080; + {$EXTERNALSYM D3DPRASTERCAPS_FOGVERTEX} + D3DPRASTERCAPS_FOGTABLE = $00000100; + {$EXTERNALSYM D3DPRASTERCAPS_FOGTABLE} + D3DPRASTERCAPS_MIPMAPLODBIAS = $00002000; + {$EXTERNALSYM D3DPRASTERCAPS_MIPMAPLODBIAS} + D3DPRASTERCAPS_ZBUFFERLESSHSR = $00008000; + {$EXTERNALSYM D3DPRASTERCAPS_ZBUFFERLESSHSR} + D3DPRASTERCAPS_FOGRANGE = $00010000; + {$EXTERNALSYM D3DPRASTERCAPS_FOGRANGE} + D3DPRASTERCAPS_ANISOTROPY = $00020000; + {$EXTERNALSYM D3DPRASTERCAPS_ANISOTROPY} + D3DPRASTERCAPS_WBUFFER = $00040000; + {$EXTERNALSYM D3DPRASTERCAPS_WBUFFER} + D3DPRASTERCAPS_WFOG = $00100000; + {$EXTERNALSYM D3DPRASTERCAPS_WFOG} + D3DPRASTERCAPS_ZFOG = $00200000; + {$EXTERNALSYM D3DPRASTERCAPS_ZFOG} + D3DPRASTERCAPS_COLORPERSPECTIVE = $00400000; { Device iterates colors perspective correct } + {$EXTERNALSYM D3DPRASTERCAPS_COLORPERSPECTIVE} + D3DPRASTERCAPS_SCISSORTEST = $01000000; + {$EXTERNALSYM D3DPRASTERCAPS_SCISSORTEST} + D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS = $02000000; + {$EXTERNALSYM D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS} + D3DPRASTERCAPS_DEPTHBIAS = $04000000; + {$EXTERNALSYM D3DPRASTERCAPS_DEPTHBIAS} + D3DPRASTERCAPS_MULTISAMPLE_TOGGLE = $08000000; + {$EXTERNALSYM D3DPRASTERCAPS_MULTISAMPLE_TOGGLE} + + // + // ZCmpCaps, AlphaCmpCaps + // + D3DPCMPCAPS_NEVER = $00000001; + {$EXTERNALSYM D3DPCMPCAPS_NEVER} + D3DPCMPCAPS_LESS = $00000002; + {$EXTERNALSYM D3DPCMPCAPS_LESS} + D3DPCMPCAPS_EQUAL = $00000004; + {$EXTERNALSYM D3DPCMPCAPS_EQUAL} + D3DPCMPCAPS_LESSEQUAL = $00000008; + {$EXTERNALSYM D3DPCMPCAPS_LESSEQUAL} + D3DPCMPCAPS_GREATER = $00000010; + {$EXTERNALSYM D3DPCMPCAPS_GREATER} + D3DPCMPCAPS_NOTEQUAL = $00000020; + {$EXTERNALSYM D3DPCMPCAPS_NOTEQUAL} + D3DPCMPCAPS_GREATEREQUAL = $00000040; + {$EXTERNALSYM D3DPCMPCAPS_GREATEREQUAL} + D3DPCMPCAPS_ALWAYS = $00000080; + {$EXTERNALSYM D3DPCMPCAPS_ALWAYS} + + // + // SourceBlendCaps, DestBlendCaps + // + D3DPBLENDCAPS_ZERO = $00000001; + {$EXTERNALSYM D3DPBLENDCAPS_ZERO} + D3DPBLENDCAPS_ONE = $00000002; + {$EXTERNALSYM D3DPBLENDCAPS_ONE} + D3DPBLENDCAPS_SRCCOLOR = $00000004; + {$EXTERNALSYM D3DPBLENDCAPS_SRCCOLOR} + D3DPBLENDCAPS_INVSRCCOLOR = $00000008; + {$EXTERNALSYM D3DPBLENDCAPS_INVSRCCOLOR} + D3DPBLENDCAPS_SRCALPHA = $00000010; + {$EXTERNALSYM D3DPBLENDCAPS_SRCALPHA} + D3DPBLENDCAPS_INVSRCALPHA = $00000020; + {$EXTERNALSYM D3DPBLENDCAPS_INVSRCALPHA} + D3DPBLENDCAPS_DESTALPHA = $00000040; + {$EXTERNALSYM D3DPBLENDCAPS_DESTALPHA} + D3DPBLENDCAPS_INVDESTALPHA = $00000080; + {$EXTERNALSYM D3DPBLENDCAPS_INVDESTALPHA} + D3DPBLENDCAPS_DESTCOLOR = $00000100; + {$EXTERNALSYM D3DPBLENDCAPS_DESTCOLOR} + D3DPBLENDCAPS_INVDESTCOLOR = $00000200; + {$EXTERNALSYM D3DPBLENDCAPS_INVDESTCOLOR} + D3DPBLENDCAPS_SRCALPHASAT = $00000400; + {$EXTERNALSYM D3DPBLENDCAPS_SRCALPHASAT} + D3DPBLENDCAPS_BOTHSRCALPHA = $00000800; + {$EXTERNALSYM D3DPBLENDCAPS_BOTHSRCALPHA} + D3DPBLENDCAPS_BOTHINVSRCALPHA = $00001000; + {$EXTERNALSYM D3DPBLENDCAPS_BOTHINVSRCALPHA} + D3DPBLENDCAPS_BLENDFACTOR = $00002000; { Supports both D3DBLEND_BLENDFACTOR and D3DBLEND_INVBLENDFACTOR } + {$EXTERNALSYM D3DPBLENDCAPS_BLENDFACTOR} + + // + // ShadeCaps + // + D3DPSHADECAPS_COLORGOURAUDRGB = $00000008; + {$EXTERNALSYM D3DPSHADECAPS_COLORGOURAUDRGB} + D3DPSHADECAPS_SPECULARGOURAUDRGB = $00000200; + {$EXTERNALSYM D3DPSHADECAPS_SPECULARGOURAUDRGB} + D3DPSHADECAPS_ALPHAGOURAUDBLEND = $00004000; + {$EXTERNALSYM D3DPSHADECAPS_ALPHAGOURAUDBLEND} + D3DPSHADECAPS_FOGGOURAUD = $00080000; + {$EXTERNALSYM D3DPSHADECAPS_FOGGOURAUD} + + // + // TextureCaps + // + D3DPTEXTURECAPS_PERSPECTIVE = $00000001; { Perspective-correct texturing is supported } + {$EXTERNALSYM D3DPTEXTURECAPS_PERSPECTIVE} + D3DPTEXTURECAPS_POW2 = $00000002; { Power-of-2 texture dimensions are required - applies to non-Cube/Volume textures only. } + {$EXTERNALSYM D3DPTEXTURECAPS_POW2} + D3DPTEXTURECAPS_ALPHA = $00000004; { Alpha in texture pixels is supported } + {$EXTERNALSYM D3DPTEXTURECAPS_ALPHA} + D3DPTEXTURECAPS_SQUAREONLY = $00000020; { Only square textures are supported } + {$EXTERNALSYM D3DPTEXTURECAPS_SQUAREONLY} + D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE = $00000040; { Texture indices are not scaled by the texture size prior to interpolation } + {$EXTERNALSYM D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE} + D3DPTEXTURECAPS_ALPHAPALETTE = $00000080; { Device can draw alpha from texture palettes } + {$EXTERNALSYM D3DPTEXTURECAPS_ALPHAPALETTE} + // Device can use non-POW2 textures if: + // 1) D3DTEXTURE_ADDRESS is set to CLAMP for this texture's stage + // 2) D3DRS_WRAP(N) is zero for this texture's coordinates + // 3) mip mapping is not enabled (use magnification filter only) + D3DPTEXTURECAPS_NONPOW2CONDITIONAL = $00000100; + {$EXTERNALSYM D3DPTEXTURECAPS_NONPOW2CONDITIONAL} + D3DPTEXTURECAPS_PROJECTED = $00000400; { Device can do D3DTTFF_PROJECTED } + {$EXTERNALSYM D3DPTEXTURECAPS_PROJECTED} + D3DPTEXTURECAPS_CUBEMAP = $00000800; { Device can do cubemap textures } + {$EXTERNALSYM D3DPTEXTURECAPS_CUBEMAP} + D3DPTEXTURECAPS_VOLUMEMAP = $00002000; { Device can do volume textures } + {$EXTERNALSYM D3DPTEXTURECAPS_VOLUMEMAP} + D3DPTEXTURECAPS_MIPMAP = $00004000; { Device can do mipmapped textures } + {$EXTERNALSYM D3DPTEXTURECAPS_MIPMAP} + D3DPTEXTURECAPS_MIPVOLUMEMAP = $00008000; { Device can do mipmapped volume textures } + {$EXTERNALSYM D3DPTEXTURECAPS_MIPVOLUMEMAP} + D3DPTEXTURECAPS_MIPCUBEMAP = $00010000; { Device can do mipmapped cube maps } + {$EXTERNALSYM D3DPTEXTURECAPS_MIPCUBEMAP} + D3DPTEXTURECAPS_CUBEMAP_POW2 = $00020000; { Device requires that cubemaps be power-of-2 dimension } + {$EXTERNALSYM D3DPTEXTURECAPS_CUBEMAP_POW2} + D3DPTEXTURECAPS_VOLUMEMAP_POW2 = $00040000; { Device requires that volume maps be power-of-2 dimension } + {$EXTERNALSYM D3DPTEXTURECAPS_VOLUMEMAP_POW2} + D3DPTEXTURECAPS_NOPROJECTEDBUMPENV = $00200000; { Device does not support projected bump env lookup operation + in programmable and fixed function pixel shaders } + {$EXTERNALSYM D3DPTEXTURECAPS_NOPROJECTEDBUMPENV} + + // + // TextureFilterCaps, StretchRectFilterCaps + // + D3DPTFILTERCAPS_MINFPOINT = $00000100; { Min Filter } + {$EXTERNALSYM D3DPTFILTERCAPS_MINFPOINT} + D3DPTFILTERCAPS_MINFLINEAR = $00000200; + {$EXTERNALSYM D3DPTFILTERCAPS_MINFLINEAR} + D3DPTFILTERCAPS_MINFANISOTROPIC = $00000400; + {$EXTERNALSYM D3DPTFILTERCAPS_MINFANISOTROPIC} + D3DPTFILTERCAPS_MINFPYRAMIDALQUAD = $00000800; + {$EXTERNALSYM D3DPTFILTERCAPS_MINFPYRAMIDALQUAD} + D3DPTFILTERCAPS_MINFGAUSSIANQUAD = $00001000; + {$EXTERNALSYM D3DPTFILTERCAPS_MINFGAUSSIANQUAD} + D3DPTFILTERCAPS_MIPFPOINT = $00010000; { Mip Filter } + {$EXTERNALSYM D3DPTFILTERCAPS_MIPFPOINT} + D3DPTFILTERCAPS_MIPFLINEAR = $00020000; + {$EXTERNALSYM D3DPTFILTERCAPS_MIPFLINEAR} + D3DPTFILTERCAPS_MAGFPOINT = $01000000; { Mag Filter } + {$EXTERNALSYM D3DPTFILTERCAPS_MAGFPOINT} + D3DPTFILTERCAPS_MAGFLINEAR = $02000000; + {$EXTERNALSYM D3DPTFILTERCAPS_MAGFLINEAR} + D3DPTFILTERCAPS_MAGFANISOTROPIC = $04000000; + {$EXTERNALSYM D3DPTFILTERCAPS_MAGFANISOTROPIC} + D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD = $08000000; + {$EXTERNALSYM D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD} + D3DPTFILTERCAPS_MAGFGAUSSIANQUAD = $10000000; + {$EXTERNALSYM D3DPTFILTERCAPS_MAGFGAUSSIANQUAD} + + // + // TextureAddressCaps + // + D3DPTADDRESSCAPS_WRAP = $00000001; + {$EXTERNALSYM D3DPTADDRESSCAPS_WRAP} + D3DPTADDRESSCAPS_MIRROR = $00000002; + {$EXTERNALSYM D3DPTADDRESSCAPS_MIRROR} + D3DPTADDRESSCAPS_CLAMP = $00000004; + {$EXTERNALSYM D3DPTADDRESSCAPS_CLAMP} + D3DPTADDRESSCAPS_BORDER = $00000008; + {$EXTERNALSYM D3DPTADDRESSCAPS_BORDER} + D3DPTADDRESSCAPS_INDEPENDENTUV = $00000010; + {$EXTERNALSYM D3DPTADDRESSCAPS_INDEPENDENTUV} + D3DPTADDRESSCAPS_MIRRORONCE = $00000020; + {$EXTERNALSYM D3DPTADDRESSCAPS_MIRRORONCE} + + // + // StencilCaps + // + D3DSTENCILCAPS_KEEP = $00000001; + {$EXTERNALSYM D3DSTENCILCAPS_KEEP} + D3DSTENCILCAPS_ZERO = $00000002; + {$EXTERNALSYM D3DSTENCILCAPS_ZERO} + D3DSTENCILCAPS_REPLACE = $00000004; + {$EXTERNALSYM D3DSTENCILCAPS_REPLACE} + D3DSTENCILCAPS_INCRSAT = $00000008; + {$EXTERNALSYM D3DSTENCILCAPS_INCRSAT} + D3DSTENCILCAPS_DECRSAT = $00000010; + {$EXTERNALSYM D3DSTENCILCAPS_DECRSAT} + D3DSTENCILCAPS_INVERT = $00000020; + {$EXTERNALSYM D3DSTENCILCAPS_INVERT} + D3DSTENCILCAPS_INCR = $00000040; + {$EXTERNALSYM D3DSTENCILCAPS_INCR} + D3DSTENCILCAPS_DECR = $00000080; + {$EXTERNALSYM D3DSTENCILCAPS_DECR} + D3DSTENCILCAPS_TWOSIDED = $00000100; + {$EXTERNALSYM D3DSTENCILCAPS_TWOSIDED} + + // + // TextureOpCaps + // + D3DTEXOPCAPS_DISABLE = $00000001; + {$EXTERNALSYM D3DTEXOPCAPS_DISABLE} + D3DTEXOPCAPS_SELECTARG1 = $00000002; + {$EXTERNALSYM D3DTEXOPCAPS_SELECTARG1} + D3DTEXOPCAPS_SELECTARG2 = $00000004; + {$EXTERNALSYM D3DTEXOPCAPS_SELECTARG2} + D3DTEXOPCAPS_MODULATE = $00000008; + {$EXTERNALSYM D3DTEXOPCAPS_MODULATE} + D3DTEXOPCAPS_MODULATE2X = $00000010; + {$EXTERNALSYM D3DTEXOPCAPS_MODULATE2X} + D3DTEXOPCAPS_MODULATE4X = $00000020; + {$EXTERNALSYM D3DTEXOPCAPS_MODULATE4X} + D3DTEXOPCAPS_ADD = $00000040; + {$EXTERNALSYM D3DTEXOPCAPS_ADD} + D3DTEXOPCAPS_ADDSIGNED = $00000080; + {$EXTERNALSYM D3DTEXOPCAPS_ADDSIGNED} + D3DTEXOPCAPS_ADDSIGNED2X = $00000100; + {$EXTERNALSYM D3DTEXOPCAPS_ADDSIGNED2X} + D3DTEXOPCAPS_SUBTRACT = $00000200; + {$EXTERNALSYM D3DTEXOPCAPS_SUBTRACT} + D3DTEXOPCAPS_ADDSMOOTH = $00000400; + {$EXTERNALSYM D3DTEXOPCAPS_ADDSMOOTH} + D3DTEXOPCAPS_BLENDDIFFUSEALPHA = $00000800; + {$EXTERNALSYM D3DTEXOPCAPS_BLENDDIFFUSEALPHA} + D3DTEXOPCAPS_BLENDTEXTUREALPHA = $00001000; + {$EXTERNALSYM D3DTEXOPCAPS_BLENDTEXTUREALPHA} + D3DTEXOPCAPS_BLENDFACTORALPHA = $00002000; + {$EXTERNALSYM D3DTEXOPCAPS_BLENDFACTORALPHA} + D3DTEXOPCAPS_BLENDTEXTUREALPHAPM = $00004000; + {$EXTERNALSYM D3DTEXOPCAPS_BLENDTEXTUREALPHAPM} + D3DTEXOPCAPS_BLENDCURRENTALPHA = $00008000; + {$EXTERNALSYM D3DTEXOPCAPS_BLENDCURRENTALPHA} + D3DTEXOPCAPS_PREMODULATE = $00010000; + {$EXTERNALSYM D3DTEXOPCAPS_PREMODULATE} + D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR = $00020000; + {$EXTERNALSYM D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR} + D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA = $00040000; + {$EXTERNALSYM D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA} + D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR = $00080000; + {$EXTERNALSYM D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR} + D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA = $00100000; + {$EXTERNALSYM D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA} + D3DTEXOPCAPS_BUMPENVMAP = $00200000; + {$EXTERNALSYM D3DTEXOPCAPS_BUMPENVMAP} + D3DTEXOPCAPS_BUMPENVMAPLUMINANCE = $00400000; + {$EXTERNALSYM D3DTEXOPCAPS_BUMPENVMAPLUMINANCE} + D3DTEXOPCAPS_DOTPRODUCT3 = $00800000; + {$EXTERNALSYM D3DTEXOPCAPS_DOTPRODUCT3} + D3DTEXOPCAPS_MULTIPLYADD = $01000000; + {$EXTERNALSYM D3DTEXOPCAPS_MULTIPLYADD} + D3DTEXOPCAPS_LERP = $02000000; + {$EXTERNALSYM D3DTEXOPCAPS_LERP} + + // + // FVFCaps + // + D3DFVFCAPS_TEXCOORDCOUNTMASK = $0000ffff; { mask for texture coordinate count field } + {$EXTERNALSYM D3DFVFCAPS_TEXCOORDCOUNTMASK} + D3DFVFCAPS_DONOTSTRIPELEMENTS = $00080000; { Device prefers that vertex elements not be stripped } + {$EXTERNALSYM D3DFVFCAPS_DONOTSTRIPELEMENTS} + D3DFVFCAPS_PSIZE = $00100000; { Device can receive point size } + {$EXTERNALSYM D3DFVFCAPS_PSIZE} + + // + // VertexProcessingCaps + // + D3DVTXPCAPS_TEXGEN = $00000001; { device can do texgen } + {$EXTERNALSYM D3DVTXPCAPS_TEXGEN} + D3DVTXPCAPS_MATERIALSOURCE7 = $00000002; { device can do DX7-level colormaterialsource ops } + {$EXTERNALSYM D3DVTXPCAPS_MATERIALSOURCE7} + D3DVTXPCAPS_DIRECTIONALLIGHTS = $00000008; { device can do directional lights } + {$EXTERNALSYM D3DVTXPCAPS_DIRECTIONALLIGHTS} + D3DVTXPCAPS_POSITIONALLIGHTS = $00000010; { device can do positional lights (includes point and spot) } + {$EXTERNALSYM D3DVTXPCAPS_POSITIONALLIGHTS} + D3DVTXPCAPS_LOCALVIEWER = $00000020; { device can do local viewer } + {$EXTERNALSYM D3DVTXPCAPS_LOCALVIEWER} + D3DVTXPCAPS_TWEENING = $00000040; { device can do vertex tweening } + {$EXTERNALSYM D3DVTXPCAPS_TWEENING} + D3DVTXPCAPS_TEXGEN_SPHEREMAP = $00000100; { device supports D3DTSS_TCI_SPHEREMAP } + {$EXTERNALSYM D3DVTXPCAPS_TEXGEN_SPHEREMAP} + D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER = $00000200; { device does not support TexGen in non-local + viewer mode } + {$EXTERNALSYM D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER} + + // + // DevCaps2 + // + D3DDEVCAPS2_STREAMOFFSET = $00000001; { Device supports offsets in streams. Must be set by DX9 drivers } + {$EXTERNALSYM D3DDEVCAPS2_STREAMOFFSET} + D3DDEVCAPS2_DMAPNPATCH = $00000002; { Device supports displacement maps for N-Patches} + {$EXTERNALSYM D3DDEVCAPS2_DMAPNPATCH} + D3DDEVCAPS2_ADAPTIVETESSRTPATCH = $00000004; { Device supports adaptive tesselation of RT-patches} + {$EXTERNALSYM D3DDEVCAPS2_ADAPTIVETESSRTPATCH} + D3DDEVCAPS2_ADAPTIVETESSNPATCH = $00000008; { Device supports adaptive tesselation of N-patches} + {$EXTERNALSYM D3DDEVCAPS2_ADAPTIVETESSNPATCH} + D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES = $00000010; { Device supports StretchRect calls with a texture as the source} + {$EXTERNALSYM D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES} + D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH = $00000020; { Device supports presampled displacement maps for N-Patches } + {$EXTERNALSYM D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH} + D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET = $00000040; { Vertex elements in a vertex declaration can share the same stream offset } + {$EXTERNALSYM D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET} + + // + // DeclTypes + // + D3DDTCAPS_UBYTE4 = $00000001; + {$EXTERNALSYM D3DDTCAPS_UBYTE4} + D3DDTCAPS_UBYTE4N = $00000002; + {$EXTERNALSYM D3DDTCAPS_UBYTE4N} + D3DDTCAPS_SHORT2N = $00000004; + {$EXTERNALSYM D3DDTCAPS_SHORT2N} + D3DDTCAPS_SHORT4N = $00000008; + {$EXTERNALSYM D3DDTCAPS_SHORT4N} + D3DDTCAPS_USHORT2N = $00000010; + {$EXTERNALSYM D3DDTCAPS_USHORT2N} + D3DDTCAPS_USHORT4N = $00000020; + {$EXTERNALSYM D3DDTCAPS_USHORT4N} + D3DDTCAPS_UDEC3 = $00000040; + {$EXTERNALSYM D3DDTCAPS_UDEC3} + D3DDTCAPS_DEC3N = $00000080; + {$EXTERNALSYM D3DDTCAPS_DEC3N} + D3DDTCAPS_FLOAT16_2 = $00000100; + {$EXTERNALSYM D3DDTCAPS_FLOAT16_2} + D3DDTCAPS_FLOAT16_4 = $00000200; + {$EXTERNALSYM D3DDTCAPS_FLOAT16_4} + + + + +(*==========================================================================; + * + * Copyright (C) Microsoft Corporation. All Rights Reserved. + * + * File: d3d9.h + * Content: Direct3D include file + * + ****************************************************************************) + +(* This identifier is passed to Direct3DCreate9 in order to ensure that an + * application was built against the correct header files. This number is + * incremented whenever a header (or other) change would require applications + * to be rebuilt. If the version doesn't match, Direct3DCreate9 will fail. + * (The number itself has no meaning.)*) + +const + D3D_SDK_VERSION = DWORD(31); + {$EXTERNALSYM D3D_SDK_VERSION} + +type + HMONITOR = THandle; + {$EXTERNALSYM HMONITOR} + +(* + * Direct3D interfaces + *) + + // forward interfaces declaration + IDirect3D9 = interface; + IDirect3DDevice9 = interface; + IDirect3DStateBlock9 = interface; + IDirect3DVertexDeclaration9 = interface; + IDirect3DVertexShader9 = interface; + IDirect3DPixelShader9 = interface; + IDirect3DResource9 = interface; + IDirect3DBaseTexture9 = interface; + IDirect3DTexture9 = interface; + IDirect3DVolumeTexture9 = interface; + IDirect3DCubeTexture9 = interface; + IDirect3DVertexBuffer9 = interface; + IDirect3DIndexBuffer9 = interface; + IDirect3DSurface9 = interface; + IDirect3DVolume9 = interface; + IDirect3DSwapChain9 = interface; + IDirect3DQuery9 = interface; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3D9);'} + {$EXTERNALSYM IDirect3D9} + IDirect3D9 = interface(IUnknown) + ['{81BDCBCA-64D4-426d-AE8D-AD0147F4275C}'] + (*** IDirect3D9 methods ***) + function RegisterSoftwareDevice(pInitializeFunction: Pointer): HResult; stdcall; + function GetAdapterCount: LongWord; stdcall; + function GetAdapterIdentifier(Adapter: LongWord; Flags: DWord; out pIdentifier: TD3DAdapterIdentifier9): HResult; stdcall; + function GetAdapterModeCount(Adapter: LongWord; Format: TD3DFormat): LongWord; stdcall; + function EnumAdapterModes(Adapter: LongWord; Format: TD3DFormat; Mode: LongWord; out pMode: TD3DDisplayMode): HResult; stdcall; + function GetAdapterDisplayMode(Adapter: LongWord; out pMode: TD3DDisplayMode): HResult; stdcall; + function CheckDeviceType(Adapter: LongWord; CheckType: TD3DDevType; DisplayFormat, BackBufferFormat: TD3DFormat; Windowed: BOOL): HResult; stdcall; + function CheckDeviceFormat(Adapter: LongWord; DeviceType: TD3DDevType; AdapterFormat: TD3DFormat; Usage: DWord; RType: TD3DResourceType; CheckFormat: TD3DFormat): HResult; stdcall; + function CheckDeviceMultiSampleType(Adapter: LongWord; DeviceType: TD3DDevType; SurfaceFormat: TD3DFormat; Windowed: BOOL; MultiSampleType: TD3DMultiSampleType; pQualityLevels: PDWORD): HResult; stdcall; + function CheckDepthStencilMatch(Adapter: LongWord; DeviceType: TD3DDevType; AdapterFormat, RenderTargetFormat, DepthStencilFormat: TD3DFormat): HResult; stdcall; + function CheckDeviceFormatConversion(Adapter: LongWord; DeviceType: TD3DDevType; SourceFormat, TargetFormat: TD3DFormat): HResult; stdcall; + function GetDeviceCaps(Adapter: LongWord; DeviceType: TD3DDevType; out pCaps: TD3DCaps9): HResult; stdcall; + function GetAdapterMonitor(Adapter: LongWord): HMONITOR; stdcall; + function CreateDevice(Adapter: LongWord; DeviceType: TD3DDevType; hFocusWindow: HWND; BehaviorFlags: DWord; pPresentationParameters: PD3DPresentParameters; out ppReturnedDeviceInterface: IDirect3DDevice9): HResult; stdcall; + end; + + + +{ SwapChain } + + + + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DDevice9);'} + {$EXTERNALSYM IDirect3DDevice9} + IDirect3DDevice9 = interface(IUnknown) + ['{D0223B96-BF7A-43fd-92BD-A43B0D82B9EB}'] + (*** IDirect3DDevice9 methods ***) + function TestCooperativeLevel: HResult; stdcall; + function GetAvailableTextureMem: LongWord; stdcall; + function EvictManagedResources: HResult; stdcall; + function GetDirect3D(out ppD3D9: IDirect3D9): HResult; stdcall; + function GetDeviceCaps(out pCaps: TD3DCaps9): HResult; stdcall; + function GetDisplayMode(iSwapChain: LongWord; out pMode: TD3DDisplayMode): HResult; stdcall; + function GetCreationParameters(out pParameters: TD3DDeviceCreationParameters): HResult; stdcall; + function SetCursorProperties(XHotSpot, YHotSpot: LongWord; pCursorBitmap: IDirect3DSurface9): HResult; stdcall; + procedure SetCursorPosition(XScreenSpace, YScreenSpace: LongWord; Flags: DWord); stdcall; + function ShowCursor(bShow: BOOL): BOOL; stdcall; + function CreateAdditionalSwapChain(const pPresentationParameters: TD3DPresentParameters; out pSwapChain: IDirect3DSwapChain9): HResult; stdcall; + function GetSwapChain(iSwapChain: LongWord; out pSwapChain: IDirect3DSwapChain9): HResult; stdcall; + function GetNumberOfSwapChains: LongWord; stdcall; + function Reset(const pPresentationParameters: TD3DPresentParameters): HResult; stdcall; + function Present(pSourceRect, pDestRect: PRect; hDestWindowOverride: HWND; pDirtyRegion: PRgnData): HResult; stdcall; + function GetBackBuffer(iSwapChain: LongWord; iBackBuffer: LongWord; _Type: TD3DBackBufferType; out ppBackBuffer: IDirect3DSurface9): HResult; stdcall; + function GetRasterStatus(iSwapChain: LongWord; out pRasterStatus: TD3DRasterStatus): HResult; stdcall; + function SetDialogBoxMode(bEnableDialogs: BOOL): HResult; stdcall; + procedure SetGammaRamp(iSwapChain: LongWord; Flags: DWord; const pRamp: TD3DGammaRamp); stdcall; + procedure GetGammaRamp(iSwapChain: LongWord; out pRamp: TD3DGammaRamp); stdcall; + function CreateTexture(Width, Height, Levels: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppTexture: IDirect3DTexture9; pSharedHandle: PHandle): HResult; stdcall; + function CreateVolumeTexture(Width, Height, Depth, Levels: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppVolumeTexture: IDirect3DVolumeTexture9; pSharedHandle: PHandle): HResult; stdcall; + function CreateCubeTexture(EdgeLength, Levels: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppCubeTexture: IDirect3DCubeTexture9; pSharedHandle: PHandle): HResult; stdcall; + function CreateVertexBuffer(Length: LongWord; Usage, FVF: DWord; Pool: TD3DPool; out ppVertexBuffer: IDirect3DVertexBuffer9; pSharedHandle: PHandle): HResult; stdcall; + function CreateIndexBuffer(Length: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppIndexBuffer: IDirect3DIndexBuffer9; pSharedHandle: PHandle): HResult; stdcall; + function CreateRenderTarget(Width, Height: LongWord; Format: TD3DFormat; MultiSample: TD3DMultiSampleType; MultisampleQuality: DWORD; Lockable: BOOL; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle): HResult; stdcall; + function CreateDepthStencilSurface(Width, Height: LongWord; Format: TD3DFormat; MultiSample: TD3DMultiSampleType; MultisampleQuality: DWORD; Discard: BOOL; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle): HResult; stdcall; + function UpdateSurface(pSourceSurface: IDirect3DSurface9; pSourceRect: PRect; pDestinationSurface: IDirect3DSurface9; pDestPoint: PPoint): HResult; stdcall; + function UpdateTexture(pSourceTexture, pDestinationTexture: IDirect3DBaseTexture9): HResult; stdcall; + function GetRenderTargetData(pRenderTarget, pDestSurface: IDirect3DSurface9): HResult; stdcall; + function GetFrontBufferData(iSwapChain: LongWord; pDestSurface: IDirect3DSurface9): HResult; stdcall; + function StretchRect(pSourceSurface: IDirect3DSurface9; pSourceRect: PRect; pDestSurface: IDirect3DSurface9; pDestRect: PRect; Filter: TD3DTextureFilterType): HResult; stdcall; + function ColorFill(pSurface: IDirect3DSurface9; pRect: PRect; color: TD3DColor): HResult; stdcall; + function CreateOffscreenPlainSurface(Width, Height: LongWord; Format: TD3DFormat; Pool: TD3DPool; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle): HResult; stdcall; + function SetRenderTarget(RenderTargetIndex: DWORD; pRenderTarget: IDirect3DSurface9): HResult; stdcall; + function GetRenderTarget(RenderTargetIndex: DWORD; out ppRenderTarget: IDirect3DSurface9): HResult; stdcall; + function SetDepthStencilSurface(pNewZStencil: IDirect3DSurface9): HResult; stdcall; + function GetDepthStencilSurface(out ppZStencilSurface: IDirect3DSurface9): HResult; stdcall; + function BeginScene: HResult; stdcall; + function EndScene: HResult; stdcall; + function Clear(Count: DWord; pRects: PD3DRect; Flags: DWord; Color: TD3DColor; Z: Single; Stencil: DWord): HResult; stdcall; + function SetTransform(State: TD3DTransformStateType; const pMatrix: TD3DMatrix): HResult; stdcall; + function GetTransform(State: TD3DTransformStateType; out pMatrix: TD3DMatrix): HResult; stdcall; + function MultiplyTransform(State: TD3DTransformStateType; const pMatrix: TD3DMatrix): HResult; stdcall; + function SetViewport(const pViewport: TD3DViewport9): HResult; stdcall; + function GetViewport(out pViewport: TD3DViewport9): HResult; stdcall; + function SetMaterial(const pMaterial: TD3DMaterial9): HResult; stdcall; + function GetMaterial(out pMaterial: TD3DMaterial9): HResult; stdcall; + function SetLight(Index: DWord; const pLight: TD3DLight9): HResult; stdcall; + function GetLight(Index: DWord; out pLight: TD3DLight9): HResult; stdcall; + function LightEnable(Index: DWord; Enable: BOOL): HResult; stdcall; + function GetLightEnable(Index: DWord; out pEnable: BOOL): HResult; stdcall; + function SetClipPlane(Index: DWord; pPlane: PSingle): HResult; stdcall; + function GetClipPlane(Index: DWord; pPlane: PSingle): HResult; stdcall; + function SetRenderState(State: TD3DRenderStateType; Value: DWord): HResult; stdcall; + function GetRenderState(State: TD3DRenderStateType; out pValue: DWord): HResult; stdcall; + function CreateStateBlock(_Type: TD3DStateBlockType; out ppSB: IDirect3DStateBlock9): HResult; stdcall; + function BeginStateBlock: HResult; stdcall; + function EndStateBlock(out ppSB: IDirect3DStateBlock9): HResult; stdcall; + function SetClipStatus(const pClipStatus: TD3DClipStatus9): HResult; stdcall; + function GetClipStatus(out pClipStatus: TD3DClipStatus9): HResult; stdcall; + function GetTexture(Stage: DWord; out ppTexture: IDirect3DBaseTexture9): HResult; stdcall; + function SetTexture(Stage: DWord; pTexture: IDirect3DBaseTexture9): HResult; stdcall; + function GetTextureStageState(Stage: DWord; _Type: TD3DTextureStageStateType; out pValue: DWord): HResult; stdcall; + function SetTextureStageState(Stage: DWord; _Type: TD3DTextureStageStateType; Value: DWord): HResult; stdcall; + function GetSamplerState(Sampler: DWORD; _Type: TD3DSamplerStateType; out pValue: DWORD): HResult; stdcall; + function SetSamplerState(Sampler: DWORD; _Type: TD3DSamplerStateType; Value: DWORD): HResult; stdcall; + function ValidateDevice(out pNumPasses: DWord): HResult; stdcall; + function SetPaletteEntries(PaletteNumber: LongWord; pEntries: pPaletteEntry): HResult; stdcall; + function GetPaletteEntries(PaletteNumber: LongWord; pEntries: pPaletteEntry): HResult; stdcall; + function SetCurrentTexturePalette(PaletteNumber: LongWord): HResult; stdcall; + function GetCurrentTexturePalette(out PaletteNumber: LongWord): HResult; stdcall; + function SetScissorRect(pRect: PRect): HResult; stdcall; + function GetScissorRect(out pRect: TRect): HResult; stdcall; + function SetSoftwareVertexProcessing(bSoftware: BOOL): HResult; stdcall; + function GetSoftwareVertexProcessing: BOOL; stdcall; + function SetNPatchMode(nSegments: Single): HResult; stdcall; + function GetNPatchMode: Single; stdcall; + function DrawPrimitive(PrimitiveType: TD3DPrimitiveType; StartVertex, PrimitiveCount: LongWord): HResult; stdcall; + function DrawIndexedPrimitive(_Type: TD3DPrimitiveType; BaseVertexIndex: Integer; MinVertexIndex, NumVertices, startIndex, primCount: LongWord): HResult; stdcall; + function DrawPrimitiveUP(PrimitiveType: TD3DPrimitiveType; PrimitiveCount: LongWord; const pVertexStreamZeroData; VertexStreamZeroStride: LongWord): HResult; stdcall; + function DrawIndexedPrimitiveUP(PrimitiveType: TD3DPrimitiveType; MinVertexIndex, NumVertice, PrimitiveCount: LongWord; const pIndexData; IndexDataFormat: TD3DFormat; const pVertexStreamZeroData; VertexStreamZeroStride: LongWord): HResult; stdcall; + function ProcessVertices(SrcStartIndex, DestIndex, VertexCount: LongWord; pDestBuffer: IDirect3DVertexBuffer9; pVertexDecl: IDirect3DVertexDeclaration9; Flags: DWord): HResult; stdcall; + function CreateVertexDeclaration(pVertexElements: PD3DVertexElement9; out ppDecl: IDirect3DVertexDeclaration9): HResult; stdcall; + function SetVertexDeclaration(pDecl: IDirect3DVertexDeclaration9): HResult; stdcall; + function GetVertexDeclaration(out ppDecl: IDirect3DVertexDeclaration9): HResult; stdcall; + function SetFVF(FVF: DWORD): HResult; stdcall; + function GetFVF(out FVF: DWORD): HResult; stdcall; + function CreateVertexShader(pFunction: PDWord; out ppShader: IDirect3DVertexShader9): HResult; stdcall; + function SetVertexShader(pShader: IDirect3DVertexShader9): HResult; stdcall; + function GetVertexShader(out ppShader: IDirect3DVertexShader9): HResult; stdcall; + function SetVertexShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall; + function GetVertexShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall; + function SetVertexShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall; + function GetVertexShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall; + function SetVertexShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall; + function GetVertexShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall; + function SetStreamSource(StreamNumber: LongWord; pStreamData: IDirect3DVertexBuffer9; OffsetInBytes, Stride: LongWord): HResult; stdcall; + function GetStreamSource(StreamNumber: LongWord; out ppStreamData: IDirect3DVertexBuffer9; out OffsetInBytes, pStride: LongWord): HResult; stdcall; + function SetStreamSourceFreq(StreamNumber: LongWord; Divider: LongWord): HResult; stdcall; + function GetStreamSourceFreq(StreamNumber: LongWord; out Divider: LongWord): HResult; stdcall; + function SetIndices(pIndexData: IDirect3DIndexBuffer9): HResult; stdcall; + function GetIndices(out ppIndexData: IDirect3DIndexBuffer9): HResult; stdcall; + function CreatePixelShader(pFunction: PDWord; out ppShader: IDirect3DPixelShader9): HResult; stdcall; + function SetPixelShader(pShader: IDirect3DPixelShader9): HResult; stdcall; + function GetPixelShader(out ppShader: IDirect3DPixelShader9): HResult; stdcall; + function SetPixelShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall; + function GetPixelShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall; + function SetPixelShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall; + function GetPixelShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall; + function SetPixelShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall; + function GetPixelShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall; + function DrawRectPatch(Handle: LongWord; pNumSegs: PSingle; pTriPatchInfo: PD3DRectPatchInfo): HResult; stdcall; + function DrawTriPatch(Handle: LongWord; pNumSegs: PSingle; pTriPatchInfo: PD3DTriPatchInfo): HResult; stdcall; + function DeletePatch(Handle: LongWord): HResult; stdcall; + function CreateQuery(_Type: TD3DQueryType; out ppQuery: IDirect3DQuery9): HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DStateBlock9);'} + {$EXTERNALSYM IDirect3DStateBlock9} + IDirect3DStateBlock9 = interface(IUnknown) + ['{B07C4FE5-310D-4ba8-A23C-4F0F206F218B}'] + (*** IDirect3DStateBlock9 methods ***) + function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall; + function Capture: HResult; stdcall; + function Apply: HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DSwapChain9);'} + {$EXTERNALSYM IDirect3DSwapChain9} + IDirect3DSwapChain9 = interface(IUnknown) + ['{794950F2-ADFC-458a-905E-10A10B0B503B}'] + (*** IDirect3DSwapChain9 methods ***) + function Present(pSourceRect, pDestRect: PRect; hDestWindowOverride: HWND; pDirtyRegion: PRgnData; dwFlags: DWORD): HResult; stdcall; + function GetFrontBufferData(pDestSurface: IDirect3DSurface9): HResult; stdcall; + function GetBackBuffer(iBackBuffer: LongWord; _Type: TD3DBackBufferType; out ppBackBuffer: IDirect3DSurface9): HResult; stdcall; + function GetRasterStatus(out pRasterStatus: TD3DRasterStatus): HResult; stdcall; + function GetDisplayMode(out pMode: TD3DDisplayMode): HResult; stdcall; + function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall; + function GetPresentParameters(out pPresentationParameters: TD3DPresentParameters): HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DResource9);'} + {$EXTERNALSYM IDirect3DResource9} + IDirect3DResource9 = interface(IUnknown) + ['{05EEC05D-8F7D-4362-B999-D1BAF357C704}'] + (*** IDirect3DResource9 methods ***) + function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall; + function SetPrivateData(const refguid: TGUID; const pData; SizeOfData, Flags: DWord): HResult; stdcall; + function GetPrivateData(const refguid: TGUID; pData: Pointer; out pSizeOfData: DWord): HResult; stdcall; + function FreePrivateData(const refguid: TGUID): HResult; stdcall; + function SetPriority(PriorityNew: DWord): DWord; stdcall; + function GetPriority: DWord; stdcall; + procedure PreLoad; stdcall; + function GetType: TD3DResourceType; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DVertexDeclaration9);'} + {$EXTERNALSYM IDirect3DVertexDeclaration9} + IDirect3DVertexDeclaration9 = interface(IUnknown) + ['{DD13C59C-36FA-4098-A8FB-C7ED39DC8546}'] + (*** IDirect3DVertexDeclaration9 methods ***) + function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall; + function GetDeclaration(pDecl: PD3DVertexElement9; out pNumElements: LongWord): HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DVertexShader9);'} + {$EXTERNALSYM IDirect3DVertexShader9} + IDirect3DVertexShader9 = interface(IUnknown) + ['{EFC5557E-6265-4613-8A94-43857889EB36}'] + (*** IDirect3DVertexShader9 methods ***) + function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall; + function GetFunction(pData: Pointer; out pSizeOfData: LongWord): HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DPixelShader9);'} + {$EXTERNALSYM IDirect3DPixelShader9} + IDirect3DPixelShader9 = interface(IUnknown) + ['{6D3BDBDC-5B02-4415-B852-CE5E8BCCB289}'] + (*** IDirect3DPixelShader9 methods ***) + function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall; + function GetFunction(pData: Pointer; out pSizeOfData: LongWord): HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DBaseTexture9);'} + {$EXTERNALSYM IDirect3DBaseTexture9} + IDirect3DBaseTexture9 = interface(IDirect3DResource9) + ['{580CA87E-1D3C-4d54-991D-B7D3E3C298CE}'] + (*** IDirect3DBaseTexture9 methods ***) + function SetLOD(LODNew: DWord): DWord; stdcall; + function GetLOD: DWord; stdcall; + function GetLevelCount: DWord; stdcall; + function SetAutoGenFilterType(FilterType: TD3DTextureFilterType): HResult; stdcall; + function GetAutoGenFilterType: TD3DTextureFilterType; stdcall; + procedure GenerateMipSubLevels; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DTexture9);'} + {$EXTERNALSYM IDirect3DTexture9} + IDirect3DTexture9 = interface(IDirect3DBaseTexture9) + ['{85C31227-3DE5-4f00-9B3A-F11AC38C18B5}'] + (*** IDirect3DTexture9 methods ***) + function GetLevelDesc(Level: LongWord; out pDesc: TD3DSurfaceDesc): HResult; stdcall; + function GetSurfaceLevel(Level: LongWord; out ppSurfaceLevel: IDirect3DSurface9): HResult; stdcall; + function LockRect(Level: LongWord; out pLockedRect: TD3DLockedRect; pRect: PRect; Flags: DWord): HResult; stdcall; + function UnlockRect(Level: LongWord): HResult; stdcall; + function AddDirtyRect(pDirtyRect: PRect): HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DVolumeTexture9);'} + {$EXTERNALSYM IDirect3DVolumeTexture9} + IDirect3DVolumeTexture9 = interface(IDirect3DBaseTexture9) + ['{2518526C-E789-4111-A7B9-47EF328D13E6}'] + (*** IDirect3DVolumeTexture9 methods ***) + function GetLevelDesc(Level: LongWord; out pDesc: TD3DVolumeDesc): HResult; stdcall; + function GetVolumeLevel(Level: LongWord; out ppVolumeLevel: IDirect3DVolume9): HResult; stdcall; + function LockBox(Level: LongWord; out pLockedVolume: TD3DLockedBox; pBox: PD3DBox; Flags: DWord): HResult; stdcall; + function UnlockBox(Level: LongWord): HResult; stdcall; + function AddDirtyBox(pDirtyBox: PD3DBox): HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DCubeTexture9);'} + {$EXTERNALSYM IDirect3DCubeTexture9} + IDirect3DCubeTexture9 = interface(IDirect3DBaseTexture9) + ['{FFF32F81-D953-473a-9223-93D652ABA93F}'] + (*** IDirect3DCubeTexture9 methods ***) + function GetLevelDesc(Level: LongWord; out pDesc: TD3DSurfaceDesc): HResult; stdcall; + function GetCubeMapSurface(FaceType: TD3DCubeMapFaces; Level: LongWord; out ppCubeMapSurface: IDirect3DSurface9): HResult; stdcall; + function LockRect(FaceType: TD3DCubeMapFaces; Level: LongWord; out pLockedRect: TD3DLockedRect; pRect: PRect; Flags: DWord): HResult; stdcall; + function UnlockRect(FaceType: TD3DCubeMapFaces; Level: LongWord): HResult; stdcall; + function AddDirtyRect(FaceType: TD3DCubeMapFaces; pDirtyRect: PRect): HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DVertexBuffer9);'} + {$EXTERNALSYM IDirect3DVertexBuffer9} + IDirect3DVertexBuffer9 = interface(IDirect3DResource9) + ['{B64BB1B5-FD70-4df6-BF91-19D0A12455E3}'] + (*** IDirect3DVertexBuffer9 methods ***) + function Lock(OffsetToLock, SizeToLock: LongWord; out ppbData: Pointer; Flags: DWord): HResult; stdcall; + function Unlock: HResult; stdcall; + function GetDesc(out pDesc: TD3DVertexBufferDesc): HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DIndexBuffer9);'} + {$EXTERNALSYM IDirect3DIndexBuffer9} + IDirect3DIndexBuffer9 = interface(IDirect3DResource9) + ['{7C9DD65E-D3F7-4529-ACEE-785830ACDE35}'] + (*** IDirect3DIndexBuffer9 methods ***) + function Lock(OffsetToLock, SizeToLock: DWord; out ppbData: Pointer; Flags: DWord): HResult; stdcall; + function Unlock: HResult; stdcall; + function GetDesc(out pDesc: TD3DIndexBufferDesc): HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DSurface9);'} + {$EXTERNALSYM IDirect3DSurface9} + IDirect3DSurface9 = interface(IDirect3DResource9) + ['{0CFBAF3A-9FF6-429a-99B3-A2796AF8B89B}'] + (*** IDirect3DSurface9 methods ***) + function GetContainer(const riid: TGUID; out ppContainer: Pointer): HResult; stdcall; + function GetDesc(out pDesc: TD3DSurfaceDesc): HResult; stdcall; + function LockRect(out pLockedRect: TD3DLockedRect; pRect: PRect; Flags: DWord): HResult; stdcall; + function UnlockRect: HResult; stdcall; + function GetDC(out phdc: HDC): HResult; stdcall; + function ReleaseDC(hdc: HDC): HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DVolume9);'} + {$EXTERNALSYM IDirect3DVolume9} + IDirect3DVolume9 = interface (IUnknown) + ['{24F416E6-1F67-4aa7-B88E-D33F6F3128A1}'] + (*** IDirect3DVolume9 methods ***) + function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall; + function SetPrivateData(const refguid: TGUID; const pData; SizeOfData, Flags: DWord): HResult; stdcall; + function GetPrivateData(const refguid: TGUID; pData: Pointer; out pSizeOfData: DWord): HResult; stdcall; + function FreePrivateData(const refguid: TGUID): HResult; stdcall; + function GetContainer(const riid: TGUID; var ppContainer: Pointer): HResult; stdcall; + function GetDesc(out pDesc: TD3DVolumeDesc): HResult; stdcall; + function LockBox(out pLockedVolume: TD3DLockedBox; pBox: PD3DBox; Flags: DWord): HResult; stdcall; + function UnlockBox: HResult; stdcall; + end; + + + {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(IDirect3DQuery9);'} + {$EXTERNALSYM IDirect3DQuery9} + IDirect3DQuery9 = interface(IUnknown) + ['{d9771460-a695-4f26-bbd3-27b840b541cc}'] + (*** IDirect3DQuery9 methods ***) + function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall; + function GetType: TD3DQueryType; stdcall; + function GetDataSize: DWORD; stdcall; + function Issue(dwIssueFlags: DWORD): HResult; stdcall; + function GetData(pData: Pointer; dwSize: DWORD; dwGetDataFlags: DWORD): HResult; stdcall; + end; + + + +(* + * Interface IID's + *) +type + IID_IDirect3D9 = IDirect3D9; + {$EXTERNALSYM IID_IDirect3D9} + IID_IDirect3DDevice9 = IDirect3DDevice9; + {$EXTERNALSYM IID_IDirect3DDevice9} + IID_IDirect3DResource9 = IDirect3DResource9; + {$EXTERNALSYM IID_IDirect3DResource9} + IID_IDirect3DBaseTexture9 = IDirect3DBaseTexture9; + {$EXTERNALSYM IID_IDirect3DBaseTexture9} + IID_IDirect3DTexture9 = IDirect3DTexture9; + {$EXTERNALSYM IID_IDirect3DTexture9} + IID_IDirect3DCubeTexture9 = IDirect3DCubeTexture9; + {$EXTERNALSYM IID_IDirect3DCubeTexture9} + IID_IDirect3DVolumeTexture9 = IDirect3DVolumeTexture9; + {$EXTERNALSYM IID_IDirect3DVolumeTexture9} + IID_IDirect3DVertexBuffer9 = IDirect3DVertexBuffer9; + {$EXTERNALSYM IID_IDirect3DVertexBuffer9} + IID_IDirect3DIndexBuffer9 = IDirect3DIndexBuffer9; + {$EXTERNALSYM IID_IDirect3DIndexBuffer9} + IID_IDirect3DSurface9 = IDirect3DSurface9; + {$EXTERNALSYM IID_IDirect3DSurface9} + IID_IDirect3DVolume9 = IDirect3DVolume9; + {$EXTERNALSYM IID_IDirect3DVolume9} + IID_IDirect3DSwapChain9 = IDirect3DSwapChain9; + {$EXTERNALSYM IID_IDirect3DSwapChain9} + IID_IDirect3DVertexDeclaration9 = IDirect3DVertexDeclaration9; + {$EXTERNALSYM IID_IDirect3DVertexDeclaration9} + IID_IDirect3DVertexShader9 = IDirect3DVertexShader9; + {$EXTERNALSYM IID_IDirect3DVertexShader9} + IID_IDirect3DPixelShader9 = IDirect3DPixelShader9; + {$EXTERNALSYM IID_IDirect3DPixelShader9} + IID_IDirect3DStateBlock9 = IDirect3DStateBlock9; + {$EXTERNALSYM IID_IDirect3DStateBlock9} + IID_IDirect3DQuery9 = IDirect3DQuery9; + {$EXTERNALSYM IID_IDirect3DQuery9} + + + +const +{**************************************************************************** + * Flags for SetPrivateData method on all D3D9 interfaces + * + * The passed pointer is an IUnknown ptr. The SizeOfData argument to SetPrivateData + * must be set to sizeof(IUnknown*). Direct3D will call AddRef through this + * pointer and Release when the private data is destroyed. The data will be + * destroyed when another SetPrivateData with the same GUID is set, when + * FreePrivateData is called, or when the D3D9 object is freed. + ****************************************************************************} + D3DSPD_IUNKNOWN = $00000001; + {$EXTERNALSYM D3DSPD_IUNKNOWN} + +(**************************************************************************** + * + * Flags for IDirect3D9::CreateDevice's BehaviorFlags + * + ****************************************************************************) + + D3DCREATE_FPU_PRESERVE = $00000002; + {$EXTERNALSYM D3DCREATE_FPU_PRESERVE} + D3DCREATE_MULTITHREADED = $00000004; + {$EXTERNALSYM D3DCREATE_MULTITHREADED} + + D3DCREATE_PUREDEVICE = $00000010; + {$EXTERNALSYM D3DCREATE_PUREDEVICE} + D3DCREATE_SOFTWARE_VERTEXPROCESSING = $00000020; + {$EXTERNALSYM D3DCREATE_SOFTWARE_VERTEXPROCESSING} + D3DCREATE_HARDWARE_VERTEXPROCESSING = $00000040; + {$EXTERNALSYM D3DCREATE_HARDWARE_VERTEXPROCESSING} + D3DCREATE_MIXED_VERTEXPROCESSING = $00000080; + {$EXTERNALSYM D3DCREATE_MIXED_VERTEXPROCESSING} + + D3DCREATE_DISABLE_DRIVER_MANAGEMENT = $00000100; + {$EXTERNALSYM D3DCREATE_DISABLE_DRIVER_MANAGEMENT} + D3DCREATE_ADAPTERGROUP_DEVICE = $00000200; + {$EXTERNALSYM D3DCREATE_ADAPTERGROUP_DEVICE} + + +(**************************************************************************** + * + * Parameter for IDirect3D9::CreateDevice's iAdapter + * + ****************************************************************************) + + D3DADAPTER_DEFAULT = 0; + {$EXTERNALSYM D3DADAPTER_DEFAULT} + +(**************************************************************************** + * + * Flags for IDirect3D9::EnumAdapters + * + ****************************************************************************) + + D3DENUM_WHQL_LEVEL = $00000002; + {$EXTERNALSYM D3DENUM_WHQL_LEVEL} + +(**************************************************************************** + * + * Maximum number of back-buffers supported in DX8 + * + ****************************************************************************) + + D3DPRESENT_BACK_BUFFERS_MAX = 3; + {$EXTERNALSYM D3DPRESENT_BACK_BUFFERS_MAX} + +(**************************************************************************** + * + * Flags for IDirect3DDevice9::SetGammaRamp + * + ****************************************************************************) + + D3DSGR_NO_CALIBRATION = $00000000; + {$EXTERNALSYM D3DSGR_NO_CALIBRATION} + D3DSGR_CALIBRATE = $00000001; + {$EXTERNALSYM D3DSGR_CALIBRATE} + +(**************************************************************************** + * + * Flags for IDirect3DDevice9::SetCursorPosition + * + ****************************************************************************) + + D3DCURSOR_IMMEDIATE_UPDATE = $00000001; + {$EXTERNALSYM D3DCURSOR_IMMEDIATE_UPDATE} + +(**************************************************************************** + * + * Flags for IDirect3DSwapChain9::Present + * + ****************************************************************************) + + D3DPRESENT_DONOTWAIT = $00000001; + {$EXTERNALSYM D3DPRESENT_DONOTWAIT} + D3DPRESENT_LINEAR_CONTENT = $00000002; + {$EXTERNALSYM D3DPRESENT_LINEAR_CONTENT} + +(**************************************************************************** + * + * Flags for DrawPrimitive/DrawIndexedPrimitive + * Also valid for Begin/BeginIndexed + * Also valid for VertexBuffer::CreateVertexBuffer + ****************************************************************************) + + +(* + * DirectDraw error codes + *) + _FACD3D = $876; + {$EXTERNALSYM _FACD3D} + +//#define MAKE_D3DHRESULT( code ) MAKE_HRESULT( 1, _FACD3D, code ) +function MAKE_D3DHRESULT(Code: DWord): DWord; +{$EXTERNALSYM MAKE_D3DHRESULT} +//#define MAKE_D3DSTATUS( code ) MAKE_HRESULT( 0, _FACD3D, code ) +function MAKE_D3DSTATUS(Code: DWord): DWord; +{$EXTERNALSYM MAKE_D3DSTATUS} + +const + MAKE_D3DHRESULT_R = (1 shl 31) or (_FACD3D shl 16); + MAKE_D3DSTATUS_R = (0 shl 31) or (_FACD3D shl 16); + +(* + * Direct3D Errors + *) + D3D_OK = S_OK; + {$EXTERNALSYM D3D_OK} + + D3DERR_WRONGTEXTUREFORMAT = HResult(MAKE_D3DHRESULT_R or 2072); + {$EXTERNALSYM D3DERR_WRONGTEXTUREFORMAT} + D3DERR_UNSUPPORTEDCOLOROPERATION = HResult(MAKE_D3DHRESULT_R or 2073); + {$EXTERNALSYM D3DERR_UNSUPPORTEDCOLOROPERATION} + D3DERR_UNSUPPORTEDCOLORARG = HResult(MAKE_D3DHRESULT_R or 2074); + {$EXTERNALSYM D3DERR_UNSUPPORTEDCOLORARG} + D3DERR_UNSUPPORTEDALPHAOPERATION = HResult(MAKE_D3DHRESULT_R or 2075); + {$EXTERNALSYM D3DERR_UNSUPPORTEDALPHAOPERATION} + D3DERR_UNSUPPORTEDALPHAARG = HResult(MAKE_D3DHRESULT_R or 2076); + {$EXTERNALSYM D3DERR_UNSUPPORTEDALPHAARG} + D3DERR_TOOMANYOPERATIONS = HResult(MAKE_D3DHRESULT_R or 2077); + {$EXTERNALSYM D3DERR_TOOMANYOPERATIONS} + D3DERR_CONFLICTINGTEXTUREFILTER = HResult(MAKE_D3DHRESULT_R or 2078); + {$EXTERNALSYM D3DERR_CONFLICTINGTEXTUREFILTER} + D3DERR_UNSUPPORTEDFACTORVALUE = HResult(MAKE_D3DHRESULT_R or 2079); + {$EXTERNALSYM D3DERR_UNSUPPORTEDFACTORVALUE} + D3DERR_CONFLICTINGRENDERSTATE = HResult(MAKE_D3DHRESULT_R or 2081); + {$EXTERNALSYM D3DERR_CONFLICTINGRENDERSTATE} + D3DERR_UNSUPPORTEDTEXTUREFILTER = HResult(MAKE_D3DHRESULT_R or 2082); + {$EXTERNALSYM D3DERR_UNSUPPORTEDTEXTUREFILTER} + D3DERR_CONFLICTINGTEXTUREPALETTE = HResult(MAKE_D3DHRESULT_R or 2086); + {$EXTERNALSYM D3DERR_CONFLICTINGTEXTUREPALETTE} + D3DERR_DRIVERINTERNALERROR = HResult(MAKE_D3DHRESULT_R or 2087); + {$EXTERNALSYM D3DERR_DRIVERINTERNALERROR} + + D3DERR_NOTFOUND = HResult(MAKE_D3DHRESULT_R or 2150); + {$EXTERNALSYM D3DERR_NOTFOUND} + D3DERR_MOREDATA = HResult(MAKE_D3DHRESULT_R or 2151); + {$EXTERNALSYM D3DERR_MOREDATA} + D3DERR_DEVICELOST = HResult(MAKE_D3DHRESULT_R or 2152); + {$EXTERNALSYM D3DERR_DEVICELOST} + D3DERR_DEVICENOTRESET = HResult(MAKE_D3DHRESULT_R or 2153); + {$EXTERNALSYM D3DERR_DEVICENOTRESET} + D3DERR_NOTAVAILABLE = HResult(MAKE_D3DHRESULT_R or 2154); + {$EXTERNALSYM D3DERR_NOTAVAILABLE} + D3DERR_OUTOFVIDEOMEMORY = HResult(MAKE_D3DHRESULT_R or 380); + {$EXTERNALSYM D3DERR_OUTOFVIDEOMEMORY} + D3DERR_INVALIDDEVICE = HResult(MAKE_D3DHRESULT_R or 2155); + {$EXTERNALSYM D3DERR_INVALIDDEVICE} + D3DERR_INVALIDCALL = HResult(MAKE_D3DHRESULT_R or 2156); + {$EXTERNALSYM D3DERR_INVALIDCALL} + D3DERR_DRIVERINVALIDCALL = HResult(MAKE_D3DHRESULT_R or 2157); + {$EXTERNALSYM D3DERR_DRIVERINVALIDCALL} + D3DERR_WASSTILLDRAWING = HResult(MAKE_D3DHRESULT_R or 540); + {$EXTERNALSYM D3DERR_WASSTILLDRAWING} + D3DOK_NOAUTOGEN = HResult(MAKE_D3DSTATUS_R or 2159); + {$EXTERNALSYM D3DOK_NOAUTOGEN} + + + +(* + * DLL Function for creating a Direct3D9 object. This object supports + * enumeration and allows the creation of Direct3DDevice9 objects. + * Pass the value of the constant D3D_SDK_VERSION to this function, so + * that the run-time can validate that your application was compiled + * against the right headers. + *) + + +function Direct3D9Loaded: Boolean; +function LoadDirect3D9: Boolean; +function UnLoadDirect3D9: Boolean; + +// Due to the way Object Pascal handles functions resulting in 'native' interface +// pointer we should declare result not as interface but as usial pointer + +{$IFDEF DIRECT3D9_DYNAMIC_LINK} +type + TDirect3DCreate9 = function (SDKVersion: LongWord): Pointer; stdcall; + +var + _Direct3DCreate9: TDirect3DCreate9 = nil; + +{$ELSE} +function _Direct3DCreate9(SDKVersion: LongWord): Pointer; stdcall; +{$ENDIF} + +function Direct3DCreate9(SDKVersion: LongWord): IDirect3D9; stdcall; +{$EXTERNALSYM Direct3DCreate9} + + +//******************************************************************** +// Introduced types for compatibility with non-Borland compliant translation +// by Ampaze (Tim Baumgarten) from http://www.crazyentertainment.net +type + PD3DAdapter_Identifier9 = PD3DAdapterIdentifier9; + PD3DDevice_Creation_Parameters = PD3DDeviceCreationParameters; + PD3DDevInfo_D3DVertexStats = PD3DDevInfoD3DVertexStats; + PD3DDevInfo_ResourceManager = PD3DDevInfoResourceManager; + PD3DDevInfo_VCache = PD3DDevInfoVCache; + PD3DIndexBuffer_Desc = PD3DIndexBufferDesc; + PD3DLocked_Box = PD3DLockedBox; + PD3DLocked_Rect = PD3DLockedRect; + PD3DPresent_Parameters = PD3DPresentParameters; + PD3DRaster_Status = PD3DRasterStatus; + PD3DRectPatch_Info = PD3DRectPatchInfo; + PD3DSurface_Desc = PD3DSurfaceDesc; + PD3DTriPatch_Info = PD3DTriPatchInfo; + PD3DVertexBuffer_Desc = PD3DVertexBufferDesc; + PD3DVolume_Desc = PD3DVolumeDesc; + + TD3DAdapter_Identifier9 = TD3DAdapterIdentifier9; + TD3DBackBuffer_Type = TD3DBackBufferType; + TD3DCubeMap_Faces = TD3DCubeMapFaces; + TD3DDevice_Creation_Parameters = TD3DDeviceCreationParameters; + TD3DDevInfo_D3DVertexStats = TD3DDevInfoD3DVertexStats; + TD3DDevInfo_ResourceManager = TD3DDevInfoResourceManager; + TD3DDevInfo_VCache = TD3DDevInfoVCache; + TD3DIndexBuffer_Desc = TD3DIndexBufferDesc; + TD3DLocked_Box = TD3DLockedBox; + TD3DLocked_Rect = TD3DLockedRect; + TD3DMultiSample_Type = TD3DMultiSampleType; + TD3DPresent_Parameters = TD3DPresentParameters; + TD3DRaster_Status = TD3DRasterStatus; + TD3DRectPatch_Info = TD3DRectPatchInfo; + TD3DSampler_Texture_Type = TD3DSamplerTextureType; + TD3DShader_AddressMode_Type = TD3DShaderAddressModeType; + TD3DShader_Comparison = TD3DShaderComparison; + TD3DShader_Instruction_Opcode_Type = TD3DShaderInstructionOpcodeType; + TD3DShader_MiscType_Offsets = TD3DShaderMiscTypeOffsets; + TD3DShader_Param_Register_Type = TD3DShaderParamRegisterType; + TD3DShader_Param_SRCMod_Type = TD3DShaderParamSRCModType; + TD3DSurface_Desc = TD3DSurfaceDesc; + TD3DTriPatch_Info = TD3DTriPatchInfo; + TD3DVertexBuffer_Desc = TD3DVertexBufferDesc; + TD3DVolume_Desc = TD3DVolumeDesc; + TD3DVS_AddressMode_Type = TD3DVSAddressModeType; + TD3DVS_RastOut_Offsets = TD3DVSRastOutOffsets; + + +implementation + +(*==========================================================================; + * File: d3d9types.h + * Content: Direct3D capabilities include file + ***************************************************************************) + +// #define D3DCOLOR_ARGB(a,r,g,b) \ +// ((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff))) +function D3DCOLOR_ARGB(a,r,g,b: DWord): TD3DColor; +begin + Result := (a shl 24) or (r shl 16) or (g shl 8) or b; +end; + +// #define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b) +function D3DCOLOR_RGBA(r,g,b,a: DWord): TD3DColor; +begin + Result := (a shl 24) or (r shl 16) or (g shl 8) or b; +end; + +// #define D3DCOLOR_XRGB(r,g,b) D3DCOLOR_ARGB(0xff,r,g,b) +function D3DCOLOR_XRGB(r,g,b: DWord): TD3DColor; +begin + Result := DWORD($FF shl 24) or (r shl 16) or (g shl 8) or b; +end; + +// #define D3DCOLOR_XYUV(y,u,v) D3DCOLOR_ARGB(0xff,y,u,v) +function D3DCOLOR_XYUV(y,u,v: DWord): TD3DColor; +begin + Result := DWORD($FF shl 24) or (y shl 16) or (u shl 8) or v; +end; + +// #define D3DCOLOR_AYUV(a,y,u,v) D3DCOLOR_ARGB(a,y,u,v) +function D3DCOLOR_AYUV(a,y,u,v: DWord): TD3DColor; +begin + Result := (a shl 24) or (y shl 16) or (u shl 8) or v; +end; + +// #define D3DCOLOR_COLORVALUE(r,g,b,a) \ +// D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWORD)((a)*255.f)) +function D3DCOLOR_COLORVALUE(r,g,b,a: Single): TD3DColor; +begin + Result := (round(a * 255) shl 24) or + (round(r * 255) shl 16) or + (round(g * 255) shl 8) or + (round(b * 255)); +end; + +// #define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256) +function D3DTS_WORLDMATRIX(index: Byte): TD3DTransformStateType; +begin + Result:= TD3DTransformStateType(index + 256); +end; + +//#define D3DPS_VERSION(_Major,_Minor) (0xFFFF0000|((_Major)<<8)|(_Minor)) +function D3DPS_VERSION(_Major, _Minor : Cardinal) : Cardinal; +begin + Result:= $FFFF0000 or (_Major shl 8 ) or _Minor; +end; + +//#define D3DVS_VERSION(_Major,_Minor) (0xFFFE0000|((_Major)<<8)|(_Minor)) +function D3DVS_VERSION(_Major, _Minor : Cardinal) : Cardinal; +begin + Result:= $FFFE0000 or (_Major shl 8 ) or _Minor; +end; + +//#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF) +function D3DSHADER_VERSION_MAJOR(_Version : Cardinal) : Cardinal; +begin + Result:= (_Version shr 8 ) and $FF; +end; + +//#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF) +function D3DSHADER_VERSION_MINOR(_Version : Cardinal) : Cardinal; +begin + Result:= (_Version shr 0) and $FF; +end; + +//#define D3DSHADER_COMMENT(_DWordSize) \ +// ((((_DWordSize)< 0; +end; + +function UnLoadDirect3D9: Boolean; +begin + Result:= True; + if Direct3D9Loaded then + begin + Result:= FreeLibrary(Direct3D9Lib); + _Direct3DCreate9:= nil; + Direct3D9Lib:= 0; + end; +end; + +function LoadDirect3D9: Boolean; +const + ProcName = 'Direct3DCreate9'; +begin + Result:= Direct3D9Loaded; + if (not Result) then + begin + Direct3D9Lib:= LoadLibrary(Direct3D9dll); + if Direct3D9Loaded then + begin + _Direct3DCreate9:= GetProcAddress(Direct3D9Lib, ProcName); + Result:= Assigned(_Direct3DCreate9); + if not Result then UnLoadDirect3D9; + end; + end; +end; +{$ELSE} +function Direct3D9Loaded: Boolean; +begin // Stub function for static linking + Result:= True; +end; + +function UnLoadDirect3D9: Boolean; +begin // Stub function for static linking + Result:= True; // should emulate "normal" behaviour +end; + +function LoadDirect3D9: Boolean; +begin // Stub function for static linking + Result:= True; +end; + +function _Direct3DCreate9(SDKVersion: LongWord): Pointer; external Direct3D9dll name 'Direct3DCreate9'; +{$ENDIF} + +function Direct3DCreate9(SDKVersion: LongWord): IDirect3D9; +begin +{$IFDEF DIRECT3D9_DYNAMIC_LINK} +{$IFDEF DIRECT3D9_DYNAMIC_LINK_EXPLICIT} + LoadDirect3D9; + +{$ENDIF} +{$ENDIF} + Result:= IDirect3D9(_Direct3DCreate9(SDKVersion)); + if Assigned(Result) then Result._Release; // Delphi autoincrement reference count +end; + +{$IFDEF DIRECT3D9_DYNAMIC_LINK} +initialization +{$IFNDEF DIRECT3D9_DYNAMIC_LINK_EXPLICIT} + LoadDirect3D9; +{$ENDIF} +finalization + UnLoadDirect3D9; +{$ENDIF} +end. + -- cgit v1.2.3