Address some SkLightingShader TODOs

src/effects/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 "SkBitmapProcState.h"
 #include "SkColor.h"
 #include "SkEmptyShader.h"
 #include "SkErrorInternals.h"
 #include "SkLightingShader.h"
 #include "SkMathPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 
 ////////////////////////////////////////////////////////////////////////////
 
 /*
    SkLightingShader TODOs:
         support other than clamp mode
         allow 'diffuse' & 'normal' to be of different dimensions?
         support different light types
         support multiple lights
         enforce normal map is 4 channel
         use SkImages instead if SkBitmaps
-        vec3 for ambient and light-color
-        add dox for both lighting equation, and how we compute normal from bitmap
 
     To Test:
         non-opaque diffuse textures
         A8 diffuse textures
         down & upsampled draws
 */
 
 
 
 /** \class SkLightingShaderImpl
     This subclass of shader applies lighting.
 */
 class SK_API SkLightingShaderImpl : public SkShader {
 public:
 
     /** Create a new lighting shader that use the provided normal map, light
         and ambient color to light the diffuse bitmap.
         @param diffuse the diffuse bitmap
         @param normal  the normal map
         @param light   the light applied to the normal map
         @param ambient the linear (unpremul) ambient light color
     */
     SkLightingShaderImpl(const SkBitmap& diffuse, const SkBitmap& normal,
                          const SkLightingShader::Light& light,
-                         const SkColor ambient, const SkMatrix* localMatrix) 
+                         const SkColor3f& ambient, const SkMatrix* localMatrix) 
         : INHERITED(localMatrix)
         , fDiffuseMap(diffuse)
         , fNormalMap(normal)
         , fLight(light)
         , fAmbientColor(ambient) {
         if (!fLight.fDirection.normalize()) {
             fLight.fDirection = SkPoint3::Make(0.0f, 0.0f, 1.0f);
         }
-        SkColorSetA(fLight.fColor, 0xFF);
-        SkColorSetA(fAmbientColor, 0xFF);
     }
 
     bool isOpaque() const override;
 
     bool asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix& viewM,
                              const SkMatrix* localMatrix, GrColor* color,
                              GrProcessorDataManager*, GrFragmentProcessor** fp) const override;
 
     size_t contextSize() const override;
 
@@ skipping 21 matching lines @@
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingShaderImpl)
 
 protected:
     void flatten(SkWriteBuffer&) const override;
     Context* onCreateContext(const ContextRec&, void*) const override;
 
 private:
     SkBitmap                fDiffuseMap;
     SkBitmap                fNormalMap;
     SkLightingShader::Light fLight;
-    SkColor                 fAmbientColor;  // linear (unpremul) color
+    SkColor3f               fAmbientColor;  // linear (unpremul) color. Range is 0..1/channel.
 
     friend class SkLightingShader;
 
     typedef SkShader INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrCoordTransform.h"
 #include "GrFragmentProcessor.h"
 #include "GrTextureAccess.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 #include "SkGr.h"
 
 class LightingFP : public GrFragmentProcessor {
 public:
     LightingFP(GrTexture* diffuse, GrTexture* normal, const SkMatrix& matrix,
-               SkVector3 lightDir, GrColor lightColor, GrColor ambientColor)
+               const SkVector3& lightDir, const SkColor3f& lightColor,
+               const SkColor3f& ambientColor)
         : fDeviceTransform(kDevice_GrCoordSet, matrix)
         , fDiffuseTextureAccess(diffuse)
         , fNormalTextureAccess(normal)
         , fLightDir(lightDir)
         , fLightColor(lightColor)
         , fAmbientColor(ambientColor) {
         this->addCoordTransform(&fDeviceTransform);
         this->addTextureAccess(&fDiffuseTextureAccess);
         this->addTextureAccess(&fNormalTextureAccess);
 
         this->initClassID<LightingFP>();
     }
 
     class LightingGLFP : public GrGLFragmentProcessor {
     public:
-        LightingGLFP() : fLightColor(GrColor_ILLEGAL), fAmbientColor(GrColor_ILLEGAL) {
+        LightingGLFP() {
             fLightDir.fX = 10000.0f;
+            fLightColor.fX = 0.0f;
+            fAmbientColor.fX = 0.0f;
         }
 
         void emitCode(EmitArgs& args) override {
 
             GrGLFragmentBuilder* fpb = args.fBuilder->getFragmentShaderBuilder();
 
             // add uniforms
             const char* lightDirUniName = NULL;
             fLightDirUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                      kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                      "LightDir", &lightDirUniName);
 
             const char* lightColorUniName = NULL;
             fLightColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                       kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                                       kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                        "LightColor", &lightColorUniName);
 
             const char* ambientColorUniName = NULL;
             fAmbientColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                         kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                                         kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                          "AmbientColor", &ambientColorUniName);
 
             fpb->codeAppend("vec4 diffuseColor = ");
             fpb->appendTextureLookupAndModulate(args.fInputColor, args.fSamplers[0], 
                                                 args.fCoords[0].c_str(), 
                                                 args.fCoords[0].getType());
             fpb->codeAppend(";");
 
             fpb->codeAppend("vec4 normalColor = ");
             fpb->appendTextureLookup(args.fSamplers[1],
                                      args.fCoords[0].c_str(), 
                                      args.fCoords[0].getType());
             fpb->codeAppend(";");
 
             fpb->codeAppend("vec3 normal = normalize(normalColor.rgb - vec3(0.5));");
             fpb->codeAppendf("vec3 lightDir = normalize(%s);", lightDirUniName);
             fpb->codeAppend("float NdotL = dot(normal, lightDir);");
             // diffuse light
-            fpb->codeAppendf("vec3 result = %s.rgb*diffuseColor.rgb*NdotL;", lightColorUniName);
+            fpb->codeAppendf("vec3 result = %s*diffuseColor.rgb*NdotL;", lightColorUniName);
             // ambient light
-            fpb->codeAppendf("result += %s.rgb;", ambientColorUniName);
+            fpb->codeAppendf("result += %s;", ambientColorUniName);
             fpb->codeAppendf("%s = vec4(result.rgb, diffuseColor.a);", args.fOutputColor);
         }
 
         void setData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) override {
             const LightingFP& lightingFP = proc.cast<LightingFP>();
 
-            SkVector3 lightDir = lightingFP.lightDir();
+            const SkVector3& lightDir = lightingFP.lightDir();
             if (lightDir != fLightDir) {
                 pdman.set3fv(fLightDirUni, 1, &lightDir.fX);
                 fLightDir = lightDir;
             }
 
-            GrColor lightColor = lightingFP.lightColor();
+            const SkColor3f& lightColor = lightingFP.lightColor();
             if (lightColor != fLightColor) {
-                GrGLfloat c[4];
-                GrColorToRGBAFloat(lightColor, c);
-                pdman.set4fv(fLightColorUni, 1, c);
+                pdman.set3fv(fLightColorUni, 1, &lightColor.fX);
                 fLightColor = lightColor;
             }
 
-            GrColor ambientColor = lightingFP.ambientColor();
+            const SkColor3f& ambientColor = lightingFP.ambientColor();
             if (ambientColor != fAmbientColor) {
-                GrGLfloat c[4];
-                GrColorToRGBAFloat(ambientColor, c);
-                pdman.set4fv(fAmbientColorUni, 1, c);
+                pdman.set3fv(fAmbientColorUni, 1, &ambientColor.fX);
                 fAmbientColor = ambientColor;
             }
         }
 
         static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
 //            const LightingFP& lightingFP = proc.cast<LightingFP>();
             // only one shader generated currently
             b->add32(0x0);
         }
 
     private:
         SkVector3 fLightDir;
         GrGLProgramDataManager::UniformHandle fLightDirUni;
 
-        GrColor fLightColor;
+        SkColor3f fLightColor;
         GrGLProgramDataManager::UniformHandle fLightColorUni;
 
-        GrColor fAmbientColor;
+        SkColor3f fAmbientColor;
         GrGLProgramDataManager::UniformHandle fAmbientColorUni;
     };
 
     GrGLFragmentProcessor* createGLInstance() const override { return SkNEW(LightingGLFP); }
 
     void getGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
         LightingGLFP::GenKey(*this, caps, b);
     }
 
     const char* name() const override { return "LightingFP"; }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         inout->mulByUnknownFourComponents();
     }
 
-    SkVector3 lightDir() const { return fLightDir; }
-    GrColor lightColor() const { return fLightColor; }
-    GrColor ambientColor() const { return fAmbientColor; }
+    const SkVector3& lightDir() const { return fLightDir; }
+    const SkColor3f& lightColor() const { return fLightColor; }
+    const SkColor3f& ambientColor() const { return fAmbientColor; }
 
 private:
     bool onIsEqual(const GrFragmentProcessor& proc) const override { 
         const LightingFP& lightingFP = proc.cast<LightingFP>();
         return fDeviceTransform == lightingFP.fDeviceTransform &&
                fDiffuseTextureAccess == lightingFP.fDiffuseTextureAccess &&
                fNormalTextureAccess == lightingFP.fNormalTextureAccess &&
                fLightDir == lightingFP.fLightDir &&
                fLightColor == lightingFP.fLightColor &&
                fAmbientColor == lightingFP.fAmbientColor;
     }
 
     GrCoordTransform fDeviceTransform;
     GrTextureAccess  fDiffuseTextureAccess;
     GrTextureAccess  fNormalTextureAccess;
     SkVector3        fLightDir;
-    GrColor          fLightColor;
-    GrColor          fAmbientColor;
+    SkColor3f        fLightColor;
+    SkColor3f        fAmbientColor;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 bool SkLightingShaderImpl::asFragmentProcessor(GrContext* context, const SkPaint& paint, 
                                                const SkMatrix& viewM, const SkMatrix* localMatrix, 
                                                GrColor* color, GrProcessorDataManager*,
                                                GrFragmentProcessor** fp) const {
     // we assume diffuse and normal maps have same width and height
     // TODO: support different sizes
@@ skipping 58 matching lines @@
         return false;
     }
 
     SkAutoTUnref<GrTexture> normalTexture(GrRefCachedBitmapTexture(context, fNormalMap, &params));
     if (!normalTexture) {
         SkErrorInternals::SetError(kInternalError_SkError,
             "Couldn't convert bitmap to texture.");
         return false;
     }
 
-    GrColor lightColor = GrColorPackRGBA(SkColorGetR(fLight.fColor), SkColorGetG(fLight.fColor),
-                                         SkColorGetB(fLight.fColor), SkColorGetA(fLight.fColor));
-    GrColor ambientColor = GrColorPackRGBA(SkColorGetR(fAmbientColor), SkColorGetG(fAmbientColor),
-                                           SkColorGetB(fAmbientColor), SkColorGetA(fAmbientColor));
-
     *fp = SkNEW_ARGS(LightingFP, (diffuseTexture, normalTexture, matrix,
-                                  fLight.fDirection, lightColor, ambientColor));
+                                  fLight.fDirection, fLight.fColor, fAmbientColor));
     *color = GrColorPackA4(paint.getAlpha());
     return true;
 }
 #else
 
 bool SkLightingShaderImpl::asFragmentProcessor(GrContext* context, const SkPaint& paint, 
                                                const SkMatrix& viewM, const SkMatrix* localMatrix, 
                                                GrColor* color, GrProcessorDataManager*,
                                                GrFragmentProcessor** fp) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
@@ skipping 32 matching lines @@
     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();
     fNormalState->~SkBitmapProcState();
 }
 
-static inline int light(int light, int diff, SkScalar NdotL, int ambient) {
-    int color = int(light * diff * NdotL + 255 * ambient);
-    if (color <= 0) {
+static inline int light(SkScalar light, int diff, SkScalar NdotL, SkScalar ambient) {
+    SkScalar color = light * diff * NdotL + 255 * ambient;
+    if (color <= 0.0f) {
         return 0;
-    } else if (color >= 255*255) {
+    } else if (color >= 255.0f) {
         return 255;
     } else {
-        return SkDiv255Round(color);
+        return (int) color;
     }
 }
 
 // larger is better (fewer times we have to loop), but we shouldn't
 // take up too much stack-space (each could here costs 16 bytes)
 #define TMP_COUNT     16
 
 void SkLightingShaderImpl::LightingShaderContext::shadeSpan(int x, int y,
                                                             SkPMColor result[], int count) {
     const SkLightingShaderImpl& lightShader = static_cast<const SkLightingShaderImpl&>(fShader);
@@ skipping 30 matching lines @@
             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();
 
             SkColor diffColor = SkUnPreMultiply::PMColorToColor(tmpColor2[i]);
             NdotL = norm.dot(lightShader.fLight.fDirection);
 
             // This is all done in linear unpremul color space
-            r = light(SkColorGetR(lightShader.fLight.fColor), SkColorGetR(diffColor), NdotL, 
-                      SkColorGetR(lightShader.fAmbientColor));
-            g = light(SkColorGetG(lightShader.fLight.fColor), SkColorGetG(diffColor), NdotL, 
-                      SkColorGetG(lightShader.fAmbientColor));
-            b = light(SkColorGetB(lightShader.fLight.fColor), SkColorGetB(diffColor), NdotL, 
-                      SkColorGetB(lightShader.fAmbientColor));
+            r = light(lightShader.fLight.fColor.fX, SkColorGetR(diffColor), NdotL, 
+                      lightShader.fAmbientColor.fX);
+            g = light(lightShader.fLight.fColor.fY, SkColorGetG(diffColor), NdotL, 
+                      lightShader.fAmbientColor.fY);
+            b = light(lightShader.fLight.fColor.fZ, SkColorGetB(diffColor), NdotL, 
+                      lightShader.fAmbientColor.fZ);
 
             result[i] = SkPreMultiplyARGB(SkColorGetA(diffColor), r, g, b);
         }
 
         result += n;
         x += n;
         count -= n;
     } while (count > 0);
 }
 
@@ skipping 18 matching lines @@
     SkBitmap normal;
     if (!buf.readBitmap(&normal)) {
         return NULL;
     }
     normal.setImmutable();
 
     SkLightingShader::Light light;
     if (!buf.readScalarArray(&light.fDirection.fX, 3)) {
         return NULL;
     }
-    light.fColor = buf.readColor();
+    if (!buf.readScalarArray(&light.fColor.fX, 3)) {
+        return NULL;
+    }
 
-    SkColor ambient = buf.readColor();
+    SkColor3f ambient;
+    if (!buf.readScalarArray(&ambient.fX, 3)) {
+        return NULL;
+    }
 
     return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, light, ambient, &localMatrix));
 }
 
 void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const {
     buf.writeMatrix(this->getLocalMatrix());
 
     buf.writeBitmap(fDiffuseMap);
     buf.writeBitmap(fNormalMap);
     buf.writeScalarArray(&fLight.fDirection.fX, 3);
-    buf.writeColor(fLight.fColor);
-    buf.writeColor(fAmbientColor);
+    buf.writeScalarArray(&fLight.fColor.fX, 3);
+    buf.writeScalarArray(&fAmbientColor.fX, 3);
 }
 
 SkShader::Context* SkLightingShaderImpl::onCreateContext(const ContextRec& rec,
                                                          void* storage) const {
 
     SkMatrix totalInverse;
     // Do this first, so we know the matrix can be inverted.
     if (!this->computeTotalInverse(rec, &totalInverse)) {
         return NULL;
     }
@@ skipping 34 matching lines @@
     // communicates between its matrix-proc and its sampler-proc. Until we can
     // widen that, we have to reject bitmaps that are larger.
     //
     static const int kMaxSize = 65535;
 
     return bm.width() > kMaxSize || bm.height() > kMaxSize;
 }
 
 SkShader* SkLightingShader::Create(const SkBitmap& diffuse, const SkBitmap& normal,
                                    const SkLightingShader::Light& light,
-                                   const SkColor ambient,
+                                   const SkColor3f& ambient,
                                    const SkMatrix* localMatrix) {
     if (diffuse.isNull() || bitmap_is_too_big(diffuse) ||
         normal.isNull() || bitmap_is_too_big(normal) ||
         diffuse.width() != normal.width() ||
         diffuse.height() != normal.height()) {
         return nullptr;
     }
 
     return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, light, ambient, localMatrix));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////