{

m_vertexShader = 0;

m_pixelShader = 0;

m_layout = 0;

m_matrixBuffer = 0;

m_cameraBuffer = 0;

m_lightBuffer = 0;

{

bool result;

// Initialize the vertex and pixel shaders.

//result = InitializeShader(device, hwnd, L"./DirectionalLight/LightingAmbient.fx", L"./DirectionalLight/LightingAmbient.fx");

//result = InitializeShader(device, hwnd, L"./DirectionalLight/LightingDiffuse.fx", L"./DirectionalLight/LightingDiffuse.fx");

result = InitializeShader(device, hwnd, L"./DirectionalLight/LightingPhongDiffuse.fx", L"./DirectionalLight/LightingPhongDiffuse.fx");

//result = InitializeShader(device, hwnd, L"./DirectionalLight/LightingPhongSpecular.fx", L"./DirectionalLight/LightingPhongSpecular.fx");

//result = InitializeShader(device, hwnd, L"./DirectionalLight/LightingSpecular.fx", L"./DirectionalLight/LightingSpecular.fx");

//result = InitializeShader(device, hwnd, L"./PointLight/LightingDiffuse.fx", L"./PointLight/LightingDiffuse.fx");

//result = InitializeShader(device, hwnd, L"./PointLight/LightingPhongDiffuse.fx", L"./PointLight/LightingPhongDiffuse.fx");

//result = InitializeShader(device, hwnd, L"./PointLight/LightingPhongSpecular.fx", L"./PointLight/LightingPhongSpecular.fx");

//result = InitializeShader(device, hwnd, L"./PointLight/LightingSpecular.fx", L"./PointLight/LightingSpecular.fx");

//result = InitializeShader(device, hwnd, L"./SpotLight/LightingDiffuse.fx", L"./SpotLight/LightingDiffuse.fx");

//result = InitializeShader(device, hwnd, L"./SpotLight/LightingPhongDiffuse.fx", L"./SpotLight/LightingPhongDiffuse.fx");

//result = InitializeShader(device, hwnd, L"./SpotLight/LightingPhongSpecular.fx", L"./SpotLight/LightingPhongSpecular.fx");

//result = InitializeShader(device, hwnd, L"./SpotLight/LightingSpecular.fx", L"./SpotLight/LightingSpecular.fx");

if(!result)

{

return false;

}

return true;

{

// Shutdown the vertex and pixel shaders as well as the related objects.

ShutdownShader();

return;

D3DXMATRIX& projectionMatrix, D3DXVECTOR3 cameraPosition, MaterialBufferType material,LightColorBufferType light)

{

bool result;

// Set the shader parameters that it will use for rendering.

result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, cameraPosition, material,light);

if(!result)

{

return false;

}

// Now render the prepared buffers with the shader.

RenderShader(deviceContext);

return true;

{

HRESULT result;

ID3D10Blob* errorMessage;

ID3D10Blob* vertexShaderBuffer;

ID3D10Blob* pixelShaderBuffer;

unsigned int numElements;

D3D11_BUFFER_DESC matrixBufferDesc;

D3D11_BUFFER_DESC cameraBufferDesc;

D3D11_BUFFER_DESC lightBufferDesc;

// 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, "VS_Main", "vs_4_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, "PS_Main", "ps_4_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);

result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), 0, &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.

D3D11_INPUT_ELEMENT_DESC polygonLayout[2];

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 = "NORMAL";

polygonLayout[1].SemanticIndex = 0;

polygonLayout[1].Format = DXGI_FORMAT_R32G32B32_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 = "COLOR";

polygonLayout[2].SemanticIndex = 0;

polygonLayout[2].Format = DXGI_FORMAT_R32G32B32A32_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(), &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;

}

// Setup the description of the dynamic lighting constant buffer that is in the vertex shader.

cameraBufferDesc.Usage = D3D11_USAGE_DYNAMIC;

cameraBufferDesc.ByteWidth = sizeof(CameraBufferType);

cameraBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;

cameraBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;

cameraBufferDesc.MiscFlags = 0;

cameraBufferDesc.StructureByteStride = 0;

// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.

result = device->CreateBuffer(&cameraBufferDesc, NULL, &m_cameraBuffer);

if(FAILED(result))

{

return false;

}

// Setup the description of the dynamic lighting constant buffer that is in the vertex shader.

lightBufferDesc.Usage = D3D11_USAGE_DYNAMIC;

lightBufferDesc.ByteWidth = sizeof(MaterialBufferType);

lightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;

lightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;

lightBufferDesc.MiscFlags = 0;

lightBufferDesc.StructureByteStride = 0;

// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.

result = device->CreateBuffer(&lightBufferDesc, NULL, &m_lightBuffer);

if(FAILED(result))

{

return false;

}

return true;

{

// Release the matrix constant buffer.

if(m_matrixBuffer)

{

m_matrixBuffer->Release();

m_matrixBuffer = 0;

}

if(m_cameraBuffer)

{

m_cameraBuffer->Release();

m_cameraBuffer = 0;

}

if(m_lightBuffer)

{

m_lightBuffer->Release();

m_lightBuffer = 0;

}

// Release the layout.

if(m_layout)

{

m_layout->Release();

m_layout = 0;

}

// Release the pixel shader.

if(m_pixelShader)

{

m_pixelShader->Release();

m_pixelShader = 0;

}

// Release the vertex shader.

if(m_vertexShader)

{

m_vertexShader->Release();

m_vertexShader = 0;

}

return;

{

char* compileErrors;

unsigned long 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;

D3DXMATRIX& projectionMatrix, D3DXVECTOR3 cameraPosition, MaterialBufferType material, LightColorBufferType light)

{

HRESULT result;

D3D11_MAPPED_SUBRESOURCE mappedResource;

MatrixBufferType* dataPtr;

CameraBufferType* CdataPtr;

MaterialBufferType* LdataPtr;

unsigned int bufferNumber;

D3DXMATRIX trans_WorldMatrix, trans_ViewMatrix, trans_ProjectionMatrix;

// Transpose the matrices to prepare them for the shader.

D3DXMatrixTranspose(&trans_WorldMatrix, &worldMatrix);

D3DXMatrixTranspose(&trans_ViewMatrix, &viewMatrix);

D3DXMatrixTranspose(&trans_ProjectionMatrix, &projectionMatrix);

//

// Lock the constant matrix buffer so it can be written to.

//

result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);

if(FAILED(result))

{

return false;

}

// Get a pointer to the data in the constant buffer.

dataPtr = (MatrixBufferType*)mappedResource.pData;

// Copy the matrices into the constant buffer.

dataPtr->world = trans_WorldMatrix;

dataPtr->view = trans_ViewMatrix;

dataPtr->projection = trans_ProjectionMatrix;

// Unlock the constant buffer.

deviceContext->Unmap(m_matrixBuffer, 0);

// Set the position of the constant buffer in the vertex shader.

bufferNumber = 0;

// Finanly set the constant buffer in the vertex shader with the updated values.

deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);

//

// Lock the constant camera buffer so it can be written to.

//

result = deviceContext->Map(m_cameraBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);

if(FAILED(result))

{

return false;

}

// Get a pointer to the data in the constant buffer.

CdataPtr = (CameraBufferType*)mappedResource.pData;

// Copy the matrices into the constant buffer.

CdataPtr->cameraPos = cameraPosition;

CdataPtr->LightPosition1 = light.myLightPosition;

CdataPtr->LightDifuse = light.myLightDifuseColor;

CdataPtr->LightAmbient = light.myLightAmbientColor;

CdataPtr->LightAtt = light.myLightAtt;

CdataPtr->LightDir = light.myLightDir;

CdataPtr->LightCone = light.myLightCone;

CdataPtr->LightRange = light.myLightRange;

// Unlock the constant buffer.

deviceContext->Unmap(m_cameraBuffer, 0);

// Set the position of the constant buffer in the vertex shader.

bufferNumber = 1;

deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_cameraBuffer);

//

// Lock the constant light buffer so it can be written to.

//

result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);

if(FAILED(result))

{

return false;

}

// Get a pointer to the data in the light constant buffer.

LdataPtr = (MaterialBufferType*)mappedResource.pData;

// Copy the lighting variables into the light constant buffer.

LdataPtr->ambientColor = material.ambientColor;

LdataPtr->diffuseColor = material.diffuseColor;

LdataPtr->specularColor = material.specularColor;

// Unlock the light constant buffer.

deviceContext->Unmap(m_lightBuffer, 0);

// Set the position of the light constant buffer in the pixel shader.

bufferNumber = 0;

// Finally set the light constant buffer in the pixel shader with the updated values.

deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer);

return true;

{

// Set the vertex input layout.

deviceContext->IASetInputLayout(m_layout);

// Set the vertex and pixel shaders that will be used to render this triangle.

deviceContext->VSSetShader(m_vertexShader, NULL, 0);

deviceContext->PSSetShader(m_pixelShader, NULL, 0);

return;

}