Changeset 268603 in webkit


Ignore:
Timestamp:
Oct 16, 2020 12:32:39 PM (4 years ago)
Author:
don.olmstead@sony.com
Message:

[WebGPU] Centralize Platform Defines
​https://bugs.webkit.org/show_bug.cgi?id=217725

Reviewed by Myles C. Maxfield.

Centralize all the Metal forward declarations and GPU platform type definitions
into GPUPlatformTypesMetal.h. Each platform implementing WebGPU will have its own
version of the file which contains the same definitions. This file is then
referenced by GPUPlatformTypes.h.

This is in preparation for adding a Dawn based implementation which requires
more substantial definitions than the Metal backend.

No new tests. No change in behavior.

  • WebCore.xcodeproj/project.pbxproj:
  • platform/graphics/gpu/GPUBindGroup.h:
  • platform/graphics/gpu/GPUBindGroupAllocator.h:
  • platform/graphics/gpu/GPUBindGroupLayout.h:
  • platform/graphics/gpu/GPUBuffer.h:

(WebCore::GPUBuffer::platformBuffer const):

  • platform/graphics/gpu/GPUCommandBuffer.h:
  • platform/graphics/gpu/GPUComputePassEncoder.h:
  • platform/graphics/gpu/GPUComputePipeline.h:
  • platform/graphics/gpu/GPUDevice.h:
  • platform/graphics/gpu/GPUPlatformTypes.h: Added.
  • platform/graphics/gpu/GPUProgrammablePassEncoder.h:
  • platform/graphics/gpu/GPUQueue.h:
  • platform/graphics/gpu/GPURenderPassEncoder.h:
  • platform/graphics/gpu/GPURenderPipeline.h:
  • platform/graphics/gpu/GPUSampler.h:
  • platform/graphics/gpu/GPUShaderModule.h:
  • platform/graphics/gpu/GPUSwapChain.h:
  • platform/graphics/gpu/GPUTexture.h:
  • platform/graphics/gpu/cocoa/GPUPlatformTypesMetal.h: Added.
Location:
trunk/Source/WebCore
Files:
1 added
18 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r268600 r268603  
     12020-10-16  Don Olmstead  <don.olmstead@sony.com>
     2
     3        [WebGPU] Centralize Platform Defines
     4        https://bugs.webkit.org/show_bug.cgi?id=217725
     5
     6        Reviewed by Myles C. Maxfield.
     7
     8        Centralize all the Metal forward declarations and GPU platform type definitions
     9        into GPUPlatformTypesMetal.h. Each platform implementing WebGPU will have its own
     10        version of the file which contains the same definitions. This file is then
     11        referenced by GPUPlatformTypes.h.
     12
     13        This is in preparation for adding a Dawn based implementation which requires
     14        more substantial definitions than the Metal backend.
     15
     16        No new tests. No change in behavior.
     17
     18        * WebCore.xcodeproj/project.pbxproj:
     19        * platform/graphics/gpu/GPUBindGroup.h:
     20        * platform/graphics/gpu/GPUBindGroupAllocator.h:
     21        * platform/graphics/gpu/GPUBindGroupLayout.h:
     22        * platform/graphics/gpu/GPUBuffer.h:
     23        (WebCore::GPUBuffer::platformBuffer const):
     24        * platform/graphics/gpu/GPUCommandBuffer.h:
     25        * platform/graphics/gpu/GPUComputePassEncoder.h:
     26        * platform/graphics/gpu/GPUComputePipeline.h:
     27        * platform/graphics/gpu/GPUDevice.h:
     28        * platform/graphics/gpu/GPUPlatformTypes.h: Added.
     29        * platform/graphics/gpu/GPUProgrammablePassEncoder.h:
     30        * platform/graphics/gpu/GPUQueue.h:
     31        * platform/graphics/gpu/GPURenderPassEncoder.h:
     32        * platform/graphics/gpu/GPURenderPipeline.h:
     33        * platform/graphics/gpu/GPUSampler.h:
     34        * platform/graphics/gpu/GPUShaderModule.h:
     35        * platform/graphics/gpu/GPUSwapChain.h:
     36        * platform/graphics/gpu/GPUTexture.h:
     37        * platform/graphics/gpu/cocoa/GPUPlatformTypesMetal.h: Added.
     38
    1392020-10-16  Chris Dumez  <cdumez@apple.com>
    240

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r268578 r268603  
    1216112161                A37A42E22527B49D00F75AFF /* EXTTextureCompressionRGTC.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EXTTextureCompressionRGTC.h; sourceTree = "<group>"; };
    1216212162                A37A42E32527B49E00F75AFF /* EXTTextureCompressionRGTC.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = EXTTextureCompressionRGTC.idl; sourceTree = "<group>"; };
     12163                A38A87A32538BEE70037A472 /* GPUPlatformTypesMetal.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GPUPlatformTypesMetal.h; sourceTree = "<group>"; };
     12164                A3C3DC5D253A19920061F32A /* GPUPlatformTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GPUPlatformTypes.h; sourceTree = "<group>"; };
    1216312165                A3AF9D81203252EE006CAD06 /* UserAgentCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = UserAgentCocoa.mm; sourceTree = "<group>"; };
    1216412166                A3AF9D8220325324006CAD06 /* UserAgent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UserAgent.h; sourceTree = "<group>"; };
    … …  
    1967319675                                D003288621C9A4E500622AA6 /* GPUPipelineLayout.h */,
    1967419676                                D003288421C9A20D00622AA6 /* GPUPipelineLayoutDescriptor.h */,
     19677                                A3C3DC5D253A19920061F32A /* GPUPlatformTypes.h */,
    1967519678                                D003914122248D400098998C /* GPUProgrammablePassEncoder.cpp */,
    1967619679                                D03211CF21AC954E00763CF2 /* GPUProgrammablePassEncoder.h */,
    … …  
    2786227865                                1C86CA4E22AA23C9001BF961 /* GPUPipelineMetalConvertLayout.cpp */,
    2786327866                                1C86CA4F22AA23C9001BF961 /* GPUPipelineMetalConvertLayout.h */,
     27867                                A38A87A32538BEE70037A472 /* GPUPlatformTypesMetal.h */,
    2786427868                                D087CE3B21ACA94200BDE174 /* GPUProgrammablePassEncoderMetal.mm */,
    2786527869                                D087CE3921ACA94200BDE174 /* GPUQueueMetal.mm */,

  • trunk/Source/WebCore/platform/graphics/gpu/GPUBindGroup.h

    r267777 r268603  
    3030#include "GPUBindGroupAllocator.h"
    3131#include "GPUBuffer.h"
     32#include "GPUPlatformTypes.h"
    3233#include "GPUTexture.h"
    3334#include <utility>
    … …  
    3536#include <wtf/RefCounted.h>
    3637#include <wtf/RefPtr.h>
    37 
    38 #if USE(METAL)
    39 #include <objc/NSObjCRuntime.h>
    40 #include <wtf/RetainPtr.h>
    41 #endif
    42 
    43 #if USE(METAL)
    44 OBJC_PROTOCOL(MTLBuffer);
    45 #endif
    4638
    4739namespace WebCore {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUBindGroupAllocator.h

    r267777 r268603  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "GPUBuffer.h"
     31#include "GPUPlatformTypes.h"
    3032#include <wtf/Optional.h>
    3133#include <wtf/Ref.h>
    3234#include <wtf/RefCounted.h>
    33 
    34 #if USE(METAL)
    35 #include <objc/NSObjCRuntime.h>
    36 #include <wtf/RetainPtr.h>
    37 #endif
    38 
    39 #if USE(METAL)
    40 OBJC_PROTOCOL(MTLArgumentEncoder);
    41 OBJC_PROTOCOL(MTLBuffer);
    42 #endif
    4335
    4436namespace WebCore {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUBindGroupLayout.h

    r267777 r268603  
    2929
    3030#include "GPUBindGroupLayoutDescriptor.h"
     31#include "GPUPlatformTypes.h"
    3132#include <wtf/HashMap.h>
    3233#include <wtf/RefCounted.h>
    3334#include <wtf/RefPtr.h>
    3435#include <wtf/Variant.h>
    35 
    36 #if USE(METAL)
    37 #include <wtf/RetainPtr.h>
    38 #endif
    39 
    40 #if USE(METAL)
    41 OBJC_PROTOCOL(MTLArgumentEncoder);
    42 OBJC_PROTOCOL(MTLBuffer);
    43 #endif // USE(METAL)
    4436
    4537namespace WebCore {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUBuffer.h

    r267777 r268603  
    3030#include "DeferrableTask.h"
    3131#include "GPUBufferUsage.h"
     32#include "GPUPlatformTypes.h"
    3233#include <wtf/Function.h>
    3334#include <wtf/OptionSet.h>
    … …  
    3536#include <wtf/RefCounted.h>
    3637#include <wtf/Vector.h>
    37 
    38 #if USE(METAL)
    39 #include <wtf/RetainPtr.h>
    40 #endif
    41 
    42 #if USE(METAL)
    43 OBJC_PROTOCOL(MTLBuffer);
    44 OBJC_PROTOCOL(MTLCommandBuffer);
    45 #endif
    4638
    4739namespace JSC {
    … …  
    5850enum class GPUBufferMappedOption;
    5951
    60 #if USE(METAL)
    61 using PlatformBuffer = MTLBuffer;
    62 using PlatformBufferSmartPtr = RetainPtr<MTLBuffer>;
    63 #endif
    64 
    6552class GPUBuffer : public RefCounted<GPUBuffer> {
    6653public:
    … …  
    7562    static RefPtr<GPUBuffer> tryCreate(GPUDevice&, const GPUBufferDescriptor&, GPUBufferMappedOption, GPUErrorScopes&);
    7663
    77     PlatformBuffer *platformBuffer() const { return m_platformBuffer.get(); }
     64    PlatformBuffer* platformBuffer() const { return m_platformBuffer.get(); }
    7865    size_t byteLength() const { return m_byteLength; }
    7966    bool isCopySource() const { return m_usage.contains(GPUBufferUsage::Flags::CopySource); }

  • trunk/Source/WebCore/platform/graphics/gpu/GPUCommandBuffer.h

    r267777 r268603  
    3030#include "GPUBuffer.h"
    3131#include "GPUOrigin3D.h"
     32#include "GPUPlatformTypes.h"
    3233#include "GPUTexture.h"
    3334#include <wtf/HashSet.h>
    3435#include <wtf/RefCounted.h>
    3536#include <wtf/RefPtr.h>
    36 
    37 #if USE(METAL)
    38 #include <wtf/RetainPtr.h>
    39 #endif
    40 
    41 #if USE(METAL)
    42 OBJC_PROTOCOL(MTLBlitCommandEncoder);
    43 OBJC_PROTOCOL(MTLCommandBuffer);
    44 #endif
    4537
    4638namespace WebCore {
    … …  
    4941
    5042struct GPUExtent3D;
    51 
    52 #if USE(METAL)
    53 using PlatformCommandBuffer = MTLCommandBuffer;
    54 using PlatformCommandBufferSmartPtr = RetainPtr<MTLCommandBuffer>;
    55 #endif
    5643
    5744struct GPUBufferCopyViewBase {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUComputePassEncoder.h

    r267777 r268603  
    3333#include <wtf/RefPtr.h>
    3434
    35 #if USE(METAL)
    36 #include <wtf/RetainPtr.h>
    37 #endif
    38 
    39 #if USE(METAL)
    40 OBJC_PROTOCOL(MTLComputeCommandEncoder);
    41 #endif
    42 
    4335namespace WebCore {
    44 
    45 #if USE(METAL)
    46 using PlatformComputePassEncoder = MTLComputeCommandEncoder;
    47 using PlatformComputePassEncoderSmartPtr = RetainPtr<MTLComputeCommandEncoder>;
    48 #endif
    4936
    5037class GPUComputePassEncoder : public GPUProgrammablePassEncoder {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUComputePipeline.h

    r267777 r268603  
    2929
    3030#include "GPUPipeline.h"
     31#include "GPUPlatformTypes.h"
    3132#include "GPUProgrammableStageDescriptor.h"
    3233#include <wtf/RefCounted.h>
    … …  
    3536#if ENABLE(WHLSL_COMPILER)
    3637#include "WHLSLPrepare.h"
    37 #endif
    38 
    39 #if USE(METAL)
    40 #include <wtf/RetainPtr.h>
    41 #endif
    42 
    43 #if USE(METAL)
    44 OBJC_PROTOCOL(MTLComputePipelineState);
    4538#endif
    4639
    … …  
    5245
    5346struct GPUComputePipelineDescriptor;
    54 
    55 #if USE(METAL)
    56 using PlatformComputePipeline = MTLComputePipelineState;
    57 using PlatformComputePipelineSmartPtr = RetainPtr<MTLComputePipelineState>;
    58 #endif
    5947
    6048class GPUComputePipeline final : public GPUPipeline {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUDevice.h

    r267777 r268603  
    3030#include "GPUBindGroupAllocator.h"
    3131#include "GPUErrorScopes.h"
     32#include "GPUPlatformTypes.h"
    3233#include "GPUQueue.h"
    3334#include "GPUSwapChain.h"
    … …  
    3839#include <wtf/RefPtr.h>
    3940#include <wtf/WeakPtr.h>
    40 
    41 #if USE(METAL)
    42 #include <wtf/RetainPtr.h>
    43 #endif
    44 
    45 #if USE(METAL)
    46 OBJC_PROTOCOL(MTLDevice);
    47 #endif
    4841
    4942namespace WebCore {
    … …  
    7467
    7568enum class GPUBufferMappedOption;
    76 
    77 #if USE(METAL)
    78 using PlatformDevice = MTLDevice;
    79 using PlatformDeviceSmartPtr = RetainPtr<MTLDevice>;
    80 #endif
    8169
    8270class GPUDevice : public RefCounted<GPUDevice>, public CanMakeWeakPtr<GPUDevice> {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUPlatformTypes.h

    r268602 r268603  
    11/*
    2  * Copyright (C) 2019 Apple Inc. All rights reserved.
     2 * Copyright (C) 2020 Sony Interactive Entertainment Inc.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2626#pragma once
    2727
    28 #if ENABLE(WEBGPU)
    29 
    30 #include <wtf/RefCounted.h>
    31 #include <wtf/RefPtr.h>
    32 
    3328#if USE(METAL)
    34 #include <wtf/RetainPtr.h>
     29#include "GPUPlatformTypesMetal.h"
     30#else
     31#error "Unsupported platform for WebGPU"
    3532#endif
    36 
    37 #if USE(METAL)
    38 OBJC_PROTOCOL(MTLSamplerState);
    39 #endif
    40 
    41 namespace WebCore {
    42 
    43 class GPUDevice;
    44 
    45 struct GPUSamplerDescriptor;
    46 
    47 #if USE(METAL)
    48 using PlatformSampler = MTLSamplerState;
    49 using PlatformSamplerSmartPtr = RetainPtr<MTLSamplerState>;
    50 #endif
    51 
    52 class GPUSampler : public RefCounted<GPUSampler> {
    53 public:
    54     static RefPtr<GPUSampler> tryCreate(const GPUDevice&, const GPUSamplerDescriptor&);
    55 
    56     PlatformSampler* platformSampler() const { return m_platformSampler.get(); }
    57 
    58 private:
    59     GPUSampler(PlatformSamplerSmartPtr&&);
    60 
    61     PlatformSamplerSmartPtr m_platformSampler;
    62 };
    63 
    64 } // namespace WebCore
    65 
    66 #endif // ENABLE(WEBGPU)

  • trunk/Source/WebCore/platform/graphics/gpu/GPUProgrammablePassEncoder.h

    r267777 r268603  
    3030#include "GPUBindGroupBinding.h"
    3131#include "GPUCommandBuffer.h"
     32#include "GPUPlatformTypes.h"
    3233#include <wtf/RefCounted.h>
    33 
    34 #if USE(METAL)
    35 #include <objc/NSObjCRuntime.h>
    36 #endif
    37 
    38 #if USE(METAL)
    39 OBJC_PROTOCOL(MTLBuffer);
    40 OBJC_PROTOCOL(MTLCommandEncoder);
    41 OBJC_PROTOCOL(MTLResource);
    42 #endif
    4334
    4435namespace WebCore {
    … …  
    4637class GPUBindGroup;
    4738class GPURenderPipeline;
    48 
    49 #if USE(METAL)
    50 using PlatformProgrammablePassEncoder = MTLCommandEncoder;
    51 #endif
    5239
    5340class GPUProgrammablePassEncoder : public RefCounted<GPUProgrammablePassEncoder> {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUQueue.h

    r267777 r268603  
    2929
    3030#include "DeferrableTask.h"
     31#include "GPUPlatformTypes.h"
    3132#include <wtf/RefCounted.h>
    3233#include <wtf/RefPtr.h>
    … …  
    3435#include <wtf/WeakPtr.h>
    3536
    36 #if USE(METAL)
    37 #include <wtf/RetainPtr.h>
    38 #endif
    39 
    40 #if USE(METAL)
    41 OBJC_PROTOCOL(MTLCommandQueue);
    42 #endif
    43 
    4437namespace WebCore {
    45 
    46 #if USE(METAL)
    47 using PlatformQueue = MTLCommandQueue;
    48 using PlatformQueueSmartPtr = RetainPtr<MTLCommandQueue>;
    49 #endif
    5038
    5139class GPUCommandBuffer;

  • trunk/Source/WebCore/platform/graphics/gpu/GPURenderPassEncoder.h

    r267777 r268603  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "GPUPlatformTypes.h"
    3031#include "GPUProgrammablePassEncoder.h"
    3132#include "GPURenderPipeline.h"
    32 
    3333#include <wtf/RefCounted.h>
    3434#include <wtf/RefPtr.h>
    3535#include <wtf/Vector.h>
    36 
    37 #if USE(METAL)
    38 #include <wtf/RetainPtr.h>
    39 #endif
    40 
    41 #if USE(METAL)
    42 OBJC_PROTOCOL(MTLRenderCommandEncoder);
    43 #endif
    4436
    4537namespace WebCore {
    … …  
    5042struct GPUColor;
    5143struct GPURenderPassDescriptor;
    52 
    53 #if USE(METAL)
    54 using PlatformRenderPassEncoder = MTLRenderCommandEncoder;
    55 using PlatformRenderPassEncoderSmartPtr = RetainPtr<MTLRenderCommandEncoder>;
    56 #endif
    5744
    5845class GPURenderPassEncoder : public GPUProgrammablePassEncoder {

  • trunk/Source/WebCore/platform/graphics/gpu/GPURenderPipeline.h

    r267777 r268603  
    2929
    3030#include "GPUPipeline.h"
     31#include "GPUPlatformTypes.h"
    3132#include "GPUProgrammableStageDescriptor.h"
    3233#include "GPURenderPipelineDescriptor.h"
    … …  
    3536#include <wtf/RefPtr.h>
    3637
    37 #if USE(METAL)
    38 #include <wtf/RetainPtr.h>
    39 #endif
    40 
    41 #if USE(METAL)
    42 OBJC_PROTOCOL(MTLDepthStencilState);
    43 OBJC_PROTOCOL(MTLRenderPipelineState);
    44 #endif
    45 
    4638namespace WebCore {
    4739
    4840class GPUDevice;
    4941class GPUErrorScopes;
    50 
    51 #if USE(METAL)
    52 using PlatformRenderPipeline = MTLRenderPipelineState;
    53 using PlatformRenderPipelineSmartPtr = RetainPtr<MTLRenderPipelineState>;
    54 #endif
    5542
    5643class GPURenderPipeline final : public GPUPipeline {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUSampler.h

    r267777 r268603  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "GPUPlatformTypes.h"
    3031#include <wtf/RefCounted.h>
    3132#include <wtf/RefPtr.h>
    32 
    33 #if USE(METAL)
    34 #include <wtf/RetainPtr.h>
    35 #endif
    36 
    37 #if USE(METAL)
    38 OBJC_PROTOCOL(MTLSamplerState);
    39 #endif
    4033
    4134namespace WebCore {
    … …  
    4437
    4538struct GPUSamplerDescriptor;
    46 
    47 #if USE(METAL)
    48 using PlatformSampler = MTLSamplerState;
    49 using PlatformSamplerSmartPtr = RetainPtr<MTLSamplerState>;
    50 #endif
    5139
    5240class GPUSampler : public RefCounted<GPUSampler> {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUShaderModule.h

    r267777 r268603  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "GPUPlatformTypes.h"
    3031#include "WHLSLPrepare.h"
    3132#include <wtf/RefCounted.h>
    3233#include <wtf/RefPtr.h>
    33 
    34 #if USE(METAL)
    35 #include <wtf/RetainPtr.h>
    36 #endif
    37 
    38 #if USE(METAL)
    39 OBJC_PROTOCOL(MTLLibrary);
    40 #endif
    4134
    4235namespace WebCore {
    … …  
    4538
    4639struct GPUShaderModuleDescriptor;
    47 
    48 #if USE(METAL)
    49 using PlatformShaderModule = MTLLibrary;
    50 using PlatformShaderModuleSmartPtr = RetainPtr<MTLLibrary>;
    51 #endif
    5240
    5341class GPUShaderModule : public RefCounted<GPUShaderModule> {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUSwapChain.h

    r267777 r268603  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "GPUPlatformTypes.h"
    3031#include "GPUTexture.h"
    3132#include "PlatformLayer.h"
    … …  
    4243#endif
    4344
    44 #if USE(METAL)
    45 #include <wtf/RetainPtr.h>
    46 #endif
    47 
    48 #if USE(METAL)
    49 OBJC_CLASS CAMetalDrawable;
    50 OBJC_CLASS WebGPULayer;
    51 #endif
    52 
    5345namespace WebCore {
    5446
    … …  
    5850
    5951enum class GPUTextureFormat;
    60 
    61 #if USE(METAL)
    62 using PlatformDrawableSmartPtr = RetainPtr<CAMetalDrawable>;
    63 using PlatformSwapLayerSmartPtr = RetainPtr<WebGPULayer>;
    64 #endif
    6552
    6653class GPUSwapChain : public RefCounted<GPUSwapChain> {

  • trunk/Source/WebCore/platform/graphics/gpu/GPUTexture.h

    r267777 r268603  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "GPUPlatformTypes.h"
    3031#include "GPUTextureUsage.h"
    3132#include <wtf/OptionSet.h>
    3233#include <wtf/RefCounted.h>
    3334#include <wtf/RefPtr.h>
    34 
    35 #if USE(METAL)
    36 #include <wtf/RetainPtr.h>
    37 #endif
    38 
    39 #if USE(METAL)
    40 OBJC_PROTOCOL(MTLTexture);
    41 #endif
    4235
    4336namespace WebCore {
    … …  
    4740
    4841struct GPUTextureDescriptor;
    49 
    50 #if USE(METAL)
    51 using PlatformTexture = MTLTexture;
    52 using PlatformTextureSmartPtr = RetainPtr<MTLTexture>;
    53 #endif
    5442
    5543class GPUTexture : public RefCounted<GPUTexture> {
Note: See TracChangeset for help on using the changeset viewer.