tom/RT_GPU
1
0
Fork 0
mirror of https://github.com/TheRedShip/RT_GPU.git synced 2025-09-27 18:48:36 +02:00
Code Issues Packages Projects Releases Wiki Activity

~ | Vertex normal obj handling

Browse Source
This commit is contained in:
TheRedShip
2025-02-24 20:19:06 +01:00
committed by tomoron
parent 30ca774491
commit 62d0863ff4
11 changed files with 108 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
includes/RT/ObjParser.hpp
View File

@ -26,20 +26,22 @@ class ObjParser
private:
glm::vec3 getVertex(std::stringstream &line);
glm::vec2 getUV(std::stringstream &line);
glm::vec3 getNormals(std::stringstream &line);
void addFace(std::stringstream &line);
long int checkVertexIndex(int index, size_t size);
void parseMtl(std::stringstream &line, Scene &scene);
bool addTriangleFromPolygon(std::vector<glm::vec3> &vertices, std::vector<glm::vec2> &textureVertices, int inv);
void addTriangle(glm::vec3 v1, glm::vec3 v2, glm::vec3 v3, std::vector<glm::vec2> textureVertices);
bool addTriangleFromPolygon(std::vector<glm::vec3> &vertices, std::vector<glm::vec2> &textureVertices, std::vector<glm::vec3> &normalVertices, int inv);
void addTriangle(glm::vec3 v1, glm::vec3 v2, glm::vec3 v3, std::vector<glm::vec2> textureVertices, std::vector<glm::vec3> normalVertices);
std::string getFilePath(std::string &file);
int pointInTriangle(glm::vec3 pts[3], std::vector<glm::vec3> vertices, size_t cur);
std::vector<std::string> objSplit(std::string str, std::string delim);
void getFaceVertices(std::vector<glm::vec3> &faceVertices, std::vector<glm::vec2> &textureVertices, std::stringstream &line);
void getFaceVertices(std::vector<glm::vec3> &faceVertices, std::vector<glm::vec2> &textureVertices, std::vector<glm::vec3> &normalVertices, std::stringstream &line);
std::string _filename;
std::ifstream _file;
std::vector<glm::vec3> _vertices;
std::vector<glm::vec2> _textureVertices;
std::vector<glm::vec3> _normalVertices;
int _mat;
std::map<std::string, int> _matNames;

5
includes/RT/Scene.hpp
View File

@ -37,7 +37,10 @@ struct GPUTriangle
alignas(16) glm::vec3 position;
alignas(16) glm::vec3 vertex1;
alignas(16) glm::vec3 vertex2;
alignas(16) glm::vec3 normal;
alignas(16) glm::vec3 normal_vertex1;
alignas(16) glm::vec3 normal_vertex2;
alignas(16) glm::vec3 normal_vertex3;
alignas(8) glm::vec2 texture_vertex1;
alignas(8) glm::vec2 texture_vertex2;

24
includes/RT/objects/Triangle.hpp
View File

@ -52,12 +52,20 @@ class Triangle : public Object
_mat_index = mat_index;
}
Triangle(const glm::vec3& position, const glm::vec3& vertex2, const glm::vec3& vertex3,
const glm::vec2& vt1, const glm::vec2& vt2, const glm::vec2& vt3, const int mat_index)
const glm::vec2& vt1, const glm::vec2& vt2, const glm::vec2& vt3,
const glm::vec3& vn1, const glm::vec3& vn2, const glm::vec3& vn3,
const int mat_index)
: Object(position, mat_index), _vertex2(vertex2), _vertex3(vertex3),
_texture_vertex1(vt1), _texture_vertex2(vt2), _texture_vertex3(vt3)
_texture_vertex1(vt1), _texture_vertex2(vt2), _texture_vertex3(vt3),
_normal_vertex1(vn1), _normal_vertex2(vn2), _normal_vertex3(vn3)
{
_normal = glm::normalize(glm::cross(_vertex2 - _position, _vertex3 - _position)); //optimization
if (vn1 == glm::vec3(0.0f) && vn2 == glm::vec3(0.0f) && vn3 == glm::vec3(0.0f))
{
glm::vec3 normal = glm::normalize(glm::cross(_vertex2 - _position, _vertex3 - _position));
_normal_vertex1 = normal;
_normal_vertex2 = normal;
_normal_vertex3 = normal;
}
_centroid = (_position + _vertex2 + _vertex3) / 3.0f;
// _vertex2 -= _position; //optimization
// _vertex3 -= _position; //optimization
@ -67,6 +75,10 @@ class Triangle : public Object
const glm::vec2 &getTextureVertex2() const {return (_texture_vertex2); }
const glm::vec2 &getTextureVertex3() const {return (_texture_vertex3); }
const glm::vec3 &getNormalVertex1() const {return (_normal_vertex1); }
const glm::vec3 &getNormalVertex2() const {return (_normal_vertex2); }
const glm::vec3 &getNormalVertex3() const {return (_normal_vertex3); }
const glm::vec3 &getVertex2() const { return (_vertex2); }
const glm::vec3 &getVertex3() const { return (_vertex3); }
const glm::vec3 &getNormal() const { return (_normal); }
@ -83,6 +95,10 @@ class Triangle : public Object
glm::vec2 _texture_vertex2;
glm::vec2 _texture_vertex3;
glm::vec3 _normal_vertex1;
glm::vec3 _normal_vertex2;
glm::vec3 _normal_vertex3;
glm::vec3 _normal;
glm::vec3 _centroid;

2
scenes/test.rt
View File

@ -7,5 +7,5 @@ MAT 255 255 255 1.0 0.0 0.0 LAM 0 // 1
# sp 0 2 0 150 1
# pl 0 0 0 0 1 0 0
OBJ obj/castle.obj
OBJ obj/lambo2.obj 0 0 0 0.25

13
shaders/debug.glsl
View File

@ -55,7 +55,10 @@ struct GPUTriangle
vec3 position;
vec3 vertex1;
vec3 vertex2;
vec3 normal;
vec3 normal_vertex1;
vec3 normal_vertex2;
vec3 normal_vertex3;
vec2 texture_vertex1;
vec2 texture_vertex2;
@ -189,7 +192,8 @@ hitInfo traceBVH(Ray ray, GPUBvhData bvh_data, inout Stats stats)
{
hit.t = temp_hit.t;
hit.obj_index = bvh_data.triangle_start_index + node.index + i;
hit.normal = temp_hit.normal;
hit.u = temp_hit.u;
hit.v = temp_hit.v;
}
}
}
@ -260,8 +264,9 @@ hitInfo traverseBVHs(Ray ray, inout Stats stats)
vec3 position = transformedRay.origin + transformedRay.direction * temp_hit.t;
hit.position = inverseTransformMatrix * position + bvh_data.offset;
vec3 based_normal = triangle.normal * sign(-dot(transformedRay.direction, triangle.normal));
hit.normal = normalize(inverseTransformMatrix * based_normal);
vec3 normal = normalize(triangle.normal_vertex1 * (1.0 - hit.u - hit.v) + triangle.normal_vertex2 * hit.u + triangle.normal_vertex3 * hit.v);
vec3 directed_normal = normal * sign(-dot(transformedRay.direction, normal));
hit.normal = normalize(inverseTransformMatrix * directed_normal);
}
}

1
shaders/denoising.glsl
View File

@ -68,6 +68,7 @@ void main()
}
}
light *= (1.0 / totalWeight);
light.a = 1.0;
if (u_pass == u_pass_count - 1)
{
vec4 color = light * imageLoad(color_texture, pixel_coords);

5
shaders/intersect.glsl
View File

@ -102,10 +102,6 @@ bool intersectTriangle(Ray ray, GPUTriangle obj, out hitInfo hit)
hit.v >= 0.0 && (hit.u + hit.v) <= 1.0 &&
hit.t > 0.0;
// hit.position = ray.origin + ray.direction * t;
// hit.normal = obj.normal * sign(-dot(ray.direction, obj.normal));
// hit.normal = vec3(u, v, 1 - (u + v)); //texture mapping
return (valid);
}
@ -114,7 +110,6 @@ bool intersectTriangle(Ray ray, GPUObject obj, out hitInfo hit)
GPUTriangle tri;
tri.position = obj.position;
tri.normal = obj.normal;
tri.vertex1 = obj.vertex1;
tri.vertex2 = obj.vertex2;

13
shaders/raytracing.glsl
View File

@ -30,7 +30,10 @@ struct GPUTriangle
vec3 position;
vec3 vertex1;
vec3 vertex2;
vec3 normal;
vec3 normal_vertex1;
vec3 normal_vertex2;
vec3 normal_vertex3;
vec2 texture_vertex1;
vec2 texture_vertex2;
@ -202,10 +205,10 @@ vec3[2] pathtrace(Ray ray, inout uint rng_state)
if (i == 0)
{
imageStore(normal_texture, ivec2(gl_GlobalInvocationID.xy), vec4(normalize(hit.normal), 1.0));
imageStore(position_texture, ivec2(gl_GlobalInvocationID.xy), vec4(normalize(hit.position), 1.0));
// vec4 accum_normal = accumulate(normal_texture, accum_normal, normalize(hit.normal));
// vec4 accum_position = accumulate(position_texture, accum_position, normalize(hit.position));
// imageStore(normal_texture, ivec2(gl_GlobalInvocationID.xy), vec4(normalize(hit.normal), 1.0));
// imageStore(position_texture, ivec2(gl_GlobalInvocationID.xy), vec4(normalize(hit.position), 1.0));
vec4 accum_normal = accumulate(normal_texture, accum_normal, normalize(hit.normal));
vec4 accum_position = accumulate(position_texture, accum_position, normalize(hit.position));
}
float p = max(color.r, max(color.g, color.b));

5
shaders/trace.glsl
View File

@ -157,8 +157,9 @@ hitInfo traverseBVHs(Ray ray)
vec3 position = transformedRay.origin + transformedRay.direction * temp_hit.t;
hit.position = inverseTransformMatrix * position + bvh_data.offset;
vec3 based_normal = triangle.normal * sign(-dot(transformedRay.direction, triangle.normal));
hit.normal = normalize(inverseTransformMatrix * based_normal);
vec3 normal = normalize(triangle.normal_vertex1 * (1.0 - hit.u - hit.v) + triangle.normal_vertex2 * hit.u + triangle.normal_vertex3 * hit.v);
vec3 directed_normal = normal * sign(-dot(transformedRay.direction, normal));
hit.normal = normalize(inverseTransformMatrix * directed_normal);
}
}

61
srcs/class/ObjParser.cpp
View File

@ -58,6 +58,15 @@ glm::vec2 ObjParser::getUV(std::stringstream &line)
return(res);
}
glm::vec3 ObjParser::getNormals(std::stringstream &line)
{
glm::vec3 res;
if(!(line >> res.x) || !(line >> res.y) || (!(line >> res.z)) && !line.eof())
throw std::runtime_error("syntax error in obj file while parsing normal vertex");
return(res);
}
long int ObjParser::checkVertexIndex(int index, size_t size)
{
if((size_t)index > size || index == 0 || (index < 0 && (size_t)(-index) > size))
@ -97,10 +106,11 @@ int ObjParser::pointInTriangle(glm::vec3 pts[3], std::vector<glm::vec3> vertices
return(0);
}
bool ObjParser::addTriangleFromPolygon(std::vector<glm::vec3> &vertices, std::vector<glm::vec2> &textureVertices, int inv)
bool ObjParser::addTriangleFromPolygon(std::vector<glm::vec3> &vertices, std::vector<glm::vec2> &textureVertices, std::vector<glm::vec3> &normalVertices, int inv)
{
glm::vec3 v1, v2, v3;
glm::vec2 vt1, vt2, vt3;
glm::vec3 vn1, vn2, vn3;
float dot;
@ -110,11 +120,13 @@ bool ObjParser::addTriangleFromPolygon(std::vector<glm::vec3> &vertices, std::ve
{
v1 = vertices.back();
vt1 = textureVertices.back();
vn1 = normalVertices.back();
}
else
{
v1 = vertices[i - 1];
vt1 = textureVertices[i - 1];
vn1 = normalVertices[i - 1];
}
v2 = vertices[i];
v3 = vertices[(i + 1) % vertices.size()];
@ -122,6 +134,9 @@ bool ObjParser::addTriangleFromPolygon(std::vector<glm::vec3> &vertices, std::ve
vt2 = textureVertices[i];
vt3 = textureVertices[(i + 1) % textureVertices.size()];
vn2 = normalVertices[i];
vn3 = normalVertices[(i + 1) % normalVertices.size()];
if (inv)
dot = glm::cross(v2 - v1, v2 - v3).z;
else
@ -133,14 +148,19 @@ bool ObjParser::addTriangleFromPolygon(std::vector<glm::vec3> &vertices, std::ve
continue;
vertices.erase(vertices.begin() + i);
textureVertices.erase(textureVertices.begin() + i);
normalVertices.erase(normalVertices.begin() + i);
std::vector<glm::vec2> texture;
texture.push_back(vt1);
texture.push_back(vt2);
texture.push_back(vt3);
addTriangle(v1, v2, v3, texture);
std::vector<glm::vec3> normals;
normals.push_back(vn1);
normals.push_back(vn2);
normals.push_back(vn3);
addTriangle(v1, v2, v3, texture, normals);
return(1);
}
return(0);
@ -159,7 +179,7 @@ std::vector<std::string> ObjParser::objSplit(std::string str, std::string delim)
return(res);
}
void ObjParser::getFaceVertices(std::vector<glm::vec3> &faceVertices, std::vector<glm::vec2> &textureVertices, std::stringstream &line)
void ObjParser::getFaceVertices(std::vector<glm::vec3> &faceVertices, std::vector<glm::vec2> &textureVertices, std::vector<glm::vec3> &normalVertices, std::stringstream &line)
{
std::string el;
std::vector<std::string> sp;
@ -174,6 +194,9 @@ void ObjParser::getFaceVertices(std::vector<glm::vec3> &faceVertices, std::vecto
if (sp.size() > 1 && sp[1].length())
textureVertices.push_back(_textureVertices[checkVertexIndex(std::stoi(sp[1]), _textureVertices.size())]);
if (sp.size() > 2 && sp[2].length())
normalVertices.push_back(_normalVertices[checkVertexIndex(std::stoi(sp[2]), _normalVertices.size())]);
faceVertices.push_back(_vertices[checkVertexIndex(std::stoi(sp[0]), _vertices.size())]);
}
}
@ -182,29 +205,34 @@ void ObjParser::addFace(std::stringstream &line)
{
std::vector<glm::vec3> faceVertices;
std::vector<glm::vec2> textureVertices;
std::vector<glm::vec3> normalVertices;
getFaceVertices(faceVertices, textureVertices, line);
getFaceVertices(faceVertices, textureVertices, normalVertices, line);
if(!line.eof())
throw std::runtime_error("OBJ : an error occured while paring face");
if(faceVertices.size() < 3)
throw std::runtime_error("OBJ : face does not have enough vertices");
while(faceVertices.size() > 3)
if (!addTriangleFromPolygon(faceVertices, textureVertices, 0))
if(!addTriangleFromPolygon(faceVertices, textureVertices, 1))
if (!addTriangleFromPolygon(faceVertices, textureVertices, normalVertices, 0))
if(!addTriangleFromPolygon(faceVertices, textureVertices, normalVertices, 1))
return ;
if(!line.eof())
throw std::runtime_error("OBJ: an error occured while parsing face");
addTriangle(faceVertices[0], faceVertices[1], faceVertices[2], textureVertices);
addTriangle(faceVertices[0], faceVertices[1], faceVertices[2], textureVertices, normalVertices);
}
void ObjParser::addTriangle(glm::vec3 v1, glm::vec3 v2, glm::vec3 v3, std::vector<glm::vec2> texture_vertices)
void ObjParser::addTriangle(glm::vec3 v1, glm::vec3 v2, glm::vec3 v3, std::vector<glm::vec2> texture_vertices, std::vector<glm::vec3> normal_vertices)
{
glm::vec2 vt1 = glm::vec2(0.);
glm::vec2 vt2 = glm::vec2(0.);
glm::vec2 vt3 = glm::vec2(0.);
glm::vec3 vn1 = glm::vec3(0.);
glm::vec3 vn2 = glm::vec3(0.);
glm::vec3 vn3 = glm::vec3(0.);
if (texture_vertices.size() == 3)
{
vt1 = texture_vertices[0];
@ -212,7 +240,14 @@ void ObjParser::addTriangle(glm::vec3 v1, glm::vec3 v2, glm::vec3 v3, std::vecto
vt3 = texture_vertices[2];
}
_triangles.push_back(Triangle(v1, v2, v3, vt1, vt2, vt3, _mat));
if (normal_vertices.size() == 3)
{
vn1 = glm::normalize(normal_vertices[0]);
vn2 = glm::normalize(normal_vertices[1]);
vn3 = glm::normalize(normal_vertices[2]);
}
_triangles.push_back(Triangle(v1, v2, v3, vt1, vt2, vt3, vn1, vn2, vn3, _mat));
}
void ObjParser::parseMtl(std::stringstream &input_line, Scene &scene)
@ -286,7 +321,9 @@ void ObjParser::parseMtl(std::stringstream &input_line, Scene &scene)
float x, y, z;
if(!(lineStream >> x >> y >> z))
throw std::runtime_error("OBJ: syntax error while getting material emission");
mat->emission = (x + y + z) / 3;
if (mat->color == glm::vec3(0.0f))
mat->color = glm::vec3(x, y, z);
mat->emission = (x + y + z);
}
else if(identifier == "Ni")
{
@ -384,6 +421,8 @@ void ObjParser::parse(Scene &scene, glm::vec3 offset, float scale, glm::mat4 tra
_vertices.push_back(getVertex(lineStream));
else if (identifier == "vt")
_textureVertices.push_back(getUV(lineStream));
else if (identifier == "vn")
_normalVertices.push_back(getNormals(lineStream));
else if (identifier == "f")
addFace(lineStream);
else if (identifier == "mtllib")

15
srcs/class/Scene.cpp
View File

@ -115,17 +115,7 @@ void Scene::addObject(Object *obj)
}
else if (obj->getType() == Object::Type::TRIANGLE)
{
GPUTriangle gpu_triangle;
auto triangle = static_cast<Triangle *>(obj);
gpu_triangle.position = triangle->getPosition();
gpu_triangle.mat_index = triangle->getMaterialIndex();
gpu_triangle.vertex1 = triangle->getVertex2();
gpu_triangle.vertex2 = triangle->getVertex3();
gpu_triangle.normal = triangle->getNormal();
_gpu_triangles.push_back(gpu_triangle);
gpu_obj.vertex1 = triangle->getVertex2();
gpu_obj.vertex2 = triangle->getVertex3();
@ -188,12 +178,15 @@ void Scene::addBvh(std::vector<Triangle> &triangles, glm::vec3 offset, float sc
gpu_triangle.vertex1 = triangles[i].getVertex2();
gpu_triangle.vertex2 = triangles[i].getVertex3();
gpu_triangle.normal = triangles[i].getNormal();
gpu_triangle.texture_vertex1 = triangles[i].getTextureVertex1();
gpu_triangle.texture_vertex2 = triangles[i].getTextureVertex2();
gpu_triangle.texture_vertex3 = triangles[i].getTextureVertex3();
gpu_triangle.normal_vertex1 = triangles[i].getNormalVertex1();
gpu_triangle.normal_vertex2 = triangles[i].getNormalVertex2();
gpu_triangle.normal_vertex3 = triangles[i].getNormalVertex3();
_gpu_triangles.push_back(gpu_triangle);
}