spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

D3D11_INPUT_ELEMENT_DESC Layout[] =
    {
        {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
        {"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
        {"NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
        {"TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
        {"BINORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
        {"TEXCOORD", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 0, D3D11_INPUT_PER_INSTANCE_DATA, 1},
        {"TEXCOORD", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 16, D3D11_INPUT_PER_INSTANCE_DATA, 1},
        {"TEXCOORD", 3, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 32, D3D11_INPUT_PER_INSTANCE_DATA, 1},
        {"TEXCOORD", 4, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 48, D3D11_INPUT_PER_INSTANCE_DATA, 1}
    };

C-/C++-Quelltext

void Object::RenderIndexedInstanced()
{
    ID3D11DeviceContext *ImmediateContext = System->GetDeviceContext();

    float *InstancesRawData = new float[Instances.size() * 16];
    float *CurInstDataPos = InstancesRawData;
    for(auto Instance = Instances.begin(); Instance != Instances.end(); ++Instance)
    {
        // to save performance it is ignored whether instance should be visible or not
        Instance->CalculateMatrices();
        memcpy(CurInstDataPos, &Instance->MatrixWorld, sizeof(Instance->MatrixWorld));
        CurInstDataPos += 16;
    }

    D3D11_SUBRESOURCE_DATA InstanceData;
    ZeroMemory(&InstanceData, sizeof(InstanceData));
    InstanceData.pSysMem = InstancesRawData;

    D3D11_BUFFER_DESC bd;
    ZeroMemory(&bd, sizeof(bd));
    bd.Usage = D3D11_USAGE_DEFAULT;
    bd.ByteWidth = sizeof(float) * 16 * Instances.size();
    bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;

    ID3D11Buffer *InstanceBuffer;
    HRESULT hr = System->GetDevice()->CreateBuffer(&bd, &InstanceData, &InstanceBuffer);
    if(FAILED(hr))
        throw Exception(hr, __LINE__, __FILE__, "Object::RenderIndexedInstanced()", "Creating an instance buffer failed.");

    UINT Strides[2] = {sizeof(Model::Vertex), sizeof(float) * 16};
    UINT Offsets[2] = {0};
    ID3D11Buffer* Buffers[2] = {Mesh->GetVertexBuffer(), InstanceBuffer};
    ImmediateContext->IASetVertexBuffers(0, 2, Buffers, Strides, Offsets);
    ImmediateContext->IASetIndexBuffer(Mesh->GetIndexBuffer(), DXGI_FORMAT_R32_UINT, 0);

    ImmediateContext->DrawIndexedInstanced(Mesh->GetNumIndices(), Instances.size(), 0, 0, 0);

    InstanceBuffer->Release();
    delete [] InstancesRawData;
}

HLSL-Quelltext

cbuffer CBViewProjection : register(b0)
{
    matrix view;
    matrix projection;
    matrix projectionortho;
    float4 camerapos;
}; 

struct VS_INPUT 
{ 
    float4 pos : POSITION; 
    float2 tex : TEXCOORD0; 
    float3 norm : NORMAL; 
    float3 tan : TANGENT; 
    float3 bin : BINORMAL; 
    float4 transform0 : TEXCOORD1;
    float4 transform1 : TEXCOORD2;
    float4 transform2 : TEXCOORD3;
    float4 transform3 : TEXCOORD4;
};

 PS_INPUT BumpmapVertexShader(VS_INPUT input)
 {
    [...]

    float4x4 world = {input.transform0, input.transform1, input.transform2, input.transform3};

    output.pos = mul(input.pos, world); 
    output.pos = mul(output.pos, view); 
    output.pos = mul(output.pos, projection);

    [...]
}

C-/C++-Quelltext

for(int i = 0; i < 16; i++)
            CurInstDataPos[i] = reinterpret_cast<float *>(&Instance->MatrixWorld)[(i % 4) * 4 + i / 4];