Add ShaderBundleData

Author: bdero

impeller/compiler/BUILD.gn

@@ -48,6 +48,8 @@ impeller_component("compiler_lib") {
     "runtime_stage_data.h",
     "shader_bundle.cc",
     "shader_bundle.h",
+    "shader_bundle_data.cc",
+    "shader_bundle_data.h",
     "source_options.cc",
     "source_options.h",
     "spirv_compiler.cc",

impeller/compiler/reflector.cc

@@ -132,6 +132,11 @@ Reflector::Reflector(Options options,
     return;
   }
 
+  shader_bundle_data_ = GenerateShaderBundleData();
+  if (!shader_bundle_data_) {
+    return;
+  }
+
   is_valid_ = true;
 }
 
@@ -166,6 +171,10 @@ std::shared_ptr<RuntimeStageData> Reflector::GetRuntimeStageData() const {
   return runtime_stage_data_;
 }
 
+std::shared_ptr<ShaderBundleData> Reflector::GetShaderBundleData() const {
+  return shader_bundle_data_;
+}
+
 std::optional<nlohmann::json> Reflector::GenerateTemplateArguments() const {
   nlohmann::json root;
 
@@ -380,6 +389,69 @@ std::shared_ptr<RuntimeStageData> Reflector::GenerateRuntimeStageData() const {
   return data;
 }
 
+std::shared_ptr<ShaderBundleData> Reflector::GenerateShaderBundleData() const {
+  const auto& entrypoints = compiler_->get_entry_points_and_stages();
+  if (entrypoints.size() != 1u) {
+    VALIDATION_LOG << "Single entrypoint not found.";
+    return nullptr;
+  }
+  auto data = std::make_shared<ShaderBundleData>(
+      options_.entry_point_name,            //
+      entrypoints.front().execution_model,  //
+      options_.target_platform              //
+  );
+  data->SetShaderData(shader_data_);
+
+  // Sort the IR so that the uniforms are in declaration order.
+  std::vector<spirv_cross::ID> uniforms =
+      SortUniforms(ir_.get(), compiler_.GetCompiler());
+
+  for (auto& sorted_id : uniforms) {
+    auto var = ir_->ids[sorted_id].get<spirv_cross::SPIRVariable>();
+    const auto spir_type = compiler_->get_type(var.basetype);
+    UniformDescription uniform_description;
+    uniform_description.name = compiler_->get_name(var.self);
+    uniform_description.location = compiler_->get_decoration(
+        var.self, spv::Decoration::DecorationLocation);
+    uniform_description.type = spir_type.basetype;
+    uniform_description.rows = spir_type.vecsize;
+    uniform_description.columns = spir_type.columns;
+    uniform_description.bit_width = spir_type.width;
+    uniform_description.array_elements = GetArrayElements(spir_type);
+    data->AddUniformDescription(std::move(uniform_description));
+  }
+
+  // We only need to worry about storing vertex attributes.
+  if (entrypoints.front().execution_model == spv::ExecutionModelVertex) {
+    const auto inputs = compiler_->get_shader_resources().stage_inputs;
+    auto input_offsets = ComputeOffsets(inputs);
+    for (const auto& input : inputs) {
+      auto location = compiler_->get_decoration(
+          input.id, spv::Decoration::DecorationLocation);
+      std::optional<size_t> offset = input_offsets[location];
+
+      const auto type = compiler_->get_type(input.type_id);
+
+      InputDescription input_description;
+      input_description.name = input.name;
+      input_description.location = compiler_->get_decoration(
+          input.id, spv::Decoration::DecorationLocation);
+      input_description.set = compiler_->get_decoration(
+          input.id, spv::Decoration::DecorationDescriptorSet);
+      input_description.binding = compiler_->get_decoration(
+          input.id, spv::Decoration::DecorationBinding);
+      input_description.type = type.basetype;
+      input_description.bit_width = type.width;
+      input_description.vec_size = type.vecsize;
+      input_description.columns = type.columns;
+      input_description.offset = offset.value_or(0u);
+      data->AddInputDescription(std::move(input_description));
+    }
+  }
+
+  return data;
+}
+
 std::optional<uint32_t> Reflector::GetArrayElements(
     const spirv_cross::SPIRType& type) const {
   if (type.array.empty()) {

impeller/compiler/reflector.h

@@ -13,6 +13,7 @@
 #include "flutter/fml/mapping.h"
 #include "impeller/compiler/compiler_backend.h"
 #include "impeller/compiler/runtime_stage_data.h"
+#include "impeller/compiler/shader_bundle_data.h"
 #include "inja/inja.hpp"
 #include "spirv_msl.hpp"
 #include "spirv_parser.hpp"
@@ -74,6 +75,8 @@ class Reflector {
 
   std::shared_ptr<RuntimeStageData> GetRuntimeStageData() const;
 
+  std::shared_ptr<ShaderBundleData> GetShaderBundleData() const;
+
  private:
   struct StructDefinition {
     std::string name;
@@ -101,6 +104,7 @@ class Reflector {
   std::shared_ptr<fml::Mapping> reflection_header_;
   std::shared_ptr<fml::Mapping> reflection_cc_;
   std::shared_ptr<RuntimeStageData> runtime_stage_data_;
+  std::shared_ptr<ShaderBundleData> shader_bundle_data_;
   bool is_valid_ = false;
 
   std::optional<nlohmann::json> GenerateTemplateArguments() const;
@@ -111,6 +115,8 @@ class Reflector {
 
   std::shared_ptr<RuntimeStageData> GenerateRuntimeStageData() const;
 
+  std::shared_ptr<ShaderBundleData> GenerateShaderBundleData() const;
+
   std::shared_ptr<fml::Mapping> InflateTemplate(std::string_view tmpl) const;
 
   std::optional<nlohmann::json::object_t> ReflectResource(

impeller/compiler/runtime_stage_data.h

@@ -17,29 +17,6 @@
 namespace impeller {
 namespace compiler {
 
-struct UniformDescription {
-  std::string name;
-  size_t location = 0u;
-  spirv_cross::SPIRType::BaseType type = spirv_cross::SPIRType::BaseType::Float;
-  size_t rows = 0u;
-  size_t columns = 0u;
-  size_t bit_width = 0u;
-  std::optional<size_t> array_elements = std::nullopt;
-};
-
-struct InputDescription {
-  std::string name;
-  size_t location;
-  size_t set;
-  size_t binding;
-  spirv_cross::SPIRType::BaseType type =
-      spirv_cross::SPIRType::BaseType::Unknown;
-  size_t bit_width;
-  size_t vec_size;
-  size_t columns;
-  size_t offset;
-};
-
 class RuntimeStageData {
  public:
   RuntimeStageData(std::string entrypoint,

impeller/compiler/shader_bundle.cc

@@ -124,14 +124,14 @@ static std::unique_ptr<fb::RuntimeStageT> GenerateShaderBackendFB(
     return nullptr;
   }
 
-  auto stage_data = reflector->GetRuntimeStageData();
-  if (!stage_data) {
-    std::cerr << "Runtime stage information was nil for bundled shader \""
-              << shader_name << "\"." << std::endl;
+  auto bundle_data = reflector->GetShaderBundleData();
+  if (!bundle_data) {
+    std::cerr << "Bundled shader information was nil for \"" << shader_name
+              << "\"." << std::endl;
     return nullptr;
   }
 
-  result = stage_data->CreateFlatbuffer();
+  result = bundle_data->CreateFlatbuffer();
   if (!result) {
     std::cerr << "Failed to create flatbuffer for bundled shader \""
               << shader_name << "\"." << std::endl;