diff --git a/build_windows.bat b/build_windows.bat index 310487c62..637402508 100644 --- a/build_windows.bat +++ b/build_windows.bat @@ -1,4 +1,6 @@ @echo off cmake -S . -B build -cmake --build build --config Release \ No newline at end of file +cmake --build build --config Release + +pause \ No newline at end of file diff --git a/engine/3rdparty/vulkanmemoryallocator/include/vk_mem_alloc.h b/engine/3rdparty/vulkanmemoryallocator/include/vk_mem_alloc.h index 65169f568..0a4e59ac2 100644 --- a/engine/3rdparty/vulkanmemoryallocator/include/vk_mem_alloc.h +++ b/engine/3rdparty/vulkanmemoryallocator/include/vk_mem_alloc.h @@ -256,7 +256,7 @@ extern "C" { // see: https://clang.llvm.org/docs/AttributeReference.html#nullable #ifndef VMA_NULLABLE #ifdef __clang__ - #define VMA_NULLABLE _Nullable + #define VMA_NULLABLE #else #define VMA_NULLABLE #endif @@ -266,7 +266,7 @@ extern "C" { // see: https://clang.llvm.org/docs/AttributeReference.html#nonnull #ifndef VMA_NOT_NULL #ifdef __clang__ - #define VMA_NOT_NULL _Nonnull + #define VMA_NOT_NULL #else #define VMA_NOT_NULL #endif @@ -13902,6 +13902,10 @@ bool VmaDefragmentationContext_T::ComputeDefragmentation_Extensive(VmaBlockVecto } break; } + case StateExtensive::Operation::Cleanup: + { + break; + } } if (vectorState.operation == StateExtensive::Operation::Cleanup) diff --git a/engine/shader/glsl/combine_ui.frag b/engine/shader/glsl/combine_ui.frag index e4ec33911..c05be556d 100644 --- a/engine/shader/glsl/combine_ui.frag +++ b/engine/shader/glsl/combine_ui.frag @@ -19,7 +19,14 @@ void main() // Gamma correct // TODO: select the VK_FORMAT_B8G8R8A8_SRGB surface format, // there is no need to do gamma correction in the fragment shader - ui_color = vec4(pow(ui_color.r, 1.0 / 2.2), pow(ui_color.g, 1.0 / 2.2), pow(ui_color.b, 1.0 / 2.2), pow(ui_color.a, 1.0 / 2.2)); - - out_color = scene_color + ui_color; + if(ui_color.r<1e-6&&ui_color.g<1e-6&&ui_color.a<1e-6) + { + ui_color = vec4(pow(ui_color.r, 1.0 / 2.2), pow(ui_color.g, 1.0 / 2.2), pow(ui_color.b, 1.0 / 2.2), pow(ui_color.a, 1.0 / 2.2)); + out_color = scene_color; + } + else + { + ui_color = vec4(pow(ui_color.r, 1.0 / 2.2), pow(ui_color.g, 1.0 / 2.2), pow(ui_color.b, 1.0 / 2.2), pow(ui_color.a, 1.0 / 2.2)); + out_color = ui_color; + } } diff --git a/engine/shader/glsl/debugdraw.frag b/engine/shader/glsl/debugdraw.frag new file mode 100644 index 000000000..20c4b8f78 --- /dev/null +++ b/engine/shader/glsl/debugdraw.frag @@ -0,0 +1,20 @@ +#version 450 + +#extension GL_GOOGLE_include_directive :enable +layout(location = 0) in vec4 fragColor; +layout(location = 1) in vec2 fragTexCoord; + +layout(location = 0) out vec4 outColor; + +layout(set = 0, binding = 2) uniform sampler2D texSampler; + + +void main(){ + outColor = fragColor; + if(fragTexCoord.x >= 0.0f && fragTexCoord.y >= 0.0f) + { + vec4 tex = texture(texSampler, fragTexCoord); + float xi = tex.r; + outColor = vec4(fragColor.r*xi,fragColor.g*xi,fragColor.b*xi,fragColor.a*xi); + } +} \ No newline at end of file diff --git a/engine/shader/glsl/debugdraw.vert b/engine/shader/glsl/debugdraw.vert new file mode 100644 index 000000000..6f95c527a --- /dev/null +++ b/engine/shader/glsl/debugdraw.vert @@ -0,0 +1,43 @@ +#version 450 + +#extension GL_GOOGLE_include_directive :enable +#include "constants.h" + +layout(location = 0) in vec3 inPosition; +layout(location = 1) in vec4 inColor; +layout(location = 2) in vec2 texcoord; + +layout(set = 0, binding = 0) uniform UniformBufferObject { + mat4 proj_view_matrix; +} ubo; + +layout(set = 0, binding = 1) uniform UniformDynamicBufferObject { + mat4 model; + vec4 color; +} dynamic_ubo; + +layout(location = 0) out vec4 fragColor; +layout(location = 1) out vec2 fragTexCoord; + +void main() { + if(texcoord.x<0) + { + gl_Position = ubo.proj_view_matrix * dynamic_ubo.model * vec4(inPosition,1.0); + } + else + { + gl_Position = vec4(inPosition,1.0); + } + + gl_PointSize = 2; + + if(dynamic_ubo.color.a>0.000001) + { + fragColor = dynamic_ubo.color; + } + else + { + fragColor = inColor; + } + fragTexCoord = texcoord; +} \ No newline at end of file diff --git a/engine/source/editor/source/editor_ui.cpp b/engine/source/editor/source/editor_ui.cpp index c1276bef0..3d4185075 100644 --- a/engine/source/editor/source/editor_ui.cpp +++ b/engine/source/editor/source/editor_ui.cpp @@ -23,6 +23,7 @@ #include "runtime/function/render/render_camera.h" #include "runtime/function/render/render_system.h" #include "runtime/function/render/window_system.h" +#include "runtime/function/render/render_debug_config.h" #include #include @@ -336,6 +337,38 @@ namespace Piccolo { g_runtime_global_context.m_world_manager->saveCurrentLevel(); } + if (ImGui::BeginMenu("Debug")) + { + if (ImGui::BeginMenu("Animation")) + { + if (ImGui::MenuItem(g_runtime_global_context.m_render_debug_config->animation.show_skeleton ? "off skeleton" : "show skeleton")) + { + g_runtime_global_context.m_render_debug_config->animation.show_skeleton = !g_runtime_global_context.m_render_debug_config->animation.show_skeleton; + } + if (ImGui::MenuItem(g_runtime_global_context.m_render_debug_config->animation.show_bone_name ? "off bone name" : "show bone name")) + { + g_runtime_global_context.m_render_debug_config->animation.show_bone_name = !g_runtime_global_context.m_render_debug_config->animation.show_bone_name; + } + ImGui::EndMenu(); + } + if (ImGui::BeginMenu("Camera")) + { + if (ImGui::MenuItem(g_runtime_global_context.m_render_debug_config->camera.show_runtime_info ? "off runtime info" : "show runtime info")) + { + g_runtime_global_context.m_render_debug_config->camera.show_runtime_info = !g_runtime_global_context.m_render_debug_config->camera.show_runtime_info; + } + ImGui::EndMenu(); + } + if (ImGui::BeginMenu("Game Object")) + { + if (ImGui::MenuItem(g_runtime_global_context.m_render_debug_config->gameObject.show_bounding_box ? "off bounding box" : "show bounding box")) + { + g_runtime_global_context.m_render_debug_config->gameObject.show_bounding_box = !g_runtime_global_context.m_render_debug_config->gameObject.show_bounding_box; + } + ImGui::EndMenu(); + } + ImGui::EndMenu(); + } if (ImGui::MenuItem("Exit")) { g_editor_global_context.m_engine_runtime->shutdownEngine(); diff --git a/engine/source/runtime/engine.cpp b/engine/source/runtime/engine.cpp index b81ed5b24..24b88c98f 100644 --- a/engine/source/runtime/engine.cpp +++ b/engine/source/runtime/engine.cpp @@ -10,6 +10,7 @@ #include "runtime/function/physics/physics_manager.h" #include "runtime/function/render/render_system.h" #include "runtime/function/render/window_system.h" +#include "runtime/function/render/debugdraw/debug_draw_manager.h" namespace Piccolo { @@ -73,7 +74,7 @@ namespace Piccolo // exchange data between logic and render contexts g_runtime_global_context.m_render_system->swapLogicRenderData(); - rendererTick(); + rendererTick(delta_time); #ifdef ENABLE_PHYSICS_DEBUG_RENDERER g_runtime_global_context.m_physics_manager->renderPhysicsWorld(delta_time); @@ -95,9 +96,9 @@ namespace Piccolo g_runtime_global_context.m_input_system->tick(); } - bool PiccoloEngine::rendererTick() + bool PiccoloEngine::rendererTick(float delta_time) { - g_runtime_global_context.m_render_system->tick(); + g_runtime_global_context.m_render_system->tick(delta_time); return true; } diff --git a/engine/source/runtime/engine.h b/engine/source/runtime/engine.h index 2597a4d73..a7d51a252 100644 --- a/engine/source/runtime/engine.h +++ b/engine/source/runtime/engine.h @@ -32,7 +32,7 @@ namespace Piccolo protected: void logicalTick(float delta_time); - bool rendererTick(); + bool rendererTick(float delta_time); void calculateFPS(float delta_time); diff --git a/engine/source/runtime/function/animation/skeleton.cpp b/engine/source/runtime/function/animation/skeleton.cpp index a0b70f938..d520e7379 100644 --- a/engine/source/runtime/function/animation/skeleton.cpp +++ b/engine/source/runtime/function/animation/skeleton.cpp @@ -154,4 +154,14 @@ namespace Piccolo } return animation_result; } + + const Bone* Skeleton::getBones() const + { + return m_bones; + } + + int32_t Skeleton::getBonesCount() const + { + return m_bone_count; + } } // namespace Piccolo \ No newline at end of file diff --git a/engine/source/runtime/function/animation/skeleton.h b/engine/source/runtime/function/animation/skeleton.h index 8b17e0b32..09eef2309 100644 --- a/engine/source/runtime/function/animation/skeleton.h +++ b/engine/source/runtime/function/animation/skeleton.h @@ -23,5 +23,7 @@ namespace Piccolo void applyAnimation(const BlendStateWithClipData& blend_state); AnimationResult outputAnimationResult(); void resetSkeleton(); + const Bone* getBones() const; + int32_t getBonesCount() const; }; } // namespace Piccolo diff --git a/engine/source/runtime/function/character/character.h b/engine/source/runtime/function/character/character.h index 52b5df58f..91b93eaa2 100644 --- a/engine/source/runtime/function/character/character.h +++ b/engine/source/runtime/function/character/character.h @@ -18,6 +18,7 @@ namespace Piccolo GObjectID getObjectID() const; void setObject(std::shared_ptr gobject); + std::weak_ptr getObject() const { return m_character_object; } void setPosition(const Vector3& position) { m_position = position; } void setRotation(const Quaternion& rotation) { m_rotation = rotation; } diff --git a/engine/source/runtime/function/framework/component/animation/animation_component.cpp b/engine/source/runtime/function/framework/component/animation/animation_component.cpp index f1505cd8e..4db965894 100644 --- a/engine/source/runtime/function/framework/component/animation/animation_component.cpp +++ b/engine/source/runtime/function/framework/component/animation/animation_component.cpp @@ -25,4 +25,6 @@ namespace Piccolo } const AnimationResult& AnimationComponent::getResult() const { return m_animation_res.animation_result; } + + const Skeleton& AnimationComponent::getSkeleton() const { return m_skeleton; } } // namespace Piccolo diff --git a/engine/source/runtime/function/framework/component/animation/animation_component.h b/engine/source/runtime/function/framework/component/animation/animation_component.h index 7e8b437b3..4d03aadf3 100644 --- a/engine/source/runtime/function/framework/component/animation/animation_component.h +++ b/engine/source/runtime/function/framework/component/animation/animation_component.h @@ -20,6 +20,8 @@ namespace Piccolo const AnimationResult& getResult() const; + const Skeleton& getSkeleton() const; + protected: META(Enable) AnimationComponentRes m_animation_res; diff --git a/engine/source/runtime/function/framework/component/camera/camera_component.h b/engine/source/runtime/function/framework/component/camera/camera_component.h index 27e871437..07b514bf6 100644 --- a/engine/source/runtime/function/framework/component/camera/camera_component.h +++ b/engine/source/runtime/function/framework/component/camera/camera_component.h @@ -32,6 +32,8 @@ namespace Piccolo CameraMode getCameraMode() const { return m_camera_mode; } void setCameraMode(CameraMode mode) { m_camera_mode = mode; } + Vector3 getPosition() const { return m_position; } + Vector3 getForward() const { return m_forward; } private: void tickFirstPersonCamera(float delta_time); diff --git a/engine/source/runtime/function/framework/component/rigidbody/rigidbody_component.cpp b/engine/source/runtime/function/framework/component/rigidbody/rigidbody_component.cpp index 8f6277950..5aa7749ed 100644 --- a/engine/source/runtime/function/framework/component/rigidbody/rigidbody_component.cpp +++ b/engine/source/runtime/function/framework/component/rigidbody/rigidbody_component.cpp @@ -1,5 +1,7 @@ #include "runtime/function/framework/component/rigidbody/rigidbody_component.h" +#include "runtime/engine.h" + #include "runtime/core/base/macro.h" #include "runtime/function/framework/component/transform/transform_component.h" @@ -7,7 +9,6 @@ #include "runtime/function/framework/world/world_manager.h" #include "runtime/function/global/global_context.h" #include "runtime/function/physics/physics_scene.h" -#include "runtime/function/physics/physics_system.h" namespace Piccolo { @@ -22,21 +23,20 @@ namespace Piccolo return; } - m_physics_actor = g_runtime_global_context.m_legacy_physics_system->createPhysicsActor( - parent_object, parent_transform->getTransformConst(), m_rigidbody_res); + std::shared_ptr physics_scene = + g_runtime_global_context.m_world_manager->getCurrentActivePhysicsScene().lock(); + ASSERT(physics_scene); - createRigidBody(parent_transform->getTransformConst()); + m_rigidbody_id = physics_scene->createRigidBody(parent_transform->getTransformConst(), m_rigidbody_res); } RigidBodyComponent::~RigidBodyComponent() { - if (m_physics_actor) - { - removeRigidBody(); + std::shared_ptr physics_scene = + g_runtime_global_context.m_world_manager->getCurrentActivePhysicsScene().lock(); + ASSERT(physics_scene); - g_runtime_global_context.m_legacy_physics_system->removePhyicsActor(m_physics_actor); - m_physics_actor = nullptr; - } + physics_scene->removeRigidBody(m_rigidbody_id); } void RigidBodyComponent::createRigidBody(const Transform& global_transform) @@ -45,25 +45,20 @@ namespace Piccolo g_runtime_global_context.m_world_manager->getCurrentActivePhysicsScene().lock(); ASSERT(physics_scene); - const uint32_t body_id = physics_scene->createRigidBody(global_transform, m_rigidbody_res); - m_physics_actor->setBodyID(body_id); + m_rigidbody_id = physics_scene->createRigidBody(global_transform, m_rigidbody_res); } void RigidBodyComponent::removeRigidBody() { - const uint32_t body_id = m_physics_actor->getBodyID(); - std::shared_ptr physics_scene = g_runtime_global_context.m_world_manager->getCurrentActivePhysicsScene().lock(); ASSERT(physics_scene); - physics_scene->removeRigidBody(body_id); + physics_scene->removeRigidBody(m_rigidbody_id); } void RigidBodyComponent::updateGlobalTransform(const Transform& transform, bool is_scale_dirty) { - m_physics_actor->setGlobalTransform(transform); - if (is_scale_dirty) { removeRigidBody(); @@ -76,8 +71,17 @@ namespace Piccolo g_runtime_global_context.m_world_manager->getCurrentActivePhysicsScene().lock(); ASSERT(physics_scene); - physics_scene->updateRigidBodyGlobalTransform(m_physics_actor->getBodyID(), transform); + physics_scene->updateRigidBodyGlobalTransform(m_rigidbody_id, transform); } } + void RigidBodyComponent::getShapeBoundingBoxes(std::vector& out_bounding_boxes) const + { + std::shared_ptr physics_scene = + g_runtime_global_context.m_world_manager->getCurrentActivePhysicsScene().lock(); + ASSERT(physics_scene); + + physics_scene->getShapeBoundingBoxes(m_rigidbody_id, out_bounding_boxes); + } + } // namespace Piccolo diff --git a/engine/source/runtime/function/framework/component/rigidbody/rigidbody_component.h b/engine/source/runtime/function/framework/component/rigidbody/rigidbody_component.h index 64042f85e..cd12a18d4 100644 --- a/engine/source/runtime/function/framework/component/rigidbody/rigidbody_component.h +++ b/engine/source/runtime/function/framework/component/rigidbody/rigidbody_component.h @@ -3,7 +3,6 @@ #include "runtime/resource/res_type/components/rigid_body.h" #include "runtime/function/framework/component/component.h" -#include "runtime/function/physics/physics_actor.h" namespace Piccolo { @@ -19,6 +18,7 @@ namespace Piccolo void tick(float delta_time) override {} void updateGlobalTransform(const Transform& transform, bool is_scale_dirty); + void getShapeBoundingBoxes(std::vector & out_boudning_boxes) const; protected: void createRigidBody(const Transform& global_transform); @@ -27,6 +27,6 @@ namespace Piccolo META(Enable) RigidBodyComponentRes m_rigidbody_res; - PhysicsActor* m_physics_actor {nullptr}; + uint32_t m_rigidbody_id {0xffffffff}; }; } // namespace Piccolo diff --git a/engine/source/runtime/function/framework/level/level_debugger.cpp b/engine/source/runtime/function/framework/level/level_debugger.cpp new file mode 100644 index 000000000..65bf51885 --- /dev/null +++ b/engine/source/runtime/function/framework/level/level_debugger.cpp @@ -0,0 +1,250 @@ +#include "level_debugger.h" +#include "runtime/core/meta/reflection/reflection.h" +#include "runtime/engine.h" +#include "runtime/function/character/character.h" +#include "runtime/function/framework/component/camera/camera_component.h" +#include "runtime/function/framework/component/component.h" +#include "runtime/function/framework/component/transform/transform_component.h" +#include "runtime/resource/res_type/components/animation.h" + +#include "runtime/resource/asset_manager/asset_manager.h" + +#include "runtime/function/global/global_context.h" +#include "runtime/function/render/debugdraw/debug_draw_manager.h" +#include "runtime/function/render/render_debug_config.h" +namespace Piccolo +{ + void LevelDebugger::tick(std::shared_ptr level) const + { + if (g_is_editor_mode) + { + return; + } + + if (g_runtime_global_context.m_render_debug_config->animation.show_bone_name) + { + showAllBonesName(level); + } + if (g_runtime_global_context.m_render_debug_config->animation.show_skeleton) + { + showAllBones(level); + } + if (g_runtime_global_context.m_render_debug_config->gameObject.show_bounding_box) + { + showAllBoundingBox(level); + } + if (g_runtime_global_context.m_render_debug_config->camera.show_runtime_info) + { + showCameraInfo(level); + } + } + + void LevelDebugger::showAllBones(std::shared_ptr level) const + { + const LevelObjectsMap& go_map = level->getAllGObjects(); + for (const auto& gobject_pair : go_map) + { + drawBones(gobject_pair.second); + } + } + + void LevelDebugger::showBones(std::shared_ptr level, GObjectID go_id) const + { + std::shared_ptr gobject = level->getGObjectByID(go_id).lock(); + drawBones(gobject); + } + + void LevelDebugger::showAllBonesName(std::shared_ptr level) const + { + const LevelObjectsMap& go_map = level->getAllGObjects(); + for (const auto& gobject_pair : go_map) + { + drawBonesName(gobject_pair.second); + } + } + + void LevelDebugger::showBonesName(std::shared_ptr level, GObjectID go_id) const + { + std::shared_ptr gobject = level->getGObjectByID(go_id).lock(); + drawBonesName(gobject); + } + + void LevelDebugger::showAllBoundingBox(std::shared_ptr level) const + { + const LevelObjectsMap& go_map = level->getAllGObjects(); + for (const auto& gobject_pair : go_map) + { + drawBoundingBox(gobject_pair.second); + } + } + + void LevelDebugger::showBoundingBox(std::shared_ptr level, GObjectID go_id) const + { + std::shared_ptr gobject = level->getGObjectByID(go_id).lock(); + drawBoundingBox(gobject); + } + + void LevelDebugger::showCameraInfo(std::shared_ptr level) const + { + std::shared_ptr gobject = level->getCurrentActiveCharacter().lock()->getObject().lock(); + drawCameraInfo(gobject); + } + void LevelDebugger::drawBones(std::shared_ptr object) const + { + const TransformComponent* transform_component = + object->tryGetComponentConst("TransformComponent"); + const AnimationComponent* animation_component = + object->tryGetComponentConst("AnimationComponent"); + + if (transform_component == nullptr || animation_component == nullptr) + return; + + DebugDrawGroup* debug_draw_group = + g_runtime_global_context.m_debugdraw_manager->tryGetOrCreateDebugDrawGroup("bone"); + + Matrix4x4 object_matrix = Transform(transform_component->getPosition(), + transform_component->getRotation(), + transform_component->getScale()) + .getMatrix(); + + const Skeleton& skeleton = animation_component->getSkeleton(); + const Bone* bones = skeleton.getBones(); + int32_t bones_count = skeleton.getBonesCount(); + for (int32_t bone_index = 0; bone_index < bones_count; bone_index++) + { + if (bones[bone_index].getParent() == nullptr || bone_index == 1) + continue; + + Matrix4x4 bone_matrix = Transform(bones[bone_index]._getDerivedPosition(), + bones[bone_index]._getDerivedOrientation(), + bones[bone_index]._getDerivedScale()) + .getMatrix(); + Vector4 bone_position(0.0f, 0.0f, 0.0f, 1.0f); + bone_position = object_matrix * bone_matrix * bone_position; + bone_position /= bone_position[3]; + + Node* parent_bone = bones[bone_index].getParent(); + Matrix4x4 parent_bone_matrix = Transform(parent_bone->_getDerivedPosition(), + parent_bone->_getDerivedOrientation(), + parent_bone->_getDerivedScale()) + .getMatrix(); + Vector4 parent_bone_position(0.0f, 0.0f, 0.0f, 1.0f); + parent_bone_position = object_matrix * parent_bone_matrix * parent_bone_position; + parent_bone_position /= parent_bone_position[3]; + + debug_draw_group->addLine(Vector3(bone_position.x, bone_position.y, bone_position.z), + Vector3(parent_bone_position.x, parent_bone_position.y, parent_bone_position.z), + Vector4(1.0f, 0.0f, 0.0f, 1.0f), + Vector4(1.0f, 0.0f, 0.0f, 1.0f), + 0.0f, + true); + debug_draw_group->addSphere(Vector3(bone_position.x, bone_position.y, bone_position.z), + 0.015f, + Vector4(0.0f, 0.0f, 1.0f, 1.0f), + 0.0f, + true); + } + } + + void LevelDebugger::drawBonesName(std::shared_ptr object) const + { + const TransformComponent* transform_component = + object->tryGetComponentConst("TransformComponent"); + const AnimationComponent* animation_component = + object->tryGetComponentConst("AnimationComponent"); + + if (transform_component == nullptr || animation_component == nullptr) + return; + + DebugDrawGroup* debug_draw_group = + g_runtime_global_context.m_debugdraw_manager->tryGetOrCreateDebugDrawGroup("bone name"); + + Matrix4x4 object_matrix = Transform(transform_component->getPosition(), + transform_component->getRotation(), + transform_component->getScale()) + .getMatrix(); + + const Skeleton& skeleton = animation_component->getSkeleton(); + const Bone* bones = skeleton.getBones(); + int32_t bones_count = skeleton.getBonesCount(); + for (int32_t bone_index = 0; bone_index < bones_count; bone_index++) + { + if (bones[bone_index].getParent() == nullptr || bone_index == 1) + continue; + + Matrix4x4 bone_matrix = Transform(bones[bone_index]._getDerivedPosition(), + bones[bone_index]._getDerivedOrientation(), + bones[bone_index]._getDerivedScale()) + .getMatrix(); + Vector4 bone_position(0.0f, 0.0f, 0.0f, 1.0f); + bone_position = object_matrix * bone_matrix * bone_position; + bone_position /= bone_position[3]; + + debug_draw_group->addText(bones[bone_index].getName(), + Vector4(1.0f, 0.0f, 0.0f, 1.0f), + Vector3(bone_position.x, bone_position.y, bone_position.z), + 8, + false); + } + } + + void LevelDebugger::drawBoundingBox(std::shared_ptr object) const + { + const RigidBodyComponent* rigidbody_component = + object->tryGetComponentConst("RigidBodyComponent"); + if (rigidbody_component == nullptr) + return; + + std::vector bounding_boxes; + rigidbody_component->getShapeBoundingBoxes(bounding_boxes); + for (size_t bounding_box_index = 0; bounding_box_index < bounding_boxes.size(); bounding_box_index++) + { + AxisAlignedBox bounding_box = bounding_boxes[bounding_box_index]; + DebugDrawGroup* debug_draw_group = + g_runtime_global_context.m_debugdraw_manager->tryGetOrCreateDebugDrawGroup("bounding box"); + Vector3 center = + Vector3(bounding_box.getCenter().x, bounding_box.getCenter().y, bounding_box.getCenter().z); + Vector3 halfExtent = + Vector3(bounding_box.getHalfExtent().x, bounding_box.getHalfExtent().y, bounding_box.getHalfExtent().z); + + debug_draw_group->addBox( + center, halfExtent, Vector4(1.0f, 0.0f, 0.0f, 0.0f), Vector4(0.0f, 1.0f, 0.0f, 1.0f)); + } + } + + void LevelDebugger::drawCameraInfo(std::shared_ptr object) const + { + const CameraComponent* camera_component = object->tryGetComponentConst("CameraComponent"); + if (camera_component == nullptr) + return; + + DebugDrawGroup* debug_draw_group = + g_runtime_global_context.m_debugdraw_manager->tryGetOrCreateDebugDrawGroup("show camera info"); + + std::ostringstream buffer; + buffer << "camera mode: "; + switch (camera_component->getCameraMode()) + { + case CameraMode::first_person: + buffer << "first person"; + break; + case CameraMode::third_person: + buffer << "third person"; + break; + case CameraMode::free: + buffer << "free"; + break; + case CameraMode::invalid: + buffer << "invalid"; + break; + } + buffer << std::endl; + + Vector3 position = camera_component->getPosition(); + Vector3 forward = camera_component->getForward(); + Vector3 direction = forward - position; + buffer << "camera position: (" << position.x << "," << position.y << "," << position.z << ")" << std::endl; + buffer << "camera direction : (" << direction.x << "," << direction.y << "," << direction.z << ")"; + debug_draw_group->addText(buffer.str(), Vector4(1.0f, 0.0f, 0.0f, 1.0f), Vector3(-1.0f, -0.2f, 0.0f), 10, true); + } +} // namespace Piccolo \ No newline at end of file diff --git a/engine/source/runtime/function/framework/level/level_debugger.h b/engine/source/runtime/function/framework/level/level_debugger.h new file mode 100644 index 000000000..d15bb2f70 --- /dev/null +++ b/engine/source/runtime/function/framework/level/level_debugger.h @@ -0,0 +1,33 @@ +#pragma once +#include "runtime/function/framework/level/level.h" +#include "runtime/function/framework/object/object.h" + +namespace Piccolo +{ + class LevelDebugger + { + public: + void tick(std::shared_ptr level) const; + + // show all bones in a level + void showAllBones(std::shared_ptr level) const; + // show all bones of a object + void showBones(std::shared_ptr level, GObjectID go_id) const; + // show all bones' name in a level + void showAllBonesName(std::shared_ptr level) const; + // show all bones' name of a object + void showBonesName(std::shared_ptr level, GObjectID go_id) const; + // show all bindingBox in a level + void showAllBoundingBox(std::shared_ptr level) const; + // show boundingBox of a object + void showBoundingBox(std::shared_ptr level, GObjectID go_id) const; + // show camera info + void showCameraInfo(std::shared_ptr level) const; + + private: + void drawBones(std::shared_ptr object) const; + void drawBonesName(std::shared_ptr object) const; + void drawBoundingBox(std::shared_ptr object) const; + void drawCameraInfo(std::shared_ptr object) const; + }; +} // namespace Piccolo \ No newline at end of file diff --git a/engine/source/runtime/function/framework/world/world_manager.cpp b/engine/source/runtime/function/framework/world/world_manager.cpp index dc819430b..d7e71cfc9 100644 --- a/engine/source/runtime/function/framework/world/world_manager.cpp +++ b/engine/source/runtime/function/framework/world/world_manager.cpp @@ -7,6 +7,7 @@ #include "runtime/function/framework/level/level.h" #include "runtime/function/global/global_context.h" +#include "runtime/function/framework/level/level_debugger.h" #include "_generated/serializer/all_serializer.h" @@ -18,6 +19,9 @@ namespace Piccolo { m_is_world_loaded = false; m_current_world_url = g_runtime_global_context.m_config_manager->getDefaultWorldUrl(); + + //debugger + m_level_debugger = std::make_shared(); } void WorldManager::clear() @@ -35,6 +39,9 @@ namespace Piccolo m_current_world_resource.reset(); m_current_world_url.clear(); m_is_world_loaded = false; + + //clear debugger + m_level_debugger.reset(); } void WorldManager::tick(float delta_time) @@ -49,6 +56,7 @@ namespace Piccolo if (active_level) { active_level->tick(delta_time); + m_level_debugger->tick(active_level); } } diff --git a/engine/source/runtime/function/framework/world/world_manager.h b/engine/source/runtime/function/framework/world/world_manager.h index ccbc43581..833f49ab8 100644 --- a/engine/source/runtime/function/framework/world/world_manager.h +++ b/engine/source/runtime/function/framework/world/world_manager.h @@ -8,6 +8,7 @@ namespace Piccolo { class Level; + class LevelDebugger; class PhysicsScene; /// Manage all game worlds, it should be support multiple worlds, including game world and editor world. @@ -40,5 +41,8 @@ namespace Piccolo std::unordered_map> m_loaded_levels; // active level, currently we just support one active level std::weak_ptr m_current_active_level; + + //debug level + std::shared_ptr m_level_debugger; }; } // namespace Piccolo diff --git a/engine/source/runtime/function/global/global_context.cpp b/engine/source/runtime/function/global/global_context.cpp index 45cc73fdb..1729178fa 100644 --- a/engine/source/runtime/function/global/global_context.cpp +++ b/engine/source/runtime/function/global/global_context.cpp @@ -12,11 +12,12 @@ #include "runtime/engine.h" #include "runtime/function/framework/world/world_manager.h" #include "runtime/function/input/input_system.h" -#include "runtime/function/physics/physics_system.h" +#include "runtime/function/particle/particle_manager.h" #include "runtime/function/physics/physics_manager.h" +#include "runtime/function/render/debugdraw/debug_draw_manager.h" +#include "runtime/function/render/render_debug_config.h" #include "runtime/function/render/render_system.h" #include "runtime/function/render/window_system.h" -#include "runtime/function/particle/particle_manager.h" namespace Piccolo { @@ -33,8 +34,6 @@ namespace Piccolo m_asset_manager = std::make_shared(); - m_legacy_physics_system = std::make_shared(); - m_physics_manager = std::make_shared(); m_physics_manager->initialize(); @@ -55,10 +54,20 @@ namespace Piccolo RenderSystemInitInfo render_init_info; render_init_info.window_system = m_window_system; m_render_system->initialize(render_init_info); + + m_debugdraw_manager = std::make_shared(); + m_debugdraw_manager->initialize(); + + m_render_debug_config = std::make_shared(); } void RuntimeGlobalContext::shutdownSystems() { + m_render_debug_config.reset(); + + m_debugdraw_manager.reset(); + + m_render_system->clear(); m_render_system.reset(); m_window_system.reset(); @@ -66,8 +75,6 @@ namespace Piccolo m_world_manager->clear(); m_world_manager.reset(); - m_legacy_physics_system.reset(); - m_physics_manager->clear(); m_physics_manager.reset(); @@ -76,7 +83,6 @@ namespace Piccolo m_asset_manager.reset(); - m_logger_system.reset(); m_file_system.reset(); diff --git a/engine/source/runtime/function/global/global_context.h b/engine/source/runtime/function/global/global_context.h index b08e80c4c..0b826f3c4 100644 --- a/engine/source/runtime/function/global/global_context.h +++ b/engine/source/runtime/function/global/global_context.h @@ -7,7 +7,6 @@ namespace Piccolo { class LogSystem; class InputSystem; - class PhysicsSystem; class PhysicsManager; class FileSystem; class AssetManager; @@ -16,6 +15,8 @@ namespace Piccolo class RenderSystem; class WindowSystem; class ParticleManager; + class DebugDrawManager; + class RenderDebugConfig; struct EngineInitParams; @@ -29,17 +30,18 @@ namespace Piccolo void shutdownSystems(); public: - std::shared_ptr m_logger_system; - std::shared_ptr m_input_system; - std::shared_ptr m_file_system; - std::shared_ptr m_asset_manager; - std::shared_ptr m_config_manager; - std::shared_ptr m_world_manager; - std::shared_ptr m_legacy_physics_system; - std::shared_ptr m_physics_manager; - std::shared_ptr m_window_system; - std::shared_ptr m_render_system; - std::shared_ptr m_particle_manager; + std::shared_ptr m_logger_system; + std::shared_ptr m_input_system; + std::shared_ptr m_file_system; + std::shared_ptr m_asset_manager; + std::shared_ptr m_config_manager; + std::shared_ptr m_world_manager; + std::shared_ptr m_physics_manager; + std::shared_ptr m_window_system; + std::shared_ptr m_render_system; + std::shared_ptr m_particle_manager; + std::shared_ptr m_debugdraw_manager; + std::shared_ptr m_render_debug_config; }; extern RuntimeGlobalContext g_runtime_global_context; diff --git a/engine/source/runtime/function/particle/particle_manager.cpp b/engine/source/runtime/function/particle/particle_manager.cpp index 23c0f6a43..e9806cbc0 100644 --- a/engine/source/runtime/function/particle/particle_manager.cpp +++ b/engine/source/runtime/function/particle/particle_manager.cpp @@ -13,9 +13,17 @@ namespace Piccolo void ParticleManager::initialize() { std::shared_ptr config_manager = g_runtime_global_context.m_config_manager; - ASSERT(config_manager); + if (config_manager == nullptr) + { + LOG_ERROR("config_manager is nullptr"); + return; + } std::shared_ptr asset_manager = g_runtime_global_context.m_asset_manager; - ASSERT(asset_manager); + if (asset_manager == nullptr) + { + LOG_ERROR("asset_manager is nullptr"); + return; + } GlobalParticleRes global_particle_res; const std::string& global_particle_res_url = config_manager->getGlobalParticleResUrl(); diff --git a/engine/source/runtime/function/physics/collision_detection.cpp b/engine/source/runtime/function/physics/collision_detection.cpp deleted file mode 100644 index 3e93a0d50..000000000 --- a/engine/source/runtime/function/physics/collision_detection.cpp +++ /dev/null @@ -1,563 +0,0 @@ -#include "runtime/function/physics/collision_detection.h" - -namespace Piccolo -{ - CollisionDetection::CollisionDetection() {} - - CollisionDetection::~CollisionDetection() {} - - bool CollisionDetection::IsAABBOverlapped(const AxisAlignedBox& aabb_a, const AxisAlignedBox& aabb_b) - { - Vector3 delta = (aabb_a.getCenter() - aabb_b.getCenter()).absoluteCopy(); - Vector3 total_size = aabb_a.getHalfExtent() + aabb_b.getHalfExtent(); - - return delta.x < total_size.x && delta.y < total_size.y && delta.z < total_size.z; - } - - bool CollisionDetection::ObjectIntersection(PhysicsActor& actor_a, - PhysicsActor& actor_b, - unsigned int id_a, - unsigned int id_b, - CollisionInfo& collision_info) - { - bool collision_status = false; - - const std::vector& actor_a_shapes = actor_a.getShapes(); - const std::vector& actor_b_shapes = actor_b.getShapes(); - - for (const auto& actor_a_shape_iter : actor_a_shapes) - { - for (const auto& actor_b_shape_iter : actor_b_shapes) - { - if (actor_a_shape_iter.m_type == RigidBodyShapeType::invalid || - actor_b_shape_iter.m_type == RigidBodyShapeType::invalid) - { - return false; - } - - collision_info.m_id_a = id_a; - collision_info.m_id_b = id_b; - - Matrix4x4 shape_mat_a = - actor_a.getTransform().getMatrix() * actor_a_shape_iter.m_local_transform.getMatrix(); - Vector3 shape_a_position; - Quaternion shape_a_rotation; - Vector3 shape_a_scale; - shape_mat_a.decomposition(shape_a_position, shape_a_scale, shape_a_rotation); - Transform shape_transform_a(shape_a_position, shape_a_rotation, shape_a_scale); - - Matrix4x4 shape_mat_b = - actor_b.getTransform().getMatrix() * actor_b_shape_iter.m_local_transform.getMatrix(); - Vector3 shape_b_position; - Quaternion shape_b_rotation; - Vector3 shape_b_scale; - shape_mat_b.decomposition(shape_b_position, shape_b_scale, shape_b_rotation); - Transform shape_transform_b(shape_b_position, shape_b_rotation, shape_b_scale); - - if (actor_a_shape_iter.m_type == RigidBodyShapeType::box && - actor_b_shape_iter.m_type == RigidBodyShapeType::box) - { - collision_status |= - AABBIntersection(static_cast(actor_a_shape_iter.m_geometry)->m_half_extents, - static_cast(actor_b_shape_iter.m_geometry)->m_half_extents, - shape_transform_a, - shape_transform_b, - collision_info); - } - - if (actor_a_shape_iter.m_type == RigidBodyShapeType::sphere && - actor_b_shape_iter.m_type == RigidBodyShapeType::sphere) - { - collision_status |= - SphereIntersection(static_cast(actor_a_shape_iter.m_geometry)->m_radius, - static_cast(actor_b_shape_iter.m_geometry)->m_radius, - shape_transform_a, - shape_transform_b, - collision_info); - } - - if (actor_a_shape_iter.m_type == RigidBodyShapeType::box && - actor_b_shape_iter.m_type == RigidBodyShapeType::sphere) - { - collision_status |= - AABBSphereIntersection(static_cast(actor_a_shape_iter.m_geometry)->m_half_extents, - static_cast(actor_b_shape_iter.m_geometry)->m_radius, - shape_transform_a, - shape_transform_b, - collision_info); - } - - if (actor_a_shape_iter.m_type == RigidBodyShapeType::sphere && - actor_b_shape_iter.m_type == RigidBodyShapeType::box) - { - collision_info.m_id_a = id_b; - collision_info.m_id_b = id_a; - collision_status |= - AABBSphereIntersection(static_cast(actor_b_shape_iter.m_geometry)->m_half_extents, - static_cast(actor_a_shape_iter.m_geometry)->m_radius, - shape_transform_b, - shape_transform_a, - collision_info); - } - } - } - return collision_status; - } - - Vector3 - CollisionDetection::getClosestPoint(const Vector3& box_size, const Transform& obb_transform, const Vector3& point) - { - Vector3 result = obb_transform.m_position; - Vector3 dir = point - result; - - float* p_box_size = (float*)&box_size; - - for (int i = 0; i < 3; ++i) - { - Matrix3x3 orientation = Matrix3x3(obb_transform.m_rotation); - float* p_orientation = (float*)&orientation; - Vector3 axis {p_orientation[0], p_orientation[1], p_orientation[2]}; - - float distance = dir.dotProduct(axis); - - if (distance > p_box_size[i]) - { - distance = p_box_size[i]; - } - if (distance < -p_box_size[i]) - { - distance = -p_box_size[i]; - } - - result += (axis * distance); - } - - return result; - } - - bool CollisionDetection::AABBIntersection(const Vector3& box_a_size, - const Vector3& box_b_size, - const Transform& world_transform_a, - const Transform& world_transform_b, - CollisionInfo& collision_info) - { - AxisAlignedBox bounding_a(world_transform_a.m_position, box_a_size); - AxisAlignedBox bounding_b(world_transform_b.m_position, box_b_size); - - if (IsAABBOverlapped(bounding_a, bounding_b)) - { - static const Vector3 faces[6] = { - Vector3 {-1, 0, 0}, - Vector3 {1, 0, 0}, - Vector3 {0, -1, 0}, - Vector3 {0, 1, 0}, - Vector3 {0, 0, -1}, - Vector3 {0, 0, 1}, - }; - - Vector3 max_a = bounding_a.getMaxCorner(); - Vector3 min_a = bounding_a.getMinCorner(); - Vector3 max_b = bounding_b.getMaxCorner(); - Vector3 min_b = bounding_b.getMinCorner(); - - float distances[6] = { - (max_b.x - min_a.x), - (max_a.x - min_b.x), - (max_b.y - min_a.y), - (max_a.y - min_b.y), - (max_b.z - min_a.z), - (max_a.z - min_b.z), - }; - float penetration = FLT_MAX; - Vector3 best_axis; - - for (int i = 0; i < 6; i++) - { - if (distances[i] < penetration) - { - penetration = distances[i]; - best_axis = faces[i]; - } - } - collision_info.addContactPoint(Vector3(), Vector3(), best_axis, penetration); - - return true; - } - - return false; - } - - bool CollisionDetection::SphereIntersection(float sphere_a_radius, - float sphere_b_radius, - const Transform& world_transform_a, - const Transform& world_transform_b, - CollisionInfo& collision_info) - { - float radii = sphere_a_radius + sphere_b_radius; - Vector3 normal = world_transform_b.m_position - world_transform_a.m_position; - - float length = normal.length(); - - if (length < radii) - { - float penetration = (radii - length); - normal.normalise(); - Vector3 localA = normal * sphere_a_radius; - Vector3 localB = -normal * sphere_b_radius; - - collision_info.addContactPoint(localA, localB, normal, penetration); - return true; - } - - return false; - } - - bool CollisionDetection::AABBSphereIntersection(const Vector3& box_size, - float sphere_radius, - const Transform& world_transform_a, - const Transform& world_transform_b, - CollisionInfo& collision_info) - { - Vector3 delta = world_transform_b.m_position - world_transform_a.m_position; - - Vector3 closest_point_on_box = Vector3::clamp(delta, -box_size, box_size); - - Vector3 local_point = delta - closest_point_on_box; - float distance = local_point.length(); - - if (distance < sphere_radius) - { - Vector3 collision_normal = local_point.normalisedCopy(); - float penetration = (sphere_radius - distance); - - Vector3 localA = Vector3(); - Vector3 localB = -collision_normal * sphere_radius; - - collision_info.addContactPoint(localA, localB, collision_normal, penetration); - - return true; - } - return false; - } - - bool CollisionDetection::OBBIntersection(const Vector3& box_a_size, - const Vector3& box_b_size, - const Transform& world_transform_a, - const Transform& world_transform_b, - CollisionInfo& collision_info) - { - Vector3 v = world_transform_a.m_position - world_transform_b.m_position; - - // compute a's basis - std::vector volume_a_axis; - volume_a_axis.push_back(world_transform_a.m_rotation * Vector3 {1, 0, 0}); // a_x - volume_a_axis.push_back(world_transform_a.m_rotation * Vector3 {0, 1, 0}); // a_y - volume_a_axis.push_back(world_transform_a.m_rotation * Vector3 {0, 0, 1}); // a_z - - // compute b's basis - std::vector volume_b_axis; - volume_b_axis.push_back(world_transform_b.m_rotation * Vector3 {1, 0, 0}); // b_x - volume_b_axis.push_back(world_transform_b.m_rotation * Vector3 {0, 1, 0}); // b_y - volume_b_axis.push_back(world_transform_b.m_rotation * Vector3 {0, 0, 1}); // b_z - - Vector3 T {v.dotProduct(volume_a_axis[0]), v.dotProduct(volume_a_axis[1]), v.dotProduct(volume_a_axis[2])}; - - Matrix3x3 R, RF; - float ra, rb, t; - - float* p_r = (float*)&R; - float* p_rf = (float*)&RF; - float* p_t = (float*)&T; - - float* half_dimensions_a = (float*)&box_a_size; - float* half_dimensions_b = (float*)&box_b_size; - - for (int i = 0; i < 3; ++i) - { - for (int j = 0; j < 3; ++j) - { - p_r[i * 3 + j] = volume_a_axis[i].dotProduct(volume_b_axis[j]); - p_rf[i * 3 + j] = 1e-6f + fabsf(p_r[i * 3 + j]); - } - } - - // a's basis vectors - for (int i = 0; i < 3; ++i) - { - ra = half_dimensions_a[i]; - rb = half_dimensions_b[0] * p_rf[i * 3 + 0] + half_dimensions_b[1] * p_rf[i * 3 + 1] + - half_dimensions_b[2] * p_rf[i * 3 + 2]; - t = fabsf(p_t[i]); - - if (t > ra + rb) - { - return false; - } - } - - // b's basis vectors - for (int i = 0; i < 3; ++i) - { - ra = half_dimensions_a[0] * p_rf[0 * 3 + i] + half_dimensions_a[1] * p_rf[1 * 3 + i] + - half_dimensions_a[2] * p_rf[2 * 3 + i]; - rb = half_dimensions_b[i]; - t = fabsf(p_t[0] * p_r[0 * 3 + i] + p_t[1] * p_r[1 * 3 + i] + p_t[2] * p_r[2 * 3 + i]); - - if (t > ra + rb) - { - return false; - } - } - - // 9 cross products - // L = A0 * B0 - ra = half_dimensions_a[1] * p_rf[2 * 3 + 0] + half_dimensions_a[2] * p_rf[1 * 3 + 0]; - rb = half_dimensions_b[1] * p_rf[0 * 3 + 2] + half_dimensions_b[2] * p_rf[0 * 3 + 1]; - t = fabsf(p_t[2] * p_r[1 * 3 + 0] - p_t[1] * p_r[2 * 3 + 0]); - if (t > ra + rb) - return false; - - // L = A0 * B1 - ra = half_dimensions_a[1] * p_rf[2 * 3 + 1] + half_dimensions_a[2] * p_rf[1 * 3 + 1]; - rb = half_dimensions_b[0] * p_rf[0 * 3 + 2] + half_dimensions_b[2] * p_rf[0 * 3 + 0]; - t = fabsf(p_t[2] * p_r[1 * 3 + 1] - p_t[1] * p_r[2 * 3 + 1]); - if (t > ra + rb) - return false; - - // L = A0 * B2 - ra = half_dimensions_a[1] * p_rf[2 * 3 + 2] + half_dimensions_a[2] * p_rf[1 * 3 + 2]; - rb = half_dimensions_b[0] * p_rf[0 * 3 + 1] + half_dimensions_b[1] * p_rf[0 * 3 + 0]; - t = fabsf(p_t[2] * p_r[1 * 3 + 2] - p_t[1] * p_r[2 * 3 + 2]); - if (t > ra + rb) - return false; - - // L = A1 * B0 - ra = half_dimensions_a[0] * p_rf[2 * 3 + 0] + half_dimensions_a[2] * p_rf[0 * 3 + 0]; - rb = half_dimensions_b[1] * p_rf[1 * 3 + 2] + half_dimensions_b[2] * p_rf[1 * 3 + 1]; - t = fabsf(p_t[0] * p_r[2 * 3 + 0] - p_t[2] * p_r[0 * 3 + 0]); - if (t > ra + rb) - return false; - - // L = A1 * B1 - ra = half_dimensions_a[0] * p_rf[2 * 3 + 1] + half_dimensions_a[2] * p_rf[0 * 3 + 1]; - rb = half_dimensions_b[0] * p_rf[1 * 3 + 2] + half_dimensions_b[2] * p_rf[1 * 3 + 0]; - t = fabsf(p_t[0] * p_r[2 * 3 + 1] - p_t[2] * p_r[0 * 3 + 1]); - if (t > ra + rb) - return false; - - // L = A1 * B2 - ra = half_dimensions_a[0] * p_rf[2 * 3 + 2] + half_dimensions_a[2] * p_rf[0 * 3 + 2]; - rb = half_dimensions_b[0] * p_rf[1 * 3 + 1] + half_dimensions_b[1] * p_rf[1 * 3 + 0]; - t = fabsf(p_t[0] * p_r[2 * 3 + 2] - p_t[2] * p_r[0 * 3 + 2]); - if (t > ra + rb) - return false; - - // L = A2 * B0 - ra = half_dimensions_a[0] * p_rf[1 * 3 + 0] + half_dimensions_a[1] * p_rf[0 * 3 + 0]; - rb = half_dimensions_b[1] * p_rf[2 * 3 + 2] + half_dimensions_b[2] * p_rf[2 * 3 + 1]; - t = fabsf(p_t[1] * p_r[0 * 3 + 0] - p_t[0] * p_r[1 * 3 + 0]); - if (t > ra + rb) - return false; - - // L = A2 * B1 - ra = half_dimensions_a[0] * p_rf[1 * 3 + 1] + half_dimensions_a[1] * p_rf[0 * 3 + 1]; - rb = half_dimensions_b[0] * p_rf[2 * 3 + 2] + half_dimensions_b[2] * p_rf[2 * 3 + 0]; - t = fabsf(p_t[1] * p_r[0 * 3 + 1] - p_t[0] * p_r[1 * 3 + 1]); - if (t > ra + rb) - return false; - - // L = A2 * B2 - ra = half_dimensions_a[0] * p_rf[1 * 3 + 2] + half_dimensions_a[1] * p_rf[0 * 3 + 2]; - rb = half_dimensions_b[0] * p_rf[2 * 3 + 1] + half_dimensions_b[1] * p_rf[2 * 3 + 0]; - t = fabsf(p_t[1] * p_r[0 * 3 + 2] - p_t[0] * p_r[1 * 3 + 2]); - if (t > ra + rb) - return false; - - return true; - } - - bool CollisionDetection::OBBSphereIntersection(const Vector3& box_size, - float sphere_radius, - const Transform& world_transform_a, - const Transform& world_transform_b, - CollisionInfo& collision_info) - { - Vector3 box_center = world_transform_a.m_position; - Vector3 sphere_center = world_transform_b.m_position; - - Vector3 closest_point = getClosestPoint(box_size, world_transform_a, sphere_center); - - float dis_sq = (closest_point - sphere_center).dotProduct(closest_point - sphere_center); - if (dis_sq > sphere_radius * sphere_radius) - { - return false; - } - - Vector3 normal; - if (CMP(dis_sq, 0.0f)) - { - if (CMP((closest_point - box_center).dotProduct(closest_point - box_center), 0.0f)) - { - return false; - } - normal = (closest_point - box_center).normalisedCopy(); - } - else - { - normal = (sphere_center - closest_point).normalisedCopy(); - } - - Vector3 outside_point = sphere_center - normal * sphere_radius; - - float distance = sqrtf((closest_point - outside_point).dotProduct(closest_point - outside_point)); - - collision_info.addContactPoint( - Vector3(), closest_point + (outside_point - closest_point) * 0.5f, normal, distance * 0.5f); - - return true; - } - - bool CollisionDetection::RayIntersection(const Ray& r, PhysicsActor& actor_a, RayCollision& collisions) - { - bool collided = false; - - return collided; - } - - bool CollisionDetection::RayBoxIntersection(const Ray& r, - const Vector3& box_pos, - const Vector3& box_size, - RayCollision& collision) - { - Vector3 box_min = box_pos - box_size; - Vector3 box_max = box_pos + box_size; - - Vector3 ray_pos = r.getStartPoint(); - Vector3 ray_dir = r.getDirection(); - - Vector3 t_vals {-1, -1, -1}; - - if (ray_dir.x > 0) - { - t_vals.x = (box_min.x - ray_pos.x) / ray_dir.x; - } - else if (ray_dir.x < 0) - { - t_vals.x = (box_max.x - ray_pos.x) / ray_dir.x; - } - - if (ray_dir.y > 0) - { - t_vals.y = (box_min.y - ray_pos.y) / ray_dir.y; - } - else if (ray_dir.y < 0) - { - t_vals.y = (box_max.y - ray_pos.y) / ray_dir.y; - } - - if (ray_dir.z > 0) - { - t_vals.z = (box_min.z - ray_pos.z) / ray_dir.z; - } - else if (ray_dir.z < 0) - { - t_vals.z = (box_max.z - ray_pos.z) / ray_dir.z; - } - - float best_t = Vector3::getMaxElement(t_vals); - - if (best_t < 0.0f) - { - return false; - } - - Vector3 intersection = ray_pos + (ray_dir * best_t); - const float epsilon = 0.0001f; - - if (intersection.x + epsilon < box_min.x || intersection.x - epsilon > box_max.x) - { - return false; - } - - if (intersection.y + epsilon < box_min.y || intersection.y - epsilon > box_max.y) - { - return false; - } - - if (intersection.z + epsilon < box_min.z || intersection.z - epsilon > box_max.z) - { - return false; - } - - collision.m_collided_point = intersection; - collision.m_ray_distance = best_t; - - return true; - } - - bool CollisionDetection::RayAABBIntersection(const Ray& r, - const Transform& world_transform, - const Vector3& box_size, - RayCollision& collision) - { - Vector3 box_pos = world_transform.m_position; - return RayBoxIntersection(r, box_pos, box_size, collision); - } - - bool CollisionDetection::RayOBBIntersection(const Ray& r, - const Transform& world_transform, - const Vector3& box_size, - RayCollision& collision) - { - Quaternion orientation = world_transform.m_rotation; - Vector3 obb_position = world_transform.m_position; - - Matrix3x3 transform = Matrix3x3(orientation); - Matrix3x3 inv_transform = Matrix3x3(orientation.conjugate()); - Vector3 local_ray_pos = r.getStartPoint() - obb_position; - - Ray temp_ray(inv_transform * local_ray_pos, inv_transform * r.getDirection()); - - bool collided = RayBoxIntersection(temp_ray, Vector3(), box_size, collision); - - if (collided) - { - collision.m_collided_point = transform * collision.m_collided_point + obb_position; - } - - return collided; - } - - bool CollisionDetection::RaySphereIntersection(const Ray& r, - const Transform& world_transform, - float sphere_radius, - RayCollision& collision) - { - Vector3 sphere_pos = world_transform.m_position; - - Vector3 dir = (sphere_pos - r.getStartPoint()); - - float sphere_proj = dir.dotProduct(r.getDirection()); - - if (sphere_proj < 0.0f) - { - return false; - } - - Vector3 point = r.getStartPoint() + (r.getDirection() * sphere_proj); - - float sphere_dist = (point - sphere_pos).length(); - - if (sphere_dist > sphere_radius) - { - return false; - } - - float offset = sqrt((sphere_radius * sphere_radius) - (sphere_dist * sphere_dist)); - - collision.m_ray_distance = sphere_proj - offset; - collision.m_collided_point = r.getStartPoint() + (r.getDirection() * collision.m_ray_distance); - - return true; - } -} // namespace Piccolo diff --git a/engine/source/runtime/function/physics/collision_detection.h b/engine/source/runtime/function/physics/collision_detection.h deleted file mode 100644 index 26f934551..000000000 --- a/engine/source/runtime/function/physics/collision_detection.h +++ /dev/null @@ -1,107 +0,0 @@ -#pragma once - -#include "runtime/core/base/hash.h" -#include "runtime/core/math/axis_aligned.h" -#include "runtime/core/math/transform.h" - -#include "runtime/function/physics/physics_actor.h" -#include "runtime/function/physics/ray.h" - -namespace Piccolo -{ - struct ContactPoint - { - Vector3 m_location_a; - Vector3 m_location_b; - Vector3 m_normal; - float m_penetration; - }; - - struct CollisionInfo - { - unsigned int m_id_a; - unsigned int m_id_b; - ContactPoint m_contact_point; - mutable int m_frame_left; - - void - addContactPoint(const Vector3& location_a, const Vector3& location_b, const Vector3& normal, float penetration) - { - m_contact_point.m_location_a = location_a; - m_contact_point.m_location_b = location_b; - m_contact_point.m_normal = normal; - m_contact_point.m_penetration = penetration; - } - - bool operator<(const CollisionInfo& rhs) const - { - size_t other_hash = 0; - hash_combine(other_hash, rhs.m_id_a, rhs.m_id_b); - size_t this_hash = 0; - hash_combine(this_hash, m_id_a, m_id_b); - return this_hash < other_hash; - } - - bool operator==(const CollisionInfo& rhs) const { return rhs.m_id_a == m_id_a && rhs.m_id_b == m_id_b; } - }; - - class CollisionDetection - { - public: - CollisionDetection(); - ~CollisionDetection(); - - static bool IsAABBOverlapped(const AxisAlignedBox& bounding_a, const AxisAlignedBox& position_b); - static bool ObjectIntersection(PhysicsActor& object_a, - PhysicsActor& object_b, - unsigned int id_a, - unsigned int id_b, - CollisionInfo& collision_info); - - static Vector3 getClosestPoint(const Vector3& box_size, const Transform& obb_transform, const Vector3& point); - - // intersect functions - static bool AABBIntersection(const Vector3& box_a_size, - const Vector3& box_b_size, - const Transform& world_transform_a, - const Transform& world_transform_b, - CollisionInfo& collision_info); - static bool SphereIntersection(float sphere_a_radius, - float sphere_b_radius, - const Transform& world_transform_a, - const Transform& world_transform_b, - CollisionInfo& collision_info); - static bool AABBSphereIntersection(const Vector3& box_size, - float sphere_radius, - const Transform& world_transform_a, - const Transform& world_transform_b, - CollisionInfo& collision_info); - static bool OBBIntersection(const Vector3& box_a_size, - const Vector3& box_b_size, - const Transform& world_transform_a, - const Transform& world_transform_b, - CollisionInfo& collision_info); - static bool OBBSphereIntersection(const Vector3& box_size, - float sphere_radius, - const Transform& world_transform_a, - const Transform& world_transform_b, - CollisionInfo& collision_info); - - // raycasting functions - static bool RayIntersection(const Ray& r, PhysicsActor& object_a, RayCollision& collisions); - static bool - RayBoxIntersection(const Ray& r, const Vector3& box_pos, const Vector3& box_size, RayCollision& collision); - static bool RayAABBIntersection(const Ray& r, - const Transform& world_transform, - const Vector3& box_size, - RayCollision& collision); - static bool RayOBBIntersection(const Ray& r, - const Transform& world_transform, - const Vector3& box_size, - RayCollision& collision); - static bool RaySphereIntersection(const Ray& r, - const Transform& world_transform, - float sphere_radius, - RayCollision& collision); - }; -} // namespace Piccolo diff --git a/engine/source/runtime/function/physics/physics_aabb_shape.h b/engine/source/runtime/function/physics/physics_aabb_shape.h deleted file mode 100644 index 9c377c4a1..000000000 --- a/engine/source/runtime/function/physics/physics_aabb_shape.h +++ /dev/null @@ -1,23 +0,0 @@ -#pragma once - -#include "runtime/core/math/vector3.h" - -#include "runtime/function/physics/physics_shape_base.h" - -namespace Piccolo -{ - class PhysicsAABBShape : public PhysicsShapeBase - { - public: - PhysicsAABBShape(const Transform& transform, const Vector3 half_dimensions) : - PhysicsShapeBase(transform), m_half_dimensions(half_dimensions) - {} - - ~PhysicsAABBShape() override {} - - Vector3 getHalfDimensions() const { return m_half_dimensions; } - - private: - Vector3 m_half_dimensions; - }; -} // namespace Piccolo \ No newline at end of file diff --git a/engine/source/runtime/function/physics/physics_actor.cpp b/engine/source/runtime/function/physics/physics_actor.cpp deleted file mode 100644 index c1b3718bb..000000000 --- a/engine/source/runtime/function/physics/physics_actor.cpp +++ /dev/null @@ -1,146 +0,0 @@ -#include "runtime/function/physics/physics_actor.h" - -#include "runtime/core/base/macro.h" - -#include "runtime/function/framework/component/transform/transform_component.h" -#include "runtime/function/framework/object/object.h" - -namespace Piccolo -{ - PhysicsActor::PhysicsActor(std::weak_ptr gobject, const Transform& global_transform) : - m_parent_object {gobject}, m_global_transform {global_transform} - { - m_friction = 0.8f; - } - - PhysicsActor::~PhysicsActor() { m_rigidbody_shapes.clear(); } - - void PhysicsActor::createShapes(const std::vector& shape_defs, const Transform& global_transform) - { - m_rigidbody_shapes = shape_defs; - for (RigidBodyShape& shape : m_rigidbody_shapes) - { - const std::string shape_type = shape.m_geometry.getTypeName(); - if (shape_type == "Box") - { - Box* box_shape_geom = new Box; - - (*box_shape_geom) = *static_cast(shape.m_geometry.getPtr()); - - shape.m_geometry.getPtrReference() = box_shape_geom; - shape.m_type = RigidBodyShapeType::box; - } - else - { - LOG_ERROR("Unsupported shape type: " + shape_type); - continue; - } - } - } - - Vector3 PhysicsActor::getLinearVelocity() const { return m_linear_velocity; } - - void PhysicsActor::setLinearVelocity(const Vector3& velocity) { m_linear_velocity = velocity; } - - Vector3 PhysicsActor::getAngularVelocity() const { return m_angular_velocity; } - - void PhysicsActor::setAngularVelocity(const Vector3& velocity) { m_angular_velocity = velocity; } - - Vector3 PhysicsActor::getTorque() const { return m_torque; } - - void PhysicsActor::addTorque(const Vector3& torque) { m_torque += torque; } - - Vector3 PhysicsActor::getForce() const { return m_force; } - - void PhysicsActor::addForce(const Vector3& force) { m_force += force; } - - void PhysicsActor::addForceAtPosition(const Vector3& force, const Vector3& position) {} - - void PhysicsActor::clearForces() - { - m_force = Vector3::ZERO; - m_torque = Vector3::ZERO; - } - - void PhysicsActor::setInverseMass(float inverse_mass) { m_inverse_mass = inverse_mass; } - - float PhysicsActor::getInverseMass() const { return m_inverse_mass; } - - void PhysicsActor::applyLinearImpulse(const Vector3& force) { m_linear_velocity += force * m_inverse_mass; } - - void PhysicsActor::applyAngularImpulse(const Vector3& force) - { - m_angular_velocity += force * m_inverse_inertia_tensor; - } - - void PhysicsActor::initCubeInertia() - { - Vector3 dimensions = m_global_transform.m_scale * 2; - Vector3 square_dimension = dimensions * dimensions; - - m_inverse_inertia.x = (12.0f * m_inverse_mass) / (square_dimension.y + square_dimension.z); - m_inverse_inertia.y = (12.0f * m_inverse_mass) / (square_dimension.x + square_dimension.z); - m_inverse_inertia.z = (12.0f * m_inverse_mass) / (square_dimension.x + square_dimension.y); - } - - void PhysicsActor::initSphereInertia() - { - float radius = Vector3::getMaxElement(m_global_transform.m_scale); - float element = 2.5f * m_inverse_mass / (radius * radius); - - m_inverse_inertia = Vector3(element, element, element); - } - - void PhysicsActor::updateInertiaTensor() - { - Quaternion q = m_global_transform.m_rotation; - - Matrix3x3 inverse_orientation = Matrix3x3(q.conjugate()); - Matrix3x3 orientation = Matrix3x3(q); - - m_inverse_inertia_tensor = orientation * Matrix3x3::scale(m_inverse_inertia) * inverse_orientation; - } - - Matrix3x3 PhysicsActor::getInertiaTensor() const { return m_inverse_inertia_tensor; } - - void PhysicsActor::setGlobalTransform(const Transform& global_transform) - { - for (RigidBodyShape& shape : m_rigidbody_shapes) - { - if (shape.m_type == RigidBodyShapeType::box) - { - Matrix4x4 global_transform_matrix = global_transform.getMatrix() * shape.m_local_transform.getMatrix(); - global_transform_matrix.decomposition(shape.m_global_transform.m_position, - shape.m_global_transform.m_scale, - shape.m_global_transform.m_rotation); - - Box* box = static_cast(shape.m_geometry); - - AxisAlignedBox bounding; - for (unsigned char i = 0; i < 2; ++i) - { - for (unsigned char j = 0; j < 2; ++j) - { - for (unsigned char k = 0; k < 2; ++k) - { - Vector3 point = box->m_half_extents; - if (i == 0) - point.x = -point.x; - if (j == 0) - point.y = -point.y; - if (k == 0) - point.z = -point.z; - - point = shape.m_global_transform.getMatrix() * point; - - bounding.merge(point); - } - } - } - - shape.m_bounding_box.update(bounding.getCenter(), bounding.getHalfExtent()); - } - } - } - -} // namespace Piccolo \ No newline at end of file diff --git a/engine/source/runtime/function/physics/physics_actor.h b/engine/source/runtime/function/physics/physics_actor.h deleted file mode 100644 index 47630ab7a..000000000 --- a/engine/source/runtime/function/physics/physics_actor.h +++ /dev/null @@ -1,84 +0,0 @@ -#pragma once - -#include "runtime/core/math/matrix3.h" -#include "runtime/core/math/transform.h" -#include "runtime/core/math/vector3.h" - -#include "runtime/resource/res_type/components/rigid_body.h" - -#include - -namespace Piccolo -{ - class GObject; - class PhysicsActor - { - public: - PhysicsActor(std::weak_ptr gobject, const Transform& global_transform); - ~PhysicsActor(); - - void createShapes(const std::vector& shape_defs, const Transform& global_transform); - - Vector3 getLinearVelocity() const; - void setLinearVelocity(const Vector3& velocity); - - Vector3 getAngularVelocity() const; - void setAngularVelocity(const Vector3& velocity); - - Vector3 getTorque() const; - void addTorque(const Vector3& torque); - - Vector3 getForce() const; - void addForce(const Vector3& force); - void addForceAtPosition(const Vector3& force, const Vector3& position); - void clearForces(); - - void setInverseMass(float inverse_mass); - float getInverseMass() const; - - void applyLinearImpulse(const Vector3& force); - void applyAngularImpulse(const Vector3& force); - - void initCubeInertia(); - void initSphereInertia(); - - void updateInertiaTensor(); - Matrix3x3 getInertiaTensor() const; - - const std::vector& getShapes() const { return m_rigidbody_shapes; } - Transform& getTransform() { return m_global_transform; } - - std::weak_ptr getParentGO() const { return m_parent_object; } - - void setActorType(int type) { m_actor_type = type; } - int getActorType() const { return m_actor_type; } - - void setGlobalTransform(const Transform& global_transform); - - void setBodyID(uint32_t body_id) { m_body_id = body_id; } - uint32_t getBodyID() const { return m_body_id; } - - protected: - std::vector m_rigidbody_shapes; - - std::weak_ptr m_parent_object; - - Transform m_global_transform; - - float m_inverse_mass {0.f}; - float m_friction {0.f}; - - Vector3 m_linear_velocity; - Vector3 m_force; - - Vector3 m_angular_velocity; - Vector3 m_torque; - - Vector3 m_inverse_inertia; - Matrix3x3 m_inverse_inertia_tensor; - - int m_actor_type {0}; - - uint32_t m_body_id{0xffffffff}; - }; -}; // namespace Piccolo diff --git a/engine/source/runtime/function/physics/physics_obb_shape.h b/engine/source/runtime/function/physics/physics_obb_shape.h deleted file mode 100644 index c5c30d8f7..000000000 --- a/engine/source/runtime/function/physics/physics_obb_shape.h +++ /dev/null @@ -1,22 +0,0 @@ -#pragma once - -#include "runtime/function/physics/physics_shape_base.h" - -#include "runtime/core/math/vector3.h" - -namespace Piccolo -{ - class PhysicsOBBShape : public PhysicsShapeBase - { - public: - PhysicsOBBShape(const Transform& transform, const Vector3 half_dimensions) : - PhysicsShapeBase(transform), m_half_dimensions(half_dimensions) - {} - ~PhysicsOBBShape() override {} - - Vector3 getHalfDimensions() const { return m_half_dimensions; } - - private: - Vector3 m_half_dimensions; - }; -} // namespace Piccolo diff --git a/engine/source/runtime/function/physics/physics_scene.cpp b/engine/source/runtime/function/physics/physics_scene.cpp index faee1e42e..5e46a5fb7 100644 --- a/engine/source/runtime/function/physics/physics_scene.cpp +++ b/engine/source/runtime/function/physics/physics_scene.cpp @@ -23,6 +23,7 @@ #include "Jolt/Physics/Collision/RayCast.h" #include "Jolt/Physics/Collision/Shape/BoxShape.h" #include "Jolt/Physics/Collision/Shape/CapsuleShape.h" +#include "Jolt/Physics/Collision/Shape/CompoundShapeVisitors.h" #include "Jolt/Physics/Collision/Shape/SphereShape.h" #include "Jolt/Physics/Collision/Shape/StaticCompoundShape.h" #include "Jolt/Physics/Collision/ShapeCast.h" @@ -128,10 +129,10 @@ namespace Piccolo } JPH::Body* jph_body = body_interface.CreateBody(JPH::BodyCreationSettings(compund_shape_setting, - toVec3(global_transform.m_position), - toQuat(global_transform.m_rotation), - motion_type, - layer)); + toVec3(global_transform.m_position), + toQuat(global_transform.m_rotation), + motion_type, + layer)); if (jph_body == nullptr) { @@ -315,6 +316,39 @@ namespace Piccolo return collector.HadHit(); } + void PhysicsScene::getShapeBoundingBoxes(uint32_t body_id, std::vector& out_bounding_boxes) const + { + JPH::BodyLockRead body_lock(m_physics.m_jolt_physics_system->GetBodyLockInterface(), JPH::BodyID(body_id)); + const JPH::Body& body = body_lock.GetBody(); + + JPH::TransformedShape body_transformed_shape = body.GetTransformedShape(); + + struct Collector : JPH::TransformedShapeCollector + { + virtual void AddHit(const ResultType& inResult) override { mShapes.push_back(inResult); } + + std::vector mShapes; + }; + + Collector collector; + body_transformed_shape.CollectTransformedShapes(body_transformed_shape.GetWorldSpaceBounds(), collector); + + for (const JPH::TransformedShape& ts : collector.mShapes) + { + const JPH::Shape* shape = ts.mShape; + + assert(shape->GetType() == JPH::EShapeType::Convex); + + RigidBodyShape rigid_body_shape; + + JPH::AABox jph_bounding_box = ts.GetWorldSpaceBounds(); + Vector3 center = toVec3(jph_bounding_box.GetCenter()); + Vector3 extent = toVec3(jph_bounding_box.GetExtent()); + + out_bounding_boxes.emplace_back(center, extent); + } + } + #ifdef ENABLE_PHYSICS_DEBUG_RENDERER void PhysicsScene::drawPhysicsScene(JPH::DebugRenderer* debug_renderer) { diff --git a/engine/source/runtime/function/physics/physics_scene.h b/engine/source/runtime/function/physics/physics_scene.h index c556eb1a8..314bc1790 100644 --- a/engine/source/runtime/function/physics/physics_scene.h +++ b/engine/source/runtime/function/physics/physics_scene.h @@ -1,5 +1,7 @@ #pragma once +#include "runtime/core/math/axis_aligned.h" + #include "runtime/function/physics/physics_config.h" namespace JPH @@ -82,6 +84,8 @@ namespace Piccolo /// @return: true if overlapped with any rigidbodies bool isOverlap(const RigidBodyShape& shape, const Matrix4x4& global_transform); + void getShapeBoundingBoxes(uint32_t body_id, std::vector& out_bounding_boxes) const; + #ifdef ENABLE_PHYSICS_DEBUG_RENDERER void drawPhysicsScene(JPH::DebugRenderer* debug_renderer); #endif diff --git a/engine/source/runtime/function/physics/physics_shape_base.h b/engine/source/runtime/function/physics/physics_shape_base.h deleted file mode 100644 index 01a37cc65..000000000 --- a/engine/source/runtime/function/physics/physics_shape_base.h +++ /dev/null @@ -1,31 +0,0 @@ -#pragma once - -#include "runtime/core/math/transform.h" - -namespace Piccolo -{ - enum class ShapeType - { - aabb = 1, - obb = 2, - sphere = 3, - invalid = 255 - }; - - class PhysicsShapeBase - { - public: - PhysicsShapeBase(const Transform& local_tarnsform) : m_local_transform(local_tarnsform) {} - PhysicsShapeBase() {} - virtual ~PhysicsShapeBase() {} - - ShapeType getType() const { return m_type; } - void setType(ShapeType type) { m_type = type; } - - const Transform& getLocalTransform() const { return m_local_transform; } - - private: - ShapeType m_type {ShapeType::invalid}; - Transform m_local_transform ; - }; -} // namespace Piccolo \ No newline at end of file diff --git a/engine/source/runtime/function/physics/physics_sphere_shape.h b/engine/source/runtime/function/physics/physics_sphere_shape.h deleted file mode 100644 index 815f7eb56..000000000 --- a/engine/source/runtime/function/physics/physics_sphere_shape.h +++ /dev/null @@ -1,21 +0,0 @@ -#pragma once - -#include "runtime/function/physics/physics_shape_base.h" - -namespace Piccolo -{ - class PhysicsSphereShape : public PhysicsShapeBase - { - public: - PhysicsSphereShape(const Transform& transform, float radius) : PhysicsShapeBase(transform), m_radius(radius) - { - // PhysicsShapeBase::PhysicsShapeBase(transform); - } - ~PhysicsSphereShape() override {} - - float getRadius() const { return m_radius; } - - private: - float m_radius {0.f}; - }; -} // namespace Piccolo diff --git a/engine/source/runtime/function/physics/physics_system.cpp b/engine/source/runtime/function/physics/physics_system.cpp deleted file mode 100644 index 32db24f50..000000000 --- a/engine/source/runtime/function/physics/physics_system.cpp +++ /dev/null @@ -1,301 +0,0 @@ -#include "runtime/function/physics/physics_system.h" - -#include "runtime/function/framework/component/transform/transform_component.h" -#include "runtime/function/framework/object/object.h" -#include "runtime/function/physics/physics_actor.h" -#include "runtime/function/physics/physics_shape_base.h" - -#include - -namespace Piccolo -{ - void PhysicsSystem::tick(float delta_time) - { - m_delta_time = delta_time; - - m_delta_time_offset += m_delta_time; - - float iteration_delta_time = 1.0f / 120.0f; - - // If the physics engine cant catch up, it'll just have to run bigger timesteps. - if (m_delta_time_offset > 8 * iteration_delta_time) - { - iteration_delta_time = 1.0f / 15.0f; - } - else if (m_delta_time_offset > 4 * iteration_delta_time) - { - iteration_delta_time = 1.0f / 30.0f; - } - else if (m_delta_time_offset > 2 * iteration_delta_time) - { - iteration_delta_time = 1.0f / 60.0f; - } - - // int constraint_iteration_count = 10; - // iteration_delta_time = delta_time; - - while (m_delta_time_offset > iteration_delta_time) - { - integrateAccelerate(iteration_delta_time); // Update accelerations from external forces - - collideAndResolve(); - - updateCollisionList(); // Remove any old collisions - - integrateVelocity(iteration_delta_time); // update positions from new velocity changes - - m_delta_time_offset -= iteration_delta_time; - } - clearForces(); - } - - PhysicsActor* PhysicsSystem::createPhysicsActor(std::weak_ptr gobject, - const Transform& global_transform, - const RigidBodyComponentRes& rigid_body_actor_res) - { - PhysicsActor* actor = new PhysicsActor(gobject, global_transform); - - actor->createShapes(rigid_body_actor_res.m_shapes, global_transform); - actor->setInverseMass(rigid_body_actor_res.m_inverse_mass); - actor->setActorType(rigid_body_actor_res.m_actor_type); - Transform actor_transform(global_transform.m_position, global_transform.m_rotation, Vector3::UNIT_SCALE); - - actor->setGlobalTransform(actor_transform); - - m_physics_actors.push_back(actor); - - return actor; - } - - void PhysicsSystem::removePhyicsActor(PhysicsActor* actor) - { - auto iter = std::find(m_physics_actors.begin(), m_physics_actors.end(), actor); - if (iter != m_physics_actors.end()) - { - m_physics_actors.erase(iter); - delete actor; - } - } - - void PhysicsSystem::collideAndResolve() - { - CollisionInfo collision_info; - for (int i = 0; i < m_physics_actors.size(); ++i) - { - for (int j = i + 1; j < m_physics_actors.size(); ++j) - { - bool intersected = CollisionDetection::ObjectIntersection( - *m_physics_actors[i], *m_physics_actors[j], i, j, collision_info); - if (intersected == false) - continue; - - impulseResolveCollision(*m_physics_actors[i], *m_physics_actors[j], collision_info.m_contact_point); - collision_info.m_frame_left = m_num_collision_frames; - - m_all_collisions.insert(collision_info); - } - } - } - - bool PhysicsSystem::raycast(const Vector3& ray_start, const Vector3& ray_direction, Vector3& out_hit_position) - { - bool is_hit = false; - - Ray ray(ray_start, ray_direction); - float distance = FLT_MAX; - for (int i = 0; i < m_physics_actors.size(); ++i) - { - RayCollision collision; - is_hit = CollisionDetection::RayIntersection(ray, *m_physics_actors[i], collision); - if (is_hit) - { - if (collision.m_ray_distance < distance) - { - distance = collision.m_ray_distance; - out_hit_position = collision.m_collided_point; - } - } - } - - return is_hit; - } - - bool PhysicsSystem::overlapByCapsule(const Vector3& position, const Capsule& capsule) - { - // currently only overlap by aabb - const float capsule_height = capsule.m_half_height + capsule.m_radius; - Vector3 center = position + capsule_height * Vector3::UNIT_Z; - Vector3 half_extent = Vector3(capsule.m_radius, capsule.m_radius, capsule_height); - AxisAlignedBox bounding(center, half_extent); - return isOverlap(bounding); - } - - bool PhysicsSystem::isOverlap(const AxisAlignedBox& query_bouding) - { - for (int i = 0; i < m_physics_actors.size(); i++) - { - for (auto& shape : m_physics_actors[i]->getShapes()) - { - if (shape.m_type == RigidBodyShapeType::invalid) - continue; - - bool is_hit = CollisionDetection::IsAABBOverlapped(query_bouding, shape.m_bounding_box); - - if (is_hit) - return true; - } - } - - return false; - } - - void PhysicsSystem::clearForces() - { - for (auto& object_iter : m_physics_actors) - { - object_iter->clearForces(); - } - } - - void PhysicsSystem::integrateAccelerate(float delta_time) - { - for (auto& object_iter : m_physics_actors) - { - float inverse_mass = object_iter->getInverseMass(); - - Vector3 linear_velocity = object_iter->getLinearVelocity(); - Vector3 force = object_iter->getForce(); - Vector3 accel = force * inverse_mass; - - if (m_is_use_gravity && inverse_mass > 0) - { - accel = accel + m_gravity; - } - - linear_velocity = linear_velocity + accel * delta_time; - object_iter->setLinearVelocity(linear_velocity); - - Vector3 torque = object_iter->getTorque(); - Vector3 angular_velocity = object_iter->getAngularVelocity(); - - object_iter->updateInertiaTensor(); // update tensor vs orientation - - Vector3 angular_accelerate = object_iter->getInertiaTensor() * torque; - - angular_velocity = angular_velocity + angular_accelerate * delta_time; // integrate angular accel - object_iter->setAngularVelocity(angular_velocity); - } - } - - void PhysicsSystem::integrateVelocity(float delta_time) - { - float frame_damping = powf(m_global_damping, delta_time); - - for (auto& object_iter : m_physics_actors) - { - Transform& transform = object_iter->getTransform(); - - Vector3 linear_velocity = object_iter->getLinearVelocity(); - transform.m_position += linear_velocity * delta_time; - - linear_velocity = linear_velocity * frame_damping; - object_iter->setLinearVelocity(linear_velocity); - - Quaternion& orientation = transform.m_rotation; - Vector3 angular_velocity = object_iter->getAngularVelocity(); - - Quaternion delta_angular {(angular_velocity * delta_time * 0.5f).x, - (angular_velocity * delta_time * 0.5f).y, - (angular_velocity * delta_time * 0.5f).z, - 0.0f}; - orientation = orientation + (delta_angular * orientation); - orientation.normalise(); - - angular_velocity = angular_velocity * frame_damping; - object_iter->setAngularVelocity(angular_velocity); - - // Vector3 pos = m_objects[i].getTransform()->getLocalPosition(); - // std::cout << "actor id : " << i++ << " after tick pos: " << pos.x << " " << pos.y << " " << pos.z << - // std::endl; - } - } - - void PhysicsSystem::updateCollisionList() - { - for (auto iter = m_all_collisions.begin(); iter != m_all_collisions.end();) - { - if (iter->m_frame_left == m_num_collision_frames) - { - // iter->m_actor_a->onCollisionBegin(iter->m_actor_b); - // iter->m_actor_b->onCollisionEnd(iter->m_actor_a); - // PMLog("collision between " + iter->m_id_a + iter->m_id_b); - } - - iter->m_frame_left = iter->m_frame_left - 1; - - if (iter->m_frame_left < 0) - { - // iter->m_actor_a->onCollisionBegin(iter->m_actor_b); - // iter->m_actor_b->onCollisionEnd(iter->m_actor_a); - // PMLog("collision between " + iter->m_id_a + iter->m_id_b); - iter = m_all_collisions.erase(iter); - } - else - { - ++iter; - } - } - } - - void PhysicsSystem::impulseResolveCollision(PhysicsActor& actor_a, - PhysicsActor& actor_b, - ContactPoint& contact_point) const - { - float total_mass = actor_a.getInverseMass() + actor_b.getInverseMass(); - - if (total_mass == 0) - { - return; - } - - Transform& transform_a = actor_a.getTransform(); - Transform& transform_b = actor_b.getTransform(); - - transform_a.m_position -= - contact_point.m_normal * contact_point.m_penetration * (actor_a.getInverseMass() / total_mass); - transform_b.m_position += - contact_point.m_normal * contact_point.m_penetration * (actor_a.getInverseMass() / total_mass); - - Vector3 relative_a = contact_point.m_location_a; - Vector3 relative_b = contact_point.m_location_b; - - Vector3 ang_velocity_a = actor_a.getAngularVelocity().crossProduct(relative_a); - Vector3 ang_velocity_b = actor_b.getAngularVelocity().crossProduct(relative_b); - - Vector3 full_velocity_a = actor_a.getLinearVelocity() + ang_velocity_a; - Vector3 full_velocity_b = actor_b.getLinearVelocity() + ang_velocity_b; - - Vector3 contact_velocity = full_velocity_b - full_velocity_a; - - float impulse_force = contact_velocity.dotProduct(contact_point.m_normal); - - Vector3 inertia_a = - (actor_a.getInertiaTensor() * relative_a.crossProduct(contact_point.m_normal)).crossProduct(relative_a); - Vector3 inertia_b = - (actor_b.getInertiaTensor() * relative_b.crossProduct(contact_point.m_normal)).crossProduct(relative_b); - - float angular_effect = (inertia_a + inertia_b).dotProduct(contact_point.m_normal); - - float restitution = 0; // 0.66f; // disperse some kinectic energy - - float impulse = (-(1.0f + restitution) * impulse_force) / (total_mass + angular_effect); - - Vector3 fullImpulse = contact_point.m_normal * impulse; - - actor_a.applyLinearImpulse(-fullImpulse); - actor_b.applyLinearImpulse(fullImpulse); - - actor_a.applyAngularImpulse(relative_a.crossProduct(-fullImpulse)); - actor_b.applyAngularImpulse(relative_b.crossProduct(fullImpulse)); - } -} // namespace Piccolo \ No newline at end of file diff --git a/engine/source/runtime/function/physics/physics_system.h b/engine/source/runtime/function/physics/physics_system.h deleted file mode 100644 index d9e13f873..000000000 --- a/engine/source/runtime/function/physics/physics_system.h +++ /dev/null @@ -1,58 +0,0 @@ -#pragma once - -#include "runtime/core/math/transform.h" - -#include "runtime/function/physics/collision_detection.h" -#include "runtime/function/physics/physics_actor.h" - -#include "runtime/resource/res_type/components/rigid_body.h" - -#include - -namespace Piccolo -{ - /// This Physics System is legacy, will be removed lated - class PhysicsSystem - { - public: - void tick(float delta_time); - - void setIsUseGravity(bool is_use_gravity) { m_is_use_gravity = is_use_gravity; } - void setGravity(const Vector3& g) { m_gravity = g; } - void setGlobalDamping(float damping) { m_global_damping = damping; } - - PhysicsActor* createPhysicsActor(std::weak_ptr gobject, - const Transform& global_transform, - const RigidBodyComponentRes& rigid_body_actor_res); - void removePhyicsActor(PhysicsActor* gobject); - - bool raycast(const Vector3& ray_start, const Vector3& ray_direction, Vector3& out_hit_position); - bool overlapByCapsule(const Vector3& position, const Capsule& capsule); - - protected: - void collideAndResolve(); - - void clearForces(); - - void integrateAccelerate(float delta_time); - void integrateVelocity(float delta_time); - - void updateCollisionList(); - - void impulseResolveCollision(PhysicsActor& object_a, PhysicsActor& object_b, ContactPoint& contact_point) const; - - bool isOverlap(const AxisAlignedBox& query_bouding); - - private: - std::vector m_physics_actors; - std::set m_all_collisions; - - unsigned int m_num_collision_frames {5}; - float m_delta_time_offset {0.f}; - float m_global_damping {0.95f}; - float m_delta_time {0.f}; - - Vector3 m_gravity {0.0f, 0.0f, -9.8f}; - bool m_is_use_gravity {true}; - }; -} // namespace Piccolo \ No newline at end of file diff --git a/engine/source/runtime/function/physics/ray.cpp b/engine/source/runtime/function/physics/ray.cpp deleted file mode 100644 index 364d71750..000000000 --- a/engine/source/runtime/function/physics/ray.cpp +++ /dev/null @@ -1,17 +0,0 @@ -#include "runtime/function/physics/ray.h" - -namespace Piccolo -{ - Ray::Ray(Vector3 start_point, Vector3 direction) - { - m_start_point = start_point; - m_direction = direction; - } - - Ray::~Ray() {} - - Vector3 Ray::getStartPoint() const { return m_start_point; } - - Vector3 Ray::getDirection() const { return m_direction; } - -} // namespace Piccolo diff --git a/engine/source/runtime/function/physics/ray.h b/engine/source/runtime/function/physics/ray.h deleted file mode 100644 index 73211240c..000000000 --- a/engine/source/runtime/function/physics/ray.h +++ /dev/null @@ -1,40 +0,0 @@ -#pragma once - -#include "runtime/core/math/vector3.h" - -namespace Piccolo -{ - struct RayCollision - { - void* m_node; - Vector3 m_collided_point; - float m_ray_distance; - - RayCollision(void* node, Vector3 collided_point) - { - this->m_node = node; - this->m_collided_point = collided_point; - this->m_ray_distance = 0.0f; - } - - RayCollision() - { - m_node = nullptr; - m_ray_distance = FLT_MAX; - } - }; - - class Ray - { - public: - Ray(Vector3 start_point, Vector3 direction); - ~Ray(); - - Vector3 getStartPoint() const; - Vector3 getDirection() const; - - private: - Vector3 m_start_point; - Vector3 m_direction; - }; -} // namespace Piccolo \ No newline at end of file diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_buffer.cpp b/engine/source/runtime/function/render/debugdraw/debug_draw_buffer.cpp new file mode 100644 index 000000000..dc22d58e0 --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_buffer.cpp @@ -0,0 +1,569 @@ +#include "debug_draw_buffer.h" +#include +#include "runtime/function/global/global_context.h" +#include "runtime/function/render/render_system.h" + +namespace Piccolo +{ + void DebugDrawAllocator::initialize(DebugDrawFont* font) + { + m_rhi = g_runtime_global_context.m_render_system->getRHI(); + m_font = font; + setupDescriptorSet(); + } + void DebugDrawAllocator::destory() + { + clear(); + unloadMeshBuffer(); + } + + void DebugDrawAllocator::tick() + { + flushPendingDelete(); + m_current_frame = (m_current_frame + 1) % k_deferred_delete_resource_frame_count; + } + + RHIBuffer* DebugDrawAllocator::getVertexBuffer(){return m_vertex_resource.buffer;} + RHIDescriptorSet* &DebugDrawAllocator::getDescriptorSet() { return m_descriptor.descriptor_set[m_rhi->getCurrentFrameIndex()]; } + + size_t DebugDrawAllocator::cacheVertexs(const std::vector& vertexs) + { + size_t offset = m_vertex_cache.size(); + m_vertex_cache.resize(offset + vertexs.size()); + for (size_t i = 0; i < vertexs.size(); i++) + { + m_vertex_cache[i + offset] = vertexs[i]; + } + return offset; + } + void DebugDrawAllocator::cacheUniformObject(Matrix4x4 proj_view_matrix) + { + m_uniform_buffer_object.proj_view_matrix = proj_view_matrix; + } + size_t DebugDrawAllocator::cacheUniformDynamicObject(const std::vector >& model_colors) + { + size_t offset = m_uniform_buffer_dynamic_object_cache.size(); + m_uniform_buffer_dynamic_object_cache.resize(offset + model_colors.size()); + for (size_t i = 0; i < model_colors.size(); i++) + { + m_uniform_buffer_dynamic_object_cache[i + offset].model_matrix = model_colors[i].first; + m_uniform_buffer_dynamic_object_cache[i + offset].color = model_colors[i].second; + } + return offset; + } + + size_t DebugDrawAllocator::getVertexCacheOffset() const + { + return m_vertex_cache.size(); + } + size_t DebugDrawAllocator::getUniformDynamicCacheOffset() const + { + return m_uniform_buffer_dynamic_object_cache.size(); + } + + void DebugDrawAllocator::allocator() + { + + clearBuffer(); + uint64_t vertex_bufferSize = static_cast(m_vertex_cache.size() * sizeof(DebugDrawVertex)); + if (vertex_bufferSize > 0) + { + m_rhi->createBuffer( + vertex_bufferSize, + RHI_BUFFER_USAGE_VERTEX_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + m_vertex_resource.buffer, + m_vertex_resource.memory); + + void* data; + m_rhi->mapMemory(m_vertex_resource.memory, 0, vertex_bufferSize, 0, &data); + memcpy(data, m_vertex_cache.data(), vertex_bufferSize); + m_rhi->unmapMemory(m_vertex_resource.memory); + } + + uint64_t uniform_BufferSize = static_cast(sizeof(UniformBufferObject)); + if (uniform_BufferSize > 0) + { + m_rhi->createBuffer( + uniform_BufferSize, + RHI_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + m_uniform_resource.buffer, + m_uniform_resource.memory); + + void* data; + m_rhi->mapMemory(m_uniform_resource.memory, 0, uniform_BufferSize, 0, &data); + memcpy(data, &m_uniform_buffer_object.proj_view_matrix, uniform_BufferSize); + m_rhi->unmapMemory(m_uniform_resource.memory); + } + + uint64_t uniform_dynamic_BufferSize = static_cast(sizeof(UniformBufferDynamicObject) * m_uniform_buffer_dynamic_object_cache.size()); + if (uniform_dynamic_BufferSize > 0) + { + m_rhi->createBuffer( + uniform_dynamic_BufferSize, + RHI_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + m_uniform_dynamic_resource.buffer, + m_uniform_dynamic_resource.memory); + + void* data; + m_rhi->mapMemory(m_uniform_dynamic_resource.memory, 0, uniform_dynamic_BufferSize, 0, &data); + memcpy(data, m_uniform_buffer_dynamic_object_cache.data(), uniform_dynamic_BufferSize); + m_rhi->unmapMemory(m_uniform_dynamic_resource.memory); + } + + updateDescriptorSet(); + } + + void DebugDrawAllocator::clear() + { + clearBuffer(); + m_vertex_cache.clear(); + m_uniform_buffer_object.proj_view_matrix = Matrix4x4::IDENTITY; + m_uniform_buffer_dynamic_object_cache.clear(); + } + + void DebugDrawAllocator::clearBuffer() + { + if (m_vertex_resource.buffer) + { + m_deffer_delete_queue[m_current_frame].push(m_vertex_resource); + m_vertex_resource.buffer = nullptr; + m_vertex_resource.memory = nullptr; + } + if (m_uniform_resource.buffer) + { + m_deffer_delete_queue[m_current_frame].push(m_uniform_resource); + m_uniform_resource.buffer = nullptr; + m_uniform_resource.memory = nullptr; + } + if (m_uniform_dynamic_resource.buffer) + { + m_deffer_delete_queue[m_current_frame].push(m_uniform_dynamic_resource); + m_uniform_dynamic_resource.buffer = nullptr; + m_uniform_dynamic_resource.memory = nullptr; + } + } + + void DebugDrawAllocator::flushPendingDelete() + { + uint32_t current_frame_to_delete = (m_current_frame + 1) % k_deferred_delete_resource_frame_count; + while (!m_deffer_delete_queue[current_frame_to_delete].empty()) + { + Resource resource_to_delete = m_deffer_delete_queue[current_frame_to_delete].front(); + m_deffer_delete_queue[current_frame_to_delete].pop(); + if (resource_to_delete.buffer == nullptr)continue; + m_rhi->freeMemory(resource_to_delete.memory); + m_rhi->destroyBuffer(resource_to_delete.buffer); + } + } + + void DebugDrawAllocator::setupDescriptorSet() + { + RHIDescriptorSetLayoutBinding uboLayoutBinding[3]; + uboLayoutBinding[0].binding = 0; + uboLayoutBinding[0].descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + uboLayoutBinding[0].descriptorCount = 1; + uboLayoutBinding[0].stageFlags = RHI_SHADER_STAGE_VERTEX_BIT; + uboLayoutBinding[0].pImmutableSamplers = nullptr; + + uboLayoutBinding[1].binding = 1; + uboLayoutBinding[1].descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; + uboLayoutBinding[1].descriptorCount = 1; + uboLayoutBinding[1].stageFlags = RHI_SHADER_STAGE_VERTEX_BIT; + uboLayoutBinding[1].pImmutableSamplers = nullptr; + + uboLayoutBinding[2].binding = 2; + uboLayoutBinding[2].descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + uboLayoutBinding[2].descriptorCount = 1; + uboLayoutBinding[2].stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; + uboLayoutBinding[2].pImmutableSamplers = nullptr; + + RHIDescriptorSetLayoutCreateInfo layoutInfo{}; + layoutInfo.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + layoutInfo.bindingCount = 3; + layoutInfo.pBindings = uboLayoutBinding; + + if (m_rhi->createDescriptorSetLayout(&layoutInfo, m_descriptor.layout) != RHI_SUCCESS) + { + throw std::runtime_error("create debug draw layout"); + } + + m_descriptor.descriptor_set.resize(m_rhi->getMaxFramesInFlight()); + for (size_t i = 0; i < m_rhi->getMaxFramesInFlight(); i++) + { + RHIDescriptorSetAllocateInfo allocInfo{}; + allocInfo.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + allocInfo.pNext = NULL; + allocInfo.descriptorPool = m_rhi->getDescriptorPoor(); + allocInfo.descriptorSetCount = 1; + allocInfo.pSetLayouts = &m_descriptor.layout; + + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&allocInfo, m_descriptor.descriptor_set[i])) + { + throw std::runtime_error("debug draw descriptor set"); + } + } + + prepareDescriptorSet(); + } + + //prepare at the start tick + void DebugDrawAllocator::prepareDescriptorSet() + { + RHIDescriptorImageInfo image_info[1]; + image_info[0].imageView = m_font->getImageView(); + image_info[0].sampler = m_rhi->getOrCreateDefaultSampler(Default_Sampler_Linear); + image_info[0].imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + for (size_t i = 0; i < m_rhi->getMaxFramesInFlight(); i++) + { + RHIWriteDescriptorSet descriptor_write[1]; + descriptor_write[0].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptor_write[0].dstSet = m_descriptor.descriptor_set[i]; + descriptor_write[0].dstBinding = 2; + descriptor_write[0].dstArrayElement = 0; + descriptor_write[0].pNext = nullptr; + descriptor_write[0].descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + descriptor_write[0].descriptorCount = 1; + descriptor_write[0].pBufferInfo = nullptr; + descriptor_write[0].pImageInfo = &image_info[0]; + descriptor_write[0].pTexelBufferView = nullptr; + + m_rhi->updateDescriptorSets(1, descriptor_write, 0, nullptr); + } + } + + //update every tick + void DebugDrawAllocator::updateDescriptorSet() + { + RHIDescriptorBufferInfo buffer_info[2]; + buffer_info[0].buffer = m_uniform_resource.buffer; + buffer_info[0].offset = 0; + buffer_info[0].range = sizeof(UniformBufferObject); + + buffer_info[1].buffer = m_uniform_dynamic_resource.buffer; + buffer_info[1].offset = 0; + buffer_info[1].range = sizeof(UniformBufferDynamicObject); + + RHIWriteDescriptorSet descriptor_write[2]; + descriptor_write[0].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptor_write[0].dstSet = m_descriptor.descriptor_set[m_rhi->getCurrentFrameIndex()]; + descriptor_write[0].dstBinding = 0; + descriptor_write[0].dstArrayElement = 0; + descriptor_write[0].pNext = nullptr; + descriptor_write[0].descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + descriptor_write[0].descriptorCount = 1; + descriptor_write[0].pBufferInfo = &buffer_info[0]; + descriptor_write[0].pImageInfo = nullptr; + descriptor_write[0].pTexelBufferView = nullptr; + + descriptor_write[1].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptor_write[1].dstSet = m_descriptor.descriptor_set[m_rhi->getCurrentFrameIndex()]; + descriptor_write[1].dstBinding = 1; + descriptor_write[1].dstArrayElement = 0; + descriptor_write[1].pNext = nullptr; + descriptor_write[1].descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; + descriptor_write[1].descriptorCount = 1; + descriptor_write[1].pBufferInfo = &buffer_info[1]; + descriptor_write[1].pImageInfo = nullptr; + descriptor_write[1].pTexelBufferView = nullptr; + + m_rhi->updateDescriptorSets(2, descriptor_write, 0, nullptr); + } + + void DebugDrawAllocator::unloadMeshBuffer() + { + m_deffer_delete_queue[m_current_frame].push(m_sphere_resource); + m_sphere_resource.buffer = nullptr; + m_sphere_resource.memory = nullptr; + m_deffer_delete_queue[m_current_frame].push(m_cylinder_resource); + m_cylinder_resource.buffer = nullptr; + m_cylinder_resource.memory = nullptr; + m_deffer_delete_queue[m_current_frame].push(m_capsule_resource); + m_capsule_resource.buffer = nullptr; + m_capsule_resource.memory = nullptr; + } + + void DebugDrawAllocator::loadSphereMeshBuffer() + { + int32_t param = m_circle_sample_count; + //radios is 1 + float _2pi = 2.0f * Math_PI; + std::vector vertexs((param * 2 + 2) * (param * 2) * 2 + (param * 2 + 1) * (param * 2) * 2); + + int32_t current_index = 0; + for (int32_t i = -param - 1; i < param + 1; i++) + { + float h = Math::sin(_2pi / 4.0f * i / (param + 1.0f)); + float h1 = Math::sin(_2pi / 4.0f * (i + 1) / (param + 1.0f)); + float r = Math::sqrt(1.0f - h * h); + float r1 = Math::sqrt(1.0f - h1 * h1); + for (int32_t j = 0; j < 2 * param; j++) + { + Vector3 p(Math::cos(_2pi / (2.0f * param) * j) * r, Math::sin(_2pi / (2.0f * param) * j) * r, h); + Vector3 p1(Math::cos(_2pi / (2.0f * param) * j) * r1, Math::sin(_2pi / (2.0f * param) * j) * r1, h1); + vertexs[current_index].pos = p; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + + vertexs[current_index].pos = p1; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + } + if (i != -param - 1) + { + for (int32_t j = 0; j < 2 * param; j++) + { + Vector3 p(Math::cos(_2pi / (2.0f * param) * j) * r, Math::sin(_2pi / (2.0f * param) * j) * r, h); + Vector3 p1(Math::cos(_2pi / (2.0f * param) * (j + 1)) * r, Math::sin(_2pi / (2.0f * param) * (j + 1)) * r, h); + vertexs[current_index].pos = p; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + + vertexs[current_index].pos = p1; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + } + } + } + + uint64_t bufferSize = static_cast(vertexs.size() * sizeof(DebugDrawVertex)); + + m_rhi->createBuffer( + bufferSize, + RHI_BUFFER_USAGE_VERTEX_BUFFER_BIT | RHI_BUFFER_USAGE_TRANSFER_DST_BIT, + VMA_MEMORY_USAGE_GPU_ONLY, + m_sphere_resource.buffer, + m_sphere_resource.memory); + + Resource stagingBuffer; + m_rhi->createBuffer( + bufferSize, + RHI_BUFFER_USAGE_TRANSFER_SRC_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + stagingBuffer.buffer, + stagingBuffer.memory); + void* data; + m_rhi->mapMemory(stagingBuffer.memory, 0, bufferSize, 0, &data); + memcpy(data, vertexs.data(), bufferSize); + m_rhi->unmapMemory(stagingBuffer.memory); + + m_rhi->copyBuffer(stagingBuffer.buffer, m_sphere_resource.buffer, 0, 0, bufferSize); + + m_rhi->destroyBuffer(stagingBuffer.buffer); + m_rhi->freeMemory(stagingBuffer.memory); + } + + void DebugDrawAllocator::loadCylinderMeshBuffer() + { + int param = m_circle_sample_count; + //radios is 1 , height is 2 + float _2pi = 2.0f * Math_PI; + std::vector vertexs(2 * param * 5 * 2); + + size_t current_index = 0; + for (int32_t i = 0; i < 2 * param; i++) + { + Vector3 p(Math::cos(_2pi / (2.0f * param) * i), Math::sin(_2pi / (2.0f * param) * i), 1.0f); + Vector3 p_(Math::cos(_2pi / (2.0f * param) * (i + 1)), Math::sin(_2pi / (2.0f * param) * (i + 1)), 1.0f); + Vector3 p1(Math::cos(_2pi / (2.0f * param) * i), Math::sin(_2pi / (2.0f * param) * i), -1.0f); + Vector3 p1_(Math::cos(_2pi / (2.0f * param) * (i + 1)), Math::sin(_2pi / (2.0f * param) * (i + 1)), -1.0f); + + vertexs[current_index].pos = p; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + vertexs[current_index].pos = p_; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + + vertexs[current_index].pos = p1; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + vertexs[current_index].pos = p1_; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + + vertexs[current_index].pos = p; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + vertexs[current_index].pos = p1; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + + vertexs[current_index].pos = p; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + vertexs[current_index].pos = Vector3(0.0f, 0.0f, 1.0f); + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + + vertexs[current_index].pos = p1; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + vertexs[current_index].pos = Vector3(0.0f, 0.0f, -1.0f); + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + } + + uint64_t bufferSize = static_cast(vertexs.size() * sizeof(DebugDrawVertex)); + + m_rhi->createBuffer( + bufferSize, + RHI_BUFFER_USAGE_VERTEX_BUFFER_BIT | RHI_BUFFER_USAGE_TRANSFER_DST_BIT, + VMA_MEMORY_USAGE_GPU_ONLY, + m_cylinder_resource.buffer, + m_cylinder_resource.memory); + + Resource stagingBuffer; + m_rhi->createBuffer( + bufferSize, + RHI_BUFFER_USAGE_TRANSFER_SRC_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + stagingBuffer.buffer, + stagingBuffer.memory); + void* data; + m_rhi->mapMemory(stagingBuffer.memory, 0, bufferSize, 0, &data); + memcpy(data, vertexs.data(), bufferSize); + m_rhi->unmapMemory(stagingBuffer.memory); + + m_rhi->copyBuffer(stagingBuffer.buffer, m_cylinder_resource.buffer, 0, 0, bufferSize); + + m_rhi->destroyBuffer(stagingBuffer.buffer); + m_rhi->freeMemory(stagingBuffer.memory); + } + + void DebugDrawAllocator::loadCapsuleMeshBuffer() + { + int param = m_circle_sample_count; + //radios is 1,height is 4 + float _2pi = 2.0f * Math_PI; + std::vector vertexs(2 * param * param * 4 + 2 * param * param * 4 + 2 * param * 2); + + size_t current_index = 0; + for (int32_t i = 0; i < param; i++) + { + float h = Math::sin(_2pi / 4.0 / param * i); + float h1 = Math::sin(_2pi / 4.0 / param * (i + 1)); + float r = Math::sqrt(1 - h * h); + float r1 = Math::sqrt(1 - h1 * h1); + for (int32_t j = 0; j < 2 * param; j++) + { + Vector3 p(Math::cos(_2pi / (2.0f * param) * j) * r, Math::sin(_2pi / (2.0f * param) * j) * r, h + 1.0f); + Vector3 p_(Math::cos(_2pi / (2.0f * param) * (j + 1)) * r, Math::sin(_2pi / (2.0f * param) * (j + 1)) * r, h + 1.0f); + Vector3 p1(Math::cos(_2pi / (2.0f * param) * j) * r1, Math::sin(_2pi / (2.0f * param) * j) * r1, h1 + 1.0f); + vertexs[current_index].pos = p; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + vertexs[current_index].pos = p1; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + + vertexs[current_index].pos = p; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + vertexs[current_index].pos = p_; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + } + } + + for (int32_t j = 0; j < 2 * param; j++) + { + Vector3 p(Math::cos(_2pi / (2.0f * param) * j), Math::sin(_2pi / (2.0f * param) * j), 1.0f); + Vector3 p1(Math::cos(_2pi / (2.0f * param) * j), Math::sin(_2pi / (2.0f * param) * j), -1.0f); + vertexs[current_index].pos = p; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + vertexs[current_index].pos = p1; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + } + + for (int32_t i = 0; i > -param ; i--) + { + float h = Math::sin(_2pi / 4.0f / param * i); + float h1 = Math::sin(_2pi / 4.0f / param * (i - 1)); + float r = Math::sqrt(1 - h * h); + float r1 = Math::sqrt(1 - h1 * h1); + for (int32_t j = 0; j < (2 * param); j++) + { + Vector3 p(Math::cos(_2pi / (2.0f * param) * j) * r, Math::sin(_2pi / (2.0f * param) * j) * r, h - 1.0f); + Vector3 p_(Math::cos(_2pi / (2.0f * param) * (j + 1)) * r, Math::sin(_2pi / (2.0f * param) * (j + 1)) * r, h - 1.0f); + Vector3 p1(Math::cos(_2pi / (2.0f * param) * j) * r1, Math::sin(_2pi / (2.0f * param) * j) * r1, h1 - 1.0f); + vertexs[current_index].pos = p; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + vertexs[current_index].pos = p1; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + + vertexs[current_index].pos = p; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + vertexs[current_index].pos = p_; + vertexs[current_index++].color = Vector4(1.0f, 0.0f, 0.0f, 1.0f); + } + } + + uint64_t bufferSize = static_cast(vertexs.size() * sizeof(DebugDrawVertex)); + + m_rhi->createBuffer( + bufferSize, + RHI_BUFFER_USAGE_VERTEX_BUFFER_BIT | RHI_BUFFER_USAGE_TRANSFER_DST_BIT, + VMA_MEMORY_USAGE_GPU_ONLY, + m_capsule_resource.buffer, + m_capsule_resource.memory); + + Resource stagingBuffer; + m_rhi->createBuffer( + bufferSize, + RHI_BUFFER_USAGE_TRANSFER_SRC_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + stagingBuffer.buffer, + stagingBuffer.memory); + void* data; + m_rhi->mapMemory(stagingBuffer.memory, 0, bufferSize, 0, &data); + memcpy(data, vertexs.data(), bufferSize); + m_rhi->unmapMemory(stagingBuffer.memory); + + m_rhi->copyBuffer(stagingBuffer.buffer, m_capsule_resource.buffer, 0, 0, bufferSize); + + m_rhi->destroyBuffer(stagingBuffer.buffer); + m_rhi->freeMemory(stagingBuffer.memory); + } + + + RHIBuffer* DebugDrawAllocator::getSphereVertexBuffer() + { + if (m_sphere_resource.buffer == nullptr) + { + loadSphereMeshBuffer(); + } + return m_sphere_resource.buffer; + } + RHIBuffer* DebugDrawAllocator::getCylinderVertexBuffer() + { + if (m_cylinder_resource.buffer == nullptr) + { + loadCylinderMeshBuffer(); + } + return m_cylinder_resource.buffer; + } + RHIBuffer* DebugDrawAllocator::getCapsuleVertexBuffer() + { + if (m_capsule_resource.buffer == nullptr) + { + loadCapsuleMeshBuffer(); + } + return m_capsule_resource.buffer; + } + + const size_t DebugDrawAllocator::getSphereVertexBufferSize() const + { + return ((m_circle_sample_count * 2 + 2) * (m_circle_sample_count * 2) * 2 + (m_circle_sample_count * 2 + 1) * (m_circle_sample_count * 2) * 2); + } + const size_t DebugDrawAllocator::getCylinderVertexBufferSize() const + { + return (m_circle_sample_count * 2) * 5 * 2; + } + const size_t DebugDrawAllocator::getCapsuleVertexBufferSize() const + { + return (m_circle_sample_count * 2) * m_circle_sample_count * 4 + (2 * m_circle_sample_count) * 2 + (2 * m_circle_sample_count) * m_circle_sample_count * 4; + } + const size_t DebugDrawAllocator::getCapsuleVertexBufferUpSize() const + { + return (m_circle_sample_count * 2) * m_circle_sample_count * 4; + } + const size_t DebugDrawAllocator::getCapsuleVertexBufferMidSize() const + { + return 2 * m_circle_sample_count * 2; + } + const size_t DebugDrawAllocator::getCapsuleVertexBufferDownSize() const + { + return 2 * m_circle_sample_count * m_circle_sample_count * 4; + } + + const size_t DebugDrawAllocator::getSizeOfUniformBufferObject() const + { + return sizeof(UniformBufferDynamicObject); + } +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_buffer.h b/engine/source/runtime/function/render/debugdraw/debug_draw_buffer.h new file mode 100644 index 000000000..53cb15aaf --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_buffer.h @@ -0,0 +1,105 @@ +#pragma once + +#include "runtime/function/render/interface/rhi.h" +#include "debug_draw_primitive.h" +#include "debug_draw_font.h" + +#include +namespace Piccolo +{ + class DebugDrawAllocator + { + public: + DebugDrawAllocator() {}; + void initialize(DebugDrawFont* font); + void destory(); + void tick(); + void clear(); + void clearBuffer(); + + size_t cacheVertexs(const std::vector& vertexs); + void cacheUniformObject(Matrix4x4 proj_view_matrix); + size_t cacheUniformDynamicObject(const std::vector >& model_colors); + + size_t getVertexCacheOffset() const; + size_t getUniformDynamicCacheOffset() const; + void allocator(); + + RHIBuffer* getVertexBuffer(); + RHIDescriptorSet* &getDescriptorSet(); + + RHIBuffer* getSphereVertexBuffer(); + RHIBuffer* getCylinderVertexBuffer(); + RHIBuffer* getCapsuleVertexBuffer(); + + const size_t getSphereVertexBufferSize() const; + const size_t getCylinderVertexBufferSize() const; + const size_t getCapsuleVertexBufferSize() const; + const size_t getCapsuleVertexBufferUpSize() const; + const size_t getCapsuleVertexBufferMidSize() const; + const size_t getCapsuleVertexBufferDownSize() const; + + const size_t getSizeOfUniformBufferObject() const; + private: + std::shared_ptr m_rhi; + struct UniformBufferObject + { + Matrix4x4 proj_view_matrix; + }; + + struct alignas(256) UniformBufferDynamicObject + { + Matrix4x4 model_matrix; + Vector4 color; + }; + + struct Resource + { + RHIBuffer* buffer = nullptr; + RHIDeviceMemory* memory = nullptr; + }; + struct Descriptor + { + RHIDescriptorSetLayout* layout = nullptr; + std::vector descriptor_set; + }; + + //descriptor + Descriptor m_descriptor; + + //changeable resource + Resource m_vertex_resource; + std::vectorm_vertex_cache; + + Resource m_uniform_resource; + UniformBufferObject m_uniform_buffer_object; + + Resource m_uniform_dynamic_resource; + std::vector m_uniform_buffer_dynamic_object_cache; + + //static mesh resource + Resource m_sphere_resource; + Resource m_cylinder_resource; + Resource m_capsule_resource; + + //font resource + DebugDrawFont* m_font = nullptr; + + //resource deleter + static const uint32_t k_deferred_delete_resource_frame_count = 5;//the count means after count-1 frame will be delete + uint32_t m_current_frame = 0; + std::queue m_deffer_delete_queue[k_deferred_delete_resource_frame_count]; + + private: + void setupDescriptorSet(); + void prepareDescriptorSet(); + void updateDescriptorSet(); + void flushPendingDelete(); + void unloadMeshBuffer(); + void loadSphereMeshBuffer(); + void loadCylinderMeshBuffer(); + void loadCapsuleMeshBuffer(); + + const int m_circle_sample_count = 10; + }; +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_context.cpp b/engine/source/runtime/function/render/debugdraw/debug_draw_context.cpp new file mode 100644 index 000000000..10b02395d --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_context.cpp @@ -0,0 +1,56 @@ +#include "debug_draw_context.h" + +namespace Piccolo +{ + DebugDrawGroup* DebugDrawContext::tryGetOrCreateDebugDrawGroup(const std::string& name) + { + std::lock_guard guard(m_mutex); + + size_t debug_draw_group_count = m_debug_draw_groups.size(); + for (size_t debug_draw_group_index = 0; debug_draw_group_index < debug_draw_group_count; debug_draw_group_index++) + { + DebugDrawGroup* debug_draw_group = m_debug_draw_groups[debug_draw_group_index]; + if (debug_draw_group->getName() == name) + { + return debug_draw_group; + } + } + + DebugDrawGroup* new_debug_draw_group = new DebugDrawGroup; + new_debug_draw_group->initialize(); + new_debug_draw_group->setName(name); + m_debug_draw_groups.push_back(new_debug_draw_group); + + return new_debug_draw_group; + } + + void DebugDrawContext::clear() + { + std::lock_guard guard(m_mutex); + + size_t debug_draw_group_count = m_debug_draw_groups.size(); + for (size_t debug_draw_group_index = 0; debug_draw_group_index < debug_draw_group_count; debug_draw_group_index++) + { + delete m_debug_draw_groups[debug_draw_group_index]; + } + + m_debug_draw_groups.clear(); + } + + void DebugDrawContext::tick(float delta_time) + { + removeDeadPrimitives(delta_time); + } + + void DebugDrawContext::removeDeadPrimitives(float delta_time) + { + std::lock_guard guard(m_mutex); + + size_t debug_draw_group_count = m_debug_draw_groups.size(); + for (size_t debug_draw_group_index = 0; debug_draw_group_index < debug_draw_group_count; debug_draw_group_index++) + { + if (m_debug_draw_groups[debug_draw_group_index] == nullptr)continue; + m_debug_draw_groups[debug_draw_group_index]->removeDeadPrimitives(delta_time); + } + } +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_context.h b/engine/source/runtime/function/render/debugdraw/debug_draw_context.h new file mode 100644 index 000000000..892b07e57 --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_context.h @@ -0,0 +1,20 @@ +#pragma once + +#include "debug_draw_group.h" + +namespace Piccolo +{ + class DebugDrawContext + { + public: + std::vector m_debug_draw_groups; + DebugDrawGroup* tryGetOrCreateDebugDrawGroup(const std::string& name); + void clear(); + void tick(float delta_time); + + private: + std::mutex m_mutex; + void removeDeadPrimitives(float delta_time); + }; + +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_font.cpp b/engine/source/runtime/function/render/debugdraw/debug_draw_font.cpp new file mode 100644 index 000000000..4863d31a3 --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_font.cpp @@ -0,0 +1,117 @@ +#include "debug_draw_font.h" + + +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include + +#define STB_TRUETYPE_IMPLEMENTATION +#include + +namespace Piccolo +{ + void DebugDrawFont::loadFont() + { + std::string str = g_runtime_global_context.m_config_manager->getEditorFontPath().string(); + const char* fontFilePath = str.c_str(); + FILE* fontFile = fopen(fontFilePath, "rb"); + if (fontFile == NULL) + { + std::runtime_error("debug draw cannot open font.ttf"); + } + fseek(fontFile, 0, SEEK_END); + uint64_t size = ftell(fontFile); + fseek(fontFile, 0, SEEK_SET); + + stbtt_fontinfo fontInfo; + unsigned char* fontBuffer = (unsigned char*)calloc(size, sizeof(unsigned char)); + fread(fontBuffer, size, 1, fontFile); + fclose(fontFile); + + if (!stbtt_InitFont(&fontInfo, fontBuffer, 0)) + { + std::runtime_error("debug draw stb init font failed\n"); + } + + unsigned char* bitmap = (unsigned char*)calloc(m_bitmap_w * m_bitmap_h, sizeof(unsigned char)); + + float pixels = m_singleCharacterHeight - 2; + float scale = stbtt_ScaleForPixelHeight(&fontInfo, pixels); + + int c_x1, c_y1, c_x2, c_y2; + int ascent = 0; + int descent = 0; + int lineGap = 0; + stbtt_GetFontVMetrics(&fontInfo, &ascent, &descent, &lineGap); + ascent = roundf(ascent * scale); + descent = roundf(descent * scale); + + + int x = 0; + for (unsigned char character = m_range_l; character <= m_range_r; character++) + { + int advanceWidth = 0; + int leftSideBearing = 0; + stbtt_GetCodepointHMetrics(&fontInfo, (unsigned char)character, &advanceWidth, &leftSideBearing); + + int c_x1, c_y1, c_x2, c_y2; + stbtt_GetCodepointBitmapBox(&fontInfo, character, scale, scale, &c_x1, &c_y1, &c_x2, &c_y2); + + int y = ascent + c_y1 - 2; + int byteOffset = roundf(leftSideBearing * scale) + (character - m_range_l) % m_numOfCharacterInOneLine * m_singleCharacterWidth + ((character - m_range_l)/ m_numOfCharacterInOneLine * m_singleCharacterHeight + y) * m_bitmap_w; + + stbtt_MakeCodepointBitmap(&fontInfo, bitmap + byteOffset, c_x2 - c_x1, c_y2 - c_y1, m_bitmap_w, scale, scale, character); + + x += roundf(advanceWidth * scale); + + int kern; + kern = stbtt_GetCodepointKernAdvance(&fontInfo, character, (unsigned char)(character + 1)); + x += roundf(kern * scale); + + } + std::vector imageData(m_bitmap_w * m_bitmap_h); + for (int i = 0; i < m_bitmap_w * m_bitmap_h; i++) + { + imageData[i] = static_cast(*(bitmap + i))/255.0f; + } + + std::shared_ptr rhi = g_runtime_global_context.m_render_system->getRHI(); + rhi->createGlobalImage(m_font_image, m_font_imageView, m_allocation, m_bitmap_w, m_bitmap_h, imageData.data(), RHIFormat::RHI_FORMAT_R32_SFLOAT); + + free(fontBuffer); + free(bitmap); + } + + void DebugDrawFont::getCharacterTextureRect(const unsigned char character, float &x1, float &y1, float &x2, float &y2) + { + if (character >= m_range_l && character <= m_range_r) + { + x1 = (character - m_range_l) % m_numOfCharacterInOneLine * m_singleCharacterWidth * 1.0f / m_bitmap_w; + x2 = ((character - m_range_l) % m_numOfCharacterInOneLine * m_singleCharacterWidth + m_singleCharacterWidth)* 1.0f / m_bitmap_w; + y1 = (character - m_range_l) / m_numOfCharacterInOneLine * m_singleCharacterHeight * 1.0f / m_bitmap_h; + y2 = ((character - m_range_l) / m_numOfCharacterInOneLine * m_singleCharacterHeight + m_singleCharacterHeight)* 1.0f / m_bitmap_h; + + } + else + { + x1 = x2 = y1 = y2 = 0; + } + } + + void DebugDrawFont::inialize() + { + loadFont(); + } + + void DebugDrawFont::destroy() + { + std::shared_ptr rhi = g_runtime_global_context.m_render_system->getRHI(); + rhi->freeMemory(m_font_imageMemory); + rhi->destroyImageView(m_font_imageView); + rhi->destroyImage(m_font_image); + } + + RHIImageView* DebugDrawFont::getImageView() const + { + return m_font_imageView; + } +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_font.h b/engine/source/runtime/function/render/debugdraw/debug_draw_font.h new file mode 100644 index 000000000..f8b76e646 --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_font.h @@ -0,0 +1,38 @@ +#pragma once + +#include +#include +#include "runtime/function/global/global_context.h" +#include "runtime/resource/config_manager/config_manager.h" +#include "runtime/function/render/render_system.h" +#include "runtime/function/render/interface/rhi.h" + +namespace Piccolo +{ + + class DebugDrawFont + { + public: + void getCharacterTextureRect(const unsigned char character, float &x1, float &y1, float &x2, float &y2); + RHIImageView* getImageView() const; + void inialize(); + void destroy(); + + private: + const unsigned char m_range_l = 32, m_range_r = 126; + const int m_singleCharacterWidth = 32; + const int m_singleCharacterHeight = 64; + const int m_numOfCharacterInOneLine = 16; + const int m_numOfCharacter = (m_range_r - m_range_l + 1); + const int m_bitmap_w = m_singleCharacterWidth * m_numOfCharacterInOneLine; + const int m_bitmap_h = m_singleCharacterHeight * ((m_numOfCharacter + m_numOfCharacterInOneLine - 1) / m_numOfCharacterInOneLine); + + RHIImage* m_font_image = nullptr; + RHIImageView* m_font_imageView = nullptr; + RHIDeviceMemory* m_font_imageMemory = nullptr; + VmaAllocation m_allocation; + + void loadFont(); + + }; +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_group.cpp b/engine/source/runtime/function/render/debugdraw/debug_draw_group.cpp new file mode 100644 index 000000000..8c5be591f --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_group.cpp @@ -0,0 +1,720 @@ +#include "debug_draw_group.h" +#include +#include "runtime/function/global/global_context.h" +#include "runtime/function/render/render_system.h" + +namespace Piccolo +{ + DebugDrawGroup::~DebugDrawGroup() { clear(); } + void DebugDrawGroup::initialize() + { + } + + void DebugDrawGroup::clear() + { + std::lock_guard guard(m_mutex); + clearData(); + } + + void DebugDrawGroup::clearData() + { + m_points.clear(); + m_lines.clear(); + m_triangles.clear(); + m_quads.clear(); + m_boxes.clear(); + m_cylinders.clear(); + m_spheres.clear(); + m_capsules.clear(); + m_texts.clear(); + } + + void DebugDrawGroup::setName(const std::string& name) { m_name = name; } + + const std::string& DebugDrawGroup::getName() const{return m_name;} + + void DebugDrawGroup::addPoint(const Vector3& position, const Vector4& color, const float life_time, const bool no_depth_test) + { + std::lock_guard guard(m_mutex); + DebugDrawPoint point; + point.m_vertex.color = color; + point.setTime(life_time); + point.m_fill_mode = _FillMode_wireframe; + point.m_vertex.pos = position; + point.m_no_depth_test = no_depth_test; + m_points.push_back(point); + } + + void DebugDrawGroup::addLine(const Vector3& point0, + const Vector3& point1, + const Vector4& color0, + const Vector4& color1, + const float life_time, + const bool no_depth_test) + { + std::lock_guard guard(m_mutex); + DebugDrawLine line; + line.setTime(life_time); + line.m_fill_mode = _FillMode_wireframe; + line.m_no_depth_test = no_depth_test; + + line.m_vertex[0].pos = point0; + line.m_vertex[0].color = color0; + + line.m_vertex[1].pos = point1; + line.m_vertex[1].color = color1; + + m_lines.push_back(line); + } + + void DebugDrawGroup::addTriangle(const Vector3& point0, + const Vector3& point1, + const Vector3& point2, + const Vector4& color0, + const Vector4& color1, + const Vector4& color2, + const float life_time, + const bool no_depth_test, + const FillMode fillmod) + { + std::lock_guard guard(m_mutex); + DebugDrawTriangle triangle; + triangle.setTime(life_time); + triangle.m_fill_mode = fillmod; + triangle.m_no_depth_test = no_depth_test; + + triangle.m_vertex[0].pos = point0; + triangle.m_vertex[0].color = color0; + + triangle.m_vertex[1].pos = point1; + triangle.m_vertex[1].color = color1; + + triangle.m_vertex[2].pos = point2; + triangle.m_vertex[2].color = color2; + + m_triangles.push_back(triangle); + + + } + + void DebugDrawGroup::addQuad(const Vector3& point0, + const Vector3& point1, + const Vector3& point2, + const Vector3& point3, + const Vector4& color0, + const Vector4& color1, + const Vector4& color2, + const Vector4& color3, + const float life_time, + const bool no_depth_test, + const FillMode fillmode) + { + std::lock_guard guard(m_mutex); + if (fillmode == _FillMode_wireframe) + { + DebugDrawQuad quad; + + quad.m_vertex[0].pos = point0; + quad.m_vertex[0].color = color0; + + quad.m_vertex[1].pos = point1; + quad.m_vertex[1].color = color1; + + quad.m_vertex[2].pos = point2; + quad.m_vertex[2].color = color2; + + quad.m_vertex[3].pos = point3; + quad.m_vertex[3].color = color3; + + quad.setTime(life_time); + quad.m_no_depth_test = no_depth_test; + + m_quads.push_back(quad); + } + else + { + DebugDrawTriangle triangle; + triangle.setTime(life_time); + triangle.m_fill_mode = _FillMode_solid; + triangle.m_no_depth_test = no_depth_test; + + triangle.m_vertex[0].pos = point0; + triangle.m_vertex[0].color = color0; + triangle.m_vertex[1].pos = point1; + triangle.m_vertex[1].color = color1; + triangle.m_vertex[2].pos = point2; + triangle.m_vertex[2].color = color2; + m_triangles.push_back(triangle); + + triangle.m_vertex[0].pos = point0; + triangle.m_vertex[0].color = color0; + triangle.m_vertex[1].pos = point2; + triangle.m_vertex[1].color = color2; + triangle.m_vertex[2].pos = point3; + triangle.m_vertex[2].color = color3; + m_triangles.push_back(triangle); + } + } + + void DebugDrawGroup::addBox(const Vector3& center_point, + const Vector3& half_extends, + const Vector4& rotate, + const Vector4& color, + const float life_time, + const bool no_depth_test) + { + std::lock_guard guard(m_mutex); + DebugDrawBox box; + box.m_center_point = center_point; + box.m_half_extents = half_extends; + box.m_rotate = rotate; + box.m_color = color; + box.m_no_depth_test = no_depth_test; + box.setTime(life_time); + + m_boxes.push_back(box); + } + + void DebugDrawGroup::addSphere(const Vector3& center, + const float radius, + const Vector4& color, + const float life_time, + const bool no_depth_test) + { + std::lock_guard guard(m_mutex); + DebugDrawSphere sphere; + sphere.m_center = center; + sphere.m_radius = radius; + sphere.m_color = color; + sphere.m_no_depth_test = no_depth_test; + sphere.setTime(life_time); + + m_spheres.push_back(sphere); + } + + void DebugDrawGroup::addCylinder(const Vector3& center, + const float radius, + const float height, + const Vector4& rotate, + const Vector4& color, + const float life_time, + const bool no_depth_test) + { + std::lock_guard guard(m_mutex); + DebugDrawCylinder cylinder; + cylinder.m_radius = radius; + cylinder.m_center = center; + cylinder.m_height = height; + cylinder.m_rotate = rotate; + cylinder.m_color = color; + cylinder.m_no_depth_test = no_depth_test; + cylinder.setTime(life_time); + + m_cylinders.push_back(cylinder); + } + + void DebugDrawGroup::addCapsule(const Vector3& center, + const Vector4& rotation, + const Vector3& scale, + const float radius, + const float height, + const Vector4& color, + const float life_time, + const bool no_depth_test) + { + std::lock_guard guard(m_mutex); + DebugDrawCapsule capsule; + capsule.m_center = center; + capsule.m_rotation = rotation; + capsule.m_scale = scale; + capsule.m_radius = radius; + capsule.m_height = height; + capsule.m_color = color; + capsule.m_no_depth_test = no_depth_test; + capsule.setTime(life_time); + + m_capsules.push_back(capsule); + } + + void DebugDrawGroup::addText(const std::string& content, + const Vector4& color, + const Vector3& coordinate, + const int size, + const bool is_screen_text, + const float life_time) + { + std::lock_guard guard(m_mutex); + DebugDrawText text; + text.m_content = content; + text.m_color = color; + text.m_coordinate = coordinate; + text.m_size = size; + text.m_is_screen_text = is_screen_text; + text.setTime(life_time); + m_texts.push_back(text); + } + + void DebugDrawGroup::removeDeadPrimitives(float delta_time) + { + for (std::list::iterator point = m_points.begin(); point != m_points.end();) + { + if (point->isTimeOut(delta_time)) { + point = m_points.erase(point); + } + else { + point++; + } + } + for (std::list::iterator line = m_lines.begin(); line != m_lines.end();) + { + if (line->isTimeOut(delta_time)) { + line = m_lines.erase(line); + } + else { + line++; + } + } + for (std::list::iterator triangle = m_triangles.begin(); triangle != m_triangles.end();) + { + if (triangle->isTimeOut(delta_time)) { + triangle = m_triangles.erase(triangle); + } + else { + triangle++; + } + } + for (std::list::iterator quad = m_quads.begin(); quad != m_quads.end();) + { + if (quad->isTimeOut(delta_time)) { + quad = m_quads.erase(quad); + } + else { + quad++; + } + } + for (std::list::iterator box = m_boxes.begin(); box != m_boxes.end();) + { + if (box->isTimeOut(delta_time)) { + box = m_boxes.erase(box); + } + else { + box++; + } + } + for (std::list::iterator cylinder = m_cylinders.begin(); cylinder != m_cylinders.end();) + { + if (cylinder->isTimeOut(delta_time)) { + cylinder = m_cylinders.erase(cylinder); + } + else { + cylinder++; + } + } + for (std::list::iterator sphere = m_spheres.begin(); sphere != m_spheres.end();) + { + if (sphere->isTimeOut(delta_time)) { + sphere = m_spheres.erase(sphere); + } + else { + sphere++; + } + } + for (std::list::iterator capsule = m_capsules.begin(); capsule != m_capsules.end();) + { + if (capsule->isTimeOut(delta_time)) { + capsule = m_capsules.erase(capsule); + } + else { + capsule++; + } + } + for (std::list::iterator text = m_texts.begin(); text != m_texts.end();) + { + if (text->isTimeOut(delta_time)) { + text = m_texts.erase(text); + } + else { + text++; + } + } + } + + void DebugDrawGroup::mergeFrom(DebugDrawGroup* group) + { + std::lock_guard guard(m_mutex); + std::lock_guard guard_2(group->m_mutex); + m_points.insert(m_points.end(), group->m_points.begin(), group->m_points.end()); + m_lines.insert(m_lines.end(), group->m_lines.begin(), group->m_lines.end()); + m_triangles.insert(m_triangles.end(), group->m_triangles.begin(), group->m_triangles.end()); + m_quads.insert(m_quads.end(), group->m_quads.begin(), group->m_quads.end()); + m_boxes.insert(m_boxes.end(), group->m_boxes.begin(), group->m_boxes.end()); + m_cylinders.insert(m_cylinders.end(), group->m_cylinders.begin(), group->m_cylinders.end()); + m_spheres.insert(m_spheres.end(), group->m_spheres.begin(), group->m_spheres.end()); + m_capsules.insert(m_capsules.end(), group->m_capsules.begin(), group->m_capsules.end()); + m_texts.insert(m_texts.end(), group->m_texts.begin(), group->m_texts.end()); + } + + size_t DebugDrawGroup::getPointCount(bool no_depth_test) const + { + size_t count = 0; + for (const DebugDrawPoint point : m_points) + { + if (point.m_no_depth_test == no_depth_test)count++; + } + return count; + } + + size_t DebugDrawGroup::getLineCount(bool no_depth_test) const + { + size_t line_count = 0; + for (const DebugDrawLine line : m_lines) + { + if (line.m_no_depth_test == no_depth_test)line_count++; + } + for (const DebugDrawTriangle triangle : m_triangles) + { + if (triangle.m_fill_mode == FillMode::_FillMode_wireframe && triangle.m_no_depth_test == no_depth_test) + { + line_count += 3; + } + } + for (const DebugDrawQuad quad : m_quads) + { + if (quad.m_fill_mode == FillMode::_FillMode_wireframe && quad.m_no_depth_test == no_depth_test) + { + line_count += 4; + } + } + for (const DebugDrawBox box : m_boxes) + { + if (box.m_no_depth_test == no_depth_test)line_count += 12; + } + return line_count; + } + + size_t DebugDrawGroup::getTriangleCount(bool no_depth_test) const + { + size_t triangle_count = 0; + for (const DebugDrawTriangle triangle : m_triangles) + { + if (triangle.m_fill_mode == FillMode::_FillMode_solid && triangle.m_no_depth_test == no_depth_test) + { + triangle_count++; + } + } + return triangle_count; + } + + size_t DebugDrawGroup::getUniformDynamicDataCount() const + { + return m_spheres.size() + m_cylinders.size() + m_capsules.size(); + } + + void DebugDrawGroup::writePointData(std::vector& vertexs, bool no_depth_test) + { + size_t vertexs_count = getPointCount(no_depth_test); + vertexs.resize(vertexs_count); + + size_t current_index = 0; + for (DebugDrawPoint point : m_points) + { + if (point.m_no_depth_test == no_depth_test)vertexs[current_index++] = point.m_vertex; + } + } + + void DebugDrawGroup::writeLineData(std::vector &vertexs, bool no_depth_test) + { + size_t vertexs_count = getLineCount(no_depth_test) * 2; + vertexs.resize(vertexs_count); + + size_t current_index = 0; + for (DebugDrawLine line : m_lines) + { + if (line.m_fill_mode == FillMode::_FillMode_wireframe && line.m_no_depth_test == no_depth_test) + { + vertexs[current_index++] = line.m_vertex[0]; + vertexs[current_index++] = line.m_vertex[1]; + } + } + for (DebugDrawTriangle triangle : m_triangles) + { + if (triangle.m_fill_mode == FillMode::_FillMode_wireframe && triangle.m_no_depth_test == no_depth_test) + { + std::vector indies = { 0,1, 1,2, 2,0 }; + for (size_t i : indies) + { + vertexs[current_index++] = triangle.m_vertex[i]; + } + } + } + for (DebugDrawQuad quad : m_quads) + { + if (quad.m_fill_mode == FillMode::_FillMode_wireframe && quad.m_no_depth_test == no_depth_test) + { + std::vector indies = { 0,1, 1,2, 2,3, 3,0 }; + for (size_t i : indies) + { + vertexs[current_index++] = quad.m_vertex[i]; + } + } + } + for (DebugDrawBox box : m_boxes) + { + if (box.m_no_depth_test == no_depth_test) + { + std::vector verts_4d(8); + float f[2] = { -1.0f,1.0f }; + for (size_t i = 0; i < 8; i++) + { + Vector3 v(f[i & 1] * box.m_half_extents.x, f[(i >> 1) & 1] * box.m_half_extents.y, f[(i >> 2) & 1] * box.m_half_extents.z); + Vector3 uv, uuv; + Vector3 qvec(box.m_rotate.x, box.m_rotate.y, box.m_rotate.z); + uv = qvec.crossProduct(v); + uuv = qvec.crossProduct(uv); + uv *= (2.0f * box.m_rotate.w); + uuv *= 2.0f; + verts_4d[i].pos = v + uv + uuv + box.m_center_point; + verts_4d[i].color = box.m_color; + } + std::vector indies = { 0,1, 1,3, 3,2, 2,0, 4,5, 5,7, 7,6, 6,4, 0,4, 1,5, 3,7, 2,6 }; + for (size_t i : indies) + { + vertexs[current_index++] = verts_4d[i]; + } + } + } + } + + void DebugDrawGroup::writeTriangleData(std::vector& vertexs, bool no_depth_test) + { + size_t vertexs_count = getTriangleCount(no_depth_test) * 3; + vertexs.resize(vertexs_count); + + size_t current_index = 0; + for (DebugDrawTriangle triangle : m_triangles) + { + if (triangle.m_fill_mode == FillMode::_FillMode_solid && triangle.m_no_depth_test == no_depth_test) + { + vertexs[current_index++] = triangle.m_vertex[0]; + vertexs[current_index++] = triangle.m_vertex[1]; + vertexs[current_index++] = triangle.m_vertex[2]; + } + } + } + + void DebugDrawGroup::writeTextData(std::vector& vertexs, DebugDrawFont* font, Matrix4x4 m_proj_view_matrix) + { + RHISwapChainDesc swapChainDesc = g_runtime_global_context.m_render_system->getRHI()->getSwapchainInfo(); + uint32_t screenWidth = swapChainDesc.viewport->width; + uint32_t screenHeight = swapChainDesc.viewport->height; + + size_t vertexs_count = getTextCharacterCount() * 6; + vertexs.resize(vertexs_count); + + size_t current_index = 0; + for(DebugDrawText text : m_texts) + { + float absoluteW = text.m_size, absoluteH = text.m_size * 2; + float w = absoluteW / (1.0f * screenWidth / 2.0f), h = absoluteH / (1.0f * screenHeight / 2.0f); + Vector3 coordinate = text.m_coordinate; + if (!text.m_is_screen_text) + { + Vector4 tempCoord(coordinate.x, coordinate.y, coordinate.z, 1.0f); + tempCoord = m_proj_view_matrix * tempCoord; + coordinate = Vector3(tempCoord.x / tempCoord.w, tempCoord.y / tempCoord.w, 0.0f); + } + float x = coordinate.x, y = coordinate.y; + for (unsigned char character : text.m_content) + { + if (character == '\n') + { + y += h; + x = coordinate.x; + } + else + { + + float x1, x2, y1, y2; + font->getCharacterTextureRect(character, x1, y1, x2, y2); + + float cx1, cx2, cy1, cy2; + cx1 = 0 + x; cx2 = w + x; + cy1 = 0 + y; cy2 = h + y; + + vertexs[current_index].pos = Vector3(cx1, cy1, 0.0f); + vertexs[current_index].color = text.m_color; + vertexs[current_index++].texcoord = Vector2(x1, y1); + + vertexs[current_index].pos = Vector3(cx1, cy2, 0.0f); + vertexs[current_index].color = text.m_color; + vertexs[current_index++].texcoord = Vector2(x1, y2); + + vertexs[current_index].pos = Vector3(cx2, cy2, 0.0f); + vertexs[current_index].color = text.m_color; + vertexs[current_index++].texcoord = Vector2(x2, y2); + + vertexs[current_index].pos = Vector3(cx1, cy1, 0.0f); + vertexs[current_index].color = text.m_color; + vertexs[current_index++].texcoord = Vector2(x1, y1); + + vertexs[current_index].pos = Vector3(cx2, cy2, 0.0f); + vertexs[current_index].color = text.m_color; + vertexs[current_index++].texcoord = Vector2(x2, y2); + + vertexs[current_index].pos = Vector3(cx2, cy1, 0.0f); + vertexs[current_index].color = text.m_color; + vertexs[current_index++].texcoord = Vector2(x2, y1); + + x += w; + } + } + } + } + + void DebugDrawGroup::writeUniformDynamicDataToCache(std::vector >& datas) + { + // cache uniformDynamic data ,first has_depth_test ,second no_depth_test + size_t data_count = getUniformDynamicDataCount() * 3; + datas.resize(data_count); + + bool no_depth_tests[] = { false,true }; + for (int32_t i = 0; i < 2; i++) + { + bool no_depth_test = no_depth_tests[i]; + + size_t current_index = 0; + for (DebugDrawSphere sphere : m_spheres) + { + if (sphere.m_no_depth_test == no_depth_test) + { + Matrix4x4 model = Matrix4x4::IDENTITY; + + Matrix4x4 tmp = Matrix4x4::IDENTITY; + tmp.makeTrans(sphere.m_center); + model = model * tmp; + tmp = Matrix4x4::buildScaleMatrix(sphere.m_radius, sphere.m_radius, sphere.m_radius); + model = model * tmp; + datas[current_index++] = std::make_pair(model, sphere.m_color); + } + } + for (DebugDrawCylinder cylinder : m_cylinders) + { + if (cylinder.m_no_depth_test == no_depth_test) + { + Matrix4x4 model = Matrix4x4::IDENTITY; + + //rolate + float w = cylinder.m_rotate.x; + float x = cylinder.m_rotate.y; + float y = cylinder.m_rotate.z; + float z = cylinder.m_rotate.w; + Matrix4x4 tmp = Matrix4x4::IDENTITY; + tmp.makeTrans(cylinder.m_center); + model = model * tmp; + + tmp = Matrix4x4::buildScaleMatrix(cylinder.m_radius, cylinder.m_radius, cylinder.m_height / 2.0f); + model = model * tmp; + + Matrix4x4 ro = Matrix4x4::IDENTITY; + ro[0][0] = 1.0f - 2.0f * y * y - 2.0f * z * z; ro[0][1] = 2.0f * x * y + 2.0f * w * z; ro[0][2] = 2.0f * x * z - 2.0f * w * y; + ro[1][0] = 2.0f * x * y - 2.0f * w * z; ro[1][1] = 1.0f - 2.0f * x * x - 2.0f * z * z; ro[1][2] = 2.0f * y * z + 2.0f * w * x; + ro[2][0] = 2.0f * x * z + 2.0f * w * y; ro[2][1] = 2.0f * y * z - 2.0f * w * x; ro[2][2] = 1.0f - 2.0f * x * x - 2.0f * y * y; + model = model * ro; + + datas[current_index++] = std::make_pair(model, cylinder.m_color); + } + } + for (DebugDrawCapsule capsule : m_capsules) + { + if (capsule.m_no_depth_test == no_depth_test) + { + Matrix4x4 model1 = Matrix4x4::IDENTITY; + Matrix4x4 model2 = Matrix4x4::IDENTITY; + Matrix4x4 model3 = Matrix4x4::IDENTITY; + + Matrix4x4 tmp = Matrix4x4::IDENTITY; + tmp.makeTrans(capsule.m_center); + model1 = model1 * tmp; + model2 = model2 * tmp; + model3 = model3 * tmp; + + tmp = Matrix4x4::buildScaleMatrix(capsule.m_scale.x, capsule.m_scale.y, capsule.m_scale.z); + model1 = model1 * tmp; + model2 = model2 * tmp; + model3 = model3 * tmp; + + //rolate + float w = capsule.m_rotation.x; + float x = capsule.m_rotation.y; + float y = capsule.m_rotation.z; + float z = capsule.m_rotation.w; + Matrix4x4 ro = Matrix4x4::IDENTITY; + ro[0][0] = 1.0f - 2.0f * y * y - 2.0f * z * z; ro[0][1] = 2.0f * x * y + 2.0f * w * z; ro[0][2] = 2.0f * x * z - 2.0f * w * y; + ro[1][0] = 2.0f * x * y - 2.0f * w * z; ro[1][1] = 1.0f - 2.0f * x * x - 2.0f * z * z; ro[1][2] = 2.0f * y * z + 2.0f * w * x; + ro[2][0] = 2.0f * x * z + 2.0f * w * y; ro[2][1] = 2.0f * y * z - 2.0f * w * x; ro[2][2] = 1.0f - 2.0f * x * x - 2.0f * y * y; + model1 = model1 * ro; + model2 = model2 * ro; + model3 = model3 * ro; + + tmp.makeTrans(Vector3(0.0f, 0.0f, capsule.m_height / 2.0f - capsule.m_radius)); + model1 = model1 * tmp; + + tmp = Matrix4x4::buildScaleMatrix(1.0f, 1.0f, capsule.m_height / (capsule.m_radius * 2.0f)); + model2 = model2 * tmp; + + tmp.makeTrans(Vector3(0.0f, 0.0f, -(capsule.m_height / 2.0f - capsule.m_radius))); + model3 = model3 * tmp; + + tmp = Matrix4x4::buildScaleMatrix(capsule.m_radius, capsule.m_radius, capsule.m_radius); + model1 = model1 * tmp; + model2 = model2 * tmp; + model3 = model3 * tmp; + + datas[current_index++] = std::make_pair(model1, capsule.m_color); + datas[current_index++] = std::make_pair(model2, capsule.m_color); + datas[current_index++] = std::make_pair(model3, capsule.m_color); + } + } + } + } + + size_t DebugDrawGroup::getSphereCount(bool no_depth_test) const + { + size_t count = 0; + for (const DebugDrawSphere sphere : m_spheres) + { + if (sphere.m_no_depth_test == no_depth_test)count++; + } + return count; + } + size_t DebugDrawGroup::getCylinderCount(bool no_depth_test) const + { + size_t count = 0; + for (const DebugDrawCylinder cylinder : m_cylinders) + { + if (cylinder.m_no_depth_test == no_depth_test)count++; + } + return count; + } + size_t DebugDrawGroup::getCapsuleCount(bool no_depth_test) const + { + size_t count = 0; + for (const DebugDrawCapsule capsule : m_capsules) + { + if (capsule.m_no_depth_test == no_depth_test)count++; + } + return count; + } + size_t DebugDrawGroup::getTextCharacterCount() const + { + size_t count = 0; + for (const DebugDrawText text : m_texts) + { + for (unsigned char character : text.m_content) + { + if (character != '\n')count++; + } + } + return count; + } +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_group.h b/engine/source/runtime/function/render/debugdraw/debug_draw_group.h new file mode 100644 index 000000000..fb43b2ad6 --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_group.h @@ -0,0 +1,126 @@ +#pragma once + +#include "debug_draw_primitive.h" +#include "debug_draw_font.h" +#include +#include + +namespace Piccolo +{ + class DebugDrawGroup + { + private: + std::mutex m_mutex; + + std::string m_name; + + std::list m_points; + std::list m_lines; + std::list m_triangles; + std::list m_quads; + std::list m_boxes; + std::list m_cylinders; + std::list m_spheres; + std::list m_capsules; + std::list m_texts; + + public: + virtual ~DebugDrawGroup(); + void initialize(); + void clear(); + void clearData(); + void setName(const std::string& name); + const std::string& getName() const; + + void addPoint(const Vector3& position, + const Vector4& color, + const float life_time = k_debug_draw_one_frame, + const bool no_depth_test = true); + + void addLine(const Vector3& point0, + const Vector3& point1, + const Vector4& color0, + const Vector4& color1, + const float life_time = k_debug_draw_one_frame, + const bool no_depth_test = true); + + void addTriangle(const Vector3& point0, + const Vector3& point1, + const Vector3& point2, + const Vector4& color0, + const Vector4& color1, + const Vector4& color2, + const float life_time = k_debug_draw_one_frame, + const bool no_depth_test = true, + const FillMode fillmod = _FillMode_wireframe); + + void addQuad(const Vector3& point0, + const Vector3& point1, + const Vector3& point2, + const Vector3& point3, + const Vector4& color0, + const Vector4& color1, + const Vector4& color2, + const Vector4& color3, + const float life_time = k_debug_draw_one_frame, + const bool no_depth_test = true, + const FillMode fillmode = _FillMode_wireframe); + + void addBox(const Vector3& center_point, + const Vector3& half_extends, + const Vector4& rotate, + const Vector4& color, + const float life_time = k_debug_draw_one_frame, + const bool no_depth_test = true); + + void addSphere(const Vector3& center, + const float radius, + const Vector4& color, + const float life_time, + const bool no_depth_test = true); + + void addCylinder(const Vector3& center, + const float radius, + const float height, + const Vector4& rotate, + const Vector4& color, + const float life_time = k_debug_draw_one_frame, + const bool no_depth_test = true); + + void addCapsule(const Vector3& center, + const Vector4& rotation, + const Vector3& scale, + const float radius, + const float height, + const Vector4& color, + const float life_time = k_debug_draw_one_frame, + const bool no_depth_test = true); + + void addText(const std::string& content, + const Vector4& color, + const Vector3& coordinate, + const int size, + const bool is_screen_text, + const float life_time = k_debug_draw_one_frame); + + void removeDeadPrimitives(float delta_time); + void mergeFrom(DebugDrawGroup* group); + + size_t getPointCount(bool no_depth_test) const; + size_t getLineCount(bool no_depth_test) const; + size_t getTriangleCount(bool no_depth_test) const; + size_t getUniformDynamicDataCount() const; + + void writePointData(std::vector& vertexs, bool no_depth_test); + void writeLineData(std::vector& vertexs, bool no_depth_test); + void writeTriangleData(std::vector& vertexs, bool no_depth_test); + void writeUniformDynamicDataToCache(std::vector >& datas); + void writeTextData(std::vector& vertexs, DebugDrawFont* font, Matrix4x4 m_proj_view_matrix); + + size_t getSphereCount(bool no_depth_test) const; + size_t getCylinderCount(bool no_depth_test) const; + size_t getCapsuleCount(bool no_depth_test) const; + size_t getTextCharacterCount() const; + + }; +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_manager.cpp b/engine/source/runtime/function/render/debugdraw/debug_draw_manager.cpp new file mode 100644 index 000000000..806bd6e39 --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_manager.cpp @@ -0,0 +1,351 @@ +#include "debug_draw_manager.h" +#include "runtime/function/global/global_context.h" +#include "runtime/function/render/render_system.h" +#include "runtime/core/math/math_headers.h" + +namespace Piccolo +{ + void DebugDrawManager::initialize() + { + m_rhi = g_runtime_global_context.m_render_system->getRHI(); + setupPipelines(); + } + + void DebugDrawManager::setupPipelines() + { + //setup pipelines + for (uint8_t i = 0; i < DebugDrawPipelineType::_debug_draw_pipeline_type_count; i++) + { + m_debug_draw_pipeline[i] = new DebugDrawPipeline((DebugDrawPipelineType)i); + m_debug_draw_pipeline[i]->initialize(); + } + m_buffer_allocator = new DebugDrawAllocator(); + m_font = new DebugDrawFont(); + m_font->inialize(); + m_buffer_allocator->initialize(m_font); + } + + void DebugDrawManager::destory() + { + for (uint8_t i = 0; i < DebugDrawPipelineType::_debug_draw_pipeline_type_count; i++) + { + m_debug_draw_pipeline[i]->destory(); + delete m_debug_draw_pipeline[i]; + } + + m_buffer_allocator->destory(); + delete m_buffer_allocator; + + //m_font->destroy(); + delete m_font; + } + void DebugDrawManager::clear() + { + std::lock_guard guard(m_mutex); + m_debug_draw_context.clear(); + } + + void DebugDrawManager::tick(float delta_time) + { + std::lock_guard guard(m_mutex); + m_buffer_allocator->tick(); + m_debug_draw_context.tick(delta_time); + } + + void DebugDrawManager::updateAfterRecreateSwapchain() + { + for (uint8_t i = 0; i < DebugDrawPipelineType::_debug_draw_pipeline_type_count; i++) + { + m_debug_draw_pipeline[i]->recreateAfterSwapchain(); + } + } + + void DebugDrawManager::preparePassData(std::shared_ptr render_resource) + { + const RenderResource* resource = static_cast(render_resource.get()); + m_proj_view_matrix = resource->m_mesh_perframe_storage_buffer_object.proj_view_matrix; + + } + + void DebugDrawManager::swapDataToRender() + { + std::lock_guard guard(m_mutex); + + m_debug_draw_group_for_render.clear(); + size_t debug_draw_group_count = m_debug_draw_context.m_debug_draw_groups.size(); + for (size_t debug_draw_group_index = 0; debug_draw_group_index < debug_draw_group_count; debug_draw_group_index++) + { + DebugDrawGroup* debug_draw_group = m_debug_draw_context.m_debug_draw_groups[debug_draw_group_index]; + if (debug_draw_group == nullptr)continue; + m_debug_draw_group_for_render.mergeFrom(debug_draw_group); + } + } + + void DebugDrawManager::draw(uint32_t current_swapchain_image_index) + { + + static uint32_t once = 1; + swapDataToRender(); + once = 0; + + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "DebugDrawManager", color); + m_rhi->cmdSetViewportPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().viewport); + m_rhi->cmdSetScissorPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().scissor); + + drawDebugObject(current_swapchain_image_index); + + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); + } + + void DebugDrawManager::prepareDrawBuffer() + { + m_buffer_allocator->clear(); + + std::vector vertexs; + + m_debug_draw_group_for_render.writePointData(vertexs, false); + m_point_start_offset = m_buffer_allocator->cacheVertexs(vertexs); + m_point_end_offset = m_buffer_allocator->getVertexCacheOffset(); + + m_debug_draw_group_for_render.writeLineData(vertexs, false); + m_line_start_offset = m_buffer_allocator->cacheVertexs(vertexs); + m_line_end_offset = m_buffer_allocator->getVertexCacheOffset(); + + m_debug_draw_group_for_render.writeTriangleData(vertexs, false); + m_triangle_start_offset = m_buffer_allocator->cacheVertexs(vertexs); + m_triangle_end_offset = m_buffer_allocator->getVertexCacheOffset(); + + m_debug_draw_group_for_render.writePointData(vertexs, true); + m_no_depth_test_point_start_offset = m_buffer_allocator->cacheVertexs(vertexs); + m_no_depth_test_point_end_offset = m_buffer_allocator->getVertexCacheOffset(); + + m_debug_draw_group_for_render.writeLineData(vertexs, true); + m_no_depth_test_line_start_offset = m_buffer_allocator->cacheVertexs(vertexs); + m_no_depth_test_line_end_offset = m_buffer_allocator->getVertexCacheOffset(); + + m_debug_draw_group_for_render.writeTriangleData(vertexs, true); + m_no_depth_test_triangle_start_offset = m_buffer_allocator->cacheVertexs(vertexs); + m_no_depth_test_triangle_end_offset = m_buffer_allocator->getVertexCacheOffset(); + + m_debug_draw_group_for_render.writeTextData(vertexs, m_font, m_proj_view_matrix); + m_text_start_offset = m_buffer_allocator->cacheVertexs(vertexs); + m_text_end_offset = m_buffer_allocator->getVertexCacheOffset(); + + m_buffer_allocator->cacheUniformObject(m_proj_view_matrix); + + std::vector > dynamicObject = { std::make_pair(Matrix4x4::IDENTITY,Vector4(0,0,0,0)) }; + m_buffer_allocator->cacheUniformDynamicObject(dynamicObject);//cache the first model matrix as Identity matrix, color as empty color. (default object) + + m_debug_draw_group_for_render.writeUniformDynamicDataToCache(dynamicObject); + m_buffer_allocator->cacheUniformDynamicObject(dynamicObject);//cache the wire frame uniform dynamic object + + m_buffer_allocator->allocator(); + } + + void DebugDrawManager::drawPointLineTriangleBox(uint32_t current_swapchain_image_index) + { + // draw point, line ,triangle , triangle_without_depth_test + RHIBuffer* vertex_buffers[] = { m_buffer_allocator->getVertexBuffer() }; + if (vertex_buffers[0] == nullptr) + { + return; + } + RHIDeviceSize offsets[] = { 0 }; + m_rhi->cmdBindVertexBuffersPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, vertex_buffers, offsets); + + std::vectorvc_pipelines{ m_debug_draw_pipeline[DebugDrawPipelineType::_debug_draw_pipeline_type_point], + m_debug_draw_pipeline[DebugDrawPipelineType::_debug_draw_pipeline_type_line], + m_debug_draw_pipeline[DebugDrawPipelineType::_debug_draw_pipeline_type_triangle], + m_debug_draw_pipeline[DebugDrawPipelineType::_debug_draw_pipeline_type_point_no_depth_test], + m_debug_draw_pipeline[DebugDrawPipelineType::_debug_draw_pipeline_type_line_no_depth_test], + m_debug_draw_pipeline[DebugDrawPipelineType::_debug_draw_pipeline_type_triangle_no_depth_test], + m_debug_draw_pipeline[DebugDrawPipelineType::_debug_draw_pipeline_type_triangle_no_depth_test] }; + std::vectorvc_start_offsets{ m_point_start_offset, + m_line_start_offset, + m_triangle_start_offset, + m_no_depth_test_point_start_offset, + m_no_depth_test_line_start_offset, + m_no_depth_test_triangle_start_offset, + m_text_start_offset }; + std::vectorvc_end_offsets{ m_point_end_offset, + m_line_end_offset, + m_triangle_end_offset, + m_no_depth_test_point_end_offset, + m_no_depth_test_line_end_offset, + m_no_depth_test_triangle_end_offset, + m_text_end_offset }; + RHIClearValue clear_values[2]; + clear_values[0].color = { 0.0f,0.0f,0.0f,0.0f }; + clear_values[1].depthStencil = { 1.0f, 0 }; + RHIRenderPassBeginInfo renderpass_begin_info{}; + renderpass_begin_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + renderpass_begin_info.renderArea.offset = { 0, 0 }; + renderpass_begin_info.renderArea.extent = m_rhi->getSwapchainInfo().extent; + renderpass_begin_info.clearValueCount = (sizeof(clear_values) / sizeof(clear_values[0])); + renderpass_begin_info.pClearValues = clear_values; + + for (size_t i = 0; i < vc_pipelines.size(); i++) + { + if (vc_end_offsets[i] - vc_start_offsets[i] == 0) + { + continue; + } + renderpass_begin_info.renderPass = vc_pipelines[i]->getFramebuffer().render_pass; + renderpass_begin_info.framebuffer = vc_pipelines[i]->getFramebuffer().framebuffers[current_swapchain_image_index]; + m_rhi->cmdBeginRenderPassPFN(m_rhi->getCurrentCommandBuffer(), &renderpass_begin_info, RHI_SUBPASS_CONTENTS_INLINE); + + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), RHI_PIPELINE_BIND_POINT_GRAPHICS, vc_pipelines[i]->getPipeline().pipeline); + + uint32_t dynamicOffset = 0; + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + vc_pipelines[i]->getPipeline().layout, + 0, + 1, + &m_buffer_allocator->getDescriptorSet(), + 1, + &dynamicOffset); + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), vc_end_offsets[i] - vc_start_offsets[i], 1, vc_start_offsets[i], 0); + + m_rhi->cmdEndRenderPassPFN(m_rhi->getCurrentCommandBuffer()); + } + } + void DebugDrawManager::drawWireFrameObject(uint32_t current_swapchain_image_index) + { + //draw wire frame object : sphere, cylinder, capsule + + std::vectorvc_pipelines{ m_debug_draw_pipeline[DebugDrawPipelineType::_debug_draw_pipeline_type_line], + m_debug_draw_pipeline[DebugDrawPipelineType::_debug_draw_pipeline_type_line_no_depth_test] }; + std::vectorno_depth_tests = { false,true }; + + for (int32_t i = 0; i < 2; i++) + { + bool no_depth_test = no_depth_tests[i]; + + RHIDeviceSize offsets[] = { 0 }; + RHIClearValue clear_values[2]; + clear_values[0].color = { 0.0f,0.0f,0.0f,0.0f }; + clear_values[1].depthStencil = { 1.0f, 0 }; + RHIRenderPassBeginInfo renderpass_begin_info{}; + renderpass_begin_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + renderpass_begin_info.renderArea.offset = { 0, 0 }; + renderpass_begin_info.renderArea.extent = m_rhi->getSwapchainInfo().extent; + renderpass_begin_info.clearValueCount = (sizeof(clear_values) / sizeof(clear_values[0])); + renderpass_begin_info.pClearValues = clear_values; + renderpass_begin_info.renderPass = vc_pipelines[i]->getFramebuffer().render_pass; + renderpass_begin_info.framebuffer = vc_pipelines[i]->getFramebuffer().framebuffers[current_swapchain_image_index]; + m_rhi->cmdBeginRenderPassPFN(m_rhi->getCurrentCommandBuffer(), &renderpass_begin_info, RHI_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), RHI_PIPELINE_BIND_POINT_GRAPHICS, vc_pipelines[i]->getPipeline().pipeline); + + size_t uniform_dynamic_size = m_buffer_allocator->getSizeOfUniformBufferObject(); + uint32_t dynamicOffset = uniform_dynamic_size; + + size_t sphere_count = m_debug_draw_group_for_render.getSphereCount(no_depth_test); + size_t cylinder_count = m_debug_draw_group_for_render.getCylinderCount(no_depth_test); + size_t capsule_count = m_debug_draw_group_for_render.getCapsuleCount(no_depth_test); + + if (sphere_count > 0) + { + RHIBuffer* sphere_vertex_buffers[] = { m_buffer_allocator->getSphereVertexBuffer() }; + m_rhi->cmdBindVertexBuffersPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, sphere_vertex_buffers, offsets); + for (size_t j = 0; j < sphere_count; j++) + { + + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + vc_pipelines[i]->getPipeline().layout, + 0, + 1, + &m_buffer_allocator->getDescriptorSet(), + 1, + &dynamicOffset); + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), m_buffer_allocator->getSphereVertexBufferSize(), 1, 0, 0); + dynamicOffset += uniform_dynamic_size; + } + } + + if (cylinder_count > 0) + { + RHIBuffer* cylinder_vertex_buffers[] = { m_buffer_allocator->getCylinderVertexBuffer() }; + m_rhi->cmdBindVertexBuffersPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, cylinder_vertex_buffers, offsets); + for (size_t j = 0; j < cylinder_count; j++) + { + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + vc_pipelines[i]->getPipeline().layout, + 0, + 1, + &m_buffer_allocator->getDescriptorSet(), + 1, + &dynamicOffset); + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), m_buffer_allocator->getCylinderVertexBufferSize(), 1, 0, 0); + dynamicOffset += uniform_dynamic_size; + } + } + + if (capsule_count > 0) + { + RHIBuffer* capsule_vertex_buffers[] = { m_buffer_allocator->getCapsuleVertexBuffer() }; + m_rhi->cmdBindVertexBuffersPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, capsule_vertex_buffers, offsets); + for (size_t j = 0; j < capsule_count; j++) + { + //draw capsule up part + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + vc_pipelines[i]->getPipeline().layout, + 0, + 1, + &m_buffer_allocator->getDescriptorSet(), + 1, + &dynamicOffset); + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), m_buffer_allocator->getCapsuleVertexBufferUpSize(), 1, 0, 0); + dynamicOffset += uniform_dynamic_size; + + //draw capsule mid part + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + vc_pipelines[i]->getPipeline().layout, + 0, + 1, + &m_buffer_allocator->getDescriptorSet(), + 1, + &dynamicOffset); + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), m_buffer_allocator->getCapsuleVertexBufferMidSize(), 1, m_buffer_allocator->getCapsuleVertexBufferUpSize(), 0); + dynamicOffset += uniform_dynamic_size; + + //draw capsule down part + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + vc_pipelines[i]->getPipeline().layout, + 0, + 1, + &m_buffer_allocator->getDescriptorSet(), + 1, + &dynamicOffset); + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), + m_buffer_allocator->getCapsuleVertexBufferDownSize(), + 1, + m_buffer_allocator->getCapsuleVertexBufferUpSize() + m_buffer_allocator->getCapsuleVertexBufferMidSize(), + 0); + dynamicOffset += uniform_dynamic_size; + } + } + + m_rhi->cmdEndRenderPassPFN(m_rhi->getCurrentCommandBuffer()); + } + } + + void DebugDrawManager::drawDebugObject(uint32_t current_swapchain_image_index) + { + prepareDrawBuffer(); + drawPointLineTriangleBox(current_swapchain_image_index); + drawWireFrameObject(current_swapchain_image_index); + } + + DebugDrawGroup* DebugDrawManager::tryGetOrCreateDebugDrawGroup(const std::string& name) + { + std::lock_guard guard(m_mutex); + return m_debug_draw_context.tryGetOrCreateDebugDrawGroup(name); + } +} diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_manager.h b/engine/source/runtime/function/render/debugdraw/debug_draw_manager.h new file mode 100644 index 000000000..982503466 --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_manager.h @@ -0,0 +1,66 @@ +#pragma once + +#include "runtime/function/render/interface/rhi.h" +#include "debug_draw_pipeline.h" +#include "debug_draw_buffer.h" +#include "runtime/function/render/render_resource.h" +#include "debug_draw_context.h" +#include "debug_draw_font.h" + + +namespace Piccolo +{ + class DebugDrawManager + { + public: + DebugDrawManager() {}; + void initialize(); + void setupPipelines(); + void preparePassData(std::shared_ptr render_resource); + void destory(); + void clear(); + void tick(float delta_time); + void updateAfterRecreateSwapchain(); + DebugDrawGroup* tryGetOrCreateDebugDrawGroup(const std::string& name); + + void draw(uint32_t current_swapchain_image_index); + ~DebugDrawManager() { destory(); } + + private: + void swapDataToRender(); + void drawDebugObject(uint32_t current_swapchain_image_index); + void prepareDrawBuffer(); + void drawPointLineTriangleBox(uint32_t current_swapchain_image_index); + void drawWireFrameObject(uint32_t current_swapchain_image_index); + + std::mutex m_mutex; + std::shared_ptr m_rhi = nullptr; + DebugDrawPipeline* m_debug_draw_pipeline[DebugDrawPipelineType::_debug_draw_pipeline_type_count] = {}; + + DebugDrawAllocator* m_buffer_allocator = nullptr; + + DebugDrawContext m_debug_draw_context; + + DebugDrawGroup m_debug_draw_group_for_render; + + DebugDrawFont* m_font = nullptr; + + Matrix4x4 m_proj_view_matrix; + + size_t m_point_start_offset; + size_t m_point_end_offset; + size_t m_line_start_offset; + size_t m_line_end_offset; + size_t m_triangle_start_offset; + size_t m_triangle_end_offset; + size_t m_no_depth_test_point_start_offset; + size_t m_no_depth_test_point_end_offset; + size_t m_no_depth_test_line_start_offset; + size_t m_no_depth_test_line_end_offset; + size_t m_no_depth_test_triangle_start_offset; + size_t m_no_depth_test_triangle_end_offset; + size_t m_text_start_offset; + size_t m_text_end_offset; + }; + +} diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_pipeline.cpp b/engine/source/runtime/function/render/debugdraw/debug_draw_pipeline.cpp new file mode 100644 index 000000000..284579b56 --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_pipeline.cpp @@ -0,0 +1,327 @@ +#include "debug_draw_pipeline.h" +#include +#include +#include +#include "runtime/function/global/global_context.h" +#include "runtime/function/render/render_system.h" +namespace Piccolo +{ + void DebugDrawPipeline::initialize() + { + m_rhi = g_runtime_global_context.m_render_system->getRHI(); + setupAttachments(); + setupRenderPass(); + setupFramebuffer(); + setupDescriptorLayout(); + setupPipelines(); + } + + void DebugDrawPipeline::recreateAfterSwapchain() + { + for (auto framebuffer : m_framebuffer.framebuffers) + { + m_rhi->destroyFramebuffer(framebuffer); + } + + setupFramebuffer(); + } + + void DebugDrawPipeline::setupAttachments() + { + + } + void DebugDrawPipeline::setupRenderPass() + { + RHIAttachmentDescription color_attachment_description{}; + color_attachment_description.format = m_rhi->getSwapchainInfo().image_format; + color_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + color_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_LOAD; + color_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_STORE; + color_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + color_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + color_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_PRESENT_SRC_KHR; + color_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_PRESENT_SRC_KHR; + + RHIAttachmentReference color_attachment_reference{}; + color_attachment_reference.attachment = 0; + color_attachment_reference.layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + + RHIAttachmentDescription depth_attachment_description{}; + depth_attachment_description.format = m_rhi->getDepthImageInfo().depth_image_format; + depth_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + depth_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_LOAD; + depth_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_STORE; + depth_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + depth_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + depth_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + depth_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + + RHIAttachmentReference depth_attachment_reference{}; + depth_attachment_reference.attachment = 1; + depth_attachment_reference.layout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + + RHISubpassDescription subpass{}; + subpass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; + subpass.colorAttachmentCount = 1; + subpass.pColorAttachments = &color_attachment_reference; + subpass.pDepthStencilAttachment = &depth_attachment_reference; + + std::array attachments = { color_attachment_description, depth_attachment_description }; + + RHISubpassDependency dependencies[1] = {}; + RHISubpassDependency& debug_draw_dependency = dependencies[0]; + debug_draw_dependency.srcSubpass = 0; + debug_draw_dependency.dstSubpass = RHI_SUBPASS_EXTERNAL; + debug_draw_dependency.srcStageMask = RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | RHI_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; + debug_draw_dependency.dstStageMask = RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | RHI_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; + debug_draw_dependency.srcAccessMask = RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | RHI_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; // STORE_OP_STORE + debug_draw_dependency.dstAccessMask = RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | RHI_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + debug_draw_dependency.dependencyFlags = 0; // NOT BY REGION + + RHIRenderPassCreateInfo renderpass_create_info{}; + renderpass_create_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + renderpass_create_info.attachmentCount = attachments.size(); + renderpass_create_info.pAttachments = attachments.data(); + renderpass_create_info.subpassCount = 1; + renderpass_create_info.pSubpasses = &subpass; + renderpass_create_info.dependencyCount = 1; + renderpass_create_info.pDependencies = dependencies; + + if (m_rhi->createRenderPass(&renderpass_create_info, m_framebuffer.render_pass) != RHI_SUCCESS) + { + throw std::runtime_error("create inefficient pick render pass"); + } + } + void DebugDrawPipeline::setupFramebuffer() + { + const std::vector&& imageViews = m_rhi->getSwapchainInfo().imageViews; + m_framebuffer.framebuffers.resize(imageViews.size()); + for (size_t i = 0; i < m_framebuffer.framebuffers.size(); i++) { + + RHIImageView* attachments[2] = { imageViews[i], m_rhi->getDepthImageInfo().depth_image_view}; + + RHIFramebufferCreateInfo framebuffer_create_info{}; + framebuffer_create_info.sType = RHI_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + framebuffer_create_info.renderPass = m_framebuffer.render_pass; + framebuffer_create_info.attachmentCount = sizeof(attachments) / sizeof(attachments[0]); + framebuffer_create_info.pAttachments = attachments; + framebuffer_create_info.width = m_rhi->getSwapchainInfo().extent.width; + framebuffer_create_info.height = m_rhi->getSwapchainInfo().extent.height; + framebuffer_create_info.layers = 1; + + if (m_rhi->createFramebuffer(&framebuffer_create_info, m_framebuffer.framebuffers[i]) !=RHI_SUCCESS) + { + throw std::runtime_error("create inefficient pick framebuffer"); + } + } + } + + void DebugDrawPipeline::setupDescriptorLayout() + { + RHIDescriptorSetLayoutBinding uboLayoutBinding[3]; + uboLayoutBinding[0].binding = 0; + uboLayoutBinding[0].descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + uboLayoutBinding[0].descriptorCount = 1; + uboLayoutBinding[0].stageFlags = RHI_SHADER_STAGE_VERTEX_BIT; + uboLayoutBinding[0].pImmutableSamplers = nullptr; + + uboLayoutBinding[1].binding = 1; + uboLayoutBinding[1].descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; + uboLayoutBinding[1].descriptorCount = 1; + uboLayoutBinding[1].stageFlags = RHI_SHADER_STAGE_VERTEX_BIT; + uboLayoutBinding[1].pImmutableSamplers = nullptr; + + uboLayoutBinding[2].binding = 2; + uboLayoutBinding[2].descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + uboLayoutBinding[2].descriptorCount = 1; + uboLayoutBinding[2].stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; + uboLayoutBinding[2].pImmutableSamplers = nullptr; + + RHIDescriptorSetLayoutCreateInfo layoutInfo{}; + layoutInfo.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + layoutInfo.bindingCount = 3; + layoutInfo.pBindings = uboLayoutBinding; + + if (m_rhi->createDescriptorSetLayout(&layoutInfo, m_descriptor_layout) != RHI_SUCCESS) + { + throw std::runtime_error("create debug draw layout"); + } + } + + void DebugDrawPipeline::setupPipelines() + { + m_render_pipelines.resize(1); + + RHIPipelineLayoutCreateInfo pipeline_layout_create_info{}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + pipeline_layout_create_info.setLayoutCount = 1; + pipeline_layout_create_info.pSetLayouts = &m_descriptor_layout; + pipeline_layout_create_info.pushConstantRangeCount = 0; + pipeline_layout_create_info.pPushConstantRanges = nullptr; + + if (m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[0].layout) != RHI_SUCCESS) + { + throw std::runtime_error("create mesh inefficient pick pipeline layout"); + } + + RHIShader* vert_shader_module = m_rhi->createShaderModule(DEBUGDRAW_VERT); + RHIShader* frag_shader_module = m_rhi->createShaderModule(DEBUGDRAW_FRAG); + + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info{}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; + vert_pipeline_shader_stage_create_info.module = vert_shader_module; + vert_pipeline_shader_stage_create_info.pName = "main"; + + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info{}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; + frag_pipeline_shader_stage_create_info.module = frag_shader_module; + frag_pipeline_shader_stage_create_info.pName = "main"; + + RHIPipelineShaderStageCreateInfo shader_stages[] = { vert_pipeline_shader_stage_create_info, + frag_pipeline_shader_stage_create_info }; + + auto vertex_binding_descriptions = DebugDrawVertex::getBindingDescriptions(); + auto vertex_attribute_descriptions = DebugDrawVertex::getAttributeDescriptions(); + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info{}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + vertex_input_state_create_info.vertexBindingDescriptionCount = static_cast(vertex_binding_descriptions.size()); + vertex_input_state_create_info.pVertexBindingDescriptions = vertex_binding_descriptions.data(); + vertex_input_state_create_info.vertexAttributeDescriptionCount = static_cast(vertex_attribute_descriptions.size()); + vertex_input_state_create_info.pVertexAttributeDescriptions = vertex_attribute_descriptions.data(); + + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info{}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_LINE_LIST; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; + + RHIPipelineViewportStateCreateInfo viewport_state_create_info{}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + viewport_state_create_info.viewportCount = 1; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; + viewport_state_create_info.scissorCount = 1; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; + + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info{}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; + rasterization_state_create_info.lineWidth = 1.0f; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_NONE; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; + rasterization_state_create_info.depthBiasConstantFactor = 0.0f; + rasterization_state_create_info.depthBiasClamp = 0.0f; + rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; + + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info{}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; + + RHIPipelineColorBlendAttachmentState color_blend_attachment_state{}; + color_blend_attachment_state.colorWriteMask = RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachment_state.blendEnable = RHI_TRUE; + color_blend_attachment_state.srcColorBlendFactor = RHI_BLEND_FACTOR_SRC_ALPHA; + color_blend_attachment_state.dstColorBlendFactor = RHI_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; + color_blend_attachment_state.colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachment_state.srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info{}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; + color_blend_state_create_info.attachmentCount = 1; + color_blend_state_create_info.pAttachments = &color_blend_attachment_state; + color_blend_state_create_info.blendConstants[0] = 0.0f; + color_blend_state_create_info.blendConstants[1] = 0.0f; + color_blend_state_create_info.blendConstants[2] = 0.0f; + color_blend_state_create_info.blendConstants[3] = 0.0f; + + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info{}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_TRUE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; + + RHIDynamicState dynamic_states[] = { RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR }; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info{}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + dynamic_state_create_info.dynamicStateCount = 2; + dynamic_state_create_info.pDynamicStates = dynamic_states; + + RHIGraphicsPipelineCreateInfo pipelineInfo{}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + pipelineInfo.stageCount = 2; + pipelineInfo.pStages = shader_stages; + pipelineInfo.pVertexInputState = &vertex_input_state_create_info; + pipelineInfo.pInputAssemblyState = &input_assembly_create_info; + pipelineInfo.pViewportState = &viewport_state_create_info; + pipelineInfo.pRasterizationState = &rasterization_state_create_info; + pipelineInfo.pMultisampleState = &multisample_state_create_info; + pipelineInfo.pColorBlendState = &color_blend_state_create_info; + pipelineInfo.pDepthStencilState = &depth_stencil_create_info; + pipelineInfo.layout = m_render_pipelines[0].layout; + pipelineInfo.renderPass = m_framebuffer.render_pass; + pipelineInfo.subpass = 0; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; + pipelineInfo.pDynamicState = &dynamic_state_create_info; + + if (m_pipeline_type == _debug_draw_pipeline_type_point) + { + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_POINT_LIST; + } + else if (m_pipeline_type == _debug_draw_pipeline_type_line) + { + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_LINE_LIST; + } + else if (m_pipeline_type == _debug_draw_pipeline_type_triangle) + { + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + } + else if (m_pipeline_type == _debug_draw_pipeline_type_point_no_depth_test) + { + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_POINT_LIST; + depth_stencil_create_info.depthTestEnable = RHI_FALSE; + } + else if (m_pipeline_type == _debug_draw_pipeline_type_line_no_depth_test) + { + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_LINE_LIST; + depth_stencil_create_info.depthTestEnable = RHI_FALSE; + } + else if (m_pipeline_type == _debug_draw_pipeline_type_triangle_no_depth_test) + { + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + depth_stencil_create_info.depthTestEnable = RHI_FALSE; + } + + if (m_rhi->createGraphicsPipelines( + RHI_NULL_HANDLE, 1, &pipelineInfo, m_render_pipelines[0].pipeline) != + RHI_SUCCESS) + { + throw std::runtime_error("create debug draw graphics pipeline"); + } + + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); + } + + void DebugDrawPipeline::destory() + { + + } + const DebugDrawPipelineBase &DebugDrawPipeline::getPipeline() const + { + return m_render_pipelines[0]; + } + const DebugDrawFramebuffer &DebugDrawPipeline::getFramebuffer() const + { + return m_framebuffer; + } +} diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_pipeline.h b/engine/source/runtime/function/render/debugdraw/debug_draw_pipeline.h new file mode 100644 index 000000000..24fc57723 --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_pipeline.h @@ -0,0 +1,69 @@ +#pragma once + +#include "runtime/function/render/interface/rhi.h" +#include "debug_draw_primitive.h" + +namespace Piccolo +{ + + struct DebugDrawFrameBufferAttachment + { + RHIImage* image = nullptr; + RHIDeviceMemory* mem = nullptr; + RHIImageView* view = nullptr; + RHIFormat format; + }; + + struct DebugDrawFramebuffer + { + int width; + int height; + RHIRenderPass* render_pass = nullptr; + + std::vector framebuffers; + std::vector attachments; + }; + + struct DebugDrawPipelineBase + { + RHIPipelineLayout* layout = nullptr; + RHIPipeline* pipeline = nullptr; + }; + + enum DebugDrawPipelineType : uint8_t + { + _debug_draw_pipeline_type_point = 0, + _debug_draw_pipeline_type_line, + _debug_draw_pipeline_type_triangle, + _debug_draw_pipeline_type_point_no_depth_test, + _debug_draw_pipeline_type_line_no_depth_test, + _debug_draw_pipeline_type_triangle_no_depth_test, + _debug_draw_pipeline_type_count, + }; + + class DebugDrawPipeline + { + public: + DebugDrawPipelineType m_pipeline_type; + DebugDrawPipeline(DebugDrawPipelineType pipelineType) {m_pipeline_type = pipelineType; } + void initialize(); + void destory(); + const DebugDrawPipelineBase &getPipeline() const; + const DebugDrawFramebuffer &getFramebuffer() const; + + void recreateAfterSwapchain(); + + private: + void setupAttachments(); + void setupFramebuffer(); + void setupRenderPass(); + void setupDescriptorLayout(); + void setupPipelines(); + + RHIDescriptorSetLayout* m_descriptor_layout; + std::vector m_render_pipelines; + DebugDrawFramebuffer m_framebuffer; + std::shared_ptr m_rhi; + + }; +} diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_primitive.cpp b/engine/source/runtime/function/render/debugdraw/debug_draw_primitive.cpp new file mode 100644 index 000000000..11d4329b6 --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_primitive.cpp @@ -0,0 +1,45 @@ +#include "debug_draw_primitive.h" +namespace Piccolo +{ + bool Piccolo::DebugDrawPrimitive::isTimeOut(float delta_time) + { + if (m_time_type == _debugDrawTimeType_infinity) + { + return false; + } + else if (m_time_type == _debugDrawTimeType_one_frame) + { + if (!m_rendered) + { + m_rendered = true; + return false; + } + else return true; + } + else + { + m_life_time -= delta_time; + return (m_life_time < 0.0f); + } + return false; + } + + void Piccolo::DebugDrawPrimitive::setTime(float in_life_time) + { + if (fabs(in_life_time - k_debug_draw_infinity_life_time) < 1e-6) + { + m_time_type = _debugDrawTimeType_infinity; + m_life_time = 0.0f; + } + else if (fabs(in_life_time - k_debug_draw_one_frame) < 1e-6) + { + m_time_type = _debugDrawTimeType_one_frame; + m_life_time = 0.03f; + } + else + { + m_time_type = _debugDrawTimeType_common; + m_life_time = in_life_time; + } + } +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/debugdraw/debug_draw_primitive.h b/engine/source/runtime/function/render/debugdraw/debug_draw_primitive.h new file mode 100644 index 000000000..acd10ac05 --- /dev/null +++ b/engine/source/runtime/function/render/debugdraw/debug_draw_primitive.h @@ -0,0 +1,185 @@ +#pragma once + +#include "runtime/function/render/interface/rhi.h" +#include "runtime/core/math/math_headers.h" + +#include + +namespace Piccolo +{ + + static const float k_debug_draw_infinity_life_time = -2.f; + static const float k_debug_draw_one_frame = 0.0f; + + enum DebugDrawTimeType : uint8_t + { + _debugDrawTimeType_infinity, + _debugDrawTimeType_one_frame, + _debugDrawTimeType_common + }; + + enum DebugDrawPrimitiveType : uint8_t + { + _debug_draw_primitive_type_point = 0, + _debug_draw_primitive_type_line, + _debug_draw_primitive_type_triangle, + _debug_draw_primitive_type_quad, + _debug_draw_primitive_type_draw_box, + _debug_draw_primitive_type_cylinder, + _debug_draw_primitive_type_sphere, + _debug_draw_primitive_type_capsule, + _debug_draw_primitive_type_text, + k_debug_draw_primitive_type_count + }; + enum FillMode : uint8_t + { + _FillMode_wireframe = 0, + _FillMode_solid = 1, + k_FillMode_count, + }; + + struct DebugDrawVertex + { + Vector3 pos; + Vector4 color; + Vector2 texcoord; + DebugDrawVertex() { pos = Vector3(-1.0f, -1.0f, -1.0f); color = Vector4(-1.0f, -1.0f, -1.0f, -1.0f); texcoord = Vector2(-1.0f, -1.0f); } + + static std::array getBindingDescriptions() + { + std::arraybinding_descriptions; + binding_descriptions[0].binding = 0; + binding_descriptions[0].stride = sizeof(DebugDrawVertex); + binding_descriptions[0].inputRate = RHI_VERTEX_INPUT_RATE_VERTEX; + + return binding_descriptions; + } + + static std::array getAttributeDescriptions() + { + std::array attribute_descriptions{}; + + // position + attribute_descriptions[0].binding = 0; + attribute_descriptions[0].location = 0; + attribute_descriptions[0].format = RHI_FORMAT_R32G32B32_SFLOAT; + attribute_descriptions[0].offset = offsetof(DebugDrawVertex, pos); + + // color + attribute_descriptions[1].binding = 0; + attribute_descriptions[1].location = 1; + attribute_descriptions[1].format = RHI_FORMAT_R32G32B32A32_SFLOAT; + attribute_descriptions[1].offset = offsetof(DebugDrawVertex, color); + + // texcoord + attribute_descriptions[2].binding = 0; + attribute_descriptions[2].location = 2; + attribute_descriptions[2].format = RHI_FORMAT_R32G32_SFLOAT; + attribute_descriptions[2].offset = offsetof(DebugDrawVertex, texcoord); + + return attribute_descriptions; + } + }; + + class DebugDrawPrimitive + { + public: + DebugDrawTimeType m_time_type{ _debugDrawTimeType_infinity }; + float m_life_time{ 0.f }; + FillMode m_fill_mode{ _FillMode_wireframe }; + bool m_no_depth_test = false; + + public: + bool isTimeOut(float delta_time); + void setTime(float in_life_time); + + private: + bool m_rendered = false;// for one frame object + }; + + class DebugDrawPoint : public DebugDrawPrimitive + { + public: + DebugDrawVertex m_vertex; + static const DebugDrawPrimitiveType k_type_enum_value = _debug_draw_primitive_type_point; + }; + + class DebugDrawLine : public DebugDrawPrimitive + { + public: + DebugDrawVertex m_vertex[2]; + static const DebugDrawPrimitiveType k_type_enum_value = _debug_draw_primitive_type_line; + }; + + class DebugDrawTriangle : public DebugDrawPrimitive + { + public: + DebugDrawVertex m_vertex[3]; + static const DebugDrawPrimitiveType k_type_enum_value = _debug_draw_primitive_type_triangle; + }; + + class DebugDrawQuad : public DebugDrawPrimitive + { + public: + DebugDrawVertex m_vertex[4]; + + static const DebugDrawPrimitiveType k_type_enum_value = _debug_draw_primitive_type_quad; + }; + + class DebugDrawBox : public DebugDrawPrimitive + { + public: + Vector3 m_center_point; + Vector3 m_half_extents; + Vector4 m_color; + Vector4 m_rotate; + + static const DebugDrawPrimitiveType k_type_enum_value = _debug_draw_primitive_type_draw_box; + }; + + class DebugDrawCylinder : public DebugDrawPrimitive + { + public: + Vector3 m_center; + Vector4 m_rotate; + float m_radius{ 0.f }; + float m_height{ 0.f }; + Vector4 m_color; + + static const DebugDrawPrimitiveType k_type_enum_value = _debug_draw_primitive_type_cylinder; + }; + class DebugDrawSphere : public DebugDrawPrimitive + { + public: + Vector3 m_center; + float m_radius{ 0.f }; + Vector4 m_color; + + static const DebugDrawPrimitiveType k_type_enum_value = _debug_draw_primitive_type_sphere; + }; + + class DebugDrawCapsule : public DebugDrawPrimitive + { + public: + Vector3 m_center; + Vector4 m_rotation; + Vector3 m_scale; + float m_radius{ 0.f }; + float m_height{ 0.f }; + Vector4 m_color; + + static const DebugDrawPrimitiveType k_type_enum_value = _debug_draw_primitive_type_capsule; + }; + + class DebugDrawText : public DebugDrawPrimitive + { + public: + std::string m_content; + Vector4 m_color; + Vector3 m_coordinate; + int m_size; + bool m_is_screen_text; + + static const DebugDrawPrimitiveType k_type_enum_value = _debug_draw_primitive_type_text; + }; +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/interface/rhi.h b/engine/source/runtime/function/render/interface/rhi.h new file mode 100644 index 000000000..ecf8f6f75 --- /dev/null +++ b/engine/source/runtime/function/render/interface/rhi.h @@ -0,0 +1,178 @@ +#pragma once + +#define GLFW_INCLUDE_VULKAN +#include +#include + +#include +#include +#include + +#include "rhi_struct.h" +namespace Piccolo +{ + class WindowSystem; + + struct RHIInitInfo + { + std::shared_ptr window_system; + }; + + class RHI + { + public: + virtual ~RHI() = 0; + + virtual void initialize(RHIInitInfo initialize_info) = 0; + virtual void prepareContext() = 0; + + virtual bool isPointLightShadowEnabled() = 0; + // allocate and create + virtual bool allocateCommandBuffers(const RHICommandBufferAllocateInfo* pAllocateInfo, RHICommandBuffer* &pCommandBuffers) = 0; + virtual bool allocateDescriptorSets(const RHIDescriptorSetAllocateInfo* pAllocateInfo, RHIDescriptorSet* &pDescriptorSets) = 0; + virtual void createSwapchain() = 0; + virtual void recreateSwapchain() = 0; + virtual void createSwapchainImageViews() = 0; + virtual void createFramebufferImageAndView() = 0; + virtual RHISampler* getOrCreateDefaultSampler(RHIDefaultSamplerType type) = 0; + virtual RHISampler* getOrCreateMipmapSampler(uint32_t width, uint32_t height) = 0; + virtual RHIShader* createShaderModule(const std::vector& shader_code) = 0; + virtual void createBuffer(RHIDeviceSize size, RHIBufferUsageFlags usage, RHIMemoryPropertyFlags properties, RHIBuffer* &buffer, RHIDeviceMemory* &buffer_memory) = 0; + virtual void createBufferAndInitialize(RHIBufferUsageFlags usage, RHIMemoryPropertyFlags properties, RHIBuffer*& buffer, RHIDeviceMemory*& buffer_memory, RHIDeviceSize size, void* data = nullptr, int datasize = 0) = 0; + virtual bool createBufferVMA(VmaAllocator allocator, + const RHIBufferCreateInfo* pBufferCreateInfo, + const VmaAllocationCreateInfo* pAllocationCreateInfo, + RHIBuffer* &pBuffer, + VmaAllocation* pAllocation, + VmaAllocationInfo* pAllocationInfo) = 0; + virtual bool createBufferWithAlignmentVMA( + VmaAllocator allocator, + const RHIBufferCreateInfo* pBufferCreateInfo, + const VmaAllocationCreateInfo* pAllocationCreateInfo, + RHIDeviceSize minAlignment, + RHIBuffer* &pBuffer, + VmaAllocation* pAllocation, + VmaAllocationInfo* pAllocationInfo) = 0; + virtual void copyBuffer(RHIBuffer* srcBuffer, RHIBuffer* dstBuffer, RHIDeviceSize srcOffset, RHIDeviceSize dstOffset, RHIDeviceSize size) = 0; + virtual void createImage(uint32_t image_width, uint32_t image_height, RHIFormat format, RHIImageTiling image_tiling, RHIImageUsageFlags image_usage_flags, RHIMemoryPropertyFlags memory_property_flags, + RHIImage* &image, RHIDeviceMemory* &memory, RHIImageCreateFlags image_create_flags, uint32_t array_layers, uint32_t miplevels) = 0; + virtual void createImageView(RHIImage* image, RHIFormat format, RHIImageAspectFlags image_aspect_flags, RHIImageViewType view_type, uint32_t layout_count, uint32_t miplevels, + RHIImageView* &image_view) = 0; + virtual void createGlobalImage(RHIImage* &image, RHIImageView* &image_view, VmaAllocation& image_allocation, uint32_t texture_image_width, uint32_t texture_image_height, void* texture_image_pixels, RHIFormat texture_image_format, uint32_t miplevels = 0) = 0; + virtual void createCubeMap(RHIImage* &image, RHIImageView* &image_view, VmaAllocation& image_allocation, uint32_t texture_image_width, uint32_t texture_image_height, std::array texture_image_pixels, RHIFormat texture_image_format, uint32_t miplevels) = 0; + virtual void createCommandPool() = 0; + virtual bool createCommandPool(const RHICommandPoolCreateInfo* pCreateInfo, RHICommandPool*& pCommandPool) = 0; + virtual bool createDescriptorPool(const RHIDescriptorPoolCreateInfo* pCreateInfo, RHIDescriptorPool* &pDescriptorPool) = 0; + virtual bool createDescriptorSetLayout(const RHIDescriptorSetLayoutCreateInfo* pCreateInfo, RHIDescriptorSetLayout* &pSetLayout) = 0; + virtual bool createFence(const RHIFenceCreateInfo* pCreateInfo, RHIFence* &pFence) = 0; + virtual bool createFramebuffer(const RHIFramebufferCreateInfo* pCreateInfo, RHIFramebuffer* &pFramebuffer) = 0; + virtual bool createGraphicsPipelines(RHIPipelineCache* pipelineCache, uint32_t createInfoCount, const RHIGraphicsPipelineCreateInfo* pCreateInfos, RHIPipeline* &pPipelines) = 0; + virtual bool createComputePipelines(RHIPipelineCache* pipelineCache, uint32_t createInfoCount, const RHIComputePipelineCreateInfo* pCreateInfos, RHIPipeline* &pPipelines) = 0; + virtual bool createPipelineLayout(const RHIPipelineLayoutCreateInfo* pCreateInfo, RHIPipelineLayout* &pPipelineLayout) = 0; + virtual bool createRenderPass(const RHIRenderPassCreateInfo* pCreateInfo, RHIRenderPass* &pRenderPass) = 0; + virtual bool createSampler(const RHISamplerCreateInfo* pCreateInfo, RHISampler* &pSampler) = 0; + virtual bool createSemaphore(const RHISemaphoreCreateInfo* pCreateInfo, RHISemaphore* &pSemaphore) = 0; + + // command and command write + virtual bool waitForFencesPFN(uint32_t fenceCount, RHIFence* const* pFence, RHIBool32 waitAll, uint64_t timeout) = 0; + virtual bool resetFencesPFN(uint32_t fenceCount, RHIFence* const* pFences) = 0; + virtual bool resetCommandPoolPFN(RHICommandPool* commandPool, RHICommandPoolResetFlags flags) = 0; + virtual bool beginCommandBufferPFN(RHICommandBuffer* commandBuffer, const RHICommandBufferBeginInfo* pBeginInfo) = 0; + virtual bool endCommandBufferPFN(RHICommandBuffer* commandBuffer) = 0; + virtual void cmdBeginRenderPassPFN(RHICommandBuffer* commandBuffer, const RHIRenderPassBeginInfo* pRenderPassBegin, RHISubpassContents contents) = 0; + virtual void cmdNextSubpassPFN(RHICommandBuffer* commandBuffer, RHISubpassContents contents) = 0; + virtual void cmdEndRenderPassPFN(RHICommandBuffer* commandBuffer) = 0; + virtual void cmdBindPipelinePFN(RHICommandBuffer* commandBuffer, RHIPipelineBindPoint pipelineBindPoint, RHIPipeline* pipeline) = 0; + virtual void cmdSetViewportPFN(RHICommandBuffer* commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const RHIViewport* pViewports) = 0; + virtual void cmdSetScissorPFN(RHICommandBuffer* commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const RHIRect2D* pScissors) = 0; + virtual void cmdBindVertexBuffersPFN( + RHICommandBuffer* commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + RHIBuffer* const* pBuffers, + const RHIDeviceSize* pOffsets) = 0; + virtual void cmdBindIndexBufferPFN(RHICommandBuffer* commandBuffer, RHIBuffer* buffer, RHIDeviceSize offset, RHIIndexType indexType) = 0; + virtual void cmdBindDescriptorSetsPFN( + RHICommandBuffer* commandBuffer, + RHIPipelineBindPoint pipelineBindPoint, + RHIPipelineLayout* layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const RHIDescriptorSet* const* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets) = 0; + virtual void cmdDrawIndexedPFN(RHICommandBuffer* commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) = 0; + virtual void cmdClearAttachmentsPFN(RHICommandBuffer* commandBuffer, uint32_t attachmentCount, const RHIClearAttachment* pAttachments, uint32_t rectCount, const RHIClearRect* pRects) = 0; + + virtual bool beginCommandBuffer(RHICommandBuffer* commandBuffer, const RHICommandBufferBeginInfo* pBeginInfo) = 0; + virtual void cmdCopyImageToBuffer(RHICommandBuffer* commandBuffer, RHIImage* srcImage, RHIImageLayout srcImageLayout, RHIBuffer* dstBuffer, uint32_t regionCount, const RHIBufferImageCopy* pRegions) = 0; + virtual void cmdCopyImageToImage(RHICommandBuffer* commandBuffer, RHIImage* srcImage, RHIImageAspectFlagBits srcFlag, RHIImage* dstImage, RHIImageAspectFlagBits dstFlag, uint32_t width, uint32_t height) = 0; + virtual void cmdCopyBuffer(RHICommandBuffer* commandBuffer, RHIBuffer* srcBuffer, RHIBuffer* dstBuffer, uint32_t regionCount, RHIBufferCopy* pRegions) = 0; + virtual void cmdDraw(RHICommandBuffer* commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) = 0; + virtual void cmdDispatch(RHICommandBuffer* commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) = 0; + virtual void cmdDispatchIndirect(RHICommandBuffer* commandBuffer, RHIBuffer* buffer, RHIDeviceSize offset) = 0; + virtual void cmdPipelineBarrier(RHICommandBuffer* commandBuffer, RHIPipelineStageFlags srcStageMask, RHIPipelineStageFlags dstStageMask, RHIDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const RHIMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const RHIBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const RHIImageMemoryBarrier* pImageMemoryBarriers) = 0; + virtual bool endCommandBuffer(RHICommandBuffer* commandBuffer) = 0; + virtual void updateDescriptorSets(uint32_t descriptorWriteCount, const RHIWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const RHICopyDescriptorSet* pDescriptorCopies) = 0; + virtual bool queueSubmit(RHIQueue* queue, uint32_t submitCount, const RHISubmitInfo* pSubmits, RHIFence* fence) = 0; + virtual bool queueWaitIdle(RHIQueue* queue) = 0; + virtual void resetCommandPool() = 0; + virtual void waitForFences() = 0; + + // query + virtual void getPhysicalDeviceProperties(RHIPhysicalDeviceProperties* pProperties) = 0; + virtual RHICommandBuffer* getCurrentCommandBuffer() const = 0; + virtual RHICommandBuffer* const* getCommandBufferList() const = 0; + virtual RHICommandPool* getCommandPoor() const = 0; + virtual RHIDescriptorPool* getDescriptorPoor() const = 0; + virtual RHIFence* const* getFenceList() const = 0; + virtual QueueFamilyIndices getQueueFamilyIndices() const = 0; + virtual RHIQueue* getGraphicsQueue() const = 0; + virtual RHIQueue* getComputeQueue() const = 0; + virtual RHISwapChainDesc getSwapchainInfo() = 0; + virtual RHIDepthImageDesc getDepthImageInfo() const = 0; + virtual uint8_t getMaxFramesInFlight() const = 0; + virtual uint8_t getCurrentFrameIndex() const = 0; + virtual void setCurrentFrameIndex(uint8_t index) = 0; + + // command write + virtual RHICommandBuffer* beginSingleTimeCommands() = 0; + virtual void endSingleTimeCommands(RHICommandBuffer* command_buffer) = 0; + virtual bool prepareBeforePass(std::function passUpdateAfterRecreateSwapchain) = 0; + virtual void submitRendering(std::function passUpdateAfterRecreateSwapchain) = 0; + virtual void pushEvent(RHICommandBuffer* commond_buffer, const char* name, const float* color) = 0; + virtual void popEvent(RHICommandBuffer* commond_buffer) = 0; + + // destory + virtual void clear() = 0; + virtual void clearSwapchain() = 0; + virtual void destroyDefaultSampler(RHIDefaultSamplerType type) = 0; + virtual void destroyMipmappedSampler() = 0; + virtual void destroyShaderModule(RHIShader* shader) = 0; + virtual void destroySemaphore(RHISemaphore* semaphore) = 0; + virtual void destroySampler(RHISampler* sampler) = 0; + virtual void destroyInstance(RHIInstance* instance) = 0; + virtual void destroyImageView(RHIImageView* imageView) = 0; + virtual void destroyImage(RHIImage* image) = 0; + virtual void destroyFramebuffer(RHIFramebuffer* framebuffer) = 0; + virtual void destroyFence(RHIFence* fence) = 0; + virtual void destroyDevice() = 0; + virtual void destroyCommandPool(RHICommandPool* commandPool) = 0; + virtual void destroyBuffer(RHIBuffer* &buffer) = 0; + virtual void freeCommandBuffers(RHICommandPool* commandPool, uint32_t commandBufferCount, RHICommandBuffer* pCommandBuffers) = 0; + + // memory + virtual void freeMemory(RHIDeviceMemory* &memory) = 0; + virtual bool mapMemory(RHIDeviceMemory* memory, RHIDeviceSize offset, RHIDeviceSize size, RHIMemoryMapFlags flags, void** ppData) = 0; + virtual void unmapMemory(RHIDeviceMemory* memory) = 0; + virtual void invalidateMappedMemoryRanges(void* pNext, RHIDeviceMemory* memory, RHIDeviceSize offset, RHIDeviceSize size) = 0; + virtual void flushMappedMemoryRanges(void* pNext, RHIDeviceMemory* memory, RHIDeviceSize offset, RHIDeviceSize size) = 0; + + //semaphores + virtual RHISemaphore* &getTextureCopySemaphore(uint32_t index) = 0; + + private: + }; + + inline RHI::~RHI() = default; +} // namespace Piccolo diff --git a/engine/source/runtime/function/render/interface/rhi_struct.h b/engine/source/runtime/function/render/interface/rhi_struct.h new file mode 100644 index 000000000..362add3f6 --- /dev/null +++ b/engine/source/runtime/function/render/interface/rhi_struct.h @@ -0,0 +1,1134 @@ +#pragma once + +#include "runtime/function/render/render_type.h" +#include +namespace Piccolo +{ + ///////////////////////////////////////////////// + #define RHI_DELETE_PTR(x) delete x; x = nullptr; + + ////////////////////class//////////////////////// + class RHIBuffer { }; + class RHIBufferView { }; + class RHICommandBuffer { }; + class RHICommandPool { }; + class RHIDescriptorPool { }; + class RHIDescriptorSet { }; + class RHIDescriptorSetLayout { }; + class RHIDevice { }; + class RHIDeviceMemory { }; + class RHIEvent { }; + class RHIFence { }; + class RHIFramebuffer { }; + class RHIImage { }; + class RHIImageView { }; + class RHIInstance { }; + class RHIQueue { }; + class RHIPhysicalDevice { }; + class RHIPipeline { }; + class RHIPipelineCache { }; + class RHIPipelineLayout { }; + class RHIRenderPass { }; + class RHISampler { }; + class RHISemaphore { }; + class RHIShader { }; + + + ////////////////////struct////////////////////////// + struct RHIMemoryBarrier; + struct RHICopyDescriptorSet; + struct RHIDescriptorImageInfo; + struct RHIDescriptorBufferInfo; + struct RHIOffset2D; + struct RHISpecializationMapEntry; + struct RHIBufferMemoryBarrier; + struct RHIImageSubresourceRange; + struct RHIImageMemoryBarrier; + struct RHIExtent2D; + struct RHIExtent3D; + struct RHIApplicationInfo; + struct RHIAttachmentDescription; + struct RHIBufferCopy; + struct RHIBufferCreateInfo; + struct RHIBufferImageCopy; + struct RHICommandBufferAllocateInfo; + struct RHICommandBufferBeginInfo; + struct RHICommandBufferInheritanceInfo; + struct RHICommandPoolCreateInfo; + struct RHIDescriptorPoolSize; + struct RHIDescriptorPoolCreateInfo; + struct RHIDescriptorSetAllocateInfo; + struct RHIDescriptorSetLayoutBinding; + struct RHIDescriptorSetLayoutCreateInfo; + struct RHIDeviceCreateInfo; + struct RHIDeviceQueueCreateInfo; + struct RHIExtensionProperties; + struct RHIFenceCreateInfo; + struct RHIFormatProperties; + struct RHIFramebufferCreateInfo; + struct RHIGraphicsPipelineCreateInfo; + struct RHIComputePipelineCreateInfo; + struct RHIImageBlit; + struct RHIImageCreateInfo; + struct RHIImageFormatProperties; + struct RHIImageViewCreateInfo; + struct RHIInstanceCreateInfo; + struct RHILayerProperties; + struct RHIMemoryAllocateInfo; + struct RHIMemoryHeap; + struct RHIMemoryRequirements; + struct RHIMemoryType; + struct RHIPhysicalDeviceFeatures; + struct RHIPhysicalDeviceLimits; + struct RHIPhysicalDeviceMemoryProperties; + struct RHIPhysicalDeviceProperties; + struct RHIPhysicalDeviceSparseProperties; + struct RHIPipelineColorBlendStateCreateInfo; + struct RHIPipelineDepthStencilStateCreateInfo; + struct RHIPipelineDynamicStateCreateInfo; + struct RHIPipelineInputAssemblyStateCreateInfo; + struct RHIPipelineLayoutCreateInfo; + struct RHIPipelineMultisampleStateCreateInfo; + struct RHIPipelineRasterizationStateCreateInfo; + struct RHIPipelineShaderStageCreateInfo; + struct RHIPipelineTessellationStateCreateInfo; + struct RHIPipelineVertexInputStateCreateInfo; + struct RHIPipelineViewportStateCreateInfo; + struct RHIPushConstantRange; + struct RHIQueueFamilyProperties; + struct RHIRenderPassCreateInfo; + struct RHISamplerCreateInfo; + struct RHISemaphoreCreateInfo; + struct RHIShaderModuleCreateInfo; + struct RHISubmitInfo; + struct RHISubpassDependency; + struct RHISubpassDescription; + struct RHIWriteDescriptorSet; + struct RHIOffset3D; + struct RHIAttachmentReference; + struct RHIComponentMapping; + struct RHIImageSubresourceLayers; + struct RHIPipelineColorBlendAttachmentState; + struct RHIRect2D; + struct RHISpecializationInfo; + struct RHIStencilOpState; + struct RHIVertexInputAttributeDescription; + struct RHIVertexInputBindingDescription; + struct RHIViewport; + struct RHIRenderPassBeginInfo; + union RHIClearValue; + union RHIClearColorValue; + struct RHIClearDepthStencilValue; + + ////////////////////struct declaration//////////////////////// + struct RHIMemoryBarrier { + RHIStructureType sType; + const void* pNext; + RHIAccessFlags srcAccessMask; + RHIAccessFlags dstAccessMask; + }; + + struct RHICopyDescriptorSet { + RHIStructureType sType; + const void* pNext; + RHIDescriptorSet* srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + RHIDescriptorSet* dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + }; + + struct RHIDescriptorImageInfo { + RHISampler* sampler; + RHIImageView* imageView; + RHIImageLayout imageLayout; + }; + + struct RHIDescriptorBufferInfo { + RHIBuffer* buffer; + RHIDeviceSize offset; + RHIDeviceSize range; + }; + + struct RHIOffset2D { + int32_t x; + int32_t y; + }; + + struct RHISpecializationMapEntry { + uint32_t constantID; + uint32_t offset; + size_t size; + }; + + struct RHIBufferMemoryBarrier { + RHIStructureType sType; + const void* pNext; + RHIAccessFlags srcAccessMask; + RHIAccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + RHIBuffer* buffer; + RHIDeviceSize offset; + RHIDeviceSize size; + }; + + struct RHIImageSubresourceRange { + RHIImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; + }; + + struct RHIImageMemoryBarrier { + RHIStructureType sType; + const void* pNext; + RHIAccessFlags srcAccessMask; + RHIAccessFlags dstAccessMask; + RHIImageLayout oldLayout; + RHIImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + RHIImage* image; + RHIImageSubresourceRange subresourceRange; + }; + + struct RHIExtent2D { + uint32_t width; + uint32_t height; + }; + + struct RHIExtent3D { + uint32_t width; + uint32_t height; + uint32_t depth; + }; + + struct RHIApplicationInfo + { + RHIStructureType sType; + const void* pNext; + const char* pApplicationName; + uint32_t applicationVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; + }; + + struct RHIAttachmentDescription + { + RHIAttachmentDescriptionFlags flags; + RHIFormat format; + RHISampleCountFlagBits samples; + RHIAttachmentLoadOp loadOp; + RHIAttachmentStoreOp storeOp; + RHIAttachmentLoadOp stencilLoadOp; + RHIAttachmentStoreOp stencilStoreOp; + RHIImageLayout initialLayout; + RHIImageLayout finalLayout; + }; + + struct RHIBufferCopy + { + RHIDeviceSize srcOffset; + RHIDeviceSize dstOffset; + RHIDeviceSize size; + }; + + struct RHIBufferCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIBufferCreateFlags flags; + RHIDeviceSize size; + RHIBufferUsageFlags usage; + RHISharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + }; + + struct RHIOffset3D + { + int32_t x; + int32_t y; + int32_t z; + }; + + struct RHIImageSubresourceLayers + { + RHIImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; + }; + + struct RHIBufferImageCopy + { + RHIDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + RHIImageSubresourceLayers imageSubresource; + RHIOffset3D imageOffset; + RHIExtent3D imageExtent; + }; + + struct RHICommandBufferAllocateInfo + { + RHIStructureType sType; + const void* pNext; + RHICommandPool* commandPool; + RHICommandBufferLevel level; + uint32_t commandBufferCount; + }; + + struct RHICommandBufferBeginInfo + { + RHIStructureType sType; + const void* pNext; + RHICommandBufferUsageFlags flags; + const RHICommandBufferInheritanceInfo* pInheritanceInfo; + }; + + struct RHICommandBufferInheritanceInfo + { + RHIStructureType sType; + const void* pNext; + RHIRenderPass* renderPass; + uint32_t subpass; + RHIFramebuffer* framebuffer; + RHIBool32 occlusionQueryEnable; + RHIQueryControlFlags queryFlags; + RHIQueryPipelineStatisticFlags pipelineStatistics; + }; + + struct RHICommandPoolCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHICommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; + }; + + struct RHIDescriptorPoolSize + { + RHIDescriptorType type; + uint32_t descriptorCount; + }; + + struct RHIDescriptorPoolCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const RHIDescriptorPoolSize* pPoolSizes; + }; + + struct RHIDescriptorSetAllocateInfo + { + RHIStructureType sType; + const void* pNext; + RHIDescriptorPool* descriptorPool; + uint32_t descriptorSetCount; + const RHIDescriptorSetLayout* const* pSetLayouts; + }; + + struct RHIDescriptorSetLayoutBinding + { + uint32_t binding; + RHIDescriptorType descriptorType; + uint32_t descriptorCount; + RHIShaderStageFlags stageFlags; + RHISampler* const* pImmutableSamplers = nullptr; + }; + + struct RHIDescriptorSetLayoutCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const RHIDescriptorSetLayoutBinding* pBindings; + }; + + struct RHIDeviceCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const RHIDeviceQueueCreateInfo** pQueueCreateInfos; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const RHIPhysicalDeviceFeatures** pEnabledFeatures; + }; + + struct RHIDeviceQueueCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities; + }; + + struct RHIExtensionProperties + { + char extensionName[RHI_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + }; + + struct RHIFenceCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIFenceCreateFlags flags; + }; + + struct RHIFormatProperties + { + RHIFormatFeatureFlags linearTilingFeatures; + RHIFormatFeatureFlags optimalTilingFeatures; + RHIFormatFeatureFlags bufferFeatures; + }; + + struct RHIFramebufferCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIFramebufferCreateFlags flags; + RHIRenderPass* renderPass; + uint32_t attachmentCount; + RHIImageView* const* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; + }; + + struct RHIGraphicsPipelineCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineCreateFlags flags; + uint32_t stageCount; + const RHIPipelineShaderStageCreateInfo* pStages; + const RHIPipelineVertexInputStateCreateInfo* pVertexInputState; + const RHIPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const RHIPipelineTessellationStateCreateInfo* pTessellationState; + const RHIPipelineViewportStateCreateInfo* pViewportState; + const RHIPipelineRasterizationStateCreateInfo* pRasterizationState; + const RHIPipelineMultisampleStateCreateInfo* pMultisampleState; + const RHIPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const RHIPipelineColorBlendStateCreateInfo* pColorBlendState; + const RHIPipelineDynamicStateCreateInfo* pDynamicState; + RHIPipelineLayout* layout; + RHIRenderPass* renderPass; + uint32_t subpass; + RHIPipeline* basePipelineHandle; + int32_t basePipelineIndex; + }; + + struct RHIComputePipelineCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineCreateFlags flags; + RHIPipelineShaderStageCreateInfo* pStages; + RHIPipelineLayout* layout; + RHIPipeline* basePipelineHandle; + int32_t basePipelineIndex; + }; + + struct RHIImageBlit + { + RHIImageSubresourceLayers srcSubresource; + RHIOffset3D srcOffsets[2]; + RHIImageSubresourceLayers dstSubresource; + RHIOffset3D dstOffsets[2]; + }; + + struct RHIImageCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIImageCreateFlags flags; + RHIImageType imageType; + RHIFormat format; + RHIExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + RHISampleCountFlagBits samples; + RHIImageTiling tiling; + RHIImageUsageFlags usage; + RHISharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + RHIImageLayout initialLayout; + }; + + struct RHIImageFormatProperties + { + RHIExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + RHISampleCountFlags sampleCounts; + RHIDeviceSize maxResourceSize; + }; + + struct RHIComponentMapping + { + RHIComponentSwizzle r; + RHIComponentSwizzle g; + RHIComponentSwizzle b; + RHIComponentSwizzle a; + }; + + struct RHIImageViewCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIImageViewCreateFlags flags; + RHIImage* image; + RHIImageViewType viewType; + RHIFormat format; + RHIComponentMapping components; + RHIImageSubresourceRange subresourceRange; + }; + + struct RHIInstanceCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIInstanceCreateFlags flags; + const RHIApplicationInfo** pApplicationInfo; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + }; + + struct RHILayerProperties + { + char layerName[RHI_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[RHI_MAX_DESCRIPTION_SIZE]; + }; + + struct RHIMemoryAllocateInfo + { + RHIStructureType sType; + const void* pNext; + RHIDeviceSize allocationSize; + uint32_t memoryTypeIndex; + }; + + struct RHIMemoryHeap + { + RHIDeviceSize size; + RHIMemoryHeapFlags flags; + }; + + struct RHIMemoryRequirements + { + RHIDeviceSize size; + RHIDeviceSize alignment; + uint32_t memoryTypeBits; + }; + + struct RHIMemoryType + { + RHIMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; + }; + + struct RHIPhysicalDeviceFeatures + { + RHIBool32 robustBufferAccess; + RHIBool32 fullDrawIndexUint32; + RHIBool32 imageCubeArray; + RHIBool32 independentBlend; + RHIBool32 geometryShader; + RHIBool32 tessellationShader; + RHIBool32 sampleRateShading; + RHIBool32 dualSrcBlend; + RHIBool32 logicOp; + RHIBool32 multiDrawIndirect; + RHIBool32 drawIndirectFirstInstance; + RHIBool32 depthClamp; + RHIBool32 depthBiasClamp; + RHIBool32 fillModeNonSolid; + RHIBool32 depthBounds; + RHIBool32 wideLines; + RHIBool32 largePoints; + RHIBool32 alphaToOne; + RHIBool32 multiViewport; + RHIBool32 samplerAnisotropy; + RHIBool32 textureCompressionETC2; + RHIBool32 textureCompressionASTC_LDR; + RHIBool32 textureCompressionBC; + RHIBool32 occlusionQueryPrecise; + RHIBool32 pipelineStatisticsQuery; + RHIBool32 vertexPipelineStoresAndAtomics; + RHIBool32 fragmentStoresAndAtomics; + RHIBool32 shaderTessellationAndGeometryPointSize; + RHIBool32 shaderImageGatherExtended; + RHIBool32 shaderStorageImageExtendedFormats; + RHIBool32 shaderStorageImageMultisample; + RHIBool32 shaderStorageImageReadWithoutFormat; + RHIBool32 shaderStorageImageWriteWithoutFormat; + RHIBool32 shaderUniformBufferArrayDynamicIndexing; + RHIBool32 shaderSampledImageArrayDynamicIndexing; + RHIBool32 shaderStorageBufferArrayDynamicIndexing; + RHIBool32 shaderStorageImageArrayDynamicIndexing; + RHIBool32 shaderClipDistance; + RHIBool32 shaderCullDistance; + RHIBool32 shaderFloat64; + RHIBool32 shaderInt64; + RHIBool32 shaderInt16; + RHIBool32 shaderResourceResidency; + RHIBool32 shaderResourceMinLod; + RHIBool32 sparseBinding; + RHIBool32 sparseResidencyBuffer; + RHIBool32 sparseResidencyImage2D; + RHIBool32 sparseResidencyImage3D; + RHIBool32 sparseResidency2Samples; + RHIBool32 sparseResidency4Samples; + RHIBool32 sparseResidency8Samples; + RHIBool32 sparseResidency16Samples; + RHIBool32 sparseResidencyAliased; + RHIBool32 variableMultisampleRate; + RHIBool32 inheritedQueries; + }; + + struct RHIPhysicalDeviceLimits + { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + RHIDeviceSize bufferImageGranularity; + RHIDeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + RHIDeviceSize minTexelBufferOffsetAlignment; + RHIDeviceSize minUniformBufferOffsetAlignment; + RHIDeviceSize minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + RHISampleCountFlags framebufferColorSampleCounts; + RHISampleCountFlags framebufferDepthSampleCounts; + RHISampleCountFlags framebufferStencilSampleCounts; + RHISampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + RHISampleCountFlags sampledImageColorSampleCounts; + RHISampleCountFlags sampledImageIntegerSampleCounts; + RHISampleCountFlags sampledImageDepthSampleCounts; + RHISampleCountFlags sampledImageStencilSampleCounts; + RHISampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + RHIBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + RHIBool32 strictLines; + RHIBool32 standardSampleLocations; + RHIDeviceSize optimalBufferCopyOffsetAlignment; + RHIDeviceSize optimalBufferCopyRowPitchAlignment; + RHIDeviceSize nonCoherentAtomSize; + }; + + struct RHIPhysicalDeviceMemoryProperties + { + uint32_t memoryTypeCount; + RHIMemoryType memoryTypes[RHI_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + RHIMemoryHeap memoryHeaps[RHI_MAX_MEMORY_HEAPS]; + }; + + struct RHIPhysicalDeviceSparseProperties + { + RHIBool32 residencyStandard2DBlockShape; + RHIBool32 residencyStandard2DMultisampleBlockShape; + RHIBool32 residencyStandard3DBlockShape; + RHIBool32 residencyAlignedMipSize; + RHIBool32 residencyNonResidentStrict; + }; + + struct RHIPhysicalDeviceProperties + { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + RHIPhysicalDeviceType deviceType; + char deviceName[RHI_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[RHI_UUID_SIZE]; + RHIPhysicalDeviceLimits limits; + RHIPhysicalDeviceSparseProperties sparseProperties; + }; + + struct RHIPipelineColorBlendStateCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineColorBlendStateCreateFlags flags; + RHIBool32 logicOpEnable; + RHILogicOp logicOp; + uint32_t attachmentCount; + const RHIPipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; + }; + + struct RHIStencilOpState + { + RHIStencilOp failOp; + RHIStencilOp passOp; + RHIStencilOp depthFailOp; + RHICompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; + }; + + struct RHIPipelineDepthStencilStateCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineDepthStencilStateCreateFlags flags; + RHIBool32 depthTestEnable; + RHIBool32 depthWriteEnable; + RHICompareOp depthCompareOp; + RHIBool32 depthBoundsTestEnable; + RHIBool32 stencilTestEnable; + RHIStencilOpState front; + RHIStencilOpState back; + float minDepthBounds; + float maxDepthBounds; + }; + + struct RHIPipelineDynamicStateCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const RHIDynamicState* pDynamicStates; + }; + + struct RHIPipelineInputAssemblyStateCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineInputAssemblyStateCreateFlags flags; + RHIPrimitiveTopology topology; + RHIBool32 primitiveRestartEnable; + }; + + struct RHIPipelineLayoutCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + RHIDescriptorSetLayout* const* pSetLayouts; + uint32_t pushConstantRangeCount; + const RHIPushConstantRange* pPushConstantRanges; + }; + + struct RHIPipelineMultisampleStateCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineMultisampleStateCreateFlags flags; + RHISampleCountFlagBits rasterizationSamples; + RHIBool32 sampleShadingEnable; + float minSampleShading; + const RHISampleMask** pSampleMask; + RHIBool32 alphaToCoverageEnable; + RHIBool32 alphaToOneEnable; + }; + + struct RHIPipelineRasterizationStateCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineRasterizationStateCreateFlags flags; + RHIBool32 depthClampEnable; + RHIBool32 rasterizerDiscardEnable; + RHIPolygonMode polygonMode; + RHICullModeFlags cullMode; + RHIFrontFace frontFace; + RHIBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; + }; + + struct RHIPipelineShaderStageCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineShaderStageCreateFlags flags; + RHIShaderStageFlagBits stage; + RHIShader* module; + const char* pName; + const RHISpecializationInfo* pSpecializationInfo; + }; + + struct RHIPipelineTessellationStateCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; + }; + + struct RHIPipelineVertexInputStateCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const RHIVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const RHIVertexInputAttributeDescription* pVertexAttributeDescriptions; + }; + + struct RHIPipelineViewportStateCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const RHIViewport* pViewports; + uint32_t scissorCount; + const RHIRect2D* pScissors; + }; + + struct RHIPushConstantRange + { + RHIShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + }; + + struct RHIQueueFamilyProperties + { + RHIQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + RHIExtent3D minImageTransferGranularity; + }; + + struct RHIRenderPassCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIRenderPassCreateFlags flags; + uint32_t attachmentCount; + const RHIAttachmentDescription* pAttachments; + uint32_t subpassCount; + const RHISubpassDescription* pSubpasses; + uint32_t dependencyCount; + const RHISubpassDependency* pDependencies; + }; + + struct RHISamplerCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHISamplerCreateFlags flags; + RHIFilter magFilter; + RHIFilter minFilter; + RHISamplerMipmapMode mipmapMode; + RHISamplerAddressMode addressModeU; + RHISamplerAddressMode addressModeV; + RHISamplerAddressMode addressModeW; + float mipLodBias; + RHIBool32 anisotropyEnable; + float maxAnisotropy; + RHIBool32 compareEnable; + RHICompareOp compareOp; + float minLod; + float maxLod; + RHIBorderColor borderColor; + RHIBool32 unnormalizedCoordinates; + }; + + struct RHISemaphoreCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHISemaphoreCreateFlags flags; + }; + + struct RHIShaderModuleCreateInfo + { + RHIStructureType sType; + const void* pNext; + RHIShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode; + }; + + struct RHISubmitInfo + { + RHIStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + RHISemaphore** pWaitSemaphores; + const RHIPipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + RHICommandBuffer* const* pCommandBuffers; + uint32_t signalSemaphoreCount; + const RHISemaphore** pSignalSemaphores; + }; + + struct RHISubpassDependency + { + uint32_t srcSubpass; + uint32_t dstSubpass; + RHIPipelineStageFlags srcStageMask; + RHIPipelineStageFlags dstStageMask; + RHIAccessFlags srcAccessMask; + RHIAccessFlags dstAccessMask; + RHIDependencyFlags dependencyFlags; + }; + + struct RHISubpassDescription + { + RHISubpassDescriptionFlags flags; + RHIPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const RHIAttachmentReference* pInputAttachments; + uint32_t colorAttachmentCount; + const RHIAttachmentReference* pColorAttachments; + const RHIAttachmentReference* pResolveAttachments; + const RHIAttachmentReference* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; + }; + + struct RHIWriteDescriptorSet + { + RHIStructureType sType; + const void* pNext; + RHIDescriptorSet* dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + RHIDescriptorType descriptorType; + RHIDescriptorImageInfo* pImageInfo = nullptr; + RHIDescriptorBufferInfo* pBufferInfo = nullptr; + RHIBufferView* pTexelBufferView = nullptr; + }; + + struct RHIAttachmentReference + { + uint32_t attachment; + RHIImageLayout layout; + }; + + struct RHIPipelineColorBlendAttachmentState + { + RHIBool32 blendEnable; + RHIBlendFactor srcColorBlendFactor; + RHIBlendFactor dstColorBlendFactor; + RHIBlendOp colorBlendOp; + RHIBlendFactor srcAlphaBlendFactor; + RHIBlendFactor dstAlphaBlendFactor; + RHIBlendOp alphaBlendOp; + RHIColorComponentFlags colorWriteMask; + }; + + struct RHIRect2D + { + RHIOffset2D offset; + RHIExtent2D extent; + }; + + struct RHISpecializationInfo + { + uint32_t mapEntryCount; + const RHISpecializationMapEntry** pMapEntries; + size_t dataSize; + const void* pData; + }; + + struct RHIVertexInputAttributeDescription + { + uint32_t location; + uint32_t binding; + RHIFormat format; + uint32_t offset; + }; + + struct RHIVertexInputBindingDescription + { + uint32_t binding; + uint32_t stride; + RHIVertexInputRate inputRate; + }; + + struct RHIViewport + { + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; + }; + + struct RHIRenderPassBeginInfo { + RHIStructureType sType; + const void* pNext; + RHIRenderPass* renderPass; + RHIFramebuffer* framebuffer; + RHIRect2D renderArea; + uint32_t clearValueCount; + const RHIClearValue* pClearValues; + }; + + struct RHIClearDepthStencilValue { + float depth; + uint32_t stencil; + }; + + union RHIClearColorValue { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; + }; + + union RHIClearValue { + RHIClearColorValue color; + RHIClearDepthStencilValue depthStencil; + }; + + struct RHIClearRect { + RHIRect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; + }; + + struct RHIClearAttachment { + RHIImageAspectFlags aspectMask; + uint32_t colorAttachment; + RHIClearValue clearValue; + }; + + struct RHISwapChainDesc + { + RHIExtent2D extent; + RHIFormat image_format; + RHIViewport* viewport; + RHIRect2D* scissor; + std::vector imageViews; + }; + + struct RHIDepthImageDesc + { + RHIImage* depth_image = VK_NULL_HANDLE; + RHIImageView* depth_image_view = VK_NULL_HANDLE; + RHIFormat depth_image_format; + }; + + struct QueueFamilyIndices + { + std::optional graphics_family; + std::optional present_family; + std::optional m_compute_family; + + bool isComplete() { return graphics_family.has_value() && present_family.has_value() && m_compute_family.has_value();; } + }; + + struct SwapChainSupportDetails + { + VkSurfaceCapabilitiesKHR capabilities; + std::vector formats; + std::vector presentModes; + }; +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/interface/vulkan/vulkan_rhi.cpp b/engine/source/runtime/function/render/interface/vulkan/vulkan_rhi.cpp new file mode 100644 index 000000000..e684a0f8f --- /dev/null +++ b/engine/source/runtime/function/render/interface/vulkan/vulkan_rhi.cpp @@ -0,0 +1,3610 @@ +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" + +#include "runtime/function/render/window_system.h" +#include "runtime/core/base/macro.h" + +#include +#include + +// https://gcc.gnu.org/onlinedocs/cpp/Stringizing.html +#define PICCOLO_XSTR(s) PICCOLO_STR(s) +#define PICCOLO_STR(s) #s + +#if defined(__GNUC__) +// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html +#if defined(__linux__) +#include +#elif defined(__MACH__) +// https://developer.apple.com/library/archive/documentation/Porting/Conceptual/PortingUnix/compiling/compiling.html +#include +#else +#error Unknown Platform +#endif +#elif defined(_MSC_VER) +// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros +#include +#define WIN32_LEAN_AND_MEAN 1 +#define NOGDICAPMASKS 1 +#define NOVIRTUALKEYCODES 1 +#define NOWINMESSAGES 1 +#define NOWINSTYLES 1 +#define NOSYSMETRICS 1 +#define NOMENUS 1 +#define NOICONS 1 +#define NOKEYSTATES 1 +#define NOSYSCOMMANDS 1 +#define NORASTEROPS 1 +#define NOSHOWWINDOW 1 +#define NOATOM 1 +#define NOCLIPBOARD 1 +#define NOCOLOR 1 +#define NOCTLMGR 1 +#define NODRAWTEXT 1 +#define NOGDI 1 +#define NOKERNEL 1 +#define NOUSER 1 +#define NONLS 1 +#define NOMB 1 +#define NOMEMMGR 1 +#define NOMETAFILE 1 +#define NOMINMAX 1 +#define NOMSG 1 +#define NOOPENFILE 1 +#define NOSCROLL 1 +#define NOSERVICE 1 +#define NOSOUND 1 +#define NOTEXTMETRIC 1 +#define NOWH 1 +#define NOWINOFFSETS 1 +#define NOCOMM 1 +#define NOKANJI 1 +#define NOHELP 1 +#define NOPROFILER 1 +#define NODEFERWINDOWPOS 1 +#define NOMCX 1 +#include +#else +#error Unknown Compiler +#endif + +#include +#include +#include +#include +#include + +namespace Piccolo +{ + VulkanRHI::~VulkanRHI() + { + // TODO + } + + void VulkanRHI::initialize(RHIInitInfo init_info) + { + m_window = init_info.window_system->getWindow(); + + std::array window_size = init_info.window_system->getWindowSize(); + + m_viewport = {0.0f, 0.0f, (float)window_size[0], (float)window_size[1], 0.0f, 1.0f}; + m_scissor = {{0, 0}, {(uint32_t)window_size[0], (uint32_t)window_size[1]}}; + +#ifndef NDEBUG + m_enable_validation_Layers = true; + m_enable_debug_utils_label = true; +#else + m_enable_validation_Layers = false; + m_enable_debug_utils_label = false; +#endif + +#if defined(__GNUC__) && defined(__MACH__) + m_enable_point_light_shadow = false; +#else + m_enable_point_light_shadow = true; +#endif + +#if defined(__GNUC__) + // https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html +#if defined(__linux__) + char const* vk_layer_path = PICCOLO_XSTR(PICCOLO_VK_LAYER_PATH); + setenv("VK_LAYER_PATH", vk_layer_path, 1); +#elif defined(__MACH__) + // https://developer.apple.com/library/archive/documentation/Porting/Conceptual/PortingUnix/compiling/compiling.html + char const* vk_layer_path = PICCOLO_XSTR(PICCOLO_VK_LAYER_PATH); + char const* vk_icd_filenames = PICCOLO_XSTR(PICCOLO_VK_ICD_FILENAMES); + setenv("VK_LAYER_PATH", vk_layer_path, 1); + setenv("VK_ICD_FILENAMES", vk_icd_filenames, 1); +#else +#error Unknown Platform +#endif +#elif defined(_MSC_VER) + // https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros + char const* vk_layer_path = PICCOLO_XSTR(PICCOLO_VK_LAYER_PATH); + SetEnvironmentVariableA("VK_LAYER_PATH", vk_layer_path); + SetEnvironmentVariableA("DISABLE_LAYER_AMD_SWITCHABLE_GRAPHICS_1", "1"); +#else +#error Unknown Compiler +#endif + + createInstance(); + + initializeDebugMessenger(); + + createWindowSurface(); + + initializePhysicalDevice(); + + createLogicalDevice(); + + createCommandPool(); + + createCommandBuffers(); + + createDescriptorPool(); + + createSyncPrimitives(); + + createSwapchain(); + + createSwapchainImageViews(); + + createFramebufferImageAndView(); + + createAssetAllocator(); + } + + void VulkanRHI::prepareContext() + { + m_vk_current_command_buffer = m_vk_command_buffers[m_current_frame_index]; + ((VulkanCommandBuffer*)m_current_command_buffer)->setResource(m_vk_current_command_buffer); + } + + void VulkanRHI::clear() + { + if (m_enable_validation_Layers) + { + destroyDebugUtilsMessengerEXT(m_instance, m_debug_messenger, nullptr); + } + } + + void VulkanRHI::waitForFences() + { + VkResult res_wait_for_fences = + _vkWaitForFences(m_device, 1, &m_is_frame_in_flight_fences[m_current_frame_index], VK_TRUE, UINT64_MAX); + if (VK_SUCCESS != res_wait_for_fences) + { + LOG_ERROR("failed to synchronize!"); + } + } + + bool VulkanRHI::waitForFences(uint32_t fenceCount, const RHIFence* const* pFences, RHIBool32 waitAll, uint64_t timeout) + { + //fence + int fence_size = fenceCount; + std::vector vk_fence_list(fence_size); + for (int i = 0; i < fence_size; ++i) + { + const auto& rhi_fence_element = pFences[i]; + auto& vk_fence_element = vk_fence_list[i]; + + vk_fence_element = ((VulkanFence*)rhi_fence_element)->getResource(); + }; + + VkResult result = vkWaitForFences(m_device, fenceCount, vk_fence_list.data(), waitAll, timeout); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("waitForFences failed"); + return false; + } + } + + void VulkanRHI::getPhysicalDeviceProperties(RHIPhysicalDeviceProperties* pProperties) + { + VkPhysicalDeviceProperties vk_physical_device_properties; + vkGetPhysicalDeviceProperties(m_physical_device, &vk_physical_device_properties); + + pProperties->apiVersion = vk_physical_device_properties.apiVersion; + pProperties->driverVersion = vk_physical_device_properties.driverVersion; + pProperties->vendorID = vk_physical_device_properties.vendorID; + pProperties->deviceID = vk_physical_device_properties.deviceID; + pProperties->deviceType = (RHIPhysicalDeviceType)vk_physical_device_properties.deviceType; + for (uint32_t i = 0; i < RHI_MAX_PHYSICAL_DEVICE_NAME_SIZE; i++) + { + pProperties->deviceName[i] = vk_physical_device_properties.deviceName[i]; + } + for (uint32_t i = 0; i < RHI_UUID_SIZE; i++) + { + pProperties->pipelineCacheUUID[i] = vk_physical_device_properties.pipelineCacheUUID[i]; + } + pProperties->sparseProperties.residencyStandard2DBlockShape = (VkBool32)vk_physical_device_properties.sparseProperties.residencyStandard2DBlockShape; + pProperties->sparseProperties.residencyStandard2DMultisampleBlockShape = (VkBool32)vk_physical_device_properties.sparseProperties.residencyStandard2DMultisampleBlockShape; + pProperties->sparseProperties.residencyStandard3DBlockShape = (VkBool32)vk_physical_device_properties.sparseProperties.residencyStandard3DBlockShape; + pProperties->sparseProperties.residencyAlignedMipSize = (VkBool32)vk_physical_device_properties.sparseProperties.residencyAlignedMipSize; + pProperties->sparseProperties.residencyNonResidentStrict = (VkBool32)vk_physical_device_properties.sparseProperties.residencyNonResidentStrict; + + pProperties->limits.maxImageDimension1D = vk_physical_device_properties.limits.maxImageDimension1D; + pProperties->limits.maxImageDimension2D = vk_physical_device_properties.limits.maxImageDimension2D; + pProperties->limits.maxImageDimension3D = vk_physical_device_properties.limits.maxImageDimension3D; + pProperties->limits.maxImageDimensionCube = vk_physical_device_properties.limits.maxImageDimensionCube; + pProperties->limits.maxImageArrayLayers = vk_physical_device_properties.limits.maxImageArrayLayers; + pProperties->limits.maxTexelBufferElements = vk_physical_device_properties.limits.maxTexelBufferElements; + pProperties->limits.maxUniformBufferRange = vk_physical_device_properties.limits.maxUniformBufferRange; + pProperties->limits.maxStorageBufferRange = vk_physical_device_properties.limits.maxStorageBufferRange; + pProperties->limits.maxPushConstantsSize = vk_physical_device_properties.limits.maxPushConstantsSize; + pProperties->limits.maxMemoryAllocationCount = vk_physical_device_properties.limits.maxMemoryAllocationCount; + pProperties->limits.maxSamplerAllocationCount = vk_physical_device_properties.limits.maxSamplerAllocationCount; + pProperties->limits.bufferImageGranularity = (VkDeviceSize)vk_physical_device_properties.limits.bufferImageGranularity; + pProperties->limits.sparseAddressSpaceSize = (VkDeviceSize)vk_physical_device_properties.limits.sparseAddressSpaceSize; + pProperties->limits.maxBoundDescriptorSets = vk_physical_device_properties.limits.maxBoundDescriptorSets; + pProperties->limits.maxPerStageDescriptorSamplers = vk_physical_device_properties.limits.maxPerStageDescriptorSamplers; + pProperties->limits.maxPerStageDescriptorUniformBuffers = vk_physical_device_properties.limits.maxPerStageDescriptorUniformBuffers; + pProperties->limits.maxPerStageDescriptorStorageBuffers = vk_physical_device_properties.limits.maxPerStageDescriptorStorageBuffers; + pProperties->limits.maxPerStageDescriptorSampledImages = vk_physical_device_properties.limits.maxPerStageDescriptorSampledImages; + pProperties->limits.maxPerStageDescriptorStorageImages = vk_physical_device_properties.limits.maxPerStageDescriptorStorageImages; + pProperties->limits.maxPerStageDescriptorInputAttachments = vk_physical_device_properties.limits.maxPerStageDescriptorInputAttachments; + pProperties->limits.maxPerStageResources = vk_physical_device_properties.limits.maxPerStageResources; + pProperties->limits.maxDescriptorSetSamplers = vk_physical_device_properties.limits.maxDescriptorSetSamplers; + pProperties->limits.maxDescriptorSetUniformBuffers = vk_physical_device_properties.limits.maxDescriptorSetUniformBuffers; + pProperties->limits.maxDescriptorSetUniformBuffersDynamic = vk_physical_device_properties.limits.maxDescriptorSetUniformBuffersDynamic; + pProperties->limits.maxDescriptorSetStorageBuffers = vk_physical_device_properties.limits.maxDescriptorSetStorageBuffers; + pProperties->limits.maxDescriptorSetStorageBuffersDynamic = vk_physical_device_properties.limits.maxDescriptorSetStorageBuffersDynamic; + pProperties->limits.maxDescriptorSetSampledImages = vk_physical_device_properties.limits.maxDescriptorSetSampledImages; + pProperties->limits.maxDescriptorSetStorageImages = vk_physical_device_properties.limits.maxDescriptorSetStorageImages; + pProperties->limits.maxDescriptorSetInputAttachments = vk_physical_device_properties.limits.maxDescriptorSetInputAttachments; + pProperties->limits.maxVertexInputAttributes = vk_physical_device_properties.limits.maxVertexInputAttributes; + pProperties->limits.maxVertexInputBindings = vk_physical_device_properties.limits.maxVertexInputBindings; + pProperties->limits.maxVertexInputAttributeOffset = vk_physical_device_properties.limits.maxVertexInputAttributeOffset; + pProperties->limits.maxVertexInputBindingStride = vk_physical_device_properties.limits.maxVertexInputBindingStride; + pProperties->limits.maxVertexOutputComponents = vk_physical_device_properties.limits.maxVertexOutputComponents; + pProperties->limits.maxTessellationGenerationLevel = vk_physical_device_properties.limits.maxTessellationGenerationLevel; + pProperties->limits.maxTessellationPatchSize = vk_physical_device_properties.limits.maxTessellationPatchSize; + pProperties->limits.maxTessellationControlPerVertexInputComponents = vk_physical_device_properties.limits.maxTessellationControlPerVertexInputComponents; + pProperties->limits.maxTessellationControlPerVertexOutputComponents = vk_physical_device_properties.limits.maxTessellationControlPerVertexOutputComponents; + pProperties->limits.maxTessellationControlPerPatchOutputComponents = vk_physical_device_properties.limits.maxTessellationControlPerPatchOutputComponents; + pProperties->limits.maxTessellationControlTotalOutputComponents = vk_physical_device_properties.limits.maxTessellationControlTotalOutputComponents; + pProperties->limits.maxTessellationEvaluationInputComponents = vk_physical_device_properties.limits.maxTessellationEvaluationInputComponents; + pProperties->limits.maxTessellationEvaluationOutputComponents = vk_physical_device_properties.limits.maxTessellationEvaluationOutputComponents; + pProperties->limits.maxGeometryShaderInvocations = vk_physical_device_properties.limits.maxGeometryShaderInvocations; + pProperties->limits.maxGeometryInputComponents = vk_physical_device_properties.limits.maxGeometryInputComponents; + pProperties->limits.maxGeometryOutputComponents = vk_physical_device_properties.limits.maxGeometryOutputComponents; + pProperties->limits.maxGeometryOutputVertices = vk_physical_device_properties.limits.maxGeometryOutputVertices; + pProperties->limits.maxGeometryTotalOutputComponents = vk_physical_device_properties.limits.maxGeometryTotalOutputComponents; + pProperties->limits.maxFragmentInputComponents = vk_physical_device_properties.limits.maxFragmentInputComponents; + pProperties->limits.maxFragmentOutputAttachments = vk_physical_device_properties.limits.maxFragmentOutputAttachments; + pProperties->limits.maxFragmentDualSrcAttachments = vk_physical_device_properties.limits.maxFragmentDualSrcAttachments; + pProperties->limits.maxFragmentCombinedOutputResources = vk_physical_device_properties.limits.maxFragmentCombinedOutputResources; + pProperties->limits.maxComputeSharedMemorySize = vk_physical_device_properties.limits.maxComputeSharedMemorySize; + for (uint32_t i = 0; i < 3; i++) + { + pProperties->limits.maxComputeWorkGroupCount[i] = vk_physical_device_properties.limits.maxComputeWorkGroupCount[i]; + } + pProperties->limits.maxComputeWorkGroupInvocations = vk_physical_device_properties.limits.maxComputeWorkGroupInvocations; + for (uint32_t i = 0; i < 3; i++) + { + pProperties->limits.maxComputeWorkGroupSize[i] = vk_physical_device_properties.limits.maxComputeWorkGroupSize[i]; + } + pProperties->limits.subPixelPrecisionBits = vk_physical_device_properties.limits.subPixelPrecisionBits; + pProperties->limits.subTexelPrecisionBits = vk_physical_device_properties.limits.subTexelPrecisionBits; + pProperties->limits.mipmapPrecisionBits = vk_physical_device_properties.limits.mipmapPrecisionBits; + pProperties->limits.maxDrawIndexedIndexValue = vk_physical_device_properties.limits.maxDrawIndexedIndexValue; + pProperties->limits.maxDrawIndirectCount = vk_physical_device_properties.limits.maxDrawIndirectCount; + pProperties->limits.maxSamplerLodBias = vk_physical_device_properties.limits.maxSamplerLodBias; + pProperties->limits.maxSamplerAnisotropy = vk_physical_device_properties.limits.maxSamplerAnisotropy; + pProperties->limits.maxViewports = vk_physical_device_properties.limits.maxViewports; + for (uint32_t i = 0; i < 2; i++) + { + pProperties->limits.maxViewportDimensions[i] = vk_physical_device_properties.limits.maxViewportDimensions[i]; + } + for (uint32_t i = 0; i < 2; i++) + { + pProperties->limits.viewportBoundsRange[i] = vk_physical_device_properties.limits.viewportBoundsRange[i]; + } + pProperties->limits.viewportSubPixelBits = vk_physical_device_properties.limits.viewportSubPixelBits; + pProperties->limits.minMemoryMapAlignment = vk_physical_device_properties.limits.minMemoryMapAlignment; + pProperties->limits.minTexelBufferOffsetAlignment = (VkDeviceSize)vk_physical_device_properties.limits.minTexelBufferOffsetAlignment; + pProperties->limits.minUniformBufferOffsetAlignment = (VkDeviceSize)vk_physical_device_properties.limits.minUniformBufferOffsetAlignment; + pProperties->limits.minStorageBufferOffsetAlignment = (VkDeviceSize)vk_physical_device_properties.limits.minStorageBufferOffsetAlignment; + pProperties->limits.minTexelOffset = vk_physical_device_properties.limits.minTexelOffset; + pProperties->limits.maxTexelOffset = vk_physical_device_properties.limits.maxTexelOffset; + pProperties->limits.minTexelGatherOffset = vk_physical_device_properties.limits.minTexelGatherOffset; + pProperties->limits.maxTexelGatherOffset = vk_physical_device_properties.limits.maxTexelGatherOffset; + pProperties->limits.minInterpolationOffset = vk_physical_device_properties.limits.minInterpolationOffset; + pProperties->limits.maxInterpolationOffset = vk_physical_device_properties.limits.maxInterpolationOffset; + pProperties->limits.subPixelInterpolationOffsetBits = vk_physical_device_properties.limits.subPixelInterpolationOffsetBits; + pProperties->limits.maxFramebufferWidth = vk_physical_device_properties.limits.maxFramebufferWidth; + pProperties->limits.maxFramebufferHeight = vk_physical_device_properties.limits.maxFramebufferHeight; + pProperties->limits.maxFramebufferLayers = vk_physical_device_properties.limits.maxFramebufferLayers; + pProperties->limits.framebufferColorSampleCounts = (VkSampleCountFlags)vk_physical_device_properties.limits.framebufferColorSampleCounts; + pProperties->limits.framebufferDepthSampleCounts = (VkSampleCountFlags)vk_physical_device_properties.limits.framebufferDepthSampleCounts; + pProperties->limits.framebufferStencilSampleCounts = (VkSampleCountFlags)vk_physical_device_properties.limits.framebufferStencilSampleCounts; + pProperties->limits.framebufferNoAttachmentsSampleCounts = (VkSampleCountFlags)vk_physical_device_properties.limits.framebufferNoAttachmentsSampleCounts; + pProperties->limits.maxColorAttachments = vk_physical_device_properties.limits.maxColorAttachments; + pProperties->limits.sampledImageColorSampleCounts = (VkSampleCountFlags)vk_physical_device_properties.limits.sampledImageColorSampleCounts; + pProperties->limits.sampledImageIntegerSampleCounts = (VkSampleCountFlags)vk_physical_device_properties.limits.sampledImageIntegerSampleCounts; + pProperties->limits.sampledImageDepthSampleCounts = (VkSampleCountFlags)vk_physical_device_properties.limits.sampledImageDepthSampleCounts; + pProperties->limits.sampledImageStencilSampleCounts = (VkSampleCountFlags)vk_physical_device_properties.limits.sampledImageStencilSampleCounts; + pProperties->limits.storageImageSampleCounts = (VkSampleCountFlags)vk_physical_device_properties.limits.storageImageSampleCounts; + pProperties->limits.maxSampleMaskWords = vk_physical_device_properties.limits.maxSampleMaskWords; + pProperties->limits.timestampComputeAndGraphics = (VkBool32)vk_physical_device_properties.limits.timestampComputeAndGraphics; + pProperties->limits.timestampPeriod = vk_physical_device_properties.limits.timestampPeriod; + pProperties->limits.maxClipDistances = vk_physical_device_properties.limits.maxClipDistances; + pProperties->limits.maxCullDistances = vk_physical_device_properties.limits.maxCullDistances; + pProperties->limits.maxCombinedClipAndCullDistances = vk_physical_device_properties.limits.maxCombinedClipAndCullDistances; + pProperties->limits.discreteQueuePriorities = vk_physical_device_properties.limits.discreteQueuePriorities; + for (uint32_t i = 0; i < 2; i++) + { + pProperties->limits.pointSizeRange[i] = vk_physical_device_properties.limits.pointSizeRange[i]; + } + for (uint32_t i = 0; i < 2; i++) + { + pProperties->limits.lineWidthRange[i] = vk_physical_device_properties.limits.lineWidthRange[i]; + } + pProperties->limits.pointSizeGranularity = vk_physical_device_properties.limits.pointSizeGranularity; + pProperties->limits.lineWidthGranularity = vk_physical_device_properties.limits.lineWidthGranularity; + pProperties->limits.strictLines = (VkBool32)vk_physical_device_properties.limits.strictLines; + pProperties->limits.standardSampleLocations = (VkBool32)vk_physical_device_properties.limits.standardSampleLocations; + pProperties->limits.optimalBufferCopyOffsetAlignment = (VkDeviceSize)vk_physical_device_properties.limits.optimalBufferCopyOffsetAlignment; + pProperties->limits.optimalBufferCopyRowPitchAlignment = (VkDeviceSize)vk_physical_device_properties.limits.optimalBufferCopyRowPitchAlignment; + pProperties->limits.nonCoherentAtomSize = (VkDeviceSize)vk_physical_device_properties.limits.nonCoherentAtomSize; + + } + + void VulkanRHI::resetCommandPool() + { + VkResult res_reset_command_pool = _vkResetCommandPool(m_device, m_command_pools[m_current_frame_index], 0); + if (VK_SUCCESS != res_reset_command_pool) + { + LOG_ERROR("failed to synchronize"); + } + } + + bool VulkanRHI::prepareBeforePass(std::function passUpdateAfterRecreateSwapchain) + { + VkResult acquire_image_result = + vkAcquireNextImageKHR(m_device, + m_swapchain, + UINT64_MAX, + m_image_available_for_render_semaphores[m_current_frame_index], + VK_NULL_HANDLE, + &m_current_swapchain_image_index); + + if (VK_ERROR_OUT_OF_DATE_KHR == acquire_image_result) + { + recreateSwapchain(); + passUpdateAfterRecreateSwapchain(); + return RHI_SUCCESS; + } + else if (VK_SUBOPTIMAL_KHR == acquire_image_result) + { + recreateSwapchain(); + passUpdateAfterRecreateSwapchain(); + + // NULL submit to wait semaphore + VkPipelineStageFlags wait_stages[] = {VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT}; + VkSubmitInfo submit_info = {}; + submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submit_info.waitSemaphoreCount = 1; + submit_info.pWaitSemaphores = &m_image_available_for_render_semaphores[m_current_frame_index]; + submit_info.pWaitDstStageMask = wait_stages; + submit_info.commandBufferCount = 0; + submit_info.pCommandBuffers = NULL; + submit_info.signalSemaphoreCount = 0; + submit_info.pSignalSemaphores = NULL; + + VkResult res_reset_fences = _vkResetFences(m_device, 1, &m_is_frame_in_flight_fences[m_current_frame_index]); + if (VK_SUCCESS != res_reset_fences) + { + LOG_ERROR("_vkResetFences failed!"); + return false; + } + + VkResult res_queue_submit = + vkQueueSubmit(((VulkanQueue*)m_graphics_queue)->getResource(), 1, &submit_info, m_is_frame_in_flight_fences[m_current_frame_index]); + if (VK_SUCCESS != res_queue_submit) + { + LOG_ERROR("vkQueueSubmit failed!"); + return false; + } + m_current_frame_index = (m_current_frame_index + 1) % k_max_frames_in_flight; + return RHI_SUCCESS; + } + else + { + if (VK_SUCCESS != acquire_image_result) + { + LOG_ERROR("vkAcquireNextImageKHR failed!"); + return false; + } + } + + // begin command buffer + VkCommandBufferBeginInfo command_buffer_begin_info {}; + command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + command_buffer_begin_info.flags = 0; + command_buffer_begin_info.pInheritanceInfo = nullptr; + + VkResult res_begin_command_buffer = + _vkBeginCommandBuffer(m_vk_command_buffers[m_current_frame_index], &command_buffer_begin_info); + + if (VK_SUCCESS != res_begin_command_buffer) + { + LOG_ERROR("_vkBeginCommandBuffer failed!"); + return false; + } + return false; + } + + void VulkanRHI::submitRendering(std::function passUpdateAfterRecreateSwapchain) + { + // end command buffer + VkResult res_end_command_buffer = _vkEndCommandBuffer(m_vk_command_buffers[m_current_frame_index]); + if (VK_SUCCESS != res_end_command_buffer) + { + LOG_ERROR("_vkEndCommandBuffer failed!"); + return; + } + + VkSemaphore semaphores[2] = { ((VulkanSemaphore*)m_image_available_for_texturescopy_semaphores[m_current_frame_index])->getResource(), + m_image_finished_for_presentation_semaphores[m_current_frame_index] }; + + // submit command buffer + VkPipelineStageFlags wait_stages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT}; + VkSubmitInfo submit_info = {}; + submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submit_info.waitSemaphoreCount = 1; + submit_info.pWaitSemaphores = &m_image_available_for_render_semaphores[m_current_frame_index]; + submit_info.pWaitDstStageMask = wait_stages; + submit_info.commandBufferCount = 1; + submit_info.pCommandBuffers = &m_vk_command_buffers[m_current_frame_index]; + submit_info.signalSemaphoreCount = 2; + submit_info.pSignalSemaphores = semaphores; + + VkResult res_reset_fences = _vkResetFences(m_device, 1, &m_is_frame_in_flight_fences[m_current_frame_index]); + + if (VK_SUCCESS != res_reset_fences) + { + LOG_ERROR("_vkResetFences failed!"); + return; + } + VkResult res_queue_submit = + vkQueueSubmit(((VulkanQueue*)m_graphics_queue)->getResource(), 1, &submit_info, m_is_frame_in_flight_fences[m_current_frame_index]); + + if (VK_SUCCESS != res_queue_submit) + { + LOG_ERROR("vkQueueSubmit failed!"); + return; + } + + // present swapchain + VkPresentInfoKHR present_info = {}; + present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; + present_info.waitSemaphoreCount = 1; + present_info.pWaitSemaphores = &m_image_finished_for_presentation_semaphores[m_current_frame_index]; + present_info.swapchainCount = 1; + present_info.pSwapchains = &m_swapchain; + present_info.pImageIndices = &m_current_swapchain_image_index; + + VkResult present_result = vkQueuePresentKHR(m_present_queue, &present_info); + if (VK_ERROR_OUT_OF_DATE_KHR == present_result || VK_SUBOPTIMAL_KHR == present_result) + { + recreateSwapchain(); + passUpdateAfterRecreateSwapchain(); + } + else + { + if (VK_SUCCESS != present_result) + { + LOG_ERROR("vkQueuePresentKHR failed!"); + return; + } + } + + m_current_frame_index = (m_current_frame_index + 1) % k_max_frames_in_flight; + } + + RHICommandBuffer* VulkanRHI::beginSingleTimeCommands() + { + VkCommandBufferAllocateInfo allocInfo {}; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandPool = ((VulkanCommandPool*)m_rhi_command_pool)->getResource(); + allocInfo.commandBufferCount = 1; + + VkCommandBuffer command_buffer; + vkAllocateCommandBuffers(m_device, &allocInfo, &command_buffer); + + VkCommandBufferBeginInfo beginInfo {}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + + _vkBeginCommandBuffer(command_buffer, &beginInfo); + + RHICommandBuffer* rhi_command_buffer = new VulkanCommandBuffer(); + ((VulkanCommandBuffer*)rhi_command_buffer)->setResource(command_buffer); + return rhi_command_buffer; + } + + void VulkanRHI::endSingleTimeCommands(RHICommandBuffer* command_buffer) + { + VkCommandBuffer vk_command_buffer = ((VulkanCommandBuffer*)command_buffer)->getResource(); + _vkEndCommandBuffer(vk_command_buffer); + + VkSubmitInfo submitInfo {}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &vk_command_buffer; + + vkQueueSubmit(((VulkanQueue*)m_graphics_queue)->getResource(), 1, &submitInfo, VK_NULL_HANDLE); + vkQueueWaitIdle(((VulkanQueue*)m_graphics_queue)->getResource()); + + vkFreeCommandBuffers(m_device, ((VulkanCommandPool*)m_rhi_command_pool)->getResource(), 1, &vk_command_buffer); + delete(command_buffer); + } + + // validation layers + bool VulkanRHI::checkValidationLayerSupport() + { + uint32_t layerCount; + vkEnumerateInstanceLayerProperties(&layerCount, nullptr); + + std::vector availableLayers(layerCount); + vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data()); + + for (const char* layerName : m_validation_layers) + { + bool layerFound = false; + + for (const auto& layerProperties : availableLayers) + { + if (strcmp(layerName, layerProperties.layerName) == 0) + { + layerFound = true; + break; + } + } + + if (!layerFound) + { + return false; + } + } + + return RHI_SUCCESS; + } + + std::vector VulkanRHI::getRequiredExtensions() + { + uint32_t glfwExtensionCount = 0; + const char** glfwExtensions; + glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); + + std::vector extensions(glfwExtensions, glfwExtensions + glfwExtensionCount); + + if (m_enable_validation_Layers || m_enable_debug_utils_label) + { + extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); + } + +#if defined(__MACH__) + extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); +#endif + + return extensions; + } + + // debug callback + static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT, + VkDebugUtilsMessageTypeFlagsEXT, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void*) + { + std::cerr << "validation layer: " << pCallbackData->pMessage << std::endl; + return VK_FALSE; + } + + void VulkanRHI::populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) + { + createInfo = {}; + createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + createInfo.messageSeverity = + VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; + createInfo.messageType = + VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; + createInfo.pfnUserCallback = debugCallback; + } + + void VulkanRHI::createInstance() + { + // validation layer will be enabled in debug mode + if (m_enable_validation_Layers && !checkValidationLayerSupport()) + { + LOG_ERROR("validation layers requested, but not available!"); + } + + m_vulkan_api_version = VK_API_VERSION_1_0; + + // app info + VkApplicationInfo appInfo {}; + appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; + appInfo.pApplicationName = "piccolo_renderer"; + appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0); + appInfo.pEngineName = "Piccolo"; + appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0); + appInfo.apiVersion = m_vulkan_api_version; + + // create info + VkInstanceCreateInfo instance_create_info {}; + instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + instance_create_info.pApplicationInfo = &appInfo; // the appInfo is stored here + + auto extensions = getRequiredExtensions(); + instance_create_info.enabledExtensionCount = static_cast(extensions.size()); + instance_create_info.ppEnabledExtensionNames = extensions.data(); + + VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo {}; + if (m_enable_validation_Layers) + { + instance_create_info.enabledLayerCount = static_cast(m_validation_layers.size()); + instance_create_info.ppEnabledLayerNames = m_validation_layers.data(); + + populateDebugMessengerCreateInfo(debugCreateInfo); + instance_create_info.pNext = (VkDebugUtilsMessengerCreateInfoEXT*)&debugCreateInfo; + } + else + { + instance_create_info.enabledLayerCount = 0; + instance_create_info.pNext = nullptr; + } + + // create m_vulkan_context._instance + if (vkCreateInstance(&instance_create_info, nullptr, &m_instance) != VK_SUCCESS) + { + LOG_ERROR("vk create instance"); + } + } + + void VulkanRHI::initializeDebugMessenger() + { + if (m_enable_validation_Layers) + { + VkDebugUtilsMessengerCreateInfoEXT createInfo; + populateDebugMessengerCreateInfo(createInfo); + if (VK_SUCCESS != createDebugUtilsMessengerEXT(m_instance, &createInfo, nullptr, &m_debug_messenger)) + { + LOG_ERROR("failed to set up debug messenger!"); + } + } + + if (m_enable_debug_utils_label) + { + _vkCmdBeginDebugUtilsLabelEXT = + (PFN_vkCmdBeginDebugUtilsLabelEXT)vkGetInstanceProcAddr(m_instance, "vkCmdBeginDebugUtilsLabelEXT"); + _vkCmdEndDebugUtilsLabelEXT = + (PFN_vkCmdEndDebugUtilsLabelEXT)vkGetInstanceProcAddr(m_instance, "vkCmdEndDebugUtilsLabelEXT"); + } + } + + void VulkanRHI::createWindowSurface() + { + if (glfwCreateWindowSurface(m_instance, m_window, nullptr, &m_surface) != VK_SUCCESS) + { + LOG_ERROR("glfwCreateWindowSurface failed!"); + } + } + + void VulkanRHI::initializePhysicalDevice() + { + uint32_t physical_device_count; + vkEnumeratePhysicalDevices(m_instance, &physical_device_count, nullptr); + if (physical_device_count == 0) + { + LOG_ERROR("enumerate physical devices failed!"); + } + else + { + // find one device that matches our requirement + // or find which is the best + std::vector physical_devices(physical_device_count); + vkEnumeratePhysicalDevices(m_instance, &physical_device_count, physical_devices.data()); + + std::vector> ranked_physical_devices; + for (const auto& device : physical_devices) + { + VkPhysicalDeviceProperties physical_device_properties; + vkGetPhysicalDeviceProperties(device, &physical_device_properties); + int score = 0; + + if (physical_device_properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) + { + score += 1000; + } + else if (physical_device_properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) + { + score += 100; + } + + ranked_physical_devices.push_back({score, device}); + } + + std::sort(ranked_physical_devices.begin(), + ranked_physical_devices.end(), + [](const std::pair& p1, const std::pair& p2) { + return p1 > p2; + }); + + for (const auto& device : ranked_physical_devices) + { + if (isDeviceSuitable(device.second)) + { + m_physical_device = device.second; + break; + } + } + + if (m_physical_device == VK_NULL_HANDLE) + { + LOG_ERROR("failed to find suitable physical device"); + } + } + } + + // logical device (m_vulkan_context._device : graphic queue, present queue, + // feature:samplerAnisotropy) + void VulkanRHI::createLogicalDevice() + { + m_queue_indices = findQueueFamilies(m_physical_device); + + std::vector queue_create_infos; // all queues that need to be created + std::set queue_families = {m_queue_indices.graphics_family.value(), + m_queue_indices.present_family.value(), + m_queue_indices.m_compute_family.value()}; + + float queue_priority = 1.0f; + for (uint32_t queue_family : queue_families) // for every queue family + { + // queue create info + VkDeviceQueueCreateInfo queue_create_info {}; + queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + queue_create_info.queueFamilyIndex = queue_family; + queue_create_info.queueCount = 1; + queue_create_info.pQueuePriorities = &queue_priority; + queue_create_infos.push_back(queue_create_info); + } + + // physical device features + VkPhysicalDeviceFeatures physical_device_features = {}; + + physical_device_features.samplerAnisotropy = VK_TRUE; + + // support inefficient readback storage buffer + physical_device_features.fragmentStoresAndAtomics = VK_TRUE; + + // support independent blending + physical_device_features.independentBlend = VK_TRUE; + + // support geometry shader + if (m_enable_point_light_shadow) + { + physical_device_features.geometryShader = VK_TRUE; + } + + // device create info + VkDeviceCreateInfo device_create_info {}; + device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + device_create_info.pQueueCreateInfos = queue_create_infos.data(); + device_create_info.queueCreateInfoCount = static_cast(queue_create_infos.size()); + device_create_info.pEnabledFeatures = &physical_device_features; + device_create_info.enabledExtensionCount = static_cast(m_device_extensions.size()); + device_create_info.ppEnabledExtensionNames = m_device_extensions.data(); + device_create_info.enabledLayerCount = 0; + + if (vkCreateDevice(m_physical_device, &device_create_info, nullptr, &m_device) != VK_SUCCESS) + { + LOG_ERROR("vk create device"); + } + + // initialize queues of this device + VkQueue vk_graphics_queue; + vkGetDeviceQueue(m_device, m_queue_indices.graphics_family.value(), 0, &vk_graphics_queue); + m_graphics_queue = new VulkanQueue(); + ((VulkanQueue*)m_graphics_queue)->setResource(vk_graphics_queue); + + vkGetDeviceQueue(m_device, m_queue_indices.present_family.value(), 0, &m_present_queue); + + VkQueue vk_compute_queue; + vkGetDeviceQueue(m_device, m_queue_indices.m_compute_family.value(), 0, &vk_compute_queue); + m_compute_queue = new VulkanQueue(); + ((VulkanQueue*)m_compute_queue)->setResource(vk_compute_queue); + + // more efficient pointer + _vkResetCommandPool = (PFN_vkResetCommandPool)vkGetDeviceProcAddr(m_device, "vkResetCommandPool"); + _vkBeginCommandBuffer = (PFN_vkBeginCommandBuffer)vkGetDeviceProcAddr(m_device, "vkBeginCommandBuffer"); + _vkEndCommandBuffer = (PFN_vkEndCommandBuffer)vkGetDeviceProcAddr(m_device, "vkEndCommandBuffer"); + _vkCmdBeginRenderPass = (PFN_vkCmdBeginRenderPass)vkGetDeviceProcAddr(m_device, "vkCmdBeginRenderPass"); + _vkCmdNextSubpass = (PFN_vkCmdNextSubpass)vkGetDeviceProcAddr(m_device, "vkCmdNextSubpass"); + _vkCmdEndRenderPass = (PFN_vkCmdEndRenderPass)vkGetDeviceProcAddr(m_device, "vkCmdEndRenderPass"); + _vkCmdBindPipeline = (PFN_vkCmdBindPipeline)vkGetDeviceProcAddr(m_device, "vkCmdBindPipeline"); + _vkCmdSetViewport = (PFN_vkCmdSetViewport)vkGetDeviceProcAddr(m_device, "vkCmdSetViewport"); + _vkCmdSetScissor = (PFN_vkCmdSetScissor)vkGetDeviceProcAddr(m_device, "vkCmdSetScissor"); + _vkWaitForFences = (PFN_vkWaitForFences)vkGetDeviceProcAddr(m_device, "vkWaitForFences"); + _vkResetFences = (PFN_vkResetFences)vkGetDeviceProcAddr(m_device, "vkResetFences"); + _vkCmdDrawIndexed = (PFN_vkCmdDrawIndexed)vkGetDeviceProcAddr(m_device, "vkCmdDrawIndexed"); + _vkCmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers)vkGetDeviceProcAddr(m_device, "vkCmdBindVertexBuffers"); + _vkCmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer)vkGetDeviceProcAddr(m_device, "vkCmdBindIndexBuffer"); + _vkCmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets)vkGetDeviceProcAddr(m_device, "vkCmdBindDescriptorSets"); + _vkCmdClearAttachments = (PFN_vkCmdClearAttachments)vkGetDeviceProcAddr(m_device, "vkCmdClearAttachments"); + + m_depth_image_format = (RHIFormat)findDepthFormat(); + } + + void VulkanRHI::createCommandPool() + { + // default graphics command pool + { + m_rhi_command_pool = new VulkanCommandPool(); + VkCommandPool vk_command_pool; + VkCommandPoolCreateInfo command_pool_create_info {}; + command_pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + command_pool_create_info.pNext = NULL; + command_pool_create_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; + command_pool_create_info.queueFamilyIndex = m_queue_indices.graphics_family.value(); + + if (vkCreateCommandPool(m_device, &command_pool_create_info, nullptr, &vk_command_pool) != VK_SUCCESS) + { + LOG_ERROR("vk create command pool"); + } + + ((VulkanCommandPool*)m_rhi_command_pool)->setResource(vk_command_pool); + } + + // other command pools + { + VkCommandPoolCreateInfo command_pool_create_info; + command_pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + command_pool_create_info.pNext = NULL; + command_pool_create_info.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT; + command_pool_create_info.queueFamilyIndex = m_queue_indices.graphics_family.value(); + + for (uint32_t i = 0; i < k_max_frames_in_flight; ++i) + { + if (vkCreateCommandPool(m_device, &command_pool_create_info, NULL, &m_command_pools[i]) != VK_SUCCESS) + { + LOG_ERROR("vk create command pool"); + } + } + } + } + + bool VulkanRHI::createCommandPool(const RHICommandPoolCreateInfo* pCreateInfo, RHICommandPool* &pCommandPool) + { + VkCommandPoolCreateInfo create_info{}; + create_info.sType = (VkStructureType)pCreateInfo->sType; + create_info.pNext = (const void*)pCreateInfo->pNext; + create_info.flags = (VkCommandPoolCreateFlags)pCreateInfo->flags; + create_info.queueFamilyIndex = pCreateInfo->queueFamilyIndex; + + pCommandPool = new VulkanCommandPool(); + VkCommandPool vk_commandPool; + VkResult result = vkCreateCommandPool(m_device, &create_info, nullptr, &vk_commandPool); + ((VulkanCommandPool*)pCommandPool)->setResource(vk_commandPool); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("vkCreateCommandPool is failed!"); + return false; + } + } + + bool VulkanRHI::createDescriptorPool(const RHIDescriptorPoolCreateInfo* pCreateInfo, RHIDescriptorPool* & pDescriptorPool) + { + int size = pCreateInfo->poolSizeCount; + std::vector descriptor_pool_size(size); + for (int i = 0; i < size; ++i) + { + const auto& rhi_desc = pCreateInfo->pPoolSizes[i]; + auto& vk_desc = descriptor_pool_size[i]; + + vk_desc.type = (VkDescriptorType)rhi_desc.type; + vk_desc.descriptorCount = rhi_desc.descriptorCount; + }; + + VkDescriptorPoolCreateInfo create_info{}; + create_info.sType = (VkStructureType)pCreateInfo->sType; + create_info.pNext = (const void*)pCreateInfo->pNext; + create_info.flags = (VkDescriptorPoolCreateFlags)pCreateInfo->flags; + create_info.maxSets = pCreateInfo->maxSets; + create_info.poolSizeCount = pCreateInfo->poolSizeCount; + create_info.pPoolSizes = descriptor_pool_size.data(); + + pDescriptorPool = new VulkanDescriptorPool(); + VkDescriptorPool vk_descriptorPool; + VkResult result = vkCreateDescriptorPool(m_device, &create_info, nullptr, &vk_descriptorPool); + ((VulkanDescriptorPool*)pDescriptorPool)->setResource(vk_descriptorPool); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("vkCreateDescriptorPool is failed!"); + return false; + } + } + + bool VulkanRHI::createDescriptorSetLayout(const RHIDescriptorSetLayoutCreateInfo* pCreateInfo, RHIDescriptorSetLayout* &pSetLayout) + { + //descriptor_set_layout_binding + int descriptor_set_layout_binding_size = pCreateInfo->bindingCount; + std::vector vk_descriptor_set_layout_binding_list(descriptor_set_layout_binding_size); + + int sampler_count = 0; + for (int i = 0; i < descriptor_set_layout_binding_size; ++i) + { + const auto& rhi_descriptor_set_layout_binding_element = pCreateInfo->pBindings[i]; + if (rhi_descriptor_set_layout_binding_element.pImmutableSamplers != nullptr) + { + sampler_count += rhi_descriptor_set_layout_binding_element.descriptorCount; + } + } + std::vector sampler_list(sampler_count); + int sampler_current = 0; + + for (int i = 0; i < descriptor_set_layout_binding_size; ++i) + { + const auto& rhi_descriptor_set_layout_binding_element = pCreateInfo->pBindings[i]; + auto& vk_descriptor_set_layout_binding_element = vk_descriptor_set_layout_binding_list[i]; + + //sampler + vk_descriptor_set_layout_binding_element.pImmutableSamplers = nullptr; + if (rhi_descriptor_set_layout_binding_element.pImmutableSamplers) + { + vk_descriptor_set_layout_binding_element.pImmutableSamplers = &sampler_list[sampler_current]; + for (int i = 0; i < rhi_descriptor_set_layout_binding_element.descriptorCount; ++i) + { + const auto& rhi_sampler_element = rhi_descriptor_set_layout_binding_element.pImmutableSamplers[i]; + auto& vk_sampler_element = sampler_list[sampler_current]; + + vk_sampler_element = ((VulkanSampler*)rhi_sampler_element)->getResource(); + + sampler_current++; + }; + } + vk_descriptor_set_layout_binding_element.binding = rhi_descriptor_set_layout_binding_element.binding; + vk_descriptor_set_layout_binding_element.descriptorType = (VkDescriptorType)rhi_descriptor_set_layout_binding_element.descriptorType; + vk_descriptor_set_layout_binding_element.descriptorCount = rhi_descriptor_set_layout_binding_element.descriptorCount; + vk_descriptor_set_layout_binding_element.stageFlags = rhi_descriptor_set_layout_binding_element.stageFlags; + }; + + if (sampler_count != sampler_current) + { + LOG_ERROR("sampler_count != sampller_current"); + return false; + } + + VkDescriptorSetLayoutCreateInfo create_info{}; + create_info.sType = (VkStructureType)pCreateInfo->sType; + create_info.pNext = (const void*)pCreateInfo->pNext; + create_info.flags = (VkDescriptorSetLayoutCreateFlags)pCreateInfo->flags; + create_info.bindingCount = pCreateInfo->bindingCount; + create_info.pBindings = vk_descriptor_set_layout_binding_list.data(); + + pSetLayout = new VulkanDescriptorSetLayout(); + VkDescriptorSetLayout vk_descriptorSetLayout; + VkResult result = vkCreateDescriptorSetLayout(m_device, &create_info, nullptr, &vk_descriptorSetLayout); + ((VulkanDescriptorSetLayout*)pSetLayout)->setResource(vk_descriptorSetLayout); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("vkCreateDescriptorSetLayout failed!"); + return false; + } + } + + bool VulkanRHI::createFence(const RHIFenceCreateInfo* pCreateInfo, RHIFence* &pFence) + { + VkFenceCreateInfo create_info{}; + create_info.sType = (VkStructureType)pCreateInfo->sType; + create_info.pNext = (const void*)pCreateInfo->pNext; + create_info.flags = (VkFenceCreateFlags)pCreateInfo->flags; + + pFence = new VulkanFence(); + VkFence vk_fence; + VkResult result = vkCreateFence(m_device, &create_info, nullptr, &vk_fence); + ((VulkanFence*)pFence)->setResource(vk_fence); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("vkCreateFence failed!"); + return false; + } + } + + bool VulkanRHI::createFramebuffer(const RHIFramebufferCreateInfo* pCreateInfo, RHIFramebuffer* &pFramebuffer) + { + //image_view + int image_view_size = pCreateInfo->attachmentCount; + std::vector vk_image_view_list(image_view_size); + for (int i = 0; i < image_view_size; ++i) + { + const auto& rhi_image_view_element = pCreateInfo->pAttachments[i]; + auto& vk_image_view_element = vk_image_view_list[i]; + + vk_image_view_element = ((VulkanImageView*)rhi_image_view_element)->getResource(); + }; + + VkFramebufferCreateInfo create_info{}; + create_info.sType = (VkStructureType)pCreateInfo->sType; + create_info.pNext = (const void*)pCreateInfo->pNext; + create_info.flags = (VkFramebufferCreateFlags)pCreateInfo->flags; + create_info.renderPass = ((VulkanRenderPass*)pCreateInfo->renderPass)->getResource(); + create_info.attachmentCount = pCreateInfo->attachmentCount; + create_info.pAttachments = vk_image_view_list.data(); + create_info.width = pCreateInfo->width; + create_info.height = pCreateInfo->height; + create_info.layers = pCreateInfo->layers; + + pFramebuffer = new VulkanFramebuffer(); + VkFramebuffer vk_framebuffer; + VkResult result = vkCreateFramebuffer(m_device, &create_info, nullptr, &vk_framebuffer); + ((VulkanFramebuffer*)pFramebuffer)->setResource(vk_framebuffer); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("vkCreateFramebuffer failed!"); + return false; + } + } + + bool VulkanRHI::createGraphicsPipelines(RHIPipelineCache* pipelineCache, uint32_t createInfoCount, const RHIGraphicsPipelineCreateInfo* pCreateInfo, RHIPipeline* &pPipelines) + { + //pipeline_shader_stage_create_info + int pipeline_shader_stage_create_info_size = pCreateInfo->stageCount; + std::vector vk_pipeline_shader_stage_create_info_list(pipeline_shader_stage_create_info_size); + + int specialization_map_entry_size_total = 0; + int specialization_info_total = 0; + for (int i = 0; i < pipeline_shader_stage_create_info_size; ++i) + { + const auto& rhi_pipeline_shader_stage_create_info_element = pCreateInfo->pStages[i]; + if (rhi_pipeline_shader_stage_create_info_element.pSpecializationInfo != nullptr) + { + specialization_info_total++; + specialization_map_entry_size_total+= rhi_pipeline_shader_stage_create_info_element.pSpecializationInfo->mapEntryCount; + } + } + std::vector vk_specialization_info_list(specialization_info_total); + std::vector vk_specialization_map_entry_list(specialization_map_entry_size_total); + int specialization_map_entry_current = 0; + int specialization_info_current = 0; + + for (int i = 0; i < pipeline_shader_stage_create_info_size; ++i) + { + const auto& rhi_pipeline_shader_stage_create_info_element = pCreateInfo->pStages[i]; + auto& vk_pipeline_shader_stage_create_info_element = vk_pipeline_shader_stage_create_info_list[i]; + + if (rhi_pipeline_shader_stage_create_info_element.pSpecializationInfo != nullptr) + { + vk_pipeline_shader_stage_create_info_element.pSpecializationInfo = &vk_specialization_info_list[specialization_info_current]; + + VkSpecializationInfo vk_specialization_info{}; + vk_specialization_info.mapEntryCount = rhi_pipeline_shader_stage_create_info_element.pSpecializationInfo->mapEntryCount; + vk_specialization_info.pMapEntries = &vk_specialization_map_entry_list[specialization_map_entry_current]; + vk_specialization_info.dataSize = rhi_pipeline_shader_stage_create_info_element.pSpecializationInfo->dataSize; + vk_specialization_info.pData = (const void*)rhi_pipeline_shader_stage_create_info_element.pSpecializationInfo->pData; + + //specialization_map_entry + for (int i = 0; i < rhi_pipeline_shader_stage_create_info_element.pSpecializationInfo->mapEntryCount; ++i) + { + const auto& rhi_specialization_map_entry_element = rhi_pipeline_shader_stage_create_info_element.pSpecializationInfo->pMapEntries[i]; + auto& vk_specialization_map_entry_element = vk_specialization_map_entry_list[specialization_map_entry_current]; + + vk_specialization_map_entry_element.constantID = rhi_specialization_map_entry_element->constantID; + vk_specialization_map_entry_element.offset = rhi_specialization_map_entry_element->offset; + vk_specialization_map_entry_element.size = rhi_specialization_map_entry_element->size; + + specialization_map_entry_current++; + }; + + specialization_info_current++; + } + else + { + vk_pipeline_shader_stage_create_info_element.pSpecializationInfo = nullptr; + } + vk_pipeline_shader_stage_create_info_element.sType = (VkStructureType)rhi_pipeline_shader_stage_create_info_element.sType; + vk_pipeline_shader_stage_create_info_element.pNext = (const void*)rhi_pipeline_shader_stage_create_info_element.pNext; + vk_pipeline_shader_stage_create_info_element.flags = (VkPipelineShaderStageCreateFlags)rhi_pipeline_shader_stage_create_info_element.flags; + vk_pipeline_shader_stage_create_info_element.stage = (VkShaderStageFlagBits)rhi_pipeline_shader_stage_create_info_element.stage; + vk_pipeline_shader_stage_create_info_element.module = ((VulkanShader*)rhi_pipeline_shader_stage_create_info_element.module)->getResource(); + vk_pipeline_shader_stage_create_info_element.pName = rhi_pipeline_shader_stage_create_info_element.pName; + }; + + if (!((specialization_map_entry_size_total == specialization_map_entry_current) + && (specialization_info_total == specialization_info_current))) + { + LOG_ERROR("(specialization_map_entry_size_total == specialization_map_entry_current)&& (specialization_info_total == specialization_info_current)"); + return false; + } + + //vertex_input_binding_description + int vertex_input_binding_description_size = pCreateInfo->pVertexInputState->vertexBindingDescriptionCount; + std::vector vk_vertex_input_binding_description_list(vertex_input_binding_description_size); + for (int i = 0; i < vertex_input_binding_description_size; ++i) + { + const auto& rhi_vertex_input_binding_description_element = pCreateInfo->pVertexInputState->pVertexBindingDescriptions[i]; + auto& vk_vertex_input_binding_description_element = vk_vertex_input_binding_description_list[i]; + + vk_vertex_input_binding_description_element.binding = rhi_vertex_input_binding_description_element.binding; + vk_vertex_input_binding_description_element.stride = rhi_vertex_input_binding_description_element.stride; + vk_vertex_input_binding_description_element.inputRate = (VkVertexInputRate)rhi_vertex_input_binding_description_element.inputRate; + }; + + //vertex_input_attribute_description + int vertex_input_attribute_description_size = pCreateInfo->pVertexInputState->vertexAttributeDescriptionCount; + std::vector vk_vertex_input_attribute_description_list(vertex_input_attribute_description_size); + for (int i = 0; i < vertex_input_attribute_description_size; ++i) + { + const auto& rhi_vertex_input_attribute_description_element = pCreateInfo->pVertexInputState->pVertexAttributeDescriptions[i]; + auto& vk_vertex_input_attribute_description_element = vk_vertex_input_attribute_description_list[i]; + + vk_vertex_input_attribute_description_element.location = rhi_vertex_input_attribute_description_element.location; + vk_vertex_input_attribute_description_element.binding = rhi_vertex_input_attribute_description_element.binding; + vk_vertex_input_attribute_description_element.format = (VkFormat)rhi_vertex_input_attribute_description_element.format; + vk_vertex_input_attribute_description_element.offset = rhi_vertex_input_attribute_description_element.offset; + }; + + VkPipelineVertexInputStateCreateInfo vk_pipeline_vertex_input_state_create_info{}; + vk_pipeline_vertex_input_state_create_info.sType = (VkStructureType)pCreateInfo->pVertexInputState->sType; + vk_pipeline_vertex_input_state_create_info.pNext = (const void*)pCreateInfo->pVertexInputState->pNext; + vk_pipeline_vertex_input_state_create_info.flags = (VkPipelineVertexInputStateCreateFlags)pCreateInfo->pVertexInputState->flags; + vk_pipeline_vertex_input_state_create_info.vertexBindingDescriptionCount = pCreateInfo->pVertexInputState->vertexBindingDescriptionCount; + vk_pipeline_vertex_input_state_create_info.pVertexBindingDescriptions = vk_vertex_input_binding_description_list.data(); + vk_pipeline_vertex_input_state_create_info.vertexAttributeDescriptionCount = pCreateInfo->pVertexInputState->vertexAttributeDescriptionCount; + vk_pipeline_vertex_input_state_create_info.pVertexAttributeDescriptions = vk_vertex_input_attribute_description_list.data(); + + VkPipelineInputAssemblyStateCreateInfo vk_pipeline_input_assembly_state_create_info{}; + vk_pipeline_input_assembly_state_create_info.sType = (VkStructureType)pCreateInfo->pInputAssemblyState->sType; + vk_pipeline_input_assembly_state_create_info.pNext = (const void*)pCreateInfo->pInputAssemblyState->pNext; + vk_pipeline_input_assembly_state_create_info.flags = (VkPipelineInputAssemblyStateCreateFlags)pCreateInfo->pInputAssemblyState->flags; + vk_pipeline_input_assembly_state_create_info.topology = (VkPrimitiveTopology)pCreateInfo->pInputAssemblyState->topology; + vk_pipeline_input_assembly_state_create_info.primitiveRestartEnable = (VkBool32)pCreateInfo->pInputAssemblyState->primitiveRestartEnable; + + const VkPipelineTessellationStateCreateInfo* vk_pipeline_tessellation_state_create_info_ptr = nullptr; + VkPipelineTessellationStateCreateInfo vk_pipeline_tessellation_state_create_info{}; + if (pCreateInfo->pTessellationState != nullptr) + { + vk_pipeline_tessellation_state_create_info.sType = (VkStructureType)pCreateInfo->pTessellationState->sType; + vk_pipeline_tessellation_state_create_info.pNext = (const void*)pCreateInfo->pTessellationState->pNext; + vk_pipeline_tessellation_state_create_info.flags = (VkPipelineTessellationStateCreateFlags)pCreateInfo->pTessellationState->flags; + vk_pipeline_tessellation_state_create_info.patchControlPoints = pCreateInfo->pTessellationState->patchControlPoints; + + vk_pipeline_tessellation_state_create_info_ptr = &vk_pipeline_tessellation_state_create_info; + } + + //viewport + int viewport_size = pCreateInfo->pViewportState->viewportCount; + std::vector vk_viewport_list(viewport_size); + for (int i = 0; i < viewport_size; ++i) + { + const auto& rhi_viewport_element = pCreateInfo->pViewportState->pViewports[i]; + auto& vk_viewport_element = vk_viewport_list[i]; + + vk_viewport_element.x = rhi_viewport_element.x; + vk_viewport_element.y = rhi_viewport_element.y; + vk_viewport_element.width = rhi_viewport_element.width; + vk_viewport_element.height = rhi_viewport_element.height; + vk_viewport_element.minDepth = rhi_viewport_element.minDepth; + vk_viewport_element.maxDepth = rhi_viewport_element.maxDepth; + }; + + //rect_2d + int rect_2d_size = pCreateInfo->pViewportState->scissorCount; + std::vector vk_rect_2d_list(rect_2d_size); + for (int i = 0; i < rect_2d_size; ++i) + { + const auto& rhi_rect_2d_element = pCreateInfo->pViewportState->pScissors[i]; + auto& vk_rect_2d_element = vk_rect_2d_list[i]; + + VkOffset2D offset2d{}; + offset2d.x = rhi_rect_2d_element.offset.x; + offset2d.y = rhi_rect_2d_element.offset.y; + + VkExtent2D extend2d{}; + extend2d.width = rhi_rect_2d_element.extent.width; + extend2d.height = rhi_rect_2d_element.extent.height; + + vk_rect_2d_element.offset = offset2d; + vk_rect_2d_element.extent = extend2d; + }; + + VkPipelineViewportStateCreateInfo vk_pipeline_viewport_state_create_info{}; + vk_pipeline_viewport_state_create_info.sType = (VkStructureType)pCreateInfo->pViewportState->sType; + vk_pipeline_viewport_state_create_info.pNext = (const void*)pCreateInfo->pViewportState->pNext; + vk_pipeline_viewport_state_create_info.flags = (VkPipelineViewportStateCreateFlags)pCreateInfo->pViewportState->flags; + vk_pipeline_viewport_state_create_info.viewportCount = pCreateInfo->pViewportState->viewportCount; + vk_pipeline_viewport_state_create_info.pViewports = vk_viewport_list.data(); + vk_pipeline_viewport_state_create_info.scissorCount = pCreateInfo->pViewportState->scissorCount; + vk_pipeline_viewport_state_create_info.pScissors = vk_rect_2d_list.data(); + + VkPipelineRasterizationStateCreateInfo vk_pipeline_rasterization_state_create_info{}; + vk_pipeline_rasterization_state_create_info.sType = (VkStructureType)pCreateInfo->pRasterizationState->sType; + vk_pipeline_rasterization_state_create_info.pNext = (const void*)pCreateInfo->pRasterizationState->pNext; + vk_pipeline_rasterization_state_create_info.flags = (VkPipelineRasterizationStateCreateFlags)pCreateInfo->pRasterizationState->flags; + vk_pipeline_rasterization_state_create_info.depthClampEnable = (VkBool32)pCreateInfo->pRasterizationState->depthClampEnable; + vk_pipeline_rasterization_state_create_info.rasterizerDiscardEnable = (VkBool32)pCreateInfo->pRasterizationState->rasterizerDiscardEnable; + vk_pipeline_rasterization_state_create_info.polygonMode = (VkPolygonMode)pCreateInfo->pRasterizationState->polygonMode; + vk_pipeline_rasterization_state_create_info.cullMode = (VkCullModeFlags)pCreateInfo->pRasterizationState->cullMode; + vk_pipeline_rasterization_state_create_info.frontFace = (VkFrontFace)pCreateInfo->pRasterizationState->frontFace; + vk_pipeline_rasterization_state_create_info.depthBiasEnable = (VkBool32)pCreateInfo->pRasterizationState->depthBiasEnable; + vk_pipeline_rasterization_state_create_info.depthBiasConstantFactor = pCreateInfo->pRasterizationState->depthBiasConstantFactor; + vk_pipeline_rasterization_state_create_info.depthBiasClamp = pCreateInfo->pRasterizationState->depthBiasClamp; + vk_pipeline_rasterization_state_create_info.depthBiasSlopeFactor = pCreateInfo->pRasterizationState->depthBiasSlopeFactor; + vk_pipeline_rasterization_state_create_info.lineWidth = pCreateInfo->pRasterizationState->lineWidth; + + VkPipelineMultisampleStateCreateInfo vk_pipeline_multisample_state_create_info{}; + vk_pipeline_multisample_state_create_info.sType = (VkStructureType)pCreateInfo->pMultisampleState->sType; + vk_pipeline_multisample_state_create_info.pNext = (const void*)pCreateInfo->pMultisampleState->pNext; + vk_pipeline_multisample_state_create_info.flags = (VkPipelineMultisampleStateCreateFlags)pCreateInfo->pMultisampleState->flags; + vk_pipeline_multisample_state_create_info.rasterizationSamples = (VkSampleCountFlagBits)pCreateInfo->pMultisampleState->rasterizationSamples; + vk_pipeline_multisample_state_create_info.sampleShadingEnable = (VkBool32)pCreateInfo->pMultisampleState->sampleShadingEnable; + vk_pipeline_multisample_state_create_info.minSampleShading = pCreateInfo->pMultisampleState->minSampleShading; + vk_pipeline_multisample_state_create_info.pSampleMask = (const RHISampleMask*)pCreateInfo->pMultisampleState->pSampleMask; + vk_pipeline_multisample_state_create_info.alphaToCoverageEnable = (VkBool32)pCreateInfo->pMultisampleState->alphaToCoverageEnable; + vk_pipeline_multisample_state_create_info.alphaToOneEnable = (VkBool32)pCreateInfo->pMultisampleState->alphaToOneEnable; + + VkStencilOpState stencil_op_state_front{}; + stencil_op_state_front.failOp = (VkStencilOp)pCreateInfo->pDepthStencilState->front.failOp; + stencil_op_state_front.passOp = (VkStencilOp)pCreateInfo->pDepthStencilState->front.passOp; + stencil_op_state_front.depthFailOp = (VkStencilOp)pCreateInfo->pDepthStencilState->front.depthFailOp; + stencil_op_state_front.compareOp = (VkCompareOp)pCreateInfo->pDepthStencilState->front.compareOp; + stencil_op_state_front.compareMask = pCreateInfo->pDepthStencilState->front.compareMask; + stencil_op_state_front.writeMask = pCreateInfo->pDepthStencilState->front.writeMask; + stencil_op_state_front.reference = pCreateInfo->pDepthStencilState->front.reference; + + VkStencilOpState stencil_op_state_back{}; + stencil_op_state_back.failOp = (VkStencilOp)pCreateInfo->pDepthStencilState->back.failOp; + stencil_op_state_back.passOp = (VkStencilOp)pCreateInfo->pDepthStencilState->back.passOp; + stencil_op_state_back.depthFailOp = (VkStencilOp)pCreateInfo->pDepthStencilState->back.depthFailOp; + stencil_op_state_back.compareOp = (VkCompareOp)pCreateInfo->pDepthStencilState->back.compareOp; + stencil_op_state_back.compareMask = pCreateInfo->pDepthStencilState->back.compareMask; + stencil_op_state_back.writeMask = pCreateInfo->pDepthStencilState->back.writeMask; + stencil_op_state_back.reference = pCreateInfo->pDepthStencilState->back.reference; + + + VkPipelineDepthStencilStateCreateInfo vk_pipeline_depth_stencil_state_create_info{}; + vk_pipeline_depth_stencil_state_create_info.sType = (VkStructureType)pCreateInfo->pDepthStencilState->sType; + vk_pipeline_depth_stencil_state_create_info.pNext = (const void*)pCreateInfo->pDepthStencilState->pNext; + vk_pipeline_depth_stencil_state_create_info.flags = (VkPipelineDepthStencilStateCreateFlags)pCreateInfo->pDepthStencilState->flags; + vk_pipeline_depth_stencil_state_create_info.depthTestEnable = (VkBool32)pCreateInfo->pDepthStencilState->depthTestEnable; + vk_pipeline_depth_stencil_state_create_info.depthWriteEnable = (VkBool32)pCreateInfo->pDepthStencilState->depthWriteEnable; + vk_pipeline_depth_stencil_state_create_info.depthCompareOp = (VkCompareOp)pCreateInfo->pDepthStencilState->depthCompareOp; + vk_pipeline_depth_stencil_state_create_info.depthBoundsTestEnable = (VkBool32)pCreateInfo->pDepthStencilState->depthBoundsTestEnable; + vk_pipeline_depth_stencil_state_create_info.stencilTestEnable = (VkBool32)pCreateInfo->pDepthStencilState->stencilTestEnable; + vk_pipeline_depth_stencil_state_create_info.front = stencil_op_state_front; + vk_pipeline_depth_stencil_state_create_info.back = stencil_op_state_back; + vk_pipeline_depth_stencil_state_create_info.minDepthBounds = pCreateInfo->pDepthStencilState->minDepthBounds; + vk_pipeline_depth_stencil_state_create_info.maxDepthBounds = pCreateInfo->pDepthStencilState->maxDepthBounds; + + //pipeline_color_blend_attachment_state + int pipeline_color_blend_attachment_state_size = pCreateInfo->pColorBlendState->attachmentCount; + std::vector vk_pipeline_color_blend_attachment_state_list(pipeline_color_blend_attachment_state_size); + for (int i = 0; i < pipeline_color_blend_attachment_state_size; ++i) + { + const auto& rhi_pipeline_color_blend_attachment_state_element = pCreateInfo->pColorBlendState->pAttachments[i]; + auto& vk_pipeline_color_blend_attachment_state_element = vk_pipeline_color_blend_attachment_state_list[i]; + + vk_pipeline_color_blend_attachment_state_element.blendEnable = (VkBool32)rhi_pipeline_color_blend_attachment_state_element.blendEnable; + vk_pipeline_color_blend_attachment_state_element.srcColorBlendFactor = (VkBlendFactor)rhi_pipeline_color_blend_attachment_state_element.srcColorBlendFactor; + vk_pipeline_color_blend_attachment_state_element.dstColorBlendFactor = (VkBlendFactor)rhi_pipeline_color_blend_attachment_state_element.dstColorBlendFactor; + vk_pipeline_color_blend_attachment_state_element.colorBlendOp = (VkBlendOp)rhi_pipeline_color_blend_attachment_state_element.colorBlendOp; + vk_pipeline_color_blend_attachment_state_element.srcAlphaBlendFactor = (VkBlendFactor)rhi_pipeline_color_blend_attachment_state_element.srcAlphaBlendFactor; + vk_pipeline_color_blend_attachment_state_element.dstAlphaBlendFactor = (VkBlendFactor)rhi_pipeline_color_blend_attachment_state_element.dstAlphaBlendFactor; + vk_pipeline_color_blend_attachment_state_element.alphaBlendOp = (VkBlendOp)rhi_pipeline_color_blend_attachment_state_element.alphaBlendOp; + vk_pipeline_color_blend_attachment_state_element.colorWriteMask = (VkColorComponentFlags)rhi_pipeline_color_blend_attachment_state_element.colorWriteMask; + }; + + VkPipelineColorBlendStateCreateInfo vk_pipeline_color_blend_state_create_info{}; + vk_pipeline_color_blend_state_create_info.sType = (VkStructureType)pCreateInfo->pColorBlendState->sType; + vk_pipeline_color_blend_state_create_info.pNext = pCreateInfo->pColorBlendState->pNext; + vk_pipeline_color_blend_state_create_info.flags = pCreateInfo->pColorBlendState->flags; + vk_pipeline_color_blend_state_create_info.logicOpEnable = pCreateInfo->pColorBlendState->logicOpEnable; + vk_pipeline_color_blend_state_create_info.logicOp = (VkLogicOp)pCreateInfo->pColorBlendState->logicOp; + vk_pipeline_color_blend_state_create_info.attachmentCount = pCreateInfo->pColorBlendState->attachmentCount; + vk_pipeline_color_blend_state_create_info.pAttachments = vk_pipeline_color_blend_attachment_state_list.data(); + for (int i = 0; i < 4; ++i) + { + vk_pipeline_color_blend_state_create_info.blendConstants[i] = pCreateInfo->pColorBlendState->blendConstants[i]; + }; + + //dynamic_state + int dynamic_state_size = pCreateInfo->pDynamicState->dynamicStateCount; + std::vector vk_dynamic_state_list(dynamic_state_size); + for (int i = 0; i < dynamic_state_size; ++i) + { + const auto& rhi_dynamic_state_element = pCreateInfo->pDynamicState->pDynamicStates[i]; + auto& vk_dynamic_state_element = vk_dynamic_state_list[i]; + + vk_dynamic_state_element = (VkDynamicState)rhi_dynamic_state_element; + }; + + VkPipelineDynamicStateCreateInfo vk_pipeline_dynamic_state_create_info{}; + vk_pipeline_dynamic_state_create_info.sType = (VkStructureType)pCreateInfo->pDynamicState->sType; + vk_pipeline_dynamic_state_create_info.pNext = pCreateInfo->pDynamicState->pNext; + vk_pipeline_dynamic_state_create_info.flags = (VkPipelineDynamicStateCreateFlags)pCreateInfo->pDynamicState->flags; + vk_pipeline_dynamic_state_create_info.dynamicStateCount = pCreateInfo->pDynamicState->dynamicStateCount; + vk_pipeline_dynamic_state_create_info.pDynamicStates = vk_dynamic_state_list.data(); + + VkGraphicsPipelineCreateInfo create_info{}; + create_info.sType = (VkStructureType)pCreateInfo->sType; + create_info.pNext = (const void*)pCreateInfo->pNext; + create_info.flags = (VkPipelineCreateFlags)pCreateInfo->flags; + create_info.stageCount = pCreateInfo->stageCount; + create_info.pStages = vk_pipeline_shader_stage_create_info_list.data(); + create_info.pVertexInputState = &vk_pipeline_vertex_input_state_create_info; + create_info.pInputAssemblyState = &vk_pipeline_input_assembly_state_create_info; + create_info.pTessellationState = vk_pipeline_tessellation_state_create_info_ptr; + create_info.pViewportState = &vk_pipeline_viewport_state_create_info; + create_info.pRasterizationState = &vk_pipeline_rasterization_state_create_info; + create_info.pMultisampleState = &vk_pipeline_multisample_state_create_info; + create_info.pDepthStencilState = &vk_pipeline_depth_stencil_state_create_info; + create_info.pColorBlendState = &vk_pipeline_color_blend_state_create_info; + create_info.pDynamicState = &vk_pipeline_dynamic_state_create_info; + create_info.layout = ((VulkanPipelineLayout*)pCreateInfo->layout)->getResource(); + create_info.renderPass = ((VulkanRenderPass*)pCreateInfo->renderPass)->getResource(); + create_info.subpass = pCreateInfo->subpass; + if (pCreateInfo->basePipelineHandle != nullptr) + { + create_info.basePipelineHandle = ((VulkanPipeline*)pCreateInfo->basePipelineHandle)->getResource(); + } + else + { + create_info.basePipelineHandle = VK_NULL_HANDLE; + } + create_info.basePipelineIndex = pCreateInfo->basePipelineIndex; + + pPipelines = new VulkanPipeline(); + VkPipeline vk_pipelines; + VkPipelineCache vk_pipeline_cache = VK_NULL_HANDLE; + if (pipelineCache != nullptr) + { + vk_pipeline_cache = ((VulkanPipelineCache*)pipelineCache)->getResource(); + } + VkResult result = vkCreateGraphicsPipelines(m_device, vk_pipeline_cache, createInfoCount, &create_info, nullptr, &vk_pipelines); + ((VulkanPipeline*)pPipelines)->setResource(vk_pipelines); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("vkCreateGraphicsPipelines failed!"); + return false; + } + } + + bool VulkanRHI::createComputePipelines(RHIPipelineCache* pipelineCache, uint32_t createInfoCount, const RHIComputePipelineCreateInfo* pCreateInfos, RHIPipeline*& pPipelines) + { + VkPipelineShaderStageCreateInfo shader_stage_create_info{}; + if (pCreateInfos->pStages->pSpecializationInfo != nullptr) + { + //will be complete soon if needed. + shader_stage_create_info.pSpecializationInfo = nullptr; + } + else + { + shader_stage_create_info.pSpecializationInfo = nullptr; + } + shader_stage_create_info.sType = (VkStructureType)pCreateInfos->pStages->sType; + shader_stage_create_info.pNext = (const void*)pCreateInfos->pStages->pNext; + shader_stage_create_info.flags = (VkPipelineShaderStageCreateFlags)pCreateInfos->pStages->flags; + shader_stage_create_info.stage = (VkShaderStageFlagBits)pCreateInfos->pStages->stage; + shader_stage_create_info.module = ((VulkanShader*)pCreateInfos->pStages->module)->getResource(); + shader_stage_create_info.pName = pCreateInfos->pStages->pName; + + VkComputePipelineCreateInfo create_info{}; + create_info.sType = (VkStructureType)pCreateInfos->sType; + create_info.pNext = (const void*)pCreateInfos->pNext; + create_info.flags = (VkPipelineCreateFlags)pCreateInfos->flags; + create_info.stage = shader_stage_create_info; + create_info.layout = ((VulkanPipelineLayout*)pCreateInfos->layout)->getResource();; + if (pCreateInfos->basePipelineHandle != nullptr) + { + create_info.basePipelineHandle = ((VulkanPipeline*)pCreateInfos->basePipelineHandle)->getResource(); + } + else + { + create_info.basePipelineHandle = VK_NULL_HANDLE; + } + create_info.basePipelineIndex = pCreateInfos->basePipelineIndex; + + pPipelines = new VulkanPipeline(); + VkPipeline vk_pipelines; + VkPipelineCache vk_pipeline_cache = VK_NULL_HANDLE; + if (pipelineCache != nullptr) + { + vk_pipeline_cache = ((VulkanPipelineCache*)pipelineCache)->getResource(); + } + VkResult result = vkCreateComputePipelines(m_device, vk_pipeline_cache, createInfoCount, &create_info, nullptr, &vk_pipelines); + ((VulkanPipeline*)pPipelines)->setResource(vk_pipelines); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("vkCreateComputePipelines failed!"); + return false; + } + } + + bool VulkanRHI::createPipelineLayout(const RHIPipelineLayoutCreateInfo* pCreateInfo, RHIPipelineLayout* &pPipelineLayout) + { + //descriptor_set_layout + int descriptor_set_layout_size = pCreateInfo->setLayoutCount; + std::vector vk_descriptor_set_layout_list(descriptor_set_layout_size); + for (int i = 0; i < descriptor_set_layout_size; ++i) + { + const auto& rhi_descriptor_set_layout_element = pCreateInfo->pSetLayouts[i]; + auto& vk_descriptor_set_layout_element = vk_descriptor_set_layout_list[i]; + + vk_descriptor_set_layout_element = ((VulkanDescriptorSetLayout*)rhi_descriptor_set_layout_element)->getResource(); + }; + + VkPipelineLayoutCreateInfo create_info{}; + create_info.sType = (VkStructureType)pCreateInfo->sType; + create_info.pNext = (const void*)pCreateInfo->pNext; + create_info.flags = (VkPipelineLayoutCreateFlags)pCreateInfo->flags; + create_info.setLayoutCount = pCreateInfo->setLayoutCount; + create_info.pSetLayouts = vk_descriptor_set_layout_list.data(); + + pPipelineLayout = new VulkanPipelineLayout(); + VkPipelineLayout vk_pipeline_layout; + VkResult result = vkCreatePipelineLayout(m_device, &create_info, nullptr, &vk_pipeline_layout); + ((VulkanPipelineLayout*)pPipelineLayout)->setResource(vk_pipeline_layout); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("vkCreatePipelineLayout failed!"); + return false; + } + } + + bool VulkanRHI::createRenderPass(const RHIRenderPassCreateInfo* pCreateInfo, RHIRenderPass* &pRenderPass) + { + // attachment convert + std::vector vk_attachments(pCreateInfo->attachmentCount); + for (int i = 0; i < pCreateInfo->attachmentCount; ++i) + { + const auto& rhi_desc = pCreateInfo->pAttachments[i]; + auto& vk_desc = vk_attachments[i]; + + vk_desc.flags = (VkAttachmentDescriptionFlags)(rhi_desc).flags; + vk_desc.format = (VkFormat)(rhi_desc).format; + vk_desc.samples = (VkSampleCountFlagBits)(rhi_desc).samples; + vk_desc.loadOp = (VkAttachmentLoadOp)(rhi_desc).loadOp; + vk_desc.storeOp = (VkAttachmentStoreOp)(rhi_desc).storeOp; + vk_desc.stencilLoadOp = (VkAttachmentLoadOp)(rhi_desc).stencilLoadOp; + vk_desc.stencilStoreOp = (VkAttachmentStoreOp)(rhi_desc).stencilStoreOp; + vk_desc.initialLayout = (VkImageLayout)(rhi_desc).initialLayout; + vk_desc.finalLayout = (VkImageLayout)(rhi_desc).finalLayout; + }; + + // subpass convert + int totalAttachmentRefenrence = 0; + for (int i = 0; i < pCreateInfo->subpassCount; i++) + { + const auto& rhi_desc = pCreateInfo->pSubpasses[i]; + totalAttachmentRefenrence += rhi_desc.inputAttachmentCount; // pInputAttachments + totalAttachmentRefenrence += rhi_desc.colorAttachmentCount; // pColorAttachments + if (rhi_desc.pDepthStencilAttachment != nullptr) + { + totalAttachmentRefenrence += rhi_desc.colorAttachmentCount; // pDepthStencilAttachment + } + if (rhi_desc.pResolveAttachments != nullptr) + { + totalAttachmentRefenrence += rhi_desc.colorAttachmentCount; // pResolveAttachments + } + } + std::vector vk_subpass_description(pCreateInfo->subpassCount); + std::vector vk_attachment_reference(totalAttachmentRefenrence); + int currentAttachmentRefence = 0; + for (int i = 0; i < pCreateInfo->subpassCount; ++i) + { + const auto& rhi_desc = pCreateInfo->pSubpasses[i]; + auto& vk_desc = vk_subpass_description[i]; + + vk_desc.flags = (VkSubpassDescriptionFlags)(rhi_desc).flags; + vk_desc.pipelineBindPoint = (VkPipelineBindPoint)(rhi_desc).pipelineBindPoint; + vk_desc.preserveAttachmentCount = (rhi_desc).preserveAttachmentCount; + vk_desc.pPreserveAttachments = (const uint32_t*)(rhi_desc).pPreserveAttachments; + + vk_desc.inputAttachmentCount = (rhi_desc).inputAttachmentCount; + vk_desc.pInputAttachments = &vk_attachment_reference[currentAttachmentRefence]; + for (int i = 0; i < (rhi_desc).inputAttachmentCount; i++) + { + const auto& rhi_attachment_refence_input = (rhi_desc).pInputAttachments[i]; + auto& vk_attachment_refence_input = vk_attachment_reference[currentAttachmentRefence]; + + vk_attachment_refence_input.attachment = rhi_attachment_refence_input.attachment; + vk_attachment_refence_input.layout = (VkImageLayout)(rhi_attachment_refence_input.layout); + + currentAttachmentRefence += 1; + }; + + vk_desc.colorAttachmentCount = (rhi_desc).colorAttachmentCount; + vk_desc.pColorAttachments = &vk_attachment_reference[currentAttachmentRefence]; + for (int i = 0; i < (rhi_desc).colorAttachmentCount; ++i) + { + const auto& rhi_attachment_refence_color = (rhi_desc).pColorAttachments[i]; + auto& vk_attachment_refence_color = vk_attachment_reference[currentAttachmentRefence]; + + vk_attachment_refence_color.attachment = rhi_attachment_refence_color.attachment; + vk_attachment_refence_color.layout = (VkImageLayout)(rhi_attachment_refence_color.layout); + + currentAttachmentRefence += 1; + }; + + if (rhi_desc.pResolveAttachments != nullptr) + { + vk_desc.pResolveAttachments = &vk_attachment_reference[currentAttachmentRefence]; + for (int i = 0; i < (rhi_desc).colorAttachmentCount; ++i) + { + const auto& rhi_attachment_refence_resolve = (rhi_desc).pResolveAttachments[i]; + auto& vk_attachment_refence_resolve = vk_attachment_reference[currentAttachmentRefence]; + + vk_attachment_refence_resolve.attachment = rhi_attachment_refence_resolve.attachment; + vk_attachment_refence_resolve.layout = (VkImageLayout)(rhi_attachment_refence_resolve.layout); + + currentAttachmentRefence += 1; + }; + } + + if (rhi_desc.pDepthStencilAttachment != nullptr) + { + vk_desc.pDepthStencilAttachment = &vk_attachment_reference[currentAttachmentRefence]; + for (int i = 0; i < (rhi_desc).colorAttachmentCount; ++i) + { + const auto& rhi_attachment_refence_depth = (rhi_desc).pDepthStencilAttachment[i]; + auto& vk_attachment_refence_depth = vk_attachment_reference[currentAttachmentRefence]; + + vk_attachment_refence_depth.attachment = rhi_attachment_refence_depth.attachment; + vk_attachment_refence_depth.layout = (VkImageLayout)(rhi_attachment_refence_depth.layout); + + currentAttachmentRefence += 1; + }; + }; + }; + if (currentAttachmentRefence != totalAttachmentRefenrence) + { + LOG_ERROR("currentAttachmentRefence != totalAttachmentRefenrence"); + return false; + } + + std::vector vk_subpass_depandecy(pCreateInfo->dependencyCount); + for (int i = 0; i < pCreateInfo->dependencyCount; ++i) + { + const auto& rhi_desc = pCreateInfo->pDependencies[i]; + auto& vk_desc = vk_subpass_depandecy[i]; + + vk_desc.srcSubpass = rhi_desc.srcSubpass; + vk_desc.dstSubpass = rhi_desc.dstSubpass; + vk_desc.srcStageMask = (VkPipelineStageFlags)(rhi_desc).srcStageMask; + vk_desc.dstStageMask = (VkPipelineStageFlags)(rhi_desc).dstStageMask; + vk_desc.srcAccessMask = (VkAccessFlags)(rhi_desc).srcAccessMask; + vk_desc.dstAccessMask = (VkAccessFlags)(rhi_desc).dstAccessMask; + vk_desc.dependencyFlags = (VkDependencyFlags)(rhi_desc).dependencyFlags; + }; + + VkRenderPassCreateInfo create_info{}; + create_info.sType = (VkStructureType)pCreateInfo->sType; + create_info.pNext = (const void*)pCreateInfo->pNext; + create_info.flags = (VkRenderPassCreateFlags)pCreateInfo->flags; + create_info.attachmentCount = pCreateInfo->attachmentCount; + create_info.pAttachments = vk_attachments.data(); + create_info.subpassCount = pCreateInfo->subpassCount; + create_info.pSubpasses = vk_subpass_description.data(); + create_info.dependencyCount = pCreateInfo->dependencyCount; + create_info.pDependencies = vk_subpass_depandecy.data(); + + pRenderPass = new VulkanRenderPass(); + VkRenderPass vk_render_pass; + VkResult result = vkCreateRenderPass(m_device, &create_info, nullptr, &vk_render_pass); + ((VulkanRenderPass*)pRenderPass)->setResource(vk_render_pass); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("vkCreateRenderPass failed!"); + return false; + } + } + + bool VulkanRHI::createSampler(const RHISamplerCreateInfo* pCreateInfo, RHISampler* &pSampler) + { + VkSamplerCreateInfo create_info{}; + create_info.sType = (VkStructureType)pCreateInfo->sType; + create_info.pNext = (const void*)pCreateInfo->pNext; + create_info.flags = (VkSamplerCreateFlags)pCreateInfo->flags; + create_info.magFilter = (VkFilter)pCreateInfo->magFilter; + create_info.minFilter = (VkFilter)pCreateInfo->minFilter; + create_info.mipmapMode = (VkSamplerMipmapMode)pCreateInfo->mipmapMode; + create_info.addressModeU = (VkSamplerAddressMode)pCreateInfo->addressModeU; + create_info.addressModeV = (VkSamplerAddressMode)pCreateInfo->addressModeV; + create_info.addressModeW = (VkSamplerAddressMode)pCreateInfo->addressModeW; + create_info.mipLodBias = pCreateInfo->mipLodBias; + create_info.anisotropyEnable = (VkBool32)pCreateInfo->anisotropyEnable; + create_info.maxAnisotropy = pCreateInfo->maxAnisotropy; + create_info.compareEnable = (VkBool32)pCreateInfo->compareEnable; + create_info.compareOp = (VkCompareOp)pCreateInfo->compareOp; + create_info.minLod = pCreateInfo->minLod; + create_info.maxLod = pCreateInfo->maxLod; + create_info.borderColor = (VkBorderColor)pCreateInfo->borderColor; + create_info.unnormalizedCoordinates = (VkBool32)pCreateInfo->unnormalizedCoordinates; + + pSampler = new VulkanSampler(); + VkSampler vk_sampler; + VkResult result = vkCreateSampler(m_device, &create_info, nullptr, &vk_sampler); + ((VulkanSampler*)pSampler)->setResource(vk_sampler); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("vkCreateSampler failed!"); + return false; + } + } + + bool VulkanRHI::createSemaphore(const RHISemaphoreCreateInfo* pCreateInfo, RHISemaphore* &pSemaphore) + { + VkSemaphoreCreateInfo create_info{}; + create_info.sType = (VkStructureType)pCreateInfo->sType; + create_info.pNext = pCreateInfo->pNext; + create_info.flags = (VkSemaphoreCreateFlags)pCreateInfo->flags; + + pSemaphore = new VulkanSemaphore(); + VkSemaphore vk_semaphore; + VkResult result = vkCreateSemaphore(m_device, &create_info, nullptr, &vk_semaphore); + ((VulkanSemaphore*)pSemaphore)->setResource(vk_semaphore); + + if (result == VK_SUCCESS) + { + return RHI_SUCCESS; + } + else + { + LOG_ERROR("vkCreateSemaphore failed!"); + return false; + } + } + + bool VulkanRHI::waitForFencesPFN(uint32_t fenceCount, RHIFence* const* pFences, RHIBool32 waitAll, uint64_t timeout) + { + //fence + int fence_size = fenceCount; + std::vector vk_fence_list(fence_size); + for (int i = 0; i < fence_size; ++i) + { + const auto& rhi_fence_element = pFences[i]; + auto& vk_fence_element = vk_fence_list[i]; + + vk_fence_element = ((VulkanFence*)rhi_fence_element)->getResource(); + }; + + VkResult result = _vkWaitForFences(m_device, fenceCount, vk_fence_list.data(), waitAll, timeout); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("_vkWaitForFences failed!"); + return false; + } + } + + bool VulkanRHI::resetFencesPFN(uint32_t fenceCount, RHIFence* const* pFences) + { + //fence + int fence_size = fenceCount; + std::vector vk_fence_list(fence_size); + for (int i = 0; i < fence_size; ++i) + { + const auto& rhi_fence_element = pFences[i]; + auto& vk_fence_element = vk_fence_list[i]; + + vk_fence_element = ((VulkanFence*)rhi_fence_element)->getResource(); + }; + + VkResult result = _vkResetFences(m_device, fenceCount, vk_fence_list.data()); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("_vkResetFences failed!"); + return false; + } + } + + bool VulkanRHI::resetCommandPoolPFN(RHICommandPool* commandPool, RHICommandPoolResetFlags flags) + { + VkResult result = _vkResetCommandPool(m_device, ((VulkanCommandPool*)commandPool)->getResource(), (VkCommandPoolResetFlags)flags); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("_vkResetCommandPool failed!"); + return false; + } + } + + bool VulkanRHI::beginCommandBufferPFN(RHICommandBuffer* commandBuffer, const RHICommandBufferBeginInfo* pBeginInfo) + { + VkCommandBufferInheritanceInfo* command_buffer_inheritance_info_ptr = nullptr; + VkCommandBufferInheritanceInfo command_buffer_inheritance_info{}; + if (pBeginInfo->pInheritanceInfo != nullptr) + { + command_buffer_inheritance_info.sType = (VkStructureType)pBeginInfo->pInheritanceInfo->sType; + command_buffer_inheritance_info.pNext = (const void*)pBeginInfo->pInheritanceInfo->pNext; + command_buffer_inheritance_info.renderPass = ((VulkanRenderPass*)pBeginInfo->pInheritanceInfo->renderPass)->getResource(); + command_buffer_inheritance_info.subpass = pBeginInfo->pInheritanceInfo->subpass; + command_buffer_inheritance_info.framebuffer = ((VulkanFramebuffer*)pBeginInfo->pInheritanceInfo->framebuffer)->getResource(); + command_buffer_inheritance_info.occlusionQueryEnable = (VkBool32)pBeginInfo->pInheritanceInfo->occlusionQueryEnable; + command_buffer_inheritance_info.queryFlags = (VkQueryControlFlags)pBeginInfo->pInheritanceInfo->queryFlags; + command_buffer_inheritance_info.pipelineStatistics = (VkQueryPipelineStatisticFlags)pBeginInfo->pInheritanceInfo->pipelineStatistics; + + command_buffer_inheritance_info_ptr = &command_buffer_inheritance_info; + } + + VkCommandBufferBeginInfo command_buffer_begin_info{}; + command_buffer_begin_info.sType = (VkStructureType)pBeginInfo->sType; + command_buffer_begin_info.pNext = (const void*)pBeginInfo->pNext; + command_buffer_begin_info.flags = (VkCommandBufferUsageFlags)pBeginInfo->flags; + command_buffer_begin_info.pInheritanceInfo = command_buffer_inheritance_info_ptr; + VkResult result = _vkBeginCommandBuffer(((VulkanCommandBuffer*)commandBuffer)->getResource(), &command_buffer_begin_info); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("_vkBeginCommandBuffer failed!"); + return false; + } + } + + bool VulkanRHI::endCommandBufferPFN(RHICommandBuffer* commandBuffer) + { + VkResult result = _vkEndCommandBuffer(((VulkanCommandBuffer*)commandBuffer)->getResource()); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("_vkEndCommandBuffer failed!"); + return false; + } + } + + void VulkanRHI::cmdBeginRenderPassPFN(RHICommandBuffer* commandBuffer, const RHIRenderPassBeginInfo* pRenderPassBegin, RHISubpassContents contents) + { + VkOffset2D offset_2d{}; + offset_2d.x = pRenderPassBegin->renderArea.offset.x; + offset_2d.y = pRenderPassBegin->renderArea.offset.y; + + VkExtent2D extent_2d{}; + extent_2d.width = pRenderPassBegin->renderArea.extent.width; + extent_2d.height = pRenderPassBegin->renderArea.extent.height; + + VkRect2D rect_2d{}; + rect_2d.offset = offset_2d; + rect_2d.extent = extent_2d; + + //clear_values + int clear_value_size = pRenderPassBegin->clearValueCount; + std::vector vk_clear_value_list(clear_value_size); + for (int i = 0; i < clear_value_size; ++i) + { + const auto& rhi_clear_value_element = pRenderPassBegin->pClearValues[i]; + auto& vk_clear_value_element = vk_clear_value_list[i]; + + VkClearColorValue vk_clear_color_value; + vk_clear_color_value.float32[0] = rhi_clear_value_element.color.float32[0]; + vk_clear_color_value.float32[1] = rhi_clear_value_element.color.float32[1]; + vk_clear_color_value.float32[2] = rhi_clear_value_element.color.float32[2]; + vk_clear_color_value.float32[3] = rhi_clear_value_element.color.float32[3]; + vk_clear_color_value.int32[0] = rhi_clear_value_element.color.int32[0]; + vk_clear_color_value.int32[1] = rhi_clear_value_element.color.int32[1]; + vk_clear_color_value.int32[2] = rhi_clear_value_element.color.int32[2]; + vk_clear_color_value.int32[3] = rhi_clear_value_element.color.int32[3]; + vk_clear_color_value.uint32[0] = rhi_clear_value_element.color.uint32[0]; + vk_clear_color_value.uint32[1] = rhi_clear_value_element.color.uint32[1]; + vk_clear_color_value.uint32[2] = rhi_clear_value_element.color.uint32[2]; + vk_clear_color_value.uint32[3] = rhi_clear_value_element.color.uint32[3]; + + VkClearDepthStencilValue vk_clear_depth_stencil_value; + vk_clear_depth_stencil_value.depth = rhi_clear_value_element.depthStencil.depth; + vk_clear_depth_stencil_value.stencil = rhi_clear_value_element.depthStencil.stencil; + + vk_clear_value_element.color = vk_clear_color_value; + vk_clear_value_element.depthStencil = vk_clear_depth_stencil_value; + + }; + + VkRenderPassBeginInfo vk_render_pass_begin_info{}; + vk_render_pass_begin_info.sType = (VkStructureType)pRenderPassBegin->sType; + vk_render_pass_begin_info.pNext = pRenderPassBegin->pNext; + vk_render_pass_begin_info.renderPass = ((VulkanRenderPass*)pRenderPassBegin->renderPass)->getResource(); + vk_render_pass_begin_info.framebuffer = ((VulkanFramebuffer*)pRenderPassBegin->framebuffer)->getResource(); + vk_render_pass_begin_info.renderArea = rect_2d; + vk_render_pass_begin_info.clearValueCount = pRenderPassBegin->clearValueCount; + vk_render_pass_begin_info.pClearValues = vk_clear_value_list.data(); + + return _vkCmdBeginRenderPass(((VulkanCommandBuffer*)commandBuffer)->getResource(), &vk_render_pass_begin_info, (VkSubpassContents)contents); + } + + void VulkanRHI::cmdNextSubpassPFN(RHICommandBuffer* commandBuffer, RHISubpassContents contents) + { + return _vkCmdNextSubpass(((VulkanCommandBuffer*)commandBuffer)->getResource(), ((VkSubpassContents)contents)); + } + + void VulkanRHI::cmdEndRenderPassPFN(RHICommandBuffer* commandBuffer) + { + return _vkCmdEndRenderPass(((VulkanCommandBuffer*)commandBuffer)->getResource()); + } + + void VulkanRHI::cmdBindPipelinePFN(RHICommandBuffer* commandBuffer, RHIPipelineBindPoint pipelineBindPoint, RHIPipeline* pipeline) + { + return _vkCmdBindPipeline(((VulkanCommandBuffer*)commandBuffer)->getResource(), (VkPipelineBindPoint)pipelineBindPoint, ((VulkanPipeline*)pipeline)->getResource()); + } + + void VulkanRHI::cmdSetViewportPFN(RHICommandBuffer* commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const RHIViewport* pViewports) + { + //viewport + int viewport_size = viewportCount; + std::vector vk_viewport_list(viewport_size); + for (int i = 0; i < viewport_size; ++i) + { + const auto& rhi_viewport_element = pViewports[i]; + auto& vk_viewport_element = vk_viewport_list[i]; + + vk_viewport_element.x = rhi_viewport_element.x; + vk_viewport_element.y = rhi_viewport_element.y; + vk_viewport_element.width = rhi_viewport_element.width; + vk_viewport_element.height = rhi_viewport_element.height; + vk_viewport_element.minDepth = rhi_viewport_element.minDepth; + vk_viewport_element.maxDepth = rhi_viewport_element.maxDepth; + }; + + return _vkCmdSetViewport(((VulkanCommandBuffer*)commandBuffer)->getResource(), firstViewport, viewportCount, vk_viewport_list.data()); + } + + void VulkanRHI::cmdSetScissorPFN(RHICommandBuffer* commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const RHIRect2D* pScissors) + { + //rect_2d + int rect_2d_size = scissorCount; + std::vector vk_rect_2d_list(rect_2d_size); + for (int i = 0; i < rect_2d_size; ++i) + { + const auto& rhi_rect_2d_element = pScissors[i]; + auto& vk_rect_2d_element = vk_rect_2d_list[i]; + + VkOffset2D offset_2d{}; + offset_2d.x = rhi_rect_2d_element.offset.x; + offset_2d.y = rhi_rect_2d_element.offset.y; + + VkExtent2D extent_2d{}; + extent_2d.width = rhi_rect_2d_element.extent.width; + extent_2d.height = rhi_rect_2d_element.extent.height; + + vk_rect_2d_element.offset = (VkOffset2D)offset_2d; + vk_rect_2d_element.extent = (VkExtent2D)extent_2d; + + }; + + return _vkCmdSetScissor(((VulkanCommandBuffer*)commandBuffer)->getResource(), firstScissor, scissorCount, vk_rect_2d_list.data()); + } + + void VulkanRHI::cmdBindVertexBuffersPFN( + RHICommandBuffer* commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + RHIBuffer* const* pBuffers, + const RHIDeviceSize* pOffsets) + { + //buffer + int buffer_size = bindingCount; + std::vector vk_buffer_list(buffer_size); + for (int i = 0; i < buffer_size; ++i) + { + const auto& rhi_buffer_element = pBuffers[i]; + auto& vk_buffer_element = vk_buffer_list[i]; + + vk_buffer_element = ((VulkanBuffer*)rhi_buffer_element)->getResource(); + }; + + //offset + int offset_size = bindingCount; + std::vector vk_device_size_list(offset_size); + for (int i = 0; i < offset_size; ++i) + { + const auto& rhi_offset_element = pOffsets[i]; + auto& vk_offset_element = vk_device_size_list[i]; + + vk_offset_element = rhi_offset_element; + }; + + return _vkCmdBindVertexBuffers(((VulkanCommandBuffer*)commandBuffer)->getResource(), firstBinding, bindingCount, vk_buffer_list.data(), vk_device_size_list.data()); + } + + void VulkanRHI::cmdBindIndexBufferPFN(RHICommandBuffer* commandBuffer, RHIBuffer* buffer, RHIDeviceSize offset, RHIIndexType indexType) + { + return _vkCmdBindIndexBuffer(((VulkanCommandBuffer*)commandBuffer)->getResource(), ((VulkanBuffer*)buffer)->getResource(), (VkDeviceSize)offset, (VkIndexType)indexType); + } + + void VulkanRHI::cmdBindDescriptorSetsPFN( + RHICommandBuffer* commandBuffer, + RHIPipelineBindPoint pipelineBindPoint, + RHIPipelineLayout* layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const RHIDescriptorSet* const* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets) + { + //descriptor_set + int descriptor_set_size = descriptorSetCount; + std::vector vk_descriptor_set_list(descriptor_set_size); + for (int i = 0; i < descriptor_set_size; ++i) + { + const auto& rhi_descriptor_set_element = pDescriptorSets[i]; + auto& vk_descriptor_set_element = vk_descriptor_set_list[i]; + + vk_descriptor_set_element = ((VulkanDescriptorSet*)rhi_descriptor_set_element)->getResource(); + }; + + //offset + int offset_size = dynamicOffsetCount; + std::vector vk_offset_list(offset_size); + for (int i = 0; i < offset_size; ++i) + { + const auto& rhi_offset_element = pDynamicOffsets[i]; + auto& vk_offset_element = vk_offset_list[i]; + + vk_offset_element = rhi_offset_element; + }; + + return _vkCmdBindDescriptorSets( + ((VulkanCommandBuffer*)commandBuffer)->getResource(), + (VkPipelineBindPoint)pipelineBindPoint, + ((VulkanPipelineLayout*)layout)->getResource(), + firstSet, descriptorSetCount, + vk_descriptor_set_list.data(), + dynamicOffsetCount, + vk_offset_list.data()); + } + + void VulkanRHI::cmdDrawIndexedPFN(RHICommandBuffer* commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) + { + return _vkCmdDrawIndexed(((VulkanCommandBuffer*)commandBuffer)->getResource(), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + } + + void VulkanRHI::cmdClearAttachmentsPFN( + RHICommandBuffer* commandBuffer, + uint32_t attachmentCount, + const RHIClearAttachment* pAttachments, + uint32_t rectCount, + const RHIClearRect* pRects) + { + //clear_attachment + int clear_attachment_size = attachmentCount; + std::vector vk_clear_attachment_list(clear_attachment_size); + for (int i = 0; i < clear_attachment_size; ++i) + { + const auto& rhi_clear_attachment_element = pAttachments[i]; + auto& vk_clear_attachment_element = vk_clear_attachment_list[i]; + + VkClearColorValue vk_clear_color_value; + vk_clear_color_value.float32[0] = rhi_clear_attachment_element.clearValue.color.float32[0]; + vk_clear_color_value.float32[1] = rhi_clear_attachment_element.clearValue.color.float32[1]; + vk_clear_color_value.float32[2] = rhi_clear_attachment_element.clearValue.color.float32[2]; + vk_clear_color_value.float32[3] = rhi_clear_attachment_element.clearValue.color.float32[3]; + vk_clear_color_value.int32[0] = rhi_clear_attachment_element.clearValue.color.int32[0]; + vk_clear_color_value.int32[1] = rhi_clear_attachment_element.clearValue.color.int32[1]; + vk_clear_color_value.int32[2] = rhi_clear_attachment_element.clearValue.color.int32[2]; + vk_clear_color_value.int32[3] = rhi_clear_attachment_element.clearValue.color.int32[3]; + vk_clear_color_value.uint32[0] = rhi_clear_attachment_element.clearValue.color.uint32[0]; + vk_clear_color_value.uint32[1] = rhi_clear_attachment_element.clearValue.color.uint32[1]; + vk_clear_color_value.uint32[2] = rhi_clear_attachment_element.clearValue.color.uint32[2]; + vk_clear_color_value.uint32[3] = rhi_clear_attachment_element.clearValue.color.uint32[3]; + + VkClearDepthStencilValue vk_clear_depth_stencil_value; + vk_clear_depth_stencil_value.depth = rhi_clear_attachment_element.clearValue.depthStencil.depth; + vk_clear_depth_stencil_value.stencil = rhi_clear_attachment_element.clearValue.depthStencil.stencil; + + vk_clear_attachment_element.clearValue.color = vk_clear_color_value; + vk_clear_attachment_element.clearValue.depthStencil = vk_clear_depth_stencil_value; + vk_clear_attachment_element.aspectMask = rhi_clear_attachment_element.aspectMask; + vk_clear_attachment_element.colorAttachment = rhi_clear_attachment_element.colorAttachment; + }; + + //clear_rect + int clear_rect_size = rectCount; + std::vector vk_clear_rect_list(clear_rect_size); + for (int i = 0; i < clear_rect_size; ++i) + { + const auto& rhi_clear_rect_element = pRects[i]; + auto& vk_clear_rect_element = vk_clear_rect_list[i]; + + VkOffset2D offset_2d{}; + offset_2d.x = rhi_clear_rect_element.rect.offset.x; + offset_2d.y = rhi_clear_rect_element.rect.offset.y; + + VkExtent2D extent_2d{}; + extent_2d.width = rhi_clear_rect_element.rect.extent.width; + extent_2d.height = rhi_clear_rect_element.rect.extent.height; + + vk_clear_rect_element.rect.offset = (VkOffset2D)offset_2d; + vk_clear_rect_element.rect.extent = (VkExtent2D)extent_2d; + vk_clear_rect_element.baseArrayLayer = rhi_clear_rect_element.baseArrayLayer; + vk_clear_rect_element.layerCount = rhi_clear_rect_element.layerCount; + }; + + return _vkCmdClearAttachments( + ((VulkanCommandBuffer*)commandBuffer)->getResource(), + attachmentCount, + vk_clear_attachment_list.data(), + rectCount, + vk_clear_rect_list.data()); + } + + bool VulkanRHI::beginCommandBuffer(RHICommandBuffer* commandBuffer, const RHICommandBufferBeginInfo* pBeginInfo) + { + VkCommandBufferInheritanceInfo command_buffer_inheritance_info{}; + const VkCommandBufferInheritanceInfo* command_buffer_inheritance_info_ptr = nullptr; + if (pBeginInfo->pInheritanceInfo != nullptr) + { + command_buffer_inheritance_info.sType = (VkStructureType)(pBeginInfo->pInheritanceInfo->sType); + command_buffer_inheritance_info.pNext = (const void*)pBeginInfo->pInheritanceInfo->pNext; + command_buffer_inheritance_info.renderPass = ((VulkanRenderPass*)pBeginInfo->pInheritanceInfo->renderPass)->getResource(); + command_buffer_inheritance_info.subpass = pBeginInfo->pInheritanceInfo->subpass; + command_buffer_inheritance_info.framebuffer = ((VulkanFramebuffer*)(pBeginInfo->pInheritanceInfo->framebuffer))->getResource(); + command_buffer_inheritance_info.occlusionQueryEnable = (VkBool32)pBeginInfo->pInheritanceInfo->occlusionQueryEnable; + command_buffer_inheritance_info.queryFlags = (VkQueryControlFlags)pBeginInfo->pInheritanceInfo->queryFlags; + command_buffer_inheritance_info.pipelineStatistics = (VkQueryPipelineStatisticFlags)pBeginInfo->pInheritanceInfo->pipelineStatistics; + + command_buffer_inheritance_info_ptr = &command_buffer_inheritance_info; + } + + VkCommandBufferBeginInfo command_buffer_begin_info{}; + command_buffer_begin_info.sType = (VkStructureType)pBeginInfo->sType; + command_buffer_begin_info.pNext = (const void*)pBeginInfo->pNext; + command_buffer_begin_info.flags = (VkCommandBufferUsageFlags)pBeginInfo->flags; + command_buffer_begin_info.pInheritanceInfo = command_buffer_inheritance_info_ptr; + + VkResult result = vkBeginCommandBuffer(((VulkanCommandBuffer*)commandBuffer)->getResource(), &command_buffer_begin_info); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("vkBeginCommandBuffer failed!"); + return false; + } + } + + bool VulkanRHI::endCommandBuffer(RHICommandBuffer* commandBuffer) + { + VkResult result = vkEndCommandBuffer(((VulkanCommandBuffer*)commandBuffer)->getResource()); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("vkEndCommandBuffer failed!"); + return false; + } + } + + void VulkanRHI::updateDescriptorSets( + uint32_t descriptorWriteCount, + const RHIWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const RHICopyDescriptorSet* pDescriptorCopies) + { + //write_descriptor_set + int write_descriptor_set_size = descriptorWriteCount; + std::vector vk_write_descriptor_set_list(write_descriptor_set_size); + int image_info_count = 0; + int buffer_info_count = 0; + for (int i = 0; i < write_descriptor_set_size; ++i) + { + const auto& rhi_write_descriptor_set_element = pDescriptorWrites[i]; + if (rhi_write_descriptor_set_element.pImageInfo != nullptr) + { + image_info_count++; + } + if (rhi_write_descriptor_set_element.pBufferInfo != nullptr) + { + buffer_info_count++; + } + } + std::vector vk_descriptor_image_info_list(image_info_count); + std::vector vk_descriptor_buffer_info_list(buffer_info_count); + int image_info_current = 0; + int buffer_info_current = 0; + + for (int i = 0; i < write_descriptor_set_size; ++i) + { + const auto& rhi_write_descriptor_set_element = pDescriptorWrites[i]; + auto& vk_write_descriptor_set_element = vk_write_descriptor_set_list[i]; + + const VkDescriptorImageInfo* vk_descriptor_image_info_ptr = nullptr; + if (rhi_write_descriptor_set_element.pImageInfo != nullptr) + { + auto& vk_descriptor_image_info = vk_descriptor_image_info_list[image_info_current]; + if (rhi_write_descriptor_set_element.pImageInfo->sampler == nullptr) + { + vk_descriptor_image_info.sampler = nullptr; + } + else + { + vk_descriptor_image_info.sampler = ((VulkanSampler*)rhi_write_descriptor_set_element.pImageInfo->sampler)->getResource(); + } + vk_descriptor_image_info.imageView = ((VulkanImageView*)rhi_write_descriptor_set_element.pImageInfo->imageView)->getResource(); + vk_descriptor_image_info.imageLayout = (VkImageLayout)rhi_write_descriptor_set_element.pImageInfo->imageLayout; + + vk_descriptor_image_info_ptr = &vk_descriptor_image_info; + image_info_current++; + } + + const VkDescriptorBufferInfo* vk_descriptor_buffer_info_ptr = nullptr; + if (rhi_write_descriptor_set_element.pBufferInfo != nullptr) + { + auto& vk_descriptor_buffer_info = vk_descriptor_buffer_info_list[buffer_info_current]; + vk_descriptor_buffer_info.buffer = ((VulkanBuffer*)rhi_write_descriptor_set_element.pBufferInfo->buffer)->getResource(); + vk_descriptor_buffer_info.offset = (VkDeviceSize)rhi_write_descriptor_set_element.pBufferInfo->offset; + vk_descriptor_buffer_info.range = (VkDeviceSize)rhi_write_descriptor_set_element.pBufferInfo->range; + + vk_descriptor_buffer_info_ptr = &vk_descriptor_buffer_info; + buffer_info_current++; + } + + vk_write_descriptor_set_element.sType = (VkStructureType)rhi_write_descriptor_set_element.sType; + vk_write_descriptor_set_element.pNext = (const void*)rhi_write_descriptor_set_element.pNext; + vk_write_descriptor_set_element.dstSet = ((VulkanDescriptorSet*)rhi_write_descriptor_set_element.dstSet)->getResource(); + vk_write_descriptor_set_element.dstBinding = rhi_write_descriptor_set_element.dstBinding; + vk_write_descriptor_set_element.dstArrayElement = rhi_write_descriptor_set_element.dstArrayElement; + vk_write_descriptor_set_element.descriptorCount = rhi_write_descriptor_set_element.descriptorCount; + vk_write_descriptor_set_element.descriptorType = (VkDescriptorType)rhi_write_descriptor_set_element.descriptorType; + vk_write_descriptor_set_element.pImageInfo = vk_descriptor_image_info_ptr; + vk_write_descriptor_set_element.pBufferInfo = vk_descriptor_buffer_info_ptr; + //vk_write_descriptor_set_element.pTexelBufferView = &((VulkanBufferView*)rhi_write_descriptor_set_element.pTexelBufferView)->getResource(); + }; + + if (image_info_current != image_info_count + || buffer_info_current != buffer_info_count) + { + LOG_ERROR("image_info_current != image_info_count || buffer_info_current != buffer_info_count"); + return; + } + + //copy_descriptor_set + int copy_descriptor_set_size = descriptorCopyCount; + std::vector vk_copy_descriptor_set_list(copy_descriptor_set_size); + for (int i = 0; i < copy_descriptor_set_size; ++i) + { + const auto& rhi_copy_descriptor_set_element = pDescriptorCopies[i]; + auto& vk_copy_descriptor_set_element = vk_copy_descriptor_set_list[i]; + + vk_copy_descriptor_set_element.sType = (VkStructureType)rhi_copy_descriptor_set_element.sType; + vk_copy_descriptor_set_element.pNext = (const void*)rhi_copy_descriptor_set_element.pNext; + vk_copy_descriptor_set_element.srcSet = ((VulkanDescriptorSet*)rhi_copy_descriptor_set_element.srcSet)->getResource(); + vk_copy_descriptor_set_element.srcBinding = rhi_copy_descriptor_set_element.srcBinding; + vk_copy_descriptor_set_element.srcArrayElement = rhi_copy_descriptor_set_element.srcArrayElement; + vk_copy_descriptor_set_element.dstSet = ((VulkanDescriptorSet*)rhi_copy_descriptor_set_element.dstSet)->getResource(); + vk_copy_descriptor_set_element.dstBinding = rhi_copy_descriptor_set_element.dstBinding; + vk_copy_descriptor_set_element.dstArrayElement = rhi_copy_descriptor_set_element.dstArrayElement; + vk_copy_descriptor_set_element.descriptorCount = rhi_copy_descriptor_set_element.descriptorCount; + }; + + vkUpdateDescriptorSets(m_device, descriptorWriteCount, vk_write_descriptor_set_list.data(), descriptorCopyCount, vk_copy_descriptor_set_list.data()); + } + + bool VulkanRHI::queueSubmit(RHIQueue* queue, uint32_t submitCount, const RHISubmitInfo* pSubmits, RHIFence* fence) + { + //submit_info + int command_buffer_size_total = 0; + int semaphore_size_total = 0; + int signal_semaphore_size_total = 0; + int pipeline_stage_flags_size_total = 0; + + int submit_info_size = submitCount; + for (int i = 0; i < submit_info_size; ++i) + { + const auto& rhi_submit_info_element = pSubmits[i]; + command_buffer_size_total += rhi_submit_info_element.commandBufferCount; + semaphore_size_total += rhi_submit_info_element.waitSemaphoreCount; + signal_semaphore_size_total += rhi_submit_info_element.signalSemaphoreCount; + pipeline_stage_flags_size_total += rhi_submit_info_element.waitSemaphoreCount; + } + std::vector vk_command_buffer_list_external(command_buffer_size_total); + std::vector vk_semaphore_list_external(semaphore_size_total); + std::vector vk_signal_semaphore_list_external(signal_semaphore_size_total); + std::vector vk_pipeline_stage_flags_list_external(pipeline_stage_flags_size_total); + + int command_buffer_size_current = 0; + int semaphore_size_current = 0; + int signal_semaphore_size_current = 0; + int pipeline_stage_flags_size_current = 0; + + + std::vector vk_submit_info_list(submit_info_size); + for (int i = 0; i < submit_info_size; ++i) + { + const auto& rhi_submit_info_element = pSubmits[i]; + auto& vk_submit_info_element = vk_submit_info_list[i]; + + vk_submit_info_element.sType = (VkStructureType)rhi_submit_info_element.sType; + vk_submit_info_element.pNext = (const void*)rhi_submit_info_element.pNext; + + //command_buffer + if (rhi_submit_info_element.commandBufferCount > 0) + { + vk_submit_info_element.commandBufferCount = rhi_submit_info_element.commandBufferCount; + vk_submit_info_element.pCommandBuffers = &vk_command_buffer_list_external[command_buffer_size_current]; + int command_buffer_size = rhi_submit_info_element.commandBufferCount; + for (int i = 0; i < command_buffer_size; ++i) + { + const auto& rhi_command_buffer_element = rhi_submit_info_element.pCommandBuffers[i]; + auto& vk_command_buffer_element = vk_command_buffer_list_external[command_buffer_size_current]; + + vk_command_buffer_element = ((VulkanCommandBuffer*)rhi_command_buffer_element)->getResource(); + + command_buffer_size_current++; + }; + } + + //semaphore + if (rhi_submit_info_element.waitSemaphoreCount > 0) + { + vk_submit_info_element.waitSemaphoreCount = rhi_submit_info_element.waitSemaphoreCount; + vk_submit_info_element.pWaitSemaphores = &vk_semaphore_list_external[semaphore_size_current]; + int semaphore_size = rhi_submit_info_element.waitSemaphoreCount; + for (int i = 0; i < semaphore_size; ++i) + { + const auto& rhi_semaphore_element = rhi_submit_info_element.pWaitSemaphores[i]; + auto& vk_semaphore_element = vk_semaphore_list_external[semaphore_size_current]; + + vk_semaphore_element = ((VulkanSemaphore*)rhi_semaphore_element)->getResource(); + + semaphore_size_current++; + }; + } + + //signal_semaphore + if (rhi_submit_info_element.signalSemaphoreCount > 0) + { + vk_submit_info_element.signalSemaphoreCount = rhi_submit_info_element.signalSemaphoreCount; + vk_submit_info_element.pSignalSemaphores = &vk_signal_semaphore_list_external[signal_semaphore_size_current]; + int signal_semaphore_size = rhi_submit_info_element.signalSemaphoreCount; + for (int i = 0; i < signal_semaphore_size; ++i) + { + const auto& rhi_signal_semaphore_element = rhi_submit_info_element.pSignalSemaphores[i]; + auto& vk_signal_semaphore_element = vk_signal_semaphore_list_external[signal_semaphore_size_current]; + + vk_signal_semaphore_element = ((VulkanSemaphore*)rhi_signal_semaphore_element)->getResource(); + + signal_semaphore_size_current++; + }; + } + + //pipeline_stage_flags + if (rhi_submit_info_element.waitSemaphoreCount > 0) + { + vk_submit_info_element.pWaitDstStageMask = &vk_pipeline_stage_flags_list_external[pipeline_stage_flags_size_current]; + int pipeline_stage_flags_size = rhi_submit_info_element.waitSemaphoreCount; + for (int i = 0; i < pipeline_stage_flags_size; ++i) + { + const auto& rhi_pipeline_stage_flags_element = rhi_submit_info_element.pWaitDstStageMask[i]; + auto& vk_pipeline_stage_flags_element = vk_pipeline_stage_flags_list_external[pipeline_stage_flags_size_current]; + + vk_pipeline_stage_flags_element = (VkPipelineStageFlags)rhi_pipeline_stage_flags_element; + + pipeline_stage_flags_size_current++; + }; + } + }; + + + if ((command_buffer_size_total != command_buffer_size_current) + || (semaphore_size_total != semaphore_size_current) + || (signal_semaphore_size_total != signal_semaphore_size_current) + || (pipeline_stage_flags_size_total != pipeline_stage_flags_size_current)) + { + LOG_ERROR("submit info is not right!"); + return false; + } + + VkFence vk_fence = VK_NULL_HANDLE; + if (fence != nullptr) + { + vk_fence = ((VulkanFence*)fence)->getResource(); + } + + VkResult result = vkQueueSubmit(((VulkanQueue*)queue)->getResource(), submitCount, vk_submit_info_list.data(), vk_fence); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("vkQueueSubmit failed!"); + return false; + } + } + + bool VulkanRHI::queueWaitIdle(RHIQueue* queue) + { + VkResult result = vkQueueWaitIdle(((VulkanQueue*)queue)->getResource()); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("vkQueueWaitIdle failed!"); + return false; + } + } + + void VulkanRHI::cmdPipelineBarrier(RHICommandBuffer* commandBuffer, + RHIPipelineStageFlags srcStageMask, + RHIPipelineStageFlags dstStageMask, + RHIDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const RHIMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const RHIBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const RHIImageMemoryBarrier* pImageMemoryBarriers) + { + + //memory_barrier + int memory_barrier_size = memoryBarrierCount; + std::vector vk_memory_barrier_list(memory_barrier_size); + for (int i = 0; i < memory_barrier_size; ++i) + { + const auto& rhi_memory_barrier_element = pMemoryBarriers[i]; + auto& vk_memory_barrier_element = vk_memory_barrier_list[i]; + + + vk_memory_barrier_element.sType = (VkStructureType)rhi_memory_barrier_element.sType; + vk_memory_barrier_element.pNext = (const void*)rhi_memory_barrier_element.pNext; + vk_memory_barrier_element.srcAccessMask = (VkAccessFlags)rhi_memory_barrier_element.srcAccessMask; + vk_memory_barrier_element.dstAccessMask = (VkAccessFlags)rhi_memory_barrier_element.dstAccessMask; + }; + + //buffer_memory_barrier + int buffer_memory_barrier_size = bufferMemoryBarrierCount; + std::vector vk_buffer_memory_barrier_list(buffer_memory_barrier_size); + for (int i = 0; i < buffer_memory_barrier_size; ++i) + { + const auto& rhi_buffer_memory_barrier_element = pBufferMemoryBarriers[i]; + auto& vk_buffer_memory_barrier_element = vk_buffer_memory_barrier_list[i]; + + vk_buffer_memory_barrier_element.sType = (VkStructureType)rhi_buffer_memory_barrier_element.sType; + vk_buffer_memory_barrier_element.pNext = (const void*)rhi_buffer_memory_barrier_element.pNext; + vk_buffer_memory_barrier_element.srcAccessMask = (VkAccessFlags)rhi_buffer_memory_barrier_element.srcAccessMask; + vk_buffer_memory_barrier_element.dstAccessMask = (VkAccessFlags)rhi_buffer_memory_barrier_element.dstAccessMask; + vk_buffer_memory_barrier_element.srcQueueFamilyIndex = rhi_buffer_memory_barrier_element.srcQueueFamilyIndex; + vk_buffer_memory_barrier_element.dstQueueFamilyIndex = rhi_buffer_memory_barrier_element.dstQueueFamilyIndex; + vk_buffer_memory_barrier_element.buffer = ((VulkanBuffer*)rhi_buffer_memory_barrier_element.buffer)->getResource(); + vk_buffer_memory_barrier_element.offset = (VkDeviceSize)rhi_buffer_memory_barrier_element.offset; + vk_buffer_memory_barrier_element.size = (VkDeviceSize)rhi_buffer_memory_barrier_element.size; + }; + + //image_memory_barrier + int image_memory_barrier_size = imageMemoryBarrierCount; + std::vector vk_image_memory_barrier_list(image_memory_barrier_size); + for (int i = 0; i < image_memory_barrier_size; ++i) + { + const auto& rhi_image_memory_barrier_element = pImageMemoryBarriers[i]; + auto& vk_image_memory_barrier_element = vk_image_memory_barrier_list[i]; + + VkImageSubresourceRange image_subresource_range{}; + image_subresource_range.aspectMask = (VkImageAspectFlags)rhi_image_memory_barrier_element.subresourceRange.aspectMask; + image_subresource_range.baseMipLevel = rhi_image_memory_barrier_element.subresourceRange.baseMipLevel; + image_subresource_range.levelCount = rhi_image_memory_barrier_element.subresourceRange.levelCount; + image_subresource_range.baseArrayLayer = rhi_image_memory_barrier_element.subresourceRange.baseArrayLayer; + image_subresource_range.layerCount = rhi_image_memory_barrier_element.subresourceRange.layerCount; + + vk_image_memory_barrier_element.sType = (VkStructureType)rhi_image_memory_barrier_element.sType; + vk_image_memory_barrier_element.pNext = (const void*)rhi_image_memory_barrier_element.pNext; + vk_image_memory_barrier_element.srcAccessMask = (VkAccessFlags)rhi_image_memory_barrier_element.srcAccessMask; + vk_image_memory_barrier_element.dstAccessMask = (VkAccessFlags)rhi_image_memory_barrier_element.dstAccessMask; + vk_image_memory_barrier_element.oldLayout = (VkImageLayout)rhi_image_memory_barrier_element.oldLayout; + vk_image_memory_barrier_element.newLayout = (VkImageLayout)rhi_image_memory_barrier_element.newLayout; + vk_image_memory_barrier_element.srcQueueFamilyIndex = rhi_image_memory_barrier_element.srcQueueFamilyIndex; + vk_image_memory_barrier_element.dstQueueFamilyIndex = rhi_image_memory_barrier_element.dstQueueFamilyIndex; + vk_image_memory_barrier_element.image = ((VulkanImage*)rhi_image_memory_barrier_element.image)->getResource(); + vk_image_memory_barrier_element.subresourceRange = image_subresource_range; + }; + + vkCmdPipelineBarrier( + ((VulkanCommandBuffer*)commandBuffer)->getResource(), + (RHIPipelineStageFlags)srcStageMask, + (RHIPipelineStageFlags)dstStageMask, + (RHIDependencyFlags)dependencyFlags, + memoryBarrierCount, + vk_memory_barrier_list.data(), + bufferMemoryBarrierCount, + vk_buffer_memory_barrier_list.data(), + imageMemoryBarrierCount, + vk_image_memory_barrier_list.data()); + } + + void VulkanRHI::cmdDraw(RHICommandBuffer* commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) + { + vkCmdDraw(((VulkanCommandBuffer*)commandBuffer)->getResource(), vertexCount, instanceCount, firstVertex, firstInstance); + } + + void VulkanRHI::cmdDispatch(RHICommandBuffer* commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) + { + vkCmdDispatch(((VulkanCommandBuffer*)commandBuffer)->getResource(), groupCountX, groupCountY, groupCountZ); + } + + void VulkanRHI::cmdDispatchIndirect(RHICommandBuffer* commandBuffer, RHIBuffer* buffer, RHIDeviceSize offset) + { + vkCmdDispatchIndirect(((VulkanCommandBuffer*)commandBuffer)->getResource(), ((VulkanBuffer*)buffer)->getResource(), offset); + } + + void VulkanRHI::cmdCopyImageToBuffer( + RHICommandBuffer* commandBuffer, + RHIImage* srcImage, + RHIImageLayout srcImageLayout, + RHIBuffer* dstBuffer, + uint32_t regionCount, + const RHIBufferImageCopy* pRegions) + { + //buffer_image_copy + int buffer_image_copy_size = regionCount; + std::vector vk_buffer_image_copy_list(buffer_image_copy_size); + for (int i = 0; i < buffer_image_copy_size; ++i) + { + const auto& rhi_buffer_image_copy_element = pRegions[i]; + auto& vk_buffer_image_copy_element = vk_buffer_image_copy_list[i]; + + VkImageSubresourceLayers image_subresource_layers{}; + image_subresource_layers.aspectMask = (VkImageAspectFlags)rhi_buffer_image_copy_element.imageSubresource.aspectMask; + image_subresource_layers.mipLevel = rhi_buffer_image_copy_element.imageSubresource.mipLevel; + image_subresource_layers.baseArrayLayer = rhi_buffer_image_copy_element.imageSubresource.baseArrayLayer; + image_subresource_layers.layerCount = rhi_buffer_image_copy_element.imageSubresource.layerCount; + + VkOffset3D offset_3d{}; + offset_3d.x = rhi_buffer_image_copy_element.imageOffset.x; + offset_3d.y = rhi_buffer_image_copy_element.imageOffset.y; + offset_3d.z = rhi_buffer_image_copy_element.imageOffset.z; + + VkExtent3D extent_3d{}; + extent_3d.width = rhi_buffer_image_copy_element.imageExtent.width; + extent_3d.height = rhi_buffer_image_copy_element.imageExtent.height; + extent_3d.depth = rhi_buffer_image_copy_element.imageExtent.depth; + + VkBufferImageCopy buffer_image_copy{}; + buffer_image_copy.bufferOffset = (VkDeviceSize)rhi_buffer_image_copy_element.bufferOffset; + buffer_image_copy.bufferRowLength = rhi_buffer_image_copy_element.bufferRowLength; + buffer_image_copy.bufferImageHeight = rhi_buffer_image_copy_element.bufferImageHeight; + buffer_image_copy.imageSubresource = image_subresource_layers; + buffer_image_copy.imageOffset = offset_3d; + buffer_image_copy.imageExtent = extent_3d; + + vk_buffer_image_copy_element.bufferOffset = (VkDeviceSize)rhi_buffer_image_copy_element.bufferOffset; + vk_buffer_image_copy_element.bufferRowLength = rhi_buffer_image_copy_element.bufferRowLength; + vk_buffer_image_copy_element.bufferImageHeight = rhi_buffer_image_copy_element.bufferImageHeight; + vk_buffer_image_copy_element.imageSubresource = image_subresource_layers; + vk_buffer_image_copy_element.imageOffset = offset_3d; + vk_buffer_image_copy_element.imageExtent = extent_3d; + }; + + vkCmdCopyImageToBuffer( + ((VulkanCommandBuffer*)commandBuffer)->getResource(), + ((VulkanImage*)srcImage)->getResource(), + (VkImageLayout)srcImageLayout, + ((VulkanBuffer*)dstBuffer)->getResource(), + regionCount, + vk_buffer_image_copy_list.data()); + } + + void VulkanRHI::cmdCopyImageToImage(RHICommandBuffer* commandBuffer, RHIImage* srcImage, RHIImageAspectFlagBits srcFlag, RHIImage* dstImage, RHIImageAspectFlagBits dstFlag, uint32_t width, uint32_t height) + { + VkImageCopy imagecopyRegion = {}; + imagecopyRegion.srcSubresource = { (VkImageAspectFlags)srcFlag, 0, 0, 1 }; + imagecopyRegion.srcOffset = { 0, 0, 0 }; + imagecopyRegion.dstSubresource = { (VkImageAspectFlags)dstFlag, 0, 0, 1 }; + imagecopyRegion.dstOffset = { 0, 0, 0 }; + imagecopyRegion.extent = { width, height, 1 }; + + vkCmdCopyImage(((VulkanCommandBuffer*)commandBuffer)->getResource(), + ((VulkanImage*)srcImage)->getResource(), + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + ((VulkanImage*)dstImage)->getResource(), + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + 1, + &imagecopyRegion); + } + + void VulkanRHI::cmdCopyBuffer(RHICommandBuffer* commandBuffer, RHIBuffer* srcBuffer, RHIBuffer* dstBuffer, uint32_t regionCount, RHIBufferCopy* pRegions) + { + VkBufferCopy copyRegion{}; + copyRegion.srcOffset = pRegions->srcOffset; + copyRegion.dstOffset = pRegions->dstOffset; + copyRegion.size = pRegions->size; + + vkCmdCopyBuffer(((VulkanCommandBuffer*)commandBuffer)->getResource(), + ((VulkanBuffer*)srcBuffer)->getResource(), + ((VulkanBuffer*)dstBuffer)->getResource(), + regionCount, + ©Region); + } + + void VulkanRHI::createCommandBuffers() + { + VkCommandBufferAllocateInfo command_buffer_allocate_info {}; + command_buffer_allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + command_buffer_allocate_info.commandBufferCount = 1U; + + for (uint32_t i = 0; i < k_max_frames_in_flight; ++i) + { + command_buffer_allocate_info.commandPool = m_command_pools[i]; + VkCommandBuffer vk_command_buffer; + if (vkAllocateCommandBuffers(m_device, &command_buffer_allocate_info, &vk_command_buffer) != VK_SUCCESS) + { + LOG_ERROR("vk allocate command buffers"); + } + m_vk_command_buffers[i] = vk_command_buffer; + m_command_buffers[i] = new VulkanCommandBuffer(); + ((VulkanCommandBuffer*)m_command_buffers[i])->setResource(vk_command_buffer); + } + } + + void VulkanRHI::createDescriptorPool() + { + // Since DescriptorSet should be treated as asset in Vulkan, DescriptorPool + // should be big enough, and thus we can sub-allocate DescriptorSet from + // DescriptorPool merely as we sub-allocate Buffer/Image from DeviceMemory. + + VkDescriptorPoolSize pool_sizes[7]; + pool_sizes[0].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + pool_sizes[0].descriptorCount = 3 + 2 + 2 + 2 + 1 + 1 + 3 + 3; + pool_sizes[1].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + pool_sizes[1].descriptorCount = 1 + 1 + 1 * m_max_vertex_blending_mesh_count; + pool_sizes[2].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + pool_sizes[2].descriptorCount = 1 * m_max_material_count; + pool_sizes[3].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + pool_sizes[3].descriptorCount = 3 + 5 * m_max_material_count + 1 + 1; // ImGui_ImplVulkan_CreateDeviceObjects + pool_sizes[4].type = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + pool_sizes[4].descriptorCount = 4 + 1 + 1 + 2; + pool_sizes[5].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; + pool_sizes[5].descriptorCount = 3; + pool_sizes[6].type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; + pool_sizes[6].descriptorCount = 1; + + VkDescriptorPoolCreateInfo pool_info {}; + pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + pool_info.poolSizeCount = sizeof(pool_sizes) / sizeof(pool_sizes[0]); + pool_info.pPoolSizes = pool_sizes; + pool_info.maxSets = + 1 + 1 + 1 + m_max_material_count + m_max_vertex_blending_mesh_count + 1 + 1; // +skybox + axis descriptor set + pool_info.flags = 0U; + + if (vkCreateDescriptorPool(m_device, &pool_info, nullptr, &m_vk_descriptor_pool) != VK_SUCCESS) + { + LOG_ERROR("create descriptor pool"); + } + + m_descriptor_pool = new VulkanDescriptorPool(); + ((VulkanDescriptorPool*)m_descriptor_pool)->setResource(m_vk_descriptor_pool); + } + + // semaphore : signal an image is ready for rendering // ready for presentation + // (m_vulkan_context._swapchain_images --> semaphores, fences) + void VulkanRHI::createSyncPrimitives() + { + VkSemaphoreCreateInfo semaphore_create_info {}; + semaphore_create_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + + VkFenceCreateInfo fence_create_info {}; + fence_create_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + fence_create_info.flags = VK_FENCE_CREATE_SIGNALED_BIT; // the fence is initialized as signaled + + for (uint32_t i = 0; i < k_max_frames_in_flight; i++) + { + m_image_available_for_texturescopy_semaphores[i] = new VulkanSemaphore(); + if (vkCreateSemaphore( + m_device, &semaphore_create_info, nullptr, &m_image_available_for_render_semaphores[i]) != + VK_SUCCESS || + vkCreateSemaphore( + m_device, &semaphore_create_info, nullptr, &m_image_finished_for_presentation_semaphores[i]) != + VK_SUCCESS || + vkCreateSemaphore( + m_device, &semaphore_create_info, nullptr, &(((VulkanSemaphore*)m_image_available_for_texturescopy_semaphores[i])->getResource())) != + VK_SUCCESS || + vkCreateFence(m_device, &fence_create_info, nullptr, &m_is_frame_in_flight_fences[i]) != VK_SUCCESS) + { + LOG_ERROR("vk create semaphore & fence"); + } + + m_rhi_is_frame_in_flight_fences[i] = new VulkanFence(); + ((VulkanFence*)m_rhi_is_frame_in_flight_fences[i])->setResource(m_is_frame_in_flight_fences[i]); + } + } + + void VulkanRHI::createFramebufferImageAndView() + { + VulkanUtil::createImage(m_physical_device, + m_device, + m_swapchain_extent.width, + m_swapchain_extent.height, + (VkFormat)m_depth_image_format, + VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | + VK_IMAGE_USAGE_TRANSFER_SRC_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + ((VulkanImage*)m_depth_image)->getResource(), + m_depth_image_memory, + 0, + 1, + 1); + + ((VulkanImageView*)m_depth_image_view)->setResource( + VulkanUtil::createImageView(m_device, ((VulkanImage*)m_depth_image)->getResource(), (VkFormat)m_depth_image_format, VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_VIEW_TYPE_2D, 1, 1)); + } + + RHISampler* VulkanRHI::getOrCreateDefaultSampler(RHIDefaultSamplerType type) + { + switch (type) + { + case Piccolo::Default_Sampler_Linear: + if (m_linear_sampler == nullptr) + { + m_linear_sampler = new VulkanSampler(); + ((VulkanSampler*)m_linear_sampler)->setResource(VulkanUtil::getOrCreateLinearSampler(m_physical_device, m_device)); + } + return m_linear_sampler; + break; + + case Piccolo::Default_Sampler_Nearest: + if (m_nearest_sampler == nullptr) + { + m_nearest_sampler = new VulkanSampler(); + ((VulkanSampler*)m_nearest_sampler)->setResource(VulkanUtil::getOrCreateNearestSampler(m_physical_device, m_device)); + } + return m_nearest_sampler; + break; + + default: + return nullptr; + break; + } + } + + RHISampler* VulkanRHI::getOrCreateMipmapSampler(uint32_t width, uint32_t height) + { + if (width == 0 || height == 0) + { + LOG_ERROR("width == 0 || height == 0"); + return nullptr; + } + RHISampler* sampler; + uint32_t mip_levels = floor(log2(std::max(width, height))) + 1; + auto find_sampler = m_mipmap_sampler_map.find(mip_levels); + if (find_sampler != m_mipmap_sampler_map.end()) + { + return find_sampler->second; + } + else + { + sampler = new VulkanSampler(); + + VkSampler vk_sampler = VulkanUtil::getOrCreateMipmapSampler(m_physical_device, m_device, width, height); + + ((VulkanSampler*)sampler)->setResource(vk_sampler); + + m_mipmap_sampler_map.insert(std::make_pair(mip_levels, sampler)); + + return sampler; + } + } + + RHIShader* VulkanRHI::createShaderModule(const std::vector& shader_code) + { + RHIShader* shahder = new VulkanShader(); + + VkShaderModule vk_shader = VulkanUtil::createShaderModule(m_device, shader_code); + + ((VulkanShader*)shahder)->setResource(vk_shader); + + return shahder; + } + + void VulkanRHI::createBuffer(RHIDeviceSize size, RHIBufferUsageFlags usage, RHIMemoryPropertyFlags properties, RHIBuffer* & buffer, RHIDeviceMemory* & buffer_memory) + { + VkBuffer vk_buffer; + VkDeviceMemory vk_device_memory; + + VulkanUtil::createBuffer(m_physical_device, m_device, size, usage, properties, vk_buffer, vk_device_memory); + + buffer = new VulkanBuffer(); + buffer_memory = new VulkanDeviceMemory(); + ((VulkanBuffer*)buffer)->setResource(vk_buffer); + ((VulkanDeviceMemory*)buffer_memory)->setResource(vk_device_memory); + } + + void VulkanRHI::createBufferAndInitialize(RHIBufferUsageFlags usage, RHIMemoryPropertyFlags properties, RHIBuffer*& buffer, RHIDeviceMemory*& buffer_memory, RHIDeviceSize size, void* data, int datasize) + { + VkBuffer vk_buffer; + VkDeviceMemory vk_device_memory; + + VulkanUtil::createBufferAndInitialize(m_device, m_physical_device, usage, properties, &vk_buffer, &vk_device_memory, size, data, datasize); + + buffer = new VulkanBuffer(); + buffer_memory = new VulkanDeviceMemory(); + ((VulkanBuffer*)buffer)->setResource(vk_buffer); + ((VulkanDeviceMemory*)buffer_memory)->setResource(vk_device_memory); + } + + bool VulkanRHI::createBufferVMA(VmaAllocator allocator, const RHIBufferCreateInfo* pBufferCreateInfo, const VmaAllocationCreateInfo* pAllocationCreateInfo, RHIBuffer* & pBuffer, VmaAllocation* pAllocation, VmaAllocationInfo* pAllocationInfo) + { + VkBuffer vk_buffer; + VkBufferCreateInfo buffer_create_info{}; + buffer_create_info.sType = (VkStructureType)pBufferCreateInfo->sType; + buffer_create_info.pNext = (const void*)pBufferCreateInfo->pNext; + buffer_create_info.flags = (VkBufferCreateFlags)pBufferCreateInfo->flags; + buffer_create_info.size = (VkDeviceSize)pBufferCreateInfo->size; + buffer_create_info.usage = (VkBufferUsageFlags)pBufferCreateInfo->usage; + buffer_create_info.sharingMode = (VkSharingMode)pBufferCreateInfo->sharingMode; + buffer_create_info.queueFamilyIndexCount = pBufferCreateInfo->queueFamilyIndexCount; + buffer_create_info.pQueueFamilyIndices = (const uint32_t*)pBufferCreateInfo->pQueueFamilyIndices; + + pBuffer = new VulkanBuffer(); + VkResult result = vmaCreateBuffer(allocator, + &buffer_create_info, + pAllocationCreateInfo, + &vk_buffer, + pAllocation, + pAllocationInfo); + + ((VulkanBuffer*)pBuffer)->setResource(vk_buffer); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + return false; + } + } + + bool VulkanRHI::createBufferWithAlignmentVMA(VmaAllocator allocator, const RHIBufferCreateInfo* pBufferCreateInfo, const VmaAllocationCreateInfo* pAllocationCreateInfo, RHIDeviceSize minAlignment, RHIBuffer* &pBuffer, VmaAllocation* pAllocation, VmaAllocationInfo* pAllocationInfo) + { + VkBuffer vk_buffer; + VkBufferCreateInfo buffer_create_info{}; + buffer_create_info.sType = (VkStructureType)pBufferCreateInfo->sType; + buffer_create_info.pNext = (const void*)pBufferCreateInfo->pNext; + buffer_create_info.flags = (VkBufferCreateFlags)pBufferCreateInfo->flags; + buffer_create_info.size = (VkDeviceSize)pBufferCreateInfo->size; + buffer_create_info.usage = (VkBufferUsageFlags)pBufferCreateInfo->usage; + buffer_create_info.sharingMode = (VkSharingMode)pBufferCreateInfo->sharingMode; + buffer_create_info.queueFamilyIndexCount = pBufferCreateInfo->queueFamilyIndexCount; + buffer_create_info.pQueueFamilyIndices = (const uint32_t*)pBufferCreateInfo->pQueueFamilyIndices; + + pBuffer = new VulkanBuffer(); + VkResult result = vmaCreateBufferWithAlignment(allocator, + &buffer_create_info, + pAllocationCreateInfo, + minAlignment, + &vk_buffer, + pAllocation, + pAllocationInfo); + + ((VulkanBuffer*)pBuffer)->setResource(vk_buffer); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("vmaCreateBufferWithAlignment failed!"); + return false; + } + } + + + void VulkanRHI::copyBuffer(RHIBuffer* srcBuffer, RHIBuffer* dstBuffer, RHIDeviceSize srcOffset, RHIDeviceSize dstOffset, RHIDeviceSize size) + { + VkBuffer vk_src_buffer = ((VulkanBuffer*)srcBuffer)->getResource(); + VkBuffer vk_dst_buffer = ((VulkanBuffer*)dstBuffer)->getResource(); + VulkanUtil::copyBuffer(this, vk_src_buffer, vk_dst_buffer, srcOffset, dstOffset, size); + } + + void VulkanRHI::createImage(uint32_t image_width, uint32_t image_height, RHIFormat format, RHIImageTiling image_tiling, RHIImageUsageFlags image_usage_flags, RHIMemoryPropertyFlags memory_property_flags, + RHIImage* &image, RHIDeviceMemory* &memory, RHIImageCreateFlags image_create_flags, uint32_t array_layers, uint32_t miplevels) + { + VkImage vk_image; + VkDeviceMemory vk_device_memory; + VulkanUtil::createImage( + m_physical_device, + m_device, + image_width, + image_height, + (VkFormat)format, + (VkImageTiling)image_tiling, + (VkImageUsageFlags)image_usage_flags, + (VkMemoryPropertyFlags)memory_property_flags, + vk_image, + vk_device_memory, + (VkImageCreateFlags)image_create_flags, + array_layers, + miplevels); + + image = new VulkanImage(); + memory = new VulkanDeviceMemory(); + ((VulkanImage*)image)->setResource(vk_image); + ((VulkanDeviceMemory*)memory)->setResource(vk_device_memory); + } + + void VulkanRHI::createImageView(RHIImage* image, RHIFormat format, RHIImageAspectFlags image_aspect_flags, RHIImageViewType view_type, uint32_t layout_count, uint32_t miplevels, + RHIImageView* &image_view) + { + image_view = new VulkanImageView(); + VkImage vk_image = ((VulkanImage*)image)->getResource(); + VkImageView vk_image_view; + vk_image_view = VulkanUtil::createImageView(m_device, vk_image, (VkFormat)format, image_aspect_flags, (VkImageViewType)view_type, layout_count, miplevels); + ((VulkanImageView*)image_view)->setResource(vk_image_view); + } + + void VulkanRHI::createGlobalImage(RHIImage* &image, RHIImageView* &image_view, VmaAllocation& image_allocation, uint32_t texture_image_width, uint32_t texture_image_height, void* texture_image_pixels, RHIFormat texture_image_format, uint32_t miplevels) + { + VkImage vk_image; + VkImageView vk_image_view; + + VulkanUtil::createGlobalImage(this, vk_image, vk_image_view,image_allocation,texture_image_width,texture_image_height,texture_image_pixels,texture_image_format,miplevels); + + image = new VulkanImage(); + image_view = new VulkanImageView(); + ((VulkanImage*)image)->setResource(vk_image); + ((VulkanImageView*)image_view)->setResource(vk_image_view); + } + + void VulkanRHI::createCubeMap(RHIImage* &image, RHIImageView* &image_view, VmaAllocation& image_allocation, uint32_t texture_image_width, uint32_t texture_image_height, std::array texture_image_pixels, RHIFormat texture_image_format, uint32_t miplevels) + { + VkImage vk_image; + VkImageView vk_image_view; + + VulkanUtil::createCubeMap(this, vk_image, vk_image_view, image_allocation, texture_image_width, texture_image_height, texture_image_pixels, texture_image_format, miplevels); + + image = new VulkanImage(); + image_view = new VulkanImageView(); + ((VulkanImage*)image)->setResource(vk_image); + ((VulkanImageView*)image_view)->setResource(vk_image_view); + } + + void VulkanRHI::createSwapchainImageViews() + { + m_swapchain_imageviews.resize(m_swapchain_images.size()); + + // create imageview (one for each this time) for all swapchain images + for (size_t i = 0; i < m_swapchain_images.size(); i++) + { + VkImageView vk_image_view; + vk_image_view = VulkanUtil::createImageView(m_device, + m_swapchain_images[i], + (VkFormat)m_swapchain_image_format, + VK_IMAGE_ASPECT_COLOR_BIT, + VK_IMAGE_VIEW_TYPE_2D, + 1, + 1); + m_swapchain_imageviews[i] = new VulkanImageView(); + ((VulkanImageView*)m_swapchain_imageviews[i])->setResource(vk_image_view); + } + } + + void VulkanRHI::createAssetAllocator() + { + VmaVulkanFunctions vulkanFunctions = {}; + vulkanFunctions.vkGetInstanceProcAddr = &vkGetInstanceProcAddr; + vulkanFunctions.vkGetDeviceProcAddr = &vkGetDeviceProcAddr; + + VmaAllocatorCreateInfo allocatorCreateInfo = {}; + allocatorCreateInfo.vulkanApiVersion = m_vulkan_api_version; + allocatorCreateInfo.physicalDevice = m_physical_device; + allocatorCreateInfo.device = m_device; + allocatorCreateInfo.instance = m_instance; + allocatorCreateInfo.pVulkanFunctions = &vulkanFunctions; + + vmaCreateAllocator(&allocatorCreateInfo, &m_assets_allocator); + } + + // todo : more descriptorSet + bool VulkanRHI::allocateDescriptorSets(const RHIDescriptorSetAllocateInfo* pAllocateInfo, RHIDescriptorSet* &pDescriptorSets) + { + //descriptor_set_layout + int descriptor_set_layout_size = pAllocateInfo->descriptorSetCount; + std::vector vk_descriptor_set_layout_list(descriptor_set_layout_size); + for (int i = 0; i < descriptor_set_layout_size; ++i) + { + const auto& rhi_descriptor_set_layout_element = pAllocateInfo->pSetLayouts[i]; + auto& vk_descriptor_set_layout_element = vk_descriptor_set_layout_list[i]; + + vk_descriptor_set_layout_element = ((VulkanDescriptorSetLayout*)rhi_descriptor_set_layout_element)->getResource(); + + VulkanDescriptorSetLayout* test = ((VulkanDescriptorSetLayout*)rhi_descriptor_set_layout_element); + + test = nullptr; + }; + + VkDescriptorSetAllocateInfo descriptorset_allocate_info{}; + descriptorset_allocate_info.sType = (VkStructureType)pAllocateInfo->sType; + descriptorset_allocate_info.pNext = (const void*)pAllocateInfo->pNext; + descriptorset_allocate_info.descriptorPool = ((VulkanDescriptorPool*)(pAllocateInfo->descriptorPool))->getResource(); + descriptorset_allocate_info.descriptorSetCount = pAllocateInfo->descriptorSetCount; + descriptorset_allocate_info.pSetLayouts = vk_descriptor_set_layout_list.data(); + + VkDescriptorSet vk_descriptor_set; + pDescriptorSets = new VulkanDescriptorSet; + VkResult result = vkAllocateDescriptorSets(m_device, &descriptorset_allocate_info, &vk_descriptor_set); + ((VulkanDescriptorSet*)pDescriptorSets)->setResource(vk_descriptor_set); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("vkAllocateDescriptorSets failed!"); + return false; + } + } + + bool VulkanRHI::allocateCommandBuffers(const RHICommandBufferAllocateInfo* pAllocateInfo, RHICommandBuffer* &pCommandBuffers) + { + VkCommandBufferAllocateInfo command_buffer_allocate_info{}; + command_buffer_allocate_info.sType = (VkStructureType)pAllocateInfo->sType; + command_buffer_allocate_info.pNext = (const void*)pAllocateInfo->pNext; + command_buffer_allocate_info.commandPool = ((VulkanCommandPool*)(pAllocateInfo->commandPool))->getResource(); + command_buffer_allocate_info.level = (VkCommandBufferLevel)pAllocateInfo->level; + command_buffer_allocate_info.commandBufferCount = pAllocateInfo->commandBufferCount; + + VkCommandBuffer vk_command_buffer; + pCommandBuffers = new RHICommandBuffer(); + VkResult result = vkAllocateCommandBuffers(m_device, &command_buffer_allocate_info, &vk_command_buffer); + ((VulkanCommandBuffer*)pCommandBuffers)->setResource(vk_command_buffer); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("vkAllocateCommandBuffers failed!"); + return false; + } + } + + void VulkanRHI::createSwapchain() + { + // query all supports of this physical device + SwapChainSupportDetails swapchain_support_details = querySwapChainSupport(m_physical_device); + + // choose the best or fitting format + VkSurfaceFormatKHR chosen_surface_format = + chooseSwapchainSurfaceFormatFromDetails(swapchain_support_details.formats); + // choose the best or fitting present mode + VkPresentModeKHR chosen_presentMode = + chooseSwapchainPresentModeFromDetails(swapchain_support_details.presentModes); + // choose the best or fitting extent + VkExtent2D chosen_extent = chooseSwapchainExtentFromDetails(swapchain_support_details.capabilities); + + uint32_t image_count = swapchain_support_details.capabilities.minImageCount + 1; + if (swapchain_support_details.capabilities.maxImageCount > 0 && + image_count > swapchain_support_details.capabilities.maxImageCount) + { + image_count = swapchain_support_details.capabilities.maxImageCount; + } + + VkSwapchainCreateInfoKHR createInfo {}; + createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; + createInfo.surface = m_surface; + + createInfo.minImageCount = image_count; + createInfo.imageFormat = chosen_surface_format.format; + createInfo.imageColorSpace = chosen_surface_format.colorSpace; + createInfo.imageExtent = chosen_extent; + createInfo.imageArrayLayers = 1; + createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + + uint32_t queueFamilyIndices[] = {m_queue_indices.graphics_family.value(), m_queue_indices.present_family.value()}; + + if (m_queue_indices.graphics_family != m_queue_indices.present_family) + { + createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT; + createInfo.queueFamilyIndexCount = 2; + createInfo.pQueueFamilyIndices = queueFamilyIndices; + } + else + { + createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; + } + + createInfo.preTransform = swapchain_support_details.capabilities.currentTransform; + createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; + createInfo.presentMode = chosen_presentMode; + createInfo.clipped = VK_TRUE; + + createInfo.oldSwapchain = VK_NULL_HANDLE; + + if (vkCreateSwapchainKHR(m_device, &createInfo, nullptr, &m_swapchain) != VK_SUCCESS) + { + LOG_ERROR("vk create swapchain khr"); + } + + vkGetSwapchainImagesKHR(m_device, m_swapchain, &image_count, nullptr); + m_swapchain_images.resize(image_count); + vkGetSwapchainImagesKHR(m_device, m_swapchain, &image_count, m_swapchain_images.data()); + + m_swapchain_image_format = (RHIFormat)chosen_surface_format.format; + m_swapchain_extent.height = chosen_extent.height; + m_swapchain_extent.width = chosen_extent.width; + + m_scissor = {{0, 0}, {m_swapchain_extent.width, m_swapchain_extent.height}}; + } + + void VulkanRHI::clearSwapchain() + { + for (auto imageview : m_swapchain_imageviews) + { + vkDestroyImageView(m_device, ((VulkanImageView*)imageview)->getResource(), NULL); + } + vkDestroySwapchainKHR(m_device, m_swapchain, NULL); // also swapchain images + } + + void VulkanRHI::destroyDefaultSampler(RHIDefaultSamplerType type) + { + switch (type) + { + case Piccolo::Default_Sampler_Linear: + VulkanUtil::destroyLinearSampler(m_device); + delete(m_linear_sampler); + break; + case Piccolo::Default_Sampler_Nearest: + VulkanUtil::destroyNearestSampler(m_device); + delete(m_nearest_sampler); + break; + default: + break; + } + } + + void VulkanRHI::destroyMipmappedSampler() + { + VulkanUtil::destroyMipmappedSampler(m_device); + + for (auto sampler : m_mipmap_sampler_map) + { + delete sampler.second; + } + m_mipmap_sampler_map.clear(); + } + + void VulkanRHI::destroyShaderModule(RHIShader* shaderModule) + { + vkDestroyShaderModule(m_device, ((VulkanShader*)shaderModule)->getResource(), nullptr); + + delete(shaderModule); + } + + void VulkanRHI::destroySemaphore(RHISemaphore* semaphore) + { + vkDestroySemaphore(m_device, ((VulkanSemaphore*)semaphore)->getResource(), nullptr); + } + + void VulkanRHI::destroySampler(RHISampler* sampler) + { + vkDestroySampler(m_device, ((VulkanSampler*)sampler)->getResource(), nullptr); + } + + void VulkanRHI::destroyInstance(RHIInstance* instance) + { + vkDestroyInstance(((VulkanInstance*)instance)->getResource(), nullptr); + } + + void VulkanRHI::destroyImageView(RHIImageView* imageView) + { + vkDestroyImageView(m_device, ((VulkanImageView*)imageView)->getResource(), nullptr); + } + + void VulkanRHI::destroyImage(RHIImage* image) + { + vkDestroyImage(m_device, ((VulkanImage*)image)->getResource(), nullptr); + } + + void VulkanRHI::destroyFramebuffer(RHIFramebuffer* framebuffer) + { + vkDestroyFramebuffer(m_device, ((VulkanFramebuffer*)framebuffer)->getResource(), nullptr); + } + + void VulkanRHI::destroyFence(RHIFence* fence) + { + vkDestroyFence(m_device, ((VulkanFence*)fence)->getResource(), nullptr); + } + + void VulkanRHI::destroyDevice() + { + vkDestroyDevice(m_device, nullptr); + } + + void VulkanRHI::destroyCommandPool(RHICommandPool* commandPool) + { + vkDestroyCommandPool(m_device, ((VulkanCommandPool*)commandPool)->getResource(), nullptr); + } + + void VulkanRHI::destroyBuffer(RHIBuffer* &buffer) + { + vkDestroyBuffer(m_device, ((VulkanBuffer*)buffer)->getResource(), nullptr); + RHI_DELETE_PTR(buffer); + } + + void VulkanRHI::freeCommandBuffers(RHICommandPool* commandPool, uint32_t commandBufferCount, RHICommandBuffer* pCommandBuffers) + { + VkCommandBuffer vk_command_buffer = ((VulkanCommandBuffer*)pCommandBuffers)->getResource(); + vkFreeCommandBuffers(m_device, ((VulkanCommandPool*)commandPool)->getResource(), commandBufferCount, &vk_command_buffer); + } + + void VulkanRHI::freeMemory(RHIDeviceMemory* &memory) + { + vkFreeMemory(m_device, ((VulkanDeviceMemory*)memory)->getResource(), nullptr); + RHI_DELETE_PTR(memory); + } + + bool VulkanRHI::mapMemory(RHIDeviceMemory* memory, RHIDeviceSize offset, RHIDeviceSize size, RHIMemoryMapFlags flags, void** ppData) + { + VkResult result = vkMapMemory(m_device, ((VulkanDeviceMemory*)memory)->getResource(), offset, size, (VkMemoryMapFlags)flags, ppData); + + if (result == VK_SUCCESS) + { + return true; + } + else + { + LOG_ERROR("vkMapMemory failed!"); + return false; + } + } + + void VulkanRHI::unmapMemory(RHIDeviceMemory* memory) + { + vkUnmapMemory(m_device, ((VulkanDeviceMemory*)memory)->getResource()); + } + + void VulkanRHI::invalidateMappedMemoryRanges(void* pNext, RHIDeviceMemory* memory, RHIDeviceSize offset, RHIDeviceSize size) + { + VkMappedMemoryRange mappedRange{}; + mappedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; + mappedRange.memory = ((VulkanDeviceMemory*)memory)->getResource(); + mappedRange.offset = offset; + mappedRange.size = size; + vkInvalidateMappedMemoryRanges(m_device, 1, &mappedRange); + } + + void VulkanRHI::flushMappedMemoryRanges(void* pNext, RHIDeviceMemory* memory, RHIDeviceSize offset, RHIDeviceSize size) + { + VkMappedMemoryRange mappedRange{}; + mappedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; + mappedRange.memory = ((VulkanDeviceMemory*)memory)->getResource(); + mappedRange.offset = offset; + mappedRange.size = size; + vkFlushMappedMemoryRanges(m_device, 1, &mappedRange); + } + + RHISemaphore* &VulkanRHI::getTextureCopySemaphore(uint32_t index) + { + return m_image_available_for_texturescopy_semaphores[index]; + } + + void VulkanRHI::recreateSwapchain() + { + int width = 0; + int height = 0; + glfwGetFramebufferSize(m_window, &width, &height); + while (width == 0 || height == 0) // minimized 0,0, pause for now + { + glfwGetFramebufferSize(m_window, &width, &height); + glfwWaitEvents(); + } + + VkResult res_wait_for_fences = + _vkWaitForFences(m_device, k_max_frames_in_flight, m_is_frame_in_flight_fences, VK_TRUE, UINT64_MAX); + if (VK_SUCCESS != res_wait_for_fences) + { + LOG_ERROR("_vkWaitForFences failed"); + return; + } + + destroyImageView(m_depth_image_view); + vkDestroyImage(m_device, ((VulkanImage*)m_depth_image)->getResource(), NULL); + vkFreeMemory(m_device, m_depth_image_memory, NULL); + + for (auto imageview : m_swapchain_imageviews) + { + vkDestroyImageView(m_device, ((VulkanImageView*)imageview)->getResource(), NULL); + } + vkDestroySwapchainKHR(m_device, m_swapchain, NULL); + + createSwapchain(); + createSwapchainImageViews(); + createFramebufferImageAndView(); + } + + VkResult VulkanRHI::createDebugUtilsMessengerEXT(VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pDebugMessenger) + { + auto func = + (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"); + if (func != nullptr) + { + return func(instance, pCreateInfo, pAllocator, pDebugMessenger); + } + else + { + return VK_ERROR_EXTENSION_NOT_PRESENT; + } + } + + void VulkanRHI::destroyDebugUtilsMessengerEXT(VkInstance instance, + VkDebugUtilsMessengerEXT debugMessenger, + const VkAllocationCallbacks* pAllocator) + { + auto func = + (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT"); + if (func != nullptr) + { + func(instance, debugMessenger, pAllocator); + } + } + + Piccolo::QueueFamilyIndices VulkanRHI::findQueueFamilies(VkPhysicalDevice physicalm_device) // for device and surface + { + QueueFamilyIndices indices; + uint32_t queue_family_count = 0; + vkGetPhysicalDeviceQueueFamilyProperties(physicalm_device, &queue_family_count, nullptr); + std::vector queue_families(queue_family_count); + vkGetPhysicalDeviceQueueFamilyProperties(physicalm_device, &queue_family_count, queue_families.data()); + + int i = 0; + for (const auto& queue_family : queue_families) + { + if (queue_family.queueFlags & VK_QUEUE_GRAPHICS_BIT) // if support graphics command queue + { + indices.graphics_family = i; + } + + if (queue_family.queueFlags & VK_QUEUE_COMPUTE_BIT) // if support compute command queue + { + indices.m_compute_family = i; + } + + + VkBool32 is_present_support = false; + vkGetPhysicalDeviceSurfaceSupportKHR(physicalm_device, + i, + m_surface, + &is_present_support); // if support surface presentation + if (is_present_support) + { + indices.present_family = i; + } + + if (indices.isComplete()) + { + break; + } + i++; + } + return indices; + } + + bool VulkanRHI::checkDeviceExtensionSupport(VkPhysicalDevice physicalm_device) + { + uint32_t extension_count; + vkEnumerateDeviceExtensionProperties(physicalm_device, nullptr, &extension_count, nullptr); + + std::vector available_extensions(extension_count); + vkEnumerateDeviceExtensionProperties(physicalm_device, nullptr, &extension_count, available_extensions.data()); + + std::set required_extensions(m_device_extensions.begin(), m_device_extensions.end()); + for (const auto& extension : available_extensions) + { + required_extensions.erase(extension.extensionName); + } + + return required_extensions.empty(); + } + + bool VulkanRHI::isDeviceSuitable(VkPhysicalDevice physicalm_device) + { + auto queue_indices = findQueueFamilies(physicalm_device); + bool is_extensions_supported = checkDeviceExtensionSupport(physicalm_device); + bool is_swapchain_adequate = false; + if (is_extensions_supported) + { + SwapChainSupportDetails swapchain_support_details = querySwapChainSupport(physicalm_device); + is_swapchain_adequate = + !swapchain_support_details.formats.empty() && !swapchain_support_details.presentModes.empty(); + } + + VkPhysicalDeviceFeatures physicalm_device_features; + vkGetPhysicalDeviceFeatures(physicalm_device, &physicalm_device_features); + + if (!queue_indices.isComplete() || !is_swapchain_adequate || !physicalm_device_features.samplerAnisotropy) + { + return false; + } + + return true; + } + + Piccolo::SwapChainSupportDetails VulkanRHI::querySwapChainSupport(VkPhysicalDevice physicalm_device) + { + SwapChainSupportDetails details_result; + + // capabilities + vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalm_device, m_surface, &details_result.capabilities); + + // formats + uint32_t format_count; + vkGetPhysicalDeviceSurfaceFormatsKHR(physicalm_device, m_surface, &format_count, nullptr); + if (format_count != 0) + { + details_result.formats.resize(format_count); + vkGetPhysicalDeviceSurfaceFormatsKHR( + physicalm_device, m_surface, &format_count, details_result.formats.data()); + } + + // present modes + uint32_t presentmode_count; + vkGetPhysicalDeviceSurfacePresentModesKHR(physicalm_device, m_surface, &presentmode_count, nullptr); + if (presentmode_count != 0) + { + details_result.presentModes.resize(presentmode_count); + vkGetPhysicalDeviceSurfacePresentModesKHR( + physicalm_device, m_surface, &presentmode_count, details_result.presentModes.data()); + } + + return details_result; + } + + VkFormat VulkanRHI::findDepthFormat() + { + return findSupportedFormat({VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT}, + VK_IMAGE_TILING_OPTIMAL, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT); + } + + VkFormat VulkanRHI::findSupportedFormat(const std::vector& candidates, + VkImageTiling tiling, + VkFormatFeatureFlags features) + { + for (VkFormat format : candidates) + { + VkFormatProperties props; + vkGetPhysicalDeviceFormatProperties(m_physical_device, format, &props); + + if (tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features) + { + return format; + } + else if (tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features) + { + return format; + } + } + + LOG_ERROR("findSupportedFormat failed"); + return VkFormat(); + } + + VkSurfaceFormatKHR + VulkanRHI::chooseSwapchainSurfaceFormatFromDetails(const std::vector& available_surface_formats) + { + for (const auto& surface_format : available_surface_formats) + { + // TODO: select the VK_FORMAT_B8G8R8A8_SRGB surface format, + // there is no need to do gamma correction in the fragment shader + if (surface_format.format == VK_FORMAT_B8G8R8A8_UNORM && + surface_format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) + { + return surface_format; + } + } + return available_surface_formats[0]; + } + + VkPresentModeKHR + VulkanRHI::chooseSwapchainPresentModeFromDetails(const std::vector& available_present_modes) + { + for (VkPresentModeKHR present_mode : available_present_modes) + { + if (VK_PRESENT_MODE_MAILBOX_KHR == present_mode) + { + return VK_PRESENT_MODE_MAILBOX_KHR; + } + } + + return VK_PRESENT_MODE_FIFO_KHR; + } + + VkExtent2D VulkanRHI::chooseSwapchainExtentFromDetails(const VkSurfaceCapabilitiesKHR& capabilities) + { + if (capabilities.currentExtent.width != UINT32_MAX) + { + return capabilities.currentExtent; + } + else + { + int width, height; + glfwGetFramebufferSize(m_window, &width, &height); + + VkExtent2D actualExtent = {static_cast(width), static_cast(height)}; + + actualExtent.width = + std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width); + actualExtent.height = + std::clamp(actualExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height); + + return actualExtent; + } + } + + void VulkanRHI::pushEvent(RHICommandBuffer* commond_buffer, const char* name, const float* color) + { + if (m_enable_debug_utils_label) + { + VkDebugUtilsLabelEXT label_info; + label_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT; + label_info.pNext = nullptr; + label_info.pLabelName = name; + for (int i = 0; i < 4; ++i) + label_info.color[i] = color[i]; + _vkCmdBeginDebugUtilsLabelEXT(((VulkanCommandBuffer*)commond_buffer)->getResource(), &label_info); + } + } + + void VulkanRHI::popEvent(RHICommandBuffer* commond_buffer) + { + if (m_enable_debug_utils_label) + { + _vkCmdEndDebugUtilsLabelEXT(((VulkanCommandBuffer*)commond_buffer)->getResource()); + } + } + bool VulkanRHI::isPointLightShadowEnabled(){ return m_enable_point_light_shadow; } + + RHICommandBuffer* VulkanRHI::getCurrentCommandBuffer() const + { + return m_current_command_buffer; + } + RHICommandBuffer* const* VulkanRHI::getCommandBufferList() const + { + return m_command_buffers; + } + RHICommandPool* VulkanRHI::getCommandPoor() const + { + return m_rhi_command_pool; + } + RHIDescriptorPool* VulkanRHI::getDescriptorPoor() const + { + return m_descriptor_pool; + } + RHIFence* const* VulkanRHI::getFenceList() const + { + return m_rhi_is_frame_in_flight_fences; + } + QueueFamilyIndices VulkanRHI::getQueueFamilyIndices() const + { + return m_queue_indices; + } + RHIQueue* VulkanRHI::getGraphicsQueue() const + { + return m_graphics_queue; + } + RHIQueue* VulkanRHI::getComputeQueue() const + { + return m_compute_queue; + } + RHISwapChainDesc VulkanRHI::getSwapchainInfo() + { + RHISwapChainDesc desc; + desc.image_format = m_swapchain_image_format; + desc.extent = m_swapchain_extent; + desc.viewport = &m_viewport; + desc.scissor = &m_scissor; + desc.imageViews = m_swapchain_imageviews; + return desc; + } + RHIDepthImageDesc VulkanRHI::getDepthImageInfo() const + { + RHIDepthImageDesc desc; + desc.depth_image_format = m_depth_image_format; + desc.depth_image_view = m_depth_image_view; + desc.depth_image = m_depth_image; + return desc; + } + uint8_t VulkanRHI::getMaxFramesInFlight() const + { + return k_max_frames_in_flight; + } + uint8_t VulkanRHI::getCurrentFrameIndex() const + { + return m_current_frame_index; + } + void VulkanRHI::setCurrentFrameIndex(uint8_t index) + { + m_current_frame_index = index; + } + +} // namespace Piccolo \ No newline at end of file diff --git a/engine/source/runtime/function/render/interface/vulkan/vulkan_rhi.h b/engine/source/runtime/function/render/interface/vulkan/vulkan_rhi.h new file mode 100644 index 000000000..4d0f9bf96 --- /dev/null +++ b/engine/source/runtime/function/render/interface/vulkan/vulkan_rhi.h @@ -0,0 +1,314 @@ +#pragma once + +#include "runtime/function/render/interface/rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi_resource.h" + +#include +#include + +#include +#include +#include + +namespace Piccolo +{ + + + class VulkanRHI final : public RHI + { + public: + // initialize + virtual void initialize(RHIInitInfo init_info) override final; + virtual void prepareContext() override final; + + // allocate and create + bool allocateCommandBuffers(const RHICommandBufferAllocateInfo* pAllocateInfo, RHICommandBuffer* &pCommandBuffers) override; + bool allocateDescriptorSets(const RHIDescriptorSetAllocateInfo* pAllocateInfo, RHIDescriptorSet* &pDescriptorSets) override; + void createSwapchain() override; + void recreateSwapchain() override; + void createSwapchainImageViews() override; + void createFramebufferImageAndView() override; + RHISampler* getOrCreateDefaultSampler(RHIDefaultSamplerType type) override; + RHISampler* getOrCreateMipmapSampler(uint32_t width, uint32_t height) override; + RHIShader* createShaderModule(const std::vector& shader_code) override; + void createBuffer(RHIDeviceSize size, RHIBufferUsageFlags usage, RHIMemoryPropertyFlags properties, RHIBuffer* &buffer, RHIDeviceMemory* &buffer_memory) override; + void createBufferAndInitialize(RHIBufferUsageFlags usage, RHIMemoryPropertyFlags properties, RHIBuffer*& buffer, RHIDeviceMemory*& buffer_memory, RHIDeviceSize size, void* data = nullptr, int datasize = 0) override; + bool createBufferVMA(VmaAllocator allocator, + const RHIBufferCreateInfo* pBufferCreateInfo, + const VmaAllocationCreateInfo* pAllocationCreateInfo, + RHIBuffer* &pBuffer, + VmaAllocation* pAllocation, + VmaAllocationInfo* pAllocationInfo) override; + bool createBufferWithAlignmentVMA( + VmaAllocator allocator, + const RHIBufferCreateInfo* pBufferCreateInfo, + const VmaAllocationCreateInfo* pAllocationCreateInfo, + RHIDeviceSize minAlignment, + RHIBuffer* &pBuffer, + VmaAllocation* pAllocation, + VmaAllocationInfo* pAllocationInfo) override; + void copyBuffer(RHIBuffer* srcBuffer, RHIBuffer* dstBuffer, RHIDeviceSize srcOffset, RHIDeviceSize dstOffset, RHIDeviceSize size) override; + void createImage(uint32_t image_width, uint32_t image_height, RHIFormat format, RHIImageTiling image_tiling, RHIImageUsageFlags image_usage_flags, RHIMemoryPropertyFlags memory_property_flags, + RHIImage* &image, RHIDeviceMemory* &memory, RHIImageCreateFlags image_create_flags, uint32_t array_layers, uint32_t miplevels) override; + void createImageView(RHIImage* image, RHIFormat format, RHIImageAspectFlags image_aspect_flags, RHIImageViewType view_type, uint32_t layout_count, uint32_t miplevels, + RHIImageView* &image_view) override; + void createGlobalImage(RHIImage* &image, RHIImageView* &image_view, VmaAllocation& image_allocation, uint32_t texture_image_width, uint32_t texture_image_height, void* texture_image_pixels, RHIFormat texture_image_format, uint32_t miplevels = 0) override; + void createCubeMap(RHIImage* &image, RHIImageView* &image_view, VmaAllocation& image_allocation, uint32_t texture_image_width, uint32_t texture_image_height, std::array texture_image_pixels, RHIFormat texture_image_format, uint32_t miplevels) override; + bool createCommandPool(const RHICommandPoolCreateInfo* pCreateInfo, RHICommandPool* &pCommandPool) override; + bool createDescriptorPool(const RHIDescriptorPoolCreateInfo* pCreateInfo, RHIDescriptorPool* &pDescriptorPool) override; + bool createDescriptorSetLayout(const RHIDescriptorSetLayoutCreateInfo* pCreateInfo, RHIDescriptorSetLayout* &pSetLayout) override; + bool createFence(const RHIFenceCreateInfo* pCreateInfo, RHIFence* &pFence) override; + bool createFramebuffer(const RHIFramebufferCreateInfo* pCreateInfo, RHIFramebuffer* &pFramebuffer) override; + bool createGraphicsPipelines(RHIPipelineCache* pipelineCache, uint32_t createInfoCount, const RHIGraphicsPipelineCreateInfo* pCreateInfos, RHIPipeline* &pPipelines) override; + bool createComputePipelines(RHIPipelineCache* pipelineCache, uint32_t createInfoCount, const RHIComputePipelineCreateInfo* pCreateInfos, RHIPipeline*& pPipelines) override; + bool createPipelineLayout(const RHIPipelineLayoutCreateInfo* pCreateInfo, RHIPipelineLayout* &pPipelineLayout) override; + bool createRenderPass(const RHIRenderPassCreateInfo* pCreateInfo, RHIRenderPass* &pRenderPass) override; + bool createSampler(const RHISamplerCreateInfo* pCreateInfo, RHISampler* &pSampler) override; + bool createSemaphore(const RHISemaphoreCreateInfo* pCreateInfo, RHISemaphore* &pSemaphore) override; + + // command and command write + bool waitForFencesPFN(uint32_t fenceCount, RHIFence* const* pFence, RHIBool32 waitAll, uint64_t timeout) override; + bool resetFencesPFN(uint32_t fenceCount, RHIFence* const* pFences) override; + bool resetCommandPoolPFN(RHICommandPool* commandPool, RHICommandPoolResetFlags flags) override; + bool beginCommandBufferPFN(RHICommandBuffer* commandBuffer, const RHICommandBufferBeginInfo* pBeginInfo) override; + bool endCommandBufferPFN(RHICommandBuffer* commandBuffer) override; + void cmdBeginRenderPassPFN(RHICommandBuffer* commandBuffer, const RHIRenderPassBeginInfo* pRenderPassBegin, RHISubpassContents contents) override; + void cmdNextSubpassPFN(RHICommandBuffer* commandBuffer, RHISubpassContents contents) override; + void cmdEndRenderPassPFN(RHICommandBuffer* commandBuffer) override; + void cmdBindPipelinePFN(RHICommandBuffer* commandBuffer, RHIPipelineBindPoint pipelineBindPoint, RHIPipeline* pipeline) override; + void cmdSetViewportPFN(RHICommandBuffer* commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const RHIViewport* pViewports) override; + void cmdSetScissorPFN(RHICommandBuffer* commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const RHIRect2D* pScissors) override; + void cmdBindVertexBuffersPFN( + RHICommandBuffer* commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + RHIBuffer* const* pBuffers, + const RHIDeviceSize* pOffsets) override; + void cmdBindIndexBufferPFN(RHICommandBuffer* commandBuffer, RHIBuffer* buffer, RHIDeviceSize offset, RHIIndexType indexType) override; + void cmdBindDescriptorSetsPFN( + RHICommandBuffer* commandBuffer, + RHIPipelineBindPoint pipelineBindPoint, + RHIPipelineLayout* layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const RHIDescriptorSet* const* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets) override; + void cmdDrawIndexedPFN(RHICommandBuffer* commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) override; + void cmdClearAttachmentsPFN(RHICommandBuffer* commandBuffer, uint32_t attachmentCount, const RHIClearAttachment* pAttachments, uint32_t rectCount, const RHIClearRect* pRects) override; + + bool beginCommandBuffer(RHICommandBuffer* commandBuffer, const RHICommandBufferBeginInfo* pBeginInfo) override; + void cmdCopyImageToBuffer(RHICommandBuffer* commandBuffer, RHIImage* srcImage, RHIImageLayout srcImageLayout, RHIBuffer* dstBuffer, uint32_t regionCount, const RHIBufferImageCopy* pRegions) override; + void cmdCopyImageToImage(RHICommandBuffer* commandBuffer, RHIImage* srcImage, RHIImageAspectFlagBits srcFlag, RHIImage* dstImage, RHIImageAspectFlagBits dstFlag, uint32_t width, uint32_t height) override; + void cmdCopyBuffer(RHICommandBuffer* commandBuffer, RHIBuffer* srcBuffer, RHIBuffer* dstBuffer, uint32_t regionCount, RHIBufferCopy* pRegions) override; + void cmdDraw(RHICommandBuffer* commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) override; + void cmdDispatch(RHICommandBuffer* commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) override; + void cmdDispatchIndirect(RHICommandBuffer* commandBuffer, RHIBuffer* buffer, RHIDeviceSize offset) override; + void cmdPipelineBarrier(RHICommandBuffer* commandBuffer, RHIPipelineStageFlags srcStageMask, RHIPipelineStageFlags dstStageMask, RHIDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const RHIMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const RHIBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const RHIImageMemoryBarrier* pImageMemoryBarriers) override; + bool endCommandBuffer(RHICommandBuffer* commandBuffer) override; + void updateDescriptorSets(uint32_t descriptorWriteCount, const RHIWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const RHICopyDescriptorSet* pDescriptorCopies) override; + bool queueSubmit(RHIQueue* queue, uint32_t submitCount, const RHISubmitInfo* pSubmits, RHIFence* fence) override; + bool queueWaitIdle(RHIQueue* queue) override; + void resetCommandPool() override; + void waitForFences() override; + bool waitForFences(uint32_t fenceCount, const RHIFence* const* pFences, RHIBool32 waitAll, uint64_t timeout); + + // query + void getPhysicalDeviceProperties(RHIPhysicalDeviceProperties* pProperties) override; + RHICommandBuffer* getCurrentCommandBuffer() const override; + RHICommandBuffer* const* getCommandBufferList() const override; + RHICommandPool* getCommandPoor() const override; + RHIDescriptorPool* getDescriptorPoor()const override; + RHIFence* const* getFenceList() const override; + QueueFamilyIndices getQueueFamilyIndices() const override; + RHIQueue* getGraphicsQueue() const override; + RHIQueue* getComputeQueue() const override; + RHISwapChainDesc getSwapchainInfo() override; + RHIDepthImageDesc getDepthImageInfo() const override; + uint8_t getMaxFramesInFlight() const override; + uint8_t getCurrentFrameIndex() const override; + void setCurrentFrameIndex(uint8_t index) override; + + // command write + RHICommandBuffer* beginSingleTimeCommands() override; + void endSingleTimeCommands(RHICommandBuffer* command_buffer) override; + bool prepareBeforePass(std::function passUpdateAfterRecreateSwapchain) override; + void submitRendering(std::function passUpdateAfterRecreateSwapchain) override; + void pushEvent(RHICommandBuffer* commond_buffer, const char* name, const float* color) override; + void popEvent(RHICommandBuffer* commond_buffer) override; + + // destory + virtual ~VulkanRHI() override final; + void clear() override; + void clearSwapchain() override; + void destroyDefaultSampler(RHIDefaultSamplerType type) override; + void destroyMipmappedSampler() override; + void destroyShaderModule(RHIShader* shader) override; + void destroySemaphore(RHISemaphore* semaphore) override; + void destroySampler(RHISampler* sampler) override; + void destroyInstance(RHIInstance* instance) override; + void destroyImageView(RHIImageView* imageView) override; + void destroyImage(RHIImage* image) override; + void destroyFramebuffer(RHIFramebuffer* framebuffer) override; + void destroyFence(RHIFence* fence) override; + void destroyDevice() override; + void destroyCommandPool(RHICommandPool* commandPool) override; + void destroyBuffer(RHIBuffer* &buffer) override; + void freeCommandBuffers(RHICommandPool* commandPool, uint32_t commandBufferCount, RHICommandBuffer* pCommandBuffers) override; + + // memory + void freeMemory(RHIDeviceMemory* &memory) override; + bool mapMemory(RHIDeviceMemory* memory, RHIDeviceSize offset, RHIDeviceSize size, RHIMemoryMapFlags flags, void** ppData) override; + void unmapMemory(RHIDeviceMemory* memory) override; + void invalidateMappedMemoryRanges(void* pNext, RHIDeviceMemory* memory, RHIDeviceSize offset, RHIDeviceSize size) override; + void flushMappedMemoryRanges(void* pNext, RHIDeviceMemory* memory, RHIDeviceSize offset, RHIDeviceSize size) override; + + //semaphores + RHISemaphore* &getTextureCopySemaphore(uint32_t index) override; + public: + static uint8_t const k_max_frames_in_flight {3}; + + + RHIQueue* m_graphics_queue{ nullptr }; + RHIQueue* m_compute_queue{ nullptr }; + + RHIFormat m_swapchain_image_format{ RHI_FORMAT_UNDEFINED }; + std::vector m_swapchain_imageviews; + RHIExtent2D m_swapchain_extent; + RHIViewport m_viewport; + RHIRect2D m_scissor; + + RHIFormat m_depth_image_format{ RHI_FORMAT_UNDEFINED }; + RHIImageView* m_depth_image_view = new VulkanImageView(); + + RHIFence* m_rhi_is_frame_in_flight_fences[k_max_frames_in_flight]; + + RHIDescriptorPool* m_descriptor_pool = new VulkanDescriptorPool(); + + RHICommandPool* m_rhi_command_pool; + + RHICommandBuffer* m_command_buffers[k_max_frames_in_flight]; + RHICommandBuffer* m_current_command_buffer = new VulkanCommandBuffer(); + + QueueFamilyIndices m_queue_indices; + + GLFWwindow* m_window {nullptr}; + VkInstance m_instance {nullptr}; + VkSurfaceKHR m_surface {nullptr}; + VkPhysicalDevice m_physical_device {nullptr}; + VkDevice m_device {nullptr}; + VkQueue m_present_queue {nullptr}; + + VkSwapchainKHR m_swapchain {nullptr}; + std::vector m_swapchain_images; + + RHIImage* m_depth_image = new VulkanImage(); + VkDeviceMemory m_depth_image_memory {nullptr}; + + std::vector m_swapchain_framebuffers; + + // asset allocator use VMA library + VmaAllocator m_assets_allocator; + + // function pointers + PFN_vkCmdBeginDebugUtilsLabelEXT _vkCmdBeginDebugUtilsLabelEXT; + PFN_vkCmdEndDebugUtilsLabelEXT _vkCmdEndDebugUtilsLabelEXT; + PFN_vkWaitForFences _vkWaitForFences; + PFN_vkResetFences _vkResetFences; + PFN_vkResetCommandPool _vkResetCommandPool; + PFN_vkBeginCommandBuffer _vkBeginCommandBuffer; + PFN_vkEndCommandBuffer _vkEndCommandBuffer; + PFN_vkCmdBeginRenderPass _vkCmdBeginRenderPass; + PFN_vkCmdNextSubpass _vkCmdNextSubpass; + PFN_vkCmdEndRenderPass _vkCmdEndRenderPass; + PFN_vkCmdBindPipeline _vkCmdBindPipeline; + PFN_vkCmdSetViewport _vkCmdSetViewport; + PFN_vkCmdSetScissor _vkCmdSetScissor; + PFN_vkCmdBindVertexBuffers _vkCmdBindVertexBuffers; + PFN_vkCmdBindIndexBuffer _vkCmdBindIndexBuffer; + PFN_vkCmdBindDescriptorSets _vkCmdBindDescriptorSets; + PFN_vkCmdDrawIndexed _vkCmdDrawIndexed; + PFN_vkCmdClearAttachments _vkCmdClearAttachments; + + // global descriptor pool + VkDescriptorPool m_vk_descriptor_pool; + + // command pool and buffers + uint8_t m_current_frame_index {0}; + VkCommandPool m_command_pools[k_max_frames_in_flight]; + VkCommandBuffer m_vk_command_buffers[k_max_frames_in_flight]; + VkSemaphore m_image_available_for_render_semaphores[k_max_frames_in_flight]; + VkSemaphore m_image_finished_for_presentation_semaphores[k_max_frames_in_flight]; + RHISemaphore* m_image_available_for_texturescopy_semaphores[k_max_frames_in_flight]; + VkFence m_is_frame_in_flight_fences[k_max_frames_in_flight]; + + // TODO: set + VkCommandBuffer m_vk_current_command_buffer; + + uint32_t m_current_swapchain_image_index; + + private: + const std::vector m_validation_layers {"VK_LAYER_KHRONOS_validation"}; + uint32_t m_vulkan_api_version {VK_API_VERSION_1_0}; + + std::vector m_device_extensions = {VK_KHR_SWAPCHAIN_EXTENSION_NAME}; + + // default sampler cache + RHISampler* m_linear_sampler = nullptr; + RHISampler* m_nearest_sampler = nullptr; + std::map m_mipmap_sampler_map; + + private: + void createInstance(); + void initializeDebugMessenger(); + void createWindowSurface(); + void initializePhysicalDevice(); + void createLogicalDevice(); + void createCommandPool() override;; + void createCommandBuffers(); + void createDescriptorPool(); + void createSyncPrimitives(); + void createAssetAllocator(); + + public: + bool isPointLightShadowEnabled() override; + + private: + bool m_enable_validation_Layers{ true }; + bool m_enable_debug_utils_label{ true }; + bool m_enable_point_light_shadow{ true }; + + // used in descriptor pool creation + uint32_t m_max_vertex_blending_mesh_count{ 256 }; + uint32_t m_max_material_count{ 256 }; + + bool checkValidationLayerSupport(); + std::vector getRequiredExtensions(); + void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo); + + VkDebugUtilsMessengerEXT m_debug_messenger = nullptr; + VkResult createDebugUtilsMessengerEXT(VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pDebugMessenger); + void destroyDebugUtilsMessengerEXT(VkInstance instance, + VkDebugUtilsMessengerEXT debugMessenger, + const VkAllocationCallbacks* pAllocator); + + QueueFamilyIndices findQueueFamilies(VkPhysicalDevice physical_device); + bool checkDeviceExtensionSupport(VkPhysicalDevice physical_device); + bool isDeviceSuitable(VkPhysicalDevice physical_device); + SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice physical_device); + + VkFormat findDepthFormat(); + VkFormat findSupportedFormat(const std::vector& candidates, + VkImageTiling tiling, + VkFormatFeatureFlags features); + + VkSurfaceFormatKHR + chooseSwapchainSurfaceFormatFromDetails(const std::vector& available_surface_formats); + VkPresentModeKHR + chooseSwapchainPresentModeFromDetails(const std::vector& available_present_modes); + VkExtent2D chooseSwapchainExtentFromDetails(const VkSurfaceCapabilitiesKHR& capabilities); + }; +} // namespace Piccolo diff --git a/engine/source/runtime/function/render/interface/vulkan/vulkan_rhi_resource.h b/engine/source/runtime/function/render/interface/vulkan/vulkan_rhi_resource.h new file mode 100644 index 000000000..92a08e76b --- /dev/null +++ b/engine/source/runtime/function/render/interface/vulkan/vulkan_rhi_resource.h @@ -0,0 +1,346 @@ +#pragma once + +#include "runtime/function/render/interface/rhi.h" + +#include +#include + +namespace Piccolo +{ + class VulkanBuffer : public RHIBuffer + { + public: + void setResource(VkBuffer res) + { + m_resource = res; + } + VkBuffer getResource() const + { + return m_resource; + } + private: + VkBuffer m_resource; + }; + class VulkanBufferView : public RHIBufferView + { + public: + void setResource(VkBufferView res) + { + m_resource = res; + } + VkBufferView getResource() const + { + return m_resource; + } + private: + VkBufferView m_resource; + }; + class VulkanCommandBuffer : public RHICommandBuffer + { + public: + void setResource(VkCommandBuffer res) + { + m_resource = res; + } + const VkCommandBuffer getResource() const + { + return m_resource; + } + private: + VkCommandBuffer m_resource; + }; + class VulkanCommandPool : public RHICommandPool + { + public: + void setResource(VkCommandPool res) + { + m_resource = res; + } + VkCommandPool getResource() const + { + return m_resource; + } + private: + VkCommandPool m_resource; + }; + class VulkanDescriptorPool : public RHIDescriptorPool + { + public: + void setResource(VkDescriptorPool res) + { + m_resource = res; + } + VkDescriptorPool getResource() const + { + return m_resource; + } + private: + VkDescriptorPool m_resource; + }; + class VulkanDescriptorSet : public RHIDescriptorSet + { + public: + void setResource(VkDescriptorSet res) + { + m_resource = res; + } + VkDescriptorSet getResource() const + { + return m_resource; + } + private: + VkDescriptorSet m_resource; + }; + class VulkanDescriptorSetLayout : public RHIDescriptorSetLayout + { + public: + void setResource(VkDescriptorSetLayout res) + { + m_resource = res; + } + VkDescriptorSetLayout getResource() const + { + return m_resource; + } + private: + VkDescriptorSetLayout m_resource; + }; + class VulkanDevice : public RHIDevice + { + public: + void setResource(VkDevice res) + { + m_resource = res; + } + VkDevice getResource() const + { + return m_resource; + } + private: + VkDevice m_resource; + }; + class VulkanDeviceMemory : public RHIDeviceMemory + { + public: + void setResource(VkDeviceMemory res) + { + m_resource = res; + } + VkDeviceMemory getResource() const + { + return m_resource; + } + private: + VkDeviceMemory m_resource; + }; + class VulkanEvent : public RHIEvent + { + public: + void setResource(VkEvent res) + { + m_resource = res; + } + VkEvent getResource() const + { + return m_resource; + } + private: + VkEvent m_resource; + }; + class VulkanFence : public RHIFence + { + public: + void setResource(VkFence res) + { + m_resource = res; + } + VkFence getResource() const + { + return m_resource; + } + private: + VkFence m_resource; + }; + class VulkanFramebuffer : public RHIFramebuffer + { + public: + void setResource(VkFramebuffer res) + { + m_resource = res; + } + VkFramebuffer getResource() const + { + return m_resource; + } + private: + VkFramebuffer m_resource; + }; + class VulkanImage : public RHIImage + { + public: + void setResource(VkImage res) + { + m_resource = res; + } + VkImage &getResource() + { + return m_resource; + } + private: + VkImage m_resource; + }; + class VulkanImageView : public RHIImageView + { + public: + void setResource(VkImageView res) + { + m_resource = res; + } + VkImageView getResource() const + { + return m_resource; + } + private: + VkImageView m_resource; + }; + class VulkanInstance : public RHIInstance + { + public: + void setResource(VkInstance res) + { + m_resource = res; + } + VkInstance getResource() const + { + return m_resource; + } + private: + VkInstance m_resource; + }; + class VulkanQueue : public RHIQueue + { + public: + void setResource(VkQueue res) + { + m_resource = res; + } + VkQueue getResource() const + { + return m_resource; + } + private: + VkQueue m_resource; + }; + class VulkanPhysicalDevice : public RHIPhysicalDevice + { + public: + void setResource(VkPhysicalDevice res) + { + m_resource = res; + } + VkPhysicalDevice getResource() const + { + return m_resource; + } + private: + VkPhysicalDevice m_resource; + }; + class VulkanPipeline : public RHIPipeline + { + public: + void setResource(VkPipeline res) + { + m_resource = res; + } + VkPipeline getResource() const + { + return m_resource; + } + private: + VkPipeline m_resource; + }; + class VulkanPipelineCache : public RHIPipelineCache + { + public: + void setResource(VkPipelineCache res) + { + m_resource = res; + } + VkPipelineCache getResource() const + { + return m_resource; + } + private: + VkPipelineCache m_resource; + }; + class VulkanPipelineLayout : public RHIPipelineLayout + { + public: + void setResource(VkPipelineLayout res) + { + m_resource = res; + } + VkPipelineLayout getResource() const + { + return m_resource; + } + private: + VkPipelineLayout m_resource; + }; + class VulkanRenderPass : public RHIRenderPass + { + public: + void setResource(VkRenderPass res) + { + m_resource = res; + } + VkRenderPass getResource() const + { + return m_resource; + } + private: + VkRenderPass m_resource; + }; + class VulkanSampler : public RHISampler + { + public: + void setResource(VkSampler res) + { + m_resource = res; + } + VkSampler getResource() const + { + return m_resource; + } + private: + VkSampler m_resource; + }; + class VulkanSemaphore : public RHISemaphore + { + public: + void setResource(VkSemaphore res) + { + m_resource = res; + } + VkSemaphore &getResource() + { + return m_resource; + } + private: + VkSemaphore m_resource; + }; + class VulkanShader : public RHIShader + { + public: + void setResource(VkShaderModule res) + { + m_resource = res; + } + VkShaderModule getResource() const + { + return m_resource; + } + private: + VkShaderModule m_resource; + }; +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/rhi/vulkan/vulkan_util.cpp b/engine/source/runtime/function/render/interface/vulkan/vulkan_util.cpp similarity index 89% rename from engine/source/runtime/function/render/rhi/vulkan/vulkan_util.cpp rename to engine/source/runtime/function/render/interface/vulkan/vulkan_util.cpp index ea59f1c3f..5b5d635fc 100644 --- a/engine/source/runtime/function/render/rhi/vulkan/vulkan_util.cpp +++ b/engine/source/runtime/function/render/interface/vulkan/vulkan_util.cpp @@ -1,8 +1,8 @@ -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/core/base/macro.h" #include -#include #include #include #include @@ -27,7 +27,8 @@ namespace Piccolo return i; } } - throw std::runtime_error("findMemoryType"); + LOG_ERROR("findMemoryType error"); + return 0; } VkShaderModule VulkanUtil::createShaderModule(VkDevice device, const std::vector& shader_code) @@ -63,7 +64,8 @@ namespace Piccolo bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; if (VK_SUCCESS != vkCreateBuffer(device, &bufferCreateInfo, nullptr, buffer)) { - throw std::runtime_error("create buffer buffer"); + LOG_ERROR("create buffer buffer failed!"); + return; } // Create the memory backing up the buffer handle @@ -89,10 +91,15 @@ namespace Piccolo } memReqs.memoryTypeBits >>= 1; } - assert(memTypeFound); + if (!memTypeFound) + { + LOG_ERROR("memTypeFound is nullptr"); + return; + } if (VK_SUCCESS != vkAllocateMemory(device, &memAlloc, nullptr, memory)) { - throw std::runtime_error("alloc memory"); + LOG_ERROR("alloc memory failed!"); + return; } if (data != nullptr && datasize != 0) @@ -100,7 +107,8 @@ namespace Piccolo void* mapped; if (VK_SUCCESS != vkMapMemory(device, *memory, 0, size, 0, &mapped)) { - throw std::runtime_error("map memory"); + LOG_ERROR("map memory failed!"); + return; } memcpy(mapped, data, datasize); vkUnmapMemory(device, *memory); @@ -108,7 +116,8 @@ namespace Piccolo if (VK_SUCCESS != vkBindBufferMemory(device, *buffer, *memory, 0)) { - throw std::runtime_error("bind memory"); + LOG_ERROR("bind memory failed!"); + return; } } @@ -128,7 +137,8 @@ namespace Piccolo if (vkCreateBuffer(device, &buffer_create_info, nullptr, &buffer) != VK_SUCCESS) { - throw std::runtime_error("vkCreateBuffer"); + LOG_ERROR("vkCreateBuffer failed!"); + return; } VkMemoryRequirements buffer_memory_requirements; // for allocate_info.allocationSize and @@ -143,7 +153,8 @@ namespace Piccolo if (vkAllocateMemory(device, &buffer_memory_allocate_info, nullptr, &buffer_memory) != VK_SUCCESS) { - throw std::runtime_error("vkAllocateMemory"); + LOG_ERROR("vkAllocateMemory failed!"); + return; } // bind buffer with buffer memory @@ -157,14 +168,19 @@ namespace Piccolo VkDeviceSize dstOffset, VkDeviceSize size) { - assert(rhi); + if (rhi == nullptr) + { + LOG_ERROR("rhi is nullptr"); + return; + } - VkCommandBuffer command_buffer = static_cast(rhi)->beginSingleTimeCommands(); + RHICommandBuffer* rhi_command_buffer = static_cast(rhi)->beginSingleTimeCommands(); + VkCommandBuffer command_buffer = ((VulkanCommandBuffer*)rhi_command_buffer)->getResource(); VkBufferCopy copyRegion = {srcOffset, dstOffset, size}; vkCmdCopyBuffer(command_buffer, srcBuffer, dstBuffer, 1, ©Region); - static_cast(rhi)->endSingleTimeCommands(command_buffer); + static_cast(rhi)->endSingleTimeCommands(rhi_command_buffer); } void VulkanUtil::createImage(VkPhysicalDevice physical_device, @@ -199,7 +215,8 @@ namespace Piccolo if (vkCreateImage(device, &image_create_info, nullptr, &image) != VK_SUCCESS) { - throw std::runtime_error("failed to create image!"); + LOG_ERROR("failed to create image!"); + return; } VkMemoryRequirements memRequirements; @@ -213,7 +230,8 @@ namespace Piccolo if (vkAllocateMemory(device, &allocInfo, nullptr, &memory) != VK_SUCCESS) { - throw std::runtime_error("failed to allocate image memory!"); + LOG_ERROR("failed to allocate image memory!"); + return; } vkBindImageMemory(device, image, memory, 0); @@ -255,7 +273,7 @@ namespace Piccolo uint32_t texture_image_width, uint32_t texture_image_height, void* texture_image_pixels, - PICCOLO_PIXEL_FORMAT texture_image_format, + RHIFormat texture_image_format, uint32_t miplevels) { if (!texture_image_pixels) @@ -267,36 +285,40 @@ namespace Piccolo VkFormat vulkan_image_format; switch (texture_image_format) { - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8_UNORM: + case RHIFormat::RHI_FORMAT_R8G8B8_UNORM: texture_byte_size = texture_image_width * texture_image_height * 3; vulkan_image_format = VK_FORMAT_R8G8B8_UNORM; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8_SRGB: + case RHIFormat::RHI_FORMAT_R8G8B8_SRGB: texture_byte_size = texture_image_width * texture_image_height * 3; vulkan_image_format = VK_FORMAT_R8G8B8_SRGB; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8A8_UNORM: + case RHIFormat::RHI_FORMAT_R8G8B8A8_UNORM: texture_byte_size = texture_image_width * texture_image_height * 4; vulkan_image_format = VK_FORMAT_R8G8B8A8_UNORM; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8A8_SRGB: + case RHIFormat::RHI_FORMAT_R8G8B8A8_SRGB: texture_byte_size = texture_image_width * texture_image_height * 4; vulkan_image_format = VK_FORMAT_R8G8B8A8_SRGB; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R32G32_FLOAT: + case RHIFormat::RHI_FORMAT_R32_SFLOAT: + texture_byte_size = texture_image_width * texture_image_height * 4; + vulkan_image_format = VK_FORMAT_R32_SFLOAT; + break; + case RHIFormat::RHI_FORMAT_R32G32_SFLOAT: texture_byte_size = texture_image_width * texture_image_height * 4 * 2; vulkan_image_format = VK_FORMAT_R32G32_SFLOAT; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R32G32B32_FLOAT: + case RHIFormat::RHI_FORMAT_R32G32B32_SFLOAT: texture_byte_size = texture_image_width * texture_image_height * 4 * 3; vulkan_image_format = VK_FORMAT_R32G32B32_SFLOAT; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R32G32B32A32_FLOAT: + case RHIFormat::RHI_FORMAT_R32G32B32A32_SFLOAT: texture_byte_size = texture_image_width * texture_image_height * 4 * 4; vulkan_image_format = VK_FORMAT_R32G32B32A32_SFLOAT; break; default: - throw std::runtime_error("invalid texture_byte_size"); + LOG_ERROR("invalid texture_byte_size"); break; } @@ -319,7 +341,7 @@ namespace Piccolo // generate mipmapped image uint32_t mip_levels = - (miplevels != 0) ? miplevels : floor(std::log2(std::max(texture_image_width, texture_image_height))) + 1; + (miplevels != 0) ? miplevels : floor(log2(std::max(texture_image_width, texture_image_height))) + 1; // use the vmaAllocator to allocate asset texture image VkImageCreateInfo image_create_info {}; @@ -390,46 +412,46 @@ namespace Piccolo uint32_t texture_image_width, uint32_t texture_image_height, std::array texture_image_pixels, - PICCOLO_PIXEL_FORMAT texture_image_format, + RHIFormat texture_image_format, uint32_t miplevels) { VkDeviceSize texture_layer_byte_size; VkDeviceSize cube_byte_size; VkFormat vulkan_image_format; - switch (texture_image_format) { - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8_UNORM: + case RHIFormat::RHI_FORMAT_R8G8B8_UNORM: texture_layer_byte_size = texture_image_width * texture_image_height * 3; vulkan_image_format = VK_FORMAT_R8G8B8_UNORM; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8_SRGB: + case RHIFormat::RHI_FORMAT_R8G8B8_SRGB: texture_layer_byte_size = texture_image_width * texture_image_height * 3; vulkan_image_format = VK_FORMAT_R8G8B8_SRGB; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8A8_UNORM: + case RHIFormat::RHI_FORMAT_R8G8B8A8_UNORM: texture_layer_byte_size = texture_image_width * texture_image_height * 4; vulkan_image_format = VK_FORMAT_R8G8B8A8_UNORM; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8A8_SRGB: + case RHIFormat::RHI_FORMAT_R8G8B8A8_SRGB: texture_layer_byte_size = texture_image_width * texture_image_height * 4; vulkan_image_format = VK_FORMAT_R8G8B8A8_SRGB; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R32G32_FLOAT: + case RHIFormat::RHI_FORMAT_R32G32_SFLOAT: texture_layer_byte_size = texture_image_width * texture_image_height * 4 * 2; vulkan_image_format = VK_FORMAT_R32G32_SFLOAT; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R32G32B32_FLOAT: + case RHIFormat::RHI_FORMAT_R32G32B32_SFLOAT: texture_layer_byte_size = texture_image_width * texture_image_height * 4 * 3; vulkan_image_format = VK_FORMAT_R32G32B32_SFLOAT; break; - case PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R32G32B32A32_FLOAT: + case RHIFormat::RHI_FORMAT_R32G32B32A32_SFLOAT: texture_layer_byte_size = texture_image_width * texture_image_height * 4 * 4; vulkan_image_format = VK_FORMAT_R32G32B32A32_SFLOAT; break; default: texture_layer_byte_size = VkDeviceSize(-1); - throw std::runtime_error("invalid texture_layer_byte_size"); + LOG_ERROR("invalid texture_layer_byte_size"); + return; break; } @@ -529,10 +551,12 @@ namespace Piccolo static_cast(rhi)->m_physical_device, image_format, &format_properties); if (!(format_properties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)) { - throw std::runtime_error("generateTextureMipMaps() : linear bliting not supported!"); + LOG_ERROR("generateTextureMipMaps() : linear bliting not supported!"); + return; } - VkCommandBuffer commandbuffer = static_cast(rhi)->beginSingleTimeCommands(); + RHICommandBuffer* rhi_command_buffer = static_cast(rhi)->beginSingleTimeCommands(); + VkCommandBuffer command_buffer = ((VulkanCommandBuffer*)rhi_command_buffer)->getResource(); VkImageMemoryBarrier barrier {}; barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; @@ -556,7 +580,7 @@ namespace Piccolo barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; - vkCmdPipelineBarrier(commandbuffer, + vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, @@ -582,7 +606,7 @@ namespace Piccolo blit.dstSubresource.baseArrayLayer = 0; blit.dstSubresource.layerCount = layers; - vkCmdBlitImage(commandbuffer, + vkCmdBlitImage(command_buffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, image, @@ -595,7 +619,7 @@ namespace Piccolo barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; barrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT; barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - vkCmdPipelineBarrier(commandbuffer, + vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, @@ -618,7 +642,7 @@ namespace Piccolo barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - vkCmdPipelineBarrier(commandbuffer, + vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, @@ -629,7 +653,7 @@ namespace Piccolo 1, &barrier); - static_cast(rhi)->endSingleTimeCommands(commandbuffer); + static_cast(rhi)->endSingleTimeCommands(rhi_command_buffer); } void VulkanUtil::transitionImageLayout(RHI* rhi, @@ -640,9 +664,14 @@ namespace Piccolo uint32_t miplevels, VkImageAspectFlags aspect_mask_bits) { - assert(rhi); + if (rhi == nullptr) + { + LOG_ERROR("rhi is nullptr"); + return; + } - VkCommandBuffer commandBuffer = static_cast(rhi)->beginSingleTimeCommands(); + RHICommandBuffer* rhi_command_buffer = static_cast(rhi)->beginSingleTimeCommands(); + VkCommandBuffer command_buffer = ((VulkanCommandBuffer*)rhi_command_buffer)->getResource(); VkImageMemoryBarrier barrier {}; barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; @@ -708,12 +737,13 @@ namespace Piccolo } else { - throw std::invalid_argument("unsupported layout transition!"); + LOG_ERROR("unsupported layout transition!"); + return; } - vkCmdPipelineBarrier(commandBuffer, sourceStage, destinationStage, 0, 0, nullptr, 0, nullptr, 1, &barrier); + vkCmdPipelineBarrier(command_buffer, sourceStage, destinationStage, 0, 0, nullptr, 0, nullptr, 1, &barrier); - static_cast(rhi)->endSingleTimeCommands(commandBuffer); + static_cast(rhi)->endSingleTimeCommands(rhi_command_buffer); } void VulkanUtil::copyBufferToImage(RHI* rhi, @@ -723,9 +753,14 @@ namespace Piccolo uint32_t height, uint32_t layer_count) { - assert(rhi); + if (rhi == nullptr) + { + LOG_ERROR("rhi is nullptr"); + return; + } - VkCommandBuffer commandBuffer = static_cast(rhi)->beginSingleTimeCommands(); + RHICommandBuffer* rhi_command_buffer = static_cast(rhi)->beginSingleTimeCommands(); + VkCommandBuffer command_buffer = ((VulkanCommandBuffer*)rhi_command_buffer)->getResource(); VkBufferImageCopy region {}; region.bufferOffset = 0; @@ -738,16 +773,21 @@ namespace Piccolo region.imageOffset = {0, 0, 0}; region.imageExtent = {width, height, 1}; - vkCmdCopyBufferToImage(commandBuffer, buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); + vkCmdCopyBufferToImage(command_buffer, buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); - static_cast(rhi)->endSingleTimeCommands(commandBuffer); + static_cast(rhi)->endSingleTimeCommands(rhi_command_buffer); } void VulkanUtil::genMipmappedImage(RHI* rhi, VkImage image, uint32_t width, uint32_t height, uint32_t mip_levels) { - assert(rhi); + if (rhi == nullptr) + { + LOG_ERROR("rhi is nullptr"); + return; + } - VkCommandBuffer commandBuffer = static_cast(rhi)->beginSingleTimeCommands(); + RHICommandBuffer* rhi_command_buffer = static_cast(rhi)->beginSingleTimeCommands(); + VkCommandBuffer command_buffer = ((VulkanCommandBuffer*)rhi_command_buffer)->getResource(); for (uint32_t i = 1; i < mip_levels; i++) { @@ -783,7 +823,7 @@ namespace Piccolo barrier.image = image; barrier.subresourceRange = mipSubRange; - vkCmdPipelineBarrier(commandBuffer, + vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, @@ -794,7 +834,7 @@ namespace Piccolo 1, &barrier); - vkCmdBlitImage(commandBuffer, + vkCmdBlitImage(command_buffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, image, @@ -808,7 +848,7 @@ namespace Piccolo barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; - vkCmdPipelineBarrier(commandBuffer, + vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, @@ -837,7 +877,7 @@ namespace Piccolo barrier.image = image; barrier.subresourceRange = mipSubRange; - vkCmdPipelineBarrier(commandBuffer, + vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, @@ -848,7 +888,7 @@ namespace Piccolo 1, &barrier); - static_cast(rhi)->endSingleTimeCommands(commandBuffer); + static_cast(rhi)->endSingleTimeCommands(rhi_command_buffer); } VkSampler VulkanUtil::getOrCreateMipmapSampler(VkPhysicalDevice physical_device, @@ -856,10 +896,13 @@ namespace Piccolo uint32_t width, uint32_t height) { - assert(width > 0 && height > 0); + if (width <= 0 || height <= 0) + { + LOG_ERROR("width <= 0 || height <= 0"); + } VkSampler sampler; - uint32_t mip_levels = floor(std::log2(std::max(width, height))) + 1; + uint32_t mip_levels = floor(log2(std::max(width, height))) + 1; auto find_sampler = m_mipmap_sampler_map.find(mip_levels); if (find_sampler != m_mipmap_sampler_map.end()) { @@ -891,7 +934,7 @@ namespace Piccolo if (vkCreateSampler(device, &samplerInfo, nullptr, &sampler) != VK_SUCCESS) { - assert(0); + LOG_ERROR("vkCreateSampler failed!"); } } @@ -937,7 +980,7 @@ namespace Piccolo if (vkCreateSampler(device, &samplerInfo, nullptr, &m_nearest_sampler) != VK_SUCCESS) { - throw std::runtime_error("vk create sampler"); + LOG_ERROR("vk create sampler"); } } @@ -972,7 +1015,7 @@ namespace Piccolo if (vkCreateSampler(device, &samplerInfo, nullptr, &m_linear_sampler) != VK_SUCCESS) { - throw std::runtime_error("vk create sampler"); + LOG_ERROR("vk create sampler"); } } diff --git a/engine/source/runtime/function/render/rhi/vulkan/vulkan_util.h b/engine/source/runtime/function/render/interface/vulkan/vulkan_util.h similarity index 94% rename from engine/source/runtime/function/render/rhi/vulkan/vulkan_util.h rename to engine/source/runtime/function/render/interface/vulkan/vulkan_util.h index 06e2c99f6..2c96a577b 100644 --- a/engine/source/runtime/function/render/rhi/vulkan/vulkan_util.h +++ b/engine/source/runtime/function/render/interface/vulkan/vulkan_util.h @@ -1,7 +1,6 @@ #pragma once -#include "runtime/function/render/render_type.h" -#include "runtime/function/render/rhi.h" +#include "runtime/function/render/interface/rhi.h" #include #include @@ -60,15 +59,15 @@ namespace Piccolo VkImageViewType view_type, uint32_t layout_count, uint32_t miplevels); - static void createGlobalImage(RHI* rhi, - VkImage& image, - VkImageView& image_view, - VmaAllocation& image_allocation, - uint32_t texture_image_width, - uint32_t texture_image_height, - void* texture_image_pixels, - PICCOLO_PIXEL_FORMAT texture_image_format, - uint32_t miplevels = 0); + static void createGlobalImage(RHI* rhi, + VkImage& image, + VkImageView& image_view, + VmaAllocation& image_allocation, + uint32_t texture_image_width, + uint32_t texture_image_height, + void* texture_image_pixels, + RHIFormat texture_image_format, + uint32_t miplevels = 0); static void createCubeMap(RHI* rhi, VkImage& image, VkImageView& image_view, @@ -76,7 +75,7 @@ namespace Piccolo uint32_t texture_image_width, uint32_t texture_image_height, std::array texture_image_pixels, - PICCOLO_PIXEL_FORMAT texture_image_format, + RHIFormat texture_image_format, uint32_t miplevels); static void generateTextureMipMaps(RHI* rhi, VkImage image, diff --git a/engine/source/runtime/function/render/rhi/vulkan/vulkan_vma.cpp b/engine/source/runtime/function/render/interface/vulkan/vulkan_vma.cpp similarity index 100% rename from engine/source/runtime/function/render/rhi/vulkan/vulkan_vma.cpp rename to engine/source/runtime/function/render/interface/vulkan/vulkan_vma.cpp diff --git a/engine/source/runtime/function/render/passes/color_grading_pass.cpp b/engine/source/runtime/function/render/passes/color_grading_pass.cpp index 58f602db0..c216626c1 100644 --- a/engine/source/runtime/function/render/passes/color_grading_pass.cpp +++ b/engine/source/runtime/function/render/passes/color_grading_pass.cpp @@ -1,8 +1,8 @@ -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" - #include "runtime/function/render/passes/color_grading_pass.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" + #include #include @@ -27,32 +27,30 @@ namespace Piccolo { m_descriptor_infos.resize(1); - VkDescriptorSetLayoutBinding post_process_global_layout_bindings[2] = {}; + RHIDescriptorSetLayoutBinding post_process_global_layout_bindings[2] = {}; - VkDescriptorSetLayoutBinding& post_process_global_layout_input_attachment_binding = + RHIDescriptorSetLayoutBinding& post_process_global_layout_input_attachment_binding = post_process_global_layout_bindings[0]; post_process_global_layout_input_attachment_binding.binding = 0; - post_process_global_layout_input_attachment_binding.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + post_process_global_layout_input_attachment_binding.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; post_process_global_layout_input_attachment_binding.descriptorCount = 1; - post_process_global_layout_input_attachment_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + post_process_global_layout_input_attachment_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; - VkDescriptorSetLayoutBinding& post_process_global_layout_LUT_binding = post_process_global_layout_bindings[1]; + RHIDescriptorSetLayoutBinding& post_process_global_layout_LUT_binding = post_process_global_layout_bindings[1]; post_process_global_layout_LUT_binding.binding = 1; - post_process_global_layout_LUT_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + post_process_global_layout_LUT_binding.descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; post_process_global_layout_LUT_binding.descriptorCount = 1; - post_process_global_layout_LUT_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + post_process_global_layout_LUT_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; - VkDescriptorSetLayoutCreateInfo post_process_global_layout_create_info; - post_process_global_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo post_process_global_layout_create_info; + post_process_global_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; post_process_global_layout_create_info.pNext = NULL; post_process_global_layout_create_info.flags = 0; post_process_global_layout_create_info.bindingCount = sizeof(post_process_global_layout_bindings) / sizeof(post_process_global_layout_bindings[0]); post_process_global_layout_create_info.pBindings = post_process_global_layout_bindings; - if (VK_SUCCESS != - vkCreateDescriptorSetLayout( - m_vulkan_rhi->m_device, &post_process_global_layout_create_info, NULL, &m_descriptor_infos[0].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&post_process_global_layout_create_info, m_descriptor_infos[0].layout)) { throw std::runtime_error("create post process global layout"); } @@ -62,89 +60,87 @@ namespace Piccolo { m_render_pipelines.resize(1); - VkDescriptorSetLayout descriptorset_layouts[1] = {m_descriptor_infos[0].layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayout* descriptorset_layouts[1] = {m_descriptor_infos[0].layout}; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = 1; pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout( - m_vulkan_rhi->m_device, &pipeline_layout_create_info, nullptr, &m_render_pipelines[0].layout) != - VK_SUCCESS) + if (m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[0].layout) != RHI_SUCCESS) { throw std::runtime_error("create post process pipeline layout"); } - VkShaderModule vert_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, POST_PROCESS_VERT); - VkShaderModule frag_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, COLOR_GRADING_FRAG); + RHIShader* vert_shader_module = m_rhi->createShaderModule(POST_PROCESS_VERT); + RHIShader* frag_shader_module = m_rhi->createShaderModule(COLOR_GRADING_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = 0; vertex_input_state_create_info.pVertexBindingDescriptions = NULL; vertex_input_state_create_info.vertexAttributeDescriptionCount = 0; vertex_input_state_create_info.pVertexAttributeDescriptions = NULL; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_BACK_BIT; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_BACK_BIT; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; - VkPipelineColorBlendAttachmentState color_blend_attachment_state {}; + RHIPipelineColorBlendAttachmentState color_blend_attachment_state {}; color_blend_attachment_state.colorWriteMask = - VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachment_state.blendEnable = VK_FALSE; - color_blend_attachment_state.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachment_state.blendEnable = RHI_FALSE; + color_blend_attachment_state.srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachment_state.srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = 1; color_blend_state_create_info.pAttachments = &color_blend_attachment_state; color_blend_state_create_info.blendConstants[0] = 0.0f; @@ -152,23 +148,23 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_TRUE; - depth_stencil_create_info.depthWriteEnable = VK_TRUE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_TRUE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; - VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; + RHIDynamicState dynamic_states[] = {RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR}; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 2; dynamic_state_create_info.pDynamicStates = dynamic_states; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -181,110 +177,96 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[0].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = _main_camera_subpass_color_grading; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines( - m_vulkan_rhi->m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_render_pipelines[0].pipeline) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, 1, &pipelineInfo, m_render_pipelines[0].pipeline)) { throw std::runtime_error("create post process graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } void ColorGradingPass::setupDescriptorSet() { - VkDescriptorSetAllocateInfo post_process_global_descriptor_set_alloc_info; - post_process_global_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHIDescriptorSetAllocateInfo post_process_global_descriptor_set_alloc_info; + post_process_global_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; post_process_global_descriptor_set_alloc_info.pNext = NULL; - post_process_global_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + post_process_global_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); post_process_global_descriptor_set_alloc_info.descriptorSetCount = 1; post_process_global_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[0].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &post_process_global_descriptor_set_alloc_info, - &m_descriptor_infos[0].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&post_process_global_descriptor_set_alloc_info, m_descriptor_infos[0].descriptor_set)) { throw std::runtime_error("allocate post process global descriptor set"); } } - void ColorGradingPass::updateAfterFramebufferRecreate(VkImageView input_attachment) + void ColorGradingPass::updateAfterFramebufferRecreate(RHIImageView* input_attachment) { - VkDescriptorImageInfo post_process_per_frame_input_attachment_info = {}; + RHIDescriptorImageInfo post_process_per_frame_input_attachment_info = {}; post_process_per_frame_input_attachment_info.sampler = - VulkanUtil::getOrCreateNearestSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); + m_rhi->getOrCreateDefaultSampler(Default_Sampler_Nearest); post_process_per_frame_input_attachment_info.imageView = input_attachment; - post_process_per_frame_input_attachment_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + post_process_per_frame_input_attachment_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkDescriptorImageInfo color_grading_LUT_image_info = {}; - color_grading_LUT_image_info.sampler = - VulkanUtil::getOrCreateLinearSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); + RHIDescriptorImageInfo color_grading_LUT_image_info = {}; + color_grading_LUT_image_info.sampler = m_rhi->getOrCreateDefaultSampler(Default_Sampler_Linear); color_grading_LUT_image_info.imageView = m_global_render_resource->_color_grading_resource._color_grading_LUT_texture_image_view; - color_grading_LUT_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + color_grading_LUT_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkWriteDescriptorSet post_process_descriptor_writes_info[2]; + RHIWriteDescriptorSet post_process_descriptor_writes_info[2]; - VkWriteDescriptorSet& post_process_descriptor_input_attachment_write_info = + RHIWriteDescriptorSet& post_process_descriptor_input_attachment_write_info = post_process_descriptor_writes_info[0]; - post_process_descriptor_input_attachment_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + post_process_descriptor_input_attachment_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; post_process_descriptor_input_attachment_write_info.pNext = NULL; post_process_descriptor_input_attachment_write_info.dstSet = m_descriptor_infos[0].descriptor_set; post_process_descriptor_input_attachment_write_info.dstBinding = 0; post_process_descriptor_input_attachment_write_info.dstArrayElement = 0; - post_process_descriptor_input_attachment_write_info.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + post_process_descriptor_input_attachment_write_info.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; post_process_descriptor_input_attachment_write_info.descriptorCount = 1; post_process_descriptor_input_attachment_write_info.pImageInfo = &post_process_per_frame_input_attachment_info; - VkWriteDescriptorSet& post_process_descriptor_LUT_write_info = post_process_descriptor_writes_info[1]; - post_process_descriptor_LUT_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHIWriteDescriptorSet& post_process_descriptor_LUT_write_info = post_process_descriptor_writes_info[1]; + post_process_descriptor_LUT_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; post_process_descriptor_LUT_write_info.pNext = NULL; post_process_descriptor_LUT_write_info.dstSet = m_descriptor_infos[0].descriptor_set; post_process_descriptor_LUT_write_info.dstBinding = 1; post_process_descriptor_LUT_write_info.dstArrayElement = 0; - post_process_descriptor_LUT_write_info.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + post_process_descriptor_LUT_write_info.descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; post_process_descriptor_LUT_write_info.descriptorCount = 1; post_process_descriptor_LUT_write_info.pImageInfo = &color_grading_LUT_image_info; - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - sizeof(post_process_descriptor_writes_info) / - sizeof(post_process_descriptor_writes_info[0]), - post_process_descriptor_writes_info, - 0, - NULL); + m_rhi->updateDescriptorSets(sizeof(post_process_descriptor_writes_info) / + sizeof(post_process_descriptor_writes_info[0]), + post_process_descriptor_writes_info, + 0, + NULL); } void ColorGradingPass::draw() { - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Color Grading", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } - - m_vulkan_rhi->m_vk_cmd_bind_pipeline( - m_vulkan_rhi->m_current_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[0].pipeline); - m_vulkan_rhi->m_vk_cmd_set_viewport(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_viewport); - m_vulkan_rhi->m_vk_cmd_set_scissor(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_scissor); - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].layout, - 0, - 1, - &m_descriptor_infos[0].descriptor_set, - 0, - NULL); - - vkCmdDraw(m_vulkan_rhi->m_current_command_buffer, 3, 1, 0, 0); - - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Color Grading", color); + + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), RHI_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[0].pipeline); + m_rhi->cmdSetViewportPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().viewport); + m_rhi->cmdSetScissorPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().scissor); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[0].layout, + 0, + 1, + &m_descriptor_infos[0].descriptor_set, + 0, + NULL); + + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), 3, 1, 0, 0); + + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } } // namespace Piccolo diff --git a/engine/source/runtime/function/render/passes/color_grading_pass.h b/engine/source/runtime/function/render/passes/color_grading_pass.h index 0ec4b54f6..be27a67bb 100644 --- a/engine/source/runtime/function/render/passes/color_grading_pass.h +++ b/engine/source/runtime/function/render/passes/color_grading_pass.h @@ -6,8 +6,8 @@ namespace Piccolo { struct ColorGradingPassInitInfo : RenderPassInitInfo { - VkRenderPass render_pass; - VkImageView input_attachment; + RHIRenderPass* render_pass; + RHIImageView* input_attachment; }; class ColorGradingPass : public RenderPass @@ -16,7 +16,7 @@ namespace Piccolo void initialize(const RenderPassInitInfo* init_info) override final; void draw() override final; - void updateAfterFramebufferRecreate(VkImageView input_attachment); + void updateAfterFramebufferRecreate(RHIImageView* input_attachment); private: void setupDescriptorSetLayout(); diff --git a/engine/source/runtime/function/render/passes/combine_ui_pass.cpp b/engine/source/runtime/function/render/passes/combine_ui_pass.cpp index bc1290c9d..1b368a4d8 100644 --- a/engine/source/runtime/function/render/passes/combine_ui_pass.cpp +++ b/engine/source/runtime/function/render/passes/combine_ui_pass.cpp @@ -1,8 +1,8 @@ -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" - #include "runtime/function/render/passes/combine_ui_pass.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" + #include #include @@ -27,33 +27,31 @@ namespace Piccolo { m_descriptor_infos.resize(1); - VkDescriptorSetLayoutBinding post_process_global_layout_bindings[2] = {}; + RHIDescriptorSetLayoutBinding post_process_global_layout_bindings[2] = {}; - VkDescriptorSetLayoutBinding& global_layout_scene_input_attachment_binding = + RHIDescriptorSetLayoutBinding& global_layout_scene_input_attachment_binding = post_process_global_layout_bindings[0]; global_layout_scene_input_attachment_binding.binding = 0; - global_layout_scene_input_attachment_binding.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + global_layout_scene_input_attachment_binding.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; global_layout_scene_input_attachment_binding.descriptorCount = 1; - global_layout_scene_input_attachment_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + global_layout_scene_input_attachment_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; - VkDescriptorSetLayoutBinding& global_layout_normal_input_attachment_binding = + RHIDescriptorSetLayoutBinding& global_layout_normal_input_attachment_binding = post_process_global_layout_bindings[1]; global_layout_normal_input_attachment_binding.binding = 1; - global_layout_normal_input_attachment_binding.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + global_layout_normal_input_attachment_binding.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; global_layout_normal_input_attachment_binding.descriptorCount = 1; - global_layout_normal_input_attachment_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + global_layout_normal_input_attachment_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; - VkDescriptorSetLayoutCreateInfo post_process_global_layout_create_info; - post_process_global_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo post_process_global_layout_create_info; + post_process_global_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; post_process_global_layout_create_info.pNext = NULL; post_process_global_layout_create_info.flags = 0; post_process_global_layout_create_info.bindingCount = sizeof(post_process_global_layout_bindings) / sizeof(post_process_global_layout_bindings[0]); post_process_global_layout_create_info.pBindings = post_process_global_layout_bindings; - if (VK_SUCCESS != - vkCreateDescriptorSetLayout( - m_vulkan_rhi->m_device, &post_process_global_layout_create_info, NULL, &m_descriptor_infos[0].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&post_process_global_layout_create_info, m_descriptor_infos[0].layout)) { throw std::runtime_error("create combine ui global layout"); } @@ -63,89 +61,87 @@ namespace Piccolo { m_render_pipelines.resize(1); - VkDescriptorSetLayout descriptorset_layouts[1] = {m_descriptor_infos[0].layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayout* descriptorset_layouts[1] = {m_descriptor_infos[0].layout}; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = 1; pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout( - m_vulkan_rhi->m_device, &pipeline_layout_create_info, nullptr, &m_render_pipelines[0].layout) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[0].layout)) { throw std::runtime_error("create combine ui pipeline layout"); } - VkShaderModule vert_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, POST_PROCESS_VERT); - VkShaderModule frag_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, COMBINE_UI_FRAG); + RHIShader* vert_shader_module = m_rhi->createShaderModule(POST_PROCESS_VERT); + RHIShader* frag_shader_module = m_rhi->createShaderModule(COMBINE_UI_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = 0; vertex_input_state_create_info.pVertexBindingDescriptions = NULL; vertex_input_state_create_info.vertexAttributeDescriptionCount = 0; vertex_input_state_create_info.pVertexAttributeDescriptions = NULL; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_BACK_BIT; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_BACK_BIT; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; - VkPipelineColorBlendAttachmentState color_blend_attachment_state {}; + RHIPipelineColorBlendAttachmentState color_blend_attachment_state {}; color_blend_attachment_state.colorWriteMask = - VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachment_state.blendEnable = VK_FALSE; - color_blend_attachment_state.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachment_state.blendEnable = RHI_FALSE; + color_blend_attachment_state.srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachment_state.srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = 1; color_blend_state_create_info.pAttachments = &color_blend_attachment_state; color_blend_state_create_info.blendConstants[0] = 0.0f; @@ -153,23 +149,23 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_TRUE; - depth_stencil_create_info.depthWriteEnable = VK_TRUE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_TRUE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; - VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; + RHIDynamicState dynamic_states[] = {RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR}; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 2; dynamic_state_create_info.pDynamicStates = dynamic_states; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -182,117 +178,102 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[0].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = _main_camera_subpass_combine_ui; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines( - m_vulkan_rhi->m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_render_pipelines[0].pipeline) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, 1, &pipelineInfo, m_render_pipelines[0].pipeline)) { throw std::runtime_error("create post process graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } void CombineUIPass::setupDescriptorSet() { - VkDescriptorSetAllocateInfo post_process_global_descriptor_set_alloc_info; - post_process_global_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHIDescriptorSetAllocateInfo post_process_global_descriptor_set_alloc_info; + post_process_global_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; post_process_global_descriptor_set_alloc_info.pNext = NULL; - post_process_global_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + post_process_global_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); post_process_global_descriptor_set_alloc_info.descriptorSetCount = 1; post_process_global_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[0].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &post_process_global_descriptor_set_alloc_info, - &m_descriptor_infos[0].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&post_process_global_descriptor_set_alloc_info, m_descriptor_infos[0].descriptor_set)) { throw std::runtime_error("allocate post process global descriptor set"); } } - void CombineUIPass::updateAfterFramebufferRecreate(VkImageView scene_input_attachment, - VkImageView ui_input_attachment) + void CombineUIPass::updateAfterFramebufferRecreate(RHIImageView* scene_input_attachment, + RHIImageView* ui_input_attachment) { - VkDescriptorImageInfo per_frame_scene_input_attachment_info = {}; - per_frame_scene_input_attachment_info.sampler = - VulkanUtil::getOrCreateNearestSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); + RHIDescriptorImageInfo per_frame_scene_input_attachment_info = {}; + per_frame_scene_input_attachment_info.sampler = m_rhi->getOrCreateDefaultSampler(Default_Sampler_Nearest); per_frame_scene_input_attachment_info.imageView = scene_input_attachment; - per_frame_scene_input_attachment_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + per_frame_scene_input_attachment_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkDescriptorImageInfo per_frame_ui_input_attachment_info = {}; - per_frame_ui_input_attachment_info.sampler = - VulkanUtil::getOrCreateNearestSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); + RHIDescriptorImageInfo per_frame_ui_input_attachment_info = {}; + per_frame_ui_input_attachment_info.sampler = m_rhi->getOrCreateDefaultSampler(Default_Sampler_Nearest); per_frame_ui_input_attachment_info.imageView = ui_input_attachment; - per_frame_ui_input_attachment_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + per_frame_ui_input_attachment_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkWriteDescriptorSet post_process_descriptor_writes_info[2]; + RHIWriteDescriptorSet post_process_descriptor_writes_info[2]; - VkWriteDescriptorSet& per_frame_scene_input_attachment_write_info = post_process_descriptor_writes_info[0]; - per_frame_scene_input_attachment_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHIWriteDescriptorSet& per_frame_scene_input_attachment_write_info = post_process_descriptor_writes_info[0]; + per_frame_scene_input_attachment_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; per_frame_scene_input_attachment_write_info.pNext = NULL; per_frame_scene_input_attachment_write_info.dstSet = m_descriptor_infos[0].descriptor_set; per_frame_scene_input_attachment_write_info.dstBinding = 0; per_frame_scene_input_attachment_write_info.dstArrayElement = 0; - per_frame_scene_input_attachment_write_info.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + per_frame_scene_input_attachment_write_info.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; per_frame_scene_input_attachment_write_info.descriptorCount = 1; per_frame_scene_input_attachment_write_info.pImageInfo = &per_frame_scene_input_attachment_info; - VkWriteDescriptorSet& per_frame_ui_input_attachment_write_info = post_process_descriptor_writes_info[1]; - per_frame_ui_input_attachment_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHIWriteDescriptorSet& per_frame_ui_input_attachment_write_info = post_process_descriptor_writes_info[1]; + per_frame_ui_input_attachment_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; per_frame_ui_input_attachment_write_info.pNext = NULL; per_frame_ui_input_attachment_write_info.dstSet = m_descriptor_infos[0].descriptor_set; per_frame_ui_input_attachment_write_info.dstBinding = 1; per_frame_ui_input_attachment_write_info.dstArrayElement = 0; - per_frame_ui_input_attachment_write_info.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + per_frame_ui_input_attachment_write_info.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; per_frame_ui_input_attachment_write_info.descriptorCount = 1; per_frame_ui_input_attachment_write_info.pImageInfo = &per_frame_ui_input_attachment_info; - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - sizeof(post_process_descriptor_writes_info) / - sizeof(post_process_descriptor_writes_info[0]), - post_process_descriptor_writes_info, - 0, - NULL); + m_rhi->updateDescriptorSets(sizeof(post_process_descriptor_writes_info) / + sizeof(post_process_descriptor_writes_info[0]), + post_process_descriptor_writes_info, + 0, + NULL); } void CombineUIPass::draw() { - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Combine UI", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Combine UI", color); - VkViewport viewport = {0.0, + RHIViewport viewport = {0.0, 0.0, - static_cast(m_vulkan_rhi->m_swapchain_extent.width), - static_cast(m_vulkan_rhi->m_swapchain_extent.height), + static_cast(m_rhi->getSwapchainInfo().extent.width), + static_cast(m_rhi->getSwapchainInfo().extent.height), 0.0, 1.0}; - VkRect2D scissor = {0, 0, m_vulkan_rhi->m_swapchain_extent.width, m_vulkan_rhi->m_swapchain_extent.height}; - - m_vulkan_rhi->m_vk_cmd_bind_pipeline( - m_vulkan_rhi->m_current_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[0].pipeline); - m_vulkan_rhi->m_vk_cmd_set_viewport(m_vulkan_rhi->m_current_command_buffer, 0, 1, &viewport); - m_vulkan_rhi->m_vk_cmd_set_scissor(m_vulkan_rhi->m_current_command_buffer, 0, 1, &scissor); - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].layout, - 0, - 1, - &m_descriptor_infos[0].descriptor_set, - 0, - NULL); - - vkCmdDraw(m_vulkan_rhi->m_current_command_buffer, 3, 1, 0, 0); - - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + RHIRect2D scissor = {0, 0, m_rhi->getSwapchainInfo().extent.width, m_rhi->getSwapchainInfo().extent.height}; + + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), RHI_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[0].pipeline); + m_rhi->cmdSetViewportPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, &viewport); + m_rhi->cmdSetScissorPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, &scissor); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[0].layout, + 0, + 1, + &m_descriptor_infos[0].descriptor_set, + 0, + NULL); + + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), 3, 1, 0, 0); + + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } } // namespace Piccolo diff --git a/engine/source/runtime/function/render/passes/combine_ui_pass.h b/engine/source/runtime/function/render/passes/combine_ui_pass.h index 61464f6dc..a125a3e9e 100644 --- a/engine/source/runtime/function/render/passes/combine_ui_pass.h +++ b/engine/source/runtime/function/render/passes/combine_ui_pass.h @@ -6,9 +6,9 @@ namespace Piccolo { struct CombineUIPassInitInfo : RenderPassInitInfo { - VkRenderPass render_pass; - VkImageView scene_input_attachment; - VkImageView ui_input_attachment; + RHIRenderPass* render_pass; + RHIImageView* scene_input_attachment; + RHIImageView* ui_input_attachment; }; class CombineUIPass : public RenderPass @@ -17,7 +17,7 @@ namespace Piccolo void initialize(const RenderPassInitInfo* init_info) override final; void draw() override final; - void updateAfterFramebufferRecreate(VkImageView scene_input_attachment, VkImageView ui_input_attachment); + void updateAfterFramebufferRecreate(RHIImageView* scene_input_attachment, RHIImageView* ui_input_attachment); private: void setupDescriptorSetLayout(); diff --git a/engine/source/runtime/function/render/passes/directional_light_pass.cpp b/engine/source/runtime/function/render/passes/directional_light_pass.cpp index b0760e6e9..ca0dccf5f 100644 --- a/engine/source/runtime/function/render/passes/directional_light_pass.cpp +++ b/engine/source/runtime/function/render/passes/directional_light_pass.cpp @@ -1,9 +1,9 @@ +#include "runtime/function/render/passes/directional_light_pass.h" + #include "runtime/function/render/render_helper.h" #include "runtime/function/render/render_mesh.h" -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" - -#include "runtime/function/render/passes/directional_light_pass.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" #include #include @@ -42,107 +42,103 @@ namespace Piccolo m_framebuffer.attachments.resize(2); // color - m_framebuffer.attachments[0].format = VK_FORMAT_R32_SFLOAT; - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - s_directional_light_shadow_map_dimension, - s_directional_light_shadow_map_dimension, - m_framebuffer.attachments[0].format, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_framebuffer.attachments[0].image, - m_framebuffer.attachments[0].mem, - 0, - 1, - 1); - m_framebuffer.attachments[0].view = VulkanUtil::createImageView(m_vulkan_rhi->m_device, - m_framebuffer.attachments[0].image, - m_framebuffer.attachments[0].format, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_VIEW_TYPE_2D, - 1, - 1); + m_framebuffer.attachments[0].format = RHI_FORMAT_R32_SFLOAT; + m_rhi->createImage(s_directional_light_shadow_map_dimension, + s_directional_light_shadow_map_dimension, + m_framebuffer.attachments[0].format, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | RHI_IMAGE_USAGE_SAMPLED_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_framebuffer.attachments[0].image, + m_framebuffer.attachments[0].mem, + 0, + 1, + 1); + m_rhi->createImageView(m_framebuffer.attachments[0].image, + m_framebuffer.attachments[0].format, + RHI_IMAGE_ASPECT_COLOR_BIT, + RHI_IMAGE_VIEW_TYPE_2D, + 1, + 1, + m_framebuffer.attachments[0].view); // depth - m_framebuffer.attachments[1].format = m_vulkan_rhi->m_depth_image_format; - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - s_directional_light_shadow_map_dimension, - s_directional_light_shadow_map_dimension, + m_framebuffer.attachments[1].format = m_rhi->getDepthImageInfo().depth_image_format; + m_rhi->createImage(s_directional_light_shadow_map_dimension, + s_directional_light_shadow_map_dimension, + m_framebuffer.attachments[1].format, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | RHI_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_framebuffer.attachments[1].image, + m_framebuffer.attachments[1].mem, + 0, + 1, + 1); + m_rhi->createImageView(m_framebuffer.attachments[1].image, m_framebuffer.attachments[1].format, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_framebuffer.attachments[1].image, - m_framebuffer.attachments[1].mem, - 0, + RHI_IMAGE_ASPECT_DEPTH_BIT, + RHI_IMAGE_VIEW_TYPE_2D, + 1, 1, - 1); - m_framebuffer.attachments[1].view = VulkanUtil::createImageView(m_vulkan_rhi->m_device, - m_framebuffer.attachments[1].image, - m_framebuffer.attachments[1].format, - VK_IMAGE_ASPECT_DEPTH_BIT, - VK_IMAGE_VIEW_TYPE_2D, - 1, - 1); + m_framebuffer.attachments[1].view); } void DirectionalLightShadowPass::setupRenderPass() { - VkAttachmentDescription attachments[2] = {}; + RHIAttachmentDescription attachments[2] = {}; - VkAttachmentDescription& directional_light_shadow_color_attachment_description = attachments[0]; + RHIAttachmentDescription& directional_light_shadow_color_attachment_description = attachments[0]; directional_light_shadow_color_attachment_description.format = m_framebuffer.attachments[0].format; - directional_light_shadow_color_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - directional_light_shadow_color_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - directional_light_shadow_color_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_STORE; - directional_light_shadow_color_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - directional_light_shadow_color_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - directional_light_shadow_color_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - directional_light_shadow_color_attachment_description.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - - VkAttachmentDescription& directional_light_shadow_depth_attachment_description = attachments[1]; + directional_light_shadow_color_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + directional_light_shadow_color_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + directional_light_shadow_color_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_STORE; + directional_light_shadow_color_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + directional_light_shadow_color_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + directional_light_shadow_color_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + directional_light_shadow_color_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + RHIAttachmentDescription& directional_light_shadow_depth_attachment_description = attachments[1]; directional_light_shadow_depth_attachment_description.format = m_framebuffer.attachments[1].format; - directional_light_shadow_depth_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - directional_light_shadow_depth_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - directional_light_shadow_depth_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - directional_light_shadow_depth_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - directional_light_shadow_depth_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - directional_light_shadow_depth_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + directional_light_shadow_depth_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + directional_light_shadow_depth_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + directional_light_shadow_depth_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + directional_light_shadow_depth_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + directional_light_shadow_depth_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + directional_light_shadow_depth_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; directional_light_shadow_depth_attachment_description.finalLayout = - VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - VkSubpassDescription subpasses[1] = {}; + RHISubpassDescription subpasses[1] = {}; - VkAttachmentReference shadow_pass_color_attachment_reference {}; + RHIAttachmentReference shadow_pass_color_attachment_reference {}; shadow_pass_color_attachment_reference.attachment = &directional_light_shadow_color_attachment_description - attachments; - shadow_pass_color_attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + shadow_pass_color_attachment_reference.layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - VkAttachmentReference shadow_pass_depth_attachment_reference {}; + RHIAttachmentReference shadow_pass_depth_attachment_reference {}; shadow_pass_depth_attachment_reference.attachment = &directional_light_shadow_depth_attachment_description - attachments; - shadow_pass_depth_attachment_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + shadow_pass_depth_attachment_reference.layout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - VkSubpassDescription& shadow_pass = subpasses[0]; - shadow_pass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + RHISubpassDescription& shadow_pass = subpasses[0]; + shadow_pass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; shadow_pass.colorAttachmentCount = 1; shadow_pass.pColorAttachments = &shadow_pass_color_attachment_reference; shadow_pass.pDepthStencilAttachment = &shadow_pass_depth_attachment_reference; - VkSubpassDependency dependencies[1] = {}; + RHISubpassDependency dependencies[1] = {}; - VkSubpassDependency& lighting_pass_dependency = dependencies[0]; + RHISubpassDependency& lighting_pass_dependency = dependencies[0]; lighting_pass_dependency.srcSubpass = 0; - lighting_pass_dependency.dstSubpass = VK_SUBPASS_EXTERNAL; - lighting_pass_dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; - lighting_pass_dependency.dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; - lighting_pass_dependency.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; // STORE_OP_STORE + lighting_pass_dependency.dstSubpass = RHI_SUBPASS_EXTERNAL; + lighting_pass_dependency.srcStageMask = RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + lighting_pass_dependency.dstStageMask = RHI_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; + lighting_pass_dependency.srcAccessMask = RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; // STORE_OP_STORE lighting_pass_dependency.dstAccessMask = 0; lighting_pass_dependency.dependencyFlags = 0; // NOT BY REGION - VkRenderPassCreateInfo renderpass_create_info {}; - renderpass_create_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + RHIRenderPassCreateInfo renderpass_create_info {}; + renderpass_create_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; renderpass_create_info.attachmentCount = (sizeof(attachments) / sizeof(attachments[0])); renderpass_create_info.pAttachments = attachments; renderpass_create_info.subpassCount = (sizeof(subpasses) / sizeof(subpasses[0])); @@ -150,18 +146,17 @@ namespace Piccolo renderpass_create_info.dependencyCount = (sizeof(dependencies) / sizeof(dependencies[0])); renderpass_create_info.pDependencies = dependencies; - if (vkCreateRenderPass(m_vulkan_rhi->m_device, &renderpass_create_info, nullptr, &m_framebuffer.render_pass) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createRenderPass(&renderpass_create_info, m_framebuffer.render_pass)) { throw std::runtime_error("create directional light shadow render pass"); } } void DirectionalLightShadowPass::setupFramebuffer() { - VkImageView attachments[2] = {m_framebuffer.attachments[0].view, m_framebuffer.attachments[1].view}; + RHIImageView* attachments[2] = {m_framebuffer.attachments[0].view, m_framebuffer.attachments[1].view}; - VkFramebufferCreateInfo framebuffer_create_info {}; - framebuffer_create_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + RHIFramebufferCreateInfo framebuffer_create_info {}; + framebuffer_create_info.sType = RHI_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; framebuffer_create_info.flags = 0U; framebuffer_create_info.renderPass = m_framebuffer.render_pass; framebuffer_create_info.attachmentCount = (sizeof(attachments) / sizeof(attachments[0])); @@ -170,8 +165,7 @@ namespace Piccolo framebuffer_create_info.height = s_directional_light_shadow_map_dimension; framebuffer_create_info.layers = 1; - if (vkCreateFramebuffer( - m_vulkan_rhi->m_device, &framebuffer_create_info, nullptr, &m_framebuffer.framebuffer) != VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createFramebuffer(&framebuffer_create_info, m_framebuffer.framebuffer)) { throw std::runtime_error("create directional light shadow framebuffer"); } @@ -180,39 +174,39 @@ namespace Piccolo { m_descriptor_infos.resize(1); - VkDescriptorSetLayoutBinding mesh_directional_light_shadow_global_layout_bindings[3]; + RHIDescriptorSetLayoutBinding mesh_directional_light_shadow_global_layout_bindings[3]; - VkDescriptorSetLayoutBinding& mesh_directional_light_shadow_global_layout_perframe_storage_buffer_binding = + RHIDescriptorSetLayoutBinding& mesh_directional_light_shadow_global_layout_perframe_storage_buffer_binding = mesh_directional_light_shadow_global_layout_bindings[0]; mesh_directional_light_shadow_global_layout_perframe_storage_buffer_binding.binding = 0; mesh_directional_light_shadow_global_layout_perframe_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_directional_light_shadow_global_layout_perframe_storage_buffer_binding.descriptorCount = 1; mesh_directional_light_shadow_global_layout_perframe_storage_buffer_binding.stageFlags = - VK_SHADER_STAGE_VERTEX_BIT; + RHI_SHADER_STAGE_VERTEX_BIT; - VkDescriptorSetLayoutBinding& mesh_directional_light_shadow_global_layout_perdrawcall_storage_buffer_binding = + RHIDescriptorSetLayoutBinding& mesh_directional_light_shadow_global_layout_perdrawcall_storage_buffer_binding = mesh_directional_light_shadow_global_layout_bindings[1]; mesh_directional_light_shadow_global_layout_perdrawcall_storage_buffer_binding.binding = 1; mesh_directional_light_shadow_global_layout_perdrawcall_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_directional_light_shadow_global_layout_perdrawcall_storage_buffer_binding.descriptorCount = 1; mesh_directional_light_shadow_global_layout_perdrawcall_storage_buffer_binding.stageFlags = - VK_SHADER_STAGE_VERTEX_BIT; + RHI_SHADER_STAGE_VERTEX_BIT; - VkDescriptorSetLayoutBinding& + RHIDescriptorSetLayoutBinding& mesh_directional_light_shadow_global_layout_per_drawcall_vertex_blending_storage_buffer_binding = mesh_directional_light_shadow_global_layout_bindings[2]; mesh_directional_light_shadow_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.binding = 2; mesh_directional_light_shadow_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_directional_light_shadow_global_layout_per_drawcall_vertex_blending_storage_buffer_binding .descriptorCount = 1; mesh_directional_light_shadow_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.stageFlags = - VK_SHADER_STAGE_VERTEX_BIT; + RHI_SHADER_STAGE_VERTEX_BIT; - VkDescriptorSetLayoutCreateInfo mesh_point_light_shadow_global_layout_create_info; - mesh_point_light_shadow_global_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo mesh_point_light_shadow_global_layout_create_info; + mesh_point_light_shadow_global_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; mesh_point_light_shadow_global_layout_create_info.pNext = NULL; mesh_point_light_shadow_global_layout_create_info.flags = 0; mesh_point_light_shadow_global_layout_create_info.bindingCount = @@ -221,10 +215,7 @@ namespace Piccolo mesh_point_light_shadow_global_layout_create_info.pBindings = mesh_directional_light_shadow_global_layout_bindings; - if (VK_SUCCESS != vkCreateDescriptorSetLayout(m_vulkan_rhi->m_device, - &mesh_point_light_shadow_global_layout_create_info, - NULL, - &m_descriptor_infos[0].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&mesh_point_light_shadow_global_layout_create_info, m_descriptor_infos[0].layout)) { throw std::runtime_error("create mesh directional light shadow global layout"); } @@ -233,98 +224,96 @@ namespace Piccolo { m_render_pipelines.resize(1); - VkDescriptorSetLayout descriptorset_layouts[] = {m_descriptor_infos[0].layout, m_per_mesh_layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayout* descriptorset_layouts[] = {m_descriptor_infos[0].layout, m_per_mesh_layout}; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = (sizeof(descriptorset_layouts) / sizeof(descriptorset_layouts[0])); pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout( - m_vulkan_rhi->m_device, &pipeline_layout_create_info, nullptr, &m_render_pipelines[0].layout) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[0].layout)) { throw std::runtime_error("create mesh directional light shadow pipeline layout"); } - VkShaderModule vert_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, MESH_DIRECTIONAL_LIGHT_SHADOW_VERT); - VkShaderModule frag_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, MESH_DIRECTIONAL_LIGHT_SHADOW_FRAG); + RHIShader* vert_shader_module = + m_rhi->createShaderModule(MESH_DIRECTIONAL_LIGHT_SHADOW_VERT); + RHIShader* frag_shader_module = + m_rhi->createShaderModule(MESH_DIRECTIONAL_LIGHT_SHADOW_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; auto vertex_binding_descriptions = MeshVertex::getBindingDescriptions(); auto vertex_attribute_descriptions = MeshVertex::getAttributeDescriptions(); - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = 1; vertex_input_state_create_info.pVertexBindingDescriptions = &vertex_binding_descriptions[0]; vertex_input_state_create_info.vertexAttributeDescriptionCount = 1; vertex_input_state_create_info.pVertexAttributeDescriptions = &vertex_attribute_descriptions[0]; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkViewport viewport = { + RHIViewport viewport = { 0, 0, s_directional_light_shadow_map_dimension, s_directional_light_shadow_map_dimension, 0.0, 1.0}; - VkRect2D scissor = {{0, 0}, + RHIRect2D scissor = {{0, 0}, {s_directional_light_shadow_map_dimension, s_directional_light_shadow_map_dimension}}; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; viewport_state_create_info.pViewports = &viewport; viewport_state_create_info.scissorCount = 1; viewport_state_create_info.pScissors = &scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_BACK_BIT; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_BACK_BIT; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_COUNTER_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; - VkPipelineColorBlendAttachmentState color_blend_attachment_state {}; + RHIPipelineColorBlendAttachmentState color_blend_attachment_state {}; color_blend_attachment_state.colorWriteMask = - VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachment_state.blendEnable = VK_FALSE; - color_blend_attachment_state.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachment_state.blendEnable = RHI_FALSE; + color_blend_attachment_state.srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachment_state.srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = 1; color_blend_state_create_info.pAttachments = &color_blend_attachment_state; color_blend_state_create_info.blendConstants[0] = 0.0f; @@ -332,21 +321,21 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_TRUE; - depth_stencil_create_info.depthWriteEnable = VK_TRUE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_TRUE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 0; dynamic_state_create_info.pDynamicStates = NULL; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = (sizeof(shader_stages) / sizeof(shader_stages[0])); pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -359,36 +348,32 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[0].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = 0; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines( - m_vulkan_rhi->m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_render_pipelines[0].pipeline) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, 1, &pipelineInfo, m_render_pipelines[0].pipeline)) { throw std::runtime_error("create mesh directional light shadow graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); } void DirectionalLightShadowPass::setupDescriptorSet() { - VkDescriptorSetAllocateInfo mesh_directional_light_shadow_global_descriptor_set_alloc_info; + RHIDescriptorSetAllocateInfo mesh_directional_light_shadow_global_descriptor_set_alloc_info; mesh_directional_light_shadow_global_descriptor_set_alloc_info.sType = - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; mesh_directional_light_shadow_global_descriptor_set_alloc_info.pNext = NULL; - mesh_directional_light_shadow_global_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + mesh_directional_light_shadow_global_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); mesh_directional_light_shadow_global_descriptor_set_alloc_info.descriptorSetCount = 1; mesh_directional_light_shadow_global_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[0].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &mesh_directional_light_shadow_global_descriptor_set_alloc_info, - &m_descriptor_infos[0].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&mesh_directional_light_shadow_global_descriptor_set_alloc_info, m_descriptor_infos[0].descriptor_set)) { throw std::runtime_error("allocate mesh directional light shadow global descriptor set"); } - VkDescriptorBufferInfo mesh_directional_light_shadow_perframe_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_directional_light_shadow_perframe_storage_buffer_info = {}; // this offset plus dynamic_offset should not be greater than the size of the buffer mesh_directional_light_shadow_perframe_storage_buffer_info.offset = 0; // the range means the size actually used by the shader per draw call @@ -399,7 +384,7 @@ namespace Piccolo assert(mesh_directional_light_shadow_perframe_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorBufferInfo mesh_directional_light_shadow_perdrawcall_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_directional_light_shadow_perdrawcall_storage_buffer_info = {}; mesh_directional_light_shadow_perdrawcall_storage_buffer_info.offset = 0; mesh_directional_light_shadow_perdrawcall_storage_buffer_info.range = sizeof(MeshDirectionalLightShadowPerdrawcallStorageBufferObject); @@ -408,7 +393,7 @@ namespace Piccolo assert(mesh_directional_light_shadow_perdrawcall_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorBufferInfo mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_info = {}; mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_info.offset = 0; mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_info.range = sizeof(MeshDirectionalLightShadowPerdrawcallVertexBlendingStorageBufferObject); @@ -417,56 +402,55 @@ namespace Piccolo assert(mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorSet descriptor_set_to_write = m_descriptor_infos[0].descriptor_set; + RHIDescriptorSet* descriptor_set_to_write = m_descriptor_infos[0].descriptor_set; - VkWriteDescriptorSet descriptor_writes[3]; + RHIWriteDescriptorSet descriptor_writes[3]; - VkWriteDescriptorSet& mesh_directional_light_shadow_perframe_storage_buffer_write_info = descriptor_writes[0]; - mesh_directional_light_shadow_perframe_storage_buffer_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHIWriteDescriptorSet& mesh_directional_light_shadow_perframe_storage_buffer_write_info = descriptor_writes[0]; + mesh_directional_light_shadow_perframe_storage_buffer_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_directional_light_shadow_perframe_storage_buffer_write_info.pNext = NULL; mesh_directional_light_shadow_perframe_storage_buffer_write_info.dstSet = descriptor_set_to_write; mesh_directional_light_shadow_perframe_storage_buffer_write_info.dstBinding = 0; mesh_directional_light_shadow_perframe_storage_buffer_write_info.dstArrayElement = 0; mesh_directional_light_shadow_perframe_storage_buffer_write_info.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_directional_light_shadow_perframe_storage_buffer_write_info.descriptorCount = 1; mesh_directional_light_shadow_perframe_storage_buffer_write_info.pBufferInfo = &mesh_directional_light_shadow_perframe_storage_buffer_info; - VkWriteDescriptorSet& mesh_directional_light_shadow_perdrawcall_storage_buffer_write_info = + RHIWriteDescriptorSet& mesh_directional_light_shadow_perdrawcall_storage_buffer_write_info = descriptor_writes[1]; mesh_directional_light_shadow_perdrawcall_storage_buffer_write_info.sType = - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_directional_light_shadow_perdrawcall_storage_buffer_write_info.pNext = NULL; mesh_directional_light_shadow_perdrawcall_storage_buffer_write_info.dstSet = descriptor_set_to_write; mesh_directional_light_shadow_perdrawcall_storage_buffer_write_info.dstBinding = 1; mesh_directional_light_shadow_perdrawcall_storage_buffer_write_info.dstArrayElement = 0; mesh_directional_light_shadow_perdrawcall_storage_buffer_write_info.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_directional_light_shadow_perdrawcall_storage_buffer_write_info.descriptorCount = 1; mesh_directional_light_shadow_perdrawcall_storage_buffer_write_info.pBufferInfo = &mesh_directional_light_shadow_perdrawcall_storage_buffer_info; - VkWriteDescriptorSet& mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info = + RHIWriteDescriptorSet& mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info = descriptor_writes[2]; mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.sType = - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.pNext = NULL; mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.dstSet = descriptor_set_to_write; mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.dstBinding = 2; mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.dstArrayElement = 0; mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.descriptorCount = 1; mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.pBufferInfo = &mesh_directional_light_shadow_per_drawcall_vertex_blending_storage_buffer_info; - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - (sizeof(descriptor_writes) / sizeof(descriptor_writes[0])), - descriptor_writes, - 0, - NULL); + m_rhi->updateDescriptorSets((sizeof(descriptor_writes) / sizeof(descriptor_writes[0])), + descriptor_writes, + 0, + NULL); } void DirectionalLightShadowPass::drawModel() { @@ -499,61 +483,48 @@ namespace Piccolo // Directional Light Shadow begin pass { - VkRenderPassBeginInfo renderpass_begin_info {}; - renderpass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + RHIRenderPassBeginInfo renderpass_begin_info {}; + renderpass_begin_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; renderpass_begin_info.renderPass = m_framebuffer.render_pass; renderpass_begin_info.framebuffer = m_framebuffer.framebuffer; renderpass_begin_info.renderArea.offset = {0, 0}; renderpass_begin_info.renderArea.extent = {s_directional_light_shadow_map_dimension, s_directional_light_shadow_map_dimension}; - VkClearValue clear_values[2]; + RHIClearValue clear_values[2]; clear_values[0].color = {1.0f}; clear_values[1].depthStencil = {1.0f, 0}; renderpass_begin_info.clearValueCount = (sizeof(clear_values) / sizeof(clear_values[0])); renderpass_begin_info.pClearValues = clear_values; - m_vulkan_rhi->m_vk_cmd_begin_render_pass( - m_vulkan_rhi->m_current_command_buffer, &renderpass_begin_info, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdBeginRenderPassPFN(m_rhi->getCurrentCommandBuffer(), &renderpass_begin_info, RHI_SUBPASS_CONTENTS_INLINE); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = {VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, - NULL, - "Directional Light Shadow", - {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Directional Light Shadow", color); } // Mesh - // if (m_vulkan_rhi->isPointLightShadowEnabled()) + if (m_rhi->isPointLightShadowEnabled()) { - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Mesh", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Mesh", color); - m_vulkan_rhi->m_vk_cmd_bind_pipeline(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].pipeline); + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), RHI_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[0].pipeline); // perframe storage buffer uint32_t perframe_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perframe_dynamic_offset + sizeof(MeshPerframeStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshDirectionalLightShadowPerframeStorageBufferObject& perframe_storage_buffer_object = (*reinterpret_cast( @@ -572,21 +543,19 @@ namespace Piccolo if (total_instance_count > 0) { // bind per mesh - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].layout, - 1, - 1, - &mesh->mesh_vertex_blending_descriptor_set, - 0, - NULL); - - VkBuffer vertex_buffers[] = {mesh->mesh_vertex_position_buffer}; - VkDeviceSize offsets[] = {0}; - m_vulkan_rhi->m_vk_cmd_bind_vertex_buffers( - m_vulkan_rhi->m_current_command_buffer, 0, 1, vertex_buffers, offsets); - m_vulkan_rhi->m_vk_cmd_bind_index_buffer( - m_vulkan_rhi->m_current_command_buffer, mesh->mesh_index_buffer, 0, VK_INDEX_TYPE_UINT16); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[0].layout, + 1, + 1, + &mesh->mesh_vertex_blending_descriptor_set, + 0, + NULL); + + RHIBuffer* vertex_buffers[] = {mesh->mesh_vertex_position_buffer}; + RHIDeviceSize offsets[] = {0}; + m_rhi->cmdBindVertexBuffersPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, vertex_buffers, offsets); + m_rhi->cmdBindIndexBufferPFN(m_rhi->getCurrentCommandBuffer(), mesh->mesh_index_buffer, 0, RHI_INDEX_TYPE_UINT16); uint32_t drawcall_max_instance_count = (sizeof(MeshDirectionalLightShadowPerdrawcallStorageBufferObject::mesh_instances) / @@ -605,18 +574,18 @@ namespace Piccolo // perdrawcall storage buffer uint32_t perdrawcall_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perdrawcall_dynamic_offset + sizeof(MeshDirectionalLightShadowPerdrawcallStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshDirectionalLightShadowPerdrawcallStorageBufferObject& perdrawcall_storage_buffer_object = @@ -648,18 +617,18 @@ namespace Piccolo { per_drawcall_vertex_blending_dynamic_offset = roundUp( m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = per_drawcall_vertex_blending_dynamic_offset + sizeof(MeshDirectionalLightShadowPerdrawcallVertexBlendingStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshDirectionalLightShadowPerdrawcallVertexBlendingStorageBufferObject& per_drawcall_vertex_blending_storage_buffer_object = @@ -694,40 +663,33 @@ namespace Piccolo uint32_t dynamic_offsets[3] = {perframe_dynamic_offset, perdrawcall_dynamic_offset, per_drawcall_vertex_blending_dynamic_offset}; - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets( - m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].layout, - 0, - 1, - &m_descriptor_infos[0].descriptor_set, - (sizeof(dynamic_offsets) / sizeof(dynamic_offsets[0])), - dynamic_offsets); - m_vulkan_rhi->m_vk_cmd_draw_indexed(m_vulkan_rhi->m_current_command_buffer, - mesh->mesh_index_count, - current_instance_count, - 0, - 0, - 0); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[0].layout, + 0, + 1, + &m_descriptor_infos[0].descriptor_set, + (sizeof(dynamic_offsets) / sizeof(dynamic_offsets[0])), + dynamic_offsets); + m_rhi->cmdDrawIndexedPFN(m_rhi->getCurrentCommandBuffer(), + mesh->mesh_index_count, + current_instance_count, + 0, + 0, + 0); } } } } - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } // Directional Light Shadow end pass { - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); - m_vulkan_rhi->m_vk_cmd_end_render_pass(m_vulkan_rhi->m_current_command_buffer); + m_rhi->cmdEndRenderPassPFN(m_rhi->getCurrentCommandBuffer()); } } } // namespace Piccolo diff --git a/engine/source/runtime/function/render/passes/directional_light_pass.h b/engine/source/runtime/function/render/passes/directional_light_pass.h index 504b9a9c1..02b16b12f 100644 --- a/engine/source/runtime/function/render/passes/directional_light_pass.h +++ b/engine/source/runtime/function/render/passes/directional_light_pass.h @@ -14,7 +14,7 @@ namespace Piccolo void preparePassData(std::shared_ptr render_resource) override final; void draw() override final; - void setPerMeshLayout(const VkDescriptorSetLayout& layout) { m_per_mesh_layout = layout; } + void setPerMeshLayout(RHIDescriptorSetLayout* layout) { m_per_mesh_layout = layout; } private: void setupAttachments(); @@ -26,7 +26,7 @@ namespace Piccolo void drawModel(); private: - VkDescriptorSetLayout m_per_mesh_layout; + RHIDescriptorSetLayout* m_per_mesh_layout; MeshDirectionalLightShadowPerframeStorageBufferObject m_mesh_directional_light_shadow_perframe_storage_buffer_object; }; diff --git a/engine/source/runtime/function/render/passes/fxaa_pass.cpp b/engine/source/runtime/function/render/passes/fxaa_pass.cpp index 72dd756eb..4b0176fa9 100644 --- a/engine/source/runtime/function/render/passes/fxaa_pass.cpp +++ b/engine/source/runtime/function/render/passes/fxaa_pass.cpp @@ -4,13 +4,13 @@ #include "runtime/function/render/render_mesh.h" #include "runtime/function/render/render_pass.h" -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" +#include "runtime/core/base/macro.h" #include #include -#include #include namespace Piccolo @@ -20,7 +20,11 @@ namespace Piccolo RenderPass::initialize(nullptr); const FXAAPassInitInfo* _init_info = static_cast(init_info); - assert(_init_info); + if (init_info == nullptr) + { + LOG_ERROR("fxaa _init_info is nullptr"); + return; + } m_framebuffer.render_pass = _init_info->render_pass; @@ -34,25 +38,23 @@ namespace Piccolo { m_descriptor_infos.resize(1); - VkDescriptorSetLayoutBinding post_process_global_layout_bindings[1] = {}; + RHIDescriptorSetLayoutBinding post_process_global_layout_bindings[1] = {}; - VkDescriptorSetLayoutBinding& post_process_global_layout_in_color = post_process_global_layout_bindings[0]; + RHIDescriptorSetLayoutBinding& post_process_global_layout_in_color = post_process_global_layout_bindings[0]; post_process_global_layout_in_color.binding = 0; - post_process_global_layout_in_color.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + post_process_global_layout_in_color.descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; post_process_global_layout_in_color.descriptorCount = 1; - post_process_global_layout_in_color.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + post_process_global_layout_in_color.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; - VkDescriptorSetLayoutCreateInfo post_process_global_layout_create_info; - post_process_global_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo post_process_global_layout_create_info; + post_process_global_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; post_process_global_layout_create_info.pNext = NULL; post_process_global_layout_create_info.flags = 0; post_process_global_layout_create_info.bindingCount = sizeof(post_process_global_layout_bindings) / sizeof(post_process_global_layout_bindings[0]); post_process_global_layout_create_info.pBindings = post_process_global_layout_bindings; - if (VK_SUCCESS != - vkCreateDescriptorSetLayout( - m_vulkan_rhi->m_device, &post_process_global_layout_create_info, NULL, &m_descriptor_infos[0].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&post_process_global_layout_create_info, m_descriptor_infos[0].layout)) { throw std::runtime_error("create post process global layout"); } @@ -62,89 +64,87 @@ namespace Piccolo { m_render_pipelines.resize(1); - VkDescriptorSetLayout descriptorset_layouts[1] = {m_descriptor_infos[0].layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayout* descriptorset_layouts[1] = {m_descriptor_infos[0].layout}; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = 1; pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout( - m_vulkan_rhi->m_device, &pipeline_layout_create_info, nullptr, &m_render_pipelines[0].layout) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[0].layout)) { throw std::runtime_error("create post process pipeline layout"); } - VkShaderModule vert_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, FXAA_VERT); - VkShaderModule frag_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, FXAA_FRAG); + RHIShader* vert_shader_module = m_rhi->createShaderModule(FXAA_VERT); + RHIShader* frag_shader_module = m_rhi->createShaderModule(FXAA_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = 0; vertex_input_state_create_info.pVertexBindingDescriptions = NULL; vertex_input_state_create_info.vertexAttributeDescriptionCount = 0; vertex_input_state_create_info.pVertexAttributeDescriptions = NULL; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_BACK_BIT; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_BACK_BIT; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; - VkPipelineColorBlendAttachmentState color_blend_attachment_state {}; + RHIPipelineColorBlendAttachmentState color_blend_attachment_state {}; color_blend_attachment_state.colorWriteMask = - VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachment_state.blendEnable = VK_FALSE; - color_blend_attachment_state.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachment_state.blendEnable = RHI_FALSE; + color_blend_attachment_state.srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachment_state.srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = 1; color_blend_state_create_info.pAttachments = &color_blend_attachment_state; color_blend_state_create_info.blendConstants[0] = 0.0f; @@ -152,23 +152,23 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_TRUE; - depth_stencil_create_info.depthWriteEnable = VK_TRUE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_TRUE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; - VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; + RHIDynamicState dynamic_states[] = {RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR}; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 2; dynamic_state_create_info.pDynamicStates = dynamic_states; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -181,106 +181,92 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[0].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = _main_camera_subpass_fxaa; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines( - m_vulkan_rhi->m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_render_pipelines[0].pipeline) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, 1, &pipelineInfo, m_render_pipelines[0].pipeline)) { throw std::runtime_error("create post process graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } void FXAAPass::setupDescriptorSet() { - VkDescriptorSetAllocateInfo post_process_global_descriptor_set_alloc_info; - post_process_global_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHIDescriptorSetAllocateInfo post_process_global_descriptor_set_alloc_info; + post_process_global_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; post_process_global_descriptor_set_alloc_info.pNext = NULL; - post_process_global_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + post_process_global_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); post_process_global_descriptor_set_alloc_info.descriptorSetCount = 1; post_process_global_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[0].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &post_process_global_descriptor_set_alloc_info, - &m_descriptor_infos[0].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&post_process_global_descriptor_set_alloc_info, m_descriptor_infos[0].descriptor_set)) { throw std::runtime_error("allocate post process global descriptor set"); } } - void FXAAPass::updateAfterFramebufferRecreate(VkImageView input_attachment) + void FXAAPass::updateAfterFramebufferRecreate(RHIImageView* input_attachment) { - VkDescriptorImageInfo post_process_per_frame_input_attachment_info = {}; - post_process_per_frame_input_attachment_info.sampler = - VulkanUtil::getOrCreateLinearSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); + RHIDescriptorImageInfo post_process_per_frame_input_attachment_info = {}; + post_process_per_frame_input_attachment_info.sampler = m_rhi->getOrCreateDefaultSampler(Default_Sampler_Linear); post_process_per_frame_input_attachment_info.imageView = input_attachment; - post_process_per_frame_input_attachment_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + post_process_per_frame_input_attachment_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkWriteDescriptorSet post_process_descriptor_writes_info[1]; + RHIWriteDescriptorSet post_process_descriptor_writes_info[1]; - VkWriteDescriptorSet& post_process_descriptor_input_attachment_write_info = + RHIWriteDescriptorSet& post_process_descriptor_input_attachment_write_info = post_process_descriptor_writes_info[0]; - post_process_descriptor_input_attachment_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + post_process_descriptor_input_attachment_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; post_process_descriptor_input_attachment_write_info.pNext = NULL; post_process_descriptor_input_attachment_write_info.dstSet = m_descriptor_infos[0].descriptor_set; post_process_descriptor_input_attachment_write_info.dstBinding = 0; post_process_descriptor_input_attachment_write_info.dstArrayElement = 0; - post_process_descriptor_input_attachment_write_info.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + post_process_descriptor_input_attachment_write_info.descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; post_process_descriptor_input_attachment_write_info.descriptorCount = 1; post_process_descriptor_input_attachment_write_info.pImageInfo = &post_process_per_frame_input_attachment_info; - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - sizeof(post_process_descriptor_writes_info) / - sizeof(post_process_descriptor_writes_info[0]), - post_process_descriptor_writes_info, - 0, - NULL); + m_rhi->updateDescriptorSets(sizeof(post_process_descriptor_writes_info) / + sizeof(post_process_descriptor_writes_info[0]), + post_process_descriptor_writes_info, + 0, + NULL); } void FXAAPass::draw() { - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "FXAA", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "FXAA", color); - VkViewport viewport = {0.0, + RHIViewport viewport = {0.0, 0.0, - static_cast(m_vulkan_rhi->m_swapchain_extent.width), - static_cast(m_vulkan_rhi->m_swapchain_extent.height), + static_cast(m_rhi->getSwapchainInfo().extent.width), + static_cast(m_rhi->getSwapchainInfo().extent.height), 0.0, 1.0}; - int32_t x = static_cast(m_vulkan_rhi->m_viewport.x); - int32_t y = static_cast(m_vulkan_rhi->m_viewport.y); - uint32_t width = static_cast(m_vulkan_rhi->m_viewport.width); - uint32_t height = static_cast(m_vulkan_rhi->m_viewport.height); - VkRect2D scissor = {x, y, width, height}; - - m_vulkan_rhi->m_vk_cmd_bind_pipeline( - m_vulkan_rhi->m_current_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[0].pipeline); - m_vulkan_rhi->m_vk_cmd_set_viewport(m_vulkan_rhi->m_current_command_buffer, 0, 1, &viewport); - m_vulkan_rhi->m_vk_cmd_set_scissor(m_vulkan_rhi->m_current_command_buffer, 0, 1, &scissor); - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].layout, - 0, - 1, - &m_descriptor_infos[0].descriptor_set, - 0, - NULL); - - vkCmdDraw(m_vulkan_rhi->m_current_command_buffer, 3, 1, 0, 0); - - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + int32_t x = static_cast(m_rhi->getSwapchainInfo().viewport->x); + int32_t y = static_cast(m_rhi->getSwapchainInfo().viewport->y); + uint32_t width = static_cast(m_rhi->getSwapchainInfo().viewport->width); + uint32_t height = static_cast(m_rhi->getSwapchainInfo().viewport->height); + RHIRect2D scissor = {x, y, width, height}; + + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), RHI_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[0].pipeline); + m_rhi->cmdSetViewportPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, &viewport); + m_rhi->cmdSetScissorPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, &scissor); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[0].layout, + 0, + 1, + &m_descriptor_infos[0].descriptor_set, + 0, + NULL); + + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), 3, 1, 0, 0); + + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } } // namespace Piccolo diff --git a/engine/source/runtime/function/render/passes/fxaa_pass.h b/engine/source/runtime/function/render/passes/fxaa_pass.h index f351fe8c2..cef02231e 100644 --- a/engine/source/runtime/function/render/passes/fxaa_pass.h +++ b/engine/source/runtime/function/render/passes/fxaa_pass.h @@ -8,8 +8,8 @@ namespace Piccolo struct FXAAPassInitInfo : RenderPassInitInfo { - VkRenderPass render_pass; - VkImageView input_attachment; + RHIRenderPass* render_pass; + RHIImageView* input_attachment; }; class FXAAPass : public RenderPass @@ -18,7 +18,7 @@ namespace Piccolo void initialize(const RenderPassInitInfo* init_info) override final; void draw() override final; - void updateAfterFramebufferRecreate(VkImageView input_attachment); + void updateAfterFramebufferRecreate(RHIImageView* input_attachment); private: void setupDescriptorSetLayout(); diff --git a/engine/source/runtime/function/render/passes/main_camera_pass.cpp b/engine/source/runtime/function/render/passes/main_camera_pass.cpp index 542d5cee4..3300e4638 100644 --- a/engine/source/runtime/function/render/passes/main_camera_pass.cpp +++ b/engine/source/runtime/function/render/passes/main_camera_pass.cpp @@ -3,8 +3,8 @@ #include "runtime/function/render/render_mesh.h" #include "runtime/function/render/render_resource.h" -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" #include #include @@ -54,216 +54,208 @@ namespace Piccolo m_framebuffer.attachments.resize(_main_camera_pass_custom_attachment_count + _main_camera_pass_post_process_attachment_count); - m_framebuffer.attachments[_main_camera_pass_gbuffer_a].format = VK_FORMAT_R8G8B8A8_UNORM; - m_framebuffer.attachments[_main_camera_pass_gbuffer_b].format = VK_FORMAT_R8G8B8A8_UNORM; - m_framebuffer.attachments[_main_camera_pass_gbuffer_c].format = VK_FORMAT_R8G8B8A8_SRGB; - m_framebuffer.attachments[_main_camera_pass_backup_buffer_odd].format = VK_FORMAT_R16G16B16A16_SFLOAT; - m_framebuffer.attachments[_main_camera_pass_backup_buffer_even].format = VK_FORMAT_R16G16B16A16_SFLOAT; + m_framebuffer.attachments[_main_camera_pass_gbuffer_a].format = RHI_FORMAT_R8G8B8A8_UNORM; + m_framebuffer.attachments[_main_camera_pass_gbuffer_b].format = RHI_FORMAT_R8G8B8A8_UNORM; + m_framebuffer.attachments[_main_camera_pass_gbuffer_c].format = RHI_FORMAT_R8G8B8A8_SRGB; + m_framebuffer.attachments[_main_camera_pass_backup_buffer_odd].format = RHI_FORMAT_R16G16B16A16_SFLOAT; + m_framebuffer.attachments[_main_camera_pass_backup_buffer_even].format = RHI_FORMAT_R16G16B16A16_SFLOAT; for (int buffer_index = 0; buffer_index < _main_camera_pass_custom_attachment_count; ++buffer_index) { if (buffer_index == _main_camera_pass_gbuffer_a) { - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - m_vulkan_rhi->m_swapchain_extent.width, - m_vulkan_rhi->m_swapchain_extent.height, - m_framebuffer.attachments[_main_camera_pass_gbuffer_a].format, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | - VK_IMAGE_USAGE_TRANSFER_SRC_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_framebuffer.attachments[_main_camera_pass_gbuffer_a].image, - m_framebuffer.attachments[_main_camera_pass_gbuffer_a].mem, - 0, - 1, - 1); + m_rhi->createImage(m_rhi->getSwapchainInfo().extent.width, + m_rhi->getSwapchainInfo().extent.height, + m_framebuffer.attachments[_main_camera_pass_gbuffer_a].format, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | RHI_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | + RHI_IMAGE_USAGE_TRANSFER_SRC_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_framebuffer.attachments[_main_camera_pass_gbuffer_a].image, + m_framebuffer.attachments[_main_camera_pass_gbuffer_a].mem, + 0, + 1, + 1); } else { - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - m_vulkan_rhi->m_swapchain_extent.width, - m_vulkan_rhi->m_swapchain_extent.height, - m_framebuffer.attachments[buffer_index].format, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_framebuffer.attachments[buffer_index].image, - m_framebuffer.attachments[buffer_index].mem, - 0, - 1, - 1); + m_rhi->createImage(m_rhi->getSwapchainInfo().extent.width, + m_rhi->getSwapchainInfo().extent.height, + m_framebuffer.attachments[buffer_index].format, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | RHI_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | + RHI_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_framebuffer.attachments[buffer_index].image, + m_framebuffer.attachments[buffer_index].mem, + 0, + 1, + 1); } - m_framebuffer.attachments[buffer_index].view = - VulkanUtil::createImageView(m_vulkan_rhi->m_device, - m_framebuffer.attachments[buffer_index].image, - m_framebuffer.attachments[buffer_index].format, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_VIEW_TYPE_2D, - 1, - 1); + m_rhi->createImageView(m_framebuffer.attachments[buffer_index].image, + m_framebuffer.attachments[buffer_index].format, + RHI_IMAGE_ASPECT_COLOR_BIT, + RHI_IMAGE_VIEW_TYPE_2D, + 1, + 1, + m_framebuffer.attachments[buffer_index].view); } - m_framebuffer.attachments[_main_camera_pass_post_process_buffer_odd].format = VK_FORMAT_R16G16B16A16_SFLOAT; - m_framebuffer.attachments[_main_camera_pass_post_process_buffer_even].format = VK_FORMAT_R16G16B16A16_SFLOAT; + m_framebuffer.attachments[_main_camera_pass_post_process_buffer_odd].format = RHI_FORMAT_R16G16B16A16_SFLOAT; + m_framebuffer.attachments[_main_camera_pass_post_process_buffer_even].format = RHI_FORMAT_R16G16B16A16_SFLOAT; for (int attachment_index = _main_camera_pass_custom_attachment_count; attachment_index < _main_camera_pass_custom_attachment_count + _main_camera_pass_post_process_attachment_count; ++attachment_index) { - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - m_vulkan_rhi->m_swapchain_extent.width, - m_vulkan_rhi->m_swapchain_extent.height, - m_framebuffer.attachments[attachment_index].format, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_framebuffer.attachments[attachment_index].image, - m_framebuffer.attachments[attachment_index].mem, - 0, - 1, - 1); - - m_framebuffer.attachments[attachment_index].view = - VulkanUtil::createImageView(m_vulkan_rhi->m_device, - m_framebuffer.attachments[attachment_index].image, - m_framebuffer.attachments[attachment_index].format, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_VIEW_TYPE_2D, - 1, - 1); + m_rhi->createImage(m_rhi->getSwapchainInfo().extent.width, + m_rhi->getSwapchainInfo().extent.height, + m_framebuffer.attachments[attachment_index].format, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | RHI_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | + RHI_IMAGE_USAGE_SAMPLED_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_framebuffer.attachments[attachment_index].image, + m_framebuffer.attachments[attachment_index].mem, + 0, + 1, + 1); + + m_rhi->createImageView(m_framebuffer.attachments[attachment_index].image, + m_framebuffer.attachments[attachment_index].format, + RHI_IMAGE_ASPECT_COLOR_BIT, + RHI_IMAGE_VIEW_TYPE_2D, + 1, + 1, + m_framebuffer.attachments[attachment_index].view); } } void MainCameraPass::setupRenderPass() { - VkAttachmentDescription attachments[_main_camera_pass_attachment_count] = {}; + RHIAttachmentDescription attachments[_main_camera_pass_attachment_count] = {}; - VkAttachmentDescription& gbuffer_normal_attachment_description = attachments[_main_camera_pass_gbuffer_a]; + RHIAttachmentDescription& gbuffer_normal_attachment_description = attachments[_main_camera_pass_gbuffer_a]; gbuffer_normal_attachment_description.format = m_framebuffer.attachments[_main_camera_pass_gbuffer_a].format; - gbuffer_normal_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - gbuffer_normal_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - gbuffer_normal_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_STORE; - gbuffer_normal_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - gbuffer_normal_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - gbuffer_normal_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - gbuffer_normal_attachment_description.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - - VkAttachmentDescription& gbuffer_metallic_roughness_shadingmodeid_attachment_description = + gbuffer_normal_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + gbuffer_normal_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + gbuffer_normal_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_STORE; + gbuffer_normal_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + gbuffer_normal_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + gbuffer_normal_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + gbuffer_normal_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + RHIAttachmentDescription& gbuffer_metallic_roughness_shadingmodeid_attachment_description = attachments[_main_camera_pass_gbuffer_b]; gbuffer_metallic_roughness_shadingmodeid_attachment_description.format = m_framebuffer.attachments[_main_camera_pass_gbuffer_b].format; - gbuffer_metallic_roughness_shadingmodeid_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - gbuffer_metallic_roughness_shadingmodeid_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - gbuffer_metallic_roughness_shadingmodeid_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - gbuffer_metallic_roughness_shadingmodeid_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + gbuffer_metallic_roughness_shadingmodeid_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + gbuffer_metallic_roughness_shadingmodeid_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + gbuffer_metallic_roughness_shadingmodeid_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + gbuffer_metallic_roughness_shadingmodeid_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; gbuffer_metallic_roughness_shadingmodeid_attachment_description.stencilStoreOp = - VK_ATTACHMENT_STORE_OP_DONT_CARE; - gbuffer_metallic_roughness_shadingmodeid_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + RHI_ATTACHMENT_STORE_OP_DONT_CARE; + gbuffer_metallic_roughness_shadingmodeid_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; gbuffer_metallic_roughness_shadingmodeid_attachment_description.finalLayout = - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkAttachmentDescription& gbuffer_albedo_attachment_description = attachments[_main_camera_pass_gbuffer_c]; + RHIAttachmentDescription& gbuffer_albedo_attachment_description = attachments[_main_camera_pass_gbuffer_c]; gbuffer_albedo_attachment_description.format = m_framebuffer.attachments[_main_camera_pass_gbuffer_c].format; - gbuffer_albedo_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - gbuffer_albedo_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - gbuffer_albedo_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - gbuffer_albedo_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - gbuffer_albedo_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - gbuffer_albedo_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - gbuffer_albedo_attachment_description.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - - VkAttachmentDescription& backup_odd_color_attachment_description = + gbuffer_albedo_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + gbuffer_albedo_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + gbuffer_albedo_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + gbuffer_albedo_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + gbuffer_albedo_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + gbuffer_albedo_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + gbuffer_albedo_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + RHIAttachmentDescription& backup_odd_color_attachment_description = attachments[_main_camera_pass_backup_buffer_odd]; backup_odd_color_attachment_description.format = m_framebuffer.attachments[_main_camera_pass_backup_buffer_odd].format; - backup_odd_color_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - backup_odd_color_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - backup_odd_color_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - backup_odd_color_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - backup_odd_color_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - backup_odd_color_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - backup_odd_color_attachment_description.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - - VkAttachmentDescription& backup_even_color_attachment_description = + backup_odd_color_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + backup_odd_color_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + backup_odd_color_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + backup_odd_color_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + backup_odd_color_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + backup_odd_color_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + backup_odd_color_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + RHIAttachmentDescription& backup_even_color_attachment_description = attachments[_main_camera_pass_backup_buffer_even]; backup_even_color_attachment_description.format = m_framebuffer.attachments[_main_camera_pass_backup_buffer_even].format; - backup_even_color_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - backup_even_color_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - backup_even_color_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - backup_even_color_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - backup_even_color_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - backup_even_color_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - backup_even_color_attachment_description.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - - VkAttachmentDescription& post_process_odd_color_attachment_description = + backup_even_color_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + backup_even_color_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + backup_even_color_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + backup_even_color_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + backup_even_color_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + backup_even_color_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + backup_even_color_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + RHIAttachmentDescription& post_process_odd_color_attachment_description = attachments[_main_camera_pass_post_process_buffer_odd]; post_process_odd_color_attachment_description.format = m_framebuffer.attachments[_main_camera_pass_post_process_buffer_odd].format; - post_process_odd_color_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - post_process_odd_color_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - post_process_odd_color_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - post_process_odd_color_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - post_process_odd_color_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - post_process_odd_color_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - post_process_odd_color_attachment_description.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - - VkAttachmentDescription& post_process_even_color_attachment_description = + post_process_odd_color_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + post_process_odd_color_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + post_process_odd_color_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + post_process_odd_color_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + post_process_odd_color_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + post_process_odd_color_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + post_process_odd_color_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + RHIAttachmentDescription& post_process_even_color_attachment_description = attachments[_main_camera_pass_post_process_buffer_even]; post_process_even_color_attachment_description.format = m_framebuffer.attachments[_main_camera_pass_post_process_buffer_even].format; - post_process_even_color_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - post_process_even_color_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - post_process_even_color_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - post_process_even_color_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - post_process_even_color_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - post_process_even_color_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - post_process_even_color_attachment_description.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - - VkAttachmentDescription& depth_attachment_description = attachments[_main_camera_pass_depth]; - depth_attachment_description.format = m_vulkan_rhi->m_depth_image_format; - depth_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - depth_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - depth_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_STORE; - depth_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - depth_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - depth_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - depth_attachment_description.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - - VkAttachmentDescription& swapchain_image_attachment_description = + post_process_even_color_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + post_process_even_color_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + post_process_even_color_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + post_process_even_color_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + post_process_even_color_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + post_process_even_color_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + post_process_even_color_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + RHIAttachmentDescription& depth_attachment_description = attachments[_main_camera_pass_depth]; + depth_attachment_description.format = m_rhi->getDepthImageInfo().depth_image_format; + depth_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + depth_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + depth_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_STORE; + depth_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + depth_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + depth_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + depth_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + + RHIAttachmentDescription& swapchain_image_attachment_description = attachments[_main_camera_pass_swap_chain_image]; - swapchain_image_attachment_description.format = m_vulkan_rhi->m_swapchain_image_format; - swapchain_image_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - swapchain_image_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - swapchain_image_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_STORE; - swapchain_image_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - swapchain_image_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - swapchain_image_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - swapchain_image_attachment_description.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; - - VkSubpassDescription subpasses[_main_camera_subpass_count] = {}; - - VkAttachmentReference base_pass_color_attachments_reference[3] = {}; + swapchain_image_attachment_description.format = m_rhi->getSwapchainInfo().image_format; + swapchain_image_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + swapchain_image_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + swapchain_image_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_STORE; + swapchain_image_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + swapchain_image_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + swapchain_image_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + swapchain_image_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_PRESENT_SRC_KHR; + + RHISubpassDescription subpasses[_main_camera_subpass_count] = {}; + + RHIAttachmentReference base_pass_color_attachments_reference[3] = {}; base_pass_color_attachments_reference[0].attachment = &gbuffer_normal_attachment_description - attachments; - base_pass_color_attachments_reference[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + base_pass_color_attachments_reference[0].layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; base_pass_color_attachments_reference[1].attachment = &gbuffer_metallic_roughness_shadingmodeid_attachment_description - attachments; - base_pass_color_attachments_reference[1].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + base_pass_color_attachments_reference[1].layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; base_pass_color_attachments_reference[2].attachment = &gbuffer_albedo_attachment_description - attachments; - base_pass_color_attachments_reference[2].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + base_pass_color_attachments_reference[2].layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - VkAttachmentReference base_pass_depth_attachment_reference {}; + RHIAttachmentReference base_pass_depth_attachment_reference {}; base_pass_depth_attachment_reference.attachment = &depth_attachment_description - attachments; - base_pass_depth_attachment_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + base_pass_depth_attachment_reference.layout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - VkSubpassDescription& base_pass = subpasses[_main_camera_subpass_basepass]; - base_pass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + RHISubpassDescription& base_pass = subpasses[_main_camera_subpass_basepass]; + base_pass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; base_pass.colorAttachmentCount = sizeof(base_pass_color_attachments_reference) / sizeof(base_pass_color_attachments_reference[0]); base_pass.pColorAttachments = &base_pass_color_attachments_reference[0]; @@ -271,26 +263,26 @@ namespace Piccolo base_pass.preserveAttachmentCount = 0; base_pass.pPreserveAttachments = NULL; - VkAttachmentReference deferred_lighting_pass_input_attachments_reference[4] = {}; + RHIAttachmentReference deferred_lighting_pass_input_attachments_reference[4] = {}; deferred_lighting_pass_input_attachments_reference[0].attachment = &gbuffer_normal_attachment_description - attachments; - deferred_lighting_pass_input_attachments_reference[0].layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + deferred_lighting_pass_input_attachments_reference[0].layout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; deferred_lighting_pass_input_attachments_reference[1].attachment = &gbuffer_metallic_roughness_shadingmodeid_attachment_description - attachments; - deferred_lighting_pass_input_attachments_reference[1].layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + deferred_lighting_pass_input_attachments_reference[1].layout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; deferred_lighting_pass_input_attachments_reference[2].attachment = &gbuffer_albedo_attachment_description - attachments; - deferred_lighting_pass_input_attachments_reference[2].layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + deferred_lighting_pass_input_attachments_reference[2].layout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; deferred_lighting_pass_input_attachments_reference[3].attachment = &depth_attachment_description - attachments; - deferred_lighting_pass_input_attachments_reference[3].layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + deferred_lighting_pass_input_attachments_reference[3].layout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkAttachmentReference deferred_lighting_pass_color_attachment_reference[1] = {}; + RHIAttachmentReference deferred_lighting_pass_color_attachment_reference[1] = {}; deferred_lighting_pass_color_attachment_reference[0].attachment = &backup_odd_color_attachment_description - attachments; - deferred_lighting_pass_color_attachment_reference[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + deferred_lighting_pass_color_attachment_reference[0].layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - VkSubpassDescription& deferred_lighting_pass = subpasses[_main_camera_subpass_deferred_lighting]; - deferred_lighting_pass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + RHISubpassDescription& deferred_lighting_pass = subpasses[_main_camera_subpass_deferred_lighting]; + deferred_lighting_pass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; deferred_lighting_pass.inputAttachmentCount = sizeof(deferred_lighting_pass_input_attachments_reference) / sizeof(deferred_lighting_pass_input_attachments_reference[0]); deferred_lighting_pass.pInputAttachments = &deferred_lighting_pass_input_attachments_reference[0]; @@ -301,17 +293,17 @@ namespace Piccolo deferred_lighting_pass.preserveAttachmentCount = 0; deferred_lighting_pass.pPreserveAttachments = NULL; - VkAttachmentReference forward_lighting_pass_color_attachments_reference[1] = {}; + RHIAttachmentReference forward_lighting_pass_color_attachments_reference[1] = {}; forward_lighting_pass_color_attachments_reference[0].attachment = &backup_odd_color_attachment_description - attachments; - forward_lighting_pass_color_attachments_reference[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + forward_lighting_pass_color_attachments_reference[0].layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - VkAttachmentReference forward_lighting_pass_depth_attachment_reference {}; + RHIAttachmentReference forward_lighting_pass_depth_attachment_reference {}; forward_lighting_pass_depth_attachment_reference.attachment = &depth_attachment_description - attachments; - forward_lighting_pass_depth_attachment_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + forward_lighting_pass_depth_attachment_reference.layout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - VkSubpassDescription& forward_lighting_pass = subpasses[_main_camera_subpass_forward_lighting]; - forward_lighting_pass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + RHISubpassDescription& forward_lighting_pass = subpasses[_main_camera_subpass_forward_lighting]; + forward_lighting_pass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; forward_lighting_pass.inputAttachmentCount = 0U; forward_lighting_pass.pInputAttachments = NULL; forward_lighting_pass.colorAttachmentCount = sizeof(forward_lighting_pass_color_attachments_reference) / @@ -321,18 +313,18 @@ namespace Piccolo forward_lighting_pass.preserveAttachmentCount = 0; forward_lighting_pass.pPreserveAttachments = NULL; - VkAttachmentReference tone_mapping_pass_input_attachment_reference {}; + RHIAttachmentReference tone_mapping_pass_input_attachment_reference {}; tone_mapping_pass_input_attachment_reference.attachment = &backup_odd_color_attachment_description - attachments; - tone_mapping_pass_input_attachment_reference.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + tone_mapping_pass_input_attachment_reference.layout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkAttachmentReference tone_mapping_pass_color_attachment_reference {}; + RHIAttachmentReference tone_mapping_pass_color_attachment_reference {}; tone_mapping_pass_color_attachment_reference.attachment = &backup_even_color_attachment_description - attachments; - tone_mapping_pass_color_attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + tone_mapping_pass_color_attachment_reference.layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - VkSubpassDescription& tone_mapping_pass = subpasses[_main_camera_subpass_tone_mapping]; - tone_mapping_pass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + RHISubpassDescription& tone_mapping_pass = subpasses[_main_camera_subpass_tone_mapping]; + tone_mapping_pass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; tone_mapping_pass.inputAttachmentCount = 1; tone_mapping_pass.pInputAttachments = &tone_mapping_pass_input_attachment_reference; tone_mapping_pass.colorAttachmentCount = 1; @@ -341,12 +333,12 @@ namespace Piccolo tone_mapping_pass.preserveAttachmentCount = 0; tone_mapping_pass.pPreserveAttachments = NULL; - VkAttachmentReference color_grading_pass_input_attachment_reference {}; + RHIAttachmentReference color_grading_pass_input_attachment_reference {}; color_grading_pass_input_attachment_reference.attachment = &backup_even_color_attachment_description - attachments; - color_grading_pass_input_attachment_reference.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + color_grading_pass_input_attachment_reference.layout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkAttachmentReference color_grading_pass_color_attachment_reference {}; + RHIAttachmentReference color_grading_pass_color_attachment_reference {}; if (m_enable_fxaa) { color_grading_pass_color_attachment_reference.attachment = @@ -357,10 +349,10 @@ namespace Piccolo color_grading_pass_color_attachment_reference.attachment = &backup_odd_color_attachment_description - attachments; } - color_grading_pass_color_attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + color_grading_pass_color_attachment_reference.layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - VkSubpassDescription& color_grading_pass = subpasses[_main_camera_subpass_color_grading]; - color_grading_pass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + RHISubpassDescription& color_grading_pass = subpasses[_main_camera_subpass_color_grading]; + color_grading_pass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; color_grading_pass.inputAttachmentCount = 1; color_grading_pass.pInputAttachments = &color_grading_pass_input_attachment_reference; color_grading_pass.colorAttachmentCount = 1; @@ -369,7 +361,7 @@ namespace Piccolo color_grading_pass.preserveAttachmentCount = 0; color_grading_pass.pPreserveAttachments = NULL; - VkAttachmentReference fxaa_pass_input_attachment_reference {}; + RHIAttachmentReference fxaa_pass_input_attachment_reference {}; if (m_enable_fxaa) { fxaa_pass_input_attachment_reference.attachment = @@ -379,14 +371,14 @@ namespace Piccolo { fxaa_pass_input_attachment_reference.attachment = &backup_even_color_attachment_description - attachments; } - fxaa_pass_input_attachment_reference.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + fxaa_pass_input_attachment_reference.layout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkAttachmentReference fxaa_pass_color_attachment_reference {}; + RHIAttachmentReference fxaa_pass_color_attachment_reference {}; fxaa_pass_color_attachment_reference.attachment = &backup_odd_color_attachment_description - attachments; - fxaa_pass_color_attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + fxaa_pass_color_attachment_reference.layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - VkSubpassDescription& fxaa_pass = subpasses[_main_camera_subpass_fxaa]; - fxaa_pass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + RHISubpassDescription& fxaa_pass = subpasses[_main_camera_subpass_fxaa]; + fxaa_pass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; fxaa_pass.inputAttachmentCount = 1; fxaa_pass.pInputAttachments = &fxaa_pass_input_attachment_reference; fxaa_pass.colorAttachmentCount = 1; @@ -395,14 +387,14 @@ namespace Piccolo fxaa_pass.preserveAttachmentCount = 0; fxaa_pass.pPreserveAttachments = NULL; - VkAttachmentReference ui_pass_color_attachment_reference {}; + RHIAttachmentReference ui_pass_color_attachment_reference {}; ui_pass_color_attachment_reference.attachment = &backup_even_color_attachment_description - attachments; - ui_pass_color_attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + ui_pass_color_attachment_reference.layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; uint32_t ui_pass_preserve_attachment = &backup_odd_color_attachment_description - attachments; - VkSubpassDescription& ui_pass = subpasses[_main_camera_subpass_ui]; - ui_pass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + RHISubpassDescription& ui_pass = subpasses[_main_camera_subpass_ui]; + ui_pass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; ui_pass.inputAttachmentCount = 0; ui_pass.pInputAttachments = NULL; ui_pass.colorAttachmentCount = 1; @@ -411,22 +403,22 @@ namespace Piccolo ui_pass.preserveAttachmentCount = 1; ui_pass.pPreserveAttachments = &ui_pass_preserve_attachment; - VkAttachmentReference combine_ui_pass_input_attachments_reference[2] = {}; + RHIAttachmentReference combine_ui_pass_input_attachments_reference[2] = {}; combine_ui_pass_input_attachments_reference[0].attachment = &backup_odd_color_attachment_description - attachments; - combine_ui_pass_input_attachments_reference[0].layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + combine_ui_pass_input_attachments_reference[0].layout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; combine_ui_pass_input_attachments_reference[1].attachment = &backup_even_color_attachment_description - attachments; - combine_ui_pass_input_attachments_reference[1].layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + combine_ui_pass_input_attachments_reference[1].layout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkAttachmentReference combine_ui_pass_color_attachment_reference {}; + RHIAttachmentReference combine_ui_pass_color_attachment_reference {}; combine_ui_pass_color_attachment_reference.attachment = &swapchain_image_attachment_description - attachments; - combine_ui_pass_color_attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + combine_ui_pass_color_attachment_reference.layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - VkSubpassDescription& combine_ui_pass = subpasses[_main_camera_subpass_combine_ui]; - combine_ui_pass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; - combine_ui_pass.inputAttachmentCount = sizeof(combine_ui_pass_input_attachments_reference) / - sizeof(combine_ui_pass_input_attachments_reference[0]); + RHISubpassDescription& combine_ui_pass = subpasses[_main_camera_subpass_combine_ui]; + combine_ui_pass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; + combine_ui_pass.inputAttachmentCount = sizeof(combine_ui_pass_input_attachments_reference) / + sizeof(combine_ui_pass_input_attachments_reference[0]); combine_ui_pass.pInputAttachments = combine_ui_pass_input_attachments_reference; combine_ui_pass.colorAttachmentCount = 1; combine_ui_pass.pColorAttachments = &combine_ui_pass_color_attachment_reference; @@ -434,107 +426,107 @@ namespace Piccolo combine_ui_pass.preserveAttachmentCount = 0; combine_ui_pass.pPreserveAttachments = NULL; - VkSubpassDependency dependencies[8] = {}; + RHISubpassDependency dependencies[8] = {}; - VkSubpassDependency& deferred_lighting_pass_depend_on_shadow_map_pass = dependencies[0]; - deferred_lighting_pass_depend_on_shadow_map_pass.srcSubpass = VK_SUBPASS_EXTERNAL; + RHISubpassDependency& deferred_lighting_pass_depend_on_shadow_map_pass = dependencies[0]; + deferred_lighting_pass_depend_on_shadow_map_pass.srcSubpass = RHI_SUBPASS_EXTERNAL; deferred_lighting_pass_depend_on_shadow_map_pass.dstSubpass = _main_camera_subpass_deferred_lighting; - deferred_lighting_pass_depend_on_shadow_map_pass.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; - deferred_lighting_pass_depend_on_shadow_map_pass.dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; - deferred_lighting_pass_depend_on_shadow_map_pass.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - deferred_lighting_pass_depend_on_shadow_map_pass.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; + deferred_lighting_pass_depend_on_shadow_map_pass.srcStageMask = RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + deferred_lighting_pass_depend_on_shadow_map_pass.dstStageMask = RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + deferred_lighting_pass_depend_on_shadow_map_pass.srcAccessMask = RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + deferred_lighting_pass_depend_on_shadow_map_pass.dstAccessMask = RHI_ACCESS_SHADER_READ_BIT; deferred_lighting_pass_depend_on_shadow_map_pass.dependencyFlags = 0; // NOT BY REGION - VkSubpassDependency& deferred_lighting_pass_depend_on_base_pass = dependencies[1]; + RHISubpassDependency& deferred_lighting_pass_depend_on_base_pass = dependencies[1]; deferred_lighting_pass_depend_on_base_pass.srcSubpass = _main_camera_subpass_basepass; deferred_lighting_pass_depend_on_base_pass.dstSubpass = _main_camera_subpass_deferred_lighting; deferred_lighting_pass_depend_on_base_pass.srcStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; deferred_lighting_pass_depend_on_base_pass.dstStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; deferred_lighting_pass_depend_on_base_pass.srcAccessMask = - VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + RHI_ACCESS_SHADER_WRITE_BIT | RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; deferred_lighting_pass_depend_on_base_pass.dstAccessMask = - VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; - deferred_lighting_pass_depend_on_base_pass.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT; + RHI_ACCESS_SHADER_READ_BIT | RHI_ACCESS_COLOR_ATTACHMENT_READ_BIT; + deferred_lighting_pass_depend_on_base_pass.dependencyFlags = RHI_DEPENDENCY_BY_REGION_BIT; - VkSubpassDependency& forward_lighting_pass_depend_on_deferred_lighting_pass = dependencies[2]; + RHISubpassDependency& forward_lighting_pass_depend_on_deferred_lighting_pass = dependencies[2]; forward_lighting_pass_depend_on_deferred_lighting_pass.srcSubpass = _main_camera_subpass_deferred_lighting; forward_lighting_pass_depend_on_deferred_lighting_pass.dstSubpass = _main_camera_subpass_forward_lighting; forward_lighting_pass_depend_on_deferred_lighting_pass.srcStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; forward_lighting_pass_depend_on_deferred_lighting_pass.dstStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; forward_lighting_pass_depend_on_deferred_lighting_pass.srcAccessMask = - VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + RHI_ACCESS_SHADER_WRITE_BIT | RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; forward_lighting_pass_depend_on_deferred_lighting_pass.dstAccessMask = - VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; - forward_lighting_pass_depend_on_deferred_lighting_pass.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT; + RHI_ACCESS_SHADER_READ_BIT | RHI_ACCESS_COLOR_ATTACHMENT_READ_BIT; + forward_lighting_pass_depend_on_deferred_lighting_pass.dependencyFlags = RHI_DEPENDENCY_BY_REGION_BIT; - VkSubpassDependency& tone_mapping_pass_depend_on_lighting_pass = dependencies[3]; + RHISubpassDependency& tone_mapping_pass_depend_on_lighting_pass = dependencies[3]; tone_mapping_pass_depend_on_lighting_pass.srcSubpass = _main_camera_subpass_forward_lighting; tone_mapping_pass_depend_on_lighting_pass.dstSubpass = _main_camera_subpass_tone_mapping; tone_mapping_pass_depend_on_lighting_pass.srcStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; tone_mapping_pass_depend_on_lighting_pass.dstStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; tone_mapping_pass_depend_on_lighting_pass.srcAccessMask = - VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + RHI_ACCESS_SHADER_WRITE_BIT | RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; tone_mapping_pass_depend_on_lighting_pass.dstAccessMask = - VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; - tone_mapping_pass_depend_on_lighting_pass.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT; + RHI_ACCESS_SHADER_READ_BIT | RHI_ACCESS_COLOR_ATTACHMENT_READ_BIT; + tone_mapping_pass_depend_on_lighting_pass.dependencyFlags = RHI_DEPENDENCY_BY_REGION_BIT; - VkSubpassDependency& color_grading_pass_depend_on_tone_mapping_pass = dependencies[4]; + RHISubpassDependency& color_grading_pass_depend_on_tone_mapping_pass = dependencies[4]; color_grading_pass_depend_on_tone_mapping_pass.srcSubpass = _main_camera_subpass_tone_mapping; color_grading_pass_depend_on_tone_mapping_pass.dstSubpass = _main_camera_subpass_color_grading; color_grading_pass_depend_on_tone_mapping_pass.srcStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; color_grading_pass_depend_on_tone_mapping_pass.dstStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; color_grading_pass_depend_on_tone_mapping_pass.srcAccessMask = - VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + RHI_ACCESS_SHADER_WRITE_BIT | RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; color_grading_pass_depend_on_tone_mapping_pass.dstAccessMask = - VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; - color_grading_pass_depend_on_tone_mapping_pass.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT; + RHI_ACCESS_SHADER_READ_BIT | RHI_ACCESS_COLOR_ATTACHMENT_READ_BIT; + color_grading_pass_depend_on_tone_mapping_pass.dependencyFlags = RHI_DEPENDENCY_BY_REGION_BIT; - VkSubpassDependency& fxaa_pass_depend_on_color_grading_pass = dependencies[5]; + RHISubpassDependency& fxaa_pass_depend_on_color_grading_pass = dependencies[5]; fxaa_pass_depend_on_color_grading_pass.srcSubpass = _main_camera_subpass_color_grading; fxaa_pass_depend_on_color_grading_pass.dstSubpass = _main_camera_subpass_fxaa; fxaa_pass_depend_on_color_grading_pass.srcStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; fxaa_pass_depend_on_color_grading_pass.dstStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; fxaa_pass_depend_on_color_grading_pass.srcAccessMask = - VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + RHI_ACCESS_SHADER_WRITE_BIT | RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; fxaa_pass_depend_on_color_grading_pass.dstAccessMask = - VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; + RHI_ACCESS_SHADER_READ_BIT | RHI_ACCESS_COLOR_ATTACHMENT_READ_BIT; - VkSubpassDependency& ui_pass_depend_on_fxaa_pass = dependencies[6]; + RHISubpassDependency& ui_pass_depend_on_fxaa_pass = dependencies[6]; ui_pass_depend_on_fxaa_pass.srcSubpass = _main_camera_subpass_fxaa; ui_pass_depend_on_fxaa_pass.dstSubpass = _main_camera_subpass_ui; ui_pass_depend_on_fxaa_pass.srcStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; ui_pass_depend_on_fxaa_pass.dstStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; - ui_pass_depend_on_fxaa_pass.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - ui_pass_depend_on_fxaa_pass.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; - ui_pass_depend_on_fxaa_pass.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + ui_pass_depend_on_fxaa_pass.srcAccessMask = RHI_ACCESS_SHADER_WRITE_BIT | RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + ui_pass_depend_on_fxaa_pass.dstAccessMask = RHI_ACCESS_SHADER_READ_BIT | RHI_ACCESS_COLOR_ATTACHMENT_READ_BIT; + ui_pass_depend_on_fxaa_pass.dependencyFlags = RHI_DEPENDENCY_BY_REGION_BIT; - VkSubpassDependency& combine_ui_pass_depend_on_ui_pass = dependencies[7]; + RHISubpassDependency& combine_ui_pass_depend_on_ui_pass = dependencies[7]; combine_ui_pass_depend_on_ui_pass.srcSubpass = _main_camera_subpass_ui; combine_ui_pass_depend_on_ui_pass.dstSubpass = _main_camera_subpass_combine_ui; combine_ui_pass_depend_on_ui_pass.srcStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; combine_ui_pass_depend_on_ui_pass.dstStageMask = - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; combine_ui_pass_depend_on_ui_pass.srcAccessMask = - VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + RHI_ACCESS_SHADER_WRITE_BIT | RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; combine_ui_pass_depend_on_ui_pass.dstAccessMask = - VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; - combine_ui_pass_depend_on_ui_pass.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT; + RHI_ACCESS_SHADER_READ_BIT | RHI_ACCESS_COLOR_ATTACHMENT_READ_BIT; + combine_ui_pass_depend_on_ui_pass.dependencyFlags = RHI_DEPENDENCY_BY_REGION_BIT; - VkRenderPassCreateInfo renderpass_create_info {}; - renderpass_create_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + RHIRenderPassCreateInfo renderpass_create_info {}; + renderpass_create_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; renderpass_create_info.attachmentCount = (sizeof(attachments) / sizeof(attachments[0])); renderpass_create_info.pAttachments = attachments; renderpass_create_info.subpassCount = (sizeof(subpasses) / sizeof(subpasses[0])); @@ -542,8 +534,7 @@ namespace Piccolo renderpass_create_info.dependencyCount = (sizeof(dependencies) / sizeof(dependencies[0])); renderpass_create_info.pDependencies = dependencies; - if (vkCreateRenderPass(m_vulkan_rhi->m_device, &renderpass_create_info, nullptr, &m_framebuffer.render_pass) != - VK_SUCCESS) + if (m_rhi->createRenderPass(&renderpass_create_info, m_framebuffer.render_pass) != RHI_SUCCESS) { throw std::runtime_error("failed to create render pass"); } @@ -554,272 +545,255 @@ namespace Piccolo m_descriptor_infos.resize(_layout_type_count); { - VkDescriptorSetLayoutBinding mesh_mesh_layout_bindings[1]; + RHIDescriptorSetLayoutBinding mesh_mesh_layout_bindings[1]; - VkDescriptorSetLayoutBinding& mesh_mesh_layout_uniform_buffer_binding = mesh_mesh_layout_bindings[0]; + RHIDescriptorSetLayoutBinding& mesh_mesh_layout_uniform_buffer_binding = mesh_mesh_layout_bindings[0]; mesh_mesh_layout_uniform_buffer_binding.binding = 0; - mesh_mesh_layout_uniform_buffer_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + mesh_mesh_layout_uniform_buffer_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; mesh_mesh_layout_uniform_buffer_binding.descriptorCount = 1; - mesh_mesh_layout_uniform_buffer_binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + mesh_mesh_layout_uniform_buffer_binding.stageFlags = RHI_SHADER_STAGE_VERTEX_BIT; mesh_mesh_layout_uniform_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutCreateInfo mesh_mesh_layout_create_info {}; - mesh_mesh_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo mesh_mesh_layout_create_info {}; + mesh_mesh_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; mesh_mesh_layout_create_info.bindingCount = 1; mesh_mesh_layout_create_info.pBindings = mesh_mesh_layout_bindings; - if (vkCreateDescriptorSetLayout(m_vulkan_rhi->m_device, - &mesh_mesh_layout_create_info, - NULL, - &m_descriptor_infos[_per_mesh].layout) != VK_SUCCESS) + if (m_rhi->createDescriptorSetLayout(&mesh_mesh_layout_create_info, m_descriptor_infos[_per_mesh].layout) != RHI_SUCCESS) { throw std::runtime_error("create mesh mesh layout"); } } { - VkDescriptorSetLayoutBinding mesh_global_layout_bindings[8]; + RHIDescriptorSetLayoutBinding mesh_global_layout_bindings[8]; - VkDescriptorSetLayoutBinding& mesh_global_layout_perframe_storage_buffer_binding = + RHIDescriptorSetLayoutBinding& mesh_global_layout_perframe_storage_buffer_binding = mesh_global_layout_bindings[0]; mesh_global_layout_perframe_storage_buffer_binding.binding = 0; mesh_global_layout_perframe_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_global_layout_perframe_storage_buffer_binding.descriptorCount = 1; mesh_global_layout_perframe_storage_buffer_binding.stageFlags = - VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT; + RHI_SHADER_STAGE_VERTEX_BIT | RHI_SHADER_STAGE_FRAGMENT_BIT; mesh_global_layout_perframe_storage_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutBinding& mesh_global_layout_perdrawcall_storage_buffer_binding = + RHIDescriptorSetLayoutBinding& mesh_global_layout_perdrawcall_storage_buffer_binding = mesh_global_layout_bindings[1]; mesh_global_layout_perdrawcall_storage_buffer_binding.binding = 1; mesh_global_layout_perdrawcall_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_global_layout_perdrawcall_storage_buffer_binding.descriptorCount = 1; - mesh_global_layout_perdrawcall_storage_buffer_binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + mesh_global_layout_perdrawcall_storage_buffer_binding.stageFlags = RHI_SHADER_STAGE_VERTEX_BIT; mesh_global_layout_perdrawcall_storage_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutBinding& mesh_global_layout_per_drawcall_vertex_blending_storage_buffer_binding = + RHIDescriptorSetLayoutBinding& mesh_global_layout_per_drawcall_vertex_blending_storage_buffer_binding = mesh_global_layout_bindings[2]; mesh_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.binding = 2; mesh_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.descriptorCount = 1; mesh_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.stageFlags = - VK_SHADER_STAGE_VERTEX_BIT; + RHI_SHADER_STAGE_VERTEX_BIT; mesh_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutBinding& mesh_global_layout_brdfLUT_texture_binding = mesh_global_layout_bindings[3]; + RHIDescriptorSetLayoutBinding& mesh_global_layout_brdfLUT_texture_binding = mesh_global_layout_bindings[3]; mesh_global_layout_brdfLUT_texture_binding.binding = 3; - mesh_global_layout_brdfLUT_texture_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + mesh_global_layout_brdfLUT_texture_binding.descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; mesh_global_layout_brdfLUT_texture_binding.descriptorCount = 1; - mesh_global_layout_brdfLUT_texture_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + mesh_global_layout_brdfLUT_texture_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; mesh_global_layout_brdfLUT_texture_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutBinding& mesh_global_layout_irradiance_texture_binding = + RHIDescriptorSetLayoutBinding& mesh_global_layout_irradiance_texture_binding = mesh_global_layout_bindings[4]; mesh_global_layout_irradiance_texture_binding = mesh_global_layout_brdfLUT_texture_binding; mesh_global_layout_irradiance_texture_binding.binding = 4; - VkDescriptorSetLayoutBinding& mesh_global_layout_specular_texture_binding = mesh_global_layout_bindings[5]; + RHIDescriptorSetLayoutBinding& mesh_global_layout_specular_texture_binding = mesh_global_layout_bindings[5]; mesh_global_layout_specular_texture_binding = mesh_global_layout_brdfLUT_texture_binding; mesh_global_layout_specular_texture_binding.binding = 5; - VkDescriptorSetLayoutBinding& mesh_global_layout_point_light_shadow_texture_binding = + RHIDescriptorSetLayoutBinding& mesh_global_layout_point_light_shadow_texture_binding = mesh_global_layout_bindings[6]; mesh_global_layout_point_light_shadow_texture_binding = mesh_global_layout_brdfLUT_texture_binding; mesh_global_layout_point_light_shadow_texture_binding.binding = 6; - VkDescriptorSetLayoutBinding& mesh_global_layout_directional_light_shadow_texture_binding = + RHIDescriptorSetLayoutBinding& mesh_global_layout_directional_light_shadow_texture_binding = mesh_global_layout_bindings[7]; mesh_global_layout_directional_light_shadow_texture_binding = mesh_global_layout_brdfLUT_texture_binding; mesh_global_layout_directional_light_shadow_texture_binding.binding = 7; - VkDescriptorSetLayoutCreateInfo mesh_global_layout_create_info; - mesh_global_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo mesh_global_layout_create_info; + mesh_global_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; mesh_global_layout_create_info.pNext = NULL; mesh_global_layout_create_info.flags = 0; mesh_global_layout_create_info.bindingCount = (sizeof(mesh_global_layout_bindings) / sizeof(mesh_global_layout_bindings[0])); mesh_global_layout_create_info.pBindings = mesh_global_layout_bindings; - if (VK_SUCCESS != vkCreateDescriptorSetLayout(m_vulkan_rhi->m_device, - &mesh_global_layout_create_info, - NULL, - &m_descriptor_infos[_mesh_global].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&mesh_global_layout_create_info, m_descriptor_infos[_mesh_global].layout)) { throw std::runtime_error("create mesh global layout"); } } { - VkDescriptorSetLayoutBinding mesh_material_layout_bindings[6]; + RHIDescriptorSetLayoutBinding mesh_material_layout_bindings[6]; // (set = 2, binding = 0 in fragment shader) - VkDescriptorSetLayoutBinding& mesh_material_layout_uniform_buffer_binding = + RHIDescriptorSetLayoutBinding& mesh_material_layout_uniform_buffer_binding = mesh_material_layout_bindings[0]; mesh_material_layout_uniform_buffer_binding.binding = 0; - mesh_material_layout_uniform_buffer_binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + mesh_material_layout_uniform_buffer_binding.descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER; mesh_material_layout_uniform_buffer_binding.descriptorCount = 1; - mesh_material_layout_uniform_buffer_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + mesh_material_layout_uniform_buffer_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; mesh_material_layout_uniform_buffer_binding.pImmutableSamplers = nullptr; // (set = 2, binding = 1 in fragment shader) - VkDescriptorSetLayoutBinding& mesh_material_layout_base_color_texture_binding = + RHIDescriptorSetLayoutBinding& mesh_material_layout_base_color_texture_binding = mesh_material_layout_bindings[1]; mesh_material_layout_base_color_texture_binding.binding = 1; - mesh_material_layout_base_color_texture_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + mesh_material_layout_base_color_texture_binding.descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; mesh_material_layout_base_color_texture_binding.descriptorCount = 1; - mesh_material_layout_base_color_texture_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + mesh_material_layout_base_color_texture_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; mesh_material_layout_base_color_texture_binding.pImmutableSamplers = nullptr; // (set = 2, binding = 2 in fragment shader) - VkDescriptorSetLayoutBinding& mesh_material_layout_metallic_roughness_texture_binding = + RHIDescriptorSetLayoutBinding& mesh_material_layout_metallic_roughness_texture_binding = mesh_material_layout_bindings[2]; mesh_material_layout_metallic_roughness_texture_binding = mesh_material_layout_base_color_texture_binding; mesh_material_layout_metallic_roughness_texture_binding.binding = 2; // (set = 2, binding = 3 in fragment shader) - VkDescriptorSetLayoutBinding& mesh_material_layout_normal_roughness_texture_binding = + RHIDescriptorSetLayoutBinding& mesh_material_layout_normal_roughness_texture_binding = mesh_material_layout_bindings[3]; mesh_material_layout_normal_roughness_texture_binding = mesh_material_layout_base_color_texture_binding; mesh_material_layout_normal_roughness_texture_binding.binding = 3; // (set = 2, binding = 4 in fragment shader) - VkDescriptorSetLayoutBinding& mesh_material_layout_occlusion_texture_binding = + RHIDescriptorSetLayoutBinding& mesh_material_layout_occlusion_texture_binding = mesh_material_layout_bindings[4]; mesh_material_layout_occlusion_texture_binding = mesh_material_layout_base_color_texture_binding; mesh_material_layout_occlusion_texture_binding.binding = 4; // (set = 2, binding = 5 in fragment shader) - VkDescriptorSetLayoutBinding& mesh_material_layout_emissive_texture_binding = + RHIDescriptorSetLayoutBinding& mesh_material_layout_emissive_texture_binding = mesh_material_layout_bindings[5]; mesh_material_layout_emissive_texture_binding = mesh_material_layout_base_color_texture_binding; mesh_material_layout_emissive_texture_binding.binding = 5; - VkDescriptorSetLayoutCreateInfo mesh_material_layout_create_info; - mesh_material_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo mesh_material_layout_create_info; + mesh_material_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; mesh_material_layout_create_info.pNext = NULL; mesh_material_layout_create_info.flags = 0; mesh_material_layout_create_info.bindingCount = 6; mesh_material_layout_create_info.pBindings = mesh_material_layout_bindings; - if (vkCreateDescriptorSetLayout(m_vulkan_rhi->m_device, - &mesh_material_layout_create_info, - nullptr, - &m_descriptor_infos[_mesh_per_material].layout) != VK_SUCCESS) - + if (m_rhi->createDescriptorSetLayout(&mesh_material_layout_create_info, m_descriptor_infos[_mesh_per_material].layout) != RHI_SUCCESS) { throw std::runtime_error("create mesh material layout"); } } { - VkDescriptorSetLayoutBinding skybox_layout_bindings[2]; + RHIDescriptorSetLayoutBinding skybox_layout_bindings[2]; - VkDescriptorSetLayoutBinding& skybox_layout_perframe_storage_buffer_binding = skybox_layout_bindings[0]; + RHIDescriptorSetLayoutBinding& skybox_layout_perframe_storage_buffer_binding = skybox_layout_bindings[0]; skybox_layout_perframe_storage_buffer_binding.binding = 0; - skybox_layout_perframe_storage_buffer_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + skybox_layout_perframe_storage_buffer_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; skybox_layout_perframe_storage_buffer_binding.descriptorCount = 1; - skybox_layout_perframe_storage_buffer_binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + skybox_layout_perframe_storage_buffer_binding.stageFlags = RHI_SHADER_STAGE_VERTEX_BIT; skybox_layout_perframe_storage_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutBinding& skybox_layout_specular_texture_binding = skybox_layout_bindings[1]; + RHIDescriptorSetLayoutBinding& skybox_layout_specular_texture_binding = skybox_layout_bindings[1]; skybox_layout_specular_texture_binding.binding = 1; - skybox_layout_specular_texture_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + skybox_layout_specular_texture_binding.descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; skybox_layout_specular_texture_binding.descriptorCount = 1; - skybox_layout_specular_texture_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + skybox_layout_specular_texture_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; skybox_layout_specular_texture_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutCreateInfo skybox_layout_create_info {}; - skybox_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo skybox_layout_create_info {}; + skybox_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; skybox_layout_create_info.bindingCount = 2; skybox_layout_create_info.pBindings = skybox_layout_bindings; - if (VK_SUCCESS != - vkCreateDescriptorSetLayout( - m_vulkan_rhi->m_device, &skybox_layout_create_info, NULL, &m_descriptor_infos[_skybox].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&skybox_layout_create_info, m_descriptor_infos[_skybox].layout)) { throw std::runtime_error("create skybox layout"); } } { - VkDescriptorSetLayoutBinding axis_layout_bindings[2]; + RHIDescriptorSetLayoutBinding axis_layout_bindings[2]; - VkDescriptorSetLayoutBinding& axis_layout_perframe_storage_buffer_binding = axis_layout_bindings[0]; + RHIDescriptorSetLayoutBinding& axis_layout_perframe_storage_buffer_binding = axis_layout_bindings[0]; axis_layout_perframe_storage_buffer_binding.binding = 0; - axis_layout_perframe_storage_buffer_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + axis_layout_perframe_storage_buffer_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; axis_layout_perframe_storage_buffer_binding.descriptorCount = 1; - axis_layout_perframe_storage_buffer_binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + axis_layout_perframe_storage_buffer_binding.stageFlags = RHI_SHADER_STAGE_VERTEX_BIT; axis_layout_perframe_storage_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutBinding& axis_layout_storage_buffer_binding = axis_layout_bindings[1]; + RHIDescriptorSetLayoutBinding& axis_layout_storage_buffer_binding = axis_layout_bindings[1]; axis_layout_storage_buffer_binding.binding = 1; - axis_layout_storage_buffer_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + axis_layout_storage_buffer_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; axis_layout_storage_buffer_binding.descriptorCount = 1; - axis_layout_storage_buffer_binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + axis_layout_storage_buffer_binding.stageFlags = RHI_SHADER_STAGE_VERTEX_BIT; axis_layout_storage_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutCreateInfo axis_layout_create_info {}; - axis_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo axis_layout_create_info {}; + axis_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; axis_layout_create_info.bindingCount = 2; axis_layout_create_info.pBindings = axis_layout_bindings; - if (VK_SUCCESS != - vkCreateDescriptorSetLayout( - m_vulkan_rhi->m_device, &axis_layout_create_info, NULL, &m_descriptor_infos[_axis].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&axis_layout_create_info, m_descriptor_infos[_axis].layout)) { throw std::runtime_error("create axis layout"); } } { - VkDescriptorSetLayoutBinding gbuffer_lighting_global_layout_bindings[4]; + RHIDescriptorSetLayoutBinding gbuffer_lighting_global_layout_bindings[4]; - VkDescriptorSetLayoutBinding& gbuffer_normal_global_layout_input_attachment_binding = + RHIDescriptorSetLayoutBinding& gbuffer_normal_global_layout_input_attachment_binding = gbuffer_lighting_global_layout_bindings[0]; gbuffer_normal_global_layout_input_attachment_binding.binding = 0; - gbuffer_normal_global_layout_input_attachment_binding.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + gbuffer_normal_global_layout_input_attachment_binding.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; gbuffer_normal_global_layout_input_attachment_binding.descriptorCount = 1; - gbuffer_normal_global_layout_input_attachment_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + gbuffer_normal_global_layout_input_attachment_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; - VkDescriptorSetLayoutBinding& + RHIDescriptorSetLayoutBinding& gbuffer_metallic_roughness_shadingmodeid_global_layout_input_attachment_binding = gbuffer_lighting_global_layout_bindings[1]; gbuffer_metallic_roughness_shadingmodeid_global_layout_input_attachment_binding.binding = 1; gbuffer_metallic_roughness_shadingmodeid_global_layout_input_attachment_binding.descriptorType = - VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; gbuffer_metallic_roughness_shadingmodeid_global_layout_input_attachment_binding.descriptorCount = 1; gbuffer_metallic_roughness_shadingmodeid_global_layout_input_attachment_binding.stageFlags = - VK_SHADER_STAGE_FRAGMENT_BIT; + RHI_SHADER_STAGE_FRAGMENT_BIT; - VkDescriptorSetLayoutBinding& gbuffer_albedo_global_layout_input_attachment_binding = + RHIDescriptorSetLayoutBinding& gbuffer_albedo_global_layout_input_attachment_binding = gbuffer_lighting_global_layout_bindings[2]; gbuffer_albedo_global_layout_input_attachment_binding.binding = 2; - gbuffer_albedo_global_layout_input_attachment_binding.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + gbuffer_albedo_global_layout_input_attachment_binding.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; gbuffer_albedo_global_layout_input_attachment_binding.descriptorCount = 1; - gbuffer_albedo_global_layout_input_attachment_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + gbuffer_albedo_global_layout_input_attachment_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; - VkDescriptorSetLayoutBinding& gbuffer_depth_global_layout_input_attachment_binding = + RHIDescriptorSetLayoutBinding& gbuffer_depth_global_layout_input_attachment_binding = gbuffer_lighting_global_layout_bindings[3]; gbuffer_depth_global_layout_input_attachment_binding.binding = 3; - gbuffer_depth_global_layout_input_attachment_binding.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + gbuffer_depth_global_layout_input_attachment_binding.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; gbuffer_depth_global_layout_input_attachment_binding.descriptorCount = 1; - gbuffer_depth_global_layout_input_attachment_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + gbuffer_depth_global_layout_input_attachment_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; - VkDescriptorSetLayoutCreateInfo gbuffer_lighting_global_layout_create_info; - gbuffer_lighting_global_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo gbuffer_lighting_global_layout_create_info; + gbuffer_lighting_global_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; gbuffer_lighting_global_layout_create_info.pNext = NULL; gbuffer_lighting_global_layout_create_info.flags = 0; gbuffer_lighting_global_layout_create_info.bindingCount = sizeof(gbuffer_lighting_global_layout_bindings) / sizeof(gbuffer_lighting_global_layout_bindings[0]); gbuffer_lighting_global_layout_create_info.pBindings = gbuffer_lighting_global_layout_bindings; - if (VK_SUCCESS != vkCreateDescriptorSetLayout(m_vulkan_rhi->m_device, - &gbuffer_lighting_global_layout_create_info, - NULL, - &m_descriptor_infos[_deferred_lighting].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&gbuffer_lighting_global_layout_create_info, m_descriptor_infos[_deferred_lighting].layout)) { throw std::runtime_error("create deferred lighting global layout"); } @@ -832,113 +806,109 @@ namespace Piccolo // mesh gbuffer { - VkDescriptorSetLayout descriptorset_layouts[3] = {m_descriptor_infos[_mesh_global].layout, + RHIDescriptorSetLayout* descriptorset_layouts[3] = {m_descriptor_infos[_mesh_global].layout, m_descriptor_infos[_per_mesh].layout, m_descriptor_infos[_mesh_per_material].layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = 3; pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout(m_vulkan_rhi->m_device, - &pipeline_layout_create_info, - nullptr, - &m_render_pipelines[_render_pipeline_type_mesh_gbuffer].layout) != VK_SUCCESS) + if (m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[_render_pipeline_type_mesh_gbuffer].layout) != RHI_SUCCESS) { throw std::runtime_error("create mesh gbuffer pipeline layout"); } - VkShaderModule vert_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, MESH_VERT); - VkShaderModule frag_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, MESH_GBUFFER_FRAG); + RHIShader* vert_shader_module = m_rhi->createShaderModule(MESH_VERT); + RHIShader* frag_shader_module = m_rhi->createShaderModule(MESH_GBUFFER_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; auto vertex_binding_descriptions = MeshVertex::getBindingDescriptions(); auto vertex_attribute_descriptions = MeshVertex::getAttributeDescriptions(); - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = vertex_binding_descriptions.size(); vertex_input_state_create_info.pVertexBindingDescriptions = &vertex_binding_descriptions[0]; vertex_input_state_create_info.vertexAttributeDescriptionCount = vertex_attribute_descriptions.size(); vertex_input_state_create_info.pVertexAttributeDescriptions = &vertex_attribute_descriptions[0]; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_BACK_BIT; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_BACK_BIT; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_COUNTER_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; - - VkPipelineColorBlendAttachmentState color_blend_attachments[3] = {}; - color_blend_attachments[0].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | - VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachments[0].blendEnable = VK_FALSE; - color_blend_attachments[0].srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachments[0].colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachments[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachments[0].alphaBlendOp = VK_BLEND_OP_ADD; - color_blend_attachments[1].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | - VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachments[1].blendEnable = VK_FALSE; - color_blend_attachments[1].srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[1].dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachments[1].colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachments[1].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[1].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachments[1].alphaBlendOp = VK_BLEND_OP_ADD; - color_blend_attachments[2].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | - VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachments[2].blendEnable = VK_FALSE; - color_blend_attachments[2].srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[2].dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachments[2].colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachments[2].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[2].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachments[2].alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info = {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; + + RHIPipelineColorBlendAttachmentState color_blend_attachments[3] = {}; + color_blend_attachments[0].colorWriteMask = RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | + RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachments[0].blendEnable = RHI_FALSE; + color_blend_attachments[0].srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachments[0].colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachments[0].srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachments[0].alphaBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachments[1].colorWriteMask = RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | + RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachments[1].blendEnable = RHI_FALSE; + color_blend_attachments[1].srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[1].dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachments[1].colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachments[1].srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[1].dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachments[1].alphaBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachments[2].colorWriteMask = RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | + RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachments[2].blendEnable = RHI_FALSE; + color_blend_attachments[2].srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[2].dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachments[2].colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachments[2].srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[2].dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachments[2].alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info = {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = sizeof(color_blend_attachments) / sizeof(color_blend_attachments[0]); color_blend_state_create_info.pAttachments = &color_blend_attachments[0]; @@ -947,22 +917,22 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_TRUE; - depth_stencil_create_info.depthWriteEnable = VK_TRUE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; - - VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_TRUE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; + + RHIDynamicState dynamic_states[] = {RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR}; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 2; dynamic_state_create_info.pDynamicStates = dynamic_states; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -975,119 +945,111 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[_render_pipeline_type_mesh_gbuffer].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = _main_camera_subpass_basepass; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines(m_vulkan_rhi->m_device, - VK_NULL_HANDLE, - 1, - &pipelineInfo, - nullptr, - &m_render_pipelines[_render_pipeline_type_mesh_gbuffer].pipeline) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, + 1, + &pipelineInfo, + m_render_pipelines[_render_pipeline_type_mesh_gbuffer].pipeline)) { throw std::runtime_error("create mesh gbuffer graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } // deferred lighting { - VkDescriptorSetLayout descriptorset_layouts[3] = {m_descriptor_infos[_mesh_global].layout, + RHIDescriptorSetLayout* descriptorset_layouts[3] = {m_descriptor_infos[_mesh_global].layout, m_descriptor_infos[_deferred_lighting].layout, m_descriptor_infos[_skybox].layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = sizeof(descriptorset_layouts) / sizeof(descriptorset_layouts[0]); pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout(m_vulkan_rhi->m_device, - &pipeline_layout_create_info, - nullptr, - &m_render_pipelines[_render_pipeline_type_deferred_lighting].layout) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createPipelineLayout(&pipeline_layout_create_info, + m_render_pipelines[_render_pipeline_type_deferred_lighting].layout)) { throw std::runtime_error("create deferred lighting pipeline layout"); } - VkShaderModule vert_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, DEFERRED_LIGHTING_VERT); - VkShaderModule frag_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, DEFERRED_LIGHTING_FRAG); + RHIShader* vert_shader_module = m_rhi->createShaderModule(DEFERRED_LIGHTING_VERT); + RHIShader* frag_shader_module = m_rhi->createShaderModule(DEFERRED_LIGHTING_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; // vert_pipeline_shader_stage_create_info.pSpecializationInfo - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; auto vertex_binding_descriptions = MeshVertex::getBindingDescriptions(); auto vertex_attribute_descriptions = MeshVertex::getAttributeDescriptions(); - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = 0; vertex_input_state_create_info.pVertexBindingDescriptions = NULL; vertex_input_state_create_info.vertexBindingDescriptionCount = 0; vertex_input_state_create_info.pVertexAttributeDescriptions = NULL; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_BACK_BIT; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_BACK_BIT; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; - - VkPipelineColorBlendAttachmentState color_blend_attachments[1] = {}; - color_blend_attachments[0].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | - VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachments[0].blendEnable = VK_FALSE; - color_blend_attachments[0].srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachments[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info = {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; + + RHIPipelineColorBlendAttachmentState color_blend_attachments[1] = {}; + color_blend_attachments[0].colorWriteMask = RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | + RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachments[0].blendEnable = RHI_FALSE; + color_blend_attachments[0].srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].dstColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachments[0].srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].dstAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info = {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = sizeof(color_blend_attachments) / sizeof(color_blend_attachments[0]); color_blend_state_create_info.pAttachments = &color_blend_attachments[0]; @@ -1096,22 +1058,22 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_FALSE; - depth_stencil_create_info.depthWriteEnable = VK_FALSE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_ALWAYS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; - - VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_FALSE; + depth_stencil_create_info.depthWriteEnable = RHI_FALSE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_ALWAYS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; + + RHIDynamicState dynamic_states[] = {RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR}; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 2; dynamic_state_create_info.pDynamicStates = dynamic_states; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -1124,114 +1086,108 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[_render_pipeline_type_deferred_lighting].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = _main_camera_subpass_deferred_lighting; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines(m_vulkan_rhi->m_device, - VK_NULL_HANDLE, - 1, - &pipelineInfo, - nullptr, - &m_render_pipelines[_render_pipeline_type_deferred_lighting].pipeline) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, + 1, + &pipelineInfo, + m_render_pipelines[_render_pipeline_type_deferred_lighting].pipeline)) { throw std::runtime_error("create deferred lighting graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } // mesh lighting { - VkDescriptorSetLayout descriptorset_layouts[3] = {m_descriptor_infos[_mesh_global].layout, - m_descriptor_infos[_per_mesh].layout, - m_descriptor_infos[_mesh_per_material].layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayout* descriptorset_layouts[3] = {m_descriptor_infos[_mesh_global].layout, + m_descriptor_infos[_per_mesh].layout, + m_descriptor_infos[_mesh_per_material].layout}; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = 3; pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout(m_vulkan_rhi->m_device, - &pipeline_layout_create_info, - nullptr, - &m_render_pipelines[_render_pipeline_type_mesh_lighting].layout) != VK_SUCCESS) + if (m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[_render_pipeline_type_mesh_lighting].layout) != RHI_SUCCESS) { throw std::runtime_error("create mesh lighting pipeline layout"); } - VkShaderModule vert_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, MESH_VERT); - VkShaderModule frag_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, MESH_FRAG); + RHIShader* vert_shader_module = m_rhi->createShaderModule(MESH_VERT); + RHIShader* frag_shader_module = m_rhi->createShaderModule(MESH_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; auto vertex_binding_descriptions = MeshVertex::getBindingDescriptions(); auto vertex_attribute_descriptions = MeshVertex::getAttributeDescriptions(); - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = vertex_binding_descriptions.size(); vertex_input_state_create_info.pVertexBindingDescriptions = &vertex_binding_descriptions[0]; vertex_input_state_create_info.vertexAttributeDescriptionCount = vertex_attribute_descriptions.size(); vertex_input_state_create_info.pVertexAttributeDescriptions = &vertex_attribute_descriptions[0]; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_BACK_BIT; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_BACK_BIT; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_COUNTER_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; - - VkPipelineColorBlendAttachmentState color_blend_attachments[1] = {}; - color_blend_attachments[0].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | - VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachments[0].blendEnable = VK_FALSE; - color_blend_attachments[0].srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachments[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info = {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; + + RHIPipelineColorBlendAttachmentState color_blend_attachments[1] = {}; + color_blend_attachments[0].colorWriteMask = RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | + RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachments[0].blendEnable = RHI_FALSE; + color_blend_attachments[0].srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].dstColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachments[0].srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].dstAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info = {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = sizeof(color_blend_attachments) / sizeof(color_blend_attachments[0]); color_blend_state_create_info.pAttachments = &color_blend_attachments[0]; @@ -1240,22 +1196,22 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_TRUE; - depth_stencil_create_info.depthWriteEnable = VK_TRUE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; - - VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_TRUE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; + + RHIDynamicState dynamic_states[] = {RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR}; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 2; dynamic_state_create_info.pDynamicStates = dynamic_states; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -1268,113 +1224,108 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[_render_pipeline_type_mesh_lighting].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = _main_camera_subpass_forward_lighting; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines(m_vulkan_rhi->m_device, - VK_NULL_HANDLE, - 1, - &pipelineInfo, - nullptr, - &m_render_pipelines[_render_pipeline_type_mesh_lighting].pipeline) != - VK_SUCCESS) + if (m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, + 1, + &pipelineInfo, + m_render_pipelines[_render_pipeline_type_mesh_lighting].pipeline) != + RHI_SUCCESS) { throw std::runtime_error("create mesh lighting graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } // skybox { - VkDescriptorSetLayout descriptorset_layouts[1] = {m_descriptor_infos[_skybox].layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayout* descriptorset_layouts[1] = {m_descriptor_infos[_skybox].layout}; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = 1; pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout(m_vulkan_rhi->m_device, - &pipeline_layout_create_info, - nullptr, - &m_render_pipelines[_render_pipeline_type_skybox].layout) != VK_SUCCESS) + if (m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[_render_pipeline_type_skybox].layout) != RHI_SUCCESS) { throw std::runtime_error("create skybox pipeline layout"); } - VkShaderModule vert_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, SKYBOX_VERT); - VkShaderModule frag_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, SKYBOX_FRAG); + RHIShader* vert_shader_module = m_rhi->createShaderModule(SKYBOX_VERT); + RHIShader* frag_shader_module = m_rhi->createShaderModule(SKYBOX_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; // vert_pipeline_shader_stage_create_info.pSpecializationInfo - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; auto vertex_binding_descriptions = MeshVertex::getBindingDescriptions(); auto vertex_attribute_descriptions = MeshVertex::getAttributeDescriptions(); - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = 0; vertex_input_state_create_info.pVertexBindingDescriptions = NULL; vertex_input_state_create_info.vertexAttributeDescriptionCount = 0; vertex_input_state_create_info.pVertexAttributeDescriptions = NULL; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_BACK_BIT; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_BACK_BIT; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_COUNTER_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; - - VkPipelineColorBlendAttachmentState color_blend_attachments[1] = {}; - color_blend_attachments[0].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | - VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachments[0].blendEnable = VK_FALSE; - color_blend_attachments[0].srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachments[0].colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachments[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachments[0].alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info = {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; + + RHIPipelineColorBlendAttachmentState color_blend_attachments[1] = {}; + color_blend_attachments[0].colorWriteMask = RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | + RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachments[0].blendEnable = RHI_FALSE; + color_blend_attachments[0].srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachments[0].colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachments[0].srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachments[0].alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info = {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = sizeof(color_blend_attachments) / sizeof(color_blend_attachments[0]); color_blend_state_create_info.pAttachments = &color_blend_attachments[0]; @@ -1383,22 +1334,22 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_TRUE; - depth_stencil_create_info.depthWriteEnable = VK_TRUE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; - - VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_TRUE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; + + RHIDynamicState dynamic_states[] = {RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR}; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 2; dynamic_state_create_info.pDynamicStates = dynamic_states; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -1411,112 +1362,107 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[_render_pipeline_type_skybox].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = _main_camera_subpass_forward_lighting; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines(m_vulkan_rhi->m_device, - VK_NULL_HANDLE, - 1, - &pipelineInfo, - nullptr, - &m_render_pipelines[_render_pipeline_type_skybox].pipeline) != VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, + 1, + &pipelineInfo, + m_render_pipelines[_render_pipeline_type_skybox].pipeline)) { throw std::runtime_error("create skybox graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } // draw axis { - VkDescriptorSetLayout descriptorset_layouts[1] = {m_descriptor_infos[_axis].layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayout* descriptorset_layouts[1] = {m_descriptor_infos[_axis].layout}; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = 1; pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout(m_vulkan_rhi->m_device, - &pipeline_layout_create_info, - nullptr, - &m_render_pipelines[_render_pipeline_type_axis].layout) != VK_SUCCESS) + if (m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[_render_pipeline_type_axis].layout) != RHI_SUCCESS) { throw std::runtime_error("create axis pipeline layout"); } - VkShaderModule vert_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, AXIS_VERT); - VkShaderModule frag_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, AXIS_FRAG); + RHIShader* vert_shader_module = m_rhi->createShaderModule(AXIS_VERT); + RHIShader* frag_shader_module = m_rhi->createShaderModule(AXIS_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; // vert_pipeline_shader_stage_create_info.pSpecializationInfo - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; auto vertex_binding_descriptions = MeshVertex::getBindingDescriptions(); auto vertex_attribute_descriptions = MeshVertex::getAttributeDescriptions(); - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = vertex_binding_descriptions.size(); vertex_input_state_create_info.pVertexBindingDescriptions = &vertex_binding_descriptions[0]; vertex_input_state_create_info.vertexAttributeDescriptionCount = vertex_attribute_descriptions.size(); vertex_input_state_create_info.pVertexAttributeDescriptions = &vertex_attribute_descriptions[0]; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_NONE; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_NONE; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_COUNTER_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; - - VkPipelineColorBlendAttachmentState color_blend_attachment_state {}; - color_blend_attachment_state.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | - VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachment_state.blendEnable = VK_FALSE; - color_blend_attachment_state.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; + + RHIPipelineColorBlendAttachmentState color_blend_attachment_state {}; + color_blend_attachment_state.colorWriteMask = RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | + RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachment_state.blendEnable = RHI_FALSE; + color_blend_attachment_state.srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachment_state.srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = 1; color_blend_state_create_info.pAttachments = &color_blend_attachment_state; color_blend_state_create_info.blendConstants[0] = 0.0f; @@ -1524,22 +1470,22 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_FALSE; - depth_stencil_create_info.depthWriteEnable = VK_FALSE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; - - VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_FALSE; + depth_stencil_create_info.depthWriteEnable = RHI_FALSE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; + + RHIDynamicState dynamic_states[] = {RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR}; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 2; dynamic_state_create_info.pDynamicStates = dynamic_states; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -1552,21 +1498,19 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[_render_pipeline_type_axis].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = _main_camera_subpass_ui; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines(m_vulkan_rhi->m_device, - VK_NULL_HANDLE, - 1, - &pipelineInfo, - nullptr, - &m_render_pipelines[_render_pipeline_type_axis].pipeline) != VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, + 1, + &pipelineInfo, + m_render_pipelines[_render_pipeline_type_axis].pipeline)) { throw std::runtime_error("create axis graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } } @@ -1581,21 +1525,19 @@ namespace Piccolo void MainCameraPass::setupModelGlobalDescriptorSet() { // update common model's global descriptor set - VkDescriptorSetAllocateInfo mesh_global_descriptor_set_alloc_info; - mesh_global_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHIDescriptorSetAllocateInfo mesh_global_descriptor_set_alloc_info; + mesh_global_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; mesh_global_descriptor_set_alloc_info.pNext = NULL; - mesh_global_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + mesh_global_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); mesh_global_descriptor_set_alloc_info.descriptorSetCount = 1; mesh_global_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[_mesh_global].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &mesh_global_descriptor_set_alloc_info, - &m_descriptor_infos[_mesh_global].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&mesh_global_descriptor_set_alloc_info, m_descriptor_infos[_mesh_global].descriptor_set)) { throw std::runtime_error("allocate mesh global descriptor set"); } - VkDescriptorBufferInfo mesh_perframe_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_perframe_storage_buffer_info = {}; // this offset plus dynamic_offset should not be greater than the size of the buffer mesh_perframe_storage_buffer_info.offset = 0; // the range means the size actually used by the shader per draw call @@ -1604,7 +1546,7 @@ namespace Piccolo assert(mesh_perframe_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorBufferInfo mesh_perdrawcall_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_perdrawcall_storage_buffer_info = {}; mesh_perdrawcall_storage_buffer_info.offset = 0; mesh_perdrawcall_storage_buffer_info.range = sizeof(MeshPerdrawcallStorageBufferObject); mesh_perdrawcall_storage_buffer_info.buffer = @@ -1612,7 +1554,7 @@ namespace Piccolo assert(mesh_perdrawcall_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorBufferInfo mesh_per_drawcall_vertex_blending_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_per_drawcall_vertex_blending_storage_buffer_info = {}; mesh_per_drawcall_vertex_blending_storage_buffer_info.offset = 0; mesh_per_drawcall_vertex_blending_storage_buffer_info.range = sizeof(MeshPerdrawcallVertexBlendingStorageBufferObject); @@ -1621,69 +1563,69 @@ namespace Piccolo assert(mesh_per_drawcall_vertex_blending_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorImageInfo brdf_texture_image_info = {}; + RHIDescriptorImageInfo brdf_texture_image_info = {}; brdf_texture_image_info.sampler = m_global_render_resource->_ibl_resource._brdfLUT_texture_sampler; brdf_texture_image_info.imageView = m_global_render_resource->_ibl_resource._brdfLUT_texture_image_view; - brdf_texture_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + brdf_texture_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkDescriptorImageInfo irradiance_texture_image_info = {}; + RHIDescriptorImageInfo irradiance_texture_image_info = {}; irradiance_texture_image_info.sampler = m_global_render_resource->_ibl_resource._irradiance_texture_sampler; irradiance_texture_image_info.imageView = m_global_render_resource->_ibl_resource._irradiance_texture_image_view; - irradiance_texture_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + irradiance_texture_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkDescriptorImageInfo specular_texture_image_info {}; + RHIDescriptorImageInfo specular_texture_image_info {}; specular_texture_image_info.sampler = m_global_render_resource->_ibl_resource._specular_texture_sampler; specular_texture_image_info.imageView = m_global_render_resource->_ibl_resource._specular_texture_image_view; - specular_texture_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + specular_texture_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkDescriptorImageInfo point_light_shadow_texture_image_info {}; + RHIDescriptorImageInfo point_light_shadow_texture_image_info{}; point_light_shadow_texture_image_info.sampler = - VulkanUtil::getOrCreateNearestSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); - point_light_shadow_texture_image_info.imageView = m_point_light_shadow_color_image_view; - point_light_shadow_texture_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + m_rhi->getOrCreateDefaultSampler(Default_Sampler_Nearest); + point_light_shadow_texture_image_info.imageView = m_point_light_shadow_color_image_view; + point_light_shadow_texture_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkDescriptorImageInfo directional_light_shadow_texture_image_info {}; + RHIDescriptorImageInfo directional_light_shadow_texture_image_info{}; directional_light_shadow_texture_image_info.sampler = - VulkanUtil::getOrCreateNearestSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); - directional_light_shadow_texture_image_info.imageView = m_directional_light_shadow_color_image_view; - directional_light_shadow_texture_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + m_rhi->getOrCreateDefaultSampler(Default_Sampler_Nearest); + directional_light_shadow_texture_image_info.imageView = m_directional_light_shadow_color_image_view; + directional_light_shadow_texture_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkWriteDescriptorSet mesh_descriptor_writes_info[8]; + RHIWriteDescriptorSet mesh_descriptor_writes_info[8]; - mesh_descriptor_writes_info[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + mesh_descriptor_writes_info[0].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_descriptor_writes_info[0].pNext = NULL; mesh_descriptor_writes_info[0].dstSet = m_descriptor_infos[_mesh_global].descriptor_set; mesh_descriptor_writes_info[0].dstBinding = 0; mesh_descriptor_writes_info[0].dstArrayElement = 0; - mesh_descriptor_writes_info[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + mesh_descriptor_writes_info[0].descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_descriptor_writes_info[0].descriptorCount = 1; mesh_descriptor_writes_info[0].pBufferInfo = &mesh_perframe_storage_buffer_info; - mesh_descriptor_writes_info[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + mesh_descriptor_writes_info[1].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_descriptor_writes_info[1].pNext = NULL; mesh_descriptor_writes_info[1].dstSet = m_descriptor_infos[_mesh_global].descriptor_set; mesh_descriptor_writes_info[1].dstBinding = 1; mesh_descriptor_writes_info[1].dstArrayElement = 0; - mesh_descriptor_writes_info[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + mesh_descriptor_writes_info[1].descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_descriptor_writes_info[1].descriptorCount = 1; mesh_descriptor_writes_info[1].pBufferInfo = &mesh_perdrawcall_storage_buffer_info; - mesh_descriptor_writes_info[2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + mesh_descriptor_writes_info[2].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_descriptor_writes_info[2].pNext = NULL; mesh_descriptor_writes_info[2].dstSet = m_descriptor_infos[_mesh_global].descriptor_set; mesh_descriptor_writes_info[2].dstBinding = 2; mesh_descriptor_writes_info[2].dstArrayElement = 0; - mesh_descriptor_writes_info[2].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + mesh_descriptor_writes_info[2].descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_descriptor_writes_info[2].descriptorCount = 1; mesh_descriptor_writes_info[2].pBufferInfo = &mesh_per_drawcall_vertex_blending_storage_buffer_info; - mesh_descriptor_writes_info[3].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + mesh_descriptor_writes_info[3].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_descriptor_writes_info[3].pNext = NULL; mesh_descriptor_writes_info[3].dstSet = m_descriptor_infos[_mesh_global].descriptor_set; mesh_descriptor_writes_info[3].dstBinding = 3; mesh_descriptor_writes_info[3].dstArrayElement = 0; - mesh_descriptor_writes_info[3].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + mesh_descriptor_writes_info[3].descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; mesh_descriptor_writes_info[3].descriptorCount = 1; mesh_descriptor_writes_info[3].pImageInfo = &brdf_texture_image_info; @@ -1703,131 +1645,123 @@ namespace Piccolo mesh_descriptor_writes_info[7].dstBinding = 7; mesh_descriptor_writes_info[7].pImageInfo = &directional_light_shadow_texture_image_info; - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - sizeof(mesh_descriptor_writes_info) / sizeof(mesh_descriptor_writes_info[0]), - mesh_descriptor_writes_info, - 0, - NULL); + m_rhi->updateDescriptorSets(sizeof(mesh_descriptor_writes_info) / sizeof(mesh_descriptor_writes_info[0]), + mesh_descriptor_writes_info, + 0, + NULL); } void MainCameraPass::setupSkyboxDescriptorSet() { - VkDescriptorSetAllocateInfo skybox_descriptor_set_alloc_info; - skybox_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHIDescriptorSetAllocateInfo skybox_descriptor_set_alloc_info; + skybox_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; skybox_descriptor_set_alloc_info.pNext = NULL; - skybox_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + skybox_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); skybox_descriptor_set_alloc_info.descriptorSetCount = 1; skybox_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[_skybox].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &skybox_descriptor_set_alloc_info, - &m_descriptor_infos[_skybox].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&skybox_descriptor_set_alloc_info, m_descriptor_infos[_skybox].descriptor_set)) { throw std::runtime_error("allocate skybox descriptor set"); } - VkDescriptorBufferInfo mesh_perframe_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_perframe_storage_buffer_info = {}; mesh_perframe_storage_buffer_info.offset = 0; mesh_perframe_storage_buffer_info.range = sizeof(MeshPerframeStorageBufferObject); mesh_perframe_storage_buffer_info.buffer = m_global_render_resource->_storage_buffer._global_upload_ringbuffer; assert(mesh_perframe_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorImageInfo specular_texture_image_info = {}; + RHIDescriptorImageInfo specular_texture_image_info = {}; specular_texture_image_info.sampler = m_global_render_resource->_ibl_resource._specular_texture_sampler; specular_texture_image_info.imageView = m_global_render_resource->_ibl_resource._specular_texture_image_view; - specular_texture_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + specular_texture_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkWriteDescriptorSet skybox_descriptor_writes_info[2]; + RHIWriteDescriptorSet skybox_descriptor_writes_info[2]; - skybox_descriptor_writes_info[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + skybox_descriptor_writes_info[0].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; skybox_descriptor_writes_info[0].pNext = NULL; skybox_descriptor_writes_info[0].dstSet = m_descriptor_infos[_skybox].descriptor_set; skybox_descriptor_writes_info[0].dstBinding = 0; skybox_descriptor_writes_info[0].dstArrayElement = 0; - skybox_descriptor_writes_info[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + skybox_descriptor_writes_info[0].descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; skybox_descriptor_writes_info[0].descriptorCount = 1; skybox_descriptor_writes_info[0].pBufferInfo = &mesh_perframe_storage_buffer_info; - skybox_descriptor_writes_info[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + skybox_descriptor_writes_info[1].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; skybox_descriptor_writes_info[1].pNext = NULL; skybox_descriptor_writes_info[1].dstSet = m_descriptor_infos[_skybox].descriptor_set; skybox_descriptor_writes_info[1].dstBinding = 1; skybox_descriptor_writes_info[1].dstArrayElement = 0; - skybox_descriptor_writes_info[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + skybox_descriptor_writes_info[1].descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; skybox_descriptor_writes_info[1].descriptorCount = 1; skybox_descriptor_writes_info[1].pImageInfo = &specular_texture_image_info; - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, 2, skybox_descriptor_writes_info, 0, NULL); + m_rhi->updateDescriptorSets(2, skybox_descriptor_writes_info, 0, NULL); } void MainCameraPass::setupAxisDescriptorSet() { - VkDescriptorSetAllocateInfo axis_descriptor_set_alloc_info; - axis_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHIDescriptorSetAllocateInfo axis_descriptor_set_alloc_info; + axis_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; axis_descriptor_set_alloc_info.pNext = NULL; - axis_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + axis_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); axis_descriptor_set_alloc_info.descriptorSetCount = 1; axis_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[_axis].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &axis_descriptor_set_alloc_info, - &m_descriptor_infos[_axis].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&axis_descriptor_set_alloc_info, m_descriptor_infos[_axis].descriptor_set)) { throw std::runtime_error("allocate axis descriptor set"); } - VkDescriptorBufferInfo mesh_perframe_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_perframe_storage_buffer_info = {}; mesh_perframe_storage_buffer_info.offset = 0; mesh_perframe_storage_buffer_info.range = sizeof(MeshPerframeStorageBufferObject); mesh_perframe_storage_buffer_info.buffer = m_global_render_resource->_storage_buffer._global_upload_ringbuffer; assert(mesh_perframe_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorBufferInfo axis_storage_buffer_info = {}; + RHIDescriptorBufferInfo axis_storage_buffer_info = {}; axis_storage_buffer_info.offset = 0; axis_storage_buffer_info.range = sizeof(AxisStorageBufferObject); axis_storage_buffer_info.buffer = m_global_render_resource->_storage_buffer._axis_inefficient_storage_buffer; - VkWriteDescriptorSet axis_descriptor_writes_info[2]; + RHIWriteDescriptorSet axis_descriptor_writes_info[2]; - axis_descriptor_writes_info[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + axis_descriptor_writes_info[0].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; axis_descriptor_writes_info[0].pNext = NULL; axis_descriptor_writes_info[0].dstSet = m_descriptor_infos[_axis].descriptor_set; axis_descriptor_writes_info[0].dstBinding = 0; axis_descriptor_writes_info[0].dstArrayElement = 0; - axis_descriptor_writes_info[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + axis_descriptor_writes_info[0].descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; axis_descriptor_writes_info[0].descriptorCount = 1; axis_descriptor_writes_info[0].pBufferInfo = &mesh_perframe_storage_buffer_info; - axis_descriptor_writes_info[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + axis_descriptor_writes_info[1].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; axis_descriptor_writes_info[1].pNext = NULL; axis_descriptor_writes_info[1].dstSet = m_descriptor_infos[_axis].descriptor_set; axis_descriptor_writes_info[1].dstBinding = 1; axis_descriptor_writes_info[1].dstArrayElement = 0; - axis_descriptor_writes_info[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + axis_descriptor_writes_info[1].descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; axis_descriptor_writes_info[1].descriptorCount = 1; axis_descriptor_writes_info[1].pBufferInfo = &axis_storage_buffer_info; - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - (uint32_t)(sizeof(axis_descriptor_writes_info) / sizeof(axis_descriptor_writes_info[0])), - axis_descriptor_writes_info, - 0, - NULL); + m_rhi->updateDescriptorSets((uint32_t)(sizeof(axis_descriptor_writes_info) / sizeof(axis_descriptor_writes_info[0])), + axis_descriptor_writes_info, + 0, + NULL); } void MainCameraPass::setupGbufferLightingDescriptorSet() { - VkDescriptorSetAllocateInfo gbuffer_light_global_descriptor_set_alloc_info; - gbuffer_light_global_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHIDescriptorSetAllocateInfo gbuffer_light_global_descriptor_set_alloc_info; + gbuffer_light_global_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; gbuffer_light_global_descriptor_set_alloc_info.pNext = NULL; - gbuffer_light_global_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + gbuffer_light_global_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); gbuffer_light_global_descriptor_set_alloc_info.descriptorSetCount = 1; gbuffer_light_global_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[_deferred_lighting].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &gbuffer_light_global_descriptor_set_alloc_info, - &m_descriptor_infos[_deferred_lighting].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&gbuffer_light_global_descriptor_set_alloc_info, m_descriptor_infos[_deferred_lighting].descriptor_set)) { throw std::runtime_error("allocate gbuffer light global descriptor set"); } @@ -1835,100 +1769,95 @@ namespace Piccolo void MainCameraPass::setupFramebufferDescriptorSet() { - VkDescriptorImageInfo gbuffer_normal_input_attachment_info = {}; - gbuffer_normal_input_attachment_info.sampler = - VulkanUtil::getOrCreateNearestSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); + RHIDescriptorImageInfo gbuffer_normal_input_attachment_info = {}; + gbuffer_normal_input_attachment_info.sampler = m_rhi->getOrCreateDefaultSampler(Default_Sampler_Nearest); gbuffer_normal_input_attachment_info.imageView = m_framebuffer.attachments[_main_camera_pass_gbuffer_a].view; - gbuffer_normal_input_attachment_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + gbuffer_normal_input_attachment_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkDescriptorImageInfo gbuffer_metallic_roughness_shadingmodeid_input_attachment_info = {}; - gbuffer_metallic_roughness_shadingmodeid_input_attachment_info.sampler = - VulkanUtil::getOrCreateNearestSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); + RHIDescriptorImageInfo gbuffer_metallic_roughness_shadingmodeid_input_attachment_info = {}; + gbuffer_metallic_roughness_shadingmodeid_input_attachment_info.sampler = m_rhi->getOrCreateDefaultSampler(Default_Sampler_Nearest); gbuffer_metallic_roughness_shadingmodeid_input_attachment_info.imageView = m_framebuffer.attachments[_main_camera_pass_gbuffer_b].view; gbuffer_metallic_roughness_shadingmodeid_input_attachment_info.imageLayout = - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkDescriptorImageInfo gbuffer_albedo_input_attachment_info = {}; - gbuffer_albedo_input_attachment_info.sampler = - VulkanUtil::getOrCreateNearestSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); + RHIDescriptorImageInfo gbuffer_albedo_input_attachment_info = {}; + gbuffer_albedo_input_attachment_info.sampler = m_rhi->getOrCreateDefaultSampler(Default_Sampler_Nearest); gbuffer_albedo_input_attachment_info.imageView = m_framebuffer.attachments[_main_camera_pass_gbuffer_c].view; - gbuffer_albedo_input_attachment_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + gbuffer_albedo_input_attachment_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkDescriptorImageInfo depth_input_attachment_info = {}; - depth_input_attachment_info.sampler = - VulkanUtil::getOrCreateNearestSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); - depth_input_attachment_info.imageView = m_vulkan_rhi->m_depth_image_view; - depth_input_attachment_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + RHIDescriptorImageInfo depth_input_attachment_info = {}; + depth_input_attachment_info.sampler = m_rhi->getOrCreateDefaultSampler(Default_Sampler_Nearest); + depth_input_attachment_info.imageView = m_rhi->getDepthImageInfo().depth_image_view; + depth_input_attachment_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkWriteDescriptorSet deferred_lighting_descriptor_writes_info[4]; + RHIWriteDescriptorSet deferred_lighting_descriptor_writes_info[4]; - VkWriteDescriptorSet& gbuffer_normal_descriptor_input_attachment_write_info = + RHIWriteDescriptorSet& gbuffer_normal_descriptor_input_attachment_write_info = deferred_lighting_descriptor_writes_info[0]; - gbuffer_normal_descriptor_input_attachment_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + gbuffer_normal_descriptor_input_attachment_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; gbuffer_normal_descriptor_input_attachment_write_info.pNext = NULL; gbuffer_normal_descriptor_input_attachment_write_info.dstSet = m_descriptor_infos[_deferred_lighting].descriptor_set; gbuffer_normal_descriptor_input_attachment_write_info.dstBinding = 0; gbuffer_normal_descriptor_input_attachment_write_info.dstArrayElement = 0; - gbuffer_normal_descriptor_input_attachment_write_info.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + gbuffer_normal_descriptor_input_attachment_write_info.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; gbuffer_normal_descriptor_input_attachment_write_info.descriptorCount = 1; gbuffer_normal_descriptor_input_attachment_write_info.pImageInfo = &gbuffer_normal_input_attachment_info; - VkWriteDescriptorSet& gbuffer_metallic_roughness_shadingmodeid_descriptor_input_attachment_write_info = + RHIWriteDescriptorSet& gbuffer_metallic_roughness_shadingmodeid_descriptor_input_attachment_write_info = deferred_lighting_descriptor_writes_info[1]; gbuffer_metallic_roughness_shadingmodeid_descriptor_input_attachment_write_info.sType = - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; gbuffer_metallic_roughness_shadingmodeid_descriptor_input_attachment_write_info.pNext = NULL; gbuffer_metallic_roughness_shadingmodeid_descriptor_input_attachment_write_info.dstSet = m_descriptor_infos[_deferred_lighting].descriptor_set; gbuffer_metallic_roughness_shadingmodeid_descriptor_input_attachment_write_info.dstBinding = 1; gbuffer_metallic_roughness_shadingmodeid_descriptor_input_attachment_write_info.dstArrayElement = 0; gbuffer_metallic_roughness_shadingmodeid_descriptor_input_attachment_write_info.descriptorType = - VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; gbuffer_metallic_roughness_shadingmodeid_descriptor_input_attachment_write_info.descriptorCount = 1; gbuffer_metallic_roughness_shadingmodeid_descriptor_input_attachment_write_info.pImageInfo = &gbuffer_metallic_roughness_shadingmodeid_input_attachment_info; - VkWriteDescriptorSet& gbuffer_albedo_descriptor_input_attachment_write_info = + RHIWriteDescriptorSet& gbuffer_albedo_descriptor_input_attachment_write_info = deferred_lighting_descriptor_writes_info[2]; - gbuffer_albedo_descriptor_input_attachment_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + gbuffer_albedo_descriptor_input_attachment_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; gbuffer_albedo_descriptor_input_attachment_write_info.pNext = NULL; gbuffer_albedo_descriptor_input_attachment_write_info.dstSet = m_descriptor_infos[_deferred_lighting].descriptor_set; gbuffer_albedo_descriptor_input_attachment_write_info.dstBinding = 2; gbuffer_albedo_descriptor_input_attachment_write_info.dstArrayElement = 0; - gbuffer_albedo_descriptor_input_attachment_write_info.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + gbuffer_albedo_descriptor_input_attachment_write_info.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; gbuffer_albedo_descriptor_input_attachment_write_info.descriptorCount = 1; gbuffer_albedo_descriptor_input_attachment_write_info.pImageInfo = &gbuffer_albedo_input_attachment_info; - VkWriteDescriptorSet& depth_descriptor_input_attachment_write_info = + RHIWriteDescriptorSet& depth_descriptor_input_attachment_write_info = deferred_lighting_descriptor_writes_info[3]; - depth_descriptor_input_attachment_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + depth_descriptor_input_attachment_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; depth_descriptor_input_attachment_write_info.pNext = NULL; depth_descriptor_input_attachment_write_info.dstSet = m_descriptor_infos[_deferred_lighting].descriptor_set; depth_descriptor_input_attachment_write_info.dstBinding = 3; depth_descriptor_input_attachment_write_info.dstArrayElement = 0; - depth_descriptor_input_attachment_write_info.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + depth_descriptor_input_attachment_write_info.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; depth_descriptor_input_attachment_write_info.descriptorCount = 1; depth_descriptor_input_attachment_write_info.pImageInfo = &depth_input_attachment_info; - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - sizeof(deferred_lighting_descriptor_writes_info) / - sizeof(deferred_lighting_descriptor_writes_info[0]), - deferred_lighting_descriptor_writes_info, - 0, - NULL); + m_rhi->updateDescriptorSets(sizeof(deferred_lighting_descriptor_writes_info) / + sizeof(deferred_lighting_descriptor_writes_info[0]), + deferred_lighting_descriptor_writes_info, + 0, + NULL); } void MainCameraPass::setupSwapchainFramebuffers() { - m_swapchain_framebuffers.resize(m_vulkan_rhi->m_swapchain_imageviews.size()); + m_swapchain_framebuffers.resize(m_rhi->getSwapchainInfo().imageViews.size()); // create frame buffer for every imageview - for (size_t i = 0; i < m_vulkan_rhi->m_swapchain_imageviews.size(); i++) + for (size_t i = 0; i < m_rhi->getSwapchainInfo().imageViews.size(); i++) { - VkImageView framebuffer_attachments_for_image_view[_main_camera_pass_attachment_count] = { + RHIImageView* framebuffer_attachments_for_image_view[_main_camera_pass_attachment_count] = { m_framebuffer.attachments[_main_camera_pass_gbuffer_a].view, m_framebuffer.attachments[_main_camera_pass_gbuffer_b].view, m_framebuffer.attachments[_main_camera_pass_gbuffer_c].view, @@ -1936,23 +1865,22 @@ namespace Piccolo m_framebuffer.attachments[_main_camera_pass_backup_buffer_even].view, m_framebuffer.attachments[_main_camera_pass_post_process_buffer_odd].view, m_framebuffer.attachments[_main_camera_pass_post_process_buffer_even].view, - m_vulkan_rhi->m_depth_image_view, - m_vulkan_rhi->m_swapchain_imageviews[i]}; + m_rhi->getDepthImageInfo().depth_image_view, + m_rhi->getSwapchainInfo().imageViews[i] }; - VkFramebufferCreateInfo framebuffer_create_info {}; - framebuffer_create_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + RHIFramebufferCreateInfo framebuffer_create_info {}; + framebuffer_create_info.sType = RHI_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; framebuffer_create_info.flags = 0U; framebuffer_create_info.renderPass = m_framebuffer.render_pass; framebuffer_create_info.attachmentCount = (sizeof(framebuffer_attachments_for_image_view) / sizeof(framebuffer_attachments_for_image_view[0])); framebuffer_create_info.pAttachments = framebuffer_attachments_for_image_view; - framebuffer_create_info.width = m_vulkan_rhi->m_swapchain_extent.width; - framebuffer_create_info.height = m_vulkan_rhi->m_swapchain_extent.height; + framebuffer_create_info.width = m_rhi->getSwapchainInfo().extent.width; + framebuffer_create_info.height = m_rhi->getSwapchainInfo().extent.height; framebuffer_create_info.layers = 1; - if (vkCreateFramebuffer( - m_vulkan_rhi->m_device, &framebuffer_create_info, nullptr, &m_swapchain_framebuffers[i]) != - VK_SUCCESS) + m_swapchain_framebuffers[i] = new VulkanFramebuffer(); + if (RHI_SUCCESS != m_rhi->createFramebuffer(&framebuffer_create_info, m_swapchain_framebuffers[i])) { throw std::runtime_error("create main camera framebuffer"); } @@ -1963,14 +1891,14 @@ namespace Piccolo { for (size_t i = 0; i < m_framebuffer.attachments.size(); i++) { - vkDestroyImage(m_vulkan_rhi->m_device, m_framebuffer.attachments[i].image, nullptr); - vkDestroyImageView(m_vulkan_rhi->m_device, m_framebuffer.attachments[i].view, nullptr); - vkFreeMemory(m_vulkan_rhi->m_device, m_framebuffer.attachments[i].mem, nullptr); + m_rhi->destroyImage(m_framebuffer.attachments[i].image); + m_rhi->destroyImageView(m_framebuffer.attachments[i].view); + m_rhi->freeMemory(m_framebuffer.attachments[i].mem); } for (auto framebuffer : m_swapchain_framebuffers) { - vkDestroyFramebuffer(m_vulkan_rhi->m_device, framebuffer, NULL); + m_rhi->destroyFramebuffer(framebuffer); } setupAttachments(); @@ -1991,14 +1919,14 @@ namespace Piccolo uint32_t current_swapchain_image_index) { { - VkRenderPassBeginInfo renderpass_begin_info {}; - renderpass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + RHIRenderPassBeginInfo renderpass_begin_info {}; + renderpass_begin_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; renderpass_begin_info.renderPass = m_framebuffer.render_pass; renderpass_begin_info.framebuffer = m_swapchain_framebuffers[current_swapchain_image_index]; renderpass_begin_info.renderArea.offset = {0, 0}; - renderpass_begin_info.renderArea.extent = m_vulkan_rhi->m_swapchain_extent; + renderpass_begin_info.renderArea.extent = m_rhi->getSwapchainInfo().extent; - VkClearValue clear_values[_main_camera_pass_attachment_count]; + RHIClearValue clear_values[_main_camera_pass_attachment_count]; clear_values[_main_camera_pass_gbuffer_a].color = {{0.0f, 0.0f, 0.0f, 0.0f}}; clear_values[_main_camera_pass_gbuffer_b].color = {{0.0f, 0.0f, 0.0f, 0.0f}}; clear_values[_main_camera_pass_gbuffer_c].color = {{0.0f, 0.0f, 0.0f, 0.0f}}; @@ -2011,100 +1939,76 @@ namespace Piccolo renderpass_begin_info.clearValueCount = (sizeof(clear_values) / sizeof(clear_values[0])); renderpass_begin_info.pClearValues = clear_values; - m_vulkan_rhi->m_vk_cmd_begin_render_pass( - m_vulkan_rhi->m_current_command_buffer, &renderpass_begin_info, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdBeginRenderPassPFN(m_rhi->getCurrentCommandBuffer(), &renderpass_begin_info, RHI_SUBPASS_CONTENTS_INLINE); } - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "BasePass", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "BasePass", color); drawMeshGbuffer(); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Deferred Lighting", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Deferred Lighting", color); drawDeferredLighting(); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Forward Lighting", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Forward Lighting", color); particle_pass.draw(); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); tone_mapping_pass.draw(); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); color_grading_pass.draw(); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); if (m_enable_fxaa) fxaa_pass.draw(); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); - VkClearAttachment clear_attachments[1]; - clear_attachments[0].aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + RHIClearAttachment clear_attachments[1]; + clear_attachments[0].aspectMask = RHI_IMAGE_ASPECT_COLOR_BIT; clear_attachments[0].colorAttachment = 0; clear_attachments[0].clearValue.color.float32[0] = 0.0; clear_attachments[0].clearValue.color.float32[1] = 0.0; clear_attachments[0].clearValue.color.float32[2] = 0.0; clear_attachments[0].clearValue.color.float32[3] = 0.0; - VkClearRect clear_rects[1]; + RHIClearRect clear_rects[1]; clear_rects[0].baseArrayLayer = 0; clear_rects[0].layerCount = 1; clear_rects[0].rect.offset.x = 0; clear_rects[0].rect.offset.y = 0; - clear_rects[0].rect.extent.width = m_vulkan_rhi->m_swapchain_extent.width; - clear_rects[0].rect.extent.height = m_vulkan_rhi->m_swapchain_extent.height; - m_vulkan_rhi->m_vk_cmd_clear_attachments(m_vulkan_rhi->m_current_command_buffer, - sizeof(clear_attachments) / sizeof(clear_attachments[0]), - clear_attachments, - sizeof(clear_rects) / sizeof(clear_rects[0]), - clear_rects); + clear_rects[0].rect.extent.width = m_rhi->getSwapchainInfo().extent.width; + clear_rects[0].rect.extent.height = m_rhi->getSwapchainInfo().extent.height; + m_rhi->cmdClearAttachmentsPFN(m_rhi->getCurrentCommandBuffer(), + sizeof(clear_attachments) / sizeof(clear_attachments[0]), + clear_attachments, + sizeof(clear_rects) / sizeof(clear_rects[0]), + clear_rects); drawAxis(); ui_pass.draw(); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); combine_ui_pass.draw(); - m_vulkan_rhi->m_vk_cmd_end_render_pass(m_vulkan_rhi->m_current_command_buffer); + m_rhi->cmdEndRenderPassPFN(m_rhi->getCurrentCommandBuffer()); } void MainCameraPass::drawForward(ColorGradingPass& color_grading_pass, @@ -2116,14 +2020,14 @@ namespace Piccolo uint32_t current_swapchain_image_index) { { - VkRenderPassBeginInfo renderpass_begin_info {}; - renderpass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + RHIRenderPassBeginInfo renderpass_begin_info {}; + renderpass_begin_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; renderpass_begin_info.renderPass = m_framebuffer.render_pass; renderpass_begin_info.framebuffer = m_swapchain_framebuffers[current_swapchain_image_index]; renderpass_begin_info.renderArea.offset = {0, 0}; - renderpass_begin_info.renderArea.extent = m_vulkan_rhi->m_swapchain_extent; + renderpass_begin_info.renderArea.extent = m_rhi->getSwapchainInfo().extent; - VkClearValue clear_values[_main_camera_pass_attachment_count]; + RHIClearValue clear_values[_main_camera_pass_attachment_count]; clear_values[_main_camera_pass_gbuffer_a].color = {{0.0f, 0.0f, 0.0f, 0.0f}}; clear_values[_main_camera_pass_gbuffer_b].color = {{0.0f, 0.0f, 0.0f, 0.0f}}; clear_values[_main_camera_pass_gbuffer_c].color = {{0.0f, 0.0f, 0.0f, 0.0f}}; @@ -2134,74 +2038,66 @@ namespace Piccolo renderpass_begin_info.clearValueCount = (sizeof(clear_values) / sizeof(clear_values[0])); renderpass_begin_info.pClearValues = clear_values; - m_vulkan_rhi->m_vk_cmd_begin_render_pass( - m_vulkan_rhi->m_current_command_buffer, &renderpass_begin_info, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdBeginRenderPassPFN(m_rhi->getCurrentCommandBuffer(), &renderpass_begin_info, RHI_SUBPASS_CONTENTS_INLINE); } - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Forward Lighting", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Forward Lighting", color); drawMeshLighting(); drawSkybox(); particle_pass.draw(); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); tone_mapping_pass.draw(); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); color_grading_pass.draw(); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); if (m_enable_fxaa) fxaa_pass.draw(); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); - VkClearAttachment clear_attachments[1]; - clear_attachments[0].aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + RHIClearAttachment clear_attachments[1]; + clear_attachments[0].aspectMask = RHI_IMAGE_ASPECT_COLOR_BIT; clear_attachments[0].colorAttachment = 0; clear_attachments[0].clearValue.color.float32[0] = 0.0; clear_attachments[0].clearValue.color.float32[1] = 0.0; clear_attachments[0].clearValue.color.float32[2] = 0.0; clear_attachments[0].clearValue.color.float32[3] = 0.0; - VkClearRect clear_rects[1]; + RHIClearRect clear_rects[1]; clear_rects[0].baseArrayLayer = 0; clear_rects[0].layerCount = 1; clear_rects[0].rect.offset.x = 0; clear_rects[0].rect.offset.y = 0; - clear_rects[0].rect.extent.width = m_vulkan_rhi->m_swapchain_extent.width; - clear_rects[0].rect.extent.height = m_vulkan_rhi->m_swapchain_extent.height; - m_vulkan_rhi->m_vk_cmd_clear_attachments(m_vulkan_rhi->m_current_command_buffer, - sizeof(clear_attachments) / sizeof(clear_attachments[0]), - clear_attachments, - sizeof(clear_rects) / sizeof(clear_rects[0]), - clear_rects); + clear_rects[0].rect.extent.width = m_rhi->getSwapchainInfo().extent.width; + clear_rects[0].rect.extent.height = m_rhi->getSwapchainInfo().extent.height; + m_rhi->cmdClearAttachmentsPFN(m_rhi->getCurrentCommandBuffer(), + sizeof(clear_attachments) / sizeof(clear_attachments[0]), + clear_attachments, + sizeof(clear_rects) / sizeof(clear_rects[0]), + clear_rects); drawAxis(); ui_pass.draw(); - m_vulkan_rhi->m_vk_cmd_next_subpass(m_vulkan_rhi->m_current_command_buffer, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdNextSubpassPFN(m_rhi->getCurrentCommandBuffer(), RHI_SUBPASS_CONTENTS_INLINE); combine_ui_pass.draw(); - m_vulkan_rhi->m_vk_cmd_end_render_pass(m_vulkan_rhi->m_current_command_buffer); + m_rhi->cmdEndRenderPassPFN(m_rhi->getCurrentCommandBuffer()); } void MainCameraPass::drawMeshGbuffer() @@ -2232,33 +2128,29 @@ namespace Piccolo mesh_nodes.push_back(temp); } - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Mesh GBuffer", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Mesh GBuffer", color); - m_vulkan_rhi->m_vk_cmd_bind_pipeline(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_mesh_gbuffer].pipeline); - m_vulkan_rhi->m_vk_cmd_set_viewport(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_viewport); - m_vulkan_rhi->m_vk_cmd_set_scissor(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_scissor); + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_mesh_gbuffer].pipeline); + m_rhi->cmdSetViewportPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().viewport); + m_rhi->cmdSetScissorPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().scissor); // perframe storage buffer uint32_t perframe_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); - m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perframe_dynamic_offset + sizeof(MeshPerframeStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); (*reinterpret_cast( reinterpret_cast( @@ -2271,14 +2163,14 @@ namespace Piccolo auto& mesh_instanced = pair1.second; // bind per material - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_mesh_gbuffer].layout, - 2, - 1, - &material.material_descriptor_set, - 0, - NULL); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_mesh_gbuffer].layout, + 2, + 1, + &material.material_descriptor_set, + 0, + NULL); // TODO: render from near to far @@ -2291,27 +2183,26 @@ namespace Piccolo if (total_instance_count > 0) { // bind per mesh - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets( - m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_mesh_gbuffer].layout, - 1, - 1, - &mesh.mesh_vertex_blending_descriptor_set, - 0, - NULL); - - VkBuffer vertex_buffers[] = {mesh.mesh_vertex_position_buffer, + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_mesh_gbuffer].layout, + 1, + 1, + &mesh.mesh_vertex_blending_descriptor_set, + 0, + NULL); + + + RHIBuffer* vertex_buffers[] = {mesh.mesh_vertex_position_buffer, mesh.mesh_vertex_varying_enable_blending_buffer, mesh.mesh_vertex_varying_buffer}; - VkDeviceSize offsets[] = {0, 0, 0}; - m_vulkan_rhi->m_vk_cmd_bind_vertex_buffers(m_vulkan_rhi->m_current_command_buffer, - 0, - (sizeof(vertex_buffers) / sizeof(vertex_buffers[0])), - vertex_buffers, - offsets); - m_vulkan_rhi->m_vk_cmd_bind_index_buffer( - m_vulkan_rhi->m_current_command_buffer, mesh.mesh_index_buffer, 0, VK_INDEX_TYPE_UINT16); + RHIDeviceSize offsets[] = {0, 0, 0}; + m_rhi->cmdBindVertexBuffersPFN(m_rhi->getCurrentCommandBuffer(), + 0, + (sizeof(vertex_buffers) / sizeof(vertex_buffers[0])), + vertex_buffers, + offsets); + m_rhi->cmdBindIndexBufferPFN(m_rhi->getCurrentCommandBuffer(), mesh.mesh_index_buffer, 0, RHI_INDEX_TYPE_UINT16); uint32_t drawcall_max_instance_count = (sizeof(MeshPerdrawcallStorageBufferObject::mesh_instances) / @@ -2330,17 +2221,17 @@ namespace Piccolo // per drawcall storage buffer uint32_t perdrawcall_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perdrawcall_dynamic_offset + sizeof(MeshPerdrawcallStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshPerdrawcallStorageBufferObject& perdrawcall_storage_buffer_object = (*reinterpret_cast( @@ -2371,18 +2262,18 @@ namespace Piccolo { per_drawcall_vertex_blending_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = per_drawcall_vertex_blending_dynamic_offset + sizeof(MeshPerdrawcallVertexBlendingStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshPerdrawcallVertexBlendingStorageBufferObject& per_drawcall_vertex_blending_storage_buffer_object = @@ -2415,75 +2306,71 @@ namespace Piccolo uint32_t dynamic_offsets[3] = {perframe_dynamic_offset, perdrawcall_dynamic_offset, per_drawcall_vertex_blending_dynamic_offset}; - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets( - m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_mesh_gbuffer].layout, - 0, - 1, - &m_descriptor_infos[_mesh_global].descriptor_set, - 3, - dynamic_offsets); - - m_vulkan_rhi->m_vk_cmd_draw_indexed(m_vulkan_rhi->m_current_command_buffer, - mesh.mesh_index_count, - current_instance_count, - 0, - 0, - 0); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_mesh_gbuffer].layout, + 0, + 1, + &m_descriptor_infos[_mesh_global].descriptor_set, + 3, + dynamic_offsets); + + m_rhi->cmdDrawIndexedPFN(m_rhi->getCurrentCommandBuffer(), + mesh.mesh_index_count, + current_instance_count, + 0, + 0, + 0); } } } } - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } void MainCameraPass::drawDeferredLighting() { - m_vulkan_rhi->m_vk_cmd_bind_pipeline(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_deferred_lighting].pipeline); + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_deferred_lighting].pipeline); - m_vulkan_rhi->m_vk_cmd_set_viewport(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_viewport); - m_vulkan_rhi->m_vk_cmd_set_scissor(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_scissor); + m_rhi->cmdSetViewportPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().viewport); + m_rhi->cmdSetScissorPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().scissor); uint32_t perframe_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); - m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perframe_dynamic_offset + sizeof(MeshPerframeStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); (*reinterpret_cast( reinterpret_cast( m_global_render_resource->_storage_buffer._global_upload_ringbuffer_memory_pointer) + perframe_dynamic_offset)) = m_mesh_perframe_storage_buffer_object; - VkDescriptorSet descriptor_sets[3] = {m_descriptor_infos[_mesh_global].descriptor_set, + RHIDescriptorSet* descriptor_sets[3] = {m_descriptor_infos[_mesh_global].descriptor_set, m_descriptor_infos[_deferred_lighting].descriptor_set, m_descriptor_infos[_skybox].descriptor_set}; uint32_t dynamic_offsets[4] = {perframe_dynamic_offset, perframe_dynamic_offset, 0, 0}; - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_deferred_lighting].layout, - 0, - 3, - descriptor_sets, - 4, - dynamic_offsets); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_deferred_lighting].layout, + 0, + 3, + descriptor_sets, + 4, + dynamic_offsets); - vkCmdDraw(m_vulkan_rhi->m_current_command_buffer, 3, 1, 0, 0); + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), 3, 1, 0, 0); } void MainCameraPass::drawMeshLighting() @@ -2514,33 +2401,29 @@ namespace Piccolo mesh_nodes.push_back(temp); } - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Model", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Model", color); - m_vulkan_rhi->m_vk_cmd_bind_pipeline(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_mesh_lighting].pipeline); - m_vulkan_rhi->m_vk_cmd_set_viewport(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_viewport); - m_vulkan_rhi->m_vk_cmd_set_scissor(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_scissor); + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_mesh_lighting].pipeline); + m_rhi->cmdSetViewportPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().viewport); + m_rhi->cmdSetScissorPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().scissor); // perframe storage buffer uint32_t perframe_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); - m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perframe_dynamic_offset + sizeof(MeshPerframeStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); (*reinterpret_cast( reinterpret_cast( @@ -2553,14 +2436,14 @@ namespace Piccolo auto& mesh_instanced = pair1.second; // bind per material - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_mesh_lighting].layout, - 2, - 1, - &material.material_descriptor_set, - 0, - NULL); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_mesh_lighting].layout, + 2, + 1, + &material.material_descriptor_set, + 0, + NULL); // TODO: render from near to far @@ -2573,27 +2456,25 @@ namespace Piccolo if (total_instance_count > 0) { // bind per mesh - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets( - m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_mesh_lighting].layout, - 1, - 1, - &mesh.mesh_vertex_blending_descriptor_set, - 0, - NULL); - - VkBuffer vertex_buffers[] = {mesh.mesh_vertex_position_buffer, + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_mesh_lighting].layout, + 1, + 1, + &mesh.mesh_vertex_blending_descriptor_set, + 0, + NULL); + + RHIBuffer* vertex_buffers[3] = {mesh.mesh_vertex_position_buffer, mesh.mesh_vertex_varying_enable_blending_buffer, mesh.mesh_vertex_varying_buffer}; - VkDeviceSize offsets[] = {0, 0, 0}; - m_vulkan_rhi->m_vk_cmd_bind_vertex_buffers(m_vulkan_rhi->m_current_command_buffer, - 0, - (sizeof(vertex_buffers) / sizeof(vertex_buffers[0])), - vertex_buffers, - offsets); - m_vulkan_rhi->m_vk_cmd_bind_index_buffer( - m_vulkan_rhi->m_current_command_buffer, mesh.mesh_index_buffer, 0, VK_INDEX_TYPE_UINT16); + RHIDeviceSize offsets[] = {0, 0, 0}; + m_rhi->cmdBindVertexBuffersPFN(m_rhi->getCurrentCommandBuffer(), + 0, + (sizeof(vertex_buffers) / sizeof(vertex_buffers[0])), + vertex_buffers, + offsets); + m_rhi->cmdBindIndexBufferPFN(m_rhi->getCurrentCommandBuffer(), mesh.mesh_index_buffer, 0, RHI_INDEX_TYPE_UINT16); uint32_t drawcall_max_instance_count = (sizeof(MeshPerdrawcallStorageBufferObject::mesh_instances) / @@ -2612,17 +2493,17 @@ namespace Piccolo // per drawcall storage buffer uint32_t perdrawcall_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perdrawcall_dynamic_offset + sizeof(MeshPerdrawcallStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshPerdrawcallStorageBufferObject& perdrawcall_storage_buffer_object = (*reinterpret_cast( @@ -2653,18 +2534,18 @@ namespace Piccolo { per_drawcall_vertex_blending_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = per_drawcall_vertex_blending_dynamic_offset + sizeof(MeshPerdrawcallVertexBlendingStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshPerdrawcallVertexBlendingStorageBufferObject& per_drawcall_vertex_blending_storage_buffer_object = @@ -2697,79 +2578,67 @@ namespace Piccolo uint32_t dynamic_offsets[3] = {perframe_dynamic_offset, perdrawcall_dynamic_offset, per_drawcall_vertex_blending_dynamic_offset}; - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets( - m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_mesh_lighting].layout, - 0, - 1, - &m_descriptor_infos[_mesh_global].descriptor_set, - 3, - dynamic_offsets); - - m_vulkan_rhi->m_vk_cmd_draw_indexed(m_vulkan_rhi->m_current_command_buffer, - mesh.mesh_index_count, - current_instance_count, - 0, - 0, - 0); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_mesh_lighting].layout, + 0, + 1, + &m_descriptor_infos[_mesh_global].descriptor_set, + 3, + dynamic_offsets); + + m_rhi->cmdDrawIndexedPFN(m_rhi->getCurrentCommandBuffer(), + mesh.mesh_index_count, + current_instance_count, + 0, + 0, + 0); } } } } - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } void MainCameraPass::drawSkybox() { uint32_t perframe_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); - m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perframe_dynamic_offset + sizeof(MeshPerframeStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); (*reinterpret_cast( reinterpret_cast( m_global_render_resource->_storage_buffer._global_upload_ringbuffer_memory_pointer) + perframe_dynamic_offset)) = m_mesh_perframe_storage_buffer_object; - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Skybox", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Skybox", color); - m_vulkan_rhi->m_vk_cmd_bind_pipeline(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_skybox].pipeline); - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_skybox].layout, - 0, - 1, - &m_descriptor_infos[_skybox].descriptor_set, - 1, - &perframe_dynamic_offset); - vkCmdDraw(m_vulkan_rhi->m_current_command_buffer, 36, 1, 0, - 0); // 2 triangles(6 vertex) each face, 6 faces + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_skybox].pipeline); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_skybox].layout, + 0, + 1, + &m_descriptor_infos[_skybox].descriptor_set, + 1, + &perframe_dynamic_offset); + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), 36, 1, 0, 0); // 2 triangles(6 vertex) each face, 6 faces - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } void MainCameraPass::drawAxis() @@ -2779,82 +2648,75 @@ namespace Piccolo uint32_t perframe_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); - m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perframe_dynamic_offset + sizeof(MeshPerframeStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); (*reinterpret_cast( reinterpret_cast( m_global_render_resource->_storage_buffer._global_upload_ringbuffer_memory_pointer) + perframe_dynamic_offset)) = m_mesh_perframe_storage_buffer_object; - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Axis", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } - - m_vulkan_rhi->m_vk_cmd_bind_pipeline(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_axis].pipeline); - m_vulkan_rhi->m_vk_cmd_set_viewport(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_viewport); - m_vulkan_rhi->m_vk_cmd_set_scissor(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_scissor); - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[_render_pipeline_type_axis].layout, - 0, - 1, - &m_descriptor_infos[_axis].descriptor_set, - 1, - &perframe_dynamic_offset); + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Axis", color); + + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_axis].pipeline); + m_rhi->cmdSetViewportPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().viewport); + m_rhi->cmdSetScissorPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().scissor); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[_render_pipeline_type_axis].layout, + 0, + 1, + &m_descriptor_infos[_axis].descriptor_set, + 1, + &perframe_dynamic_offset); m_axis_storage_buffer_object.selected_axis = m_selected_axis; m_axis_storage_buffer_object.model_matrix = m_visiable_nodes.p_axis_node->model_matrix; - VkBuffer vertex_buffers[] = {m_visiable_nodes.p_axis_node->ref_mesh->mesh_vertex_position_buffer, + RHIBuffer* vertex_buffers[3] = {m_visiable_nodes.p_axis_node->ref_mesh->mesh_vertex_position_buffer, m_visiable_nodes.p_axis_node->ref_mesh->mesh_vertex_varying_enable_blending_buffer, m_visiable_nodes.p_axis_node->ref_mesh->mesh_vertex_varying_buffer}; - VkDeviceSize offsets[] = {0, 0, 0}; - m_vulkan_rhi->m_vk_cmd_bind_vertex_buffers(m_vulkan_rhi->m_current_command_buffer, - 0, - (sizeof(vertex_buffers) / sizeof(vertex_buffers[0])), - vertex_buffers, - offsets); - m_vulkan_rhi->m_vk_cmd_bind_index_buffer(m_vulkan_rhi->m_current_command_buffer, - m_visiable_nodes.p_axis_node->ref_mesh->mesh_index_buffer, - 0, - VK_INDEX_TYPE_UINT16); + RHIDeviceSize offsets[3] = {0, 0, 0}; + m_rhi->cmdBindVertexBuffersPFN(m_rhi->getCurrentCommandBuffer(), + 0, + (sizeof(vertex_buffers) / sizeof(vertex_buffers[0])), + vertex_buffers, + offsets); + m_rhi->cmdBindIndexBufferPFN(m_rhi->getCurrentCommandBuffer(), + m_visiable_nodes.p_axis_node->ref_mesh->mesh_index_buffer, + 0, + RHI_INDEX_TYPE_UINT16); (*reinterpret_cast(reinterpret_cast( m_global_render_resource->_storage_buffer._axis_inefficient_storage_buffer_memory_pointer))) = m_axis_storage_buffer_object; - m_vulkan_rhi->m_vk_cmd_draw_indexed(m_vulkan_rhi->m_current_command_buffer, - m_visiable_nodes.p_axis_node->ref_mesh->mesh_index_count, - 1, - 0, - 0, - 0); + m_rhi->cmdDrawIndexedPFN(m_rhi->getCurrentCommandBuffer(), + m_visiable_nodes.p_axis_node->ref_mesh->mesh_index_count, + 1, + 0, + 0, + 0); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } - VkCommandBuffer MainCameraPass::getRenderCommandBuffer() { return m_vulkan_rhi->m_current_command_buffer; } + RHICommandBuffer* MainCameraPass::getRenderCommandBuffer() { return m_rhi->getCurrentCommandBuffer(); } void MainCameraPass::setupParticlePass() { - m_particle_pass->setDepthAndNormalImage(m_vulkan_rhi->m_depth_image, + m_particle_pass->setDepthAndNormalImage(m_rhi->getDepthImageInfo().depth_image, m_framebuffer.attachments[_main_camera_pass_gbuffer_a].image); m_particle_pass->setRenderPassHandle(m_framebuffer.render_pass); diff --git a/engine/source/runtime/function/render/passes/main_camera_pass.h b/engine/source/runtime/function/render/passes/main_camera_pass.h index b2267b531..357ccab13 100644 --- a/engine/source/runtime/function/render/passes/main_camera_pass.h +++ b/engine/source/runtime/function/render/passes/main_camera_pass.h @@ -77,8 +77,8 @@ namespace Piccolo void copyNormalAndDepthImage(); - VkImageView m_point_light_shadow_color_image_view; - VkImageView m_directional_light_shadow_color_image_view; + RHIImageView* m_point_light_shadow_color_image_view; + RHIImageView* m_directional_light_shadow_color_image_view; bool m_is_show_axis{ false }; bool m_enable_fxaa{ false }; @@ -88,7 +88,7 @@ namespace Piccolo void updateAfterFramebufferRecreate(); - VkCommandBuffer getRenderCommandBuffer(); + RHICommandBuffer* getRenderCommandBuffer(); void setParticlePass(std::shared_ptr pass); @@ -117,7 +117,7 @@ namespace Piccolo private: - std::vector m_swapchain_framebuffers; + std::vector m_swapchain_framebuffers; std::shared_ptr m_particle_pass; }; } // namespace Piccolo diff --git a/engine/source/runtime/function/render/passes/particle_pass.cpp b/engine/source/runtime/function/render/passes/particle_pass.cpp index b955a96f4..44dcbf787 100644 --- a/engine/source/runtime/function/render/passes/particle_pass.cpp +++ b/engine/source/runtime/function/render/passes/particle_pass.cpp @@ -1,8 +1,9 @@ -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" +#include "runtime/function/render/passes/particle_pass.h" + +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" #include "runtime/function/global/global_context.h" -#include "runtime/function/render/passes/particle_pass.h" #include "runtime/function/render/render_camera.h" #include "runtime/function/render/render_system.h" @@ -17,335 +18,291 @@ namespace Piccolo { - void ParticleEmitterBufferBatch::freeUpBatch(VkDevice device) + void ParticleEmitterBufferBatch::freeUpBatch(std::shared_ptr rhi) { - vkFreeMemory(device, m_counter_host_memory, nullptr); - vkFreeMemory(device, m_position_host_memory, nullptr); - vkFreeMemory(device, m_position_device_memory, nullptr); - vkFreeMemory(device, m_counter_device_memory, nullptr); - vkFreeMemory(device, m_indirect_dispatch_argument_memory, nullptr); - vkFreeMemory(device, m_alive_list_memory, nullptr); - vkFreeMemory(device, m_alive_list_next_memory, nullptr); - vkFreeMemory(device, m_dead_list_memory, nullptr); - vkFreeMemory(device, m_particle_component_res_memory, nullptr); - vkFreeMemory(device, m_position_render_memory, nullptr); - - vkDestroyBuffer(device, m_particle_storage_buffer, nullptr); - vkDestroyBuffer(device, m_position_render_buffer, nullptr); - vkDestroyBuffer(device, m_position_device_buffer, nullptr); - vkDestroyBuffer(device, m_position_host_buffer, nullptr); - vkDestroyBuffer(device, m_counter_device_buffer, nullptr); - vkDestroyBuffer(device, m_counter_host_buffer, nullptr); - vkDestroyBuffer(device, m_indirect_dispatch_argument_buffer, nullptr); - vkDestroyBuffer(device, m_alive_list_buffer, nullptr); - vkDestroyBuffer(device, m_alive_list_next_buffer, nullptr); - vkDestroyBuffer(device, m_dead_list_buffer, nullptr); - vkDestroyBuffer(device, m_particle_component_res_buffer, nullptr); + rhi->freeMemory(m_counter_host_memory); + rhi->freeMemory(m_position_host_memory); + rhi->freeMemory(m_position_device_memory); + rhi->freeMemory(m_counter_device_memory); + rhi->freeMemory(m_indirect_dispatch_argument_memory); + rhi->freeMemory(m_alive_list_memory); + rhi->freeMemory(m_alive_list_next_memory); + rhi->freeMemory(m_dead_list_memory); + rhi->freeMemory(m_particle_component_res_memory); + rhi->freeMemory(m_position_render_memory); + + rhi->destroyBuffer(m_particle_storage_buffer); + rhi->destroyBuffer(m_position_render_buffer); + rhi->destroyBuffer(m_position_device_buffer); + rhi->destroyBuffer(m_position_host_buffer); + rhi->destroyBuffer(m_counter_device_buffer); + rhi->destroyBuffer(m_counter_host_buffer); + rhi->destroyBuffer(m_indirect_dispatch_argument_buffer); + rhi->destroyBuffer(m_alive_list_buffer); + rhi->destroyBuffer(m_alive_list_next_buffer); + rhi->destroyBuffer(m_dead_list_buffer); + rhi->destroyBuffer(m_particle_component_res_buffer); } void ParticlePass::copyNormalAndDepthImage() { - uint8_t index = (m_vulkan_rhi->m_current_frame_index + m_vulkan_rhi->s_max_frames_in_flight - 1) % - m_vulkan_rhi->s_max_frames_in_flight; + uint8_t index = + (m_rhi->getCurrentFrameIndex() + m_rhi->getMaxFramesInFlight() - 1) % m_rhi->getMaxFramesInFlight(); - if (VK_SUCCESS != - vkWaitForFences( - m_vulkan_rhi->m_device, 1, &m_vulkan_rhi->m_is_frame_in_flight_fences[index], VK_TRUE, UINT64_MAX)) - throw std::runtime_error("wait for fence"); + m_rhi->waitForFencesPFN(1, &(m_rhi->getFenceList()[index]), VK_TRUE, UINT64_MAX); - VkCommandBufferBeginInfo command_buffer_begin_info {}; - command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + RHICommandBufferBeginInfo command_buffer_begin_info {}; + command_buffer_begin_info.sType = RHI_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; command_buffer_begin_info.flags = 0; command_buffer_begin_info.pInheritanceInfo = nullptr; - VkResult res_begin_command_buffer = - m_vulkan_rhi->m_vk_begin_command_buffer(m_copy_command_buffer, &command_buffer_begin_info); - assert(VK_SUCCESS == res_begin_command_buffer); + bool res_begin_command_buffer = m_rhi->beginCommandBufferPFN(m_copy_command_buffer, &command_buffer_begin_info); + assert(RHI_SUCCESS == res_begin_command_buffer); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = {VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, - NULL, - "Copy Depth Image for Particle", - {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_copy_command_buffer, &label_info); - } + float color[4] = {1.0f, 1.0f, 1.0f, 1.0f}; + m_rhi->pushEvent(m_copy_command_buffer, "Copy Depth Image for Particle", color); // depth image - VkImageSubresourceRange subresourceRange = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1}; - VkImageMemoryBarrier imagememorybarrier {}; - imagememorybarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; - imagememorybarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - imagememorybarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + RHIImageSubresourceRange subresourceRange = {RHI_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1}; + RHIImageMemoryBarrier imagememorybarrier {}; + imagememorybarrier.sType = RHI_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + imagememorybarrier.srcQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + imagememorybarrier.dstQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; imagememorybarrier.subresourceRange = subresourceRange; { - imagememorybarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; - imagememorybarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + imagememorybarrier.oldLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + imagememorybarrier.newLayout = RHI_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; imagememorybarrier.srcAccessMask = 0; - imagememorybarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + imagememorybarrier.dstAccessMask = RHI_ACCESS_TRANSFER_WRITE_BIT; imagememorybarrier.image = m_dst_depth_image; - vkCmdPipelineBarrier(m_copy_command_buffer, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - &imagememorybarrier); - - imagememorybarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; - imagememorybarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - imagememorybarrier.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; - imagememorybarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; + m_rhi->cmdPipelineBarrier(m_copy_command_buffer, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + &imagememorybarrier); + + imagememorybarrier.oldLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + imagememorybarrier.newLayout = RHI_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + imagememorybarrier.srcAccessMask = RHI_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + imagememorybarrier.dstAccessMask = RHI_ACCESS_TRANSFER_READ_BIT; imagememorybarrier.image = m_src_depth_image; - vkCmdPipelineBarrier(m_copy_command_buffer, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - &imagememorybarrier); - - VkImageCopy imagecopyRegion = {}; - imagecopyRegion.srcSubresource = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 0, 1}; - imagecopyRegion.srcOffset = {0, 0, 0}; - imagecopyRegion.dstSubresource = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 0, 1}; - imagecopyRegion.dstOffset = {0, 0, 0}; - imagecopyRegion.extent = { - m_vulkan_rhi->m_swapchain_extent.width, m_vulkan_rhi->m_swapchain_extent.height, 1}; - - vkCmdCopyImage(m_copy_command_buffer, - m_src_depth_image, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - m_dst_depth_image, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - 1, - &imagecopyRegion); - - imagememorybarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - imagememorybarrier.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - imagememorybarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - imagememorybarrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT; - - vkCmdPipelineBarrier(m_copy_command_buffer, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - &imagememorybarrier); + m_rhi->cmdPipelineBarrier(m_copy_command_buffer, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + &imagememorybarrier); + + m_rhi->cmdCopyImageToImage(m_copy_command_buffer, + m_src_depth_image, + RHI_IMAGE_ASPECT_DEPTH_BIT, + m_dst_depth_image, + RHI_IMAGE_ASPECT_DEPTH_BIT, + m_rhi->getSwapchainInfo().extent.width, + m_rhi->getSwapchainInfo().extent.height); + + imagememorybarrier.oldLayout = RHI_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + imagememorybarrier.newLayout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + imagememorybarrier.srcAccessMask = RHI_ACCESS_TRANSFER_WRITE_BIT; + imagememorybarrier.dstAccessMask = + RHI_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | RHI_ACCESS_SHADER_READ_BIT; + + m_rhi->cmdPipelineBarrier(m_copy_command_buffer, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + &imagememorybarrier); imagememorybarrier.image = m_dst_depth_image; - imagememorybarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; - imagememorybarrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - imagememorybarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - imagememorybarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - - vkCmdPipelineBarrier(m_copy_command_buffer, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - &imagememorybarrier); + imagememorybarrier.oldLayout = RHI_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + imagememorybarrier.newLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + imagememorybarrier.srcAccessMask = RHI_ACCESS_TRANSFER_WRITE_BIT; + imagememorybarrier.dstAccessMask = RHI_ACCESS_SHADER_READ_BIT; + + m_rhi->cmdPipelineBarrier(m_copy_command_buffer, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + &imagememorybarrier); } - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - // end depth image copy label - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_copy_command_buffer); - } + m_rhi->popEvent(m_copy_command_buffer); // end depth image copy label - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = {VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, - NULL, - "Copy Normal Image for Particle", - {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_copy_command_buffer, &label_info); - } + m_rhi->pushEvent(m_copy_command_buffer, "Copy Normal Image for Particle", color); // color image - subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; + subresourceRange = {RHI_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; imagememorybarrier.subresourceRange = subresourceRange; { - imagememorybarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; - imagememorybarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + imagememorybarrier.oldLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + imagememorybarrier.newLayout = RHI_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; imagememorybarrier.srcAccessMask = 0; - imagememorybarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + imagememorybarrier.dstAccessMask = RHI_ACCESS_TRANSFER_WRITE_BIT; imagememorybarrier.image = m_dst_normal_image; - vkCmdPipelineBarrier(m_copy_command_buffer, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - &imagememorybarrier); - - imagememorybarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; - imagememorybarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - imagememorybarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - imagememorybarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; + m_rhi->cmdPipelineBarrier(m_copy_command_buffer, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + &imagememorybarrier); + + imagememorybarrier.oldLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + imagememorybarrier.newLayout = RHI_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + imagememorybarrier.srcAccessMask = RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + imagememorybarrier.dstAccessMask = RHI_ACCESS_TRANSFER_READ_BIT; imagememorybarrier.image = m_src_normal_image; - vkCmdPipelineBarrier(m_copy_command_buffer, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - &imagememorybarrier); - - VkImageCopy imagecopyRegion = {}; - imagecopyRegion.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}; - imagecopyRegion.srcOffset = {0, 0, 0}; - imagecopyRegion.dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}; - imagecopyRegion.dstOffset = {0, 0, 0}; - imagecopyRegion.extent = { - m_vulkan_rhi->m_swapchain_extent.width, m_vulkan_rhi->m_swapchain_extent.height, 1}; - - vkCmdCopyImage(m_copy_command_buffer, - m_src_normal_image, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - m_dst_normal_image, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - 1, - &imagecopyRegion); - - imagememorybarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - imagememorybarrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - imagememorybarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - imagememorybarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT; - - vkCmdPipelineBarrier(m_copy_command_buffer, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - &imagememorybarrier); + m_rhi->cmdPipelineBarrier(m_copy_command_buffer, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + &imagememorybarrier); + + m_rhi->cmdCopyImageToImage(m_copy_command_buffer, + m_src_normal_image, + RHI_IMAGE_ASPECT_COLOR_BIT, + m_dst_normal_image, + RHI_IMAGE_ASPECT_COLOR_BIT, + m_rhi->getSwapchainInfo().extent.width, + m_rhi->getSwapchainInfo().extent.height); + + imagememorybarrier.oldLayout = RHI_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + imagememorybarrier.newLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + imagememorybarrier.srcAccessMask = RHI_ACCESS_TRANSFER_WRITE_BIT; + imagememorybarrier.dstAccessMask = RHI_ACCESS_COLOR_ATTACHMENT_READ_BIT | RHI_ACCESS_SHADER_READ_BIT; + + m_rhi->cmdPipelineBarrier(m_copy_command_buffer, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + &imagememorybarrier); imagememorybarrier.image = m_dst_normal_image; - imagememorybarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; - imagememorybarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL; - imagememorybarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - imagememorybarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - - vkCmdPipelineBarrier(m_copy_command_buffer, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - &imagememorybarrier); - } - - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - // end normal image copy label - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_copy_command_buffer); + imagememorybarrier.oldLayout = RHI_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + imagememorybarrier.newLayout = RHI_IMAGE_LAYOUT_GENERAL; + imagememorybarrier.srcAccessMask = RHI_ACCESS_TRANSFER_WRITE_BIT; + imagememorybarrier.dstAccessMask = RHI_ACCESS_SHADER_READ_BIT; + + m_rhi->cmdPipelineBarrier(m_copy_command_buffer, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + &imagememorybarrier); } - VkResult res_end_command_buffer = m_vulkan_rhi->m_vk_end_command_buffer(m_copy_command_buffer); - assert(VK_SUCCESS == res_end_command_buffer); - - VkResult res_reset_fences = m_vulkan_rhi->m_vk_reset_fences( - m_vulkan_rhi->m_device, 1, &m_vulkan_rhi->m_is_frame_in_flight_fences[index]); - assert(VK_SUCCESS == res_reset_fences); - - VkPipelineStageFlags wait_stages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT}; - VkSubmitInfo submit_info = {}; - submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; - submit_info.waitSemaphoreCount = 1; - submit_info.pWaitSemaphores = &m_vulkan_rhi->m_image_available_for_texturescopy_semaphores[index]; - submit_info.pWaitDstStageMask = wait_stages; - submit_info.commandBufferCount = 1; - submit_info.pCommandBuffers = &m_copy_command_buffer; - submit_info.signalSemaphoreCount = 0; - submit_info.pSignalSemaphores = nullptr; - VkResult res_queue_submit = vkQueueSubmit( - m_vulkan_rhi->m_graphics_queue, 1, &submit_info, m_vulkan_rhi->m_is_frame_in_flight_fences[index]); - assert(VK_SUCCESS == res_queue_submit); - - vkQueueWaitIdle(m_vulkan_rhi->m_graphics_queue); + m_rhi->popEvent(m_copy_command_buffer); + + bool res_end_command_buffer = m_rhi->endCommandBufferPFN(m_copy_command_buffer); + assert(RHI_SUCCESS == res_end_command_buffer); + + bool res_reset_fences = m_rhi->resetFencesPFN(1, &m_rhi->getFenceList()[index]); + assert(RHI_SUCCESS == res_reset_fences); + + RHIPipelineStageFlags wait_stages[] = {RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT}; + RHISubmitInfo submit_info = {}; + submit_info.sType = RHI_STRUCTURE_TYPE_SUBMIT_INFO; + submit_info.waitSemaphoreCount = 1; + submit_info.pWaitSemaphores = &(m_rhi->getTextureCopySemaphore(index)); + submit_info.pWaitDstStageMask = wait_stages; + submit_info.commandBufferCount = 1; + submit_info.pCommandBuffers = &m_copy_command_buffer; + submit_info.signalSemaphoreCount = 0; + submit_info.pSignalSemaphores = nullptr; + bool res_queue_submit = + m_rhi->queueSubmit(m_rhi->getGraphicsQueue(), 1, &submit_info, m_rhi->getFenceList()[index]); + assert(RHI_SUCCESS == res_queue_submit); + + m_rhi->queueWaitIdle(m_rhi->getGraphicsQueue()); } void ParticlePass::updateAfterFramebufferRecreate() { - vkDestroyImage(m_vulkan_rhi->m_device, m_dst_depth_image, nullptr); - vkFreeMemory(m_vulkan_rhi->m_device, m_dst_depth_image_memory, nullptr); - - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - m_vulkan_rhi->m_swapchain_extent.width, - m_vulkan_rhi->m_swapchain_extent.height, - m_vulkan_rhi->m_depth_image_format, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_dst_depth_image, - m_dst_depth_image_memory, - 0, - 1, - 1); - - vkDestroyImage(m_vulkan_rhi->m_device, m_dst_normal_image, nullptr); - vkFreeMemory(m_vulkan_rhi->m_device, m_dst_normal_image_memory, nullptr); - - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - m_vulkan_rhi->m_swapchain_extent.width, - m_vulkan_rhi->m_swapchain_extent.height, - VK_FORMAT_R8G8B8A8_UNORM, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_dst_normal_image, - m_dst_normal_image_memory, - 0, - 1, - 1); - - m_src_depth_image_view = VulkanUtil::createImageView(m_vulkan_rhi->m_device, - m_dst_depth_image, - m_vulkan_rhi->m_depth_image_format, - VK_IMAGE_ASPECT_DEPTH_BIT, - VK_IMAGE_VIEW_TYPE_2D, - 1, - 1); - m_src_normal_image_view = VulkanUtil::createImageView(m_vulkan_rhi->m_device, - m_dst_normal_image, - VK_FORMAT_R8G8B8A8_UNORM, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_VIEW_TYPE_2D, - 1, - 1); + m_rhi->destroyImage(m_dst_depth_image); + m_rhi->freeMemory(m_dst_depth_image_memory); + + m_rhi->createImage(m_rhi->getSwapchainInfo().extent.width, + m_rhi->getSwapchainInfo().extent.height, + m_rhi->getDepthImageInfo().depth_image_format, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_SAMPLED_BIT | RHI_IMAGE_USAGE_TRANSFER_DST_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_dst_depth_image, + m_dst_depth_image_memory, + 0, + 1, + 1); + + m_rhi->destroyImage(m_dst_normal_image); + m_rhi->freeMemory(m_dst_normal_image_memory); + + m_rhi->createImage(m_rhi->getSwapchainInfo().extent.width, + m_rhi->getSwapchainInfo().extent.height, + RHI_FORMAT_R8G8B8A8_UNORM, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_STORAGE_BIT | RHI_IMAGE_USAGE_TRANSFER_DST_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_dst_normal_image, + m_dst_normal_image_memory, + 0, + 1, + 1); + + m_rhi->createImageView(m_dst_depth_image, + m_rhi->getDepthImageInfo().depth_image_format, + RHI_IMAGE_ASPECT_DEPTH_BIT, + RHI_IMAGE_VIEW_TYPE_2D, + 1, + 1, + m_src_depth_image_view); + + m_rhi->createImageView(m_dst_normal_image, + RHI_FORMAT_R8G8B8A8_UNORM, + RHI_IMAGE_ASPECT_COLOR_BIT, + RHI_IMAGE_VIEW_TYPE_2D, + 1, + 1, + m_src_normal_image_view); updateDescriptorSet(); } @@ -354,34 +311,25 @@ namespace Piccolo { for (int i = 0; i < m_emitter_count; ++i) { - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "ParticleBillboard", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_render_command_buffer, &label_info); - } - - m_vulkan_rhi->m_vk_cmd_bind_pipeline( - m_render_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[1].pipeline); - m_vulkan_rhi->m_vk_cmd_set_viewport(m_render_command_buffer, 0, 1, &m_vulkan_rhi->m_viewport); - m_vulkan_rhi->m_vk_cmd_set_scissor(m_render_command_buffer, 0, 1, &m_vulkan_rhi->m_scissor); - - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_render_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[1].layout, - 0, - 1, - &m_descriptor_infos[i * 3 + 2].descriptor_set, - 0, - nullptr); - - vkCmdDraw(m_render_command_buffer, 4, m_emitter_buffer_batches[i].m_num_particle, 0, 0); - - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - // end particle draw label - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_render_command_buffer); - } + float color[4] = {1.0f, 1.0f, 1.0f, 1.0f}; + m_rhi->pushEvent(m_render_command_buffer, "ParticleBillboard", color); + + m_rhi->cmdBindPipelinePFN( + m_render_command_buffer, RHI_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[1].pipeline); + m_rhi->cmdSetViewportPFN(m_render_command_buffer, 0, 1, m_rhi->getSwapchainInfo().viewport); + m_rhi->cmdSetScissorPFN(m_render_command_buffer, 0, 1, m_rhi->getSwapchainInfo().scissor); + m_rhi->cmdBindDescriptorSetsPFN(m_render_command_buffer, + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[1].layout, + 0, + 1, + &m_descriptor_infos[i * 3 + 2].descriptor_set, + 0, + NULL); + + m_rhi->cmdDraw(m_render_command_buffer, 4, m_emitter_buffer_batches[i].m_num_particle, 0, 0); + + m_rhi->popEvent(m_render_command_buffer); } } @@ -391,160 +339,154 @@ namespace Piccolo { std::shared_ptr m_particle_billboard_texture_resource = m_render_resource->loadTextureHDR( m_particle_manager->getGlobalParticleRes().m_particle_billboard_texture_path); - VulkanUtil::createGlobalImage(m_vulkan_rhi.get(), - m_particle_billboard_texture_image, - m_particle_billboard_texture_image_view, - m_particle_billboard_texture_vma_allocation, - m_particle_billboard_texture_resource->m_width, - m_particle_billboard_texture_resource->m_height, - m_particle_billboard_texture_resource->m_pixels, - m_particle_billboard_texture_resource->m_format); + m_rhi->createGlobalImage(m_particle_billboard_texture_image, + m_particle_billboard_texture_image_view, + m_particle_billboard_texture_vma_allocation, + m_particle_billboard_texture_resource->m_width, + m_particle_billboard_texture_resource->m_height, + m_particle_billboard_texture_resource->m_pixels, + m_particle_billboard_texture_resource->m_format); } // piccolo texture { std::shared_ptr m_piccolo_logo_texture_resource = m_render_resource->loadTexture( m_particle_manager->getGlobalParticleRes().m_piccolo_logo_texture_path, true); - VulkanUtil::createGlobalImage(m_vulkan_rhi.get(), - m_piccolo_logo_texture_image, - m_piccolo_logo_texture_image_view, - m_piccolo_logo_texture_vma_allocation, - m_piccolo_logo_texture_resource->m_width, - m_piccolo_logo_texture_resource->m_height, - m_piccolo_logo_texture_resource->m_pixels, - m_piccolo_logo_texture_resource->m_format); + m_rhi->createGlobalImage(m_piccolo_logo_texture_image, + m_piccolo_logo_texture_image_view, + m_piccolo_logo_texture_vma_allocation, + m_piccolo_logo_texture_resource->m_width, + m_piccolo_logo_texture_resource->m_height, + m_piccolo_logo_texture_resource->m_pixels, + m_piccolo_logo_texture_resource->m_format); } - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - m_vulkan_rhi->m_swapchain_extent.width, - m_vulkan_rhi->m_swapchain_extent.height, - m_vulkan_rhi->m_depth_image_format, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_dst_depth_image, - m_dst_depth_image_memory, - 0, - 1, - 1); - - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - m_vulkan_rhi->m_swapchain_extent.width, - m_vulkan_rhi->m_swapchain_extent.height, - VK_FORMAT_R8G8B8A8_UNORM, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_dst_normal_image, - m_dst_normal_image_memory, - 0, - 1, - 1); - - m_src_depth_image_view = VulkanUtil::createImageView(m_vulkan_rhi->m_device, - m_dst_depth_image, - m_vulkan_rhi->m_depth_image_format, - VK_IMAGE_ASPECT_DEPTH_BIT, - VK_IMAGE_VIEW_TYPE_2D, - 1, - 1); - m_src_normal_image_view = VulkanUtil::createImageView(m_vulkan_rhi->m_device, - m_dst_normal_image, - VK_FORMAT_R8G8B8A8_UNORM, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_VIEW_TYPE_2D, - 1, - 1); + m_rhi->createImage(m_rhi->getSwapchainInfo().extent.width, + m_rhi->getSwapchainInfo().extent.height, + m_rhi->getDepthImageInfo().depth_image_format, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_SAMPLED_BIT | RHI_IMAGE_USAGE_TRANSFER_DST_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_dst_depth_image, + m_dst_depth_image_memory, + 0, + 1, + 1); + + m_rhi->createImage(m_rhi->getSwapchainInfo().extent.width, + m_rhi->getSwapchainInfo().extent.height, + RHI_FORMAT_R8G8B8A8_UNORM, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_STORAGE_BIT | RHI_IMAGE_USAGE_TRANSFER_DST_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_dst_normal_image, + m_dst_normal_image_memory, + 0, + 1, + 1); + + m_rhi->createImageView(m_dst_depth_image, + m_rhi->getDepthImageInfo().depth_image_format, + RHI_IMAGE_ASPECT_DEPTH_BIT, + RHI_IMAGE_VIEW_TYPE_2D, + 1, + 1, + m_src_depth_image_view); + + m_rhi->createImageView(m_dst_normal_image, + RHI_FORMAT_R8G8B8A8_UNORM, + RHI_IMAGE_ASPECT_COLOR_BIT, + RHI_IMAGE_VIEW_TYPE_2D, + 1, + 1, + m_src_normal_image_view); } void ParticlePass::setupParticleDescriptorSet() { for (int eid = 0; eid < m_emitter_count; ++eid) { - VkDescriptorSetAllocateInfo particlebillboard_global_descriptor_set_alloc_info; - particlebillboard_global_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHIDescriptorSetAllocateInfo particlebillboard_global_descriptor_set_alloc_info; + particlebillboard_global_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; particlebillboard_global_descriptor_set_alloc_info.pNext = NULL; - particlebillboard_global_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + particlebillboard_global_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); particlebillboard_global_descriptor_set_alloc_info.descriptorSetCount = 1; particlebillboard_global_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[2].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &particlebillboard_global_descriptor_set_alloc_info, - &m_descriptor_infos[eid * 3 + 2].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&particlebillboard_global_descriptor_set_alloc_info, + m_descriptor_infos[eid * 3 + 2].descriptor_set)) { throw std::runtime_error("allocate particle billboard global descriptor set"); } - VkDescriptorBufferInfo particlebillboard_perframe_storage_buffer_info = {}; - particlebillboard_perframe_storage_buffer_info.offset = 0; - particlebillboard_perframe_storage_buffer_info.range = VK_WHOLE_SIZE; - particlebillboard_perframe_storage_buffer_info.buffer = m_particle_billboard_uniform_buffer; + RHIDescriptorBufferInfo particlebillboard_perframe_storage_buffer_info = {}; + particlebillboard_perframe_storage_buffer_info.offset = 0; + particlebillboard_perframe_storage_buffer_info.range = RHI_WHOLE_SIZE; + particlebillboard_perframe_storage_buffer_info.buffer = m_particle_billboard_uniform_buffer; - VkDescriptorBufferInfo particlebillboard_perdrawcall_storage_buffer_info = {}; - particlebillboard_perdrawcall_storage_buffer_info.offset = 0; - particlebillboard_perdrawcall_storage_buffer_info.range = VK_WHOLE_SIZE; + RHIDescriptorBufferInfo particlebillboard_perdrawcall_storage_buffer_info = {}; + particlebillboard_perdrawcall_storage_buffer_info.offset = 0; + particlebillboard_perdrawcall_storage_buffer_info.range = RHI_WHOLE_SIZE; particlebillboard_perdrawcall_storage_buffer_info.buffer = m_emitter_buffer_batches[eid].m_position_render_buffer; - VkWriteDescriptorSet particlebillboard_descriptor_writes_info[3]; + RHIWriteDescriptorSet particlebillboard_descriptor_writes_info[3]; - particlebillboard_descriptor_writes_info[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + particlebillboard_descriptor_writes_info[0].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; particlebillboard_descriptor_writes_info[0].pNext = NULL; particlebillboard_descriptor_writes_info[0].dstSet = m_descriptor_infos[eid * 3 + 2].descriptor_set; particlebillboard_descriptor_writes_info[0].dstBinding = 0; particlebillboard_descriptor_writes_info[0].dstArrayElement = 0; - particlebillboard_descriptor_writes_info[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + particlebillboard_descriptor_writes_info[0].descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER; particlebillboard_descriptor_writes_info[0].descriptorCount = 1; particlebillboard_descriptor_writes_info[0].pBufferInfo = &particlebillboard_perframe_storage_buffer_info; - particlebillboard_descriptor_writes_info[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + particlebillboard_descriptor_writes_info[1].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; particlebillboard_descriptor_writes_info[1].pNext = NULL; particlebillboard_descriptor_writes_info[1].dstSet = m_descriptor_infos[eid * 3 + 2].descriptor_set; particlebillboard_descriptor_writes_info[1].dstBinding = 1; particlebillboard_descriptor_writes_info[1].dstArrayElement = 0; - particlebillboard_descriptor_writes_info[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + particlebillboard_descriptor_writes_info[1].descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; particlebillboard_descriptor_writes_info[1].descriptorCount = 1; particlebillboard_descriptor_writes_info[1].pBufferInfo = &particlebillboard_perdrawcall_storage_buffer_info; - VkSampler sampler; - VkSamplerCreateInfo samplerCreateInfo {}; - samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; + RHISampler* sampler; + RHISamplerCreateInfo samplerCreateInfo {}; + samplerCreateInfo.sType = RHI_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; samplerCreateInfo.maxAnisotropy = 1.0f; samplerCreateInfo.anisotropyEnable = true; - samplerCreateInfo.magFilter = VK_FILTER_LINEAR; - samplerCreateInfo.minFilter = VK_FILTER_LINEAR; - samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; - samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT; - samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT; - samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.magFilter = RHI_FILTER_LINEAR; + samplerCreateInfo.minFilter = RHI_FILTER_LINEAR; + samplerCreateInfo.mipmapMode = RHI_SAMPLER_MIPMAP_MODE_LINEAR; + samplerCreateInfo.addressModeU = RHI_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.addressModeV = RHI_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.addressModeW = RHI_SAMPLER_ADDRESS_MODE_REPEAT; samplerCreateInfo.mipLodBias = 0.0f; - samplerCreateInfo.compareOp = VK_COMPARE_OP_NEVER; + samplerCreateInfo.compareOp = RHI_COMPARE_OP_NEVER; samplerCreateInfo.minLod = 0.0f; samplerCreateInfo.maxLod = 0.0f; - samplerCreateInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; - if (VK_SUCCESS != vkCreateSampler(m_vulkan_rhi->m_device, &samplerCreateInfo, nullptr, &sampler)) + samplerCreateInfo.borderColor = RHI_BORDER_COLOR_FLOAT_OPAQUE_WHITE; + if (RHI_SUCCESS != m_rhi->createSampler(&samplerCreateInfo, sampler)) { throw std::runtime_error("create sampler error"); } - VkDescriptorImageInfo particle_texture_image_info = {}; - particle_texture_image_info.sampler = sampler; - particle_texture_image_info.imageView = m_particle_billboard_texture_image_view; - particle_texture_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + RHIDescriptorImageInfo particle_texture_image_info = {}; + particle_texture_image_info.sampler = sampler; + particle_texture_image_info.imageView = m_particle_billboard_texture_image_view; + particle_texture_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - particlebillboard_descriptor_writes_info[2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + particlebillboard_descriptor_writes_info[2].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; particlebillboard_descriptor_writes_info[2].pNext = NULL; particlebillboard_descriptor_writes_info[2].dstSet = m_descriptor_infos[eid * 3 + 2].descriptor_set; particlebillboard_descriptor_writes_info[2].dstBinding = 2; particlebillboard_descriptor_writes_info[2].dstArrayElement = 0; - particlebillboard_descriptor_writes_info[2].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + particlebillboard_descriptor_writes_info[2].descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; particlebillboard_descriptor_writes_info[2].descriptorCount = 1; particlebillboard_descriptor_writes_info[2].pImageInfo = &particle_texture_image_info; - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, 3, particlebillboard_descriptor_writes_info, 0, NULL); + m_rhi->updateDescriptorSets(3, particlebillboard_descriptor_writes_info, 0, NULL); } } @@ -552,7 +494,7 @@ namespace Piccolo { for (int i = 0; i < m_emitter_buffer_batches.size(); ++i) { - m_emitter_buffer_batches[i].freeUpBatch(m_vulkan_rhi->m_device); + m_emitter_buffer_batches[i].freeUpBatch(m_rhi); } m_emitter_count = count; @@ -582,150 +524,134 @@ namespace Piccolo const VkDeviceSize indirectArgumentSize = sizeof(IndirectArgumemt); struct IndirectArgumemt indirectargument = {}; indirectargument.alive_flap_bit = 1; - VulkanUtil::createBufferAndInitialize(m_vulkan_rhi->m_device, - m_vulkan_rhi->m_physical_device, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | - VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, - &m_emitter_buffer_batches[id].m_indirect_dispatch_argument_buffer, - &m_emitter_buffer_batches[id].m_indirect_dispatch_argument_memory, - indirectArgumentSize, - &indirectargument, - indirectArgumentSize); + m_rhi->createBufferAndInitialize(RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT | RHI_BUFFER_USAGE_INDIRECT_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT, + m_emitter_buffer_batches[id].m_indirect_dispatch_argument_buffer, + m_emitter_buffer_batches[id].m_indirect_dispatch_argument_memory, + indirectArgumentSize, + &indirectargument, + indirectArgumentSize); const VkDeviceSize aliveListSize = 4 * sizeof(uint32_t) * s_max_particles; std::vector aliveindices(s_max_particles * 4, 0); for (int i = 0; i < s_max_particles; ++i) aliveindices[i * 4] = i; - VulkanUtil::createBufferAndInitialize(m_vulkan_rhi->m_device, - m_vulkan_rhi->m_physical_device, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, - &m_emitter_buffer_batches[id].m_alive_list_buffer, - &m_emitter_buffer_batches[id].m_alive_list_memory, - aliveListSize, - aliveindices.data(), - aliveListSize); - - VulkanUtil::createBufferAndInitialize(m_vulkan_rhi->m_device, - m_vulkan_rhi->m_physical_device, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - &m_emitter_buffer_batches[id].m_alive_list_next_buffer, - &m_emitter_buffer_batches[id].m_alive_list_next_memory, - aliveListSize); + + m_rhi->createBufferAndInitialize(RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT, + m_emitter_buffer_batches[id].m_alive_list_buffer, + m_emitter_buffer_batches[id].m_alive_list_memory, + aliveListSize, + aliveindices.data(), + aliveListSize); + + m_rhi->createBufferAndInitialize(RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_emitter_buffer_batches[id].m_alive_list_next_buffer, + m_emitter_buffer_batches[id].m_alive_list_next_memory, + aliveListSize); const VkDeviceSize deadListSize = 4 * sizeof(uint32_t) * s_max_particles; std::vector deadindices(s_max_particles * 4, 0); for (int32_t i = 0; i < s_max_particles; ++i) deadindices[i * 4] = s_max_particles - 1 - i; - VulkanUtil::createBufferAndInitialize(m_vulkan_rhi->m_device, - m_vulkan_rhi->m_physical_device, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, - &m_emitter_buffer_batches[id].m_dead_list_buffer, - &m_emitter_buffer_batches[id].m_dead_list_memory, - deadListSize, - deadindices.data(), - deadListSize); + + m_rhi->createBufferAndInitialize(RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT, + m_emitter_buffer_batches[id].m_dead_list_buffer, + m_emitter_buffer_batches[id].m_dead_list_memory, + deadListSize, + deadindices.data(), + deadListSize); } - VkFence fence; + RHIFence* fence = nullptr; ParticleCounter counterNext {}; { - - VulkanUtil::createBufferAndInitialize(m_vulkan_rhi->m_device, - m_vulkan_rhi->m_physical_device, - VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, - &m_emitter_buffer_batches[id].m_counter_host_buffer, - &m_emitter_buffer_batches[id].m_counter_host_memory, - counterBufferSize, - &counter, - sizeof(counter)); + m_rhi->createBufferAndInitialize(RHI_BUFFER_USAGE_TRANSFER_SRC_BIT | RHI_BUFFER_USAGE_TRANSFER_DST_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT, + m_emitter_buffer_batches[id].m_counter_host_buffer, + m_emitter_buffer_batches[id].m_counter_host_memory, + counterBufferSize, + &counter, + sizeof(counter)); // Flush writes to host visible buffer void* mapped; - vkMapMemory(m_vulkan_rhi->m_device, - m_emitter_buffer_batches[id].m_counter_host_memory, - 0, - VK_WHOLE_SIZE, - 0, - &mapped); - VkMappedMemoryRange mappedRange {}; - mappedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; - mappedRange.memory = m_emitter_buffer_batches[id].m_counter_host_memory; - mappedRange.offset = 0; - mappedRange.size = VK_WHOLE_SIZE; - vkFlushMappedMemoryRanges(m_vulkan_rhi->m_device, 1, &mappedRange); - vkUnmapMemory(m_vulkan_rhi->m_device, m_emitter_buffer_batches[id].m_counter_host_memory); - - VulkanUtil::createBufferAndInitialize(m_vulkan_rhi->m_device, - m_vulkan_rhi->m_physical_device, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | - VK_BUFFER_USAGE_TRANSFER_SRC_BIT | - VK_BUFFER_USAGE_TRANSFER_DST_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - &m_emitter_buffer_batches[id].m_counter_device_buffer, - &m_emitter_buffer_batches[id].m_counter_device_memory, - counterBufferSize); + m_rhi->mapMemory(m_emitter_buffer_batches[id].m_counter_host_memory, 0, RHI_WHOLE_SIZE, 0, &mapped); + + m_rhi->flushMappedMemoryRanges( + nullptr, m_emitter_buffer_batches[id].m_counter_host_memory, 0, RHI_WHOLE_SIZE); + + m_rhi->unmapMemory(m_emitter_buffer_batches[id].m_counter_host_memory); + + m_rhi->createBufferAndInitialize(RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT | RHI_BUFFER_USAGE_TRANSFER_SRC_BIT | + RHI_BUFFER_USAGE_TRANSFER_DST_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_emitter_buffer_batches[id].m_counter_device_buffer, + m_emitter_buffer_batches[id].m_counter_device_memory, + counterBufferSize); // Copy to staging buffer - VkCommandBufferAllocateInfo cmdBufAllocateInfo {}; - cmdBufAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; - cmdBufAllocateInfo.commandPool = m_vulkan_rhi->m_command_pool; - cmdBufAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + RHICommandBufferAllocateInfo cmdBufAllocateInfo {}; + cmdBufAllocateInfo.sType = RHI_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + cmdBufAllocateInfo.commandPool = m_rhi->getCommandPoor(); + cmdBufAllocateInfo.level = RHI_COMMAND_BUFFER_LEVEL_PRIMARY; cmdBufAllocateInfo.commandBufferCount = 1; - VkCommandBuffer copyCmd; - if (VK_SUCCESS != vkAllocateCommandBuffers(m_vulkan_rhi->m_device, &cmdBufAllocateInfo, ©Cmd)) + RHICommandBuffer* copyCmd; + if (RHI_SUCCESS != m_rhi->allocateCommandBuffers(&cmdBufAllocateInfo, copyCmd)) { throw std::runtime_error("alloc command buffer"); } - VkCommandBufferBeginInfo cmdBufInfo {}; - cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; - if (VK_SUCCESS != vkBeginCommandBuffer(copyCmd, &cmdBufInfo)) + RHICommandBufferBeginInfo cmdBufInfo {}; + cmdBufInfo.sType = RHI_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + if (RHI_SUCCESS != m_rhi->beginCommandBuffer(copyCmd, &cmdBufInfo)) { throw std::runtime_error("begin command buffer"); } - VkBufferCopy copyRegion = {}; - copyRegion.size = counterBufferSize; - vkCmdCopyBuffer(copyCmd, - m_emitter_buffer_batches[id].m_counter_host_buffer, - m_emitter_buffer_batches[id].m_counter_device_buffer, - 1, - ©Region); - if (VK_SUCCESS != vkEndCommandBuffer(copyCmd)) + RHIBufferCopy copyRegion = {}; + copyRegion.srcOffset = 0; + copyRegion.dstOffset = 0; + copyRegion.size = counterBufferSize; + m_rhi->cmdCopyBuffer(copyCmd, + m_emitter_buffer_batches[id].m_counter_host_buffer, + m_emitter_buffer_batches[id].m_counter_device_buffer, + 1, + ©Region); + + if (RHI_SUCCESS != m_rhi->endCommandBuffer(copyCmd)) { throw std::runtime_error("buffer copy"); } - VkSubmitInfo submitInfo {}; - submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + RHISubmitInfo submitInfo {}; + submitInfo.sType = RHI_STRUCTURE_TYPE_SUBMIT_INFO; submitInfo.commandBufferCount = 1; submitInfo.pCommandBuffers = ©Cmd; - VkFenceCreateInfo fenceInfo {}; - fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + RHIFenceCreateInfo fenceInfo {}; + fenceInfo.sType = RHI_STRUCTURE_TYPE_FENCE_CREATE_INFO; fenceInfo.flags = 0; - if (VK_SUCCESS != vkCreateFence(m_vulkan_rhi->m_device, &fenceInfo, nullptr, &fence)) + if (RHI_SUCCESS != m_rhi->createFence(&fenceInfo, fence)) { throw std::runtime_error("create fence"); } // Submit to the queue - if (VK_SUCCESS != vkQueueSubmit(m_vulkan_rhi->m_compute_queue, 1, &submitInfo, fence)) + if (RHI_SUCCESS != m_rhi->queueSubmit(m_rhi->getComputeQueue(), 1, &submitInfo, fence)) { throw std::runtime_error("queue submit"); } - if (VK_SUCCESS != vkWaitForFences(m_vulkan_rhi->m_device, 1, &fence, VK_TRUE, UINT64_MAX)) + + if (RHI_SUCCESS != m_rhi->waitForFencesPFN(1, &fence, RHI_TRUE, UINT64_MAX)) { throw std::runtime_error("wait fence submit"); } - vkDestroyFence(m_vulkan_rhi->m_device, fence, nullptr); - vkFreeCommandBuffers(m_vulkan_rhi->m_device, m_vulkan_rhi->m_command_pool, 1, ©Cmd); + m_rhi->destroyFence(fence); + m_rhi->freeCommandBuffers(m_rhi->getCommandPoor(), 1, copyCmd); } const VkDeviceSize staggingBuferSize = s_max_particles * sizeof(Particle); @@ -733,125 +659,112 @@ namespace Piccolo // fill in data { - VulkanUtil::createBufferAndInitialize(m_vulkan_rhi->m_device, - m_vulkan_rhi->m_physical_device, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | - VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - &m_emitter_buffer_batches[id].m_particle_component_res_buffer, - &m_emitter_buffer_batches[id].m_particle_component_res_memory, - sizeof(ParticleEmitterDesc), - &m_emitter_buffer_batches[id].m_emitter_desc, - sizeof(ParticleEmitterDesc)); - - if (VK_SUCCESS != vkMapMemory(m_vulkan_rhi->m_device, - m_emitter_buffer_batches[id].m_particle_component_res_memory, - 0, - VK_WHOLE_SIZE, - 0, - &m_emitter_buffer_batches[id].m_emitter_desc_mapped)) + + m_rhi->createBufferAndInitialize(RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | + RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + m_emitter_buffer_batches[id].m_particle_component_res_buffer, + m_emitter_buffer_batches[id].m_particle_component_res_memory, + sizeof(ParticleEmitterDesc), + &m_emitter_buffer_batches[id].m_emitter_desc, + sizeof(ParticleEmitterDesc)); + + if (RHI_SUCCESS != m_rhi->mapMemory(m_emitter_buffer_batches[id].m_particle_component_res_memory, + 0, + RHI_WHOLE_SIZE, + 0, + &m_emitter_buffer_batches[id].m_emitter_desc_mapped)) { throw std::runtime_error("map emitter component res buffer"); } - VulkanUtil::createBufferAndInitialize(m_vulkan_rhi->m_device, - m_vulkan_rhi->m_physical_device, - VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, - &m_emitter_buffer_batches[id].m_position_host_buffer, - &m_emitter_buffer_batches[id].m_position_host_memory, - staggingBuferSize); + m_rhi->createBufferAndInitialize(RHI_BUFFER_USAGE_TRANSFER_SRC_BIT | RHI_BUFFER_USAGE_TRANSFER_DST_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT, + m_emitter_buffer_batches[id].m_position_host_buffer, + m_emitter_buffer_batches[id].m_position_host_memory, + staggingBuferSize); // Flush writes to host visible buffer void* mapped; - vkMapMemory(m_vulkan_rhi->m_device, - m_emitter_buffer_batches[id].m_position_host_memory, - 0, - VK_WHOLE_SIZE, - 0, - &mapped); - VkMappedMemoryRange mappedRange {}; - mappedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; - mappedRange.memory = m_emitter_buffer_batches[id].m_position_host_memory; - mappedRange.offset = 0; - mappedRange.size = VK_WHOLE_SIZE; - vkFlushMappedMemoryRanges(m_vulkan_rhi->m_device, 1, &mappedRange); - vkUnmapMemory(m_vulkan_rhi->m_device, m_emitter_buffer_batches[id].m_position_host_memory); - - VulkanUtil::createBufferAndInitialize(m_vulkan_rhi->m_device, - m_vulkan_rhi->m_physical_device, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | - VK_BUFFER_USAGE_TRANSFER_SRC_BIT | - VK_BUFFER_USAGE_TRANSFER_DST_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - &m_emitter_buffer_batches[id].m_position_device_buffer, - &m_emitter_buffer_batches[id].m_position_device_memory, - staggingBuferSize); - - VulkanUtil::createBufferAndInitialize(m_vulkan_rhi->m_device, - m_vulkan_rhi->m_physical_device, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | - VK_BUFFER_USAGE_TRANSFER_SRC_BIT | - VK_BUFFER_USAGE_TRANSFER_DST_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - &m_emitter_buffer_batches[id].m_position_render_buffer, - &m_emitter_buffer_batches[id].m_position_render_memory, - staggingBuferSize); + m_rhi->mapMemory(m_emitter_buffer_batches[id].m_position_host_memory, 0, RHI_WHOLE_SIZE, 0, &mapped); + + m_rhi->flushMappedMemoryRanges( + nullptr, m_emitter_buffer_batches[id].m_position_host_memory, 0, RHI_WHOLE_SIZE); + + m_rhi->unmapMemory(m_emitter_buffer_batches[id].m_position_host_memory); + + m_rhi->createBufferAndInitialize(RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT | RHI_BUFFER_USAGE_TRANSFER_SRC_BIT | + RHI_BUFFER_USAGE_TRANSFER_DST_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_emitter_buffer_batches[id].m_position_device_buffer, + m_emitter_buffer_batches[id].m_position_device_memory, + staggingBuferSize); + + m_rhi->createBufferAndInitialize(RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT | RHI_BUFFER_USAGE_TRANSFER_SRC_BIT | + RHI_BUFFER_USAGE_TRANSFER_DST_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_emitter_buffer_batches[id].m_position_render_buffer, + m_emitter_buffer_batches[id].m_position_render_memory, + staggingBuferSize); // Copy to staging buffer - VkCommandBufferAllocateInfo cmdBufAllocateInfo {}; - cmdBufAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; - cmdBufAllocateInfo.commandPool = m_vulkan_rhi->m_command_pool; - cmdBufAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + RHICommandBufferAllocateInfo cmdBufAllocateInfo {}; + cmdBufAllocateInfo.sType = RHI_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + cmdBufAllocateInfo.commandPool = m_rhi->getCommandPoor(); + cmdBufAllocateInfo.level = RHI_COMMAND_BUFFER_LEVEL_PRIMARY; cmdBufAllocateInfo.commandBufferCount = 1; - VkCommandBuffer copyCmd; - if (VK_SUCCESS != vkAllocateCommandBuffers(m_vulkan_rhi->m_device, &cmdBufAllocateInfo, ©Cmd)) + RHICommandBuffer* copyCmd; + if (RHI_SUCCESS != m_rhi->allocateCommandBuffers(&cmdBufAllocateInfo, copyCmd)) { throw std::runtime_error("alloc command buffer"); } - VkCommandBufferBeginInfo cmdBufInfo {}; - cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; - if (VK_SUCCESS != vkBeginCommandBuffer(copyCmd, &cmdBufInfo)) + RHICommandBufferBeginInfo cmdBufInfo {}; + cmdBufInfo.sType = RHI_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + if (RHI_SUCCESS != m_rhi->beginCommandBuffer(copyCmd, &cmdBufInfo)) { throw std::runtime_error("begin command buffer"); } - VkBufferCopy copyRegion = {}; - copyRegion.size = staggingBuferSize; - vkCmdCopyBuffer(copyCmd, - m_emitter_buffer_batches[id].m_position_host_buffer, - m_emitter_buffer_batches[id].m_position_device_buffer, - 1, - ©Region); - if (VK_SUCCESS != vkEndCommandBuffer(copyCmd)) + RHIBufferCopy copyRegion = {}; + copyRegion.srcOffset = 0; + copyRegion.dstOffset = 0; + copyRegion.size = staggingBuferSize; + m_rhi->cmdCopyBuffer(copyCmd, + m_emitter_buffer_batches[id].m_position_host_buffer, + m_emitter_buffer_batches[id].m_position_device_buffer, + 1, + ©Region); + + if (RHI_SUCCESS != m_rhi->endCommandBuffer(copyCmd)) { throw std::runtime_error("buffer copy"); } - VkSubmitInfo submitInfo {}; - submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + RHISubmitInfo submitInfo {}; + submitInfo.sType = RHI_STRUCTURE_TYPE_SUBMIT_INFO; submitInfo.commandBufferCount = 1; submitInfo.pCommandBuffers = ©Cmd; - VkFenceCreateInfo fenceInfo {}; - fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + RHIFenceCreateInfo fenceInfo {}; + fenceInfo.sType = RHI_STRUCTURE_TYPE_FENCE_CREATE_INFO; fenceInfo.flags = 0; - if (VK_SUCCESS != vkCreateFence(m_vulkan_rhi->m_device, &fenceInfo, nullptr, &fence)) + if (RHI_SUCCESS != m_rhi->createFence(&fenceInfo, fence)) { throw std::runtime_error("create fence"); } // Submit to the queue - if (VK_SUCCESS != vkQueueSubmit(m_vulkan_rhi->m_compute_queue, 1, &submitInfo, fence)) + if (RHI_SUCCESS != m_rhi->queueSubmit(m_rhi->getComputeQueue(), 1, &submitInfo, fence)) { throw std::runtime_error("queue submit"); } - if (VK_SUCCESS != vkWaitForFences(m_vulkan_rhi->m_device, 1, &fence, VK_TRUE, UINT64_MAX)) + + if (RHI_SUCCESS != m_rhi->waitForFencesPFN(1, &fence, RHI_TRUE, UINT64_MAX)) { throw std::runtime_error("wait fence submit"); } - vkDestroyFence(m_vulkan_rhi->m_device, fence, nullptr); - vkFreeCommandBuffers(m_vulkan_rhi->m_device, m_vulkan_rhi->m_command_pool, 1, ©Cmd); + m_rhi->destroyFence(fence); + m_rhi->freeCommandBuffers(m_rhi->getCommandPoor(), 1, copyCmd); } } @@ -869,21 +782,20 @@ namespace Piccolo setupPipelines(); setupAttachments(); - VkCommandBufferAllocateInfo cmdBufAllocateInfo {}; - cmdBufAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; - cmdBufAllocateInfo.commandPool = m_vulkan_rhi->m_command_pool; - cmdBufAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + RHICommandBufferAllocateInfo cmdBufAllocateInfo {}; + cmdBufAllocateInfo.sType = RHI_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + cmdBufAllocateInfo.commandPool = m_rhi->getCommandPoor(); + cmdBufAllocateInfo.level = RHI_COMMAND_BUFFER_LEVEL_PRIMARY; cmdBufAllocateInfo.commandBufferCount = 1; - if (VK_SUCCESS != - vkAllocateCommandBuffers(m_vulkan_rhi->m_device, &cmdBufAllocateInfo, &m_compute_command_buffer)) + if (RHI_SUCCESS != m_rhi->allocateCommandBuffers(&cmdBufAllocateInfo, m_compute_command_buffer)) throw std::runtime_error("alloc compute command buffer"); - if (VK_SUCCESS != vkAllocateCommandBuffers(m_vulkan_rhi->m_device, &cmdBufAllocateInfo, &m_copy_command_buffer)) - throw std::runtime_error("alloc copyt command buffer"); + if (RHI_SUCCESS != m_rhi->allocateCommandBuffers(&cmdBufAllocateInfo, m_copy_command_buffer)) + throw std::runtime_error("alloc copy command buffer"); - VkFenceCreateInfo fenceCreateInfo {}; - fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + RHIFenceCreateInfo fenceCreateInfo {}; + fenceCreateInfo.sType = RHI_STRUCTURE_TYPE_FENCE_CREATE_INFO; fenceCreateInfo.flags = 0; - if (VK_SUCCESS != vkCreateFence(m_vulkan_rhi->m_device, &fenceCreateInfo, nullptr, &m_fence)) + if (RHI_SUCCESS != m_rhi->createFence(&fenceCreateInfo, m_fence)) throw std::runtime_error("create fence"); } @@ -901,107 +813,105 @@ namespace Piccolo // compute descriptor sets { - VkDescriptorSetLayoutBinding particle_layout_bindings[11] = {}; + RHIDescriptorSetLayoutBinding particle_layout_bindings[11] = {}; { - VkDescriptorSetLayoutBinding& uniform_layout_bingding = particle_layout_bindings[0]; - uniform_layout_bingding.binding = 0; - uniform_layout_bingding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - uniform_layout_bingding.descriptorCount = 1; - uniform_layout_bingding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + RHIDescriptorSetLayoutBinding& uniform_layout_bingding = particle_layout_bindings[0]; + uniform_layout_bingding.binding = 0; + uniform_layout_bingding.descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + uniform_layout_bingding.descriptorCount = 1; + uniform_layout_bingding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; } { - VkDescriptorSetLayoutBinding& storage_position_layout_binding = particle_layout_bindings[1]; - storage_position_layout_binding.binding = 1; - storage_position_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - storage_position_layout_binding.descriptorCount = 1; - storage_position_layout_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + RHIDescriptorSetLayoutBinding& storage_position_layout_binding = particle_layout_bindings[1]; + storage_position_layout_binding.binding = 1; + storage_position_layout_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + storage_position_layout_binding.descriptorCount = 1; + storage_position_layout_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; } { - VkDescriptorSetLayoutBinding& storage_counter_layout_binding = particle_layout_bindings[2]; - storage_counter_layout_binding.binding = 2; - storage_counter_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - storage_counter_layout_binding.descriptorCount = 1; - storage_counter_layout_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + RHIDescriptorSetLayoutBinding& storage_counter_layout_binding = particle_layout_bindings[2]; + storage_counter_layout_binding.binding = 2; + storage_counter_layout_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + storage_counter_layout_binding.descriptorCount = 1; + storage_counter_layout_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; } { - VkDescriptorSetLayoutBinding& storage_indirectargument_layout_binding = particle_layout_bindings[3]; - storage_indirectargument_layout_binding.binding = 3; - storage_indirectargument_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + RHIDescriptorSetLayoutBinding& storage_indirectargument_layout_binding = particle_layout_bindings[3]; + storage_indirectargument_layout_binding.binding = 3; + storage_indirectargument_layout_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; storage_indirectargument_layout_binding.descriptorCount = 1; - storage_indirectargument_layout_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + storage_indirectargument_layout_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; } { - VkDescriptorSetLayoutBinding& alive_list_layout_binding = particle_layout_bindings[4]; - alive_list_layout_binding.binding = 4; - alive_list_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - alive_list_layout_binding.descriptorCount = 1; - alive_list_layout_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + RHIDescriptorSetLayoutBinding& alive_list_layout_binding = particle_layout_bindings[4]; + alive_list_layout_binding.binding = 4; + alive_list_layout_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + alive_list_layout_binding.descriptorCount = 1; + alive_list_layout_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; } { - VkDescriptorSetLayoutBinding& dead_list_layout_binding = particle_layout_bindings[5]; - dead_list_layout_binding.binding = 5; - dead_list_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - dead_list_layout_binding.descriptorCount = 1; - dead_list_layout_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + RHIDescriptorSetLayoutBinding& dead_list_layout_binding = particle_layout_bindings[5]; + dead_list_layout_binding.binding = 5; + dead_list_layout_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + dead_list_layout_binding.descriptorCount = 1; + dead_list_layout_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; } { - VkDescriptorSetLayoutBinding& alive_list_next_layout_binding = particle_layout_bindings[6]; - alive_list_next_layout_binding.binding = 6; - alive_list_next_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - alive_list_next_layout_binding.descriptorCount = 1; - alive_list_next_layout_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + RHIDescriptorSetLayoutBinding& alive_list_next_layout_binding = particle_layout_bindings[6]; + alive_list_next_layout_binding.binding = 6; + alive_list_next_layout_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + alive_list_next_layout_binding.descriptorCount = 1; + alive_list_next_layout_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; } { - VkDescriptorSetLayoutBinding& particle_res_layout_binding = particle_layout_bindings[7]; - particle_res_layout_binding.binding = 7; - particle_res_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - particle_res_layout_binding.descriptorCount = 1; - particle_res_layout_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + RHIDescriptorSetLayoutBinding& particle_res_layout_binding = particle_layout_bindings[7]; + particle_res_layout_binding.binding = 7; + particle_res_layout_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + particle_res_layout_binding.descriptorCount = 1; + particle_res_layout_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; } { - VkDescriptorSetLayoutBinding& scene_uniformbuffer_layout_binding = particle_layout_bindings[8]; - scene_uniformbuffer_layout_binding.binding = 8; - scene_uniformbuffer_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - scene_uniformbuffer_layout_binding.descriptorCount = 1; - scene_uniformbuffer_layout_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + RHIDescriptorSetLayoutBinding& scene_uniformbuffer_layout_binding = particle_layout_bindings[8]; + scene_uniformbuffer_layout_binding.binding = 8; + scene_uniformbuffer_layout_binding.descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + scene_uniformbuffer_layout_binding.descriptorCount = 1; + scene_uniformbuffer_layout_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; } { - VkDescriptorSetLayoutBinding& storage_render_position_layout_binding = particle_layout_bindings[9]; - storage_render_position_layout_binding.binding = 9; - storage_render_position_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + RHIDescriptorSetLayoutBinding& storage_render_position_layout_binding = particle_layout_bindings[9]; + storage_render_position_layout_binding.binding = 9; + storage_render_position_layout_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; storage_render_position_layout_binding.descriptorCount = 1; - storage_render_position_layout_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + storage_render_position_layout_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; } { - VkDescriptorSetLayoutBinding& piccolo_texture_layout_binding = particle_layout_bindings[10]; - piccolo_texture_layout_binding.binding = 10; - piccolo_texture_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + RHIDescriptorSetLayoutBinding& piccolo_texture_layout_binding = particle_layout_bindings[10]; + piccolo_texture_layout_binding.binding = 10; + piccolo_texture_layout_binding.descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; piccolo_texture_layout_binding.descriptorCount = 1; - piccolo_texture_layout_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + piccolo_texture_layout_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; } - VkDescriptorSetLayoutCreateInfo particle_descriptor_layout_create_info; - particle_descriptor_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo particle_descriptor_layout_create_info; + particle_descriptor_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; particle_descriptor_layout_create_info.pNext = NULL; particle_descriptor_layout_create_info.flags = 0; particle_descriptor_layout_create_info.bindingCount = sizeof(particle_layout_bindings) / sizeof(particle_layout_bindings[0]); particle_descriptor_layout_create_info.pBindings = particle_layout_bindings; - if (VK_SUCCESS != vkCreateDescriptorSetLayout(m_vulkan_rhi->m_device, - &particle_descriptor_layout_create_info, - NULL, - &m_descriptor_infos[0].layout)) + if (RHI_SUCCESS != + m_rhi->createDescriptorSetLayout(&particle_descriptor_layout_create_info, m_descriptor_infos[0].layout)) { throw std::runtime_error("setup particle compute Descriptor done"); } @@ -1009,78 +919,74 @@ namespace Piccolo } // scene depth and normal binding { - VkDescriptorSetLayoutBinding scene_global_layout_bindings[2] = {}; + RHIDescriptorSetLayoutBinding scene_global_layout_bindings[2] = {}; - VkDescriptorSetLayoutBinding& gbuffer_normal_global_layout_input_attachment_binding = + RHIDescriptorSetLayoutBinding& gbuffer_normal_global_layout_input_attachment_binding = scene_global_layout_bindings[0]; gbuffer_normal_global_layout_input_attachment_binding.binding = 0; - gbuffer_normal_global_layout_input_attachment_binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; + gbuffer_normal_global_layout_input_attachment_binding.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_IMAGE; gbuffer_normal_global_layout_input_attachment_binding.descriptorCount = 1; - gbuffer_normal_global_layout_input_attachment_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + gbuffer_normal_global_layout_input_attachment_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; - VkDescriptorSetLayoutBinding& gbuffer_depth_global_layout_input_attachment_binding = + RHIDescriptorSetLayoutBinding& gbuffer_depth_global_layout_input_attachment_binding = scene_global_layout_bindings[1]; gbuffer_depth_global_layout_input_attachment_binding.binding = 1; gbuffer_depth_global_layout_input_attachment_binding.descriptorType = - VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; gbuffer_depth_global_layout_input_attachment_binding.descriptorCount = 1; - gbuffer_depth_global_layout_input_attachment_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + gbuffer_depth_global_layout_input_attachment_binding.stageFlags = RHI_SHADER_STAGE_COMPUTE_BIT; - VkDescriptorSetLayoutCreateInfo gbuffer_lighting_global_layout_create_info; - gbuffer_lighting_global_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo gbuffer_lighting_global_layout_create_info; + gbuffer_lighting_global_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; gbuffer_lighting_global_layout_create_info.pNext = NULL; gbuffer_lighting_global_layout_create_info.flags = 0; gbuffer_lighting_global_layout_create_info.bindingCount = sizeof(scene_global_layout_bindings) / sizeof(scene_global_layout_bindings[0]); gbuffer_lighting_global_layout_create_info.pBindings = scene_global_layout_bindings; - if (VK_SUCCESS != vkCreateDescriptorSetLayout(m_vulkan_rhi->m_device, - &gbuffer_lighting_global_layout_create_info, - NULL, - &m_descriptor_infos[1].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&gbuffer_lighting_global_layout_create_info, + m_descriptor_infos[1].layout)) throw std::runtime_error("create scene normal and depth global layout"); } { - VkDescriptorSetLayoutBinding particlebillboard_global_layout_bindings[3]; + RHIDescriptorSetLayoutBinding particlebillboard_global_layout_bindings[3]; - VkDescriptorSetLayoutBinding& particlebillboard_global_layout_perframe_storage_buffer_binding = + RHIDescriptorSetLayoutBinding& particlebillboard_global_layout_perframe_storage_buffer_binding = particlebillboard_global_layout_bindings[0]; particlebillboard_global_layout_perframe_storage_buffer_binding.binding = 0; particlebillboard_global_layout_perframe_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER; particlebillboard_global_layout_perframe_storage_buffer_binding.descriptorCount = 1; - particlebillboard_global_layout_perframe_storage_buffer_binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + particlebillboard_global_layout_perframe_storage_buffer_binding.stageFlags = RHI_SHADER_STAGE_VERTEX_BIT; particlebillboard_global_layout_perframe_storage_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutBinding& particlebillboard_global_layout_perdrawcall_storage_buffer_binding = + RHIDescriptorSetLayoutBinding& particlebillboard_global_layout_perdrawcall_storage_buffer_binding = particlebillboard_global_layout_bindings[1]; particlebillboard_global_layout_perdrawcall_storage_buffer_binding.binding = 1; particlebillboard_global_layout_perdrawcall_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; particlebillboard_global_layout_perdrawcall_storage_buffer_binding.descriptorCount = 1; - particlebillboard_global_layout_perdrawcall_storage_buffer_binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + particlebillboard_global_layout_perdrawcall_storage_buffer_binding.stageFlags = RHI_SHADER_STAGE_VERTEX_BIT; particlebillboard_global_layout_perdrawcall_storage_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutBinding& particlebillboard_global_layout_texture_binding = + RHIDescriptorSetLayoutBinding& particlebillboard_global_layout_texture_binding = particlebillboard_global_layout_bindings[2]; - particlebillboard_global_layout_texture_binding.binding = 2; - particlebillboard_global_layout_texture_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; - particlebillboard_global_layout_texture_binding.descriptorCount = 1; - particlebillboard_global_layout_texture_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + particlebillboard_global_layout_texture_binding.binding = 2; + particlebillboard_global_layout_texture_binding.descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + particlebillboard_global_layout_texture_binding.descriptorCount = 1; + particlebillboard_global_layout_texture_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; particlebillboard_global_layout_texture_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutCreateInfo particlebillboard_global_layout_create_info; - particlebillboard_global_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo particlebillboard_global_layout_create_info; + particlebillboard_global_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; particlebillboard_global_layout_create_info.pNext = NULL; particlebillboard_global_layout_create_info.flags = 0; particlebillboard_global_layout_create_info.bindingCount = 3; particlebillboard_global_layout_create_info.pBindings = particlebillboard_global_layout_bindings; - if (VK_SUCCESS != vkCreateDescriptorSetLayout(m_vulkan_rhi->m_device, - &particlebillboard_global_layout_create_info, - NULL, - &m_descriptor_infos[2].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&particlebillboard_global_layout_create_info, + m_descriptor_infos[2].layout)) { throw std::runtime_error("create particle billboard global layout"); } @@ -1093,29 +999,27 @@ namespace Piccolo // compute pipeline { - VkDescriptorSetLayout descriptorset_layouts[2] = {m_descriptor_infos[0].layout, - m_descriptor_infos[1].layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayout* descriptorset_layouts[2] = {m_descriptor_infos[0].layout, + m_descriptor_infos[1].layout}; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = sizeof(descriptorset_layouts) / sizeof(descriptorset_layouts[0]); pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout( - m_vulkan_rhi->m_device, &pipeline_layout_create_info, nullptr, &m_render_pipelines[0].layout) != - VK_SUCCESS) + if (m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[0].layout) != RHI_SUCCESS) throw std::runtime_error("create compute pass pipe layout"); LOG_INFO("compute pipe layout done"); } - + /* VkPipelineCache pipelineCache; VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {}; - pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; - if (VK_SUCCESS != - vkCreatePipelineCache(m_vulkan_rhi->m_device, &pipelineCacheCreateInfo, nullptr, &pipelineCache)) + pipelineCacheCreateInfo.sType = RHI_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; + if (RHI_SUCCESS != vkCreatePipelineCache(m_vulkan_rhi->m_device, &pipelineCacheCreateInfo, nullptr, + &pipelineCache)) { throw std::runtime_error("create particle cache"); - } + }*/ struct SpecializationData { @@ -1133,57 +1037,52 @@ namespace Piccolo specializationInfo.dataSize = sizeof(specializationData); specializationInfo.pData = &specializationData; - VkComputePipelineCreateInfo computePipelineCreateInfo {}; + RHIComputePipelineCreateInfo computePipelineCreateInfo {}; - computePipelineCreateInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; + computePipelineCreateInfo.sType = RHI_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; computePipelineCreateInfo.layout = m_render_pipelines[0].layout; computePipelineCreateInfo.flags = 0; - VkPipelineShaderStageCreateInfo shaderStage = {}; - shaderStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - shaderStage.stage = VK_SHADER_STAGE_COMPUTE_BIT; - shaderStage.pName = "main"; + RHIPipelineShaderStageCreateInfo shaderStage = {}; + shaderStage.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + shaderStage.stage = RHI_SHADER_STAGE_COMPUTE_BIT; + shaderStage.pName = "main"; { - shaderStage.module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, PARTICLE_KICKOFF_COMP); + shaderStage.module = m_rhi->createShaderModule(PARTICLE_KICKOFF_COMP); shaderStage.pSpecializationInfo = nullptr; - assert(shaderStage.module != VK_NULL_HANDLE); + assert(shaderStage.module != RHI_NULL_HANDLE); - computePipelineCreateInfo.stage = shaderStage; - if (VK_SUCCESS != - vkCreateComputePipelines( - m_vulkan_rhi->m_device, pipelineCache, 1, &computePipelineCreateInfo, nullptr, &m_kickoff_pipeline)) + computePipelineCreateInfo.pStages = &shaderStage; + if (RHI_SUCCESS != m_rhi->createComputePipelines( + /*pipelineCache*/ nullptr, 1, &computePipelineCreateInfo, m_kickoff_pipeline)) { throw std::runtime_error("create particle kickoff pipe"); } } { - shaderStage.module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, PARTICLE_EMIT_COMP); + shaderStage.module = m_rhi->createShaderModule(PARTICLE_EMIT_COMP); shaderStage.pSpecializationInfo = nullptr; - assert(shaderStage.module != VK_NULL_HANDLE); + assert(shaderStage.module != RHI_NULL_HANDLE); - computePipelineCreateInfo.stage = shaderStage; - if (VK_SUCCESS != - vkCreateComputePipelines( - m_vulkan_rhi->m_device, pipelineCache, 1, &computePipelineCreateInfo, nullptr, &m_emit_pipeline)) + computePipelineCreateInfo.pStages = &shaderStage; + if (RHI_SUCCESS != m_rhi->createComputePipelines( + /*pipelineCache*/ nullptr, 1, &computePipelineCreateInfo, m_emit_pipeline)) { throw std::runtime_error("create particle emit pipe"); } } { - shaderStage.module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, PARTICLE_SIMULATE_COMP); + shaderStage.module = m_rhi->createShaderModule(PARTICLE_SIMULATE_COMP); shaderStage.pSpecializationInfo = nullptr; - assert(shaderStage.module != VK_NULL_HANDLE); - - computePipelineCreateInfo.stage = shaderStage; - if (VK_SUCCESS != vkCreateComputePipelines(m_vulkan_rhi->m_device, - pipelineCache, - 1, - &computePipelineCreateInfo, - nullptr, - &m_simulate_pipeline)) + assert(shaderStage.module != RHI_NULL_HANDLE); + + computePipelineCreateInfo.pStages = &shaderStage; + + if (RHI_SUCCESS != m_rhi->createComputePipelines( + /*pipelineCache*/ nullptr, 1, &computePipelineCreateInfo, m_simulate_pipeline)) { throw std::runtime_error("create particle simulate pipe"); } @@ -1191,91 +1090,87 @@ namespace Piccolo // particle billboard { - VkDescriptorSetLayout descriptorset_layouts[1] = {m_descriptor_infos[2].layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayout* descriptorset_layouts[1] = {m_descriptor_infos[2].layout}; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = 1; pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout( - m_vulkan_rhi->m_device, &pipeline_layout_create_info, nullptr, &m_render_pipelines[1].layout) != - VK_SUCCESS) + if (m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[1].layout) != RHI_SUCCESS) { throw std::runtime_error("create particle billboard pipeline layout"); } - VkShaderModule vert_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, PARTICLEBILLBOARD_VERT); - VkShaderModule frag_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, PARTICLEBILLBOARD_FRAG); + RHIShader* vert_shader_module = m_rhi->createShaderModule(PARTICLEBILLBOARD_VERT); + RHIShader* frag_shader_module = m_rhi->createShaderModule(PARTICLEBILLBOARD_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, - frag_pipeline_shader_stage_create_info}; + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + frag_pipeline_shader_stage_create_info}; - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = 0; vertex_input_state_create_info.pVertexBindingDescriptions = NULL; vertex_input_state_create_info.vertexAttributeDescriptionCount = 0; vertex_input_state_create_info.pVertexAttributeDescriptions = NULL; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_NONE; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_NONE; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; - - VkPipelineColorBlendAttachmentState color_blend_attachments[1] = {}; - color_blend_attachments[0].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | - VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachments[0].blendEnable = VK_TRUE; - color_blend_attachments[0].srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; - color_blend_attachments[0].colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachments[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachments[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachments[0].alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info = {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; + + RHIPipelineColorBlendAttachmentState color_blend_attachments[1] = {}; + color_blend_attachments[0].colorWriteMask = RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | + RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachments[0].blendEnable = RHI_TRUE; + color_blend_attachments[0].srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].dstColorBlendFactor = RHI_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; + color_blend_attachments[0].colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachments[0].srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachments[0].dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachments[0].alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info = {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = sizeof(color_blend_attachments) / sizeof(color_blend_attachments[0]); color_blend_state_create_info.pAttachments = &color_blend_attachments[0]; @@ -1284,23 +1179,23 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_TRUE; - depth_stencil_create_info.depthWriteEnable = VK_FALSE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_FALSE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; - VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; + RHIDynamicState dynamic_states[] = {RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR}; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 2; dynamic_state_create_info.pDynamicStates = dynamic_states; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -1313,29 +1208,25 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[1].layout; pipelineInfo.renderPass = m_render_pass; pipelineInfo.subpass = _main_camera_subpass_forward_lighting; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines(m_vulkan_rhi->m_device, - VK_NULL_HANDLE, - 1, - &pipelineInfo, - nullptr, - &m_render_pipelines[1].pipeline) != VK_SUCCESS) + if (m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, 1, &pipelineInfo, m_render_pipelines[1].pipeline) != + RHI_SUCCESS) { throw std::runtime_error("create particle billboard graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } } void ParticlePass::allocateDescriptorSet() { - VkDescriptorSetAllocateInfo particle_descriptor_set_alloc_info; - particle_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; - particle_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + RHIDescriptorSetAllocateInfo particle_descriptor_set_alloc_info; + particle_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + particle_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); m_descriptor_infos.resize(3 * m_emitter_count); for (int eid = 0; eid < m_emitter_count; ++eid) @@ -1343,17 +1234,16 @@ namespace Piccolo particle_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[0].layout; particle_descriptor_set_alloc_info.descriptorSetCount = 1; particle_descriptor_set_alloc_info.pNext = NULL; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &particle_descriptor_set_alloc_info, - &m_descriptor_infos[eid * 3].descriptor_set)) + + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&particle_descriptor_set_alloc_info, + m_descriptor_infos[eid * 3].descriptor_set)) throw std::runtime_error("allocate compute descriptor set"); particle_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[1].layout; particle_descriptor_set_alloc_info.descriptorSetCount = 1; particle_descriptor_set_alloc_info.pNext = NULL; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &particle_descriptor_set_alloc_info, - &m_descriptor_infos[eid * 3 + 1].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&particle_descriptor_set_alloc_info, + m_descriptor_infos[eid * 3 + 1].descriptor_set)) LOG_INFO("allocate normal and depth descriptor set done"); } } @@ -1364,242 +1254,241 @@ namespace Piccolo { // compute part { - std::vector computeWriteDescriptorSets { + std::vector computeWriteDescriptorSets { {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}}; - VkDescriptorBufferInfo uniformbufferDescriptor = {m_compute_uniform_buffer, 0, VK_WHOLE_SIZE}; + RHIDescriptorBufferInfo uniformbufferDescriptor = {m_compute_uniform_buffer, 0, RHI_WHOLE_SIZE}; { - VkWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[0]; - descriptorset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; - descriptorset.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - descriptorset.dstBinding = 0; - descriptorset.pBufferInfo = &uniformbufferDescriptor; - descriptorset.descriptorCount = 1; + RHIWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[0]; + descriptorset.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; + descriptorset.descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + descriptorset.dstBinding = 0; + descriptorset.pBufferInfo = &uniformbufferDescriptor; + descriptorset.descriptorCount = 1; } - VkDescriptorBufferInfo positionBufferDescriptor = { - m_emitter_buffer_batches[eid].m_position_device_buffer, 0, VK_WHOLE_SIZE}; + RHIDescriptorBufferInfo positionBufferDescriptor = { + m_emitter_buffer_batches[eid].m_position_device_buffer, 0, RHI_WHOLE_SIZE}; { - VkWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[1]; - descriptorset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; - descriptorset.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - descriptorset.dstBinding = 1; - descriptorset.pBufferInfo = &positionBufferDescriptor; - descriptorset.descriptorCount = 1; + RHIWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[1]; + descriptorset.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; + descriptorset.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + descriptorset.dstBinding = 1; + descriptorset.pBufferInfo = &positionBufferDescriptor; + descriptorset.descriptorCount = 1; } - VkDescriptorBufferInfo counterBufferDescriptor = { - m_emitter_buffer_batches[eid].m_counter_device_buffer, 0, VK_WHOLE_SIZE}; + RHIDescriptorBufferInfo counterBufferDescriptor = { + m_emitter_buffer_batches[eid].m_counter_device_buffer, 0, RHI_WHOLE_SIZE}; { - VkWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[2]; - descriptorset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; - descriptorset.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - descriptorset.dstBinding = 2; - descriptorset.pBufferInfo = &counterBufferDescriptor; - descriptorset.descriptorCount = 1; + RHIWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[2]; + descriptorset.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; + descriptorset.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + descriptorset.dstBinding = 2; + descriptorset.pBufferInfo = &counterBufferDescriptor; + descriptorset.descriptorCount = 1; } - VkDescriptorBufferInfo indirectArgumentBufferDescriptor = { - m_emitter_buffer_batches[eid].m_indirect_dispatch_argument_buffer, 0, VK_WHOLE_SIZE}; + RHIDescriptorBufferInfo indirectArgumentBufferDescriptor = { + m_emitter_buffer_batches[eid].m_indirect_dispatch_argument_buffer, 0, RHI_WHOLE_SIZE}; { - VkWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[3]; - descriptorset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; - descriptorset.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - descriptorset.dstBinding = 3; - descriptorset.pBufferInfo = &indirectArgumentBufferDescriptor; - descriptorset.descriptorCount = 1; + RHIWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[3]; + descriptorset.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; + descriptorset.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + descriptorset.dstBinding = 3; + descriptorset.pBufferInfo = &indirectArgumentBufferDescriptor; + descriptorset.descriptorCount = 1; } - VkDescriptorBufferInfo aliveListBufferDescriptor = { - m_emitter_buffer_batches[eid].m_alive_list_buffer, 0, VK_WHOLE_SIZE}; + RHIDescriptorBufferInfo aliveListBufferDescriptor = { + m_emitter_buffer_batches[eid].m_alive_list_buffer, 0, RHI_WHOLE_SIZE}; { - VkWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[4]; - descriptorset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; - descriptorset.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - descriptorset.dstBinding = 4; - descriptorset.pBufferInfo = &aliveListBufferDescriptor; - descriptorset.descriptorCount = 1; + RHIWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[4]; + descriptorset.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; + descriptorset.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + descriptorset.dstBinding = 4; + descriptorset.pBufferInfo = &aliveListBufferDescriptor; + descriptorset.descriptorCount = 1; } - VkDescriptorBufferInfo deadListBufferDescriptor = { - m_emitter_buffer_batches[eid].m_dead_list_buffer, 0, VK_WHOLE_SIZE}; + RHIDescriptorBufferInfo deadListBufferDescriptor = { + m_emitter_buffer_batches[eid].m_dead_list_buffer, 0, RHI_WHOLE_SIZE}; { - VkWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[5]; - descriptorset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; - descriptorset.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - descriptorset.dstBinding = 5; - descriptorset.pBufferInfo = &deadListBufferDescriptor; - descriptorset.descriptorCount = 1; + RHIWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[5]; + descriptorset.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; + descriptorset.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + descriptorset.dstBinding = 5; + descriptorset.pBufferInfo = &deadListBufferDescriptor; + descriptorset.descriptorCount = 1; } - VkDescriptorBufferInfo aliveListNextBufferDescriptor = { - m_emitter_buffer_batches[eid].m_alive_list_next_buffer, 0, VK_WHOLE_SIZE}; + RHIDescriptorBufferInfo aliveListNextBufferDescriptor = { + m_emitter_buffer_batches[eid].m_alive_list_next_buffer, 0, RHI_WHOLE_SIZE}; { - VkWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[6]; - descriptorset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; - descriptorset.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - descriptorset.dstBinding = 6; - descriptorset.pBufferInfo = &aliveListNextBufferDescriptor; - descriptorset.descriptorCount = 1; + RHIWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[6]; + descriptorset.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; + descriptorset.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + descriptorset.dstBinding = 6; + descriptorset.pBufferInfo = &aliveListNextBufferDescriptor; + descriptorset.descriptorCount = 1; } - VkDescriptorBufferInfo particleComponentResBufferDescriptor = { - m_emitter_buffer_batches[eid].m_particle_component_res_buffer, 0, VK_WHOLE_SIZE}; + RHIDescriptorBufferInfo particleComponentResBufferDescriptor = { + m_emitter_buffer_batches[eid].m_particle_component_res_buffer, 0, RHI_WHOLE_SIZE}; { - VkWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[7]; - descriptorset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; - descriptorset.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - descriptorset.dstBinding = 7; - descriptorset.pBufferInfo = &particleComponentResBufferDescriptor; - descriptorset.descriptorCount = 1; + RHIWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[7]; + descriptorset.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; + descriptorset.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + descriptorset.dstBinding = 7; + descriptorset.pBufferInfo = &particleComponentResBufferDescriptor; + descriptorset.descriptorCount = 1; } - VkDescriptorBufferInfo particleSceneUniformBufferDescriptor = { - m_scene_uniform_buffer, 0, VK_WHOLE_SIZE}; + RHIDescriptorBufferInfo particleSceneUniformBufferDescriptor = { + m_scene_uniform_buffer, 0, RHI_WHOLE_SIZE}; { - VkWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[8]; - descriptorset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; - descriptorset.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - descriptorset.dstBinding = 8; - descriptorset.pBufferInfo = &particleSceneUniformBufferDescriptor; - descriptorset.descriptorCount = 1; + RHIWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[8]; + descriptorset.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; + descriptorset.descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + descriptorset.dstBinding = 8; + descriptorset.pBufferInfo = &particleSceneUniformBufferDescriptor; + descriptorset.descriptorCount = 1; } - VkDescriptorBufferInfo positionRenderbufferDescriptor = { - m_emitter_buffer_batches[eid].m_position_render_buffer, 0, VK_WHOLE_SIZE}; + RHIDescriptorBufferInfo positionRenderbufferDescriptor = { + m_emitter_buffer_batches[eid].m_position_render_buffer, 0, RHI_WHOLE_SIZE}; { - VkWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[9]; - descriptorset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; - descriptorset.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - descriptorset.dstBinding = 9; - descriptorset.pBufferInfo = &positionRenderbufferDescriptor; - descriptorset.descriptorCount = 1; + RHIWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[9]; + descriptorset.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; + descriptorset.descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; + descriptorset.dstBinding = 9; + descriptorset.pBufferInfo = &positionRenderbufferDescriptor; + descriptorset.descriptorCount = 1; } - VkSampler sampler; - VkSamplerCreateInfo samplerCreateInfo {}; - samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; + RHISampler* sampler; + RHISamplerCreateInfo samplerCreateInfo {}; + samplerCreateInfo.sType = RHI_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; samplerCreateInfo.maxAnisotropy = 1.0f; samplerCreateInfo.anisotropyEnable = true; - samplerCreateInfo.magFilter = VK_FILTER_LINEAR; - samplerCreateInfo.minFilter = VK_FILTER_LINEAR; - samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; - samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT; - samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT; - samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.magFilter = RHI_FILTER_LINEAR; + samplerCreateInfo.minFilter = RHI_FILTER_LINEAR; + samplerCreateInfo.mipmapMode = RHI_SAMPLER_MIPMAP_MODE_LINEAR; + samplerCreateInfo.addressModeU = RHI_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.addressModeV = RHI_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.addressModeW = RHI_SAMPLER_ADDRESS_MODE_REPEAT; samplerCreateInfo.mipLodBias = 0.0f; - samplerCreateInfo.compareOp = VK_COMPARE_OP_NEVER; + samplerCreateInfo.compareOp = RHI_COMPARE_OP_NEVER; samplerCreateInfo.minLod = 0.0f; samplerCreateInfo.maxLod = 0.0f; - samplerCreateInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; - if (VK_SUCCESS != vkCreateSampler(m_vulkan_rhi->m_device, &samplerCreateInfo, nullptr, &sampler)) + samplerCreateInfo.borderColor = RHI_BORDER_COLOR_FLOAT_OPAQUE_WHITE; + + if (RHI_SUCCESS != m_rhi->createSampler(&samplerCreateInfo, sampler)) { throw std::runtime_error("create sampler error"); } - VkDescriptorImageInfo piccolo_texture_image_info = {}; - piccolo_texture_image_info.sampler = sampler; - piccolo_texture_image_info.imageView = m_piccolo_logo_texture_image_view; - piccolo_texture_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + RHIDescriptorImageInfo piccolo_texture_image_info = {}; + piccolo_texture_image_info.sampler = sampler; + piccolo_texture_image_info.imageView = m_piccolo_logo_texture_image_view; + piccolo_texture_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; { - VkWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[10]; - descriptorset.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; - descriptorset.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; - descriptorset.dstBinding = 10; - descriptorset.pImageInfo = &piccolo_texture_image_info; - descriptorset.descriptorCount = 1; + RHIWriteDescriptorSet& descriptorset = computeWriteDescriptorSets[10]; + descriptorset.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorset.dstSet = m_descriptor_infos[eid * 3].descriptor_set; + descriptorset.descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + descriptorset.dstBinding = 10; + descriptorset.pImageInfo = &piccolo_texture_image_info; + descriptorset.descriptorCount = 1; } - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - static_cast(computeWriteDescriptorSets.size()), - computeWriteDescriptorSets.data(), - 0, - NULL); + m_rhi->updateDescriptorSets(static_cast(computeWriteDescriptorSets.size()), + computeWriteDescriptorSets.data(), + 0, + NULL); } { - VkWriteDescriptorSet descriptor_input_attachment_writes_info[2] = {{}, {}}; + RHIWriteDescriptorSet descriptor_input_attachment_writes_info[2] = {{}, {}}; - VkDescriptorImageInfo gbuffer_normal_descriptor_image_info = {}; - gbuffer_normal_descriptor_image_info.sampler = nullptr; - gbuffer_normal_descriptor_image_info.imageView = m_src_normal_image_view; - gbuffer_normal_descriptor_image_info.imageLayout = VK_IMAGE_LAYOUT_GENERAL; + RHIDescriptorImageInfo gbuffer_normal_descriptor_image_info = {}; + gbuffer_normal_descriptor_image_info.sampler = nullptr; + gbuffer_normal_descriptor_image_info.imageView = m_src_normal_image_view; + gbuffer_normal_descriptor_image_info.imageLayout = RHI_IMAGE_LAYOUT_GENERAL; { - VkWriteDescriptorSet& gbuffer_normal_descriptor_input_attachment_write_info = + RHIWriteDescriptorSet& gbuffer_normal_descriptor_input_attachment_write_info = descriptor_input_attachment_writes_info[0]; gbuffer_normal_descriptor_input_attachment_write_info.sType = - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; gbuffer_normal_descriptor_input_attachment_write_info.pNext = NULL; gbuffer_normal_descriptor_input_attachment_write_info.dstSet = m_descriptor_infos[eid * 3 + 1].descriptor_set; gbuffer_normal_descriptor_input_attachment_write_info.dstBinding = 0; gbuffer_normal_descriptor_input_attachment_write_info.dstArrayElement = 0; gbuffer_normal_descriptor_input_attachment_write_info.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; + RHI_DESCRIPTOR_TYPE_STORAGE_IMAGE; gbuffer_normal_descriptor_input_attachment_write_info.descriptorCount = 1; gbuffer_normal_descriptor_input_attachment_write_info.pImageInfo = &gbuffer_normal_descriptor_image_info; } - VkSampler sampler; - VkSamplerCreateInfo samplerCreateInfo {}; - samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; + RHISampler* sampler; + RHISamplerCreateInfo samplerCreateInfo {}; + samplerCreateInfo.sType = RHI_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; samplerCreateInfo.maxAnisotropy = 1.0f; samplerCreateInfo.anisotropyEnable = true; - samplerCreateInfo.magFilter = VK_FILTER_NEAREST; - samplerCreateInfo.minFilter = VK_FILTER_NEAREST; - samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; - samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT; - samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT; - samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.magFilter = RHI_FILTER_NEAREST; + samplerCreateInfo.minFilter = RHI_FILTER_NEAREST; + samplerCreateInfo.mipmapMode = RHI_SAMPLER_MIPMAP_MODE_LINEAR; + samplerCreateInfo.addressModeU = RHI_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.addressModeV = RHI_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.addressModeW = RHI_SAMPLER_ADDRESS_MODE_REPEAT; samplerCreateInfo.mipLodBias = 0.0f; - samplerCreateInfo.compareOp = VK_COMPARE_OP_NEVER; + samplerCreateInfo.compareOp = RHI_COMPARE_OP_NEVER; samplerCreateInfo.minLod = 0.0f; samplerCreateInfo.maxLod = 0.0f; - samplerCreateInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; - if (VK_SUCCESS != vkCreateSampler(m_vulkan_rhi->m_device, &samplerCreateInfo, nullptr, &sampler)) + samplerCreateInfo.borderColor = RHI_BORDER_COLOR_FLOAT_OPAQUE_WHITE; + if (RHI_SUCCESS != m_rhi->createSampler(&samplerCreateInfo, sampler)) { throw std::runtime_error("create sampler error"); } - VkDescriptorImageInfo depth_descriptor_image_info = {}; - depth_descriptor_image_info.sampler = sampler; - depth_descriptor_image_info.imageView = m_src_depth_image_view; - depth_descriptor_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + RHIDescriptorImageInfo depth_descriptor_image_info = {}; + depth_descriptor_image_info.sampler = sampler; + depth_descriptor_image_info.imageView = m_src_depth_image_view; + depth_descriptor_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; { - VkWriteDescriptorSet& depth_descriptor_input_attachment_write_info = + RHIWriteDescriptorSet& depth_descriptor_input_attachment_write_info = descriptor_input_attachment_writes_info[1]; - depth_descriptor_input_attachment_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + depth_descriptor_input_attachment_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; depth_descriptor_input_attachment_write_info.pNext = NULL; depth_descriptor_input_attachment_write_info.dstSet = m_descriptor_infos[eid * 3 + 1].descriptor_set; depth_descriptor_input_attachment_write_info.dstBinding = 1; depth_descriptor_input_attachment_write_info.dstArrayElement = 0; depth_descriptor_input_attachment_write_info.descriptorType = - VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; depth_descriptor_input_attachment_write_info.descriptorCount = 1; depth_descriptor_input_attachment_write_info.pImageInfo = &depth_descriptor_image_info; } - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - sizeof(descriptor_input_attachment_writes_info) / - sizeof(descriptor_input_attachment_writes_info[0]), - descriptor_input_attachment_writes_info, - 0, - NULL); + m_rhi->updateDescriptorSets(sizeof(descriptor_input_attachment_writes_info) / + sizeof(descriptor_input_attachment_writes_info[0]), + descriptor_input_attachment_writes_info, + 0, + NULL); } } } @@ -1608,359 +1497,321 @@ namespace Piccolo { for (auto i : m_emitter_tick_indices) { - VkCommandBufferBeginInfo cmdBufInfo {}; - cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + RHICommandBufferBeginInfo cmdBufInfo {}; + cmdBufInfo.sType = RHI_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; // particle compute pass - if (VK_SUCCESS != vkBeginCommandBuffer(m_compute_command_buffer, &cmdBufInfo)) + if (RHI_SUCCESS != m_rhi->beginCommandBuffer(m_compute_command_buffer, &cmdBufInfo)) { throw std::runtime_error("begin command buffer"); } - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT compute_label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Particle compute", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_compute_command_buffer, &compute_label_info); + float color[4] = {1.0f, 1.0f, 1.0f, 1.0f}; + m_rhi->pushEvent(m_compute_command_buffer, "Particle compute", color); + m_rhi->pushEvent(m_compute_command_buffer, "Particle Kickoff", color); - VkDebugUtilsLabelEXT kickoff_label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Particle Kickoff", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_compute_command_buffer, &kickoff_label_info); - } + m_rhi->cmdBindPipelinePFN(m_compute_command_buffer, RHI_PIPELINE_BIND_POINT_COMPUTE, m_kickoff_pipeline); + RHIDescriptorSet* descriptorsets[2] = {m_descriptor_infos[i * 3].descriptor_set, + m_descriptor_infos[i * 3 + 1].descriptor_set}; + m_rhi->cmdBindDescriptorSetsPFN(m_compute_command_buffer, + RHI_PIPELINE_BIND_POINT_COMPUTE, + m_render_pipelines[0].layout, + 0, + 2, + descriptorsets, + 0, + 0); - vkCmdBindPipeline(m_compute_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, m_kickoff_pipeline); - VkDescriptorSet descriptorsets[2] = {m_descriptor_infos[i * 3].descriptor_set, - m_descriptor_infos[i * 3 + 1].descriptor_set}; - vkCmdBindDescriptorSets(m_compute_command_buffer, - VK_PIPELINE_BIND_POINT_COMPUTE, - m_render_pipelines[0].layout, - 0, - 2, - descriptorsets, - 0, - 0); - vkCmdDispatch(m_compute_command_buffer, 1, 1, 1); - - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - // end particle kickoff label - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_compute_command_buffer); - } - VkBufferMemoryBarrier bufferBarrier {}; - bufferBarrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; + m_rhi->cmdDispatch(m_compute_command_buffer, 1, 1, 1); + + m_rhi->popEvent(m_compute_command_buffer); // end particle kickoff label + + RHIBufferMemoryBarrier bufferBarrier {}; + bufferBarrier.sType = RHI_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; bufferBarrier.buffer = m_emitter_buffer_batches[i].m_counter_device_buffer; - bufferBarrier.size = VK_WHOLE_SIZE; - bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; - bufferBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - - vkCmdPipelineBarrier(m_compute_command_buffer, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 1, - &bufferBarrier, - 0, - nullptr); + bufferBarrier.size = RHI_WHOLE_SIZE; + bufferBarrier.srcAccessMask = RHI_ACCESS_SHADER_WRITE_BIT; + bufferBarrier.dstAccessMask = RHI_ACCESS_SHADER_READ_BIT; + bufferBarrier.srcQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + bufferBarrier.dstQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + + m_rhi->cmdPipelineBarrier(m_compute_command_buffer, + RHI_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 1, + &bufferBarrier, + 0, + nullptr); bufferBarrier.buffer = m_emitter_buffer_batches[i].m_indirect_dispatch_argument_buffer; - bufferBarrier.size = VK_WHOLE_SIZE; - bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; - bufferBarrier.dstAccessMask = VK_ACCESS_INDIRECT_COMMAND_READ_BIT | VK_ACCESS_SHADER_READ_BIT; - bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - - vkCmdPipelineBarrier(m_compute_command_buffer, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 1, - &bufferBarrier, - 0, - nullptr); + bufferBarrier.size = RHI_WHOLE_SIZE; + bufferBarrier.srcAccessMask = RHI_ACCESS_SHADER_WRITE_BIT; + bufferBarrier.dstAccessMask = RHI_ACCESS_INDIRECT_COMMAND_READ_BIT | RHI_ACCESS_SHADER_READ_BIT; + bufferBarrier.srcQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + bufferBarrier.dstQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Particle Emit", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_compute_command_buffer, &label_info); - } + m_rhi->cmdPipelineBarrier(m_compute_command_buffer, + RHI_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 1, + &bufferBarrier, + 0, + nullptr); - vkCmdBindPipeline(m_compute_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, m_emit_pipeline); - vkCmdDispatchIndirect(m_compute_command_buffer, - m_emitter_buffer_batches[i].m_indirect_dispatch_argument_buffer, - s_argument_offset_emit); + m_rhi->pushEvent(m_compute_command_buffer, "Particle Emit", color); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - // end particle emit label - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_compute_command_buffer); - } + m_rhi->cmdBindPipelinePFN(m_compute_command_buffer, RHI_PIPELINE_BIND_POINT_COMPUTE, m_emit_pipeline); + + m_rhi->cmdDispatchIndirect(m_compute_command_buffer, + m_emitter_buffer_batches[i].m_indirect_dispatch_argument_buffer, + s_argument_offset_emit); + + m_rhi->popEvent(m_compute_command_buffer); // end particle emit label bufferBarrier.buffer = m_emitter_buffer_batches[i].m_position_device_buffer; - bufferBarrier.size = VK_WHOLE_SIZE; - bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; - bufferBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - - vkCmdPipelineBarrier(m_compute_command_buffer, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 1, - &bufferBarrier, - 0, - nullptr); + bufferBarrier.size = RHI_WHOLE_SIZE; + bufferBarrier.srcAccessMask = RHI_ACCESS_SHADER_WRITE_BIT; + bufferBarrier.dstAccessMask = RHI_ACCESS_SHADER_READ_BIT; + bufferBarrier.srcQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + bufferBarrier.dstQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + + m_rhi->cmdPipelineBarrier(m_compute_command_buffer, + RHI_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 1, + &bufferBarrier, + 0, + nullptr); bufferBarrier.buffer = m_emitter_buffer_batches[i].m_position_render_buffer; - bufferBarrier.size = VK_WHOLE_SIZE; - bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; - bufferBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - - vkCmdPipelineBarrier(m_compute_command_buffer, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 1, - &bufferBarrier, - 0, - nullptr); + bufferBarrier.size = RHI_WHOLE_SIZE; + bufferBarrier.srcAccessMask = RHI_ACCESS_SHADER_WRITE_BIT; + bufferBarrier.dstAccessMask = RHI_ACCESS_SHADER_READ_BIT; + bufferBarrier.srcQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + bufferBarrier.dstQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + + m_rhi->cmdPipelineBarrier(m_compute_command_buffer, + RHI_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 1, + &bufferBarrier, + 0, + nullptr); bufferBarrier.buffer = m_emitter_buffer_batches[i].m_counter_device_buffer; - bufferBarrier.size = VK_WHOLE_SIZE; - bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; - bufferBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - - vkCmdPipelineBarrier(m_compute_command_buffer, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 1, - &bufferBarrier, - 0, - nullptr); + bufferBarrier.size = RHI_WHOLE_SIZE; + bufferBarrier.srcAccessMask = RHI_ACCESS_SHADER_WRITE_BIT; + bufferBarrier.dstAccessMask = RHI_ACCESS_SHADER_READ_BIT; + bufferBarrier.srcQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + bufferBarrier.dstQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + + m_rhi->cmdPipelineBarrier(m_compute_command_buffer, + RHI_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 1, + &bufferBarrier, + 0, + nullptr); bufferBarrier.buffer = m_emitter_buffer_batches[i].m_alive_list_buffer; - bufferBarrier.size = VK_WHOLE_SIZE; - bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; - bufferBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - - vkCmdPipelineBarrier(m_compute_command_buffer, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 1, - &bufferBarrier, - 0, - nullptr); + bufferBarrier.size = RHI_WHOLE_SIZE; + bufferBarrier.srcAccessMask = RHI_ACCESS_SHADER_WRITE_BIT; + bufferBarrier.dstAccessMask = RHI_ACCESS_SHADER_READ_BIT; + bufferBarrier.srcQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + bufferBarrier.dstQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + + m_rhi->cmdPipelineBarrier(m_compute_command_buffer, + RHI_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 1, + &bufferBarrier, + 0, + nullptr); bufferBarrier.buffer = m_emitter_buffer_batches[i].m_dead_list_buffer; - bufferBarrier.size = VK_WHOLE_SIZE; - bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; - bufferBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - - vkCmdPipelineBarrier(m_compute_command_buffer, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 1, - &bufferBarrier, - 0, - nullptr); + bufferBarrier.size = RHI_WHOLE_SIZE; + bufferBarrier.srcAccessMask = RHI_ACCESS_SHADER_WRITE_BIT; + bufferBarrier.dstAccessMask = RHI_ACCESS_SHADER_READ_BIT; + bufferBarrier.srcQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + bufferBarrier.dstQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + + m_rhi->cmdPipelineBarrier(m_compute_command_buffer, + RHI_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 1, + &bufferBarrier, + 0, + nullptr); bufferBarrier.buffer = m_emitter_buffer_batches[i].m_alive_list_next_buffer; - bufferBarrier.size = VK_WHOLE_SIZE; - bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; - bufferBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - - vkCmdPipelineBarrier(m_compute_command_buffer, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 1, - &bufferBarrier, - 0, - nullptr); - - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Particle Simulate", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_compute_command_buffer, &label_info); - } - - vkCmdBindPipeline(m_compute_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, m_simulate_pipeline); - vkCmdDispatchIndirect(m_compute_command_buffer, - m_emitter_buffer_batches[i].m_indirect_dispatch_argument_buffer, - s_argument_offset_simulate); - - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - // end particle simulate label - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_compute_command_buffer); - } - - if (VK_SUCCESS != vkEndCommandBuffer(m_compute_command_buffer)) + bufferBarrier.size = RHI_WHOLE_SIZE; + bufferBarrier.srcAccessMask = RHI_ACCESS_SHADER_WRITE_BIT; + bufferBarrier.dstAccessMask = RHI_ACCESS_SHADER_READ_BIT; + bufferBarrier.srcQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + bufferBarrier.dstQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + + m_rhi->cmdPipelineBarrier(m_compute_command_buffer, + RHI_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 1, + &bufferBarrier, + 0, + nullptr); + + m_rhi->pushEvent(m_compute_command_buffer, "Particle Simulate", color); + + m_rhi->cmdBindPipelinePFN(m_compute_command_buffer, RHI_PIPELINE_BIND_POINT_COMPUTE, m_simulate_pipeline); + m_rhi->cmdDispatchIndirect(m_compute_command_buffer, + m_emitter_buffer_batches[i].m_indirect_dispatch_argument_buffer, + s_argument_offset_simulate); + + m_rhi->popEvent(m_compute_command_buffer); // end particle simulate label + + if (RHI_SUCCESS != m_rhi->endCommandBuffer(m_compute_command_buffer)) { throw std::runtime_error("end command buffer"); } - vkResetFences(m_vulkan_rhi->m_device, 1, &m_fence); - VkSubmitInfo computeSubmitInfo {}; - computeSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + m_rhi->resetFencesPFN(1, &m_fence); + + RHISubmitInfo computeSubmitInfo {}; + computeSubmitInfo.sType = RHI_STRUCTURE_TYPE_SUBMIT_INFO; computeSubmitInfo.pWaitDstStageMask = 0; computeSubmitInfo.commandBufferCount = 1; computeSubmitInfo.pCommandBuffers = &m_compute_command_buffer; - if (VK_SUCCESS != vkQueueSubmit(m_vulkan_rhi->m_compute_queue, 1, &computeSubmitInfo, m_fence)) + + if (RHI_SUCCESS != m_rhi->queueSubmit(m_rhi->getComputeQueue(), 1, &computeSubmitInfo, m_fence)) { throw std::runtime_error("compute queue submit"); } - if (VK_SUCCESS != vkWaitForFences(m_vulkan_rhi->m_device, 1, &m_fence, VK_TRUE, UINT64_MAX)) + if (RHI_SUCCESS != m_rhi->waitForFencesPFN(1, &m_fence, RHI_TRUE, UINT64_MAX)) { throw std::runtime_error("wait for fence"); } - if (VK_SUCCESS != vkBeginCommandBuffer(m_compute_command_buffer, &cmdBufInfo)) + if (RHI_SUCCESS != m_rhi->beginCommandBuffer(m_compute_command_buffer, &cmdBufInfo)) { throw std::runtime_error("begin command buffer"); } - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = {VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, - NULL, - "Copy Particle Counter Buffer", - {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_compute_command_buffer, &label_info); - } + m_rhi->pushEvent(m_compute_command_buffer, "Copy Particle Counter Buffer", color); // Barrier to ensure that shader writes are finished before buffer is read back from GPU - bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; - bufferBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; + bufferBarrier.srcAccessMask = RHI_ACCESS_SHADER_WRITE_BIT; + bufferBarrier.dstAccessMask = RHI_ACCESS_TRANSFER_READ_BIT; bufferBarrier.buffer = m_emitter_buffer_batches[i].m_counter_device_buffer; - bufferBarrier.size = VK_WHOLE_SIZE; - bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - - vkCmdPipelineBarrier(m_compute_command_buffer, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - VK_PIPELINE_STAGE_TRANSFER_BIT, - 0, - 0, - nullptr, - 1, - &bufferBarrier, - 0, - nullptr); + bufferBarrier.size = RHI_WHOLE_SIZE; + bufferBarrier.srcQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + bufferBarrier.dstQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + + m_rhi->cmdPipelineBarrier(m_compute_command_buffer, + RHI_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + RHI_PIPELINE_STAGE_TRANSFER_BIT, + 0, + 0, + nullptr, + 1, + &bufferBarrier, + 0, + nullptr); // Read back to host visible buffer - VkBufferCopy copyRegion = {}; - copyRegion.size = sizeof(ParticleCounter); - vkCmdCopyBuffer(m_compute_command_buffer, - m_emitter_buffer_batches[i].m_counter_device_buffer, - m_emitter_buffer_batches[i].m_counter_host_buffer, - 1, - ©Region); - // Barrier to ensure that buffer copy is finished before host reading from it - bufferBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - bufferBarrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT; - bufferBarrier.buffer = m_emitter_buffer_batches[i].m_counter_host_buffer; - bufferBarrier.size = VK_WHOLE_SIZE; - bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - - vkCmdPipelineBarrier(m_compute_command_buffer, - VK_PIPELINE_STAGE_TRANSFER_BIT, - VK_PIPELINE_STAGE_HOST_BIT, - 0, - 0, - nullptr, - 1, - &bufferBarrier, - 0, - nullptr); + RHIBufferCopy copyRegion {}; + copyRegion.srcOffset = 0; + copyRegion.dstOffset = 0; + copyRegion.size = sizeof(ParticleCounter); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - // end particle counter copy label - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_compute_command_buffer); - // end particle compute label - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_compute_command_buffer); - } + m_rhi->cmdCopyBuffer(m_compute_command_buffer, + m_emitter_buffer_batches[i].m_counter_device_buffer, + m_emitter_buffer_batches[i].m_counter_host_buffer, + 1, + ©Region); - if (VK_SUCCESS != vkEndCommandBuffer(m_compute_command_buffer)) + // Barrier to ensure that buffer copy is finished before host reading from it + bufferBarrier.srcAccessMask = RHI_ACCESS_TRANSFER_WRITE_BIT; + bufferBarrier.dstAccessMask = RHI_ACCESS_HOST_READ_BIT; + bufferBarrier.buffer = m_emitter_buffer_batches[i].m_counter_host_buffer; + bufferBarrier.size = RHI_WHOLE_SIZE; + bufferBarrier.srcQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + bufferBarrier.dstQueueFamilyIndex = RHI_QUEUE_FAMILY_IGNORED; + + m_rhi->cmdPipelineBarrier(m_compute_command_buffer, + RHI_PIPELINE_STAGE_TRANSFER_BIT, + RHI_PIPELINE_STAGE_HOST_BIT, + 0, + 0, + nullptr, + 1, + &bufferBarrier, + 0, + nullptr); + + m_rhi->popEvent(m_compute_command_buffer); // end particle counter copy label + + m_rhi->popEvent(m_compute_command_buffer); // end particle compute label + + if (RHI_SUCCESS != m_rhi->endCommandBuffer(m_compute_command_buffer)) { throw std::runtime_error("end command buffer"); } // Submit compute work - vkResetFences(m_vulkan_rhi->m_device, 1, &m_fence); + m_rhi->resetFencesPFN(1, &m_fence); computeSubmitInfo = {}; - const VkPipelineStageFlags waitStageMask = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; - computeSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + const VkPipelineStageFlags waitStageMask = RHI_PIPELINE_STAGE_COMPUTE_SHADER_BIT; + computeSubmitInfo.sType = RHI_STRUCTURE_TYPE_SUBMIT_INFO; computeSubmitInfo.pWaitDstStageMask = &waitStageMask; computeSubmitInfo.commandBufferCount = 1; computeSubmitInfo.pCommandBuffers = &m_compute_command_buffer; - if (VK_SUCCESS != vkQueueSubmit(m_vulkan_rhi->m_compute_queue, 1, &computeSubmitInfo, m_fence)) + + if (RHI_SUCCESS != m_rhi->queueSubmit(m_rhi->getComputeQueue(), 1, &computeSubmitInfo, m_fence)) { throw std::runtime_error("compute queue submit"); } - if (VK_SUCCESS != vkWaitForFences(m_vulkan_rhi->m_device, 1, &m_fence, VK_TRUE, UINT64_MAX)) + if (RHI_SUCCESS != m_rhi->waitForFencesPFN(1, &m_fence, RHI_TRUE, UINT64_MAX)) { throw std::runtime_error("wait for fence"); } - vkQueueWaitIdle(m_vulkan_rhi->m_compute_queue); + m_rhi->queueWaitIdle(m_rhi->getComputeQueue()); // Make device writes visible to the host void* mapped; - vkMapMemory(m_vulkan_rhi->m_device, - m_emitter_buffer_batches[i].m_counter_host_memory, - 0, - VK_WHOLE_SIZE, - 0, - &mapped); - VkMappedMemoryRange mappedRange {}; - mappedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; - mappedRange.memory = m_emitter_buffer_batches[i].m_counter_host_memory; - mappedRange.offset = 0; - mappedRange.size = VK_WHOLE_SIZE; - vkInvalidateMappedMemoryRanges(m_vulkan_rhi->m_device, 1, &mappedRange); + m_rhi->mapMemory(m_emitter_buffer_batches[i].m_counter_host_memory, 0, RHI_WHOLE_SIZE, 0, &mapped); + + m_rhi->invalidateMappedMemoryRanges( + nullptr, m_emitter_buffer_batches[i].m_counter_host_memory, 0, RHI_WHOLE_SIZE); // Copy to output ParticleCounter counterNext {}; memcpy(&counterNext, mapped, sizeof(ParticleCounter)); - vkUnmapMemory(m_vulkan_rhi->m_device, m_emitter_buffer_batches[i].m_counter_host_memory); + m_rhi->unmapMemory(m_emitter_buffer_batches[i].m_counter_host_memory); if constexpr (s_verbose_particle_alive_info) LOG_INFO("{} {} {} {}", @@ -1976,31 +1827,26 @@ namespace Piccolo void ParticlePass::prepareUniformBuffer() { - VkDeviceMemory d_mem; - VulkanUtil::createBuffer(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - sizeof(m_particle_collision_perframe_storage_buffer_object), - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - m_scene_uniform_buffer, - d_mem); - if (VK_SUCCESS != - vkMapMemory(m_vulkan_rhi->m_device, d_mem, 0, VK_WHOLE_SIZE, 0, &m_scene_uniform_buffer_mapped)) + RHIDeviceMemory* d_mem; + m_rhi->createBuffer(sizeof(m_particle_collision_perframe_storage_buffer_object), + RHI_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + m_scene_uniform_buffer, + d_mem); + + if (RHI_SUCCESS != m_rhi->mapMemory(d_mem, 0, RHI_WHOLE_SIZE, 0, &m_scene_uniform_buffer_mapped)) { throw std::runtime_error("map billboard uniform buffer"); } - VkDeviceMemory d_uniformdmemory; - VulkanUtil::createBufferAndInitialize(m_vulkan_rhi->m_device, - m_vulkan_rhi->m_physical_device, - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | - VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - &m_compute_uniform_buffer, - &d_uniformdmemory, - sizeof(m_ubo)); - if (VK_SUCCESS != - vkMapMemory( - m_vulkan_rhi->m_device, d_uniformdmemory, 0, VK_WHOLE_SIZE, 0, &m_particle_compute_buffer_mapped)) + RHIDeviceMemory* d_uniformdmemory; + + m_rhi->createBufferAndInitialize(RHI_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + m_compute_uniform_buffer, + d_uniformdmemory, + sizeof(m_ubo)); + + if (RHI_SUCCESS != m_rhi->mapMemory(d_uniformdmemory, 0, RHI_WHOLE_SIZE, 0, &m_particle_compute_buffer_mapped)) { throw std::runtime_error("map buffer"); } @@ -2017,31 +1863,29 @@ namespace Piccolo float rnd0 = m_random_engine.uniformDistribution(0, 1000) * 0.001f; float rnd1 = m_random_engine.uniformDistribution(0, 1000) * 0.001f; float rnd2 = m_random_engine.uniformDistribution(0, 1000) * 0.001f; - m_ubo.pack = Vector4 {rnd0, static_cast(m_vulkan_rhi->m_current_frame_index), rnd1, rnd2}; + m_ubo.pack = Vector4 {rnd0, static_cast(m_rhi->getCurrentFrameIndex()), rnd1, rnd2}; m_ubo.xemit_count = 100000; - m_viewport_params = m_vulkan_rhi->m_viewport; + m_viewport_params = *m_rhi->getSwapchainInfo().viewport; m_ubo.viewport.x = m_viewport_params.x; m_ubo.viewport.y = m_viewport_params.y; m_ubo.viewport.z = m_viewport_params.width; m_ubo.viewport.w = m_viewport_params.height; - m_ubo.extent.x = m_vulkan_rhi->m_scissor.extent.width; - m_ubo.extent.y = m_vulkan_rhi->m_scissor.extent.height; + m_ubo.extent.x = m_rhi->getSwapchainInfo().scissor->extent.width; + m_ubo.extent.y = m_rhi->getSwapchainInfo().scissor->extent.height; memcpy(m_particle_compute_buffer_mapped, &m_ubo, sizeof(m_ubo)); { - VkDeviceMemory d_mem; - VulkanUtil::createBuffer(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - sizeof(m_particlebillboard_perframe_storage_buffer_object), - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - m_particle_billboard_uniform_buffer, - d_mem); - if (VK_SUCCESS != - vkMapMemory( - m_vulkan_rhi->m_device, d_mem, 0, VK_WHOLE_SIZE, 0, &m_particle_billboard_uniform_buffer_mapped)) + RHIDeviceMemory* d_mem; + m_rhi->createBuffer(sizeof(m_particlebillboard_perframe_storage_buffer_object), + RHI_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + m_particle_billboard_uniform_buffer, + d_mem); + + if (RHI_SUCCESS != + m_rhi->mapMemory(d_mem, 0, RHI_WHOLE_SIZE, 0, &m_particle_billboard_uniform_buffer_mapped)) { throw std::runtime_error("map billboard uniform buffer"); } @@ -2070,14 +1914,14 @@ namespace Piccolo float rnd0 = m_random_engine.uniformDistribution(0, 1000) * 0.001f; float rnd1 = m_random_engine.uniformDistribution(0, 1000) * 0.001f; float rnd2 = m_random_engine.uniformDistribution(0, 1000) * 0.001f; - m_ubo.pack = Vector4 {rnd0, rnd1, rnd2, static_cast(m_vulkan_rhi->m_current_frame_index)}; + m_ubo.pack = Vector4 {rnd0, rnd1, rnd2, static_cast(m_rhi->getCurrentFrameIndex())}; - m_ubo.viewport.x = m_vulkan_rhi->m_viewport.x; - m_ubo.viewport.y = m_vulkan_rhi->m_viewport.y; - m_ubo.viewport.z = m_vulkan_rhi->m_viewport.width; - m_ubo.viewport.w = m_vulkan_rhi->m_viewport.height; - m_ubo.extent.x = m_vulkan_rhi->m_scissor.extent.width; - m_ubo.extent.y = m_vulkan_rhi->m_scissor.extent.height; + m_ubo.viewport.x = m_rhi->getSwapchainInfo().viewport->x; + m_ubo.viewport.y = m_rhi->getSwapchainInfo().viewport->y; + m_ubo.viewport.z = m_rhi->getSwapchainInfo().viewport->width; + m_ubo.viewport.w = m_rhi->getSwapchainInfo().viewport->height; + m_ubo.extent.x = m_rhi->getSwapchainInfo().scissor->extent.width; + m_ubo.extent.y = m_rhi->getSwapchainInfo().scissor->extent.height; m_ubo.extent.z = g_runtime_global_context.m_render_system->getRenderCamera()->m_znear; m_ubo.extent.w = g_runtime_global_context.m_render_system->getRenderCamera()->m_zfar; @@ -2101,24 +1945,24 @@ namespace Piccolo &m_particlebillboard_perframe_storage_buffer_object, sizeof(m_particlebillboard_perframe_storage_buffer_object)); - m_viewport_params = m_vulkan_rhi->m_viewport; + m_viewport_params = *m_rhi->getSwapchainInfo().viewport; updateUniformBuffer(); updateEmitterTransform(); } } - void ParticlePass::setDepthAndNormalImage(VkImage depth_image, VkImage normal_image) + void ParticlePass::setDepthAndNormalImage(RHIImage* depth_image, RHIImage* normal_image) { m_src_depth_image = depth_image; m_src_normal_image = normal_image; } - void ParticlePass::setRenderCommandBufferHandle(VkCommandBuffer command_buffer) + void ParticlePass::setRenderCommandBufferHandle(RHICommandBuffer* command_buffer) { m_render_command_buffer = command_buffer; } - void ParticlePass::setRenderPassHandle(VkRenderPass render_pass) { m_render_pass = render_pass; } + void ParticlePass::setRenderPassHandle(RHIRenderPass* render_pass) { m_render_pass = render_pass; } void ParticlePass::setTickIndices(const std::vector& tick_indices) { diff --git a/engine/source/runtime/function/render/passes/particle_pass.h b/engine/source/runtime/function/render/passes/particle_pass.h index 04fa64b53..706dc4e26 100644 --- a/engine/source/runtime/function/render/passes/particle_pass.h +++ b/engine/source/runtime/function/render/passes/particle_pass.h @@ -15,35 +15,35 @@ namespace Piccolo class ParticleEmitterBufferBatch { public: - VkBuffer m_particle_storage_buffer; - VkBuffer m_position_render_buffer; - VkBuffer m_position_device_buffer; - VkBuffer m_position_host_buffer; - VkBuffer m_counter_device_buffer; - VkBuffer m_counter_host_buffer; - VkBuffer m_indirect_dispatch_argument_buffer; - VkBuffer m_alive_list_buffer; - VkBuffer m_alive_list_next_buffer; - VkBuffer m_dead_list_buffer; - VkBuffer m_particle_component_res_buffer; - - VkDeviceMemory m_counter_host_memory; - VkDeviceMemory m_position_host_memory; - VkDeviceMemory m_position_device_memory; - VkDeviceMemory m_counter_device_memory; - VkDeviceMemory m_indirect_dispatch_argument_memory; - VkDeviceMemory m_alive_list_memory; - VkDeviceMemory m_alive_list_next_memory; - VkDeviceMemory m_dead_list_memory; - VkDeviceMemory m_particle_component_res_memory; - VkDeviceMemory m_position_render_memory; + RHIBuffer* m_particle_storage_buffer = nullptr; + RHIBuffer* m_position_render_buffer = nullptr; + RHIBuffer* m_position_device_buffer = nullptr; + RHIBuffer* m_position_host_buffer = nullptr; + RHIBuffer* m_counter_device_buffer = nullptr; + RHIBuffer* m_counter_host_buffer = nullptr; + RHIBuffer* m_indirect_dispatch_argument_buffer = nullptr; + RHIBuffer* m_alive_list_buffer = nullptr; + RHIBuffer* m_alive_list_next_buffer = nullptr; + RHIBuffer* m_dead_list_buffer = nullptr; + RHIBuffer* m_particle_component_res_buffer = nullptr; + + RHIDeviceMemory* m_counter_host_memory = nullptr; + RHIDeviceMemory* m_position_host_memory = nullptr; + RHIDeviceMemory* m_position_device_memory = nullptr; + RHIDeviceMemory* m_counter_device_memory = nullptr; + RHIDeviceMemory* m_indirect_dispatch_argument_memory = nullptr; + RHIDeviceMemory* m_alive_list_memory = nullptr; + RHIDeviceMemory* m_alive_list_next_memory = nullptr; + RHIDeviceMemory* m_dead_list_memory = nullptr; + RHIDeviceMemory* m_particle_component_res_memory = nullptr; + RHIDeviceMemory* m_position_render_memory = nullptr; void* m_emitter_desc_mapped {nullptr}; ParticleEmitterDesc m_emitter_desc; uint32_t m_num_particle {0}; - void freeUpBatch(VkDevice device); + void freeUpBatch(std::shared_ptr rhi); }; class ParticlePass : public RenderPass @@ -59,13 +59,13 @@ namespace Piccolo void copyNormalAndDepthImage(); - void setDepthAndNormalImage(VkImage depth_image, VkImage normal_image); + void setDepthAndNormalImage(RHIImage* depth_image, RHIImage* normal_image); void setupParticlePass(); - void setRenderCommandBufferHandle(VkCommandBuffer command_buffer); + void setRenderCommandBufferHandle(RHICommandBuffer* command_buffer); - void setRenderPassHandle(VkRenderPass render_pass); + void setRenderPassHandle(RHIRenderPass* render_pass); void updateAfterFramebufferRecreate(); @@ -98,43 +98,43 @@ namespace Piccolo void setupParticleDescriptorSet(); - VkPipeline m_kickoff_pipeline; - VkPipeline m_emit_pipeline; - VkPipeline m_simulate_pipeline; + RHIPipeline* m_kickoff_pipeline = nullptr; + RHIPipeline* m_emit_pipeline = nullptr; + RHIPipeline* m_simulate_pipeline = nullptr; - VkCommandBuffer m_compute_command_buffer; - VkCommandBuffer m_render_command_buffer; - VkCommandBuffer m_copy_command_buffer; + RHICommandBuffer* m_compute_command_buffer = nullptr; + RHICommandBuffer* m_render_command_buffer = nullptr; + RHICommandBuffer* m_copy_command_buffer = nullptr; - VkBuffer m_scene_uniform_buffer; - VkBuffer m_compute_uniform_buffer; - VkBuffer m_particle_billboard_uniform_buffer; + RHIBuffer* m_scene_uniform_buffer = nullptr; + RHIBuffer* m_compute_uniform_buffer = nullptr; + RHIBuffer* m_particle_billboard_uniform_buffer = nullptr; - VkViewport m_viewport_params; + RHIViewport m_viewport_params; - VkFence m_fence; + RHIFence* m_fence = nullptr; - VkImage m_src_depth_image; - VkImage m_dst_normal_image; - VkImage m_src_normal_image; - VkImage m_dst_depth_image; - VkImageView m_src_depth_image_view; - VkImageView m_src_normal_image_view; - VkDeviceMemory m_dst_normal_image_memory; - VkDeviceMemory m_dst_depth_image_memory; + RHIImage* m_src_depth_image = nullptr; + RHIImage* m_dst_normal_image = nullptr; + RHIImage* m_src_normal_image = nullptr; + RHIImage* m_dst_depth_image = nullptr; + RHIImageView* m_src_depth_image_view = nullptr; + RHIImageView* m_src_normal_image_view = nullptr; + RHIDeviceMemory* m_dst_normal_image_memory = nullptr; + RHIDeviceMemory* m_dst_depth_image_memory = nullptr; /* * particle rendering */ - VkImage m_particle_billboard_texture_image; - VkImageView m_particle_billboard_texture_image_view; + RHIImage* m_particle_billboard_texture_image = nullptr; + RHIImageView* m_particle_billboard_texture_image_view = nullptr; VmaAllocation m_particle_billboard_texture_vma_allocation; - VkImage m_piccolo_logo_texture_image; - VkImageView m_piccolo_logo_texture_image_view; + RHIImage* m_piccolo_logo_texture_image = nullptr; + RHIImageView* m_piccolo_logo_texture_image_view = nullptr; VmaAllocation m_piccolo_logo_texture_vma_allocation; - VkRenderPass m_render_pass; + RHIRenderPass* m_render_pass = nullptr; ParticleBillboardPerframeStorageBufferObject m_particlebillboard_perframe_storage_buffer_object; ParticleCollisionPerframeStorageBufferObject m_particle_collision_perframe_storage_buffer_object; diff --git a/engine/source/runtime/function/render/passes/pick_pass.cpp b/engine/source/runtime/function/render/passes/pick_pass.cpp index f8b6c2b39..90ad4a1a6 100644 --- a/engine/source/runtime/function/render/passes/pick_pass.cpp +++ b/engine/source/runtime/function/render/passes/pick_pass.cpp @@ -1,16 +1,15 @@ +#include "runtime/function/render/passes/pick_pass.h" + #include "runtime/function/render/render_mesh.h" -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" #include "runtime/function/render/render_helper.h" -#include "runtime/function/render/passes/pick_pass.h" - #include #include -#define STB_IMAGE_WRITE_IMPLEMENTATION -#include + #include #include @@ -39,77 +38,75 @@ namespace Piccolo { _mesh_inefficient_pick_perframe_storage_buffer_object.proj_view_matrix = vulkan_resource->m_mesh_inefficient_pick_perframe_storage_buffer_object.proj_view_matrix; - _mesh_inefficient_pick_perframe_storage_buffer_object.rt_width = m_vulkan_rhi->m_swapchain_extent.width; - _mesh_inefficient_pick_perframe_storage_buffer_object.rt_height = m_vulkan_rhi->m_swapchain_extent.height; + _mesh_inefficient_pick_perframe_storage_buffer_object.rt_width = m_rhi->getSwapchainInfo().extent.width; + _mesh_inefficient_pick_perframe_storage_buffer_object.rt_height = m_rhi->getSwapchainInfo().extent.height; } } void PickPass::draw() {} void PickPass::setupAttachments() { m_framebuffer.attachments.resize(1); - m_framebuffer.attachments[0].format = VK_FORMAT_R32_UINT; - - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - m_vulkan_rhi->m_swapchain_extent.width, - m_vulkan_rhi->m_swapchain_extent.height, - m_framebuffer.attachments[0].format, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_framebuffer.attachments[0].image, - m_framebuffer.attachments[0].mem, - 0, - 1, - 1); - m_framebuffer.attachments[0].view = VulkanUtil::createImageView(m_vulkan_rhi->m_device, - m_framebuffer.attachments[0].image, - m_framebuffer.attachments[0].format, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_VIEW_TYPE_2D, - 1, - 1); + m_framebuffer.attachments[0].format = RHI_FORMAT_R32_UINT; + + m_rhi->createImage(m_rhi->getSwapchainInfo().extent.width, + m_rhi->getSwapchainInfo().extent.height, + m_framebuffer.attachments[0].format, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | RHI_IMAGE_USAGE_TRANSFER_SRC_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_framebuffer.attachments[0].image, + m_framebuffer.attachments[0].mem, + 0, + 1, + 1); + m_rhi->createImageView(m_framebuffer.attachments[0].image, + m_framebuffer.attachments[0].format, + RHI_IMAGE_ASPECT_COLOR_BIT, + RHI_IMAGE_VIEW_TYPE_2D, + 1, + 1, + m_framebuffer.attachments[0].view); } void PickPass::setupRenderPass() { - VkAttachmentDescription color_attachment_description {}; + RHIAttachmentDescription color_attachment_description {}; color_attachment_description.format = m_framebuffer.attachments[0].format; - color_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - color_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - color_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_STORE; - color_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - color_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - color_attachment_description.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - color_attachment_description.finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - - VkAttachmentDescription depth_attachment_description {}; - depth_attachment_description.format = m_vulkan_rhi->m_depth_image_format; - depth_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - depth_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - depth_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - depth_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - depth_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - depth_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - depth_attachment_description.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - - VkAttachmentDescription attachments[2] = {color_attachment_description, depth_attachment_description}; - - VkAttachmentReference color_attachment_reference {}; + color_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + color_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + color_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_STORE; + color_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + color_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + color_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + color_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + + RHIAttachmentDescription depth_attachment_description {}; + depth_attachment_description.format = m_rhi->getDepthImageInfo().depth_image_format; + depth_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + depth_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + depth_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + depth_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + depth_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + depth_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + depth_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + + RHIAttachmentDescription attachments[2] = {color_attachment_description, depth_attachment_description}; + + RHIAttachmentReference color_attachment_reference {}; color_attachment_reference.attachment = 0; - color_attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + color_attachment_reference.layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - VkAttachmentReference depth_attachment_reference {}; + RHIAttachmentReference depth_attachment_reference {}; depth_attachment_reference.attachment = 1; - depth_attachment_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + depth_attachment_reference.layout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - VkSubpassDescription subpass {}; - subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + RHISubpassDescription subpass {}; + subpass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &color_attachment_reference; subpass.pDepthStencilAttachment = &depth_attachment_reference; - VkRenderPassCreateInfo renderpass_create_info {}; - renderpass_create_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + RHIRenderPassCreateInfo renderpass_create_info {}; + renderpass_create_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; renderpass_create_info.attachmentCount = sizeof(attachments) / sizeof(attachments[0]); renderpass_create_info.pAttachments = attachments; renderpass_create_info.subpassCount = 1; @@ -117,27 +114,25 @@ namespace Piccolo renderpass_create_info.dependencyCount = 0; renderpass_create_info.pDependencies = NULL; - if (vkCreateRenderPass(m_vulkan_rhi->m_device, &renderpass_create_info, nullptr, &m_framebuffer.render_pass) != - VK_SUCCESS) + if (m_rhi->createRenderPass(&renderpass_create_info, m_framebuffer.render_pass) != RHI_SUCCESS) { throw std::runtime_error("create inefficient pick render pass"); } } void PickPass::setupFramebuffer() { - VkImageView attachments[2] = {m_framebuffer.attachments[0].view, m_vulkan_rhi->m_depth_image_view}; + RHIImageView* attachments[2] = {m_framebuffer.attachments[0].view, m_rhi->getDepthImageInfo().depth_image_view }; - VkFramebufferCreateInfo framebuffer_create_info {}; - framebuffer_create_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + RHIFramebufferCreateInfo framebuffer_create_info {}; + framebuffer_create_info.sType = RHI_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; framebuffer_create_info.renderPass = m_framebuffer.render_pass; framebuffer_create_info.attachmentCount = sizeof(attachments) / sizeof(attachments[0]); framebuffer_create_info.pAttachments = attachments; - framebuffer_create_info.width = m_vulkan_rhi->m_swapchain_extent.width; - framebuffer_create_info.height = m_vulkan_rhi->m_swapchain_extent.height; + framebuffer_create_info.width = m_rhi->getSwapchainInfo().extent.width; + framebuffer_create_info.height = m_rhi->getSwapchainInfo().extent.height; framebuffer_create_info.layers = 1; - if (vkCreateFramebuffer( - m_vulkan_rhi->m_device, &framebuffer_create_info, nullptr, &m_framebuffer.framebuffer) != VK_SUCCESS) + if (m_rhi->createFramebuffer(&framebuffer_create_info, m_framebuffer.framebuffer) != RHI_SUCCESS) { throw std::runtime_error("create inefficient pick framebuffer"); } @@ -146,40 +141,40 @@ namespace Piccolo { m_descriptor_infos.resize(1); - VkDescriptorSetLayoutBinding mesh_inefficient_pick_global_layout_bindings[3]; + RHIDescriptorSetLayoutBinding mesh_inefficient_pick_global_layout_bindings[3]; - VkDescriptorSetLayoutBinding& mesh_inefficient_pick_global_layout_perframe_storage_buffer_binding = + RHIDescriptorSetLayoutBinding& mesh_inefficient_pick_global_layout_perframe_storage_buffer_binding = mesh_inefficient_pick_global_layout_bindings[0]; mesh_inefficient_pick_global_layout_perframe_storage_buffer_binding.binding = 0; mesh_inefficient_pick_global_layout_perframe_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_inefficient_pick_global_layout_perframe_storage_buffer_binding.descriptorCount = 1; mesh_inefficient_pick_global_layout_perframe_storage_buffer_binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; mesh_inefficient_pick_global_layout_perframe_storage_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutBinding& mesh_inefficient_pick_global_layout_perdrawcall_storage_buffer_binding = + RHIDescriptorSetLayoutBinding& mesh_inefficient_pick_global_layout_perdrawcall_storage_buffer_binding = mesh_inefficient_pick_global_layout_bindings[1]; mesh_inefficient_pick_global_layout_perdrawcall_storage_buffer_binding.binding = 1; mesh_inefficient_pick_global_layout_perdrawcall_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_inefficient_pick_global_layout_perdrawcall_storage_buffer_binding.descriptorCount = 1; mesh_inefficient_pick_global_layout_perdrawcall_storage_buffer_binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; mesh_inefficient_pick_global_layout_perdrawcall_storage_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutBinding& + RHIDescriptorSetLayoutBinding& mesh_inefficient_pick_global_layout_perdrawcall_vertex_blending_storage_buffer_binding = mesh_inefficient_pick_global_layout_bindings[2]; mesh_inefficient_pick_global_layout_perdrawcall_vertex_blending_storage_buffer_binding.binding = 2; mesh_inefficient_pick_global_layout_perdrawcall_vertex_blending_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_inefficient_pick_global_layout_perdrawcall_vertex_blending_storage_buffer_binding.descriptorCount = 1; mesh_inefficient_pick_global_layout_perdrawcall_vertex_blending_storage_buffer_binding.stageFlags = - VK_SHADER_STAGE_VERTEX_BIT; + RHI_SHADER_STAGE_VERTEX_BIT; mesh_inefficient_pick_global_layout_perdrawcall_vertex_blending_storage_buffer_binding.pImmutableSamplers = NULL; - VkDescriptorSetLayoutCreateInfo mesh_inefficient_pick_global_layout_create_info; - mesh_inefficient_pick_global_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo mesh_inefficient_pick_global_layout_create_info; + mesh_inefficient_pick_global_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; mesh_inefficient_pick_global_layout_create_info.pNext = NULL; mesh_inefficient_pick_global_layout_create_info.flags = 0; mesh_inefficient_pick_global_layout_create_info.bindingCount = @@ -187,10 +182,8 @@ namespace Piccolo sizeof(mesh_inefficient_pick_global_layout_bindings[0])); mesh_inefficient_pick_global_layout_create_info.pBindings = mesh_inefficient_pick_global_layout_bindings; - if (VK_SUCCESS != vkCreateDescriptorSetLayout(m_vulkan_rhi->m_device, - &mesh_inefficient_pick_global_layout_create_info, - NULL, - &m_descriptor_infos[0].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&mesh_inefficient_pick_global_layout_create_info, m_descriptor_infos[0].layout)) + { throw std::runtime_error("create mesh inefficient pick global layout"); } @@ -199,93 +192,91 @@ namespace Piccolo { m_render_pipelines.resize(1); - VkDescriptorSetLayout descriptorset_layouts[] = {m_descriptor_infos[0].layout, _per_mesh_layout}; + RHIDescriptorSetLayout* descriptorset_layouts[] = {m_descriptor_infos[0].layout, _per_mesh_layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = sizeof(descriptorset_layouts) / sizeof(descriptorset_layouts[0]); pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout( - m_vulkan_rhi->m_device, &pipeline_layout_create_info, nullptr, &m_render_pipelines[0].layout) != - VK_SUCCESS) + if (m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[0].layout) != RHI_SUCCESS) { throw std::runtime_error("create mesh inefficient pick pipeline layout"); } - VkShaderModule vert_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, MESH_INEFFICIENT_PICK_VERT); - VkShaderModule frag_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, MESH_INEFFICIENT_PICK_FRAG); + RHIShader* vert_shader_module = + m_rhi->createShaderModule(MESH_INEFFICIENT_PICK_VERT); + RHIShader* frag_shader_module = + m_rhi->createShaderModule(MESH_INEFFICIENT_PICK_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; - auto vertex_binding_descriptions = MeshVertex::getBindingDescriptions(); - auto vertex_attribute_descriptions = MeshVertex::getAttributeDescriptions(); - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + auto vertex_binding_descriptions = MeshVertex::getBindingDescriptions(); + auto vertex_attribute_descriptions = MeshVertex::getAttributeDescriptions(); + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = 1; vertex_input_state_create_info.pVertexBindingDescriptions = &vertex_binding_descriptions[0]; vertex_input_state_create_info.vertexAttributeDescriptionCount = 1; vertex_input_state_create_info.pVertexAttributeDescriptions = &vertex_attribute_descriptions[0]; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_BACK_BIT; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_BACK_BIT; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_COUNTER_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; - - VkPipelineColorBlendAttachmentState color_blend_attachment_state {}; - color_blend_attachment_state.colorWriteMask = VK_COLOR_COMPONENT_R_BIT; - color_blend_attachment_state.blendEnable = VK_FALSE; - color_blend_attachment_state.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; + + RHIPipelineColorBlendAttachmentState color_blend_attachment_state {}; + color_blend_attachment_state.colorWriteMask = RHI_COLOR_COMPONENT_R_BIT; + color_blend_attachment_state.blendEnable = RHI_FALSE; + color_blend_attachment_state.srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachment_state.srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = 1; color_blend_state_create_info.pAttachments = &color_blend_attachment_state; color_blend_state_create_info.blendConstants[0] = 0.0f; @@ -293,22 +284,22 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_TRUE; - depth_stencil_create_info.depthWriteEnable = VK_TRUE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; - - VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_TRUE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; + + RHIDynamicState dynamic_states[] = { RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR}; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 2; dynamic_state_create_info.pDynamicStates = dynamic_states; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -321,36 +312,32 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[0].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = 0; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines( - m_vulkan_rhi->m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_render_pipelines[0].pipeline) != - VK_SUCCESS) + if (m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, 1, &pipelineInfo, m_render_pipelines[0].pipeline) != RHI_SUCCESS) { throw std::runtime_error("create mesh inefficient pick graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } void PickPass::setupDescriptorSet() { - VkDescriptorSetAllocateInfo mesh_inefficient_pick_global_descriptor_set_alloc_info; - mesh_inefficient_pick_global_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHIDescriptorSetAllocateInfo mesh_inefficient_pick_global_descriptor_set_alloc_info; + mesh_inefficient_pick_global_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; mesh_inefficient_pick_global_descriptor_set_alloc_info.pNext = NULL; - mesh_inefficient_pick_global_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + mesh_inefficient_pick_global_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); mesh_inefficient_pick_global_descriptor_set_alloc_info.descriptorSetCount = 1; mesh_inefficient_pick_global_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[0].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &mesh_inefficient_pick_global_descriptor_set_alloc_info, - &m_descriptor_infos[0].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&mesh_inefficient_pick_global_descriptor_set_alloc_info, m_descriptor_infos[0].descriptor_set)) { throw std::runtime_error("allocate mesh inefficient pick global descriptor set"); } - VkDescriptorBufferInfo mesh_inefficient_pick_perframe_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_inefficient_pick_perframe_storage_buffer_info = {}; // this offset plus dynamic_offset should not be greater than the size of // the buffer mesh_inefficient_pick_perframe_storage_buffer_info.offset = 0; @@ -360,7 +347,7 @@ namespace Piccolo mesh_inefficient_pick_perframe_storage_buffer_info.buffer = m_global_render_resource->_storage_buffer._global_upload_ringbuffer; - VkDescriptorBufferInfo mesh_inefficient_pick_perdrawcall_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_inefficient_pick_perdrawcall_storage_buffer_info = {}; mesh_inefficient_pick_perdrawcall_storage_buffer_info.offset = 0; mesh_inefficient_pick_perdrawcall_storage_buffer_info.range = sizeof(MeshInefficientPickPerdrawcallStorageBufferObject); @@ -369,7 +356,7 @@ namespace Piccolo assert(mesh_inefficient_pick_perdrawcall_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorBufferInfo mesh_inefficient_pick_perdrawcall_vertex_blending_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_inefficient_pick_perdrawcall_vertex_blending_storage_buffer_info = {}; mesh_inefficient_pick_perdrawcall_vertex_blending_storage_buffer_info.offset = 0; mesh_inefficient_pick_perdrawcall_vertex_blending_storage_buffer_info.range = sizeof(MeshInefficientPickPerdrawcallVertexBlendingStorageBufferObject); @@ -378,51 +365,50 @@ namespace Piccolo assert(mesh_inefficient_pick_perdrawcall_vertex_blending_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkWriteDescriptorSet mesh_descriptor_writes_info[3]; + RHIWriteDescriptorSet mesh_descriptor_writes_info[3]; - mesh_descriptor_writes_info[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + mesh_descriptor_writes_info[0].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_descriptor_writes_info[0].pNext = NULL; mesh_descriptor_writes_info[0].dstSet = m_descriptor_infos[0].descriptor_set; mesh_descriptor_writes_info[0].dstBinding = 0; mesh_descriptor_writes_info[0].dstArrayElement = 0; - mesh_descriptor_writes_info[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + mesh_descriptor_writes_info[0].descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_descriptor_writes_info[0].descriptorCount = 1; mesh_descriptor_writes_info[0].pBufferInfo = &mesh_inefficient_pick_perframe_storage_buffer_info; - mesh_descriptor_writes_info[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + mesh_descriptor_writes_info[1].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_descriptor_writes_info[1].pNext = NULL; mesh_descriptor_writes_info[1].dstSet = m_descriptor_infos[0].descriptor_set; mesh_descriptor_writes_info[1].dstBinding = 1; mesh_descriptor_writes_info[1].dstArrayElement = 0; - mesh_descriptor_writes_info[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + mesh_descriptor_writes_info[1].descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_descriptor_writes_info[1].descriptorCount = 1; mesh_descriptor_writes_info[1].pBufferInfo = &mesh_inefficient_pick_perdrawcall_storage_buffer_info; - mesh_descriptor_writes_info[2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + mesh_descriptor_writes_info[2].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_descriptor_writes_info[2].pNext = NULL; mesh_descriptor_writes_info[2].dstSet = m_descriptor_infos[0].descriptor_set; mesh_descriptor_writes_info[2].dstBinding = 2; mesh_descriptor_writes_info[2].dstArrayElement = 0; - mesh_descriptor_writes_info[2].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + mesh_descriptor_writes_info[2].descriptorType = RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_descriptor_writes_info[2].descriptorCount = 1; mesh_descriptor_writes_info[2].pBufferInfo = &mesh_inefficient_pick_perdrawcall_vertex_blending_storage_buffer_info; - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - sizeof(mesh_descriptor_writes_info) / sizeof(mesh_descriptor_writes_info[0]), - mesh_descriptor_writes_info, - 0, - NULL); + m_rhi->updateDescriptorSets(sizeof(mesh_descriptor_writes_info) / sizeof(mesh_descriptor_writes_info[0]), + mesh_descriptor_writes_info, + 0, + NULL); } void PickPass::recreateFramebuffer() { for (size_t i = 0; i < m_framebuffer.attachments.size(); i++) { - vkDestroyImage(m_vulkan_rhi->m_device, m_framebuffer.attachments[i].image, nullptr); - vkDestroyImageView(m_vulkan_rhi->m_device, m_framebuffer.attachments[i].view, nullptr); - vkFreeMemory(m_vulkan_rhi->m_device, m_framebuffer.attachments[i].mem, nullptr); + m_rhi->destroyImage(m_framebuffer.attachments[i].image); + m_rhi->destroyImageView(m_framebuffer.attachments[i].view); + m_rhi->freeMemory(m_framebuffer.attachments[i].mem); } - vkDestroyFramebuffer(m_vulkan_rhi->m_device, m_framebuffer.framebuffer, nullptr); + m_rhi->destroyFramebuffer(m_framebuffer.framebuffer); setupAttachments(); setupFramebuffer(); @@ -430,11 +416,11 @@ namespace Piccolo uint32_t PickPass::pick(const Vector2& picked_uv) { uint32_t pixel_x = - static_cast(picked_uv.x * m_vulkan_rhi->m_viewport.width + m_vulkan_rhi->m_viewport.x); + static_cast(picked_uv.x * m_rhi->getSwapchainInfo().viewport->width + m_rhi->getSwapchainInfo().viewport->x); uint32_t pixel_y = - static_cast(picked_uv.y * m_vulkan_rhi->m_viewport.height + m_vulkan_rhi->m_viewport.y); - uint32_t picked_pixel_index = m_vulkan_rhi->m_swapchain_extent.width * pixel_y + pixel_x; - if (pixel_x >= m_vulkan_rhi->m_swapchain_extent.width || pixel_y >= m_vulkan_rhi->m_swapchain_extent.height) + static_cast(picked_uv.y * m_rhi->getSwapchainInfo().viewport->height + m_rhi->getSwapchainInfo().viewport->y); + uint32_t picked_pixel_index = m_rhi->getSwapchainInfo().extent.width * pixel_y + pixel_x; + if (pixel_x >= m_rhi->getSwapchainInfo().extent.width || pixel_y >= m_rhi->getSwapchainInfo().extent.height) return 0; struct MeshNode @@ -465,109 +451,91 @@ namespace Piccolo model_nodes.push_back(temp); } + m_rhi->prepareContext(); + // reset storage buffer offset - m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[*m_vulkan_rhi->m_p_current_frame_index] = - m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[*m_vulkan_rhi->m_p_current_frame_index]; - - VkResult res_wait_for_fences = - vkWaitForFences(m_vulkan_rhi->m_device, - 1, - &m_vulkan_rhi->m_is_frame_in_flight_fences[*m_vulkan_rhi->m_p_current_frame_index], - VK_TRUE, - UINT64_MAX); - assert(VK_SUCCESS == res_wait_for_fences); - - VkResult res_reset_command_pool = m_vulkan_rhi->m_vk_reset_command_pool( - m_vulkan_rhi->m_device, m_vulkan_rhi->m_p_command_pools[*m_vulkan_rhi->m_p_current_frame_index], 0); - assert(VK_SUCCESS == res_reset_command_pool); - - VkCommandBufferBeginInfo command_buffer_begin_info {}; - command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = + m_global_render_resource->_storage_buffer._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()]; + + m_rhi->waitForFences(); + + m_rhi->resetCommandPool(); + + RHICommandBufferBeginInfo command_buffer_begin_info {}; + command_buffer_begin_info.sType = RHI_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; command_buffer_begin_info.flags = 0; command_buffer_begin_info.pInheritanceInfo = nullptr; - VkResult res_begin_command_buffer = m_vulkan_rhi->m_vk_begin_command_buffer( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], &command_buffer_begin_info); - assert(VK_SUCCESS == res_begin_command_buffer); + bool res_begin_command_buffer = m_rhi->beginCommandBufferPFN( + m_rhi->getCurrentCommandBuffer(), &command_buffer_begin_info); + assert(RHI_SUCCESS == res_begin_command_buffer); { - VkImageMemoryBarrier transfer_to_render_barrier {}; - transfer_to_render_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + RHIImageMemoryBarrier transfer_to_render_barrier {}; + transfer_to_render_barrier.sType = RHI_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; transfer_to_render_barrier.pNext = nullptr; transfer_to_render_barrier.srcAccessMask = 0; - transfer_to_render_barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - transfer_to_render_barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; - transfer_to_render_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - transfer_to_render_barrier.srcQueueFamilyIndex = m_vulkan_rhi->m_queue_indices.m_graphics_family.value(); - transfer_to_render_barrier.dstQueueFamilyIndex = m_vulkan_rhi->m_queue_indices.m_graphics_family.value(); + transfer_to_render_barrier.dstAccessMask = RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + transfer_to_render_barrier.oldLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + transfer_to_render_barrier.newLayout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + transfer_to_render_barrier.srcQueueFamilyIndex = m_rhi->getQueueFamilyIndices().graphics_family.value(); + transfer_to_render_barrier.dstQueueFamilyIndex = m_rhi->getQueueFamilyIndices().graphics_family.value(); transfer_to_render_barrier.image = m_framebuffer.attachments[0].image; - transfer_to_render_barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; - vkCmdPipelineBarrier(m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - &transfer_to_render_barrier); + transfer_to_render_barrier.subresourceRange = { RHI_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 }; + m_rhi->cmdPipelineBarrier(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + &transfer_to_render_barrier); } - m_vulkan_rhi->m_vk_cmd_set_viewport( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], 0, 1, &m_vulkan_rhi->m_viewport); - m_vulkan_rhi->m_vk_cmd_set_scissor( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], 0, 1, &m_vulkan_rhi->m_scissor); + m_rhi->cmdSetViewportPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().viewport); + m_rhi->cmdSetScissorPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().scissor); - VkRenderPassBeginInfo renderpass_begin_info {}; - renderpass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + RHIRenderPassBeginInfo renderpass_begin_info {}; + renderpass_begin_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; renderpass_begin_info.renderPass = m_framebuffer.render_pass; renderpass_begin_info.framebuffer = m_framebuffer.framebuffer; renderpass_begin_info.renderArea.offset = {0, 0}; - renderpass_begin_info.renderArea.extent = m_vulkan_rhi->m_swapchain_extent; + renderpass_begin_info.renderArea.extent = m_rhi->getSwapchainInfo().extent; - VkClearColorValue color_value = {0, 0, 0, 0}; - VkClearValue clearValues[2] = {color_value, {1.0f, 0}}; - renderpass_begin_info.clearValueCount = 2; - renderpass_begin_info.pClearValues = clearValues; + RHIClearColorValue color_value = {0, 0, 0, 0}; + RHIClearValue clearValues[2] = {color_value, {1.0f, 0}}; + renderpass_begin_info.clearValueCount = 2; + renderpass_begin_info.pClearValues = clearValues; - m_vulkan_rhi->m_vk_cmd_begin_render_pass( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], + m_rhi->cmdBeginRenderPassPFN(m_rhi->getCurrentCommandBuffer(), &renderpass_begin_info, - VK_SUBPASS_CONTENTS_INLINE); // no second buffer + RHI_SUBPASS_CONTENTS_INLINE); // no second buffer - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Mesh Inefficient Pick", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], &label_info); - } + float color[4] = { 1.0f,1.0f,1.0f,1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Mesh Inefficient Pick", color); - m_vulkan_rhi->m_vk_cmd_bind_pipeline(m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].pipeline); - m_vulkan_rhi->m_vk_cmd_set_viewport( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], 0, 1, &m_vulkan_rhi->m_viewport); - m_vulkan_rhi->m_vk_cmd_set_scissor( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], 0, 1, &m_vulkan_rhi->m_scissor); + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[0].pipeline); + m_rhi->cmdSetViewportPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().viewport); + m_rhi->cmdSetScissorPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().scissor); // perframe storage buffer uint32_t perframe_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[*m_vulkan_rhi->m_p_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[*m_vulkan_rhi->m_p_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perframe_dynamic_offset + sizeof(MeshInefficientPickPerframeStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[*m_vulkan_rhi->m_p_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[*m_vulkan_rhi->m_p_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[*m_vulkan_rhi->m_p_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); (*reinterpret_cast( reinterpret_cast( @@ -590,29 +558,26 @@ namespace Piccolo if (total_instance_count > 0) { // bind per mesh - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].layout, - 1, - 1, - &mesh.mesh_vertex_blending_descriptor_set, - 0, - NULL); - - VkBuffer vertex_buffers[] = {mesh.mesh_vertex_position_buffer}; - VkDeviceSize offsets[] = {0}; - m_vulkan_rhi->m_vk_cmd_bind_vertex_buffers( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], - 0, - 1, - vertex_buffers, - offsets); - m_vulkan_rhi->m_vk_cmd_bind_index_buffer( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], - mesh.mesh_index_buffer, - 0, - VK_INDEX_TYPE_UINT16); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[0].layout, + 1, + 1, + &mesh.mesh_vertex_blending_descriptor_set, + 0, + NULL); + + RHIBuffer* vertex_buffers[] = { mesh.mesh_vertex_position_buffer }; + RHIDeviceSize offsets[] = { 0 }; + m_rhi->cmdBindVertexBuffersPFN(m_rhi->getCurrentCommandBuffer(), + 0, + 1, + vertex_buffers, + offsets); + m_rhi->cmdBindIndexBufferPFN(m_rhi->getCurrentCommandBuffer(), + mesh.mesh_index_buffer, + 0, + RHI_INDEX_TYPE_UINT16); uint32_t drawcall_max_instance_count = (sizeof(MeshInefficientPickPerdrawcallStorageBufferObject::model_matrices) / @@ -631,17 +596,17 @@ namespace Piccolo // perdrawcall storage buffer uint32_t perdrawcall_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[*m_vulkan_rhi->m_p_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[*m_vulkan_rhi->m_p_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perdrawcall_dynamic_offset + sizeof(MeshInefficientPickPerdrawcallStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[*m_vulkan_rhi->m_p_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[*m_vulkan_rhi->m_p_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[*m_vulkan_rhi->m_p_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshInefficientPickPerdrawcallStorageBufferObject& perdrawcall_storage_buffer_object = (*reinterpret_cast( @@ -662,18 +627,18 @@ namespace Piccolo { per_drawcall_vertex_blending_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[*m_vulkan_rhi->m_p_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[*m_vulkan_rhi->m_p_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = per_drawcall_vertex_blending_dynamic_offset + sizeof(MeshInefficientPickPerdrawcallVertexBlendingStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[*m_vulkan_rhi->m_p_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[*m_vulkan_rhi->m_p_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[*m_vulkan_rhi->m_p_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshInefficientPickPerdrawcallVertexBlendingStorageBufferObject& per_drawcall_vertex_blending_storage_buffer_object = @@ -703,157 +668,125 @@ namespace Piccolo uint32_t dynamic_offsets[3] = {perframe_dynamic_offset, perdrawcall_dynamic_offset, per_drawcall_vertex_blending_dynamic_offset}; - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].layout, - 0, - 1, - &m_descriptor_infos[0].descriptor_set, - sizeof(dynamic_offsets) / sizeof(dynamic_offsets[0]), - dynamic_offsets); - - m_vulkan_rhi->m_vk_cmd_draw_indexed( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index], - mesh.mesh_index_count, - current_instance_count, - 0, - 0, - 0); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[0].layout, + 0, + 1, + &m_descriptor_infos[0].descriptor_set, + sizeof(dynamic_offsets) / sizeof(dynamic_offsets[0]), + dynamic_offsets); + + m_rhi->cmdDrawIndexedPFN(m_rhi->getCurrentCommandBuffer(), + mesh.mesh_index_count, + current_instance_count, + 0, + 0, + 0); } } } } - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index]); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); // end render pass - m_vulkan_rhi->m_vk_cmd_end_render_pass( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index]); + m_rhi->cmdEndRenderPassPFN(m_rhi->getCurrentCommandBuffer()); // end command buffer - VkResult res_end_command_buffer = m_vulkan_rhi->m_vk_end_command_buffer( - m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index]); - assert(VK_SUCCESS == res_end_command_buffer); - - VkResult res_reset_fences = m_vulkan_rhi->m_vk_reset_fences( - m_vulkan_rhi->m_device, - 1, - &m_vulkan_rhi->m_is_frame_in_flight_fences[*m_vulkan_rhi->m_p_current_frame_index]); - assert(VK_SUCCESS == res_reset_fences); - - VkSubmitInfo submit_info = {}; - submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; - submit_info.waitSemaphoreCount = 0; - submit_info.pWaitSemaphores = NULL; - submit_info.pWaitDstStageMask = 0; - submit_info.commandBufferCount = 1; - submit_info.pCommandBuffers = &m_vulkan_rhi->m_p_command_buffers[*m_vulkan_rhi->m_p_current_frame_index]; + bool res_end_command_buffer = m_rhi->endCommandBufferPFN(m_rhi->getCurrentCommandBuffer()); + assert(RHI_SUCCESS == res_end_command_buffer); + + bool res_reset_fences = m_rhi->resetFencesPFN(1, &m_rhi->getFenceList()[m_rhi->getCurrentFrameIndex()]); + assert(RHI_SUCCESS == res_reset_fences); + + RHISubmitInfo submit_info = {}; + submit_info.sType = RHI_STRUCTURE_TYPE_SUBMIT_INFO; + submit_info.waitSemaphoreCount = 0; + submit_info.pWaitSemaphores = NULL; + submit_info.pWaitDstStageMask = 0; + submit_info.commandBufferCount = 1; + RHICommandBuffer* commandBuffer = m_rhi->getCurrentCommandBuffer(); + submit_info.pCommandBuffers = &commandBuffer; submit_info.signalSemaphoreCount = 0; - submit_info.pSignalSemaphores = NULL; + submit_info.pSignalSemaphores = NULL; - VkResult res_queue_submit = - vkQueueSubmit(m_vulkan_rhi->m_graphics_queue, - 1, - &submit_info, - m_vulkan_rhi->m_is_frame_in_flight_fences[*m_vulkan_rhi->m_p_current_frame_index]); - assert(VK_SUCCESS == res_queue_submit); + bool res_queue_submit =m_rhi->queueSubmit(m_rhi->getGraphicsQueue(), + 1, + &submit_info, + m_rhi->getFenceList()[m_rhi->getCurrentFrameIndex()]); + assert(RHI_SUCCESS == res_queue_submit); - auto new_index = (*m_vulkan_rhi->m_p_current_frame_index + 1) % m_vulkan_rhi->s_max_frames_in_flight; - *m_vulkan_rhi->m_p_current_frame_index = new_index; + m_rhi->setCurrentFrameIndex((m_rhi->getCurrentFrameIndex() + 1) % m_rhi->getMaxFramesInFlight()); // implicit host read barrier - res_wait_for_fences = m_vulkan_rhi->m_vk_wait_for_fences(m_vulkan_rhi->m_device, - m_vulkan_rhi->s_max_frames_in_flight, - m_vulkan_rhi->m_is_frame_in_flight_fences, - VK_TRUE, - UINT64_MAX); - assert(VK_SUCCESS == res_wait_for_fences); + bool res_wait_for_fences = m_rhi->waitForFencesPFN(m_rhi->getMaxFramesInFlight(), + m_rhi->getFenceList(), + RHI_TRUE, + UINT64_MAX); + assert(RHI_SUCCESS == res_wait_for_fences); - auto command_buffer = m_vulkan_rhi->beginSingleTimeCommands(); + auto command_buffer = m_rhi->beginSingleTimeCommands(); - VkBufferImageCopy region {}; + RHIBufferImageCopy region {}; region.bufferOffset = 0; region.bufferRowLength = 0; region.bufferImageHeight = 0; - region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + region.imageSubresource.aspectMask = RHI_IMAGE_ASPECT_COLOR_BIT; region.imageSubresource.mipLevel = 0; region.imageSubresource.baseArrayLayer = 0; region.imageSubresource.layerCount = 1; region.imageOffset = {0, 0, 0}; - region.imageExtent = {m_vulkan_rhi->m_swapchain_extent.width, m_vulkan_rhi->m_swapchain_extent.height, 1}; - - uint32_t buffer_size = m_vulkan_rhi->m_swapchain_extent.width * m_vulkan_rhi->m_swapchain_extent.height * 4; - VkBuffer inefficient_staging_buffer; - VkDeviceMemory inefficient_staging_buffer_memory; - VulkanUtil::createBuffer(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - buffer_size, - VK_BUFFER_USAGE_TRANSFER_DST_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - inefficient_staging_buffer, - inefficient_staging_buffer_memory); - - VkImageMemoryBarrier copy_to_buffer_barrier {}; - copy_to_buffer_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + region.imageExtent = { m_rhi->getSwapchainInfo().extent.width, m_rhi->getSwapchainInfo().extent.height, 1 }; + + uint32_t buffer_size = m_rhi->getSwapchainInfo().extent.width * m_rhi->getSwapchainInfo().extent.height * 4; + RHIBuffer* inefficient_staging_buffer; + RHIDeviceMemory* inefficient_staging_buffer_memory; + m_rhi->createBuffer(buffer_size, + RHI_BUFFER_USAGE_TRANSFER_DST_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + inefficient_staging_buffer, + inefficient_staging_buffer_memory); + + RHIImageMemoryBarrier copy_to_buffer_barrier {}; + copy_to_buffer_barrier.sType = RHI_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; copy_to_buffer_barrier.pNext = nullptr; - copy_to_buffer_barrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - copy_to_buffer_barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; - copy_to_buffer_barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - copy_to_buffer_barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - copy_to_buffer_barrier.srcQueueFamilyIndex = m_vulkan_rhi->m_queue_indices.m_graphics_family.value(); - copy_to_buffer_barrier.dstQueueFamilyIndex = m_vulkan_rhi->m_queue_indices.m_graphics_family.value(); + copy_to_buffer_barrier.srcAccessMask = RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + copy_to_buffer_barrier.dstAccessMask = RHI_ACCESS_TRANSFER_READ_BIT; + copy_to_buffer_barrier.oldLayout = RHI_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + copy_to_buffer_barrier.newLayout = RHI_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + copy_to_buffer_barrier.srcQueueFamilyIndex = m_rhi->getQueueFamilyIndices().graphics_family.value(); + copy_to_buffer_barrier.dstQueueFamilyIndex = m_rhi->getQueueFamilyIndices().graphics_family.value(); copy_to_buffer_barrier.image = m_framebuffer.attachments[0].image; - copy_to_buffer_barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; - vkCmdPipelineBarrier(command_buffer, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VK_PIPELINE_STAGE_TRANSFER_BIT, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - ©_to_buffer_barrier); - - vkCmdCopyImageToBuffer(command_buffer, - m_framebuffer.attachments[0].image, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - inefficient_staging_buffer, - 1, - ®ion); - - m_vulkan_rhi->endSingleTimeCommands(command_buffer); + copy_to_buffer_barrier.subresourceRange = { RHI_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; + m_rhi->cmdPipelineBarrier(command_buffer, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT, + RHI_PIPELINE_STAGE_TRANSFER_BIT, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + ©_to_buffer_barrier); + + m_rhi->cmdCopyImageToBuffer(command_buffer, + m_framebuffer.attachments[0].image, + RHI_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + inefficient_staging_buffer, + 1, + ®ion); + + m_rhi->endSingleTimeCommands(command_buffer); uint32_t* data = nullptr; - vkMapMemory(m_vulkan_rhi->m_device, inefficient_staging_buffer_memory, 0, buffer_size, 0, (void**)&data); - -#if 0 - auto w = _rhi->_swapchain_extent.width; - auto h = _rhi->_swapchain_extent.height; - std::vector image_data(w * h * 4); - for (int i = 0; i < h; i++) - { - for (int j = 0; j < w; j++) - { - image_data[4 * (i * w + j) + 0] = data[i * w + j]; - image_data[4 * (i * w + j) + 1] = 0; - image_data[4 * (i * w + j) + 2] = 0; - image_data[4 * (i * w + j) + 3] = 0xFF; - } - } - stbi_write_png("pick.png", w, h, 4, image_data.data(), w * 4); -#endif + m_rhi->mapMemory(inefficient_staging_buffer_memory, 0, buffer_size, 0, (void**)&data); uint32_t node_id = data[picked_pixel_index]; - vkUnmapMemory(m_vulkan_rhi->m_device, inefficient_staging_buffer_memory); + m_rhi->unmapMemory(inefficient_staging_buffer_memory); - vkDestroyBuffer(m_vulkan_rhi->m_device, inefficient_staging_buffer, nullptr); - vkFreeMemory(m_vulkan_rhi->m_device, inefficient_staging_buffer_memory, nullptr); + m_rhi->destroyBuffer(inefficient_staging_buffer); + m_rhi->freeMemory(inefficient_staging_buffer_memory); return node_id; } diff --git a/engine/source/runtime/function/render/passes/pick_pass.h b/engine/source/runtime/function/render/passes/pick_pass.h index c05f4d2f3..2753a360c 100644 --- a/engine/source/runtime/function/render/passes/pick_pass.h +++ b/engine/source/runtime/function/render/passes/pick_pass.h @@ -9,7 +9,7 @@ namespace Piccolo struct PickPassInitInfo : RenderPassInitInfo { - VkDescriptorSetLayout per_mesh_layout; + RHIDescriptorSetLayout* per_mesh_layout; }; class PickPass : public RenderPass @@ -34,10 +34,10 @@ namespace Piccolo void setupDescriptorSet(); private: - VkImage _object_id_image {VK_NULL_HANDLE}; - VkDeviceMemory _object_id_image_memory {VK_NULL_HANDLE}; - VkImageView _object_id_image_view {VK_NULL_HANDLE}; + RHIImage* _object_id_image = nullptr; + RHIDeviceMemory* _object_id_image_memory = nullptr; + RHIImageView* _object_id_image_view = nullptr; - VkDescriptorSetLayout _per_mesh_layout {VK_NULL_HANDLE}; + RHIDescriptorSetLayout* _per_mesh_layout = nullptr; }; } // namespace Piccolo diff --git a/engine/source/runtime/function/render/passes/point_light_pass.cpp b/engine/source/runtime/function/render/passes/point_light_pass.cpp index 75a0562ce..e503cb1ca 100644 --- a/engine/source/runtime/function/render/passes/point_light_pass.cpp +++ b/engine/source/runtime/function/render/passes/point_light_pass.cpp @@ -1,9 +1,9 @@ +#include "runtime/function/render/passes/point_light_pass.h" + #include "runtime/function/render/render_helper.h" #include "runtime/function/render/render_mesh.h" -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" - -#include "runtime/function/render/passes/point_light_pass.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" #include #include @@ -40,19 +40,12 @@ namespace Piccolo } void PointLightShadowPass::draw() { - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Point Light Shadow", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Point Light Shadow", color); drawModel(); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } void PointLightShadowPass::setupAttachments() { @@ -60,106 +53,100 @@ namespace Piccolo m_framebuffer.attachments.resize(2); // color - m_framebuffer.attachments[0].format = VK_FORMAT_R32_SFLOAT; - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - s_point_light_shadow_map_dimension, - s_point_light_shadow_map_dimension, - m_framebuffer.attachments[0].format, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_framebuffer.attachments[0].image, - m_framebuffer.attachments[0].mem, - 0, - 2 * s_max_point_light_count, - 1); - m_framebuffer.attachments[0].view = VulkanUtil::createImageView(m_vulkan_rhi->m_device, - m_framebuffer.attachments[0].image, - m_framebuffer.attachments[0].format, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_VIEW_TYPE_2D_ARRAY, - 2 * s_max_point_light_count, - 1); + m_framebuffer.attachments[0].format = RHI_FORMAT_R32_SFLOAT; + m_rhi->createImage(s_point_light_shadow_map_dimension, + s_point_light_shadow_map_dimension, + m_framebuffer.attachments[0].format, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | RHI_IMAGE_USAGE_SAMPLED_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_framebuffer.attachments[0].image, + m_framebuffer.attachments[0].mem, + 0, + 2 * s_max_point_light_count, + 1); + m_rhi->createImageView(m_framebuffer.attachments[0].image, + m_framebuffer.attachments[0].format, + RHI_IMAGE_ASPECT_COLOR_BIT, + RHI_IMAGE_VIEW_TYPE_2D_ARRAY, + 2 * s_max_point_light_count, + 1, + m_framebuffer.attachments[0].view); // depth - m_framebuffer.attachments[1].format = m_vulkan_rhi->m_depth_image_format; - VulkanUtil::createImage(m_vulkan_rhi->m_physical_device, - m_vulkan_rhi->m_device, - s_point_light_shadow_map_dimension, - s_point_light_shadow_map_dimension, - m_framebuffer.attachments[1].format, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_framebuffer.attachments[1].image, - m_framebuffer.attachments[1].mem, - 0, - 2 * s_max_point_light_count, - 1); - m_framebuffer.attachments[1].view = VulkanUtil::createImageView(m_vulkan_rhi->m_device, - m_framebuffer.attachments[1].image, - m_framebuffer.attachments[1].format, - VK_IMAGE_ASPECT_DEPTH_BIT, - VK_IMAGE_VIEW_TYPE_2D_ARRAY, - 2 * s_max_point_light_count, - 1); + m_framebuffer.attachments[1].format = m_rhi->getDepthImageInfo().depth_image_format; + m_rhi->createImage(s_point_light_shadow_map_dimension, + s_point_light_shadow_map_dimension, + m_framebuffer.attachments[1].format, + RHI_IMAGE_TILING_OPTIMAL, + RHI_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | RHI_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + m_framebuffer.attachments[1].image, + m_framebuffer.attachments[1].mem, + 0, + 2 * s_max_point_light_count, + 1); + m_rhi->createImageView(m_framebuffer.attachments[1].image, + m_framebuffer.attachments[1].format, + RHI_IMAGE_ASPECT_DEPTH_BIT, + RHI_IMAGE_VIEW_TYPE_2D_ARRAY, + 2 * s_max_point_light_count, + 1, + m_framebuffer.attachments[1].view); } void PointLightShadowPass::setupRenderPass() { - VkAttachmentDescription attachments[2] = {}; - - VkAttachmentDescription& point_light_shadow_color_attachment_description = attachments[0]; - point_light_shadow_color_attachment_description.format = m_framebuffer.attachments[0].format; - point_light_shadow_color_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - point_light_shadow_color_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - point_light_shadow_color_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_STORE; - point_light_shadow_color_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - point_light_shadow_color_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - point_light_shadow_color_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - point_light_shadow_color_attachment_description.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - - VkAttachmentDescription& point_light_shadow_depth_attachment_description = attachments[1]; - point_light_shadow_depth_attachment_description.format = m_framebuffer.attachments[1].format; - point_light_shadow_depth_attachment_description.samples = VK_SAMPLE_COUNT_1_BIT; - point_light_shadow_depth_attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - point_light_shadow_depth_attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - point_light_shadow_depth_attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - point_light_shadow_depth_attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - point_light_shadow_depth_attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - point_light_shadow_depth_attachment_description.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - - VkSubpassDescription subpasses[1] = {}; - - VkAttachmentReference shadow_pass_color_attachment_reference {}; - shadow_pass_color_attachment_reference.attachment = - &point_light_shadow_color_attachment_description - attachments; - shadow_pass_color_attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - - VkAttachmentReference shadow_pass_depth_attachment_reference {}; - shadow_pass_depth_attachment_reference.attachment = - &point_light_shadow_depth_attachment_description - attachments; - shadow_pass_depth_attachment_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - - VkSubpassDescription& shadow_pass = subpasses[0]; - shadow_pass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; - shadow_pass.colorAttachmentCount = 1; - shadow_pass.pColorAttachments = &shadow_pass_color_attachment_reference; - shadow_pass.pDepthStencilAttachment = &shadow_pass_depth_attachment_reference; - - VkSubpassDependency dependencies[1] = {}; - - VkSubpassDependency& lighting_pass_dependency = dependencies[0]; - lighting_pass_dependency.srcSubpass = 0; - lighting_pass_dependency.dstSubpass = VK_SUBPASS_EXTERNAL; - lighting_pass_dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; - lighting_pass_dependency.dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; - lighting_pass_dependency.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; // STORE_OP_STORE - lighting_pass_dependency.dstAccessMask = 0; - lighting_pass_dependency.dependencyFlags = 0; // NOT BY REGION - - VkRenderPassCreateInfo renderpass_create_info {}; - renderpass_create_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + RHIAttachmentDescription attachments[2] = {}; + + RHIAttachmentDescription& point_light_shadow_color_attachment_description = attachments[0]; + point_light_shadow_color_attachment_description.format = m_framebuffer.attachments[0].format; + point_light_shadow_color_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + point_light_shadow_color_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + point_light_shadow_color_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_STORE; + point_light_shadow_color_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + point_light_shadow_color_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + point_light_shadow_color_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + point_light_shadow_color_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + RHIAttachmentDescription& point_light_shadow_depth_attachment_description = attachments[1]; + point_light_shadow_depth_attachment_description.format = m_framebuffer.attachments[1].format; + point_light_shadow_depth_attachment_description.samples = RHI_SAMPLE_COUNT_1_BIT; + point_light_shadow_depth_attachment_description.loadOp = RHI_ATTACHMENT_LOAD_OP_CLEAR; + point_light_shadow_depth_attachment_description.storeOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + point_light_shadow_depth_attachment_description.stencilLoadOp = RHI_ATTACHMENT_LOAD_OP_DONT_CARE; + point_light_shadow_depth_attachment_description.stencilStoreOp = RHI_ATTACHMENT_STORE_OP_DONT_CARE; + point_light_shadow_depth_attachment_description.initialLayout = RHI_IMAGE_LAYOUT_UNDEFINED; + point_light_shadow_depth_attachment_description.finalLayout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + + RHISubpassDescription subpasses[1] = {}; + + RHIAttachmentReference shadow_pass_color_attachment_reference {}; + shadow_pass_color_attachment_reference.attachment = &point_light_shadow_color_attachment_description - attachments; + shadow_pass_color_attachment_reference.layout = RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + + RHIAttachmentReference shadow_pass_depth_attachment_reference {}; + shadow_pass_depth_attachment_reference.attachment = &point_light_shadow_depth_attachment_description - attachments; + shadow_pass_depth_attachment_reference.layout = RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + + RHISubpassDescription& shadow_pass = subpasses[0]; + shadow_pass.pipelineBindPoint = RHI_PIPELINE_BIND_POINT_GRAPHICS; + shadow_pass.colorAttachmentCount = 1; + shadow_pass.pColorAttachments = &shadow_pass_color_attachment_reference; + shadow_pass.pDepthStencilAttachment = &shadow_pass_depth_attachment_reference; + + RHISubpassDependency dependencies[1] = {}; + + RHISubpassDependency& lighting_pass_dependency = dependencies[0]; + lighting_pass_dependency.srcSubpass = 0; + lighting_pass_dependency.dstSubpass = RHI_SUBPASS_EXTERNAL; + lighting_pass_dependency.srcStageMask = RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + lighting_pass_dependency.dstStageMask = RHI_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; + lighting_pass_dependency.srcAccessMask = RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; // STORE_OP_STORE + lighting_pass_dependency.dstAccessMask = 0; + lighting_pass_dependency.dependencyFlags = 0; // NOT BY REGION + + RHIRenderPassCreateInfo renderpass_create_info {}; + renderpass_create_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; renderpass_create_info.attachmentCount = (sizeof(attachments) / sizeof(attachments[0])); renderpass_create_info.pAttachments = attachments; renderpass_create_info.subpassCount = (sizeof(subpasses) / sizeof(subpasses[0])); @@ -167,18 +154,17 @@ namespace Piccolo renderpass_create_info.dependencyCount = (sizeof(dependencies) / sizeof(dependencies[0])); renderpass_create_info.pDependencies = dependencies; - if (vkCreateRenderPass(m_vulkan_rhi->m_device, &renderpass_create_info, nullptr, &m_framebuffer.render_pass) != - VK_SUCCESS) + if (m_rhi->createRenderPass(&renderpass_create_info, m_framebuffer.render_pass) != RHI_SUCCESS) { throw std::runtime_error("create point light shadow render pass"); } } void PointLightShadowPass::setupFramebuffer() { - VkImageView attachments[2] = {m_framebuffer.attachments[0].view, m_framebuffer.attachments[1].view}; + RHIImageView* attachments[2] = {m_framebuffer.attachments[0].view, m_framebuffer.attachments[1].view}; - VkFramebufferCreateInfo framebuffer_create_info {}; - framebuffer_create_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + RHIFramebufferCreateInfo framebuffer_create_info {}; + framebuffer_create_info.sType = RHI_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; framebuffer_create_info.flags = 0U; framebuffer_create_info.renderPass = m_framebuffer.render_pass; framebuffer_create_info.attachmentCount = (sizeof(attachments) / sizeof(attachments[0])); @@ -187,8 +173,7 @@ namespace Piccolo framebuffer_create_info.height = s_point_light_shadow_map_dimension; framebuffer_create_info.layers = 2 * s_max_point_light_count; - if (vkCreateFramebuffer( - m_vulkan_rhi->m_device, &framebuffer_create_info, nullptr, &m_framebuffer.framebuffer) != VK_SUCCESS) + if (m_rhi->createFramebuffer(&framebuffer_create_info, m_framebuffer.framebuffer) != RHI_SUCCESS) { throw std::runtime_error("create point light shadow framebuffer"); } @@ -197,38 +182,38 @@ namespace Piccolo { m_descriptor_infos.resize(1); - VkDescriptorSetLayoutBinding mesh_point_light_shadow_global_layout_bindings[3]; + RHIDescriptorSetLayoutBinding mesh_point_light_shadow_global_layout_bindings[3]; - VkDescriptorSetLayoutBinding& mesh_point_light_shadow_global_layout_perframe_storage_buffer_binding = + RHIDescriptorSetLayoutBinding& mesh_point_light_shadow_global_layout_perframe_storage_buffer_binding = mesh_point_light_shadow_global_layout_bindings[0]; mesh_point_light_shadow_global_layout_perframe_storage_buffer_binding.binding = 0; mesh_point_light_shadow_global_layout_perframe_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_point_light_shadow_global_layout_perframe_storage_buffer_binding.descriptorCount = 1; mesh_point_light_shadow_global_layout_perframe_storage_buffer_binding.stageFlags = - VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_FRAGMENT_BIT; + RHI_SHADER_STAGE_GEOMETRY_BIT | RHI_SHADER_STAGE_FRAGMENT_BIT; - VkDescriptorSetLayoutBinding& mesh_point_light_shadow_global_layout_perdrawcall_storage_buffer_binding = + RHIDescriptorSetLayoutBinding& mesh_point_light_shadow_global_layout_perdrawcall_storage_buffer_binding = mesh_point_light_shadow_global_layout_bindings[1]; mesh_point_light_shadow_global_layout_perdrawcall_storage_buffer_binding.binding = 1; mesh_point_light_shadow_global_layout_perdrawcall_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_point_light_shadow_global_layout_perdrawcall_storage_buffer_binding.descriptorCount = 1; mesh_point_light_shadow_global_layout_perdrawcall_storage_buffer_binding.stageFlags = - VK_SHADER_STAGE_VERTEX_BIT; + RHI_SHADER_STAGE_VERTEX_BIT; - VkDescriptorSetLayoutBinding& + RHIDescriptorSetLayoutBinding& mesh_point_light_shadow_global_layout_per_drawcall_vertex_blending_storage_buffer_binding = mesh_point_light_shadow_global_layout_bindings[2]; mesh_point_light_shadow_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.binding = 2; mesh_point_light_shadow_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_point_light_shadow_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.descriptorCount = 1; mesh_point_light_shadow_global_layout_per_drawcall_vertex_blending_storage_buffer_binding.stageFlags = - VK_SHADER_STAGE_VERTEX_BIT; + RHI_SHADER_STAGE_VERTEX_BIT; - VkDescriptorSetLayoutCreateInfo mesh_point_light_shadow_global_layout_create_info; - mesh_point_light_shadow_global_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo mesh_point_light_shadow_global_layout_create_info; + mesh_point_light_shadow_global_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; mesh_point_light_shadow_global_layout_create_info.pNext = NULL; mesh_point_light_shadow_global_layout_create_info.flags = 0; mesh_point_light_shadow_global_layout_create_info.bindingCount = @@ -236,121 +221,116 @@ namespace Piccolo sizeof(mesh_point_light_shadow_global_layout_bindings[0])); mesh_point_light_shadow_global_layout_create_info.pBindings = mesh_point_light_shadow_global_layout_bindings; - if (VK_SUCCESS != vkCreateDescriptorSetLayout(m_vulkan_rhi->m_device, - &mesh_point_light_shadow_global_layout_create_info, - NULL, - &m_descriptor_infos[0].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&mesh_point_light_shadow_global_layout_create_info, m_descriptor_infos[0].layout)) { throw std::runtime_error("create mesh point light shadow global layout"); } } void PointLightShadowPass::setupPipelines() { - if (!m_vulkan_rhi->isPointLightShadowEnabled()) + if (!m_rhi->isPointLightShadowEnabled()) return; m_render_pipelines.resize(1); - VkDescriptorSetLayout descriptorset_layouts[] = {m_descriptor_infos[0].layout, m_per_mesh_layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayout* descriptorset_layouts[] = {m_descriptor_infos[0].layout, m_per_mesh_layout}; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = (sizeof(descriptorset_layouts) / sizeof(descriptorset_layouts[0])); pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout( - m_vulkan_rhi->m_device, &pipeline_layout_create_info, nullptr, &m_render_pipelines[0].layout) != - VK_SUCCESS) + if (m_rhi->createPipelineLayout( &pipeline_layout_create_info, m_render_pipelines[0].layout) != RHI_SUCCESS) { throw std::runtime_error("create mesh point light shadow pipeline layout"); } - VkShaderModule vert_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, MESH_POINT_LIGHT_SHADOW_VERT); - VkShaderModule geom_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, MESH_POINT_LIGHT_SHADOW_GEOM); - VkShaderModule frag_shader_module = - VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, MESH_POINT_LIGHT_SHADOW_FRAG); + RHIShader* vert_shader_module = + m_rhi->createShaderModule(MESH_POINT_LIGHT_SHADOW_VERT); + RHIShader* geom_shader_module = + m_rhi->createShaderModule(MESH_POINT_LIGHT_SHADOW_GEOM); + RHIShader* frag_shader_module = + m_rhi->createShaderModule(MESH_POINT_LIGHT_SHADOW_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo geom_pipeline_shader_stage_create_info {}; - geom_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - geom_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_GEOMETRY_BIT; + RHIPipelineShaderStageCreateInfo geom_pipeline_shader_stage_create_info {}; + geom_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + geom_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_GEOMETRY_BIT; geom_pipeline_shader_stage_create_info.module = geom_shader_module; geom_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, geom_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; auto vertex_binding_descriptions = MeshVertex::getBindingDescriptions(); auto vertex_attribute_descriptions = MeshVertex::getAttributeDescriptions(); - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = 1; vertex_input_state_create_info.pVertexBindingDescriptions = &vertex_binding_descriptions[0]; vertex_input_state_create_info.vertexAttributeDescriptionCount = 1; vertex_input_state_create_info.pVertexAttributeDescriptions = &vertex_attribute_descriptions[0]; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkViewport viewport = {0, 0, s_point_light_shadow_map_dimension, s_point_light_shadow_map_dimension, 0.0, 1.0}; - VkRect2D scissor = {{0, 0}, {s_point_light_shadow_map_dimension, s_point_light_shadow_map_dimension}}; + RHIViewport viewport = {0, 0, s_point_light_shadow_map_dimension, s_point_light_shadow_map_dimension, 0.0, 1.0}; + RHIRect2D scissor = {{0, 0}, {s_point_light_shadow_map_dimension, s_point_light_shadow_map_dimension}}; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; // TODO : test more to verify - rasterization_state_create_info.cullMode = VK_CULL_MODE_BACK_BIT; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_BACK_BIT; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_COUNTER_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; - VkPipelineColorBlendAttachmentState color_blend_attachment_state {}; + RHIPipelineColorBlendAttachmentState color_blend_attachment_state {}; color_blend_attachment_state.colorWriteMask = - VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachment_state.blendEnable = VK_FALSE; - color_blend_attachment_state.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHI_COLOR_COMPONENT_R_BIT | RHI_COLOR_COMPONENT_G_BIT | RHI_COLOR_COMPONENT_B_BIT | RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachment_state.blendEnable = RHI_FALSE; + color_blend_attachment_state.srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachment_state.srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = 1; color_blend_state_create_info.pAttachments = &color_blend_attachment_state; color_blend_state_create_info.blendConstants[0] = 0.0f; @@ -358,21 +338,21 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_TRUE; - depth_stencil_create_info.depthWriteEnable = VK_TRUE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_TRUE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 0; dynamic_state_create_info.pDynamicStates = NULL; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = (sizeof(shader_stages) / sizeof(shader_stages[0])); pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -385,37 +365,33 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[0].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = 0; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines( - m_vulkan_rhi->m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_render_pipelines[0].pipeline) != - VK_SUCCESS) + if (m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, 1, &pipelineInfo, m_render_pipelines[0].pipeline) != RHI_SUCCESS) { throw std::runtime_error("create mesh point light shadow graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, geom_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(geom_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } void PointLightShadowPass::setupDescriptorSet() { - VkDescriptorSetAllocateInfo mesh_point_light_shadow_global_descriptor_set_alloc_info; - mesh_point_light_shadow_global_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHIDescriptorSetAllocateInfo mesh_point_light_shadow_global_descriptor_set_alloc_info; + mesh_point_light_shadow_global_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; mesh_point_light_shadow_global_descriptor_set_alloc_info.pNext = NULL; - mesh_point_light_shadow_global_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + mesh_point_light_shadow_global_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); mesh_point_light_shadow_global_descriptor_set_alloc_info.descriptorSetCount = 1; mesh_point_light_shadow_global_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[0].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &mesh_point_light_shadow_global_descriptor_set_alloc_info, - &m_descriptor_infos[0].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&mesh_point_light_shadow_global_descriptor_set_alloc_info, m_descriptor_infos[0].descriptor_set)) { throw std::runtime_error("allocate mesh point light shadow global descriptor set"); } - VkDescriptorBufferInfo mesh_point_light_shadow_perframe_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_point_light_shadow_perframe_storage_buffer_info = {}; // this offset plus dynamic_offset should not be greater than the size of the buffer mesh_point_light_shadow_perframe_storage_buffer_info.offset = 0; // the range means the size actually used by the shader per draw call @@ -426,7 +402,7 @@ namespace Piccolo assert(mesh_point_light_shadow_perframe_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorBufferInfo mesh_point_light_shadow_perdrawcall_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_point_light_shadow_perdrawcall_storage_buffer_info = {}; mesh_point_light_shadow_perdrawcall_storage_buffer_info.offset = 0; mesh_point_light_shadow_perdrawcall_storage_buffer_info.range = sizeof(MeshPointLightShadowPerdrawcallStorageBufferObject); @@ -435,7 +411,7 @@ namespace Piccolo assert(mesh_point_light_shadow_perdrawcall_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorBufferInfo mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_info = {}; + RHIDescriptorBufferInfo mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_info = {}; mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_info.offset = 0; mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_info.range = sizeof(MeshPointLightShadowPerdrawcallVertexBlendingStorageBufferObject); @@ -444,50 +420,49 @@ namespace Piccolo assert(mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_info.range < m_global_render_resource->_storage_buffer._max_storage_buffer_range); - VkDescriptorSet descriptor_set_to_write = m_descriptor_infos[0].descriptor_set; + RHIDescriptorSet* descriptor_set_to_write = m_descriptor_infos[0].descriptor_set; - VkWriteDescriptorSet descriptor_writes[3]; + RHIWriteDescriptorSet descriptor_writes[3]; - VkWriteDescriptorSet& mesh_point_light_shadow_perframe_storage_buffer_write_info = descriptor_writes[0]; - mesh_point_light_shadow_perframe_storage_buffer_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHIWriteDescriptorSet& mesh_point_light_shadow_perframe_storage_buffer_write_info = descriptor_writes[0]; + mesh_point_light_shadow_perframe_storage_buffer_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_point_light_shadow_perframe_storage_buffer_write_info.pNext = NULL; mesh_point_light_shadow_perframe_storage_buffer_write_info.dstSet = descriptor_set_to_write; mesh_point_light_shadow_perframe_storage_buffer_write_info.dstBinding = 0; mesh_point_light_shadow_perframe_storage_buffer_write_info.dstArrayElement = 0; mesh_point_light_shadow_perframe_storage_buffer_write_info.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_point_light_shadow_perframe_storage_buffer_write_info.descriptorCount = 1; mesh_point_light_shadow_perframe_storage_buffer_write_info.pBufferInfo = &mesh_point_light_shadow_perframe_storage_buffer_info; - VkWriteDescriptorSet& mesh_point_light_shadow_perdrawcall_storage_buffer_write_info = descriptor_writes[1]; - mesh_point_light_shadow_perdrawcall_storage_buffer_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHIWriteDescriptorSet& mesh_point_light_shadow_perdrawcall_storage_buffer_write_info = descriptor_writes[1]; + mesh_point_light_shadow_perdrawcall_storage_buffer_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_point_light_shadow_perdrawcall_storage_buffer_write_info.pNext = NULL; mesh_point_light_shadow_perdrawcall_storage_buffer_write_info.dstSet = descriptor_set_to_write; mesh_point_light_shadow_perdrawcall_storage_buffer_write_info.dstBinding = 1; mesh_point_light_shadow_perdrawcall_storage_buffer_write_info.dstArrayElement = 0; mesh_point_light_shadow_perdrawcall_storage_buffer_write_info.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_point_light_shadow_perdrawcall_storage_buffer_write_info.descriptorCount = 1; mesh_point_light_shadow_perdrawcall_storage_buffer_write_info.pBufferInfo = &mesh_point_light_shadow_perdrawcall_storage_buffer_info; - VkWriteDescriptorSet& mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info = + RHIWriteDescriptorSet& mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info = descriptor_writes[2]; mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.sType = - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.pNext = NULL; mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.dstSet = descriptor_set_to_write; mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.dstBinding = 2; mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.dstArrayElement = 0; mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.descriptorCount = 1; mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_write_info.pBufferInfo = &mesh_point_light_shadow_per_drawcall_vertex_blending_storage_buffer_info; - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - (sizeof(descriptor_writes) / sizeof(descriptor_writes[0])), + m_rhi->updateDescriptorSets((sizeof(descriptor_writes) / sizeof(descriptor_writes[0])), descriptor_writes, 0, NULL); @@ -520,53 +495,44 @@ namespace Piccolo mesh_nodes.push_back(temp); } - VkRenderPassBeginInfo renderpass_begin_info {}; - renderpass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + RHIRenderPassBeginInfo renderpass_begin_info {}; + renderpass_begin_info.sType = RHI_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; renderpass_begin_info.renderPass = m_framebuffer.render_pass; renderpass_begin_info.framebuffer = m_framebuffer.framebuffer; renderpass_begin_info.renderArea.offset = {0, 0}; renderpass_begin_info.renderArea.extent = {s_point_light_shadow_map_dimension, s_point_light_shadow_map_dimension}; - VkClearValue clear_values[2]; + RHIClearValue clear_values[2]; clear_values[0].color = {1.0f}; clear_values[1].depthStencil = {1.0f, 0}; renderpass_begin_info.clearValueCount = (sizeof(clear_values) / sizeof(clear_values[0])); renderpass_begin_info.pClearValues = clear_values; - m_vulkan_rhi->m_vk_cmd_begin_render_pass( - m_vulkan_rhi->m_current_command_buffer, &renderpass_begin_info, VK_SUBPASS_CONTENTS_INLINE); + m_rhi->cmdBeginRenderPassPFN(m_rhi->getCurrentCommandBuffer(), &renderpass_begin_info, RHI_SUBPASS_CONTENTS_INLINE); - if (m_vulkan_rhi->isPointLightShadowEnabled()) + if (m_rhi->isPointLightShadowEnabled()) { - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Mesh", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Mesh", color); - m_vulkan_rhi->m_vk_cmd_bind_pipeline(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].pipeline); + m_rhi->cmdBindPipelinePFN( + m_rhi->getCurrentCommandBuffer(), RHI_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[0].pipeline); // perframe storage buffer uint32_t perframe_dynamic_offset = - roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + roundUp(m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); - m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + + m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perframe_dynamic_offset + sizeof(MeshPerframeStorageBufferObject); - assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= - (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + - m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + + assert(m_global_render_resource->_storage_buffer._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= + (m_global_render_resource->_storage_buffer._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + + m_global_render_resource->_storage_buffer._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshPointLightShadowPerframeStorageBufferObject& perframe_storage_buffer_object = - (*reinterpret_cast( + (*reinterpret_cast( reinterpret_cast( m_global_render_resource->_storage_buffer._global_upload_ringbuffer_memory_pointer) + perframe_dynamic_offset)); @@ -588,27 +554,26 @@ namespace Piccolo if (total_instance_count > 0) { // bind per mesh - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].layout, - 1, - 1, - &mesh.mesh_vertex_blending_descriptor_set, - 0, - NULL); - - VkBuffer vertex_buffers[] = {mesh.mesh_vertex_position_buffer}; - VkDeviceSize offsets[] = {0}; - m_vulkan_rhi->m_vk_cmd_bind_vertex_buffers( - m_vulkan_rhi->m_current_command_buffer, 0, 1, vertex_buffers, offsets); - m_vulkan_rhi->m_vk_cmd_bind_index_buffer( - m_vulkan_rhi->m_current_command_buffer, mesh.mesh_index_buffer, 0, VK_INDEX_TYPE_UINT16); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[0].layout, + 1, + 1, + &mesh.mesh_vertex_blending_descriptor_set, + 0, + NULL); + + RHIBuffer* vertex_buffers[] = {mesh.mesh_vertex_position_buffer}; + RHIDeviceSize offsets[] = {0}; + m_rhi->cmdBindVertexBuffersPFN( + m_rhi->getCurrentCommandBuffer(), 0, 1, vertex_buffers, offsets); + m_rhi->cmdBindIndexBufferPFN( + m_rhi->getCurrentCommandBuffer(), mesh.mesh_index_buffer, 0, RHI_INDEX_TYPE_UINT16); uint32_t drawcall_max_instance_count = (sizeof(MeshPointLightShadowPerdrawcallStorageBufferObject::mesh_instances) / sizeof(MeshPointLightShadowPerdrawcallStorageBufferObject::mesh_instances[0])); - uint32_t drawcall_count = - roundUp(total_instance_count, drawcall_max_instance_count) / drawcall_max_instance_count; + uint32_t drawcall_count = roundUp(total_instance_count, drawcall_max_instance_count) / drawcall_max_instance_count; for (uint32_t drawcall_index = 0; drawcall_index < drawcall_count; ++drawcall_index) { @@ -621,17 +586,17 @@ namespace Piccolo // perdrawcall storage buffer uint32_t perdrawcall_dynamic_offset = roundUp(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = perdrawcall_dynamic_offset + sizeof(MeshPointLightShadowPerdrawcallStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshPointLightShadowPerdrawcallStorageBufferObject& perdrawcall_storage_buffer_object = (*reinterpret_cast( @@ -662,18 +627,18 @@ namespace Piccolo { per_drawcall_vertex_blending_dynamic_offset = roundUp( m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index], + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()], m_global_render_resource->_storage_buffer._min_storage_buffer_offset_alignment); m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] = + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] = per_drawcall_vertex_blending_dynamic_offset + sizeof(MeshPointLightShadowPerdrawcallVertexBlendingStorageBufferObject); assert(m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_end[m_vulkan_rhi->m_current_frame_index] <= + ._global_upload_ringbuffers_end[m_rhi->getCurrentFrameIndex()] <= (m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_begin[m_vulkan_rhi->m_current_frame_index] + + ._global_upload_ringbuffers_begin[m_rhi->getCurrentFrameIndex()] + m_global_render_resource->_storage_buffer - ._global_upload_ringbuffers_size[m_vulkan_rhi->m_current_frame_index])); + ._global_upload_ringbuffers_size[m_rhi->getCurrentFrameIndex()])); MeshPointLightShadowPerdrawcallVertexBlendingStorageBufferObject& per_drawcall_vertex_blending_storage_buffer_object = @@ -708,34 +673,30 @@ namespace Piccolo uint32_t dynamic_offsets[3] = {perframe_dynamic_offset, perdrawcall_dynamic_offset, per_drawcall_vertex_blending_dynamic_offset}; - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets( - m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].layout, - 0, - 1, - &m_descriptor_infos[0].descriptor_set, - (sizeof(dynamic_offsets) / sizeof(dynamic_offsets[0])), - dynamic_offsets); - - m_vulkan_rhi->m_vk_cmd_draw_indexed(m_vulkan_rhi->m_current_command_buffer, - mesh.mesh_index_count, - current_instance_count, - 0, - 0, - 0); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[0].layout, + 0, + 1, + &m_descriptor_infos[0].descriptor_set, + (sizeof(dynamic_offsets) / sizeof(dynamic_offsets[0])), + dynamic_offsets); + + m_rhi->cmdDrawIndexedPFN(m_rhi->getCurrentCommandBuffer(), + mesh.mesh_index_count, + current_instance_count, + 0, + 0, + 0); } } } } - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } - m_vulkan_rhi->m_vk_cmd_end_render_pass(m_vulkan_rhi->m_current_command_buffer); + m_rhi->cmdEndRenderPassPFN(m_rhi->getCurrentCommandBuffer()); } } // namespace Piccolo diff --git a/engine/source/runtime/function/render/passes/point_light_pass.h b/engine/source/runtime/function/render/passes/point_light_pass.h index 381727b5a..ebeb1490e 100644 --- a/engine/source/runtime/function/render/passes/point_light_pass.h +++ b/engine/source/runtime/function/render/passes/point_light_pass.h @@ -14,7 +14,7 @@ namespace Piccolo void preparePassData(std::shared_ptr render_resource) override final; void draw() override final; - void setPerMeshLayout(const VkDescriptorSetLayout& layout) { m_per_mesh_layout = layout; } + void setPerMeshLayout(RHIDescriptorSetLayout* layout) { m_per_mesh_layout = layout; } private: void setupAttachments(); @@ -26,7 +26,7 @@ namespace Piccolo void drawModel(); private: - VkDescriptorSetLayout m_per_mesh_layout; + RHIDescriptorSetLayout* m_per_mesh_layout; MeshPointLightShadowPerframeStorageBufferObject m_mesh_point_light_shadow_perframe_storage_buffer_object; }; } // namespace Piccolo diff --git a/engine/source/runtime/function/render/passes/tone_mapping_pass.cpp b/engine/source/runtime/function/render/passes/tone_mapping_pass.cpp index 464cda171..b824e664a 100644 --- a/engine/source/runtime/function/render/passes/tone_mapping_pass.cpp +++ b/engine/source/runtime/function/render/passes/tone_mapping_pass.cpp @@ -1,8 +1,8 @@ -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" - #include "runtime/function/render/passes/tone_mapping_pass.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" + #include #include @@ -27,26 +27,22 @@ namespace Piccolo { m_descriptor_infos.resize(1); - VkDescriptorSetLayoutBinding post_process_global_layout_bindings[1] = {}; + RHIDescriptorSetLayoutBinding post_process_global_layout_bindings[1] = {}; - VkDescriptorSetLayoutBinding& post_process_global_layout_input_attachment_binding = - post_process_global_layout_bindings[0]; + RHIDescriptorSetLayoutBinding& post_process_global_layout_input_attachment_binding = post_process_global_layout_bindings[0]; post_process_global_layout_input_attachment_binding.binding = 0; - post_process_global_layout_input_attachment_binding.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + post_process_global_layout_input_attachment_binding.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; post_process_global_layout_input_attachment_binding.descriptorCount = 1; - post_process_global_layout_input_attachment_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + post_process_global_layout_input_attachment_binding.stageFlags = RHI_SHADER_STAGE_FRAGMENT_BIT; - VkDescriptorSetLayoutCreateInfo post_process_global_layout_create_info; - post_process_global_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayoutCreateInfo post_process_global_layout_create_info; + post_process_global_layout_create_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; post_process_global_layout_create_info.pNext = NULL; post_process_global_layout_create_info.flags = 0; - post_process_global_layout_create_info.bindingCount = - sizeof(post_process_global_layout_bindings) / sizeof(post_process_global_layout_bindings[0]); + post_process_global_layout_create_info.bindingCount = sizeof(post_process_global_layout_bindings) / sizeof(post_process_global_layout_bindings[0]); post_process_global_layout_create_info.pBindings = post_process_global_layout_bindings; - if (VK_SUCCESS != - vkCreateDescriptorSetLayout( - m_vulkan_rhi->m_device, &post_process_global_layout_create_info, NULL, &m_descriptor_infos[0].layout)) + if (RHI_SUCCESS != m_rhi->createDescriptorSetLayout(&post_process_global_layout_create_info, m_descriptor_infos[0].layout)) { throw std::runtime_error("create post process global layout"); } @@ -55,89 +51,89 @@ namespace Piccolo { m_render_pipelines.resize(1); - VkDescriptorSetLayout descriptorset_layouts[1] = {m_descriptor_infos[0].layout}; - VkPipelineLayoutCreateInfo pipeline_layout_create_info {}; - pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + RHIDescriptorSetLayout* descriptorset_layouts[1] = {m_descriptor_infos[0].layout}; + RHIPipelineLayoutCreateInfo pipeline_layout_create_info {}; + pipeline_layout_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_create_info.setLayoutCount = 1; pipeline_layout_create_info.pSetLayouts = descriptorset_layouts; - if (vkCreatePipelineLayout( - m_vulkan_rhi->m_device, &pipeline_layout_create_info, nullptr, &m_render_pipelines[0].layout) != - VK_SUCCESS) + if (m_rhi->createPipelineLayout(&pipeline_layout_create_info, m_render_pipelines[0].layout) != RHI_SUCCESS) { throw std::runtime_error("create post process pipeline layout"); } - VkShaderModule vert_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, POST_PROCESS_VERT); - VkShaderModule frag_shader_module = VulkanUtil::createShaderModule(m_vulkan_rhi->m_device, TONE_MAPPING_FRAG); + RHIShader* vert_shader_module = m_rhi->createShaderModule(POST_PROCESS_VERT); + RHIShader* frag_shader_module = m_rhi->createShaderModule(TONE_MAPPING_FRAG); - VkPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; - vert_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - vert_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_VERTEX_BIT; + RHIPipelineShaderStageCreateInfo vert_pipeline_shader_stage_create_info {}; + vert_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vert_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_VERTEX_BIT; vert_pipeline_shader_stage_create_info.module = vert_shader_module; vert_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; - frag_pipeline_shader_stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; - frag_pipeline_shader_stage_create_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + RHIPipelineShaderStageCreateInfo frag_pipeline_shader_stage_create_info {}; + frag_pipeline_shader_stage_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + frag_pipeline_shader_stage_create_info.stage = RHI_SHADER_STAGE_FRAGMENT_BIT; frag_pipeline_shader_stage_create_info.module = frag_shader_module; frag_pipeline_shader_stage_create_info.pName = "main"; - VkPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, + RHIPipelineShaderStageCreateInfo shader_stages[] = {vert_pipeline_shader_stage_create_info, frag_pipeline_shader_stage_create_info}; - VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; - vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + RHIPipelineVertexInputStateCreateInfo vertex_input_state_create_info {}; + vertex_input_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; vertex_input_state_create_info.vertexBindingDescriptionCount = 0; vertex_input_state_create_info.pVertexBindingDescriptions = NULL; vertex_input_state_create_info.vertexAttributeDescriptionCount = 0; vertex_input_state_create_info.pVertexAttributeDescriptions = NULL; - VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; - input_assembly_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - input_assembly_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - input_assembly_create_info.primitiveRestartEnable = VK_FALSE; + RHIPipelineInputAssemblyStateCreateInfo input_assembly_create_info {}; + input_assembly_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + input_assembly_create_info.topology = RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; + input_assembly_create_info.primitiveRestartEnable = RHI_FALSE; - VkPipelineViewportStateCreateInfo viewport_state_create_info {}; - viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + RHIPipelineViewportStateCreateInfo viewport_state_create_info {}; + viewport_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; viewport_state_create_info.viewportCount = 1; - viewport_state_create_info.pViewports = &m_vulkan_rhi->m_viewport; + viewport_state_create_info.pViewports = m_rhi->getSwapchainInfo().viewport; viewport_state_create_info.scissorCount = 1; - viewport_state_create_info.pScissors = &m_vulkan_rhi->m_scissor; + viewport_state_create_info.pScissors = m_rhi->getSwapchainInfo().scissor; - VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; - rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rasterization_state_create_info.depthClampEnable = VK_FALSE; - rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE; - rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL; + RHIPipelineRasterizationStateCreateInfo rasterization_state_create_info {}; + rasterization_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterization_state_create_info.depthClampEnable = RHI_FALSE; + rasterization_state_create_info.rasterizerDiscardEnable = RHI_FALSE; + rasterization_state_create_info.polygonMode = RHI_POLYGON_MODE_FILL; rasterization_state_create_info.lineWidth = 1.0f; - rasterization_state_create_info.cullMode = VK_CULL_MODE_BACK_BIT; - rasterization_state_create_info.frontFace = VK_FRONT_FACE_CLOCKWISE; - rasterization_state_create_info.depthBiasEnable = VK_FALSE; + rasterization_state_create_info.cullMode = RHI_CULL_MODE_BACK_BIT; + rasterization_state_create_info.frontFace = RHI_FRONT_FACE_CLOCKWISE; + rasterization_state_create_info.depthBiasEnable = RHI_FALSE; rasterization_state_create_info.depthBiasConstantFactor = 0.0f; rasterization_state_create_info.depthBiasClamp = 0.0f; rasterization_state_create_info.depthBiasSlopeFactor = 0.0f; - VkPipelineMultisampleStateCreateInfo multisample_state_create_info {}; - multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - multisample_state_create_info.sampleShadingEnable = VK_FALSE; - multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; - - VkPipelineColorBlendAttachmentState color_blend_attachment_state {}; - color_blend_attachment_state.colorWriteMask = - VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - color_blend_attachment_state.blendEnable = VK_FALSE; - color_blend_attachment_state.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD; - color_blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - color_blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD; - - VkPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; - color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - color_blend_state_create_info.logicOpEnable = VK_FALSE; - color_blend_state_create_info.logicOp = VK_LOGIC_OP_COPY; + RHIPipelineMultisampleStateCreateInfo multisample_state_create_info {}; + multisample_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisample_state_create_info.sampleShadingEnable = RHI_FALSE; + multisample_state_create_info.rasterizationSamples = RHI_SAMPLE_COUNT_1_BIT; + + RHIPipelineColorBlendAttachmentState color_blend_attachment_state {}; + color_blend_attachment_state.colorWriteMask = RHI_COLOR_COMPONENT_R_BIT | + RHI_COLOR_COMPONENT_G_BIT | + RHI_COLOR_COMPONENT_B_BIT | + RHI_COLOR_COMPONENT_A_BIT; + color_blend_attachment_state.blendEnable = RHI_FALSE; + color_blend_attachment_state.srcColorBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstColorBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.colorBlendOp = RHI_BLEND_OP_ADD; + color_blend_attachment_state.srcAlphaBlendFactor = RHI_BLEND_FACTOR_ONE; + color_blend_attachment_state.dstAlphaBlendFactor = RHI_BLEND_FACTOR_ZERO; + color_blend_attachment_state.alphaBlendOp = RHI_BLEND_OP_ADD; + + RHIPipelineColorBlendStateCreateInfo color_blend_state_create_info {}; + color_blend_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + color_blend_state_create_info.logicOpEnable = RHI_FALSE; + color_blend_state_create_info.logicOp = RHI_LOGIC_OP_COPY; color_blend_state_create_info.attachmentCount = 1; color_blend_state_create_info.pAttachments = &color_blend_attachment_state; color_blend_state_create_info.blendConstants[0] = 0.0f; @@ -145,23 +141,23 @@ namespace Piccolo color_blend_state_create_info.blendConstants[2] = 0.0f; color_blend_state_create_info.blendConstants[3] = 0.0f; - VkPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; - depth_stencil_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - depth_stencil_create_info.depthTestEnable = VK_TRUE; - depth_stencil_create_info.depthWriteEnable = VK_TRUE; - depth_stencil_create_info.depthCompareOp = VK_COMPARE_OP_LESS; - depth_stencil_create_info.depthBoundsTestEnable = VK_FALSE; - depth_stencil_create_info.stencilTestEnable = VK_FALSE; + RHIPipelineDepthStencilStateCreateInfo depth_stencil_create_info {}; + depth_stencil_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + depth_stencil_create_info.depthTestEnable = RHI_TRUE; + depth_stencil_create_info.depthWriteEnable = RHI_TRUE; + depth_stencil_create_info.depthCompareOp = RHI_COMPARE_OP_LESS; + depth_stencil_create_info.depthBoundsTestEnable = RHI_FALSE; + depth_stencil_create_info.stencilTestEnable = RHI_FALSE; - VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; + RHIDynamicState dynamic_states[] = {RHI_DYNAMIC_STATE_VIEWPORT, RHI_DYNAMIC_STATE_SCISSOR}; - VkPipelineDynamicStateCreateInfo dynamic_state_create_info {}; - dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + RHIPipelineDynamicStateCreateInfo dynamic_state_create_info {}; + dynamic_state_create_info.sType = RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamic_state_create_info.dynamicStateCount = 2; dynamic_state_create_info.pDynamicStates = dynamic_states; - VkGraphicsPipelineCreateInfo pipelineInfo {}; - pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + RHIGraphicsPipelineCreateInfo pipelineInfo {}; + pipelineInfo.sType = RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; pipelineInfo.pStages = shader_stages; pipelineInfo.pVertexInputState = &vertex_input_state_create_info; @@ -174,92 +170,78 @@ namespace Piccolo pipelineInfo.layout = m_render_pipelines[0].layout; pipelineInfo.renderPass = m_framebuffer.render_pass; pipelineInfo.subpass = _main_camera_subpass_tone_mapping; - pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; + pipelineInfo.basePipelineHandle = RHI_NULL_HANDLE; pipelineInfo.pDynamicState = &dynamic_state_create_info; - if (vkCreateGraphicsPipelines( - m_vulkan_rhi->m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_render_pipelines[0].pipeline) != - VK_SUCCESS) + if (RHI_SUCCESS != m_rhi->createGraphicsPipelines(RHI_NULL_HANDLE, 1, &pipelineInfo, m_render_pipelines[0].pipeline)) { throw std::runtime_error("create post process graphics pipeline"); } - vkDestroyShaderModule(m_vulkan_rhi->m_device, vert_shader_module, nullptr); - vkDestroyShaderModule(m_vulkan_rhi->m_device, frag_shader_module, nullptr); + m_rhi->destroyShaderModule(vert_shader_module); + m_rhi->destroyShaderModule(frag_shader_module); } void ToneMappingPass::setupDescriptorSet() { - VkDescriptorSetAllocateInfo post_process_global_descriptor_set_alloc_info; - post_process_global_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + RHIDescriptorSetAllocateInfo post_process_global_descriptor_set_alloc_info; + post_process_global_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; post_process_global_descriptor_set_alloc_info.pNext = NULL; - post_process_global_descriptor_set_alloc_info.descriptorPool = m_vulkan_rhi->m_descriptor_pool; + post_process_global_descriptor_set_alloc_info.descriptorPool = m_rhi->getDescriptorPoor(); post_process_global_descriptor_set_alloc_info.descriptorSetCount = 1; post_process_global_descriptor_set_alloc_info.pSetLayouts = &m_descriptor_infos[0].layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(m_vulkan_rhi->m_device, - &post_process_global_descriptor_set_alloc_info, - &m_descriptor_infos[0].descriptor_set)) + if (RHI_SUCCESS != m_rhi->allocateDescriptorSets(&post_process_global_descriptor_set_alloc_info, + m_descriptor_infos[0].descriptor_set)) { throw std::runtime_error("allocate post process global descriptor set"); } } - void ToneMappingPass::updateAfterFramebufferRecreate(VkImageView input_attachment) + void ToneMappingPass::updateAfterFramebufferRecreate(RHIImageView* input_attachment) { - VkDescriptorImageInfo post_process_per_frame_input_attachment_info = {}; - post_process_per_frame_input_attachment_info.sampler = - VulkanUtil::getOrCreateNearestSampler(m_vulkan_rhi->m_physical_device, m_vulkan_rhi->m_device); + RHIDescriptorImageInfo post_process_per_frame_input_attachment_info = {}; + post_process_per_frame_input_attachment_info.sampler = m_rhi->getOrCreateDefaultSampler(Default_Sampler_Nearest); post_process_per_frame_input_attachment_info.imageView = input_attachment; - post_process_per_frame_input_attachment_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + post_process_per_frame_input_attachment_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - VkWriteDescriptorSet post_process_descriptor_writes_info[1]; + RHIWriteDescriptorSet post_process_descriptor_writes_info[1]; - VkWriteDescriptorSet& post_process_descriptor_input_attachment_write_info = - post_process_descriptor_writes_info[0]; - post_process_descriptor_input_attachment_write_info.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + RHIWriteDescriptorSet& post_process_descriptor_input_attachment_write_info = post_process_descriptor_writes_info[0]; + post_process_descriptor_input_attachment_write_info.sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; post_process_descriptor_input_attachment_write_info.pNext = NULL; post_process_descriptor_input_attachment_write_info.dstSet = m_descriptor_infos[0].descriptor_set; post_process_descriptor_input_attachment_write_info.dstBinding = 0; post_process_descriptor_input_attachment_write_info.dstArrayElement = 0; - post_process_descriptor_input_attachment_write_info.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + post_process_descriptor_input_attachment_write_info.descriptorType = RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; post_process_descriptor_input_attachment_write_info.descriptorCount = 1; - post_process_descriptor_input_attachment_write_info.pImageInfo = &post_process_per_frame_input_attachment_info; - - vkUpdateDescriptorSets(m_vulkan_rhi->m_device, - sizeof(post_process_descriptor_writes_info) / - sizeof(post_process_descriptor_writes_info[0]), - post_process_descriptor_writes_info, - 0, - NULL); + post_process_descriptor_input_attachment_write_info.pImageInfo = &post_process_per_frame_input_attachment_info; + + m_rhi->updateDescriptorSets(sizeof(post_process_descriptor_writes_info) / + sizeof(post_process_descriptor_writes_info[0]), + post_process_descriptor_writes_info, + 0, + NULL); } void ToneMappingPass::draw() { - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, NULL, "Tone Map", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } - - m_vulkan_rhi->m_vk_cmd_bind_pipeline( - m_vulkan_rhi->m_current_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[0].pipeline); - m_vulkan_rhi->m_vk_cmd_set_viewport(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_viewport); - m_vulkan_rhi->m_vk_cmd_set_scissor(m_vulkan_rhi->m_current_command_buffer, 0, 1, &m_vulkan_rhi->m_scissor); - m_vulkan_rhi->m_vk_cmd_bind_descriptor_sets(m_vulkan_rhi->m_current_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - m_render_pipelines[0].layout, - 0, - 1, - &m_descriptor_infos[0].descriptor_set, - 0, - NULL); - - vkCmdDraw(m_vulkan_rhi->m_current_command_buffer, 3, 1, 0, 0); - - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "Tone Map", color); + + m_rhi->cmdBindPipelinePFN(m_rhi->getCurrentCommandBuffer(), RHI_PIPELINE_BIND_POINT_GRAPHICS, m_render_pipelines[0].pipeline); + m_rhi->cmdSetViewportPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().viewport); + m_rhi->cmdSetScissorPFN(m_rhi->getCurrentCommandBuffer(), 0, 1, m_rhi->getSwapchainInfo().scissor); + m_rhi->cmdBindDescriptorSetsPFN(m_rhi->getCurrentCommandBuffer(), + RHI_PIPELINE_BIND_POINT_GRAPHICS, + m_render_pipelines[0].layout, + 0, + 1, + &m_descriptor_infos[0].descriptor_set, + 0, + NULL); + + m_rhi->cmdDraw(m_rhi->getCurrentCommandBuffer(), 3, 1, 0, 0); + + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } } // namespace Piccolo diff --git a/engine/source/runtime/function/render/passes/tone_mapping_pass.h b/engine/source/runtime/function/render/passes/tone_mapping_pass.h index bbc0e5a72..68efc12d3 100644 --- a/engine/source/runtime/function/render/passes/tone_mapping_pass.h +++ b/engine/source/runtime/function/render/passes/tone_mapping_pass.h @@ -6,8 +6,8 @@ namespace Piccolo { struct ToneMappingPassInitInfo : RenderPassInitInfo { - VkRenderPass render_pass; - VkImageView input_attachment; + RHIRenderPass* render_pass; + RHIImageView* input_attachment; }; class ToneMappingPass : public RenderPass @@ -16,7 +16,7 @@ namespace Piccolo void initialize(const RenderPassInitInfo* init_info) override final; void draw() override final; - void updateAfterFramebufferRecreate(VkImageView input_attachment); + void updateAfterFramebufferRecreate(RHIImageView* input_attachment); private: void setupDescriptorSetLayout(); diff --git a/engine/source/runtime/function/render/passes/ui_pass.cpp b/engine/source/runtime/function/render/passes/ui_pass.cpp index f7d94ac17..0caef5c89 100644 --- a/engine/source/runtime/function/render/passes/ui_pass.cpp +++ b/engine/source/runtime/function/render/passes/ui_pass.cpp @@ -1,7 +1,7 @@ -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" - #include "runtime/function/render/passes/ui_pass.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" + #include "runtime/resource/config_manager/config_manager.h" #include "runtime/function/ui/window_ui.h" @@ -9,8 +9,6 @@ #include #include -#include - namespace Piccolo { void UIPass::initialize(const RenderPassInitInfo* init_info) @@ -24,64 +22,64 @@ namespace Piccolo { m_window_ui = window_ui; - ImGui_ImplGlfw_InitForVulkan(m_vulkan_rhi->m_window, true); + ImGui_ImplGlfw_InitForVulkan(std::static_pointer_cast(m_rhi)->m_window, true); ImGui_ImplVulkan_InitInfo init_info = {}; - init_info.Instance = m_vulkan_rhi->m_instance; - init_info.PhysicalDevice = m_vulkan_rhi->m_physical_device; - init_info.Device = m_vulkan_rhi->m_device; - init_info.QueueFamily = m_vulkan_rhi->m_queue_indices.m_graphics_family.value(); - init_info.Queue = m_vulkan_rhi->m_graphics_queue; - init_info.DescriptorPool = m_vulkan_rhi->m_descriptor_pool; + init_info.Instance = std::static_pointer_cast(m_rhi)->m_instance; + init_info.PhysicalDevice = std::static_pointer_cast(m_rhi)->m_physical_device; + init_info.Device = std::static_pointer_cast(m_rhi)->m_device; + init_info.QueueFamily = m_rhi->getQueueFamilyIndices().graphics_family.value(); + init_info.Queue = ((VulkanQueue*)m_rhi->getGraphicsQueue())->getResource(); + init_info.DescriptorPool = std::static_pointer_cast(m_rhi)->m_vk_descriptor_pool; init_info.Subpass = _main_camera_subpass_ui; - + // may be different from the real swapchain image count // see ImGui_ImplVulkanH_GetMinImageCountFromPresentMode init_info.MinImageCount = 3; init_info.ImageCount = 3; - ImGui_ImplVulkan_Init(&init_info, m_framebuffer.render_pass); + ImGui_ImplVulkan_Init(&init_info, ((VulkanRenderPass*)m_framebuffer.render_pass)->getResource()); uploadFonts(); } void UIPass::uploadFonts() { - VkCommandBufferAllocateInfo allocInfo = {}; - allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; - allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; - allocInfo.commandPool = m_vulkan_rhi->m_command_pool; + RHICommandBufferAllocateInfo allocInfo = {}; + allocInfo.sType = RHI_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.level = RHI_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandPool = m_rhi->getCommandPoor(); allocInfo.commandBufferCount = 1; - VkCommandBuffer commandBuffer = {}; - if (VK_SUCCESS != vkAllocateCommandBuffers(m_vulkan_rhi->m_device, &allocInfo, &commandBuffer)) + RHICommandBuffer* commandBuffer = new VulkanCommandBuffer(); + if (RHI_SUCCESS != m_rhi->allocateCommandBuffers(&allocInfo, commandBuffer)) { throw std::runtime_error("failed to allocate command buffers!"); } - VkCommandBufferBeginInfo beginInfo = {}; - beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; - beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + RHICommandBufferBeginInfo beginInfo = {}; + beginInfo.sType = RHI_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = RHI_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; - if (VK_SUCCESS != vkBeginCommandBuffer(commandBuffer, &beginInfo)) + if (RHI_SUCCESS != m_rhi->beginCommandBuffer(commandBuffer, &beginInfo)) { throw std::runtime_error("Could not create one-time command buffer!"); } - ImGui_ImplVulkan_CreateFontsTexture(commandBuffer); + ImGui_ImplVulkan_CreateFontsTexture(((VulkanCommandBuffer*)commandBuffer)->getResource()); - if (VK_SUCCESS != vkEndCommandBuffer(commandBuffer)) + if (RHI_SUCCESS != m_rhi->endCommandBuffer(commandBuffer)) { throw std::runtime_error("failed to record command buffer!"); } - VkSubmitInfo submitInfo {}; - submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + RHISubmitInfo submitInfo {}; + submitInfo.sType = RHI_STRUCTURE_TYPE_SUBMIT_INFO; submitInfo.commandBufferCount = 1; submitInfo.pCommandBuffers = &commandBuffer; - vkQueueSubmit(m_vulkan_rhi->m_graphics_queue, 1, &submitInfo, VK_NULL_HANDLE); - vkQueueWaitIdle(m_vulkan_rhi->m_graphics_queue); + m_rhi->queueSubmit(m_rhi->getGraphicsQueue(), 1, &submitInfo, RHI_NULL_HANDLE); + m_rhi->queueWaitIdle(m_rhi->getGraphicsQueue()); - vkFreeCommandBuffers(m_vulkan_rhi->m_device, m_vulkan_rhi->m_command_pool, 1, &commandBuffer); + m_rhi->freeCommandBuffers(m_rhi->getCommandPoor(), 1, commandBuffer); ImGui_ImplVulkan_DestroyFontUploadObjects(); } @@ -96,21 +94,14 @@ namespace Piccolo m_window_ui->preRender(); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - VkDebugUtilsLabelEXT label_info = { - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, nullptr, "ImGUI", {1.0f, 1.0f, 1.0f, 1.0f}}; - m_vulkan_rhi->m_vk_cmd_begin_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer, &label_info); - } + float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + m_rhi->pushEvent(m_rhi->getCurrentCommandBuffer(), "ImGUI", color); ImGui::Render(); - ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), m_vulkan_rhi->m_current_command_buffer); + ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), std::static_pointer_cast(m_rhi)->m_vk_current_command_buffer); - if (m_vulkan_rhi->isDebugLabelEnabled()) - { - m_vulkan_rhi->m_vk_cmd_end_debug_utils_label_ext(m_vulkan_rhi->m_current_command_buffer); - } + m_rhi->popEvent(m_rhi->getCurrentCommandBuffer()); } } } // namespace Piccolo diff --git a/engine/source/runtime/function/render/passes/ui_pass.h b/engine/source/runtime/function/render/passes/ui_pass.h index 7a8f37ced..cbffd15aa 100644 --- a/engine/source/runtime/function/render/passes/ui_pass.h +++ b/engine/source/runtime/function/render/passes/ui_pass.h @@ -8,7 +8,7 @@ namespace Piccolo struct UIPassInitInfo : RenderPassInitInfo { - VkRenderPass render_pass; + RHIRenderPass* render_pass; }; class UIPass : public RenderPass diff --git a/engine/source/runtime/function/render/render_common.h b/engine/source/runtime/function/render/render_common.h index 58e58b6a3..9cda39c34 100644 --- a/engine/source/runtime/function/render/render_common.h +++ b/engine/source/runtime/function/render/render_common.h @@ -5,6 +5,7 @@ #include "runtime/core/math/vector4.h" #include "runtime/function/render/render_type.h" +#include "interface/rhi.h" #include #include @@ -178,53 +179,53 @@ namespace Piccolo uint32_t mesh_vertex_count; - VkBuffer mesh_vertex_position_buffer; + RHIBuffer* mesh_vertex_position_buffer; VmaAllocation mesh_vertex_position_buffer_allocation; - VkBuffer mesh_vertex_varying_enable_blending_buffer; + RHIBuffer* mesh_vertex_varying_enable_blending_buffer; VmaAllocation mesh_vertex_varying_enable_blending_buffer_allocation; - VkBuffer mesh_vertex_joint_binding_buffer; + RHIBuffer* mesh_vertex_joint_binding_buffer; VmaAllocation mesh_vertex_joint_binding_buffer_allocation; - VkDescriptorSet mesh_vertex_blending_descriptor_set; + RHIDescriptorSet* mesh_vertex_blending_descriptor_set; - VkBuffer mesh_vertex_varying_buffer; + RHIBuffer* mesh_vertex_varying_buffer; VmaAllocation mesh_vertex_varying_buffer_allocation; uint32_t mesh_index_count; - VkBuffer mesh_index_buffer; + RHIBuffer* mesh_index_buffer; VmaAllocation mesh_index_buffer_allocation; }; // material struct VulkanPBRMaterial { - VkImage base_color_texture_image = VK_NULL_HANDLE; - VkImageView base_color_image_view = VK_NULL_HANDLE; - VmaAllocation base_color_image_allocation; + RHIImage* base_color_texture_image; + RHIImageView* base_color_image_view; + VmaAllocation base_color_image_allocation; - VkImage metallic_roughness_texture_image = VK_NULL_HANDLE; - VkImageView metallic_roughness_image_view = VK_NULL_HANDLE; - VmaAllocation metallic_roughness_image_allocation; + RHIImage* metallic_roughness_texture_image; + RHIImageView* metallic_roughness_image_view; + VmaAllocation metallic_roughness_image_allocation; - VkImage normal_texture_image = VK_NULL_HANDLE; - VkImageView normal_image_view = VK_NULL_HANDLE; - VmaAllocation normal_image_allocation; + RHIImage* normal_texture_image; + RHIImageView* normal_image_view; + VmaAllocation normal_image_allocation; - VkImage occlusion_texture_image = VK_NULL_HANDLE; - VkImageView occlusion_image_view = VK_NULL_HANDLE; - VmaAllocation occlusion_image_allocation; + RHIImage* occlusion_texture_image; + RHIImageView* occlusion_image_view; + VmaAllocation occlusion_image_allocation; - VkImage emissive_texture_image = VK_NULL_HANDLE; - VkImageView emissive_image_view = VK_NULL_HANDLE; - VmaAllocation emissive_image_allocation; + RHIImage* emissive_texture_image; + RHIImageView* emissive_image_view; + VmaAllocation emissive_image_allocation; - VkBuffer material_uniform_buffer; - VmaAllocation material_uniform_buffer_allocation; + RHIBuffer* material_uniform_buffer; + VmaAllocation material_uniform_buffer_allocation; - VkDescriptorSet material_descriptor_set; + RHIDescriptorSet* material_descriptor_set; }; // nodes @@ -249,26 +250,26 @@ namespace Piccolo struct TextureDataToUpdate { - void* base_color_image_pixels; - uint32_t base_color_image_width; - uint32_t base_color_image_height; - PICCOLO_PIXEL_FORMAT base_color_image_format; - void* metallic_roughness_image_pixels; - uint32_t metallic_roughness_image_width; - uint32_t metallic_roughness_image_height; - PICCOLO_PIXEL_FORMAT metallic_roughness_image_format; - void* normal_roughness_image_pixels; - uint32_t normal_roughness_image_width; - uint32_t normal_roughness_image_height; - PICCOLO_PIXEL_FORMAT normal_roughness_image_format; - void* occlusion_image_pixels; - uint32_t occlusion_image_width; - uint32_t occlusion_image_height; - PICCOLO_PIXEL_FORMAT occlusion_image_format; - void* emissive_image_pixels; - uint32_t emissive_image_width; - uint32_t emissive_image_height; - PICCOLO_PIXEL_FORMAT emissive_image_format; - VulkanPBRMaterial* now_material; + void* base_color_image_pixels; + uint32_t base_color_image_width; + uint32_t base_color_image_height; + RHIFormat base_color_image_format; + void* metallic_roughness_image_pixels; + uint32_t metallic_roughness_image_width; + uint32_t metallic_roughness_image_height; + RHIFormat metallic_roughness_image_format; + void* normal_roughness_image_pixels; + uint32_t normal_roughness_image_width; + uint32_t normal_roughness_image_height; + RHIFormat normal_roughness_image_format; + void* occlusion_image_pixels; + uint32_t occlusion_image_width; + uint32_t occlusion_image_height; + RHIFormat occlusion_image_format; + void* emissive_image_pixels; + uint32_t emissive_image_width; + uint32_t emissive_image_height; + RHIFormat emissive_image_format; + VulkanPBRMaterial* now_material; }; } // namespace Piccolo diff --git a/engine/source/runtime/function/render/render_debug_config.h b/engine/source/runtime/function/render/render_debug_config.h new file mode 100644 index 000000000..7d8e2dfa8 --- /dev/null +++ b/engine/source/runtime/function/render/render_debug_config.h @@ -0,0 +1,24 @@ +namespace Piccolo +{ + class RenderDebugConfig + { + public: + struct Animation + { + bool show_skeleton = false; + bool show_bone_name = false; + }; + struct Camera + { + bool show_runtime_info = false; + }; + struct GameObject + { + bool show_bounding_box = false; + }; + + Animation animation; + Camera camera; + GameObject gameObject; + }; +} \ No newline at end of file diff --git a/engine/source/runtime/function/render/render_mesh.h b/engine/source/runtime/function/render/render_mesh.h index ae08cd142..20d553cf8 100644 --- a/engine/source/runtime/function/render/render_mesh.h +++ b/engine/source/runtime/function/render/render_mesh.h @@ -5,7 +5,7 @@ #include "runtime/core/math/vector4.h" #include -#include +#include "interface/rhi.h" namespace Piccolo { @@ -33,49 +33,49 @@ namespace Piccolo Vector4 weights; }; - static std::array getBindingDescriptions() + static std::array getBindingDescriptions() { - std::array binding_descriptions {}; + std::array binding_descriptions {}; // position binding_descriptions[0].binding = 0; binding_descriptions[0].stride = sizeof(VulkanMeshVertexPostition); - binding_descriptions[0].inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + binding_descriptions[0].inputRate = RHI_VERTEX_INPUT_RATE_VERTEX; // varying blending binding_descriptions[1].binding = 1; binding_descriptions[1].stride = sizeof(VulkanMeshVertexVaryingEnableBlending); - binding_descriptions[1].inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + binding_descriptions[1].inputRate = RHI_VERTEX_INPUT_RATE_VERTEX; // varying binding_descriptions[2].binding = 2; binding_descriptions[2].stride = sizeof(VulkanMeshVertexVarying); - binding_descriptions[2].inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + binding_descriptions[2].inputRate = RHI_VERTEX_INPUT_RATE_VERTEX; return binding_descriptions; } - static std::array getAttributeDescriptions() + static std::array getAttributeDescriptions() { - std::array attribute_descriptions {}; + std::array attribute_descriptions {}; // position attribute_descriptions[0].binding = 0; attribute_descriptions[0].location = 0; - attribute_descriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT; + attribute_descriptions[0].format = RHI_FORMAT_R32G32B32_SFLOAT; attribute_descriptions[0].offset = offsetof(VulkanMeshVertexPostition, position); // varying blending attribute_descriptions[1].binding = 1; attribute_descriptions[1].location = 1; - attribute_descriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT; + attribute_descriptions[1].format = RHI_FORMAT_R32G32B32_SFLOAT; attribute_descriptions[1].offset = offsetof(VulkanMeshVertexVaryingEnableBlending, normal); attribute_descriptions[2].binding = 1; attribute_descriptions[2].location = 2; - attribute_descriptions[2].format = VK_FORMAT_R32G32B32_SFLOAT; + attribute_descriptions[2].format = RHI_FORMAT_R32G32B32_SFLOAT; attribute_descriptions[2].offset = offsetof(VulkanMeshVertexVaryingEnableBlending, tangent); // varying attribute_descriptions[3].binding = 2; attribute_descriptions[3].location = 3; - attribute_descriptions[3].format = VK_FORMAT_R32G32_SFLOAT; + attribute_descriptions[3].format = RHI_FORMAT_R32G32_SFLOAT; attribute_descriptions[3].offset = offsetof(VulkanMeshVertexVarying, texcoord); return attribute_descriptions; diff --git a/engine/source/runtime/function/render/render_pass.cpp b/engine/source/runtime/function/render/render_pass.cpp index 11af73b7e..b6aa6940d 100644 --- a/engine/source/runtime/function/render/render_pass.cpp +++ b/engine/source/runtime/function/render/render_pass.cpp @@ -3,7 +3,7 @@ #include "runtime/core/base/macro.h" #include "runtime/function/render/render_resource.h" -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" Piccolo::VisiableNodes Piccolo::RenderPass::m_visiable_nodes; @@ -11,7 +11,6 @@ namespace Piccolo { void RenderPass::initialize(const RenderPassInitInfo* init_info) { - m_vulkan_rhi = std::static_pointer_cast(m_rhi); m_global_render_resource = &(std::static_pointer_cast(m_render_resource)->m_global_render_resource); } @@ -19,11 +18,11 @@ namespace Piccolo void RenderPass::postInitialize() {} - VkRenderPass RenderPass::getRenderPass() const { return m_framebuffer.render_pass; } + RHIRenderPass* RenderPass::getRenderPass() const { return m_framebuffer.render_pass; } - std::vector RenderPass::getFramebufferImageViews() const + std::vector RenderPass::getFramebufferImageViews() const { - std::vector image_views; + std::vector image_views; for (auto& attach : m_framebuffer.attachments) { image_views.push_back(attach.view); @@ -31,9 +30,9 @@ namespace Piccolo return image_views; } - std::vector RenderPass::getDescriptorSetLayouts() const + std::vector RenderPass::getDescriptorSetLayouts() const { - std::vector layouts; + std::vector layouts; for (auto& desc : m_descriptor_infos) { layouts.push_back(desc.layout); diff --git a/engine/source/runtime/function/render/render_pass.h b/engine/source/runtime/function/render/render_pass.h index 1d8e5d56e..d0c2ba2f3 100644 --- a/engine/source/runtime/function/render/render_pass.h +++ b/engine/source/runtime/function/render/render_pass.h @@ -55,35 +55,34 @@ namespace Piccolo public: struct FrameBufferAttachment { - VkImage image; - VkDeviceMemory mem; - VkImageView view; - VkFormat format; + RHIImage* image; + RHIDeviceMemory* mem; + RHIImageView* view; + RHIFormat format; }; struct Framebuffer { int width; int height; - VkFramebuffer framebuffer; - VkRenderPass render_pass; + RHIFramebuffer* framebuffer; + RHIRenderPass* render_pass; std::vector attachments; }; struct Descriptor { - VkDescriptorSetLayout layout; - VkDescriptorSet descriptor_set; + RHIDescriptorSetLayout* layout; + RHIDescriptorSet* descriptor_set; }; struct RenderPipelineBase { - VkPipelineLayout layout; - VkPipeline pipeline; + RHIPipelineLayout* layout; + RHIPipeline* pipeline; }; - std::shared_ptr m_vulkan_rhi {nullptr}; GlobalRenderResource* m_global_render_resource {nullptr}; std::vector m_descriptor_infos; @@ -95,9 +94,9 @@ namespace Piccolo virtual void draw(); - virtual VkRenderPass getRenderPass() const; - virtual std::vector getFramebufferImageViews() const; - virtual std::vector getDescriptorSetLayouts() const; + virtual RHIRenderPass* getRenderPass() const; + virtual std::vector getFramebufferImageViews() const; + virtual std::vector getDescriptorSetLayouts() const; static VisiableNodes m_visiable_nodes; diff --git a/engine/source/runtime/function/render/render_pass_base.h b/engine/source/runtime/function/render/render_pass_base.h index 709973ac2..a2afd7b85 100644 --- a/engine/source/runtime/function/render/render_pass_base.h +++ b/engine/source/runtime/function/render/render_pass_base.h @@ -1,6 +1,6 @@ #pragma once -#include "runtime/function/render/rhi.h" +#include "runtime/function/render/interface/rhi.h" namespace Piccolo { diff --git a/engine/source/runtime/function/render/render_pipeline.cpp b/engine/source/runtime/function/render/render_pipeline.cpp index 06a2ed4f8..4b9f3f076 100644 --- a/engine/source/runtime/function/render/render_pipeline.cpp +++ b/engine/source/runtime/function/render/render_pipeline.cpp @@ -1,5 +1,5 @@ #include "runtime/function/render/render_pipeline.h" -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" #include "runtime/function/render/passes/color_grading_pass.h" #include "runtime/function/render/passes/combine_ui_pass.h" @@ -11,6 +11,8 @@ #include "runtime/function/render/passes/ui_pass.h" #include "runtime/function/render/passes/particle_pass.h" +#include "runtime/function/render/debugdraw/debug_draw_manager.h" + #include "runtime/core/base/macro.h" namespace Piccolo @@ -66,7 +68,7 @@ namespace Piccolo std::static_pointer_cast(m_particle_pass)->setupParticlePass(); - std::vector descriptor_layouts = _main_camera_pass->getDescriptorSetLayouts(); + std::vector descriptor_layouts = _main_camera_pass->getDescriptorSetLayouts(); std::static_pointer_cast(m_point_light_shadow_pass) ->setPerMeshLayout(descriptor_layouts[MainCameraPass::LayoutType::_per_mesh]); std::static_pointer_cast(m_directional_light_pass) @@ -153,6 +155,9 @@ namespace Piccolo particle_pass, vulkan_rhi->m_current_swapchain_image_index); + + g_runtime_global_context.m_debugdraw_manager->draw(vulkan_rhi->m_current_swapchain_image_index); + vulkan_rhi->submitRendering(std::bind(&RenderPipeline::passUpdateAfterRecreateSwapchain, this)); static_cast(m_particle_pass.get())->copyNormalAndDepthImage(); static_cast(m_particle_pass.get())->simulate(); @@ -199,6 +204,8 @@ namespace Piccolo combine_ui_pass, particle_pass, vulkan_rhi->m_current_swapchain_image_index); + + g_runtime_global_context.m_debugdraw_manager->draw(vulkan_rhi->m_current_swapchain_image_index); vulkan_rhi->submitRendering(std::bind(&RenderPipeline::passUpdateAfterRecreateSwapchain, this)); static_cast(m_particle_pass.get())->copyNormalAndDepthImage(); @@ -227,6 +234,7 @@ namespace Piccolo main_camera_pass.getFramebufferImageViews()[_main_camera_pass_backup_buffer_even]); pick_pass.recreateFramebuffer(); particle_pass.updateAfterFramebufferRecreate(); + g_runtime_global_context.m_debugdraw_manager->updateAfterRecreateSwapchain(); } uint32_t RenderPipeline::getGuidOfPickedMesh(const Vector2& picked_uv) { diff --git a/engine/source/runtime/function/render/render_pipeline_base.cpp b/engine/source/runtime/function/render/render_pipeline_base.cpp index d93dd36ea..10be414eb 100644 --- a/engine/source/runtime/function/render/render_pipeline_base.cpp +++ b/engine/source/runtime/function/render/render_pipeline_base.cpp @@ -1,6 +1,7 @@ #include "runtime/function/render/render_pipeline_base.h" - +#include "runtime/function/render/debugdraw/debug_draw_manager.h" #include "runtime/core/base/macro.h" +#include "runtime/function/global/global_context.h" namespace Piccolo { @@ -11,6 +12,7 @@ namespace Piccolo m_directional_light_pass->preparePassData(render_resource); m_point_light_shadow_pass->preparePassData(render_resource); m_particle_pass->preparePassData(render_resource); + g_runtime_global_context.m_debugdraw_manager->preparePassData(render_resource); } void RenderPipelineBase::forwardRender(std::shared_ptr rhi, std::shared_ptr render_resource) diff --git a/engine/source/runtime/function/render/render_pipeline_base.h b/engine/source/runtime/function/render/render_pipeline_base.h index 2a1cb269a..756289900 100644 --- a/engine/source/runtime/function/render/render_pipeline_base.h +++ b/engine/source/runtime/function/render/render_pipeline_base.h @@ -25,6 +25,8 @@ namespace Piccolo public: virtual ~RenderPipelineBase() {} + virtual void clear() {}; + virtual void initialize(RenderPipelineInitInfo init_info) = 0; virtual void preparePassData(std::shared_ptr render_resource); diff --git a/engine/source/runtime/function/render/render_resource.cpp b/engine/source/runtime/function/render/render_resource.cpp index 6d69f6a5c..8f8ac52b3 100644 --- a/engine/source/runtime/function/render/render_resource.cpp +++ b/engine/source/runtime/function/render/render_resource.cpp @@ -1,10 +1,11 @@ +#include "runtime/function/render/render_resource.h" + #include "runtime/function/render/render_camera.h" #include "runtime/function/render/render_helper.h" #include "runtime/function/render/render_mesh.h" -#include "runtime/function/render/render_resource.h" -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_util.h" #include "runtime/function/render/passes/main_camera_pass.h" @@ -14,6 +15,10 @@ namespace Piccolo { + void RenderResource::clear() + { + } + void RenderResource::uploadGlobalRenderResource(std::shared_ptr rhi, LevelResourceDesc level_resource_desc) { // create and map global storage buffer @@ -59,57 +64,55 @@ namespace Piccolo createIBLTextures(rhi, irradiance_maps, specular_maps); // create brdf lut texture - VulkanUtil::createGlobalImage(rhi.get(), - m_global_render_resource._ibl_resource._brdfLUT_texture_image, - m_global_render_resource._ibl_resource._brdfLUT_texture_image_view, - m_global_render_resource._ibl_resource._brdfLUT_texture_image_allocation, - brdf_map->m_width, - brdf_map->m_height, - brdf_map->m_pixels, - brdf_map->m_format); + rhi->createGlobalImage( + m_global_render_resource._ibl_resource._brdfLUT_texture_image, + m_global_render_resource._ibl_resource._brdfLUT_texture_image_view, + m_global_render_resource._ibl_resource._brdfLUT_texture_image_allocation, + brdf_map->m_width, + brdf_map->m_height, + brdf_map->m_pixels, + brdf_map->m_format); // color grading std::shared_ptr color_grading_map = loadTexture(level_resource_desc.m_color_grading_resource_desc.m_color_grading_map); // create color grading texture - VulkanUtil::createGlobalImage( - rhi.get(), + rhi->createGlobalImage( m_global_render_resource._color_grading_resource._color_grading_LUT_texture_image, m_global_render_resource._color_grading_resource._color_grading_LUT_texture_image_view, m_global_render_resource._color_grading_resource._color_grading_LUT_texture_image_allocation, color_grading_map->m_width, color_grading_map->m_height, color_grading_map->m_pixels, - color_grading_map->m_format, - 1); + color_grading_map->m_format); } void RenderResource::uploadGameObjectRenderResource(std::shared_ptr rhi, - RenderEntity render_entity, - RenderMeshData mesh_data, - RenderMaterialData material_data) + RenderEntity render_entity, + RenderMeshData mesh_data, + RenderMaterialData material_data) { getOrCreateVulkanMesh(rhi, render_entity, mesh_data); getOrCreateVulkanMaterial(rhi, render_entity, material_data); } void RenderResource::uploadGameObjectRenderResource(std::shared_ptr rhi, - RenderEntity render_entity, - RenderMeshData mesh_data) + RenderEntity render_entity, + RenderMeshData mesh_data) { getOrCreateVulkanMesh(rhi, render_entity, mesh_data); } void RenderResource::uploadGameObjectRenderResource(std::shared_ptr rhi, - RenderEntity render_entity, - RenderMaterialData material_data) + RenderEntity render_entity, + RenderMaterialData material_data) { getOrCreateVulkanMaterial(rhi, render_entity, material_data); } void RenderResource::updatePerFrameBuffer(std::shared_ptr render_scene, - std::shared_ptr camera) + std::shared_ptr camera) { Matrix4x4 view_matrix = camera->getViewMatrix(); Matrix4x4 proj_matrix = camera->getPersProjMatrix(); @@ -117,7 +120,7 @@ namespace Piccolo Matrix4x4 proj_view_matrix = proj_matrix * view_matrix; // ambient light - Vector3 ambient_light = render_scene->m_ambient_light.m_irradiance; + Vector3 ambient_light = render_scene->m_ambient_light.m_irradiance; uint32_t point_light_num = static_cast(render_scene->m_point_light_list.m_lights.size()); // set ubo data @@ -167,118 +170,106 @@ namespace Piccolo { VulkanRHI* raw_rhi = static_cast(rhi.get()); - VkPhysicalDeviceProperties physical_device_properties {}; - vkGetPhysicalDeviceProperties(raw_rhi->m_physical_device, &physical_device_properties); - - VkSamplerCreateInfo samplerInfo {}; - samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; - samplerInfo.magFilter = VK_FILTER_LINEAR; - samplerInfo.minFilter = VK_FILTER_LINEAR; - samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; - samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; - samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; - samplerInfo.anisotropyEnable = VK_TRUE; // close:false - samplerInfo.maxAnisotropy = physical_device_properties.limits.maxSamplerAnisotropy; // close :1.0f - samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK; - samplerInfo.unnormalizedCoordinates = VK_FALSE; - samplerInfo.compareEnable = VK_FALSE; - samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS; - samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; - samplerInfo.maxLod = 0.0f; - - if (m_global_render_resource._ibl_resource._brdfLUT_texture_sampler != VK_NULL_HANDLE) + RHIPhysicalDeviceProperties physical_device_properties{}; + rhi->getPhysicalDeviceProperties(&physical_device_properties); + + RHISamplerCreateInfo samplerInfo{}; + samplerInfo.sType = RHI_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; + samplerInfo.magFilter = RHI_FILTER_LINEAR; + samplerInfo.minFilter = RHI_FILTER_LINEAR; + samplerInfo.addressModeU = RHI_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + samplerInfo.addressModeV = RHI_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + samplerInfo.addressModeW = RHI_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + samplerInfo.anisotropyEnable = RHI_TRUE; // close:false + samplerInfo.maxAnisotropy = physical_device_properties.limits.maxSamplerAnisotropy; // close :1.0f + samplerInfo.borderColor = RHI_BORDER_COLOR_INT_OPAQUE_BLACK; + samplerInfo.unnormalizedCoordinates = RHI_FALSE; + samplerInfo.compareEnable = RHI_FALSE; + samplerInfo.compareOp = RHI_COMPARE_OP_ALWAYS; + samplerInfo.mipmapMode = RHI_SAMPLER_MIPMAP_MODE_LINEAR; + samplerInfo.maxLod = 0.0f; + + if (m_global_render_resource._ibl_resource._brdfLUT_texture_sampler != RHI_NULL_HANDLE) { - vkDestroySampler( - raw_rhi->m_device, m_global_render_resource._ibl_resource._brdfLUT_texture_sampler, nullptr); + rhi->destroySampler(m_global_render_resource._ibl_resource._brdfLUT_texture_sampler); } - if (vkCreateSampler(raw_rhi->m_device, - &samplerInfo, - nullptr, - &m_global_render_resource._ibl_resource._brdfLUT_texture_sampler) != VK_SUCCESS) + if (rhi->createSampler(&samplerInfo, m_global_render_resource._ibl_resource._brdfLUT_texture_sampler) != RHI_SUCCESS) { throw std::runtime_error("vk create sampler"); } - samplerInfo.minLod = 0.0f; - samplerInfo.maxLod = 8.0f; // TODO: irradiance_texture_miplevels + samplerInfo.minLod = 0.0f; + samplerInfo.maxLod = 8.0f; // TODO: irradiance_texture_miplevels samplerInfo.mipLodBias = 0.0f; - if (m_global_render_resource._ibl_resource._irradiance_texture_sampler != VK_NULL_HANDLE) + if (m_global_render_resource._ibl_resource._irradiance_texture_sampler != RHI_NULL_HANDLE) { - vkDestroySampler( - raw_rhi->m_device, m_global_render_resource._ibl_resource._irradiance_texture_sampler, nullptr); + rhi->destroySampler(m_global_render_resource._ibl_resource._irradiance_texture_sampler); } - if (vkCreateSampler(raw_rhi->m_device, - &samplerInfo, - nullptr, - &m_global_render_resource._ibl_resource._irradiance_texture_sampler) != VK_SUCCESS) + if (rhi->createSampler(&samplerInfo, m_global_render_resource._ibl_resource._irradiance_texture_sampler) != RHI_SUCCESS) { throw std::runtime_error("vk create sampler"); } - if (m_global_render_resource._ibl_resource._specular_texture_sampler != VK_NULL_HANDLE) + if (m_global_render_resource._ibl_resource._specular_texture_sampler != RHI_NULL_HANDLE) { - vkDestroySampler( - raw_rhi->m_device, m_global_render_resource._ibl_resource._specular_texture_sampler, nullptr); + rhi->destroySampler(m_global_render_resource._ibl_resource._specular_texture_sampler); } - if (vkCreateSampler(raw_rhi->m_device, - &samplerInfo, - nullptr, - &m_global_render_resource._ibl_resource._specular_texture_sampler) != VK_SUCCESS) + if (rhi->createSampler(&samplerInfo, m_global_render_resource._ibl_resource._specular_texture_sampler) != RHI_SUCCESS) { throw std::runtime_error("vk create sampler"); } } void RenderResource::createIBLTextures(std::shared_ptr rhi, - std::array, 6> irradiance_maps, - std::array, 6> specular_maps) + std::array, 6> irradiance_maps, + std::array, 6> specular_maps) { // assume all textures have same width, height and format uint32_t irradiance_cubemap_miplevels = static_cast( - std::floor(std::log2(std::max(irradiance_maps[0]->m_width, irradiance_maps[0]->m_height)))) + + std::floor(log2(std::max(irradiance_maps[0]->m_width, irradiance_maps[0]->m_height)))) + 1; - VulkanUtil::createCubeMap(rhi.get(), - m_global_render_resource._ibl_resource._irradiance_texture_image, - m_global_render_resource._ibl_resource._irradiance_texture_image_view, - m_global_render_resource._ibl_resource._irradiance_texture_image_allocation, - irradiance_maps[0]->m_width, - irradiance_maps[0]->m_height, - {irradiance_maps[0]->m_pixels, - irradiance_maps[1]->m_pixels, - irradiance_maps[2]->m_pixels, - irradiance_maps[3]->m_pixels, - irradiance_maps[4]->m_pixels, - irradiance_maps[5]->m_pixels}, - irradiance_maps[0]->m_format, - irradiance_cubemap_miplevels); + rhi->createCubeMap( + m_global_render_resource._ibl_resource._irradiance_texture_image, + m_global_render_resource._ibl_resource._irradiance_texture_image_view, + m_global_render_resource._ibl_resource._irradiance_texture_image_allocation, + irradiance_maps[0]->m_width, + irradiance_maps[0]->m_height, + { irradiance_maps[0]->m_pixels, + irradiance_maps[1]->m_pixels, + irradiance_maps[2]->m_pixels, + irradiance_maps[3]->m_pixels, + irradiance_maps[4]->m_pixels, + irradiance_maps[5]->m_pixels }, + irradiance_maps[0]->m_format, + irradiance_cubemap_miplevels); uint32_t specular_cubemap_miplevels = static_cast( - std::floor(std::log2(std::max(specular_maps[0]->m_width, specular_maps[0]->m_height)))) + + std::floor(log2(std::max(specular_maps[0]->m_width, specular_maps[0]->m_height)))) + 1; - VulkanUtil::createCubeMap(rhi.get(), - m_global_render_resource._ibl_resource._specular_texture_image, - m_global_render_resource._ibl_resource._specular_texture_image_view, - m_global_render_resource._ibl_resource._specular_texture_image_allocation, - specular_maps[0]->m_width, - specular_maps[0]->m_height, - {specular_maps[0]->m_pixels, - specular_maps[1]->m_pixels, - specular_maps[2]->m_pixels, - specular_maps[3]->m_pixels, - specular_maps[4]->m_pixels, - specular_maps[5]->m_pixels}, - specular_maps[0]->m_format, - specular_cubemap_miplevels); + rhi->createCubeMap( + m_global_render_resource._ibl_resource._specular_texture_image, + m_global_render_resource._ibl_resource._specular_texture_image_view, + m_global_render_resource._ibl_resource._specular_texture_image_allocation, + specular_maps[0]->m_width, + specular_maps[0]->m_height, + { specular_maps[0]->m_pixels, + specular_maps[1]->m_pixels, + specular_maps[2]->m_pixels, + specular_maps[3]->m_pixels, + specular_maps[4]->m_pixels, + specular_maps[5]->m_pixels }, + specular_maps[0]->m_format, + specular_cubemap_miplevels); } VulkanMesh& - RenderResource::getOrCreateVulkanMesh(std::shared_ptr rhi, RenderEntity entity, RenderMeshData mesh_data) + RenderResource::getOrCreateVulkanMesh(std::shared_ptr rhi, RenderEntity entity, RenderMeshData mesh_data) { size_t assetid = entity.m_mesh_asset_id; @@ -294,7 +285,7 @@ namespace Piccolo assert(res.second); uint32_t index_buffer_size = static_cast(mesh_data.m_static_mesh_data.m_index_buffer->m_size); - void* index_buffer_data = mesh_data.m_static_mesh_data.m_index_buffer->m_data; + void* index_buffer_data = mesh_data.m_static_mesh_data.m_index_buffer->m_data; uint32_t vertex_buffer_size = static_cast(mesh_data.m_static_mesh_data.m_vertex_buffer->m_size); MeshVertexDataDefinition* vertex_buffer_data = @@ -335,8 +326,8 @@ namespace Piccolo } VulkanPBRMaterial& RenderResource::getOrCreateVulkanMaterial(std::shared_ptr rhi, - RenderEntity entity, - RenderMaterialData material_data) + RenderEntity entity, + RenderMaterialData material_data) { VulkanRHI* vulkan_context = static_cast(rhi.get()); @@ -353,60 +344,60 @@ namespace Piccolo auto res = m_vulkan_pbr_materials.insert(std::make_pair(assetid, std::move(temp))); assert(res.second); - float empty_image[] = {0.5f, 0.5f, 0.5f, 0.5f}; + float empty_image[] = { 0.5f, 0.5f, 0.5f, 0.5f }; - void* base_color_image_pixels = empty_image; - uint32_t base_color_image_width = 1; + void* base_color_image_pixels = empty_image; + uint32_t base_color_image_width = 1; uint32_t base_color_image_height = 1; - PICCOLO_PIXEL_FORMAT base_color_image_format = PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8A8_SRGB; + RHIFormat base_color_image_format = RHIFormat::RHI_FORMAT_R8G8B8A8_SRGB; if (material_data.m_base_color_texture) { base_color_image_pixels = material_data.m_base_color_texture->m_pixels; - base_color_image_width = static_cast(material_data.m_base_color_texture->m_width); + base_color_image_width = static_cast(material_data.m_base_color_texture->m_width); base_color_image_height = static_cast(material_data.m_base_color_texture->m_height); base_color_image_format = material_data.m_base_color_texture->m_format; } - void* metallic_roughness_image_pixels = empty_image; - uint32_t metallic_roughness_width = 1; - uint32_t metallic_roughness_height = 1; - PICCOLO_PIXEL_FORMAT metallic_roughness_format = PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8A8_UNORM; + void* metallic_roughness_image_pixels = empty_image; + uint32_t metallic_roughness_width = 1; + uint32_t metallic_roughness_height = 1; + RHIFormat metallic_roughness_format = RHIFormat::RHI_FORMAT_R8G8B8A8_UNORM; if (material_data.m_metallic_roughness_texture) { metallic_roughness_image_pixels = material_data.m_metallic_roughness_texture->m_pixels; - metallic_roughness_width = static_cast(material_data.m_metallic_roughness_texture->m_width); + metallic_roughness_width = static_cast(material_data.m_metallic_roughness_texture->m_width); metallic_roughness_height = static_cast(material_data.m_metallic_roughness_texture->m_height); metallic_roughness_format = material_data.m_metallic_roughness_texture->m_format; } - void* normal_roughness_image_pixels = empty_image; - uint32_t normal_roughness_width = 1; - uint32_t normal_roughness_height = 1; - PICCOLO_PIXEL_FORMAT normal_roughness_format = PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8A8_UNORM; + void* normal_roughness_image_pixels = empty_image; + uint32_t normal_roughness_width = 1; + uint32_t normal_roughness_height = 1; + RHIFormat normal_roughness_format = RHIFormat::RHI_FORMAT_R8G8B8A8_UNORM; if (material_data.m_normal_texture) { normal_roughness_image_pixels = material_data.m_normal_texture->m_pixels; - normal_roughness_width = static_cast(material_data.m_normal_texture->m_width); - normal_roughness_height = static_cast(material_data.m_normal_texture->m_height); - normal_roughness_format = material_data.m_normal_texture->m_format; + normal_roughness_width = static_cast(material_data.m_normal_texture->m_width); + normal_roughness_height = static_cast(material_data.m_normal_texture->m_height); + normal_roughness_format = material_data.m_normal_texture->m_format; } - void* occlusion_image_pixels = empty_image; - uint32_t occlusion_image_width = 1; + void* occlusion_image_pixels = empty_image; + uint32_t occlusion_image_width = 1; uint32_t occlusion_image_height = 1; - PICCOLO_PIXEL_FORMAT occlusion_image_format = PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8A8_UNORM; + RHIFormat occlusion_image_format = RHIFormat::RHI_FORMAT_R8G8B8A8_UNORM; if (material_data.m_occlusion_texture) { occlusion_image_pixels = material_data.m_occlusion_texture->m_pixels; - occlusion_image_width = static_cast(material_data.m_occlusion_texture->m_width); + occlusion_image_width = static_cast(material_data.m_occlusion_texture->m_width); occlusion_image_height = static_cast(material_data.m_occlusion_texture->m_height); occlusion_image_format = material_data.m_occlusion_texture->m_format; } - void* emissive_image_pixels = empty_image; - uint32_t emissive_image_width = 1; + void* emissive_image_pixels = empty_image; + uint32_t emissive_image_width = 1; uint32_t emissive_image_height = 1; - PICCOLO_PIXEL_FORMAT emissive_image_format = PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8A8_UNORM; + RHIFormat emissive_image_format = RHIFormat::RHI_FORMAT_R8G8B8A8_UNORM; if (material_data.m_emissive_texture) { emissive_image_pixels = material_data.m_emissive_texture->m_pixels; @@ -422,65 +413,64 @@ namespace Piccolo // data { // temporary staging buffer - VkDeviceSize buffer_size = sizeof(MeshPerMaterialUniformBufferObject); - - VkBuffer inefficient_staging_buffer = VK_NULL_HANDLE; - VkDeviceMemory inefficient_staging_buffer_memory = VK_NULL_HANDLE; - VulkanUtil::createBuffer(vulkan_context->m_physical_device, - vulkan_context->m_device, - buffer_size, - VK_BUFFER_USAGE_TRANSFER_SRC_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - inefficient_staging_buffer, - inefficient_staging_buffer_memory); - // VK_BUFFER_USAGE_TRANSFER_SRC_BIT: buffer can be used as source in a + + RHIDeviceSize buffer_size = sizeof(MeshPerMaterialUniformBufferObject); + + RHIBuffer* inefficient_staging_buffer = RHI_NULL_HANDLE; + RHIDeviceMemory* inefficient_staging_buffer_memory = RHI_NULL_HANDLE; + rhi->createBuffer( + buffer_size, + RHI_BUFFER_USAGE_TRANSFER_SRC_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + inefficient_staging_buffer, + inefficient_staging_buffer_memory); + // RHI_BUFFER_USAGE_TRANSFER_SRC_BIT: buffer can be used as source in a // memory transfer operation void* staging_buffer_data = nullptr; - vkMapMemory(vulkan_context->m_device, - inefficient_staging_buffer_memory, - 0, - buffer_size, - 0, - &staging_buffer_data); - + rhi->mapMemory( + inefficient_staging_buffer_memory, + 0, + buffer_size, + 0, + &staging_buffer_data); + MeshPerMaterialUniformBufferObject& material_uniform_buffer_info = (*static_cast(staging_buffer_data)); - material_uniform_buffer_info.is_blend = entity.m_blend; - material_uniform_buffer_info.is_double_sided = entity.m_double_sided; - material_uniform_buffer_info.baseColorFactor = entity.m_base_color_factor; - material_uniform_buffer_info.metallicFactor = entity.m_metallic_factor; - material_uniform_buffer_info.roughnessFactor = entity.m_roughness_factor; - material_uniform_buffer_info.normalScale = entity.m_normal_scale; + material_uniform_buffer_info.is_blend = entity.m_blend; + material_uniform_buffer_info.is_double_sided = entity.m_double_sided; + material_uniform_buffer_info.baseColorFactor = entity.m_base_color_factor; + material_uniform_buffer_info.metallicFactor = entity.m_metallic_factor; + material_uniform_buffer_info.roughnessFactor = entity.m_roughness_factor; + material_uniform_buffer_info.normalScale = entity.m_normal_scale; material_uniform_buffer_info.occlusionStrength = entity.m_occlusion_strength; - material_uniform_buffer_info.emissiveFactor = entity.m_emissive_factor; + material_uniform_buffer_info.emissiveFactor = entity.m_emissive_factor; - vkUnmapMemory(vulkan_context->m_device, inefficient_staging_buffer_memory); + rhi->unmapMemory(inefficient_staging_buffer_memory); // use the vmaAllocator to allocate asset uniform buffer - VkBufferCreateInfo bufferInfo = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; - bufferInfo.size = buffer_size; - bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; + RHIBufferCreateInfo bufferInfo = { RHI_STRUCTURE_TYPE_BUFFER_CREATE_INFO }; + bufferInfo.size = buffer_size; + bufferInfo.usage = RHI_BUFFER_USAGE_UNIFORM_BUFFER_BIT | RHI_BUFFER_USAGE_TRANSFER_DST_BIT; VmaAllocationCreateInfo allocInfo = {}; - allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; + allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; - vmaCreateBufferWithAlignment( + rhi->createBufferWithAlignmentVMA( vulkan_context->m_assets_allocator, &bufferInfo, &allocInfo, m_global_render_resource._storage_buffer._min_uniform_buffer_offset_alignment, - &now_material.material_uniform_buffer, + now_material.material_uniform_buffer, &now_material.material_uniform_buffer_allocation, NULL); // use the data from staging buffer - VulkanUtil::copyBuffer( - rhi.get(), inefficient_staging_buffer, now_material.material_uniform_buffer, 0, 0, buffer_size); + rhi->copyBuffer(inefficient_staging_buffer, now_material.material_uniform_buffer, 0, 0, buffer_size); // release staging buffer - vkDestroyBuffer(vulkan_context->m_device, inefficient_staging_buffer, nullptr); - vkFreeMemory(vulkan_context->m_device, inefficient_staging_buffer_memory, nullptr); + rhi->destroyBuffer(inefficient_staging_buffer); + rhi->freeMemory(inefficient_staging_buffer_memory); } TextureDataToUpdate update_texture_data; @@ -508,101 +498,90 @@ namespace Piccolo updateTextureImageData(rhi, update_texture_data); - VkDescriptorSetAllocateInfo material_descriptor_set_alloc_info; - material_descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; - material_descriptor_set_alloc_info.pNext = NULL; - material_descriptor_set_alloc_info.descriptorPool = vulkan_context->m_descriptor_pool; + RHIDescriptorSetAllocateInfo material_descriptor_set_alloc_info; + material_descriptor_set_alloc_info.sType = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + material_descriptor_set_alloc_info.pNext = NULL; + material_descriptor_set_alloc_info.descriptorPool = vulkan_context->m_descriptor_pool; material_descriptor_set_alloc_info.descriptorSetCount = 1; material_descriptor_set_alloc_info.pSetLayouts = m_material_descriptor_set_layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(vulkan_context->m_device, - &material_descriptor_set_alloc_info, - &now_material.material_descriptor_set)) + if (RHI_SUCCESS != rhi->allocateDescriptorSets( + &material_descriptor_set_alloc_info, + now_material.material_descriptor_set)) { throw std::runtime_error("allocate material descriptor set"); } - VkDescriptorBufferInfo material_uniform_buffer_info = {}; - material_uniform_buffer_info.offset = 0; - material_uniform_buffer_info.range = sizeof(MeshPerMaterialUniformBufferObject); - material_uniform_buffer_info.buffer = now_material.material_uniform_buffer; - - VkDescriptorImageInfo base_color_image_info = {}; - base_color_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - base_color_image_info.imageView = now_material.base_color_image_view; - base_color_image_info.sampler = VulkanUtil::getOrCreateMipmapSampler(vulkan_context->m_physical_device, - vulkan_context->m_device, - base_color_image_width, - base_color_image_height); - - VkDescriptorImageInfo metallic_roughness_image_info = {}; - metallic_roughness_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - metallic_roughness_image_info.imageView = now_material.metallic_roughness_image_view; - metallic_roughness_image_info.sampler = - VulkanUtil::getOrCreateMipmapSampler(vulkan_context->m_physical_device, - vulkan_context->m_device, - metallic_roughness_width, - metallic_roughness_height); - - VkDescriptorImageInfo normal_roughness_image_info = {}; - normal_roughness_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - normal_roughness_image_info.imageView = now_material.normal_image_view; - normal_roughness_image_info.sampler = VulkanUtil::getOrCreateMipmapSampler(vulkan_context->m_physical_device, - vulkan_context->m_device, - normal_roughness_width, - normal_roughness_height); - - VkDescriptorImageInfo occlusion_image_info = {}; - occlusion_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - occlusion_image_info.imageView = now_material.occlusion_image_view; - occlusion_image_info.sampler = VulkanUtil::getOrCreateMipmapSampler(vulkan_context->m_physical_device, - vulkan_context->m_device, - occlusion_image_width, - occlusion_image_height); - - VkDescriptorImageInfo emissive_image_info = {}; - emissive_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - emissive_image_info.imageView = now_material.emissive_image_view; - emissive_image_info.sampler = VulkanUtil::getOrCreateMipmapSampler( - vulkan_context->m_physical_device, vulkan_context->m_device, emissive_image_width, emissive_image_height); - - VkWriteDescriptorSet mesh_descriptor_writes_info[6]; - - mesh_descriptor_writes_info[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - mesh_descriptor_writes_info[0].pNext = NULL; - mesh_descriptor_writes_info[0].dstSet = now_material.material_descriptor_set; - mesh_descriptor_writes_info[0].dstBinding = 0; + RHIDescriptorBufferInfo material_uniform_buffer_info = {}; + material_uniform_buffer_info.offset = 0; + material_uniform_buffer_info.range = sizeof(MeshPerMaterialUniformBufferObject); + material_uniform_buffer_info.buffer = now_material.material_uniform_buffer; + + RHIDescriptorImageInfo base_color_image_info = {}; + base_color_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + base_color_image_info.imageView = now_material.base_color_image_view; + base_color_image_info.sampler = rhi->getOrCreateMipmapSampler(base_color_image_width, + base_color_image_height); + + RHIDescriptorImageInfo metallic_roughness_image_info = {}; + metallic_roughness_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + metallic_roughness_image_info.imageView = now_material.metallic_roughness_image_view; + metallic_roughness_image_info.sampler = rhi->getOrCreateMipmapSampler(metallic_roughness_width, + metallic_roughness_height); + + RHIDescriptorImageInfo normal_roughness_image_info = {}; + normal_roughness_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + normal_roughness_image_info.imageView = now_material.normal_image_view; + normal_roughness_image_info.sampler = rhi->getOrCreateMipmapSampler(normal_roughness_width, + normal_roughness_height); + + RHIDescriptorImageInfo occlusion_image_info = {}; + occlusion_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + occlusion_image_info.imageView = now_material.occlusion_image_view; + occlusion_image_info.sampler = rhi->getOrCreateMipmapSampler(occlusion_image_width,occlusion_image_height); + + RHIDescriptorImageInfo emissive_image_info = {}; + emissive_image_info.imageLayout = RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + emissive_image_info.imageView = now_material.emissive_image_view; + emissive_image_info.sampler = rhi->getOrCreateMipmapSampler(emissive_image_width, emissive_image_height); + + RHIWriteDescriptorSet mesh_descriptor_writes_info[6]; + + mesh_descriptor_writes_info[0].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + mesh_descriptor_writes_info[0].pNext = NULL; + mesh_descriptor_writes_info[0].dstSet = now_material.material_descriptor_set; + mesh_descriptor_writes_info[0].dstBinding = 0; mesh_descriptor_writes_info[0].dstArrayElement = 0; - mesh_descriptor_writes_info[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + mesh_descriptor_writes_info[0].descriptorType = RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER; mesh_descriptor_writes_info[0].descriptorCount = 1; - mesh_descriptor_writes_info[0].pBufferInfo = &material_uniform_buffer_info; + mesh_descriptor_writes_info[0].pBufferInfo = &material_uniform_buffer_info; - mesh_descriptor_writes_info[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - mesh_descriptor_writes_info[1].pNext = NULL; - mesh_descriptor_writes_info[1].dstSet = now_material.material_descriptor_set; - mesh_descriptor_writes_info[1].dstBinding = 1; + mesh_descriptor_writes_info[1].sType = RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + mesh_descriptor_writes_info[1].pNext = NULL; + mesh_descriptor_writes_info[1].dstSet = now_material.material_descriptor_set; + mesh_descriptor_writes_info[1].dstBinding = 1; mesh_descriptor_writes_info[1].dstArrayElement = 0; - mesh_descriptor_writes_info[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + mesh_descriptor_writes_info[1].descriptorType = RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; mesh_descriptor_writes_info[1].descriptorCount = 1; - mesh_descriptor_writes_info[1].pImageInfo = &base_color_image_info; + mesh_descriptor_writes_info[1].pImageInfo = &base_color_image_info; - mesh_descriptor_writes_info[2] = mesh_descriptor_writes_info[1]; + mesh_descriptor_writes_info[2] = mesh_descriptor_writes_info[1]; mesh_descriptor_writes_info[2].dstBinding = 2; mesh_descriptor_writes_info[2].pImageInfo = &metallic_roughness_image_info; - mesh_descriptor_writes_info[3] = mesh_descriptor_writes_info[1]; + mesh_descriptor_writes_info[3] = mesh_descriptor_writes_info[1]; mesh_descriptor_writes_info[3].dstBinding = 3; mesh_descriptor_writes_info[3].pImageInfo = &normal_roughness_image_info; - mesh_descriptor_writes_info[4] = mesh_descriptor_writes_info[1]; + mesh_descriptor_writes_info[4] = mesh_descriptor_writes_info[1]; mesh_descriptor_writes_info[4].dstBinding = 4; mesh_descriptor_writes_info[4].pImageInfo = &occlusion_image_info; - mesh_descriptor_writes_info[5] = mesh_descriptor_writes_info[1]; + mesh_descriptor_writes_info[5] = mesh_descriptor_writes_info[1]; mesh_descriptor_writes_info[5].dstBinding = 5; mesh_descriptor_writes_info[5].pImageInfo = &emissive_image_info; - vkUpdateDescriptorSets(vulkan_context->m_device, 6, mesh_descriptor_writes_info, 0, nullptr); + rhi->updateDescriptorSets(6, mesh_descriptor_writes_info, 0, nullptr); return now_material; } @@ -654,41 +633,38 @@ namespace Piccolo assert(0 == (index_buffer_size % sizeof(uint16_t))); uint32_t index_count = index_buffer_size / sizeof(uint16_t); - VkDeviceSize vertex_position_buffer_size = sizeof(MeshVertex::VulkanMeshVertexPostition) * vertex_count; - VkDeviceSize vertex_varying_enable_blending_buffer_size = + RHIDeviceSize vertex_position_buffer_size = sizeof(MeshVertex::VulkanMeshVertexPostition) * vertex_count; + RHIDeviceSize vertex_varying_enable_blending_buffer_size = sizeof(MeshVertex::VulkanMeshVertexVaryingEnableBlending) * vertex_count; - VkDeviceSize vertex_varying_buffer_size = sizeof(MeshVertex::VulkanMeshVertexVarying) * vertex_count; - VkDeviceSize vertex_joint_binding_buffer_size = + RHIDeviceSize vertex_varying_buffer_size = sizeof(MeshVertex::VulkanMeshVertexVarying) * vertex_count; + RHIDeviceSize vertex_joint_binding_buffer_size = sizeof(MeshVertex::VulkanMeshVertexJointBinding) * index_count; - VkDeviceSize vertex_position_buffer_offset = 0; - VkDeviceSize vertex_varying_enable_blending_buffer_offset = + RHIDeviceSize vertex_position_buffer_offset = 0; + RHIDeviceSize vertex_varying_enable_blending_buffer_offset = vertex_position_buffer_offset + vertex_position_buffer_size; - VkDeviceSize vertex_varying_buffer_offset = + RHIDeviceSize vertex_varying_buffer_offset = vertex_varying_enable_blending_buffer_offset + vertex_varying_enable_blending_buffer_size; - VkDeviceSize vertex_joint_binding_buffer_offset = vertex_varying_buffer_offset + vertex_varying_buffer_size; + RHIDeviceSize vertex_joint_binding_buffer_offset = vertex_varying_buffer_offset + vertex_varying_buffer_size; // temporary staging buffer - VkDeviceSize inefficient_staging_buffer_size = + RHIDeviceSize inefficient_staging_buffer_size = vertex_position_buffer_size + vertex_varying_enable_blending_buffer_size + vertex_varying_buffer_size + vertex_joint_binding_buffer_size; - VkBuffer inefficient_staging_buffer = VK_NULL_HANDLE; - VkDeviceMemory inefficient_staging_buffer_memory = VK_NULL_HANDLE; - VulkanUtil::createBuffer(vulkan_context->m_physical_device, - vulkan_context->m_device, - inefficient_staging_buffer_size, - VK_BUFFER_USAGE_TRANSFER_SRC_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - inefficient_staging_buffer, - inefficient_staging_buffer_memory); + RHIBuffer* inefficient_staging_buffer = RHI_NULL_HANDLE; + RHIDeviceMemory* inefficient_staging_buffer_memory = RHI_NULL_HANDLE; + rhi->createBuffer(inefficient_staging_buffer_size, + RHI_BUFFER_USAGE_TRANSFER_SRC_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + inefficient_staging_buffer, + inefficient_staging_buffer_memory); void* inefficient_staging_buffer_data; - vkMapMemory(vulkan_context->m_device, - inefficient_staging_buffer_memory, - 0, - VK_WHOLE_SIZE, - 0, - &inefficient_staging_buffer_data); + rhi->mapMemory(inefficient_staging_buffer_memory, + 0, + RHI_WHOLE_SIZE, + 0, + &inefficient_staging_buffer_data); MeshVertex::VulkanMeshVertexPostition* mesh_vertex_positions = reinterpret_cast( @@ -717,7 +693,7 @@ namespace Piccolo vertex_buffer_data[vertex_index].y, vertex_buffer_data[vertex_index].z); - mesh_vertex_blending_varyings[vertex_index].normal = normal; + mesh_vertex_blending_varyings[vertex_index].normal = normal; mesh_vertex_blending_varyings[vertex_index].tangent = tangent; mesh_vertex_varyings[vertex_index].texcoord = @@ -749,159 +725,151 @@ namespace Piccolo joint_binding_buffer_data[vertex_buffer_index].m_weight3 * inv_total_weight); } - vkUnmapMemory(vulkan_context->m_device, inefficient_staging_buffer_memory); + rhi->unmapMemory(inefficient_staging_buffer_memory); // use the vmaAllocator to allocate asset vertex buffer - VkBufferCreateInfo bufferInfo = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; + RHIBufferCreateInfo bufferInfo = { RHI_STRUCTURE_TYPE_BUFFER_CREATE_INFO }; VmaAllocationCreateInfo allocInfo = {}; - allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; - - bufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; - bufferInfo.size = vertex_position_buffer_size; - vmaCreateBuffer(vulkan_context->m_assets_allocator, - &bufferInfo, - &allocInfo, - &now_mesh.mesh_vertex_position_buffer, - &now_mesh.mesh_vertex_position_buffer_allocation, - NULL); + allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; + + bufferInfo.usage = RHI_BUFFER_USAGE_VERTEX_BUFFER_BIT | RHI_BUFFER_USAGE_TRANSFER_DST_BIT; + bufferInfo.size = vertex_position_buffer_size; + rhi->createBufferVMA(vulkan_context->m_assets_allocator, + &bufferInfo, + &allocInfo, + now_mesh.mesh_vertex_position_buffer, + &now_mesh.mesh_vertex_position_buffer_allocation, + NULL); bufferInfo.size = vertex_varying_enable_blending_buffer_size; - vmaCreateBuffer(vulkan_context->m_assets_allocator, - &bufferInfo, - &allocInfo, - &now_mesh.mesh_vertex_varying_enable_blending_buffer, - &now_mesh.mesh_vertex_varying_enable_blending_buffer_allocation, - NULL); + rhi->createBufferVMA(vulkan_context->m_assets_allocator, + &bufferInfo, + &allocInfo, + now_mesh.mesh_vertex_varying_enable_blending_buffer, + &now_mesh.mesh_vertex_varying_enable_blending_buffer_allocation, + NULL); bufferInfo.size = vertex_varying_buffer_size; - vmaCreateBuffer(vulkan_context->m_assets_allocator, - &bufferInfo, - &allocInfo, - &now_mesh.mesh_vertex_varying_buffer, - &now_mesh.mesh_vertex_varying_buffer_allocation, - NULL); - - bufferInfo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; - bufferInfo.size = vertex_joint_binding_buffer_size; - vmaCreateBuffer(vulkan_context->m_assets_allocator, - &bufferInfo, - &allocInfo, - &now_mesh.mesh_vertex_joint_binding_buffer, - &now_mesh.mesh_vertex_joint_binding_buffer_allocation, - NULL); + rhi->createBufferVMA(vulkan_context->m_assets_allocator, + &bufferInfo, + &allocInfo, + now_mesh.mesh_vertex_varying_buffer, + &now_mesh.mesh_vertex_varying_buffer_allocation, + NULL); + + bufferInfo.usage = RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT | RHI_BUFFER_USAGE_TRANSFER_DST_BIT; + bufferInfo.size = vertex_joint_binding_buffer_size; + rhi->createBufferVMA(vulkan_context->m_assets_allocator, + &bufferInfo, + &allocInfo, + now_mesh.mesh_vertex_joint_binding_buffer, + &now_mesh.mesh_vertex_joint_binding_buffer_allocation, + NULL); // use the data from staging buffer - VulkanUtil::copyBuffer(rhi.get(), - inefficient_staging_buffer, - now_mesh.mesh_vertex_position_buffer, - vertex_position_buffer_offset, - 0, - vertex_position_buffer_size); - VulkanUtil::copyBuffer(rhi.get(), - inefficient_staging_buffer, - now_mesh.mesh_vertex_varying_enable_blending_buffer, - vertex_varying_enable_blending_buffer_offset, - 0, - vertex_varying_enable_blending_buffer_size); - VulkanUtil::copyBuffer(rhi.get(), - inefficient_staging_buffer, - now_mesh.mesh_vertex_varying_buffer, - vertex_varying_buffer_offset, - 0, - vertex_varying_buffer_size); - VulkanUtil::copyBuffer(rhi.get(), - inefficient_staging_buffer, - now_mesh.mesh_vertex_joint_binding_buffer, - vertex_joint_binding_buffer_offset, - 0, - vertex_joint_binding_buffer_size); + rhi->copyBuffer(inefficient_staging_buffer, + now_mesh.mesh_vertex_position_buffer, + vertex_position_buffer_offset, + 0, + vertex_position_buffer_size); + rhi->copyBuffer(inefficient_staging_buffer, + now_mesh.mesh_vertex_varying_enable_blending_buffer, + vertex_varying_enable_blending_buffer_offset, + 0, + vertex_varying_enable_blending_buffer_size); + rhi->copyBuffer(inefficient_staging_buffer, + now_mesh.mesh_vertex_varying_buffer, + vertex_varying_buffer_offset, + 0, + vertex_varying_buffer_size); + rhi->copyBuffer(inefficient_staging_buffer, + now_mesh.mesh_vertex_joint_binding_buffer, + vertex_joint_binding_buffer_offset, + 0, + vertex_joint_binding_buffer_size); // release staging buffer - vkDestroyBuffer(vulkan_context->m_device, inefficient_staging_buffer, nullptr); - vkFreeMemory(vulkan_context->m_device, inefficient_staging_buffer_memory, nullptr); + rhi->destroyBuffer(inefficient_staging_buffer); + rhi->freeMemory(inefficient_staging_buffer_memory); // update descriptor set - VkDescriptorSetAllocateInfo mesh_vertex_blending_per_mesh_descriptor_set_alloc_info; + RHIDescriptorSetAllocateInfo mesh_vertex_blending_per_mesh_descriptor_set_alloc_info; mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.sType = - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; - mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.pNext = NULL; + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.pNext = NULL; mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.descriptorPool = vulkan_context->m_descriptor_pool; mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.descriptorSetCount = 1; mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.pSetLayouts = m_mesh_descriptor_set_layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(vulkan_context->m_device, - &mesh_vertex_blending_per_mesh_descriptor_set_alloc_info, - &now_mesh.mesh_vertex_blending_descriptor_set)) + if (RHI_SUCCESS != rhi->allocateDescriptorSets( + &mesh_vertex_blending_per_mesh_descriptor_set_alloc_info, + now_mesh.mesh_vertex_blending_descriptor_set)) { throw std::runtime_error("allocate mesh vertex blending per mesh descriptor set"); } - VkDescriptorBufferInfo mesh_vertex_Joint_binding_storage_buffer_info = {}; - mesh_vertex_Joint_binding_storage_buffer_info.offset = 0; - mesh_vertex_Joint_binding_storage_buffer_info.range = vertex_joint_binding_buffer_size; + RHIDescriptorBufferInfo mesh_vertex_Joint_binding_storage_buffer_info = {}; + mesh_vertex_Joint_binding_storage_buffer_info.offset = 0; + mesh_vertex_Joint_binding_storage_buffer_info.range = vertex_joint_binding_buffer_size; mesh_vertex_Joint_binding_storage_buffer_info.buffer = now_mesh.mesh_vertex_joint_binding_buffer; assert(mesh_vertex_Joint_binding_storage_buffer_info.range < - m_global_render_resource._storage_buffer._max_storage_buffer_range); + m_global_render_resource._storage_buffer._max_storage_buffer_range); - VkDescriptorSet descriptor_set_to_write = now_mesh.mesh_vertex_blending_descriptor_set; + RHIDescriptorSet* descriptor_set_to_write = now_mesh.mesh_vertex_blending_descriptor_set; - VkWriteDescriptorSet descriptor_writes[1]; + RHIWriteDescriptorSet descriptor_writes[1]; - VkWriteDescriptorSet& mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info = + RHIWriteDescriptorSet& mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info = descriptor_writes[0]; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.sType = - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.pNext = NULL; - mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.dstSet = descriptor_set_to_write; + RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.pNext = NULL; + mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.dstSet = descriptor_set_to_write; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.dstBinding = 0; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.dstArrayElement = 0; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.descriptorCount = 1; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.pBufferInfo = &mesh_vertex_Joint_binding_storage_buffer_info; - vkUpdateDescriptorSets(vulkan_context->m_device, - (sizeof(descriptor_writes) / sizeof(descriptor_writes[0])), - descriptor_writes, - 0, - NULL); + rhi->updateDescriptorSets((sizeof(descriptor_writes) / sizeof(descriptor_writes[0])), + descriptor_writes, + 0, + NULL); } else { assert(0 == (vertex_buffer_size % sizeof(MeshVertexDataDefinition))); uint32_t vertex_count = vertex_buffer_size / sizeof(MeshVertexDataDefinition); - VkDeviceSize vertex_position_buffer_size = sizeof(MeshVertex::VulkanMeshVertexPostition) * vertex_count; - VkDeviceSize vertex_varying_enable_blending_buffer_size = + RHIDeviceSize vertex_position_buffer_size = sizeof(MeshVertex::VulkanMeshVertexPostition) * vertex_count; + RHIDeviceSize vertex_varying_enable_blending_buffer_size = sizeof(MeshVertex::VulkanMeshVertexVaryingEnableBlending) * vertex_count; - VkDeviceSize vertex_varying_buffer_size = sizeof(MeshVertex::VulkanMeshVertexVarying) * vertex_count; + RHIDeviceSize vertex_varying_buffer_size = sizeof(MeshVertex::VulkanMeshVertexVarying) * vertex_count; - VkDeviceSize vertex_position_buffer_offset = 0; - VkDeviceSize vertex_varying_enable_blending_buffer_offset = + RHIDeviceSize vertex_position_buffer_offset = 0; + RHIDeviceSize vertex_varying_enable_blending_buffer_offset = vertex_position_buffer_offset + vertex_position_buffer_size; - VkDeviceSize vertex_varying_buffer_offset = + RHIDeviceSize vertex_varying_buffer_offset = vertex_varying_enable_blending_buffer_offset + vertex_varying_enable_blending_buffer_size; // temporary staging buffer - VkDeviceSize inefficient_staging_buffer_size = + RHIDeviceSize inefficient_staging_buffer_size = vertex_position_buffer_size + vertex_varying_enable_blending_buffer_size + vertex_varying_buffer_size; - VkBuffer inefficient_staging_buffer = VK_NULL_HANDLE; - VkDeviceMemory inefficient_staging_buffer_memory = VK_NULL_HANDLE; - VulkanUtil::createBuffer(vulkan_context->m_physical_device, - vulkan_context->m_device, - inefficient_staging_buffer_size, - VK_BUFFER_USAGE_TRANSFER_SRC_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - inefficient_staging_buffer, - inefficient_staging_buffer_memory); + RHIBuffer* inefficient_staging_buffer = RHI_NULL_HANDLE; + RHIDeviceMemory* inefficient_staging_buffer_memory = RHI_NULL_HANDLE; + rhi->createBuffer(inefficient_staging_buffer_size, + RHI_BUFFER_USAGE_TRANSFER_SRC_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + inefficient_staging_buffer, + inefficient_staging_buffer_memory); void* inefficient_staging_buffer_data; - vkMapMemory(vulkan_context->m_device, - inefficient_staging_buffer_memory, - 0, - VK_WHOLE_SIZE, - 0, - &inefficient_staging_buffer_data); + rhi->mapMemory(inefficient_staging_buffer_memory, + 0, + RHI_WHOLE_SIZE, + 0, + &inefficient_staging_buffer_data); MeshVertex::VulkanMeshVertexPostition* mesh_vertex_positions = reinterpret_cast( @@ -927,115 +895,111 @@ namespace Piccolo vertex_buffer_data[vertex_index].y, vertex_buffer_data[vertex_index].z); - mesh_vertex_blending_varyings[vertex_index].normal = normal; + mesh_vertex_blending_varyings[vertex_index].normal = normal; mesh_vertex_blending_varyings[vertex_index].tangent = tangent; mesh_vertex_varyings[vertex_index].texcoord = Vector2(vertex_buffer_data[vertex_index].u, vertex_buffer_data[vertex_index].v); } - vkUnmapMemory(vulkan_context->m_device, inefficient_staging_buffer_memory); + rhi->unmapMemory(inefficient_staging_buffer_memory); // use the vmaAllocator to allocate asset vertex buffer - VkBufferCreateInfo bufferInfo = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; - bufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; + RHIBufferCreateInfo bufferInfo = { RHI_STRUCTURE_TYPE_BUFFER_CREATE_INFO }; + bufferInfo.usage = RHI_BUFFER_USAGE_VERTEX_BUFFER_BIT | RHI_BUFFER_USAGE_TRANSFER_DST_BIT; VmaAllocationCreateInfo allocInfo = {}; - allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; + allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; bufferInfo.size = vertex_position_buffer_size; - vmaCreateBuffer(vulkan_context->m_assets_allocator, - &bufferInfo, - &allocInfo, - &now_mesh.mesh_vertex_position_buffer, - &now_mesh.mesh_vertex_position_buffer_allocation, - NULL); + rhi->createBufferVMA(vulkan_context->m_assets_allocator, + &bufferInfo, + &allocInfo, + now_mesh.mesh_vertex_position_buffer, + &now_mesh.mesh_vertex_position_buffer_allocation, + NULL); bufferInfo.size = vertex_varying_enable_blending_buffer_size; - vmaCreateBuffer(vulkan_context->m_assets_allocator, - &bufferInfo, - &allocInfo, - &now_mesh.mesh_vertex_varying_enable_blending_buffer, - &now_mesh.mesh_vertex_varying_enable_blending_buffer_allocation, - NULL); + rhi->createBufferVMA(vulkan_context->m_assets_allocator, + &bufferInfo, + &allocInfo, + now_mesh.mesh_vertex_varying_enable_blending_buffer, + &now_mesh.mesh_vertex_varying_enable_blending_buffer_allocation, + NULL); bufferInfo.size = vertex_varying_buffer_size; - vmaCreateBuffer(vulkan_context->m_assets_allocator, - &bufferInfo, - &allocInfo, - &now_mesh.mesh_vertex_varying_buffer, - &now_mesh.mesh_vertex_varying_buffer_allocation, - NULL); + rhi->createBufferVMA(vulkan_context->m_assets_allocator, + &bufferInfo, + &allocInfo, + now_mesh.mesh_vertex_varying_buffer, + &now_mesh.mesh_vertex_varying_buffer_allocation, + NULL); // use the data from staging buffer - VulkanUtil::copyBuffer(rhi.get(), - inefficient_staging_buffer, - now_mesh.mesh_vertex_position_buffer, - vertex_position_buffer_offset, - 0, - vertex_position_buffer_size); - VulkanUtil::copyBuffer(rhi.get(), - inefficient_staging_buffer, - now_mesh.mesh_vertex_varying_enable_blending_buffer, - vertex_varying_enable_blending_buffer_offset, - 0, - vertex_varying_enable_blending_buffer_size); - VulkanUtil::copyBuffer(rhi.get(), - inefficient_staging_buffer, - now_mesh.mesh_vertex_varying_buffer, - vertex_varying_buffer_offset, - 0, - vertex_varying_buffer_size); + rhi->copyBuffer(inefficient_staging_buffer, + now_mesh.mesh_vertex_position_buffer, + vertex_position_buffer_offset, + 0, + vertex_position_buffer_size); + rhi->copyBuffer(inefficient_staging_buffer, + now_mesh.mesh_vertex_varying_enable_blending_buffer, + vertex_varying_enable_blending_buffer_offset, + 0, + vertex_varying_enable_blending_buffer_size); + rhi->copyBuffer(inefficient_staging_buffer, + now_mesh.mesh_vertex_varying_buffer, + vertex_varying_buffer_offset, + 0, + vertex_varying_buffer_size); // release staging buffer - vkDestroyBuffer(vulkan_context->m_device, inefficient_staging_buffer, nullptr); - vkFreeMemory(vulkan_context->m_device, inefficient_staging_buffer_memory, nullptr); + rhi->destroyBuffer(inefficient_staging_buffer); + rhi->freeMemory(inefficient_staging_buffer_memory); // update descriptor set - VkDescriptorSetAllocateInfo mesh_vertex_blending_per_mesh_descriptor_set_alloc_info; + RHIDescriptorSetAllocateInfo mesh_vertex_blending_per_mesh_descriptor_set_alloc_info; mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.sType = - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; - mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.pNext = NULL; + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.pNext = NULL; mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.descriptorPool = vulkan_context->m_descriptor_pool; mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.descriptorSetCount = 1; mesh_vertex_blending_per_mesh_descriptor_set_alloc_info.pSetLayouts = m_mesh_descriptor_set_layout; - if (VK_SUCCESS != vkAllocateDescriptorSets(vulkan_context->m_device, - &mesh_vertex_blending_per_mesh_descriptor_set_alloc_info, - &now_mesh.mesh_vertex_blending_descriptor_set)) + if (RHI_SUCCESS != rhi->allocateDescriptorSets( + &mesh_vertex_blending_per_mesh_descriptor_set_alloc_info, + now_mesh.mesh_vertex_blending_descriptor_set)) { throw std::runtime_error("allocate mesh vertex blending per mesh descriptor set"); } - VkDescriptorBufferInfo mesh_vertex_Joint_binding_storage_buffer_info = {}; - mesh_vertex_Joint_binding_storage_buffer_info.offset = 0; - mesh_vertex_Joint_binding_storage_buffer_info.range = 1; + RHIDescriptorBufferInfo mesh_vertex_Joint_binding_storage_buffer_info = {}; + mesh_vertex_Joint_binding_storage_buffer_info.offset = 0; + mesh_vertex_Joint_binding_storage_buffer_info.range = 1; mesh_vertex_Joint_binding_storage_buffer_info.buffer = m_global_render_resource._storage_buffer._global_null_descriptor_storage_buffer; assert(mesh_vertex_Joint_binding_storage_buffer_info.range < - m_global_render_resource._storage_buffer._max_storage_buffer_range); + m_global_render_resource._storage_buffer._max_storage_buffer_range); - VkDescriptorSet descriptor_set_to_write = now_mesh.mesh_vertex_blending_descriptor_set; + RHIDescriptorSet* descriptor_set_to_write = now_mesh.mesh_vertex_blending_descriptor_set; - VkWriteDescriptorSet descriptor_writes[1]; + RHIWriteDescriptorSet descriptor_writes[1]; - VkWriteDescriptorSet& mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info = + RHIWriteDescriptorSet& mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info = descriptor_writes[0]; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.sType = - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.pNext = NULL; - mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.dstSet = descriptor_set_to_write; + RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.pNext = NULL; + mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.dstSet = descriptor_set_to_write; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.dstBinding = 0; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.dstArrayElement = 0; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.descriptorType = - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.descriptorCount = 1; mesh_vertex_blending_vertex_Joint_binding_storage_buffer_write_info.pBufferInfo = &mesh_vertex_Joint_binding_storage_buffer_info; - vkUpdateDescriptorSets(vulkan_context->m_device, - (sizeof(descriptor_writes) / sizeof(descriptor_writes[0])), - descriptor_writes, - 0, - NULL); + rhi->updateDescriptorSets((sizeof(descriptor_writes) / sizeof(descriptor_writes[0])), + descriptor_writes, + 0, + NULL); } } @@ -1047,93 +1011,90 @@ namespace Piccolo VulkanRHI* vulkan_context = static_cast(rhi.get()); // temp staging buffer - VkDeviceSize buffer_size = index_buffer_size; - - VkBuffer inefficient_staging_buffer; - VkDeviceMemory inefficient_staging_buffer_memory; - VulkanUtil::createBuffer(vulkan_context->m_physical_device, - vulkan_context->m_device, - buffer_size, - VK_BUFFER_USAGE_TRANSFER_SRC_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - inefficient_staging_buffer, - inefficient_staging_buffer_memory); + RHIDeviceSize buffer_size = index_buffer_size; + + RHIBuffer* inefficient_staging_buffer; + RHIDeviceMemory* inefficient_staging_buffer_memory; + rhi->createBuffer(buffer_size, + RHI_BUFFER_USAGE_TRANSFER_SRC_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + inefficient_staging_buffer, + inefficient_staging_buffer_memory); void* staging_buffer_data; - vkMapMemory( - vulkan_context->m_device, inefficient_staging_buffer_memory, 0, buffer_size, 0, &staging_buffer_data); + rhi->mapMemory(inefficient_staging_buffer_memory, 0, buffer_size, 0, &staging_buffer_data); memcpy(staging_buffer_data, index_buffer_data, (size_t)buffer_size); - vkUnmapMemory(vulkan_context->m_device, inefficient_staging_buffer_memory); + rhi->unmapMemory(inefficient_staging_buffer_memory); // use the vmaAllocator to allocate asset index buffer - VkBufferCreateInfo bufferInfo = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; - bufferInfo.size = buffer_size; - bufferInfo.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; + RHIBufferCreateInfo bufferInfo = { RHI_STRUCTURE_TYPE_BUFFER_CREATE_INFO }; + bufferInfo.size = buffer_size; + bufferInfo.usage = RHI_BUFFER_USAGE_INDEX_BUFFER_BIT | RHI_BUFFER_USAGE_TRANSFER_DST_BIT; VmaAllocationCreateInfo allocInfo = {}; - allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; + allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; - vmaCreateBuffer(vulkan_context->m_assets_allocator, - &bufferInfo, - &allocInfo, - &now_mesh.mesh_index_buffer, - &now_mesh.mesh_index_buffer_allocation, - NULL); + rhi->createBufferVMA(vulkan_context->m_assets_allocator, + &bufferInfo, + &allocInfo, + now_mesh.mesh_index_buffer, + &now_mesh.mesh_index_buffer_allocation, + NULL); // use the data from staging buffer - VulkanUtil::copyBuffer(rhi.get(), inefficient_staging_buffer, now_mesh.mesh_index_buffer, 0, 0, buffer_size); + rhi->copyBuffer( inefficient_staging_buffer, now_mesh.mesh_index_buffer, 0, 0, buffer_size); // release temp staging buffer - vkDestroyBuffer(vulkan_context->m_device, inefficient_staging_buffer, nullptr); - vkFreeMemory(vulkan_context->m_device, inefficient_staging_buffer_memory, nullptr); + rhi->destroyBuffer(inefficient_staging_buffer); + rhi->freeMemory(inefficient_staging_buffer_memory); } void RenderResource::updateTextureImageData(std::shared_ptr rhi, const TextureDataToUpdate& texture_data) { - VulkanUtil::createGlobalImage(rhi.get(), - texture_data.now_material->base_color_texture_image, - texture_data.now_material->base_color_image_view, - texture_data.now_material->base_color_image_allocation, - texture_data.base_color_image_width, - texture_data.base_color_image_height, - texture_data.base_color_image_pixels, - texture_data.base_color_image_format); - - VulkanUtil::createGlobalImage(rhi.get(), - texture_data.now_material->metallic_roughness_texture_image, - texture_data.now_material->metallic_roughness_image_view, - texture_data.now_material->metallic_roughness_image_allocation, - texture_data.metallic_roughness_image_width, - texture_data.metallic_roughness_image_height, - texture_data.metallic_roughness_image_pixels, - texture_data.metallic_roughness_image_format); - - VulkanUtil::createGlobalImage(rhi.get(), - texture_data.now_material->normal_texture_image, - texture_data.now_material->normal_image_view, - texture_data.now_material->normal_image_allocation, - texture_data.normal_roughness_image_width, - texture_data.normal_roughness_image_height, - texture_data.normal_roughness_image_pixels, - texture_data.normal_roughness_image_format); - - VulkanUtil::createGlobalImage(rhi.get(), - texture_data.now_material->occlusion_texture_image, - texture_data.now_material->occlusion_image_view, - texture_data.now_material->occlusion_image_allocation, - texture_data.occlusion_image_width, - texture_data.occlusion_image_height, - texture_data.occlusion_image_pixels, - texture_data.occlusion_image_format); - - VulkanUtil::createGlobalImage(rhi.get(), - texture_data.now_material->emissive_texture_image, - texture_data.now_material->emissive_image_view, - texture_data.now_material->emissive_image_allocation, - texture_data.emissive_image_width, - texture_data.emissive_image_height, - texture_data.emissive_image_pixels, - texture_data.emissive_image_format); + rhi->createGlobalImage( + texture_data.now_material->base_color_texture_image, + texture_data.now_material->base_color_image_view, + texture_data.now_material->base_color_image_allocation, + texture_data.base_color_image_width, + texture_data.base_color_image_height, + texture_data.base_color_image_pixels, + texture_data.base_color_image_format); + + rhi->createGlobalImage( + texture_data.now_material->metallic_roughness_texture_image, + texture_data.now_material->metallic_roughness_image_view, + texture_data.now_material->metallic_roughness_image_allocation, + texture_data.metallic_roughness_image_width, + texture_data.metallic_roughness_image_height, + texture_data.metallic_roughness_image_pixels, + texture_data.metallic_roughness_image_format); + + rhi->createGlobalImage( + texture_data.now_material->normal_texture_image, + texture_data.now_material->normal_image_view, + texture_data.now_material->normal_image_allocation, + texture_data.normal_roughness_image_width, + texture_data.normal_roughness_image_height, + texture_data.normal_roughness_image_pixels, + texture_data.normal_roughness_image_format); + + rhi->createGlobalImage( + texture_data.now_material->occlusion_texture_image, + texture_data.now_material->occlusion_image_view, + texture_data.now_material->occlusion_image_allocation, + texture_data.occlusion_image_width, + texture_data.occlusion_image_height, + texture_data.occlusion_image_pixels, + texture_data.occlusion_image_format); + + rhi->createGlobalImage( + texture_data.now_material->emissive_texture_image, + texture_data.now_material->emissive_image_view, + texture_data.now_material->emissive_image_allocation, + texture_data.emissive_image_width, + texture_data.emissive_image_height, + texture_data.emissive_image_pixels, + texture_data.emissive_image_format); } VulkanMesh& RenderResource::getEntityMesh(RenderEntity entity) @@ -1174,31 +1135,29 @@ namespace Piccolo void RenderResource::createAndMapStorageBuffer(std::shared_ptr rhi) { - VulkanRHI* raw_rhi = static_cast(rhi.get()); - StorageBuffer& _storage_buffer = m_global_render_resource._storage_buffer; - uint32_t frames_in_flight = raw_rhi->s_max_frames_in_flight; + VulkanRHI* raw_rhi = static_cast(rhi.get()); + StorageBuffer& _storage_buffer = m_global_render_resource._storage_buffer; + uint32_t frames_in_flight = raw_rhi->k_max_frames_in_flight; - VkPhysicalDeviceProperties properties; - vkGetPhysicalDeviceProperties(raw_rhi->m_physical_device, &properties); + RHIPhysicalDeviceProperties properties; + rhi->getPhysicalDeviceProperties(&properties); _storage_buffer._min_uniform_buffer_offset_alignment = static_cast(properties.limits.minUniformBufferOffsetAlignment); _storage_buffer._min_storage_buffer_offset_alignment = static_cast(properties.limits.minStorageBufferOffsetAlignment); _storage_buffer._max_storage_buffer_range = properties.limits.maxStorageBufferRange; - _storage_buffer._non_coherent_atom_size = properties.limits.nonCoherentAtomSize; + _storage_buffer._non_coherent_atom_size = properties.limits.nonCoherentAtomSize; // In Vulkan, the storage buffer should be pre-allocated. // The size is 128MB in NVIDIA D3D11 // driver(https://developer.nvidia.com/content/constant-buffers-without-constant-pain-0). uint32_t global_storage_buffer_size = 1024 * 1024 * 128; - VulkanUtil::createBuffer(raw_rhi->m_physical_device, - raw_rhi->m_device, - global_storage_buffer_size, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - _storage_buffer._global_upload_ringbuffer, - _storage_buffer._global_upload_ringbuffer_memory); + rhi->createBuffer(global_storage_buffer_size, + RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + _storage_buffer._global_upload_ringbuffer, + _storage_buffer._global_upload_ringbuffer_memory); _storage_buffer._global_upload_ringbuffers_begin.resize(frames_in_flight); _storage_buffer._global_upload_ringbuffers_end.resize(frames_in_flight); @@ -1212,37 +1171,31 @@ namespace Piccolo } // axis - VulkanUtil::createBuffer(raw_rhi->m_physical_device, - raw_rhi->m_device, - sizeof(AxisStorageBufferObject), - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - _storage_buffer._axis_inefficient_storage_buffer, - _storage_buffer._axis_inefficient_storage_buffer_memory); + rhi->createBuffer(sizeof(AxisStorageBufferObject), + RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT | RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT, + _storage_buffer._axis_inefficient_storage_buffer, + _storage_buffer._axis_inefficient_storage_buffer_memory); // null descriptor - VulkanUtil::createBuffer(raw_rhi->m_physical_device, - raw_rhi->m_device, - 64, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - 0, - _storage_buffer._global_null_descriptor_storage_buffer, - _storage_buffer._global_null_descriptor_storage_buffer_memory); + rhi->createBuffer(64, + RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT, + 0, + _storage_buffer._global_null_descriptor_storage_buffer, + _storage_buffer._global_null_descriptor_storage_buffer_memory); // TODO: Unmap when program terminates - vkMapMemory(raw_rhi->m_device, - _storage_buffer._global_upload_ringbuffer_memory, - 0, - VK_WHOLE_SIZE, - 0, - &_storage_buffer._global_upload_ringbuffer_memory_pointer); - - vkMapMemory(raw_rhi->m_device, - _storage_buffer._axis_inefficient_storage_buffer_memory, - 0, - VK_WHOLE_SIZE, - 0, - &_storage_buffer._axis_inefficient_storage_buffer_memory_pointer); + rhi->mapMemory(_storage_buffer._global_upload_ringbuffer_memory, + 0, + RHI_WHOLE_SIZE, + 0, + &_storage_buffer._global_upload_ringbuffer_memory_pointer); + + rhi->mapMemory(_storage_buffer._axis_inefficient_storage_buffer_memory, + 0, + RHI_WHOLE_SIZE, + 0, + &_storage_buffer._axis_inefficient_storage_buffer_memory_pointer); static_assert(64 >= sizeof(MeshVertex::VulkanMeshVertexJointBinding), ""); } diff --git a/engine/source/runtime/function/render/render_resource.h b/engine/source/runtime/function/render/render_resource.h index 75507bd2d..45c1223d3 100644 --- a/engine/source/runtime/function/render/render_resource.h +++ b/engine/source/runtime/function/render/render_resource.h @@ -2,7 +2,7 @@ #include "runtime/function/render/render_resource_base.h" #include "runtime/function/render/render_type.h" -#include "runtime/function/render/rhi.h" +#include "runtime/function/render/interface/rhi.h" #include "runtime/function/render/render_common.h" @@ -13,6 +13,7 @@ #include #include #include +#include namespace Piccolo { @@ -22,75 +23,75 @@ namespace Piccolo struct IBLResource { - VkImage _brdfLUT_texture_image {VK_NULL_HANDLE}; - VkImageView _brdfLUT_texture_image_view {VK_NULL_HANDLE}; - VkSampler _brdfLUT_texture_sampler {VK_NULL_HANDLE}; + RHIImage* _brdfLUT_texture_image; + RHIImageView* _brdfLUT_texture_image_view; + RHISampler* _brdfLUT_texture_sampler; VmaAllocation _brdfLUT_texture_image_allocation; - VkImage _irradiance_texture_image {VK_NULL_HANDLE}; - VkImageView _irradiance_texture_image_view {VK_NULL_HANDLE}; - VkSampler _irradiance_texture_sampler {VK_NULL_HANDLE}; + RHIImage* _irradiance_texture_image; + RHIImageView* _irradiance_texture_image_view; + RHISampler* _irradiance_texture_sampler; VmaAllocation _irradiance_texture_image_allocation; - VkImage _specular_texture_image {VK_NULL_HANDLE}; - VkImageView _specular_texture_image_view {VK_NULL_HANDLE}; - VkSampler _specular_texture_sampler {VK_NULL_HANDLE}; + RHIImage* _specular_texture_image; + RHIImageView* _specular_texture_image_view; + RHISampler* _specular_texture_sampler; VmaAllocation _specular_texture_image_allocation; }; struct IBLResourceData { - void* _brdfLUT_texture_image_pixels; + void* _brdfLUT_texture_image_pixels; uint32_t _brdfLUT_texture_image_width; uint32_t _brdfLUT_texture_image_height; - PICCOLO_PIXEL_FORMAT _brdfLUT_texture_image_format; + RHIFormat _brdfLUT_texture_image_format; std::array _irradiance_texture_image_pixels; uint32_t _irradiance_texture_image_width; uint32_t _irradiance_texture_image_height; - PICCOLO_PIXEL_FORMAT _irradiance_texture_image_format; + RHIFormat _irradiance_texture_image_format; std::array _specular_texture_image_pixels; uint32_t _specular_texture_image_width; uint32_t _specular_texture_image_height; - PICCOLO_PIXEL_FORMAT _specular_texture_image_format; + RHIFormat _specular_texture_image_format; }; struct ColorGradingResource { - VkImage _color_grading_LUT_texture_image {VK_NULL_HANDLE}; - VkImageView _color_grading_LUT_texture_image_view {VK_NULL_HANDLE}; + RHIImage* _color_grading_LUT_texture_image; + RHIImageView* _color_grading_LUT_texture_image_view; VmaAllocation _color_grading_LUT_texture_image_allocation; }; struct ColorGradingResourceData { - void* _color_grading_LUT_texture_image_pixels; - uint32_t _color_grading_LUT_texture_image_width; - uint32_t _color_grading_LUT_texture_image_height; - PICCOLO_PIXEL_FORMAT _color_grading_LUT_texture_image_format; + void* _color_grading_LUT_texture_image_pixels; + uint32_t _color_grading_LUT_texture_image_width; + uint32_t _color_grading_LUT_texture_image_height; + RHIFormat _color_grading_LUT_texture_image_format; }; struct StorageBuffer { // limits - uint32_t _min_uniform_buffer_offset_alignment {256}; - uint32_t _min_storage_buffer_offset_alignment {256}; - uint32_t _max_storage_buffer_range {1 << 27}; - uint32_t _non_coherent_atom_size {256}; - - VkBuffer _global_upload_ringbuffer; - VkDeviceMemory _global_upload_ringbuffer_memory; - void* _global_upload_ringbuffer_memory_pointer; + uint32_t _min_uniform_buffer_offset_alignment{ 256 }; + uint32_t _min_storage_buffer_offset_alignment{ 256 }; + uint32_t _max_storage_buffer_range{ 1 << 27 }; + uint32_t _non_coherent_atom_size{ 256 }; + + RHIBuffer* _global_upload_ringbuffer; + RHIDeviceMemory* _global_upload_ringbuffer_memory; + void* _global_upload_ringbuffer_memory_pointer; std::vector _global_upload_ringbuffers_begin; std::vector _global_upload_ringbuffers_end; std::vector _global_upload_ringbuffers_size; - VkBuffer _global_null_descriptor_storage_buffer; - VkDeviceMemory _global_null_descriptor_storage_buffer_memory; + RHIBuffer* _global_null_descriptor_storage_buffer; + RHIDeviceMemory* _global_null_descriptor_storage_buffer_memory; // axis - VkBuffer _axis_inefficient_storage_buffer; - VkDeviceMemory _axis_inefficient_storage_buffer_memory; - void* _axis_inefficient_storage_buffer_memory_pointer; + RHIBuffer* _axis_inefficient_storage_buffer; + RHIDeviceMemory* _axis_inefficient_storage_buffer_memory; + void* _axis_inefficient_storage_buffer_memory_pointer; }; struct GlobalRenderResource @@ -103,24 +104,26 @@ namespace Piccolo class RenderResource : public RenderResourceBase { public: + void clear() override final; + virtual void uploadGlobalRenderResource(std::shared_ptr rhi, - LevelResourceDesc level_resource_desc) override final; + LevelResourceDesc level_resource_desc) override final; virtual void uploadGameObjectRenderResource(std::shared_ptr rhi, - RenderEntity render_entity, - RenderMeshData mesh_data, - RenderMaterialData material_data) override final; + RenderEntity render_entity, + RenderMeshData mesh_data, + RenderMaterialData material_data) override final; virtual void uploadGameObjectRenderResource(std::shared_ptr rhi, - RenderEntity render_entity, - RenderMeshData mesh_data) override final; + RenderEntity render_entity, + RenderMeshData mesh_data) override final; virtual void uploadGameObjectRenderResource(std::shared_ptr rhi, - RenderEntity render_entity, - RenderMaterialData material_data) override final; + RenderEntity render_entity, + RenderMaterialData material_data) override final; virtual void updatePerFrameBuffer(std::shared_ptr render_scene, - std::shared_ptr camera) override final; + std::shared_ptr camera) override final; VulkanMesh& getEntityMesh(RenderEntity entity); @@ -146,8 +149,8 @@ namespace Piccolo std::map m_vulkan_pbr_materials; // descriptor set layout in main camera pass will be used when uploading resource - const VkDescriptorSetLayout* m_mesh_descriptor_set_layout {nullptr}; - const VkDescriptorSetLayout* m_material_descriptor_set_layout {nullptr}; + RHIDescriptorSetLayout* const* m_mesh_descriptor_set_layout {nullptr}; + RHIDescriptorSetLayout* const* m_material_descriptor_set_layout {nullptr}; private: void createAndMapStorageBuffer(std::shared_ptr rhi); diff --git a/engine/source/runtime/function/render/render_resource_base.cpp b/engine/source/runtime/function/render/render_resource_base.cpp index 685be0e86..09199d5ca 100644 --- a/engine/source/runtime/function/render/render_resource_base.cpp +++ b/engine/source/runtime/function/render/render_resource_base.cpp @@ -39,10 +39,10 @@ namespace Piccolo switch (desired_channels) { case 2: - texture->m_format = PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R32G32_FLOAT; + texture->m_format = RHIFormat::RHI_FORMAT_R32G32_SFLOAT; break; case 4: - texture->m_format = PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R32G32B32A32_FLOAT; + texture->m_format = RHIFormat::RHI_FORMAT_R32G32B32A32_SFLOAT; break; default: // three component format is not supported in some vulkan driver implementations @@ -72,8 +72,8 @@ namespace Piccolo texture->m_width = iw; texture->m_height = ih; - texture->m_format = (is_srgb) ? PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8A8_SRGB : - PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_R8G8B8A8_UNORM; + texture->m_format = (is_srgb) ? RHIFormat::RHI_FORMAT_R8G8B8A8_SRGB : + RHIFormat::RHI_FORMAT_R8G8B8A8_UNORM; texture->m_depth = 1; texture->m_array_layers = 1; texture->m_mip_levels = 1; diff --git a/engine/source/runtime/function/render/render_resource_base.h b/engine/source/runtime/function/render/render_resource_base.h index 5b52a0a48..64c4b8b36 100644 --- a/engine/source/runtime/function/render/render_resource_base.h +++ b/engine/source/runtime/function/render/render_resource_base.h @@ -19,6 +19,8 @@ namespace Piccolo public: virtual ~RenderResourceBase() {} + virtual void clear() = 0; + virtual void uploadGlobalRenderResource(std::shared_ptr rhi, LevelResourceDesc level_resource_desc) = 0; virtual void uploadGameObjectRenderResource(std::shared_ptr rhi, diff --git a/engine/source/runtime/function/render/render_scene.cpp b/engine/source/runtime/function/render/render_scene.cpp index 45d9d3b6a..e8bd4965d 100644 --- a/engine/source/runtime/function/render/render_scene.cpp +++ b/engine/source/runtime/function/render/render_scene.cpp @@ -5,6 +5,10 @@ namespace Piccolo { + void RenderScene::clear() + { + } + void RenderScene::updateVisibleObjects(std::shared_ptr render_resource, std::shared_ptr camera) { diff --git a/engine/source/runtime/function/render/render_scene.h b/engine/source/runtime/function/render/render_scene.h index 67e86cfcc..71d95fe4e 100644 --- a/engine/source/runtime/function/render/render_scene.h +++ b/engine/source/runtime/function/render/render_scene.h @@ -36,6 +36,9 @@ namespace Piccolo std::vector m_main_camera_visible_mesh_nodes; RenderAxisNode m_axis_node; + // clear + void clear(); + // update visible objects in each frame void updateVisibleObjects(std::shared_ptr render_resource, std::shared_ptr camera); diff --git a/engine/source/runtime/function/render/render_system.cpp b/engine/source/runtime/function/render/render_system.cpp index 5b00afddf..36fb3f84f 100644 --- a/engine/source/runtime/function/render/render_system.cpp +++ b/engine/source/runtime/function/render/render_system.cpp @@ -12,15 +12,20 @@ #include "runtime/function/render/render_resource_base.h" #include "runtime/function/render/render_scene.h" #include "runtime/function/render/window_system.h" +#include "runtime/function/global/global_context.h" +#include "runtime/function/render/debugdraw/debug_draw_manager.h" #include "runtime/function/render/passes/main_camera_pass.h" #include "runtime/function/render/passes/particle_pass.h" -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" +#include "runtime/function/render/interface/vulkan/vulkan_rhi.h" namespace Piccolo { - RenderSystem::~RenderSystem() {} + RenderSystem::~RenderSystem() + { + clear(); + } void RenderSystem::initialize(RenderSystemInitInfo init_info) { @@ -89,7 +94,7 @@ namespace Piccolo .layout; } - void RenderSystem::tick() + void RenderSystem::tick(float delta_time) { // process swap data between logic and render contexts processSwapData(); @@ -107,6 +112,8 @@ namespace Piccolo // prepare pipeline's render passes data m_render_pipeline->preparePassData(m_render_resource); + g_runtime_global_context.m_debugdraw_manager->tick(delta_time); + // render one frame if (m_render_pipeline_type == RENDER_PIPELINE_TYPE::FORWARD_PIPELINE) { @@ -122,12 +129,41 @@ namespace Piccolo } } + void RenderSystem::clear() + { + if (m_rhi) + { + m_rhi->clear(); + } + m_rhi.reset(); + + if (m_render_scene) + { + m_render_scene->clear(); + } + m_render_scene.reset(); + + if (m_render_resource) + { + m_render_resource->clear(); + } + m_render_resource.reset(); + + if (m_render_pipeline) + { + m_render_pipeline->clear(); + } + m_render_pipeline.reset(); + } + void RenderSystem::swapLogicRenderData() { m_swap_context.swapLogicRenderData(); } RenderSwapContext& RenderSystem::getSwapContext() { return m_swap_context; } std::shared_ptr RenderSystem::getRenderCamera() const { return m_render_camera; } + std::shared_ptr RenderSystem::getRHI() const { return m_rhi; } + void RenderSystem::updateEngineContentViewport(float offset_x, float offset_y, float width, float height) { std::static_pointer_cast(m_rhi)->m_viewport.x = offset_x; diff --git a/engine/source/runtime/function/render/render_system.h b/engine/source/runtime/function/render/render_system.h index 7c0fbd7c8..7702cb9dc 100644 --- a/engine/source/runtime/function/render/render_system.h +++ b/engine/source/runtime/function/render/render_system.h @@ -18,10 +18,12 @@ namespace Piccolo class RenderScene; class RenderCamera; class WindowUI; + class DebugDrawManager; struct RenderSystemInitInfo { std::shared_ptr window_system; + std::shared_ptr debugdraw_manager; }; struct EngineContentViewport @@ -39,11 +41,13 @@ namespace Piccolo ~RenderSystem(); void initialize(RenderSystemInitInfo init_info); - void tick(); + void tick(float delta_time); + void clear(); void swapLogicRenderData(); RenderSwapContext& getSwapContext(); std::shared_ptr getRenderCamera() const; + std::shared_ptr getRHI() const; void setRenderPipelineType(RENDER_PIPELINE_TYPE pipeline_type); void initializeUIRenderBackend(WindowUI* window_ui); diff --git a/engine/source/runtime/function/render/render_type.h b/engine/source/runtime/function/render/render_type.h index e660f3838..fecd6ac00 100644 --- a/engine/source/runtime/function/render/render_type.h +++ b/engine/source/runtime/function/render/render_type.h @@ -6,20 +6,1683 @@ #include #include + +/// +/// RHI Type +/// namespace Piccolo { - enum class PICCOLO_PIXEL_FORMAT : uint8_t +#define RHI_MAX_EXTENSION_NAME_SIZE 256U +#define RHI_MAX_DESCRIPTION_SIZE 256U +#define RHI_MAX_MEMORY_TYPES 32U +#define RHI_MAX_PHYSICAL_DEVICE_NAME_SIZE 256U +#define RHI_UUID_SIZE 16U +#define RHI_MAX_MEMORY_HEAPS 16U +#define RHI_SUBPASS_EXTERNAL (~0U) +#define RHI_QUEUE_FAMILY_IGNORED (~0U) +#define RHI_WHOLE_SIZE (~0ULL) +#define RHI_NULL_HANDLE nullptr +#define RHI_SUCCESS true +#define RHI_TRUE true +#define RHI_FALSE false + + enum RHIStructureType : int + { + RHI_STRUCTURE_TYPE_APPLICATION_INFO = 0, + RHI_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + RHI_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + RHI_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + RHI_STRUCTURE_TYPE_SUBMIT_INFO = 4, + RHI_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + RHI_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + RHI_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + RHI_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + RHI_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + RHI_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + RHI_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + RHI_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + RHI_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + RHI_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + RHI_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + RHI_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + RHI_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + RHI_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + RHI_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + RHI_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + RHI_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + RHI_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + RHI_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + RHI_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + RHI_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + RHI_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + RHI_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + RHI_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + RHI_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + RHI_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + RHI_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + RHI_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + RHI_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + RHI_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + RHI_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + RHI_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + RHI_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + RHI_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + RHI_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + RHI_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + RHI_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + RHI_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + RHI_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + RHI_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, + RHI_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + RHI_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + RHI_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + RHI_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + RHI_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, + RHI_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + RHI_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + RHI_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + RHI_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + RHI_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + RHI_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + RHI_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + RHI_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + RHI_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + RHI_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, + RHI_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + RHI_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + RHI_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + RHI_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + RHI_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + RHI_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + RHI_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + RHI_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + RHI_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + RHI_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + RHI_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + RHI_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + RHI_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + RHI_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + RHI_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + RHI_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + RHI_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, + RHI_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, + RHI_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, + RHI_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, + RHI_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, + RHI_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, + RHI_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, + RHI_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, + RHI_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, + RHI_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, + RHI_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, + RHI_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, + RHI_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, + RHI_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, + RHI_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, + RHI_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, + RHI_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, + RHI_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, + RHI_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, + RHI_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, + RHI_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, + RHI_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, + RHI_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, + RHI_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, + RHI_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, + RHI_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + RHI_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + RHI_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + RHI_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + RHI_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + RHI_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + RHI_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + RHI_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + RHI_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + RHI_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + RHI_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + RHI_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + RHI_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + RHI_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, + RHI_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + RHI_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + RHI_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, + RHI_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, + RHI_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, + RHI_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, + RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, + RHI_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000, + RHI_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001, + RHI_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002, + RHI_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, + RHI_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, + RHI_STRUCTURE_TYPE_RENDERING_INFO_KHR = 1000044000, + RHI_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR = 1000044001, + RHI_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR = 1000044002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = 1000044003, + RHI_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = 1000044004, + RHI_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, + RHI_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, + RHI_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008, + RHI_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009, + RHI_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, + RHI_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + RHI_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + RHI_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + RHI_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + RHI_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, + RHI_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + RHI_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000, + RHI_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + RHI_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + RHI_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + RHI_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + RHI_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + RHI_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + RHI_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + RHI_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + RHI_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + RHI_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + RHI_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + RHI_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + RHI_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + RHI_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + RHI_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + RHI_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, + RHI_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, + RHI_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, + RHI_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, + RHI_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + RHI_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + RHI_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + RHI_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + RHI_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, + RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + RHI_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, + RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, + RHI_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + RHI_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + RHI_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + RHI_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + RHI_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + RHI_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + RHI_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, + RHI_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, + RHI_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, + RHI_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, + RHI_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, + RHI_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + RHI_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + RHI_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + RHI_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, + RHI_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, + RHI_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, + RHI_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, + RHI_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, + RHI_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MRHI = 1000122000, + RHI_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MRHI = 1000123000, + RHI_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, + RHI_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, + RHI_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, + RHI_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, + RHI_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, + RHI_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, + RHI_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, + RHI_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, + RHI_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, + RHI_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, + RHI_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, + RHI_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001, + RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002, + RHI_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003, + RHI_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + RHI_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + RHI_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + RHI_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + RHI_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + RHI_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009, + RHI_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010, + RHI_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011, + RHI_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001, + RHI_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015, + RHI_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016, + RHI_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013, + RHI_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001, + RHI_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, + RHI_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, + RHI_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, + RHI_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, + RHI_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, + RHI_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, + RHI_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, + RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, + RHI_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, + RHI_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, + RHI_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, + RHI_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, + RHI_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, + RHI_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, + RHI_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, + RHI_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, + RHI_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, + RHI_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, + RHI_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + RHI_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, + RHI_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, + RHI_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, + RHI_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, + RHI_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000, + RHI_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000192000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, + RHI_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, + RHI_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, + RHI_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, + RHI_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, + RHI_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, + RHI_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002, + RHI_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003, + RHI_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004, + RHI_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, + RHI_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000, + RHI_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001, + RHI_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = 1000215000, + RHI_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, + RHI_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000, + RHI_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002, + RHI_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, + RHI_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, + RHI_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, + RHI_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, + RHI_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = 1000245000, + RHI_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, + RHI_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000, + RHI_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001, + RHI_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000, + RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002, + RHI_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000, + RHI_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, + RHI_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, + RHI_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, + RHI_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, + RHI_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001, + RHI_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002, + RHI_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, + RHI_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, + RHI_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, + RHI_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, + RHI_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, + RHI_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003, + RHI_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004, + RHI_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005, + RHI_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000, + RHI_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = 1000280000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = 1000280001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001, + RHI_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000, + RHI_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, + RHI_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, + RHI_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, + RHI_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, + RHI_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, + RHI_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = 1000295000, + RHI_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = 1000295001, + RHI_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = 1000295002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = 1000297000, + RHI_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, + RHI_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = 1000314000, + RHI_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = 1000314001, + RHI_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = 1000314002, + RHI_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = 1000314003, + RHI_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = 1000314004, + RHI_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = 1000314005, + RHI_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = 1000314006, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = 1000314007, + RHI_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, + RHI_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = 1000325000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, + RHI_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001, + RHI_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, + RHI_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = 1000335000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000, + RHI_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = 1000337000, + RHI_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = 1000337001, + RHI_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = 1000337002, + RHI_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = 1000337003, + RHI_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = 1000337004, + RHI_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = 1000337005, + RHI_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = 1000337006, + RHI_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = 1000337007, + RHI_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = 1000337008, + RHI_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = 1000337009, + RHI_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = 1000337010, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000, + RHI_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = 1000351000, + RHI_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = 1000351002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, + RHI_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, + RHI_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, + RHI_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = 1000360000, + RHI_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000, + RHI_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001, + RHI_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002, + RHI_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000, + RHI_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001, + RHI_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000, + RHI_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001, + RHI_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002, + RHI_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003, + RHI_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004, + RHI_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005, + RHI_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006, + RHI_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007, + RHI_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008, + RHI_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009, + RHI_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000, + RHI_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, + RHI_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, + RHI_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = 1000388000, + RHI_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = 1000388001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, + RHI_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = 1000413000, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = 1000413001, + RHI_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = 1000413002, + RHI_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = 1000413003, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + RHI_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = RHI_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + RHI_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = RHI_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, + RHI_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + RHI_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = RHI_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + RHI_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = RHI_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + RHI_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = RHI_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + RHI_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = RHI_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + RHI_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = RHI_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = RHI_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = RHI_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = RHI_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = RHI_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + RHI_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = RHI_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + RHI_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = RHI_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + RHI_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + RHI_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + RHI_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + RHI_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + RHI_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + RHI_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = RHI_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + RHI_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + RHI_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + RHI_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + RHI_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = RHI_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, + RHI_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, + RHI_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = RHI_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, + RHI_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = RHI_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, + RHI_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = RHI_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, + RHI_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = RHI_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, + RHI_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = RHI_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, + RHI_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = RHI_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, + RHI_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = RHI_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, + RHI_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = RHI_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, + RHI_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = RHI_STRUCTURE_TYPE_SUBPASS_END_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + RHI_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + RHI_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + RHI_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + RHI_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + RHI_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, + RHI_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = RHI_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + RHI_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = RHI_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, + RHI_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = RHI_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, + RHI_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = RHI_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + RHI_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = RHI_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + RHI_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = RHI_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + RHI_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = RHI_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + RHI_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = RHI_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + RHI_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, + RHI_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + RHI_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = RHI_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + RHI_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = RHI_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + RHI_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = RHI_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + RHI_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + RHI_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = RHI_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, + RHI_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = RHI_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = RHI_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, + RHI_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = RHI_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, + RHI_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, + RHI_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = RHI_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, + RHI_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = RHI_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, + RHI_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = RHI_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, + RHI_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = RHI_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, + RHI_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = RHI_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, + RHI_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = RHI_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, + RHI_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = RHI_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + RHI_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = RHI_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, + RHI_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = RHI_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + RHI_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = RHI_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, + RHI_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = RHI_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, + RHI_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = RHI_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, + RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = RHI_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, + RHI_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHISharingMode : int + { + RHI_SHARING_MODE_EXCLUSIVE = 0, + RHI_SHARING_MODE_CONCURRENT = 1, + RHI_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHICommandBufferLevel : int + { + RHI_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + RHI_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + RHI_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIImageType : int + { + RHI_IMAGE_TYPE_1D = 0, + RHI_IMAGE_TYPE_2D = 1, + RHI_IMAGE_TYPE_3D = 2, + RHI_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIFormat : int + { + RHI_FORMAT_UNDEFINED = 0, + RHI_FORMAT_R4G4_UNORM_PACK8 = 1, + RHI_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + RHI_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + RHI_FORMAT_R5G6B5_UNORM_PACK16 = 4, + RHI_FORMAT_B5G6R5_UNORM_PACK16 = 5, + RHI_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + RHI_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + RHI_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + RHI_FORMAT_R8_UNORM = 9, + RHI_FORMAT_R8_SNORM = 10, + RHI_FORMAT_R8_USCALED = 11, + RHI_FORMAT_R8_SSCALED = 12, + RHI_FORMAT_R8_UINT = 13, + RHI_FORMAT_R8_SINT = 14, + RHI_FORMAT_R8_SRGB = 15, + RHI_FORMAT_R8G8_UNORM = 16, + RHI_FORMAT_R8G8_SNORM = 17, + RHI_FORMAT_R8G8_USCALED = 18, + RHI_FORMAT_R8G8_SSCALED = 19, + RHI_FORMAT_R8G8_UINT = 20, + RHI_FORMAT_R8G8_SINT = 21, + RHI_FORMAT_R8G8_SRGB = 22, + RHI_FORMAT_R8G8B8_UNORM = 23, + RHI_FORMAT_R8G8B8_SNORM = 24, + RHI_FORMAT_R8G8B8_USCALED = 25, + RHI_FORMAT_R8G8B8_SSCALED = 26, + RHI_FORMAT_R8G8B8_UINT = 27, + RHI_FORMAT_R8G8B8_SINT = 28, + RHI_FORMAT_R8G8B8_SRGB = 29, + RHI_FORMAT_B8G8R8_UNORM = 30, + RHI_FORMAT_B8G8R8_SNORM = 31, + RHI_FORMAT_B8G8R8_USCALED = 32, + RHI_FORMAT_B8G8R8_SSCALED = 33, + RHI_FORMAT_B8G8R8_UINT = 34, + RHI_FORMAT_B8G8R8_SINT = 35, + RHI_FORMAT_B8G8R8_SRGB = 36, + RHI_FORMAT_R8G8B8A8_UNORM = 37, + RHI_FORMAT_R8G8B8A8_SNORM = 38, + RHI_FORMAT_R8G8B8A8_USCALED = 39, + RHI_FORMAT_R8G8B8A8_SSCALED = 40, + RHI_FORMAT_R8G8B8A8_UINT = 41, + RHI_FORMAT_R8G8B8A8_SINT = 42, + RHI_FORMAT_R8G8B8A8_SRGB = 43, + RHI_FORMAT_B8G8R8A8_UNORM = 44, + RHI_FORMAT_B8G8R8A8_SNORM = 45, + RHI_FORMAT_B8G8R8A8_USCALED = 46, + RHI_FORMAT_B8G8R8A8_SSCALED = 47, + RHI_FORMAT_B8G8R8A8_UINT = 48, + RHI_FORMAT_B8G8R8A8_SINT = 49, + RHI_FORMAT_B8G8R8A8_SRGB = 50, + RHI_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + RHI_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + RHI_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + RHI_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + RHI_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + RHI_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + RHI_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + RHI_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + RHI_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + RHI_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + RHI_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + RHI_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + RHI_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + RHI_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + RHI_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + RHI_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + RHI_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + RHI_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + RHI_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + RHI_FORMAT_R16_UNORM = 70, + RHI_FORMAT_R16_SNORM = 71, + RHI_FORMAT_R16_USCALED = 72, + RHI_FORMAT_R16_SSCALED = 73, + RHI_FORMAT_R16_UINT = 74, + RHI_FORMAT_R16_SINT = 75, + RHI_FORMAT_R16_SFLOAT = 76, + RHI_FORMAT_R16G16_UNORM = 77, + RHI_FORMAT_R16G16_SNORM = 78, + RHI_FORMAT_R16G16_USCALED = 79, + RHI_FORMAT_R16G16_SSCALED = 80, + RHI_FORMAT_R16G16_UINT = 81, + RHI_FORMAT_R16G16_SINT = 82, + RHI_FORMAT_R16G16_SFLOAT = 83, + RHI_FORMAT_R16G16B16_UNORM = 84, + RHI_FORMAT_R16G16B16_SNORM = 85, + RHI_FORMAT_R16G16B16_USCALED = 86, + RHI_FORMAT_R16G16B16_SSCALED = 87, + RHI_FORMAT_R16G16B16_UINT = 88, + RHI_FORMAT_R16G16B16_SINT = 89, + RHI_FORMAT_R16G16B16_SFLOAT = 90, + RHI_FORMAT_R16G16B16A16_UNORM = 91, + RHI_FORMAT_R16G16B16A16_SNORM = 92, + RHI_FORMAT_R16G16B16A16_USCALED = 93, + RHI_FORMAT_R16G16B16A16_SSCALED = 94, + RHI_FORMAT_R16G16B16A16_UINT = 95, + RHI_FORMAT_R16G16B16A16_SINT = 96, + RHI_FORMAT_R16G16B16A16_SFLOAT = 97, + RHI_FORMAT_R32_UINT = 98, + RHI_FORMAT_R32_SINT = 99, + RHI_FORMAT_R32_SFLOAT = 100, + RHI_FORMAT_R32G32_UINT = 101, + RHI_FORMAT_R32G32_SINT = 102, + RHI_FORMAT_R32G32_SFLOAT = 103, + RHI_FORMAT_R32G32B32_UINT = 104, + RHI_FORMAT_R32G32B32_SINT = 105, + RHI_FORMAT_R32G32B32_SFLOAT = 106, + RHI_FORMAT_R32G32B32A32_UINT = 107, + RHI_FORMAT_R32G32B32A32_SINT = 108, + RHI_FORMAT_R32G32B32A32_SFLOAT = 109, + RHI_FORMAT_R64_UINT = 110, + RHI_FORMAT_R64_SINT = 111, + RHI_FORMAT_R64_SFLOAT = 112, + RHI_FORMAT_R64G64_UINT = 113, + RHI_FORMAT_R64G64_SINT = 114, + RHI_FORMAT_R64G64_SFLOAT = 115, + RHI_FORMAT_R64G64B64_UINT = 116, + RHI_FORMAT_R64G64B64_SINT = 117, + RHI_FORMAT_R64G64B64_SFLOAT = 118, + RHI_FORMAT_R64G64B64A64_UINT = 119, + RHI_FORMAT_R64G64B64A64_SINT = 120, + RHI_FORMAT_R64G64B64A64_SFLOAT = 121, + RHI_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + RHI_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + RHI_FORMAT_D16_UNORM = 124, + RHI_FORMAT_X8_D24_UNORM_PACK32 = 125, + RHI_FORMAT_D32_SFLOAT = 126, + RHI_FORMAT_S8_UINT = 127, + RHI_FORMAT_D16_UNORM_S8_UINT = 128, + RHI_FORMAT_D24_UNORM_S8_UINT = 129, + RHI_FORMAT_D32_SFLOAT_S8_UINT = 130, + RHI_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + RHI_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + RHI_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + RHI_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + RHI_FORMAT_BC2_UNORM_BLOCK = 135, + RHI_FORMAT_BC2_SRGB_BLOCK = 136, + RHI_FORMAT_BC3_UNORM_BLOCK = 137, + RHI_FORMAT_BC3_SRGB_BLOCK = 138, + RHI_FORMAT_BC4_UNORM_BLOCK = 139, + RHI_FORMAT_BC4_SNORM_BLOCK = 140, + RHI_FORMAT_BC5_UNORM_BLOCK = 141, + RHI_FORMAT_BC5_SNORM_BLOCK = 142, + RHI_FORMAT_BC6H_UFLOAT_BLOCK = 143, + RHI_FORMAT_BC6H_SFLOAT_BLOCK = 144, + RHI_FORMAT_BC7_UNORM_BLOCK = 145, + RHI_FORMAT_BC7_SRGB_BLOCK = 146, + RHI_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + RHI_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + RHI_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + RHI_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + RHI_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + RHI_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + RHI_FORMAT_EAC_R11_UNORM_BLOCK = 153, + RHI_FORMAT_EAC_R11_SNORM_BLOCK = 154, + RHI_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + RHI_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + RHI_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + RHI_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + RHI_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + RHI_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + RHI_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + RHI_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + RHI_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + RHI_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + RHI_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + RHI_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + RHI_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + RHI_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + RHI_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + RHI_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + RHI_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + RHI_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + RHI_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + RHI_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + RHI_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + RHI_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + RHI_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + RHI_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + RHI_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + RHI_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + RHI_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + RHI_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + RHI_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + RHI_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + RHI_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + RHI_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + RHI_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + RHI_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + RHI_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + RHI_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + RHI_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + RHI_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + RHI_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + RHI_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + RHI_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + RHI_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + RHI_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + RHI_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + RHI_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + RHI_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + RHI_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + RHI_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + RHI_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + RHI_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + RHI_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + RHI_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + RHI_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + RHI_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + RHI_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + RHI_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + RHI_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + RHI_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + RHI_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + RHI_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + RHI_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + RHI_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + RHI_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + RHI_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, + RHI_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + RHI_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + RHI_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + RHI_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + RHI_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + RHI_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + RHI_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + RHI_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + RHI_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000, + RHI_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001, + RHI_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002, + RHI_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003, + RHI_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004, + RHI_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005, + RHI_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006, + RHI_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007, + RHI_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008, + RHI_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009, + RHI_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010, + RHI_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011, + RHI_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012, + RHI_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013, + RHI_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = 1000330000, + RHI_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = 1000330001, + RHI_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = 1000330002, + RHI_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = 1000330003, + RHI_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = 1000340000, + RHI_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = 1000340001, + RHI_FORMAT_G8B8G8R8_422_UNORM_KHR = RHI_FORMAT_G8B8G8R8_422_UNORM, + RHI_FORMAT_B8G8R8G8_422_UNORM_KHR = RHI_FORMAT_B8G8R8G8_422_UNORM, + RHI_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = RHI_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + RHI_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = RHI_FORMAT_G8_B8R8_2PLANE_420_UNORM, + RHI_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = RHI_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + RHI_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = RHI_FORMAT_G8_B8R8_2PLANE_422_UNORM, + RHI_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = RHI_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + RHI_FORMAT_R10X6_UNORM_PACK16_KHR = RHI_FORMAT_R10X6_UNORM_PACK16, + RHI_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = RHI_FORMAT_R10X6G10X6_UNORM_2PACK16, + RHI_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = RHI_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + RHI_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = RHI_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + RHI_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = RHI_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + RHI_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = RHI_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + RHI_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = RHI_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + RHI_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = RHI_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + RHI_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = RHI_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + RHI_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = RHI_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + RHI_FORMAT_R12X4_UNORM_PACK16_KHR = RHI_FORMAT_R12X4_UNORM_PACK16, + RHI_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = RHI_FORMAT_R12X4G12X4_UNORM_2PACK16, + RHI_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = RHI_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + RHI_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = RHI_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + RHI_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = RHI_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + RHI_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = RHI_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + RHI_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = RHI_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + RHI_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = RHI_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + RHI_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = RHI_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + RHI_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = RHI_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + RHI_FORMAT_G16B16G16R16_422_UNORM_KHR = RHI_FORMAT_G16B16G16R16_422_UNORM, + RHI_FORMAT_B16G16R16G16_422_UNORM_KHR = RHI_FORMAT_B16G16R16G16_422_UNORM, + RHI_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = RHI_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + RHI_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = RHI_FORMAT_G16_B16R16_2PLANE_420_UNORM, + RHI_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = RHI_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + RHI_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = RHI_FORMAT_G16_B16R16_2PLANE_422_UNORM, + RHI_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = RHI_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + RHI_FORMAT_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHISampleCountFlagBits : int + { + RHI_SAMPLE_COUNT_1_BIT = 0x00000001, + RHI_SAMPLE_COUNT_2_BIT = 0x00000002, + RHI_SAMPLE_COUNT_4_BIT = 0x00000004, + RHI_SAMPLE_COUNT_8_BIT = 0x00000008, + RHI_SAMPLE_COUNT_16_BIT = 0x00000010, + RHI_SAMPLE_COUNT_32_BIT = 0x00000020, + RHI_SAMPLE_COUNT_64_BIT = 0x00000040, + RHI_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIImageTiling : int + { + RHI_IMAGE_TILING_OPTIMAL = 0, + RHI_IMAGE_TILING_LINEAR = 1, + RHI_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, + RHI_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIImageLayout : int + { + RHI_IMAGE_LAYOUT_UNDEFINED = 0, + RHI_IMAGE_LAYOUT_GENERAL = 1, + RHI_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + RHI_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + RHI_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + RHI_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + RHI_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + RHI_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + RHI_IMAGE_LAYOUT_PREINITIALIZED = 8, + RHI_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + RHI_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + RHI_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, + RHI_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, + RHI_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, + RHI_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, + RHI_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + RHI_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, + RHI_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, + RHI_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = 1000314001, + RHI_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = RHI_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, + RHI_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = RHI_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + RHI_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = RHI_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, + RHI_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = RHI_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, + RHI_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = RHI_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, + RHI_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = RHI_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, + RHI_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = RHI_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, + RHI_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIImageViewType : int + { + RHI_IMAGE_VIEW_TYPE_1D = 0, + RHI_IMAGE_VIEW_TYPE_2D = 1, + RHI_IMAGE_VIEW_TYPE_3D = 2, + RHI_IMAGE_VIEW_TYPE_CUBE = 3, + RHI_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + RHI_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + RHI_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + RHI_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIAttachmentLoadOp : int + { + RHI_ATTACHMENT_LOAD_OP_LOAD = 0, + RHI_ATTACHMENT_LOAD_OP_CLEAR = 1, + RHI_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + RHI_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000, + RHI_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIAttachmentStoreOp : int + { + RHI_ATTACHMENT_STORE_OP_STORE = 0, + RHI_ATTACHMENT_STORE_OP_DONT_CARE = 1, + RHI_ATTACHMENT_STORE_OP_NONE_KHR = 1000301000, + RHI_ATTACHMENT_STORE_OP_NONE_QCOM = RHI_ATTACHMENT_STORE_OP_NONE_KHR, + RHI_ATTACHMENT_STORE_OP_NONE_EXT = RHI_ATTACHMENT_STORE_OP_NONE_KHR, + RHI_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIBorderColor : int + { + RHI_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + RHI_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + RHI_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + RHI_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + RHI_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + RHI_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + RHI_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, + RHI_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, + RHI_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHICompareOp : int + { + RHI_COMPARE_OP_NEVER = 0, + RHI_COMPARE_OP_LESS = 1, + RHI_COMPARE_OP_EQUAL = 2, + RHI_COMPARE_OP_LESS_OR_EQUAL = 3, + RHI_COMPARE_OP_GREATER = 4, + RHI_COMPARE_OP_NOT_EQUAL = 5, + RHI_COMPARE_OP_GREATER_OR_EQUAL = 6, + RHI_COMPARE_OP_ALWAYS = 7, + RHI_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIDescriptorType : int + { + RHI_DESCRIPTOR_TYPE_SAMPLER = 0, + RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + RHI_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + RHI_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + RHI_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + RHI_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + RHI_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + RHI_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + RHI_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + RHI_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000, + RHI_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, + RHI_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + RHI_DESCRIPTOR_TYPE_MUTABLE_VALVE = 1000351000, + RHI_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIDynamicState : int + { + RHI_DYNAMIC_STATE_VIEWPORT = 0, + RHI_DYNAMIC_STATE_SCISSOR = 1, + RHI_DYNAMIC_STATE_LINE_WIDTH = 2, + RHI_DYNAMIC_STATE_DEPTH_BIAS = 3, + RHI_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + RHI_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + RHI_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + RHI_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + RHI_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + RHI_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, + RHI_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + RHI_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, + RHI_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000, + RHI_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, + RHI_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, + RHI_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, + RHI_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, + RHI_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000, + RHI_DYNAMIC_STATE_CULL_MODE_EXT = 1000267000, + RHI_DYNAMIC_STATE_FRONT_FACE_EXT = 1000267001, + RHI_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = 1000267002, + RHI_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = 1000267003, + RHI_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = 1000267004, + RHI_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = 1000267005, + RHI_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = 1000267006, + RHI_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = 1000267007, + RHI_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = 1000267008, + RHI_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = 1000267009, + RHI_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = 1000267010, + RHI_DYNAMIC_STATE_STENCIL_OP_EXT = 1000267011, + RHI_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, + RHI_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, + RHI_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = 1000377001, + RHI_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = 1000377002, + RHI_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, + RHI_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = 1000377004, + RHI_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, + RHI_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIFilter : int + { + RHI_FILTER_NEAREST = 0, + RHI_FILTER_LINEAR = 1, + RHI_FILTER_CUBIC_IMG = 1000015000, + RHI_FILTER_CUBIC_EXT = RHI_FILTER_CUBIC_IMG, + RHI_FILTER_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIFrontFace : int + { + RHI_FRONT_FACE_COUNTER_CLOCKWISE = 0, + RHI_FRONT_FACE_CLOCKWISE = 1, + RHI_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHILogicOp : int + { + RHI_LOGIC_OP_CLEAR = 0, + RHI_LOGIC_OP_AND = 1, + RHI_LOGIC_OP_AND_REVERSE = 2, + RHI_LOGIC_OP_COPY = 3, + RHI_LOGIC_OP_AND_INVERTED = 4, + RHI_LOGIC_OP_NO_OP = 5, + RHI_LOGIC_OP_XOR = 6, + RHI_LOGIC_OP_OR = 7, + RHI_LOGIC_OP_NOR = 8, + RHI_LOGIC_OP_EQUIVALENT = 9, + RHI_LOGIC_OP_INVERT = 10, + RHI_LOGIC_OP_OR_REVERSE = 11, + RHI_LOGIC_OP_COPY_INVERTED = 12, + RHI_LOGIC_OP_OR_INVERTED = 13, + RHI_LOGIC_OP_NAND = 14, + RHI_LOGIC_OP_SET = 15, + RHI_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIPhysicalDeviceType : int + { + RHI_PHYSICAL_DEVICE_TYPE_OTHER = 0, + RHI_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + RHI_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + RHI_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + RHI_PHYSICAL_DEVICE_TYPE_CPU = 4, + RHI_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIPipelineBindPoint : int { - PICCOLO_PIXEL_FORMAT_UNKNOWN = 0, - PICCOLO_PIXEL_FORMAT_R8G8B8_UNORM, - PICCOLO_PIXEL_FORMAT_R8G8B8_SRGB, - PICCOLO_PIXEL_FORMAT_R8G8B8A8_UNORM, - PICCOLO_PIXEL_FORMAT_R8G8B8A8_SRGB, - PICCOLO_PIXEL_FORMAT_R32G32_FLOAT, - PICCOLO_PIXEL_FORMAT_R32G32B32_FLOAT, - PICCOLO_PIXEL_FORMAT_R32G32B32A32_FLOAT + RHI_PIPELINE_BIND_POINT_GRAPHICS = 0, + RHI_PIPELINE_BIND_POINT_COMPUTE = 1, + RHI_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000, + RHI_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003, + RHI_PIPELINE_BIND_POINT_RAY_TRACING_NV = RHI_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + RHI_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF }; + enum RHIPolygonMode : int + { + RHI_POLYGON_MODE_FILL = 0, + RHI_POLYGON_MODE_LINE = 1, + RHI_POLYGON_MODE_POINT = 2, + RHI_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, + RHI_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIPrimitiveTopology : int + { + RHI_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + RHI_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + RHI_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + RHI_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + RHI_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + RHI_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + RHI_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + RHI_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHISamplerAddressMode : int + { + RHI_SAMPLER_ADDRESS_MODE_REPEAT = 0, + RHI_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + RHI_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + RHI_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + RHI_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + RHI_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = RHI_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, + RHI_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHISamplerMipmapMode : int + { + RHI_SAMPLER_MIPMAP_MODE_NEAREST = 0, + RHI_SAMPLER_MIPMAP_MODE_LINEAR = 1, + RHI_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIShaderStageFlagBits : int + { + RHI_SHADER_STAGE_VERTEX_BIT = 0x00000001, + RHI_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, + RHI_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, + RHI_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, + RHI_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, + RHI_SHADER_STAGE_COMPUTE_BIT = 0x00000020, + RHI_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, + RHI_SHADER_STAGE_ALL = 0x7FFFFFFF, + RHI_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100, + RHI_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200, + RHI_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400, + RHI_SHADER_STAGE_MISS_BIT_KHR = 0x00000800, + RHI_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000, + RHI_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000, + RHI_SHADER_STAGE_TASK_BIT_NV = 0x00000040, + RHI_SHADER_STAGE_MESH_BIT_NV = 0x00000080, + RHI_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000, + RHI_SHADER_STAGE_RAYGEN_BIT_NV = RHI_SHADER_STAGE_RAYGEN_BIT_KHR, + RHI_SHADER_STAGE_ANY_HIT_BIT_NV = RHI_SHADER_STAGE_ANY_HIT_BIT_KHR, + RHI_SHADER_STAGE_CLOSEST_HIT_BIT_NV = RHI_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, + RHI_SHADER_STAGE_MISS_BIT_NV = RHI_SHADER_STAGE_MISS_BIT_KHR, + RHI_SHADER_STAGE_INTERSECTION_BIT_NV = RHI_SHADER_STAGE_INTERSECTION_BIT_KHR, + RHI_SHADER_STAGE_CALLABLE_BIT_NV = RHI_SHADER_STAGE_CALLABLE_BIT_KHR, + RHI_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIComponentSwizzle : int { + RHI_COMPONENT_SWIZZLE_IDENTITY = 0, + RHI_COMPONENT_SWIZZLE_ZERO = 1, + RHI_COMPONENT_SWIZZLE_ONE = 2, + RHI_COMPONENT_SWIZZLE_R = 3, + RHI_COMPONENT_SWIZZLE_G = 4, + RHI_COMPONENT_SWIZZLE_B = 5, + RHI_COMPONENT_SWIZZLE_A = 6, + RHI_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIBlendOp : int { + RHI_BLEND_OP_ADD = 0, + RHI_BLEND_OP_SUBTRACT = 1, + RHI_BLEND_OP_REVERSE_SUBTRACT = 2, + RHI_BLEND_OP_MIN = 3, + RHI_BLEND_OP_MAX = 4, + RHI_BLEND_OP_ZERO_EXT = 1000148000, + RHI_BLEND_OP_SRC_EXT = 1000148001, + RHI_BLEND_OP_DST_EXT = 1000148002, + RHI_BLEND_OP_SRC_OVER_EXT = 1000148003, + RHI_BLEND_OP_DST_OVER_EXT = 1000148004, + RHI_BLEND_OP_SRC_IN_EXT = 1000148005, + RHI_BLEND_OP_DST_IN_EXT = 1000148006, + RHI_BLEND_OP_SRC_OUT_EXT = 1000148007, + RHI_BLEND_OP_DST_OUT_EXT = 1000148008, + RHI_BLEND_OP_SRC_ATOP_EXT = 1000148009, + RHI_BLEND_OP_DST_ATOP_EXT = 1000148010, + RHI_BLEND_OP_XOR_EXT = 1000148011, + RHI_BLEND_OP_MULTIPLY_EXT = 1000148012, + RHI_BLEND_OP_SCREEN_EXT = 1000148013, + RHI_BLEND_OP_OVERLAY_EXT = 1000148014, + RHI_BLEND_OP_DARKEN_EXT = 1000148015, + RHI_BLEND_OP_LIGHTEN_EXT = 1000148016, + RHI_BLEND_OP_COLORDODGE_EXT = 1000148017, + RHI_BLEND_OP_COLORBURN_EXT = 1000148018, + RHI_BLEND_OP_HARDLIGHT_EXT = 1000148019, + RHI_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + RHI_BLEND_OP_DIFFERENCE_EXT = 1000148021, + RHI_BLEND_OP_EXCLUSION_EXT = 1000148022, + RHI_BLEND_OP_INVERT_EXT = 1000148023, + RHI_BLEND_OP_INVERT_RGB_EXT = 1000148024, + RHI_BLEND_OP_LINEARDODGE_EXT = 1000148025, + RHI_BLEND_OP_LINEARBURN_EXT = 1000148026, + RHI_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + RHI_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + RHI_BLEND_OP_PINLIGHT_EXT = 1000148029, + RHI_BLEND_OP_HARDMIX_EXT = 1000148030, + RHI_BLEND_OP_HSL_HUE_EXT = 1000148031, + RHI_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + RHI_BLEND_OP_HSL_COLOR_EXT = 1000148033, + RHI_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + RHI_BLEND_OP_PLUS_EXT = 1000148035, + RHI_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + RHI_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + RHI_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + RHI_BLEND_OP_MINUS_EXT = 1000148039, + RHI_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + RHI_BLEND_OP_CONTRAST_EXT = 1000148041, + RHI_BLEND_OP_INVERT_OVG_EXT = 1000148042, + RHI_BLEND_OP_RED_EXT = 1000148043, + RHI_BLEND_OP_GREEN_EXT = 1000148044, + RHI_BLEND_OP_BLUE_EXT = 1000148045, + RHI_BLEND_OP_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIStencilOp : int { + RHI_STENCIL_OP_KEEP = 0, + RHI_STENCIL_OP_ZERO = 1, + RHI_STENCIL_OP_REPLACE = 2, + RHI_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + RHI_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + RHI_STENCIL_OP_INVERT = 5, + RHI_STENCIL_OP_INCREMENT_AND_WRAP = 6, + RHI_STENCIL_OP_DECREMENT_AND_WRAP = 7, + RHI_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIVertexInputRate : int { + RHI_VERTEX_INPUT_RATE_VERTEX = 0, + RHI_VERTEX_INPUT_RATE_INSTANCE = 1, + RHI_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIBlendFactor { + RHI_BLEND_FACTOR_ZERO = 0, + RHI_BLEND_FACTOR_ONE = 1, + RHI_BLEND_FACTOR_SRC_COLOR = 2, + RHI_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + RHI_BLEND_FACTOR_DST_COLOR = 4, + RHI_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + RHI_BLEND_FACTOR_SRC_ALPHA = 6, + RHI_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + RHI_BLEND_FACTOR_DST_ALPHA = 8, + RHI_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + RHI_BLEND_FACTOR_CONSTANT_COLOR = 10, + RHI_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + RHI_BLEND_FACTOR_CONSTANT_ALPHA = 12, + RHI_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + RHI_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + RHI_BLEND_FACTOR_SRC1_COLOR = 15, + RHI_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + RHI_BLEND_FACTOR_SRC1_ALPHA = 17, + RHI_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + RHI_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIImageAspectFlagBits { + RHI_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + RHI_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + RHI_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + RHI_IMAGE_ASPECT_METADATA_BIT = 0x00000008, + RHI_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, + RHI_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, + RHI_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, + RHI_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080, + RHI_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, + RHI_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, + RHI_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, + RHI_IMAGE_ASPECT_PLANE_0_BIT_KHR = RHI_IMAGE_ASPECT_PLANE_0_BIT, + RHI_IMAGE_ASPECT_PLANE_1_BIT_KHR = RHI_IMAGE_ASPECT_PLANE_1_BIT, + RHI_IMAGE_ASPECT_PLANE_2_BIT_KHR = RHI_IMAGE_ASPECT_PLANE_2_BIT, + RHI_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIBufferUsageFlagBits { + RHI_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, + RHI_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, + RHI_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, + RHI_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, + RHI_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, + RHI_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, + RHI_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, + RHI_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, + RHI_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, + RHI_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000, + RHI_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800, + RHI_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, + RHI_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, + RHI_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000, + RHI_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000, + RHI_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400, + RHI_BUFFER_USAGE_RAY_TRACING_BIT_NV = RHI_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, + RHI_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = RHI_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + RHI_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = RHI_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + RHI_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIMemoryPropertyFlagBits { + RHI_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, + RHI_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, + RHI_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, + RHI_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, + RHI_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, + RHI_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, + RHI_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040, + RHI_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080, + RHI_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0x00000100, + RHI_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIPipelineStageFlagBits { + RHI_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, + RHI_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, + RHI_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, + RHI_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, + RHI_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, + RHI_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, + RHI_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, + RHI_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, + RHI_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, + RHI_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, + RHI_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, + RHI_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, + RHI_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, + RHI_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, + RHI_PIPELINE_STAGE_HOST_BIT = 0x00004000, + RHI_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, + RHI_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, + RHI_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000, + RHI_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, + RHI_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000, + RHI_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000, + RHI_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000, + RHI_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000, + RHI_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, + RHI_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000, + RHI_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000, + RHI_PIPELINE_STAGE_NONE_KHR = 0, + RHI_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = RHI_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + RHI_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = RHI_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, + RHI_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = RHI_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, + RHI_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIAccessFlagBits { + RHI_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, + RHI_ACCESS_INDEX_READ_BIT = 0x00000002, + RHI_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, + RHI_ACCESS_UNIFORM_READ_BIT = 0x00000008, + RHI_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, + RHI_ACCESS_SHADER_READ_BIT = 0x00000020, + RHI_ACCESS_SHADER_WRITE_BIT = 0x00000040, + RHI_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, + RHI_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, + RHI_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, + RHI_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, + RHI_ACCESS_TRANSFER_READ_BIT = 0x00000800, + RHI_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, + RHI_ACCESS_HOST_READ_BIT = 0x00002000, + RHI_ACCESS_HOST_WRITE_BIT = 0x00004000, + RHI_ACCESS_MEMORY_READ_BIT = 0x00008000, + RHI_ACCESS_MEMORY_WRITE_BIT = 0x00010000, + RHI_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000, + RHI_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000, + RHI_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000, + RHI_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, + RHI_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, + RHI_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000, + RHI_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000, + RHI_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000, + RHI_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000, + RHI_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000, + RHI_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000, + RHI_ACCESS_NONE_KHR = 0, + RHI_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = RHI_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, + RHI_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = RHI_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, + RHI_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = RHI_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, + RHI_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHICullModeFlagBits { + RHI_CULL_MODE_NONE = 0, + RHI_CULL_MODE_FRONT_BIT = 0x00000001, + RHI_CULL_MODE_BACK_BIT = 0x00000002, + RHI_CULL_MODE_FRONT_AND_BACK = 0x00000003, + RHI_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIColorComponentFlagBits { + RHI_COLOR_COMPONENT_R_BIT = 0x00000001, + RHI_COLOR_COMPONENT_G_BIT = 0x00000002, + RHI_COLOR_COMPONENT_B_BIT = 0x00000004, + RHI_COLOR_COMPONENT_A_BIT = 0x00000008, + RHI_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHICommandPoolCreateFlagBits { + RHI_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + RHI_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, + RHI_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, + RHI_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIImageUsageFlagBits { + RHI_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, + RHI_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, + RHI_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, + RHI_IMAGE_USAGE_STORAGE_BIT = 0x00000008, + RHI_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, + RHI_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, + RHI_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, + RHI_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, + RHI_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, + RHI_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100, + RHI_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, + RHI_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = RHI_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + RHI_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIIndexType { + RHI_INDEX_TYPE_UINT16 = 0, + RHI_INDEX_TYPE_UINT32 = 1, + RHI_INDEX_TYPE_NONE_KHR = 1000165000, + RHI_INDEX_TYPE_UINT8_EXT = 1000265000, + RHI_INDEX_TYPE_NONE_NV = RHI_INDEX_TYPE_NONE_KHR, + RHI_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHISubpassContents { + RHI_SUBPASS_CONTENTS_INLINE = 0, + RHI_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + RHI_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIFenceCreateFlagBits { + RHI_FENCE_CREATE_SIGNALED_BIT = 0x00000001, + RHI_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHICommandBufferUsageFlagBits { + RHI_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, + RHI_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, + RHI_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, + RHI_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + enum RHIDefaultSamplerType + { + Default_Sampler_Linear, + Default_Sampler_Nearest + }; + + enum RHIDependencyFlagBits { + RHI_DEPENDENCY_BY_REGION_BIT = 0x00000001, + RHI_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, + RHI_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, + RHI_DEPENDENCY_VIEW_LOCAL_BIT_KHR = RHI_DEPENDENCY_VIEW_LOCAL_BIT, + RHI_DEPENDENCY_DEVICE_GROUP_BIT_KHR = RHI_DEPENDENCY_DEVICE_GROUP_BIT, + RHI_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }; + + typedef uint32_t RHIAccessFlags; + typedef uint32_t RHIImageAspectFlags; + typedef uint32_t RHIFormatFeatureFlags; + typedef uint32_t RHIImageCreateFlags; + typedef uint32_t RHISampleCountFlags; + typedef uint32_t RHIImageUsageFlags; + typedef uint32_t RHIInstanceCreateFlags; + typedef uint32_t RHIMemoryHeapFlags; + typedef uint32_t RHIMemoryPropertyFlags; + typedef uint32_t RHIQueueFlags; + typedef uint32_t RHIDeviceCreateFlags; + typedef uint32_t RHIDeviceQueueCreateFlags; + typedef uint32_t RHIPipelineStageFlags; + typedef uint32_t RHIMemoryMapFlags; + typedef uint32_t RHISparseMemoryBindFlags; + typedef uint32_t RHISparseImageFormatFlags; + typedef uint32_t RHIFenceCreateFlags; + typedef uint32_t RHISemaphoreCreateFlags; + typedef uint32_t RHIEventCreateFlags; + typedef uint32_t RHIQueryPipelineStatisticFlags; + typedef uint32_t RHIQueryPoolCreateFlags; + typedef uint32_t RHIQueryResultFlags; + typedef uint32_t RHIBufferCreateFlags; + typedef uint32_t RHIBufferUsageFlags; + typedef uint32_t RHIBufferViewCreateFlags; + typedef uint32_t RHIImageViewCreateFlags; + typedef uint32_t RHIShaderModuleCreateFlags; + typedef uint32_t RHIPipelineCacheCreateFlags; + typedef uint32_t RHIColorComponentFlags; + typedef uint32_t RHIPipelineCreateFlags; + typedef uint32_t RHIPipelineShaderStageCreateFlags; + typedef uint32_t RHICullModeFlags; + typedef uint32_t RHIPipelineVertexInputStateCreateFlags; + typedef uint32_t RHIPipelineInputAssemblyStateCreateFlags; + typedef uint32_t RHIPipelineTessellationStateCreateFlags; + typedef uint32_t RHIPipelineViewportStateCreateFlags; + typedef uint32_t RHIPipelineRasterizationStateCreateFlags; + typedef uint32_t RHIPipelineMultisampleStateCreateFlags; + typedef uint32_t RHIPipelineDepthStencilStateCreateFlags; + typedef uint32_t RHIPipelineColorBlendStateCreateFlags; + typedef uint32_t RHIPipelineDynamicStateCreateFlags; + typedef uint32_t RHIPipelineLayoutCreateFlags; + typedef uint32_t RHIShaderStageFlags; + typedef uint32_t RHISamplerCreateFlags; + typedef uint32_t RHIDescriptorPoolCreateFlags; + typedef uint32_t RHIDescriptorPoolResetFlags; + typedef uint32_t RHIDescriptorSetLayoutCreateFlags; + typedef uint32_t RHIAttachmentDescriptionFlags; + typedef uint32_t RHIDependencyFlags; + typedef uint32_t RHIFramebufferCreateFlags; + typedef uint32_t RHIRenderPassCreateFlags; + typedef uint32_t RHICommandPoolCreateFlags; + typedef uint32_t RHISubpassDescriptionFlags; + typedef uint32_t RHICommandPoolResetFlags; + typedef uint32_t RHICommandBufferUsageFlags; + typedef uint32_t RHIQueryControlFlags; + typedef uint32_t RHICommandBufferResetFlags; + typedef uint32_t RHIStencilFaceFlags; + typedef uint32_t RHIBool32; + typedef uint64_t RHIDeviceAddress; + typedef uint64_t RHIDeviceSize; + typedef uint32_t RHIFlags; + typedef uint32_t RHISampleMask; +} + +namespace Piccolo +{ enum class PICCOLO_IMAGE_TYPE : uint8_t { PICCOLO_IMAGE_TYPE_UNKNOWM = 0, @@ -65,8 +1728,8 @@ namespace Piccolo uint32_t m_array_layers {0}; void* m_pixels {nullptr}; - PICCOLO_PIXEL_FORMAT m_format {PICCOLO_PIXEL_FORMAT::PICCOLO_PIXEL_FORMAT_UNKNOWN}; - PICCOLO_IMAGE_TYPE m_type {PICCOLO_IMAGE_TYPE::PICCOLO_IMAGE_TYPE_UNKNOWM}; + RHIFormat m_format = RHI_FORMAT_MAX_ENUM; + PICCOLO_IMAGE_TYPE m_type { PICCOLO_IMAGE_TYPE::PICCOLO_IMAGE_TYPE_UNKNOWM}; TextureData() = default; ~TextureData() diff --git a/engine/source/runtime/function/render/rhi.cpp b/engine/source/runtime/function/render/rhi.cpp deleted file mode 100644 index cc5fe4231..000000000 --- a/engine/source/runtime/function/render/rhi.cpp +++ /dev/null @@ -1,4 +0,0 @@ -#include "runtime/function/render/rhi.h" - -namespace Piccolo -{} \ No newline at end of file diff --git a/engine/source/runtime/function/render/rhi.h b/engine/source/runtime/function/render/rhi.h deleted file mode 100644 index d937ccedc..000000000 --- a/engine/source/runtime/function/render/rhi.h +++ /dev/null @@ -1,41 +0,0 @@ -#pragma once - -#define GLFW_INCLUDE_VULKAN -#include - -#include - -namespace Piccolo -{ - class WindowSystem; - - struct RHIInitInfo - { - std::shared_ptr window_system; - }; - - class RHI - { - public: - virtual ~RHI() = 0; - - virtual void initialize(RHIInitInfo initialize_info) = 0; - virtual void prepareContext() = 0; - bool isValidationLayerEnabled() const { return m_enable_validation_Layers; } - bool isDebugLabelEnabled() const { return m_enable_debug_utils_label; } - bool isPointLightShadowEnabled() const { return m_enable_point_light_shadow; } - - protected: - bool m_enable_validation_Layers {true}; - bool m_enable_debug_utils_label {true}; - bool m_enable_point_light_shadow {true}; - - // used in descriptor pool creation - uint32_t m_max_vertex_blending_mesh_count {256}; - uint32_t m_max_material_count {256}; - - private: - }; - - inline RHI::~RHI() = default; -} // namespace Piccolo diff --git a/engine/source/runtime/function/render/rhi/vulkan/vulkan_rhi.cpp b/engine/source/runtime/function/render/rhi/vulkan/vulkan_rhi.cpp deleted file mode 100644 index 7b05f5bb2..000000000 --- a/engine/source/runtime/function/render/rhi/vulkan/vulkan_rhi.cpp +++ /dev/null @@ -1,1124 +0,0 @@ -#include "runtime/function/render/rhi/vulkan/vulkan_rhi.h" -#include "runtime/function/render/rhi/vulkan/vulkan_util.h" - -#include "runtime/function/render/window_system.h" - -#include -#include - -// https://gcc.gnu.org/onlinedocs/cpp/Stringizing.html -#define PICCOLO_XSTR(s) PICCOLO_STR(s) -#define PICCOLO_STR(s) #s - -#if defined(__GNUC__) -// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html -#if defined(__linux__) -#include -#elif defined(__MACH__) -// https://developer.apple.com/library/archive/documentation/Porting/Conceptual/PortingUnix/compiling/compiling.html -#include -#else -#error Unknown Platform -#endif -#elif defined(_MSC_VER) -// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros -#include -#define WIN32_LEAN_AND_MEAN 1 -#define NOGDICAPMASKS 1 -#define NOVIRTUALKEYCODES 1 -#define NOWINMESSAGES 1 -#define NOWINSTYLES 1 -#define NOSYSMETRICS 1 -#define NOMENUS 1 -#define NOICONS 1 -#define NOKEYSTATES 1 -#define NOSYSCOMMANDS 1 -#define NORASTEROPS 1 -#define NOSHOWWINDOW 1 -#define NOATOM 1 -#define NOCLIPBOARD 1 -#define NOCOLOR 1 -#define NOCTLMGR 1 -#define NODRAWTEXT 1 -#define NOGDI 1 -#define NOKERNEL 1 -#define NOUSER 1 -#define NONLS 1 -#define NOMB 1 -#define NOMEMMGR 1 -#define NOMETAFILE 1 -#define NOMINMAX 1 -#define NOMSG 1 -#define NOOPENFILE 1 -#define NOSCROLL 1 -#define NOSERVICE 1 -#define NOSOUND 1 -#define NOTEXTMETRIC 1 -#define NOWH 1 -#define NOWINOFFSETS 1 -#define NOCOMM 1 -#define NOKANJI 1 -#define NOHELP 1 -#define NOPROFILER 1 -#define NODEFERWINDOWPOS 1 -#define NOMCX 1 -#include -#else -#error Unknown Compiler -#endif - -#include -#include -#include -#include -#include - -namespace Piccolo -{ - VulkanRHI::~VulkanRHI() - { - // TODO - } - - void VulkanRHI::initialize(RHIInitInfo init_info) - { - m_window = init_info.window_system->getWindow(); - - std::array window_size = init_info.window_system->getWindowSize(); - - m_viewport = {0.0f, 0.0f, (float)window_size[0], (float)window_size[1], 0.0f, 1.0f}; - m_scissor = {{0, 0}, {(uint32_t)window_size[0], (uint32_t)window_size[1]}}; - -#ifndef NDEBUG - m_enable_validation_Layers = true; - m_enable_debug_utils_label = true; -#else - m_enable_validation_Layers = false; - m_enable_debug_utils_label = false; -#endif - -#if defined(__GNUC__) && defined(__MACH__) - m_enable_point_light_shadow = false; -#else - m_enable_point_light_shadow = true; -#endif - -#if defined(__GNUC__) - // https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html -#if defined(__linux__) - char const* vk_layer_path = PICCOLO_XSTR(PICCOLO_VK_LAYER_PATH); - setenv("VK_LAYER_PATH", vk_layer_path, 1); -#elif defined(__MACH__) - // https://developer.apple.com/library/archive/documentation/Porting/Conceptual/PortingUnix/compiling/compiling.html - char const* vk_layer_path = PICCOLO_XSTR(PICCOLO_VK_LAYER_PATH); - char const* vk_icd_filenames = PICCOLO_XSTR(PICCOLO_VK_ICD_FILENAMES); - setenv("VK_LAYER_PATH", vk_layer_path, 1); - setenv("VK_ICD_FILENAMES", vk_icd_filenames, 1); -#else -#error Unknown Platform -#endif -#elif defined(_MSC_VER) - // https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros - char const* vk_layer_path = PICCOLO_XSTR(PICCOLO_VK_LAYER_PATH); - SetEnvironmentVariableA("VK_LAYER_PATH", vk_layer_path); - SetEnvironmentVariableA("DISABLE_LAYER_AMD_SWITCHABLE_GRAPHICS_1", "1"); -#else -#error Unknown Compiler -#endif - - createInstance(); - - initializeDebugMessenger(); - - createWindowSurface(); - - initializePhysicalDevice(); - - createLogicalDevice(); - - createCommandPool(); - - createCommandBuffers(); - - createDescriptorPool(); - - createSyncPrimitives(); - - createSwapchain(); - - createSwapchainImageViews(); - - createFramebufferImageAndView(); - - createAssetAllocator(); - } - - void VulkanRHI::prepareContext() - { - m_p_current_frame_index = &m_current_frame_index; - m_current_command_buffer = m_command_buffers[m_current_frame_index]; - m_p_command_buffers = m_command_buffers; - m_p_command_pools = m_command_pools; - } - - void VulkanRHI::clear() - { - if (m_enable_validation_Layers) - { - destroyDebugUtilsMessengerEXT(m_instance, m_debug_messenger, nullptr); - } - } - - void VulkanRHI::waitForFences() - { - VkResult res_wait_for_fences = - m_vk_wait_for_fences(m_device, 1, &m_is_frame_in_flight_fences[m_current_frame_index], VK_TRUE, UINT64_MAX); - if (VK_SUCCESS != res_wait_for_fences) - { - throw std::runtime_error("failed to synchronize"); - } - } - - void VulkanRHI::resetCommandPool() - { - VkResult res_reset_command_pool = m_vk_reset_command_pool(m_device, m_command_pools[m_current_frame_index], 0); - if (VK_SUCCESS != res_reset_command_pool) - { - throw std::runtime_error("failed to synchronize"); - } - } - - bool VulkanRHI::prepareBeforePass(std::function passUpdateAfterRecreateSwapchain) - { - VkResult acquire_image_result = - vkAcquireNextImageKHR(m_device, - m_swapchain, - UINT64_MAX, - m_image_available_for_render_semaphores[m_current_frame_index], - VK_NULL_HANDLE, - &m_current_swapchain_image_index); - - if (VK_ERROR_OUT_OF_DATE_KHR == acquire_image_result) - { - recreateSwapchain(); - passUpdateAfterRecreateSwapchain(); - return true; - } - else if (VK_SUBOPTIMAL_KHR == acquire_image_result) - { - recreateSwapchain(); - passUpdateAfterRecreateSwapchain(); - - // NULL submit to wait semaphore - VkPipelineStageFlags wait_stages[] = {VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT}; - VkSubmitInfo submit_info = {}; - submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; - submit_info.waitSemaphoreCount = 1; - submit_info.pWaitSemaphores = &m_image_available_for_render_semaphores[m_current_frame_index]; - submit_info.pWaitDstStageMask = wait_stages; - submit_info.commandBufferCount = 0; - submit_info.pCommandBuffers = NULL; - submit_info.signalSemaphoreCount = 0; - submit_info.pSignalSemaphores = NULL; - - VkResult res_reset_fences = - m_vk_reset_fences(m_device, 1, &m_is_frame_in_flight_fences[m_current_frame_index]); - assert(VK_SUCCESS == res_reset_fences); - - VkResult res_queue_submit = - vkQueueSubmit(m_graphics_queue, 1, &submit_info, m_is_frame_in_flight_fences[m_current_frame_index]); - assert(VK_SUCCESS == res_queue_submit); - - m_current_frame_index = (m_current_frame_index + 1) % s_max_frames_in_flight; - return true; - } - else - { - assert(VK_SUCCESS == acquire_image_result); - } - - // begin command buffer - VkCommandBufferBeginInfo command_buffer_begin_info {}; - command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; - command_buffer_begin_info.flags = 0; - command_buffer_begin_info.pInheritanceInfo = nullptr; - - VkResult res_begin_command_buffer = - m_vk_begin_command_buffer(m_command_buffers[m_current_frame_index], &command_buffer_begin_info); - assert(VK_SUCCESS == res_begin_command_buffer); - - return false; - } - - void VulkanRHI::submitRendering(std::function passUpdateAfterRecreateSwapchain) - { - // end command buffer - VkResult res_end_command_buffer = m_vk_end_command_buffer(m_command_buffers[m_current_frame_index]); - assert(VK_SUCCESS == res_end_command_buffer); - - VkSemaphore semaphores[2] = {m_image_available_for_texturescopy_semaphores[m_current_frame_index], - m_image_finished_for_presentation_semaphores[m_current_frame_index]}; - // submit command buffer - VkPipelineStageFlags wait_stages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT}; - VkSubmitInfo submit_info = {}; - submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; - submit_info.waitSemaphoreCount = 1; - submit_info.pWaitSemaphores = &m_image_available_for_render_semaphores[m_current_frame_index]; - submit_info.pWaitDstStageMask = wait_stages; - submit_info.commandBufferCount = 1; - submit_info.pCommandBuffers = &m_command_buffers[m_current_frame_index]; - submit_info.signalSemaphoreCount = 2; - submit_info.pSignalSemaphores = semaphores; - - VkResult res_reset_fences = m_vk_reset_fences(m_device, 1, &m_is_frame_in_flight_fences[m_current_frame_index]); - assert(VK_SUCCESS == res_reset_fences); - - VkResult res_queue_submit = - vkQueueSubmit(m_graphics_queue, 1, &submit_info, m_is_frame_in_flight_fences[m_current_frame_index]); - assert(VK_SUCCESS == res_queue_submit); - - // present swapchain - VkPresentInfoKHR present_info = {}; - present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; - present_info.waitSemaphoreCount = 1; - present_info.pWaitSemaphores = &m_image_finished_for_presentation_semaphores[m_current_frame_index]; - present_info.swapchainCount = 1; - present_info.pSwapchains = &m_swapchain; - present_info.pImageIndices = &m_current_swapchain_image_index; - - VkResult present_result = vkQueuePresentKHR(m_present_queue, &present_info); - if (VK_ERROR_OUT_OF_DATE_KHR == present_result || VK_SUBOPTIMAL_KHR == present_result) - { - recreateSwapchain(); - passUpdateAfterRecreateSwapchain(); - } - else - { - assert(VK_SUCCESS == present_result); - } - - m_current_frame_index = (m_current_frame_index + 1) % s_max_frames_in_flight; - } - - VkCommandBuffer VulkanRHI::beginSingleTimeCommands() - { - VkCommandBufferAllocateInfo allocInfo {}; - allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; - allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; - allocInfo.commandPool = m_command_pool; - allocInfo.commandBufferCount = 1; - - VkCommandBuffer command_buffer; - vkAllocateCommandBuffers(m_device, &allocInfo, &command_buffer); - - VkCommandBufferBeginInfo beginInfo {}; - beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; - beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; - - m_vk_begin_command_buffer(command_buffer, &beginInfo); - - return command_buffer; - } - - void VulkanRHI::endSingleTimeCommands(VkCommandBuffer command_buffer) - { - m_vk_end_command_buffer(command_buffer); - - VkSubmitInfo submitInfo {}; - submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; - submitInfo.commandBufferCount = 1; - submitInfo.pCommandBuffers = &command_buffer; - - vkQueueSubmit(m_graphics_queue, 1, &submitInfo, VK_NULL_HANDLE); - vkQueueWaitIdle(m_graphics_queue); - - vkFreeCommandBuffers(m_device, m_command_pool, 1, &command_buffer); - } - - // validation layers - bool VulkanRHI::checkValidationLayerSupport() - { - uint32_t layerCount; - vkEnumerateInstanceLayerProperties(&layerCount, nullptr); - - std::vector availableLayers(layerCount); - vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data()); - - for (const char* layerName : m_validation_layers) - { - bool layerFound = false; - - for (const auto& layerProperties : availableLayers) - { - if (strcmp(layerName, layerProperties.layerName) == 0) - { - layerFound = true; - break; - } - } - - if (!layerFound) - { - return false; - } - } - - return true; - } - - std::vector VulkanRHI::getRequiredExtensions() - { - uint32_t glfwExtensionCount = 0; - const char** glfwExtensions; - glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); - - std::vector extensions(glfwExtensions, glfwExtensions + glfwExtensionCount); - - if (m_enable_validation_Layers || m_enable_debug_utils_label) - { - extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); - } - -#if defined(__MACH__) - extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); -#endif - - return extensions; - } - - // debug callback - static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT, - VkDebugUtilsMessageTypeFlagsEXT, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, - void*) - { - std::cerr << "validation layer: " << pCallbackData->pMessage << std::endl; - return VK_FALSE; - } - - void VulkanRHI::populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) - { - createInfo = {}; - createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; - createInfo.messageSeverity = - VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; - createInfo.messageType = - VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; - createInfo.pfnUserCallback = debugCallback; - } - - void VulkanRHI::createInstance() - { - // validation layer will be enabled in debug mode - if (m_enable_validation_Layers && !checkValidationLayerSupport()) - { - throw std::runtime_error("validation layers requested, but not available!"); - } - - m_vulkan_api_version = VK_API_VERSION_1_0; - - // app info - VkApplicationInfo appInfo {}; - appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; - appInfo.pApplicationName = "pilot_renderer"; - appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0); - appInfo.pEngineName = "Piccolo"; - appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0); - appInfo.apiVersion = m_vulkan_api_version; - - // create info - VkInstanceCreateInfo instance_create_info {}; - instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; - instance_create_info.pApplicationInfo = &appInfo; // the appInfo is stored here - - auto extensions = getRequiredExtensions(); - instance_create_info.enabledExtensionCount = static_cast(extensions.size()); - instance_create_info.ppEnabledExtensionNames = extensions.data(); - - VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo {}; - if (m_enable_validation_Layers) - { - instance_create_info.enabledLayerCount = static_cast(m_validation_layers.size()); - instance_create_info.ppEnabledLayerNames = m_validation_layers.data(); - - populateDebugMessengerCreateInfo(debugCreateInfo); - instance_create_info.pNext = (VkDebugUtilsMessengerCreateInfoEXT*)&debugCreateInfo; - } - else - { - instance_create_info.enabledLayerCount = 0; - instance_create_info.pNext = nullptr; - } - - // create m_vulkan_context._instance - if (vkCreateInstance(&instance_create_info, nullptr, &m_instance) != VK_SUCCESS) - { - throw std::runtime_error("vk create instance"); - } - } - - void VulkanRHI::initializeDebugMessenger() - { - if (m_enable_validation_Layers) - { - VkDebugUtilsMessengerCreateInfoEXT createInfo; - populateDebugMessengerCreateInfo(createInfo); - if (VK_SUCCESS != createDebugUtilsMessengerEXT(m_instance, &createInfo, nullptr, &m_debug_messenger)) - { - throw std::runtime_error("failed to set up debug messenger!"); - } - } - - if (m_enable_debug_utils_label) - { - m_vk_cmd_begin_debug_utils_label_ext = - (PFN_vkCmdBeginDebugUtilsLabelEXT)vkGetInstanceProcAddr(m_instance, "vkCmdBeginDebugUtilsLabelEXT"); - m_vk_cmd_end_debug_utils_label_ext = - (PFN_vkCmdEndDebugUtilsLabelEXT)vkGetInstanceProcAddr(m_instance, "vkCmdEndDebugUtilsLabelEXT"); - } - } - - void VulkanRHI::createWindowSurface() - { - if (glfwCreateWindowSurface(m_instance, m_window, nullptr, &m_surface) != VK_SUCCESS) - { - throw std::runtime_error("glfwCreateWindowSurface"); - } - } - - void VulkanRHI::initializePhysicalDevice() - { - uint32_t physical_device_count; - vkEnumeratePhysicalDevices(m_instance, &physical_device_count, nullptr); - if (physical_device_count == 0) - { - throw std::runtime_error("enumerate physical devices"); - } - else - { - // find one device that matches our requirement - // or find which is the best - std::vector physical_devices(physical_device_count); - vkEnumeratePhysicalDevices(m_instance, &physical_device_count, physical_devices.data()); - - std::vector> ranked_physical_devices; - for (const auto& device : physical_devices) - { - VkPhysicalDeviceProperties physical_device_properties; - vkGetPhysicalDeviceProperties(device, &physical_device_properties); - int score = 0; - - if (physical_device_properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) - { - score += 1000; - } - else if (physical_device_properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) - { - score += 100; - } - - ranked_physical_devices.push_back({score, device}); - } - - std::sort(ranked_physical_devices.begin(), - ranked_physical_devices.end(), - [](const std::pair& p1, const std::pair& p2) { - return p1 > p2; - }); - - for (const auto& device : ranked_physical_devices) - { - if (isDeviceSuitable(device.second)) - { - m_physical_device = device.second; - break; - } - } - - if (m_physical_device == VK_NULL_HANDLE) - { - throw std::runtime_error("failed to find suitable physical device"); - } - } - } - - // logical device (m_vulkan_context._device : graphic queue, present queue, - // feature:samplerAnisotropy) - void VulkanRHI::createLogicalDevice() - { - m_queue_indices = findQueueFamilies(m_physical_device); - - std::vector queue_create_infos; // all queues that need to be created - std::set queue_families = {m_queue_indices.m_graphics_family.value(), - m_queue_indices.m_present_family.value(), - m_queue_indices.m_compute_family.value()}; - - float queue_priority = 1.0f; - for (uint32_t queue_family : queue_families) // for every queue family - { - // queue create info - VkDeviceQueueCreateInfo queue_create_info {}; - queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; - queue_create_info.queueFamilyIndex = queue_family; - queue_create_info.queueCount = 1; - queue_create_info.pQueuePriorities = &queue_priority; - queue_create_infos.push_back(queue_create_info); - } - - // physical device features - VkPhysicalDeviceFeatures physical_device_features = {}; - - physical_device_features.samplerAnisotropy = VK_TRUE; - - // support inefficient readback storage buffer - physical_device_features.fragmentStoresAndAtomics = VK_TRUE; - - // support independent blending - physical_device_features.independentBlend = VK_TRUE; - - // support geometry shader - if (m_enable_point_light_shadow) - { - physical_device_features.geometryShader = VK_TRUE; - } - - // device create info - VkDeviceCreateInfo device_create_info {}; - device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; - device_create_info.pQueueCreateInfos = queue_create_infos.data(); - device_create_info.queueCreateInfoCount = static_cast(queue_create_infos.size()); - device_create_info.pEnabledFeatures = &physical_device_features; - device_create_info.enabledExtensionCount = static_cast(m_device_extensions.size()); - device_create_info.ppEnabledExtensionNames = m_device_extensions.data(); - device_create_info.enabledLayerCount = 0; - - if (vkCreateDevice(m_physical_device, &device_create_info, nullptr, &m_device) != VK_SUCCESS) - { - throw std::runtime_error("vk create device"); - } - - // initialize queues of this device - vkGetDeviceQueue(m_device, m_queue_indices.m_graphics_family.value(), 0, &m_graphics_queue); - vkGetDeviceQueue(m_device, m_queue_indices.m_present_family.value(), 0, &m_present_queue); - vkGetDeviceQueue(m_device, m_queue_indices.m_compute_family.value(), 0, &m_compute_queue); - - // more efficient pointer - m_vk_wait_for_fences = (PFN_vkWaitForFences)vkGetDeviceProcAddr(m_device, "vkWaitForFences"); - m_vk_reset_fences = (PFN_vkResetFences)vkGetDeviceProcAddr(m_device, "vkResetFences"); - m_vk_reset_command_pool = (PFN_vkResetCommandPool)vkGetDeviceProcAddr(m_device, "vkResetCommandPool"); - m_vk_begin_command_buffer = (PFN_vkBeginCommandBuffer)vkGetDeviceProcAddr(m_device, "vkBeginCommandBuffer"); - m_vk_end_command_buffer = (PFN_vkEndCommandBuffer)vkGetDeviceProcAddr(m_device, "vkEndCommandBuffer"); - m_vk_cmd_begin_render_pass = (PFN_vkCmdBeginRenderPass)vkGetDeviceProcAddr(m_device, "vkCmdBeginRenderPass"); - m_vk_cmd_next_subpass = (PFN_vkCmdNextSubpass)vkGetDeviceProcAddr(m_device, "vkCmdNextSubpass"); - m_vk_cmd_end_render_pass = (PFN_vkCmdEndRenderPass)vkGetDeviceProcAddr(m_device, "vkCmdEndRenderPass"); - m_vk_cmd_bind_pipeline = (PFN_vkCmdBindPipeline)vkGetDeviceProcAddr(m_device, "vkCmdBindPipeline"); - m_vk_cmd_set_viewport = (PFN_vkCmdSetViewport)vkGetDeviceProcAddr(m_device, "vkCmdSetViewport"); - m_vk_cmd_set_scissor = (PFN_vkCmdSetScissor)vkGetDeviceProcAddr(m_device, "vkCmdSetScissor"); - m_vk_cmd_bind_vertex_buffers = - (PFN_vkCmdBindVertexBuffers)vkGetDeviceProcAddr(m_device, "vkCmdBindVertexBuffers"); - m_vk_cmd_bind_index_buffer = (PFN_vkCmdBindIndexBuffer)vkGetDeviceProcAddr(m_device, "vkCmdBindIndexBuffer"); - m_vk_cmd_bind_descriptor_sets = - (PFN_vkCmdBindDescriptorSets)vkGetDeviceProcAddr(m_device, "vkCmdBindDescriptorSets"); - m_vk_cmd_draw_indexed = (PFN_vkCmdDrawIndexed)vkGetDeviceProcAddr(m_device, "vkCmdDrawIndexed"); - m_vk_cmd_clear_attachments = (PFN_vkCmdClearAttachments)vkGetDeviceProcAddr(m_device, "vkCmdClearAttachments"); - - m_depth_image_format = findDepthFormat(); - } - - void VulkanRHI::createCommandPool() - { - // default graphics command pool - { - VkCommandPoolCreateInfo command_pool_create_info {}; - command_pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; - command_pool_create_info.pNext = NULL; - command_pool_create_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; - command_pool_create_info.queueFamilyIndex = m_queue_indices.m_graphics_family.value(); - - if (vkCreateCommandPool(m_device, &command_pool_create_info, nullptr, &m_command_pool) != VK_SUCCESS) - { - throw std::runtime_error("vk create command pool"); - } - } - - // other command pools - { - VkCommandPoolCreateInfo command_pool_create_info; - command_pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; - command_pool_create_info.pNext = NULL; - command_pool_create_info.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT; - command_pool_create_info.queueFamilyIndex = m_queue_indices.m_graphics_family.value(); - - for (uint32_t i = 0; i < s_max_frames_in_flight; ++i) - { - if (vkCreateCommandPool(m_device, &command_pool_create_info, NULL, &m_command_pools[i]) != VK_SUCCESS) - { - throw std::runtime_error("vk create command pool"); - } - } - } - } - - void VulkanRHI::createCommandBuffers() - { - VkCommandBufferAllocateInfo command_buffer_allocate_info {}; - command_buffer_allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; - command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; - command_buffer_allocate_info.commandBufferCount = 1U; - - for (uint32_t i = 0; i < s_max_frames_in_flight; ++i) - { - command_buffer_allocate_info.commandPool = m_command_pools[i]; - - if (vkAllocateCommandBuffers(m_device, &command_buffer_allocate_info, &m_command_buffers[i]) != VK_SUCCESS) - { - throw std::runtime_error("vk allocate command buffers"); - } - } - } - - void VulkanRHI::createDescriptorPool() - { - // Since DescriptorSet should be treated as asset in Vulkan, DescriptorPool - // should be big enough, and thus we can sub-allocate DescriptorSet from - // DescriptorPool merely as we sub-allocate Buffer/Image from DeviceMemory. - - VkDescriptorPoolSize pool_sizes[6]; - pool_sizes[0].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; - pool_sizes[0].descriptorCount = 3 + 2 + 2 + 2 + 1 + 1 + 3 + 3; - pool_sizes[1].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - pool_sizes[1].descriptorCount = 1 + 1 + 1 * m_max_vertex_blending_mesh_count; - pool_sizes[2].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - pool_sizes[2].descriptorCount = 1 * m_max_material_count; - pool_sizes[3].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; - pool_sizes[3].descriptorCount = 3 + 5 * m_max_material_count + 1 + 1; // ImGui_ImplVulkan_CreateDeviceObjects - pool_sizes[4].type = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; - pool_sizes[4].descriptorCount = 4 + 1 + 1 + 2; - pool_sizes[5].type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; - pool_sizes[5].descriptorCount = 1; - - VkDescriptorPoolCreateInfo pool_info {}; - pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; - pool_info.poolSizeCount = sizeof(pool_sizes) / sizeof(pool_sizes[0]); - pool_info.pPoolSizes = pool_sizes; - pool_info.maxSets = 1 + 1 + 1 + m_max_material_count + m_max_vertex_blending_mesh_count + 1 + - 1; // +skybox + axis descriptor set - pool_info.flags = 0U; - - if (vkCreateDescriptorPool(m_device, &pool_info, nullptr, &m_descriptor_pool) != VK_SUCCESS) - { - throw std::runtime_error("create descriptor pool"); - } - } - - // semaphore : signal an image is ready for rendering // ready for presentation - // (m_vulkan_context._swapchain_images --> semaphores, fences) - void VulkanRHI::createSyncPrimitives() - { - VkSemaphoreCreateInfo semaphore_create_info {}; - semaphore_create_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; - - VkFenceCreateInfo fence_create_info {}; - fence_create_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; - fence_create_info.flags = VK_FENCE_CREATE_SIGNALED_BIT; // the fence is initialized as signaled - - for (uint32_t i = 0; i < s_max_frames_in_flight; i++) - { - if (vkCreateSemaphore( - m_device, &semaphore_create_info, nullptr, &m_image_available_for_render_semaphores[i]) != - VK_SUCCESS || - vkCreateSemaphore( - m_device, &semaphore_create_info, nullptr, &m_image_finished_for_presentation_semaphores[i]) != - VK_SUCCESS || - vkCreateSemaphore( - m_device, &semaphore_create_info, nullptr, &m_image_available_for_texturescopy_semaphores[i]) != - VK_SUCCESS || - vkCreateFence(m_device, &fence_create_info, nullptr, &m_is_frame_in_flight_fences[i]) != VK_SUCCESS) - { - throw std::runtime_error("vk create semaphore & fence"); - } - } - } - - void VulkanRHI::createFramebufferImageAndView() - { - VulkanUtil::createImage(m_physical_device, - m_device, - m_swapchain_extent.width, - m_swapchain_extent.height, - m_depth_image_format, - VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | - VK_IMAGE_USAGE_TRANSFER_SRC_BIT, - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - m_depth_image, - m_depth_image_memory, - 0, - 1, - 1); - - m_depth_image_view = VulkanUtil::createImageView( - m_device, m_depth_image, m_depth_image_format, VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_VIEW_TYPE_2D, 1, 1); - } - - void VulkanRHI::createSwapchainImageViews() - { - m_swapchain_imageviews.resize(m_swapchain_images.size()); - - // create imageview (one for each this time) for all swapchain images - for (size_t i = 0; i < m_swapchain_images.size(); i++) - { - m_swapchain_imageviews[i] = VulkanUtil::createImageView(m_device, - m_swapchain_images[i], - m_swapchain_image_format, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_VIEW_TYPE_2D, - 1, - 1); - } - } - - void VulkanRHI::createAssetAllocator() - { - VmaVulkanFunctions vulkanFunctions = {}; - vulkanFunctions.vkGetInstanceProcAddr = &vkGetInstanceProcAddr; - vulkanFunctions.vkGetDeviceProcAddr = &vkGetDeviceProcAddr; - - VmaAllocatorCreateInfo allocatorCreateInfo = {}; - allocatorCreateInfo.vulkanApiVersion = m_vulkan_api_version; - allocatorCreateInfo.physicalDevice = m_physical_device; - allocatorCreateInfo.device = m_device; - allocatorCreateInfo.instance = m_instance; - allocatorCreateInfo.pVulkanFunctions = &vulkanFunctions; - - vmaCreateAllocator(&allocatorCreateInfo, &m_assets_allocator); - } - - void VulkanRHI::createSwapchain() - { - // query all supports of this physical device - SwapChainSupportDetails swapchain_support_details = querySwapChainSupport(m_physical_device); - - // choose the best or fitting format - VkSurfaceFormatKHR chosen_surface_format = - chooseSwapchainSurfaceFormatFromDetails(swapchain_support_details.m_formats); - // choose the best or fitting present mode - VkPresentModeKHR chosen_presentMode = - chooseSwapchainPresentModeFromDetails(swapchain_support_details.m_presentModes); - // choose the best or fitting extent - VkExtent2D chosen_extent = chooseSwapchainExtentFromDetails(swapchain_support_details.m_capabilities); - - uint32_t image_count = swapchain_support_details.m_capabilities.minImageCount + 1; - if (swapchain_support_details.m_capabilities.maxImageCount > 0 && - image_count > swapchain_support_details.m_capabilities.maxImageCount) - { - image_count = swapchain_support_details.m_capabilities.maxImageCount; - } - - VkSwapchainCreateInfoKHR createInfo {}; - createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; - createInfo.surface = m_surface; - - createInfo.minImageCount = image_count; - createInfo.imageFormat = chosen_surface_format.format; - createInfo.imageColorSpace = chosen_surface_format.colorSpace; - createInfo.imageExtent = chosen_extent; - createInfo.imageArrayLayers = 1; - createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; - - uint32_t queueFamilyIndices[] = {m_queue_indices.m_graphics_family.value(), - m_queue_indices.m_present_family.value()}; - - if (m_queue_indices.m_graphics_family != m_queue_indices.m_present_family) - { - createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT; - createInfo.queueFamilyIndexCount = 2; - createInfo.pQueueFamilyIndices = queueFamilyIndices; - } - else - { - createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; - } - - createInfo.preTransform = swapchain_support_details.m_capabilities.currentTransform; - createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; - createInfo.presentMode = chosen_presentMode; - createInfo.clipped = VK_TRUE; - - createInfo.oldSwapchain = VK_NULL_HANDLE; - - if (vkCreateSwapchainKHR(m_device, &createInfo, nullptr, &m_swapchain) != VK_SUCCESS) - { - throw std::runtime_error("vk create swapchain khr"); - } - - vkGetSwapchainImagesKHR(m_device, m_swapchain, &image_count, nullptr); - m_swapchain_images.resize(image_count); - vkGetSwapchainImagesKHR(m_device, m_swapchain, &image_count, m_swapchain_images.data()); - - m_swapchain_image_format = chosen_surface_format.format; - m_swapchain_extent = chosen_extent; - - m_scissor = {{0, 0}, {m_swapchain_extent.width, m_swapchain_extent.height}}; - } - - void VulkanRHI::clearSwapchain() - { - for (auto imageview : m_swapchain_imageviews) - { - vkDestroyImageView(m_device, imageview, NULL); - } - vkDestroySwapchainKHR(m_device, m_swapchain, NULL); // also swapchain images - } - - void VulkanRHI::recreateSwapchain() - { - int width = 0; - int height = 0; - glfwGetFramebufferSize(m_window, &width, &height); - while (width == 0 || height == 0) // minimized 0,0, pause for now - { - glfwGetFramebufferSize(m_window, &width, &height); - glfwWaitEvents(); - } - - VkResult res_wait_for_fences = - m_vk_wait_for_fences(m_device, s_max_frames_in_flight, m_is_frame_in_flight_fences, VK_TRUE, UINT64_MAX); - assert(VK_SUCCESS == res_wait_for_fences); - - vkDestroyImageView(m_device, m_depth_image_view, NULL); - vkDestroyImage(m_device, m_depth_image, NULL); - vkFreeMemory(m_device, m_depth_image_memory, NULL); - - for (auto imageview : m_swapchain_imageviews) - { - vkDestroyImageView(m_device, imageview, NULL); - } - vkDestroySwapchainKHR(m_device, m_swapchain, NULL); - - createSwapchain(); - createSwapchainImageViews(); - createFramebufferImageAndView(); - } - - VkResult VulkanRHI::createDebugUtilsMessengerEXT(VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugUtilsMessengerEXT* pDebugMessenger) - { - auto func = - (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"); - if (func != nullptr) - { - return func(instance, pCreateInfo, pAllocator, pDebugMessenger); - } - else - { - return VK_ERROR_EXTENSION_NOT_PRESENT; - } - } - - void VulkanRHI::destroyDebugUtilsMessengerEXT(VkInstance instance, - VkDebugUtilsMessengerEXT debugMessenger, - const VkAllocationCallbacks* pAllocator) - { - auto func = - (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT"); - if (func != nullptr) - { - func(instance, debugMessenger, pAllocator); - } - } - - Piccolo::QueueFamilyIndices VulkanRHI::findQueueFamilies(VkPhysicalDevice physical_device) // for device and surface - { - QueueFamilyIndices indices; - uint32_t queue_family_count = 0; - vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, nullptr); - std::vector queue_families(queue_family_count); - vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, queue_families.data()); - - int i = 0; - for (const auto& queue_family : queue_families) - { - if (queue_family.queueFlags & VK_QUEUE_GRAPHICS_BIT) // if support graphics command queue - { - indices.m_graphics_family = i; - } - - if (queue_family.queueFlags & VK_QUEUE_COMPUTE_BIT) // if support compute command queue - { - indices.m_compute_family = i; - } - - VkBool32 is_present_support = false; - vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, - i, - m_surface, - &is_present_support); // if support surface presentation - if (is_present_support) - { - indices.m_present_family = i; - } - - if (indices.isComplete()) - { - break; - } - i++; - } - return indices; - } - - bool VulkanRHI::checkDeviceExtensionSupport(VkPhysicalDevice physical_device) - { - uint32_t extension_count; - vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &extension_count, nullptr); - - std::vector available_extensions(extension_count); - vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &extension_count, available_extensions.data()); - - std::set required_extensions(m_device_extensions.begin(), m_device_extensions.end()); - for (const auto& extension : available_extensions) - { - required_extensions.erase(extension.extensionName); - } - - return required_extensions.empty(); - } - - bool VulkanRHI::isDeviceSuitable(VkPhysicalDevice physical_device) - { - auto queue_indices = findQueueFamilies(physical_device); - bool is_extensions_supported = checkDeviceExtensionSupport(physical_device); - bool is_swapchain_adequate = false; - if (is_extensions_supported) - { - SwapChainSupportDetails swapchain_support_details = querySwapChainSupport(physical_device); - is_swapchain_adequate = - !swapchain_support_details.m_formats.empty() && !swapchain_support_details.m_presentModes.empty(); - } - - VkPhysicalDeviceFeatures physical_device_features; - vkGetPhysicalDeviceFeatures(physical_device, &physical_device_features); - - if (!queue_indices.isComplete() || !is_swapchain_adequate || !physical_device_features.samplerAnisotropy) - { - return false; - } - - return true; - } - - Piccolo::SwapChainSupportDetails VulkanRHI::querySwapChainSupport(VkPhysicalDevice physical_device) - { - SwapChainSupportDetails details_result; - - // capabilities - vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, m_surface, &details_result.m_capabilities); - - // formats - uint32_t format_count; - vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, m_surface, &format_count, nullptr); - if (format_count != 0) - { - details_result.m_formats.resize(format_count); - vkGetPhysicalDeviceSurfaceFormatsKHR( - physical_device, m_surface, &format_count, details_result.m_formats.data()); - } - - // present modes - uint32_t presentmode_count; - vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, m_surface, &presentmode_count, nullptr); - if (presentmode_count != 0) - { - details_result.m_presentModes.resize(presentmode_count); - vkGetPhysicalDeviceSurfacePresentModesKHR( - physical_device, m_surface, &presentmode_count, details_result.m_presentModes.data()); - } - - return details_result; - } - - VkFormat VulkanRHI::findDepthFormat() - { - return findSupportedFormat({VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT}, - VK_IMAGE_TILING_OPTIMAL, - VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT); - } - - VkFormat VulkanRHI::findSupportedFormat(const std::vector& candidates, - VkImageTiling tiling, - VkFormatFeatureFlags features) - { - for (VkFormat format : candidates) - { - VkFormatProperties props; - vkGetPhysicalDeviceFormatProperties(m_physical_device, format, &props); - - if (tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features) - { - return format; - } - else if (tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features) - { - return format; - } - } - - throw std::runtime_error("findSupportedFormat failed"); - } - - VkSurfaceFormatKHR - VulkanRHI::chooseSwapchainSurfaceFormatFromDetails(const std::vector& available_surface_formats) - { - for (const auto& surface_format : available_surface_formats) - { - // TODO: select the VK_FORMAT_B8G8R8A8_SRGB surface format, - // there is no need to do gamma correction in the fragment shader - if (surface_format.format == VK_FORMAT_B8G8R8A8_UNORM && - surface_format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) - { - return surface_format; - } - } - return available_surface_formats[0]; - } - - VkPresentModeKHR - VulkanRHI::chooseSwapchainPresentModeFromDetails(const std::vector& available_present_modes) - { - for (VkPresentModeKHR present_mode : available_present_modes) - { - if (VK_PRESENT_MODE_MAILBOX_KHR == present_mode) - { - return VK_PRESENT_MODE_MAILBOX_KHR; - } - } - - return VK_PRESENT_MODE_FIFO_KHR; - } - - VkExtent2D VulkanRHI::chooseSwapchainExtentFromDetails(const VkSurfaceCapabilitiesKHR& capabilities) - { - if (capabilities.currentExtent.width != UINT32_MAX) - { - return capabilities.currentExtent; - } - else - { - int width, height; - glfwGetFramebufferSize(m_window, &width, &height); - - VkExtent2D actualExtent = {static_cast(width), static_cast(height)}; - - actualExtent.width = - std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width); - actualExtent.height = - std::clamp(actualExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height); - - return actualExtent; - } - } - -} // namespace Piccolo \ No newline at end of file diff --git a/engine/source/runtime/function/render/rhi/vulkan/vulkan_rhi.h b/engine/source/runtime/function/render/rhi/vulkan/vulkan_rhi.h deleted file mode 100644 index 3769667ff..000000000 --- a/engine/source/runtime/function/render/rhi/vulkan/vulkan_rhi.h +++ /dev/null @@ -1,187 +0,0 @@ -#pragma once - -#include "runtime/function/render/rhi.h" - -#include -#include - -#include -#include -#include - -namespace Piccolo -{ - struct QueueFamilyIndices - { - std::optional m_graphics_family; - std::optional m_present_family; - std::optional m_compute_family; - - bool isComplete() const - { - return m_graphics_family.has_value() && m_present_family.has_value() && m_compute_family.has_value(); - } - }; - - struct SwapChainSupportDetails - { - VkSurfaceCapabilitiesKHR m_capabilities {}; - std::vector m_formats; - std::vector m_presentModes; - }; - - class VulkanRHI final : public RHI - { - public: - // override functions - virtual ~VulkanRHI() override final; - virtual void initialize(RHIInitInfo init_info) override final; - virtual void prepareContext() override final; - - // command - VkCommandBuffer beginSingleTimeCommands(); - void endSingleTimeCommands(VkCommandBuffer command_buffer); - - // swapchain - void createSwapchain(); - void clearSwapchain(); - void recreateSwapchain(); - - void createSwapchainImageViews(); - void createFramebufferImageAndView(); - - // debug utilities label - PFN_vkCmdBeginDebugUtilsLabelEXT m_vk_cmd_begin_debug_utils_label_ext; - PFN_vkCmdEndDebugUtilsLabelEXT m_vk_cmd_end_debug_utils_label_ext; - - // clear - void clear(); - - void waitForFences(); - void resetCommandPool(); - bool prepareBeforePass(std::function passUpdateAfterRecreateSwapchain); - void submitRendering(std::function passUpdateAfterRecreateSwapchain); - - private: - void createInstance(); - void initializeDebugMessenger(); - void createWindowSurface(); - void initializePhysicalDevice(); - void createLogicalDevice(); - void createCommandPool(); - void createCommandBuffers(); - void createDescriptorPool(); - void createSyncPrimitives(); - void createAssetAllocator(); - - bool checkValidationLayerSupport(); - std::vector getRequiredExtensions(); - void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo); - - VkResult createDebugUtilsMessengerEXT(VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugUtilsMessengerEXT* pDebugMessenger); - void destroyDebugUtilsMessengerEXT(VkInstance instance, - VkDebugUtilsMessengerEXT debugMessenger, - const VkAllocationCallbacks* pAllocator); - - QueueFamilyIndices findQueueFamilies(VkPhysicalDevice physical_device); - bool checkDeviceExtensionSupport(VkPhysicalDevice physical_device); - bool isDeviceSuitable(VkPhysicalDevice physical_device); - SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice physical_device); - - VkFormat findDepthFormat(); - VkFormat findSupportedFormat(const std::vector& candidates, - VkImageTiling tiling, - VkFormatFeatureFlags features); - - VkSurfaceFormatKHR - chooseSwapchainSurfaceFormatFromDetails(const std::vector& available_surface_formats); - VkPresentModeKHR - chooseSwapchainPresentModeFromDetails(const std::vector& available_present_modes); - VkExtent2D chooseSwapchainExtentFromDetails(const VkSurfaceCapabilitiesKHR& capabilities); - - public: - GLFWwindow* m_window {nullptr}; - VkInstance m_instance {VK_NULL_HANDLE}; - VkSurfaceKHR m_surface {VK_NULL_HANDLE}; - VkPhysicalDevice m_physical_device {VK_NULL_HANDLE}; - QueueFamilyIndices m_queue_indices; - VkDevice m_device {VK_NULL_HANDLE}; - VkFormat m_depth_image_format {VK_FORMAT_UNDEFINED}; - VkQueue m_graphics_queue {VK_NULL_HANDLE}; - VkQueue m_present_queue {VK_NULL_HANDLE}; - VkQueue m_compute_queue {VK_NULL_HANDLE}; - VkCommandPool m_command_pool {VK_NULL_HANDLE}; - - VkSwapchainKHR m_swapchain {VK_NULL_HANDLE}; - VkFormat m_swapchain_image_format {VK_FORMAT_UNDEFINED}; - VkExtent2D m_swapchain_extent; - std::vector m_swapchain_images; - std::vector m_swapchain_imageviews; - - VkImage m_depth_image {VK_NULL_HANDLE}; - VkDeviceMemory m_depth_image_memory {VK_NULL_HANDLE}; - VkImageView m_depth_image_view {VK_NULL_HANDLE}; - - std::vector m_swapchain_framebuffers; - - // asset allocator use VMA library - VmaAllocator m_assets_allocator; - - // function pointers - PFN_vkWaitForFences m_vk_wait_for_fences; - PFN_vkResetFences m_vk_reset_fences; - PFN_vkResetCommandPool m_vk_reset_command_pool; - PFN_vkBeginCommandBuffer m_vk_begin_command_buffer; - PFN_vkEndCommandBuffer m_vk_end_command_buffer; - PFN_vkCmdBeginRenderPass m_vk_cmd_begin_render_pass; - PFN_vkCmdNextSubpass m_vk_cmd_next_subpass; - PFN_vkCmdEndRenderPass m_vk_cmd_end_render_pass; - PFN_vkCmdBindPipeline m_vk_cmd_bind_pipeline; - PFN_vkCmdSetViewport m_vk_cmd_set_viewport; - PFN_vkCmdSetScissor m_vk_cmd_set_scissor; - PFN_vkCmdBindVertexBuffers m_vk_cmd_bind_vertex_buffers; - PFN_vkCmdBindIndexBuffer m_vk_cmd_bind_index_buffer; - PFN_vkCmdBindDescriptorSets m_vk_cmd_bind_descriptor_sets; - PFN_vkCmdDrawIndexed m_vk_cmd_draw_indexed; - PFN_vkCmdClearAttachments m_vk_cmd_clear_attachments; - - // global descriptor pool - VkDescriptorPool m_descriptor_pool; - - // command pool and buffers - static uint8_t const s_max_frames_in_flight {3}; - uint8_t m_current_frame_index {0}; - VkCommandPool m_command_pools[s_max_frames_in_flight]; - VkCommandBuffer m_command_buffers[s_max_frames_in_flight]; - VkSemaphore m_image_available_for_render_semaphores[s_max_frames_in_flight]; - VkSemaphore m_image_available_for_texturescopy_semaphores[s_max_frames_in_flight]; - VkSemaphore m_image_finished_for_presentation_semaphores[s_max_frames_in_flight]; - VkFence m_is_frame_in_flight_fences[s_max_frames_in_flight]; - - // TODO: set - VkCommandBuffer m_current_command_buffer; - uint8_t* m_p_current_frame_index {nullptr}; - VkCommandPool* m_p_command_pools {nullptr}; - VkCommandBuffer* m_p_command_buffers {nullptr}; - VkViewport m_viewport; - VkRect2D m_scissor; - - uint32_t m_current_swapchain_image_index; - - private: - const std::vector m_validation_layers {"VK_LAYER_KHRONOS_validation"}; - uint32_t m_vulkan_api_version {VK_API_VERSION_1_0}; - - std::vector m_device_extensions = { - VK_KHR_SWAPCHAIN_EXTENSION_NAME, -#if defined(__MACH__) - "VK_KHR_portability_subset" -#endif - }; - - VkDebugUtilsMessengerEXT m_debug_messenger {VK_NULL_HANDLE}; - }; -} // namespace Piccolo