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

src/core/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 "SkBitmapProcShader.h"
 #include "SkBitmapProcState.h"
 #include "SkColor.h"
@@ skipping 27 matching lines @@
 
 /** \class SkLightingShaderImpl
     This subclass of shader applies lighting.
 */
 class SkLightingShaderImpl : public SkShader {
 public:
 
     /** Create a new lighting shader that uses the provided normal map and
         lights to light the diffuse bitmap.
         @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 diffLocalM        the local matrix for the diffuse coordinates
-        @param normLocalM        the local matrix for the normal coordinates
-        @param normalSource      the normal source for GPU computations
+        @param normalSource      the source of normals for lighting computation
     */
-    SkLightingShaderImpl(const SkBitmap& diffuse, const SkBitmap& normal,
+    SkLightingShaderImpl(const SkBitmap& diffuse,
                          const sk_sp<SkLights> lights,
-                         const SkVector& invNormRotation,
-                         const SkMatrix* diffLocalM, const SkMatrix* normLocalM,
+                         const SkMatrix* diffLocalM,
                          sk_sp<SkNormalSource> normalSource)
         : INHERITED(diffLocalM)
         , fDiffuseMap(diffuse)
-        , fNormalMap(normal)
         , fLights(std::move(lights))
-        , fInvNormRotation(invNormRotation) {
-
-        if (normLocalM) {
-            fNormLocalMatrix = *normLocalM;
-        } else {
-            fNormLocalMatrix.reset();
-        }
-        // Pre-cache so future calls to fNormLocalMatrix.getType() are threadsafe.
-        (void)fNormLocalMatrix.getType();
-
-        fNormalSource = std::move(normalSource);
-    }
+        , fNormalSource(std::move(normalSource)) {}
 
     bool isOpaque() const override;
 
 #if SK_SUPPORT_GPU
     sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*,
                                                    const SkMatrix& viewM,
                                                    const SkMatrix* localMatrix,
                                                    SkFilterQuality,
                                                    SkSourceGammaTreatment) const override;
 #endif
@@ skipping 24 matching lines @@
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingShaderImpl)
 
 protected:
     void flatten(SkWriteBuffer&) const override;
     size_t onContextSize(const ContextRec&) const override;
     Context* onCreateContext(const ContextRec&, void*) const override;
 
 private:
     SkBitmap        fDiffuseMap;
-    SkBitmap        fNormalMap;
-
     sk_sp<SkLights> fLights;
 
-    SkMatrix        fNormLocalMatrix;
-    SkVector        fInvNormRotation;
-
     sk_sp<SkNormalSource> fNormalSource;
 
     friend class SkLightingShader;
 
     typedef SkShader INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
@@ skipping 183 matching lines @@
 
 sk_sp<GrFragmentProcessor> SkLightingShaderImpl::asFragmentProcessor(
                                                      GrContext* context,
                                                      const SkMatrix& viewM,
                                                      const SkMatrix* localMatrix,
                                                      SkFilterQuality filterQuality,
                                                      SkSourceGammaTreatment gammaTreatment) const {
     // we assume diffuse and normal maps have same width and height
     // TODO: support different sizes, will be addressed when diffuse maps are factored out of
     //       SkLightingShader in a future CL
-    SkASSERT(fDiffuseMap.width() == fNormalMap.width() &&
-             fDiffuseMap.height() == fNormalMap.height());
     SkMatrix diffM;
 
     if (!make_mat(fDiffuseMap, this->getLocalMatrix(), localMatrix, &diffM)) {
         return nullptr;
     }
 
     bool doBicubic;
     GrTextureParams::FilterMode diffFilterMode = GrSkFilterQualityToGrFilterMode(
                                                     SkTMin(filterQuality, kMedium_SkFilterQuality),
                                                     viewM,
@@ skipping 151 matching lines @@
 
 sk_sp<SkFlattenable> SkLightingShaderImpl::CreateProc(SkReadBuffer& buf) {
     SkMatrix diffLocalM;
     bool hasDiffLocalM = buf.readBool();
     if (hasDiffLocalM) {
         buf.readMatrix(&diffLocalM);
     } else {
         diffLocalM.reset();
     }
 
-    SkMatrix normLocalM;
-    bool hasNormLocalM = buf.readBool();
-    if (hasNormLocalM) {
-        buf.readMatrix(&normLocalM);
-    } else {
-        normLocalM.reset();
-    }
-
     SkBitmap diffuse;
     if (!buf.readBitmap(&diffuse)) {
         return nullptr;
     }
     diffuse.setImmutable();
 
-    SkBitmap normal;
-    if (!buf.readBitmap(&normal)) {
-        return nullptr;
-    }
-    normal.setImmutable();
-
     int numLights = buf.readInt();
 
     SkLights::Builder builder;
 
     for (int l = 0; l < numLights; ++l) {
         bool isAmbient = buf.readBool();
 
         SkColor3f color;
         if (!buf.readScalarArray(&color.fX, 3)) {
             return nullptr;
         }
 
         if (isAmbient) {
             builder.add(SkLights::Light(color));
         } else {
             SkVector3 dir;
             if (!buf.readScalarArray(&dir.fX, 3)) {
                 return nullptr;
             }
             builder.add(SkLights::Light(color, dir));
         }
     }
 
     sk_sp<SkLights> lights(builder.finish());
 
-    SkVector invNormRotation = {1,0};
-    if (!buf.isVersionLT(SkReadBuffer::kLightingShaderWritesInvNormRotation)) {
-        invNormRotation = buf.readPoint();
-    }
-
     sk_sp<SkNormalSource> normalSource(buf.readFlattenable<SkNormalSource>());
 
-    return sk_make_sp<SkLightingShaderImpl>(diffuse, normal, std::move(lights), invNormRotation,
-                                            &diffLocalM, &normLocalM, std::move(normalSource));
+    return sk_make_sp<SkLightingShaderImpl>(diffuse, std::move(lights), &diffLocalM,
+                                            std::move(normalSource));
 }
 
 void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const {
     this->INHERITED::flatten(buf);
 
-    bool hasNormLocalM = !fNormLocalMatrix.isIdentity();
-    buf.writeBool(hasNormLocalM);
-    if (hasNormLocalM) {
-        buf.writeMatrix(fNormLocalMatrix);
-    }
-
     buf.writeBitmap(fDiffuseMap);
-    buf.writeBitmap(fNormalMap);
 
     buf.writeInt(fLights->numLights());
     for (int l = 0; l < fLights->numLights(); ++l) {
         const SkLights::Light& light = fLights->light(l);
 
         bool isAmbient = SkLights::Light::kAmbient_LightType == light.type();
 
         buf.writeBool(isAmbient);
         buf.writeScalarArray(&light.color().fX, 3);
         if (!isAmbient) {
             buf.writeScalarArray(&light.dir().fX, 3);
         }
     }
-    buf.writePoint(fInvNormRotation);
 
     buf.writeFlattenable(fNormalSource.get());
 }
 
 size_t SkLightingShaderImpl::onContextSize(const ContextRec& rec) const {
     return sizeof(LightingShaderContext);
 }
 
 SkShader::Context* SkLightingShaderImpl::onCreateContext(const ContextRec& rec,
                                                          void* storage) const {
@@ skipping 24 matching lines @@
         sk_free(heapAllocated);
         return nullptr;
     }
 
     return new (storage) LightingShaderContext(*this, rec, diffuseState, normalProvider,
                                                heapAllocated);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-sk_sp<SkShader> SkLightingShader::Make(const SkBitmap& diffuse, const SkBitmap& normal,
+sk_sp<SkShader> SkLightingShader::Make(const SkBitmap& diffuse,
                                        sk_sp<SkLights> lights,
-                                       const SkVector& invNormRotation,
-                                       const SkMatrix* diffLocalM, const SkMatrix* normLocalM) {
-    if (diffuse.isNull() || SkBitmapProcShader::BitmapIsTooBig(diffuse) ||
-        normal.isNull()  || SkBitmapProcShader::BitmapIsTooBig(normal) ||
-        diffuse.width()  != normal.width() ||
-        diffuse.height() != normal.height()) {
+                                       const SkMatrix* diffLocalM,
+                                       sk_sp<SkNormalSource> normalSource) {
+    if (diffuse.isNull() || SkBitmapProcShader::BitmapIsTooBig(diffuse)) {
         return nullptr;
     }
-    SkASSERT(SkScalarNearlyEqual(invNormRotation.lengthSqd(), SK_Scalar1));
 
-    // TODO: support other tile modes
-    sk_sp<SkShader> mapShader = SkMakeBitmapShader(normal, SkShader::kClamp_TileMode,
-                                                   SkShader::kClamp_TileMode, normLocalM, nullptr);
+    if (!normalSource) {
+        // TODO: Use a default implementation of normalSource instead
+        return nullptr;
+    }
 
-    sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(mapShader,
-                                                                           invNormRotation);
-
-    return sk_make_sp<SkLightingShaderImpl>(diffuse, normal, std::move(lights),
-            invNormRotation, diffLocalM, normLocalM, std::move(normalSource));
+    return sk_make_sp<SkLightingShaderImpl>(diffuse, std::move(lights), diffLocalM,
+                                            std::move(normalSource));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////