Move all ShaderBuilder files to GLSL

experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDither.h"
 #include "SkPerlinNoiseShader2.h"
 #include "SkColorFilter.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkShader.h"
 #include "SkUnPreMultiply.h"
 #include "SkString.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "GrInvariantOutput.h"
 #include "SkGr.h"
 #include "effects/GrConstColorProcessor.h"
 #include "gl/GrGLFragmentProcessor.h"
-#include "gl/builders/GrGLProgramBuilder.h"
+#include "glsl/GrGLSLFragmentShaderBuilder.h"
+#include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #endif
 
 static const int kBlockSize = 256;
 static const int kBlockMask = kBlockSize - 1;
 static const int kPerlinNoise = 4096;
 static const int kRandMaximum = SK_MaxS32; // 2**31 - 1
 
 static uint8_t improved_noise_permutations[] = { 
     151, 160, 137,  91,  90,  15, 131,  13, 201,  95,  96,  53, 194, 233,   7, 225, 140,  36, 103, 
@@ skipping 714 matching lines @@
                                        kNone_SkFilterQuality);
 }
 
 GrGLPerlinNoise2::GrGLPerlinNoise2(const GrProcessor& processor)
   : fType(processor.cast<GrPerlinNoise2Effect>().type())
   , fStitchTiles(processor.cast<GrPerlinNoise2Effect>().stitchTiles())
   , fNumOctaves(processor.cast<GrPerlinNoise2Effect>().numOctaves()) {
 }
 
 void GrGLPerlinNoise2::emitCode(EmitArgs& args) {
-    GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
+    GrGLSLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
     SkString vCoords = fsBuilder->ensureFSCoords2D(args.fCoords, 0);
 
-    fBaseFrequencyUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+    fBaseFrequencyUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
                                             "baseFrequency");
     const char* baseFrequencyUni = args.fBuilder->getUniformCStr(fBaseFrequencyUni);
 
     const char* stitchDataUni = nullptr;
     if (fStitchTiles) {
-        fStitchDataUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+        fStitchDataUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
                                              kVec2f_GrSLType, kDefault_GrSLPrecision,
                                              "stitchData");
         stitchDataUni = args.fBuilder->getUniformCStr(fStitchDataUni);
     }
 
     // There are 4 lines, so the center of each line is 1/8, 3/8, 5/8 and 7/8
     const char* chanCoordR  = "0.125";
     const char* chanCoordG  = "0.375";
     const char* chanCoordB  = "0.625";
     const char* chanCoordA  = "0.875";
@@ skipping 218 matching lines @@
     // Clamp values
     fsBuilder->codeAppendf("\n\t\t%s = clamp(%s, 0.0, 1.0);", args.fOutputColor, args.fOutputColor);
 
     // Pre-multiply the result
     fsBuilder->codeAppendf("\n\t\t%s = vec4(%s.rgb * %s.aaa, %s.a);\n",
                            args.fOutputColor, args.fOutputColor,
                            args.fOutputColor, args.fOutputColor);
 }
 
 void GrGLPerlinNoise2::GenKey(const GrProcessor& processor, const GrGLSLCaps&,
-                             GrProcessorKeyBuilder* b) {
+                              GrProcessorKeyBuilder* b) {
     const GrPerlinNoise2Effect& turbulence = processor.cast<GrPerlinNoise2Effect>();
 
     uint32_t key = turbulence.numOctaves();
 
     key = key << 3; // Make room for next 3 bits
 
     switch (turbulence.type()) {
         case SkPerlinNoiseShader2::kFractalNoise_Type:
             key |= 0x1;
             break;
@@ skipping 143 matching lines @@
     return shader->asFragmentProcessor(d->fContext,
                                        GrTest::TestMatrix(d->fRandom), nullptr,
                                        kNone_SkFilterQuality);
 }
 
 GrGLImprovedPerlinNoise::GrGLImprovedPerlinNoise(const GrProcessor& processor)
   : fZ(processor.cast<GrImprovedPerlinNoiseEffect>().z()) {
 }
 
 void GrGLImprovedPerlinNoise::emitCode(EmitArgs& args) {
-    GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
+    GrGLSLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
     SkString vCoords = fsBuilder->ensureFSCoords2D(args.fCoords, 0);
 
-    fBaseFrequencyUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+    fBaseFrequencyUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
                                             "baseFrequency");
     const char* baseFrequencyUni = args.fBuilder->getUniformCStr(fBaseFrequencyUni);
 
-    fOctavesUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+    fOctavesUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
                                       kFloat_GrSLType, kDefault_GrSLPrecision,
                                       "octaves");
     const char* octavesUni = args.fBuilder->getUniformCStr(fOctavesUni);
 
-    fZUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+    fZUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
                                       kFloat_GrSLType, kDefault_GrSLPrecision,
                                       "z");
     const char* zUni = args.fBuilder->getUniformCStr(fZUni);
 
     // fade function
     static const GrGLSLShaderVar fadeArgs[] =  {
         GrGLSLShaderVar("t", kVec3f_GrSLType)
     };
     SkString fadeFuncName;
     fsBuilder->emitFunction(kVec3f_GrSLType, "fade", SK_ARRAY_COUNT(fadeArgs),
@@ skipping 230 matching lines @@
     str->append(" seed: ");
     str->appendScalar(fSeed);
     str->append(" stitch tiles: ");
     str->append(fStitchTiles ? "true " : "false ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif