376 lines
11 KiB
C++
376 lines
11 KiB
C++
#include <iostream>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <memory>
|
|
#include <filesystem>
|
|
#include <GL/glew.h>
|
|
|
|
#include "renderer/wavefront.h"
|
|
|
|
ObjElement toElement(const std::string &s) {
|
|
if (s == "#") return ObjElement::OHASH;
|
|
if (s == "mtllib") return ObjElement::MTLLIB;
|
|
if (s == "usemtl") return ObjElement::USEMTL;
|
|
if (s == "o") return ObjElement::O;
|
|
if (s == "v") return ObjElement::V;
|
|
if (s == "vn") return ObjElement::VN;
|
|
if (s == "vt") return ObjElement::VT;
|
|
if (s == "f") return ObjElement::F;
|
|
return ObjElement::OUNKNOWN;
|
|
}
|
|
|
|
MtlElement toMtlElement(const std::string &s) {
|
|
if (s == "#") return MtlElement::MHASH;
|
|
if (s == "newmtl") return MtlElement::NEWMTL;
|
|
if (s == "Ns") return MtlElement::NS;
|
|
if (s == "Ka") return MtlElement::KA;
|
|
if (s == "Ks") return MtlElement::KS;
|
|
if (s == "Kd") return MtlElement::KD;
|
|
if (s == "Ni") return MtlElement::NI;
|
|
if (s == "d") return MtlElement::D;
|
|
if (s == "illum") return MtlElement::ILLUM;
|
|
if (s == "map_Kd") return MtlElement::MAP_KD;
|
|
if (s == "map_Ka") return MtlElement::MAP_KA;
|
|
// if (s == "map_Ke") return MtlElement::MAP_KE;
|
|
return MtlElement::MUNKNOWN;
|
|
}
|
|
|
|
void Vertex::DefineAttrib()
|
|
{
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(offsetof(Vertex, m_position)));
|
|
glEnableVertexAttribArray(0);
|
|
|
|
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(offsetof(Vertex, m_normal)));
|
|
glEnableVertexAttribArray(1);
|
|
|
|
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(offsetof(Vertex, m_texCoord)));
|
|
glEnableVertexAttribArray(2);
|
|
}
|
|
|
|
inline int Object::NormalizeIndex(const std::string &s, int baseCount) {
|
|
if (s.empty()) return -1;
|
|
int idx = std::stoi(s);
|
|
if (idx > 0) return idx - 1;
|
|
return baseCount + idx;
|
|
}
|
|
|
|
Mesh::Mesh() {
|
|
glGenVertexArrays(1, &m_vao);
|
|
glGenBuffers(1, &m_vbo);
|
|
glGenBuffers(1, &m_ebo);
|
|
|
|
glBindVertexArray(m_vao);
|
|
|
|
// VBO (vertex buffer)
|
|
glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
|
|
glBufferData(GL_ARRAY_BUFFER, 0, nullptr, GL_STATIC_DRAW);
|
|
|
|
// EBO (index buffer)
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 0, nullptr, GL_STATIC_DRAW);
|
|
|
|
Vertex::DefineAttrib();
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
glBindVertexArray(0);
|
|
}
|
|
|
|
Object::Object() {
|
|
m_vertices = std::vector<glm::vec3>();
|
|
m_normals = std::vector<glm::vec3>();
|
|
m_texCoords = std::vector<glm::vec2>();
|
|
}
|
|
|
|
void Object::LoadMaterials(const std::filesystem::path& filename) {
|
|
std::ifstream file(filename);
|
|
|
|
std::string currentMaterialName;
|
|
std::shared_ptr<Material> currentMaterial;
|
|
|
|
std::string line;
|
|
while (std::getline(file, line)) {
|
|
std::istringstream iss(line);
|
|
std::string prefix;
|
|
iss >> prefix;
|
|
switch(toMtlElement(prefix)) {
|
|
case MtlElement::MHASH:
|
|
{
|
|
std::cout << "comment: " << line << std::endl;
|
|
continue;
|
|
}
|
|
case MtlElement::NEWMTL:
|
|
{
|
|
if (currentMaterial) {
|
|
m_materials.insert(std::make_pair(currentMaterialName, std::move(currentMaterial)));
|
|
currentMaterial = nullptr;
|
|
}
|
|
std::string materialName;
|
|
iss >> materialName;
|
|
currentMaterialName = materialName;
|
|
currentMaterial = std::make_shared<Material>();
|
|
break;
|
|
}
|
|
case MtlElement::NS:
|
|
{
|
|
float weight;
|
|
iss >> weight;
|
|
currentMaterial->SetSpecularWeight(weight);
|
|
}
|
|
case MtlElement::KA:
|
|
{
|
|
float r, g, b;
|
|
iss >> r >> g >> b;
|
|
currentMaterial->SetAmbientColor(glm::vec3(r, g, b));
|
|
break;
|
|
}
|
|
case MtlElement::KS:
|
|
{
|
|
float r, g, b;
|
|
iss >> r >> g >> b;
|
|
currentMaterial->SetSpecularColor(glm::vec3(r, g, b));
|
|
break;
|
|
}
|
|
case MtlElement::KD:
|
|
{
|
|
float r, g, b;
|
|
iss >> r >> g >> b;
|
|
currentMaterial->SetDiffuseColor(glm::vec3(r, g, b));
|
|
break;
|
|
}
|
|
case MtlElement::D:
|
|
{
|
|
float d;
|
|
iss >> d;
|
|
currentMaterial->SetOpacity(d);
|
|
break;
|
|
}
|
|
case MtlElement::ILLUM:
|
|
{
|
|
int illum;
|
|
iss >> illum;
|
|
currentMaterial->SetIllumination(illum);
|
|
break;
|
|
}
|
|
case MtlElement::MAP_KD:
|
|
{
|
|
std::string texturePath;
|
|
std::string part;
|
|
while (iss >> part) {
|
|
texturePath += part + " ";
|
|
}
|
|
texturePath = texturePath.substr(0, texturePath.size() - 1);
|
|
currentMaterial->SetDiffuseTexture(Texture::LoadFile(texturePath));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentMaterial) {
|
|
// m_materials.insert(std::make_pair(currentMaterialName, std::move(currentMaterial)));
|
|
AddMaterial(currentMaterialName, std::move(currentMaterial));
|
|
}
|
|
}
|
|
|
|
void Object::AddMaterial(std::string name, std::shared_ptr<Material> material)
|
|
{
|
|
m_materials.insert(std::make_pair(std::move(name), std::move(material)));
|
|
}
|
|
|
|
std::shared_ptr<Material> Object::GetMaterial(std::string name)
|
|
{
|
|
auto material = m_materials.find(name);
|
|
if (material == m_materials.end()) return nullptr;
|
|
return material->second;
|
|
}
|
|
|
|
void Object::CreateNewMesh(const std::string& materialName)
|
|
{
|
|
Mesh mesh;
|
|
mesh.materialName = materialName;
|
|
m_meshes.push_back(mesh);
|
|
}
|
|
|
|
Mesh& Object::GetLastMesh()
|
|
{
|
|
if (m_meshes.empty()) {
|
|
auto material = std::make_shared<Material>();
|
|
material->SetAmbientColor(glm::vec3(0.52f, 0.52f, 0.52f));
|
|
// TODO: come up with name for a default material
|
|
AddMaterial("", std::move(material));
|
|
CreateNewMesh("");
|
|
}
|
|
return m_meshes.back();
|
|
}
|
|
|
|
Object Object::LoadFile(const std::string& filename) {
|
|
std::ifstream file(filename);
|
|
|
|
Object obj;
|
|
|
|
std::string line;
|
|
while (std::getline(file, line)) {
|
|
std::istringstream iss(line);
|
|
std::string prefix;
|
|
iss >> prefix;
|
|
switch(toElement(prefix)) {
|
|
// comment
|
|
case ObjElement::OHASH:
|
|
{
|
|
std::cout << "comment: " << line << std::endl;
|
|
continue;
|
|
}
|
|
case ObjElement::MTLLIB:
|
|
{
|
|
std::string mtlFile;
|
|
iss >> mtlFile;
|
|
std::filesystem::path fullPath = filename;
|
|
std::filesystem::path mtlPath = fullPath.replace_filename(mtlFile);
|
|
obj.LoadMaterials(mtlPath);
|
|
std::cout << "loaded mtl at '" << mtlPath << "' with "
|
|
<< obj.m_materials.size() << " materials" << std::endl;
|
|
break;
|
|
}
|
|
case ObjElement::USEMTL:
|
|
{
|
|
std::string materialName;
|
|
iss >> materialName;
|
|
auto& mesh = obj.GetLastMesh();
|
|
if (mesh.materialName != materialName) {
|
|
Mesh mesh;
|
|
mesh.materialName = materialName;
|
|
obj.m_meshes.push_back(mesh);
|
|
}
|
|
break;
|
|
}
|
|
// object name I suppose
|
|
case ObjElement::O:
|
|
{
|
|
obj.m_name = line.substr(2);
|
|
break;
|
|
}
|
|
// vertex with its position
|
|
case ObjElement::V:
|
|
{
|
|
float x, y, z, w;
|
|
w = 1.0f;
|
|
iss >> x >> y >> z;
|
|
if (iss >> w) {
|
|
x /= w;
|
|
y /= w;
|
|
z /= w;
|
|
}
|
|
obj.m_vertices.emplace_back(x, y, z);
|
|
break;
|
|
}
|
|
case ObjElement::VN:
|
|
{
|
|
float x, y, z;
|
|
iss >> x >> y >> z;
|
|
obj.m_normals.emplace_back(x, y, z);
|
|
break;
|
|
}
|
|
case ObjElement::VT:
|
|
{
|
|
float u, v;
|
|
iss >> u >> v;
|
|
obj.m_texCoords.emplace_back(u, 1.0f - v);
|
|
break;
|
|
}
|
|
case ObjElement::F:
|
|
{
|
|
auto& mesh = obj.GetLastMesh();
|
|
std::string token;
|
|
|
|
while (iss >> token) {
|
|
std::string a, b, c;
|
|
std::istringstream ref(token);
|
|
|
|
std::getline(ref, a, '/');
|
|
std::getline(ref, b, '/');
|
|
std::getline(ref, c, '/');
|
|
|
|
int vi = Object::NormalizeIndex(a, (int)obj.m_vertices.size());
|
|
int ti = Object::NormalizeIndex(b, (int)obj.m_texCoords.size());
|
|
int ni = Object::NormalizeIndex(c, (int)obj.m_normals.size());
|
|
|
|
glm::vec3 vert, norm;
|
|
glm::vec2 texCoord;
|
|
vert = obj.m_vertices[vi];
|
|
if (ni >= 0) norm = obj.m_normals[ni];
|
|
if (ti >= 0) texCoord = obj.m_texCoords[ti];
|
|
|
|
mesh.m_vertexBuffer.emplace_back(vert, norm, texCoord);
|
|
mesh.m_indexBuffer.push_back(mesh.m_vertexBuffer.size() - 1);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::cout << "Object name: " << obj.m_name << std::endl;
|
|
std::cout << "Vertices count: " << obj.m_vertices.size() << std::endl;
|
|
std::cout << "Normals count: " << obj.m_normals.size() << std::endl;
|
|
std::cout << "TexCoords count: " << obj.m_texCoords.size() << std::endl;
|
|
std::cout << "Meshes count: " << obj.m_meshes.size() << std::endl;
|
|
std::cout << "Materials count: " << obj.m_materials.size() << std::endl;
|
|
|
|
// std::cout << "Vertex Buffer size: " << obj.m_vertexBuffer.size() << std::endl;
|
|
// std::cout << "Index Buffer size: " << obj.m_indexBuffer.size() << std::endl;
|
|
|
|
file.close();
|
|
|
|
for (auto &mesh : obj.m_meshes) {
|
|
mesh.Upload();
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
void Object::Render(Shader& shader)
|
|
{
|
|
for (auto &mesh : m_meshes) {
|
|
auto material = GetMaterial(mesh.materialName);
|
|
|
|
shader.setFloat("ambientStrength", 0.2f);
|
|
shader.setFloat("shininess", material->GetSpecularWeight());
|
|
shader.setFloat("opacity", material->GetOpacity());
|
|
shader.setBool("useSpecular", material->GetIllumination() >= 2);
|
|
shader.setFloat("specularStrength", 1.0f);
|
|
shader.setVec3("ambientColor", material->GetAmbientColor());
|
|
shader.setVec3("diffuseColor", material->GetDiffuseColor());
|
|
shader.setVec3("specularColor", material->GetSpecularColor());
|
|
|
|
if (material->HasDiffuseTexture()) {
|
|
shader.setBool("useTexture", true);
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, material->GetDiffuseTexture()->GetID());
|
|
shader.setInt("diffuseTex", 0);
|
|
} else {
|
|
shader.setBool("useTexture", false);
|
|
}
|
|
|
|
mesh.Render();
|
|
}
|
|
}
|
|
|
|
void Mesh::Upload()
|
|
{
|
|
glBindVertexArray(m_vao);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
|
|
glBufferData(GL_ARRAY_BUFFER, m_vertexBuffer.size() * sizeof(Vertex), m_vertexBuffer.data(), GL_STATIC_DRAW);
|
|
|
|
// Upload indices
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer.size() * sizeof(unsigned int), m_indexBuffer.data(), GL_STATIC_DRAW);
|
|
|
|
glBindVertexArray(0);
|
|
}
|
|
|
|
void Mesh::Render()
|
|
{
|
|
Bind();
|
|
glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(m_indexBuffer.size()), GL_UNSIGNED_INT, 0);
|
|
Unbind();
|
|
}
|