src/gpu/vk/GrVkGpu.h - platform/external/skia - Gitiles

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #ifndef GrVkGpu_DEFINED
 #define GrVkGpu_DEFINED

 #include "GrGpu.h"
 #include "GrGpuFactory.h"
 #include "vk/GrVkBackendContext.h"
 #include "GrVkCaps.h"
 #include "GrVkCopyManager.h"
 #include "GrVkIndexBuffer.h"
 #include "GrVkMemory.h"
 #include "GrVkResourceProvider.h"
 #include "GrVkSemaphore.h"
 #include "GrVkVertexBuffer.h"
 #include "GrVkUtil.h"
 #include "vk/GrVkDefines.h"

 class GrPipeline;
 class GrNonInstancedMesh;

 class GrVkBufferImpl;
 class GrVkPipeline;
 class GrVkPipelineState;
 class GrVkPrimaryCommandBuffer;
 class GrVkRenderPass;
 class GrVkSecondaryCommandBuffer;
 class GrVkTexture;
 struct GrVkInterface;

 namespace SkSL {
     class Compiler;
 }

 class GrVkGpu : public GrGpu {
 public:
     static GrGpu* Create(GrBackendContext backendContext, const GrContextOptions& options,
                          GrContext* context);

     ~GrVkGpu() override;

     const GrVkInterface* vkInterface() const { return fBackendContext->fInterface.get(); }
     const GrVkCaps& vkCaps() const { return *fVkCaps; }

     VkDevice device() const { return fDevice; }
     VkQueue  queue() const { return fQueue; }
     VkCommandPool cmdPool() const { return fCmdPool; }
     VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties() const {
         return fPhysDevMemProps;
     }

     GrVkResourceProvider& resourceProvider() { return fResourceProvider; }

     GrVkPrimaryCommandBuffer* currentCommandBuffer() { return fCurrentCmdBuffer; }

     enum SyncQueue {
         kForce_SyncQueue,
         kSkip_SyncQueue
     };

     bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
                              GrPixelConfig readConfig, DrawPreference*,
                              ReadPixelTempDrawInfo*) override;

     bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
                               GrPixelConfig srcConfig, DrawPreference*,
                               WritePixelTempDrawInfo*) override;

     bool onCopySurface(GrSurface* dst,
                        GrSurface* src,
                        const SkIRect& srcRect,
                        const SkIPoint& dstPoint) override;

     void onQueryMultisampleSpecs(GrRenderTarget* rt, const GrStencilSettings&,
                                  int* effectiveSampleCnt, SamplePattern*) override;

     void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {}

     GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h,
                                                     GrPixelConfig config,
                                                     bool isRenderTarget) override;
     bool isTestingOnlyBackendTexture(GrBackendObject id) const override;
     void deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandonTexture) override;

     GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
                                                                 int width,
                                                                 int height) override;

     void clearStencil(GrRenderTarget* target) override;

     GrGpuCommandBuffer* createCommandBuffer(
             const GrGpuCommandBuffer::LoadAndStoreInfo& colorInfo,
             const GrGpuCommandBuffer::LoadAndStoreInfo& stencilInfo) override;

     void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) override {}

     void addMemoryBarrier(VkPipelineStageFlags srcStageMask,
                           VkPipelineStageFlags dstStageMask,
                           bool byRegion,
                           VkMemoryBarrier* barrier) const;
     void addBufferMemoryBarrier(VkPipelineStageFlags srcStageMask,
                                 VkPipelineStageFlags dstStageMask,
                                 bool byRegion,
                                 VkBufferMemoryBarrier* barrier) const;
     void addImageMemoryBarrier(VkPipelineStageFlags srcStageMask,
                                VkPipelineStageFlags dstStageMask,
                                bool byRegion,
                                VkImageMemoryBarrier* barrier) const;

     SkSL::Compiler* shaderCompiler() const {
         return fCompiler;
     }

     void onResolveRenderTarget(GrRenderTarget* target) override {
         this->internalResolveRenderTarget(target, true);
     }

     void submitSecondaryCommandBuffer(const SkTArray<GrVkSecondaryCommandBuffer*>&,
                                       const GrVkRenderPass*,
                                       const VkClearValue*,
                                       GrVkRenderTarget*,
                                       const SkIRect& bounds);

     void finishOpList() override;

     GrFence SK_WARN_UNUSED_RESULT insertFence() override;
     bool waitFence(GrFence, uint64_t timeout) override;
     void deleteFence(GrFence) const override;

     sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT makeSemaphore() override;
     void insertSemaphore(sk_sp<GrSemaphore> semaphore) override;
     void waitSemaphore(sk_sp<GrSemaphore> semaphore) override;

     void flush() override;

     void generateMipmap(GrVkTexture* tex);

     bool updateBuffer(GrVkBuffer* buffer, const void* src, VkDeviceSize offset, VkDeviceSize size);

     // Heaps
     enum Heap {
         kLinearImage_Heap = 0,
         // We separate out small (i.e., <= 16K) images to reduce fragmentation
         // in the main heap.
         kOptimalImage_Heap,
         kSmallOptimalImage_Heap,
         // We have separate vertex and image heaps, because it's possible that
         // a given Vulkan driver may allocate them separately.
         kVertexBuffer_Heap,
         kIndexBuffer_Heap,
         kUniformBuffer_Heap,
         kCopyReadBuffer_Heap,
         kCopyWriteBuffer_Heap,

         kLastHeap = kCopyWriteBuffer_Heap
     };
     static const int kHeapCount = kLastHeap + 1;

     GrVkHeap* getHeap(Heap heap) const { return fHeaps[heap].get(); }

 private:
     GrVkGpu(GrContext* context, const GrContextOptions& options,
             const GrVkBackendContext* backendContext);

     void onResetContext(uint32_t resetBits) override {}

     GrTexture* onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
                                const SkTArray<GrMipLevel>&) override;

     GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, SkBudgeted,
                                          const SkTArray<GrMipLevel>&) override { return NULL; }

     sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) override;

     sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override;
     sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&) override {
         return nullptr;
     }

     GrBuffer* onCreateBuffer(size_t size, GrBufferType type, GrAccessPattern,
                              const void* data) override;

     gr_instanced::InstancedRendering* onCreateInstancedRendering() override { return nullptr; }

     bool onReadPixels(GrSurface* surface,
                       int left, int top, int width, int height,
                       GrPixelConfig,
                       void* buffer,
                       size_t rowBytes) override;

     bool onWritePixels(GrSurface* surface,
                        int left, int top, int width, int height,
                        GrPixelConfig config, const SkTArray<GrMipLevel>&) override;

     bool onTransferPixels(GrSurface*,
                           int left, int top, int width, int height,
                           GrPixelConfig config, GrBuffer* transferBuffer,
                           size_t offset, size_t rowBytes) override { return false; }

     // Ends and submits the current command buffer to the queue and then creates a new command
     // buffer and begins it. If sync is set to kForce_SyncQueue, the function will wait for all
     // work in the queue to finish before returning. If the signalSemaphore is not VK_NULL_HANDLE,
     // we will signal the semaphore at the end of this command buffer. If this GrVkGpu object has
     // any semaphores in fSemaphoresToWaitOn, we will add those wait semaphores to this command
     // buffer when submitting.
     void submitCommandBuffer(SyncQueue sync,
                              const GrVkSemaphore::Resource* signalSemaphore = nullptr);

     void internalResolveRenderTarget(GrRenderTarget* target, bool requiresSubmit);

     void copySurfaceAsCopyImage(GrSurface* dst,
                                 GrSurface* src,
                                 GrVkImage* dstImage,
                                 GrVkImage* srcImage,
                                 const SkIRect& srcRect,
                                 const SkIPoint& dstPoint);

     void copySurfaceAsBlit(GrSurface* dst,
                            GrSurface* src,
                            GrVkImage* dstImage,
                            GrVkImage* srcImage,
                            const SkIRect& srcRect,
                            const SkIPoint& dstPoint);

     void copySurfaceAsResolve(GrSurface* dst,
                               GrSurface* src,
                               const SkIRect& srcRect,
                               const SkIPoint& dstPoint);

     // helpers for onCreateTexture and writeTexturePixels
     bool uploadTexDataLinear(GrVkTexture* tex,
                              int left, int top, int width, int height,
                              GrPixelConfig dataConfig,
                              const void* data,
                              size_t rowBytes);
     bool uploadTexDataOptimal(GrVkTexture* tex,
                               int left, int top, int width, int height,
                               GrPixelConfig dataConfig,
                               const SkTArray<GrMipLevel>&);

     void resolveImage(GrVkRenderTarget* dst,
                       GrVkRenderTarget* src,
                       const SkIRect& srcRect,
                       const SkIPoint& dstPoint);

     sk_sp<const GrVkBackendContext> fBackendContext;
     sk_sp<GrVkCaps>                 fVkCaps;

     // These Vulkan objects are provided by the client, and also stored in fBackendContext.
     // They're copied here for convenient access.
     VkDevice                                     fDevice;
     VkQueue                                      fQueue;    // Must be Graphics queue

     // Created by GrVkGpu
     GrVkResourceProvider                         fResourceProvider;
     VkCommandPool                                fCmdPool;

     GrVkPrimaryCommandBuffer*                    fCurrentCmdBuffer;

     SkSTArray<1, const GrVkSemaphore::Resource*> fSemaphoresToWaitOn;

     VkPhysicalDeviceMemoryProperties             fPhysDevMemProps;

     std::unique_ptr<GrVkHeap>                    fHeaps[kHeapCount];

     GrVkCopyManager                              fCopyManager;

 #ifdef SK_ENABLE_VK_LAYERS
     // For reporting validation layer errors
     VkDebugReportCallbackEXT               fCallback;
 #endif

     // compiler used for compiling sksl into spirv. We only want to create the compiler once since
     // there is significant overhead to the first compile of any compiler.
     SkSL::Compiler* fCompiler;

     typedef GrGpu INHERITED;
 };

 #endif
	/*
	* Copyright 2015 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#ifndef GrVkGpu_DEFINED
	#define GrVkGpu_DEFINED

	#include "GrGpu.h"
	#include "GrGpuFactory.h"
	#include "vk/GrVkBackendContext.h"
	#include "GrVkCaps.h"
	#include "GrVkCopyManager.h"
	#include "GrVkIndexBuffer.h"
	#include "GrVkMemory.h"
	#include "GrVkResourceProvider.h"
	#include "GrVkSemaphore.h"
	#include "GrVkVertexBuffer.h"
	#include "GrVkUtil.h"
	#include "vk/GrVkDefines.h"

	class GrPipeline;
	class GrNonInstancedMesh;

	class GrVkBufferImpl;
	class GrVkPipeline;
	class GrVkPipelineState;
	class GrVkPrimaryCommandBuffer;
	class GrVkRenderPass;
	class GrVkSecondaryCommandBuffer;
	class GrVkTexture;
	struct GrVkInterface;

	namespace SkSL {
	class Compiler;
	}

	class GrVkGpu : public GrGpu {
	public:
	static GrGpu* Create(GrBackendContext backendContext, const GrContextOptions& options,
	GrContext* context);

	~GrVkGpu() override;

	const GrVkInterface* vkInterface() const { return fBackendContext->fInterface.get(); }
	const GrVkCaps& vkCaps() const { return *fVkCaps; }

	VkDevice device() const { return fDevice; }
	VkQueue queue() const { return fQueue; }
	VkCommandPool cmdPool() const { return fCmdPool; }
	VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties() const {
	return fPhysDevMemProps;
	}

	GrVkResourceProvider& resourceProvider() { return fResourceProvider; }

	GrVkPrimaryCommandBuffer* currentCommandBuffer() { return fCurrentCmdBuffer; }

	enum SyncQueue {
	kForce_SyncQueue,
	kSkip_SyncQueue
	};

	bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
	GrPixelConfig readConfig, DrawPreference*,
	ReadPixelTempDrawInfo*) override;

	bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
	GrPixelConfig srcConfig, DrawPreference*,
	WritePixelTempDrawInfo*) override;

	bool onCopySurface(GrSurface* dst,
	GrSurface* src,
	const SkIRect& srcRect,
	const SkIPoint& dstPoint) override;

	void onQueryMultisampleSpecs(GrRenderTarget* rt, const GrStencilSettings&,
	int* effectiveSampleCnt, SamplePattern*) override;

	void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {}

	GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h,
	GrPixelConfig config,
	bool isRenderTarget) override;
	bool isTestingOnlyBackendTexture(GrBackendObject id) const override;
	void deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandonTexture) override;

	GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
	int width,
	int height) override;

	void clearStencil(GrRenderTarget* target) override;

	GrGpuCommandBuffer* createCommandBuffer(
	const GrGpuCommandBuffer::LoadAndStoreInfo& colorInfo,
	const GrGpuCommandBuffer::LoadAndStoreInfo& stencilInfo) override;

	void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) override {}

	void addMemoryBarrier(VkPipelineStageFlags srcStageMask,
	VkPipelineStageFlags dstStageMask,
	bool byRegion,
	VkMemoryBarrier* barrier) const;
	void addBufferMemoryBarrier(VkPipelineStageFlags srcStageMask,
	VkPipelineStageFlags dstStageMask,
	bool byRegion,
	VkBufferMemoryBarrier* barrier) const;
	void addImageMemoryBarrier(VkPipelineStageFlags srcStageMask,
	VkPipelineStageFlags dstStageMask,
	bool byRegion,
	VkImageMemoryBarrier* barrier) const;

	SkSL::Compiler* shaderCompiler() const {
	return fCompiler;
	}

	void onResolveRenderTarget(GrRenderTarget* target) override {
	this->internalResolveRenderTarget(target, true);
	}

	void submitSecondaryCommandBuffer(const SkTArray<GrVkSecondaryCommandBuffer*>&,
	const GrVkRenderPass*,
	const VkClearValue*,
	GrVkRenderTarget*,
	const SkIRect& bounds);

	void finishOpList() override;

	GrFence SK_WARN_UNUSED_RESULT insertFence() override;
	bool waitFence(GrFence, uint64_t timeout) override;
	void deleteFence(GrFence) const override;

	sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT makeSemaphore() override;
	void insertSemaphore(sk_sp<GrSemaphore> semaphore) override;
	void waitSemaphore(sk_sp<GrSemaphore> semaphore) override;

	void flush() override;

	void generateMipmap(GrVkTexture* tex);

	bool updateBuffer(GrVkBuffer* buffer, const void* src, VkDeviceSize offset, VkDeviceSize size);

	// Heaps
	enum Heap {
	kLinearImage_Heap = 0,
	// We separate out small (i.e., <= 16K) images to reduce fragmentation
	// in the main heap.
	kOptimalImage_Heap,
	kSmallOptimalImage_Heap,
	// We have separate vertex and image heaps, because it's possible that
	// a given Vulkan driver may allocate them separately.
	kVertexBuffer_Heap,
	kIndexBuffer_Heap,
	kUniformBuffer_Heap,
	kCopyReadBuffer_Heap,
	kCopyWriteBuffer_Heap,

	kLastHeap = kCopyWriteBuffer_Heap
	};
	static const int kHeapCount = kLastHeap + 1;

	GrVkHeap* getHeap(Heap heap) const { return fHeaps[heap].get(); }

	private:
	GrVkGpu(GrContext* context, const GrContextOptions& options,
	const GrVkBackendContext* backendContext);

	void onResetContext(uint32_t resetBits) override {}

	GrTexture* onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
	const SkTArray<GrMipLevel>&) override;

	GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, SkBudgeted,
	const SkTArray<GrMipLevel>&) override { return NULL; }

	sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) override;

	sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override;
	sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&) override {
	return nullptr;
	}

	GrBuffer* onCreateBuffer(size_t size, GrBufferType type, GrAccessPattern,
	const void* data) override;

	gr_instanced::InstancedRendering* onCreateInstancedRendering() override { return nullptr; }

	bool onReadPixels(GrSurface* surface,
	int left, int top, int width, int height,
	GrPixelConfig,
	void* buffer,
	size_t rowBytes) override;

	bool onWritePixels(GrSurface* surface,
	int left, int top, int width, int height,
	GrPixelConfig config, const SkTArray<GrMipLevel>&) override;

	bool onTransferPixels(GrSurface*,
	int left, int top, int width, int height,
	GrPixelConfig config, GrBuffer* transferBuffer,
	size_t offset, size_t rowBytes) override { return false; }

	// Ends and submits the current command buffer to the queue and then creates a new command
	// buffer and begins it. If sync is set to kForce_SyncQueue, the function will wait for all
	// work in the queue to finish before returning. If the signalSemaphore is not VK_NULL_HANDLE,
	// we will signal the semaphore at the end of this command buffer. If this GrVkGpu object has
	// any semaphores in fSemaphoresToWaitOn, we will add those wait semaphores to this command
	// buffer when submitting.
	void submitCommandBuffer(SyncQueue sync,
	const GrVkSemaphore::Resource* signalSemaphore = nullptr);

	void internalResolveRenderTarget(GrRenderTarget* target, bool requiresSubmit);

	void copySurfaceAsCopyImage(GrSurface* dst,
	GrSurface* src,
	GrVkImage* dstImage,
	GrVkImage* srcImage,
	const SkIRect& srcRect,
	const SkIPoint& dstPoint);

	void copySurfaceAsBlit(GrSurface* dst,
	GrSurface* src,
	GrVkImage* dstImage,
	GrVkImage* srcImage,
	const SkIRect& srcRect,
	const SkIPoint& dstPoint);

	void copySurfaceAsResolve(GrSurface* dst,
	GrSurface* src,
	const SkIRect& srcRect,
	const SkIPoint& dstPoint);

	// helpers for onCreateTexture and writeTexturePixels
	bool uploadTexDataLinear(GrVkTexture* tex,
	int left, int top, int width, int height,
	GrPixelConfig dataConfig,
	const void* data,
	size_t rowBytes);
	bool uploadTexDataOptimal(GrVkTexture* tex,
	int left, int top, int width, int height,
	GrPixelConfig dataConfig,
	const SkTArray<GrMipLevel>&);

	void resolveImage(GrVkRenderTarget* dst,
	GrVkRenderTarget* src,
	const SkIRect& srcRect,
	const SkIPoint& dstPoint);

	sk_sp<const GrVkBackendContext> fBackendContext;
	sk_sp<GrVkCaps> fVkCaps;

	// These Vulkan objects are provided by the client, and also stored in fBackendContext.
	// They're copied here for convenient access.
	VkDevice fDevice;
	VkQueue fQueue; // Must be Graphics queue

	// Created by GrVkGpu
	GrVkResourceProvider fResourceProvider;
	VkCommandPool fCmdPool;

	GrVkPrimaryCommandBuffer* fCurrentCmdBuffer;

	SkSTArray<1, const GrVkSemaphore::Resource*> fSemaphoresToWaitOn;

	VkPhysicalDeviceMemoryProperties fPhysDevMemProps;

	std::unique_ptr<GrVkHeap> fHeaps[kHeapCount];

	GrVkCopyManager fCopyManager;

	#ifdef SK_ENABLE_VK_LAYERS
	// For reporting validation layer errors
	VkDebugReportCallbackEXT fCallback;
	#endif

	// compiler used for compiling sksl into spirv. We only want to create the compiler once since
	// there is significant overhead to the first compile of any compiler.
	SkSL::Compiler* fCompiler;

	typedef GrGpu INHERITED;
	};

	#endif