Move XferProcessors to glsl

src/gpu/effects/GrCoverageSetOpXP.cpp

 
 /*
  * 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 "effects/GrCoverageSetOpXP.h"
 #include "GrCaps.h"
 #include "GrColor.h"
 #include "GrProcessor.h"
 #include "GrProcOptInfo.h"
-#include "gl/GrGLXferProcessor.h"
 #include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
+#include "glsl/GrGLSLXferProcessor.h"
 
 class CoverageSetOpXP : public GrXferProcessor {
 public:
     static GrXferProcessor* Create(SkRegion::Op regionOp, bool invertCoverage) {
         return new CoverageSetOpXP(regionOp, invertCoverage);
     }
 
     ~CoverageSetOpXP() override;
 
     const char* name() const override { return "Coverage Set Op"; }
 
-    GrGLXferProcessor* createGLInstance() const override;
+    GrGLSLXferProcessor* createGLInstance() const override;
 
     bool invertCoverage() const { return fInvertCoverage; }
 
 private:
     CoverageSetOpXP(SkRegion::Op regionOp, bool fInvertCoverage);
 
     GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
                                                  const GrProcOptInfo& coveragePOI,
                                                  bool doesStencilWrite,
                                                  GrColor* color,
@@ skipping 10 matching lines @@
     }
 
     SkRegion::Op fRegionOp;
     bool         fInvertCoverage;
 
     typedef GrXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class GLCoverageSetOpXP : public GrGLXferProcessor {
+class GLCoverageSetOpXP : public GrGLSLXferProcessor {
 public:
     GLCoverageSetOpXP(const GrProcessor&) {}
 
     ~GLCoverageSetOpXP() override {}
 
     static void GenKey(const GrProcessor& processor, const GrGLSLCaps& caps,
                        GrProcessorKeyBuilder* b) {
         const CoverageSetOpXP& xp = processor.cast<CoverageSetOpXP>();
         uint32_t key = xp.invertCoverage() ?  0x0 : 0x1;
         b->add32(key);
     };
 
 private:
     void emitOutputsForBlendState(const EmitArgs& args) override {
         const CoverageSetOpXP& xp = args.fXP.cast<CoverageSetOpXP>();
         GrGLSLXPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
 
         if (xp.invertCoverage()) {
             fsBuilder->codeAppendf("%s = 1.0 - %s;", args.fOutputPrimary, args.fInputCoverage);
         } else {
             fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputCoverage);
         }
     }
 
     void onSetData(const GrGLSLProgramDataManager&, const GrXferProcessor&) override {};
 
-    typedef GrGLXferProcessor INHERITED;
+    typedef GrGLSLXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CoverageSetOpXP::CoverageSetOpXP(SkRegion::Op regionOp, bool invertCoverage)
     : fRegionOp(regionOp)
     , fInvertCoverage(invertCoverage) {
     this->initClassID<CoverageSetOpXP>();
 }
 
 CoverageSetOpXP::~CoverageSetOpXP() {
 }
 
 void CoverageSetOpXP::onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
     GLCoverageSetOpXP::GenKey(*this, caps, b);
 }
 
-GrGLXferProcessor* CoverageSetOpXP::createGLInstance() const {
+GrGLSLXferProcessor* CoverageSetOpXP::createGLInstance() const {
     return new GLCoverageSetOpXP(*this);
 }
 
 GrXferProcessor::OptFlags
 CoverageSetOpXP::onGetOptimizations(const GrProcOptInfo& colorPOI,
                                     const GrProcOptInfo& coveragePOI,
                                     bool doesStencilWrite,
                                     GrColor* color,
                                     const GrCaps& caps) {
     // We never look at the color input
@@ skipping 129 matching lines @@
 }
 
 GR_DEFINE_XP_FACTORY_TEST(GrCoverageSetOpXPFactory);
 
 const GrXPFactory* GrCoverageSetOpXPFactory::TestCreate(GrProcessorTestData* d) {
     SkRegion::Op regionOp = SkRegion::Op(d->fRandom->nextULessThan(SkRegion::kLastOp + 1));
     bool invertCoverage = !d->fRenderTarget->hasMixedSamples() && d->fRandom->nextBool();
     return GrCoverageSetOpXPFactory::Create(regionOp, invertCoverage);
 }