{******************************************************************************}
{*                                                                            *}
{*  copyright (c) microsoft corporation.  all rights reserved.                *}
{*                                                                            *}
{*  files:      d3d9types.h d3d9caps.h d3d9.h                                 *}
{*  content:    direct3d9 include files                                       *}
{*                                                                            *}
{*  directx 9.0 delphi / freepascal adaptation by alexey barkovoy             *}
{*  e-mail: directx@clootie.ru                                                *}
{*                                                                            *}
{*  latest version can be downloaded from:                                    *}
{*    http://clootie.ru                                                       *}
{*    http://sourceforge.net/projects/delphi-dx9sdk                           *}
{*                                                                            *}
{*----------------------------------------------------------------------------*}
{*  $id: direct3d9.pas,v 1.1 2005/09/12 22:04:53 z0m3ie exp $ }
{******************************************************************************}
{                                                                              }
{ obtained through: joint endeavour of delphi innovators (project jedi)        }
{                                                                              }
{ the contents of this file are used with permission, subject to the mozilla   }
{ public license version 1.1 (the "license"); you may not use this file except }
{ in compliance with the license. you may obtain a copy of the license at      }
{ http://www.mozilla.org/mpl/mpl-1.1.html                                      }
{                                                                              }
{ software distributed under the license is distributed on an "as is" basis,   }
{ without warranty of any kind, either express or implied. see the license for }
{ the specific language governing rights and limitations under the license.    }
{                                                                              }
{ alternatively, the contents of this file may be used under the terms of the  }
{ gnu lesser general public license (the  "lgpl license"), in which case the   }
{ provisions of the lgpl license are applicable instead of those above.        }
{ if you wish to allow use of your version of this file only under the terms   }
{ of the lgpl license and not to allow others to use your version of this file }
{ under the mpl, indicate your decision by deleting  the provisions above and  }
{ replace  them with the notice and other provisions required by the lgpl      }
{ license.  if you do not delete the provisions above, a recipient may use     }
{ your version of this file under either the mpl or the lgpl license.          }
{                                                                              }
{ for more information about the lgpl: http://www.gnu.org/copyleft/lesser.html }
{                                                                              }
{******************************************************************************}

{.$I DirectX.inc}

unit direct3d9;

interface

// Global level dynamic loading support
{$IFDEF DYNAMIC_LINK_ALL}
  {$DEFINE DIRECT3D9_DYNAMIC_LINK}
{$ENDIF}
{$IFDEF DYNAMIC_LINK_EXPLICIT_ALL}
  {$DEFINE DIRECT3D9_DYNAMIC_LINK_EXPLICIT}
{$ENDIF}

// Remove "dots" below to force some kind of dynamic linking
{.$DEFINE DIRECT3D9_DYNAMIC_LINK}
{.$DEFINE DIRECT3D9_DYNAMIC_LINK_EXPLICIT}


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;
  TD3DColor = DXTypes.TD3DColor;

// maps unsigned 8 bits/channel to D3DCOLOR
// #define D3DCOLOR_ARGB(a,r,g,b) \
//     ((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))
function D3DCOLOR_ARGB(a,r,g,b: DWord): TD3DColor;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
// #define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b)
function D3DCOLOR_RGBA(r,g,b,a: DWord): TD3DColor;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
// #define D3DCOLOR_XRGB(r,g,b)   D3DCOLOR_ARGB(0xff,r,g,b)
function D3DCOLOR_XRGB(r,g,b: DWord): TD3DColor;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}

// #define D3DCOLOR_XYUV(y,u,v)   D3DCOLOR_ARGB(0xff,y,u,v)
function D3DCOLOR_XYUV(y,u,v: DWord): TD3DColor;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
// #define D3DCOLOR_AYUV(a,y,u,v) D3DCOLOR_ARGB(a,y,u,v)
function D3DCOLOR_AYUV(a,y,u,v: DWord): TD3DColor;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}

// maps floating point channels (0.f to 1.f range) to D3DCOLOR
// #define D3DCOLOR_COLORVALUE(r,g,b,a) \
//     D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWORD)((a)*255.f))
function D3DCOLOR_COLORVALUE(r,g,b,a: Single): TD3DColor;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}

type
  _D3DVECTOR = DXTypes._D3DVECTOR;
  D3DVECTOR = DXTypes.D3DVECTOR;
  TD3DVector = DXTypes.TD3DVector;
  PD3DVector = DXTypes.PD3DVector;

  PD3DColorValue = ^TD3DColorValue;
  _D3DCOLORVALUE = packed record
    r: Single;
    g: Single;
    b: Single;
    a: Single;
  end {_D3DCOLORVALUE};
  D3DCOLORVALUE = _D3DCOLORVALUE;
  TD3DColorValue = _D3DCOLORVALUE;

  PD3DRect = ^TD3DRect;
  _D3DRECT = packed record
    x1: LongInt;
    y1: LongInt;
    x2: LongInt;
    y2: LongInt;
  end {_D3DRECT};
  D3DRECT = _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};
  D3DMATRIX = _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};
  D3DVIEWPORT9 = _D3DVIEWPORT9;
  TD3DViewport9 = _D3DVIEWPORT9;

(*
 * Values for clip fields.
 *)

const
  // Max number of user clipping planes, supported in D3D.
  D3DMAXUSERCLIPPLANES = 32;

  // These bits could be ORed together to use with D3DRS_CLIPPLANEENABLE
  //
  D3DCLIPPLANE0 = (1 shl 0);
  D3DCLIPPLANE1 = (1 shl 1);
  D3DCLIPPLANE2 = (1 shl 2);
  D3DCLIPPLANE3 = (1 shl 3);
  D3DCLIPPLANE4 = (1 shl 4);
  D3DCLIPPLANE5 = (1 shl 5);

  // The following bits are used in the ClipUnion and ClipIntersection
  // members of the D3DCLIPSTATUS9
  //
  D3DCS_LEFT    = $00000001;
  D3DCS_RIGHT   = $00000002;
  D3DCS_TOP     = $00000004;
  D3DCS_BOTTOM  = $00000008;
  D3DCS_FRONT   = $00000010;
  D3DCS_BACK    = $00000020;
  D3DCS_PLANE0  = $00000040;
  D3DCS_PLANE1  = $00000080;
  D3DCS_PLANE2  = $00000100;
  D3DCS_PLANE3  = $00000200;
  D3DCS_PLANE4  = $00000400;
  D3DCS_PLANE5  = $00000800;

  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;

type
  PD3DClipStatus9 = ^TD3DClipStatus9;
  _D3DCLIPSTATUS9 = packed record
    ClipUnion: DWord;
    ClipIntersection: DWord;
  end {_D3DCLIPSTATUS9};
  D3DCLIPSTATUS9 = _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};
  D3DMATERIAL9 = _D3DMATERIAL9;
  TD3DMaterial9 = _D3DMATERIAL9;

  _D3DLIGHTTYPE = (
    D3DLIGHT_INVALID_0, {= 0}
    D3DLIGHT_POINT,     {= 1}
    D3DLIGHT_SPOT,      {= 2}
    D3DLIGHT_DIRECTIONAL{= 3}
  );
  D3DLIGHTTYPE = _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};
  D3DLIGHT9 = _D3DLIGHT9;
  TD3DLight9 = _D3DLIGHT9;

(*
 * Options for clearing
 *)
const
  D3DCLEAR_TARGET       = $00000001; { Clear target surface }
  D3DCLEAR_ZBUFFER      = $00000002; { Clear target z buffer }
  D3DCLEAR_STENCIL      = $00000004; { Clear stencil planes }

(*
 * The following defines the rendering states
 *)
type
  _D3DSHADEMODE = DWord;
  D3DSHADEMODE = _D3DSHADEMODE;
  TD3DShadeMode = _D3DSHADEMODE;

const
  D3DSHADE_FLAT      = 1;
  D3DSHADE_GOURAUD   = 2;
  D3DSHADE_PHONG     = 3;

type
  _D3DFILLMODE = DWord;
  D3DFILLMODE = _D3DFILLMODE;
  TD3DFillMode = _D3DFILLMODE;

const
  D3DFILL_POINT      = 1;
  D3DFILL_WIREFRAME  = 2;
  D3DFILL_SOLID      = 3;

type
  _D3DBLEND = DWord;
  D3DBLEND = _D3DBLEND;
  TD3DBlend = _D3DBLEND;

const
  D3DBLEND_ZERO              = 1;
  D3DBLEND_ONE               = 2;
  D3DBLEND_SRCCOLOR          = 3;
  D3DBLEND_INVSRCCOLOR       = 4;
  D3DBLEND_SRCALPHA          = 5;
  D3DBLEND_INVSRCALPHA       = 6;
  D3DBLEND_DESTALPHA         = 7;
  D3DBLEND_INVDESTALPHA      = 8;
  D3DBLEND_DESTCOLOR         = 9;
  D3DBLEND_INVDESTCOLOR      = 10;
  D3DBLEND_SRCALPHASAT       = 11;
  D3DBLEND_BOTHSRCALPHA      = 12;
  D3DBLEND_BOTHINVSRCALPHA   = 13;
  D3DBLEND_BLENDFACTOR       = 14; (* Only supported if D3DPBLENDCAPS_BLENDFACTOR is on *)
  D3DBLEND_INVBLENDFACTOR    = 15; (* Only supported if D3DPBLENDCAPS_BLENDFACTOR is on *)

type
  _D3DBLENDOP = DWord;
  D3DBLENDOP = _D3DBLENDOP;
  TD3DBlendOp = _D3DBLENDOP;

const
  D3DBLENDOP_ADD             = 1;
  D3DBLENDOP_SUBTRACT        = 2;
  D3DBLENDOP_REVSUBTRACT     = 3;
  D3DBLENDOP_MIN             = 4;
  D3DBLENDOP_MAX             = 5;

type
  _D3DTEXTUREADDRESS = DWord;
  D3DTEXTUREADDRESS = _D3DTEXTUREADDRESS;
  TD3DTextureAddress = _D3DTEXTUREADDRESS;

const
  D3DTADDRESS_WRAP           = 1;
  D3DTADDRESS_MIRROR         = 2;
  D3DTADDRESS_CLAMP          = 3;
  D3DTADDRESS_BORDER         = 4;
  D3DTADDRESS_MIRRORONCE     = 5;

type
  _D3DCULL = DWord;
  D3DCULL = _D3DCULL;
  TD3DCull = _D3DCULL;

const
  D3DCULL_NONE       = 1;
  D3DCULL_CW         = 2;
  D3DCULL_CCW        = 3;

type
  _D3DCMPFUNC = DWord;
  D3DCMPFUNC = _D3DCMPFUNC;
  TD3DCmpFunc = _D3DCMPFUNC;

const
  D3DCMP_NEVER          = 1;
  D3DCMP_LESS           = 2;
  D3DCMP_EQUAL          = 3;
  D3DCMP_LESSEQUAL      = 4;
  D3DCMP_GREATER        = 5;
  D3DCMP_NOTEQUAL       = 6;
  D3DCMP_GREATEREQUAL   = 7;
  D3DCMP_ALWAYS         = 8;

type
  _D3DSTENCILOP = DWord;
  D3DSTENCILOP = _D3DSTENCILOP;
  TD3DStencilOp = _D3DSTENCILOP;

const
  D3DSTENCILOP_KEEP     = 1;
  D3DSTENCILOP_ZERO     = 2;
  D3DSTENCILOP_REPLACE  = 3;
  D3DSTENCILOP_INCRSAT  = 4;
  D3DSTENCILOP_DECRSAT  = 5;
  D3DSTENCILOP_INVERT   = 6;
  D3DSTENCILOP_INCR     = 7;
  D3DSTENCILOP_DECR     = 8;

type
  _D3DFOGMODE = DWord;
  D3DFOGMODE = _D3DFOGMODE;
  TD3DFogMode = _D3DFOGMODE;

const
  D3DFOG_NONE   = 0;
  D3DFOG_EXP    = 1;
  D3DFOG_EXP2   = 2;
  D3DFOG_LINEAR = 3;

type
  _D3DZBUFFERTYPE = DWord;
  D3DZBUFFERTYPE = _D3DZBUFFERTYPE;
  TD3DZBufferType = _D3DZBUFFERTYPE;

const
  D3DZB_FALSE   = 0;
  D3DZB_TRUE    = 1;
  D3DZB_USEW    = 2;

type
  // Primitives supported by draw-primitive API
  _D3DPRIMITIVETYPE = (
    D3DPT_INVALID_0    {= 0},
    D3DPT_POINTLIST    {= 1},
    D3DPT_LINELIST     {= 2},
    D3DPT_LINESTRIP    {= 3},
    D3DPT_TRIANGLELIST {= 4},
    D3DPT_TRIANGLESTRIP{= 5},
    D3DPT_TRIANGLEFAN  {= 6}
  );
  D3DPRIMITIVETYPE = _D3DPRIMITIVETYPE;
  TD3DPrimitiveType = _D3DPRIMITIVETYPE;

const
  D3DTS_VIEW          = 2;
  D3DTS_PROJECTION    = 3;
  D3DTS_TEXTURE0      = 16;
  D3DTS_TEXTURE1      = 17;
  D3DTS_TEXTURE2      = 18;
  D3DTS_TEXTURE3      = 19;
  D3DTS_TEXTURE4      = 20;
  D3DTS_TEXTURE5      = 21;
  D3DTS_TEXTURE6      = 22;
  D3DTS_TEXTURE7      = 23;
  D3DTS_FORCE_DWORD   = $7fffffff; (* force 32-bit size enum *)

type
  _D3DTRANSFORMSTATETYPE = DWord;
  D3DTRANSFORMSTATETYPE = _D3DTRANSFORMSTATETYPE;
  TD3DTransformStateType = _D3DTRANSFORMSTATETYPE;

// #define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256)
function D3DTS_WORLDMATRIX(index: Byte): TD3DTransformStateType;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}

const
  D3DTS_WORLD   =  TD3DTransformStateType(0 + 256); // #define D3DTS_WORLD  D3DTS_WORLDMATRIX(0)
  D3DTS_WORLD1  =  TD3DTransformStateType(1 + 256); // #define D3DTS_WORLD1 D3DTS_WORLDMATRIX(1)
  D3DTS_WORLD2  =  TD3DTransformStateType(2 + 256); // #define D3DTS_WORLD2 D3DTS_WORLDMATRIX(2)
  D3DTS_WORLD3  =  TD3DTransformStateType(3 + 256); // #define D3DTS_WORLD3 D3DTS_WORLDMATRIX(3)

type
  _D3DRENDERSTATETYPE = DWord;
  D3DRENDERSTATETYPE = _D3DRENDERSTATETYPE;
  TD3DRenderStateType = _D3DRENDERSTATETYPE;

const
  D3DRS_ZENABLE                   = TD3DRenderStateType(7);    { D3DZBUFFERTYPE (or TRUE/FALSE for legacy) }
  D3DRS_FILLMODE                  = TD3DRenderStateType(8);    { D3DFILLMODE }
  D3DRS_SHADEMODE                 = TD3DRenderStateType(9);    { D3DSHADEMODE }
  D3DRS_ZWRITEENABLE              = TD3DRenderStateType(14);   { TRUE to enable z writes }
  D3DRS_ALPHATESTENABLE           = TD3DRenderStateType(15);   { TRUE to enable alpha tests }
  D3DRS_LASTPIXEL                 = TD3DRenderStateType(16);   { TRUE for last-pixel on lines }
  D3DRS_SRCBLEND                  = TD3DRenderStateType(19);   { D3DBLEND }
  D3DRS_DESTBLEND                 = TD3DRenderStateType(20);   { D3DBLEND }
  D3DRS_CULLMODE                  = TD3DRenderStateType(22);   { D3DCULL }
  D3DRS_ZFUNC                     = TD3DRenderStateType(23);   { D3DCMPFUNC }
  D3DRS_ALPHAREF                  = TD3DRenderStateType(24);   { D3DFIXED }
  D3DRS_ALPHAFUNC                 = TD3DRenderStateType(25);   { D3DCMPFUNC }
  D3DRS_DITHERENABLE              = TD3DRenderStateType(26);   { TRUE to enable dithering }
  D3DRS_ALPHABLENDENABLE          = TD3DRenderStateType(27);   { TRUE to enable alpha blending }
  D3DRS_FOGENABLE                 = TD3DRenderStateType(28);   { TRUE to enable fog blending }
  D3DRS_SPECULARENABLE            = TD3DRenderStateType(29);   { TRUE to enable specular }
  D3DRS_FOGCOLOR                  = TD3DRenderStateType(34);   { D3DCOLOR }
  D3DRS_FOGTABLEMODE              = TD3DRenderStateType(35);   { D3DFOGMODE }
  D3DRS_FOGSTART                  = TD3DRenderStateType(36);   { Fog start (for both vertex and pixel fog) }
  D3DRS_FOGEND                    = TD3DRenderStateType(37);   { Fog end      }
  D3DRS_FOGDENSITY                = TD3DRenderStateType(38);   { Fog density  }
  D3DRS_RANGEFOGENABLE            = TD3DRenderStateType(48);   { Enables range-based fog }
  D3DRS_STENCILENABLE             = TD3DRenderStateType(52);   { BOOL enable/disable stenciling }
  D3DRS_STENCILFAIL               = TD3DRenderStateType(53);   { D3DSTENCILOP to do if stencil test fails }
  D3DRS_STENCILZFAIL              = TD3DRenderStateType(54);   { D3DSTENCILOP to do if stencil test passes and Z test fails }
  D3DRS_STENCILPASS               = TD3DRenderStateType(55);   { D3DSTENCILOP to do if both stencil and Z tests pass }
  D3DRS_STENCILFUNC               = TD3DRenderStateType(56);   { D3DCMPFUNC fn.  Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true }
  D3DRS_STENCILREF                = TD3DRenderStateType(57);   { Reference value used in stencil test }
  D3DRS_STENCILMASK               = TD3DRenderStateType(58);   { Mask value used in stencil test }
  D3DRS_STENCILWRITEMASK          = TD3DRenderStateType(59);   { Write mask applied to values written to stencil buffer }
  D3DRS_TEXTUREFACTOR             = TD3DRenderStateType(60);   { D3DCOLOR used for multi-texture blend }
  D3DRS_WRAP0                     = TD3DRenderStateType(128);  { wrap for 1st texture coord. set }
  D3DRS_WRAP1                     = TD3DRenderStateType(129);  { wrap for 2nd texture coord. set }
  D3DRS_WRAP2                     = TD3DRenderStateType(130);  { wrap for 3rd texture coord. set }
  D3DRS_WRAP3                     = TD3DRenderStateType(131);  { wrap for 4th texture coord. set }
  D3DRS_WRAP4                     = TD3DRenderStateType(132);  { wrap for 5th texture coord. set }
  D3DRS_WRAP5                     = TD3DRenderStateType(133);  { wrap for 6th texture coord. set }
  D3DRS_WRAP6                     = TD3DRenderStateType(134);  { wrap for 7th texture coord. set }
  D3DRS_WRAP7                     = TD3DRenderStateType(135);  { wrap for 8th texture coord. set }
  D3DRS_CLIPPING                  = TD3DRenderStateType(136);
  D3DRS_LIGHTING                  = TD3DRenderStateType(137);
  D3DRS_AMBIENT                   = TD3DRenderStateType(139);
  D3DRS_FOGVERTEXMODE             = TD3DRenderStateType(140);
  D3DRS_COLORVERTEX               = TD3DRenderStateType(141);
  D3DRS_LOCALVIEWER               = TD3DRenderStateType(142);
  D3DRS_NORMALIZENORMALS          = TD3DRenderStateType(143);
  D3DRS_DIFFUSEMATERIALSOURCE     = TD3DRenderStateType(145);
  D3DRS_SPECULARMATERIALSOURCE    = TD3DRenderStateType(146);
  D3DRS_AMBIENTMATERIALSOURCE     = TD3DRenderStateType(147);
  D3DRS_EMISSIVEMATERIALSOURCE    = TD3DRenderStateType(148);
  D3DRS_VERTEXBLEND               = TD3DRenderStateType(151);
  D3DRS_CLIPPLANEENABLE           = TD3DRenderStateType(152);
  D3DRS_POINTSIZE                 = TD3DRenderStateType(154);   { float point size }
  D3DRS_POINTSIZE_MIN             = TD3DRenderStateType(155);   { float point size min threshold }
  D3DRS_POINTSPRITEENABLE         = TD3DRenderStateType(156);   { BOOL point texture coord control }
  D3DRS_POINTSCALEENABLE          = TD3DRenderStateType(157);   { BOOL point size scale enable }
  D3DRS_POINTSCALE_A              = TD3DRenderStateType(158);   { float point attenuation A value }
  D3DRS_POINTSCALE_B              = TD3DRenderStateType(159);   { float point attenuation B value }
  D3DRS_POINTSCALE_C              = TD3DRenderStateType(160);   { float point attenuation C value }
  D3DRS_MULTISAMPLEANTIALIAS      = TD3DRenderStateType(161);  // BOOL - set to do FSAA with multisample buffer
  D3DRS_MULTISAMPLEMASK           = TD3DRenderStateType(162);  // DWORD - per-sample enable/disable
  D3DRS_PATCHEDGESTYLE            = TD3DRenderStateType(163);  // Sets whether patch edges will use float style tessellation
  D3DRS_DEBUGMONITORTOKEN         = TD3DRenderStateType(165);  // DEBUG ONLY - token to debug monitor
  D3DRS_POINTSIZE_MAX             = TD3DRenderStateType(166);   { float point size max threshold }
  D3DRS_INDEXEDVERTEXBLENDENABLE  = TD3DRenderStateType(167);
  D3DRS_COLORWRITEENABLE          = TD3DRenderStateType(168);  // per-channel write enable
  D3DRS_TWEENFACTOR               = TD3DRenderStateType(170);   // float tween factor
  D3DRS_BLENDOP                   = TD3DRenderStateType(171);   // D3DBLENDOP setting
  D3DRS_POSITIONDEGREE            = TD3DRenderStateType(172);   // NPatch position interpolation degree. D3DDEGREE_LINEAR or D3DDEGREE_CUBIC (default)
  D3DRS_NORMALDEGREE              = TD3DRenderStateType(173);   // NPatch normal interpolation degree. D3DDEGREE_LINEAR (default) or D3DDEGREE_QUADRATIC
  D3DRS_SCISSORTESTENABLE         = TD3DRenderStateType(174);
  D3DRS_SLOPESCALEDEPTHBIAS       = TD3DRenderStateType(175);
  D3DRS_ANTIALIASEDLINEENABLE     = TD3DRenderStateType(176);
  D3DRS_MINTESSELLATIONLEVEL      = TD3DRenderStateType(178);
  D3DRS_MAXTESSELLATIONLEVEL      = TD3DRenderStateType(179);
  D3DRS_ADAPTIVETESS_X            = TD3DRenderStateType(180);
  D3DRS_ADAPTIVETESS_Y            = TD3DRenderStateType(181);
  D3DRS_ADAPTIVETESS_Z            = TD3DRenderStateType(182);
  D3DRS_ADAPTIVETESS_W            = TD3DRenderStateType(183);
  D3DRS_ENABLEADAPTIVETESSELLATION = TD3DRenderStateType(184);
  D3DRS_TWOSIDEDSTENCILMODE       = TD3DRenderStateType(185);   (* BOOL enable/disable 2 sided stenciling *)
  D3DRS_CCW_STENCILFAIL           = TD3DRenderStateType(186);   (* D3DSTENCILOP to do if ccw stencil test fails *)
  D3DRS_CCW_STENCILZFAIL          = TD3DRenderStateType(187);   (* D3DSTENCILOP to do if ccw stencil test passes and Z test fails *)
  D3DRS_CCW_STENCILPASS           = TD3DRenderStateType(188);   (* D3DSTENCILOP to do if both ccw stencil and Z tests pass *)
  D3DRS_CCW_STENCILFUNC           = TD3DRenderStateType(189);   (* D3DCMPFUNC fn.  ccw Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true *)
  D3DRS_COLORWRITEENABLE1         = TD3DRenderStateType(190);   (* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS *)
  D3DRS_COLORWRITEENABLE2         = TD3DRenderStateType(191);   (* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS *)
  D3DRS_COLORWRITEENABLE3         = TD3DRenderStateType(192);   (* Additional ColorWriteEnables for the devices that support D3DPMISCCAPS_INDEPENDENTWRITEMASKS *)
  D3DRS_BLENDFACTOR               = TD3DRenderStateType(193);   (* D3DCOLOR used for a constant blend factor during alpha blending for devices that support D3DPBLENDCAPS_BLENDFACTOR *)
  D3DRS_SRGBWRITEENABLE           = TD3DRenderStateType(194);   (* Enable rendertarget writes to be DE-linearized to SRGB (for formats that expose D3DUSAGE_QUERY_SRGBWRITE) *)
  D3DRS_DEPTHBIAS                 = TD3DRenderStateType(195);
  D3DRS_WRAP8                     = TD3DRenderStateType(198);   (* Additional wrap states for vs_3_0+ attributes with D3DDECLUSAGE_TEXCOORD *)
  D3DRS_WRAP9                     = TD3DRenderStateType(199);
  D3DRS_WRAP10                    = TD3DRenderStateType(200);
  D3DRS_WRAP11                    = TD3DRenderStateType(201);
  D3DRS_WRAP12                    = TD3DRenderStateType(202);
  D3DRS_WRAP13                    = TD3DRenderStateType(203);
  D3DRS_WRAP14                    = TD3DRenderStateType(204);
  D3DRS_WRAP15                    = TD3DRenderStateType(205);
  D3DRS_SEPARATEALPHABLENDENABLE  = TD3DRenderStateType(206);  (* TRUE to enable a separate blending function for the alpha channel *)
  D3DRS_SRCBLENDALPHA             = TD3DRenderStateType(207);  (* SRC blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE *)
  D3DRS_DESTBLENDALPHA            = TD3DRenderStateType(208);  (* DST blend factor for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE *)
  D3DRS_BLENDOPALPHA              = TD3DRenderStateType(209);  (* Blending operation for the alpha channel when D3DRS_SEPARATEDESTALPHAENABLE is TRUE *)


  D3DRS_FORCE_DWORD               = TD3DRenderStateType($7fffffff); { force 32-bit size enum }

const
  // Maximum number of simultaneous render targets D3D supports
  D3D_MAX_SIMULTANEOUS_RENDERTARGETS = 4;

type
  // Values for material source
  _D3DMATERIALCOLORSOURCE = DWord;
  D3DMATERIALCOLORSOURCE = _D3DMATERIALCOLORSOURCE;
  TD3DMaterialSource = _D3DMATERIALCOLORSOURCE;

const
  D3DMCS_MATERIAL       = TD3DMaterialSource(0);         // Color from material is used
  D3DMCS_COLOR1         = TD3DMaterialSource(1);         // Diffuse vertex color is used
  D3DMCS_COLOR2         = TD3DMaterialSource(2);         // Specular vertex color is used
  D3DMCS_FORCE_DWORD    = TD3DMaterialSource($7fffffff); // force 32-bit size enum

  // Bias to apply to the texture coordinate set to apply a wrap to.
  D3DRENDERSTATE_WRAPBIAS                = DWORD(128);

  { Flags to construct the WRAP render states }
  D3DWRAP_U             = $00000001;
  D3DWRAP_V             = $00000002;
  D3DWRAP_W             = $00000004;

  { Flags to construct the WRAP render states for 1D thru 4D texture coordinates }
  D3DWRAPCOORD_0        = $00000001;    // same as D3DWRAP_U
  D3DWRAPCOORD_1        = $00000002;    // same as D3DWRAP_V
  D3DWRAPCOORD_2        = $00000004;    // same as D3DWRAP_W
  D3DWRAPCOORD_3        = $00000008;

  { Flags to construct D3DRS_COLORWRITEENABLE }
  D3DCOLORWRITEENABLE_RED       = (1 shl 0);
  D3DCOLORWRITEENABLE_GREEN     = (1 shl 1);
  D3DCOLORWRITEENABLE_BLUE      = (1 shl 2);
  D3DCOLORWRITEENABLE_ALPHA     = (1 shl 3);

(*
 * State enumerants for per-stage processing of fixed function pixel processing
 * Two of these affect fixed function vertex processing as well: TEXTURETRANSFORMFLAGS and TEXCOORDINDEX.
 *)
type
  _D3DTEXTURESTAGESTATETYPE = DWord;
  D3DTEXTURESTAGESTATETYPE = _D3DTEXTURESTAGESTATETYPE;
  TD3DTextureStageStateType = _D3DTEXTURESTAGESTATETYPE;

const
  D3DTSS_COLOROP        = TD3DTextureStageStateType( 1); { D3DTEXTUREOP - per-stage blending controls for color channels }
  D3DTSS_COLORARG1      = TD3DTextureStageStateType( 2); { D3DTA_* (texture arg) }
  D3DTSS_COLORARG2      = TD3DTextureStageStateType( 3); { D3DTA_* (texture arg) }
  D3DTSS_ALPHAOP        = TD3DTextureStageStateType( 4); { D3DTEXTUREOP - per-stage blending controls for alpha channel }
  D3DTSS_ALPHAARG1      = TD3DTextureStageStateType( 5); { D3DTA_* (texture arg) }
  D3DTSS_ALPHAARG2      = TD3DTextureStageStateType( 6); { D3DTA_* (texture arg) }
  D3DTSS_BUMPENVMAT00   = TD3DTextureStageStateType( 7); { float (bump mapping matrix) }
  D3DTSS_BUMPENVMAT01   = TD3DTextureStageStateType( 8); { float (bump mapping matrix) }
  D3DTSS_BUMPENVMAT10   = TD3DTextureStageStateType( 9); { float (bump mapping matrix) }
  D3DTSS_BUMPENVMAT11   = TD3DTextureStageStateType(10); { float (bump mapping matrix) }
  D3DTSS_TEXCOORDINDEX  = TD3DTextureStageStateType(11); { identifies which set of texture coordinates index this texture }
  D3DTSS_BUMPENVLSCALE  = TD3DTextureStageStateType(22); { float scale for bump map luminance }
  D3DTSS_BUMPENVLOFFSET = TD3DTextureStageStateType(23); { float offset for bump map luminance }
  D3DTSS_TEXTURETRANSFORMFLAGS = TD3DTextureStageStateType(24); { D3DTEXTURETRANSFORMFLAGS controls texture transform }
  D3DTSS_COLORARG0      = TD3DTextureStageStateType(26); { D3DTA_* third arg for triadic ops }
  D3DTSS_ALPHAARG0      = TD3DTextureStageStateType(27); { D3DTA_* third arg for triadic ops }
  D3DTSS_RESULTARG      = TD3DTextureStageStateType(28); { D3DTA_* arg for result (CURRENT or TEMP) }
  D3DTSS_CONSTANT       = TD3DTextureStageStateType(32); { Per-stage constant D3DTA_CONSTANT }

  D3DTSS_FORCE_DWORD    = TD3DTextureStageStateType($7fffffff); { force 32-bit size enum }

type
(*
 * State enumerants for per-sampler texture processing.
 *)
  _D3DSAMPLERSTATETYPE = (
    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  }
  );
  D3DSAMPLERSTATETYPE = _D3DSAMPLERSTATETYPE;
  TD3DSamplerStateType = _D3DSAMPLERSTATETYPE;

const
  { Special sampler which is used in the tesselator }
  D3DDMAPSAMPLER = 256;

  // Samplers used in vertex shaders
  D3DVERTEXTEXTURESAMPLER0 = (D3DDMAPSAMPLER+1);
  D3DVERTEXTEXTURESAMPLER1 = (D3DDMAPSAMPLER+2);
  D3DVERTEXTEXTURESAMPLER2 = (D3DDMAPSAMPLER+3);
  D3DVERTEXTEXTURESAMPLER3 = (D3DDMAPSAMPLER+4);

  // 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;
  D3DTSS_TCI_CAMERASPACENORMAL                  = $00010000;
  D3DTSS_TCI_CAMERASPACEPOSITION                = $00020000;
  D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR        = $00030000;
  D3DTSS_TCI_SPHEREMAP                          = $00040000;

(*
 * Enumerations for COLOROP and ALPHAOP texture blending operations set in
 * texture processing stage controls in D3DTSS.
 *)
type
  _D3DTEXTUREOP = DWord;
  D3DTEXTUREOP = _D3DTEXTUREOP;
  TD3DTextureOp = _D3DTEXTUREOP;

const
  // Control
  D3DTOP_DISABLE              = 1;      // disables stage
  D3DTOP_SELECTARG1           = 2;      // the default
  D3DTOP_SELECTARG2           = 3;

  // Modulate
  D3DTOP_MODULATE             = 4;      // multiply args together
  D3DTOP_MODULATE2X           = 5;      // multiply and  1 bit
  D3DTOP_MODULATE4X           = 6;      // multiply and  2 bits

  // Add
  D3DTOP_ADD                  =  7;   // add arguments together
  D3DTOP_ADDSIGNED            =  8;   // add with -0.5 bias
  D3DTOP_ADDSIGNED2X          =  9;   // as above but left  1 bit
  D3DTOP_SUBTRACT             = 10;   // Arg1 - Arg2, with no saturation
  D3DTOP_ADDSMOOTH            = 11;   // add 2 args, subtract product
                                      // Arg1 + Arg2 - Arg1*Arg2
                                      // = Arg1 + (1-Arg1)*Arg2

  // Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha)
  D3DTOP_BLENDDIFFUSEALPHA    = 12; // iterated alpha
  D3DTOP_BLENDTEXTUREALPHA    = 13; // texture alpha
  D3DTOP_BLENDFACTORALPHA     = 14; // alpha from D3DRS_TEXTUREFACTOR

  // Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha)
  D3DTOP_BLENDTEXTUREALPHAPM  = 15; // texture alpha
  D3DTOP_BLENDCURRENTALPHA    = 16; // by alpha of current color

  // Specular mapping
  D3DTOP_PREMODULATE            = 17;     // modulate with next texture before use
  D3DTOP_MODULATEALPHA_ADDCOLOR = 18;     // Arg1.RGB + Arg1.A*Arg2.RGB
                                          // COLOROP only
  D3DTOP_MODULATECOLOR_ADDALPHA = 19;     // Arg1.RGB*Arg2.RGB + Arg1.A
                                          // COLOROP only
  D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20;  // (1-Arg1.A)*Arg2.RGB + Arg1.RGB
                                          // COLOROP only
  D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21;  // (1-Arg1.RGB)*Arg2.RGB + Arg1.A
                                          // COLOROP only

  // Bump mapping
  D3DTOP_BUMPENVMAP           = 22; // per pixel env map perturbation
  D3DTOP_BUMPENVMAPLUMINANCE  = 23; // with luminance channel

  // 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;

  // Triadic ops
  D3DTOP_MULTIPLYADD          = 25; // Arg0 + Arg1*Arg2
  D3DTOP_LERP                 = 26; // (Arg0)*Arg1 + (1-Arg0)*Arg2

(*
 * 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
  D3DTA_DIFFUSE           = $00000000;  // select diffuse color (read only)
  D3DTA_CURRENT           = $00000001;  // select stage destination register (read/write)
  D3DTA_TEXTURE           = $00000002;  // select texture color (read only)
  D3DTA_TFACTOR           = $00000003;  // select D3DRS_TEXTUREFACTOR (read only)
  D3DTA_SPECULAR          = $00000004;  // select specular color (read only)
  D3DTA_TEMP              = $00000005;  // select temporary register color (read/write)
  D3DTA_CONSTANT          = $00000006;  // select texture stage constant
  D3DTA_COMPLEMENT        = $00000010;  // take 1.0 - x (read modifier)
  D3DTA_ALPHAREPLICATE    = $00000020;  // replicate alpha to color components (read modifier)

type
  //
  // Values for D3DSAMP_***FILTER texture stage states
  //
  _D3DTEXTUREFILTERTYPE = DWord;
  D3DTEXTUREFILTERTYPE = _D3DTEXTUREFILTERTYPE;
  TD3DTextureFilterType = _D3DTEXTUREFILTERTYPE;

const
  D3DTEXF_NONE            = 0;    // filtering disabled (valid for mip filter only)
  D3DTEXF_POINT           = 1;    // nearest
  D3DTEXF_LINEAR          = 2;    // linear interpolation
  D3DTEXF_ANISOTROPIC     = 3;    // anisotropic
  D3DTEXF_PYRAMIDALQUAD   = 6;    // 4-sample tent
  D3DTEXF_GAUSSIANQUAD    = 7;    // 4-sample gaussian

const
  { Bits for Flags in ProcessVertices call }
  D3DPV_DONOTCOPYDATA        = (1 shl 0);

//-------------------------------------------------------------------

  // Flexible vertex format bits
  //
  D3DFVF_RESERVED0        = $001;
  D3DFVF_POSITION_MASK    = $400E;
  D3DFVF_XYZ              = $002;
  D3DFVF_XYZRHW           = $004;
  D3DFVF_XYZB1            = $006;
  D3DFVF_XYZB2            = $008;
  D3DFVF_XYZB3            = $00a;
  D3DFVF_XYZB4            = $00c;
  D3DFVF_XYZB5            = $00e;
  D3DFVF_XYZW             = $4002;

  D3DFVF_NORMAL           = $010;
  D3DFVF_PSIZE            = $020;
  D3DFVF_DIFFUSE          = $040;
  D3DFVF_SPECULAR         = $080;

  D3DFVF_TEXCOUNT_MASK    = $f00;
  D3DFVF_TEXCOUNT_SHIFT   = 8;
  D3DFVF_TEX0             = $000;
  D3DFVF_TEX1             = $100;
  D3DFVF_TEX2             = $200;
  D3DFVF_TEX3             = $300;
  D3DFVF_TEX4             = $400;
  D3DFVF_TEX5             = $500;
  D3DFVF_TEX6             = $600;
  D3DFVF_TEX7             = $700;
  D3DFVF_TEX8             = $800;

  D3DFVF_LASTBETA_UBYTE4   = $1000;
  D3DFVF_LASTBETA_D3DCOLOR = $8000;

  D3DFVF_RESERVED2         = $6000;  // 2 reserved bits

//---------------------------------------------------------------------
// 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
  );
  D3DDECLUSAGE = _D3DDECLUSAGE;
  TD3DDeclUsage = _D3DDECLUSAGE;

const
  MAXD3DDECLUSAGE         = DWORD(D3DDECLUSAGE_SAMPLE);
  MAXD3DDECLUSAGEINDEX    = 15;
  MAXD3DDECLLENGTH        = 64; // does not include "end" marker vertex element

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
  );
  D3DDECLMETHOD = _D3DDECLMETHOD;
  TD3DDeclMethod = _D3DDECLMETHOD;

const
  MAXD3DDECLMETHOD = DWORD(D3DDECLMETHOD_LOOKUPPRESAMPLED);

type
  // Declarations for _Type fields
  //
  _D3DDECLTYPE = (
    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.
  );
  D3DDECLTYPE = _D3DDECLTYPE;
  TD3DDeclType = _D3DDECLTYPE;

// Restores enums to be 4 byte in size
{$MINENUMSIZE 4}

const
  MAXD3DDECLTYPE      = DWORD(D3DDECLTYPE_UNUSED);

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;
  D3DVERTEXELEMENT9 = _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);

// Maximum supported number of texture coordinate sets
const
  D3DDP_MAXTEXCOORD   = 8;

//---------------------------------------------------------------------
// Values for IDirect3DDevice9::SetStreamSourceFreq's Setting parameter
//---------------------------------------------------------------------
  D3DSTREAMSOURCE_INDEXEDDATA  = LongWord(1 shl 30);
  D3DSTREAMSOURCE_INSTANCEDATA = LongWord(2 shl 30);


//---------------------------------------------------------------------
//
// 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;

  D3DSI_INSTLENGTH_MASK   = $0F000000;
  D3DSI_INSTLENGTH_SHIFT  = 24;

type 
  _D3DSHADER_INSTRUCTION_OPCODE_TYPE = DWord;
  D3DSHADER_INSTRUCTION_OPCODE_TYPE = _D3DSHADER_INSTRUCTION_OPCODE_TYPE;
  TD3DShaderInstructionOpcodeType = _D3DSHADER_INSTRUCTION_OPCODE_TYPE;

const
  D3DSIO_NOP          = 0;
  D3DSIO_MOV          = 1;
  D3DSIO_ADD          = 2;
  D3DSIO_SUB          = 3;
  D3DSIO_MAD          = 4;
  D3DSIO_MUL          = 5;
  D3DSIO_RCP          = 6;
  D3DSIO_RSQ          = 7;
  D3DSIO_DP3          = 8;
  D3DSIO_DP4          = 9;
  D3DSIO_MIN          = 10;
  D3DSIO_MAX          = 11;
  D3DSIO_SLT          = 12;
  D3DSIO_SGE          = 13;
  D3DSIO_EXP          = 14;
  D3DSIO_LOG          = 15;
  D3DSIO_LIT          = 16;
  D3DSIO_DST          = 17;
  D3DSIO_LRP          = 18;
  D3DSIO_FRC          = 19;
  D3DSIO_M4x4         = 20;
  D3DSIO_M4x3         = 21;
  D3DSIO_M3x4         = 22;
  D3DSIO_M3x3         = 23;
  D3DSIO_M3x2         = 24;
  D3DSIO_CALL         = 25;
  D3DSIO_CALLNZ       = 26;
  D3DSIO_LOOP         = 27;
  D3DSIO_RET          = 28;
  D3DSIO_ENDLOOP      = 29;
  D3DSIO_LABEL        = 30;
  D3DSIO_DCL          = 31;
  D3DSIO_POW          = 32;
  D3DSIO_CRS          = 33;
  D3DSIO_SGN          = 34;
  D3DSIO_ABS          = 35;
  D3DSIO_NRM          = 36;
  D3DSIO_SINCOS       = 37;
  D3DSIO_REP          = 38;
  D3DSIO_ENDREP       = 39;
  D3DSIO_IF           = 40;
  D3DSIO_IFC          = 41;
  D3DSIO_ELSE         = 42;
  D3DSIO_ENDIF        = 43;
  D3DSIO_BREAK        = 44;
  D3DSIO_BREAKC       = 45;
  D3DSIO_MOVA         = 46;
  D3DSIO_DEFB         = 47;
  D3DSIO_DEFI         = 48;

  D3DSIO_TEXCOORD     = 64;
  D3DSIO_TEXKILL      = 65;
  D3DSIO_TEX          = 66;
  D3DSIO_TEXBEM       = 67;
  D3DSIO_TEXBEML      = 68;
  D3DSIO_TEXREG2AR    = 69;
  D3DSIO_TEXREG2GB    = 70;
  D3DSIO_TEXM3x2PAD   = 71;
  D3DSIO_TEXM3x2TEX   = 72;
  D3DSIO_TEXM3x3PAD   = 73;
  D3DSIO_TEXM3x3TEX   = 74;
  D3DSIO_RESERVED0    = 75;
  D3DSIO_TEXM3x3SPEC  = 76;
  D3DSIO_TEXM3x3VSPEC = 77;
  D3DSIO_EXPP         = 78;
  D3DSIO_LOGP         = 79;
  D3DSIO_CND          = 80;
  D3DSIO_DEF          = 81;
  D3DSIO_TEXREG2RGB   = 82;
  D3DSIO_TEXDP3TEX    = 83;
  D3DSIO_TEXM3x2DEPTH = 84;
  D3DSIO_TEXDP3       = 85;
  D3DSIO_TEXM3x3      = 86;
  D3DSIO_TEXDEPTH     = 87;
  D3DSIO_CMP          = 88;
  D3DSIO_BEM          = 89;

  D3DSIO_DP2ADD       = 90;
  D3DSIO_DSX          = 91;
  D3DSIO_DSY          = 92;
  D3DSIO_TEXLDD       = 93;
  D3DSIO_SETP         = 94;
  D3DSIO_TEXLDL       = 95;
  D3DSIO_BREAKP       = 96;


  D3DSIO_PHASE        = $FFFD;
  D3DSIO_COMMENT      = $FFFE;
  D3DSIO_END          = $FFFF;

  //---------------------------------------------------------------------
  // 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;

  //---------------------------------------------------------------------
  // Opcode specific controls

  D3DSP_OPCODESPECIFICCONTROL_MASK  = $00ff0000;
  D3DSP_OPCODESPECIFICCONTROL_SHIFT = 16;

  // ps_2_0 texld controls
  D3DSI_TEXLD_PROJECT = ($01 shl D3DSP_OPCODESPECIFICCONTROL_SHIFT);
  D3DSI_TEXLD_BIAS    = ($02 shl D3DSP_OPCODESPECIFICCONTROL_SHIFT);

type
  // Comparison for dynamic conditional instruction opcodes (i.e. if, breakc)
  {$MINENUMSIZE 1} // Forces TD3DShaderComparison be 1 byte enum
  _D3DSHADER_COMPARISON = (
                         // < = >
    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
  );
  D3DSHADER_COMPARISON = _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;
  D3DSHADER_COMPARISON_MASK  = ($7 shl D3DSHADER_COMPARISON_SHIFT);

  //---------------------------------------------------------------------
  // Predication flags on instruction token
  D3DSHADER_INSTRUCTION_PREDICATED    = ($1 shl 28);

  //---------------------------------------------------------------------
  // DCL Info Token Controls

  // For dcl info tokens requiring a semantic (usage + index)
  D3DSP_DCL_USAGE_SHIFT = 0;
  D3DSP_DCL_USAGE_MASK  = $0000000f;

  D3DSP_DCL_USAGEINDEX_SHIFT = 16;
  D3DSP_DCL_USAGEINDEX_MASK  = $000f0000;

  // DCL pixel shader sampler info token.
  D3DSP_TEXTURETYPE_SHIFT = 27;
  D3DSP_TEXTURETYPE_MASK  = $78000000;

type
  _D3DSAMPLER_TEXTURE_TYPE = DWord;
  D3DSAMPLER_TEXTURE_TYPE = _D3DSAMPLER_TEXTURE_TYPE;
  TD3DSamplerTextureType = _D3DSAMPLER_TEXTURE_TYPE;

const
  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

const
  //---------------------------------------------------------------------
  // Parameter Token Bit Definitions
  //
  D3DSP_REGNUM_MASK       = $000007FF;

  // destination parameter write mask
  D3DSP_WRITEMASK_0       = $00010000;  // Component 0 (X;Red)
  D3DSP_WRITEMASK_1       = $00020000;  // Component 1 (Y;Green)
  D3DSP_WRITEMASK_2       = $00040000;  // Component 2 (Z;Blue)
  D3DSP_WRITEMASK_3       = $00080000;  // Component 3 (W;Alpha)
  D3DSP_WRITEMASK_ALL     = $000F0000;  // All Components

  // destination parameter modifiers
  D3DSP_DSTMOD_SHIFT      = 20;
  D3DSP_DSTMOD_MASK       = $00F00000;

  // Bit masks for destination parameter modifiers
    D3DSPDM_NONE                 = (0 shl D3DSP_DSTMOD_SHIFT); // nop
    D3DSPDM_SATURATE             = (1 shl D3DSP_DSTMOD_SHIFT); // clamp to 0. to 1. range
    D3DSPDM_PARTIALPRECISION     = (2 shl D3DSP_DSTMOD_SHIFT); // Partial precision hint
    D3DSPDM_MSAMPCENTROID        = (4 shl D3DSP_DSTMOD_SHIFT); // Relevant to multisampling only:
                                                               //      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;
  D3DSP_DSTSHIFT_MASK     = $0F000000;

  // destination/source parameter register type
  D3DSP_REGTYPE_SHIFT     = 28;
  D3DSP_REGTYPE_SHIFT2    = 8;
  D3DSP_REGTYPE_MASK      = $70000000;
  D3DSP_REGTYPE_MASK2     = $00001800;


const
  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

type
  _D3DSHADER_PARAM_REGISTER_TYPE = DWord;
  D3DSHADER_PARAM_REGISTER_TYPE = _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 = (
    D3DSMO_POSITION   {= 0}, // Input position x,y,z,rhw (PS)
    D3DSMO_FACE   {= 1}  // Floating point primitive area (PS)
  );
  D3DSHADER_MISCTYPE_OFFSETS = _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
  );
  D3DVS_RASTOUT_OFFSETS = _D3DVS_RASTOUT_OFFSETS;
  TD3DVSRastoutOffsets = _D3DVS_RASTOUT_OFFSETS;

// Source operand addressing modes

const
  D3DVS_ADDRESSMODE_SHIFT = 13;
  D3DVS_ADDRESSMODE_MASK  = 1 shl D3DVS_ADDRESSMODE_SHIFT;

type
  _D3DVS_ADDRESSMODE_TYPE = DWord;
  D3DVS_ADDRESSMODE_TYPE = _D3DVS_ADDRESSMODE_TYPE;
  TD3DVSAddressModeType = _D3DVS_ADDRESSMODE_TYPE;

const
  D3DVS_ADDRMODE_ABSOLUTE    = 0 shl D3DVS_ADDRESSMODE_SHIFT;
  D3DVS_ADDRMODE_RELATIVE    = 1 shl D3DVS_ADDRESSMODE_SHIFT; 
  D3DVS_ADDRMODE_FORCE_DWORD = $7fffffff;                      // force 32-bit size enum

const
  D3DSHADER_ADDRESSMODE_SHIFT = 13;
  D3DSHADER_ADDRESSMODE_MASK  = (1 shl D3DSHADER_ADDRESSMODE_SHIFT);

type
  _D3DSHADER_ADDRESSMODE_TYPE = DWord;
  D3DSHADER_ADDRESSMODE_TYPE = _D3DSHADER_ADDRESSMODE_TYPE;
  TD3DShaderAddressModeType = _D3DSHADER_ADDRESSMODE_TYPE;

const
  D3DSHADER_ADDRMODE_ABSOLUTE  = (0 shl D3DSHADER_ADDRESSMODE_SHIFT);
  D3DSHADER_ADDRMODE_RELATIVE  = (1 shl D3DSHADER_ADDRESSMODE_SHIFT);
  D3DSHADER_ADDRMODE_FORCE_DWORD = $7fffffff; // force 32-bit size enum

  // Source operand swizzle definitions
  //
  D3DVS_SWIZZLE_SHIFT     = 16;
  D3DVS_SWIZZLE_MASK      = $00FF0000;

  // The following bits define where to take component X from:

  D3DVS_X_X = 0 shl D3DVS_SWIZZLE_SHIFT;
  D3DVS_X_Y = 1 shl D3DVS_SWIZZLE_SHIFT;
  D3DVS_X_Z = 2 shl D3DVS_SWIZZLE_SHIFT;
  D3DVS_X_W = 3 shl D3DVS_SWIZZLE_SHIFT;

  // The following bits define where to take component Y from:

  D3DVS_Y_X = 0 shl (D3DVS_SWIZZLE_SHIFT + 2);
  D3DVS_Y_Y = 1 shl (D3DVS_SWIZZLE_SHIFT + 2);
  D3DVS_Y_Z = 2 shl (D3DVS_SWIZZLE_SHIFT + 2);
  D3DVS_Y_W = 3 shl (D3DVS_SWIZZLE_SHIFT + 2);

  // The following bits define where to take component Z from:

  D3DVS_Z_X = 0 shl (D3DVS_SWIZZLE_SHIFT + 4);
  D3DVS_Z_Y = 1 shl (D3DVS_SWIZZLE_SHIFT + 4);
  D3DVS_Z_Z = 2 shl (D3DVS_SWIZZLE_SHIFT + 4);
  D3DVS_Z_W = 3 shl (D3DVS_SWIZZLE_SHIFT + 4);

  // The following bits define where to take component W from:

  D3DVS_W_X = 0 shl (D3DVS_SWIZZLE_SHIFT + 6);
  D3DVS_W_Y = 1 shl (D3DVS_SWIZZLE_SHIFT + 6);
  D3DVS_W_Z = 2 shl (D3DVS_SWIZZLE_SHIFT + 6);
  D3DVS_W_W = 3 shl (D3DVS_SWIZZLE_SHIFT + 6);

  // 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;

  // source parameter swizzle
  D3DSP_SWIZZLE_SHIFT = 16;
  D3DSP_SWIZZLE_MASK  = $00FF0000;

  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));

  // 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));

  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));

  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));

  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));

  // source parameter modifiers
  D3DSP_SRCMOD_SHIFT      = 24;
  D3DSP_SRCMOD_MASK       = $0F000000;

type
  _D3DSHADER_PARAM_SRCMOD_TYPE = DWord;
  D3DSHADER_PARAM_SRCMOD_TYPE = _D3DSHADER_PARAM_SRCMOD_TYPE;
  TD3DShaderParamSRCModType = _D3DSHADER_PARAM_SRCMOD_TYPE;

const
  D3DSPSM_NONE        = 0 shl D3DSP_SRCMOD_SHIFT; // nop
  D3DSPSM_NEG         = 1 shl D3DSP_SRCMOD_SHIFT; // negate
  D3DSPSM_BIAS        = 2 shl D3DSP_SRCMOD_SHIFT; // bias
  D3DSPSM_BIASNEG     = 3 shl D3DSP_SRCMOD_SHIFT; // bias and negate
  D3DSPSM_SIGN        = 4 shl D3DSP_SRCMOD_SHIFT; // sign
  D3DSPSM_SIGNNEG     = 5 shl D3DSP_SRCMOD_SHIFT; // sign and negate
  D3DSPSM_COMP        = 6 shl D3DSP_SRCMOD_SHIFT; // complement
  D3DSPSM_X2          = 7 shl D3DSP_SRCMOD_SHIFT; // *2
  D3DSPSM_X2NEG       = 8 shl D3DSP_SRCMOD_SHIFT; // *2 and negate
  D3DSPSM_DZ          = 9 shl D3DSP_SRCMOD_SHIFT; // divide through by z component
  D3DSPSM_DW          = 10 shl D3DSP_SRCMOD_SHIFT; // divide through by w component
  D3DSPSM_ABS         = 11 shl D3DSP_SRCMOD_SHIFT; // abs()
  D3DSPSM_ABSNEG      = 12 shl D3DSP_SRCMOD_SHIFT; // -abs()
  D3DSPSM_NOT         = 13 shl D3DSP_SRCMOD_SHIFT; // for predicate register: "!p0"
  D3DSPSM_FORCE_DWORD = $7fffffff;                // force 32-bit size enum

// pixel shader version token
//#define D3DPS_VERSION(_Major,_Minor) (0xFFFF0000|((_Major)<<8)|(_Minor))
function D3DPS_VERSION(_Major, _Minor: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}

// vertex shader version token
//#define D3DVS_VERSION(_Major,_Minor) (0xFFFE0000|((_Major)<<8)|(_Minor))
function D3DVS_VERSION(_Major, _Minor: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}

// extract major/minor from version cap
//#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF)
function D3DSHADER_VERSION_MAJOR(_Version: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
//#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF)
function D3DSHADER_VERSION_MINOR(_Version: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}

const
  // destination/source parameter register type
  D3DSI_COMMENTSIZE_SHIFT = 16;
  D3DSI_COMMENTSIZE_MASK  = $7FFF0000;

//#define D3DSHADER_COMMENT(_DWordSize) \
//    ((((_DWordSize)<<D3DSI_COMMENTSIZE_SHIFT)&D3DSI_COMMENTSIZE_MASK)|D3DSIO_COMMENT)
function D3DSHADER_COMMENT(_DWordSize: DWord) : DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}

const
  // pixel/vertex shader end token
  D3DPS_END  = $0000FFFF;
  D3DVS_END  = $0000FFFF;


//---------------------------------------------------------------------

type
  // High order surfaces
  //
  _D3DBASISTYPE = (
    D3DBASIS_BEZIER      {= 0},
    D3DBASIS_BSPLINE     {= 1},
    D3DBASIS_CATMULL_ROM {= 2} { In D3D8 this used to be D3DBASIS_INTERPOLATE }
  );
  D3DBASISTYPE = _D3DBASISTYPE;
  TD3DBasisType = _D3DBASISTYPE;

  _D3DDEGREETYPE = (
    D3DDEGREE_invalid_0  {= 0},
    D3DDEGREE_LINEAR     {= 1},
    D3DDEGREE_QUADRATIC  {= 2},
    D3DDEGREE_CUBIC      {= 3},
    D3DDEGREE_invalid_4  {= 4},
    D3DDEGREE_QUINTIC    {= 5}
  );
  D3DDEGREETYPE = _D3DDEGREETYPE;
  TD3DDegreeType = _D3DDEGREETYPE;

  _D3DPATCHEDGESTYLE = (
    D3DPATCHEDGE_DISCRETE   {= 0},
    D3DPATCHEDGE_CONTINUOUS {= 1}
  );
  D3DPATCHEDGESTYLE = _D3DPATCHEDGESTYLE;
  TD3DPatchEdgeStyle = _D3DPATCHEDGESTYLE;

  _D3DSTATEBLOCKTYPE = (
    D3DSBT_INVALID_0,
    D3DSBT_ALL          {= 1}, // capture all state
    D3DSBT_PIXELSTATE   {= 2}, // capture pixel state
    D3DSBT_VERTEXSTATE  {= 3}  // capture vertex state
  );
  D3DSTATEBLOCKTYPE = _D3DSTATEBLOCKTYPE;
  TD3DStateBlockType = _D3DSTATEBLOCKTYPE;

type
  // The D3DVERTEXBLENDFLAGS type is used with D3DRS_VERTEXBLEND state.
  //
  _D3DVERTEXBLENDFLAGS = DWord;
  D3DVERTEXBLENDFLAGS = _D3DVERTEXBLENDFLAGS;
  TD3DVertexBlendFlags = _D3DVERTEXBLENDFLAGS;

const
  D3DVBF_DISABLE  = 0;            // Disable vertex blending
  D3DVBF_1WEIGHTS = 1;            // 2 matrix blending
  D3DVBF_2WEIGHTS = 2;            // 3 matrix blending
  D3DVBF_3WEIGHTS = 3;            // 4 matrix blending
  D3DVBF_TWEENING = 255;          // blending using D3DRS_TWEENFACTOR
  D3DVBF_0WEIGHTS = 256;          // one matrix is used with weight 1.0
  D3DVBF_FORCE_DWORD = $7fffffff; // force 32-bit size enum

type
  _D3DTEXTURETRANSFORMFLAGS = DWord;
  D3DTEXTURETRANSFORMFLAGS = _D3DTEXTURETRANSFORMFLAGS;
  TD3DTextureTransformFlags = _D3DTEXTURETRANSFORMFLAGS;

const
  D3DTTFF_DISABLE         = 0;    // texture coordinates are passed directly
  D3DTTFF_COUNT1          = 1;    // rasterizer should expect 1-D texture coords
  D3DTTFF_COUNT2          = 2;    // rasterizer should expect 2-D texture coords
  D3DTTFF_COUNT3          = 3;    // rasterizer should expect 3-D texture coords
  D3DTTFF_COUNT4          = 4;    // rasterizer should expect 4-D texture coords
  D3DTTFF_PROJECTED       = 256;  // texcoords to be divided by COUNTth element
  D3DTTFF_FORCE_DWORD     = $7fffffff;

const
  // Macros to set texture coordinate format bits in the FVF id

  D3DFVF_TEXTUREFORMAT2 = 0;         // Two floating point values
  D3DFVF_TEXTUREFORMAT1 = 3;         // One floating point value
  D3DFVF_TEXTUREFORMAT3 = 1;         // Three floating point values
  D3DFVF_TEXTUREFORMAT4 = 2;         // Four floating point values

//#define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE3(CoordIndex: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
//#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2)
function D3DFVF_TEXCOORDSIZE2(CoordIndex: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
//#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE4(CoordIndex: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
//#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE1(CoordIndex: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}


//---------------------------------------------------------------------

type
  { Direct3D9 Device types }
  _D3DDEVTYPE = (
    D3DDEVTYPE_INVALID_0,
    D3DDEVTYPE_HAL         {= 1},
    D3DDEVTYPE_REF         {= 2},
    D3DDEVTYPE_SW          {= 3},

    D3DDEVTYPE_NULLREF     {= 4}
  );
  D3DDEVTYPE = _D3DDEVTYPE;
  TD3DDevType = _D3DDEVTYPE;

  { Multi-Sample buffer types }
  _D3DMULTISAMPLE_TYPE = (
    D3DMULTISAMPLE_NONE            {=  0},
    D3DMULTISAMPLE_NONMASKABLE     {=  1},
    D3DMULTISAMPLE_2_SAMPLES       {=  2},
    D3DMULTISAMPLE_3_SAMPLES       {=  3},
    D3DMULTISAMPLE_4_SAMPLES       {=  4},
    D3DMULTISAMPLE_5_SAMPLES       {=  5},
    D3DMULTISAMPLE_6_SAMPLES       {=  6},
    D3DMULTISAMPLE_7_SAMPLES       {=  7},
    D3DMULTISAMPLE_8_SAMPLES       {=  8},
    D3DMULTISAMPLE_9_SAMPLES       {=  9},
    D3DMULTISAMPLE_10_SAMPLES      {= 10},
    D3DMULTISAMPLE_11_SAMPLES      {= 11},
    D3DMULTISAMPLE_12_SAMPLES      {= 12},
    D3DMULTISAMPLE_13_SAMPLES      {= 13},
    D3DMULTISAMPLE_14_SAMPLES      {= 14},
    D3DMULTISAMPLE_15_SAMPLES      {= 15},
    D3DMULTISAMPLE_16_SAMPLES      {= 16}
  );
  D3DMULTISAMPLE_TYPE = _D3DMULTISAMPLE_TYPE;
  TD3DMultiSampleType = _D3DMULTISAMPLE_TYPE;

(* Formats
 * Most of these names have the following convention:
 *      A = Alpha
 *      R = Red
 *      G = Green
 *      B = Blue
 *      X = Unused Bits
 *      P = Palette
 *      L = Luminance
 *      U = dU coordinate for BumpMap
 *      V = dV coordinate for BumpMap
 *      S = Stencil
 *      D = Depth (e.g. Z or W buffer)
 *      C = Computed from other channels (typically on certain read operations)
 *
 *      Further, the order of the pieces are from MSB first; hence
 *      D3DFMT_A8L8 indicates that the high byte of this two byte
 *      format is alpha.
 *
 *      D3DFMT_D16_LOCKABLE indicates:
 *           - An integer 16-bit value.
 *           - An app-lockable surface.
 *
 *      D3DFMT_D32F_LOCKABLE indicates:
 *           - An IEEE 754 floating-point value.
 *           - An app-lockable surface.
 *
 *      All Depth/Stencil formats except D3DFMT_D16_LOCKABLE and D3DFMT_D32F_LOCKABLE indicate:
 *          - no particular bit ordering per pixel, and
 *          - are not app lockable, and
 *          - the driver is allowed to consume more than the indicated
 *            number of bits per Depth channel (but not Stencil channel).
 *)
//    #define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
//                ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |       \
//                ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
function MAKEFOURCC(ch0, ch1, ch2, ch3: Char): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}


const
  D3DFMT_UNKNOWN              =  0;

  D3DFMT_R8G8B8               = 20;
  D3DFMT_A8R8G8B8             = 21;
  D3DFMT_X8R8G8B8             = 22;
  D3DFMT_R5G6B5               = 23;
  D3DFMT_X1R5G5B5             = 24;
  D3DFMT_A1R5G5B5             = 25;
  D3DFMT_A4R4G4B4             = 26;
  D3DFMT_R3G3B2               = 27;
  D3DFMT_A8                   = 28;
  D3DFMT_A8R3G3B2             = 29;
  D3DFMT_X4R4G4B4             = 30;
  D3DFMT_A2B10G10R10          = 31;
  D3DFMT_A8B8G8R8             = 32;
  D3DFMT_X8B8G8R8             = 33;
  D3DFMT_G16R16               = 34;
  D3DFMT_A2R10G10B10          = 35;
  D3DFMT_A16B16G16R16         = 36;

  D3DFMT_A8P8                 = 40;
  D3DFMT_P8                   = 41;

  D3DFMT_L8                   = 50;
  D3DFMT_A8L8                 = 51;
  D3DFMT_A4L4                 = 52;

  D3DFMT_V8U8                 = 60;
  D3DFMT_L6V5U5               = 61;
  D3DFMT_X8L8V8U8             = 62;
  D3DFMT_Q8W8V8U8             = 63;
  D3DFMT_V16U16               = 64;
  D3DFMT_A2W10V10U10          = 67;

  // D3DFMT_UYVY                 = MAKEFOURCC('U', 'Y', 'V', 'Y');
  D3DFMT_UYVY                 = Byte('U') or (Byte('Y') shl 8) or (Byte('V') shl 16) or (Byte('Y') shl 24);
  // D3DFMT_R8G8_B8G8            = MAKEFOURCC('R', 'G', 'B', 'G'),
  D3DFMT_R8G8_B8G8            = Byte('R') or (Byte('G') shl 8) or (Byte('B') shl 16) or (Byte('G') shl 24);
  // D3DFMT_YUY2                 = MAKEFOURCC('Y', 'U', 'Y', '2'),
  D3DFMT_YUY2                 = Byte('Y') or (Byte('U') shl 8) or (Byte('Y') shl 16) or (Byte('2') shl 24);
  // D3DFMT_G8R8_G8B8            = MAKEFOURCC('G', 'R', 'G', 'B'),
  D3DFMT_G8R8_G8B8            = Byte('G') or (Byte('R') shl 8) or (Byte('G') shl 16) or (Byte('B') shl 24);
  // D3DFMT_DXT1                 = MAKEFOURCC('D', 'X', 'T', '1'),
  D3DFMT_DXT1                 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('1') shl 24);
  // D3DFMT_DXT2                 = MAKEFOURCC('D', 'X', 'T', '2'),
  D3DFMT_DXT2                 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('2') shl 24);
  // D3DFMT_DXT3                 = MAKEFOURCC('D', 'X', 'T', '3'),
  D3DFMT_DXT3                 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('3') shl 24);
  // D3DFMT_DXT4                 = MAKEFOURCC('D', 'X', 'T', '4'),
  D3DFMT_DXT4                 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('4') shl 24);
  // D3DFMT_DXT5                 = MAKEFOURCC('D', 'X', 'T', '5'),
  D3DFMT_DXT5                 = Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or (Byte('5') shl 24);

  D3DFMT_D16_LOCKABLE         = 70;
  D3DFMT_D32                  = 71;
  D3DFMT_D15S1                = 73;
  D3DFMT_D24S8                = 75;
  D3DFMT_D24X8                = 77;
  D3DFMT_D24X4S4              = 79;
  D3DFMT_D16                  = 80;


  D3DFMT_D32F_LOCKABLE        = 82;
  D3DFMT_D24FS8               = 83;


  D3DFMT_L16                  = 81;


  D3DFMT_VERTEXDATA           =100;
  D3DFMT_INDEX16              =101;
  D3DFMT_INDEX32              =102;

  D3DFMT_Q16W16V16U16         =110;

  // D3DFMT_MULTI2_ARGB8         = MAKEFOURCC('M','E','T','1'),
  D3DFMT_MULTI2_ARGB8         = Byte('M') or (Byte('E') shl 8) or (Byte('T') shl 16) or (Byte('1') shl 24);

  // Floating point surface formats

  // s10e5 formats (16-bits per channel)
  D3DFMT_R16F                 = 111;
  D3DFMT_G16R16F              = 112;
  D3DFMT_A16B16G16R16F        = 113;

  // IEEE s23e8 formats (32-bits per channel)
  D3DFMT_R32F                 = 114;
  D3DFMT_G32R32F              = 115;
  D3DFMT_A32B32G32R32F        = 116;

  D3DFMT_CxV8U8               = 117;

  // ATI - 3Dc/ATI2N texture format
  // D3DFMT_ATI2                 = MAKEFOURCC('A', 'T', 'I', '2'),
  D3DFMT_ATI2                 = Byte('A') or (Byte('T') shl 8) or (Byte('I') shl 16) or (Byte('2') shl 24);
  //{$EXTERNALSYM D3DFMT_ATI2} //Clootie: - this is not defined in original SDK headers

  D3DFMT_FORCE_DWORD          = $7fffffff;

type
  _D3DFORMAT = DWord;
  D3DFORMAT = _D3DFORMAT;
  PD3DFormat = ^TD3DFormat;
  TD3DFormat = _D3DFORMAT;

  { Display Modes }
  PD3DDisplayMode = ^TD3DDisplayMode;
  _D3DDISPLAYMODE = packed record
    Width: LongWord;
    Height: LongWord;
    RefreshRate: LongWord;
    Format: TD3DFormat;
  end {_D3DDISPLAYMODE};
  D3DDISPLAYMODE = _D3DDISPLAYMODE;
  TD3DDisplayMode = _D3DDISPLAYMODE;

  { Creation Parameters }
  PD3DDeviceCreationParameters = ^TD3DDeviceCreationParameters;
  _D3DDEVICE_CREATION_PARAMETERS = packed record
    AdapterOrdinal: LongWord;
    DeviceType: TD3DDevType;
    hFocusWindow: HWND;
    BehaviorFlags: LongInt;
  end {_D3DDEVICE_CREATION_PARAMETERS};
  D3DDEVICE_CREATION_PARAMETERS = _D3DDEVICE_CREATION_PARAMETERS;
  TD3DDeviceCreationParameters = _D3DDEVICE_CREATION_PARAMETERS;


  { SwapEffects }
  _D3DSWAPEFFECT = (
    D3DSWAPEFFECT_INVALID_0     {= 0},
    D3DSWAPEFFECT_DISCARD       {= 1},
    D3DSWAPEFFECT_FLIP          {= 2},
    D3DSWAPEFFECT_COPY          {= 3}
  );
  D3DSWAPEFFECT = _D3DSWAPEFFECT;
  TD3DSwapEffect = _D3DSWAPEFFECT;

  { Pool types }
  _D3DPOOL = (
    D3DPOOL_DEFAULT     {= 0},
    D3DPOOL_MANAGED     {= 1},
    D3DPOOL_SYSTEMMEM   {= 2},
    D3DPOOL_SCRATCH     {= 3}
  );
  D3DPOOL = _D3DPOOL;
  TD3DPool = _D3DPOOL;


const
  { RefreshRate pre-defines }
  D3DPRESENT_RATE_DEFAULT         = $00000000;

type
  { Resize Optional Parameters }
  PD3DPresentParameters = ^TD3DPresentParameters;
  _D3DPRESENT_PARAMETERS_ = packed record
    BackBufferWidth:                    LongWord;
    BackBufferHeight:                   LongWord;
    BackBufferFormat:                   TD3DFormat;
    BackBufferCount:                    LongWord;

    MultiSampleType:                    TD3DMultiSampleType;
    MultiSampleQuality:                 DWORD;

    SwapEffect:                         TD3DSwapEffect;
    hDeviceWindow:                      HWND;
    Windowed:                           Bool;
    EnableAutoDepthStencil:             Bool;
    AutoDepthStencilFormat:             TD3DFormat;
    Flags: LongInt;

    { FullScreen_RefreshRateInHz must be zero for Windowed mode }
    FullScreen_RefreshRateInHz:         LongWord;
    PresentationInterval:               LongWord;
  end {_D3DPRESENT_PARAMETERS_};
  D3DPRESENT_PARAMETERS = _D3DPRESENT_PARAMETERS_;
  TD3DPresentParameters = _D3DPRESENT_PARAMETERS_;

  // Values for D3DPRESENT_PARAMETERS.Flags

const
  D3DPRESENTFLAG_LOCKABLE_BACKBUFFER  = $00000001;
  D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL = $00000002;
  D3DPRESENTFLAG_DEVICECLIP           = $00000004;
  D3DPRESENTFLAG_VIDEO                = $00000010;

  { Gamma Ramp: Same as DX7 }

type
  PD3DGammaRamp = ^TD3DGammaRamp;
  _D3DGAMMARAMP = packed record
    red   : array [0..255] of Word;
    green : array [0..255] of Word;
    blue  : array [0..255] of Word;
  end;
  D3DGAMMARAMP = _D3DGAMMARAMP;
  TD3DGammaRamp = _D3DGAMMARAMP;

  { Back buffer types }
  _D3DBACKBUFFER_TYPE = (
    D3DBACKBUFFER_TYPE_MONO         {= 0},
    D3DBACKBUFFER_TYPE_LEFT         {= 1},
    D3DBACKBUFFER_TYPE_RIGHT        {= 2}
  );
  D3DBACKBUFFER_TYPE = _D3DBACKBUFFER_TYPE;
  TD3DBackbufferType = _D3DBACKBUFFER_TYPE;


  { Types }
  _D3DRESOURCETYPE = (
    D3DRTYPE_INVALID_0              {=  0},
    D3DRTYPE_SURFACE                {=  1},
    D3DRTYPE_VOLUME                 {=  2},
    D3DRTYPE_TEXTURE                {=  3},
    D3DRTYPE_VOLUMETEXTURE          {=  4},
    D3DRTYPE_CUBETEXTURE            {=  5},
    D3DRTYPE_VERTEXBUFFER           {=  6},
    D3DRTYPE_INDEXBUFFER            {=  7}
  );
  D3DRESOURCETYPE = _D3DRESOURCETYPE;
  TD3DResourceType = _D3DRESOURCETYPE;

const
  { Usages }
  D3DUSAGE_RENDERTARGET       = $00000001;
  D3DUSAGE_DEPTHSTENCIL       = $00000002;
  D3DUSAGE_DYNAMIC            = $00000200;

  // When passed to CheckDeviceFormat, D3DUSAGE_AUTOGENMIPMAP may return
  // D3DOK_NOAUTOGEN if the device doesn't support autogeneration for that format.
  // D3DOK_NOAUTOGEN is a success code, not a failure code... the SUCCEEDED and FAILED macros
  // will return true and false respectively for this code.
  D3DUSAGE_AUTOGENMIPMAP      = $00000400;
  D3DUSAGE_DMAP               = $00004000;

  // The following usages are valid only for querying CheckDeviceFormat
  D3DUSAGE_QUERY_LEGACYBUMPMAP            = $00008000;
  D3DUSAGE_QUERY_SRGBREAD                 = $00010000;
  D3DUSAGE_QUERY_FILTER                   = $00020000;
  D3DUSAGE_QUERY_SRGBWRITE                = $00040000;
  D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING = $00080000;
  D3DUSAGE_QUERY_VERTEXTEXTURE            = $00100000;
  D3DUSAGE_QUERY_WRAPANDMIP               = $00200000;


  { Usages for Vertex/Index buffers }
  D3DUSAGE_WRITEONLY          = $00000008;
  D3DUSAGE_SOFTWAREPROCESSING = $00000010;
  D3DUSAGE_DONOTCLIP          = $00000020;
  D3DUSAGE_POINTS             = $00000040;
  D3DUSAGE_RTPATCHES          = $00000080;
  D3DUSAGE_NPATCHES           = $00000100;








type
  { CubeMap Face identifiers }
  _D3DCUBEMAP_FACES = (
    D3DCUBEMAP_FACE_POSITIVE_X     {= 0},
    D3DCUBEMAP_FACE_NEGATIVE_X     {= 1},
    D3DCUBEMAP_FACE_POSITIVE_Y     {= 2},
    D3DCUBEMAP_FACE_NEGATIVE_Y     {= 3},
    D3DCUBEMAP_FACE_POSITIVE_Z     {= 4},
    D3DCUBEMAP_FACE_NEGATIVE_Z     {= 5}
  );
  D3DCUBEMAP_FACES = _D3DCUBEMAP_FACES;
  TD3DCubemapFaces = _D3DCUBEMAP_FACES;


const
  { Lock flags }
  D3DLOCK_READONLY         = $00000010;
  D3DLOCK_DISCARD          = $00002000;
  D3DLOCK_NOOVERWRITE      = $00001000;
  D3DLOCK_NOSYSLOCK        = $00000800;
  D3DLOCK_DONOTWAIT        = $00004000;

  D3DLOCK_NO_DIRTY_UPDATE  = $00008000;






type
  { Vertex Buffer Description }
  PD3DVertexBufferDesc = ^TD3DVertexBufferDesc;
  _D3DVERTEXBUFFER_DESC = packed record
    Format : TD3DFormat;
    _Type  : TD3DResourceType;
    Usage  : DWord;
    Pool   : TD3DPool;
    Size   : LongWord;

    FVF    : DWord;
  end;
  D3DVERTEXBUFFER_DESC = _D3DVERTEXBUFFER_DESC;
  TD3DVertexBufferDesc = _D3DVERTEXBUFFER_DESC;

  { Index Buffer Description }
  PD3DIndexBufferDesc = ^TD3DIndexBufferDesc;
  _D3DINDEXBUFFER_DESC = packed record
    Format : TD3DFormat;
    _Type  : TD3DResourceType;
    Usage  : DWord;
    Pool   : TD3DPool;
    Size   : LongWord;
  end {_D3DINDEXBUFFER_DESC};
  D3DINDEXBUFFER_DESC = _D3DINDEXBUFFER_DESC;
  TD3DIndexBufferDesc = _D3DINDEXBUFFER_DESC;


 { Surface Description }
  PD3DSurfaceDesc = ^TD3DSurfaceDesc;
  _D3DSURFACE_DESC = packed record
    Format : TD3DFormat;
    _Type  : TD3DResourceType;
    Usage  : DWord;
    Pool   : TD3DPool;

    MultiSampleType: TD3DMultiSampleType;
    MultiSampleQuality: DWORD;
    Width  : LongWord;
    Height : LongWord;
  end {_D3DSURFACE_DESC};
  D3DSURFACE_DESC = _D3DSURFACE_DESC;
  TD3DSurfaceDesc = _D3DSURFACE_DESC;

  PD3DVolumeDesc = ^TD3DVolumeDesc;
  _D3DVOLUME_DESC = packed record
    Format : TD3DFormat;
    _Type  : TD3DResourceType;
    Usage  : DWord;
    Pool   : TD3DPool;

    Width  : LongWord;
    Height : LongWord;
    Depth  : LongWord;
  end {_D3DVOLUME_DESC};
  D3DVOLUME_DESC = _D3DVOLUME_DESC;
  TD3DVolumeDesc = _D3DVOLUME_DESC;

  { Structure for LockRect }
  PD3DLockedRect = ^TD3DLockedRect;
  _D3DLOCKED_RECT = packed record
    Pitch: Integer;
    pBits: Pointer; // void*
  end {_D3DLOCKED_RECT};
  D3DLOCKED_RECT = _D3DLOCKED_RECT;
  TD3DLockedRect = _D3DLOCKED_RECT;

  { Structures for LockBox }
  PD3DBox = ^TD3DBox;
  _D3DBOX = packed record
    Left        : LongWord;
    Top         : LongWord;
    Right       : LongWord;
    Bottom      : LongWord;
    Front       : LongWord;
    Back        : LongWord;
  end {_D3DBOX};
  D3DBOX = _D3DBOX;
  TD3DBox = _D3DBOX;

  PD3DLockedBox = ^TD3DLockedBox;
  _D3DLOCKED_BOX = packed record
    RowPitch    : Integer;
    SlicePitch  : Integer;
    pBits       : Pointer; // void*
  end {_D3DLOCKED_BOX};
  D3DLOCKED_BOX = _D3DLOCKED_BOX;
  TD3DLockedBox = _D3DLOCKED_BOX;

  { Structures for LockRange }
  PD3DRange = ^TD3DRange;
  _D3DRANGE = packed record
    Offset      : LongWord;
    Size        : LongWord;
  end {_D3DRANGE};
  D3DRANGE = _D3DRANGE;
  TD3DRange = _D3DRANGE;

  { Structures for high order primitives }
  PD3DRectPatchInfo = ^TD3DRectPatchInfo;
  _D3DRECTPATCH_INFO = packed record
    StartVertexOffsetWidth  : LongWord;
    StartVertexOffsetHeight : LongWord;
    Width                   : LongWord;
    Height                  : LongWord;
    Stride                  : LongWord;
    Basis                   : TD3DBasisType;
    Degree                  : TD3DDegreeType;
  end;
  D3DRECTPATCH_INFO = _D3DRECTPATCH_INFO;
  TD3DRectPatchInfo = _D3DRECTPATCH_INFO;

  PD3DTriPatchInfo = ^TD3DTriPatchInfo;
  _D3DTRIPATCH_INFO = packed record
    StartVertexOffset : LongWord;
    NumVertices       : LongWord;
    Basis             : TD3DBasisType;
    Degree            : TD3DDegreeType;
  end;
  D3DTRIPATCH_INFO = _D3DTRIPATCH_INFO;
  TD3DTriPatchInfo = _D3DTRIPATCH_INFO;

const
  { Adapter Identifier }
  MAX_DEVICE_IDENTIFIER_STRING  = 512;
type
  PD3DAdapterIdentifier9 = ^TD3DAdapterIdentifier9;
  _D3DADAPTER_IDENTIFIER9 = packed record
    Driver      : array [0..MAX_DEVICE_IDENTIFIER_STRING-1] of Char;
    Description : array [0..MAX_DEVICE_IDENTIFIER_STRING-1] of Char;
    DeviceName  : array [0..31] of Char;   { Device name for GDI (ex. \\.\DISPLAY1) }

{$IFDEF WIN32}
    DriverVersion               : Int64;   { Defined for 32 bit components }
{$ELSE}
    DriverVersionLowPart        : DWord;   { Defined for 16 bit driver components }
    DriverVersionHighPart       : DWord;
{$ENDIF}

    VendorId    : DWord;
    DeviceId    : DWord;
    SubSysId    : DWord;
    Revision    : DWord;

    DeviceIdentifier : TGUID;

    WHQLLevel   : DWord;

  end;
  D3DADAPTER_IDENTIFIER9 = _D3DADAPTER_IDENTIFIER9;
  TD3DAdapterIdentifier9 = _D3DADAPTER_IDENTIFIER9;


  { Raster Status structure returned by GetRasterStatus }
  PD3DRasterStatus = ^TD3DRasterStatus;
  _D3DRASTER_STATUS = packed record
    InVBlank : Bool;
    ScanLine : LongWord;
  end;
  D3DRASTER_STATUS = _D3DRASTER_STATUS;
  TD3DRasterStatus = _D3DRASTER_STATUS;



{ Debug monitor tokens (DEBUG only)

   Note that if D3DRS_DEBUGMONITORTOKEN is set, the call is treated as
   passing a token to the debug monitor.  For example, if, after passing
   D3DDMT_ENABLE/DISABLE to D3DRS_DEBUGMONITORTOKEN other token values
   are passed in, the enabled/disabled state of the debug
   monitor will still persist.

   The debug monitor defaults to enabled.

   Calling GetRenderState on D3DRS_DEBUGMONITORTOKEN is not of any use.
}
  _D3DDEBUGMONITORTOKENS = DWord;
  D3DDEBUGMONITORTOKENS = _D3DDEBUGMONITORTOKENS;
  TD3DDebugMonitorTokens = _D3DDEBUGMONITORTOKENS;

const
  D3DDMT_ENABLE            = 0;    // enable debug monitor
  D3DDMT_DISABLE           = 1;    // disable debug monitor

const
  // Async feedback
  D3DQUERYTYPE_VCACHE                 = 4; { D3DISSUE_END }
  D3DQUERYTYPE_RESOURCEMANAGER        = 5; { D3DISSUE_END }
  D3DQUERYTYPE_VERTEXSTATS            = 6; { D3DISSUE_END }
  D3DQUERYTYPE_EVENT                  = 8; { D3DISSUE_END }
  D3DQUERYTYPE_OCCLUSION              = 9; { D3DISSUE_BEGIN, D3DISSUE_END }
  D3DQUERYTYPE_TIMESTAMP              = 10; { D3DISSUE_END }
  D3DQUERYTYPE_TIMESTAMPDISJOINT      = 11; { D3DISSUE_BEGIN, D3DISSUE_END }
  D3DQUERYTYPE_TIMESTAMPFREQ          = 12; { D3DISSUE_END }
  D3DQUERYTYPE_PIPELINETIMINGS        = 13; { D3DISSUE_BEGIN, D3DISSUE_END }
  D3DQUERYTYPE_INTERFACETIMINGS       = 14; { D3DISSUE_BEGIN, D3DISSUE_END }
  D3DQUERYTYPE_VERTEXTIMINGS          = 15; { D3DISSUE_BEGIN, D3DISSUE_END }
  D3DQUERYTYPE_PIXELTIMINGS           = 16; { D3DISSUE_BEGIN, D3DISSUE_END }
  D3DQUERYTYPE_BANDWIDTHTIMINGS       = 17; { D3DISSUE_BEGIN, D3DISSUE_END }
  D3DQUERYTYPE_CACHEUTILIZATION       = 18; { D3DISSUE_BEGIN, D3DISSUE_END }
type
  _D3DQUERYTYPE = DWord;
  D3DQUERYTYPE = _D3DQUERYTYPE;
  TD3DQueryType = _D3DQUERYTYPE;

const
  // Flags field for Issue
  D3DISSUE_END     = (1 shl 0); // Tells the runtime to issue the end of a query, changing it's state to "non-signaled".
  D3DISSUE_BEGIN   = (1 shl 1); // Tells the runtime to issue the beginng of a query.


  // Flags field for GetData
  D3DGETDATA_FLUSH = (1 shl 0); // Tells the runtime to flush if the query is outstanding.

type
  PD3DResourceStats = ^TD3DResourceStats;
  _D3DRESOURCESTATS = packed record
  // Data collected since last Present()
    bThrashing                  : BOOL;  (* indicates if thrashing *)
    ApproxBytesDownloaded       : DWORD; (* Approximate number of bytes downloaded by resource manager *)
    NumEvicts                   : DWORD; (* number of objects evicted *)
    NumVidCreates               : DWORD; (* number of objects created in video memory *)
    LastPri                     : DWORD; (* priority of last object evicted *)
    NumUsed                     : DWORD; (* number of objects set to the device *)
    NumUsedInVidMem             : DWORD; (* number of objects set to the device, which are already in video memory *)
  // Persistent data
    WorkingSet                  : DWORD; (* number of objects in video memory *)
    WorkingSetBytes             : DWORD; (* number of bytes in video memory *)
    TotalManaged                : DWORD; (* total number of managed objects *)
    TotalBytes                  : DWORD; (* total number of bytes of managed objects *)
  end;
  D3DRESOURCESTATS = _D3DRESOURCESTATS;
  TD3DResourceStats = _D3DRESOURCESTATS;

const
  D3DRTYPECOUNT = (DWORD(D3DRTYPE_INDEXBUFFER) + 1);

type
  PD3DDevInfoResourceManager = ^TD3DDevInfoResourceManager;
  _D3DDEVINFO_RESOURCEMANAGER = packed record
    stats: array [0..D3DRTYPECOUNT-1] of TD3DResourceStats;
  end;
  D3DDEVINFO_RESOURCEMANAGER = _D3DDEVINFO_RESOURCEMANAGER;
  TD3DDevInfoResourceManager = _D3DDEVINFO_RESOURCEMANAGER;

  PD3DDevInfoD3DVertexStats = ^TD3DDevInfoD3DVertexStats;
  _D3DDEVINFO_D3DVERTEXSTATS = packed record
    NumRenderedTriangles        : DWORD; (* total number of triangles that are not clipped in this frame *)
    NumExtraClippingTriangles   : DWORD; (* Number of new triangles generated by clipping *)
  end;
  D3DDEVINFO_D3DVERTEXSTATS = _D3DDEVINFO_D3DVERTEXSTATS;
  TD3DDevInfoD3DVertexStats = _D3DDEVINFO_D3DVERTEXSTATS;

  PD3DDevInfoVCache = ^TD3DDevInfoVCache;
  _D3DDEVINFO_VCACHE = packed record
    Pattern     : DWORD;        (* bit pattern, return value must be FOUR_CC('C', 'A', 'C', 'H') *)
    OptMethod   : DWORD;        (* optimization method 0 means longest strips, 1 means vertex cache based *)
    CacheSize   : DWORD;        (* cache size to optimize for  (only required if type is 1) *)
    MagicNumber : DWORD;        (* used to determine when to restart strips (only required if type is 1)*)
  end;
  D3DDEVINFO_VCACHE = _D3DDEVINFO_VCACHE;
  TD3DDevInfoVCache = _D3DDEVINFO_VCACHE;

  PD3DDevInfoD3D9PipelineTimings = ^TD3DDevInfoD3D9PipelineTimings;
  _D3DDEVINFO_D3D9PIPELINETIMINGS = packed record
    VertexProcessingTimePercent: Single;
    PixelProcessingTimePercent: Single;
    OtherGPUProcessingTimePercent: Single;
    GPUIdleTimePercent: Single;
  end;
  D3DDEVINFO_D3D9PIPELINETIMINGS = _D3DDEVINFO_D3D9PIPELINETIMINGS;
  TD3DDevInfoD3D9PipelineTimings = _D3DDEVINFO_D3D9PIPELINETIMINGS;

  PD3DDevInfoD3D9InterfaceTimings = ^TD3DDevInfoD3D9InterfaceTimings;
  _D3DDEVINFO_D3D9INTERFACETIMINGS = packed record
    WaitingForGPUToUseApplicationResourceTimePercent: Single;
    WaitingForGPUToAcceptMoreCommandsTimePercent: Single;
    WaitingForGPUToStayWithinLatencyTimePercent: Single;
    WaitingForGPUExclusiveResourceTimePercent: Single;
    WaitingForGPUOtherTimePercent: Single;
  end;
  D3DDEVINFO_D3D9INTERFACETIMINGS = _D3DDEVINFO_D3D9INTERFACETIMINGS;
  TD3DDevInfoD3D9InterfaceTimings = _D3DDEVINFO_D3D9INTERFACETIMINGS;

  PD3DDevInfoD3D9StageTimings = ^TD3DDevInfoD3D9StageTimings;
  _D3DDEVINFO_D3D9STAGETIMINGS = packed record
    MemoryProcessingPercent: Single;
    ComputationProcessingPercent: Single;
  end;
  D3DDEVINFO_D3D9STAGETIMINGS = _D3DDEVINFO_D3D9STAGETIMINGS;
  TD3DDevInfoD3D9StageTimings = _D3DDEVINFO_D3D9STAGETIMINGS;

  PD3DDevInfoD3D9BandwidthTimings = ^TD3DDevInfoD3D9BandwidthTimings;
  _D3DDEVINFO_D3D9BANDWIDTHTIMINGS = packed record
    MaxBandwidthUtilized: Single;
    FrontEndUploadMemoryUtilizedPercent: Single;
    VertexRateUtilizedPercent: Single;
    TriangleSetupRateUtilizedPercent: Single;
    FillRateUtilizedPercent: Single;
  end;
  D3DDEVINFO_D3D9BANDWIDTHTIMINGS = _D3DDEVINFO_D3D9BANDWIDTHTIMINGS;
  TD3DDevInfoD3D9BandwidthTimings = _D3DDEVINFO_D3D9BANDWIDTHTIMINGS;

  PD3DDevInfoD3D9CacheUtilization = ^TD3DDevInfoD3D9CacheUtilization;
  _D3DDEVINFO_D3D9CACHEUTILIZATION = packed record
    TextureCacheHitRate: Single; // Percentage of cache hits
    PostTransformVertexCacheHitRate: Single;
  end;
  D3DDEVINFO_D3D9CACHEUTILIZATION = _D3DDEVINFO_D3D9CACHEUTILIZATION;
  TD3DDevInfoD3D9CacheUtilization = _D3DDEVINFO_D3D9CACHEUTILIZATION;





(*==========================================================================;
 *
 *  Copyright (C) Microsoft Corporation.  All Rights Reserved.
 *
 *  File:       d3d9caps.h
 *  Content:    Direct3D capabilities include file
 *
 ***************************************************************************)

type
  PD3DVShaderCaps2_0 = ^TD3DVShaderCaps2_0;
  _D3DVSHADERCAPS2_0 = packed record
    Caps:                     DWORD;
    DynamicFlowControlDepth:  Integer;
    NumTemps:                 Integer;
    StaticFlowControlDepth:   Integer;
  end;
  D3DVSHADERCAPS2_0 = _D3DVSHADERCAPS2_0;
  TD3DVShaderCaps2_0 = _D3DVSHADERCAPS2_0;

const
  D3DVS20CAPS_PREDICATION              = (1 shl 0);

  D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH  = 24;
  D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH  = 0;
  D3DVS20_MAX_NUMTEMPS                 = 32;
  D3DVS20_MIN_NUMTEMPS                 = 12;
  D3DVS20_MAX_STATICFLOWCONTROLDEPTH   = 4;
  D3DVS20_MIN_STATICFLOWCONTROLDEPTH   = 1;

type
  PD3DPShaderCaps2_0 = ^TD3DPShaderCaps2_0;
  _D3DPSHADERCAPS2_0 = packed record
    Caps:                     DWORD;
    DynamicFlowControlDepth:  Integer;
    NumTemps:                 Integer;
    StaticFlowControlDepth:   Integer;
    NumInstructionSlots:      Integer;
  end;
  D3DPSHADERCAPS2_0 = _D3DPSHADERCAPS2_0;
  TD3DPShaderCaps2_0 = _D3DPSHADERCAPS2_0;

const
  D3DPS20CAPS_ARBITRARYSWIZZLE         = (1 shl 0);
  D3DPS20CAPS_GRADIENTINSTRUCTIONS     = (1 shl 1);
  D3DPS20CAPS_PREDICATION              = (1 shl 2);
  D3DPS20CAPS_NODEPENDENTREADLIMIT     = (1 shl 3);
  D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT    = (1 shl 4);

  D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH  = 24;
  D3DPS20_MIN_DYNAMICFLOWCONTROLDEPTH  = 0;
  D3DPS20_MAX_NUMTEMPS                 = 32;
  D3DPS20_MIN_NUMTEMPS                 = 12;
  D3DPS20_MAX_STATICFLOWCONTROLDEPTH   = 4;
  D3DPS20_MIN_STATICFLOWCONTROLDEPTH   = 0;
  D3DPS20_MAX_NUMINSTRUCTIONSLOTS      = 512;
  D3DPS20_MIN_NUMINSTRUCTIONSLOTS      = 96;

  D3DMIN30SHADERINSTRUCTIONS           = 512;
  D3DMAX30SHADERINSTRUCTIONS           = 32768;

type
  PD3DCaps9 = ^TD3DCaps9;
  _D3DCAPS9 = record
    (* Device Info *)
    DeviceType: TD3DDevType;
    AdapterOrdinal: DWord;

    (* Caps from DX7 Draw *)
    Caps: DWord;
    Caps2: DWord;
    Caps3: DWord;
    PresentationIntervals: DWord;

    (* Cursor Caps *)
    CursorCaps: DWORD;

    (* 3D Device Caps *)
    DevCaps: DWord;
    PrimitiveMiscCaps: DWord;
    RasterCaps: DWord;
    ZCmpCaps: DWord;
    SrcBlendCaps: DWord;
    DestBlendCaps: DWord;
    AlphaCmpCaps: DWord;
    ShadeCaps: DWord;
    TextureCaps: DWord;
    TextureFilterCaps: DWord;           // D3DPTFILTERCAPS for IDirect3DTexture9's
    CubeTextureFilterCaps: DWord;       // D3DPTFILTERCAPS for IDirect3DCubeTexture9's
    VolumeTextureFilterCaps: DWord;     // D3DPTFILTERCAPS for IDirect3DVolumeTexture9's
    TextureAddressCaps: DWord;          // D3DPTADDRESSCAPS for IDirect3DTexture9's
    VolumeTextureAddressCaps: DWord;    // D3DPTADDRESSCAPS for IDirect3DVolumeTexture9's

    LineCaps: DWord;                    // D3DLINECAPS

    MaxTextureWidth, MaxTextureHeight: DWord;
    MaxVolumeExtent: DWord;

    MaxTextureRepeat: DWord;
    MaxTextureAspectRatio: DWord;
    MaxAnisotropy: DWord;
    MaxVertexW: Single;

    GuardBandLeft: Single;
    GuardBandTop: Single;
    GuardBandRight: Single;
    GuardBandBottom: Single;

    ExtentsAdjust: Single;
    StencilCaps: DWord;

    FVFCaps: DWord;
    TextureOpCaps: DWord;
    MaxTextureBlendStages: DWord;
    MaxSimultaneousTextures: DWord;

    VertexProcessingCaps: DWord;
    MaxActiveLights: DWord;
    MaxUserClipPlanes: DWord;
    MaxVertexBlendMatrices: DWord;
    MaxVertexBlendMatrixIndex: DWord;

    MaxPointSize: Single;

    MaxPrimitiveCount: DWord;           // max number of primitives per DrawPrimitive call
    MaxVertexIndex: DWord;
    MaxStreams: DWord;
    MaxStreamStride: DWord;             // max stride for SetStreamSource

    VertexShaderVersion: DWord;
    MaxVertexShaderConst: DWord;        // number of vertex shader constant registers

    PixelShaderVersion: DWord;
    PixelShader1xMaxValue: Single;      // max value storable in registers of ps.1.x shaders

    // Here are the DX9 specific ones
    DevCaps2: DWORD;

    MaxNpatchTessellationLevel: Single;
    Reserved5: DWORD;

    MasterAdapterOrdinal: LongWord;     // ordinal of master adaptor for adapter group
    AdapterOrdinalInGroup: LongWord;    // ordinal inside the adapter group
    NumberOfAdaptersInGroup: LongWord;  // number of adapters in this adapter group (only if master)
    DeclTypes: DWORD;                   // Data types, supported in vertex declarations
    NumSimultaneousRTs: DWORD;          // Will be at least 1
    StretchRectFilterCaps: DWORD;       // Filter caps supported by StretchRect
    VS20Caps: TD3DVShaderCaps2_0;
    PS20Caps: TD3DPShaderCaps2_0;
    VertexTextureFilterCaps: DWORD;     // D3DPTFILTERCAPS for IDirect3DTexture9's for texture, used in vertex shaders
    MaxVShaderInstructionsExecuted: DWORD; // maximum number of vertex shader instructions that can be executed
    MaxPShaderInstructionsExecuted: DWORD; // maximum number of pixel shader instructions that can be executed
    MaxVertexShader30InstructionSlots: DWORD;
    MaxPixelShader30InstructionSlots: DWORD;
  end {D3DCAPS9};
  D3DCAPS9 = _D3DCAPS9;
  TD3DCaps9 = _D3DCAPS9;

  //
  // BIT DEFINES FOR D3DCAPS9 DWORD MEMBERS
  //

const
  //
  // Caps
  //
  D3DCAPS_READ_SCANLINE         = $00020000;

  //
  // Caps2
  //
  D3DCAPS2_FULLSCREENGAMMA      = $00020000;
  D3DCAPS2_CANCALIBRATEGAMMA    = $00100000;
  D3DCAPS2_RESERVED             = $02000000;
  D3DCAPS2_CANMANAGERESOURCE    = $10000000;
  D3DCAPS2_DYNAMICTEXTURES      = $20000000;
  D3DCAPS2_CANAUTOGENMIPMAP     = $40000000;

  //
  // Caps3
  //
  D3DCAPS3_RESERVED             = $8000001F;

  // Indicates that the device can respect the ALPHABLENDENABLE render state
  // when fullscreen while using the FLIP or DISCARD swap effect.
  // COPY and COPYVSYNC swap effects work whether or not this flag is set.
  D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD     = $00000020;

  // Indicates that the device can perform a gamma correction from
  // a windowed back buffer containing linear content to the sRGB desktop.
  D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION  = $00000080;

  D3DCAPS3_COPY_TO_VIDMEM         = $00000100; { Device can acclerate copies from sysmem to local vidmem }
  D3DCAPS3_COPY_TO_SYSTEMMEM      = $00000200; { Device can acclerate copies from local vidmem to sysmem }


  //
  // PresentationIntervals
  //
  D3DPRESENT_INTERVAL_DEFAULT   = $00000000;
  D3DPRESENT_INTERVAL_ONE       = $00000001;
  D3DPRESENT_INTERVAL_TWO       = $00000002;
  D3DPRESENT_INTERVAL_THREE     = $00000004;
  D3DPRESENT_INTERVAL_FOUR      = $00000008;
  D3DPRESENT_INTERVAL_IMMEDIATE = $80000000;

  //
  // CursorCaps
  //
  // Driver supports HW color cursor in at least hi-res modes(height >=400)
  D3DCURSORCAPS_COLOR           = $00000001;
  // Driver supports HW cursor also in low-res modes(height < 400)
  D3DCURSORCAPS_LOWRES          = $00000002;

  //
  // DevCaps
  //
  D3DDEVCAPS_EXECUTESYSTEMMEMORY        = $00000010; { Device can use execute buffers from system memory }
  D3DDEVCAPS_EXECUTEVIDEOMEMORY         = $00000020; { Device can use execute buffers from video memory }
  D3DDEVCAPS_TLVERTEXSYSTEMMEMORY       = $00000040; { Device can use TL buffers from system memory }
  D3DDEVCAPS_TLVERTEXVIDEOMEMORY        = $00000080; { Device can use TL buffers from video memory }
  D3DDEVCAPS_TEXTURESYSTEMMEMORY        = $00000100; { Device can texture from system memory }
  D3DDEVCAPS_TEXTUREVIDEOMEMORY         = $00000200; { Device can texture from device memory }
  D3DDEVCAPS_DRAWPRIMTLVERTEX           = $00000400; { Device can draw TLVERTEX primitives }
  D3DDEVCAPS_CANRENDERAFTERFLIP         = $00000800; { Device can render without waiting for flip to complete }
  D3DDEVCAPS_TEXTURENONLOCALVIDMEM      = $00001000; { Device can texture from nonlocal video memory }
  D3DDEVCAPS_DRAWPRIMITIVES2            = $00002000; { Device can support DrawPrimitives2 }
  D3DDEVCAPS_SEPARATETEXTUREMEMORIES    = $00004000; { Device is texturing from separate memory pools }
  D3DDEVCAPS_DRAWPRIMITIVES2EX          = $00008000; { Device can support Extended DrawPrimitives2 i.e. DX7 compliant driver }
  D3DDEVCAPS_HWTRANSFORMANDLIGHT        = $00010000; { Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also }
  D3DDEVCAPS_CANBLTSYSTONONLOCAL        = $00020000; { Device supports a Tex Blt from system memory to non-local vidmem }
  D3DDEVCAPS_HWRASTERIZATION            = $00080000; { Device has HW acceleration for rasterization }
  D3DDEVCAPS_PUREDEVICE                 = $00100000; { Device supports D3DCREATE_PUREDEVICE }
  D3DDEVCAPS_QUINTICRTPATCHES           = $00200000; { Device supports quintic Beziers and BSplines }
  D3DDEVCAPS_RTPATCHES                  = $00400000; { Device supports Rect and Tri patches }
  D3DDEVCAPS_RTPATCHHANDLEZERO          = $00800000; { Indicates that RT Patches may be drawn efficiently using handle 0 }
  D3DDEVCAPS_NPATCHES                   = $01000000; { Device supports N-Patches }

  //
  // PrimitiveMiscCaps
  //
  D3DPMISCCAPS_MASKZ                    = $00000002;
  D3DPMISCCAPS_CULLNONE                 = $00000010;
  D3DPMISCCAPS_CULLCW                   = $00000020;
  D3DPMISCCAPS_CULLCCW                  = $00000040;
  D3DPMISCCAPS_COLORWRITEENABLE         = $00000080;
  D3DPMISCCAPS_CLIPPLANESCALEDPOINTS    = $00000100; { Device correctly clips scaled points to clip planes }
  D3DPMISCCAPS_CLIPTLVERTS              = $00000200; { device will clip post-transformed vertex primitives }
  D3DPMISCCAPS_TSSARGTEMP               = $00000400; { device supports D3DTA_TEMP for temporary register }
  D3DPMISCCAPS_BLENDOP                  = $00000800; { device supports D3DRS_BLENDOP }
  D3DPMISCCAPS_NULLREFERENCE            = $00001000; { Reference Device that doesnt render }
  D3DPMISCCAPS_INDEPENDENTWRITEMASKS    = $00004000; { Device supports independent write masks for MET or MRT }
  D3DPMISCCAPS_PERSTAGECONSTANT         = $00008000; { Device supports per-stage constants }
  D3DPMISCCAPS_FOGANDSPECULARALPHA      = $00010000; { Device supports separate fog and specular alpha (many devices
                                                       use the specular alpha channel to store fog factor) }
  D3DPMISCCAPS_SEPARATEALPHABLEND       = $00020000; { Device supports separate blend settings for the alpha channel }
  D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS    = $00040000; { Device supports different bit depths for MRT }
  D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING = $00080000; { Device supports post-pixel shader operations for MRT }
  D3DPMISCCAPS_FOGVERTEXCLAMPED           = $00100000; { Device clamps fog blend factor per vertex }

  //
  // LineCaps
  //
  D3DLINECAPS_TEXTURE                   = $00000001;
  D3DLINECAPS_ZTEST                     = $00000002;
  D3DLINECAPS_BLEND                     = $00000004;
  D3DLINECAPS_ALPHACMP                  = $00000008;
  D3DLINECAPS_FOG                       = $00000010;
  D3DLINECAPS_ANTIALIAS                 = $00000020;

  //
  // RasterCaps
  //
  D3DPRASTERCAPS_DITHER                 = $00000001;
  D3DPRASTERCAPS_ZTEST                  = $00000010;
  D3DPRASTERCAPS_FOGVERTEX              = $00000080;
  D3DPRASTERCAPS_FOGTABLE               = $00000100;
  D3DPRASTERCAPS_MIPMAPLODBIAS          = $00002000;
  D3DPRASTERCAPS_ZBUFFERLESSHSR         = $00008000;
  D3DPRASTERCAPS_FOGRANGE               = $00010000;
  D3DPRASTERCAPS_ANISOTROPY             = $00020000;
  D3DPRASTERCAPS_WBUFFER                = $00040000;
  D3DPRASTERCAPS_WFOG                   = $00100000;
  D3DPRASTERCAPS_ZFOG                   = $00200000;
  D3DPRASTERCAPS_COLORPERSPECTIVE       = $00400000; { Device iterates colors perspective correct }
  D3DPRASTERCAPS_SCISSORTEST            = $01000000;
  D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS    = $02000000;
  D3DPRASTERCAPS_DEPTHBIAS              = $04000000;
  D3DPRASTERCAPS_MULTISAMPLE_TOGGLE     = $08000000;

  //
  // ZCmpCaps, AlphaCmpCaps
  //
  D3DPCMPCAPS_NEVER                     = $00000001;
  D3DPCMPCAPS_LESS                      = $00000002;
  D3DPCMPCAPS_EQUAL                     = $00000004;
  D3DPCMPCAPS_LESSEQUAL                 = $00000008;
  D3DPCMPCAPS_GREATER                   = $00000010;
  D3DPCMPCAPS_NOTEQUAL                  = $00000020;
  D3DPCMPCAPS_GREATEREQUAL              = $00000040;
  D3DPCMPCAPS_ALWAYS                    = $00000080;

  //
  // SourceBlendCaps, DestBlendCaps
  //
  D3DPBLENDCAPS_ZERO                    = $00000001;
  D3DPBLENDCAPS_ONE                     = $00000002;
  D3DPBLENDCAPS_SRCCOLOR                = $00000004;
  D3DPBLENDCAPS_INVSRCCOLOR             = $00000008;
  D3DPBLENDCAPS_SRCALPHA                = $00000010;
  D3DPBLENDCAPS_INVSRCALPHA             = $00000020;
  D3DPBLENDCAPS_DESTALPHA               = $00000040;
  D3DPBLENDCAPS_INVDESTALPHA            = $00000080;
  D3DPBLENDCAPS_DESTCOLOR               = $00000100;
  D3DPBLENDCAPS_INVDESTCOLOR            = $00000200;
  D3DPBLENDCAPS_SRCALPHASAT             = $00000400;
  D3DPBLENDCAPS_BOTHSRCALPHA            = $00000800;
  D3DPBLENDCAPS_BOTHINVSRCALPHA         = $00001000;
  D3DPBLENDCAPS_BLENDFACTOR             = $00002000; { Supports both D3DBLEND_BLENDFACTOR and D3DBLEND_INVBLENDFACTOR }

  //
  // ShadeCaps
  //
  D3DPSHADECAPS_COLORGOURAUDRGB         = $00000008;
  D3DPSHADECAPS_SPECULARGOURAUDRGB      = $00000200;
  D3DPSHADECAPS_ALPHAGOURAUDBLEND       = $00004000;
  D3DPSHADECAPS_FOGGOURAUD              = $00080000;

  //
  // TextureCaps
  //
  D3DPTEXTURECAPS_PERSPECTIVE           = $00000001; { Perspective-correct texturing is supported }
  D3DPTEXTURECAPS_POW2                  = $00000002; { Power-of-2 texture dimensions are required - applies to non-Cube/Volume textures only. }
  D3DPTEXTURECAPS_ALPHA                 = $00000004; { Alpha in texture pixels is supported }
  D3DPTEXTURECAPS_SQUAREONLY            = $00000020; { Only square textures are supported }
  D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE = $00000040; { Texture indices are not scaled by the texture size prior to interpolation }
  D3DPTEXTURECAPS_ALPHAPALETTE          = $00000080; { Device can draw alpha from texture palettes }
  // 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;
  D3DPTEXTURECAPS_PROJECTED             = $00000400; { Device can do D3DTTFF_PROJECTED }
  D3DPTEXTURECAPS_CUBEMAP               = $00000800; { Device can do cubemap textures }
  D3DPTEXTURECAPS_VOLUMEMAP             = $00002000; { Device can do volume textures }
  D3DPTEXTURECAPS_MIPMAP                = $00004000; { Device can do mipmapped textures }
  D3DPTEXTURECAPS_MIPVOLUMEMAP          = $00008000; { Device can do mipmapped volume textures }
  D3DPTEXTURECAPS_MIPCUBEMAP            = $00010000; { Device can do mipmapped cube maps }
  D3DPTEXTURECAPS_CUBEMAP_POW2          = $00020000; { Device requires that cubemaps be power-of-2 dimension }
  D3DPTEXTURECAPS_VOLUMEMAP_POW2        = $00040000; { Device requires that volume maps be power-of-2 dimension }
  D3DPTEXTURECAPS_NOPROJECTEDBUMPENV    = $00200000; { Device does not support projected bump env lookup operation
                                                       in programmable and fixed function pixel shaders }

  //
  // TextureFilterCaps, StretchRectFilterCaps
  //
  D3DPTFILTERCAPS_MINFPOINT             = $00000100; { Min Filter }
  D3DPTFILTERCAPS_MINFLINEAR            = $00000200;
  D3DPTFILTERCAPS_MINFANISOTROPIC       = $00000400;
  D3DPTFILTERCAPS_MINFPYRAMIDALQUAD     = $00000800;
  D3DPTFILTERCAPS_MINFGAUSSIANQUAD      = $00001000;
  D3DPTFILTERCAPS_MIPFPOINT             = $00010000; { Mip Filter }
  D3DPTFILTERCAPS_MIPFLINEAR            = $00020000;
  D3DPTFILTERCAPS_MAGFPOINT             = $01000000; { Mag Filter }
  D3DPTFILTERCAPS_MAGFLINEAR            = $02000000;
  D3DPTFILTERCAPS_MAGFANISOTROPIC       = $04000000;
  D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD     = $08000000;
  D3DPTFILTERCAPS_MAGFGAUSSIANQUAD      = $10000000;

  //
  // TextureAddressCaps
  //
  D3DPTADDRESSCAPS_WRAP                 = $00000001;
  D3DPTADDRESSCAPS_MIRROR               = $00000002;
  D3DPTADDRESSCAPS_CLAMP                = $00000004;
  D3DPTADDRESSCAPS_BORDER               = $00000008;
  D3DPTADDRESSCAPS_INDEPENDENTUV        = $00000010;
  D3DPTADDRESSCAPS_MIRRORONCE           = $00000020;

  //
  // StencilCaps
  //
  D3DSTENCILCAPS_KEEP                   = $00000001;
  D3DSTENCILCAPS_ZERO                   = $00000002;
  D3DSTENCILCAPS_REPLACE                = $00000004;
  D3DSTENCILCAPS_INCRSAT                = $00000008;
  D3DSTENCILCAPS_DECRSAT                = $00000010;
  D3DSTENCILCAPS_INVERT                 = $00000020;
  D3DSTENCILCAPS_INCR                   = $00000040;
  D3DSTENCILCAPS_DECR                   = $00000080;
  D3DSTENCILCAPS_TWOSIDED               = $00000100;

  //
  // TextureOpCaps
  //
  D3DTEXOPCAPS_DISABLE                          = $00000001;
  D3DTEXOPCAPS_SELECTARG1                       = $00000002;
  D3DTEXOPCAPS_SELECTARG2                       = $00000004;
  D3DTEXOPCAPS_MODULATE                         = $00000008;
  D3DTEXOPCAPS_MODULATE2X                       = $00000010;
  D3DTEXOPCAPS_MODULATE4X                       = $00000020;
  D3DTEXOPCAPS_ADD                              = $00000040;
  D3DTEXOPCAPS_ADDSIGNED                        = $00000080;
  D3DTEXOPCAPS_ADDSIGNED2X                      = $00000100;
  D3DTEXOPCAPS_SUBTRACT                         = $00000200;
  D3DTEXOPCAPS_ADDSMOOTH                        = $00000400;
  D3DTEXOPCAPS_BLENDDIFFUSEALPHA                = $00000800;
  D3DTEXOPCAPS_BLENDTEXTUREALPHA                = $00001000;
  D3DTEXOPCAPS_BLENDFACTORALPHA                 = $00002000;
  D3DTEXOPCAPS_BLENDTEXTUREALPHAPM              = $00004000;
  D3DTEXOPCAPS_BLENDCURRENTALPHA                = $00008000;
  D3DTEXOPCAPS_PREMODULATE                      = $00010000;
  D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR           = $00020000;
  D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA           = $00040000;
  D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR        = $00080000;
  D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA        = $00100000;
  D3DTEXOPCAPS_BUMPENVMAP                       = $00200000;
  D3DTEXOPCAPS_BUMPENVMAPLUMINANCE              = $00400000;
  D3DTEXOPCAPS_DOTPRODUCT3                      = $00800000;
  D3DTEXOPCAPS_MULTIPLYADD                      = $01000000;
  D3DTEXOPCAPS_LERP                             = $02000000;

  //
  // FVFCaps
  //
  D3DFVFCAPS_TEXCOORDCOUNTMASK  = $0000ffff; { mask for texture coordinate count field }
  D3DFVFCAPS_DONOTSTRIPELEMENTS = $00080000; { Device prefers that vertex elements not be stripped }
  D3DFVFCAPS_PSIZE              = $00100000; { Device can receive point size }

  //
  // VertexProcessingCaps
  //
  D3DVTXPCAPS_TEXGEN            = $00000001; { device can do texgen }
  D3DVTXPCAPS_MATERIALSOURCE7   = $00000002; { device can do DX7-level colormaterialsource ops }
  D3DVTXPCAPS_DIRECTIONALLIGHTS = $00000008; { device can do directional lights }
  D3DVTXPCAPS_POSITIONALLIGHTS  = $00000010; { device can do positional lights (includes point and spot) }
  D3DVTXPCAPS_LOCALVIEWER       = $00000020; { device can do local viewer }
  D3DVTXPCAPS_TWEENING          = $00000040; { device can do vertex tweening }
  D3DVTXPCAPS_TEXGEN_SPHEREMAP  = $00000100; { device supports D3DTSS_TCI_SPHEREMAP }
  D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER = $00000200; { device does not support TexGen in non-local
                                                      viewer mode }

  //
  // DevCaps2
  //
  D3DDEVCAPS2_STREAMOFFSET                        = $00000001; { Device supports offsets in streams. Must be set by DX9 drivers }
  D3DDEVCAPS2_DMAPNPATCH                          = $00000002; { Device supports displacement maps for N-Patches}
  D3DDEVCAPS2_ADAPTIVETESSRTPATCH                 = $00000004; { Device supports adaptive tesselation of RT-patches}
  D3DDEVCAPS2_ADAPTIVETESSNPATCH                  = $00000008; { Device supports adaptive tesselation of N-patches}
  D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES       = $00000010; { Device supports StretchRect calls with a texture as the source}
  D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH                = $00000020; { Device supports presampled displacement maps for N-Patches }
  D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET  = $00000040; { Vertex elements in a vertex declaration can share the same stream offset }

  //
  // DeclTypes
  //
  D3DDTCAPS_UBYTE4     = $00000001;
  D3DDTCAPS_UBYTE4N    = $00000002;
  D3DDTCAPS_SHORT2N    = $00000004;
  D3DDTCAPS_SHORT4N    = $00000008;
  D3DDTCAPS_USHORT2N   = $00000010;
  D3DDTCAPS_USHORT4N   = $00000020;
  D3DDTCAPS_UDEC3      = $00000040;
  D3DDTCAPS_DEC3N      = $00000080;
  D3DDTCAPS_FLOAT16_2  = $00000100;
  D3DDTCAPS_FLOAT16_4  = $00000200;




(*==========================================================================;
 *
 *  Copyright (C) Microsoft Corporation.  All Rights Reserved.
 *
 *  File:   d3d9.h
 *  Content:    Direct3D include file
 *
 ****************************************************************************)

(* This identifier is passed to Direct3DCreate9 in order to ensure that an
 * application was built against the correct header files. This number is
 * incremented whenever a header (or other) change would require applications
 * to be rebuilt. If the version doesn't match, Direct3DCreate9 will fail.
 * (The number itself has no meaning.)*)

const
  D3D_SDK_VERSION   = (32 or $80000000);
  D3D9b_SDK_VERSION = (31 or $80000000);

type
  HMONITOR = THandle;

(*
 * 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;

  
  IDirect3D9 = interface(IUnknown)
    ['{81BDCBCA-64D4-426d-AE8D-AD0147F4275C}']
    (*** IDirect3D9 methods ***)
    function RegisterSoftwareDevice(pInitializeFunction: Pointer): HResult; stdcall;
    function GetAdapterCount: LongWord; stdcall;
    function GetAdapterIdentifier(Adapter: LongWord; Flags: DWord; out pIdentifier: TD3DAdapterIdentifier9): HResult; stdcall;
    function GetAdapterModeCount(Adapter: LongWord; Format: TD3DFormat): LongWord; stdcall;
    function EnumAdapterModes(Adapter: LongWord; Format: TD3DFormat; Mode: LongWord; out pMode: TD3DDisplayMode): HResult; stdcall;
    function GetAdapterDisplayMode(Adapter: LongWord; out pMode: TD3DDisplayMode): HResult; stdcall;
    function CheckDeviceType(Adapter: LongWord; CheckType: TD3DDevType; AdapterFormat, BackBufferFormat: TD3DFormat; Windowed: BOOL): HResult; stdcall;
    function CheckDeviceFormat(Adapter: LongWord; DeviceType: TD3DDevType; AdapterFormat: TD3DFormat; Usage: DWord; RType: TD3DResourceType; CheckFormat: TD3DFormat): HResult; stdcall;
    function CheckDeviceMultiSampleType(Adapter: LongWord; DeviceType: TD3DDevType; SurfaceFormat: TD3DFormat; Windowed: BOOL; MultiSampleType: TD3DMultiSampleType; pQualityLevels: PDWORD): HResult; stdcall;
    function CheckDepthStencilMatch(Adapter: LongWord; DeviceType: TD3DDevType; AdapterFormat, RenderTargetFormat, DepthStencilFormat: TD3DFormat): HResult; stdcall;
    function CheckDeviceFormatConversion(Adapter: LongWord; DeviceType: TD3DDevType; SourceFormat, TargetFormat: TD3DFormat): HResult; stdcall;
    function GetDeviceCaps(Adapter: LongWord; DeviceType: TD3DDevType; out pCaps: TD3DCaps9): HResult; stdcall;
    function GetAdapterMonitor(Adapter: LongWord): HMONITOR; stdcall;
    function CreateDevice(Adapter: LongWord; DeviceType: TD3DDevType; hFocusWindow: HWND; BehaviorFlags: DWord; pPresentationParameters: PD3DPresentParameters; out ppReturnedDeviceInterface: IDirect3DDevice9): HResult; stdcall;
  end;

  IDirect3D9Helper = class
    (*** helper information ***)
    szVersionString: PWideChar;
  end;




{ SwapChain }





  IDirect3DDevice9 = interface(IUnknown)
    ['{D0223B96-BF7A-43fd-92BD-A43B0D82B9EB}']
    (*** IDirect3DDevice9 methods ***)
    function TestCooperativeLevel: HResult; stdcall;
    function GetAvailableTextureMem: LongWord; stdcall;
    function EvictManagedResources: HResult; stdcall;
    function GetDirect3D(out ppD3D9: IDirect3D9): HResult; stdcall;
    function GetDeviceCaps(out pCaps: TD3DCaps9): HResult; stdcall;
    function GetDisplayMode(iSwapChain: LongWord; out pMode: TD3DDisplayMode): HResult; stdcall;
    function GetCreationParameters(out pParameters: TD3DDeviceCreationParameters): HResult; stdcall;
    function SetCursorProperties(XHotSpot, YHotSpot: LongWord; pCursorBitmap: IDirect3DSurface9): HResult; stdcall;
    procedure SetCursorPosition(XScreenSpace, YScreenSpace: LongWord; Flags: DWord); stdcall;
    function ShowCursor(bShow: BOOL): BOOL; stdcall;
    function CreateAdditionalSwapChain(const pPresentationParameters: TD3DPresentParameters; out pSwapChain: IDirect3DSwapChain9): HResult; stdcall;
    function GetSwapChain(iSwapChain: LongWord; out pSwapChain: IDirect3DSwapChain9): HResult; stdcall;
    function GetNumberOfSwapChains: LongWord; stdcall;
    function Reset(const pPresentationParameters: TD3DPresentParameters): HResult; stdcall;
    function Present(pSourceRect, pDestRect: PRect; hDestWindowOverride: HWND; pDirtyRegion: PRgnData): HResult; stdcall;
    function GetBackBuffer(iSwapChain: LongWord; iBackBuffer: LongWord; _Type: TD3DBackBufferType; out ppBackBuffer: IDirect3DSurface9): HResult; stdcall;
    function GetRasterStatus(iSwapChain: LongWord; out pRasterStatus: TD3DRasterStatus): HResult; stdcall;
    function SetDialogBoxMode(bEnableDialogs: BOOL): HResult; stdcall;
    procedure SetGammaRamp(iSwapChain: LongWord; Flags: DWord; const pRamp: TD3DGammaRamp); stdcall;
    procedure GetGammaRamp(iSwapChain: LongWord; out pRamp: TD3DGammaRamp); stdcall;
    function CreateTexture(Width, Height, Levels: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppTexture: IDirect3DTexture9; pSharedHandle: PHandle): HResult; stdcall;
    function CreateVolumeTexture(Width, Height, Depth, Levels: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppVolumeTexture: IDirect3DVolumeTexture9; pSharedHandle: PHandle): HResult; stdcall;
    function CreateCubeTexture(EdgeLength, Levels: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppCubeTexture: IDirect3DCubeTexture9; pSharedHandle: PHandle): HResult; stdcall;
    function CreateVertexBuffer(Length: LongWord; Usage, FVF: DWord; Pool: TD3DPool; out ppVertexBuffer: IDirect3DVertexBuffer9; pSharedHandle: PHandle): HResult; stdcall;
    function CreateIndexBuffer(Length: LongWord; Usage: DWord; Format: TD3DFormat; Pool: TD3DPool; out ppIndexBuffer: IDirect3DIndexBuffer9; pSharedHandle: PHandle): HResult; stdcall;
    function CreateRenderTarget(Width, Height: LongWord; Format: TD3DFormat; MultiSample: TD3DMultiSampleType; MultisampleQuality: DWORD; Lockable: BOOL; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle): HResult; stdcall;
    function CreateDepthStencilSurface(Width, Height: LongWord; Format: TD3DFormat; MultiSample: TD3DMultiSampleType; MultisampleQuality: DWORD; Discard: BOOL; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle): HResult; stdcall;
    function UpdateSurface(pSourceSurface: IDirect3DSurface9; pSourceRect: PRect; pDestinationSurface: IDirect3DSurface9; pDestPoint: PPoint): HResult; stdcall;
    function UpdateTexture(pSourceTexture, pDestinationTexture: IDirect3DBaseTexture9): HResult; stdcall;
    function GetRenderTargetData(pRenderTarget, pDestSurface: IDirect3DSurface9): HResult; stdcall;
    function GetFrontBufferData(iSwapChain: LongWord; pDestSurface: IDirect3DSurface9): HResult; stdcall;
    function StretchRect(pSourceSurface: IDirect3DSurface9; pSourceRect: PRect; pDestSurface: IDirect3DSurface9; pDestRect: PRect; Filter: TD3DTextureFilterType): HResult; stdcall;
    function ColorFill(pSurface: IDirect3DSurface9; pRect: PRect; color: TD3DColor): HResult; stdcall;
    function CreateOffscreenPlainSurface(Width, Height: LongWord; Format: TD3DFormat; Pool: TD3DPool; out ppSurface: IDirect3DSurface9; pSharedHandle: PHandle): HResult; stdcall;
    function SetRenderTarget(RenderTargetIndex: DWORD; pRenderTarget: IDirect3DSurface9): HResult; stdcall;
    function GetRenderTarget(RenderTargetIndex: DWORD; out ppRenderTarget: IDirect3DSurface9): HResult; stdcall;
    function SetDepthStencilSurface(pNewZStencil: IDirect3DSurface9): HResult; stdcall;
    function GetDepthStencilSurface(out ppZStencilSurface: IDirect3DSurface9): HResult; stdcall;
    function BeginScene: HResult; stdcall;
    function EndScene: HResult; stdcall;
    function Clear(Count: DWord; pRects: PD3DRect; Flags: DWord; Color: TD3DColor; Z: Single; Stencil: DWord): HResult; stdcall;
    function SetTransform(State: TD3DTransformStateType; const pMatrix: TD3DMatrix): HResult; stdcall;
    function GetTransform(State: TD3DTransformStateType; out pMatrix: TD3DMatrix): HResult; stdcall;
    function MultiplyTransform(State: TD3DTransformStateType; const pMatrix: TD3DMatrix): HResult; stdcall;
    function SetViewport(const pViewport: TD3DViewport9): HResult; stdcall;
    function GetViewport(out pViewport: TD3DViewport9): HResult; stdcall;
    function SetMaterial(const pMaterial: TD3DMaterial9): HResult; stdcall;
    function GetMaterial(out pMaterial: TD3DMaterial9): HResult; stdcall;
    function SetLight(Index: DWord; const pLight: TD3DLight9): HResult; stdcall;
    function GetLight(Index: DWord; out pLight: TD3DLight9): HResult; stdcall;
    function LightEnable(Index: DWord; Enable: BOOL): HResult; stdcall;
    function GetLightEnable(Index: DWord; out pEnable: BOOL): HResult; stdcall;
    function SetClipPlane(Index: DWord; pPlane: PSingle): HResult; stdcall;
    function GetClipPlane(Index: DWord; pPlane: PSingle): HResult; stdcall;
    function SetRenderState(State: TD3DRenderStateType; Value: DWord): HResult; stdcall;
    function GetRenderState(State: TD3DRenderStateType; out pValue: DWord): HResult; stdcall;
    function CreateStateBlock(_Type: TD3DStateBlockType; out ppSB: IDirect3DStateBlock9): HResult; stdcall;
    function BeginStateBlock: HResult; stdcall;
    function EndStateBlock(out ppSB: IDirect3DStateBlock9): HResult; stdcall;
    function SetClipStatus(const pClipStatus: TD3DClipStatus9): HResult; stdcall;
    function GetClipStatus(out pClipStatus: TD3DClipStatus9): HResult; stdcall;
    function GetTexture(Stage: DWord; out ppTexture: IDirect3DBaseTexture9): HResult; stdcall;
    function SetTexture(Stage: DWord; pTexture: IDirect3DBaseTexture9): HResult; stdcall;
    function GetTextureStageState(Stage: DWord; _Type: TD3DTextureStageStateType; out pValue: DWord): HResult; stdcall;
    function SetTextureStageState(Stage: DWord; _Type: TD3DTextureStageStateType; Value: DWord): HResult; stdcall;
    function GetSamplerState(Sampler: DWORD; _Type: TD3DSamplerStateType; out pValue: DWORD): HResult; stdcall;
    function SetSamplerState(Sampler: DWORD; _Type: TD3DSamplerStateType; Value: DWORD): HResult; stdcall;
    function ValidateDevice(out pNumPasses: DWord): HResult; stdcall;
    function SetPaletteEntries(PaletteNumber: LongWord; pEntries: pPaletteEntry): HResult; stdcall;
    function GetPaletteEntries(PaletteNumber: LongWord; pEntries: pPaletteEntry): HResult; stdcall;
    function SetCurrentTexturePalette(PaletteNumber: LongWord): HResult; stdcall;
    function GetCurrentTexturePalette(out PaletteNumber: LongWord): HResult; stdcall;
    function SetScissorRect(pRect: PRect): HResult; stdcall;
    function GetScissorRect(out pRect: TRect): HResult; stdcall;
    function SetSoftwareVertexProcessing(bSoftware: BOOL): HResult; stdcall;
    function GetSoftwareVertexProcessing: BOOL; stdcall;
    function SetNPatchMode(nSegments: Single): HResult; stdcall;
    function GetNPatchMode: Single; stdcall;
    function DrawPrimitive(PrimitiveType: TD3DPrimitiveType; StartVertex, PrimitiveCount: LongWord): HResult; stdcall;
    function DrawIndexedPrimitive(_Type: TD3DPrimitiveType; BaseVertexIndex: Integer; MinVertexIndex, NumVertices, startIndex, primCount: LongWord): HResult; stdcall;
    function DrawPrimitiveUP(PrimitiveType: TD3DPrimitiveType; PrimitiveCount: LongWord; const pVertexStreamZeroData; VertexStreamZeroStride: LongWord): HResult; stdcall;
    function DrawIndexedPrimitiveUP(PrimitiveType: TD3DPrimitiveType; MinVertexIndex, NumVertice, PrimitiveCount: LongWord; const pIndexData; IndexDataFormat: TD3DFormat; const pVertexStreamZeroData; VertexStreamZeroStride: LongWord): HResult; stdcall;
    function ProcessVertices(SrcStartIndex, DestIndex, VertexCount: LongWord; pDestBuffer: IDirect3DVertexBuffer9; pVertexDecl: IDirect3DVertexDeclaration9; Flags: DWord): HResult; stdcall;
    function CreateVertexDeclaration(pVertexElements: PD3DVertexElement9; out ppDecl: IDirect3DVertexDeclaration9): HResult; stdcall;
    function SetVertexDeclaration(pDecl: IDirect3DVertexDeclaration9): HResult; stdcall;
    function GetVertexDeclaration(out ppDecl: IDirect3DVertexDeclaration9): HResult; stdcall;
    function SetFVF(FVF: DWORD): HResult; stdcall;
    function GetFVF(out FVF: DWORD): HResult; stdcall;
    function CreateVertexShader(pFunction: PDWord; out ppShader: IDirect3DVertexShader9): HResult; stdcall;
    function SetVertexShader(pShader: IDirect3DVertexShader9): HResult; stdcall;
    function GetVertexShader(out ppShader: IDirect3DVertexShader9): HResult; stdcall;
    function SetVertexShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall;
    function GetVertexShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall;
    function SetVertexShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall;
    function GetVertexShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall;
    function SetVertexShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall;
    function GetVertexShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall;
    function SetStreamSource(StreamNumber: LongWord; pStreamData: IDirect3DVertexBuffer9; OffsetInBytes, Stride: LongWord): HResult; stdcall;
    function GetStreamSource(StreamNumber: LongWord; out ppStreamData: IDirect3DVertexBuffer9; out pOffsetInBytes, pStride: LongWord): HResult; stdcall;
    function SetStreamSourceFreq(StreamNumber: LongWord; Setting: LongWord): HResult; stdcall;
    function GetStreamSourceFreq(StreamNumber: LongWord; out Setting: LongWord): HResult; stdcall;
    function SetIndices(pIndexData: IDirect3DIndexBuffer9): HResult; stdcall;
    function GetIndices(out ppIndexData: IDirect3DIndexBuffer9): HResult; stdcall;
    function CreatePixelShader(pFunction: PDWord; out ppShader: IDirect3DPixelShader9): HResult; stdcall;
    function SetPixelShader(pShader: IDirect3DPixelShader9): HResult; stdcall;
    function GetPixelShader(out ppShader: IDirect3DPixelShader9): HResult; stdcall;
    function SetPixelShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall;
    function GetPixelShaderConstantF(StartRegister: LongWord; pConstantData: PSingle; Vector4fCount: LongWord): HResult; stdcall;
    function SetPixelShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall;
    function GetPixelShaderConstantI(StartRegister: LongWord; pConstantData: PInteger; Vector4iCount: LongWord): HResult; stdcall;
    function SetPixelShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall;
    function GetPixelShaderConstantB(StartRegister: LongWord; pConstantData: PBOOL; BoolCount: LongWord): HResult; stdcall;
    function DrawRectPatch(Handle: LongWord; pNumSegs: PSingle; pTriPatchInfo: PD3DRectPatchInfo): HResult; stdcall;
    function DrawTriPatch(Handle: LongWord; pNumSegs: PSingle; pTriPatchInfo: PD3DTriPatchInfo): HResult; stdcall;
    function DeletePatch(Handle: LongWord): HResult; stdcall;
    function CreateQuery(_Type: TD3DQueryType; out ppQuery: IDirect3DQuery9): HResult; stdcall;
  end;
                   
  IDirect3DDevice9Helper = class
    (*** helper information ***)
    CreationParameters: TD3DDeviceCreationParameters;
    PresentParameters: TD3DPresentParameters;
    DisplayMode: TD3DDisplayMode;
    Caps: TD3DCaps9;

    AvailableTextureMem: LongWord;
    SwapChains: LongWord;
    Textures: LongWord;
    VertexBuffers: LongWord;
    IndexBuffers: LongWord;
    VertexShaders: LongWord;
    PixelShaders: LongWord;

    Viewport: TD3DViewport9;
    ProjectionMatrix: TD3DMatrix;
    ViewMatrix: TD3DMatrix;
    WorldMatrix: TD3DMatrix;
    TextureMatrices: array[0..7] of TD3DMatrix;

    FVF: DWORD;
    VertexSize: LongWord;
    VertexShaderVersion: DWORD;
    PixelShaderVersion: DWORD;
    SoftwareVertexProcessing: BOOL;

    Material: TD3DMaterial9;
    Lights: array[0..15] of  TD3DLight9;
    LightsEnabled: array[0..15] of BOOL;

    GammaRamp: TD3DGammaRamp;
    ScissorRect: TRect;
    DialogBoxMode: BOOL;
  end;



  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;

  IDirect3DStateBlock9Helper = class
    (*** helper information ***)
    CreationCallStack: PWideChar;
  end;



  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;

  IDirect3DSwapChain9Helper = class
    (*** helper information ***)
    PresentParameters: TD3DPresentParameters;
    DisplayMode: TD3DDisplayMode;
    CreationCallStack: PWideChar;
  end;



  IDirect3DResource9 = interface(IUnknown)
    ['{05EEC05D-8F7D-4362-B999-D1BAF357C704}']
    (*** IDirect3DResource9 methods ***)
    function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall;
    function SetPrivateData(const refguid: TGUID; const pData: Pointer; SizeOfData, Flags: DWord): HResult; stdcall;
    function GetPrivateData(const refguid: TGUID; pData: Pointer; out pSizeOfData: DWord): HResult; stdcall;
    function FreePrivateData(const refguid: TGUID): HResult; stdcall;
    function SetPriority(PriorityNew: DWord): DWord; stdcall;
    function GetPriority: DWord; stdcall;
    procedure PreLoad; stdcall;
    function GetType: TD3DResourceType; stdcall;
  end;


  IDirect3DVertexDeclaration9 = interface(IUnknown)
    ['{DD13C59C-36FA-4098-A8FB-C7ED39DC8546}']
    (*** IDirect3DVertexDeclaration9 methods ***)
    function GetDevice(out ppDevice: IDirect3DDevice9): HResult; stdcall;
    function GetDeclaration(pElement: PD3DVertexElement9; out pNumElements: LongWord): HResult; stdcall;
  end;

  IDirect3DVertexDeclaration9Helper = class
    (*** helper information ***)
    CreationCallStack: PWideChar;
  end;



  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;

  IDirect3DVertexShader9Helper = class
    (*** helper information ***)
    Version: DWORD;
    CreationCallStack: PWideChar;
  end;



  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;

  IDirect3DPixelShader9Helper = class
    (*** helper information ***)
    Version: DWORD;
    CreationCallStack: PWideChar;
  end;



  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;


  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;

  IDirect3DTexture9Helper = class
    (*** helper information ***)
    Name: PWideChar;
    Width: LongWord;
    Height: LongWord;
    Levels: LongWord;
    Usage: DWORD;
    Format: TD3DFormat;
    Pool: TD3DPool;
    Priority: DWORD;
    LOD: DWORD;
    FilterType: TD3DTextureFilterType;
    LockCount: LongWord;
    CreationCallStack: PWideChar;
  end;



  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;

  IDirect3DVolumeTexture9Helper = class
    (*** helper information ***)
    Name: PWideChar;
    Width: LongWord;
    Height: LongWord;
    Depth: LongWord;
    Levels: LongWord;
    Usage: DWORD;
    Format: TD3DFormat;
    Pool: TD3DPool;
    Priority: DWORD;
    LOD: DWORD;
    FilterType: TD3DTextureFilterType;
    LockCount: LongWord;
    CreationCallStack: PWideChar;
  end;



  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;

  IDirect3DCubeTexture9Helper = class
    (*** helper information ***)
    Name: PWideChar;
    Width: LongWord;
    Height: LongWord;
    Depth: LongWord;
    Levels: LongWord;
    Usage: DWORD;
    Format: TD3DFormat;
    Pool: TD3DPool;
    Priority: DWORD;
    LOD: DWORD;
    FilterType: TD3DTextureFilterType;
    LockCount: LongWord;
    CreationCallStack: PWideChar;
  end;



  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;

  IDirect3DVertexBuffer9Helper = class
    (*** helper information ***)
    Name: PWideChar;
    Length: LongWord;
    Usage: DWORD;
    FVF: DWORD;
    Pool: TD3DPool;
    Priority: DWORD;
    LockCount: LongWord;
    CreationCallStack: PWideChar;
  end;



  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;

  IDirect3DIndexBuffer9Helper = class
    (*** helper information ***)
    Name: PWideChar;
    Length: LongWord;
    Usage: DWORD;
    Format: TD3DFormat;
    Pool: TD3DPool;
    Priority: DWORD;
    LockCount: LongWord;
    CreationCallStack: PWideChar;
  end;



  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;

  IDirect3DSurface9Helper = class
    (*** helper information ***)
    Name: PWideChar;
    Width: LongWord;
    Height: LongWord;
    Usage: DWORD;
    Format: TD3DFormat;
    Pool: TD3DPool;
    MultiSampleType: TD3DMultiSampleType;
    MultiSampleQuality: DWORD;
    Priority: DWORD;
    LockCount: LongWord;
    DCCount: LongWord;
    CreationCallStack: PWideChar;
  end;



  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;

  IDirect3DVolume9Helper = class
    (*** helper information ***)
    Name: PWideChar;
    Width: LongWord;
    Height: LongWord;
    Depth: LongWord;
    Usage: DWORD;
    Format: TD3DFormat;
    Pool: TD3DPool;
    LockCount: LongWord;
    CreationCallStack: PWideChar;
  end;



  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;

  IDirect3DQuery9Helper = class
    (*** helper information ***)
    _Type: TD3DQueryType;
    DataSize: DWORD;
    CreationCallStack: PWideChar;
  end;




(*
 * Interface IID's
 *)
type
  IID_IDirect3D9              = IDirect3D9;
  IID_IDirect3DDevice9        = IDirect3DDevice9;
  IID_IDirect3DResource9      = IDirect3DResource9;
  IID_IDirect3DBaseTexture9   = IDirect3DBaseTexture9;
  IID_IDirect3DTexture9       = IDirect3DTexture9;
  IID_IDirect3DCubeTexture9   = IDirect3DCubeTexture9;
  IID_IDirect3DVolumeTexture9 = IDirect3DVolumeTexture9;
  IID_IDirect3DVertexBuffer9  = IDirect3DVertexBuffer9;
  IID_IDirect3DIndexBuffer9   = IDirect3DIndexBuffer9;
  IID_IDirect3DSurface9       = IDirect3DSurface9;
  IID_IDirect3DVolume9        = IDirect3DVolume9;
  IID_IDirect3DSwapChain9     = IDirect3DSwapChain9;
  IID_IDirect3DVertexDeclaration9 = IDirect3DVertexDeclaration9;
  IID_IDirect3DVertexShader9  = IDirect3DVertexShader9;
  IID_IDirect3DPixelShader9   = IDirect3DPixelShader9;
  IID_IDirect3DStateBlock9    = IDirect3DStateBlock9;
  IID_IDirect3DQuery9         = IDirect3DQuery9;
const
  IID_HelperName : TGUID = '{E4A36723-FDFE-4b22-B146-3C04C07F4CC8}';



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;

(****************************************************************************
 *
 * Flags for IDirect3D9::CreateDevice's BehaviorFlags
 *
 ****************************************************************************)

  D3DCREATE_FPU_PRESERVE                  = $00000002;
  D3DCREATE_MULTITHREADED                 = $00000004;

  D3DCREATE_PUREDEVICE                    = $00000010;
  D3DCREATE_SOFTWARE_VERTEXPROCESSING     = $00000020;
  D3DCREATE_HARDWARE_VERTEXPROCESSING     = $00000040;
  D3DCREATE_MIXED_VERTEXPROCESSING        = $00000080;

  D3DCREATE_DISABLE_DRIVER_MANAGEMENT     = $00000100;
  D3DCREATE_ADAPTERGROUP_DEVICE           = $00000200;
  D3DCREATE_DISABLE_DRIVER_MANAGEMENT_EX  = $00000400;

  // this flag causes the d3d runtime not to alter the focus
  // window in any way. use with caution- the burden of supporting
  // focus management events (alt-tab, etc.) falls on the
  // application, and appropriate responses (switching display
  // mode, etc.) should be coded.
  d3dcreate_nowindowchanges               = $00000800;


(****************************************************************************
 *
 * Parameter for IDirect3D9::CreateDevice's Adapter argument
 *
 ****************************************************************************)

  D3DADAPTER_DEFAULT                      = 0;

(****************************************************************************
 *
 * Flags for IDirect3D9::EnumAdapters
 *
 ****************************************************************************)

  D3DENUM_WHQL_LEVEL                       = $00000002;

(****************************************************************************
 *
 * Maximum number of back-buffers supported in DX9
 *
 ****************************************************************************)

  D3DPRESENT_BACK_BUFFERS_MAX             = 3;

(****************************************************************************
 *
 * Flags for IDirect3DDevice9::SetGammaRamp
 *
 ****************************************************************************)

  D3DSGR_NO_CALIBRATION                  = $00000000;
  D3DSGR_CALIBRATE                       = $00000001;

(****************************************************************************
 *
 * Flags for IDirect3DDevice9::SetCursorPosition
 *
 ****************************************************************************)

  D3DCURSOR_IMMEDIATE_UPDATE             = $00000001;

(****************************************************************************
 *
 * Flags for IDirect3DSwapChain9::Present
 *
 ****************************************************************************)

  D3DPRESENT_DONOTWAIT                   = $00000001;
  D3DPRESENT_LINEAR_CONTENT              = $00000002;

(****************************************************************************
 *
 * Flags for DrawPrimitive/DrawIndexedPrimitive
 *   Also valid for Begin/BeginIndexed
 *   Also valid for VertexBuffer::CreateVertexBuffer
 ****************************************************************************)


(*
 *  DirectDraw error codes
 *)
  _FACD3D = $876;

//#define MAKE_D3DHRESULT( code )  MAKE_HRESULT( 1, _FACD3D, code )
function MAKE_D3DHRESULT(Code: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
//#define MAKE_D3DSTATUS( code )  MAKE_HRESULT( 0, _FACD3D, code )
function MAKE_D3DSTATUS(Code: DWord): DWord;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}

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;

  D3DERR_WRONGTEXTUREFORMAT               = HResult(MAKE_D3DHRESULT_R or 2072);
  D3DERR_UNSUPPORTEDCOLOROPERATION        = HResult(MAKE_D3DHRESULT_R or 2073);
  D3DERR_UNSUPPORTEDCOLORARG              = HResult(MAKE_D3DHRESULT_R or 2074);
  D3DERR_UNSUPPORTEDALPHAOPERATION        = HResult(MAKE_D3DHRESULT_R or 2075);
  D3DERR_UNSUPPORTEDALPHAARG              = HResult(MAKE_D3DHRESULT_R or 2076);
  D3DERR_TOOMANYOPERATIONS                = HResult(MAKE_D3DHRESULT_R or 2077);
  D3DERR_CONFLICTINGTEXTUREFILTER         = HResult(MAKE_D3DHRESULT_R or 2078);
  D3DERR_UNSUPPORTEDFACTORVALUE           = HResult(MAKE_D3DHRESULT_R or 2079);
  D3DERR_CONFLICTINGRENDERSTATE           = HResult(MAKE_D3DHRESULT_R or 2081);
  D3DERR_UNSUPPORTEDTEXTUREFILTER         = HResult(MAKE_D3DHRESULT_R or 2082);
  D3DERR_CONFLICTINGTEXTUREPALETTE        = HResult(MAKE_D3DHRESULT_R or 2086);
  D3DERR_DRIVERINTERNALERROR              = HResult(MAKE_D3DHRESULT_R or 2087);

  D3DERR_NOTFOUND                         = HResult(MAKE_D3DHRESULT_R or 2150);
  D3DERR_MOREDATA                         = HResult(MAKE_D3DHRESULT_R or 2151);
  D3DERR_DEVICELOST                       = HResult(MAKE_D3DHRESULT_R or 2152);
  D3DERR_DEVICENOTRESET                   = HResult(MAKE_D3DHRESULT_R or 2153);
  D3DERR_NOTAVAILABLE                     = HResult(MAKE_D3DHRESULT_R or 2154);
  D3DERR_OUTOFVIDEOMEMORY                 = HResult(MAKE_D3DHRESULT_R or 380);
  D3DERR_INVALIDDEVICE                    = HResult(MAKE_D3DHRESULT_R or 2155);
  D3DERR_INVALIDCALL                      = HResult(MAKE_D3DHRESULT_R or 2156);
  D3DERR_DRIVERINVALIDCALL                = HResult(MAKE_D3DHRESULT_R or 2157);
  D3DERR_WASSTILLDRAWING                  = HResult(MAKE_D3DHRESULT_R or 540);
  D3DOK_NOAUTOGEN                         = HResult(MAKE_D3DSTATUS_R or 2159);



(*
 * DLL Function for creating a Direct3D9 object. This object supports
 * enumeration and allows the creation of Direct3DDevice9 objects.
 * Pass the value of the constant D3D_SDK_VERSION to this function, so
 * that the run-time can validate that your application was compiled
 * against the right headers.
 *)


function Direct3D9Loaded: Boolean;
function LoadDirect3D9: Boolean;
function UnLoadDirect3D9: Boolean;

const
  Direct3D9dll = 'd3d9.dll';

// Due to the way Object Pascal handles functions resulting in 'native' interface
// pointer we should declare result not as interface but as usial pointer

{$IFDEF DIRECT3D9_DYNAMIC_LINK}
type
  TDirect3DCreate9 = function (SDKVersion: LongWord): Pointer; stdcall;

var
  _Direct3DCreate9: TDirect3DCreate9 = nil;

{$ELSE}
function _Direct3DCreate9(SDKVersion: LongWord): Pointer; stdcall;
{$ENDIF}

function Direct3DCreate9(SDKVersion: LongWord): IDirect3D9; stdcall;

(*
 * Stubs for graphics profiling.
 *)

function D3DPERF_BeginEvent(col: TD3DColor; wszName: PWideChar): Integer; stdcall; external Direct3D9dll;
function D3DPERF_EndEvent: Integer; stdcall; external Direct3D9dll;
procedure D3DPERF_SetMarker(col: TD3DColor; wszName: PWideChar); stdcall; external Direct3D9dll;
procedure D3DPERF_SetRegion(col: TD3DColor; wszName: PWideChar); stdcall; external Direct3D9dll;
function D3DPERF_QueryRepeatFrame: BOOL; stdcall; external Direct3D9dll;

procedure D3DPERF_SetOptions(dwOptions: DWORD); stdcall; external Direct3D9dll;
function D3DPERF_GetStatus: DWORD; stdcall; external Direct3D9dll;


//********************************************************************
// Introduced types for compatibility with non-Borland compliant translation
// by Ampaze (Tim Baumgarten) from http://www.crazyentertainment.net
type
  PD3DAdapter_Identifier9               = PD3DAdapterIdentifier9;
  PD3DDevice_Creation_Parameters        = PD3DDeviceCreationParameters;
  PD3DDevInfo_D3DVertexStats            = PD3DDevInfoD3DVertexStats;
  PD3DDevInfo_ResourceManager           = PD3DDevInfoResourceManager;
  PD3DDevInfo_VCache                    = PD3DDevInfoVCache;
  PD3DIndexBuffer_Desc                  = PD3DIndexBufferDesc;
  PD3DLocked_Box                        = PD3DLockedBox;
  PD3DLocked_Rect                       = PD3DLockedRect;
  PD3DPresent_Parameters                = PD3DPresentParameters;
  PD3DRaster_Status                     = PD3DRasterStatus;
  PD3DRectPatch_Info                    = PD3DRectPatchInfo;
  PD3DSurface_Desc                      = PD3DSurfaceDesc;
  PD3DTriPatch_Info                     = PD3DTriPatchInfo;
  PD3DVertexBuffer_Desc                 = PD3DVertexBufferDesc;
  PD3DVolume_Desc                       = PD3DVolumeDesc;

  TD3DAdapter_Identifier9               = TD3DAdapterIdentifier9;
  TD3DBackBuffer_Type                   = TD3DBackBufferType;
  TD3DCubeMap_Faces                     = TD3DCubeMapFaces;
  TD3DDevice_Creation_Parameters        = TD3DDeviceCreationParameters;
  TD3DDevInfo_D3DVertexStats            = TD3DDevInfoD3DVertexStats;
  TD3DDevInfo_ResourceManager           = TD3DDevInfoResourceManager;
  TD3DDevInfo_VCache                    = TD3DDevInfoVCache;
  TD3DIndexBuffer_Desc                  = TD3DIndexBufferDesc;
  TD3DLocked_Box                        = TD3DLockedBox;
  TD3DLocked_Rect                       = TD3DLockedRect;
  TD3DMultiSample_Type                  = TD3DMultiSampleType;
  TD3DPresent_Parameters                = TD3DPresentParameters;
  TD3DRaster_Status                     = TD3DRasterStatus;
  TD3DRectPatch_Info                    = TD3DRectPatchInfo;
  TD3DSampler_Texture_Type              = TD3DSamplerTextureType;
  TD3DShader_AddressMode_Type           = TD3DShaderAddressModeType;
  TD3DShader_Comparison                 = TD3DShaderComparison;
  TD3DShader_Instruction_Opcode_Type    = TD3DShaderInstructionOpcodeType;
  TD3DShader_MiscType_Offsets           = TD3DShaderMiscTypeOffsets;
  TD3DShader_Param_Register_Type        = TD3DShaderParamRegisterType;
  TD3DShader_Param_SRCMod_Type          = TD3DShaderParamSRCModType;
  TD3DSurface_Desc                      = TD3DSurfaceDesc;
  TD3DTriPatch_Info                     = TD3DTriPatchInfo;
  TD3DVertexBuffer_Desc                 = TD3DVertexBufferDesc;
  TD3DVolume_Desc                       = TD3DVolumeDesc;
  TD3DVS_AddressMode_Type               = TD3DVSAddressModeType;
  TD3DVS_RastOut_Offsets                = TD3DVSRastOutOffsets;


implementation

(*==========================================================================;
 *  File:       d3d9types.h
 *  Content:    Direct3D capabilities include file
 ***************************************************************************)

// #define D3DCOLOR_ARGB(a,r,g,b) \
//     ((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))
function D3DCOLOR_ARGB(a,r,g,b: DWord): TD3DColor;
begin
  Result := (a shl 24) or (r shl 16) or (g shl 8) or b;
end;

// #define D3DCOLOR_RGBA(r,g,b,a) D3DCOLOR_ARGB(a,r,g,b)
function D3DCOLOR_RGBA(r,g,b,a: DWord): TD3DColor;
begin
  Result := (a shl 24) or (r shl 16) or (g shl 8) or b;
end;

// #define D3DCOLOR_XRGB(r,g,b)   D3DCOLOR_ARGB(0xff,r,g,b)
function D3DCOLOR_XRGB(r,g,b: DWord): TD3DColor;
begin
  Result := DWORD($FF shl 24) or (r shl 16) or (g shl 8) or b;
end;

// #define D3DCOLOR_XYUV(y,u,v)   D3DCOLOR_ARGB(0xff,y,u,v)
function D3DCOLOR_XYUV(y,u,v: DWord): TD3DColor;
begin
  Result := DWORD($FF shl 24) or (y shl 16) or (u shl 8) or v;
end;

// #define D3DCOLOR_AYUV(a,y,u,v) D3DCOLOR_ARGB(a,y,u,v)
function D3DCOLOR_AYUV(a,y,u,v: DWord): TD3DColor;
begin
  Result := (a shl 24) or (y shl 16) or (u shl 8) or v;
end;

// #define D3DCOLOR_COLORVALUE(r,g,b,a) \
//     D3DCOLOR_RGBA((DWORD)((r)*255.f),(DWORD)((g)*255.f),(DWORD)((b)*255.f),(DWORD)((a)*255.f))
function D3DCOLOR_COLORVALUE(r,g,b,a: Single): TD3DColor;
begin
  Result := (round(a * 255) shl 24) or
    (round(r * 255) shl 16) or
    (round(g * 255) shl 8) or
    (round(b * 255));
end;

// #define D3DTS_WORLDMATRIX(index) (D3DTRANSFORMSTATETYPE)(index + 256)
function D3DTS_WORLDMATRIX(index: Byte): TD3DTransformStateType;
begin
  Result:= TD3DTransformStateType(index + 256);
end;

//#define D3DPS_VERSION(_Major,_Minor) (0xFFFF0000|((_Major)<<8)|(_Minor))
function D3DPS_VERSION(_Major, _Minor : Cardinal) : Cardinal;
begin
  Result:= $FFFF0000 or (_Major shl 8 ) or _Minor;
end;

//#define D3DVS_VERSION(_Major,_Minor) (0xFFFE0000|((_Major)<<8)|(_Minor))
function D3DVS_VERSION(_Major, _Minor : Cardinal) : Cardinal;
begin
  Result:= $FFFE0000 or (_Major shl 8 ) or _Minor;
end;

//#define D3DSHADER_VERSION_MAJOR(_Version) (((_Version)>>8)&0xFF)
function D3DSHADER_VERSION_MAJOR(_Version : Cardinal) : Cardinal;
begin
  Result:= (_Version shr 8 ) and $FF;
end;

//#define D3DSHADER_VERSION_MINOR(_Version) (((_Version)>>0)&0xFF)
function D3DSHADER_VERSION_MINOR(_Version : Cardinal) : Cardinal;
begin
  Result:= (_Version shr 0) and $FF;
end;

//#define D3DSHADER_COMMENT(_DWordSize) \
//    ((((_DWordSize)<<D3DSI_COMMENTSIZE_SHIFT)&D3DSI_COMMENTSIZE_MASK)|D3DSIO_COMMENT)
function D3DSHADER_COMMENT(_DWordSize: DWord) : DWord;
begin
  Result:= ((_DWordSize shl D3DSI_COMMENTSIZE_SHIFT) and D3DSI_COMMENTSIZE_MASK) or D3DSIO_COMMENT;
end;

//#define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE3(CoordIndex: DWord): DWord;
begin
  Result:= D3DFVF_TEXTUREFORMAT3 shl (CoordIndex * 2 + 16)
end;

//#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2)
function D3DFVF_TEXCOORDSIZE2(CoordIndex: DWord): DWord;
begin
  Result:= D3DFVF_TEXTUREFORMAT2;
end;

//#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE4(CoordIndex: DWord): DWord;
begin
  Result:= D3DFVF_TEXTUREFORMAT4 shl (CoordIndex * 2 + 16)
end;

//#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16))
function D3DFVF_TEXCOORDSIZE1(CoordIndex: DWord): DWord;
begin
  Result:= D3DFVF_TEXTUREFORMAT1 shl (CoordIndex * 2 + 16)
end;

//    #define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
//                ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |       \
//                ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
function MAKEFOURCC(ch0, ch1, ch2, ch3: Char): DWord;
begin
  Result:= Byte(ch0) or (Byte(ch1) shl 8) or (Byte(ch2) shl 16) or (Byte(ch3) shl 24 );
end;

(*==========================================================================;
 *  File:   d3d9.h
 *  Content:    Direct3D include file
 ****************************************************************************)

//#define MAKE_D3DHRESULT( code )  MAKE_HRESULT( 1, _FACD3D, code )
function MAKE_D3DHRESULT(Code: DWord): DWord;
begin
  Result:= DWord((1 shl 31) or (_FACD3D shl 16)) or Code;
end;

//#define MAKE_D3DSTATUS( code )  MAKE_HRESULT( 0, _FACD3D, code )
function MAKE_D3DSTATUS(Code: DWord): DWord;
begin
  Result:= DWord((0 shl 31) or (_FACD3D shl 16)) or Code;
end;

{$IFDEF DIRECT3D9_DYNAMIC_LINK}
var
  Direct3D9Lib: THandle = 0;

function Direct3D9Loaded: Boolean;
begin
  Result:= Direct3D9Lib <> 0;
end;

function UnLoadDirect3D9: Boolean;
begin
  Result:= True;
  if Direct3D9Loaded then
  begin
    Result:= FreeLibrary(Direct3D9Lib);
    _Direct3DCreate9:= nil;
    Direct3D9Lib:= 0;
  end;
end;

function LoadDirect3D9: Boolean;
const
  ProcName = 'Direct3DCreate9';
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; stdcall; external Direct3D9dll name 'Direct3DCreate9';
{$ENDIF}

function Direct3DCreate9(SDKVersion: LongWord): IDirect3D9;stdcall;
begin
{$IFDEF DIRECT3D9_DYNAMIC_LINK}
{$IFDEF DIRECT3D9_DYNAMIC_LINK_EXPLICIT}
  LoadDirect3D9;

{$ENDIF}
{$ENDIF}
  Result:= IDirect3D9(_Direct3DCreate9(SDKVersion));
  if Assigned(Result) then Result._Release; // Delphi autoincrement reference count
end;

{$IFDEF DIRECT3D9_DYNAMIC_LINK}
initialization
{$IFNDEF DIRECT3D9_DYNAMIC_LINK_EXPLICIT}
  LoadDirect3D9;
{$ENDIF}
finalization
  UnLoadDirect3D9;
{$ENDIF}
end.