From 3719b93b56914fd9c5d729f52a4d701c3a39ac2a Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Sun, 27 Apr 2025 18:41:59 +0700 Subject: [PATCH 01/24] Debug renderer WIP1. --- CMakeLists.txt | 7 +- src/physics/debug/debug_renderer.cpp | 5 - src/physics/debug/jolt_debug_renderer.cpp | 9 + ...debug_renderer.h => jolt_debug_renderer.h} | 6 +- src/renderer/assets/asset_manager.cpp | 6 +- .../assets/render_object/render_object.cpp | 2 +- src/renderer/debug/debug_renderer.cpp | 180 ++++++++++++++++++ src/renderer/debug/debug_renderer.h | 96 ++++++++++ src/renderer/debug/debug_renderer_types.h | 66 +++++++ 9 files changed, 363 insertions(+), 14 deletions(-) delete mode 100644 src/physics/debug/debug_renderer.cpp create mode 100644 src/physics/debug/jolt_debug_renderer.cpp rename src/physics/debug/{debug_renderer.h => jolt_debug_renderer.h} (90%) create mode 100644 src/renderer/debug/debug_renderer.cpp create mode 100644 src/renderer/debug/debug_renderer.h create mode 100644 src/renderer/debug/debug_renderer_types.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 9fbabb9b..9325ec4c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -131,8 +131,8 @@ set(PHYSICS_SOURCES src/physics/physics_utils.h src/physics/physics_utils.cpp src/physics/physics_constants.h - src/physics/debug/debug_renderer.cpp - src/physics/debug/debug_renderer.h + src/physics/debug/jolt_debug_renderer.cpp + src/physics/debug/jolt_debug_renderer.h src/physics/physics_body.h ) @@ -263,6 +263,9 @@ set(TEMP_SOURCES src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline_types.h src/renderer/pipelines/basic/basic_compute/basic_compute_pipeline_types.h src/renderer/pipelines/visibility_pass/visibility_pass_pipeline_types.h + src/renderer/debug/debug_renderer.cpp + src/renderer/debug/debug_renderer.h + src/renderer/debug/debug_renderer_tyoes.h ) diff --git a/src/physics/debug/debug_renderer.cpp b/src/physics/debug/debug_renderer.cpp deleted file mode 100644 index 37ab9517..00000000 --- a/src/physics/debug/debug_renderer.cpp +++ /dev/null @@ -1,5 +0,0 @@ -// -// Created by William on 2024-12-26. -// - -#include "debug_renderer.h" diff --git a/src/physics/debug/jolt_debug_renderer.cpp b/src/physics/debug/jolt_debug_renderer.cpp new file mode 100644 index 00000000..b62b2d3b --- /dev/null +++ b/src/physics/debug/jolt_debug_renderer.cpp @@ -0,0 +1,9 @@ +// +// Created by William on 2024-12-26. +// + +#include "jolt_debug_renderer.h" +will_engine::physics::JoltDebugRenderer::JoltDebugRenderer() +{ + Initialize(); +} diff --git a/src/physics/debug/debug_renderer.h b/src/physics/debug/jolt_debug_renderer.h similarity index 90% rename from src/physics/debug/debug_renderer.h rename to src/physics/debug/jolt_debug_renderer.h index cd954f3f..efd1ec91 100644 --- a/src/physics/debug/debug_renderer.h +++ b/src/physics/debug/jolt_debug_renderer.h @@ -10,10 +10,12 @@ namespace will_engine::physics { -class DebugRendererImpl final : public JPH::DebugRenderer +class JoltDebugRenderer final : public JPH::DebugRenderer { public: - ~DebugRendererImpl() override; + JoltDebugRenderer(); + + ~JoltDebugRenderer() override; void DrawLine(JPH::RVec3Arg inFrom, JPH::RVec3Arg inTo, JPH::ColorArg inColor) override; diff --git a/src/renderer/assets/asset_manager.cpp b/src/renderer/assets/asset_manager.cpp index d36c38d0..8d537f5a 100644 --- a/src/renderer/assets/asset_manager.cpp +++ b/src/renderer/assets/asset_manager.cpp @@ -15,14 +15,14 @@ will_engine::AssetManager::~AssetManager() void will_engine::AssetManager::scanForAll() { + fmt::print("Scanning for .willmodel and .willtexture files\n"); + scanForRenderObjects(); scanForTextures(); } void will_engine::AssetManager::scanForTextures() { - fmt::print("Scanning for .willtexture files\n"); - const std::vector willTextures = file::findWillFiles(relative(std::filesystem::current_path() / "assets"), ".willtexture"); textures.reserve(willTextures.size()); for (std::filesystem::path willTexture : willTextures) { @@ -38,8 +38,6 @@ void will_engine::AssetManager::scanForTextures() void will_engine::AssetManager::scanForRenderObjects() { - fmt::print("Scanning for .willmodel files\n"); - const std::vector willModels = file::findWillFiles(relative(std::filesystem::current_path() / "assets"), ".willmodel"); renderObjects.reserve(willModels.size()); for (std::filesystem::path willModel : willModels) { diff --git a/src/renderer/assets/render_object/render_object.cpp b/src/renderer/assets/render_object/render_object.cpp index 9eb2e981..60a5d79f 100644 --- a/src/renderer/assets/render_object/render_object.cpp +++ b/src/renderer/assets/render_object/render_object.cpp @@ -686,7 +686,7 @@ void RenderObject::load() } uint64_t boundingSphereBufferSize = sizeof(BoundingSphere) * boundingSpheres.size(); - AllocatedBuffer meshBoundsStaging = resourceManager.createStagingBuffer(boundingSphereBufferSize); + const AllocatedBuffer meshBoundsStaging = resourceManager.createStagingBuffer(boundingSphereBufferSize); memcpy(meshBoundsStaging.info.pMappedData, boundingSpheres.data(), boundingSphereBufferSize); meshBoundsBuffer = resourceManager.createDeviceBuffer(boundingSphereBufferSize); diff --git a/src/renderer/debug/debug_renderer.cpp b/src/renderer/debug/debug_renderer.cpp new file mode 100644 index 00000000..268ad20c --- /dev/null +++ b/src/renderer/debug/debug_renderer.cpp @@ -0,0 +1,180 @@ +// +// Created by William on 2025-04-27. +// + +#include "debug_renderer.h" + +#include +#include + +#include "src/renderer/resource_manager.h" + + +namespace will_engine::debug_renderer +{ +DebugRenderer::DebugRenderer(ResourceManager& resourceManager) : resourceManager(resourceManager) +{ + // 8 vertices, 12 edges (24 points) + constexpr int32_t boxVertexCount = 8; + constexpr int32_t boxIndicesCount = 24; + instancedVertices.reserve(instancedVertices.size() + boxVertexCount); + instancedIndices.reserve(instancedIndices.size() + boxIndicesCount); + + std::vector boxVertices = { + {{0, 0, 0}}, // 0: near bottom left + {{1, 0, 0}}, // 1: near bottom right + {{1, 1, 0}}, // 2: near top right + {{0, 1, 0}}, // 3: near top left + {{0, 0, 1}}, // 4: far bottom left + {{1, 0, 1}}, // 5: far bottom right + {{1, 1, 1}}, // 6: far top right + {{0, 1, 1}} // 7: far top left + }; + + std::vector boxIndices = { + // Near face + 0, 1, 1, 2, 2, 3, 3, 0, + // Far face + 4, 5, 5, 6, 6, 7, 7, 4, + // Connecting edges + 0, 4, 1, 5, 2, 6, 3, 7 + }; + + size_t boxVertexOffset = instancedVertices.size(); + size_t boxIndexOffset = instancedIndices.size(); + instancedVertices.insert(instancedVertices.end(), boxVertices.begin(), boxVertices.end()); + instancedIndices.insert(instancedIndices.end(), boxIndices.begin(), boxIndices.end()); + + boxDrawIndirect.indexCount = boxIndicesCount; + boxDrawIndirect.instanceCount = 0; + boxDrawIndirect.firstIndex = boxIndexOffset; + boxDrawIndirect.vertexOffset = boxVertexOffset; + boxDrawIndirect.firstInstance = 0; + + // Vertex Buffer + const uint64_t instancedVertexBufferSize = instancedVertices.size() * sizeof(DebugRendererVertex); + const AllocatedBuffer instancedVertexStaging = resourceManager.createStagingBuffer(instancedVertexBufferSize); + memcpy(instancedVertexStaging.info.pMappedData, instancedVertices.data(), instancedVertexBufferSize); + instancedVertexBuffer = resourceManager.createDeviceBuffer(instancedVertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); + + // Index Buffer + const uint64_t instancedIndexBufferSize = instancedIndices.size() * sizeof(uint32_t); + const AllocatedBuffer instancedIndexStaging = resourceManager.createStagingBuffer(instancedIndexBufferSize); + memcpy(instancedIndexStaging.info.pMappedData, instancedIndices.data(), instancedIndexBufferSize); + instancedIndexBuffer = resourceManager.createDeviceBuffer(instancedIndexBufferSize, VK_BUFFER_USAGE_INDEX_BUFFER_BIT); + + std::array bufferCopies = { + BufferCopyInfo(instancedVertexStaging, 0, instancedVertexBuffer, 0, instancedVertexBufferSize), + {instancedIndexStaging, 0, instancedIndexBuffer, 0, instancedIndexBufferSize}, + }; + + resourceManager.copyBufferImmediate(bufferCopies); + for (BufferCopyInfo bufferCopy : bufferCopies) { + resourceManager.destroyBufferImmediate(bufferCopy.src); + } + + // Box Instance Data Buffer + boxInstanceBuffer = resourceManager.createHostSequentialBuffer(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT * sizeof(BoxInstance)); + + // Addresses Buffer - change number to be number of instance buffers to be in the addresses buffer + size_t addressesBufferSize = sizeof(VkDeviceAddress) * 1; + addressBuffer = resourceManager.createHostSequentialBuffer(addressesBufferSize); + const std::array addresses = {resourceManager.getBufferAddress(boxInstanceBuffer)}; + memcpy(addressBuffer.info.pMappedData, addresses.data(), addressesBufferSize); + + // Draw indirect buffer + drawIndirectBuffer = resourceManager.createHostSequentialBuffer(sizeof(VkDrawIndexedIndirectCommand) * 1); + const std::array drawIndirectCommands = {boxDrawIndirect}; + memcpy(drawIndirectBuffer.info.pMappedData, drawIndirectCommands.data(), sizeof(VkDrawIndexedIndirectCommand) * 1); + + // todo: copy staging vertex and index into "instance real buffers" + + + DescriptorLayoutBuilder layoutBuilder; + layoutBuilder.addBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER); + addressesLayout = resourceManager.createDescriptorSetLayout(layoutBuilder, VK_SHADER_STAGE_VERTEX_BIT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT); + + addressesDescriptorBuffer = resourceManager.createDescriptorBufferUniform(addressesLayout, 1); + + DescriptorUniformData addressesUniformData{ + .uniformBuffer = addressBuffer, + .allocSize = addressesBufferSize, + }; + resourceManager.setupDescriptorBufferUniform(addressesDescriptorBuffer, {addressesUniformData}, 0); +} + +DebugRenderer::~DebugRenderer() {} + +void DebugRenderer::drawLine(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color) +{} + +void DebugRenderer::drawSphere(const glm::vec3& center, float radius, const glm::vec3& color, DebugRendererCategory category) +{ + if (!hasFlag(activeCategories, category)) { return; } + + + // add to vertices and indices +} + +void DebugRenderer::drawBox(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, DebugRendererCategory category) +{ + if (!hasFlag(activeCategories, category)) { return; } + + // Create transformation matrix directly: + // 1. Scale from unit cube to the desired dimensions + // 2. Translate to the center position + const glm::mat4 transform = glm::translate(glm::mat4(1.0f), center) * + glm::scale(glm::mat4(1.0f), dimensions); + + // Create and add the box instance + BoxInstance instance; + instance.transform = transform; + instance.color = color; + + boxInstances.push_back(instance); + + + // Update the indirect draw command + +} + +void DebugRenderer::drawBoxMinmax(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, DebugRendererCategory category) +{ + if (!hasFlag(activeCategories, category)) { return; } + + // add box instance to + std::vector boxInstances; +} + +void DebugRenderer::render(VkCommandBuffer cmd) +{ + if (boxInstances.size() > DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT) { + boxInstances.resize(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT); + } + + boxDrawIndirect.instanceCount = boxInstances.size(); + + const std::array drawIndirectCommands = {boxDrawIndirect}; + memcpy(drawIndirectBuffer.info.pMappedData, drawIndirectCommands.data(), sizeof(VkDrawIndexedIndirectCommand) * 1); + + memcpy(boxInstanceBuffer.info.pMappedData, boxInstances.data(), sizeof(BoxInstance) * boxInstances.size()); + + // draw w/ pipeline +} + +void DebugRenderer::clear() +{ + // remove anything past the defaults + vertices.clear(); + indices.clear(); +} + +void DebugRenderer::createPipeline() +{} + +void DebugRenderer::generateBuffers() +{ + // populate vertex and index buffers +} +} diff --git a/src/renderer/debug/debug_renderer.h b/src/renderer/debug/debug_renderer.h new file mode 100644 index 00000000..3b8d5256 --- /dev/null +++ b/src/renderer/debug/debug_renderer.h @@ -0,0 +1,96 @@ +// +// Created by William on 2025-04-27. +// + +#ifndef DEBUG_RENDERER_H +#define DEBUG_RENDERER_H +#include "debug_renderer_types.h" +#include "src/renderer/vk_types.h" +#include "src/renderer/descriptor_buffer/descriptor_buffer_uniform.h" + +namespace will_engine +{ +class ResourceManager; +} + +namespace will_engine::debug_renderer +{ +class DebugRenderer +{ +public: + static DebugRenderer* debugRenderer; + static DebugRenderer* get() { return debugRenderer; } + static void set(DebugRenderer* _debugRenderer) { debugRenderer = _debugRenderer; } + + + + DebugRenderer(ResourceManager& resourceManager); + + ~DebugRenderer(); + + void drawLine(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color); + + void drawSphere(const glm::vec3& center, float radius, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); + + void drawBox(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); + + void drawBoxMinmax(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); + + void render(VkCommandBuffer cmd); + + void clear(); + + void reloadShaders() + { + createPipeline(); + } + +private: + void createPipeline(); + + VkPipeline pipeline; + VkPipelineLayout pipelineLayout; + +private: + ResourceManager& resourceManager; + void generateBuffers(); + + DebugRendererCategory activeCategories{DebugRendererCategory::ALL}; + + // for custom debug draws from Jolt. For primitives use the instanced draws instead. + std::vector vertices{}; + std::vector indices{}; + AllocatedBuffer vertexBuffer{VK_NULL_HANDLE}; + AllocatedBuffer indexBuffer{VK_NULL_HANDLE}; + + + VkDescriptorSetLayout addressesLayout; + + std::vector instancedVertices; + std::vector instancedIndices; + AllocatedBuffer instancedVertexBuffer; + AllocatedBuffer instancedIndexBuffer; + + /** + * Default size is 512 instances + */ + std::vector boxInstances; + AllocatedBuffer boxInstanceBuffer{VK_NULL_HANDLE}; + + /** + * Includes: + * \n \code{ boxInstanceBuffer.address }\endcode + */ + AllocatedBuffer addressBuffer{VK_NULL_HANDLE}; + /** + * Should only house 1x address buffer, but for "correctness" should use `FRAME_OVERLAP` number of address buffers. + * \n But since addresses don't change often (almost never), will forgo this + */ + DescriptorBufferUniform addressesDescriptorBuffer; + + VkDrawIndexedIndirectCommand boxDrawIndirect; + AllocatedBuffer drawIndirectBuffer{VK_NULL_HANDLE}; +}; +} + +#endif //DEBUG_RENDERER_H diff --git a/src/renderer/debug/debug_renderer_types.h b/src/renderer/debug/debug_renderer_types.h new file mode 100644 index 00000000..442e161d --- /dev/null +++ b/src/renderer/debug/debug_renderer_types.h @@ -0,0 +1,66 @@ +// +// Created by William on 2025-04-27. +// + +#ifndef DEBUG_RENDERER_TYPES_H +#define DEBUG_RENDERER_TYPES_H + +#include + +namespace will_engine::debug_renderer +{ +static constexpr inline int32_t DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT = 512; +enum class DebugRendererCategory +{ + None = 0x00000000, // Will always be drawn + Physics = 1 << 0, + Gameplay = 1 << 1, + UI = 1 << 2, + General = 1 << 3, + Navigation = 1 << 4, + AI = 1 << 5, + ALL = 0xFFFFFFFF +}; + +inline DebugRendererCategory operator|(DebugRendererCategory a, DebugRendererCategory b) +{ + return static_cast(static_cast(a) | static_cast(b)); +} + +inline DebugRendererCategory operator&(DebugRendererCategory a, DebugRendererCategory b) +{ + return static_cast(static_cast(a) & static_cast(b)); +} + +inline DebugRendererCategory operator~(DebugRendererCategory a) +{ + return static_cast(~static_cast(a)); +} + +inline DebugRendererCategory& operator|=(DebugRendererCategory& a, DebugRendererCategory b) +{ + return a = a | b; +} + +inline DebugRendererCategory& operator&=(DebugRendererCategory& a, DebugRendererCategory b) +{ + return a = a & b; +} + +inline bool hasFlag(DebugRendererCategory flags, DebugRendererCategory flag) +{ + return (static_cast(flags) & static_cast(flag)) == static_cast(flag); +} + +struct DebugRendererVertex +{ + glm::vec3 position; +}; + +struct BoxInstance { + glm::mat4 transform; // Position + scale + glm::vec3 color; +}; +} + +#endif //DEBUG_RENDERER_TYPES_H From 1b70045857ff7c8d48622abce818a9bacb4d1e99 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Sun, 27 Apr 2025 23:21:14 +0700 Subject: [PATCH 02/24] Debug renderer draw cube implemented and functional. --- assets/settings.willengine | 14 +- shaders/debug/debug_renderer.frag | 10 + shaders/debug/debug_renderer.vert | 27 ++ src/core/engine.cpp | 20 +- src/core/engine.h | 7 + src/physics/debug/jolt_debug_renderer.cpp | 25 ++ src/renderer/debug/debug_renderer.cpp | 249 +++++++++++++----- src/renderer/debug/debug_renderer.h | 49 ++-- src/renderer/debug/debug_renderer_types.h | 13 +- src/renderer/imgui_wrapper.cpp | 50 +--- .../deferred_mrt/deferred_mrt_pipeline.cpp | 1 - src/renderer/vk_pipelines.cpp | 6 +- src/renderer/vk_pipelines.h | 6 +- src/renderer/vulkan_context.cpp | 1 + 14 files changed, 325 insertions(+), 153 deletions(-) create mode 100644 shaders/debug/debug_renderer.frag create mode 100644 shaders/debug/debug_renderer.vert diff --git a/assets/settings.willengine b/assets/settings.willengine index 8dd9b130..d5738d04 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -19.169994354248047, - 105.9618911743164, - 36.455501556396484 + -1.3541245460510254, + 0.5453407168388367, + 1.056149959564209 ], "rotation": [ - -0.14886538684368134, - -0.2690022885799408, - -0.04212456941604614, - 0.9506327509880066 + -0.011114215478301048, + 0.6052320003509521, + -0.008450469002127647, + -0.7959267497062683 ], "fov": 1.3089969158172607, "aspectRatio": 1.4861111640930176, diff --git a/shaders/debug/debug_renderer.frag b/shaders/debug/debug_renderer.frag new file mode 100644 index 00000000..4c321ecf --- /dev/null +++ b/shaders/debug/debug_renderer.frag @@ -0,0 +1,10 @@ +#version 460 + +layout(location = 0) in vec3 inColor; + +layout (location = 0) out vec4 albedoTarget; + +void main() { + // 0 indicates this won't do light calculations in deferred resolve + albedoTarget = vec4(inColor, 0.0); +} diff --git a/shaders/debug/debug_renderer.vert b/shaders/debug/debug_renderer.vert new file mode 100644 index 00000000..ecf5e530 --- /dev/null +++ b/shaders/debug/debug_renderer.vert @@ -0,0 +1,27 @@ +#version 460 + +layout(location = 0) in vec3 inPosition; + +layout(location = 0) out vec3 outColor; + +#include "scene.glsl" + +struct BoxInstance{ + mat4 transform; + vec3 color; + float padding; +}; + +// layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl + +layout(std140, set = 1, binding = 0) readonly buffer BoxInstanceBuffer { + BoxInstance instances[]; +} boxInstances; + +void main() { + BoxInstance instance = boxInstances.instances[gl_InstanceIndex]; + + gl_Position = sceneData.viewProj * vec4(inPosition, 1.0); + gl_Position.xy += gl_Position.w * sceneData.jitter.xy; + outColor = instance.color; +} \ No newline at end of file diff --git a/src/core/engine.cpp b/src/core/engine.cpp index e068a83f..7130ee57 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -25,6 +25,7 @@ #include "src/renderer/descriptor_buffer/descriptor_buffer_uniform.h" #include "src/renderer/environment/environment.h" #include "../renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.h" +#include "src/renderer/debug/debug_renderer.h" #include "src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.h" #include "src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline_types.h" #include "src/renderer/pipelines/geometry/deferred_resolve/deferred_resolve_pipeline.h" @@ -126,6 +127,9 @@ void Engine::init() assetManager = new AssetManager(*resourceManager); physics = new physics::Physics(); physics::Physics::set(physics); + debugRenderer = new debug_renderer::DebugRenderer(*resourceManager); + debug_renderer::DebugRenderer::set(debugRenderer); + startupProfiler.addEntry("Immediate, ResourceM, AssetM, Physics"); environmentMap = new environment::Environment(*resourceManager, *immediate); @@ -624,6 +628,19 @@ void Engine::render(float deltaTime) transparentPipeline->drawAccumulate(cmd, transparentDrawInfo); } + if (bDrawDebugRendering) { + debug_renderer::DebugRendererDrawInfo debugRendererDrawInfo{ + currentFrameOverlap, + albedoRenderTarget.imageView, + depthImage.imageView, + sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), + sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap + }; + + debugRenderer->drawBox({0, 0, 0}, {2.0f, 2.0f, 2.0f}, {0.0f, 1.0f, 0.0f}); + debugRenderer->draw(cmd, debugRendererDrawInfo); + } + vk_helpers::transitionImage(cmd, normalRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); vk_helpers::transitionImage(cmd, albedoRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, @@ -850,7 +867,8 @@ void Engine::cleanup() delete cascadedShadowMap; delete environmentMap; - delete physics::Physics::get(); + delete debugRenderer; + delete physics; delete immediate; delete resourceManager; diff --git a/src/core/engine.h b/src/core/engine.h index 78473738..33860a75 100644 --- a/src/core/engine.h +++ b/src/core/engine.h @@ -28,6 +28,11 @@ #include "src/renderer/pipelines/shadows/ground_truth_ambient_occlusion/ambient_occlusion_types.h" +namespace will_engine::debug_renderer +{ +class DebugRenderer; +} + class ResourceManager; class ImmediateSubmitter; class VulkanContext; @@ -158,6 +163,7 @@ class Engine ResourceManager* resourceManager{nullptr}; AssetManager* assetManager{nullptr}; physics::Physics* physics{nullptr}; + debug_renderer::DebugRenderer* debugRenderer{nullptr}; environment::Environment* environmentMap{nullptr}; @@ -210,6 +216,7 @@ class Engine bool bDrawTransparents{true}; bool bEnableShadows{true}; bool bEnableContactShadows{true}; + bool bDrawDebugRendering{true}; void hotReloadShaders() const; diff --git a/src/physics/debug/jolt_debug_renderer.cpp b/src/physics/debug/jolt_debug_renderer.cpp index b62b2d3b..8ec48b9d 100644 --- a/src/physics/debug/jolt_debug_renderer.cpp +++ b/src/physics/debug/jolt_debug_renderer.cpp @@ -3,7 +3,32 @@ // #include "jolt_debug_renderer.h" + will_engine::physics::JoltDebugRenderer::JoltDebugRenderer() { Initialize(); } + +will_engine::physics::JoltDebugRenderer::~JoltDebugRenderer() {} +void will_engine::physics::JoltDebugRenderer::DrawLine(JPH::RVec3Arg inFrom, JPH::RVec3Arg inTo, JPH::ColorArg inColor) {} + +void will_engine::physics::JoltDebugRenderer::DrawTriangle(JPH::RVec3Arg inV1, JPH::RVec3Arg inV2, JPH::RVec3Arg inV3, JPH::ColorArg inColor, + ECastShadow inCastShadow) {} + +JPH::DebugRenderer::Batch will_engine::physics::JoltDebugRenderer::CreateTriangleBatch(const Triangle* inTriangles, int inTriangleCount) +{ + return {}; +} + +JPH::DebugRenderer::Batch will_engine::physics::JoltDebugRenderer::CreateTriangleBatch(const Vertex* inVertices, int inVertexCount, + const JPH::uint32* inIndices, int inIndexCount) +{ + return {}; +} + +void will_engine::physics::JoltDebugRenderer::DrawGeometry(JPH::RMat44Arg inModelMatrix, const JPH::AABox& inWorldSpaceBounds, float inLODScaleSq, + JPH::ColorArg inModelColor, const GeometryRef& inGeometry, ECullMode inCullMode, + ECastShadow inCastShadow, EDrawMode inDrawMode) {} + +void will_engine::physics::JoltDebugRenderer::DrawText3D(JPH::RVec3Arg inPosition, const JPH::string_view& inString, JPH::ColorArg inColor, + float inHeight) {} diff --git a/src/renderer/debug/debug_renderer.cpp b/src/renderer/debug/debug_renderer.cpp index 268ad20c..be744eb5 100644 --- a/src/renderer/debug/debug_renderer.cpp +++ b/src/renderer/debug/debug_renderer.cpp @@ -6,14 +6,18 @@ #include #include +#include #include "src/renderer/resource_manager.h" namespace will_engine::debug_renderer { +DebugRenderer* DebugRenderer::debugRenderer = nullptr; + DebugRenderer::DebugRenderer(ResourceManager& resourceManager) : resourceManager(resourceManager) { + boxInstances.reserve(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT); // 8 vertices, 12 edges (24 points) constexpr int32_t boxVertexCount = 8; constexpr int32_t boxIndicesCount = 24; @@ -45,11 +49,10 @@ DebugRenderer::DebugRenderer(ResourceManager& resourceManager) : resourceManager instancedVertices.insert(instancedVertices.end(), boxVertices.begin(), boxVertices.end()); instancedIndices.insert(instancedIndices.end(), boxIndices.begin(), boxIndices.end()); - boxDrawIndirect.indexCount = boxIndicesCount; - boxDrawIndirect.instanceCount = 0; - boxDrawIndirect.firstIndex = boxIndexOffset; - boxDrawIndirect.vertexOffset = boxVertexOffset; - boxDrawIndirect.firstInstance = 0; + boxDrawIndexedData.indexCount = boxIndicesCount; + boxDrawIndexedData.firstIndex = boxIndexOffset; + boxDrawIndexedData.vertexOffset = static_cast(boxVertexOffset); + boxDrawIndexedData.firstInstance = 0; // Vertex Buffer const uint64_t instancedVertexBufferSize = instancedVertices.size() * sizeof(DebugRendererVertex); @@ -63,7 +66,7 @@ DebugRenderer::DebugRenderer(ResourceManager& resourceManager) : resourceManager memcpy(instancedIndexStaging.info.pMappedData, instancedIndices.data(), instancedIndexBufferSize); instancedIndexBuffer = resourceManager.createDeviceBuffer(instancedIndexBufferSize, VK_BUFFER_USAGE_INDEX_BUFFER_BIT); - std::array bufferCopies = { + std::array bufferCopies = { BufferCopyInfo(instancedVertexStaging, 0, instancedVertexBuffer, 0, instancedVertexBufferSize), {instancedIndexStaging, 0, instancedIndexBuffer, 0, instancedIndexBufferSize}, }; @@ -73,38 +76,188 @@ DebugRenderer::DebugRenderer(ResourceManager& resourceManager) : resourceManager resourceManager.destroyBufferImmediate(bufferCopy.src); } + DescriptorLayoutBuilder layoutBuilder; + layoutBuilder.addBinding(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER); + uniformLayout = resourceManager.createDescriptorSetLayout(layoutBuilder, VK_SHADER_STAGE_VERTEX_BIT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT); + // Box Instance Data Buffer - boxInstanceBuffer = resourceManager.createHostSequentialBuffer(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT * sizeof(BoxInstance)); + constexpr uint64_t boxInstanceBufferSize = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT * sizeof(BoxInstance); + boxInstanceDescriptorBuffer = resourceManager.createDescriptorBufferUniform(uniformLayout, FRAME_OVERLAP); + for (int32_t i = 0; i < FRAME_OVERLAP; ++i) { + boxInstanceBuffers[i] = resourceManager.createHostSequentialBuffer(boxInstanceBufferSize); + DescriptorUniformData addressesUniformData{ + .uniformBuffer = boxInstanceBuffers[i], + .allocSize = boxInstanceBufferSize, + }; + + resourceManager.setupDescriptorBufferUniform(boxInstanceDescriptorBuffer, {addressesUniformData}, i); + } - // Addresses Buffer - change number to be number of instance buffers to be in the addresses buffer - size_t addressesBufferSize = sizeof(VkDeviceAddress) * 1; - addressBuffer = resourceManager.createHostSequentialBuffer(addressesBufferSize); - const std::array addresses = {resourceManager.getBufferAddress(boxInstanceBuffer)}; - memcpy(addressBuffer.info.pMappedData, addresses.data(), addressesBufferSize); + VkDescriptorSetLayout descriptorLayout[2]; + descriptorLayout[0] = resourceManager.getSceneDataLayout(); + descriptorLayout[1] = uniformLayout; - // Draw indirect buffer - drawIndirectBuffer = resourceManager.createHostSequentialBuffer(sizeof(VkDrawIndexedIndirectCommand) * 1); - const std::array drawIndirectCommands = {boxDrawIndirect}; - memcpy(drawIndirectBuffer.info.pMappedData, drawIndirectCommands.data(), sizeof(VkDrawIndexedIndirectCommand) * 1); - // todo: copy staging vertex and index into "instance real buffers" + VkPipelineLayoutCreateInfo layoutInfo = vk_helpers::pipelineLayoutCreateInfo(); + layoutInfo.pSetLayouts = descriptorLayout; + layoutInfo.pNext = nullptr; + layoutInfo.setLayoutCount = 2; + layoutInfo.pPushConstantRanges = nullptr; + layoutInfo.pushConstantRangeCount = 0; + pipelineLayout = resourceManager.createPipelineLayout(layoutInfo); - DescriptorLayoutBuilder layoutBuilder; - layoutBuilder.addBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER); - addressesLayout = resourceManager.createDescriptorSetLayout(layoutBuilder, VK_SHADER_STAGE_VERTEX_BIT, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT); + createPipeline(); +} + +DebugRenderer::~DebugRenderer() +{ + resourceManager.destroyDescriptorSetLayout(uniformLayout); + + resourceManager.destroyBuffer(instancedVertexBuffer); + resourceManager.destroyBuffer(instancedIndexBuffer); + + for (AllocatedBuffer& buffer : boxInstanceBuffers) { + resourceManager.destroyBuffer(buffer); + } + resourceManager.destroyDescriptorBuffer(boxInstanceDescriptorBuffer); + + resourceManager.destroyPipeline(pipeline); + resourceManager.destroyPipelineLayout(pipelineLayout); +} + +void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawInfo) +{ + if (boxInstances.empty()) { return; } + + if (boxInstances.size() > DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT) { + boxInstances.resize(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT); + } - addressesDescriptorBuffer = resourceManager.createDescriptorBufferUniform(addressesLayout, 1); + // upload + const AllocatedBuffer& currentBoxInstanceBuffer = boxInstanceBuffers[drawInfo.currentFrameOverlap]; + memcpy(currentBoxInstanceBuffer.info.pMappedData, boxInstances.data(), sizeof(BoxInstance) * boxInstances.size()); + + const VkRenderingAttachmentInfo albedoAttachment = vk_helpers::attachmentInfo(drawInfo.albedoTarget, nullptr, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + + const VkRenderingAttachmentInfo depthAttachment = vk_helpers::attachmentInfo(drawInfo.depthTarget, nullptr, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL); + + VkRenderingInfo renderInfo{}; + renderInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO; + renderInfo.pNext = nullptr; + + VkRenderingAttachmentInfo renderAttachments[1]; + renderAttachments[0] = albedoAttachment; + + renderInfo.renderArea = VkRect2D{VkOffset2D{0, 0}, RENDER_EXTENTS}; + renderInfo.layerCount = 1; + renderInfo.colorAttachmentCount = 1; + renderInfo.pColorAttachments = renderAttachments; + renderInfo.pDepthAttachment = &depthAttachment; + renderInfo.pStencilAttachment = nullptr; + + vkCmdBeginRendering(cmd, &renderInfo); + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); + + vkCmdSetLineWidth(cmd, 3.0f); + + // Viewport + VkViewport viewport = {}; + viewport.x = 0; + viewport.y = 0; + viewport.width = RENDER_EXTENTS.width; + viewport.height = RENDER_EXTENTS.height; + viewport.minDepth = 0.f; + viewport.maxDepth = 1.f; + vkCmdSetViewport(cmd, 0, 1, &viewport); + // Scissor + VkRect2D scissor = {}; + scissor.offset.x = 0; + scissor.offset.y = 0; + scissor.extent.width = RENDER_EXTENTS.width; + scissor.extent.height = RENDER_EXTENTS.height; + vkCmdSetScissor(cmd, 0, 1, &scissor); + + const std::array descriptorBufferBindingInfos{ + drawInfo.sceneDataBinding, + boxInstanceDescriptorBuffer.getDescriptorBufferBindingInfo() + }; - DescriptorUniformData addressesUniformData{ - .uniformBuffer = addressBuffer, - .allocSize = addressesBufferSize, + vkCmdBindDescriptorBuffersEXT(cmd, 2, descriptorBufferBindingInfos.data()); + + constexpr std::array indices{0, 1}; + const std::array offsets{ + drawInfo.sceneDataOffset, + boxInstanceDescriptorBuffer.getDescriptorBufferSize() * drawInfo.currentFrameOverlap, }; - resourceManager.setupDescriptorBufferUniform(addressesDescriptorBuffer, {addressesUniformData}, 0); + + vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 2, indices.data(), offsets.data()); + + vkCmdBindVertexBuffers(cmd, 0, 1, &instancedVertexBuffer.buffer, &ZERO_DEVICE_SIZE); + vkCmdBindIndexBuffer(cmd, instancedIndexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32); + + + vkCmdDrawIndexed(cmd, boxDrawIndexedData.indexCount, boxInstances.size(), boxDrawIndexedData.firstIndex + , boxDrawIndexedData.vertexOffset, boxDrawIndexedData.firstInstance); + + vkCmdEndRendering(cmd); + + clear(); + } -DebugRenderer::~DebugRenderer() {} +void DebugRenderer::clear() +{ + boxInstances.clear(); + + // remove anything past the defaults + //vertices.clear(); + //indices.clear(); +} + +void DebugRenderer::createPipeline() +{ + resourceManager.destroyPipeline(pipeline); + VkShaderModule vertShader = resourceManager.createShaderModule("shaders/debug/debug_renderer.vert"); + VkShaderModule fragShader = resourceManager.createShaderModule("shaders/debug/debug_renderer.frag"); + + PipelineBuilder renderPipelineBuilder; + VkVertexInputBindingDescription vertexBinding{}; + vertexBinding.binding = 0; + vertexBinding.stride = sizeof(DebugRendererVertex); + vertexBinding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + + VkVertexInputAttributeDescription vertexAttributes[4]; + vertexAttributes[0].binding = 0; + vertexAttributes[0].location = 0; + vertexAttributes[0].format = VK_FORMAT_R32G32B32_SFLOAT; + vertexAttributes[0].offset = offsetof(DebugRendererVertex, position); + + const VkVertexInputBindingDescription vertexBindings[1] = {vertexBinding}; + + renderPipelineBuilder.setupVertexInput(vertexBindings, 1, vertexAttributes, 1); + + renderPipelineBuilder.setShaders(vertShader, fragShader); + renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_LINE_LIST); + renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_LINE, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); + renderPipelineBuilder.disableMultisampling(); + renderPipelineBuilder.disableBlending(); + renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); + renderPipelineBuilder.setupRenderer({ALBEDO_FORMAT}, DEPTH_FORMAT); + renderPipelineBuilder.setupPipelineLayout(pipelineLayout); + const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; + pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); + resourceManager.destroyShaderModule(vertShader); + resourceManager.destroyShaderModule(fragShader); +} + +void DebugRenderer::generateBuffers() +{ + // populate vertex and index buffers +} void DebugRenderer::drawLine(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color) {} @@ -121,22 +274,14 @@ void DebugRenderer::drawBox(const glm::vec3& center, const glm::vec3& dimensions { if (!hasFlag(activeCategories, category)) { return; } - // Create transformation matrix directly: - // 1. Scale from unit cube to the desired dimensions - // 2. Translate to the center position const glm::mat4 transform = glm::translate(glm::mat4(1.0f), center) * - glm::scale(glm::mat4(1.0f), dimensions); + glm::scale(glm::mat4(1.0f), dimensions); - // Create and add the box instance - BoxInstance instance; + BoxInstance instance{}; instance.transform = transform; instance.color = color; boxInstances.push_back(instance); - - - // Update the indirect draw command - } void DebugRenderer::drawBoxMinmax(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, DebugRendererCategory category) @@ -147,34 +292,4 @@ void DebugRenderer::drawBoxMinmax(const glm::vec3& min, const glm::vec3& max, co std::vector boxInstances; } -void DebugRenderer::render(VkCommandBuffer cmd) -{ - if (boxInstances.size() > DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT) { - boxInstances.resize(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT); - } - - boxDrawIndirect.instanceCount = boxInstances.size(); - - const std::array drawIndirectCommands = {boxDrawIndirect}; - memcpy(drawIndirectBuffer.info.pMappedData, drawIndirectCommands.data(), sizeof(VkDrawIndexedIndirectCommand) * 1); - - memcpy(boxInstanceBuffer.info.pMappedData, boxInstances.data(), sizeof(BoxInstance) * boxInstances.size()); - - // draw w/ pipeline -} - -void DebugRenderer::clear() -{ - // remove anything past the defaults - vertices.clear(); - indices.clear(); -} - -void DebugRenderer::createPipeline() -{} - -void DebugRenderer::generateBuffers() -{ - // populate vertex and index buffers -} } diff --git a/src/renderer/debug/debug_renderer.h b/src/renderer/debug/debug_renderer.h index 3b8d5256..3592961e 100644 --- a/src/renderer/debug/debug_renderer.h +++ b/src/renderer/debug/debug_renderer.h @@ -4,7 +4,10 @@ #ifndef DEBUG_RENDERER_H #define DEBUG_RENDERER_H +#include + #include "debug_renderer_types.h" +#include "src/renderer/renderer_constants.h" #include "src/renderer/vk_types.h" #include "src/renderer/descriptor_buffer/descriptor_buffer_uniform.h" @@ -22,6 +25,13 @@ class DebugRenderer static DebugRenderer* get() { return debugRenderer; } static void set(DebugRenderer* _debugRenderer) { debugRenderer = _debugRenderer; } + struct DrawIndexedData + { + uint32_t indexCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; + }; DebugRenderer(ResourceManager& resourceManager); @@ -36,7 +46,8 @@ class DebugRenderer void drawBoxMinmax(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); - void render(VkCommandBuffer cmd); +public: + void draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawInfo); void clear(); @@ -48,8 +59,8 @@ class DebugRenderer private: void createPipeline(); - VkPipeline pipeline; - VkPipelineLayout pipelineLayout; + VkPipeline pipeline{VK_NULL_HANDLE}; + VkPipelineLayout pipelineLayout{VK_NULL_HANDLE}; private: ResourceManager& resourceManager; @@ -58,38 +69,32 @@ class DebugRenderer DebugRendererCategory activeCategories{DebugRendererCategory::ALL}; // for custom debug draws from Jolt. For primitives use the instanced draws instead. - std::vector vertices{}; - std::vector indices{}; - AllocatedBuffer vertexBuffer{VK_NULL_HANDLE}; - AllocatedBuffer indexBuffer{VK_NULL_HANDLE}; + // std::vector vertices{}; + // std::vector indices{}; + // AllocatedBuffer vertexBuffer{VK_NULL_HANDLE}; + // AllocatedBuffer indexBuffer{VK_NULL_HANDLE}; - VkDescriptorSetLayout addressesLayout; + VkDescriptorSetLayout uniformLayout{VK_NULL_HANDLE}; - std::vector instancedVertices; - std::vector instancedIndices; - AllocatedBuffer instancedVertexBuffer; - AllocatedBuffer instancedIndexBuffer; + std::vector instancedVertices{}; + std::vector instancedIndices{}; + AllocatedBuffer instancedVertexBuffer{VK_NULL_HANDLE}; + AllocatedBuffer instancedIndexBuffer{VK_NULL_HANDLE}; /** - * Default size is 512 instances + * Default size is 512 instances (if vector is greater than 512, it will be truncated) */ std::vector boxInstances; - AllocatedBuffer boxInstanceBuffer{VK_NULL_HANDLE}; + std::array boxInstanceBuffers{VK_NULL_HANDLE, VK_NULL_HANDLE}; + DrawIndexedData boxDrawIndexedData{}; - /** - * Includes: - * \n \code{ boxInstanceBuffer.address }\endcode - */ - AllocatedBuffer addressBuffer{VK_NULL_HANDLE}; /** * Should only house 1x address buffer, but for "correctness" should use `FRAME_OVERLAP` number of address buffers. * \n But since addresses don't change often (almost never), will forgo this */ - DescriptorBufferUniform addressesDescriptorBuffer; + DescriptorBufferUniform boxInstanceDescriptorBuffer; - VkDrawIndexedIndirectCommand boxDrawIndirect; - AllocatedBuffer drawIndirectBuffer{VK_NULL_HANDLE}; }; } diff --git a/src/renderer/debug/debug_renderer_types.h b/src/renderer/debug/debug_renderer_types.h index 442e161d..c3ac7e6c 100644 --- a/src/renderer/debug/debug_renderer_types.h +++ b/src/renderer/debug/debug_renderer_types.h @@ -6,11 +6,12 @@ #define DEBUG_RENDERER_TYPES_H #include +#include namespace will_engine::debug_renderer { static constexpr inline int32_t DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT = 512; -enum class DebugRendererCategory +enum class DebugRendererCategory : uint32_t { None = 0x00000000, // Will always be drawn Physics = 1 << 0, @@ -60,6 +61,16 @@ struct DebugRendererVertex struct BoxInstance { glm::mat4 transform; // Position + scale glm::vec3 color; + float padding; +}; + +struct DebugRendererDrawInfo +{ + int32_t currentFrameOverlap{}; + VkImageView albedoTarget; + VkImageView depthTarget; + VkDescriptorBufferBindingInfoEXT sceneDataBinding{}; + VkDeviceSize sceneDataOffset{0}; }; } diff --git a/src/renderer/imgui_wrapper.cpp b/src/renderer/imgui_wrapper.cpp index a8cc20c5..0c822ffd 100644 --- a/src/renderer/imgui_wrapper.cpp +++ b/src/renderer/imgui_wrapper.cpp @@ -1214,55 +1214,7 @@ void ImguiWrapper::imguiInterface(Engine* engine) ImGui::End(); if (ImGui::Begin("Discardable Debug")) { - if (contactShadowsOutputImguiId == VK_NULL_HANDLE) { - if (engine->contactShadowsPipeline->debugImage.imageView != VK_NULL_HANDLE) { - contactShadowsOutputImguiId = ImGui_ImplVulkan_AddTexture( - engine->resourceManager->getDefaultSamplerNearest(), - engine->contactShadowsPipeline->debugImage.imageView, - VK_IMAGE_LAYOUT_GENERAL); - } - } - - if (contactShadowsOutputImguiId == VK_NULL_HANDLE) { - ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Debug texture not available."); - } - else { - // Calculate best fit size - float maxSize = ImGui::GetContentRegionAvail().x; - maxSize = glm::min(maxSize, 1024.0f); - - VkExtent3D imageExtent = engine->contactShadowsPipeline->debugImage.imageExtent; - float width = std::min(maxSize, static_cast(imageExtent.width)); - float aspectRatio = static_cast(imageExtent.width) / static_cast(imageExtent.height); - float height = width / aspectRatio; - - ImGui::Image(reinterpret_cast(contactShadowsOutputImguiId), ImVec2(width, height)); - - if (ImGui::Button("Save SCSS Debug Image")) { - if (file::getOrCreateDirectory(file::imagesSavePath)) { - const std::filesystem::path path = file::imagesSavePath / "scss_debug.png"; - - vk_helpers::saveImageR8G8B8A8UNORM( - *engine->resourceManager, - *engine->immediate, - engine->contactShadowsPipeline->debugImage, - VK_IMAGE_LAYOUT_GENERAL, - path.string().c_str(), - 0 - ); - - ImGui::OpenPopup("SaveConfirmation"); - } - } - - if (ImGui::BeginPopupModal("SaveConfirmation", NULL, ImGuiWindowFlags_AlwaysAutoResize)) { - ImGui::Text("Image saved to %s/gtao_debug.png", file::imagesSavePath.string().c_str()); - if (ImGui::Button("OK", ImVec2(120, 0))) { - ImGui::CloseCurrentPopup(); - } - ImGui::EndPopup(); - } - } + ImGui::Checkbox("Draw Debug Render", &engine->bDrawDebugRendering); } ImGui::End(); diff --git a/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp b/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp index 8ff34193..4bb83afe 100644 --- a/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp +++ b/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp @@ -95,7 +95,6 @@ void will_engine::deferred_mrt::DeferredMrtPipeline::draw(VkCommandBuffer cmd, c scissor.extent.width = RENDER_EXTENTS.width; scissor.extent.height = RENDER_EXTENTS.height; vkCmdSetScissor(cmd, 0, 1, &scissor); - constexpr VkDeviceSize zeroOffset{0}; for (RenderObject* renderObject : drawInfo.renderObjects) { if (!renderObject->canDraw()) { continue; } diff --git a/src/renderer/vk_pipelines.cpp b/src/renderer/vk_pipelines.cpp index 3c655e87..d0d5491d 100644 --- a/src/renderer/vk_pipelines.cpp +++ b/src/renderer/vk_pipelines.cpp @@ -170,12 +170,12 @@ void will_engine::PipelineBuilder::setupInputAssembly(const VkPrimitiveTopology inputAssembly.primitiveRestartEnable = enablePrimitiveRestart; } -void will_engine::PipelineBuilder::setupRasterization(const VkPolygonMode polygonMode, const VkCullModeFlags cullMode, const VkFrontFace frontFace, - bool rasterizerDiscardEnable) +void will_engine::PipelineBuilder::setupRasterization(VkPolygonMode polygonMode, VkCullModeFlags cullMode, VkFrontFace frontFace, + float lineWidth, bool rasterizerDiscardEnable) { // Draw Mode rasterizer.polygonMode = polygonMode; - rasterizer.lineWidth = 1.0f; + rasterizer.lineWidth = lineWidth; // Culling rasterizer.cullMode = cullMode; diff --git a/src/renderer/vk_pipelines.h b/src/renderer/vk_pipelines.h index 8ad9d587..cb84f57e 100644 --- a/src/renderer/vk_pipelines.h +++ b/src/renderer/vk_pipelines.h @@ -46,7 +46,7 @@ class PipelineBuilder void setupInputAssembly(VkPrimitiveTopology topology, bool enablePrimitiveRestart = false); - void setupRasterization(VkPolygonMode polygonMode, VkCullModeFlags cullMode, VkFrontFace frontFace, bool rasterizerDiscardEnable = false); + void setupRasterization(VkPolygonMode polygonMode, VkCullModeFlags cullMode, VkFrontFace frontFace, float lineWidth = 1.0f, bool rasterizerDiscardEnable = false); /** * Use to initialize the depth bias of the pipeline. @@ -101,10 +101,12 @@ class PipelineBuilder */ void disableDepthTest(); - VkPipelineDynamicStateCreateInfo generateDynamicStates(VkDynamicState states[], uint32_t count); void setupTessellation(int32_t controlPoints = 4); +private: + VkPipelineDynamicStateCreateInfo generateDynamicStates(VkDynamicState states[], uint32_t count); + private: std::vector shaderStages; diff --git a/src/renderer/vulkan_context.cpp b/src/renderer/vulkan_context.cpp index 4227edef..a0c2544f 100644 --- a/src/renderer/vulkan_context.cpp +++ b/src/renderer/vulkan_context.cpp @@ -52,6 +52,7 @@ VulkanContext::VulkanContext(SDL_Window* window, bool useValidationLayers) otherFeatures.tessellationShader = VK_TRUE; otherFeatures.fillModeNonSolid = VK_TRUE; otherFeatures.independentBlend = VK_TRUE; + otherFeatures.wideLines = VK_TRUE; // Descriptor Buffer Extension VkPhysicalDeviceDescriptorBufferFeaturesEXT descriptorBufferFeatures = {}; From 9ff7a0c7f407e80ee145a106acf3572637f7e114 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Mon, 28 Apr 2025 21:04:52 +0700 Subject: [PATCH 03/24] Sphere Debug Rendering. --- assets/settings.willengine | 14 +- shaders/debug/debug_renderer.vert | 12 +- src/core/engine.cpp | 19 +- src/core/time.cpp | 6 + src/core/time.h | 2 + src/renderer/debug/debug_renderer.cpp | 281 +++++++++++++++------- src/renderer/debug/debug_renderer.h | 27 +-- src/renderer/debug/debug_renderer_types.h | 42 +++- 8 files changed, 271 insertions(+), 132 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index d5738d04..24448214 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -1.3541245460510254, - 0.5453407168388367, - 1.056149959564209 + -4.979162693023682, + 1.0666637420654297, + -4.32814359664917 ], "rotation": [ - -0.011114215478301048, - 0.6052320003509521, - -0.008450469002127647, - -0.7959267497062683 + 0.009367896243929863, + -0.7754089832305908, + 0.011506090871989727, + 0.6312849521636963 ], "fov": 1.3089969158172607, "aspectRatio": 1.4861111640930176, diff --git a/shaders/debug/debug_renderer.vert b/shaders/debug/debug_renderer.vert index ecf5e530..bb34d958 100644 --- a/shaders/debug/debug_renderer.vert +++ b/shaders/debug/debug_renderer.vert @@ -6,7 +6,7 @@ layout(location = 0) out vec3 outColor; #include "scene.glsl" -struct BoxInstance{ +struct Instance{ mat4 transform; vec3 color; float padding; @@ -14,14 +14,14 @@ struct BoxInstance{ // layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl -layout(std140, set = 1, binding = 0) readonly buffer BoxInstanceBuffer { - BoxInstance instances[]; -} boxInstances; +layout(std140, set = 1, binding = 0) readonly buffer InstanceBuffer { + Instance instances[]; +} instances; void main() { - BoxInstance instance = boxInstances.instances[gl_InstanceIndex]; + Instance instance = instances.instances[gl_InstanceIndex]; - gl_Position = sceneData.viewProj * vec4(inPosition, 1.0); + gl_Position = sceneData.viewProj * instance.transform * vec4(inPosition, 1.0); gl_Position.xy += gl_Position.w * sceneData.jitter.xy; outColor = instance.color; } \ No newline at end of file diff --git a/src/core/engine.cpp b/src/core/engine.cpp index 7130ee57..daa4729b 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -483,7 +483,6 @@ void Engine::render(float deltaTime) profiler.beginTimer("2Render"); - std::vector allRenderObjects = assetManager->getAllRenderObjects(); // Update Render Object Buffers and Model Matrices @@ -637,7 +636,15 @@ void Engine::render(float deltaTime) sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap }; - debugRenderer->drawBox({0, 0, 0}, {2.0f, 2.0f, 2.0f}, {0.0f, 1.0f, 0.0f}); + + for (int32_t i{0}; i < 100; i++) { + for (int32_t j{0}; j < 100; j++) { + float z = glm::sin(Time::Get().getTime() - j * 0.5f) * 2.0; + debugRenderer->drawBox({i, j, z}, {0.8f, 0.8f, 0.8f}, {0.0f, 0.7f, 0.1f}); + } + } + + debugRenderer->drawSphere({0, 0, -5}, 2.0f, {0.0f, 0.7f, 0.1f}); debugRenderer->draw(cmd, debugRendererDrawInfo); } @@ -744,12 +751,14 @@ void Engine::render(float deltaTime) if (engine_constants::useImgui) { vk_helpers::transitionImage(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); imguiWrapper->drawImgui(cmd, swapchainImageViews[swapchainImageIndex], swapchainExtent); - vk_helpers::transitionImage(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, + vk_helpers::transitionImage(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_ASPECT_COLOR_BIT); - } else { + } + else { vk_helpers::transitionImage(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_ASPECT_COLOR_BIT); } diff --git a/src/core/time.cpp b/src/core/time.cpp index 84992bf0..c755bef5 100644 --- a/src/core/time.cpp +++ b/src/core/time.cpp @@ -21,10 +21,16 @@ void Time::update() // Breakpoint resume case if (deltaTime > 1000) { deltaTime = 333; } lastTime = last; + } float Time::getDeltaTime() const { return static_cast(deltaTime) / 1000.0f; } + +float Time::getTime() const +{ + return static_cast(lastTime) / 1000.0f; +} } diff --git a/src/core/time.h b/src/core/time.h index ff4f9e07..47073ef3 100644 --- a/src/core/time.h +++ b/src/core/time.h @@ -25,6 +25,8 @@ class Time [[nodiscard]] float getDeltaTime() const; + [[nodiscard]] float getTime() const; + private: uint64_t deltaTime = 0; uint64_t lastTime = 0; diff --git a/src/renderer/debug/debug_renderer.cpp b/src/renderer/debug/debug_renderer.cpp index be744eb5..ff27ca3b 100644 --- a/src/renderer/debug/debug_renderer.cpp +++ b/src/renderer/debug/debug_renderer.cpp @@ -17,42 +17,13 @@ DebugRenderer* DebugRenderer::debugRenderer = nullptr; DebugRenderer::DebugRenderer(ResourceManager& resourceManager) : resourceManager(resourceManager) { - boxInstances.reserve(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT); - // 8 vertices, 12 edges (24 points) - constexpr int32_t boxVertexCount = 8; - constexpr int32_t boxIndicesCount = 24; - instancedVertices.reserve(instancedVertices.size() + boxVertexCount); - instancedIndices.reserve(instancedIndices.size() + boxIndicesCount); - - std::vector boxVertices = { - {{0, 0, 0}}, // 0: near bottom left - {{1, 0, 0}}, // 1: near bottom right - {{1, 1, 0}}, // 2: near top right - {{0, 1, 0}}, // 3: near top left - {{0, 0, 1}}, // 4: far bottom left - {{1, 0, 1}}, // 5: far bottom right - {{1, 1, 1}}, // 6: far top right - {{0, 1, 1}} // 7: far top left - }; - - std::vector boxIndices = { - // Near face - 0, 1, 1, 2, 2, 3, 3, 0, - // Far face - 4, 5, 5, 6, 6, 7, 7, 4, - // Connecting edges - 0, 4, 1, 5, 2, 6, 3, 7 - }; - - size_t boxVertexOffset = instancedVertices.size(); - size_t boxIndexOffset = instancedIndices.size(); - instancedVertices.insert(instancedVertices.end(), boxVertices.begin(), boxVertices.end()); - instancedIndices.insert(instancedIndices.end(), boxIndices.begin(), boxIndices.end()); + DescriptorLayoutBuilder layoutBuilder; + layoutBuilder.addBinding(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER); + uniformLayout = resourceManager.createDescriptorSetLayout(layoutBuilder, VK_SHADER_STAGE_VERTEX_BIT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT); - boxDrawIndexedData.indexCount = boxIndicesCount; - boxDrawIndexedData.firstIndex = boxIndexOffset; - boxDrawIndexedData.vertexOffset = static_cast(boxVertexOffset); - boxDrawIndexedData.firstInstance = 0; + setupBoxRendering(BOX_INSTANCE_INDEX); + setupSphereRendering(SPHERE_INSTANCE_INDEX); // Vertex Buffer const uint64_t instancedVertexBufferSize = instancedVertices.size() * sizeof(DebugRendererVertex); @@ -76,23 +47,6 @@ DebugRenderer::DebugRenderer(ResourceManager& resourceManager) : resourceManager resourceManager.destroyBufferImmediate(bufferCopy.src); } - DescriptorLayoutBuilder layoutBuilder; - layoutBuilder.addBinding(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER); - uniformLayout = resourceManager.createDescriptorSetLayout(layoutBuilder, VK_SHADER_STAGE_VERTEX_BIT, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT); - - // Box Instance Data Buffer - constexpr uint64_t boxInstanceBufferSize = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT * sizeof(BoxInstance); - boxInstanceDescriptorBuffer = resourceManager.createDescriptorBufferUniform(uniformLayout, FRAME_OVERLAP); - for (int32_t i = 0; i < FRAME_OVERLAP; ++i) { - boxInstanceBuffers[i] = resourceManager.createHostSequentialBuffer(boxInstanceBufferSize); - DescriptorUniformData addressesUniformData{ - .uniformBuffer = boxInstanceBuffers[i], - .allocSize = boxInstanceBufferSize, - }; - - resourceManager.setupDescriptorBufferUniform(boxInstanceDescriptorBuffer, {addressesUniformData}, i); - } VkDescriptorSetLayout descriptorLayout[2]; descriptorLayout[0] = resourceManager.getSceneDataLayout(); @@ -118,10 +72,12 @@ DebugRenderer::~DebugRenderer() resourceManager.destroyBuffer(instancedVertexBuffer); resourceManager.destroyBuffer(instancedIndexBuffer); - for (AllocatedBuffer& buffer : boxInstanceBuffers) { - resourceManager.destroyBuffer(buffer); + for (DebugRenderGroup& group : debugRenderInstanceGroups) { + for (AllocatedBuffer& buffer : group.instanceBuffers) { + resourceManager.destroyBuffer(buffer); + } + resourceManager.destroyDescriptorBuffer(group.instanceDescriptorBuffer); } - resourceManager.destroyDescriptorBuffer(boxInstanceDescriptorBuffer); resourceManager.destroyPipeline(pipeline); resourceManager.destroyPipelineLayout(pipelineLayout); @@ -129,15 +85,19 @@ DebugRenderer::~DebugRenderer() void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawInfo) { - if (boxInstances.empty()) { return; } + // Upload + for (DebugRenderGroup group : debugRenderInstanceGroups) { + if (group.instances.empty()) { continue; } - if (boxInstances.size() > DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT) { - boxInstances.resize(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT); + if (group.instances.size() > DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT) { + group.instances.resize(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT); + // todo: dynamic resize + } + + AllocatedBuffer& instanceBuffer = group.instanceBuffers[drawInfo.currentFrameOverlap]; + memcpy(instanceBuffer.info.pMappedData, group.instances.data(), sizeof(DebugRendererInstance) * group.instances.size()); } - // upload - const AllocatedBuffer& currentBoxInstanceBuffer = boxInstanceBuffers[drawInfo.currentFrameOverlap]; - memcpy(currentBoxInstanceBuffer.info.pMappedData, boxInstances.data(), sizeof(BoxInstance) * boxInstances.size()); const VkRenderingAttachmentInfo albedoAttachment = vk_helpers::attachmentInfo(drawInfo.albedoTarget, nullptr, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); @@ -162,7 +122,7 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI vkCmdBeginRendering(cmd, &renderInfo); vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); - vkCmdSetLineWidth(cmd, 3.0f); + vkCmdSetLineWidth(cmd, 2.0f); // Viewport VkViewport viewport = {}; @@ -181,41 +141,44 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI scissor.extent.height = RENDER_EXTENTS.height; vkCmdSetScissor(cmd, 0, 1, &scissor); - const std::array descriptorBufferBindingInfos{ - drawInfo.sceneDataBinding, - boxInstanceDescriptorBuffer.getDescriptorBufferBindingInfo() - }; + for (DebugRenderGroup& group : debugRenderInstanceGroups) { + if (group.instances.empty()) { continue;; } - vkCmdBindDescriptorBuffersEXT(cmd, 2, descriptorBufferBindingInfos.data()); - constexpr std::array indices{0, 1}; - const std::array offsets{ - drawInfo.sceneDataOffset, - boxInstanceDescriptorBuffer.getDescriptorBufferSize() * drawInfo.currentFrameOverlap, - }; + const std::array descriptorBufferBindingInfos{ + drawInfo.sceneDataBinding, + group.instanceDescriptorBuffer.getDescriptorBufferBindingInfo() + }; - vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 2, indices.data(), offsets.data()); + vkCmdBindDescriptorBuffersEXT(cmd, 2, descriptorBufferBindingInfos.data()); + + constexpr std::array indices{0, 1}; + const std::array offsets{ + drawInfo.sceneDataOffset, + group.instanceDescriptorBuffer.getDescriptorBufferSize() * drawInfo.currentFrameOverlap, + }; + + vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 2, indices.data(), offsets.data()); + + vkCmdBindVertexBuffers(cmd, 0, 1, &instancedVertexBuffer.buffer, &ZERO_DEVICE_SIZE); + vkCmdBindIndexBuffer(cmd, instancedIndexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32); - vkCmdBindVertexBuffers(cmd, 0, 1, &instancedVertexBuffer.buffer, &ZERO_DEVICE_SIZE); - vkCmdBindIndexBuffer(cmd, instancedIndexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32); + vkCmdDrawIndexed(cmd, group.drawIndexedData.indexCount, group.instances.size(), group.drawIndexedData.firstIndex + , group.drawIndexedData.vertexOffset, group.drawIndexedData.firstInstance); + } - vkCmdDrawIndexed(cmd, boxDrawIndexedData.indexCount, boxInstances.size(), boxDrawIndexedData.firstIndex - , boxDrawIndexedData.vertexOffset, boxDrawIndexedData.firstInstance); vkCmdEndRendering(cmd); clear(); - } void DebugRenderer::clear() { - boxInstances.clear(); - - // remove anything past the defaults - //vertices.clear(); - //indices.clear(); + for (DebugRenderGroup& group : debugRenderInstanceGroups) { + group.instances.clear(); + } } void DebugRenderer::createPipeline() @@ -265,31 +228,165 @@ void DebugRenderer::drawLine(const glm::vec3& start, const glm::vec3& end, const void DebugRenderer::drawSphere(const glm::vec3& center, float radius, const glm::vec3& color, DebugRendererCategory category) { if (!hasFlag(activeCategories, category)) { return; } + if (!hasFlag(activeCategories, category)) { return; } + + const glm::mat4 transform = glm::translate(glm::mat4(1.0f), center) * glm::scale(glm::mat4(1.0f), glm::vec3(radius)); + DebugRendererInstance instance{}; + instance.transform = transform; + instance.color = color; - // add to vertices and indices + debugRenderInstanceGroups[SPHERE_INSTANCE_INDEX].instances.push_back(instance); } -void DebugRenderer::drawBox(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, DebugRendererCategory category) +void DebugRenderer::drawBox(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, const DebugRendererCategory category) { if (!hasFlag(activeCategories, category)) { return; } - const glm::mat4 transform = glm::translate(glm::mat4(1.0f), center) * - glm::scale(glm::mat4(1.0f), dimensions); + const glm::mat4 transform = glm::translate(glm::mat4(1.0f), center) * glm::scale(glm::mat4(1.0f), dimensions); - BoxInstance instance{}; + DebugRendererInstance instance{}; instance.transform = transform; instance.color = color; - boxInstances.push_back(instance); + debugRenderInstanceGroups[BOX_INSTANCE_INDEX].instances.push_back(instance); } -void DebugRenderer::drawBoxMinmax(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, DebugRendererCategory category) +void DebugRenderer::drawBoxMinmax(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, const DebugRendererCategory category) { if (!hasFlag(activeCategories, category)) { return; } - // add box instance to - std::vector boxInstances; + const glm::vec3 size = max - min; + const glm::vec3 center = min + size * 0.5f; + + drawBox(center, size, color, category); } + +void DebugRenderer::setupBoxRendering(const int32_t index) +{ + // Box Instance Data Buffer + constexpr uint64_t boxInstanceBufferSize = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT * sizeof(DebugRendererInstance); + debugRenderInstanceGroups[index].instanceDescriptorBuffer = resourceManager.createDescriptorBufferUniform(uniformLayout, FRAME_OVERLAP); + for (int32_t i = 0; i < FRAME_OVERLAP; ++i) { + debugRenderInstanceGroups[index].instanceBuffers[i] = resourceManager.createHostSequentialBuffer(boxInstanceBufferSize); + DescriptorUniformData addressesUniformData{ + .uniformBuffer = debugRenderInstanceGroups[index].instanceBuffers[i], + .allocSize = boxInstanceBufferSize, + }; + + resourceManager.setupDescriptorBufferUniform(debugRenderInstanceGroups[index].instanceDescriptorBuffer, {addressesUniformData}, i); + } + + + debugRenderInstanceGroups[index].instances.reserve(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT); + // 8 vertices, 12 edges (24 points) + constexpr int32_t boxVertexCount = 8; + constexpr int32_t boxIndicesCount = 24; + instancedVertices.reserve(instancedVertices.size() + boxVertexCount); + instancedIndices.reserve(instancedIndices.size() + boxIndicesCount); + + std::vector boxVertices = { + {{0, 0, 0}}, // 0: near bottom left + {{1, 0, 0}}, // 1: near bottom right + {{1, 1, 0}}, // 2: near top right + {{0, 1, 0}}, // 3: near top left + {{0, 0, 1}}, // 4: far bottom left + {{1, 0, 1}}, // 5: far bottom right + {{1, 1, 1}}, // 6: far top right + {{0, 1, 1}} // 7: far top left + }; + + std::vector boxIndices = { + // Near face + 0, 1, 1, 2, 2, 3, 3, 0, + // Far face + 4, 5, 5, 6, 6, 7, 7, 4, + // Connecting edges + 0, 4, 1, 5, 2, 6, 3, 7 + }; + + const size_t boxVertexOffset = instancedVertices.size(); + const size_t boxIndexOffset = instancedIndices.size(); + instancedVertices.insert(instancedVertices.end(), boxVertices.begin(), boxVertices.end()); + instancedIndices.insert(instancedIndices.end(), boxIndices.begin(), boxIndices.end()); + + debugRenderInstanceGroups[index].drawIndexedData.indexCount = boxIndicesCount; + debugRenderInstanceGroups[index].drawIndexedData.firstIndex = boxIndexOffset; + debugRenderInstanceGroups[index].drawIndexedData.vertexOffset = static_cast(boxVertexOffset); + debugRenderInstanceGroups[index].drawIndexedData.firstInstance = 0; +} + +void DebugRenderer::setupSphereRendering(const int32_t index) +{ + // Sphere Instance Data Buffer + constexpr uint64_t sphereInstanceBufferSize = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT * sizeof(DebugRendererInstance); + debugRenderInstanceGroups[index].instanceDescriptorBuffer = resourceManager.createDescriptorBufferUniform(uniformLayout, FRAME_OVERLAP); + for (int32_t i = 0; i < FRAME_OVERLAP; ++i) { + debugRenderInstanceGroups[index].instanceBuffers[i] = resourceManager.createHostSequentialBuffer(sphereInstanceBufferSize); + DescriptorUniformData addressesUniformData{ + .uniformBuffer = debugRenderInstanceGroups[index].instanceBuffers[i], + .allocSize = sphereInstanceBufferSize, + }; + + resourceManager.setupDescriptorBufferUniform(debugRenderInstanceGroups[index].instanceDescriptorBuffer, {addressesUniformData}, i); + } + + debugRenderInstanceGroups[index].instances.reserve(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT); + + constexpr int32_t rings = SPHERE_DETAIL_MEDIUM.rings; + constexpr int32_t segments = SPHERE_DETAIL_MEDIUM.segments; + constexpr int32_t sphereVertexCount = (rings + 1) * segments; + constexpr int32_t sphereLineCount = rings * segments * 2; // Longitude + latitude lines + constexpr int32_t sphereIndicesCount = sphereLineCount * 2; // 2 indices per line + + instancedVertices.reserve(instancedVertices.size() + sphereVertexCount); + instancedIndices.reserve(instancedIndices.size() + sphereIndicesCount); + + std::vector sphereVertices; + sphereVertices.reserve(sphereVertexCount); + + for (int32_t ring = 0; ring <= rings; ++ring) { + float phi = glm::pi() * static_cast(ring) / static_cast(rings); + for (int32_t segment = 0; segment < segments; ++segment) { + float theta = 2.0f * glm::pi() * static_cast(segment) / static_cast(segments); + + float x = std::sin(phi) * std::cos(theta); + float y = std::cos(phi); + float z = std::sin(phi) * std::sin(theta); + + sphereVertices.push_back({{x, y, z}}); + } + } + + std::vector sphereIndices; + sphereIndices.reserve(sphereIndicesCount); + + for (int32_t ring = 0; ring < rings; ++ring) { + const int32_t ringStart = ring * segments; + const int32_t nextRingStart = (ring + 1) * segments; + for (int32_t segment = 0; segment < segments; ++segment) { + sphereIndices.push_back(ringStart + segment); + sphereIndices.push_back(nextRingStart + segment); + } + } + + for (int32_t ring = 0; ring <= rings; ++ring) { + const int32_t ringStart = ring * segments; + for (int32_t segment = 0; segment < segments; ++segment) { + sphereIndices.push_back(ringStart + segment); + sphereIndices.push_back(ringStart + ((segment + 1) % segments)); + } + } + + const size_t sphereVertexOffset = instancedVertices.size(); + const size_t sphereIndexOffset = instancedIndices.size(); + instancedVertices.insert(instancedVertices.end(), sphereVertices.begin(), sphereVertices.end()); + instancedIndices.insert(instancedIndices.end(), sphereIndices.begin(), sphereIndices.end()); + + debugRenderInstanceGroups[index].drawIndexedData.indexCount = sphereIndicesCount; + debugRenderInstanceGroups[index].drawIndexedData.firstIndex = sphereIndexOffset; + debugRenderInstanceGroups[index].drawIndexedData.vertexOffset = static_cast(sphereVertexOffset); + debugRenderInstanceGroups[index].drawIndexedData.firstInstance = 0; +} } diff --git a/src/renderer/debug/debug_renderer.h b/src/renderer/debug/debug_renderer.h index 3592961e..41c1b270 100644 --- a/src/renderer/debug/debug_renderer.h +++ b/src/renderer/debug/debug_renderer.h @@ -25,14 +25,10 @@ class DebugRenderer static DebugRenderer* get() { return debugRenderer; } static void set(DebugRenderer* _debugRenderer) { debugRenderer = _debugRenderer; } - struct DrawIndexedData - { - uint32_t indexCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; - }; + void setupBoxRendering(int32_t index); + + void setupSphereRendering(int32_t index); DebugRenderer(ResourceManager& resourceManager); @@ -49,14 +45,14 @@ class DebugRenderer public: void draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawInfo); - void clear(); - void reloadShaders() { createPipeline(); } private: + void clear(); + void createPipeline(); VkPipeline pipeline{VK_NULL_HANDLE}; @@ -83,17 +79,12 @@ class DebugRenderer AllocatedBuffer instancedIndexBuffer{VK_NULL_HANDLE}; /** - * Default size is 512 instances (if vector is greater than 512, it will be truncated) + * 0 = box, 1 = sphere */ - std::vector boxInstances; - std::array boxInstanceBuffers{VK_NULL_HANDLE, VK_NULL_HANDLE}; - DrawIndexedData boxDrawIndexedData{}; + std::array debugRenderInstanceGroups; + + - /** - * Should only house 1x address buffer, but for "correctness" should use `FRAME_OVERLAP` number of address buffers. - * \n But since addresses don't change often (almost never), will forgo this - */ - DescriptorBufferUniform boxInstanceDescriptorBuffer; }; } diff --git a/src/renderer/debug/debug_renderer_types.h b/src/renderer/debug/debug_renderer_types.h index c3ac7e6c..bd909055 100644 --- a/src/renderer/debug/debug_renderer_types.h +++ b/src/renderer/debug/debug_renderer_types.h @@ -8,9 +8,25 @@ #include #include +#include "src/renderer/renderer_constants.h" +#include "src/renderer/vk_types.h" +#include "src/renderer/descriptor_buffer/descriptor_buffer_uniform.h" + namespace will_engine::debug_renderer { static constexpr inline int32_t DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT = 512; +static constexpr inline int32_t BOX_INSTANCE_INDEX = 0; +static constexpr inline int32_t SPHERE_INSTANCE_INDEX = 1; + +struct SphereDetailLevel { + int32_t rings; + int32_t segments; +}; + +static constexpr inline SphereDetailLevel SPHERE_DETAIL_LOW = {4, 8}; +static constexpr inline SphereDetailLevel SPHERE_DETAIL_MEDIUM = {8, 16}; +static constexpr inline SphereDetailLevel SPHERE_DETAIL_HIGH = {16, 32}; + enum class DebugRendererCategory : uint32_t { None = 0x00000000, // Will always be drawn @@ -58,10 +74,11 @@ struct DebugRendererVertex glm::vec3 position; }; -struct BoxInstance { - glm::mat4 transform; // Position + scale - glm::vec3 color; - float padding; +struct DebugRendererInstance +{ + glm::mat4 transform{1.0f}; // Position + scale + glm::vec3 color{0.0f, 1.0f, 0.0f}; + float padding{0.0f}; }; struct DebugRendererDrawInfo @@ -72,6 +89,23 @@ struct DebugRendererDrawInfo VkDescriptorBufferBindingInfoEXT sceneDataBinding{}; VkDeviceSize sceneDataOffset{0}; }; + +struct DrawIndexedData +{ + uint32_t indexCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +}; + + +struct DebugRenderGroup +{ + std::vector instances; + std::array instanceBuffers{VK_NULL_HANDLE, VK_NULL_HANDLE}; + DrawIndexedData drawIndexedData{}; + DescriptorBufferUniform instanceDescriptorBuffer; +}; } #endif //DEBUG_RENDERER_TYPES_H From 242057e593c153da9f9a9df884901d3e1abeabda Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Mon, 28 Apr 2025 21:08:12 +0700 Subject: [PATCH 04/24] Wrap debug rendering in macros. --- assets/settings.willengine | 14 +++++++------- src/core/engine.cpp | 8 +++++++- 2 files changed, 14 insertions(+), 8 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index 24448214..b345c431 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -4.979162693023682, - 1.0666637420654297, - -4.32814359664917 + -10.612048149108887, + 92.03742218017578, + 12.376736640930176 ], "rotation": [ - 0.009367896243929863, - -0.7754089832305908, - 0.011506090871989727, - 0.6312849521636963 + -0.06418858468532562, + 0.39057981967926025, + -0.027312830090522766, + -0.91792231798172 ], "fov": 1.3089969158172607, "aspectRatio": 1.4861111640930176, diff --git a/src/core/engine.cpp b/src/core/engine.cpp index daa4729b..0c4d92ef 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -127,8 +127,10 @@ void Engine::init() assetManager = new AssetManager(*resourceManager); physics = new physics::Physics(); physics::Physics::set(physics); +#if WILL_ENGINE_DEBUG debugRenderer = new debug_renderer::DebugRenderer(*resourceManager); debug_renderer::DebugRenderer::set(debugRenderer); +#endif startupProfiler.addEntry("Immediate, ResourceM, AssetM, Physics"); @@ -627,6 +629,7 @@ void Engine::render(float deltaTime) transparentPipeline->drawAccumulate(cmd, transparentDrawInfo); } +#if WILL_ENGINE_DEBUG if (bDrawDebugRendering) { debug_renderer::DebugRendererDrawInfo debugRendererDrawInfo{ currentFrameOverlap, @@ -644,9 +647,10 @@ void Engine::render(float deltaTime) } } - debugRenderer->drawSphere({0, 0, -5}, 2.0f, {0.0f, 0.7f, 0.1f}); + debugRenderer->drawSphere({0, 0, -5}, 1.0f, {0.0f, 0.7f, 0.1f}); debugRenderer->draw(cmd, debugRendererDrawInfo); } +#endif vk_helpers::transitionImage(cmd, normalRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); @@ -876,7 +880,9 @@ void Engine::cleanup() delete cascadedShadowMap; delete environmentMap; +#if WILL_ENGINE_DEBUG delete debugRenderer; +#endif delete physics; delete immediate; delete resourceManager; From 38ae892a8001b617287a9f5cc1a566cc1109d344 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Mon, 28 Apr 2025 21:16:17 +0700 Subject: [PATCH 05/24] Static debug rendering functions. --- assets/settings.willengine | 12 ++++----- src/core/engine.cpp | 23 +++++++++------- src/renderer/debug/debug_renderer.cpp | 39 ++++++++++++++++++++++----- src/renderer/debug/debug_renderer.h | 18 ++++++++++--- 4 files changed, 67 insertions(+), 25 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index b345c431..cc0db7e8 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -10.612048149108887, + -13.893285751342773, 92.03742218017578, - 12.376736640930176 + 4.206960201263428 ], "rotation": [ - -0.06418858468532562, - 0.39057981967926025, - -0.027312830090522766, - -0.91792231798172 + 0.06707009673118591, + 0.6916321516036987, + 0.06476836651563644, + -0.716206431388855 ], "fov": 1.3089969158172607, "aspectRatio": 1.4861111640930176, diff --git a/src/core/engine.cpp b/src/core/engine.cpp index 0c4d92ef..33160363 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -363,6 +363,8 @@ void Engine::updateGame(const float deltaTime) } hierarchalBeginQueue.clear(); + // This is the main game update loop. + // Recursively updates all child gameobjects of each map for (Map* map : activeMaps) { map->update(deltaTime); } @@ -378,6 +380,18 @@ void Engine::updateGame(const float deltaTime) delete hierarchical; } hierarchicalDeletionQueue.clear(); + + + for (int32_t i{0}; i < 100; i++) { + for (int32_t j{0}; j < 100; j++) { + float z = glm::sin(Time::Get().getTime() - j * 0.5f) * 2.0; + debug_renderer::DebugRenderer::drawBox({i, j, z}, {0.8f, 0.8f, 0.8f}, {0.0f, 0.7f, 0.1f}); + } + } + + debug_renderer::DebugRenderer::drawSphere({0, 0, -5}, 1.0f, {0.0f, 0.7f, 0.1f}); + + } void Engine::updateRender(VkCommandBuffer cmd, const float deltaTime, const int32_t currentFrameOverlap, const int32_t previousFrameOverlap) const @@ -639,15 +653,6 @@ void Engine::render(float deltaTime) sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap }; - - for (int32_t i{0}; i < 100; i++) { - for (int32_t j{0}; j < 100; j++) { - float z = glm::sin(Time::Get().getTime() - j * 0.5f) * 2.0; - debugRenderer->drawBox({i, j, z}, {0.8f, 0.8f, 0.8f}, {0.0f, 0.7f, 0.1f}); - } - } - - debugRenderer->drawSphere({0, 0, -5}, 1.0f, {0.0f, 0.7f, 0.1f}); debugRenderer->draw(cmd, debugRendererDrawInfo); } #endif diff --git a/src/renderer/debug/debug_renderer.cpp b/src/renderer/debug/debug_renderer.cpp index ff27ca3b..5ab76c51 100644 --- a/src/renderer/debug/debug_renderer.cpp +++ b/src/renderer/debug/debug_renderer.cpp @@ -83,6 +83,34 @@ DebugRenderer::~DebugRenderer() resourceManager.destroyPipelineLayout(pipelineLayout); } +void DebugRenderer::drawLine(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color) +{ + DebugRenderer* inst = get(); + if (!inst) { return; } + inst->drawLineImpl(start, end, color); +} + +void DebugRenderer::drawSphere(const glm::vec3& center, float radius, const glm::vec3& color, DebugRendererCategory category) +{ + DebugRenderer* inst = get(); + if (!inst) { return; } + inst->drawSphereImpl(center, radius, color, category); +} + +void DebugRenderer::drawBox(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, DebugRendererCategory category) +{ + DebugRenderer* inst = get(); + if (!inst) { return; } + inst->drawBoxImpl(center, dimensions, color, category); +} + +void DebugRenderer::drawBoxMinMax(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, DebugRendererCategory category) +{ + DebugRenderer* inst = get(); + if (!inst) { return; } + inst->drawBoxMinMaxImpl(min, max, color, category); +} + void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawInfo) { // Upload @@ -222,13 +250,12 @@ void DebugRenderer::generateBuffers() // populate vertex and index buffers } -void DebugRenderer::drawLine(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color) +void DebugRenderer::drawLineImpl(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color) {} -void DebugRenderer::drawSphere(const glm::vec3& center, float radius, const glm::vec3& color, DebugRendererCategory category) +void DebugRenderer::drawSphereImpl(const glm::vec3& center, const float radius, const glm::vec3& color, DebugRendererCategory category) { if (!hasFlag(activeCategories, category)) { return; } - if (!hasFlag(activeCategories, category)) { return; } const glm::mat4 transform = glm::translate(glm::mat4(1.0f), center) * glm::scale(glm::mat4(1.0f), glm::vec3(radius)); @@ -239,7 +266,7 @@ void DebugRenderer::drawSphere(const glm::vec3& center, float radius, const glm: debugRenderInstanceGroups[SPHERE_INSTANCE_INDEX].instances.push_back(instance); } -void DebugRenderer::drawBox(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, const DebugRendererCategory category) +void DebugRenderer::drawBoxImpl(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, const DebugRendererCategory category) { if (!hasFlag(activeCategories, category)) { return; } @@ -252,14 +279,14 @@ void DebugRenderer::drawBox(const glm::vec3& center, const glm::vec3& dimensions debugRenderInstanceGroups[BOX_INSTANCE_INDEX].instances.push_back(instance); } -void DebugRenderer::drawBoxMinmax(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, const DebugRendererCategory category) +void DebugRenderer::drawBoxMinMaxImpl(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, const DebugRendererCategory category) { if (!hasFlag(activeCategories, category)) { return; } const glm::vec3 size = max - min; const glm::vec3 center = min + size * 0.5f; - drawBox(center, size, color, category); + drawBoxImpl(center, size, color, category); } diff --git a/src/renderer/debug/debug_renderer.h b/src/renderer/debug/debug_renderer.h index 41c1b270..f44ddcd9 100644 --- a/src/renderer/debug/debug_renderer.h +++ b/src/renderer/debug/debug_renderer.h @@ -34,13 +34,23 @@ class DebugRenderer ~DebugRenderer(); - void drawLine(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color); +public: + static void drawLine(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color); + + static void drawSphere(const glm::vec3& center, float radius, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); + + static void drawBox(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); + + static void drawBoxMinMax(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); + +private: + void drawLineImpl(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color); - void drawSphere(const glm::vec3& center, float radius, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); + void drawSphereImpl(const glm::vec3& center, float radius, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); - void drawBox(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); + void drawBoxImpl(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); - void drawBoxMinmax(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); + void drawBoxMinMaxImpl(const glm::vec3& min, const glm::vec3& max, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); public: void draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawInfo); From 80dc98e19b2261b9e883c04cbba9b427e81765e4 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Mon, 28 Apr 2025 22:31:12 +0700 Subject: [PATCH 06/24] Dynamically resizing instance buffer for Instanced Debug Rendering. --- assets/settings.willengine | 14 +++++----- src/renderer/debug/debug_renderer.cpp | 34 +++++++++++++++++++---- src/renderer/debug/debug_renderer_types.h | 2 ++ 3 files changed, 38 insertions(+), 12 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index cc0db7e8..f0fe200a 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -13.893285751342773, - 92.03742218017578, - 4.206960201263428 + -29.880571365356445, + 80.48847961425781, + 52.8734130859375 ], "rotation": [ - 0.06707009673118591, - 0.6916321516036987, - 0.06476836651563644, - -0.716206431388855 + 0.013379615731537342, + 0.432039350271225, + 0.006410097703337669, + -0.9017327427864075 ], "fov": 1.3089969158172607, "aspectRatio": 1.4861111640930176, diff --git a/src/renderer/debug/debug_renderer.cpp b/src/renderer/debug/debug_renderer.cpp index 5ab76c51..9f9ef240 100644 --- a/src/renderer/debug/debug_renderer.cpp +++ b/src/renderer/debug/debug_renderer.cpp @@ -113,16 +113,36 @@ void DebugRenderer::drawBoxMinMax(const glm::vec3& min, const glm::vec3& max, co void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawInfo) { + if (drawInfo.currentFrameOverlap < 0 || drawInfo.currentFrameOverlap >= FRAME_OVERLAP) { return; } + // Upload - for (DebugRenderGroup group : debugRenderInstanceGroups) { + for (DebugRenderGroup& group : debugRenderInstanceGroups) { if (group.instances.empty()) { continue; } - if (group.instances.size() > DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT) { - group.instances.resize(DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT); - // todo: dynamic resize + if (group.instances.size() > group.instanceBufferSizes[drawInfo.currentFrameOverlap]) { + uint64_t newSize = group.instanceBufferSizes[drawInfo.currentFrameOverlap]; + // Can potentially overflow resulting in infinite loop, but it would need to be so insanely large, cant even create a buffer that big + while (group.instances.size() > newSize) { + newSize += DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; + } + + resourceManager.destroyBuffer(group.instanceBuffers[drawInfo.currentFrameOverlap]); + + // Don't need to copy, writing to it in the next section anyway + const uint64_t newBufferSize = newSize * sizeof(DebugRendererInstance); + group.instanceBuffers[drawInfo.currentFrameOverlap] = resourceManager.createHostSequentialBuffer(newBufferSize); + + DescriptorUniformData addressesUniformData{ + .uniformBuffer = group.instanceBuffers[drawInfo.currentFrameOverlap], + .allocSize = newBufferSize, + }; + + resourceManager.setupDescriptorBufferUniform(group.instanceDescriptorBuffer, {addressesUniformData}, drawInfo.currentFrameOverlap); + + group.instanceBufferSizes[drawInfo.currentFrameOverlap] = newSize; } - AllocatedBuffer& instanceBuffer = group.instanceBuffers[drawInfo.currentFrameOverlap]; + const AllocatedBuffer& instanceBuffer = group.instanceBuffers[drawInfo.currentFrameOverlap]; memcpy(instanceBuffer.info.pMappedData, group.instances.data(), sizeof(DebugRendererInstance) * group.instances.size()); } @@ -294,8 +314,10 @@ void DebugRenderer::setupBoxRendering(const int32_t index) { // Box Instance Data Buffer constexpr uint64_t boxInstanceBufferSize = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT * sizeof(DebugRendererInstance); + debugRenderInstanceGroups[index].instanceDescriptorBuffer = resourceManager.createDescriptorBufferUniform(uniformLayout, FRAME_OVERLAP); for (int32_t i = 0; i < FRAME_OVERLAP; ++i) { + debugRenderInstanceGroups[index].instanceBufferSizes[i] = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; debugRenderInstanceGroups[index].instanceBuffers[i] = resourceManager.createHostSequentialBuffer(boxInstanceBufferSize); DescriptorUniformData addressesUniformData{ .uniformBuffer = debugRenderInstanceGroups[index].instanceBuffers[i], @@ -348,9 +370,11 @@ void DebugRenderer::setupSphereRendering(const int32_t index) { // Sphere Instance Data Buffer constexpr uint64_t sphereInstanceBufferSize = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT * sizeof(DebugRendererInstance); + debugRenderInstanceGroups[index].instanceDescriptorBuffer = resourceManager.createDescriptorBufferUniform(uniformLayout, FRAME_OVERLAP); for (int32_t i = 0; i < FRAME_OVERLAP; ++i) { debugRenderInstanceGroups[index].instanceBuffers[i] = resourceManager.createHostSequentialBuffer(sphereInstanceBufferSize); + debugRenderInstanceGroups[index].instanceBufferSizes[i] = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; DescriptorUniformData addressesUniformData{ .uniformBuffer = debugRenderInstanceGroups[index].instanceBuffers[i], .allocSize = sphereInstanceBufferSize, diff --git a/src/renderer/debug/debug_renderer_types.h b/src/renderer/debug/debug_renderer_types.h index bd909055..800dd204 100644 --- a/src/renderer/debug/debug_renderer_types.h +++ b/src/renderer/debug/debug_renderer_types.h @@ -103,8 +103,10 @@ struct DebugRenderGroup { std::vector instances; std::array instanceBuffers{VK_NULL_HANDLE, VK_NULL_HANDLE}; + std::array instanceBufferSizes{0, 0}; DrawIndexedData drawIndexedData{}; DescriptorBufferUniform instanceDescriptorBuffer; + }; } From da958e0ee238fe48cd27a040f10566377e965402 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Tue, 29 Apr 2025 21:38:41 +0700 Subject: [PATCH 07/24] Line Debug Rendering --- assets/settings.willengine | 14 +- shaders/debug/debug_renderer.vert | 12 +- shaders/debug/debug_renderer_instanced.frag | 10 + shaders/debug/debug_renderer_instanced.vert | 27 ++ src/core/engine.cpp | 2 +- src/physics/debug/jolt_debug_renderer.cpp | 24 +- src/physics/debug/jolt_debug_renderer.h | 2 +- src/renderer/debug/debug_renderer.cpp | 307 ++++++++++++++------ src/renderer/debug/debug_renderer.h | 29 +- src/renderer/debug/debug_renderer_types.h | 6 + src/renderer/resource_manager.cpp | 4 +- src/renderer/resource_manager.h | 2 +- 12 files changed, 310 insertions(+), 129 deletions(-) create mode 100644 shaders/debug/debug_renderer_instanced.frag create mode 100644 shaders/debug/debug_renderer_instanced.vert diff --git a/assets/settings.willengine b/assets/settings.willengine index f0fe200a..a3c1647f 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -29.880571365356445, - 80.48847961425781, - 52.8734130859375 + 0.48122724890708923, + 97.64861297607422, + 7.157678604125977 ], "rotation": [ - 0.013379615731537342, - 0.432039350271225, - 0.006410097703337669, - -0.9017327427864075 + -0.642738938331604, + 0.0367264486849308, + -0.030873939394950867, + -0.7645814418792725 ], "fov": 1.3089969158172607, "aspectRatio": 1.4861111640930176, diff --git a/shaders/debug/debug_renderer.vert b/shaders/debug/debug_renderer.vert index bb34d958..e0edaed8 100644 --- a/shaders/debug/debug_renderer.vert +++ b/shaders/debug/debug_renderer.vert @@ -1,6 +1,7 @@ #version 460 layout(location = 0) in vec3 inPosition; +layout(location = 1) in vec3 inColor; layout(location = 0) out vec3 outColor; @@ -14,14 +15,7 @@ struct Instance{ // layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl -layout(std140, set = 1, binding = 0) readonly buffer InstanceBuffer { - Instance instances[]; -} instances; - void main() { - Instance instance = instances.instances[gl_InstanceIndex]; - - gl_Position = sceneData.viewProj * instance.transform * vec4(inPosition, 1.0); - gl_Position.xy += gl_Position.w * sceneData.jitter.xy; - outColor = instance.color; + gl_Position = sceneData.viewProj * vec4(inPosition, 1.0); + outColor = inColor; } \ No newline at end of file diff --git a/shaders/debug/debug_renderer_instanced.frag b/shaders/debug/debug_renderer_instanced.frag new file mode 100644 index 00000000..4c321ecf --- /dev/null +++ b/shaders/debug/debug_renderer_instanced.frag @@ -0,0 +1,10 @@ +#version 460 + +layout(location = 0) in vec3 inColor; + +layout (location = 0) out vec4 albedoTarget; + +void main() { + // 0 indicates this won't do light calculations in deferred resolve + albedoTarget = vec4(inColor, 0.0); +} diff --git a/shaders/debug/debug_renderer_instanced.vert b/shaders/debug/debug_renderer_instanced.vert new file mode 100644 index 00000000..bb34d958 --- /dev/null +++ b/shaders/debug/debug_renderer_instanced.vert @@ -0,0 +1,27 @@ +#version 460 + +layout(location = 0) in vec3 inPosition; + +layout(location = 0) out vec3 outColor; + +#include "scene.glsl" + +struct Instance{ + mat4 transform; + vec3 color; + float padding; +}; + +// layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl + +layout(std140, set = 1, binding = 0) readonly buffer InstanceBuffer { + Instance instances[]; +} instances; + +void main() { + Instance instance = instances.instances[gl_InstanceIndex]; + + gl_Position = sceneData.viewProj * instance.transform * vec4(inPosition, 1.0); + gl_Position.xy += gl_Position.w * sceneData.jitter.xy; + outColor = instance.color; +} \ No newline at end of file diff --git a/src/core/engine.cpp b/src/core/engine.cpp index 33160363..b691fb44 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -391,7 +391,7 @@ void Engine::updateGame(const float deltaTime) debug_renderer::DebugRenderer::drawSphere({0, 0, -5}, 1.0f, {0.0f, 0.7f, 0.1f}); - + debug_renderer::DebugRenderer::drawLine({0, 0, 0}, {0, 100, 0}, {1, 0, 0}); } void Engine::updateRender(VkCommandBuffer cmd, const float deltaTime, const int32_t currentFrameOverlap, const int32_t previousFrameOverlap) const diff --git a/src/physics/debug/jolt_debug_renderer.cpp b/src/physics/debug/jolt_debug_renderer.cpp index 8ec48b9d..240b8d18 100644 --- a/src/physics/debug/jolt_debug_renderer.cpp +++ b/src/physics/debug/jolt_debug_renderer.cpp @@ -10,25 +10,41 @@ will_engine::physics::JoltDebugRenderer::JoltDebugRenderer() } will_engine::physics::JoltDebugRenderer::~JoltDebugRenderer() {} -void will_engine::physics::JoltDebugRenderer::DrawLine(JPH::RVec3Arg inFrom, JPH::RVec3Arg inTo, JPH::ColorArg inColor) {} +void will_engine::physics::JoltDebugRenderer::DrawLine(JPH::RVec3Arg inFrom, JPH::RVec3Arg inTo, JPH::ColorArg inColor) +{ + // Implement this +} void will_engine::physics::JoltDebugRenderer::DrawTriangle(JPH::RVec3Arg inV1, JPH::RVec3Arg inV2, JPH::RVec3Arg inV3, JPH::ColorArg inColor, - ECastShadow inCastShadow) {} + ECastShadow inCastShadow) +{ + // Implement this +} JPH::DebugRenderer::Batch will_engine::physics::JoltDebugRenderer::CreateTriangleBatch(const Triangle* inTriangles, int inTriangleCount) { + // Implement This + return {}; } JPH::DebugRenderer::Batch will_engine::physics::JoltDebugRenderer::CreateTriangleBatch(const Vertex* inVertices, int inVertexCount, const JPH::uint32* inIndices, int inIndexCount) { + // Implement This return {}; } void will_engine::physics::JoltDebugRenderer::DrawGeometry(JPH::RMat44Arg inModelMatrix, const JPH::AABox& inWorldSpaceBounds, float inLODScaleSq, JPH::ColorArg inModelColor, const GeometryRef& inGeometry, ECullMode inCullMode, - ECastShadow inCastShadow, EDrawMode inDrawMode) {} + ECastShadow inCastShadow, EDrawMode inDrawMode) +{ + + // Implement This +} void will_engine::physics::JoltDebugRenderer::DrawText3D(JPH::RVec3Arg inPosition, const JPH::string_view& inString, JPH::ColorArg inColor, - float inHeight) {} + float inHeight) +{ + // Do not implement this +} diff --git a/src/physics/debug/jolt_debug_renderer.h b/src/physics/debug/jolt_debug_renderer.h index efd1ec91..e674890d 100644 --- a/src/physics/debug/jolt_debug_renderer.h +++ b/src/physics/debug/jolt_debug_renderer.h @@ -19,7 +19,7 @@ class JoltDebugRenderer final : public JPH::DebugRenderer void DrawLine(JPH::RVec3Arg inFrom, JPH::RVec3Arg inTo, JPH::ColorArg inColor) override; - void DrawTriangle(JPH::RVec3Arg inV1, JPH::RVec3Arg inV2, JPH::RVec3Arg inV3, JPH::ColorArg inColor, ECastShadow inCastShadow = ECastShadow::Off) override; + void DrawTriangle(JPH::RVec3Arg inV1, JPH::RVec3Arg inV2, JPH::RVec3Arg inV3, JPH::ColorArg inColor, ECastShadow inCastShadow) override; Batch CreateTriangleBatch(const Triangle* inTriangles, int inTriangleCount) override; diff --git a/src/renderer/debug/debug_renderer.cpp b/src/renderer/debug/debug_renderer.cpp index 9f9ef240..eaab4283 100644 --- a/src/renderer/debug/debug_renderer.cpp +++ b/src/renderer/debug/debug_renderer.cpp @@ -24,6 +24,7 @@ DebugRenderer::DebugRenderer(ResourceManager& resourceManager) : resourceManager setupBoxRendering(BOX_INSTANCE_INDEX); setupSphereRendering(SPHERE_INSTANCE_INDEX); + setupLineRendering(); // Vertex Buffer const uint64_t instancedVertexBufferSize = instancedVertices.size() * sizeof(DebugRendererVertex); @@ -48,19 +49,21 @@ DebugRenderer::DebugRenderer(ResourceManager& resourceManager) : resourceManager } - VkDescriptorSetLayout descriptorLayout[2]; + std::array descriptorLayout; descriptorLayout[0] = resourceManager.getSceneDataLayout(); descriptorLayout[1] = uniformLayout; - VkPipelineLayoutCreateInfo layoutInfo = vk_helpers::pipelineLayoutCreateInfo(); - layoutInfo.pSetLayouts = descriptorLayout; + layoutInfo.pSetLayouts = descriptorLayout.data(); layoutInfo.pNext = nullptr; layoutInfo.setLayoutCount = 2; layoutInfo.pPushConstantRanges = nullptr; layoutInfo.pushConstantRangeCount = 0; - pipelineLayout = resourceManager.createPipelineLayout(layoutInfo); + instancedPipelineLayout = resourceManager.createPipelineLayout(layoutInfo); + + layoutInfo.setLayoutCount = 1; + normalPipelineLayout = resourceManager.createPipelineLayout(layoutInfo); createPipeline(); } @@ -79,8 +82,15 @@ DebugRenderer::~DebugRenderer() resourceManager.destroyDescriptorBuffer(group.instanceDescriptorBuffer); } - resourceManager.destroyPipeline(pipeline); - resourceManager.destroyPipelineLayout(pipelineLayout); + for (AllocatedBuffer& buffer : lineVertexBuffers) { + resourceManager.destroyBuffer(buffer); + } + + resourceManager.destroyPipelineLayout(instancedPipelineLayout); + resourceManager.destroyPipelineLayout(normalPipelineLayout); + resourceManager.destroyPipeline(instancedLinePipeline); + resourceManager.destroyPipeline(linePipeline); + resourceManager.destroyPipeline(trianglePipeline); } void DebugRenderer::drawLine(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color) @@ -119,6 +129,8 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI for (DebugRenderGroup& group : debugRenderInstanceGroups) { if (group.instances.empty()) { continue; } + AllocatedBuffer& instanceBuffer = group.instanceBuffers[drawInfo.currentFrameOverlap]; + if (group.instances.size() > group.instanceBufferSizes[drawInfo.currentFrameOverlap]) { uint64_t newSize = group.instanceBufferSizes[drawInfo.currentFrameOverlap]; // Can potentially overflow resulting in infinite loop, but it would need to be so insanely large, cant even create a buffer that big @@ -126,14 +138,14 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI newSize += DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; } - resourceManager.destroyBuffer(group.instanceBuffers[drawInfo.currentFrameOverlap]); + resourceManager.destroyBuffer(instanceBuffer); // Don't need to copy, writing to it in the next section anyway const uint64_t newBufferSize = newSize * sizeof(DebugRendererInstance); - group.instanceBuffers[drawInfo.currentFrameOverlap] = resourceManager.createHostSequentialBuffer(newBufferSize); + instanceBuffer = resourceManager.createHostSequentialBuffer(newBufferSize); DescriptorUniformData addressesUniformData{ - .uniformBuffer = group.instanceBuffers[drawInfo.currentFrameOverlap], + .uniformBuffer = instanceBuffer, .allocSize = newBufferSize, }; @@ -142,10 +154,29 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI group.instanceBufferSizes[drawInfo.currentFrameOverlap] = newSize; } - const AllocatedBuffer& instanceBuffer = group.instanceBuffers[drawInfo.currentFrameOverlap]; memcpy(instanceBuffer.info.pMappedData, group.instances.data(), sizeof(DebugRendererInstance) * group.instances.size()); } + // Upload Vertex Line Data + { + AllocatedBuffer& lineVertexBuffer = lineVertexBuffers[drawInfo.currentFrameOverlap]; + + if (lineVertices.size() > lineVertexBuffersSizes[drawInfo.currentFrameOverlap]) { + int64_t newSize = lineVertexBuffersSizes[drawInfo.currentFrameOverlap]; + while (lineVertices.size() > newSize) { + newSize += DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; + } + + resourceManager.destroyBuffer(lineVertexBuffer); + + const uint64_t newBufferSize = newSize * sizeof(DebugRendererVertexFull); + lineVertexBuffer = resourceManager.createHostSequentialBuffer(newBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); + lineVertexBuffersSizes[drawInfo.currentFrameOverlap] = newSize; + } + + memcpy(lineVertexBuffer.info.pMappedData, lineVertices.data(), sizeof(DebugRendererVertexFull) * lineVertices.size()); + } + const VkRenderingAttachmentInfo albedoAttachment = vk_helpers::attachmentInfo(drawInfo.albedoTarget, nullptr, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); @@ -168,54 +199,84 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI renderInfo.pStencilAttachment = nullptr; vkCmdBeginRendering(cmd, &renderInfo); - vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); - - vkCmdSetLineWidth(cmd, 2.0f); - - // Viewport - VkViewport viewport = {}; - viewport.x = 0; - viewport.y = 0; - viewport.width = RENDER_EXTENTS.width; - viewport.height = RENDER_EXTENTS.height; - viewport.minDepth = 0.f; - viewport.maxDepth = 1.f; - vkCmdSetViewport(cmd, 0, 1, &viewport); - // Scissor - VkRect2D scissor = {}; - scissor.offset.x = 0; - scissor.offset.y = 0; - scissor.extent.width = RENDER_EXTENTS.width; - scissor.extent.height = RENDER_EXTENTS.height; - vkCmdSetScissor(cmd, 0, 1, &scissor); - - for (DebugRenderGroup& group : debugRenderInstanceGroups) { - if (group.instances.empty()) { continue;; } - - - const std::array descriptorBufferBindingInfos{ - drawInfo.sceneDataBinding, - group.instanceDescriptorBuffer.getDescriptorBufferBindingInfo() - }; + // Instanced rendering + { + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, instancedLinePipeline); + + vkCmdSetLineWidth(cmd, 2.0f); + + // Viewport + VkViewport viewport = {}; + viewport.x = 0; + viewport.y = 0; + viewport.width = RENDER_EXTENTS.width; + viewport.height = RENDER_EXTENTS.height; + viewport.minDepth = 0.f; + viewport.maxDepth = 1.f; + vkCmdSetViewport(cmd, 0, 1, &viewport); + // Scissor + VkRect2D scissor = {}; + scissor.offset.x = 0; + scissor.offset.y = 0; + scissor.extent.width = RENDER_EXTENTS.width; + scissor.extent.height = RENDER_EXTENTS.height; + vkCmdSetScissor(cmd, 0, 1, &scissor); + + for (DebugRenderGroup& group : debugRenderInstanceGroups) { + if (group.instances.empty()) { continue;; } + + + const std::array descriptorBufferBindingInfos{ + drawInfo.sceneDataBinding, + group.instanceDescriptorBuffer.getDescriptorBufferBindingInfo() + }; - vkCmdBindDescriptorBuffersEXT(cmd, 2, descriptorBufferBindingInfos.data()); + vkCmdBindDescriptorBuffersEXT(cmd, 2, descriptorBufferBindingInfos.data()); - constexpr std::array indices{0, 1}; - const std::array offsets{ - drawInfo.sceneDataOffset, - group.instanceDescriptorBuffer.getDescriptorBufferSize() * drawInfo.currentFrameOverlap, - }; + constexpr std::array indices{0, 1}; + const std::array offsets{ + drawInfo.sceneDataOffset, + group.instanceDescriptorBuffer.getDescriptorBufferSize() * drawInfo.currentFrameOverlap, + }; - vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 2, indices.data(), offsets.data()); + vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, instancedPipelineLayout, 0, 2, indices.data(), offsets.data()); - vkCmdBindVertexBuffers(cmd, 0, 1, &instancedVertexBuffer.buffer, &ZERO_DEVICE_SIZE); - vkCmdBindIndexBuffer(cmd, instancedIndexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32); + vkCmdBindVertexBuffers(cmd, 0, 1, &instancedVertexBuffer.buffer, &ZERO_DEVICE_SIZE); + vkCmdBindIndexBuffer(cmd, instancedIndexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32); - vkCmdDrawIndexed(cmd, group.drawIndexedData.indexCount, group.instances.size(), group.drawIndexedData.firstIndex - , group.drawIndexedData.vertexOffset, group.drawIndexedData.firstInstance); + vkCmdDrawIndexed(cmd, group.drawIndexedData.indexCount, group.instances.size(), group.drawIndexedData.firstIndex + , group.drawIndexedData.vertexOffset, group.drawIndexedData.firstInstance); + } } + // Line Rendering + if (lineVertices.size() > 0) { + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, linePipeline); + + vkCmdSetLineWidth(cmd, 2.0f); + + // Viewport + VkViewport viewport = {}; + viewport.x = 0; + viewport.y = 0; + viewport.width = RENDER_EXTENTS.width; + viewport.height = RENDER_EXTENTS.height; + viewport.minDepth = 0.f; + viewport.maxDepth = 1.f; + vkCmdSetViewport(cmd, 0, 1, &viewport); + // Scissor + VkRect2D scissor = {}; + scissor.offset.x = 0; + scissor.offset.y = 0; + scissor.extent.width = RENDER_EXTENTS.width; + scissor.extent.height = RENDER_EXTENTS.height; + vkCmdSetScissor(cmd, 0, 1, &scissor); + + AllocatedBuffer& currentLineVertexBuffer = lineVertexBuffers[drawInfo.currentFrameOverlap]; + vkCmdBindVertexBuffers(cmd, 0, 1, ¤tLineVertexBuffer.buffer, &ZERO_DEVICE_SIZE); + vkCmdDraw(cmd, lineVertices.size(), 1, 0, 0); + } vkCmdEndRendering(cmd); @@ -227,51 +288,97 @@ void DebugRenderer::clear() for (DebugRenderGroup& group : debugRenderInstanceGroups) { group.instances.clear(); } + lineVertices.clear(); } void DebugRenderer::createPipeline() { - resourceManager.destroyPipeline(pipeline); - VkShaderModule vertShader = resourceManager.createShaderModule("shaders/debug/debug_renderer.vert"); - VkShaderModule fragShader = resourceManager.createShaderModule("shaders/debug/debug_renderer.frag"); - - PipelineBuilder renderPipelineBuilder; - VkVertexInputBindingDescription vertexBinding{}; - vertexBinding.binding = 0; - vertexBinding.stride = sizeof(DebugRendererVertex); - vertexBinding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; - - VkVertexInputAttributeDescription vertexAttributes[4]; - vertexAttributes[0].binding = 0; - vertexAttributes[0].location = 0; - vertexAttributes[0].format = VK_FORMAT_R32G32B32_SFLOAT; - vertexAttributes[0].offset = offsetof(DebugRendererVertex, position); - - const VkVertexInputBindingDescription vertexBindings[1] = {vertexBinding}; - - renderPipelineBuilder.setupVertexInput(vertexBindings, 1, vertexAttributes, 1); - - renderPipelineBuilder.setShaders(vertShader, fragShader); - renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_LINE_LIST); - renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_LINE, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); - renderPipelineBuilder.disableMultisampling(); - renderPipelineBuilder.disableBlending(); - renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); - renderPipelineBuilder.setupRenderer({ALBEDO_FORMAT}, DEPTH_FORMAT); - renderPipelineBuilder.setupPipelineLayout(pipelineLayout); - const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; - pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(fragShader); -} + resourceManager.destroyPipeline(instancedLinePipeline); + resourceManager.destroyPipeline(trianglePipeline); + resourceManager.destroyPipeline(linePipeline); + + // Instanced Pipeline + { + VkShaderModule vertShader = resourceManager.createShaderModule("shaders/debug/debug_renderer_instanced.vert"); + VkShaderModule fragShader = resourceManager.createShaderModule("shaders/debug/debug_renderer_instanced.frag"); + + PipelineBuilder renderPipelineBuilder; + VkVertexInputBindingDescription vertexBinding{}; + vertexBinding.binding = 0; + vertexBinding.stride = sizeof(DebugRendererVertex); + vertexBinding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + + std::array vertexAttributes; + vertexAttributes[0].binding = 0; + vertexAttributes[0].location = 0; + vertexAttributes[0].format = VK_FORMAT_R32G32B32_SFLOAT; + vertexAttributes[0].offset = offsetof(DebugRendererVertex, position); + + renderPipelineBuilder.setupVertexInput(&vertexBinding, 1, vertexAttributes.data(), 1); + + renderPipelineBuilder.setShaders(vertShader, fragShader); + renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_LINE_LIST); // line so that we don't see diagonals on quads + renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_LINE, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); + renderPipelineBuilder.disableMultisampling(); + renderPipelineBuilder.disableBlending(); + renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); + renderPipelineBuilder.setupRenderer({ALBEDO_FORMAT}, DEPTH_FORMAT); + renderPipelineBuilder.setupPipelineLayout(instancedPipelineLayout); + const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; + instancedLinePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); + + resourceManager.destroyShaderModule(vertShader); + resourceManager.destroyShaderModule(fragShader); + } -void DebugRenderer::generateBuffers() -{ - // populate vertex and index buffers + // Line Vertex Pipeline + { + VkShaderModule vertShader = resourceManager.createShaderModule("shaders/debug/debug_renderer.vert"); + VkShaderModule fragShader = resourceManager.createShaderModule("shaders/debug/debug_renderer.frag"); + + PipelineBuilder renderPipelineBuilder; + VkVertexInputBindingDescription vertexBinding{}; + vertexBinding.binding = 0; + vertexBinding.stride = sizeof(DebugRendererVertexFull); + vertexBinding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + + std::array vertexAttributes; + vertexAttributes[0].binding = 0; + vertexAttributes[0].location = 0; + vertexAttributes[0].format = VK_FORMAT_R32G32B32_SFLOAT; + vertexAttributes[0].offset = offsetof(DebugRendererVertexFull, position); + + vertexAttributes[1].binding = 0; + vertexAttributes[1].location = 1; + vertexAttributes[1].format = VK_FORMAT_R32G32B32_SFLOAT; + vertexAttributes[1].offset = offsetof(DebugRendererVertexFull, color); + + renderPipelineBuilder.setupVertexInput(&vertexBinding, 1, vertexAttributes.data(), 2); + + renderPipelineBuilder.setShaders(vertShader, fragShader); + renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_LINE_LIST); + renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_LINE, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); + renderPipelineBuilder.disableMultisampling(); + renderPipelineBuilder.disableBlending(); + renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); + renderPipelineBuilder.setupRenderer({ALBEDO_FORMAT}, DEPTH_FORMAT); + renderPipelineBuilder.setupPipelineLayout(normalPipelineLayout); + const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; + linePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); + + resourceManager.destroyShaderModule(vertShader); + resourceManager.destroyShaderModule(fragShader); + } + + //renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST); + //trianglePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); } void DebugRenderer::drawLineImpl(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color) -{} +{ + lineVertices.push_back({start, color}); + lineVertices.push_back({end, color}); +} void DebugRenderer::drawSphereImpl(const glm::vec3& center, const float radius, const glm::vec3& color, DebugRendererCategory category) { @@ -309,7 +416,6 @@ void DebugRenderer::drawBoxMinMaxImpl(const glm::vec3& min, const glm::vec3& max drawBoxImpl(center, size, color, category); } - void DebugRenderer::setupBoxRendering(const int32_t index) { // Box Instance Data Buffer @@ -336,14 +442,14 @@ void DebugRenderer::setupBoxRendering(const int32_t index) instancedIndices.reserve(instancedIndices.size() + boxIndicesCount); std::vector boxVertices = { - {{0, 0, 0}}, // 0: near bottom left - {{1, 0, 0}}, // 1: near bottom right - {{1, 1, 0}}, // 2: near top right - {{0, 1, 0}}, // 3: near top left - {{0, 0, 1}}, // 4: far bottom left - {{1, 0, 1}}, // 5: far bottom right - {{1, 1, 1}}, // 6: far top right - {{0, 1, 1}} // 7: far top left + {{-0.5, -0.5, -0.5}}, // 0: near bottom left + {{ 0.5, -0.5, -0.5}}, // 1: near bottom right + {{ 0.5, 0.5, -0.5}}, // 2: near top right + {{-0.5, 0.5, -0.5}}, // 3: near top left + {{-0.5, -0.5, 0.5}}, // 4: far bottom left + {{ 0.5, -0.5, 0.5}}, // 5: far bottom right + {{ 0.5, 0.5, 0.5}}, // 6: far top right + {{-0.5, 0.5, 0.5}} // 7: far top left }; std::vector boxIndices = { @@ -440,4 +546,13 @@ void DebugRenderer::setupSphereRendering(const int32_t index) debugRenderInstanceGroups[index].drawIndexedData.vertexOffset = static_cast(sphereVertexOffset); debugRenderInstanceGroups[index].drawIndexedData.firstInstance = 0; } + +void DebugRenderer::setupLineRendering() +{ + constexpr uint64_t vertexBufferSize = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT * sizeof(DebugRendererVertexFull); + for (int32_t i{0}; i < FRAME_OVERLAP; i++) { + lineVertexBuffersSizes[i] = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; + lineVertexBuffers[i] = resourceManager.createHostSequentialBuffer(vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); + } +} } diff --git a/src/renderer/debug/debug_renderer.h b/src/renderer/debug/debug_renderer.h index f44ddcd9..2656f684 100644 --- a/src/renderer/debug/debug_renderer.h +++ b/src/renderer/debug/debug_renderer.h @@ -18,6 +18,12 @@ class ResourceManager; namespace will_engine::debug_renderer { + +struct DebugRendererPushConstant +{ + int32_t bInstanced{false}; +}; + class DebugRenderer { public: @@ -30,6 +36,8 @@ class DebugRenderer void setupSphereRendering(int32_t index); + void setupLineRendering(); + DebugRenderer(ResourceManager& resourceManager); ~DebugRenderer(); @@ -65,21 +73,26 @@ class DebugRenderer void createPipeline(); - VkPipeline pipeline{VK_NULL_HANDLE}; - VkPipelineLayout pipelineLayout{VK_NULL_HANDLE}; + VkPipelineLayout instancedPipelineLayout{VK_NULL_HANDLE}; + VkPipelineLayout normalPipelineLayout{VK_NULL_HANDLE}; + VkPipeline instancedLinePipeline{VK_NULL_HANDLE}; + + + /** + * Full refers to vertex format. Also refers to the lack of vertex color in the vertex data + */ + VkPipeline linePipeline{VK_NULL_HANDLE}; + VkPipeline trianglePipeline{VK_NULL_HANDLE}; private: ResourceManager& resourceManager; - void generateBuffers(); DebugRendererCategory activeCategories{DebugRendererCategory::ALL}; // for custom debug draws from Jolt. For primitives use the instanced draws instead. - // std::vector vertices{}; - // std::vector indices{}; - // AllocatedBuffer vertexBuffer{VK_NULL_HANDLE}; - // AllocatedBuffer indexBuffer{VK_NULL_HANDLE}; - + std::vector lineVertices{}; + std::array lineVertexBuffersSizes{0, 0}; + std::array lineVertexBuffers{VK_NULL_HANDLE, VK_NULL_HANDLE}; VkDescriptorSetLayout uniformLayout{VK_NULL_HANDLE}; diff --git a/src/renderer/debug/debug_renderer_types.h b/src/renderer/debug/debug_renderer_types.h index 800dd204..9a861140 100644 --- a/src/renderer/debug/debug_renderer_types.h +++ b/src/renderer/debug/debug_renderer_types.h @@ -69,6 +69,12 @@ inline bool hasFlag(DebugRendererCategory flags, DebugRendererCategory flag) return (static_cast(flags) & static_cast(flag)) == static_cast(flag); } +struct DebugRendererVertexFull +{ + glm::vec3 position; + glm::vec3 color; +}; + struct DebugRendererVertex { glm::vec3 position; diff --git a/src/renderer/resource_manager.cpp b/src/renderer/resource_manager.cpp index be54a45a..8c3e7aff 100644 --- a/src/renderer/resource_manager.cpp +++ b/src/renderer/resource_manager.cpp @@ -292,12 +292,12 @@ AllocatedBuffer will_engine::ResourceManager::createBuffer(const size_t allocSiz return newBuffer; } -AllocatedBuffer will_engine::ResourceManager::createHostSequentialBuffer(const size_t allocSize) const +AllocatedBuffer will_engine::ResourceManager::createHostSequentialBuffer(const size_t allocSize, const VkBufferUsageFlags additionalUsages) const { const VkBufferCreateInfo bufferInfo{ .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .size = allocSize, - .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | additionalUsages, .sharingMode = VK_SHARING_MODE_EXCLUSIVE }; diff --git a/src/renderer/resource_manager.h b/src/renderer/resource_manager.h index d7941e75..660460e5 100644 --- a/src/renderer/resource_manager.h +++ b/src/renderer/resource_manager.h @@ -87,7 +87,7 @@ class ResourceManager public: // VkBuffer [[nodiscard]] AllocatedBuffer createBuffer(size_t allocSize, VkBufferUsageFlags usage, VmaMemoryUsage memoryUsage) const; - AllocatedBuffer createHostSequentialBuffer(size_t allocSize) const; + AllocatedBuffer createHostSequentialBuffer(size_t allocSize, VkBufferUsageFlags additionalUsages = 0) const; AllocatedBuffer createHostRandomBuffer(size_t allocSize, VkBufferUsageFlags additionalUsages = 0) const; From 925c21ecb8709b00e6c7d2811e43f7adb270855c Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Tue, 29 Apr 2025 21:54:50 +0700 Subject: [PATCH 08/24] Slight optimizations to debug renderer, updated visualization. --- assets/settings.willengine | 14 +++---- src/core/engine.cpp | 5 ++- src/renderer/debug/debug_renderer.cpp | 59 +++++++++------------------ 3 files changed, 30 insertions(+), 48 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index a3c1647f..662809a0 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - 0.48122724890708923, - 97.64861297607422, - 7.157678604125977 + -47.55965805053711, + 42.862831115722656, + 3.535586357116699 ], "rotation": [ - -0.642738938331604, - 0.0367264486849308, - -0.030873939394950867, - -0.7645814418792725 + 0.24308720231056213, + -0.26667773723602295, + -0.06970307230949402, + -0.9300177693367004 ], "fov": 1.3089969158172607, "aspectRatio": 1.4861111640930176, diff --git a/src/core/engine.cpp b/src/core/engine.cpp index b691fb44..c2584c50 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -382,14 +382,15 @@ void Engine::updateGame(const float deltaTime) hierarchicalDeletionQueue.clear(); + constexpr glm::vec3 offset{-100,100,0}; for (int32_t i{0}; i < 100; i++) { for (int32_t j{0}; j < 100; j++) { float z = glm::sin(Time::Get().getTime() - j * 0.5f) * 2.0; - debug_renderer::DebugRenderer::drawBox({i, j, z}, {0.8f, 0.8f, 0.8f}, {0.0f, 0.7f, 0.1f}); + debug_renderer::DebugRenderer::drawBox(offset + glm::vec3(i, j, z), {0.8f, 0.8f, 0.8f}, {0.0f, 0.7f, 0.1f}); } } - debug_renderer::DebugRenderer::drawSphere({0, 0, -5}, 1.0f, {0.0f, 0.7f, 0.1f}); + debug_renderer::DebugRenderer::drawSphere({-50, 40, 0}, 1.0f, {0.0f, 0.7f, 0.1f}); debug_renderer::DebugRenderer::drawLine({0, 0, 0}, {0, 100, 0}, {1, 0, 0}); } diff --git a/src/renderer/debug/debug_renderer.cpp b/src/renderer/debug/debug_renderer.cpp index eaab4283..3b44c3d5 100644 --- a/src/renderer/debug/debug_renderer.cpp +++ b/src/renderer/debug/debug_renderer.cpp @@ -199,29 +199,30 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI renderInfo.pStencilAttachment = nullptr; vkCmdBeginRendering(cmd, &renderInfo); + + vkCmdSetLineWidth(cmd, 2.0f); + + // Viewport + VkViewport viewport = {}; + viewport.x = 0; + viewport.y = 0; + viewport.width = RENDER_EXTENTS.width; + viewport.height = RENDER_EXTENTS.height; + viewport.minDepth = 0.f; + viewport.maxDepth = 1.f; + vkCmdSetViewport(cmd, 0, 1, &viewport); + // Scissor + VkRect2D scissor = {}; + scissor.offset.x = 0; + scissor.offset.y = 0; + scissor.extent.width = RENDER_EXTENTS.width; + scissor.extent.height = RENDER_EXTENTS.height; + vkCmdSetScissor(cmd, 0, 1, &scissor); + // Instanced rendering { vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, instancedLinePipeline); - vkCmdSetLineWidth(cmd, 2.0f); - - // Viewport - VkViewport viewport = {}; - viewport.x = 0; - viewport.y = 0; - viewport.width = RENDER_EXTENTS.width; - viewport.height = RENDER_EXTENTS.height; - viewport.minDepth = 0.f; - viewport.maxDepth = 1.f; - vkCmdSetViewport(cmd, 0, 1, &viewport); - // Scissor - VkRect2D scissor = {}; - scissor.offset.x = 0; - scissor.offset.y = 0; - scissor.extent.width = RENDER_EXTENTS.width; - scissor.extent.height = RENDER_EXTENTS.height; - vkCmdSetScissor(cmd, 0, 1, &scissor); - for (DebugRenderGroup& group : debugRenderInstanceGroups) { if (group.instances.empty()) { continue;; } @@ -253,26 +254,6 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI // Line Rendering if (lineVertices.size() > 0) { vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, linePipeline); - - vkCmdSetLineWidth(cmd, 2.0f); - - // Viewport - VkViewport viewport = {}; - viewport.x = 0; - viewport.y = 0; - viewport.width = RENDER_EXTENTS.width; - viewport.height = RENDER_EXTENTS.height; - viewport.minDepth = 0.f; - viewport.maxDepth = 1.f; - vkCmdSetViewport(cmd, 0, 1, &viewport); - // Scissor - VkRect2D scissor = {}; - scissor.offset.x = 0; - scissor.offset.y = 0; - scissor.extent.width = RENDER_EXTENTS.width; - scissor.extent.height = RENDER_EXTENTS.height; - vkCmdSetScissor(cmd, 0, 1, &scissor); - AllocatedBuffer& currentLineVertexBuffer = lineVertexBuffers[drawInfo.currentFrameOverlap]; vkCmdBindVertexBuffers(cmd, 0, 1, ¤tLineVertexBuffer.buffer, &ZERO_DEVICE_SIZE); vkCmdDraw(cmd, lineVertices.size(), 1, 0, 0); From 0e5ca8cd327e8d10bcae6eb132b2613c9a6c4355 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Wed, 30 Apr 2025 20:19:59 +0700 Subject: [PATCH 09/24] New monitor hard-coded resolution. Implemented line drawing for jolt debug renderer. --- assets/settings.willengine | 14 +++++++------- src/core/engine.cpp | 2 +- src/physics/debug/jolt_debug_renderer.cpp | 10 +++++++--- src/physics/debug/jolt_debug_renderer.h | 12 ++++++++---- src/physics/physics_utils.cpp | 5 +++++ src/physics/physics_utils.h | 2 ++ src/renderer/renderer_constants.h | 2 +- 7 files changed, 31 insertions(+), 16 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index 662809a0..8140fd11 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -47.55965805053711, - 42.862831115722656, - 3.535586357116699 + -43.791263580322266, + 121.78400421142578, + 38.26096725463867 ], "rotation": [ - 0.24308720231056213, - -0.26667773723602295, - -0.06970307230949402, - -0.9300177693367004 + -0.07764521986246109, + -0.1404663622379303, + -0.01105167530477047, + 0.98697429895401 ], "fov": 1.3089969158172607, "aspectRatio": 1.4861111640930176, diff --git a/src/core/engine.cpp b/src/core/engine.cpp index c2584c50..9b5dfb0e 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -77,7 +77,7 @@ void Engine::init() // We initialize SDL and create a window with it. SDL_Init(SDL_INIT_VIDEO); constexpr auto window_flags = SDL_WINDOW_VULKAN | SDL_WINDOW_BORDERLESS | SDL_WINDOW_RESIZABLE; - windowExtent = {1920, 1080}; + windowExtent = {RENDER_EXTENTS.width, RENDER_EXTENTS.height}; //auto window_flags = static_cast(SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE); diff --git a/src/physics/debug/jolt_debug_renderer.cpp b/src/physics/debug/jolt_debug_renderer.cpp index 240b8d18..40ee1bb8 100644 --- a/src/physics/debug/jolt_debug_renderer.cpp +++ b/src/physics/debug/jolt_debug_renderer.cpp @@ -4,15 +4,20 @@ #include "jolt_debug_renderer.h" +#include "src/physics/physics_utils.h" +#include "src/renderer/debug/debug_renderer.h" + + will_engine::physics::JoltDebugRenderer::JoltDebugRenderer() { Initialize(); } will_engine::physics::JoltDebugRenderer::~JoltDebugRenderer() {} -void will_engine::physics::JoltDebugRenderer::DrawLine(JPH::RVec3Arg inFrom, JPH::RVec3Arg inTo, JPH::ColorArg inColor) + +void will_engine::physics::JoltDebugRenderer::DrawLine(JPH::RVec3Arg inFrom, JPH::RVec3Arg inTo, const JPH::ColorArg inColor) { - // Implement this + debug_renderer::DebugRenderer::drawLine(PhysicsUtils::toGLM(inFrom), PhysicsUtils::toGLM(inTo), PhysicsUtils::toGLM(inColor)); } void will_engine::physics::JoltDebugRenderer::DrawTriangle(JPH::RVec3Arg inV1, JPH::RVec3Arg inV2, JPH::RVec3Arg inV3, JPH::ColorArg inColor, @@ -39,7 +44,6 @@ void will_engine::physics::JoltDebugRenderer::DrawGeometry(JPH::RMat44Arg inMode JPH::ColorArg inModelColor, const GeometryRef& inGeometry, ECullMode inCullMode, ECastShadow inCastShadow, EDrawMode inDrawMode) { - // Implement This } diff --git a/src/physics/debug/jolt_debug_renderer.h b/src/physics/debug/jolt_debug_renderer.h index e674890d..b7199017 100644 --- a/src/physics/debug/jolt_debug_renderer.h +++ b/src/physics/debug/jolt_debug_renderer.h @@ -2,11 +2,15 @@ // Created by William on 2024-12-26. // -#ifndef DEBUG_RENDERER_H -#define DEBUG_RENDERER_H +#ifndef JOLT_DEBUG_RENDERER_H +#define JOLT_DEBUG_RENDERER_H #include -#include + +namespace will_engine::debug_renderer +{ +class DebugRenderer; +} namespace will_engine::physics { @@ -32,4 +36,4 @@ class JoltDebugRenderer final : public JPH::DebugRenderer }; } -#endif //DEBUG_RENDERER_H +#endif //JOLT_DEBUG_RENDERER_H diff --git a/src/physics/physics_utils.cpp b/src/physics/physics_utils.cpp index c4521d72..fc2bb843 100644 --- a/src/physics/physics_utils.cpp +++ b/src/physics/physics_utils.cpp @@ -26,6 +26,11 @@ glm::mat4 will_engine::physics::PhysicsUtils::toGLM(const JPH::Mat44& mat) }; } +glm::vec3 will_engine::physics::PhysicsUtils::toGLM(JPH::ColorArg inColor) +{ + return {inColor.r, inColor.g, inColor.b}; +} + JPH::Vec3 will_engine::physics::PhysicsUtils::toJolt(const glm::vec3& v) { return {v.x, v.y, v.z}; diff --git a/src/physics/physics_utils.h b/src/physics/physics_utils.h index aebee8c8..0da10b06 100644 --- a/src/physics/physics_utils.h +++ b/src/physics/physics_utils.h @@ -24,6 +24,8 @@ class PhysicsUtils static glm::mat4 toGLM(const JPH::Mat44& mat); + static glm::vec3 toGLM(JPH::ColorArg inColor); + static JPH::Vec3 toJolt(const glm::vec3& v); static JPH::Quat toJolt(const glm::quat& q); diff --git a/src/renderer/renderer_constants.h b/src/renderer/renderer_constants.h index e77c7791..9b834a46 100644 --- a/src/renderer/renderer_constants.h +++ b/src/renderer/renderer_constants.h @@ -12,7 +12,7 @@ constexpr char ENGINE_NAME[] = "Will Engine"; constexpr bool USING_REVERSED_DEPTH_BUFFER = true; constexpr VkDeviceSize ZERO_DEVICE_SIZE = 0; //constexpr VkExtent2D RENDER_EXTENTS{1920, 1080}; -constexpr VkExtent2D RENDER_EXTENTS{2140, 1440}; +constexpr VkExtent2D RENDER_EXTENTS{2560 , 1440}; //constexpr VkExtent2D RENDER_EXTENTS{3840, 2160}; constexpr float RENDER_EXTENT_WIDTH{RENDER_EXTENTS.width}; constexpr float RENDER_EXTENT_HEIGHT{RENDER_EXTENTS.height}; From 5f50d3545e9e52d8842f4aa2cf123811dff91196 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Fri, 2 May 2025 16:14:43 +0700 Subject: [PATCH 10/24] Triangle debug rendering. --- assets/settings.willengine | 14 ++--- src/core/engine.cpp | 2 + src/physics/debug/jolt_debug_renderer.cpp | 58 ++++++++++++++++-- src/physics/debug/jolt_debug_renderer.h | 21 ++++++- src/renderer/debug/debug_renderer.cpp | 71 ++++++++++++++++++++--- src/renderer/debug/debug_renderer.h | 14 ++++- 6 files changed, 157 insertions(+), 23 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index 8140fd11..61170151 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -43.791263580322266, - 121.78400421142578, - 38.26096725463867 + 0.6203035116195679, + 0.6310845017433167, + 6.731230735778809 ], "rotation": [ - -0.07764521986246109, - -0.1404663622379303, - -0.01105167530477047, - 0.98697429895401 + -0.01829422637820244, + -0.002617889316752553, + -4.903024819213897e-05, + 0.9998292922973633 ], "fov": 1.3089969158172607, "aspectRatio": 1.4861111640930176, diff --git a/src/core/engine.cpp b/src/core/engine.cpp index 9b5dfb0e..28213326 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -393,6 +393,8 @@ void Engine::updateGame(const float deltaTime) debug_renderer::DebugRenderer::drawSphere({-50, 40, 0}, 1.0f, {0.0f, 0.7f, 0.1f}); debug_renderer::DebugRenderer::drawLine({0, 0, 0}, {0, 100, 0}, {1, 0, 0}); + + debug_renderer::DebugRenderer::drawTriangle({0,0,0}, {1,0,0}, {0,1,0}, {0,1,0}); } void Engine::updateRender(VkCommandBuffer cmd, const float deltaTime, const int32_t currentFrameOverlap, const int32_t previousFrameOverlap) const diff --git a/src/physics/debug/jolt_debug_renderer.cpp b/src/physics/debug/jolt_debug_renderer.cpp index 40ee1bb8..4c87675b 100644 --- a/src/physics/debug/jolt_debug_renderer.cpp +++ b/src/physics/debug/jolt_debug_renderer.cpp @@ -28,23 +28,71 @@ void will_engine::physics::JoltDebugRenderer::DrawTriangle(JPH::RVec3Arg inV1, J JPH::DebugRenderer::Batch will_engine::physics::JoltDebugRenderer::CreateTriangleBatch(const Triangle* inTriangles, int inTriangleCount) { - // Implement This + const auto batch = new BatchImpl; + if (inTriangles == nullptr || inTriangleCount == 0) + return batch; - return {}; + batch->mTriangles.assign(inTriangles, inTriangles + inTriangleCount); + return batch; } JPH::DebugRenderer::Batch will_engine::physics::JoltDebugRenderer::CreateTriangleBatch(const Vertex* inVertices, int inVertexCount, const JPH::uint32* inIndices, int inIndexCount) { - // Implement This - return {}; + // Copied from JPH::DebugRendererSimple + const auto batch = new BatchImpl; + if (inVertices == nullptr || inVertexCount == 0 || inIndices == nullptr || inIndexCount == 0) + return batch; + + // Convert indexed triangle list to triangle list + batch->mTriangles.resize(inIndexCount / 3); + for (size_t t = 0; t < batch->mTriangles.size(); ++t) + { + Triangle &triangle = batch->mTriangles[t]; + triangle.mV[0] = inVertices[inIndices[t * 3 + 0]]; + triangle.mV[1] = inVertices[inIndices[t * 3 + 1]]; + triangle.mV[2] = inVertices[inIndices[t * 3 + 2]]; + } + + return batch; } void will_engine::physics::JoltDebugRenderer::DrawGeometry(JPH::RMat44Arg inModelMatrix, const JPH::AABox& inWorldSpaceBounds, float inLODScaleSq, JPH::ColorArg inModelColor, const GeometryRef& inGeometry, ECullMode inCullMode, ECastShadow inCastShadow, EDrawMode inDrawMode) { - // Implement This + // cull mode is always ignored (never cull) + // cast shadow is always ignored (never cast shadows) + // draw mode is always ignored (always wireframe) + + // Copied from JPH::DebugRendererSimple + // Figure out which LOD to use (default to LOD 0) + const LOD *lod = inGeometry->mLODs.data(); + if (mCameraPosSet) + lod = &inGeometry->GetLOD(JPH::Vec3(mCameraPos), inWorldSpaceBounds, inLODScaleSq); + + // Draw the batch + const BatchImpl *batch = static_cast(lod->mTriangleBatch.GetPtr()); + for (const Triangle &triangle : batch->mTriangles) + { + const JPH::RVec3 v0 = inModelMatrix * JPH::Vec3(triangle.mV[0].mPosition); + const JPH::RVec3 v1 = inModelMatrix * JPH::Vec3(triangle.mV[1].mPosition); + const JPH::RVec3 v2 = inModelMatrix * JPH::Vec3(triangle.mV[2].mPosition); + const JPH::Color color = inModelColor * triangle.mV[0].mColor; + + switch (inDrawMode) + { + case EDrawMode::Wireframe: + DrawLine(v0, v1, color); + DrawLine(v1, v2, color); + DrawLine(v2, v0, color); + break; + + case EDrawMode::Solid: + DrawTriangle(v0, v1, v2, color, inCastShadow); + break; + } + } } void will_engine::physics::JoltDebugRenderer::DrawText3D(JPH::RVec3Arg inPosition, const JPH::string_view& inString, JPH::ColorArg inColor, diff --git a/src/physics/debug/jolt_debug_renderer.h b/src/physics/debug/jolt_debug_renderer.h index b7199017..1a7a46d5 100644 --- a/src/physics/debug/jolt_debug_renderer.h +++ b/src/physics/debug/jolt_debug_renderer.h @@ -29,10 +29,29 @@ class JoltDebugRenderer final : public JPH::DebugRenderer Batch CreateTriangleBatch(const Vertex* inVertices, int inVertexCount, const JPH::uint32* inIndices, int inIndexCount) override; - void DrawGeometry(JPH::RMat44Arg inModelMatrix, const JPH::AABox& inWorldSpaceBounds, float inLODScaleSq, JPH::ColorArg inModelColor, const GeometryRef& inGeometry, ECullMode inCullMode, + void DrawGeometry(JPH::RMat44Arg inModelMatrix, const JPH::AABox& inWorldSpaceBounds, float inLODScaleSq, JPH::ColorArg inModelColor, + const GeometryRef& inGeometry, ECullMode inCullMode, ECastShadow inCastShadow, EDrawMode inDrawMode) override; void DrawText3D(JPH::RVec3Arg inPosition, const JPH::string_view& inString, JPH::ColorArg inColor, float inHeight) override; + + class BatchImpl final : public JPH::RefTargetVirtual + { + public: + JPH_OVERRIDE_NEW_DELETE + + virtual void AddRef() override { ++mRefCount; } + virtual void Release() override { if (--mRefCount == 0) delete this; } + + JPH::Array mTriangles; + + private: + std::atomic mRefCount = 0; + }; + + /// Last provided camera position + JPH::RVec3 mCameraPos; + bool mCameraPosSet = false; }; } diff --git a/src/renderer/debug/debug_renderer.cpp b/src/renderer/debug/debug_renderer.cpp index 3b44c3d5..aa11e9a3 100644 --- a/src/renderer/debug/debug_renderer.cpp +++ b/src/renderer/debug/debug_renderer.cpp @@ -85,6 +85,9 @@ DebugRenderer::~DebugRenderer() for (AllocatedBuffer& buffer : lineVertexBuffers) { resourceManager.destroyBuffer(buffer); } + for (AllocatedBuffer& buffer : triangleVertexBuffers) { + resourceManager.destroyBuffer(buffer); + } resourceManager.destroyPipelineLayout(instancedPipelineLayout); resourceManager.destroyPipelineLayout(normalPipelineLayout); @@ -100,6 +103,13 @@ void DebugRenderer::drawLine(const glm::vec3& start, const glm::vec3& end, const inst->drawLineImpl(start, end, color); } +void DebugRenderer::drawTriangle(const glm::vec3& v1, const glm::vec3& v2, const glm::vec3& v3, const glm::vec3& color) +{ + DebugRenderer* inst = get(); + if (!inst) { return; } + inst->drawTriangleImpl(v1, v2, v3, color); +} + void DebugRenderer::drawSphere(const glm::vec3& center, float radius, const glm::vec3& color, DebugRendererCategory category) { DebugRenderer* inst = get(); @@ -157,12 +167,12 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI memcpy(instanceBuffer.info.pMappedData, group.instances.data(), sizeof(DebugRendererInstance) * group.instances.size()); } - // Upload Vertex Line Data + // Upload Vertex Data { AllocatedBuffer& lineVertexBuffer = lineVertexBuffers[drawInfo.currentFrameOverlap]; - if (lineVertices.size() > lineVertexBuffersSizes[drawInfo.currentFrameOverlap]) { - int64_t newSize = lineVertexBuffersSizes[drawInfo.currentFrameOverlap]; + if (lineVertices.size() > lineVertexBufferSizes[drawInfo.currentFrameOverlap]) { + int64_t newSize = lineVertexBufferSizes[drawInfo.currentFrameOverlap]; while (lineVertices.size() > newSize) { newSize += DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; } @@ -171,10 +181,27 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI const uint64_t newBufferSize = newSize * sizeof(DebugRendererVertexFull); lineVertexBuffer = resourceManager.createHostSequentialBuffer(newBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); - lineVertexBuffersSizes[drawInfo.currentFrameOverlap] = newSize; + lineVertexBufferSizes[drawInfo.currentFrameOverlap] = newSize; } memcpy(lineVertexBuffer.info.pMappedData, lineVertices.data(), sizeof(DebugRendererVertexFull) * lineVertices.size()); + + AllocatedBuffer& triangleVertexBuffer = triangleVertexBuffers[drawInfo.currentFrameOverlap]; + + if (triangleVertices.size() > triangleVertexBufferSizes[drawInfo.currentFrameOverlap]) { + int64_t newSize = triangleVertexBufferSizes[drawInfo.currentFrameOverlap]; + while (triangleVertices.size() > newSize) { + newSize += DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; + } + + resourceManager.destroyBuffer(triangleVertexBuffer); + + const uint64_t newBufferSize = newSize * sizeof(DebugRendererVertexFull); + triangleVertexBuffer = resourceManager.createHostSequentialBuffer(newBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); + triangleVertexBufferSizes[drawInfo.currentFrameOverlap] = newSize; + } + + memcpy(triangleVertexBuffer.info.pMappedData, triangleVertices.data(), sizeof(DebugRendererVertexFull) * triangleVertices.size()); } @@ -252,13 +279,20 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI } // Line Rendering - if (lineVertices.size() > 0) { + if (!lineVertices.empty()) { vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, linePipeline); AllocatedBuffer& currentLineVertexBuffer = lineVertexBuffers[drawInfo.currentFrameOverlap]; vkCmdBindVertexBuffers(cmd, 0, 1, ¤tLineVertexBuffer.buffer, &ZERO_DEVICE_SIZE); vkCmdDraw(cmd, lineVertices.size(), 1, 0, 0); } + if (!triangleVertices.empty()) { + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, trianglePipeline); + AllocatedBuffer& currentTriangleVertexBuffer = triangleVertexBuffers[drawInfo.currentFrameOverlap]; + vkCmdBindVertexBuffers(cmd, 0, 1, ¤tTriangleVertexBuffer.buffer, &ZERO_DEVICE_SIZE); + vkCmdDraw(cmd, triangleVertices.size(), 1, 0, 0); + } + vkCmdEndRendering(cmd); clear(); @@ -270,6 +304,7 @@ void DebugRenderer::clear() group.instances.clear(); } lineVertices.clear(); + triangleVertices.clear(); } void DebugRenderer::createPipeline() @@ -347,12 +382,15 @@ void DebugRenderer::createPipeline() const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; linePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); + renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); + renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST); + trianglePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); + resourceManager.destroyShaderModule(vertShader); resourceManager.destroyShaderModule(fragShader); } - //renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST); - //trianglePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); + } void DebugRenderer::drawLineImpl(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color) @@ -361,6 +399,13 @@ void DebugRenderer::drawLineImpl(const glm::vec3& start, const glm::vec3& end, c lineVertices.push_back({end, color}); } +void DebugRenderer::drawTriangleImpl(const glm::vec3& v1, const glm::vec3& v2, const glm::vec3& v3, const glm::vec3& color) +{ + triangleVertices.push_back({v1, color}); + triangleVertices.push_back({v2, color}); + triangleVertices.push_back({v3, color}); +} + void DebugRenderer::drawSphereImpl(const glm::vec3& center, const float radius, const glm::vec3& color, DebugRendererCategory category) { if (!hasFlag(activeCategories, category)) { return; } @@ -532,8 +577,18 @@ void DebugRenderer::setupLineRendering() { constexpr uint64_t vertexBufferSize = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT * sizeof(DebugRendererVertexFull); for (int32_t i{0}; i < FRAME_OVERLAP; i++) { - lineVertexBuffersSizes[i] = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; + lineVertexBufferSizes[i] = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; lineVertexBuffers[i] = resourceManager.createHostSequentialBuffer(vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); } } + +void DebugRenderer::setupTriangleRendering() +{ + constexpr uint64_t vertexBufferSize = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT * sizeof(DebugRendererVertexFull); + for (int32_t i{0}; i < FRAME_OVERLAP; i++) { + triangleVertexBufferSizes[i] = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; + triangleVertexBuffers[i] = resourceManager.createHostSequentialBuffer(vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); + } + +} } diff --git a/src/renderer/debug/debug_renderer.h b/src/renderer/debug/debug_renderer.h index 2656f684..d4fbe998 100644 --- a/src/renderer/debug/debug_renderer.h +++ b/src/renderer/debug/debug_renderer.h @@ -38,13 +38,17 @@ class DebugRenderer void setupLineRendering(); - DebugRenderer(ResourceManager& resourceManager); + void setupTriangleRendering(); + + explicit DebugRenderer(ResourceManager& resourceManager); ~DebugRenderer(); public: static void drawLine(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color); + static void drawTriangle(const glm::vec3& v1, const glm::vec3& v2, const glm::vec3& v3, const glm::vec3& color); + static void drawSphere(const glm::vec3& center, float radius, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); static void drawBox(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); @@ -54,6 +58,8 @@ class DebugRenderer private: void drawLineImpl(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color); + void drawTriangleImpl(const glm::vec3& v1, const glm::vec3& v2, const glm::vec3& v3, const glm::vec3& color); + void drawSphereImpl(const glm::vec3& center, float radius, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); void drawBoxImpl(const glm::vec3& center, const glm::vec3& dimensions, const glm::vec3& color, DebugRendererCategory category = DebugRendererCategory::General); @@ -91,9 +97,13 @@ class DebugRenderer // for custom debug draws from Jolt. For primitives use the instanced draws instead. std::vector lineVertices{}; - std::array lineVertexBuffersSizes{0, 0}; + std::array lineVertexBufferSizes{0, 0}; std::array lineVertexBuffers{VK_NULL_HANDLE, VK_NULL_HANDLE}; + std::vector triangleVertices{}; + std::array triangleVertexBufferSizes{0, 0}; + std::array triangleVertexBuffers{VK_NULL_HANDLE, VK_NULL_HANDLE}; + VkDescriptorSetLayout uniformLayout{VK_NULL_HANDLE}; std::vector instancedVertices{}; From 446c5a6b7e5831a74b14bc75b0513faadb607bb1 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Fri, 2 May 2025 17:44:38 +0700 Subject: [PATCH 11/24] Fully implemented (Slow) physics debug rendering. --- CMakeLists.txt | 7 +-- assets/settings.willengine | 14 +++--- shaders/debug/debug_renderer.vert | 1 + src/core/engine.cpp | 6 +-- src/core/engine.h | 1 + src/physics/debug/jolt_debug_renderer.cpp | 23 +++++---- src/physics/debug/jolt_debug_renderer.h | 9 +++- src/physics/physics.cpp | 33 ++++++++++++- src/physics/physics.h | 58 ++++++++++++++++++++++- src/renderer/debug/debug_renderer.cpp | 19 ++++---- src/renderer/debug/debug_renderer.h | 3 ++ src/renderer/imgui_wrapper.cpp | 40 ++++++++++++++-- src/renderer/imgui_wrapper.h | 5 ++ 13 files changed, 178 insertions(+), 41 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9325ec4c..0db38f64 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,11 +4,11 @@ project(WillEngine) set(CMAKE_CXX_STANDARD 20) add_definitions(-DVK_NO_PROTOTYPES) + add_definitions(-DGLM_FORCE_DEPTH_ZERO_TO_ONE) add_definitions(-DGLM_ENABLE_EXPERIMENTAL) -add_definitions(-DJPH_DEBUG_RENDERER) + #add_definitions(-DJPH_PROFILE_ENABLED=0) -#add_definitions(-DJPH_DEBUG_RENDERER=0) add_definitions(-DJPH_ENABLE_ASSERTS=1) add_definitions(-DJPH_ENABLE_ASSERT_MESSAGES=1) @@ -16,6 +16,7 @@ add_definitions(-DJPH_ENABLE_ASSERT_MESSAGES=1) # ##endif if (CMAKE_BUILD_TYPE STREQUAL "Debug") add_definitions(-DWILL_ENGINE_DEBUG=1) + add_definitions(-DJPH_DEBUG_RENDERER) elseif (CMAKE_BUILD_TYPE STREQUAL "Release") add_definitions(-DWILL_ENGINE_RELEASE=1) endif () @@ -265,7 +266,7 @@ set(TEMP_SOURCES src/renderer/pipelines/visibility_pass/visibility_pass_pipeline_types.h src/renderer/debug/debug_renderer.cpp src/renderer/debug/debug_renderer.h - src/renderer/debug/debug_renderer_tyoes.h + src/renderer/debug/debug_renderer_types.h ) diff --git a/assets/settings.willengine b/assets/settings.willengine index 61170151..c2683d72 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - 0.6203035116195679, - 0.6310845017433167, - 6.731230735778809 + -19.742630004882813, + 58.299896240234375, + 50.910675048828125 ], "rotation": [ - -0.01829422637820244, - -0.002617889316752553, - -4.903024819213897e-05, - 0.9998292922973633 + -0.1941918581724167, + -0.4166218042373657, + -0.09158731251955032, + 0.8833615183830261 ], "fov": 1.3089969158172607, "aspectRatio": 1.4861111640930176, diff --git a/shaders/debug/debug_renderer.vert b/shaders/debug/debug_renderer.vert index e0edaed8..69dd4ab9 100644 --- a/shaders/debug/debug_renderer.vert +++ b/shaders/debug/debug_renderer.vert @@ -17,5 +17,6 @@ struct Instance{ void main() { gl_Position = sceneData.viewProj * vec4(inPosition, 1.0); + gl_Position.xy += gl_Position.w * sceneData.jitter.xy; outColor = inColor; } \ No newline at end of file diff --git a/src/core/engine.cpp b/src/core/engine.cpp index 28213326..ce862731 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -331,11 +331,11 @@ void Engine::run() void Engine::updatePhysics(const float deltaTime) const { - if (bPausePhysics) { - return; + if (!bPausePhysics) { + physics::Physics::get()->update(deltaTime); } - physics::Physics::get()->update(deltaTime); + physics::Physics::get()->drawDebug(); } void Engine::updateGame(const float deltaTime) diff --git a/src/core/engine.h b/src/core/engine.h index 33860a75..43b8036e 100644 --- a/src/core/engine.h +++ b/src/core/engine.h @@ -14,6 +14,7 @@ #include "camera/free_camera.h" #include "scene/serializer.h" #include "src/core/profiler/profiler.h" +#include "src/physics/debug/jolt_debug_renderer.h" #include "src/renderer/imgui_wrapper.h" #include "src/renderer/renderer_constants.h" #include "src/renderer/vk_types.h" diff --git a/src/physics/debug/jolt_debug_renderer.cpp b/src/physics/debug/jolt_debug_renderer.cpp index 4c87675b..321004c2 100644 --- a/src/physics/debug/jolt_debug_renderer.cpp +++ b/src/physics/debug/jolt_debug_renderer.cpp @@ -2,6 +2,8 @@ // Created by William on 2024-12-26. // +#ifdef JPH_DEBUG_RENDERER + #include "jolt_debug_renderer.h" #include "src/physics/physics_utils.h" @@ -23,11 +25,13 @@ void will_engine::physics::JoltDebugRenderer::DrawLine(JPH::RVec3Arg inFrom, JPH void will_engine::physics::JoltDebugRenderer::DrawTriangle(JPH::RVec3Arg inV1, JPH::RVec3Arg inV2, JPH::RVec3Arg inV3, JPH::ColorArg inColor, ECastShadow inCastShadow) { - // Implement this + debug_renderer::DebugRenderer::drawTriangle(PhysicsUtils::toGLM(inV1), PhysicsUtils::toGLM(inV2), PhysicsUtils::toGLM(inV3), + PhysicsUtils::toGLM(inColor)); } JPH::DebugRenderer::Batch will_engine::physics::JoltDebugRenderer::CreateTriangleBatch(const Triangle* inTriangles, int inTriangleCount) { + // Copied from JPH::DebugRendererSimple const auto batch = new BatchImpl; if (inTriangles == nullptr || inTriangleCount == 0) return batch; @@ -46,9 +50,8 @@ JPH::DebugRenderer::Batch will_engine::physics::JoltDebugRenderer::CreateTriangl // Convert indexed triangle list to triangle list batch->mTriangles.resize(inIndexCount / 3); - for (size_t t = 0; t < batch->mTriangles.size(); ++t) - { - Triangle &triangle = batch->mTriangles[t]; + for (size_t t = 0; t < batch->mTriangles.size(); ++t) { + Triangle& triangle = batch->mTriangles[t]; triangle.mV[0] = inVertices[inIndices[t * 3 + 0]]; triangle.mV[1] = inVertices[inIndices[t * 3 + 1]]; triangle.mV[2] = inVertices[inIndices[t * 3 + 2]]; @@ -67,21 +70,19 @@ void will_engine::physics::JoltDebugRenderer::DrawGeometry(JPH::RMat44Arg inMode // Copied from JPH::DebugRendererSimple // Figure out which LOD to use (default to LOD 0) - const LOD *lod = inGeometry->mLODs.data(); + const LOD* lod = inGeometry->mLODs.data(); if (mCameraPosSet) lod = &inGeometry->GetLOD(JPH::Vec3(mCameraPos), inWorldSpaceBounds, inLODScaleSq); // Draw the batch - const BatchImpl *batch = static_cast(lod->mTriangleBatch.GetPtr()); - for (const Triangle &triangle : batch->mTriangles) - { + const BatchImpl* batch = static_cast(lod->mTriangleBatch.GetPtr()); + for (const Triangle& triangle : batch->mTriangles) { const JPH::RVec3 v0 = inModelMatrix * JPH::Vec3(triangle.mV[0].mPosition); const JPH::RVec3 v1 = inModelMatrix * JPH::Vec3(triangle.mV[1].mPosition); const JPH::RVec3 v2 = inModelMatrix * JPH::Vec3(triangle.mV[2].mPosition); const JPH::Color color = inModelColor * triangle.mV[0].mColor; - switch (inDrawMode) - { + switch (inDrawMode) { case EDrawMode::Wireframe: DrawLine(v0, v1, color); DrawLine(v1, v2, color); @@ -100,3 +101,5 @@ void will_engine::physics::JoltDebugRenderer::DrawText3D(JPH::RVec3Arg inPositio { // Do not implement this } + +#endif // JPH_DEBUG_RENDERER diff --git a/src/physics/debug/jolt_debug_renderer.h b/src/physics/debug/jolt_debug_renderer.h index 1a7a46d5..6c7bbcff 100644 --- a/src/physics/debug/jolt_debug_renderer.h +++ b/src/physics/debug/jolt_debug_renderer.h @@ -5,7 +5,14 @@ #ifndef JOLT_DEBUG_RENDERER_H #define JOLT_DEBUG_RENDERER_H -#include +#include +#include + +#ifndef JPH_DEBUG_RENDERER + #error This file should only be included when JPH_DEBUG_RENDERER is defined +#endif // !JPH_DEBUG_RENDERER + + namespace will_engine::debug_renderer { diff --git a/src/physics/physics.cpp b/src/physics/physics.cpp index 63b6982b..91c53c50 100644 --- a/src/physics/physics.cpp +++ b/src/physics/physics.cpp @@ -47,6 +47,10 @@ Physics::Physics() // Create physics system physicsSystem = new JPH::PhysicsSystem(); +#ifdef JPH_DEBUG_RENDERER + joltDebugRenderer = new JoltDebugRenderer(); + joltDebugDrawFilter = new JoltDebugDrawFilter(); +#endif physicsSystem->Init( MAX_BODIES, NUM_BODY_MUTEXES, @@ -261,7 +265,7 @@ JPH::BodyID Physics::setupRigidbody(IPhysicsBody* physicsBody, const JPH::EShape shape = getUnitCapsuleShape(); break; } - shape = new JPH::CapsuleShape(shapeParams.y, shapeParams.z); + shape = new JPH::CapsuleShape(shapeParams.y, shapeParams.x); break; case JPH::EShapeSubType::Cylinder: if (shapeParams == UNIT_CYLINDER) { @@ -341,6 +345,11 @@ void Physics::releaseRigidbody(IPhysicsBody* physicsBody) physicsSystem->GetBodyInterface().DestroyBody(bodyId); physicsObjects.erase(bodyId); physicsBody->setPhysicsBodyId(JPH::BodyID(JPH::BodyID::cMaxBodyIndex)); + +#ifdef JPH_DEBUG_RENDERER + joltDebugDrawFilter->RemoveBody(bodyId); +#endif // JPH_DEBUG_RENDERER + } void Physics::setPositionAndRotation(const JPH::BodyID bodyId, const glm::vec3 position, const glm::quat rotation, const bool activate) const @@ -411,6 +420,14 @@ void Physics::setMotionType(const IPhysicsBody* body, const JPH::EMotionType mot physicsSystem->GetBodyInterface().SetMotionType(body->getPhysicsBodyId(), motionType, activation); } +void Physics::drawDebug() +{ +#ifdef JPH_DEBUG_RENDERER + constexpr JPH::BodyManager::DrawSettings drawSettings{}; + physicsSystem->DrawBodies(drawSettings, joltDebugRenderer, joltDebugDrawFilter); +#endif +} + PhysicsProperties Physics::serializeProperties(const IPhysicsBody* physicsBody) const { if (physicsBody == nullptr || physicsBody->getPhysicsBodyId().GetIndex() == JPH::BodyID::cMaxBodyIndex) { @@ -472,4 +489,18 @@ bool Physics::deserializeProperties(IPhysicsBody* physicsBody, const PhysicsProp auto bodyId = setupRigidbody(physicsBody, properties.shapeType, properties.shapeParams, static_cast(properties.motionType), properties.layer); return bodyId.GetIndex() != JPH::BodyID::cMaxBodyIndex; } + +void Physics::drawDebug(const JPH::BodyID bodyId) const +{ +#ifdef JPH_DEBUG_RENDERER + joltDebugDrawFilter->AddBody(bodyId); +#endif // JPH_DEBUG_RENDERER +} + +void Physics::stopDrawDebug(const JPH::BodyID bodyId) const +{ +#ifdef JPH_DEBUG_RENDERER + joltDebugDrawFilter->RemoveBody(bodyId); +#endif // JPH_DEBUG_RENDERER +} } diff --git a/src/physics/physics.h b/src/physics/physics.h index a8db72f8..1d212435 100644 --- a/src/physics/physics.h +++ b/src/physics/physics.h @@ -18,6 +18,7 @@ #include "physics_types.h" #include "physics_body.h" +#include "debug/jolt_debug_renderer.h" class GameObject; @@ -72,9 +73,11 @@ class Physics PhysicsObject* getPhysicsObject(JPH::BodyID bodyId); public: - JPH::BodyID setupRigidbody(IPhysicsBody* physicsBody, JPH::EShapeSubType shapeType, glm::vec3 shapeParams, JPH::EMotionType motion, JPH::ObjectLayer layer); + JPH::BodyID setupRigidbody(IPhysicsBody* physicsBody, JPH::EShapeSubType shapeType, glm::vec3 shapeParams, JPH::EMotionType motion, + JPH::ObjectLayer layer); - JPH::BodyID setupRigidbody(IPhysicsBody* physicsBody, JPH::HeightFieldShapeSettings& heightFieldShapeSettings, JPH::EMotionType motion, JPH::ObjectLayer layer); + JPH::BodyID setupRigidbody(IPhysicsBody* physicsBody, JPH::HeightFieldShapeSettings& heightFieldShapeSettings, JPH::EMotionType motion, + JPH::ObjectLayer layer); void releaseRigidbody(IPhysicsBody* physicsBody); @@ -96,10 +99,13 @@ class Physics void setMotionType(const IPhysicsBody* body, JPH::EMotionType motionType, JPH::EActivation activation) const; + void drawDebug(); + public: // Serialization PhysicsProperties serializeProperties(const IPhysicsBody* physicsBody) const; bool deserializeProperties(IPhysicsBody* physicsBody, const PhysicsProperties& properties); + private: // Core systems JPH::PhysicsSystem* physicsSystem = nullptr; @@ -128,6 +134,54 @@ class Physics JPH::ShapeRefC unitSphereShape = nullptr; JPH::ShapeRefC unitCapsuleShape = nullptr; JPH::ShapeRefC unitCylinderShape = nullptr; + + +public: // Debug + void drawDebug(JPH::BodyID bodyId) const; + void stopDrawDebug(JPH::BodyID bodyId) const; + +private: // Debug +#ifdef JPH_DEBUG_RENDERER + class JoltDebugDrawFilter final : public JPH::BodyDrawFilter + { + public: + ~JoltDebugDrawFilter() override = default; + + bool ShouldDraw(const JPH::Body& inBody) const override + { + return !bodiesToDraw.empty() && std::ranges::find(bodiesToDraw, inBody.GetID()) != bodiesToDraw.end(); + } + + void AddBody(const JPH::BodyID bodyId) + { + if (std::ranges::find(bodiesToDraw, bodyId) == bodiesToDraw.end()) { + bodiesToDraw.push_back(bodyId); + } + } + + void RemoveBody(const JPH::BodyID bodyId) + { + const auto it = std::ranges::find(bodiesToDraw, bodyId); + if (it != bodiesToDraw.end()) { + bodiesToDraw.erase(it); + } + } + + void Clear() + { + bodiesToDraw.clear(); + } + + private: + std::vector bodiesToDraw; + }; + + + JoltDebugDrawFilter* joltDebugDrawFilter{nullptr}; + JoltDebugRenderer* joltDebugRenderer{nullptr}; +#endif + +public: }; } diff --git a/src/renderer/debug/debug_renderer.cpp b/src/renderer/debug/debug_renderer.cpp index aa11e9a3..368dfc78 100644 --- a/src/renderer/debug/debug_renderer.cpp +++ b/src/renderer/debug/debug_renderer.cpp @@ -382,15 +382,13 @@ void DebugRenderer::createPipeline() const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; linePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); - renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); + //renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST); trianglePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); resourceManager.destroyShaderModule(vertShader); resourceManager.destroyShaderModule(fragShader); } - - } void DebugRenderer::drawLineImpl(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color) @@ -469,13 +467,13 @@ void DebugRenderer::setupBoxRendering(const int32_t index) std::vector boxVertices = { {{-0.5, -0.5, -0.5}}, // 0: near bottom left - {{ 0.5, -0.5, -0.5}}, // 1: near bottom right - {{ 0.5, 0.5, -0.5}}, // 2: near top right - {{-0.5, 0.5, -0.5}}, // 3: near top left - {{-0.5, -0.5, 0.5}}, // 4: far bottom left - {{ 0.5, -0.5, 0.5}}, // 5: far bottom right - {{ 0.5, 0.5, 0.5}}, // 6: far top right - {{-0.5, 0.5, 0.5}} // 7: far top left + {{0.5, -0.5, -0.5}}, // 1: near bottom right + {{0.5, 0.5, -0.5}}, // 2: near top right + {{-0.5, 0.5, -0.5}}, // 3: near top left + {{-0.5, -0.5, 0.5}}, // 4: far bottom left + {{0.5, -0.5, 0.5}}, // 5: far bottom right + {{0.5, 0.5, 0.5}}, // 6: far top right + {{-0.5, 0.5, 0.5}} // 7: far top left }; std::vector boxIndices = { @@ -589,6 +587,5 @@ void DebugRenderer::setupTriangleRendering() triangleVertexBufferSizes[i] = DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; triangleVertexBuffers[i] = resourceManager.createHostSequentialBuffer(vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); } - } } diff --git a/src/renderer/debug/debug_renderer.h b/src/renderer/debug/debug_renderer.h index d4fbe998..aaae371c 100644 --- a/src/renderer/debug/debug_renderer.h +++ b/src/renderer/debug/debug_renderer.h @@ -24,6 +24,9 @@ struct DebugRendererPushConstant int32_t bInstanced{false}; }; +/** + * Note: Debug rendering doesn't write to the velocity buffer, so do not contribute to the velocity buffer. As a result, no TAA is expected. + */ class DebugRenderer { public: diff --git a/src/renderer/imgui_wrapper.cpp b/src/renderer/imgui_wrapper.cpp index 0c822ffd..d5ff07ca 100644 --- a/src/renderer/imgui_wrapper.cpp +++ b/src/renderer/imgui_wrapper.cpp @@ -21,6 +21,7 @@ #include "src/core/camera/free_camera.h" #include "src/core/game_object/renderable.h" #include "src/core/scene/serializer.h" +#include "src/physics/physics.h" #include "src/util/file.h" #include "src/util/math_utils.h" @@ -1222,6 +1223,14 @@ void ImguiWrapper::imguiInterface(Engine* engine) if (IImguiRenderable* imguiRenderable = dynamic_cast(selectedItem)) { imguiRenderable->selectedRenderImgui(); } + + if (auto gameObject = dynamic_cast(selectedItem)) { + if (components::RigidBodyComponent* rb = gameObject->getRigidbody()) { + if (rb->hasRigidBody()) { + physics::Physics::get()->drawDebug(rb->getPhysicsBodyId()); + } + } + } } ImGui::Render(); @@ -1429,7 +1438,7 @@ void ImguiWrapper::drawSceneGraph(Engine* engine) if (destroy) { selectedMap->destroy(); selectMap(nullptr); - selectedItem = nullptr; + deselectItem(); } } @@ -1452,7 +1461,7 @@ void ImguiWrapper::displayGameObject(Engine* engine, IHierarchical* obj, const i ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1, 0, 0, 1)); if (ImGui::Button("X")) { if (selectedItem == obj) { - selectedItem = nullptr; + deselectItem(); } obj->destroy(); } @@ -1484,7 +1493,12 @@ void ImguiWrapper::displayGameObject(Engine* engine, IHierarchical* obj, const i } if (ImGui::IsItemClicked() && !ImGui::IsItemToggledOpen()) { - selectedItem = (obj == selectedItem) ? nullptr : obj; + if (obj == selectedItem) { + deselectItem(); + } + else { + selectItem(obj); + } } ImGui::NextColumn(); @@ -1621,4 +1635,24 @@ int ImguiWrapper::getIndexInVector(const IHierarchical* obj, const std::vector(selectedItem)) { + if (const components::RigidBodyComponent* rb = gameObject->getRigidbody()) { + if (rb->hasRigidBody()) { + physics::Physics::get()->stopDrawDebug(rb->getPhysicsBodyId()); + } + } + } + selectedItem = nullptr; +} } diff --git a/src/renderer/imgui_wrapper.h b/src/renderer/imgui_wrapper.h index a3aae996..1d9ef03f 100644 --- a/src/renderer/imgui_wrapper.h +++ b/src/renderer/imgui_wrapper.h @@ -60,6 +60,11 @@ class ImguiWrapper */ static int getIndexInVector(const IHierarchical* obj, const std::vector& vector); +private: + void selectItem(IHierarchical* hierarchical); + + void deselectItem(); + private: const VulkanContext& context; From 24b8d91a28a6c37abef2b0a743e532ba7fa9fdc6 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Fri, 2 May 2025 17:48:21 +0700 Subject: [PATCH 12/24] Fix compile issue for release builds (disable physics draw in release). --- src/core/engine.h | 1 - src/physics/physics.h | 2 ++ 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/src/core/engine.h b/src/core/engine.h index 43b8036e..33860a75 100644 --- a/src/core/engine.h +++ b/src/core/engine.h @@ -14,7 +14,6 @@ #include "camera/free_camera.h" #include "scene/serializer.h" #include "src/core/profiler/profiler.h" -#include "src/physics/debug/jolt_debug_renderer.h" #include "src/renderer/imgui_wrapper.h" #include "src/renderer/renderer_constants.h" #include "src/renderer/vk_types.h" diff --git a/src/physics/physics.h b/src/physics/physics.h index 1d212435..4a4d04a0 100644 --- a/src/physics/physics.h +++ b/src/physics/physics.h @@ -18,7 +18,9 @@ #include "physics_types.h" #include "physics_body.h" +#ifdef JPH_DEBUG_RENDERER #include "debug/jolt_debug_renderer.h" +#endif // JPH_DEBUG_RENDERER class GameObject; From dd087b80d9b8c49c76ba61cf8c30b4ee26dfe92d Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Fri, 2 May 2025 21:28:37 +0700 Subject: [PATCH 13/24] Composite debug draws with final image to skip TAA, tone-mapping, and sharpening. --- CMakeLists.txt | 2 + assets/settings.willengine | 18 +-- shaders/debug/debug_pipeline.comp | 31 +++++ shaders/debug/debug_renderer.frag | 6 +- shaders/debug/debug_renderer.vert | 11 +- shaders/debug/debug_renderer_instanced.frag | 6 +- shaders/debug/debug_renderer_instanced.vert | 1 - shaders/environment/environment.frag | 2 +- src/core/camera/free_camera.h | 5 +- src/core/engine.cpp | 84 +++++++----- src/core/engine.h | 11 +- src/physics/debug/jolt_debug_renderer.h | 2 - src/renderer/debug/debug_renderer.cpp | 25 +++- src/renderer/debug/debug_renderer_types.h | 2 +- src/renderer/imgui_wrapper.cpp | 7 +- .../pipelines/debug/debug_pipeline.cpp | 123 ++++++++++++++++++ src/renderer/pipelines/debug/debug_pipeline.h | 54 ++++++++ src/renderer/renderer_constants.h | 4 +- 18 files changed, 319 insertions(+), 75 deletions(-) create mode 100644 shaders/debug/debug_pipeline.comp create mode 100644 src/renderer/pipelines/debug/debug_pipeline.cpp create mode 100644 src/renderer/pipelines/debug/debug_pipeline.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 0db38f64..b4af05fd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -267,6 +267,8 @@ set(TEMP_SOURCES src/renderer/debug/debug_renderer.cpp src/renderer/debug/debug_renderer.h src/renderer/debug/debug_renderer_types.h + src/renderer/pipelines/debug/debug_pipeline.cpp + src/renderer/pipelines/debug/debug_pipeline.h ) diff --git a/assets/settings.willengine b/assets/settings.willengine index c2683d72..b0145d1b 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,18 +9,18 @@ }, "cameraSettings": { "position": [ - -19.742630004882813, - 58.299896240234375, - 50.910675048828125 + 40.22589874267578, + 152.3096160888672, + -0.24074575304985046 ], "rotation": [ - -0.1941918581724167, - -0.4166218042373657, - -0.09158731251955032, - 0.8833615183830261 + -0.04059086740016937, + 0.6134752631187439, + 0.031599532812833786, + 0.7880368828773499 ], "fov": 1.3089969158172607, - "aspectRatio": 1.4861111640930176, + "aspectRatio": 1.7777777910232544, "nearPlane": 1000.0, "farPlane": 0.10000000149011612 }, @@ -127,7 +127,7 @@ } }, "taaSettings": { - "enabled": true, + "enabled": false, "properties": { "blendValue": 0.10000000149011612 } diff --git a/shaders/debug/debug_pipeline.comp b/shaders/debug/debug_pipeline.comp new file mode 100644 index 00000000..136d6fc2 --- /dev/null +++ b/shaders/debug/debug_pipeline.comp @@ -0,0 +1,31 @@ +#version 460 + +layout (local_size_x = 16, local_size_y = 16) in; + +layout(binding = 0) uniform sampler2D debugImage; +layout(binding = 1, rgba16) uniform image2D finalImage; + +layout (push_constant) uniform PushConstants { + vec2 bounds; +} push; + + +void main() { + ivec2 pixelCoord = ivec2(gl_GlobalInvocationID.xy); + if (any(greaterThan(pixelCoord, ivec2(push.bounds)))) { + return; + } + vec2 uv = (vec2(pixelCoord) + 0.5) / push.bounds; + vec4 mainColor = imageLoad(finalImage, pixelCoord); + + // todo: debugUv also needs to be unjittered + vec2 debugUv = uv; + debugUv.y = 1 - debugUv.y; + vec4 debugColor = texture(debugImage, debugUv); + + + + vec4 finalColor = mix(mainColor, debugColor, debugColor.a); + + imageStore(finalImage, pixelCoord, finalColor); +} \ No newline at end of file diff --git a/shaders/debug/debug_renderer.frag b/shaders/debug/debug_renderer.frag index 4c321ecf..e7bfb980 100644 --- a/shaders/debug/debug_renderer.frag +++ b/shaders/debug/debug_renderer.frag @@ -1,10 +1,10 @@ #version 460 -layout(location = 0) in vec3 inColor; +layout (location = 0) in vec3 inColor; -layout (location = 0) out vec4 albedoTarget; +layout (location = 0) out vec4 imageTarget; void main() { // 0 indicates this won't do light calculations in deferred resolve - albedoTarget = vec4(inColor, 0.0); + imageTarget = vec4(inColor, 1.0); } diff --git a/shaders/debug/debug_renderer.vert b/shaders/debug/debug_renderer.vert index 69dd4ab9..a8187efa 100644 --- a/shaders/debug/debug_renderer.vert +++ b/shaders/debug/debug_renderer.vert @@ -1,22 +1,17 @@ #version 460 +#include "scene.glsl" + layout(location = 0) in vec3 inPosition; layout(location = 1) in vec3 inColor; layout(location = 0) out vec3 outColor; -#include "scene.glsl" - -struct Instance{ - mat4 transform; - vec3 color; - float padding; -}; - // layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl void main() { gl_Position = sceneData.viewProj * vec4(inPosition, 1.0); gl_Position.xy += gl_Position.w * sceneData.jitter.xy; outColor = inColor; + // todo: add jitter } \ No newline at end of file diff --git a/shaders/debug/debug_renderer_instanced.frag b/shaders/debug/debug_renderer_instanced.frag index 4c321ecf..e7bfb980 100644 --- a/shaders/debug/debug_renderer_instanced.frag +++ b/shaders/debug/debug_renderer_instanced.frag @@ -1,10 +1,10 @@ #version 460 -layout(location = 0) in vec3 inColor; +layout (location = 0) in vec3 inColor; -layout (location = 0) out vec4 albedoTarget; +layout (location = 0) out vec4 imageTarget; void main() { // 0 indicates this won't do light calculations in deferred resolve - albedoTarget = vec4(inColor, 0.0); + imageTarget = vec4(inColor, 1.0); } diff --git a/shaders/debug/debug_renderer_instanced.vert b/shaders/debug/debug_renderer_instanced.vert index bb34d958..2f718f19 100644 --- a/shaders/debug/debug_renderer_instanced.vert +++ b/shaders/debug/debug_renderer_instanced.vert @@ -20,7 +20,6 @@ layout(std140, set = 1, binding = 0) readonly buffer InstanceBuffer { void main() { Instance instance = instances.instances[gl_InstanceIndex]; - gl_Position = sceneData.viewProj * instance.transform * vec4(inPosition, 1.0); gl_Position.xy += gl_Position.w * sceneData.jitter.xy; outColor = instance.color; diff --git a/shaders/environment/environment.frag b/shaders/environment/environment.frag index dd53a94c..e0d6618b 100644 --- a/shaders/environment/environment.frag +++ b/shaders/environment/environment.frag @@ -21,7 +21,7 @@ void main() direction.y = -direction.y; vec3 envColor = textureLod(environmentMap, direction, 0).rgb; - // 0 = environment map flag + // 0 = "do not calculate lighting" flag albedoTarget = vec4(envColor, 0.0); vec3 normal = mat3(sceneData.view) * -direction; diff --git a/src/core/camera/free_camera.h b/src/core/camera/free_camera.h index 875fc3e7..1a1a1325 100644 --- a/src/core/camera/free_camera.h +++ b/src/core/camera/free_camera.h @@ -15,9 +15,8 @@ namespace will_engine */ class FreeCamera final : public Camera { public: - FreeCamera() = default; - - FreeCamera(float fov, float aspect, float nearPlane, float farPlane); + explicit FreeCamera(float fov = 1.308996939f, float aspect = RENDER_EXTENT_WIDTH / RENDER_EXTENT_HEIGHT, float nearPlane = 1000.0f, + float farPlane = 0.1f); ~FreeCamera() override = default; diff --git a/src/core/engine.cpp b/src/core/engine.cpp index ce862731..88eef39b 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -26,6 +26,7 @@ #include "src/renderer/environment/environment.h" #include "../renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.h" #include "src/renderer/debug/debug_renderer.h" +#include "src/renderer/pipelines/debug/debug_pipeline.h" #include "src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.h" #include "src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline_types.h" #include "src/renderer/pipelines/geometry/deferred_resolve/deferred_resolve_pipeline.h" @@ -130,6 +131,8 @@ void Engine::init() #if WILL_ENGINE_DEBUG debugRenderer = new debug_renderer::DebugRenderer(*resourceManager); debug_renderer::DebugRenderer::set(debugRenderer); + debugPipeline = new debug_pipeline::DebugPipeline(*resourceManager); + debugPipeline->setupDescriptorBuffer(finalImageBuffer.imageView); #endif startupProfiler.addEntry("Immediate, ResourceM, AssetM, Physics"); @@ -249,7 +252,7 @@ void Engine::initRenderer() const post_process_pipeline::PostProcessDescriptor postProcessDescriptor{ taaResolveTarget.imageView, - postProcessOutputBuffer.imageView, + finalImageBuffer.imageView, resourceManager->getDefaultSamplerLinear() }; postProcessPipeline->setupDescriptorBuffer(postProcessDescriptor); @@ -382,7 +385,7 @@ void Engine::updateGame(const float deltaTime) hierarchicalDeletionQueue.clear(); - constexpr glm::vec3 offset{-100,100,0}; + constexpr glm::vec3 offset{-100, 100, 0}; for (int32_t i{0}; i < 100; i++) { for (int32_t j{0}; j < 100; j++) { float z = glm::sin(Time::Get().getTime() - j * 0.5f) * 2.0; @@ -394,7 +397,7 @@ void Engine::updateGame(const float deltaTime) debug_renderer::DebugRenderer::drawLine({0, 0, 0}, {0, 100, 0}, {1, 0, 0}); - debug_renderer::DebugRenderer::drawTriangle({0,0,0}, {1,0,0}, {0,1,0}, {0,1,0}); + debug_renderer::DebugRenderer::drawTriangle({0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 1, 0}); } void Engine::updateRender(VkCommandBuffer cmd, const float deltaTime, const int32_t currentFrameOverlap, const int32_t previousFrameOverlap) const @@ -646,20 +649,6 @@ void Engine::render(float deltaTime) transparentPipeline->drawAccumulate(cmd, transparentDrawInfo); } -#if WILL_ENGINE_DEBUG - if (bDrawDebugRendering) { - debug_renderer::DebugRendererDrawInfo debugRendererDrawInfo{ - currentFrameOverlap, - albedoRenderTarget.imageView, - depthImage.imageView, - sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), - sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap - }; - - debugRenderer->draw(cmd, debugRendererDrawInfo); - } -#endif - vk_helpers::transitionImage(cmd, normalRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); vk_helpers::transitionImage(cmd, albedoRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, @@ -741,7 +730,7 @@ void Engine::render(float deltaTime) vk_helpers::transitionImage(cmd, taaResolveTarget.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, postProcessOutputBuffer.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::transitionImage(cmd, finalImageBuffer.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); const post_process_pipeline::PostProcessDrawInfo postProcessDrawInfo{ @@ -752,13 +741,39 @@ void Engine::render(float deltaTime) postProcessPipeline->draw(cmd, postProcessDrawInfo); - vk_helpers::transitionImage(cmd, postProcessOutputBuffer.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, +#if WILL_ENGINE_DEBUG + if (bDrawDebugRendering) { + vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, debugPipeline->getDebugTarget().image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, {0.0f, 0.0f, 0.0f, 0.0f}); + vk_helpers::transitionImage(cmd, depthImage.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, + VK_IMAGE_ASPECT_DEPTH_BIT); + + + + debug_renderer::DebugRendererDrawInfo debugRendererDrawInfo{ + currentFrameOverlap, + debugPipeline->getDebugTarget().imageView, + depthImage.imageView, + sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), + sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap + }; + + debugRenderer->draw(cmd, debugRendererDrawInfo); + + vk_helpers::transitionImage(cmd, debugPipeline->getDebugTarget().image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_IMAGE_ASPECT_COLOR_BIT); + + // Composite all draws in the debug image into the final image + debugPipeline->draw(cmd); + } +#endif + vk_helpers::transitionImage(cmd, finalImageBuffer.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::transitionImage(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::copyImageToImage(cmd, postProcessOutputBuffer.image, swapchainImages[swapchainImageIndex], RENDER_EXTENTS, swapchainExtent); + vk_helpers::copyImageToImage(cmd, finalImageBuffer.image, swapchainImages[swapchainImageIndex], RENDER_EXTENTS, swapchainExtent); - vk_helpers::transitionImage(cmd, postProcessOutputBuffer.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, + vk_helpers::transitionImage(cmd, finalImageBuffer.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); if (engine_constants::useImgui) { @@ -844,9 +859,10 @@ void Engine::cleanup() resourceManager->destroyBuffer(debugSceneDataBuffer); resourceManager->destroyDescriptorBuffer(sceneDataDescriptorBuffer); -#ifndef NDEBUG - delete imguiWrapper; -#endif + if (engine_constants::useImgui) { + delete imguiWrapper; + } + for (const FrameData& frame : frames) { vkDestroyCommandPool(context->device, frame._commandPool, nullptr); @@ -865,7 +881,7 @@ void Engine::cleanup() resourceManager->destroyImage(velocityRenderTarget); resourceManager->destroyImage(taaResolveTarget); resourceManager->destroyImage(historyBuffer); - resourceManager->destroyImage(postProcessOutputBuffer); + resourceManager->destroyImage(finalImageBuffer); for (Map* map : activeMaps) { map->destroy(); @@ -890,6 +906,7 @@ void Engine::cleanup() delete environmentMap; #if WILL_ENGINE_DEBUG delete debugRenderer; + delete debugPipeline; #endif delete physics; delete immediate; @@ -1099,25 +1116,26 @@ void Engine::createDrawResources() historyBuffer.imageFormat, historyBuffer.image, VK_IMAGE_ASPECT_COLOR_BIT); VK_CHECK(vkCreateImageView(context->device, &historyBufferImageViewInfo, nullptr, &historyBuffer.imageView)); } - // Post Process Resolve + // Final Image { - postProcessOutputBuffer.imageFormat = DRAW_FORMAT; + finalImageBuffer.imageFormat = DRAW_FORMAT; constexpr VkExtent3D imageExtent = {RENDER_EXTENTS.width, RENDER_EXTENTS.height, 1}; - postProcessOutputBuffer.imageExtent = imageExtent; + finalImageBuffer.imageExtent = imageExtent; VkImageUsageFlags usageFlags{}; + usageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; usageFlags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; usageFlags |= VK_IMAGE_USAGE_SAMPLED_BIT; - const VkImageCreateInfo imageCreateInfo = vk_helpers::imageCreateInfo(postProcessOutputBuffer.imageFormat, usageFlags, imageExtent); + const VkImageCreateInfo imageCreateInfo = vk_helpers::imageCreateInfo(finalImageBuffer.imageFormat, usageFlags, imageExtent); VmaAllocationCreateInfo imageAllocationInfo = {}; imageAllocationInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; imageAllocationInfo.requiredFlags = static_cast(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); - vmaCreateImage(context->allocator, &imageCreateInfo, &imageAllocationInfo, &postProcessOutputBuffer.image, - &postProcessOutputBuffer.allocation, nullptr); + vmaCreateImage(context->allocator, &imageCreateInfo, &imageAllocationInfo, &finalImageBuffer.image, + &finalImageBuffer.allocation, nullptr); - VkImageViewCreateInfo rview_info = vk_helpers::imageviewCreateInfo(postProcessOutputBuffer.imageFormat, postProcessOutputBuffer.image, + VkImageViewCreateInfo rview_info = vk_helpers::imageviewCreateInfo(finalImageBuffer.imageFormat, finalImageBuffer.image, VK_IMAGE_ASPECT_COLOR_BIT); - VK_CHECK(vkCreateImageView(context->device, &rview_info, nullptr, &postProcessOutputBuffer.imageView)); + VK_CHECK(vkCreateImageView(context->device, &rview_info, nullptr, &finalImageBuffer.imageView)); } } diff --git a/src/core/engine.h b/src/core/engine.h index 33860a75..09c52a47 100644 --- a/src/core/engine.h +++ b/src/core/engine.h @@ -5,7 +5,6 @@ #ifndef ENGINE_H #define ENGINE_H -#include #include #include @@ -39,6 +38,11 @@ class VulkanContext; namespace will_engine { +namespace debug_pipeline +{ + class DebugPipeline; +} + namespace ambient_occlusion { class GroundTruthAmbientOcclusionPipeline; @@ -163,7 +167,10 @@ class Engine ResourceManager* resourceManager{nullptr}; AssetManager* assetManager{nullptr}; physics::Physics* physics{nullptr}; +#if WILL_ENGINE_DEBUG debug_renderer::DebugRenderer* debugRenderer{nullptr}; + debug_pipeline::DebugPipeline* debugPipeline{nullptr}; +#endif environment::Environment* environmentMap{nullptr}; @@ -294,7 +301,7 @@ class Engine * A copy of the previous TAA Resolve Buffer */ AllocatedImage historyBuffer{}; - AllocatedImage postProcessOutputBuffer{}; + AllocatedImage finalImageBuffer{}; private: // Swapchain VkSwapchainKHR swapchain{}; diff --git a/src/physics/debug/jolt_debug_renderer.h b/src/physics/debug/jolt_debug_renderer.h index 6c7bbcff..b08e1430 100644 --- a/src/physics/debug/jolt_debug_renderer.h +++ b/src/physics/debug/jolt_debug_renderer.h @@ -12,8 +12,6 @@ #error This file should only be included when JPH_DEBUG_RENDERER is defined #endif // !JPH_DEBUG_RENDERER - - namespace will_engine::debug_renderer { class DebugRenderer; diff --git a/src/renderer/debug/debug_renderer.cpp b/src/renderer/debug/debug_renderer.cpp index 368dfc78..da869487 100644 --- a/src/renderer/debug/debug_renderer.cpp +++ b/src/renderer/debug/debug_renderer.cpp @@ -205,9 +205,8 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI } - const VkRenderingAttachmentInfo albedoAttachment = vk_helpers::attachmentInfo(drawInfo.albedoTarget, nullptr, + const VkRenderingAttachmentInfo imageAttachment = vk_helpers::attachmentInfo(drawInfo.imageTarget, nullptr, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); - const VkRenderingAttachmentInfo depthAttachment = vk_helpers::attachmentInfo(drawInfo.depthTarget, nullptr, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL); @@ -216,7 +215,7 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI renderInfo.pNext = nullptr; VkRenderingAttachmentInfo renderAttachments[1]; - renderAttachments[0] = albedoAttachment; + renderAttachments[0] = imageAttachment; renderInfo.renderArea = VkRect2D{VkOffset2D{0, 0}, RENDER_EXTENTS}; renderInfo.layerCount = 1; @@ -227,7 +226,7 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI vkCmdBeginRendering(cmd, &renderInfo); - vkCmdSetLineWidth(cmd, 2.0f); + vkCmdSetLineWidth(cmd, 1.0f); // Viewport VkViewport viewport = {}; @@ -281,6 +280,13 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI // Line Rendering if (!lineVertices.empty()) { vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, linePipeline); + + const std::array descriptorBufferBindingInfos{drawInfo.sceneDataBinding}; + constexpr std::array indices{}; + const std::array offsets{drawInfo.sceneDataOffset}; + vkCmdBindDescriptorBuffersEXT(cmd, 1, descriptorBufferBindingInfos.data()); + vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, normalPipelineLayout, 0, 1, indices.data(), offsets.data()); + AllocatedBuffer& currentLineVertexBuffer = lineVertexBuffers[drawInfo.currentFrameOverlap]; vkCmdBindVertexBuffers(cmd, 0, 1, ¤tLineVertexBuffer.buffer, &ZERO_DEVICE_SIZE); vkCmdDraw(cmd, lineVertices.size(), 1, 0, 0); @@ -288,6 +294,13 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI if (!triangleVertices.empty()) { vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, trianglePipeline); + + const std::array descriptorBufferBindingInfos{drawInfo.sceneDataBinding}; + constexpr std::array indices{}; + const std::array offsets{drawInfo.sceneDataOffset}; + vkCmdBindDescriptorBuffersEXT(cmd, 1, descriptorBufferBindingInfos.data()); + vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, normalPipelineLayout, 0, 1, indices.data(), offsets.data()); + AllocatedBuffer& currentTriangleVertexBuffer = triangleVertexBuffers[drawInfo.currentFrameOverlap]; vkCmdBindVertexBuffers(cmd, 0, 1, ¤tTriangleVertexBuffer.buffer, &ZERO_DEVICE_SIZE); vkCmdDraw(cmd, triangleVertices.size(), 1, 0, 0); @@ -337,7 +350,7 @@ void DebugRenderer::createPipeline() renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_LINE, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); - renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); + renderPipelineBuilder.enableDepthTest(false, VK_COMPARE_OP_GREATER_OR_EQUAL); renderPipelineBuilder.setupRenderer({ALBEDO_FORMAT}, DEPTH_FORMAT); renderPipelineBuilder.setupPipelineLayout(instancedPipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; @@ -376,7 +389,7 @@ void DebugRenderer::createPipeline() renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_LINE, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); - renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); + renderPipelineBuilder.enableDepthTest(false, VK_COMPARE_OP_GREATER_OR_EQUAL); renderPipelineBuilder.setupRenderer({ALBEDO_FORMAT}, DEPTH_FORMAT); renderPipelineBuilder.setupPipelineLayout(normalPipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; diff --git a/src/renderer/debug/debug_renderer_types.h b/src/renderer/debug/debug_renderer_types.h index 9a861140..218096f5 100644 --- a/src/renderer/debug/debug_renderer_types.h +++ b/src/renderer/debug/debug_renderer_types.h @@ -90,7 +90,7 @@ struct DebugRendererInstance struct DebugRendererDrawInfo { int32_t currentFrameOverlap{}; - VkImageView albedoTarget; + VkImageView imageTarget; VkImageView depthTarget; VkDescriptorBufferBindingInfoEXT sceneDataBinding{}; VkDeviceSize sceneDataOffset{0}; diff --git a/src/renderer/imgui_wrapper.cpp b/src/renderer/imgui_wrapper.cpp index d5ff07ca..c139e999 100644 --- a/src/renderer/imgui_wrapper.cpp +++ b/src/renderer/imgui_wrapper.cpp @@ -277,6 +277,11 @@ void ImguiWrapper::imguiInterface(Engine* engine) ImGui::Unindent(); } + if (ImGui::Button("Hard-Reset All Camera Settings")) { + delete engine->camera; + engine->camera = new FreeCamera(); + } + ImGui::EndTabItem(); } @@ -717,7 +722,7 @@ void ImguiWrapper::imguiInterface(Engine* engine) if (ImGui::Button("Save Post Process Resolve Target")) { if (file::getOrCreateDirectory(file::imagesSavePath)) { std::filesystem::path path = file::imagesSavePath / "postProcesResolve.png"; - vk_helpers::saveImageRGBA16SFLOAT(*engine->resourceManager, *engine->immediate, engine->postProcessOutputBuffer, + vk_helpers::saveImageRGBA16SFLOAT(*engine->resourceManager, *engine->immediate, engine->finalImageBuffer, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT, path.string().c_str()); } else { diff --git a/src/renderer/pipelines/debug/debug_pipeline.cpp b/src/renderer/pipelines/debug/debug_pipeline.cpp new file mode 100644 index 00000000..b8ef483b --- /dev/null +++ b/src/renderer/pipelines/debug/debug_pipeline.cpp @@ -0,0 +1,123 @@ +// +// Created by William on 2025-05-02. +// + +#include "debug_pipeline.h" + +#include "volk/volk.h" + +namespace will_engine::debug_pipeline +{ +DebugPipeline::DebugPipeline(ResourceManager& resourceManager) : resourceManager(resourceManager) +{ + DescriptorLayoutBuilder layoutBuilder; + layoutBuilder.addBinding(0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER); // Debug output (flipped image!) + layoutBuilder.addBinding(1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE); // Final Image + + descriptorSetLayout = resourceManager.createDescriptorSetLayout(layoutBuilder, VK_SHADER_STAGE_COMPUTE_BIT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT); + + VkPushConstantRange pushConstants{}; + pushConstants.offset = 0; + pushConstants.size = sizeof(DebugPushConstant); + pushConstants.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + + VkDescriptorSetLayout setLayouts[1]; + setLayouts[0] = descriptorSetLayout; + + VkPipelineLayoutCreateInfo layoutInfo{}; + layoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + layoutInfo.pNext = nullptr; + layoutInfo.pSetLayouts = setLayouts; + layoutInfo.setLayoutCount = 1; + layoutInfo.pPushConstantRanges = &pushConstants; + layoutInfo.pushConstantRangeCount = 1; + + pipelineLayout = resourceManager.createPipelineLayout(layoutInfo); + + createPipeline(); + + descriptorBuffer = resourceManager.createDescriptorBufferSampler(descriptorSetLayout, 1); + + // Debug Output (Gizmos, Debug Draws, etc. Output here before combined w/ final image. Goes around normal pass stuff. Expects inputs to be jittered because to test against depth buffer, fragments need to be jittered cause depth buffer is jittered) + constexpr VkExtent3D imageExtent = {RENDER_EXTENTS.width, RENDER_EXTENTS.height, 1}; + VkImageUsageFlags usageFlags{}; + usageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + usageFlags |= VK_IMAGE_USAGE_SAMPLED_BIT; + usageFlags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; + const VkImageCreateInfo imageCreateInfo = vk_helpers::imageCreateInfo(DRAW_FORMAT, usageFlags, imageExtent); + debugTarget = resourceManager.createImage(imageCreateInfo); +} + +DebugPipeline::~DebugPipeline() +{ + resourceManager.destroyPipeline(pipeline); + resourceManager.destroyPipelineLayout(pipelineLayout); + resourceManager.destroyDescriptorSetLayout(descriptorSetLayout); + resourceManager.destroyDescriptorBuffer(descriptorBuffer); + resourceManager.destroyImage(debugTarget); +} + +void DebugPipeline::setupDescriptorBuffer(VkImageView finalImageView) +{ + std::vector descriptors; + descriptors.reserve(2); + + VkDescriptorImageInfo inputImage{}; + inputImage.sampler = resourceManager.getDefaultSamplerNearest(); + inputImage.imageView = debugTarget.imageView; + inputImage.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + + VkDescriptorImageInfo outputImage{}; + outputImage.imageView = finalImageView; + outputImage.imageLayout = VK_IMAGE_LAYOUT_GENERAL; + + descriptors.push_back({VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, inputImage, false}); + descriptors.push_back({VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, outputImage, false}); + + resourceManager.setupDescriptorBufferSampler(descriptorBuffer, descriptors, 0); +} + +void DebugPipeline::draw(VkCommandBuffer cmd) const +{ + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline); + + DebugPushConstant push{}; + push.renderBounds = {RENDER_EXTENT_WIDTH, RENDER_EXTENT_HEIGHT}; + vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(DebugPushConstant), &push); + + const std::array bindingInfos{descriptorBuffer.getDescriptorBufferBindingInfo()}; + vkCmdBindDescriptorBuffersEXT(cmd, 1, bindingInfos.data()); + + constexpr std::array indices{}; + constexpr std::array offsets{}; + vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, indices.data(), offsets.data()); + + const auto x = static_cast(std::ceil(RENDER_EXTENT_WIDTH / 16.0f)); + const auto y = static_cast(std::ceil(RENDER_EXTENT_HEIGHT / 16.0f)); + vkCmdDispatch(cmd, x, y, 1); +} + +void DebugPipeline::createPipeline() +{ + resourceManager.destroyPipeline(pipeline); + VkShaderModule computeShader = resourceManager.createShaderModule("shaders/debug/debug_pipeline.comp"); + + VkPipelineShaderStageCreateInfo stageInfo{}; + stageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + stageInfo.pNext = nullptr; + stageInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT; + stageInfo.module = computeShader; + stageInfo.pName = "main"; + + VkComputePipelineCreateInfo pipelineInfo{}; + pipelineInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; + pipelineInfo.pNext = nullptr; + pipelineInfo.layout = pipelineLayout; + pipelineInfo.stage = stageInfo; + pipelineInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; + + pipeline = resourceManager.createComputePipeline(pipelineInfo); + resourceManager.destroyShaderModule(computeShader); +} +} diff --git a/src/renderer/pipelines/debug/debug_pipeline.h b/src/renderer/pipelines/debug/debug_pipeline.h new file mode 100644 index 00000000..11802ffc --- /dev/null +++ b/src/renderer/pipelines/debug/debug_pipeline.h @@ -0,0 +1,54 @@ +// +// Created by William on 2025-05-02. +// + +#ifndef DEBUG_PIPELINE_H +#define DEBUG_PIPELINE_H + + +#ifndef WILL_ENGINE_DEBUG + #error This file should only be included when JPH_DEBUG_RENDERER is defined +#endif // !WILL_ENGINE_DEBUG + +#include "src/renderer/resource_manager.h" + + +namespace will_engine::debug_pipeline +{ + +struct DebugPushConstant +{ + glm::vec2 renderBounds{RENDER_EXTENT_WIDTH, RENDER_EXTENT_HEIGHT}; +}; + +class DebugPipeline { +public: + explicit DebugPipeline(ResourceManager& resourceManager); + + ~DebugPipeline(); + + void setupDescriptorBuffer(VkImageView finalImageView); + + void draw(VkCommandBuffer cmd) const; + + void reloadShaders() { createPipeline(); } + + const AllocatedImage& getDebugTarget() const { return debugTarget; } + +private: + void createPipeline(); + +private: + ResourceManager& resourceManager; + + VkPipelineLayout pipelineLayout{VK_NULL_HANDLE}; + VkPipeline pipeline{VK_NULL_HANDLE}; + VkDescriptorSetLayout descriptorSetLayout{VK_NULL_HANDLE}; + DescriptorBufferSampler descriptorBuffer; + + AllocatedImage debugTarget{}; +}; + +} + +#endif //DEBUG_PIPELINE_H diff --git a/src/renderer/renderer_constants.h b/src/renderer/renderer_constants.h index 9b834a46..43f20232 100644 --- a/src/renderer/renderer_constants.h +++ b/src/renderer/renderer_constants.h @@ -11,8 +11,8 @@ constexpr int32_t FRAME_OVERLAP = 2; constexpr char ENGINE_NAME[] = "Will Engine"; constexpr bool USING_REVERSED_DEPTH_BUFFER = true; constexpr VkDeviceSize ZERO_DEVICE_SIZE = 0; -//constexpr VkExtent2D RENDER_EXTENTS{1920, 1080}; -constexpr VkExtent2D RENDER_EXTENTS{2560 , 1440}; +constexpr VkExtent2D RENDER_EXTENTS{1920, 1080}; +//constexpr VkExtent2D RENDER_EXTENTS{2560 , 1440}; //constexpr VkExtent2D RENDER_EXTENTS{3840, 2160}; constexpr float RENDER_EXTENT_WIDTH{RENDER_EXTENTS.width}; constexpr float RENDER_EXTENT_HEIGHT{RENDER_EXTENTS.height}; From 247f8992b34d09b17dca8d1d20dc0701102b9062 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Sat, 3 May 2025 18:09:59 +0700 Subject: [PATCH 14/24] Pack normals to allow use of UNORM formats. --- assets/settings.willengine | 16 ++++++++-------- .../ground_truth/gtao_main_pass.comp | 1 + shaders/debug/debug_renderer.vert | 2 -- shaders/debug/debug_renderer_instanced.vert | 1 - shaders/deferredMrt.frag | 3 +-- shaders/deferredResolve.comp | 3 +++ shaders/environment/environment.frag | 4 ++-- shaders/include/common.glsl | 16 ++++++++++++++++ shaders/terrain/terrain.frag | 4 ++-- src/renderer/renderer_constants.h | 8 ++++++-- src/renderer/resource_manager.cpp | 6 ++++++ 11 files changed, 45 insertions(+), 19 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index b0145d1b..1c35f90e 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - 40.22589874267578, - 152.3096160888672, - -0.24074575304985046 + -8.544395446777344, + 42.04850387573242, + 8.131829261779785 ], "rotation": [ - -0.04059086740016937, - 0.6134752631187439, - 0.031599532812833786, - 0.7880368828773499 + 0.15659655630588531, + 0.262852281332016, + 0.04327920451760292, + -0.9510590434074402 ], "fov": 1.3089969158172607, "aspectRatio": 1.7777777910232544, @@ -127,7 +127,7 @@ } }, "taaSettings": { - "enabled": false, + "enabled": true, "properties": { "blendValue": 0.10000000149011612 } diff --git a/shaders/ambient_occlusion/ground_truth/gtao_main_pass.comp b/shaders/ambient_occlusion/ground_truth/gtao_main_pass.comp index ad21dd10..a3746419 100644 --- a/shaders/ambient_occlusion/ground_truth/gtao_main_pass.comp +++ b/shaders/ambient_occlusion/ground_truth/gtao_main_pass.comp @@ -132,6 +132,7 @@ void main() { // Get view space normal by sampling normal buffer and converting from world to view (code not relevant) vec3 viewNormal = texture(normalBuffer, uv).rgb; + viewNormal = unpackNormal(viewNormal); if (pushConstants.debug == 2){ imageStore(debugImage, screenPos, vec4(viewNormal, 1.0f)); diff --git a/shaders/debug/debug_renderer.vert b/shaders/debug/debug_renderer.vert index a8187efa..7ea059ce 100644 --- a/shaders/debug/debug_renderer.vert +++ b/shaders/debug/debug_renderer.vert @@ -11,7 +11,5 @@ layout(location = 0) out vec3 outColor; void main() { gl_Position = sceneData.viewProj * vec4(inPosition, 1.0); - gl_Position.xy += gl_Position.w * sceneData.jitter.xy; outColor = inColor; - // todo: add jitter } \ No newline at end of file diff --git a/shaders/debug/debug_renderer_instanced.vert b/shaders/debug/debug_renderer_instanced.vert index 2f718f19..b898818c 100644 --- a/shaders/debug/debug_renderer_instanced.vert +++ b/shaders/debug/debug_renderer_instanced.vert @@ -21,6 +21,5 @@ layout(std140, set = 1, binding = 0) readonly buffer InstanceBuffer { void main() { Instance instance = instances.instances[gl_InstanceIndex]; gl_Position = sceneData.viewProj * instance.transform * vec4(inPosition, 1.0); - gl_Position.xy += gl_Position.w * sceneData.jitter.xy; outColor = instance.color; } \ No newline at end of file diff --git a/shaders/deferredMrt.frag b/shaders/deferredMrt.frag index 47eaca35..305c5148 100644 --- a/shaders/deferredMrt.frag +++ b/shaders/deferredMrt.frag @@ -73,8 +73,7 @@ void main() { roughness *= metalRoughSample.g; } - - normalTarget = vec4(normalize(inViewNormal), 0.0f); + normalTarget = vec4(packNormal(normalize(inViewNormal)), 0.0f); albedoTarget = vec4(albedo.xyz, 1.0f); pbrTarget = vec4(metallic, roughness, 0.0f, inHasTransparent); diff --git a/shaders/deferredResolve.comp b/shaders/deferredResolve.comp index 08fd8fee..1a743429 100644 --- a/shaders/deferredResolve.comp +++ b/shaders/deferredResolve.comp @@ -1,6 +1,7 @@ #version 460 #extension GL_EXT_nonuniform_qualifier: enable +#include "common.glsl" #include "scene.glsl" #include "pbr.glsl" #include "environment.glsl" @@ -86,6 +87,8 @@ void main() { } float depth = texture(depthBuffer, uv).r; vec3 viewNormal = texture(normalRenderTarget, uv).rgb; + viewNormal = unpackNormal(viewNormal); + vec4 pbrData = texture(pbrRenderTarget, uv); vec3 viewPosition = reconstructPosition(uv, depth); diff --git a/shaders/environment/environment.frag b/shaders/environment/environment.frag index e0d6618b..3f707d88 100644 --- a/shaders/environment/environment.frag +++ b/shaders/environment/environment.frag @@ -1,5 +1,6 @@ #version 450 +#include "common.glsl" #include "scene.glsl" layout (location = 0) in vec3 uv; @@ -24,8 +25,7 @@ void main() // 0 = "do not calculate lighting" flag albedoTarget = vec4(envColor, 0.0); - vec3 normal = mat3(sceneData.view) * -direction; - normalTarget = vec4(normal, 0.0f); + normalTarget = vec4(packNormal(mat3(sceneData.view) * -direction), 0.0f); pbrTarget = vec4(0.0f); vec2 currNdc = inCurrMvpPosition.xy / inCurrMvpPosition.w; diff --git a/shaders/include/common.glsl b/shaders/include/common.glsl index e3b65769..81363fb2 100644 --- a/shaders/include/common.glsl +++ b/shaders/include/common.glsl @@ -47,4 +47,20 @@ bool nearlyEqual(float a, float b, float epsilon) { return abs(a - b) <= epsilon; } +vec3 unpackNormal(vec3 packedNormal) { + #ifdef REMAP_NORMALS + return packedNormal * 2.0 - 1.0; + #else + return packedNormal; + #endif +} + +vec3 packNormal(vec3 normal) { + #ifdef REMAP_NORMALS + return normal * 0.5 + 0.5; + #else + return normal; + #endif +} + #endif // COMMON_GLSL \ No newline at end of file diff --git a/shaders/terrain/terrain.frag b/shaders/terrain/terrain.frag index 4f2dfd81..6cee5061 100644 --- a/shaders/terrain/terrain.frag +++ b/shaders/terrain/terrain.frag @@ -3,10 +3,10 @@ #extension GL_EXT_buffer_reference: require #extension GL_EXT_nonuniform_qualifier: enable +#include "common.glsl" #include "scene.glsl" #include "structure.glsl" - // world space layout (location = 0) in vec3 inPosition; layout (location = 1) in vec3 inNormal; @@ -41,7 +41,7 @@ float smoothBlend(float value, float threshold, float range) { } void main() { - normalTarget = vec4(mat3(sceneData.view) * normalize(inNormal), 0.0f); + normalTarget = vec4(packNormal(mat3(sceneData.view) * normalize(inNormal)), 0.0f);; float slope = 1.0 - abs(dot(normalize(inNormal), vec3(0.0, 1.0, 0.0))); float height = inPosition.y; diff --git a/src/renderer/renderer_constants.h b/src/renderer/renderer_constants.h index 43f20232..711b08b0 100644 --- a/src/renderer/renderer_constants.h +++ b/src/renderer/renderer_constants.h @@ -5,6 +5,7 @@ #ifndef RENDERER_CONSTANTS_H #define RENDERER_CONSTANTS_H #include + namespace will_engine { constexpr int32_t FRAME_OVERLAP = 2; @@ -19,8 +20,11 @@ constexpr float RENDER_EXTENT_HEIGHT{RENDER_EXTENTS.height}; constexpr VkFormat DRAW_FORMAT{VK_FORMAT_R16G16B16A16_SFLOAT}; constexpr VkFormat DEPTH_FORMAT{VK_FORMAT_D32_SFLOAT}; constexpr VkFormat VELOCITY_FORMAT{VK_FORMAT_R16G16_SFLOAT}; -constexpr VkFormat NORMAL_FORMAT{VK_FORMAT_R16G16B16A16_SNORM}; -// Be careful, environment map is in HDR format, so non-float formats wont work + +constexpr bool NORMAL_REMAP{true}; +constexpr VkFormat NORMAL_FORMAT = NORMAL_REMAP ? VK_FORMAT_A2R10G10B10_UNORM_PACK32 : VK_FORMAT_R16G16B16A16_SNORM; + +// Be careful, environment map is in HDR format, so non-float formats for albedo won't work constexpr VkFormat ALBEDO_FORMAT{VK_FORMAT_R16G16B16A16_SFLOAT}; constexpr VkFormat PBR_FORMAT{VK_FORMAT_R8G8B8A8_UNORM}; } diff --git a/src/renderer/resource_manager.cpp b/src/renderer/resource_manager.cpp index 8c3e7aff..dd74bd47 100644 --- a/src/renderer/resource_manager.cpp +++ b/src/renderer/resource_manager.cpp @@ -668,6 +668,12 @@ VkShaderModule will_engine::ResourceManager::createShaderModule(const std::files std::vector include_paths = {"shaders/include"}; options.SetIncluder(std::make_unique(include_paths)); + + // Macros + if (NORMAL_REMAP) { + options.AddMacroDefinition("REMAP_NORMALS"); + } + auto result = compiler.CompileGlslToSpv(source, kind, "shader", options); if (result.GetCompilationStatus() != shaderc_compilation_status_success) { From f3a254c35d89327131682e520a0018879c0db7cf Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Sun, 4 May 2025 15:56:44 +0700 Subject: [PATCH 15/24] Jitter and Unjitter debug draws for consistency with depth buffer. Mesh highlight debug outline WIP. --- CMakeLists.txt | 12 ++-- assets/settings.willengine | 14 ++-- ...bug_pipeline.comp => debug_composite.comp} | 11 ++- shaders/debug/debug_highlight_renderer.frag | 4 ++ shaders/debug/debug_highlight_renderer.vert | 15 ++++ shaders/debug/debug_renderer.vert | 1 + shaders/debug/debug_renderer_instanced.vert | 1 + src/core/engine.cpp | 22 +++--- src/core/engine.h | 4 +- .../components/mesh_renderer_component.cpp | 30 +++++++- .../components/mesh_renderer_component.h | 3 + src/physics/debug/jolt_debug_renderer.cpp | 2 +- .../assets/render_object/render_object.cpp | 18 +++-- .../assets/render_object/render_object.h | 8 ++- .../assets/render_object/render_reference.h | 11 +++ ...eline.cpp => debug_composite_pipeline.cpp} | 36 +++++----- ..._pipeline.h => debug_composite_pipeline.h} | 16 +++-- .../debug/debug_highlight_pipeline.cpp | 72 +++++++++++++++++++ .../debug/debug_highlight_pipeline.h | 45 ++++++++++++ .../{ => pipelines}/debug/debug_renderer.cpp | 1 + .../{ => pipelines}/debug/debug_renderer.h | 0 .../debug/debug_renderer_types.h | 0 .../deferred_mrt/deferred_mrt_pipeline.cpp | 4 +- .../transparent_pipeline.cpp | 13 +--- src/renderer/vk_pipelines.cpp | 11 ++- src/renderer/vk_pipelines.h | 2 +- 26 files changed, 281 insertions(+), 75 deletions(-) rename shaders/debug/{debug_pipeline.comp => debug_composite.comp} (70%) create mode 100644 shaders/debug/debug_highlight_renderer.frag create mode 100644 shaders/debug/debug_highlight_renderer.vert rename src/renderer/pipelines/debug/{debug_pipeline.cpp => debug_composite_pipeline.cpp} (79%) rename src/renderer/pipelines/debug/{debug_pipeline.h => debug_composite_pipeline.h} (67%) create mode 100644 src/renderer/pipelines/debug/debug_highlight_pipeline.cpp create mode 100644 src/renderer/pipelines/debug/debug_highlight_pipeline.h rename src/renderer/{ => pipelines}/debug/debug_renderer.cpp (99%) rename src/renderer/{ => pipelines}/debug/debug_renderer.h (100%) rename src/renderer/{ => pipelines}/debug/debug_renderer_types.h (100%) diff --git a/CMakeLists.txt b/CMakeLists.txt index b4af05fd..2b24adac 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -264,11 +264,13 @@ set(TEMP_SOURCES src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline_types.h src/renderer/pipelines/basic/basic_compute/basic_compute_pipeline_types.h src/renderer/pipelines/visibility_pass/visibility_pass_pipeline_types.h - src/renderer/debug/debug_renderer.cpp - src/renderer/debug/debug_renderer.h - src/renderer/debug/debug_renderer_types.h - src/renderer/pipelines/debug/debug_pipeline.cpp - src/renderer/pipelines/debug/debug_pipeline.h + src/renderer/pipelines/debug/debug_renderer.cpp + src/renderer/pipelines/debug/debug_renderer.h + src/renderer/pipelines/debug/debug_renderer_types.h + src/renderer/pipelines/debug/debug_composite_pipeline.cpp + src/renderer/pipelines/debug/debug_composite_pipeline.h + src/renderer/pipelines/debug/debug_highlight_pipeline.cpp + src/renderer/pipelines/debug/debug_highlight_pipeline.h ) diff --git a/assets/settings.willengine b/assets/settings.willengine index 1c35f90e..0dc93afe 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -8.544395446777344, - 42.04850387573242, - 8.131829261779785 + -48.649864196777344, + 40.66029739379883, + 0.20613041520118713 ], "rotation": [ - 0.15659655630588531, - 0.262852281332016, - 0.04327920451760292, - -0.9510590434074402 + 0.045760832726955414, + -0.6482749581336975, + -0.039084888994693756, + -0.7590243220329285 ], "fov": 1.3089969158172607, "aspectRatio": 1.7777777910232544, diff --git a/shaders/debug/debug_pipeline.comp b/shaders/debug/debug_composite.comp similarity index 70% rename from shaders/debug/debug_pipeline.comp rename to shaders/debug/debug_composite.comp index 136d6fc2..ac9e5beb 100644 --- a/shaders/debug/debug_pipeline.comp +++ b/shaders/debug/debug_composite.comp @@ -1,9 +1,13 @@ #version 460 +#include "scene.glsl" + layout (local_size_x = 16, local_size_y = 16) in; -layout(binding = 0) uniform sampler2D debugImage; -layout(binding = 1, rgba16) uniform image2D finalImage; +// layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl + +layout(set = 1, binding = 0) uniform sampler2D debugImage; +layout(set = 1, binding = 1, rgba16) uniform image2D finalImage; layout (push_constant) uniform PushConstants { vec2 bounds; @@ -18,9 +22,10 @@ void main() { vec2 uv = (vec2(pixelCoord) + 0.5) / push.bounds; vec4 mainColor = imageLoad(finalImage, pixelCoord); - // todo: debugUv also needs to be unjittered vec2 debugUv = uv; debugUv.y = 1 - debugUv.y; + debugUv += sceneData.jitter.xy / 2.0f; + vec4 debugColor = texture(debugImage, debugUv); diff --git a/shaders/debug/debug_highlight_renderer.frag b/shaders/debug/debug_highlight_renderer.frag new file mode 100644 index 00000000..e45ea7e1 --- /dev/null +++ b/shaders/debug/debug_highlight_renderer.frag @@ -0,0 +1,4 @@ +#version 460 + +void main() { +} diff --git a/shaders/debug/debug_highlight_renderer.vert b/shaders/debug/debug_highlight_renderer.vert new file mode 100644 index 00000000..03a66282 --- /dev/null +++ b/shaders/debug/debug_highlight_renderer.vert @@ -0,0 +1,15 @@ +#version 460 + +#include "scene.glsl" + +layout(location = 0) in vec3 inPosition; + +// layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl + +layout (push_constant) uniform PushConstants { + mat4 modelMatrix; +} push; + +void main() { + gl_Position = sceneData.viewProj * modelMatrix * vec4(inPosition, 1.0); +} \ No newline at end of file diff --git a/shaders/debug/debug_renderer.vert b/shaders/debug/debug_renderer.vert index 7ea059ce..fcec9ef0 100644 --- a/shaders/debug/debug_renderer.vert +++ b/shaders/debug/debug_renderer.vert @@ -11,5 +11,6 @@ layout(location = 0) out vec3 outColor; void main() { gl_Position = sceneData.viewProj * vec4(inPosition, 1.0); + gl_Position.xy += gl_Position.w * sceneData.jitter.xy; outColor = inColor; } \ No newline at end of file diff --git a/shaders/debug/debug_renderer_instanced.vert b/shaders/debug/debug_renderer_instanced.vert index b898818c..2f718f19 100644 --- a/shaders/debug/debug_renderer_instanced.vert +++ b/shaders/debug/debug_renderer_instanced.vert @@ -21,5 +21,6 @@ layout(std140, set = 1, binding = 0) readonly buffer InstanceBuffer { void main() { Instance instance = instances.instances[gl_InstanceIndex]; gl_Position = sceneData.viewProj * instance.transform * vec4(inPosition, 1.0); + gl_Position.xy += gl_Position.w * sceneData.jitter.xy; outColor = instance.color; } \ No newline at end of file diff --git a/src/core/engine.cpp b/src/core/engine.cpp index 88eef39b..0dda13c3 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -25,8 +25,8 @@ #include "src/renderer/descriptor_buffer/descriptor_buffer_uniform.h" #include "src/renderer/environment/environment.h" #include "../renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.h" -#include "src/renderer/debug/debug_renderer.h" -#include "src/renderer/pipelines/debug/debug_pipeline.h" +#include "../renderer/pipelines/debug/debug_renderer.h" +#include "src/renderer/pipelines/debug/debug_composite_pipeline.h" #include "src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.h" #include "src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline_types.h" #include "src/renderer/pipelines/geometry/deferred_resolve/deferred_resolve_pipeline.h" @@ -131,7 +131,7 @@ void Engine::init() #if WILL_ENGINE_DEBUG debugRenderer = new debug_renderer::DebugRenderer(*resourceManager); debug_renderer::DebugRenderer::set(debugRenderer); - debugPipeline = new debug_pipeline::DebugPipeline(*resourceManager); + debugPipeline = new debug_pipeline::DebugCompositePipeline(*resourceManager); debugPipeline->setupDescriptorBuffer(finalImageBuffer.imageView); #endif @@ -743,12 +743,12 @@ void Engine::render(float deltaTime) #if WILL_ENGINE_DEBUG if (bDrawDebugRendering) { - vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, debugPipeline->getDebugTarget().image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, {0.0f, 0.0f, 0.0f, 0.0f}); + vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, debugPipeline->getDebugTarget().image, VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, {0.0f, 0.0f, 0.0f, 0.0f}); vk_helpers::transitionImage(cmd, depthImage.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT); - debug_renderer::DebugRendererDrawInfo debugRendererDrawInfo{ currentFrameOverlap, debugPipeline->getDebugTarget().imageView, @@ -759,11 +759,17 @@ void Engine::render(float deltaTime) debugRenderer->draw(cmd, debugRendererDrawInfo); - vk_helpers::transitionImage(cmd, debugPipeline->getDebugTarget().image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::transitionImage(cmd, debugPipeline->getDebugTarget().image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_IMAGE_ASPECT_COLOR_BIT); + + debug_pipeline::DebugCompositePipelineDrawInfo drawInfo{ + sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), + sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap + }; // Composite all draws in the debug image into the final image - debugPipeline->draw(cmd); + debugPipeline->draw(cmd, drawInfo); } #endif vk_helpers::transitionImage(cmd, finalImageBuffer.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, diff --git a/src/core/engine.h b/src/core/engine.h index 09c52a47..e2e0048c 100644 --- a/src/core/engine.h +++ b/src/core/engine.h @@ -40,7 +40,7 @@ namespace will_engine { namespace debug_pipeline { - class DebugPipeline; + class DebugCompositePipeline; } namespace ambient_occlusion @@ -169,7 +169,7 @@ class Engine physics::Physics* physics{nullptr}; #if WILL_ENGINE_DEBUG debug_renderer::DebugRenderer* debugRenderer{nullptr}; - debug_pipeline::DebugPipeline* debugPipeline{nullptr}; + debug_pipeline::DebugCompositePipeline* debugPipeline{nullptr}; #endif environment::Environment* environmentMap{nullptr}; diff --git a/src/core/game_object/components/mesh_renderer_component.cpp b/src/core/game_object/components/mesh_renderer_component.cpp index 997a3dde..68d0c951 100644 --- a/src/core/game_object/components/mesh_renderer_component.cpp +++ b/src/core/game_object/components/mesh_renderer_component.cpp @@ -41,6 +41,33 @@ void MeshRendererComponent::beginDestroy() releaseMesh(); } +void MeshRendererComponent::drawHighlight() +{ + if (!pRenderReference) { + return; + } + + std::optional> meshData = pRenderReference->getMeshData(meshIndex); + if (!meshData.has_value()) { return; } + + // for (const Primitive& primitive : meshData.value().get().primitives) { + // primitive.indexCount; + // uint32_t instanceCount = 1; + // primitive.firstIndex; + // primitive.vertexOffset; + // uint32_t firstInstance = 0; + // + // glm::mat4 pushModelMatrix = getModelMatrix(); + // + // // bind vertex and instance buffer from pRenderReference + // vkCmdBindVertexBuffers(cmd, 0, 1, &pRenderReference->getPositionVertexBuffer().buffer, &ZERO_DEVICE_SIZE); + // vkCmdBindIndexBuffer(cmd, pRenderReference->getIndexBuffer().buffer, 0, VK_INDEX_TYPE_UINT32); + // + // // Draw this mesh w/ vkCmdDrawIndexed w/ model matrix passed through push + // vkCmdDrawIndexed(cmd, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + // } +} + void MeshRendererComponent::serialize(ordered_json& j) { Component::serialize(j); @@ -145,7 +172,8 @@ void MeshRendererComponent::setOwner(IComponentContainer* owner) transformableOwner = dynamic_cast(owner); if (!transformableOwner) { - fmt::print("Attempted to attach a mesh renderer to an IComponentContainer that does not implement ITransformable. Model matrix will always be identity.\n"); + fmt::print( + "Attempted to attach a mesh renderer to an IComponentContainer that does not implement ITransformable. Model matrix will always be identity.\n"); } } } // namespace will_engine::components diff --git a/src/core/game_object/components/mesh_renderer_component.h b/src/core/game_object/components/mesh_renderer_component.h index c49305c2..a3876cd7 100644 --- a/src/core/game_object/components/mesh_renderer_component.h +++ b/src/core/game_object/components/mesh_renderer_component.h @@ -55,6 +55,9 @@ class MeshRendererComponent : public Component, public IRenderable void beginDestroy() override; +public: + void drawHighlight(); + public: // Serialization void serialize(ordered_json& j) override; diff --git a/src/physics/debug/jolt_debug_renderer.cpp b/src/physics/debug/jolt_debug_renderer.cpp index 321004c2..bcd871bb 100644 --- a/src/physics/debug/jolt_debug_renderer.cpp +++ b/src/physics/debug/jolt_debug_renderer.cpp @@ -7,7 +7,7 @@ #include "jolt_debug_renderer.h" #include "src/physics/physics_utils.h" -#include "src/renderer/debug/debug_renderer.h" +#include "../../renderer/pipelines/debug/debug_renderer.h" will_engine::physics::JoltDebugRenderer::JoltDebugRenderer() diff --git a/src/renderer/assets/render_object/render_object.cpp b/src/renderer/assets/render_object/render_object.cpp index 60a5d79f..3db46191 100644 --- a/src/renderer/assets/render_object/render_object.cpp +++ b/src/renderer/assets/render_object/render_object.cpp @@ -102,11 +102,10 @@ bool RenderObject::updateBuffers(VkCommandBuffer cmd, const int32_t currentFrame *pPrimitiveData = pair.second; } - // vk_helpers::synchronizeUniform(cmd, currentPrimitiveBuffer, VK_PIPELINE_STAGE_2_HOST_BIT - // , VK_ACCESS_2_HOST_WRITE_BIT - // , VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | - // VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT - // , VK_ACCESS_2_UNIFORM_READ_BIT); + vk_helpers::synchronizeUniform(cmd, currentPrimitiveBuffer, VK_PIPELINE_STAGE_2_HOST_BIT + , VK_ACCESS_2_HOST_WRITE_BIT + , VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT + , VK_ACCESS_2_UNIFORM_READ_BIT); } AllocatedBuffer& currentInstanceBuffer = modelMatrixBuffers[currentFrameOverlap]; @@ -336,8 +335,15 @@ bool RenderObject::releaseInstanceIndex(IRenderable* renderable) return true; } +std::optional > RenderObject::getMeshData(const int32_t meshIndex) +{ + if (meshIndex < 0 || meshIndex >= meshes.size()) { return std::nullopt; } + return meshes[meshIndex]; +} + bool RenderObject::parseGltf(const std::filesystem::path& gltfFilepath, std::vector& materials, - std::vector& vertexPositions, std::vector& vertexProperties, std::vector& indices) + std::vector& vertexPositions, std::vector& vertexProperties, + std::vector& indices) { auto start = std::chrono::system_clock::now(); diff --git a/src/renderer/assets/render_object/render_object.h b/src/renderer/assets/render_object/render_object.h index 9d61df34..0d679430 100644 --- a/src/renderer/assets/render_object/render_object.h +++ b/src/renderer/assets/render_object/render_object.h @@ -99,6 +99,8 @@ class RenderObject final : public IRenderReference bool releaseInstanceIndex(IRenderable* renderable) override; + std::optional> getMeshData(int32_t meshIndex) override;; + private: // IRenderReference /** * Hash of the file path @@ -115,9 +117,9 @@ class RenderObject final : public IRenderReference [[nodiscard]] const DescriptorBufferUniform& getAddressesDescriptorBuffer() const { return addressesDescriptorBuffer; } [[nodiscard]] const DescriptorBufferSampler& getTextureDescriptorBuffer() const { return textureDescriptorBuffer; } [[nodiscard]] const DescriptorBufferUniform& getFrustumCullingAddressesDescriptorBuffer() { return frustumCullingDescriptorBuffer; } - [[nodiscard]] const AllocatedBuffer& getPositionVertexBuffer() const { return vertexPositionBuffer; } - [[nodiscard]] const AllocatedBuffer& getPropertyVertexBuffer() const { return vertexPropertyBuffer; } - [[nodiscard]] const AllocatedBuffer& getIndexBuffer() const { return indexBuffer; } + [[nodiscard]] const AllocatedBuffer& getPositionVertexBuffer() const override { return vertexPositionBuffer; } + [[nodiscard]] const AllocatedBuffer& getPropertyVertexBuffer() const override { return vertexPropertyBuffer; } + [[nodiscard]] const AllocatedBuffer& getIndexBuffer() const override { return indexBuffer; } [[nodiscard]] const AllocatedBuffer& getOpaqueIndirectBuffer(const int32_t currentFrameOverlap) const { diff --git a/src/renderer/assets/render_object/render_reference.h b/src/renderer/assets/render_object/render_reference.h index d5268533..294c5050 100644 --- a/src/renderer/assets/render_object/render_reference.h +++ b/src/renderer/assets/render_object/render_reference.h @@ -7,6 +7,9 @@ #include +#include "src/renderer/vk_types.h" +#include "render_object_types.h" + namespace will_engine { class IRenderable; @@ -26,6 +29,14 @@ class IRenderReference [[nodiscard]] virtual uint32_t getId() const = 0; virtual bool releaseInstanceIndex(IRenderable* renderable) = 0; + + virtual std::optional> getMeshData(int32_t meshIndex) = 0; + + virtual const AllocatedBuffer& getPositionVertexBuffer() const = 0; + + virtual const AllocatedBuffer& getPropertyVertexBuffer() const = 0; + + virtual const AllocatedBuffer& getIndexBuffer() const = 0; }; } diff --git a/src/renderer/pipelines/debug/debug_pipeline.cpp b/src/renderer/pipelines/debug/debug_composite_pipeline.cpp similarity index 79% rename from src/renderer/pipelines/debug/debug_pipeline.cpp rename to src/renderer/pipelines/debug/debug_composite_pipeline.cpp index b8ef483b..86a67c46 100644 --- a/src/renderer/pipelines/debug/debug_pipeline.cpp +++ b/src/renderer/pipelines/debug/debug_composite_pipeline.cpp @@ -2,13 +2,13 @@ // Created by William on 2025-05-02. // -#include "debug_pipeline.h" +#include "debug_composite_pipeline.h" #include "volk/volk.h" namespace will_engine::debug_pipeline { -DebugPipeline::DebugPipeline(ResourceManager& resourceManager) : resourceManager(resourceManager) +DebugCompositePipeline::DebugCompositePipeline(ResourceManager& resourceManager) : resourceManager(resourceManager) { DescriptorLayoutBuilder layoutBuilder; layoutBuilder.addBinding(0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER); // Debug output (flipped image!) @@ -22,14 +22,15 @@ DebugPipeline::DebugPipeline(ResourceManager& resourceManager) : resourceManager pushConstants.size = sizeof(DebugPushConstant); pushConstants.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; - VkDescriptorSetLayout setLayouts[1]; - setLayouts[0] = descriptorSetLayout; + std::array setLayouts; + setLayouts[0] = resourceManager.getSceneDataLayout(); + setLayouts[1] = descriptorSetLayout; VkPipelineLayoutCreateInfo layoutInfo{}; layoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; layoutInfo.pNext = nullptr; - layoutInfo.pSetLayouts = setLayouts; - layoutInfo.setLayoutCount = 1; + layoutInfo.pSetLayouts = setLayouts.data(); + layoutInfo.setLayoutCount = 2; layoutInfo.pPushConstantRanges = &pushConstants; layoutInfo.pushConstantRangeCount = 1; @@ -49,7 +50,7 @@ DebugPipeline::DebugPipeline(ResourceManager& resourceManager) : resourceManager debugTarget = resourceManager.createImage(imageCreateInfo); } -DebugPipeline::~DebugPipeline() +DebugCompositePipeline::~DebugCompositePipeline() { resourceManager.destroyPipeline(pipeline); resourceManager.destroyPipelineLayout(pipelineLayout); @@ -58,7 +59,7 @@ DebugPipeline::~DebugPipeline() resourceManager.destroyImage(debugTarget); } -void DebugPipeline::setupDescriptorBuffer(VkImageView finalImageView) +void DebugCompositePipeline::setupDescriptorBuffer(VkImageView finalImageView) { std::vector descriptors; descriptors.reserve(2); @@ -78,7 +79,7 @@ void DebugPipeline::setupDescriptorBuffer(VkImageView finalImageView) resourceManager.setupDescriptorBufferSampler(descriptorBuffer, descriptors, 0); } -void DebugPipeline::draw(VkCommandBuffer cmd) const +void DebugCompositePipeline::draw(VkCommandBuffer cmd, DebugCompositePipelineDrawInfo drawInfo) const { vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline); @@ -86,22 +87,25 @@ void DebugPipeline::draw(VkCommandBuffer cmd) const push.renderBounds = {RENDER_EXTENT_WIDTH, RENDER_EXTENT_HEIGHT}; vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(DebugPushConstant), &push); - const std::array bindingInfos{descriptorBuffer.getDescriptorBufferBindingInfo()}; - vkCmdBindDescriptorBuffersEXT(cmd, 1, bindingInfos.data()); + const std::array bindingInfos{ + drawInfo.sceneDataBinding, + descriptorBuffer.getDescriptorBufferBindingInfo() + }; + vkCmdBindDescriptorBuffersEXT(cmd, 2, bindingInfos.data()); - constexpr std::array indices{}; - constexpr std::array offsets{}; - vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, indices.data(), offsets.data()); + constexpr std::array indices{0, 1}; + const std::array offsets{drawInfo.sceneDataOffset, 0}; + vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 2, indices.data(), offsets.data()); const auto x = static_cast(std::ceil(RENDER_EXTENT_WIDTH / 16.0f)); const auto y = static_cast(std::ceil(RENDER_EXTENT_HEIGHT / 16.0f)); vkCmdDispatch(cmd, x, y, 1); } -void DebugPipeline::createPipeline() +void DebugCompositePipeline::createPipeline() { resourceManager.destroyPipeline(pipeline); - VkShaderModule computeShader = resourceManager.createShaderModule("shaders/debug/debug_pipeline.comp"); + VkShaderModule computeShader = resourceManager.createShaderModule("shaders/debug/debug_composite.comp"); VkPipelineShaderStageCreateInfo stageInfo{}; stageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; diff --git a/src/renderer/pipelines/debug/debug_pipeline.h b/src/renderer/pipelines/debug/debug_composite_pipeline.h similarity index 67% rename from src/renderer/pipelines/debug/debug_pipeline.h rename to src/renderer/pipelines/debug/debug_composite_pipeline.h index 11802ffc..f9d6449c 100644 --- a/src/renderer/pipelines/debug/debug_pipeline.h +++ b/src/renderer/pipelines/debug/debug_composite_pipeline.h @@ -7,7 +7,7 @@ #ifndef WILL_ENGINE_DEBUG - #error This file should only be included when JPH_DEBUG_RENDERER is defined + #error This file should only be included when WILL_ENGINE_DEBUG is defined #endif // !WILL_ENGINE_DEBUG #include "src/renderer/resource_manager.h" @@ -21,15 +21,21 @@ struct DebugPushConstant glm::vec2 renderBounds{RENDER_EXTENT_WIDTH, RENDER_EXTENT_HEIGHT}; }; -class DebugPipeline { +struct DebugCompositePipelineDrawInfo +{ + VkDescriptorBufferBindingInfoEXT sceneDataBinding{}; + VkDeviceSize sceneDataOffset{0}; +}; + +class DebugCompositePipeline { public: - explicit DebugPipeline(ResourceManager& resourceManager); + explicit DebugCompositePipeline(ResourceManager& resourceManager); - ~DebugPipeline(); + ~DebugCompositePipeline(); void setupDescriptorBuffer(VkImageView finalImageView); - void draw(VkCommandBuffer cmd) const; + void draw(VkCommandBuffer cmd, DebugCompositePipelineDrawInfo drawInfo) const; void reloadShaders() { createPipeline(); } diff --git a/src/renderer/pipelines/debug/debug_highlight_pipeline.cpp b/src/renderer/pipelines/debug/debug_highlight_pipeline.cpp new file mode 100644 index 00000000..02c5c391 --- /dev/null +++ b/src/renderer/pipelines/debug/debug_highlight_pipeline.cpp @@ -0,0 +1,72 @@ +// +// Created by William on 2025-05-04. +// + +#include "debug_highlight_pipeline.h" + +#include "src/renderer/assets/render_object/render_object_types.h" + + +namespace will_engine::debug_highlight_pipeline +{ +DebugHighlightPipeline::DebugHighlightPipeline(ResourceManager& resourceManager) : resourceManager(resourceManager) +{ + std::array descriptorLayout; + descriptorLayout[0] = resourceManager.getSceneDataLayout(); + + VkPushConstantRange pushConstants{}; + pushConstants.offset = 0; + pushConstants.size = sizeof(DebugHighlightDrawPushConstant); + pushConstants.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + + VkPipelineLayoutCreateInfo layoutInfo = vk_helpers::pipelineLayoutCreateInfo(); + layoutInfo.pNext = nullptr; + layoutInfo.pSetLayouts = descriptorLayout.data(); + layoutInfo.setLayoutCount = 1; + layoutInfo.pPushConstantRanges = &pushConstants; + layoutInfo.pushConstantRangeCount = 1; + + pipelineLayout = resourceManager.createPipelineLayout(layoutInfo); + + //debugHighlightStencil = +} + +DebugHighlightPipeline::~DebugHighlightPipeline() {} + +void DebugHighlightPipeline::draw(VkCommandBuffer cmd) const +{} + +void DebugHighlightPipeline::createPipeline() +{ + VkShaderModule vertShader = resourceManager.createShaderModule("shaders/debug/debug_highlight_renderer.vert"); + VkShaderModule fragShader = resourceManager.createShaderModule("shaders/debug/debug_highlight_renderer.frag"); + + PipelineBuilder renderPipelineBuilder; + VkVertexInputBindingDescription vertexBinding{}; + vertexBinding.binding = 0; + vertexBinding.stride = sizeof(VertexPosition); + vertexBinding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + + std::array vertexAttributes; + vertexAttributes[0].binding = 0; + vertexAttributes[0].location = 0; + vertexAttributes[0].format = VK_FORMAT_R32G32B32_SFLOAT; + vertexAttributes[0].offset = offsetof(VertexPosition, position); + + renderPipelineBuilder.setupVertexInput(&vertexBinding, 1, vertexAttributes.data(), 1); + + renderPipelineBuilder.setShaders(vertShader, fragShader); + renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_LINE_LIST); + renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); + renderPipelineBuilder.disableMultisampling(); + renderPipelineBuilder.disableBlending(); + renderPipelineBuilder.disableDepthTest(); + renderPipelineBuilder.setupRenderer({}, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED); + renderPipelineBuilder.setupPipelineLayout(pipelineLayout); + const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; + pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); + + resourceManager.destroyShaderModule(vertShader); + resourceManager.destroyShaderModule(fragShader); +} +} diff --git a/src/renderer/pipelines/debug/debug_highlight_pipeline.h b/src/renderer/pipelines/debug/debug_highlight_pipeline.h new file mode 100644 index 00000000..8e8e4e85 --- /dev/null +++ b/src/renderer/pipelines/debug/debug_highlight_pipeline.h @@ -0,0 +1,45 @@ +// +// Created by William on 2025-05-04. +// + +#ifndef DEBUG_HIGHLIGHT_PIPELINE_H +#define DEBUG_HIGHLIGHT_PIPELINE_H + +#include + +#include "src/renderer/resource_manager.h" + +namespace will_engine::debug_highlight_pipeline +{ +struct DebugHighlightDrawPushConstant +{ + glm::vec4 modelMatrix{1.0f}; +}; + +class DebugHighlightPipeline { + explicit DebugHighlightPipeline(ResourceManager& resourceManager); + + ~DebugHighlightPipeline(); + + void draw(VkCommandBuffer cmd) const; + + void reloadShaders() { createPipeline(); } + +private: + void createPipeline(); + +private: + ResourceManager& resourceManager; + + VkPipelineLayout pipelineLayout{VK_NULL_HANDLE}; + VkPipeline pipeline{VK_NULL_HANDLE}; + + AllocatedImage debugHighlightStencil{}; +}; +} + + + + + +#endif //DEBUG_HIGHLIGHT_PIPELINE_H diff --git a/src/renderer/debug/debug_renderer.cpp b/src/renderer/pipelines/debug/debug_renderer.cpp similarity index 99% rename from src/renderer/debug/debug_renderer.cpp rename to src/renderer/pipelines/debug/debug_renderer.cpp index da869487..970a9bb5 100644 --- a/src/renderer/debug/debug_renderer.cpp +++ b/src/renderer/pipelines/debug/debug_renderer.cpp @@ -2,6 +2,7 @@ // Created by William on 2025-04-27. // + #include "debug_renderer.h" #include diff --git a/src/renderer/debug/debug_renderer.h b/src/renderer/pipelines/debug/debug_renderer.h similarity index 100% rename from src/renderer/debug/debug_renderer.h rename to src/renderer/pipelines/debug/debug_renderer.h diff --git a/src/renderer/debug/debug_renderer_types.h b/src/renderer/pipelines/debug/debug_renderer_types.h similarity index 100% rename from src/renderer/debug/debug_renderer_types.h rename to src/renderer/pipelines/debug/debug_renderer_types.h diff --git a/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp b/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp index 4bb83afe..5af30596 100644 --- a/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp +++ b/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp @@ -99,7 +99,7 @@ void will_engine::deferred_mrt::DeferredMrtPipeline::draw(VkCommandBuffer cmd, c for (RenderObject* renderObject : drawInfo.renderObjects) { if (!renderObject->canDraw()) { continue; } - std::array descriptorBufferBindingInfos{ + std::array descriptorBufferBindingInfos{ drawInfo.sceneDataBinding, renderObject->getAddressesDescriptorBuffer().getDescriptorBufferBindingInfo(), renderObject->getTextureDescriptorBuffer().getDescriptorBufferBindingInfo(), @@ -109,7 +109,7 @@ void will_engine::deferred_mrt::DeferredMrtPipeline::draw(VkCommandBuffer cmd, c constexpr std::array indices{0, 1, 2}; - std::array offsets{ + std::array offsets{ drawInfo.sceneDataOffset, renderObject->getAddressesDescriptorBuffer().getDescriptorBufferSize() * drawInfo.currentFrameOverlap, ZERO_DEVICE_SIZE diff --git a/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp b/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp index 80283e87..9b1ab184 100644 --- a/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp +++ b/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp @@ -400,20 +400,9 @@ void TransparentPipeline::createCompositePipeline() blendAttachmentStates[0].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - // blendAttachmentStates[0].blendEnable = VK_TRUE; - // blendAttachmentStates[0].srcColorBlendFactor = VK_BLEND_FACTOR_ONE; - // blendAttachmentStates[0].dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; - // blendAttachmentStates[0].colorBlendOp = VK_BLEND_OP_ADD; - // blendAttachmentStates[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; - // blendAttachmentStates[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; - // blendAttachmentStates[0].alphaBlendOp = VK_BLEND_OP_ADD; - // blendAttachmentStates[0].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | - // VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - - pipelineBuilder.setupBlending(blendAttachmentStates); pipelineBuilder.disableDepthTest(); - pipelineBuilder.setupRenderer({DRAW_FORMAT}, VK_FORMAT_UNDEFINED); + pipelineBuilder.setupRenderer({DRAW_FORMAT}); pipelineBuilder.setupPipelineLayout(compositePipelineLayout); compositePipeline = resourceManager.createRenderPipeline(pipelineBuilder); diff --git a/src/renderer/vk_pipelines.cpp b/src/renderer/vk_pipelines.cpp index d0d5491d..aa4bb09e 100644 --- a/src/renderer/vk_pipelines.cpp +++ b/src/renderer/vk_pipelines.cpp @@ -205,11 +205,11 @@ void will_engine::PipelineBuilder::setupMultisampling(VkBool32 sampleShadingEnab multisampling.alphaToOneEnable = alphaToOneEnable; } -void will_engine::PipelineBuilder::setupRenderer(const std::vector& colorattachmentFormat, const VkFormat depthAttachmentFormat) +void will_engine::PipelineBuilder::setupRenderer(const std::vector& colorAttachmentFormat, const VkFormat depthAttachmentFormat, const VkFormat stencilAttachmentFormat) { // Color Format - if (!colorattachmentFormat.empty()) { - colorAttachmentFormats = colorattachmentFormat; + if (!colorAttachmentFormat.empty()) { + colorAttachmentFormats = colorAttachmentFormat; renderInfo.colorAttachmentCount = colorAttachmentFormats.size(); renderInfo.pColorAttachmentFormats = colorAttachmentFormats.data(); } @@ -218,6 +218,11 @@ void will_engine::PipelineBuilder::setupRenderer(const std::vector& co if (depthAttachmentFormat != VK_FORMAT_UNDEFINED) { renderInfo.depthAttachmentFormat = depthAttachmentFormat; } + + // Stencil Format + if (stencilAttachmentFormat != VK_FORMAT_UNDEFINED) { + renderInfo.stencilAttachmentFormat = stencilAttachmentFormat; + } } void will_engine::PipelineBuilder::setupDepthStencil(VkBool32 depthTestEnable, VkBool32 depthWriteEnable, VkCompareOp compareOp, VkBool32 depthBoundsTestEnable, diff --git a/src/renderer/vk_pipelines.h b/src/renderer/vk_pipelines.h index cb84f57e..029007fc 100644 --- a/src/renderer/vk_pipelines.h +++ b/src/renderer/vk_pipelines.h @@ -60,7 +60,7 @@ class PipelineBuilder void setupMultisampling(VkBool32 sampleShadingEnable, VkSampleCountFlagBits rasterizationSamples, float minSampleShading, const VkSampleMask* pSampleMask, VkBool32 alphaToCoverageEnable, VkBool32 alphaToOneEnable); - void setupRenderer(const std::vector& colorattachmentFormat, VkFormat depthAttachmentFormat); + void setupRenderer(const std::vector& colorAttachmentFormat, VkFormat depthAttachmentFormat = VK_FORMAT_UNDEFINED, VkFormat stencilAttachmentFormat = VK_FORMAT_UNDEFINED); /** * Set up the depth and stencil for this pipeline From 93d44e32b7f41675860c950f020e2e3204f87775 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Sun, 4 May 2025 16:56:49 +0700 Subject: [PATCH 16/24] Mesh highlight WIP2. Refactor name of resource destroyers. --- CMakeLists.txt | 5 +- shaders/debug/debug_composite.comp | 6 +- ...t_renderer.frag => debug_highlighter.frag} | 0 ...t_renderer.vert => debug_highlighter.vert} | 2 +- src/core/engine.cpp | 55 ++++--- src/core/engine.h | 13 ++ .../components/mesh_renderer_component.h | 2 + src/core/game_object/renderable.h | 2 + .../assets/render_object/render_object.cpp | 58 +++---- .../assets/texture/texture_resource.cpp | 2 +- src/renderer/environment/environment.cpp | 56 +++---- src/renderer/imgui_wrapper.cpp | 38 ++--- src/renderer/imgui_wrapper.h | 6 +- .../basic_compute/basic_compute_pipeline.cpp | 12 +- .../basic_render/basic_render_pipeline.cpp | 14 +- .../debug/debug_composite_pipeline.cpp | 26 +--- .../debug/debug_composite_pipeline.h | 6 +- .../debug/debug_highlight_pipeline.cpp | 72 --------- .../pipelines/debug/debug_highlighter.cpp | 146 ++++++++++++++++++ ...ghlight_pipeline.h => debug_highlighter.h} | 19 ++- .../pipelines/debug/debug_renderer.cpp | 52 +++---- .../pipelines/debug/debug_renderer_types.h | 2 +- .../deferred_mrt/deferred_mrt_pipeline.cpp | 10 +- .../deferred_resolve_pipeline.cpp | 10 +- .../environment/environment_pipeline.cpp | 10 +- .../geometry/terrain/terrain_pipeline.cpp | 26 ++-- .../transparent_pipeline.cpp | 30 ++-- .../post_process/post_process_pipeline.cpp | 12 +- .../temporal_antialiasing_pipeline.cpp | 12 +- .../cascaded_shadow_map.cpp | 38 ++--- .../contact_shadows_pipeline.cpp | 18 +-- ...round_truth_ambient_occlusion_pipeline.cpp | 54 +++---- .../visibility_pass_pipeline.cpp | 8 +- src/renderer/renderer_constants.h | 1 + src/renderer/resource_manager.cpp | 51 +++--- src/renderer/resource_manager.h | 20 +-- src/renderer/terrain/terrain_chunk.cpp | 12 +- src/renderer/vk_helpers.cpp | 16 +- 38 files changed, 512 insertions(+), 410 deletions(-) rename shaders/debug/{debug_highlight_renderer.frag => debug_highlighter.frag} (100%) rename shaders/debug/{debug_highlight_renderer.vert => debug_highlighter.vert} (75%) delete mode 100644 src/renderer/pipelines/debug/debug_highlight_pipeline.cpp create mode 100644 src/renderer/pipelines/debug/debug_highlighter.cpp rename src/renderer/pipelines/debug/{debug_highlight_pipeline.h => debug_highlighter.h} (56%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 2b24adac..bb6d3460 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -269,9 +269,8 @@ set(TEMP_SOURCES src/renderer/pipelines/debug/debug_renderer_types.h src/renderer/pipelines/debug/debug_composite_pipeline.cpp src/renderer/pipelines/debug/debug_composite_pipeline.h - src/renderer/pipelines/debug/debug_highlight_pipeline.cpp - src/renderer/pipelines/debug/debug_highlight_pipeline.h - + src/renderer/pipelines/debug/debug_highlighter.cpp + src/renderer/pipelines/debug/debug_highlighter.h ) add_executable(WillEngine main.cpp diff --git a/shaders/debug/debug_composite.comp b/shaders/debug/debug_composite.comp index ac9e5beb..f614b92c 100644 --- a/shaders/debug/debug_composite.comp +++ b/shaders/debug/debug_composite.comp @@ -23,14 +23,12 @@ void main() { vec4 mainColor = imageLoad(finalImage, pixelCoord); vec2 debugUv = uv; + // Flip (Main image is flipped in PP) debugUv.y = 1 - debugUv.y; + // Unjitter debugUv += sceneData.jitter.xy / 2.0f; - vec4 debugColor = texture(debugImage, debugUv); - - vec4 finalColor = mix(mainColor, debugColor, debugColor.a); - imageStore(finalImage, pixelCoord, finalColor); } \ No newline at end of file diff --git a/shaders/debug/debug_highlight_renderer.frag b/shaders/debug/debug_highlighter.frag similarity index 100% rename from shaders/debug/debug_highlight_renderer.frag rename to shaders/debug/debug_highlighter.frag diff --git a/shaders/debug/debug_highlight_renderer.vert b/shaders/debug/debug_highlighter.vert similarity index 75% rename from shaders/debug/debug_highlight_renderer.vert rename to shaders/debug/debug_highlighter.vert index 03a66282..48fd7c94 100644 --- a/shaders/debug/debug_highlight_renderer.vert +++ b/shaders/debug/debug_highlighter.vert @@ -11,5 +11,5 @@ layout (push_constant) uniform PushConstants { } push; void main() { - gl_Position = sceneData.viewProj * modelMatrix * vec4(inPosition, 1.0); + gl_Position = sceneData.viewProj * push.modelMatrix * vec4(inPosition, 1.0); } \ No newline at end of file diff --git a/src/core/engine.cpp b/src/core/engine.cpp index 0dda13c3..f1b06f40 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -27,6 +27,7 @@ #include "../renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.h" #include "../renderer/pipelines/debug/debug_renderer.h" #include "src/renderer/pipelines/debug/debug_composite_pipeline.h" +#include "src/renderer/pipelines/debug/debug_highlighter.h" #include "src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.h" #include "src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline_types.h" #include "src/renderer/pipelines/geometry/deferred_resolve/deferred_resolve_pipeline.h" @@ -98,9 +99,8 @@ void Engine::init() startupProfiler.addEntry("Vulkan Context"); createSwapchain(windowExtent.width, windowExtent.height); - createDrawResources(); - startupProfiler.addEntry("Swapchain/Draw Resources"); + startupProfiler.addEntry("Swapchain"); // Command Pools const VkCommandPoolCreateInfo commandPoolInfo = vk_helpers::commandPoolCreateInfo(context->graphicsQueueFamily, @@ -128,11 +128,15 @@ void Engine::init() assetManager = new AssetManager(*resourceManager); physics = new physics::Physics(); physics::Physics::set(physics); + + createDrawResources(); + #if WILL_ENGINE_DEBUG debugRenderer = new debug_renderer::DebugRenderer(*resourceManager); debug_renderer::DebugRenderer::set(debugRenderer); debugPipeline = new debug_pipeline::DebugCompositePipeline(*resourceManager); - debugPipeline->setupDescriptorBuffer(finalImageBuffer.imageView); + debugPipeline->setupDescriptorBuffer(debugTarget.imageView, finalImageBuffer.imageView); + debugHighlighter = new debug_highlight_pipeline::DebugHighlighter(*resourceManager); #endif startupProfiler.addEntry("Immediate, ResourceM, AssetM, Physics"); @@ -742,8 +746,10 @@ void Engine::render(float deltaTime) postProcessPipeline->draw(cmd, postProcessDrawInfo); #if WILL_ENGINE_DEBUG + // Ensure all real rendering happens before this step, as debug draws do write to the depth buffer. + // This should ALWAYS be the final step before copying to swapchain if (bDrawDebugRendering) { - vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, debugPipeline->getDebugTarget().image, VK_IMAGE_LAYOUT_UNDEFINED, + vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, debugTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, {0.0f, 0.0f, 0.0f, 0.0f}); vk_helpers::transitionImage(cmd, depthImage.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT); @@ -751,7 +757,7 @@ void Engine::render(float deltaTime) debug_renderer::DebugRendererDrawInfo debugRendererDrawInfo{ currentFrameOverlap, - debugPipeline->getDebugTarget().imageView, + debugTarget.imageView, depthImage.imageView, sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap @@ -759,7 +765,7 @@ void Engine::render(float deltaTime) debugRenderer->draw(cmd, debugRendererDrawInfo); - vk_helpers::transitionImage(cmd, debugPipeline->getDebugTarget().image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + vk_helpers::transitionImage(cmd, debugTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); @@ -860,10 +866,10 @@ void Engine::cleanup() delete postProcessPipeline; for (AllocatedBuffer sceneBuffer : sceneDataBuffers) { - resourceManager->destroyBuffer(sceneBuffer); + resourceManager->destroy(sceneBuffer); } - resourceManager->destroyBuffer(debugSceneDataBuffer); - resourceManager->destroyDescriptorBuffer(sceneDataDescriptorBuffer); + resourceManager->destroy(debugSceneDataBuffer); + resourceManager->destroy(sceneDataDescriptorBuffer); if (engine_constants::useImgui) { delete imguiWrapper; @@ -879,15 +885,15 @@ void Engine::cleanup() vkDestroySemaphore(context->device, frame._swapchainSemaphore, nullptr); } - resourceManager->destroyImage(drawImage); - resourceManager->destroyImage(depthImage); - resourceManager->destroyImage(normalRenderTarget); - resourceManager->destroyImage(albedoRenderTarget); - resourceManager->destroyImage(pbrRenderTarget); - resourceManager->destroyImage(velocityRenderTarget); - resourceManager->destroyImage(taaResolveTarget); - resourceManager->destroyImage(historyBuffer); - resourceManager->destroyImage(finalImageBuffer); + resourceManager->destroy(drawImage); + resourceManager->destroy(depthImage); + resourceManager->destroy(normalRenderTarget); + resourceManager->destroy(albedoRenderTarget); + resourceManager->destroy(pbrRenderTarget); + resourceManager->destroy(velocityRenderTarget); + resourceManager->destroy(taaResolveTarget); + resourceManager->destroy(historyBuffer); + resourceManager->destroy(finalImageBuffer); for (Map* map : activeMaps) { map->destroy(); @@ -911,7 +917,9 @@ void Engine::cleanup() delete cascadedShadowMap; delete environmentMap; #if WILL_ENGINE_DEBUG + resourceManager->destroy(debugTarget); delete debugRenderer; + delete debugHighlighter; delete debugPipeline; #endif delete physics; @@ -1143,6 +1151,17 @@ void Engine::createDrawResources() VK_IMAGE_ASPECT_COLOR_BIT); VK_CHECK(vkCreateImageView(context->device, &rview_info, nullptr, &finalImageBuffer.imageView)); } + +#if WILL_ENGINE_DEBUG + // Debug Output (Gizmos, Debug Draws, etc. Output here before combined w/ final image. Goes around normal pass stuff. Expects inputs to be jittered because to test against depth buffer, fragments need to be jittered cause depth buffer is jittered) + constexpr VkExtent3D imageExtent = {RENDER_EXTENTS.width, RENDER_EXTENTS.height, 1}; + VkImageUsageFlags usageFlags{}; + usageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + usageFlags |= VK_IMAGE_USAGE_SAMPLED_BIT; + usageFlags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; + const VkImageCreateInfo imageCreateInfo = vk_helpers::imageCreateInfo(DRAW_FORMAT, usageFlags, imageExtent); + debugTarget = resourceManager->createImage(imageCreateInfo); +#endif } void Engine::setCsmSettings(const cascaded_shadows::CascadedShadowMapSettings& settings) diff --git a/src/core/engine.h b/src/core/engine.h index e2e0048c..eb06c9fa 100644 --- a/src/core/engine.h +++ b/src/core/engine.h @@ -38,6 +38,11 @@ class VulkanContext; namespace will_engine { +namespace debug_highlight_pipeline +{ + class DebugHighlighter; +} + namespace debug_pipeline { class DebugCompositePipeline; @@ -169,8 +174,11 @@ class Engine physics::Physics* physics{nullptr}; #if WILL_ENGINE_DEBUG debug_renderer::DebugRenderer* debugRenderer{nullptr}; + debug_highlight_pipeline::DebugHighlighter* debugHighlighter{nullptr}; debug_pipeline::DebugCompositePipeline* debugPipeline{nullptr}; #endif + // Might be used in imgui which can be active outside of debug build + IHierarchical* selectedItem{nullptr}; environment::Environment* environmentMap{nullptr}; @@ -301,6 +309,11 @@ class Engine * A copy of the previous TAA Resolve Buffer */ AllocatedImage historyBuffer{}; + +#if WILL_ENGINE_DEBUG + AllocatedImage debugTarget{}; +#endif + AllocatedImage finalImageBuffer{}; private: // Swapchain diff --git a/src/core/game_object/components/mesh_renderer_component.h b/src/core/game_object/components/mesh_renderer_component.h index a3876cd7..1f0928b4 100644 --- a/src/core/game_object/components/mesh_renderer_component.h +++ b/src/core/game_object/components/mesh_renderer_component.h @@ -82,6 +82,8 @@ class MeshRendererComponent : public Component, public IRenderable uint32_t getRenderReferenceId() const override { return pRenderReference ? pRenderReference->getId() : INDEX_NONE; } + IRenderReference* getRenderReference() const override { return pRenderReference; } + int32_t getMeshIndex() const override { return meshIndex; } void releaseMesh() override; diff --git a/src/core/game_object/renderable.h b/src/core/game_object/renderable.h index d4039852..f367dc56 100644 --- a/src/core/game_object/renderable.h +++ b/src/core/game_object/renderable.h @@ -21,6 +21,8 @@ class IRenderable [[nodiscard]] virtual uint32_t getRenderReferenceId() const = 0; + [[nodiscard]] virtual IRenderReference* getRenderReference() const = 0; + [[nodiscard]] virtual int32_t getMeshIndex() const = 0; [[nodiscard]] virtual bool& isVisible() = 0; diff --git a/src/renderer/assets/render_object/render_object.cpp b/src/renderer/assets/render_object/render_object.cpp index 3db46191..c808cb2b 100644 --- a/src/renderer/assets/render_object/render_object.cpp +++ b/src/renderer/assets/render_object/render_object.cpp @@ -78,7 +78,7 @@ bool RenderObject::updateBuffers(VkCommandBuffer cmd, const int32_t currentFrame // Recreate the primitive buffer if needed size_t latestPrimitiveBufferSize = currentMaxPrimitiveCount * sizeof(PrimitiveData); if (currentPrimitiveBuffer.info.size != latestPrimitiveBufferSize) { - resourceManager.destroyBuffer(currentPrimitiveBuffer); + resourceManager.destroy(currentPrimitiveBuffer); currentPrimitiveBuffer = resourceManager.createHostRandomBuffer(latestPrimitiveBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT); @@ -114,7 +114,7 @@ bool RenderObject::updateBuffers(VkCommandBuffer cmd, const int32_t currentFrame // sizes don't match, need to recreate the buffer size_t latestInstanceBufferSize = currentMaxInstanceCount * sizeof(InstanceData); if (currentInstanceBuffer.info.size != latestInstanceBufferSize) { - resourceManager.destroyBuffer(currentInstanceBuffer); + resourceManager.destroy(currentInstanceBuffer); currentInstanceBuffer = resourceManager.createHostRandomBuffer(latestInstanceBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT); @@ -144,9 +144,9 @@ bool RenderObject::updateBuffers(VkCommandBuffer cmd, const int32_t currentFrame } AllocatedBuffer& currentOpaqueDrawIndirectBuffer = opaqueDrawIndirectBuffers[currentFrameOverlap]; - resourceManager.destroyBuffer(currentOpaqueDrawIndirectBuffer); + resourceManager.destroy(currentOpaqueDrawIndirectBuffer); if (!opaqueDrawCommands.empty()) { - resourceManager.destroyBuffer(currentOpaqueDrawIndirectBuffer); + resourceManager.destroy(currentOpaqueDrawIndirectBuffer); AllocatedBuffer indirectStaging = resourceManager.createStagingBuffer(opaqueDrawCommands.size() * sizeof(VkDrawIndexedIndirectCommand)); memcpy(indirectStaging.info.pMappedData, opaqueDrawCommands.data(), opaqueDrawCommands.size() * sizeof(VkDrawIndexedIndirectCommand)); currentOpaqueDrawIndirectBuffer = resourceManager.createDeviceBuffer(opaqueDrawCommands.size() * sizeof(VkDrawIndexedIndirectCommand), @@ -154,7 +154,7 @@ bool RenderObject::updateBuffers(VkCommandBuffer cmd, const int32_t currentFrame vk_helpers::copyBuffer(cmd, indirectStaging, 0, currentOpaqueDrawIndirectBuffer, 0, opaqueDrawCommands.size() * sizeof(VkDrawIndexedIndirectCommand)); - resourceManager.destroyBuffer(indirectStaging); + resourceManager.destroy(indirectStaging); const FrustumCullingBuffers cullingAddresses{ .meshBoundsBuffer = resourceManager.getBufferAddress(meshBoundsBuffer), @@ -167,11 +167,11 @@ bool RenderObject::updateBuffers(VkCommandBuffer cmd, const int32_t currentFrame AllocatedBuffer stagingCullingAddressesBuffer = resourceManager.createStagingBuffer(sizeof(FrustumCullingBuffers)); memcpy(stagingCullingAddressesBuffer.info.pMappedData, &cullingAddresses, sizeof(FrustumCullingBuffers)); vk_helpers::copyBuffer(cmd, stagingCullingAddressesBuffer, 0, currentCullingAddressBuffers, 0, sizeof(FrustumCullingBuffers)); - resourceManager.destroyBuffer(stagingCullingAddressesBuffer); + resourceManager.destroy(stagingCullingAddressesBuffer); } AllocatedBuffer& currentTransparentDrawIndirectBuffer = transparentDrawIndirectBuffers[currentFrameOverlap]; - resourceManager.destroyBuffer(currentTransparentDrawIndirectBuffer); + resourceManager.destroy(currentTransparentDrawIndirectBuffer); if (!transparentDrawCommands.empty()) { AllocatedBuffer indirectStaging = resourceManager.createStagingBuffer(transparentDrawCommands.size() * sizeof(VkDrawIndexedIndirectCommand)); @@ -183,7 +183,7 @@ bool RenderObject::updateBuffers(VkCommandBuffer cmd, const int32_t currentFrame vk_helpers::copyBuffer(cmd, indirectStaging, 0, currentTransparentDrawIndirectBuffer, 0, transparentDrawCommands.size() * sizeof(VkDrawIndexedIndirectCommand)); - resourceManager.destroyBuffer(indirectStaging); + resourceManager.destroy(indirectStaging); const FrustumCullingBuffers cullingAddresses{ .meshBoundsBuffer = resourceManager.getBufferAddress(meshBoundsBuffer), @@ -196,7 +196,7 @@ bool RenderObject::updateBuffers(VkCommandBuffer cmd, const int32_t currentFrame AllocatedBuffer stagingCullingAddressesBuffer = resourceManager.createStagingBuffer(sizeof(FrustumCullingBuffers)); memcpy(stagingCullingAddressesBuffer.info.pMappedData, &cullingAddresses, sizeof(FrustumCullingBuffers)); vk_helpers::copyBuffer(cmd, stagingCullingAddressesBuffer, 0, currentCullingAddressBuffers, 0, sizeof(FrustumCullingBuffers)); - resourceManager.destroyBuffer(stagingCullingAddressesBuffer); + resourceManager.destroy(stagingCullingAddressesBuffer); } bufferFramesToUpdate--; @@ -709,7 +709,7 @@ void RenderObject::load() // Be careful, this destroys a copy of the staging buffer. Not an issue since it deletes the buffer in GPU memory. // Will be dangerous if you attempt to hold onto the staging buffers outside of this load function for (BufferCopyInfo bufferCopy : bufferCopies) { - resourceManager.destroyBufferImmediate(bufferCopy.src); + resourceManager.destroyImmediate(bufferCopy.src); } bIsLoaded = true; @@ -736,7 +736,7 @@ void RenderObject::unload() continue; } - resourceManager.destroyImage(image); + resourceManager.destroy(image); } for (auto& sampler : samplers) { @@ -745,30 +745,30 @@ void RenderObject::unload() continue; } - resourceManager.destroySampler(sampler); + resourceManager.destroy(sampler); } - resourceManager.destroyBuffer(vertexPositionBuffer); - resourceManager.destroyBuffer(vertexPropertyBuffer); - resourceManager.destroyBuffer(indexBuffer); + resourceManager.destroy(vertexPositionBuffer); + resourceManager.destroy(vertexPropertyBuffer); + resourceManager.destroy(indexBuffer); - resourceManager.destroyBuffer(materialBuffer); + resourceManager.destroy(materialBuffer); - resourceManager.destroyBuffer(meshBoundsBuffer); + resourceManager.destroy(meshBoundsBuffer); for (int i = 0; i < FRAME_OVERLAP; ++i) { - resourceManager.destroyBuffer(opaqueDrawIndirectBuffers[i]); - resourceManager.destroyBuffer(transparentDrawIndirectBuffers[i]); - resourceManager.destroyBuffer(addressBuffers[i]); - resourceManager.destroyBuffer(primitiveDataBuffers[i]); - resourceManager.destroyBuffer(modelMatrixBuffers[i]); - resourceManager.destroyBuffer(opaqueCullingAddressBuffers[i]); - resourceManager.destroyBuffer(transparentCullingAddressBuffers[i]); - } - - resourceManager.destroyDescriptorBuffer(addressesDescriptorBuffer); - resourceManager.destroyDescriptorBuffer(frustumCullingDescriptorBuffer); - resourceManager.destroyDescriptorBuffer(textureDescriptorBuffer); + resourceManager.destroy(opaqueDrawIndirectBuffers[i]); + resourceManager.destroy(transparentDrawIndirectBuffers[i]); + resourceManager.destroy(addressBuffers[i]); + resourceManager.destroy(primitiveDataBuffers[i]); + resourceManager.destroy(modelMatrixBuffers[i]); + resourceManager.destroy(opaqueCullingAddressBuffers[i]); + resourceManager.destroy(transparentCullingAddressBuffers[i]); + } + + resourceManager.destroy(addressesDescriptorBuffer); + resourceManager.destroy(frustumCullingDescriptorBuffer); + resourceManager.destroy(textureDescriptorBuffer); opaqueDrawCommands.clear(); transparentDrawCommands.clear(); diff --git a/src/renderer/assets/texture/texture_resource.cpp b/src/renderer/assets/texture/texture_resource.cpp index e1cec583..8453a97e 100644 --- a/src/renderer/assets/texture/texture_resource.cpp +++ b/src/renderer/assets/texture/texture_resource.cpp @@ -48,6 +48,6 @@ TextureResource::TextureResource(ResourceManager& resourceManager, const std::fi TextureResource::~TextureResource() { // todo: deferred texture destruction for multi-buffer modification - resourceManager.destroyImage(image); + resourceManager.destroy(image); } } // will_engine diff --git a/src/renderer/environment/environment.cpp b/src/renderer/environment/environment.cpp index a76bfe8c..13aac207 100644 --- a/src/renderer/environment/environment.cpp +++ b/src/renderer/environment/environment.cpp @@ -98,7 +98,7 @@ will_engine::environment::Environment::Environment(ResourceManager& resourceMana computePipelineCreateInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; equiToCubemapPipeline = resourceManager.createComputePipeline(computePipelineCreateInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } // Cubemap -> Diff Pipeline @@ -136,7 +136,7 @@ will_engine::environment::Environment::Environment(ResourceManager& resourceMana computePipelineCreateInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; cubemapToDiffusePipeline = resourceManager.createComputePipeline(computePipelineCreateInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } // Cubemap -> Spec Pipeline @@ -174,7 +174,7 @@ will_engine::environment::Environment::Environment(ResourceManager& resourceMana computePipelineCreateInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; cubemapToSpecularPipeline = resourceManager.createComputePipeline(computePipelineCreateInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } // LUT Generation @@ -207,7 +207,7 @@ will_engine::environment::Environment::Environment(ResourceManager& resourceMana computePipelineCreateInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; lutPipeline = resourceManager.createComputePipeline(computePipelineCreateInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } @@ -273,37 +273,37 @@ will_engine::environment::Environment::Environment(ResourceManager& resourceMana will_engine::environment::Environment::~Environment() { - resourceManager.destroyPipelineLayout(equiToCubemapPipelineLayout); - resourceManager.destroyPipelineLayout(cubemapToDiffusePipelineLayout); - resourceManager.destroyPipelineLayout(cubemapToSpecularPipelineLayout); - resourceManager.destroyPipelineLayout(lutPipelineLayout); - resourceManager.destroyPipeline(equiToCubemapPipeline); - resourceManager.destroyPipeline(cubemapToDiffusePipeline); - resourceManager.destroyPipeline(cubemapToSpecularPipeline); - resourceManager.destroyPipeline(lutPipeline); + resourceManager.destroy(equiToCubemapPipelineLayout); + resourceManager.destroy(cubemapToDiffusePipelineLayout); + resourceManager.destroy(cubemapToSpecularPipelineLayout); + resourceManager.destroy(lutPipelineLayout); + resourceManager.destroy(equiToCubemapPipeline); + resourceManager.destroy(cubemapToDiffusePipeline); + resourceManager.destroy(cubemapToSpecularPipeline); + resourceManager.destroy(lutPipeline); - resourceManager.destroySampler(sampler); + resourceManager.destroy(sampler); - resourceManager.destroyDescriptorBuffer(cubemapStorageDescriptorBuffer); - resourceManager.destroyDescriptorBuffer(cubemapDescriptorBuffer); - resourceManager.destroyDescriptorBuffer(equiImageDescriptorBuffer); - resourceManager.destroyDescriptorBuffer(diffSpecMapDescriptorBuffer); - resourceManager.destroyDescriptorBuffer(lutDescriptorBuffer); + resourceManager.destroy(cubemapStorageDescriptorBuffer); + resourceManager.destroy(cubemapDescriptorBuffer); + resourceManager.destroy(equiImageDescriptorBuffer); + resourceManager.destroy(diffSpecMapDescriptorBuffer); + resourceManager.destroy(lutDescriptorBuffer); - resourceManager.destroyImage(lutImage); + resourceManager.destroy(lutImage); lutImage = {}; for (EnvironmentMapData& envMap : environmentMaps) { - resourceManager.destroyImage(envMap.cubemapImage); - resourceManager.destroyImage(envMap.specDiffCubemap); + resourceManager.destroy(envMap.cubemapImage); + resourceManager.destroy(envMap.specDiffCubemap); } - resourceManager.destroyDescriptorSetLayout(equiImageLayout); - resourceManager.destroyDescriptorSetLayout(cubemapStorageLayout); - resourceManager.destroyDescriptorSetLayout(cubemapSamplerLayout); - resourceManager.destroyDescriptorSetLayout(lutLayout); - resourceManager.destroyDescriptorSetLayout(environmentIBLLayout); + resourceManager.destroy(equiImageLayout); + resourceManager.destroy(cubemapStorageLayout); + resourceManager.destroy(cubemapSamplerLayout); + resourceManager.destroy(lutLayout); + resourceManager.destroy(environmentIBLLayout); } void will_engine::environment::Environment::loadEnvironment(const char* name, const char* path, int32_t environmentMapIndex) @@ -389,7 +389,7 @@ void will_engine::environment::Environment::loadEnvironment(const char* name, co // can safely destroy the cubemap image view in the storage buffer - resourceManager.destroyImage(equiImage); + resourceManager.destroy(equiImage); cubemapStorageDescriptorBuffer.freeDescriptorBufferIndex(cubemapIndex); equiImageDescriptorBuffer.freeDescriptorBufferIndex(equipIndex); @@ -503,7 +503,7 @@ void will_engine::environment::Environment::loadEnvironment(const char* name, co // can safely destroy all the storage mip level image views since we don't plan on writing to them anymore for (CubemapImageView specDiffView : specDiffCubemap.cubemapImageViews) { - resourceManager.destroyImageView(specDiffView.imageView); + resourceManager.destroy(specDiffView.imageView); } specDiffCubemap.cubemapImageViews.clear(); cubemapStorageDescriptorBuffer.freeAllDescriptorBufferIndices(); diff --git a/src/renderer/imgui_wrapper.cpp b/src/renderer/imgui_wrapper.cpp index c139e999..470c05b3 100644 --- a/src/renderer/imgui_wrapper.cpp +++ b/src/renderer/imgui_wrapper.cpp @@ -874,7 +874,7 @@ void ImguiWrapper::imguiInterface(Engine* engine) } ImGui::SameLine(); - if (auto container = dynamic_cast(selectedItem)) { + if (auto container = dynamic_cast(engine->selectedItem)) { if (ImGui::Button("Attach to selected item")) { if (!container->getMeshRenderer()) { auto newComponent = components::ComponentFactory::getInstance(). @@ -1224,12 +1224,12 @@ void ImguiWrapper::imguiInterface(Engine* engine) } ImGui::End(); - if (selectedItem) { - if (IImguiRenderable* imguiRenderable = dynamic_cast(selectedItem)) { + if (engine->selectedItem) { + if (IImguiRenderable* imguiRenderable = dynamic_cast(engine->selectedItem)) { imguiRenderable->selectedRenderImgui(); } - if (auto gameObject = dynamic_cast(selectedItem)) { + if (auto gameObject = dynamic_cast(engine->selectedItem)) { if (components::RigidBodyComponent* rb = gameObject->getRigidbody()) { if (rb->hasRigidBody()) { physics::Physics::get()->drawDebug(rb->getPhysicsBodyId()); @@ -1443,7 +1443,7 @@ void ImguiWrapper::drawSceneGraph(Engine* engine) if (destroy) { selectedMap->destroy(); selectMap(nullptr); - deselectItem(); + deselectItem(engine); } } @@ -1465,8 +1465,8 @@ void ImguiWrapper::displayGameObject(Engine* engine, IHierarchical* obj, const i ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.2f, 0.2f, 0.2f, 1.0f)); ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1, 0, 0, 1)); if (ImGui::Button("X")) { - if (selectedItem == obj) { - deselectItem(); + if (engine->selectedItem == obj) { + deselectItem(engine); } obj->destroy(); } @@ -1485,7 +1485,7 @@ void ImguiWrapper::displayGameObject(Engine* engine, IHierarchical* obj, const i ? fmt::format("{:.{}s}...", name, std::max(0, maxNameLength - 3)) : fmt::format("{:<{}}", name, maxNameLength); - if (obj == selectedItem) { + if (obj == engine->selectedItem) { ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.0f, 1.0f, 0.0f, 1.0f)); ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(0.0f, 0.6f, 0.0f, 1.0f)); ImGui::PushStyleColor(ImGuiCol_HeaderActive, ImVec4(0.0f, 0.7f, 0.0f, 1.0f)); @@ -1493,16 +1493,16 @@ void ImguiWrapper::displayGameObject(Engine* engine, IHierarchical* obj, const i const bool isOpen = ImGui::TreeNodeEx("##TreeNode", flags, "%s", formattedName.c_str()); - if (obj == selectedItem) { + if (obj == engine->selectedItem) { ImGui::PopStyleColor(3); } if (ImGui::IsItemClicked() && !ImGui::IsItemToggledOpen()) { - if (obj == selectedItem) { - deselectItem(); + if (obj == engine->selectedItem) { + deselectItem(engine); } else { - selectItem(obj); + selectItem(engine, obj); } } ImGui::NextColumn(); @@ -1641,23 +1641,23 @@ int ImguiWrapper::getIndexInVector(const IHierarchical* obj, const std::vectorselectedItem != nullptr) { + deselectItem(engine); } - selectedItem = hierarchical; + engine->selectedItem = hierarchical; } -void ImguiWrapper::deselectItem() +void ImguiWrapper::deselectItem(Engine* engine) { - if (const auto gameObject = dynamic_cast(selectedItem)) { + if (const auto gameObject = dynamic_cast(engine->selectedItem)) { if (const components::RigidBodyComponent* rb = gameObject->getRigidbody()) { if (rb->hasRigidBody()) { physics::Physics::get()->stopDrawDebug(rb->getPhysicsBodyId()); } } } - selectedItem = nullptr; + engine->selectedItem = nullptr; } } diff --git a/src/renderer/imgui_wrapper.h b/src/renderer/imgui_wrapper.h index 1d9ef03f..8a917d1b 100644 --- a/src/renderer/imgui_wrapper.h +++ b/src/renderer/imgui_wrapper.h @@ -61,16 +61,16 @@ class ImguiWrapper static int getIndexInVector(const IHierarchical* obj, const std::vector& vector); private: - void selectItem(IHierarchical* hierarchical); + static void selectItem(Engine* engine, IHierarchical* hierarchical); - void deselectItem(); + static void deselectItem(Engine* engine); private: const VulkanContext& context; VkDescriptorPool imguiPool{VK_NULL_HANDLE}; - IHierarchical* selectedItem{nullptr}; + Map* selectedMap{nullptr}; uint32_t selectedRenderObjectId = 0; diff --git a/src/renderer/pipelines/basic/basic_compute/basic_compute_pipeline.cpp b/src/renderer/pipelines/basic/basic_compute/basic_compute_pipeline.cpp index 48d00cb7..94728781 100644 --- a/src/renderer/pipelines/basic/basic_compute/basic_compute_pipeline.cpp +++ b/src/renderer/pipelines/basic/basic_compute/basic_compute_pipeline.cpp @@ -34,10 +34,10 @@ BasicComputePipeline::BasicComputePipeline(ResourceManager& resourceManager) : r BasicComputePipeline::~BasicComputePipeline() { - resourceManager.destroyPipeline(pipeline); - resourceManager.destroyPipelineLayout(pipelineLayout); - resourceManager.destroyDescriptorSetLayout(descriptorSetLayout); - resourceManager.destroyDescriptorBuffer(samplerDescriptorBuffer); + resourceManager.destroy(pipeline); + resourceManager.destroy(pipelineLayout); + resourceManager.destroy(descriptorSetLayout); + resourceManager.destroy(samplerDescriptorBuffer); } void BasicComputePipeline::setupDescriptors(const ComputeDescriptorInfo& descriptorInfo) @@ -70,7 +70,7 @@ void BasicComputePipeline::draw(VkCommandBuffer cmd, const ComputeDrawInfo drawI void BasicComputePipeline::createPipeline() { - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipeline); VkShaderModule gradientShader = resourceManager.createShaderModule("shaders/basic/compute.comp"); VkPipelineShaderStageCreateInfo stageInfo{}; @@ -89,6 +89,6 @@ void BasicComputePipeline::createPipeline() pipeline = resourceManager.createComputePipeline(computePipelineCreateInfo); - resourceManager.destroyShaderModule(gradientShader); + resourceManager.destroy(gradientShader); } } diff --git a/src/renderer/pipelines/basic/basic_render/basic_render_pipeline.cpp b/src/renderer/pipelines/basic/basic_render/basic_render_pipeline.cpp index 44a7cd96..160eaa39 100644 --- a/src/renderer/pipelines/basic/basic_render/basic_render_pipeline.cpp +++ b/src/renderer/pipelines/basic/basic_render/basic_render_pipeline.cpp @@ -40,10 +40,10 @@ will_engine::basic_render_pipeline::BasicRenderPipeline::BasicRenderPipeline(Res will_engine::basic_render_pipeline::BasicRenderPipeline::~BasicRenderPipeline() { - resourceManager.destroyPipeline(pipeline); - resourceManager.destroyPipelineLayout(pipelineLayout); - resourceManager.destroyDescriptorSetLayout(samplerDescriptorLayout); - resourceManager.destroyDescriptorBuffer(samplerDescriptorBuffer); + resourceManager.destroy(pipeline); + resourceManager.destroy(pipelineLayout); + resourceManager.destroy(samplerDescriptorLayout); + resourceManager.destroy(samplerDescriptorBuffer); } void will_engine::basic_render_pipeline::BasicRenderPipeline::setupDescriptors(const RenderDescriptorInfo& descriptorInfo) @@ -112,7 +112,7 @@ void will_engine::basic_render_pipeline::BasicRenderPipeline::draw(VkCommandBuff void will_engine::basic_render_pipeline::BasicRenderPipeline::createPipeline() { - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipeline); VkShaderModule vertShader = resourceManager.createShaderModule("shaders/basic/vertex.vert"); VkShaderModule fragShader = resourceManager.createShaderModule("shaders/basic/fragment.frag"); @@ -128,6 +128,6 @@ void will_engine::basic_render_pipeline::BasicRenderPipeline::createPipeline() pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(fragShader); + resourceManager.destroy(vertShader); + resourceManager.destroy(fragShader); } diff --git a/src/renderer/pipelines/debug/debug_composite_pipeline.cpp b/src/renderer/pipelines/debug/debug_composite_pipeline.cpp index 86a67c46..4f839cb9 100644 --- a/src/renderer/pipelines/debug/debug_composite_pipeline.cpp +++ b/src/renderer/pipelines/debug/debug_composite_pipeline.cpp @@ -39,34 +39,24 @@ DebugCompositePipeline::DebugCompositePipeline(ResourceManager& resourceManager) createPipeline(); descriptorBuffer = resourceManager.createDescriptorBufferSampler(descriptorSetLayout, 1); - - // Debug Output (Gizmos, Debug Draws, etc. Output here before combined w/ final image. Goes around normal pass stuff. Expects inputs to be jittered because to test against depth buffer, fragments need to be jittered cause depth buffer is jittered) - constexpr VkExtent3D imageExtent = {RENDER_EXTENTS.width, RENDER_EXTENTS.height, 1}; - VkImageUsageFlags usageFlags{}; - usageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; - usageFlags |= VK_IMAGE_USAGE_SAMPLED_BIT; - usageFlags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; - const VkImageCreateInfo imageCreateInfo = vk_helpers::imageCreateInfo(DRAW_FORMAT, usageFlags, imageExtent); - debugTarget = resourceManager.createImage(imageCreateInfo); } DebugCompositePipeline::~DebugCompositePipeline() { - resourceManager.destroyPipeline(pipeline); - resourceManager.destroyPipelineLayout(pipelineLayout); - resourceManager.destroyDescriptorSetLayout(descriptorSetLayout); - resourceManager.destroyDescriptorBuffer(descriptorBuffer); - resourceManager.destroyImage(debugTarget); + resourceManager.destroy(pipeline); + resourceManager.destroy(pipelineLayout); + resourceManager.destroy(descriptorSetLayout); + resourceManager.destroy(descriptorBuffer); } -void DebugCompositePipeline::setupDescriptorBuffer(VkImageView finalImageView) +void DebugCompositePipeline::setupDescriptorBuffer(VkImageView debugTarget, VkImageView finalImageView) { std::vector descriptors; descriptors.reserve(2); VkDescriptorImageInfo inputImage{}; inputImage.sampler = resourceManager.getDefaultSamplerNearest(); - inputImage.imageView = debugTarget.imageView; + inputImage.imageView = debugTarget; inputImage.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; VkDescriptorImageInfo outputImage{}; @@ -104,7 +94,7 @@ void DebugCompositePipeline::draw(VkCommandBuffer cmd, DebugCompositePipelineDra void DebugCompositePipeline::createPipeline() { - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipeline); VkShaderModule computeShader = resourceManager.createShaderModule("shaders/debug/debug_composite.comp"); VkPipelineShaderStageCreateInfo stageInfo{}; @@ -122,6 +112,6 @@ void DebugCompositePipeline::createPipeline() pipelineInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; pipeline = resourceManager.createComputePipeline(pipelineInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } } diff --git a/src/renderer/pipelines/debug/debug_composite_pipeline.h b/src/renderer/pipelines/debug/debug_composite_pipeline.h index f9d6449c..0231d76a 100644 --- a/src/renderer/pipelines/debug/debug_composite_pipeline.h +++ b/src/renderer/pipelines/debug/debug_composite_pipeline.h @@ -33,14 +33,12 @@ class DebugCompositePipeline { ~DebugCompositePipeline(); - void setupDescriptorBuffer(VkImageView finalImageView); + void setupDescriptorBuffer(VkImageView debugTarget, VkImageView finalImageView); void draw(VkCommandBuffer cmd, DebugCompositePipelineDrawInfo drawInfo) const; void reloadShaders() { createPipeline(); } - const AllocatedImage& getDebugTarget() const { return debugTarget; } - private: void createPipeline(); @@ -51,8 +49,6 @@ class DebugCompositePipeline { VkPipeline pipeline{VK_NULL_HANDLE}; VkDescriptorSetLayout descriptorSetLayout{VK_NULL_HANDLE}; DescriptorBufferSampler descriptorBuffer; - - AllocatedImage debugTarget{}; }; } diff --git a/src/renderer/pipelines/debug/debug_highlight_pipeline.cpp b/src/renderer/pipelines/debug/debug_highlight_pipeline.cpp deleted file mode 100644 index 02c5c391..00000000 --- a/src/renderer/pipelines/debug/debug_highlight_pipeline.cpp +++ /dev/null @@ -1,72 +0,0 @@ -// -// Created by William on 2025-05-04. -// - -#include "debug_highlight_pipeline.h" - -#include "src/renderer/assets/render_object/render_object_types.h" - - -namespace will_engine::debug_highlight_pipeline -{ -DebugHighlightPipeline::DebugHighlightPipeline(ResourceManager& resourceManager) : resourceManager(resourceManager) -{ - std::array descriptorLayout; - descriptorLayout[0] = resourceManager.getSceneDataLayout(); - - VkPushConstantRange pushConstants{}; - pushConstants.offset = 0; - pushConstants.size = sizeof(DebugHighlightDrawPushConstant); - pushConstants.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; - - VkPipelineLayoutCreateInfo layoutInfo = vk_helpers::pipelineLayoutCreateInfo(); - layoutInfo.pNext = nullptr; - layoutInfo.pSetLayouts = descriptorLayout.data(); - layoutInfo.setLayoutCount = 1; - layoutInfo.pPushConstantRanges = &pushConstants; - layoutInfo.pushConstantRangeCount = 1; - - pipelineLayout = resourceManager.createPipelineLayout(layoutInfo); - - //debugHighlightStencil = -} - -DebugHighlightPipeline::~DebugHighlightPipeline() {} - -void DebugHighlightPipeline::draw(VkCommandBuffer cmd) const -{} - -void DebugHighlightPipeline::createPipeline() -{ - VkShaderModule vertShader = resourceManager.createShaderModule("shaders/debug/debug_highlight_renderer.vert"); - VkShaderModule fragShader = resourceManager.createShaderModule("shaders/debug/debug_highlight_renderer.frag"); - - PipelineBuilder renderPipelineBuilder; - VkVertexInputBindingDescription vertexBinding{}; - vertexBinding.binding = 0; - vertexBinding.stride = sizeof(VertexPosition); - vertexBinding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; - - std::array vertexAttributes; - vertexAttributes[0].binding = 0; - vertexAttributes[0].location = 0; - vertexAttributes[0].format = VK_FORMAT_R32G32B32_SFLOAT; - vertexAttributes[0].offset = offsetof(VertexPosition, position); - - renderPipelineBuilder.setupVertexInput(&vertexBinding, 1, vertexAttributes.data(), 1); - - renderPipelineBuilder.setShaders(vertShader, fragShader); - renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_LINE_LIST); - renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); - renderPipelineBuilder.disableMultisampling(); - renderPipelineBuilder.disableBlending(); - renderPipelineBuilder.disableDepthTest(); - renderPipelineBuilder.setupRenderer({}, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED); - renderPipelineBuilder.setupPipelineLayout(pipelineLayout); - const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; - pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); - - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(fragShader); -} -} diff --git a/src/renderer/pipelines/debug/debug_highlighter.cpp b/src/renderer/pipelines/debug/debug_highlighter.cpp new file mode 100644 index 00000000..ce3cc1f5 --- /dev/null +++ b/src/renderer/pipelines/debug/debug_highlighter.cpp @@ -0,0 +1,146 @@ +// +// Created by William on 2025-05-04. +// + +#include "debug_highlighter.h" + +#include + +#include "src/core/game_object/renderable.h" +#include "src/renderer/assets/render_object/render_object_types.h" + + +namespace will_engine::debug_highlight_pipeline +{ +DebugHighlighter::DebugHighlighter(ResourceManager& resourceManager) : resourceManager(resourceManager) +{ + std::array descriptorLayout; + descriptorLayout[0] = resourceManager.getSceneDataLayout(); + + VkPushConstantRange pushConstants{}; + pushConstants.offset = 0; + pushConstants.size = sizeof(DebugHighlightDrawPushConstant); + pushConstants.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + + VkPipelineLayoutCreateInfo layoutInfo = vk_helpers::pipelineLayoutCreateInfo(); + layoutInfo.pNext = nullptr; + layoutInfo.pSetLayouts = descriptorLayout.data(); + layoutInfo.setLayoutCount = 1; + layoutInfo.pPushConstantRanges = &pushConstants; + layoutInfo.pushConstantRangeCount = 1; + + pipelineLayout = resourceManager.createPipelineLayout(layoutInfo); + + createPipeline(); +} + +DebugHighlighter::~DebugHighlighter() +{ + + resourceManager.destroy(pipelineLayout); + resourceManager.destroy(pipeline); + resourceManager.destroy(debugHighlightStencil); +} + +void DebugHighlighter::draw(VkCommandBuffer cmd, IRenderable* highlightTarget, VkImageView debugTarget, VkImageView depthTarget) const +{ + if (IRenderReference* renderRef = highlightTarget->getRenderReference()) { + const std::optional> meshData = renderRef->getMeshData(highlightTarget->getMeshIndex()); + if (!meshData.has_value()) { return; } + + const VkRenderingAttachmentInfo imageAttachment = vk_helpers::attachmentInfo(debugTarget, nullptr, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + const VkRenderingAttachmentInfo depthAttachment = vk_helpers::attachmentInfo(depthTarget, nullptr, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL); + + VkRenderingInfo renderInfo{}; + renderInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO; + renderInfo.pNext = nullptr; + + VkRenderingAttachmentInfo renderAttachments[1]; + renderAttachments[0] = imageAttachment; + + renderInfo.renderArea = VkRect2D{VkOffset2D{0, 0}, RENDER_EXTENTS}; + renderInfo.layerCount = 1; + renderInfo.colorAttachmentCount = 1; + renderInfo.pColorAttachments = renderAttachments; + renderInfo.pDepthAttachment = &depthAttachment; + renderInfo.pStencilAttachment = nullptr; + + vkCmdBeginRendering(cmd, &renderInfo); + + vkCmdSetLineWidth(cmd, 1.0f); + + // Viewport + VkViewport viewport = {}; + viewport.x = 0; + viewport.y = 0; + viewport.width = RENDER_EXTENTS.width; + viewport.height = RENDER_EXTENTS.height; + viewport.minDepth = 0.f; + viewport.maxDepth = 1.f; + vkCmdSetViewport(cmd, 0, 1, &viewport); + // Scissor + VkRect2D scissor = {}; + scissor.offset.x = 0; + scissor.offset.y = 0; + scissor.extent.width = RENDER_EXTENTS.width; + scissor.extent.height = RENDER_EXTENTS.height; + vkCmdSetScissor(cmd, 0, 1, &scissor); + + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); + + for (const Primitive& primitive : meshData.value().get().primitives) { + const uint32_t indexCount = primitive.indexCount; + const uint32_t firstIndex = primitive.firstIndex; + const int32_t vertexOffset = primitive.vertexOffset; + constexpr uint32_t firstInstance = 0; + constexpr uint32_t instanceCount = 1; + + DebugHighlightDrawPushConstant push{}; + push.modelMatrix = highlightTarget->getModelMatrix(); + vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(DebugHighlightDrawPushConstant), &push); + + vkCmdBindVertexBuffers(cmd, 0, 1, &renderRef->getPositionVertexBuffer().buffer, &ZERO_DEVICE_SIZE); + vkCmdBindIndexBuffer(cmd, renderRef->getIndexBuffer().buffer, 0, VK_INDEX_TYPE_UINT32); + + // Draw this mesh w/ vkCmdDrawIndexed w/ model matrix passed through push + vkCmdDrawIndexed(cmd, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + } + } +} + +void DebugHighlighter::createPipeline() +{ + VkShaderModule vertShader = resourceManager.createShaderModule("shaders/debug/debug_highlighter.vert"); + VkShaderModule fragShader = resourceManager.createShaderModule("shaders/debug/debug_highlighter.frag"); + + PipelineBuilder renderPipelineBuilder; + VkVertexInputBindingDescription vertexBinding{}; + vertexBinding.binding = 0; + vertexBinding.stride = sizeof(VertexPosition); + vertexBinding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + + std::array vertexAttributes; + vertexAttributes[0].binding = 0; + vertexAttributes[0].location = 0; + vertexAttributes[0].format = VK_FORMAT_R32G32B32_SFLOAT; + vertexAttributes[0].offset = offsetof(VertexPosition, position); + + renderPipelineBuilder.setupVertexInput(&vertexBinding, 1, vertexAttributes.data(), 1); + + renderPipelineBuilder.setShaders(vertShader, fragShader); + renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_LINE_LIST); + renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); + renderPipelineBuilder.disableMultisampling(); + renderPipelineBuilder.disableBlending(); + renderPipelineBuilder.disableDepthTest(); + renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED); + renderPipelineBuilder.setupPipelineLayout(pipelineLayout); + const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; + pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); + + resourceManager.destroy(vertShader); + resourceManager.destroy(fragShader); +} +} diff --git a/src/renderer/pipelines/debug/debug_highlight_pipeline.h b/src/renderer/pipelines/debug/debug_highlighter.h similarity index 56% rename from src/renderer/pipelines/debug/debug_highlight_pipeline.h rename to src/renderer/pipelines/debug/debug_highlighter.h index 8e8e4e85..994ce9c8 100644 --- a/src/renderer/pipelines/debug/debug_highlight_pipeline.h +++ b/src/renderer/pipelines/debug/debug_highlighter.h @@ -9,19 +9,26 @@ #include "src/renderer/resource_manager.h" +namespace will_engine +{ +class IRenderable; +} + namespace will_engine::debug_highlight_pipeline { struct DebugHighlightDrawPushConstant { - glm::vec4 modelMatrix{1.0f}; + glm::mat4 modelMatrix{1.0f}; + glm::vec4 color{1.0f, 0.647f, 0.0f, 1.0f}; }; -class DebugHighlightPipeline { - explicit DebugHighlightPipeline(ResourceManager& resourceManager); +class DebugHighlighter { +public: + explicit DebugHighlighter(ResourceManager& resourceManager); - ~DebugHighlightPipeline(); + ~DebugHighlighter(); - void draw(VkCommandBuffer cmd) const; + void draw(VkCommandBuffer cmd, IRenderable* highlightTarget, VkImageView debugTarget, VkImageView depthTarget) const; void reloadShaders() { createPipeline(); } @@ -34,7 +41,7 @@ class DebugHighlightPipeline { VkPipelineLayout pipelineLayout{VK_NULL_HANDLE}; VkPipeline pipeline{VK_NULL_HANDLE}; - AllocatedImage debugHighlightStencil{}; + AllocatedImage debugHighlightStencil{VK_NULL_HANDLE}; }; } diff --git a/src/renderer/pipelines/debug/debug_renderer.cpp b/src/renderer/pipelines/debug/debug_renderer.cpp index 970a9bb5..a68bdd27 100644 --- a/src/renderer/pipelines/debug/debug_renderer.cpp +++ b/src/renderer/pipelines/debug/debug_renderer.cpp @@ -46,7 +46,7 @@ DebugRenderer::DebugRenderer(ResourceManager& resourceManager) : resourceManager resourceManager.copyBufferImmediate(bufferCopies); for (BufferCopyInfo bufferCopy : bufferCopies) { - resourceManager.destroyBufferImmediate(bufferCopy.src); + resourceManager.destroyImmediate(bufferCopy.src); } @@ -71,30 +71,30 @@ DebugRenderer::DebugRenderer(ResourceManager& resourceManager) : resourceManager DebugRenderer::~DebugRenderer() { - resourceManager.destroyDescriptorSetLayout(uniformLayout); + resourceManager.destroy(uniformLayout); - resourceManager.destroyBuffer(instancedVertexBuffer); - resourceManager.destroyBuffer(instancedIndexBuffer); + resourceManager.destroy(instancedVertexBuffer); + resourceManager.destroy(instancedIndexBuffer); for (DebugRenderGroup& group : debugRenderInstanceGroups) { for (AllocatedBuffer& buffer : group.instanceBuffers) { - resourceManager.destroyBuffer(buffer); + resourceManager.destroy(buffer); } - resourceManager.destroyDescriptorBuffer(group.instanceDescriptorBuffer); + resourceManager.destroy(group.instanceDescriptorBuffer); } for (AllocatedBuffer& buffer : lineVertexBuffers) { - resourceManager.destroyBuffer(buffer); + resourceManager.destroy(buffer); } for (AllocatedBuffer& buffer : triangleVertexBuffers) { - resourceManager.destroyBuffer(buffer); + resourceManager.destroy(buffer); } - resourceManager.destroyPipelineLayout(instancedPipelineLayout); - resourceManager.destroyPipelineLayout(normalPipelineLayout); - resourceManager.destroyPipeline(instancedLinePipeline); - resourceManager.destroyPipeline(linePipeline); - resourceManager.destroyPipeline(trianglePipeline); + resourceManager.destroy(instancedPipelineLayout); + resourceManager.destroy(normalPipelineLayout); + resourceManager.destroy(instancedLinePipeline); + resourceManager.destroy(linePipeline); + resourceManager.destroy(trianglePipeline); } void DebugRenderer::drawLine(const glm::vec3& start, const glm::vec3& end, const glm::vec3& color) @@ -149,7 +149,7 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI newSize += DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; } - resourceManager.destroyBuffer(instanceBuffer); + resourceManager.destroy(instanceBuffer); // Don't need to copy, writing to it in the next section anyway const uint64_t newBufferSize = newSize * sizeof(DebugRendererInstance); @@ -178,7 +178,7 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI newSize += DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; } - resourceManager.destroyBuffer(lineVertexBuffer); + resourceManager.destroy(lineVertexBuffer); const uint64_t newBufferSize = newSize * sizeof(DebugRendererVertexFull); lineVertexBuffer = resourceManager.createHostSequentialBuffer(newBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); @@ -195,7 +195,7 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI newSize += DEFAULT_DEBUG_RENDERER_INSTANCE_COUNT; } - resourceManager.destroyBuffer(triangleVertexBuffer); + resourceManager.destroy(triangleVertexBuffer); const uint64_t newBufferSize = newSize * sizeof(DebugRendererVertexFull); triangleVertexBuffer = resourceManager.createHostSequentialBuffer(newBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); @@ -206,7 +206,7 @@ void DebugRenderer::draw(VkCommandBuffer cmd, const DebugRendererDrawInfo& drawI } - const VkRenderingAttachmentInfo imageAttachment = vk_helpers::attachmentInfo(drawInfo.imageTarget, nullptr, + const VkRenderingAttachmentInfo imageAttachment = vk_helpers::attachmentInfo(drawInfo.debugTarget, nullptr, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); const VkRenderingAttachmentInfo depthAttachment = vk_helpers::attachmentInfo(drawInfo.depthTarget, nullptr, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL); @@ -323,9 +323,9 @@ void DebugRenderer::clear() void DebugRenderer::createPipeline() { - resourceManager.destroyPipeline(instancedLinePipeline); - resourceManager.destroyPipeline(trianglePipeline); - resourceManager.destroyPipeline(linePipeline); + resourceManager.destroy(instancedLinePipeline); + resourceManager.destroy(trianglePipeline); + resourceManager.destroy(linePipeline); // Instanced Pipeline { @@ -351,14 +351,14 @@ void DebugRenderer::createPipeline() renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_LINE, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); - renderPipelineBuilder.enableDepthTest(false, VK_COMPARE_OP_GREATER_OR_EQUAL); + renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); renderPipelineBuilder.setupRenderer({ALBEDO_FORMAT}, DEPTH_FORMAT); renderPipelineBuilder.setupPipelineLayout(instancedPipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; instancedLinePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(fragShader); + resourceManager.destroy(vertShader); + resourceManager.destroy(fragShader); } // Line Vertex Pipeline @@ -390,7 +390,7 @@ void DebugRenderer::createPipeline() renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_LINE, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); - renderPipelineBuilder.enableDepthTest(false, VK_COMPARE_OP_GREATER_OR_EQUAL); + renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); renderPipelineBuilder.setupRenderer({ALBEDO_FORMAT}, DEPTH_FORMAT); renderPipelineBuilder.setupPipelineLayout(normalPipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; @@ -400,8 +400,8 @@ void DebugRenderer::createPipeline() renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST); trianglePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(fragShader); + resourceManager.destroy(vertShader); + resourceManager.destroy(fragShader); } } diff --git a/src/renderer/pipelines/debug/debug_renderer_types.h b/src/renderer/pipelines/debug/debug_renderer_types.h index 218096f5..1c8bb737 100644 --- a/src/renderer/pipelines/debug/debug_renderer_types.h +++ b/src/renderer/pipelines/debug/debug_renderer_types.h @@ -90,7 +90,7 @@ struct DebugRendererInstance struct DebugRendererDrawInfo { int32_t currentFrameOverlap{}; - VkImageView imageTarget; + VkImageView debugTarget; VkImageView depthTarget; VkDescriptorBufferBindingInfoEXT sceneDataBinding{}; VkDeviceSize sceneDataOffset{0}; diff --git a/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp b/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp index 5af30596..37c01565 100644 --- a/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp +++ b/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp @@ -34,8 +34,8 @@ will_engine::deferred_mrt::DeferredMrtPipeline::DeferredMrtPipeline(ResourceMana will_engine::deferred_mrt::DeferredMrtPipeline::~DeferredMrtPipeline() { - resourceManager.destroyPipelineLayout(pipelineLayout); - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipelineLayout); + resourceManager.destroy(pipeline); } void will_engine::deferred_mrt::DeferredMrtPipeline::draw(VkCommandBuffer cmd, const DeferredMrtDrawInfo& drawInfo) const @@ -132,7 +132,7 @@ void will_engine::deferred_mrt::DeferredMrtPipeline::draw(VkCommandBuffer cmd, c void will_engine::deferred_mrt::DeferredMrtPipeline::createPipeline() { - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipeline); VkShaderModule vertShader = resourceManager.createShaderModule("shaders/deferredMrt.vert"); VkShaderModule fragShader = resourceManager.createShaderModule("shaders/deferredMrt.frag"); @@ -182,6 +182,6 @@ void will_engine::deferred_mrt::DeferredMrtPipeline::createPipeline() renderPipelineBuilder.setupPipelineLayout(pipelineLayout); pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(fragShader); + resourceManager.destroy(vertShader); + resourceManager.destroy(fragShader); } diff --git a/src/renderer/pipelines/geometry/deferred_resolve/deferred_resolve_pipeline.cpp b/src/renderer/pipelines/geometry/deferred_resolve/deferred_resolve_pipeline.cpp index 357d65fb..fa10734b 100644 --- a/src/renderer/pipelines/geometry/deferred_resolve/deferred_resolve_pipeline.cpp +++ b/src/renderer/pipelines/geometry/deferred_resolve/deferred_resolve_pipeline.cpp @@ -46,9 +46,9 @@ will_engine::deferred_resolve::DeferredResolvePipeline::DeferredResolvePipeline( will_engine::deferred_resolve::DeferredResolvePipeline::~DeferredResolvePipeline() { - resourceManager.destroyPipelineLayout(pipelineLayout); - resourceManager.destroyPipeline(pipeline); - resourceManager.destroyDescriptorBuffer(resolveDescriptorBuffer); + resourceManager.destroy(pipelineLayout); + resourceManager.destroy(pipeline); + resourceManager.destroy(resolveDescriptorBuffer); } void will_engine::deferred_resolve::DeferredResolvePipeline::setupDescriptorBuffer(const DeferredResolveDescriptor& drawInfo) @@ -162,7 +162,7 @@ void will_engine::deferred_resolve::DeferredResolvePipeline::draw(VkCommandBuffe void will_engine::deferred_resolve::DeferredResolvePipeline::createPipeline() { - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipeline); VkShaderModule deferredResolveShader = resourceManager.createShaderModule("shaders/deferredResolve.comp"); VkPipelineShaderStageCreateInfo stageInfo = {}; @@ -180,5 +180,5 @@ void will_engine::deferred_resolve::DeferredResolvePipeline::createPipeline() pipelineInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; pipeline = resourceManager.createComputePipeline(pipelineInfo); - resourceManager.destroyShaderModule(deferredResolveShader); + resourceManager.destroy(deferredResolveShader); } diff --git a/src/renderer/pipelines/geometry/environment/environment_pipeline.cpp b/src/renderer/pipelines/geometry/environment/environment_pipeline.cpp index 7acab329..eddfcf87 100644 --- a/src/renderer/pipelines/geometry/environment/environment_pipeline.cpp +++ b/src/renderer/pipelines/geometry/environment/environment_pipeline.cpp @@ -30,8 +30,8 @@ will_engine::environment_pipeline::EnvironmentPipeline::EnvironmentPipeline(Reso will_engine::environment_pipeline::EnvironmentPipeline::~EnvironmentPipeline() { - resourceManager.destroyPipeline(pipeline); - resourceManager.destroyPipelineLayout(pipelineLayout); + resourceManager.destroy(pipeline); + resourceManager.destroy(pipelineLayout); } void will_engine::environment_pipeline::EnvironmentPipeline::draw(VkCommandBuffer cmd, const EnvironmentDrawInfo& drawInfo) const @@ -108,7 +108,7 @@ void will_engine::environment_pipeline::EnvironmentPipeline::draw(VkCommandBuffe void will_engine::environment_pipeline::EnvironmentPipeline::createPipeline() { - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipeline); VkShaderModule vertShader = resourceManager.createShaderModule("shaders/environment/environment.vert"); VkShaderModule fragShader = resourceManager.createShaderModule("shaders/environment/environment.frag"); @@ -125,6 +125,6 @@ void will_engine::environment_pipeline::EnvironmentPipeline::createPipeline() pipeline = resourceManager.createRenderPipeline(pipelineBuilder); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(fragShader); + resourceManager.destroy(vertShader); + resourceManager.destroy(fragShader); } diff --git a/src/renderer/pipelines/geometry/terrain/terrain_pipeline.cpp b/src/renderer/pipelines/geometry/terrain/terrain_pipeline.cpp index cb112f2f..c7622226 100644 --- a/src/renderer/pipelines/geometry/terrain/terrain_pipeline.cpp +++ b/src/renderer/pipelines/geometry/terrain/terrain_pipeline.cpp @@ -39,9 +39,9 @@ will_engine::terrain::TerrainPipeline::TerrainPipeline(ResourceManager& resource will_engine::terrain::TerrainPipeline::~TerrainPipeline() { - resourceManager.destroyPipelineLayout(pipelineLayout); - resourceManager.destroyPipeline(pipeline); - resourceManager.destroyPipeline(linePipeline); + resourceManager.destroy(pipelineLayout); + resourceManager.destroy(pipeline); + resourceManager.destroy(linePipeline); } void will_engine::terrain::TerrainPipeline::draw(VkCommandBuffer cmd, const TerrainDrawInfo& drawInfo) const @@ -143,7 +143,7 @@ void will_engine::terrain::TerrainPipeline::draw(VkCommandBuffer cmd, const Terr void will_engine::terrain::TerrainPipeline::createPipeline() { - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipeline); VkShaderModule vertShader = resourceManager.createShaderModule("shaders/terrain/terrain.vert"); VkShaderModule tescShader = resourceManager.createShaderModule("shaders/terrain/terrain.tesc"); VkShaderModule teseShader = resourceManager.createShaderModule("shaders/terrain/terrain.tese"); @@ -189,15 +189,15 @@ void will_engine::terrain::TerrainPipeline::createPipeline() pipelineBuilder.setupTessellation(4); pipeline = resourceManager.createRenderPipeline(pipelineBuilder, {VK_DYNAMIC_STATE_DEPTH_BIAS}); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(tescShader); - resourceManager.destroyShaderModule(teseShader); - resourceManager.destroyShaderModule(fragShader); + resourceManager.destroy(vertShader); + resourceManager.destroy(tescShader); + resourceManager.destroy(teseShader); + resourceManager.destroy(fragShader); } void will_engine::terrain::TerrainPipeline::createLinePipeline() { - resourceManager.destroyPipeline(linePipeline); + resourceManager.destroy(linePipeline); VkShaderModule vertShader = resourceManager.createShaderModule("shaders/terrain/terrain.vert"); VkShaderModule tescShader = resourceManager.createShaderModule("shaders/terrain/terrain.tesc"); VkShaderModule teseShader = resourceManager.createShaderModule("shaders/terrain/terrain.tese"); @@ -243,8 +243,8 @@ void will_engine::terrain::TerrainPipeline::createLinePipeline() pipelineBuilder.setupTessellation(4); linePipeline = resourceManager.createRenderPipeline(pipelineBuilder, {VK_DYNAMIC_STATE_DEPTH_BIAS}); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(tescShader); - resourceManager.destroyShaderModule(teseShader); - resourceManager.destroyShaderModule(fragShader); + resourceManager.destroy(vertShader); + resourceManager.destroy(tescShader); + resourceManager.destroy(teseShader); + resourceManager.destroy(fragShader); } diff --git a/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp b/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp index 9b1ab184..c860bef5 100644 --- a/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp +++ b/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp @@ -101,15 +101,15 @@ TransparentPipeline::TransparentPipeline(ResourceManager& resourceManager, TransparentPipeline::~TransparentPipeline() { - resourceManager.destroyImage(accumulationImage); - resourceManager.destroyImage(revealageImage); - resourceManager.destroyImage(debugImage); - resourceManager.destroyPipelineLayout(accumulationPipelineLayout); - resourceManager.destroyPipeline(accumulationPipeline); - resourceManager.destroyDescriptorSetLayout(compositeDescriptorSetLayout); - resourceManager.destroyPipelineLayout(compositePipelineLayout); - resourceManager.destroyPipeline(compositePipeline); - resourceManager.destroyDescriptorBuffer(compositeDescriptorBuffer); + resourceManager.destroy(accumulationImage); + resourceManager.destroy(revealageImage); + resourceManager.destroy(debugImage); + resourceManager.destroy(accumulationPipelineLayout); + resourceManager.destroy(accumulationPipeline); + resourceManager.destroy(compositeDescriptorSetLayout); + resourceManager.destroy(compositePipelineLayout); + resourceManager.destroy(compositePipeline); + resourceManager.destroy(compositeDescriptorBuffer); } void TransparentPipeline::drawAccumulate(VkCommandBuffer cmd, const TransparentAccumulateDrawInfo& drawInfo) const @@ -297,7 +297,7 @@ void TransparentPipeline::drawComposite(VkCommandBuffer cmd, const TransparentCo void TransparentPipeline::createAccumulationPipeline() { - resourceManager.destroyPipeline(accumulationPipeline); + resourceManager.destroy(accumulationPipeline); VkShaderModule vertShader = resourceManager.createShaderModule("shaders/transparent.vert"); VkShaderModule fragShader = resourceManager.createShaderModule("shaders/transparent.frag"); @@ -372,13 +372,13 @@ void TransparentPipeline::createAccumulationPipeline() pipelineBuilder.setupPipelineLayout(accumulationPipelineLayout); accumulationPipeline = resourceManager.createRenderPipeline(pipelineBuilder); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(fragShader); + resourceManager.destroy(vertShader); + resourceManager.destroy(fragShader); } void TransparentPipeline::createCompositePipeline() { - resourceManager.destroyPipeline(compositePipeline); + resourceManager.destroy(compositePipeline); VkShaderModule vertShader = resourceManager.createShaderModule("shaders/transparentComposite.vert"); VkShaderModule fragShader = resourceManager.createShaderModule("shaders/transparentComposite.frag"); @@ -406,7 +406,7 @@ void TransparentPipeline::createCompositePipeline() pipelineBuilder.setupPipelineLayout(compositePipelineLayout); compositePipeline = resourceManager.createRenderPipeline(pipelineBuilder); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(fragShader); + resourceManager.destroy(vertShader); + resourceManager.destroy(fragShader); } } diff --git a/src/renderer/pipelines/post/post_process/post_process_pipeline.cpp b/src/renderer/pipelines/post/post_process/post_process_pipeline.cpp index 33c10344..1788eccd 100644 --- a/src/renderer/pipelines/post/post_process/post_process_pipeline.cpp +++ b/src/renderer/pipelines/post/post_process/post_process_pipeline.cpp @@ -47,10 +47,10 @@ will_engine::post_process_pipeline::PostProcessPipeline::PostProcessPipeline(Res will_engine::post_process_pipeline::PostProcessPipeline::~PostProcessPipeline() { - resourceManager.destroyPipeline(pipeline); - resourceManager.destroyPipelineLayout(pipelineLayout); - resourceManager.destroyDescriptorSetLayout(descriptorSetLayout); - resourceManager.destroyDescriptorBuffer(descriptorBuffer); + resourceManager.destroy(pipeline); + resourceManager.destroy(pipelineLayout); + resourceManager.destroy(descriptorSetLayout); + resourceManager.destroy(descriptorBuffer); } void will_engine::post_process_pipeline::PostProcessPipeline::setupDescriptorBuffer(const PostProcessDescriptor& bufferInfo) @@ -113,7 +113,7 @@ void will_engine::post_process_pipeline::PostProcessPipeline::draw(VkCommandBuff void will_engine::post_process_pipeline::PostProcessPipeline::createPipeline() { - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipeline); VkShaderModule computeShader = resourceManager.createShaderModule("shaders/postProcess.comp"); VkPipelineShaderStageCreateInfo stageInfo{}; @@ -131,5 +131,5 @@ void will_engine::post_process_pipeline::PostProcessPipeline::createPipeline() pipelineInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; pipeline = resourceManager.createComputePipeline(pipelineInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } diff --git a/src/renderer/pipelines/post/temporal_antialiasing/temporal_antialiasing_pipeline.cpp b/src/renderer/pipelines/post/temporal_antialiasing/temporal_antialiasing_pipeline.cpp index 54521d61..0ed7a2b2 100644 --- a/src/renderer/pipelines/post/temporal_antialiasing/temporal_antialiasing_pipeline.cpp +++ b/src/renderer/pipelines/post/temporal_antialiasing/temporal_antialiasing_pipeline.cpp @@ -47,10 +47,10 @@ will_engine::temporal_antialiasing_pipeline::TemporalAntialiasingPipeline::Tempo will_engine::temporal_antialiasing_pipeline::TemporalAntialiasingPipeline::~TemporalAntialiasingPipeline() { - resourceManager.destroyPipeline(pipeline); - resourceManager.destroyPipelineLayout(pipelineLayout); - resourceManager.destroyDescriptorSetLayout(descriptorSetLayout); - resourceManager.destroyDescriptorBuffer(descriptorBuffer); + resourceManager.destroy(pipeline); + resourceManager.destroy(pipelineLayout); + resourceManager.destroy(descriptorSetLayout); + resourceManager.destroy(descriptorBuffer); } void will_engine::temporal_antialiasing_pipeline::TemporalAntialiasingPipeline::setupDescriptorBuffer(const TemporalAntialiasingDescriptor& descriptor) @@ -134,7 +134,7 @@ void will_engine::temporal_antialiasing_pipeline::TemporalAntialiasingPipeline:: void will_engine::temporal_antialiasing_pipeline::TemporalAntialiasingPipeline::createPipeline() { - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipeline); VkShaderModule computeShader = resourceManager.createShaderModule("shaders/taa.comp"); VkPipelineShaderStageCreateInfo stageInfo{}; @@ -152,5 +152,5 @@ void will_engine::temporal_antialiasing_pipeline::TemporalAntialiasingPipeline:: pipelineInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; pipeline = resourceManager.createComputePipeline(pipelineInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } diff --git a/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp b/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp index 36b5623f..41f59e33 100644 --- a/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp +++ b/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp @@ -143,22 +143,22 @@ will_engine::cascaded_shadows::CascadedShadowMap::CascadedShadowMap(ResourceMana will_engine::cascaded_shadows::CascadedShadowMap::~CascadedShadowMap() { for (CascadeShadowMapData& cascadeShadowMapData : shadowMaps) { - resourceManager.destroyImage(cascadeShadowMapData.depthShadowMap); + resourceManager.destroy(cascadeShadowMapData.depthShadowMap); cascadeShadowMapData.depthShadowMap = {}; } - resourceManager.destroyDescriptorSetLayout(cascadedShadowMapUniformLayout); - resourceManager.destroyDescriptorSetLayout(cascadedShadowMapSamplerLayout); + resourceManager.destroy(cascadedShadowMapUniformLayout); + resourceManager.destroy(cascadedShadowMapSamplerLayout); for (int32_t i = 0; i < FRAME_OVERLAP; ++i) { - resourceManager.destroyBuffer(cascadedShadowMapDatas[i]); + resourceManager.destroy(cascadedShadowMapDatas[i]); } - resourceManager.destroyDescriptorBuffer(cascadedShadowMapDescriptorBufferSampler); - resourceManager.destroyDescriptorBuffer(cascadedShadowMapDescriptorBufferUniform); - resourceManager.destroySampler(sampler); - resourceManager.destroyPipeline(renderObjectPipeline); - resourceManager.destroyPipelineLayout(renderObjectPipelineLayout); - resourceManager.destroyPipeline(terrainPipeline); - resourceManager.destroyPipelineLayout(terrainPipelineLayout); + resourceManager.destroy(cascadedShadowMapDescriptorBufferSampler); + resourceManager.destroy(cascadedShadowMapDescriptorBufferUniform); + resourceManager.destroy(sampler); + resourceManager.destroy(renderObjectPipeline); + resourceManager.destroy(renderObjectPipelineLayout); + resourceManager.destroy(terrainPipeline); + resourceManager.destroy(terrainPipelineLayout); } void will_engine::cascaded_shadows::CascadedShadowMap::update(const DirectionalLight& mainLight, const Camera* camera, @@ -421,7 +421,7 @@ glm::mat4 will_engine::cascaded_shadows::CascadedShadowMap::getLightSpaceMatrix( void will_engine::cascaded_shadows::CascadedShadowMap::createRenderObjectPipeline() { - resourceManager.destroyPipeline(renderObjectPipeline); + resourceManager.destroy(renderObjectPipeline); VkShaderModule vertShader = resourceManager.createShaderModule("shaders/shadows/shadow_pass.vert"); VkShaderModule fragShader = resourceManager.createShaderModule("shaders/shadows/shadow_pass.frag"); @@ -451,13 +451,13 @@ void will_engine::cascaded_shadows::CascadedShadowMap::createRenderObjectPipelin pipelineBuilder.setupPipelineLayout(renderObjectPipelineLayout); renderObjectPipeline = resourceManager.createRenderPipeline(pipelineBuilder, {VK_DYNAMIC_STATE_DEPTH_BIAS}); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(fragShader); + resourceManager.destroy(vertShader); + resourceManager.destroy(fragShader); } void will_engine::cascaded_shadows::CascadedShadowMap::createTerrainPipeline() { - resourceManager.destroyPipeline(terrainPipeline); + resourceManager.destroy(terrainPipeline); VkShaderModule vertShader = resourceManager.createShaderModule("shaders/shadows/terrain_shadow_pass.vert"); VkShaderModule tescShader = resourceManager.createShaderModule("shaders/shadows/terrain_shadow_pass.tesc"); @@ -490,10 +490,10 @@ void will_engine::cascaded_shadows::CascadedShadowMap::createTerrainPipeline() pipelineBuilder.setupTessellation(4); terrainPipeline = resourceManager.createRenderPipeline(pipelineBuilder, {VK_DYNAMIC_STATE_DEPTH_BIAS}); - resourceManager.destroyShaderModule(vertShader); - resourceManager.destroyShaderModule(tescShader); - resourceManager.destroyShaderModule(teseShader); - resourceManager.destroyShaderModule(fragShader); + resourceManager.destroy(vertShader); + resourceManager.destroy(tescShader); + resourceManager.destroy(teseShader); + resourceManager.destroy(fragShader); } void will_engine::cascaded_shadows::CascadedShadowMap::generateSplits() diff --git a/src/renderer/pipelines/shadows/contact_shadow/contact_shadows_pipeline.cpp b/src/renderer/pipelines/shadows/contact_shadow/contact_shadows_pipeline.cpp index 16c359d6..751b2897 100644 --- a/src/renderer/pipelines/shadows/contact_shadow/contact_shadows_pipeline.cpp +++ b/src/renderer/pipelines/shadows/contact_shadow/contact_shadows_pipeline.cpp @@ -79,15 +79,15 @@ ContactShadowsPipeline::ContactShadowsPipeline(ResourceManager& resourceManager) ContactShadowsPipeline::~ContactShadowsPipeline() { - resourceManager.destroyPipeline(pipeline); - resourceManager.destroyPipelineLayout(pipelineLayout); - resourceManager.destroyDescriptorSetLayout(descriptorSetLayout); + resourceManager.destroy(pipeline); + resourceManager.destroy(pipelineLayout); + resourceManager.destroy(descriptorSetLayout); - resourceManager.destroySampler(depthSampler); + resourceManager.destroy(depthSampler); - resourceManager.destroyImage(contactShadowImage); - resourceManager.destroyImage(debugImage); - resourceManager.destroyDescriptorBuffer(descriptorBufferSampler); + resourceManager.destroy(contactShadowImage); + resourceManager.destroy(debugImage); + resourceManager.destroy(descriptorBufferSampler); } void ContactShadowsPipeline::setupDescriptorBuffer(const VkImageView& depthImageView) @@ -154,7 +154,7 @@ void ContactShadowsPipeline::draw(VkCommandBuffer cmd, const ContactShadowsDrawI void ContactShadowsPipeline::createPipeline() { - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipeline); VkShaderModule computeShader = resourceManager.createShaderModule("shaders/shadows/contact_shadow_pass.comp"); VkPipelineShaderStageCreateInfo stageInfo{}; @@ -172,7 +172,7 @@ void ContactShadowsPipeline::createPipeline() pipelineInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; pipeline = resourceManager.createComputePipeline(pipelineInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } DispatchList ContactShadowsPipeline::buildDispatchList(const Camera* camera, const DirectionalLight& mainLight) diff --git a/src/renderer/pipelines/shadows/ground_truth_ambient_occlusion/ground_truth_ambient_occlusion_pipeline.cpp b/src/renderer/pipelines/shadows/ground_truth_ambient_occlusion/ground_truth_ambient_occlusion_pipeline.cpp index 080d707e..9ac5e28b 100644 --- a/src/renderer/pipelines/shadows/ground_truth_ambient_occlusion/ground_truth_ambient_occlusion_pipeline.cpp +++ b/src/renderer/pipelines/shadows/ground_truth_ambient_occlusion/ground_truth_ambient_occlusion_pipeline.cpp @@ -226,42 +226,42 @@ will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::GroundTruth will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::~GroundTruthAmbientOcclusionPipeline() { // Debug Resources - resourceManager.destroyImage(debugImage); + resourceManager.destroy(debugImage); // Depth Prefilter Resources - resourceManager.destroyDescriptorSetLayout(depthPrefilterSetLayout); - resourceManager.destroyPipelineLayout(depthPrefilterPipelineLayout); - resourceManager.destroyPipeline(depthPrefilterPipeline); + resourceManager.destroy(depthPrefilterSetLayout); + resourceManager.destroy(depthPrefilterPipelineLayout); + resourceManager.destroy(depthPrefilterPipeline); for (int32_t i = 0; i < DEPTH_PREFILTER_MIP_COUNT; ++i) { - resourceManager.destroyImageView(depthPrefilterImageViews[i]); + resourceManager.destroy(depthPrefilterImageViews[i]); } - resourceManager.destroyImage(depthPrefilterImage); - resourceManager.destroySampler(depthSampler); + resourceManager.destroy(depthPrefilterImage); + resourceManager.destroy(depthSampler); - resourceManager.destroyDescriptorBuffer(depthPrefilterDescriptorBuffer); + resourceManager.destroy(depthPrefilterDescriptorBuffer); // AO Resources - resourceManager.destroyDescriptorSetLayout(ambientOcclusionSetLayout); - resourceManager.destroyPipelineLayout(ambientOcclusionPipelineLayout); - resourceManager.destroyPipeline(ambientOcclusionPipeline); + resourceManager.destroy(ambientOcclusionSetLayout); + resourceManager.destroy(ambientOcclusionPipelineLayout); + resourceManager.destroy(ambientOcclusionPipeline); - resourceManager.destroySampler(depthPrefilterSampler); - resourceManager.destroySampler(normalsSampler); - resourceManager.destroyImage(ambientOcclusionImage); - resourceManager.destroyImage(edgeDataImage); + resourceManager.destroy(depthPrefilterSampler); + resourceManager.destroy(normalsSampler); + resourceManager.destroy(ambientOcclusionImage); + resourceManager.destroy(edgeDataImage); - resourceManager.destroyDescriptorBuffer(ambientOcclusionDescriptorBuffer); + resourceManager.destroy(ambientOcclusionDescriptorBuffer); // Spatial Filtering Resources - resourceManager.destroyDescriptorSetLayout(spatialFilteringSetLayout); - resourceManager.destroyPipelineLayout(spatialFilteringPipelineLayout); - resourceManager.destroyPipeline(spatialFilteringPipeline); + resourceManager.destroy(spatialFilteringSetLayout); + resourceManager.destroy(spatialFilteringPipelineLayout); + resourceManager.destroy(spatialFilteringPipeline); - resourceManager.destroyImage(denoisedFinalAO); + resourceManager.destroy(denoisedFinalAO); - resourceManager.destroyDescriptorBuffer(spatialFilteringDescriptorBuffer); + resourceManager.destroy(spatialFilteringDescriptorBuffer); } void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::setupDepthPrefilterDescriptorBuffer(const VkImageView& depthImageView) @@ -488,7 +488,7 @@ void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::reload void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::createDepthPrefilterPipeline() { - resourceManager.destroyPipeline(depthPrefilterPipeline); + resourceManager.destroy(depthPrefilterPipeline); VkShaderModule computeShader = resourceManager.createShaderModule("shaders/ambient_occlusion/ground_truth/gtao_depth_prefilter.comp"); VkPipelineShaderStageCreateInfo stageInfo{}; @@ -506,12 +506,12 @@ void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::create pipelineInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; depthPrefilterPipeline = resourceManager.createComputePipeline(pipelineInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::createAmbientOcclusionPipeline() { - resourceManager.destroyPipeline(ambientOcclusionPipeline); + resourceManager.destroy(ambientOcclusionPipeline); VkShaderModule computeShader = resourceManager.createShaderModule("shaders/ambient_occlusion/ground_truth/gtao_main_pass.comp"); VkPipelineShaderStageCreateInfo stageInfo{}; @@ -529,12 +529,12 @@ void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::create pipelineInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; ambientOcclusionPipeline = resourceManager.createComputePipeline(pipelineInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::createSpatialFilteringPipeline() { - resourceManager.destroyPipeline(spatialFilteringPipeline); + resourceManager.destroy(spatialFilteringPipeline); VkShaderModule computeShader = resourceManager.createShaderModule("shaders/ambient_occlusion/ground_truth/gtao_spatial_filter.comp"); VkPipelineShaderStageCreateInfo stageInfo{}; @@ -552,5 +552,5 @@ void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::create pipelineInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; spatialFilteringPipeline = resourceManager.createComputePipeline(pipelineInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } diff --git a/src/renderer/pipelines/visibility_pass/visibility_pass_pipeline.cpp b/src/renderer/pipelines/visibility_pass/visibility_pass_pipeline.cpp index d2c3223c..acc31761 100644 --- a/src/renderer/pipelines/visibility_pass/visibility_pass_pipeline.cpp +++ b/src/renderer/pipelines/visibility_pass/visibility_pass_pipeline.cpp @@ -39,8 +39,8 @@ will_engine::visibility_pass_pipeline::VisibilityPassPipeline::VisibilityPassPip will_engine::visibility_pass_pipeline::VisibilityPassPipeline::~VisibilityPassPipeline() { - resourceManager.destroyPipeline(pipeline); - resourceManager.destroyPipelineLayout(pipelineLayout); + resourceManager.destroy(pipeline); + resourceManager.destroy(pipelineLayout); } void will_engine::visibility_pass_pipeline::VisibilityPassPipeline::draw(VkCommandBuffer cmd, const VisibilityPassDrawInfo& drawInfo) const @@ -97,7 +97,7 @@ void will_engine::visibility_pass_pipeline::VisibilityPassPipeline::draw(VkComma void will_engine::visibility_pass_pipeline::VisibilityPassPipeline::createPipeline() { - resourceManager.destroyPipeline(pipeline); + resourceManager.destroy(pipeline); VkShaderModule computeShader = resourceManager.createShaderModule("shaders/visibility_pass.comp"); VkPipelineShaderStageCreateInfo stageInfo{}; @@ -115,5 +115,5 @@ void will_engine::visibility_pass_pipeline::VisibilityPassPipeline::createPipeli pipelineInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; pipeline = resourceManager.createComputePipeline(pipelineInfo); - resourceManager.destroyShaderModule(computeShader); + resourceManager.destroy(computeShader); } diff --git a/src/renderer/renderer_constants.h b/src/renderer/renderer_constants.h index 711b08b0..375f4361 100644 --- a/src/renderer/renderer_constants.h +++ b/src/renderer/renderer_constants.h @@ -20,6 +20,7 @@ constexpr float RENDER_EXTENT_HEIGHT{RENDER_EXTENTS.height}; constexpr VkFormat DRAW_FORMAT{VK_FORMAT_R16G16B16A16_SFLOAT}; constexpr VkFormat DEPTH_FORMAT{VK_FORMAT_D32_SFLOAT}; constexpr VkFormat VELOCITY_FORMAT{VK_FORMAT_R16G16_SFLOAT}; +constexpr VkFormat DEBUG_FORMAT{VK_FORMAT_R8G8B8A8_SNORM}; constexpr bool NORMAL_REMAP{true}; constexpr VkFormat NORMAL_FORMAT = NORMAL_REMAP ? VK_FORMAT_A2R10G10B10_UNORM_PACK32 : VK_FORMAT_R16G16B16A16_SNORM; diff --git a/src/renderer/resource_manager.cpp b/src/renderer/resource_manager.cpp index dd74bd47..0381054c 100644 --- a/src/renderer/resource_manager.cpp +++ b/src/renderer/resource_manager.cpp @@ -168,19 +168,19 @@ will_engine::ResourceManager::~ResourceManager() { if (context.device == VK_NULL_HANDLE) { return; } - destroyImage(whiteImage); - destroyImage(errorCheckerboardImage); - destroySampler(defaultSamplerNearest); - destroySampler(defaultSamplerLinear); - destroySampler(defaultSamplerMipMappedLinear); - destroyDescriptorSetLayout(emptyDescriptorSetLayout); - destroyDescriptorSetLayout(sceneDataLayout); - destroyDescriptorSetLayout(frustumCullLayout); - destroyDescriptorSetLayout(addressesLayout); - destroyDescriptorSetLayout(texturesLayout); - destroyDescriptorSetLayout(renderTargetsLayout); - destroyDescriptorSetLayout(terrainTexturesLayout); - destroyDescriptorSetLayout(terrainUniformLayout); + destroy(whiteImage); + destroy(errorCheckerboardImage); + destroy(defaultSamplerNearest); + destroy(defaultSamplerLinear); + destroy(defaultSamplerMipMappedLinear); + destroy(emptyDescriptorSetLayout); + destroy(sceneDataLayout); + destroy(frustumCullLayout); + destroy(addressesLayout); + destroy(texturesLayout); + destroy(renderTargetsLayout); + destroy(terrainTexturesLayout); + destroy(terrainUniformLayout); flushDestructionQueue(); } @@ -425,7 +425,7 @@ VkDeviceAddress will_engine::ResourceManager::getBufferAddress(const AllocatedBu return srcPtr; } -void will_engine::ResourceManager::destroyBufferImmediate(AllocatedBuffer& buffer) const +void will_engine::ResourceManager::destroyImmediate(AllocatedBuffer& buffer) const { if (buffer.buffer == VK_NULL_HANDLE) { return; } vmaDestroyBuffer(context.allocator, buffer.buffer, buffer.allocation); @@ -433,7 +433,7 @@ void will_engine::ResourceManager::destroyBufferImmediate(AllocatedBuffer& buffe buffer.allocation = VK_NULL_HANDLE; } -void will_engine::ResourceManager::destroyBuffer(AllocatedBuffer& buffer) +void will_engine::ResourceManager::destroy(AllocatedBuffer& buffer) { if (buffer.buffer == VK_NULL_HANDLE) { return; } destructionQueues[lastKnownFrameOverlap].bufferQueue.push_back({buffer.buffer, buffer.allocation}); @@ -538,7 +538,7 @@ AllocatedImage will_engine::ResourceManager::createImage(const void* data, const } }); - destroyBufferImmediate(uploadbuffer); + destroyImmediate(uploadbuffer); return newImage; } @@ -568,8 +568,9 @@ AllocatedImage will_engine::ResourceManager::createCubemap(const VkExtent3D size return newImage; } -void will_engine::ResourceManager::destroyImage(AllocatedImage& image) +void will_engine::ResourceManager::destroy(AllocatedImage& image) { + if (image.image == VK_NULL_HANDLE) { return; } destructionQueues[lastKnownFrameOverlap].imageQueue.push_back({image.image, image.allocation}); destructionQueues[lastKnownFrameOverlap].imageViewQueue.push_back(image.imageView); image.image = VK_NULL_HANDLE; @@ -579,7 +580,7 @@ void will_engine::ResourceManager::destroyImage(AllocatedImage& image) image.imageFormat = {}; } -void will_engine::ResourceManager::destroySampler(VkSampler sampler) +void will_engine::ResourceManager::destroy(VkSampler sampler) { destructionQueues[lastKnownFrameOverlap].samplerQueue.push_back(sampler); sampler = VK_NULL_HANDLE; @@ -609,9 +610,9 @@ int32_t will_engine::ResourceManager::setupDescriptorBufferUniform(DescriptorBuf return descriptorBuffer.setupData(context.device, uniformBuffers, index); } -void will_engine::ResourceManager::destroyDescriptorBuffer(DescriptorBuffer& descriptorBuffer) +void will_engine::ResourceManager::destroy(DescriptorBuffer& descriptorBuffer) { - destroyBuffer(descriptorBuffer.getBuffer()); + destroy(descriptorBuffer.getBuffer()); } VkShaderModule will_engine::ResourceManager::createShaderModule(const std::filesystem::path& path) const @@ -700,7 +701,7 @@ VkShaderModule will_engine::ResourceManager::createShaderModule(const std::files return shaderModule; } -void will_engine::ResourceManager::destroyShaderModule(VkShaderModule& shaderModule) const +void will_engine::ResourceManager::destroy(VkShaderModule& shaderModule) const { vkDestroyShaderModule(context.device, shaderModule, nullptr); shaderModule = VK_NULL_HANDLE; @@ -713,7 +714,7 @@ VkPipelineLayout will_engine::ResourceManager::createPipelineLayout(const VkPipe return pipelineLayout; } -void will_engine::ResourceManager::destroyPipelineLayout(VkPipelineLayout pipelineLayout) +void will_engine::ResourceManager::destroy(VkPipelineLayout pipelineLayout) { if (pipelineLayout == VK_NULL_HANDLE) { return; } destructionQueues[lastKnownFrameOverlap].pipelineLayoutQueue.push_back(pipelineLayout); @@ -734,7 +735,7 @@ VkPipeline will_engine::ResourceManager::createComputePipeline(const VkComputePi return computePipeline; } -void will_engine::ResourceManager::destroyPipeline(VkPipeline pipeline) +void will_engine::ResourceManager::destroy(VkPipeline pipeline) { if (pipeline == VK_NULL_HANDLE) { return; } destructionQueues[lastKnownFrameOverlap].pipelineQueue.push_back(pipeline); @@ -748,7 +749,7 @@ VkDescriptorSetLayout will_engine::ResourceManager::createDescriptorSetLayout(De return layoutBuilder.build(context.device, shaderStageFlags, nullptr, layoutCreateFlags); } -void will_engine::ResourceManager::destroyDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) +void will_engine::ResourceManager::destroy(VkDescriptorSetLayout descriptorSetLayout) { if (descriptorSetLayout == VK_NULL_HANDLE) { return; } destructionQueues[lastKnownFrameOverlap].descriptorSetLayoutQueue.push_back(descriptorSetLayout); @@ -762,7 +763,7 @@ VkImageView will_engine::ResourceManager::createImageView(const VkImageViewCreat return imageView; } -void will_engine::ResourceManager::destroyImageView(VkImageView imageView) +void will_engine::ResourceManager::destroy(VkImageView imageView) { if (imageView == VK_NULL_HANDLE) { return; } destructionQueues[lastKnownFrameOverlap].imageViewQueue.push_back(imageView); diff --git a/src/renderer/resource_manager.h b/src/renderer/resource_manager.h index 660460e5..4aa1fcd3 100644 --- a/src/renderer/resource_manager.h +++ b/src/renderer/resource_manager.h @@ -102,9 +102,9 @@ class ResourceManager * \n should not be used otherwise, as the buffer may be destroyed before it is used. * @param buffer */ - void destroyBufferImmediate(AllocatedBuffer& buffer) const; + void destroyImmediate(AllocatedBuffer& buffer) const; - void destroyBuffer(AllocatedBuffer& buffer); + void destroy(AllocatedBuffer& buffer); public: // VkBuffer Helpers void copyBufferImmediate(const AllocatedBuffer& src, const AllocatedBuffer& dst, VkDeviceSize size) const; @@ -123,7 +123,7 @@ class ResourceManager public: // Samplers [[nodiscard]] VkSampler createSampler(const VkSamplerCreateInfo& createInfo) const; - void destroySampler(VkSampler sampler); + void destroy(VkSampler sampler); public: // VkImage and VkImageView [[nodiscard]] AllocatedImage createImage(const VkImageCreateInfo& createInfo) const; @@ -135,7 +135,7 @@ class ResourceManager [[nodiscard]] AllocatedImage createCubemap(VkExtent3D size, VkFormat format, VkImageUsageFlags usage, bool mipmapped = false) const; - void destroyImage(AllocatedImage& image); + void destroy(AllocatedImage& image); public: // Descriptor Buffer [[nodiscard]] DescriptorBufferSampler createDescriptorBufferSampler(VkDescriptorSetLayout layout, int32_t maxObjectCount) const; @@ -148,7 +148,7 @@ class ResourceManager int32_t setupDescriptorBufferUniform(DescriptorBufferUniform& descriptorBuffer, const std::vector& uniformBuffers, int index = -1) const; - void destroyDescriptorBuffer(DescriptorBuffer& descriptorBuffer); + void destroy(DescriptorBuffer& descriptorBuffer); public: // Shader Module VkShaderModule createShaderModule(const std::filesystem::path& path) const; @@ -157,30 +157,30 @@ class ResourceManager * As far as I know shader modules don't need to defer destroyed, since it's used to construct the pipeline (without `ImmediateSubmitter`) * @param shaderModule */ - void destroyShaderModule(VkShaderModule& shaderModule) const; + void destroy(VkShaderModule& shaderModule) const; public: // Pipeline Layout VkPipelineLayout createPipelineLayout(const VkPipelineLayoutCreateInfo& createInfo) const; - void destroyPipelineLayout(VkPipelineLayout pipelineLayout); + void destroy(VkPipelineLayout pipelineLayout); public: // Pipelines VkPipeline createRenderPipeline(PipelineBuilder& builder, const std::vector& additionalDynamicStates = {}) const; VkPipeline createComputePipeline(const VkComputePipelineCreateInfo& pipelineInfo) const; - void destroyPipeline(VkPipeline pipeline); + void destroy(VkPipeline pipeline); public: // Descriptor Set Layout VkDescriptorSetLayout createDescriptorSetLayout(DescriptorLayoutBuilder& layoutBuilder, VkShaderStageFlagBits shaderStageFlags, VkDescriptorSetLayoutCreateFlagBits layoutCreateFlags) const; - void destroyDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout); + void destroy(VkDescriptorSetLayout descriptorSetLayout); public: // Image View VkImageView createImageView(const VkImageViewCreateInfo& viewInfo) const; - void destroyImageView(VkImageView imageView); + void destroy(VkImageView imageView); public: [[nodiscard]] VkSampler getDefaultSamplerLinear() const { return defaultSamplerLinear; } diff --git a/src/renderer/terrain/terrain_chunk.cpp b/src/renderer/terrain/terrain_chunk.cpp index 5bb05dd9..617dfbe5 100644 --- a/src/renderer/terrain/terrain_chunk.cpp +++ b/src/renderer/terrain/terrain_chunk.cpp @@ -40,7 +40,7 @@ TerrainChunk::TerrainChunk(ResourceManager& resourceManager, const std::vector& heightData) diff --git a/src/renderer/vk_helpers.cpp b/src/renderer/vk_helpers.cpp index 7574d63e..a132f9ab 100644 --- a/src/renderer/vk_helpers.cpp +++ b/src/renderer/vk_helpers.cpp @@ -640,7 +640,7 @@ void will_engine::vk_helpers::saveImageRGBA32F(const ResourceManager& resourceMa stbi_write_png(savePath, image.imageExtent.width, image.imageExtent.height, 4, byteImageData, image.imageExtent.width * 4); delete[] byteImageData; - resourceManager.destroyBufferImmediate(receivingBuffer); + resourceManager.destroyImmediate(receivingBuffer); } void will_engine::vk_helpers::saveImageRGBA16SFLOAT(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, @@ -690,7 +690,7 @@ void will_engine::vk_helpers::saveImageRGBA16SFLOAT(const ResourceManager& resou stbi_write_png(savePath, image.imageExtent.width, image.imageExtent.height, 4, byteImageData, image.imageExtent.width * 4); delete[] byteImageData; - resourceManager.destroyBufferImmediate(receivingBuffer); + resourceManager.destroyImmediate(receivingBuffer); } void will_engine::vk_helpers::savePacked32Bit(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, @@ -735,7 +735,7 @@ void will_engine::vk_helpers::savePacked32Bit(const ResourceManager& resourceMan stbi_write_png(savePath, image.imageExtent.width, image.imageExtent.height, 4, byteImageData, image.imageExtent.width * 4); delete[] byteImageData; - resourceManager.destroyBufferImmediate(receivingBuffer); + resourceManager.destroyImmediate(receivingBuffer); } void will_engine::vk_helpers::savePacked64Bit(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, @@ -780,7 +780,7 @@ void will_engine::vk_helpers::savePacked64Bit(const ResourceManager& resourceMan stbi_write_png(savePath, image.imageExtent.width, image.imageExtent.height, 4, byteImageData, image.imageExtent.width * 4); delete[] byteImageData; - resourceManager.destroyBufferImmediate(receivingBuffer); + resourceManager.destroyImmediate(receivingBuffer); } void will_engine::vk_helpers::saveImageR32F(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, @@ -828,7 +828,7 @@ void will_engine::vk_helpers::saveImageR32F(const ResourceManager& resourceManag stbi_write_png(savePath, static_cast(newXSize), static_cast(newYSize), 4, byteImageData, static_cast(newXSize) * 4); delete[] byteImageData; - resourceManager.destroyBufferImmediate(receivingBuffer); + resourceManager.destroyImmediate(receivingBuffer); } void will_engine::vk_helpers::saveImageR16F(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, @@ -879,7 +879,7 @@ void will_engine::vk_helpers::saveImageR16F(const ResourceManager& resourceManag stbi_write_png(savePath, static_cast(newXSize), static_cast(newYSize), 4, byteImageData, static_cast(newXSize) * 4); delete[] byteImageData; - resourceManager.destroyBufferImmediate(receivingBuffer); + resourceManager.destroyImmediate(receivingBuffer); } void will_engine::vk_helpers::saveImageR8UNORM(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, @@ -925,7 +925,7 @@ void will_engine::vk_helpers::saveImageR8UNORM(const ResourceManager& resourceMa stbi_write_png(savePath, static_cast(width), static_cast(height), 4, byteImageData, static_cast(width) * 4); delete[] byteImageData; - resourceManager.destroyBufferImmediate(receivingBuffer); + resourceManager.destroyImmediate(receivingBuffer); } void will_engine::vk_helpers::saveImageR8G8B8A8UNORM(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, @@ -972,7 +972,7 @@ void will_engine::vk_helpers::saveImageR8G8B8A8UNORM(const ResourceManager& reso stbi_write_png(savePath, static_cast(width), static_cast(height), 4, byteImageData, static_cast(width) * 4); delete[] byteImageData; - resourceManager.destroyBufferImmediate(receivingBuffer); + resourceManager.destroyImmediate(receivingBuffer); } void will_engine::vk_helpers::saveImage(const std::vector& imageData, int width, int height, std::filesystem::path filename, From ac925d60b0a88a834dc97d3cdec2edf6539e3ece Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Sun, 4 May 2025 17:41:36 +0700 Subject: [PATCH 17/24] Mesh highlighter WIP3. --- assets/settings.willengine | 14 +++++++------- shaders/debug/debug_highlighter.frag | 5 +++++ shaders/debug/debug_highlighter.vert | 6 ++++++ src/core/engine.cpp | 10 ++++++++-- src/core/engine.h | 8 +++++++- src/renderer/imgui_wrapper.cpp | 4 ++-- .../pipelines/debug/debug_highlighter.cpp | 15 ++++++++------- src/renderer/pipelines/debug/debug_renderer.cpp | 4 ++-- 8 files changed, 45 insertions(+), 21 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index 0dc93afe..1fda02a7 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -48.649864196777344, - 40.66029739379883, - 0.20613041520118713 + 29.101533889770508, + 39.091552734375, + 3.8559868335723877 ], "rotation": [ - 0.045760832726955414, - -0.6482749581336975, - -0.039084888994693756, - -0.7590243220329285 + 0.04926401004195213, + -0.7643494009971619, + -0.0588165745139122, + -0.6402215361595154 ], "fov": 1.3089969158172607, "aspectRatio": 1.7777777910232544, diff --git a/shaders/debug/debug_highlighter.frag b/shaders/debug/debug_highlighter.frag index e45ea7e1..59de6425 100644 --- a/shaders/debug/debug_highlighter.frag +++ b/shaders/debug/debug_highlighter.frag @@ -1,4 +1,9 @@ #version 460 +layout (location = 0) in vec3 inColor; + +layout (location = 0) out vec4 imageTarget; + void main() { + imageTarget = vec4(inColor, 1.0); } diff --git a/shaders/debug/debug_highlighter.vert b/shaders/debug/debug_highlighter.vert index 48fd7c94..0ef23564 100644 --- a/shaders/debug/debug_highlighter.vert +++ b/shaders/debug/debug_highlighter.vert @@ -4,12 +4,18 @@ layout(location = 0) in vec3 inPosition; +layout(location = 0) out vec3 outColor; + // layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl layout (push_constant) uniform PushConstants { mat4 modelMatrix; + vec4 color; } push; void main() { gl_Position = sceneData.viewProj * push.modelMatrix * vec4(inPosition, 1.0); + // fixed depth offset so that the whole object can be seen in most cases + gl_Position.z += 0.001; + outColor = push.color.xyz; } \ No newline at end of file diff --git a/src/core/engine.cpp b/src/core/engine.cpp index f1b06f40..d8133aa8 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -765,6 +765,12 @@ void Engine::render(float deltaTime) debugRenderer->draw(cmd, debugRendererDrawInfo); + if (IComponentContainer* cc = dynamic_cast(selectedItem)) { + if (components::MeshRendererComponent* meshRenderer = cc->getComponent()) { + debugHighlighter->draw(cmd, meshRenderer, debugTarget.imageView, depthImage.imageView); + } + } + vk_helpers::transitionImage(cmd, debugTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); @@ -936,7 +942,7 @@ void Engine::cleanup() SDL_DestroyWindow(window); } -IHierarchical* Engine::createGameObject(Map* map, const std::string& name) const +IHierarchical* Engine::createGameObject(Map* map, const std::string& name) { const auto newGameObject = new GameObject(name); map->addGameObject(newGameObject); @@ -1159,7 +1165,7 @@ void Engine::createDrawResources() usageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; usageFlags |= VK_IMAGE_USAGE_SAMPLED_BIT; usageFlags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; - const VkImageCreateInfo imageCreateInfo = vk_helpers::imageCreateInfo(DRAW_FORMAT, usageFlags, imageExtent); + const VkImageCreateInfo imageCreateInfo = vk_helpers::imageCreateInfo(DEBUG_FORMAT, usageFlags, imageExtent); debugTarget = resourceManager->createImage(imageCreateInfo); #endif } diff --git a/src/core/engine.h b/src/core/engine.h index eb06c9fa..80b2c128 100644 --- a/src/core/engine.h +++ b/src/core/engine.h @@ -149,7 +149,13 @@ class Engine void cleanup(); public: - [[nodiscard]] IHierarchical* createGameObject(Map* map, const std::string& name) const; + /** + * Creates a gameobject as a child of the map parameter + * @param map + * @param name + * @return + */ + [[nodiscard]] static IHierarchical* createGameObject(Map* map, const std::string& name); void addToBeginQueue(IHierarchical* obj); diff --git a/src/renderer/imgui_wrapper.cpp b/src/renderer/imgui_wrapper.cpp index 470c05b3..e2a9c97e 100644 --- a/src/renderer/imgui_wrapper.cpp +++ b/src/renderer/imgui_wrapper.cpp @@ -892,7 +892,7 @@ void ImguiWrapper::imguiInterface(Engine* engine) } else { if (ImGui::Button("Add to Scene")) { - IHierarchical* gob = engine->createGameObject(selectedMap, objectName); + IHierarchical* gob = Engine::createGameObject(selectedMap, objectName); if (auto _container = dynamic_cast(gob)) { auto newComponent = components::ComponentFactory::getInstance().createComponent( @@ -1279,7 +1279,7 @@ void ImguiWrapper::drawSceneGraph(Engine* engine) if (ImGui::BeginTabItem("Scene Graph")) { if (ImGui::Button("Create Game Object")) { static int32_t incrementId{0}; - [[maybe_unused]] IHierarchical* gameObject = engine->createGameObject(selectedMap, fmt::format("New GameObject_{}", incrementId++)); + [[maybe_unused]] IHierarchical* gameObject = Engine::createGameObject(selectedMap, fmt::format("New GameObject_{}", incrementId++)); } ImGui::Separator(); if (!selectedMap->getChildren().empty()) { diff --git a/src/renderer/pipelines/debug/debug_highlighter.cpp b/src/renderer/pipelines/debug/debug_highlighter.cpp index ce3cc1f5..67e9f265 100644 --- a/src/renderer/pipelines/debug/debug_highlighter.cpp +++ b/src/renderer/pipelines/debug/debug_highlighter.cpp @@ -36,7 +36,6 @@ DebugHighlighter::DebugHighlighter(ResourceManager& resourceManager) : resourceM DebugHighlighter::~DebugHighlighter() { - resourceManager.destroy(pipelineLayout); resourceManager.destroy(pipeline); resourceManager.destroy(debugHighlightStencil); @@ -45,11 +44,11 @@ DebugHighlighter::~DebugHighlighter() void DebugHighlighter::draw(VkCommandBuffer cmd, IRenderable* highlightTarget, VkImageView debugTarget, VkImageView depthTarget) const { if (IRenderReference* renderRef = highlightTarget->getRenderReference()) { - const std::optional> meshData = renderRef->getMeshData(highlightTarget->getMeshIndex()); + const std::optional > meshData = renderRef->getMeshData(highlightTarget->getMeshIndex()); if (!meshData.has_value()) { return; } const VkRenderingAttachmentInfo imageAttachment = vk_helpers::attachmentInfo(debugTarget, nullptr, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); const VkRenderingAttachmentInfo depthAttachment = vk_helpers::attachmentInfo(depthTarget, nullptr, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL); @@ -69,7 +68,7 @@ void DebugHighlighter::draw(VkCommandBuffer cmd, IRenderable* highlightTarget, V vkCmdBeginRendering(cmd, &renderInfo); - vkCmdSetLineWidth(cmd, 1.0f); + vkCmdSetLineWidth(cmd, 2.0f); // Viewport VkViewport viewport = {}; @@ -107,6 +106,8 @@ void DebugHighlighter::draw(VkCommandBuffer cmd, IRenderable* highlightTarget, V // Draw this mesh w/ vkCmdDrawIndexed w/ model matrix passed through push vkCmdDrawIndexed(cmd, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); } + + vkCmdEndRendering(cmd); } } @@ -130,12 +131,12 @@ void DebugHighlighter::createPipeline() renderPipelineBuilder.setupVertexInput(&vertexBinding, 1, vertexAttributes.data(), 1); renderPipelineBuilder.setShaders(vertShader, fragShader); - renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_LINE_LIST); + renderPipelineBuilder.setupInputAssembly(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST); renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); - renderPipelineBuilder.disableDepthTest(); - renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED); + renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); + renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, VK_FORMAT_D32_SFLOAT, VK_FORMAT_UNDEFINED); renderPipelineBuilder.setupPipelineLayout(pipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); diff --git a/src/renderer/pipelines/debug/debug_renderer.cpp b/src/renderer/pipelines/debug/debug_renderer.cpp index a68bdd27..1c20b216 100644 --- a/src/renderer/pipelines/debug/debug_renderer.cpp +++ b/src/renderer/pipelines/debug/debug_renderer.cpp @@ -352,7 +352,7 @@ void DebugRenderer::createPipeline() renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); - renderPipelineBuilder.setupRenderer({ALBEDO_FORMAT}, DEPTH_FORMAT); + renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, DEPTH_FORMAT); renderPipelineBuilder.setupPipelineLayout(instancedPipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; instancedLinePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); @@ -391,7 +391,7 @@ void DebugRenderer::createPipeline() renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); - renderPipelineBuilder.setupRenderer({ALBEDO_FORMAT}, DEPTH_FORMAT); + renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, DEPTH_FORMAT); renderPipelineBuilder.setupPipelineLayout(normalPipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; linePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); From 93cf181fc384c7c7dc50a88dff7290df86746b2d Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Mon, 5 May 2025 21:48:35 +0700 Subject: [PATCH 18/24] Debug highlighter outputs to a stencil buffer. --- assets/settings.willengine | 14 +-- src/core/engine.cpp | 56 ++++++----- src/core/engine.h | 7 +- src/renderer/imgui_wrapper.cpp | 15 ++- src/renderer/lighting/directional_light.h | 1 + .../pipelines/debug/debug_highlighter.cpp | 27 ++++-- .../pipelines/debug/debug_highlighter.h | 6 +- .../pipelines/debug/debug_renderer_types.h | 4 +- .../cascaded_shadow_map.cpp | 4 +- src/renderer/renderer_constants.h | 3 +- src/renderer/resource_manager.cpp | 11 ++- src/renderer/resource_manager.h | 2 +- src/renderer/vk_helpers.cpp | 97 +++++++++++++++++++ src/renderer/vk_helpers.h | 4 + 14 files changed, 199 insertions(+), 52 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index 1fda02a7..8d3602d1 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - 29.101533889770508, - 39.091552734375, - 3.8559868335723877 + -16.31094741821289, + 60.820003509521484, + 33.037052154541016 ], "rotation": [ - 0.04926401004195213, - -0.7643494009971619, - -0.0588165745139122, - -0.6402215361595154 + 0.20286287367343903, + 0.349800169467926, + 0.0778701901435852, + -0.9112753868103027 ], "fov": 1.3089969158172607, "aspectRatio": 1.7777777910232544, diff --git a/src/core/engine.cpp b/src/core/engine.cpp index d8133aa8..8018dfc4 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -225,16 +225,16 @@ void Engine::initRenderer() postProcessPipeline = new post_process_pipeline::PostProcessPipeline(*resourceManager); startupProfiler.addEntry("Init PP Pass"); - ambientOcclusionPipeline->setupDepthPrefilterDescriptorBuffer(depthImage.imageView); + ambientOcclusionPipeline->setupDepthPrefilterDescriptorBuffer(depthImageView); ambientOcclusionPipeline->setupAmbientOcclusionDescriptorBuffer(normalRenderTarget.imageView); ambientOcclusionPipeline->setupSpatialFilteringDescriptorBuffer(); - contactShadowsPipeline->setupDescriptorBuffer(depthImage.imageView); + contactShadowsPipeline->setupDescriptorBuffer(depthImageView); const deferred_resolve::DeferredResolveDescriptor deferredResolveDescriptor{ normalRenderTarget.imageView, albedoRenderTarget.imageView, pbrRenderTarget.imageView, - depthImage.imageView, + depthImageView, velocityRenderTarget.imageView, ambientOcclusionPipeline->getAmbientOcclusionRenderTarget().imageView, contactShadowsPipeline->getContactShadowRenderTarget().imageView, @@ -246,7 +246,7 @@ void Engine::initRenderer() const temporal_antialiasing_pipeline::TemporalAntialiasingDescriptor temporalAntialiasingDescriptor{ drawImage.imageView, historyBuffer.imageView, - depthImage.imageView, + depthImageView, velocityRenderTarget.imageView, taaResolveTarget.imageView, resourceManager->getDefaultSamplerLinear() @@ -551,8 +551,8 @@ void Engine::render(float deltaTime) vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, drawImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); - vk_helpers::transitionImage(cmd, depthImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, - VK_IMAGE_ASPECT_DEPTH_BIT); + vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + DEPTH_STENCIL_ASPECT_FLAG); vk_helpers::transitionImage(cmd, normalRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); vk_helpers::transitionImage(cmd, albedoRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, @@ -568,7 +568,7 @@ void Engine::render(float deltaTime) albedoRenderTarget.imageView, pbrRenderTarget.imageView, velocityRenderTarget.imageView, - depthImage.imageView, + depthImageView, sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap, environmentMap->getCubemapDescriptorBuffer().getDescriptorBufferBindingInfo(), @@ -598,7 +598,7 @@ void Engine::render(float deltaTime) albedoRenderTarget.imageView, pbrRenderTarget.imageView, velocityRenderTarget.imageView, - depthImage.imageView, + depthImageView, sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap }; @@ -613,7 +613,7 @@ void Engine::render(float deltaTime) albedoRenderTarget.imageView, pbrRenderTarget.imageView, velocityRenderTarget.imageView, - depthImage.imageView, + depthImageView, sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap }; @@ -629,7 +629,7 @@ void Engine::render(float deltaTime) albedoRenderTarget.imageView, pbrRenderTarget.imageView, velocityRenderTarget.imageView, - depthImage.imageView, + depthImageView, sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), sceneDataDescriptorBuffer.getDescriptorBufferSize() * FRAME_OVERLAP }; @@ -638,7 +638,7 @@ void Engine::render(float deltaTime) transparent_pipeline::TransparentAccumulateDrawInfo transparentDrawInfo{ true, - depthImage.imageView, + depthImageView, currentFrameOverlap, allRenderObjects, sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), @@ -661,8 +661,8 @@ void Engine::render(float deltaTime) VK_IMAGE_ASPECT_COLOR_BIT); vk_helpers::transitionImage(cmd, velocityRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, depthImage.image, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - VK_IMAGE_ASPECT_DEPTH_BIT); + vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + DEPTH_STENCIL_ASPECT_FLAG); vk_helpers::transitionImage(cmd, drawImage.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); ambient_occlusion::GTAODrawInfo gtaoDrawInfo{ @@ -751,14 +751,14 @@ void Engine::render(float deltaTime) if (bDrawDebugRendering) { vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, debugTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, {0.0f, 0.0f, 0.0f, 0.0f}); - vk_helpers::transitionImage(cmd, depthImage.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, - VK_IMAGE_ASPECT_DEPTH_BIT); + vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + DEPTH_STENCIL_ASPECT_FLAG); debug_renderer::DebugRendererDrawInfo debugRendererDrawInfo{ currentFrameOverlap, debugTarget.imageView, - depthImage.imageView, + depthImageView, sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap }; @@ -767,7 +767,7 @@ void Engine::render(float deltaTime) if (IComponentContainer* cc = dynamic_cast(selectedItem)) { if (components::MeshRendererComponent* meshRenderer = cc->getComponent()) { - debugHighlighter->draw(cmd, meshRenderer, debugTarget.imageView, depthImage.imageView); + debugHighlighter->draw(cmd, meshRenderer, debugTarget.imageView, depthStencilImage.imageView); } } @@ -892,7 +892,9 @@ void Engine::cleanup() } resourceManager->destroy(drawImage); - resourceManager->destroy(depthImage); + resourceManager->destroy(depthStencilImage); + resourceManager->destroy(depthImageView); + resourceManager->destroy(stencilImageView); resourceManager->destroy(normalRenderTarget); resourceManager->destroy(albedoRenderTarget); resourceManager->destroy(pbrRenderTarget); @@ -1043,22 +1045,28 @@ void Engine::createDrawResources() } // Depth Image { - depthImage.imageFormat = DEPTH_FORMAT; + depthStencilImage.imageFormat = DEPTH_FORMAT; constexpr VkExtent3D depthImageExtent = {RENDER_EXTENTS.width, RENDER_EXTENTS.height, 1}; - depthImage.imageExtent = depthImageExtent; + depthStencilImage.imageExtent = depthImageExtent; VkImageUsageFlags depthImageUsages{}; depthImageUsages |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; depthImageUsages |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; depthImageUsages |= VK_IMAGE_USAGE_SAMPLED_BIT; - VkImageCreateInfo depthImageInfo = vk_helpers::imageCreateInfo(depthImage.imageFormat, depthImageUsages, depthImageExtent); + VkImageCreateInfo depthImageInfo = vk_helpers::imageCreateInfo(depthStencilImage.imageFormat, depthImageUsages, depthImageExtent); VmaAllocationCreateInfo depthImageAllocationInfo = {}; depthImageAllocationInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; depthImageAllocationInfo.requiredFlags = static_cast(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); - vmaCreateImage(context->allocator, &depthImageInfo, &depthImageAllocationInfo, &depthImage.image, &depthImage.allocation, nullptr); + vmaCreateImage(context->allocator, &depthImageInfo, &depthImageAllocationInfo, &depthStencilImage.image, &depthStencilImage.allocation, nullptr); - VkImageViewCreateInfo depthViewInfo = vk_helpers::imageviewCreateInfo(depthImage.imageFormat, depthImage.image, VK_IMAGE_ASPECT_DEPTH_BIT); - VK_CHECK(vkCreateImageView(context->device, &depthViewInfo, nullptr, &depthImage.imageView)); + VkImageViewCreateInfo combinedViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, DEPTH_STENCIL_ASPECT_FLAG); + VK_CHECK(vkCreateImageView(context->device, &combinedViewInfo, nullptr, &depthStencilImage.imageView)); + + VkImageViewCreateInfo depthViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, VK_IMAGE_ASPECT_DEPTH_BIT); + VK_CHECK(vkCreateImageView(context->device, &depthViewInfo, nullptr, &depthImageView)); + + VkImageViewCreateInfo stencilViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, VK_IMAGE_ASPECT_STENCIL_BIT); + VK_CHECK(vkCreateImageView(context->device, &stencilViewInfo, nullptr, &stencilImageView)); } // Render Targets { diff --git a/src/core/engine.h b/src/core/engine.h index 80b2c128..f32d4d1c 100644 --- a/src/core/engine.h +++ b/src/core/engine.h @@ -288,7 +288,12 @@ class Engine private: // Draw Resources AllocatedImage drawImage{}; - AllocatedImage depthImage{}; + /** + * Image view in this depth image is VK_IMAGE_ASPECT_DEPTH_BIT + */ + AllocatedImage depthStencilImage{}; + VkImageView depthImageView{VK_NULL_HANDLE}; + VkImageView stencilImageView{VK_NULL_HANDLE}; /** * 8.8.8 View Normals - 8 unused diff --git a/src/renderer/imgui_wrapper.cpp b/src/renderer/imgui_wrapper.cpp index e2a9c97e..23952c60 100644 --- a/src/renderer/imgui_wrapper.cpp +++ b/src/renderer/imgui_wrapper.cpp @@ -12,6 +12,7 @@ #include "environment/environment.h" +#include "pipelines/debug/debug_highlighter.h" #include "pipelines/post/post_process/post_process_pipeline_types.h" #include "pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.h" #include "pipelines/shadows/ground_truth_ambient_occlusion/ambient_occlusion_types.h" @@ -656,7 +657,7 @@ void ImguiWrapper::imguiInterface(Engine* engine) return (2.0f * zNear) / (zFar + zNear - d * (zFar - zNear)); }; - vk_helpers::saveImageR32F(*engine->resourceManager, *engine->immediate, engine->depthImage, + vk_helpers::saveImageR32F(*engine->resourceManager, *engine->immediate, engine->depthStencilImage, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT, path.string().c_str(), depthNormalize); } @@ -1221,6 +1222,18 @@ void ImguiWrapper::imguiInterface(Engine* engine) if (ImGui::Begin("Discardable Debug")) { ImGui::Checkbox("Draw Debug Render", &engine->bDrawDebugRendering); + + ImGui::Separator(); + if (ImGui::Button("Save Stencil Debug Draw")) { + if (file::getOrCreateDirectory(file::imagesSavePath)) { + const std::filesystem::path path = file::imagesSavePath / "debugStencil.png"; + vk_helpers::saveStencilBuffer(*engine->resourceManager, *engine->immediate, engine->depthStencilImage, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, path.string().c_str()); + } + else { + fmt::print(" Failed to find/create image save path directory"); + } + } } ImGui::End(); diff --git a/src/renderer/lighting/directional_light.h b/src/renderer/lighting/directional_light.h index f82ad4fb..80957c65 100644 --- a/src/renderer/lighting/directional_light.h +++ b/src/renderer/lighting/directional_light.h @@ -36,6 +36,7 @@ class DirectionalLight DirectionalLightData getData() const { return {direction, intensity, color}; } + // todo: remove friend void ImguiWrapper::imguiInterface(Engine* engine); private: diff --git a/src/renderer/pipelines/debug/debug_highlighter.cpp b/src/renderer/pipelines/debug/debug_highlighter.cpp index 67e9f265..39f42b60 100644 --- a/src/renderer/pipelines/debug/debug_highlighter.cpp +++ b/src/renderer/pipelines/debug/debug_highlighter.cpp @@ -38,10 +38,9 @@ DebugHighlighter::~DebugHighlighter() { resourceManager.destroy(pipelineLayout); resourceManager.destroy(pipeline); - resourceManager.destroy(debugHighlightStencil); } -void DebugHighlighter::draw(VkCommandBuffer cmd, IRenderable* highlightTarget, VkImageView debugTarget, VkImageView depthTarget) const +void DebugHighlighter::draw(VkCommandBuffer cmd, IRenderable* highlightTarget, VkImageView debugTarget, VkImageView depthStencilTarget) const { if (IRenderReference* renderRef = highlightTarget->getRenderReference()) { const std::optional > meshData = renderRef->getMeshData(highlightTarget->getMeshIndex()); @@ -49,8 +48,13 @@ void DebugHighlighter::draw(VkCommandBuffer cmd, IRenderable* highlightTarget, V const VkRenderingAttachmentInfo imageAttachment = vk_helpers::attachmentInfo(debugTarget, nullptr, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); - const VkRenderingAttachmentInfo depthAttachment = vk_helpers::attachmentInfo(depthTarget, nullptr, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL); + const VkRenderingAttachmentInfo depthAttachment = vk_helpers::attachmentInfo(depthStencilTarget, nullptr, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); + + VkClearValue stencilClear{}; + stencilClear.depthStencil = {0.0f, 0}; + const VkRenderingAttachmentInfo stencilAttachment = vk_helpers::attachmentInfo(depthStencilTarget, &stencilClear, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); VkRenderingInfo renderInfo{}; renderInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO; @@ -64,7 +68,7 @@ void DebugHighlighter::draw(VkCommandBuffer cmd, IRenderable* highlightTarget, V renderInfo.colorAttachmentCount = 1; renderInfo.pColorAttachments = renderAttachments; renderInfo.pDepthAttachment = &depthAttachment; - renderInfo.pStencilAttachment = nullptr; + renderInfo.pStencilAttachment = &stencilAttachment; vkCmdBeginRendering(cmd, &renderInfo); @@ -135,8 +139,17 @@ void DebugHighlighter::createPipeline() renderPipelineBuilder.setupRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE); renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); - renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); - renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, VK_FORMAT_D32_SFLOAT, VK_FORMAT_UNDEFINED); + constexpr VkStencilOpState stencilOp = { + VK_STENCIL_OP_REPLACE, + VK_STENCIL_OP_REPLACE, + VK_STENCIL_OP_REPLACE, + VK_COMPARE_OP_ALWAYS, + 0xff, + 0xff, + 1 + }; + renderPipelineBuilder.setupDepthStencil(VK_TRUE, VK_TRUE, VK_COMPARE_OP_GREATER_OR_EQUAL, VK_FALSE, VK_TRUE, stencilOp, stencilOp, 0.0f, 1.0f); + renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, DEPTH_FORMAT, DEPTH_FORMAT); renderPipelineBuilder.setupPipelineLayout(pipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); diff --git a/src/renderer/pipelines/debug/debug_highlighter.h b/src/renderer/pipelines/debug/debug_highlighter.h index 994ce9c8..70757320 100644 --- a/src/renderer/pipelines/debug/debug_highlighter.h +++ b/src/renderer/pipelines/debug/debug_highlighter.h @@ -7,6 +7,7 @@ #include +#include "src/renderer/imgui_wrapper.h" #include "src/renderer/resource_manager.h" namespace will_engine @@ -28,7 +29,7 @@ class DebugHighlighter { ~DebugHighlighter(); - void draw(VkCommandBuffer cmd, IRenderable* highlightTarget, VkImageView debugTarget, VkImageView depthTarget) const; + void draw(VkCommandBuffer cmd, IRenderable* highlightTarget, VkImageView debugTarget, VkImageView depthStencilTarget) const; void reloadShaders() { createPipeline(); } @@ -41,7 +42,8 @@ class DebugHighlighter { VkPipelineLayout pipelineLayout{VK_NULL_HANDLE}; VkPipeline pipeline{VK_NULL_HANDLE}; - AllocatedImage debugHighlightStencil{VK_NULL_HANDLE}; + // todo: remove + friend void ImguiWrapper::imguiInterface(Engine* engine); }; } diff --git a/src/renderer/pipelines/debug/debug_renderer_types.h b/src/renderer/pipelines/debug/debug_renderer_types.h index 1c8bb737..e844e884 100644 --- a/src/renderer/pipelines/debug/debug_renderer_types.h +++ b/src/renderer/pipelines/debug/debug_renderer_types.h @@ -90,8 +90,8 @@ struct DebugRendererInstance struct DebugRendererDrawInfo { int32_t currentFrameOverlap{}; - VkImageView debugTarget; - VkImageView depthTarget; + VkImageView debugTarget{VK_NULL_HANDLE}; + VkImageView depthTarget{VK_NULL_HANDLE}; VkDescriptorBufferBindingInfoEXT sceneDataBinding{}; VkDeviceSize sceneDataOffset{0}; }; diff --git a/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp b/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp index 41f59e33..5b753335 100644 --- a/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp +++ b/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp @@ -447,7 +447,7 @@ void will_engine::cascaded_shadows::CascadedShadowMap::createRenderObjectPipelin pipelineBuilder.disableMultisampling(); pipelineBuilder.disableBlending(); pipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_LESS_OR_EQUAL); - pipelineBuilder.setupRenderer({}, DEPTH_FORMAT); + pipelineBuilder.setupRenderer({}, CASCADE_DEPTH_FORMAT); pipelineBuilder.setupPipelineLayout(renderObjectPipelineLayout); renderObjectPipeline = resourceManager.createRenderPipeline(pipelineBuilder, {VK_DYNAMIC_STATE_DEPTH_BIAS}); @@ -485,7 +485,7 @@ void will_engine::cascaded_shadows::CascadedShadowMap::createTerrainPipeline() pipelineBuilder.disableMultisampling(); pipelineBuilder.disableBlending(); pipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_LESS_OR_EQUAL); - pipelineBuilder.setupRenderer({}, DEPTH_FORMAT); + pipelineBuilder.setupRenderer({}, CASCADE_DEPTH_FORMAT); pipelineBuilder.setupPipelineLayout(terrainPipelineLayout); pipelineBuilder.setupTessellation(4); diff --git a/src/renderer/renderer_constants.h b/src/renderer/renderer_constants.h index 375f4361..cf78606e 100644 --- a/src/renderer/renderer_constants.h +++ b/src/renderer/renderer_constants.h @@ -18,7 +18,8 @@ constexpr VkExtent2D RENDER_EXTENTS{1920, 1080}; constexpr float RENDER_EXTENT_WIDTH{RENDER_EXTENTS.width}; constexpr float RENDER_EXTENT_HEIGHT{RENDER_EXTENTS.height}; constexpr VkFormat DRAW_FORMAT{VK_FORMAT_R16G16B16A16_SFLOAT}; -constexpr VkFormat DEPTH_FORMAT{VK_FORMAT_D32_SFLOAT}; +constexpr VkFormat DEPTH_FORMAT{VK_FORMAT_D32_SFLOAT_S8_UINT}; +constexpr VkImageAspectFlags DEPTH_STENCIL_ASPECT_FLAG{VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT}; constexpr VkFormat VELOCITY_FORMAT{VK_FORMAT_R16G16_SFLOAT}; constexpr VkFormat DEBUG_FORMAT{VK_FORMAT_R8G8B8A8_SNORM}; diff --git a/src/renderer/resource_manager.cpp b/src/renderer/resource_manager.cpp index 0381054c..3c30a72c 100644 --- a/src/renderer/resource_manager.cpp +++ b/src/renderer/resource_manager.cpp @@ -461,7 +461,7 @@ AllocatedImage will_engine::ResourceManager::createImage(const VkImageCreateInfo // allocate and create the image VK_CHECK(vmaCreateImage(context.allocator, &createInfo, &allocInfo, &newImage.image, &newImage.allocation, nullptr)); - const VkImageAspectFlags aspectFlag = createInfo.format == VK_FORMAT_D32_SFLOAT ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT; + const VkImageAspectFlags aspectFlag = createInfo.format == VK_FORMAT_D32_SFLOAT || createInfo.format == VK_FORMAT_D32_SFLOAT_S8_UINT ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT; // build an image-view for the image VkImageViewCreateInfo view_info = vk_helpers::imageviewCreateInfo(createInfo.format, newImage.image, aspectFlag); @@ -473,7 +473,7 @@ AllocatedImage will_engine::ResourceManager::createImage(const VkImageCreateInfo } AllocatedImage will_engine::ResourceManager::createImage(const VkExtent3D size, const VkFormat format, const VkImageUsageFlags usage, - const bool mipmapped) const + const bool mipmapped, VkImageAspectFlagBits aspectFlag) const { AllocatedImage newImage{}; newImage.imageFormat = format; @@ -491,10 +491,13 @@ AllocatedImage will_engine::ResourceManager::createImage(const VkExtent3D size, // allocate and create the image VK_CHECK(vmaCreateImage(context.allocator, &imgInfo, &allocinfo, &newImage.image, &newImage.allocation, nullptr)); - const VkImageAspectFlags aspectFlag = format == VK_FORMAT_D32_SFLOAT ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT; + VkImageAspectFlags targetAspect = aspectFlag; + if (targetAspect == VK_IMAGE_ASPECT_NONE) { + targetAspect = format == VK_FORMAT_D32_SFLOAT || format == VK_FORMAT_D32_SFLOAT_S8_UINT ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT; + } // build a image-view for the image - VkImageViewCreateInfo view_info = vk_helpers::imageviewCreateInfo(format, newImage.image, aspectFlag); + VkImageViewCreateInfo view_info = vk_helpers::imageviewCreateInfo(format, newImage.image, targetAspect); view_info.subresourceRange.levelCount = imgInfo.mipLevels; VK_CHECK(vkCreateImageView(context.device, &view_info, nullptr, &newImage.imageView)); diff --git a/src/renderer/resource_manager.h b/src/renderer/resource_manager.h index 4aa1fcd3..6c4dc258 100644 --- a/src/renderer/resource_manager.h +++ b/src/renderer/resource_manager.h @@ -128,7 +128,7 @@ class ResourceManager public: // VkImage and VkImageView [[nodiscard]] AllocatedImage createImage(const VkImageCreateInfo& createInfo) const; - [[nodiscard]] AllocatedImage createImage(VkExtent3D size, VkFormat format, VkImageUsageFlags usage, bool mipmapped = false) const; + [[nodiscard]] AllocatedImage createImage(VkExtent3D size, VkFormat format, VkImageUsageFlags usage, bool mipmapped = false, VkImageAspectFlagBits aspectFlag = VK_IMAGE_ASPECT_NONE) const; [[nodiscard]] AllocatedImage createImage(const void* data, size_t dataSize, VkExtent3D size, VkFormat format, VkImageUsageFlags usage, bool mipmapped = false) const; diff --git a/src/renderer/vk_helpers.cpp b/src/renderer/vk_helpers.cpp index a132f9ab..587a3b52 100644 --- a/src/renderer/vk_helpers.cpp +++ b/src/renderer/vk_helpers.cpp @@ -928,6 +928,103 @@ void will_engine::vk_helpers::saveImageR8UNORM(const ResourceManager& resourceMa resourceManager.destroyImmediate(receivingBuffer); } +void will_engine::vk_helpers::saveImageR8UINT(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, + const AllocatedImage& image, VkImageLayout imageLayout, const char* savePath, VkImageAspectFlagBits aspectFlag, int32_t mipLevel) +{ + const size_t width = image.imageExtent.width / static_cast(std::pow(2, mipLevel)); + const size_t height = image.imageExtent.height / static_cast(std::pow(2, mipLevel)); + const size_t texelCount = width * height; + const size_t dataSize = texelCount * 1 * sizeof(uint8_t); + + AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); + + immediate.submit([&, mipLevel](VkCommandBuffer cmd) { + VkBufferImageCopy bufferCopyRegion{}; + bufferCopyRegion.imageSubresource.aspectMask = aspectFlag; + bufferCopyRegion.imageSubresource.mipLevel = mipLevel; + bufferCopyRegion.imageSubresource.baseArrayLayer = 0; + bufferCopyRegion.imageSubresource.layerCount = 1; + bufferCopyRegion.imageExtent = {static_cast(width), static_cast(height), 1u}; + bufferCopyRegion.bufferOffset = 0; + bufferCopyRegion.bufferRowLength = 0; + bufferCopyRegion.bufferImageHeight = 0; + + transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectFlag); + + vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); + + transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, aspectFlag); + }); + + void* data = receivingBuffer.info.pMappedData; + const auto imageData = static_cast(data); + + const auto byteImageData = new uint8_t[texelCount * 4]; + for (size_t i = 0; i < texelCount; ++i) { + const auto value = imageData[i]; + byteImageData[i * 4 + 0] = value; + byteImageData[i * 4 + 1] = value; + byteImageData[i * 4 + 2] = value; + byteImageData[i * 4 + 3] = 255; + } + + stbi_write_png(savePath, static_cast(width), static_cast(height), 4, byteImageData, static_cast(width) * 4); + + delete[] byteImageData; + resourceManager.destroyImmediate(receivingBuffer); +} + +void will_engine::vk_helpers::saveStencilBuffer(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, + const AllocatedImage& depthStencilImage, VkImageLayout imageLayout, const char* savePath) +{ + const size_t width = depthStencilImage.imageExtent.width; + const size_t height = depthStencilImage.imageExtent.height; + const size_t texelCount = width * height; + const size_t dataSize = texelCount * sizeof(uint8_t); + + AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); + + immediate.submit([&](VkCommandBuffer cmd) { + VkBufferImageCopy bufferCopyRegion{}; + bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; + bufferCopyRegion.imageSubresource.mipLevel = 0; + bufferCopyRegion.imageSubresource.baseArrayLayer = 0; + bufferCopyRegion.imageSubresource.layerCount = 1; + bufferCopyRegion.imageExtent = {static_cast(width), static_cast(height), 1u}; + bufferCopyRegion.bufferOffset = 0; + bufferCopyRegion.bufferRowLength = 0; + bufferCopyRegion.bufferImageHeight = 0; + + transitionImage(cmd, depthStencilImage.image, imageLayout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + DEPTH_STENCIL_ASPECT_FLAG); + + vkCmdCopyImageToBuffer(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + receivingBuffer.buffer, 1, &bufferCopyRegion); + + // Transition back + transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, imageLayout, + DEPTH_STENCIL_ASPECT_FLAG); + }); + + void* data = receivingBuffer.info.pMappedData; + const auto stencilData = static_cast(data); + + // Convert to RGBA for PNG output + const auto byteImageData = new uint8_t[texelCount * 4]; + for (size_t i = 0; i < texelCount; ++i) { + const auto value = stencilData[i]; + byteImageData[i * 4 + 0] = value * 255.0f; + byteImageData[i * 4 + 1] = value * 255.0f; + byteImageData[i * 4 + 2] = value * 255.0f; + byteImageData[i * 4 + 3] = 255; + } + + stbi_write_png(savePath, static_cast(width), static_cast(height), 4, byteImageData, static_cast(width) * 4); + + delete[] byteImageData; + resourceManager.destroyImmediate(receivingBuffer); +} + void will_engine::vk_helpers::saveImageR8G8B8A8UNORM(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, VkImageLayout imageLayout, const char* savePath, int32_t mipLevel) { diff --git a/src/renderer/vk_helpers.h b/src/renderer/vk_helpers.h index 853fee11..db2ed34f 100644 --- a/src/renderer/vk_helpers.h +++ b/src/renderer/vk_helpers.h @@ -134,6 +134,10 @@ namespace vk_helpers void saveImageR8UNORM(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, VkImageLayout imageLayout, const char* savePath, int32_t mipLevel = 0); + void saveImageR8UINT(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, + VkImageLayout imageLayout, const char* savePath, VkImageAspectFlagBits aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT, int32_t mipLevel = 0); + void saveStencilBuffer(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, + const AllocatedImage& depthStencilImage, VkImageLayout imageLayout, const char* savePath); void saveImageR8G8B8A8UNORM(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, VkImageLayout imageLayout, const char* savePath, int32_t mipLevel = 0); From b821fd853a0c830d1035023ff876a7cc600a8507 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Mon, 5 May 2025 21:53:37 +0700 Subject: [PATCH 19/24] Render constants cleanup. --- src/core/engine.cpp | 14 +++++++------- .../basic/basic_render/basic_render_pipeline.cpp | 2 +- .../pipelines/debug/debug_highlighter.cpp | 2 +- src/renderer/pipelines/debug/debug_renderer.cpp | 4 ++-- .../deferred_mrt/deferred_mrt_pipeline.cpp | 2 +- .../environment/environment_pipeline.cpp | 2 +- .../geometry/terrain/terrain_pipeline.cpp | 4 ++-- .../transparent_pipeline.cpp | 2 +- src/renderer/renderer_constants.h | 16 ++++++++++++---- src/renderer/vk_helpers.cpp | 4 ++-- 10 files changed, 30 insertions(+), 22 deletions(-) diff --git a/src/core/engine.cpp b/src/core/engine.cpp index 8018dfc4..6d4b9e41 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -24,8 +24,8 @@ #include "src/renderer/assets/render_object/render_object.h" #include "src/renderer/descriptor_buffer/descriptor_buffer_uniform.h" #include "src/renderer/environment/environment.h" -#include "../renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.h" -#include "../renderer/pipelines/debug/debug_renderer.h" +#include "src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.h" +#include "src/renderer/pipelines/debug/debug_renderer.h" #include "src/renderer/pipelines/debug/debug_composite_pipeline.h" #include "src/renderer/pipelines/debug/debug_highlighter.h" #include "src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.h" @@ -552,7 +552,7 @@ void Engine::render(float deltaTime) vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, drawImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - DEPTH_STENCIL_ASPECT_FLAG); + VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); vk_helpers::transitionImage(cmd, normalRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); vk_helpers::transitionImage(cmd, albedoRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, @@ -662,7 +662,7 @@ void Engine::render(float deltaTime) vk_helpers::transitionImage(cmd, velocityRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - DEPTH_STENCIL_ASPECT_FLAG); + VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); vk_helpers::transitionImage(cmd, drawImage.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); ambient_occlusion::GTAODrawInfo gtaoDrawInfo{ @@ -752,7 +752,7 @@ void Engine::render(float deltaTime) vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, debugTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, {0.0f, 0.0f, 0.0f, 0.0f}); vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - DEPTH_STENCIL_ASPECT_FLAG); + VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); debug_renderer::DebugRendererDrawInfo debugRendererDrawInfo{ @@ -1045,7 +1045,7 @@ void Engine::createDrawResources() } // Depth Image { - depthStencilImage.imageFormat = DEPTH_FORMAT; + depthStencilImage.imageFormat = DEPTH_STENCIL_FORMAT; constexpr VkExtent3D depthImageExtent = {RENDER_EXTENTS.width, RENDER_EXTENTS.height, 1}; depthStencilImage.imageExtent = depthImageExtent; VkImageUsageFlags depthImageUsages{}; @@ -1059,7 +1059,7 @@ void Engine::createDrawResources() depthImageAllocationInfo.requiredFlags = static_cast(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); vmaCreateImage(context->allocator, &depthImageInfo, &depthImageAllocationInfo, &depthStencilImage.image, &depthStencilImage.allocation, nullptr); - VkImageViewCreateInfo combinedViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, DEPTH_STENCIL_ASPECT_FLAG); + VkImageViewCreateInfo combinedViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); VK_CHECK(vkCreateImageView(context->device, &combinedViewInfo, nullptr, &depthStencilImage.imageView)); VkImageViewCreateInfo depthViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, VK_IMAGE_ASPECT_DEPTH_BIT); diff --git a/src/renderer/pipelines/basic/basic_render/basic_render_pipeline.cpp b/src/renderer/pipelines/basic/basic_render/basic_render_pipeline.cpp index 160eaa39..b064963e 100644 --- a/src/renderer/pipelines/basic/basic_render/basic_render_pipeline.cpp +++ b/src/renderer/pipelines/basic/basic_render/basic_render_pipeline.cpp @@ -123,7 +123,7 @@ void will_engine::basic_render_pipeline::BasicRenderPipeline::createPipeline() renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); - renderPipelineBuilder.setupRenderer({DRAW_FORMAT}, DEPTH_FORMAT); + renderPipelineBuilder.setupRenderer({DRAW_FORMAT}, DEPTH_STENCIL_FORMAT); renderPipelineBuilder.setupPipelineLayout(pipelineLayout); pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder); diff --git a/src/renderer/pipelines/debug/debug_highlighter.cpp b/src/renderer/pipelines/debug/debug_highlighter.cpp index 39f42b60..5e2c4737 100644 --- a/src/renderer/pipelines/debug/debug_highlighter.cpp +++ b/src/renderer/pipelines/debug/debug_highlighter.cpp @@ -149,7 +149,7 @@ void DebugHighlighter::createPipeline() 1 }; renderPipelineBuilder.setupDepthStencil(VK_TRUE, VK_TRUE, VK_COMPARE_OP_GREATER_OR_EQUAL, VK_FALSE, VK_TRUE, stencilOp, stencilOp, 0.0f, 1.0f); - renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, DEPTH_FORMAT, DEPTH_FORMAT); + renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, DEPTH_STENCIL_FORMAT, DEPTH_STENCIL_FORMAT); renderPipelineBuilder.setupPipelineLayout(pipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); diff --git a/src/renderer/pipelines/debug/debug_renderer.cpp b/src/renderer/pipelines/debug/debug_renderer.cpp index 1c20b216..5a1a6d3f 100644 --- a/src/renderer/pipelines/debug/debug_renderer.cpp +++ b/src/renderer/pipelines/debug/debug_renderer.cpp @@ -352,7 +352,7 @@ void DebugRenderer::createPipeline() renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); - renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, DEPTH_FORMAT); + renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, DEPTH_STENCIL_FORMAT); renderPipelineBuilder.setupPipelineLayout(instancedPipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; instancedLinePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); @@ -391,7 +391,7 @@ void DebugRenderer::createPipeline() renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); - renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, DEPTH_FORMAT); + renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, DEPTH_STENCIL_FORMAT); renderPipelineBuilder.setupPipelineLayout(normalPipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; linePipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); diff --git a/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp b/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp index 37c01565..56888f64 100644 --- a/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp +++ b/src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.cpp @@ -178,7 +178,7 @@ void will_engine::deferred_mrt::DeferredMrtPipeline::createPipeline() renderPipelineBuilder.disableMultisampling(); renderPipelineBuilder.disableBlending(); renderPipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); - renderPipelineBuilder.setupRenderer({NORMAL_FORMAT, ALBEDO_FORMAT, PBR_FORMAT, VELOCITY_FORMAT}, DEPTH_FORMAT); + renderPipelineBuilder.setupRenderer({NORMAL_FORMAT, ALBEDO_FORMAT, PBR_FORMAT, VELOCITY_FORMAT}, DEPTH_STENCIL_FORMAT); renderPipelineBuilder.setupPipelineLayout(pipelineLayout); pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder); diff --git a/src/renderer/pipelines/geometry/environment/environment_pipeline.cpp b/src/renderer/pipelines/geometry/environment/environment_pipeline.cpp index eddfcf87..c705cbfb 100644 --- a/src/renderer/pipelines/geometry/environment/environment_pipeline.cpp +++ b/src/renderer/pipelines/geometry/environment/environment_pipeline.cpp @@ -119,7 +119,7 @@ void will_engine::environment_pipeline::EnvironmentPipeline::createPipeline() pipelineBuilder.disableMultisampling(); pipelineBuilder.disableBlending(); pipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); - pipelineBuilder.setupRenderer({NORMAL_FORMAT, ALBEDO_FORMAT, PBR_FORMAT, VELOCITY_FORMAT}, DEPTH_FORMAT); + pipelineBuilder.setupRenderer({NORMAL_FORMAT, ALBEDO_FORMAT, PBR_FORMAT, VELOCITY_FORMAT}, DEPTH_STENCIL_FORMAT); pipelineBuilder.setupPipelineLayout(pipelineLayout); diff --git a/src/renderer/pipelines/geometry/terrain/terrain_pipeline.cpp b/src/renderer/pipelines/geometry/terrain/terrain_pipeline.cpp index c7622226..7960d4c2 100644 --- a/src/renderer/pipelines/geometry/terrain/terrain_pipeline.cpp +++ b/src/renderer/pipelines/geometry/terrain/terrain_pipeline.cpp @@ -184,7 +184,7 @@ void will_engine::terrain::TerrainPipeline::createPipeline() pipelineBuilder.disableMultisampling(); pipelineBuilder.disableBlending(); pipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); - pipelineBuilder.setupRenderer({NORMAL_FORMAT, ALBEDO_FORMAT, PBR_FORMAT, VELOCITY_FORMAT}, DEPTH_FORMAT); + pipelineBuilder.setupRenderer({NORMAL_FORMAT, ALBEDO_FORMAT, PBR_FORMAT, VELOCITY_FORMAT}, DEPTH_STENCIL_FORMAT); pipelineBuilder.setupPipelineLayout(pipelineLayout); pipelineBuilder.setupTessellation(4); @@ -238,7 +238,7 @@ void will_engine::terrain::TerrainPipeline::createLinePipeline() pipelineBuilder.disableMultisampling(); pipelineBuilder.disableBlending(); pipelineBuilder.enableDepthTest(true, VK_COMPARE_OP_GREATER_OR_EQUAL); - pipelineBuilder.setupRenderer({NORMAL_FORMAT, ALBEDO_FORMAT, PBR_FORMAT, VELOCITY_FORMAT}, DEPTH_FORMAT); + pipelineBuilder.setupRenderer({NORMAL_FORMAT, ALBEDO_FORMAT, PBR_FORMAT, VELOCITY_FORMAT}, DEPTH_STENCIL_FORMAT); pipelineBuilder.setupPipelineLayout(pipelineLayout); pipelineBuilder.setupTessellation(4); diff --git a/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp b/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp index c860bef5..9cc43eb3 100644 --- a/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp +++ b/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp @@ -368,7 +368,7 @@ void TransparentPipeline::createAccumulationPipeline() pipelineBuilder.setupBlending(blendAttachmentStates); pipelineBuilder.enableDepthTest(false, VK_COMPARE_OP_GREATER); - pipelineBuilder.setupRenderer({accumulationImageFormat, revealageImageFormat, debugImageFormat}, DEPTH_FORMAT); + pipelineBuilder.setupRenderer({accumulationImageFormat, revealageImageFormat, debugImageFormat}, DEPTH_STENCIL_FORMAT); pipelineBuilder.setupPipelineLayout(accumulationPipelineLayout); accumulationPipeline = resourceManager.createRenderPipeline(pipelineBuilder); diff --git a/src/renderer/renderer_constants.h b/src/renderer/renderer_constants.h index cf78606e..d03df0ef 100644 --- a/src/renderer/renderer_constants.h +++ b/src/renderer/renderer_constants.h @@ -15,19 +15,27 @@ constexpr VkDeviceSize ZERO_DEVICE_SIZE = 0; constexpr VkExtent2D RENDER_EXTENTS{1920, 1080}; //constexpr VkExtent2D RENDER_EXTENTS{2560 , 1440}; //constexpr VkExtent2D RENDER_EXTENTS{3840, 2160}; + constexpr float RENDER_EXTENT_WIDTH{RENDER_EXTENTS.width}; constexpr float RENDER_EXTENT_HEIGHT{RENDER_EXTENTS.height}; + +// Be careful, environment map is in HDR format, so non-float formats for draw image won't work constexpr VkFormat DRAW_FORMAT{VK_FORMAT_R16G16B16A16_SFLOAT}; -constexpr VkFormat DEPTH_FORMAT{VK_FORMAT_D32_SFLOAT_S8_UINT}; -constexpr VkImageAspectFlags DEPTH_STENCIL_ASPECT_FLAG{VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT}; -constexpr VkFormat VELOCITY_FORMAT{VK_FORMAT_R16G16_SFLOAT}; -constexpr VkFormat DEBUG_FORMAT{VK_FORMAT_R8G8B8A8_SNORM}; + +constexpr VkFormat DEPTH_STENCIL_FORMAT{VK_FORMAT_D32_SFLOAT_S8_UINT}; +constexpr VkFormat DEPTH_FORMAT{VK_FORMAT_D32_SFLOAT}; +constexpr VkFormat STENCIL_FORMAT{VK_FORMAT_S8_UINT}; constexpr bool NORMAL_REMAP{true}; constexpr VkFormat NORMAL_FORMAT = NORMAL_REMAP ? VK_FORMAT_A2R10G10B10_UNORM_PACK32 : VK_FORMAT_R16G16B16A16_SNORM; +constexpr VkFormat VELOCITY_FORMAT{VK_FORMAT_R16G16_SFLOAT}; + +constexpr VkFormat DEBUG_FORMAT{VK_FORMAT_R8G8B8A8_SNORM}; + // Be careful, environment map is in HDR format, so non-float formats for albedo won't work constexpr VkFormat ALBEDO_FORMAT{VK_FORMAT_R16G16B16A16_SFLOAT}; + constexpr VkFormat PBR_FORMAT{VK_FORMAT_R8G8B8A8_UNORM}; } diff --git a/src/renderer/vk_helpers.cpp b/src/renderer/vk_helpers.cpp index 587a3b52..17e2ea77 100644 --- a/src/renderer/vk_helpers.cpp +++ b/src/renderer/vk_helpers.cpp @@ -996,14 +996,14 @@ void will_engine::vk_helpers::saveStencilBuffer(const ResourceManager& resourceM bufferCopyRegion.bufferImageHeight = 0; transitionImage(cmd, depthStencilImage.image, imageLayout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - DEPTH_STENCIL_ASPECT_FLAG); + VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); vkCmdCopyImageToBuffer(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, receivingBuffer.buffer, 1, &bufferCopyRegion); // Transition back transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, imageLayout, - DEPTH_STENCIL_ASPECT_FLAG); + VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); }); void* data = receivingBuffer.info.pMappedData; From a1cb4c91ec4982c54488fccde7117481d84b630d Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Mon, 5 May 2025 23:08:44 +0700 Subject: [PATCH 20/24] Save Image debug refactor WIP. --- CMakeLists.txt | 4 +- assets/settings.willengine | 14 +-- src/renderer/imgui_wrapper.cpp | 15 +-- src/renderer/vk_helpers.cpp | 216 +++++++++++++++++++++++++++++++-- src/renderer/vk_helpers.h | 46 ++++++- 5 files changed, 262 insertions(+), 33 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index bb6d3460..29cea602 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,7 @@ cmake_minimum_required(VERSION 3.28) project(WillEngine) -set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD 23) add_definitions(-DVK_NO_PROTOTYPES) @@ -49,7 +49,7 @@ add_subdirectory(extern/fastgltf/deps) # simdjson # Jolt Physics set(PHYSICS_REPO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/extern/JoltPhysics") include(extern/JoltPhysics/Jolt/Jolt.cmake) -set(CMAKE_CXX_STANDARD 20) # Jolt sets it to 17 +set(CMAKE_CXX_STANDARD 23) # Jolt sets it to 17 include_directories(${CMAKE_SOURCE_DIR}) diff --git a/assets/settings.willengine b/assets/settings.willengine index 8d3602d1..50c1a676 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -16.31094741821289, - 60.820003509521484, - 33.037052154541016 + -14.322464942932129, + 57.0402717590332, + 16.393896102905273 ], "rotation": [ - 0.20286287367343903, - 0.349800169467926, - 0.0778701901435852, - -0.9112753868103027 + 0.15307776629924774, + 0.4118880033493042, + 0.07040654867887497, + -0.8955212831497192 ], "fov": 1.3089969158172607, "aspectRatio": 1.7777777910232544, diff --git a/src/renderer/imgui_wrapper.cpp b/src/renderer/imgui_wrapper.cpp index 23952c60..aec8a314 100644 --- a/src/renderer/imgui_wrapper.cpp +++ b/src/renderer/imgui_wrapper.cpp @@ -669,17 +669,7 @@ void ImguiWrapper::imguiInterface(Engine* engine) if (ImGui::Button("Save Normals")) { if (file::getOrCreateDirectory(file::imagesSavePath)) { const std::filesystem::path path = file::imagesSavePath / "normalRT.png"; - auto unpackFunc = [](const uint32_t packedColor) { - glm::vec4 pixel = glm::unpackSnorm4x8(packedColor); - pixel.r = pixel.r * 0.5f + 0.5f; - pixel.g = pixel.g * 0.5f + 0.5f; - pixel.b = pixel.b * 0.5f + 0.5f; - pixel.a = 1.0f; - return pixel; - }; - vk_helpers::savePacked32Bit(*engine->resourceManager, *engine->immediate, engine->normalRenderTarget, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT, path.string().c_str(), - unpackFunc); + vk_helpers::saveImage(*engine->resourceManager, *engine->immediate, engine->normalRenderTarget, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, vk_helpers::ImageFormat::A2R10G10B10_UNORM, path.string()); } else { fmt::print(" Failed to save normal render target"); @@ -1227,8 +1217,7 @@ void ImguiWrapper::imguiInterface(Engine* engine) if (ImGui::Button("Save Stencil Debug Draw")) { if (file::getOrCreateDirectory(file::imagesSavePath)) { const std::filesystem::path path = file::imagesSavePath / "debugStencil.png"; - vk_helpers::saveStencilBuffer(*engine->resourceManager, *engine->immediate, engine->depthStencilImage, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, path.string().c_str()); + vk_helpers::saveImage(*engine->resourceManager, *engine->immediate, engine->depthStencilImage, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, vk_helpers::ImageFormat::D32S8, path.string(), true); } else { fmt::print(" Failed to find/create image save path directory"); diff --git a/src/renderer/vk_helpers.cpp b/src/renderer/vk_helpers.cpp index 17e2ea77..9236b413 100644 --- a/src/renderer/vk_helpers.cpp +++ b/src/renderer/vk_helpers.cpp @@ -594,6 +594,7 @@ VkPipelineShaderStageCreateInfo will_engine::vk_helpers::pipelineShaderStageCrea return info; } + void will_engine::vk_helpers::saveImageRGBA32F(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, const VkImageLayout imageLayout, const VkImageAspectFlags aspectFlag, @@ -929,7 +930,8 @@ void will_engine::vk_helpers::saveImageR8UNORM(const ResourceManager& resourceMa } void will_engine::vk_helpers::saveImageR8UINT(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& image, VkImageLayout imageLayout, const char* savePath, VkImageAspectFlagBits aspectFlag, int32_t mipLevel) + const AllocatedImage& image, VkImageLayout imageLayout, const char* savePath, + VkImageAspectFlagBits aspectFlag, int32_t mipLevel) { const size_t width = image.imageExtent.width / static_cast(std::pow(2, mipLevel)); const size_t height = image.imageExtent.height / static_cast(std::pow(2, mipLevel)); @@ -975,7 +977,7 @@ void will_engine::vk_helpers::saveImageR8UINT(const ResourceManager& resourceMan } void will_engine::vk_helpers::saveStencilBuffer(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& depthStencilImage, VkImageLayout imageLayout, const char* savePath) + const AllocatedImage& depthStencilImage, VkImageLayout imageLayout, const char* savePath) { const size_t width = depthStencilImage.imageExtent.width; const size_t height = depthStencilImage.imageExtent.height; @@ -996,14 +998,14 @@ void will_engine::vk_helpers::saveStencilBuffer(const ResourceManager& resourceM bufferCopyRegion.bufferImageHeight = 0; transitionImage(cmd, depthStencilImage.image, imageLayout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); + VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); vkCmdCopyImageToBuffer(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - receivingBuffer.buffer, 1, &bufferCopyRegion); + receivingBuffer.buffer, 1, &bufferCopyRegion); // Transition back transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, imageLayout, - VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); + VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); }); void* data = receivingBuffer.info.pMappedData; @@ -1013,9 +1015,9 @@ void will_engine::vk_helpers::saveStencilBuffer(const ResourceManager& resourceM const auto byteImageData = new uint8_t[texelCount * 4]; for (size_t i = 0; i < texelCount; ++i) { const auto value = stencilData[i]; - byteImageData[i * 4 + 0] = value * 255.0f; - byteImageData[i * 4 + 1] = value * 255.0f; - byteImageData[i * 4 + 2] = value * 255.0f; + byteImageData[i * 4 + 0] = value; + byteImageData[i * 4 + 1] = value; + byteImageData[i * 4 + 2] = value; byteImageData[i * 4 + 3] = 255; } @@ -1114,3 +1116,201 @@ void will_engine::vk_helpers::saveHeightmap(const std::vector& heightData delete[] byteImageData; } + +will_engine::vk_helpers::FormatInfo will_engine::vk_helpers::getFormatInfo(ImageFormat format, bool stencilOnly) +{ + switch (format) { + case ImageFormat::RGBA32F: + return {16, VK_IMAGE_ASPECT_COLOR_BIT}; + case ImageFormat::RGBA16F: + return {8, VK_IMAGE_ASPECT_COLOR_BIT}; + case ImageFormat::RGBA8: + return {4, VK_IMAGE_ASPECT_COLOR_BIT}; + case ImageFormat::R32F: + return {4, VK_IMAGE_ASPECT_COLOR_BIT}; + case ImageFormat::R16F: + return {2, VK_IMAGE_ASPECT_COLOR_BIT}; + case ImageFormat::R8UNORM: + return {1, VK_IMAGE_ASPECT_COLOR_BIT}; + case ImageFormat::R8UINT: + return {1, VK_IMAGE_ASPECT_COLOR_BIT}; + case ImageFormat::A2R10G10B10_UNORM: + return {sizeof(uint32_t), VK_IMAGE_ASPECT_COLOR_BIT}; + case ImageFormat::D32S8: + return {stencilOnly ? sizeof(uint8_t) : sizeof(uint32_t), VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT}; + default: + return {0, 0}; + } +} + +void will_engine::vk_helpers::saveImage(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, + const AllocatedImage& image, VkImageLayout imageLayout, + ImageFormat format, const std::string& savePath, bool saveStencilOnly) +{ + const FormatInfo info = getFormatInfo(format, saveStencilOnly); + const VkImageAspectFlags aspectMask = info.aspectMask; + + VkImageAspectFlags subresourceAspect = aspectMask; + // This will look different if `VK_KHR_separate_depth_stencil_layouts` is enabled + if (info.aspectMask == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { + subresourceAspect = saveStencilOnly ? VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT; + } + const uint32_t texelCount = image.imageExtent.width * image.imageExtent.height; + const size_t dataSize = texelCount * info.bytesPerPixel; + AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); + + immediate.submit([&](VkCommandBuffer cmd) { + VkBufferImageCopy bufferCopyRegion{}; + bufferCopyRegion.imageSubresource.aspectMask = subresourceAspect; + bufferCopyRegion.imageSubresource.mipLevel = 0; + bufferCopyRegion.imageSubresource.baseArrayLayer = 0; + bufferCopyRegion.imageSubresource.layerCount = 1; + bufferCopyRegion.imageExtent = image.imageExtent; + bufferCopyRegion.bufferOffset = 0; + bufferCopyRegion.bufferRowLength = 0; + bufferCopyRegion.bufferImageHeight = 0; + + transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectMask); + vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); + transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, aspectMask); + }); + + + void* data = receivingBuffer.info.pMappedData; + std::vector outputData(texelCount * 4); + processImageData(data, outputData, texelCount, format, saveStencilOnly); + + stbi_write_png(savePath.c_str(), image.imageExtent.width, image.imageExtent.height, 4, outputData.data(), image.imageExtent.width * 4); + + resourceManager.destroyImmediate(receivingBuffer); +} + +void will_engine::vk_helpers::processImageData(void* sourceData, std::span targetData, uint32_t pixelCount, ImageFormat format, + bool stencilOnly) +{ + constexpr float powEight = 255.0f; + + switch (format) { + case ImageFormat::RGBA32F: + { + const auto floatData = static_cast(sourceData); + for (uint32_t i = 0; i < pixelCount; ++i) { + for (uint32_t c = 0; c < 4; ++c) { + const float value = std::max(0.0f, std::min(1.0f, floatData[i * 4 + c])); + targetData[i * 4 + c] = static_cast(value * powEight); + } + } + break; + } + + case ImageFormat::RGBA16F: + { + const auto halfData = static_cast(sourceData); + for (uint32_t i = 0; i < pixelCount; ++i) { + for (uint32_t c = 0; c < 4; ++c) { + float value = halfData[i * 4 + c]; + value = std::max(0.0f, std::min(1.0f, value)); + targetData[i * 4 + c] = static_cast(value * powEight); + } + } + break; + } + + case ImageFormat::RGBA8: + { + const auto packedData = static_cast(sourceData); + for (uint32_t i = 0; i < pixelCount; ++i) { + const uint32_t pixel = packedData[i]; + targetData[i * 4] = (pixel & 0xFF); + targetData[i * 4 + 1] = ((pixel >> 8) & 0xFF); + targetData[i * 4 + 2] = ((pixel >> 16) & 0xFF); + targetData[i * 4 + 3] = ((pixel >> 24) & 0xFF); + } + break; + } + + case ImageFormat::R32F: + { + const auto floatData = static_cast(sourceData); + for (uint32_t i = 0; i < pixelCount; ++i) { + const float depth = floatData[i]; + for (uint32_t c = 0; c < 3; ++c) { + targetData[i * 4 + c] = static_cast(depth * powEight); + } + targetData[i * 4 + 3] = 255; + } + break; + } + + case ImageFormat::R16F: + { + const auto halfData = static_cast(sourceData); + for (uint32_t i = 0; i < pixelCount; ++i) { + const float depth = halfData[i]; + for (uint32_t c = 0; c < 3; ++c) { + targetData[i * 4 + c] = static_cast(depth * powEight); + } + targetData[i * 4 + 3] = 255; + } + break; + } + + case ImageFormat::R8UNORM: + case ImageFormat::R8UINT: + { + const uint8_t* byteSource = static_cast(sourceData); + for (uint32_t i = 0; i < pixelCount; ++i) { + const uint8_t value = byteSource[i]; + for (uint32_t c = 0; c < 3; ++c) { + targetData[i * 4 + c] = value; + } + targetData[i * 4 + 3] = 255; + } + break; + } + case ImageFormat::A2R10G10B10_UNORM: + { + const uint32_t* byteSource = static_cast(sourceData); + for (uint32_t i = 0; i < pixelCount; ++i) { + const uint32_t value = byteSource[i]; + + // Extract components according to A2R10G10B10 layout (AI BS) + const float r = static_cast((value >> 20) & 0x3FF) / 1023.0f; + const float g = static_cast((value >> 10) & 0x3FF) / 1023.0f; + const float b = static_cast(value & 0x3FF) / 1023.0f; + //const float a = static_cast((value >> 30) & 0x3) / 3.0f; + + targetData[i * 4 + 0] = static_cast(r * powEight); + targetData[i * 4 + 1] = static_cast(g * powEight); + targetData[i * 4 + 2] = static_cast(b * powEight); + //targetData[i * 4 + 3] = static_cast(a * 255.0f); + targetData[i * 4 + 3] = powEight; + } + break; + } + case ImageFormat::D32S8: + { + if (stencilOnly) { + const uint8_t* byteSource = static_cast(sourceData); + for (uint32_t i = 0; i < pixelCount; ++i) { + const uint8_t stencil = byteSource[i]; + for (uint32_t c = 0; c < 3; ++c) { + targetData[i * 4 + c] = stencil * 255.0f; + } + targetData[i * 4 + 3] = 255; + } + } + else { + const auto depthData = static_cast(sourceData); + for (uint32_t i = 0; i < pixelCount; ++i) { + const float depth = depthData[i]; + for (uint32_t c = 0; c < 3; ++c) { + targetData[i * 4 + c] = static_cast(depth * powEight); + } + targetData[i * 4 + 3] = 255; + } + } + break; + } + } +} diff --git a/src/renderer/vk_helpers.h b/src/renderer/vk_helpers.h index db2ed34f..52a3eafc 100644 --- a/src/renderer/vk_helpers.h +++ b/src/renderer/vk_helpers.h @@ -6,6 +6,7 @@ #define VKHELPERS_H #include #include +#include #include #include @@ -26,6 +27,27 @@ class ImmediateSubmitter; namespace vk_helpers { + // Enum to define supported image formats + enum class ImageFormat + { + RGBA32F, + RGBA16F, + RGBA8, + A2R10G10B10_UNORM, + R32F, + R16F, + R8UNORM, + R8UINT, + D32S8 + }; + + // Structure to hold format-specific parameters + struct FormatInfo + { + uint64_t bytesPerPixel; + VkImageAspectFlags aspectMask; + }; + VkImageCreateInfo imageCreateInfo(VkFormat format, VkImageUsageFlags usageFlags, VkExtent3D extent); VkImageCreateInfo cubemapCreateInfo(VkFormat format, VkImageUsageFlags usageFlags, VkExtent3D extent); @@ -80,7 +102,8 @@ namespace vk_helpers */ VkDeviceSize getAlignedSize(VkDeviceSize value, VkDeviceSize alignment); - void copyBuffer(VkCommandBuffer cmd, const AllocatedBuffer& src, VkDeviceSize srcOffset, const AllocatedBuffer& dst, VkDeviceSize dstOffset, VkDeviceSize size); + void copyBuffer(VkCommandBuffer cmd, const AllocatedBuffer& src, VkDeviceSize srcOffset, const AllocatedBuffer& dst, VkDeviceSize dstOffset, + VkDeviceSize size); void clearColorImage(VkCommandBuffer cmd, VkImageAspectFlagBits aspectFlag, VkImage image, VkImageLayout srcLayout, VkImageLayout dstLayout, VkClearColorValue clearColor = {0.0f, 0.0f, 0.0f, 1.0f}); @@ -134,10 +157,13 @@ namespace vk_helpers void saveImageR8UNORM(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, VkImageLayout imageLayout, const char* savePath, int32_t mipLevel = 0); + void saveImageR8UINT(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, - VkImageLayout imageLayout, const char* savePath, VkImageAspectFlagBits aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT, int32_t mipLevel = 0); + VkImageLayout imageLayout, const char* savePath, VkImageAspectFlagBits aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT, + int32_t mipLevel = 0); + void saveStencilBuffer(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& depthStencilImage, VkImageLayout imageLayout, const char* savePath); + const AllocatedImage& depthStencilImage, VkImageLayout imageLayout, const char* savePath); void saveImageR8G8B8A8UNORM(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, VkImageLayout imageLayout, const char* savePath, int32_t mipLevel = 0); @@ -145,6 +171,20 @@ namespace vk_helpers void saveImage(const std::vector& imageData, int width, int height, std::filesystem::path filename, bool overrideAlpha = true); void saveHeightmap(const std::vector& heightData, int width, int height, const std::filesystem::path& filename); + + FormatInfo getFormatInfo(ImageFormat format, bool stencilOnly); + + void processImageData(void* sourceData, std::span targetData, + uint32_t pixelCount, + ImageFormat format, bool stencilOnly = false); + + void saveImage(const ResourceManager& resourceManager, + const ImmediateSubmitter& immediate, + const AllocatedImage& image, + VkImageLayout imageLayout, + ImageFormat format, + const std::string& savePath, + bool saveStencilOnly = false); } } From c654b2d0d065260c6efe2ce0532c25c44548381f Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Tue, 6 May 2025 20:51:14 +0700 Subject: [PATCH 21/24] Debug highlighter now correctly outputs only the outline of the object to the debug image. --- assets/settings.willengine | 14 +- shaders/debug/debug_composite.comp | 9 +- .../debug/debug_highlighter_processing.comp | 60 +++++ shaders/deferredResolve.comp | 2 +- src/core/engine.cpp | 88 ++++++- src/core/engine.h | 3 +- .../assets/render_object/render_reference.h | 2 + src/renderer/imgui_wrapper.cpp | 4 +- .../debug/debug_composite_pipeline.cpp | 13 +- .../debug/debug_composite_pipeline.h | 6 - .../pipelines/debug/debug_highlighter.cpp | 232 ++++++++++++------ .../pipelines/debug/debug_highlighter.h | 20 +- src/renderer/vk_helpers.cpp | 10 +- src/renderer/vk_helpers.h | 2 +- 14 files changed, 339 insertions(+), 126 deletions(-) create mode 100644 shaders/debug/debug_highlighter_processing.comp diff --git a/assets/settings.willengine b/assets/settings.willengine index 50c1a676..9f668112 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -14.322464942932129, - 57.0402717590332, - 16.393896102905273 + -13.128146171569824, + 37.29668045043945, + 7.1479692459106445 ], "rotation": [ - 0.15307776629924774, - 0.4118880033493042, - 0.07040654867887497, - -0.8955212831497192 + 0.08503364771604538, + -0.22412154078483582, + 0.019634202122688293, + 0.9706459045410156 ], "fov": 1.3089969158172607, "aspectRatio": 1.7777777910232544, diff --git a/shaders/debug/debug_composite.comp b/shaders/debug/debug_composite.comp index f614b92c..c468e0af 100644 --- a/shaders/debug/debug_composite.comp +++ b/shaders/debug/debug_composite.comp @@ -9,17 +9,12 @@ layout (local_size_x = 16, local_size_y = 16) in; layout(set = 1, binding = 0) uniform sampler2D debugImage; layout(set = 1, binding = 1, rgba16) uniform image2D finalImage; -layout (push_constant) uniform PushConstants { - vec2 bounds; -} push; - - void main() { ivec2 pixelCoord = ivec2(gl_GlobalInvocationID.xy); - if (any(greaterThan(pixelCoord, ivec2(push.bounds)))) { + if (any(greaterThan(pixelCoord, ivec2(sceneData.renderTargetSize)))) { return; } - vec2 uv = (vec2(pixelCoord) + 0.5) / push.bounds; + vec2 uv = (vec2(pixelCoord) + 0.5) / sceneData.renderTargetSize; vec4 mainColor = imageLoad(finalImage, pixelCoord); vec2 debugUv = uv; diff --git a/shaders/debug/debug_highlighter_processing.comp b/shaders/debug/debug_highlighter_processing.comp new file mode 100644 index 00000000..54fbfe80 --- /dev/null +++ b/shaders/debug/debug_highlighter_processing.comp @@ -0,0 +1,60 @@ +#version 460 + +#include "scene.glsl" + +layout (local_size_x = 16, local_size_y = 16) in; + +// layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl + +layout(set = 1, binding = 0, r8ui) uniform uimage2D highlighterStencil; +layout(set = 1, binding = 1, rgba16) uniform image2D debugTarget; + +const int OUTLINE_THICKNESS = 2; + +void main() { + ivec2 pixelCoord = ivec2(gl_GlobalInvocationID.xy); + if (any(greaterThan(pixelCoord, ivec2(sceneData.renderTargetSize)))) { + return; + } + + uint stencilValue = imageLoad(highlighterStencil, pixelCoord).r; + + if (stencilValue == 0) { + return; + } + + bool isEdge = false; + + for (int thickness = 1; thickness <= OUTLINE_THICKNESS; thickness++) { + for (int dir = 0; dir < 4; dir++) { + ivec2 offset; + if (dir == 0) offset = ivec2(thickness, 0); // Right + if (dir == 1) offset = ivec2(-thickness, 0); // Left + if (dir == 2) offset = ivec2(0, thickness); // Down + if (dir == 3) offset = ivec2(0, -thickness); // Up + + ivec2 neighborCoord = pixelCoord + offset; + + if (all(greaterThanEqual(neighborCoord, ivec2(0))) && + all(lessThan(neighborCoord, ivec2(sceneData.renderTargetSize)))) { + uint neighborValue = imageLoad(highlighterStencil, neighborCoord).r; + if (neighborValue == 0) { + isEdge = true; + break; + } + } else { + isEdge = true; + break; + } + } + + if (isEdge) { + break; + } + } + + if (isEdge) { + vec4 outlineColor = vec4(1.0, 0.647, 0.0, 1.0); + imageStore(debugTarget, pixelCoord, outlineColor); + } +} \ No newline at end of file diff --git a/shaders/deferredResolve.comp b/shaders/deferredResolve.comp index 1a743429..698d9d7e 100644 --- a/shaders/deferredResolve.comp +++ b/shaders/deferredResolve.comp @@ -177,7 +177,7 @@ void main() { imageStore(outputImage, screenPos, albedo); break; case 4: - imageStore(outputImage, screenPos, vec4(worldN * 0.5f + 0.5f, 1.0f)); + imageStore(outputImage, screenPos, vec4(packNormal(viewNormal), 1.0f)); break; case 5: imageStore(outputImage, screenPos, pbrData); diff --git a/src/core/engine.cpp b/src/core/engine.cpp index 6d4b9e41..8dd08c95 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -137,6 +137,7 @@ void Engine::init() debugPipeline = new debug_pipeline::DebugCompositePipeline(*resourceManager); debugPipeline->setupDescriptorBuffer(debugTarget.imageView, finalImageBuffer.imageView); debugHighlighter = new debug_highlight_pipeline::DebugHighlighter(*resourceManager); + debugHighlighter->setupDescriptorBuffer(stencilImageView, debugTarget.imageView); #endif startupProfiler.addEntry("Immediate, ResourceM, AssetM, Physics"); @@ -338,11 +339,13 @@ void Engine::run() void Engine::updatePhysics(const float deltaTime) const { - if (!bPausePhysics) { + if (bEnablePhysics) { physics::Physics::get()->update(deltaTime); } - physics::Physics::get()->drawDebug(); + if (bDebugPhysics) { + physics::Physics::get()->drawDebug(); + } } void Engine::updateGame(const float deltaTime) @@ -365,6 +368,33 @@ void Engine::updateGame(const float deltaTime) } } + if (input.isKeyPressed(SDLK_G)) { + if (camera) { + if (auto transformable = dynamic_cast(selectedItem)) { + glm::vec3 itemPosition = transformable->getPosition(); + + glm::vec3 itemScale = transformable->getScale(); + float maxDimension = glm::max(glm::max(itemScale.x, itemScale.y), itemScale.z); + + float distance = glm::max(5.0f, maxDimension * 3.0f); + + glm::vec3 currentCamPos = camera->getTransform().getPosition(); + glm::vec3 currentDirection = glm::normalize(itemPosition - currentCamPos); + + glm::vec3 newCamPos = itemPosition - (currentDirection * distance); + + glm::vec3 forward = glm::normalize(newCamPos - itemPosition); + glm::vec3 right = glm::normalize(glm::cross(glm::vec3(0.0f, 1.0f, 0.0f), forward)); + glm::vec3 up = glm::cross(forward, right); + + glm::mat3 rotMatrix(right, up, forward); + glm::quat newRotation = glm::quat_cast(rotMatrix); + + camera->setCameraTransform(newCamPos, newRotation); + } + } + } + for (IHierarchical* hierarchal : hierarchalBeginQueue) { hierarchal->beginPlay(); } @@ -661,7 +691,8 @@ void Engine::render(float deltaTime) VK_IMAGE_ASPECT_COLOR_BIT); vk_helpers::transitionImage(cmd, velocityRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); vk_helpers::transitionImage(cmd, drawImage.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); @@ -751,7 +782,8 @@ void Engine::render(float deltaTime) if (bDrawDebugRendering) { vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, debugTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, {0.0f, 0.0f, 0.0f, 0.0f}); - vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); @@ -765,15 +797,43 @@ void Engine::render(float deltaTime) debugRenderer->draw(cmd, debugRendererDrawInfo); + bool stencilDrawn = false; + + debug_highlight_pipeline::DebugHighlighterDrawInfo highlightDrawInfo{ + nullptr, + depthStencilImage, + sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), + sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap + }; + + if (IComponentContainer* cc = dynamic_cast(selectedItem)) { if (components::MeshRendererComponent* meshRenderer = cc->getComponent()) { - debugHighlighter->draw(cmd, meshRenderer, debugTarget.imageView, depthStencilImage.imageView); + highlightDrawInfo.highlightTarget = meshRenderer; + stencilDrawn = debugHighlighter->drawHighlightStencil(cmd, highlightDrawInfo); } } - vk_helpers::transitionImage(cmd, debugTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - VK_IMAGE_ASPECT_COLOR_BIT); + if (stencilDrawn) { + vk_helpers::transitionImage(cmd, debugTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_GENERAL, + VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, + VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); + + debugHighlighter->drawHighlightProcessing(cmd, highlightDrawInfo); + + + vk_helpers::transitionImage(cmd, debugTarget.image, VK_IMAGE_LAYOUT_GENERAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_IMAGE_ASPECT_COLOR_BIT); + } + else { + vk_helpers::transitionImage(cmd, debugTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_IMAGE_ASPECT_COLOR_BIT); + } + debug_pipeline::DebugCompositePipelineDrawInfo drawInfo{ sceneDataDescriptorBuffer.getDescriptorBufferBindingInfo(), @@ -1057,15 +1117,19 @@ void Engine::createDrawResources() VmaAllocationCreateInfo depthImageAllocationInfo = {}; depthImageAllocationInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; depthImageAllocationInfo.requiredFlags = static_cast(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); - vmaCreateImage(context->allocator, &depthImageInfo, &depthImageAllocationInfo, &depthStencilImage.image, &depthStencilImage.allocation, nullptr); + vmaCreateImage(context->allocator, &depthImageInfo, &depthImageAllocationInfo, &depthStencilImage.image, &depthStencilImage.allocation, + nullptr); - VkImageViewCreateInfo combinedViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); + VkImageViewCreateInfo combinedViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, + VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); VK_CHECK(vkCreateImageView(context->device, &combinedViewInfo, nullptr, &depthStencilImage.imageView)); - VkImageViewCreateInfo depthViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, VK_IMAGE_ASPECT_DEPTH_BIT); + VkImageViewCreateInfo depthViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, + VK_IMAGE_ASPECT_DEPTH_BIT); VK_CHECK(vkCreateImageView(context->device, &depthViewInfo, nullptr, &depthImageView)); - VkImageViewCreateInfo stencilViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, VK_IMAGE_ASPECT_STENCIL_BIT); + VkImageViewCreateInfo stencilViewInfo = vk_helpers::imageviewCreateInfo(depthStencilImage.imageFormat, depthStencilImage.image, + VK_IMAGE_ASPECT_STENCIL_BIT); VK_CHECK(vkCreateImageView(context->device, &stencilViewInfo, nullptr, &stencilImageView)); } // Render Targets diff --git a/src/core/engine.h b/src/core/engine.h index f32d4d1c..8d2d48f3 100644 --- a/src/core/engine.h +++ b/src/core/engine.h @@ -182,6 +182,7 @@ class Engine debug_renderer::DebugRenderer* debugRenderer{nullptr}; debug_highlight_pipeline::DebugHighlighter* debugHighlighter{nullptr}; debug_pipeline::DebugCompositePipeline* debugPipeline{nullptr}; + bool bDebugPhysics{true}; #endif // Might be used in imgui which can be active outside of debug build IHierarchical* selectedItem{nullptr}; @@ -233,7 +234,7 @@ class Engine bool bEnableDebugFrustumCullDraw{false}; int32_t deferredDebug{0}; bool bDrawTerrainLines{false}; - bool bPausePhysics{true}; + bool bEnablePhysics{true}; bool bDrawTransparents{true}; bool bEnableShadows{true}; bool bEnableContactShadows{true}; diff --git a/src/renderer/assets/render_object/render_reference.h b/src/renderer/assets/render_object/render_reference.h index 294c5050..2e04fc4b 100644 --- a/src/renderer/assets/render_object/render_reference.h +++ b/src/renderer/assets/render_object/render_reference.h @@ -5,6 +5,8 @@ #ifndef RENDER_REFERENCE_H #define RENDER_REFERENCE_H +#include + #include #include "src/renderer/vk_types.h" diff --git a/src/renderer/imgui_wrapper.cpp b/src/renderer/imgui_wrapper.cpp index aec8a314..969b11aa 100644 --- a/src/renderer/imgui_wrapper.cpp +++ b/src/renderer/imgui_wrapper.cpp @@ -234,6 +234,8 @@ void ImguiWrapper::imguiInterface(Engine* engine) ImGui::Checkbox("Enable Shadows", &engine->bEnableShadows); ImGui::Checkbox("Enable Contact Shadows", &engine->bEnableContactShadows); ImGui::Checkbox("Enable Transparent Primitives", &engine->bDrawTransparents); + ImGui::Checkbox("Disable Physics", &engine->bEnablePhysics); + ImGui::Checkbox("Enable Physics Debug", &engine->bDebugPhysics); ImGui::DragInt("Shadows PCF Level", &engine->csmSettings.pcfLevel, 2, 1, 5); @@ -621,8 +623,6 @@ void ImguiWrapper::imguiInterface(Engine* engine) ImGui::Separator(); - ImGui::Checkbox("Disable Physics", &engine->bPausePhysics); - ImGui::Text("Deferred Debug"); const char* deferredDebugOptions[]{ "None", "Depth", "Velocity", "Albedo", "Normal", "PBR", "Shadows", "Cascade Level", "nDotL", "AO", "Contact Shadows" diff --git a/src/renderer/pipelines/debug/debug_composite_pipeline.cpp b/src/renderer/pipelines/debug/debug_composite_pipeline.cpp index 4f839cb9..d7c98281 100644 --- a/src/renderer/pipelines/debug/debug_composite_pipeline.cpp +++ b/src/renderer/pipelines/debug/debug_composite_pipeline.cpp @@ -17,11 +17,6 @@ DebugCompositePipeline::DebugCompositePipeline(ResourceManager& resourceManager) descriptorSetLayout = resourceManager.createDescriptorSetLayout(layoutBuilder, VK_SHADER_STAGE_COMPUTE_BIT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT); - VkPushConstantRange pushConstants{}; - pushConstants.offset = 0; - pushConstants.size = sizeof(DebugPushConstant); - pushConstants.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; - std::array setLayouts; setLayouts[0] = resourceManager.getSceneDataLayout(); setLayouts[1] = descriptorSetLayout; @@ -31,8 +26,8 @@ DebugCompositePipeline::DebugCompositePipeline(ResourceManager& resourceManager) layoutInfo.pNext = nullptr; layoutInfo.pSetLayouts = setLayouts.data(); layoutInfo.setLayoutCount = 2; - layoutInfo.pPushConstantRanges = &pushConstants; - layoutInfo.pushConstantRangeCount = 1; + layoutInfo.pPushConstantRanges = nullptr; + layoutInfo.pushConstantRangeCount = 0; pipelineLayout = resourceManager.createPipelineLayout(layoutInfo); @@ -73,10 +68,6 @@ void DebugCompositePipeline::draw(VkCommandBuffer cmd, DebugCompositePipelineDra { vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline); - DebugPushConstant push{}; - push.renderBounds = {RENDER_EXTENT_WIDTH, RENDER_EXTENT_HEIGHT}; - vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(DebugPushConstant), &push); - const std::array bindingInfos{ drawInfo.sceneDataBinding, descriptorBuffer.getDescriptorBufferBindingInfo() diff --git a/src/renderer/pipelines/debug/debug_composite_pipeline.h b/src/renderer/pipelines/debug/debug_composite_pipeline.h index 0231d76a..7aac62fd 100644 --- a/src/renderer/pipelines/debug/debug_composite_pipeline.h +++ b/src/renderer/pipelines/debug/debug_composite_pipeline.h @@ -15,12 +15,6 @@ namespace will_engine::debug_pipeline { - -struct DebugPushConstant -{ - glm::vec2 renderBounds{RENDER_EXTENT_WIDTH, RENDER_EXTENT_HEIGHT}; -}; - struct DebugCompositePipelineDrawInfo { VkDescriptorBufferBindingInfoEXT sceneDataBinding{}; diff --git a/src/renderer/pipelines/debug/debug_highlighter.cpp b/src/renderer/pipelines/debug/debug_highlighter.cpp index 5e2c4737..701fffd1 100644 --- a/src/renderer/pipelines/debug/debug_highlighter.cpp +++ b/src/renderer/pipelines/debug/debug_highlighter.cpp @@ -14,7 +14,7 @@ namespace will_engine::debug_highlight_pipeline { DebugHighlighter::DebugHighlighter(ResourceManager& resourceManager) : resourceManager(resourceManager) { - std::array descriptorLayout; + std::array descriptorLayout; descriptorLayout[0] = resourceManager.getSceneDataLayout(); VkPushConstantRange pushConstants{}; @@ -31,90 +31,157 @@ DebugHighlighter::DebugHighlighter(ResourceManager& resourceManager) : resourceM pipelineLayout = resourceManager.createPipelineLayout(layoutInfo); + DescriptorLayoutBuilder layoutBuilder; + layoutBuilder.addBinding(0, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE); // Stencil Image + layoutBuilder.addBinding(1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE); // Debug Target + + processingSetLayout = resourceManager.createDescriptorSetLayout(layoutBuilder, VK_SHADER_STAGE_COMPUTE_BIT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT); + + descriptorLayout[1] = processingSetLayout; + + layoutInfo.setLayoutCount = 2; + layoutInfo.pPushConstantRanges = nullptr; + layoutInfo.pushConstantRangeCount = 0; + + processingPipelineLayout = resourceManager.createPipelineLayout(layoutInfo); + createPipeline(); + + descriptorBuffer = resourceManager.createDescriptorBufferSampler(processingSetLayout, 1); } DebugHighlighter::~DebugHighlighter() { + resourceManager.destroy(processingSetLayout); resourceManager.destroy(pipelineLayout); + resourceManager.destroy(processingPipelineLayout); resourceManager.destroy(pipeline); + resourceManager.destroy(processingPipeline); + resourceManager.destroy(descriptorBuffer); } -void DebugHighlighter::draw(VkCommandBuffer cmd, IRenderable* highlightTarget, VkImageView debugTarget, VkImageView depthStencilTarget) const +void DebugHighlighter::setupDescriptorBuffer(VkImageView stencilImageView, VkImageView debugTarget) { - if (IRenderReference* renderRef = highlightTarget->getRenderReference()) { - const std::optional > meshData = renderRef->getMeshData(highlightTarget->getMeshIndex()); - if (!meshData.has_value()) { return; } - - const VkRenderingAttachmentInfo imageAttachment = vk_helpers::attachmentInfo(debugTarget, nullptr, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); - const VkRenderingAttachmentInfo depthAttachment = vk_helpers::attachmentInfo(depthStencilTarget, nullptr, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); - - VkClearValue stencilClear{}; - stencilClear.depthStencil = {0.0f, 0}; - const VkRenderingAttachmentInfo stencilAttachment = vk_helpers::attachmentInfo(depthStencilTarget, &stencilClear, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); - - VkRenderingInfo renderInfo{}; - renderInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO; - renderInfo.pNext = nullptr; - - VkRenderingAttachmentInfo renderAttachments[1]; - renderAttachments[0] = imageAttachment; - - renderInfo.renderArea = VkRect2D{VkOffset2D{0, 0}, RENDER_EXTENTS}; - renderInfo.layerCount = 1; - renderInfo.colorAttachmentCount = 1; - renderInfo.pColorAttachments = renderAttachments; - renderInfo.pDepthAttachment = &depthAttachment; - renderInfo.pStencilAttachment = &stencilAttachment; - - vkCmdBeginRendering(cmd, &renderInfo); - - vkCmdSetLineWidth(cmd, 2.0f); - - // Viewport - VkViewport viewport = {}; - viewport.x = 0; - viewport.y = 0; - viewport.width = RENDER_EXTENTS.width; - viewport.height = RENDER_EXTENTS.height; - viewport.minDepth = 0.f; - viewport.maxDepth = 1.f; - vkCmdSetViewport(cmd, 0, 1, &viewport); - // Scissor - VkRect2D scissor = {}; - scissor.offset.x = 0; - scissor.offset.y = 0; - scissor.extent.width = RENDER_EXTENTS.width; - scissor.extent.height = RENDER_EXTENTS.height; - vkCmdSetScissor(cmd, 0, 1, &scissor); - - vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); - - for (const Primitive& primitive : meshData.value().get().primitives) { - const uint32_t indexCount = primitive.indexCount; - const uint32_t firstIndex = primitive.firstIndex; - const int32_t vertexOffset = primitive.vertexOffset; - constexpr uint32_t firstInstance = 0; - constexpr uint32_t instanceCount = 1; - - DebugHighlightDrawPushConstant push{}; - push.modelMatrix = highlightTarget->getModelMatrix(); - vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(DebugHighlightDrawPushConstant), &push); - - vkCmdBindVertexBuffers(cmd, 0, 1, &renderRef->getPositionVertexBuffer().buffer, &ZERO_DEVICE_SIZE); - vkCmdBindIndexBuffer(cmd, renderRef->getIndexBuffer().buffer, 0, VK_INDEX_TYPE_UINT32); - - // Draw this mesh w/ vkCmdDrawIndexed w/ model matrix passed through push - vkCmdDrawIndexed(cmd, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); - } + std::vector descriptors; + descriptors.reserve(2); - vkCmdEndRendering(cmd); + VkDescriptorImageInfo inputImage{}; + inputImage.imageView = stencilImageView; + inputImage.imageLayout = VK_IMAGE_LAYOUT_GENERAL; + + VkDescriptorImageInfo outputImage{}; + outputImage.imageView = debugTarget; + outputImage.imageLayout = VK_IMAGE_LAYOUT_GENERAL; + + descriptors.push_back({VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, inputImage, false}); + descriptors.push_back({VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, outputImage, false}); + + resourceManager.setupDescriptorBufferSampler(descriptorBuffer, descriptors, 0); +} + +bool DebugHighlighter::drawHighlightStencil(VkCommandBuffer cmd, const DebugHighlighterDrawInfo& drawInfo) const +{ + if (IRenderReference* renderRef = drawInfo.highlightTarget->getRenderReference()) { + const std::optional > meshData = renderRef->getMeshData(drawInfo.highlightTarget->getMeshIndex()); + if (meshData.has_value()) { + const VkRenderingAttachmentInfo depthAttachment = vk_helpers::attachmentInfo(drawInfo.depthStencilTarget.imageView, nullptr, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); + + VkClearValue stencilClear{}; + stencilClear.depthStencil = {0.0f, 0}; + const VkRenderingAttachmentInfo stencilAttachment = vk_helpers::attachmentInfo(drawInfo.depthStencilTarget.imageView, &stencilClear, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); + + VkRenderingInfo renderInfo{}; + renderInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO; + renderInfo.pNext = nullptr; + + renderInfo.renderArea = VkRect2D{VkOffset2D{0, 0}, RENDER_EXTENTS}; + renderInfo.layerCount = 1; + renderInfo.colorAttachmentCount = 0; + renderInfo.pColorAttachments = nullptr; + renderInfo.pDepthAttachment = &depthAttachment; + renderInfo.pStencilAttachment = &stencilAttachment; + + vkCmdBeginRendering(cmd, &renderInfo); + + vkCmdSetLineWidth(cmd, 2.0f); + + // Viewport + VkViewport viewport = {}; + viewport.x = 0; + viewport.y = 0; + viewport.width = RENDER_EXTENTS.width; + viewport.height = RENDER_EXTENTS.height; + viewport.minDepth = 0.f; + viewport.maxDepth = 1.f; + vkCmdSetViewport(cmd, 0, 1, &viewport); + // Scissor + VkRect2D scissor = {}; + scissor.offset.x = 0; + scissor.offset.y = 0; + scissor.extent.width = RENDER_EXTENTS.width; + scissor.extent.height = RENDER_EXTENTS.height; + vkCmdSetScissor(cmd, 0, 1, &scissor); + + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); + + const std::array bindingInfos{ + drawInfo.sceneDataBinding, + }; + vkCmdBindDescriptorBuffersEXT(cmd, 1, bindingInfos.data()); + + constexpr std::array indices{0u}; + const std::array offsets{drawInfo.sceneDataOffset}; + vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, indices.data(), offsets.data()); + + + for (const Primitive& primitive : meshData.value().get().primitives) { + const uint32_t indexCount = primitive.indexCount; + const uint32_t firstIndex = primitive.firstIndex; + const int32_t vertexOffset = primitive.vertexOffset; + constexpr uint32_t firstInstance = 0; + constexpr uint32_t instanceCount = 1; + + DebugHighlightDrawPushConstant push{}; + push.modelMatrix = drawInfo.highlightTarget->getModelMatrix(); + vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(DebugHighlightDrawPushConstant), &push); + + vkCmdBindVertexBuffers(cmd, 0, 1, &renderRef->getPositionVertexBuffer().buffer, &ZERO_DEVICE_SIZE); + vkCmdBindIndexBuffer(cmd, renderRef->getIndexBuffer().buffer, 0, VK_INDEX_TYPE_UINT32); + + // Draw this mesh w/ vkCmdDrawIndexed w/ model matrix passed through push + vkCmdDrawIndexed(cmd, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + } + + vkCmdEndRendering(cmd); + return true; + } } + return false; } +void DebugHighlighter::drawHighlightProcessing(VkCommandBuffer cmd, const DebugHighlighterDrawInfo& drawInfo) const +{ + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, processingPipeline); + + const std::array bindingInfos{ + drawInfo.sceneDataBinding, + descriptorBuffer.getDescriptorBufferBindingInfo() + }; + vkCmdBindDescriptorBuffersEXT(cmd, 2, bindingInfos.data()); + + constexpr std::array indices{0, 1}; + const std::array offsets{drawInfo.sceneDataOffset, 0}; + vkCmdSetDescriptorBufferOffsetsEXT(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, processingPipelineLayout, 0, 2, indices.data(), offsets.data()); + + const auto x = static_cast(std::ceil(RENDER_EXTENT_WIDTH / 16.0f)); + const auto y = static_cast(std::ceil(RENDER_EXTENT_HEIGHT / 16.0f)); + vkCmdDispatch(cmd, x, y, 1); +} + + void DebugHighlighter::createPipeline() { VkShaderModule vertShader = resourceManager.createShaderModule("shaders/debug/debug_highlighter.vert"); @@ -149,12 +216,33 @@ void DebugHighlighter::createPipeline() 1 }; renderPipelineBuilder.setupDepthStencil(VK_TRUE, VK_TRUE, VK_COMPARE_OP_GREATER_OR_EQUAL, VK_FALSE, VK_TRUE, stencilOp, stencilOp, 0.0f, 1.0f); - renderPipelineBuilder.setupRenderer({DEBUG_FORMAT}, DEPTH_STENCIL_FORMAT, DEPTH_STENCIL_FORMAT); + renderPipelineBuilder.setupRenderer({}, DEPTH_STENCIL_FORMAT, DEPTH_STENCIL_FORMAT); renderPipelineBuilder.setupPipelineLayout(pipelineLayout); const std::vector additionalDynamicStates{VK_DYNAMIC_STATE_LINE_WIDTH}; pipeline = resourceManager.createRenderPipeline(renderPipelineBuilder, additionalDynamicStates); resourceManager.destroy(vertShader); resourceManager.destroy(fragShader); + + + resourceManager.destroy(processingPipeline); + VkShaderModule computeShader = resourceManager.createShaderModule("shaders/debug/debug_highlighter_processing.comp"); + + VkPipelineShaderStageCreateInfo stageInfo{}; + stageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + stageInfo.pNext = nullptr; + stageInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT; + stageInfo.module = computeShader; + stageInfo.pName = "main"; + + VkComputePipelineCreateInfo pipelineInfo{}; + pipelineInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; + pipelineInfo.pNext = nullptr; + pipelineInfo.layout = processingPipelineLayout; + pipelineInfo.stage = stageInfo; + pipelineInfo.flags = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT; + + processingPipeline = resourceManager.createComputePipeline(pipelineInfo); + resourceManager.destroy(computeShader); } } diff --git a/src/renderer/pipelines/debug/debug_highlighter.h b/src/renderer/pipelines/debug/debug_highlighter.h index 70757320..bc8ef7f5 100644 --- a/src/renderer/pipelines/debug/debug_highlighter.h +++ b/src/renderer/pipelines/debug/debug_highlighter.h @@ -7,6 +7,7 @@ #include +#include "src/core/game_object/renderable.h" #include "src/renderer/imgui_wrapper.h" #include "src/renderer/resource_manager.h" @@ -23,13 +24,25 @@ struct DebugHighlightDrawPushConstant glm::vec4 color{1.0f, 0.647f, 0.0f, 1.0f}; }; +struct DebugHighlighterDrawInfo +{ + IRenderable* highlightTarget{nullptr}; + AllocatedImage depthStencilTarget{VK_NULL_HANDLE}; + VkDescriptorBufferBindingInfoEXT sceneDataBinding{}; + VkDeviceSize sceneDataOffset{0}; +}; + class DebugHighlighter { public: explicit DebugHighlighter(ResourceManager& resourceManager); ~DebugHighlighter(); - void draw(VkCommandBuffer cmd, IRenderable* highlightTarget, VkImageView debugTarget, VkImageView depthStencilTarget) const; + void setupDescriptorBuffer(VkImageView stencilImageView, VkImageView debugTarget); + + bool drawHighlightStencil(VkCommandBuffer cmd, const DebugHighlighterDrawInfo& drawInfo) const; + + void drawHighlightProcessing(VkCommandBuffer cmd, const DebugHighlighterDrawInfo& drawInfo) const; void reloadShaders() { createPipeline(); } @@ -42,6 +55,11 @@ class DebugHighlighter { VkPipelineLayout pipelineLayout{VK_NULL_HANDLE}; VkPipeline pipeline{VK_NULL_HANDLE}; + VkDescriptorSetLayout processingSetLayout{VK_NULL_HANDLE}; + VkPipelineLayout processingPipelineLayout{VK_NULL_HANDLE}; + VkPipeline processingPipeline{VK_NULL_HANDLE}; + DescriptorBufferSampler descriptorBuffer{}; + // todo: remove friend void ImguiWrapper::imguiInterface(Engine* engine); }; diff --git a/src/renderer/vk_helpers.cpp b/src/renderer/vk_helpers.cpp index 9236b413..125d145b 100644 --- a/src/renderer/vk_helpers.cpp +++ b/src/renderer/vk_helpers.cpp @@ -280,19 +280,19 @@ void will_engine::vk_helpers::copyBuffer(VkCommandBuffer cmd, const AllocatedBuf vkCmdCopyBuffer(cmd, src.buffer, dst.buffer, 1, &vertexCopy); } -void will_engine::vk_helpers::clearColorImage(VkCommandBuffer cmd, VkImageAspectFlagBits aspectFlag, VkImage image, VkImageLayout srcLayout, +void will_engine::vk_helpers::clearColorImage(VkCommandBuffer cmd, VkImageAspectFlags aspectFlag, VkImage image, VkImageLayout srcLayout, VkImageLayout dstLayout, VkClearColorValue clearColor) { - transitionImage(cmd, image, srcLayout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - constexpr VkImageSubresourceRange range{ - .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + transitionImage(cmd, image, srcLayout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, aspectFlag); + VkImageSubresourceRange range{ + .aspectMask = aspectFlag, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1 }; vkCmdClearColorImage(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColor, 1, &range); - transitionImage(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, dstLayout, VK_IMAGE_ASPECT_COLOR_BIT); + transitionImage(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, dstLayout, aspectFlag); } diff --git a/src/renderer/vk_helpers.h b/src/renderer/vk_helpers.h index 52a3eafc..84c055d9 100644 --- a/src/renderer/vk_helpers.h +++ b/src/renderer/vk_helpers.h @@ -105,7 +105,7 @@ namespace vk_helpers void copyBuffer(VkCommandBuffer cmd, const AllocatedBuffer& src, VkDeviceSize srcOffset, const AllocatedBuffer& dst, VkDeviceSize dstOffset, VkDeviceSize size); - void clearColorImage(VkCommandBuffer cmd, VkImageAspectFlagBits aspectFlag, VkImage image, VkImageLayout srcLayout, VkImageLayout dstLayout, + void clearColorImage(VkCommandBuffer cmd, VkImageAspectFlags aspectFlag, VkImage image, VkImageLayout srcLayout, VkImageLayout dstLayout, VkClearColorValue clearColor = {0.0f, 0.0f, 0.0f, 1.0f}); void transitionImage(VkCommandBuffer cmd, VkImage image, VkImageLayout currentLayout, VkImageLayout targetLayout, VkImageAspectFlags aspectMask); From 81ed57d61538a8df75d8eab35dd13b033d44669e Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Tue, 6 May 2025 21:52:04 +0700 Subject: [PATCH 22/24] Reduce code duplication from different save image function types. --- assets/settings.willengine | 14 +- src/core/engine.cpp | 66 +-- .../assets/render_object/render_object.cpp | 4 +- src/renderer/environment/environment.cpp | 10 +- src/renderer/imgui_wrapper.cpp | 28 +- .../transparent_pipeline.cpp | 12 +- .../cascaded_shadow_map.cpp | 4 +- .../contact_shadows_pipeline.cpp | 2 +- ...round_truth_ambient_occlusion_pipeline.cpp | 16 +- .../visibility_pass_pipeline.cpp | 2 +- src/renderer/resource_manager.cpp | 4 +- src/renderer/vk_helpers.cpp | 526 +----------------- src/renderer/vk_helpers.h | 42 +- 13 files changed, 103 insertions(+), 627 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index 9f668112..4ce9c687 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - -13.128146171569824, - 37.29668045043945, - 7.1479692459106445 + 9.182855606079102, + 23.231033325195313, + 37.03011703491211 ], "rotation": [ - 0.08503364771604538, - -0.22412154078483582, - 0.019634202122688293, - 0.9706459045410156 + -0.18478946387767792, + -0.34653541445732117, + -0.06983248144388199, + 0.9170003533363342 ], "fov": 1.3089969158172607, "aspectRatio": 1.7777777910232544, diff --git a/src/core/engine.cpp b/src/core/engine.cpp index 8dd08c95..92eae9fb 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -504,9 +504,9 @@ void Engine::updateRender(VkCommandBuffer cmd, const float deltaTime, const int3 pDebugSceneData->texelSize = {1.0f / RENDER_EXTENT_WIDTH, 1.0f / RENDER_EXTENT_HEIGHT}; pDebugSceneData->deltaTime = deltaTime; - vk_helpers::synchronizeUniform(cmd, sceneDataBuffer, VK_PIPELINE_STAGE_2_HOST_BIT, VK_ACCESS_2_HOST_WRITE_BIT, + vk_helpers::uniformBarrier(cmd, sceneDataBuffer, VK_PIPELINE_STAGE_2_HOST_BIT, VK_ACCESS_2_HOST_WRITE_BIT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, VK_ACCESS_2_UNIFORM_READ_BIT); - vk_helpers::synchronizeUniform(cmd, debugSceneDataBuffer, VK_PIPELINE_STAGE_2_HOST_BIT, VK_ACCESS_2_HOST_WRITE_BIT, + vk_helpers::uniformBarrier(cmd, debugSceneDataBuffer, VK_PIPELINE_STAGE_2_HOST_BIT, VK_ACCESS_2_HOST_WRITE_BIT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, VK_ACCESS_2_UNIFORM_READ_BIT); } @@ -581,15 +581,15 @@ void Engine::render(float deltaTime) vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, drawImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); - vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); - vk_helpers::transitionImage(cmd, normalRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, normalRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, albedoRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, albedoRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, pbrRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, pbrRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, velocityRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, velocityRenderTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); environment_pipeline::EnvironmentDrawInfo environmentPipelineDrawInfo{ @@ -683,18 +683,18 @@ void Engine::render(float deltaTime) transparentPipeline->drawAccumulate(cmd, transparentDrawInfo); } - vk_helpers::transitionImage(cmd, normalRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, normalRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, albedoRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, albedoRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, pbrRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, pbrRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, velocityRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, velocityRenderTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); - vk_helpers::transitionImage(cmd, drawImage.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, drawImage.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); ambient_occlusion::GTAODrawInfo gtaoDrawInfo{ camera, @@ -734,7 +734,7 @@ void Engine::render(float deltaTime) }; deferredResolvePipeline->draw(cmd, deferredResolveDrawInfo); - vk_helpers::transitionImage(cmd, drawImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, drawImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); transparent_pipeline::TransparentCompositeDrawInfo compositeDrawInfo{ drawImage.imageView }; @@ -742,11 +742,11 @@ void Engine::render(float deltaTime) transparentPipeline->drawComposite(cmd, compositeDrawInfo); } - vk_helpers::transitionImage(cmd, drawImage.image, VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, drawImage.image, VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); const VkImageLayout originLayout = frameNumber == 0 ? VK_IMAGE_LAYOUT_UNDEFINED : VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; - vk_helpers::transitionImage(cmd, historyBuffer.image, originLayout, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, taaResolveTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, historyBuffer.image, originLayout, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, taaResolveTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); const temporal_antialiasing_pipeline::TemporalAntialiasingDrawInfo taaDrawInfo{ taaSettings.blendValue, @@ -757,15 +757,15 @@ void Engine::render(float deltaTime) temporalAntialiasingPipeline->draw(cmd, taaDrawInfo); // Copy to TAA History - vk_helpers::transitionImage(cmd, taaResolveTarget.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + vk_helpers::imageBarrier(cmd, taaResolveTarget.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, historyBuffer.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + vk_helpers::imageBarrier(cmd, historyBuffer.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); vk_helpers::copyImageToImage(cmd, taaResolveTarget.image, historyBuffer.image, RENDER_EXTENTS, RENDER_EXTENTS); - vk_helpers::transitionImage(cmd, taaResolveTarget.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, taaResolveTarget.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, finalImageBuffer.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, finalImageBuffer.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); const post_process_pipeline::PostProcessDrawInfo postProcessDrawInfo{ @@ -782,7 +782,7 @@ void Engine::render(float deltaTime) if (bDrawDebugRendering) { vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, debugTarget.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, {0.0f, 0.0f, 0.0f, 0.0f}); - vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); @@ -815,21 +815,21 @@ void Engine::render(float deltaTime) } if (stencilDrawn) { - vk_helpers::transitionImage(cmd, debugTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, debugTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, + vk_helpers::imageBarrier(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); debugHighlighter->drawHighlightProcessing(cmd, highlightDrawInfo); - vk_helpers::transitionImage(cmd, debugTarget.image, VK_IMAGE_LAYOUT_GENERAL, + vk_helpers::imageBarrier(cmd, debugTarget.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); } else { - vk_helpers::transitionImage(cmd, debugTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, debugTarget.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); } @@ -840,31 +840,31 @@ void Engine::render(float deltaTime) sceneDataDescriptorBuffer.getDescriptorBufferSize() * currentFrameOverlap }; - // Composite all draws in the debug image into the final image + // Composite all draws in the debug image into `finalImageBuffer` debugPipeline->draw(cmd, drawInfo); } #endif - vk_helpers::transitionImage(cmd, finalImageBuffer.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + vk_helpers::imageBarrier(cmd, finalImageBuffer.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + vk_helpers::imageBarrier(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); vk_helpers::copyImageToImage(cmd, finalImageBuffer.image, swapchainImages[swapchainImageIndex], RENDER_EXTENTS, swapchainExtent); - vk_helpers::transitionImage(cmd, finalImageBuffer.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, + vk_helpers::imageBarrier(cmd, finalImageBuffer.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); if (engine_constants::useImgui) { - vk_helpers::transitionImage(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + vk_helpers::imageBarrier(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); imguiWrapper->drawImgui(cmd, swapchainImageViews[swapchainImageIndex], swapchainExtent); - vk_helpers::transitionImage(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_ASPECT_COLOR_BIT); } else { - vk_helpers::transitionImage(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + vk_helpers::imageBarrier(cmd, swapchainImages[swapchainImageIndex], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_ASPECT_COLOR_BIT); } diff --git a/src/renderer/assets/render_object/render_object.cpp b/src/renderer/assets/render_object/render_object.cpp index c808cb2b..2c7228d3 100644 --- a/src/renderer/assets/render_object/render_object.cpp +++ b/src/renderer/assets/render_object/render_object.cpp @@ -62,7 +62,7 @@ void RenderObject::update(VkCommandBuffer cmd, const int32_t currentFrameOverlap renderable->setRenderFramesToUpdate(renderable->getRenderFramesToUpdate() - 1); - vk_helpers::synchronizeUniform(cmd, currentFrameModelMatrix, VK_PIPELINE_STAGE_2_HOST_BIT, VK_ACCESS_2_HOST_WRITE_BIT, + vk_helpers::uniformBarrier(cmd, currentFrameModelMatrix, VK_PIPELINE_STAGE_2_HOST_BIT, VK_ACCESS_2_HOST_WRITE_BIT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, VK_ACCESS_2_UNIFORM_READ_BIT); } } @@ -102,7 +102,7 @@ bool RenderObject::updateBuffers(VkCommandBuffer cmd, const int32_t currentFrame *pPrimitiveData = pair.second; } - vk_helpers::synchronizeUniform(cmd, currentPrimitiveBuffer, VK_PIPELINE_STAGE_2_HOST_BIT + vk_helpers::uniformBarrier(cmd, currentPrimitiveBuffer, VK_PIPELINE_STAGE_2_HOST_BIT , VK_ACCESS_2_HOST_WRITE_BIT , VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT , VK_ACCESS_2_UNIFORM_READ_BIT); diff --git a/src/renderer/environment/environment.cpp b/src/renderer/environment/environment.cpp index 13aac207..24105281 100644 --- a/src/renderer/environment/environment.cpp +++ b/src/renderer/environment/environment.cpp @@ -233,7 +233,7 @@ will_engine::environment::Environment::Environment(ResourceManager& resourceMana resourceManager.setupDescriptorBufferSampler(lutDescriptorBuffer, descriptor, 0); immediate.submit([&](VkCommandBuffer cmd) { - vk_helpers::transitionImage(cmd, lutImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, lutImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, lutPipeline); @@ -253,7 +253,7 @@ will_engine::environment::Environment::Environment(ResourceManager& resourceMana constexpr uint32_t z_disp = 1; vkCmdDispatch(cmd, xDisp, yDisp, z_disp); - vk_helpers::transitionImage(cmd, lutImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, lutImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); }); } @@ -366,7 +366,7 @@ void will_engine::environment::Environment::loadEnvironment(const char* name, co immediate.submit([&](VkCommandBuffer cmd) { - vk_helpers::transitionImage(cmd, newEnvMapData.cubemapImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, newEnvMapData.cubemapImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, equiToCubemapPipeline); @@ -432,7 +432,7 @@ void will_engine::environment::Environment::loadEnvironment(const char* name, co } immediate.submit([&](VkCommandBuffer cmd) { - vk_helpers::transitionImage(cmd, specDiffCubemap.allocatedImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, specDiffCubemap.allocatedImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); VkDescriptorBufferBindingInfoEXT descriptorBufferBindingInfo[2]; @@ -497,7 +497,7 @@ void will_engine::environment::Environment::loadEnvironment(const char* name, co } - vk_helpers::transitionImage(cmd, specDiffCubemap.allocatedImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, specDiffCubemap.allocatedImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); }); diff --git a/src/renderer/imgui_wrapper.cpp b/src/renderer/imgui_wrapper.cpp index 969b11aa..981e6d3a 100644 --- a/src/renderer/imgui_wrapper.cpp +++ b/src/renderer/imgui_wrapper.cpp @@ -639,8 +639,7 @@ void ImguiWrapper::imguiInterface(Engine* engine) if (ImGui::Button("Save Draw Image")) { if (file::getOrCreateDirectory(file::imagesSavePath)) { const std::filesystem::path path = file::imagesSavePath / "drawImage.png"; - vk_helpers::saveImageRGBA16SFLOAT(*engine->resourceManager, *engine->immediate, engine->drawImage, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT, path.string().c_str()); + vk_helpers::saveImage(*engine->resourceManager, *engine->immediate, engine->drawImage, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, vk_helpers::ImageFormat::RGBA16F, path.string()); } else { fmt::print(" Failed to find/create image save path directory"); @@ -679,14 +678,7 @@ void ImguiWrapper::imguiInterface(Engine* engine) if (ImGui::Button("Save Albedo Render Target")) { if (file::getOrCreateDirectory(file::imagesSavePath)) { const std::filesystem::path path = file::imagesSavePath / "albedoRT.png"; - auto unpackFunc = [](const uint32_t packedColor) { - glm::vec4 pixel = glm::unpackUnorm4x8(packedColor); - pixel.a = 1.0f; - return pixel; - }; - vk_helpers::savePacked32Bit(*engine->resourceManager, *engine->immediate, engine->albedoRenderTarget, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT, path.string().c_str(), - unpackFunc); + vk_helpers::saveImage(*engine->resourceManager, *engine->immediate, engine->albedoRenderTarget, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, vk_helpers::ImageFormat::RGBA16F, path.string()); } else { fmt::print(" Failed to save albedo render target"); @@ -696,25 +688,17 @@ void ImguiWrapper::imguiInterface(Engine* engine) if (ImGui::Button("Save PBR Render Target")) { if (file::getOrCreateDirectory(file::imagesSavePath)) { std::filesystem::path path = file::imagesSavePath / "pbrRT.png"; - auto unpackFunc = [](const uint32_t packedColor) { - glm::vec4 pixel = glm::unpackUnorm4x8(packedColor); - pixel.a = 1.0f; - return pixel; - }; - vk_helpers::savePacked32Bit(*engine->resourceManager, *engine->immediate, engine->pbrRenderTarget, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT, path.string().c_str(), - unpackFunc); + vk_helpers::saveImage(*engine->resourceManager, *engine->immediate, engine->pbrRenderTarget, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, vk_helpers::ImageFormat::RGBA8_UNORM, path.string()); } else { fmt::print(" Failed to save pbr render target"); } } - if (ImGui::Button("Save Post Process Resolve Target")) { + if (ImGui::Button("Save Final Image")) { if (file::getOrCreateDirectory(file::imagesSavePath)) { - std::filesystem::path path = file::imagesSavePath / "postProcesResolve.png"; - vk_helpers::saveImageRGBA16SFLOAT(*engine->resourceManager, *engine->immediate, engine->finalImageBuffer, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT, path.string().c_str()); + std::filesystem::path path = file::imagesSavePath / "finalImage.png"; + vk_helpers::saveImage(*engine->resourceManager, *engine->immediate, engine->finalImageBuffer, VK_IMAGE_LAYOUT_GENERAL, vk_helpers::ImageFormat::RGBA16F, path.string()); } else { fmt::print(" Failed to find/create image save path directory"); diff --git a/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp b/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp index 9cc43eb3..71cf394e 100644 --- a/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp +++ b/src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline.cpp @@ -119,11 +119,11 @@ void TransparentPipeline::drawAccumulate(VkCommandBuffer cmd, const TransparentA label.pLabelName = "Transparent Accumulation Pass (Render Objects)"; vkCmdBeginDebugUtilsLabelEXT(cmd, &label); - vk_helpers::transitionImage(cmd, accumulationImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, accumulationImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, revealageImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, revealageImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, debugImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, debugImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); @@ -219,11 +219,11 @@ void TransparentPipeline::drawAccumulate(VkCommandBuffer cmd, const TransparentA vkCmdEndRendering(cmd); - vk_helpers::transitionImage(cmd, accumulationImage.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, accumulationImage.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, revealageImage.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, revealageImage.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, debugImage.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, debugImage.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); vkCmdEndDebugUtilsLabelEXT(cmd); diff --git a/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp b/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp index 5b753335..0cb928c7 100644 --- a/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp +++ b/src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.cpp @@ -206,7 +206,7 @@ void will_engine::cascaded_shadows::CascadedShadowMap::draw(VkCommandBuffer cmd, continue; } - vk_helpers::transitionImage(cmd, cascadeShadowMapData.depthShadowMap.image, VK_IMAGE_LAYOUT_UNDEFINED, + vk_helpers::imageBarrier(cmd, cascadeShadowMapData.depthShadowMap.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT); @@ -352,7 +352,7 @@ void will_engine::cascaded_shadows::CascadedShadowMap::draw(VkCommandBuffer cmd, vkCmdEndRendering(cmd); } - vk_helpers::transitionImage(cmd, cascadeShadowMapData.depthShadowMap.image, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, + vk_helpers::imageBarrier(cmd, cascadeShadowMapData.depthShadowMap.image, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT); } diff --git a/src/renderer/pipelines/shadows/contact_shadow/contact_shadows_pipeline.cpp b/src/renderer/pipelines/shadows/contact_shadow/contact_shadows_pipeline.cpp index 751b2897..148e3735 100644 --- a/src/renderer/pipelines/shadows/contact_shadow/contact_shadows_pipeline.cpp +++ b/src/renderer/pipelines/shadows/contact_shadow/contact_shadows_pipeline.cpp @@ -118,7 +118,7 @@ void ContactShadowsPipeline::setupDescriptorBuffer(const VkImageView& depthImage void ContactShadowsPipeline::draw(VkCommandBuffer cmd, const ContactShadowsDrawInfo& drawInfo) { - vk_helpers::transitionImage(cmd, debugImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, debugImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, contactShadowImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL); if (!drawInfo.bIsEnabled) { diff --git a/src/renderer/pipelines/shadows/ground_truth_ambient_occlusion/ground_truth_ambient_occlusion_pipeline.cpp b/src/renderer/pipelines/shadows/ground_truth_ambient_occlusion/ground_truth_ambient_occlusion_pipeline.cpp index 9ac5e28b..c365595e 100644 --- a/src/renderer/pipelines/shadows/ground_truth_ambient_occlusion/ground_truth_ambient_occlusion_pipeline.cpp +++ b/src/renderer/pipelines/shadows/ground_truth_ambient_occlusion/ground_truth_ambient_occlusion_pipeline.cpp @@ -388,14 +388,14 @@ void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::draw(V drawInfo.push.noiseIndex = GTAO_DENOISE_PASSES > 0 ? drawInfo.currentFrame % 64 : 0; - vk_helpers::transitionImage(cmd, debugImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, debugImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, depthPrefilterImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL); if (!drawInfo.bEnabled) { vk_helpers::clearColorImage(cmd, VK_IMAGE_ASPECT_COLOR_BIT, denoisedFinalAO.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, {1.0f, 1.0f, 1.0f, 1.0f}); - vk_helpers::transitionImage(cmd, debugImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, debugImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); return; } @@ -420,9 +420,9 @@ void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::draw(V vkCmdDispatch(cmd, x, y, 1); } - vk_helpers::transitionImage(cmd, depthPrefilterImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, depthPrefilterImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, ambientOcclusionImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, ambientOcclusionImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); // Ambient Occlusion { vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, ambientOcclusionPipeline); @@ -444,9 +444,9 @@ void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::draw(V } - vk_helpers::transitionImage(cmd, ambientOcclusionImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, ambientOcclusionImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, denoisedFinalAO.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, + vk_helpers::imageBarrier(cmd, denoisedFinalAO.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); // Spatial Filtering { @@ -469,11 +469,11 @@ void will_engine::ambient_occlusion::GroundTruthAmbientOcclusionPipeline::draw(V vkCmdDispatch(cmd, x, y, 1); } - vk_helpers::transitionImage(cmd, denoisedFinalAO.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, denoisedFinalAO.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); - vk_helpers::transitionImage(cmd, debugImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, debugImage.image, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); vkCmdEndDebugUtilsLabelEXT(cmd); diff --git a/src/renderer/pipelines/visibility_pass/visibility_pass_pipeline.cpp b/src/renderer/pipelines/visibility_pass/visibility_pass_pipeline.cpp index acc31761..86ae01be 100644 --- a/src/renderer/pipelines/visibility_pass/visibility_pass_pipeline.cpp +++ b/src/renderer/pipelines/visibility_pass/visibility_pass_pipeline.cpp @@ -86,7 +86,7 @@ void will_engine::visibility_pass_pipeline::VisibilityPassPipeline::draw(VkComma vkCmdDispatch(cmd, static_cast(std::ceil(static_cast(renderObject->getOpaqueDrawIndirectCommandCount()) / 64.0f)), 1, 1); - vk_helpers::synchronizeUniform(cmd, renderObject->getOpaqueIndirectBuffer(drawInfo.currentFrameOverlap), + vk_helpers::uniformBarrier(cmd, renderObject->getOpaqueIndirectBuffer(drawInfo.currentFrameOverlap), VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT, VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT); } diff --git a/src/renderer/resource_manager.cpp b/src/renderer/resource_manager.cpp index 3c30a72c..e669bbbe 100644 --- a/src/renderer/resource_manager.cpp +++ b/src/renderer/resource_manager.cpp @@ -516,7 +516,7 @@ AllocatedImage will_engine::ResourceManager::createImage(const void* data, const const AllocatedImage newImage = createImage(size, format, usage | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, mipmapped); immediate.submit([&](VkCommandBuffer cmd) { - vk_helpers::transitionImage(cmd, newImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); + vk_helpers::imageBarrier(cmd, newImage.image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); VkBufferImageCopy copyRegion = {}; copyRegion.bufferOffset = 0; @@ -536,7 +536,7 @@ AllocatedImage will_engine::ResourceManager::createImage(const void* data, const vk_helpers::generateMipmaps(cmd, newImage.image, VkExtent2D{newImage.imageExtent.width, newImage.imageExtent.height}); } else { - vk_helpers::transitionImage(cmd, newImage.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + vk_helpers::imageBarrier(cmd, newImage.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); } }); diff --git a/src/renderer/vk_helpers.cpp b/src/renderer/vk_helpers.cpp index 125d145b..a2fff3ae 100644 --- a/src/renderer/vk_helpers.cpp +++ b/src/renderer/vk_helpers.cpp @@ -283,7 +283,7 @@ void will_engine::vk_helpers::copyBuffer(VkCommandBuffer cmd, const AllocatedBuf void will_engine::vk_helpers::clearColorImage(VkCommandBuffer cmd, VkImageAspectFlags aspectFlag, VkImage image, VkImageLayout srcLayout, VkImageLayout dstLayout, VkClearColorValue clearColor) { - transitionImage(cmd, image, srcLayout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, aspectFlag); + imageBarrier(cmd, image, srcLayout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, aspectFlag); VkImageSubresourceRange range{ .aspectMask = aspectFlag, .baseMipLevel = 0, @@ -292,11 +292,11 @@ void will_engine::vk_helpers::clearColorImage(VkCommandBuffer cmd, VkImageAspect .layerCount = 1 }; vkCmdClearColorImage(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColor, 1, &range); - transitionImage(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, dstLayout, aspectFlag); + imageBarrier(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, dstLayout, aspectFlag); } -void will_engine::vk_helpers::transitionImage(VkCommandBuffer cmd, VkImage image, VkImageLayout currentLayout, VkImageLayout targetLayout, +void will_engine::vk_helpers::imageBarrier(VkCommandBuffer cmd, VkImage image, VkImageLayout currentLayout, VkImageLayout targetLayout, VkImageAspectFlags aspectMask) { VkImageMemoryBarrier2 imageBarrier{.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2}; @@ -323,7 +323,7 @@ void will_engine::vk_helpers::transitionImage(VkCommandBuffer cmd, VkImage image vkCmdPipelineBarrier2(cmd, &depInfo); } -void will_engine::vk_helpers::synchronizeUniform(VkCommandBuffer cmd, const AllocatedBuffer& buffer, VkPipelineStageFlagBits2 srcPipelineStage, +void will_engine::vk_helpers::uniformBarrier(VkCommandBuffer cmd, const AllocatedBuffer& buffer, VkPipelineStageFlagBits2 srcPipelineStage, VkAccessFlagBits2 srcAccessBit, VkPipelineStageFlagBits2 dstPipelineStage, VkAccessFlagBits2 dstAccessBit) { @@ -387,40 +387,6 @@ void will_engine::vk_helpers::copyImageToImage(VkCommandBuffer cmd, VkImage sour vkCmdBlitImage2(cmd, &blitInfo); } -void will_engine::vk_helpers::copyDepthToDepth(VkCommandBuffer cmd, VkImage source, VkImage destination, VkExtent2D srcSize, VkExtent2D dstSize) -{ - VkImageBlit2 blitRegion{.sType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, .pNext = nullptr}; - - blitRegion.srcOffsets[1].x = srcSize.width; - blitRegion.srcOffsets[1].y = srcSize.height; - blitRegion.srcOffsets[1].z = 1; - - blitRegion.dstOffsets[1].x = dstSize.width; - blitRegion.dstOffsets[1].y = dstSize.height; - blitRegion.dstOffsets[1].z = 1; - - blitRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; - blitRegion.srcSubresource.baseArrayLayer = 0; - blitRegion.srcSubresource.layerCount = 1; - blitRegion.srcSubresource.mipLevel = 0; - - blitRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; - blitRegion.dstSubresource.baseArrayLayer = 0; - blitRegion.dstSubresource.layerCount = 1; - blitRegion.dstSubresource.mipLevel = 0; - - VkBlitImageInfo2 blitInfo{.sType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, .pNext = nullptr}; - blitInfo.dstImage = destination; - blitInfo.dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; - blitInfo.srcImage = source; - blitInfo.srcImageLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - blitInfo.filter = VK_FILTER_NEAREST; - blitInfo.regionCount = 1; - blitInfo.pRegions = &blitRegion; - - vkCmdBlitImage2(cmd, &blitInfo); -} - void will_engine::vk_helpers::generateMipmaps(VkCommandBuffer cmd, VkImage image, VkExtent2D imageSize) { const int mipLevels = static_cast(std::floor(std::log2(std::max(imageSize.width, imageSize.height)))) + 1; @@ -488,13 +454,13 @@ void will_engine::vk_helpers::generateMipmaps(VkCommandBuffer cmd, VkImage image } // transition all mip levels into the final read_only layout - transitionImage(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); + imageBarrier(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); } void will_engine::vk_helpers::generateMipmapsCubemap(VkCommandBuffer cmd, VkImage image, VkExtent2D imageSize, VkImageLayout inputLayout, VkImageLayout ouputLayout) { - transitionImage(cmd, image, inputLayout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); + imageBarrier(cmd, image, inputLayout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT); const int mipLevels = static_cast(std::floor(std::log2(std::max(imageSize.width, imageSize.height)))) + 1; for (int mip = 0; mip < mipLevels; mip++) { @@ -561,7 +527,7 @@ void will_engine::vk_helpers::generateMipmapsCubemap(VkCommandBuffer cmd, VkImag } // transition all mip levels into the final read_only layout - transitionImage(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, ouputLayout, VK_IMAGE_ASPECT_COLOR_BIT); + imageBarrier(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, ouputLayout, VK_IMAGE_ASPECT_COLOR_BIT); } VkPipelineLayoutCreateInfo will_engine::vk_helpers::pipelineLayoutCreateInfo() @@ -594,196 +560,6 @@ VkPipelineShaderStageCreateInfo will_engine::vk_helpers::pipelineShaderStageCrea return info; } - -void will_engine::vk_helpers::saveImageRGBA32F(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& image, const VkImageLayout imageLayout, - const VkImageAspectFlags aspectFlag, - const char* savePath, const bool overrideAlpha) -{ - constexpr int channelCount = 4; - const size_t dataSize = image.imageExtent.width * image.imageExtent.height * channelCount * sizeof(float); - AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); - - immediate.submit([&](VkCommandBuffer cmd) { - VkBufferImageCopy bufferCopyRegion{}; - bufferCopyRegion.imageSubresource.aspectMask = aspectFlag; - bufferCopyRegion.imageSubresource.mipLevel = 0; - bufferCopyRegion.imageSubresource.baseArrayLayer = 0; - bufferCopyRegion.imageSubresource.layerCount = 1; - bufferCopyRegion.imageExtent = image.imageExtent; - bufferCopyRegion.bufferOffset = 0; - bufferCopyRegion.bufferRowLength = 0; - bufferCopyRegion.bufferImageHeight = 0; - - vk_helpers::transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectFlag); - - vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); - - vk_helpers::transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, VK_IMAGE_ASPECT_COLOR_BIT); - }); - - void* data = receivingBuffer.info.pMappedData; - const auto imageData = static_cast(data); - - const auto byteImageData = new uint8_t[image.imageExtent.width * image.imageExtent.height * 4]; - const auto powEight = static_cast(pow(2, 8) - 1); - for (size_t i = 0; i < image.imageExtent.width * image.imageExtent.height; ++i) { - for (int j = 0; j < channelCount; j++) { - const auto value = static_cast(imageData[i * channelCount + j] * powEight); - byteImageData[i * 4 + j] = value; - } - - if (overrideAlpha) { - byteImageData[i * 4 + 3] = 255; - } - } - - stbi_write_png(savePath, image.imageExtent.width, image.imageExtent.height, 4, byteImageData, image.imageExtent.width * 4); - - delete[] byteImageData; - resourceManager.destroyImmediate(receivingBuffer); -} - -void will_engine::vk_helpers::saveImageRGBA16SFLOAT(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& image, VkImageLayout imageLayout, - VkImageAspectFlags aspectFlag, - const char* savePath, const bool overrideAlpha) -{ - using half_float::half; - constexpr int channelCount = 4; - const size_t dataSize = image.imageExtent.width * image.imageExtent.height * channelCount * sizeof(half); - AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); - - immediate.submit([&](VkCommandBuffer cmd) { - VkBufferImageCopy bufferCopyRegion{}; - bufferCopyRegion.imageSubresource.aspectMask = aspectFlag; - bufferCopyRegion.imageSubresource.mipLevel = 0; - bufferCopyRegion.imageSubresource.baseArrayLayer = 0; - bufferCopyRegion.imageSubresource.layerCount = 1; - bufferCopyRegion.imageExtent = image.imageExtent; - bufferCopyRegion.bufferOffset = 0; - bufferCopyRegion.bufferRowLength = 0; - bufferCopyRegion.bufferImageHeight = 0; - - vk_helpers::transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectFlag); - - vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); - - vk_helpers::transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, VK_IMAGE_ASPECT_COLOR_BIT); - }); - - void* data = receivingBuffer.info.pMappedData; - const auto imageData = static_cast(data); - - const auto byteImageData = new uint8_t[image.imageExtent.width * image.imageExtent.height * 4]; - for (size_t i = 0; i < image.imageExtent.width * image.imageExtent.height; ++i) { - for (int j = 0; j < channelCount; j++) { - auto value = static_cast(imageData[i * channelCount + j]); - value = std::max(0.0f, std::min(1.0f, value)); - byteImageData[i * 4 + j] = static_cast(std::lround(value * 255.0f)); - } - - if (overrideAlpha) { - byteImageData[i * 4 + 3] = 255; - } - } - - stbi_write_png(savePath, image.imageExtent.width, image.imageExtent.height, 4, byteImageData, image.imageExtent.width * 4); - - delete[] byteImageData; - resourceManager.destroyImmediate(receivingBuffer); -} - -void will_engine::vk_helpers::savePacked32Bit(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& image, VkImageLayout imageLayout, VkImageAspectFlags aspectFlag, - const char* savePath, const std::function& unpackingFunction) -{ - const size_t dataSize = image.imageExtent.width * image.imageExtent.height * sizeof(uint32_t); - AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); - - immediate.submit([&](VkCommandBuffer cmd) { - VkBufferImageCopy bufferCopyRegion{}; - bufferCopyRegion.imageSubresource.aspectMask = aspectFlag; - bufferCopyRegion.imageSubresource.mipLevel = 0; - bufferCopyRegion.imageSubresource.baseArrayLayer = 0; - bufferCopyRegion.imageSubresource.layerCount = 1; - bufferCopyRegion.imageExtent = image.imageExtent; - bufferCopyRegion.bufferOffset = 0; - bufferCopyRegion.bufferRowLength = 0; - bufferCopyRegion.bufferImageHeight = 0; - - vk_helpers::transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectFlag); - - vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); - - vk_helpers::transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, VK_IMAGE_ASPECT_COLOR_BIT); - }); - - void* data = receivingBuffer.info.pMappedData; - const auto imageData = static_cast(data); - - const auto byteImageData = new uint8_t[image.imageExtent.width * image.imageExtent.height * 4]; - const auto powEight = powf(2, 8) - 1; - for (size_t i = 0; i < image.imageExtent.width * image.imageExtent.height; ++i) { - const glm::vec4 pixel = unpackingFunction(imageData[i]); - - byteImageData[i * 4] = static_cast(pixel.r * powEight); - byteImageData[i * 4 + 1] = static_cast(pixel.g * powEight); - byteImageData[i * 4 + 2] = static_cast(pixel.b * powEight); - byteImageData[i * 4 + 3] = static_cast(pixel.a * powEight); - } - - stbi_write_png(savePath, image.imageExtent.width, image.imageExtent.height, 4, byteImageData, image.imageExtent.width * 4); - - delete[] byteImageData; - resourceManager.destroyImmediate(receivingBuffer); -} - -void will_engine::vk_helpers::savePacked64Bit(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& image, VkImageLayout imageLayout, VkImageAspectFlags aspectFlag, - const char* savePath, const std::function& unpackingFunction) -{ - const size_t dataSize = image.imageExtent.width * image.imageExtent.height * sizeof(uint64_t); - AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); - - immediate.submit([&](VkCommandBuffer cmd) { - VkBufferImageCopy bufferCopyRegion{}; - bufferCopyRegion.imageSubresource.aspectMask = aspectFlag; - bufferCopyRegion.imageSubresource.mipLevel = 0; - bufferCopyRegion.imageSubresource.baseArrayLayer = 0; - bufferCopyRegion.imageSubresource.layerCount = 1; - bufferCopyRegion.imageExtent = image.imageExtent; - bufferCopyRegion.bufferOffset = 0; - bufferCopyRegion.bufferRowLength = 0; - bufferCopyRegion.bufferImageHeight = 0; - - vk_helpers::transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectFlag); - - vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); - - vk_helpers::transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, VK_IMAGE_ASPECT_COLOR_BIT); - }); - - void* data = receivingBuffer.info.pMappedData; - const auto imageData = static_cast(data); - - const auto byteImageData = new uint8_t[image.imageExtent.width * image.imageExtent.height * 4]; - const auto powEight = powf(2, 8) - 1; - for (size_t i = 0; i < image.imageExtent.width * image.imageExtent.height; ++i) { - const glm::vec4 pixel = unpackingFunction(imageData[i]); - - byteImageData[i * 4] = static_cast(pixel.r * powEight); - byteImageData[i * 4 + 1] = static_cast(pixel.g * powEight); - byteImageData[i * 4 + 2] = static_cast(pixel.b * powEight); - byteImageData[i * 4 + 3] = static_cast(pixel.a * powEight); - } - - stbi_write_png(savePath, image.imageExtent.width, image.imageExtent.height, 4, byteImageData, image.imageExtent.width * 4); - - delete[] byteImageData; - resourceManager.destroyImmediate(receivingBuffer); -} - void will_engine::vk_helpers::saveImageR32F(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, VkImageLayout imageLayout, VkImageAspectFlags aspectFlag, const char* savePath, const std::function& valueTransform, int32_t mipLevel) @@ -805,11 +581,11 @@ void will_engine::vk_helpers::saveImageR32F(const ResourceManager& resourceManag bufferCopyRegion.bufferRowLength = 0; bufferCopyRegion.bufferImageHeight = 0; - transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectFlag); + imageBarrier(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectFlag); vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); - transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, aspectFlag); + imageBarrier(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, aspectFlag); }); void* data = receivingBuffer.info.pMappedData; @@ -832,268 +608,6 @@ void will_engine::vk_helpers::saveImageR32F(const ResourceManager& resourceManag resourceManager.destroyImmediate(receivingBuffer); } -void will_engine::vk_helpers::saveImageR16F(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, - VkImageLayout imageLayout, - VkImageAspectFlags aspectFlag, const char* savePath, const std::function& valueTransform, - int32_t mipLevel) -{ - size_t newXSize = image.imageExtent.width / static_cast(std::pow(2, mipLevel)); - size_t newYSize = image.imageExtent.height / static_cast(std::pow(2, mipLevel)); - const size_t texelCount = newXSize * newYSize; - const size_t dataSize = texelCount * 1 * sizeof(uint16_t); - AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); - - immediate.submit([&, mipLevel](VkCommandBuffer cmd) { - VkBufferImageCopy bufferCopyRegion{}; - bufferCopyRegion.imageSubresource.aspectMask = aspectFlag; - bufferCopyRegion.imageSubresource.mipLevel = mipLevel; - bufferCopyRegion.imageSubresource.baseArrayLayer = 0; - bufferCopyRegion.imageSubresource.layerCount = 1; - bufferCopyRegion.imageExtent = {static_cast(newXSize), static_cast(newYSize), 1u}; - bufferCopyRegion.bufferOffset = 0; - bufferCopyRegion.bufferRowLength = 0; - bufferCopyRegion.bufferImageHeight = 0; - - transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectFlag); - - vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); - - transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, aspectFlag); - }); - - void* data = receivingBuffer.info.pMappedData; - const auto imageData = static_cast(data); - - - const auto byteImageData = new uint8_t[texelCount * 4]; - const auto powEight = static_cast(pow(2, 8) - 1); - for (size_t i = 0; i < texelCount; ++i) { - const uint16_t rvalue = imageData[i]; - const float floatValue = valueTransform(rvalue); - const auto value = static_cast(floatValue * powEight); - byteImageData[i * 4 + 0] = value; - byteImageData[i * 4 + 1] = value; - byteImageData[i * 4 + 2] = value; - byteImageData[i * 4 + 3] = 255; - } - - stbi_write_png(savePath, static_cast(newXSize), static_cast(newYSize), 4, byteImageData, static_cast(newXSize) * 4); - - delete[] byteImageData; - resourceManager.destroyImmediate(receivingBuffer); -} - -void will_engine::vk_helpers::saveImageR8UNORM(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& image, VkImageLayout imageLayout, const char* savePath, int32_t mipLevel) -{ - const size_t width = image.imageExtent.width / static_cast(std::pow(2, mipLevel)); - const size_t height = image.imageExtent.height / static_cast(std::pow(2, mipLevel)); - const size_t texelCount = width * height; - const size_t dataSize = texelCount * 1 * sizeof(uint8_t); - - AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); - - immediate.submit([&, mipLevel](VkCommandBuffer cmd) { - VkBufferImageCopy bufferCopyRegion{}; - bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - bufferCopyRegion.imageSubresource.mipLevel = mipLevel; - bufferCopyRegion.imageSubresource.baseArrayLayer = 0; - bufferCopyRegion.imageSubresource.layerCount = 1; - bufferCopyRegion.imageExtent = {static_cast(width), static_cast(height), 1u}; - bufferCopyRegion.bufferOffset = 0; - bufferCopyRegion.bufferRowLength = 0; - bufferCopyRegion.bufferImageHeight = 0; - - transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); - - vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); - - transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, VK_IMAGE_ASPECT_COLOR_BIT); - }); - - void* data = receivingBuffer.info.pMappedData; - const auto imageData = static_cast(data); - - const auto byteImageData = new uint8_t[texelCount * 4]; - for (size_t i = 0; i < texelCount; ++i) { - const auto value = imageData[i]; - byteImageData[i * 4 + 0] = value; - byteImageData[i * 4 + 1] = value; - byteImageData[i * 4 + 2] = value; - byteImageData[i * 4 + 3] = 255; - } - - stbi_write_png(savePath, static_cast(width), static_cast(height), 4, byteImageData, static_cast(width) * 4); - - delete[] byteImageData; - resourceManager.destroyImmediate(receivingBuffer); -} - -void will_engine::vk_helpers::saveImageR8UINT(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& image, VkImageLayout imageLayout, const char* savePath, - VkImageAspectFlagBits aspectFlag, int32_t mipLevel) -{ - const size_t width = image.imageExtent.width / static_cast(std::pow(2, mipLevel)); - const size_t height = image.imageExtent.height / static_cast(std::pow(2, mipLevel)); - const size_t texelCount = width * height; - const size_t dataSize = texelCount * 1 * sizeof(uint8_t); - - AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); - - immediate.submit([&, mipLevel](VkCommandBuffer cmd) { - VkBufferImageCopy bufferCopyRegion{}; - bufferCopyRegion.imageSubresource.aspectMask = aspectFlag; - bufferCopyRegion.imageSubresource.mipLevel = mipLevel; - bufferCopyRegion.imageSubresource.baseArrayLayer = 0; - bufferCopyRegion.imageSubresource.layerCount = 1; - bufferCopyRegion.imageExtent = {static_cast(width), static_cast(height), 1u}; - bufferCopyRegion.bufferOffset = 0; - bufferCopyRegion.bufferRowLength = 0; - bufferCopyRegion.bufferImageHeight = 0; - - transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectFlag); - - vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); - - transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, aspectFlag); - }); - - void* data = receivingBuffer.info.pMappedData; - const auto imageData = static_cast(data); - - const auto byteImageData = new uint8_t[texelCount * 4]; - for (size_t i = 0; i < texelCount; ++i) { - const auto value = imageData[i]; - byteImageData[i * 4 + 0] = value; - byteImageData[i * 4 + 1] = value; - byteImageData[i * 4 + 2] = value; - byteImageData[i * 4 + 3] = 255; - } - - stbi_write_png(savePath, static_cast(width), static_cast(height), 4, byteImageData, static_cast(width) * 4); - - delete[] byteImageData; - resourceManager.destroyImmediate(receivingBuffer); -} - -void will_engine::vk_helpers::saveStencilBuffer(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& depthStencilImage, VkImageLayout imageLayout, const char* savePath) -{ - const size_t width = depthStencilImage.imageExtent.width; - const size_t height = depthStencilImage.imageExtent.height; - const size_t texelCount = width * height; - const size_t dataSize = texelCount * sizeof(uint8_t); - - AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); - - immediate.submit([&](VkCommandBuffer cmd) { - VkBufferImageCopy bufferCopyRegion{}; - bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; - bufferCopyRegion.imageSubresource.mipLevel = 0; - bufferCopyRegion.imageSubresource.baseArrayLayer = 0; - bufferCopyRegion.imageSubresource.layerCount = 1; - bufferCopyRegion.imageExtent = {static_cast(width), static_cast(height), 1u}; - bufferCopyRegion.bufferOffset = 0; - bufferCopyRegion.bufferRowLength = 0; - bufferCopyRegion.bufferImageHeight = 0; - - transitionImage(cmd, depthStencilImage.image, imageLayout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); - - vkCmdCopyImageToBuffer(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - receivingBuffer.buffer, 1, &bufferCopyRegion); - - // Transition back - transitionImage(cmd, depthStencilImage.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, imageLayout, - VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); - }); - - void* data = receivingBuffer.info.pMappedData; - const auto stencilData = static_cast(data); - - // Convert to RGBA for PNG output - const auto byteImageData = new uint8_t[texelCount * 4]; - for (size_t i = 0; i < texelCount; ++i) { - const auto value = stencilData[i]; - byteImageData[i * 4 + 0] = value; - byteImageData[i * 4 + 1] = value; - byteImageData[i * 4 + 2] = value; - byteImageData[i * 4 + 3] = 255; - } - - stbi_write_png(savePath, static_cast(width), static_cast(height), 4, byteImageData, static_cast(width) * 4); - - delete[] byteImageData; - resourceManager.destroyImmediate(receivingBuffer); -} - -void will_engine::vk_helpers::saveImageR8G8B8A8UNORM(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& image, VkImageLayout imageLayout, const char* savePath, int32_t mipLevel) -{ - const size_t width = image.imageExtent.width / static_cast(std::pow(2, mipLevel)); - const size_t height = image.imageExtent.height / static_cast(std::pow(2, mipLevel)); - const size_t texelCount = width * height; - const size_t dataSize = texelCount * 4 * sizeof(uint8_t); - - AllocatedBuffer receivingBuffer = resourceManager.createReceivingBuffer(dataSize); - - immediate.submit([&, mipLevel](VkCommandBuffer cmd) { - VkBufferImageCopy bufferCopyRegion{}; - bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - bufferCopyRegion.imageSubresource.mipLevel = mipLevel; - bufferCopyRegion.imageSubresource.baseArrayLayer = 0; - bufferCopyRegion.imageSubresource.layerCount = 1; - bufferCopyRegion.imageExtent = {static_cast(width), static_cast(height), 1u}; - bufferCopyRegion.bufferOffset = 0; - bufferCopyRegion.bufferRowLength = 0; - bufferCopyRegion.bufferImageHeight = 0; - - transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_ASPECT_COLOR_BIT); - - vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); - - transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, VK_IMAGE_ASPECT_COLOR_BIT); - }); - - void* data = receivingBuffer.info.pMappedData; - const auto imageData = static_cast(data); - - const auto byteImageData = new uint8_t[texelCount * 4]; - for (size_t i = 0; i < texelCount; ++i) { - const auto value = imageData[i]; - byteImageData[i * 4 + 0] = imageData[i * 4 + 0]; - byteImageData[i * 4 + 1] = imageData[i * 4 + 1]; - byteImageData[i * 4 + 2] = imageData[i * 4 + 2]; - // overwrite alpha to 1.0f - byteImageData[i * 4 + 3] = 255; - } - - stbi_write_png(savePath, static_cast(width), static_cast(height), 4, byteImageData, static_cast(width) * 4); - - delete[] byteImageData; - resourceManager.destroyImmediate(receivingBuffer); -} - -void will_engine::vk_helpers::saveImage(const std::vector& imageData, int width, int height, std::filesystem::path filename, - bool overrideAlpha) -{ - const auto byteImageData = new uint8_t[width * height * 4]; - for (size_t i = 0; i < width * height; ++i) { - for (int j = 0; j < 4; j++) { - auto value = static_cast(imageData[i * 4 + j]); - value = std::max(0.0f, std::min(1.0f, value)); - byteImageData[i * 4 + j] = static_cast(std::lround(value * 255.0f)); - } - - if (overrideAlpha) { - byteImageData[i * 4 + 3] = 255; - } - } - - stbi_write_png(filename.string().c_str(), width, height, 4, byteImageData, width * 4); - delete[] byteImageData; -} - void will_engine::vk_helpers::saveHeightmap(const std::vector& heightData, int width, int height, const std::filesystem::path& filename) { float minHeight = std::numeric_limits::max(); @@ -1123,9 +637,11 @@ will_engine::vk_helpers::FormatInfo will_engine::vk_helpers::getFormatInfo(Image case ImageFormat::RGBA32F: return {16, VK_IMAGE_ASPECT_COLOR_BIT}; case ImageFormat::RGBA16F: - return {8, VK_IMAGE_ASPECT_COLOR_BIT}; + return {sizeof(half_float::half) * 4, VK_IMAGE_ASPECT_COLOR_BIT}; case ImageFormat::RGBA8: return {4, VK_IMAGE_ASPECT_COLOR_BIT}; + case ImageFormat::RGBA8_UNORM: + return {sizeof(uint8_t) * 4, VK_IMAGE_ASPECT_COLOR_BIT}; case ImageFormat::R32F: return {4, VK_IMAGE_ASPECT_COLOR_BIT}; case ImageFormat::R16F: @@ -1170,9 +686,9 @@ void will_engine::vk_helpers::saveImage(const ResourceManager& resourceManager, bufferCopyRegion.bufferRowLength = 0; bufferCopyRegion.bufferImageHeight = 0; - transitionImage(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectMask); + imageBarrier(cmd, image.image, imageLayout, VK_IMAGE_LAYOUT_GENERAL, aspectMask); vkCmdCopyImageToBuffer(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, receivingBuffer.buffer, 1, &bufferCopyRegion); - transitionImage(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, aspectMask); + imageBarrier(cmd, image.image, VK_IMAGE_LAYOUT_GENERAL, imageLayout, aspectMask); }); @@ -1228,6 +744,18 @@ void will_engine::vk_helpers::processImageData(void* sourceData, std::span(sourceData); + for (uint32_t i = 0; i < pixelCount; ++i) { + const glm::vec4 pixel = glm::unpackUnorm4x8(packedData[i]); + targetData[i * 4] = pixel.r * powEight; + targetData[i * 4 + 1] = pixel.g * powEight; + targetData[i * 4 + 2] = pixel.b * powEight; + targetData[i * 4 + 3] = powEight; + } + break; + } case ImageFormat::R32F: { @@ -1237,7 +765,7 @@ void will_engine::vk_helpers::processImageData(void* sourceData, std::span(depth * powEight); } - targetData[i * 4 + 3] = 255; + targetData[i * 4 + 3] = powEight; } break; } diff --git a/src/renderer/vk_helpers.h b/src/renderer/vk_helpers.h index 84c055d9..d3351344 100644 --- a/src/renderer/vk_helpers.h +++ b/src/renderer/vk_helpers.h @@ -33,6 +33,7 @@ namespace vk_helpers RGBA32F, RGBA16F, RGBA8, + RGBA8_UNORM, A2R10G10B10_UNORM, R32F, R16F, @@ -108,18 +109,14 @@ namespace vk_helpers void clearColorImage(VkCommandBuffer cmd, VkImageAspectFlags aspectFlag, VkImage image, VkImageLayout srcLayout, VkImageLayout dstLayout, VkClearColorValue clearColor = {0.0f, 0.0f, 0.0f, 1.0f}); - void transitionImage(VkCommandBuffer cmd, VkImage image, VkImageLayout currentLayout, VkImageLayout targetLayout, VkImageAspectFlags aspectMask); + void imageBarrier(VkCommandBuffer cmd, VkImage image, VkImageLayout currentLayout, VkImageLayout targetLayout, VkImageAspectFlags aspectMask); - void transitionImage(VkCommandBuffer cmd, VkImage image, VkImageLayout currentLayout, VkImageAspectFlags aspectMask, VkImageLayout targetLayout); - - void synchronizeUniform(VkCommandBuffer cmd, const AllocatedBuffer& buffer, VkPipelineStageFlagBits2 srcPipelineStage, + void uniformBarrier(VkCommandBuffer cmd, const AllocatedBuffer& buffer, VkPipelineStageFlagBits2 srcPipelineStage, VkAccessFlagBits2 srcAccessBit, VkPipelineStageFlagBits2 dstPipelineStage, VkAccessFlagBits2 dstAccessBit); void copyImageToImage(VkCommandBuffer cmd, VkImage source, VkImage destination, VkExtent2D srcSize, VkExtent2D dstSize); - void copyDepthToDepth(VkCommandBuffer cmd, VkImage source, VkImage destination, VkExtent2D srcSize, VkExtent2D dstSize); - void generateMipmaps(VkCommandBuffer cmd, VkImage image, VkExtent2D imageSize); void generateMipmapsCubemap(VkCommandBuffer cmd, VkImage image, VkExtent2D imageSize, VkImageLayout inputLayout, VkImageLayout ouputLayout); @@ -130,20 +127,6 @@ namespace vk_helpers VkPipelineShaderStageCreateInfo pipelineShaderStageCreateInfo(VkShaderStageFlagBits stage, VkShaderModule shaderModule, const char* entry = "main"); - void saveImageRGBA32F(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, - VkImageLayout imageLayout, VkImageAspectFlags aspectFlag, const char* savePath, bool overrideAlpha = true); - - void saveImageRGBA16SFLOAT(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, - VkImageLayout imageLayout, VkImageAspectFlags aspectFlag, const char* savePath, bool overrideAlpha = true); - - void savePacked32Bit(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, - VkImageLayout imageLayout, VkImageAspectFlags aspectFlag, const char* savePath, - const std::function& unpackingFunction); - - void savePacked64Bit(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, - VkImageLayout imageLayout, VkImageAspectFlags aspectFlag, const char* savePath, - const std::function& unpackingFunction); - /** * Save the Allocated image as a grayscaled image. The image must be a format with only 1 channel (e.g. R32 or D32) */ @@ -151,25 +134,6 @@ namespace vk_helpers VkImageLayout imageLayout, VkImageAspectFlags aspectFlag, const char* savePath, const std::function& valueTransform, int32_t mipLevel = 0); - void saveImageR16F(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, - VkImageLayout imageLayout, VkImageAspectFlags aspectFlag, const char* savePath, - const std::function& valueTransform, int32_t mipLevel = 0); - - void saveImageR8UNORM(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, - VkImageLayout imageLayout, const char* savePath, int32_t mipLevel = 0); - - void saveImageR8UINT(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, - VkImageLayout imageLayout, const char* savePath, VkImageAspectFlagBits aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT, - int32_t mipLevel = 0); - - void saveStencilBuffer(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, - const AllocatedImage& depthStencilImage, VkImageLayout imageLayout, const char* savePath); - - void saveImageR8G8B8A8UNORM(const ResourceManager& resourceManager, const ImmediateSubmitter& immediate, const AllocatedImage& image, - VkImageLayout imageLayout, const char* savePath, int32_t mipLevel = 0); - - void saveImage(const std::vector& imageData, int width, int height, std::filesystem::path filename, bool overrideAlpha = true); - void saveHeightmap(const std::vector& heightData, int width, int height, const std::filesystem::path& filename); FormatInfo getFormatInfo(ImageFormat format, bool stencilOnly); From 399bedaf88c0962bee9f230e5c36f6711e20a9db Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Wed, 7 May 2025 18:20:04 +0700 Subject: [PATCH 23/24] Minor updates to the debug renderer for release builds. --- assets/settings.willengine | 14 +++++++------- src/core/engine.cpp | 8 ++++++-- src/core/engine.h | 2 +- .../pipelines/debug/debug_composite_pipeline.h | 4 ---- src/renderer/pipelines/debug/debug_renderer.h | 2 +- 5 files changed, 15 insertions(+), 15 deletions(-) diff --git a/assets/settings.willengine b/assets/settings.willengine index 4ce9c687..5a2ea691 100644 --- a/assets/settings.willengine +++ b/assets/settings.willengine @@ -9,15 +9,15 @@ }, "cameraSettings": { "position": [ - 9.182855606079102, - 23.231033325195313, - 37.03011703491211 + -7.438582420349121, + 34.399600982666016, + 47.61833953857422 ], "rotation": [ - -0.18478946387767792, - -0.34653541445732117, - -0.06983248144388199, - 0.9170003533363342 + 0.025229064747691154, + -0.12272556871175766, + 0.0031201005913317204, + 0.9921150803565979 ], "fov": 1.3089969158172607, "aspectRatio": 1.7777777910232544, diff --git a/src/core/engine.cpp b/src/core/engine.cpp index 92eae9fb..4d2f6b2e 100644 --- a/src/core/engine.cpp +++ b/src/core/engine.cpp @@ -24,10 +24,12 @@ #include "src/renderer/assets/render_object/render_object.h" #include "src/renderer/descriptor_buffer/descriptor_buffer_uniform.h" #include "src/renderer/environment/environment.h" -#include "src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.h" -#include "src/renderer/pipelines/debug/debug_renderer.h" +#if WILL_ENGINE_DEBUG #include "src/renderer/pipelines/debug/debug_composite_pipeline.h" #include "src/renderer/pipelines/debug/debug_highlighter.h" +#endif // !WILL_ENGINE_DEBUG +#include "src/renderer/pipelines/debug/debug_renderer.h" +#include "src/renderer/pipelines/shadows/cascaded_shadow_map/cascaded_shadow_map.h" #include "src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline.h" #include "src/renderer/pipelines/geometry/deferred_mrt/deferred_mrt_pipeline_types.h" #include "src/renderer/pipelines/geometry/deferred_resolve/deferred_resolve_pipeline.h" @@ -343,9 +345,11 @@ void Engine::updatePhysics(const float deltaTime) const physics::Physics::get()->update(deltaTime); } +#if WILL_ENGINE_DEBUG if (bDebugPhysics) { physics::Physics::get()->drawDebug(); } +#endif } void Engine::updateGame(const float deltaTime) diff --git a/src/core/engine.h b/src/core/engine.h index 8d2d48f3..e676beb5 100644 --- a/src/core/engine.h +++ b/src/core/engine.h @@ -182,7 +182,6 @@ class Engine debug_renderer::DebugRenderer* debugRenderer{nullptr}; debug_highlight_pipeline::DebugHighlighter* debugHighlighter{nullptr}; debug_pipeline::DebugCompositePipeline* debugPipeline{nullptr}; - bool bDebugPhysics{true}; #endif // Might be used in imgui which can be active outside of debug build IHierarchical* selectedItem{nullptr}; @@ -239,6 +238,7 @@ class Engine bool bEnableShadows{true}; bool bEnableContactShadows{true}; bool bDrawDebugRendering{true}; + bool bDebugPhysics{true}; void hotReloadShaders() const; diff --git a/src/renderer/pipelines/debug/debug_composite_pipeline.h b/src/renderer/pipelines/debug/debug_composite_pipeline.h index 7aac62fd..5b430ab7 100644 --- a/src/renderer/pipelines/debug/debug_composite_pipeline.h +++ b/src/renderer/pipelines/debug/debug_composite_pipeline.h @@ -6,10 +6,6 @@ #define DEBUG_PIPELINE_H -#ifndef WILL_ENGINE_DEBUG - #error This file should only be included when WILL_ENGINE_DEBUG is defined -#endif // !WILL_ENGINE_DEBUG - #include "src/renderer/resource_manager.h" diff --git a/src/renderer/pipelines/debug/debug_renderer.h b/src/renderer/pipelines/debug/debug_renderer.h index aaae371c..fa82ab3a 100644 --- a/src/renderer/pipelines/debug/debug_renderer.h +++ b/src/renderer/pipelines/debug/debug_renderer.h @@ -4,12 +4,12 @@ #ifndef DEBUG_RENDERER_H #define DEBUG_RENDERER_H + #include #include "debug_renderer_types.h" #include "src/renderer/renderer_constants.h" #include "src/renderer/vk_types.h" -#include "src/renderer/descriptor_buffer/descriptor_buffer_uniform.h" namespace will_engine { From 45a7b9c22cffacef143f4599bdf4e58b5e946935 Mon Sep 17 00:00:00 2001 From: Williscool13 Date: Wed, 7 May 2025 18:28:14 +0700 Subject: [PATCH 24/24] Specify vulkan version to try to fix CI. --- .github/workflows/windows-build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/windows-build.yml b/.github/workflows/windows-build.yml index 3907b68f..6f6fd64a 100644 --- a/.github/workflows/windows-build.yml +++ b/.github/workflows/windows-build.yml @@ -30,7 +30,7 @@ jobs: - name: Install Vulkan SDK uses: humbletim/install-vulkan-sdk@c2aa128094d42ba02959a660f03e0a4e012192f9 with: - version: latest + version: 1.3.296.0 cache: true - name: Configure CMake