Error creating vertex buffer

Question

I have an error while creating vertexbuffer Here is my code:

bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{



HRESULT result;
    ID3D10Blob* errorMessage;
    ID3D10Blob* vertexShaderBuffer;
    ID3D10Blob* pixelShaderBuffer;
    D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
    unsigned int numElements;
    D3D11_BUFFER_DESC matrixBufferDesc;


// Initialize the pointers this function will use to null.
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;

// Compile the vertex shader code.
result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "ColorVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, 
                               &vertexShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
    // If the shader failed to compile it should have writen something to the error message.
    if(errorMessage)
    {
        OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
    }
    // If there was  nothing in the error message then it simply could not find the shader file itself.
    else
    {
        MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
    }

    return false;
}

// Compile the pixel shader code.
result = D3DX11CompileFromFile(psFilename, NULL, NULL, "ColorPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, 
                               &pixelShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
    // If the shader failed to compile it should have writen something to the error message.
    if(errorMessage)
    {
        OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
    }
    // If there was nothing in the error message then it simply could not find the file itself.
    else
    {
        MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
    }

    return false;
}

// Create the vertex shader from the buffer.
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL,
    &m_vertexShader);
if(FAILED(result))
{
    return false;
}

// Create the pixel shader from the buffer.
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL,
    &m_pixelShader);
if(FAILED(result))
{
    return false;
}

// Create the vertex input layout description.
// This setup needs to match the VertexType stucture in the ModelClass and in the shader.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;

polygonLayout[1].SemanticName = "COLOR";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;

// Get a count of the elements in the layout.
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);

// Create the vertex input layout.
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), 
                                   vertexShaderBuffer->GetBufferSize(), &m_layout);
if(FAILED(result))
{
    return false;
}

// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;

pixelShaderBuffer->Release();
pixelShaderBuffer = 0;

// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;

// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if(FAILED(result))
{
    return false;
}

return true;
}

And btw that, I'm going from tutorials http://www.rastertek.com/dx11tut04.html .You can see the hole code there. I heard the problem could be , that my videocard doesn't support DirectX 11. If that's the problem, can I do software vertex processing with feature level 11 or something like that, so it'll work.

Answer 1

If your card didn't support Direct3D 11 features the program would fail at device initialisation and not shader creation, so if you are initialising your device with D3D_FEATURE_LEVEL_11_0 and it succeeds, that means that your problem lies somewhere in the shader code. This is quite likely given that IntelliSense doesn't work with HLSL.

Luckily your framework comes with some error reporting facilities, so you can simply look at shader_errors.txt file to see where your problem lies.

If the above is not the case (i.e. you've already changed your Direct3D feature level) then you have several options:

1. Change your shader model to match Direct3D feature level in D3DX11CompileFromFile() method, e.g. if you are using D3D_FEATURE_LEVEL_10_0 set your shader models to vs_4_0 and ps_4_0.

2. If you're using Windows 8 (somewhat unlikely on a machine with no DX11 support) then you can use D3D_DRIVER_TYPE_WARP in your device initialisation, which is a fast software rasterizer, but on older versions of Windows it doesn't support 11_0 feature level.

3. As a last resort you can use D3D_DRIVER_TYPE_REFERENCE which supports all Direct3D features, but is extremely slow, to a point of being unusable.

Ultimately it is always a good idea to have some form of a fallback option in case the hardware you're running on doesn't support your desired feature level. For example:

D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;

HRESULT result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, D3D11_CREATE_DEVICE_DEBUG, &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if (FAILED(result))
{
    featureLevel = D3D_FEATURE_LEVEL_10_0;
    result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, D3D11_CREATE_DEVICE_DEBUG, &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
    if (FAILED(result))
    {
        // OK, now quit, we need at least DirectX 10 compatible hardware
        return false;
    }
}

// In shader class
if (m_device->GetFeatureLevel() == D3D_FEATURE_LEVEL_11_0)
{
    // use 5.0 shader model
}
else
{
    // use 4.0 shader model
}