Support for custom vertex data in SkSL and drawVertices

Adds a 'varying' modifier to the SkSL frontend. Only valid
for pipeline stage (runtime effect) SkSL programs, and only
on variables that are float, or float[2-4].

Runtime effect SkSL can declare varyings. The effect gathers
and reflects them. The GPU backend uses SkShader_Base's new
asRuntimeEffect() to get this data.

GrDrawVerticesOp and its GP get the shader's effect, if any.
They use this to add vertex attributes, varyings, and global
variables (in the fragment shader) of the appropriate width.
The globals have procedurally generated names, based on
their index in the list ("_vtx_attr_%d"). The GP's fragment
code copies the varyings to the globals.

When PipelineStageCodeGenerator sees a varying reference,
it just replaces that with the procedurally generated name
that matches the logic in the op.

Change-Id: I0effbc4f3425d452cb7d62e51e268f3b48fa3c74
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/275962
Reviewed-by: Brian Salomon <[email protected]>
Commit-Queue: Brian Osman <[email protected]>

Author: brianosman

gm/vertices.cpp

@@ -22,9 +22,13 @@
 #include "include/core/SkTypes.h"
 #include "include/core/SkVertices.h"
 #include "include/effects/SkGradientShader.h"
+#include "include/effects/SkRuntimeEffect.h"
 #include "include/private/SkTDArray.h"
 #include "include/utils/SkRandom.h"
+#include "src/core/SkVerticesPriv.h"
 #include "src/shaders/SkLocalMatrixShader.h"
+#include "src/utils/SkPatchUtils.h"
+#include "tools/Resources.h"
 #include "tools/ToolUtils.h"
 
 #include <initializer_list>
@@ -335,3 +339,46 @@ DEF_SIMPLE_GM(vertices_perspective, canvas, 256, 256) {
     canvas->drawVertices(verts, paint);
     canvas->restore();
 }
+
+DEF_SIMPLE_GM(vertices_data_lerp, canvas, 256, 256) {
+    SkPoint pts[12] = {{0, 0},     {85, 0},    {171, 0},  {256, 0}, {256, 85}, {256, 171},
+                       {256, 256}, {171, 256}, {85, 256}, {0, 256}, {0, 171},  {0, 85}};
+
+    auto patchVerts = SkPatchUtils::MakeVertices(pts, nullptr, nullptr, 12, 12);
+    SkVertices::Info info;
+    patchVerts->getInfo(&info);
+
+    SkVertices::CustomLayout customLayout { 1 };
+    SkVertices::Builder builder(info.fMode, info.fVertexCount, info.fIndexCount, customLayout);
+
+    memcpy(builder.positions(), info.fPositions, info.fVertexCount * sizeof(SkPoint));
+    memcpy(builder.indices(), info.fIndices, info.fIndexCount * sizeof(uint16_t));
+
+    SkRandom rnd;
+    for (int i = 0; i < info.fVertexCount; ++i) {
+        builder.perVertexData()[i] = rnd.nextBool() ? 1.0f : 0.0f;
+    }
+
+    auto verts = builder.detach();
+
+    SkPaint paint;
+    const char* gProg = R"(
+        in fragmentProcessor c0;
+        in fragmentProcessor c1;
+        varying float vtx_lerp;
+        void main(float2 p, inout half4 color) {
+            half4 col0 = sample(c0, p);
+            half4 col1 = sample(c1, p);
+            color = mix(col0, col1, half(vtx_lerp));
+        }
+    )";
+    auto [effect, errorText] = SkRuntimeEffect::Make(SkString(gProg));
+    SkMatrix scale = SkMatrix::MakeScale(2);
+    sk_sp<SkShader> children[] = {
+        GetResourceAsImage("images/mandrill_256.png")->makeShader(),
+        GetResourceAsImage("images/color_wheel.png")->makeShader(scale),
+    };
+    paint.setShader(effect->makeShader(nullptr, children, 2, nullptr, false));
+
+    canvas->drawVertices(verts, paint);
+}

include/effects/SkRuntimeEffect.h

@@ -74,6 +74,11 @@ class SK_API SkRuntimeEffect : public SkRefCnt {
         size_t sizeInBytes() const;
     };
 
+    struct Varying {
+        SkString fName;
+        int      fWidth;  // 1 - 4 (floats)
+    };
+
     // [Effect, ErrorText]
     // If successful, Effect != nullptr, otherwise, ErrorText contains the reason for failure.
     using EffectResult = std::tuple<sk_sp<SkRuntimeEffect>, SkString>;
@@ -112,8 +117,12 @@ class SK_API SkRuntimeEffect : public SkRefCnt {
     // Combined size of just the 'uniform' variables.
     size_t uniformSize() const { return fUniformSize; }
 
+    // Total number of channels across all varyings, combined.
+    int varyingCount() const;
+
     ConstIterable<Variable> inputs() const { return ConstIterable<Variable>(fInAndUniformVars); }
     ConstIterable<SkString> children() const { return ConstIterable<SkString>(fChildren); }
+    ConstIterable<Varying> varyings() const { return ConstIterable<Varying>(fVaryings); }
 
 #if SK_SUPPORT_GPU
     // This re-compiles the program from scratch, using the supplied shader caps.
@@ -136,7 +145,7 @@ class SK_API SkRuntimeEffect : public SkRefCnt {
 private:
     SkRuntimeEffect(SkString sksl, std::unique_ptr<SkSL::Program> baseProgram,
                     std::vector<Variable>&& inAndUniformVars, std::vector<SkString>&& children,
-                    size_t uniformSize);
+                    std::vector<Varying>&& varyings, size_t uniformSize);
 
     using SpecializeResult = std::tuple<std::unique_ptr<SkSL::Program>, SkString>;
     SpecializeResult specialize(SkSL::Program& baseProgram, const void* inputs,
@@ -148,6 +157,7 @@ class SK_API SkRuntimeEffect : public SkRefCnt {
     std::unique_ptr<SkSL::Program> fBaseProgram;
     std::vector<Variable> fInAndUniformVars;
     std::vector<SkString> fChildren;
+    std::vector<Varying>  fVaryings;
 
     size_t fUniformSize;
 };

src/core/SkRuntimeEffect.cpp

@@ -16,6 +16,7 @@
 #include "src/sksl/SkSLByteCode.h"
 #include "src/sksl/SkSLCompiler.h"
 #include "src/sksl/SkSLInterpreter.h"
+#include "src/sksl/ir/SkSLFunctionDefinition.h"
 #include "src/sksl/ir/SkSLVarDeclarations.h"
 
 #if SK_SUPPORT_GPU
@@ -66,8 +67,25 @@ SkRuntimeEffect::EffectResult SkRuntimeEffect::Make(SkString sksl) {
     size_t offset = 0, uniformSize = 0;
     std::vector<Variable> inAndUniformVars;
     std::vector<SkString> children;
+    std::vector<Varying> varyings;
     const SkSL::Context& ctx(compiler->context());
 
+    // Scrape the varyings
+    for (const auto& e : *program) {
+        if (e.fKind == SkSL::ProgramElement::kVar_Kind) {
+            SkSL::VarDeclarations& v = (SkSL::VarDeclarations&) e;
+            for (const auto& varStatement : v.fVars) {
+                const SkSL::Variable& var = *((SkSL::VarDeclaration&) *varStatement).fVar;
+
+                if (var.fModifiers.fFlags & SkSL::Modifiers::kVarying_Flag) {
+                    varyings.push_back({var.fName, var.fType.kind() == SkSL::Type::kVector_Kind
+                                                           ? var.fType.columns()
+                                                           : 1});
+                }
+            }
+        }
+    }
+
     // Gather the inputs in two passes, to de-interleave them in our input layout.
     // We put the uniforms *first*, so that the CPU backend can alias the combined input block as
     // the uniform block when calling the interpreter.
@@ -200,6 +218,7 @@ SkRuntimeEffect::EffectResult SkRuntimeEffect::Make(SkString sksl) {
                                                       std::move(program),
                                                       std::move(inAndUniformVars),
                                                       std::move(children),
+                                                      std::move(varyings),
                                                       uniformSize));
     return std::make_pair(std::move(effect), SkString());
 }
@@ -227,12 +246,14 @@ SkRuntimeEffect::SkRuntimeEffect(SkString sksl,
                                  std::unique_ptr<SkSL::Program> baseProgram,
                                  std::vector<Variable>&& inAndUniformVars,
                                  std::vector<SkString>&& children,
+                                 std::vector<Varying>&& varyings,
                                  size_t uniformSize)
         : fHash(SkGoodHash()(sksl))
         , fSkSL(std::move(sksl))
         , fBaseProgram(std::move(baseProgram))
         , fInAndUniformVars(std::move(inAndUniformVars))
         , fChildren(std::move(children))
+        , fVaryings(std::move(varyings))
         , fUniformSize(uniformSize) {
     SkASSERT(fBaseProgram);
     SkASSERT(SkIsAlign4(fUniformSize));
@@ -247,6 +268,14 @@ size_t SkRuntimeEffect::inputSize() const {
                                                 fInAndUniformVars.back().sizeInBytes());
 }
 
+int SkRuntimeEffect::varyingCount() const {
+    int count = 0;
+    for (const auto& v : fVaryings) {
+        count += v.fWidth;
+    }
+    return count;
+}
+
 SkRuntimeEffect::SpecializeResult SkRuntimeEffect::specialize(SkSL::Program& baseProgram,
                                                               const void* inputs,
                                                               const SkSL::SharedCompiler& compiler) {
@@ -528,6 +557,8 @@ class SkRTShader : public SkShaderBase {
         }
     }
 
+    SkRuntimeEffect* asRuntimeEffect() const override { return fEffect.get(); }
+
     SK_FLATTENABLE_HOOKS(SkRTShader)
 
 private:

src/gpu/GrRenderTargetContext.cpp

@@ -1064,7 +1064,8 @@ void GrRenderTargetContext::drawVertices(const GrClip& clip,
                                          GrPaint&& paint,
                                          const SkMatrix& viewMatrix,
                                          sk_sp<SkVertices> vertices,
-                                         GrPrimitiveType* overridePrimType) {
+                                         GrPrimitiveType* overridePrimType,
+                                         const SkRuntimeEffect* effect) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
@@ -1076,7 +1077,7 @@ void GrRenderTargetContext::drawVertices(const GrClip& clip,
     GrAAType aaType = this->chooseAAType(GrAA::kNo);
     std::unique_ptr<GrDrawOp> op = GrDrawVerticesOp::Make(
             fContext, std::move(paint), std::move(vertices), viewMatrix, aaType,
-            this->colorInfo().refColorSpaceXformFromSRGB(), overridePrimType);
+            this->colorInfo().refColorSpaceXformFromSRGB(), overridePrimType, effect);
     this->addDrawOp(clip, std::move(op));
 }
 

src/gpu/GrRenderTargetContext.h

@@ -49,6 +49,7 @@ struct SkRect;
 class SkRegion;
 class SkRRect;
 struct SkRSXform;
+class SkRuntimeEffect;
 class SkTextBlob;
 class SkVertices;
 
@@ -411,12 +412,14 @@ class GrRenderTargetContext : public GrSurfaceContext {
      * @param   viewMatrix       transformation matrix
      * @param   vertices         specifies the mesh to draw.
      * @param   overridePrimType primitive type to draw. If NULL, derive prim type from vertices.
+     * @param   effect           runtime effect that will handle custom vertex attributes.
      */
     void drawVertices(const GrClip&,
                       GrPaint&& paint,
                       const SkMatrix& viewMatrix,
                       sk_sp<SkVertices> vertices,
-                      GrPrimitiveType* overridePrimType = nullptr);
+                      GrPrimitiveType* overridePrimType = nullptr,
+                      const SkRuntimeEffect* effect = nullptr);
 
     /**
      * Draws textured sprites from an atlas with a paint. This currently does not support AA for the

src/gpu/SkGpuDevice.cpp

@@ -12,6 +12,7 @@
 #include "include/core/SkPicture.h"
 #include "include/core/SkSurface.h"
 #include "include/core/SkVertices.h"
+#include "include/effects/SkRuntimeEffect.h"
 #include "include/gpu/GrContext.h"
 #include "include/private/SkShadowFlags.h"
 #include "include/private/SkTo.h"
@@ -1031,14 +1032,25 @@ void SkGpuDevice::wireframeVertices(SkVertices::VertexMode vmode, int vertexCoun
 void SkGpuDevice::drawVertices(const SkVertices* vertices, SkBlendMode mode, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawVertices", fContext.get());
+    SkASSERT(vertices);
 
     SkVertices::Info info;
     vertices->getInfo(&info);
 
-    SkASSERT(vertices);
+    const SkRuntimeEffect* effect =
+            paint.getShader() ? as_SB(paint.getShader())->asRuntimeEffect() : nullptr;
+    int shaderVaryingCount = effect ? effect->varyingCount() : 0;
+
+    // TODO: Hoist this check up to SkCanvas
+    if (shaderVaryingCount != info.fPerVertexDataCount) {
+        return;
+    }
+
+    // Pretend that we have tex coords when using custom per-vertex data. The shader is going to
+    // use those (rather than local coords), but our paint conversion remains the same.
     GrPaint grPaint;
     bool hasColors = info.hasColors();
-    bool hasTexs = info.hasTexCoords();
+    bool hasTexs = info.hasTexCoords() || info.hasPerVertexData();
     if ((!hasTexs || !paint.getShader()) && !hasColors) {
         // The dreaded wireframe mode. Fallback to drawVertices and go so slooooooow.
         this->wireframeVertices(vertices->mode(), vertices->vertexCount(), vertices->positions(),
@@ -1051,7 +1063,8 @@ void SkGpuDevice::drawVertices(const SkVertices* vertices, SkBlendMode mode, con
         return;
     }
     fRenderTargetContext->drawVertices(this->clip(), std::move(grPaint), this->localToDevice(),
-                                       sk_ref_sp(const_cast<SkVertices*>(vertices)));
+                                       sk_ref_sp(const_cast<SkVertices*>(vertices)), nullptr,
+                                       effect);
 }
 
 ///////////////////////////////////////////////////////////////////////////////