celshade_class.cpp

 
// Filename: lightshaderclass.cpp
#include "celshade_class.h"
 
 
celshade_class::celshade_class()
{
    vertex_shader_ = 0;
    pixel_shader_ = 0;
    layout_ = 0;
    sample_state_ = 0;
    matrix_buffer_ = 0;
    camera_buffer_ = 0;
    sunlight_buffer_ = 0;
    sunlight_color_buffer_ = 0;
    sunlight_position_buffer_ = 0;
}
 
 
celshade_class::celshade_class(const celshade_class& other)
{
}
 
 
celshade_class::~celshade_class()
{
}
 
 
bool celshade_class::initialize(ID3D11Device* device, HWND hwnd)
{
    Logger::Get().Log("Initializing LightShaderClass", __FILE__, __LINE__, Logger::LogLevel::Initialize);
 
    wchar_t vsFilename[128];
    wchar_t psFilename[128];
    int error;
    bool result;
 
    // Set the filename of the vertex shader.
    error = wcscpy_s(vsFilename, 128, L"src/hlsl/celshading.vs");
    if (error != 0)
    {
        Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
        return false;
    }
 
    // Set the filename of the pixel shader.
    error = wcscpy_s(psFilename, 128, L"src/hlsl/celshading.ps");
    if (error != 0)
    {
        Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
        return false;
    }
    // initialize the vertex and pixel shaders.
    result = initialize_shader(device, hwnd, vsFilename, psFilename);
    if (!result)
    {
        Logger::Get().Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
        return false;
    }
 
    Logger::Get().Log("SunLightShaderClass initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
 
    return true;
}
 
 
void celshade_class::shutdown()
{
    // shutdown the vertex and pixel shaders as well as the related objects.
    shutdown_shader();
 
    return;
}
 
bool celshade_class::render(ID3D11DeviceContext* deviceContext, int index_count, XMMATRIX world_matrix, XMMATRIX view_matrix, XMMATRIX projection_matrix,
    ID3D11ShaderResourceView* texture, XMFLOAT4 diffuse_color, XMFLOAT4 ambient_color, XMFLOAT3 sun_direction, float sunIntensity)
{
    bool result;
 
 
    // Set the shader parameters that it will use for rendering.
    result = set_shader_parameters(deviceContext, world_matrix, view_matrix, projection_matrix, texture, diffuse_color, ambient_color, sun_direction, sunIntensity);
    if (!result)
    {
        Logger::Get().Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
        return false;
    }
 
    // Now render the prepared buffers with the shader.
    render_shader(deviceContext, index_count);
 
    return true;
}
 
 
bool celshade_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
    Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
 
    HRESULT result;
    ID3D10Blob* errorMessage;
    ID3D10Blob* vertexShaderBuffer;
    ID3D10Blob* pixelShaderBuffer;
    D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
    unsigned int numElements;
    D3D11_SAMPLER_DESC samplerDesc;
    D3D11_BUFFER_DESC matrixBufferDesc;
    D3D11_BUFFER_DESC sunlightBufferDesc;
 
    // initialize the pointers this function will use to null.
    errorMessage = 0;
    vertexShaderBuffer = 0;
    pixelShaderBuffer = 0;
 
    // Compile the vertex shader code.
    result = D3DCompileFromFile(vsFilename, NULL, NULL, "SunLightVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &vertexShaderBuffer, &errorMessage);
    if (FAILED(result))
    {
        if (errorMessage)
        {
            output_shader_error_message(errorMessage, hwnd, vsFilename);
        }
        else
        {
            Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
        }
        return false;
    }
 
    // Compile the pixel shader code.
    result = D3DCompileFromFile(psFilename, NULL, NULL, "SunLightPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &pixelShaderBuffer, &errorMessage);
    if (FAILED(result))
    {
        if (errorMessage)
        {
            output_shader_error_message(errorMessage, hwnd, psFilename);
        }
        else
        {
            Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
        }
        return false;
    }
 
    // Create the vertex shader from the buffer.
    result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
    if (FAILED(result))
    {
        Logger::Get().Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
        return false;
    }
 
    // Create the pixel shader from the buffer.
    result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
    if (FAILED(result))
    {
        Logger::Get().Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
        return false;
    }
 
    // Create the vertex input layout description.
    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 = "TEXCOORD";
    polygonLayout[1].SemanticIndex = 0;
    polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
    polygonLayout[1].InputSlot = 0;
    polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[1].InstanceDataStepRate = 0;
 
    polygonLayout[2].SemanticName = "NORMAL";
    polygonLayout[2].SemanticIndex = 0;
    polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[2].InputSlot = 0;
    polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[2].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(), &layout_);
    if (FAILED(result))
    {
        Logger::Get().Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
        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;
 
    // Create a texture sampler state description.
    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.MipLODBias = 0.0f;
    samplerDesc.MaxAnisotropy = 1;
    samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
    samplerDesc.BorderColor[0] = 0;
    samplerDesc.BorderColor[1] = 0;
    samplerDesc.BorderColor[2] = 0;
    samplerDesc.BorderColor[3] = 0;
    samplerDesc.MinLOD = 0;
    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
 
    // Create the texture sampler state.
    result = device->CreateSamplerState(&samplerDesc, &sample_state_);
    if (FAILED(result))
    {
        Logger::Get().Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
        return false;
    }
 
    // Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
    matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    matrixBufferDesc.ByteWidth = sizeof(matrix_buffer_type);
    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, &matrix_buffer_);
    if (FAILED(result))
    {
        Logger::Get().Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
        return false;
    }
 
    // Setup the description of the dynamic sunlight constant buffer that is in the pixel shader.
    sunlightBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    sunlightBufferDesc.ByteWidth = sizeof(sun_light_buffer_type);
    sunlightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    sunlightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    sunlightBufferDesc.MiscFlags = 0;
    sunlightBufferDesc.StructureByteStride = 0;
 
    // Create the constant buffer pointer so we can access the pixel shader constant buffer from within this class.
    result = device->CreateBuffer(&sunlightBufferDesc, NULL, &sunlight_buffer_);
    if (FAILED(result))
    {
        Logger::Get().Log("Failed to create sunlight buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
        return false;
    }
 
    Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
 
    return true;
}
 
 
 
 
void celshade_class::shutdown_shader()
{
    Logger::Get().Log("Shutting down SunLightShaderClass", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
 
    // Release the light constant buffers.
    if (sunlight_color_buffer_)
    {
        sunlight_color_buffer_->Release();
        sunlight_color_buffer_ = 0;
    }
 
    if (sunlight_position_buffer_)
    {
        sunlight_position_buffer_->Release();
        sunlight_position_buffer_ = 0;
    }
 
    // Release the light constant buffer.
    if (sunlight_buffer_)
    {
        sunlight_buffer_->Release();
        sunlight_buffer_ = 0;
    }
 
    // Release the camera constant buffer.
    if (camera_buffer_)
    {
        camera_buffer_->Release();
        camera_buffer_ = 0;
    }
 
    // Release the matrix constant buffer.
    if (matrix_buffer_)
    {
        matrix_buffer_->Release();
        matrix_buffer_ = 0;
    }
 
    // Release the sampler state.
    if (sample_state_)
    {
        sample_state_->Release();
        sample_state_ = 0;
    }
 
    // Release the layout.
    if (layout_)
    {
        layout_->Release();
        layout_ = 0;
    }
 
    // Release the pixel shader.
    if (pixel_shader_)
    {
        pixel_shader_->Release();
        pixel_shader_ = 0;
    }
 
    // Release the vertex shader.
    if (vertex_shader_)
    {
        vertex_shader_->Release();
        vertex_shader_ = 0;
    }
 
    Logger::Get().Log("SunLightShaderClass shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
 
    return;
}
 
 
void celshade_class::output_shader_error_message(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename)
{
    char* compileErrors;
    unsigned __int64 bufferSize, i;
    ofstream fout;
 
 
    // Get a pointer to the error message text buffer.
    compileErrors = (char*)(errorMessage->GetBufferPointer());
 
    // Get the length of the message.
    bufferSize = errorMessage->GetBufferSize();
 
    // Open a file to write the error message to.
    fout.open("shader-error.txt");
 
    // Write out the error message.
    for (i = 0; i < bufferSize; i++)
    {
        fout << compileErrors[i];
    }
 
    // Close the file.
    fout.close();
 
    // Release the error message.
    errorMessage->Release();
    errorMessage = 0;
 
    // Pop a message up on the screen to notify the user to check the text file for compile errors.
    MessageBox(hwnd, L"Error compiling shader.  Check shader-error.txt for message.", shaderFilename, MB_OK);
 
    return;
}
 
 
bool celshade_class::set_shader_parameters(
    ID3D11DeviceContext* device_context,
    XMMATRIX world_matrix,
    XMMATRIX view_matrix,
    XMMATRIX projection_matrix,
    ID3D11ShaderResourceView* texture,
    XMFLOAT4 ambient_color,
    XMFLOAT4 diffuse_color,
    XMFLOAT3 light_direction,
    float sun_intensity
    )
{
    HRESULT result;
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    matrix_buffer_type* dataPtr;
    camera_buffer_type* dataPtr2;
    sun_light_buffer_type* dataPtr3;
    unsigned int bufferNumber;
 
    // Transpose the matrices to prepare them for the shader.
    world_matrix = XMMatrixTranspose(world_matrix);
    view_matrix = XMMatrixTranspose(view_matrix);
    projection_matrix = XMMatrixTranspose(projection_matrix);
 
    // Lock the constant buffer so it can be written to.
    result = device_context->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
    if (FAILED(result))
    {
        return false;
    }
 
    // Get a pointer to the data in the constant buffer.
    dataPtr = (matrix_buffer_type*)mappedResource.pData;
 
    // Copy the matrices into the constant buffer.
    dataPtr->world = world_matrix;
    dataPtr->view = view_matrix;
    dataPtr->projection = projection_matrix;
 
    // Unlock the constant buffer.
    device_context->Unmap(matrix_buffer_, 0);
 
    // Set the position of the constant buffer in the vertex shader.
    bufferNumber = 0;
 
    // Finally set the constant buffer in the vertex shader with the updated values.
    device_context->VSSetConstantBuffers(bufferNumber, 1, &matrix_buffer_);
 
    // Lock the sunlight constant buffer so it can be written to.
    result = device_context->Map(sunlight_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
    if (FAILED(result))
    {
        return false;
    }
 
    // Get a pointer to the data in the constant buffer.
    dataPtr3 = (sun_light_buffer_type*)mappedResource.pData;
 
    // Copy the lighting variables into the constant buffer.
    dataPtr3->ambient_color = ambient_color;
    dataPtr3->diffuse_color = diffuse_color;
    dataPtr3->sun_direction = light_direction;
    dataPtr3->intensity = sun_intensity;
 
    // Unlock the constant buffer.
    device_context->Unmap(sunlight_buffer_, 0);
 
    // Set the position of the sunlight constant buffer in the pixel shader.
    bufferNumber = 0;
    
    // Finally set the sunlight constant buffer in the pixel shader with the updated values.
    device_context->PSSetConstantBuffers(bufferNumber, 1, &sunlight_buffer_);
 
    // Set shader texture resource in the pixel shader.
    device_context->PSSetShaderResources(0, 1, &texture);
 
    return true;
}
 
void celshade_class::render_shader(ID3D11DeviceContext* deviceContext, int indexCount)
{
    // Set the vertex input layout.
    deviceContext->IASetInputLayout(layout_);
 
    // Set the vertex and pixel shaders that will be used to render this triangle.
    deviceContext->VSSetShader(vertex_shader_, NULL, 0);
    deviceContext->PSSetShader(pixel_shader_, NULL, 0);
 
    // Set the sampler state in the pixel shader.
    deviceContext->PSSetSamplers(0, 1, &sample_state_);
 
    // render the triangle.
    deviceContext->DrawIndexed(indexCount, 0, 0);
 
    return;
}