dl_vk.h

浏览该文件的文档.

#pragma once
 
#ifndef DL_DISABLE_RENDER
#include <optional>
#include <vector>
#include <unordered_map>
 
#include "system/dl_platform.h"
 
#if (DL_PLATFORM != DL_PLATFORM_ANDROID)
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#else
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_android.h>
#include "system/dl_android.h"
#endif
 
#if DL_PLATFORM == DL_PLATFORM_APPLE
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_beta.h>
#endif
 
#include "io/dl_log.h"
#include "math/dl_matrix.h"
#include "render/dl_sprite.h"
#include "base/dl_type_user.h"
#include "memory/dl_buffer.h"
#include "vk/dl_vertex.h"
#include "render/dl_image.h"
#include "render/dl_model.h"
#include "base/dl_color.h"
#include "render/dl_model_object.h"
#include "render/dl_camera.h"
#include "render/dl_render_def.h"
#include "render/dl_light.h"
#include "base/dl_vector_reuse.h"
#include "base/dl_object_pool.h"
#include "io/dl_thread_task.h"
 
namespace dl
{
 
//交换链支持细节
struct SwapChainSupportDetails
{
    VkSurfaceCapabilitiesKHR _capabilities;
    std::vector<VkSurfaceFormatKHR> _formats;
    std::vector<VkPresentModeKHR> _presentModes;
};
 
//
struct Texture
{
    VkImage _image;                           // 纹理图像
    VkDeviceMemory _memory;              // 纹理图像内存
    VkImageView _imageView;                   // 纹理图像视图
    // 以下不保证填充
    uint32_t _mipLevel;                                // mipmap数（和图像大小有关）
    uint32_t _width;                              // 宽，仅2d管线的纹理填充
    uint32_t _height;                                // 高，仅2d管线的纹理填充
 
    Texture() :
        _image{ VK_NULL_HANDLE },
        _memory{ VK_NULL_HANDLE },
        _imageView{ VK_NULL_HANDLE },
        _mipLevel{ 0 },
        _width{ 0 },
        _height{ 0 }
    {}
 
    bool IsVaild()
    {
        return _image != VK_NULL_HANDLE;
    }
 
    void Delete(VkDevice device)
    {
        vkDestroyImageView(device, _imageView, nullptr);
        vkDestroyImage(device, _image, nullptr);
        vkFreeMemory(device, _memory, nullptr);
 
        _image = VK_NULL_HANDLE;
    }
};
 
// 最大图元数
constexpr size_t NUM_MAX_PRIMITIVE = 1024;
// 最大材质数（ubMaterial）
constexpr size_t NUM_MAX_MATERIAL = 256;
// 最大骨骼实例（ubBone）
constexpr size_t NUM_MAX_BONE = 128;
// 单个实例最大骨骼数（ubBone[96]）与shader一致
constexpr size_t NUM_MAX_JOINT = 256;
// 平行光数量 与shader一致
constexpr size_t NUM_MAX_LIGHT_DIR = 3;
// 点光源数量 与shader一致
constexpr size_t NUM_MAX_LIGHT_DOT = 10;
// 聚光灯数量 与shader一致
constexpr size_t NUM_MAX_LIGHT_SPOT = 3;
// 灯光数量
constexpr size_t NUM_MAX_LIGHT = NUM_MAX_LIGHT_DIR + NUM_MAX_LIGHT_DOT + NUM_MAX_LIGHT_SPOT;
// csm级数
constexpr size_t NUM_SHADOW_CASCADE = 4;
// csm贴图大小
constexpr uint32_t SIZE_SHADOW_IMAGE = 2048;
// csm贴图格式
constexpr VkFormat FORMAT_SHADOW_IMAGE = VK_FORMAT_D32_SFLOAT;
 
 
 
// 最大drawcall数（2d）
constexpr size_t NUM_MAX_DRAW_CALL_2D = 100;
// 最大精灵数
constexpr size_t NUM_MAX_2D_SPRITE = 402400;
// 单个drawcall索引数（2d）
constexpr size_t NUM_2D_INDEX = 6 * NUM_MAX_2D_SPRITE;
// 初始Canvas顶点数
constexpr size_t NUM_START_2D_VERTEX = 4 * 1024;
// 最大根坐标系数（2d的cbo数）
constexpr size_t NUM_MAX_ROOT_COOR = 32;
// 2d纹理空闲时间后自动释放（毫秒）
constexpr unsigned TIME_FREE_TEXTURE_2D = 60 * 1000;
// 2d采样器数量
constexpr size_t NUM_2D_SAMPLER = 3;
 
// 样本着色（更高级的多重采样，基本不会使用）
constexpr bool OPEN_SAMPLE_SHADING = false;
// 线框模式（很多设备不支持）
constexpr bool OPEN_FILL_MODE_NON_SOLID = false;
 
// 验证层
#ifdef NDEBUG
constexpr bool ENABLE_VALIDATION_LAYERS = false;
#else
// linux开启验证层有问题
#if (DL_PLATFORM == DL_PLATFORM_WIN32)
constexpr bool ENABLE_VALIDATION_LAYERS = true;// obs注入时有问题
#else
constexpr bool ENABLE_VALIDATION_LAYERS = false;
#endif
 
#endif
 
// 最大演员实例数量
constexpr size_t NUM_MAX_ACTOR = 10240;
 
// gfx顶点数（默认，会自动扩容）
constexpr size_t NUM_GFX_VERTEX = 1024;
 
// gfx定义（请勿修改）
constexpr size_t INDEX_GFX_3D_NORMAL_DOT = 0;
constexpr size_t INDEX_GFX_3D_NORMAL_LINE = 1;
constexpr size_t INDEX_GFX_3D_NORMAL_TRIANGLE = 2;
constexpr size_t INDEX_GFX_2D_NORMAL_DOT = 3;
constexpr size_t INDEX_GFX_2D_NORMAL_LINE = 4;
constexpr size_t INDEX_GFX_2D_NORMAL_TRIANGLE = 5;
constexpr size_t INDEX_GFX_3D_TRANS_DOT = 6;
constexpr size_t INDEX_GFX_3D_TRANS_LINE = 7;
constexpr size_t INDEX_GFX_3D_TRANS_TRIANGLE = 8;
constexpr size_t INDEX_GFX_2D_TRANS_DOT = 9;
constexpr size_t INDEX_GFX_2D_TRANS_LINE = 10;
constexpr size_t INDEX_GFX_2D_TRANS_TRIANGLE = 11;
constexpr size_t NUM_GFX = 12;
constexpr size_t NUM_GFX_HALF = 6;
constexpr size_t NUM_GFX_QUAD = 3;
 
// 持久映射2d ubo（效率似乎差不多）
constexpr bool USE_MAPPED_2D_UBO = false;
 
// 交换链表面格式
constexpr VkFormat DL_VK_FORMAT_SURFACE = VK_FORMAT_B8G8R8A8_SRGB;
constexpr VkFormat DL_VK_FORMAT_SRGB = VK_FORMAT_B8G8R8A8_SRGB;
constexpr VkFormat DL_VK_FORMAT_UNORM = VK_FORMAT_B8G8R8A8_UNORM;
constexpr VkFormat DL_VK_FORMAT_SRGB_TEXTURE = VK_FORMAT_R8G8B8A8_SRGB;
constexpr VkFormat DL_VK_FORMAT_UNORM_TEXTURE = VK_FORMAT_R8G8B8A8_UNORM;

class VK
{
public:
    struct alignas(16) UbObject
    {
        Matrix4 _proj;
        Matrix4 _view;
        Position3 _camPos;
        float _pad;
    };
    // push const 至少支持128
    struct PushConstantData
    {
        Matrix4 _model;
        Color _color;
    }; 
    static_assert(sizeof(PushConstantData) <= 128);
    // 阴影
    struct alignas(16) UbCSM
    {
        std::array<Matrix4, NUM_SHADOW_CASCADE> _viewProj;
    };
    struct PushConstantCSM
    {
        Matrix4 _model;
        uint32_t _cascadeIndex;
    };
    static_assert(sizeof(PushConstantCSM) <= 128);
    // 骨骼
    struct alignas(16) UboBone
    {
        Matrix4 _trans[NUM_MAX_JOINT];
    };
 
    // 图元，单次draw call，多个实例共享的
    //（变换和骨骼动画是实例化的，不放这里）
    struct Primitive
    {
        size_t _idMaterial;
        size_t _idTexDiffuse;
        size_t _idTexPhysical;
        size_t _idTexNormal;
        size_t _idTexAo;
        size_t _idTexEmissive;
    };
 
    struct Canvas
    {
        Texture _texture;        // 【带锁】当前使用纹理
        Texture _textureFast;    // 【带锁】创建full后，旧的fast纹理存这里
        unsigned _tkcUsed;      // 使用时间戳
        unsigned _textureState; // 0.不需要动态加载 1.使用的小图 2.加载中 3.待更新描述符 4.使用的大图
        std::mutex _mutex;
 
        std::string _pathTextureFull; // 为空表示本身就是使用的full纹理
        std::vector<VkBuffer> _vertexBuffer;           // 顶点缓冲（每帧改变）
        std::vector<VkDeviceMemory> _vertexBufferMemory;// 顶点缓冲内存
        std::vector<VkDeviceSize> _vertexBufferSize;   // 顶点缓冲大小
 
        std::vector<Sprite*> _allSprite;
        std::vector<Sprite*> _allSpriteTrans;
 
        size_t _id;
        std::vector<size_t> _numVertex;
 
        Canvas(VK* vk) :
            _tkcUsed{ 0 },
            _textureState{ 0 }
        {
            _vertexBuffer.resize(vk->_countFrame);
            _vertexBufferMemory.resize(vk->_countFrame);
            _vertexBufferSize.resize(vk->_countFrame);
            _numVertex.resize(vk->_countFrame);
        }
 
        void TryRelase(VK* vk, unsigned tkc)
        {
            if (_textureState != 4)
                return;
 
            bool clear = _tkcUsed && tkc > _tkcUsed + TIME_FREE_TEXTURE_2D;
            if (!clear)
                return;
 
            // 尝试锁住纹理
            if (!_mutex.try_lock())
                return;
            vkDeviceWaitIdle(vk->GetDevice());
            // 释放大图
            _texture.Delete(vk->GetDevice());
            // 切换至小图
            _texture = _textureFast;
            _textureFast = Texture{};
            // 更新描述符
            vk->UpdateCanvasDescriptor(this);
            _mutex.unlock();
            _textureState = 1;
            log_msg("Canvas纹理释放：{}", _pathTextureFull);
        }
 
        void TryLoad(VK* vk)
        {
            if (_textureState == 1)
            {
                _textureState = 2;
                TextureManager::TaskLoad task;
                task._idCanvas = _id;
                vk->_textureMgr._mtt.AddTask(task);
            }
            else if (_textureState == 3)
            {
                vkDeviceWaitIdle(vk->GetDevice());
                vk->UpdateCanvasDescriptor(this);
                _textureState = 4;
                log_msg("Canvas纹理加载：{}", _pathTextureFull);
            }
        }
 
        // 【多线程调用】
        void RealLoad(VK* vk)
        {
            assert(_textureState == 2);
            Texture tex;
            vk->_create_texture_ktx(_pathTextureFull, tex);
            _mutex.lock();
            _textureFast =_texture;
            _texture = tex;
            _mutex.unlock();
            _textureState = 3;
        }
 
 
        void Delete(VkDevice device)
        {
            _mutex.lock();
            _texture.Delete(device);
            if (_textureFast.IsVaild())
                _textureFast.Delete(device);
            _mutex.unlock();
 
            for (size_t i = 0; i < _vertexBuffer.size(); ++i)
            {
                vkDestroyBuffer(device, _vertexBuffer[i], nullptr);
                vkFreeMemory(device, _vertexBufferMemory[i], nullptr);
            }
        }
    };
 
    using Viewport = Array<float, 4>;
    // 2dDrawCall 按 以下优先级排序拆分（每一项都不同产生拆分，所以跨Canvas必然产生拆分）
    // 1.半透明最后（放入单独的list处理）
    // 2.Canvas（顶点 + 纹理）
    // 3.矩阵
    // 4.视口
    // 5.裁剪
    // 6.采样器
    // 7.混合
    struct DrawCall
    {
        Canvas* _canvas;
        Coor* _rootCoor;
        Viewport* _viewport;
        Rect* _scissorRect;
        Sprite::Sampler _sampler;
        Sprite::Blend _blend;
 
        // 现修改为顶点位置
        size_t _beg;
        size_t _end;
 
        bool operator==(const DrawCall& b) const
        {
            return _canvas == b._canvas
                && _rootCoor == b._rootCoor
                && _viewport == b._viewport
                && _scissorRect == b._scissorRect
                && _sampler == b._sampler
                && _blend == b._blend;
        }
    };
    // dc和它拥有的sprite
    struct DrawCallList
    {
        DrawCall _dc;
        std::vector<Sprite*> _listSpr;
        bool operator==(const DrawCallList& b)
        {
            return _dc == b._dc;
        }
    };
    // 按z排序
    struct DrawCallZ
    {
        float _z;
        DrawCallList _dcl;
        bool operator==(const DrawCallZ& b)
        {
            return _z == b._z
                && _dcl == b._dcl;
        }
    };
 
    struct VK2D
    {
        struct UBO
        {
            alignas(16) Matrix4 _viewProj;
        };
 
        struct CBO
        {
            alignas(16) Matrix4 _model;
            uint32_t _samplerIndex;
        };
 
 
        VkPipelineLayout _pipelineLayout;                //  管线布局
        VkPipeline _graphicsPipeline;                  //  图形管线（无半透明）
        VkPipeline _graphicsPipelineTrans;                //  图形管线（alpha混合）
        VkPipeline _graphicsPipelineEffect;              //  图形管线（特效混合）
        VkPipeline _graphicsPipelineGray;              //  图形管线（灰度绘制）
        VkDescriptorSetLayout _descriptorSetLayout0;   //  描述符集合布局（全局）
        VkDescriptorSetLayout _descriptorSetLayout1;   //  描述符集合布局
        std::vector<VkBuffer> _uniformBuffers;               // 统一缓冲
        std::vector<VkDeviceMemory> _uniformBuffersMemory; // 统一缓冲内存
        std::vector<void*> _uniformBuffersMapped;  // 统一缓冲映射
        VkDescriptorPool _descriptorPool;                // 描述符池
        std::vector<VkDescriptorSet> _descriptorSets0;  // 所有描述符集
        std::vector<VkDescriptorSet> _descriptorSets1;  // 所有描述符集
        VkBuffer _indexBuffer;                          // 索引缓冲（注意是32位）
        VkDeviceMemory _indexBufferMemory;                // 索引缓冲内存
        VkSampler _textureSampler;                       // 2d纹理采样器
        VkSampler _textureSamplerPixel;                 // 2d纹理采样器
        VkSampler _textureSamplerUI;                   // 2d纹理采样器
        std::array<CBO, NUM_MAX_ROOT_COOR> _allCBO;      // 常量缓冲
        size_t _curPushConstant;                        // 当前使用 常量缓冲 下标
        std::array<Coor*, NUM_MAX_ROOT_COOR> _allRootCoor;  // 所有根坐标系
        std::array<Matrix4, NUM_MAX_ROOT_COOR> _allRootCoorMat;  // 所有根坐标系矩阵
        Matrix4 _mat2D;                                    // 2d世界坐标系
        std::unordered_map<size_t, Canvas*> _allCanvas;   // 画布（RenderTarget + 静态 + Register精灵）
        RenderInfo2D _renderInfo;                        // 绘制信息
        //------------------------缓存区域（避免每帧重分配内存）-----------------------
        std::vector<VK::DrawCall> _vecDc;
        std::vector<VK::DrawCall> _vecDcTrans;
        VectorReuse<DrawCallList> _vecDcList;
        VectorReuse<DrawCallZ> _vecDcListZ;
        DrawCallZ _tempDcListZ;
    };
 
    struct VertexBufferGfx
    {
        struct Frame
        {
            VkBuffer _vertexBuffer;                        // 顶点缓冲（每帧改变）
            VkDeviceMemory _vertexBufferMemory;          // 顶点缓冲内存
            VkDeviceSize _vertexBufferSize;                // 顶点缓冲大小
 
            VertexGfx* _vertex;
            std::size_t _index;
            std::size_t _num;
 
            Frame() :
                _vertex{ nullptr },
                _index{ 0 },
                _num{ 0 }
            {}
 
            void Lock(VkDevice device)
            {
                vkMapMemory(device, _vertexBufferMemory, 0, _vertexBufferSize, 0, (void**)&_vertex);
            }
            void Unlock(VkDevice device)
            {
                _vertex = nullptr;
                vkUnmapMemory(device, _vertexBufferMemory);
            }
            void Delete(VkDevice device)
            {
                vkDestroyBuffer(device, _vertexBuffer, nullptr);
                vkFreeMemory(device, _vertexBufferMemory, nullptr);
            }
        };
        
        std::vector<Frame> _frame;
 
        void Init(VK* vk)
        {
            _frame.resize(vk->_countFrame);
        }
 
        Frame& operator[](size_t i)
        {
            return _frame[i];
        }
        
        void Delete(VkDevice device)
        {
            for (size_t i = 0; i < _frame.size(); ++i)
            {
                _frame[i].Delete(device);
            }
        }
    };
 
 
    struct VKGfx
    {
        struct UBO
        {
            Matrix4 _viewProj;
        };
        VkPipelineLayout _pipelineLayout;                //管线布局
        // 3d和2d共用管线，但透明度需要区分
        // 点、线、三角形（半透明x2)
        std::array<VkPipeline, NUM_GFX_HALF> _vecGraphicsPipeline;// 图形管线
        // uniform为 帧数 * 2 （3d，2d 各一个）
        VkDescriptorSetLayout _descriptorSetLayout;     //描述符集合布局
        std::vector<VkBuffer> _uniformBuffers;               //统一缓冲
        std::vector<VkDeviceMemory> _uniformBuffersMemory; //统一缓冲内存
        VkDescriptorPool _descriptorPool;                //描述符池
        std::vector<VkDescriptorSet> _descriptorSets;    //所有描述符集
 
        // 点、线、三角形、2d点、2d线、2d三角形（半透明x2)
        std::array<VertexBufferGfx, NUM_GFX> _arrVB;
        // CPU写入缓冲区
        std::array<std::vector<VertexGfx>, NUM_GFX> _allVertex;
    };
 
    // 渲染目标（3d默认具有0下标）
    struct VKRenderTarget
    {
        Texture _texColor;
        Texture _texDepth;
        Texture _texColorOut; // 由Canvas释放
        VkFramebuffer _frameBuffer;
 
        void Delete(VkDevice device)
        {
            vkDestroyFramebuffer(device, _frameBuffer, nullptr);
            _texColor.Delete(device);
            _texDepth.Delete(device);
        }
    };
 
    VK(GLFWwindow* window) :
        _currentFrame{ 0 },
        _bFrameBufferResize{ false },
        _textureMgr{ this }
    {
        _allValidationLayer =
        {
            "VK_LAYER_KHRONOS_validation"
        };
        _allDeviceExtension =
        {
            VK_KHR_SWAPCHAIN_EXTENSION_NAME
        };
#if DL_PLATFORM == DL_PLATFORM_APPLE
        _allDeviceExtension.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
#endif
 
        _init(window);
    }

    VkShaderModule CreateShaderModule(Buffer& buf);

    void Update();

    void Render(GLFWwindow* window);

    void RenderEnd()
    {
        _curPushConstant = 1;
    }

    void SetFrameBufferResize() { _bFrameBufferResize = true; }

    static VKAPI_ATTR VkBool32 VKAPI_CALL CallbackDebug(
        VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
        VkDebugUtilsMessageTypeFlagsEXT messageType,
        const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
        void* pUserData)
    {
        if (messageSeverity == VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT)
            log_test0(pCallbackData->pMessage);
        else if (messageSeverity == VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)
            log_info0(pCallbackData->pMessage);
 
        return VK_FALSE;
    }

    static VkResult CreateDebugUtilsMessengerEXT(VkInstance instance,
        const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
        const VkAllocationCallbacks* pAllocator,
        VkDebugUtilsMessengerEXT* pDebugMessenger)
    {
        auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
        if (func != nullptr)
            return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
        else
            return VK_ERROR_EXTENSION_NOT_PRESENT;
    }

    static void DestroyDebugUtilsMessengerEXT(VkInstance instance,
        VkDebugUtilsMessengerEXT debugMessenger,
        const VkAllocationCallbacks* pAllocator)
    {
        auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
        if (func != nullptr)
            func(instance, debugMessenger, pAllocator);
    }

    void PopulateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo);
    uint32_t FindMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties);
    bool CreateBuffer(VkDeviceSize size,
        VkBufferUsageFlags usage, VkMemoryPropertyFlags properties,
        VkBuffer& buffer, VkDeviceMemory& bufferMemory);
    void CopyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size);
    void CopyBufferToImage(VkBuffer buffer, VkImage image, 
        uint32_t width, uint32_t height, uint32_t mip_level);
    void CopyBufferToImageMulti(
        const std::array<VkBuffer, NUM_MIPMAP_2D>& vec_buffer,
        VkImage image, const std::array<Size, NUM_MIPMAP_2D>& vec_size);
    
    template <typename T>
    void CreateVertexBufferGPU(const std::vector<T>& vertices,
        VkBuffer& vertexBuffer,
        VkDeviceMemory& vertexBufferMemory)
    {
        VkDeviceSize bufferSize = sizeof(T) * vertices.size();
 
        VkBuffer stagingBuffer;
        VkDeviceMemory stagingBufferMemory;
        CreateBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
            stagingBuffer, stagingBufferMemory);
 
        void* data;
        vkMapMemory(_device, stagingBufferMemory, 0, bufferSize, 0, &data);
        memcpy(data, vertices.data(), (size_t)bufferSize);
        vkUnmapMemory(_device, stagingBufferMemory);
 
        CreateBuffer(bufferSize,
            VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
            vertexBuffer, vertexBufferMemory);
 
        CopyBuffer(stagingBuffer, vertexBuffer, bufferSize);
 
        vkDestroyBuffer(_device, stagingBuffer, nullptr);
        vkFreeMemory(_device, stagingBufferMemory, nullptr);
    }

    template <typename T>
    bool CreateVertexBufferCPU(size_t vertex_num,
        VkBuffer& vertexBuffer, VkDeviceMemory& vertexBufferMemory, VkDeviceSize& bufferSize)
    {
        bufferSize = sizeof(T) * vertex_num;
        return CreateBuffer(bufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
            vertexBuffer, vertexBufferMemory);
 
        //映射内存
        /*void* data;
        vkMapMemory(_device, vertexBufferMemory, 0, bufferSize, 0, &data);
        memcpy(data, vertices.data(), (size_t)bufferSize);
        vkUnmapMemory(_device, vertexBufferMemory);*/
    }

    template<typename T>
    void CreateIndexBuffer(const std::vector<T>& indices, VkBuffer& indexBuffer, VkDeviceMemory& indexBufferMemory)
    {
        VkDeviceSize bufferSize = sizeof(T) * indices.size();
 
        VkBuffer stagingBuffer;
        VkDeviceMemory stagingBufferMemory;
        CreateBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
            stagingBuffer, stagingBufferMemory);
 
        void* data;
        vkMapMemory(_device, stagingBufferMemory, 0, bufferSize, 0, &data);
        memcpy(data, indices.data(), (size_t)bufferSize);
        vkUnmapMemory(_device, stagingBufferMemory);
 
        CreateBuffer(bufferSize,
            VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
            indexBuffer, indexBufferMemory);
 
        CopyBuffer(stagingBuffer, indexBuffer, bufferSize);
 
        vkDestroyBuffer(_device, stagingBuffer, nullptr);
        vkFreeMemory(_device, stagingBufferMemory, nullptr);
    }

    void CreateImage(uint32_t w, uint32_t h, uint32_t mip_level, VkSampleCountFlagBits numSamples,
        VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties,
        VkImage& image, VkDeviceMemory& imageMemory, uint32_t layers = 1);

    VkImageView CreateImageView(VkImage image, VkFormat format,
        VkImageAspectFlags aspectFlags, uint32_t mip_level);

    VkCommandBuffer BeginSingleTimeCommands();
    void EndSingleTimeCommands(VkCommandBuffer commandBuffer);
    void TransitionImageLayout(VkImage image, VkFormat format,
        VkImageLayout oldLayout, VkImageLayout newLayout, uint32_t mip_level);
    VkFormat FindSupportedFormat(const std::vector<VkFormat>& candidates,
        VkImageTiling tiling, VkFormatFeatureFlags features);

    VkFormat FindDepthFormat();
    bool HasStencilComponent(VkFormat format)
    {
        return format == VK_FORMAT_D32_SFLOAT_S8_UINT || format == VK_FORMAT_D24_UNORM_S8_UINT;
    }
 
    VkDevice GetDevice() { return _device; }

    size_t CreateMaterial(Material& m)
    {
        for (size_t i = 0; i < _allMaterial.size(); ++i)
        {
            if (_allMaterial[i] == m)
                return i;
        }
        size_t id = _allMaterial.size();
        if (id >= NUM_MAX_MATERIAL)
        {
            log_warn("材质数超过上限！");
            return 0;
        }
        void* data;
        vkMapMemory(_device, _ubMaterialMemory[id], 0, sizeof(m), 0, &data);
        memcpy(data, &m, sizeof(m));
        vkUnmapMemory(_device, _ubMaterialMemory[id]);
 
        _allMaterial.push_back(m);
        return id;
    }

    size_t CreatePrimitive(ModelMaterial& m);
 

    Model* CreateModel(ModelObject* object);
    void RenderModel(VkCommandBuffer command_buffer, Model* model, size_t shadow);
    void DeleteModel(Model* model)
    {
        if (!model)
            return;
        vkDestroyBuffer(_device, model->_indexBuffer, nullptr);
        vkFreeMemory(_device, model->_indexBufferMemory, nullptr);
 
        vkDestroyBuffer(_device, model->_vertexBuffer, nullptr);
        vkFreeMemory(_device, model->_vertexBufferMemory, nullptr);
 
        delete model;
    }

    size_t GetPushConstantNext()
    {
        return _curPushConstant++;
    }

    PushConstantData* GetPushConstant(size_t id)
    {
        if (id >= _allPushConstant.size())
        {
            log(fmt::format("超过 推送常量区上限：{}", _allPushConstant.size()));
            return nullptr;
        }
        return &_allPushConstant[id];
    }

    void UpdateUboBone(size_t id, std::vector<Matrix4>& trans)
    {
        if (trans.empty())
            return;
        size_t size = sizeof(Matrix4) * (std::min)(trans.size(), NUM_MAX_JOINT);
        size_t index = id * _countFrame + _currentFrame;
 
        void* data;
        vkMapMemory(_device, _ubBoneMemory[index], 0, size, 0, &data);
        memcpy(data, trans.data(), size);
        vkUnmapMemory(_device, _ubBoneMemory[index]);
    }

    size_t GetUboBoneFree()
    {
        for (size_t i = 0; i < _mapBoneUse.size(); ++i)
        {
            if (!_mapBoneUse[i])
                return i;
        }
        log("无可用骨骼ub！");
        return -1;
    }

    void SetUboBoneFree(size_t id)
    {
        assert(_mapBoneUse[id]);
        _mapBoneUse[id] = false;
    }

    void SetUboBoneUse(size_t id)
    {
        assert(!_mapBoneUse[id]);
        _mapBoneUse[id] = true;
    }
 
    void SetDebugView(DebugView3D type)
    {
        _pass._debugView = (float)type;
    }
    DebugView3D GetDebugView()
    {
        return (DebugView3D)_pass._debugView;
    }

    size_t CreateTextureReal(Image* image, bool srgb, bool delete_image);

    size_t CreateTexture(std::string_view path_name, bool srgb = true);
 

    // 初始使用fast_tex，后续动态加载完整tex
    void CreateCanvas(size_t id, Texture tex, std::string_view path_tex_full);
    void CreateCanvasImage(size_t tex_id, const std::array<Image*, NUM_MIPMAP_2D>& vec_image);
    void CreateCanvasImageKtx(size_t tex_id, std::string_view path_name, std::string_view path_tex_full);
    void CreateCanvasRenderTarget(size_t rt_id, VKRenderTarget& rt);
 
    void UpdateCanvasRenderTarget(size_t rt_id, VKRenderTarget& rt);
 
    // 需要canvas【加锁】 只能主线程调用
    void UpdateCanvasDescriptor(Canvas* canvas);
 
    Canvas* GetCanvas(size_t id);
    Canvas* GetCanvasByTexture(size_t tex_id);
    Canvas* GetCanvasByRenderTarget(size_t rt_id);
 
    size_t GetCanvasSize()
    {
        return _2d._allCanvas.size();
    }

    Texture CreateTexture2D(const std::array<Image*, NUM_MIPMAP_2D>& vec_image);

    // 仅更新2d的动态纹理
    // 必须通过暂存缓冲更新
    void UpdateTexture2D(Texture tex, const PointU& xy, Image* image, const RectU& rect);
 
    //！导出交换链图像
    void ScreenShot(std::string_view path_name);
 
    //！导出图像
    void ExportTexture(Texture tex, std::string_view path_name);
 
    void ExportTextureCanvas(std::string_view path);

    void GenerateMipmaps(VkImage image, VkFormat imageFormat, int32_t texWidth, int32_t texHeight, uint32_t mipLevels);

    VkSampleCountFlagBits GetMaxUsableSampleCount();

    size_t LoadSkybox(std::string_view path);
    void SetSkybox(size_t i);
 
 
    //
    bool CreateRenderTargetReal(size_t i, VKRenderTarget& rt);
    size_t CreateRenderTarget();

    const RenderInfo2D& GetRenderInfo2D()
    {
        return _2d._renderInfo;
    }
 
    const RenderInfo3D& GetRenderInfo3D()
    {
        return _renderInfo;
    }

    Camera* GetCamera()
    {
        return _camera;
    }

    void Release()
    {
        vkDeviceWaitIdle(_device);
        _release_swap_chain();
    }
 
    ~VK();
private:
 
    VkInstance _instance;                               // vk实例
    std::vector<VkExtensionProperties> _allExtension;   // 所有扩展，返回获得
    std::vector<VkLayerProperties> _allLayer;           // 所有层，返回获得
    std::vector<const char*> _allValidationLayer;       // 验证层，手动设置
    VkPhysicalDevice _physicalDevice;                   // 所选物理设备
    std::vector<VkPhysicalDevice> _allPhysicalDevice;   // 所有物理设备
    VkDevice _device;                                   // 逻辑设备
    VkQueue _graphicsQueue;                             // 图形队列
    VkSurfaceKHR _surface;                              // 窗口表面
    VkQueue _presentQueue;                              // 呈现队列
    std::vector<const char*> _allDeviceExtension;       // 物理设备所需扩展，手动设置
    VkSwapchainKHR _swapChain;                          // 交换链
    uint32_t _countFrame;                               // 交换链 frame数
    std::vector<VkImage> _allImageSwapChain;            // 交换链图像
    VkFormat _formatSwapChainImage;                     // 交换链图像格式
    VkExtent2D _extentSwapChain;                        // 交换链范围
    std::vector<VkImageView> _allImageViewSwapChain;    // 交换链图像视图
    VkRenderPass _renderPass3D;                         // 3d渲染流程
    VkRenderPass _renderPass2D;                         // 2d渲染流程
    VkPipelineLayout _pipelineLayout;                   // 管线布局
    VkPipelineLayout _pipelineLayoutBone;               // 管线布局（骨骼动画）
    VkPipeline _graphicsPipeline;                       // 图形管线
    VkPipeline _graphicsPipelineBone;                   // 图形管线（骨骼动画）
    std::vector<VkFramebuffer> _allFrameBufferSwapChain;// 交换链帧缓冲区
    VkCommandPool _commandPool;                         // 命令池
    std::vector<VkCommandBuffer> _allCommandBuffer;     // 命令缓冲区（依赖于命令池，自动释放）
    std::vector<VkSemaphore> _allSemaphoreImageAvailable;// 同步对象（交换链图像可用）
    std::vector<VkSemaphore> _allSemaphoreRenderFinished;// 同步对象（绘制完成）
    std::vector<VkFence> _allFenceInFlight;              // 同步对象（绘制过程）
    VkCommandPool _commandPoolUpload;                   // 命令池（上传）
    VkQueue _transferQueue;                             // 传输队列
    uint32_t _currentFrame;                         //当前帧
    bool _bFrameBufferResize;                       //帧缓冲大小发生变化
    VkDebugUtilsMessengerEXT _debugMessenger;       //调试信使
    VkDescriptorSetLayout _descriptorSetLayout;     //描述符集合布局
    VkDescriptorSetLayout _descriptorSetLayoutTex;  //描述符集合布局（纹理贴图）
    VkDescriptorSetLayout _descriptorSetLayoutBone; //描述符集合布局（骨骼动画）
    std::vector<VkBuffer> _uniformBuffers;              //统一缓冲
    std::vector<VkDeviceMemory> _uniformBuffersMemory;  //统一缓冲内存
    VkDescriptorPool _descriptorPool;               //描述符池
    std::vector<VkDescriptorSet> _descriptorSets;       // 描述符集（ubo、matrial、pass、cascade、ibl、brdf）
    std::vector<VkDescriptorSet> _descriptorSetsTex;    // 描述符集（纹理）
    std::vector<VkDescriptorSet> _descriptorSetsBone;   // 描述符集（带骨骼动画）
    VkSampler _standardSampler;                     // 纹理采样器（标准）
    VkSampler _pointSampler;                        // 纹理采样器（physical、mask）
    VkImage _depthImage;                            //深度图像
    VkDeviceMemory _depthImageMemory;               //深度图像内存
    VkImageView _depthImageView;                    //深度图像视图
    std::array<PushConstantData, NUM_MAX_ACTOR> _allPushConstant;//常量缓冲
    size_t _curPushConstant;                        //当前使用 常量缓冲 下标
    Camera* _camera;                              //当前摄像机（设置vp矩阵）
    Camera _cameraDefault;                            //默认相机
    std::vector<Texture> _allTexture3D;                 //3d使用的所有贴图
    std::unordered_map<std::string, size_t> _mapPath2Texture;   //文件路径 -> 纹理下标
    std::vector<VkBuffer> _ubMaterial;                  // 材质缓冲
    std::vector<VkDeviceMemory> _ubMaterialMemory;      // 材质缓冲内存
    std::vector<VkBuffer> _ubPass;                  // 通用缓冲
    std::vector<VkDeviceMemory> _ubPassMemory;      // 通用缓冲内存
    std::vector<Material> _allMaterial;                 // 所有已添加材质（计数和避免重复）
    std::vector<VkBuffer> _ubBone;                      // 骨骼ub
    std::vector<VkDeviceMemory> _ubBoneMemory;          // 骨骼ub内存
    std::vector<bool> _mapBoneUse;                      // 骨骼ub使用表
    std::vector<Primitive> _allPrimitive;               // 所有图元
    VkImage _colorImage;                                // 离屏图像
    VkDeviceMemory _colorImageMemory;                   // 离屏图像内存
    VkImageView _colorImageView;                        // 离屏图像视图
    std::vector<VKRenderTarget> _allRenderTarget;       // 所有rt，0为默认3d渲染使用 
    
    struct TextureManager
    {
        struct TaskLoad
        {
            size_t _idCanvas;
        };
 
        MultiThreadTask<TaskLoad> _mtt;
        TextureManager(VK* vk) 
        {
            _mtt.Init([vk](TaskLoad& task) {
                Canvas* canvas = vk->GetCanvas(task._idCanvas);
                canvas->RealLoad(vk);
                }, 1);
        }
    };
    TextureManager _textureMgr;
    //---------------------灯光数据（每帧重建）----------------------------
    std::vector<LightDir> _allLightDir;
    std::vector<LightDot> _allLightDot;
    std::vector<LightSpot> _allLightSpot;
    UbPass _pass;
 
    // 天空盒
    struct Skybox
    {
        VkPipelineLayout _pipelineLayout;               // 管线布局
        VkPipeline _graphicsPipeline;                   // 图形管线
        VkDescriptorSetLayout _descriptorSetLayout;     // 描述符布局
        std::vector<VkDescriptorSet> _descriptorSets;   // 描述符集
        VkBuffer _vertexBuffer;                 // 顶点缓冲（每帧改变）
        VkDeviceMemory _vertexBufferMemory;     // 顶点缓冲内存
        VkDeviceSize _vertexBufferSize;         // 顶点缓冲大小
        VkBuffer _indexBuffer;                  // 顶点缓冲（每帧改变）
        VkDeviceMemory _indexBufferMemory;      // 顶点缓冲内存
 
        VkSampler _envSampler;          // env 采样器
        VkSampler _iblSampler;          // ibl 采样器
        VkSampler _brdfSampler;         // brdf 采样器
 
        Texture _texBrdf;               // brdf
 
        struct Instance
        {
            Texture _texEnv;          // env cube
            Texture _texIbl;          // ibl cube
            std::array<Position4, 9> _sh;  // 球谐环境光
        };
        std::vector<Instance> _vec;
        size_t _current;
    };
    Skybox _skybox;
 
    // 阴影
    struct Shadow
    {
        VkRenderPass _renderPass;
        VkDescriptorSetLayout _descriptorSetLayout;     // 描述符布局 set0
        std::vector<VkDescriptorSet> _descriptorSets;   // 描述符集（ubo）
        VkPipelineLayout _layout;
        VkPipeline _pipeline;
        VkPipeline _pipelineBone;
        VkSampler _sampler;         // 采样器
        Texture _tex;
 
        std::vector<VkBuffer> _ubCsmBuffer;
        std::vector<VkDeviceMemory> _ubCsmMemory;
 
        struct Cascade
        {
            VkImageView _imageView;
            VkFramebuffer _frameBuffer;
        };
        std::vector<Cascade> _cascade;
    };
    Shadow _shadow;
    
    RenderInfo3D _renderInfo;
 
    // 图元在描述符的实际下标如下：
    //index = _idPrimitive * NUM_MAX_FRAME_IN_FLIGHT + _currentFrame;
    VK2D _2d;                                       //2d管线
    VKGfx _gfx;                                        // gfx管线
    std::vector<std::vector<Model*>> _allMulModel;// 3d可绘制实例
 
    void _init(GLFWwindow* window);
    // 检查拓展支持数
    void _check_extension();
    // 返回需要的扩展（根据验证层）
    std::vector<const char*> _get_required_extensions();
    // 创建实例
    void _create_instance();
    // 创建验证层
    void _check_layer();
    // 检查调试层支持
    bool _check_validation_layer();
 
    //开启调试信使
    void _create_debug_messenger()
    {
        if (!ENABLE_VALIDATION_LAYERS)
            return;
        VkDebugUtilsMessengerCreateInfoEXT createInfo;
        PopulateDebugMessengerCreateInfo(createInfo);
 
        if (CreateDebugUtilsMessengerEXT(_instance, &createInfo,
            nullptr, &_debugMessenger) != VK_SUCCESS)
        {
            log_err0("开启调试信使失败！");
            return;
        }
    }
 
    // 创建物理设备
    void _create_physical_device();
 
    // 检查物理设备是否可用
    bool _is_device_suitable(VkPhysicalDevice device);
    // 检查物理设备扩展支持
    bool _check_device_extension(VkPhysicalDevice device);
    // 物理设备返回队列族 0.通用 1.传输
    bool _find_queue_families(VkPhysicalDevice device, uint32_t& index, int type = 0);
 
    // 创建逻辑设备
    void _create_logical_device();
    // 创建窗口表面
    void _create_surface(GLFWwindow* window);
 
    // 返回交换链支持细节
    SwapChainSupportDetails _query_swap_chain_support(VkPhysicalDevice device);
    // 选择交换链合适的表面格式
    VkSurfaceFormatKHR _choose_swap_surface_format(const std::vector<VkSurfaceFormatKHR>& availableFormats);
    // 选择交换链合适的呈现模式
    VkPresentModeKHR _choose_swap_present_mode(const std::vector<VkPresentModeKHR>& availablePresentModes);
 
    // 选择交换链分辨率
    VkExtent2D _choose_swap_extent(const VkSurfaceCapabilitiesKHR& capabilities,
        GLFWwindow* window);
 
    // 创建交换链
    void _create_swap_chain(GLFWwindow* window);
    // 创建交换链图像视图
    void _create_image_view();
 
    // 创建绘图流程
    void _create_render_pass();
    // 创建图形管道
    void _create_pipeline_layout_3d();
    void _create_pipeline_layout_skybox();
 
    //-------------------骨骼动画-----------------
    void _create_descriptor_set_layout_bone();//布局
    void _create_pipeline_layout_bone();//管线
    void _create_uniform_bone();//统一缓冲
 
    void _create_ibl();
 
    // 从ktx创建纹理
    void _create_texture_ktx(std::string_view path, Texture& tex);
 
    // 创建交换链帧缓冲区
    void _create_frame_buffer();
 
    // 创建命令池
    void _create_command_pool();
    // 创建命令缓冲区
    void _create_command_buffer();
 
    // 创建同步对象
    void _create_sync_objects();
     
    // 上传队列
    void _create_command_upload();
    // 记录命令
    void _record_command_buffer(VkCommandBuffer command_buffer, uint32_t index_image);
public:
    // 重建交换链
    void _rebuild_swap_chain(GLFWwindow* window);
 
    void _render_light(const LightDir& l)
    {
        _allLightDir.push_back(l);
    }
    void _render_light(const LightDot& l)
    {
        _allLightDot.push_back(l);
    }
    void _render_light(const LightSpot& l)
    {
        _allLightSpot.push_back(l);
    }
private:
    //释放交换链相关资源
    void _release_swap_chain();
 
 
    //创建描述符布局（管线依赖）
    void _create_descriptor_set_layout();
    void _create_descriptor_set_layout_texture();
 
    //创建统一缓冲
    void _create_uniform_buffers();
 
    //更新统一缓冲
    void _update_uniform_buffer();
    void _update_uniform_light();
 
    // 创建描述符池
    void _create_descriptor_pool();
 
    // 创建描述符集
    void _create_descriptor_sets();
 
    // 创建纹理采样器
    void _create_texture_sampler();
    // 创建深度缓存资源
    void _create_depth_resources();
    // 创建msaa资源
    void _create_color_resources();
 
 
    //2d管线
    void _create_2d();
    void _delete_2d();
 
    // gfx管线
    void _create_gfx();
    void _delete_gfx();
 
    // skybox管线
    void _create_skybox();
    void _delete_skybox();
    void _create_descriptor_set_layout_skybox();
 
 
    // shadow管线
    void _create_shadow();
    void _delete_shadow();
    void _create_render_pass_shadow();
 
    VkPipelineLayout _create_pipline_layout_shadow();
 
    VkPipeline _create_graphics_pipeline_shadow(
        std::string_view vs, std::string_view ps,
        VkVertexInputBindingDescription* bind_desc, VkVertexInputAttributeDescription* attr_desc,
        size_t num_attr, VkPipelineLayout layout);
    void _create_descriptor_set_layout_shadow();
 
    bool _check_gfx_vertex(VertexBufferGfx::Frame& f_old);
 
    //------------------------------管线-------------------------------------
 
    void _create_pipeline_all();
    void _delete_pipeline_all();
 
    void _create_pipeline_gfx();
    void _create_pipeline_2d();
    void _create_pipeline_3d();
    void _create_pipeline_bone();
    void _create_pipeline_skybox();
    void _create_pipeline_shadow();
public:
    // 动态参数
    struct RenderParam
    {
        VkSampleCountFlagBits _msaaLevel;
 
    }_param;
 
    uint32_t GetCurrentFrame()
    {
        return _currentFrame;
    }
 
    void GfxPushDot(const VertexGfx& v)
    {
        bool opaque = isColorOpaque(v._color);
        auto& vec = _gfx._allVertex[0 + !opaque * NUM_GFX_HALF];
        vec.push_back(v);
    }
    void GfxPushLine(const VertexGfx& v0, const VertexGfx& v1)
    {
        bool opaque = isColorOpaque(v0._color) && isColorOpaque(v1._color);
        auto& vec = _gfx._allVertex[1 + !opaque * NUM_GFX_HALF];
        vec.push_back(v0);
        vec.push_back(v1);
    }
    void GfxPushTriangle(const VertexGfx& v0, const VertexGfx& v1, const VertexGfx& v2)
    {
        bool opaque = isColorOpaque(v0._color) && isColorOpaque(v1._color) && isColorOpaque(v2._color);
        auto& vec = _gfx._allVertex[2 + !opaque * NUM_GFX_HALF];
        vec.push_back(v0);
        vec.push_back(v1);
        vec.push_back(v2);
    }
    void GfxPushDot2D(const VertexGfx& v)
    {
        bool opaque = isColorOpaque(v._color);
        auto& vec = _gfx._allVertex[0 + !opaque * NUM_GFX_HALF + NUM_GFX_QUAD];
        vec.push_back(v);
    }
    void GfxPushLine2D(const VertexGfx& v0, const VertexGfx& v1)
    {
        bool opaque = isColorOpaque(v0._color) && isColorOpaque(v1._color);
        auto& vec = _gfx._allVertex[1 + !opaque * NUM_GFX_HALF + NUM_GFX_QUAD];
        vec.push_back(v0);
        vec.push_back(v1);
    }
    void GfxPushTriangle2D(const VertexGfx& v0, const VertexGfx& v1, const VertexGfx& v2)
    {
        bool opaque = isColorOpaque(v0._color) && isColorOpaque(v1._color) && isColorOpaque(v2._color);
        auto& vec = _gfx._allVertex[2 + !opaque * NUM_GFX_HALF + NUM_GFX_QUAD];
        vec.push_back(v0);
        vec.push_back(v1);
        vec.push_back(v2);
    }
 
    Coor* GetRootCoor(size_t index);
 
    size_t GetMulModelSize() { return _allMulModel.size(); }
    std::vector<Model*>& GetMulModel(size_t i)
    {
        return _allMulModel[i];
    }
    void AddMulModel(std::vector<Model*>& vec)
    {
        _allMulModel.push_back(vec);
    }
};
 
extern VK* g_vk;
 
}
 
 
#endif