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

package/cpp/third_party/tgfx/src/gpu/metal/MetalRenderPass.h

@@ -0,0 +1,110 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 <Metal/Metal.h>
+#include "tgfx/gpu/RenderPass.h"
+
+namespace tgfx {
+
+class MetalCommandEncoder;
+class MetalRenderPipeline;
+
+/**
+ * Metal render pass implementation.
+ */
+class MetalRenderPass : public RenderPass {
+ public:
+  static std::shared_ptr<MetalRenderPass> Make(MetalCommandEncoder* encoder,
+                                               const RenderPassDescriptor& descriptor);
+
+  ~MetalRenderPass() override;
+
+  /**
+   * Returns the Metal render command encoder.
+   */
+  id<MTLRenderCommandEncoder> metalRenderCommandEncoder() const {
+    return renderEncoder;
+  }
+
+  // RenderPass interface implementation
+  GPU* gpu() const override;
+  void setViewport(int x, int y, int width, int height) override;
+  void setScissorRect(int x, int y, int width, int height) override;
+  void setPipeline(std::shared_ptr<RenderPipeline> pipeline) override;
+  void setVertexBuffer(unsigned slot, std::shared_ptr<GPUBuffer> buffer,
+                       size_t offset = 0) override;
+  void setIndexBuffer(std::shared_ptr<GPUBuffer> buffer,
+                      IndexFormat format = IndexFormat::UInt16) override;
+  void setTexture(unsigned binding, std::shared_ptr<Texture> texture,
+                  std::shared_ptr<Sampler> sampler) override;
+  void setUniformBuffer(unsigned binding, std::shared_ptr<GPUBuffer> buffer, size_t offset,
+                        size_t size) override;
+  void setStencilReference(uint32_t reference) override;
+
+  void draw(PrimitiveType primitiveType, uint32_t vertexCount, uint32_t instanceCount = 1,
+            uint32_t firstVertex = 0, uint32_t firstInstance = 0) override;
+  void drawIndexed(PrimitiveType primitiveType, uint32_t indexCount, uint32_t instanceCount = 1,
+                   uint32_t firstIndex = 0, int32_t baseVertex = 0,
+                   uint32_t firstInstance = 0) override;
+
+ protected:
+  void onEnd() override;
+
+ private:
+  MetalRenderPass(MetalCommandEncoder* encoder, const RenderPassDescriptor& descriptor);
+
+  MetalCommandEncoder* commandEncoder = nullptr;
+  id<MTLRenderCommandEncoder> renderEncoder = nil;
+  std::shared_ptr<MetalRenderPipeline> currentPipeline = nullptr;
+
+  // Cached scissor rect to avoid redundant Metal API calls.
+  int lastScissorX = -1;
+  int lastScissorY = -1;
+  int lastScissorWidth = -1;
+  int lastScissorHeight = -1;
+
+  // Cached uniform buffer state to avoid redundant Metal API calls.
+  // Index 0 = VERTEX_UBO_BINDING_POINT, Index 1 = FRAGMENT_UBO_BINDING_POINT.
+  static constexpr int MaxUniformBindings = 2;
+  GPUBuffer* lastUniformBuffers[MaxUniformBindings] = {};
+  size_t lastUniformOffsets[MaxUniformBindings] = {};
+
+  // Cached texture/sampler state to avoid redundant Metal API calls.
+  static constexpr int MaxTextureBindings = 16;
+  Texture* lastTextures[MaxTextureBindings] = {};
+  Sampler* lastSamplers[MaxTextureBindings] = {};
+
+  // Cached vertex buffer state to avoid redundant Metal API calls.
+  static constexpr int MaxVertexBufferSlots = 4;
+  GPUBuffer* lastVertexBuffers[MaxVertexBufferSlots] = {};
+  size_t lastVertexOffsets[MaxVertexBufferSlots] = {};
+
+  // Cached pipeline sub-states to avoid redundant Metal API calls.
+  id<MTLDepthStencilState> lastDepthStencilState = nil;
+  MTLCullMode lastCullMode = MTLCullModeNone;
+  MTLWinding lastFrontFace = MTLWindingClockwise;
+  bool cullModeInitialized = false;
+
+  // Index buffer state (Metal doesn't have separate setIndexBuffer)
+  std::shared_ptr<class MetalBuffer> indexBuffer = nullptr;
+  IndexFormat indexFormat = IndexFormat::UInt16;
+};
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/metal/MetalRenderPass.mm

@@ -0,0 +1,386 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "MetalRenderPass.h"
+#include "MetalBuffer.h"
+#include "MetalCommandEncoder.h"
+#include "MetalRenderPipeline.h"
+#include "MetalSampler.h"
+#include "MetalShaderModule.h"
+#include "MetalTexture.h"
+#include "MetalUtil.h"
+#include "core/utils/Log.h"
+
+namespace tgfx {
+
+std::shared_ptr<MetalRenderPass> MetalRenderPass::Make(MetalCommandEncoder* encoder,
+                                                       const RenderPassDescriptor& descriptor) {
+  if (!encoder) {
+    return nullptr;
+  }
+
+  auto pass = std::shared_ptr<MetalRenderPass>(new MetalRenderPass(encoder, descriptor));
+  if (!pass->renderEncoder) {
+    return nullptr;
+  }
+  return pass;
+}
+
+MetalRenderPass::MetalRenderPass(MetalCommandEncoder* encoder, const RenderPassDescriptor& desc)
+    : RenderPass(desc), commandEncoder(encoder) {
+  // Create Metal render pass descriptor
+  MTLRenderPassDescriptor* metalRenderPassDescriptor =
+      [MTLRenderPassDescriptor renderPassDescriptor];
+
+  // Configure color attachments
+  for (size_t i = 0; i < descriptor.colorAttachments.size(); i++) {
+    const auto& colorAttachment = descriptor.colorAttachments[i];
+    if (!colorAttachment.texture) {
+      continue;
+    }
+
+    auto colorTexture = std::static_pointer_cast<MetalTexture>(colorAttachment.texture);
+
+    metalRenderPassDescriptor.colorAttachments[i].texture = colorTexture->metalTexture();
+    metalRenderPassDescriptor.colorAttachments[i].loadAction =
+        ToMTLLoadAction(colorAttachment.loadAction);
+    metalRenderPassDescriptor.colorAttachments[i].storeAction =
+        ToMTLStoreAction(colorAttachment.storeAction);
+
+    if (colorAttachment.loadAction == LoadAction::Clear) {
+      auto clearColor = colorAttachment.clearValue;
+      metalRenderPassDescriptor.colorAttachments[i].clearColor =
+          MTLClearColorMake(clearColor.red, clearColor.green, clearColor.blue, clearColor.alpha);
+    }
+
+    // Configure resolve texture if present (for MSAA)
+    if (colorAttachment.resolveTexture) {
+      auto resolveTexture = std::static_pointer_cast<MetalTexture>(colorAttachment.resolveTexture);
+      metalRenderPassDescriptor.colorAttachments[i].resolveTexture = resolveTexture->metalTexture();
+      // Use StoreAndMultisampleResolve to keep MSAA texture content for future Load operations
+      metalRenderPassDescriptor.colorAttachments[i].storeAction =
+          MTLStoreActionStoreAndMultisampleResolve;
+    }
+  }
+
+  // Configure depth-stencil attachment
+  if (descriptor.depthStencilAttachment.texture) {
+    auto depthStencilTexture =
+        std::static_pointer_cast<MetalTexture>(descriptor.depthStencilAttachment.texture);
+
+    metalRenderPassDescriptor.depthAttachment.texture = depthStencilTexture->metalTexture();
+    metalRenderPassDescriptor.depthAttachment.loadAction =
+        ToMTLLoadAction(descriptor.depthStencilAttachment.loadAction);
+    metalRenderPassDescriptor.depthAttachment.storeAction =
+        ToMTLStoreAction(descriptor.depthStencilAttachment.storeAction);
+
+    metalRenderPassDescriptor.stencilAttachment.texture = depthStencilTexture->metalTexture();
+    metalRenderPassDescriptor.stencilAttachment.loadAction =
+        ToMTLLoadAction(descriptor.depthStencilAttachment.loadAction);
+    metalRenderPassDescriptor.stencilAttachment.storeAction =
+        ToMTLStoreAction(descriptor.depthStencilAttachment.storeAction);
+
+    if (descriptor.depthStencilAttachment.loadAction == LoadAction::Clear) {
+      metalRenderPassDescriptor.depthAttachment.clearDepth =
+          descriptor.depthStencilAttachment.depthClearValue;
+      metalRenderPassDescriptor.stencilAttachment.clearStencil =
+          descriptor.depthStencilAttachment.stencilClearValue;
+    }
+  }
+
+  // Create render command encoder
+  renderEncoder = [[commandEncoder->metalCommandBuffer()
+      renderCommandEncoderWithDescriptor:metalRenderPassDescriptor] retain];
+
+  // Set default viewport based on the first color attachment
+  if (renderEncoder && !descriptor.colorAttachments.empty() &&
+      descriptor.colorAttachments[0].texture) {
+    auto texture = descriptor.colorAttachments[0].texture;
+    MTLViewport viewport;
+    viewport.originX = 0.0;
+    viewport.originY = 0.0;
+    viewport.width = static_cast<double>(texture->width());
+    viewport.height = static_cast<double>(texture->height());
+    viewport.znear = 0.0;
+    viewport.zfar = 1.0;
+    [renderEncoder setViewport:viewport];
+  }
+}
+
+void MetalRenderPass::onEnd() {
+  if (renderEncoder) {
+    [renderEncoder endEncoding];
+    [renderEncoder release];
+    renderEncoder = nil;
+  }
+}
+
+MetalRenderPass::~MetalRenderPass() {
+  onEnd();
+}
+
+GPU* MetalRenderPass::gpu() const {
+  return commandEncoder->gpu();
+}
+
+void MetalRenderPass::setViewport(int x, int y, int width, int height) {
+  if (!renderEncoder) return;
+
+  MTLViewport viewport;
+  viewport.originX = static_cast<double>(x);
+  viewport.originY = static_cast<double>(y);
+  viewport.width = static_cast<double>(width);
+  viewport.height = static_cast<double>(height);
+  viewport.znear = 0.0;
+  viewport.zfar = 1.0;
+
+  [renderEncoder setViewport:viewport];
+}
+
+void MetalRenderPass::setScissorRect(int x, int y, int width, int height) {
+  if (!renderEncoder) return;
+
+  // Clamp to render target bounds - Metal requires non-negative values
+  // and scissor rect must be within render target bounds
+  int renderWidth = 0;
+  int renderHeight = 0;
+  if (!descriptor.colorAttachments.empty() && descriptor.colorAttachments[0].texture) {
+    renderWidth = descriptor.colorAttachments[0].texture->width();
+    renderHeight = descriptor.colorAttachments[0].texture->height();
+  }
+
+  // Clamp negative coordinates
+  if (x < 0) {
+    width += x;  // Reduce width by the amount x is negative
+    x = 0;
+  }
+  if (y < 0) {
+    height += y;  // Reduce height by the amount y is negative
+    y = 0;
+  }
+
+  // Clamp to render target bounds
+  if (x + width > renderWidth) {
+    width = renderWidth - x;
+  }
+  if (y + height > renderHeight) {
+    height = renderHeight - y;
+  }
+
+  // Metal does not allow scissor rect with zero width or height.
+  if (width <= 0 || height <= 0) {
+    return;
+  }
+
+  if (x == lastScissorX && y == lastScissorY && width == lastScissorWidth &&
+      height == lastScissorHeight) {
+    return;
+  }
+  lastScissorX = x;
+  lastScissorY = y;
+  lastScissorWidth = width;
+  lastScissorHeight = height;
+
+  MTLScissorRect scissorRect;
+  scissorRect.x = static_cast<NSUInteger>(x);
+  scissorRect.y = static_cast<NSUInteger>(y);
+  scissorRect.width = static_cast<NSUInteger>(width);
+  scissorRect.height = static_cast<NSUInteger>(height);
+
+  [renderEncoder setScissorRect:scissorRect];
+}
+
+void MetalRenderPass::setPipeline(std::shared_ptr<RenderPipeline> pipeline) {
+  if (!renderEncoder || !pipeline) return;
+  if (currentPipeline == pipeline) return;
+
+  currentPipeline = std::static_pointer_cast<MetalRenderPipeline>(pipeline);
+  [renderEncoder setRenderPipelineState:currentPipeline->metalRenderPipelineState()];
+
+  // Set depth stencil state if available
+  auto depthStencilState = currentPipeline->metalDepthStencilState();
+  if (depthStencilState && depthStencilState != lastDepthStencilState) {
+    lastDepthStencilState = depthStencilState;
+    [renderEncoder setDepthStencilState:depthStencilState];
+  }
+
+  // Set cull mode and front face winding with caching
+  if (!cullModeInitialized || currentPipeline->cullMode != lastCullMode) {
+    lastCullMode = currentPipeline->cullMode;
+    [renderEncoder setCullMode:lastCullMode];
+  }
+  if (!cullModeInitialized || currentPipeline->frontFace != lastFrontFace) {
+    lastFrontFace = currentPipeline->frontFace;
+    [renderEncoder setFrontFacingWinding:lastFrontFace];
+  }
+  cullModeInitialized = true;
+}
+
+void MetalRenderPass::setVertexBuffer(unsigned slot, std::shared_ptr<GPUBuffer> buffer,
+                                      size_t offset) {
+  if (!renderEncoder || !buffer) {
+    return;
+  }
+  if (slot < MaxVertexBufferSlots && lastVertexBuffers[slot] == buffer.get() &&
+      lastVertexOffsets[slot] == offset) {
+    return;
+  }
+
+  DEBUG_ASSERT(slot < VertexBufferIndexStart);
+  auto metalBufferIndex = VertexBufferIndexStart - slot;
+
+  if (slot < MaxVertexBufferSlots && lastVertexBuffers[slot] == buffer.get()) {
+    // Same buffer, only offset changed — use lightweight offset-only update.
+    lastVertexOffsets[slot] = offset;
+    [renderEncoder setVertexBufferOffset:offset atIndex:metalBufferIndex];
+    return;
+  }
+
+  if (slot < MaxVertexBufferSlots) {
+    lastVertexBuffers[slot] = buffer.get();
+    lastVertexOffsets[slot] = offset;
+  }
+
+  auto metalBuffer = std::static_pointer_cast<MetalBuffer>(buffer);
+  [renderEncoder setVertexBuffer:metalBuffer->metalBuffer() offset:offset atIndex:metalBufferIndex];
+}
+
+void MetalRenderPass::setIndexBuffer(std::shared_ptr<GPUBuffer> buffer, IndexFormat format) {
+  // Metal doesn't have a separate setIndexBuffer method
+  // Index buffer is set during drawIndexed call
+  indexBuffer = std::static_pointer_cast<MetalBuffer>(buffer);
+  indexFormat = format;
+}
+
+void MetalRenderPass::setTexture(unsigned binding, std::shared_ptr<Texture> texture,
+                                 std::shared_ptr<Sampler> sampler) {
+  if (!renderEncoder || !texture) {
+    return;
+  }
+
+  // Remap logical binding to actual Metal texture index via the pipeline's mapping table.
+  unsigned textureIndex = currentPipeline ? currentPipeline->getTextureIndex(binding) : binding;
+
+  if (textureIndex < MaxTextureBindings && lastTextures[textureIndex] == texture.get() &&
+      lastSamplers[textureIndex] == sampler.get()) {
+    return;
+  }
+  if (textureIndex < MaxTextureBindings) {
+    lastTextures[textureIndex] = texture.get();
+    lastSamplers[textureIndex] = sampler.get();
+  }
+
+  auto metalTexture = std::static_pointer_cast<MetalTexture>(texture);
+  [renderEncoder setFragmentTexture:metalTexture->metalTexture() atIndex:textureIndex];
+
+  if (sampler) {
+    auto metalSampler = std::static_pointer_cast<MetalSampler>(sampler);
+    [renderEncoder setFragmentSamplerState:metalSampler->metalSamplerState() atIndex:textureIndex];
+  }
+}
+
+void MetalRenderPass::setUniformBuffer(unsigned binding, std::shared_ptr<GPUBuffer> buffer,
+                                       size_t offset, size_t size) {
+  if (!renderEncoder || !buffer) {
+    return;
+  }
+  DEBUG_ASSERT(binding < VertexBufferIndexStart);
+  (void)size;  // Metal doesn't need explicit size
+
+  if (binding < MaxUniformBindings && lastUniformBuffers[binding] == buffer.get() &&
+      lastUniformOffsets[binding] == offset) {
+    return;
+  }
+
+  uint32_t visibility = currentPipeline ? currentPipeline->getUniformBlockVisibility(binding)
+                                        : ShaderVisibility::VertexFragment;
+
+  if (binding < MaxUniformBindings && lastUniformBuffers[binding] == buffer.get()) {
+    // Same buffer, only offset changed — use lightweight offset-only update.
+    lastUniformOffsets[binding] = offset;
+    if (visibility & ShaderVisibility::Vertex) {
+      [renderEncoder setVertexBufferOffset:offset atIndex:binding];
+    }
+    if (visibility & ShaderVisibility::Fragment) {
+      [renderEncoder setFragmentBufferOffset:offset atIndex:binding];
+    }
+    return;
+  }
+
+  if (binding < MaxUniformBindings) {
+    lastUniformBuffers[binding] = buffer.get();
+    lastUniformOffsets[binding] = offset;
+  }
+
+  auto metalBuffer = std::static_pointer_cast<MetalBuffer>(buffer);
+
+  // Bind the uniform buffer to the shader stages specified by the pipeline's visibility flags.
+  if (visibility & ShaderVisibility::Vertex) {
+    [renderEncoder setVertexBuffer:metalBuffer->metalBuffer() offset:offset atIndex:binding];
+  }
+  if (visibility & ShaderVisibility::Fragment) {
+    [renderEncoder setFragmentBuffer:metalBuffer->metalBuffer() offset:offset atIndex:binding];
+  }
+}
+
+void MetalRenderPass::setStencilReference(uint32_t reference) {
+  if (!renderEncoder) {
+    return;
+  }
+  [renderEncoder setStencilReferenceValue:reference];
+}
+
+void MetalRenderPass::draw(PrimitiveType primitiveType, uint32_t vertexCount,
+                           uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+  if (!renderEncoder) {
+    return;
+  }
+
+  MTLPrimitiveType metalPrimitiveType = ToMTLPrimitiveType(primitiveType);
+  [renderEncoder drawPrimitives:metalPrimitiveType
+                    vertexStart:firstVertex
+                    vertexCount:vertexCount
+                  instanceCount:instanceCount
+                   baseInstance:firstInstance];
+}
+
+void MetalRenderPass::drawIndexed(PrimitiveType primitiveType, uint32_t indexCount,
+                                  uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex,
+                                  uint32_t firstInstance) {
+  if (!renderEncoder || !indexBuffer) {
+    return;
+  }
+
+  MTLPrimitiveType metalPrimitiveType = ToMTLPrimitiveType(primitiveType);
+
+  // Convert IndexFormat to Metal types
+  MTLIndexType indexType =
+      (indexFormat == IndexFormat::UInt32) ? MTLIndexTypeUInt32 : MTLIndexTypeUInt16;
+  size_t indexSize = (indexFormat == IndexFormat::UInt32) ? sizeof(uint32_t) : sizeof(uint16_t);
+
+  [renderEncoder drawIndexedPrimitives:metalPrimitiveType
+                            indexCount:indexCount
+                             indexType:indexType
+                           indexBuffer:indexBuffer->metalBuffer()
+                     indexBufferOffset:(firstIndex * indexSize)
+                         instanceCount:instanceCount
+                            baseVertex:baseVertex
+                          baseInstance:firstInstance];
+}
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/metal/MetalRenderPipeline.h

@@ -0,0 +1,91 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 <Metal/Metal.h>
+#include <unordered_map>
+#include "MetalResource.h"
+#include "tgfx/gpu/RenderPipeline.h"
+
+namespace tgfx {
+
+class MetalGPU;
+
+/**
+ * Metal render pipeline implementation.
+ */
+class MetalRenderPipeline : public RenderPipeline, public MetalResource {
+ public:
+  static std::shared_ptr<MetalRenderPipeline> Make(MetalGPU* gpu,
+                                                   const RenderPipelineDescriptor& descriptor);
+
+  /**
+   * Returns the Metal render pipeline state.
+   */
+  id<MTLRenderPipelineState> metalRenderPipelineState() const {
+    return pipelineState;
+  }
+
+  /**
+   * Returns the Metal depth stencil state.
+   */
+  id<MTLDepthStencilState> metalDepthStencilState() const {
+    return depthStencilState;
+  }
+
+  /**
+   * Returns the actual Metal texture index for the given logical binding point.
+   * Returns the binding value unchanged if no mapping is found (for custom shaders that set
+   * textures directly without a BindingLayout).
+   */
+  unsigned getTextureIndex(unsigned binding) const;
+
+  /**
+   * Returns the shader stage visibility flags for the given uniform block binding point.
+   * Returns ShaderVisibility::VertexFragment if no mapping is found.
+   */
+  uint32_t getUniformBlockVisibility(unsigned binding) const;
+
+ protected:
+  void onRelease(MetalGPU* gpu) override;
+
+ private:
+  MetalRenderPipeline(MetalGPU* gpu, const RenderPipelineDescriptor& descriptor);
+  ~MetalRenderPipeline() override = default;
+
+  bool createPipelineState(MetalGPU* gpu, const RenderPipelineDescriptor& descriptor);
+  bool createDepthStencilState(id<MTLDevice> device, const RenderPipelineDescriptor& descriptor);
+  static void configureVertexDescriptor(MTLRenderPipelineDescriptor* metalDescriptor,
+                                        const RenderPipelineDescriptor& descriptor);
+  static void configureColorAttachments(MTLRenderPipelineDescriptor* metalDescriptor, MetalGPU* gpu,
+                                        const RenderPipelineDescriptor& descriptor);
+
+  id<MTLRenderPipelineState> pipelineState = nil;
+  id<MTLDepthStencilState> depthStencilState = nil;
+  id<MTLLibrary> sampleMaskLibrary = nil;
+  std::unordered_map<unsigned, unsigned> textureUnits = {};
+  std::unordered_map<unsigned, uint32_t> uniformBlockVisibility = {};
+  MTLCullMode cullMode = MTLCullModeNone;
+  MTLWinding frontFace = MTLWindingCounterClockwise;
+
+  friend class MetalGPU;
+  friend class MetalRenderPass;
+};
+
+}  // namespace tgfx