remove path specific program building classes

src/gpu/gl/GrGLProgram.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgram.h"
 
 #include "GrAllocator.h"
@@ skipping 13 matching lines @@
 #define GL_CALL(X) GR_GL_CALL(fGpu->glInterface(), X)
 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(fGpu->glInterface(), R, X)
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLProgram::GrGLProgram(GrGLGpu* gpu,
                          const GrProgramDesc& desc,
                          const BuiltinUniformHandles& builtinUniforms,
                          GrGLuint programID,
                          const UniformInfoArray& uniforms,
+                         const SeparableVaryingInfoArray& separableVaryings,
                          GrGLInstalledGeoProc* geometryProcessor,
                          GrGLInstalledXferProc* xferProcessor,
                          GrGLInstalledFragProcs* fragmentProcessors,
                          SkTArray<UniformHandle>* passSamplerUniforms)
     : fColor(GrColor_ILLEGAL)
     , fCoverage(0)
     , fDstTextureUnit(-1)
     , fBuiltinUniformHandles(builtinUniforms)
     , fProgramID(programID)
     , fGeometryProcessor(geometryProcessor)
     , fXferProcessor(xferProcessor)
     , fFragmentProcessors(SkRef(fragmentProcessors))
     , fDesc(desc)
     , fGpu(gpu)
-    , fProgramDataManager(gpu, uniforms) {
+    , fProgramDataManager(gpu, programID, uniforms, separableVaryings) {
     fSamplerUniforms.swap(passSamplerUniforms);
     // Assign texture units to sampler uniforms one time up front.
     GL_CALL(UseProgram(fProgramID));
     for (int i = 0; i < fSamplerUniforms.count(); i++) {
         fProgramDataManager.setSampler(fSamplerUniforms[i], i);
     }
 }
 
 GrGLProgram::~GrGLProgram() {
     if (fProgramID) {
@@ skipping 29 matching lines @@
     // we set the textures, and uniforms for installed processors in a generic way, but subclasses
     // of GLProgram determine how to set coord transforms
     fGeometryProcessor->fGLProc->setData(fProgramDataManager, primProc);
     append_texture_bindings(fGeometryProcessor.get(), primProc, textureBindings);
 
     this->setFragmentData(primProc, pipeline, textureBindings);
 
     const GrXferProcessor& xp = *pipeline.getXferProcessor();
     fXferProcessor->fGLProc->setData(fProgramDataManager, xp);
     append_texture_bindings(fXferProcessor.get(), xp, textureBindings);
-
-    // Some of GrGLProgram subclasses need to update state here
-    this->didSetData();
 }
 
 void GrGLProgram::setFragmentData(const GrPrimitiveProcessor& primProc,
                                   const GrPipeline& pipeline,
                                   SkTArray<const GrTextureAccess*>* textureBindings) {
     int numProcessors = fFragmentProcessors->fProcs.count();
     for (int i = 0; i < numProcessors; ++i) {
         const GrFragmentProcessor& processor = pipeline.getFragmentProcessor(i);
         fFragmentProcessors->fProcs[i]->fGLProc->setData(fProgramDataManager, processor);
         this->setTransformData(primProc,
                                processor,
                                i,
                                fFragmentProcessors->fProcs[i]);
         append_texture_bindings(fFragmentProcessors->fProcs[i], processor, textureBindings);
     }
 }
 void GrGLProgram::setTransformData(const GrPrimitiveProcessor& primProc,
                                    const GrFragmentProcessor& processor,
                                    int index,
                                    GrGLInstalledFragProc* ip) {
-    GrGLGeometryProcessor* gp =
-            static_cast<GrGLGeometryProcessor*>(fGeometryProcessor.get()->fGLProc.get());
+    GrGLPrimitiveProcessor* gp = fGeometryProcessor.get()->fGLProc.get();
     gp->setTransformData(primProc, fProgramDataManager, index,
                          processor.coordTransforms());
 }
 
 void GrGLProgram::setRenderTargetState(const GrPrimitiveProcessor& primProc,
                                        const GrPipeline& pipeline) {
     // Load the RT height uniform if it is needed to y-flip gl_FragCoord.
     if (fBuiltinUniformHandles.fRTHeightUni.isValid() &&
         fRenderTargetState.fRenderTargetSize.fHeight != pipeline.getRenderTarget()->height()) {
         fProgramDataManager.set1f(fBuiltinUniformHandles.fRTHeightUni,
                                    SkIntToScalar(pipeline.getRenderTarget()->height()));
     }
 
-    // call subclasses to set the actual view matrix
-    this->onSetRenderTargetState(primProc, pipeline);
-}
-
-void GrGLProgram::onSetRenderTargetState(const GrPrimitiveProcessor&,
-                                         const GrPipeline& pipeline) {
+    // set RT adjustment
     const GrRenderTarget* rt = pipeline.getRenderTarget();
     SkISize size;
     size.set(rt->width(), rt->height());
-    if (fRenderTargetState.fRenderTargetOrigin != rt->origin() ||
-        fRenderTargetState.fRenderTargetSize != size) {
-        fRenderTargetState.fRenderTargetSize = size;
-        fRenderTargetState.fRenderTargetOrigin = rt->origin();
+    if (!primProc.isPathRendering()) {
+        if (fRenderTargetState.fRenderTargetOrigin != rt->origin() ||
+            fRenderTargetState.fRenderTargetSize != size) {
+            fRenderTargetState.fRenderTargetSize = size;
+            fRenderTargetState.fRenderTargetOrigin = rt->origin();
 
-        GrGLfloat rtAdjustmentVec[4];
-        fRenderTargetState.getRTAdjustmentVec(rtAdjustmentVec);
-        fProgramDataManager.set4fv(fBuiltinUniformHandles.fRTAdjustmentUni, 1, rtAdjustmentVec);
+            GrGLfloat rtAdjustmentVec[4];
+            fRenderTargetState.getRTAdjustmentVec(rtAdjustmentVec);
+            fProgramDataManager.set4fv(fBuiltinUniformHandles.fRTAdjustmentUni, 1, rtAdjustmentVec);
+        }
+    } else {
+        SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport());
+        const GrPathProcessor& pathProc = primProc.cast<GrPathProcessor>();
+        fGpu->glPathRendering()->setProjectionMatrix(pathProc.viewMatrix(),
+                                                     size, rt->origin());
     }
 }
-