Abstracted diffuse color map out of SkLightingShaderImpl into a generic SkShader

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 22 matching lines @@
         down & upsampled draws
 */
 
 
 
 /** \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 lights            the lights applied to the normal map
-        @param diffLocalM        the local matrix for the diffuse coordinates
+        @param diffuseShader     the shader that provides the diffuse colors
         @param normalSource      the source of normals for lighting computation
+        @param lights            the lights applied to the geometry
     */
-    SkLightingShaderImpl(const SkBitmap& diffuse,
-                         const sk_sp<SkLights> lights,
-                         const SkMatrix* diffLocalM,
-                         sk_sp<SkLightingShader::NormalSource> normalSource)
-        : INHERITED(diffLocalM)
-        , fDiffuseMap(diffuse)
-        , fLights(std::move(lights)) {
-
-        fNormalSource = std::move(normalSource);
-    }
+    SkLightingShaderImpl(sk_sp<SkShader> diffuseShader,
+                         sk_sp<SkLightingShader::NormalSource> normalSource,
+                         const sk_sp<SkLights> lights)
+        : fDiffuseShader(std::move(diffuseShader))
+        , fNormalSource(std::move(normalSource))
+        , fLights(std::move(lights)) {}
 
     bool isOpaque() const override;
 
 #if SK_SUPPORT_GPU
     sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*,
                                                    const SkMatrix& viewM,
                                                    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,
-                              SkLightingShader::NormalSource::Provider*);
+                              SkShader::Context* diffuseContext,
+                              SkLightingShader::NormalSource::Provider*, void* heapAllocated);
         ~LightingShaderContext() override;
 
         void shadeSpan(int x, int y, SkPMColor[], int count) override;
 
         uint32_t getFlags() const override { return fFlags; }
 
     private:
-        SkBitmapProcState*                        fDiffuseState;
+        SkShader::Context*                        fDiffuseContext;
         SkLightingShader::NormalSource::Provider* fNormalProvider;
         uint32_t                                  fFlags;
 
+        void* fHeapAllocated;
+
         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;
 
 private:
-    SkBitmap        fDiffuseMap;
+    sk_sp<SkShader> fDiffuseShader;
+    sk_sp<SkLightingShader::NormalSource> fNormalSource;
     sk_sp<SkLights> fLights;
 
-    sk_sp<SkLightingShader::NormalSource> fNormalSource;
-
     friend class SkLightingShader;
 
     typedef SkShader INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrCoordTransform.h"
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "GrTextureAccess.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #include "SkGr.h"
 #include "SkGrPriv.h"
 
 class LightingFP : public GrFragmentProcessor {
 public:
-    LightingFP(GrTexture* diffuse, const SkMatrix& diffMatrix, const GrTextureParams& diffParams,
-               sk_sp<SkLights> lights, sk_sp<GrFragmentProcessor> normalFP)
-        : fDiffDeviceTransform(kLocal_GrCoordSet, diffMatrix, diffuse, diffParams.filterMode())
-        , fDiffuseTextureAccess(diffuse, diffParams) {
-        this->addCoordTransform(&fDiffDeviceTransform);
-        this->addTextureAccess(&fDiffuseTextureAccess);
+    LightingFP(sk_sp<GrFragmentProcessor> diffuseFP, sk_sp<GrFragmentProcessor> normalFP,
+               sk_sp<SkLights> lights) {
 
         // fuse all ambient lights into a single one
         fAmbientColor.set(0.0f, 0.0f, 0.0f);
         for (int i = 0; i < lights->numLights(); ++i) {
             if (SkLights::Light::kAmbient_LightType == lights->light(i).type()) {
                 fAmbientColor += lights->light(i).color();
             } else {
                 // TODO: handle more than one of these
                 fLightColor = lights->light(i).color();
                 fLightDir = lights->light(i).dir();
             }
         }
 
+        this->registerChildProcessor(std::move(diffuseFP));
         this->registerChildProcessor(std::move(normalFP));
         this->initClassID<LightingFP>();
     }
 
     class GLSLLightingFP : public GrGLSLFragmentProcessor {
     public:
         GLSLLightingFP() {
             fLightDir.fX = 10000.0f;
             fLightColor.fX = 0.0f;
             fAmbientColor.fX = 0.0f;
@@ skipping 13 matching lines @@
             const char* lightColorUniName = nullptr;
             fLightColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                         kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                         "LightColor", &lightColorUniName);
 
             const char* ambientColorUniName = nullptr;
             fAmbientColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                           kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                           "AmbientColor", &ambientColorUniName);
 
-            fragBuilder->codeAppend("vec4 diffuseColor = ");
-            fragBuilder->appendTextureLookupAndModulate(args.fInputColor, args.fTexSamplers[0],
-                                                args.fCoords[0].c_str(),
-                                                args.fCoords[0].getType());
-            fragBuilder->codeAppend(";");
+            SkString dstDiffuseName("dstDiffuse");
+            this->emitChild(0, args.fInputColor, &dstDiffuseName, args);
+            fragBuilder->codeAppendf("vec4 diffuseColor = %s;", dstDiffuseName.c_str());
 
             SkString dstNormalName("dstNormal");
-            this->emitChild(0, nullptr, &dstNormalName, args);
+            this->emitChild(1, nullptr, &dstNormalName, args);
 
             fragBuilder->codeAppendf("vec3 normal = %s.xyz;", dstNormalName.c_str());
             fragBuilder->codeAppendf("float NdotL = clamp(dot(normal, %s), 0.0, 1.0);",
                                      lightDirUniName);
             // diffuse light
             fragBuilder->codeAppendf("vec3 result = %s*diffuseColor.rgb*NdotL;", lightColorUniName);
             // ambient light
             fragBuilder->codeAppendf("result += %s;", ambientColorUniName);
             fragBuilder->codeAppendf("%s = vec4(result.rgb, diffuseColor.a);", args.fOutputColor);
         }
@@ skipping 51 matching lines @@
 
     const SkVector3& lightDir() const { return fLightDir; }
     const SkColor3f& lightColor() const { return fLightColor; }
     const SkColor3f& ambientColor() const { return fAmbientColor; }
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new GLSLLightingFP; }
 
     bool onIsEqual(const GrFragmentProcessor& proc) const override {
         const LightingFP& lightingFP = proc.cast<LightingFP>();
-        return fDiffDeviceTransform == lightingFP.fDiffDeviceTransform &&
-               fDiffuseTextureAccess == lightingFP.fDiffuseTextureAccess &&
-               fLightDir == lightingFP.fLightDir &&
+        return fLightDir == lightingFP.fLightDir &&
                fLightColor == lightingFP.fLightColor &&
                fAmbientColor == lightingFP.fAmbientColor;
     }
 
-    GrCoordTransform fDiffDeviceTransform;
-    GrTextureAccess  fDiffuseTextureAccess;
     SkVector3        fLightDir;
     SkColor3f        fLightColor;
     SkColor3f        fAmbientColor;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
-static bool make_mat(const SkBitmap& bm,
-                     const SkMatrix& localMatrix1,
-                     const SkMatrix* localMatrix2,
-                     SkMatrix* result) {
-
-    result->setIDiv(bm.width(), bm.height());
-
-    SkMatrix lmInverse;
-    if (!localMatrix1.invert(&lmInverse)) {
-        return false;
-    }
-    if (localMatrix2) {
-        SkMatrix inv;
-        if (!localMatrix2->invert(&inv)) {
-            return false;
-        }
-        lmInverse.postConcat(inv);
-    }
-    result->preConcat(lmInverse);
-
-    return true;
-}
-
 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
-    SkMatrix diffM;
-
-    if (!make_mat(fDiffuseMap, this->getLocalMatrix(), localMatrix, &diffM)) {
-        return nullptr;
-    }
-
-    bool doBicubic;
-    GrTextureParams::FilterMode diffFilterMode = GrSkFilterQualityToGrFilterMode(
-                                                    SkTMin(filterQuality, kMedium_SkFilterQuality),
-                                                    viewM,
-                                                    this->getLocalMatrix(),
-                                                    &doBicubic);
-    SkASSERT(!doBicubic);
-
-    // TODO: support other tile modes
-    GrTextureParams diffParams(kClamp_TileMode, diffFilterMode);
-    SkAutoTUnref<GrTexture> diffuseTexture(GrRefCachedBitmapTexture(context, fDiffuseMap,
-                                                                    diffParams, gammaTreatment));
-    if (!diffuseTexture) {
-        SkErrorInternals::SetError(kInternalError_SkError, "Couldn't convert bitmap to texture.");
-        return nullptr;
-    }
-
+    sk_sp<GrFragmentProcessor> diffuseFP(
+            fDiffuseShader->asFragmentProcessor(context, viewM, localMatrix, filterQuality,
+                                               gammaTreatment));
     sk_sp<GrFragmentProcessor> normalFP(
             fNormalSource->asFragmentProcessor(context, viewM, localMatrix, filterQuality,
                                                gammaTreatment));
     sk_sp<GrFragmentProcessor> inner (
-            new LightingFP(diffuseTexture, diffM, diffParams, fLights, std::move(normalFP)));
+            new LightingFP(std::move(diffuseFP), std::move(normalFP), fLights));
 
     return GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner));
 }
 
 #endif
 
 ////////////////////////////////////////////////////////////////////////////
 
 bool SkLightingShaderImpl::isOpaque() const {
-    return fDiffuseMap.isOpaque();
+    return fDiffuseShader->isOpaque();
 }
 
 SkLightingShaderImpl::LightingShaderContext::LightingShaderContext(
-        const SkLightingShaderImpl& shader, const ContextRec& rec, SkBitmapProcState* diffuseState,
-        SkLightingShader::NormalSource::Provider* normalProvider)
+        const SkLightingShaderImpl& shader, const ContextRec& rec,
+        SkShader::Context* diffuseContext, SkLightingShader::NormalSource::Provider* normalProvider,
+        void* heapAllocated)
     : INHERITED(shader, rec)
-    , fDiffuseState(diffuseState)
-    , fNormalProvider(normalProvider) {
-    const SkPixmap& pixmap = fDiffuseState->fPixmap;
-    bool isOpaque = pixmap.isOpaque();
+    , fDiffuseContext(diffuseContext)
+    , fNormalProvider(normalProvider)
+    , fHeapAllocated(heapAllocated) {
+    bool isOpaque = shader.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();
+    // The dependencies have been created outside of the context on memory that was allocated by
+    // the onCreateContext() method. Call the destructors and free the memory.
+    fDiffuseContext->~Context();
     fNormalProvider->~Provider();
+
+    free(fHeapAllocated);
 }
 
 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 BUFFER_MAX 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];
-
-    SkBitmapProcState::MatrixProc   diffMProc = fDiffuseState->getMatrixProc();
-    SkBitmapProcState::SampleProc32 diffSProc = fDiffuseState->getSampleProc32();
-
-    int max = fDiffuseState->maxCountForBufferSize(BUFFER_MAX);
-
-    SkASSERT(fDiffuseState->fPixmap.addr());
-
-    SkASSERT(max <= BUFFER_MAX);
+    SkPMColor diffuse[BUFFER_MAX];
     SkPoint3 normals[BUFFER_MAX];
 
     do {
-        int n = count;
-        if (n > max) {
-            n = max;
-        }
+        int n = SkTMin(count, BUFFER_MAX);
 
-        diffMProc(*fDiffuseState, tmpColor, n, x, y);
-        diffSProc(*fDiffuseState, tmpColor, n, tmpColor2);
-
+        fDiffuseContext->shadeSpan(x, y, diffuse, n);
         fNormalProvider->fillScanLine(x, y, normals, n);
 
         for (int i = 0; i < n; ++i) {
 
-            SkColor diffColor = SkUnPreMultiply::PMColorToColor(tmpColor2[i]);
+            SkColor diffColor = SkUnPreMultiply::PMColorToColor(diffuse[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());
@@ skipping 18 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////
 
 #ifndef SK_IGNORE_TO_STRING
 void SkLightingShaderImpl::toString(SkString* str) const {
     str->appendf("LightingShader: ()");
 }
 #endif
 
 sk_sp<SkFlattenable> SkLightingShaderImpl::CreateProc(SkReadBuffer& buf) {
-    SkMatrix diffLocalM;
-    bool hasDiffLocalM = buf.readBool();
-    if (hasDiffLocalM) {
-        buf.readMatrix(&diffLocalM);
-    } else {
-        diffLocalM.reset();
-    }
 
-    SkBitmap diffuse;
-    if (!buf.readBitmap(&diffuse)) {
-        return nullptr;
-    }
-    diffuse.setImmutable();
+    // Discarding SkShader flattenable params
+    bool hasLocalMatrix = buf.readBool();
+    SkASSERT(!hasLocalMatrix);
 
     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());
 
     sk_sp<SkLightingShader::NormalSource> normalSource(
             buf.readFlattenable<SkLightingShader::NormalSource>());
+    sk_sp<SkShader> diffuseShader(buf.readFlattenable<SkShader>());
 
-    return sk_make_sp<SkLightingShaderImpl>(diffuse, std::move(lights), &diffLocalM,
-                                            std::move(normalSource));
+    return sk_make_sp<SkLightingShaderImpl>(std::move(diffuseShader), std::move(normalSource),
+                                            std::move(lights));
 }
 
 void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const {
     this->INHERITED::flatten(buf);
 
-    buf.writeBitmap(fDiffuseMap);
-
     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.writeFlattenable(fNormalSource.get());
+    buf.writeFlattenable(fDiffuseShader.get());
 }
 
 size_t SkLightingShaderImpl::onContextSize(const ContextRec& rec) const {
-    return sizeof(LightingShaderContext) +
-           sizeof(SkBitmapProcState)     +
-           fNormalSource->providerSize(rec);
+    return 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));
+    size_t heapRequired = fDiffuseShader->contextSize(rec) + fNormalSource->providerSize(rec);
+    void* heapAllocated = malloc(heapRequired); // Freed on ~LightingShaderContext()

[dvonbeck, 2016/06/17 16:05:51]

malloc and free. Should I be using some SkMalloc or something?

 
-    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);
+    void* diffuseContextStorage = (char*)heapAllocated;
 
+    SkShader::Context* diffuseContext = fDiffuseShader->createContext(rec, diffuseContextStorage);
+
+    void* normalProviderStorage = (char*)heapAllocated + fDiffuseShader->contextSize(rec);
     SkLightingShader::NormalSource::Provider* normalProvider =
             fNormalSource->asProvider(rec, normalProviderStorage);
     if (!normalProvider) {
-        diffuseState->~SkBitmapProcState();
+        diffuseContext->~Context();
+        free(heapAllocated);
         return nullptr;
     }
 
-    return new (storage) LightingShaderContext(*this, rec, diffuseState, normalProvider);
+    return new (storage) LightingShaderContext(*this, rec, diffuseContext, normalProvider,
+                                               heapAllocated);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkShader> SkLightingShader::Make(const SkBitmap& diffuse, sk_sp<SkLights> lights,
             const SkMatrix* diffLocalM, sk_sp<NormalSource> normalSource) {
     if (diffuse.isNull() || SkBitmapProcShader::BitmapIsTooBig(diffuse)) {
         return nullptr;
     }
 
     if (!normalSource) {
         // TODO: Use a default implementation of normalSource instead
         return nullptr;
     }
 
-    return sk_make_sp<SkLightingShaderImpl>(diffuse, std::move(lights), diffLocalM,
-                                            std::move(normalSource));
+    // TODO: support other tile modes
+    sk_sp<SkShader> diffuseShader = SkBitmapProcShader::MakeBitmapShader(diffuse,
+            SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, diffLocalM);
+
+    return sk_make_sp<SkLightingShaderImpl>(std::move(diffuseShader), std::move(normalSource),
+                                            std::move(lights));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////