tutorial 20

https://www.youtube.com/watch?v=d5p44idnZLQ
Signed-off-by: Chakib_Chemso <chemsoblakblak@gmail.com>

Vulkan Engine/Vulkan Engine.vcxproj

@@ -24,6 +24,7 @@
       <ClCompile Include="renderer\vk_renderer.cpp"/>
       <ClCompile Include="renderer\vk_swapchain.cpp"/>
       <ClCompile Include="renderer\vk_window.cpp"/>
+      <ClCompile Include="simple_render_system\vk_descriptors.cpp"/>
       <ClCompile Include="simple_render_system\vk_pipeline.cpp"/>
       <ClCompile Include="simple_render_system\vk_simple_render_system.cpp"/>
   </ItemGroup>
@@ -42,6 +43,7 @@
         <ClInclude Include="renderer\vk_renderer.hpp"/>
         <ClInclude Include="renderer\vk_swapchain.hpp"/>
         <ClInclude Include="renderer\vk_window.hpp"/>
+        <ClInclude Include="simple_render_system\vk_descriptors.hpp"/>
         <ClInclude Include="simple_render_system\vk_pipeline.hpp"/>
         <ClInclude Include="simple_render_system\vk_simple_render_system.hpp"/>
     </ItemGroup>

Vulkan Engine/apps/application.cpp

@@ -2,7 +2,6 @@
 
 #include <chrono>
 #include <future>
-#include <iostream>
 #include <glm/glm.hpp>
 
 #include "input_controller.hpp"
@@ -12,120 +11,138 @@
 #include "../renderer/vk_device.hpp"
 #include "../simple_render_system/vk_simple_render_system.hpp"
 
-namespace vk_engine
+using vk_engine::application;
+
+struct global_ubo
 {
-	struct global_ubo
-	{
-		glm::mat4 projection_view{1.f};
-		glm::vec3 light_direction{
-			normalize(glm::vec3{1.f, -3.f, -1.f})
-		};
+	glm::mat4 projection_view{1.f};
+	glm::vec3 light_direction{
+		normalize(glm::vec3{1.f, -3.f, -1.f})
 	};
+};
 
-	application::application()
+application::application()
+{
+	global_pool = vk_descriptor_pool::builder(device)
+	              .set_max_sets(vk_swapchain::MAX_FRAMES_IN_FLIGHT)
+	              .add_pool_size(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk_swapchain::MAX_FRAMES_IN_FLIGHT)
+	              .build();
+	load_game_objects();
+}
+
+application::~application() = default;
+
+void application::run()
+{
+	std::vector<std::unique_ptr<vk_buffer>> ubo_buffers(vk_swapchain::MAX_FRAMES_IN_FLIGHT);
+
+	for (auto& ubo_buffer : ubo_buffers)
 	{
-		load_game_objects();
+		ubo_buffer = std::make_unique<vk_buffer>(
+			device,
+			sizeof global_ubo,
+			1,
+			VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+			VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
+		);
+		ubo_buffer->map();
 	}
 
-	application::~application()
-	= default;
+	auto global_set_layout = vk_descriptor_set_layout::builder(device)
+	                         .add_binding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT)
+	                         .build();
 
-	void application::run()
+	std::vector<VkDescriptorSet> global_descriptor_sets(vk_swapchain::MAX_FRAMES_IN_FLIGHT);
+	for (int i = 0; i < static_cast<int>(global_descriptor_sets.size()); ++i)
 	{
-		std::vector<std::unique_ptr<vk_buffer>> ubo_buffers(vk_swapchain::MAX_FRAMES_IN_FLIGHT);
-
-		for (auto& ubo_buffer : ubo_buffers)
-		{
-			ubo_buffer = std::make_unique<vk_buffer>(
-				device,
-				sizeof global_ubo,
-				1,
-				VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
-				VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
-			);
-			ubo_buffer->map();
-		}
+		auto buffer_info = ubo_buffers[i]->descriptor_info();
+		vk_descriptor_writer(*global_set_layout, *global_pool)
+			.write_buffer(0, &buffer_info)
+			.build(global_descriptor_sets[i]);
+	}
 
-		auto viewer_object = vk_game_object::create_game_object();
+	global_ubo ubo{};
+	auto viewer_object = vk_game_object::create_game_object();
 
-		constexpr input_controller cam_controller{};
+	constexpr input_controller cam_controller{};
 
-		vk_camera camera{};
-		//camera.set_view_direction(glm::vec3{0.f}, glm::vec3{0.5f, 0.f, 1.f});
-		//camera.set_view_target(glm::vec3(-1, -2, -2), glm::vec3(0, 0, 2.5));
+	vk_camera camera{};
+	//camera.set_view_direction(glm::vec3{0.f}, glm::vec3{0.5f, 0.f, 1.f});
+	//camera.set_view_target(glm::vec3(-1, -2, -2), glm::vec3(0, 0, 2.5));
 
-		const vk_simple_render_system simple_render_system{device, renderer.get_swap_chain_render_pass()};
+	const vk_simple_render_system simple_render_system{
+		device, renderer.get_swap_chain_render_pass(), global_set_layout->get_descriptor_set_layout()
+	};
 
-		auto current_time = std::chrono::high_resolution_clock::now();
+	auto current_time = std::chrono::high_resolution_clock::now();
 
-		while (!window.should_close())
-		{
-			glfwPollEvents();
+	while (!window.should_close())
+	{
+		glfwPollEvents();
 
-			auto new_time = std::chrono::high_resolution_clock::now();
-			float frame_time = std::chrono::duration<float, std::chrono::seconds::period>(new_time - current_time).
-				count();
-			current_time = new_time;
+		auto new_time = std::chrono::high_resolution_clock::now();
+		float frame_time = std::chrono::duration<float, std::chrono::seconds::period>(new_time - current_time).
+			count();
+		current_time = new_time;
 
-			cam_controller.move_in_plane_xz(window.get_glfw_window(), frame_time, viewer_object);
-			camera.set_view_yxz(viewer_object.transform.translation, viewer_object.transform.rotation);
+		cam_controller.move_in_plane_xz(window.get_glfw_window(), frame_time, viewer_object);
+		camera.set_view_yxz(viewer_object.transform.translation, viewer_object.transform.rotation);
 
-			const float aspect = renderer.get_aspect_ratio();
-			camera.set_orthographic_projection(-aspect, aspect, -1.f, 1.f, -1.f, 1.f);
-			camera.set_perspective_projection(glm::radians(60.f), aspect, 0.1f, 100.f);
+		const float aspect = renderer.get_aspect_ratio();
+		camera.set_orthographic_projection(-aspect, aspect, -1.f, 1.f, -1.f, 1.f);
+		camera.set_perspective_projection(glm::radians(60.f), aspect, 0.1f, 100.f);
 
-			if (const auto command_buffer = renderer.begin_frame())
+		if (const auto command_buffer = renderer.begin_frame())
+		{
+			int frame_index = renderer.get_frame_index();
+			vk_frame_info frame_info{
+				frame_index,
+				frame_time,
+				command_buffer,
+				camera,
+				global_descriptor_sets[frame_index]
+			};
+			// std::cout
+			// 	<< "[Main]" << std::endl
+			// 	<< "	frame index:" << frame_index << std::endl
+			// 	<< "	frame time: " << frame_time << std::endl
+			// 	<< "	frame rate: " << 1 / frame_time << std::endl;
+
+			//update
+			ubo.projection_view = camera.get_projection() * camera.get_view();
+			ubo_buffers[frame_index]->write_to_buffer(&ubo);
+			ubo_buffers[frame_index]->flush();
+
+			//render
+			renderer.begin_swap_chain_render_pass(command_buffer);
+
+			// update rotations
+			/*for (auto& game_object : game_objects)
 			{
-				int frame_index = renderer.get_frame_index();
-				vk_frame_info frame_info{
-					frame_index,
-					frame_time,
-					command_buffer,
-					camera
-				};
-				// std::cout
-				// 	<< "[Main]" << std::endl
-				// 	<< "	frame index:" << frame_index << std::endl
-				// 	<< "	frame time: " << frame_time << std::endl
-				// 	<< "	frame rate: " << 1 / frame_time << std::endl;
-
-				//update
-				global_ubo ubo{};
-				ubo.projection_view = camera.get_projection() * camera.get_view();
-				ubo_buffers[frame_index]->write_to_buffer(&ubo);
-				ubo_buffers[frame_index]->flush();
-
-				//render
-				renderer.begin_swap_chain_render_pass(command_buffer);
-
-				// update rotations
-				/*for (auto& game_object : game_objects)
-				{
-					game_object.transform.rotation.y = glm::mod(game_object.transform.rotation.y + 0.1f, 360.f);
-					game_object.transform.rotation.x = glm::mod(game_object.transform.rotation.x + 0.1f, 360.f);
-					game_object.transform.rotation.z = glm::mod(game_object.transform.rotation.z + 0.1f, 360.f);
-				}*/
-
-				simple_render_system.render_game_objects(frame_info, game_objects);
-
-				renderer.end_swap_chain_render_pass(command_buffer);
-				renderer.end_frame();
-			}
-		}
+				game_object.transform.rotation.y = glm::mod(game_object.transform.rotation.y + 0.1f, 360.f);
+				game_object.transform.rotation.x = glm::mod(game_object.transform.rotation.x + 0.1f, 360.f);
+				game_object.transform.rotation.z = glm::mod(game_object.transform.rotation.z + 0.1f, 360.f);
+			}*/
+
+			simple_render_system.render_game_objects(frame_info, game_objects);
 
-		vkDeviceWaitIdle(device.get_device());
+			renderer.end_swap_chain_render_pass(command_buffer);
+			renderer.end_frame();
+		}
 	}
 
-	void application::load_game_objects()
-	{
-		const std::shared_ptr model = vk_model::create_model_from_file(
-			device,
-			R"(assets\models\smooth_vase.obj)");
+	vkDeviceWaitIdle(device.get_device());
+}
 
-		auto game_object = vk_game_object::create_game_object();
-		game_object.model = model;
-		game_object.transform.translation = {.0f, .0f, 2.5f};
-		game_object.transform.scale = glm::vec3{3.f};
-		game_objects.push_back(std::move(game_object));
-	}
+void application::load_game_objects()
+{
+	const std::shared_ptr model = vk_model::create_model_from_file(
+		device,
+		R"(assets\models\smooth_vase.obj)");
+
+	auto game_object = vk_game_object::create_game_object();
+	game_object.model = model;
+	game_object.transform.translation = {.0f, .0f, 2.5f};
+	game_object.transform.scale = glm::vec3{3.f};
+	game_objects.push_back(std::move(game_object));
 }

Vulkan Engine/apps/application.hpp

@@ -4,6 +4,7 @@
 #include "../renderer/vk_device.hpp"
 #include "../renderer/vk_renderer.hpp"
 #include "../renderer/vk_window.hpp"
+#include "../simple_render_system/vk_descriptors.hpp"
 
 namespace vk_engine
 {
@@ -28,6 +29,8 @@ namespace vk_engine
 		vk_device device{window};
 		vk_renderer renderer{window, device};
 
+		//order matters
+		std::unique_ptr<vk_descriptor_pool> global_pool{};
 		std::vector<vk_game_object> game_objects;
 	};
 }

Vulkan Engine/apps/gravity_vec_field_app.cpp

@@ -29,7 +29,7 @@ std::unique_ptr<vk_model> create_square_model(vk_device& device, const vec3 offs
 std::unique_ptr<vk_model> create_circle_model(vk_device& device, const unsigned int num_sides, const vec3 color)
 {
 	std::vector<vk_model::vertex> unique_vertices{};
-	for (int i = 0; i < num_sides; i++)
+	for (int i = 0; i < static_cast<int>(num_sides); i++)
 	{
 		const float angle = i * glm::two_pi<float>() / num_sides;
 		unique_vertices.push_back({
@@ -40,7 +40,7 @@ std::unique_ptr<vk_model> create_circle_model(vk_device& device, const unsigned
 	unique_vertices.push_back({}); // adds center vertex at 0, 0, 0
 
 	std::vector<vk_model::vertex> vertices{};
-	for (int i = 0; i < num_sides; i++)
+	for (int i = 0; i < static_cast<int>(num_sides); i++)
 	{
 		vertices.push_back(unique_vertices[i]);
 		vertices.push_back(unique_vertices[(i + 1) % num_sides]);
@@ -62,8 +62,8 @@ gravity_physics_system::gravity_physics_system(const float strength): strength_g
 void gravity_physics_system::update(std::vector<vk_game_object>& objs, const float dt,
                                     const unsigned substeps) const
 {
-	const float step_delta = dt / substeps;
-	for (int i = 0; i < substeps; i++)
+	const float step_delta = dt / static_cast<float>(substeps);
+	for (int i = 0; i < static_cast<int>(substeps); i++)
 	{
 		step_simulation(objs, step_delta);
 	}
@@ -181,7 +181,7 @@ void gravity_vec_field_app::run()
 	gravity_physics_system gravity_system{0.81f};
 	vec_field_system vec_field_system{};
 
-	vk_simple_render_system simple_render_system{device, renderer.get_swap_chain_render_pass()};
+	vk_simple_render_system simple_render_system{device, renderer.get_swap_chain_render_pass(), nullptr}; //TODO
 	vk_camera camera{};
 
 	while (!window.should_close())
@@ -203,7 +203,8 @@ void gravity_vec_field_app::run()
 				frame_index,
 				0,
 				command_buffer,
-				camera
+				camera,
+				nullptr,
 			};
 			renderer.begin_swap_chain_render_pass(command_buffer);
 			simple_render_system.render_game_objects(frame_info, physics_objects);

Vulkan Engine/apps/rotating_triangles_app.cpp

@@ -19,7 +19,9 @@ namespace vk_engine
 
 	void rotating_triangles_app::run()
 	{
-		const vk_simple_render_system simple_render_system{device, renderer.get_swap_chain_render_pass()};
+		const vk_simple_render_system simple_render_system{
+			device, renderer.get_swap_chain_render_pass(), nullptr
+		}; //TODO
 		vk_camera camera{};
 
 		while (!window.should_close())

Vulkan Engine/engine/vk_model.cpp

@@ -4,7 +4,6 @@
 #include "../engine/vk_utils.hpp"
 
 #include <cassert>
-#include <cstring>
 #include <iostream>
 #include <unordered_map>
 #include <glm/gtx/hash.hpp>

Vulkan Engine/main.cpp

@@ -1,6 +1,4 @@
 #include "apps/application.hpp"
-#include "apps/gravity_vec_field_app.hpp"
-#include "apps/rotating_triangles_app.hpp"
 
 #include <iostream>
 

Vulkan Engine/renderer/vk_frame_info.hpp

@@ -11,5 +11,6 @@ namespace vk_engine
 		float frame_time;
 		VkCommandBuffer command_buffer;
 		vk_camera& camera;
+		VkDescriptorSet global_descriptor_set;
 	};
 }

Vulkan Engine/shaders/simple_shader.frag

@@ -5,7 +5,7 @@ layout (location = 0) in vec3 frag_color;
 layout (location = 0) out vec4 out_color;
 
 layout (push_constant) uniform Push {
-    mat4 transform; //projection * view * model
+    mat4 model_mat;
     mat4 normal_mat;
 } push;
 

Vulkan Engine/shaders/simple_shader.vert

@@ -7,19 +7,24 @@ layout (location = 3) in vec3 uv;
 
 layout (location = 0) out vec3 frag_color;
 
+layout (set = 0, binding = 0) uniform GlobalUBO {
+    mat4 projection_view_mat;
+    vec3 directional_light;
+} ubo;
+
 layout (push_constant) uniform Push {
-    mat4 transform; //projection * view * model
+    mat4 model_mat;
     mat4 normal_mat;
 } push;
 
-const vec3 DIRECTIONAL_LIGHT = normalize(vec3(0.0, 0.0, 1.0));
 const float AMBIENT_LIGHT = 0.2;
 
 void main() {
-    gl_Position = push.transform * vec4(position, 1.0);
+    gl_Position = ubo.projection_view_mat * push.model_mat * vec4(position, 1.0);
 
     vec3 normal_world_space = normalize(mat3(push.normal_mat) * normal);
-    float light_intensity = AMBIENT_LIGHT + max(dot(normal_world_space, DIRECTIONAL_LIGHT), 0.0);
+
+    float light_intensity = AMBIENT_LIGHT + max(dot(normal_world_space, ubo.directional_light), 0.0);
 
     frag_color = light_intensity * color;
 }