merge 3d diffuse lighting

enginecustom/light.ps

@@ -8,12 +8,11 @@
 /////////////
 Texture2D shaderTexture : register(t0);
 SamplerState SampleType : register(s0);
-
 cbuffer LightBuffer
 {
     float4 diffuseColor;
     float3 lightDirection;
-	float padding;
+    float padding;
 };
 
 
@@ -24,7 +23,7 @@ struct PixelInputType
 {
     float4 position : SV_POSITION;
     float2 tex : TEXCOORD0;
-	float3 normal : NORMAL;
+    float3 normal : NORMAL;
 };
 
 
@@ -33,29 +32,26 @@ struct PixelInputType
 ////////////////////////////////////////////////////////////////////////////////
 float4 LightPixelShader(PixelInputType input) : SV_TARGET
 {
-	float4 textureColor;
+    float4 textureColor;
-	float3 lightDir;
+    float3 lightDir;
-	float lightIntensity;
+    float lightIntensity;
-	float4 color;
+    float4 color;
 
 
-	// Sample the pixel color from the texture using the sampler at this texture coordinate location.
+    // Sample the pixel color from the texture using the sampler at this texture coordinate location.
-	textureColor = shaderTexture.Sample(SampleType, input.tex);
+    textureColor = shaderTexture.Sample(SampleType, input.tex);
 
-	// Invert the light direction for calculations.
+    // Invert the light direction for calculations.
     lightDir = -lightDirection;
 
     // Calculate the amount of light on this pixel.
     lightIntensity = saturate(dot(input.normal, lightDir));
 
-    // Change the diffuse color to red (0, 1, 0)
-    float3 greenDiffuseColor = float3(1, 0, 0);
-
     // Determine the final amount of diffuse color based on the diffuse color combined with the light intensity.
     color = saturate(diffuseColor * lightIntensity);
 
     // Multiply the texture pixel and the final diffuse color to get the final pixel color result.
-	color = color * textureColor;
+    color = color * textureColor;
 
-	return color;
+    return color;
-}
+}

enginecustom/light.vs

@@ -8,12 +8,11 @@
 /////////////
 cbuffer MatrixBuffer
 {
-	matrix worldMatrix;
+    matrix worldMatrix;
-	matrix viewMatrix;
+    matrix viewMatrix;
-	matrix projectionMatrix;
+    matrix projectionMatrix;
 };
 
-
 //////////////
 // TYPEDEFS //
 //////////////
@@ -21,14 +20,14 @@ struct VertexInputType
 {
     float4 position : POSITION;
     float2 tex : TEXCOORD0;
-	float3 normal : NORMAL;
+    float3 normal : NORMAL;
 };
 
 struct PixelInputType
 {
     float4 position : SV_POSITION;
     float2 tex : TEXCOORD0;
-	float3 normal : NORMAL;
+    float3 normal : NORMAL;
 };
 
 
@@ -40,18 +39,18 @@ PixelInputType LightVertexShader(VertexInputType input)
     PixelInputType output;
     
 
-	// Change the position vector to be 4 units for proper matrix calculations.
+    // Change the position vector to be 4 units for proper matrix calculations.
     input.position.w = 1.0f;
 
-	// Calculate the position of the vertex against the world, view, and projection matrices.
+    // Calculate the position of the vertex against the world, view, and projection matrices.
     output.position = mul(input.position, worldMatrix);
     output.position = mul(output.position, viewMatrix);
     output.position = mul(output.position, projectionMatrix);
     
-	// Store the texture coordinates for the pixel shader.
+    // Store the texture coordinates for the pixel shader.
-	output.tex = input.tex;
+    output.tex = input.tex;
-    
+
-	// Calculate the normal vector against the world matrix only.
+    // Calculate the normal vector against the world matrix only.
     output.normal = mul(input.normal, (float3x3)worldMatrix);
 	
     // Normalize the normal vector.

enginecustom/lightclass.cpp

@@ -21,25 +21,25 @@ LightClass::~LightClass()
 
 void LightClass::SetDiffuseColor(float red, float green, float blue, float alpha)
 {
-	m_diffuseColor = XMFLOAT4(red, green, blue, alpha);
+    m_diffuseColor = XMFLOAT4(red, green, blue, alpha);
-	return;
+    return;
 }
 
 
 void LightClass::SetDirection(float x, float y, float z)
 {
-	m_direction = XMFLOAT3(x, y, z);
+    m_direction = XMFLOAT3(x, y, z);
-	return;
+    return;
 }
 
 
 XMFLOAT4 LightClass::GetDiffuseColor()
 {
-	return m_diffuseColor;
+    return m_diffuseColor;
 }
 
 
 XMFLOAT3 LightClass::GetDirection()
 {
-	return m_direction;
+    return m_direction;
 }

enginecustom/lightclass.h

@@ -1,3 +1,4 @@
+#pragma once
 ////////////////////////////////////////////////////////////////////////////////
 // Filename: lightclass.h
 ////////////////////////////////////////////////////////////////////////////////
@@ -18,19 +19,19 @@ using namespace DirectX;
 class LightClass
 {
 public:
-	LightClass();
+    LightClass();
-	LightClass(const LightClass&);
+    LightClass(const LightClass&);
-	~LightClass();
+    ~LightClass();
+
+    void SetDirection(float, float, float);
+    void SetDiffuseColor(float, float, float, float);
+
+    XMFLOAT3 GetDirection();
+    XMFLOAT4 GetDiffuseColor();
 
-	void SetDiffuseColor(float, float, float, float);
-	void SetDirection(float, float, float);
-	
-	XMFLOAT4 GetDiffuseColor();
-	XMFLOAT3 GetDirection();
-	
 private:
-	XMFLOAT4 m_diffuseColor;
+    XMFLOAT4 m_diffuseColor;
-	XMFLOAT3 m_direction;
+    XMFLOAT3 m_direction;
 };
 
 #endif

enginecustom/lightshaderclass.cpp

@@ -6,12 +6,12 @@
 
 LightShaderClass::LightShaderClass()
 {
-	m_vertexShader = 0;
+    m_vertexShader = 0;
-	m_pixelShader = 0;
+    m_pixelShader = 0;
-	m_layout = 0;
+    m_layout = 0;
-	m_sampleState = 0;
+    m_sampleState = 0;
-	m_matrixBuffer = 0;
+    m_matrixBuffer = 0;
-	m_lightBuffer = 0;
+    m_lightBuffer = 0;
 }
 
 
@@ -27,179 +27,179 @@ LightShaderClass::~LightShaderClass()
 
 bool LightShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
 {
-	wchar_t vsFilename[128];
+    wchar_t vsFilename[128];
-	wchar_t psFilename[128];
+    wchar_t psFilename[128];
-	int error;
+    int error;
-	bool result;
+    bool result;
 
+    // Set the filename of the vertex shader.
+    error = wcscpy_s(vsFilename, 128, L"./Light.vs");
+    if (error != 0)
+    {
+        return false;
+    }
 
-	// Set the filename of the vertex shader.
+    // Set the filename of the pixel shader.
-	error = wcscpy_s(vsFilename, 128, L"../enginecustom/light.vs");
+    error = wcscpy_s(psFilename, 128, L"./Light.ps");
-	if (error != 0)
+    if (error != 0)
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
-	// Set the filename of the pixel shader.
+    // Initialize the vertex and pixel shaders.
-	error = wcscpy_s(psFilename, 128, L"../enginecustom/light.ps");
+    result = InitializeShader(device, hwnd, vsFilename, psFilename);
-	if (error != 0)
+    if (!result)
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
-	// Initialize the vertex and pixel shaders.
+    return true;
-	result = InitializeShader(device, hwnd, vsFilename, psFilename);
-	if(!result)
-	{
-		return false;
-	}
-
-	return true;
 }
 
 
 void LightShaderClass::Shutdown()
 {
-	// Shutdown the vertex and pixel shaders as well as the related objects.
+    // Shutdown the vertex and pixel shaders as well as the related objects.
-	ShutdownShader();
+    ShutdownShader();
 
-	return;
+    return;
 }
 
-
 bool LightShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, XMMATRIX projectionMatrix,
-							  ID3D11ShaderResourceView* texture, XMFLOAT3 lightDirection, XMFLOAT4 diffuseColor)
+    ID3D11ShaderResourceView* texture, XMFLOAT3 lightDirection, XMFLOAT4 diffuseColor)
 {
-	bool result;
+    bool result;
 
 
-	// Set the shader parameters that it will use for rendering.
+    // Set the shader parameters that it will use for rendering.
-	result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, lightDirection, diffuseColor);
+    result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, lightDirection, diffuseColor);
-	if(!result)
+    if (!result)
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
-	// Now render the prepared buffers with the shader.
+    // Now render the prepared buffers with the shader.
-	RenderShader(deviceContext, indexCount);
+    RenderShader(deviceContext, indexCount);
 
-	return true;
+    return true;
 }
 
 
 bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
 {
-	HRESULT result;
+    HRESULT result;
-	ID3D10Blob* errorMessage;
+    ID3D10Blob* errorMessage;
-	ID3D10Blob* vertexShaderBuffer;
+    ID3D10Blob* vertexShaderBuffer;
-	ID3D10Blob* pixelShaderBuffer;
+    ID3D10Blob* pixelShaderBuffer;
-	D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
+
-	unsigned int numElements;
+    D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
+    unsigned int numElements;
     D3D11_SAMPLER_DESC samplerDesc;
-	D3D11_BUFFER_DESC matrixBufferDesc;
+    D3D11_BUFFER_DESC matrixBufferDesc;
-	D3D11_BUFFER_DESC lightBufferDesc;
+
+    D3D11_BUFFER_DESC lightBufferDesc;
 
 
-	// Initialize the pointers this function will use to null.
+    // Initialize the pointers this function will use to null.
-	errorMessage = 0;
+    errorMessage = 0;
-	vertexShaderBuffer = 0;
+    vertexShaderBuffer = 0;
-	pixelShaderBuffer = 0;
+    pixelShaderBuffer = 0;
 
     // Compile the vertex shader code.
-	result = D3DCompileFromFile(vsFilename, NULL, NULL, "LightVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &vertexShaderBuffer, &errorMessage);
+    result = D3DCompileFromFile(vsFilename, NULL, NULL, "LightVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &vertexShaderBuffer, &errorMessage);
-	if(FAILED(result))
+    if (FAILED(result))
-	{
+    {
-		// If the shader failed to compile it should have writen something to the error message.
+        // If the shader failed to compile it should have writen something to the error message.
-		if(errorMessage)
+        if (errorMessage)
-		{
+        {
-			OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
+            OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
-		}
+        }
-		// If there was nothing in the error message then it simply could not find the shader file itself.
+        // If there was nothing in the error message then it simply could not find the shader file itself.
-		else
+        else
-		{
+        {
-			MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
+            MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
-		}
+        }
 
-		return false;
+        return false;
-	}
+    }
 
     // Compile the pixel shader code.
-	result = D3DCompileFromFile(psFilename, NULL, NULL, "LightPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &pixelShaderBuffer, &errorMessage);
+    result = D3DCompileFromFile(psFilename, NULL, NULL, "LightPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &pixelShaderBuffer, &errorMessage);
-	if(FAILED(result))
+    if (FAILED(result))
-	{
+    {
-		// If the shader failed to compile it should have writen something to the error message.
+        // If the shader failed to compile it should have writen something to the error message.
-		if(errorMessage)
+        if (errorMessage)
-		{
+        {
-			OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
+            OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
-		}
+        }
-		// If there was nothing in the error message then it simply could not find the file itself.
+        // If there was nothing in the error message then it simply could not find the file itself.
-		else
+        else
-		{
+        {
-			MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
+            MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
-		}
+        }
 
-		return false;
+        return false;
-	}
+    }
 
     // Create the vertex shader from the buffer.
     result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
-	if(FAILED(result))
+    if (FAILED(result))
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
     // Create the pixel shader from the buffer.
     result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
-	if(FAILED(result))
+    if (FAILED(result))
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
-	// Create the vertex input layout description.
+    // Create the vertex input layout description.
-	// This setup needs to match the VertexType stucture in the ModelClass and in the shader.
+    // This setup needs to match the VertexType stucture in the ModelClass and in the shader.
-	polygonLayout[0].SemanticName = "POSITION";
+    polygonLayout[0].SemanticName = "POSITION";
-	polygonLayout[0].SemanticIndex = 0;
+    polygonLayout[0].SemanticIndex = 0;
-	polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
+    polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
-	polygonLayout[0].InputSlot = 0;
+    polygonLayout[0].InputSlot = 0;
-	polygonLayout[0].AlignedByteOffset = 0;
+    polygonLayout[0].AlignedByteOffset = 0;
-	polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
+    polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
-	polygonLayout[0].InstanceDataStepRate = 0;
+    polygonLayout[0].InstanceDataStepRate = 0;
 
-	polygonLayout[1].SemanticName = "TEXCOORD";
+    polygonLayout[1].SemanticName = "TEXCOORD";
-	polygonLayout[1].SemanticIndex = 0;
+    polygonLayout[1].SemanticIndex = 0;
-	polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
+    polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
-	polygonLayout[1].InputSlot = 0;
+    polygonLayout[1].InputSlot = 0;
-	polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
+    polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
-	polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
+    polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
-	polygonLayout[1].InstanceDataStepRate = 0;
+    polygonLayout[1].InstanceDataStepRate = 0;
 
-	polygonLayout[2].SemanticName = "NORMAL";
+    polygonLayout[2].SemanticName = "NORMAL";
-	polygonLayout[2].SemanticIndex = 0;
+    polygonLayout[2].SemanticIndex = 0;
-	polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
+    polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
-	polygonLayout[2].InputSlot = 0;
+    polygonLayout[2].InputSlot = 0;
-	polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
+    polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
-	polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
+    polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
-	polygonLayout[2].InstanceDataStepRate = 0;
+    polygonLayout[2].InstanceDataStepRate = 0;
 
-	// Get a count of the elements in the layout.
+    // Get a count of the elements in the layout.
     numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
 
-	// Create the vertex input layout.
+    // Create the vertex input layout.
-	result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), 
+    result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(),
-		                               &m_layout);
+        &m_layout);
-	if(FAILED(result))
+    if (FAILED(result))
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
-	// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
+    // Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
-	vertexShaderBuffer->Release();
+    vertexShaderBuffer->Release();
-	vertexShaderBuffer = 0;
+    vertexShaderBuffer = 0;
 
-	pixelShaderBuffer->Release();
+    pixelShaderBuffer->Release();
-	pixelShaderBuffer = 0;
+    pixelShaderBuffer = 0;
 
-	// Create a texture sampler state description.
+    // 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;
@@ -208,222 +208,221 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
     samplerDesc.MaxAnisotropy = 1;
     samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
     samplerDesc.BorderColor[0] = 0;
-	samplerDesc.BorderColor[1] = 0;
+    samplerDesc.BorderColor[1] = 0;
-	samplerDesc.BorderColor[2] = 0;
+    samplerDesc.BorderColor[2] = 0;
-	samplerDesc.BorderColor[3] = 0;
+    samplerDesc.BorderColor[3] = 0;
     samplerDesc.MinLOD = 0;
     samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
 
-	// Create the texture sampler state.
+    // Create the texture sampler state.
     result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
-	if(FAILED(result))
+    if (FAILED(result))
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
-	// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
+    // 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.ByteWidth = sizeof(MatrixBufferType);
     matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
     matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
     matrixBufferDesc.MiscFlags = 0;
-	matrixBufferDesc.StructureByteStride = 0;
+    matrixBufferDesc.StructureByteStride = 0;
 
-	// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
+    // 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);
+    result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
-	if(FAILED(result))
+    if (FAILED(result))
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
-	// Setup the description of the light dynamic constant buffer that is in the pixel shader.
+    // Setup the description of the light dynamic constant buffer that is in the pixel shader.
-	// Note that ByteWidth always needs to be a multiple of 16 if using D3D11_BIND_CONSTANT_BUFFER or CreateBuffer will fail.
+   // Note that ByteWidth always needs to be a multiple of 16 if using D3D11_BIND_CONSTANT_BUFFER or CreateBuffer will fail.
-	lightBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+    lightBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
-	lightBufferDesc.ByteWidth = sizeof(LightBufferType);
+    lightBufferDesc.ByteWidth = sizeof(LightBufferType);
-	lightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+    lightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
-	lightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+    lightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
-	lightBufferDesc.MiscFlags = 0;
+    lightBufferDesc.MiscFlags = 0;
-	lightBufferDesc.StructureByteStride = 0;
+    lightBufferDesc.StructureByteStride = 0;
 
-	// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
+    // 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);
+    result = device->CreateBuffer(&lightBufferDesc, NULL, &m_lightBuffer);
-	if(FAILED(result))
+    if (FAILED(result))
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
-	return true;
+    return true;
 }
 
 
 void LightShaderClass::ShutdownShader()
 {
-	// Release the light constant buffer.
+    // Release the light constant buffer.
-	if(m_lightBuffer)
+    if (m_lightBuffer)
-	{
+    {
-		m_lightBuffer->Release();
+        m_lightBuffer->Release();
-		m_lightBuffer = 0;
+        m_lightBuffer = 0;
-	}
+    }
 
-	// Release the matrix constant buffer.
+    // Release the matrix constant buffer.
-	if(m_matrixBuffer)
+    if (m_matrixBuffer)
-	{
+    {
-		m_matrixBuffer->Release();
+        m_matrixBuffer->Release();
-		m_matrixBuffer = 0;
+        m_matrixBuffer = 0;
-	}
+    }
 
-	// Release the sampler state.
+    // Release the sampler state.
-	if(m_sampleState)
+    if (m_sampleState)
-	{
+    {
-		m_sampleState->Release();
+        m_sampleState->Release();
-		m_sampleState = 0;
+        m_sampleState = 0;
-	}
+    }
 
-	// Release the layout.
+    // Release the layout.
-	if(m_layout)
+    if (m_layout)
-	{
+    {
-		m_layout->Release();
+        m_layout->Release();
-		m_layout = 0;
+        m_layout = 0;
-	}
+    }
 
-	// Release the pixel shader.
+    // Release the pixel shader.
-	if(m_pixelShader)
+    if (m_pixelShader)
-	{
+    {
-		m_pixelShader->Release();
+        m_pixelShader->Release();
-		m_pixelShader = 0;
+        m_pixelShader = 0;
-	}
+    }
 
-	// Release the vertex shader.
+    // Release the vertex shader.
-	if(m_vertexShader)
+    if (m_vertexShader)
-	{
+    {
-		m_vertexShader->Release();
+        m_vertexShader->Release();
-		m_vertexShader = 0;
+        m_vertexShader = 0;
-	}
+    }
 
-	return;
+    return;
 }
 
 
 void LightShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename)
 {
-	char* compileErrors;
+    char* compileErrors;
-	unsigned __int64 bufferSize, i;
+    unsigned __int64 bufferSize, i;
-	ofstream fout;
+    ofstream fout;
 
 
-	// Get a pointer to the error message text buffer.
+    // Get a pointer to the error message text buffer.
-	compileErrors = (char*)(errorMessage->GetBufferPointer());
+    compileErrors = (char*)(errorMessage->GetBufferPointer());
 
-	// Get the length of the message.
+    // Get the length of the message.
-	bufferSize = errorMessage->GetBufferSize();
+    bufferSize = errorMessage->GetBufferSize();
 
-	// Open a file to write the error message to.
+    // Open a file to write the error message to.
-	fout.open("shader-error.txt");
+    fout.open("shader-error.txt");
 
-	// Write out the error message.
+    // Write out the error message.
-	for(i=0; i<bufferSize; i++)
+    for (i = 0; i < bufferSize; i++)
-	{
+    {
-		fout << compileErrors[i];
+        fout << compileErrors[i];
-	}
+    }
 
-	// Close the file.
+    // Close the file.
-	fout.close();
+    fout.close();
 
-	// Release the error message.
+    // Release the error message.
-	errorMessage->Release();
+    errorMessage->Release();
-	errorMessage = 0;
+    errorMessage = 0;
 
-	// Pop a message up on the screen to notify the user to check the text file for compile errors.
+    // 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);
+    MessageBox(hwnd, L"Error compiling shader.  Check shader-error.txt for message.", shaderFilename, MB_OK);
 
-	return;
+    return;
 }
 
-
+bool LightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix, XMMATRIX projectionMatrix,
-bool LightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix, XMMATRIX projectionMatrix, 
+    ID3D11ShaderResourceView* texture, XMFLOAT3 lightDirection, XMFLOAT4 diffuseColor)
-										   ID3D11ShaderResourceView* texture, XMFLOAT3 lightDirection, XMFLOAT4 diffuseColor)
 {
-	HRESULT result;
+    HRESULT result;
     D3D11_MAPPED_SUBRESOURCE mappedResource;
-	unsigned int bufferNumber;
+    unsigned int bufferNumber;
-	MatrixBufferType* dataPtr;
+    MatrixBufferType* dataPtr;
-	LightBufferType* dataPtr2;
+    LightBufferType* dataPtr2;
 
 
-	// Transpose the matrices to prepare them for the shader.
+    // Transpose the matrices to prepare them for the shader.
-	worldMatrix = XMMatrixTranspose(worldMatrix);
+    worldMatrix = XMMatrixTranspose(worldMatrix);
-	viewMatrix = XMMatrixTranspose(viewMatrix);
+    viewMatrix = XMMatrixTranspose(viewMatrix);
-	projectionMatrix = XMMatrixTranspose(projectionMatrix);
+    projectionMatrix = XMMatrixTranspose(projectionMatrix);
 
-	// Lock the constant buffer so it can be written to.
+    // Lock the constant buffer so it can be written to.
-	result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+    result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
-	if(FAILED(result))
+    if (FAILED(result))
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
-	// Get a pointer to the data in the constant buffer.
+    // Get a pointer to the data in the constant buffer.
-	dataPtr = (MatrixBufferType*)mappedResource.pData;
+    dataPtr = (MatrixBufferType*)mappedResource.pData;
 
-	// Copy the matrices into the constant buffer.
+    // Copy the matrices into the constant buffer.
-	dataPtr->world = worldMatrix;
+    dataPtr->world = worldMatrix;
-	dataPtr->view = viewMatrix;
+    dataPtr->view = viewMatrix;
-	dataPtr->projection = projectionMatrix;
+    dataPtr->projection = projectionMatrix;
 
-	// Unlock the constant buffer.
+    // Unlock the constant buffer.
     deviceContext->Unmap(m_matrixBuffer, 0);
 
-	// Set the position of the constant buffer in the vertex shader.
+    // Set the position of the constant buffer in the vertex shader.
-	bufferNumber = 0;
+    bufferNumber = 0;
 
-	// Now set the constant buffer in the vertex shader with the updated values.
+    // Now set the constant buffer in the vertex shader with the updated values.
     deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);
 
-	// Set shader texture resource in the pixel shader.
+    // Set shader texture resource in the pixel shader.
-	deviceContext->PSSetShaderResources(0, 1, &texture);
+    deviceContext->PSSetShaderResources(0, 1, &texture);
 
-	// Lock the light constant buffer so it can be written to.
+    // Lock the light constant buffer so it can be written to.
-	result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+    result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
-	if(FAILED(result))
+    if (FAILED(result))
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
-	// Get a pointer to the data in the constant buffer.
+    // Get a pointer to the data in the constant buffer.
-	dataPtr2 = (LightBufferType*)mappedResource.pData;
+    dataPtr2 = (LightBufferType*)mappedResource.pData;
 
-	// Copy the lighting variables into the constant buffer.
+    // Copy the lighting variables into the constant buffer.
-	dataPtr2->diffuseColor = diffuseColor;
+    dataPtr2->diffuseColor = diffuseColor;
-	dataPtr2->lightDirection = lightDirection;
+    dataPtr2->lightDirection = lightDirection;
-	dataPtr2->padding = 0.0f;
+    dataPtr2->padding = 0.0f;
 
-	// Unlock the constant buffer.
+    // Unlock the constant buffer.
-	deviceContext->Unmap(m_lightBuffer, 0);
+    deviceContext->Unmap(m_lightBuffer, 0);
 
-	// Set the position of the light constant buffer in the pixel shader.
+    // Set the position of the light constant buffer in the pixel shader.
-	bufferNumber = 0;
+    bufferNumber = 0;
 
-	// Finally set the light constant buffer in the pixel shader with the updated values.
+    // Finally set the light constant buffer in the pixel shader with the updated values.
-	deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer);
+    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer);
 
-	return true;
+    return true;
 }
 
 
 void LightShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount)
 {
-	// Set the vertex input layout.
+    // Set the vertex input layout.
-	deviceContext->IASetInputLayout(m_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);
 
-	// Set the sampler state in the pixel shader.
+    // Set the sampler state in the pixel shader.
-	deviceContext->PSSetSamplers(0, 1, &m_sampleState);
+    deviceContext->PSSetSamplers(0, 1, &m_sampleState);
 
-	// Render the triangle.
+    // Render the triangle.
-	deviceContext->DrawIndexed(indexCount, 0, 0);
+    deviceContext->DrawIndexed(indexCount, 0, 0);
 
-	return;
+    return;
-}
+}

enginecustom/lightshaderclass.h

@@ -22,44 +22,44 @@ using namespace std;
 class LightShaderClass
 {
 private:
-	struct MatrixBufferType
+    struct MatrixBufferType
-	{
+    {
-		XMMATRIX world;
+        XMMATRIX world;
-		XMMATRIX view;
+        XMMATRIX view;
-		XMMATRIX projection;
+        XMMATRIX projection;
-	};
+    };
 
-	struct LightBufferType
+    struct LightBufferType
-	{
+    {
-		XMFLOAT4 diffuseColor;
+        XMFLOAT4 diffuseColor;
-		XMFLOAT3 lightDirection;
+        XMFLOAT3 lightDirection;
-		float padding;  // Added extra padding so structure is a multiple of 16 for CreateBuffer function requirements.
+        float padding;  // Added extra padding so structure is a multiple of 16 for CreateBuffer function requirements.
-	};
+    };
 
 public:
-	LightShaderClass();
+    LightShaderClass();
-	LightShaderClass(const LightShaderClass&);
+    LightShaderClass(const LightShaderClass&);
-	~LightShaderClass();
+    ~LightShaderClass();
 
-	bool Initialize(ID3D11Device*, HWND);
+    bool Initialize(ID3D11Device*, HWND);
-	void Shutdown();
+    void Shutdown();
-	bool Render(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT3, XMFLOAT4);
+    bool Render(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT3, XMFLOAT4);
 
 private:
-	bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*);
+    bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*);
-	void ShutdownShader();
+    void ShutdownShader();
-	void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*);
+    void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*);
 
-	bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT3, XMFLOAT4);
+    bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT3, XMFLOAT4);
-	void RenderShader(ID3D11DeviceContext*, int);
+    void RenderShader(ID3D11DeviceContext*, int);
 
 private:
-	ID3D11VertexShader* m_vertexShader;
+    ID3D11VertexShader* m_vertexShader;
-	ID3D11PixelShader* m_pixelShader;
+    ID3D11PixelShader* m_pixelShader;
-	ID3D11InputLayout* m_layout;
+    ID3D11InputLayout* m_layout;
-	ID3D11SamplerState* m_sampleState;
+    ID3D11SamplerState* m_sampleState;
-	ID3D11Buffer* m_matrixBuffer;
+    ID3D11Buffer* m_matrixBuffer;
-	ID3D11Buffer* m_lightBuffer;
+    ID3D11Buffer* m_lightBuffer;
 };
 
 #endif