Minor cleanup of SkLightingShader

src/effects/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"
 #include "SkErrorInternals.h"
 #include "SkLightingShader.h"
 #include "SkMathPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 
-///////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
 
 /*
    SkLightingShader TODOs:
         support other than clamp mode
         allow 'diffuse' & 'normal' to be of different dimensions?
         support different light types
         support multiple lights
         enforce normal map is 4 channel
         use SkImages instead if SkBitmaps
         vec3 for ambient and light-color
@@ skipping 57 matching lines @@
 
     private:
         SkBitmapProcState* fDiffuseState;
         SkBitmapProcState* fNormalState;
         uint32_t           fFlags;
 
         typedef SkShader::Context INHERITED;
     };
 
     SK_TO_STRING_OVERRIDE()
-    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(LightingShader)
+    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingShaderImpl)
 
 protected:
     void flatten(SkWriteBuffer&) const override;
     Context* onCreateContext(const ContextRec&, void*) const override;
 
 private:
     SkBitmap                fDiffuseMap;
     SkBitmap                fNormalMap;
     SkLightingShader::Light fLight;
     SkColor                 fAmbientColor;  // linear (unpremul) color
 
+    friend class SkLightingShader;
+
     typedef SkShader INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrCoordTransform.h"
 #include "GrFragmentProcessor.h"
 #include "GrTextureAccess.h"
@@ skipping 322 matching lines @@
         }
 
         diffMProc(*fDiffuseState, tmpColor, n, x, y);
         diffSProc(*fDiffuseState, tmpColor, n, tmpColor2);
 
         normalMProc(*fNormalState, tmpNormal, n, x, y);
         normalSProc(*fNormalState, tmpNormal, n, tmpNormal2);
 
         for (int i = 0; i < n; ++i) {
             SkASSERT(0xFF == SkColorGetA(tmpNormal2[i]));  // opaque -> unpremul
-            norm.set(SkIntToScalar(SkColorGetR(tmpNormal2[i]))-127.0f,
-                     SkIntToScalar(SkColorGetG(tmpNormal2[i]))-127.0f,
-                     SkIntToScalar(SkColorGetB(tmpNormal2[i]))-127.0f);
+            norm.set(SkIntToScalar(SkGetPackedR32(tmpNormal2[i]))-127.0f,
+                     SkIntToScalar(SkGetPackedG32(tmpNormal2[i]))-127.0f,
+                     SkIntToScalar(SkGetPackedB32(tmpNormal2[i]))-127.0f);
             norm.normalize();
 
             SkColor diffColor = SkUnPreMultiply::PMColorToColor(tmpColor2[i]);
             NdotL = norm.dot(lightShader.fLight.fDirection);
 
             // This is all done in linear unpremul color space
             r = light(SkColorGetR(lightShader.fLight.fColor), SkColorGetR(diffColor), NdotL, 
                       SkColorGetR(lightShader.fAmbientColor));
             g = light(SkColorGetG(lightShader.fLight.fColor), SkColorGetG(diffColor), NdotL, 
                       SkColorGetG(lightShader.fAmbientColor));
@@ skipping 112 matching lines @@
         normal.isNull() || bitmap_is_too_big(normal) ||
         diffuse.width() != normal.width() ||
         diffuse.height() != normal.height()) {
         return nullptr;
     }
 
     return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, light, ambient, localMatrix));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+
+SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingShader)
+    SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingShaderImpl)
+SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
+
+///////////////////////////////////////////////////////////////////////////////