Image filters: force near-zero floating point parameters to zero.

src/effects/SkLightingImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLightingImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 81 matching lines @@
     SkScalar fKD;
 };
 
 static SkScalar max_component(const SkPoint3& p) {
     return p.x() > p.y() ? (p.x() > p.z() ? p.x() : p.z()) : (p.y() > p.z() ? p.y() : p.z());
 }
 
 class SpecularLightingType {
 public:
     SpecularLightingType(SkScalar ks, SkScalar shininess)
-        : fKS(ks), fShininess(shininess) {}
+        : fKS(SkScalarNormalize(ks)), fShininess(SkScalarNormalize(shininess)) {}
     SkPMColor light(const SkPoint3& normal, const SkPoint3& surfaceTolight,
                     const SkPoint3& lightColor) const {
         SkPoint3 halfDir(surfaceTolight);
         halfDir.fZ += SK_Scalar1;        // eye position is always (0, 0, 1)
         fast_normalize(&halfDir);
         SkScalar colorScale = SkScalarMul(fKS,
             SkScalarPow(normal.dot(halfDir), fShininess));
         colorScale = SkScalarClampMax(colorScale, SK_Scalar1);
         SkPoint3 color = lightColor.makeScale(colorScale);
         return SkPackARGB32(SkClampMax(SkScalarRoundToInt(max_component(color)), 255),
@@ skipping 196 matching lines @@
         lightBitmap<LightingType, LightType, UncheckedPixelFetcher>(
             lightingType, light, src, dst, surfaceScale, bounds);
     } else {
         lightBitmap<LightingType, LightType, DecalPixelFetcher>(
             lightingType, light, src, dst, surfaceScale, bounds);
     }
 }
 
 SkPoint3 readPoint3(SkReadBuffer& buffer) {
     SkPoint3 point;
-    point.fX = buffer.readScalar();
-    point.fY = buffer.readScalar();
-    point.fZ = buffer.readScalar();
+    point.fX = SkScalarNormalize(buffer.readScalar());
+    point.fY = SkScalarNormalize(buffer.readScalar());
+    point.fZ = SkScalarNormalize(buffer.readScalar());
     buffer.validate(SkScalarIsFinite(point.fX) &&
                     SkScalarIsFinite(point.fY) &&
                     SkScalarIsFinite(point.fZ));
     return point;
 };
 
 void writePoint3(const SkPoint3& point, SkWriteBuffer& buffer) {
     buffer.writeScalar(point.fX);
     buffer.writeScalar(point.fY);
     buffer.writeScalar(point.fZ);
@@ skipping 436 matching lines @@
     void flattenLight(SkWriteBuffer& buffer) const;
     static SkImageFilterLight* UnflattenLight(SkReadBuffer& buffer);
 
 protected:
     SkImageFilterLight(SkColor color) {
         fColor = SkPoint3::Make(SkIntToScalar(SkColorGetR(color)),
                                 SkIntToScalar(SkColorGetG(color)),
                                 SkIntToScalar(SkColorGetB(color)));
     }
     SkImageFilterLight(const SkPoint3& color)
-      : fColor(color) {}
+      : fColor(color.makeDenormalsZero()) {}
     SkImageFilterLight(SkReadBuffer& buffer) {
         fColor = readPoint3(buffer);
     }
 
     virtual void onFlattenLight(SkWriteBuffer& buffer) const = 0;
 
 
 private:
     typedef SkRefCnt INHERITED;
     SkPoint3 fColor;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkDistantLight : public SkImageFilterLight {
 public:
     SkDistantLight(const SkPoint3& direction, SkColor color)
-      : INHERITED(color), fDirection(direction) {
+      : INHERITED(color), fDirection(direction.makeDenormalsZero()) {
     }
 
     SkPoint3 surfaceToLight(int x, int y, int z, SkScalar surfaceScale) const {
         return fDirection;
     };
     const SkPoint3& lightColor(const SkPoint3&) const { return this->color(); }
     LightType type() const override { return kDistant_LightType; }
     const SkPoint3& direction() const { return fDirection; }
     GrGLLight* createGLLight() const override {
 #if SK_SUPPORT_GPU
@@ skipping 182 matching lines @@
     const SkPoint3& target() const { return fTarget; }
     SkScalar specularExponent() const { return fSpecularExponent; }
     SkScalar cosInnerConeAngle() const { return fCosInnerConeAngle; }
     SkScalar cosOuterConeAngle() const { return fCosOuterConeAngle; }
     SkScalar coneScale() const { return fConeScale; }
     const SkPoint3& s() const { return fS; }
 
     SkSpotLight(SkReadBuffer& buffer) : INHERITED(buffer) {
         fLocation = readPoint3(buffer);
         fTarget = readPoint3(buffer);
-        fSpecularExponent = buffer.readScalar();
-        fCosOuterConeAngle = buffer.readScalar();
-        fCosInnerConeAngle = buffer.readScalar();
-        fConeScale = buffer.readScalar();
+        fSpecularExponent = SkScalarNormalize(buffer.readScalar());
+        fCosOuterConeAngle = SkScalarNormalize(buffer.readScalar());
+        fCosInnerConeAngle = SkScalarNormalize(buffer.readScalar());
+        fConeScale = SkScalarNormalize(buffer.readScalar());
         fS = readPoint3(buffer);
         buffer.validate(SkScalarIsFinite(fSpecularExponent) &&
                         SkScalarIsFinite(fCosOuterConeAngle) &&
                         SkScalarIsFinite(fCosInnerConeAngle) &&
                         SkScalarIsFinite(fConeScale));
     }
 protected:
     SkSpotLight(const SkPoint3& location,
                 const SkPoint3& target,
                 SkScalar specularExponent,
                 SkScalar cosOuterConeAngle,
                 SkScalar cosInnerConeAngle,
                 SkScalar coneScale,
                 const SkPoint3& s,
                 const SkPoint3& color)
      : INHERITED(color),
-       fLocation(location),
-       fTarget(target),
-       fSpecularExponent(specularExponent),
-       fCosOuterConeAngle(cosOuterConeAngle),
-       fCosInnerConeAngle(cosInnerConeAngle),
-       fConeScale(coneScale),
-       fS(s)
+       fLocation(location.makeDenormalsZero()),
+       fTarget(target.makeDenormalsZero()),
+       fSpecularExponent(SkScalarNormalize(specularExponent)),
+       fCosOuterConeAngle(SkScalarNormalize(cosOuterConeAngle)),
+       fCosInnerConeAngle(SkScalarNormalize(cosInnerConeAngle)),
+       fConeScale(SkScalarNormalize(coneScale)),
+       fS(s.makeDenormalsZero())
     {
     }
     void onFlattenLight(SkWriteBuffer& buffer) const override {
         writePoint3(fLocation, buffer);
         writePoint3(fTarget, buffer);
         buffer.writeScalar(fSpecularExponent);
         buffer.writeScalar(fCosOuterConeAngle);
         buffer.writeScalar(fCosInnerConeAngle);
         buffer.writeScalar(fConeScale);
         writePoint3(fS, buffer);
@@ skipping 59 matching lines @@
             return nullptr;
     }
 }
 ///////////////////////////////////////////////////////////////////////////////
 
 SkLightingImageFilter::SkLightingImageFilter(sk_sp<SkImageFilterLight> light,
                                              SkScalar surfaceScale,
                                              sk_sp<SkImageFilter> input, const CropRect* cropRect)
     : INHERITED(&input, 1, cropRect)
     , fLight(std::move(light))
-    , fSurfaceScale(surfaceScale / 255) {
+    , fSurfaceScale(SkScalarNormalize(surfaceScale / 255)) {
 }
 
 SkLightingImageFilter::~SkLightingImageFilter() {}
 
 sk_sp<SkImageFilter> SkLightingImageFilter::MakeDistantLitDiffuse(const SkPoint3& direction,
                                                                   SkColor lightColor,
                                                                   SkScalar surfaceScale,
                                                                   SkScalar kd,
                                                                   sk_sp<SkImageFilter> input,
                                                                   const CropRect* cropRect) {
@@ skipping 95 matching lines @@
     return sk_sp<SkImageFilter>(new SkDiffuseLightingImageFilter(std::move(light), surfaceScale, 
                                                                  kd, std::move(input), cropRect));
 }
 
 SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(sk_sp<SkImageFilterLight> light,
                                                            SkScalar surfaceScale,
                                                            SkScalar kd,
                                                            sk_sp<SkImageFilter> input,
                                                            const CropRect* cropRect)
     : INHERITED(std::move(light), surfaceScale, std::move(input), cropRect)
-    , fKD(kd) {
+    , fKD(SkScalarNormalize(kd)) {
 }
 
 sk_sp<SkFlattenable> SkDiffuseLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     sk_sp<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
     SkScalar surfaceScale = buffer.readScalar();
     SkScalar kd = buffer.readScalar();
     return Make(std::move(light), surfaceScale, kd, common.getInput(0), &common.cropRect());
 }
 
@@ skipping 140 matching lines @@
                                                                   std::move(input), cropRect));
 }
 
 SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(sk_sp<SkImageFilterLight> light,
                                                              SkScalar surfaceScale,
                                                              SkScalar ks,
                                                              SkScalar shininess,
                                                              sk_sp<SkImageFilter> input,
                                                              const CropRect* cropRect)
     : INHERITED(std::move(light), surfaceScale, std::move(input), cropRect)
-    , fKS(ks)
-    , fShininess(shininess) {
+    , fKS(SkScalarNormalize(ks))
+    , fShininess(SkScalarNormalize(shininess)) {
 }
 
 sk_sp<SkFlattenable> SkSpecularLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     sk_sp<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
     SkScalar surfaceScale = buffer.readScalar();
     SkScalar ks = buffer.readScalar();
     SkScalar shine = buffer.readScalar();
     return Make(std::move(light), surfaceScale, ks, shine, common.getInput(0),
                 &common.cropRect());
@@ skipping 302 matching lines @@
 };
 
 GrLightingEffect::GrLightingEffect(GrTexture* texture,
                                    const SkImageFilterLight* light,
                                    SkScalar surfaceScale,
                                    const SkMatrix& matrix,
                                    BoundaryMode boundaryMode,
                                    const SkIRect* srcBounds)
     : INHERITED(texture, nullptr, GrCoordTransform::MakeDivByTextureWHMatrix(texture))
     , fLight(light)
-    , fSurfaceScale(surfaceScale)
+    , fSurfaceScale(SkScalarNormalize(surfaceScale))
     , fFilterMatrix(matrix)
     , fBoundaryMode(boundaryMode)
     , fDomain(create_domain(texture, srcBounds, GrTextureDomain::kDecal_Mode)) {
     fLight->ref();
     if (light->requiresFragmentPosition()) {
         this->setWillReadFragmentPosition();
     }
 }
 
 GrLightingEffect::~GrLightingEffect() {
@@ skipping 453 matching lines @@
 
     fragBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight);
 }
 
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END