Turned on SkSL->GLSL compiler

src/gpu/instanced/InstanceProcessor.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "InstanceProcessor.h"
 
 #include "GrContext.h"
@@ skipping 89 matching lines @@
 
 class GLSLInstanceProcessor::VertexInputs {
 public:
     VertexInputs(const InstanceProcessor& instProc, GrGLSLVertexBuilder* vertexBuilder)
         : fInstProc(instProc),
           fVertexBuilder(vertexBuilder) {
     }
 
     void initParams(const SamplerHandle paramsBuffer) {
         fParamsBuffer = paramsBuffer;
-        fVertexBuilder->definef("PARAMS_IDX_MASK", "0x%xu", kParamsIdx_InfoMask);
         fVertexBuilder->appendPrecisionModifier(kHigh_GrSLPrecision);
-        fVertexBuilder->codeAppendf("int paramsIdx = int(%s & PARAMS_IDX_MASK);",
-                                    this->attr(Attrib::kInstanceInfo));
+        fVertexBuilder->codeAppendf("int paramsIdx = int(%s & 0x%x);",
+                                    this->attr(Attrib::kInstanceInfo),
+                                    kParamsIdx_InfoMask);
     }
 
     const char* attr(Attrib attr) const { return fInstProc.getAttrib((int)attr).fName; }
 
     void fetchNextParam(GrSLType type = kVec4f_GrSLType) const {
         SkASSERT(fParamsBuffer.isValid());
         if (type != kVec4f_GrSLType) {
             fVertexBuilder->codeAppendf("%s(", GrGLSLTypeString(type));
         }
         fVertexBuilder->appendTexelFetch(fParamsBuffer, "paramsIdx++");
@@ skipping 93 matching lines @@
     VertexInputs inputs(ip, v);
     if (ip.batchInfo().fHasParams) {
         SkASSERT(1 == ip.numBuffers());
         inputs.initParams(args.fBufferSamplers[0]);
     }
 
     if (!ip.batchInfo().fHasPerspective) {
         v->codeAppendf("mat2x3 shapeMatrix = mat2x3(%s, %s);",
                        inputs.attr(Attrib::kShapeMatrixX), inputs.attr(Attrib::kShapeMatrixY));
     } else {
-        v->definef("PERSPECTIVE_FLAG", "0x%xu", kPerspective_InfoFlag);
+        v->defineConstantf("int", "PERSPECTIVE_FLAG", "0x%x", kPerspective_InfoFlag);
         v->codeAppendf("mat3 shapeMatrix = mat3(%s, %s, vec3(0, 0, 1));",
                        inputs.attr(Attrib::kShapeMatrixX), inputs.attr(Attrib::kShapeMatrixY));
-        v->codeAppendf("if (0u != (%s & PERSPECTIVE_FLAG)) {",
+        v->codeAppendf("if (0 != (%s & PERSPECTIVE_FLAG)) {",
                        inputs.attr(Attrib::kInstanceInfo));
         v->codeAppend (    "shapeMatrix[2] = ");
         inputs.fetchNextParam(kVec3f_GrSLType);
         v->codeAppend (    ";");
         v->codeAppend ("}");
     }
 
     bool hasSingleShapeType = SkIsPow2(ip.batchInfo().fShapeTypes);
     if (!hasSingleShapeType) {
-        v->define("SHAPE_TYPE_BIT", kShapeType_InfoBit);
+        v->defineConstant("SHAPE_TYPE_BIT", kShapeType_InfoBit);
         v->codeAppendf("uint shapeType = %s >> SHAPE_TYPE_BIT;",
                        inputs.attr(Attrib::kInstanceInfo));
     }
 
     SkAutoTDelete<Backend> backend(Backend::Create(pipeline, ip.batchInfo(), inputs));
     backend->init(varyingHandler, v);
 
     int usedShapeDefinitions = 0;
 
     if (hasSingleShapeType || !(ip.batchInfo().fShapeTypes & ~kRRect_ShapesMask)) {
@@ skipping 27 matching lines @@
         if (ip.batchInfo().fShapeTypes & kRect_ShapeFlag) {
             v->codeAppend ("else {");
             backend->setupRect(v);
             v->codeAppend ("}");
         }
     }
 
     if (ip.batchInfo().fInnerShapeTypes) {
         bool hasSingleInnerShapeType = SkIsPow2(ip.batchInfo().fInnerShapeTypes);
         if (!hasSingleInnerShapeType) {
-            v->definef("INNER_SHAPE_TYPE_MASK", "0x%xu", kInnerShapeType_InfoMask);
-            v->define("INNER_SHAPE_TYPE_BIT", kInnerShapeType_InfoBit);
+            v->defineConstantf("int", "INNER_SHAPE_TYPE_MASK", "0x%x", kInnerShapeType_InfoMask);
+            v->defineConstant("INNER_SHAPE_TYPE_BIT", kInnerShapeType_InfoBit);
             v->codeAppendf("uint innerShapeType = ((%s & INNER_SHAPE_TYPE_MASK) >> "
                                                   "INNER_SHAPE_TYPE_BIT);",
                            inputs.attr(Attrib::kInstanceInfo));
         }
         // Here we take advantage of the fact that outerRect == localRect in recordDRRect.
         v->codeAppendf("vec4 outer = %s;", inputs.attr(Attrib::kLocalRect));
         v->codeAppend ("vec4 inner = ");
         inputs.fetchNextParam();
         v->codeAppend (";");
         // outer2Inner is a transform from shape coords to inner shape coords:
@@ skipping 39 matching lines @@
             }
             if (ip.batchInfo().fInnerShapeTypes & kRect_ShapeFlag) {
                 v->codeAppend("else {");
                 backend->setupInnerRect(v);
                 v->codeAppend("}");
             }
         }
     }
 
     if (usedShapeDefinitions & kOval_ShapeFlag) {
-        v->definef("OVAL_SHAPE_TYPE", "%du", (int)ShapeType::kOval);
+        v->defineConstant("OVAL_SHAPE_TYPE", (int)ShapeType::kOval);
     }
     if (usedShapeDefinitions & kSimpleRRect_ShapeFlag) {
-        v->definef("SIMPLE_R_RECT_SHAPE_TYPE", "%du", (int)ShapeType::kSimpleRRect);
+        v->defineConstant("SIMPLE_R_RECT_SHAPE_TYPE", (int)ShapeType::kSimpleRRect);
     }
     if (usedShapeDefinitions & kNinePatch_ShapeFlag) {
-        v->definef("NINE_PATCH_SHAPE_TYPE", "%du", (int)ShapeType::kNinePatch);
+        v->defineConstant("NINE_PATCH_SHAPE_TYPE", (int)ShapeType::kNinePatch);
     }
     SkASSERT(!(usedShapeDefinitions & (kRect_ShapeFlag | kComplexRRect_ShapeFlag)));
 
     backend->emitCode(v, f, pipeline.ignoresCoverage() ? nullptr : args.fOutputCoverage,
                       args.fOutputColor);
 
     const char* localCoords = nullptr;
     if (ip.batchInfo().fUsesLocalCoords) {
         localCoords = "localCoords";
         v->codeAppendf("vec2 t = 0.5 * (%s + vec2(1));", backend->outShapeCoords());
         v->codeAppendf("vec2 localCoords = (1.0 - t) * %s.xy + t * %s.zw;",
                        inputs.attr(Attrib::kLocalRect), inputs.attr(Attrib::kLocalRect));
     }
     if (ip.batchInfo().fHasLocalMatrix && ip.batchInfo().fHasParams) {
-        v->definef("LOCAL_MATRIX_FLAG", "0x%xu", kLocalMatrix_InfoFlag);
-        v->codeAppendf("if (0u != (%s & LOCAL_MATRIX_FLAG)) {",
+        v->defineConstantf("int", "LOCAL_MATRIX_FLAG", "0x%x", kLocalMatrix_InfoFlag);
+        v->codeAppendf("if (0 != (%s & LOCAL_MATRIX_FLAG)) {",
                        inputs.attr(Attrib::kInstanceInfo));
         if (!ip.batchInfo().fUsesLocalCoords) {
             inputs.skipParams(2);
         } else {
             v->codeAppendf(    "mat2x3 localMatrix;");
             v->codeAppend (    "localMatrix[0] = ");
             inputs.fetchNextParam(kVec3f_GrSLType);
             v->codeAppend (    ";");
             v->codeAppend (    "localMatrix[1] = ");
             inputs.fetchNextParam(kVec3f_GrSLType);
@@ skipping 790 matching lines @@
         } else if (fBatchInfo.fShapeTypes & kOval_ShapeFlag) {
             fArcCoords = fShapeCoords;
             fArcInverseMatrix = fShapeInverseMatrix;
             fFragArcHalfSpan = fFragShapeHalfSpan;
             if (fBatchInfo.fShapeTypes & kRect_ShapeFlag) {
                 varyingHandler->addFlatVarying("triangleIsArc", &fTriangleIsArc,
                                                kLow_GrSLPrecision);
             }
         }
         if (kRect_ShapeFlag != fBatchInfo.fShapeTypes) {
-           v->definef("SAMPLE_MASK_ALL", "0x%x", (1 << fEffectiveSampleCnt) - 1);
+           v->defineConstantf("int", "SAMPLE_MASK_ALL", "0x%x", (1 << fEffectiveSampleCnt) - 1);
            varyingHandler->addFlatVarying("earlyAccept", &fEarlyAccept, kHigh_GrSLPrecision);
         }
     }
     if (!fBatchInfo.fHasPerspective) {
         v->codeAppend("mat2 shapeInverseMatrix = inverse(mat2(shapeMatrix));");
         v->codeAppend("vec2 fragShapeSpan = abs(vec4(shapeInverseMatrix).xz) + "
                                            "abs(vec4(shapeInverseMatrix).yw);");
     }
 }
 
@@ skipping 160 matching lines @@
         v->codeAppendf("innerRadii = max(innerRadii, 2e-1 * %s);", fFragInnerShapeHalfSpan.vsOut());
     } else {
         v->codeAppend ("innerRadii = max(innerRadii, vec2(1e-4));");
     }
     v->codeAppendf("%s = vec4(1.0 - innerRadii, 1.0 / innerRadii);", fInnerRRect.vsOut());
 }
 
 void GLSLInstanceProcessor::BackendMultisample::onEmitCode(GrGLSLVertexBuilder*,
                                                            GrGLSLPPFragmentBuilder* f,
                                                            const char*, const char*) {
-    f->define("SAMPLE_COUNT", fEffectiveSampleCnt);
+    f->defineConstant("SAMPLE_COUNT", fEffectiveSampleCnt);
     if (this->isMixedSampled()) {
-        f->definef("SAMPLE_MASK_ALL", "0x%x", (1 << fEffectiveSampleCnt) - 1);
-        f->definef("SAMPLE_MASK_MSB", "0x%x", 1 << (fEffectiveSampleCnt - 1));
+        f->defineConstantf("int", "SAMPLE_MASK_ALL", "0x%x", (1 << fEffectiveSampleCnt) - 1);
+        f->defineConstantf("int", "SAMPLE_MASK_MSB", "0x%x", 1 << (fEffectiveSampleCnt - 1));
     }
 
     if (kRect_ShapeFlag != (fBatchInfo.fShapeTypes | fBatchInfo.fInnerShapeTypes)) {
         GrGLSLShaderVar x("x", kVec2f_GrSLType, GrGLSLShaderVar::kNonArray, kHigh_GrSLPrecision);
         f->emitFunction(kFloat_GrSLType, "square", 1, &x, "return dot(x, x);", &fSquareFun);
     }
 
     EmitShapeCoords shapeCoords;
     shapeCoords.fVarying = &fShapeCoords;
     shapeCoords.fInverseMatrix = fShapeInverseMatrix.fsIn();
@@ skipping 737 matching lines @@
 
         case kCorneredRect_FirstIndex: return "basic_round_rect";
         case kCorneredFramedRect_FirstIndex: return "coverage_round_rect";
         case kCorneredRectFanned_FirstIndex: return "mixed_samples_round_rect";
 
         default: return "unknown";
     }
 }
 
 }