direct3d.pas

3D GameStudio 的Delphi开发包

    0: (
      x: TD3DValue;
      y: TD3DValue;
      z: TD3DValue;
     );
    1: (
      dvX: TD3DValue;
      dvY: TD3DValue;
      dvZ: TD3DValue;
     );
  end {_D3DVECTOR};
  {$EXTERNALSYM _D3DVECTOR}
  D3DVECTOR = _D3DVECTOR;
  {$EXTERNALSYM D3DVECTOR}
  TD3DVector = _D3DVECTOR;



(******************************************************************
 *                                                                *
 *   D3DVec.inl                                                   *
 *                                                                *
 *   float-valued 3D vector class for Direct3D.                   *
 *                                                                *
 *   Copyright (c) 1996-1998 Microsoft Corp. All rights reserved. *
 *                                                                *
 ******************************************************************)

    // Addition and subtraction
  function VectorAdd(const v1, v2: TD3DVector): TD3DVector;
  function VectorSub(const v1, v2: TD3DVector): TD3DVector;
    // Scalar multiplication and division
  function VectorMulS(const v: TD3DVector; s: TD3DValue): TD3DVector;
  function VectorDivS(const v: TD3DVector; s: TD3DValue): TD3DVector;
    // Memberwise multiplication and division
  function VectorMul(const v1, v2: TD3DVector): TD3DVector;
  function VectorDiv(const v1, v2: TD3DVector): TD3DVector;
    // Vector dominance
  function VectorSmaller(v1, v2: TD3DVector): Boolean;
  function VectorSmallerEqual(v1, v2: TD3DVector): Boolean;
    // Bitwise equality
  function VectorEqual(v1, v2: TD3DVector): Boolean;
    // Length-related functions
  function VectorSquareMagnitude(v: TD3DVector): TD3DValue;
  function VectorMagnitude(v: TD3DVector): TD3DValue;
    // Returns vector with same direction and unit length
  function VectorNormalize(const v: TD3DVector): TD3DVector;
    // Return min/max component of the input vector
  function VectorMin(v: TD3DVector): TD3DValue;
  function VectorMax(v: TD3DVector): TD3DValue;
    // Return memberwise min/max of input vectors
  function VectorMinimize(const v1, v2: TD3DVector): TD3DVector;
  function VectorMaximize(const v1, v2: TD3DVector): TD3DVector;
    // Dot and cross product
  function VectorDotProduct(v1, v2: TD3DVector): TD3DValue;
  function VectorCrossProduct(const v1, v2: TD3DVector): TD3DVector;

type
(*
 * Vertex data types supported in an ExecuteBuffer.
 *)

(*
 * Homogeneous vertices
 *)

  PD3DHVertex = ^TD3DHVertex;
  _D3DHVERTEX = packed record
    dwFlags: DWORD;        (* Homogeneous clipping flags *)
    case Integer of
    0: (
      hx: TD3DValue;
      hy: TD3DValue;
      hz: TD3DValue;
     );
    1: (
      dvHX: TD3DValue;
      dvHY: TD3DValue;
      dvHZ: TD3DValue;
     );
  end;
  {$EXTERNALSYM _D3DHVERTEX}
  D3DHVERTEX = _D3DHVERTEX;
  {$EXTERNALSYM D3DHVERTEX}
  TD3DHVertex = _D3DHVERTEX;


(*
 * Transformed/lit vertices
 *)

  PD3DTLVertex = ^TD3DTLVertex;
  _D3DTLVERTEX = packed record
    case Integer of
    0: (
      sx: TD3DValue;             (* Screen coordinates *)
      sy: TD3DValue;
      sz: TD3DValue;
      rhw: TD3DValue;            (* Reciprocal of homogeneous w *)
      color: TD3DColor;          (* Vertex color *)
      specular: TD3DColor;       (* Specular component of vertex *)
      tu: TD3DValue;             (* Texture coordinates *)
      tv: TD3DValue;
     );
    1: (
      dvSX: TD3DValue;
      dvSY: TD3DValue;
      dvSZ: TD3DValue;
      dvRHW: TD3DValue;
      dcColor: TD3DColor;
      dcSpecular: TD3DColor;
      dvTU: TD3DValue;
      dvTV: TD3DValue;
     );
  end;
  {$EXTERNALSYM _D3DTLVERTEX}
  D3DTLVERTEX = _D3DTLVERTEX;
  {$EXTERNALSYM D3DTLVERTEX}
  TD3DTLVertex = _D3DTLVERTEX;

(*
 * Untransformed/lit vertices
 *)

  PD3DLVertex = ^TD3DLVertex;
  _D3DLVERTEX = packed record
    case Integer of
    0: (
      x: TD3DValue;             (* Homogeneous coordinates *)
      y: TD3DValue;
      z: TD3DValue;
      dwReserved: DWORD;
      color: TD3DColor;         (* Vertex color *)
      specular: TD3DColor;      (* Specular component of vertex *)
      tu: TD3DValue;            (* Texture coordinates *)
      tv: TD3DValue;
     );
    1: (
      dvX: TD3DValue;
      dvY: TD3DValue;
      dvZ: TD3DValue;
      UNIONFILLER1d: DWORD;
      dcColor: TD3DColor;
      dcSpecular: TD3DColor;
      dvTU: TD3DValue;
      dvTV: TD3DValue;
     );
  end;
  {$EXTERNALSYM _D3DLVERTEX}
  D3DLVERTEX = _D3DLVERTEX;
  {$EXTERNALSYM D3DLVERTEX}
  TD3DLVertex = _D3DLVERTEX;


(*
 * Untransformed/unlit vertices
 *)

  PD3DVertex = ^TD3DVertex;
  _D3DVERTEX = packed record
    case Integer of
    0: (
      x: TD3DValue;             (* Homogeneous coordinates *)
      y: TD3DValue;
      z: TD3DValue;
      nx: TD3DValue;            (* Normal *)
      ny: TD3DValue;
      nz: TD3DValue;
      tu: TD3DValue;            (* Texture coordinates *)
      tv: TD3DValue;
     );
    1: (
      dvX: TD3DValue;
      dvY: TD3DValue;
      dvZ: TD3DValue;
      dvNX: TD3DValue;
      dvNY: TD3DValue;
      dvNZ: TD3DValue;
      dvTU: TD3DValue;
      dvTV: TD3DValue;
     );
  end;
  {$EXTERNALSYM _D3DVERTEX}
  D3DVERTEX = _D3DVERTEX;
  {$EXTERNALSYM D3DVERTEX}
  TD3DVertex = _D3DVERTEX;

(*
 * Matrix, viewport, and tranformation structures and definitions.
 *)

  PD3DMatrix = ^TD3DMatrix;
  _D3DMATRIX = packed record
    case integer of
      0 : (_11, _12, _13, _14: TD3DValue;
           _21, _22, _23, _24: TD3DValue;
           _31, _32, _33, _34: TD3DValue;
           _41, _42, _43, _44: TD3DValue);
      1 : (m : array [0..3, 0..3] of TD3DValue);
  end {_D3DMATRIX};
  {$EXTERNALSYM _D3DMATRIX}
  D3DMATRIX = _D3DMATRIX;
  {$EXTERNALSYM D3DMATRIX}
  TD3DMatrix = _D3DMATRIX;

  PD3DViewport = ^TD3DViewport;
  _D3DVIEWPORT = packed record
    dwSize: DWORD;
    dwX: DWORD;
    dwY: DWORD;                (* Top left *)
    dwWidth: DWORD;
    dwHeight: DWORD;           (* Dimensions *)
    dvScaleX: TD3DValue;       (* Scale homogeneous to screen *)
    dvScaleY: TD3DValue;       (* Scale homogeneous to screen *)
    dvMaxX: TD3DValue;         (* Min/max homogeneous x coord *)
    dvMaxY: TD3DValue;         (* Min/max homogeneous y coord *)
    dvMinZ: TD3DValue;
    dvMaxZ: TD3DValue;         (* Min/max homogeneous z coord *)
  end {_D3DVIEWPORT};
  {$EXTERNALSYM _D3DVIEWPORT}
  D3DVIEWPORT = _D3DVIEWPORT;
  {$EXTERNALSYM D3DVIEWPORT}
  TD3DViewport = _D3DVIEWPORT;


{$IFDEF DIRECT3D_VERSION_5}
  PD3DViewport2 = ^TD3DViewport2;
  _D3DVIEWPORT2 = packed record
    dwSize: DWORD;
    dwX: DWORD;
    dwY: DWORD;                (* Viewport Top left *)
    dwWidth: DWORD;
    dwHeight: DWORD;           (* Viewport Dimensions *)
    dvClipX: TD3DValue;	       (* Top left of clip volume *)
    dvClipY: TD3DValue;
    dvClipWidth: TD3DValue;    (* Clip Volume Dimensions *)
    dvClipHeight: TD3DValue;
    dvMinZ: TD3DValue;         (* Min/max of clip Volume *)
    dvMaxZ: TD3DValue;
  end;
  {$EXTERNALSYM _D3DVIEWPORT2}
  D3DVIEWPORT2 = _D3DVIEWPORT2;
  {$EXTERNALSYM D3DVIEWPORT2}
  TD3DViewport2 = _D3DVIEWPORT2;
{$ENDIF} // DIRECT3D_VERSION_5


{$IFDEF DIRECT3D_VERSION_7}
  PD3DViewport7 = ^TD3DViewport7;
  _D3DVIEWPORT7 = packed record
    dwX: DWORD;
    dwY: DWORD;                (* Viewport Top left *)
    dwWidth: DWORD;
    dwHeight: DWORD;           (* Viewport Dimensions *)
    dvMinZ: TD3DValue;         (* Min/max of clip Volume *)
    dvMaxZ: TD3DValue;
  end;
  {$EXTERNALSYM _D3DVIEWPORT7}
  D3DVIEWPORT7 = _D3DVIEWPORT7;
  {$EXTERNALSYM D3DVIEWPORT7}
  TD3DViewport7 = _D3DVIEWPORT7;
{$ENDIF} // DIRECT3D_VERSION_7

(*
 * Values for clip fields.
 *)

{$IFDEF DIRECT3D_VERSION_7}

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

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

{$ENDIF} // DIRECT3D_VERSION_7

const
  D3DCLIP_LEFT                            = $00000001;
  {$EXTERNALSYM D3DCLIP_LEFT}
  D3DCLIP_RIGHT                           = $00000002;
  {$EXTERNALSYM D3DCLIP_RIGHT}
  D3DCLIP_TOP                             = $00000004;
  {$EXTERNALSYM D3DCLIP_TOP}
  D3DCLIP_BOTTOM                          = $00000008;
  {$EXTERNALSYM D3DCLIP_BOTTOM}
  D3DCLIP_FRONT                           = $00000010;
  {$EXTERNALSYM D3DCLIP_FRONT}
  D3DCLIP_BACK                            = $00000020;
  {$EXTERNALSYM D3DCLIP_BACK}
  D3DCLIP_GEN0                            = $00000040;
  {$EXTERNALSYM D3DCLIP_GEN0}
  D3DCLIP_GEN1                            = $00000080;
  {$EXTERNALSYM D3DCLIP_GEN1}
  D3DCLIP_GEN2                            = $00000100;
  {$EXTERNALSYM D3DCLIP_GEN2}
  D3DCLIP_GEN3                            = $00000200;
  {$EXTERNALSYM D3DCLIP_GEN3}
  D3DCLIP_GEN4                            = $00000400;
  {$EXTERNALSYM D3DCLIP_GEN4}
  D3DCLIP_GEN5                            = $00000800;
  {$EXTERNALSYM D3DCLIP_GEN5}

(*
 * Values for d3d status.
 *)

  D3DSTATUS_CLIPUNIONLEFT                 = D3DCLIP_LEFT;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONLEFT}
  D3DSTATUS_CLIPUNIONRIGHT                = D3DCLIP_RIGHT;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONRIGHT}
  D3DSTATUS_CLIPUNIONTOP                  = D3DCLIP_TOP;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONTOP}
  D3DSTATUS_CLIPUNIONBOTTOM               = D3DCLIP_BOTTOM;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONBOTTOM}
  D3DSTATUS_CLIPUNIONFRONT                = D3DCLIP_FRONT;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONFRONT}
  D3DSTATUS_CLIPUNIONBACK                 = D3DCLIP_BACK;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONBACK}
  D3DSTATUS_CLIPUNIONGEN0                 = D3DCLIP_GEN0;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONGEN0}
  D3DSTATUS_CLIPUNIONGEN1                 = D3DCLIP_GEN1;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONGEN1}
  D3DSTATUS_CLIPUNIONGEN2                 = D3DCLIP_GEN2;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONGEN2}
  D3DSTATUS_CLIPUNIONGEN3                 = D3DCLIP_GEN3;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONGEN3}
  D3DSTATUS_CLIPUNIONGEN4                 = D3DCLIP_GEN4;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONGEN4}
  D3DSTATUS_CLIPUNIONGEN5                 = D3DCLIP_GEN5;
  {$EXTERNALSYM D3DSTATUS_CLIPUNIONGEN5}

  D3DSTATUS_CLIPINTERSECTIONLEFT          = $00001000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONLEFT}
  D3DSTATUS_CLIPINTERSECTIONRIGHT         = $00002000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONRIGHT}
  D3DSTATUS_CLIPINTERSECTIONTOP           = $00004000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONTOP}
  D3DSTATUS_CLIPINTERSECTIONBOTTOM        = $00008000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONBOTTOM}
  D3DSTATUS_CLIPINTERSECTIONFRONT         = $00010000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONFRONT}
  D3DSTATUS_CLIPINTERSECTIONBACK          = $00020000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONBACK}
  D3DSTATUS_CLIPINTERSECTIONGEN0          = $00040000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONGEN0}
  D3DSTATUS_CLIPINTERSECTIONGEN1          = $00080000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONGEN1}
  D3DSTATUS_CLIPINTERSECTIONGEN2          = $00100000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONGEN2}
  D3DSTATUS_CLIPINTERSECTIONGEN3          = $00200000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONGEN3}
  D3DSTATUS_CLIPINTERSECTIONGEN4          = $00400000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONGEN4}
  D3DSTATUS_CLIPINTERSECTIONGEN5          = $00800000;
  {$EXTERNALSYM D3DSTATUS_CLIPINTERSECTIONGEN5}
  D3DSTATUS_ZNOTVISIBLE                   = $01000000;
  {$EXTERNALSYM D3DSTATUS_ZNOTVISIBLE}