Test for stroke tesellation in compute

Author: dnfield

impeller/compiler/compiler.cc

@@ -34,7 +34,7 @@ static CompilerBackend CreateMSLCompiler(const spirv_cross::ParsedIR& ir,
   // If this version specification changes, the GN rules that process the
   // Metal to AIR must be updated as well.
   sl_options.msl_version =
-      spirv_cross::CompilerMSL::Options::make_msl_version(1, 2);
+      spirv_cross::CompilerMSL::Options::make_msl_version(2, 1);
   sl_options.use_framebuffer_fetch_subpasses = true;
   sl_compiler->set_msl_options(sl_options);
 
@@ -348,7 +348,7 @@ Compiler::Compiler(const fml::Mapping& source_mapping,
           shaderc_optimization_level::shaderc_optimization_level_performance);
       spirv_options.SetTargetEnvironment(
           shaderc_target_env::shaderc_target_env_vulkan,
-          shaderc_env_version::shaderc_env_version_vulkan_1_1);
+          shaderc_env_version::shaderc_env_version_vulkan_1_3);
       spirv_options.SetTargetSpirv(
           shaderc_spirv_version::shaderc_spirv_version_1_3);
       break;
@@ -357,9 +357,9 @@ Compiler::Compiler(const fml::Mapping& source_mapping,
           shaderc_optimization_level::shaderc_optimization_level_performance);
       spirv_options.SetTargetEnvironment(
           shaderc_target_env::shaderc_target_env_vulkan,
-          shaderc_env_version::shaderc_env_version_vulkan_1_0);
+          shaderc_env_version::shaderc_env_version_vulkan_1_3);
       spirv_options.SetTargetSpirv(
-          shaderc_spirv_version::shaderc_spirv_version_1_0);
+          shaderc_spirv_version::shaderc_spirv_version_1_3);
       break;
     case TargetPlatform::kRuntimeStageMetal:
     case TargetPlatform::kRuntimeStageGLES:
@@ -383,7 +383,7 @@ Compiler::Compiler(const fml::Mapping& source_mapping,
           shaderc_target_env::shaderc_target_env_opengl,
           shaderc_env_version::shaderc_env_version_opengl_4_5);
       spirv_options.SetTargetSpirv(
-          shaderc_spirv_version::shaderc_spirv_version_1_0);
+          shaderc_spirv_version::shaderc_spirv_version_1_3);
       spirv_options.AddMacroDefinition("SKIA_GRAPHICS_BACKEND");
       break;
     case TargetPlatform::kUnknown:
@@ -437,9 +437,10 @@ Compiler::Compiler(const fml::Mapping& source_mapping,
                    << ShaderCErrorToString(spv_result_->GetCompilationStatus())
                    << ". " << spv_result_->GetNumErrors() << " error(s) and "
                    << spv_result_->GetNumWarnings() << " warning(s).";
-    if (spv_result_->GetNumErrors() > 0 || spv_result_->GetNumWarnings() > 0) {
-      COMPILER_ERROR_NO_PREFIX << spv_result_->GetErrorMessage();
-    }
+    // if (spv_result_->GetNumErrors() > 0 || spv_result_->GetNumWarnings() > 0)
+    // {
+    COMPILER_ERROR_NO_PREFIX << spv_result_->GetErrorMessage();
+    // }
     return;
   } else {
     included_file_names_ = std::move(included_file_names);

impeller/compiler/shader_lib/impeller/BUILD.gn

@@ -10,6 +10,7 @@ copy("impeller") {
     "constants.glsl",
     "gaussian.glsl",
     "gradient.glsl",
+    "path.glsl",
     "texture.glsl",
     "transform.glsl",
     "types.glsl",

impeller/compiler/shader_lib/impeller/path.glsl

@@ -0,0 +1,68 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef PATH_GLSL_
+#define PATH_GLSL_
+
+#define MOVE 0
+#define LINE 1
+#define QUAD 2
+#define CUBIC 3
+
+struct LineData {
+  vec2 p1;
+  vec2 p2;
+};
+
+struct QuadData {
+  vec2 p1;
+  vec2 cp;
+  vec2 p2;
+};
+
+struct CubicData {
+  vec2 p1;
+  vec2 cp1;
+  vec2 cp2;
+  vec2 p2;
+};
+
+struct Position {
+  uint index;
+  uint count;
+};
+
+/// Solve for point on a quadratic Bezier curve defined by starting point `p1`,
+/// control point `cp`, and end point `p2` at time `t`.
+vec2 QuadraticSolve(QuadData quad, float t) {
+  return (1.0 - t) * (1.0 - t) * quad.p1 +  //
+         2.0 * (1.0 - t) * t * quad.cp +    //
+         t * t * quad.p2;
+}
+
+vec2 CubicSolve(CubicData cubic, float t) {
+  return (1. - t) * (1. - t) * (1. - t) * cubic.p1 +  //
+         3 * (1. - t) * (1. - t) * t * cubic.cp1 +    //
+         3 * (1. - t) * t * t * cubic.cp2 +           //
+         t * t * t * cubic.p2;
+}
+
+/// Used to approximate quadratic curves using parabola.
+///
+/// See
+/// https://raphlinus.github.io/graphics/curves/2019/12/23/flatten-quadbez.html
+float ApproximateParabolaIntegral(float x) {
+  float d = 0.67;
+  return x / (1.0 - d + sqrt(sqrt(pow(d, 4) + 0.25 * x * x)));
+}
+
+bool isfinite(float f) {
+  return !isnan(f) && !isinf(f);
+}
+
+float Cross(vec2 p1, vec2 p2) {
+  return p1.x * p2.y - p1.y * p2.x;
+}
+
+#endif

impeller/fixtures/BUILD.gn

@@ -18,6 +18,7 @@ impeller_shaders("shader_fixtures") {
     "box_fade.vert",
     "colors.vert",
     "colors.frag",
+    "cubic_to_quads.comp",
     "impeller.frag",
     "impeller.vert",
     "inactive_uniforms.frag",
@@ -26,19 +27,24 @@ impeller_shaders("shader_fixtures") {
     "instanced_draw.vert",
     "mipmaps.frag",
     "mipmaps.vert",
+    "quad_polyline.comp",
     "sample.comp",
     "stage1.comp",
     "stage2.comp",
     "simple.vert",
+    "stroke.comp",
     "test_texture.frag",
     "test_texture.vert",
   ]
 
   if (impeller_enable_opengles) {
     gles_exclusions = [
+      "cubic_to_quads.comp",
+      "quad_polyline.comp",
       "sample.comp",
       "stage1.comp",
       "stage2.comp",
+      "stroke.comp",
     ]
   }
 }
@@ -70,10 +76,12 @@ test_fixtures("file_fixtures") {
     "bay_bridge.jpg",
     "blue_noise.png",
     "boston.jpg",
+    "cubic_to_quads.comp",
     "embarcadero.jpg",
     "flutter_logo_baked.glb",
     "kalimba.jpg",
     "multiple_stages.hlsl",
+    "quad_polyline.comp",
     "resources_limit.vert",
     "sample.comp",
     "sample.frag",
@@ -85,6 +93,7 @@ test_fixtures("file_fixtures") {
     "sa%m#ple.vert",
     "stage1.comp",
     "stage2.comp",
+    "stroke.comp",
     "struct_def_bug.vert",
     "table_mountain_nx.png",
     "table_mountain_ny.png",

impeller/fixtures/cubic_to_quads.comp

@@ -0,0 +1,83 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#extension GL_KHR_shader_subgroup_arithmetic : enable
+
+layout(local_size_x = 512, local_size_y = 1) in;
+layout(std430) buffer;
+
+#include <impeller/path.glsl>
+
+layout(binding = 0) readonly buffer Cubics {
+  uint count;
+  CubicData data[];
+}
+cubics;
+
+layout(binding = 1) buffer Quads {
+  uint count;
+  QuadData data[];
+}
+quads;
+
+uniform Config {
+  float accuracy;
+}
+config;
+
+shared uint quad_counts[512];
+shared uint count_sums[512];
+
+void main() {
+  uint ident = gl_GlobalInvocationID.x;
+  if (ident >= cubics.count) {
+    return;
+  }
+
+  // The maximum error, as a vector from the cubic to the best approximating
+  // quadratic, is proportional to the third derivative, which is constant
+  // across the segment. Thus, the error scales down as the third power of
+  // the number of subdivisions. Our strategy then is to subdivide `t` evenly.
+  //
+  // This is an overestimate of the error because only the component
+  // perpendicular to the first derivative is important. But the simplicity is
+  // appealing.
+
+  // This magic number is the square of 36 / sqrt(3).
+  // See: http://caffeineowl.com/graphics/2d/vectorial/cubic2quad01.html
+  float max_hypot2 = 432.0 * config.accuracy * config.accuracy;
+
+  CubicData cubic = cubics.data[ident];
+
+  vec2 err_v = 3.0 * (cubic.cp2 - cubic.cp1) + cubic.p1 - cubic.p2;
+  float err = dot(err_v, err_v);
+  float quad_count = max(1., ceil(pow(err * (1.0 / max_hypot2), 1. / 6.0)));
+
+  quad_counts[ident] = uint(quad_count);
+
+  barrier();
+  count_sums[ident] = subgroupInclusiveAdd(quad_counts[ident]);
+
+  quads.count = count_sums[cubics.count - 1];
+  for (uint i = 0; i < quad_count; i++) {
+    float t0 = i / quad_count;
+    float t1 = (i + 1) / quad_count;
+
+    // calculate the subsegment
+    vec2 sub_p1 = CubicSolve(cubic, t0);
+    vec2 sub_p2 = CubicSolve(cubic, t1);
+    QuadData quad = QuadData(3.0 * (cubic.cp1 - cubic.p1),   //
+                             3.0 * (cubic.cp2 - cubic.cp1),  //
+                             3.0 * (cubic.p2 - cubic.cp2));
+    float sub_scale = (t1 - t0) * (1.0 / 3.0);
+    vec2 sub_cp1 = sub_p1 + sub_scale * QuadraticSolve(quad, t0);
+    vec2 sub_cp2 = sub_p2 - sub_scale * QuadraticSolve(quad, t1);
+
+    vec2 quad_p1x2 = 3.0 * sub_cp1 - sub_p1;
+    vec2 quad_p2x2 = 3.0 * sub_cp2 - sub_p2;
+    uint offset = count_sums[ident] - uint(quad_count);
+    quads.data[offset + i] = QuadData(sub_p1,                           //
+                                      ((quad_p1x2 + quad_p2x2) / 4.0),  //
+                                      sub_p2);
+  }
+}