| /* | |
| * Copyright 2010 Google Inc. | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #ifndef GrDrawTarget_DEFINED | |
| #define GrDrawTarget_DEFINED | |
| #include "GrClip.h" | |
| #include "GrContext.h" | |
| #include "GrPathProcessor.h" | |
| #include "GrPrimitiveProcessor.h" | |
| #include "GrPathRendering.h" | |
| #include "GrXferProcessor.h" | |
| #include "batches/GrDrawBatch.h" | |
| #include "SkClipStack.h" | |
| #include "SkMatrix.h" | |
| #include "SkPath.h" | |
| #include "SkStringUtils.h" | |
| #include "SkStrokeRec.h" | |
| #include "SkTArray.h" | |
| #include "SkTLazy.h" | |
| #include "SkTypes.h" | |
| #include "SkXfermode.h" | |
| //#define ENABLE_MDB 1 | |
| class GrAuditTrail; | |
| class GrBatch; | |
| class GrClearBatch; | |
| class GrClip; | |
| class GrCaps; | |
| class GrPath; | |
| class GrDrawPathBatchBase; | |
| class GrPipelineBuilder; | |
| class GrDrawTarget final : public SkRefCnt { | |
| public: | |
| /** Options for GrDrawTarget behavior. */ | |
| struct Options { | |
| Options () | |
| : fClipBatchToBounds(false) | |
| , fDrawBatchBounds(false) | |
| , fMaxBatchLookback(-1) | |
| , fMaxBatchLookahead(-1) {} | |
| bool fClipBatchToBounds; | |
| bool fDrawBatchBounds; | |
| int fMaxBatchLookback; | |
| int fMaxBatchLookahead; | |
| }; | |
| GrDrawTarget(GrRenderTarget*, GrGpu*, GrResourceProvider*, GrAuditTrail*, const Options&); | |
| ~GrDrawTarget() override; | |
| void makeClosed() { | |
| fLastFullClearBatch = nullptr; | |
| // We only close drawTargets When MDB is enabled. When MDB is disabled there is only | |
| // ever one drawTarget and all calls will be funnelled into it. | |
| #ifdef ENABLE_MDB | |
| this->setFlag(kClosed_Flag); | |
| #endif | |
| this->forwardCombine(); | |
| } | |
| bool isClosed() const { return this->isSetFlag(kClosed_Flag); } | |
| // TODO: this entry point is only needed in the non-MDB world. Remove when | |
| // we make the switch to MDB | |
| void clearRT() { fRenderTarget = nullptr; } | |
| /* | |
| * Notify this drawTarget that it relies on the contents of 'dependedOn' | |
| */ | |
| void addDependency(GrSurface* dependedOn); | |
| /* | |
| * Does this drawTarget depend on 'dependedOn'? | |
| */ | |
| bool dependsOn(GrDrawTarget* dependedOn) const { | |
| return fDependencies.find(dependedOn) >= 0; | |
| } | |
| /* | |
| * Dump out the drawTarget dependency DAG | |
| */ | |
| SkDEBUGCODE(void dump() const;) | |
| /** | |
| * Empties the draw buffer of any queued up draws. | |
| */ | |
| void reset(); | |
| /** | |
| * Together these two functions flush all queued up draws to GrCommandBuffer. The return value | |
| * of drawBatches() indicates whether any commands were actually issued to the GPU. | |
| */ | |
| void prepareBatches(GrBatchFlushState* flushState); | |
| bool drawBatches(GrBatchFlushState* flushState); | |
| /** | |
| * Gets the capabilities of the draw target. | |
| */ | |
| const GrCaps* caps() const { return fGpu->caps(); } | |
| void drawBatch(const GrPipelineBuilder&, GrDrawContext*, const GrClip&, GrDrawBatch*); | |
| void addBatch(sk_sp<GrBatch>); | |
| /** | |
| * Draws the path into user stencil bits. Upon return, all user stencil values | |
| * inside the path will be nonzero. The path's fill must be either even/odd or | |
| * winding (notnverse or hairline).It will respect the HW antialias boolean (if | |
| * possible in the 3D API). Note, we will never have an inverse fill with | |
| * stencil path. | |
| */ | |
| void stencilPath(GrDrawContext*, | |
| const GrClip&, | |
| bool useHWAA, | |
| const SkMatrix& viewMatrix, | |
| const GrPath*); | |
| /** Clears the entire render target */ | |
| void fullClear(GrRenderTarget*, GrColor color); | |
| /** Discards the contents render target. */ | |
| void discard(GrRenderTarget*); | |
| /** | |
| * Copies a pixel rectangle from one surface to another. This call may finalize | |
| * reserved vertex/index data (as though a draw call was made). The src pixels | |
| * copied are specified by srcRect. They are copied to a rect of the same | |
| * size in dst with top left at dstPoint. If the src rect is clipped by the | |
| * src bounds then pixel values in the dst rect corresponding to area clipped | |
| * by the src rect are not overwritten. This method is not guaranteed to succeed | |
| * depending on the type of surface, configs, etc, and the backend-specific | |
| * limitations. | |
| */ | |
| bool copySurface(GrSurface* dst, | |
| GrSurface* src, | |
| const SkIRect& srcRect, | |
| const SkIPoint& dstPoint); | |
| gr_instanced::InstancedRendering* instancedRendering() const { | |
| SkASSERT(fInstancedRendering); | |
| return fInstancedRendering; | |
| } | |
| private: | |
| friend class GrDrawingManager; // for resetFlag & TopoSortTraits | |
| friend class GrDrawContextPriv; // for clearStencilClip | |
| enum Flags { | |
| kClosed_Flag = 0x01, //!< This drawTarget can't accept any more batches | |
| kWasOutput_Flag = 0x02, //!< Flag for topological sorting | |
| kTempMark_Flag = 0x04, //!< Flag for topological sorting | |
| }; | |
| void setFlag(uint32_t flag) { | |
| fFlags |= flag; | |
| } | |
| void resetFlag(uint32_t flag) { | |
| fFlags &= ~flag; | |
| } | |
| bool isSetFlag(uint32_t flag) const { | |
| return SkToBool(fFlags & flag); | |
| } | |
| struct TopoSortTraits { | |
| static void Output(GrDrawTarget* dt, int /* index */) { | |
| dt->setFlag(GrDrawTarget::kWasOutput_Flag); | |
| } | |
| static bool WasOutput(const GrDrawTarget* dt) { | |
| return dt->isSetFlag(GrDrawTarget::kWasOutput_Flag); | |
| } | |
| static void SetTempMark(GrDrawTarget* dt) { | |
| dt->setFlag(GrDrawTarget::kTempMark_Flag); | |
| } | |
| static void ResetTempMark(GrDrawTarget* dt) { | |
| dt->resetFlag(GrDrawTarget::kTempMark_Flag); | |
| } | |
| static bool IsTempMarked(const GrDrawTarget* dt) { | |
| return dt->isSetFlag(GrDrawTarget::kTempMark_Flag); | |
| } | |
| static int NumDependencies(const GrDrawTarget* dt) { | |
| return dt->fDependencies.count(); | |
| } | |
| static GrDrawTarget* Dependency(GrDrawTarget* dt, int index) { | |
| return dt->fDependencies[index]; | |
| } | |
| }; | |
| // Returns the batch that the input batch was combined with or the input batch if it wasn't | |
| // combined. | |
| GrBatch* recordBatch(GrBatch*, const SkRect& clippedBounds); | |
| void forwardCombine(); | |
| // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required | |
| // but couldn't be made. Otherwise, returns true. This method needs to be protected because it | |
| // needs to be accessed by GLPrograms to setup a correct drawstate | |
| bool setupDstReadIfNecessary(const GrPipelineBuilder&, | |
| GrRenderTarget*, | |
| const GrClip&, | |
| const GrPipelineOptimizations& optimizations, | |
| GrXferProcessor::DstTexture*, | |
| const SkRect& batchBounds); | |
| void addDependency(GrDrawTarget* dependedOn); | |
| // Used only by drawContextPriv. | |
| void clearStencilClip(const GrFixedClip&, bool insideStencilMask, GrRenderTarget*); | |
| struct RecordedBatch { | |
| sk_sp<GrBatch> fBatch; | |
| SkRect fClippedBounds; | |
| }; | |
| SkSTArray<256, RecordedBatch, true> fRecordedBatches; | |
| GrClearBatch* fLastFullClearBatch; | |
| // The context is only in service of the GrClip, remove once it doesn't need this. | |
| GrContext* fContext; | |
| GrGpu* fGpu; | |
| GrResourceProvider* fResourceProvider; | |
| GrAuditTrail* fAuditTrail; | |
| SkDEBUGCODE(int fDebugID;) | |
| uint32_t fFlags; | |
| // 'this' drawTarget relies on the output of the drawTargets in 'fDependencies' | |
| SkTDArray<GrDrawTarget*> fDependencies; | |
| GrRenderTarget* fRenderTarget; | |
| bool fClipBatchToBounds; | |
| bool fDrawBatchBounds; | |
| int fMaxBatchLookback; | |
| int fMaxBatchLookahead; | |
| SkAutoTDelete<gr_instanced::InstancedRendering> fInstancedRendering; | |
| typedef SkRefCnt INHERITED; | |
| }; | |
| #endif |