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,

[reed1, 2016/06/20 15:00:39]

0. Should we have a variant that takes SkImage? SkPixmap?
1. MakeFromBitmap ?
2. More dox on normal rotation... 
- does that vector have to be normalized (i.e. length == 1)?
- why is 'inv' in the name?
- what is a default value? (... 1,0 ?)
3. Is normLocalM forward (my guess) or inverse?
- can I pass nullptr?

[dvonbeck, 2016/06/20 20:03:58]

0. I could make it take in a shader instead of a bitmap, and make it
"format-agnostic". I think that sounds like the best option, instead of having
different factories for each format.
1. I called MakeMap from NormalMap, not Bitmap. If I end up writing the API I
described  just now, I'll call it MakeFromNormalMap and take in a Shader
instead.
2. The vector does have to be normalized. Greg and I will talk to Rob tomorrow
and discuss what the best approach for this specific parameter is once he gets
back on Wednesday, since he wrote that part. Inv is supposed to stand for
inverted. I'll give it a default value that results in no rotation.
3. It is a transformation from texture coordinates to the shape's source space.
I assume this is forward? It is the same format as the local matrices for the
bitmap shader. Nullptr is accepted, gets interpreted as an identity matrix. I
will add this details to the comments.

-                                           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
@@ skipping 17 matching lines @@
         (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