237 lines
8.9 KiB
C++
237 lines
8.9 KiB
C++
#include "light/light.h"
|
|
#include "primitive/triangle.h"
|
|
#include "scene/scene.h"
|
|
#include "shader/shader.h"
|
|
#include <array>
|
|
#include <cassert>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
const std::string WHITESPACE = " \n\r\t\f\v";
|
|
std::string ltrim(const std::string &s) {
|
|
size_t start = s.find_first_not_of(WHITESPACE);
|
|
return (start == std::string::npos) ? "" : s.substr(start);
|
|
}
|
|
|
|
std::string rtrim(const std::string &s) {
|
|
size_t end = s.find_last_not_of(WHITESPACE);
|
|
return (end == std::string::npos) ? "" : s.substr(0, end + 1);
|
|
}
|
|
|
|
std::string trim(const std::string &s) { return rtrim(ltrim(s)); }
|
|
|
|
void Scene::add(const std::shared_ptr<Light> &light) { this->lights_.push_back(light); }
|
|
|
|
void Scene::add(const std::shared_ptr<Primitive> &primitive) {
|
|
assert(primitive->shader() != nullptr);
|
|
this->primitives_.push_back(primitive);
|
|
}
|
|
|
|
void Scene::addObj(char const *fileName, Vector3d const &scale, Vector3d const &translation,
|
|
const std::shared_ptr<Shader> &shader, bool flipU, bool flipV) {
|
|
std::vector<std::shared_ptr<Primitive>> triangles = loadObj(fileName, scale, translation, shader, flipU, flipV);
|
|
this->primitives_.insert(this->primitives_.end(), std::make_move_iterator(triangles.begin()),
|
|
std::make_move_iterator(triangles.end()));
|
|
}
|
|
|
|
std::vector<std::shared_ptr<Primitive>> Scene::loadObj(char const *fileName, Vector3d const &scale,
|
|
Vector3d const &translation,
|
|
const std::shared_ptr<Shader> &shader, bool flipU, bool flipV) {
|
|
std::vector<std::shared_ptr<Primitive>> faces;
|
|
std::vector<std::array<int, 3>> indices;
|
|
|
|
// Open file from disk
|
|
std::ifstream file;
|
|
file.open(fileName);
|
|
if (!file.is_open()) {
|
|
std::cout << "(Scene): Could not open .obj file: " << fileName << std::endl;
|
|
return std::vector<std::shared_ptr<Primitive>>();
|
|
}
|
|
|
|
// Print the file name
|
|
std::cout << "(Scene): Loading \"" << fileName << "\"" << std::endl;
|
|
|
|
// Actual model data
|
|
std::vector<Vector3d> vData;
|
|
std::vector<Vector3d> tangentData;
|
|
std::vector<Vector3d> bitangentData;
|
|
std::vector<Vector3d> normalData;
|
|
std::vector<Vector3d> vnData;
|
|
std::vector<Vector2d> vtData;
|
|
|
|
// Read vertices, normals, textures, and faces from the file
|
|
std::string line;
|
|
while (getline(file, line)) {
|
|
std::stringstream lineStream(trim(line));
|
|
std::string type;
|
|
lineStream >> type;
|
|
|
|
// Vertices
|
|
if (type == "v") {
|
|
float x, y, z;
|
|
lineStream >> x >> y >> z;
|
|
vData.emplace_back(componentProduct(Vector3d(x, y, z), scale) + translation);
|
|
tangentData.emplace_back();
|
|
bitangentData.emplace_back();
|
|
normalData.emplace_back();
|
|
}
|
|
|
|
// Texture coordinates
|
|
if (type == "vt") {
|
|
float u, v;
|
|
lineStream >> u >> v;
|
|
vtData.emplace_back(flipU ? 1.0f - u : u, flipV ? 1.0f - v : v);
|
|
}
|
|
|
|
// Normals
|
|
if (type == "vn") {
|
|
float a, b, c;
|
|
lineStream >> a >> b >> c;
|
|
vnData.emplace_back(normalized(componentQuotient(
|
|
Vector3d(a, b, c),
|
|
scale))); // Division needed for preventing stretched normals, normals' = (transform^-1)^T * normals
|
|
}
|
|
|
|
// Faces
|
|
if (type == "f") {
|
|
std::string vertex[3];
|
|
std::array<int, 3> vertInd = {-1, -1, -1};
|
|
std::array<int, 3> texInd = {-1, -1, -1};
|
|
std::array<int, 3> normInd = {-1, -1, -1};
|
|
lineStream >> vertex[0] >> vertex[1] >> vertex[2];
|
|
|
|
// triangulate polygons, like quads (which must be given in triangle fan notation)
|
|
while (!vertex[2].empty()) {
|
|
auto triangle = std::make_shared<Triangle>(shader);
|
|
|
|
for (int i = 0; i < 3; ++i) {
|
|
std::stringstream vertexSteam(vertex[i]);
|
|
std::string reference;
|
|
|
|
// vertex index
|
|
getline(vertexSteam, reference, '/');
|
|
try {
|
|
vertInd[i] = stoi(reference) - 1;
|
|
triangle->setVertex(i, vData.at(vertInd[i]));
|
|
} catch (...) {
|
|
std::cout << "Error: vertex index invalid on line \"" << line << "\"" << std::endl;
|
|
}
|
|
|
|
// texture index
|
|
if (getline(vertexSteam, reference, '/')) {
|
|
if (!reference.empty()) {
|
|
try {
|
|
texInd[i] = stoi(reference) - 1;
|
|
triangle->setSurface(i, vtData.at(texInd[i]));
|
|
} catch (...) {
|
|
std::cout << "Error: texture coordinate index invalid on line \"" << line << "\"" << std::endl;
|
|
}
|
|
}
|
|
|
|
// normal index
|
|
if (getline(vertexSteam, reference, '/')) {
|
|
try {
|
|
normInd[i] = stoi(reference) - 1;
|
|
triangle->setNormal(i, vnData.at(normInd[i]));
|
|
} catch (...) {
|
|
std::cout << "Error: normal index invalid on line \"" << line << "\"" << std::endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// calculate and accumulate tangent and bitangent vectors
|
|
if (std::all_of(vertInd.begin(), vertInd.end(), [](int i) { return i > -1; }) &&
|
|
std::all_of(texInd.begin(), texInd.end(), [](int i) { return i > -1; })) {
|
|
for (int i = 0; i < 3; i++) {
|
|
const Vector3d deltaPos1 = vData.at(vertInd[(i + 1) % 3]) - vData.at(vertInd[i]);
|
|
const Vector3d deltaPos2 = vData.at(vertInd[(i + 2) % 3]) - vData.at(vertInd[i]);
|
|
|
|
const Vector2d deltaUV1 = vtData.at(texInd[(i + 1) % 3]) - vtData.at(texInd[i]);
|
|
const Vector2d deltaUV2 = vtData.at(texInd[(i + 2) % 3]) - vtData.at(texInd[i]);
|
|
|
|
const float r = 1.0f / (deltaUV1.u * deltaUV2.v - deltaUV1.v * deltaUV2.u);
|
|
tangentData[vertInd[i]] += (deltaPos1 * deltaUV2.v - deltaPos2 * deltaUV1.v) * r;
|
|
bitangentData[vertInd[i]] += (deltaPos2 * deltaUV1.u - deltaPos1 * deltaUV2.u) * r;
|
|
|
|
normalData[vertInd[i]] += crossProduct(tangentData[vertInd[i]], bitangentData[vertInd[i]]);
|
|
}
|
|
}
|
|
|
|
faces.push_back(triangle);
|
|
indices.push_back(vertInd);
|
|
|
|
// get the next triangle
|
|
if (lineStream.eof())
|
|
break;
|
|
|
|
vertex[1] = vertex[2];
|
|
lineStream >> vertex[2];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Close the file
|
|
file.close();
|
|
|
|
// set the normalized tangents and bitangents
|
|
for (int i = 0; i < faces.size(); i++) {
|
|
for (int j = 0; j < 3; j++) {
|
|
Vector3d tangent = normalized(tangentData[indices[i][j]]);
|
|
const Vector3d bitangent = normalized(bitangentData[indices[i][j]]);
|
|
// try to use the normal from the obj file, if it doesn't exist, use the computed normal
|
|
Vector3d normal = normalized(normalData[indices[i][j]]);
|
|
if (vnData.size() > 0)
|
|
normal = dynamic_cast<Triangle *>(faces[i].get())->getNormal(j);
|
|
|
|
// gram-schmidt orthogonalization
|
|
tangent = normalized(tangent - normal * dotProduct(normal, tangent));
|
|
// check handedness of coordinate system
|
|
if (dotProduct(crossProduct(normal, tangent), bitangent) < 0.0f)
|
|
tangent *= -1.0f;
|
|
|
|
dynamic_cast<Triangle *>(faces[i].get())->setTangent(j, tangent);
|
|
dynamic_cast<Triangle *>(faces[i].get())->setBitangent(j, bitangent);
|
|
dynamic_cast<Triangle *>(faces[i].get())->setNormal(j, normal);
|
|
}
|
|
}
|
|
|
|
// Debug output
|
|
std::cout << " -> " << vData.size() << " vertices parsed" << std::endl;
|
|
std::cout << " -> " << vnData.size() << " normals parsed" << std::endl;
|
|
std::cout << " -> " << vtData.size() << " uv-positions parsed" << std::endl;
|
|
std::cout << " -> " << faces.size() << " primitives parsed" << std::endl;
|
|
|
|
faces.push_back(std::make_shared<Triangle>(vertices[x - 1] * scale + translation,
|
|
vertices[y - 1] * scale + translation,
|
|
vertices[z - 1] * scale + translation,
|
|
vertex_normals[xn - 1], vertex_normals[yn - 1],
|
|
vertex_normals[zn - 1],
|
|
shader));
|
|
} else if (key == "#") {
|
|
file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
|
|
} else {
|
|
file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
|
|
}
|
|
}
|
|
file.close();
|
|
}
|
|
return faces;
|
|
}
|
|
|
|
Color Scene::traceRay(Ray &ray) const {
|
|
if (this->findIntersection(ray) && ray.remainingBounces-- > 0) {
|
|
// If the ray has hit an object, call the shader ...
|
|
return ray.primitive->shader()->shade(*this, ray);
|
|
} else if (this->environmentMap) {
|
|
// ... otherwise look up the environment map ...
|
|
float const phi = std::acos(ray.direction.y);
|
|
float const rho = std::atan2(ray.direction.z, ray.direction.x) + float(PI);
|
|
return this->environmentMap->color(rho / (2.0f * float(PI)), phi / float(PI));
|
|
} else {
|
|
// ... if all else fails, just return the background color
|
|
return this->backgroundColor;
|
|
}
|
|
}
|