ObjLoader.cpp

#include "ObjLoader.h"

// Custom libraries
#include "object3D.h"
#include "sanitize.h"

// External libraries
#include <glad/glad.h>
#include <glm/glm.hpp>

// Standard libraries
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>

constexpr char VERT[] = "v";	// Vertex position.
constexpr char NORMAL[] = "vn"; // Vertex normals.
constexpr char UVS[] = "vt";	// Vertex texture coordinates.
constexpr char INDEX[] = "f";	// Index data.

// Object indicies delimeter
#define INDEX_DEL '/'

void importOBJAsset(Object3D* object, const char* filepath, const glm::vec4* rgba)
{
	// Sanitization checks
	checkptr(object)
	if (!CHECK_CLASS(object, Object3D*)) throw std::runtime_error("ERROR: The input object is not Object3D");
	checkptr(filepath)

	std::ifstream file(filepath, std::ios::in);
	if (file.fail()) { std::cout << "ERROR: Filepath is invalid, may not exist or may be incorrect at... " << filepath << std::endl; return; }

	std::vector<glm::vec3> tmp_positions, tmp_normals;
	std::vector<glm::vec2> tmp_uvs;
	
	// Index: 5/1/1 --- pos/uv/normals.
	// Obj index 1 is 0 in C++.
	std::vector<GLuint> temp_index_pos, temp_index_uvs, temp_index_normals;

	// Temporary information to store vertex positional, normal and texture coordinate information.
	GLdouble x, y, z;

	// Read every line on file. - https://stackoverflow.com/questions/7868936/read-file-line-by-line-using-ifstream-in-c - Date Accessed: 19/11/2023
#pragma omp parallel
	{
#pragma omp parallel for
		for (std::string line; std::getline(file, line);) {
			std::stringstream ss(line);
			std::string string;
			ss >> string;

			// Get all vertices and indices and store into temporary vectors.
			if (string == VERT) {
				ss >> x >> y >> z;
				tmp_positions.push_back({ x,y,z });
			}

			// Fetch all vertex normal data.
			if (string == NORMAL) {
				ss >> x >> y >> z;
				tmp_normals.push_back({ x,y,z });
			}

			// Fetch all vertex UV normal data.
			if (string == UVS) {
				ss >> x >> y;
				// Flip Y-axis UV correction.
				tmp_uvs.push_back(glm::vec2(x, 1 - y));
			}

			if (string == INDEX) {
				std::string index;

				while (ss >> index) {
					std::stringstream ss_data(index);
					size_t i = 0;
					// Split current index into separate elements with the '/' delimeter.
					for (std::string data; std::getline(ss_data, data, INDEX_DEL); ++i) {

						// 0 - Vertex position index
						if (i == 0) {
							temp_index_pos.push_back((std::stoi(data) - 1));
						}
						// 1 - Vertex texture coordinates index.
						else if (i == 1) {
							temp_index_uvs.push_back((std::stoi(data) - 1));
						}
						// 2 - 2 - Vertex normals index.
						else if (i == 2) {
							temp_index_normals.push_back((std::stoi(data) - 1));
						}
					}
				}
			}
		}
	}

	// Copy information
	#pragma omp parallel for
	for (GLuint& index : temp_index_pos) {
		object->vertex_positions.push_back(tmp_positions[index]);
	}

	#pragma omp parallel for
	for (GLuint& index : temp_index_uvs) {
		object->texture_coords.push_back(tmp_uvs[index]);
	}

	#pragma omp parallel for
	for (GLuint& index : temp_index_normals) {
		object->vertex_normals.push_back(tmp_normals[index]);
	}
	object->indices = temp_index_pos;

	// Assign colours
	if (rgba != nullptr) object->vertex_colours.assign(object->vertex_positions.size(), *rgba);
	else { object->vertex_colours.push_back({ 1,1,1,1 }); }

	// Reduce size for mem clearup.
	tmp_positions.clear();
	tmp_positions.resize(0);
	
	tmp_normals.clear();
	tmp_normals.resize(0);
	
	tmp_uvs.clear();
	tmp_uvs.resize(0);
	
	temp_index_pos.clear();
	temp_index_pos.resize(0);
	
	temp_index_uvs.clear();
	temp_index_uvs.resize(0);
	
	temp_index_normals.clear();
	temp_index_normals.resize(0);

}