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

+ | Multiple obj using multiple BVH

Browse Source
This commit is contained in:
TheRedShip
2025-01-19 22:40:02 +01:00
parent d7bf46e76e
commit 84b0f22127
11 changed files with 170 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
includes/RT/BVH.hpp
View File

@ -28,7 +28,7 @@ struct AABB
void grow( glm::vec3 p ) { min = glm::min( min, p ), max = glm::max( max, p ); }
float area()
float area()
{
glm::vec3 e = max - min;
return (e.x * e.y + e.y * e.z + e.z * e.x);
@ -45,15 +45,13 @@ struct BVHStats
class BVH
{
public:
BVH(std::vector<GPUTriangle> &primitives, int first_primitive, int primitive_count);
BVH(std::vector<Triangle> &triangles, int first_primitive, int primitive_count);
void showAABB(Scene *scene);
void updateBounds(std::vector <GPUTriangle> &primitives);
void subdivide(std::vector<GPUTriangle> &primitives);
void updateBounds(std::vector<Triangle> &triangles);
void subdivide(std::vector<Triangle> &triangles);
float evaluateSah(std::vector<GPUTriangle> &primitives, int axis, float pos);
float evaluateSah(std::vector<Triangle> &triangles, int axis, float pos);
int getSize();
int getLeaves();

2
includes/RT/ObjParser.hpp
View File

@ -39,6 +39,8 @@ class ObjParser
std::vector<glm::vec2> _textureVertices;
int _mat;
std::map<std::string, int> _matNames;
std::vector<Triangle> _triangles;
};
#endif

15
includes/RT/Scene.hpp
View File

@ -86,6 +86,14 @@ struct GPUBvh
int primitive_count;
};
struct GPUBvhData
{
alignas(16) glm::vec3 offset;
int bvh_start_index;
int triangle_start_index;
};
class Sphere;
class Camera;
@ -103,11 +111,15 @@ class Scene
void updateLightAndObjects(int mat_id);
std::set<int> getGPULights();
void addBvh(std::vector<Triangle> &triangles);
const std::vector<GPUObject> &getObjectData() const;
const std::vector<GPUTriangle> &getTriangleData() const;
std::vector<GPUMaterial> &getMaterialData();
std::vector<GPUBvh> &getBVH();
std::vector<GPUBvhData> &getBvhData();
std::vector<GPUBvh> &getBvh();
GPUVolume &getVolume();
GPUDebug &getDebug();
@ -116,6 +128,7 @@ class Scene
GPUMaterial getMaterial(int material_index);
private:
std::vector<GPUBvhData> _gpu_bvh_data;
std::vector<GPUBvh> _gpu_bvh;
std::vector<GPUObject> _gpu_objects;

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

@ -46,6 +46,7 @@ class Triangle : public Object
// _vertex3 -= _position; //optimization
_normal = glm::normalize(glm::cross(_vertex2 - _position, _vertex3 - _position)); //optimization
_centroid = (_position + _vertex2 + _vertex3) / 3.0f;
_mat_index = mat_index;
}
@ -55,11 +56,14 @@ class Triangle : public Object
// _vertex3 -= _position; //optimization
_normal = glm::normalize(glm::cross(_vertex2 - _position, _vertex3 - _position)); //optimization
_centroid = (_position + _vertex2 + _vertex3) / 3.0f;
}
const glm::vec3 &getVertex2() const { return (_vertex2); }
const glm::vec3 &getVertex3() const { return (_vertex3); }
const glm::vec3 &getNormal() const { return (_normal); }
const glm::vec3 &getCentroid() const { return (_centroid); }
Type getType() const override { return Type::TRIANGLE; }
@ -68,6 +72,8 @@ class Triangle : public Object
glm::vec3 _vertex3;
glm::vec3 _normal;
glm::vec3 _centroid;
};
#endif

3
scenes/dragon.rt
View File

@ -24,7 +24,8 @@ pl 0 -2 0 0 1 0 2 // floor
qu -1 1.999 -1 2 0 0 0 0 2 6
OBJ obj/Dragon_800K.obj
OBJ obj/Dragon_80K.obj
OBJ obj/Lowpoly_tree_sample.obj
po -1.99 -0.5 -0.5 0 1 0 0 0 1 1 4
po -0.5 -0.5 -1.99 0 1 0 1 0 0 0 4

52
shaders/debug.glsl
View File

@ -67,6 +67,18 @@ layout(std430, binding = 2) buffer TriangleBuffer
GPUTriangle triangles[];
};
struct GPUBvhData
{
vec3 offset;
int bvh_start_index;
int triangle_start_index;
};
layout(std430, binding = 3) buffer BvhDataBuffer
{
GPUBvhData BvhData[];
};
struct GPUBvh
{
vec3 min;
@ -80,9 +92,9 @@ struct GPUBvh
int first_primitive;
int primitive_count;
};
layout(std430, binding = 3) buffer BvhBuffer
layout(std430, binding = 4) buffer BvhBuffer
{
GPUBvh bvh[];
GPUBvh Bvh[];
};
uniform int u_objectsNum;
@ -133,7 +145,7 @@ int traceRay(Ray ray)
return (num_hit);
}
hitInfo traceBVH(Ray ray, inout Stats stats)
hitInfo traceBVH(Ray ray, GPUBvhData bvh_data, inout Stats stats)
{
hitInfo hit;
hitInfo hit_bvh;
@ -148,28 +160,28 @@ hitInfo traceBVH(Ray ray, inout Stats stats)
while (stack_ptr >= 0)
{
int current_index = stack[stack_ptr--];
GPUBvh node = bvh[current_index];
GPUBvh node = Bvh[bvh_data.bvh_start_index + current_index];
if (node.is_leaf != 0)
{
for (int i = 0; i < node.primitive_count; i++)
{
GPUTriangle obj = triangles[node.first_primitive + i];
GPUTriangle obj = triangles[bvh_data.triangle_start_index + node.first_primitive + i];
hitInfo temp_hit;
if (intersectTriangle(ray, obj, temp_hit) && temp_hit.t < hit.t)
{
hit.t = temp_hit.t;
hit.normal = temp_hit.normal;
hit.obj_index = node.first_primitive + i;
hit.obj_index = bvh_data.triangle_start_index + node.first_primitive + i;
}
stats.triangle_count++;
}
}
else
{
GPUBvh left_node = bvh[node.left_index];
GPUBvh right_node = bvh[node.right_index];
GPUBvh left_node = Bvh[bvh_data.bvh_start_index + node.left_index];
GPUBvh right_node = Bvh[bvh_data.bvh_start_index + node.right_index];
hitInfo left_hit;
hitInfo right_hit;
@ -198,6 +210,28 @@ hitInfo traceBVH(Ray ray, inout Stats stats)
return (hit);
}
hitInfo traverseBVHs(Ray ray, inout Stats stats)
{
hitInfo hit;
hit.t = 1e30;
hit.obj_index = -1;
for (int i = 0; i < u_bvhNum; i++)
{
ray.origin = i == 0 ? ray.origin : ray.origin + vec3(2., 0., 0.);
hitInfo temp_hit = traceBVH(ray, BvhData[i], stats);
if (temp_hit.t < hit.t)
{
hit.t = temp_hit.t;
hit.obj_index = temp_hit.obj_index;
hit.normal = temp_hit.normal;
}
}
return (hit);
}
Ray initRay(vec2 uv)
{
@ -216,7 +250,7 @@ vec3 debugColor(vec2 uv)
Ray ray = initRay(uv);
Stats stats = Stats(0, 0);
hitInfo hit = traceBVH(ray, stats);
hitInfo hit = traverseBVHs(ray, stats);
float box_display = float(stats.box_count) / float(debug.box_treshold);
float triangle_display = float(stats.triangle_count) / float(debug.triangle_treshold);

2
shaders/trace.glsl
View File

@ -130,7 +130,7 @@ hitInfo traceRay(Ray ray)
hitScene = traceScene(ray);
hit = hitBVH.t < hitScene.t ? hitBVH : hitScene;
#if 1
#if 0
if (hit.obj_index == -1 || objects[hit.obj_index].type != 5)
break ;
ray = portalRay(ray, hit);

25
srcs/RT.cpp
View File

@ -20,21 +20,22 @@ int main(int argc, char **argv)
return (1);
Window window(&scene, WIDTH, HEIGHT, "RT_GPU", 0);
Shader shader("shaders/vertex.vert", "shaders/frag.frag", "shaders/compute.glsl");
// Shader shader("shaders/vertex.vert", "shaders/frag.frag", "shaders/debug.glsl");
// Shader shader("shaders/vertex.vert", "shaders/frag.frag", "shaders/compute.glsl");
Shader shader("shaders/vertex.vert", "shaders/frag.frag", "shaders/debug.glsl");
GLint max_gpu_size;
glGetIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &max_gpu_size);
const std::vector<GPUObject> &object_data = scene.getObjectData();
const std::vector<GPUTriangle> &triangle_data = scene.getTriangleData();
const std::vector<GPUBvh> &bvh_data = scene.getBVH();
const std::vector<GPUBvh> &bvh_nodes = scene.getBvh();
const std::vector<GPUBvhData> &bvh_data = scene.getBvhData();
const std::vector<GPUMaterial> &material_data = scene.getMaterialData();
std::cout << "Sending " << object_data.size() << " objects for " << \
object_data.size() * sizeof(GPUObject) + \
triangle_data.size() * sizeof(GPUTriangle) + \
bvh_data.size() * sizeof(GPUBvh) + \
bvh_nodes.size() * sizeof(GPUBvh) + \
material_data.size() * sizeof(GPUMaterial) \
<< " / " << max_gpu_size << " bytes" << std::endl;
@ -50,23 +51,29 @@ int main(int argc, char **argv)
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUTriangle) * triangle_data.size(), triangle_data.data(), GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, trianglesSSBO);
GLuint bvh_nodesSSBO;
glGenBuffers(1, &bvh_nodesSSBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, bvh_nodesSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUBvhData) * bvh_data.size(), bvh_data.data(), GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, bvh_nodesSSBO);
GLuint bvhSSBO;
glGenBuffers(1, &bvhSSBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, bvhSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUBvh) * bvh_data.size(), bvh_data.data(), GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, bvhSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUBvh) * bvh_nodes.size(), bvh_nodes.data(), GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, bvhSSBO);
GLuint materialSSBO;
glGenBuffers(1, &materialSSBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, materialSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUMaterial) * material_data.size(), nullptr, GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, materialSSBO);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, materialSSBO);
GLuint lightSSBO;
glGenBuffers(1, &lightSSBO);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, lightSSBO);
glBufferData(GL_SHADER_STORAGE_BUFFER, scene.getGPULights().size() * sizeof(int), nullptr, GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, lightSSBO);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 6, lightSSBO);
GLuint cameraUBO;
@ -151,7 +158,7 @@ int main(int argc, char **argv)
shader.set_int("u_frameCount", window.getFrameCount());
shader.set_int("u_objectsNum", object_data.size());
shader.set_int("u_bvhNum", scene.getBVH().size());
shader.set_int("u_bvhNum", bvh_data.size());
shader.set_int("u_lightsNum", gpu_lights.size());
shader.set_int("u_pixelisation", window.getPixelisation());
shader.set_float("u_time", (float)(glfwGetTime()));

79
srcs/class/BVH.cpp
View File

@ -12,7 +12,7 @@
#include "BVH.hpp"
BVH::BVH(std::vector<GPUTriangle> &primitives, int first_primitive, int primitive_count) : _aabb(AABB(glm::vec3(1e30f), glm::vec3(-1e30f)))
BVH::BVH(std::vector<Triangle> &triangles, int first_primitive, int primitive_count) : _aabb(AABB(glm::vec3(1e30f), glm::vec3(-1e30f)))
{
_left = nullptr;
_right = nullptr;
@ -22,30 +22,27 @@ BVH::BVH(std::vector<GPUTriangle> &primitives, int first_primitive, int primitiv
_first_primitive = first_primitive;
_primitive_count = primitive_count;
updateBounds(primitives);
subdivide(primitives);
updateBounds(triangles);
subdivide(triangles);
}
void BVH::updateBounds(std::vector<GPUTriangle> &primitives)
void BVH::updateBounds(std::vector<Triangle> &triangles)
{
for (int i = 0; i < _primitive_count; i++)
{
GPUTriangle leaf_triangle = primitives[_first_primitive + i];
Triangle leaf_triangle = triangles[_first_primitive + i];
// if (leaf_triangle.type != (int)Object::Type::TRIANGLE)
// continue ;
_aabb.min = glm::min(_aabb.min, leaf_triangle.position);
_aabb.min = glm::min(_aabb.min, leaf_triangle.vertex1);
_aabb.min = glm::min(_aabb.min, leaf_triangle.vertex2);
_aabb.max = glm::max(_aabb.max, leaf_triangle.position);
_aabb.max = glm::max(_aabb.max, leaf_triangle.vertex1);
_aabb.max = glm::max(_aabb.max, leaf_triangle.vertex2);
_aabb.min = glm::min(_aabb.min, leaf_triangle.getPosition());
_aabb.min = glm::min(_aabb.min, leaf_triangle.getVertex2());
_aabb.min = glm::min(_aabb.min, leaf_triangle.getVertex3());
_aabb.max = glm::max(_aabb.max, leaf_triangle.getPosition());
_aabb.max = glm::max(_aabb.max, leaf_triangle.getVertex2());
_aabb.max = glm::max(_aabb.max, leaf_triangle.getVertex3());
}
}
float BVH::evaluateSah(std::vector<GPUTriangle> &primitives, int axis, float pos)
float BVH::evaluateSah(std::vector<Triangle> &triangles, int axis, float pos)
{
AABB left_box(glm::vec3(1e30f), glm::vec3(-1e30f));
AABB right_box(glm::vec3(1e30f), glm::vec3(-1e30f));
@ -55,22 +52,21 @@ float BVH::evaluateSah(std::vector<GPUTriangle> &primitives, int axis, float pos
for (int i = 0; i < _primitive_count; i++)
{
GPUTriangle triangle = primitives[_first_primitive + i];
glm::vec3 centroid = (triangle.position + triangle.vertex1 + triangle.vertex2) / 3.0f;
Triangle triangle = triangles[_first_primitive + i];
if (centroid[axis] < pos)
if (triangle.getCentroid()[axis] < pos)
{
left_count++;
left_box.grow( triangle.position );
left_box.grow( triangle.vertex1 );
left_box.grow( triangle.vertex2 );
left_box.grow( triangle.getPosition() );
left_box.grow( triangle.getVertex2() );
left_box.grow( triangle.getVertex3() );
}
else
{
right_count++;
right_box.grow( triangle.position );
right_box.grow( triangle.vertex1 );
right_box.grow( triangle.vertex2 );
right_box.grow( triangle.getPosition() );
right_box.grow( triangle.getVertex2() );
right_box.grow( triangle.getVertex3() );
}
}
float cost = left_count * left_box.area() + right_count * right_box.area();
@ -79,7 +75,7 @@ float BVH::evaluateSah(std::vector<GPUTriangle> &primitives, int axis, float pos
void BVH::subdivide(std::vector<GPUTriangle> &primitives)
void BVH::subdivide(std::vector<Triangle> &triangles)
{
if (_primitive_count <= 4)
return ;
@ -100,7 +96,7 @@ void BVH::subdivide(std::vector<GPUTriangle> &primitives)
float split_t = (i + 1) / (num_test_per_axis + 1.0f);
float candidate_pos = start_pos + (end_pos - start_pos) * split_t;
float cost = evaluateSah(primitives, axis, candidate_pos);
float cost = evaluateSah(triangles, axis, candidate_pos);
if (cost < best_cost)
{
@ -119,14 +115,13 @@ void BVH::subdivide(std::vector<GPUTriangle> &primitives)
while (i <= j)
{
GPUTriangle triangle = primitives[i];
glm::vec3 centroid = (triangle.position + triangle.vertex1 + triangle.vertex2) / 3.0f;
Triangle triangle = triangles[i];
if (centroid[axis] < split_pos)
if (triangle.getCentroid()[axis] < split_pos)
i++;
else
{
std::swap(primitives[i], primitives[j]);
std::swap(triangles[i], triangles[j]);
j--;
}
}
@ -138,32 +133,12 @@ void BVH::subdivide(std::vector<GPUTriangle> &primitives)
_is_leaf = false;
_left = new BVH(primitives, _first_primitive, left_count);
_right = new BVH(primitives, i , _primitive_count - left_count);
_left = new BVH(triangles, _first_primitive, left_count);
_right = new BVH(triangles, i , _primitive_count - left_count);
_primitive_count = 0;
}
void BVH::showAABB(Scene *scene)
{
if (!_is_leaf)
{
scene->addObject(new Sphere(_aabb.min, 0.5f, 6));
scene->addObject(new Sphere(_aabb.max, 0.5f, 6));
scene->addObject(new Sphere(glm::vec3(_aabb.min.x, _aabb.min.y, _aabb.max.z), 0.5f, 6));
scene->addObject(new Sphere(glm::vec3(_aabb.min.x, _aabb.max.y, _aabb.min.z), 0.5f, 6));
scene->addObject(new Sphere(glm::vec3(_aabb.max.x, _aabb.min.y, _aabb.min.z), 0.5f, 6));
scene->addObject(new Sphere(glm::vec3(_aabb.min.x, _aabb.max.y, _aabb.max.z), 0.5f, 6));
scene->addObject(new Sphere(glm::vec3(_aabb.max.x, _aabb.min.y, _aabb.max.z), 0.5f, 6));
scene->addObject(new Sphere(glm::vec3(_aabb.max.x, _aabb.max.y, _aabb.min.z), 0.5f, 6));
}
else
{
// _left->showAABB(scene);
// _right->showAABB(scene);
}
}
const AABB &BVH::getAABB() const
{
return (_aabb);

6
srcs/class/ObjParser.cpp
View File

@ -16,8 +16,10 @@ ObjParser::ObjParser(std::string &filename)
{
_mat = 0;
_file.open(filename);
if(!_file.is_open())
throw std::runtime_error("OBJ : could not open object file");
}
ObjParser::~ObjParser()
@ -164,7 +166,7 @@ void ObjParser::addFace(std::stringstream &line, Scene &scene)
void ObjParser::addTriangle(glm::vec3 v1, glm::vec3 v2, glm::vec3 v3, Scene &scene)
{
scene.addObject(new Triangle(v1, v2, v3, _mat));
_triangles.push_back(Triangle(v1, v2, v3, _mat));
}
void ObjParser::parseMtl(std::stringstream &input_line, Scene &scene)
@ -272,5 +274,7 @@ void ObjParser::parse(Scene &scene)
throw;
}
}
scene.addBvh(_triangles);
}

63
srcs/class/Scene.cpp
View File

@ -59,20 +59,20 @@ bool Scene::parseScene(char *name)
file.close();
std::cout << "Parsing done" << std::endl;
std::cout << "Starting BVH" << std::endl;
// std::cout << "Starting BVH" << std::endl;
BVH *bvh = new BVH(_gpu_triangles, 0, _gpu_triangles.size());
_gpu_bvh = bvh->getGPUBvhs();
// BVH *bvh = new BVH(_gpu_triangles, 0, _gpu_triangles.size());
// _gpu_bvh = bvh->getGPUBvhs();
std::cout << "BVH Done: " << std::endl;
// std::cout << "BVH Done: " << std::endl;
std::cout << "\tBVH size: " << bvh->getSize() << std::endl;
std::cout << "\tBVH leaves: " << bvh->getLeaves() << std::endl << std::endl;
// std::cout << "\tBVH size: " << bvh->getSize() << std::endl;
// std::cout << "\tBVH leaves: " << bvh->getLeaves() << std::endl << std::endl;
BVHStats stats = bvh->analyzeBVHLeaves(bvh);
std::cout << "\tMin triangles per leaf: " << stats.min_triangles << std::endl;
std::cout << "\tMax triangles per leaf: " << stats.max_triangles << std::endl;
std::cout << "\tAverage triangles per leaf: " << stats.average_triangles << std::endl << std::endl;
// BVHStats stats = bvh->analyzeBVHLeaves(bvh);
// std::cout << "\tMin triangles per leaf: " << stats.min_triangles << std::endl;
// std::cout << "\tMax triangles per leaf: " << stats.max_triangles << std::endl;
// std::cout << "\tAverage triangles per leaf: " << stats.average_triangles << std::endl << std::endl;
return (true);
}
@ -119,15 +119,14 @@ void Scene::addObject(Object *obj)
GPUTriangle gpu_triangle;
auto triangle = static_cast<Triangle *>(obj);
gpu_triangle.position = obj->getPosition();
gpu_triangle.mat_index = obj->getMaterialIndex();
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);
return ;
}
else if (obj->getType() == Object::Type::PORTAL)
@ -156,6 +155,37 @@ void Scene::addObject(Object *obj)
_gpu_objects.push_back(gpu_obj);
}
void Scene::addBvh(std::vector<Triangle> &triangles)
{
GPUBvhData new_bvh_data;
std::vector<GPUBvh> new_bvhs_list;
BVH *bvh = new BVH(triangles, 0, triangles.size());
new_bvhs_list = bvh->getGPUBvhs();
new_bvh_data.offset = glm::vec3(0., 0., 0.);
new_bvh_data.bvh_start_index = _gpu_bvh.size();
new_bvh_data.triangle_start_index = _gpu_triangles.size();
_gpu_bvh_data.push_back(new_bvh_data);
_gpu_bvh.insert(_gpu_bvh.end(), new_bvhs_list.begin(), new_bvhs_list.end());
for (int i = 0; i < (int)triangles.size(); i++)
{
GPUTriangle gpu_triangle;
gpu_triangle.position = triangles[i].getPosition();
gpu_triangle.mat_index = triangles[i].getMaterialIndex();
gpu_triangle.vertex1 = triangles[i].getVertex2();
gpu_triangle.vertex2 = triangles[i].getVertex3();
gpu_triangle.normal = triangles[i].getNormal();
_gpu_triangles.push_back(gpu_triangle);
}
}
void Scene::addMaterial(Material *material)
{
GPUMaterial gpu_mat;
@ -216,7 +246,12 @@ GPUDebug &Scene::getDebug()
return (_gpu_debug);
}
std::vector<GPUBvh> &Scene::getBVH()
std::vector<GPUBvhData> &Scene::getBvhData()
{
return (_gpu_bvh_data);
}
std::vector<GPUBvh> &Scene::getBvh()
{
return (_gpu_bvh);
}