diff options
Diffstat (limited to 'src')
38 files changed, 2287 insertions, 339 deletions
diff --git a/src/binary_reader.cpp b/src/binary_reader.cpp index 5847328..04633a2 100644 --- a/src/binary_reader.cpp +++ b/src/binary_reader.cpp @@ -26,6 +26,11 @@ union IntAndFloat32bit{ float f; }; +union IntAndFloat64bit{ + uint64_t i; + double f; +}; + } BinaryReader::BinaryReader(std::string file_path): @@ -65,6 +70,37 @@ BinaryReader::read_ui32() return b1 << 24 | b2 << 16 | b3 << 8 | b4; } +uint64_t +BinaryReader::read_ui64() +{ + uint8_t b1{this->data[_pointer++]}, b2{this->data[_pointer++]}, + b3{this->data[_pointer++]}, b4{this->data[_pointer++]}, + b5{this->data[_pointer++]}, b6{this->data[_pointer++]}, + b7{this->data[_pointer++]}, b8{this->data[_pointer++]}; + + return (uint64_t)b1 << 56 | (uint64_t)b2 << 48 | (uint64_t)b3 << 40 | + (uint64_t)b4 << 32 | (uint64_t)b5 << 24 | (uint64_t)b6 << 16 | + (uint64_t)b7 << 8 | (uint64_t)b8; +} + +float +BinaryReader::read_float() +{ + IntAndFloat32bit num; + num.i = read_ui32(); + + return num.f; +} + +double +BinaryReader::read_double() +{ + IntAndFloat64bit num; + num.i = read_ui64(); + + return num.f; +} + glm::vec2 BinaryReader::read_vec2() { @@ -81,6 +117,31 @@ BinaryReader::read_vec3() return glm::vec3{x.f, y.f, z.f}; } +glm::quat +BinaryReader::read_quat() +{ + IntAndFloat32bit w{read_ui32()}, x{read_ui32()}, y{read_ui32()}, + z{read_ui32()}; + + return glm::quat{w.f, x.f, y.f, z.f}; +} + +glm::mat4 +BinaryReader::read_mat4() +{ + glm::mat4 matrix; + float *offset_matrix_data{glm::value_ptr(matrix)}; + + for(int i{0}; i < 16; i++) + { + IntAndFloat32bit num; + num.i = read_ui32(); + offset_matrix_data[i] = num.f; + } + + return matrix; +} + void BinaryReader::read_chars(char *str, int size) { diff --git a/src/binary_reader.hpp b/src/binary_reader.hpp index b2e4de5..5dbff54 100644 --- a/src/binary_reader.hpp +++ b/src/binary_reader.hpp @@ -43,12 +43,27 @@ public: uint32_t read_ui32(); + uint64_t + read_ui64(); + + float + read_float(); + + double + read_double(); + glm::vec2 read_vec2(); glm::vec3 read_vec3(); + glm::quat + read_quat(); + + glm::mat4 + read_mat4(); + void read_chars(char *str, int size); }; diff --git a/src/core.cpp b/src/core.cpp index 5039ffe..986ecc1 100644 --- a/src/core.cpp +++ b/src/core.cpp @@ -20,9 +20,11 @@ #include "font.hpp" #include "graphic.hpp" #include "key.hpp" -#include "mesh.hpp" -#include "model.hpp" #include "rotation_3d.hpp" +#include "skeletal_model.hpp" +#include "skeletal_mesh.hpp" +#include "static_model.hpp" +#include "static_mesh.hpp" #include "sound.hpp" #include "sprite.hpp" #include "texture.hpp" @@ -51,14 +53,22 @@ vk_debug_callback( { // Set level. Log::Level log_level; - if(message_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) + switch(message_severity) + { + case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: log_level = Log::Level::Trace; - else if(message_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) + break; + case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: log_level = Log::Level::Information; - else if(message_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) + break; + case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: log_level = Log::Level::Warning; - else if(message_severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) + break; + case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: + default: log_level = Log::Level::Error; + break; + } // Log message. cg_core.log.message(log_level, callback_data->pMessage); @@ -144,7 +154,9 @@ load_game(void *obj) cg_graphic_finish_config(cg_core.mrb); cg_core.max_frame_duration = - duration<long long, std::milli>(1000 / cg_core.fps); + duration<long long, std::milli>(1000 / cg_core.fps); + // FIXME: actually calculates the real delta time. + cg_core.delta_time = 1.0f / cg_core.fps; } void @@ -593,6 +605,26 @@ unload_vk_graphics_pipeline_3d(void *obj) } void +load_vk_graphics_pipeline_3d_skeletal(void *obj) +{ + try + { + cg_core.vk_graphics_pipeline_3d_skeletal = + std::make_unique<VK::GraphicsPipeline3DSkeletal>(); + } + catch(const CommandError &e) + { + throw CommandError{"Failed to create 3d skeletal graphics pipeline."}; + } +} + +void +unload_vk_graphics_pipeline_3d_skeletal(void *obj) +{ + cg_core.vk_graphics_pipeline_3d_skeletal = nullptr; +} + +void load_vk_graphics_pipeline_2d_solid(void *obj) { try @@ -660,14 +692,14 @@ unload_vk_renderer(void *obj) void load_mruby_interface(void *obj) { - mrb_value main_obj = mrb_obj_iv_inspect(cg_core.mrb, cg_core.mrb->top_self); - cg_candy_gear_init(cg_core.mrb); cg_font_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_skeletal_model_init(cg_core.mrb); + cg_skeletal_mesh_init(cg_core.mrb); + cg_static_model_init(cg_core.mrb); + cg_static_mesh_init(cg_core.mrb); cg_sound_init(cg_core.mrb); cg_sprite_init(cg_core.mrb); cg_texture_init(cg_core.mrb); @@ -675,13 +707,6 @@ load_mruby_interface(void *obj) cg_vector_4d_init(cg_core.mrb); cg_view_2d_init(cg_core.mrb); cg_view_3d_init(cg_core.mrb); - - mrb_funcall_id(cg_core.mrb, main_obj, cg_core.sym_init, 0); - if (cg_core.mrb->exc) - { - mrb_print_error(cg_core.mrb); - throw CommandError{"Error initializing game."}; - } } } @@ -709,6 +734,9 @@ const CommandChain cg_sCore::loader{ &unload_vk_graphics_pipeline_2d_solid_layout}, {&load_vk_graphics_pipeline_2d_wired_layout, &unload_vk_graphics_pipeline_2d_wired_layout}, + // TODO: finish skeletal mesh animation + // {&load_vk_graphics_pipeline_3d_skeletal, + // &unload_vk_graphics_pipeline_3d_skeletal}, {&load_vk_graphics_pipeline_3d, &unload_vk_graphics_pipeline_3d}, {&load_vk_graphics_pipeline_2d_solid, &unload_vk_graphics_pipeline_2d_solid}, {&load_vk_graphics_pipeline_2d_wired, &unload_vk_graphics_pipeline_2d_wired}, diff --git a/src/core.hpp b/src/core.hpp index ad5d136..d9e3c9e 100644 --- a/src/core.hpp +++ b/src/core.hpp @@ -54,6 +54,7 @@ #include "vk/graphics_pipeline_2d_wired.hpp" #include "vk/graphics_pipeline_3d_layout.hpp" #include "vk/graphics_pipeline_3d.hpp" +#include "vk/graphics_pipeline_3d_skeletal.hpp" #include "vk/renderer.hpp" #include "vk/swapchain.hpp" @@ -98,6 +99,7 @@ struct cg_sCore Uint32 fps; std::chrono::duration<long long, std::milli> max_frame_duration; + float delta_time; SDL_Window *window; @@ -119,6 +121,8 @@ struct cg_sCore VK::GraphicsPipeline2DSolidLayout *vk_graphics_pipeline_2d_solid_layout; VK::GraphicsPipeline2DWiredLayout *vk_graphics_pipeline_2d_wired_layout; std::unique_ptr<VK::GraphicsPipeline3D> vk_graphics_pipeline_3d; + std::unique_ptr<VK::GraphicsPipeline3DSkeletal> + vk_graphics_pipeline_3d_skeletal; std::unique_ptr<VK::GraphicsPipeline2DSolid> vk_graphics_pipeline_2d_solid; std::unique_ptr<VK::GraphicsPipeline2DWired> vk_graphics_pipeline_2d_wired; diff --git a/src/main.cpp b/src/main.cpp index 7f02f49..75b7894 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -41,7 +41,15 @@ int main(int argc, char *argv[]) return 1; } - mrb_value main_obj = mrb_obj_iv_inspect(cg_core.mrb, cg_core.mrb->top_self); + mrb_value main_obj{mrb_obj_iv_inspect(cg_core.mrb, cg_core.mrb->top_self)}; + + mrb_funcall_id(cg_core.mrb, main_obj, cg_core.sym_init, 0); + if (cg_core.mrb->exc) + { + mrb_print_error(cg_core.mrb); + cg_sCore::loader.revert(nullptr); + return 1; + } auto frame_start = steady_clock::now(); diff --git a/src/mesh.cpp b/src/mesh.cpp deleted file mode 100644 index 409d45e..0000000 --- a/src/mesh.cpp +++ /dev/null @@ -1,62 +0,0 @@ -/* - * 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/model.cpp b/src/model.cpp deleted file mode 100644 index b5c4185..0000000 --- a/src/model.cpp +++ /dev/null @@ -1,87 +0,0 @@ -/* - * 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 "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) -{ - auto ptr = static_cast<std::shared_ptr<VK::Model>*>(obj); - - ptr->~shared_ptr(); - mrb_free(mrb, ptr); -} - -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) -{ - std::shared_ptr<VK::Mesh> *mesh; - std::shared_ptr<VK::Texture> *texture; - std::shared_ptr<VK::Model> *ptr; - - 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>)); - - new(ptr)std::shared_ptr<VK::Model>( - std::make_shared<VK::Model>(*mesh, *texture)); - - 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); - VK::ModelInstance instance; - std::shared_ptr<glm::vec3> *position; - std::shared_ptr<glm::vec3> *rotation; - - mrb_get_args( - mrb, "dd", &position, &cg_vector_3d_type, &rotation, &cg_rotation_3d_type); - instance.position = **position; - instance.rotation = **rotation; - - auto &instances = cg_core.vk_renderer->models_to_draw[ - cg_core.vk_swapchain->current_frame][*ptr]; - instances.push_back(instance); - - return self; -} - -void -cg_model_init(mrb_state *mrb) -{ - struct RClass *cg_m, *cg_cModel; - - cg_m = mrb_module_get(mrb, "CandyGear"); - cg_cModel = mrb_define_class_under(mrb, cg_m, "Model", mrb->object_class); - MRB_SET_INSTANCE_TT(cg_cModel, MRB_TT_DATA); - mrb_define_method( - mrb, cg_cModel, "initialize", cg_cModel_initialize, MRB_ARGS_REQ(2)); - mrb_define_method(mrb, cg_cModel, "draw", cg_cModel_draw, MRB_ARGS_REQ(2)); -} diff --git a/src/skeletal_mesh.cpp b/src/skeletal_mesh.cpp new file mode 100644 index 0000000..767ef5a --- /dev/null +++ b/src/skeletal_mesh.cpp @@ -0,0 +1,67 @@ +/* + * Copyright 2022-2023 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 "skeletal_mesh.hpp" + +#include "rotation_3d.hpp" +#include "vector_3d.hpp" +#include "vk/skeletal_mesh.hpp" + +void +cg_free_skeletal_mesh(mrb_state *mrb, void* obj) +{ + auto ptr = static_cast<std::shared_ptr<VK::SkeletalMesh>*>(obj); + + ptr->~shared_ptr(); + mrb_free(mrb, ptr); +} + +const struct mrb_data_type cg_skeletal_mesh_type = { + "CG_SkeletalMesh", cg_free_skeletal_mesh }; + +static mrb_value +cg_cSkeletalMesh_initialize(mrb_state *mrb, mrb_value self) +{ + const char *file_path; + + std::shared_ptr<VK::SkeletalMesh> *ptr; + + mrb_get_args(mrb, "z", &file_path); + ptr = (std::shared_ptr<VK::SkeletalMesh>*)DATA_PTR(self); + if(ptr) mrb_free(mrb, ptr); + ptr = (std::shared_ptr<VK::SkeletalMesh>*)mrb_malloc( + mrb, sizeof(std::shared_ptr<VK::SkeletalMesh>)); + + new(ptr)std::shared_ptr<VK::SkeletalMesh>( + std::make_shared<VK::SkeletalMesh>(file_path)); + + mrb_data_init(self, ptr, &cg_skeletal_mesh_type); + return self; +} + +void +cg_skeletal_mesh_init(mrb_state *mrb) +{ + struct RClass *cg_m, *cg_cSkeletalMesh; + + cg_m = mrb_module_get(mrb, "CandyGear"); + cg_cSkeletalMesh = mrb_define_class_under( + mrb, cg_m, "SkeletalMesh", mrb->object_class); + MRB_SET_INSTANCE_TT(cg_cSkeletalMesh, MRB_TT_DATA); + mrb_define_method( + mrb, cg_cSkeletalMesh, "initialize", cg_cSkeletalMesh_initialize, + MRB_ARGS_REQ(1)); +} diff --git a/src/skeletal_mesh.hpp b/src/skeletal_mesh.hpp new file mode 100644 index 0000000..476aa9b --- /dev/null +++ b/src/skeletal_mesh.hpp @@ -0,0 +1,27 @@ +/* + * Copyright 2022-2023 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_SKELETAL_MESH_H +#define CANDY_GEAR_SKELETAL_MESH_H 1 + +#include "core.hpp" + +extern const struct mrb_data_type cg_skeletal_mesh_type; + +void +cg_skeletal_mesh_init(mrb_state *mrb); + +#endif /* CANDY_GEAR_SKELETAL_MESH_H */ diff --git a/src/skeletal_model.cpp b/src/skeletal_model.cpp new file mode 100644 index 0000000..0165e91 --- /dev/null +++ b/src/skeletal_model.cpp @@ -0,0 +1,134 @@ +/* + * Copyright 2022-2023 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 "skeletal_model.hpp" + +#include "vector_3d.hpp" +#include "rotation_3d.hpp" +#include "skeletal_mesh.hpp" +#include "texture.hpp" +#include "vk/skeletal_model.hpp" + +void +cg_free_skeletal_model(mrb_state *mrb, void *obj) +{ + auto ptr = static_cast<std::shared_ptr<VK::SkeletalModel>*>(obj); + + ptr->~shared_ptr(); + mrb_free(mrb, ptr); +} + +const struct mrb_data_type cg_skeletal_model_type = { + "CG_SkeletalModel", cg_free_skeletal_model }; + +static mrb_value +cg_cSkeletalModel_initialize(mrb_state *mrb, mrb_value self) +{ + std::shared_ptr<VK::SkeletalMesh> *skeletal_mesh; + std::shared_ptr<VK::Texture> *texture; + std::shared_ptr<glm::vec3> *position; + std::shared_ptr<glm::vec3> *rotation; + std::shared_ptr<VK::SkeletalModel> *ptr; + + mrb_get_args( + mrb, "dddd", &skeletal_mesh, &cg_skeletal_mesh_type, &texture, + &cg_texture_type, &position, &cg_vector_3d_type, &rotation, + &cg_rotation_3d_type); + ptr = (std::shared_ptr<VK::SkeletalModel>*)DATA_PTR(self); + if(ptr) mrb_free(mrb, ptr); + ptr = (std::shared_ptr<VK::SkeletalModel>*)mrb_malloc( + mrb, sizeof(std::shared_ptr<VK::SkeletalModel>)); + + new(ptr)std::shared_ptr<VK::SkeletalModel>( + std::make_shared<VK::SkeletalModel>( + *skeletal_mesh, *texture, *position, *rotation)); + + mrb_data_init(self, ptr, &cg_skeletal_model_type); + return self; +} + +static mrb_value +cg_cSkeletalModel_set_rotation(mrb_state *mrb, mrb_value self) +{ + auto ptr = (std::shared_ptr<VK::SkeletalModel>*)DATA_PTR(self); + std::shared_ptr<glm::vec3> *rotation; + + mrb_get_args(mrb, "d", &rotation, &cg_rotation_3d_type); + (*ptr)->rotation = *rotation; + + return self; +} + +static mrb_value +cg_cSkeletalModel_set_position(mrb_state *mrb, mrb_value self) +{ + auto ptr = (std::shared_ptr<VK::SkeletalModel>*)DATA_PTR(self); + std::shared_ptr<glm::vec3> *position; + + mrb_get_args(mrb, "d", &position, &cg_vector_3d_type); + (*ptr)->position = *position; + + return self; +} + +static mrb_value +cg_cSkeletalModel_set_animation(mrb_state *mrb, mrb_value self) +{ + auto ptr = (std::shared_ptr<VK::SkeletalModel>*)DATA_PTR(self); + mrb_int animation_index; + + mrb_get_args(mrb, "i", &animation_index); + (*ptr)->animation_index = animation_index; + + return self; +} + +static mrb_value +cg_cSkeletalModel_draw(mrb_state *mrb, mrb_value self) +{ + auto ptr = (std::shared_ptr<VK::SkeletalModel>*)DATA_PTR(self); + + auto &instances = cg_core.vk_renderer->skeletal_models_to_draw[ + cg_core.vk_swapchain->current_frame][(*ptr)->skeletal_mesh]; + instances.push_back(*ptr); + + return self; +} + +void +cg_skeletal_model_init(mrb_state *mrb) +{ + struct RClass *cg_m, *cg_cSkeletalModel; + + cg_m = mrb_module_get(mrb, "CandyGear"); + cg_cSkeletalModel = mrb_define_class_under( + mrb, cg_m, "SkeletalModel", mrb->object_class); + MRB_SET_INSTANCE_TT(cg_cSkeletalModel, MRB_TT_DATA); + mrb_define_method( + mrb, cg_cSkeletalModel, "initialize", cg_cSkeletalModel_initialize, + MRB_ARGS_REQ(4)); + mrb_define_method( + mrb, cg_cSkeletalModel, "position=", cg_cSkeletalModel_set_position, + MRB_ARGS_REQ(1)); + mrb_define_method( + mrb, cg_cSkeletalModel, "rotation=", cg_cSkeletalModel_set_rotation, + MRB_ARGS_REQ(1)); + mrb_define_method( + mrb, cg_cSkeletalModel, "animation=", cg_cSkeletalModel_set_animation, + MRB_ARGS_REQ(1)); + mrb_define_method( + mrb, cg_cSkeletalModel, "draw", cg_cSkeletalModel_draw, MRB_ARGS_NONE()); +} diff --git a/src/mesh.hpp b/src/skeletal_model.hpp index a68e224..05f9c2e 100644 --- a/src/mesh.hpp +++ b/src/skeletal_model.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -14,14 +14,12 @@ * limitations under the License. */ -#ifndef CANDY_GEAR_MESH_H -#define CANDY_GEAR_MESH_H 1 +#ifndef CANDY_GEAR_SKELETAL_MODEL_H +#define CANDY_GEAR_SKELETAL_MODEL_H 1 #include "core.hpp" -extern const struct mrb_data_type cg_mesh_type; - void -cg_mesh_init(mrb_state *mrb); +cg_skeletal_model_init(mrb_state *mrb); -#endif /* CANDY_GEAR_MESH_H */ +#endif /* CANDY_GEAR_SKELETAL_MODEL_H */ diff --git a/src/static_mesh.cpp b/src/static_mesh.cpp new file mode 100644 index 0000000..e1e8776 --- /dev/null +++ b/src/static_mesh.cpp @@ -0,0 +1,67 @@ +/* + * Copyright 2022-2023 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 "static_mesh.hpp" + +#include "rotation_3d.hpp" +#include "vector_3d.hpp" +#include "vk/static_mesh.hpp" + +void +cg_free_static_mesh(mrb_state *mrb, void* obj) +{ + auto ptr = static_cast<std::shared_ptr<VK::StaticMesh>*>(obj); + + ptr->~shared_ptr(); + mrb_free(mrb, ptr); +} + +const struct mrb_data_type cg_static_mesh_type = { + "CG_StaticMesh", cg_free_static_mesh }; + +static mrb_value +cg_cStaticMesh_initialize(mrb_state *mrb, mrb_value self) +{ + const char *file_path; + + std::shared_ptr<VK::StaticMesh> *ptr; + + mrb_get_args(mrb, "z", &file_path); + ptr = (std::shared_ptr<VK::StaticMesh>*)DATA_PTR(self); + if(ptr) mrb_free(mrb, ptr); + ptr = (std::shared_ptr<VK::StaticMesh>*)mrb_malloc( + mrb, sizeof(std::shared_ptr<VK::StaticMesh>)); + + new(ptr)std::shared_ptr<VK::StaticMesh>( + std::make_shared<VK::StaticMesh>(file_path)); + + mrb_data_init(self, ptr, &cg_static_mesh_type); + return self; +} + +void +cg_static_mesh_init(mrb_state *mrb) +{ + struct RClass *cg_m, *cg_cStaticMesh; + + cg_m = mrb_module_get(mrb, "CandyGear"); + cg_cStaticMesh = mrb_define_class_under( + mrb, cg_m, "StaticMesh", mrb->object_class); + MRB_SET_INSTANCE_TT(cg_cStaticMesh, MRB_TT_DATA); + mrb_define_method( + mrb, cg_cStaticMesh, "initialize", cg_cStaticMesh_initialize, + MRB_ARGS_REQ(1)); +} diff --git a/src/static_mesh.hpp b/src/static_mesh.hpp new file mode 100644 index 0000000..8f3b2d6 --- /dev/null +++ b/src/static_mesh.hpp @@ -0,0 +1,27 @@ +/* + * Copyright 2022-2023 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_STATIC_MESH_H +#define CANDY_GEAR_STATIC_MESH_H 1 + +#include "core.hpp" + +extern const struct mrb_data_type cg_static_mesh_type; + +void +cg_static_mesh_init(mrb_state *mrb); + +#endif /* CANDY_GEAR_STATIC_MESH_H */ diff --git a/src/static_model.cpp b/src/static_model.cpp new file mode 100644 index 0000000..25a08c7 --- /dev/null +++ b/src/static_model.cpp @@ -0,0 +1,119 @@ +/* + * Copyright 2022-2023 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 "static_model.hpp" + +#include "vector_3d.hpp" +#include "rotation_3d.hpp" +#include "static_mesh.hpp" +#include "texture.hpp" +#include "vk/static_model.hpp" + +void +cg_free_static_model(mrb_state *mrb, void *obj) +{ + auto ptr = static_cast<std::shared_ptr<VK::StaticModel>*>(obj); + + ptr->~shared_ptr(); + mrb_free(mrb, ptr); +} + +const struct mrb_data_type cg_static_model_type = { + "CG_StaticModel", cg_free_static_model }; + +static mrb_value +cg_cStaticModel_initialize(mrb_state *mrb, mrb_value self) +{ + std::shared_ptr<VK::StaticMesh> *static_mesh; + std::shared_ptr<VK::Texture> *texture; + std::shared_ptr<glm::vec3> *position; + std::shared_ptr<glm::vec3> *rotation; + std::shared_ptr<VK::StaticModel> *ptr; + + mrb_get_args( + mrb, "dddd", &static_mesh, &cg_static_mesh_type, &texture, + &cg_texture_type, &position, &cg_vector_3d_type, &rotation, + &cg_rotation_3d_type); + ptr = (std::shared_ptr<VK::StaticModel>*)DATA_PTR(self); + if(ptr) mrb_free(mrb, ptr); + ptr = (std::shared_ptr<VK::StaticModel>*)mrb_malloc( + mrb, sizeof(std::shared_ptr<VK::StaticModel>)); + + new(ptr)std::shared_ptr<VK::StaticModel>( + std::make_shared<VK::StaticModel>( + *static_mesh, *texture, *position, *rotation)); + + mrb_data_init(self, ptr, &cg_static_model_type); + return self; +} + +static mrb_value +cg_cStaticModel_set_rotation(mrb_state *mrb, mrb_value self) +{ + auto ptr = (std::shared_ptr<VK::StaticModel>*)DATA_PTR(self); + std::shared_ptr<glm::vec3> *rotation; + + mrb_get_args(mrb, "d", &rotation, &cg_rotation_3d_type); + (*ptr)->rotation = *rotation; + + return self; +} + +static mrb_value +cg_cStaticModel_set_position(mrb_state *mrb, mrb_value self) +{ + auto ptr = (std::shared_ptr<VK::StaticModel>*)DATA_PTR(self); + std::shared_ptr<glm::vec3> *position; + + mrb_get_args(mrb, "d", &position, &cg_vector_3d_type); + (*ptr)->position = *position; + + return self; +} + +static mrb_value +cg_cStaticModel_draw(mrb_state *mrb, mrb_value self) +{ + auto ptr = (std::shared_ptr<VK::StaticModel>*)DATA_PTR(self); + + auto &instances = cg_core.vk_renderer->static_models_to_draw[ + cg_core.vk_swapchain->current_frame][(*ptr)->static_mesh]; + instances.push_back(*ptr); + + return self; +} + +void +cg_static_model_init(mrb_state *mrb) +{ + struct RClass *cg_m, *cg_cStaticModel; + + cg_m = mrb_module_get(mrb, "CandyGear"); + cg_cStaticModel = mrb_define_class_under( + mrb, cg_m, "StaticModel", mrb->object_class); + MRB_SET_INSTANCE_TT(cg_cStaticModel, MRB_TT_DATA); + mrb_define_method( + mrb, cg_cStaticModel, "initialize", cg_cStaticModel_initialize, + MRB_ARGS_REQ(4)); + mrb_define_method( + mrb, cg_cStaticModel, "position=", cg_cStaticModel_set_position, + MRB_ARGS_REQ(1)); + mrb_define_method( + mrb, cg_cStaticModel, "rotation=", cg_cStaticModel_set_rotation, + MRB_ARGS_REQ(1)); + mrb_define_method( + mrb, cg_cStaticModel, "draw", cg_cStaticModel_draw, MRB_ARGS_NONE()); +} diff --git a/src/model.hpp b/src/static_model.hpp index 50e49a1..dfb7054 100644 --- a/src/model.hpp +++ b/src/static_model.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -14,12 +14,12 @@ * limitations under the License. */ -#ifndef CANDY_GEAR_MODEL_H -#define CANDY_GEAR_MODEL_H 1 +#ifndef CANDY_GEAR_STATIC_MODEL_H +#define CANDY_GEAR_STATIC_MODEL_H 1 #include "core.hpp" void -cg_model_init(mrb_state *mrb); +cg_static_model_init(mrb_state *mrb); -#endif /* CANDY_GEAR_MODEL_H */ +#endif /* CANDY_GEAR_STATIC_MODEL_H */ diff --git a/src/vk/model_instance.hpp b/src/vk/animation.cpp index 1383737..fec038e 100644 --- a/src/vk/model_instance.hpp +++ b/src/vk/animation.cpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -14,19 +14,14 @@ * limitations under the License. */ -#ifndef CANDY_GEAR_VK_MODEL_INSTANCE_H -#define CANDY_GEAR_VK_MODEL_INSTANCE_H 1 - -#include "core.hpp" +#include "animation.hpp" namespace VK { -struct ModelInstance +Bone::Bone(glm::mat4 offset_matrix): + offset_matrix{offset_matrix} { - glm::vec3 position, rotation; -}; - } -#endif /* CANDY_GEAR_VK_MODEL_INSTANCE_H */ +} diff --git a/src/vk/animation.hpp b/src/vk/animation.hpp new file mode 100644 index 0000000..46dd5bc --- /dev/null +++ b/src/vk/animation.hpp @@ -0,0 +1,51 @@ +/* + * Copyright 2022-2023 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_ANIMATION_H +#define CANDY_GEAR_VK_ANIMATION_H 1 + +#include <vector> + +#include "core.hpp" +#include "animation/frame.hpp" + +namespace VK +{ + +struct Bone +{ + glm::mat4x4 offset_matrix; + + Bone(glm::mat4 offset_matrix); +}; + +struct BoneTransform +{ + uint32_t bone_id; + Channel<glm::vec3> positions; + Channel<glm::quat> rotations; + Channel<glm::vec3> scales; +}; + +struct Animation +{ + std::vector<BoneTransform> bone_transforms; + float final_time; +}; + +} + +#endif /* CANDY_GEAR_VK_ANIMATION_H */ diff --git a/src/vk/animation/frame.hpp b/src/vk/animation/frame.hpp new file mode 100644 index 0000000..953a6a6 --- /dev/null +++ b/src/vk/animation/frame.hpp @@ -0,0 +1,85 @@ +/* + * Copyright 2022-2023 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_FRAME_H +#define CANDY_GEAR_VK_FRAME_H 1 + +#include <vector> + +#include "../core.hpp" + +namespace VK +{ + +template<typename T> +struct Frame +{ + const T value; + const float timestamp; + + Frame(T value, float timestamp): + value{value}, + timestamp{timestamp} + { + } + +}; + +template<typename T> +struct Channel +{ + int current_index{0}; + std::vector<Frame<T>> key_frames; + + inline glm::mat4 + interpolate( + float animation_time, + glm::mat4 (*single_frame)(T frame), + glm::mat4 (*multiple_frames)(T current_frame, T next_frame, float scale)) + { + if(this->key_frames.size() == 1) + return single_frame(this->key_frames[0].value); + else + { + while(animation_time > this->key_frames[current_index].timestamp) + this->current_index++; + + float scale_factor; + Frame<T> *previous_frame; + Frame<T> *next_frame{&(this->key_frames[this->current_index])}; + if(this->current_index == 0) + { + previous_frame = &(this->key_frames[this->key_frames.size() - 1]); + float midway_length{animation_time - 0}; + float frames_diff{next_frame->timestamp - 0}; + scale_factor = midway_length / frames_diff; + } + else + { + previous_frame = &(this->key_frames[this->current_index - 1]); + float midway_length{animation_time - previous_frame->timestamp}; + float frames_diff{next_frame->timestamp - previous_frame->timestamp}; + scale_factor = midway_length / frames_diff; + } + + return multiple_frames( + previous_frame->value, next_frame->value, scale_factor); + } + }; +}; + +} +#endif /* CANDY_GEAR_VK_FRAME_H */ diff --git a/src/vk/core.hpp b/src/vk/core.hpp index 6d42bde..64d1431 100644 --- a/src/vk/core.hpp +++ b/src/vk/core.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -23,8 +23,9 @@ #define GLM_FORCE_DEPTH_ZERO_TO_ONE #include <glm/ext/vector_float3.hpp> -#include <glm/glm.hpp> +#include <glm/ext.hpp> #include <glm/gtc/matrix_transform.hpp> +#include <glm/gtx/quaternion.hpp> #include <glm/vec3.hpp> #include <vulkan/vulkan.h> diff --git a/src/vk/graphics_pipeline_3d.cpp b/src/vk/graphics_pipeline_3d.cpp index 4eacc9d..6639d99 100644 --- a/src/vk/graphics_pipeline_3d.cpp +++ b/src/vk/graphics_pipeline_3d.cpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -22,7 +22,7 @@ #include "../core.hpp" #include "core.hpp" #include "image.hpp" -#include "vertex_3d.hpp" +#include "static_mesh_vertex.hpp" #include "uniform_data_object.hpp" namespace @@ -330,7 +330,7 @@ load_pipeline(void *obj) VkVertexInputBindingDescription vertex_input_binding{}; vertex_input_binding.binding = 0; - vertex_input_binding.stride = sizeof(VK::Vertex3D); + vertex_input_binding.stride = sizeof(VK::StaticMeshVertex); vertex_input_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; std::array<VkVertexInputAttributeDescription, 3> vertex_attribute{}; @@ -338,17 +338,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::Vertex3D, position); + vertex_attribute[0].offset = offsetof(VK::StaticMeshVertex, 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::Vertex3D, normal); + vertex_attribute[1].offset = offsetof(VK::StaticMeshVertex, 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::Vertex3D, texture_coord); + vertex_attribute[2].offset = offsetof(VK::StaticMeshVertex, texture_coord); VkPipelineVertexInputStateCreateInfo vertex_input_info = {}; vertex_input_info.sType = @@ -557,49 +557,48 @@ GraphicsPipeline3D::draw( } // Draw models - for(auto& [model, instances]: - cg_core.vk_renderer->models_to_draw[current_frame]) + for(auto& [static_mesh, instances]: + cg_core.vk_renderer->static_models_to_draw[current_frame]) { - std::array<VkDescriptorSet, 3> vk_descriptor_sets{ - this->descriptor_sets_world[image_index], - view->descriptor_sets_3d[image_index], - model->descriptor_sets[image_index]}; - VkBuffer vertex_buffers[]{model->mesh->vertex_buffer->buffer}; + VkBuffer vertex_buffers[]{static_mesh->vertex_buffer->buffer}; VkDeviceSize offsets[]{0}; - vkCmdBindDescriptorSets( - draw_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, - cg_core.vk_graphics_pipeline_3d_layout->pipeline, 0, - vk_descriptor_sets.size(), vk_descriptor_sets.data(), 0, nullptr); vkCmdBindPipeline( draw_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, this->graphic_pipeline); vkCmdBindVertexBuffers( draw_command_buffer, 0, 1, vertex_buffers, offsets); vkCmdBindIndexBuffer( - draw_command_buffer, model->mesh->index_buffer->buffer, 0, + draw_command_buffer, static_mesh->index_buffer->buffer, 0, VK_INDEX_TYPE_UINT32); for(auto &instance: instances) { // Object matrix. - glm::mat4 instance_matrix{1.0f}; - instance_matrix = glm::translate( - instance_matrix, instance.position); - instance_matrix = glm::rotate( - instance_matrix, instance.rotation.x, glm::vec3{1.0, 0.0, 0.0}); - instance_matrix = glm::rotate( - instance_matrix, instance.rotation.y, glm::vec3{0.0, 1.0, 0.0}); - instance_matrix = glm::rotate( - instance_matrix, instance.rotation.z, glm::vec3{0.0, 0.0, 1.0}); - - ODOModelInstance model_instance{instance_matrix}; - vkCmdPushConstants( - draw_command_buffer, - cg_core.vk_graphics_pipeline_3d_layout->pipeline, - VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(ODOModelInstance), - &model_instance); + glm::mat4 base_matrix{1.0f}; + base_matrix = glm::translate(base_matrix, *instance->position); + base_matrix = glm::rotate( + base_matrix, instance->rotation->x, glm::vec3{1.0, 0.0, 0.0}); + base_matrix = glm::rotate( + base_matrix, instance->rotation->y, glm::vec3{0.0, 1.0, 0.0}); + base_matrix = glm::rotate( + base_matrix, instance->rotation->z, glm::vec3{0.0, 0.0, 1.0}); + + std::array<VkDescriptorSet, 3> vk_descriptor_sets{ + this->descriptor_sets_world[image_index], + view->descriptor_sets_3d[image_index], + instance->descriptor_sets[image_index]}; + + vkCmdBindDescriptorSets( + draw_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, + cg_core.vk_graphics_pipeline_3d_layout->pipeline, 0, + vk_descriptor_sets.size(), vk_descriptor_sets.data(), 0, nullptr); + vkCmdDrawIndexed( - draw_command_buffer, model->mesh->index_count, 1, 0, 0, 0); + draw_command_buffer, static_mesh->index_count, 1, 0, 0, 0); + + VK::ODOStaticModel odo_static_model{}; + odo_static_model.base_matrix = base_matrix; + instance->uniform_buffers[image_index].copy_data(&odo_static_model); } } @@ -627,6 +626,7 @@ GraphicsPipeline3D::draw( view->ub_3d[image_index].copy_data(&ubo_view_3d); } + // TODO: Do not update this for each view. All views use the same data. { // Update world uniform buffer ODOWorld3D_Vert ubo_world_3d_vert{}; ubo_world_3d_vert.ambient_light_color = glm::vec4{0.25, 0.25, 0.25, 1.0}; diff --git a/src/vk/graphics_pipeline_3d.hpp b/src/vk/graphics_pipeline_3d.hpp index 925df77..d174b6e 100644 --- a/src/vk/graphics_pipeline_3d.hpp +++ b/src/vk/graphics_pipeline_3d.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -23,8 +23,6 @@ #include "../command.hpp" #include "core.hpp" #include "command_pool.hpp" -#include "model.hpp" -#include "model_instance.hpp" #include "uniform_buffer.hpp" #include "view_3d.hpp" diff --git a/src/vk/graphics_pipeline_3d_layout.cpp b/src/vk/graphics_pipeline_3d_layout.cpp index db5d210..cbb73e5 100644 --- a/src/vk/graphics_pipeline_3d_layout.cpp +++ b/src/vk/graphics_pipeline_3d_layout.cpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -103,18 +103,64 @@ unload_descriptor_set_view(void *obj) } void -load_descriptor_set_model_instance(void *obj) +load_descriptor_set_skeletal_model(void *obj) { auto self = static_cast<VK::GraphicsPipeline3DLayout*>(obj); - std::array<VkDescriptorSetLayoutBinding, 1> layout_bindings{}; - + std::array<VkDescriptorSetLayoutBinding, 2> layout_bindings; layout_bindings[0].binding = 0; - layout_bindings[0].descriptorType = + 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_skeletal_model) != VK_SUCCESS) + throw CommandError{ + "Failed to create Vulkan descriptor set layout for model instance."}; +} + +void +unload_descriptor_set_skeletal_model(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DLayout*>(obj); + + vkDestroyDescriptorSetLayout( + cg_core.vk_device_with_swapchain->device, + self->descriptor_set_skeletal_model, nullptr); +} + +void +load_descriptor_set_static_model(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DLayout*>(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_FRAGMENT_BIT; + 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; @@ -125,19 +171,19 @@ load_descriptor_set_model_instance(void *obj) if(vkCreateDescriptorSetLayout( cg_core.vk_device_with_swapchain->device, &layout_info, nullptr, - &self->descriptor_set_model_instance) != VK_SUCCESS) + &self->descriptor_set_static_model) != VK_SUCCESS) throw CommandError{ "Failed to create Vulkan descriptor set layout for model instance."}; } void -unload_descriptor_set_model_instance(void *obj) +unload_descriptor_set_static_model(void *obj) { auto self = static_cast<VK::GraphicsPipeline3DLayout*>(obj); vkDestroyDescriptorSetLayout( cg_core.vk_device_with_swapchain->device, - self->descriptor_set_model_instance, nullptr); + self->descriptor_set_static_model, nullptr); } void @@ -148,19 +194,14 @@ load_pipeline(void *obj) std::array<VkDescriptorSetLayout, 3> set_layouts{ self->descriptor_set_world, self->descriptor_set_view, - self->descriptor_set_model_instance}; - - std::array<VkPushConstantRange, 1> push_constants; - push_constants[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; - push_constants[0].offset = 0; - push_constants[0].size = sizeof(VK::ODOModelInstance); + self->descriptor_set_skeletal_model}; 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 = push_constants.size(); - pipeline_layout_info.pPushConstantRanges = push_constants.data(); + pipeline_layout_info.pushConstantRangeCount = 0; + pipeline_layout_info.pPushConstantRanges = nullptr; if(vkCreatePipelineLayout( cg_core.vk_device_with_swapchain->device, @@ -266,7 +307,8 @@ unload_render_pass(void *obj) const CommandChain loader{ {&load_descriptor_set_world, &unload_descriptor_set_world}, {&load_descriptor_set_view, &unload_descriptor_set_view}, - {&load_descriptor_set_model_instance, &unload_descriptor_set_model_instance}, + {&load_descriptor_set_skeletal_model, &unload_descriptor_set_skeletal_model}, + {&load_descriptor_set_static_model, &unload_descriptor_set_static_model}, {&load_pipeline, &unload_pipeline}, {&load_render_pass, &unload_render_pass} }; diff --git a/src/vk/graphics_pipeline_3d_layout.hpp b/src/vk/graphics_pipeline_3d_layout.hpp index 10c8bd9..cb89b95 100644 --- a/src/vk/graphics_pipeline_3d_layout.hpp +++ b/src/vk/graphics_pipeline_3d_layout.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -26,7 +26,8 @@ struct GraphicsPipeline3DLayout { VkDescriptorSetLayout descriptor_set_world; VkDescriptorSetLayout descriptor_set_view; - VkDescriptorSetLayout descriptor_set_model_instance; + VkDescriptorSetLayout descriptor_set_skeletal_model; + VkDescriptorSetLayout descriptor_set_static_model; VkPipelineLayout pipeline; VkRenderPass render_pass; diff --git a/src/vk/graphics_pipeline_3d_skeletal.cpp b/src/vk/graphics_pipeline_3d_skeletal.cpp new file mode 100644 index 0000000..3e1db66 --- /dev/null +++ b/src/vk/graphics_pipeline_3d_skeletal.cpp @@ -0,0 +1,657 @@ +/* + * Copyright 2022-2023 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_3d.hpp" + +#include <array> +#include <stdexcept> + +#include "../core.hpp" +#include "core.hpp" +#include "image.hpp" +#include "skeletal_mesh_vertex.hpp" +#include "uniform_data_object.hpp" + +namespace +{ + +void +load_world_vert_uniform_buffer(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + try + { + self->ub_world_vert.reserve(cg_core.vk_swapchain->images_count); + for(auto i{0}; i < cg_core.vk_swapchain->images_count; i++) + self->ub_world_vert.emplace_back( + cg_core.vk_device_with_swapchain, sizeof(VK::ODOWorld3D_Vert)); + } + catch(const std::exception& e) + { + throw CommandError{e.what()}; + } +} + +void +unload_world_vert_uniform_buffer(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + self->ub_world_vert.clear(); +} + +void +load_world_frag_uniform_buffer(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + try + { + self->ub_world_frag.reserve(cg_core.vk_swapchain->images_count); + for(auto i{0}; i < cg_core.vk_swapchain->images_count; i++) + self->ub_world_frag.emplace_back( + cg_core.vk_device_with_swapchain, sizeof(VK::ODOWorld3D_Frag)); + } + catch(const std::exception& e) + { + throw CommandError{e.what()}; + } +} + +void +unload_world_frag_uniform_buffer(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + self->ub_world_frag.clear(); +} + +void +load_descriptor_pool(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + uint32_t uniform_buffers_count = + self->ub_world_vert.size() + self->ub_world_vert.size(); + + VkDescriptorPoolSize descriptor_pool_size{}; + descriptor_pool_size.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + descriptor_pool_size.descriptorCount = uniform_buffers_count; + + VkDescriptorPoolCreateInfo pool_info{}; + pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + pool_info.pNext = nullptr; + pool_info.flags = 0; + pool_info.maxSets = uniform_buffers_count; + pool_info.poolSizeCount = 1; + pool_info.pPoolSizes = &descriptor_pool_size; + + if(vkCreateDescriptorPool( + cg_core.vk_device_with_swapchain->device, &pool_info, nullptr, + &self->descriptor_pool) != VK_SUCCESS) + throw CommandError{"Failed to create a Vulkan descriptor pool."}; +} + +void +unload_descriptor_pool(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + vkDestroyDescriptorPool( + cg_core.vk_device_with_swapchain->device, self->descriptor_pool, + nullptr); +} + +void +load_descriptor_sets_world(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + std::vector<VkDescriptorSetLayout> layouts( + cg_core.vk_swapchain->images_count, + cg_core.vk_graphics_pipeline_3d_layout->descriptor_set_world); + + VkDescriptorSetAllocateInfo alloc_info{}; + alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + alloc_info.descriptorPool = self->descriptor_pool; + alloc_info.descriptorSetCount = layouts.size(); + alloc_info.pSetLayouts = layouts.data(); + + self->descriptor_sets_world.resize(layouts.size()); + if(vkAllocateDescriptorSets( + cg_core.vk_device_with_swapchain->device, &alloc_info, + self->descriptor_sets_world.data()) != VK_SUCCESS) + throw CommandError{"Failed to create Vulkan world descriptor set."}; +} + +void +load_resources_to_descriptor_sets(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + for(auto i{0}; i < cg_core.vk_swapchain->images_count; i++) + { + VkDescriptorBufferInfo world_vert_info{}; + world_vert_info.buffer = self->ub_world_vert[i].buffer; + world_vert_info.offset = 0; + world_vert_info.range = sizeof(VK::ODOWorld3D_Vert); + + VkDescriptorBufferInfo world_frag_info{}; + world_frag_info.buffer = self->ub_world_frag[i].buffer; + world_frag_info.offset = 0; + world_frag_info.range = sizeof(VK::ODOWorld3D_Frag); + + std::array<VkWriteDescriptorSet, 2> write_descriptors{}; + write_descriptors[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + write_descriptors[0].dstSet = self->descriptor_sets_world[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 = &world_vert_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->descriptor_sets_world[i]; + write_descriptors[1].dstBinding = 1; + write_descriptors[1].dstArrayElement = 0; + write_descriptors[1].descriptorCount = 1; + write_descriptors[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + write_descriptors[1].pBufferInfo = &world_frag_info; + write_descriptors[1].pImageInfo = nullptr; + write_descriptors[1].pTexelBufferView = nullptr; + + vkUpdateDescriptorSets( + cg_core.vk_device_with_swapchain->device, write_descriptors.size(), + write_descriptors.data(), 0, nullptr); + } +} + +void +load_depth_image(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + VkExtent3D extent3d{}; + extent3d.width = cg_core.display_width; + extent3d.height = cg_core.display_height; + extent3d.depth = 1; + + try + { + VK::Image::create( + cg_core.vk_device_with_swapchain, + &self->depth_image, + &self->depth_image_memory, + VK_FORMAT_D32_SFLOAT, + extent3d, + 1, + VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT + ); + } + catch(VK::Image::Error error) + { + std::string error_message{"Failed to create depth image → "}; + error_message += error.what(); + throw CommandError{error_message}; + } +} + +void +unload_depth_image(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + vkDestroyImage( + cg_core.vk_device_with_swapchain->device, self->depth_image, + nullptr); + vkFreeMemory( + cg_core.vk_device_with_swapchain->device, + self->depth_image_memory, nullptr); +} + +void +load_depth_image_view(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + try + { + VK::Image::create_view( + cg_core.vk_device_with_swapchain, &self->depth_image_view, + self->depth_image, + VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT); + } + catch(VK::Image::Error error) + { + std::string error_message{"Failed to create depth image view → "}; + error_message += error.what(); + throw CommandError{error_message}; + } +} + +void +unload_depth_image_view(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(obj); + + vkDestroyImageView( + cg_core.vk_device_with_swapchain->device, self->depth_image_view, nullptr); +} + +void +load_framebuffer(void *obj) +{ + auto self = static_cast<VK::GraphicsPipeline3DSkeletal*>(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, 2> attachments = { + cg_core.vk_swapchain->image_views[i], + self->depth_image_view + }; + + VkFramebufferCreateInfo framebuffer_info{}; + framebuffer_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + framebuffer_info.renderPass = + cg_core.vk_graphics_pipeline_3d_layout->render_pass; + framebuffer_info.attachmentCount = attachments.size(); + framebuffer_info.pAttachments = attachments.data(); + framebuffer_info.width = cg_core.display_width; + framebuffer_info.height = cg_core.display_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::GraphicsPipeline3DSkeletal*>(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::GraphicsPipeline3DSkeletal*>(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->vert3d_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->frag3d_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(VK::SkeletalMeshVertex); + vertex_input_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + + std::array<VkVertexInputAttributeDescription, 5> vertex_attribute{}; + // Position. + vertex_attribute[0].location = 0; + vertex_attribute[0].binding = 0; + vertex_attribute[0].format = VK_FORMAT_R32G32B32_SFLOAT; + vertex_attribute[0].offset = offsetof(VK::SkeletalMeshVertex, 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::SkeletalMeshVertex, 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::SkeletalMeshVertex, texture_coord); + // Bones ids. + vertex_attribute[3].location = 3; + vertex_attribute[3].binding = 0; + vertex_attribute[3].format = VK_FORMAT_R32G32B32A32_SINT; + vertex_attribute[3].offset = offsetof(VK::SkeletalMeshVertex, bone_ids); + // Bones weights. + vertex_attribute[4].location = 4; + vertex_attribute[4].binding = 0; + vertex_attribute[4].format = VK_FORMAT_R32G32B32A32_SFLOAT; + vertex_attribute[4].offset = offsetof(VK::SkeletalMeshVertex, bone_weights); + + 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_LIST; + input_assembly.primitiveRestartEnable = VK_FALSE; + + VkViewport viewport = {}; + viewport.x = 0; + viewport.y = 0; + viewport.width = cg_core.display_width; + viewport.height = cg_core.display_height; + viewport.minDepth = 0.0f; + viewport.maxDepth = 1.0f; + + VkRect2D scissor = {}; + scissor.offset = {0, 0}; + scissor.extent = {cg_core.display_width, cg_core.display_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; + + VkPipelineDepthStencilStateCreateInfo depth_stencil = {}; + depth_stencil.sType = + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil.depthTestEnable = VK_TRUE; + depth_stencil.depthWriteEnable = VK_TRUE; + depth_stencil.depthCompareOp = VK_COMPARE_OP_LESS; + depth_stencil.depthBoundsTestEnable = VK_FALSE; + depth_stencil.minDepthBounds = 0.0f; + depth_stencil.maxDepthBounds = 1.0f; + depth_stencil.stencilTestEnable = VK_FALSE; + depth_stencil.front = {}; + depth_stencil.back = {}; + + 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 = &depth_stencil; + pipeline_info.pColorBlendState = &color_blending; + pipeline_info.pDynamicState = &dynamic_state_info; + pipeline_info.layout = cg_core.vk_graphics_pipeline_3d_layout->pipeline; + pipeline_info.renderPass = + cg_core.vk_graphics_pipeline_3d_layout->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::GraphicsPipeline3DSkeletal*>(obj); + + vkDestroyPipeline( + cg_core.vk_device_with_swapchain->device, self->graphic_pipeline, nullptr); +} + +const CommandChain loader{ + {&load_world_vert_uniform_buffer, &unload_world_vert_uniform_buffer}, + {&load_world_frag_uniform_buffer, &unload_world_frag_uniform_buffer}, + {&load_descriptor_pool, &unload_descriptor_pool}, + // By destroying the pool the sets are also destroyed. + {&load_descriptor_sets_world, nullptr}, + {&load_resources_to_descriptor_sets, nullptr}, + {&load_depth_image, &unload_depth_image}, + {&load_depth_image_view, &unload_depth_image_view}, + {&load_framebuffer, &unload_framebuffer}, + {&load_pipeline, &unload_pipeline} +}; + +} + +namespace VK +{ + +GraphicsPipeline3DSkeletal::GraphicsPipeline3DSkeletal() +{ + loader.execute(this); +} + +GraphicsPipeline3DSkeletal::~GraphicsPipeline3DSkeletal() +{ + loader.revert(this); +} + +void +GraphicsPipeline3DSkeletal::draw( + std::shared_ptr<View3D> view, const VkCommandBuffer draw_command_buffer, + const size_t current_frame, const uint32_t image_index) +{ + { // Set viewport + VkViewport vk_viewport{}; + vk_viewport.x = view->region.x; + vk_viewport.y = view->region.y; + vk_viewport.width = view->region.z; + vk_viewport.height = view->region.w; + vk_viewport.minDepth = 0.0f; + vk_viewport.maxDepth = 1.0f; + vkCmdSetViewport(draw_command_buffer, 0, 1, &vk_viewport); + + VkRect2D vk_scissor{}; + vk_scissor.offset.x = static_cast<int32_t>(view->region.x); + vk_scissor.offset.y = static_cast<int32_t>(view->region.y); + vk_scissor.extent.width = static_cast<uint32_t>(view->region.z); + vk_scissor.extent.height = static_cast<uint32_t>(view->region.w); + vkCmdSetScissor(draw_command_buffer, 0, 1, &vk_scissor); + } + + // Draw models + for(auto& [skeletal_mesh, instances]: + cg_core.vk_renderer->skeletal_models_to_draw[current_frame]) + { + VkBuffer vertex_buffers[]{skeletal_mesh->vertex_buffer->buffer}; + VkDeviceSize offsets[]{0}; + + vkCmdBindPipeline( + draw_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, + this->graphic_pipeline); + vkCmdBindVertexBuffers( + draw_command_buffer, 0, 1, vertex_buffers, offsets); + vkCmdBindIndexBuffer( + draw_command_buffer, skeletal_mesh->index_buffer->buffer, 0, + VK_INDEX_TYPE_UINT32); + + for(auto &instance: instances) + { // Object matrix. + glm::mat4 base_matrix{1.0f}; + base_matrix = glm::translate(base_matrix, *instance->position); + base_matrix = glm::rotate( + base_matrix, instance->rotation->x, glm::vec3{1.0, 0.0, 0.0}); + base_matrix = glm::rotate( + base_matrix, instance->rotation->y, glm::vec3{0.0, 1.0, 0.0}); + base_matrix = glm::rotate( + base_matrix, instance->rotation->z, glm::vec3{0.0, 0.0, 1.0}); + + std::array<VkDescriptorSet, 3> vk_descriptor_sets{ + this->descriptor_sets_world[image_index], + view->descriptor_sets_3d[image_index], + instance->descriptor_sets[image_index]}; + + vkCmdBindDescriptorSets( + draw_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, + cg_core.vk_graphics_pipeline_3d_layout->pipeline, 0, + vk_descriptor_sets.size(), vk_descriptor_sets.data(), 0, nullptr); + + vkCmdDrawIndexed( + draw_command_buffer, skeletal_mesh->index_count, 1, 0, 0, 0); + + VK::ODOSkeletalModel odo_skeletal_model{}; + instance->tick(cg_core.delta_time); + odo_skeletal_model.base_matrix = base_matrix; + std::copy(instance->bone_transforms.begin(), + instance->bone_transforms.end(), + odo_skeletal_model.bone_matrices); + instance->uniform_buffers[image_index].copy_data(&odo_skeletal_model); + } + } + + { // Update view uniform buffers + VK::ODOView3D ubo_view_3d{}; + + // View matrix. + ubo_view_3d.view = glm::mat4{1.0f}; + ubo_view_3d.view = glm::translate( + ubo_view_3d.view, *view->camera_position); + ubo_view_3d.view = glm::rotate( + ubo_view_3d.view, view->camera_rotation->y, glm::vec3{0.0, 1.0, 0.0}); + ubo_view_3d.view = glm::rotate( + ubo_view_3d.view, view->camera_rotation->x, glm::vec3{1.0, 0.0, 0.0}); + ubo_view_3d.view = glm::rotate( + ubo_view_3d.view, view->camera_rotation->z, glm::vec3{0.0, 0.0, 1.0}); + ubo_view_3d.view = glm::inverse(ubo_view_3d.view); + + // Projection matrix. + ubo_view_3d.proj = glm::perspective( + glm::radians(45.0f), + view->region.z / view->region.w, + 0.1f, 100.0f); + + view->ub_3d[image_index].copy_data(&ubo_view_3d); + } + + // TODO: Do not update this for each view. All views use the same data. + { // Update world uniform buffer + ODOWorld3D_Vert ubo_world_3d_vert{}; + ubo_world_3d_vert.ambient_light_color = glm::vec4{0.25, 0.25, 0.25, 1.0}; + this->ub_world_vert[image_index].copy_data(&ubo_world_3d_vert); + + ODOWorld3D_Frag ubo_world_3d_frag{}; + ubo_world_3d_frag.directional_light_direction = + glm::vec3{-0.57735, 0.57735, -0.57735}; + ubo_world_3d_frag.directional_light_color = glm::vec4{0.8, 0.8, 0.8, 1.0}; + this->ub_world_frag[image_index].copy_data(&ubo_world_3d_frag); + } +} + +} diff --git a/src/vk/graphics_pipeline_3d_skeletal.hpp b/src/vk/graphics_pipeline_3d_skeletal.hpp new file mode 100644 index 0000000..9563e14 --- /dev/null +++ b/src/vk/graphics_pipeline_3d_skeletal.hpp @@ -0,0 +1,60 @@ +/* + * Copyright 2022-2023 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_3D_SKELETAL_H +#define CANDY_GEAR_VK_GRAPHICS_PIPELINE_3D_SKELETAL_H 1 + +#include <memory> +#include <unordered_map> + +#include "../command.hpp" +#include "core.hpp" +#include "command_pool.hpp" +#include "skeletal_model.hpp" +#include "uniform_buffer.hpp" +#include "view_3d.hpp" + +namespace VK +{ + +struct GraphicsPipeline3DSkeletal +{ + // Depth image. + VkImage depth_image; + VkDeviceMemory depth_image_memory; + VkImageView depth_image_view; + + // FIXME: if this vector get resized, it will cause a segmentation fault! + std::vector<UniformBuffer> ub_world_vert; + std::vector<UniformBuffer> ub_world_frag; + + VkDescriptorPool descriptor_pool; + std::vector<VkDescriptorSet> descriptor_sets_world; + + std::vector<VkFramebuffer> swapchain_framebuffers; + VkPipeline graphic_pipeline; + + GraphicsPipeline3DSkeletal(); + ~GraphicsPipeline3DSkeletal(); + + void + draw(std::shared_ptr<View3D> view, const VkCommandBuffer draw_command_buffer, + const size_t current_frame, const uint32_t image_index); +}; + +} + +#endif /* CANDY_GEAR_VK_GRAPHICS_PIPELINE_SKELETAL_3D_H */ diff --git a/src/vk/renderer.cpp b/src/vk/renderer.cpp index a7e5f35..b240cb9 100644 --- a/src/vk/renderer.cpp +++ b/src/vk/renderer.cpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -143,7 +143,8 @@ namespace VK Renderer::Renderer(std::vector<std::shared_ptr<View2D>> views_2d, std::vector<std::shared_ptr<View3D>> views_3d): - models_to_draw{cg_core.vk_swapchain->images_count}, + skeletal_models_to_draw{cg_core.vk_swapchain->images_count}, + static_models_to_draw{cg_core.vk_swapchain->images_count}, views_2d{views_2d}, views_3d{views_3d} { @@ -347,14 +348,15 @@ Renderer::draw() // Prepare for the next frame. { - this->models_to_draw[next_frame].clear(); + this->skeletal_models_to_draw[next_frame].clear(); + this->static_models_to_draw[next_frame].clear(); cg_core.vk_swapchain->current_frame = next_frame; } } else { // Clear images for the current frame because we are skipping this frame. - this->models_to_draw[cg_core.vk_swapchain->current_frame].clear(); + this->skeletal_models_to_draw[cg_core.vk_swapchain->current_frame].clear(); for(auto &view: this->views_2d) view->sprites_to_draw[cg_core.vk_swapchain->current_frame].clear(); for(auto &view: this->views_3d) diff --git a/src/vk/renderer.hpp b/src/vk/renderer.hpp index 551e4e5..7c7d111 100644 --- a/src/vk/renderer.hpp +++ b/src/vk/renderer.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -22,8 +22,10 @@ #include <vector> #include "core.hpp" -#include "model.hpp" -#include "model_instance.hpp" +#include "skeletal_mesh.hpp" +#include "skeletal_model.hpp" +#include "static_mesh.hpp" +#include "static_model.hpp" #include "queue_family.hpp" #include "view_2d.hpp" #include "view_3d.hpp" @@ -33,9 +35,17 @@ namespace VK struct Renderer { - std::vector<std::unordered_map< - std::shared_ptr<Model>, std::vector<ModelInstance>>> - models_to_draw; + std::vector< + std::unordered_map< + std::shared_ptr<SkeletalMesh>, + std::vector<std::shared_ptr<SkeletalModel>>>> + skeletal_models_to_draw; + + std::vector< + std::unordered_map< + std::shared_ptr<StaticMesh>, + std::vector<std::shared_ptr<StaticModel>>>> + static_models_to_draw; VkDescriptorPool descriptor_pool; std::vector<std::shared_ptr<View2D>> views_2d; diff --git a/src/vk/skeletal_mesh.cpp b/src/vk/skeletal_mesh.cpp new file mode 100644 index 0000000..b65d27d --- /dev/null +++ b/src/vk/skeletal_mesh.cpp @@ -0,0 +1,204 @@ +/* + * Copyright 2022-2023 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 "skeletal_mesh.hpp" + +#include "../binary_reader.hpp" +#include "../command.hpp" +#include "../core.hpp" +#include "skeletal_mesh_vertex.hpp" + +namespace +{ + +// Data that is only needed for the command chain but not for the SkeletalMesh +// goes here. +struct MeshBuilder +{ + std::string mesh_path; + VK::SkeletalMesh *mesh; + + MeshBuilder(VK::SkeletalMesh *m, std::string mp); + MeshBuilder(VK::SkeletalMesh *m, const char* mp); +}; + +MeshBuilder::MeshBuilder(VK::SkeletalMesh *m, std::string mp): + mesh{m}, + mesh_path{mp} +{ +} + +MeshBuilder::MeshBuilder(VK::SkeletalMesh *m, const char *mp): + MeshBuilder{m, std::string(mp)} +{ +} + +void +load_mesh(void *obj) +{ + auto self = static_cast<MeshBuilder*>(obj); + + BinaryReader input{self->mesh_path}; + + self->mesh->queue_family = + cg_core.vk_device_with_swapchain->get_queue_family_with_graphics(); + + { // Load vertexes. + auto vertex_count{input.read_ui32()}; + std::vector<VK::SkeletalMeshVertex> vertexes{vertex_count}; + + for(auto i{0}; i < vertex_count; i++) + { + vertexes[i].position = input.read_vec3(); + vertexes[i].normal = input.read_vec3(); + vertexes[i].texture_coord = input.read_vec2(); + + for(auto ii{0}; ii < VK::SKELETAL_MESH_MAX_NUM_OF_INFLUENCING_BONES; + ii++) + vertexes[i].bone_ids[ii] = input.read_ui32(); + + for(auto ii{0}; ii < VK::SKELETAL_MESH_MAX_NUM_OF_INFLUENCING_BONES; + ii++) + vertexes[i].bone_weights[ii] = input.read_float(); + } + + 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 = input.read_ui32(); + std::vector<uint32_t> indexes(self->mesh->index_count); + + for(auto i{0}; i < self->mesh->index_count; i++) + indexes[i] = input.read_ui32(); + + 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}; + } + + { // Load bones + auto bone_count{input.read_ui32()}; + self->mesh->bones.reserve(bone_count); + for(int i{0}; i < bone_count; i++) + self->mesh->bones.emplace_back(input.read_mat4()); + } + + { // Load animations + auto num_animations{input.read_ui32()}; + self->mesh->animations.resize(num_animations); + for(uint32_t i{0}; i < num_animations; i++) + { + auto duration{input.read_double()}; + self->mesh->animations[i].final_time = (float)duration; + + auto ticks_per_second{input.read_double()}; + + auto num_bone_transforms{input.read_ui32()}; + std::vector<VK::BoneTransform> *bone_transforms = + &(self->mesh->animations[i].bone_transforms); + bone_transforms->resize(num_bone_transforms); + for(uint32_t bone_transform_index{0}; + bone_transform_index < num_bone_transforms; bone_transform_index++) + { + auto bone_id{input.read_ui32()}; + + auto num_positions{input.read_ui32()}; + VK::Channel<glm::vec3> *positions = + &((*bone_transforms)[bone_transform_index].positions); + for(auto position_key_index{0}; position_key_index < num_positions; + position_key_index++) + { + auto vec3{input.read_vec3()}; + auto timestamp{input.read_double()}; + positions->key_frames.emplace_back( + vec3, static_cast<float>(timestamp)); + } + + auto num_rotations{input.read_ui32()}; + VK::Channel<glm::quat> *rotations = + &((*bone_transforms)[bone_transform_index].rotations); + for(auto rotation_key_index{0}; rotation_key_index < num_rotations; + rotation_key_index++) + { + auto quat{input.read_quat()}; + auto timestamp{input.read_double()}; + rotations->key_frames.emplace_back( + quat, static_cast<float>(timestamp)); + } + + auto num_scales{input.read_ui32()}; + VK::Channel<glm::vec3> *scales = + &((*bone_transforms)[bone_transform_index].scales); + for(auto scaling_key_index{0}; scaling_key_index < num_scales; + scaling_key_index++) + { + auto vec3{input.read_vec3()}; + auto timestamp{input.read_double()}; + scales->key_frames.emplace_back(vec3, static_cast<float>(timestamp)); + } + } + } + } +} + +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 +{ + +SkeletalMesh::SkeletalMesh(std::string mesh_path) +{ + MeshBuilder mesh_builder(this, mesh_path); + loader.execute(&mesh_builder); +} + +SkeletalMesh::SkeletalMesh(const char* mesh_path): + SkeletalMesh{std::string(mesh_path)} +{ +} + +SkeletalMesh::~SkeletalMesh() +{ + MeshBuilder mesh_builder(this, ""); + loader.revert(&mesh_builder); +} + +} diff --git a/src/vk/skeletal_mesh.hpp b/src/vk/skeletal_mesh.hpp new file mode 100644 index 0000000..7fc8334 --- /dev/null +++ b/src/vk/skeletal_mesh.hpp @@ -0,0 +1,52 @@ +/* + * Copyright 2022-2023 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_SKELETAL_MESH_H +#define CANDY_GEAR_VK_SKELETAL_MESH_H 1 + +#include <string> +#include <vector> + +#include "animation.hpp" +#include "core.hpp" +#include "destination_buffer.hpp" +#include "queue_family.hpp" +#include "uniform_buffer.hpp" +#include "texture.hpp" + +namespace VK +{ + +struct SkeletalMesh +{ + QueueFamily *queue_family; + + uint32_t index_count; + SourceBuffer *source_vertex_buffer; + DestinationBuffer *index_buffer; + DestinationBuffer *vertex_buffer; + + std::vector<Bone> bones; + std::vector<Animation> animations; + + SkeletalMesh(std::string mesh_path); + SkeletalMesh(const char* mesh_path); + ~SkeletalMesh(); +}; + +} + +#endif /* CANDY_GEAR_VK_SKELETAL_MESH_H */ diff --git a/src/vk/skeletal_mesh_vertex.hpp b/src/vk/skeletal_mesh_vertex.hpp new file mode 100644 index 0000000..b5bba3d --- /dev/null +++ b/src/vk/skeletal_mesh_vertex.hpp @@ -0,0 +1,42 @@ +/* + * Copyright 2022-2023 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_SKELETAL_MESH_VERTEX_H +#define CANDY_GEAR_VK_SKELETAL_MESH_VERTEX_H 1 + +#include "core.hpp" + +namespace VK +{ + +// This variable define the maximum ammount of bones that can influence a +// vertex. +const int SKELETAL_MESH_MAX_NUM_OF_INFLUENCING_BONES{4}; +const int SKELETAL_MESH_MAX_NUM_OF_BONES{50}; + +struct SkeletalMeshVertex +{ + glm::vec3 position; + glm::vec3 normal; + glm::vec2 texture_coord; + + uint32_t bone_ids[SKELETAL_MESH_MAX_NUM_OF_INFLUENCING_BONES]; + float bone_weights[SKELETAL_MESH_MAX_NUM_OF_INFLUENCING_BONES]; +}; + +} + +#endif /* CANDY_GEAR_VK_SKELETAL_MESH_VERTEX_H */ diff --git a/src/vk/skeletal_model.cpp b/src/vk/skeletal_model.cpp new file mode 100644 index 0000000..8528535 --- /dev/null +++ b/src/vk/skeletal_model.cpp @@ -0,0 +1,256 @@ +/* + * Copyright 2022-2023 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 "skeletal_model.hpp" + +#include "../core.hpp" +#include "uniform_data_object.hpp" + +namespace +{ + +void +load_uniform_buffers(void *obj) +{ + auto self = static_cast<VK::SkeletalModel*>(obj); + + try + { + self->uniform_buffers.reserve(cg_core.vk_swapchain->images_count); + for(auto i{0}; i < cg_core.vk_swapchain->images_count; i++) + self->uniform_buffers.emplace_back( + cg_core.vk_device_with_swapchain, sizeof(VK::ODOSkeletalModel)); + } + catch(const std::exception& e) + { + throw CommandError{e.what()}; + } +} + +void +unload_uniform_buffers(void *obj) +{ + auto self = static_cast<VK::SkeletalModel*>(obj); + + self->uniform_buffers.clear(); +} + +void +load_descriptor_set_pool(void *obj) +{ + auto self = static_cast<VK::SkeletalModel*>(obj); + + std::array<VkDescriptorPoolSize, 2> descriptor_pool_sizes{}; + descriptor_pool_sizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + descriptor_pool_sizes[0].descriptorCount = + self->uniform_buffers.size(); + descriptor_pool_sizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + descriptor_pool_sizes[1].descriptorCount = + cg_core.vk_swapchain->images_count; + + 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->uniform_buffers.size(); + pool_info.poolSizeCount = descriptor_pool_sizes.size(); + pool_info.pPoolSizes = descriptor_pool_sizes.data(); + + if(vkCreateDescriptorPool( + self->skeletal_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<VK::SkeletalModel*>(obj); + + vkDestroyDescriptorPool( + self->skeletal_mesh->queue_family->device->device, self->descriptor_pool, + nullptr); +} + +void +load_descriptor_sets(void *obj) +{ + auto self = static_cast<VK::SkeletalModel*>(obj); + + std::vector<VkDescriptorSetLayout> layouts( + cg_core.vk_swapchain->images_count, + cg_core.vk_graphics_pipeline_3d_layout->descriptor_set_skeletal_model); + + VkDescriptorSetAllocateInfo alloc_info{}; + alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + alloc_info.descriptorPool = self->descriptor_pool; + alloc_info.descriptorSetCount = layouts.size(); + alloc_info.pSetLayouts = layouts.data(); + + self->descriptor_sets.resize(layouts.size()); + if(vkAllocateDescriptorSets( + self->skeletal_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<VK::SkeletalModel*>(obj); + + for(auto i{0}; i < self->uniform_buffers.size(); i++) + { + VkDescriptorBufferInfo buffer_info{}; + buffer_info.buffer = self->uniform_buffers[i].buffer; + buffer_info.offset = 0; + buffer_info.range = sizeof(VK::ODOSkeletalModel); + + VkDescriptorImageInfo image_info{}; + image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + 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->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->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_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 +{ + +SkeletalModel::SkeletalModel( + std::shared_ptr<SkeletalMesh> skeletal_mesh, + std::shared_ptr<Texture> texture, std::shared_ptr<glm::vec3> position, + std::shared_ptr<glm::vec3> rotation): + skeletal_mesh{skeletal_mesh}, + texture{texture}, + position{position}, + rotation{rotation}, + animation_index{0}, + animation_time{0.0f}, + bone_transforms(SKELETAL_MESH_MAX_NUM_OF_BONES) +{ + loader.execute(this); + + for(int i{0}; i < skeletal_mesh->bones.size(); i++) + this->bone_transforms[i] = skeletal_mesh->bones[i].offset_matrix; +} + +SkeletalModel::~SkeletalModel() +{ + loader.revert(this); +} + +void +SkeletalModel::tick(float delta) +{ + VK::Animation *current_animation = + &this->skeletal_mesh->animations[this->animation_index]; + + { // update time + this->animation_time += delta; + if(this->animation_time > current_animation->final_time) + { + this->animation_time -= current_animation->final_time; + for(VK::BoneTransform &bone_transform: + current_animation->bone_transforms) + { + bone_transform.positions.current_index = 0; + bone_transform.rotations.current_index = 0; + bone_transform.scales.current_index = 0; + } + } + } + + for(int i{0}; i < current_animation->bone_transforms.size(); i++) + { + VK::BoneTransform *bone_transform = ¤t_animation->bone_transforms[i]; + + auto position{bone_transform->positions.interpolate( + this->animation_time, + [](glm::vec3 frame) + { + return glm::translate(glm::mat4(1.0f), frame); + }, + [](glm::vec3 previous_frame, glm::vec3 next_frame, float scale_factor) + { + glm::vec3 final_position{glm::mix( + previous_frame, next_frame, scale_factor)}; + return glm::translate(glm::mat4(1.0f), final_position); + })}; + + auto rotation{bone_transform->rotations.interpolate( + this->animation_time, + [](glm::quat frame) + { + return glm::toMat4(glm::normalize(frame)); + }, + [](glm::quat previous_frame, glm::quat next_frame, float scale_factor) + { + return glm::toMat4(glm::slerp( + previous_frame, next_frame, scale_factor)); + })}; + + auto scale{bone_transform->scales.interpolate( + this->animation_time, + [](glm::vec3 frame) + { + return glm::scale(glm::mat4(1.0f), frame); + }, + [](glm::vec3 previous_frame, glm::vec3 next_frame, float scale_factor) + { + glm::vec3 scale{glm::mix( + previous_frame, next_frame, scale_factor)}; + return glm::scale(glm::mat4(1.0f), scale); + })}; + + this->bone_transforms[i] = position * rotation * scale; + } +} + +} diff --git a/src/vk/skeletal_model.hpp b/src/vk/skeletal_model.hpp new file mode 100644 index 0000000..1043e0f --- /dev/null +++ b/src/vk/skeletal_model.hpp @@ -0,0 +1,54 @@ +/* + * Copyright 2022-2023 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_SKELETAL_MODEL_H +#define CANDY_GEAR_VK_SKELETAL_MODEL_H 1 + +#include <memory> +#include <vector> + +#include "core.hpp" +#include "skeletal_mesh.hpp" + +namespace VK +{ + +struct SkeletalModel +{ + std::shared_ptr<SkeletalMesh> skeletal_mesh; + std::shared_ptr<Texture> texture; + std::vector<UniformBuffer> uniform_buffers; + std::shared_ptr<glm::vec3> position, rotation; + int animation_index; + float animation_time; + std::vector<glm::mat4> bone_transforms; + + VkDescriptorPool descriptor_pool; + std::vector<VkDescriptorSet> descriptor_sets; + + SkeletalModel( + std::shared_ptr<SkeletalMesh> skeletal_mesh, + std::shared_ptr<Texture> texture, std::shared_ptr<glm::vec3> position, + std::shared_ptr<glm::vec3> rotation); + ~SkeletalModel(); + + void + tick(float delta); +}; + +} + +#endif /* CANDY_GEAR_VK_SKELETAL_MODEL_H */ diff --git a/src/vk/mesh.cpp b/src/vk/static_mesh.cpp index 9afeac3..29034df 100644 --- a/src/vk/mesh.cpp +++ b/src/vk/static_mesh.cpp @@ -14,34 +14,34 @@ * limitations under the License. */ -#include "mesh.hpp" +#include "static_mesh.hpp" #include "../binary_reader.hpp" #include "../command.hpp" #include "../core.hpp" -#include "vertex_3d.hpp" +#include "static_mesh_vertex.hpp" namespace { -// Data that is only needed for the command chain but not for the Mesh goes -// here. +// Data that is only needed for the command chain but not for the StaticMesh +// goes here. struct MeshBuilder { std::string mesh_path; - VK::Mesh *mesh; + VK::StaticMesh *mesh; - MeshBuilder(VK::Mesh *m, std::string mp); - MeshBuilder(VK::Mesh *m, const char* mp); + MeshBuilder(VK::StaticMesh *m, std::string mp); + MeshBuilder(VK::StaticMesh *m, const char* mp); }; -MeshBuilder::MeshBuilder(VK::Mesh *m, std::string mp): +MeshBuilder::MeshBuilder(VK::StaticMesh *m, std::string mp): mesh{m}, mesh_path{mp} { } -MeshBuilder::MeshBuilder(VK::Mesh *m, const char *mp): +MeshBuilder::MeshBuilder(VK::StaticMesh *m, const char *mp): MeshBuilder{m, std::string(mp)} { } @@ -56,10 +56,9 @@ load_mesh(void *obj) self->mesh->queue_family = cg_core.vk_device_with_swapchain->get_queue_family_with_graphics(); - // Load vertexes. - { + { // Load vertexes. auto vertex_count{input.read_ui32()}; - std::vector<VK::Vertex3D> vertexes{vertex_count}; + std::vector<VK::StaticMeshVertex> vertexes{vertex_count}; for(auto i{0}; i < vertex_count; i++) { @@ -77,8 +76,7 @@ load_mesh(void *obj) VK_BUFFER_USAGE_VERTEX_BUFFER_BIT}; } - // Load indexes. - { + { // Load indexes self->mesh->index_count = input.read_ui32(); std::vector<uint32_t> indexes(self->mesh->index_count); @@ -114,18 +112,18 @@ static const CommandChain loader{ namespace VK { -Mesh::Mesh(std::string mesh_path) +StaticMesh::StaticMesh(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)} +StaticMesh::StaticMesh(const char* mesh_path): + StaticMesh{std::string(mesh_path)} { } -Mesh::~Mesh() +StaticMesh::~StaticMesh() { MeshBuilder mesh_builder(this, ""); loader.revert(&mesh_builder); diff --git a/src/vk/mesh.hpp b/src/vk/static_mesh.hpp index 97b9d8a..0ab38b2 100644 --- a/src/vk/mesh.hpp +++ b/src/vk/static_mesh.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -14,8 +14,8 @@ * limitations under the License. */ -#ifndef CANDY_GEAR_VK_MESH_H -#define CANDY_GEAR_VK_MESH_H 1 +#ifndef CANDY_GEAR_VK_STATIC_MESH_H +#define CANDY_GEAR_VK_STATIC_MESH_H 1 #include <string> #include <vector> @@ -29,7 +29,7 @@ namespace VK { -struct Mesh +struct StaticMesh { QueueFamily *queue_family; @@ -38,11 +38,11 @@ struct Mesh DestinationBuffer *index_buffer; DestinationBuffer *vertex_buffer; - Mesh(std::string mesh_path); - Mesh(const char* mesh_path); - ~Mesh(); + StaticMesh(std::string mesh_path); + StaticMesh(const char* mesh_path); + ~StaticMesh(); }; } -#endif /* CANDY_GEAR_VK_MESH_H */ +#endif /* CANDY_GEAR_VK_STATIC_MESH_H */ diff --git a/src/vk/vertex_3d.hpp b/src/vk/static_mesh_vertex.hpp index 8bb8675..7a91fe4 100644 --- a/src/vk/vertex_3d.hpp +++ b/src/vk/static_mesh_vertex.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -14,15 +14,15 @@ * limitations under the License. */ -#ifndef CANDY_GEAR_VK_VERTEX_3D_H -#define CANDY_GEAR_VK_VERTEX_3D_H 1 +#ifndef CANDY_GEAR_VK_STATIC_MESH_VERTEX_H +#define CANDY_GEAR_VK_STATIC_MESH_VERTEX_H 1 #include "core.hpp" namespace VK { -struct Vertex3D +struct StaticMeshVertex { glm::vec3 position; glm::vec3 normal; @@ -31,4 +31,4 @@ struct Vertex3D } -#endif /* CANDY_GEAR_VK_VERTEX_3D_H */ +#endif /* CANDY_GEAR_VK_STATIC_MESH_VERTEX_H */ diff --git a/src/vk/model.cpp b/src/vk/static_model.cpp index 4f63ddb..bf1f0d3 100644 --- a/src/vk/model.cpp +++ b/src/vk/static_model.cpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -14,9 +14,7 @@ * limitations under the License. */ -#include "model.hpp" - -#include <array> +#include "static_model.hpp" #include "../core.hpp" #include "uniform_data_object.hpp" @@ -27,45 +25,52 @@ namespace void load_uniform_buffers(void *obj) { - auto self = static_cast<VK::Model*>(obj); + auto self = static_cast<VK::StaticModel*>(obj); - self->ub_model_instance.reserve(cg_core.vk_swapchain->images_count); - for(int i{0}; i < cg_core.vk_swapchain->images_count; i++) - self->ub_model_instance.emplace_back( - cg_core.vk_device_with_swapchain, sizeof(VK::ODOModelInstance)); + try + { + self->uniform_buffers.reserve(cg_core.vk_swapchain->images_count); + for(auto i{0}; i < cg_core.vk_swapchain->images_count; i++) + self->uniform_buffers.emplace_back( + cg_core.vk_device_with_swapchain, sizeof(VK::ODOStaticModel)); + } + catch(const std::exception& e) + { + throw CommandError{e.what()}; + } } void unload_uniform_buffers(void *obj) { - auto self = static_cast<VK::Model*>(obj); + auto self = static_cast<VK::StaticModel*>(obj); - self->ub_model_instance.clear(); + self->uniform_buffers.clear(); } void load_descriptor_set_pool(void *obj) { - auto self = static_cast<VK::Model*>(obj); + auto self = static_cast<VK::StaticModel*>(obj); std::array<VkDescriptorPoolSize, 2> descriptor_pool_sizes{}; descriptor_pool_sizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; descriptor_pool_sizes[0].descriptorCount = - self->ub_model_instance.size(); + self->uniform_buffers.size(); descriptor_pool_sizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; descriptor_pool_sizes[1].descriptorCount = - self->ub_model_instance.size(); + cg_core.vk_swapchain->images_count; 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->ub_model_instance.size(); + pool_info.maxSets = self->uniform_buffers.size(); pool_info.poolSizeCount = descriptor_pool_sizes.size(); pool_info.pPoolSizes = descriptor_pool_sizes.data(); if(vkCreateDescriptorPool( - self->mesh->queue_family->device->device, &pool_info, nullptr, + self->static_mesh->queue_family->device->device, &pool_info, nullptr, &self->descriptor_pool) != VK_SUCCESS) throw CommandError{"Failed to create a Vulkan descriptor pool."}; } @@ -73,20 +78,21 @@ load_descriptor_set_pool(void *obj) void unload_descriptor_set_pool(void *obj) { - auto self = static_cast<VK::Model*>(obj); + auto self = static_cast<VK::StaticModel*>(obj); vkDestroyDescriptorPool( - self->mesh->queue_family->device->device, self->descriptor_pool, nullptr); + self->static_mesh->queue_family->device->device, self->descriptor_pool, + nullptr); } void load_descriptor_sets(void *obj) { - auto self = static_cast<VK::Model*>(obj); + auto self = static_cast<VK::StaticModel*>(obj); std::vector<VkDescriptorSetLayout> layouts( cg_core.vk_swapchain->images_count, - cg_core.vk_graphics_pipeline_3d_layout->descriptor_set_model_instance); + cg_core.vk_graphics_pipeline_3d_layout->descriptor_set_static_model); VkDescriptorSetAllocateInfo alloc_info{}; alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; @@ -96,7 +102,7 @@ load_descriptor_sets(void *obj) self->descriptor_sets.resize(layouts.size()); if(vkAllocateDescriptorSets( - self->mesh->queue_family->device->device, &alloc_info, + self->static_mesh->queue_family->device->device, &alloc_info, self->descriptor_sets.data()) != VK_SUCCESS) CommandError{"Failed to create Vulkan descriptor set."}; } @@ -104,31 +110,40 @@ load_descriptor_sets(void *obj) void load_buffers_to_descriptor_sets(void *obj) { - auto self = static_cast<VK::Model*>(obj); + auto self = static_cast<VK::StaticModel*>(obj); - for(auto i{0}; i < self->ub_model_instance.size(); i++) + for(auto i{0}; i < self->uniform_buffers.size(); i++) { VkDescriptorBufferInfo buffer_info{}; - buffer_info.buffer = self->ub_model_instance[i].buffer; + buffer_info.buffer = self->uniform_buffers[i].buffer; buffer_info.offset = 0; - buffer_info.range = sizeof(VK::ODOModelInstance); + buffer_info.range = sizeof(VK::ODOStaticModel); VkDescriptorImageInfo image_info{}; image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; image_info.imageView = self->texture->view; image_info.sampler = self->texture->sampler; - std::array<VkWriteDescriptorSet, 1> write_descriptors{}; + std::array<VkWriteDescriptorSet, 2> write_descriptors{}; write_descriptors[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; write_descriptors[0].dstSet = self->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_COMBINED_IMAGE_SAMPLER; - write_descriptors[0].pBufferInfo = nullptr; - write_descriptors[0].pImageInfo = &image_info; + 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->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(), @@ -148,14 +163,19 @@ static const CommandChain loader{ namespace VK { -Model::Model(std::shared_ptr<Mesh> mesh, std::shared_ptr<Texture> texture): - mesh{mesh}, - texture{texture} +StaticModel::StaticModel( + std::shared_ptr<StaticMesh> static_mesh, + std::shared_ptr<Texture> texture, std::shared_ptr<glm::vec3> position, + std::shared_ptr<glm::vec3> rotation): + static_mesh{static_mesh}, + texture{texture}, + position{position}, + rotation{rotation} { loader.execute(this); } -Model::~Model() +StaticModel::~StaticModel() { loader.revert(this); } diff --git a/src/vk/model.hpp b/src/vk/static_model.hpp index 72682b2..08c68c8 100644 --- a/src/vk/model.hpp +++ b/src/vk/static_model.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -14,28 +14,35 @@ * limitations under the License. */ -#ifndef CANDY_GEAR_VK_MODEL_H -#define CANDY_GEAR_VK_MODEL_H 1 +#ifndef CANDY_GEAR_VK_STATIC_MODEL_H +#define CANDY_GEAR_VK_STATIC_MODEL_H 1 -#include "mesh.hpp" -#include "texture.hpp" +#include <memory> +#include <vector> + +#include "core.hpp" +#include "static_mesh.hpp" namespace VK { -struct Model +struct StaticModel { - std::shared_ptr<Mesh> mesh; + std::shared_ptr<StaticMesh> static_mesh; std::shared_ptr<Texture> texture; + std::vector<UniformBuffer> uniform_buffers; + std::shared_ptr<glm::vec3> position, rotation; - std::vector<UniformBuffer> ub_model_instance; VkDescriptorPool descriptor_pool; std::vector<VkDescriptorSet> descriptor_sets; - Model(std::shared_ptr<Mesh> mesh, std::shared_ptr<Texture> texture); - ~Model(); + StaticModel( + std::shared_ptr<StaticMesh> static_mesh, + std::shared_ptr<Texture> texture, std::shared_ptr<glm::vec3> position, + std::shared_ptr<glm::vec3> rotation); + ~StaticModel(); }; } -#endif /* CANDY_GEAR_VK_MODEL_H */ +#endif /* CANDY_GEAR_VK_STATIC_MODEL_H */ diff --git a/src/vk/uniform_data_object.hpp b/src/vk/uniform_data_object.hpp index 102b82d..4ee4e73 100644 --- a/src/vk/uniform_data_object.hpp +++ b/src/vk/uniform_data_object.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2022 Frederico de Oliveira Linhares + * Copyright 2022-2023 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. @@ -18,6 +18,7 @@ #define CANDY_GEAR_VK_UNIFORM_DATA_OBJECT_H 1 #include "core.hpp" +#include "skeletal_mesh_vertex.hpp" namespace VK { @@ -44,9 +45,15 @@ struct ODOWorld3D_Frag glm::vec4 directional_light_color; }; -struct ODOModelInstance +struct ODOStaticModel { - glm::mat4 matrix; + glm::mat4 base_matrix; +}; + +struct ODOSkeletalModel +{ + glm::mat4 base_matrix; + glm::mat4 bone_matrices[SKELETAL_MESH_MAX_NUM_OF_BONES]; }; struct ODOVector4D |