Refactoring of CPU NormalMap handling out into its own class

src/core/SkLightingShader.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 SkLightingShader_DEFINED
 #define SkLightingShader_DEFINED
 
 #include "SkLights.h"
 #include "SkShader.h"
 
 class SkBitmap;
 class SkMatrix;
 
 class SK_API SkLightingShader {
 public:
-    /** Abstract class that generates or reads in normals for use by SkLightingShader. Currently
-        implements the GPU side only. Not to be used as part of the API yet. Used internally by
-        SkLightingShader.
-    */
-    class SK_API NormalSource : public SkFlattenable {
-    public:
-        virtual ~NormalSource();
-
-#if SK_SUPPORT_GPU
-        /** Returns a fragment processor that takes no input and outputs a normal (already rotated)
-            as its output color. To be used as a child fragment processor.
-        */
-        virtual sk_sp<GrFragmentProcessor> asFragmentProcessor(
-                GrContext* context,
-                const SkMatrix& viewM,
-                const SkMatrix* localMatrix,
-                SkFilterQuality filterQuality,
-                SkSourceGammaTreatment gammaTreatment) const = 0;
-#endif
-
-        /** Returns a normal source that provides normals sourced from the the normal map argument.
-              Not to be used as part of the API yet. Used internally by SkLightingShader.
-
-              @param  normal                the normal map
-              @param  invNormRotation       rotation applied to the normal map's normals
-              @param  normLocalM            the local matrix for the normal map
-
-              nullptr will be returned if
-                  'normal' is empty
-                  'normal' too big (> 65535 on either side)
-
-              The normal map is currently assumed to be an 8888 image where the normal at a texel
-              is retrieved by:
-                  N.x = R-127;
-                  N.y = G-127;
-                  N.z = B-127;
-                  N.normalize();
-              The +Z axis is thus encoded in RGB as (127, 127, 255) while the -Z axis is
-              (127, 127, 0).
-        */
-        static sk_sp<NormalSource> MakeMap(const SkBitmap& normal, const SkVector& invNormRotation,
-                                           const SkMatrix* normLocalM);
-
-        SK_DEFINE_FLATTENABLE_TYPE(NormalSource)
-        SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
-    };
-
-
-
     /** Returns a shader that lights the diffuse and normal maps with a set of lights.
 
         It returns a shader with a reference count of 1.
         The caller should decrement the shader's reference count when done with the shader.
         It is an error for count to be < 2.
         @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  diffLocalMatrix the local matrix for the diffuse texture
-        @param  normLocalMatrix the local matrix for the normal map
+        @param  diffLocalMatrix the local matrix for the diffuse map (transform from
+                                texture coordinates to shape source coordinates). nullptr is
+                                interpreted as an identity matrix.
+        @param  normLocalMatrix the local matrix for the normal map (transform from
+                                texture coordinates to shape source coordinates). nullptr is
+                                interpreted as an identity matrix.
 
         nullptr will be returned if:
             either 'diffuse' or 'normal' are empty
             either 'diffuse' or 'normal' are too big (> 65535 on a side)
             'diffuse' and 'normal' aren't the same size
 
         The lighting equation is currently:
             result = LightColor * DiffuseColor * (Normal * LightDir) + AmbientColor
 
         The normal map is currently assumed to be an 8888 image where the normal at a texel
         is retrieved by:
             N.x = R-127;
             N.y = G-127;
             N.z = B-127;
             N.normalize();
         The +Z axis is thus encoded in RGB as (127, 127, 255) while the -Z axis is
         (127, 127, 0).
     */
     static sk_sp<SkShader> Make(const SkBitmap& diffuse, const SkBitmap& normal,
                                 sk_sp<SkLights> lights, const SkVector& invNormRotation,
                                 const SkMatrix* diffLocalMatrix, const SkMatrix* normLocalMatrix);
 
     SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
 };
 
 #endif