GaussianSplatVulkanInteropContext.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.open3d.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
//
// Vulkan-OpenGL interop context for Gaussian splatting compute (Linux/Windows).
//
// Owns a headless Vulkan instance and logical device used solely for compute
// work. All resources that must be visible to both Vulkan compute and
// OpenGL/Filament are allocated here as exportable memory objects.
//
// Key relationships:
//   - GaussianSplatOpenGLContext creates the GL/GLFW context and calls
//     glewInit(). After that, call ProbeGLExtensions() to verify the
//     GL interop extensions are present.
//   - FilamentEngine.cpp calls Initialize() before GL context setup, and
//     Shutdown() on engine teardown.
//   - GaussianSplatVulkanBackend uses CreateSharedColorImage() and
//     CreateSharedDepthImage() per view, holding the handles in OutputTargets.
//
// Uses vulkan-hpp (Vulkan-Headers) for Vulkan loading and RAII handle
// lifetime management, and VMA (vk_mem_alloc.h from the pinned 3rdparty
// download) for suballocated internal-only buffer allocations.
//
// Thread-safety: not thread-safe. All calls must be made from the render
// thread. Shared images must be created or destroyed while the GL context is
// current (for the GL import calls).
 
#pragma once
 
#if !defined(__APPLE__)
 
#include <cstdint>
#include <string>
 
// Suppress C function-prototype declarations in vulkan.h: all Vulkan entry
// points are resolved at runtime through vulkan-hpp's per-object RAII
// dispatchers (ContextDispatcher / InstanceDispatcher / DeviceDispatcher),
// not as statically-linked symbols.
//
// NOTE: BlueVK (used by Filament) also defines VK_NO_PROTOTYPES before
// including vulkan.h, so the two includes are mutually compatible when
// this header is included after Filament headers.
#ifndef VK_NO_PROTOTYPES
#define VK_NO_PROTOTYPES
#endif
#include <vulkan/vulkan_raii.hpp>
 
namespace open3d {
namespace visualization {
namespace rendering {
 
// ---------------------------------------------------------------------------
// Shared resource descriptors
// ---------------------------------------------------------------------------
 
enum class VkInteropImageFormat {
    kRGBA16F,   
    kDepth32F,  
};
 
struct SharedImageDesc {
    VkImage vk_image = VK_NULL_HANDLE;
    VkDeviceMemory vk_memory = VK_NULL_HANDLE;  
 
    std::uint32_t gl_memory_object = 0;  
    std::uint32_t gl_texture = 0;        
 
    std::uint32_t width = 0;
    std::uint32_t height = 0;
    VkInteropImageFormat format = VkInteropImageFormat::kRGBA16F;
 
    VkImageLayout current_layout = VK_IMAGE_LAYOUT_UNDEFINED;
 
    bool IsValid() const { return vk_image != VK_NULL_HANDLE; }
};
 
// ---------------------------------------------------------------------------
// GaussianSplatVulkanInteropContext — headless Vulkan compute context
// ---------------------------------------------------------------------------
 
class GaussianSplatVulkanInteropContext {
public:
    static GaussianSplatVulkanInteropContext& GetInstance();
 
    bool Initialize();
 
    void Shutdown();
 
    bool IsValid() const { return initialized_; }
 
    bool ProbeGLExtensions();
 
    bool AreGLExtensionsReady() const { return gl_extensions_ok_; }
 
    const std::string& GetLastError() const { return last_error_; }
 
    // --- Device accessors (used by VulkanBackend and ComputeGPUVulkan) ----
    // vk::Handle::CType provides the underlying C type (e.g.
    // vk::Instance::CType
    // == VkInstance). On 64-bit platforms vk::raii handles implicitly convert
    // to their C equivalents; static_cast is used here to be explicit and
    // 32-bit safe.
    VkInstance GetVkInstance() const {
        return static_cast<vk::Instance::CType>(*instance_);
    }
    VkDevice GetDevice() const {
        return static_cast<vk::Device::CType>(*device_);
    }
    VkPhysicalDevice GetPhysicalDevice() const {
        return static_cast<vk::PhysicalDevice::CType>(*physical_device_);
    }
    VkQueue GetComputeQueue() const {
        return static_cast<vk::Queue::CType>(*compute_queue_);
    }
    std::uint32_t GetComputeQueueFamily() const {
        return compute_queue_family_;
    }
    bool GetDebugUtilsEnabled() const { return debug_utils_enabled_; }
    std::uint32_t GetSubgroupSize() const { return subgroup_size_; }
    std::uint32_t GetSubgroupSupportedStages() const {
        return subgroup_supported_stages_;
    }
    std::uint32_t GetSubgroupSupportedOperations() const {
        return subgroup_supported_operations_;
    }
 
    // RAII accessors used by ComputeGPUVulkan to create sub-objects.
    const vk::raii::Instance& GetRaiiInstance() const { return instance_; }
    const vk::raii::Device& GetRaiiDevice() const { return device_; }
 
    // --- Shared-image lifecycle -------------------------------------------
 
    SharedImageDesc CreateSharedColorImage(std::uint32_t width,
                                           std::uint32_t height,
                                           const char* label = nullptr);
 
    SharedImageDesc CreateSharedDepthImage(std::uint32_t width,
                                           std::uint32_t height,
                                           const char* label = nullptr);
 
    void DestroySharedImage(SharedImageDesc& desc);
 
    // --- Vulkan device memory type helpers --------------------------------
 
    std::uint32_t FindMemoryType(std::uint32_t type_filter,
                                 VkMemoryPropertyFlags props) const;
 
private:
    GaussianSplatVulkanInteropContext() = default;
    ~GaussianSplatVulkanInteropContext();
 
    GaussianSplatVulkanInteropContext(
            const GaussianSplatVulkanInteropContext&) = delete;
    GaussianSplatVulkanInteropContext& operator=(
            const GaussianSplatVulkanInteropContext&) = delete;
 
    // --- Internal helpers -------------------------------------------------
 
    bool CreateInstance();
    bool SelectPhysicalDevice();
    bool CreateLogicalDevice();
 
    bool AllocateExportableImage(std::uint32_t width,
                                 std::uint32_t height,
                                 VkFormat vk_format,
                                 VkImageUsageFlags usage,
                                 VkImage& out_image,
                                 VkDeviceMemory& out_memory,
                                 int& out_fd) const;
 
    bool ImportFDIntoGL(int fd,
                        std::uint32_t width,
                        std::uint32_t height,
                        VkDeviceSize memory_size,
                        VkInteropImageFormat format,
                        std::uint32_t& out_gl_memory_object,
                        std::uint32_t& out_gl_texture) const;
 
    SharedImageDesc CreateSharedImage(std::uint32_t width,
                                      std::uint32_t height,
                                      VkInteropImageFormat format,
                                      const char* label);
 
    // --- State ------------------------------------------------------------
    bool initialized_ = false;
    bool gl_extensions_ok_ = false;
    bool debug_utils_enabled_ =
            false;                     // VK_EXT_debug_utils enabled in instance
    std::uint32_t subgroup_size_ = 0;  // queried after logical device creation
    std::uint32_t subgroup_supported_stages_ = 0;
    std::uint32_t subgroup_supported_operations_ = 0;
    std::string last_error_;
 
    // RAII handles. Destruction order is reverse of declaration order:
    // compute_queue_ → device_ → physical_device_ → instance_ → context_.
    // vk::raii::Context loads the Vulkan loader; all others are sub-objects.
    vk::raii::Context context_;
    vk::raii::Instance instance_{nullptr};
    vk::raii::PhysicalDevice physical_device_{nullptr};
    vk::raii::Device device_{nullptr};
    vk::raii::Queue compute_queue_{nullptr};
    std::uint32_t compute_queue_family_ = UINT32_MAX;
 
    VkPhysicalDeviceMemoryProperties memory_props_{};
};
 
}  // namespace rendering
}  // namespace visualization
}  // namespace open3d
 
#endif  // !defined(__APPLE__)