#include "Mesh.h"

#include <glm/gtc/matrix_transform.hpp>

#include <glm/gtx/rotate_vector.hpp>

#include <assimp/Importer.hpp>

#include <assimp/scene.h>

#include <assimp/postprocess.h>

#include "GLFWApp.h"

Mesh::Mesh()

: m_useSmoothNormal(false)//, m_render_option(RENDER_ENUM::RENDER_NORMAL)

{

}

Mesh::Mesh(const Mesh &other)

{

*this = std::move(other);

}

Mesh::~Mesh()

{

#ifdef _DEBUG

std::cout << "Mesh Dtor\n";

#endif

Release();

}

bool Mesh::Initialize(std::shared_ptr<Shader> shader)

{

if (!shader)

return false;

if (!m_shader)

m_shader = shader;

if (!m_shader->getProgram())

{

bool shader_status = false;

if (!m_useSmoothNormal)

shader_status = m_shader->SetupShader(ShaderEnum::SHADER_MODE_FLAT);

else

shader_status = m_shader->SetupShader(ShaderEnum::SHADER_MODE_PHONG);

if (!shader_status)

{

fprintf(stderr, "shader setup failed -- please check your file existence");

return false;

}

}

RegistToManager();

return true;

}

void Mesh::Release()

{

glDeleteBuffers(3, m_vbo);

glDeleteBuffers(1, &m_ebo);

glDeleteVertexArrays(1, &m_vao);

m_shader.reset();

if (m_positions.size() > 0)

m_positions.clear();

if (m_normals.size() > 0)

m_normals.clear();

if (m_indices.size() > 0)

m_indices.clear();

if (m_colors.size() > 0)

m_colors.clear();

if (m_texcoord.size() > 0)

m_texcoord.clear();

if (m_triangleNormalIndex.size() > 0)

m_triangleNormalIndex.clear();

m_positions.shrink_to_fit();

m_normals.shrink_to_fit();

m_colors.shrink_to_fit();

m_texcoord.shrink_to_fit();

m_indices.shrink_to_fit();

}

/*

bool Mesh::LoadFromFile(std::string path)

{

if (path.find(".obj") == string::npos)

{

cout << "Only Support (.obj) Files" << endl;

return false;

}

ifstream fin;

fin.open(path.c_str());

if (!fin)

{

cout << "Cannot Open File" << path << "!!\n";

return false;

}

string data_buf;

string symb;

bool start = true;

while (fin >> symb)

{

if (symb.compare("#") == 0)

{

getline(fin, data_buf);

}

else if (symb.compare("v") == 0)

{

float x, y, z;

getline(fin, data_buf);

istringstream sin(data_buf.c_str());

sin >> x >> y >> z;

glm::vec3 position(x, y, z);

m_positions.push_back(position);

}

else if (symb.compare("vn") == 0)

{

float x, y, z;

getline(fin, data_buf);

istringstream sin(data_buf.c_str());

sin >> x >> y >> z;

glm::vec3 normal(x, y, z);

m_normals.push_back(normal);

}

else if (symb.compare("f") == 0)

{

//build indices and calculate flat normals;

//Triangle only Ov<

getline(fin, data_buf);

istringstream sin(data_buf.c_str());

unsigned int index[20];

int indicesCount = 0;

if (data_buf.find("//") != std::string::npos) //found "//" in data_buf

{

string data1, data2, data3;

unsigned int triangleId;

sin >> data1 >> data2 >> data3;

data1.replace(data1.find("//"), string("//").length(), " ");

data2.replace(data2.find("//"), string("//").length(), " ");

data3.replace(data3.find("//"), string("//").length(), " ");

istringstream parseIndices1(data1.c_str());

istringstream parseIndices2(data2.c_str());

istringstream parseIndices3(data3.c_str());

parseIndices1 >> index[0] >> triangleId;

parseIndices2 >> index[1];

parseIndices3 >> index[2];

parseIndices1.clear();

parseIndices2.clear();

parseIndices3.clear();

m_triangleNormalIndex.push_back(triangleId - 1);

for (int i = 0; i < 3; i++)

{

m_indices.push_back(index[i] - 1);

}

}

else if (data_buf.find("/") != std::string::npos) //found "/" in data_buf

{

string data1, data2, data3;

unsigned int vt[3];

unsigned int vn[3];

sin >> data1 >> data2 >> data3;

data1.replace(data1.find("/"), string("/").length(), " ");

data2.replace(data2.find("/"), string("/").length(), " ");

data3.replace(data3.find("/"), string("/").length(), " ");

istringstream parseIndices1(data1.c_str());

istringstream parseIndices2(data2.c_str());

istringstream parseIndices3(data3.c_str());

parseIndices1 >> index[0] >> vt[0] >> vn[0];

parseIndices2 >> index[1] >> vt[1] >> vn[1];

parseIndices3 >> index[2] >> vt[2] >> vn[2];

parseIndices1.clear();

parseIndices2.clear();

parseIndices3.clear();

m_triangleNormalIndex.push_back(vn[0] - 1);

for (int i = 0; i < 3; i++)

{

m_indices.push_back(index[i] - 1);

}

}

else

{

unsigned int data;

while (sin >> data)

{

index[indicesCount] = data;

indicesCount++;

}

for (int i = 1; i < indicesCount - 1; i++)

{

m_indices.push_back(index[0] - 1);

m_indices.push_back(index[i] - 1);

m_indices.push_back(index[i + 1] - 1);

}

}

}

}

fin.close();

std::cout << "Load Success!! " + path << endl;

if (m_useSmoothNormal)

{

ComputeSmoothNormal(1);

}

SetupGLBuffers();

//UploadToGPU();

return true;

}

bool Mesh::LoadFromFileAssimp(std::string path)

{

if (path.find(".obj") == string::npos)

{

cout << "Only Support (.obj) Files" << endl;

return false;

}

Assimp::Importer importer;

const auto scene = importer.ReadFile(

path,

aiProcess_CalcTangentSpace |

aiProcess_Triangulate

);

if (!scene)

{

std::cout << importer.GetErrorString() << std::endl;

return false;

}

if (scene->HasMeshes())

std::cout << scene->mNumMeshes << std::endl;

// Obj file will only contain one mesh....

const aiVector3D Zero3D(0.0f, 0.0f, 0.0f);

const auto mesh = scene->mMeshes[0];

for (unsigned int i = 0; i < mesh->mNumVertices; ++i)

{

const auto* pos = &(mesh->mVertices[i]);

const auto* normal = &(mesh->mNormals[i]);

const auto* texcoord = mesh->HasTextureCoords(0) ? &(mesh->mTextureCoords[0][i]) : &Zero3D;

m_positions.push_back( glm::vec3(pos->x, pos->y, pos->z) );

m_normals.push_back( glm::vec3(normal->x, normal->y, normal->z) );

m_texcoord.push_back( glm::vec2(texcoord->x, texcoord->y) );

}

for (unsigned int i = 0; i < mesh->mNumFaces; ++i)

{

const aiFace& face = mesh->mFaces[i];

#ifdef _DEBUG

assert(face.mNumIndices == 3);

#endif

m_indices.push_back(face.mIndices[0]);

m_indices.push_back(face.mIndices[1]);

m_indices.push_back(face.mIndices[2]);

}

SetupGLBuffers();

std::cout << "Load Sucess (Assimp)\t" << path << std::endl;

return true;

}

*/

void Mesh::UploadToGPU()

{

glBindVertexArray(m_vao);

//upload vertices position to GPU

if (m_positions.size() > 0)

{

glBindBuffer(GL_ARRAY_BUFFER, m_vbo[0]);

glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3)* m_positions.size(),

m_positions.data(), GL_STATIC_DRAW);

glEnableVertexAttribArray(0);

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);

std::cout << "Has Vertex, Size:" << m_positions.size() << "\n";

}

if (m_normals.size() > 0)

{

glBindBuffer(GL_ARRAY_BUFFER, m_vbo[1]);

glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3)* m_normals.size(),

m_normals.data(), GL_STATIC_DRAW);

glEnableVertexAttribArray(1);

glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);

std::cout << "Has Normal, size: " << m_normals.size() << "\n";

}

if (m_texcoord.size() > 0)

{

glBindBuffer(GL_ARRAY_BUFFER, m_vbo[2]);

glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec2)* m_texcoord.size(),

m_texcoord.data(), GL_STATIC_DRAW);

glEnableVertexAttribArray(2);

glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 0);

std::cout << "Using Texture\n";

}

//setup indices info

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);

glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * m_indices.size(),

m_indices.data(), GL_STATIC_DRAW);

glBindVertexArray(0);

}

void Mesh::UpdatePositions()

{

glBindVertexArray(m_vao);

//upload vertices position to GPU

if (m_positions.size() > 0)

{

glBindBuffer(GL_ARRAY_BUFFER, m_vbo[0]);

glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3)* m_positions.size(),

m_positions.data(), GL_STREAM_DRAW);

glEnableVertexAttribArray(0);

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);

}

glBindVertexArray(0);

}

void Mesh::UpdateNormals()

{

glBindVertexArray(m_vao);

if (m_normals.size() > 0)

{

glBindBuffer(GL_ARRAY_BUFFER, m_vbo[1]);

glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3)* m_normals.size(),

m_normals.data(), GL_STREAM_DRAW);

glEnableVertexAttribArray(1);

glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);

}

glBindVertexArray(0);

}

void Mesh::UpdateTextcoords()

{

glBindVertexArray(m_vao);

if (m_texcoord.size() > 0)

{

glBindBuffer(GL_ARRAY_BUFFER, m_vbo[2]);

glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec2)* m_texcoord.size(),

m_texcoord.data(), GL_STREAM_DRAW);

glEnableVertexAttribArray(2);

glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 0);

}

glBindVertexArray(0);

}

void Mesh::UpdateIndices()

{

glBindVertexArray(m_vao);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);

glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * m_indices.size(),

m_indices.data(), GL_STREAM_DRAW);

glBindVertexArray(0);

}

void Mesh::SetupGLBuffers()

{

if (!m_shader)

{

std::cout << "No shader No render!\n";

return;

}

m_shader->Use();

glGenVertexArrays(1, &m_vao);

glGenBuffers(3, m_vbo);

glGenBuffers(1, &m_ebo);

UploadToGPU();

}

void Mesh::ComputeSmoothNormal(unsigned int normal_type)

{

if (!m_useSmoothNormal)

return;

switch (normal_type)

{

case 1:

{

ComputeVNormalByFace();

break;

}

case 2:

{

ComputeVNormalByEdge();

break;

}

default:

{

break;

}

}//switch end

}

void Mesh::ResetPositions(std::vector<glm::vec3>& pos)

{

m_positions.clear();

m_positions = pos;

UpdatePositions();

}

void Mesh::ResetNormals(std::vector<glm::vec3>& normals)

{

m_normals.clear();

m_normals = std::move(normals);

UpdateNormals();

}

void Mesh::ResetTexCoord(std::vector<glm::vec2>& texcoords)

{

m_texcoord.clear();

m_texcoord = std::move(texcoords);

UpdatePositions();

}

void Mesh::ResetIndices(std::vector<unsigned int>& indices)

{

m_indices.clear();

m_indices = std::move(indices);

UpdateIndices();

}

void Mesh::Render()

{

if (!m_shader)

return;

if (m_indices.size() <= 0)

{

std::cout << "There's no any index to draw\n";

return;

}

//m_shader->Use();

}

/*

void Mesh::Update()

{

SetupGLBuffers();

}

*/

void Mesh::setPositions(std::vector<glm::vec3> pos)

{

m_positions = pos;

}

void Mesh::setNormals(std::vector<glm::vec3>& normals)

{

m_normals = std::move(normals);

}

void Mesh::setIndices(std::vector<unsigned int>& indices)

{

m_indices = std::move(indices);

}

void Mesh::setTexCoord(std::vector<glm::vec2>& texcoords)

{

m_texcoord = std::move(texcoords);

}

void Mesh::setShader(std::shared_ptr<Shader> shader)

{

m_shader = shader;

}

void Mesh::setName(std::string name)

{

m_name = name;

}

/*

void Mesh::setRenderOption(RENDER_ENUM render_option)

{

m_render_option = render_option;

}

*/

void Mesh::ComputeVNormalByFace()

{

if (m_normals.size() == 0)

{

std::cout << "Require given normals\n";

return;

}

struct Normal_Acc

{

glm::vec3 value;

int count=0;

};

std::cout << "Face Avg Computation\n";

std::vector<Normal_Acc> normal_sum;

normal_sum.resize(m_positions.size());

{

size_t idx = 0;

for (size_t i = 0; i < m_indices.size(); i += 3)

{

/*

std::cout << m_indices[i + 0] << "//" << m_triangleNormalIndex[idx] << " ";

std::cout << m_indices[i + 1] << "//" << m_triangleNormalIndex[idx] << " ";

std::cout << m_indices[i + 2] << "//" << m_triangleNormalIndex[idx] << " \n";

*/

unsigned int v1, v2, v3, tri_normal_id;

v1 = m_indices[i + 0];

v2 = m_indices[i + 1];

v3 = m_indices[i + 2];

tri_normal_id = m_triangleNormalIndex[idx];

normal_sum[v1].value += m_normals[tri_normal_id];

normal_sum[v1].count++;

normal_sum[v2].value += m_normals[tri_normal_id];

normal_sum[v2].count++;

normal_sum[v3].value += m_normals[tri_normal_id];

normal_sum[v3].count++;

idx++;

}

for (size_t i = 0; i < normal_sum.size();++i)

{

/*

std::cout << normal_sum[i].value.x << " "

<< normal_sum[i].value.y << " "

<< normal_sum[i].value.z << " "

<< normal_sum[i].count << "\n";

*/

normal_sum[i].value = normal_sum[i].value / static_cast<float>(normal_sum[i].count);

}

m_normals.clear();

m_normals.resize(normal_sum.size());

for (size_t i = 0; i < normal_sum.size(); ++i)

{

m_normals[i] = normal_sum[i].value;

/*

std::cout << normal_sum[i].value.x << " "

<< normal_sum[i].value.y << " "

<< normal_sum[i].value.z << "\n";

*/

}

}

}

void Mesh::ComputeVNormalByEdge()

{

std::cout << "Edge Relate Normal Avg\n";

}

void Mesh::RegistToManager()

{

GLFWApp::getInstance()->getResourceManager()->AddMesh( shared_from_this() );

}