GLProgramsTest 3.0

src/gpu/gl/builders/GrGLProgramBuilder.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 "GrGLProgramBuilder.h"
 
 #include "gl/GrGLGeometryProcessor.h"
@@ skipping 49 matching lines @@
     // uniforms, varyings, textures, etc
     SkAutoTDelete<GrGLProgramBuilder> builder(CreateProgramBuilder(args, gpu));
 
     GrGLProgramBuilder* pb = builder.get();
 
     // TODO: Once all stages can handle taking a float or vec4 and correctly handling them we can
     // seed correctly here
     GrGLSLExpr4 inputColor;
     GrGLSLExpr4 inputCoverage;
 
-    pb->emitAndInstallProcs(&inputColor, &inputCoverage);
+    if (!pb->emitAndInstallProcs(&inputColor, &inputCoverage)) {
+        return NULL;
+    }
 
     return pb->finalize();
 }
 
 GrGLProgramBuilder* GrGLProgramBuilder::CreateProgramBuilder(const DrawArgs& args,
                                                              GrGLGpu* gpu) {
     if (args.fPrimitiveProcessor->isPathRendering()) {
         SkASSERT(gpu->glCaps().shaderCaps()->pathRenderingSupport() &&
                  !args.fPrimitiveProcessor->willUseGeoShader() &&
                  args.fPrimitiveProcessor->numAttribs() == 0);
@@ skipping 101 matching lines @@
             fUniforms[i].fVariable.appendDecl(this->ctxInfo(), out);
             out->append(";\n");
         }
     }
 }
 
 const GrGLContextInfo& GrGLProgramBuilder::ctxInfo() const {
     return fGpu->ctxInfo();
 }
 
-void GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr4* inputCoverage) {
+bool GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr4* inputCoverage) {
     // First we loop over all of the installed processors and collect coord transforms.  These will
     // be sent to the GrGLPrimitiveProcessor in its emitCode function
+    const GrPrimitiveProcessor& primProc = this->primitiveProcessor();
+    int totalTextures = primProc.numTextures();
+    const int maxTextureUnits = fGpu->glCaps().maxFragmentTextureUnits();
     SkSTArray<8, GrGLProcessor::TransformedCoordsArray> outCoords;
     for (int i = 0; i < this->pipeline().numFragmentStages(); i++) {
         const GrFragmentProcessor* processor = this->pipeline().getFragmentStage(i).processor();
         SkSTArray<2, const GrCoordTransform*, true>& procCoords = fCoordTransforms.push_back();
         for (int t = 0; t < processor->numTransforms(); t++) {
             procCoords.push_back(&processor->coordTransform(t));
         }
+
+        totalTextures += processor->numTextures();
+        if (totalTextures >= maxTextureUnits) {
+            GrContextDebugf(fGpu->getContext(), "Program would use too many texture units\n");
+            return false;
+        }
     }
 
-    const GrPrimitiveProcessor& primProc = this->primitiveProcessor();
     this->emitAndInstallProc(primProc, inputColor, inputCoverage);
 
     fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs));
     int numProcs = this->pipeline().numFragmentStages();
     this->emitAndInstallFragProcs(0, this->pipeline().numColorFragmentStages(), inputColor);
     this->emitAndInstallFragProcs(this->pipeline().numColorFragmentStages(), numProcs,
                                   inputCoverage);
     this->emitAndInstallXferProc(*this->pipeline().getXferProcessor(), *inputColor, *inputCoverage);
+    return true;
 }
 
 void GrGLProgramBuilder::emitAndInstallFragProcs(int procOffset,
                                                  int numProcs,
                                                  GrGLSLExpr4* inOut) {
     for (int e = procOffset; e < numProcs; ++e) {
         GrGLSLExpr4 output;
         const GrPendingFragmentStage& stage = this->pipeline().getFragmentStage(e);
         this->emitAndInstallProc(stage, e, *inOut, &output);
         *inOut = output;
@@ skipping 269 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
         SkDELETE(fProcs[e]);
     }
 }