epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2006 The Android Open Source Project |
| 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 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "include/core/SkMallocPixelRef.h" |
| 9 | #include "include/core/SkPaint.h" |
| 10 | #include "include/core/SkPicture.h" |
| 11 | #include "include/core/SkScalar.h" |
Ben Wagner | 729a23f | 2019-05-17 16:29:34 -0400 | [diff] [blame] | 12 | #include "src/core/SkArenaAlloc.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 13 | #include "src/core/SkColorSpacePriv.h" |
| 14 | #include "src/core/SkColorSpaceXformSteps.h" |
| 15 | #include "src/core/SkRasterPipeline.h" |
| 16 | #include "src/core/SkReadBuffer.h" |
| 17 | #include "src/core/SkTLazy.h" |
| 18 | #include "src/core/SkWriteBuffer.h" |
| 19 | #include "src/shaders/SkBitmapProcShader.h" |
| 20 | #include "src/shaders/SkColorShader.h" |
| 21 | #include "src/shaders/SkEmptyShader.h" |
| 22 | #include "src/shaders/SkPictureShader.h" |
| 23 | #include "src/shaders/SkShaderBase.h" |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 24 | |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 25 | #if SK_SUPPORT_GPU |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 26 | #include "src/gpu/GrFragmentProcessor.h" |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 27 | #endif |
| 28 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 29 | SkShaderBase::SkShaderBase(const SkMatrix* localMatrix) |
| 30 | : fLocalMatrix(localMatrix ? *localMatrix : SkMatrix::I()) { |
mtklein | 435eba7 | 2014-12-01 12:06:24 -0800 | [diff] [blame] | 31 | // Pre-cache so future calls to fLocalMatrix.getType() are threadsafe. |
| 32 | (void)fLocalMatrix.getType(); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 33 | } |
| 34 | |
Mike Klein | de2244c | 2018-12-04 11:16:08 -0500 | [diff] [blame] | 35 | SkShaderBase::~SkShaderBase() {} |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 36 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 37 | void SkShaderBase::flatten(SkWriteBuffer& buffer) const { |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 38 | this->INHERITED::flatten(buffer); |
commit-bot@chromium.org | 5970f62 | 2014-05-12 20:42:21 +0000 | [diff] [blame] | 39 | bool hasLocalM = !fLocalMatrix.isIdentity(); |
bsalomon@google.com | f94b3a4 | 2012-10-31 18:09:01 +0000 | [diff] [blame] | 40 | buffer.writeBool(hasLocalM); |
| 41 | if (hasLocalM) { |
| 42 | buffer.writeMatrix(fLocalMatrix); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 43 | } |
| 44 | } |
| 45 | |
Florin Malita | c6c5ead | 2018-04-11 15:33:40 -0400 | [diff] [blame] | 46 | SkTCopyOnFirstWrite<SkMatrix> |
| 47 | SkShaderBase::totalLocalMatrix(const SkMatrix* preLocalMatrix, |
| 48 | const SkMatrix* postLocalMatrix) const { |
| 49 | SkTCopyOnFirstWrite<SkMatrix> m(fLocalMatrix); |
| 50 | |
| 51 | if (preLocalMatrix) { |
| 52 | m.writable()->preConcat(*preLocalMatrix); |
| 53 | } |
| 54 | |
| 55 | if (postLocalMatrix) { |
| 56 | m.writable()->postConcat(*postLocalMatrix); |
| 57 | } |
| 58 | |
| 59 | return m; |
| 60 | } |
| 61 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 62 | bool SkShaderBase::computeTotalInverse(const SkMatrix& ctm, |
| 63 | const SkMatrix* outerLocalMatrix, |
| 64 | SkMatrix* totalInverse) const { |
Florin Malita | c6c5ead | 2018-04-11 15:33:40 -0400 | [diff] [blame] | 65 | return SkMatrix::Concat(ctm, *this->totalLocalMatrix(outerLocalMatrix)).invert(totalInverse); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 66 | } |
| 67 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 68 | bool SkShaderBase::asLuminanceColor(SkColor* colorPtr) const { |
reed | 8367b8c | 2014-08-22 08:30:20 -0700 | [diff] [blame] | 69 | SkColor storage; |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 70 | if (nullptr == colorPtr) { |
reed | 8367b8c | 2014-08-22 08:30:20 -0700 | [diff] [blame] | 71 | colorPtr = &storage; |
| 72 | } |
| 73 | if (this->onAsLuminanceColor(colorPtr)) { |
| 74 | *colorPtr = SkColorSetA(*colorPtr, 0xFF); // we only return opaque |
| 75 | return true; |
| 76 | } |
| 77 | return false; |
| 78 | } |
| 79 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 80 | SkShaderBase::Context* SkShaderBase::makeContext(const ContextRec& rec, SkArenaAlloc* alloc) const { |
Mike Reed | e92aae6 | 2018-10-17 10:21:51 -0400 | [diff] [blame] | 81 | #ifdef SK_ENABLE_LEGACY_SHADERCONTEXT |
Florin Malita | af2769d | 2018-04-04 13:46:35 -0400 | [diff] [blame] | 82 | // We always fall back to raster pipeline when perspective is present. |
| 83 | if (rec.fMatrix->hasPerspective() || |
| 84 | fLocalMatrix.hasPerspective() || |
| 85 | (rec.fLocalMatrix && rec.fLocalMatrix->hasPerspective()) || |
| 86 | !this->computeTotalInverse(*rec.fMatrix, rec.fLocalMatrix, nullptr)) { |
| 87 | return nullptr; |
| 88 | } |
| 89 | |
| 90 | return this->onMakeContext(rec, alloc); |
Mike Reed | e92aae6 | 2018-10-17 10:21:51 -0400 | [diff] [blame] | 91 | #else |
| 92 | return nullptr; |
| 93 | #endif |
commit-bot@chromium.org | f3e5059 | 2014-04-30 23:29:02 +0000 | [diff] [blame] | 94 | } |
| 95 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 96 | SkShaderBase::Context::Context(const SkShaderBase& shader, const ContextRec& rec) |
commit-bot@chromium.org | 80116dc | 2014-05-06 17:16:03 +0000 | [diff] [blame] | 97 | : fShader(shader), fCTM(*rec.fMatrix) |
commit-bot@chromium.org | 87fcd95 | 2014-04-23 19:10:51 +0000 | [diff] [blame] | 98 | { |
Florin Malita | af2769d | 2018-04-04 13:46:35 -0400 | [diff] [blame] | 99 | // We should never use a context with perspective. |
Florin Malita | 5769dd2 | 2017-07-12 13:31:25 -0400 | [diff] [blame] | 100 | SkASSERT(!rec.fMatrix->hasPerspective()); |
| 101 | SkASSERT(!rec.fLocalMatrix || !rec.fLocalMatrix->hasPerspective()); |
Florin Malita | af2769d | 2018-04-04 13:46:35 -0400 | [diff] [blame] | 102 | SkASSERT(!shader.getLocalMatrix().hasPerspective()); |
Florin Malita | 7d022e0 | 2017-05-15 15:06:39 -0400 | [diff] [blame] | 103 | |
commit-bot@chromium.org | 87fcd95 | 2014-04-23 19:10:51 +0000 | [diff] [blame] | 104 | // Because the context parameters must be valid at this point, we know that the matrix is |
| 105 | // invertible. |
Florin Malita | 26368c3 | 2017-05-08 13:03:24 -0400 | [diff] [blame] | 106 | SkAssertResult(fShader.computeTotalInverse(*rec.fMatrix, rec.fLocalMatrix, &fTotalInverse)); |
commit-bot@chromium.org | 87fcd95 | 2014-04-23 19:10:51 +0000 | [diff] [blame] | 107 | |
commit-bot@chromium.org | e901b6d | 2014-05-01 19:31:31 +0000 | [diff] [blame] | 108 | fPaintAlpha = rec.fPaint->getAlpha(); |
commit-bot@chromium.org | 87fcd95 | 2014-04-23 19:10:51 +0000 | [diff] [blame] | 109 | } |
| 110 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 111 | SkShaderBase::Context::~Context() {} |
commit-bot@chromium.org | 87fcd95 | 2014-04-23 19:10:51 +0000 | [diff] [blame] | 112 | |
Mike Reed | 011d166 | 2019-02-28 17:19:25 -0500 | [diff] [blame] | 113 | bool SkShaderBase::ContextRec::isLegacyCompatible(SkColorSpace* shaderColorSpace) const { |
Mike Klein | a7bb87e | 2019-12-03 11:04:54 -0600 | [diff] [blame] | 114 | // In legacy pipelines, shaders always produce premul (or opaque) and the destination is also |
| 115 | // always premul (or opaque). (And those "or opaque" caveats won't make any difference here.) |
| 116 | SkAlphaType shaderAT = kPremul_SkAlphaType, |
| 117 | dstAT = kPremul_SkAlphaType; |
| 118 | return 0 == SkColorSpaceXformSteps{shaderColorSpace, shaderAT, |
| 119 | fDstColorSpace, dstAT}.flags.mask(); |
Mike Reed | 011d166 | 2019-02-28 17:19:25 -0500 | [diff] [blame] | 120 | } |
| 121 | |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 122 | SkImage* SkShader::isAImage(SkMatrix* localMatrix, SkTileMode xy[2]) const { |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 123 | return as_SB(this)->onIsAImage(localMatrix, xy); |
| 124 | } |
| 125 | |
vandebo@chromium.org | d3ae779 | 2011-02-24 00:21:06 +0000 | [diff] [blame] | 126 | SkShader::GradientType SkShader::asAGradient(GradientInfo* info) const { |
| 127 | return kNone_GradientType; |
| 128 | } |
| 129 | |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 130 | #if SK_SUPPORT_GPU |
Mike Reed | e3429e6 | 2018-01-19 11:43:34 -0500 | [diff] [blame] | 131 | std::unique_ptr<GrFragmentProcessor> SkShaderBase::asFragmentProcessor(const GrFPArgs&) const { |
bsalomon | c21b09e | 2015-08-28 18:46:56 -0700 | [diff] [blame] | 132 | return nullptr; |
rileya@google.com | 03c1c35 | 2012-07-20 20:02:43 +0000 | [diff] [blame] | 133 | } |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 134 | #endif |
rileya@google.com | 03c1c35 | 2012-07-20 20:02:43 +0000 | [diff] [blame] | 135 | |
Mike Reed | 7656b2c | 2019-04-08 11:48:20 -0400 | [diff] [blame] | 136 | sk_sp<SkShader> SkShaderBase::makeAsALocalMatrixShader(SkMatrix*) const { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 137 | return nullptr; |
commit-bot@chromium.org | 8fae213 | 2014-05-07 22:26:37 +0000 | [diff] [blame] | 138 | } |
| 139 | |
Mike Reed | c8bea7d | 2019-04-09 13:55:36 -0400 | [diff] [blame] | 140 | sk_sp<SkShader> SkShaders::Empty() { return sk_make_sp<SkEmptyShader>(); } |
| 141 | sk_sp<SkShader> SkShaders::Color(SkColor color) { return sk_make_sp<SkColorShader>(color); } |
reed | 8367b8c | 2014-08-22 08:30:20 -0700 | [diff] [blame] | 142 | |
Mike Reed | 50acf8f | 2019-04-08 13:20:23 -0400 | [diff] [blame] | 143 | sk_sp<SkShader> SkBitmap::makeShader(SkTileMode tmx, SkTileMode tmy, const SkMatrix* lm) const { |
| 144 | if (lm && !lm->invert(nullptr)) { |
| 145 | return nullptr; |
| 146 | } |
| 147 | return SkMakeBitmapShader(*this, tmx, tmy, lm, kIfMutable_SkCopyPixelsMode); |
| 148 | } |
| 149 | |
| 150 | sk_sp<SkShader> SkBitmap::makeShader(const SkMatrix* lm) const { |
| 151 | return this->makeShader(SkTileMode::kClamp, SkTileMode::kClamp, lm); |
| 152 | } |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 153 | |
Mike Reed | 1386b2d | 2019-03-13 21:15:05 -0400 | [diff] [blame] | 154 | bool SkShaderBase::appendStages(const SkStageRec& rec) const { |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 155 | return this->onAppendStages(rec); |
Florin Malita | 9206c76 | 2017-01-30 12:08:05 -0500 | [diff] [blame] | 156 | } |
| 157 | |
Mike Reed | 1386b2d | 2019-03-13 21:15:05 -0400 | [diff] [blame] | 158 | bool SkShaderBase::onAppendStages(const SkStageRec& rec) const { |
Mike Klein | 541cbd4 | 2019-01-30 13:11:33 -0500 | [diff] [blame] | 159 | // SkShader::Context::shadeSpan() handles the paint opacity internally, |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 160 | // but SkRasterPipelineBlitter applies it as a separate stage. |
Mike Klein | 541cbd4 | 2019-01-30 13:11:33 -0500 | [diff] [blame] | 161 | // We skip the internal shadeSpan() step by forcing the paint opaque. |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 162 | SkTCopyOnFirstWrite<SkPaint> opaquePaint(rec.fPaint); |
| 163 | if (rec.fPaint.getAlpha() != SK_AlphaOPAQUE) { |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 164 | opaquePaint.writable()->setAlpha(SK_AlphaOPAQUE); |
| 165 | } |
| 166 | |
Mike Klein | 894328d | 2019-03-21 10:06:38 -0500 | [diff] [blame] | 167 | ContextRec cr(*opaquePaint, rec.fCTM, rec.fLocalM, rec.fDstColorType, sk_srgb_singleton()); |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 168 | |
Mike Klein | b11ab57 | 2018-10-24 06:42:14 -0400 | [diff] [blame] | 169 | struct CallbackCtx : SkRasterPipeline_CallbackCtx { |
Mike Klein | b0b2c96 | 2019-03-21 10:33:51 -0500 | [diff] [blame] | 170 | sk_sp<const SkShader> shader; |
| 171 | Context* ctx; |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 172 | }; |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 173 | auto cb = rec.fAlloc->make<CallbackCtx>(); |
Mike Klein | b0b2c96 | 2019-03-21 10:33:51 -0500 | [diff] [blame] | 174 | cb->shader = sk_ref_sp(this); |
| 175 | cb->ctx = as_SB(this)->makeContext(cr, rec.fAlloc); |
Mike Klein | b11ab57 | 2018-10-24 06:42:14 -0400 | [diff] [blame] | 176 | cb->fn = [](SkRasterPipeline_CallbackCtx* self, int active_pixels) { |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 177 | auto c = (CallbackCtx*)self; |
| 178 | int x = (int)c->rgba[0], |
Mike Klein | 541cbd4 | 2019-01-30 13:11:33 -0500 | [diff] [blame] | 179 | y = (int)c->rgba[1]; |
| 180 | SkPMColor tmp[SkRasterPipeline_kMaxStride]; |
| 181 | c->ctx->shadeSpan(x,y, tmp, active_pixels); |
| 182 | |
| 183 | for (int i = 0; i < active_pixels; i++) { |
| 184 | auto rgba_4f = SkPMColor4f::FromPMColor(tmp[i]); |
| 185 | memcpy(c->rgba + 4*i, rgba_4f.vec(), 4*sizeof(float)); |
| 186 | } |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 187 | }; |
| 188 | |
| 189 | if (cb->ctx) { |
Mike Klein | e8de024 | 2018-03-10 12:37:11 -0500 | [diff] [blame] | 190 | rec.fPipeline->append(SkRasterPipeline::seed_shader); |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 191 | rec.fPipeline->append(SkRasterPipeline::callback, cb); |
Mike Klein | 894328d | 2019-03-21 10:06:38 -0500 | [diff] [blame] | 192 | rec.fAlloc->make<SkColorSpaceXformSteps>(sk_srgb_singleton(), kPremul_SkAlphaType, |
| 193 | rec.fDstCS, kPremul_SkAlphaType) |
| 194 | ->apply(rec.fPipeline, true); |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 195 | return true; |
| 196 | } |
Mike Klein | 44d3279 | 2017-05-10 12:29:38 -0400 | [diff] [blame] | 197 | return false; |
| 198 | } |
| 199 | |
Mike Klein | 0393505 | 2019-11-01 11:36:55 -0500 | [diff] [blame] | 200 | bool SkShaderBase::program(skvm::Builder* p, |
| 201 | SkColorSpace* dstCS, |
Mike Klein | 1cc6067 | 2019-11-05 14:19:58 -0600 | [diff] [blame] | 202 | skvm::Uniforms* uniforms, |
Mike Klein | f3d4109 | 2019-11-04 13:22:02 -0600 | [diff] [blame] | 203 | skvm::F32 x, skvm::F32 y, |
Mike Klein | b9f2088 | 2019-11-08 12:14:15 -0600 | [diff] [blame] | 204 | skvm::F32* r, skvm::F32* g, skvm::F32* b, skvm::F32* a) const { |
Mike Klein | 0393505 | 2019-11-01 11:36:55 -0500 | [diff] [blame] | 205 | // Force opaque alpha for all opaque shaders. |
| 206 | // |
Mike Klein | b9f2088 | 2019-11-08 12:14:15 -0600 | [diff] [blame] | 207 | // This is primarily nice in that we usually have a 1.0f constant splat |
Mike Klein | 0393505 | 2019-11-01 11:36:55 -0500 | [diff] [blame] | 208 | // somewhere in the program anyway, and this will let us drop the work the |
| 209 | // shader notionally does to produce alpha, p->extract(...), etc. in favor |
| 210 | // of that simple hoistable splat. |
| 211 | // |
| 212 | // More subtly, it makes isOpaque() a parameter to all shader program |
| 213 | // generation, guaranteeing that is-opaque bit is mixed into the overall |
| 214 | // shader program hash and blitter Key. This makes it safe for us to use |
| 215 | // that bit to make decisions when constructing an SkVMBlitter, like doing |
| 216 | // SrcOver -> Src strength reduction. |
Mike Klein | 1cc6067 | 2019-11-05 14:19:58 -0600 | [diff] [blame] | 217 | if (this->onProgram(p, dstCS, uniforms, x,y, r,g,b,a)) { |
Mike Klein | fb9146f | 2019-11-05 05:49:34 -0600 | [diff] [blame] | 218 | if (this->isOpaque()) { |
Mike Klein | b9f2088 | 2019-11-08 12:14:15 -0600 | [diff] [blame] | 219 | *a = p->splat(1.0f); |
Mike Klein | 0393505 | 2019-11-01 11:36:55 -0500 | [diff] [blame] | 220 | } |
| 221 | return true; |
| 222 | } |
| 223 | return false; |
| 224 | } |
| 225 | |
reed | 0ccc62d | 2016-05-04 13:09:39 -0700 | [diff] [blame] | 226 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
reed | 830dfd8 | 2016-03-16 12:29:01 -0700 | [diff] [blame] | 227 | |
reed | 60c9b58 | 2016-04-03 09:11:13 -0700 | [diff] [blame] | 228 | sk_sp<SkFlattenable> SkEmptyShader::CreateProc(SkReadBuffer&) { |
Mike Reed | c8bea7d | 2019-04-09 13:55:36 -0400 | [diff] [blame] | 229 | return SkShaders::Empty(); |
reed | 9fa60da | 2014-08-21 07:59:51 -0700 | [diff] [blame] | 230 | } |