robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 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 | |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 8 | #ifndef GrRenderTargetContext_DEFINED |
| 9 | #define GrRenderTargetContext_DEFINED |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 10 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 11 | #include "include/core/SkCanvas.h" |
| 12 | #include "include/core/SkDrawable.h" |
| 13 | #include "include/core/SkRefCnt.h" |
| 14 | #include "include/core/SkSurface.h" |
| 15 | #include "include/core/SkSurfaceProps.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 16 | #include "include/private/GrTypesPriv.h" |
Greg Daniel | f41b2bd | 2019-08-22 16:19:24 -0400 | [diff] [blame] | 17 | #include "src/gpu/GrOpsTask.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 18 | #include "src/gpu/GrPaint.h" |
Greg Daniel | f91aeb2 | 2019-06-18 09:58:02 -0400 | [diff] [blame] | 19 | #include "src/gpu/GrRenderTargetProxy.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 20 | #include "src/gpu/GrSurfaceContext.h" |
Greg Daniel | a83de58 | 2019-10-22 09:33:25 -0400 | [diff] [blame] | 21 | #include "src/gpu/GrSurfaceProxyView.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 22 | #include "src/gpu/GrXferProcessor.h" |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 23 | #include "src/gpu/geometry/GrQuad.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 24 | #include "src/gpu/text/GrTextTarget.h" |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 25 | |
Greg Daniel | a5cb781 | 2017-06-16 09:45:32 -0400 | [diff] [blame] | 26 | class GrBackendSemaphore; |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 27 | class GrClip; |
Brian Osman | 2240be9 | 2017-10-18 13:15:13 -0400 | [diff] [blame] | 28 | class GrColorSpaceXform; |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 29 | class GrCoverageCountingPathRenderer; |
Brian Salomon | 9afd371 | 2016-12-01 10:59:09 -0500 | [diff] [blame] | 30 | class GrDrawOp; |
csmartdalton | 29df760 | 2016-08-31 11:55:52 -0700 | [diff] [blame] | 31 | class GrFixedClip; |
Robert Phillips | 0d075de | 2019-03-04 11:08:13 -0500 | [diff] [blame] | 32 | class GrOp; |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 33 | class GrRenderTarget; |
Brian Osman | 45580d3 | 2016-11-23 09:37:01 -0500 | [diff] [blame] | 34 | class GrRenderTargetContextPriv; |
Brian Salomon | 2fad74a | 2017-12-20 13:28:55 -0500 | [diff] [blame] | 35 | class GrShape; |
bsalomon | 6663acf | 2016-05-10 09:14:17 -0700 | [diff] [blame] | 36 | class GrStyle; |
Robert Phillips | eaa8625 | 2016-11-08 13:49:39 +0000 | [diff] [blame] | 37 | class GrTextureProxy; |
robertphillips | 4430239 | 2016-07-08 14:43:03 -0700 | [diff] [blame] | 38 | struct GrUserStencilSettings; |
Jim Van Verth | 3af1af9 | 2017-05-18 15:06:54 -0400 | [diff] [blame] | 39 | struct SkDrawShadowRec; |
Herb Derby | cddab25 | 2018-07-16 11:19:04 -0400 | [diff] [blame] | 40 | class SkGlyphRunList; |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 41 | struct SkIPoint; |
| 42 | struct SkIRect; |
msarett | 10e3d9b | 2016-08-18 15:46:03 -0700 | [diff] [blame] | 43 | class SkLatticeIter; |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 44 | class SkMatrix; |
robertphillips | 2334fb6 | 2015-06-17 05:43:33 -0700 | [diff] [blame] | 45 | class SkPaint; |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 46 | class SkPath; |
| 47 | struct SkPoint; |
| 48 | struct SkRect; |
Brian Osman | 45580d3 | 2016-11-23 09:37:01 -0500 | [diff] [blame] | 49 | class SkRegion; |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 50 | class SkRRect; |
jvanverth | 31ff762 | 2015-08-07 10:09:28 -0700 | [diff] [blame] | 51 | struct SkRSXform; |
Brian Osman | 3c35842 | 2020-03-23 10:44:12 -0400 | [diff] [blame] | 52 | class SkRuntimeEffect; |
robertphillips | 2334fb6 | 2015-06-17 05:43:33 -0700 | [diff] [blame] | 53 | class SkTextBlob; |
Brian Salomon | 199fb87 | 2017-02-06 09:41:10 -0500 | [diff] [blame] | 54 | class SkVertices; |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 55 | |
Brian Osman | 45580d3 | 2016-11-23 09:37:01 -0500 | [diff] [blame] | 56 | /** |
| 57 | * A helper object to orchestrate commands (draws, etc...) for GrSurfaces that are GrRenderTargets. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 58 | */ |
Brian Salomon | 57f211b | 2019-08-21 15:21:09 -0400 | [diff] [blame] | 59 | class GrRenderTargetContext : public GrSurfaceContext { |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 60 | public: |
Greg Daniel | e20fcad | 2020-01-08 11:52:34 -0500 | [diff] [blame] | 61 | static std::unique_ptr<GrRenderTargetContext> Make( |
Greg Daniel | ba0ff78 | 2020-01-07 15:42:57 -0500 | [diff] [blame] | 62 | GrRecordingContext*, GrColorType, sk_sp<SkColorSpace>, sk_sp<GrSurfaceProxy>, |
| 63 | GrSurfaceOrigin, const SkSurfaceProps*, bool managedOps = true); |
| 64 | |
Brian Salomon | a56a746 | 2020-02-07 14:17:25 -0500 | [diff] [blame] | 65 | static std::unique_ptr<GrRenderTargetContext> Make(GrRecordingContext*, |
| 66 | GrColorType, |
| 67 | sk_sp<SkColorSpace>, |
| 68 | SkBackingFit, |
| 69 | SkISize dimensions, |
| 70 | const GrBackendFormat&, |
| 71 | int sampleCnt, |
| 72 | GrMipMapped, |
| 73 | GrProtected, |
| 74 | GrSurfaceOrigin, |
| 75 | SkBudgeted, |
| 76 | const SkSurfaceProps*); |
Greg Daniel | e20fcad | 2020-01-08 11:52:34 -0500 | [diff] [blame] | 77 | |
| 78 | // Same as above but will use the default GrBackendFormat for the given GrColorType |
| 79 | static std::unique_ptr<GrRenderTargetContext> Make( |
Brian Salomon | a56a746 | 2020-02-07 14:17:25 -0500 | [diff] [blame] | 80 | GrRecordingContext*, |
| 81 | GrColorType, |
| 82 | sk_sp<SkColorSpace>, |
| 83 | SkBackingFit, |
| 84 | SkISize dimensions, |
| 85 | int sampleCnt = 1, |
| 86 | GrMipMapped = GrMipMapped::kNo, |
| 87 | GrProtected = GrProtected::kNo, |
| 88 | GrSurfaceOrigin = kBottomLeft_GrSurfaceOrigin, |
| 89 | SkBudgeted = SkBudgeted::kYes, |
| 90 | const SkSurfaceProps* = nullptr); |
Greg Daniel | e20fcad | 2020-01-08 11:52:34 -0500 | [diff] [blame] | 91 | |
| 92 | // Same as previous factory but will try to use fallback GrColorTypes if the one passed in |
| 93 | // fails. The fallback GrColorType will have at least the number of channels and precision per |
| 94 | // channel as the passed in GrColorType. It may also swizzle the changes (e.g., BGRA -> RGBA). |
| 95 | // SRGB-ness will be preserved. |
| 96 | static std::unique_ptr<GrRenderTargetContext> MakeWithFallback( |
Brian Salomon | a56a746 | 2020-02-07 14:17:25 -0500 | [diff] [blame] | 97 | GrRecordingContext*, |
| 98 | GrColorType, |
| 99 | sk_sp<SkColorSpace>, |
| 100 | SkBackingFit, |
| 101 | SkISize dimensions, |
| 102 | int sampleCnt = 1, |
| 103 | GrMipMapped = GrMipMapped::kNo, |
| 104 | GrProtected = GrProtected::kNo, |
| 105 | GrSurfaceOrigin = kBottomLeft_GrSurfaceOrigin, |
| 106 | SkBudgeted = SkBudgeted::kYes, |
| 107 | const SkSurfaceProps* = nullptr); |
Greg Daniel | e20fcad | 2020-01-08 11:52:34 -0500 | [diff] [blame] | 108 | |
Greg Daniel | ba0ff78 | 2020-01-07 15:42:57 -0500 | [diff] [blame] | 109 | // These match the definitions in SkSurface & GrSurface.h, for whence they came |
| 110 | typedef void* ReleaseContext; |
| 111 | typedef void (*ReleaseProc)(ReleaseContext); |
| 112 | |
| 113 | // Creates a GrRenderTargetContext that wraps the passed in GrBackendTexture. |
| 114 | static std::unique_ptr<GrRenderTargetContext> MakeFromBackendTexture( |
| 115 | GrRecordingContext*, GrColorType, sk_sp<SkColorSpace>, const GrBackendTexture&, |
| 116 | int sampleCnt, GrSurfaceOrigin, const SkSurfaceProps*, ReleaseProc releaseProc, |
| 117 | ReleaseContext releaseCtx); |
| 118 | |
| 119 | static std::unique_ptr<GrRenderTargetContext> MakeFromBackendTextureAsRenderTarget( |
| 120 | GrRecordingContext*, GrColorType, sk_sp<SkColorSpace>, const GrBackendTexture&, |
| 121 | int sampleCnt, GrSurfaceOrigin, const SkSurfaceProps*); |
| 122 | |
| 123 | static std::unique_ptr<GrRenderTargetContext> MakeFromBackendRenderTarget( |
| 124 | GrRecordingContext*, GrColorType, sk_sp<SkColorSpace>, const GrBackendRenderTarget&, |
| 125 | GrSurfaceOrigin, const SkSurfaceProps*, ReleaseProc releaseProc, |
| 126 | ReleaseContext releaseCtx); |
| 127 | |
| 128 | static std::unique_ptr<GrRenderTargetContext> MakeFromVulkanSecondaryCB( |
| 129 | GrRecordingContext*, const SkImageInfo&, const GrVkDrawableInfo&, |
| 130 | const SkSurfaceProps*); |
| 131 | |
Greg Daniel | 3912a4b | 2020-01-14 09:56:04 -0500 | [diff] [blame] | 132 | GrRenderTargetContext(GrRecordingContext*, GrSurfaceProxyView readView, |
Brian Salomon | 8afde5f | 2020-04-01 16:22:00 -0400 | [diff] [blame^] | 133 | GrSurfaceProxyView writeView, GrColorType, sk_sp<SkColorSpace>, |
Greg Daniel | 3912a4b | 2020-01-14 09:56:04 -0500 | [diff] [blame] | 134 | const SkSurfaceProps*, bool managedOpsTask = true); |
Greg Daniel | bfa19c4 | 2019-12-19 16:41:40 -0500 | [diff] [blame] | 135 | |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 136 | ~GrRenderTargetContext() override; |
robertphillips | 2334fb6 | 2015-06-17 05:43:33 -0700 | [diff] [blame] | 137 | |
Robert Phillips | e4643cc | 2018-08-14 13:01:29 -0400 | [diff] [blame] | 138 | virtual void drawGlyphRunList(const GrClip&, const SkMatrix& viewMatrix, const SkGlyphRunList&); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 139 | |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 140 | /** |
| 141 | * Provides a perfomance hint that the render target's contents are allowed |
| 142 | * to become undefined. |
| 143 | */ |
robertphillips | 2e1e51f | 2015-10-15 08:01:48 -0700 | [diff] [blame] | 144 | void discard(); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 145 | |
Chris Dalton | 344e903 | 2017-12-11 15:42:09 -0700 | [diff] [blame] | 146 | enum class CanClearFullscreen : bool { |
| 147 | kNo = false, |
| 148 | kYes = true |
| 149 | }; |
| 150 | |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 151 | /** |
| 152 | * Clear the entire or rect of the render target, ignoring any clips. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 153 | * @param rect the rect to clear or the whole thing if rect is NULL. |
| 154 | * @param color the color to clear to. |
Chris Dalton | 344e903 | 2017-12-11 15:42:09 -0700 | [diff] [blame] | 155 | * @param CanClearFullscreen allows partial clears to be converted to fullscreen clears on |
| 156 | * tiling platforms where that is an optimization. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 157 | */ |
Brian Osman | 9a9baae | 2018-11-05 15:06:26 -0500 | [diff] [blame] | 158 | void clear(const SkIRect* rect, const SkPMColor4f& color, CanClearFullscreen); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 159 | |
Chris Dalton | 0493fbd | 2019-09-18 15:49:46 -0600 | [diff] [blame] | 160 | void clear(const SkPMColor4f& color) { |
| 161 | return this->clear(nullptr, color, CanClearFullscreen::kYes); |
| 162 | } |
| 163 | |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 164 | /** |
| 165 | * Draw everywhere (respecting the clip) with the paint. |
| 166 | */ |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 167 | void drawPaint(const GrClip&, GrPaint&&, const SkMatrix& viewMatrix); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 168 | |
| 169 | /** |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 170 | * Draw the rect using a paint. |
| 171 | * @param paint describes how to color pixels. |
| 172 | * @param GrAA Controls whether rect is antialiased |
| 173 | * @param viewMatrix transformation matrix |
| 174 | * @param style The style to apply. Null means fill. Currently path effects are not |
| 175 | * allowed. |
| 176 | * The rects coords are used to access the paint (through texture matrix) |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 177 | */ |
robertphillips | 2e1e51f | 2015-10-15 08:01:48 -0700 | [diff] [blame] | 178 | void drawRect(const GrClip&, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 179 | GrPaint&& paint, |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 180 | GrAA, |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 181 | const SkMatrix& viewMatrix, |
| 182 | const SkRect&, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 183 | const GrStyle* style = nullptr); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 184 | |
| 185 | /** |
bsalomon | a2e69fc | 2015-11-05 10:41:43 -0800 | [diff] [blame] | 186 | * Maps a rectangle of shader coordinates to a rectangle and fills that rectangle. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 187 | * |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 188 | * @param paint describes how to color pixels. |
| 189 | * @param GrAA Controls whether rect is antialiased |
| 190 | * @param viewMatrix transformation matrix which applies to rectToDraw |
| 191 | * @param rectToDraw the rectangle to draw |
| 192 | * @param localRect the rectangle of shader coordinates applied to rectToDraw |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 193 | */ |
Michael Ludwig | 136f45a | 2019-02-19 11:44:41 -0500 | [diff] [blame] | 194 | void fillRectToRect(const GrClip& clip, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 195 | GrPaint&& paint, |
Michael Ludwig | 136f45a | 2019-02-19 11:44:41 -0500 | [diff] [blame] | 196 | GrAA aa, |
bsalomon | a2e69fc | 2015-11-05 10:41:43 -0800 | [diff] [blame] | 197 | const SkMatrix& viewMatrix, |
| 198 | const SkRect& rectToDraw, |
Michael Ludwig | 136f45a | 2019-02-19 11:44:41 -0500 | [diff] [blame] | 199 | const SkRect& localRect) { |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 200 | DrawQuad quad{GrQuad::MakeFromRect(rectToDraw, viewMatrix), GrQuad(localRect), |
| 201 | aa == GrAA::kYes ? GrQuadAAFlags::kAll : GrQuadAAFlags::kNone}; |
| 202 | this->drawFilledQuad(clip, std::move(paint), aa, &quad); |
Michael Ludwig | 136f45a | 2019-02-19 11:44:41 -0500 | [diff] [blame] | 203 | } |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 204 | |
| 205 | /** |
bsalomon | a2e69fc | 2015-11-05 10:41:43 -0800 | [diff] [blame] | 206 | * Fills a rect with a paint and a localMatrix. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 207 | */ |
bsalomon | a2e69fc | 2015-11-05 10:41:43 -0800 | [diff] [blame] | 208 | void fillRectWithLocalMatrix(const GrClip& clip, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 209 | GrPaint&& paint, |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 210 | GrAA aa, |
bsalomon | a2e69fc | 2015-11-05 10:41:43 -0800 | [diff] [blame] | 211 | const SkMatrix& viewMatrix, |
| 212 | const SkRect& rect, |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 213 | const SkMatrix& localMatrix) { |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 214 | DrawQuad quad{GrQuad::MakeFromRect(rect, viewMatrix), |
| 215 | GrQuad::MakeFromRect(rect, localMatrix), |
| 216 | aa == GrAA::kYes ? GrQuadAAFlags::kAll : GrQuadAAFlags::kNone}; |
| 217 | this->drawFilledQuad(clip, std::move(paint), aa, &quad); |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 218 | } |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 219 | |
Michael Ludwig | 7545190 | 2019-01-23 11:14:29 -0500 | [diff] [blame] | 220 | /** |
| 221 | * Creates an op that draws a fill rect with per-edge control over anti-aliasing. |
Michael Ludwig | ce62dec | 2019-02-19 11:48:46 -0500 | [diff] [blame] | 222 | * |
| 223 | * This is a specialized version of fillQuadWithEdgeAA, but is kept separate since knowing |
| 224 | * the geometry is a rectangle affords more optimizations. |
Michael Ludwig | 7545190 | 2019-01-23 11:14:29 -0500 | [diff] [blame] | 225 | */ |
Michael Ludwig | 136f45a | 2019-02-19 11:44:41 -0500 | [diff] [blame] | 226 | void fillRectWithEdgeAA(const GrClip& clip, GrPaint&& paint, GrAA aa, GrQuadAAFlags edgeAA, |
| 227 | const SkMatrix& viewMatrix, const SkRect& rect, |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 228 | const SkRect* optionalLocalRect = nullptr) { |
| 229 | const SkRect& localRect = optionalLocalRect ? *optionalLocalRect : rect; |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 230 | DrawQuad quad{GrQuad::MakeFromRect(rect, viewMatrix), GrQuad(localRect), edgeAA}; |
| 231 | this->drawFilledQuad(clip, std::move(paint), aa, &quad); |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 232 | } |
Michael Ludwig | 7545190 | 2019-01-23 11:14:29 -0500 | [diff] [blame] | 233 | |
Michael Ludwig | ce62dec | 2019-02-19 11:48:46 -0500 | [diff] [blame] | 234 | /** |
| 235 | * Similar to fillRectWithEdgeAA but draws an arbitrary 2D convex quadrilateral transformed |
| 236 | * by 'viewMatrix', with per-edge control over anti-aliasing. The quad should follow the |
| 237 | * ordering used by SkRect::toQuad(), which determines how the edge AA is applied: |
| 238 | * - "top" = points [0] and [1] |
| 239 | * - "right" = points[1] and [2] |
| 240 | * - "bottom" = points[2] and [3] |
| 241 | * - "left" = points[3] and [0] |
| 242 | * |
| 243 | * The last argument, 'optionalLocalQuad', can be null if no separate local coordinates are |
| 244 | * necessary. |
| 245 | */ |
| 246 | void fillQuadWithEdgeAA(const GrClip& clip, GrPaint&& paint, GrAA aa, GrQuadAAFlags edgeAA, |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 247 | const SkMatrix& viewMatrix, const SkPoint points[4], |
| 248 | const SkPoint optionalLocalPoints[4]) { |
| 249 | const SkPoint* localPoints = optionalLocalPoints ? optionalLocalPoints : points; |
| 250 | DrawQuad quad{GrQuad::MakeFromSkQuad(points, viewMatrix), |
| 251 | GrQuad::MakeFromSkQuad(localPoints, SkMatrix::I()), edgeAA}; |
| 252 | this->drawFilledQuad(clip, std::move(paint), aa, &quad); |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 253 | } |
Michael Ludwig | ce62dec | 2019-02-19 11:48:46 -0500 | [diff] [blame] | 254 | |
Michael Ludwig | 6985853 | 2018-11-28 15:34:34 -0500 | [diff] [blame] | 255 | /** Used with drawQuadSet */ |
| 256 | struct QuadSetEntry { |
| 257 | SkRect fRect; |
| 258 | SkPMColor4f fColor; // Overrides any color on the GrPaint |
| 259 | SkMatrix fLocalMatrix; |
| 260 | GrQuadAAFlags fAAFlags; |
| 261 | }; |
| 262 | |
Michael Ludwig | 7545190 | 2019-01-23 11:14:29 -0500 | [diff] [blame] | 263 | // TODO(michaelludwig) - remove if the bulk API is not useful for SkiaRenderer |
Michael Ludwig | 6985853 | 2018-11-28 15:34:34 -0500 | [diff] [blame] | 264 | void drawQuadSet(const GrClip& clip, GrPaint&& paint, GrAA aa, const SkMatrix& viewMatrix, |
| 265 | const QuadSetEntry[], int cnt); |
| 266 | |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 267 | /** |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 268 | * Creates an op that draws a subrectangle of a texture. The passed color is modulated by the |
| 269 | * texture's color. 'srcRect' specifies the rectangle of the texture to draw. 'dstRect' |
| 270 | * specifies the rectangle to draw in local coords which will be transformed by 'viewMatrix' to |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 271 | * device space. |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 272 | */ |
Greg Daniel | 40903af | 2020-01-30 14:55:05 -0500 | [diff] [blame] | 273 | void drawTexture(const GrClip& clip, GrSurfaceProxyView view, SkAlphaType srcAlphaType, |
| 274 | GrSamplerState::Filter filter, SkBlendMode mode, const SkPMColor4f& color, |
| 275 | const SkRect& srcRect, const SkRect& dstRect, GrAA aa, GrQuadAAFlags edgeAA, |
| 276 | SkCanvas::SrcRectConstraint constraint, const SkMatrix& viewMatrix, |
| 277 | sk_sp<GrColorSpaceXform> texXform) { |
Michael Ludwig | aee26ea | 2019-07-08 16:22:48 +0000 | [diff] [blame] | 278 | const SkRect* domain = constraint == SkCanvas::kStrict_SrcRectConstraint ? |
| 279 | &srcRect : nullptr; |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 280 | DrawQuad quad{GrQuad::MakeFromRect(dstRect, viewMatrix), GrQuad(srcRect), edgeAA}; |
| 281 | |
Greg Daniel | 40903af | 2020-01-30 14:55:05 -0500 | [diff] [blame] | 282 | this->drawTexturedQuad(clip, std::move(view), srcAlphaType, std::move(texXform), |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 283 | filter, color, mode, aa, &quad, domain); |
Michael Ludwig | aee26ea | 2019-07-08 16:22:48 +0000 | [diff] [blame] | 284 | } |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 285 | |
Michael Ludwig | ce62dec | 2019-02-19 11:48:46 -0500 | [diff] [blame] | 286 | /** |
| 287 | * Variant of drawTexture that instead draws the texture applied to 'dstQuad' transformed by |
| 288 | * 'viewMatrix', using the 'srcQuad' texture coordinates clamped to the optional 'domain'. If |
| 289 | * 'domain' is null, it's equivalent to using the fast src rect constraint. If 'domain' is |
| 290 | * provided, the strict src rect constraint is applied using 'domain'. |
| 291 | */ |
Greg Daniel | 2f3cd4f | 2020-02-07 11:07:25 -0500 | [diff] [blame] | 292 | void drawTextureQuad(const GrClip& clip, GrSurfaceProxyView view, GrColorType srcColorType, |
Brian Salomon | fc11844 | 2019-11-22 19:09:27 -0500 | [diff] [blame] | 293 | SkAlphaType srcAlphaType, GrSamplerState::Filter filter, SkBlendMode mode, |
| 294 | const SkPMColor4f& color, const SkPoint srcQuad[4], |
| 295 | const SkPoint dstQuad[4], GrAA aa, GrQuadAAFlags edgeAA, |
| 296 | const SkRect* domain, const SkMatrix& viewMatrix, |
Michael Ludwig | aee26ea | 2019-07-08 16:22:48 +0000 | [diff] [blame] | 297 | sk_sp<GrColorSpaceXform> texXform) { |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 298 | DrawQuad quad{GrQuad::MakeFromSkQuad(dstQuad, viewMatrix), |
| 299 | GrQuad::MakeFromSkQuad(srcQuad, SkMatrix::I()), edgeAA}; |
Greg Daniel | 2f3cd4f | 2020-02-07 11:07:25 -0500 | [diff] [blame] | 300 | this->drawTexturedQuad(clip, std::move(view), srcAlphaType, std::move(texXform), |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 301 | filter, color, mode, aa, &quad, domain); |
Michael Ludwig | aee26ea | 2019-07-08 16:22:48 +0000 | [diff] [blame] | 302 | } |
Michael Ludwig | ce62dec | 2019-02-19 11:48:46 -0500 | [diff] [blame] | 303 | |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 304 | /** Used with drawTextureSet */ |
| 305 | struct TextureSetEntry { |
Greg Daniel | 549325c | 2019-10-30 16:19:20 -0400 | [diff] [blame] | 306 | GrSurfaceProxyView fProxyView; |
Brian Salomon | fc11844 | 2019-11-22 19:09:27 -0500 | [diff] [blame] | 307 | SkAlphaType fSrcAlphaType; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 308 | SkRect fSrcRect; |
| 309 | SkRect fDstRect; |
Michael Ludwig | 1433cfd | 2019-02-27 17:12:30 -0500 | [diff] [blame] | 310 | const SkPoint* fDstClipQuad; // Must be null, or point to an array of 4 points |
Michael Ludwig | 7ae2ab5 | 2019-03-05 16:00:20 -0500 | [diff] [blame] | 311 | const SkMatrix* fPreViewMatrix; // If not null, entry's CTM is 'viewMatrix' * fPreViewMatrix |
Brian Salomon | 1da5cad | 2018-11-21 09:21:18 -0500 | [diff] [blame] | 312 | float fAlpha; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 313 | GrQuadAAFlags fAAFlags; |
| 314 | }; |
| 315 | /** |
| 316 | * Draws a set of textures with a shared filter, color, view matrix, color xform, and |
| 317 | * texture color xform. The textures must all have the same GrTextureType and GrConfig. |
Michael Ludwig | ce62dec | 2019-02-19 11:48:46 -0500 | [diff] [blame] | 318 | * |
| 319 | * If any entries provide a non-null fDstClip array, it will be read from immediately based on |
| 320 | * fDstClipCount, so the pointer can become invalid after this returns. |
Michael Ludwig | 379e496 | 2019-12-06 13:21:26 -0500 | [diff] [blame] | 321 | * |
Hal Canary | 425929c | 2019-12-09 11:55:40 -0500 | [diff] [blame] | 322 | * 'proxRunCnt' is the number of proxy changes encountered in the entry array. Technically this |
Michael Ludwig | 379e496 | 2019-12-06 13:21:26 -0500 | [diff] [blame] | 323 | * can be inferred from the array within this function, but the information is already known |
| 324 | * by SkGpuDevice, so no need to incur another iteration over the array. |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 325 | */ |
Hal Canary | 425929c | 2019-12-09 11:55:40 -0500 | [diff] [blame] | 326 | void drawTextureSet(const GrClip&, TextureSetEntry[], int cnt, int proxyRunCnt, |
Michael Ludwig | 379e496 | 2019-12-06 13:21:26 -0500 | [diff] [blame] | 327 | GrSamplerState::Filter, SkBlendMode mode, GrAA aa, |
| 328 | SkCanvas::SrcRectConstraint, const SkMatrix& viewMatrix, |
| 329 | sk_sp<GrColorSpaceXform> texXform); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 330 | |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 331 | /** |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 332 | * Draw a roundrect using a paint. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 333 | * |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 334 | * @param paint describes how to color pixels. |
| 335 | * @param GrAA Controls whether rrect is antialiased. |
| 336 | * @param viewMatrix transformation matrix |
| 337 | * @param rrect the roundrect to draw |
| 338 | * @param style style to apply to the rrect. Currently path effects are not allowed. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 339 | */ |
robertphillips | 2e1e51f | 2015-10-15 08:01:48 -0700 | [diff] [blame] | 340 | void drawRRect(const GrClip&, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 341 | GrPaint&&, |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 342 | GrAA, |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 343 | const SkMatrix& viewMatrix, |
| 344 | const SkRRect& rrect, |
bsalomon | 6663acf | 2016-05-10 09:14:17 -0700 | [diff] [blame] | 345 | const GrStyle& style); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 346 | |
| 347 | /** |
Jim Van Verth | 3af1af9 | 2017-05-18 15:06:54 -0400 | [diff] [blame] | 348 | * Use a fast method to render the ambient and spot shadows for a path. |
| 349 | * Will return false if not possible for the given path. |
Jim Van Verth | c590341 | 2016-11-17 15:27:09 -0500 | [diff] [blame] | 350 | * |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 351 | * @param viewMatrix transformation matrix |
Jim Van Verth | 3af1af9 | 2017-05-18 15:06:54 -0400 | [diff] [blame] | 352 | * @param path the path to shadow |
| 353 | * @param rec parameters for shadow rendering |
Jim Van Verth | c590341 | 2016-11-17 15:27:09 -0500 | [diff] [blame] | 354 | */ |
Jim Van Verth | 3af1af9 | 2017-05-18 15:06:54 -0400 | [diff] [blame] | 355 | bool drawFastShadow(const GrClip&, |
Jim Van Verth | 3af1af9 | 2017-05-18 15:06:54 -0400 | [diff] [blame] | 356 | const SkMatrix& viewMatrix, |
| 357 | const SkPath& path, |
| 358 | const SkDrawShadowRec& rec); |
Jim Van Verth | c590341 | 2016-11-17 15:27:09 -0500 | [diff] [blame] | 359 | |
| 360 | /** |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 361 | * Shortcut for filling a SkPath consisting of nested rrects using a paint. The result is |
| 362 | * undefined if outer does not contain inner. |
robertphillips | 0009589 | 2016-02-29 13:50:40 -0800 | [diff] [blame] | 363 | * |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 364 | * @param paint describes how to color pixels. |
| 365 | * @param GrAA Controls whether rrects edges are antialiased |
| 366 | * @param viewMatrix transformation matrix |
| 367 | * @param outer the outer roundrect |
| 368 | * @param inner the inner roundrect |
robertphillips | 0009589 | 2016-02-29 13:50:40 -0800 | [diff] [blame] | 369 | */ |
| 370 | void drawDRRect(const GrClip&, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 371 | GrPaint&&, |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 372 | GrAA, |
robertphillips | 0009589 | 2016-02-29 13:50:40 -0800 | [diff] [blame] | 373 | const SkMatrix& viewMatrix, |
| 374 | const SkRRect& outer, |
| 375 | const SkRRect& inner); |
| 376 | |
| 377 | /** |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 378 | * Draws a path. |
| 379 | * |
| 380 | * @param paint describes how to color pixels. |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 381 | * @param GrAA Controls whether the path is antialiased. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 382 | * @param viewMatrix transformation matrix |
| 383 | * @param path the path to draw |
bsalomon | 6663acf | 2016-05-10 09:14:17 -0700 | [diff] [blame] | 384 | * @param style style to apply to the path. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 385 | */ |
robertphillips | 2e1e51f | 2015-10-15 08:01:48 -0700 | [diff] [blame] | 386 | void drawPath(const GrClip&, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 387 | GrPaint&&, |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 388 | GrAA, |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 389 | const SkMatrix& viewMatrix, |
| 390 | const SkPath&, |
Robert Phillips | 20390c3 | 2018-08-17 11:01:03 -0400 | [diff] [blame] | 391 | const GrStyle&); |
| 392 | |
| 393 | /** |
| 394 | * Draws a shape. |
| 395 | * |
| 396 | * @param paint describes how to color pixels. |
| 397 | * @param GrAA Controls whether the path is antialiased. |
| 398 | * @param viewMatrix transformation matrix |
| 399 | * @param shape the shape to draw |
| 400 | */ |
| 401 | void drawShape(const GrClip&, |
| 402 | GrPaint&&, |
| 403 | GrAA, |
| 404 | const SkMatrix& viewMatrix, |
| 405 | const GrShape&); |
| 406 | |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 407 | |
| 408 | /** |
| 409 | * Draws vertices with a paint. |
| 410 | * |
Brian Osman | ae0c50c | 2017-05-25 16:56:34 -0400 | [diff] [blame] | 411 | * @param paint describes how to color pixels. |
| 412 | * @param viewMatrix transformation matrix |
| 413 | * @param vertices specifies the mesh to draw. |
| 414 | * @param overridePrimType primitive type to draw. If NULL, derive prim type from vertices. |
Brian Osman | 3c35842 | 2020-03-23 10:44:12 -0400 | [diff] [blame] | 415 | * @param effect runtime effect that will handle custom vertex attributes. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 416 | */ |
robertphillips | 2e1e51f | 2015-10-15 08:01:48 -0700 | [diff] [blame] | 417 | void drawVertices(const GrClip&, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 418 | GrPaint&& paint, |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 419 | const SkMatrix& viewMatrix, |
Brian Osman | ae0c50c | 2017-05-25 16:56:34 -0400 | [diff] [blame] | 420 | sk_sp<SkVertices> vertices, |
Brian Osman | 3c35842 | 2020-03-23 10:44:12 -0400 | [diff] [blame] | 421 | GrPrimitiveType* overridePrimType = nullptr, |
| 422 | const SkRuntimeEffect* effect = nullptr); |
Brian Salomon | 199fb87 | 2017-02-06 09:41:10 -0500 | [diff] [blame] | 423 | |
| 424 | /** |
Brian Osman | 4d92b89 | 2019-03-24 00:53:23 +0000 | [diff] [blame] | 425 | * Draws textured sprites from an atlas with a paint. This currently does not support AA for the |
| 426 | * sprite rectangle edges. |
| 427 | * |
| 428 | * @param paint describes how to color pixels. |
| 429 | * @param viewMatrix transformation matrix |
| 430 | * @param spriteCount number of sprites. |
| 431 | * @param xform array of compressed transformation data, required. |
| 432 | * @param texRect array of texture rectangles used to access the paint. |
| 433 | * @param colors optional array of per-sprite colors, supercedes |
| 434 | * the paint's color field. |
| 435 | */ |
| 436 | void drawAtlas(const GrClip&, |
| 437 | GrPaint&& paint, |
| 438 | const SkMatrix& viewMatrix, |
| 439 | int spriteCount, |
| 440 | const SkRSXform xform[], |
| 441 | const SkRect texRect[], |
| 442 | const SkColor colors[]); |
| 443 | |
| 444 | /** |
msarett | cc319b9 | 2016-08-25 18:07:18 -0700 | [diff] [blame] | 445 | * Draws a region. |
| 446 | * |
| 447 | * @param paint describes how to color pixels |
| 448 | * @param viewMatrix transformation matrix |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 449 | * @param aa should the rects of the region be antialiased. |
msarett | cc319b9 | 2016-08-25 18:07:18 -0700 | [diff] [blame] | 450 | * @param region the region to be drawn |
| 451 | * @param style style to apply to the region |
| 452 | */ |
| 453 | void drawRegion(const GrClip&, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 454 | GrPaint&& paint, |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 455 | GrAA aa, |
msarett | cc319b9 | 2016-08-25 18:07:18 -0700 | [diff] [blame] | 456 | const SkMatrix& viewMatrix, |
| 457 | const SkRegion& region, |
Stan Iliev | 73d8fd9 | 2017-08-02 15:36:24 -0400 | [diff] [blame] | 458 | const GrStyle& style, |
| 459 | const GrUserStencilSettings* ss = nullptr); |
msarett | cc319b9 | 2016-08-25 18:07:18 -0700 | [diff] [blame] | 460 | |
jvanverth | 31ff762 | 2015-08-07 10:09:28 -0700 | [diff] [blame] | 461 | /** |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 462 | * Draws an oval. |
| 463 | * |
| 464 | * @param paint describes how to color pixels. |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 465 | * @param GrAA Controls whether the oval is antialiased. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 466 | * @param viewMatrix transformation matrix |
| 467 | * @param oval the bounding rect of the oval. |
bsalomon | 6663acf | 2016-05-10 09:14:17 -0700 | [diff] [blame] | 468 | * @param style style to apply to the oval. Currently path effects are not allowed. |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 469 | */ |
robertphillips | 2e1e51f | 2015-10-15 08:01:48 -0700 | [diff] [blame] | 470 | void drawOval(const GrClip&, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 471 | GrPaint&& paint, |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 472 | GrAA, |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 473 | const SkMatrix& viewMatrix, |
| 474 | const SkRect& oval, |
bsalomon | 6663acf | 2016-05-10 09:14:17 -0700 | [diff] [blame] | 475 | const GrStyle& style); |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 476 | /** |
| 477 | * Draws a partial arc of an oval. |
| 478 | * |
| 479 | * @param paint describes how to color pixels. |
Brian Salomon | 9950408 | 2016-12-09 15:51:31 -0500 | [diff] [blame] | 480 | * @param GrGrAA Controls whether the arc is antialiased. |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 481 | * @param viewMatrix transformation matrix. |
| 482 | * @param oval the bounding rect of the oval. |
| 483 | * @param startAngle starting angle in degrees. |
| 484 | * @param sweepAngle angle to sweep in degrees. Must be in (-360, 360) |
| 485 | * @param useCenter true means that the implied path begins at the oval center, connects as |
| 486 | * a line to the point indicated by the start contains the arc indicated by |
| 487 | * the sweep angle. If false the line beginning at the center point is |
| 488 | * omitted. |
| 489 | * @param style style to apply to the oval. |
| 490 | */ |
bsalomon | 4f3a0ca | 2016-08-22 13:14:26 -0700 | [diff] [blame] | 491 | void drawArc(const GrClip&, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 492 | GrPaint&& paint, |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 493 | GrAA, |
bsalomon | 4f3a0ca | 2016-08-22 13:14:26 -0700 | [diff] [blame] | 494 | const SkMatrix& viewMatrix, |
| 495 | const SkRect& oval, |
| 496 | SkScalar startAngle, |
| 497 | SkScalar sweepAngle, |
| 498 | bool useCenter, |
| 499 | const GrStyle& style); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 500 | |
joshualitt | 33a5fce | 2015-11-18 13:28:51 -0800 | [diff] [blame] | 501 | /** |
bsalomon | 4f3a0ca | 2016-08-22 13:14:26 -0700 | [diff] [blame] | 502 | * Draw the image as a set of rects, specified by |iter|. |
joshualitt | 33a5fce | 2015-11-18 13:28:51 -0800 | [diff] [blame] | 503 | */ |
msarett | 10e3d9b | 2016-08-18 15:46:03 -0700 | [diff] [blame] | 504 | void drawImageLattice(const GrClip&, |
Brian Salomon | 2a943df | 2018-05-04 13:43:19 -0400 | [diff] [blame] | 505 | GrPaint&&, |
msarett | 10e3d9b | 2016-08-18 15:46:03 -0700 | [diff] [blame] | 506 | const SkMatrix& viewMatrix, |
Greg Daniel | ed96bca | 2019-12-05 15:05:54 -0500 | [diff] [blame] | 507 | GrSurfaceProxyView, |
Greg Daniel | 82c6b10 | 2020-01-21 10:33:22 -0500 | [diff] [blame] | 508 | SkAlphaType alphaType, |
Brian Salomon | 2a943df | 2018-05-04 13:43:19 -0400 | [diff] [blame] | 509 | sk_sp<GrColorSpaceXform>, |
| 510 | GrSamplerState::Filter, |
| 511 | std::unique_ptr<SkLatticeIter>, |
msarett | 10e3d9b | 2016-08-18 15:46:03 -0700 | [diff] [blame] | 512 | const SkRect& dst); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 513 | |
robertphillips | 8c523e0 | 2016-07-26 07:41:00 -0700 | [diff] [blame] | 514 | /** |
Greg Daniel | 46cfbc6 | 2019-06-07 11:43:30 -0400 | [diff] [blame] | 515 | * Draws the src texture with no matrix. The dstRect is the dstPoint with the width and height |
| 516 | * of the srcRect. The srcRect and dstRect are clipped to the bounds of the src and dst surfaces |
| 517 | * respectively. |
| 518 | */ |
Greg Daniel | 573312e | 2020-02-07 17:22:35 -0500 | [diff] [blame] | 519 | bool blitTexture(GrSurfaceProxyView view, const SkIRect& srcRect, const SkIPoint& dstPoint); |
Greg Daniel | 46cfbc6 | 2019-06-07 11:43:30 -0400 | [diff] [blame] | 520 | |
| 521 | /** |
Greg Daniel | 64cc9aa | 2018-10-19 13:54:56 -0400 | [diff] [blame] | 522 | * Adds the necessary signal and wait semaphores and adds the passed in SkDrawable to the |
| 523 | * command stream. |
| 524 | */ |
| 525 | void drawDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler>, const SkRect& bounds); |
| 526 | |
Brian Salomon | ab32f65 | 2019-05-10 14:24:50 -0400 | [diff] [blame] | 527 | using ReadPixelsCallback = SkSurface::ReadPixelsCallback; |
| 528 | using ReadPixelsContext = SkSurface::ReadPixelsContext; |
Brian Salomon | 024bd00 | 2019-06-11 11:38:16 -0400 | [diff] [blame] | 529 | using RescaleGamma = SkSurface::RescaleGamma; |
| 530 | |
| 531 | // GPU implementation for SkSurface::asyncRescaleAndReadPixels. |
Brian Salomon | 031b0ba | 2019-05-23 11:05:26 -0400 | [diff] [blame] | 532 | void asyncRescaleAndReadPixels(const SkImageInfo& info, const SkIRect& srcRect, |
Brian Salomon | 024bd00 | 2019-06-11 11:38:16 -0400 | [diff] [blame] | 533 | RescaleGamma rescaleGamma, SkFilterQuality rescaleQuality, |
| 534 | ReadPixelsCallback callback, ReadPixelsContext context); |
| 535 | // GPU implementation for SkSurface::asyncRescaleAndReadPixelsYUV420. |
| 536 | void asyncRescaleAndReadPixelsYUV420(SkYUVColorSpace yuvColorSpace, |
Brian Salomon | 9241a6d | 2019-10-03 13:26:54 -0400 | [diff] [blame] | 537 | sk_sp<SkColorSpace> dstColorSpace, |
| 538 | const SkIRect& srcRect, |
Brian Salomon | a56a746 | 2020-02-07 14:17:25 -0500 | [diff] [blame] | 539 | SkISize dstSize, |
Brian Salomon | 9241a6d | 2019-10-03 13:26:54 -0400 | [diff] [blame] | 540 | RescaleGamma rescaleGamma, |
Brian Salomon | 024bd00 | 2019-06-11 11:38:16 -0400 | [diff] [blame] | 541 | SkFilterQuality rescaleQuality, |
Brian Salomon | 9241a6d | 2019-10-03 13:26:54 -0400 | [diff] [blame] | 542 | ReadPixelsCallback callback, |
Brian Salomon | 024bd00 | 2019-06-11 11:38:16 -0400 | [diff] [blame] | 543 | ReadPixelsContext context); |
Brian Salomon | ab32f65 | 2019-05-10 14:24:50 -0400 | [diff] [blame] | 544 | |
Greg Daniel | 64cc9aa | 2018-10-19 13:54:56 -0400 | [diff] [blame] | 545 | /** |
robertphillips | 8c523e0 | 2016-07-26 07:41:00 -0700 | [diff] [blame] | 546 | * After this returns any pending surface IO will be issued to the backend 3D API and |
| 547 | * if the surface has MSAA it will be resolved. |
| 548 | */ |
Greg Daniel | e6bfb7d | 2019-04-17 15:26:11 -0400 | [diff] [blame] | 549 | GrSemaphoresSubmitted flush(SkSurface::BackendSurfaceAccess access, const GrFlushInfo&); |
Greg Daniel | a5cb781 | 2017-06-16 09:45:32 -0400 | [diff] [blame] | 550 | |
| 551 | /** |
| 552 | * The next time this GrRenderTargetContext is flushed, the gpu will wait on the passed in |
| 553 | * semaphores before executing any commands. |
| 554 | */ |
Robert Phillips | bc4994a | 2019-02-14 08:36:56 -0500 | [diff] [blame] | 555 | bool waitOnSemaphores(int numSemaphores, const GrBackendSemaphore waitSemaphores[]); |
robertphillips | 8c523e0 | 2016-07-26 07:41:00 -0700 | [diff] [blame] | 556 | |
Greg Daniel | 46e366a | 2019-12-16 14:38:36 -0500 | [diff] [blame] | 557 | int numSamples() const { return this->asRenderTargetProxy()->numSamples(); } |
robertphillips | ca6eafc | 2016-05-17 09:57:46 -0700 | [diff] [blame] | 558 | const SkSurfaceProps& surfaceProps() const { return fSurfaceProps; } |
Greg Daniel | 46e366a | 2019-12-16 14:38:36 -0500 | [diff] [blame] | 559 | bool wrapsVkSecondaryCB() const { return this->asRenderTargetProxy()->wrapsVkSecondaryCB(); } |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 560 | GrMipMapped mipMapped() const; |
robertphillips | 7bceedc | 2015-12-01 12:51:26 -0800 | [diff] [blame] | 561 | |
Greg Daniel | 3912a4b | 2020-01-14 09:56:04 -0500 | [diff] [blame] | 562 | // TODO: See if it makes sense for this to return a const& instead and require the callers to |
| 563 | // make a copy (which refs the proxy) if needed. |
Brian Salomon | 8afde5f | 2020-04-01 16:22:00 -0400 | [diff] [blame^] | 564 | GrSurfaceProxyView writeSurfaceView() { return fWriteView; } |
Greg Daniel | a83de58 | 2019-10-22 09:33:25 -0400 | [diff] [blame] | 565 | |
Robert Phillips | be9aff2 | 2019-02-15 11:33:22 -0500 | [diff] [blame] | 566 | // This entry point should only be called if the backing GPU object is known to be |
| 567 | // instantiated. |
Greg Daniel | 3912a4b | 2020-01-14 09:56:04 -0500 | [diff] [blame] | 568 | GrRenderTarget* accessRenderTarget() { return this->asSurfaceProxy()->peekRenderTarget(); } |
Robert Phillips | eaa8625 | 2016-11-08 13:49:39 +0000 | [diff] [blame] | 569 | |
Robert Phillips | d46697a | 2017-01-25 12:10:37 -0500 | [diff] [blame] | 570 | GrRenderTargetContext* asRenderTargetContext() override { return this; } |
| 571 | |
robertphillips | 391395d | 2016-03-02 09:26:36 -0800 | [diff] [blame] | 572 | // Provides access to functions that aren't part of the public API. |
Brian Osman | 693a540 | 2016-10-27 15:13:22 -0400 | [diff] [blame] | 573 | GrRenderTargetContextPriv priv(); |
| 574 | const GrRenderTargetContextPriv priv() const; |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 575 | |
Herb Derby | c1b482c | 2018-08-09 15:02:27 -0400 | [diff] [blame] | 576 | GrTextTarget* textTarget() { return fTextTarget.get(); } |
Brian Salomon | f18b1d8 | 2017-10-27 11:30:49 -0400 | [diff] [blame] | 577 | |
Robert Phillips | b520476 | 2019-06-19 14:12:13 -0400 | [diff] [blame] | 578 | #if GR_TEST_UTILS |
Greg Daniel | 3912a4b | 2020-01-14 09:56:04 -0500 | [diff] [blame] | 579 | bool testingOnly_IsInstantiated() const { return this->asSurfaceProxy()->isInstantiated(); } |
Chris Dalton | 6b98280 | 2019-06-27 13:53:46 -0600 | [diff] [blame] | 580 | void testingOnly_SetPreserveOpsOnFullClear() { fPreserveOpsOnFullClear_TestingOnly = true; } |
Greg Daniel | f41b2bd | 2019-08-22 16:19:24 -0400 | [diff] [blame] | 581 | GrOpsTask* testingOnly_PeekLastOpsTask() { return fOpsTask.get(); } |
Robert Phillips | b520476 | 2019-06-19 14:12:13 -0400 | [diff] [blame] | 582 | #endif |
Robert Phillips | eaa8625 | 2016-11-08 13:49:39 +0000 | [diff] [blame] | 583 | |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 584 | private: |
Brian Salomon | f18b1d8 | 2017-10-27 11:30:49 -0400 | [diff] [blame] | 585 | class TextTarget; |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 586 | enum class QuadOptimization; |
Brian Salomon | f18b1d8 | 2017-10-27 11:30:49 -0400 | [diff] [blame] | 587 | |
Chris Dalton | 7d6748e | 2019-03-13 00:34:52 -0600 | [diff] [blame] | 588 | GrAAType chooseAAType(GrAA); |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 589 | |
Brian Salomon | 649a341 | 2017-03-09 13:50:43 -0500 | [diff] [blame] | 590 | friend class GrAtlasTextBlob; // for access to add[Mesh]DrawOp |
Greg Daniel | f41b2bd | 2019-08-22 16:19:24 -0400 | [diff] [blame] | 591 | friend class GrClipStackClip; // for access to getOpsTask |
Chris Dalton | c4b4735 | 2019-08-23 10:10:36 -0600 | [diff] [blame] | 592 | friend class GrOnFlushResourceProvider; // for access to getOpsTask (http://skbug.com/9357) |
robertphillips | 55fdccc | 2016-06-06 06:16:20 -0700 | [diff] [blame] | 593 | |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 594 | friend class GrRenderTargetContextPriv; |
robertphillips | 976f5f0 | 2016-06-03 10:59:20 -0700 | [diff] [blame] | 595 | |
Brian Salomon | 42521e8 | 2016-12-07 16:44:58 -0500 | [diff] [blame] | 596 | // All the path renderers currently make their own ops |
Brian Salomon | 649a341 | 2017-03-09 13:50:43 -0500 | [diff] [blame] | 597 | friend class GrSoftwarePathRenderer; // for access to add[Mesh]DrawOp |
| 598 | friend class GrAAConvexPathRenderer; // for access to add[Mesh]DrawOp |
| 599 | friend class GrDashLinePathRenderer; // for access to add[Mesh]DrawOp |
| 600 | friend class GrAAHairLinePathRenderer; // for access to add[Mesh]DrawOp |
| 601 | friend class GrAALinearizingConvexPathRenderer; // for access to add[Mesh]DrawOp |
Jim Van Verth | 8301046 | 2017-03-16 08:45:39 -0400 | [diff] [blame] | 602 | friend class GrSmallPathRenderer; // for access to add[Mesh]DrawOp |
Brian Salomon | 649a341 | 2017-03-09 13:50:43 -0500 | [diff] [blame] | 603 | friend class GrDefaultPathRenderer; // for access to add[Mesh]DrawOp |
Brian Salomon | 649a341 | 2017-03-09 13:50:43 -0500 | [diff] [blame] | 604 | friend class GrStencilAndCoverPathRenderer; // for access to add[Mesh]DrawOp |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 605 | friend class GrTriangulatingPathRenderer; // for access to add[Mesh]DrawOp |
Chris Dalton | 9414c96 | 2018-06-14 10:14:50 -0600 | [diff] [blame] | 606 | friend class GrCCPerFlushResources; // for access to addDrawOp |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 607 | friend class GrCoverageCountingPathRenderer; // for access to addDrawOp |
Robert Phillips | 438d986 | 2019-11-14 12:46:05 -0500 | [diff] [blame] | 608 | friend class GrFillRectOp; // for access to addDrawOp |
Chris Dalton | 0a22b1e | 2020-03-26 11:52:15 -0600 | [diff] [blame] | 609 | friend class GrTessellationPathRenderer; // for access to addDrawOp |
Robert Phillips | e837e61 | 2019-11-15 11:02:50 -0500 | [diff] [blame] | 610 | friend class GrTextureOp; // for access to addDrawOp |
Robert Phillips | 438d986 | 2019-11-14 12:46:05 -0500 | [diff] [blame] | 611 | |
Greg Daniel | 46e366a | 2019-12-16 14:38:36 -0500 | [diff] [blame] | 612 | SkDEBUGCODE(void onValidate() const override;) |
Greg Daniel | a83de58 | 2019-10-22 09:33:25 -0400 | [diff] [blame] | 613 | |
| 614 | |
Greg Daniel | f41b2bd | 2019-08-22 16:19:24 -0400 | [diff] [blame] | 615 | GrOpsTask::CanDiscardPreviousOps canDiscardPreviousOpsOnFullClear() const; |
Chris Dalton | 858cf23 | 2019-10-14 16:20:00 -0600 | [diff] [blame] | 616 | void setNeedsStencil(bool useMixedSamplesIfNotMSAA); |
Chris Dalton | 6b98280 | 2019-06-27 13:53:46 -0600 | [diff] [blame] | 617 | |
Brian Osman | 9a9baae | 2018-11-05 15:06:26 -0500 | [diff] [blame] | 618 | void internalClear(const GrFixedClip&, const SkPMColor4f&, CanClearFullscreen); |
Michael Ludwig | c39d0c8 | 2019-01-15 10:03:43 -0500 | [diff] [blame] | 619 | void internalStencilClear(const GrFixedClip&, bool insideStencilMask); |
csmartdalton | 29df760 | 2016-08-31 11:55:52 -0700 | [diff] [blame] | 620 | |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 621 | // Only consumes the GrPaint if successful. |
robertphillips | 0009589 | 2016-02-29 13:50:40 -0800 | [diff] [blame] | 622 | bool drawFilledDRRect(const GrClip& clip, |
Brian Salomon | 82f4431 | 2017-01-11 13:42:54 -0500 | [diff] [blame] | 623 | GrPaint&& paint, |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 624 | GrAA, |
robertphillips | 0009589 | 2016-02-29 13:50:40 -0800 | [diff] [blame] | 625 | const SkMatrix& viewMatrix, |
| 626 | const SkRRect& origOuter, |
| 627 | const SkRRect& origInner); |
| 628 | |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 629 | // If the drawn quad's paint is a const blended color, provide it as a non-null pointer to |
| 630 | // 'constColor', which enables the draw-as-clear optimization. Otherwise it is assumed the paint |
| 631 | // requires some form of shading that invalidates using a clear op. |
| 632 | // |
| 633 | // The non-const pointers should be the original draw request on input, and will be updated as |
| 634 | // appropriate depending on the returned optimization level. |
| 635 | // |
Michael Ludwig | e08b443 | 2019-06-19 18:00:48 -0400 | [diff] [blame] | 636 | // 'stencilSettings' are provided merely for decision making purposes; When non-null, |
| 637 | // optimization strategies that submit special ops are avoided. |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 638 | QuadOptimization attemptQuadOptimization(const GrClip& clip, |
| 639 | const SkPMColor4f* constColor, |
Michael Ludwig | e08b443 | 2019-06-19 18:00:48 -0400 | [diff] [blame] | 640 | const GrUserStencilSettings* stencilSettings, |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 641 | GrAA* aa, |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 642 | DrawQuad* quad); |
robertphillips | 4430239 | 2016-07-08 14:43:03 -0700 | [diff] [blame] | 643 | |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 644 | // If stencil settings, 'ss', are non-null, AA controls MSAA or no AA. If they are null, then AA |
| 645 | // can choose between coverage, MSAA as per chooseAAType(). This will always attempt to apply |
| 646 | // quad optimizations, so all quad/rect public APIs should rely on this function for consistent |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 647 | // clipping behavior. 'quad' will be modified in place to reflect final rendered geometry. |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 648 | void drawFilledQuad(const GrClip& clip, |
| 649 | GrPaint&& paint, |
| 650 | GrAA aa, |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 651 | DrawQuad* quad, |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 652 | const GrUserStencilSettings* ss = nullptr); |
Brian Salomon | 7694b90 | 2019-06-18 21:00:21 +0000 | [diff] [blame] | 653 | |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 654 | // Like drawFilledQuad but does not require using a GrPaint or FP for texturing. |
| 655 | // 'quad' may be modified in place to reflect final geometry. |
Michael Ludwig | aee26ea | 2019-07-08 16:22:48 +0000 | [diff] [blame] | 656 | void drawTexturedQuad(const GrClip& clip, |
Greg Daniel | 549325c | 2019-10-30 16:19:20 -0400 | [diff] [blame] | 657 | GrSurfaceProxyView proxyView, |
Brian Salomon | fc11844 | 2019-11-22 19:09:27 -0500 | [diff] [blame] | 658 | SkAlphaType alphaType, |
Michael Ludwig | aee26ea | 2019-07-08 16:22:48 +0000 | [diff] [blame] | 659 | sk_sp<GrColorSpaceXform> textureXform, |
| 660 | GrSamplerState::Filter filter, |
| 661 | const SkPMColor4f& color, |
| 662 | SkBlendMode blendMode, |
| 663 | GrAA aa, |
Michael Ludwig | 6b45c5d | 2020-02-07 09:56:38 -0500 | [diff] [blame] | 664 | DrawQuad* quad, |
Michael Ludwig | aee26ea | 2019-07-08 16:22:48 +0000 | [diff] [blame] | 665 | const SkRect* domain = nullptr); |
| 666 | |
Brian Salomon | 2fad74a | 2017-12-20 13:28:55 -0500 | [diff] [blame] | 667 | void drawShapeUsingPathRenderer(const GrClip&, GrPaint&&, GrAA, const SkMatrix&, |
| 668 | const GrShape&); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 669 | |
Chris Dalton | 0875512 | 2019-08-05 16:13:47 -0600 | [diff] [blame] | 670 | void addOp(std::unique_ptr<GrOp>); |
| 671 | |
Brian Salomon | 348a037 | 2018-10-31 10:42:18 -0400 | [diff] [blame] | 672 | // Allows caller of addDrawOp to know which op list an op will be added to. |
Greg Daniel | f41b2bd | 2019-08-22 16:19:24 -0400 | [diff] [blame] | 673 | using WillAddOpFn = void(GrOp*, uint32_t opsTaskID); |
Brian Salomon | 348a037 | 2018-10-31 10:42:18 -0400 | [diff] [blame] | 674 | // These perform processing specific to GrDrawOp-derived ops before recording them into an |
| 675 | // op list. Before adding the op to an op list the WillAddOpFn is called. Note that it |
| 676 | // will not be called in the event that the op is discarded. Moreover, the op may merge into |
| 677 | // another op after the function is called (either before addDrawOp returns or some time later). |
| 678 | void addDrawOp(const GrClip&, std::unique_ptr<GrDrawOp>, |
| 679 | const std::function<WillAddOpFn>& = std::function<WillAddOpFn>()); |
robertphillips | 2334fb6 | 2015-06-17 05:43:33 -0700 | [diff] [blame] | 680 | |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 681 | // Makes a copy of the proxy if it is necessary for the draw and places the texture that should |
| 682 | // be used by GrXferProcessor to access the destination color in 'result'. If the return |
| 683 | // value is false then a texture copy could not be made. |
Greg Daniel | 524e28b | 2019-11-01 11:48:53 -0400 | [diff] [blame] | 684 | bool SK_WARN_UNUSED_RESULT setupDstProxyView(const GrClip&, const GrOp& op, |
| 685 | GrXferProcessor::DstProxyView* result); |
Brian Salomon | 467921e | 2017-03-06 16:17:12 -0500 | [diff] [blame] | 686 | |
Brian Salomon | 9241a6d | 2019-10-03 13:26:54 -0400 | [diff] [blame] | 687 | class AsyncReadResult; |
| 688 | |
Brian Salomon | 024bd00 | 2019-06-11 11:38:16 -0400 | [diff] [blame] | 689 | // The async read step of asyncRescaleAndReadPixels() |
| 690 | void asyncReadPixels(const SkIRect& rect, SkColorType colorType, ReadPixelsCallback callback, |
| 691 | ReadPixelsContext context); |
| 692 | |
Greg Daniel | f41b2bd | 2019-08-22 16:19:24 -0400 | [diff] [blame] | 693 | GrOpsTask* getOpsTask(); |
robertphillips | a106c62 | 2015-10-16 09:07:06 -0700 | [diff] [blame] | 694 | |
Herb Derby | c1b482c | 2018-08-09 15:02:27 -0400 | [diff] [blame] | 695 | std::unique_ptr<GrTextTarget> fTextTarget; |
Greg Daniel | a83de58 | 2019-10-22 09:33:25 -0400 | [diff] [blame] | 696 | |
Brian Salomon | 8afde5f | 2020-04-01 16:22:00 -0400 | [diff] [blame^] | 697 | GrSurfaceProxyView fWriteView; |
robertphillips | a106c62 | 2015-10-16 09:07:06 -0700 | [diff] [blame] | 698 | |
Greg Daniel | f41b2bd | 2019-08-22 16:19:24 -0400 | [diff] [blame] | 699 | // In MDB-mode the GrOpsTask can be closed by some other renderTargetContext that has picked |
| 700 | // it up. For this reason, the GrOpsTask should only ever be accessed via 'getOpsTask'. |
| 701 | sk_sp<GrOpsTask> fOpsTask; |
robertphillips | 2334fb6 | 2015-06-17 05:43:33 -0700 | [diff] [blame] | 702 | |
Brian Salomon | f18b1d8 | 2017-10-27 11:30:49 -0400 | [diff] [blame] | 703 | SkSurfaceProps fSurfaceProps; |
Greg Daniel | f41b2bd | 2019-08-22 16:19:24 -0400 | [diff] [blame] | 704 | bool fManagedOpsTask; |
Robert Phillips | e305cc1f | 2016-12-14 12:19:05 -0500 | [diff] [blame] | 705 | |
Chris Dalton | effee20 | 2019-07-01 22:28:03 -0600 | [diff] [blame] | 706 | int fNumStencilSamples = 0; |
Chris Dalton | 6b98280 | 2019-06-27 13:53:46 -0600 | [diff] [blame] | 707 | #if GR_TEST_UTILS |
| 708 | bool fPreserveOpsOnFullClear_TestingOnly = false; |
| 709 | #endif |
| 710 | |
Robert Phillips | e305cc1f | 2016-12-14 12:19:05 -0500 | [diff] [blame] | 711 | typedef GrSurfaceContext INHERITED; |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 712 | }; |
| 713 | |
| 714 | #endif |