Add in missing flags to pass more of the spirv-cross tests (google#664)

Originally implemented in google#589

Fixes google#641
Fixes google#642
Fixes google#643
Fixes google#644
Fixes google#645
Fixes google#646
Fixes google#647
Fixes google#654
Fixes google#655
Fixes google#656
Fixes google#657

libshaderc_spvc/include/shaderc/spvc.h

@@ -27,6 +27,11 @@ extern "C" {
 #include "shaderc/status.h"
 #include "shaderc/visibility.h"
 
+typedef enum {
+  shaderc_spvc_msl_platform_ios,
+  shaderc_spvc_msl_platform_macos,
+} shaderc_spvc_msl_platform;
+
 // An opaque handle to an object that manages all compiler state.
 typedef struct shaderc_spvc_compiler* shaderc_spvc_compiler_t;
 
@@ -108,14 +113,69 @@ SHADERC_EXPORT void shaderc_spvc_compile_options_set_flatten_ubo(
 SHADERC_EXPORT void shaderc_spvc_compile_options_set_glsl_language_version(
     shaderc_spvc_compile_options_t options, uint32_t version);
 
+// If true, flatten multidimensional arrays, e.g. foo[a][b][c] -> foo[a*b*c].
+// Default is false.
+SHADERC_EXPORT void
+shaderc_spvc_compile_options_set_flatten_multidimensional_arrays(
+    shaderc_spvc_compile_options_t options, bool b);
+
+// Force interpretion as ES, or not.  Default is to detect from source.
+SHADERC_EXPORT void shaderc_spvc_compile_options_set_es(
+    shaderc_spvc_compile_options_t options, bool b);
+
+// If true, emit push constants as uniform buffer objects.  Default is false.
+SHADERC_EXPORT void
+shaderc_spvc_compile_options_set_glsl_emit_push_constant_as_ubo(
+    shaderc_spvc_compile_options_t options, bool b);
+
 // Set MSL language version.  Default is 10200 (i.e. 1.2).
 SHADERC_EXPORT void shaderc_spvc_compile_options_set_msl_language_version(
     shaderc_spvc_compile_options_t options, uint32_t version);
 
+// If true, swizzle MSL texture samples.  Default is false.
+SHADERC_EXPORT void
+shaderc_spvc_compile_options_set_msl_swizzle_texture_samples(
+    shaderc_spvc_compile_options_t options, bool b);
+
+// Choose MSL platform.  Default is MacOS.
+SHADERC_EXPORT void shaderc_spvc_compile_options_set_msl_platform(
+    shaderc_spvc_compile_options_t options, shaderc_spvc_msl_platform platform);
+
+// If true, pad MSL fragment output.  Default is false.
+SHADERC_EXPORT void shaderc_spvc_compile_options_set_msl_pad_fragment_output(
+    shaderc_spvc_compile_options_t options, bool b);
+
+// If true, capture MSL output to buffer.  Default is false.
+SHADERC_EXPORT void shaderc_spvc_compile_options_set_msl_capture(
+    shaderc_spvc_compile_options_t options, bool b);
+
+// If true, flip the Y-coord of the built-in "TessCoord."  Default is top left.
+SHADERC_EXPORT void shaderc_spvc_compile_options_set_msl_domain_lower_left(
+    shaderc_spvc_compile_options_t options, bool b);
+
+// Enable use of MSL 2.0 indirect argument buffers.  Default is not to use them.
+SHADERC_EXPORT void shaderc_spvc_compile_options_set_msl_argument_buffers(
+    shaderc_spvc_compile_options_t options, bool b);
+
+// When using MSL argument buffers, force "classic" MSL 1.0 binding for the
+// given descriptor sets. This corresponds to VK_KHR_push_descriptor in Vulkan.
+SHADERC_EXPORT void
+shaderc_spvc_compile_options_set_msl_discrete_descriptor_sets(
+    shaderc_spvc_compile_options_t options, const uint32_t* descriptors,
+    size_t num_descriptors);
+
 // Set HLSL shader model.  Default is 30.
-SHADERC_EXPORT void shaderc_spvc_compile_options_set_shader_model(
+SHADERC_EXPORT void shaderc_spvc_compile_options_set_hlsl_shader_model(
     shaderc_spvc_compile_options_t options, uint32_t model);
 
+// If true, ignore PointSize.  Default is false.
+SHADERC_EXPORT void shaderc_spvc_compile_options_set_hlsl_point_size_compat(
+    shaderc_spvc_compile_options_t options, bool b);
+
+// If true, ignore PointCoord.  Default is false.
+SHADERC_EXPORT void shaderc_spvc_compile_options_set_hlsl_point_coord_compat(
+    shaderc_spvc_compile_options_t options, bool b);
+
 // If true (default is false):
 //   GLSL: map depth from Vulkan/D3D style to GL style, i.e. [ 0,w] -> [-w,w]
 //   MSL : map depth from GL style to Vulkan/D3D style, i.e. [-w,w] -> [ 0,w]

libshaderc_spvc/include/shaderc/spvc.hpp

@@ -142,14 +142,80 @@ class CompileOptions {
     shaderc_spvc_compile_options_set_glsl_language_version(options_, version);
   }
 
+  // If true, flatten multidimensional arrays, e.g. foo[a][b][c] -> foo[a*b*c].
+  // Default is false.
+  void SetFlattenMultidimensionalArrays(bool b) {
+    shaderc_spvc_compile_options_set_flatten_multidimensional_arrays(options_,
+                                                                     b);
+  }
+
+  // Force interpretion as ES, or not.  Default is to detect from source.
+  void SetES(bool b) { shaderc_spvc_compile_options_set_es(options_, b); }
+
+  // If true, emit push constants as uniform buffer objects.  Default is false.
+  void SetGLSLEmitPushConstantAsUBO(bool b) {
+    shaderc_spvc_compile_options_set_glsl_emit_push_constant_as_ubo(options_,
+                                                                    b);
+  }
+
   // Which MSL version should be produced.  Default is 10200 (i.e. 1.2).
   void SetMSLLanguageVersion(uint32_t version) {
     shaderc_spvc_compile_options_set_msl_language_version(options_, version);
   }
 
+  // If true, swizzle MSL texture samples.  Default is false.
+  void SetMSLSwizzleTextureSamples(bool b) {
+    shaderc_spvc_compile_options_set_msl_swizzle_texture_samples(options_, b);
+  }
+
+  // Choose MSL platform.  Default is MacOS.
+  void SetMSLPlatform(shaderc_spvc_msl_platform platform) {
+    shaderc_spvc_compile_options_set_msl_platform(options_, platform);
+  }
+
+  // If true, pad MSL fragment output.  Default is false.
+  void SetMSLPadFragmentOutput(bool b) {
+    shaderc_spvc_compile_options_set_msl_pad_fragment_output(options_, b);
+  }
+
+  // If true, capture MSL output to buffer.  Default is false.
+  void SetMSLCapture(bool b) {
+    shaderc_spvc_compile_options_set_msl_capture(options_, b);
+  }
+
+  // If true, flip the Y-coord of the built-in "TessCoord."  Default is top
+  // left.
+  void SetMSLDomainLowerLeft(bool b) {
+    shaderc_spvc_compile_options_set_msl_domain_lower_left(options_, b);
+  }
+
+  // Enable use of MSL 2.0 indirect argument buffers.  Default is not to use
+  // them.
+  void SetMSLArgumentBuffers(bool b) {
+    shaderc_spvc_compile_options_set_msl_argument_buffers(options_, b);
+  }
+
+  // When using MSL argument buffers, force "classic" MSL 1.0 binding for the
+  // given descriptor sets. This corresponds to VK_KHR_push_descriptor in
+  // Vulkan.
+  void SetMSLDiscreteDescriptorSets(const std::vector<uint32_t> descriptors) {
+    shaderc_spvc_compile_options_set_msl_discrete_descriptor_sets(
+        options_, descriptors.data(), descriptors.size());
+  }
+
   // Which HLSL shader model should be used.  Default is 30.
-  void SetShaderModel(uint32_t model) {
-    shaderc_spvc_compile_options_set_shader_model(options_, model);
+  void SetHLSLShaderModel(uint32_t model) {
+    shaderc_spvc_compile_options_set_hlsl_shader_model(options_, model);
+  }
+
+  // If true, ignore PointSize.  Default is false.
+  void SetHLSLPointSizeCompat(bool b) {
+    shaderc_spvc_compile_options_set_hlsl_point_size_compat(options_, b);
+  }
+
+  // If true, ignore PointCoord.  Default is false.
+  void SetHLSLPointCoordCompat(bool b) {
+    shaderc_spvc_compile_options_set_hlsl_point_coord_compat(options_, b);
   }
 
   // If true (default is false):

libshaderc_spvc/src/spvc.cc

@@ -38,9 +38,12 @@ struct shaderc_spvc_compile_options {
   bool validate = true;
   bool remove_unused_variables = false;
   bool flatten_ubo = false;
+  bool force_es = false;
+  bool forced_es_setting = false;
   std::string entry_point;
   spv_target_env source_env = SPV_ENV_VULKAN_1_0;
   spv_target_env target_env = SPV_ENV_VULKAN_1_0;
+  std::vector<uint32_t> msl_discrete_descriptor_sets;
   spirv_cross::CompilerGLSL::Options glsl;
   spirv_cross::CompilerHLSL::Options hlsl;
   spirv_cross::CompilerMSL::Options msl;
@@ -51,8 +54,6 @@ shaderc_spvc_compile_options_t shaderc_spvc_compile_options_initialize() {
       new (std::nothrow) shaderc_spvc_compile_options;
   if (options) {
     options->glsl.version = 0;
-    options->hlsl.point_size_compat = true;
-    options->hlsl.point_coord_compat = true;
   }
   return options;
 }
@@ -140,16 +141,86 @@ void shaderc_spvc_compile_options_set_glsl_language_version(
   options->glsl.version = version;
 }
 
+void shaderc_spvc_compile_options_set_flatten_multidimensional_arrays(
+    shaderc_spvc_compile_options_t options, bool b) {
+  options->glsl.flatten_multidimensional_arrays = b;
+}
+
+void shaderc_spvc_compile_options_set_es(shaderc_spvc_compile_options_t options,
+                                         bool b) {
+  options->forced_es_setting = b;
+  options->force_es = true;
+}
+
+void shaderc_spvc_compile_options_set_glsl_emit_push_constant_as_ubo(
+    shaderc_spvc_compile_options_t options, bool b) {
+  options->glsl.emit_push_constant_as_uniform_buffer = b;
+}
+
 void shaderc_spvc_compile_options_set_msl_language_version(
     shaderc_spvc_compile_options_t options, uint32_t version) {
   options->msl.msl_version = version;
 }
 
-void shaderc_spvc_compile_options_set_shader_model(
+void shaderc_spvc_compile_options_set_msl_swizzle_texture_samples(
+    shaderc_spvc_compile_options_t options, bool b) {
+  options->msl.swizzle_texture_samples = b;
+}
+
+void shaderc_spvc_compile_options_set_msl_platform(
+    shaderc_spvc_compile_options_t options,
+    shaderc_spvc_msl_platform platform) {
+  switch (platform) {
+    case shaderc_spvc_msl_platform_ios:
+      options->msl.platform = spirv_cross::CompilerMSL::Options::iOS;
+    case shaderc_spvc_msl_platform_macos:
+      options->msl.platform = spirv_cross::CompilerMSL::Options::macOS;
+  }
+}
+
+void shaderc_spvc_compile_options_set_msl_pad_fragment_output(
+    shaderc_spvc_compile_options_t options, bool b) {
+  options->msl.pad_fragment_output_components = b;
+}
+
+void shaderc_spvc_compile_options_set_msl_capture(
+    shaderc_spvc_compile_options_t options, bool b) {
+  options->msl.capture_output_to_buffer = b;
+}
+
+void shaderc_spvc_compile_options_set_msl_domain_lower_left(
+    shaderc_spvc_compile_options_t options, bool b) {
+  options->msl.tess_domain_origin_lower_left = b;
+}
+
+void shaderc_spvc_compile_options_set_msl_argument_buffers(
+    shaderc_spvc_compile_options_t options, bool b) {
+  options->msl.argument_buffers = b;
+}
+
+void shaderc_spvc_compile_options_set_msl_discrete_descriptor_sets(
+    shaderc_spvc_compile_options_t options, const uint32_t* descriptors,
+    size_t num_descriptors) {
+  options->msl_discrete_descriptor_sets.resize(num_descriptors);
+  std::copy_n(descriptors, num_descriptors,
+              options->msl_discrete_descriptor_sets.begin());
+}
+
+void shaderc_spvc_compile_options_set_hlsl_shader_model(
     shaderc_spvc_compile_options_t options, uint32_t model) {
   options->hlsl.shader_model = model;
 }
 
+void shaderc_spvc_compile_options_set_hlsl_point_size_compat(
+    shaderc_spvc_compile_options_t options, bool b) {
+  options->hlsl.point_size_compat = b;
+}
+
+void shaderc_spvc_compile_options_set_hlsl_point_coord_compat(
+    shaderc_spvc_compile_options_t options, bool b) {
+  options->hlsl.point_coord_compat = b;
+}
+
 void shaderc_spvc_compile_options_set_fixup_clipspace(
     shaderc_spvc_compile_options_t options, bool b) {
   options->glsl.vertex.fixup_clipspace = b;
@@ -325,6 +396,9 @@ shaderc_spvc_compilation_result_t shaderc_spvc_compile_into_glsl(
       }
     }
 
+    // Override detected setting, if any.
+    if (options->force_es) options->glsl.es = options->forced_es_setting;
+
     auto entry_points = compiler->get_entry_points_and_stages();
     spv::ExecutionModel model = spv::ExecutionModelMax;
     if (!options->entry_point.empty()) {
@@ -428,6 +502,9 @@ shaderc_spvc_compilation_result_t shaderc_spvc_compile_into_msl(
         new (std::nothrow) spirv_cross::CompilerMSL(source, source_len));
     if (!compiler) return std::make_tuple(nullptr, nullptr);
     compiler->set_common_options(options->glsl);
+    compiler->set_msl_options(options->msl);
+    for (auto i : options->msl_discrete_descriptor_sets)
+      compiler->add_discrete_descriptor_set(i);
     return std::make_tuple(nullptr, compiler.release());
   };
   return validate_and_compile(builder, source, source_len, options);

spvc/src/main.cc

@@ -72,6 +72,18 @@ An input file of - represents standard input.
   --vulkan-semantics
   --separate-shader-objects
   --flatten-ubo
+  --flatten-multidimensional-arrays
+  --es
+  --no-es
+  --glsl-emit-push-constant-as-ubo
+  --msl-swizzle-texture-samples
+  --msl-platform=ios|macos
+  --msl-pad-fragment-output
+  --msl-capture-output
+  --msl-domain-lower-left
+  --msl-argument-buffers
+  --msl-discrete-descriptor-set=<number>
+  --hlsl-enable-compat
   --shader-model=<model>
 )";
 }
@@ -157,6 +169,7 @@ int main(int argc, char** argv) {
   shaderc_spvc::Compiler compiler;
   shaderc_spvc::CompileOptions options;
   std::vector<uint32_t> input;
+  std::vector<uint32_t> msl_discrete_descriptor;
   string_piece output_path;
   string_piece output_language;
   string_piece source_env = "vulkan1.0";
@@ -220,13 +233,49 @@ int main(int argc, char** argv) {
     } else if (arg == "--flatten-ubo") {
       options.SetFlattenUbo(true);
     } else if (arg == "--flatten-multidimensional-arrays") {
-      // TODO(fjhenigman)
+      options.SetFlattenMultidimensionalArrays(true);
     } else if (arg == "--es") {
-      // TODO(fjhenigman)
+      options.SetES(true);
+    } else if (arg == "--no-es") {
+      options.SetES(false);
     } else if (arg == "--hlsl-enable-compat") {
-      // TODO(fjhenigman)
+      options.SetHLSLPointSizeCompat(true);
+      options.SetHLSLPointCoordCompat(true);
     } else if (arg == "--glsl-emit-push-constant-as-ubo") {
-      // TODO(fjhenigman)
+      options.SetGLSLEmitPushConstantAsUBO(true);
+    } else if (arg == "--msl-swizzle-texture-samples") {
+      options.SetMSLSwizzleTextureSamples(true);
+    } else if (arg.starts_with("--msl-platform=")) {
+      string_piece platform;
+      GetOptionArgument(argc, argv, &i, "--msl-platform=", &platform);
+      if (platform == "ios") {
+        options.SetMSLPlatform(shaderc_spvc_msl_platform_ios);
+      } else if (platform == "macos") {
+        options.SetMSLPlatform(shaderc_spvc_msl_platform_macos);
+      } else {
+        std::cerr << "spvc: error: invalid value '" << platform
+                  << "' in --msl-platform=" << std::endl;
+        return 1;
+      }
+    } else if (arg == "--msl-pad-fragment-output") {
+      options.SetMSLPadFragmentOutput(true);
+    } else if (arg == "--msl-capture-output") {
+      options.SetMSLCapture(true);
+    } else if (arg == "--msl-domain-lower-left") {
+      options.SetMSLDomainLowerLeft(true);
+    } else if (arg == "--msl-argument-buffers") {
+      options.SetMSLArgumentBuffers(true);
+    } else if (arg.starts_with("--msl-discrete-descriptor-set=")) {
+      string_piece descriptor_str;
+      GetOptionArgument(argc, argv, &i,
+                        "--msl-discrete-descriptor-set=", &descriptor_str);
+      uint32_t descriptor_num;
+      if (!ParseUint32(descriptor_str.str(), &descriptor_num)) {
+        std::cerr << "spvc: error: invalid value '" << descriptor_str
+                  << "' in --msl-discrete-descriptor-set=" << std::endl;
+        return 1;
+      }
+      msl_discrete_descriptor.push_back(descriptor_num);
     } else if (arg.starts_with("--shader-model=")) {
       string_piece shader_model_str;
       GetOptionArgument(argc, argv, &i, "--shader-model=", &shader_model_str);
@@ -236,7 +285,7 @@ int main(int argc, char** argv) {
                   << "' in --shader-model=" << std::endl;
         return 1;
       }
-      options.SetShaderModel(shader_model_num);
+      options.SetHLSLShaderModel(shader_model_num);
     } else if (arg.starts_with("--source-env=")) {
       string_piece env;
       GetOptionArgument(argc, argv, &i, "--source-env=", &env);
@@ -299,6 +348,8 @@ int main(int argc, char** argv) {
     }
   }
 
+  options.SetMSLDiscreteDescriptorSets(msl_discrete_descriptor);
+
   shaderc_spvc::CompilationResult result;
   if (output_language == "glsl") {
     result = compiler.CompileSpvToGlsl((const uint32_t*)input.data(),