Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #ifndef GrVkGpu_DEFINED |
| 9 | #define GrVkGpu_DEFINED |
| 10 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 11 | #define USE_SKSL 1 |
| 12 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 13 | #include "GrGpu.h" |
| 14 | #include "GrGpuFactory.h" |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 15 | #include "vk/GrVkBackendContext.h" |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 16 | #include "GrVkCaps.h" |
egdaniel | bc9b296 | 2016-09-27 08:00:53 -0700 | [diff] [blame] | 17 | #include "GrVkCopyManager.h" |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 18 | #include "GrVkIndexBuffer.h" |
jvanverth | 6b6ffc4 | 2016-06-13 14:28:07 -0700 | [diff] [blame] | 19 | #include "GrVkMemory.h" |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 20 | #include "GrVkResourceProvider.h" |
| 21 | #include "GrVkVertexBuffer.h" |
| 22 | #include "GrVkUtil.h" |
| 23 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 24 | #if USE_SKSL |
| 25 | namespace SkSL { |
| 26 | class Compiler; |
| 27 | } |
| 28 | #else |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 29 | #include "shaderc/shaderc.h" |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 30 | #endif |
| 31 | |
jvanverth | e50f3e7 | 2016-03-28 07:03:06 -0700 | [diff] [blame] | 32 | #include "vk/GrVkDefines.h" |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 33 | |
| 34 | class GrPipeline; |
egdaniel | 0e1853c | 2016-03-17 11:35:45 -0700 | [diff] [blame] | 35 | class GrNonInstancedMesh; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 36 | |
| 37 | class GrVkBufferImpl; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 38 | class GrVkPipeline; |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 39 | class GrVkPipelineState; |
egdaniel | 066df7c | 2016-06-08 14:02:27 -0700 | [diff] [blame] | 40 | class GrVkPrimaryCommandBuffer; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 41 | class GrVkRenderPass; |
egdaniel | 066df7c | 2016-06-08 14:02:27 -0700 | [diff] [blame] | 42 | class GrVkSecondaryCommandBuffer; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 43 | class GrVkTexture; |
| 44 | struct GrVkInterface; |
| 45 | |
| 46 | class GrVkGpu : public GrGpu { |
| 47 | public: |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 48 | static GrGpu* Create(GrBackendContext backendContext, const GrContextOptions& options, |
| 49 | GrContext* context); |
| 50 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 51 | ~GrVkGpu() override; |
| 52 | |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 53 | const GrVkInterface* vkInterface() const { return fBackendContext->fInterface; } |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 54 | const GrVkCaps& vkCaps() const { return *fVkCaps; } |
| 55 | |
| 56 | VkDevice device() const { return fDevice; } |
| 57 | VkQueue queue() const { return fQueue; } |
| 58 | VkCommandPool cmdPool() const { return fCmdPool; } |
| 59 | VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties() const { |
| 60 | return fPhysDevMemProps; |
| 61 | } |
| 62 | |
egdaniel | bc9b296 | 2016-09-27 08:00:53 -0700 | [diff] [blame] | 63 | GrVkResourceProvider& resourceProvider() { return fResourceProvider; } |
| 64 | |
| 65 | GrVkPrimaryCommandBuffer* currentCommandBuffer() { return fCurrentCmdBuffer; } |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 66 | |
| 67 | enum SyncQueue { |
| 68 | kForce_SyncQueue, |
| 69 | kSkip_SyncQueue |
| 70 | }; |
| 71 | |
| 72 | bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes, |
| 73 | GrPixelConfig readConfig, DrawPreference*, |
| 74 | ReadPixelTempDrawInfo*) override; |
| 75 | |
| 76 | bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height, |
| 77 | GrPixelConfig srcConfig, DrawPreference*, |
| 78 | WritePixelTempDrawInfo*) override; |
| 79 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 80 | bool onCopySurface(GrSurface* dst, |
| 81 | GrSurface* src, |
| 82 | const SkIRect& srcRect, |
| 83 | const SkIPoint& dstPoint) override; |
| 84 | |
csmartdalton | 0d28e57 | 2016-07-06 09:59:43 -0700 | [diff] [blame] | 85 | void onGetMultisampleSpecs(GrRenderTarget* rt, const GrStencilSettings&, |
| 86 | int* effectiveSampleCnt, SamplePattern*) override; |
cdalton | 28f45b9 | 2016-03-07 13:58:26 -0800 | [diff] [blame] | 87 | |
egdaniel | 4bcd62e | 2016-08-31 07:37:31 -0700 | [diff] [blame] | 88 | bool initDescForDstCopy(const GrRenderTarget* src, GrSurfaceDesc* desc) const override; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 89 | |
| 90 | void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {} |
| 91 | |
| 92 | GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h, |
egdaniel | 0a3a7f7 | 2016-06-24 09:22:31 -0700 | [diff] [blame] | 93 | GrPixelConfig config, |
| 94 | bool isRenderTarget) override; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 95 | bool isTestingOnlyBackendTexture(GrBackendObject id) const override; |
| 96 | void deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandonTexture) override; |
| 97 | |
| 98 | GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*, |
| 99 | int width, |
| 100 | int height) override; |
| 101 | |
egdaniel | 3d5d9ac | 2016-03-01 12:56:15 -0800 | [diff] [blame] | 102 | void clearStencil(GrRenderTarget* target) override; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 103 | |
egdaniel | 9cb6340 | 2016-06-23 08:37:05 -0700 | [diff] [blame] | 104 | GrGpuCommandBuffer* createCommandBuffer( |
| 105 | GrRenderTarget* target, |
| 106 | const GrGpuCommandBuffer::LoadAndStoreInfo& colorInfo, |
| 107 | const GrGpuCommandBuffer::LoadAndStoreInfo& stencilInfo) override; |
egdaniel | 066df7c | 2016-06-08 14:02:27 -0700 | [diff] [blame] | 108 | |
egdaniel | e267893 | 2016-03-24 09:50:58 -0700 | [diff] [blame] | 109 | void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) override {} |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 110 | |
| 111 | void addMemoryBarrier(VkPipelineStageFlags srcStageMask, |
| 112 | VkPipelineStageFlags dstStageMask, |
| 113 | bool byRegion, |
| 114 | VkMemoryBarrier* barrier) const; |
| 115 | void addBufferMemoryBarrier(VkPipelineStageFlags srcStageMask, |
| 116 | VkPipelineStageFlags dstStageMask, |
| 117 | bool byRegion, |
| 118 | VkBufferMemoryBarrier* barrier) const; |
| 119 | void addImageMemoryBarrier(VkPipelineStageFlags srcStageMask, |
| 120 | VkPipelineStageFlags dstStageMask, |
| 121 | bool byRegion, |
| 122 | VkImageMemoryBarrier* barrier) const; |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 123 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 124 | #if USE_SKSL |
| 125 | SkSL::Compiler* shaderCompiler() const { |
| 126 | return fCompiler; |
| 127 | } |
| 128 | #else |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 129 | shaderc_compiler_t shadercCompiler() const { |
| 130 | return fCompiler; |
| 131 | } |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 132 | #endif |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 133 | |
egdaniel | 6693355 | 2016-08-24 07:22:19 -0700 | [diff] [blame] | 134 | void onResolveRenderTarget(GrRenderTarget* target) override; |
| 135 | |
jvanverth | 7ec9241 | 2016-07-06 09:24:57 -0700 | [diff] [blame] | 136 | void submitSecondaryCommandBuffer(GrVkSecondaryCommandBuffer*, |
egdaniel | 9cb6340 | 2016-06-23 08:37:05 -0700 | [diff] [blame] | 137 | const GrVkRenderPass*, |
| 138 | const VkClearValue*, |
| 139 | GrVkRenderTarget*, |
| 140 | const SkIRect& bounds); |
egdaniel | 066df7c | 2016-06-08 14:02:27 -0700 | [diff] [blame] | 141 | |
Robert Phillips | f2361d2 | 2016-10-25 14:20:06 -0400 | [diff] [blame^] | 142 | void finishOpList() override; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 143 | |
jvanverth | 84741b3 | 2016-09-30 08:39:02 -0700 | [diff] [blame] | 144 | GrFence SK_WARN_UNUSED_RESULT insertFence() const override; |
| 145 | bool waitFence(GrFence, uint64_t timeout) const override; |
| 146 | void deleteFence(GrFence) const override; |
| 147 | |
egdaniel | 50ead53 | 2016-07-13 14:23:26 -0700 | [diff] [blame] | 148 | void generateMipmap(GrVkTexture* tex); |
jvanverth | 6234006 | 2016-04-26 08:01:44 -0700 | [diff] [blame] | 149 | |
jvanverth | db37909 | 2016-07-07 11:18:46 -0700 | [diff] [blame] | 150 | bool updateBuffer(GrVkBuffer* buffer, const void* src, VkDeviceSize offset, VkDeviceSize size); |
jvanverth | a584de9 | 2016-06-30 09:10:52 -0700 | [diff] [blame] | 151 | |
jvanverth | 6b6ffc4 | 2016-06-13 14:28:07 -0700 | [diff] [blame] | 152 | // Heaps |
| 153 | enum Heap { |
| 154 | kLinearImage_Heap = 0, |
| 155 | // We separate out small (i.e., <= 16K) images to reduce fragmentation |
| 156 | // in the main heap. |
| 157 | kOptimalImage_Heap, |
| 158 | kSmallOptimalImage_Heap, |
egdaniel | 6693355 | 2016-08-24 07:22:19 -0700 | [diff] [blame] | 159 | // We have separate vertex and image heaps, because it's possible that |
jvanverth | 6b6ffc4 | 2016-06-13 14:28:07 -0700 | [diff] [blame] | 160 | // a given Vulkan driver may allocate them separately. |
| 161 | kVertexBuffer_Heap, |
| 162 | kIndexBuffer_Heap, |
| 163 | kUniformBuffer_Heap, |
| 164 | kCopyReadBuffer_Heap, |
| 165 | kCopyWriteBuffer_Heap, |
| 166 | |
| 167 | kLastHeap = kCopyWriteBuffer_Heap |
| 168 | }; |
| 169 | static const int kHeapCount = kLastHeap + 1; |
| 170 | |
| 171 | GrVkHeap* getHeap(Heap heap) const { return fHeaps[heap]; } |
| 172 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 173 | private: |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 174 | GrVkGpu(GrContext* context, const GrContextOptions& options, |
| 175 | const GrVkBackendContext* backendContext); |
| 176 | |
egdaniel | cfcd181 | 2016-03-22 07:16:10 -0700 | [diff] [blame] | 177 | void onResetContext(uint32_t resetBits) override {} |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 178 | |
kkinnunen | 2e6055b | 2016-04-22 01:48:29 -0700 | [diff] [blame] | 179 | GrTexture* onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, |
bsalomon | a1e6b3b | 2016-03-02 10:58:23 -0800 | [diff] [blame] | 180 | const SkTArray<GrMipLevel>&) override; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 181 | |
kkinnunen | 2e6055b | 2016-04-22 01:48:29 -0700 | [diff] [blame] | 182 | GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, SkBudgeted, |
egdaniel | e267893 | 2016-03-24 09:50:58 -0700 | [diff] [blame] | 183 | const SkTArray<GrMipLevel>&) override { return NULL; } |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 184 | |
| 185 | GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) override; |
| 186 | |
| 187 | GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&, |
| 188 | GrWrapOwnership) override; |
kkinnunen | 49c4c22 | 2016-04-01 04:50:37 -0700 | [diff] [blame] | 189 | GrRenderTarget* onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&) override { return NULL; } |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 190 | |
cdalton | 1bf3e71 | 2016-04-19 10:00:02 -0700 | [diff] [blame] | 191 | GrBuffer* onCreateBuffer(size_t size, GrBufferType type, GrAccessPattern, |
| 192 | const void* data) override; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 193 | |
csmartdalton | e0d3629 | 2016-07-29 08:14:20 -0700 | [diff] [blame] | 194 | gr_instanced::InstancedRendering* onCreateInstancedRendering() override { return nullptr; } |
| 195 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 196 | bool onReadPixels(GrSurface* surface, |
| 197 | int left, int top, int width, int height, |
| 198 | GrPixelConfig, |
| 199 | void* buffer, |
| 200 | size_t rowBytes) override; |
| 201 | |
| 202 | bool onWritePixels(GrSurface* surface, |
| 203 | int left, int top, int width, int height, |
bsalomon | a1e6b3b | 2016-03-02 10:58:23 -0800 | [diff] [blame] | 204 | GrPixelConfig config, const SkTArray<GrMipLevel>&) override; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 205 | |
jvanverth | c3d706f | 2016-04-20 10:33:27 -0700 | [diff] [blame] | 206 | bool onTransferPixels(GrSurface*, |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 207 | int left, int top, int width, int height, |
cdalton | 397536c | 2016-03-25 12:15:03 -0700 | [diff] [blame] | 208 | GrPixelConfig config, GrBuffer* transferBuffer, |
jvanverth | c3d706f | 2016-04-20 10:33:27 -0700 | [diff] [blame] | 209 | size_t offset, size_t rowBytes) override { return false; } |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 210 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 211 | // Ends and submits the current command buffer to the queue and then creates a new command |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 212 | // buffer and begins it. If sync is set to kForce_SyncQueue, the function will wait for all |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 213 | // work in the queue to finish before returning. |
| 214 | void submitCommandBuffer(SyncQueue sync); |
| 215 | |
| 216 | void copySurfaceAsCopyImage(GrSurface* dst, |
| 217 | GrSurface* src, |
egdaniel | 17b8925 | 2016-04-05 07:23:38 -0700 | [diff] [blame] | 218 | GrVkImage* dstImage, |
| 219 | GrVkImage* srcImage, |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 220 | const SkIRect& srcRect, |
| 221 | const SkIPoint& dstPoint); |
| 222 | |
egdaniel | 17b8925 | 2016-04-05 07:23:38 -0700 | [diff] [blame] | 223 | void copySurfaceAsBlit(GrSurface* dst, |
| 224 | GrSurface* src, |
| 225 | GrVkImage* dstImage, |
| 226 | GrVkImage* srcImage, |
| 227 | const SkIRect& srcRect, |
| 228 | const SkIPoint& dstPoint); |
| 229 | |
egdaniel | 4bcd62e | 2016-08-31 07:37:31 -0700 | [diff] [blame] | 230 | void copySurfaceAsResolve(GrSurface* dst, |
| 231 | GrSurface* src, |
| 232 | const SkIRect& srcRect, |
| 233 | const SkIPoint& dstPoint); |
| 234 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 235 | void copySurfaceAsDraw(GrSurface* dst, |
| 236 | GrSurface* src, |
| 237 | const SkIRect& srcRect, |
| 238 | const SkIPoint& dstPoint); |
| 239 | |
jvanverth | 900bd4a | 2016-04-29 13:53:12 -0700 | [diff] [blame] | 240 | // helpers for onCreateTexture and writeTexturePixels |
| 241 | bool uploadTexDataLinear(GrVkTexture* tex, |
| 242 | int left, int top, int width, int height, |
| 243 | GrPixelConfig dataConfig, |
| 244 | const void* data, |
| 245 | size_t rowBytes); |
| 246 | bool uploadTexDataOptimal(GrVkTexture* tex, |
| 247 | int left, int top, int width, int height, |
| 248 | GrPixelConfig dataConfig, |
| 249 | const SkTArray<GrMipLevel>&); |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 250 | |
egdaniel | 4bcd62e | 2016-08-31 07:37:31 -0700 | [diff] [blame] | 251 | void resolveImage(GrVkRenderTarget* dst, |
| 252 | GrVkRenderTarget* src, |
| 253 | const SkIRect& srcRect, |
| 254 | const SkIPoint& dstPoint); |
| 255 | |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 256 | SkAutoTUnref<const GrVkBackendContext> fBackendContext; |
| 257 | SkAutoTUnref<GrVkCaps> fVkCaps; |
| 258 | |
| 259 | // These Vulkan objects are provided by the client, and also stored in fBackendContext. |
| 260 | // They're copied here for convenient access. |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 261 | VkDevice fDevice; |
| 262 | VkQueue fQueue; // Must be Graphics queue |
| 263 | |
| 264 | // Created by GrVkGpu |
| 265 | GrVkResourceProvider fResourceProvider; |
| 266 | VkCommandPool fCmdPool; |
egdaniel | 9a6cf80 | 2016-06-08 08:22:05 -0700 | [diff] [blame] | 267 | GrVkPrimaryCommandBuffer* fCurrentCmdBuffer; |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 268 | VkPhysicalDeviceMemoryProperties fPhysDevMemProps; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 269 | |
jvanverth | 6b6ffc4 | 2016-06-13 14:28:07 -0700 | [diff] [blame] | 270 | SkAutoTDelete<GrVkHeap> fHeaps[kHeapCount]; |
| 271 | |
egdaniel | bc9b296 | 2016-09-27 08:00:53 -0700 | [diff] [blame] | 272 | GrVkCopyManager fCopyManager; |
| 273 | |
egdaniel | 735109c | 2016-07-27 08:03:57 -0700 | [diff] [blame] | 274 | #ifdef SK_ENABLE_VK_LAYERS |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 275 | // For reporting validation layer errors |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 276 | VkDebugReportCallbackEXT fCallback; |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 277 | #endif |
| 278 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 279 | #if USE_SKSL |
| 280 | SkSL::Compiler* fCompiler; |
| 281 | #else |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 282 | // Shaderc compiler used for compiling glsl in spirv. We only want to create the compiler once |
| 283 | // since there is significant overhead to the first compile of any compiler. |
| 284 | shaderc_compiler_t fCompiler; |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 285 | #endif |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 286 | |
| 287 | typedef GrGpu INHERITED; |
| 288 | }; |
| 289 | |
| 290 | #endif |