directxgraphics.pas.svn-base

这是一段游戏修改工具的源代码.ring3功能由dephi开发,驱动是C开发.希望对大家有帮助

type TD3DTextureStageStateType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
       D3DTSS_COLOROP               =  1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTEXTUREOP - per-stage blending controls for color channels *)
       D3DTSS_COLORARG1             =  2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTA_* (texture arg) *)
       D3DTSS_COLORARG2             =  3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTA_* (texture arg) *)
       D3DTSS_ALPHAOP               =  4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTEXTUREOP - per-stage blending controls for alpha channel *)
       D3DTSS_ALPHAARG1             =  5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTA_* (texture arg) *)
       D3DTSS_ALPHAARG2             =  6{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTA_* (texture arg) *)
       D3DTSS_BUMPENVMAT00          =  7{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* float (bump mapping matrix) *)
       D3DTSS_BUMPENVMAT01          =  8{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* float (bump mapping matrix) *)
       D3DTSS_BUMPENVMAT10          =  9{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* float (bump mapping matrix) *)
       D3DTSS_BUMPENVMAT11          = 10{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* float (bump mapping matrix) *)
       D3DTSS_TEXCOORDINDEX         = 11{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* identifies which set of texture coordinates index this texture *)
       D3DTSS_ADDRESSU              = 13{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTEXTUREADDRESS for U coordinate *)
       D3DTSS_ADDRESSV              = 14{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTEXTUREADDRESS for V coordinate *)
       D3DTSS_BORDERCOLOR           = 15{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DCOLOR *)
       D3DTSS_MAGFILTER             = 16{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTEXTUREFILTER filter to use for magnification *)
       D3DTSS_MINFILTER             = 17{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTEXTUREFILTER filter to use for minification *)
       D3DTSS_MIPFILTER             = 18{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTEXTUREFILTER filter to use between mipmaps during minification *)
       D3DTSS_MIPMAPLODBIAS         = 19{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* float Mipmap LOD bias *)
       D3DTSS_MAXMIPLEVEL           = 20{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* DWORD 0..(n-1) LOD index of largest map to use (0 == largest) *)
       D3DTSS_MAXANISOTROPY         = 21{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* DWORD maximum anisotropy *)
       D3DTSS_BUMPENVLSCALE         = 22{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* float scale for bump map luminance *)
       D3DTSS_BUMPENVLOFFSET        = 23{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* float offset for bump map luminance *)
       D3DTSS_TEXTURETRANSFORMFLAGS = 24{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTEXTURETRANSFORMFLAGS controls texture transform *)
       D3DTSS_ADDRESSW              = 25{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTEXTUREADDRESS for W coordinate *)
       D3DTSS_COLORARG0             = 26{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTA_* third arg for triadic ops *)
       D3DTSS_ALPHAARG0             = 27{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTA_* third arg for triadic ops *)
       D3DTSS_RESULTARG             = 28{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}     (* D3DTA_* arg for result (CURRENT or TEMP) *)
       D3DTSS_FORCE_DWORD           = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};     (* force 32-bit size enum *)

const
// Values; used with D3DTSS_TEXCOORDINDEX; to specify that the vertex data(position
// and normal in the camera space) should be taken as texture coordinates
// Low 16 bits are used to specify texture coordinate index; to take the WRAP mode from
  D3DTSS_TCI_PASSTHRU                    = $00000000;
  D3DTSS_TCI_CAMERASPACENORMAL           = $00010000;
  D3DTSS_TCI_CAMERASPACEPOSITION         = $00020000;
  D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR = $00030000;

(* Enumerations for COLOROP and ALPHAOP texture blending operations set in
 * texture processing stage controls in D3DTSS. *)

type TD3DTextureOp = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}

       // Control
       D3DTOP_DISABLE                   = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}   // disables stage
       D3DTOP_SELECTARG1                = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}   // the default
       D3DTOP_SELECTARG2                = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}

       // Modulate
       D3DTOP_MODULATE                  = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}   // multiply args together
       D3DTOP_MODULATE2X                = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}   // multiply and  1 bit
       D3DTOP_MODULATE4X                = 6{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}   // multiply and  2 bits

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

       // Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha)
       D3DTOP_BLENDDIFFUSEALPHA         = 12{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}  // iterated alpha
       D3DTOP_BLENDTEXTUREALPHA         = 13{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}  // texture alpha
       D3DTOP_BLENDFACTORALPHA          = 14{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}  // alpha from D3DRS_TEXTUREFACTOR

       // Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha)
       D3DTOP_BLENDTEXTUREALPHAPM       = 15{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}  // texture alpha
       D3DTOP_BLENDCURRENTALPHA         = 16{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}  // by alpha of current color

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

       // Bump mapping
       D3DTOP_BUMPENVMAP                = 22{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}  // per pixel env map perturbation
       D3DTOP_BUMPENVMAPLUMINANCE       = 23{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}  // 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{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}

       // Triadic ops
       D3DTOP_MULTIPLYADD               = 25{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}  // Arg0 + Arg1*Arg2
       D3DTOP_LERP                      = 26{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}  // (Arg0)*Arg1 + (1-Arg0)*Arg2

       D3DTOP_FORCE_DWORD               = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};

const
(* Values for COLORARG0;1;2; ALPHAARG0;1;2; and RESULTARG texture blending
 * operations set in texture processing stage controls in D3DRENDERSTATE. *)
  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_COMPLEMENT        = $00000010;  // take 1.0 - x (read modifier)
  D3DTA_ALPHAREPLICATE    = $00000020;  // replicate alpha to color components (read modifier)


// Values for D3DTSS_***FILTER texture stage states

type TD3DTextureFilterType = {$IFNDEF NOENUMS}({$ELSE}LongWord;{$ENDIF}
{$IFDEF NOENUMS}const{$ENDIF}
       D3DTEXF_NONE            = 0{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}    // filtering disabled (valid for mip filter only)
       D3DTEXF_POINT           = 1{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}    // nearest
       D3DTEXF_LINEAR          = 2{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}    // linear interpolation
       D3DTEXF_ANISOTROPIC     = 3{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}    // anisotropic
       D3DTEXF_FLATCUBIC       = 4{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}    // cubic
       D3DTEXF_GAUSSIANCUBIC   = 5{$IFNDEF NOENUMS},{$ELSE};{$ENDIF}    // different cubic kernel
       D3DTEXF_FORCE_DWORD     = $7fffffff{$IFNDEF NOENUMS}){$ENDIF};   // force 32-bit size enum

const

(* Bits for Flags in ProcessVertices call *)
  D3DPV_DONOTCOPYDATA  = 1 shl 0;

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

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

  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_RESERVED2        = $E000;  // 4 reserved bits

//---------------------------------------------------------------------
// Vertex Shaders
//

(*

Vertex Shader Declaration

The declaration portion of a vertex shader defines the static external
interface of the shader.  The information in the declaration includes:

- Assignments of vertex shader input registers to data streams.  These
assignments bind a specific vertex register to a single component within a
vertex stream.  A vertex stream element is identified by a byte offset
within the stream and a type.  The type specifies the arithmetic data type
plus the dimensionality (1; 2; 3; or 4 values).  Stream data which is
less than 4 values are always expanded out to 4 values with zero or more
0.F values and one 1.F value.

- Assignment of vertex shader input registers to implicit data from the
primitive tessellator.  This controls the loading of vertex data which is
not loaded from a stream; but rather is generated during primitive
tessellation prior to the vertex shader.

- Loading data into the constant memory at the time a shader is set as the
current shader.  Each token specifies values for one or more contiguous 4
DWORD constant registers.  This allows the shader to update an arbitrary
subset of the constant memory; overwriting the device state (which
contains the current values of the constant memory).  Note that these
values can be subsequently overwritten (between DrawPrimitive calls)
during the time a shader is bound to a device via the
SetVertexShaderConstant method.


Declaration arrays are single-dimensional arrays of DWORDs composed of
multiple tokens each of which is one or more DWORDs.  The single-DWORD
token value = $FFFFFFFF is a special token used to indicate the end of the
declaration array.  The single DWORD token value = $00000000 is a NOP token
with is ignored during the declaration parsing.  Note that = $00000000 is a
valid value for DWORDs following the first DWORD for multiple word tokens.

[31:29] TokenType
    = $0 - NOP (requires all DWORD bits to be zero)
    = $1 - stream selector
    = $2 - stream data definition (map to vertex input memory)
    = $3 - vertex input memory from tessellator
    = $4 - constant memory from shader
    = $5 - extension
    = $6 - reserved
    = $7 - end-of-array (requires all DWORD bits to be 1)

NOP Token (single DWORD token)
    [31:29] = $0
    [28:00] = $0

Stream Selector (single DWORD token)
    [31:29] = $1
    [28]    indicates whether this is a tessellator stream
    [27:04] = $0
    [03:00] stream selector (0..15)

Stream Data Definition (single DWORD token)
    Vertex Input Register Load
      [31:29] = $2
      [28]    = $0
      [27:20] = $0
      [19:16] type (dimensionality and data type)
      [15:04] = $0
      [03:00] vertex register address (0..15)
    Data Skip (no register load)
      [31:29] = $2
      [28]    = $1
      [27:20] = $0
      [19:16] count of DWORDS to skip over (0..15)
      [15:00] = $0
    Vertex Input Memory from Tessellator Data (single DWORD token)
      [31:29] = $3
      [28]    indicates whether data is normals or u/v
      [27:24] = $0