diff --git a/enginecustom/Cameraclass.cpp b/enginecustom/Cameraclass.cpp new file mode 100644 index 0000000..0520dd2 --- /dev/null +++ b/enginecustom/Cameraclass.cpp @@ -0,0 +1,112 @@ +//////////////////////////////////////////////////////////////////////////////// +// Filename: cameraclass.cpp +//////////////////////////////////////////////////////////////////////////////// +#include "cameraclass.h" + +CameraClass::CameraClass() +{ + m_positionX = 0.0f; + m_positionY = 0.0f; + m_positionZ = 0.0f; + + m_rotationX = 0.0f; + m_rotationY = 0.0f; + m_rotationZ = 0.0f; +} + + +CameraClass::CameraClass(const CameraClass& other) +{ +} + + +CameraClass::~CameraClass() +{ +} + +void CameraClass::SetPosition(float x, float y, float z) +{ + m_positionX = x; + m_positionY = y; + m_positionZ = z; + return; +} + + +void CameraClass::SetRotation(float x, float y, float z) +{ + m_rotationX = x; + m_rotationY = y; + m_rotationZ = z; + return; +} + +XMFLOAT3 CameraClass::GetPosition() +{ + return XMFLOAT3(m_positionX, m_positionY, m_positionZ); +} + + +XMFLOAT3 CameraClass::GetRotation() +{ + return XMFLOAT3(m_rotationX, m_rotationY, m_rotationZ); +} + +void CameraClass::Render() +{ + XMFLOAT3 up, position, lookAt; + XMVECTOR upVector, positionVector, lookAtVector; + float yaw, pitch, roll; + XMMATRIX rotationMatrix; + + + // Setup the vector that points upwards. + up.x = 0.0f; + up.y = 1.0f; + up.z = 0.0f; + + // Load it into a XMVECTOR structure. + upVector = XMLoadFloat3(&up); + + // Setup the position of the camera in the world. + position.x = m_positionX; + position.y = m_positionY; + position.z = m_positionZ; + + // Load it into a XMVECTOR structure. + positionVector = XMLoadFloat3(&position); + + // Setup where the camera is looking by default. + lookAt.x = 0.0f; + lookAt.y = 0.0f; + lookAt.z = 1.0f; + + // Load it into a XMVECTOR structure. + lookAtVector = XMLoadFloat3(&lookAt); + + // Set the yaw (Y axis), pitch (X axis), and roll (Z axis) rotations in radians. + pitch = m_rotationX * 0.0174532925f; + yaw = m_rotationY * 0.0174532925f; + roll = m_rotationZ * 0.0174532925f; + + // Create the rotation matrix from the yaw, pitch, and roll values. + rotationMatrix = XMMatrixRotationRollPitchYaw(pitch, yaw, roll); + + // Transform the lookAt and up vector by the rotation matrix so the view is correctly rotated at the origin. + lookAtVector = XMVector3TransformCoord(lookAtVector, rotationMatrix); + upVector = XMVector3TransformCoord(upVector, rotationMatrix); + + // Translate the rotated camera position to the location of the viewer. + lookAtVector = XMVectorAdd(positionVector, lookAtVector); + + // Finally create the view matrix from the three updated vectors. + m_viewMatrix = XMMatrixLookAtLH(positionVector, lookAtVector, upVector); + + return; +} + +void CameraClass::GetViewMatrix(XMMATRIX& viewMatrix) +{ + viewMatrix = m_viewMatrix; + return; +} \ No newline at end of file diff --git a/enginecustom/Cameraclass.h b/enginecustom/Cameraclass.h new file mode 100644 index 0000000..1c4cfed --- /dev/null +++ b/enginecustom/Cameraclass.h @@ -0,0 +1,40 @@ +//////////////////////////////////////////////////////////////////////////////// +// Filename: cameraclass.h +//////////////////////////////////////////////////////////////////////////////// +#ifndef _CAMERACLASS_H_ +#define _CAMERACLASS_H_ + + +////////////// +// INCLUDES // +////////////// +#include +using namespace DirectX; + + +//////////////////////////////////////////////////////////////////////////////// +// Class name: CameraClass +//////////////////////////////////////////////////////////////////////////////// +class CameraClass +{ +public: + CameraClass(); + CameraClass(const CameraClass&); + ~CameraClass(); + + void SetPosition(float, float, float); + void SetRotation(float, float, float); + + XMFLOAT3 GetPosition(); + XMFLOAT3 GetRotation(); + + void Render(); + void GetViewMatrix(XMMATRIX&); + +private: + float m_positionX, m_positionY, m_positionZ; + float m_rotationX, m_rotationY, m_rotationZ; + XMMATRIX m_viewMatrix; +}; + +#endif \ No newline at end of file diff --git a/enginecustom/Color.ps.hlsl b/enginecustom/Color.ps similarity index 100% rename from enginecustom/Color.ps.hlsl rename to enginecustom/Color.ps diff --git a/enginecustom/Color.vs.hlsl b/enginecustom/Color.vs similarity index 100% rename from enginecustom/Color.vs.hlsl rename to enginecustom/Color.vs diff --git a/enginecustom/Colorshaderclass.cpp b/enginecustom/Colorshaderclass.cpp index 43bc0f3..84abd56 100644 --- a/enginecustom/Colorshaderclass.cpp +++ b/enginecustom/Colorshaderclass.cpp @@ -30,14 +30,14 @@ bool ColorShaderClass::Initialize(ID3D11Device* device, HWND hwnd) // Set the filename of the vertex shader. - error = wcscpy_s(vsFilename, 128, L"../Engine/color.vs"); + error = wcscpy_s(vsFilename, 128, L"../enginecustom/Color.vs"); if (error != 0) { return false; } // Set the filename of the pixel shader. - error = wcscpy_s(psFilename, 128, L"../Engine/color.ps"); + error = wcscpy_s(psFilename, 128, L"../enginecustom/Color.ps"); if (error != 0) { return false; @@ -200,4 +200,127 @@ bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* } return true; +} + +void ColorShaderClass::ShutdownShader() +{ + // Release the matrix constant buffer. + if (m_matrixBuffer) + { + m_matrixBuffer->Release(); + m_matrixBuffer = 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; +} + +void ColorShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename) +{ + char* compileErrors; + unsigned long 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; +} + +bool ColorShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix, + XMMATRIX projectionMatrix) +{ + HRESULT result; + D3D11_MAPPED_SUBRESOURCE mappedResource; + MatrixBufferType* dataPtr; + unsigned int bufferNumber; + + // Transpose the matrices to prepare them for the shader. + worldMatrix = XMMatrixTranspose(worldMatrix); + viewMatrix = XMMatrixTranspose(viewMatrix); + projectionMatrix = XMMatrixTranspose(projectionMatrix); + + // Lock the constant 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 = worldMatrix; + dataPtr->view = viewMatrix; + dataPtr->projection = 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); + + return true; +} + +void ColorShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount) +{ + // 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); + + // Render the triangle. + deviceContext->DrawIndexed(indexCount, 0, 0); + + return; } \ No newline at end of file diff --git a/enginecustom/applicationclass.cpp b/enginecustom/applicationclass.cpp index 1751adc..a28c4a7 100644 --- a/enginecustom/applicationclass.cpp +++ b/enginecustom/applicationclass.cpp @@ -1,9 +1,15 @@ +//////////////////////////////////////////////////////////////////////////////// +// Filename: applicationclass.cpp +//////////////////////////////////////////////////////////////////////////////// #include "applicationclass.h" ApplicationClass::ApplicationClass() { m_Direct3D = 0; + m_Camera = 0; + m_Model = 0; + m_ColorShader = 0; } @@ -31,12 +37,62 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) MessageBox(hwnd, L"Could not initialize Direct3D", L"Error", MB_OK); return false; } + + // Create the camera object. + m_Camera = new CameraClass; + + // Set the initial position of the camera. + m_Camera->SetPosition(0.0f, 0.0f, -5.0f); + + // Create and initialize the model object. + m_Model = new ModelClass; + + result = m_Model->Initialize(m_Direct3D->GetDevice()); + if (!result) + { + MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); + return false; + } + + // Create and initialize the color shader object. + m_ColorShader = new ColorShaderClass; + + result = m_ColorShader->Initialize(m_Direct3D->GetDevice(), hwnd); + if (!result) + { + MessageBox(hwnd, L"Could not initialize the color shader object.", L"Error", MB_OK); + return false; + } + return true; } void ApplicationClass::Shutdown() { + // Release the color shader object. + if (m_ColorShader) + { + m_ColorShader->Shutdown(); + delete m_ColorShader; + m_ColorShader = 0; + } + + // Release the model object. + if (m_Model) + { + m_Model->Shutdown(); + delete m_Model; + m_Model = 0; + } + + // Release the camera object. + if (m_Camera) + { + delete m_Camera; + m_Camera = 0; + } + // Release the Direct3D object. if (m_Direct3D) { @@ -60,17 +116,40 @@ bool ApplicationClass::Frame() { return false; } + return true; } bool ApplicationClass::Render() { - // Clear the buffers to begin the scene. - m_Direct3D->BeginScene(255.0f, 255.0f, 0.0f, 1.0f); + XMMATRIX worldMatrix, viewMatrix, projectionMatrix; + bool result; + // Clear the buffers to begin the scene. + m_Direct3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f); + + // Generate the view matrix based on the camera's position. + m_Camera->Render(); + + // Get the world, view, and projection matrices from the camera and d3d objects. + m_Direct3D->GetWorldMatrix(worldMatrix); + m_Camera->GetViewMatrix(viewMatrix); + m_Direct3D->GetProjectionMatrix(projectionMatrix); + + // Put the model vertex and index buffers on the graphics pipeline to prepare them for drawing. + m_Model->Render(m_Direct3D->GetDeviceContext()); + + // Render the model using the color shader. + result = m_ColorShader->Render(m_Direct3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix); + if (!result) + { + return false; + } + // Present the rendered scene to the screen. m_Direct3D->EndScene(); + return true; } \ No newline at end of file diff --git a/enginecustom/applicationclass.h b/enginecustom/applicationclass.h index d62822f..8a74383 100644 --- a/enginecustom/applicationclass.h +++ b/enginecustom/applicationclass.h @@ -5,9 +5,12 @@ ////////////// // INCLUDES // ////////////// -#include +#include "cameraclass.h" +#include "modelclass.h" +#include "colorshaderclass.h" #include "d3dclass.h" + ///////////// // GLOBALS // ///////////// @@ -32,6 +35,9 @@ private: private: D3DClass* m_Direct3D; + CameraClass* m_Camera; + ModelClass* m_Model; + ColorShaderClass* m_ColorShader; }; #endif \ No newline at end of file diff --git a/enginecustom/enginecustom.vcxproj b/enginecustom/enginecustom.vcxproj index 22bd778..3c74b8c 100644 --- a/enginecustom/enginecustom.vcxproj +++ b/enginecustom/enginecustom.vcxproj @@ -21,35 +21,43 @@ + + + + - + Pixel Pixel Pixel Pixel - - + false + Document + + Vertex Vertex Vertex Vertex - + false + Document + 17.0 diff --git a/enginecustom/enginecustom.vcxproj.filters b/enginecustom/enginecustom.vcxproj.filters index 64ca351..c3fe977 100644 --- a/enginecustom/enginecustom.vcxproj.filters +++ b/enginecustom/enginecustom.vcxproj.filters @@ -36,6 +36,12 @@ Fichiers sources + + Fichiers sources + + + Fichiers sources + @@ -53,16 +59,20 @@ Fichiers d%27en-tête + + Fichiers d%27en-tête + + + Fichiers d%27en-tête + - - - + shader - - + + shader - + \ No newline at end of file diff --git a/enginecustom/modelclass.cpp b/enginecustom/modelclass.cpp new file mode 100644 index 0000000..0eedb98 --- /dev/null +++ b/enginecustom/modelclass.cpp @@ -0,0 +1,199 @@ +//////////////////////////////////////////////////////////////////////////////// +// Filename: modelclass.cpp +//////////////////////////////////////////////////////////////////////////////// +#include "modelclass.h" + + +ModelClass::ModelClass() +{ + m_vertexBuffer = 0; + m_indexBuffer = 0; +} + + +ModelClass::ModelClass(const ModelClass& other) +{ +} + + +ModelClass::~ModelClass() +{ +} + + +bool ModelClass::Initialize(ID3D11Device* device) +{ + bool result; + + + // Initialize the vertex and index buffers. + result = InitializeBuffers(device); + if (!result) + { + return false; + } + + return true; +} + + +void ModelClass::Shutdown() +{ + // Shutdown the vertex and index buffers. + ShutdownBuffers(); + + return; +} + + +void ModelClass::Render(ID3D11DeviceContext* deviceContext) +{ + // Put the vertex and index buffers on the graphics pipeline to prepare them for drawing. + RenderBuffers(deviceContext); + + return; +} + + +int ModelClass::GetIndexCount() +{ + return m_indexCount; +} + + +bool ModelClass::InitializeBuffers(ID3D11Device* device) +{ + VertexType* vertices; + unsigned long* indices; + D3D11_BUFFER_DESC vertexBufferDesc, indexBufferDesc; + D3D11_SUBRESOURCE_DATA vertexData, indexData; + HRESULT result; + + + // Set the number of vertices in the vertex array. + m_vertexCount = 3; + + // Set the number of indices in the index array. + m_indexCount = 3; + + // Create the vertex array. + vertices = new VertexType[m_vertexCount]; + if (!vertices) + { + return false; + } + + // Create the index array. + indices = new unsigned long[m_indexCount]; + if (!indices) + { + return false; + } + + // Load the vertex array with data. + vertices[0].position = XMFLOAT3(-1.0f, -1.0f, 0.0f); // Bottom left. + vertices[0].color = XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f); + + vertices[1].position = XMFLOAT3(0.0f, 1.0f, 0.0f); // Top middle. + vertices[1].color = XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f); + + vertices[2].position = XMFLOAT3(1.0f, -1.0f, 0.0f); // Bottom right. + vertices[2].color = XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f); + + // Load the index array with data. + indices[0] = 0; // Bottom left. + indices[1] = 1; // Top middle. + indices[2] = 2; // Bottom right. + + // Set up the description of the static vertex buffer. + vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT; + vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount; + vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + vertexBufferDesc.CPUAccessFlags = 0; + vertexBufferDesc.MiscFlags = 0; + vertexBufferDesc.StructureByteStride = 0; + + // Give the subresource structure a pointer to the vertex data. + vertexData.pSysMem = vertices; + vertexData.SysMemPitch = 0; + vertexData.SysMemSlicePitch = 0; + + // Now create the vertex buffer. + result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer); + if (FAILED(result)) + { + return false; + } + + // Set up the description of the static index buffer. + indexBufferDesc.Usage = D3D11_USAGE_DEFAULT; + indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount; + indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; + indexBufferDesc.CPUAccessFlags = 0; + indexBufferDesc.MiscFlags = 0; + indexBufferDesc.StructureByteStride = 0; + + // Give the subresource structure a pointer to the index data. + indexData.pSysMem = indices; + indexData.SysMemPitch = 0; + indexData.SysMemSlicePitch = 0; + + // Create the index buffer. + result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer); + if (FAILED(result)) + { + return false; + } + + // Release the arrays now that the vertex and index buffers have been created and loaded. + delete[] vertices; + vertices = 0; + + delete[] indices; + indices = 0; + + return true; +} + + +void ModelClass::ShutdownBuffers() +{ + // Release the index buffer. + if (m_indexBuffer) + { + m_indexBuffer->Release(); + m_indexBuffer = 0; + } + + // Release the vertex buffer. + if (m_vertexBuffer) + { + m_vertexBuffer->Release(); + m_vertexBuffer = 0; + } + + return; +} + + +void ModelClass::RenderBuffers(ID3D11DeviceContext* deviceContext) +{ + unsigned int stride; + unsigned int offset; + + + // Set vertex buffer stride and offset. + stride = sizeof(VertexType); + offset = 0; + + // Set the vertex buffer to active in the input assembler so it can be rendered. + deviceContext->IASetVertexBuffers(0, 1, &m_vertexBuffer, &stride, &offset); + + // Set the index buffer to active in the input assembler so it can be rendered. + deviceContext->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0); + + // Set the type of primitive that should be rendered from this vertex buffer, in this case triangles. + deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + + return; +} \ No newline at end of file diff --git a/enginecustom/modelclass.h b/enginecustom/modelclass.h new file mode 100644 index 0000000..f84628b --- /dev/null +++ b/enginecustom/modelclass.h @@ -0,0 +1,49 @@ +//////////////////////////////////////////////////////////////////////////////// +// Filename: modelclass.h +//////////////////////////////////////////////////////////////////////////////// +#ifndef _MODELCLASS_H_ +#define _MODELCLASS_H_ + + +////////////// +// INCLUDES // +////////////// +#include +#include +using namespace DirectX; + + +//////////////////////////////////////////////////////////////////////////////// +// Class name: ModelClass +//////////////////////////////////////////////////////////////////////////////// +class ModelClass +{ +private: + struct VertexType + { + XMFLOAT3 position; + XMFLOAT4 color; + }; + +public: + ModelClass(); + ModelClass(const ModelClass&); + ~ModelClass(); + + bool Initialize(ID3D11Device*); + void Shutdown(); + void Render(ID3D11DeviceContext*); + + int GetIndexCount(); + +private: + bool InitializeBuffers(ID3D11Device*); + void ShutdownBuffers(); + void RenderBuffers(ID3D11DeviceContext*); + +private: + ID3D11Buffer* m_vertexBuffer, * m_indexBuffer; + int m_vertexCount, m_indexCount; +}; + +#endif \ No newline at end of file