diff --git a/enginecustom/applicationclass.h b/enginecustom/applicationclass.h index c8cacbb..f1eeca8 100644 --- a/enginecustom/applicationclass.h +++ b/enginecustom/applicationclass.h @@ -27,6 +27,9 @@ #include "modellistclass.h" #include "positionclass.h" #include "frustumclass.h" +#include "rendertextureclass.h" +#include "displayplaneclass.h" + ///////////// @@ -57,6 +60,7 @@ private: bool UpdateMouseStrings(int, int, bool); bool UpdateFps(); bool UpdateRenderCountString(int); + bool RenderSceneToTexture(float); private: D3DClass* m_Direct3D; @@ -87,6 +91,8 @@ private: PositionClass* m_Position; FrustumClass* m_Frustum; XMMATRIX m_baseViewMatrix; + RenderTextureClass* m_RenderTexture; + DisplayPlaneClass* m_DisplayPlane; }; #endif diff --git a/enginecustom/displayplaneclass.cpp b/enginecustom/displayplaneclass.cpp new file mode 100644 index 0000000..798489b --- /dev/null +++ b/enginecustom/displayplaneclass.cpp @@ -0,0 +1,199 @@ +#include "displayplaneclass.h" + + +DisplayPlaneClass::DisplayPlaneClass() +{ + m_vertexBuffer = 0; + m_indexBuffer = 0; +} + + +DisplayPlaneClass::DisplayPlaneClass(const DisplayPlaneClass& other) +{ +} + + +DisplayPlaneClass::~DisplayPlaneClass() +{ +} + +bool DisplayPlaneClass::Initialize(ID3D11Device* device, float width, float height) +{ + bool result; + + + // Initialize the vertex and index buffer that hold the geometry for the button. + result = InitializeBuffers(device, width, height); + if (!result) + { + return false; + } + + return true; +} + + +void DisplayPlaneClass::Shutdown() +{ + // Release the vertex and index buffers. + ShutdownBuffers(); + + return; +} + + +void DisplayPlaneClass::Render(ID3D11DeviceContext* deviceContext) +{ + // Put the vertex and index buffers on the graphics pipeline to prepare them for drawing. + RenderBuffers(deviceContext); + + return; +} + + +int DisplayPlaneClass::GetIndexCount() +{ + return m_indexCount; +} + +bool DisplayPlaneClass::InitializeBuffers(ID3D11Device* device, float width, float height) +{ + VertexType* vertices; + unsigned long* indices; + D3D11_BUFFER_DESC vertexBufferDesc, indexBufferDesc; + D3D11_SUBRESOURCE_DATA vertexData, indexData; + HRESULT result; + int i; + + + // Set the number of vertices in the vertex array. + m_vertexCount = 6; + + // Set the number of indices in the index array. + m_indexCount = m_vertexCount; + + // Create the vertex array. + vertices = new VertexType[m_vertexCount]; + + // Create the index array. + indices = new unsigned long[m_indexCount]; + + // Load the vertex array with data. + // First triangle. + vertices[0].position = XMFLOAT3(-width, height, 0.0f); // Top left. + vertices[0].texture = XMFLOAT2(0.0f, 0.0f); + + vertices[1].position = XMFLOAT3(width, -height, 0.0f); // Bottom right. + vertices[1].texture = XMFLOAT2(1.0f, 1.0f); + + vertices[2].position = XMFLOAT3(-width, -height, 0.0f); // Bottom left. + vertices[2].texture = XMFLOAT2(0.0f, 1.0f); + + // Second triangle. + vertices[3].position = XMFLOAT3(-width, height, 0.0f); // Top left. + vertices[3].texture = XMFLOAT2(0.0f, 0.0f); + + vertices[4].position = XMFLOAT3(width, height, 0.0f); // Top right. + vertices[4].texture = XMFLOAT2(1.0f, 0.0f); + + vertices[5].position = XMFLOAT3(width, -height, 0.0f); // Bottom right. + vertices[5].texture = XMFLOAT2(1.0f, 1.0f); + + // Load the index array with data. + for (i = 0; i < m_indexCount; i++) + { + indices[i] = i; + } + + // Set up the description of the 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 finally create the vertex buffer. + result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer); + if (FAILED(result)) + { + return false; + } + + // Set up the description of the 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 DisplayPlaneClass::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 DisplayPlaneClass::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/displayplaneclass.h b/enginecustom/displayplaneclass.h new file mode 100644 index 0000000..7d91023 --- /dev/null +++ b/enginecustom/displayplaneclass.h @@ -0,0 +1,44 @@ +#ifndef _DISPLAYPLANECLASS_H_ +#define _DISPLAYPLANECLASS_H_ + + +/////////////////////// +// MY CLASS INCLUDES // +/////////////////////// +#include "d3dclass.h" + + +//////////////////////////////////////////////////////////////////////////////// +// Class name: DisplayPlaneClass +//////////////////////////////////////////////////////////////////////////////// +class DisplayPlaneClass +{ +private: + struct VertexType + { + XMFLOAT3 position; + XMFLOAT2 texture; + }; + +public: + DisplayPlaneClass(); + DisplayPlaneClass(const DisplayPlaneClass&); + ~DisplayPlaneClass(); + + bool Initialize(ID3D11Device*, float, float); + void Shutdown(); + void Render(ID3D11DeviceContext*); + + int GetIndexCount(); + +private: + bool InitializeBuffers(ID3D11Device*, float, float); + void ShutdownBuffers(); + void RenderBuffers(ID3D11DeviceContext*); + +private: + ID3D11Buffer* m_vertexBuffer, * m_indexBuffer; + int m_vertexCount, m_indexCount; +}; + +#endif diff --git a/enginecustom/rendertextureclass.cpp b/enginecustom/rendertextureclass.cpp new file mode 100644 index 0000000..d4435a8 --- /dev/null +++ b/enginecustom/rendertextureclass.cpp @@ -0,0 +1,248 @@ +#include "rendertextureclass.h" + +RenderTextureClass::RenderTextureClass() +{ + m_renderTargetTexture = 0; + m_renderTargetView = 0; + m_shaderResourceView = 0; + m_depthStencilBuffer = 0; + m_depthStencilView = 0; +} + + +RenderTextureClass::RenderTextureClass(const RenderTextureClass& other) +{ +} + + +RenderTextureClass::~RenderTextureClass() +{ +} + +bool RenderTextureClass::Initialize(ID3D11Device * device, int textureWidth, int textureHeight, float screenDepth, float screenNear, int format) +{ + D3D11_TEXTURE2D_DESC textureDesc; + HRESULT result; + D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc; + D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc; + D3D11_TEXTURE2D_DESC depthBufferDesc; + D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc; + DXGI_FORMAT textureFormat; + + + // Set the texture format. + switch (format) + { + case 1: + { + textureFormat = DXGI_FORMAT_R8G8B8A8_UNORM; + break; + } + default: + { + textureFormat = DXGI_FORMAT_R8G8B8A8_UNORM; + break; + } + } + + // Store the width and height of the render texture. + m_textureWidth = textureWidth; + m_textureHeight = textureHeight; + + // Initialize the render target texture description. + ZeroMemory(&textureDesc, sizeof(textureDesc)); + + // Setup the render target texture description. + textureDesc.Width = textureWidth; + textureDesc.Height = textureHeight; + textureDesc.MipLevels = 1; + textureDesc.ArraySize = 1; + textureDesc.Format = textureFormat; + textureDesc.SampleDesc.Count = 1; + textureDesc.Usage = D3D11_USAGE_DEFAULT; + textureDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE; + textureDesc.CPUAccessFlags = 0; + textureDesc.MiscFlags = 0; + + // Create the render target texture. + result = device->CreateTexture2D(&textureDesc, NULL, &m_renderTargetTexture); + if (FAILED(result)) + { + return false; + } + + // Setup the description of the render target view. + renderTargetViewDesc.Format = textureDesc.Format; + renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + renderTargetViewDesc.Texture2D.MipSlice = 0; + + // Create the render target view. + result = device->CreateRenderTargetView(m_renderTargetTexture, &renderTargetViewDesc, &m_renderTargetView); + if (FAILED(result)) + { + return false; + } + + // Setup the description of the shader resource view. + shaderResourceViewDesc.Format = textureDesc.Format; + shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + shaderResourceViewDesc.Texture2D.MostDetailedMip = 0; + shaderResourceViewDesc.Texture2D.MipLevels = 1; + + // Create the shader resource view. + result = device->CreateShaderResourceView(m_renderTargetTexture, &shaderResourceViewDesc, &m_shaderResourceView); + if (FAILED(result)) + { + return false; + } + + // Initialize the description of the depth buffer. + ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc)); + + // Set up the description of the depth buffer. + depthBufferDesc.Width = textureWidth; + depthBufferDesc.Height = textureHeight; + depthBufferDesc.MipLevels = 1; + depthBufferDesc.ArraySize = 1; + depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; + depthBufferDesc.SampleDesc.Count = 1; + depthBufferDesc.SampleDesc.Quality = 0; + depthBufferDesc.Usage = D3D11_USAGE_DEFAULT; + depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; + depthBufferDesc.CPUAccessFlags = 0; + depthBufferDesc.MiscFlags = 0; + + // Create the texture for the depth buffer using the filled out description. + result = device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer); + if (FAILED(result)) + { + return false; + } + + // Initailze the depth stencil view description. + ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc)); + + // Set up the depth stencil view description. + depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; + depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; + depthStencilViewDesc.Texture2D.MipSlice = 0; + + // Create the depth stencil view. + result = device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView); + if (FAILED(result)) + { + return false; + } + + // Setup the viewport for rendering. + m_viewport.Width = (float)textureWidth; + m_viewport.Height = (float)textureHeight; + m_viewport.MinDepth = 0.0f; + m_viewport.MaxDepth = 1.0f; + m_viewport.TopLeftX = 0; + m_viewport.TopLeftY = 0; + + // Setup the projection matrix. + m_projectionMatrix = XMMatrixPerspectiveFovLH((3.141592654f / 4.0f), ((float)textureWidth / (float)textureHeight), screenNear, screenDepth); + + // Create an orthographic projection matrix for 2D rendering. + m_orthoMatrix = XMMatrixOrthographicLH((float)textureWidth, (float)textureHeight, screenNear, screenDepth); + + return true; +} + +void RenderTextureClass::Shutdown() +{ + if (m_depthStencilView) + { + m_depthStencilView->Release(); + m_depthStencilView = 0; + } + + if (m_depthStencilBuffer) + { + m_depthStencilBuffer->Release(); + m_depthStencilBuffer = 0; + } + + if (m_shaderResourceView) + { + m_shaderResourceView->Release(); + m_shaderResourceView = 0; + } + + if (m_renderTargetView) + { + m_renderTargetView->Release(); + m_renderTargetView = 0; + } + + if (m_renderTargetTexture) + { + m_renderTargetTexture->Release(); + m_renderTargetTexture = 0; + } + + return; +} + +void RenderTextureClass::SetRenderTarget(ID3D11DeviceContext * deviceContext) +{ + // Bind the render target view and depth stencil buffer to the output render pipeline. + deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView); + + // Set the viewport. + deviceContext->RSSetViewports(1, &m_viewport); + + return; +} + +void RenderTextureClass::ClearRenderTarget(ID3D11DeviceContext * deviceContext, float red, float green, float blue, float alpha) +{ + float color[4]; + + + // Setup the color to clear the buffer to. + color[0] = red; + color[1] = green; + color[2] = blue; + color[3] = alpha; + + // Clear the back buffer. + deviceContext->ClearRenderTargetView(m_renderTargetView, color); + + // Clear the depth buffer. + deviceContext->ClearDepthStencilView(m_depthStencilView, D3D11_CLEAR_DEPTH, 1.0f, 0); + + return; +} + +ID3D11ShaderResourceView* RenderTextureClass::GetShaderResourceView() +{ + return m_shaderResourceView; +} + +void RenderTextureClass::GetProjectionMatrix(XMMATRIX & projectionMatrix) +{ + projectionMatrix = m_projectionMatrix; + return; +} + + +void RenderTextureClass::GetOrthoMatrix(XMMATRIX & orthoMatrix) +{ + orthoMatrix = m_orthoMatrix; + return; +} + + +int RenderTextureClass::GetTextureWidth() +{ + return m_textureWidth; +} + + +int RenderTextureClass::GetTextureHeight() +{ + return m_textureHeight; +} \ No newline at end of file diff --git a/enginecustom/rendertextureclass.h b/enginecustom/rendertextureclass.h new file mode 100644 index 0000000..ef06537 --- /dev/null +++ b/enginecustom/rendertextureclass.h @@ -0,0 +1,51 @@ +//////////////////////////////////////////////////////////////////////////////// +// Filename: rendertextureclass.h +//////////////////////////////////////////////////////////////////////////////// +#ifndef _RENDERTEXTURECLASS_H_ +#define _RENDERTEXTURECLASS_H_ + + +////////////// +// INCLUDES // +////////////// +#include +#include +using namespace DirectX; + + +//////////////////////////////////////////////////////////////////////////////// +// Class name: RenderTextureClass +//////////////////////////////////////////////////////////////////////////////// +class RenderTextureClass +{ +public: + RenderTextureClass(); + RenderTextureClass(const RenderTextureClass&); + ~RenderTextureClass(); + + bool Initialize(ID3D11Device*, int, int, float, float, int); + void Shutdown(); + + void SetRenderTarget(ID3D11DeviceContext*); + void ClearRenderTarget(ID3D11DeviceContext*, float, float, float, float); + ID3D11ShaderResourceView* GetShaderResourceView(); + + void GetProjectionMatrix(XMMATRIX&); + void GetOrthoMatrix(XMMATRIX&); + + int GetTextureWidth(); + int GetTextureHeight(); + +private: + int m_textureWidth, m_textureHeight; + ID3D11Texture2D* m_renderTargetTexture; + ID3D11RenderTargetView* m_renderTargetView; + ID3D11ShaderResourceView* m_shaderResourceView; + ID3D11Texture2D* m_depthStencilBuffer; + ID3D11DepthStencilView* m_depthStencilView; + D3D11_VIEWPORT m_viewport; + XMMATRIX m_projectionMatrix; + XMMATRIX m_orthoMatrix; +}; + +#endif