Made shadows blurry (thru implementing variance mapping)

src/core/SkShadowShader.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-
-#include "SkLights.h"
+#include "SkCanvas.h"
+//#include "SkLights.h"
 #include "SkReadBuffer.h"
 #include "SkShadowShader.h"
-#include "SkPoint3.h"
 
 ////////////////////////////////////////////////////////////////////////////
 #ifdef SK_EXPERIMENTAL_SHADOWING
 
 
 /** \class SkShadowShaderImpl
     This subclass of shader applies shadowing
 */
 class SkShadowShaderImpl : public SkShader {
 public:
     /** Create a new shadowing shader that shadows
         @param to do        to do
     */
     SkShadowShaderImpl(sk_sp<SkShader> povDepthShader,
                        sk_sp<SkShader> diffuseShader,
                        sk_sp<SkLights> lights,
-                       int diffuseWidth, int diffuseHeight)
+                       int diffuseWidth, int diffuseHeight,
+                       const SkShadowParams& params)
             : fPovDepthShader(std::move(povDepthShader))
             , fDiffuseShader(std::move(diffuseShader))
             , fLights(std::move(lights))
             , fDiffuseWidth(diffuseWidth)
-            , fDiffuseHeight(diffuseHeight) { }
+            , fDiffuseHeight(diffuseHeight)
+            , fShadowParams(params) { }
 
     bool isOpaque() const override;
 
 #if SK_SUPPORT_GPU
     sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
 #endif
 
     class ShadowShaderContext : public SkShader::Context {
     public:
         // The context takes ownership of the states. It will call their destructors
@@ skipping 28 matching lines @@
     Context* onCreateContext(const ContextRec&, void*) const override;
 
 private:
     sk_sp<SkShader> fPovDepthShader;
     sk_sp<SkShader> fDiffuseShader;
     sk_sp<SkLights> fLights;
 
     int fDiffuseWidth;
     int fDiffuseHeight;
 
+    SkShadowParams fShadowParams;
+
     friend class SkShadowShader;
 
     typedef SkShader INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrCoordTransform.h"
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "SkGr.h"
 #include "SkGrPriv.h"
 #include "SkSpecialImage.h"
 #include "SkImage_Base.h"
 #include "GrContext.h"
 
 class ShadowFP : public GrFragmentProcessor {
 public:
     ShadowFP(sk_sp<GrFragmentProcessor> povDepth,
              sk_sp<GrFragmentProcessor> diffuse,
              sk_sp<SkLights> lights,
              int diffuseWidth, int diffuseHeight,
+             const SkShadowParams& params,
              GrContext* context) {
 
         // fuse all ambient lights into a single one
         fAmbientColor.set(0.0f, 0.0f, 0.0f);
 
         fNumDirLights = 0; // refers to directional lights.
         for (int i = 0; i < lights->numLights(); ++i) {
             if (SkLights::Light::kAmbient_LightType == lights->light(i).type()) {
                 fAmbientColor += lights->light(i).color();
             } else if (fNumDirLights < SkShadowShader::kMaxNonAmbientLights) {
@@ skipping 11 matching lines @@
                 fDepthMapHeight[fNumDirLights] = shadowMap->height();
                 fDepthMapWidth[fNumDirLights] = shadowMap->width();
 
                 fNumDirLights++;
             }
         }
 
         fWidth = diffuseWidth;
         fHeight = diffuseHeight;
 
-        this->registerChildProcessor(std::move(povDepth)); 
+        fShadowParams = params;
+
+        this->registerChildProcessor(std::move(povDepth));
         this->registerChildProcessor(std::move(diffuse));
         this->initClassID<ShadowFP>();
     }
 
     class GLSLShadowFP : public GrGLSLFragmentProcessor {
     public:
         GLSLShadowFP() { }
 
         void emitCode(EmitArgs& args) override {
 
             GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
             GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
             // add uniforms
             int32_t numLights = args.fFp.cast<ShadowFP>().fNumDirLights;
             SkASSERT(numLights <= SkShadowShader::kMaxNonAmbientLights);
 
+            int blurAlgorithm = args.fFp.cast<ShadowFP>().fShadowParams.fType;
+
             const char* lightDirUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
             const char* lightColorUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
 
             const char* depthMapWidthUniName[SkShadowShader::kMaxNonAmbientLights]
                     = {nullptr};
             const char* depthMapHeightUniName[SkShadowShader::kMaxNonAmbientLights]
                     = {nullptr};
 
             SkString lightDirUniNameBase("lightDir");
             SkString lightColorUniNameBase("lightColor");
@@ skipping 28 matching lines @@
                                                    kDefault_GrSLPrecision,
                                                    depthMapWidthUniNameStr.c_str(),
                                                    &depthMapWidthUniName[i]);
                 fDepthMapHeightUni[i] = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                    kInt_GrSLType,
                                                    kDefault_GrSLPrecision,
                                                    depthMapHeightUniNameStr.c_str(),
                                                    &depthMapHeightUniName[i]);
             }
 
+            const char* shBiasUniName = nullptr;
+            const char* minVarianceUniName = nullptr;
+
+            fBiasingConstantUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                             kFloat_GrSLType,
+                                                             kDefault_GrSLPrecision,
+                                                             "shadowBias", &shBiasUniName);
+            fMinVarianceUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                         kFloat_GrSLType,
+                                                         kDefault_GrSLPrecision,
+                                                         "minVariance", &minVarianceUniName);
 
             const char* widthUniName = nullptr;
             const char* heightUniName = nullptr;
 
             fWidthUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                    kInt_GrSLType,
                                                    kDefault_GrSLPrecision,
                                                    "width", &widthUniName);
             fHeightUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                     kInt_GrSLType,
@@ skipping 31 matching lines @@
                                          offset.c_str(), lightDirUniName[i]);
 
                 fragBuilder->codeAppendf("vec2 %s = (vec2(%s, %s) / vec2(%s, %s));\n",
                                          scaleVec.c_str(),
                                          widthUniName, heightUniName,
                                          depthMapWidthUniName[i], depthMapHeightUniName[i]);
 
                 fragBuilder->codeAppendf("vec2 %s = 1 - %s;\n",
                                          scaleOffsetVec.c_str(), scaleVec.c_str());
 
-
                 fragBuilder->codeAppendf("vec2 %s = (vMatrixCoord_0_1_Stage0 + "
-                                                    "vec2(%s.x, 0 - %s.y)) "
-                                                   " * %s + vec2(0,1) * %s;\n",
-
+                                                 "vec2(%s.x, 0 - %s.y)) "
+                                                 " * %s + vec2(0,1) * %s;\n",
                                          povCoord.c_str(), offset.c_str(), offset.c_str(),
                                          scaleVec.c_str(), scaleOffsetVec.c_str());
 
                 fragBuilder->appendTextureLookup(&depthMaps[i], args.fTexSamplers[i],
                                                  povCoord.c_str(),
                                                  kVec2f_GrSLType);
+
+
             }
 
             const char* ambientColorUniName = nullptr;
             fAmbientColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                           kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                           "AmbientColor", &ambientColorUniName);
 
             fragBuilder->codeAppendf("vec4 resultDiffuseColor = %s;", diffuseColor.c_str());
 
-            // Essentially,
-            // diffColor * (ambientLightTot + foreachDirLight(lightColor * (N . L)))
+            // all the normal vectors point straight up
             SkString totalLightColor("totalLightColor");
-            fragBuilder->codeAppendf("vec3 %s = vec3(0);", totalLightColor.c_str());
+            fragBuilder->codeAppendf("vec3 %s = vec3(0,0,0);", totalLightColor.c_str());
+
+            fragBuilder->codeAppendf("float lightProbability;");
+            fragBuilder->codeAppendf("float variance;");
+            fragBuilder->codeAppendf("float d;");
 
             for (int i = 0; i < numLights; i++) {
-                fragBuilder->codeAppendf("if (%s.b >= %s.b) {",
+                fragBuilder->codeAppendf("lightProbability = 1;");
+
+                // 1/512 is less than half a pixel; imperceptible
+                fragBuilder->codeAppendf("if (%s.b <= %s.b + 1/512) {",
                                          povDepth.c_str(), depthMaps[i].c_str());
-                // Note that dot(vec3(0,0,1), %s) == %s.z * %s
-                fragBuilder->codeAppendf("%s += %s.z * %s;",
+                if (blurAlgorithm == SkShadowParams::kVariance_BlurAlgorithm) {
+                    fragBuilder->codeAppendf("vec2 moments = vec2(%s.b * 255,  %s.g * 255 * 256 );",
+                                             depthMaps[i].c_str(), depthMaps[i].c_str());
+
+                    // variance biasing lessens light bleeding
+                    fragBuilder->codeAppendf("variance = max(moments.y - (moments.x * moments.x),"
+                                                     "%s);", minVarianceUniName);
+
+                    fragBuilder->codeAppendf("d = (%s.b * 255) - moments.x;", povDepth.c_str());
+                    fragBuilder->codeAppendf("lightProbability = "
+                                             "(variance / (variance + d * d));");
+
+                    SkString clamp("clamp");
+                    clamp.appendf("%d", i);
+
+                    // choosing between light artifacts or correct shape shadows
+                    // linstep
+                    fragBuilder->codeAppendf("float %s = clamp((lightProbability - %s) /"
+                                                              "(1 - %s), 0, 1);",
+                                             clamp.c_str(), shBiasUniName, shBiasUniName);
+
+                    fragBuilder->codeAppendf("lightProbability = %s;", clamp.c_str());
+                } else {
+                    fragBuilder->codeAppendf("if (%s.b >= %s.b) {",
+                                             povDepth.c_str(), depthMaps[i].c_str());
+                    fragBuilder->codeAppendf("lightProbability = 1;");
+                    fragBuilder->codeAppendf("} else { lightProbability = 0; }");
+                }
+
+                // VSM: The curved shadows near plane edges are mostly light bleeding.
+                fragBuilder->codeAppendf("}");
+
+                fragBuilder->codeAppendf("%s += dot(vec3(0,0,1), %s) * %s * lightProbability;",
                                          totalLightColor.c_str(),
                                          lightDirUniName[i],
                                          lightColorUniName[i]);
-                fragBuilder->codeAppendf("}");
             }
 
-            fragBuilder->codeAppendf("%s += %s;",
-                                     totalLightColor.c_str(),
-                                     ambientColorUniName);
+            fragBuilder->codeAppendf("%s += %s;", totalLightColor.c_str(), ambientColorUniName);
 
             fragBuilder->codeAppendf("resultDiffuseColor *= vec4(%s, 1);",
                                      totalLightColor.c_str());
 
             fragBuilder->codeAppendf("%s = resultDiffuseColor;", args.fOutputColor);
         }
 
         static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             const ShadowFP& shadowFP = proc.cast<ShadowFP>();
             b->add32(shadowFP.fNumDirLights);
+            b->add32(shadowFP.fShadowParams.fType);
         }
 
     protected:
         void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
             const ShadowFP &shadowFP = proc.cast<ShadowFP>();
 
-            fNumDirLights = shadowFP.numLights();
-
-            for (int i = 0; i < fNumDirLights; i++) {
+            for (int i = 0; i < shadowFP.fNumDirLights; i++) {
                 const SkVector3& lightDir = shadowFP.lightDir(i);
                 if (lightDir != fLightDir[i]) {
                     pdman.set3fv(fLightDirUni[i], 1, &lightDir.fX);
                     fLightDir[i] = lightDir;
                 }
                 const SkColor3f& lightColor = shadowFP.lightColor(i);
                 if (lightColor != fLightColor[i]) {
                     pdman.set3fv(fLightColorUni[i], 1, &lightColor.fX);
                     fLightColor[i] = lightColor;
                 }
 
                 int depthMapWidth = shadowFP.depthMapWidth(i);
                 if (depthMapWidth != fDepthMapWidth[i]) {
                     pdman.set1i(fDepthMapWidthUni[i], depthMapWidth);
                     fDepthMapWidth[i] = depthMapWidth;
                 }
                 int depthMapHeight = shadowFP.depthMapHeight(i);
                 if (depthMapHeight != fDepthMapHeight[i]) {
                     pdman.set1i(fDepthMapHeightUni[i], depthMapHeight);
                     fDepthMapHeight[i] = depthMapHeight;
                 }
             }
 
+            SkScalar biasingConstant = shadowFP.shadowParams().fBiasingConstant;
+            if (biasingConstant != fBiasingConstant) {
+                pdman.set1f(fBiasingConstantUni, biasingConstant);
+                fBiasingConstant = biasingConstant;
+            }
+
+            SkScalar minVariance = shadowFP.shadowParams().fMinVariance;
+            if (minVariance != fMinVariance) {
+                pdman.set1f(fMinVarianceUni, minVariance);
+                fMinVariance = minVariance;
+            }
+
             int width = shadowFP.width();
             if (width != fWidth) {
                 pdman.set1i(fWidthUni, width);
                 fWidth = width;
             }
             int height = shadowFP.height();
             if (height != fHeight) {
                 pdman.set1i(fHeightUni, height);
                 fHeight = height;
             }
@@ skipping 20 matching lines @@
 
         int fDepthMapHeight[SkShadowShader::kMaxNonAmbientLights];
         GrGLSLProgramDataManager::UniformHandle
                 fDepthMapHeightUni[SkShadowShader::kMaxNonAmbientLights];
 
         int fWidth;
         GrGLSLProgramDataManager::UniformHandle fWidthUni;
         int fHeight;
         GrGLSLProgramDataManager::UniformHandle fHeightUni;
 
+        SkScalar fBiasingConstant;
+        GrGLSLProgramDataManager::UniformHandle fBiasingConstantUni;
+        SkScalar fMinVariance;
+        GrGLSLProgramDataManager::UniformHandle fMinVarianceUni;
+
         SkColor3f fAmbientColor;
         GrGLSLProgramDataManager::UniformHandle fAmbientColorUni;
-
-        int fNumDirLights;
     };
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
         GLSLShadowFP::GenKey(*this, caps, b);
     }
 
     const char* name() const override { return "shadowFP"; }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         inout->mulByUnknownFourComponents();
@@ skipping 13 matching lines @@
         SkASSERT(i < fNumDirLights);
         return fDepthMapWidth[i];
     }
     int depthMapHeight(int i) const {
         SkASSERT(i < fNumDirLights);
         return fDepthMapHeight[i];
     }
     int width() const {return fWidth; }
     int height() const {return fHeight; }
 
+    const SkShadowParams& shadowParams() const {return fShadowParams; }
+
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new GLSLShadowFP; }
 
     bool onIsEqual(const GrFragmentProcessor& proc) const override {
         const ShadowFP& shadowFP = proc.cast<ShadowFP>();
         if (fAmbientColor != shadowFP.fAmbientColor || fNumDirLights != shadowFP.fNumDirLights) {
             return false;
         }
 
         if (fWidth != shadowFP.fWidth || fHeight != shadowFP.fHeight) {
@@ skipping 21 matching lines @@
     SkColor3f        fLightColor[SkShadowShader::kMaxNonAmbientLights];
     GrTextureAccess  fDepthMapAccess[SkShadowShader::kMaxNonAmbientLights];
     sk_sp<GrTexture> fTexture[SkShadowShader::kMaxNonAmbientLights];
 
     int              fDepthMapWidth[SkShadowShader::kMaxNonAmbientLights];
     int              fDepthMapHeight[SkShadowShader::kMaxNonAmbientLights];
 
     int              fHeight;
     int              fWidth;
 
+    SkShadowParams     fShadowParams;
+
     SkColor3f        fAmbientColor;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 sk_sp<GrFragmentProcessor> SkShadowShaderImpl::asFragmentProcessor(const AsFPArgs& fpargs) const {
 
     sk_sp<GrFragmentProcessor> povDepthFP = fPovDepthShader->asFragmentProcessor(fpargs);
 
     sk_sp<GrFragmentProcessor> diffuseFP = fDiffuseShader->asFragmentProcessor(fpargs);
 
     sk_sp<GrFragmentProcessor> shadowfp = sk_make_sp<ShadowFP>(std::move(povDepthFP),
                                                                std::move(diffuseFP),
                                                                std::move(fLights),
                                                                fDiffuseWidth, fDiffuseHeight,
-                                                               fpargs.fContext);
+                                                               fShadowParams, fpargs.fContext);
     return shadowfp;
 }
 
 
 #endif
 
 ////////////////////////////////////////////////////////////////////////////
 
 bool SkShadowShaderImpl::isOpaque() const {
     return fDiffuseShader->isOpaque();
@@ skipping 104 matching lines @@
 #endif
 
 sk_sp<SkFlattenable> SkShadowShaderImpl::CreateProc(SkReadBuffer& buf) {
 
     // Discarding SkShader flattenable params
     bool hasLocalMatrix = buf.readBool();
     SkAssertResult(!hasLocalMatrix);
 
     sk_sp<SkLights> lights = SkLights::MakeFromBuffer(buf);
 
+    SkShadowParams params;
+    params.fMinVariance = buf.readScalar();
+    params.fBiasingConstant = buf.readScalar();
+    params.fType = (SkShadowParams::ShadowType) buf.readInt();
+    params.fShadowRadius = buf.readScalar();
+
     int diffuseWidth = buf.readInt();
     int diffuseHeight = buf.readInt();
 
     sk_sp<SkShader> povDepthShader(buf.readFlattenable<SkShader>());
     sk_sp<SkShader> diffuseShader(buf.readFlattenable<SkShader>());
 
     return sk_make_sp<SkShadowShaderImpl>(std::move(povDepthShader),
                                           std::move(diffuseShader),
                                           std::move(lights),
-                                          diffuseWidth, diffuseHeight);
+                                          diffuseWidth, diffuseHeight,
+                                          params);
 }
 
 void SkShadowShaderImpl::flatten(SkWriteBuffer& buf) const {
     this->INHERITED::flatten(buf);
 
     fLights->flatten(buf);
 
+    buf.writeScalar(fShadowParams.fMinVariance);
+    buf.writeScalar(fShadowParams.fBiasingConstant);
+    buf.writeInt(fShadowParams.fType);
+    buf.writeScalar(fShadowParams.fShadowRadius);
+
     buf.writeInt(fDiffuseWidth);
     buf.writeInt(fDiffuseHeight);
 
     buf.writeFlattenable(fPovDepthShader.get());
     buf.writeFlattenable(fDiffuseShader.get());
 }
 
 size_t SkShadowShaderImpl::onContextSize(const ContextRec& rec) const {
     return sizeof(ShadowShaderContext);
 }
@@ skipping 25 matching lines @@
 
     return new (storage) ShadowShaderContext(*this, rec, povDepthContext, diffuseContext,
                                              heapAllocated);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkShader> SkShadowShader::Make(sk_sp<SkShader> povDepthShader,
                                      sk_sp<SkShader> diffuseShader,
                                      sk_sp<SkLights> lights,
-                                     int diffuseWidth, int diffuseHeight) {
+                                     int diffuseWidth, int diffuseHeight,
+                                     const SkShadowParams& params) {
     if (!povDepthShader || !diffuseShader) {
         // TODO: Use paint's color in absence of a diffuseShader
         // TODO: Use a default implementation of normalSource instead
         return nullptr;
     }
 
     return sk_make_sp<SkShadowShaderImpl>(std::move(povDepthShader),
                                           std::move(diffuseShader),
                                           std::move(lights),
-                                          diffuseWidth, diffuseHeight);
+                                          diffuseWidth, diffuseHeight,
+                                          params);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShadowShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkShadowShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #endif