Add option to skip glTF validation

Author: pablode

src/guc/main.c

@@ -47,6 +47,13 @@ static struct cag_option cmd_options[] = {
     .value_name = "<index>",
     .description = "Index of the material variant that is selected by default"
   },
+  {
+    .identifier = 's',
+    .access_letters = "s",
+    .access_name = "skip-validation",
+    .value_name = NULL,
+    .description = "Skip glTF validation for reduced processing time"
+  },
   {
     .identifier = 'l',
     .access_letters = "l",
@@ -60,15 +67,16 @@ static struct cag_option cmd_options[] = {
     .access_name = "help",
     .value_name = NULL,
     .description = "Show the command help"
-  }
+  },
 };
 
 int main(int argc, char* argv[])
 {
   struct guc_options options = {
     .emit_mtlx = false,
     .mtlx_as_usdshade = false,
-    .default_material_variant = 0
+    .default_material_variant = 0,
+    .skip_validation = false
   };
 
   cag_option_context context;
@@ -88,6 +96,9 @@ int main(int argc, char* argv[])
       options.default_material_variant = atoi(value); // fall back to 0 on error
       break;
     }
+    case 's':
+      options.skip_validation = true;
+      break;
     case 'l': {
       printf("%s\n", license_text);
       return EXIT_SUCCESS;

src/libguc/include/guc.h

@@ -40,6 +40,10 @@ struct guc_options
   // If the asset supports the KHR_materials_variants extension, select the material
   // variant at the given index by default.
   int default_material_variant;
+
+  // If set to true, don't validate the glTF data model on load. This reduces the
+  // processing time at the cost of stability and security.
+  bool skip_validation;
 };
 
 bool guc_convert(const char* gltf_path,

src/libguc/src/cgltf_util.cpp

@@ -418,7 +418,7 @@ namespace detail
 
 namespace guc
 {
-  bool load_gltf(const char* gltfPath, cgltf_data** data)
+  bool load_gltf(const char* gltfPath, cgltf_data** data, bool validate)
   {
     detail::BufferHolder* bufferHolder = new detail::BufferHolder;
 
@@ -448,13 +448,16 @@ namespace guc
       return false;
     }
 
-    result = cgltf_validate(*data);
-
-    if (result != cgltf_result_success)
+    if (validate)
     {
-      TF_RUNTIME_ERROR("unable to validate glTF: %s", cgltf_error_string(result));
-      free_gltf(*data);
-      return false;
+      result = cgltf_validate(*data);
+
+      if (result != cgltf_result_success)
+      {
+        TF_RUNTIME_ERROR("unable to validate glTF: %s", cgltf_error_string(result));
+        free_gltf(*data);
+        return false;
+      }
     }
 
     bool meshoptCompressionRequired = false;

src/libguc/src/cgltf_util.h

@@ -20,7 +20,7 @@
 
 namespace guc
 {
-  bool load_gltf(const char* gltfPath, cgltf_data** data);
+  bool load_gltf(const char* gltfPath, cgltf_data** data, bool validate);
 
   void free_gltf(cgltf_data* data);
 

src/libguc/src/fileFormat.cpp

@@ -51,6 +51,7 @@ TF_DEFINE_PRIVATE_TOKENS(
   (gltf)
   (glb)
   (emitMtlx)
+  (skipValidation)
 );
 
 TF_REGISTRY_FUNCTION(TfType)
@@ -110,6 +111,11 @@ SdfAbstractDataRefPtr UsdGlTFFileFormat::InitData(const FileFormatArguments& arg
   {
     data->emitMtlx = TfUnstringify<bool>(emitMtlxIt->second);
   }
+  auto skipValidationIt = args.find(_tokens->skipValidation.GetText());
+  if (skipValidationIt != args.end())
+  {
+    data->skipValidation = TfUnstringify<bool>(skipValidationIt->second);
+  }
 
   return data;
 }
@@ -131,16 +137,18 @@ bool UsdGlTFFileFormat::Read(SdfLayer* layer,
   ArDefaultResolverContext ctx({srcDir.string()});
   ArResolverContextBinder binder(ctx);
 
+  SdfAbstractDataRefPtr layerData = InitData(layer->GetFileFormatArguments());
+  UsdGlTFDataConstPtr data = TfDynamic_cast<const UsdGlTFDataConstPtr>(layerData);
+
+  bool validateGltf = !data->skipValidation;
+
   cgltf_data* gltf_data = nullptr;
-  if (!load_gltf(resolvedPath.c_str(), &gltf_data))
+  if (!load_gltf(resolvedPath.c_str(), &gltf_data, validateGltf))
   {
     TF_RUNTIME_ERROR("unable to load glTF file %s", resolvedPath.c_str());
     return false;
   }
 
-  SdfAbstractDataRefPtr layerData = InitData(layer->GetFileFormatArguments());
-  UsdGlTFDataConstPtr data = TfDynamic_cast<const UsdGlTFDataConstPtr>(layerData);
-
   Converter::Params params = {};
   params.srcDir = srcDir;
   params.dstDir = s_tmpDirHolder.makeDir();
@@ -208,10 +216,15 @@ void UsdGlTFFileFormat::ComposeFieldsForFileFormatArguments(const std::string& a
                                                             FileFormatArguments* args,
                                                             VtValue *dependencyContextData) const
 {
-  VtValue emitMtlxValue;
-  if (context.ComposeValue(_tokens->emitMtlx, &emitMtlxValue))
+  VtValue emitMtlx;
+  if (context.ComposeValue(_tokens->emitMtlx, &emitMtlx))
+  {
+    (*args)[_tokens->emitMtlx] = TfStringify(emitMtlx);
+  }
+  VtValue skipValidation;
+  if (context.ComposeValue(_tokens->skipValidation, &skipValidation))
   {
-    (*args)[_tokens->emitMtlx] = TfStringify(emitMtlxValue);
+    (*args)[_tokens->skipValidation] = TfStringify(skipValidation);
   }
 }
 

src/libguc/src/fileFormat.h

@@ -77,6 +77,7 @@ class UsdGlTFData : public SdfData
 {
 public:
   bool emitMtlx = false;
+  bool skipValidation = false;
 };
 
 PXR_NAMESPACE_CLOSE_SCOPE

src/libguc/src/guc.cpp

@@ -89,9 +89,9 @@ bool guc_convert(const char* gltf_path,
   fs::path base_usd_path = usd_path;
   fs::path dst_dir = base_usd_path.parent_path();
 
-  bool export_usdz = base_usd_path.extension() == ".usdz";
+  bool exportUsdz = base_usd_path.extension() == ".usdz";
 
-  if (export_usdz)
+  if (exportUsdz)
   {
     dst_dir = ArchMakeTmpSubdir(ArchGetTmpDir(), "guc");
     TF_DEBUG(GUC).Msg("using temp dir %s\n", dst_dir.string().c_str());
@@ -107,14 +107,16 @@ bool guc_convert(const char* gltf_path,
     TF_DEBUG(GUC).Msg("temporary USD path: %s\n", base_usd_path.string().c_str());
   }
 
+  bool validateGltf = !options->skip_validation;
+
   cgltf_data* gltf_data = nullptr;
-  if (!load_gltf(gltf_path, &gltf_data))
+  if (!load_gltf(gltf_path, &gltf_data, validateGltf))
   {
     TF_RUNTIME_ERROR("unable to load glTF file %s", gltf_path);
     return false;
   }
 
-  bool copyExistingFiles = !export_usdz; // Add source files directly to archive in case of USDZ
+  bool copyExistingFiles = !exportUsdz; // Add source files directly to archive in case of USDZ
 
   Converter::FileExports fileExports;
   bool result = convertToUsd(src_dir, gltf_data, base_usd_path, copyExistingFiles, options, fileExports);
@@ -128,7 +130,7 @@ bool guc_convert(const char* gltf_path,
 
   // In case of USDZ, we have now written the USDC file and all image files to a
   // temporary directory. Next, we invoke Pixar's USDZ API in order to zip them.
-  if (export_usdz)
+  if (exportUsdz)
   {
     auto usdz_dst_dir = fs::absolute(final_usd_path).parent_path();
     if (!fs::exists(usdz_dst_dir) && !fs::create_directories(usdz_dst_dir))