mirror of
https://github.com/Kelsidavis/WoWee.git
synced 2026-03-24 16:10:14 +00:00
Work on character rendering and frustrum culling etc
This commit is contained in:
Kelsi
parent
fc5294eb0f
commit
7dd1dada5f
16 changed files with 559 additions and 138 deletions
|
|
@ -42,12 +42,15 @@ glm::vec3 Camera::getUp() const {
|
|||
|
||||
Ray Camera::screenToWorldRay(float screenX, float screenY, float screenW, float screenH) const {
|
||||
float ndcX = (2.0f * screenX / screenW) - 1.0f;
|
||||
float ndcY = 1.0f - (2.0f * screenY / screenH);
|
||||
// Vulkan Y-flip is baked into projectionMatrix, so NDC Y maps directly:
|
||||
// screen top (y=0) → NDC -1, screen bottom (y=H) → NDC +1
|
||||
float ndcY = (2.0f * screenY / screenH) - 1.0f;
|
||||
|
||||
glm::mat4 invVP = glm::inverse(projectionMatrix * viewMatrix);
|
||||
|
||||
glm::vec4 nearPt = invVP * glm::vec4(ndcX, ndcY, -1.0f, 1.0f);
|
||||
glm::vec4 farPt = invVP * glm::vec4(ndcX, ndcY, 1.0f, 1.0f);
|
||||
// Vulkan / GLM_FORCE_DEPTH_ZERO_TO_ONE: NDC z ∈ [0, 1]
|
||||
glm::vec4 nearPt = invVP * glm::vec4(ndcX, ndcY, 0.0f, 1.0f);
|
||||
glm::vec4 farPt = invVP * glm::vec4(ndcX, ndcY, 1.0f, 1.0f);
|
||||
nearPt /= nearPt.w;
|
||||
farPt /= farPt.w;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,9 @@
|
|||
#include "rendering/character_preview.hpp"
|
||||
#include "rendering/character_renderer.hpp"
|
||||
#include "rendering/vk_render_target.hpp"
|
||||
#include "rendering/vk_texture.hpp"
|
||||
#include "rendering/vk_context.hpp"
|
||||
#include "rendering/vk_frame_data.hpp"
|
||||
#include "rendering/camera.hpp"
|
||||
#include "rendering/renderer.hpp"
|
||||
#include "pipeline/asset_manager.hpp"
|
||||
|
|
@ -10,9 +12,12 @@
|
|||
#include "pipeline/dbc_layout.hpp"
|
||||
#include "core/logger.hpp"
|
||||
#include "core/application.hpp"
|
||||
#include <imgui.h>
|
||||
#include <backends/imgui_impl_vulkan.h>
|
||||
#include <glm/gtc/matrix_transform.hpp>
|
||||
#include <algorithm>
|
||||
#include <unordered_set>
|
||||
#include <cstring>
|
||||
|
||||
namespace wowee {
|
||||
namespace rendering {
|
||||
|
|
@ -26,11 +31,34 @@ CharacterPreview::~CharacterPreview() {
|
|||
bool CharacterPreview::initialize(pipeline::AssetManager* am) {
|
||||
assetManager_ = am;
|
||||
|
||||
charRenderer_ = std::make_unique<CharacterRenderer>();
|
||||
// If already initialized with valid resources, reuse them.
|
||||
// This avoids destroying GPU resources that may still be referenced by
|
||||
// an in-flight command buffer (compositePass recorded earlier this frame).
|
||||
if (renderTarget_ && renderTarget_->isValid() && charRenderer_ && camera_) {
|
||||
// Mark model as not loaded — loadCharacter() will handle instance cleanup
|
||||
modelLoaded_ = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
auto* appRenderer = core::Application::getInstance().getRenderer();
|
||||
VkContext* vkCtx = appRenderer ? appRenderer->getVkContext() : nullptr;
|
||||
vkCtx_ = appRenderer ? appRenderer->getVkContext() : nullptr;
|
||||
VkDescriptorSetLayout perFrameLayout = appRenderer ? appRenderer->getPerFrameSetLayout() : VK_NULL_HANDLE;
|
||||
if (!charRenderer_->initialize(vkCtx, perFrameLayout, am)) {
|
||||
|
||||
if (!vkCtx_ || perFrameLayout == VK_NULL_HANDLE) {
|
||||
LOG_ERROR("CharacterPreview: no VkContext or perFrameLayout available");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create off-screen render target first (need its render pass for pipeline creation)
|
||||
createFBO();
|
||||
if (!renderTarget_ || !renderTarget_->isValid()) {
|
||||
LOG_ERROR("CharacterPreview: failed to create off-screen render target");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Initialize CharacterRenderer with our off-screen render pass
|
||||
charRenderer_ = std::make_unique<CharacterRenderer>();
|
||||
if (!charRenderer_->initialize(vkCtx_, perFrameLayout, am, renderTarget_->getRenderPass())) {
|
||||
LOG_ERROR("CharacterPreview: failed to initialize CharacterRenderer");
|
||||
return false;
|
||||
}
|
||||
|
|
@ -45,35 +73,187 @@ bool CharacterPreview::initialize(pipeline::AssetManager* am) {
|
|||
camera_->setFov(30.0f);
|
||||
camera_->setAspectRatio(static_cast<float>(fboWidth_) / static_cast<float>(fboHeight_));
|
||||
// Pull camera back far enough to see full body + head with margin
|
||||
// Human ~2 units tall, Tauren ~2.5. At distance 4.5 with FOV 30:
|
||||
// vertical visible = 2 * 4.5 * tan(15°) ≈ 2.41 units
|
||||
camera_->setPosition(glm::vec3(0.0f, 4.5f, 0.9f));
|
||||
camera_->setRotation(270.0f, 0.0f);
|
||||
|
||||
// TODO: create Vulkan offscreen render target
|
||||
// createFBO();
|
||||
|
||||
LOG_INFO("CharacterPreview initialized (", fboWidth_, "x", fboHeight_, ")");
|
||||
return true;
|
||||
}
|
||||
|
||||
void CharacterPreview::shutdown() {
|
||||
// destroyFBO(); // TODO: Vulkan offscreen cleanup
|
||||
// Unregister from renderer before destroying resources
|
||||
auto* appRenderer = core::Application::getInstance().getRenderer();
|
||||
if (appRenderer) appRenderer->unregisterPreview(this);
|
||||
|
||||
if (charRenderer_) {
|
||||
charRenderer_->shutdown();
|
||||
charRenderer_.reset();
|
||||
}
|
||||
camera_.reset();
|
||||
destroyFBO();
|
||||
modelLoaded_ = false;
|
||||
compositeRendered_ = false;
|
||||
instanceId_ = 0;
|
||||
}
|
||||
|
||||
void CharacterPreview::createFBO() {
|
||||
// TODO: Create Vulkan offscreen render target for character preview
|
||||
if (!vkCtx_) return;
|
||||
VkDevice device = vkCtx_->getDevice();
|
||||
VmaAllocator allocator = vkCtx_->getAllocator();
|
||||
|
||||
// 1. Create off-screen render target with depth
|
||||
renderTarget_ = std::make_unique<VkRenderTarget>();
|
||||
if (!renderTarget_->create(*vkCtx_, fboWidth_, fboHeight_, VK_FORMAT_R8G8B8A8_UNORM, true)) {
|
||||
LOG_ERROR("CharacterPreview: failed to create render target");
|
||||
renderTarget_.reset();
|
||||
return;
|
||||
}
|
||||
|
||||
// 1b. Transition the color image from UNDEFINED to SHADER_READ_ONLY_OPTIMAL
|
||||
// so that ImGui::Image doesn't sample an image in UNDEFINED layout before
|
||||
// the first compositePass runs.
|
||||
{
|
||||
VkCommandBuffer cmd = vkCtx_->beginSingleTimeCommands();
|
||||
VkImageMemoryBarrier barrier{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
|
||||
barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
||||
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
||||
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
||||
barrier.image = renderTarget_->getColorImage();
|
||||
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
barrier.subresourceRange.baseMipLevel = 0;
|
||||
barrier.subresourceRange.levelCount = 1;
|
||||
barrier.subresourceRange.baseArrayLayer = 0;
|
||||
barrier.subresourceRange.layerCount = 1;
|
||||
barrier.srcAccessMask = 0;
|
||||
barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
||||
vkCmdPipelineBarrier(cmd,
|
||||
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
|
||||
0, 0, nullptr, 0, nullptr, 1, &barrier);
|
||||
vkCtx_->endSingleTimeCommands(cmd);
|
||||
}
|
||||
|
||||
// 2. Create 1x1 dummy white texture (shadow map placeholder)
|
||||
{
|
||||
uint8_t white[] = {255, 255, 255, 255};
|
||||
dummyWhiteTex_ = std::make_unique<VkTexture>();
|
||||
dummyWhiteTex_->upload(*vkCtx_, white, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, false);
|
||||
dummyWhiteTex_->createSampler(device, VK_FILTER_NEAREST, VK_FILTER_NEAREST,
|
||||
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
|
||||
}
|
||||
|
||||
// 3. Create descriptor pool for per-frame sets (2 UBO + 2 sampler)
|
||||
{
|
||||
VkDescriptorPoolSize sizes[2]{};
|
||||
sizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
||||
sizes[0].descriptorCount = MAX_FRAMES;
|
||||
sizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
||||
sizes[1].descriptorCount = MAX_FRAMES;
|
||||
|
||||
VkDescriptorPoolCreateInfo ci{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
|
||||
ci.maxSets = MAX_FRAMES;
|
||||
ci.poolSizeCount = 2;
|
||||
ci.pPoolSizes = sizes;
|
||||
if (vkCreateDescriptorPool(device, &ci, nullptr, &previewDescPool_) != VK_SUCCESS) {
|
||||
LOG_ERROR("CharacterPreview: failed to create descriptor pool");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// 4. Create per-frame UBOs and descriptor sets
|
||||
auto* appRenderer = core::Application::getInstance().getRenderer();
|
||||
VkDescriptorSetLayout perFrameLayout = appRenderer->getPerFrameSetLayout();
|
||||
|
||||
for (uint32_t i = 0; i < MAX_FRAMES; i++) {
|
||||
// Create mapped UBO
|
||||
VkBufferCreateInfo bufInfo{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
|
||||
bufInfo.size = sizeof(GPUPerFrameData);
|
||||
bufInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
|
||||
|
||||
VmaAllocationCreateInfo allocInfo{};
|
||||
allocInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
|
||||
allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
|
||||
|
||||
VmaAllocationInfo mapInfo{};
|
||||
if (vmaCreateBuffer(allocator, &bufInfo, &allocInfo,
|
||||
&previewUBO_[i], &previewUBOAlloc_[i], &mapInfo) != VK_SUCCESS) {
|
||||
LOG_ERROR("CharacterPreview: failed to create UBO ", i);
|
||||
return;
|
||||
}
|
||||
previewUBOMapped_[i] = mapInfo.pMappedData;
|
||||
|
||||
// Allocate descriptor set
|
||||
VkDescriptorSetAllocateInfo setAlloc{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
|
||||
setAlloc.descriptorPool = previewDescPool_;
|
||||
setAlloc.descriptorSetCount = 1;
|
||||
setAlloc.pSetLayouts = &perFrameLayout;
|
||||
if (vkAllocateDescriptorSets(device, &setAlloc, &previewPerFrameSet_[i]) != VK_SUCCESS) {
|
||||
LOG_ERROR("CharacterPreview: failed to allocate descriptor set ", i);
|
||||
return;
|
||||
}
|
||||
|
||||
// Write UBO binding (0) and shadow sampler binding (1) using dummy white texture
|
||||
VkDescriptorBufferInfo descBuf{};
|
||||
descBuf.buffer = previewUBO_[i];
|
||||
descBuf.offset = 0;
|
||||
descBuf.range = sizeof(GPUPerFrameData);
|
||||
|
||||
VkDescriptorImageInfo shadowImg = dummyWhiteTex_->descriptorInfo();
|
||||
|
||||
VkWriteDescriptorSet writes[2]{};
|
||||
writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
||||
writes[0].dstSet = previewPerFrameSet_[i];
|
||||
writes[0].dstBinding = 0;
|
||||
writes[0].descriptorCount = 1;
|
||||
writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
||||
writes[0].pBufferInfo = &descBuf;
|
||||
writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
||||
writes[1].dstSet = previewPerFrameSet_[i];
|
||||
writes[1].dstBinding = 1;
|
||||
writes[1].descriptorCount = 1;
|
||||
writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
||||
writes[1].pImageInfo = &shadowImg;
|
||||
|
||||
vkUpdateDescriptorSets(device, 2, writes, 0, nullptr);
|
||||
}
|
||||
|
||||
// 5. Register the color attachment as an ImGui texture
|
||||
imguiTextureId_ = ImGui_ImplVulkan_AddTexture(
|
||||
renderTarget_->getSampler(),
|
||||
renderTarget_->getColorImageView(),
|
||||
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
|
||||
|
||||
LOG_INFO("CharacterPreview: off-screen FBO created (", fboWidth_, "x", fboHeight_, ")");
|
||||
}
|
||||
|
||||
void CharacterPreview::destroyFBO() {
|
||||
// TODO: Destroy Vulkan offscreen render target
|
||||
if (!vkCtx_) return;
|
||||
VkDevice device = vkCtx_->getDevice();
|
||||
VmaAllocator allocator = vkCtx_->getAllocator();
|
||||
|
||||
if (imguiTextureId_) {
|
||||
ImGui_ImplVulkan_RemoveTexture(imguiTextureId_);
|
||||
imguiTextureId_ = VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < MAX_FRAMES; i++) {
|
||||
if (previewUBO_[i]) {
|
||||
vmaDestroyBuffer(allocator, previewUBO_[i], previewUBOAlloc_[i]);
|
||||
previewUBO_[i] = VK_NULL_HANDLE;
|
||||
}
|
||||
}
|
||||
|
||||
if (previewDescPool_) {
|
||||
vkDestroyDescriptorPool(device, previewDescPool_, nullptr);
|
||||
previewDescPool_ = VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
dummyWhiteTex_.reset();
|
||||
|
||||
if (renderTarget_) {
|
||||
renderTarget_->destroy(device, allocator);
|
||||
renderTarget_.reset();
|
||||
}
|
||||
}
|
||||
|
||||
bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
|
||||
|
|
@ -84,8 +264,11 @@ bool CharacterPreview::loadCharacter(game::Race race, game::Gender gender,
|
|||
return false;
|
||||
}
|
||||
|
||||
// Remove existing instance
|
||||
// Remove existing instance.
|
||||
// Must wait for GPU to finish — compositePass() may have recorded draw commands
|
||||
// referencing this instance's bone buffers earlier in the current frame.
|
||||
if (instanceId_ > 0) {
|
||||
if (vkCtx_) vkDeviceWaitIdle(vkCtx_->getDevice());
|
||||
charRenderer_->removeInstance(instanceId_);
|
||||
instanceId_ = 0;
|
||||
modelLoaded_ = false;
|
||||
|
|
@ -592,14 +775,48 @@ void CharacterPreview::update(float deltaTime) {
|
|||
}
|
||||
|
||||
void CharacterPreview::render() {
|
||||
if (!charRenderer_ || !camera_ || !modelLoaded_) {
|
||||
// No-op — actual rendering happens in compositePass() called from Renderer::beginFrame()
|
||||
}
|
||||
|
||||
void CharacterPreview::compositePass(VkCommandBuffer cmd, uint32_t frameIndex) {
|
||||
// Only composite when a UI screen actually requested it this frame
|
||||
if (!compositeRequested_) return;
|
||||
compositeRequested_ = false;
|
||||
|
||||
if (!charRenderer_ || !camera_ || !modelLoaded_ || !renderTarget_ || !renderTarget_->isValid()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO: Vulkan offscreen rendering for character preview
|
||||
// Need a VkRenderTarget, begin a render pass into it, then:
|
||||
// charRenderer_->render(cmd, perFrameSet, *camera_);
|
||||
// For now, the preview is non-functional until Vulkan offscreen is wired up.
|
||||
uint32_t fi = frameIndex % MAX_FRAMES;
|
||||
|
||||
// Update per-frame UBO with preview camera matrices and studio lighting
|
||||
GPUPerFrameData ubo{};
|
||||
ubo.view = camera_->getViewMatrix();
|
||||
ubo.projection = camera_->getProjectionMatrix();
|
||||
ubo.lightSpaceMatrix = glm::mat4(1.0f);
|
||||
// Studio lighting: key light from upper-right-front
|
||||
ubo.lightDir = glm::vec4(glm::normalize(glm::vec3(0.5f, -0.7f, 0.5f)), 0.0f);
|
||||
ubo.lightColor = glm::vec4(1.0f, 0.95f, 0.9f, 0.0f);
|
||||
ubo.ambientColor = glm::vec4(0.35f, 0.35f, 0.4f, 0.0f);
|
||||
ubo.viewPos = glm::vec4(camera_->getPosition(), 0.0f);
|
||||
// No fog in preview
|
||||
ubo.fogColor = glm::vec4(0.05f, 0.05f, 0.1f, 0.0f);
|
||||
ubo.fogParams = glm::vec4(9999.0f, 10000.0f, 0.0f, 0.0f);
|
||||
// Shadows disabled
|
||||
ubo.shadowParams = glm::vec4(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
|
||||
std::memcpy(previewUBOMapped_[fi], &ubo, sizeof(GPUPerFrameData));
|
||||
|
||||
// Begin off-screen render pass
|
||||
VkClearColorValue clearColor = {{0.05f, 0.05f, 0.1f, 1.0f}};
|
||||
renderTarget_->beginPass(cmd, clearColor);
|
||||
|
||||
// Render the character model
|
||||
charRenderer_->render(cmd, previewPerFrameSet_[fi], *camera_);
|
||||
|
||||
renderTarget_->endPass(cmd);
|
||||
|
||||
compositeRendered_ = true;
|
||||
}
|
||||
|
||||
void CharacterPreview::rotate(float yawDelta) {
|
||||
|
|
|
|||
|
|
@ -86,12 +86,14 @@ CharacterRenderer::~CharacterRenderer() {
|
|||
}
|
||||
|
||||
bool CharacterRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout,
|
||||
pipeline::AssetManager* am) {
|
||||
pipeline::AssetManager* am,
|
||||
VkRenderPass renderPassOverride) {
|
||||
core::Logger::getInstance().info("Initializing character renderer (Vulkan)...");
|
||||
|
||||
vkCtx_ = ctx;
|
||||
assetManager = am;
|
||||
perFrameLayout_ = perFrameLayout;
|
||||
renderPassOverride_ = renderPassOverride;
|
||||
|
||||
VkDevice device = vkCtx_->getDevice();
|
||||
|
||||
|
|
@ -182,7 +184,8 @@ bool CharacterRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFram
|
|||
return false;
|
||||
}
|
||||
|
||||
VkRenderPass mainPass = vkCtx_->getImGuiRenderPass();
|
||||
VkRenderPass mainPass = renderPassOverride_ ? renderPassOverride_ : vkCtx_->getImGuiRenderPass();
|
||||
VkSampleCountFlagBits samples = renderPassOverride_ ? VK_SAMPLE_COUNT_1_BIT : vkCtx_->getMsaaSamples();
|
||||
|
||||
// --- Vertex input ---
|
||||
// M2Vertex: vec3 pos(12) + uint8[4] boneWeights(4) + uint8[4] boneIndices(4) +
|
||||
|
|
@ -210,7 +213,7 @@ bool CharacterRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFram
|
|||
.setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
|
||||
.setDepthTest(true, depthWrite, VK_COMPARE_OP_LESS_OR_EQUAL)
|
||||
.setColorBlendAttachment(blendState)
|
||||
.setMultisample(vkCtx_->getMsaaSamples())
|
||||
.setMultisample(samples)
|
||||
.setLayout(pipelineLayout_)
|
||||
.setRenderPass(mainPass)
|
||||
.setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
|
||||
|
|
@ -252,6 +255,9 @@ bool CharacterRenderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFram
|
|||
void CharacterRenderer::shutdown() {
|
||||
if (!vkCtx_) return;
|
||||
|
||||
LOG_INFO("CharacterRenderer::shutdown instances=", instances.size(),
|
||||
" models=", models.size(), " override=", (void*)renderPassOverride_);
|
||||
|
||||
vkDeviceWaitIdle(vkCtx_->getDevice());
|
||||
VkDevice device = vkCtx_->getDevice();
|
||||
VmaAllocator alloc = vkCtx_->getAllocator();
|
||||
|
|
@ -1321,6 +1327,13 @@ glm::mat4 CharacterRenderer::getBoneTransform(const pipeline::M2Bone& bone, floa
|
|||
// --- Rendering ---
|
||||
|
||||
void CharacterRenderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const Camera& camera) {
|
||||
// Periodic instance count log (every ~10s at 30fps)
|
||||
if (!renderPassOverride_) {
|
||||
renderLogCounter_++;
|
||||
if (renderLogCounter_ % 300 == 1) {
|
||||
LOG_INFO("CharRenderer[WORLD]::render instances=", instances.size());
|
||||
}
|
||||
}
|
||||
if (instances.empty() || !opaquePipeline_) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -2196,6 +2209,9 @@ void CharacterRenderer::clearTextureSlotOverride(uint32_t instanceId, uint16_t t
|
|||
void CharacterRenderer::setInstanceVisible(uint32_t instanceId, bool visible) {
|
||||
auto it = instances.find(instanceId);
|
||||
if (it != instances.end()) {
|
||||
if (it->second.visible != visible) {
|
||||
LOG_INFO("CharacterRenderer::setInstanceVisible id=", instanceId, " visible=", visible);
|
||||
}
|
||||
it->second.visible = visible;
|
||||
|
||||
// Also hide/show attached weapons (for first-person mode)
|
||||
|
|
@ -2212,6 +2228,11 @@ void CharacterRenderer::removeInstance(uint32_t instanceId) {
|
|||
auto it = instances.find(instanceId);
|
||||
if (it == instances.end()) return;
|
||||
|
||||
LOG_INFO("CharacterRenderer::removeInstance id=", instanceId,
|
||||
" pos=(", it->second.position.x, ",", it->second.position.y, ",", it->second.position.z, ")",
|
||||
" remaining=", instances.size() - 1,
|
||||
" override=", (void*)renderPassOverride_);
|
||||
|
||||
// Remove child attachments first (helmets/weapons), otherwise they leak as
|
||||
// orphan render instances when the parent creature despawns.
|
||||
auto attachments = it->second.weaponAttachments;
|
||||
|
|
@ -2585,7 +2606,8 @@ void CharacterRenderer::recreatePipelines() {
|
|||
return;
|
||||
}
|
||||
|
||||
VkRenderPass mainPass = vkCtx_->getImGuiRenderPass();
|
||||
VkRenderPass mainPass = renderPassOverride_ ? renderPassOverride_ : vkCtx_->getImGuiRenderPass();
|
||||
VkSampleCountFlagBits samples = renderPassOverride_ ? VK_SAMPLE_COUNT_1_BIT : vkCtx_->getMsaaSamples();
|
||||
|
||||
// --- Vertex input ---
|
||||
VkVertexInputBindingDescription charBinding{};
|
||||
|
|
@ -2610,13 +2632,17 @@ void CharacterRenderer::recreatePipelines() {
|
|||
.setRasterization(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE)
|
||||
.setDepthTest(true, depthWrite, VK_COMPARE_OP_LESS_OR_EQUAL)
|
||||
.setColorBlendAttachment(blendState)
|
||||
.setMultisample(vkCtx_->getMsaaSamples())
|
||||
.setMultisample(samples)
|
||||
.setLayout(pipelineLayout_)
|
||||
.setRenderPass(mainPass)
|
||||
.setDynamicStates({VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR})
|
||||
.build(device);
|
||||
};
|
||||
|
||||
LOG_INFO("CharacterRenderer::recreatePipelines: renderPass=", (void*)mainPass,
|
||||
" samples=", static_cast<int>(samples),
|
||||
" pipelineLayout=", (void*)pipelineLayout_);
|
||||
|
||||
opaquePipeline_ = buildCharPipeline(PipelineBuilder::blendDisabled(), true);
|
||||
alphaTestPipeline_ = buildCharPipeline(PipelineBuilder::blendAlpha(), true);
|
||||
alphaPipeline_ = buildCharPipeline(PipelineBuilder::blendAlpha(), false);
|
||||
|
|
@ -2625,7 +2651,16 @@ void CharacterRenderer::recreatePipelines() {
|
|||
charVert.destroy();
|
||||
charFrag.destroy();
|
||||
|
||||
core::Logger::getInstance().info("CharacterRenderer: pipelines recreated");
|
||||
if (!opaquePipeline_ || !alphaTestPipeline_ || !alphaPipeline_ || !additivePipeline_) {
|
||||
LOG_ERROR("CharacterRenderer::recreatePipelines FAILED: opaque=", (void*)opaquePipeline_,
|
||||
" alphaTest=", (void*)alphaTestPipeline_,
|
||||
" alpha=", (void*)alphaPipeline_,
|
||||
" additive=", (void*)additivePipeline_,
|
||||
" renderPass=", (void*)mainPass, " samples=", static_cast<int>(samples));
|
||||
} else {
|
||||
LOG_INFO("CharacterRenderer: pipelines recreated successfully (samples=",
|
||||
static_cast<int>(samples), ")");
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace rendering
|
||||
|
|
|
|||
|
|
@ -5,45 +5,56 @@ namespace wowee {
|
|||
namespace rendering {
|
||||
|
||||
void Frustum::extractFromMatrix(const glm::mat4& vp) {
|
||||
// Extract planes from view-projection matrix
|
||||
// Based on Gribb & Hartmann method (Fast Extraction of Viewing Frustum Planes)
|
||||
// Extract frustum planes from view-projection matrix.
|
||||
// Vulkan clip-space conventions (GLM_FORCE_DEPTH_ZERO_TO_ONE + Y-flip):
|
||||
// x_clip ∈ [-w, w], y_clip ∈ [-w, w] (Y flipped in proj), z_clip ∈ [0, w]
|
||||
//
|
||||
// Gribb & Hartmann method adapted for Vulkan depth [0,1].
|
||||
// Left/Right/Top/Bottom use the standard row4 ± row1/row2 formulas
|
||||
// (the Y-flip swaps the TOP/BOTTOM row2 sign, but the extracted half-spaces
|
||||
// are still correct — they just get each other's label. We swap the
|
||||
// assignments so the enum names match the geometric meaning.)
|
||||
|
||||
// Left plane: row4 + row1
|
||||
// Left plane: row4 + row1 (x_clip >= -w_clip)
|
||||
planes[LEFT].normal.x = vp[0][3] + vp[0][0];
|
||||
planes[LEFT].normal.y = vp[1][3] + vp[1][0];
|
||||
planes[LEFT].normal.z = vp[2][3] + vp[2][0];
|
||||
planes[LEFT].distance = vp[3][3] + vp[3][0];
|
||||
normalizePlane(planes[LEFT]);
|
||||
|
||||
// Right plane: row4 - row1
|
||||
// Right plane: row4 - row1 (x_clip <= w_clip)
|
||||
planes[RIGHT].normal.x = vp[0][3] - vp[0][0];
|
||||
planes[RIGHT].normal.y = vp[1][3] - vp[1][0];
|
||||
planes[RIGHT].normal.z = vp[2][3] - vp[2][0];
|
||||
planes[RIGHT].distance = vp[3][3] - vp[3][0];
|
||||
normalizePlane(planes[RIGHT]);
|
||||
|
||||
// Bottom plane: row4 + row2
|
||||
planes[BOTTOM].normal.x = vp[0][3] + vp[0][1];
|
||||
planes[BOTTOM].normal.y = vp[1][3] + vp[1][1];
|
||||
planes[BOTTOM].normal.z = vp[2][3] + vp[2][1];
|
||||
planes[BOTTOM].distance = vp[3][3] + vp[3][1];
|
||||
normalizePlane(planes[BOTTOM]);
|
||||
// With the Vulkan Y-flip (proj[1][1] negated), row4+row2 extracts
|
||||
// what is geometrically the TOP plane and row4-row2 extracts BOTTOM.
|
||||
// Swap the assignments so enum labels match geometry.
|
||||
|
||||
// Top plane: row4 - row2
|
||||
planes[TOP].normal.x = vp[0][3] - vp[0][1];
|
||||
planes[TOP].normal.y = vp[1][3] - vp[1][1];
|
||||
planes[TOP].normal.z = vp[2][3] - vp[2][1];
|
||||
planes[TOP].distance = vp[3][3] - vp[3][1];
|
||||
// Top plane (geometric): row4 - row2 after Y-flip
|
||||
planes[TOP].normal.x = vp[0][3] + vp[0][1];
|
||||
planes[TOP].normal.y = vp[1][3] + vp[1][1];
|
||||
planes[TOP].normal.z = vp[2][3] + vp[2][1];
|
||||
planes[TOP].distance = vp[3][3] + vp[3][1];
|
||||
normalizePlane(planes[TOP]);
|
||||
|
||||
// Near plane: row4 + row3
|
||||
planes[NEAR].normal.x = vp[0][3] + vp[0][2];
|
||||
planes[NEAR].normal.y = vp[1][3] + vp[1][2];
|
||||
planes[NEAR].normal.z = vp[2][3] + vp[2][2];
|
||||
planes[NEAR].distance = vp[3][3] + vp[3][2];
|
||||
// Bottom plane (geometric): row4 + row2 after Y-flip
|
||||
planes[BOTTOM].normal.x = vp[0][3] - vp[0][1];
|
||||
planes[BOTTOM].normal.y = vp[1][3] - vp[1][1];
|
||||
planes[BOTTOM].normal.z = vp[2][3] - vp[2][1];
|
||||
planes[BOTTOM].distance = vp[3][3] - vp[3][1];
|
||||
normalizePlane(planes[BOTTOM]);
|
||||
|
||||
// Near plane: row3 (z_clip >= 0 in Vulkan depth [0,1])
|
||||
planes[NEAR].normal.x = vp[0][2];
|
||||
planes[NEAR].normal.y = vp[1][2];
|
||||
planes[NEAR].normal.z = vp[2][2];
|
||||
planes[NEAR].distance = vp[3][2];
|
||||
normalizePlane(planes[NEAR]);
|
||||
|
||||
// Far plane: row4 - row3
|
||||
// Far plane: row4 - row3 (z_clip <= w_clip)
|
||||
planes[FAR].normal.x = vp[0][3] - vp[0][2];
|
||||
planes[FAR].normal.y = vp[1][3] - vp[1][2];
|
||||
planes[FAR].normal.z = vp[2][3] - vp[2][2];
|
||||
|
|
|
|||
|
|
@ -412,32 +412,37 @@ void PerformanceHUD::render(const Renderer* renderer, const Camera* camera) {
|
|||
if (showControls) {
|
||||
ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "CONTROLS");
|
||||
ImGui::Separator();
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F1: Toggle HUD");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F2: Wireframe");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F3: Single tile");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F4: Culling");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F5: Stats");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F6: Multi-tile");
|
||||
|
||||
ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.5f, 1.0f), "Movement");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "WASD: Move/Strafe");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Q/E: Turn left/right");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Space: Jump");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "X: Sit/Stand");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "~: Auto-run");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Z: Sheathe weapons");
|
||||
|
||||
ImGui::Spacing();
|
||||
ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.5f, 1.0f), "UI Panels");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "B: Bags/Inventory");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "C: Character sheet");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "L: Quest log");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "N: Talents");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "P: Spellbook");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "M: World map");
|
||||
|
||||
ImGui::Spacing();
|
||||
ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.5f, 1.0f), "Combat & Chat");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "1-0,-,=: Action bar");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Tab: Target cycle");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Enter: Chat");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "/: Chat command");
|
||||
|
||||
ImGui::Spacing();
|
||||
ImGui::TextColored(ImVec4(0.8f, 0.8f, 0.5f, 1.0f), "Debug");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F1: Toggle this HUD");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F4: Toggle shadows");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F7: Level-up FX");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F8: Water");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F9: Time");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F10: Sun/Moon");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F11: Stars");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "F12: Fog");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "+/-: Change time");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "C: Clouds");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "[/]: Density");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "L: Lens Flare");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), ",/.: Intensity");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "M: Moon Cycle");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), ";/': Moon Phase");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "W: Weather");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "</>: Wx Intensity");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "K: Spawn Character");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "J: Remove Chars");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "O: Spawn Test WMO");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Shift+O: Real WMO");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "P: Clear WMOs");
|
||||
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Esc: Settings/Close");
|
||||
}
|
||||
|
||||
ImGui::End();
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@
|
|||
#include "rendering/charge_effect.hpp"
|
||||
#include "rendering/levelup_effect.hpp"
|
||||
#include "rendering/character_renderer.hpp"
|
||||
#include "rendering/character_preview.hpp"
|
||||
#include "rendering/wmo_renderer.hpp"
|
||||
#include "rendering/m2_renderer.hpp"
|
||||
#include "rendering/minimap.hpp"
|
||||
|
|
@ -723,6 +724,21 @@ void Renderer::shutdown() {
|
|||
LOG_INFO("Renderer shutdown");
|
||||
}
|
||||
|
||||
void Renderer::registerPreview(CharacterPreview* preview) {
|
||||
if (!preview) return;
|
||||
auto it = std::find(activePreviews_.begin(), activePreviews_.end(), preview);
|
||||
if (it == activePreviews_.end()) {
|
||||
activePreviews_.push_back(preview);
|
||||
}
|
||||
}
|
||||
|
||||
void Renderer::unregisterPreview(CharacterPreview* preview) {
|
||||
auto it = std::find(activePreviews_.begin(), activePreviews_.end(), preview);
|
||||
if (it != activePreviews_.end()) {
|
||||
activePreviews_.erase(it);
|
||||
}
|
||||
}
|
||||
|
||||
void Renderer::setMsaaSamples(VkSampleCountFlagBits samples) {
|
||||
if (!vkCtx) return;
|
||||
|
||||
|
|
@ -840,6 +856,13 @@ void Renderer::beginFrame() {
|
|||
worldMap->compositePass(currentCmd);
|
||||
}
|
||||
|
||||
// Character preview composite passes
|
||||
for (auto* preview : activePreviews_) {
|
||||
if (preview && preview->isModelLoaded()) {
|
||||
preview->compositePass(currentCmd, vkCtx->getCurrentFrame());
|
||||
}
|
||||
}
|
||||
|
||||
// Shadow pre-pass (before main render pass)
|
||||
if (shadowsEnabled && shadowDepthImage != VK_NULL_HANDLE) {
|
||||
renderShadowPass();
|
||||
|
|
@ -3007,6 +3030,15 @@ void Renderer::renderOverlay(const glm::vec4& color) {
|
|||
void Renderer::renderWorld(game::World* world, game::GameHandler* gameHandler) {
|
||||
(void)world;
|
||||
|
||||
{
|
||||
static int rwLogCounter = 0;
|
||||
if (++rwLogCounter % 300 == 1) {
|
||||
LOG_INFO("Renderer::renderWorld frame=", rwLogCounter,
|
||||
" cmd=", (void*)currentCmd,
|
||||
" charRenderer=", (void*)characterRenderer.get());
|
||||
}
|
||||
}
|
||||
|
||||
auto renderStart = std::chrono::steady_clock::now();
|
||||
lastTerrainRenderMs = 0.0;
|
||||
lastWMORenderMs = 0.0;
|
||||
|
|
|
|||
|
|
@ -1041,8 +1041,18 @@ bool VkContext::recreateSwapchain(int width, int height) {
|
|||
VkCommandBuffer VkContext::beginFrame(uint32_t& imageIndex) {
|
||||
auto& frame = frames[currentFrame];
|
||||
|
||||
// Wait for this frame's fence
|
||||
vkWaitForFences(device, 1, &frame.inFlightFence, VK_TRUE, UINT64_MAX);
|
||||
// Wait for this frame's fence (with timeout to detect GPU hangs)
|
||||
static int beginFrameCounter = 0;
|
||||
beginFrameCounter++;
|
||||
VkResult fenceResult = vkWaitForFences(device, 1, &frame.inFlightFence, VK_TRUE, 5000000000ULL); // 5 second timeout
|
||||
if (fenceResult == VK_TIMEOUT) {
|
||||
LOG_ERROR("beginFrame[", beginFrameCounter, "] FENCE TIMEOUT (5s) on frame slot ", currentFrame, " — GPU hang detected!");
|
||||
return VK_NULL_HANDLE;
|
||||
}
|
||||
if (fenceResult != VK_SUCCESS) {
|
||||
LOG_ERROR("beginFrame[", beginFrameCounter, "] fence wait failed: ", (int)fenceResult);
|
||||
return VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
// Acquire next swapchain image
|
||||
VkResult result = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX,
|
||||
|
|
@ -1070,7 +1080,13 @@ VkCommandBuffer VkContext::beginFrame(uint32_t& imageIndex) {
|
|||
}
|
||||
|
||||
void VkContext::endFrame(VkCommandBuffer cmd, uint32_t imageIndex) {
|
||||
vkEndCommandBuffer(cmd);
|
||||
static int endFrameCounter = 0;
|
||||
endFrameCounter++;
|
||||
|
||||
VkResult endResult = vkEndCommandBuffer(cmd);
|
||||
if (endResult != VK_SUCCESS) {
|
||||
LOG_ERROR("endFrame[", endFrameCounter, "] vkEndCommandBuffer FAILED: ", (int)endResult);
|
||||
}
|
||||
|
||||
auto& frame = frames[currentFrame];
|
||||
|
||||
|
|
@ -1086,8 +1102,9 @@ void VkContext::endFrame(VkCommandBuffer cmd, uint32_t imageIndex) {
|
|||
submitInfo.signalSemaphoreCount = 1;
|
||||
submitInfo.pSignalSemaphores = &frame.renderFinishedSemaphore;
|
||||
|
||||
if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, frame.inFlightFence) != VK_SUCCESS) {
|
||||
LOG_ERROR("Failed to submit draw command buffer");
|
||||
VkResult submitResult = vkQueueSubmit(graphicsQueue, 1, &submitInfo, frame.inFlightFence);
|
||||
if (submitResult != VK_SUCCESS) {
|
||||
LOG_ERROR("endFrame[", endFrameCounter, "] vkQueueSubmit FAILED: ", (int)submitResult);
|
||||
}
|
||||
|
||||
VkPresentInfoKHR presentInfo{};
|
||||
|
|
|
|||
|
|
@ -9,9 +9,10 @@ VkRenderTarget::~VkRenderTarget() {
|
|||
// Must call destroy() explicitly with device/allocator before destruction
|
||||
}
|
||||
|
||||
bool VkRenderTarget::create(VkContext& ctx, uint32_t width, uint32_t height, VkFormat format) {
|
||||
bool VkRenderTarget::create(VkContext& ctx, uint32_t width, uint32_t height, VkFormat format, bool withDepth) {
|
||||
VkDevice device = ctx.getDevice();
|
||||
VmaAllocator allocator = ctx.getAllocator();
|
||||
hasDepth_ = withDepth;
|
||||
|
||||
// Create color image (COLOR_ATTACHMENT + SAMPLED for reading in subsequent passes)
|
||||
colorImage_ = createImage(device, allocator, width, height, format,
|
||||
|
|
@ -22,6 +23,17 @@ bool VkRenderTarget::create(VkContext& ctx, uint32_t width, uint32_t height, VkF
|
|||
return false;
|
||||
}
|
||||
|
||||
// Create depth image if requested
|
||||
if (withDepth) {
|
||||
depthImage_ = createImage(device, allocator, width, height,
|
||||
VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
|
||||
if (!depthImage_.image) {
|
||||
LOG_ERROR("VkRenderTarget: failed to create depth image (", width, "x", height, ")");
|
||||
destroy(device, allocator);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Create sampler (linear filtering, clamp to edge)
|
||||
VkSamplerCreateInfo samplerInfo{};
|
||||
samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
||||
|
|
@ -41,44 +53,77 @@ bool VkRenderTarget::create(VkContext& ctx, uint32_t width, uint32_t height, VkF
|
|||
}
|
||||
|
||||
// Create render pass
|
||||
// Color attachment: UNDEFINED -> COLOR_ATTACHMENT_OPTIMAL (during pass)
|
||||
// -> SHADER_READ_ONLY_OPTIMAL (final layout, ready for sampling)
|
||||
VkAttachmentDescription colorAttachment{};
|
||||
colorAttachment.format = format;
|
||||
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
|
||||
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
||||
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
||||
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||||
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||||
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
||||
VkAttachmentDescription attachments[2]{};
|
||||
// Color attachment: UNDEFINED -> COLOR_ATTACHMENT_OPTIMAL -> SHADER_READ_ONLY_OPTIMAL
|
||||
attachments[0].format = format;
|
||||
attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;
|
||||
attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
||||
attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
||||
attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||||
attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||||
attachments[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
attachments[0].finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
||||
|
||||
// Depth attachment (only used when withDepth)
|
||||
attachments[1].format = VK_FORMAT_D32_SFLOAT;
|
||||
attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
|
||||
attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
||||
attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||||
attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||||
attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||||
attachments[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
attachments[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||
|
||||
VkAttachmentReference colorRef{};
|
||||
colorRef.attachment = 0;
|
||||
colorRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
|
||||
VkAttachmentReference depthRef{};
|
||||
depthRef.attachment = 1;
|
||||
depthRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||
|
||||
VkSubpassDescription subpass{};
|
||||
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||||
subpass.colorAttachmentCount = 1;
|
||||
subpass.pColorAttachments = &colorRef;
|
||||
if (withDepth) subpass.pDepthStencilAttachment = &depthRef;
|
||||
|
||||
// Dependency: external -> subpass 0 (wait for previous reads to finish)
|
||||
VkSubpassDependency dependency{};
|
||||
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
|
||||
dependency.dstSubpass = 0;
|
||||
dependency.srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
||||
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||||
dependency.srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
||||
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||||
// Dependencies
|
||||
VkSubpassDependency dependencies[2]{};
|
||||
uint32_t depCount = 1;
|
||||
|
||||
// Input dependency: wait for previous fragment shader reads before writing
|
||||
dependencies[0].srcSubpass = VK_SUBPASS_EXTERNAL;
|
||||
dependencies[0].dstSubpass = 0;
|
||||
dependencies[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
||||
dependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||||
dependencies[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
||||
dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||||
|
||||
if (withDepth) {
|
||||
dependencies[0].dstStageMask |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
|
||||
dependencies[0].dstAccessMask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
||||
|
||||
// Output dependency (depth targets only): ensure writes complete before fragment reads
|
||||
dependencies[1].srcSubpass = 0;
|
||||
dependencies[1].dstSubpass = VK_SUBPASS_EXTERNAL;
|
||||
dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
|
||||
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
||||
dependencies[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
||||
dependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
|
||||
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
||||
dependencies[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
||||
depCount = 2;
|
||||
}
|
||||
|
||||
VkRenderPassCreateInfo rpInfo{};
|
||||
rpInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
||||
rpInfo.attachmentCount = 1;
|
||||
rpInfo.pAttachments = &colorAttachment;
|
||||
rpInfo.attachmentCount = withDepth ? 2u : 1u;
|
||||
rpInfo.pAttachments = attachments;
|
||||
rpInfo.subpassCount = 1;
|
||||
rpInfo.pSubpasses = &subpass;
|
||||
rpInfo.dependencyCount = 1;
|
||||
rpInfo.pDependencies = &dependency;
|
||||
rpInfo.dependencyCount = depCount;
|
||||
rpInfo.pDependencies = dependencies;
|
||||
|
||||
if (vkCreateRenderPass(device, &rpInfo, nullptr, &renderPass_) != VK_SUCCESS) {
|
||||
LOG_ERROR("VkRenderTarget: failed to create render pass");
|
||||
|
|
@ -87,11 +132,12 @@ bool VkRenderTarget::create(VkContext& ctx, uint32_t width, uint32_t height, VkF
|
|||
}
|
||||
|
||||
// Create framebuffer
|
||||
VkImageView fbAttachments[2] = { colorImage_.imageView, depthImage_.imageView };
|
||||
VkFramebufferCreateInfo fbInfo{};
|
||||
fbInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
||||
fbInfo.renderPass = renderPass_;
|
||||
fbInfo.attachmentCount = 1;
|
||||
fbInfo.pAttachments = &colorImage_.imageView;
|
||||
fbInfo.attachmentCount = withDepth ? 2u : 1u;
|
||||
fbInfo.pAttachments = fbAttachments;
|
||||
fbInfo.width = width;
|
||||
fbInfo.height = height;
|
||||
fbInfo.layers = 1;
|
||||
|
|
@ -102,7 +148,7 @@ bool VkRenderTarget::create(VkContext& ctx, uint32_t width, uint32_t height, VkF
|
|||
return false;
|
||||
}
|
||||
|
||||
LOG_INFO("VkRenderTarget created (", width, "x", height, ")");
|
||||
LOG_INFO("VkRenderTarget created (", width, "x", height, withDepth ? ", with depth)" : ")");
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -119,7 +165,9 @@ void VkRenderTarget::destroy(VkDevice device, VmaAllocator allocator) {
|
|||
vkDestroySampler(device, sampler_, nullptr);
|
||||
sampler_ = VK_NULL_HANDLE;
|
||||
}
|
||||
destroyImage(device, allocator, depthImage_);
|
||||
destroyImage(device, allocator, colorImage_);
|
||||
hasDepth_ = false;
|
||||
}
|
||||
|
||||
void VkRenderTarget::beginPass(VkCommandBuffer cmd, const VkClearColorValue& clear) {
|
||||
|
|
@ -130,10 +178,11 @@ void VkRenderTarget::beginPass(VkCommandBuffer cmd, const VkClearColorValue& cle
|
|||
rpBegin.renderArea.offset = {0, 0};
|
||||
rpBegin.renderArea.extent = getExtent();
|
||||
|
||||
VkClearValue clearValue{};
|
||||
clearValue.color = clear;
|
||||
rpBegin.clearValueCount = 1;
|
||||
rpBegin.pClearValues = &clearValue;
|
||||
VkClearValue clearValues[2]{};
|
||||
clearValues[0].color = clear;
|
||||
clearValues[1].depthStencil = {1.0f, 0};
|
||||
rpBegin.clearValueCount = hasDepth_ ? 2u : 1u;
|
||||
rpBegin.pClearValues = clearValues;
|
||||
|
||||
vkCmdBeginRenderPass(cmd, &rpBegin, VK_SUBPASS_CONTENTS_INLINE);
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue