////////////////////////////////////////////////////////////////////////////////

// Filename: modelclass.cpp

////////////////////////////////////////////////////////////////////////////////

#include "modelclass.h"

ModelClass::ModelClass()

{

m_vertexBuffer = nullptr;

m_indexBuffer = nullptr;

#ifdef TEXTURE_SHADER

m_Texture = nullptr;

#endif

}

ModelClass::ModelClass(const ModelClass& other)

{

}

ModelClass::~ModelClass()

{

}

#ifdef TEXTURE_SHADER

bool ModelClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceContext, char* textureFilename)

#else

bool ModelClass::Initialize(ID3D11Device* device)

#endif

{

bool result;

// Initialize the vertex and index buffers.

result = InitializeBuffers(device);

if(!result)

{

return false;

}

#ifdef TEXTURE_SHADER

// Load the texture for this model.

result = LoadTexture(device, deviceContext, textureFilename);

if (!result)

{

return false;

}

#endif

return true;

}

void ModelClass::Shutdown()

{

#ifdef TEXTURE_SHADER

// Release the model texture.

ReleaseTexture();

#endif

// 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;

}

#ifdef TEXTURE_SHADER

ID3D11ShaderResourceView* ModelClass::GetTexture()

{

return m_Texture->GetTexture();

}

#endif

// The InitializeBuffers function is where we handle creating the vertex and index buffers.

// Usually you would read in a model and create the buffers from that data file.

// For this tutorial we will just set the points in the vertex and index buffer manually since it is only a single triangle.

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 = 4;

// Set the number of indices in the index array.

m_indexCount = 4;

// 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, in the clockwise order otherwise it will not be drawn due to back face culling.

vertices[0].position = XMFLOAT3(-1.0f, -1.0f, 0.0f);

vertices[1].position = XMFLOAT3(-1.0f, 1.0f, 0.0f);

vertices[2].position = XMFLOAT3(1.0f, 1.0f, 0.0f);

vertices[3].position = XMFLOAT3(1.0f, -1.0f, 0.0f);

#ifdef TEXTURE_SHADER

vertices[0].texture = XMFLOAT2(0.0f, 1.0f);

vertices[1].texture = XMFLOAT2(0.0f, 0.0f);

vertices[2].texture = XMFLOAT2(1.0f, 0.0f);

vertices[3].texture = XMFLOAT2(1.0f, 1.0f);

#else

vertices[0].color = XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f);

vertices[1].color = XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f);

vertices[2].color = XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f);

#endif

// Load the index array with data. using triangle strip topology

indices[0] = 0;

indices[1] = 1;

indices[2] = 3;

indices[3] = 2;

// indices[4] = 2; // if using triangle list we must have 6 indices

// indices[5] = 3;

// 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 the vertex and index arrays as they are no longer needed since the data was copied into the buffers.

delete[] vertices;

vertices = nullptr;

delete[] indices;

indices = nullptr;

return true;

}

void ModelClass::ShutdownBuffers()

{

// Release the index buffer.

if (m_indexBuffer)

{

m_indexBuffer->Release();

m_indexBuffer = nullptr;

}

// Release the vertex buffer.

if (m_vertexBuffer)

{

m_vertexBuffer->Release();

m_vertexBuffer = nullptr;

}

return;

}

void ModelClass::RenderBuffers(ID3D11DeviceContext* deviceContext)

{

unsigned int stride;

unsigned int offset;

// Set the vertex buffer stride and offset.

stride = sizeof(VertexType);

offset = 0;

// Set the vertex buffer to active in the input asembler 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.

deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);

return;

}

#ifdef TEXTURE_SHADER

bool ModelClass::LoadTexture(ID3D11Device* device, ID3D11DeviceContext* deviceContext, char* filename)

{

bool result;

// Create the texture object.

m_Texture = new TextureClass;

if (!m_Texture)

{

return false;

}

// Initialize the texture object.

result = m_Texture->Initialize(device, deviceContext, filename);

if (!result)

{

return false;

}

return true;

}

void ModelClass::ReleaseTexture()

{

// Release the texture object.

if (m_Texture)

{

m_Texture->Shutdown();

delete m_Texture;

m_Texture = nullptr;

}

return;

}

#endif