Some vk ext

MaxwellGengYF · MaxwellGengYF · commit f78631b10f44 · 2025-08-03T11:48:54.000+08:00
diff --git a/include/luisa/backends/ext/native_resource_ext_interface.h b/include/luisa/backends/ext/native_resource_ext_interface.h
@@ -19,10 +19,8 @@ class Swapchain;
 
 class NativeResourceExt : public DeviceExtension {
 
-private:
-    DeviceInterface *_device;
-
 protected:
+    DeviceInterface *_device;
     ~NativeResourceExt() noexcept = default;
 
 public:
diff --git a/src/backends/dx/DXApi/ext.cpp b/src/backends/dx/DXApi/ext.cpp
@@ -88,7 +88,7 @@ BufferCreationInfo DxNativeResourceExt::register_external_buffer(
     auto res = static_cast<Buffer *>(new ExternalBuffer(
         dx_device,
         reinterpret_cast<ID3D12Resource *>(external_ptr),
-        *reinterpret_cast<D3D12_RESOURCE_STATES const *>(custom_data)));
+        custom_data ? *reinterpret_cast<D3D12_RESOURCE_STATES const *>(custom_data) : D3D12_RESOURCE_STATE_COMMON));
     BufferCreationInfo info;
     info.handle = resource_to_handle(res);
     info.native_handle = res->GetResource();
@@ -104,22 +104,22 @@ ResourceCreationInfo DxNativeResourceExt::register_external_image(
     void *custom_data) noexcept {
     auto desc = reinterpret_cast<NativeTextureDesc const *>(custom_data);
     GFXFormat gfxFormat;
-    if (desc->custom_format == DXGI_FORMAT_UNKNOWN) {
+    if (!desc || desc->custom_format == DXGI_FORMAT_UNKNOWN) {
         gfxFormat = TextureBase::ToGFXFormat(format);
     } else {
         gfxFormat = static_cast<GFXFormat>(desc->custom_format);
     }
     auto res = static_cast<TextureBase *>(new ExternalTexture(
         dx_device,
         reinterpret_cast<ID3D12Resource *>(external_ptr),
-        desc->initState,
+        desc ? desc->initState : D3D12_RESOURCE_STATE_COMMON,
         width,
         height,
         gfxFormat,
         (TextureDimension)dimension,
         depth,
         mipmap_levels,
-        desc->allowUav));
+        desc ? desc->allowUav : true));
     return {
         reinterpret_cast<uint64_t>(res),
         external_ptr};
diff --git a/src/backends/vk/buffer.h b/src/backends/vk/buffer.h
@@ -24,6 +24,18 @@ class Buffer : public Resource {
     uint64_t get_device_address() const;
     virtual bool flush_host() const { return false; }
 };
+class ExternalBuffer : public Buffer {
+    VkBuffer _buffer{};
+
+public:
+    ExternalBuffer(Device *device, VkBuffer vk_buffer, size_t size_bytes)
+        : Buffer{device, size_bytes},
+          _buffer(vk_buffer) {
+    }
+    ExternalBuffer(ExternalBuffer &&rhs) = default;
+    ~ExternalBuffer() = default;
+    VkBuffer vk_buffer() const override { return _buffer; }
+};
 class BufferView {
 public:
     Buffer const *buffer;
diff --git a/src/backends/vk/device.cpp b/src/backends/vk/device.cpp
@@ -22,6 +22,7 @@
 #include "sparse_buffer.h"
 #include "pinned_memory_ext.h"
 #include "vk_raster_ext.h"
+#include "vk_native_res_ext.h"
 #include <luisa/backends/ext/raster_ext_interface.h>
 namespace lc::vk {
 static constexpr uint k_shader_model = 65u;
@@ -363,6 +364,18 @@ Device::Device(Context &&ctx_arg, DeviceConfig const *configs)
         [](DeviceExtension *ext) {
             delete static_cast<VkRasterExt *>(ext);
         });
+    exts.try_emplace(
+#ifdef LUISA_USE_SYSTEM_STL
+        luisa::string{NativeResourceExt::name},
+#else
+        NativeResourceExt::name,
+#endif
+        [](Device *device) -> DeviceExtension * {
+            return new VkNativeResourceExt(device);
+        },
+        [](DeviceExtension *ext) {
+            delete static_cast<VkNativeResourceExt *>(ext);
+        });
     // auto exts = detail::supported_exts(physical_device());
     // for(auto&& i : exts){
     //     LUISA_INFO("{}", i.extensionName);
@@ -728,7 +741,7 @@ BufferCreationInfo Device::create_buffer(const Type *element, size_t elem_count,
 }
 BufferCreationInfo Device::create_buffer(const ir::CArc<ir::Type> *element, size_t elem_count, void *external_ptr) noexcept { return BufferCreationInfo::make_invalid(); }
 void Device::destroy_buffer(uint64_t handle) noexcept {
-    delete reinterpret_cast<DefaultBuffer *>(handle);
+    delete reinterpret_cast<Buffer *>(handle);
 }
 
 // texture
diff --git a/src/backends/vk/texture.cpp b/src/backends/vk/texture.cpp
@@ -6,6 +6,24 @@ using namespace luisa::compute;
 Texture::Texture(Device *device)
     : Resource(device) {
 }
+Texture::Texture(
+    Device *device,
+    VkImage external_image,
+    uint dimension,
+    VkFormat format,
+    uint3 size,
+    uint mip,
+    bool simultaneous_access)
+    : Resource(device),
+      _img(external_image),
+      _format(
+          static_cast<compute::PixelFormat>(static_cast<uint>(format) | (1u << 31u))),
+      _size(size),
+      _mip(mip),
+      _dimension(dimension),
+      _contained{false},
+      _simultaneous_access(simultaneous_access) {}
+
 Texture::Texture(
     Device *device,
     uint dimension,
@@ -43,7 +61,7 @@ Texture::Texture(
 Texture::~Texture() {
     if (_img.allocation)
         device()->allocator().destroy_image(_img);
-    else
+    else if (_contained)
         vkDestroyImage(device()->logic_device(), _img.image, Device::alloc_callbacks());
 }
 
@@ -122,8 +140,12 @@ uint3 Texture::tex3d_tile_size(luisa::compute::PixelStorage storage) {
 }
 
 VkFormat Texture::to_vk_format(PixelFormat format) {
+    // native format
+    if ((luisa::to_underlying(format) & (1u << 31u)) != 0) {
+        return static_cast<VkFormat>(luisa::to_underlying(format) & ((1u << 31u) - 1u));
+    }
     // depth
-    if (luisa::to_underlying(format) > 65535u) {
+    else if (luisa::to_underlying(format) > 65535u) {
         auto depth_format = static_cast<compute::DepthFormat>(luisa::to_underlying(format) & 65535u);
         switch (depth_format) {
             case compute::DepthFormat::D16:
diff --git a/src/backends/vk/texture.h b/src/backends/vk/texture.h
@@ -11,13 +11,23 @@ class Texture : public Resource {
     uint3 _size;
     uint _mip;
     uint _dimension;
-    bool _simultaneous_access;
+    bool _contained : 1 {true};
+    bool _simultaneous_access : 1;
     mutable luisa::spin_mutex _layout_mtx;
     mutable vstd::vector<VkImageLayout> _layouts;
 public:
     auto simultaneous_access() const { return _simultaneous_access; }
     auto dimension() const { return _dimension; }
     Texture(Device *device);
+    // external
+    Texture(
+        Device *device,
+        VkImage external_image,
+        uint dimension,
+        VkFormat format,
+        uint3 size,
+        uint mip,
+        bool simultaneous_access);
     Texture(
         Device *device,
         uint dimension,
@@ -36,7 +46,7 @@ class Texture : public Resource {
     static uint2 tex2d_tile_size(luisa::compute::PixelStorage storage);
     static uint3 tex3d_tile_size(luisa::compute::PixelStorage storage);
     uint3 tile_size() const {
-        if (luisa::to_underlying(_format) > 65535u) return {}; // depth
+        if (luisa::to_underlying(_format) > 65535u) return {};// depth
         if (_dimension <= 2) {
             return make_uint3(tex2d_tile_size(luisa::compute::pixel_format_to_storage(_format)), 1);
         } else {
@@ -47,8 +57,8 @@ class Texture : public Resource {
 
     auto mip() const { return _mip; }
     auto vk_image() const { return _img.image; }
-    auto format() const { 
-        if (luisa::to_underlying(_format) > 65535u) return static_cast<compute::PixelFormat>(-1); // depth
+    auto format() const {
+        if (luisa::to_underlying(_format) > 65535u) return static_cast<compute::PixelFormat>(-1);// depth
         return _format;
     }
     auto depth_format() const {
diff --git a/src/backends/vk/vk_native_res_ext.cpp b/src/backends/vk/vk_native_res_ext.cpp
@@ -0,0 +1,76 @@
+#include "vk_native_res_ext.h"
+#include "buffer.h"
+#include "texture.h"
+#include "device.h"
+namespace lc::vk {
+VkNativeResourceExt::VkNativeResourceExt(Device *device) : NativeResourceExt(device) {}
+BufferCreationInfo VkNativeResourceExt::register_external_buffer(
+    void *buffer_ptr,
+    const Type *element,
+    size_t elem_count,
+    // custom data see backends' header
+    void *custom_data) noexcept {
+    size_t elem_size = (element == Type::of<void>()) ? 1 : element->size();
+    size_t size = elem_size * elem_count;
+    BufferCreationInfo info;
+    info.handle = reinterpret_cast<uint64_t>(new ExternalBuffer(
+        static_cast<Device *>(_device),
+        static_cast<VkBuffer>(buffer_ptr),
+        size));
+    info.native_handle = buffer_ptr;
+    info.element_stride = elem_size;
+    info.total_size_bytes = size;
+    return info;
+}
+ResourceCreationInfo VkNativeResourceExt::register_external_image(
+    void *image_ptr,
+    PixelFormat format, uint dimension,
+    uint width, uint height, uint depth,
+    uint mipmap_levels,
+    // custom data see backends' header
+    void *custom_data) noexcept {
+    VkFormat vk_format = custom_data ? *static_cast<VkFormat *>(custom_data) : Texture::to_vk_format(format);
+    auto tex = new Texture(
+        static_cast<Device *>(_device),
+        static_cast<VkImage>(image_ptr),
+        dimension,
+        vk_format,
+        uint3(width, height, depth),
+        mipmap_levels,
+        false);
+    ResourceCreationInfo info{
+        .handle = reinterpret_cast<uint64_t>(tex),
+        .native_handle = image_ptr};
+    return info;
+}
+
+ResourceCreationInfo VkNativeResourceExt::register_external_depth_buffer(
+    void *depth_buffer_ptr,
+    DepthFormat format,
+    uint width,
+    uint height,
+    // custom data see backends' header
+    void *custom_data) noexcept {
+    // TODO
+    return ResourceCreationInfo::make_invalid();
+}
+
+SwapchainCreationInfo VkNativeResourceExt::register_external_swapchain(
+    void *swapchain_ptr,
+    bool vsync) noexcept {
+    // TODO
+    SwapchainCreationInfo s;
+    s.invalidate();
+    return s;
+}
+
+uint64_t VkNativeResourceExt::get_native_resource_device_address(
+    void *native_handle) noexcept {
+    VkBufferDeviceAddressInfoKHR buffer_device_address_info{};
+    buffer_device_address_info.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
+    buffer_device_address_info.buffer = static_cast<VkBuffer>(native_handle);
+    return vkGetBufferDeviceAddress(static_cast<Device *>(_device)->logic_device(), &buffer_device_address_info);
+}
+
+VkNativeResourceExt::~VkNativeResourceExt() {}
+}// namespace lc::vk
diff --git a/src/backends/vk/vk_native_res_ext.h b/src/backends/vk/vk_native_res_ext.h
@@ -0,0 +1,41 @@
+#pragma once
+#include <luisa/backends/ext/native_resource_ext_interface.h>
+namespace lc::vk {
+class Device;
+using namespace luisa::compute;
+class VkNativeResourceExt : public NativeResourceExt {
+public:
+    VkNativeResourceExt(Device *device);
+    BufferCreationInfo register_external_buffer(
+        void *buffer_ptr,
+        const Type *element,
+        size_t elem_count,
+        // custom data see backends' header
+        void *custom_data) noexcept override;
+
+    ResourceCreationInfo register_external_image(
+        void *image_ptr,
+        PixelFormat format, uint dimension,
+        uint width, uint height, uint depth,
+        uint mipmap_levels,
+        // custom data see backends' header
+        void *custom_data) noexcept override;
+
+    ResourceCreationInfo register_external_depth_buffer(
+        void *depth_buffer_ptr,
+        DepthFormat format,
+        uint width,
+        uint height,
+        // custom data see backends' header
+        void *custom_data) noexcept override;
+
+    SwapchainCreationInfo register_external_swapchain(
+        void *swapchain_ptr,
+        bool vsync) noexcept override;
+
+    uint64_t get_native_resource_device_address(
+        void *native_handle) noexcept override;
+
+    ~VkNativeResourceExt();
+};
+}// namespace lc::vk
diff --git a/src/backends/vk/vk_raster_ext.cpp b/src/backends/vk/vk_raster_ext.cpp
@@ -3,6 +3,7 @@
 #include "../common/hlsl/shader_compiler.h"
 #include "../common/hlsl/hlsl_codegen.h"
 #include "shader_serializer.h"
+#include "compute_shader.h"
 namespace lc::vk {
 static constexpr uint k_shader_model = 65u;
 ResourceCreationInfo VkRasterExt::create_raster_shader(
@@ -69,15 +70,27 @@ ResourceCreationInfo VkRasterExt::create_raster_shader(
 ResourceCreationInfo VkRasterExt::load_raster_shader(
     luisa::span<Type const *const> types,
     luisa::string_view ser_path) noexcept {
-    return ResourceCreationInfo::make_invalid();
+    auto deser_result = ShaderSerializer::try_deser_raster(_device, {}, {}, ser_path, SerdeType::ByteCode, _device->binary_io());
+    if (!deser_result.shader)
+        return ResourceCreationInfo::make_invalid();
+    ResourceCreationInfo info{};
+    info.handle = reinterpret_cast<uint64_t>(deser_result.shader);
+    if (!ComputeShader::verify_type_md5(types, deser_result.type_md5)) {
+        LUISA_WARNING("Shader {} arguments not match.", name);
+        info.invalidate();
+        return info;
+    }
+    return info;
 }
 
 VkRasterExt::VkRasterExt(Device *device) {
     _device = device;
 }
 VkRasterExt::~VkRasterExt() {}
 
-void VkRasterExt::destroy_raster_shader(uint64_t handle) noexcept {}
+void VkRasterExt::destroy_raster_shader(uint64_t handle) noexcept {
+    delete reinterpret_cast<RasterShader*>(handle);
+}
 
 // depth buffer
 ResourceCreationInfo VkRasterExt::create_depth_buffer(DepthFormat format, uint width, uint height) noexcept {
diff --git a/src/ext/imgui b/src/ext/imgui
@@ -1 +1 @@
-Subproject commit 63f00dae6b9142c2570aaf30b58932153e796567
+Subproject commit eda70b4e1a681c8fef983dc81f7e0225322a8fcb
