Merge pull request #54 from MrScriptX/engine

clean buffers when updating mesh

Author: MrScriptX

Engine/Engine.cpp

@@ -30,7 +30,7 @@ Engine::~Engine()
 		for (size_t t = 0; t < mp_scene->getObjects()[i]->getMeshesCount(); t++)
 		{
 			mp_scene->getObjects()[i]->getMesh(t).getMaterial()->DestroyTexture();
-			mp_scene->getObjects()[i]->getMesh(t).destroyMesh();
+			mp_scene->getObjects()[i]->getMesh(t).DestroyBuffers();
 		}
 
 		mp_scene->getObjects()[i]->destroy();
@@ -80,6 +80,49 @@ const std::shared_ptr<GameObject> Engine::CreateGameObject(const std::string& ob
 	return go;
 }
 
+const std::shared_ptr<GameObject> Engine::CreateCube(const glm::vec3& position, const float& size, const glm::vec3& vcolor)
+{
+	std::shared_ptr<GameObject> cube = std::make_shared<GameObject>(mp_renderer);
+
+	Geometry g;
+
+	const float half_size = size / 2;
+
+	//vertices
+	g.addVertex({ -half_size, -half_size, -half_size }, vcolor, { .0f, .0f });
+	g.addVertex({ half_size, -half_size, -half_size }, vcolor, { .0f, 2.0f });
+	g.addVertex({ -half_size, half_size, -half_size }, vcolor, { 2.0f, .0f });
+	g.addVertex({ half_size, half_size, -half_size }, vcolor, { 2.0f, .0f });
+	g.addVertex({ -half_size, -half_size, half_size }, vcolor, { .0f, .0f });
+	g.addVertex({ half_size, -half_size, half_size }, vcolor, { .0f, 2.0f });
+	g.addVertex({ -half_size, half_size, half_size }, vcolor, { 2.0f, .0f });
+	g.addVertex({ half_size, half_size, half_size }, vcolor, { 2.0f, 2.0f });
+
+	//indices
+	g.addIndices(0, 2, 1);
+	g.addIndices(1, 2, 3);
+
+	g.addIndices(5, 7, 4);
+	g.addIndices(4, 7, 6);
+
+	g.addIndices(1, 3, 5);
+	g.addIndices(5, 3, 7);
+
+	g.addIndices(4, 6, 0);
+	g.addIndices(0, 6, 2);
+
+	g.addIndices(2, 6, 3);
+	g.addIndices(3, 6, 7);
+
+	g.addIndices(4, 0, 5);
+	g.addIndices(5, 0, 1);
+
+	cube->LoadMesh(g.vertices, g.indices);
+	cube->setPosition(position);
+
+	return cube;
+}
+
 void Engine::BindKeyToFunc(const int& key, std::function<void()>& func, const ActionType& type)
 {
 	mp_controller->SetKeyToFunc(key, func, type);
@@ -122,13 +165,18 @@ void Engine::update()
 	m_last_time = current_time;
 
 	const int32_t frame = mp_renderer->AcquireNextImage();
-	if (frame != -1 && (mp_scene->isUpdate(frame) || mp_renderer->IsUpdated(frame)))
+	if (frame != -1 && (mp_scene->isUpdate(frame) || mp_renderer->NeedUpdate(frame)))
 	{
 		mp_renderer->beginRecordCommandBuffers(mp_renderer->getCommandBuffer(frame), mp_renderer->getFrameBuffer(frame));
 		mp_scene->render(mp_renderer->getCommandBuffer(frame), frame);
 		mp_renderer->endRecordCommandBuffers(mp_renderer->getCommandBuffer(frame));
 
-		mp_renderer->SetUpdate(frame);
+		mp_renderer->SetUpdated(frame);
+		
+		if (mp_renderer->IsUpdated())
+		{
+			mp_scene->Clean();
+		}
 	}
 
 	mp_main_camera->UpdateUBO(static_cast<float>(mp_config->width), static_cast<float>(mp_config->height));

Engine/Engine.h

@@ -3,8 +3,10 @@
 
 #include "Window.h"
 
-#include "world/GameObject.h"
 #include "world/Scene.h"
+#include "world/GameObject.h"
+
+#include "graphics/Geometry.h"
 
 class Engine
 {
@@ -26,6 +28,8 @@ class Engine
 	// CREATE GAMEOBJECT
 	const std::shared_ptr<GameObject> CreateGameObject();
 	const std::shared_ptr<GameObject> CreateGameObject(const std::string& object_file);
+	
+	const std::shared_ptr<GameObject> CreateCube(const glm::vec3& position, const float& size, const glm::vec3& vcolor);
 
 	// CONTROLLER
 	void BindKeyToFunc(const int& key, std::function<void()>& func, const ActionType& type = ActionType::R3D_PRESS);
@@ -49,7 +53,7 @@ class Engine
 	std::shared_ptr<Camera> mp_main_camera;
 	std::shared_ptr<Controller> mp_controller;
 	std::shared_ptr<Config> mp_config;
-	
+
 	std::chrono::steady_clock::time_point m_last_time;
 };
 

Engine/Engine.vcxproj

@@ -71,6 +71,7 @@
     <ClInclude Include="Engine.h" />
     <ClInclude Include="errors.h" />
     <ClInclude Include="graphics\Config.h" />
+    <ClInclude Include="graphics\Geometry.h" />
     <ClInclude Include="graphics\Graphics.h" />
     <ClInclude Include="graphics\Math.h" />
     <ClInclude Include="graphics\Shaders.h" />
@@ -134,7 +135,7 @@
     <CharacterSet>NotSet</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
@@ -229,11 +230,11 @@
       <Optimization>Disabled</Optimization>
       <SDLCheck>true</SDLCheck>
       <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>$(ProjectDir)\libs\stb_image;$(VULKAN_SDK)\Include;$(ProjectDir)\libs\glfw-3.3.4\include;$(ProjectDir)\libs\glm;$(ProjectDir)\libs\assimp-5.0.1\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(VULKAN_SDK)\Include;$(SolutionDir)\dependencies\stb_image;$(SolutionDir)\dependencies\glfw-3.3.4\include;$(SolutionDir)\dependencies\glm;$(SolutionDir)\dependencies\assimp-5.0.1\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
-      <AdditionalLibraryDirectories>$(VULKAN_SDK)\Lib;$(ProjectDir)\libs\glfw-3.3.4\lib;$(ProjectDir)\glew-2.1.0\lib;$(ProjectDir)\libs\assimp-5.0.1\lib\Debug;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>$(VULKAN_SDK)\Lib;$(SolutionDir)\libs\glfw-3.3.4\lib;$(SolutionDir)\libs\glew-2.1.0\lib;$(SolutionDir)\libs\assimp-5.0.1\lib\Debug;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <AdditionalDependencies>vulkan-1.lib;glfw3.lib;assimp-vc142-mtd.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>

Engine/Engine.vcxproj.filters

@@ -176,6 +176,9 @@
     <ClInclude Include="graphics\Shaders.h">
       <Filter>Engine\Graphics</Filter>
     </ClInclude>
+    <ClInclude Include="graphics\Geometry.h">
+      <Filter>Engine\Graphics</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="assets\shaders\HLSL\no_texture_shader.frag">

Engine/Source.cpp

@@ -13,16 +13,58 @@ int main()
 		std::shared_ptr<GameObject> room = engine.CreateGameObject();
 		room->loadMesh("assets/models/viking_room.obj");
 		room->bindMatToMesh(0, room_texture);
-		room->setPosition({ 3.0f, 0.0f, 0.0f });
+		room->setPosition({ 3.0f, 0.0f, 3.0f });
 
 		std::shared_ptr<Material> room2_texture = engine.CreateMaterial(TSHADER::NO_TEXTURE);
 		std::shared_ptr<GameObject> room2 = engine.CreateGameObject();
 		room2->loadMesh("assets/models/viking_room.obj");
 		room2->bindMatToMesh(0, room2_texture);
 		room2->setPosition({ 6.0f, 0.0f, 0.0f });
 
+		std::shared_ptr<Material> cube_texture = engine.CreateMaterial(TSHADER::NO_TEXTURE);
+		std::shared_ptr<GameObject> cube = engine.CreateCube({ 2.0f, .0f, .0f }, 1.f, {1.f, .0f, .0f});
+		cube->bindMatToMesh(0, cube_texture);
+
+		const float half_size = 1.f / 2.f;
+		Geometry voxel;
+
+		//vertices
+		uint32_t index_0 = voxel.addVertex({ 0.f - half_size, 0.f - half_size, -2.f - half_size }, { 0.f, 1.f, 0.f }, { .0f, .0f });
+		uint32_t index_1 = voxel.addVertex({ 0.f + half_size, 0.f - half_size, -2.f - half_size }, { 0.f, 1.f, 0.f }, { .0f, 2.0f });
+		uint32_t index_2 = voxel.addVertex({ 0.f - half_size, 0.f + half_size, -2.f - half_size }, { 0.f, 1.f, 0.f }, { 2.0f, .0f });
+		uint32_t index_3 = voxel.addVertex({ 0.f + half_size, 0.f + half_size, -2.f - half_size }, { 0.f, 1.f, 0.f }, { 2.0f, .0f });
+		uint32_t index_4 = voxel.addVertex({ 0.f - half_size, 0.f - half_size, -2.f + half_size }, { 0.f, 1.f, 0.f }, { .0f, .0f });
+		uint32_t index_5 = voxel.addVertex({ 0.f + half_size, 0.f - half_size, -2.f + half_size }, { 0.f, 1.f, 0.f }, { .0f, 2.0f });
+		uint32_t index_6 = voxel.addVertex({ 0.f - half_size, 0.f + half_size, -2.f + half_size }, { 0.f, 1.f, 0.f }, { 2.0f, .0f });
+		uint32_t index_7 = voxel.addVertex({ 0.f + half_size, 0.f + half_size, -2.f + half_size }, { 0.f, 1.f, 0.f }, { 2.0f, 2.0f });
+
+		//indices
+		voxel.addIndices(index_0, index_2, index_1);
+		voxel.addIndices(index_1, index_2, index_3);
+
+		voxel.addIndices(index_5, index_7, index_4);
+		voxel.addIndices(index_4, index_7, index_6);
+
+		voxel.addIndices(index_1, index_3, index_5);
+		voxel.addIndices(index_5, index_3, index_7);
+
+		voxel.addIndices(index_4, index_6, index_0);
+		voxel.addIndices(index_0, index_6, index_2);
+
+		voxel.addIndices(index_2, index_6, index_3);
+		voxel.addIndices(index_3, index_6, index_7);
+
+		voxel.addIndices(index_4, index_0, index_5);
+		voxel.addIndices(index_5, index_0, index_1);
+
+		cube->LoadMesh(voxel.vertices, voxel.indices);
+
+		cube->bindMatToMesh(1, cube_texture);
+
 		std::shared_ptr<Scene> scene = std::make_shared<Scene>();
 		scene->addGameObject(room);
+		scene->addGameObject(room2);
+		scene->addGameObject(cube);
 
 		engine.setScene(scene);
 
@@ -45,9 +87,17 @@ int main()
 		// running loop
 		do
 		{
-			if (init++ == 30000)
+			//cube->setPosition(cube->getPosition() + glm::vec3{0.0001f, 0.f, 0.f});
+
+			if (init++ == 10000)
 			{
-				scene->addGameObject(room2);
+				Geometry v;
+				v.vertices = cube->GetVertices(1);
+				v.indices = cube->GetIndices(1);
+				v.vertices[0].color = { .0f, .0f, 1.0f };
+
+				cube->UpdateMesh(1, v.vertices, v.indices);
+				scene->Update();
 			}
 
 			engine.update();

Engine/graphics/Geometry.h

@@ -0,0 +1,35 @@
+#ifndef _GEOMETRY_H
+#define _GEOMETRY_H
+
+#include "Vertex.h"
+
+struct Geometry
+{
+	std::vector<Vertex> vertices;
+	std::vector<uint32_t> indices;
+
+	int32_t nb_vertices = -1;
+
+	uint32_t addVertex(glm::vec3 pos, glm::vec3 color, glm::vec2 texCoord)
+	{
+		Vertex vertex;
+		vertex.pos = pos;
+		vertex.color = color;
+		vertex.texCoord = texCoord;
+
+		vertices.push_back(vertex);
+
+		nb_vertices++;
+
+		return nb_vertices;
+	}
+
+	void addIndices(uint32_t x, uint32_t y, uint32_t z)
+	{
+		indices.push_back(x);
+		indices.push_back(y);
+		indices.push_back(z);
+	}
+};
+
+#endif

Engine/graphics/Vertex.h

@@ -11,7 +11,6 @@
 #include <glm/gtx/hash.hpp>
 
 
-
 struct Vertex
 {
 	glm::vec3 pos;

Engine/renderer/Renderer.cpp

@@ -16,7 +16,7 @@ Renderer::Renderer(GLFWwindow& window, uint32_t width, uint32_t height)
 {
 	WIDTH = std::make_unique<uint32_t>(width);
 	HEIGHT = std::make_unique<uint32_t>(height);
-	m_is_updated.fill(false);
+	m_is_updated = { false };
 
 	m_pBufferFactory = std::make_unique<VulkanBuffer>(m_graphic);
 
@@ -223,14 +223,19 @@ const int Renderer::getFrameIndex()
 	return m_current_image;
 }
 
-const bool& Renderer::IsUpdated(const size_t& i)
+const bool Renderer::IsUpdated()
+{
+	return m_is_updated == false;
+}
+
+const bool Renderer::NeedUpdate(const size_t& i)
 {
 	return m_is_updated[i];
 }
 
-void Renderer::SetUpdate(const size_t& i)
+void Renderer::SetUpdated(const size_t& i)
 {
-	m_is_updated[i] = false;
+	m_is_updated.set(i, false);
 }
 
 const uint32_t& Renderer::GetHeight()
@@ -668,7 +673,7 @@ void Renderer::recreateSwapchain()
 	createFramebuffer();
 	allocateCommandBuffers();
 
-	m_is_updated.fill(true);
+	m_is_updated.set(true);
 }
 
 void Renderer::cleanSwapchain()

Engine/renderer/Renderer.h

@@ -13,6 +13,7 @@
 #include <iostream>
 #include <memory>
 #include <algorithm>
+#include <bitset>
 
 #include "VulkanInstance.h"
 #include "VulkanDevice.h"
@@ -57,10 +58,12 @@ class Renderer
 	std::unique_ptr<VulkanBuffer>& getBufferFactory();
 	std::unique_ptr<VulkanPipeline>& GetPipelineFactory();
 	const int getFrameIndex();
-	const bool& IsUpdated(const size_t& i);
-	void SetUpdate(const size_t& i);
 	const uint32_t& GetHeight();
 
+	const bool IsUpdated();
+	const bool NeedUpdate(const size_t& i);
+	void SetUpdated(const size_t& i);
+
 	//rendering
 	void createVerticesBuffer(std::shared_ptr<std::vector<Vertex>> vertices, Buffer& buffer);
 	void createIndicesBuffer(std::shared_ptr<std::vector<uint32_t>> indices, Buffer& buffer);
@@ -148,7 +151,7 @@ class Renderer
 
 	uint32_t m_current_image = 0;
 	uint32_t m_last_image = 0;
-	std::array<bool, 3> m_is_updated;
+	std::bitset<3> m_is_updated;
 };
 
 #endif _RENDERER_H