GrGLSLPrimitiveProcessor.h 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134
  1. /*
  2. * Copyright 2013 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. #ifndef GrGLSLPrimitiveProcessor_DEFINED
  8. #define GrGLSLPrimitiveProcessor_DEFINED
  9. #include "src/gpu/GrFragmentProcessor.h"
  10. #include "src/gpu/GrPrimitiveProcessor.h"
  11. #include "src/gpu/glsl/GrGLSLProgramDataManager.h"
  12. #include "src/gpu/glsl/GrGLSLUniformHandler.h"
  13. class GrPrimitiveProcessor;
  14. class GrGLSLFPFragmentBuilder;
  15. class GrGLSLGeometryBuilder;
  16. class GrGLSLGPBuilder;
  17. class GrGLSLVaryingHandler;
  18. class GrGLSLVertexBuilder;
  19. class GrShaderCaps;
  20. class GrGLSLPrimitiveProcessor {
  21. public:
  22. using FPCoordTransformIter = GrFragmentProcessor::CoordTransformIter;
  23. virtual ~GrGLSLPrimitiveProcessor() {}
  24. using UniformHandle = GrGLSLProgramDataManager::UniformHandle;
  25. using SamplerHandle = GrGLSLUniformHandler::SamplerHandle;
  26. /**
  27. * This class provides access to the GrCoordTransforms across all GrFragmentProcessors in a
  28. * GrPipeline. It is also used by the primitive processor to specify the fragment shader
  29. * variable that will hold the transformed coords for each GrCoordTransform. It is required that
  30. * the primitive processor iterate over each coord transform and insert a shader var result for
  31. * each. The GrGLSLFragmentProcessors will reference these variables in their fragment code.
  32. */
  33. class FPCoordTransformHandler : public SkNoncopyable {
  34. public:
  35. FPCoordTransformHandler(const GrPipeline& pipeline,
  36. SkTArray<GrShaderVar>* transformedCoordVars)
  37. : fIter(pipeline)
  38. , fTransformedCoordVars(transformedCoordVars) {}
  39. ~FPCoordTransformHandler() { SkASSERT(!this->nextCoordTransform());}
  40. const GrCoordTransform* nextCoordTransform();
  41. // 'args' are constructor params to GrShaderVar.
  42. template<typename... Args>
  43. void specifyCoordsForCurrCoordTransform(Args&&... args) {
  44. SkASSERT(!fAddedCoord);
  45. fTransformedCoordVars->emplace_back(std::forward<Args>(args)...);
  46. SkDEBUGCODE(fAddedCoord = true;)
  47. }
  48. private:
  49. GrFragmentProcessor::CoordTransformIter fIter;
  50. SkDEBUGCODE(bool fAddedCoord = false;)
  51. SkDEBUGCODE(const GrCoordTransform* fCurr = nullptr;)
  52. SkTArray<GrShaderVar>* fTransformedCoordVars;
  53. };
  54. struct EmitArgs {
  55. EmitArgs(GrGLSLVertexBuilder* vertBuilder,
  56. GrGLSLGeometryBuilder* geomBuilder,
  57. GrGLSLFPFragmentBuilder* fragBuilder,
  58. GrGLSLVaryingHandler* varyingHandler,
  59. GrGLSLUniformHandler* uniformHandler,
  60. const GrShaderCaps* caps,
  61. const GrPrimitiveProcessor& gp,
  62. const char* outputColor,
  63. const char* outputCoverage,
  64. const char* rtAdjustName,
  65. const SamplerHandle* texSamplers,
  66. FPCoordTransformHandler* transformHandler)
  67. : fVertBuilder(vertBuilder)
  68. , fGeomBuilder(geomBuilder)
  69. , fFragBuilder(fragBuilder)
  70. , fVaryingHandler(varyingHandler)
  71. , fUniformHandler(uniformHandler)
  72. , fShaderCaps(caps)
  73. , fGP(gp)
  74. , fOutputColor(outputColor)
  75. , fOutputCoverage(outputCoverage)
  76. , fRTAdjustName(rtAdjustName)
  77. , fTexSamplers(texSamplers)
  78. , fFPCoordTransformHandler(transformHandler) {}
  79. GrGLSLVertexBuilder* fVertBuilder;
  80. GrGLSLGeometryBuilder* fGeomBuilder;
  81. GrGLSLFPFragmentBuilder* fFragBuilder;
  82. GrGLSLVaryingHandler* fVaryingHandler;
  83. GrGLSLUniformHandler* fUniformHandler;
  84. const GrShaderCaps* fShaderCaps;
  85. const GrPrimitiveProcessor& fGP;
  86. const char* fOutputColor;
  87. const char* fOutputCoverage;
  88. const char* fRTAdjustName;
  89. const SamplerHandle* fTexSamplers;
  90. FPCoordTransformHandler* fFPCoordTransformHandler;
  91. };
  92. /**
  93. * This is similar to emitCode() in the base class, except it takes a full shader builder.
  94. * This allows the effect subclass to emit vertex code.
  95. */
  96. virtual void emitCode(EmitArgs&) = 0;
  97. /**
  98. * A GrGLSLPrimitiveProcessor instance can be reused with any GrGLSLPrimitiveProcessor that
  99. * produces the same stage key; this function reads data from a GrGLSLPrimitiveProcessor and
  100. * uploads any uniform variables required by the shaders created in emitCode(). The
  101. * GrPrimitiveProcessor parameter is guaranteed to be of the same type and to have an
  102. * identical processor key as the GrPrimitiveProcessor that created this
  103. * GrGLSLPrimitiveProcessor.
  104. * The subclass may use the transform iterator to perform any setup required for the particular
  105. * set of fp transform matrices, such as uploading via uniforms. The iterator will iterate over
  106. * the transforms in the same order as the TransformHandler passed to emitCode.
  107. */
  108. virtual void setData(const GrGLSLProgramDataManager&, const GrPrimitiveProcessor&,
  109. FPCoordTransformIter&&) = 0;
  110. static SkMatrix GetTransformMatrix(const SkMatrix& localMatrix, const GrCoordTransform&);
  111. protected:
  112. void setupUniformColor(GrGLSLFPFragmentBuilder* fragBuilder,
  113. GrGLSLUniformHandler* uniformHandler,
  114. const char* outputName,
  115. UniformHandle* colorUniform);
  116. };
  117. #endif