From 84b0f22127006e6e631706f9a3ba14a5ce49c3a5 Mon Sep 17 00:00:00 2001 From: TheRedShip Date: Sun, 19 Jan 2025 22:40:02 +0100 Subject: [PATCH] + | Multiple obj using multiple BVH --- includes/RT/BVH.hpp | 12 ++--- includes/RT/ObjParser.hpp | 2 + includes/RT/Scene.hpp | 15 +++++- includes/RT/objects/Triangle.hpp | 6 +++ scenes/dragon.rt | 3 +- shaders/debug.glsl | 52 +++++++++++++++++---- shaders/trace.glsl | 2 +- srcs/RT.cpp | 25 ++++++---- srcs/class/BVH.cpp | 79 +++++++++++--------------------- srcs/class/ObjParser.cpp | 6 ++- srcs/class/Scene.cpp | 63 +++++++++++++++++++------ 11 files changed, 170 insertions(+), 95 deletions(-) diff --git a/includes/RT/BVH.hpp b/includes/RT/BVH.hpp index d7f77f5..8fa34ad 100644 --- a/includes/RT/BVH.hpp +++ b/includes/RT/BVH.hpp @@ -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 &primitives, int first_primitive, int primitive_count); + BVH(std::vector &triangles, int first_primitive, int primitive_count); - void showAABB(Scene *scene); - - void updateBounds(std::vector &primitives); - void subdivide(std::vector &primitives); + void updateBounds(std::vector &triangles); + void subdivide(std::vector &triangles); - float evaluateSah(std::vector &primitives, int axis, float pos); + float evaluateSah(std::vector &triangles, int axis, float pos); int getSize(); int getLeaves(); diff --git a/includes/RT/ObjParser.hpp b/includes/RT/ObjParser.hpp index 2812a8f..9e9d2db 100644 --- a/includes/RT/ObjParser.hpp +++ b/includes/RT/ObjParser.hpp @@ -39,6 +39,8 @@ class ObjParser std::vector _textureVertices; int _mat; std::map _matNames; + + std::vector _triangles; }; #endif diff --git a/includes/RT/Scene.hpp b/includes/RT/Scene.hpp index a83ca3a..095ec13 100644 --- a/includes/RT/Scene.hpp +++ b/includes/RT/Scene.hpp @@ -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 getGPULights(); + void addBvh(std::vector &triangles); + const std::vector &getObjectData() const; const std::vector &getTriangleData() const; std::vector &getMaterialData(); - std::vector &getBVH(); + + std::vector &getBvhData(); + std::vector &getBvh(); GPUVolume &getVolume(); GPUDebug &getDebug(); @@ -116,6 +128,7 @@ class Scene GPUMaterial getMaterial(int material_index); private: + std::vector _gpu_bvh_data; std::vector _gpu_bvh; std::vector _gpu_objects; diff --git a/includes/RT/objects/Triangle.hpp b/includes/RT/objects/Triangle.hpp index 858d82f..95f5b20 100644 --- a/includes/RT/objects/Triangle.hpp +++ b/includes/RT/objects/Triangle.hpp @@ -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 diff --git a/scenes/dragon.rt b/scenes/dragon.rt index fec78cd..632c449 100644 --- a/scenes/dragon.rt +++ b/scenes/dragon.rt @@ -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 diff --git a/shaders/debug.glsl b/shaders/debug.glsl index c6806c2..f8fd4a4 100644 --- a/shaders/debug.glsl +++ b/shaders/debug.glsl @@ -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); diff --git a/shaders/trace.glsl b/shaders/trace.glsl index a2d191d..26ac5ed 100644 --- a/shaders/trace.glsl +++ b/shaders/trace.glsl @@ -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); diff --git a/srcs/RT.cpp b/srcs/RT.cpp index d206924..5667ac1 100644 --- a/srcs/RT.cpp +++ b/srcs/RT.cpp @@ -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 &object_data = scene.getObjectData(); const std::vector &triangle_data = scene.getTriangleData(); - const std::vector &bvh_data = scene.getBVH(); + const std::vector &bvh_nodes = scene.getBvh(); + const std::vector &bvh_data = scene.getBvhData(); const std::vector &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())); diff --git a/srcs/class/BVH.cpp b/srcs/class/BVH.cpp index 1cc88fc..027b3a1 100644 --- a/srcs/class/BVH.cpp +++ b/srcs/class/BVH.cpp @@ -12,7 +12,7 @@ #include "BVH.hpp" -BVH::BVH(std::vector &primitives, int first_primitive, int primitive_count) : _aabb(AABB(glm::vec3(1e30f), glm::vec3(-1e30f))) +BVH::BVH(std::vector &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 &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 &primitives) +void BVH::updateBounds(std::vector &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 &primitives, int axis, float pos) +float BVH::evaluateSah(std::vector &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 &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 &primitives, int axis, float pos -void BVH::subdivide(std::vector &primitives) +void BVH::subdivide(std::vector &triangles) { if (_primitive_count <= 4) return ; @@ -100,7 +96,7 @@ void BVH::subdivide(std::vector &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 &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 &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); diff --git a/srcs/class/ObjParser.cpp b/srcs/class/ObjParser.cpp index 665f23d..46d799a 100644 --- a/srcs/class/ObjParser.cpp +++ b/srcs/class/ObjParser.cpp @@ -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); } diff --git a/srcs/class/Scene.cpp b/srcs/class/Scene.cpp index febad85..0715e3d 100644 --- a/srcs/class/Scene.cpp +++ b/srcs/class/Scene.cpp @@ -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(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 &triangles) +{ + GPUBvhData new_bvh_data; + std::vector 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 &Scene::getBVH() +std::vector &Scene::getBvhData() +{ + return (_gpu_bvh_data); +} + +std::vector &Scene::getBvh() { return (_gpu_bvh); }