LightingShader and NormalSource comment and style fixes

src/core/SkNormalMapSource.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 "SkNormalMapSource.h"
 
 #include "SkLightingShader.h"
@@ skipping 55 matching lines @@
             fragBuilder->codeAppend( "    float scalingFactorSquared = "
                                                  "( (transformed.x * transformed.x) "
                                                    "+ (transformed.y * transformed.y) )"
                                                  "/(1.0 - (normal.z * normal.z));");
             fragBuilder->codeAppendf("    %s = vec4(transformed*inversesqrt(scalingFactorSquared),"
                                                    "normal.z, 0.0);",
                     args.fOutputColor);
             fragBuilder->codeAppend( "}");
         }
 
-        static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
-                           GrProcessorKeyBuilder* b) {
+        static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
             b->add32(0x0);
         }
 
     protected:
         void setNormalData(const GrGLSLProgramDataManager& pdman,
                            const GrProcessor& proc) override {
             const NormalMapFP& normalMapFP = proc.cast<NormalMapFP>();
 
             const SkMatrix& invCTM = normalMapFP.invCTM();
             fColumnMajorInvCTM22[0] = invCTM.get(SkMatrix::kMScaleX);
             fColumnMajorInvCTM22[1] = invCTM.get(SkMatrix::kMSkewY);
             fColumnMajorInvCTM22[2] = invCTM.get(SkMatrix::kMSkewX);
             fColumnMajorInvCTM22[3] = invCTM.get(SkMatrix::kMScaleY);
             pdman.setMatrix2f(fXformUni, fColumnMajorInvCTM22);
         }
 
     private:
+        // Upper-right 2x2 corner of the inverse of the CTM in column-major form
         float fColumnMajorInvCTM22[4];
         GrGLSLProgramDataManager::UniformHandle fXformUni;
     };
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
         GLSLNormalMapFP::GenKey(*this, caps, b);
     }
 
     const char* name() const override { return "NormalMapFP"; }
 
@@ skipping 22 matching lines @@
     }
 
     return sk_make_sp<NormalMapFP>(std::move(mapFP), fInvCTM);
 }
 
 #endif // SK_SUPPORT_GPU
 
 ////////////////////////////////////////////////////////////////////////////
 
 SkNormalMapSourceImpl::Provider::Provider(const SkNormalMapSourceImpl& source,
-                                        SkShader::Context* mapContext,
-                                        SkPaint* overridePaint)
+                                          SkShader::Context* mapContext,
+                                          SkPaint* overridePaint)
     : fSource(source)
     , fMapContext(mapContext)
     , fOverridePaint(overridePaint) {}
 
 SkNormalMapSourceImpl::Provider::~Provider() {
     fMapContext->~Context();
     fOverridePaint->~SkPaint();
 }
 
-SkNormalSource::Provider* SkNormalMapSourceImpl::asProvider(
-        const SkShader::ContextRec &rec, void *storage) const {
+SkNormalSource::Provider* SkNormalMapSourceImpl::asProvider(const SkShader::ContextRec &rec,
+                                                            void *storage) const {
     SkMatrix normTotalInv;
     if (!this->computeNormTotalInverse(rec, &normTotalInv)) {
         return nullptr;
     }
 
     // Overriding paint's alpha because we need the normal map's RGB channels to be unpremul'd
     void* paintStorage = (char*)storage + sizeof(Provider);
     SkPaint* overridePaint = new (paintStorage) SkPaint(*(rec.fPaint));
     overridePaint->setAlpha(0xFF);
     SkShader::ContextRec overrideRec(*overridePaint, *(rec.fMatrix), rec.fLocalMatrix,
                                      rec.fPreferredDstType);
 
     void* mapContextStorage = (char*) paintStorage + sizeof(SkPaint);
     SkShader::Context* context = fMapShader->createContext(overrideRec, mapContextStorage);
     if (!context) {
         return nullptr;
     }
 
     return new (storage) Provider(*this, context, overridePaint);
 }
 
 size_t SkNormalMapSourceImpl::providerSize(const SkShader::ContextRec& rec) const {
     return sizeof(Provider) + sizeof(SkPaint) + fMapShader->contextSize(rec);
 }
 
 bool SkNormalMapSourceImpl::computeNormTotalInverse(const SkShader::ContextRec& rec,
-                                                  SkMatrix* normTotalInverse) const {
+                                                    SkMatrix* normTotalInverse) const {
     SkMatrix total;
     total.setConcat(*rec.fMatrix, fMapShader->getLocalMatrix());
 
     const SkMatrix* m = &total;
     if (rec.fLocalMatrix) {
         total.setConcat(*m, *rec.fLocalMatrix);
         m = &total;
     }
     return m->invert(normTotalInverse);
 }
 
 #define BUFFER_MAX 16
 void SkNormalMapSourceImpl::Provider::fillScanLine(int x, int y, SkPoint3 output[],
-                                                 int count) const {
+                                                   int count) const {
     SkPMColor tmpNormalColors[BUFFER_MAX];
 
     do {
         int n = SkTMin(count, BUFFER_MAX);
 
         fMapContext->shadeSpan(x, y, tmpNormalColors, n);
 
         for (int i = 0; i < n; i++) {
             SkPoint3 tempNorm;
 
@@ skipping 57 matching lines @@
 
 sk_sp<SkNormalSource> SkNormalSource::MakeFromNormalMap(sk_sp<SkShader> map, const SkMatrix& ctm) {
     SkMatrix invCTM;
 
     if (!ctm.invert(&invCTM) || !map) {
         return nullptr;
     }
 
     return sk_make_sp<SkNormalMapSourceImpl>(std::move(map), invCTM);
 }