GrProcessorSet.cpp 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253
  1. /*
  2. * Copyright 2017 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. #include "src/core/SkBlendModePriv.h"
  8. #include "src/gpu/GrAppliedClip.h"
  9. #include "src/gpu/GrCaps.h"
  10. #include "src/gpu/GrProcessorSet.h"
  11. #include "src/gpu/GrUserStencilSettings.h"
  12. #include "src/gpu/GrXferProcessor.h"
  13. #include "src/gpu/effects/GrPorterDuffXferProcessor.h"
  14. const GrProcessorSet& GrProcessorSet::EmptySet() {
  15. static GrProcessorSet gEmpty(GrProcessorSet::Empty::kEmpty);
  16. return gEmpty;
  17. }
  18. GrProcessorSet GrProcessorSet::MakeEmptySet() {
  19. return GrProcessorSet(GrProcessorSet::Empty::kEmpty);
  20. }
  21. GrProcessorSet::GrProcessorSet(GrPaint&& paint) : fXP(paint.getXPFactory()) {
  22. fFlags = 0;
  23. if (paint.numColorFragmentProcessors() <= kMaxColorProcessors) {
  24. fColorFragmentProcessorCnt = paint.numColorFragmentProcessors();
  25. fFragmentProcessors.reset(paint.numTotalFragmentProcessors());
  26. int i = 0;
  27. for (auto& fp : paint.fColorFragmentProcessors) {
  28. SkASSERT(fp.get());
  29. fFragmentProcessors[i++] = std::move(fp);
  30. }
  31. for (auto& fp : paint.fCoverageFragmentProcessors) {
  32. SkASSERT(fp.get());
  33. fFragmentProcessors[i++] = std::move(fp);
  34. }
  35. } else {
  36. SkDebugf("Insane number of color fragment processors in paint. Dropping all processors.");
  37. fColorFragmentProcessorCnt = 0;
  38. }
  39. SkDEBUGCODE(paint.fAlive = false;)
  40. }
  41. GrProcessorSet::GrProcessorSet(SkBlendMode mode)
  42. : fXP(SkBlendMode_AsXPFactory(mode))
  43. , fColorFragmentProcessorCnt(0)
  44. , fFragmentProcessorOffset(0)
  45. , fFlags(0) {}
  46. GrProcessorSet::GrProcessorSet(std::unique_ptr<GrFragmentProcessor> colorFP)
  47. : fFragmentProcessors(1)
  48. , fXP((const GrXPFactory*)nullptr)
  49. , fColorFragmentProcessorCnt(1)
  50. , fFragmentProcessorOffset(0)
  51. , fFlags(0) {
  52. SkASSERT(colorFP);
  53. fFragmentProcessors[0] = std::move(colorFP);
  54. }
  55. GrProcessorSet::GrProcessorSet(GrProcessorSet&& that)
  56. : fXP(std::move(that.fXP))
  57. , fColorFragmentProcessorCnt(that.fColorFragmentProcessorCnt)
  58. , fFragmentProcessorOffset(0)
  59. , fFlags(that.fFlags) {
  60. fFragmentProcessors.reset(that.fFragmentProcessors.count() - that.fFragmentProcessorOffset);
  61. for (int i = 0; i < fFragmentProcessors.count(); ++i) {
  62. fFragmentProcessors[i] =
  63. std::move(that.fFragmentProcessors[i + that.fFragmentProcessorOffset]);
  64. }
  65. that.fColorFragmentProcessorCnt = 0;
  66. that.fFragmentProcessors.reset(0);
  67. }
  68. GrProcessorSet::~GrProcessorSet() {
  69. if (this->isFinalized() && this->xferProcessor()) {
  70. this->xferProcessor()->unref();
  71. }
  72. }
  73. #ifdef SK_DEBUG
  74. SkString dump_fragment_processor_tree(const GrFragmentProcessor* fp, int indentCnt) {
  75. SkString result;
  76. SkString indentString;
  77. for (int i = 0; i < indentCnt; ++i) {
  78. indentString.append(" ");
  79. }
  80. result.appendf("%s%s %s \n", indentString.c_str(), fp->name(), fp->dumpInfo().c_str());
  81. if (fp->numChildProcessors()) {
  82. for (int i = 0; i < fp->numChildProcessors(); ++i) {
  83. result += dump_fragment_processor_tree(&fp->childProcessor(i), indentCnt + 1);
  84. }
  85. }
  86. return result;
  87. }
  88. SkString GrProcessorSet::dumpProcessors() const {
  89. SkString result;
  90. if (this->numFragmentProcessors()) {
  91. if (this->numColorFragmentProcessors()) {
  92. result.append("Color Fragment Processors:\n");
  93. for (int i = 0; i < this->numColorFragmentProcessors(); ++i) {
  94. result += dump_fragment_processor_tree(this->colorFragmentProcessor(i), 1);
  95. }
  96. } else {
  97. result.append("No color fragment processors.\n");
  98. }
  99. if (this->numCoverageFragmentProcessors()) {
  100. result.append("Coverage Fragment Processors:\n");
  101. for (int i = 0; i < this->numColorFragmentProcessors(); ++i) {
  102. result += dump_fragment_processor_tree(this->coverageFragmentProcessor(i), 1);
  103. }
  104. } else {
  105. result.append("No coverage fragment processors.\n");
  106. }
  107. } else {
  108. result.append("No color or coverage fragment processors.\n");
  109. }
  110. if (this->isFinalized()) {
  111. result.append("Xfer Processor: ");
  112. if (this->xferProcessor()) {
  113. result.appendf("%s\n", this->xferProcessor()->name());
  114. } else {
  115. result.append("SrcOver\n");
  116. }
  117. } else {
  118. result.append("XP Factory dumping not implemented.\n");
  119. }
  120. return result;
  121. }
  122. #endif
  123. bool GrProcessorSet::operator==(const GrProcessorSet& that) const {
  124. SkASSERT(this->isFinalized());
  125. SkASSERT(that.isFinalized());
  126. int fpCount = this->numFragmentProcessors();
  127. if (((fFlags ^ that.fFlags) & ~kFinalized_Flag) || fpCount != that.numFragmentProcessors() ||
  128. fColorFragmentProcessorCnt != that.fColorFragmentProcessorCnt) {
  129. return false;
  130. }
  131. for (int i = 0; i < fpCount; ++i) {
  132. int a = i + fFragmentProcessorOffset;
  133. int b = i + that.fFragmentProcessorOffset;
  134. if (!fFragmentProcessors[a]->isEqual(*that.fFragmentProcessors[b])) {
  135. return false;
  136. }
  137. }
  138. // Most of the time both of these are null
  139. if (!this->xferProcessor() && !that.xferProcessor()) {
  140. return true;
  141. }
  142. const GrXferProcessor& thisXP = this->xferProcessor()
  143. ? *this->xferProcessor()
  144. : GrPorterDuffXPFactory::SimpleSrcOverXP();
  145. const GrXferProcessor& thatXP = that.xferProcessor()
  146. ? *that.xferProcessor()
  147. : GrPorterDuffXPFactory::SimpleSrcOverXP();
  148. return thisXP.isEqual(thatXP);
  149. }
  150. GrProcessorSet::Analysis GrProcessorSet::finalize(
  151. const GrProcessorAnalysisColor& colorInput, const GrProcessorAnalysisCoverage coverageInput,
  152. const GrAppliedClip* clip, const GrUserStencilSettings* userStencil,
  153. bool hasMixedSampledCoverage, const GrCaps& caps, GrClampType clampType,
  154. SkPMColor4f* overrideInputColor) {
  155. SkASSERT(!this->isFinalized());
  156. SkASSERT(!fFragmentProcessorOffset);
  157. GrProcessorSet::Analysis analysis;
  158. analysis.fCompatibleWithCoverageAsAlpha = GrProcessorAnalysisCoverage::kLCD != coverageInput;
  159. const std::unique_ptr<const GrFragmentProcessor>* fps =
  160. fFragmentProcessors.get() + fFragmentProcessorOffset;
  161. GrColorFragmentProcessorAnalysis colorAnalysis(
  162. colorInput, unique_ptr_address_as_pointer_address(fps), fColorFragmentProcessorCnt);
  163. fps += fColorFragmentProcessorCnt;
  164. int n = this->numCoverageFragmentProcessors();
  165. bool hasCoverageFP = n > 0;
  166. bool coverageUsesLocalCoords = false;
  167. for (int i = 0; i < n; ++i) {
  168. if (!fps[i]->compatibleWithCoverageAsAlpha()) {
  169. analysis.fCompatibleWithCoverageAsAlpha = false;
  170. }
  171. coverageUsesLocalCoords |= fps[i]->usesLocalCoords();
  172. }
  173. if (clip) {
  174. hasCoverageFP = hasCoverageFP || clip->numClipCoverageFragmentProcessors();
  175. for (int i = 0; i < clip->numClipCoverageFragmentProcessors(); ++i) {
  176. const GrFragmentProcessor* clipFP = clip->clipCoverageFragmentProcessor(i);
  177. analysis.fCompatibleWithCoverageAsAlpha &= clipFP->compatibleWithCoverageAsAlpha();
  178. coverageUsesLocalCoords |= clipFP->usesLocalCoords();
  179. }
  180. }
  181. int colorFPsToEliminate = colorAnalysis.initialProcessorsToEliminate(overrideInputColor);
  182. analysis.fInputColorType = static_cast<Analysis::PackedInputColorType>(
  183. colorFPsToEliminate ? Analysis::kOverridden_InputColorType
  184. : Analysis::kOriginal_InputColorType);
  185. GrProcessorAnalysisCoverage outputCoverage;
  186. if (GrProcessorAnalysisCoverage::kLCD == coverageInput) {
  187. outputCoverage = GrProcessorAnalysisCoverage::kLCD;
  188. } else if (hasCoverageFP || GrProcessorAnalysisCoverage::kSingleChannel == coverageInput) {
  189. outputCoverage = GrProcessorAnalysisCoverage::kSingleChannel;
  190. } else {
  191. outputCoverage = GrProcessorAnalysisCoverage::kNone;
  192. }
  193. GrXPFactory::AnalysisProperties props = GrXPFactory::GetAnalysisProperties(
  194. this->xpFactory(), colorAnalysis.outputColor(), outputCoverage, caps, clampType);
  195. if (!this->numCoverageFragmentProcessors() &&
  196. GrProcessorAnalysisCoverage::kNone == coverageInput) {
  197. }
  198. analysis.fRequiresDstTexture =
  199. SkToBool(props & GrXPFactory::AnalysisProperties::kRequiresDstTexture);
  200. analysis.fCompatibleWithCoverageAsAlpha &=
  201. SkToBool(props & GrXPFactory::AnalysisProperties::kCompatibleWithCoverageAsAlpha);
  202. analysis.fRequiresNonOverlappingDraws = SkToBool(
  203. props & GrXPFactory::AnalysisProperties::kRequiresNonOverlappingDraws);
  204. if (props & GrXPFactory::AnalysisProperties::kIgnoresInputColor) {
  205. colorFPsToEliminate = this->numColorFragmentProcessors();
  206. analysis.fInputColorType =
  207. static_cast<Analysis::PackedInputColorType>(Analysis::kIgnored_InputColorType);
  208. analysis.fUsesLocalCoords = coverageUsesLocalCoords;
  209. } else {
  210. analysis.fCompatibleWithCoverageAsAlpha &=
  211. colorAnalysis.allProcessorsCompatibleWithCoverageAsAlpha();
  212. analysis.fUsesLocalCoords = coverageUsesLocalCoords | colorAnalysis.usesLocalCoords();
  213. }
  214. for (int i = 0; i < colorFPsToEliminate; ++i) {
  215. fFragmentProcessors[i].reset(nullptr);
  216. }
  217. fFragmentProcessorOffset = colorFPsToEliminate;
  218. fColorFragmentProcessorCnt -= colorFPsToEliminate;
  219. analysis.fHasColorFragmentProcessor = (fColorFragmentProcessorCnt != 0);
  220. auto xp = GrXPFactory::MakeXferProcessor(this->xpFactory(), colorAnalysis.outputColor(),
  221. outputCoverage, hasMixedSampledCoverage, caps,
  222. clampType);
  223. fXP.fProcessor = xp.release();
  224. fFlags |= kFinalized_Flag;
  225. analysis.fIsInitialized = true;
  226. #ifdef SK_DEBUG
  227. bool hasXferBarrier =
  228. fXP.fProcessor &&
  229. GrXferBarrierType::kNone_GrXferBarrierType != fXP.fProcessor->xferBarrierType(caps);
  230. bool needsNonOverlappingDraws = analysis.fRequiresDstTexture || hasXferBarrier;
  231. SkASSERT(analysis.fRequiresNonOverlappingDraws == needsNonOverlappingDraws);
  232. #endif
  233. return analysis;
  234. }