/*
 * Copyright (c) 2026 Mykhailo Mamedov. All rights reserved.
 *
 * RESEARCH PREVIEW / REFERENCE ONLY:
 * This source code is provided solely for the purpose of reviewing
 * the author's research methods and implementation.
 *
 * NO LICENSE GRANTED:
 * This code is NOT for distribution, modification, or use in any
 * project (commercial or otherwise). Unauthorized copying or
 * use of this code is strictly prohibited.
 *
 * For inquiries regarding use or licensing, contact: ua.modin@gmail.com
 * 
 * 
 * Description:
 * 
 * High-performance volumetric rendering engine-component
 * optimized for massive strand geometries (30M+ vertices). 
 * Implements hardware-accelerated ray-marching
 * and volume-image buffer based shadow casting
 * to achieve real-time visualization of dense fiber structures.
 * 
 */

#include <stdio.h>
#include <span>

#ifndef STR_COMPONENT_HEADER
#define STR_COMPONENT_HEADER

namespace M_STR {

    namespace cfg {
        inline constexpr auto SMOOTH_STRAND_COUNT = 64U;
        inline constexpr auto IS_NOT_CUBE_MAP = false;
        inline constexpr auto IS_3D_IMAGE = true;
        inline constexpr auto IS_LAYOUT_GENNERAL = true;
        inline constexpr auto UNIFORM_BUFFER_SIZE = sizeof(glm::mat4);
    }

    struct appInfo {
        VkDevice Device = NULL;
        u32 NumImages = 0;
        VK::VulkanCore* vCore;
        GLFWwindow* m_pWindow;
        size_t uniformBufferSize = 0;
        glm::ivec2 offscreenViewportSize{};
    };

    struct PushConstants {
        glm::mat4 viewProj;
        glm::vec3 gridOrigin;
        float gridExtent;
        glm::vec3 lightDir;
        float _pad;
    };

    struct PushConstantsComputeBase {
        glm::mat4 viewProj;
        glm::vec3 gridOrigin;
        float gridCellSize;
        float gridExtent;
        u32 frameCount;
        float _pad[2];
    };

    struct CurveHeader {        // Matches GLSL.
        uint32_t poolOffset;
        uint32_t pointCount;
        uint32_t maxPoints;
        uint32_t _padding;      // 16-byte alignment
        glm::vec4 color;
    };

    struct CurvePoint {
        glm::vec4 pos;          // xyz = position, w = radius
        // ...
    };

    struct StrandData { // Master CPU record.
        uint32_t slotIdx; // Reserved
        std::vector<CurvePoint> points;
        glm::vec4 color;
        uint8_t dirtyCount = 0; // Match with m_numImages to update all frames in flight.

        // Static helper to ingest initial generated data.
        static void IngestInitialPool(
            std::vector<StrandData>&targetMasterRecord,
            std::span<const CurveHeader> srcHeaders,
            std::span<const CurvePoint> srcPointPool,
            u32 imagesInFlight
        ) {
            // We assume target is already resized.
            for (uint32_t sIdx = 0; sIdx < srcHeaders.size(); ++sIdx) {
                StrandData& strandTarget = targetMasterRecord[sIdx];
                const CurveHeader& srcHeader = srcHeaders[sIdx];

                strandTarget.slotIdx = sIdx; // Initial index matches slot index
                strandTarget.color = srcHeader.color;

                // Extract points from the generated pool
                strandTarget.points.clear();
                strandTarget.points.reserve(srcHeader.pointCount);
                for (uint32_t pIdx = 0; pIdx < srcHeader.pointCount; ++pIdx) {
                    // Read the position+radius into master record.
                    strandTarget.points.push_back(srcPointPool[srcHeader.poolOffset + pIdx]);
                }
            }
        }
    };

    struct VolumetricGrid {
        glm::vec3 origin; // Min corner of the box
        glm::vec3 extent; // Size of the box
    };

    VolumetricGrid calculateGrid(const std::vector<CurvePoint>& particles) {
        glm::vec3 minBound(FLT_MAX);
        glm::vec3 maxBound(-FLT_MAX);

        for (const auto& p : particles) {
            minBound = glm::min(minBound, glm::vec3(p.pos));
            maxBound = glm::max(maxBound, glm::vec3(p.pos));
        }

        float padding = 1.0f;
        minBound -= padding;
        maxBound += padding;

        VolumetricGrid grid;
        grid.origin = minBound;
        grid.extent = maxBound - minBound;
        return grid;
    }


    class Curves {

    public:
        VK::BufferMemory m_indirectBuffer;
        std::vector<StrandData> cpuStrands;
        std::vector <VK::BufferMemory> curvePointPoolBuffer;
        std::vector <VK::BufferMemory> curveHeadersBuffer;
        std::vector<VK::BufferMemory> uniform_buffers;
        std::vector <VK::BufferMemory> curveSmoothPointsBuffer;
        std::vector<CurveHeader> curveHeaders;
        std::vector<CurvePoint> curvePointPool;
        std::vector <void*> curveHeadersBufferPtr;
        std::vector <void*> curvePointPoolBufferPtr;
        std::vector<uint32_t> freeSlots;
        std::vector<uint32_t> activeStrands;
        std::vector <VkShaderModule> shaders;

        VK::VulkanTexture shadowBuffer;
        PushConstantsComputeBase pcComp{};
        PushConstants pcDraw{};

        M_PIPE::UPipelineV1* pipe = NULL;
        M_PIPE::UPipelineV1* pipeCurvesCompute = NULL;
        M_PIPE::UPipelineV1* pipeCurvesFadeCompute = NULL;
        VkDevice m_device = NULL;
        u32 m_numImages = 0;
        GLFWwindow* m_pWindow = NULL;
        VkShaderModule m_shader_strandCompute = VK_NULL_HANDLE;
        VkShaderModule m_shader_strandFadeCompute = VK_NULL_HANDLE;
        VkShaderModule m_shader_strandVertex = VK_NULL_HANDLE;
        VkShaderModule m_shader_strandFragment = VK_NULL_HANDLE;
        VK::VulkanCore* vkCore;
        size_t m_uniformBufferSize = 0;
        // TODO: Remove.
        bool runNudges = false;
        bool hasNudges = false;
        bool nudgetAlready = false;
        u32 maxStrands = 200000;
        u32 maxStrandPoints = 100;

        Curves(appInfo& info);
        void createCVComputePipeline();
        void createShadowMapPipeline();
        void createCurveGraphicPipeline();
        void createShaders();
        void CreateIndirectBuffer();
        void createUniformBuffers();
        void RecordCommandBufferCurves(VkCommandBuffer CmdBuf, int ImageIndex);
        //void nudgeParticle(Particle* mappedVram, uint32_t index, glm::vec3 newPos);
        void generateVines(std::vector<CurveHeader>& headers, std::vector<CurvePoint>& pool, uint32_t numStrands);
        void generateClumps(std::vector<CurveHeader>& headers, std::vector<CurvePoint>& pool, uint32_t numStrands);
        void createBuffers();
        void createShadowImage();
        void createFadeShadowPipeline();
        void writeComputeBuffers(VkCommandBuffer CmdBuf, int ImageIndex, u32 currentFrame);
        void applyNudges(VkCommandBuffer CmdBuf, int ImageIndex, u32 currentFrame);
        uint32_t findEmptySlot();
        void UpdateScene(u32 currentFrame);

        ~Curves();
    };
} // namespace

#endif // STR_COMPONENT_HEADER
//
//
// --- The Implementation Section ---
#ifdef STR_COMPONENT

namespace M_STR {

    Curves::Curves(appInfo& info) {
        m_device = info.Device;
        m_numImages = info.NumImages;
        vkCore = info.vCore;
        m_pWindow = info.m_pWindow;
        m_uniformBufferSize = info.uniformBufferSize;

        u32 strandsToGen = 100000;
        curveHeaders.resize(strandsToGen);
        curvePointPool.resize(strandsToGen * maxStrandPoints);
        // generateVines(curveHeaders, curvePointPool, strandsToGen);
        generateClumps(curveHeaders, curvePointPool, strandsToGen);
        cpuStrands.resize(maxStrands);
        StrandData::IngestInitialPool(cpuStrands, curveHeaders, curvePointPool, m_numImages);
        freeSlots.clear();
        activeStrands.clear();
        for (uint32_t i = 0; i < maxStrands; ++i) {
            if (i >= curveHeaders.size()) {
                freeSlots.push_back(i);
                cpuStrands[i].points.clear();
            }
            else {
                activeStrands.push_back(i);
            }
        }

        pcComp.gridCellSize = 128.0f;
        VolumetricGrid boundingInfo = calculateGrid(curvePointPool);
        pcComp.gridOrigin = boundingInfo.origin;
        pcDraw.gridOrigin = pcComp.gridOrigin;
        pcComp.gridExtent = boundingInfo.extent.x;
        pcDraw.gridExtent = boundingInfo.extent.x;
        pcDraw.lightDir = glm::vec3(-1.0f, 0.3f, -0.02f);
        pcDraw._pad = 1.0f;

        CreateIndirectBuffer(); // Disabled for now. We need to adj draw pass after compute is finished.
        createUniformBuffers();
        createBuffers();
        createShadowImage();
        createShaders();
        createCurveGraphicPipeline(); // Graphics.
        createFadeShadowPipeline();
        createCVComputePipeline();

    }

    void Curves::generateVines(std::vector<CurveHeader>& headers, std::vector<CurvePoint>& pool, uint32_t numStrands) {
        const uint32_t maxPtsPerStrand = 100;
        const uint32_t initPtsPerStrand = 64;
        const float spacing = 0.02f;

        headers.resize(numStrands);
        pool.resize(numStrands * maxPtsPerStrand);

        std::vector<uint32_t> indices(numStrands);
        std::iota(indices.begin(), indices.end(), 0);

        std::for_each(std::execution::par, indices.begin(), indices.end(), [&](uint32_t sIdx) {
            std::mt19937 gen(sIdx);
            std::uniform_real_distribution<float> angleDist(-0.015f, 0.015f);
            std::uniform_real_distribution<float> posDist(-10.0f, 10.0f);
            std::uniform_real_distribution<float> colorDist(0.6f, 1.0f);

            headers[sIdx].poolOffset = sIdx * maxPtsPerStrand;
            headers[sIdx].pointCount = initPtsPerStrand;
            headers[sIdx].maxPoints = maxPtsPerStrand;
            headers[sIdx].color = glm::vec4(colorDist(gen), colorDist(gen), colorDist(gen), 1.0f);

            glm::vec3 currPos(posDist(gen), 0.0f, posDist(gen));
            glm::vec3 growDir(0, -1, 0);

            for (uint32_t i = 0; i < initPtsPerStrand; i++) {
                uint32_t pIdx = headers[sIdx].poolOffset + i;

                // Radius taper.
                float radius = glm::mix(0.05f, 0.05f, (float)i / 9.0f);
                pool[pIdx].pos = glm::vec4(currPos, radius);

                // Rotate growth
                glm::mat4 rot = glm::rotate(glm::mat4(1.0f), angleDist(gen), glm::vec3(1, 0, 0));
                rot = glm::rotate(rot, angleDist(gen), glm::vec3(0, 0, 1));
                growDir = glm::vec3(rot * glm::vec4(growDir, 0.0f));

                currPos += growDir * spacing;
            }
        });
    }

    void Curves::generateClumps(std::vector<CurveHeader>& headers, std::vector<CurvePoint>& pool, uint32_t numStrands) {
        const uint32_t maxPtsPerStrand = 100;
        const uint32_t initPtsPerStrand = 64;
        const float spacing = 0.007f;

        // Attractors
        const int numClumps = 3;
        glm::vec3 clumps[numClumps] = {
            glm::vec3(0, -3, 0),
            glm::vec3(2.0f, -3.2f, 1.5f) * 2.0f,
            glm::vec3(-1.5f, -3.7f, -2.0f) * 3.0f
        };

        std::vector<uint32_t> indices(numStrands);
        std::iota(indices.begin(), indices.end(), 0);

        std::for_each(std::execution::par, indices.begin(), indices.end(), [&](uint32_t sIdx) {
            std::mt19937 gen(sIdx);
            std::uniform_real_distribution<float> jitter(-1.4f, 1.4f);
            std::uniform_real_distribution<float> noise(-0.05f, 0.05f);
            std::uniform_real_distribution<float> colorDist(0.6f, 1.0f);

            // Assign this strand to one of the clumps
            glm::vec3 center = clumps[sIdx % numClumps];

            headers[sIdx].poolOffset = sIdx * maxPtsPerStrand;
            headers[sIdx].pointCount = initPtsPerStrand;
            headers[sIdx].maxPoints = maxPtsPerStrand;
            headers[sIdx].color = glm::vec4(colorDist(gen), colorDist(gen), colorDist(gen), 1.0f);

            glm::vec3 currPos = center + glm::vec3(jitter(gen), jitter(gen), jitter(gen))*2.0f;
            glm::vec3 growDir = glm::normalize(glm::cross(currPos - center, glm::vec3(0, 1, 0)));

            for (uint32_t i = 0; i < initPtsPerStrand; i++) {
                uint32_t pIdx = headers[sIdx].poolOffset + i;
                pool[pIdx].pos = glm::vec4(currPos, 0.015f);
                glm::vec3 toCenter = glm::normalize(center - currPos);
                growDir = glm::normalize(growDir + toCenter * 0.07f + glm::vec3(noise(gen)));
                currPos += growDir * spacing;
            }
        });
    }

    uint32_t Curves::findEmptySlot() {
        if (freeSlots.empty()) return UINT32_MAX;
        uint32_t slot = freeSlots.back();
        freeSlots.pop_back();
        activeStrands.push_back(slot);
        return slot;
    }

    void Curves::applyNudges(VkCommandBuffer CmdBuf, int ImageIndex, u32 currentFrame) {
        if (!runNudges)return;
        if (!nudgetAlready) {
            UpdateScene(currentFrame); // Adding a strand, nudging the rest in master buffer.
            nudgetAlready = true;
        }
        // Apply master changes to device.
        std::span<CurveHeader> gpuHeaders{ static_cast<CurveHeader*>(curveHeadersBufferPtr[ImageIndex]), maxStrands };
        std::span<CurvePoint>  gpuPoints{ static_cast<CurvePoint*>(curvePointPoolBufferPtr[ImageIndex]), maxStrands * maxStrandPoints };
        hasNudges = false;
        for (uint32_t idx : activeStrands) {
            auto& localStrandRef = cpuStrands[idx];

            if (localStrandRef.dirtyCount > 0) {
                // UPLOAD to the current buffer.
                gpuHeaders[idx].pointCount = localStrandRef.points.size();
                gpuHeaders[idx].poolOffset = idx * maxStrandPoints;
                gpuHeaders[idx].color = localStrandRef.color;
                gpuHeaders[idx].maxPoints = maxStrandPoints;

                // Update point pool for the strand.
                std::copy(localStrandRef.points.begin(), localStrandRef.points.end(), &gpuPoints[idx * maxStrandPoints]);

                // 2. One buffer is now up to date
                localStrandRef.dirtyCount--;
                hasNudges = true;
            }
        }
    }

    void Curves::createUniformBuffers() {
        assert(m_uniformBufferSize);
        uniform_buffers = vkCore->CreateUniformBuffers(m_uniformBufferSize);
    }

    void Curves::createBuffers() {
        VkResult res;
        VkBufferUsageFlags bufferUsage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
        VkMemoryPropertyFlags hostDeviceVisible = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;

        VkDeviceSize bufferSize;
        for (uint32_t i = 0; i < m_numImages; ++i) {
            VK::BufferMemory curveHeader;
            void* pBuffer = NULL;
            void* pBufferPool = NULL;

            // Buffer for structural headers.
            bufferSize = maxStrands * sizeof(CurveHeader);
            curveHeader = vkCore->CreateBuffer(
                bufferSize,
                bufferUsage,
                hostDeviceVisible,
                VK_SHARING_MODE_CONCURRENT,
                { vkCore->m_queueFamily, vkCore->m_queueFamilyCompute }
            );
            res = vkMapMemory(m_device, curveHeader.m_mem, 0, bufferSize, 0, &pBuffer);
            CHECK_VK_RESULT(res, "vkMapMemory curveHeader");
            memcpy(pBuffer, curveHeaders.data(), (size_t)curveHeaders.size() * sizeof(CurveHeader)); // The same data in each buffer.
            curveHeadersBuffer.push_back(curveHeader);
            curveHeadersBufferPtr.push_back(pBuffer);

            // Buffer for transit smooth curves to VTX.
            bufferSize = maxStrands * sizeof(glm::vec4) * cfg::SMOOTH_STRAND_COUNT;
            curveSmoothPointsBuffer.push_back(
                vkCore->CreateBuffer(
                    bufferSize,
                    bufferUsage,
                    hostDeviceVisible,
                    VK_SHARING_MODE_CONCURRENT,
                    { vkCore->m_queueFamily, vkCore->m_queueFamilyCompute }
                )
            );

            // Point pool buffer, for each frame in flight.
            bufferSize = maxStrands * maxStrandPoints * sizeof(CurvePoint);
            VK::BufferMemory curvePool;
            curvePool = vkCore->CreateBuffer(
                bufferSize,
                bufferUsage,
                hostDeviceVisible,
                VK_SHARING_MODE_CONCURRENT,
                { vkCore->m_queueFamily, vkCore->m_queueFamilyCompute }
            );
            res = vkMapMemory(m_device, curvePool.m_mem, 0, bufferSize, 0, &pBufferPool);
            CHECK_VK_RESULT(res, "vkMapMemory PointPool");
            memcpy(pBufferPool, curvePointPool.data(), (size_t)curvePointPool.size() * sizeof(CurvePoint));
            curvePointPoolBuffer.push_back(curvePool);
            curvePointPoolBufferPtr.push_back(pBufferPool); // For later updates.
        }
    }

    void Curves::createShadowImage() {

        VkResult res;
        VkFormat imageFormat = VK_FORMAT_R32_SFLOAT;
        
        vkCore->CreateImage(
            shadowBuffer,
            pcComp.gridCellSize, // Width
            pcComp.gridCellSize, // Heigh
            imageFormat,
            VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
            cfg::IS_NOT_CUBE_MAP, // Cubemap
            pcComp.gridCellSize, // Depths
            cfg::IS_3D_IMAGE, // is 3d not 2d
            VK_SHARING_MODE_CONCURRENT // Sharing mode.
        );
        vkCore->setObjectName(m_device, shadowBuffer.m_image, std::format("shadowBufferImage").c_str());

        shadowBuffer.m_view = VK::CreateImageView(
            vkCore->GetDevice(), shadowBuffer.m_image, imageFormat,
            VK_IMAGE_ASPECT_COLOR_BIT,
            cfg::IS_NOT_CUBE_MAP, // Cubemap.
            cfg::IS_3D_IMAGE // is 3d image.
        );
        vkCore->setObjectName(m_device, shadowBuffer.m_view, std::format("shadowBufferView").c_str());

        VkSamplerCreateInfo samplerInfo{};
        samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
        // Preserved from previous.
        samplerInfo.magFilter = VK_FILTER_LINEAR; // automatically blends the 8 surrounding voxels
        samplerInfo.minFilter = VK_FILTER_LINEAR; // to avoid lego bricks
        samplerInfo.anisotropyEnable = VK_FALSE;
        samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;

        // Added for light depth.
        samplerInfo.compareEnable = VK_FALSE;
        samplerInfo.compareOp = VK_COMPARE_OP_LESS;
        samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
        samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
        samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
        samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
        samplerInfo.minLod = 0.0f;
        samplerInfo.maxLod = 1.0f;
        res = vkCreateSampler(vkCore->GetDevice(), &samplerInfo, nullptr, &shadowBuffer.m_sampler);
        CHECK_VK_RESULT(res, "vkCreateSampler");
        vkCore->setObjectName(m_device, shadowBuffer.m_sampler, std::format("shadowBufferSampler").c_str());
    }

    void Curves::CreateIndirectBuffer() {
        std::vector<VkDrawIndirectCommand> DrawCommands(1);
        VkDrawIndirectCommand cmd = {
            .vertexCount = cfg::SMOOTH_STRAND_COUNT,
            .instanceCount = maxStrands,
            .firstVertex = 0,
            .firstInstance = 0
        };
        DrawCommands[0] = cmd;
        m_indirectBuffer = vkCore->CreateIndirectBuffer(
            DrawCommands.data(),
            ARRAY_SIZE_IN_BYTES(DrawCommands)
        );
    }

    void Curves::createShaders() {  // TODO: Refactor.
        m_shader_strandCompute = VK::CreateShaderModuleFromText(m_device, "strandsBase.comp");
        m_shader_strandFadeCompute = VK::CreateShaderModuleFromText(m_device, "strandsFade.comp");
        m_shader_strandVertex = VK::CreateShaderModuleFromText(m_device, "crv.vert");
        m_shader_strandFragment = VK::CreateShaderModuleFromText(m_device, "crv.frag");
        shaders.push_back(m_shader_strandCompute);
        shaders.push_back(m_shader_strandFadeCompute);
        shaders.push_back(m_shader_strandVertex);
        shaders.push_back(m_shader_strandFragment);
        vkCore->setObjectName(m_device, m_shader_strandCompute, std::format("m_shader_strandCompute").c_str());
        vkCore->setObjectName(m_device, m_shader_strandFadeCompute, std::format("m_shader_strandFadeCompute").c_str());
        vkCore->setObjectName(m_device, m_shader_strandVertex, std::format("m_shader_strandVertex").c_str());
        vkCore->setObjectName(m_device, m_shader_strandFragment, std::format("m_shader_strandFragment").c_str());
    }

    void Curves::createCurveGraphicPipeline() {
        M_PIPE::PipelineDescU1 pipeInfo{};
        pipeInfo.Device = m_device;
        pipeInfo.vertex_shader = m_shader_strandVertex;
        pipeInfo.fragment_shader = m_shader_strandFragment;
        pipeInfo.numImages = m_numImages;
        pipeInfo.pushSize = sizeof(pcDraw);

        std::vector<VkBuffer> smoothBuffers;
        for (VK::BufferMemory compound : curveSmoothPointsBuffer) {
            smoothBuffers.push_back(compound.m_buffer);
        }
        std::vector<VkBuffer> headBuffers;
        for (VK::BufferMemory compound : curveHeadersBuffer) {
            headBuffers.push_back(compound.m_buffer);
        }

        M_PIPE::BindingInfo smoothPointsBinding{
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
            .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
            .multiBuffer = smoothBuffers,  // Transit to graphics pipe.
            .hasCustomBinding = true,
            .hasSingleBufferPerSet = true,
            .bindingOverride = 0
        };

        M_PIPE::BindingInfo headersBinding{
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
            .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
            .multiBuffer = headBuffers,  // Curve heads.
            .hasCustomBinding = true,
            .hasSingleBufferPerSet = true,
            .bindingOverride = 1
        };

        M_PIPE::BindingInfo shadowBinding{
            .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
            .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
            .samplers = {shadowBuffer.m_sampler},
            .imageViews = {shadowBuffer.m_view},
            .imageLayoutInit = VK_IMAGE_LAYOUT_GENERAL,
            .hasCustomBinding = true,
            .bindingOverride = 2
        };

        pipeInfo.bindings.push_back(smoothPointsBinding);
        pipeInfo.bindings.push_back(headersBinding);
        pipeInfo.bindings.push_back(shadowBinding);

        std::vector<VkFormat> colorFormats;
        colorFormats.push_back(vkCore->GetSwapChainFormat());
        pipeInfo.prim_topology = VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
        pipeInfo.colorAttachmentFormats = colorFormats;
        pipeInfo.depthAttachmentFormat = vkCore->GetDepthFormat();
        pipeInfo.hasDynamicState = true;
        pipeInfo.pWindow = m_pWindow;
        pipeInfo.hasViewport = true;
        pipeInfo.hasRendering = true;
        pipeInfo.hasRasterization = true;
        pipeInfo.nameId = "strandGraphicsPipeline";
        pipeInfo.pCore = vkCore;
        pipe = new M_PIPE::UPipelineV1(pipeInfo);
    }

    void Curves::createFadeShadowPipeline() {
        M_PIPE::PipelineDescU1 pipe_info{};
        pipe_info.Device = m_device;
        pipe_info.numImages = m_numImages;
        {
            M_PIPE::BindingInfo shadowImageBinding{
                .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
                .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
                .imageViews = {shadowBuffer.m_view},
                .imageLayoutInit = VK_IMAGE_LAYOUT_GENERAL,
                .hasCustomBinding = true,
                .bindingOverride = 0
            };
            pipe_info.bindings.push_back(shadowImageBinding);
        }
        pipe_info.compute_shader = m_shader_strandFadeCompute;
        pipe_info.isCompute = true;
        pipe_info.nameId = "curvesComputeFadePipeline";
        pipe_info.pCore = vkCore;
        pipeCurvesFadeCompute = new M_PIPE::UPipelineV1(pipe_info);
    }

    void Curves::writeComputeBuffers(VkCommandBuffer CmdBuf, int ImageIndex, u32 currentFrame) {

        if (currentFrame == 0) {
            M_TOOLS::Sync()
                .image(shadowBuffer.m_image,
                    VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, // From nothing to General
                    VK_PIPELINE_STAGE_2_NONE, 0,                        // Source: Nothing
                    VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, VK_ACCESS_2_MEMORY_WRITE_BIT) // Ready for use
                .apply(CmdBuf);
        }

        M_TOOLS::Sync()
            .image(shadowBuffer.m_image,
                VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
                VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, VK_ACCESS_2_SHADER_READ_BIT,      // srcMask, srcAccess
                VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT)   // dstMask, dstAccess
            .apply(CmdBuf);

        // Shadow fade.
        pipeCurvesFadeCompute->Bind(CmdBuf);
        pipeCurvesFadeCompute->bindDescriptorSets(CmdBuf, ImageIndex);
        vkCmdDispatch(CmdBuf, 16, 16, 16); // TODO: link size.

        if (hasNudges) {
            // Push vk buffer changes to device.
            M_TOOLS::Sync()
                .buffer(curveHeadersBuffer[ImageIndex].m_buffer,
                    VK_PIPELINE_STAGE_2_HOST_BIT, VK_ACCESS_2_HOST_WRITE_BIT,               // Source: CPU
                    VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT)    // Dest: GPU
                .buffer(curvePointPoolBuffer[ImageIndex].m_buffer,
                    VK_PIPELINE_STAGE_2_HOST_BIT, VK_ACCESS_2_HOST_WRITE_BIT,
                    VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT)
                .apply(CmdBuf);
        }

        // Compute catmullRom + shadows
        pipeCurvesCompute->Bind(CmdBuf);
        pipeCurvesCompute->bindDescriptorSets(CmdBuf, ImageIndex);
        pipeCurvesCompute->PushConstants(CmdBuf, sizeof(pcComp), &pcComp);
        vkCmdPushConstants(
            CmdBuf,															// VkCommandBuffer commandBuffer
            pipeCurvesCompute->GetPipelineLayout(),					        // VkPipelineLayout layout
            VK_SHADER_STAGE_COMPUTE_BIT,									// VkShaderStageFlags stageFlags
            0,																// offset
            sizeof(pcComp),										            // size
            &pcComp
        );

        vkCmdDispatch(CmdBuf, maxStrands, 1, 1);

        // hand off shadow and renderable curves to render pipes.
        M_TOOLS::Sync()
            .image(shadowBuffer.m_image,
                VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
                VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT,       // srcMask, srcAccess
                VK_PIPELINE_STAGE_2_NONE, VK_ACCESS_2_NONE)                                 // dstMask, dstAccess
            .buffer(curveSmoothPointsBuffer[ImageIndex].m_buffer,
                VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT,       // srcMask, srcAccess
                VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, VK_ACCESS_2_SHADER_STORAGE_READ_BIT)  // dstMask, dstAccess
            .apply(CmdBuf);
        // Note: Don't use NONE mask/access, it would only silence validation.
    }

    void Curves::createCVComputePipeline() {
        M_PIPE::PipelineDescU1 pipe_info{};
        pipe_info.Device = m_device;
        pipe_info.numImages = m_numImages;

        std::vector<VkBuffer> smoothBuffers; // TODO: move in pipeline.
        for (VK::BufferMemory compound : curveSmoothPointsBuffer) {
            smoothBuffers.push_back(compound.m_buffer);
        }
        std::vector<VkBuffer> headBuffers;
        for (VK::BufferMemory compound : curveHeadersBuffer) {
            headBuffers.push_back(compound.m_buffer);
        }

        std::vector<VkBuffer> poolBuffers;
        for (VK::BufferMemory compound : curvePointPoolBuffer) {
            poolBuffers.push_back(compound.m_buffer);
        }

        {
            M_PIPE::BindingInfo headersBinding{
                .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
                .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
                .multiBuffer = headBuffers,
                .hasCustomBinding = true,
                .hasSingleBufferPerSet = true,
                .bindingOverride = 0
            };
            pipe_info.bindings.push_back(headersBinding);

            M_PIPE::BindingInfo pointPoolBinding{
                .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
                .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
                .multiBuffer = poolBuffers,  // Point-pool for compute only.
                .hasCustomBinding = true,
                .hasSingleBufferPerSet = true,
                .bindingOverride = 1
            };
            pipe_info.bindings.push_back(pointPoolBinding);

            M_PIPE::BindingInfo smoothPointsBinding{
                .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
                .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
                .multiBuffer = smoothBuffers,  // Transit to graphics pipe.
                .hasCustomBinding = true,
                .hasSingleBufferPerSet = true,
                .bindingOverride = 2
            };
            pipe_info.bindings.push_back(smoothPointsBinding);

            M_PIPE::BindingInfo shadowImageBinding{
                .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
                .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
                .imageViews = {shadowBuffer.m_view},
                .imageLayoutInit = VK_IMAGE_LAYOUT_GENERAL,
                .hasCustomBinding = true,
                .bindingOverride = 3
            };
            pipe_info.bindings.push_back(shadowImageBinding);
        }
        pipe_info.pushSize = sizeof(PushConstantsComputeBase);
        pipe_info.compute_shader = m_shader_strandCompute;
        pipe_info.isCompute = true;
        pipe_info.nameId = "curvesComputePipeline";
        pipe_info.pCore = vkCore;
        pipeCurvesCompute = new M_PIPE::UPipelineV1(pipe_info);
    }

    void Curves::RecordCommandBufferCurves(VkCommandBuffer CmdBuf, int ImageIndex) {
        vkCore->pfnVkCmdSetPolygonModeEXT(CmdBuf, VkPolygonMode::VK_POLYGON_MODE_FILL);
        vkCore->pfnVkCmdSetPrimitiveTopologyEXT(CmdBuf, VK_PRIMITIVE_TOPOLOGY_POINT_LIST);
        pipe->Bind(CmdBuf);
        pipe->PushConstants(CmdBuf, sizeof(pcDraw), &pcDraw);
        pipe->bindDescriptorSets(CmdBuf, ImageIndex);
        vkCmdDrawIndirect(CmdBuf,
            m_indirectBuffer.m_buffer,
            0,      // offset inside the indirect buffer            
            (u32)1, // number of VkDrawIndirectCommand elements
            sizeof(VkDrawIndirectCommand));
    }

    Curves::~Curves() {
        vkDeviceWaitIdle(m_device);

        for (auto& buffer : uniform_buffers) {
            buffer.Destroy(m_device);
        }

        for (auto shaderModule : shaders) {
            vkDestroyShaderModule(m_device, shaderModule, NULL);
        }

        for (auto buff : curveHeadersBuffer) {
            vkUnmapMemory(m_device, buff.m_mem);
            buff.Destroy(m_device);
        }
        for (auto buff : curveSmoothPointsBuffer) {
            buff.Destroy(m_device);
        }
        m_indirectBuffer.Destroy(m_device);

        for (auto buff : curvePointPoolBuffer) {
            vkUnmapMemory(m_device, buff.m_mem);
            buff.Destroy(m_device);
        }

        shadowBuffer.Destroy(m_device);

        delete pipe;
        delete pipeCurvesCompute;
        delete pipeCurvesFadeCompute;

    }

} // namespace

#endif
// --- The Implementation Section End ---