[Flutter GPU] Pack multiple backends in shader bundles.

bdero · bdero · commit e15341952c51 · 2023-12-19T01:56:02.000-08:00
diff --git a/impeller/compiler/shader_bundle.cc b/impeller/compiler/shader_bundle.cc
@@ -80,12 +80,12 @@ std::optional<ShaderBundleConfig> ParseShaderBundleConfig(
   return bundle;
 }
 
-static std::unique_ptr<fb::ShaderT> GenerateShaderFB(
+static std::unique_ptr<fb::RuntimeStageT> GenerateShaderBackendFB(
+    TargetPlatform target_platform,
     SourceOptions& options,
     const std::string& shader_name,
     const ShaderConfig& shader_config) {
-  auto result = std::make_unique<fb::ShaderT>();
-  result->name = shader_name;
+  auto result = std::make_unique<fb::RuntimeStageT>();
 
   std::shared_ptr<fml::FileMapping> source_file_mapping =
       fml::FileMapping::CreateReadOnly(shader_config.source_file_name);
@@ -96,6 +96,8 @@ static std::unique_ptr<fb::ShaderT> GenerateShaderFB(
   }
 
   /// Override options.
+  options.target_platform = target_platform;
+  options.file_name = shader_name;  // This is just used for error messages.
   options.type = shader_config.type;
   options.source_language = shader_config.language;
   options.entry_point_name = EntryPointFunctionNameFromSourceName(
@@ -129,8 +131,8 @@ static std::unique_ptr<fb::ShaderT> GenerateShaderFB(
     return nullptr;
   }
 
-  result->shader = stage_data->CreateFlatbuffer();
-  if (!result->shader) {
+  result = stage_data->CreateFlatbuffer();
+  if (!result) {
     std::cerr << "Failed to create flatbuffer for bundled shader \""
               << shader_name << "\"." << std::endl;
     return nullptr;
@@ -139,6 +141,29 @@ static std::unique_ptr<fb::ShaderT> GenerateShaderFB(
   return result;
 }
 
+static std::unique_ptr<fb::ShaderT> GenerateShaderFB(
+    SourceOptions& options,
+    const std::string& shader_name,
+    const ShaderConfig& shader_config) {
+  auto result = std::make_unique<fb::ShaderT>();
+  result->name = shader_name;
+  result->metal_ios = GenerateShaderBackendFB(
+      TargetPlatform::kMetalIOS, options, shader_name, shader_config);
+  result->metal_desktop = GenerateShaderBackendFB(
+      TargetPlatform::kMetalDesktop, options, shader_name, shader_config);
+  result->opengl_es = GenerateShaderBackendFB(
+      TargetPlatform::kOpenGLES, options, shader_name, shader_config);
+  result->opengl_desktop = GenerateShaderBackendFB(
+      TargetPlatform::kOpenGLDesktop, options, shader_name, shader_config);
+  result->vulkan = GenerateShaderBackendFB(TargetPlatform::kVulkan, options,
+                                           shader_name, shader_config);
+  if (!(result->metal_ios && result->metal_desktop && result->opengl_es &&
+        result->opengl_desktop && result->vulkan)) {
+    return nullptr;
+  }
+  return result;
+}
+
 std::optional<fb::ShaderBundleT> GenerateShaderBundleFlatbuffer(
     const std::string& bundle_config_json,
     SourceOptions& options) {
diff --git a/impeller/compiler/shader_bundle_unittests.cc b/impeller/compiler/shader_bundle_unittests.cc
@@ -156,14 +156,14 @@ TEST(ShaderBundleTest, GenerateShaderBundleFlatbufferProducesCorrectResult) {
   /// Verify vertex shader.
   ///
 
-  EXPECT_STREQ(vertex->shader->entrypoint.c_str(),
+  EXPECT_STREQ(vertex->metal_desktop->entrypoint.c_str(),
                "flutter_gpu_unlit_vertex_main");
-  EXPECT_EQ(vertex->shader->stage, fb::Stage::kVertex);
-  EXPECT_EQ(vertex->shader->target_platform, fb::TargetPlatform::kMetal);
+  EXPECT_EQ(vertex->metal_desktop->stage, fb::Stage::kVertex);
+  EXPECT_EQ(vertex->metal_desktop->target_platform, fb::TargetPlatform::kMetal);
 
   // Inputs.
-  ASSERT_EQ(vertex->shader->inputs.size(), 1u);
-  const auto& v_in_position = vertex->shader->inputs[0];
+  ASSERT_EQ(vertex->metal_desktop->inputs.size(), 1u);
+  const auto& v_in_position = vertex->metal_desktop->inputs[0];
   EXPECT_STREQ(v_in_position->name.c_str(), "position");
   EXPECT_EQ(v_in_position->location, 0u);
   EXPECT_EQ(v_in_position->set, 0u);
@@ -175,16 +175,16 @@ TEST(ShaderBundleTest, GenerateShaderBundleFlatbufferProducesCorrectResult) {
   EXPECT_EQ(v_in_position->offset, 0u);
 
   // Uniforms.
-  ASSERT_EQ(vertex->shader->uniforms.size(), 2u);
-  const auto* v_mvp = FindByName(vertex->shader->uniforms, "mvp");
+  ASSERT_EQ(vertex->metal_desktop->uniforms.size(), 2u);
+  const auto* v_mvp = FindByName(vertex->metal_desktop->uniforms, "mvp");
   ASSERT_NE(v_mvp, nullptr);
   EXPECT_EQ(v_mvp->location, 0u);
   EXPECT_EQ(v_mvp->type, fb::UniformDataType::kFloat);
   EXPECT_EQ(v_mvp->bit_width, 32u);
   EXPECT_EQ(v_mvp->rows, 4u);
   EXPECT_EQ(v_mvp->columns, 4u);
   EXPECT_EQ(v_mvp->array_elements, 0u);
-  const auto* v_color = FindByName(vertex->shader->uniforms, "color");
+  const auto* v_color = FindByName(vertex->metal_desktop->uniforms, "color");
   ASSERT_NE(v_color, nullptr);
   EXPECT_EQ(v_color->location, 1u);
   EXPECT_EQ(v_color->type, fb::UniformDataType::kFloat);
@@ -197,16 +197,17 @@ TEST(ShaderBundleTest, GenerateShaderBundleFlatbufferProducesCorrectResult) {
   /// Verify fragment shader.
   ///
 
-  EXPECT_STREQ(fragment->shader->entrypoint.c_str(),
+  EXPECT_STREQ(fragment->metal_desktop->entrypoint.c_str(),
                "flutter_gpu_unlit_fragment_main");
-  EXPECT_EQ(fragment->shader->stage, fb::Stage::kFragment);
-  EXPECT_EQ(fragment->shader->target_platform, fb::TargetPlatform::kMetal);
+  EXPECT_EQ(fragment->metal_desktop->stage, fb::Stage::kFragment);
+  EXPECT_EQ(fragment->metal_desktop->target_platform,
+            fb::TargetPlatform::kMetal);
 
   // Inputs (not recorded for fragment shaders).
-  ASSERT_EQ(fragment->shader->inputs.size(), 0u);
+  ASSERT_EQ(fragment->metal_desktop->inputs.size(), 0u);
 
   // Uniforms.
-  ASSERT_EQ(fragment->shader->inputs.size(), 0u);
+  ASSERT_EQ(fragment->metal_desktop->inputs.size(), 0u);
 }
 
 }  // namespace testing
diff --git a/impeller/compiler/switches.cc b/impeller/compiler/switches.cc
@@ -200,7 +200,7 @@ bool Switches::AreValid(std::ostream& explain) const {
   const bool shader_bundle_mode = !shader_bundle.empty();
 
   bool valid = true;
-  if (target_platform == TargetPlatform::kUnknown) {
+  if (target_platform == TargetPlatform::kUnknown && !shader_bundle_mode) {
     explain << "The target platform (only one) was not specified." << std::endl;
     valid = false;
   }
diff --git a/impeller/fixtures/BUILD.gn b/impeller/fixtures/BUILD.gn
@@ -125,7 +125,6 @@ impellerc("flutter_gpu_shaders") {
     "flutter_gpu_texture.frag",
     "flutter_gpu_texture.vert",
   ]
-  shader_target_flag = "--runtime-stage-metal"
   shader_bundle = "{\"UnlitFragment\": {\"type\": \"fragment\", \"file\": \"../../flutter/impeller/fixtures/flutter_gpu_unlit.frag\"}, \"UnlitVertex\": {\"type\": \"vertex\", \"file\": \"../../flutter/impeller/fixtures/flutter_gpu_unlit.vert\"}, \"TextureFragment\": {\"type\": \"fragment\", \"file\": \"../../flutter/impeller/fixtures/flutter_gpu_texture.frag\"}, \"TextureVertex\": {\"type\": \"vertex\", \"file\": \"../../flutter/impeller/fixtures/flutter_gpu_texture.vert\"}}"
   shader_bundle_output = "playground.shaderbundle"
 }
diff --git a/impeller/fixtures/flutter_gpu_texture.vert b/impeller/fixtures/flutter_gpu_texture.vert
@@ -2,7 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-uniform mat4 mvp;
+uniform VertInfo {
+  mat4 mvp;
+}
+vert_info;
 
 in vec3 position;
 in vec2 texture_coords;
@@ -13,5 +16,5 @@ out vec4 v_color;
 void main() {
   v_texture_coords = texture_coords;
   v_color = color;
-  gl_Position = mvp * vec4(position, 1.0);
+  gl_Position = vert_info.mvp * vec4(position, 1.0);
 }
diff --git a/impeller/fixtures/flutter_gpu_unlit.vert b/impeller/fixtures/flutter_gpu_unlit.vert
@@ -2,15 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#version 320 es
-
-layout(location = 0) uniform mat4 mvp;
-layout(location = 1) uniform vec4 color;
+uniform VertInfo {
+  mat4 mvp;
+  vec4 color;
+}
+vert_info;
 
 in vec2 position;
 out vec4 v_color;
 
 void main() {
-  v_color = color;
-  gl_Position = mvp * vec4(position, 0.0, 1.0);
+  v_color = vert_info.color;
+  gl_Position = vert_info.mvp * vec4(position, 0.0, 1.0);
 }
diff --git a/impeller/renderer/renderer_dart_unittests.cc b/impeller/renderer/renderer_dart_unittests.cc
@@ -9,31 +9,27 @@
 #include "flutter/common/settings.h"
 #include "flutter/common/task_runners.h"
 #include "flutter/lib/gpu/context.h"
-#include "flutter/lib/gpu/shader.h"
 #include "flutter/lib/gpu/shader_library.h"
 #include "flutter/runtime/dart_isolate.h"
 #include "flutter/runtime/dart_vm_lifecycle.h"
 #include "flutter/testing/dart_fixture.h"
 #include "flutter/testing/dart_isolate_runner.h"
 #include "flutter/testing/testing.h"
 #include "fml/memory/ref_ptr.h"
-#include "impeller/core/shader_types.h"
 #include "impeller/playground/playground_test.h"
 #include "impeller/renderer/render_pass.h"
-#include "impeller/renderer/vertex_descriptor.h"
-#include "impeller/runtime_stage/runtime_stage.h"
 
 #include "gtest/gtest.h"
 #include "third_party/imgui/imgui.h"
 
 namespace impeller {
 namespace testing {
 
-static void InstantiateTestShaderLibrary() {
+static void InstantiateTestShaderLibrary(Context::BackendType backend_type) {
   auto fixture =
       flutter::testing::OpenFixtureAsMapping("playground.shaderbundle");
-  auto library =
-      flutter::gpu::ShaderLibrary::MakeFromFlatbuffer(std::move(fixture));
+  auto library = flutter::gpu::ShaderLibrary::MakeFromFlatbuffer(
+      backend_type, std::move(fixture));
   flutter::gpu::ShaderLibrary::SetOverride(library);
 }
 
@@ -57,7 +53,7 @@ class RendererDartTest : public PlaygroundTest,
     assert(GetContext() != nullptr);
     flutter::gpu::Context::SetOverrideContext(GetContext());
 
-    InstantiateTestShaderLibrary();
+    InstantiateTestShaderLibrary(GetContext()->GetBackendType());
 
     return isolate_.get();
   }
diff --git a/impeller/shader_bundle/BUILD.gn b/impeller/shader_bundle/BUILD.gn
@@ -10,7 +10,6 @@ flatbuffers("shader_bundle_flatbuffers") {
   public_configs = [ "//flutter/impeller/runtime_stage:runtime_stage_config" ]
   public_deps = [
     "//flutter/impeller/runtime_stage:runtime_stage_flatbuffers",
-    "//flutter/impeller/runtime_stage:runtime_stage_types_flatbuffers",
     "//flutter/third_party/flatbuffers",
   ]
 }
diff --git a/impeller/shader_bundle/shader_bundle.fbs b/impeller/shader_bundle/shader_bundle.fbs
@@ -8,7 +8,11 @@ namespace impeller.fb;
 
 table Shader {
   name: string;
-  shader: RuntimeStage;
+  metal_ios: RuntimeStage;
+  metal_desktop: RuntimeStage;
+  opengl_es: RuntimeStage;
+  opengl_desktop: RuntimeStage;
+  vulkan: RuntimeStage;
 }
 
 table ShaderBundle {
diff --git a/impeller/tools/impeller.gni b/impeller/tools/impeller.gni
@@ -288,6 +288,7 @@ template("_impellerc") {
 #                                       --opengl-desktop
 #                                       --vulkan
 #                                       --runtime-stage-metal
+#                                   Not required for --shader_bundle mode.
 # Required: sl_file_extension       The file extension to use for output files.
 #                                   Not required for --shader_bundle mode.
 # Optional: iplr                    Causes --sl output to be in iplr/runtime
@@ -305,7 +306,7 @@ template("_impellerc") {
 #                                   flatbuffer.
 template("impellerc") {
   assert(defined(invoker.shaders), "Impeller shaders must be specified.")
-  assert(defined(invoker.shader_target_flag),
+  assert(defined(invoker.shader_target_flag) || defined(invoker.shader_bundle),
          "The flag to impellerc for target selection must be specified.")
   assert(defined(invoker.sl_file_extension) || defined(invoker.shader_bundle),
          "The extension of the SL file must be specified (metal, glsl, etc..).")
@@ -315,7 +316,7 @@ template("impellerc") {
         "When shader_bundle is specified, shader_output_bundle must also be specified.")
   }
 
-  sksl = invoker.shader_target_flag == "--sksl"
+  sksl = defined(invoker.iplr) && invoker.shader_target_flag == "--sksl"
   iplr = false
   if (defined(invoker.iplr) && invoker.iplr) {
     iplr = invoker.iplr
@@ -347,13 +348,8 @@ template("impellerc") {
       generated_dir = "$target_gen_dir"
     }
 
-    shader_target_flag = invoker.shader_target_flag
-
     shader_lib_dir = rebase_path("//flutter/impeller/compiler/shader_lib")
-    args = [
-      "--include=$shader_lib_dir",
-      "$shader_target_flag",
-    ]
+    args = [ "--include=$shader_lib_dir" ]
 
     # When we're in single invocation mode, we can't use source enumeration.
     if (!single_invocation) {
@@ -365,6 +361,10 @@ template("impellerc") {
         "--include={{source_dir}}",
         "--depfile=$depfile_intermediate_path",
       ]
+
+      if (defined(invoker.shader_target_flag)) {
+        args += [ "${invoker.shader_target_flag}" ]
+      }
     }
 
     if (defined(invoker.gles_language_version)) {
diff --git a/lib/gpu/context.cc b/lib/gpu/context.cc
@@ -22,10 +22,41 @@ void Context::SetOverrideContext(std::shared_ptr<impeller::Context> context) {
   default_context_ = std::move(context);
 }
 
-std::shared_ptr<impeller::Context> Context::GetDefaultContext() {
+std::shared_ptr<impeller::Context> Context::GetOverrideContext() {
   return default_context_;
 }
 
+std::shared_ptr<impeller::Context> Context::GetDefaultContext(
+    std::optional<std::string>& out_error) {
+  auto override_context = GetOverrideContext();
+  if (override_context) {
+    return override_context;
+  }
+
+  auto dart_state = flutter::UIDartState::Current();
+  if (!dart_state->IsImpellerEnabled()) {
+    out_error =
+        "Flutter GPU requires the Impeller rendering backend to be enabled.";
+    return nullptr;
+  }
+  // Grab the Impeller context from the IO manager.
+  std::promise<std::shared_ptr<impeller::Context>> context_promise;
+  auto impeller_context_future = context_promise.get_future();
+  fml::TaskRunner::RunNowOrPostTask(
+      dart_state->GetTaskRunners().GetIOTaskRunner(),
+      fml::MakeCopyable([promise = std::move(context_promise),
+                         io_manager = dart_state->GetIOManager()]() mutable {
+        promise.set_value(io_manager ? io_manager->GetImpellerContext()
+                                     : nullptr);
+      }));
+  auto context = impeller_context_future.get();
+
+  if (!context) {
+    out_error = "Unable to retrieve the Impeller context.";
+  }
+  return context;
+}
+
 Context::Context(std::shared_ptr<impeller::Context> context)
     : context_(std::move(context)) {}
 
@@ -43,33 +74,12 @@ std::shared_ptr<impeller::Context> Context::GetContext() {
 ///
 
 Dart_Handle InternalFlutterGpu_Context_InitializeDefault(Dart_Handle wrapper) {
-  auto dart_state = flutter::UIDartState::Current();
-
-  std::shared_ptr<impeller::Context> impeller_context =
-      flutter::gpu::Context::GetDefaultContext();
-
-  if (!impeller_context) {
-    if (!dart_state->IsImpellerEnabled()) {
-      return tonic::ToDart(
-          "Flutter GPU requires the Impeller rendering backend to be enabled.");
-    }
-
-    // Grab the Impeller context from the IO manager.
-    std::promise<std::shared_ptr<impeller::Context>> context_promise;
-    auto impeller_context_future = context_promise.get_future();
-    fml::TaskRunner::RunNowOrPostTask(
-        dart_state->GetTaskRunners().GetIOTaskRunner(),
-        fml::MakeCopyable([promise = std::move(context_promise),
-                           io_manager = dart_state->GetIOManager()]() mutable {
-          promise.set_value(io_manager ? io_manager->GetImpellerContext()
-                                       : nullptr);
-        }));
-    impeller_context = impeller_context_future.get();
+  std::optional<std::string> out_error;
+  auto impeller_context = flutter::gpu::Context::GetDefaultContext(out_error);
+  if (out_error.has_value()) {
+    return tonic::ToDart(out_error.value());
   }
 
-  if (!impeller_context) {
-    return tonic::ToDart("Unable to retrieve the Impeller context.");
-  }
   auto res = fml::MakeRefCounted<flutter::gpu::Context>(impeller_context);
   res->AssociateWithDartWrapper(wrapper);
 
diff --git a/lib/gpu/context.h b/lib/gpu/context.h
@@ -20,7 +20,10 @@ class Context : public RefCountedDartWrappable<Context> {
  public:
   static void SetOverrideContext(std::shared_ptr<impeller::Context> context);
 
-  static std::shared_ptr<impeller::Context> GetDefaultContext();
+  static std::shared_ptr<impeller::Context> GetOverrideContext();
+
+  static std::shared_ptr<impeller::Context> GetDefaultContext(
+      std::optional<std::string>& out_error);
 
   explicit Context(std::shared_ptr<impeller::Context> context);
   ~Context() override;
diff --git a/lib/gpu/shader_library.cc b/lib/gpu/shader_library.cc
diff --git a/lib/gpu/shader_library.h b/lib/gpu/shader_library.h

Original file line number	Diff line number	Diff line change
`@@ -200,7 +200,7 @@ bool Switches::AreValid(std::ostream& explain) const {`
`200`	`200`	`const bool shader_bundle_mode = !shader_bundle.empty();`
`201`	`201`
`202`	`202`	`bool valid = true;`
`203`		`- if (target_platform == TargetPlatform::kUnknown) {`
	`203`	`+ if (target_platform == TargetPlatform::kUnknown && !shader_bundle_mode) {`
`204`	`204`	`explain << "The target platform (only one) was not specified." << std::endl;`
`205`	`205`	`valid = false;`
`206`	`206`	`}`
Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,6 @@ impellerc("flutter_gpu_shaders") {`
`125`	`125`	`"flutter_gpu_texture.frag",`
`126`	`126`	`"flutter_gpu_texture.vert",`
`127`	`127`	`]`
`128`		`- shader_target_flag = "--runtime-stage-metal"`
`129`	`128`	`shader_bundle = "{\"UnlitFragment\": {\"type\": \"fragment\", \"file\": \"../../flutter/impeller/fixtures/flutter_gpu_unlit.frag\"}, \"UnlitVertex\": {\"type\": \"vertex\", \"file\": \"../../flutter/impeller/fixtures/flutter_gpu_unlit.vert\"}, \"TextureFragment\": {\"type\": \"fragment\", \"file\": \"../../flutter/impeller/fixtures/flutter_gpu_texture.frag\"}, \"TextureVertex\": {\"type\": \"vertex\", \"file\": \"../../flutter/impeller/fixtures/flutter_gpu_texture.vert\"}}"`
`130`	`129`	`shader_bundle_output = "playground.shaderbundle"`
`131`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,6 @@ flatbuffers("shader_bundle_flatbuffers") {`
`10`	`10`	`public_configs = [ "//flutter/impeller/runtime_stage:runtime_stage_config" ]`
`11`	`11`	`public_deps = [`
`12`	`12`	`"//flutter/impeller/runtime_stage:runtime_stage_flatbuffers",`
`13`		`- "//flutter/impeller/runtime_stage:runtime_stage_types_flatbuffers",`
`14`	`13`	`"//flutter/third_party/flatbuffers",`
`15`	`14`	`]`
`16`	`15`	`}`