2830 lines
113 KiB
C++
2830 lines
113 KiB
C++
#include "vulkanrenderer.h"
|
||
|
||
#define VK_NO_PROTOTYPES
|
||
#include <volk.h>
|
||
|
||
#include <cstring>
|
||
#include <cmath>
|
||
#include <algorithm>
|
||
#include <iostream>
|
||
|
||
#ifdef ENABLE_FREETYPE
|
||
#include <ft2build.h>
|
||
#include FT_FREETYPE_H
|
||
#endif
|
||
|
||
#ifndef M_PI
|
||
#define M_PI 3.14159265358979323846
|
||
#endif
|
||
|
||
VulkanRenderer::VulkanRenderer()
|
||
: m_device(VK_NULL_HANDLE)
|
||
, m_physicalDevice(VK_NULL_HANDLE)
|
||
, m_graphicsQueue(VK_NULL_HANDLE)
|
||
, m_queueFamilyIndex(0)
|
||
, m_transferCommandPool(VK_NULL_HANDLE)
|
||
, m_renderPass(VK_NULL_HANDLE)
|
||
, m_backgroundPipeline(VK_NULL_HANDLE)
|
||
, m_backgroundPipelineLayout(VK_NULL_HANDLE)
|
||
, m_geometryPipeline(VK_NULL_HANDLE)
|
||
, m_geometryPipelineLayout(VK_NULL_HANDLE)
|
||
, m_linePipeline(VK_NULL_HANDLE)
|
||
, m_linePipelineLayout(VK_NULL_HANDLE)
|
||
, m_textPipeline(VK_NULL_HANDLE)
|
||
, m_textPipelineLayout(VK_NULL_HANDLE)
|
||
, m_descriptorSetLayout(VK_NULL_HANDLE)
|
||
, m_descriptorPool(VK_NULL_HANDLE)
|
||
, m_backgroundVertexBuffer(VK_NULL_HANDLE)
|
||
, m_backgroundVertexMemory(VK_NULL_HANDLE)
|
||
, m_backgroundIndexBuffer(VK_NULL_HANDLE)
|
||
, m_backgroundIndexMemory(VK_NULL_HANDLE)
|
||
, m_backgroundIndexCount(0)
|
||
, m_circleVertexBuffer(VK_NULL_HANDLE)
|
||
, m_circleVertexMemory(VK_NULL_HANDLE)
|
||
, m_circleIndexBuffer(VK_NULL_HANDLE)
|
||
, m_circleIndexMemory(VK_NULL_HANDLE)
|
||
, m_circleIndexCount(0)
|
||
, m_waveVertexBuffer(VK_NULL_HANDLE)
|
||
, m_waveVertexMemory(VK_NULL_HANDLE)
|
||
, m_waveIndexBuffer(VK_NULL_HANDLE)
|
||
, m_waveIndexMemory(VK_NULL_HANDLE)
|
||
, m_waveIndexCount(0)
|
||
, m_fontTexture(VK_NULL_HANDLE)
|
||
, m_fontTextureMemory(VK_NULL_HANDLE)
|
||
, m_fontTextureView(VK_NULL_HANDLE)
|
||
, m_fontSampler(VK_NULL_HANDLE)
|
||
, m_textVertexBuffer(VK_NULL_HANDLE)
|
||
, m_textVertexMemory(VK_NULL_HANDLE)
|
||
, m_textIndexBuffer(VK_NULL_HANDLE)
|
||
, m_textIndexMemory(VK_NULL_HANDLE)
|
||
, m_textIndexCount(0)
|
||
, m_msaaImage(VK_NULL_HANDLE)
|
||
, m_msaaImageMemory(VK_NULL_HANDLE)
|
||
, m_msaaImageView(VK_NULL_HANDLE)
|
||
, m_msaaSamples(VK_SAMPLE_COUNT_1_BIT)
|
||
, m_width(0)
|
||
, m_height(0)
|
||
, m_swapchainFormat(0)
|
||
, m_initialized(false)
|
||
, m_errorCallback(nullptr)
|
||
{
|
||
memset(&m_ubo, 0, sizeof(m_ubo));
|
||
}
|
||
|
||
VulkanRenderer::~VulkanRenderer()
|
||
{
|
||
cleanup();
|
||
}
|
||
|
||
bool VulkanRenderer::initialize(VkDevice device, VkPhysicalDevice physicalDevice,
|
||
VkQueue graphicsQueue, uint32_t queueFamilyIndex,
|
||
uint32_t swapchainFormat, uint32_t width, uint32_t height)
|
||
{
|
||
m_device = device;
|
||
m_physicalDevice = physicalDevice;
|
||
m_graphicsQueue = graphicsQueue;
|
||
m_queueFamilyIndex = queueFamilyIndex;
|
||
m_swapchainFormat = swapchainFormat;
|
||
m_width = width;
|
||
m_height = height;
|
||
m_transferCommandPool = VK_NULL_HANDLE;
|
||
|
||
// Determine best MSAA sample count
|
||
m_msaaSamples = getMaxUsableSampleCount();
|
||
std::cout << "Using MSAA with " << m_msaaSamples << " samples" << std::endl;
|
||
|
||
// Create MSAA resources if MSAA is enabled
|
||
if (m_msaaSamples > VK_SAMPLE_COUNT_1_BIT) {
|
||
if (!createMSAAResources()) {
|
||
logError("Failed to create MSAA resources, falling back to no MSAA");
|
||
m_msaaSamples = VK_SAMPLE_COUNT_1_BIT;
|
||
}
|
||
}
|
||
|
||
if (!createRenderPass()) {
|
||
logError("Failed to create render pass");
|
||
return false;
|
||
}
|
||
|
||
if (!createDescriptorSetLayout()) {
|
||
logError("Failed to create descriptor set layout");
|
||
return false;
|
||
}
|
||
|
||
if (!createBackgroundPipeline()) {
|
||
logError("Failed to create background pipeline");
|
||
return false;
|
||
}
|
||
|
||
if (!createGeometryPipeline()) {
|
||
logError("Failed to create geometry pipeline");
|
||
return false;
|
||
}
|
||
|
||
if (!createLinePipeline()) {
|
||
logError("Failed to create line pipeline");
|
||
return false;
|
||
}
|
||
|
||
if (!createUniformBuffers()) {
|
||
logError("Failed to create uniform buffers");
|
||
return false;
|
||
}
|
||
|
||
if (!createDescriptorPool()) {
|
||
logError("Failed to create descriptor pool");
|
||
return false;
|
||
}
|
||
|
||
if (!createDescriptorSets()) {
|
||
logError("Failed to create descriptor sets");
|
||
return false;
|
||
}
|
||
|
||
// Initialize UBO with current dimensions
|
||
m_ubo.time = 0.0f;
|
||
m_ubo.resolution[0] = static_cast<float>(m_width);
|
||
m_ubo.resolution[1] = static_cast<float>(m_height);
|
||
m_ubo.rotation = 0.0f;
|
||
m_ubo.wavePhase = 0.0f;
|
||
|
||
// Update all uniform buffers with initial values
|
||
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
||
if (m_uniformBuffersMapped[i] != nullptr) {
|
||
memcpy(m_uniformBuffersMapped[i], &m_ubo, sizeof(m_ubo));
|
||
}
|
||
}
|
||
|
||
// Create background geometry
|
||
std::vector<Vertex> bgVertices;
|
||
std::vector<uint16_t> bgIndices;
|
||
generateBackgroundQuad(bgVertices, bgIndices);
|
||
m_backgroundIndexCount = bgIndices.size();
|
||
|
||
if (!createVertexBuffer(bgVertices, m_backgroundVertexBuffer, m_backgroundVertexMemory)) {
|
||
logError("Failed to create background vertex buffer");
|
||
return false;
|
||
}
|
||
|
||
if (!createIndexBuffer(bgIndices, m_backgroundIndexBuffer, m_backgroundIndexMemory)) {
|
||
logError("Failed to create background index buffer");
|
||
return false;
|
||
}
|
||
|
||
// Initialize text rendering (optional)
|
||
if (initializeTextRendering()) {
|
||
std::cout << "Creating text pipeline..." << std::endl;
|
||
if (!createTextPipeline()) {
|
||
logError("Failed to create text pipeline - text rendering will be disabled");
|
||
} else {
|
||
// Update descriptor sets to include font texture
|
||
std::cout << "Updating descriptor sets with font texture..." << std::endl;
|
||
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
||
VkDescriptorBufferInfo bufferInfo = {};
|
||
bufferInfo.buffer = m_uniformBuffers[i];
|
||
bufferInfo.offset = 0;
|
||
bufferInfo.range = sizeof(UniformBufferObject);
|
||
|
||
VkDescriptorImageInfo imageInfo = {};
|
||
imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
||
imageInfo.imageView = m_fontTextureView;
|
||
imageInfo.sampler = m_fontSampler;
|
||
|
||
std::vector<VkWriteDescriptorSet> descriptorWrites(2);
|
||
|
||
// UBO descriptor
|
||
descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
||
descriptorWrites[0].dstSet = m_descriptorSets[i];
|
||
descriptorWrites[0].dstBinding = 0;
|
||
descriptorWrites[0].dstArrayElement = 0;
|
||
descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
||
descriptorWrites[0].descriptorCount = 1;
|
||
descriptorWrites[0].pBufferInfo = &bufferInfo;
|
||
|
||
// Font texture descriptor
|
||
descriptorWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
||
descriptorWrites[1].dstSet = m_descriptorSets[i];
|
||
descriptorWrites[1].dstBinding = 1;
|
||
descriptorWrites[1].dstArrayElement = 0;
|
||
descriptorWrites[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
||
descriptorWrites[1].descriptorCount = 1;
|
||
descriptorWrites[1].pImageInfo = &imageInfo;
|
||
|
||
vkUpdateDescriptorSets(m_device, descriptorWrites.size(), descriptorWrites.data(), 0, nullptr);
|
||
}
|
||
std::cout << "Descriptor sets updated with font texture" << std::endl;
|
||
}
|
||
} else {
|
||
std::cout << "Text rendering initialization failed - text will be disabled" << std::endl;
|
||
}
|
||
|
||
m_initialized = true;
|
||
return true;
|
||
}
|
||
|
||
uint32_t VulkanRenderer::getMaxUsableSampleCount()
|
||
{
|
||
VkPhysicalDeviceProperties physicalDeviceProperties;
|
||
vkGetPhysicalDeviceProperties(m_physicalDevice, &physicalDeviceProperties);
|
||
|
||
VkSampleCountFlags counts = physicalDeviceProperties.limits.framebufferColorSampleCounts &
|
||
physicalDeviceProperties.limits.framebufferDepthSampleCounts;
|
||
|
||
std::cout << "Available MSAA sample counts: ";
|
||
if (counts & VK_SAMPLE_COUNT_64_BIT) std::cout << "64 ";
|
||
if (counts & VK_SAMPLE_COUNT_32_BIT) std::cout << "32 ";
|
||
if (counts & VK_SAMPLE_COUNT_16_BIT) std::cout << "16 ";
|
||
if (counts & VK_SAMPLE_COUNT_8_BIT) std::cout << "8 ";
|
||
if (counts & VK_SAMPLE_COUNT_4_BIT) std::cout << "4 ";
|
||
if (counts & VK_SAMPLE_COUNT_2_BIT) std::cout << "2 ";
|
||
std::cout << std::endl;
|
||
|
||
// Prefer higher sample counts for better quality
|
||
if (counts & VK_SAMPLE_COUNT_16_BIT) {
|
||
std::cout << "Selected: 16x MSAA" << std::endl;
|
||
return VK_SAMPLE_COUNT_16_BIT;
|
||
}
|
||
if (counts & VK_SAMPLE_COUNT_8_BIT) {
|
||
std::cout << "Selected: 8x MSAA" << std::endl;
|
||
return VK_SAMPLE_COUNT_8_BIT;
|
||
}
|
||
if (counts & VK_SAMPLE_COUNT_4_BIT) {
|
||
std::cout << "Selected: 4x MSAA" << std::endl;
|
||
return VK_SAMPLE_COUNT_4_BIT;
|
||
}
|
||
if (counts & VK_SAMPLE_COUNT_2_BIT) {
|
||
std::cout << "Selected: 2x MSAA" << std::endl;
|
||
return VK_SAMPLE_COUNT_2_BIT;
|
||
}
|
||
|
||
std::cout << "No MSAA support available" << std::endl;
|
||
return VK_SAMPLE_COUNT_1_BIT;
|
||
}
|
||
|
||
bool VulkanRenderer::createMSAAResources()
|
||
{
|
||
std::cout << "Creating MSAA resources: " << m_width << "x" << m_height
|
||
<< " with " << m_msaaSamples << " samples" << std::endl;
|
||
|
||
VkImageCreateInfo imageInfo = {};
|
||
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
||
imageInfo.imageType = VK_IMAGE_TYPE_2D;
|
||
imageInfo.extent.width = m_width;
|
||
imageInfo.extent.height = m_height;
|
||
imageInfo.extent.depth = 1;
|
||
imageInfo.mipLevels = 1;
|
||
imageInfo.arrayLayers = 1;
|
||
imageInfo.format = static_cast<VkFormat>(m_swapchainFormat);
|
||
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
|
||
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
imageInfo.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
||
imageInfo.samples = static_cast<VkSampleCountFlagBits>(m_msaaSamples);
|
||
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
|
||
VkResult result = vkCreateImage(m_device, &imageInfo, nullptr, &m_msaaImage);
|
||
if (result != VK_SUCCESS) {
|
||
std::cout << "Failed to create MSAA image, error: " << result << std::endl;
|
||
logError("Failed to create MSAA image");
|
||
return false;
|
||
}
|
||
std::cout << "MSAA image created successfully" << std::endl;
|
||
|
||
VkMemoryRequirements memRequirements;
|
||
vkGetImageMemoryRequirements(m_device, m_msaaImage, &memRequirements);
|
||
std::cout << "MSAA memory requirements: size=" << memRequirements.size
|
||
<< " alignment=" << memRequirements.alignment << std::endl;
|
||
|
||
VkMemoryAllocateInfo allocInfo = {};
|
||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||
allocInfo.allocationSize = memRequirements.size;
|
||
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits,
|
||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||
|
||
result = vkAllocateMemory(m_device, &allocInfo, nullptr, &m_msaaImageMemory);
|
||
if (result != VK_SUCCESS) {
|
||
std::cout << "Failed to allocate MSAA image memory, error: " << result << std::endl;
|
||
logError("Failed to allocate MSAA image memory");
|
||
vkDestroyImage(m_device, m_msaaImage, nullptr);
|
||
m_msaaImage = VK_NULL_HANDLE;
|
||
return false;
|
||
}
|
||
std::cout << "MSAA memory allocated successfully" << std::endl;
|
||
|
||
result = vkBindImageMemory(m_device, m_msaaImage, m_msaaImageMemory, 0);
|
||
if (result != VK_SUCCESS) {
|
||
std::cout << "Failed to bind MSAA image memory, error: " << result << std::endl;
|
||
logError("Failed to bind MSAA image memory");
|
||
vkFreeMemory(m_device, m_msaaImageMemory, nullptr);
|
||
vkDestroyImage(m_device, m_msaaImage, nullptr);
|
||
m_msaaImage = VK_NULL_HANDLE;
|
||
m_msaaImageMemory = VK_NULL_HANDLE;
|
||
return false;
|
||
}
|
||
std::cout << "MSAA memory bound successfully" << std::endl;
|
||
|
||
// Create image view
|
||
VkImageViewCreateInfo viewInfo = {};
|
||
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||
viewInfo.image = m_msaaImage;
|
||
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
||
viewInfo.format = static_cast<VkFormat>(m_swapchainFormat);
|
||
viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
viewInfo.subresourceRange.baseMipLevel = 0;
|
||
viewInfo.subresourceRange.levelCount = 1;
|
||
viewInfo.subresourceRange.baseArrayLayer = 0;
|
||
viewInfo.subresourceRange.layerCount = 1;
|
||
|
||
result = vkCreateImageView(m_device, &viewInfo, nullptr, &m_msaaImageView);
|
||
if (result != VK_SUCCESS) {
|
||
std::cout << "Failed to create MSAA image view, error: " << result << std::endl;
|
||
logError("Failed to create MSAA image view");
|
||
vkFreeMemory(m_device, m_msaaImageMemory, nullptr);
|
||
vkDestroyImage(m_device, m_msaaImage, nullptr);
|
||
m_msaaImage = VK_NULL_HANDLE;
|
||
m_msaaImageMemory = VK_NULL_HANDLE;
|
||
return false;
|
||
}
|
||
std::cout << "MSAA image view created successfully" << std::endl;
|
||
std::cout << "MSAA resources created: image=" << m_msaaImage
|
||
<< " view=" << m_msaaImageView << std::endl;
|
||
|
||
return true;
|
||
}
|
||
|
||
void VulkanRenderer::cleanupMSAAResources()
|
||
{
|
||
if (m_msaaImageView != VK_NULL_HANDLE) {
|
||
vkDestroyImageView(m_device, m_msaaImageView, nullptr);
|
||
m_msaaImageView = VK_NULL_HANDLE;
|
||
}
|
||
if (m_msaaImage != VK_NULL_HANDLE) {
|
||
vkDestroyImage(m_device, m_msaaImage, nullptr);
|
||
m_msaaImage = VK_NULL_HANDLE;
|
||
}
|
||
if (m_msaaImageMemory != VK_NULL_HANDLE) {
|
||
vkFreeMemory(m_device, m_msaaImageMemory, nullptr);
|
||
m_msaaImageMemory = VK_NULL_HANDLE;
|
||
}
|
||
}
|
||
|
||
void VulkanRenderer::cleanup()
|
||
{
|
||
cleanupMSAAResources();
|
||
if (!m_device) return;
|
||
|
||
// Clean up buffers
|
||
if (m_backgroundVertexBuffer) vkDestroyBuffer(m_device, m_backgroundVertexBuffer, nullptr);
|
||
if (m_backgroundVertexMemory) vkFreeMemory(m_device, m_backgroundVertexMemory, nullptr);
|
||
if (m_backgroundIndexBuffer) vkDestroyBuffer(m_device, m_backgroundIndexBuffer, nullptr);
|
||
if (m_backgroundIndexMemory) vkFreeMemory(m_device, m_backgroundIndexMemory, nullptr);
|
||
|
||
if (m_textVertexBuffer) vkDestroyBuffer(m_device, m_textVertexBuffer, nullptr);
|
||
if (m_textVertexMemory) vkFreeMemory(m_device, m_textVertexMemory, nullptr);
|
||
if (m_textIndexBuffer) vkDestroyBuffer(m_device, m_textIndexBuffer, nullptr);
|
||
if (m_textIndexMemory) vkFreeMemory(m_device, m_textIndexMemory, nullptr);
|
||
|
||
if (m_circleVertexBuffer) vkDestroyBuffer(m_device, m_circleVertexBuffer, nullptr);
|
||
if (m_circleVertexMemory) vkFreeMemory(m_device, m_circleVertexMemory, nullptr);
|
||
if (m_circleIndexBuffer) vkDestroyBuffer(m_device, m_circleIndexBuffer, nullptr);
|
||
if (m_circleIndexMemory) vkFreeMemory(m_device, m_circleIndexMemory, nullptr);
|
||
|
||
if (m_waveVertexBuffer) vkDestroyBuffer(m_device, m_waveVertexBuffer, nullptr);
|
||
if (m_waveVertexMemory) vkFreeMemory(m_device, m_waveVertexMemory, nullptr);
|
||
if (m_waveIndexBuffer) vkDestroyBuffer(m_device, m_waveIndexBuffer, nullptr);
|
||
if (m_waveIndexMemory) vkFreeMemory(m_device, m_waveIndexMemory, nullptr);
|
||
|
||
// Clean up line pipeline
|
||
if (m_linePipeline) vkDestroyPipeline(m_device, m_linePipeline, nullptr);
|
||
if (m_linePipelineLayout) vkDestroyPipelineLayout(m_device, m_linePipelineLayout, nullptr);
|
||
|
||
// Clean up uniform buffers
|
||
for (size_t i = 0; i < m_uniformBuffers.size(); i++) {
|
||
if (m_uniformBuffers[i]) vkDestroyBuffer(m_device, m_uniformBuffers[i], nullptr);
|
||
if (m_uniformBuffersMemory[i]) vkFreeMemory(m_device, m_uniformBuffersMemory[i], nullptr);
|
||
}
|
||
m_uniformBuffers.clear();
|
||
m_uniformBuffersMemory.clear();
|
||
m_uniformBuffersMapped.clear();
|
||
|
||
// Clean up text resources
|
||
if (m_fontSampler) vkDestroySampler(m_device, m_fontSampler, nullptr);
|
||
if (m_fontTextureView) vkDestroyImageView(m_device, m_fontTextureView, nullptr);
|
||
if (m_fontTexture) vkDestroyImage(m_device, m_fontTexture, nullptr);
|
||
if (m_fontTextureMemory) vkFreeMemory(m_device, m_fontTextureMemory, nullptr);
|
||
|
||
// Clean up descriptors
|
||
if (m_descriptorPool) vkDestroyDescriptorPool(m_device, m_descriptorPool, nullptr);
|
||
if (m_descriptorSetLayout) vkDestroyDescriptorSetLayout(m_device, m_descriptorSetLayout, nullptr);
|
||
|
||
// Clean up transfer command pool
|
||
if (m_transferCommandPool) vkDestroyCommandPool(m_device, m_transferCommandPool, nullptr);
|
||
|
||
// Clean up pipelines
|
||
if (m_backgroundPipeline) vkDestroyPipeline(m_device, m_backgroundPipeline, nullptr);
|
||
if (m_backgroundPipelineLayout) vkDestroyPipelineLayout(m_device, m_backgroundPipelineLayout, nullptr);
|
||
if (m_geometryPipeline) vkDestroyPipeline(m_device, m_geometryPipeline, nullptr);
|
||
if (m_geometryPipelineLayout) vkDestroyPipelineLayout(m_device, m_geometryPipelineLayout, nullptr);
|
||
if (m_textPipeline) vkDestroyPipeline(m_device, m_textPipeline, nullptr);
|
||
if (m_textPipelineLayout) vkDestroyPipelineLayout(m_device, m_textPipelineLayout, nullptr);
|
||
|
||
// Clean up framebuffers
|
||
for (auto fb : m_framebuffers) {
|
||
if (fb) vkDestroyFramebuffer(m_device, fb, nullptr);
|
||
}
|
||
m_framebuffers.clear();
|
||
|
||
// Clean up render pass
|
||
if (m_renderPass) vkDestroyRenderPass(m_device, m_renderPass, nullptr);
|
||
|
||
m_device = VK_NULL_HANDLE;
|
||
m_initialized = false;
|
||
}
|
||
|
||
bool VulkanRenderer::resize(uint32_t width, uint32_t height)
|
||
{
|
||
std::cout << "VulkanRenderer::resize called: " << width << "x" << height
|
||
<< " (previous: " << m_width << "x" << m_height << ")" << std::endl;
|
||
|
||
m_width = width;
|
||
m_height = height;
|
||
|
||
// Update UBO resolution immediately
|
||
m_ubo.resolution[0] = static_cast<float>(m_width);
|
||
m_ubo.resolution[1] = static_cast<float>(m_height);
|
||
|
||
// Update all uniform buffers with new resolution
|
||
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
||
if (i < m_uniformBuffersMapped.size() && m_uniformBuffersMapped[i] != nullptr) {
|
||
memcpy(m_uniformBuffersMapped[i], &m_ubo, sizeof(m_ubo));
|
||
}
|
||
}
|
||
|
||
std::cout << " Updated UBO resolution to: (" << m_ubo.resolution[0] << ", " << m_ubo.resolution[1] << ")" << std::endl;
|
||
|
||
// Recreate framebuffers with new size
|
||
for (auto fb : m_framebuffers) {
|
||
if (fb) vkDestroyFramebuffer(m_device, fb, nullptr);
|
||
}
|
||
m_framebuffers.clear();
|
||
|
||
// Recreate MSAA resources if MSAA is enabled
|
||
if (m_msaaSamples > VK_SAMPLE_COUNT_1_BIT) {
|
||
cleanupMSAAResources();
|
||
if (!createMSAAResources()) {
|
||
logError("Failed to recreate MSAA resources during resize");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return createFramebuffers();
|
||
}
|
||
|
||
void VulkanRenderer::recordCommandBuffer(VkCommandBuffer commandBuffer,
|
||
uint32_t imageIndex,
|
||
VkImageView imageView,
|
||
int frameCount,
|
||
double rotationAngle,
|
||
double wavePhase,
|
||
bool paintingEnabled,
|
||
const std::string& lockInfo)
|
||
{
|
||
if (!m_initialized) {
|
||
return;
|
||
}
|
||
|
||
// Check for valid dimensions
|
||
if (m_width < 100 || m_height < 100) {
|
||
paintingEnabled = false;
|
||
}
|
||
|
||
// 根本性修复：使用 host-visible buffers 进行动态更新
|
||
// 这样可以直接映射内存更新，无需 staging buffer 和命令队列同步
|
||
if (paintingEnabled) {
|
||
std::vector<Vertex> circleVertices, waveVertices;
|
||
std::vector<uint16_t> circleIndices, waveIndices;
|
||
|
||
// 生成动态几何体（使用当前动画参数）
|
||
generateRotatingCircles(circleVertices, circleIndices, rotationAngle);
|
||
generateWaveEffect(waveVertices, waveIndices, wavePhase);
|
||
|
||
// 首次创建 buffers（使用 host-visible 内存）
|
||
if (m_circleVertexBuffer == VK_NULL_HANDLE) {
|
||
VkDeviceSize circleVertexSize = sizeof(Vertex) * 1024; // 预分配足够空间
|
||
VkDeviceSize circleIndexSize = sizeof(uint16_t) * 2048;
|
||
VkDeviceSize waveVertexSize = sizeof(Vertex) * 1024;
|
||
VkDeviceSize waveIndexSize = sizeof(uint16_t) * 2048;
|
||
|
||
if (!createDynamicVertexBuffer(circleVertexSize, m_circleVertexBuffer, m_circleVertexMemory)) {
|
||
logError("Failed to create dynamic circle vertex buffer");
|
||
return;
|
||
}
|
||
if (!createDynamicIndexBuffer(circleIndexSize, m_circleIndexBuffer, m_circleIndexMemory)) {
|
||
logError("Failed to create dynamic circle index buffer");
|
||
return;
|
||
}
|
||
if (!createDynamicVertexBuffer(waveVertexSize, m_waveVertexBuffer, m_waveVertexMemory)) {
|
||
logError("Failed to create dynamic wave vertex buffer");
|
||
return;
|
||
}
|
||
if (!createDynamicIndexBuffer(waveIndexSize, m_waveIndexBuffer, m_waveIndexMemory)) {
|
||
logError("Failed to create dynamic wave index buffer");
|
||
return;
|
||
}
|
||
|
||
std::cout << "Dynamic geometry buffers created (host-visible, no staging)" << std::endl;
|
||
}
|
||
|
||
// 直接更新 buffer 内容（通过内存映射，无需命令队列）
|
||
if (!circleVertices.empty() && !circleIndices.empty()) {
|
||
updateDynamicBuffer(m_circleVertexMemory, circleVertices.data(),
|
||
sizeof(Vertex) * circleVertices.size());
|
||
updateDynamicBuffer(m_circleIndexMemory, circleIndices.data(),
|
||
sizeof(uint16_t) * circleIndices.size());
|
||
m_circleIndexCount = circleIndices.size();
|
||
}
|
||
|
||
if (!waveVertices.empty() && !waveIndices.empty()) {
|
||
updateDynamicBuffer(m_waveVertexMemory, waveVertices.data(),
|
||
sizeof(Vertex) * waveVertices.size());
|
||
updateDynamicBuffer(m_waveIndexMemory, waveIndices.data(),
|
||
sizeof(uint16_t) * waveIndices.size());
|
||
m_waveIndexCount = waveIndices.size();
|
||
}
|
||
}
|
||
|
||
// Update uniform buffer
|
||
m_ubo.time = static_cast<float>(frameCount);
|
||
m_ubo.resolution[0] = static_cast<float>(m_width);
|
||
m_ubo.resolution[1] = static_cast<float>(m_height);
|
||
m_ubo.rotation = static_cast<float>(rotationAngle);
|
||
m_ubo.wavePhase = static_cast<float>(wavePhase);
|
||
m_ubo.paintingEnabled = paintingEnabled ? 1.0f : 0.0f;
|
||
|
||
|
||
|
||
// CRITICAL FIX: Update ALL uniform buffers every frame!
|
||
// Each descriptor set points to a different buffer, so all must have current data
|
||
// Otherwise, alternating frames will use stale data from the other buffer
|
||
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
||
updateUniformBuffer(i);
|
||
}
|
||
|
||
// Use consistent frame index for descriptor set binding
|
||
uint32_t frameIndex = static_cast<uint32_t>(frameCount) % MAX_FRAMES_IN_FLIGHT;
|
||
|
||
|
||
// Begin command buffer
|
||
VkCommandBufferBeginInfo beginInfo = {};
|
||
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
||
VkResult result = vkBeginCommandBuffer(commandBuffer, &beginInfo);
|
||
if (result != VK_SUCCESS) {
|
||
return;
|
||
}
|
||
|
||
// Make sure we have enough image views
|
||
while (m_imageViews.size() <= imageIndex) {
|
||
m_imageViews.push_back(VK_NULL_HANDLE);
|
||
}
|
||
|
||
// Make sure we have enough framebuffers
|
||
while (m_framebuffers.size() <= imageIndex) {
|
||
m_framebuffers.push_back(VK_NULL_HANDLE);
|
||
}
|
||
|
||
// Check if we need to create or recreate framebuffer
|
||
bool needsRecreate = false;
|
||
if (m_framebuffers[imageIndex] == VK_NULL_HANDLE) {
|
||
needsRecreate = true;
|
||
} else if (m_imageViews[imageIndex] != imageView) {
|
||
// Image view changed - destroy old framebuffer
|
||
vkDestroyFramebuffer(m_device, m_framebuffers[imageIndex], nullptr);
|
||
m_framebuffers[imageIndex] = VK_NULL_HANDLE;
|
||
needsRecreate = true;
|
||
}
|
||
|
||
// Update image view
|
||
m_imageViews[imageIndex] = imageView;
|
||
|
||
// Create framebuffer if needed
|
||
if (needsRecreate) {
|
||
VkFramebufferCreateInfo fbInfo = {};
|
||
fbInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
||
fbInfo.renderPass = m_renderPass;
|
||
fbInfo.width = m_width;
|
||
fbInfo.height = m_height;
|
||
fbInfo.layers = 1;
|
||
|
||
if (m_msaaSamples > VK_SAMPLE_COUNT_1_BIT) {
|
||
// MSAA enabled: attach MSAA image and resolve image
|
||
VkImageView attachments[2] = {
|
||
m_msaaImageView,
|
||
imageView
|
||
};
|
||
fbInfo.attachmentCount = 2;
|
||
fbInfo.pAttachments = attachments;
|
||
|
||
static int fbCreateCount = 0;
|
||
std::cout << "Creating framebuffer " << imageIndex << " (#" << fbCreateCount++
|
||
<< ") with MSAA (msaa_view=" << m_msaaImageView
|
||
<< ", resolve=" << imageView << ")" << std::endl;
|
||
} else {
|
||
// No MSAA: single attachment
|
||
fbInfo.attachmentCount = 1;
|
||
fbInfo.pAttachments = &imageView;
|
||
}
|
||
|
||
VkResult result = vkCreateFramebuffer(m_device, &fbInfo, nullptr, &m_framebuffers[imageIndex]);
|
||
if (result != VK_SUCCESS) {
|
||
std::cout << "ERROR: Failed to create framebuffer " << imageIndex
|
||
<< ", error code: " << result << std::endl;
|
||
return;
|
||
}
|
||
}
|
||
|
||
// Begin render pass
|
||
VkRenderPassBeginInfo renderPassInfo = {};
|
||
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
|
||
renderPassInfo.renderPass = m_renderPass;
|
||
renderPassInfo.framebuffer = m_framebuffers[imageIndex];
|
||
renderPassInfo.renderArea.offset = {0, 0};
|
||
renderPassInfo.renderArea.extent = {m_width, m_height};
|
||
|
||
VkClearValue clearColor = {{{0.0f, 0.0f, 0.0f, 1.0f}}};
|
||
renderPassInfo.clearValueCount = 1;
|
||
renderPassInfo.pClearValues = &clearColor;
|
||
|
||
vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
|
||
|
||
|
||
|
||
// Set dynamic viewport and scissor
|
||
VkViewport viewport = {};
|
||
viewport.x = 0.0f;
|
||
viewport.y = 0.0f;
|
||
viewport.width = static_cast<float>(m_width);
|
||
viewport.height = static_cast<float>(m_height);
|
||
viewport.minDepth = 0.0f;
|
||
viewport.maxDepth = 1.0f;
|
||
vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
|
||
|
||
VkRect2D scissor = {};
|
||
scissor.offset = {0, 0};
|
||
scissor.extent = {m_width, m_height};
|
||
vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
|
||
|
||
// Draw background
|
||
drawBackground(commandBuffer, frameCount);
|
||
|
||
if (paintingEnabled) {
|
||
// Draw geometry (circles and waves)
|
||
drawGeometry(commandBuffer, frameCount, rotationAngle, wavePhase);
|
||
}
|
||
|
||
// Draw text (status info)
|
||
drawText(commandBuffer, frameCount, paintingEnabled, lockInfo);
|
||
|
||
vkCmdEndRenderPass(commandBuffer);
|
||
vkEndCommandBuffer(commandBuffer);
|
||
}
|
||
|
||
void VulkanRenderer::updateAnimationParams(int frameCount, double rotation, double wavePhase)
|
||
{
|
||
m_ubo.time = static_cast<float>(frameCount);
|
||
m_ubo.rotation = static_cast<float>(rotation);
|
||
m_ubo.wavePhase = static_cast<float>(wavePhase);
|
||
}
|
||
|
||
VkFramebuffer VulkanRenderer::getFramebuffer(uint32_t index) const
|
||
{
|
||
if (index < m_framebuffers.size()) {
|
||
return m_framebuffers[index];
|
||
}
|
||
return VK_NULL_HANDLE;
|
||
}
|
||
|
||
bool VulkanRenderer::createRenderPass()
|
||
{
|
||
std::vector<VkAttachmentDescription> attachments;
|
||
|
||
if (m_msaaSamples > VK_SAMPLE_COUNT_1_BIT) {
|
||
// MSAA color attachment
|
||
VkAttachmentDescription colorAttachment = {};
|
||
colorAttachment.format = static_cast<VkFormat>(m_swapchainFormat);
|
||
colorAttachment.samples = static_cast<VkSampleCountFlagBits>(m_msaaSamples);
|
||
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_COLOR_ATTACHMENT_OPTIMAL;
|
||
attachments.push_back(colorAttachment);
|
||
|
||
// Resolve attachment (for presenting)
|
||
VkAttachmentDescription resolveAttachment = {};
|
||
resolveAttachment.format = static_cast<VkFormat>(m_swapchainFormat);
|
||
resolveAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
|
||
resolveAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||
resolveAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
||
resolveAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||
resolveAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||
resolveAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
resolveAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
|
||
attachments.push_back(resolveAttachment);
|
||
|
||
VkAttachmentReference colorAttachmentRef = {};
|
||
colorAttachmentRef.attachment = 0;
|
||
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||
|
||
VkAttachmentReference resolveAttachmentRef = {};
|
||
resolveAttachmentRef.attachment = 1;
|
||
resolveAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||
|
||
VkSubpassDescription subpass = {};
|
||
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||
subpass.colorAttachmentCount = 1;
|
||
subpass.pColorAttachments = &colorAttachmentRef;
|
||
subpass.pResolveAttachments = &resolveAttachmentRef;
|
||
|
||
VkSubpassDependency dependency = {};
|
||
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
|
||
dependency.dstSubpass = 0;
|
||
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||
dependency.srcAccessMask = 0;
|
||
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||
|
||
VkRenderPassCreateInfo renderPassInfo = {};
|
||
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
||
renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
|
||
renderPassInfo.pAttachments = attachments.data();
|
||
renderPassInfo.subpassCount = 1;
|
||
renderPassInfo.pSubpasses = &subpass;
|
||
renderPassInfo.dependencyCount = 1;
|
||
renderPassInfo.pDependencies = &dependency;
|
||
|
||
return vkCreateRenderPass(m_device, &renderPassInfo, nullptr, &m_renderPass) == VK_SUCCESS;
|
||
} else {
|
||
// No MSAA - single color attachment
|
||
VkAttachmentDescription colorAttachment = {};
|
||
colorAttachment.format = static_cast<VkFormat>(m_swapchainFormat);
|
||
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_PRESENT_SRC_KHR;
|
||
|
||
VkAttachmentReference colorAttachmentRef = {};
|
||
colorAttachmentRef.attachment = 0;
|
||
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||
|
||
VkSubpassDescription subpass = {};
|
||
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||
subpass.colorAttachmentCount = 1;
|
||
subpass.pColorAttachments = &colorAttachmentRef;
|
||
|
||
VkSubpassDependency dependency = {};
|
||
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
|
||
dependency.dstSubpass = 0;
|
||
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||
dependency.srcAccessMask = 0;
|
||
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||
|
||
VkRenderPassCreateInfo renderPassInfo = {};
|
||
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
||
renderPassInfo.attachmentCount = 1;
|
||
renderPassInfo.pAttachments = &colorAttachment;
|
||
renderPassInfo.subpassCount = 1;
|
||
renderPassInfo.pSubpasses = &subpass;
|
||
renderPassInfo.dependencyCount = 1;
|
||
renderPassInfo.pDependencies = &dependency;
|
||
|
||
return vkCreateRenderPass(m_device, &renderPassInfo, nullptr, &m_renderPass) == VK_SUCCESS;
|
||
}
|
||
}
|
||
|
||
bool VulkanRenderer::createFramebuffers()
|
||
{
|
||
m_framebuffers.resize(m_imageViews.size());
|
||
|
||
for (size_t i = 0; i < m_imageViews.size(); i++) {
|
||
VkFramebufferCreateInfo framebufferInfo = {};
|
||
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
||
framebufferInfo.renderPass = m_renderPass;
|
||
framebufferInfo.width = m_width;
|
||
framebufferInfo.height = m_height;
|
||
framebufferInfo.layers = 1;
|
||
|
||
if (m_msaaSamples > VK_SAMPLE_COUNT_1_BIT) {
|
||
// MSAA enabled: attach MSAA image and resolve image
|
||
if (m_msaaImageView == VK_NULL_HANDLE) {
|
||
std::cout << "ERROR: MSAA image view is null when creating framebuffer " << i << std::endl;
|
||
return false;
|
||
}
|
||
VkImageView attachments[2] = {
|
||
m_msaaImageView,
|
||
m_imageViews[i]
|
||
};
|
||
framebufferInfo.attachmentCount = 2;
|
||
framebufferInfo.pAttachments = attachments;
|
||
std::cout << "Creating framebuffer " << i << " with MSAA (view=" << m_msaaImageView
|
||
<< ", resolve=" << m_imageViews[i] << ")" << std::endl;
|
||
} else {
|
||
// No MSAA: single attachment
|
||
framebufferInfo.attachmentCount = 1;
|
||
framebufferInfo.pAttachments = &m_imageViews[i];
|
||
}
|
||
|
||
VkResult result = vkCreateFramebuffer(m_device, &framebufferInfo, nullptr, &m_framebuffers[i]);
|
||
if (result != VK_SUCCESS) {
|
||
std::cout << "Failed to create framebuffer " << i << ", error: " << result << std::endl;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
VkShaderModule VulkanRenderer::createShaderModule(const std::vector<char>& code)
|
||
{
|
||
VkShaderModuleCreateInfo createInfo = {};
|
||
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||
createInfo.codeSize = code.size();
|
||
createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data());
|
||
|
||
VkShaderModule shaderModule;
|
||
if (vkCreateShaderModule(m_device, &createInfo, nullptr, &shaderModule) != VK_SUCCESS) {
|
||
return VK_NULL_HANDLE;
|
||
}
|
||
|
||
return shaderModule;
|
||
}
|
||
|
||
bool VulkanRenderer::createBackgroundPipeline()
|
||
{
|
||
// For now, use simple shaders embedded in code
|
||
// In production, load from compiled SPIR-V files
|
||
|
||
// Simple vertex shader (SPIR-V bytecode for passthrough with UBO)
|
||
static const uint32_t bgVertCode[] = {
|
||
#include "shaders_spirv/background_vert.inc"
|
||
};
|
||
|
||
static const uint32_t bgFragCode[] = {
|
||
#include "shaders_spirv/background_frag.inc"
|
||
};
|
||
|
||
// Create shader modules
|
||
VkShaderModuleCreateInfo vertModuleInfo = {};
|
||
vertModuleInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||
vertModuleInfo.codeSize = sizeof(bgVertCode);
|
||
vertModuleInfo.pCode = bgVertCode;
|
||
|
||
VkShaderModule vertShaderModule;
|
||
if (vkCreateShaderModule(m_device, &vertModuleInfo, nullptr, &vertShaderModule) != VK_SUCCESS) {
|
||
// Fallback to simple pipeline without shader includes
|
||
return createBackgroundPipelineSimple();
|
||
}
|
||
|
||
VkShaderModuleCreateInfo fragModuleInfo = {};
|
||
fragModuleInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||
fragModuleInfo.codeSize = sizeof(bgFragCode);
|
||
fragModuleInfo.pCode = bgFragCode;
|
||
|
||
VkShaderModule fragShaderModule;
|
||
if (vkCreateShaderModule(m_device, &fragModuleInfo, nullptr, &fragShaderModule) != VK_SUCCESS) {
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
return createBackgroundPipelineSimple();
|
||
}
|
||
|
||
// Shader stages
|
||
VkPipelineShaderStageCreateInfo vertStageInfo = {};
|
||
vertStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||
vertStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
|
||
vertStageInfo.module = vertShaderModule;
|
||
vertStageInfo.pName = "main";
|
||
|
||
VkPipelineShaderStageCreateInfo fragStageInfo = {};
|
||
fragStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||
fragStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
||
fragStageInfo.module = fragShaderModule;
|
||
fragStageInfo.pName = "main";
|
||
|
||
VkPipelineShaderStageCreateInfo shaderStages[] = {vertStageInfo, fragStageInfo};
|
||
|
||
// Vertex input
|
||
VkVertexInputBindingDescription bindingDescription = {};
|
||
bindingDescription.binding = 0;
|
||
bindingDescription.stride = sizeof(Vertex);
|
||
bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
||
|
||
VkVertexInputAttributeDescription attributeDescriptions[3] = {};
|
||
// Position
|
||
attributeDescriptions[0].binding = 0;
|
||
attributeDescriptions[0].location = 0;
|
||
attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
|
||
attributeDescriptions[0].offset = offsetof(Vertex, pos);
|
||
// Color
|
||
attributeDescriptions[1].binding = 0;
|
||
attributeDescriptions[1].location = 1;
|
||
attributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
|
||
attributeDescriptions[1].offset = offsetof(Vertex, color);
|
||
// TexCoord
|
||
attributeDescriptions[2].binding = 0;
|
||
attributeDescriptions[2].location = 2;
|
||
attributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
|
||
attributeDescriptions[2].offset = offsetof(Vertex, texCoord);
|
||
|
||
VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
|
||
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
||
vertexInputInfo.vertexBindingDescriptionCount = 1;
|
||
vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
|
||
vertexInputInfo.vertexAttributeDescriptionCount = 3;
|
||
vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions;
|
||
|
||
// Input assembly
|
||
VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
|
||
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
||
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
||
inputAssembly.primitiveRestartEnable = VK_FALSE;
|
||
|
||
// Viewport and scissor - use dynamic state
|
||
VkPipelineViewportStateCreateInfo viewportState = {};
|
||
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
|
||
viewportState.viewportCount = 1;
|
||
viewportState.pViewports = nullptr; // Will be set dynamically
|
||
viewportState.scissorCount = 1;
|
||
viewportState.pScissors = nullptr; // Will be set dynamically
|
||
|
||
// Rasterizer
|
||
VkPipelineRasterizationStateCreateInfo rasterizer = {};
|
||
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
|
||
rasterizer.depthClampEnable = VK_FALSE;
|
||
rasterizer.rasterizerDiscardEnable = VK_FALSE;
|
||
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
|
||
rasterizer.lineWidth = 1.0f;
|
||
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
|
||
rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
|
||
rasterizer.depthBiasEnable = VK_FALSE;
|
||
|
||
// Multisampling
|
||
VkPipelineMultisampleStateCreateInfo multisampling = {};
|
||
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
||
multisampling.sampleShadingEnable = VK_TRUE; // Enable sample shading for better quality
|
||
multisampling.minSampleShading = 0.5f; // Minimum fraction for sample shading
|
||
multisampling.rasterizationSamples = static_cast<VkSampleCountFlagBits>(m_msaaSamples);
|
||
|
||
// Color blending
|
||
VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
|
||
colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
|
||
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
||
colorBlendAttachment.blendEnable = VK_FALSE;
|
||
|
||
VkPipelineColorBlendStateCreateInfo colorBlending = {};
|
||
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
||
colorBlending.logicOpEnable = VK_FALSE;
|
||
colorBlending.attachmentCount = 1;
|
||
colorBlending.pAttachments = &colorBlendAttachment;
|
||
|
||
// Pipeline layout
|
||
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
|
||
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
||
pipelineLayoutInfo.setLayoutCount = 1;
|
||
pipelineLayoutInfo.pSetLayouts = &m_descriptorSetLayout;
|
||
|
||
if (vkCreatePipelineLayout(m_device, &pipelineLayoutInfo, nullptr, &m_backgroundPipelineLayout) != VK_SUCCESS) {
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
vkDestroyShaderModule(m_device, fragShaderModule, nullptr);
|
||
return false;
|
||
}
|
||
|
||
// Dynamic state - viewport and scissor
|
||
VkDynamicState dynamicStates[] = {
|
||
VK_DYNAMIC_STATE_VIEWPORT,
|
||
VK_DYNAMIC_STATE_SCISSOR
|
||
};
|
||
|
||
VkPipelineDynamicStateCreateInfo dynamicState = {};
|
||
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
||
dynamicState.dynamicStateCount = 2;
|
||
dynamicState.pDynamicStates = dynamicStates;
|
||
|
||
// Create graphics pipeline
|
||
VkGraphicsPipelineCreateInfo pipelineInfo = {};
|
||
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
||
pipelineInfo.stageCount = 2;
|
||
pipelineInfo.pStages = shaderStages;
|
||
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
||
pipelineInfo.pInputAssemblyState = &inputAssembly;
|
||
pipelineInfo.pViewportState = &viewportState;
|
||
pipelineInfo.pRasterizationState = &rasterizer;
|
||
pipelineInfo.pMultisampleState = &multisampling;
|
||
pipelineInfo.pColorBlendState = &colorBlending;
|
||
pipelineInfo.pDynamicState = &dynamicState;
|
||
pipelineInfo.layout = m_backgroundPipelineLayout;
|
||
pipelineInfo.renderPass = m_renderPass;
|
||
pipelineInfo.subpass = 0;
|
||
|
||
VkResult result = vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_backgroundPipeline);
|
||
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
vkDestroyShaderModule(m_device, fragShaderModule, nullptr);
|
||
|
||
return result == VK_SUCCESS;
|
||
}
|
||
|
||
bool VulkanRenderer::createBackgroundPipelineSimple()
|
||
{
|
||
// Fallback: create a simple pipeline without external shaders
|
||
// This is a placeholder implementation
|
||
logError("Shader files not found, using simple color-only rendering");
|
||
return true;
|
||
}
|
||
|
||
bool VulkanRenderer::createGeometryPipeline()
|
||
{
|
||
// Similar to background pipeline but with different blend mode for overlays
|
||
// For now, reuse the same structure
|
||
|
||
static const uint32_t geomVertCode[] = {
|
||
#include "shaders_spirv/geometry_vert.inc"
|
||
};
|
||
|
||
static const uint32_t geomFragCode[] = {
|
||
#include "shaders_spirv/geometry_frag.inc"
|
||
};
|
||
|
||
VkShaderModuleCreateInfo vertModuleInfo = {};
|
||
vertModuleInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||
vertModuleInfo.codeSize = sizeof(geomVertCode);
|
||
vertModuleInfo.pCode = geomVertCode;
|
||
|
||
VkShaderModule vertShaderModule;
|
||
if (vkCreateShaderModule(m_device, &vertModuleInfo, nullptr, &vertShaderModule) != VK_SUCCESS) {
|
||
return false;
|
||
}
|
||
|
||
VkShaderModuleCreateInfo fragModuleInfo = {};
|
||
fragModuleInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||
fragModuleInfo.codeSize = sizeof(geomFragCode);
|
||
fragModuleInfo.pCode = geomFragCode;
|
||
|
||
VkShaderModule fragShaderModule;
|
||
if (vkCreateShaderModule(m_device, &fragModuleInfo, nullptr, &fragShaderModule) != VK_SUCCESS) {
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
return false;
|
||
}
|
||
|
||
VkPipelineShaderStageCreateInfo shaderStages[2] = {};
|
||
shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||
shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
|
||
shaderStages[0].module = vertShaderModule;
|
||
shaderStages[0].pName = "main";
|
||
shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||
shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
||
shaderStages[1].module = fragShaderModule;
|
||
shaderStages[1].pName = "main";
|
||
|
||
// Vertex input
|
||
VkVertexInputBindingDescription bindingDescription = {};
|
||
bindingDescription.binding = 0;
|
||
bindingDescription.stride = sizeof(Vertex);
|
||
bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
||
|
||
VkVertexInputAttributeDescription attributeDescriptions[3] = {};
|
||
attributeDescriptions[0].binding = 0;
|
||
attributeDescriptions[0].location = 0;
|
||
attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
|
||
attributeDescriptions[0].offset = offsetof(Vertex, pos);
|
||
attributeDescriptions[1].binding = 0;
|
||
attributeDescriptions[1].location = 1;
|
||
attributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
|
||
attributeDescriptions[1].offset = offsetof(Vertex, color);
|
||
attributeDescriptions[2].binding = 0;
|
||
attributeDescriptions[2].location = 2;
|
||
attributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
|
||
attributeDescriptions[2].offset = offsetof(Vertex, texCoord);
|
||
|
||
VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
|
||
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
||
vertexInputInfo.vertexBindingDescriptionCount = 1;
|
||
vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
|
||
vertexInputInfo.vertexAttributeDescriptionCount = 3;
|
||
vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions;
|
||
|
||
VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
|
||
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
||
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
||
inputAssembly.primitiveRestartEnable = VK_FALSE;
|
||
|
||
// Viewport and scissor - use dynamic state
|
||
VkPipelineViewportStateCreateInfo viewportState = {};
|
||
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
|
||
viewportState.viewportCount = 1;
|
||
viewportState.pViewports = nullptr; // Will be set dynamically
|
||
viewportState.scissorCount = 1;
|
||
viewportState.pScissors = nullptr; // Will be set dynamically
|
||
|
||
VkPipelineRasterizationStateCreateInfo rasterizer = {};
|
||
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
|
||
rasterizer.depthClampEnable = VK_FALSE;
|
||
rasterizer.rasterizerDiscardEnable = VK_FALSE;
|
||
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
|
||
rasterizer.lineWidth = 1.0f;
|
||
rasterizer.cullMode = VK_CULL_MODE_NONE;
|
||
rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
||
rasterizer.depthBiasEnable = VK_FALSE;
|
||
|
||
VkPipelineMultisampleStateCreateInfo multisampling = {};
|
||
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
||
multisampling.sampleShadingEnable = VK_TRUE; // Enable sample shading for better quality
|
||
multisampling.minSampleShading = 0.5f; // Minimum fraction for sample shading
|
||
multisampling.rasterizationSamples = static_cast<VkSampleCountFlagBits>(m_msaaSamples);
|
||
|
||
// Enable alpha blending
|
||
VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
|
||
colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
|
||
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
||
colorBlendAttachment.blendEnable = VK_TRUE;
|
||
colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
||
colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
||
colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
|
||
colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
|
||
colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
|
||
colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
|
||
|
||
VkPipelineColorBlendStateCreateInfo colorBlending = {};
|
||
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
||
colorBlending.logicOpEnable = VK_FALSE;
|
||
colorBlending.attachmentCount = 1;
|
||
colorBlending.pAttachments = &colorBlendAttachment;
|
||
|
||
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
|
||
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
||
pipelineLayoutInfo.setLayoutCount = 1;
|
||
pipelineLayoutInfo.pSetLayouts = &m_descriptorSetLayout;
|
||
|
||
if (vkCreatePipelineLayout(m_device, &pipelineLayoutInfo, nullptr, &m_geometryPipelineLayout) != VK_SUCCESS) {
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
vkDestroyShaderModule(m_device, fragShaderModule, nullptr);
|
||
return false;
|
||
}
|
||
|
||
// Dynamic state - viewport and scissor
|
||
VkDynamicState dynamicStates[] = {
|
||
VK_DYNAMIC_STATE_VIEWPORT,
|
||
VK_DYNAMIC_STATE_SCISSOR
|
||
};
|
||
|
||
VkPipelineDynamicStateCreateInfo dynamicState = {};
|
||
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
||
dynamicState.dynamicStateCount = 2;
|
||
dynamicState.pDynamicStates = dynamicStates;
|
||
|
||
VkGraphicsPipelineCreateInfo pipelineInfo = {};
|
||
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
||
pipelineInfo.stageCount = 2;
|
||
pipelineInfo.pStages = shaderStages;
|
||
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
||
pipelineInfo.pInputAssemblyState = &inputAssembly;
|
||
pipelineInfo.pViewportState = &viewportState;
|
||
pipelineInfo.pRasterizationState = &rasterizer;
|
||
pipelineInfo.pMultisampleState = &multisampling;
|
||
pipelineInfo.pColorBlendState = &colorBlending;
|
||
pipelineInfo.pDynamicState = &dynamicState;
|
||
pipelineInfo.layout = m_geometryPipelineLayout;
|
||
pipelineInfo.renderPass = m_renderPass;
|
||
pipelineInfo.subpass = 0;
|
||
|
||
VkResult result = vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_geometryPipeline);
|
||
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
vkDestroyShaderModule(m_device, fragShaderModule, nullptr);
|
||
|
||
return (result == VK_SUCCESS);
|
||
}
|
||
|
||
bool VulkanRenderer::createLinePipeline()
|
||
{
|
||
// Create a pipeline for line rendering (waves)
|
||
|
||
static const uint32_t geomVertCode[] = {
|
||
#include "shaders_spirv/geometry_vert.inc"
|
||
};
|
||
|
||
static const uint32_t geomFragCode[] = {
|
||
#include "shaders_spirv/geometry_frag.inc"
|
||
};
|
||
|
||
VkShaderModuleCreateInfo vertModuleInfo = {};
|
||
vertModuleInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||
vertModuleInfo.codeSize = sizeof(geomVertCode);
|
||
vertModuleInfo.pCode = geomVertCode;
|
||
|
||
VkShaderModule vertShaderModule;
|
||
if (vkCreateShaderModule(m_device, &vertModuleInfo, nullptr, &vertShaderModule) != VK_SUCCESS) {
|
||
return false;
|
||
}
|
||
|
||
VkShaderModuleCreateInfo fragModuleInfo = {};
|
||
fragModuleInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||
fragModuleInfo.codeSize = sizeof(geomFragCode);
|
||
fragModuleInfo.pCode = geomFragCode;
|
||
|
||
VkShaderModule fragShaderModule;
|
||
if (vkCreateShaderModule(m_device, &fragModuleInfo, nullptr, &fragShaderModule) != VK_SUCCESS) {
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
return false;
|
||
}
|
||
|
||
VkPipelineShaderStageCreateInfo shaderStages[2] = {};
|
||
shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||
shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
|
||
shaderStages[0].module = vertShaderModule;
|
||
shaderStages[0].pName = "main";
|
||
shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||
shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
||
shaderStages[1].module = fragShaderModule;
|
||
shaderStages[1].pName = "main";
|
||
|
||
// Vertex input
|
||
VkVertexInputBindingDescription bindingDescription = {};
|
||
bindingDescription.binding = 0;
|
||
bindingDescription.stride = sizeof(Vertex);
|
||
bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
||
|
||
VkVertexInputAttributeDescription attributeDescriptions[3] = {};
|
||
attributeDescriptions[0].binding = 0;
|
||
attributeDescriptions[0].location = 0;
|
||
attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
|
||
attributeDescriptions[0].offset = offsetof(Vertex, pos);
|
||
attributeDescriptions[1].binding = 0;
|
||
attributeDescriptions[1].location = 1;
|
||
attributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
|
||
attributeDescriptions[1].offset = offsetof(Vertex, color);
|
||
attributeDescriptions[2].binding = 0;
|
||
attributeDescriptions[2].location = 2;
|
||
attributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
|
||
attributeDescriptions[2].offset = offsetof(Vertex, texCoord);
|
||
|
||
VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
|
||
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
||
vertexInputInfo.vertexBindingDescriptionCount = 1;
|
||
vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
|
||
vertexInputInfo.vertexAttributeDescriptionCount = 3;
|
||
vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions;
|
||
|
||
VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
|
||
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
||
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST; // Line rendering!
|
||
inputAssembly.primitiveRestartEnable = VK_FALSE;
|
||
|
||
// Viewport and scissor - use dynamic state
|
||
VkPipelineViewportStateCreateInfo viewportState = {};
|
||
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
|
||
viewportState.viewportCount = 1;
|
||
viewportState.pViewports = nullptr; // Will be set dynamically
|
||
viewportState.scissorCount = 1;
|
||
viewportState.pScissors = nullptr; // Will be set dynamically
|
||
|
||
VkPipelineRasterizationStateCreateInfo rasterizer = {};
|
||
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
|
||
rasterizer.depthClampEnable = VK_FALSE;
|
||
rasterizer.rasterizerDiscardEnable = VK_FALSE;
|
||
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
|
||
rasterizer.lineWidth = 2.0f; // Thicker lines for visibility
|
||
rasterizer.cullMode = VK_CULL_MODE_NONE;
|
||
rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
||
rasterizer.depthBiasEnable = VK_FALSE;
|
||
|
||
VkPipelineMultisampleStateCreateInfo multisampling = {};
|
||
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
||
multisampling.sampleShadingEnable = VK_TRUE; // Enable sample shading for smoother lines
|
||
multisampling.minSampleShading = 0.75f; // Higher quality for lines
|
||
multisampling.rasterizationSamples = static_cast<VkSampleCountFlagBits>(m_msaaSamples);
|
||
|
||
// Enable alpha blending
|
||
VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
|
||
colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
|
||
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
||
colorBlendAttachment.blendEnable = VK_TRUE;
|
||
colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
||
colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
||
colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
|
||
colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
|
||
colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
|
||
colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
|
||
|
||
VkPipelineColorBlendStateCreateInfo colorBlending = {};
|
||
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
||
colorBlending.logicOpEnable = VK_FALSE;
|
||
colorBlending.attachmentCount = 1;
|
||
colorBlending.pAttachments = &colorBlendAttachment;
|
||
|
||
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
|
||
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
||
pipelineLayoutInfo.setLayoutCount = 1;
|
||
pipelineLayoutInfo.pSetLayouts = &m_descriptorSetLayout;
|
||
|
||
if (vkCreatePipelineLayout(m_device, &pipelineLayoutInfo, nullptr, &m_linePipelineLayout) != VK_SUCCESS) {
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
vkDestroyShaderModule(m_device, fragShaderModule, nullptr);
|
||
return false;
|
||
}
|
||
|
||
// Dynamic state - viewport and scissor
|
||
VkDynamicState dynamicStates[] = {
|
||
VK_DYNAMIC_STATE_VIEWPORT,
|
||
VK_DYNAMIC_STATE_SCISSOR
|
||
};
|
||
|
||
VkPipelineDynamicStateCreateInfo dynamicState = {};
|
||
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
||
dynamicState.dynamicStateCount = 2;
|
||
dynamicState.pDynamicStates = dynamicStates;
|
||
|
||
VkGraphicsPipelineCreateInfo pipelineInfo = {};
|
||
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
||
pipelineInfo.stageCount = 2;
|
||
pipelineInfo.pStages = shaderStages;
|
||
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
||
pipelineInfo.pInputAssemblyState = &inputAssembly;
|
||
pipelineInfo.pViewportState = &viewportState;
|
||
pipelineInfo.pRasterizationState = &rasterizer;
|
||
pipelineInfo.pMultisampleState = &multisampling;
|
||
pipelineInfo.pColorBlendState = &colorBlending;
|
||
pipelineInfo.pDynamicState = &dynamicState;
|
||
pipelineInfo.layout = m_linePipelineLayout;
|
||
pipelineInfo.renderPass = m_renderPass;
|
||
pipelineInfo.subpass = 0;
|
||
|
||
VkResult result = vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_linePipeline);
|
||
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
vkDestroyShaderModule(m_device, fragShaderModule, nullptr);
|
||
|
||
return (result == VK_SUCCESS);
|
||
}
|
||
|
||
bool VulkanRenderer::createTextPipeline()
|
||
{
|
||
// Load text shaders from embedded SPIR-V
|
||
static const uint32_t textVertCode[] = {
|
||
#include "shaders_spirv/text_vert.inc"
|
||
};
|
||
|
||
static const uint32_t textFragCode[] = {
|
||
#include "shaders_spirv/text_frag.inc"
|
||
};
|
||
|
||
VkShaderModuleCreateInfo vertModuleInfo = {};
|
||
vertModuleInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||
vertModuleInfo.codeSize = sizeof(textVertCode);
|
||
vertModuleInfo.pCode = textVertCode;
|
||
|
||
VkShaderModule vertShaderModule = VK_NULL_HANDLE;
|
||
if (vkCreateShaderModule(m_device, &vertModuleInfo, nullptr, &vertShaderModule) != VK_SUCCESS) {
|
||
logError("Failed to create text vertex shader module");
|
||
return false;
|
||
}
|
||
|
||
VkShaderModuleCreateInfo fragModuleInfo = {};
|
||
fragModuleInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||
fragModuleInfo.codeSize = sizeof(textFragCode);
|
||
fragModuleInfo.pCode = textFragCode;
|
||
|
||
VkShaderModule fragShaderModule = VK_NULL_HANDLE;
|
||
if (vkCreateShaderModule(m_device, &fragModuleInfo, nullptr, &fragShaderModule) != VK_SUCCESS) {
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
logError("Failed to create text fragment shader module");
|
||
return false;
|
||
}
|
||
|
||
VkPipelineShaderStageCreateInfo vertShaderStageInfo = {};
|
||
vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||
vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
|
||
vertShaderStageInfo.module = vertShaderModule;
|
||
vertShaderStageInfo.pName = "main";
|
||
|
||
VkPipelineShaderStageCreateInfo fragShaderStageInfo = {};
|
||
fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||
fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
||
fragShaderStageInfo.module = fragShaderModule;
|
||
fragShaderStageInfo.pName = "main";
|
||
|
||
VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};
|
||
|
||
// Vertex input
|
||
VkVertexInputBindingDescription bindingDescription = {};
|
||
bindingDescription.binding = 0;
|
||
bindingDescription.stride = sizeof(Vertex);
|
||
bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
||
|
||
std::vector<VkVertexInputAttributeDescription> attributeDescriptions(3);
|
||
attributeDescriptions[0].binding = 0;
|
||
attributeDescriptions[0].location = 0;
|
||
attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
|
||
attributeDescriptions[0].offset = offsetof(Vertex, pos);
|
||
|
||
attributeDescriptions[1].binding = 0;
|
||
attributeDescriptions[1].location = 1;
|
||
attributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
|
||
attributeDescriptions[1].offset = offsetof(Vertex, color);
|
||
|
||
attributeDescriptions[2].binding = 0;
|
||
attributeDescriptions[2].location = 2;
|
||
attributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
|
||
attributeDescriptions[2].offset = offsetof(Vertex, texCoord);
|
||
|
||
VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
|
||
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
||
vertexInputInfo.vertexBindingDescriptionCount = 1;
|
||
vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
|
||
vertexInputInfo.vertexAttributeDescriptionCount = attributeDescriptions.size();
|
||
vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
|
||
|
||
VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
|
||
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
||
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
||
inputAssembly.primitiveRestartEnable = VK_FALSE;
|
||
|
||
VkViewport viewport = {};
|
||
viewport.x = 0.0f;
|
||
viewport.y = 0.0f;
|
||
viewport.width = (float)m_width;
|
||
viewport.height = (float)m_height;
|
||
viewport.minDepth = 0.0f;
|
||
viewport.maxDepth = 1.0f;
|
||
|
||
VkRect2D scissor = {};
|
||
scissor.offset = {0, 0};
|
||
scissor.extent = {m_width, m_height};
|
||
|
||
VkPipelineViewportStateCreateInfo viewportState = {};
|
||
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
|
||
viewportState.viewportCount = 1;
|
||
viewportState.pViewports = &viewport;
|
||
viewportState.scissorCount = 1;
|
||
viewportState.pScissors = &scissor;
|
||
|
||
VkPipelineRasterizationStateCreateInfo rasterizer = {};
|
||
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
|
||
rasterizer.depthClampEnable = VK_FALSE;
|
||
rasterizer.rasterizerDiscardEnable = VK_FALSE;
|
||
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
|
||
rasterizer.lineWidth = 1.0f;
|
||
rasterizer.cullMode = VK_CULL_MODE_NONE;
|
||
rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
||
rasterizer.depthBiasEnable = VK_FALSE;
|
||
|
||
VkPipelineMultisampleStateCreateInfo multisampling = {};
|
||
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
||
multisampling.sampleShadingEnable = VK_TRUE; // Enable sample shading for smoother text
|
||
multisampling.minSampleShading = 1.0f; // Maximum quality for text rendering
|
||
multisampling.rasterizationSamples = static_cast<VkSampleCountFlagBits>(m_msaaSamples);
|
||
|
||
// Enable alpha blending for text
|
||
VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
|
||
colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
|
||
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
||
colorBlendAttachment.blendEnable = VK_TRUE;
|
||
colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
||
colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
||
colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
|
||
colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
|
||
colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
|
||
colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
|
||
|
||
VkPipelineColorBlendStateCreateInfo colorBlending = {};
|
||
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
||
colorBlending.logicOpEnable = VK_FALSE;
|
||
colorBlending.attachmentCount = 1;
|
||
colorBlending.pAttachments = &colorBlendAttachment;
|
||
|
||
// Create descriptor set layout for text (with texture sampler)
|
||
VkDescriptorSetLayoutBinding bindings[2];
|
||
|
||
// UBO binding
|
||
bindings[0].binding = 0;
|
||
bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
||
bindings[0].descriptorCount = 1;
|
||
bindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
|
||
bindings[0].pImmutableSamplers = nullptr;
|
||
|
||
// Texture sampler binding
|
||
bindings[1].binding = 1;
|
||
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
||
bindings[1].descriptorCount = 1;
|
||
bindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
|
||
bindings[1].pImmutableSamplers = nullptr;
|
||
|
||
VkDescriptorSetLayoutCreateInfo layoutInfo = {};
|
||
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
||
layoutInfo.bindingCount = 2;
|
||
layoutInfo.pBindings = bindings;
|
||
|
||
VkDescriptorSetLayout textDescriptorSetLayout;
|
||
if (vkCreateDescriptorSetLayout(m_device, &layoutInfo, nullptr, &textDescriptorSetLayout) != VK_SUCCESS) {
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
vkDestroyShaderModule(m_device, fragShaderModule, nullptr);
|
||
return false;
|
||
}
|
||
|
||
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
|
||
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
||
pipelineLayoutInfo.setLayoutCount = 1;
|
||
pipelineLayoutInfo.pSetLayouts = &textDescriptorSetLayout;
|
||
|
||
if (vkCreatePipelineLayout(m_device, &pipelineLayoutInfo, nullptr, &m_textPipelineLayout) != VK_SUCCESS) {
|
||
vkDestroyDescriptorSetLayout(m_device, textDescriptorSetLayout, nullptr);
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
vkDestroyShaderModule(m_device, fragShaderModule, nullptr);
|
||
return false;
|
||
}
|
||
|
||
VkGraphicsPipelineCreateInfo pipelineInfo = {};
|
||
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
||
pipelineInfo.stageCount = 2;
|
||
pipelineInfo.pStages = shaderStages;
|
||
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
||
pipelineInfo.pInputAssemblyState = &inputAssembly;
|
||
pipelineInfo.pViewportState = &viewportState;
|
||
pipelineInfo.pRasterizationState = &rasterizer;
|
||
pipelineInfo.pMultisampleState = &multisampling;
|
||
pipelineInfo.pColorBlendState = &colorBlending;
|
||
pipelineInfo.layout = m_textPipelineLayout;
|
||
pipelineInfo.renderPass = m_renderPass;
|
||
pipelineInfo.subpass = 0;
|
||
|
||
VkResult result = vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &pipelineInfo,
|
||
nullptr, &m_textPipeline);
|
||
|
||
vkDestroyShaderModule(m_device, vertShaderModule, nullptr);
|
||
vkDestroyShaderModule(m_device, fragShaderModule, nullptr);
|
||
vkDestroyDescriptorSetLayout(m_device, textDescriptorSetLayout, nullptr);
|
||
|
||
if (result != VK_SUCCESS) {
|
||
logError("Failed to create text graphics pipeline");
|
||
return false;
|
||
}
|
||
|
||
std::cout << "Text pipeline created successfully" << std::endl;
|
||
std::cout << "Text pipeline handle: " << m_textPipeline << std::endl;
|
||
std::cout << "Text pipeline layout: " << m_textPipelineLayout << std::endl;
|
||
return true;
|
||
}
|
||
|
||
bool VulkanRenderer::createDescriptorSetLayout()
|
||
{
|
||
std::vector<VkDescriptorSetLayoutBinding> bindings(2);
|
||
|
||
// UBO binding
|
||
bindings[0].binding = 0;
|
||
bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
||
bindings[0].descriptorCount = 1;
|
||
bindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
|
||
bindings[0].pImmutableSamplers = nullptr;
|
||
|
||
// Image sampler binding
|
||
bindings[1].binding = 1;
|
||
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
||
bindings[1].descriptorCount = 1;
|
||
bindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
|
||
bindings[1].pImmutableSamplers = nullptr;
|
||
|
||
VkDescriptorSetLayoutCreateInfo layoutInfo = {};
|
||
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
||
layoutInfo.bindingCount = bindings.size();
|
||
layoutInfo.pBindings = bindings.data();
|
||
|
||
if (vkCreateDescriptorSetLayout(m_device, &layoutInfo, nullptr, &m_descriptorSetLayout) != VK_SUCCESS) {
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
bool VulkanRenderer::createDescriptorPool()
|
||
{
|
||
std::vector<VkDescriptorPoolSize> poolSizes(2);
|
||
|
||
// UBO pool size
|
||
poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
||
poolSizes[0].descriptorCount = MAX_FRAMES_IN_FLIGHT;
|
||
|
||
// Image sampler pool size
|
||
poolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
||
poolSizes[1].descriptorCount = MAX_FRAMES_IN_FLIGHT;
|
||
|
||
VkDescriptorPoolCreateInfo poolInfo = {};
|
||
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
|
||
poolInfo.poolSizeCount = poolSizes.size();
|
||
poolInfo.pPoolSizes = poolSizes.data();
|
||
poolInfo.maxSets = MAX_FRAMES_IN_FLIGHT;
|
||
|
||
if (vkCreateDescriptorPool(m_device, &poolInfo, nullptr, &m_descriptorPool) != VK_SUCCESS) {
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
bool VulkanRenderer::createDescriptorSets()
|
||
{
|
||
std::vector<VkDescriptorSetLayout> layouts(MAX_FRAMES_IN_FLIGHT, m_descriptorSetLayout);
|
||
|
||
VkDescriptorSetAllocateInfo allocInfo = {};
|
||
allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
|
||
allocInfo.descriptorPool = m_descriptorPool;
|
||
allocInfo.descriptorSetCount = MAX_FRAMES_IN_FLIGHT;
|
||
allocInfo.pSetLayouts = layouts.data();
|
||
|
||
m_descriptorSets.resize(MAX_FRAMES_IN_FLIGHT);
|
||
if (vkAllocateDescriptorSets(m_device, &allocInfo, m_descriptorSets.data()) != VK_SUCCESS) {
|
||
return false;
|
||
}
|
||
|
||
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
||
VkDescriptorBufferInfo bufferInfo = {};
|
||
bufferInfo.buffer = m_uniformBuffers[i];
|
||
bufferInfo.offset = 0;
|
||
bufferInfo.range = sizeof(UniformBufferObject);
|
||
|
||
std::vector<VkWriteDescriptorSet> descriptorWrites;
|
||
|
||
// UBO descriptor
|
||
VkWriteDescriptorSet uboWrite = {};
|
||
uboWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
||
uboWrite.dstSet = m_descriptorSets[i];
|
||
uboWrite.dstBinding = 0;
|
||
uboWrite.dstArrayElement = 0;
|
||
uboWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
||
uboWrite.descriptorCount = 1;
|
||
uboWrite.pBufferInfo = &bufferInfo;
|
||
descriptorWrites.push_back(uboWrite);
|
||
|
||
// Font texture descriptor (if available)
|
||
VkDescriptorImageInfo imageInfo = {};
|
||
if (m_fontTextureView != VK_NULL_HANDLE && m_fontSampler != VK_NULL_HANDLE) {
|
||
imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
||
imageInfo.imageView = m_fontTextureView;
|
||
imageInfo.sampler = m_fontSampler;
|
||
|
||
VkWriteDescriptorSet imageWrite = {};
|
||
imageWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
||
imageWrite.dstSet = m_descriptorSets[i];
|
||
imageWrite.dstBinding = 1;
|
||
imageWrite.dstArrayElement = 0;
|
||
imageWrite.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
||
imageWrite.descriptorCount = 1;
|
||
imageWrite.pImageInfo = &imageInfo;
|
||
descriptorWrites.push_back(imageWrite);
|
||
}
|
||
|
||
vkUpdateDescriptorSets(m_device, descriptorWrites.size(), descriptorWrites.data(), 0, nullptr);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool VulkanRenderer::createUniformBuffers()
|
||
{
|
||
VkDeviceSize bufferSize = sizeof(UniformBufferObject);
|
||
|
||
m_uniformBuffers.resize(MAX_FRAMES_IN_FLIGHT);
|
||
m_uniformBuffersMemory.resize(MAX_FRAMES_IN_FLIGHT);
|
||
m_uniformBuffersMapped.resize(MAX_FRAMES_IN_FLIGHT);
|
||
|
||
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
||
if (!createBuffer(bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||
m_uniformBuffers[i], m_uniformBuffersMemory[i])) {
|
||
logError("Failed to create uniform buffer");
|
||
return false;
|
||
}
|
||
|
||
VkResult result = vkMapMemory(m_device, m_uniformBuffersMemory[i], 0, bufferSize, 0, &m_uniformBuffersMapped[i]);
|
||
if (result != VK_SUCCESS) {
|
||
logError("Failed to map uniform buffer memory");
|
||
return false;
|
||
}
|
||
|
||
if (m_uniformBuffersMapped[i] == nullptr) {
|
||
logError("Uniform buffer mapped pointer is null");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void VulkanRenderer::updateUniformBuffer(uint32_t currentImage)
|
||
{
|
||
if (currentImage < m_uniformBuffersMapped.size()) {
|
||
if (m_uniformBuffersMapped[currentImage] != nullptr) {
|
||
memcpy(m_uniformBuffersMapped[currentImage], &m_ubo, sizeof(m_ubo));
|
||
} else {
|
||
logError("Uniform buffer mapped pointer is null");
|
||
}
|
||
} else {
|
||
std::cerr << "VulkanRenderer::updateUniformBuffer - currentImage " << currentImage
|
||
<< " out of range (size: " << m_uniformBuffersMapped.size() << ")" << std::endl;
|
||
}
|
||
}
|
||
|
||
bool VulkanRenderer::createVertexBuffer(const std::vector<Vertex>& vertices,
|
||
VkBuffer& buffer, VkDeviceMemory& memory)
|
||
{
|
||
if (vertices.empty()) {
|
||
logError("Cannot create vertex buffer from empty vertices");
|
||
return false;
|
||
}
|
||
|
||
VkDeviceSize bufferSize = sizeof(Vertex) * vertices.size();
|
||
|
||
VkBuffer stagingBuffer;
|
||
VkDeviceMemory stagingBufferMemory;
|
||
if (!createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||
stagingBuffer, stagingBufferMemory)) {
|
||
logError("Failed to create staging buffer for vertex buffer");
|
||
return false;
|
||
}
|
||
|
||
void* data = nullptr;
|
||
VkResult result = vkMapMemory(m_device, stagingBufferMemory, 0, bufferSize, 0, &data);
|
||
if (result != VK_SUCCESS || data == nullptr) {
|
||
logError("Failed to map staging buffer memory for vertex buffer");
|
||
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
|
||
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
|
||
return false;
|
||
}
|
||
|
||
memcpy(data, vertices.data(), bufferSize);
|
||
vkUnmapMemory(m_device, stagingBufferMemory);
|
||
|
||
if (!createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, buffer, memory)) {
|
||
logError("Failed to create device local vertex buffer");
|
||
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
|
||
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
|
||
return false;
|
||
}
|
||
|
||
if (!copyBuffer(stagingBuffer, buffer, bufferSize)) {
|
||
logError("Failed to copy staging buffer to vertex buffer");
|
||
// 清理已创建的目标 buffer 和 staging buffer
|
||
vkDestroyBuffer(m_device, buffer, nullptr);
|
||
vkFreeMemory(m_device, memory, nullptr);
|
||
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
|
||
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
|
||
buffer = VK_NULL_HANDLE;
|
||
memory = VK_NULL_HANDLE;
|
||
return false;
|
||
}
|
||
|
||
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
|
||
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool VulkanRenderer::createIndexBuffer(const std::vector<uint16_t>& indices,
|
||
VkBuffer& buffer, VkDeviceMemory& memory)
|
||
{
|
||
if (indices.empty()) {
|
||
logError("Cannot create index buffer from empty indices");
|
||
return false;
|
||
}
|
||
|
||
VkDeviceSize bufferSize = sizeof(uint16_t) * indices.size();
|
||
|
||
VkBuffer stagingBuffer;
|
||
VkDeviceMemory stagingBufferMemory;
|
||
if (!createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||
stagingBuffer, stagingBufferMemory)) {
|
||
logError("Failed to create staging buffer for index buffer");
|
||
return false;
|
||
}
|
||
|
||
void* data = nullptr;
|
||
VkResult result = vkMapMemory(m_device, stagingBufferMemory, 0, bufferSize, 0, &data);
|
||
if (result != VK_SUCCESS || data == nullptr) {
|
||
logError("Failed to map staging buffer memory for index buffer");
|
||
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
|
||
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
|
||
return false;
|
||
}
|
||
|
||
memcpy(data, indices.data(), bufferSize);
|
||
vkUnmapMemory(m_device, stagingBufferMemory);
|
||
|
||
if (!createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
|
||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, buffer, memory)) {
|
||
logError("Failed to create device local index buffer");
|
||
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
|
||
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
|
||
return false;
|
||
}
|
||
|
||
if (!copyBuffer(stagingBuffer, buffer, bufferSize)) {
|
||
logError("Failed to copy staging buffer to index buffer");
|
||
// 清理已创建的目标 buffer 和 staging buffer
|
||
vkDestroyBuffer(m_device, buffer, nullptr);
|
||
vkFreeMemory(m_device, memory, nullptr);
|
||
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
|
||
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
|
||
buffer = VK_NULL_HANDLE;
|
||
memory = VK_NULL_HANDLE;
|
||
return false;
|
||
}
|
||
|
||
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
|
||
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool VulkanRenderer::createDynamicVertexBuffer(uint64_t size, VkBuffer& buffer, VkDeviceMemory& memory)
|
||
{
|
||
// 创建 host-visible 的 vertex buffer，可以直接映射更新，无需 staging buffer
|
||
return createBuffer(size,
|
||
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||
buffer, memory);
|
||
}
|
||
|
||
bool VulkanRenderer::createDynamicIndexBuffer(uint64_t size, VkBuffer& buffer, VkDeviceMemory& memory)
|
||
{
|
||
// 创建 host-visible 的 index buffer，可以直接映射更新，无需 staging buffer
|
||
return createBuffer(size,
|
||
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
|
||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||
buffer, memory);
|
||
}
|
||
|
||
bool VulkanRenderer::updateDynamicBuffer(VkDeviceMemory memory, const void* data, uint64_t size)
|
||
{
|
||
// 直接映射内存并更新，无需命令队列和同步
|
||
void* mappedData = nullptr;
|
||
VkResult result = vkMapMemory(m_device, memory, 0, size, 0, &mappedData);
|
||
if (result != VK_SUCCESS || mappedData == nullptr) {
|
||
logError("Failed to map dynamic buffer memory");
|
||
return false;
|
||
}
|
||
|
||
memcpy(mappedData, data, size);
|
||
vkUnmapMemory(m_device, memory);
|
||
return true;
|
||
}
|
||
|
||
bool VulkanRenderer::createBuffer(uint64_t size, uint32_t usage, uint32_t properties,
|
||
VkBuffer& buffer, VkDeviceMemory& memory)
|
||
{
|
||
VkBufferCreateInfo bufferInfo = {};
|
||
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
||
bufferInfo.size = size;
|
||
bufferInfo.usage = usage;
|
||
bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
|
||
if (vkCreateBuffer(m_device, &bufferInfo, nullptr, &buffer) != VK_SUCCESS) {
|
||
return false;
|
||
}
|
||
|
||
VkMemoryRequirements memRequirements;
|
||
vkGetBufferMemoryRequirements(m_device, buffer, &memRequirements);
|
||
|
||
VkMemoryAllocateInfo allocInfo = {};
|
||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||
allocInfo.allocationSize = memRequirements.size;
|
||
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
|
||
|
||
if (vkAllocateMemory(m_device, &allocInfo, nullptr, &memory) != VK_SUCCESS) {
|
||
vkDestroyBuffer(m_device, buffer, nullptr);
|
||
return false;
|
||
}
|
||
|
||
vkBindBufferMemory(m_device, buffer, memory, 0);
|
||
return true;
|
||
}
|
||
|
||
bool VulkanRenderer::copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, uint64_t size)
|
||
{
|
||
if (srcBuffer == VK_NULL_HANDLE || dstBuffer == VK_NULL_HANDLE) {
|
||
logError("Cannot copy buffer: source or destination is null");
|
||
return false;
|
||
}
|
||
|
||
if (m_graphicsQueue == VK_NULL_HANDLE) {
|
||
logError("Cannot copy buffer: graphics queue is null");
|
||
return false;
|
||
}
|
||
|
||
// Note: 移除 vkDeviceWaitIdle，改用 fence 精确同步
|
||
// vkDeviceWaitIdle 在三缓冲场景下会导致等待失败
|
||
// 因为双缓冲的 fence 机制只能确保 2 帧的同步
|
||
|
||
|
||
// Create a one-time command pool if not exists
|
||
if (m_transferCommandPool == VK_NULL_HANDLE) {
|
||
VkCommandPoolCreateInfo poolInfo = {};
|
||
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
||
poolInfo.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
|
||
poolInfo.queueFamilyIndex = m_queueFamilyIndex;
|
||
|
||
VkResult result = vkCreateCommandPool(m_device, &poolInfo, nullptr, &m_transferCommandPool);
|
||
if (result != VK_SUCCESS) {
|
||
logError("Failed to create transfer command pool");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// Allocate a one-time command buffer
|
||
VkCommandBufferAllocateInfo allocInfo = {};
|
||
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
||
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
||
allocInfo.commandPool = m_transferCommandPool;
|
||
allocInfo.commandBufferCount = 1;
|
||
|
||
VkCommandBuffer commandBuffer;
|
||
VkResult result = vkAllocateCommandBuffers(m_device, &allocInfo, &commandBuffer);
|
||
if (result != VK_SUCCESS) {
|
||
logError("Failed to allocate command buffer for copy");
|
||
return false;
|
||
}
|
||
|
||
// Begin recording
|
||
VkCommandBufferBeginInfo beginInfo = {};
|
||
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
||
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
||
|
||
result = vkBeginCommandBuffer(commandBuffer, &beginInfo);
|
||
if (result != VK_SUCCESS) {
|
||
logError("Failed to begin command buffer for copy");
|
||
vkFreeCommandBuffers(m_device, m_transferCommandPool, 1, &commandBuffer);
|
||
return false;
|
||
}
|
||
|
||
// Copy command
|
||
VkBufferCopy copyRegion = {};
|
||
copyRegion.srcOffset = 0;
|
||
copyRegion.dstOffset = 0;
|
||
copyRegion.size = size;
|
||
vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, ©Region);
|
||
|
||
result = vkEndCommandBuffer(commandBuffer);
|
||
if (result != VK_SUCCESS) {
|
||
logError("Failed to end command buffer for copy");
|
||
vkFreeCommandBuffers(m_device, m_transferCommandPool, 1, &commandBuffer);
|
||
return false;
|
||
}
|
||
|
||
// Create a fence for synchronization
|
||
VkFenceCreateInfo fenceInfo = {};
|
||
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
|
||
fenceInfo.flags = 0;
|
||
|
||
VkFence fence;
|
||
result = vkCreateFence(m_device, &fenceInfo, nullptr, &fence);
|
||
if (result != VK_SUCCESS) {
|
||
logError("Failed to create fence for buffer copy");
|
||
vkFreeCommandBuffers(m_device, m_transferCommandPool, 1, &commandBuffer);
|
||
return false;
|
||
}
|
||
|
||
// Submit and wait
|
||
VkSubmitInfo submitInfo = {};
|
||
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
||
submitInfo.commandBufferCount = 1;
|
||
submitInfo.pCommandBuffers = &commandBuffer;
|
||
|
||
result = vkQueueSubmit(m_graphicsQueue, 1, &submitInfo, fence);
|
||
if (result != VK_SUCCESS) {
|
||
std::cerr << "vkQueueSubmit failed with error code: " << result << std::endl;
|
||
logError("Failed to submit copy command");
|
||
vkDestroyFence(m_device, fence, nullptr);
|
||
vkFreeCommandBuffers(m_device, m_transferCommandPool, 1, &commandBuffer);
|
||
return false;
|
||
}
|
||
|
||
// Wait for the fence with short timeout (100ms) to avoid blocking
|
||
// 使用短超时快速失败，避免长时间阻塞渲染循环导致设备丢失
|
||
result = vkWaitForFences(m_device, 1, &fence, VK_TRUE, 100000000ULL); // 100 ms in nanoseconds
|
||
if (result == VK_TIMEOUT) {
|
||
std::cerr << "TIMEOUT: vkWaitForFences exceeded 100ms - GPU busy, will retry later" << std::endl;
|
||
logError("Timeout waiting for fence after copy (100ms) - skipping this buffer update");
|
||
vkDestroyFence(m_device, fence, nullptr);
|
||
vkFreeCommandBuffers(m_device, m_transferCommandPool, 1, &commandBuffer);
|
||
return false;
|
||
} else if (result != VK_SUCCESS) {
|
||
std::cerr << "vkWaitForFences failed with error code: " << result << std::endl;
|
||
logError("Failed to wait for fence after copy");
|
||
vkDestroyFence(m_device, fence, nullptr);
|
||
vkFreeCommandBuffers(m_device, m_transferCommandPool, 1, &commandBuffer);
|
||
return false;
|
||
}
|
||
|
||
// Cleanup fence
|
||
vkDestroyFence(m_device, fence, nullptr);
|
||
|
||
// Free command buffer
|
||
vkFreeCommandBuffers(m_device, m_transferCommandPool, 1, &commandBuffer);
|
||
|
||
return true;
|
||
}
|
||
|
||
uint32_t VulkanRenderer::findMemoryType(uint32_t typeFilter, uint32_t properties)
|
||
{
|
||
VkPhysicalDeviceMemoryProperties memProperties;
|
||
vkGetPhysicalDeviceMemoryProperties(m_physicalDevice, &memProperties);
|
||
|
||
for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
|
||
if ((typeFilter & (1 << i)) &&
|
||
(memProperties.memoryTypes[i].propertyFlags & properties) == properties) {
|
||
return i;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
bool VulkanRenderer::initializeTextRendering()
|
||
{
|
||
#ifdef ENABLE_FREETYPE
|
||
std::cout << "========================================" << std::endl;
|
||
std::cout << "Initializing text rendering with FreeType..." << std::endl;
|
||
|
||
// Initialize FreeType library
|
||
FT_Library ft;
|
||
if (FT_Init_FreeType(&ft)) {
|
||
logError("Failed to initialize FreeType library");
|
||
return false;
|
||
}
|
||
|
||
// Load font face - try multiple common font paths
|
||
FT_Face face;
|
||
const char* fontPaths[] = {
|
||
"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
|
||
"/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
|
||
"/usr/share/fonts/TTF/DejaVuSans.ttf",
|
||
"/System/Library/Fonts/Helvetica.ttc",
|
||
"/usr/local/share/fonts/DejaVuSans.ttf"
|
||
};
|
||
|
||
bool fontLoaded = false;
|
||
for (const char* fontPath : fontPaths) {
|
||
if (FT_New_Face(ft, fontPath, 0, &face) == 0) {
|
||
std::cout << "Loaded font: " << fontPath << std::endl;
|
||
fontLoaded = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!fontLoaded) {
|
||
logError("Failed to load any font");
|
||
FT_Done_FreeType(ft);
|
||
return false;
|
||
}
|
||
|
||
// Set pixel size
|
||
FT_Set_Pixel_Sizes(face, 0, 48);
|
||
|
||
// Create font atlas
|
||
if (!createFontAtlas()) {
|
||
logError("Failed to create font atlas");
|
||
FT_Done_Face(face);
|
||
FT_Done_FreeType(ft);
|
||
return false;
|
||
}
|
||
|
||
// Generate character textures for ASCII printable characters
|
||
const int atlasWidth = 512;
|
||
const int atlasHeight = 512;
|
||
unsigned char* atlasData = new unsigned char[atlasWidth * atlasHeight];
|
||
memset(atlasData, 0, atlasWidth * atlasHeight);
|
||
|
||
int penX = 0;
|
||
int penY = 0;
|
||
int rowHeight = 0;
|
||
|
||
// Generate glyphs for ASCII 32-126
|
||
for (unsigned char c = 32; c < 127; c++) {
|
||
if (FT_Load_Char(face, c, FT_LOAD_RENDER)) {
|
||
std::cerr << "Failed to load glyph: " << c << std::endl;
|
||
continue;
|
||
}
|
||
|
||
FT_GlyphSlot g = face->glyph;
|
||
|
||
// Check if we need to move to next row
|
||
if (penX + g->bitmap.width >= atlasWidth) {
|
||
penX = 0;
|
||
penY += rowHeight;
|
||
rowHeight = 0;
|
||
}
|
||
|
||
// Check if we have space
|
||
if (penY + g->bitmap.rows >= atlasHeight) {
|
||
std::cerr << "Font atlas too small!" << std::endl;
|
||
break;
|
||
}
|
||
|
||
// Copy glyph bitmap to atlas
|
||
for (unsigned int row = 0; row < g->bitmap.rows; row++) {
|
||
for (unsigned int col = 0; col < g->bitmap.width; col++) {
|
||
int x = penX + col;
|
||
int y = penY + row;
|
||
atlasData[y * atlasWidth + x] = g->bitmap.buffer[row * g->bitmap.width + col];
|
||
}
|
||
}
|
||
|
||
// Store character info
|
||
CharInfo charInfo;
|
||
charInfo.texCoords[0] = (float)penX / atlasWidth;
|
||
charInfo.texCoords[1] = (float)penY / atlasHeight;
|
||
charInfo.texCoords[2] = (float)g->bitmap.width / atlasWidth;
|
||
charInfo.texCoords[3] = (float)g->bitmap.rows / atlasHeight;
|
||
charInfo.size[0] = (float)g->bitmap.width;
|
||
charInfo.size[1] = (float)g->bitmap.rows;
|
||
charInfo.bearing[0] = (float)g->bitmap_left;
|
||
charInfo.bearing[1] = (float)g->bitmap_top;
|
||
charInfo.advance = (float)(g->advance.x >> 6);
|
||
|
||
m_charInfoMap[c] = charInfo;
|
||
|
||
// Update position
|
||
penX += g->bitmap.width + 1; // 1 pixel padding
|
||
rowHeight = std::max(rowHeight, (int)g->bitmap.rows);
|
||
}
|
||
|
||
// Create Vulkan texture from atlas
|
||
VkDeviceSize imageSize = atlasWidth * atlasHeight;
|
||
|
||
// Create staging buffer
|
||
VkBuffer stagingBuffer;
|
||
VkDeviceMemory stagingBufferMemory;
|
||
if (!createBuffer(imageSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||
stagingBuffer, stagingBufferMemory)) {
|
||
delete[] atlasData;
|
||
FT_Done_Face(face);
|
||
FT_Done_FreeType(ft);
|
||
return false;
|
||
}
|
||
|
||
// Copy atlas data to staging buffer
|
||
void* data;
|
||
vkMapMemory(m_device, stagingBufferMemory, 0, imageSize, 0, &data);
|
||
memcpy(data, atlasData, imageSize);
|
||
vkUnmapMemory(m_device, stagingBufferMemory);
|
||
|
||
delete[] atlasData;
|
||
|
||
// Create image
|
||
VkImageCreateInfo imageInfo = {};
|
||
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
||
imageInfo.imageType = VK_IMAGE_TYPE_2D;
|
||
imageInfo.extent.width = atlasWidth;
|
||
imageInfo.extent.height = atlasHeight;
|
||
imageInfo.extent.depth = 1;
|
||
imageInfo.mipLevels = 1;
|
||
imageInfo.arrayLayers = 1;
|
||
imageInfo.format = VK_FORMAT_R8_UNORM;
|
||
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
|
||
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
imageInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
|
||
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
|
||
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
|
||
if (vkCreateImage(m_device, &imageInfo, nullptr, &m_fontTexture) != VK_SUCCESS) {
|
||
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
|
||
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
|
||
FT_Done_Face(face);
|
||
FT_Done_FreeType(ft);
|
||
return false;
|
||
}
|
||
|
||
// Allocate image memory
|
||
VkMemoryRequirements memRequirements;
|
||
vkGetImageMemoryRequirements(m_device, m_fontTexture, &memRequirements);
|
||
|
||
VkMemoryAllocateInfo allocInfo = {};
|
||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||
allocInfo.allocationSize = memRequirements.size;
|
||
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits,
|
||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||
|
||
if (vkAllocateMemory(m_device, &allocInfo, nullptr, &m_fontTextureMemory) != VK_SUCCESS) {
|
||
vkDestroyImage(m_device, m_fontTexture, nullptr);
|
||
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
|
||
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
|
||
FT_Done_Face(face);
|
||
FT_Done_FreeType(ft);
|
||
return false;
|
||
}
|
||
|
||
vkBindImageMemory(m_device, m_fontTexture, m_fontTextureMemory, 0);
|
||
|
||
// Transition image layout and copy buffer to image
|
||
// (This requires a command buffer - simplified version)
|
||
VkCommandPoolCreateInfo poolInfo = {};
|
||
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
||
poolInfo.queueFamilyIndex = m_queueFamilyIndex;
|
||
poolInfo.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
|
||
|
||
if (m_transferCommandPool == VK_NULL_HANDLE) {
|
||
vkCreateCommandPool(m_device, &poolInfo, nullptr, &m_transferCommandPool);
|
||
}
|
||
|
||
VkCommandBufferAllocateInfo allocInfoCmd = {};
|
||
allocInfoCmd.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
||
allocInfoCmd.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
||
allocInfoCmd.commandPool = m_transferCommandPool;
|
||
allocInfoCmd.commandBufferCount = 1;
|
||
|
||
VkCommandBuffer commandBuffer;
|
||
vkAllocateCommandBuffers(m_device, &allocInfoCmd, &commandBuffer);
|
||
|
||
VkCommandBufferBeginInfo beginInfo = {};
|
||
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
||
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
||
|
||
vkBeginCommandBuffer(commandBuffer, &beginInfo);
|
||
|
||
// Transition to transfer dst
|
||
VkImageMemoryBarrier barrier = {};
|
||
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
||
barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
||
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
||
barrier.image = m_fontTexture;
|
||
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_TRANSFER_WRITE_BIT;
|
||
|
||
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
|
||
VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
|
||
|
||
// Copy buffer to image
|
||
VkBufferImageCopy region = {};
|
||
region.bufferOffset = 0;
|
||
region.bufferRowLength = 0;
|
||
region.bufferImageHeight = 0;
|
||
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
region.imageSubresource.mipLevel = 0;
|
||
region.imageSubresource.baseArrayLayer = 0;
|
||
region.imageSubresource.layerCount = 1;
|
||
region.imageOffset = {0, 0, 0};
|
||
region.imageExtent = {(uint32_t)atlasWidth, (uint32_t)atlasHeight, 1};
|
||
|
||
vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, m_fontTexture,
|
||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion);
|
||
|
||
// Transition to shader read
|
||
barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||
barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
||
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
||
barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
||
|
||
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
|
||
|
||
vkEndCommandBuffer(commandBuffer);
|
||
|
||
VkSubmitInfo submitInfo = {};
|
||
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
||
submitInfo.commandBufferCount = 1;
|
||
submitInfo.pCommandBuffers = &commandBuffer;
|
||
|
||
vkQueueSubmit(m_graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
|
||
vkQueueWaitIdle(m_graphicsQueue);
|
||
|
||
vkFreeCommandBuffers(m_device, m_transferCommandPool, 1, &commandBuffer);
|
||
vkDestroyBuffer(m_device, stagingBuffer, nullptr);
|
||
vkFreeMemory(m_device, stagingBufferMemory, nullptr);
|
||
|
||
// Create image view
|
||
VkImageViewCreateInfo viewInfo = {};
|
||
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||
viewInfo.image = m_fontTexture;
|
||
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
||
viewInfo.format = VK_FORMAT_R8_UNORM;
|
||
viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
viewInfo.subresourceRange.baseMipLevel = 0;
|
||
viewInfo.subresourceRange.levelCount = 1;
|
||
viewInfo.subresourceRange.baseArrayLayer = 0;
|
||
viewInfo.subresourceRange.layerCount = 1;
|
||
|
||
if (vkCreateImageView(m_device, &viewInfo, nullptr, &m_fontTextureView) != VK_SUCCESS) {
|
||
FT_Done_Face(face);
|
||
FT_Done_FreeType(ft);
|
||
return false;
|
||
}
|
||
|
||
// Create sampler
|
||
VkSamplerCreateInfo samplerInfo = {};
|
||
samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
||
samplerInfo.magFilter = VK_FILTER_LINEAR;
|
||
samplerInfo.minFilter = VK_FILTER_LINEAR;
|
||
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
||
samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
||
samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
||
samplerInfo.anisotropyEnable = VK_FALSE;
|
||
samplerInfo.maxAnisotropy = 1.0f;
|
||
samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
|
||
samplerInfo.unnormalizedCoordinates = VK_FALSE;
|
||
samplerInfo.compareEnable = VK_FALSE;
|
||
samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
|
||
samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
|
||
|
||
if (vkCreateSampler(m_device, &samplerInfo, nullptr, &m_fontSampler) != VK_SUCCESS) {
|
||
FT_Done_Face(face);
|
||
FT_Done_FreeType(ft);
|
||
return false;
|
||
}
|
||
|
||
// Cleanup FreeType
|
||
FT_Done_Face(face);
|
||
FT_Done_FreeType(ft);
|
||
|
||
std::cout << "Text rendering initialized successfully with " << m_charInfoMap.size() << " characters" << std::endl;
|
||
std::cout << "Font texture: " << (m_fontTexture != VK_NULL_HANDLE ? "OK" : "NULL") << std::endl;
|
||
std::cout << "Font texture view: " << (m_fontTextureView != VK_NULL_HANDLE ? "OK" : "NULL") << std::endl;
|
||
std::cout << "Font sampler: " << (m_fontSampler != VK_NULL_HANDLE ? "OK" : "NULL") << std::endl;
|
||
std::cout << "========================================" << std::endl;
|
||
return true;
|
||
#else
|
||
std::cout << "Text rendering not available (FreeType not enabled)" << std::endl;
|
||
return false;
|
||
#endif
|
||
}
|
||
|
||
bool VulkanRenderer::createFontAtlas()
|
||
{
|
||
// Font atlas creation is now handled in initializeTextRendering
|
||
return true;
|
||
}
|
||
|
||
void VulkanRenderer::generateBackgroundQuad(std::vector<Vertex>& vertices,
|
||
std::vector<uint16_t>& indices)
|
||
{
|
||
// Full-screen quad in NDC space
|
||
vertices = {
|
||
{{-1.0f, -1.0f}, {1.0f, 0.0f, 0.0f, 1.0f}, {0.0f, 0.0f}},
|
||
{{ 1.0f, -1.0f}, {0.0f, 1.0f, 0.0f, 1.0f}, {1.0f, 0.0f}},
|
||
{{ 1.0f, 1.0f}, {0.0f, 0.0f, 1.0f, 1.0f}, {1.0f, 1.0f}},
|
||
{{-1.0f, 1.0f}, {1.0f, 1.0f, 0.0f, 1.0f}, {0.0f, 1.0f}}
|
||
};
|
||
|
||
indices = {0, 1, 2, 2, 3, 0};
|
||
}
|
||
|
||
void VulkanRenderer::generateRotatingCircles(std::vector<Vertex>& vertices,
|
||
std::vector<uint16_t>& indices,
|
||
double rotation)
|
||
{
|
||
vertices.clear();
|
||
indices.clear();
|
||
|
||
// Safety check for dimensions
|
||
if (m_width == 0 || m_height == 0) {
|
||
std::cout << "WARNING: generateRotatingCircles called with zero dimensions!" << std::endl;
|
||
return;
|
||
}
|
||
|
||
|
||
// Use screen coordinates (Y-down): center is at middle of screen
|
||
float centerX = m_width / 2.0f;
|
||
float centerY = m_height / 2.0f;
|
||
int numCircles = 8;
|
||
float orbitRadius = 80.0f; // Match CustomWidget
|
||
float circleRadius = 15.0f; // Match CustomWidget
|
||
|
||
|
||
|
||
for (int i = 0; i < numCircles; i++) {
|
||
float angle = (i * 2.0f * M_PI / numCircles) + rotation * M_PI / 180.0f;
|
||
float x = centerX + orbitRadius * cos(angle);
|
||
// Y-down screen coords: positive sin moves down
|
||
float y = centerY + orbitRadius * sin(angle);
|
||
|
||
// HSV to RGB for color - more vibrant colors
|
||
float hue = fmod((i * 360.0f / numCircles + rotation), 360.0f) / 360.0f;
|
||
float r = std::abs(sin(hue * 6.28318f)) * 0.8f + 0.2f;
|
||
float g = std::abs(sin((hue + 0.33f) * 6.28318f)) * 0.8f + 0.2f;
|
||
float b = std::abs(sin((hue + 0.66f) * 6.28318f)) * 0.8f + 0.2f;
|
||
|
||
// Create circle as triangles
|
||
int segments = 16;
|
||
uint16_t centerIdx = vertices.size();
|
||
|
||
// Center vertex with more opaque alpha
|
||
vertices.push_back({{x, y}, {r, g, b, 0.9f}, {0.5f, 0.5f}});
|
||
|
||
for (int j = 0; j <= segments; j++) {
|
||
float segAngle = j * 2.0f * M_PI / segments;
|
||
float vx = x + circleRadius * cos(segAngle);
|
||
float vy = y + circleRadius * sin(segAngle);
|
||
vertices.push_back({{vx, vy}, {r, g, b, 0.9f}, {0.0f, 0.0f}});
|
||
|
||
if (j > 0) {
|
||
indices.push_back(centerIdx);
|
||
indices.push_back(centerIdx + j);
|
||
indices.push_back(centerIdx + j + 1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void VulkanRenderer::generateWaveEffect(std::vector<Vertex>& vertices,
|
||
std::vector<uint16_t>& indices,
|
||
double wavePhase)
|
||
{
|
||
vertices.clear();
|
||
indices.clear();
|
||
|
||
// Safety check for dimensions
|
||
if (m_width == 0 || m_height == 0) {
|
||
std::cout << "WARNING: generateWaveEffect called with zero dimensions!" << std::endl;
|
||
return;
|
||
}
|
||
|
||
int numPoints = m_width / 5 + 1;
|
||
float waveY = m_height * 0.7f;
|
||
float amplitude = 30.0f;
|
||
|
||
// First wave - screen coordinates (Y-down)
|
||
for (int i = 0; i < numPoints; i++) {
|
||
float x = i * 5.0f;
|
||
float y = waveY + amplitude * sin(wavePhase + x * 0.02);
|
||
vertices.push_back({{x, y}, {1.0f, 1.0f, 1.0f, 0.6f}, {0.0f, 0.0f}});
|
||
}
|
||
|
||
// Line list indices for first wave (pairs of points)
|
||
for (int i = 0; i < numPoints - 1; i++) {
|
||
indices.push_back(i);
|
||
indices.push_back(i + 1);
|
||
}
|
||
|
||
// Second wave (phase shifted) - screen coordinates (Y-down)
|
||
uint16_t offset = vertices.size();
|
||
for (int i = 0; i < numPoints; i++) {
|
||
float x = i * 5.0f;
|
||
float y = waveY + amplitude * sin(wavePhase + M_PI + x * 0.02);
|
||
vertices.push_back({{x, y}, {1.0f, 1.0f, 0.4f, 0.5f}, {0.0f, 0.0f}});
|
||
}
|
||
|
||
// Line list indices for second wave (pairs of points)
|
||
for (int i = 0; i < numPoints - 1; i++) {
|
||
indices.push_back(offset + i);
|
||
indices.push_back(offset + i + 1);
|
||
}
|
||
}
|
||
|
||
float VulkanRenderer::calculateTextWidth(const std::string& text, float scale)
|
||
{
|
||
if (m_charInfoMap.empty()) {
|
||
return 0.0f;
|
||
}
|
||
|
||
float width = 0.0f;
|
||
for (size_t i = 0; i < text.length(); i++) {
|
||
char c = text[i];
|
||
|
||
// Skip newlines and characters not in atlas
|
||
if (c == '\n' || m_charInfoMap.find(c) == m_charInfoMap.end()) {
|
||
continue;
|
||
}
|
||
|
||
const CharInfo& ch = m_charInfoMap[c];
|
||
width += ch.advance * scale;
|
||
}
|
||
|
||
return width;
|
||
}
|
||
|
||
void VulkanRenderer::generateTextQuads(const std::string& text, float x, float y,
|
||
float scale, const float color[4],
|
||
std::vector<Vertex>& vertices,
|
||
std::vector<uint16_t>& indices)
|
||
{
|
||
if (m_charInfoMap.empty()) {
|
||
return; // No font loaded
|
||
}
|
||
|
||
float currentX = x;
|
||
float currentY = y;
|
||
|
||
for (size_t i = 0; i < text.length(); i++) {
|
||
char c = text[i];
|
||
|
||
// Handle newline
|
||
if (c == '\n') {
|
||
currentX = x;
|
||
currentY += 60.0f * scale; // Line height
|
||
continue;
|
||
}
|
||
|
||
// Skip characters not in atlas
|
||
if (m_charInfoMap.find(c) == m_charInfoMap.end()) {
|
||
continue;
|
||
}
|
||
|
||
const CharInfo& ch = m_charInfoMap[c];
|
||
|
||
float xpos = currentX + ch.bearing[0] * scale;
|
||
float ypos = currentY - ch.bearing[1] * scale;
|
||
float w = ch.size[0] * scale;
|
||
float h = ch.size[1] * scale;
|
||
|
||
// Use pixel coordinates (shader will convert to NDC)
|
||
float x0 = xpos;
|
||
float y0 = ypos;
|
||
float x1 = xpos + w;
|
||
float y1 = ypos + h;
|
||
|
||
// Texture coordinates
|
||
float u0 = ch.texCoords[0];
|
||
float v0 = ch.texCoords[1];
|
||
float u1 = ch.texCoords[0] + ch.texCoords[2];
|
||
float v1 = ch.texCoords[1] + ch.texCoords[3];
|
||
|
||
uint16_t startIdx = vertices.size();
|
||
|
||
// Create quad
|
||
Vertex v0_vert = {{x0, y0}, {color[0], color[1], color[2], color[3]}, {u0, v0}};
|
||
Vertex v1_vert = {{x1, y0}, {color[0], color[1], color[2], color[3]}, {u1, v0}};
|
||
Vertex v2_vert = {{x1, y1}, {color[0], color[1], color[2], color[3]}, {u1, v1}};
|
||
Vertex v3_vert = {{x0, y1}, {color[0], color[1], color[2], color[3]}, {u0, v1}};
|
||
|
||
vertices.push_back(v0_vert);
|
||
vertices.push_back(v1_vert);
|
||
vertices.push_back(v2_vert);
|
||
vertices.push_back(v3_vert);
|
||
|
||
// Two triangles
|
||
indices.push_back(startIdx + 0);
|
||
indices.push_back(startIdx + 1);
|
||
indices.push_back(startIdx + 2);
|
||
indices.push_back(startIdx + 2);
|
||
indices.push_back(startIdx + 3);
|
||
indices.push_back(startIdx + 0);
|
||
|
||
currentX += ch.advance * scale;
|
||
}
|
||
}
|
||
|
||
void VulkanRenderer::drawBackground(VkCommandBuffer commandBuffer, int frameCount)
|
||
{
|
||
if (m_backgroundPipeline == VK_NULL_HANDLE || m_backgroundVertexBuffer == VK_NULL_HANDLE ||
|
||
m_backgroundPipelineLayout == VK_NULL_HANDLE || m_descriptorSets.empty()) {
|
||
return;
|
||
}
|
||
|
||
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_backgroundPipeline);
|
||
|
||
// Use the same frameIndex that was used to update the uniform buffer
|
||
uint32_t frameIndex = frameCount % MAX_FRAMES_IN_FLIGHT;
|
||
if (frameIndex >= m_descriptorSets.size()) {
|
||
return;
|
||
}
|
||
|
||
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
||
m_backgroundPipelineLayout, 0, 1, &m_descriptorSets[frameIndex], 0, nullptr);
|
||
|
||
VkBuffer vertexBuffers[] = {m_backgroundVertexBuffer};
|
||
VkDeviceSize offsets[] = {0};
|
||
vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
|
||
vkCmdBindIndexBuffer(commandBuffer, m_backgroundIndexBuffer, 0, VK_INDEX_TYPE_UINT16);
|
||
vkCmdDrawIndexed(commandBuffer, m_backgroundIndexCount, 1, 0, 0, 0);
|
||
}
|
||
|
||
void VulkanRenderer::drawGeometry(VkCommandBuffer commandBuffer, int frameCount, double rotation, double wavePhase)
|
||
{
|
||
if (m_geometryPipeline == VK_NULL_HANDLE || m_geometryPipelineLayout == VK_NULL_HANDLE ||
|
||
m_descriptorSets.empty()) {
|
||
return;
|
||
}
|
||
|
||
// Use the same frameIndex that was used to update the uniform buffer
|
||
uint32_t frameIndex = frameCount % MAX_FRAMES_IN_FLIGHT;
|
||
if (frameIndex >= m_descriptorSets.size()) {
|
||
return;
|
||
}
|
||
|
||
// Draw circles with geometry pipeline
|
||
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_geometryPipeline);
|
||
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
||
m_geometryPipelineLayout, 0, 1, &m_descriptorSets[frameIndex], 0, nullptr);
|
||
|
||
if (m_circleVertexBuffer != VK_NULL_HANDLE && m_circleIndexBuffer != VK_NULL_HANDLE && m_circleIndexCount > 0) {
|
||
VkBuffer vertexBuffers[] = {m_circleVertexBuffer};
|
||
VkDeviceSize offsets[] = {0};
|
||
vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
|
||
vkCmdBindIndexBuffer(commandBuffer, m_circleIndexBuffer, 0, VK_INDEX_TYPE_UINT16);
|
||
vkCmdDrawIndexed(commandBuffer, m_circleIndexCount, 1, 0, 0, 0);
|
||
}
|
||
|
||
// Draw waves with line pipeline
|
||
if (m_linePipeline != VK_NULL_HANDLE && m_linePipelineLayout != VK_NULL_HANDLE &&
|
||
m_waveVertexBuffer != VK_NULL_HANDLE && m_waveIndexBuffer != VK_NULL_HANDLE && m_waveIndexCount > 0) {
|
||
|
||
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_linePipeline);
|
||
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
||
m_linePipelineLayout, 0, 1, &m_descriptorSets[frameIndex], 0, nullptr);
|
||
|
||
VkBuffer waveBuffers[] = {m_waveVertexBuffer};
|
||
VkDeviceSize offsets[] = {0};
|
||
vkCmdBindVertexBuffers(commandBuffer, 0, 1, waveBuffers, offsets);
|
||
vkCmdBindIndexBuffer(commandBuffer, m_waveIndexBuffer, 0, VK_INDEX_TYPE_UINT16);
|
||
vkCmdDrawIndexed(commandBuffer, m_waveIndexCount, 1, 0, 0, 0);
|
||
}
|
||
}
|
||
|
||
void VulkanRenderer::drawText(VkCommandBuffer commandBuffer, int frameCount,
|
||
bool paintingEnabled, const std::string& lockInfo)
|
||
{
|
||
static int textDebugCounter = 0;
|
||
|
||
if (m_charInfoMap.empty() || m_textPipeline == VK_NULL_HANDLE) {
|
||
if (textDebugCounter % 300 == 1) {
|
||
std::cout << "Text rendering not available - skipping" << std::endl;
|
||
}
|
||
return; // Text rendering not available
|
||
}
|
||
|
||
// Bind text pipeline
|
||
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_textPipeline);
|
||
|
||
// Bind descriptor sets for text rendering (if using textures)
|
||
if (!m_descriptorSets.empty()) {
|
||
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
||
m_textPipelineLayout, 0, 1,
|
||
&m_descriptorSets[0], 0, nullptr);
|
||
}
|
||
|
||
std::vector<Vertex> vertices;
|
||
std::vector<uint16_t> indices;
|
||
|
||
float white[4] = {1.0f, 1.0f, 1.0f, 1.0f};
|
||
float green[4] = {0.78f, 1.0f, 0.78f, 1.0f};
|
||
float yellow[4] = {1.0f, 1.0f, 0.59f, 1.0f};
|
||
float magenta[4] = {1.0f, 0.78f, 1.0f, 1.0f};
|
||
float gray[4] = {0.78f, 0.78f, 0.78f, 1.0f};
|
||
|
||
// Use reference resolution (1920x1080) for consistent text size across different window sizes
|
||
const float refWidth = m_width;
|
||
const float refHeight = m_height;
|
||
|
||
// Calculate uniform scale factor based on height to avoid text distortion
|
||
// Use height as the primary factor since vertical space is usually more constrained
|
||
float scale = m_height / refHeight;
|
||
|
||
// For positioning, we still need to account for the actual window dimensions
|
||
// But use the same scale factor for both X and Y to prevent distortion
|
||
float scaleX = scale;
|
||
float scaleY = scale;
|
||
|
||
if (!paintingEnabled) {
|
||
// Screen locked state
|
||
std::string title = "PAINTING DISABLED";
|
||
std::string subtitle = "(Screen Locked)";
|
||
|
||
// Calculate centered positions
|
||
float titleScale = 0.6f;
|
||
float subtitleScale = 0.5f;
|
||
float titleWidth = calculateTextWidth(title, titleScale);
|
||
float subtitleWidth = calculateTextWidth(subtitle, subtitleScale);
|
||
|
||
float titleX = (refWidth - titleWidth) / 2.0f * scaleX;
|
||
float titleY = (refHeight / 2.0f - 30.0f) * scaleY;
|
||
float subtitleX = (refWidth - subtitleWidth) / 2.0f * scaleX;
|
||
float subtitleY = (refHeight / 2.0f + 30.0f) * scaleY;
|
||
|
||
generateTextQuads(title, titleX, titleY, titleScale, white, vertices, indices);
|
||
generateTextQuads(subtitle, subtitleX, subtitleY, subtitleScale, gray, vertices, indices);
|
||
|
||
// Stats
|
||
std::string stats = "Total Frames Painted: " + std::to_string(frameCount);
|
||
generateTextQuads(stats, 20.0f * scaleX, m_height - 60.0f * scaleY, 0.3f, gray, vertices, indices);
|
||
} else {
|
||
// Active rendering state
|
||
std::string title = "Screen Lock Detector - Painting Active";
|
||
|
||
// Calculate centered position for title
|
||
float titleScale = 0.7f;
|
||
float titleWidth = calculateTextWidth(title, titleScale);
|
||
float titleX = (refWidth - titleWidth) / 2.0f * scaleX;
|
||
|
||
generateTextQuads(title, titleX - 10.0f * scaleX, 60.0f * scaleY, titleScale, white, vertices, indices);
|
||
|
||
// Stats info box
|
||
std::string frameStr = "Frame Count: " + std::to_string(frameCount);
|
||
std::string fpsStr = "FPS: ~60";
|
||
std::string rotStr = "Rotation: " + std::to_string((int)m_ubo.rotation) + "°";
|
||
std::string timeStr = "Running Time: " + std::to_string((int)m_ubo.time) + "s";
|
||
|
||
generateTextQuads(frameStr, 20.0f * scaleX, 130.0f * scaleY, 0.3f, green, vertices, indices);
|
||
generateTextQuads(fpsStr, 20.0f * scaleX, 150.0f * scaleY, 0.3f, green, vertices, indices);
|
||
generateTextQuads(rotStr, 20.0f * scaleX, 170.0f * scaleY, 0.3f, green, vertices, indices);
|
||
generateTextQuads(timeStr, 20.0f * scaleX, 190.0f * scaleY, 0.3f, green, vertices, indices);
|
||
|
||
// Lock info (if available)
|
||
if (!lockInfo.empty()) {
|
||
std::string lockTitle = "Last Lock Info:";
|
||
generateTextQuads(lockTitle, 20.0f * scaleX, 220.0f * scaleY, 0.4f, magenta, vertices, indices);
|
||
|
||
// Parse lock info (assuming format from lockInfo string)
|
||
size_t pos = 0;
|
||
int line = 0;
|
||
std::string info = lockInfo;
|
||
while ((pos = info.find('\n')) != std::string::npos) {
|
||
std::string token = info.substr(0, pos);
|
||
if (!token.empty()) {
|
||
generateTextQuads(token, 20.0f * scaleX, (240.0f + line * 20.0f) * scaleY, 0.3f, magenta, vertices, indices);
|
||
line++;
|
||
}
|
||
info.erase(0, pos + 1);
|
||
}
|
||
if (!info.empty()) {
|
||
generateTextQuads(info, 20.0f * scaleX, (240.0f + line * 20.0f) * scaleY, 0.3f, magenta, vertices, indices);
|
||
}
|
||
}
|
||
|
||
// Hint at bottom - centered
|
||
std::string hint = "Lock your screen to see the painting stop automatically!";
|
||
float hintScale = 0.5f;
|
||
float hintWidth = calculateTextWidth(hint, hintScale);
|
||
float hintX = (refWidth - hintWidth) / 2.0f * scaleX;
|
||
|
||
generateTextQuads(hint, hintX, m_height - 50.0f * scaleY, hintScale, yellow, vertices, indices);
|
||
}
|
||
|
||
// Create/update text buffers
|
||
if (vertices.empty() || indices.empty()) {
|
||
if (textDebugCounter % 300 == 1) {
|
||
std::cout << "No text vertices generated - skipping" << std::endl;
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 首次创建 text buffers（使用 host-visible 内存）
|
||
if (m_textVertexBuffer == VK_NULL_HANDLE) {
|
||
VkDeviceSize textVertexSize = sizeof(Vertex) * 4096; // 预分配足够空间
|
||
VkDeviceSize textIndexSize = sizeof(uint16_t) * 6144;
|
||
|
||
if (!createDynamicVertexBuffer(textVertexSize, m_textVertexBuffer, m_textVertexMemory)) {
|
||
logError("Failed to create dynamic text vertex buffer");
|
||
return;
|
||
}
|
||
if (!createDynamicIndexBuffer(textIndexSize, m_textIndexBuffer, m_textIndexMemory)) {
|
||
logError("Failed to create dynamic text index buffer");
|
||
vkDestroyBuffer(m_device, m_textVertexBuffer, nullptr);
|
||
vkFreeMemory(m_device, m_textVertexMemory, nullptr);
|
||
m_textVertexBuffer = VK_NULL_HANDLE;
|
||
m_textVertexMemory = VK_NULL_HANDLE;
|
||
return;
|
||
}
|
||
|
||
std::cout << "Dynamic text buffers created (host-visible, no staging)" << std::endl;
|
||
}
|
||
|
||
// 每帧直接更新 buffer 内容（通过内存映射，无需命令队列）
|
||
// 使用 host-visible buffers 后，更新成本极低，无需缓存
|
||
if (!vertices.empty() && !indices.empty()) {
|
||
if (!updateDynamicBuffer(m_textVertexMemory, vertices.data(),
|
||
sizeof(Vertex) * vertices.size())) {
|
||
logError("Failed to update text vertex buffer");
|
||
return;
|
||
}
|
||
if (!updateDynamicBuffer(m_textIndexMemory, indices.data(),
|
||
sizeof(uint16_t) * indices.size())) {
|
||
logError("Failed to update text index buffer");
|
||
return;
|
||
}
|
||
m_textIndexCount = indices.size();
|
||
}
|
||
|
||
// Draw text with newly created buffers
|
||
VkBuffer vertexBuffers[] = {m_textVertexBuffer};
|
||
VkDeviceSize offsets[] = {0};
|
||
vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
|
||
vkCmdBindIndexBuffer(commandBuffer, m_textIndexBuffer, 0, VK_INDEX_TYPE_UINT16);
|
||
vkCmdDrawIndexed(commandBuffer, m_textIndexCount, 1, 0, 0, 0);
|
||
}
|
||
|
||
void VulkanRenderer::logError(const char* message)
|
||
{
|
||
if (m_errorCallback) {
|
||
m_errorCallback(message);
|
||
} else {
|
||
std::cerr << "VulkanRenderer Error: " << message << std::endl;
|
||
}
|
||
}
|