Bundle parsing routine

impeller/compiler/shader_bundle.cc

@@ -10,68 +10,76 @@
 namespace impeller {
 namespace compiler {
 
-/// Compiles and outputs a
-bool GenerateShaderBundle(Switches& switches) {
-  auto json = nlohmann::json::parse(switches.iplr_bundle);
+static std::optional<ShaderBundleConfig> ParseShaderBundleConfig(
+    std::string& json_config) {
+  auto json = nlohmann::json::parse(json_config);
   if (!json.is_object()) {
     std::cerr << "The shader bundle must be a JSON object." << std::endl;
-    return false;
+    return std::nullopt;
   }
 
-  /// Bundle parsing.
-
-  IPLRBundleEntries bundle_entries_result;
-  for (auto& [bundle_name, bundle_value] : json.items()) {
-    if (!bundle_value.is_object()) {
-      std::cerr << "Invalid bundle entry \"" << bundle_name
+  ShaderBundleConfig bundle;
+  for (auto& [shader_name, shader_value] : json.items()) {
+    if (bundle.find(shader_name) == bundle.end()) {
+      std::cerr << "Duplicate shader \"" << shader_name << "\"." << std::endl;
+      return std::nullopt;
+    }
+    if (!shader_value.is_object()) {
+      std::cerr << "Invalid shader entry \"" << shader_name
                 << "\": Entry is not a JSON object." << std::endl;
-      return false;
+      return std::nullopt;
     }
 
-    /// Shader parsing.
+    ShaderConfig shader;
 
-    IPLRBundleEntry bundle_entry_result;
-    for (auto& [shader_name, shader_value] : bundle_value.items()) {
-      if (bundle_entry_result.find(shader_name) == bundle_entry_result.end()) {
-        std::cerr << "Duplicate shader \"" << shader_name << "\" in bundle \""
-                  << bundle_name << "\"." << std::endl;
-        return false;
-      }
-      if (!bundle_value.is_object()) {
-        std::cerr << "Invalid shader entry \"" << shader_name
-                  << "\" in bundle \"" << bundle_name
-                  << "\": Entry is not a JSON object." << std::endl;
-        return false;
-      }
+    if (!shader_value.contains("file")) {
+      std::cerr << "Invalid shader entry \"" << shader_name
+                << "\": Missing required \"file\" field. \"" << std::endl;
+      return std::nullopt;
+    }
+    shader.source_file_name = shader_value["file"];
+
+    if (!shader_value.contains("type")) {
+      std::cerr << "Invalid shader entry \"" << shader_name
+                << "\": Missing required \"type\" field. \"" << std::endl;
+      return std::nullopt;
+    }
+    shader.type = shader_value["type"];
+    if (shader.type == SourceType::kUnknown) {
+      std::cerr << "Invalid shader entry \"" << shader_name
+                << "\": Shader type \"" << shader_value["type"]
+                << "\" is unknown. \"" << std::endl;
+      return std::nullopt;
+    }
 
-      IPLRShaderEntry stage_result;
+    shader.language = shader_value.contains("language")
+                          ? ToSourceLanguage(shader_value["language"])
+                          : SourceLanguage::kGLSL;
+    if (shader.language == SourceLanguage::kUnknown) {
+      std::cerr << "Invalid shader entry \"" << shader_name
+                << "\": Unknown language type \"" << shader_value["language"]
+                << "\"." << std::endl;
+      return std::nullopt;
+    }
 
-      stage_result.language = shader_value.contains("language")
-                                  ? ToSourceLanguage(shader_value["language"])
-                                  : SourceLanguage::kGLSL;
-      if (stage_result.language == SourceLanguage::kUnknown) {
-        std::cerr << "Invalid shader entry \"" << shader_name
-                  << "\" in bundle \"" << bundle_name
-                  << "\": Unknown language type \"" << shader_value["language"]
-                  << "\"." << std::endl;
-        return false;
-      }
+    shader.entry_point = shader_value.contains("entry_point")
+                             ? shader_value["entry_point"]
+                             : "main";
 
-      if (!shader_value.contains("name")) {
-        std::cerr << "Duplicate IPLR bundle stage entry \"" << shader_name
-                  << "\" in bundle \"" << bundle_name << "\": Entry ."
-                  << std::endl;
-        return false;
-      }
-      stage_result.source_file_name = shader_value["name"];
+    bundle[shader_name] = shader;
+  }
 
-      stage_result.entry_point = shader_value.contains("entry_point")
-                                     ? shader_value["entry_point"]
-                                     : "main";
+  return bundle;
+}
 
-      bundle_entry_result[shader_name] = stage_result;
-    }
-    bundle_entries_result[bundle_name] = bundle_entry_result;
+/// Parses the given JSON shader bundle configuration and invokes the compiler
+/// multiple times to produce a shader bundle file.
+bool GenerateShaderBundle(Switches& switches) {
+  /// Parse the bundle files.
+  std::optional<ShaderBundleConfig> bundle_config =
+      ParseShaderBundleConfig(switches.iplr_bundle);
+  if (!bundle_config) {
+    return false;
   }
 
   return true;

impeller/compiler/types.cc

@@ -4,6 +4,7 @@
 
 #include "impeller/compiler/types.h"
 
+#include <cctype>
 #include <filesystem>
 #include <sstream>
 
@@ -42,6 +43,34 @@ SourceType SourceTypeFromFileName(const std::string& file_name) {
   return SourceType::kUnknown;
 }
 
+SourceType SourceTypeFromString(std::string name) {
+  for (auto it = name.begin(); it != name.end(); it++) {
+    *it = std::tolower(static_cast<unsigned char>(*it));
+  }
+
+  if (name == "vertex") {
+    return SourceType::kVertexShader;
+  }
+
+  if (name == "fragment") {
+    return SourceType::kFragmentShader;
+  }
+
+  if (name == "tessellationcontrol") {
+    return SourceType::kTessellationControlShader;
+  }
+
+  if (name == "tessellationevaluation") {
+    return SourceType::kTessellationEvaluationShader;
+  }
+
+  if (name == "compute") {
+    return SourceType::kComputeShader;
+  }
+
+  return SourceType::kUnknown;
+}
+
 SourceLanguage ToSourceLanguage(const std::string& source_language) {
   if (source_language == "glsl") {
     return SourceLanguage::kGLSL;

impeller/compiler/types.h

@@ -43,16 +43,15 @@ enum class SourceLanguage {
   kHLSL,
 };
 
-struct IPLRShaderEntry {
+/// A shader config parsed as part of a ShaderBundleConfig.
+struct ShaderConfig {
   std::string source_file_name;
   SourceType type;
   SourceLanguage language;
   std::string entry_point;
 };
 
-using IPLRBundleEntry = std::map<std::string, IPLRShaderEntry>;
-
-using IPLRBundleEntries = std::map<std::string, IPLRBundleEntry>;
+using ShaderBundleConfig = std::map<std::string, ShaderConfig>;
 
 bool TargetPlatformIsMetal(TargetPlatform platform);
 
@@ -62,6 +61,8 @@ bool TargetPlatformIsVulkan(TargetPlatform platform);
 
 SourceType SourceTypeFromFileName(const std::string& file_name);
 
+SourceType SourceTypeFromString(const std::string& name);
+
 std::string SourceTypeToString(SourceType type);
 
 std::string TargetPlatformToString(TargetPlatform platform);