Add drawDrawable support to GrRenderTargetContext.
This also includes adding drawable Op and plumbing it through to the GPU.
BUG=skia:
Change-Id: I0b2464c5a458c2fbf05b9528e47b9e6e3ac27d57
Reviewed-on: https://skia-review.googlesource.com/c/9645
Commit-Queue: Greg Daniel <egdaniel@google.com>
Reviewed-by: Jim Van Verth <jvanverth@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
diff --git a/src/gpu/GrGpuCommandBuffer.h b/src/gpu/GrGpuCommandBuffer.h
index c1b44b4..888d459 100644
--- a/src/gpu/GrGpuCommandBuffer.h
+++ b/src/gpu/GrGpuCommandBuffer.h
@@ -10,6 +10,7 @@
#include "GrColor.h"
#include "GrPipeline.h"
+#include "SkDrawable.h"
#include "ops/GrDrawOp.h"
class GrOpFlushState;
@@ -19,6 +20,7 @@
class GrPipeline;
class GrPrimitiveProcessor;
class GrRenderTarget;
+class GrSemaphore;
struct SkIRect;
struct SkRect;
@@ -117,6 +119,11 @@
// TODO: This should be removed in the future to favor using the load and store ops for discard
virtual void discard() = 0;
+ /**
+ * Executes the SkDrawable object for the underlying backend.
+ */
+ virtual void executeDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler>) {}
+
protected:
GrGpuRTCommandBuffer() : fOrigin(kTopLeft_GrSurfaceOrigin), fRenderTarget(nullptr) {}
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index beae7f9..41a4e4a 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -26,6 +26,7 @@
#include "GrStencilAttachment.h"
#include "GrStyle.h"
#include "GrTracing.h"
+#include "SkDrawable.h"
#include "SkDrawShadowInfo.h"
#include "SkGlyphRunPainter.h"
#include "SkGr.h"
@@ -39,6 +40,7 @@
#include "ops/GrClearOp.h"
#include "ops/GrClearStencilClipOp.h"
#include "ops/GrDebugMarkerOp.h"
+#include "ops/GrDrawableOp.h"
#include "ops/GrDrawAtlasOp.h"
#include "ops/GrDrawOp.h"
#include "ops/GrDrawVerticesOp.h"
@@ -1442,6 +1444,13 @@
this->addDrawOp(clip, std::move(op));
}
+void GrRenderTargetContext::drawDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler> drawable,
+ const SkRect& bounds) {
+ std::unique_ptr<GrOp> op(GrDrawableOp::Make(fContext, std::move(drawable), bounds));
+ SkASSERT(op);
+ this->getRTOpList()->addOp(std::move(op), *this->caps());
+}
+
GrSemaphoresSubmitted GrRenderTargetContext::prepareForExternalIO(
int numSemaphores, GrBackendSemaphore backendSemaphores[]) {
ASSERT_SINGLE_OWNER
diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h
index c4a6740..6617e0b 100644
--- a/src/gpu/GrRenderTargetContext.h
+++ b/src/gpu/GrRenderTargetContext.h
@@ -17,6 +17,7 @@
#include "GrTypesPriv.h"
#include "GrXferProcessor.h"
#include "SkCanvas.h"
+#include "SkDrawable.h"
#include "SkRefCnt.h"
#include "SkSurfaceProps.h"
#include "text/GrTextTarget.h"
@@ -339,6 +340,12 @@
const SkRect& dst);
/**
+ * Adds the necessary signal and wait semaphores and adds the passed in SkDrawable to the
+ * command stream.
+ */
+ void drawDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler>, const SkRect& bounds);
+
+ /**
* After this returns any pending surface IO will be issued to the backend 3D API and
* if the surface has MSAA it will be resolved.
*/
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 9440013..1002053 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1696,13 +1696,14 @@
std::unique_ptr<SkDrawable::GpuDrawHandler> gpuDraw =
drawable->snapGpuDrawHandler(api, combinedMatrix);
if (gpuDraw) {
- // TODO: send the gpuDraw to the renderTargetContext and make an Op out of it
- // return;
+ fRenderTargetContext->drawDrawable(std::move(gpuDraw), drawable->getBounds());
+ return;
}
}
this->INHERITED::drawDrawable(drawable, matrix, canvas);
}
+
///////////////////////////////////////////////////////////////////////////////
void SkGpuDevice::flush() {
diff --git a/src/gpu/ops/GrDrawableOp.cpp b/src/gpu/ops/GrDrawableOp.cpp
new file mode 100644
index 0000000..6e648be
--- /dev/null
+++ b/src/gpu/ops/GrDrawableOp.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrDrawableOp.h"
+
+#include "GrContext.h"
+#include "GrContextPriv.h"
+#include "GrGpuCommandBuffer.h"
+#include "GrMemoryPool.h"
+#include "GrOpFlushState.h"
+#include "SkDrawable.h"
+
+std::unique_ptr<GrDrawableOp> GrDrawableOp::Make(
+ GrContext* context, std::unique_ptr<SkDrawable::GpuDrawHandler> drawable,
+ const SkRect& bounds) {
+ GrOpMemoryPool* pool = context->contextPriv().opMemoryPool();
+ return pool->allocate<GrDrawableOp>(std::move(drawable), bounds);
+}
+
+GrDrawableOp::GrDrawableOp(std::unique_ptr<SkDrawable::GpuDrawHandler> drawable,
+ const SkRect& bounds)
+ : INHERITED(ClassID())
+ , fDrawable(std::move(drawable)) {
+ this->setBounds(bounds, HasAABloat::kNo, IsZeroArea::kNo);
+}
+
+void GrDrawableOp::onExecute(GrOpFlushState* state) {
+ SkASSERT(state->commandBuffer());
+ state->rtCommandBuffer()->executeDrawable(std::move(fDrawable));
+}
+
diff --git a/src/gpu/ops/GrDrawableOp.h b/src/gpu/ops/GrDrawableOp.h
new file mode 100644
index 0000000..cb295b2
--- /dev/null
+++ b/src/gpu/ops/GrDrawableOp.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDrawableOp_DEFINED
+#define GrDrawableOp_DEFINED
+
+#include "GrOp.h"
+
+#include "GrSemaphore.h"
+#include "SkDrawable.h"
+#include "SkMatrix.h"
+
+class GrDrawableOp final : public GrOp {
+public:
+ DEFINE_OP_CLASS_ID
+
+ static std::unique_ptr<GrDrawableOp> Make(GrContext*,
+ std::unique_ptr<SkDrawable::GpuDrawHandler> drawable,
+ const SkRect& bounds);
+
+ const char* name() const override { return "Drawable"; }
+
+ SkString dumpInfo() const override {
+ return INHERITED::dumpInfo();
+ }
+
+private:
+ friend class GrOpMemoryPool; // for ctor
+
+ GrDrawableOp(std::unique_ptr<SkDrawable::GpuDrawHandler>, const SkRect& bounds);
+
+ CombineResult onCombineIfPossible(GrOp* that, const GrCaps& caps) override {
+ return CombineResult::kCannotCombine;
+ }
+ void onPrepare(GrOpFlushState*) override {}
+
+ void onExecute(GrOpFlushState* state) override;
+
+ std::unique_ptr<SkDrawable::GpuDrawHandler> fDrawable;
+
+ typedef GrOp INHERITED;
+};
+
+#endif
+
diff --git a/src/gpu/vk/GrVkCommandBuffer.h b/src/gpu/vk/GrVkCommandBuffer.h
index cb2875d..4675478 100644
--- a/src/gpu/vk/GrVkCommandBuffer.h
+++ b/src/gpu/vk/GrVkCommandBuffer.h
@@ -311,6 +311,8 @@
const GrVkRenderPass* compatibleRenderPass);
void end(const GrVkGpu* gpu);
+ VkCommandBuffer vkCommandBuffer() { return fCmdBuffer; }
+
#ifdef SK_TRACE_VK_RESOURCES
void dumpInfo() const override {
SkDebugf("GrVkSecondaryCommandBuffer: %d (%d refs)\n", fCmdBuffer, this->getRefCnt());
diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index 2e6d97d..4d23f55 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -307,6 +307,9 @@
fCurrentCmdBuffer->submitToQueue(this, fQueue, sync, fSemaphoresToSignal, fSemaphoresToWaitOn);
+ // We must delete and drawables that have been waitint till submit for us to destroy.
+ fDrawables.reset();
+
for (int i = 0; i < fSemaphoresToWaitOn.count(); ++i) {
fSemaphoresToWaitOn[i]->unref(this);
}
@@ -2153,3 +2156,7 @@
return nullptr;
}
+void GrVkGpu::addDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler> drawable) {
+ fDrawables.emplace_back(std::move(drawable));
+}
+
diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h
index 3b9a2e5..6e599de 100644
--- a/src/gpu/vk/GrVkGpu.h
+++ b/src/gpu/vk/GrVkGpu.h
@@ -141,6 +141,14 @@
void insertSemaphore(sk_sp<GrSemaphore> semaphore, bool flush) override;
void waitSemaphore(sk_sp<GrSemaphore> semaphore) override;
+ // These match the definitions in SkDrawable, from whence they came
+ typedef void* SubmitContext;
+ typedef void (*SubmitProc)(SubmitContext submitContext);
+
+ // Adds an SkDrawable::GpuDrawHandler that we will delete the next time we submit the primary
+ // command buffer to the gpu.
+ void addDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler> drawable);
+
sk_sp<GrSemaphore> prepareTextureForCrossContextUsage(GrTexture*) override;
void copyBuffer(GrVkBuffer* srcBuffer, GrVkBuffer* dstBuffer, VkDeviceSize srcOffset,
@@ -227,40 +235,42 @@
size_t srcRowBytes, GrVkImageInfo* info);
#endif
- sk_sp<const GrVkInterface> fInterface;
- sk_sp<GrVkMemoryAllocator> fMemoryAllocator;
- sk_sp<GrVkCaps> fVkCaps;
+ sk_sp<const GrVkInterface> fInterface;
+ sk_sp<GrVkMemoryAllocator> fMemoryAllocator;
+ sk_sp<GrVkCaps> fVkCaps;
- VkInstance fInstance;
- VkPhysicalDevice fPhysicalDevice;
- VkDevice fDevice;
- VkQueue fQueue; // Must be Graphics queue
- uint32_t fQueueIndex;
+ VkInstance fInstance;
+ VkPhysicalDevice fPhysicalDevice;
+ VkDevice fDevice;
+ VkQueue fQueue; // Must be Graphics queue
+ uint32_t fQueueIndex;
// Created by GrVkGpu
- GrVkResourceProvider fResourceProvider;
- VkCommandPool fCmdPool;
+ GrVkResourceProvider fResourceProvider;
+ VkCommandPool fCmdPool;
- GrVkPrimaryCommandBuffer* fCurrentCmdBuffer;
+ GrVkPrimaryCommandBuffer* fCurrentCmdBuffer;
- SkSTArray<1, GrVkSemaphore::Resource*> fSemaphoresToWaitOn;
- SkSTArray<1, GrVkSemaphore::Resource*> fSemaphoresToSignal;
+ SkSTArray<1, GrVkSemaphore::Resource*> fSemaphoresToWaitOn;
+ SkSTArray<1, GrVkSemaphore::Resource*> fSemaphoresToSignal;
- VkPhysicalDeviceProperties fPhysDevProps;
- VkPhysicalDeviceMemoryProperties fPhysDevMemProps;
+ SkTArray<std::unique_ptr<SkDrawable::GpuDrawHandler>> fDrawables;
- GrVkCopyManager fCopyManager;
+ VkPhysicalDeviceProperties fPhysDevProps;
+ VkPhysicalDeviceMemoryProperties fPhysDevMemProps;
+
+ GrVkCopyManager fCopyManager;
// 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;
+ SkSL::Compiler* fCompiler;
// We need a bool to track whether or not we've already disconnected all the gpu resources from
// vulkan context.
- bool fDisconnected;
+ bool fDisconnected;
- std::unique_ptr<GrVkGpuRTCommandBuffer> fCachedRTCommandBuffer;
- std::unique_ptr<GrVkGpuTextureCommandBuffer> fCachedTexCommandBuffer;
+ std::unique_ptr<GrVkGpuRTCommandBuffer> fCachedRTCommandBuffer;
+ std::unique_ptr<GrVkGpuTextureCommandBuffer> fCachedTexCommandBuffer;
typedef GrGpu INHERITED;
};
diff --git a/src/gpu/vk/GrVkGpuCommandBuffer.cpp b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
index edd73fc..fce6235 100644
--- a/src/gpu/vk/GrVkGpuCommandBuffer.cpp
+++ b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
@@ -7,6 +7,7 @@
#include "GrVkGpuCommandBuffer.h"
+#include "GrBackendDrawableInfo.h"
#include "GrFixedClip.h"
#include "GrMesh.h"
#include "GrOpFlushState.h"
@@ -19,7 +20,9 @@
#include "GrVkRenderPass.h"
#include "GrVkRenderTarget.h"
#include "GrVkResourceProvider.h"
+#include "GrVkSemaphore.h"
#include "GrVkTexture.h"
+#include "SkDrawable.h"
#include "SkRect.h"
void GrVkGpuTextureCommandBuffer::copy(GrSurface* src, GrSurfaceOrigin srcOrigin,
@@ -267,6 +270,8 @@
fRenderTarget = nullptr;
}
+////////////////////////////////////////////////////////////////////////////////
+
void GrVkGpuRTCommandBuffer::discard() {
GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(fRenderTarget);
@@ -777,3 +782,36 @@
baseIndex, baseVertex, baseInstance);
fGpu->stats()->incNumDraws();
}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void GrVkGpuRTCommandBuffer::executeDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler> drawable) {
+ GrVkRenderTarget* target = static_cast<GrVkRenderTarget*>(fRenderTarget);
+
+ GrVkImage* targetImage = target->msaaImage() ? target->msaaImage() : target;
+
+ CommandBufferInfo& cbInfo = fCommandBufferInfos[fCurrentCmdInfo];
+ VkRect2D bounds;
+ bounds.offset = { 0, 0 };
+ bounds.extent = { 0, 0 };
+
+ GrVkDrawableInfo vkInfo;
+ vkInfo.fSecondaryCommandBuffer = cbInfo.currentCmdBuf()->vkCommandBuffer();
+ vkInfo.fCompatibleRenderPass = cbInfo.fRenderPass->vkRenderPass();
+ SkAssertResult(cbInfo.fRenderPass->colorAttachmentIndex(&vkInfo.fImageAttachmentIndex));
+ vkInfo.fFormat = targetImage->imageFormat();
+ vkInfo.fDrawBounds = &bounds;
+
+ GrBackendDrawableInfo info(vkInfo);
+
+ drawable->draw(info);
+ fGpu->addDrawable(std::move(drawable));
+
+ if (bounds.extent.width == 0 || bounds.extent.height == 0) {
+ cbInfo.fBounds.join(target->getBoundsRect());
+ } else {
+ cbInfo.fBounds.join(SkRect::MakeXYWH(bounds.offset.x, bounds.offset.y,
+ bounds.extent.width, bounds.extent.height));
+ }
+}
+
diff --git a/src/gpu/vk/GrVkGpuCommandBuffer.h b/src/gpu/vk/GrVkGpuCommandBuffer.h
index 6aad0c2..b40cff3 100644
--- a/src/gpu/vk/GrVkGpuCommandBuffer.h
+++ b/src/gpu/vk/GrVkGpuCommandBuffer.h
@@ -74,6 +74,8 @@
void copy(GrSurface* src, GrSurfaceOrigin srcOrigin, const SkIRect& srcRect,
const SkIPoint& dstPoint) override;
+ void executeDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler>) override;
+
void set(GrRenderTarget*, GrSurfaceOrigin,
const GrGpuRTCommandBuffer::LoadAndStoreInfo&,
const GrGpuRTCommandBuffer::StencilLoadAndStoreInfo&);