diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/main.cpp | 2 | ||||
| -rw-r--r-- | src/mesh.cpp | 62 | ||||
| -rw-r--r-- | src/mesh.hpp | 27 | ||||
| -rw-r--r-- | src/model.cpp | 18 | ||||
| -rw-r--r-- | src/vk/graphics_pipeline_3d.cpp | 7 | ||||
| -rw-r--r-- | src/vk/mesh.cpp | 161 | ||||
| -rw-r--r-- | src/vk/mesh.hpp | 48 | ||||
| -rw-r--r-- | src/vk/model.cpp | 177 | ||||
| -rw-r--r-- | src/vk/model.hpp | 22 |
9 files changed, 345 insertions, 179 deletions
diff --git a/src/main.cpp b/src/main.cpp index d818c8f..178fcbb 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -20,6 +20,7 @@ #include "candy_gear.hpp" #include "core.hpp" #include "key.hpp" +#include "mesh.hpp" #include "model.hpp" #include "rotation_3d.hpp" #include "sound.hpp" @@ -64,6 +65,7 @@ int main(int argc, char *argv[]) mrb_define_module(cg_core.mrb, "CandyGear"); cg_candy_gear_init(cg_core.mrb); cg_key_init(cg_core.mrb); + cg_mesh_init(cg_core.mrb); cg_model_init(cg_core.mrb); cg_rotation_3d_init(cg_core.mrb); cg_sound_init(cg_core.mrb); diff --git a/src/mesh.cpp b/src/mesh.cpp new file mode 100644 index 0000000..409d45e --- /dev/null +++ b/src/mesh.cpp @@ -0,0 +1,62 @@ +/* + * 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 "mesh.hpp" + +#include "rotation_3d.hpp" +#include "vector_3d.hpp" + +void +cg_free_mesh(mrb_state *mrb, void* obj) +{ + auto ptr = static_cast<std::shared_ptr<VK::Mesh>*>(obj); + + ptr->~shared_ptr(); + mrb_free(mrb, ptr); +} + +const struct mrb_data_type cg_mesh_type = { "CG_Mesh", cg_free_mesh }; + +static mrb_value +cg_cMesh_initialize(mrb_state *mrb, mrb_value self) +{ + const char *file_path; + + std::shared_ptr<VK::Mesh> *ptr; + + mrb_get_args(mrb, "z", &file_path); + ptr = (std::shared_ptr<VK::Mesh>*)DATA_PTR(self); + if(ptr) mrb_free(mrb, ptr); + ptr = (std::shared_ptr<VK::Mesh>*)mrb_malloc( + mrb, sizeof(std::shared_ptr<VK::Mesh>)); + + new(ptr)std::shared_ptr<VK::Mesh>(std::make_shared<VK::Mesh>(file_path)); + + mrb_data_init(self, ptr, &cg_mesh_type); + return self; +} + +void +cg_mesh_init(mrb_state *mrb) +{ + struct RClass *cg_m, *cg_cMesh; + + cg_m = mrb_module_get(mrb, "CandyGear"); + cg_cMesh = mrb_define_class_under(mrb, cg_m, "Mesh", mrb->object_class); + MRB_SET_INSTANCE_TT(cg_cMesh, MRB_TT_DATA); + mrb_define_method( + mrb, cg_cMesh, "initialize", cg_cMesh_initialize, MRB_ARGS_REQ(1)); +} diff --git a/src/mesh.hpp b/src/mesh.hpp new file mode 100644 index 0000000..a68e224 --- /dev/null +++ b/src/mesh.hpp @@ -0,0 +1,27 @@ +/* + * 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_MESH_H +#define CANDY_GEAR_MESH_H 1 + +#include "core.hpp" + +extern const struct mrb_data_type cg_mesh_type; + +void +cg_mesh_init(mrb_state *mrb); + +#endif /* CANDY_GEAR_MESH_H */ diff --git a/src/model.cpp b/src/model.cpp index 6a6e470..b5c4185 100644 --- a/src/model.cpp +++ b/src/model.cpp @@ -16,13 +16,14 @@ #include "model.hpp" +#include "mesh.hpp" #include "rotation_3d.hpp" #include "texture.hpp" #include "vector_3d.hpp" #include "vk/model_instance.hpp" void -cg_free_model(mrb_state *mrb, void* obj) +cg_free_model(mrb_state *mrb, void *obj) { auto ptr = static_cast<std::shared_ptr<VK::Model>*>(obj); @@ -35,32 +36,27 @@ const struct mrb_data_type cg_model_type = { "CG_Model", cg_free_model }; static mrb_value cg_cModel_initialize(mrb_state *mrb, mrb_value self) { - const char *file_path; - - mrb_sym id_at_texture; - mrb_value texture_v; - + std::shared_ptr<VK::Mesh> *mesh; std::shared_ptr<VK::Texture> *texture; std::shared_ptr<VK::Model> *ptr; - mrb_get_args(mrb, "zd", &file_path, &texture, &cg_texture_type); + mrb_get_args(mrb, "dd", &mesh, &cg_mesh_type, &texture, &cg_texture_type); ptr = (std::shared_ptr<VK::Model>*)DATA_PTR(self); if(ptr) mrb_free(mrb, ptr); ptr = (std::shared_ptr<VK::Model>*)mrb_malloc( mrb, sizeof(std::shared_ptr<VK::Model>)); - std::string path{file_path}; new(ptr)std::shared_ptr<VK::Model>( - std::make_shared<VK::Model>(path, *texture)); + std::make_shared<VK::Model>(*mesh, *texture)); - mrb_data_init(self, ptr, &cg_model_type); + mrb_data_init(self, ptr, &cg_mesh_type); return self; } static mrb_value cg_cModel_draw(mrb_state *mrb, mrb_value self) { - auto *ptr = (std::shared_ptr<VK::Model>*)DATA_PTR(self); + auto ptr = (std::shared_ptr<VK::Model>*)DATA_PTR(self); VK::ModelInstance instance; std::shared_ptr<glm::vec3> *position; std::shared_ptr<glm::vec3> *rotation; diff --git a/src/vk/graphics_pipeline_3d.cpp b/src/vk/graphics_pipeline_3d.cpp index eb86401..f3a54e7 100644 --- a/src/vk/graphics_pipeline_3d.cpp +++ b/src/vk/graphics_pipeline_3d.cpp @@ -566,7 +566,7 @@ GraphicsPipeline3D::draw( this->descriptor_sets_world[image_index], view->descriptor_sets_3d[image_index], model->descriptor_sets[image_index]}; - VkBuffer vertex_buffers[]{model->vertex_buffer->buffer}; + VkBuffer vertex_buffers[]{model->mesh->vertex_buffer->buffer}; VkDeviceSize offsets[]{0}; vkCmdBindDescriptorSets( @@ -579,10 +579,11 @@ GraphicsPipeline3D::draw( vkCmdBindVertexBuffers( draw_command_buffer, 0, 1, vertex_buffers, offsets); vkCmdBindIndexBuffer( - draw_command_buffer, model->index_buffer->buffer, 0, + draw_command_buffer, model->mesh->index_buffer->buffer, 0, VK_INDEX_TYPE_UINT32); vkCmdDrawIndexed( - draw_command_buffer, model->index_count, instances.size(), 0, 0, 0); + draw_command_buffer, model->mesh->index_count, instances.size(), + 0, 0, 0); } VK::UBOModelInstance ubo_model_instance; diff --git a/src/vk/mesh.cpp b/src/vk/mesh.cpp new file mode 100644 index 0000000..70b9d45 --- /dev/null +++ b/src/vk/mesh.cpp @@ -0,0 +1,161 @@ +/* + * 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 "mesh.hpp" + +#include <array> +#include <fstream> + +#include "../command.hpp" +#include "../core.hpp" +#include "vertex_3d.hpp" + +namespace +{ + +// Data that is only needed for the command chain but not for the Mesh goes +// here. +struct MeshBuilder +{ + std::string mesh_path; + VK::Mesh *mesh; + + MeshBuilder(VK::Mesh *m, std::string mp); + MeshBuilder(VK::Mesh *m, const char* mp); +}; + +MeshBuilder::MeshBuilder(VK::Mesh *m, std::string mp): + mesh{m}, + mesh_path{mp} +{ +} + +MeshBuilder::MeshBuilder(VK::Mesh *m, const char *mp): + MeshBuilder{m, std::string(mp)} +{ +} + +uint32_t read_uint32_from_file(std::ifstream &input_file) +{ + uint32_t data{}; + input_file.read((char*)&data, sizeof(uint32_t)); + return data; +} + +glm::vec2 read_vec2_from_file(std::ifstream &input_file) +{ + glm::vec2 data{}; + input_file.read((char*)&data.x, sizeof(glm::vec2::value_type)); + input_file.read((char*)&data.y, sizeof(glm::vec2::value_type)); + return data; +} + +glm::vec3 read_vec3_from_file(std::ifstream &input_file) +{ + glm::vec3 data{}; + input_file.read((char*)&data.x, sizeof(glm::vec3::value_type)); + input_file.read((char*)&data.y, sizeof(glm::vec3::value_type)); + input_file.read((char*)&data.z, sizeof(glm::vec3::value_type)); + return data; +} + +void +load_mesh(void *obj) +{ + auto self = static_cast<MeshBuilder*>(obj); + + std::ifstream input_file{self->mesh_path}; + if(!input_file.is_open()) throw CommandError{"Failed to open file."}; + + self->mesh->queue_family = + cg_core.vk_device_with_swapchain->get_queue_family_with_graphics(); + + // Load vertexes. + { + auto vertex_count{read_uint32_from_file(input_file)}; + std::vector<VK::Vertex3D> vertexes{vertex_count}; + + for(auto i{0}; i < vertex_count; i++) + { + vertexes[i].position = read_vec3_from_file(input_file); + vertexes[i].normal = read_vec3_from_file(input_file); + vertexes[i].texture_coord = read_vec2_from_file(input_file); + } + + void *vertexes_data{vertexes.data()}; + size_t vertexes_size = sizeof(vertexes[0]) * vertexes.size(); + self->mesh->source_vertex_buffer = new VK::SourceBuffer{ + self->mesh->queue_family->device, vertexes_data, vertexes_size}; + self->mesh->vertex_buffer = new VK::DestinationBuffer{ + self->mesh->queue_family, self->mesh->source_vertex_buffer, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT}; + } + + // Load indexes. + { + self->mesh->index_count = read_uint32_from_file(input_file); + std::vector<uint32_t> indexes(self->mesh->index_count); + + for(auto i{0}; i < self->mesh->index_count; i++) + indexes[i] = read_uint32_from_file(input_file); + + void *indexes_data{indexes.data()}; + size_t indexes_size{sizeof(indexes[0]) * indexes.size()}; + VK::SourceBuffer source_index_buffer{ + self->mesh->queue_family->device, indexes_data, indexes_size}; + self->mesh->index_buffer = new VK::DestinationBuffer{ + self->mesh->queue_family, &source_index_buffer, + VK_BUFFER_USAGE_INDEX_BUFFER_BIT}; + } +} + +void +unload_mesh(void *obj) +{ + auto self = static_cast<MeshBuilder*>(obj); + + delete self->mesh->index_buffer; + delete self->mesh->vertex_buffer; + delete self->mesh->source_vertex_buffer; +} + +static const CommandChain loader{ + {&load_mesh, &unload_mesh} +}; + +} + +namespace VK +{ + +Mesh::Mesh(std::string mesh_path) +{ + MeshBuilder mesh_builder(this, mesh_path); + loader.execute(&mesh_builder); +} + +Mesh::Mesh(const char* mesh_path): + Mesh{std::string(mesh_path)} +{ +} + +Mesh::~Mesh() +{ + MeshBuilder mesh_builder(this, ""); + loader.revert(&mesh_builder); +} + +} diff --git a/src/vk/mesh.hpp b/src/vk/mesh.hpp new file mode 100644 index 0000000..97b9d8a --- /dev/null +++ b/src/vk/mesh.hpp @@ -0,0 +1,48 @@ +/* + * 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_MESH_H +#define CANDY_GEAR_VK_MESH_H 1 + +#include <string> +#include <vector> + +#include "core.hpp" +#include "destination_buffer.hpp" +#include "queue_family.hpp" +#include "uniform_buffer.hpp" +#include "texture.hpp" + +namespace VK +{ + +struct Mesh +{ + QueueFamily *queue_family; + + uint32_t index_count; + SourceBuffer *source_vertex_buffer; + DestinationBuffer *index_buffer; + DestinationBuffer *vertex_buffer; + + Mesh(std::string mesh_path); + Mesh(const char* mesh_path); + ~Mesh(); +}; + +} + +#endif /* CANDY_GEAR_VK_MESH_H */ diff --git a/src/vk/model.cpp b/src/vk/model.cpp index b92ec91..d38342d 100644 --- a/src/vk/model.cpp +++ b/src/vk/model.cpp @@ -17,181 +17,71 @@ #include "model.hpp" #include <array> -#include <fstream> -#include "../command.hpp" #include "../core.hpp" -#include "vertex_3d.hpp" namespace { -// Data that is only needed for the command chain but not for the Model goes -// here. -struct ModelBuilder -{ - std::string model_path; - VK::Model *model; - - ModelBuilder(VK::Model *m, std::string mp); - ModelBuilder(VK::Model *m, const char* mp); -}; - -ModelBuilder::ModelBuilder(VK::Model *m, std::string mp): - model{m}, - model_path{mp} -{ -} - -ModelBuilder::ModelBuilder(VK::Model *m, const char *mp): - ModelBuilder{m, std::string(mp)} -{ -} - -uint32_t read_uint32_from_file(std::ifstream &input_file) -{ - uint32_t data{}; - input_file.read((char*)&data, sizeof(uint32_t)); - return data; -} - -glm::vec2 read_vec2_from_file(std::ifstream &input_file) -{ - glm::vec2 data{}; - input_file.read((char*)&data.x, sizeof(glm::vec2::value_type)); - input_file.read((char*)&data.y, sizeof(glm::vec2::value_type)); - return data; -} - -glm::vec3 read_vec3_from_file(std::ifstream &input_file) -{ - glm::vec3 data{}; - input_file.read((char*)&data.x, sizeof(glm::vec3::value_type)); - input_file.read((char*)&data.y, sizeof(glm::vec3::value_type)); - input_file.read((char*)&data.z, sizeof(glm::vec3::value_type)); - return data; -} - -void -load_mesh(void *obj) -{ - auto self = static_cast<ModelBuilder*>(obj); - - std::ifstream input_file{self->model_path}; - if(!input_file.is_open()) throw CommandError{"Failed to open file."}; - - self->model->queue_family = - cg_core.vk_device_with_swapchain->get_queue_family_with_graphics(); - - // Load vertexes. - { - auto vertex_count{read_uint32_from_file(input_file)}; - std::vector<VK::Vertex3D> vertexes{vertex_count}; - - for(auto i{0}; i < vertex_count; i++) - { - vertexes[i].position = read_vec3_from_file(input_file); - vertexes[i].normal = read_vec3_from_file(input_file); - vertexes[i].texture_coord = read_vec2_from_file(input_file); - } - - void *vertexes_data{vertexes.data()}; - size_t vertexes_size = sizeof(vertexes[0]) * vertexes.size(); - self->model->source_vertex_buffer = new VK::SourceBuffer{ - self->model->queue_family->device, vertexes_data, vertexes_size}; - self->model->vertex_buffer = new VK::DestinationBuffer{ - self->model->queue_family, self->model->source_vertex_buffer, - VK_BUFFER_USAGE_VERTEX_BUFFER_BIT}; - } - - // Load indexes. - { - self->model->index_count = read_uint32_from_file(input_file); - std::vector<uint32_t> indexes(self->model->index_count); - - for(auto i{0}; i < self->model->index_count; i++) - indexes[i] = read_uint32_from_file(input_file); - - void *indexes_data{indexes.data()}; - size_t indexes_size{sizeof(indexes[0]) * indexes.size()}; - VK::SourceBuffer source_index_buffer{ - self->model->queue_family->device, indexes_data, indexes_size}; - self->model->index_buffer = new VK::DestinationBuffer{ - self->model->queue_family, &source_index_buffer, - VK_BUFFER_USAGE_INDEX_BUFFER_BIT}; - } -} - -void -unload_mesh(void *obj) -{ - auto self = static_cast<ModelBuilder*>(obj); - - delete self->model->index_buffer; - delete self->model->vertex_buffer; - delete self->model->source_vertex_buffer; -} - void load_uniform_buffers(void *obj) { - auto self = static_cast<ModelBuilder*>(obj); + auto self = static_cast<VK::Model*>(obj); - self->model->ub_model_instance.reserve(cg_core.vk_swapchain->images_count); + self->ub_model_instance.reserve(cg_core.vk_swapchain->images_count); for(int i{0}; i < cg_core.vk_swapchain->images_count; i++) - self->model->ub_model_instance.emplace_back( + self->ub_model_instance.emplace_back( cg_core.vk_device_with_swapchain, sizeof(VK::UBOModelInstance)); } void unload_uniform_buffers(void *obj) { - auto self = static_cast<ModelBuilder*>(obj); + auto self = static_cast<VK::Model*>(obj); - self->model->ub_model_instance.clear(); + self->ub_model_instance.clear(); } void load_descriptor_set_pool(void *obj) { - auto self = static_cast<ModelBuilder*>(obj); + auto self = static_cast<VK::Model*>(obj); std::array<VkDescriptorPoolSize, 2> descriptor_pool_sizes{}; descriptor_pool_sizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; descriptor_pool_sizes[0].descriptorCount = - self->model->ub_model_instance.size(); + self->ub_model_instance.size(); descriptor_pool_sizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; descriptor_pool_sizes[1].descriptorCount = - self->model->ub_model_instance.size(); + self->ub_model_instance.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->model->ub_model_instance.size(); + pool_info.maxSets = self->ub_model_instance.size(); pool_info.poolSizeCount = descriptor_pool_sizes.size(); pool_info.pPoolSizes = descriptor_pool_sizes.data(); if(vkCreateDescriptorPool( - self->model->queue_family->device->device, &pool_info, nullptr, - &self->model->descriptor_pool) != VK_SUCCESS) + self->mesh->queue_family->device->device, &pool_info, nullptr, + &self->descriptor_pool) != VK_SUCCESS) throw CommandError{"Failed to create a Vulkan descriptor pool."}; } void unload_descriptor_set_pool(void *obj) { - auto self = static_cast<ModelBuilder*>(obj); + auto self = static_cast<VK::Model*>(obj); vkDestroyDescriptorPool( - self->model->queue_family->device->device, self->model->descriptor_pool, - nullptr); + self->mesh->queue_family->device->device, self->descriptor_pool, nullptr); } void load_descriptor_sets(void *obj) { - auto self = static_cast<ModelBuilder*>(obj); + auto self = static_cast<VK::Model*>(obj); std::vector<VkDescriptorSetLayout> layouts( cg_core.vk_swapchain->images_count, @@ -199,37 +89,37 @@ load_descriptor_sets(void *obj) VkDescriptorSetAllocateInfo alloc_info{}; alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; - alloc_info.descriptorPool = self->model->descriptor_pool; + alloc_info.descriptorPool = self->descriptor_pool; alloc_info.descriptorSetCount = layouts.size(); alloc_info.pSetLayouts = layouts.data(); - self->model->descriptor_sets.resize(layouts.size()); + self->descriptor_sets.resize(layouts.size()); if(vkAllocateDescriptorSets( - self->model->queue_family->device->device, &alloc_info, - self->model->descriptor_sets.data()) != VK_SUCCESS) + self->mesh->queue_family->device->device, &alloc_info, + self->descriptor_sets.data()) != VK_SUCCESS) CommandError{"Failed to create Vulkan descriptor set."}; } void load_buffers_to_descriptor_sets(void *obj) { - auto self = static_cast<ModelBuilder*>(obj); + auto self = static_cast<VK::Model*>(obj); - for(auto i{0}; i < self->model->ub_model_instance.size(); i++) + for(auto i{0}; i < self->ub_model_instance.size(); i++) { VkDescriptorBufferInfo buffer_info{}; - buffer_info.buffer = self->model->ub_model_instance[i].buffer; + buffer_info.buffer = self->ub_model_instance[i].buffer; buffer_info.offset = 0; buffer_info.range = sizeof(VK::UBOModelInstance); VkDescriptorImageInfo image_info{}; image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - image_info.imageView = self->model->texture->view; - image_info.sampler = self->model->texture->sampler; + image_info.imageView = self->texture->view; + image_info.sampler = self->texture->sampler; std::array<VkWriteDescriptorSet, 2> write_descriptors{}; write_descriptors[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - write_descriptors[0].dstSet = self->model->descriptor_sets[i]; + write_descriptors[0].dstSet = self->descriptor_sets[i]; write_descriptors[0].dstBinding = 0; write_descriptors[0].dstArrayElement = 0; write_descriptors[0].descriptorCount = 1; @@ -239,7 +129,7 @@ load_buffers_to_descriptor_sets(void *obj) write_descriptors[0].pTexelBufferView = nullptr; write_descriptors[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - write_descriptors[1].dstSet = self->model->descriptor_sets[i]; + write_descriptors[1].dstSet = self->descriptor_sets[i]; write_descriptors[1].dstBinding = 1; write_descriptors[1].dstArrayElement = 0; write_descriptors[1].descriptorCount = 1; @@ -256,11 +146,10 @@ load_buffers_to_descriptor_sets(void *obj) } 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}, + {&load_buffers_to_descriptor_sets, nullptr} }; } @@ -268,22 +157,16 @@ static const CommandChain loader{ namespace VK { -Model::Model(std::string model_path, std::shared_ptr<Texture> texture): +Model::Model(std::shared_ptr<Mesh> mesh, std::shared_ptr<Texture> texture): + mesh{mesh}, texture{texture} { - ModelBuilder model_builder(this, model_path); - loader.execute(&model_builder); -} - -Model::Model(const char* model_path, std::shared_ptr<Texture> texture): - Model{std::string(model_path), texture} -{ + loader.execute(this); } Model::~Model() { - ModelBuilder model_builder(this, ""); - loader.revert(&model_builder); + loader.revert(this); } } diff --git a/src/vk/model.hpp b/src/vk/model.hpp index d6f8b69..72682b2 100644 --- a/src/vk/model.hpp +++ b/src/vk/model.hpp @@ -17,13 +17,7 @@ #ifndef CANDY_GEAR_VK_MODEL_H #define CANDY_GEAR_VK_MODEL_H 1 -#include <string> -#include <vector> - -#include "core.hpp" -#include "destination_buffer.hpp" -#include "queue_family.hpp" -#include "uniform_buffer.hpp" +#include "mesh.hpp" #include "texture.hpp" namespace VK @@ -31,22 +25,14 @@ namespace VK struct Model { - QueueFamily *queue_family; - - uint32_t index_count; - SourceBuffer *source_vertex_buffer; - DestinationBuffer *index_buffer; - DestinationBuffer *vertex_buffer; + std::shared_ptr<Mesh> mesh; + std::shared_ptr<Texture> texture; std::vector<UniformBuffer> ub_model_instance; - VkDescriptorPool descriptor_pool; std::vector<VkDescriptorSet> descriptor_sets; - std::shared_ptr<Texture> texture; - - Model(std::string model_path, std::shared_ptr<Texture> texture); - Model(const char* model_path, std::shared_ptr<Texture> texture); + Model(std::shared_ptr<Mesh> mesh, std::shared_ptr<Texture> texture); ~Model(); }; |