Renderer.cpp

#define VMA_IMPLEMENTATION
#include "Renderer.h"
#include "Scene.h"
#include "Input.h"
#include "MathUtils.h"
#include "EditorUI.h"
#include <iostream>
#include <stdexcept>
#include <fstream>
#include <algorithm>
#include <cstring>
#include <array>

#include "imgui.h"
#include "backends/imgui_impl_glfw.h"
#include "backends/imgui_impl_vulkan.h"

#ifdef _WIN32
    #include <windows.h>
#else
    #include <unistd.h>
    #include <limits.h>
#endif

std::string getExecutableDir() {
#ifdef _WIN32
    char result[MAX_PATH];
    return std::string(result, GetModuleFileName(NULL, result, MAX_PATH));
#else
    char result[PATH_MAX];
    ssize_t count = readlink("/proc/self/exe", result, PATH_MAX);
    std::string path = std::string(result, (count > 0) ? count : 0);
    return fs::path(path).parent_path().string();
#endif
}

void Renderer::init(GLFWwindow* window) {
    createInstance();
    createSurface(window);
    pickPhysicalDevice();
    createLogicalDevice();

    VmaAllocatorCreateInfo allocatorInfo = {};
    allocatorInfo.vulkanApiVersion = VK_API_VERSION_1_3;
    allocatorInfo.physicalDevice = physicalDevice;
    allocatorInfo.device = device;
    allocatorInfo.instance = instance;
    vmaCreateAllocator(&allocatorInfo, &allocator);

    createSwapchain(window);
    createImageViews();
    createDepthResources();
    createGuiRenderPass();
    createGuiFramebuffers();
    createSSBO();
    createDescriptors();
    createPipeline();
    createGraphicsPipeline();
    createDepthPrimePipeline();
    
    std::string shaderPath = getExecutableDir() + "/" + SHADER_SOURCE;
    if(fs::exists(shaderPath)) lastShaderWriteTime = fs::last_write_time(shaderPath);
    
    createCommandPool();
    createCommandBuffers();
    createSyncObjects();
    initImGui(window);
}

void Renderer::cleanup() {
    vkDeviceWaitIdle(device);
    for (auto& mesh : meshCache) {
        if (mesh.isLoaded) {
            vmaDestroyBuffer(allocator, mesh.vertexBuffer.buffer, mesh.vertexBuffer.allocation);
            vmaDestroyBuffer(allocator, mesh.indexBuffer.buffer, mesh.indexBuffer.allocation);
        }
    }
    vkDestroyPipeline(device, graphicsPipeline, nullptr); vkDestroyPipelineLayout(device, graphicsPipelineLayout, nullptr);
    if(logoSampler) vkDestroySampler(device, logoSampler, nullptr); if(logoImageView) vkDestroyImageView(device, logoImageView, nullptr); 
    if(logoImage) vmaDestroyImage(allocator, logoImage, logoImageAllocation);

    ImGui_ImplVulkan_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext();
    vkDestroyDescriptorPool(device, imguiDescriptorPool, nullptr); vkDestroyRenderPass(device, imguiRenderPass, nullptr);
    cleanupSwapchain();
    vkDestroyPipeline(device, computePipeline, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
    vkDestroyPipeline(device, depthPrimePipeline, nullptr); vkDestroyPipelineLayout(device, depthPrimePipelineLayout, nullptr);
    vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
    vkDestroyDescriptorSetLayout(device, depthPrimeSetLayout, nullptr);
    
    vmaUnmapMemory(allocator, sceneBufferAllocation);
    vmaDestroyBuffer(allocator, sceneBuffer, sceneBufferAllocation);

    for(int i=0; i<2; i++) { vkDestroySemaphore(device, imageAvailable[i], nullptr); vkDestroySemaphore(device, renderFinished[i], nullptr); vkDestroyFence(device, inFlightFences[i], nullptr); }
    vkDestroyCommandPool(device, commandPool, nullptr);
    
    vmaDestroyAllocator(allocator);
    vkDestroyDevice(device, nullptr); vkDestroySurfaceKHR(instance, surface, nullptr); vkDestroyInstance(instance, nullptr);
}

std::string findShaderSource() {
    std::string path1 = getExecutableDir() + "/" + SHADER_SOURCE;
    if (fs::exists(path1)) return path1;
    std::string path2 = getExecutableDir() + "/../" + SHADER_SOURCE;
    if (fs::exists(path2)) return path2;
    return SHADER_SOURCE;
}

void Renderer::drawFrame(GLFWwindow* window, bool& framebufferResized) {
    std::string shaderPath = findShaderSource();
    if (fs::exists(shaderPath)) { 
        try { 
            auto t = fs::last_write_time(shaderPath); 
            if (t > lastShaderWriteTime) { 
                vkDeviceWaitIdle(device); 
                reloadShader(); 
                lastShaderWriteTime = t; 
            } 
        } catch(...) {} 
    }
    
    vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
    updateSSBO();
    vkQueueWaitIdle(computeQueue);
    uint32_t imageIndex; VkResult res = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAvailable[currentFrame], VK_NULL_HANDLE, &imageIndex);
    if (res == VK_ERROR_OUT_OF_DATE_KHR) { recreateSwapchain(window); return; }
    vkResetFences(device, 1, &inFlightFences[currentFrame]);
    recordCommandBuffer(commandBuffers[imageIndex], imageIndex);
    VkSubmitInfo si{VK_STRUCTURE_TYPE_SUBMIT_INFO}; VkSemaphore ws[]={imageAvailable[currentFrame]}; VkPipelineStageFlags wst[]={VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT}; si.waitSemaphoreCount=1; si.pWaitSemaphores=ws; si.pWaitDstStageMask=wst; si.commandBufferCount=1; si.pCommandBuffers=&commandBuffers[imageIndex]; VkSemaphore ss[]={renderFinished[currentFrame]}; si.signalSemaphoreCount=1; si.pSignalSemaphores=ss;
    vkQueueSubmit(computeQueue, 1, &si, inFlightFences[currentFrame]);
    VkPresentInfoKHR pi{VK_STRUCTURE_TYPE_PRESENT_INFO_KHR}; pi.waitSemaphoreCount=1; pi.pWaitSemaphores=ss; pi.swapchainCount=1; pi.pSwapchains=&swapchain; pi.pImageIndices=&imageIndex;
    res = vkQueuePresentKHR(presentQueue, &pi);
    if (res == VK_ERROR_OUT_OF_DATE_KHR || res == VK_SUBOPTIMAL_KHR || framebufferResized) { framebufferResized = false; recreateSwapchain(window); }
    currentFrame = (currentFrame + 1) % 2;
}

void Renderer::createInstance() { VkApplicationInfo a{VK_STRUCTURE_TYPE_APPLICATION_INFO,nullptr,"SDF",1,"",1,VK_API_VERSION_1_3}; uint32_t c; const char** e=glfwGetRequiredInstanceExtensions(&c); VkInstanceCreateInfo i{VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,nullptr,0,&a,0,nullptr,c,e}; vkCreateInstance(&i,nullptr,&instance); }
void Renderer::createSurface(GLFWwindow* window) { glfwCreateWindowSurface(instance,window,nullptr,&surface); }
void Renderer::pickPhysicalDevice() { uint32_t c; vkEnumeratePhysicalDevices(instance,&c,nullptr); std::vector<VkPhysicalDevice> d(c); vkEnumeratePhysicalDevices(instance,&c,d.data()); physicalDevice=d[0]; }
void Renderer::createLogicalDevice() {
    float p = 1.0f; VkDeviceQueueCreateInfo q{VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, nullptr, 0, 0, 1, &p};
    const char* e[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
    VkPhysicalDeviceFeatures deviceFeatures{}; deviceFeatures.shaderStorageImageWriteWithoutFormat = VK_TRUE;
    VkDeviceCreateInfo i{VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, nullptr, 0, 1, &q, 0, nullptr, 1, e, &deviceFeatures};
    vkCreateDevice(physicalDevice, &i, nullptr, &device); vkGetDeviceQueue(device, 0, 0, &computeQueue); vkGetDeviceQueue(device, 0, 0, &presentQueue);
}

void Renderer::createSwapchain(GLFWwindow* window) { VkSurfaceCapabilitiesKHR c; vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice,surface,&c); if(c.currentExtent.width!=UINT32_MAX) swapchainExtent=c.currentExtent; else { int w,h; glfwGetFramebufferSize(window,&w,&h); swapchainExtent={static_cast<uint32_t>(w),static_cast<uint32_t>(h)}; } VkSwapchainCreateInfoKHR i{VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR}; i.surface=surface; i.minImageCount=c.minImageCount+1; if(c.maxImageCount>0&&i.minImageCount>c.maxImageCount) i.minImageCount=c.maxImageCount; i.imageFormat=VK_FORMAT_B8G8R8A8_UNORM; i.imageColorSpace=VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; i.imageExtent=swapchainExtent; i.imageArrayLayers=1; i.imageUsage=VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_STORAGE_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT; i.preTransform=c.currentTransform; i.compositeAlpha=VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; i.presentMode=VK_PRESENT_MODE_FIFO_KHR; i.clipped=VK_TRUE; vkCreateSwapchainKHR(device,&i,nullptr,&swapchain); uint32_t n; vkGetSwapchainImagesKHR(device,swapchain,&n,nullptr); swapchainImages.resize(n); vkGetSwapchainImagesKHR(device,swapchain,&n,swapchainImages.data()); }
void Renderer::createImageViews() { swapchainImageViews.resize(swapchainImages.size()); for(size_t i=0;i<swapchainImages.size();i++) { VkImageViewCreateInfo v{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,nullptr,0,swapchainImages[i],VK_IMAGE_VIEW_TYPE_2D,VK_FORMAT_B8G8R8A8_UNORM,{},{VK_IMAGE_ASPECT_COLOR_BIT,0,1,0,1}}; vkCreateImageView(device,&v,nullptr,&swapchainImageViews[i]); } }

void Renderer::createBuffer(VkDeviceSize s, VkBufferUsageFlags u, VmaMemoryUsage vmaUsage, VkBuffer& b, VmaAllocation& a) {
    VkBufferCreateInfo bufferInfo = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
    bufferInfo.size = s;
    bufferInfo.usage = u;

    VmaAllocationCreateInfo allocInfo = {};
    allocInfo.usage = vmaUsage;

    vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &b, &a, nullptr);
}

void Renderer::createDepthResources() {
    VkFormat depthFormat = VK_FORMAT_D32_SFLOAT;
    createImage(swapchainExtent.width, swapchainExtent.height, depthFormat, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VMA_MEMORY_USAGE_GPU_ONLY, depthImage, depthImageAllocation);
    depthImageView = createImageView(depthImage, depthFormat, VK_IMAGE_ASPECT_DEPTH_BIT);
    createSdfDepthResources();
}

void Renderer::createSdfDepthResources() {
    sdfDepthImages.resize(swapchainImages.size());
    sdfDepthImageAllocations.resize(swapchainImages.size());
    sdfDepthImageViews.resize(swapchainImages.size());
    for(size_t i=0; i<swapchainImages.size(); i++) {
        createImage(swapchainExtent.width, swapchainExtent.height, VK_FORMAT_R32_SFLOAT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, VMA_MEMORY_USAGE_GPU_ONLY, sdfDepthImages[i], sdfDepthImageAllocations[i]);
        sdfDepthImageViews[i] = createImageView(sdfDepthImages[i], VK_FORMAT_R32_SFLOAT, VK_IMAGE_ASPECT_COLOR_BIT);
    }
}

void Renderer::createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VmaMemoryUsage vmaUsage, VkImage& image, VmaAllocation& allocation) {
    VkImageCreateInfo imageInfo{}; imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; imageInfo.imageType = VK_IMAGE_TYPE_2D; imageInfo.extent.width = width; imageInfo.extent.height = height; imageInfo.extent.depth = 1; imageInfo.mipLevels = 1; imageInfo.arrayLayers = 1; imageInfo.format = format; imageInfo.tiling = tiling; imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; imageInfo.usage = usage; imageInfo.samples = VK_SAMPLE_COUNT_1_BIT; imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
    
    VmaAllocationCreateInfo allocInfo = {};
    allocInfo.usage = vmaUsage;
    
    if (vmaCreateImage(allocator, &imageInfo, &allocInfo, &image, &allocation, nullptr) != VK_SUCCESS) throw std::runtime_error("failed to create image via VMA!");
}

VkImageView Renderer::createImageView(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags) {
    VkImageViewCreateInfo viewInfo{}; viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; viewInfo.image = image; viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; viewInfo.format = format; viewInfo.subresourceRange.aspectMask = aspectFlags; viewInfo.subresourceRange.baseMipLevel = 0; viewInfo.subresourceRange.levelCount = 1; viewInfo.subresourceRange.baseArrayLayer = 0; viewInfo.subresourceRange.layerCount = 1;
    VkImageView imageView; if (vkCreateImageView(device, &viewInfo, nullptr, &imageView) != VK_SUCCESS) throw std::runtime_error("failed to create image view!");
    return imageView;
}

void Renderer::createGuiRenderPass() {
    VkAttachmentDescription attachment = {}; attachment.format = VK_FORMAT_B8G8R8A8_UNORM; attachment.samples = VK_SAMPLE_COUNT_1_BIT; attachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD; attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; attachment.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; attachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
    VkAttachmentReference color_attachment = {}; color_attachment.attachment = 0; color_attachment.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

    VkAttachmentDescription depthAttachment{};
    depthAttachment.format = VK_FORMAT_D32_SFLOAT;
    depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
    depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
    depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

    VkAttachmentReference depthAttachmentRef{};
    depthAttachmentRef.attachment = 1;
    depthAttachmentRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

    VkSubpassDescription subpass = {}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &color_attachment;
    subpass.pDepthStencilAttachment = &depthAttachmentRef;

    VkSubpassDependency dependency = {}; dependency.srcSubpass = VK_SUBPASS_EXTERNAL; dependency.dstSubpass = 0; dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; dependency.srcAccessMask = 0; dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;

    std::array<VkAttachmentDescription, 2> attachments = {attachment, depthAttachment};
    VkRenderPassCreateInfo info = {}; info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; info.attachmentCount = (uint32_t)attachments.size(); info.pAttachments = attachments.data(); info.subpassCount = 1; info.pSubpasses = &subpass; info.dependencyCount = 1; info.pDependencies = &dependency;
    vkCreateRenderPass(device, &info, nullptr, &imguiRenderPass);
}

void Renderer::createGuiFramebuffers() {
    imguiFramebuffers.resize(swapchainImageViews.size());
    for (size_t i = 0; i < swapchainImageViews.size(); i++) {
        std::array<VkImageView, 2> attachments = { swapchainImageViews[i], depthImageView };
        VkFramebufferCreateInfo info = {}; info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; info.renderPass = imguiRenderPass; info.attachmentCount = (uint32_t)attachments.size(); info.pAttachments = attachments.data(); info.width = swapchainExtent.width; info.height = swapchainExtent.height; info.layers = 1;
        vkCreateFramebuffer(device, &info, nullptr, &imguiFramebuffers[i]);
    }
}

void Renderer::createSSBO() { 
    createBuffer(sizeof(ObjectData)*MAX_OBJECTS, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU, sceneBuffer, sceneBufferAllocation); 
    vmaMapMemory(allocator, sceneBufferAllocation, &sceneBufferMapped); 
}

void Renderer::updateSSBO() {
    gpuObjectCache.clear();
    for (int i = 0; i < sceneGraph.size(); i++) {
        if (sceneGraph[i].parent == -1) {
            updateHierarchy(i, mat4(1.0f));
        }
    }
    for (const auto& node : sceneGraph) {
        gpuObjectCache.push_back(node.gpuData);
        if (gpuObjectCache.size() >= MAX_OBJECTS) break;
    }
    if (!gpuObjectCache.empty()) {
        memcpy(sceneBufferMapped, gpuObjectCache.data(), gpuObjectCache.size() * sizeof(ObjectData));
    }
}

void Renderer::createDescriptors() {
    VkDescriptorSetLayoutBinding b[]={
        {0,VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,1,VK_SHADER_STAGE_COMPUTE_BIT},
        {1,VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,1,VK_SHADER_STAGE_COMPUTE_BIT},
        {2,VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,1,VK_SHADER_STAGE_COMPUTE_BIT}
    };
    VkDescriptorSetLayoutCreateInfo l{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,nullptr,0,3,b};
    vkCreateDescriptorSetLayout(device,&l,nullptr,&descriptorSetLayout);
    VkDescriptorPoolSize s[]={
        {VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,(uint32_t)swapchainImages.size() * 2},
        {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,(uint32_t)swapchainImages.size()},
        {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,(uint32_t)swapchainImages.size()}
    };
    VkDescriptorPoolCreateInfo p{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,nullptr,0,(uint32_t)swapchainImages.size() + 10,3,s};
    vkCreateDescriptorPool(device,&p,nullptr,&descriptorPool);
    std::vector<VkDescriptorSetLayout> dl(swapchainImages.size(),descriptorSetLayout);
    VkDescriptorSetAllocateInfo a{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,nullptr,descriptorPool,(uint32_t)swapchainImages.size(),dl.data()};
    descriptorSets.resize(swapchainImages.size());
    vkAllocateDescriptorSets(device,&a,descriptorSets.data());
    for(size_t i=0;i<swapchainImages.size();i++) {
        VkDescriptorImageInfo im{nullptr,swapchainImageViews[i],VK_IMAGE_LAYOUT_GENERAL};
        VkDescriptorBufferInfo bu{sceneBuffer,0,sizeof(ObjectData)*MAX_OBJECTS};
        VkDescriptorImageInfo de{nullptr,sdfDepthImageViews[i],VK_IMAGE_LAYOUT_GENERAL};
        VkWriteDescriptorSet w[]={
            {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,nullptr,descriptorSets[i],0,0,1,VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,&im,nullptr,nullptr},
            {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,nullptr,descriptorSets[i],1,0,1,VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,nullptr,&bu,nullptr},
            {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,nullptr,descriptorSets[i],2,0,1,VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,&de,nullptr,nullptr}
        };
        vkUpdateDescriptorSets(device,3,w,0,nullptr);
    }

    VkDescriptorSetLayoutBinding dpb = {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT};
    VkDescriptorSetLayoutCreateInfo dpl{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,nullptr,0,1,&dpb};
    vkCreateDescriptorSetLayout(device, &dpl, nullptr, &depthPrimeSetLayout);

    VkSamplerCreateInfo samplerInfo{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
    samplerInfo.magFilter = VK_FILTER_NEAREST; samplerInfo.minFilter = VK_FILTER_NEAREST;
    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;
    vkCreateSampler(device, &samplerInfo, nullptr, &depthPrimeSampler);

    std::vector<VkDescriptorSetLayout> layouts(swapchainImages.size(), depthPrimeSetLayout);
    VkDescriptorSetAllocateInfo allocInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, nullptr, descriptorPool, (uint32_t)swapchainImages.size(), layouts.data()};
    depthPrimeSets.resize(swapchainImages.size());
    vkAllocateDescriptorSets(device, &allocInfo, depthPrimeSets.data());

    for (size_t i = 0; i < swapchainImages.size(); i++) {
        VkDescriptorImageInfo imageInfo{depthPrimeSampler, sdfDepthImageViews[i], VK_IMAGE_LAYOUT_GENERAL};
        VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, depthPrimeSets[i], 0, 0, 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imageInfo, nullptr, nullptr};
        vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
    }
}

void Renderer::createPipeline() {
    std::string binPath = getExecutableDir() + "/" + SHADER_BINARY;
    auto c=readFile(binPath); VkShaderModuleCreateInfo m{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,nullptr,0,c.size(),(uint32_t*)c.data()};
    VkShaderModule sm; vkCreateShaderModule(device,&m,nullptr,&sm);
    VkPushConstantRange p{VK_SHADER_STAGE_COMPUTE_BIT,0,sizeof(PushConstants)};
    VkPipelineLayoutCreateInfo l{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,nullptr,0,1,&descriptorSetLayout,1,&p};
    vkCreatePipelineLayout(device,&l,nullptr,&pipelineLayout);
    VkComputePipelineCreateInfo i{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,nullptr,0,{VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,nullptr,0,VK_SHADER_STAGE_COMPUTE_BIT,sm,"main"},pipelineLayout};
    vkCreateComputePipelines(device,VK_NULL_HANDLE,1,&i,nullptr,&computePipeline); vkDestroyShaderModule(device,sm,nullptr);
}

void Renderer::createGraphicsPipeline() {
    std::string vertPath = getExecutableDir() + "/mesh_vert.spv";
    std::string fragPath = getExecutableDir() + "/mesh_frag.spv";
    auto virtCode = readFile(vertPath);
    auto fragCode = readFile(fragPath);
    VkShaderModule vertSM, fragSM;
    VkShaderModuleCreateInfo m1{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,nullptr,0,virtCode.size(),(uint32_t*)virtCode.data()};
    VkShaderModuleCreateInfo m2{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,nullptr,0,fragCode.size(),(uint32_t*)fragCode.data()};
    vkCreateShaderModule(device,&m1,nullptr,&vertSM); vkCreateShaderModule(device,&m2,nullptr,&fragSM);

    VkPipelineShaderStageCreateInfo stages[] = {
        {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,nullptr,0,VK_SHADER_STAGE_VERTEX_BIT,vertSM,"main"},
        {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,nullptr,0,VK_SHADER_STAGE_FRAGMENT_BIT,fragSM,"main"}
    };

    VkVertexInputBindingDescription bindingDesc{}; bindingDesc.binding = 0; bindingDesc.stride = sizeof(Vertex); bindingDesc.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
    VkVertexInputAttributeDescription attrDesc[4];
    attrDesc[0] = {0,0,VK_FORMAT_R32G32B32_SFLOAT, offsetof(Vertex, pos)};
    attrDesc[1] = {1,0,VK_FORMAT_R32G32B32_SFLOAT, offsetof(Vertex, normal)};
    attrDesc[2] = {2,0,VK_FORMAT_R32G32_SFLOAT, offsetof(Vertex, uv)};
    attrDesc[3] = {3,0,VK_FORMAT_R32G32B32A32_SFLOAT, offsetof(Vertex, color)};

    VkPipelineVertexInputStateCreateInfo vertexInputInfo{VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO};
    vertexInputInfo.vertexBindingDescriptionCount = 1; vertexInputInfo.pVertexBindingDescriptions = &bindingDesc;
    vertexInputInfo.vertexAttributeDescriptionCount = 4; vertexInputInfo.pVertexAttributeDescriptions = attrDesc;

    VkPipelineInputAssemblyStateCreateInfo inputAssembly{VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO};
    inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;

    VkViewport viewport{0.0f, 0.0f, (float)swapchainExtent.width, (float)swapchainExtent.height, 0.0f, 1.0f};
    VkRect2D scissor{{0, 0}, swapchainExtent};
    VkPipelineViewportStateCreateInfo viewportState{VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO};
    viewportState.viewportCount = 1; viewportState.scissorCount = 1;

    VkPipelineRasterizationStateCreateInfo rasterizer{VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO};
    rasterizer.polygonMode = VK_POLYGON_MODE_FILL; rasterizer.lineWidth = 1.0f; rasterizer.cullMode = VK_CULL_MODE_BACK_BIT; rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;

    VkPipelineMultisampleStateCreateInfo multisampling{VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO};
    multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;

    VkPipelineDepthStencilStateCreateInfo depthStencil{VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO};
    depthStencil.depthTestEnable = VK_TRUE; depthStencil.depthWriteEnable = VK_TRUE; depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;

    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{VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO};
    colorBlending.attachmentCount = 1; colorBlending.pAttachments = &colorBlendAttachment;

    VkDynamicState dynamicStates[] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
    VkPipelineDynamicStateCreateInfo dynamicState{VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO};
    dynamicState.dynamicStateCount = 2; dynamicState.pDynamicStates = dynamicStates;

    VkPushConstantRange p{VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(mat4) + sizeof(mat4) + sizeof(vec4) * 3};
    VkPipelineLayoutCreateInfo pipelineLayoutInfo{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
    pipelineLayoutInfo.setLayoutCount = 0; pipelineLayoutInfo.pushConstantRangeCount = 1; pipelineLayoutInfo.pPushConstantRanges = &p;
    vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &graphicsPipelineLayout);

    VkGraphicsPipelineCreateInfo pipelineInfo{VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO};
    pipelineInfo.stageCount = 2; pipelineInfo.pStages = stages; pipelineInfo.pVertexInputState = &vertexInputInfo;
    pipelineInfo.pInputAssemblyState = &inputAssembly; pipelineInfo.pViewportState = &viewportState;
    pipelineInfo.pRasterizationState = &rasterizer; pipelineInfo.pMultisampleState = &multisampling;
    pipelineInfo.pDepthStencilState = &depthStencil; pipelineInfo.pColorBlendState = &colorBlending;
    pipelineInfo.pDynamicState = &dynamicState;
    pipelineInfo.layout = graphicsPipelineLayout; pipelineInfo.renderPass = imguiRenderPass;
    pipelineInfo.subpass = 0;

    vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline);
    vkDestroyShaderModule(device, vertSM, nullptr); vkDestroyShaderModule(device, fragSM, nullptr);
}

void Renderer::createDepthPrimePipeline() {
    std::string vertPath = getExecutableDir() + "/depth_prime_vert.spv";
    std::string fragPath = getExecutableDir() + "/depth_prime_frag.spv";
    auto vert = readFile(vertPath);
    auto frag = readFile(fragPath);
    VkShaderModule vsm, fsm;
    VkShaderModuleCreateInfo vm{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,nullptr,0,vert.size(),(uint32_t*)vert.data()};
    VkShaderModuleCreateInfo fm{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,nullptr,0,frag.size(),(uint32_t*)frag.data()};
    vkCreateShaderModule(device, &vm, nullptr, &vsm); vkCreateShaderModule(device, &fm, nullptr, &fsm);

    VkPipelineShaderStageCreateInfo stages[2] = {
        {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,nullptr,0,VK_SHADER_STAGE_VERTEX_BIT,vsm,"main"},
        {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,nullptr,0,VK_SHADER_STAGE_FRAGMENT_BIT,fsm,"main"}
    };

    VkPipelineLayoutCreateInfo li{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,nullptr,0,1,&depthPrimeSetLayout,0,nullptr};
    vkCreatePipelineLayout(device, &li, nullptr, &depthPrimePipelineLayout);

    VkPipelineVertexInputStateCreateInfo vi{VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO};
    VkPipelineInputAssemblyStateCreateInfo ia{VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO};
    ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;

    VkPipelineViewportStateCreateInfo vp{VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO};
    vp.viewportCount = 1; vp.scissorCount = 1;

    VkPipelineRasterizationStateCreateInfo rs{VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO};
    rs.polygonMode = VK_POLYGON_MODE_FILL; rs.lineWidth = 1.0f; rs.cullMode = VK_CULL_MODE_NONE;

    VkPipelineMultisampleStateCreateInfo ms{VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO};
    ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;

    VkPipelineDepthStencilStateCreateInfo ds{VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO};
    ds.depthTestEnable = VK_TRUE; ds.depthWriteEnable = VK_TRUE; ds.depthCompareOp = VK_COMPARE_OP_ALWAYS;

    VkPipelineColorBlendAttachmentState dp_cba{}; dp_cba.colorWriteMask = 0; dp_cba.blendEnable = VK_FALSE;
    VkPipelineColorBlendStateCreateInfo cb{VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO};
    cb.attachmentCount = 1; cb.pAttachments = &dp_cba;

    VkDynamicState dyns[] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
    VkPipelineDynamicStateCreateInfo dynamicInfo{VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO};
    dynamicInfo.dynamicStateCount = 2; dynamicInfo.pDynamicStates = dyns;

    VkGraphicsPipelineCreateInfo pi{VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO};
    pi.stageCount = 2; pi.pStages = stages; pi.pVertexInputState = &vi; pi.pInputAssemblyState = &ia;
    pi.pViewportState = &vp; pi.pRasterizationState = &rs; pi.pMultisampleState = &ms;
    pi.pDepthStencilState = &ds; pi.pColorBlendState = &cb; pi.pDynamicState = &dynamicInfo;
    pi.layout = depthPrimePipelineLayout; pi.renderPass = imguiRenderPass; pi.subpass = 0;

    vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pi, nullptr, &depthPrimePipeline);
    vkDestroyShaderModule(device, vsm, nullptr); vkDestroyShaderModule(device, fsm, nullptr);
}

void Renderer::createCommandPool() { VkCommandPoolCreateInfo i{VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,nullptr,VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT}; vkCreateCommandPool(device,&i,nullptr,&commandPool); }
void Renderer::createCommandBuffers() { commandBuffers.resize(swapchainImages.size()); VkCommandBufferAllocateInfo i{VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,nullptr,commandPool,VK_COMMAND_BUFFER_LEVEL_PRIMARY,(uint32_t)commandBuffers.size()}; vkAllocateCommandBuffers(device,&i,commandBuffers.data()); }
void Renderer::createSyncObjects() { imageAvailable.resize(2); renderFinished.resize(2); inFlightFences.resize(2); VkSemaphoreCreateInfo s{VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO}; VkFenceCreateInfo f{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,nullptr,VK_FENCE_CREATE_SIGNALED_BIT}; for(int i=0;i<2;i++) { vkCreateSemaphore(device,&s,nullptr,&imageAvailable[i]); vkCreateSemaphore(device,&s,nullptr,&renderFinished[i]); vkCreateFence(device,&f,nullptr,&inFlightFences[i]); } }

void Renderer::recordCommandBuffer(VkCommandBuffer cb, uint32_t i) {
    vkResetCommandBuffer(cb, 0);
    VkCommandBufferBeginInfo bi{VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; vkBeginCommandBuffer(cb, &bi);

    VkImageMemoryBarrier barriers[2] = {};
    barriers[0].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barriers[0].srcAccessMask = 0; barriers[0].dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT; barriers[0].oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; barriers[0].newLayout = VK_IMAGE_LAYOUT_GENERAL; barriers[0].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barriers[0].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barriers[0].image = swapchainImages[i]; barriers[0].subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};

    barriers[1].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barriers[1].srcAccessMask = 0; barriers[1].dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT; barriers[1].oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; barriers[1].newLayout = VK_IMAGE_LAYOUT_GENERAL; barriers[1].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barriers[1].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barriers[1].image = sdfDepthImages[i]; barriers[1].subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};

    vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 2, barriers);

    vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_COMPUTE, computePipeline);
    vkCmdBindDescriptorSets(cb, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, &descriptorSets[i], 0, nullptr);

    PushConstants pc;
    pc.resolution = { (float)swapchainExtent.width, (float)swapchainExtent.height };
    pc.time=(float)glfwGetTime();
    pc.objectCount=(int)sceneGraph.size();
    pc.selectedIndex = selectedIndices.empty() ? -1 : selectedIndices.back();
    pc.draggingAxis=(isDraggingGizmo && showGizmos)?currentGizmoAxis:0;
    pc.mode=currentMode;
    pc.uiMinX = currentUiBounds.x; pc.uiMinY = currentUiBounds.y; pc.uiMaxX = currentUiBounds.z; pc.uiMaxY = currentUiBounds.w;
    pc.shadingMode = currentShadingMode;

    vec3 center = getSelectionCenter();
    pc.gizmoPos[0] = center.x; pc.gizmoPos[1] = center.y; pc.gizmoPos[2] = center.z;

    auto updateCameraMatrix = [](float* m) {
        CameraBasis b = getCameraBasis();
        mat4 view = glm::lookAt(b.pos, b.pos + b.fwd, b.up);
        mat4 invView = glm::inverse(view);
        memcpy(m, glm::value_ptr(invView), sizeof(float) * 16);
    };
    updateCameraMatrix(pc.camToWorld);
    float fov = glm::radians(45.0f);
    pc.focalLength = 1.0f / tan(fov * 0.5f);
    vkCmdPushConstants(cb, pipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(PushConstants), &pc);
    vkCmdDispatch(cb, (swapchainExtent.width+15)/16, (swapchainExtent.height+15)/16, 1);

    VkImageMemoryBarrier barriers2[2] = {};
    barriers2[0].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barriers2[0].srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; barriers2[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; barriers2[0].oldLayout = VK_IMAGE_LAYOUT_GENERAL; barriers2[0].newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; barriers2[0].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barriers2[0].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barriers2[0].image = swapchainImages[i]; barriers2[0].subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};

    barriers2[1].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barriers2[1].srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; barriers2[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT; barriers2[1].oldLayout = VK_IMAGE_LAYOUT_GENERAL; barriers2[1].newLayout = VK_IMAGE_LAYOUT_GENERAL; barriers2[1].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barriers2[1].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barriers2[1].image = sdfDepthImages[i]; barriers2[1].subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};

    vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 2, barriers2);

    VkRenderPassBeginInfo info = {}; info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; info.renderPass = imguiRenderPass; info.framebuffer = imguiFramebuffers[i]; info.renderArea.extent = swapchainExtent;
    VkClearValue clearValues[2]; clearValues[0].color = {{0.1f, 0.1f, 0.1f, 1.0f}}; clearValues[1].depthStencil = {1.0f, 0}; info.clearValueCount = 2; info.pClearValues = clearValues;

    vkCmdBeginRenderPass(cb, &info, VK_SUBPASS_CONTENTS_INLINE);
    VkViewport viewport{0.0f, 0.0f, (float)swapchainExtent.width, (float)swapchainExtent.height, 0.0f, 1.0f}; vkCmdSetViewport(cb, 0, 1, &viewport);
    VkRect2D scissor{{0, 0}, swapchainExtent}; vkCmdSetScissor(cb, 0, 1, &scissor);

    vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, depthPrimePipeline);
    vkCmdBindDescriptorSets(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, depthPrimePipelineLayout, 0, 1, &depthPrimeSets[i], 0, nullptr);
    vkCmdDraw(cb, 3, 1, 0, 0);

    vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
    
    CameraBasis camBasis = getCameraBasis();
    mat4 view = glm::lookAt(camBasis.pos, camBasis.pos + camBasis.fwd, camBasis.up);
    mat4 proj = glm::perspective(glm::radians(45.0f), (float)swapchainExtent.width / (float)swapchainExtent.height, 0.1f, 200.0f);
    proj[1][1] *= -1; // Vulkan Y inversion

    mat4 viewProj = proj * view;
    vec4 camPos = vec4(camBasis.pos, 1.0f);

    for (int idx = 0; idx < (int)sceneGraph.size(); idx++) {
        const auto& node = sceneGraph[idx];
        if (node.meshIdx >= 0 && node.meshIdx < meshCache.size()) {
            const auto& mesh = meshCache[node.meshIdx];
            if (!mesh.isLoaded) continue;
            mat4 model = calculateWorldMatrix(idx);
            struct MeshPush { mat4 viewProj; mat4 model; vec4 color; vec4 params; vec4 camPos; } mp;
            mp.viewProj = viewProj; mp.model = model; mp.color = node.gpuData.color; mp.params = node.gpuData.params; mp.camPos = camPos;
            vkCmdPushConstants(cb, graphicsPipelineLayout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(MeshPush), &mp);
            VkDeviceSize offsets[] = {0}; vkCmdBindVertexBuffers(cb, 0, 1, &mesh.vertexBuffer.buffer, offsets);
            vkCmdBindIndexBuffer(cb, mesh.indexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32);
            vkCmdDrawIndexed(cb, mesh.indexBuffer.count, 1, 0, 0, 0);
        }
    }

    ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), cb);
    vkCmdEndRenderPass(cb);
    vkEndCommandBuffer(cb);
}

void Renderer::initImGui(GLFWwindow* window) {
    VkDescriptorPoolSize pool_sizes[] = { { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 } };
    VkDescriptorPoolCreateInfo pool_info = {}; pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; pool_info.maxSets = 1000; pool_info.poolSizeCount = 1; pool_info.pPoolSizes = pool_sizes;
    vkCreateDescriptorPool(device, &pool_info, nullptr, &imguiDescriptorPool);
    IMGUI_CHECKVERSION(); ImGui::CreateContext(); setupImGuiStyle();
    ImGui_ImplGlfw_InitForVulkan(window, true);
    ImGui_ImplVulkan_InitInfo init_info = {}; init_info.Instance = instance; init_info.PhysicalDevice = physicalDevice; init_info.Device = device; init_info.QueueFamily = 0; init_info.Queue = presentQueue; init_info.DescriptorPool = imguiDescriptorPool; init_info.MinImageCount = 2; init_info.ImageCount = (uint32_t)swapchainImages.size(); init_info.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
    ImGui_ImplVulkan_Init(&init_info, imguiRenderPass);
    VkCommandBuffer command_buffer = commandBuffers[0]; vkResetCommandBuffer(command_buffer, 0);
    VkCommandBufferBeginInfo begin_info = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
    vkBeginCommandBuffer(command_buffer, &begin_info); ImGui_ImplVulkan_CreateFontsTexture(command_buffer); vkEndCommandBuffer(command_buffer);
    VkSubmitInfo submit_info = {VK_STRUCTURE_TYPE_SUBMIT_INFO}; submit_info.commandBufferCount = 1; submit_info.pCommandBuffers = &command_buffer;
    vkQueueSubmit(computeQueue, 1, &submit_info, VK_NULL_HANDLE); vkDeviceWaitIdle(device); ImGui_ImplVulkan_DestroyFontUploadObjects();
}

void Renderer::reloadShader() { 
    std::string srcPath = findShaderSource();
    std::string binPath = getExecutableDir() + "/" + SHADER_BINARY;
    std::string cmd = "glslc \"" + srcPath + "\" -o \"" + binPath + "\"";
    int result = system(cmd.c_str()); 
    if (result == 0) { 
        vkDeviceWaitIdle(device); 
        vkDestroyPipeline(device, computePipeline, nullptr); 
        try { createPipeline(); spdlog::info("Shader reloaded"); } 
        catch(...) { spdlog::error("Failed to create pipeline after shader reload"); } 
    } else { spdlog::error("Shader compilation failed: {}", cmd); } 
}

void Renderer::cleanupSwapchain() {
    for (auto iv : sdfDepthImageViews) vkDestroyImageView(device, iv, nullptr);
    for (size_t i = 0; i < sdfDepthImages.size(); i++) {
        vmaDestroyImage(allocator, sdfDepthImages[i], sdfDepthImageAllocations[i]);
    }
    vkDestroyImageView(device, depthImageView, nullptr);
    vmaDestroyImage(allocator, depthImage, depthImageAllocation);

    for (auto iv : swapchainImageViews) vkDestroyImageView(device, iv, nullptr);
    for (auto fb : imguiFramebuffers) vkDestroyFramebuffer(device, fb, nullptr);
    vkDestroySwapchainKHR(device, swapchain, nullptr);
    vkDestroyDescriptorPool(device, descriptorPool, nullptr);
    if (depthPrimeSampler != VK_NULL_HANDLE) { vkDestroySampler(device, depthPrimeSampler, nullptr); depthPrimeSampler = VK_NULL_HANDLE; }
}

void Renderer::recreateSwapchain(GLFWwindow* window) { int width=0,height=0; glfwGetFramebufferSize(window,&width,&height); while(width==0||height==0){glfwGetFramebufferSize(window,&width,&height); glfwWaitEvents();} vkDeviceWaitIdle(device); cleanupSwapchain(); createSwapchain(window); createImageViews(); createDepthResources(); createGuiFramebuffers(); createDescriptors(); ImGui_ImplVulkan_SetMinImageCount(2); }

std::vector<uint8_t> Renderer::captureScreenshot(VkExtent2D swapchainExtent, const std::vector<VkImage>& swapchainImages) {
    vkDeviceWaitIdle(device);
    VkDeviceSize imageSize = swapchainExtent.width * swapchainExtent.height * 4;
    VkBuffer dstBuffer; VmaAllocation dstBufferAllocation;
    createBuffer(imageSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_TO_CPU, dstBuffer, dstBufferAllocation);
    VkCommandBufferAllocateInfo allocInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO};
    allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; allocInfo.commandPool = commandPool; allocInfo.commandBufferCount = 1;
    VkCommandBuffer commandBuffer; vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
    VkCommandBufferBeginInfo beginInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
    vkBeginCommandBuffer(commandBuffer, &beginInfo);
    VkImageMemoryBarrier barrier{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
    barrier.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT; barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
    barrier.oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.image = swapchainImages[0]; barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
    vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
    VkBufferImageCopy region{}; region.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}; region.imageExtent = {swapchainExtent.width, swapchainExtent.height, 1};
    vkCmdCopyImageToBuffer(commandBuffer, swapchainImages[0], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstBuffer, 1, &region);
    barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; barrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
    barrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT; barrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
    vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
    vkEndCommandBuffer(commandBuffer);
    VkSubmitInfo submitInfo{VK_STRUCTURE_TYPE_SUBMIT_INFO}; submitInfo.commandBufferCount = 1; submitInfo.pCommandBuffers = &commandBuffer;
    vkQueueSubmit(computeQueue, 1, &submitInfo, VK_NULL_HANDLE); vkQueueWaitIdle(computeQueue);
    std::vector<uint8_t> pixels(imageSize); void* data; vmaMapMemory(allocator, dstBufferAllocation, &data);
    memcpy(pixels.data(), data, (size_t)imageSize); vmaUnmapMemory(allocator, dstBufferAllocation);
    vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); 
    vmaDestroyBuffer(allocator, dstBuffer, dstBufferAllocation);
    for(size_t i = 0; i < pixels.size(); i += 4) std::swap(pixels[i], pixels[i+2]);
    return pixels;
}

void Renderer::setupInternalLogo(GLFWwindow* window) {
    auto generateLogoPixels = [](int width, int height) {
        std::vector<unsigned char> pixels(width * height * 4, 0);
        auto drawRect = [&](int x, int y, int w, int h) {
            for(int i = y; i < y + h; i++) {
                for(int j = x; j < x + w; j++) {
                    if (j >= 0 && j < width && i >= 0 && i < height) {
                        int idx = (i * width + j) * 4;
                        pixels[idx + 0] = 130; pixels[idx + 1] = 130; pixels[idx + 2] = 130; pixels[idx + 3] = 255;
                    }
                }
            }
        };
        float t = 4.8; float gap = 4.8;
        int a1_x = 10; int a1_y = 10; int a1_w = 44; int a1_h = 44;
        drawRect(a1_x, a1_y, t, a1_h); drawRect(a1_x + a1_w - t, a1_y, t, a1_h); drawRect(a1_x, a1_y, a1_w, t);
        int a2_x = a1_x + t + gap; int a2_y = a1_y + t + gap; int a2_w = a1_w - (t + gap) * 2; int a2_h = a1_h - (t + gap);
        drawRect(a2_x, a2_y, t, a2_h); drawRect(a2_x + a2_w - t, a2_y, t, a2_h); drawRect(a2_x, a2_y, a2_w, t);
        return pixels;
    };
    int w = 64, h = 64; std::vector<unsigned char> pixels = generateLogoPixels(w, h);
    GLFWimage images[1]; images[0].width = w; images[0].height = h; images[0].pixels = const_cast<unsigned char*>(pixels.data()); glfwSetWindowIcon(window, 1, images);
    createLogoTexture(pixels, w, h);
}

void Renderer::createLogoTexture(const std::vector<unsigned char>& pixels, int w, int h) {
    VkDeviceSize imageSize = w * h * 4;
    VkBuffer stagingBuffer; VmaAllocation stagingAllocation;
    createBuffer(imageSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY, stagingBuffer, stagingAllocation);
    void* data; vmaMapMemory(allocator, stagingAllocation, &data); memcpy(data, pixels.data(), static_cast<size_t>(imageSize)); vmaUnmapMemory(allocator, stagingAllocation);
    
    VkImageCreateInfo imageInfo{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
    imageInfo.imageType = VK_IMAGE_TYPE_2D; imageInfo.extent.width = w; imageInfo.extent.height = h; imageInfo.extent.depth = 1;
    imageInfo.mipLevels = 1; imageInfo.arrayLayers = 1; imageInfo.format = VK_FORMAT_R8G8B8A8_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;
    
    VmaAllocationCreateInfo allocInfo = {};
    allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
    vmaCreateImage(allocator, &imageInfo, &allocInfo, &logoImage, &logoImageAllocation, nullptr);

    VkCommandBufferAllocateInfo cmdAlloc{VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO};
    cmdAlloc.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cmdAlloc.commandPool = commandPool; cmdAlloc.commandBufferCount = 1;
    VkCommandBuffer cb; vkAllocateCommandBuffers(device, &cmdAlloc, &cb);
    VkCommandBufferBeginInfo beginInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
    vkBeginCommandBuffer(cb, &beginInfo);
    VkImageMemoryBarrier barrier{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 = logoImage; barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
    barrier.srcAccessMask = 0; barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
    vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
    VkBufferImageCopy region{}; region.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}; region.imageExtent = {static_cast<uint32_t>(w), static_cast<uint32_t>(h), 1};
    vkCmdCopyBufferToImage(cb, stagingBuffer, logoImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
    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(cb, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
    vkEndCommandBuffer(cb); VkSubmitInfo submitInfo{VK_STRUCTURE_TYPE_SUBMIT_INFO}; submitInfo.commandBufferCount = 1; submitInfo.pCommandBuffers = &cb;
    vkQueueSubmit(computeQueue, 1, &submitInfo, VK_NULL_HANDLE); vkQueueWaitIdle(computeQueue);
    vkFreeCommandBuffers(device, commandPool, 1, &cb); 
    vmaDestroyBuffer(allocator, stagingBuffer, stagingAllocation);
    
    VkImageViewCreateInfo viewInfo{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
    viewInfo.image = logoImage; viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; viewInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
    viewInfo.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
    vkCreateImageView(device, &viewInfo, nullptr, &logoImageView);
    VkSamplerCreateInfo samplerInfo{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
    samplerInfo.magFilter = VK_FILTER_LINEAR; samplerInfo.minFilter = VK_FILTER_LINEAR; samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_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.maxAnisotropy = 1.0f;
    vkCreateSampler(device, &samplerInfo, nullptr, &logoSampler);
    g_AppLogoID = ImGui_ImplVulkan_AddTexture(logoSampler, logoImageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
}