render to texture sans modif applicationclass.cpp

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

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;
+}

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

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;
+}

enginecustom/rendertextureclass.h

@@ -0,0 +1,51 @@
+////////////////////////////////////////////////////////////////////////////////
+// Filename: rendertextureclass.h
+////////////////////////////////////////////////////////////////////////////////
+#ifndef _RENDERTEXTURECLASS_H_
+#define _RENDERTEXTURECLASS_H_
+
+
+//////////////
+// INCLUDES //
+//////////////
+#include <d3d11.h>
+#include <directxmath.h>
+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