Added math for SkNormalBevelSource to create bevels on GPU side

src/core/SkNormalBevelSource.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 "SkNormalBevelSource.h"
 
 #include "SkNormalSource.h"
 #include "SkNormalSourcePriv.h"
 #include "SkPoint3.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 
 #if SK_SUPPORT_GPU
 #include "GrInvariantOutput.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "SkGr.h"
 
+/** \class NormalBevelFP
+ *
+ *  Fragment processor for the SkNormalBevelSource.
+ *

[robertphillips, 2016/08/03 16:33:15]

What do you think about renaming these bevelWidth, fBevelWidth, ...

?

[dvonbeck, 2016/08/03 21:04:20]

Done. Should I do this in the user-facing API too?

+ *  @param type    type of the bevel
+ *  @param width   width of the bevel in device space
+ *  @param height  height of the bevel in device space
+ */
 class NormalBevelFP : public GrFragmentProcessor {
 public:
     NormalBevelFP(SkNormalSource::BevelType type, SkScalar width, SkScalar height)
         : fType(type)
         , fWidth(width)
         , fHeight(height) {
         this->initClassID<NormalBevelFP>();
 
         fUsesDistanceVectorField = true;
     }
 
     class GLSLNormalBevelFP : public GLSLNormalFP {
     public:
         GLSLNormalBevelFP() {
             fPrevWidth = SkFloatToScalar(0.0f);
             fPrevHeight = SkFloatToScalar(0.0f);
         }
 
         void onEmitCode(EmitArgs& args) override {
             GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
+            const NormalBevelFP& fp = args.fFp.cast<NormalBevelFP>();
             GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
             const char* widthUniName = nullptr;
             fWidthUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kFloat_GrSLType,
                     kDefault_GrSLPrecision, "Width", &widthUniName);
 
             const char* heightUniName = nullptr;
             fHeightUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kFloat_GrSLType,
                     kDefault_GrSLPrecision, "Height", &heightUniName);
 

[robertphillips, 2016/08/03 16:33:14]

Do you think the shader compilers are going to be smart enough to coalesce all
the length(distanceVector) calls?

[dvonbeck, 2016/08/03 16:39:24]

I assume so but I don't know. Do you think I should change it?

[dvonbeck, 2016/08/03 21:04:19]

No longer necessary.

-            fragBuilder->codeAppendf("%s = vec4(0.0, 0.0, 1.0, 0.0);", args.fOutputColor);
+            fragBuilder->codeAppend( "vec3 normal;");
+            fragBuilder->codeAppendf("if (length(%s) >= %s) {",
+                                     fragBuilder->distanceVectorName(), widthUniName);
+            fragBuilder->codeAppend( "    normal = vec3(0.0, 0.0, 1.0);");
+            fragBuilder->codeAppend( "} else {");
+            this->emitMath(fragBuilder, fp.fType, widthUniName, heightUniName);
+            fragBuilder->codeAppend( "}");
+            fragBuilder->codeAppendf("%s = vec4(normal, 0.0);", args.fOutputColor);
         }
 
         static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             const NormalBevelFP& fp = proc.cast<NormalBevelFP>();
             b->add32(static_cast<int>(fp.fType));
         }
 
     protected:
         void setNormalData(const GrGLSLProgramDataManager& pdman,
                            const GrProcessor& proc) override {
             const NormalBevelFP& normalBevelFP = proc.cast<NormalBevelFP>();
 
             if (fPrevWidth  != normalBevelFP.fWidth) {
                 pdman.set1f(fWidthUni, normalBevelFP.fWidth);
                 fPrevWidth = normalBevelFP.fWidth;
             }
             if (fPrevHeight != normalBevelFP.fHeight) {
                 pdman.set1f(fHeightUni, normalBevelFP.fHeight);
                 fPrevHeight = normalBevelFP.fHeight;
             }
         }
 
+        void emitMath(GrGLSLFPFragmentBuilder* fb, SkNormalSource::BevelType type,
+                      const char* width, const char* height) {
+            const char* distanceVector = fb->distanceVectorName();
+
+            // Setting t to the distance from the end of the bevel as opposed to the beginning if
+            // the bevel is rounded out.
+            if ( type == SkNormalSource::BevelType::kRoundedIn ) {
+                fb->codeAppendf("    float t = %s - length(%s);", width, distanceVector);
+            } else if (type == SkNormalSource::BevelType::kRoundedOut) {
+                fb->codeAppendf("    float t = length(%s);", distanceVector);
+            }
+
+            switch (type) {
+                case SkNormalSource::BevelType::kLinear:
+                    fb->codeAppendf("    normal = normalize(%s*vec3(%s, 0.0) "
+                                                           "+ vec3(0.0, 0.0, %s));",
+                                    height, distanceVector, width);
+                    break;

[robertphillips, 2016/08/03 16:33:15]

Add a "// fall through" comment

[dvonbeck, 2016/08/03 21:04:20]

Done.

+                case SkNormalSource::BevelType::kRoundedOut:
+                case SkNormalSource::BevelType::kRoundedIn:
+                    // calculating the slope of the normal with respect to the distance vector by
+                    // setting it equal to the negative reciprocal of the derivative of the bezier

[robertphillips, 2016/08/03 16:33:15]

cure -> curve

One would hope the shader compilers can coalesce the sqrt(t) calls.

[dvonbeck, 2016/08/03 16:39:24]

Do you think they will, or should I make it explicit?

[dvonbeck, 2016/08/03 21:04:20]

Done.

+                    // cure
+                    fb->codeAppendf("float slope = %s * sqrt(t) / (%s * (sqrt(%s) - sqrt(t)));",
+                                    width, height, width);
+                    // calculating a value so that when appended to the distance vector and
+                    // normalized, it would result in a normal with the correct slope
+                    fb->codeAppend("float z_prenorm = slope * t;");
+                    // Multiplying with the height's sign to orient the vector inwards for bevels of
+                    // negative height

[robertphillips, 2016/08/03 16:33:15]

Is sign() verboten?

[dvonbeck, 2016/08/03 21:04:20]

No longer necessary.

+                    fb->codeAppendf("normal = normalize(vec3(%s, z_prenorm)) * normalize(%s);",
+                                    distanceVector, height);
+                    break;
+                default:
+                    SkDEBUGFAIL("Invalid bevel type passed to emitMath");
+            }
+        }
+
     private:
         SkScalar fPrevWidth;
         GrGLSLProgramDataManager::UniformHandle fWidthUni;
 
         SkScalar fPrevHeight;
         GrGLSLProgramDataManager::UniformHandle fHeightUni;
     };
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
         GLSLNormalBevelFP::GenKey(*this, caps, b);
@@ skipping 14 matching lines @@
                fWidth  == normalBevelFP.fWidth &&
                fHeight == normalBevelFP.fHeight;
     }
 
     SkNormalSource::BevelType fType;
     SkScalar fWidth;
     SkScalar fHeight;
 };
 
 sk_sp<GrFragmentProcessor> SkNormalBevelSourceImpl::asFragmentProcessor(
-        const SkShader::AsFPArgs&) const {
+        const SkShader::AsFPArgs& args) const {
 
-    return sk_make_sp<NormalBevelFP>(fType, fWidth, fHeight);
+    SkScalar maxScale = args.fViewMatrix->getMaxScale();
+
+    // Providing device-space width and height
+    return sk_make_sp<NormalBevelFP>(fType, maxScale * fWidth, maxScale * fHeight);
 }
 
 #endif // SK_SUPPORT_GPU
 
 ////////////////////////////////////////////////////////////////////////////
 
 SkNormalBevelSourceImpl::Provider::Provider() {}
 
 SkNormalBevelSourceImpl::Provider::~Provider() {}
 
@@ skipping 37 matching lines @@
 sk_sp<SkNormalSource> SkNormalSource::MakeBevel(BevelType type, SkScalar width, SkScalar height) {
     /* TODO make sure this checks are tolerant enough to account for loss of conversion when GPUs
        use 16-bit float types. We don't want to assume stuff is non-zero on the GPU and be wrong.*/
     SkASSERT(width > 0.0f && !SkScalarNearlyZero(width));
     if (SkScalarNearlyZero(height)) {
         return SkNormalSource::MakeFlat();
     }
 
     return sk_make_sp<SkNormalBevelSourceImpl>(type, width, height);
 }