/* * Copyright 2020 Google LLC * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "src/gpu/ganesh/ClipStack.h" #include "include/core/SkAlphaType.h" #include "include/core/SkBlendMode.h" #include "include/core/SkClipOp.h" #include "include/core/SkColorSpace.h" #include "include/core/SkMatrix.h" #include "include/core/SkPath.h" #include "include/core/SkRRect.h" #include "include/core/SkRegion.h" #include "include/core/SkSamplingOptions.h" #include "include/core/SkScalar.h" #include "include/gpu/GpuTypes.h" #include "include/gpu/ganesh/GrBackendSurface.h" #include "include/gpu/ganesh/GrDirectContext.h" #include "include/gpu/ganesh/GrRecordingContext.h" #include "include/gpu/ganesh/GrTypes.h" #include "include/private/base/SkPoint_impl.h" #include "include/private/base/SkTArray.h" #include "include/private/base/SkTo.h" #include "include/private/gpu/ganesh/GrTypesPriv.h" #include "src/base/SkVx.h" #include "src/core/SkPathPriv.h" #include "src/core/SkRRectPriv.h" #include "src/core/SkRectPriv.h" #include "src/core/SkTaskGroup.h" #include "src/core/SkTraceEvent.h" #include "src/gpu/SkBackingFit.h" #include "src/gpu/Swizzle.h" #include "src/gpu/ganesh/GrAppliedClip.h" #include "src/gpu/ganesh/GrCaps.h" #include "src/gpu/ganesh/GrClip.h" #include "src/gpu/ganesh/GrColorInfo.h" #include "src/gpu/ganesh/GrDeferredProxyUploader.h" #include "src/gpu/ganesh/GrDirectContextPriv.h" #include "src/gpu/ganesh/GrDrawingManager.h" #include "src/gpu/ganesh/GrFPArgs.h" #include "src/gpu/ganesh/GrFragmentProcessor.h" #include "src/gpu/ganesh/GrFragmentProcessors.h" #include "src/gpu/ganesh/GrProxyProvider.h" #include "src/gpu/ganesh/GrRecordingContextPriv.h" #include "src/gpu/ganesh/GrRenderTargetProxy.h" #include "src/gpu/ganesh/GrSWMaskHelper.h" #include "src/gpu/ganesh/GrSamplerState.h" #include "src/gpu/ganesh/GrSurfaceProxy.h" #include "src/gpu/ganesh/GrSurfaceProxyView.h" #include "src/gpu/ganesh/GrTextureProxy.h" #include "src/gpu/ganesh/GrTextureProxyPriv.h" #include "src/gpu/ganesh/GrWindowRectangles.h" #include "src/gpu/ganesh/GrWindowRectsState.h" #include "src/gpu/ganesh/StencilMaskHelper.h" #include "src/gpu/ganesh/SurfaceDrawContext.h" #include "src/gpu/ganesh/effects/GrBlendFragmentProcessor.h" #include "src/gpu/ganesh/effects/GrConvexPolyEffect.h" #include "src/gpu/ganesh/effects/GrRRectEffect.h" #include "src/gpu/ganesh/effects/GrTextureEffect.h" #include "src/gpu/ganesh/geometry/GrQuad.h" #include "src/gpu/ganesh/geometry/GrQuadUtils.h" #include "src/gpu/ganesh/ops/AtlasPathRenderer.h" #include "src/gpu/ganesh/ops/GrDrawOp.h" #include <algorithm> #include <atomic> #include <functional> #include <tuple> #include <utility> class GrOp; struct GrShaderCaps; usingnamespaceskia_private; namespace { // This captures which of the two elements in (A op B) would be required when they are combined, // where op is intersect or difference. enum class ClipGeometry { … }; // A and B can be Element, SaveRecord, or Draw. Supported combinations are, order not mattering, // (Element, Element), (Element, SaveRecord), (Element, Draw), and (SaveRecord, Draw). template<typename A, typename B> ClipGeometry get_clip_geometry(const A& a, const B& b) { … } // a.contains(b) where a's local space is defined by 'aToDevice', and b's possibly separate local // space is defined by 'bToDevice'. 'a' and 'b' geometry are provided in their local spaces. // Automatically takes into account if the anti-aliasing policies differ. When the policies match, // we assume that coverage AA or GPU's non-AA rasterization will apply to A and B equivalently, so // we can compare the original shapes. When the modes are mixed, we outset B in device space first. bool shape_contains_rect(const GrShape& a, const SkMatrix& aToDevice, const SkMatrix& deviceToA, const SkRect& b, const SkMatrix& bToDevice, bool mixedAAMode) { … } SkIRect subtract(const SkIRect& a, const SkIRect& b, bool exact) { … } GrClipEdgeType get_clip_edge_type(SkClipOp op, GrAA aa) { … } static uint32_t kInvalidGenID = …; static uint32_t kEmptyGenID = …; static uint32_t kWideOpenGenID = …; uint32_t next_gen_id() { … } // Functions for rendering / applying clip shapes in various ways // The general strategy is: // - Represent the clip element as an analytic FP that tests sk_FragCoord vs. its device shape // - Render the clip element to the stencil, if stencil is allowed and supports the AA, and the // size of the element indicates stenciling will be worth it, vs. making a mask. // - Try to put the individual element into a clip atlas, which is then sampled during the draw // - Render the element into a SW mask and upload it. If possible, the SW rasterization happens // in parallel. static constexpr GrSurfaceOrigin kMaskOrigin = …; GrFPResult analytic_clip_fp(const skgpu::ganesh::ClipStack::Element& e, const GrShaderCaps& caps, std::unique_ptr<GrFragmentProcessor> fp) { … } // TODO: Currently this only works with tessellation because the tessellation path renderer owns and // manages the atlas. The high-level concept could be generalized to support any path renderer going // into a shared atlas. GrFPResult clip_atlas_fp(const skgpu::ganesh::SurfaceDrawContext* sdc, const GrOp* opBeingClipped, skgpu::ganesh::AtlasPathRenderer* atlasPathRenderer, const SkIRect& scissorBounds, const skgpu::ganesh::ClipStack::Element& e, std::unique_ptr<GrFragmentProcessor> inputFP) { … } void draw_to_sw_mask(GrSWMaskHelper* helper, const skgpu::ganesh::ClipStack::Element& e, bool clearMask) { … } GrSurfaceProxyView render_sw_mask(GrRecordingContext* context, const SkIRect& bounds, const skgpu::ganesh::ClipStack::Element** elements, int count) { … } void render_stencil_mask(GrRecordingContext* rContext, skgpu::ganesh::SurfaceDrawContext* sdc, uint32_t genID, const SkIRect& bounds, const skgpu::ganesh::ClipStack::Element** elements, int count, GrAppliedClip* out) { … } } // anonymous namespace namespace skgpu::ganesh { class ClipStack::Draw { … }; /////////////////////////////////////////////////////////////////////////////// // ClipStack::Element ClipStack::RawElement::RawElement(const SkMatrix& localToDevice, const GrShape& shape, GrAA aa, SkClipOp op) : … { … } void ClipStack::RawElement::markInvalid(const SaveRecord& current) { … } void ClipStack::RawElement::restoreValid(const SaveRecord& current) { … } bool ClipStack::RawElement::contains(const Draw& d) const { … } bool ClipStack::RawElement::contains(const SaveRecord& s) const { … } bool ClipStack::RawElement::contains(const RawElement& e) const { … } void ClipStack::RawElement::simplify(const SkIRect& deviceBounds, bool forceAA) { … } bool ClipStack::RawElement::combine(const RawElement& other, const SaveRecord& current) { … } void ClipStack::RawElement::updateForElement(RawElement* added, const SaveRecord& current) { … } ClipStack::ClipState ClipStack::RawElement::clipType() const { … } /////////////////////////////////////////////////////////////////////////////// // ClipStack::Mask ClipStack::Mask::Mask(const SaveRecord& current, const SkIRect& drawBounds) : … { … } bool ClipStack::Mask::appliesToDraw(const SaveRecord& current, const SkIRect& drawBounds) const { … } void ClipStack::Mask::invalidate(GrProxyProvider* proxyProvider) { … } /////////////////////////////////////////////////////////////////////////////// // ClipStack::SaveRecord ClipStack::SaveRecord::SaveRecord(const SkIRect& deviceBounds) : … { … } ClipStack::SaveRecord::SaveRecord(const SaveRecord& prior, int startingMaskIndex, int startingElementIndex) : … { … } uint32_t ClipStack::SaveRecord::genID() const { … } ClipStack::ClipState ClipStack::SaveRecord::state() const { … } bool ClipStack::SaveRecord::contains(const ClipStack::Draw& draw) const { … } bool ClipStack::SaveRecord::contains(const ClipStack::RawElement& element) const { … } void ClipStack::SaveRecord::removeElements(RawElement::Stack* elements) { … } void ClipStack::SaveRecord::restoreElements(RawElement::Stack* elements) { … } void ClipStack::SaveRecord::invalidateMasks(GrProxyProvider* proxyProvider, Mask::Stack* masks) { … } void ClipStack::SaveRecord::reset(const SkIRect& bounds) { … } void ClipStack::SaveRecord::addShader(sk_sp<SkShader> shader) { … } bool ClipStack::SaveRecord::addElement(RawElement&& toAdd, RawElement::Stack* elements) { … } bool ClipStack::SaveRecord::appendElement(RawElement&& toAdd, RawElement::Stack* elements) { … } void ClipStack::SaveRecord::replaceWithElement(RawElement&& toAdd, RawElement::Stack* elements) { … } /////////////////////////////////////////////////////////////////////////////// // ClipStack // NOTE: Based on draw calls in all GMs, SKPs, and SVGs as of 08/20, 98% use a clip stack with // one Element and up to two SaveRecords, thus the inline size for RawElement::Stack and // SaveRecord::Stack (this conveniently keeps the size of ClipStack manageable). The max // encountered element stack depth was 5 and the max save depth was 6. Using an increment of 8 for // these stacks means that clip management will incur a single allocation for the remaining 2% // of the draws, with extra head room for more complex clips encountered in the wild. // // The mask stack increment size was chosen to be smaller since only 0.2% of the evaluated draw call // set ever used a mask (which includes stencil masks), or up to 0.3% when the atlas is disabled. static constexpr int kElementStackIncrement = …; static constexpr int kSaveStackIncrement = …; static constexpr int kMaskStackIncrement = …; // And from this same draw call set, the most complex clip could only use 5 analytic coverage FPs. // Historically we limited it to 4 based on Blink's call pattern, so we keep the limit as-is since // it's so close to the empirically encountered max. static constexpr int kMaxAnalyticFPs = …; // The number of stack-allocated mask pointers to store before extending the arrays. // Stack size determined empirically, the maximum number of elements put in a SW mask was 4 // across our set of GMs, SKPs, and SVGs used for testing. static constexpr int kNumStackMasks = …; ClipStack::ClipStack(const SkIRect& deviceBounds, const SkMatrix* ctm, bool forceAA) : … { … } ClipStack::~ClipStack() { … } void ClipStack::save() { … } void ClipStack::restore() { … } SkIRect ClipStack::getConservativeBounds() const { … } GrClip::PreClipResult ClipStack::preApply(const SkRect& bounds, GrAA aa) const { … } GrClip::Effect ClipStack::apply(GrRecordingContext* rContext, SurfaceDrawContext* sdc, GrDrawOp* op, GrAAType aa, GrAppliedClip* out, SkRect* bounds) const { … } ClipStack::SaveRecord& ClipStack::writableSaveRecord(bool* wasDeferred) { … } void ClipStack::clipShader(sk_sp<SkShader> shader) { … } void ClipStack::replaceClip(const SkIRect& rect) { … } void ClipStack::clip(RawElement&& element) { … } GrFPResult ClipStack::GetSWMaskFP(GrRecordingContext* context, Mask::Stack* masks, const SaveRecord& current, const SkIRect& bounds, const Element** elements, int count, std::unique_ptr<GrFragmentProcessor> clipFP) { … } } // namespace skgpu::ganesh
Codebase Browser
chromium