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

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);
}