Add ability to rotate light direction in drawLitAtlas Sample slide

samplecode/SampleLitAtlas.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 "SampleCode.h"
 #include "SkAnimTimer.h"
 #include "SkView.h"
 #include "SkCanvas.h"
 #include "SkDrawable.h"
 #include "SkLightingShader.h"
 #include "SkLights.h"
 #include "SkRandom.h"
 #include "SkRSXform.h"
 
 #include "sk_tool_utils.h"
 
 class DrawLitAtlasDrawable : public SkDrawable {
 public:
     DrawLitAtlasDrawable(const SkRect& r)
         : fBounds(r)
-        , fUseColors(false) {
+        , fUseColors(false)
+        , fLightDir(SkVector3::Make(1.0f, 0.0f, 0.0f)) {
         fAtlas = MakeAtlas();
 
         SkRandom rand;
         for (int i = 0; i < kNumAsteroids; ++i) {
             fAsteroids[i].initAsteroid(&rand, fBounds, &fDiffTex[i], &fNormTex[i]);
         }
 
         fShip.initShip(fBounds, &fDiffTex[kNumAsteroids], &fNormTex[kNumAsteroids]);
 
-        SkLights::Builder builder;
-
-        builder.add(SkLights::Light(SkColor3f::Make(1.0f, 1.0f, 1.0f),
-                                    SkVector3::Make(1.0f, 0.0f, 0.0f)));
-        builder.add(SkLights::Light(SkColor3f::Make(0.2f, 0.2f, 0.2f)));
-
-        fLights = builder.finish();
+        this->updateLights();
     }
 
     void toggleUseColors() {
         fUseColors = !fUseColors;
     }
 
+    void rotateLight() {
+        SkScalar c;
+        SkScalar s = SkScalarSinCos(SK_ScalarPI/6.0f, &c);
+
+        SkScalar newX = c * fLightDir.fX - s * fLightDir.fY;
+        SkScalar newY = s * fLightDir.fX + c * fLightDir.fY;
+
+        fLightDir.set(newX, newY, 0.0f);
+
+        this->updateLights();
+    }
+
     void left() {
         SkScalar newRot = SkScalarMod(fShip.rot() + (2*SK_ScalarPI - SK_ScalarPI/32.0f),
                                       2 * SK_ScalarPI);
         fShip.setRot(newRot);
     }
 
     void right() {
         SkScalar newRot = SkScalarMod(fShip.rot() + SK_ScalarPI/32.0f, 2 * SK_ScalarPI);
         fShip.setRot(newRot);
     }
@@ skipping 27 matching lines @@
         }
 
         fShip.advance(fBounds);
         xforms[kNumAsteroids] = fShip.asRSXform();
         if (fUseColors) {
             colors[kNumAsteroids] = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF);
         }
 
 #ifdef SK_DEBUG
         canvas->drawBitmap(fAtlas, 0, 0); // just to see the atlas
-#endif        
+
+        this->drawLightDir(canvas, fBounds.centerX(), fBounds.centerY());
+#endif
 
 #if 0
         // TODO: revitalize when drawLitAtlas API lands
         SkPaint paint;
         paint.setFilterQuality(kLow_SkFilterQuality);
 
         const SkRect cull = this->getBounds();
         const SkColor* colorsPtr = fUseColors ? colors : NULL;
 
         canvas->drawLitAtlas(fAtlas, xforms, fDiffTex, fNormTex, colorsPtr, kNumAsteroids+1,
                              SkXfermode::kModulate_Mode, &cull, &paint, fLights);
 #else
         SkMatrix diffMat, normalMat;
 
         for (int i = 0; i < kNumAsteroids+1; ++i) {
             colors[i] = colors[i] & 0xFF000000; // to silence compilers
             SkPaint paint;
 
             SkRect r = fDiffTex[i];
             r.offsetTo(0, 0);
 
             diffMat.setRectToRect(fDiffTex[i], r, SkMatrix::kFill_ScaleToFit);
             normalMat.setRectToRect(fNormTex[i], r, SkMatrix::kFill_ScaleToFit);
 
             SkMatrix m;
             m.setRSXform(xforms[i]);
 
             // TODO: correctly pull out the pure rotation
             SkVector invNormRotation = { m[SkMatrix::kMScaleX], m[SkMatrix::kMSkewY] };
+            SkASSERT(SkScalarNearlyEqual(invNormRotation.lengthSqd(), SK_Scalar1));
 
             paint.setShader(SkLightingShader::Make(fAtlas, fAtlas, fLights,
                                                    invNormRotation, &diffMat, &normalMat));
 
             canvas->save();
                 canvas->setMatrix(m);
                 canvas->drawRect(r, paint);
             canvas->restore();
         }
 #endif
@@ skipping 24 matching lines @@
         kBigAsteroid_ObjType = 0,
         kMedAsteroid_ObjType,
         kSmAsteroid_ObjType,
         kShip_ObjType,
 
         kLast_ObjType = kShip_ObjType
     };
 
     static const int kObjTypeCount = kLast_ObjType + 1;
 
+    void updateLights() {        
+        SkLights::Builder builder;
+
+        builder.add(SkLights::Light(SkColor3f::Make(1.0f, 1.0f, 1.0f), fLightDir));
+        builder.add(SkLights::Light(SkColor3f::Make(0.2f, 0.2f, 0.2f)));
+
+        fLights = builder.finish();
+    }
+
+#ifdef SK_DEBUG
+    // Draw a vector to the light
+    void drawLightDir(SkCanvas* canvas, SkScalar centerX, SkScalar centerY) {
+        static const int kBgLen = 30;
+        static const int kSmLen = 5;
+
+        // TODO: change the lighting coordinate system to be right handed
+        SkPoint p1 = SkPoint::Make(centerX + kBgLen * fLightDir.fX,
+                                   centerY - kBgLen * fLightDir.fY);
+        SkPoint p2 = SkPoint::Make(centerX + (kBgLen-kSmLen) * fLightDir.fX,
+                                   centerY - (kBgLen-kSmLen) * fLightDir.fY);
+
+        SkPaint p;
+        canvas->drawLine(centerX, centerY, p1.fX, p1.fY, p);
+        canvas->drawLine(p1.fX, p1.fY,
+                         p2.fX - kSmLen * fLightDir.fY, p2.fY - kSmLen * fLightDir.fX, p);
+        canvas->drawLine(p1.fX, p1.fY,
+                         p2.fX + kSmLen * fLightDir.fY, p2.fY + kSmLen * fLightDir.fX, p);
+    }
+#endif
+
     // Create the mixed diffuse & normal atlas
     // 
     //    big color circle  |  big normal hemi
     //    ------------------------------------
     //    med color circle  |  med normal pyra
     //    ------------------------------------
     //    sm color circle   |   sm normal hemi 
     //    ------------------------------------
     //    big ship          | big tetra normal
     static SkBitmap MakeAtlas() {
@@ skipping 213 matching lines @@
     static const int kShipYOff = kSmYOff + kSmSize + kPad;
     static const int kMaxShipSpeed = 5;
 
     SkBitmap        fAtlas;
     ObjectRecord    fAsteroids[kNumAsteroids];
     ObjectRecord    fShip;
     SkRect          fDiffTex[kNumAsteroids+kNumShips];
     SkRect          fNormTex[kNumAsteroids+kNumShips];
     SkRect          fBounds;
     bool            fUseColors;
+    SkVector3       fLightDir;
     sk_sp<SkLights> fLights;
 
     typedef SkDrawable INHERITED;
 };
 
 class DrawLitAtlasView : public SampleView {
 public:
     DrawLitAtlasView()
         : fDrawable(new DrawLitAtlasDrawable(SkRect::MakeWH(640, 480))) {
     }
@@ skipping 16 matching lines @@
                     this->inval(NULL);
                     return true;
                 case 'k': 
                     fDrawable->thrust();
                     this->inval(NULL); 
                     return true;
                 case 'l':
                     fDrawable->right();
                     this->inval(NULL); 
                     return true;
+                case 'o':
+                    fDrawable->rotateLight();
+                    this->inval(NULL); 
+                    return true;
                 default:
                     break;
             }
         }
         return this->INHERITED::onQuery(evt);
     }
 
     void onDrawContent(SkCanvas* canvas) override {
         canvas->drawDrawable(fDrawable);
         this->inval(NULL);
@@ skipping 11 matching lines @@
 private:
     SkAutoTUnref<DrawLitAtlasDrawable> fDrawable;
 
     typedef SampleView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* MyFactory() { return new DrawLitAtlasView; }
 static SkViewRegister reg(MyFactory);