diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/candy_gear.cpp | 4 | ||||
| -rw-r--r-- | src/core.cpp | 52 | ||||
| -rw-r--r-- | src/core.hpp | 8 | ||||
| -rw-r--r-- | src/main.cpp | 4 | ||||
| -rw-r--r-- | src/model.cpp | 5 | ||||
| -rw-r--r-- | src/model.hpp | 3 | ||||
| -rw-r--r-- | src/rotation3d.hpp | 6 | ||||
| -rw-r--r-- | src/sprite.cpp | 81 | ||||
| -rw-r--r-- | src/sprite.hpp | 25 | ||||
| -rw-r--r-- | src/vector3d.hpp | 6 | ||||
| -rw-r--r-- | src/vk/device.cpp | 18 | ||||
| -rw-r--r-- | src/vk/device.hpp | 7 | ||||
| -rw-r--r-- | src/vk/graphics_pipeline_2d.cpp | 488 | ||||
| -rw-r--r-- | src/vk/graphics_pipeline_2d.hpp | 51 | ||||
| -rw-r--r-- | src/vk/graphics_pipeline_3d.cpp (renamed from src/vk/graphics_pipeline.cpp) | 270 | ||||
| -rw-r--r-- | src/vk/graphics_pipeline_3d.hpp (renamed from src/vk/graphics_pipeline.hpp) | 26 | ||||
| -rw-r--r-- | src/vk/model.cpp | 9 | ||||
| -rw-r--r-- | src/vk/renderer.cpp | 245 | ||||
| -rw-r--r-- | src/vk/renderer.hpp | 49 | ||||
| -rw-r--r-- | src/vk/sprite.cpp | 226 | ||||
| -rw-r--r-- | src/vk/sprite.hpp | 55 | ||||
| -rw-r--r-- | src/vk/uniform_buffer.hpp | 7 | ||||
| -rw-r--r-- | src/vk/vertex_3d.hpp (renamed from src/vk/vertex.hpp) | 8 |
23 files changed, 1367 insertions, 286 deletions
diff --git a/src/candy_gear.cpp b/src/candy_gear.cpp index d0922c6..45d105e 100644 --- a/src/candy_gear.cpp +++ b/src/candy_gear.cpp @@ -65,7 +65,7 @@ cg_mCandyGear_set_camera_position(mrb_state *mrb, mrb_value self) std::shared_ptr<glm::vec3> *camera_position; mrb_get_args(mrb, "d", &camera_position, &cg_vector3d_type); - cg_core.vk_graphics_pipeline->camera_position = (*camera_position); + cg_core.vk_graphics_pipeline_3d->camera_position = (*camera_position); return self; } @@ -76,7 +76,7 @@ cg_mCandyGear_set_camera_rotation(mrb_state *mrb, mrb_value self) std::shared_ptr<glm::vec3> *camera_rotation; mrb_get_args(mrb, "d", &camera_rotation, &cg_rotation3d_type); - cg_core.vk_graphics_pipeline->camera_rotation = (*camera_rotation); + cg_core.vk_graphics_pipeline_3d->camera_rotation = (*camera_rotation); return self; } diff --git a/src/core.cpp b/src/core.cpp index a1c996f..ecf7d47 100644 --- a/src/core.cpp +++ b/src/core.cpp @@ -452,22 +452,60 @@ unload_vk_swapchain(void *obj) } static void -load_vk_graphics_pipeline(void *obj) +load_vk_graphics_pipeline_3d(void *obj) { try { - cg_core.vk_graphics_pipeline = new VK::GraphicsPipeline(); + cg_core.vk_graphics_pipeline_3d = new VK::GraphicsPipeline3D(); } catch(const CommandError &e) { - throw CommandError{"Failed to create graphics pipeline."}; + throw CommandError{"Failed to create 3d graphics pipeline."}; } } static void -unload_vk_graphics_pipeline(void *obj) +unload_vk_graphics_pipeline_3d(void *obj) { - delete cg_core.vk_graphics_pipeline; + delete cg_core.vk_graphics_pipeline_3d; +} + +static void +load_vk_graphics_pipeline_2d(void *obj) +{ + try + { + cg_core.vk_graphics_pipeline_2d = new VK::GraphicsPipeline2D(); + } + catch(const CommandError &e) + { + throw CommandError{"Failed to create 2d graphics pipeline."}; + } +} + +static void +unload_vk_graphics_pipeline_2d(void *obj) +{ + delete cg_core.vk_graphics_pipeline_2d; +} + +static void +load_vk_renderer(void *obj) +{ + try + { + cg_core.vk_renderer = new VK::Renderer(); + } + catch(const CommandError &e) + { + throw CommandError{"Failed to create renderer."}; + } +} + +static void +unload_vk_renderer(void *obj) +{ + delete cg_core.vk_renderer; } static void @@ -508,7 +546,9 @@ const CommandChain cg_sCore::loader{ #endif {&load_vk_devices, &unload_vk_devices}, {&load_vk_swapchain, &unload_vk_swapchain}, - {&load_vk_graphics_pipeline, &unload_vk_graphics_pipeline}, + {&load_vk_graphics_pipeline_3d, &unload_vk_graphics_pipeline_3d}, + {&load_vk_graphics_pipeline_2d, &unload_vk_graphics_pipeline_2d}, + {&load_vk_renderer, &unload_vk_renderer}, {&load_mruby, &unload_mruby}, {&load_mruby_symbols, nullptr} }; diff --git a/src/core.hpp b/src/core.hpp index d9e68e8..1f75279 100644 --- a/src/core.hpp +++ b/src/core.hpp @@ -42,7 +42,9 @@ #include "log.hpp" #include "vk/device.hpp" -#include "vk/graphics_pipeline.hpp" +#include "vk/graphics_pipeline_3d.hpp" +#include "vk/graphics_pipeline_2d.hpp" +#include "vk/renderer.hpp" #include "vk/swapchain.hpp" extern std::random_device random_seed; @@ -103,7 +105,9 @@ struct cg_sCore std::vector<VK::Device> vk_devices; VK::Device *vk_device_with_swapchain; VK::Swapchain *vk_swapchain; - VK::GraphicsPipeline *vk_graphics_pipeline; + VK::GraphicsPipeline3D *vk_graphics_pipeline_3d; + VK::GraphicsPipeline2D *vk_graphics_pipeline_2d; + VK::Renderer *vk_renderer; bool quit_game; }; diff --git a/src/main.cpp b/src/main.cpp index 61f7967..d82ba1b 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -23,6 +23,7 @@ #include "model.hpp" #include "rotation3d.hpp" #include "sound.hpp" +#include "sprite.hpp" #include "texture.hpp" #include "vector3d.hpp" @@ -63,6 +64,7 @@ int main(int argc, char *argv[]) cg_model_init(cg_core.mrb); cg_rotation3d_init(cg_core.mrb); cg_sound_init(cg_core.mrb); + cg_sprite_init(cg_core.mrb); cg_texture_init(cg_core.mrb); cg_vector3d_init(cg_core.mrb); @@ -119,7 +121,7 @@ int main(int argc, char *argv[]) mrb_funcall_id(cg_core.mrb, main_obj, sym_tick, 0); if (cg_core.mrb->exc) handle_error(cg_core.mrb); - cg_core.vk_graphics_pipeline->draw(); + cg_core.vk_renderer->draw(); // Timer { diff --git a/src/model.cpp b/src/model.cpp index 06ddf65..c0a35d8 100644 --- a/src/model.cpp +++ b/src/model.cpp @@ -70,9 +70,8 @@ cg_cModel_draw(mrb_state *mrb, mrb_value self) instance.position = **position; instance.rotation = **rotation; - auto &instances = - cg_core.vk_graphics_pipeline->models_to_draw[ - cg_core.vk_graphics_pipeline->current_frame][*ptr]; + auto &instances = cg_core.vk_graphics_pipeline_3d->models_to_draw[ + cg_core.vk_renderer->current_frame][*ptr]; instances.push_back(instance); return self; diff --git a/src/model.hpp b/src/model.hpp index 414fa30..50e49a1 100644 --- a/src/model.hpp +++ b/src/model.hpp @@ -17,10 +17,7 @@ #ifndef CANDY_GEAR_MODEL_H #define CANDY_GEAR_MODEL_H 1 -#include <memory> - #include "core.hpp" -#include "vk/model.hpp" void cg_model_init(mrb_state *mrb); diff --git a/src/rotation3d.hpp b/src/rotation3d.hpp index 6b94e89..6d3980d 100644 --- a/src/rotation3d.hpp +++ b/src/rotation3d.hpp @@ -14,8 +14,8 @@ * limitations under the License. */ -#ifndef CANDY_GEAR_ROTATION3D_H -#define CANDY_GEAR_ROTATION3D_H 1 +#ifndef CANDY_GEAR_ROTATION_3D_H +#define CANDY_GEAR_ROTATION_3D_H 1 #include "core.hpp" @@ -24,4 +24,4 @@ extern const struct mrb_data_type cg_rotation3d_type; void cg_rotation3d_init(mrb_state *mrb); -#endif /* CANDY_GEAR_ROTATION3D_H */ +#endif /* CANDY_GEAR_ROTATION_3D_H */ diff --git a/src/sprite.cpp b/src/sprite.cpp new file mode 100644 index 0000000..2aad6d6 --- /dev/null +++ b/src/sprite.cpp @@ -0,0 +1,81 @@ +/* + * Copyright 2022 Frederico de Oliveira Linhares + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "sprite.hpp" + +#include "vk/sprite.hpp" +#include "texture.hpp" + +void +cg_free_sprite(mrb_state *mrb, void* obj) +{ + auto ptr = static_cast<std::shared_ptr<VK::Sprite>*>(obj); + + ptr->~shared_ptr(); + mrb_free(mrb, ptr); +} + +const struct mrb_data_type cg_sprite_type = { "CG_Sprite", cg_free_sprite }; + +static mrb_value +cg_cSprite_initialize(mrb_state *mrb, mrb_value self) +{ + mrb_float x, y, w, h; + + std::shared_ptr<VK::Texture> *texture; + std::shared_ptr<VK::Sprite> *ptr; + + mrb_get_args(mrb, "dffff", &texture, &cg_texture_type, &x, &y, &w, &h); + ptr = (std::shared_ptr<VK::Sprite>*)DATA_PTR(self); + if(ptr) mrb_free(mrb, ptr); + ptr = (std::shared_ptr<VK::Sprite>*)mrb_malloc( + mrb, sizeof(std::shared_ptr<VK::Sprite>)); + + glm::vec4 rect{x, y, w, h}; + new(ptr)std::shared_ptr<VK::Sprite>( + std::make_shared<VK::Sprite>(*texture, rect)); + + mrb_data_init(self, ptr, &cg_sprite_type); + return self; +} + +static mrb_value +cg_cSprite_draw(mrb_state *mrb, mrb_value self) +{ + auto *ptr = (std::shared_ptr<VK::Sprite>*)DATA_PTR(self); + mrb_float x, y, w, h; + + mrb_get_args(mrb, "ffff", &x, &y, &w, &h); + auto &positions = cg_core.vk_graphics_pipeline_2d->sprites_to_draw[ + cg_core.vk_renderer->current_frame][*ptr]; + glm::vec4 position{x, y, w, h}; + positions.push_back(position); + + return self; +} + +void +cg_sprite_init(mrb_state *mrb) +{ + struct RClass *cg_m, *cg_cSprite; + + cg_m = mrb_module_get(mrb, "CandyGear"); + cg_cSprite = mrb_define_class_under(mrb, cg_m, "Sprite", mrb->object_class); + MRB_SET_INSTANCE_TT(cg_cSprite, MRB_TT_DATA); + mrb_define_method( + mrb, cg_cSprite, "initialize", cg_cSprite_initialize, MRB_ARGS_REQ(5)); + mrb_define_method(mrb, cg_cSprite, "draw", cg_cSprite_draw, MRB_ARGS_REQ(4)); +} diff --git a/src/sprite.hpp b/src/sprite.hpp new file mode 100644 index 0000000..6b21023 --- /dev/null +++ b/src/sprite.hpp @@ -0,0 +1,25 @@ +/* + * Copyright 2022 Frederico de Oliveira Linhares + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CANDY_GEAR_SPRITE_H +#define CANDY_GEAR_SPRITE_H 1 + +#include "core.hpp" + +void +cg_sprite_init(mrb_state *mrb); + +#endif /* CANDY_GEAR_SPRITE_H */ diff --git a/src/vector3d.hpp b/src/vector3d.hpp index 2533f4e..fab6f61 100644 --- a/src/vector3d.hpp +++ b/src/vector3d.hpp @@ -14,8 +14,8 @@ * limitations under the License. */ -#ifndef CANDY_GEAR_VECTOR3D_H -#define CANDY_GEAR_VECTOR3D_H 1 +#ifndef CANDY_GEAR_VECTOR_3D_H +#define CANDY_GEAR_VECTOR_3D_H 1 #include "core.hpp" @@ -31,4 +31,4 @@ cg_cVector3D_get_z(mrb_state *mrb, mrb_value self); void cg_vector3d_init(mrb_state *mrb); -#endif /* CANDY_GEAR_VECTOR3D_H */ +#endif /* CANDY_GEAR_VECTOR_3D_H */ diff --git a/src/vk/device.cpp b/src/vk/device.cpp index b4b47fb..74727f9 100644 --- a/src/vk/device.cpp +++ b/src/vk/device.cpp @@ -157,10 +157,14 @@ Device::Device(VkPhysicalDevice vk_physical_device, bool with_swapchain) // Load Shaders { - this->vert_shader_module = create_shader_module( - this->device, DATA_DIR "/glsl/vert.spv"); - this->frag_shader_module = create_shader_module( - this->device, DATA_DIR "/glsl/frag.spv"); + this->vert3d_shader_module = create_shader_module( + this->device, DATA_DIR "/glsl/shader_3d.vert.spv"); + this->frag3d_shader_module = create_shader_module( + this->device, DATA_DIR "/glsl/shader_3d.frag.spv"); + this->vert2d_shader_module = create_shader_module( + this->device, DATA_DIR "/glsl/shader_2d.vert.spv"); + this->frag2d_shader_module = create_shader_module( + this->device, DATA_DIR "/glsl/shader_2d.frag.spv"); } this->queue_families = static_cast<QueueFamily*>( @@ -194,8 +198,10 @@ Device::~Device() std::free(this->queue_families); // Destroy shaders - vkDestroyShaderModule(this->device, this->vert_shader_module, nullptr); - vkDestroyShaderModule(this->device, this->frag_shader_module, nullptr); + vkDestroyShaderModule(this->device, this->vert3d_shader_module, nullptr); + vkDestroyShaderModule(this->device, this->frag3d_shader_module, nullptr); + vkDestroyShaderModule(this->device, this->vert2d_shader_module, nullptr); + vkDestroyShaderModule(this->device, this->frag2d_shader_module, nullptr); vkDeviceWaitIdle(this->device); vkDestroyDevice(this->device, nullptr); diff --git a/src/vk/device.hpp b/src/vk/device.hpp index 56bd6e4..cc5df82 100644 --- a/src/vk/device.hpp +++ b/src/vk/device.hpp @@ -36,8 +36,11 @@ struct Device public: VkDevice device; VkPhysicalDevice physical_device; - VkShaderModule vert_shader_module; - VkShaderModule frag_shader_module; + + VkShaderModule vert3d_shader_module; + VkShaderModule frag3d_shader_module; + VkShaderModule vert2d_shader_module; + VkShaderModule frag2d_shader_module; bool with_swapchain; diff --git a/src/vk/graphics_pipeline_2d.cpp b/src/vk/graphics_pipeline_2d.cpp new file mode 100644 index 0000000..e8fd002 --- /dev/null +++ b/src/vk/graphics_pipeline_2d.cpp @@ -0,0 +1,488 @@ +/* + * Copyright 2022 Frederico de Oliveira Linhares + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "graphics_pipeline_2d.hpp" + +#include <array> + +#include "../core.hpp" +#include "sprite.hpp" + +namespace +{ + +void +load_descriptor_set_layout_image_sprites(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline2D*>(obj); + + std::array<VkDescriptorSetLayoutBinding, 2> layout_bindings{}; + + layout_bindings[0].binding = 0; + layout_bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + layout_bindings[0].descriptorCount = 1; + layout_bindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + layout_bindings[0].pImmutableSamplers = nullptr; + + layout_bindings[1].binding = 1; + layout_bindings[1].descriptorType = + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + layout_bindings[1].descriptorCount = 1; + layout_bindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + layout_bindings[1].pImmutableSamplers = nullptr; + + VkDescriptorSetLayoutCreateInfo layout_info{}; + layout_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + layout_info.pNext = nullptr; + layout_info.flags = 0; + layout_info.bindingCount = static_cast<uint32_t>(layout_bindings.size()); + layout_info.pBindings = layout_bindings.data(); + + if(vkCreateDescriptorSetLayout( + cg_core.vk_device_with_swapchain->device, &layout_info, nullptr, + &self->descriptor_set_layout_sprites) != VK_SUCCESS) + throw CommandError{ + "Failed to create Vulkan descriptor set layout for model instance."}; +} + +void +unload_descriptor_set_layout_image_sprites(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline2D*>(obj); + + vkDestroyDescriptorSetLayout( + cg_core.vk_device_with_swapchain->device, + self->descriptor_set_layout_sprites, nullptr); +} + +void +load_pipeline_layout(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline2D*>(obj); + + std::array<VkDescriptorSetLayout, 1> set_layouts{ + self->descriptor_set_layout_sprites + }; + + VkPipelineLayoutCreateInfo pipeline_layout_info{}; + pipeline_layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + pipeline_layout_info.setLayoutCount = set_layouts.size(); + pipeline_layout_info.pSetLayouts = set_layouts.data(); + pipeline_layout_info.pushConstantRangeCount = 0; + pipeline_layout_info.pPushConstantRanges = nullptr; + + if(vkCreatePipelineLayout( + cg_core.vk_device_with_swapchain->device, + &pipeline_layout_info, nullptr, &self->pipeline_layout) != VK_SUCCESS) + throw CommandError{"Failed to create Vulkan pipeline layout."}; +} + +void +unload_pipeline_layout(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline2D*>(obj); + + vkDestroyPipelineLayout( + cg_core.vk_device_with_swapchain->device, self->pipeline_layout, nullptr); +} + +void +load_render_pass(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline2D*>(obj); + + std::array<VkAttachmentDescription, 1> attachments{}; + // Color attachment. + attachments[0].flags = 0; + attachments[0].format = cg_core.vk_swapchain->image_format; + attachments[0].samples = VK_SAMPLE_COUNT_1_BIT; + attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_LOAD; + attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE; + attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + attachments[0].initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + attachments[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; + + VkAttachmentReference color_attachment_ref{}; + color_attachment_ref.attachment = 0; + color_attachment_ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + + VkSubpassDescription subpass{}; + subpass.flags = 0; + subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + subpass.inputAttachmentCount = 0; + subpass.pInputAttachments = nullptr; + subpass.colorAttachmentCount = 1; + subpass.pColorAttachments = &color_attachment_ref; + subpass.pResolveAttachments = nullptr; + subpass.pDepthStencilAttachment = nullptr; + subpass.preserveAttachmentCount = 0; + subpass.pPreserveAttachments = nullptr; + + VkSubpassDependency dependency{}; + dependency.srcSubpass = VK_SUBPASS_EXTERNAL; + dependency.dstSubpass = 0; + dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; + dependency.srcAccessMask = 0; + dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; + dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + + VkRenderPassCreateInfo render_pass_info{}; + render_pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + render_pass_info.pNext = nullptr; + render_pass_info.flags = 0; + render_pass_info.attachmentCount = attachments.size(); + render_pass_info.pAttachments = attachments.data(); + render_pass_info.subpassCount = 1; + render_pass_info.pSubpasses = &subpass; + render_pass_info.dependencyCount = 1; + render_pass_info.pDependencies = &dependency; + + if(vkCreateRenderPass( + cg_core.vk_device_with_swapchain->device, &render_pass_info, + nullptr, &self->render_pass) != VK_SUCCESS) + throw CommandError{"Failed to create Vulkan Render Pass."}; +} + +void +unload_render_pass(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline2D*>(obj); + + vkDestroyRenderPass( + cg_core.vk_device_with_swapchain->device, self->render_pass, nullptr); +} + +void +load_framebuffer(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline2D*>(obj); + + self->swapchain_framebuffers.resize(cg_core.vk_swapchain->images_count); + for (auto i{0}; i < cg_core.vk_swapchain->images_count; i++) + { + std::array<VkImageView, 1> attachments = { + cg_core.vk_swapchain->image_views[i] + }; + + VkFramebufferCreateInfo framebuffer_info{}; + framebuffer_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + framebuffer_info.renderPass = self->render_pass; + framebuffer_info.attachmentCount = attachments.size(); + framebuffer_info.pAttachments = attachments.data(); + framebuffer_info.width = cg_core.screen_width; + framebuffer_info.height = cg_core.screen_height; + framebuffer_info.layers = 1; + + if(vkCreateFramebuffer( + cg_core.vk_device_with_swapchain->device, &framebuffer_info, nullptr, + &self->swapchain_framebuffers[i]) != VK_SUCCESS) + throw CommandError{"Failed to create Vulkan Framebuffer."}; + } +} + +void +unload_framebuffer(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline2D*>(obj); + + for(auto framebuffer: self->swapchain_framebuffers) + vkDestroyFramebuffer( + cg_core.vk_device_with_swapchain->device, framebuffer, nullptr); +} + +void +load_pipeline(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline2D*>(obj); + + VkPipelineShaderStageCreateInfo vert_shader_stage_info{}; + vert_shader_stage_info.sType = + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_shader_stage_info.pNext = nullptr; + vert_shader_stage_info.flags = 0; + vert_shader_stage_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + vert_shader_stage_info.module = + cg_core.vk_device_with_swapchain->vert2d_shader_module; + vert_shader_stage_info.pName = "main"; + vert_shader_stage_info.pSpecializationInfo = nullptr; + + VkPipelineShaderStageCreateInfo frag_shader_stage_info{}; + frag_shader_stage_info.sType = + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_shader_stage_info.pNext = nullptr; + frag_shader_stage_info.flags = 0; + frag_shader_stage_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + frag_shader_stage_info.module = + cg_core.vk_device_with_swapchain->frag2d_shader_module; + frag_shader_stage_info.pName = "main"; + frag_shader_stage_info.pSpecializationInfo = nullptr; + + VkPipelineShaderStageCreateInfo shader_stages[] = { + vert_shader_stage_info, + frag_shader_stage_info + }; + + VkVertexInputBindingDescription vertex_input_binding{}; + vertex_input_binding.binding = 0; + vertex_input_binding.stride = sizeof(glm::vec2); + vertex_input_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + + std::array<VkVertexInputAttributeDescription, 1> vertex_attribute{}; + // Texture coordinate. + vertex_attribute[0].location = 0; + vertex_attribute[0].binding = 0; + vertex_attribute[0].format = VK_FORMAT_R32G32_SFLOAT; + vertex_attribute[0].offset = 0; + + VkPipelineVertexInputStateCreateInfo vertex_input_info = {}; + vertex_input_info.sType = + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + vertex_input_info.pNext = nullptr; + vertex_input_info.flags = 0; + vertex_input_info.vertexBindingDescriptionCount = 1; + vertex_input_info.pVertexBindingDescriptions = &vertex_input_binding; + vertex_input_info.vertexAttributeDescriptionCount = + static_cast<uint32_t>(vertex_attribute.size()); + vertex_input_info.pVertexAttributeDescriptions = vertex_attribute.data(); + + VkPipelineInputAssemblyStateCreateInfo input_assembly = {}; + input_assembly.sType = + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly.pNext = nullptr; + input_assembly.flags = 0; + input_assembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; + input_assembly.primitiveRestartEnable = VK_FALSE; + + VkViewport viewport = {}; + viewport.x = 0.0f; + viewport.y = 0.0f; + viewport.width = static_cast<float>(cg_core.screen_width); + viewport.height = static_cast<float>(cg_core.screen_height); + viewport.minDepth = 0.0f; + viewport.maxDepth = 1.0f; + + VkRect2D scissor = {}; + scissor.offset = {0, 0}; + scissor.extent = {cg_core.screen_width, cg_core.screen_height}; + + VkPipelineViewportStateCreateInfo viewport_state = {}; + viewport_state.sType = + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + viewport_state.pNext = nullptr; + viewport_state.flags = 0; + viewport_state.viewportCount = 1; + viewport_state.pViewports = &viewport; + viewport_state.scissorCount = 1; + viewport_state.pScissors = &scissor; + + VkPipelineRasterizationStateCreateInfo rasterizer = {}; + rasterizer.sType = + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterizer.pNext = nullptr; + rasterizer.flags = 0; + rasterizer.depthClampEnable = VK_FALSE; + rasterizer.rasterizerDiscardEnable = VK_FALSE; + rasterizer.polygonMode = VK_POLYGON_MODE_FILL; + rasterizer.cullMode = VK_CULL_MODE_NONE; + rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; + rasterizer.depthBiasEnable = VK_FALSE; + rasterizer.depthBiasConstantFactor = 0.0f; + rasterizer.depthBiasClamp = 0.0f; + rasterizer.depthBiasSlopeFactor = 0.0f; + rasterizer.lineWidth = 1.0f; + + VkPipelineMultisampleStateCreateInfo multisampling = {}; + multisampling.sType = + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; + multisampling.sampleShadingEnable = VK_FALSE; + multisampling.minSampleShading = 1.0f; + multisampling.pSampleMask = nullptr; + multisampling.alphaToCoverageEnable = VK_FALSE; + multisampling.alphaToOneEnable = VK_FALSE; + + VkPipelineColorBlendAttachmentState color_blend_attachment = {}; + color_blend_attachment.blendEnable = VK_FALSE; + color_blend_attachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; + color_blend_attachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; + color_blend_attachment.colorBlendOp = VK_BLEND_OP_ADD; + color_blend_attachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; + color_blend_attachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; + color_blend_attachment.alphaBlendOp = VK_BLEND_OP_ADD; + color_blend_attachment.colorWriteMask = + VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | + VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; + + VkPipelineColorBlendStateCreateInfo color_blending = {}; + color_blending.sType = + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blending.pNext = nullptr; + color_blending.flags = 0; + color_blending.logicOpEnable = VK_FALSE; + color_blending.logicOp = VK_LOGIC_OP_COPY; + color_blending.attachmentCount = 1; + color_blending.pAttachments = &color_blend_attachment; + color_blending.blendConstants[0] = 0.0f; + color_blending.blendConstants[1] = 0.0f; + color_blending.blendConstants[2] = 0.0f; + color_blending.blendConstants[3] = 0.0f; + + VkDynamicState dynamic_states[] = { + VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_LINE_WIDTH + }; + + VkPipelineDynamicStateCreateInfo dynamic_state_info = {}; + dynamic_state_info.sType = + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + dynamic_state_info.dynamicStateCount = 2; + dynamic_state_info.pDynamicStates = dynamic_states; + + VkGraphicsPipelineCreateInfo pipeline_info{}; + pipeline_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + pipeline_info.pNext = nullptr; + pipeline_info.flags = 0; + pipeline_info.stageCount = 2; + pipeline_info.pStages = shader_stages; + pipeline_info.pVertexInputState = &vertex_input_info; + pipeline_info.pInputAssemblyState = &input_assembly; + pipeline_info.pTessellationState = nullptr; + pipeline_info.pViewportState = &viewport_state; + pipeline_info.pRasterizationState = &rasterizer; + pipeline_info.pMultisampleState = &multisampling; + pipeline_info.pDepthStencilState = nullptr; + pipeline_info.pColorBlendState = &color_blending; + pipeline_info.pDynamicState = &dynamic_state_info; + pipeline_info.layout = self->pipeline_layout; + pipeline_info.renderPass = self->render_pass; + pipeline_info.subpass = 0; + pipeline_info.basePipelineHandle = VK_NULL_HANDLE; + pipeline_info.basePipelineIndex = -1; + + if(vkCreateGraphicsPipelines( + cg_core.vk_device_with_swapchain->device, VK_NULL_HANDLE, 1, + &pipeline_info, nullptr, &self->graphic_pipeline) != VK_SUCCESS) + throw CommandError{"Failed to create graphics pipeline."}; +} + +void +unload_pipeline(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline2D*>(obj); + + vkDestroyPipeline( + cg_core.vk_device_with_swapchain->device, self->graphic_pipeline, nullptr); +} + +const CommandChain loader{ + {&load_descriptor_set_layout_image_sprites, + &unload_descriptor_set_layout_image_sprites}, + {&load_pipeline_layout, &unload_pipeline_layout}, + {&load_render_pass, &unload_render_pass}, + {&load_framebuffer, &unload_framebuffer}, + {&load_pipeline, &unload_pipeline} +}; + +} + +namespace VK +{ + +GraphicsPipeline2D::GraphicsPipeline2D(): + sprites_to_draw{cg_core.vk_swapchain->images_count} +{ + loader.execute(this); +} + +GraphicsPipeline2D::~GraphicsPipeline2D() +{ + loader.revert(this); +} + +void +GraphicsPipeline2D::draw( + const VkCommandBuffer draw_command_buffer, const size_t current_frame, + const size_t next_frame, const uint32_t image_index) +{ + // Load command + { + VkRenderPassBeginInfo render_pass_begin{}; + render_pass_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + render_pass_begin.pNext = nullptr; + render_pass_begin.renderPass = this->render_pass; + render_pass_begin.framebuffer = this->swapchain_framebuffers[image_index]; + render_pass_begin.renderArea.offset = {0, 0}; + render_pass_begin.renderArea.extent = { + cg_core.screen_width, cg_core.screen_height}; + render_pass_begin.clearValueCount = 0; + render_pass_begin.pClearValues = nullptr; + + vkCmdBeginRenderPass( + draw_command_buffer, &render_pass_begin,VK_SUBPASS_CONTENTS_INLINE); + + VkViewport vk_viewport{}; + vk_viewport.width = static_cast<float>(cg_core.screen_width); + vk_viewport.height = static_cast<float>(cg_core.screen_height); + vk_viewport.minDepth = 0.0f; + vk_viewport.maxDepth = 1.0f; + vkCmdSetViewport(draw_command_buffer, 0, 1, &vk_viewport); + + VkRect2D vk_scissor{}; + vk_scissor.extent.width = cg_core.screen_width; + vk_scissor.extent.height = cg_core.screen_height; + vk_scissor.offset.x = 0; + vk_scissor.offset.y = 0; + vkCmdSetScissor(draw_command_buffer, 0, 1, &vk_scissor); + + // Draw sprites + for(auto& [sprite, positions]: this->sprites_to_draw[current_frame]) + { + // Commands + { + VkDeviceSize offsets[]{0}; + + vkCmdBindDescriptorSets( + draw_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, + this->pipeline_layout, 0, 1, &sprite->descriptor_sets[image_index], + 0, nullptr); + vkCmdBindPipeline( + draw_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, + this->graphic_pipeline); + vkCmdBindVertexBuffers( + draw_command_buffer, 0, 1, &sprite->vertex_buffer->buffer, offsets); + vkCmdDraw( + draw_command_buffer, Sprite::vertex_count, positions.size(), 0, 0); + } + + VK::UBOSpritePositions ubo_sprite_positions; + for(auto i{0}; i < positions.size(); i++) + ubo_sprite_positions.positions[i] = positions[i]; + sprite->ub_sprite_positions[image_index].copy_data( + &ubo_sprite_positions); + } + } + vkCmdEndRenderPass(draw_command_buffer); + + // Prepare for the next frame. + this->sprites_to_draw[next_frame].clear(); +} + +} diff --git a/src/vk/graphics_pipeline_2d.hpp b/src/vk/graphics_pipeline_2d.hpp new file mode 100644 index 0000000..f6a1b47 --- /dev/null +++ b/src/vk/graphics_pipeline_2d.hpp @@ -0,0 +1,51 @@ +/* + * Copyright 2022 Frederico de Oliveira Linhares + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CANDY_GEAR_VK_GRAPHICS_PIPELINE_2D_H +#define CANDY_GEAR_VK_GRAPHICS_PIPELINE_2D_H 1 + +#include <vector> + +#include "core.hpp" +#include "sprite.hpp" + +namespace VK +{ + +struct GraphicsPipeline2D +{ + VkDescriptorSetLayout descriptor_set_layout_sprites; + VkPipelineLayout pipeline_layout; + + VkRenderPass render_pass; + std::vector<VkFramebuffer> swapchain_framebuffers; + VkPipeline graphic_pipeline; + + std::vector< + std::unordered_map<std::shared_ptr<Sprite>, std::vector<glm::vec4>>> + sprites_to_draw; + + GraphicsPipeline2D(); + ~GraphicsPipeline2D(); + + void + draw(const VkCommandBuffer draw_command_buffer, const size_t current_frame, + const size_t next_frame, const uint32_t image_index); +}; + +} + +#endif /* CANDY_GEAR_VK_GRAPHICS_PIPELINE_2D_H */ diff --git a/src/vk/graphics_pipeline.cpp b/src/vk/graphics_pipeline_3d.cpp index 3956a99..04a2adb 100644 --- a/src/vk/graphics_pipeline.cpp +++ b/src/vk/graphics_pipeline_3d.cpp @@ -14,7 +14,7 @@ * limitations under the License. */ -#include "graphics_pipeline.hpp" +#include "graphics_pipeline_3d.hpp" #include <array> #include <stdexcept> @@ -23,7 +23,7 @@ #include "core.hpp" #include "image.hpp" #include "uniform_buffer.hpp" -#include "vertex.hpp" +#include "vertex_3d.hpp" namespace { @@ -31,7 +31,7 @@ namespace void load_descriptor_set_layout_model_instance(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); std::array<VkDescriptorSetLayoutBinding, 2> layout_bindings{}; @@ -65,7 +65,7 @@ load_descriptor_set_layout_model_instance(void *obj) void unload_descriptor_set_layout_model_instance(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); vkDestroyDescriptorSetLayout( cg_core.vk_device_with_swapchain->device, @@ -75,7 +75,7 @@ unload_descriptor_set_layout_model_instance(void *obj) void load_descriptor_set_layout_world_view(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); std::array<VkDescriptorSetLayoutBinding, 2> set_layouts{}; set_layouts[0].binding = 0; @@ -107,7 +107,7 @@ load_descriptor_set_layout_world_view(void *obj) void unload_descriptor_set_layout_world_view(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); vkDestroyDescriptorSetLayout( cg_core.vk_device_with_swapchain->device, @@ -117,7 +117,7 @@ unload_descriptor_set_layout_world_view(void *obj) void load_pipeline_layout(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); std::array<VkDescriptorSetLayout, 2> set_layouts{ self->descriptor_set_layout_world_view, @@ -139,7 +139,7 @@ load_pipeline_layout(void *obj) void unload_pipeline_layout(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); vkDestroyPipelineLayout( cg_core.vk_device_with_swapchain->device, self->pipeline_layout, nullptr); @@ -148,7 +148,7 @@ unload_pipeline_layout(void *obj) void load_view_projection_uniform_buffer(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); try { @@ -166,7 +166,7 @@ load_view_projection_uniform_buffer(void *obj) void unload_view_projection_uniform_buffer(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); self->ub_view_projection.clear(); } @@ -174,7 +174,7 @@ unload_view_projection_uniform_buffer(void *obj) void load_directional_light_uniform_buffer(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); try { @@ -192,7 +192,7 @@ load_directional_light_uniform_buffer(void *obj) void unload_directional_light_uniform_buffer(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); self->ub_directional_light.clear(); } @@ -200,7 +200,7 @@ unload_directional_light_uniform_buffer(void *obj) void load_descriptor_pool(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); VkDescriptorPoolSize descriptor_pool_size{}; descriptor_pool_size.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; @@ -225,7 +225,7 @@ load_descriptor_pool(void *obj) void unload_descriptor_pool(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); vkDestroyDescriptorPool( cg_core.vk_device_with_swapchain->device, self->descriptor_pool, nullptr); @@ -234,7 +234,7 @@ unload_descriptor_pool(void *obj) void load_world_view_descriptor_sets(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); std::vector<VkDescriptorSetLayout> layouts( cg_core.vk_swapchain->images_count, @@ -257,7 +257,7 @@ load_world_view_descriptor_sets(void *obj) void load_resources_to_descriptor_sets(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); for(auto i{0}; i < self->ub_view_projection.size(); i++) { @@ -301,7 +301,7 @@ load_resources_to_descriptor_sets(void *obj) void load_depth_image(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); VkExtent3D extent3d{}; extent3d.width = cg_core.screen_width; @@ -332,7 +332,7 @@ load_depth_image(void *obj) void unload_depth_image(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); vkDestroyImage( cg_core.vk_device_with_swapchain->device, self->depth_image, nullptr); @@ -344,7 +344,7 @@ unload_depth_image(void *obj) void load_depth_image_view(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); try { @@ -364,7 +364,7 @@ load_depth_image_view(void *obj) void unload_depth_image_view(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); vkDestroyImageView( cg_core.vk_device_with_swapchain->device, self->depth_image_view, nullptr); @@ -373,7 +373,7 @@ unload_depth_image_view(void *obj) void load_render_pass(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); std::array<VkAttachmentDescription, 2> attachments{}; // Color attachment. @@ -385,7 +385,7 @@ load_render_pass(void *obj) attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; attachments[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - attachments[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; + attachments[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; // Depth attachment. attachments[1].flags = 0; attachments[1].format = VK_FORMAT_D32_SFLOAT; @@ -450,7 +450,7 @@ load_render_pass(void *obj) void unload_render_pass(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); vkDestroyRenderPass( cg_core.vk_device_with_swapchain->device, self->render_pass, nullptr); @@ -459,7 +459,7 @@ unload_render_pass(void *obj) void load_framebuffer(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); self->swapchain_framebuffers.resize(cg_core.vk_swapchain->images_count); for (auto i{0}; i < cg_core.vk_swapchain->images_count; i++) @@ -489,7 +489,7 @@ load_framebuffer(void *obj) void unload_framebuffer(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); for(auto framebuffer: self->swapchain_framebuffers) vkDestroyFramebuffer( @@ -499,7 +499,7 @@ unload_framebuffer(void *obj) void load_pipeline(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); VkPipelineShaderStageCreateInfo vert_shader_stage_info = {}; vert_shader_stage_info.sType = @@ -508,7 +508,7 @@ load_pipeline(void *obj) vert_shader_stage_info.flags = 0; vert_shader_stage_info.stage = VK_SHADER_STAGE_VERTEX_BIT; vert_shader_stage_info.module = - cg_core.vk_device_with_swapchain->vert_shader_module; + cg_core.vk_device_with_swapchain->vert3d_shader_module; vert_shader_stage_info.pName = "main"; vert_shader_stage_info.pSpecializationInfo = nullptr; @@ -519,7 +519,7 @@ load_pipeline(void *obj) frag_shader_stage_info.flags = 0; frag_shader_stage_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; frag_shader_stage_info.module = - cg_core.vk_device_with_swapchain->frag_shader_module; + cg_core.vk_device_with_swapchain->frag3d_shader_module; frag_shader_stage_info.pName = "main"; frag_shader_stage_info.pSpecializationInfo = nullptr; @@ -530,7 +530,7 @@ load_pipeline(void *obj) VkVertexInputBindingDescription vertex_input_binding{}; vertex_input_binding.binding = 0; - vertex_input_binding.stride = sizeof(VK::Vertex); + vertex_input_binding.stride = sizeof(VK::Vertex3D); vertex_input_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; std::array<VkVertexInputAttributeDescription, 3> vertex_attribute{}; @@ -538,17 +538,17 @@ load_pipeline(void *obj) vertex_attribute[0].location = 0; vertex_attribute[0].binding = 0; vertex_attribute[0].format = VK_FORMAT_R32G32B32_SFLOAT; - vertex_attribute[0].offset = offsetof(VK::Vertex, position); + vertex_attribute[0].offset = offsetof(VK::Vertex3D, position); // Normal. vertex_attribute[1].location = 1; vertex_attribute[1].binding = 0; vertex_attribute[1].format = VK_FORMAT_R32G32B32_SFLOAT; - vertex_attribute[1].offset = offsetof(VK::Vertex, normal); + vertex_attribute[1].offset = offsetof(VK::Vertex3D, normal); // Texture coordinate. vertex_attribute[2].location = 2; vertex_attribute[2].binding = 0; vertex_attribute[2].format = VK_FORMAT_R32G32_SFLOAT; - vertex_attribute[2].offset = offsetof(VK::Vertex, texture_coord); + vertex_attribute[2].offset = offsetof(VK::Vertex3D, texture_coord); VkPipelineVertexInputStateCreateInfo vertex_input_info = {}; vertex_input_info.sType = @@ -697,122 +697,12 @@ load_pipeline(void *obj) void unload_pipeline(void *obj) { - auto self = static_cast<VK::GraphicsPipeline*>(obj); + auto self = static_cast<VK::GraphicsPipeline3D*>(obj); vkDestroyPipeline( cg_core.vk_device_with_swapchain->device, self->graphic_pipeline, nullptr); } -void -load_frame_sync(void *obj) -{ - auto self = static_cast<VK::GraphicsPipeline*>(obj); - - self->image_available_semaphores.resize(self->max_frames_in_flight); - self->render_finished_semaphores.resize(self->max_frames_in_flight); - self->in_flight_fences.resize(self->max_frames_in_flight); - - VkSemaphoreCreateInfo semaphore_info = {}; - semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; - semaphore_info.pNext = nullptr; - semaphore_info.flags = 0; - - VkFenceCreateInfo fence_info = {}; - fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; - fence_info.pNext = nullptr; - fence_info.flags = VK_FENCE_CREATE_SIGNALED_BIT; - - // FIXME: if this loop fails, it will not destroy the semaphores. - for(auto i{0}; i < self->max_frames_in_flight; i++) - { - if(vkCreateSemaphore( - cg_core.vk_device_with_swapchain->device, &semaphore_info, - nullptr, &self->image_available_semaphores[i]) != VK_SUCCESS || - vkCreateSemaphore( - cg_core.vk_device_with_swapchain->device, &semaphore_info, - nullptr, &self->render_finished_semaphores[i]) != VK_SUCCESS || - vkCreateFence(cg_core.vk_device_with_swapchain->device, &fence_info, - nullptr, &self->in_flight_fences[i]) != VK_SUCCESS) - throw CommandError{"Failed to create semaphores."}; - } -} - -void -unload_frame_sync(void *obj) -{ - auto self = static_cast<VK::GraphicsPipeline*>(obj); - - vkDeviceWaitIdle(cg_core.vk_device_with_swapchain->device); - - for(auto i{0}; i < self->max_frames_in_flight; i++) - { - vkDestroySemaphore(cg_core.vk_device_with_swapchain->device, - self->render_finished_semaphores[i], nullptr); - vkDestroySemaphore(cg_core.vk_device_with_swapchain->device, - self->image_available_semaphores[i], nullptr); - vkDestroyFence(cg_core.vk_device_with_swapchain->device, - self->in_flight_fences[i], nullptr); - } -} - -void -load_queue_family(void *obj) -{ - auto self = static_cast<VK::GraphicsPipeline*>(obj); - - self->queue_family = - cg_core.vk_device_with_swapchain->get_queue_family_with_presentation(); -} - -void -load_command_pool(void *obj) -{ - auto self = static_cast<VK::GraphicsPipeline*>(obj); - - VkCommandPoolCreateInfo create_info{}; - create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; - create_info.pNext = nullptr; - create_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; - create_info.queueFamilyIndex = self->queue_family->family_index; - - vkCreateCommandPool( - self->queue_family->device->device, &create_info, nullptr, - &self->command_pool); -} - -void -unload_command_pool(void *obj) -{ - auto self = static_cast<VK::GraphicsPipeline*>(obj); - - vkWaitForFences(cg_core.vk_device_with_swapchain->device, 2, - self->in_flight_fences.data(), VK_TRUE, - std::numeric_limits<uint64_t>::max()); - vkDestroyCommandPool( - self->queue_family->device->device, self->command_pool, nullptr); -} - -void -load_draw_command_buffer(void *obj) -{ - auto self = static_cast<VK::GraphicsPipeline*>(obj); - - // FIXME: 3 is a magical number, triple buffering. - self->draw_command_buffers.resize(3); - - VkCommandBufferAllocateInfo allocate_info{}; - allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; - allocate_info.pNext = nullptr; - allocate_info.commandPool = self->command_pool; - allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; - allocate_info.commandBufferCount = self->draw_command_buffers.size(); - - if(vkAllocateCommandBuffers( - self->queue_family->device->device, &allocate_info, - self->draw_command_buffers.data()) != VK_SUCCESS) - throw CommandError{"Vulkan draw command buffers could not be allocated."}; -} - const CommandChain loader{ {&load_descriptor_set_layout_model_instance, &unload_descriptor_set_layout_model_instance}, @@ -831,11 +721,7 @@ const CommandChain loader{ {&load_depth_image_view, &unload_depth_image_view}, {&load_render_pass, &unload_render_pass}, {&load_framebuffer, &unload_framebuffer}, - {&load_pipeline, &unload_pipeline}, - {&load_frame_sync, &unload_frame_sync}, - {&load_queue_family, nullptr}, - {&load_command_pool, &unload_command_pool}, - {&load_draw_command_buffer, nullptr} + {&load_pipeline, &unload_pipeline} }; } @@ -843,8 +729,7 @@ const CommandChain loader{ namespace VK { -GraphicsPipeline::GraphicsPipeline(): - current_frame{0}, +GraphicsPipeline3D::GraphicsPipeline3D(): camera_position{std::make_shared<glm::vec3>(0.0f, 0.0f, 0.0f)}, camera_rotation{std::make_shared<glm::vec3>(0.0f, 0.0f, 0.0f)}, models_to_draw{cg_core.vk_swapchain->images_count} @@ -852,41 +737,18 @@ GraphicsPipeline::GraphicsPipeline(): loader.execute(this); } -GraphicsPipeline::~GraphicsPipeline() +GraphicsPipeline3D::~GraphicsPipeline3D() { loader.revert(this); } void -GraphicsPipeline::draw() +GraphicsPipeline3D::draw( + const VkCommandBuffer draw_command_buffer, const size_t current_frame, + const size_t next_frame, const uint32_t image_index) { - vkWaitForFences(cg_core.vk_device_with_swapchain->device, 1, - &this->in_flight_fences[this->current_frame], VK_TRUE, - std::numeric_limits<uint64_t>::max()); - vkResetFences(cg_core.vk_device_with_swapchain->device, 1, - &this->in_flight_fences[this->current_frame]); - - uint32_t image_index; - vkAcquireNextImageKHR( - cg_core.vk_device_with_swapchain->device, cg_core.vk_swapchain->swapchain, - std::numeric_limits<uint64_t>::max(), - this->image_available_semaphores[this->current_frame], - VK_NULL_HANDLE, &image_index); - - auto &draw_command_buffer = this->draw_command_buffers[this->current_frame]; - vkResetCommandBuffer(draw_command_buffer, 0); - // Load command. { - VkCommandBufferBeginInfo begin_info{}; - begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; - begin_info.flags = 0; - begin_info.pInheritanceInfo = nullptr; - if (vkBeginCommandBuffer(draw_command_buffer, &begin_info) != VK_SUCCESS) - { - throw std::runtime_error{"Failed to beggin draw command buffer."}; - } - // Dark gray blue. std::array<VkClearValue, 2> clear_values{}; clear_values[0].color = {0.12f, 0.12f, 0.18f, 1.0f}; @@ -921,7 +783,7 @@ GraphicsPipeline::draw() vkCmdSetScissor(draw_command_buffer, 0, 1, &vk_scissor); // Draw models - for(auto& [model, instances] : this->models_to_draw[this->current_frame]) + for(auto& [model, instances] : this->models_to_draw[current_frame]) { // Commands { @@ -962,15 +824,13 @@ GraphicsPipeline::draw() instance_matrix = glm::rotate( instance_matrix, instances[i].rotation.z, glm::vec3{0.0, 0.0, 1.0}); - ubo_model_instance.model[i] = instance_matrix; + ubo_model_instance.instances[i] = instance_matrix; } model->ub_model_instance[image_index].copy_data(&ubo_model_instance); } vkCmdEndRenderPass(draw_command_buffer); - if(vkEndCommandBuffer(draw_command_buffer) != VK_SUCCESS) - throw std::runtime_error{"Failed to end draw command buffer."}; } // Update view projection uniform buffers @@ -1013,52 +873,8 @@ GraphicsPipeline::draw() this->ub_directional_light[image_index].copy_data(&ubo_directional_light); } - // Submit drawing command. - { - auto queue{this->queue_family->get_queue()}; - - VkSemaphore wait_semaphores[]{ - this->image_available_semaphores[this->current_frame]}; - VkPipelineStageFlags wait_stages[] = - {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT}; - VkSemaphore signal_semaphores[]{ - this->render_finished_semaphores[this->current_frame]}; - - VkSubmitInfo submit_info{}; - submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; - submit_info.pNext = nullptr; - submit_info.waitSemaphoreCount = 1; - submit_info.pWaitSemaphores = wait_semaphores; - submit_info.pWaitDstStageMask = wait_stages; - submit_info.commandBufferCount = 1; - submit_info.pCommandBuffers = &draw_command_buffer; - submit_info.signalSemaphoreCount = 1; - submit_info.pSignalSemaphores = signal_semaphores; - - if(vkQueueSubmit( - queue.queue, 1, &submit_info, - this->in_flight_fences[this->current_frame]) != VK_SUCCESS) - throw std::runtime_error{"Failed to submit draw command buffer."}; - - VkSwapchainKHR swap_chains[]{cg_core.vk_swapchain->swapchain}; - - VkPresentInfoKHR present_info{}; - present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; - present_info.pNext = nullptr; - present_info.waitSemaphoreCount = 1; - present_info.pWaitSemaphores = signal_semaphores; - present_info.swapchainCount = 1; - present_info.pSwapchains = swap_chains; - present_info.pImageIndices = &image_index; - present_info.pResults = nullptr; - - vkQueuePresentKHR(queue.queue, &present_info); - - // Prepare for the next frame. - this->current_frame = - (this->current_frame + 1) % this->max_frames_in_flight; - this->models_to_draw[this->current_frame].clear(); - } + // Prepare for the next frame. + this->models_to_draw[next_frame].clear(); } } diff --git a/src/vk/graphics_pipeline.hpp b/src/vk/graphics_pipeline_3d.hpp index b4a282a..2efbc00 100644 --- a/src/vk/graphics_pipeline.hpp +++ b/src/vk/graphics_pipeline_3d.hpp @@ -14,8 +14,8 @@ * limitations under the License. */ -#ifndef CANDY_GEAR_VK_GRAPHICS_PIPELINE_H -#define CANDY_GEAR_VK_GRAPHICS_PIPELINE_H 1 +#ifndef CANDY_GEAR_VK_GRAPHICS_PIPELINE_3D_H +#define CANDY_GEAR_VK_GRAPHICS_PIPELINE_3D_H 1 #include <memory> #include <unordered_map> @@ -30,7 +30,7 @@ namespace VK { -struct GraphicsPipeline +struct GraphicsPipeline3D { VkDescriptorSetLayout descriptor_set_layout_model_instance; VkDescriptorSetLayout descriptor_set_layout_world_view; @@ -52,30 +52,20 @@ struct GraphicsPipeline std::vector<VkFramebuffer> swapchain_framebuffers; VkPipeline graphic_pipeline; - QueueFamily *queue_family; - VkCommandPool command_pool; - std::vector<VkCommandBuffer> draw_command_buffers; - - // Buffering control. - static const int max_frames_in_flight{2}; - size_t current_frame; - std::vector<VkSemaphore> image_available_semaphores; - std::vector<VkSemaphore> render_finished_semaphores; - std::vector<VkFence> in_flight_fences; - std::shared_ptr<glm::vec3> camera_position; std::shared_ptr<glm::vec3> camera_rotation; std::vector<std::unordered_map< std::shared_ptr<Model>, std::vector<ModelInstance>>> models_to_draw; - GraphicsPipeline(); - ~GraphicsPipeline(); + GraphicsPipeline3D(); + ~GraphicsPipeline3D(); void - draw(); + draw(const VkCommandBuffer draw_command_buffer, const size_t current_frame, + const size_t next_frame, const uint32_t image_index); }; } -#endif /* CANDY_GEAR_VK_GRAPHICS_PIPELINE_H */ +#endif /* CANDY_GEAR_VK_GRAPHICS_PIPELINE_3D_H */ diff --git a/src/vk/model.cpp b/src/vk/model.cpp index 5cf96b6..240ad13 100644 --- a/src/vk/model.cpp +++ b/src/vk/model.cpp @@ -21,7 +21,7 @@ #include "../command.hpp" #include "../core.hpp" -#include "vertex.hpp" +#include "vertex_3d.hpp" namespace { @@ -82,12 +82,11 @@ load_mesh(void *obj) self->model->queue_family = cg_core.vk_device_with_swapchain->get_queue_family_with_graphics(); - VK::Queue transfer_queue{self->model->queue_family->get_queue()}; // Load vertexes. { auto vertex_count{read_uint32_from_file(input_file)}; - std::vector<VK::Vertex> vertexes{vertex_count}; + std::vector<VK::Vertex3D> vertexes{vertex_count}; for(auto i{0}; i < vertex_count; i++) { @@ -133,7 +132,7 @@ unload_mesh(void *obj) delete self->model->source_vertex_buffer; } -auto +void load_uniform_buffers(void *obj) { auto self = static_cast<ModelBuilder*>(obj); @@ -196,7 +195,7 @@ load_descriptor_sets(void *obj) std::vector<VkDescriptorSetLayout> layouts( cg_core.vk_swapchain->images_count, - cg_core.vk_graphics_pipeline->descriptor_set_layout_model_instance); + cg_core.vk_graphics_pipeline_3d->descriptor_set_layout_model_instance); VkDescriptorSetAllocateInfo alloc_info{}; alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; diff --git a/src/vk/renderer.cpp b/src/vk/renderer.cpp new file mode 100644 index 0000000..33a4bf7 --- /dev/null +++ b/src/vk/renderer.cpp @@ -0,0 +1,245 @@ +/* + * Copyright 2022 Frederico de Oliveira Linhares + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "renderer.hpp" + +#include "../core.hpp" + +namespace +{ + +void +load_frame_sync(void *obj) +{ + auto self = static_cast<VK::Renderer*>(obj); + + self->image_available_semaphores.resize(self->max_frames_in_flight); + self->render_finished_semaphores.resize(self->max_frames_in_flight); + self->in_flight_fences.resize(self->max_frames_in_flight); + + VkSemaphoreCreateInfo semaphore_info = {}; + semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + semaphore_info.pNext = nullptr; + semaphore_info.flags = 0; + + VkFenceCreateInfo fence_info = {}; + fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + fence_info.pNext = nullptr; + fence_info.flags = VK_FENCE_CREATE_SIGNALED_BIT; + + // FIXME: if this loop fails, it will not destroy the semaphores. + for(auto i{0}; i < self->max_frames_in_flight; i++) + { + if(vkCreateSemaphore( + cg_core.vk_device_with_swapchain->device, &semaphore_info, + nullptr, &self->image_available_semaphores[i]) != VK_SUCCESS || + vkCreateSemaphore( + cg_core.vk_device_with_swapchain->device, &semaphore_info, + nullptr, &self->render_finished_semaphores[i]) != VK_SUCCESS || + vkCreateFence(cg_core.vk_device_with_swapchain->device, &fence_info, + nullptr, &self->in_flight_fences[i]) != VK_SUCCESS) + throw CommandError{"Failed to create semaphores."}; + } +} + +void +unload_frame_sync(void *obj) +{ + auto self = static_cast<VK::Renderer*>(obj); + + vkDeviceWaitIdle(cg_core.vk_device_with_swapchain->device); + + for(auto i{0}; i < self->max_frames_in_flight; i++) + { + vkDestroySemaphore(cg_core.vk_device_with_swapchain->device, + self->render_finished_semaphores[i], nullptr); + vkDestroySemaphore(cg_core.vk_device_with_swapchain->device, + self->image_available_semaphores[i], nullptr); + vkDestroyFence(cg_core.vk_device_with_swapchain->device, + self->in_flight_fences[i], nullptr); + } +} + +void +load_queue_family(void *obj) +{ + auto self = static_cast<VK::Renderer*>(obj); + + self->queue_family = + cg_core.vk_device_with_swapchain->get_queue_family_with_presentation(); +} + +void +load_command_pool(void *obj) +{ + auto self = static_cast<VK::Renderer*>(obj); + + VkCommandPoolCreateInfo create_info{}; + create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + create_info.pNext = nullptr; + create_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; + create_info.queueFamilyIndex = self->queue_family->family_index; + + vkCreateCommandPool( + self->queue_family->device->device, &create_info, nullptr, + &self->command_pool); +} + +void +unload_command_pool(void *obj) +{ + auto self = static_cast<VK::Renderer*>(obj); + + vkWaitForFences(cg_core.vk_device_with_swapchain->device, 2, + self->in_flight_fences.data(), VK_TRUE, + std::numeric_limits<uint64_t>::max()); + vkDestroyCommandPool( + self->queue_family->device->device, self->command_pool, nullptr); +} + +void +load_draw_command_buffer(void *obj) +{ + auto self = static_cast<VK::Renderer*>(obj); + + // FIXME: 3 is a magical number, triple buffering. + self->draw_command_buffers.resize(3); + + VkCommandBufferAllocateInfo allocate_info{}; + allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocate_info.pNext = nullptr; + allocate_info.commandPool = self->command_pool; + allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocate_info.commandBufferCount = self->draw_command_buffers.size(); + + if(vkAllocateCommandBuffers( + self->queue_family->device->device, &allocate_info, + self->draw_command_buffers.data()) != VK_SUCCESS) + throw CommandError{"Vulkan draw command buffers could not be allocated."}; +} + +const CommandChain loader{ + {&load_frame_sync, &unload_frame_sync}, + {&load_queue_family, nullptr}, + {&load_command_pool, &unload_command_pool}, + {&load_draw_command_buffer, nullptr} +}; + +} + +namespace VK +{ + +Renderer::Renderer(): + current_frame{0} +{ + loader.execute(this); +} + +Renderer::~Renderer() +{ + loader.revert(this); +} + +void +Renderer::draw() +{ + vkWaitForFences(cg_core.vk_device_with_swapchain->device, 1, + &this->in_flight_fences[this->current_frame], VK_TRUE, + std::numeric_limits<uint64_t>::max()); + vkResetFences(cg_core.vk_device_with_swapchain->device, 1, + &this->in_flight_fences[this->current_frame]); + + uint32_t image_index; + vkAcquireNextImageKHR( + cg_core.vk_device_with_swapchain->device, cg_core.vk_swapchain->swapchain, + std::numeric_limits<uint64_t>::max(), + this->image_available_semaphores[this->current_frame], + VK_NULL_HANDLE, &image_index); + + VkCommandBuffer draw_command_buffer = + this->draw_command_buffers[this->current_frame]; + vkResetCommandBuffer(draw_command_buffer, 0); + + auto next_frame = this->current_frame + 1; + if(next_frame == this->max_frames_in_flight) next_frame = 0; + + // Begin command buffer. + { + VkCommandBufferBeginInfo begin_info{}; + begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + begin_info.flags = 0; + begin_info.pInheritanceInfo = nullptr; + if (vkBeginCommandBuffer(draw_command_buffer, &begin_info) != VK_SUCCESS) + throw std::runtime_error{"Failed to beggin draw command buffer."}; + } + + cg_core.vk_graphics_pipeline_3d->draw( + draw_command_buffer, current_frame, next_frame, image_index); + cg_core.vk_graphics_pipeline_2d->draw( + draw_command_buffer, current_frame, next_frame, image_index); + + // End command buffer. + if(vkEndCommandBuffer(draw_command_buffer) != VK_SUCCESS) + throw std::runtime_error{"Failed to end draw command buffer."}; + + // Submit drawing command. + { + auto queue{this->queue_family->get_queue()}; + + VkSemaphore wait_semaphores[]{ + this->image_available_semaphores[this->current_frame]}; + VkPipelineStageFlags wait_stages[] = + {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT}; + VkSemaphore signal_semaphores[]{ + this->render_finished_semaphores[this->current_frame]}; + + VkSubmitInfo submit_info{}; + submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submit_info.pNext = nullptr; + submit_info.waitSemaphoreCount = 1; + submit_info.pWaitSemaphores = wait_semaphores; + submit_info.pWaitDstStageMask = wait_stages; + submit_info.commandBufferCount = 1; + submit_info.pCommandBuffers = &draw_command_buffer; + submit_info.signalSemaphoreCount = 1; + submit_info.pSignalSemaphores = signal_semaphores; + + if(vkQueueSubmit( + queue.queue, 1, &submit_info, + this->in_flight_fences[this->current_frame]) != VK_SUCCESS) + throw std::runtime_error{"Failed to submit draw command buffer."}; + + VkSwapchainKHR swap_chains[]{cg_core.vk_swapchain->swapchain}; + + VkPresentInfoKHR present_info{}; + present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; + present_info.pNext = nullptr; + present_info.waitSemaphoreCount = 1; + present_info.pWaitSemaphores = signal_semaphores; + present_info.swapchainCount = 1; + present_info.pSwapchains = swap_chains; + present_info.pImageIndices = &image_index; + present_info.pResults = nullptr; + + vkQueuePresentKHR(queue.queue, &present_info); + } + + // Prepare for the next frame. + this->current_frame = next_frame; +} + +} diff --git a/src/vk/renderer.hpp b/src/vk/renderer.hpp new file mode 100644 index 0000000..4b6c91d --- /dev/null +++ b/src/vk/renderer.hpp @@ -0,0 +1,49 @@ +/* + * Copyright 2022 Frederico de Oliveira Linhares + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CANDY_GEAR_VK_RENDERER_H +#define CANDY_GEAR_VK_RENDERER_H 1 + +#include <vector> + +#include "core.hpp" +#include "queue_family.hpp" + +namespace VK +{ + +struct Renderer +{ + static const int max_frames_in_flight{2}; + size_t current_frame; + std::vector<VkSemaphore> image_available_semaphores; + std::vector<VkSemaphore> render_finished_semaphores; + std::vector<VkFence> in_flight_fences; + + QueueFamily *queue_family; + VkCommandPool command_pool; + std::vector<VkCommandBuffer> draw_command_buffers; + + Renderer(); + ~Renderer(); + + void + draw(); +}; + +} + +#endif /* CANDY_GEAR_VK_RENDERER_H */ diff --git a/src/vk/sprite.cpp b/src/vk/sprite.cpp new file mode 100644 index 0000000..e00fcbe --- /dev/null +++ b/src/vk/sprite.cpp @@ -0,0 +1,226 @@ +/* + * Copyright 2022 Frederico de Oliveira Linhares + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "sprite.hpp" + +#include <array> + +#include "../core.hpp" +#include "sprite.hpp" + +namespace +{ + +struct SpriteBuilder +{ + VK::Sprite *sprite; + glm::vec4 rect; + + SpriteBuilder(VK::Sprite *sprite, glm::vec4 rect); +}; + +SpriteBuilder::SpriteBuilder(VK::Sprite *sprite, glm::vec4 rect): + sprite{sprite}, + rect{rect} +{ +} + +void +load_mesh(void *obj) +{ + auto self = static_cast<SpriteBuilder*>(obj); + + self->sprite->queue_family = + cg_core.vk_device_with_swapchain->get_queue_family_with_graphics(); + + glm::vec2 rect[VK::Sprite::vertex_count]{ + glm::vec2{self->rect.x, self->rect.y}, + glm::vec2{self->rect.x, self->rect.w}, + glm::vec2{self->rect.z, self->rect.y}, + glm::vec2{self->rect.z, self->rect.w} + }; + + void *vertexes_data{&rect}; + static const size_t vertexes_size = + sizeof(glm::vec2) * VK::Sprite::vertex_count; + self->sprite->source_buffer = new VK::SourceBuffer{ + self->sprite->queue_family->device, vertexes_data, vertexes_size}; + self->sprite->vertex_buffer = new VK::DestinationBuffer{ + self->sprite->queue_family, self->sprite->source_buffer, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT}; +} + +void +unload_mesh(void *obj) +{ + auto self = static_cast<SpriteBuilder*>(obj); + + delete self->sprite->vertex_buffer; + delete self->sprite->source_buffer; +} + +void +load_uniform_buffers(void *obj) +{ + auto self = static_cast<SpriteBuilder*>(obj); + + self->sprite->ub_sprite_positions.reserve( + cg_core.vk_swapchain->images_count); + for(auto i{0}; i < cg_core.vk_swapchain->images_count; i++) + self->sprite->ub_sprite_positions.emplace_back( + cg_core.vk_device_with_swapchain, sizeof(VK::UBOSpritePositions)); +} + +void +unload_uniform_buffers(void *obj) +{ + auto self = static_cast<SpriteBuilder*>(obj); + + self->sprite->ub_sprite_positions.clear(); +} + +void +load_descriptor_set_pool(void *obj) +{ + auto self = static_cast<SpriteBuilder*>(obj); + + std::array<VkDescriptorPoolSize, 2> descriptor_pool_sizes{}; + descriptor_pool_sizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + descriptor_pool_sizes[0].descriptorCount = + self->sprite->ub_sprite_positions.size(); + descriptor_pool_sizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + descriptor_pool_sizes[1].descriptorCount = + self->sprite->ub_sprite_positions.size(); + + VkDescriptorPoolCreateInfo pool_info{}; + pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + pool_info.pNext = nullptr; + pool_info.flags = 0; + pool_info.maxSets = self->sprite->ub_sprite_positions.size(); + pool_info.poolSizeCount = descriptor_pool_sizes.size(); + pool_info.pPoolSizes = descriptor_pool_sizes.data(); + + if(vkCreateDescriptorPool( + self->sprite->queue_family->device->device, &pool_info, nullptr, + &self->sprite->descriptor_pool) != VK_SUCCESS) + throw CommandError{"Failed to create a Vulkan descriptor pool."}; + +} + +void +unload_descriptor_set_pool(void *obj) +{ + auto self = static_cast<SpriteBuilder*>(obj); + + vkDestroyDescriptorPool( + self->sprite->queue_family->device->device, self->sprite->descriptor_pool, + nullptr); +} + +void +load_descriptor_sets(void *obj) +{ + auto self = static_cast<SpriteBuilder*>(obj); + + std::vector<VkDescriptorSetLayout> layouts( + cg_core.vk_swapchain->images_count, + cg_core.vk_graphics_pipeline_2d->descriptor_set_layout_sprites); + + VkDescriptorSetAllocateInfo alloc_info{}; + alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + alloc_info.descriptorPool = self->sprite->descriptor_pool; + alloc_info.descriptorSetCount = layouts.size(); + alloc_info.pSetLayouts = layouts.data(); + + self->sprite->descriptor_sets.resize(layouts.size()); + if(vkAllocateDescriptorSets( + self->sprite->queue_family->device->device, &alloc_info, + self->sprite->descriptor_sets.data()) != VK_SUCCESS) + CommandError{"Failed to create Vulkan descriptor set."}; +} + +void +load_buffers_to_descriptor_sets(void *obj) +{ + auto self = static_cast<SpriteBuilder*>(obj); + + for(auto i{0}; i < self->sprite->ub_sprite_positions.size(); i++) + { + VkDescriptorBufferInfo buffer_info{}; + buffer_info.buffer = self->sprite->ub_sprite_positions[i].buffer; + buffer_info.offset = 0; + buffer_info.range = sizeof(VK::UBOSpritePositions); + + VkDescriptorImageInfo image_info{}; + image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + image_info.imageView = self->sprite->texture->view; + image_info.sampler = self->sprite->texture->sampler; + + std::array<VkWriteDescriptorSet, 2> write_descriptors{}; + write_descriptors[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + write_descriptors[0].dstSet = self->sprite->descriptor_sets[i]; + write_descriptors[0].dstBinding = 0; + write_descriptors[0].dstArrayElement = 0; + write_descriptors[0].descriptorCount = 1; + write_descriptors[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + write_descriptors[0].pBufferInfo = &buffer_info; + write_descriptors[0].pImageInfo = nullptr; + write_descriptors[0].pTexelBufferView = nullptr; + + write_descriptors[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + write_descriptors[1].dstSet = self->sprite->descriptor_sets[i]; + write_descriptors[1].dstBinding = 1; + write_descriptors[1].dstArrayElement = 0; + write_descriptors[1].descriptorCount = 1; + write_descriptors[1].descriptorType = + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + write_descriptors[1].pBufferInfo = nullptr; + write_descriptors[1].pImageInfo = &image_info; + write_descriptors[1].pTexelBufferView = nullptr; + + vkUpdateDescriptorSets( + cg_core.vk_device_with_swapchain->device, write_descriptors.size(), + write_descriptors.data(), 0, nullptr); + } +} + +static const CommandChain loader{ + {&load_mesh, &unload_mesh}, + {&load_uniform_buffers, &unload_uniform_buffers}, + {&load_descriptor_set_pool, &unload_descriptor_set_pool}, + {&load_descriptor_sets, nullptr}, + {&load_buffers_to_descriptor_sets, nullptr}, +}; + +} + +namespace VK +{ + +Sprite::Sprite(std::shared_ptr<Texture> texture, glm::vec4 rect): + texture{texture} +{ + SpriteBuilder sprite_builder(this, rect); + loader.execute(&sprite_builder); +} + +Sprite::~Sprite() +{ + SpriteBuilder sprite_builder(this, glm::vec4()); + loader.revert(&sprite_builder); +} + +} diff --git a/src/vk/sprite.hpp b/src/vk/sprite.hpp new file mode 100644 index 0000000..b0c0183 --- /dev/null +++ b/src/vk/sprite.hpp @@ -0,0 +1,55 @@ +/* + * Copyright 2022 Frederico de Oliveira Linhares + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CANDY_GEAR_VK_SPRITE_H +#define CANDY_GEAR_VK_SPRITE_H 1 + +#include <memory> +#include <unordered_map> +#include <vector> + +#include "core.hpp" +#include "destination_buffer.hpp" +#include "queue_family.hpp" +#include "uniform_buffer.hpp" +#include "texture.hpp" + +namespace VK +{ + +struct Sprite +{ + static const uint32_t vertex_count{4}; + + QueueFamily *queue_family; + + SourceBuffer *source_buffer; + DestinationBuffer *vertex_buffer; + + std::vector<UniformBuffer> ub_sprite_positions; + + VkDescriptorPool descriptor_pool; + std::vector<VkDescriptorSet> descriptor_sets; + + std::shared_ptr<Texture> texture; + + Sprite(std::shared_ptr<Texture> texture, glm::vec4 rect); + ~Sprite(); +}; + +} + +#endif /* CANDY_GEAR_VK_SPRITE_H */ diff --git a/src/vk/uniform_buffer.hpp b/src/vk/uniform_buffer.hpp index 14deead..50759b8 100644 --- a/src/vk/uniform_buffer.hpp +++ b/src/vk/uniform_buffer.hpp @@ -26,9 +26,14 @@ namespace VK { +struct UBOSpritePositions +{ + glm::vec4 positions[128]; +}; + struct UBOModelInstance { - glm::mat4 model[128]; + glm::mat4 instances[128]; }; struct UBOViewProjection diff --git a/src/vk/vertex.hpp b/src/vk/vertex_3d.hpp index 07332a8..8bb8675 100644 --- a/src/vk/vertex.hpp +++ b/src/vk/vertex_3d.hpp @@ -14,15 +14,15 @@ * limitations under the License. */ -#ifndef CANDY_GEAR_VK_VERTEX_H -#define CANDY_GEAR_VK_VERTEX_H 1 +#ifndef CANDY_GEAR_VK_VERTEX_3D_H +#define CANDY_GEAR_VK_VERTEX_3D_H 1 #include "core.hpp" namespace VK { -struct Vertex +struct Vertex3D { glm::vec3 position; glm::vec3 normal; @@ -31,4 +31,4 @@ struct Vertex } -#endif /* CANDY_GEAR_VK_VERTEX_H */ +#endif /* CANDY_GEAR_VK_VERTEX_3D_H */ |