react-native-tgfx 0.0.0 → 0.0.2-alpha.0

package/cpp/third_party/tgfx/src/gpu/vulkan/VulkanRenderPipeline.h

@@ -0,0 +1,108 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <unordered_map>
+#include <unordered_set>
+#include "core/utils/Log.h"
+#include "gpu/vulkan/VulkanAPI.h"
+#include "gpu/vulkan/VulkanResource.h"
+#include "tgfx/gpu/RenderPass.h"
+#include "tgfx/gpu/RenderPipeline.h"
+
+namespace tgfx {
+
+class VulkanGPU;
+
+/**
+ * Vulkan render pipeline implementation.
+ */
+class VulkanRenderPipeline : public RenderPipeline, public VulkanResource {
+ public:
+  static std::shared_ptr<VulkanRenderPipeline> Make(VulkanGPU* gpu,
+                                                    const RenderPipelineDescriptor& descriptor);
+
+  VkPipeline vulkanPipeline() const {
+    return pipeline;
+  }
+
+  /// Returns the VkPipeline matching the given primitive type. When extendedDynamicState is
+  /// unavailable, a separate TriangleStrip pipeline variant is created at construction time.
+  VkPipeline vulkanPipeline(PrimitiveType type) const {
+    if (type == PrimitiveType::TriangleStrip) {
+      DEBUG_ASSERT(stripPipeline != VK_NULL_HANDLE);
+      return stripPipeline;
+    }
+    return pipeline;
+  }
+
+  VkPipelineLayout vulkanPipelineLayout() const {
+    return pipelineLayout;
+  }
+
+  /// Returns the descriptor set layout for UBO bindings (set 0).
+  VkDescriptorSetLayout vulkanUboSetLayout() const {
+    return uboSetLayout;
+  }
+
+  /// Returns the descriptor set layout for texture/sampler bindings (set 1).
+  VkDescriptorSetLayout vulkanTextureSetLayout() const {
+    return textureSetLayout;
+  }
+
+  unsigned getTextureIndex(unsigned binding) const;
+
+  uint32_t getUniformBlockVisibility(unsigned binding) const;
+
+  bool hasUniformBinding(unsigned binding) const {
+    return uniformBindingSet.count(binding) > 0;
+  }
+
+  const std::unordered_set<unsigned>& getTextureBindings() const {
+    return textureBindingSet;
+  }
+
+ protected:
+  void onRelease(VulkanGPU* gpu) override;
+
+ private:
+  VulkanRenderPipeline(VulkanGPU* gpu, const RenderPipelineDescriptor& descriptor);
+  ~VulkanRenderPipeline() override = default;
+
+  bool createDescriptorSetLayouts(VulkanGPU* gpu, const RenderPipelineDescriptor& descriptor);
+  bool createPipelineLayout(VulkanGPU* gpu);
+  bool createPipeline(VulkanGPU* gpu, const RenderPipelineDescriptor& descriptor,
+                      VkPrimitiveTopology topology, VkPipeline* outPipeline);
+
+  VkPipeline pipeline = VK_NULL_HANDLE;
+  VkPipeline stripPipeline = VK_NULL_HANDLE;
+  VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
+  // Descriptor set 0: UBO bindings (vertex UBO at binding 0, fragment UBO at binding 1).
+  VkDescriptorSetLayout uboSetLayout = VK_NULL_HANDLE;
+  // Descriptor set 1: texture/sampler bindings (binding 0, 1, 2, ...).
+  VkDescriptorSetLayout textureSetLayout = VK_NULL_HANDLE;
+  std::unordered_map<unsigned, unsigned> textureUnits = {};
+  std::unordered_map<unsigned, uint32_t> uniformBlockVisibility = {};
+  std::unordered_set<unsigned> uniformBindingSet = {};
+  std::unordered_set<unsigned> textureBindingSet = {};
+
+  friend class VulkanGPU;
+};
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/vulkan/VulkanResource.cpp

@@ -0,0 +1,21 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "VulkanResource.h"
+
+namespace tgfx {}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/vulkan/VulkanResource.h

@@ -0,0 +1,43 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <list>
+#include "core/utils/ReturnQueue.h"
+
+namespace tgfx {
+
+class VulkanGPU;
+
+/**
+ * Base class for Vulkan GPU resources. Subclasses must implement the onRelease() method to free all
+ * underlying GPU resources. No Vulkan API calls should be made during destruction since the resource
+ * may be destroyed on any thread.
+ */
+class VulkanResource : public ReturnNode {
+ protected:
+  virtual void onRelease(VulkanGPU* gpu) = 0;
+
+ private:
+  std::list<VulkanResource*>::iterator cachedPosition;
+
+  friend class VulkanGPU;
+};
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/vulkan/VulkanSampler.cpp

@@ -0,0 +1,108 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "VulkanSampler.h"
+#include "VulkanGPU.h"
+#include "VulkanUtil.h"
+#include "core/utils/Log.h"
+
+namespace tgfx {
+
+static VkFilter ToVkFilter(FilterMode mode) {
+  switch (mode) {
+    case FilterMode::Nearest:
+      return VK_FILTER_NEAREST;
+    case FilterMode::Linear:
+      return VK_FILTER_LINEAR;
+    default:
+      return VK_FILTER_NEAREST;
+  }
+}
+
+static VkSamplerMipmapMode ToVkMipmapMode(MipmapMode mode) {
+  switch (mode) {
+    case MipmapMode::Nearest:
+      return VK_SAMPLER_MIPMAP_MODE_NEAREST;
+    case MipmapMode::Linear:
+      return VK_SAMPLER_MIPMAP_MODE_LINEAR;
+    default:
+      return VK_SAMPLER_MIPMAP_MODE_NEAREST;
+  }
+}
+
+static VkSamplerAddressMode ToVkAddressMode(AddressMode mode) {
+  switch (mode) {
+    case AddressMode::ClampToEdge:
+      return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+    case AddressMode::Repeat:
+      return VK_SAMPLER_ADDRESS_MODE_REPEAT;
+    case AddressMode::MirrorRepeat:
+      return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
+    case AddressMode::ClampToBorder:
+      return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
+    default:
+      return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+  }
+}
+
+std::shared_ptr<VulkanSampler> VulkanSampler::Make(VulkanGPU* gpu,
+                                                   const SamplerDescriptor& descriptor) {
+  if (!gpu) {
+    return nullptr;
+  }
+
+  VkSamplerCreateInfo samplerInfo = {};
+  samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+  samplerInfo.minFilter = ToVkFilter(descriptor.minFilter);
+  samplerInfo.magFilter = ToVkFilter(descriptor.magFilter);
+  samplerInfo.mipmapMode = ToVkMipmapMode(descriptor.mipmapMode);
+  samplerInfo.addressModeU = ToVkAddressMode(descriptor.addressModeX);
+  samplerInfo.addressModeV = ToVkAddressMode(descriptor.addressModeY);
+  samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+  samplerInfo.mipLodBias = 0.0f;
+  samplerInfo.anisotropyEnable = VK_FALSE;
+  samplerInfo.maxAnisotropy = 1.0f;
+  samplerInfo.compareEnable = VK_FALSE;
+  samplerInfo.minLod = 0.0f;
+  // When mipmap is disabled, clamp maxLod to 0 to prevent sampling uninitialized mip levels.
+  // Textures may be created with multiple mip levels but only have level 0 data uploaded.
+  samplerInfo.maxLod = (descriptor.mipmapMode == MipmapMode::None) ? 0.0f : VK_LOD_CLAMP_NONE;
+  samplerInfo.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
+  samplerInfo.unnormalizedCoordinates = VK_FALSE;
+
+  VkSampler vkSampler = VK_NULL_HANDLE;
+  auto result = vkCreateSampler(gpu->device(), &samplerInfo, nullptr, &vkSampler);
+  if (result != VK_SUCCESS) {
+    LOGE("VulkanSampler::Make() vkCreateSampler failed: %s", VkResultToString(result));
+    return nullptr;
+  }
+
+  return gpu->makeResource<VulkanSampler>(vkSampler);
+}
+
+VulkanSampler::VulkanSampler(VkSampler sampler) : sampler(sampler) {
+}
+
+void VulkanSampler::onRelease(VulkanGPU* gpu) {
+  if (sampler != VK_NULL_HANDLE) {
+    vkDestroySampler(gpu->device(), sampler, nullptr);
+    sampler = VK_NULL_HANDLE;
+  }
+}
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/vulkan/VulkanSampler.h

@@ -0,0 +1,52 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "gpu/vulkan/VulkanAPI.h"
+#include "gpu/vulkan/VulkanResource.h"
+#include "tgfx/gpu/Sampler.h"
+
+namespace tgfx {
+
+class VulkanGPU;
+
+/**
+ * Vulkan sampler implementation.
+ */
+class VulkanSampler : public Sampler, public VulkanResource {
+ public:
+  static std::shared_ptr<VulkanSampler> Make(VulkanGPU* gpu, const SamplerDescriptor& descriptor);
+
+  VkSampler vulkanSampler() const {
+    return sampler;
+  }
+
+ protected:
+  void onRelease(VulkanGPU* gpu) override;
+
+ private:
+  explicit VulkanSampler(VkSampler sampler);
+  ~VulkanSampler() override = default;
+
+  VkSampler sampler = VK_NULL_HANDLE;
+
+  friend class VulkanGPU;
+};
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/vulkan/VulkanSemaphore.cpp

@@ -0,0 +1,82 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "VulkanSemaphore.h"
+#include "VulkanGPU.h"
+#include "VulkanUtil.h"
+#include "core/utils/Log.h"
+
+namespace tgfx {
+
+std::shared_ptr<VulkanSemaphore> VulkanSemaphore::Make(VulkanGPU* gpu) {
+  if (!gpu) {
+    return nullptr;
+  }
+  if (!gpu->extensions().timelineSemaphore) {
+    return nullptr;
+  }
+
+  VkSemaphoreTypeCreateInfo timelineInfo = {};
+  timelineInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
+  timelineInfo.semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE;
+  timelineInfo.initialValue = 0;
+
+  VkSemaphoreCreateInfo semaphoreInfo = {};
+  semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+  semaphoreInfo.pNext = &timelineInfo;
+
+  VkSemaphore semaphore = VK_NULL_HANDLE;
+  auto result = vkCreateSemaphore(gpu->device(), &semaphoreInfo, nullptr, &semaphore);
+  if (result != VK_SUCCESS) {
+    LOGE("VulkanSemaphore::Make() vkCreateSemaphore failed: %s", VkResultToString(result));
+    return nullptr;
+  }
+
+  return gpu->makeResource<VulkanSemaphore>(semaphore, static_cast<uint64_t>(0));
+}
+
+std::shared_ptr<VulkanSemaphore> VulkanSemaphore::MakeFrom(VulkanGPU* gpu, VkSemaphore semaphore,
+                                                           uint64_t value) {
+  if (!gpu || semaphore == VK_NULL_HANDLE) {
+    return nullptr;
+  }
+  return gpu->makeResource<VulkanSemaphore>(semaphore, value, true);
+}
+
+VulkanSemaphore::VulkanSemaphore(VkSemaphore semaphore, uint64_t value, bool adopted)
+    : _semaphore(semaphore), _value(value), _adopted(adopted) {
+}
+
+BackendSemaphore VulkanSemaphore::getBackendSemaphore() const {
+  if (_semaphore == VK_NULL_HANDLE) {
+    return {};
+  }
+  VulkanSyncInfo vulkanInfo = {};
+  vulkanInfo.semaphore = reinterpret_cast<uint64_t>(_semaphore);
+  vulkanInfo.value = _value;
+  return BackendSemaphore(vulkanInfo);
+}
+
+void VulkanSemaphore::onRelease(VulkanGPU* gpu) {
+  if (_semaphore != VK_NULL_HANDLE && !_adopted) {
+    vkDestroySemaphore(gpu->device(), _semaphore, nullptr);
+    _semaphore = VK_NULL_HANDLE;
+  }
+}
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/vulkan/VulkanSemaphore.h

@@ -0,0 +1,71 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "gpu/vulkan/VulkanAPI.h"
+#include "gpu/vulkan/VulkanResource.h"
+#include "tgfx/gpu/Semaphore.h"
+
+namespace tgfx {
+
+class VulkanGPU;
+
+/**
+ * Vulkan semaphore implementation using VK_KHR_timeline_semaphore for GPU synchronization.
+ */
+class VulkanSemaphore : public Semaphore, public VulkanResource {
+ public:
+  static std::shared_ptr<VulkanSemaphore> Make(VulkanGPU* gpu);
+
+  static std::shared_ptr<VulkanSemaphore> MakeFrom(VulkanGPU* gpu, VkSemaphore semaphore,
+                                                   uint64_t value);
+
+  VulkanSemaphore(VkSemaphore semaphore, uint64_t value, bool adopted = false);
+  ~VulkanSemaphore() override = default;
+
+  VkSemaphore vulkanSemaphore() const {
+    return _semaphore;
+  }
+
+  uint64_t signalValue() const {
+    return _value;
+  }
+
+  uint64_t nextSignalValue() const {
+    return _value + 1;
+  }
+
+  void commitSignalValue() {
+    ++_value;
+  }
+
+  BackendSemaphore getBackendSemaphore() const override;
+
+ protected:
+  void onRelease(VulkanGPU* gpu) override;
+
+ private:
+  VkSemaphore _semaphore = VK_NULL_HANDLE;
+  uint64_t _value = 0;
+  bool _adopted = false;
+
+  friend class VulkanGPU;
+};
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/vulkan/VulkanShaderModule.cpp

@@ -0,0 +1,65 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "VulkanShaderModule.h"
+#include "VulkanGPU.h"
+#include "core/utils/Log.h"
+#include "gpu/ShaderCompiler.h"
+
+namespace tgfx {
+
+std::shared_ptr<VulkanShaderModule> VulkanShaderModule::Make(
+    VulkanGPU* gpu, const ShaderModuleDescriptor& descriptor) {
+  if (!gpu) {
+    return nullptr;
+  }
+  auto module = gpu->makeResource<VulkanShaderModule>(gpu, descriptor);
+  if (module->vulkanShaderModule() == VK_NULL_HANDLE) {
+    return nullptr;
+  }
+  return module;
+}
+
+VulkanShaderModule::VulkanShaderModule(VulkanGPU* gpu, const ShaderModuleDescriptor& descriptor) {
+  std::string vulkanGLSL = PreprocessGLSL(descriptor.code);
+  auto spirvBinary = CompileGLSLToSPIRV(gpu->shaderCompiler(), vulkanGLSL, descriptor.stage);
+  if (spirvBinary.empty()) {
+    LOGE("VulkanShaderModule: GLSL to SPIR-V compilation failed.");
+    return;
+  }
+
+  VkShaderModuleCreateInfo createInfo = {};
+  createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+  createInfo.codeSize = spirvBinary.size() * sizeof(uint32_t);
+  createInfo.pCode = spirvBinary.data();
+
+  auto result = vkCreateShaderModule(gpu->device(), &createInfo, nullptr, &shaderModule);
+  if (result != VK_SUCCESS) {
+    LOGE("VulkanShaderModule: vkCreateShaderModule failed.");
+    shaderModule = VK_NULL_HANDLE;
+  }
+}
+
+void VulkanShaderModule::onRelease(VulkanGPU* gpu) {
+  if (shaderModule != VK_NULL_HANDLE) {
+    vkDestroyShaderModule(gpu->device(), shaderModule, nullptr);
+    shaderModule = VK_NULL_HANDLE;
+  }
+}
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/vulkan/VulkanShaderModule.h

@@ -0,0 +1,54 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "gpu/vulkan/VulkanAPI.h"
+#include "gpu/vulkan/VulkanResource.h"
+#include "tgfx/gpu/ShaderModule.h"
+
+namespace tgfx {
+
+class VulkanGPU;
+
+/**
+ * Vulkan shader module implementation. Compiles GLSL to SPIR-V via the shared ShaderCompiler, then
+ * creates a VkShaderModule from the SPIR-V binary.
+ */
+class VulkanShaderModule : public ShaderModule, public VulkanResource {
+ public:
+  static std::shared_ptr<VulkanShaderModule> Make(VulkanGPU* gpu,
+                                                  const ShaderModuleDescriptor& descriptor);
+
+  VkShaderModule vulkanShaderModule() const {
+    return shaderModule;
+  }
+
+ protected:
+  void onRelease(VulkanGPU* gpu) override;
+
+ private:
+  VulkanShaderModule(VulkanGPU* gpu, const ShaderModuleDescriptor& descriptor);
+  ~VulkanShaderModule() override = default;
+
+  VkShaderModule shaderModule = VK_NULL_HANDLE;
+
+  friend class VulkanGPU;
+};
+
+}  // namespace tgfx