ModelClass.cpp

#include "ModelClass.h"



ModelClass::ModelClass() {

}

ModelClass::ModelClass(const ModelClass& other) {
    m_meshes = other.m_meshes;
    m_vertexBuffers = other.m_vertexBuffers;
}

ModelClass::~ModelClass() {

}

bool ModelClass::Initialize(ID3D11Device* device) {
    bool result;
    result = InitializeVertexBuffers(device);
    if (!result) {
        cout << "[ModelClass]\tError: failed InitializeBuffers()." << endl;
        return false;
    }
    return true;
}

void ModelClass::SetMeshSubsets(vector<Mesh>& subsets) {
    m_meshes = subsets;
}

void ModelClass::Shutdown() {
    ShutdownBuffers();
}

bool ModelClass::InitializeVertexBuffers(ID3D11Device* device) {
    D3D11_BUFFER_DESC vertexBufferDesc;
    D3D11_SUBRESOURCE_DATA vertexData;
    HRESULT result;

    for (size_t i = 0; i < m_meshes.size(); i++) {
        vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
        vertexBufferDesc.ByteWidth = (UINT)(m_meshes[i].vertices.size() * sizeof(VertexType));
        vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
        vertexBufferDesc.StructureByteStride = 0;
        vertexBufferDesc.CPUAccessFlags = 0;
        vertexBufferDesc.MiscFlags = 0;

        vertexData.pSysMem = m_meshes[i].vertices.data();
        vertexData.SysMemPitch = 0;
        vertexData.SysMemSlicePitch = 0;

        ID3D11Buffer* vertexBuffer;
        result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &vertexBuffer);
        if (FAILED(result)) {
            cout << "[ModelClass]\tError: failed to create vertex buffer." << endl;
            return false;
        }
        m_vertexBuffers.push_back(vertexBuffer);
    }
    return true;
}

void ModelClass::ShutdownBuffers() {
    while (!m_vertexBuffers.empty()) {
        m_vertexBuffers.back()->Release();
        m_vertexBuffers.erase(m_vertexBuffers.end());
    }
}

void ModelClass::Render(ID3D11DeviceContext* deviceContext, ShadersTable* shadersTable, MaterialLibrary* matLibrary, TexturesTable* texturesTable, D3DXMATRIX& worldMatrix, D3DXMATRIX& viewMatrix, D3DXMATRIX& projectionMatrix) {
    unsigned int stride;
    unsigned int offset;

    stride = sizeof(VertexType);
    offset = 0;

    for (size_t i = 0; i < m_vertexBuffers.size(); i++) {
        deviceContext->IASetVertexBuffers(0, 1, &m_vertexBuffers[i], &stride, &offset);
        deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
        Material* currentMaterial = matLibrary->GetMaterialByName(m_meshes[i].material);
        if (!currentMaterial) {
            cout << "[ModelClass]\tWarning: unable to get material " << m_meshes[i].material << " during rendering. " << endl;
        }
        else {
            ShaderClass* shader = shadersTable->GetShaderByName(currentMaterial->type);
            if (shader == nullptr) {
                cout << "[ModelClass]\tError: unable to get shader " << m_meshes[i].material << " from ShadersTable." << endl;
            }
            else {
                shader->Render(deviceContext, texturesTable, m_meshes[i].vertices.size(), worldMatrix, viewMatrix, projectionMatrix, currentMaterial);
            }
        }
    }
}