Style bikeshed - remove extraneous whitespace

src/core/SkLightingShader.cpp

-
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapProcState.h"
 #include "SkColor.h"
 #include "SkEmptyShader.h"
@@ skipping 34 matching lines @@
         @param diffuse    the diffuse bitmap
         @param normal     the normal map
         @param lights     the lights applied to the normal map
         @param invNormRotation rotation applied to the normal map's normals
         @param diffLocalM the local matrix for the diffuse coordinates
         @param normLocalM the local matrix for the normal coordinates
     */
     SkLightingShaderImpl(const SkBitmap& diffuse, const SkBitmap& normal,
                          const SkLightingShader::Lights* lights,
                          const SkVector& invNormRotation,
-                         const SkMatrix* diffLocalM, const SkMatrix* normLocalM) 
+                         const SkMatrix* diffLocalM, const SkMatrix* normLocalM)
         : INHERITED(diffLocalM)
         , fDiffuseMap(diffuse)
         , fNormalMap(normal)
         , fLights(SkRef(lights))
         , fInvNormRotation(invNormRotation) {
 
         if (normLocalM) {
             fNormLocalMatrix = *normLocalM;
         } else {
             fNormLocalMatrix.reset();
@@ skipping 130 matching lines @@
             fAmbientColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                           kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                           "AmbientColor", &ambientColorUniName);
 
             const char* xformUniName = nullptr;
             fXformUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                    kVec2f_GrSLType, kDefault_GrSLPrecision,
                                                    "Xform", &xformUniName);
 
             fragBuilder->codeAppend("vec4 diffuseColor = ");
-            fragBuilder->appendTextureLookupAndModulate(args.fInputColor, args.fSamplers[0], 
-                                                args.fCoords[0].c_str(), 
+            fragBuilder->appendTextureLookupAndModulate(args.fInputColor, args.fSamplers[0],
+                                                args.fCoords[0].c_str(),
                                                 args.fCoords[0].getType());
             fragBuilder->codeAppend(";");
 
             fragBuilder->codeAppend("vec4 normalColor = ");
             fragBuilder->appendTextureLookup(args.fSamplers[1],
-                                     args.fCoords[1].c_str(), 
+                                     args.fCoords[1].c_str(),
                                      args.fCoords[1].getType());
             fragBuilder->codeAppend(";");
 
             fragBuilder->codeAppend("vec3 normal = normalColor.rgb - vec3(0.5);");
 
             fragBuilder->codeAppendf(
                                  "mat3 m = mat3(%s.x, -%s.y, 0.0, %s.y, %s.x, 0.0, 0.0, 0.0, 1.0);",
                                  xformUniName, xformUniName, xformUniName, xformUniName);
-            
+
             // TODO: inverse map the light direction vectors in the vertex shader rather than
             // transforming all the normals here!
             fragBuilder->codeAppend("normal = normalize(m*normal);");
 
             fragBuilder->codeAppendf("float NdotL = clamp(dot(normal, %s), 0.0, 1.0);",
                                      lightDirUniName);
             // diffuse light
             fragBuilder->codeAppendf("vec3 result = %s*diffuseColor.rgb*NdotL;", lightColorUniName);
             // ambient light
             fragBuilder->codeAppendf("result += %s;", ambientColorUniName);
@@ skipping 61 matching lines @@
     }
 
     const SkVector3& lightDir() const { return fLightDir; }
     const SkColor3f& lightColor() const { return fLightColor; }
     const SkColor3f& ambientColor() const { return fAmbientColor; }
     const SkVector& invNormRotation() const { return fInvNormRotation; }
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new LightingGLFP; }
 
-    bool onIsEqual(const GrFragmentProcessor& proc) const override { 
+    bool onIsEqual(const GrFragmentProcessor& proc) const override {
         const LightingFP& lightingFP = proc.cast<LightingFP>();
         return fDiffDeviceTransform == lightingFP.fDiffDeviceTransform &&
                fNormDeviceTransform == lightingFP.fNormDeviceTransform &&
                fDiffuseTextureAccess == lightingFP.fDiffuseTextureAccess &&
                fNormalTextureAccess == lightingFP.fNormalTextureAccess &&
                fLightDir == lightingFP.fLightDir &&
                fLightColor == lightingFP.fLightColor &&
                fAmbientColor == lightingFP.fAmbientColor &&
                fInvNormRotation == lightingFP.fInvNormRotation;
     }
 
     GrCoordTransform fDiffDeviceTransform;
     GrCoordTransform fNormDeviceTransform;
     GrTextureAccess  fDiffuseTextureAccess;
     GrTextureAccess  fNormalTextureAccess;
     SkVector3        fLightDir;
     SkColor3f        fLightColor;
     SkColor3f        fAmbientColor;
 
     SkVector         fInvNormRotation;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 static bool make_mat(const SkBitmap& bm,
                      const SkMatrix& localMatrix1,
                      const SkMatrix* localMatrix2,
                      SkMatrix* result) {
-    
+
     result->setIDiv(bm.width(), bm.height());
 
     SkMatrix lmInverse;
     if (!localMatrix1.invert(&lmInverse)) {
         return false;
     }
     if (localMatrix2) {
         SkMatrix inv;
         if (!localMatrix2->invert(&inv)) {
             return false;
         }
         lmInverse.postConcat(inv);
     }
     result->preConcat(lmInverse);
 
     return true;
 }
 
 const GrFragmentProcessor* SkLightingShaderImpl::asFragmentProcessor(
                                                              GrContext* context,
                                                              const SkMatrix& viewM,
                                                              const SkMatrix* localMatrix,
                                                              SkFilterQuality filterQuality) const {
     // we assume diffuse and normal maps have same width and height
     // TODO: support different sizes
     SkASSERT(fDiffuseMap.width() == fNormalMap.width() &&
              fDiffuseMap.height() == fNormalMap.height());
     SkMatrix diffM, normM;
-    
+
     if (!make_mat(fDiffuseMap, this->getLocalMatrix(), localMatrix, &diffM)) {
         return nullptr;
     }
 
     if (!make_mat(fNormalMap, fNormLocalMatrix, localMatrix, &normM)) {
         return nullptr;
     }
 
     bool doBicubic;
     GrTextureParams::FilterMode diffFilterMode = GrSkFilterQualityToGrFilterMode(
-                                        SkTMin(filterQuality, kMedium_SkFilterQuality), 
+                                        SkTMin(filterQuality, kMedium_SkFilterQuality),
                                         viewM,
                                         this->getLocalMatrix(),
-                                        &doBicubic); 
+                                        &doBicubic);
     SkASSERT(!doBicubic);
 
     GrTextureParams::FilterMode normFilterMode = GrSkFilterQualityToGrFilterMode(
-                                        SkTMin(filterQuality, kMedium_SkFilterQuality), 
+                                        SkTMin(filterQuality, kMedium_SkFilterQuality),
                                         viewM,
                                         fNormLocalMatrix,
-                                        &doBicubic); 
+                                        &doBicubic);
     SkASSERT(!doBicubic);
 
     // TODO: support other tile modes
     GrTextureParams diffParams(kClamp_TileMode, diffFilterMode);
     SkAutoTUnref<GrTexture> diffuseTexture(GrRefCachedBitmapTexture(context,
                                                                     fDiffuseMap, diffParams));
     if (!diffuseTexture) {
         SkErrorInternals::SetError(kInternalError_SkError, "Couldn't convert bitmap to texture.");
         return nullptr;
     }
@@ skipping 45 matching lines @@
     // elsewhere. Call the destructors but leave the freeing of the memory to the caller.
     fDiffuseState->~SkBitmapProcState();
     fNormalState->~SkBitmapProcState();
 }
 
 static inline SkPMColor convert(SkColor3f color, U8CPU a) {
     if (color.fX <= 0.0f) {
         color.fX = 0.0f;
     } else if (color.fX >= 255.0f) {
         color.fX = 255.0f;
-    } 
+    }
 
     if (color.fY <= 0.0f) {
         color.fY = 0.0f;
     } else if (color.fY >= 255.0f) {
         color.fY = 255.0f;
-    } 
+    }
 
     if (color.fZ <= 0.0f) {
         color.fZ = 0.0f;
     } else if (color.fZ >= 255.0f) {
         color.fZ = 255.0f;
-    } 
+    }
 
     return SkPreMultiplyARGB(a, (int) color.fX,  (int) color.fY, (int) color.fZ);
 }
 
 // larger is better (fewer times we have to loop), but we shouldn't
 // take up too much stack-space (each one here costs 16 bytes)
 #define TMP_COUNT     16
 
 void SkLightingShaderImpl::LightingShaderContext::shadeSpan(int x, int y,
                                                             SkPMColor result[], int count) {
@@ skipping 31 matching lines @@
 
         for (int i = 0; i < n; ++i) {
             SkASSERT(0xFF == SkColorGetA(tmpNormal2[i]));  // opaque -> unpremul
             norm.set(SkIntToScalar(SkGetPackedR32(tmpNormal2[i]))-127.0f,
                      SkIntToScalar(SkGetPackedG32(tmpNormal2[i]))-127.0f,
                      SkIntToScalar(SkGetPackedB32(tmpNormal2[i]))-127.0f);
             norm.normalize();
 
             xformedNorm.fX = lightShader.fInvNormRotation.fX * norm.fX +
                              lightShader.fInvNormRotation.fY * norm.fY;
-            xformedNorm.fY = lightShader.fInvNormRotation.fX * norm.fX - 
+            xformedNorm.fY = lightShader.fInvNormRotation.fX * norm.fX -
                              lightShader.fInvNormRotation.fY * norm.fY;
             xformedNorm.fZ = norm.fZ;
 
             SkColor diffColor = SkUnPreMultiply::PMColorToColor(tmpColor2[i]);
 
             SkColor3f accum = SkColor3f::Make(0.0f, 0.0f, 0.0f);
             // This is all done in linear unpremul color space (each component 0..255.0f though)
             for (int l = 0; l < lightShader.fLights->numLights(); ++l) {
                 const SkLight& light = lightShader.fLights->light(l);
 
@@ skipping 69 matching lines @@
             return nullptr;
         }
 
         if (isAmbient) {
             builder.add(SkLight(color));
         } else {
             SkVector3 dir;
             if (!buf.readScalarArray(&dir.fX, 3)) {
                 return nullptr;
             }
-            builder.add(SkLight(color, dir));        
+            builder.add(SkLight(color, dir));
         }
     }
 
     SkAutoTUnref<const SkLightingShader::Lights> lights(builder.finish());
 
     return new SkLightingShaderImpl(diffuse, normal, lights, SkVector::Make(1.0f, 0.0f),
                                     &diffLocalM, &normLocalM);
 }
 
 void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const {
@@ skipping 102 matching lines @@
                                             normLocalM);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////