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 | |
Florin Malita | 9206c76 | 2017-01-30 12:08:05 -0500 | [diff] [blame] | 8 | #include "SkArenaAlloc.h" |
commit-bot@chromium.org | a5572e5 | 2014-03-07 03:24:41 +0000 | [diff] [blame] | 9 | #include "SkBitmapProcShader.h" |
reed | 8367b8c | 2014-08-22 08:30:20 -0700 | [diff] [blame] | 10 | #include "SkColorShader.h" |
Mike Reed | 5800f2e | 2019-03-03 22:12:51 +0000 | [diff] [blame] | 11 | #include "SkColorSpacePriv.h" |
Florin Malita | 47e55a5 | 2017-06-06 12:26:54 -0400 | [diff] [blame] | 12 | #include "SkColorSpaceXformer.h" |
commit-bot@chromium.org | ce56d96 | 2014-05-05 18:39:18 +0000 | [diff] [blame] | 13 | #include "SkEmptyShader.h" |
commit-bot@chromium.org | a5572e5 | 2014-03-07 03:24:41 +0000 | [diff] [blame] | 14 | #include "SkMallocPixelRef.h" |
| 15 | #include "SkPaint.h" |
commit-bot@chromium.org | c5d9bb0 | 2014-04-08 15:19:34 +0000 | [diff] [blame] | 16 | #include "SkPicture.h" |
| 17 | #include "SkPictureShader.h" |
Florin Malita | 9206c76 | 2017-01-30 12:08:05 -0500 | [diff] [blame] | 18 | #include "SkRasterPipeline.h" |
mtklein | 1b24933 | 2015-07-07 12:21:21 -0700 | [diff] [blame] | 19 | #include "SkReadBuffer.h" |
vandebo@chromium.org | d3ae779 | 2011-02-24 00:21:06 +0000 | [diff] [blame] | 20 | #include "SkScalar.h" |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 21 | #include "SkShaderBase.h" |
Florin Malita | 9206c76 | 2017-01-30 12:08:05 -0500 | [diff] [blame] | 22 | #include "SkTLazy.h" |
commit-bot@chromium.org | 8b0e8ac | 2014-01-30 18:58:24 +0000 | [diff] [blame] | 23 | #include "SkWriteBuffer.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 |
| 26 | #include "GrFragmentProcessor.h" |
| 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 Reed | 5800f2e | 2019-03-03 22:12:51 +0000 | [diff] [blame] | 114 | return sk_can_use_legacy_blits(shaderColorSpace, fDstColorSpace); |
Mike Reed | 011d166 | 2019-02-28 17:19:25 -0500 | [diff] [blame] | 115 | } |
| 116 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 117 | const SkMatrix& SkShader::getLocalMatrix() const { |
| 118 | return as_SB(this)->getLocalMatrix(); |
| 119 | } |
| 120 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 121 | SkImage* SkShader::isAImage(SkMatrix* localMatrix, TileMode xy[2]) const { |
| 122 | return as_SB(this)->onIsAImage(localMatrix, xy); |
| 123 | } |
| 124 | |
vandebo@chromium.org | d3ae779 | 2011-02-24 00:21:06 +0000 | [diff] [blame] | 125 | SkShader::GradientType SkShader::asAGradient(GradientInfo* info) const { |
| 126 | return kNone_GradientType; |
| 127 | } |
| 128 | |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 129 | #if SK_SUPPORT_GPU |
Mike Reed | e3429e6 | 2018-01-19 11:43:34 -0500 | [diff] [blame] | 130 | std::unique_ptr<GrFragmentProcessor> SkShaderBase::asFragmentProcessor(const GrFPArgs&) const { |
bsalomon | c21b09e | 2015-08-28 18:46:56 -0700 | [diff] [blame] | 131 | return nullptr; |
rileya@google.com | 03c1c35 | 2012-07-20 20:02:43 +0000 | [diff] [blame] | 132 | } |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 133 | #endif |
rileya@google.com | 03c1c35 | 2012-07-20 20:02:43 +0000 | [diff] [blame] | 134 | |
Florin Malita | d93e11c | 2017-05-24 21:15:46 +0000 | [diff] [blame] | 135 | sk_sp<SkShader> SkShader::makeAsALocalMatrixShader(SkMatrix*) const { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 136 | return nullptr; |
commit-bot@chromium.org | 8fae213 | 2014-05-07 22:26:37 +0000 | [diff] [blame] | 137 | } |
| 138 | |
reed | 8a21c9f | 2016-03-08 18:50:00 -0800 | [diff] [blame] | 139 | sk_sp<SkShader> SkShader::MakeEmptyShader() { return sk_make_sp<SkEmptyShader>(); } |
commit-bot@chromium.org | ce56d96 | 2014-05-05 18:39:18 +0000 | [diff] [blame] | 140 | |
reed | 8a21c9f | 2016-03-08 18:50:00 -0800 | [diff] [blame] | 141 | sk_sp<SkShader> SkShader::MakeColorShader(SkColor color) { return sk_make_sp<SkColorShader>(color); } |
reed | 8367b8c | 2014-08-22 08:30:20 -0700 | [diff] [blame] | 142 | |
reed | 8a21c9f | 2016-03-08 18:50:00 -0800 | [diff] [blame] | 143 | sk_sp<SkShader> SkShader::MakeBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy, |
| 144 | const SkMatrix* localMatrix) { |
Florin Malita | 8d3ffad | 2017-02-03 18:21:17 +0000 | [diff] [blame] | 145 | if (localMatrix && !localMatrix->invert(nullptr)) { |
| 146 | return nullptr; |
| 147 | } |
Herb Derby | bfdc87a | 2017-02-14 15:06:23 +0000 | [diff] [blame] | 148 | return SkMakeBitmapShader(src, tmx, tmy, localMatrix, kIfMutable_SkCopyPixelsMode); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 149 | } |
| 150 | |
reed | 7fb4f8b | 2016-03-11 04:33:52 -0800 | [diff] [blame] | 151 | sk_sp<SkShader> SkShader::MakePictureShader(sk_sp<SkPicture> src, TileMode tmx, TileMode tmy, |
reed | 8a21c9f | 2016-03-08 18:50:00 -0800 | [diff] [blame] | 152 | const SkMatrix* localMatrix, const SkRect* tile) { |
Florin Malita | 8d3ffad | 2017-02-03 18:21:17 +0000 | [diff] [blame] | 153 | if (localMatrix && !localMatrix->invert(nullptr)) { |
| 154 | return nullptr; |
| 155 | } |
reed | 8a21c9f | 2016-03-08 18:50:00 -0800 | [diff] [blame] | 156 | return SkPictureShader::Make(std::move(src), tmx, tmy, localMatrix, tile); |
commit-bot@chromium.org | c5d9bb0 | 2014-04-08 15:19:34 +0000 | [diff] [blame] | 157 | } |
| 158 | |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 159 | bool SkShaderBase::appendStages(const StageRec& rec) const { |
| 160 | return this->onAppendStages(rec); |
Florin Malita | 9206c76 | 2017-01-30 12:08:05 -0500 | [diff] [blame] | 161 | } |
| 162 | |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 163 | bool SkShaderBase::onAppendStages(const StageRec& rec) const { |
Mike Klein | 541cbd4 | 2019-01-30 13:11:33 -0500 | [diff] [blame] | 164 | // SkShader::Context::shadeSpan() handles the paint opacity internally, |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 165 | // but SkRasterPipelineBlitter applies it as a separate stage. |
Mike Klein | 541cbd4 | 2019-01-30 13:11:33 -0500 | [diff] [blame] | 166 | // We skip the internal shadeSpan() step by forcing the paint opaque. |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 167 | SkTCopyOnFirstWrite<SkPaint> opaquePaint(rec.fPaint); |
| 168 | if (rec.fPaint.getAlpha() != SK_AlphaOPAQUE) { |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 169 | opaquePaint.writable()->setAlpha(SK_AlphaOPAQUE); |
| 170 | } |
| 171 | |
Brian Osman | 2e8f48e | 2018-10-19 13:50:48 -0400 | [diff] [blame] | 172 | ContextRec cr(*opaquePaint, rec.fCTM, rec.fLocalM, rec.fDstColorType, rec.fDstCS); |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 173 | |
Mike Klein | b11ab57 | 2018-10-24 06:42:14 -0400 | [diff] [blame] | 174 | struct CallbackCtx : SkRasterPipeline_CallbackCtx { |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 175 | sk_sp<SkShader> shader; |
| 176 | Context* ctx; |
| 177 | }; |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 178 | auto cb = rec.fAlloc->make<CallbackCtx>(); |
| 179 | cb->shader = rec.fDstCS ? SkColorSpaceXformer::Make(sk_ref_sp(rec.fDstCS))->apply(this) |
| 180 | : sk_ref_sp((SkShader*)this); |
| 181 | cb->ctx = as_SB(cb->shader)->makeContext(cr, rec.fAlloc); |
Mike Klein | b11ab57 | 2018-10-24 06:42:14 -0400 | [diff] [blame] | 182 | cb->fn = [](SkRasterPipeline_CallbackCtx* self, int active_pixels) { |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 183 | auto c = (CallbackCtx*)self; |
| 184 | int x = (int)c->rgba[0], |
Mike Klein | 541cbd4 | 2019-01-30 13:11:33 -0500 | [diff] [blame] | 185 | y = (int)c->rgba[1]; |
| 186 | SkPMColor tmp[SkRasterPipeline_kMaxStride]; |
| 187 | c->ctx->shadeSpan(x,y, tmp, active_pixels); |
| 188 | |
| 189 | for (int i = 0; i < active_pixels; i++) { |
| 190 | auto rgba_4f = SkPMColor4f::FromPMColor(tmp[i]); |
| 191 | memcpy(c->rgba + 4*i, rgba_4f.vec(), 4*sizeof(float)); |
| 192 | } |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 193 | }; |
| 194 | |
| 195 | if (cb->ctx) { |
Mike Klein | e8de024 | 2018-03-10 12:37:11 -0500 | [diff] [blame] | 196 | rec.fPipeline->append(SkRasterPipeline::seed_shader); |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 197 | rec.fPipeline->append(SkRasterPipeline::callback, cb); |
Mike Reed | 6867eee | 2017-06-02 13:25:15 -0400 | [diff] [blame] | 198 | return true; |
| 199 | } |
Mike Klein | 44d3279 | 2017-05-10 12:29:38 -0400 | [diff] [blame] | 200 | return false; |
| 201 | } |
| 202 | |
reed | 0ccc62d | 2016-05-04 13:09:39 -0700 | [diff] [blame] | 203 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
reed | 830dfd8 | 2016-03-16 12:29:01 -0700 | [diff] [blame] | 204 | |
reed | 60c9b58 | 2016-04-03 09:11:13 -0700 | [diff] [blame] | 205 | sk_sp<SkFlattenable> SkEmptyShader::CreateProc(SkReadBuffer&) { |
| 206 | return SkShader::MakeEmptyShader(); |
reed | 9fa60da | 2014-08-21 07:59:51 -0700 | [diff] [blame] | 207 | } |