SkComposeShader.cpp 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253
  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. #include "include/core/SkColorFilter.h"
  8. #include "include/core/SkString.h"
  9. #include "include/private/SkColorData.h"
  10. #include "src/core/SkArenaAlloc.h"
  11. #include "src/core/SkBlendModePriv.h"
  12. #include "src/core/SkRasterPipeline.h"
  13. #include "src/core/SkReadBuffer.h"
  14. #include "src/core/SkWriteBuffer.h"
  15. #include "src/shaders/SkColorShader.h"
  16. #include "src/shaders/SkComposeShader.h"
  17. namespace {
  18. sk_sp<SkShader> wrap_lm(sk_sp<SkShader> shader, const SkMatrix* lm) {
  19. return (shader && lm) ? shader->makeWithLocalMatrix(*lm) : shader;
  20. }
  21. struct LocalMatrixStageRec final : public SkStageRec {
  22. LocalMatrixStageRec(const SkStageRec& rec, const SkMatrix& lm)
  23. : INHERITED(rec) {
  24. if (!lm.isIdentity()) {
  25. if (fLocalM) {
  26. fStorage.setConcat(lm, *fLocalM);
  27. fLocalM = fStorage.isIdentity() ? nullptr : &fStorage;
  28. } else {
  29. fLocalM = &lm;
  30. }
  31. }
  32. }
  33. private:
  34. SkMatrix fStorage;
  35. using INHERITED = SkStageRec;
  36. };
  37. } // namespace
  38. sk_sp<SkShader> SkShaders::Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src,
  39. const SkMatrix* lm) {
  40. switch (mode) {
  41. case SkBlendMode::kClear: return Color(0);
  42. case SkBlendMode::kDst: return wrap_lm(std::move(dst), lm);
  43. case SkBlendMode::kSrc: return wrap_lm(std::move(src), lm);
  44. default: break;
  45. }
  46. return sk_sp<SkShader>(new SkShader_Blend(mode, std::move(dst), std::move(src), lm));
  47. }
  48. sk_sp<SkShader> SkShaders::Lerp(float weight, sk_sp<SkShader> dst, sk_sp<SkShader> src,
  49. const SkMatrix* lm) {
  50. if (SkScalarIsNaN(weight)) {
  51. return nullptr;
  52. }
  53. if (dst == src || weight <= 0) {
  54. return wrap_lm(std::move(dst), lm);
  55. }
  56. if (weight >= 1) {
  57. return wrap_lm(std::move(src), lm);
  58. }
  59. return sk_sp<SkShader>(new SkShader_Lerp(weight, std::move(dst), std::move(src), lm));
  60. }
  61. sk_sp<SkShader> SkShaders::Lerp(sk_sp<SkShader> red, sk_sp<SkShader> dst, sk_sp<SkShader> src,
  62. const SkMatrix* lm) {
  63. if (!red) {
  64. return nullptr;
  65. }
  66. if (dst == src) {
  67. return wrap_lm(std::move(dst), lm);
  68. }
  69. return sk_sp<SkShader>(new SkShader_LerpRed(std::move(red), std::move(dst), std::move(src),
  70. lm));
  71. }
  72. ///////////////////////////////////////////////////////////////////////////////
  73. static bool append_shader_or_paint(const SkStageRec& rec, SkShader* shader) {
  74. if (shader) {
  75. if (!as_SB(shader)->appendStages(rec)) {
  76. return false;
  77. }
  78. } else {
  79. rec.fPipeline->append_constant_color(rec.fAlloc, rec.fPaint.getColor4f().premul().vec());
  80. }
  81. return true;
  82. }
  83. // Returns the output of e0, and leaves the output of e1 in r,g,b,a
  84. static float* append_two_shaders(const SkStageRec& rec, SkShader* s0, SkShader* s1) {
  85. struct Storage {
  86. float fRes0[4 * SkRasterPipeline_kMaxStride];
  87. };
  88. auto storage = rec.fAlloc->make<Storage>();
  89. if (!append_shader_or_paint(rec, s0)) {
  90. return nullptr;
  91. }
  92. rec.fPipeline->append(SkRasterPipeline::store_src, storage->fRes0);
  93. if (!append_shader_or_paint(rec, s1)) {
  94. return nullptr;
  95. }
  96. return storage->fRes0;
  97. }
  98. ///////////////////////////////////////////////////////////////////////////////
  99. sk_sp<SkFlattenable> SkShader_Blend::CreateProc(SkReadBuffer& buffer) {
  100. sk_sp<SkShader> dst(buffer.readShader());
  101. sk_sp<SkShader> src(buffer.readShader());
  102. unsigned mode = buffer.read32();
  103. // check for valid mode before we cast to the enum type
  104. if (!buffer.validate(mode <= (unsigned)SkBlendMode::kLastMode)) {
  105. return nullptr;
  106. }
  107. return SkShaders::Blend(static_cast<SkBlendMode>(mode), std::move(dst), std::move(src));
  108. }
  109. void SkShader_Blend::flatten(SkWriteBuffer& buffer) const {
  110. buffer.writeFlattenable(fDst.get());
  111. buffer.writeFlattenable(fSrc.get());
  112. buffer.write32((int)fMode);
  113. }
  114. bool SkShader_Blend::onAppendStages(const SkStageRec& orig_rec) const {
  115. const LocalMatrixStageRec rec(orig_rec, this->getLocalMatrix());
  116. float* res0 = append_two_shaders(rec, fDst.get(), fSrc.get());
  117. if (!res0) {
  118. return false;
  119. }
  120. rec.fPipeline->append(SkRasterPipeline::load_dst, res0);
  121. SkBlendMode_AppendStages(fMode, rec.fPipeline);
  122. return true;
  123. }
  124. sk_sp<SkFlattenable> SkShader_Lerp::CreateProc(SkReadBuffer& buffer) {
  125. sk_sp<SkShader> dst(buffer.readShader());
  126. sk_sp<SkShader> src(buffer.readShader());
  127. float t = buffer.readScalar();
  128. return buffer.isValid() ? SkShaders::Lerp(t, std::move(dst), std::move(src)) : nullptr;
  129. }
  130. void SkShader_Lerp::flatten(SkWriteBuffer& buffer) const {
  131. buffer.writeFlattenable(fDst.get());
  132. buffer.writeFlattenable(fSrc.get());
  133. buffer.writeScalar(fWeight);
  134. }
  135. bool SkShader_Lerp::onAppendStages(const SkStageRec& orig_rec) const {
  136. const LocalMatrixStageRec rec(orig_rec, this->getLocalMatrix());
  137. float* res0 = append_two_shaders(rec, fDst.get(), fSrc.get());
  138. if (!res0) {
  139. return false;
  140. }
  141. rec.fPipeline->append(SkRasterPipeline::load_dst, res0);
  142. rec.fPipeline->append(SkRasterPipeline::lerp_1_float, &fWeight);
  143. return true;
  144. }
  145. sk_sp<SkFlattenable> SkShader_LerpRed::CreateProc(SkReadBuffer& buffer) {
  146. sk_sp<SkShader> dst(buffer.readShader());
  147. sk_sp<SkShader> src(buffer.readShader());
  148. sk_sp<SkShader> red(buffer.readShader());
  149. return buffer.isValid() ?
  150. SkShaders::Lerp(std::move(red), std::move(dst), std::move(src)) : nullptr;
  151. }
  152. void SkShader_LerpRed::flatten(SkWriteBuffer& buffer) const {
  153. buffer.writeFlattenable(fDst.get());
  154. buffer.writeFlattenable(fSrc.get());
  155. buffer.writeFlattenable(fRed.get());
  156. }
  157. bool SkShader_LerpRed::onAppendStages(const SkStageRec& orig_rec) const {
  158. const LocalMatrixStageRec rec(orig_rec, this->getLocalMatrix());
  159. struct Storage {
  160. float fRed[4 * SkRasterPipeline_kMaxStride];
  161. };
  162. auto storage = rec.fAlloc->make<Storage>();
  163. if (!as_SB(fRed)->appendStages(rec)) {
  164. return false;
  165. }
  166. // actually, we just need the first (red) channel, but for now we store rgba
  167. rec.fPipeline->append(SkRasterPipeline::store_src, storage->fRed);
  168. float* res0 = append_two_shaders(rec, fDst.get(), fSrc.get());
  169. if (!res0) {
  170. return false;
  171. }
  172. rec.fPipeline->append(SkRasterPipeline::load_dst, res0);
  173. rec.fPipeline->append(SkRasterPipeline::lerp_native, &storage->fRed[0]);
  174. return true;
  175. }
  176. #if SK_SUPPORT_GPU
  177. #include "include/private/GrRecordingContext.h"
  178. #include "src/gpu/effects/GrXfermodeFragmentProcessor.h"
  179. #include "src/gpu/effects/generated/GrComposeLerpEffect.h"
  180. #include "src/gpu/effects/generated/GrComposeLerpRedEffect.h"
  181. #include "src/gpu/effects/generated/GrConstColorProcessor.h"
  182. static std::unique_ptr<GrFragmentProcessor> as_fp(const GrFPArgs& args, SkShader* shader) {
  183. return shader ? as_SB(shader)->asFragmentProcessor(args) : nullptr;
  184. }
  185. std::unique_ptr<GrFragmentProcessor> SkShader_Blend::asFragmentProcessor(
  186. const GrFPArgs& orig_args) const {
  187. const GrFPArgs::WithPreLocalMatrix args(orig_args, this->getLocalMatrix());
  188. auto fpA = as_fp(args, fDst.get());
  189. auto fpB = as_fp(args, fSrc.get());
  190. if (!fpA || !fpB) {
  191. return nullptr;
  192. }
  193. return GrXfermodeFragmentProcessor::MakeFromTwoProcessors(std::move(fpB),
  194. std::move(fpA), fMode);
  195. }
  196. std::unique_ptr<GrFragmentProcessor> SkShader_Lerp::asFragmentProcessor(
  197. const GrFPArgs& orig_args) const {
  198. const GrFPArgs::WithPreLocalMatrix args(orig_args, this->getLocalMatrix());
  199. auto fpA = as_fp(args, fDst.get());
  200. auto fpB = as_fp(args, fSrc.get());
  201. return GrComposeLerpEffect::Make(std::move(fpA), std::move(fpB), fWeight);
  202. }
  203. std::unique_ptr<GrFragmentProcessor> SkShader_LerpRed::asFragmentProcessor(
  204. const GrFPArgs& orig_args) const {
  205. const GrFPArgs::WithPreLocalMatrix args(orig_args, this->getLocalMatrix());
  206. auto fpA = as_fp(args, fDst.get());
  207. auto fpB = as_fp(args, fSrc.get());
  208. auto red = as_SB(fRed)->asFragmentProcessor(args);
  209. if (!red) {
  210. return nullptr;
  211. }
  212. return GrComposeLerpRedEffect::Make(std::move(fpA), std::move(fpB), std::move(red));
  213. }
  214. #endif