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.
+ *
+ *  @param bevelType    type of the bevel
+ *  @param bevelWidth   width of the bevel in device space
+ *  @param bevelHeight  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) {
+    NormalBevelFP(SkNormalSource::BevelType bevelType, SkScalar bevelWidth, SkScalar bevelHeight)
+        : fBevelType(bevelType)
+        , fBevelWidth(bevelWidth)
+        , fBevelHeight(bevelHeight) {
         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);
 
-            fragBuilder->codeAppendf("%s = vec4(0.0, 0.0, 1.0, 0.0);", args.fOutputColor);
+            // Here we are splitting the distance vector into length and normalized direction
+            // TODO: Output these values from the geometry processor frag code instead of the vector
+            fragBuilder->codeAppendf("float dv_length = length(%s);",
+                                     fragBuilder->distanceVectorName());
+            fragBuilder->codeAppendf("vec2 dv_norm = normalize(%s);",
+                                     fragBuilder->distanceVectorName());
+
+            fragBuilder->codeAppend( "vec3 normal;");
+            fragBuilder->codeAppendf("if (dv_length >= %s) {", widthUniName);
+            fragBuilder->codeAppend( "    normal = vec3(0.0, 0.0, 1.0);");
+            fragBuilder->codeAppend( "} else {");
+            this->emitMath(fragBuilder, fp.fBevelType, 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));
+            b->add32(static_cast<int>(fp.fBevelType));
         }
 
     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 (fPrevWidth  != normalBevelFP.fBevelWidth) {
+                pdman.set1f(fWidthUni, normalBevelFP.fBevelWidth);
+                fPrevWidth = normalBevelFP.fBevelWidth;
             }
-            if (fPrevHeight != normalBevelFP.fHeight) {
-                pdman.set1f(fHeightUni, normalBevelFP.fHeight);
-                fPrevHeight = normalBevelFP.fHeight;
+            if (fPrevHeight != normalBevelFP.fBevelHeight) {
+                pdman.set1f(fHeightUni, normalBevelFP.fBevelHeight);
+                fPrevHeight = normalBevelFP.fBevelHeight;
             }
         }
 
+        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 in.
+            if ( type == SkNormalSource::BevelType::kRoundedIn ) {

[egdaniel, 2016/08/04 03:08:17]

this should be inside roundOut/In section right?

[dvonbeck, 2016/08/04 17:57:25]

I guess it makes more sense over there. Done.

+                fb->codeAppendf("float t = %s - dv_length;", width);
+            } else if (type == SkNormalSource::BevelType::kRoundedOut) {
+                fb->codeAppendf("float t = dv_length;");
+            }
+
+            switch (type) {
+                case SkNormalSource::BevelType::kLinear:
+                    fb->codeAppendf("normal = normalize(%s*vec3(%s, 0.0) + vec3(0.0, 0.0, %s));",

[egdaniel, 2016/08/04 03:08:17]

I don't think this is correct. Without going into detail here, the fact that the
final z value will depend on the x,y of the distance vector (cause of the
normalization), must be wrong. Z should only depend on width and height. I can
show you my approach tomorrow but the tldr is we can pass up two uniforms (in
the width height slots) and the normal is vec3(dv_norm * H', W') with no
normalization needed.

[dvonbeck, 2016/08/04 17:57:25]

Done.

+                                    height, distanceVector, width);
+                    break;
+                case SkNormalSource::BevelType::kRoundedOut:
+                    // Fall through
+                case SkNormalSource::BevelType::kRoundedIn:
+                    fb->codeAppendf("float rootTOverW = sqrt(t/%s);", width);
+
+                    // Calculating the d- and z-components of the normal, where 'd' is the axis
+                    // co-linear to the distance vector. Equation was derived from the formula for
+                    // a bezier curve.
+                    fb->codeAppendf("vec2 unnormalizedNormal_dz = vec2(%s*(1.0-rootTOverW), "

[egdaniel, 2016/08/04 03:08:17]

just trying to confirm in my head, since we multiply the d component by height,
it will just naturally give us the right x,y for a negative height, right?

[dvonbeck, 2016/08/04 17:57:25]

Yes. I think it's more that my math explicitly built the vector pointing
outwards, so I had to flip it when it didn't. I don't know why I had to flip the
z-component before and not now, but it works ¯\_(ツ)_/¯

+                                                                       "%s*rootTOverW);",
+                                    height, width);
+                    fb->codeAppendf("vec2 normal_dz = normalize(unnormalizedNormal_dz);");
+
+                    // Multiplying the d-component of the normal with the normalized distance vector
+                    // splitting it in x- and y-components
+                    fb->codeAppendf("normal = vec3(normal_dz.x*dv_norm, normal_dz.y);");
+
+                    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);
     }
 
     const char* name() const override { return "NormalBevelFP"; }
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         inout->setToUnknown(GrInvariantOutput::ReadInput::kWillNot_ReadInput);
     }
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new GLSLNormalBevelFP; }
 
     bool onIsEqual(const GrFragmentProcessor& proc) const override {
         const NormalBevelFP& normalBevelFP = proc.cast<NormalBevelFP>();
-        return fType   == normalBevelFP.fType &&
-               fWidth  == normalBevelFP.fWidth &&
-               fHeight == normalBevelFP.fHeight;
+        return fBevelType   == normalBevelFP.fBevelType &&
+               fBevelWidth  == normalBevelFP.fBevelWidth &&
+               fBevelHeight == normalBevelFP.fBevelHeight;
     }
 
-    SkNormalSource::BevelType fType;
-    SkScalar fWidth;
-    SkScalar fHeight;
+    SkNormalSource::BevelType fBevelType;
+    SkScalar fBevelWidth;
+    SkScalar fBevelHeight;
 };
 
 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);
 }