Прежде чем углубляться в детали, я хочу обрисовать проблему:

Я использую RWStructuredBuffers для хранения вывода моих вычислительных шейдеров (CS). Поскольку вершинные и пиксельные шейдеры не могут читать из RWStructuredBuffers, я сопоставляю StructuredBuffer с одним и тем же слотом (u0 / t0) и (u4 / t4):

cbuffer cbWorld : register (b1) 
{
    float4x4 worldViewProj;
    int dummy;
}   

struct VS_IN
{
    float4 pos : POSITION;
    float4 col : COLOR;
};

struct PS_IN
{

    float4 pos : SV_POSITION;
    float4 col : COLOR;
};

RWStructuredBuffer<float4> colorOutputTable : register (u0);    // 2D color data
StructuredBuffer<float4> output2 :            register (t0);    // same as u0
RWStructuredBuffer<int> counterTable :        register (u1);    // depth data for z values
RWStructuredBuffer<VS_IN>vertexTable :        register (u4);    // triangle list
StructuredBuffer<VS_IN>vertexTable2 :         register (t4);    // same as u4

Я использую ShaderRecourceView для предоставления доступа к буферам пиксельных и / или вершинных шейдеров. Эта концепция прекрасно работает для моего пиксельного шейдера, однако вершинный шейдер, похоже, читает только 0 значений (я использую SV_VertexID в качестве индекса для буферов):

PS_IN VS_3DA ( uint vid : SV_VertexID ) 
{           
    PS_IN output = (PS_IN)0; 
    PS_IN input = vertexTable2[vid];
    output.pos = mul(input.pos, worldViewProj); 
    output.col = input.col; 
    return output;
}

Нет сообщений об ошибках или предупреждений от компилятора hlsl, renderloop работает со скоростью 60 кадров в секунду (используя vsync), но экран остается черным. Так как я очищаю экран с помощью Color.White до вызова Draw (..), конвейер рендеринга кажется активным.

Когда я считываю содержимое данных треугольника через UAView из графического процессора в «vertArray» и возвращаю его обратно в буфер вершин, все работает, однако:

Программа:

    let vertices = Buffer.Create(device, BindFlags.VertexBuffer, vertArray)
    context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertices, Utilities.SizeOf<Vector4>() * 2, 0))

HLSL:

PS_IN VS_3D (VS_IN input )
{
    PS_IN output = (PS_IN)0;    
    output.pos = mul(input.pos, worldViewProj);
    output.col = input.col; 
    return output;
}

Здесь определение 2D - Vertex / Pixelshaders. Обратите внимание, что PS_2D обращается к буферу «output2» в слоте t0 - и это именно та «хитрость», которую я хочу повторить для трехмерного вершинного шейдера «VS_3DA»:

float4 PS_2D ( float4 input : SV_Position) : SV_Target
{        
    uint2 pixel =  uint2(input.x, input.y);         
    return output2[ pixel.y * width + pixel.x]; 
}

float4 VS_2D ( uint vid : SV_VertexID ) : SV_POSITION
{
if (vid == 0)
    return float4(-1, -1, 0, 1);
if (vid == 1)
    return float4( 1, -1, 0, 1);
if (vid == 2)
    return float4(-1,  1, 0, 1);    

return float4( 1,  1, 0, 1);    
}

Три дня я искал и экспериментировал безрезультатно. Вся информация, которую я собрал, кажется, подтверждает, что мой подход с использованием тогда SV_VertexID должен работать.

Кто-нибудь может дать совет? Спасибо, что прочитали мой пост!

================================================== ===================

ПОДРОБНОСТИ:

Мне очень нравится концепция вычислительных шейдеров DirectX 11, и я хочу использовать ее для алгебраических вычислений. В качестве тестового примера я рендерил фракталы (множества Мандельброта) в 3D. Все работает как положено - за исключением одного последнего кирпича в стене.

Расчет состоит из следующих шагов:

Использование CS для вычисления 2D текстуры (выходные данные «counterTable» и «colorOutbutTable» (работает)

При желании визуализировать эту текстуру на экране (работает)

Использование другой CS для создания сетки (список треугольников). Эта CS берет значения x, y и цвета из шага 1, вычисляет координату z и, наконец, создает квад для каждого пикселя. Результат сохраняется в «vertexTable». (работает)

Подача списка треугольников в вершинный шейдер (проблема !!!)

Визуализация на экране (работает - с использованием буфера вершин).

Для программирования я использую F # 3.0 и SharpDX в качестве оболочки .NET. ShaderRessourceView для обоих шейдеров (пиксель и вершина) настроен с одинаковыми параметрами (кроме параметров размера):

let mutable descr = new BufferDescription()     
descr.BindFlags <- BindFlags.UnorderedAccess ||| BindFlags.ShaderResource 
descr.Usage <- ResourceUsage.Default  
descr.CpuAccessFlags <- CpuAccessFlags.None
descr.StructureByteStride <- xxx    / / depends on shader
descr.SizeInBytes <-  yyy       / / depends on shader
descr.OptionFlags <- ResourceOptionFlags.BufferStructured

Здесь нет ничего особенного. Создание 2D-буфера (привязывается к буферу «output2» в слоте t0):

outputBuffer2D <- new Buffer(device, descr) 
outputView2D <- new UnorderedAccessView (device, outputBuffer2D)  
shaderResourceView2D <- new ShaderResourceView (device, outputBuffer2D)

Создание 3D-буфера (привязывается к «vertexTable2» в слоте t4):

vertexBuffer3D <- new Buffer(device, descr) 
shaderResourceView3D <- new ShaderResourceView (device, vertexBuffer3D)
//  UAView not required here

Настройка ресурсов для 2D:

context.InputAssembler.PrimitiveTopology <- PrimitiveTopology.TriangleStrip
context.OutputMerger.SetRenderTargets(renderTargetView2D)
context.OutputMerger.SetDepthStencilState(depthStencilState2D)
context.VertexShader.Set (vertexShader2D)
context.PixelShader.Set (pixelShader2D) 

визуализация 2D:

context.PixelShader.SetShaderResource(COLOR_OUT_SLOT, shaderResourceView2D)
context.PixelShader.SetConstantBuffer(CONSTANT_SLOT_GLOBAL, constantBuffer2D )
context.ClearRenderTargetView (renderTargetView2D, Color.White.ToColor4())         
context.Draw(4,0)                                                
swapChain.Present(1, PresentFlags.None)            

Настройка ресурсов для 3D:

context.InputAssembler.PrimitiveTopology <- PrimitiveTopology.TriangleList
context.OutputMerger.SetTargets(depthView3D, renderTargetView2D)
context.VertexShader.SetShaderResource(TRIANGLE_SLOT, shaderResourceView3D )
context.VertexShader.SetConstantBuffer(CONSTANT_SLOT_3D, constantBuffer3D)
context.VertexShader.Set(vertexShader3D)
context.PixelShader.Set(pixelShader3D)

рендеринг 3D (не работает - черный экран как результат вывода)

context.ClearDepthStencilView(depthView3D, DepthStencilClearFlags.Depth, 1.0f, 0uy)
context.Draw(dataXsize * dataYsize * 6, 0)
swapChain.Present(1, PresentFlags.None)

Наконец номера слотов:

static let CONSTANT_SLOT_GLOBAL = 0
static let CONSTANT_SLOT_3D = 1
static let COLOR_OUT_SLOT = 0
static let COUNTER_SLOT = 1
static let COLOR_SLOT = 2    
static let TRIANGLE_SLOT = 4