API change to allow for NormalSource selection at the user level.

gm/lightingshader.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 "gm.h"
 
+#include "SkBitmapProcShader.h"
 #include "SkLightingShader.h"
+#include "SkNormalSource.h"
 #include "SkPoint3.h"
 #include "SkShader.h"
 
 // Create a hemispherical normal map
 static SkBitmap make_hemi_normalmap(int texSize) {
     SkBitmap hemi;
     hemi.allocN32Pixels(texSize, texSize);
 
     sk_tool_utils::create_hemi_normal_map(&hemi, SkIRect::MakeWH(texSize, texSize));
     return hemi;
@@ skipping 20 matching lines @@
 namespace skiagm {
 
 // This GM exercises lighting shaders.
 class LightingShaderGM : public GM {
 public:
     LightingShaderGM() {
         this->setBGColor(sk_tool_utils::color_to_565(0xFFCCCCCC));
 
         SkLights::Builder builder;
 
         builder.add(SkLights::Light(SkColor3f::Make(1.0f, 1.0f, 1.0f),

[robertphillips, 2016/07/06 16:36:33]

I think you want this to be normalized: 
 (SK_ScalarRoot2Over2, 0.0f, SK_ScalarRoot2Over2)
?

[dvonbeck, 2016/07/06 18:07:48]

It gets normalized by the constructor, should I still change it?

[robertphillips, 2016/07/06 19:11:13]

It will probably make more sense to the reader. Otherwise they have to normalize
it in their heads to figure out where to expect the light.

[dvonbeck, 2016/07/06 19:34:36]

Done.

-                                    SkVector3::Make(1.0f, 0.0f, 0.0f)));
+                                    SkVector3::Make(1.0f, 0.0f, 0.6f)));
         builder.add(SkLights::Light(SkColor3f::Make(0.2f, 0.2f, 0.2f)));
 
         fLights = builder.finish();
     }
 
 protected:
     enum NormalMap {
         kHemi_NormalMap,
         kFrustum_NormalMap,
         kTetra_NormalMap,
@@ skipping 25 matching lines @@
 
     void drawRect(SkCanvas* canvas, const SkRect& r, NormalMap mapType) {
 
         SkRect bitmapBounds = SkRect::MakeIWH(fDiffuse.width(), fDiffuse.height());
 
         SkMatrix matrix;
         matrix.setRectToRect(bitmapBounds, r, SkMatrix::kFill_ScaleToFit);
 
         const SkMatrix& ctm = canvas->getTotalMatrix();
 
-        // TODO: correctly pull out the pure rotation
-        SkVector invNormRotation = { ctm[SkMatrix::kMScaleX], ctm[SkMatrix::kMSkewY] };
-
         SkPaint paint;
-        paint.setShader(SkLightingShader::Make(fDiffuse, fNormalMaps[mapType], fLights,
-                                               invNormRotation, &matrix, &matrix));
+        sk_sp<SkShader> normalMap = SkMakeBitmapShader(fNormalMaps[mapType],
+                SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix, nullptr);
+        sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap),
+                                                                               ctm);
+        paint.setShader(SkLightingShader::Make(fDiffuse, fLights, &matrix,
+                                               std::move(normalSource)));
 
         canvas->drawRect(r, paint);
     }
 
     void onDraw(SkCanvas* canvas) override {
         SkMatrix m;
         SkRect r;
 
         {
             r = SkRect::MakeWH(SkIntToScalar(kTexSize), SkIntToScalar(kTexSize));
@@ skipping 53 matching lines @@
 
     sk_sp<SkLights> fLights;
 
     typedef GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM(return new LightingShaderGM;)
 }