delphi10.2的directX11的着色器单元D3D11Shader.pas

最新推荐文章于 2024-06-15 23:01:06 发布
最新推荐文章于 2024-06-15 23:01:06 发布
阅读量932 收藏
点赞数
分类专栏： delphi的RTL中的单元文件 文章标签： delphi Directcompute 异构计算 DX11 着色器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vbfgm/article/details/83338292
版权

Winapi.D3D11Shader.pas这个单元用于DirectCompute 异构计算，是把里面的英文注释翻译了一下。

{*******************************************************}
{                                                       }
{                Delphi Runtime Library                 }
{                                                       }
{ Files: D3D11Shader.h                                  }
{         Copyright (C) Microsoft Corporation.          }
{         All Rights Reserved.                          }
{                                                       }
{       Translator: Embarcadero Technologies, Inc.      }
{ Copyright(c) 1995-2017 Embarcadero Technologies, Inc. }
{              All rights reserved                      }
{                                                       }
{*******************************************************}
unit Winapi.D3D11Shader;

{$ALIGN ON}
{$MINENUMSIZE 4}
{$WEAKPACKAGEUNIT}

interface

//
//
//  文件:       D3D11Shader.h
//  内容:    D3D11 着色器类型和API
//
//

uses
  Winapi.D3DCommon,
  Winapi.Windows;

type
  D3D11_SHADER_VERSION_TYPE = (
    D3D11_SHVER_PIXEL_SHADER    = 0,
  {$EXTERNALSYM D3D11_SHVER_PIXEL_SHADER}
    D3D11_SHVER_VERTEX_SHADER   = 1,
  {$EXTERNALSYM D3D11_SHVER_VERTEX_SHADER}
    D3D11_SHVER_GEOMETRY_SHADER = 2,
  {$EXTERNALSYM D3D11_SHVER_GEOMETRY_SHADER}
    // D3D11 Shaders
    D3D11_SHVER_HULL_SHADER     = 3,
  {$EXTERNALSYM D3D11_SHVER_HULL_SHADER}
    D3D11_SHVER_DOMAIN_SHADER   = 4,
  {$EXTERNALSYM D3D11_SHVER_DOMAIN_SHADER}
    D3D11_SHVER_COMPUTE_SHADER  = 5);
  {$EXTERNALSYM D3D11_SHVER_COMPUTE_SHADER}
  {$EXTERNALSYM D3D11_SHADER_VERSION_TYPE}

    TD3D11ShaderVersionType = D3D11_SHADER_VERSION_TYPE;
  {$EXTERNALSYM D3D11_SHADER_VERSION_TYPE}

// Parameter flags. 参数标志。
type

  D3D_RESOURCE_RETURN_TYPE = record end;
  {$EXTERNALSYM D3D_RESOURCE_RETURN_TYPE}

  D3D11_CBUFFER_TYPE = record end;
  {$EXTERNALSYM D3D11_CBUFFER_TYPE}

  _D3D11_SIGNATURE_PARAMETER_DESC = record
    SemanticName:     LPCSTR;         // 语义的名称
    SemanticIndex:    UINT;           // 语义索引
    _Register:        UINT;           // 成员变量数
    SystemValueType:  D3D_NAME;       // 一个预定义的系统值，或D3D_NAME_UNDEFINED(如果不适用)
    ComponentType:    D3D_REGISTER_COMPONENT_TYPE;  // 标量类型(如uint、float等)
    Mask:             BYTE;           // 掩码用于指示使用寄存器的哪些组件
                                      // (D3D10_COMPONENT_MASK值的组合)
    ReadWriteMask:    BYTE;           // 掩码用于指示给定组件是从不写入(如果这是输出信号)，
                                      // 还是始终读取(如果这是输入信号)。
                                      // (D3D10_COMPONENT_MASK值的组合)
                                      //
    Stream:           UINT;           // 流索引
    MinPrecision:     D3D_MIN_PRECISION;   // 最小期望插值精度
  end;
  {$EXTERNALSYM _D3D11_SIGNATURE_PARAMETER_DESC}
  D3D11_SIGNATURE_PARAMETER_DESC = _D3D11_SIGNATURE_PARAMETER_DESC;
  {$EXTERNALSYM D3D11_SIGNATURE_PARAMETER_DESC}
  TD3D11SignatureParameterDesc = D3D11_SIGNATURE_PARAMETER_DESC;


  _D3D11_SHADER_BUFFER_DESC = record
    Name: LPCSTR;            // 常量缓冲区的名称
    _Type: D3D_CBUFFER_TYPE;  // 指示缓冲区内容的类型
    Variables: UINT;         // 成员变量数
    Size: UINT;              // CB大小(字节)
    uFlags: UINT;            // 缓冲区描述标志
  end;
  {$EXTERNALSYM _D3D11_SHADER_BUFFER_DESC}
  D3D11_SHADER_BUFFER_DESC = _D3D11_SHADER_BUFFER_DESC;
  {$EXTERNALSYM D3D11_SHADER_BUFFER_DESC}
  PD3D11ShaderBufferDesc = ^D3D11_SHADER_BUFFER_DESC;
  TD3D11ShaderBufferDesc = D3D11_SHADER_BUFFER_DESC;

  _D3D11_SHADER_VARIABLE_DESC = record
    Name: LPCSTR;       // 变量名
    StartOffset: UINT;  // 固定缓冲区的后备存储器中的偏移量
    Size: UINT;         // 变量的大小(以字节为单位)
    uFlags: UINT;       // 变量的标志
    DefaultValue: LPVOID; // 原始指针默认值
    StartTexture: UINT;   // 第一个纹理索引 (或者-1，如果没有使用纹理)
    TextureSize: UINT;    // 可能使用的纹理槽数。
    StartSampler: UINT;   // 第一个采样器索引 (或者-1，如果没有使用纹理)
    SamplerSize: UINT;    // 可能使用的采样器槽数。
  end;
  {$EXTERNALSYM _D3D11_SHADER_VARIABLE_DESC}
  D3D11_SHADER_VARIABLE_DESC = _D3D11_SHADER_VARIABLE_DESC;
  {$EXTERNALSYM D3D11_SHADER_VARIABLE_DESC}
  TD3D11ShaderVariableDesc = D3D11_SHADER_VARIABLE_DESC;

  _D3D11_SHADER_TYPE_DESC = record
    _Class: D3D_SHADER_VARIABLE_CLASS;  // 变量类(例如对象、矩阵等)
    _Type: D3D_SHADER_VARIABLE_TYPE;    // 变量类型(如浮点、取样器等)
    Rows: UINT;                         // 行数(对矩阵；其他为1；如果不适用，为0) (for matrices, 1 for other numeric, 0 if not applicable)
    Columns: UINT;                      // 列数 (对向量和矩阵；其他为1；如果不适用，为0)
    Elements: UINT;                     // 元素数 (如果不是数组则为0)
    Members: UINT;                      // 成员数 (如果不是一个结构则为0)
    Offset: UINT;                       // 从结构开始处的的偏移量(如果不是结构成员则为0)
    Name: LPCSTR;                       // 类型名，可以为NULL
  end;
  {$EXTERNALSYM _D3D11_SHADER_TYPE_DESC}
  D3D11_SHADER_TYPE_DESC = _D3D11_SHADER_TYPE_DESC;
  {$EXTERNALSYM D3D11_SHADER_TYPE_DESC}
  PD3D11ShaderTypeDesc = ^D3D11_SHADER_TYPE_DESC;
  TD3D11ShaderTypeDesc = D3D11_SHADER_TYPE_DESC;

  D3D11_TESSELLATOR_DOMAIN = record end;

  D3D11_TESSELLATOR_PARTITIONING = record end;

  D3D11_TESSELLATOR_OUTPUT_PRIMITIVE = record end;

  _D3D11_SHADER_DESC = record
    Version:                UINT;                        // 着色器版本
    Creator:                LPCSTR;                        // 创造者的字符串
    Flags:                  UINT;                        // 着色器编译/解析标志

    ConstantBuffers:        UINT;                        // 常量缓冲器数量
    BoundResources:         UINT;                        // 绑定资源数量
    InputParameters:        UINT;                        // 输入信号中的参数数量
    OutputParameters:       UINT;                        // 输出信号中的参数数量

    InstructionCount:       UINT;                        // 发出指令数量
    TempRegisterCount:      UINT;                        // 使用的临时寄存器的数量
    TempArrayCount:         UINT;                        // 使用的临时数组的数量
    DefCount:               UINT;                        // 常量定义的数量
    DclCount:               UINT;                        // 声明数量(输入+输出)
    TextureNormalInstructions:   UINT;                        // 非分类纹理指令的数量
    TextureLoadInstructions:     UINT;                        // Number of texture load instructions
    TextureCompInstructions:     UINT;                        // 纹理加载指令的数量
    TextureBiasInstructions:     UINT;                        // 纹理偏置指令的数量
    TextureGradientInstructions: UINT;                        // 纹理渐变指令的数量
    FloatInstructionCount:       UINT;                        // 使用的浮点算术指令数量
    IntInstructionCount:         UINT;                        // 使用的有符号整数算术指令的数目
    UintInstructionCount:        UINT;                        // 使用的无符号整数算术指令数
    StaticFlowControlCount:      UINT;                        // 使用的静态流控制指令的数量
    DynamicFlowControlCount:     UINT;                        //使用的动态流控制指令的数量
    MacroInstructionCount:       UINT;                        // 使用的宏指令的数量
    ArrayInstructionCount:       UINT;                        // 使用的数组指令数
    CutInstructionCount:         UINT;                        // 使用的剪切(CUT)指令的数量
    EmitInstructionCount:        UINT;                        // 发出指令的数量
    GSOutputTopology:            D3D_PRIMITIVE_TOPOLOGY;      // Geometry shader output topology几何着色器输出拓扑
    GSMaxOutputVertexCount:      UINT;                        // 几何着色器最大的输出顶点计数
    InputPrimitive:              D3D_PRIMITIVE;               // GS/HS input primitive   GS / HS输入图元
    PatchConstantParameters:     UINT;                        // 补丁常数信号中的参数数量
    cGSInstanceCount:            UINT;                        // 几何着色器实例的数量
    cControlPoints:              UINT;                        //HS->DS阶段中控制点数量
    HSOutputPrimitive:           D3D_TESSELLATOR_OUTPUT_PRIMITIVE; // Primitive output by the tessellator  由镶嵌器输出的图元
    HSPartitioning:              D3D_TESSELLATOR_PARTITIONING;     // 镶嵌器的划分模式
    TessellatorDomain:           D3D_TESSELLATOR_DOMAIN;           // 镶嵌器域 (四、三、等值线)
    // 指令数
    cBarrierInstructions:        UINT;                        // Number of barrier instructions in a compute shader 计算着色器中的障碍指令数
    cInterlockedInstructions:    UINT;                        // Number of interlocked instructions 互锁指令的数量
    cTextureStoreInstructions:   UINT;                        // 纹理写入数
  end;
  {$EXTERNALSYM _D3D11_SHADER_DESC}
  D3D11_SHADER_DESC = _D3D11_SHADER_DESC;
  {$EXTERNALSYM D3D11_SHADER_DESC}
  TD3D11ShaderDesc = D3D11_SHADER_DESC;

  _D3D11_SHADER_INPUT_BIND_DESC = record
    Name:       LPCSTR;                    // 资源名称
    _Type:      D3D_SHADER_INPUT_TYPE;     // 资源类型 (例如纹理、cbuffer等。)
    BindPoint:  UINT;                      // 绑定点开始
    BindCount:  UINT;                      // 连续绑定点的数量(用于数组)

    uFlags:     UINT;                      // 输入绑定的标志
    ReturnType: D3D_RESOURCE_RETURN_TYPE;  // 返回类型(若纹理)
    Dimension:  D3D_SRV_DIMENSION;         // 维度(如果纹理)
    NumSamples: UINT;                      // 样本数量(如果不是MS纹理，则为0)
  end;
  {$EXTERNALSYM _D3D11_SHADER_INPUT_BIND_DESC}
  D3D11_SHADER_INPUT_BIND_DESC = _D3D11_SHADER_INPUT_BIND_DESC;
  {$EXTERNALSYM D3D11_SHADER_INPUT_BIND_DESC}
  TD3D11ShaderInputBindDesc = D3D11_SHADER_INPUT_BIND_DESC;

const
  D3D_SHADER_REQUIRES_DOUBLES                         = $00000001;
  {$EXTERNALSYM D3D_SHADER_REQUIRES_DOUBLES}
  D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL             = $00000002;
  {$EXTERNALSYM D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL}
  D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE             = $00000004;
  {$EXTERNALSYM D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE}
  D3D_SHADER_REQUIRES_64_UAVS                         = $00000008;
  {$EXTERNALSYM D3D_SHADER_REQUIRES_64_UAVS}
  D3D_SHADER_REQUIRES_MINIMUM_PRECISION               = $00000010;
  {$EXTERNALSYM D3D_SHADER_REQUIRES_MINIMUM_PRECISION}
  D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS          = $00000020;
  {$EXTERNALSYM D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS}
  D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS          = $00000040;
  {$EXTERNALSYM D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS}
  D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING    = $00000080;
  {$EXTERNALSYM D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING}
  D3D_SHADER_REQUIRES_TILED_RESOURCES                 = $00000100;
  {$EXTERNALSYM D3D_SHADER_REQUIRES_TILED_RESOURCES}


type
  _D3D11_LIBRARY_DESC = record
    Creator: LPCSTR;    // 库创始人的名字。
    Flags: UINT;        // 编译标志.
    FunctionCount: UINT;// 从库导出的函数的数量。
  end;
  {$EXTERNALSYM _D3D11_LIBRARY_DESC}
  D3D11_LIBRARY_DESC = _D3D11_LIBRARY_DESC;
  {$EXTERNALSYM D3D11_LIBRARY_DESC}
  TD3D11LibraryDesc = D3D11_LIBRARY_DESC;
  PD3D11LibraryDesc = ^TD3D11LibraryDesc;

  _D3D11_FUNCTION_DESC = record
    Version: UINT;                // 着色器版本
    Creator: LPCSTR;              // 创建者的字符串
    Flags: UINT;                  // 着色器编译/解析标志

    ConstantBuffers: UINT;        // 常量缓冲器数量
    BoundResources: UINT;         // 绑定资源数量

    InstructionCount: UINT;       // 发出指令数量
    TempRegisterCount: UINT;      // 使用的临时寄存器的数量
    TempArrayCount: UINT;         // 使用的临时数组的数量
    DefCount: UINT;               // 常量定义数量
    DclCount: UINT;               // 声明数量(输入+输出)
    TextureNormalInstructions: UINT;    // 非分类纹理指令的数量
    TextureLoadInstructions: UINT;      // 纹理加载指令的数量
    TextureCompInstructions: UINT;      // 纹理比较指令的数目
    TextureBiasInstructions: UINT;      // Number of texture bias instructions 纹理偏置指令的数量
    TextureGradientInstructions: UINT;  // 纹理渐变指令的数量
    FloatInstructionCount: UINT;        // 使用的浮点算术指令数
    IntInstructionCount: UINT;          // 使用的有符号整数算术指令的数目
    UintInstructionCount: UINT;         // 使用的无符号整数算术指令数
    StaticFlowControlCount: UINT;       // 使用的静态流控制指令的数量
    DynamicFlowControlCount: UINT;      // 使用的动态流控制指令的数量
    MacroInstructionCount: UINT;        // 使用的宏指令的数量
    ArrayInstructionCount: UINT;        // 使用的数组指令数
    MovInstructionCount: UINT;          // 使用了mov指令数量
    MovcInstructionCount: UINT;         // 使用的movc指令的数量
    ConversionInstructionCount: UINT;   // 使用的类型转换指令的数量
    BitwiseInstructionCount: UINT;      // 使用的按位运算指令的数量
    MinFeatureLevel: D3D_FEATURE_LEVEL; // Min target of the function byte code 函数字节码的最小目标
    RequiredFeatureFlags: UINT64;       // 所需的特性标志

    Name: LPCSTR;                       // 函数名
    FunctionParameterCount: Integer;    // 函数信号中的逻辑参数数(不包括返回值)
    HasReturn: BOOL;                    // 为TRUE——表明函数返回一个值；为false——表明它是一个子例程。
    Has10Level9VertexShader: BOOL;      // 为TRUE—— 有一个 10L9 VS（顶点着色器） blob
    Has10Level9PixelShader: BOOL;       // 为TRUE—— 有一个 10L9 PS（像素着色器） blob
  end;
  {$EXTERNALSYM _D3D11_FUNCTION_DESC}
  D3D11_FUNCTION_DESC = _D3D11_FUNCTION_DESC;
  {$EXTERNALSYM D3D11_FUNCTION_DESC}
  TD3D11FunctionDesc = D3D11_FUNCTION_DESC;
  PD3D11FunctionDesc = ^TD3D11FunctionDesc;

  _D3D11_PARAMETER_DESC = record
    Name: LPCSTR;                               // 参数名称。
    SemanticName: LPCSTR;                       // 参数语义名称(+索引)。
    _Type: D3D_SHADER_VARIABLE_TYPE;            // 元素类型。
    _Class: D3D_SHADER_VARIABLE_CLASS;          //  标量/向量/矩阵。
    Rows: UINT;                                 // Rows是矩阵参数。
    Columns: UINT;                              // 矩阵中的分量或列。
    InterpolationMode: D3D_INTERPOLATION_MODE;  // 插值模式。
    Flags: D3D_PARAMETER_FLAGS;                 // 参数修改器。

    FirstInRegister: UINT;      // 这个参数的第一个输入寄存器。
    FirstInComponent: UINT;     // 这个参数的第一个输入寄存器组件。
    FirstOutRegister: UINT;     // 这个参数的第一个输出寄存器。
    FirstOutComponent: UINT;    // 这个参数的第一个输出寄存器组件。
  end;
  {$EXTERNALSYM _D3D11_PARAMETER_DESC}
  D3D11_PARAMETER_DESC = _D3D11_PARAMETER_DESC;
  {$EXTERNALSYM D3D11_PARAMETER_DESC}
  TD3D11ParameterDesc = D3D11_PARAMETER_DESC;
  PD3D11ParameterDesc = ^TD3D11ParameterDesc;


//
// Interfaces 
//

type

  ID3D11ShaderReflectionType = interface;
  PD3D11SHADERREFLECTIONTYPE = ^ID3D11ShaderReflectionType;
  LPD3D11SHADERREFLECTIONTYPE = ^ID3D11ShaderReflectionType;
  {$EXTERNALSYM LPD3D11SHADERREFLECTIONTYPE}

  ID3D11ShaderReflectionVariable = interface;
  PID3D11ShaderReflectionVariable = ^ID3D11ShaderReflectionVariable;
  LPD3D11SHADERREFLECTIONVARIABLE = ^ID3D11ShaderReflectionVariable;
  {$EXTERNALSYM LPD3D11SHADERREFLECTIONVARIABLE}

  ID3D11ShaderReflectionConstantBuffer = interface;
  PID3D11ShaderReflectionConstantBuffer = ^ID3D11ShaderReflectionConstantBuffer;
  LPD3D11SHADERREFLECTIONCONSTANTBUFFER = ^ID3D11ShaderReflectionConstantBuffer;
  {$EXTERNALSYM LPD3D11SHADERREFLECTIONCONSTANTBUFFER}

  ID3D11ShaderReflection = interface;
  PIDD3D11SHADERREFLECTION = ^ID3D11ShaderReflection;
  LPD3D11SHADERREFLECTION = ^ID3D11ShaderReflection;
  {$EXTERNALSYM LPD3D11SHADERREFLECTION}

  ID3D11FunctionReflection = interface;
  LPD3D11FUNCTIONREFLECTION = ^ID3D11FunctionReflection;
  PID3D11FUNCTIONREFLECTION = ^ID3D11FunctionReflection;
  {$EXTERNALSYM LPD3D11FUNCTIONREFLECTION}

  ID3D11FunctionParameterReflection = interface;
  LPD3D11FUNCTIONPARAMETERREFLECTION = ^ID3D11FunctionParameterReflection;
  PID3D11FUNCTIONPARAMETERREFLECTION = ^ID3D11FunctionParameterReflection;
  {$EXTERNALSYM LPD3D11FUNCTIONPARAMETERREFLECTION}


  PID3D11ShaderReflectionType = ^ID3D11ShaderReflectionType;

  {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(ID3D11ShaderReflectionType);'}
  {$EXTERNALSYM ID3D11ShaderReflectionType}
  ID3D11ShaderReflectionType = interface
  ['{6E6FFA6A-9BAE-4613-A51E-91652D508C21}']
    function GetDesc((*_Out_*) out pDesc: D3D11_SHADER_TYPE_DESC): HRESULT; stdcall;
    function GetMemberTypeByIndex((*_In_*) Index: UINT): ID3D11ShaderReflectionType; stdcall;
    function GetMemberTypeByName((*_In_*) Name: LPCSTR): ID3D11ShaderReflectionType; stdcall;
    function GetMemberTypeName((*_In_*) Index: UINT): LPCSTR; stdcall;
    function IsEqual((*_In_*) pType: ID3D11ShaderReflectionType): HRESULT; stdcall;
    function GetSubType: ID3D11ShaderReflectionType; stdcall;
    function GetBaseClass: ID3D11ShaderReflectionType; stdcall;
    function GetNumInterfaces: UINT; stdcall;
    function GetInterfaceByIndex((*_In_*) uIndex: UINT): ID3D11ShaderReflectionType; stdcall;
    function IsOfType((*_In_*) pType: ID3D11ShaderReflectionType): HRESULT; stdcall;
    function ImplementsInterface((*_In_*) pBase: ID3D11ShaderReflectionType): HRESULT; stdcall;
  end;
  {$EXTERNALSYM IID_ID3D11ShaderReflectionType}
  IID_ID3D11ShaderReflectionType = ID3D11ShaderReflectionType;

  {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(ID3D11ShaderReflectionVariable);'}
  ID3D11ShaderReflectionVariable = interface
  ['{51F23923-F3E5-4BD1-91CB-606177D8DB4C}']

    function GetDesc((*_Out_*) out pDesc: D3D11_SHADER_VARIABLE_DESC): HRESULT; stdcall;

    function GetType: ID3D11ShaderReflectionType; stdcall;
    function GetBuffer: ID3D11ShaderReflectionConstantBuffer; stdcall;

    function GetInterfaceSlot((*_In_*) uArrayIndex: UINT): UINT; stdcall;
  end;
  {$EXTERNALSYM ID3D11ShaderReflectionVariable}
  IID_ID3D11ShaderReflectionVariable = ID3D11ShaderReflectionVariable;
  {$EXTERNALSYM IID_ID3D11ShaderReflectionVariable}
  TID3D11ShaderReflectionVariable = ID3D11ShaderReflectionVariable;


  {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(ID3D11ShaderReflectionConstantBuffer);'}
  ID3D11ShaderReflectionConstantBuffer = interface
  ['{EB62D63D-93DD-4318-8AE8-C6F83AD371B8}']
    function GetDesc(out pDesc: D3D11_SHADER_BUFFER_DESC): HRESULT; stdcall;

    function GetVariableByIndex((*_In_*) Index: UINT): ID3D11ShaderReflectionVariable; stdcall;
    function GetVariableByName((*_In_*) Name: LPCSTR): ID3D11ShaderReflectionVariable; stdcall;
  end;
  {$EXTERNALSYM ID3D11ShaderReflectionConstantBuffer}
  IID_ID3D11ShaderReflectionConstantBuffer = ID3D11ShaderReflectionConstantBuffer;
  {$EXTERNALSYM IID_ID3D11ShaderReflectionConstantBuffer}
  TID3D11ShaderReflectionConstantBuffer = ID3D11ShaderReflectionConstantBuffer;


// 如果反射API发生变化，ID3D11ShaderReflection IID可能会从SDK版本更改为SDK版本。
// 这可以防止来自旧二进制工作的新API使用新代码
// 使用新头文件重新编译将获得新的ID。
//

  {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(ID3D11ShaderReflection);'}
  ID3D11ShaderReflection = interface(IUnknown)
  ['{0A233719-3960-4578-9D7C-203B8B1D9CC1}']
    function GetDesc((*_Out_*) out pDesc: D3D11_SHADER_DESC): HRESULT; stdcall;

    function GetConstantBufferByIndex((*_In_*) Index: UINT): ID3D11ShaderReflectionConstantBuffer; stdcall;
    function GetConstantBufferByName((*_In_*) Name: LPCSTR): ID3D11ShaderReflectionConstantBuffer; stdcall;

    function GetResourceBindingDesc((*_In_*) ResourceIndex: UINT;
                                    (*_Out_*) out pDesc: D3D11_SHADER_INPUT_BIND_DESC): HRESULT; stdcall;

    function GetInputParameterDesc((*_In_*) ParameterIndex: UINT;
                                   (*_Out_*) out pDesc: D3D11_SIGNATURE_PARAMETER_DESC): HRESULT; stdcall;
    function GetOutputParameterDesc((*_In_*) ParameterIndex: UINT;
                                    (*_Out_*) out pDesc: D3D11_SIGNATURE_PARAMETER_DESC): HRESULT; stdcall;
    function GetPatchConstantParameterDesc((*_In_*) ParameterIndex: UINT;
                                           (*_Out_*) out pDesc: D3D11_SIGNATURE_PARAMETER_DESC): HRESULT; stdcall;

    function GetVariableByName((*_In_*) Name: LPCSTR): ID3D11ShaderReflectionVariable; stdcall;

    function GetResourceBindingDescByName((*_In_*) Name: LPCSTR;
                                          (*_Out_*) out pDesc: D3D11_SHADER_INPUT_BIND_DESC): HRESULT; stdcall;

    function GetMovInstructionCount: UINT; stdcall;
    function GetMovcInstructionCount: UINT; stdcall;
    function GetConversionInstructionCount: UINT; stdcall;
    function GetBitwiseInstructionCount: UINT; stdcall;

    function GetGSInputPrimitive: D3D_PRIMITIVE; stdcall;
    function IsSampleFrequencyShader: BOOL; stdcall;

    function GetNumInterfaceSlots: UINT; stdcall;
    function GetMinFeatureLevel((*_Out_*) {enum} out pLevel: D3D_FEATURE_LEVEL): HRESULT; stdcall;

    function GetThreadGroupSize(
                                 (*_Out_opt_*) pSizeX: PUINT;
                                 (*_Out_opt_*) pSizeY: PUINT;
                                 (*_Out_opt_*) pSizeZ: PUINT): UINT; stdcall;

    function GetRequiresFlags: UINT64; stdcall;
  end;
  {$EXTERNALSYM ID3D11ShaderReflection}
  IID_ID3D11ShaderReflection = ID3D11ShaderReflection;
  {$EXTERNALSYM IID_ID3D11ShaderReflection}
  TID3D11ShaderReflection = ID3D11ShaderReflection;


  ID3D11LibraryReflection = interface(IUnknown)
  ['{54384F1B-5B3E-4BB7-AE01-60BA3097CBB6}']
    function GetDesc((*Out_*) out pDesc: D3D11_LIBRARY_DESC): HRESULT; stdcall;

    function GetFunctionByIndex((*_In_*) FunctionIndex: Integer): ID3D11FunctionReflection; stdcall;
  end;
  {$EXTERNALSYM ID3D11LibraryReflection}
  IID_ID3D11LibraryReflection = ID3D11LibraryReflection;
  {$EXTERNALSYM IID_ID3D11LibraryReflection}

  ID3D11FunctionReflection = interface(IUnknown)
  ['{207BCECB-D683-4A06-A8A3-9B149B9F73A4}']
    function GetDesc((*Out_*) out pDesc: D3D11_FUNCTION_DESC): HRESULT; stdcall;

    function GetConstantBufferByIndex((*In_*) BufferIndex: UINT): ID3D11ShaderReflectionConstantBuffer; stdcall;
    function GetConstantBufferByName((*In_*) Name: LPCSTR): ID3D11ShaderReflectionConstantBuffer; stdcall;

    function GetResourceBindingDesc((*In_*) ResourceIndex: UINT;
                                    (*_Out_*) out pDesc: D3D11_SHADER_INPUT_BIND_DESC): HRESULT; stdcall;

    function GetVariableByName((*_In_*) Name: LPCSTR): ID3D11ShaderReflectionVariable; stdcall;

    function GetResourceBindingDescByName((*In_*) Name: LPCSTR;
                                    (*_Out_*) out pDesc: D3D11_SHADER_INPUT_BIND_DESC): HRESULT; stdcall;

    // 使用D3D_RETURN_PARAMETER_INDEX获取返回值的描述。
    function GetFunctionParameter((*_In_*) ParameterIndex: Integer): ID3D11FunctionParameterReflection; stdcall;
  end;
  {$EXTERNALSYM IID_ID3D11FunctionReflection}
  IID_ID3D11FunctionReflection = ID3D11FunctionReflection;
  {$EXTERNALSYM ID3D11FunctionReflection}

  ID3D11FunctionParameterReflection = interface
  ['{42757488-334F-47FE-982E-1A65D08CC462}']
    function GetDesc((*_Out_*) out pDesc: D3D11_PARAMETER_DESC): HRESULT; stdcall;
  end;
  {$EXTERNALSYM IID_ID3D11FunctionParameterReflection}
  IID_ID3D11FunctionParameterReflection = ID3D11FunctionParameterReflection;
  {$EXTERNALSYM ID3D11FunctionParameterReflection}

  ID3D11ModuleInstance = interface;

  ID3D11Module = interface(IUnknown)
  ['{CAC701EE-80FC-4122-8242-10B39C8CEC34}']
    // 为资源重新绑定创建一个模块实例。
    function CreateInstance((*_In_opt_*) pNamespace: LPCSTR;
                            (*_COM_Outptr_*) out ppModuleInstance: ID3D11ModuleInstance): HRESULT; stdcall;
  end;
  {$EXTERNALSYM IID_ID3D11Module}
  IID_ID3D11Module = ID3D11Module;
  {$EXTERNALSYM ID3D11Module}

  ID3D11ModuleInstance = interface(IUnknown)
  ['{469E07F7-045A-48D5-AA12-68A478CDF75D}']
    //
    // 资源绑定API。
    //
    function BindConstantBuffer((*THIS_ _In_*) uSrcSlot: UINT; (*_In_*) uDstSlot: UINT; (*_In_*) cbDstOffset: UINT): HRESULT; stdcall;
    function BindConstantBufferByName((*THIS_ _In_*) pName: LPCSTR; (*_In_*) uDstSlot: UINT; (*_In_*) cbDstOffset: UINT ): HRESULT; stdcall;

    function BindResource((*THIS_ _In_*) uSrcSlot: UINT; (*_In_*) uDstSlot: UINT; (*_In_*) uCount: UINT): HRESULT; stdcall;
    function BindResourceByName((*THIS_ _In_*) pName: LPCSTR; (*_In_*) uDstSlot: UINT; (*_In_*) uCount: UINT): HRESULT; stdcall;

    function BindSampler((*THIS_ _In_*) uSrcSlot: UINT; (*_In_*) uDstSlot: UINT; (*_In_*) uCount: UINT): HRESULT; stdcall;
    function BindSamplerByName((*THIS_ _In_*) pName: LPCSTR; (*_In_*) uDstSlot: UINT; (*_In_*) uCount: UINT): HRESULT; stdcall;

    function BindUnorderedAccessView((*THIS_ _In_*) uSrcSlot: UINT; (*_In_*) uDstSlot: UINT; (*_In_*) uCount: UINT): HRESULT; stdcall;
    function BindUnorderedAccessViewByName((*THIS_ _In_*) pName: LPCSTR; (*_In_*) uDstSlot: UINT; (*_In_*) uCount: UINT): HRESULT; stdcall;

    function BindResourceAsUnorderedAccessView((*THIS_ _In_*) uSrcSrvSlot: UINT; (*_In_*) uDstUavSlot: UINT; (*_In_*) uCount: UINT): HRESULT; stdcall;
    function BindResourceAsUnorderedAccessViewByName((*THIS_ _In_*) pSrvName: LPCSTR; (*_In_*) uDstUavSlot: UINT; (*_In_*) uCount: UINT): HRESULT; stdcall;
  end;
  {$EXTERNALSYM IID_ID3D11ModuleInstance}
  IID_ID3D11ModuleInstance = ID3D11ModuleInstance;
  {$EXTERNALSYM ID3D11ModuleInstance}

  ID3D11Linker = interface(IUnknown)
  ['{59A6CD0E-E10D-4C1F-88C0-63ABA1DAF30E}']
    // 链接着色器并生成一个适合D3D运行时的着色器blob。
    function Link((*_In_*) pEntry: ID3D11ModuleInstance;
                          (*_In_*) pEntryName: LPCSTR;
                          (*_In_*) pTargetName: LPCSTR;
                          (*_In_*) uFlags: UINT;
                          (*_COM_Outptr_*) out ppShaderBlob: ID3DBlob;
                          (*_Always_(_Outptr_opt_result_maybenull_)*)
                          out ppErrorBuffer: ID3DBlob): HRESULT; stdcall;

    // 添加要用于链接的库模块的实例。
    function UseLibrary((*_In_*) pLibraryMI: ID3D11ModuleInstance): HRESULT; stdcall;

    // 添加一个剪辑平面，其平面系数取自一个cbuffer条目，用于10L9着色器。
    function AddClipPlaneFromCBuffer((*_In_*) uCBufferSlot: UINT; (*_In_*) uCBufferEntry: UINT): HRESULT; stdcall;
  end;
  {$EXTERNALSYM IID_ID3D11Linker}
  IID_ID3D11Linker = ID3D11Linker;
  {$EXTERNALSYM ID3D11Linker}

  ID3D11LinkingNode = interface(IUnknown)
  ['{D80DD70C-8D2F-4751-94A1-03C79B3556DB}']
  end;
  {$EXTERNALSYM IID_ID3D11LinkingNode}
  IID_ID3D11LinkingNode = ID3D11LinkingNode;
  {$EXTERNALSYM ID3D11LinkingNode}


  ID3D11FunctionLinkingGraph = interface(IUnknown)
  ['{54133220-1CE8-43D3-8236-9855C5CEECFF}']
    // 从FLG描述中创建一个着色器模块输出。
    function CreateModuleInstance((*_COM_Outptr_*) out ppModuleInstance: ID3D11ModuleInstance;
                                  (*_Always_(_Outptr_opt_result_maybenull_)*) out ppErrorBuffer: ID3DBlob): HRESULT; stdcall;

    function SetInputSignature((*__in_ecount(cInputParameters)*) const pInputParameters: PD3D11ParameterDesc;
                               (*_In_*) cInputParameters: UINT;
                               (*_COM_Outptr_*) out ppInputNode: ID3D11LinkingNode): HRESULT; stdcall;

    function SetOutputSignature((*__in_ecount(cOutputParameters)*) const pOutputParameters: PD3D11ParameterDesc;
                              (*_In_*) cOutputParameters: UINT;
                              (*_COM_Outptr_*) out ppOutputNode: ID3D11LinkingNode): HRESULT; stdcall;

    function CallFunction((*_In_ opt_*) pModuleInstanceNamespace: LPCSTR;
                          (*_In_*) pModuleWithFunctionPrototype: ID3D11Module;
                          (*_In_*) pFunctionName: LPCSTR;
                          (*_COM_Outptr_*) out ppCallNode: ID3D11LinkingNode): HRESULT; stdcall;

    function PassValue((*_In_*) pSrcNode: ID3D11LinkingNode;
                       (*_In_*) SrcParameterIndex: integer;
                       (*_In_*) pDstNode: ID3D11LinkingNode;
                       (*_In_*) DstParameterIndex: integer): HRESULT; stdcall;

    function PassValueWithSwizzle((*_In_*) pSrcNode: ID3D11LinkingNode;
                                  (*_In_*) SrcParameterIndex: integer;
                                  (*_In_*) pSrcSwizzle: LPCSTR;
                                  (*_In_*) pDstNode: ID3D11LinkingNode;
                                  (*_In_*) DstParameterIndex: integer;
                                  (*_In_*) pDstSwizzle: LPCSTR ): HRESULT; stdcall;

    function GetLastError((*_Always_(_Outptr_opt_result_maybenull_)*) out ppErrorBuffer: ID3DBlob): HRESULT; stdcall;

    function GenerateHlsl((*_In_*) uFlags: UINT;// uFlags为未来使用预留。
                          (*_COM_Outptr_*) out ppBuffer: ID3DBlob): HRESULT; stdcall;
  end;



//
// APIs //
//

// Macro defininitons
function D3D11_SHVER_GET_TYPE(_Version: UInt): UINT;
{$EXTERNALSYM D3D11_SHVER_GET_TYPE}
function D3D11_SHVER_GET_MAJOR(_Version: UInt): UINT;
{$EXTERNALSYM D3D11_SHVER_GET_MAJOR}
function D3D11_SHVER_GET_MINOR(_Version: UInt): UINT;
{$EXTERNALSYM D3D11_SHVER_GET_MINOR}
implementation

function D3D11_SHVER_GET_TYPE(_Version: UInt): UINT;
begin
    result := (((_Version) shr 16) and $FFFF)
end;

function D3D11_SHVER_GET_MAJOR(_Version: UInt): UINT;
begin
  result := (((_Version) shr 4) and $F)
end;

function D3D11_SHVER_GET_MINOR(_Version: UInt): UINT;
begin
  result := (((_Version) shr 0) and $F);
end;
end.

 

 

孤独的学者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
DELPHI 学习--------D3D 旋转
12-22
DELPHI 学习--------D3D 旋转。Direct3D ,顶点及材质的使用
DirectX11程序设计
02-22
这本书是Wendy Joness写的《Beginning DirectX 10 Game　Programming》的后续版本。在这本书中，我们将教你使用最新的Direct3D 11进行基础的游戏图形设计。
Delphi 中的颜色常量及效果图
weixin_30918415的博客
12-26 144
颜色名称颜色效果HexHTML clBlack $000000 #000000 clMaroon $000080 #800000 clGreen $008000 #008000 clOlive $008080 #808000 clNavy $800000 #000080 ...
Delphi,在DelphiXE下使用DirectX的初步摸索
最新发布
清风-德尔斐
06-15 314
昨天刚安装了 DelphiXE ， Delphi2010以上的版本自带了 DirectX 的SDK。Memo1.Lines.Add('不能创建 REF 设备!Memo1.Lines.Add('成功创建 REF 设备');Memo1.Lines.Add('不能创建 HAL 设备!Memo1.Lines.Add ('成功创建 HAL 设备');
Delphi 与 DirectX 之 DelphiX(11): TPictureCollectionItem.DrawAdd、DrawSub
weixin_33779515的博客
09-26 132
为什么80%的码农都做不了架构师？>>> ...
delphi3d-engine：用于Delphi和Windows的3D图形和游戏引擎
02-04
Delphi3D引擎 适用于Delphi，DirectX 11和Windows的3D图形和游戏引擎。 它用于开发免费的多人游戏 。 用法 发动机 复制项目中的所有文件或使用我们通常链接到该项目的方式：将Engine目录和所有子目录添加到Delphi中的搜索路径中（必须为每个目标32位和64位进行配置）。 经过测试（在Rise of Legions中），该引擎可以使用图形组件（客户端）与32位一起工作，而无需任何图形（服务器）就可以与64位一起工作。 使用Delphi 10.1 Berlin（开发版本）时：内置的DirectX-Headers包含一些错误，这些错误已由我们修复。 确保在项目中包
d3d11renderers.rar
07-31
4. **资源创建**：在D3D11中，顶点缓冲区（Vertex Buffer）、索引缓冲区（Index Buffer）、纹理、着色器（Shader）等都是资源。`CreateBuffer`和`CreateTexture2D`用于创建缓冲区和纹理，而`CreateVertexShader`、`...
D3D11YUVRendering.rar
10-13
- 创建与纹理相对应的视图（ID3D11ShaderResourceView），这样我们可以在着色器中访问这些纹理。对每个纹理使用`ID3D11Device::CreateShaderResourceView`，指定纹理和视图描述。 4. **着色器编程**： - 在顶点...
D3D11-Wallhack-master.zip_FW1FontWrapper_d3d11 hook源码_dx11_mainv
07-15
在IT行业中，Direct3D 11（简称D3D11）是微软开发的图形应用程序接口（API），用于处理Windows平台上的3D图形渲染。它属于DirectX的一部分，广泛应用于游戏开发、科学可视化和专业图像处理等领域。"Wallhack"通常指...
d3d11.dll文件
09-19
WIN7放到windows SYSTEM32中就可以了
D3D11Texture2D.e
11-27
D3D11绘制文本源码
在delphi中使用freetype对D3D绘字优化的源码
05-06
DELPHI下使用Freetype在D3D中绘字一点源码，同时提供delphi可以用的pas和对应dll还有DGL和D3D9的pas~ 希望能帮到其他使用delphi做游戏开发或者D3D开发的童鞋~
delphiX控件（DirectX）
08-05
delphi的DirectX控件，做小游戏十分方便
使用Delphi游戏光影效果惊人，
12-23
游戏光影效果惊人，使用Delphi的朋友们可以看看
DELPHI HOOK D3D画字画字源代码
02-13
DELPHI HOOK D3D画字画字源代码，可以在其它3D游戏中显示自己设定的文字
D3D11地形渲染
05-15
设计了一种基于GPU编程实现的大规模地形场景的实时绘制与漫游算法。利用GPU端完成地形网格更新、地形块的自动选取、高度图和纹理图采样等大部分计算工作，大大减轻了CPU端的计算负载。
DelphiX.1.0.9(Delphi DirectX 3D 游戏制作）
05-07
Delphi 3D 游戏制作， delphiX是将DirectX技术应用到Delphi的一通控件。
DirectX11入门：着色器与特效解析
这部分内容详细阐述了Direct3D 11(D3D11)在游戏编程中的应用，其中着色器是图形渲染的核心部分，它们允许程序员自定义图形管道的不同阶段，实现更复杂的视觉效果。可编程着色器的历史表明了图形技术的进步，从固定的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

孤独的学者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值