Revert of Refactoring of CPU NormalMap handling out into its own class

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"
 #include "SkEmptyShader.h"
 #include "SkErrorInternals.h"
 #include "SkLightingShader.h"
 #include "SkMathPriv.h"
-#include "SkNormalSource.h"
 #include "SkPoint3.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 
 ////////////////////////////////////////////////////////////////////////////
 
 /*
    SkLightingShader TODOs:
         support other than clamp mode
         allow 'diffuse' & 'normal' to be of different dimensions?
@@ skipping 23 matching lines @@
         @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
     */
     SkLightingShaderImpl(const SkBitmap& diffuse, const SkBitmap& normal,
                          const sk_sp<SkLights> lights,
                          const SkVector& invNormRotation,
                          const SkMatrix* diffLocalM, const SkMatrix* normLocalM,
-                         sk_sp<SkNormalSource> normalSource)
+                         sk_sp<SkLightingShader::NormalSource> normalSource)
         : INHERITED(diffLocalM)
         , fDiffuseMap(diffuse)
         , fNormalMap(normal)
         , fLights(std::move(lights))
         , fInvNormRotation(invNormRotation) {
 
         if (normLocalM) {
             fNormLocalMatrix = *normLocalM;
         } else {
             fNormLocalMatrix.reset();
@@ skipping 12 matching lines @@
                                                    const SkMatrix* localMatrix,
                                                    SkFilterQuality,
                                                    SkSourceGammaTreatment) const override;
 #endif
 
     class LightingShaderContext : public SkShader::Context {
     public:
         // The context takes ownership of the states. It will call their destructors
         // but will NOT free the memory.
         LightingShaderContext(const SkLightingShaderImpl&, const ContextRec&,
-                              SkBitmapProcState* diffuseState, SkNormalSource::Provider*);
+                              SkBitmapProcState* diffuseState, SkBitmapProcState* normalState);
         ~LightingShaderContext() override;
 
         void shadeSpan(int x, int y, SkPMColor[], int count) override;
 
         uint32_t getFlags() const override { return fFlags; }
 
     private:
-        SkBitmapProcState*        fDiffuseState;
-        SkNormalSource::Provider* fNormalProvider;
-        uint32_t                  fFlags;
+        SkBitmapProcState* fDiffuseState;
+        SkBitmapProcState* fNormalState;
+        uint32_t           fFlags;
 
         typedef SkShader::Context INHERITED;
     };
 
     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;
+    bool computeNormTotalInverse(const ContextRec& rec, SkMatrix* normTotalInverse) const;
 
 private:
     SkBitmap        fDiffuseMap;
     SkBitmap        fNormalMap;
 
     sk_sp<SkLights> fLights;
 
     SkMatrix        fNormLocalMatrix;
     SkVector        fInvNormRotation;
 
-    sk_sp<SkNormalSource> fNormalSource;
+    sk_sp<SkLightingShader::NormalSource> fNormalSource;
 
     friend class SkLightingShader;
 
     typedef SkShader INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
@@ skipping 225 matching lines @@
 
 #endif
 
 ////////////////////////////////////////////////////////////////////////////
 
 bool SkLightingShaderImpl::isOpaque() const {
     return fDiffuseMap.isOpaque();
 }
 
 SkLightingShaderImpl::LightingShaderContext::LightingShaderContext(
-        const SkLightingShaderImpl& shader, const ContextRec& rec, SkBitmapProcState* diffuseState,
-        SkNormalSource::Provider* normalProvider)
+                                                                const SkLightingShaderImpl& shader,
+                                                                const ContextRec& rec,
+                                                                SkBitmapProcState* diffuseState,
+                                                                SkBitmapProcState* normalState)
     : INHERITED(shader, rec)
     , fDiffuseState(diffuseState)
-    , fNormalProvider(normalProvider) {
+    , fNormalState(normalState) {
     const SkPixmap& pixmap = fDiffuseState->fPixmap;
     bool isOpaque = pixmap.isOpaque();
 
     // update fFlags
     uint32_t flags = 0;
     if (isOpaque && (255 == this->getPaintAlpha())) {
         flags |= kOpaqueAlpha_Flag;
     }
 
     fFlags = flags;
 }
 
 SkLightingShaderImpl::LightingShaderContext::~LightingShaderContext() {
     // The bitmap proc states have been created outside of the context on memory that will be freed
     // elsewhere. Call the destructors but leave the freeing of the memory to the caller.
     fDiffuseState->~SkBitmapProcState();
-    fNormalProvider->~Provider();
+    fNormalState->~SkBitmapProcState();
 }
 
 static inline SkPMColor convert(SkColor3f color, U8CPU a) {
     if (color.fX <= 0.0f) {
         color.fX = 0.0f;
     } else if (color.fX >= 255.0f) {
         color.fX = 255.0f;
     }
 
     if (color.fY <= 0.0f) {
         color.fY = 0.0f;
     } else if (color.fY >= 255.0f) {
         color.fY = 255.0f;
     }
 
     if (color.fZ <= 0.0f) {
         color.fZ = 0.0f;
     } else if (color.fZ >= 255.0f) {
         color.fZ = 255.0f;
     }
 
     return SkPreMultiplyARGB(a, (int) color.fX,  (int) color.fY, (int) color.fZ);
 }
 
 // larger is better (fewer times we have to loop), but we shouldn't
 // take up too much stack-space (each one here costs 16 bytes)
-#define TMP_COUNT 16
-#define BUFFER_MAX ((int)(TMP_COUNT * sizeof(uint32_t)))
+#define TMP_COUNT     16
+
 void SkLightingShaderImpl::LightingShaderContext::shadeSpan(int x, int y,
                                                             SkPMColor result[], int count) {
     const SkLightingShaderImpl& lightShader = static_cast<const SkLightingShaderImpl&>(fShader);
 
-    uint32_t  tmpColor[TMP_COUNT];
-    SkPMColor tmpColor2[2*TMP_COUNT];
+    uint32_t  tmpColor[TMP_COUNT], tmpNormal[TMP_COUNT];
+    SkPMColor tmpColor2[2*TMP_COUNT], tmpNormal2[2*TMP_COUNT];
 
     SkBitmapProcState::MatrixProc   diffMProc = fDiffuseState->getMatrixProc();
     SkBitmapProcState::SampleProc32 diffSProc = fDiffuseState->getSampleProc32();
 
-    int max = fDiffuseState->maxCountForBufferSize(BUFFER_MAX);
+    SkBitmapProcState::MatrixProc   normalMProc = fNormalState->getMatrixProc();
+    SkBitmapProcState::SampleProc32 normalSProc = fNormalState->getSampleProc32();
+
+    int diffMax = fDiffuseState->maxCountForBufferSize(sizeof(tmpColor[0]) * TMP_COUNT);
+    int normMax = fNormalState->maxCountForBufferSize(sizeof(tmpNormal[0]) * TMP_COUNT);
+    int max = SkTMin(diffMax, normMax);
 
     SkASSERT(fDiffuseState->fPixmap.addr());
+    SkASSERT(fNormalState->fPixmap.addr());
 
-    SkASSERT(max <= BUFFER_MAX);
-    SkPoint3 normals[BUFFER_MAX];
+    SkPoint3 norm, xformedNorm;
 
     do {
         int n = count;
         if (n > max) {
             n = max;
         }
 
         diffMProc(*fDiffuseState, tmpColor, n, x, y);
         diffSProc(*fDiffuseState, tmpColor, n, tmpColor2);
 
-        fNormalProvider->fillScanLine(x, y, normals, n);
+        normalMProc(*fNormalState, tmpNormal, n, x, y);
+        normalSProc(*fNormalState, tmpNormal, n, tmpNormal2);
 
         for (int i = 0; i < n; ++i) {
+            SkASSERT(0xFF == SkColorGetA(tmpNormal2[i]));  // opaque -> unpremul
+            norm.set(SkIntToScalar(SkGetPackedR32(tmpNormal2[i]))-127.0f,
+                     SkIntToScalar(SkGetPackedG32(tmpNormal2[i]))-127.0f,
+                     SkIntToScalar(SkGetPackedB32(tmpNormal2[i]))-127.0f);
+            norm.normalize();
+
+            xformedNorm.fX = lightShader.fInvNormRotation.fX * norm.fX +
+                             lightShader.fInvNormRotation.fY * norm.fY;
+            xformedNorm.fY = -lightShader.fInvNormRotation.fY * norm.fX +
+                             lightShader.fInvNormRotation.fX * norm.fY;
+            xformedNorm.fZ = norm.fZ;
 
             SkColor diffColor = SkUnPreMultiply::PMColorToColor(tmpColor2[i]);
 
             SkColor3f accum = SkColor3f::Make(0.0f, 0.0f, 0.0f);
             // This is all done in linear unpremul color space (each component 0..255.0f though)
             for (int l = 0; l < lightShader.fLights->numLights(); ++l) {
                 const SkLights::Light& light = lightShader.fLights->light(l);
 
                 if (SkLights::Light::kAmbient_LightType == light.type()) {
                     accum += light.color().makeScale(255.0f);
                 } else {
-                    SkScalar NdotL = normals[i].dot(light.dir());
+                    SkScalar NdotL = xformedNorm.dot(light.dir());
                     if (NdotL < 0.0f) {
                         NdotL = 0.0f;
                     }
 
                     accum.fX += light.color().fX * SkColorGetR(diffColor) * NdotL;
                     accum.fY += light.color().fY * SkColorGetG(diffColor) * NdotL;
                     accum.fZ += light.color().fZ * SkColorGetB(diffColor) * NdotL;
                 }
             }
 
@@ skipping 66 matching lines @@
         }
     }
 
     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>());
+    sk_sp<SkLightingShader::NormalSource> normalSource(
+            buf.readFlattenable<SkLightingShader::NormalSource>());
 
     return sk_make_sp<SkLightingShaderImpl>(diffuse, normal, std::move(lights), invNormRotation,
                                             &diffLocalM, &normLocalM, std::move(normalSource));
 }
 
 void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const {
     this->INHERITED::flatten(buf);
 
     bool hasNormLocalM = !fNormLocalMatrix.isIdentity();
     buf.writeBool(hasNormLocalM);
@@ skipping 14 matching lines @@
         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) +
-           sizeof(SkBitmapProcState)     +
-           fNormalSource->providerSize(rec);
+bool SkLightingShaderImpl::computeNormTotalInverse(const ContextRec& rec,
+                                                   SkMatrix* normTotalInverse) const {
+    SkMatrix total;
+    total.setConcat(*rec.fMatrix, fNormLocalMatrix);
+
+    const SkMatrix* m = &total;
+    if (rec.fLocalMatrix) {
+        total.setConcat(*m, *rec.fLocalMatrix);
+        m = &total;
+    }
+    return m->invert(normTotalInverse);
+}
+
+size_t SkLightingShaderImpl::onContextSize(const ContextRec&) const {
+    return 2 * sizeof(SkBitmapProcState) + sizeof(LightingShaderContext);
 }
 
 SkShader::Context* SkLightingShaderImpl::onCreateContext(const ContextRec& rec,
                                                          void* storage) const {
 
     SkMatrix diffTotalInv;
     // computeTotalInverse was called in SkShader::createContext so we know it will succeed
     SkAssertResult(this->computeTotalInverse(rec, &diffTotalInv));
 
+    SkMatrix normTotalInv;
+    if (!this->computeNormTotalInverse(rec, &normTotalInv)) {
+        return nullptr;
+    }
+
     void* diffuseStateStorage = (char*)storage + sizeof(LightingShaderContext);
     SkBitmapProcState* diffuseState = new (diffuseStateStorage) SkBitmapProcState(fDiffuseMap,
                                               SkShader::kClamp_TileMode, SkShader::kClamp_TileMode,
                                                                     SkMipMap::DeduceTreatment(rec));
     SkASSERT(diffuseState);
     if (!diffuseState->setup(diffTotalInv, *rec.fPaint)) {
         diffuseState->~SkBitmapProcState();
         return nullptr;
     }
-    void* normalProviderStorage = (char*)storage +
-                                  sizeof(LightingShaderContext) +
-                                  sizeof(SkBitmapProcState);
-
-    SkNormalSource::Provider* normalProvider = fNormalSource->asProvider(rec,
-                                                                         normalProviderStorage);
-    if (!normalProvider) {
-        diffuseState->~SkBitmapProcState();
-        return nullptr;
-    }
 
-    return new (storage) LightingShaderContext(*this, rec, diffuseState, normalProvider);
+    void* normalStateStorage = (char*)storage +
+                                sizeof(LightingShaderContext) +
+                                sizeof(SkBitmapProcState);
+    SkBitmapProcState* normalState = new (normalStateStorage) SkBitmapProcState(fNormalMap,
+                                            SkShader::kClamp_TileMode, SkShader::kClamp_TileMode,
+                                                                    SkMipMap::DeduceTreatment(rec));
+    SkASSERT(normalState);
+    if (!normalState->setup(normTotalInv, *rec.fPaint)) {
+        diffuseState->~SkBitmapProcState();
+        normalState->~SkBitmapProcState();
+        return nullptr;
+    }
+
+    return new (storage) LightingShaderContext(*this, rec, diffuseState, normalState);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkShader> SkLightingShader::Make(const SkBitmap& diffuse, const SkBitmap& normal,
                                        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()) {
         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);
-
-    sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(mapShader,
-                                                                           invNormRotation);
+    sk_sp<SkLightingShader::NormalSource> normalSource =
+            SkLightingShader::NormalSource::MakeMap(normal, invNormRotation, normLocalM);
 
     return sk_make_sp<SkLightingShaderImpl>(diffuse, normal, std::move(lights),
             invNormRotation, diffLocalM, normLocalM, std::move(normalSource));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////