Move all ShaderBuilder files to GLSL

src/gpu/glsl/GrGLSLProgramBuilder.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLSLProgramBuilder_DEFINED
 #define GrGLSLProgramBuilder_DEFINED
 
 #include "GrGeometryProcessor.h"
 #include "GrGpu.h"
-#include "gl/builders/GrGLFragmentShaderBuilder.h"
-#include "gl/builders/GrGLGeometryShaderBuilder.h"
-#include "gl/builders/GrGLVertexShaderBuilder.h"
+#include "glsl/GrGLSLFragmentShaderBuilder.h"
+#include "glsl/GrGLSLGeometryShaderBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
+#include "glsl/GrGLSLVertexShaderBuilder.h"
 
 class GrGLSLCaps;
 class GrGLSLShaderVar;
 
+// Enough precision to represent 1 / 2048 accurately in printf
+#define GR_SIGNIFICANT_POW2_DECIMAL_DIG 11
+
 class GrGLSLUniformBuilder {
 public:
     enum ShaderVisibility {
         kVertex_Visibility   = 1 << kVertex_GrShaderType,
         kGeometry_Visibility = 1 << kGeometry_GrShaderType,
         kFragment_Visibility = 1 << kFragment_GrShaderType,
     };
 
     virtual ~GrGLSLUniformBuilder() {}
 
@@ skipping 73 matching lines @@
 
     Varying fVarying;
 
 private:
     GrSLType fType;
     const char* fVsOut;
     const char* fGsIn;
     const char* fGsOut;
     const char* fFsIn;
 
-    friend class GrGLVertexBuilder;
-    friend class GrGLGeometryBuilder;
-    friend class GrGLXferBuilder;
-    friend class GrGLFragmentShaderBuilder;
+    friend class GrGLSLVertexBuilder;
+    friend class GrGLSLGeometryBuilder;
+    friend class GrGLSLXferBuilder;
+    friend class GrGLSLFragmentShaderBuilder;
 };
 
 struct GrGLSLVertToFrag : public GrGLSLVarying {
     GrGLSLVertToFrag(GrSLType type)
         : GrGLSLVarying(type, kVertToFrag_Varying) {}
 };
 
 struct GrGLSLVertToGeo : public GrGLSLVarying {
     GrGLSLVertToGeo(GrSLType type)
         : GrGLSLVarying(type, kVertToGeo_Varying) {}
@@ skipping 28 matching lines @@
 
     /*
      * Creates a fragment shader varying that can be referred to.
      * Comparable to GrGLSLUniformBuilder::addUniform().
      */
     virtual SeparableVaryingHandle addSeparableVarying(
         const char* name, GrGLSLVertToFrag*,
         GrSLPrecision fsPrecision = kDefault_GrSLPrecision) = 0;
 
     // TODO rename getFragmentBuilder
-    virtual GrGLFragmentBuilder* getFragmentShaderBuilder() = 0;
-    virtual GrGLVertexBuilder* getVertexShaderBuilder() = 0;
+    virtual GrGLSLFragmentBuilder* getFragmentShaderBuilder() = 0;
+    virtual GrGLSLVertexBuilder* getVertexShaderBuilder() = 0;
 
     /*
      * *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
      */
 };
 
 
 /* a specializations for FPs. Lets the user add uniforms and FS code */
 class GrGLSLFPBuilder : public virtual GrGLSLUniformBuilder {
 public:
-    virtual GrGLFragmentBuilder* getFragmentShaderBuilder() = 0;
+    virtual GrGLSLFragmentBuilder* getFragmentShaderBuilder() = 0;
 
     /*
      * *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
      */
 };
 
 /* a specializations for XPs. Lets the user add uniforms and FS code */
 class GrGLSLXPBuilder : public virtual GrGLSLUniformBuilder {
 public:
-    virtual GrGLXPFragmentBuilder* getFragmentShaderBuilder() = 0;
+    virtual GrGLSLXPFragmentBuilder* getFragmentShaderBuilder() = 0;
 
     /*
      * *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
      */
 };
 
 class GrGLSLProgramBuilder : public GrGLSLGPBuilder,
                              public GrGLSLFPBuilder,
                              public GrGLSLXPBuilder {
 public:
     typedef GrGpu::DrawArgs DrawArgs;
 
-    GrGLXPFragmentBuilder* getFragmentShaderBuilder() override { return &fFS; }
-    GrGLVertexBuilder* getVertexShaderBuilder() override { return &fVS; }
+    GrGLSLXPFragmentBuilder* getFragmentShaderBuilder() override { return &fFS; }
+    GrGLSLVertexBuilder* getVertexShaderBuilder() override { return &fVS; }
 
     // Handles for program uniforms (other than per-effect uniforms)
     struct BuiltinUniformHandles {
         UniformHandle       fRTAdjustmentUni;
 
         // We use the render target height to provide a y-down frag coord when specifying
         // origin_upper_left is not supported.
         UniformHandle       fRTHeightUni;
     };
 
@@ skipping 20 matching lines @@
     const char* rtAdjustment() const { return "rtAdjustment"; }
 
     // Generates a name for a variable. The generated string will be name prefixed by the prefix
     // char (unless the prefix is '\0'). It also will mangle the name to be stage-specific unless
     // explicitly asked not to.
     void nameVariable(SkString* out, char prefix, const char* name, bool mangle = true);
 
     // number of each input/output type in a single allocation block, used by many builders
     static const int kVarsPerBlock;
 
-    GrGLVertexBuilder fVS;
-    GrGLGeometryBuilder fGS;
-    GrGLFragmentShaderBuilder fFS;
+    GrGLSLVertexBuilder fVS;
+    GrGLSLGeometryBuilder fGS;
+    GrGLSLFragmentShaderBuilder fFS;
     int fStageIndex;
 
     BuiltinUniformHandles fUniformHandles;
 
     const DrawArgs& fArgs;
 
 private:
     virtual void onAppendUniformDecls(ShaderVisibility visibility, SkString* out) const = 0;
 
-    friend class GrGLShaderBuilder;
-    friend class GrGLVertexBuilder;
-    friend class GrGLFragmentShaderBuilder;
-    friend class GrGLGeometryBuilder;
+    friend class GrGLSLShaderBuilder;
+    friend class GrGLSLVertexBuilder;
+    friend class GrGLSLFragmentShaderBuilder;
+    friend class GrGLSLGeometryBuilder;
 };
 
 #endif