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 11 #define USE_SKSL 1 12 13 #include "GrGpu.h" 14 #include "GrGpuFactory.h" 15 #include "vk/GrVkBackendContext.h" 16 #include "GrVkCaps.h" 17 #include "GrVkCopyManager.h" 18 #include "GrVkIndexBuffer.h" 19 #include "GrVkMemory.h" 20 #include "GrVkResourceProvider.h" 21 #include "GrVkVertexBuffer.h" 22 #include "GrVkUtil.h" 23 24 #if USE_SKSL 25 namespace SkSL { 26 class Compiler; 27 } 28 #else 29 #include "shaderc/shaderc.h" 30 #endif 31 32 #include "vk/GrVkDefines.h" 33 34 class GrPipeline; 35 class GrNonInstancedMesh; 36 37 class GrVkBufferImpl; 38 class GrVkPipeline; 39 class GrVkPipelineState; 40 class GrVkPrimaryCommandBuffer; 41 class GrVkRenderPass; 42 class GrVkSecondaryCommandBuffer; 43 class GrVkTexture; 44 struct GrVkInterface; 45 46 class GrVkGpu : public GrGpu { 47 public: 48 static GrGpu* Create(GrBackendContext backendContext, const GrContextOptions& options, 49 GrContext* context); 50 51 ~GrVkGpu() override; 52 vkInterface()53 const GrVkInterface* vkInterface() const { return fBackendContext->fInterface; } vkCaps()54 const GrVkCaps& vkCaps() const { return *fVkCaps; } 55 device()56 VkDevice device() const { return fDevice; } queue()57 VkQueue queue() const { return fQueue; } cmdPool()58 VkCommandPool cmdPool() const { return fCmdPool; } physicalDeviceMemoryProperties()59 VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties() const { 60 return fPhysDevMemProps; 61 } 62 resourceProvider()63 GrVkResourceProvider& resourceProvider() { return fResourceProvider; } 64 currentCommandBuffer()65 GrVkPrimaryCommandBuffer* currentCommandBuffer() { return fCurrentCmdBuffer; } 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 80 bool onCopySurface(GrSurface* dst, 81 GrSurface* src, 82 const SkIRect& srcRect, 83 const SkIPoint& dstPoint) override; 84 85 void onGetMultisampleSpecs(GrRenderTarget* rt, const GrStencilSettings&, 86 int* effectiveSampleCnt, SamplePattern*) override; 87 88 bool initDescForDstCopy(const GrRenderTarget* src, GrSurfaceDesc* desc) const override; 89 xferBarrier(GrRenderTarget *,GrXferBarrierType)90 void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {} 91 92 GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h, 93 GrPixelConfig config, 94 bool isRenderTarget) override; 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 102 void clearStencil(GrRenderTarget* target) override; 103 104 GrGpuCommandBuffer* createCommandBuffer( 105 GrRenderTarget* target, 106 const GrGpuCommandBuffer::LoadAndStoreInfo& colorInfo, 107 const GrGpuCommandBuffer::LoadAndStoreInfo& stencilInfo) override; 108 drawDebugWireRect(GrRenderTarget *,const SkIRect &,GrColor)109 void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) override {} 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; 123 124 #if USE_SKSL shaderCompiler()125 SkSL::Compiler* shaderCompiler() const { 126 return fCompiler; 127 } 128 #else shadercCompiler()129 shaderc_compiler_t shadercCompiler() const { 130 return fCompiler; 131 } 132 #endif 133 134 void onResolveRenderTarget(GrRenderTarget* target) override; 135 136 void submitSecondaryCommandBuffer(GrVkSecondaryCommandBuffer*, 137 const GrVkRenderPass*, 138 const VkClearValue*, 139 GrVkRenderTarget*, 140 const SkIRect& bounds); 141 142 void finishDrawTarget() override; 143 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 148 void generateMipmap(GrVkTexture* tex); 149 150 bool updateBuffer(GrVkBuffer* buffer, const void* src, VkDeviceSize offset, VkDeviceSize size); 151 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, 159 // We have separate vertex and image heaps, because it's possible that 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 getHeap(Heap heap)171 GrVkHeap* getHeap(Heap heap) const { return fHeaps[heap]; } 172 173 private: 174 GrVkGpu(GrContext* context, const GrContextOptions& options, 175 const GrVkBackendContext* backendContext); 176 onResetContext(uint32_t resetBits)177 void onResetContext(uint32_t resetBits) override {} 178 179 GrTexture* onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, 180 const SkTArray<GrMipLevel>&) override; 181 onCreateCompressedTexture(const GrSurfaceDesc & desc,SkBudgeted,const SkTArray<GrMipLevel> &)182 GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, SkBudgeted, 183 const SkTArray<GrMipLevel>&) override { return NULL; } 184 185 GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) override; 186 187 GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&, 188 GrWrapOwnership) override; onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc &)189 GrRenderTarget* onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&) override { return NULL; } 190 191 GrBuffer* onCreateBuffer(size_t size, GrBufferType type, GrAccessPattern, 192 const void* data) override; 193 onCreateInstancedRendering()194 gr_instanced::InstancedRendering* onCreateInstancedRendering() override { return nullptr; } 195 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, 204 GrPixelConfig config, const SkTArray<GrMipLevel>&) override; 205 onTransferPixels(GrSurface *,int left,int top,int width,int height,GrPixelConfig config,GrBuffer * transferBuffer,size_t offset,size_t rowBytes)206 bool onTransferPixels(GrSurface*, 207 int left, int top, int width, int height, 208 GrPixelConfig config, GrBuffer* transferBuffer, 209 size_t offset, size_t rowBytes) override { return false; } 210 211 // Ends and submits the current command buffer to the queue and then creates a new command 212 // buffer and begins it. If sync is set to kForce_SyncQueue, the function will wait for all 213 // work in the queue to finish before returning. 214 void submitCommandBuffer(SyncQueue sync); 215 216 void copySurfaceAsCopyImage(GrSurface* dst, 217 GrSurface* src, 218 GrVkImage* dstImage, 219 GrVkImage* srcImage, 220 const SkIRect& srcRect, 221 const SkIPoint& dstPoint); 222 223 void copySurfaceAsBlit(GrSurface* dst, 224 GrSurface* src, 225 GrVkImage* dstImage, 226 GrVkImage* srcImage, 227 const SkIRect& srcRect, 228 const SkIPoint& dstPoint); 229 230 void copySurfaceAsResolve(GrSurface* dst, 231 GrSurface* src, 232 const SkIRect& srcRect, 233 const SkIPoint& dstPoint); 234 235 void copySurfaceAsDraw(GrSurface* dst, 236 GrSurface* src, 237 const SkIRect& srcRect, 238 const SkIPoint& dstPoint); 239 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>&); 250 251 void resolveImage(GrVkRenderTarget* dst, 252 GrVkRenderTarget* src, 253 const SkIRect& srcRect, 254 const SkIPoint& dstPoint); 255 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. 261 VkDevice fDevice; 262 VkQueue fQueue; // Must be Graphics queue 263 264 // Created by GrVkGpu 265 GrVkResourceProvider fResourceProvider; 266 VkCommandPool fCmdPool; 267 GrVkPrimaryCommandBuffer* fCurrentCmdBuffer; 268 VkPhysicalDeviceMemoryProperties fPhysDevMemProps; 269 270 SkAutoTDelete<GrVkHeap> fHeaps[kHeapCount]; 271 272 GrVkCopyManager fCopyManager; 273 274 #ifdef SK_ENABLE_VK_LAYERS 275 // For reporting validation layer errors 276 VkDebugReportCallbackEXT fCallback; 277 #endif 278 279 #if USE_SKSL 280 SkSL::Compiler* fCompiler; 281 #else 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; 285 #endif 286 287 typedef GrGpu INHERITED; 288 }; 289 290 #endif 291