+ | Multiple obj using multiple BVH

includes/RT/BVH.hpp

@@ -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<Triangle> &triangles);
+		void	subdivide(std::vector<Triangle> &triangles);
 
-		void	updateBounds(std::vector <GPUTriangle> &primitives);
+		float	evaluateSah(std::vector<Triangle> &triangles, int axis, float pos);
-		void	subdivide(std::vector<GPUTriangle> &primitives);
-
-		float	evaluateSah(std::vector<GPUTriangle> &primitives, int axis, float pos);
 
 		int							getSize();
 		int							getLeaves();

includes/RT/ObjParser.hpp

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

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

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

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

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 left_node = Bvh[bvh_data.bvh_start_index + node.left_index];
-			GPUBvh right_node = bvh[node.right_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);

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

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/compute.glsl");
-	// Shader		shader("shaders/vertex.vert", "shaders/frag.frag", "shaders/debug.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);
+	glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUBvh) * bvh_nodes.size(), bvh_nodes.data(), GL_STATIC_DRAW);
-	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, bvhSSBO);
+	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()));

srcs/class/BVH.cpp

@@ -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);
+	updateBounds(triangles);
-	subdivide(primitives);
+	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)
+		_aabb.min = glm::min(_aabb.min, leaf_triangle.getPosition());
-			// continue ;
+        _aabb.min = glm::min(_aabb.min, leaf_triangle.getVertex2());
-		
+        _aabb.min = glm::min(_aabb.min, leaf_triangle.getVertex3());
-		_aabb.min = glm::min(_aabb.min, leaf_triangle.position);
+        _aabb.max = glm::max(_aabb.max, leaf_triangle.getPosition());
-        _aabb.min = glm::min(_aabb.min, leaf_triangle.vertex1);
+        _aabb.max = glm::max(_aabb.max, leaf_triangle.getVertex2());
-        _aabb.min = glm::min(_aabb.min, leaf_triangle.vertex2);
+        _aabb.max = glm::max(_aabb.max, leaf_triangle.getVertex3());
-        _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);
 	}
 }
 
 
-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];
+        Triangle triangle = triangles[_first_primitive + i];
-		glm::vec3 centroid = (triangle.position + triangle.vertex1 + triangle.vertex2) / 3.0f;
 
-        if (centroid[axis] < pos)
+        if (triangle.getCentroid()[axis] < pos)
         {
             left_count++;
-            left_box.grow( triangle.position );
+            left_box.grow( triangle.getPosition() );
-            left_box.grow( triangle.vertex1 );
+            left_box.grow( triangle.getVertex2() );
-            left_box.grow( triangle.vertex2 );
+            left_box.grow( triangle.getVertex3() );
         }
         else
         {
             right_count++;
-            right_box.grow( triangle.position );
+            right_box.grow( triangle.getPosition() );
-            right_box.grow( triangle.vertex1 );
+            right_box.grow( triangle.getVertex2() );
-            right_box.grow( triangle.vertex2 );
+            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];
+		Triangle triangle = triangles[i];
-		glm::vec3 centroid = (triangle.position + triangle.vertex1 + triangle.vertex2) / 3.0f;
 
-		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);
+	_left = new BVH(triangles, _first_primitive, left_count);
-	_right = new BVH(primitives, i , _primitive_count - 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);

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

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());
+	// BVH *bvh = new BVH(_gpu_triangles, 0, _gpu_triangles.size());
-	_gpu_bvh = bvh->getGPUBvhs();
+	// _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 size: " << bvh->getSize() << std::endl;
-	std::cout << "\tBVH leaves: " << bvh->getLeaves() << std::endl << std::endl;
+	// std::cout << "\tBVH leaves: " << bvh->getLeaves() << std::endl << std::endl;
 
-	BVHStats stats = bvh->analyzeBVHLeaves(bvh);
+	// BVHStats stats = bvh->analyzeBVHLeaves(bvh);
-	std::cout << "\tMin triangles per leaf: " << stats.min_triangles << std::endl;
+	// std::cout << "\tMin triangles per leaf: " << stats.min_triangles << std::endl;
-	std::cout << "\tMax triangles per leaf: " << stats.max_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;
+	// 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.position = triangle->getPosition();
-		gpu_triangle.mat_index = obj->getMaterialIndex();
+		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);
 }