cbuffer和tbuffer

 Shader Model 4支持的新东西，通过打包数据可以获得更好的性能。原文转发：
Shader Constants (DirectX HLSL)

In shader model 4, shader constants are stored in one or more buffer resources in memory. They can be organized into two types of buffers: constant buffers (cbuffers) and texture buffers (tbuffers). Constant buffers are optimized for constant-variable usage, which is characterized by lower-latency access and more frequent update from the CPU. For this reason, additional size, layout, and access restrictions apply to these resources. Texture buffers are accessed like textures and perform better for arbitrarily indexed data. Regardless of which type of resource you use, there is no limit to the number of constant buffers or texture buffers an application can create.

Declaring a constant buffer or a texture buffer looks very much like a structure declaration in C, with the addition of the register and packoffset keywords for manually assigning registers or packing data.

BufferType [Name] [: register(b#)] {     VariableDeclaration [: packoffset(c#.xyzw)];      ... };

 

Parameters BufferType

[in] The buffer type.

BufferType	Description
cbuffer	constant buffer
tbuffer	texture buffer

 

Name

[in] Optional, ASCII string containing a unique buffer name.

register(b#)

[in] Optional keyword, used to manually pack constant data. Constants can be packed in a register only in a constant buffer, where the starting register is given by the register number (#).

VariableDeclaration

[in] Variable declaration, similar to a structure member declaration. This can be any HLSL type or effect object (except a texture or a sampler object).

packoffset(c#.xyzw)

[in] Optional keyword, used to manually pack constant data. Constants can be packed in any constant buffer, where the register number is given by (#). Sub-component packing (using xyzw swizzling) is available for constants whose size fit within a single register (do not cross a register boundary). For instance, a float4 could not be packed in a single register starting with the y component as it would not fit in a four-component register.

Remarks

Constant buffers reduce the bandwidth required to update shader constants by allowing shader constants to be grouped together and committed at the same time rather than making individual calls to commit each constant separately.

A constant buffer is a specialized buffer resource that is accessed like a buffer. Each constant buffer can hold up to 4096 ; each vector contains up to four 32-bit values. You can bind up to 14 constant buffers per pipeline stage (2 additional slots are reserved for internal use).

A texture buffer is a specialized buffer resource that is accessed like a texture. Texture access (as compared with buffer access) can have better performance for arbitrarily indexed data. You can bind up to 128 texture buffers per pipeline stage.

A buffer resource is designed to minimize the overhead of setting shader constants. The effect framework (see ) will manage updating constant and texture buffers, or you can use the Direct3D API to update buffers (see for information). An application can also copy data from another buffer (such as a render target or a stream-output target) into a constant buffer.

For additional information on using constant buffers in a D3D10 application see and .

For additional information on using constant buffers in a D3D11 application see and .

A constant buffer does not require a to be bound to the pipeline. A texture buffer, however, requires a view and must be bound to a texture slot (or must be bound with when using an effect).

There are two ways to pack constants data: using the and keywords.

Differences between Direct3D 9 and Direct3D 10 and 11:

Unlike the auto-allocation of constants in Direct3D 9, which did not perform packing and instead assigned each variable to a set of float4 registers, HLSL constant variables follow packing rules in Direct3D 10 and 11.

 

Organizing constant buffers

Constant buffers reduce the bandwidth required to update shader constants by allowing shader constants to be grouped together and committed at the same time rather than making individual calls to commit each constant separately.

The best way to efficiently use constant buffers is to organize shader variables into constant buffers based on their frequency of update. This allows an application to minimize the bandwidth required for updating shader constants. For example, a shader might declare two constant buffers and organize the data in each based on their frequency of update: data that needs to be updated on a per-object basis (like a world matrix) is grouped into a constant buffer which could be updated for each object. This is separate from data that characterizes a scene and is therefore likely to be updated much less often (when the scene changes).

cbuffer myObject
{
float4x4 matWorld;
float3 vObjectPosition;
int arrayIndex;
}

cbuffer myScene
{
float3 vSunPosition;
float4x4 matView;
}

Default constant buffers

There are two default constant buffers available, $Global and $Param. Variables which are placed in the global scope are added implicitly to the $Global cbuffer, using the same packing method as is used for cbuffers. Uniform parameters in the parameter list of a function appear in the $Param constant buffer when a shader is compiled outside of the effects framework. When compiled inside the effects framework, all uniforms must resolve to variables defined in the global scope.

Examples

Here is an example from that is a texture buffer made up of an array of matrices.

tbuffer tbAnimMatrices
{
matrix g_mTexBoneWorld[MAX_BONE_MATRICES];
};

This example declaration manually assigns a constant buffer to start at a particular register, and also packs particular elements by subcomponents.

cbuffer MyBuffer : register(b3)
{
float4 Element1 : packoffset(c0);
float1 Element2 : packoffset(c1);
float1 Element3 : packoffset(c1.y);
}

Related Topics

 

 另：

在DirectX10 SDK的范例中，主要是使用Effect框架来组织Shader。但是有些情况下，引擎需要自己来生成或管理shader，sampler,textrue等，这样Effect框架的灵活性就显的不够了。

SDK的“HLSLWithoutFX10 Sample”中 演示了如何不使用Effect框架的方法，但是有些问题没有说到。主要是关于Shader与应用程序间的数据传递。要传递的数据主要有 constant buffer,samplerstate,textrue(resource)。查阅了一些资料加上摸索加上Exjoy的帮助，整理了 一下不使用Effect框架来管理数据传递的方法。主要有两种：

1 最简单也是直接的就是用寄存器名来绑定数据了。

首先是constant的传递。

这 里要先提一下DirectX10中新引入的constant buffer。在DX10中，constant存放于常量缓冲区中，每个常量缓冲区由 4096个常量寄存器组成，共有16个常量缓冲区。这样就可以根据constant更新的频率来组织，可以提升性能。Constant buffer会为 两种：cbuffer,tbuffer。注意tbuffer是并不是用来存储纹理的，而是指可以像纹理那样来访问其中的数据，对于索引类数据有更好的性 能。

来看实例：

在shader中有如下定义

cbuffer MyBuffer : register(b3)
{
float4 Element1 : packoffset(c0);
float1 Element2 : packoffset(c1);
float1 Element3 : packoffset(c1.y);
}

register(bN)：b表示constant buffer，N为input slot (0-15) 。

即表示Mybuffer存放于b3中。

在应用程序中使用如下。

g_pd3dDevice->VSSetConstantBuffers( 3, 1, pBuffers );

第一个参数即为要传递的buffer放置的slot起点。类似的函数PSSetConstantBuffers，GSSetConstantBuffers。

Textrue类似，语法为register(tN), t 表示纹理，N 为input slot (0-127) 。

例，PS中：

Texture2D txDiffuse : register(t3);

应用程序中：g_pd3dDevice->PSSetShaderResources( 3, 1, texViewArray );

Samplers语法为register(sN), s 表示取样器，s 为input slot (0-127) 。

例，PS中：

SamplerState samLinear2 : register(s4)
{
Filter = MIN_MAG_MIP_LINEAR;
AddressU = Wrap;
AddressV = Wrap;
};

应用程序中使用的函数为ID3D10Device::PSGetSamplers（）。

2 使用shader reflect系统

这种方法可以按变量名来传递数据。

举个例子来说吧，PS中有如下定义：

Texture2D txDiffuse;

SamplerState samLinear
{
Filter = MIN_MAG_MIP_LINEAR;
AddressU = Wrap;
AddressV = Wrap;
};

cbuffer pscb0
{
float4 color;
};

（1）创建一个ID3D10ShaderReflection对象，通过这个对象可以从已编译好的shader中取得相应的信息。

hr = D3D10ReflectShader( (void*) pPSBuf->GetBufferPointer(), pPSBuf->GetBufferSize(),&pIShaderReflection );

（2）调用GetDesc，得到的D3D10_SHADER_DESC中的BoundResources为当前的shader绑定的resource数量。这里的resouce包括了constant buffer，texture，sampler，此处返回的BoundResources为3。

D3D10_SHADER_DESC desc;
if( pIShaderReflection )
{
pIShaderReflection->GetDesc( &desc );
}

（3）使用GetResourceBindingDesc得到具体的每个resource的绑定信息。

D3D10_SHADER_INPUT_BIND_DESC resourceBindingDesc0;
D3D10_SHADER_INPUT_BIND_DESC resourceBindingDesc1;
D3D10_SHADER_INPUT_BIND_DESC resourceBindingDesc2;

if( pIShaderReflection )
{
pIShaderReflection->GetResourceBindingDesc(0, &resourceBindingDesc0);
pIShaderReflection->GetResourceBindingDesc(1, &resourceBindingDesc1);
pIShaderReflection->GetResourceBindingDesc(2, &resourceBindingDesc2 );
}

     D3D10_SHADER_INPUT_BIND_DESC结构中的主要的属性有：

     LPCSTR Name  绑定的resource的名字

     D3D10_SHADER_INPUT_TYPE Typ

       D3D10_SHADER_INPUT_TYPE为枚举        量:D3D10_SIT_CBUFFER,D3D10_SIT_TBUFFER,

    D3D10_SIT_TEXTURE,D3D10_SIT_SAMPLER

   注意，此处的D3D10_SIT_CBUFFER，D3D10_SIT_TBUFFER都是指constant buffer。     UINT BindPoint：资源绑定的slot。即我们要使用的。

此处结果为：

resourceBindingDesc0  samLinear

resourceBindingDesc1  txDiffuse

resourceBindingDesc2  pscb0

（4）根据（3）得到的信息进行具体的绑定，我们要绑定纹理，所以使用resourceBindingDesc1：

const char* texname1 = "txDiffuse";

if( strcmp( texname1, resourceBindingDesc1.Name) == NULL )
{
    //给PS设置纹理
g_pd3dDevice->PSSetShaderResources( resourceBindingDesc1.BindPoint, 1, texViewArray );
}

Constant buffer和sampler类似。