| /* |
| * Copyright 2014 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "src/core/SkMatrixProvider.h" |
| #include "src/core/SkTLazy.h" |
| #include "src/core/SkVM.h" |
| #include "src/shaders/SkLocalMatrixShader.h" |
| |
| #if SK_SUPPORT_GPU |
| #include "src/gpu/ganesh/GrFPArgs.h" |
| #include "src/gpu/ganesh/GrFragmentProcessor.h" |
| #include "src/gpu/ganesh/effects/GrMatrixEffect.h" |
| #endif |
| |
| #ifdef SK_ENABLE_SKSL |
| #include "src/core/SkKeyHelpers.h" |
| #include "src/core/SkPaintParamsKey.h" |
| #endif |
| |
| #if SK_SUPPORT_GPU |
| std::unique_ptr<GrFragmentProcessor> SkLocalMatrixShader::asFragmentProcessor( |
| const GrFPArgs& args) const { |
| return as_SB(fProxyShader)->asFragmentProcessor( |
| GrFPArgs::ConcatLocalMatrix(args, this->getLocalMatrix())); |
| } |
| #endif |
| |
| #ifdef SK_ENABLE_SKSL |
| void SkLocalMatrixShader::addToKey(const SkKeyContext& keyContext, |
| SkPaintParamsKeyBuilder* builder, |
| SkPipelineDataGatherer* gatherer) const { |
| LocalMatrixShaderBlock::LMShaderData lmShaderData(this->getLocalMatrix()); |
| |
| LocalMatrixShaderBlock::BeginBlock(keyContext, builder, gatherer, lmShaderData); |
| |
| as_SB(fProxyShader)->addToKey(keyContext, builder, gatherer); |
| |
| builder->endBlock(); |
| } |
| #endif |
| |
| sk_sp<SkFlattenable> SkLocalMatrixShader::CreateProc(SkReadBuffer& buffer) { |
| SkMatrix lm; |
| buffer.readMatrix(&lm); |
| auto baseShader(buffer.readShader()); |
| if (!baseShader) { |
| return nullptr; |
| } |
| return baseShader->makeWithLocalMatrix(lm); |
| } |
| |
| void SkLocalMatrixShader::flatten(SkWriteBuffer& buffer) const { |
| buffer.writeMatrix(this->getLocalMatrix()); |
| buffer.writeFlattenable(fProxyShader.get()); |
| } |
| |
| #ifdef SK_ENABLE_LEGACY_SHADERCONTEXT |
| SkShaderBase::Context* SkLocalMatrixShader::onMakeContext( |
| const ContextRec& rec, SkArenaAlloc* alloc) const |
| { |
| SkTCopyOnFirstWrite<SkMatrix> lm(this->getLocalMatrix()); |
| if (rec.fLocalMatrix) { |
| *lm.writable() = ConcatLocalMatrices(*rec.fLocalMatrix, *lm); |
| } |
| |
| ContextRec newRec(rec); |
| newRec.fLocalMatrix = lm; |
| |
| return as_SB(fProxyShader)->makeContext(newRec, alloc); |
| } |
| #endif |
| |
| SkImage* SkLocalMatrixShader::onIsAImage(SkMatrix* outMatrix, SkTileMode* mode) const { |
| SkMatrix imageMatrix; |
| SkImage* image = fProxyShader->isAImage(&imageMatrix, mode); |
| if (image && outMatrix) { |
| *outMatrix = ConcatLocalMatrices(this->getLocalMatrix(), imageMatrix); |
| } |
| |
| return image; |
| } |
| |
| bool SkLocalMatrixShader::onAppendStages(const SkStageRec& rec) const { |
| SkTCopyOnFirstWrite<SkMatrix> lm(this->getLocalMatrix()); |
| if (rec.fLocalM) { |
| *lm.writable() = ConcatLocalMatrices(*rec.fLocalM, *lm); |
| } |
| |
| SkStageRec newRec = rec; |
| newRec.fLocalM = lm; |
| return as_SB(fProxyShader)->appendStages(newRec); |
| } |
| |
| |
| skvm::Color SkLocalMatrixShader::onProgram(skvm::Builder* p, |
| skvm::Coord device, skvm::Coord local, skvm::Color paint, |
| const SkMatrixProvider& matrices, const SkMatrix* localM, |
| const SkColorInfo& dst, |
| skvm::Uniforms* uniforms, SkArenaAlloc* alloc) const { |
| SkTCopyOnFirstWrite<SkMatrix> lm(this->getLocalMatrix()); |
| if (localM) { |
| *lm.writable() = ConcatLocalMatrices(*localM, *lm); |
| } |
| return as_SB(fProxyShader)->program(p, device,local, paint, |
| matrices,lm.get(), dst, |
| uniforms,alloc); |
| } |
| |
| sk_sp<SkShader> SkShader::makeWithLocalMatrix(const SkMatrix& localMatrix) const { |
| if (localMatrix.isIdentity()) { |
| return sk_ref_sp(const_cast<SkShader*>(this)); |
| } |
| |
| const SkMatrix* lm = &localMatrix; |
| |
| sk_sp<SkShader> baseShader; |
| SkMatrix otherLocalMatrix; |
| sk_sp<SkShader> proxy = as_SB(this)->makeAsALocalMatrixShader(&otherLocalMatrix); |
| if (proxy) { |
| otherLocalMatrix = SkShaderBase::ConcatLocalMatrices(localMatrix, otherLocalMatrix); |
| lm = &otherLocalMatrix; |
| baseShader = proxy; |
| } else { |
| baseShader = sk_ref_sp(const_cast<SkShader*>(this)); |
| } |
| |
| return sk_make_sp<SkLocalMatrixShader>(std::move(baseShader), *lm); |
| } |
| |
| //////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Replaces the CTM when used. Created to support clipShaders, which have to be evaluated |
| * using the CTM that was present at the time they were specified (which may be different |
| * from the CTM at the time something is drawn through the clip. |
| */ |
| class SkCTMShader final : public SkShaderBase { |
| public: |
| SkCTMShader(sk_sp<SkShader> proxy, const SkMatrix& ctm) |
| : fProxyShader(std::move(proxy)) |
| , fCTM(ctm) |
| {} |
| |
| GradientType asAGradient(GradientInfo* info) const override { |
| return fProxyShader->asAGradient(info); |
| } |
| |
| #if SK_SUPPORT_GPU |
| std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const GrFPArgs&) const override; |
| #endif |
| |
| protected: |
| void flatten(SkWriteBuffer&) const override { SkASSERT(false); } |
| |
| bool onAppendStages(const SkStageRec& rec) const override { |
| SkOverrideDeviceMatrixProvider matrixProvider(fCTM); |
| SkStageRec newRec = { |
| rec.fPipeline, |
| rec.fAlloc, |
| rec.fDstColorType, |
| rec.fDstCS, |
| rec.fPaint, |
| rec.fLocalM, |
| matrixProvider, |
| rec.fSurfaceProps |
| }; |
| return as_SB(fProxyShader)->appendStages(newRec); |
| } |
| |
| skvm::Color onProgram(skvm::Builder* p, |
| skvm::Coord device, skvm::Coord local, skvm::Color paint, |
| const SkMatrixProvider& matrices, const SkMatrix* localM, |
| const SkColorInfo& dst, |
| skvm::Uniforms* uniforms, SkArenaAlloc* alloc) const override { |
| SkOverrideDeviceMatrixProvider matrixProvider(fCTM); |
| return as_SB(fProxyShader)->program(p, device,local, paint, |
| matrixProvider,localM, dst, |
| uniforms,alloc); |
| } |
| |
| private: |
| SK_FLATTENABLE_HOOKS(SkCTMShader) |
| |
| sk_sp<SkShader> fProxyShader; |
| SkMatrix fCTM; |
| |
| using INHERITED = SkShaderBase; |
| }; |
| |
| |
| #if SK_SUPPORT_GPU |
| std::unique_ptr<GrFragmentProcessor> SkCTMShader::asFragmentProcessor( |
| const GrFPArgs& args) const { |
| SkMatrix ctmInv; |
| if (!fCTM.invert(&ctmInv)) { |
| return nullptr; |
| } |
| |
| auto ctmProvider = SkOverrideDeviceMatrixProvider(fCTM); |
| auto base = as_SB(fProxyShader)->asFragmentProcessor( |
| GrFPArgs::ConcatLocalMatrix(args.withNewMatrixProvider(ctmProvider), |
| this->getLocalMatrix())); |
| if (!base) { |
| return nullptr; |
| } |
| |
| // In order for the shader to be evaluated with the original CTM, we explicitly evaluate it |
| // at sk_FragCoord, and pass that through the inverse of the original CTM. This avoids requiring |
| // local coords for the shader and mapping from the draw's local to device and then back. |
| return GrFragmentProcessor::DeviceSpace(GrMatrixEffect::Make(ctmInv, std::move(base))); |
| } |
| #endif |
| |
| sk_sp<SkFlattenable> SkCTMShader::CreateProc(SkReadBuffer& buffer) { |
| SkASSERT(false); |
| return nullptr; |
| } |
| |
| sk_sp<SkShader> SkShaderBase::makeWithCTM(const SkMatrix& postM) const { |
| return sk_sp<SkShader>(new SkCTMShader(sk_ref_sp(this), postM)); |
| } |