Changed SkLightingShader API to take in a shader as color source

This CL's base is the CL for the same modification, but in the implementation side: https://codereview.chromium.org/2062703003/

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2064153002

Review-Url: https://codereview.chromium.org/2064153002

diff --git a/gm/lightingshader.cpp b/gm/lightingshader.cpp
index 3b1c224..2cf4a95 100644 (file)
--- a/gm/lightingshader.cpp
+++ b/gm/lightingshader.cpp
@@ -100,12 +100,14 @@ protected:
         const SkMatrix& ctm = canvas->getTotalMatrix();
 
         SkPaint paint;
+        sk_sp<SkShader> diffuseShader = SkMakeBitmapShader(fDiffuse,
+                SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix, nullptr);
         sk_sp<SkShader> normalMap = SkMakeBitmapShader(fNormalMaps[mapType],
                 SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix, nullptr);
         sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap),
                                                                                ctm);
-        paint.setShader(SkLightingShader::Make(fDiffuse, fLights, &matrix,
-                                               std::move(normalSource)));
+        paint.setShader(SkLightingShader::Make(std::move(diffuseShader), std::move(normalSource),
+                                               fLights));
 
         canvas->drawRect(r, paint);
     }

diff --git a/samplecode/SampleLighting.cpp b/samplecode/SampleLighting.cpp
index 5949f49..c191a6c 100755 (executable)
--- a/samplecode/SampleLighting.cpp
+++ b/samplecode/SampleLighting.cpp
@@ -70,8 +70,10 @@ protected:
             SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, nullptr, nullptr);
         sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(
                 std::move(normalMap), SkMatrix::I());
-        paint.setShader(SkLightingShader::Make(fDiffuseBitmap, std::move(lights), nullptr,
-                                               std::move(normalSource)));
+        sk_sp<SkShader> diffuseShader = SkBitmapProcShader::MakeBitmapShader(fDiffuseBitmap,
+                SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, nullptr);
+        paint.setShader(SkLightingShader::Make(std::move(diffuseShader), std::move(normalSource),
+                                               std::move(lights)));
         paint.setColor(SK_ColorBLACK);
 
         SkRect r = SkRect::MakeWH((SkScalar)fDiffuseBitmap.width(),

diff --git a/samplecode/SampleLitAtlas.cpp b/samplecode/SampleLitAtlas.cpp
index ba42ed8..f1882b7 100644 (file)
--- a/samplecode/SampleLitAtlas.cpp
+++ b/samplecode/SampleLitAtlas.cpp
@@ -134,8 +134,10 @@ protected:
                     SkShader::kClamp_TileMode, &normalMat, nullptr);
             sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(
                     std::move(normalMap), m);
-            paint.setShader(SkLightingShader::Make(fAtlas, fLights, &diffMat,
-                                                   std::move(normalSource)));
+            sk_sp<SkShader> diffuseShader = SkBitmapProcShader::MakeBitmapShader(fAtlas,
+                    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &diffMat);
+            paint.setShader(SkLightingShader::Make(std::move(diffuseShader),
+                    std::move(normalSource), fLights));
 
             canvas->save();
                 canvas->setMatrix(m);

diff --git a/src/core/SkLightingShader.cpp b/src/core/SkLightingShader.cpp
index 84ec64c..02f14b3 100644 (file)
--- a/src/core/SkLightingShader.cpp
+++ b/src/core/SkLightingShader.cpp
@@ -488,23 +488,15 @@ SkShader::Context* SkLightingShaderImpl::onCreateContext(const ContextRec& rec,
 
 ///////////////////////////////////////////////////////////////////////////////
 
-sk_sp<SkShader> SkLightingShader::Make(const SkBitmap& diffuse,
-                                       sk_sp<SkLights> lights,
-                                       const SkMatrix* diffLocalM,
-                                       sk_sp<SkNormalSource> normalSource) {
-    if (diffuse.isNull() || SkBitmapProcShader::BitmapIsTooBig(diffuse)) {
-        return nullptr;
-    }
-
-    if (!normalSource) {
+sk_sp<SkShader> SkLightingShader::Make(sk_sp<SkShader> diffuseShader,
+                                       sk_sp<SkNormalSource> normalSource,
+                                       sk_sp<SkLights> lights) {
+    if (!diffuseShader || !normalSource) {
+        // TODO: Use paint's color in absence of a diffuseShader
         // TODO: Use a default implementation of normalSource instead
         return nullptr;
     }
 
-    // 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));
 }

diff --git a/src/core/SkLightingShader.h b/src/core/SkLightingShader.h
index f103823..bb64261 100644 (file)
--- a/src/core/SkLightingShader.h
+++ b/src/core/SkLightingShader.h
@@ -17,29 +17,22 @@ class SkNormalSource;
 
 class SK_API SkLightingShader {
 public:
-    /** Returns a shader that lights the diffuse map using the normals and a set of lights.
+    /** Returns a shader that lights the shape, colored by the diffuseShader, using the
+        normals from normalSource, with the set of lights provided.
 
         It returns a shader with a reference count of 1.
         The caller should decrement the shader's reference count when done with the shader.
         It is an error for count to be < 2.
-        @param  diffuse     the diffuse bitmap
-        @param  lights       the lights applied to the normal map
-        @param  diffLocalMatrix the local matrix for the diffuse map (transform from
-                                texture coordinates to shape source coordinates). nullptr is
-                                interpreted as an identity matrix.
-        @param  normalSource the source for the normals
-
-        nullptr will be returned if:
-            'diffuse' is empty
-            'diffuse' is too big (> 65535 on any side)
+        @param  diffuseShader     the shader that provides the colors
+        @param  normalSource      the source for the shape's normals
+        @param  lights            the lights applied to the normals
 
         The lighting equation is currently:
             result = LightColor * DiffuseColor * (Normal * LightDir) + AmbientColor
 
     */
-    static sk_sp<SkShader> Make(const SkBitmap& diffuse, sk_sp<SkLights> lights,
-                                const SkMatrix* diffLocalMatrix,
-                                sk_sp<SkNormalSource> normalSource);
+    static sk_sp<SkShader> Make(sk_sp<SkShader> diffuseShader, sk_sp<SkNormalSource> normalSource,
+                                sk_sp<SkLights> lights);
 
     SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
 };

diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index 1e96eef..88f88fc 100644 (file)
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -585,8 +585,11 @@ DEF_TEST(Serialization, reporter) {
                                                        SkShader::kClamp_TileMode, &matrix, nullptr);
         sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap),
                                                                                ctm);
-        sk_sp<SkShader> lightingShader = SkLightingShader::Make(diffuse, fLights, &matrix,
-                                                                std::move(normalSource));
+        sk_sp<SkShader> diffuseShader = SkMakeBitmapShader(diffuse, SkShader::kClamp_TileMode,
+                SkShader::kClamp_TileMode, &matrix, nullptr);
+        sk_sp<SkShader> lightingShader = SkLightingShader::Make(std::move(diffuseShader),
+                                                                std::move(normalSource),
+                                                                fLights);
 
         SkAutoTUnref<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
         // TODO test equality?