Merge pull request #3450 from beersandrew/validation-usdUtils-MissingReferenceValidator

usdValidation: usdUtils: MissingReferenceValidator

(Internal change: 2352292)

Author: pixar-oss

pxr/usdValidation/bin/usdchecker/testenv/testUsdChecker/baseline/arkitRules_validationFramework.txt

@@ -62,6 +62,10 @@
 	Doc: Only valid core layer extensions (.usd, .usda, .usdc, .usdz), valid core texture extensions (.exr, .jpg, .jpeg, .png) and embedded audio files (.M4A, .MP3, .WAV) are allowed in a package.
 	Keywords: UsdUtilsValidators, UsdzValidators
 	isSuite: False
+[usdUtilsValidators:MissingReferenceValidator]:
+	Doc: The composed USD stage should not contain any unresolvable asset dependencies (in every possible variation of the asset), when using the default asset resolver.
+	Keywords: UsdUtilsValidators
+	isSuite: False
 [usdUtilsValidators:PackageEncapsulationValidator]:
 	Doc: If the root layer is a package, then its recommended for the composed stage to not contain references to files outside the package. The package should be self-contained, warn if not.
 	Keywords: UsdUtilsValidators, UsdzValidators

pxr/usdValidation/bin/usdchecker/testenv/testUsdChecker/baseline/baseRules_validationFramework.txt

@@ -58,6 +58,10 @@
 	Keywords: UsdSkelValidators
 	SchemaTypes: UsdSkelBindingAPI
 	isSuite: False
+[usdUtilsValidators:MissingReferenceValidator]:
+	Doc: The composed USD stage should not contain any unresolvable asset dependencies (in every possible variation of the asset), when using the default asset resolver.
+	Keywords: UsdUtilsValidators
+	isSuite: False
 [usdValidation:CompositionErrorTest]:
 	Doc: Validator aims at providing all composition errors, which were generated while composing the stage.
 	Keywords: UsdCoreValidators

pxr/usdValidation/usdUtilsValidators/CMakeLists.txt

@@ -30,6 +30,8 @@ pxr_build_test(testUsdUtilsValidators
         tf
         sdf
         usd
+        usdGeom
+        usdShade
         usdValidation
         usdUtils
         usdUtilsValidators

pxr/usdValidation/usdUtilsValidators/plugInfo.json

@@ -9,6 +9,9 @@
                             "UsdzValidators"
                         ]
                     },
+                    "MissingReferenceValidator": {
+                        "doc": "The composed USD stage should not contain any unresolvable asset dependencies (in every possible variation of the asset), when using the default asset resolver."
+                    },
                     "PackageEncapsulationValidator": {
                         "doc": "If the root layer is a package, then its recommended for the composed stage to not contain references to files outside the package. The package should be self-contained, warn if not.", 
                         "keywords": [

pxr/usdValidation/usdUtilsValidators/testenv/testUsdUtilsValidators.cpp

@@ -7,6 +7,10 @@
 
 #include "pxr/base/arch/systemInfo.h"
 #include "pxr/base/tf/pathUtils.h"
+#include "pxr/usd/usd/editContext.h"
+#include "pxr/usd/usd/variantSets.h"
+#include "pxr/usd/usdShade/shader.h"
+#include "pxr/usd/usdGeom/tokens.h"
 #include "pxr/usdValidation/usdUtilsValidators/validatorTokens.h"
 #include "pxr/usdValidation/usdValidation/error.h"
 #include "pxr/usdValidation/usdValidation/registry.h"
@@ -30,18 +34,19 @@ TestUsdUsdzValidators()
     UsdValidationValidatorMetadataVector metadata
         = registry.GetValidatorMetadataForPlugin(
             _tokens->usdUtilsValidatorsPlugin);
-    TF_AXIOM(metadata.size() == 2);
+    TF_AXIOM(metadata.size() == 3);
     // Since other validators can be registered with a UsdUtilsValidators
     // keyword, our validators registered in usd are a subset of the entire
     // set.
     std::set<TfToken> validatorMetadataNameSet;
-    for (const UsdValidationValidatorMetadata &metadata : metadata) {
-        validatorMetadataNameSet.insert(metadata.name);
+    for (const UsdValidationValidatorMetadata &m : metadata) {
+        validatorMetadataNameSet.insert(m.name);
     }
 
     const std::set<TfToken> expectedValidatorNames
         = { UsdUtilsValidatorNameTokens->packageEncapsulationValidator,
-            UsdUtilsValidatorNameTokens->fileExtensionValidator };
+            UsdUtilsValidatorNameTokens->fileExtensionValidator, 
+            UsdUtilsValidatorNameTokens->missingReferenceValidator };
 
     TF_AXIOM(validatorMetadataNameSet == expectedValidatorNames);
 }
@@ -90,7 +95,7 @@ TestPackageEncapsulationValidator()
         const std::string realUsdzPath = rootLayer->GetRealPath();
         const std::string errorLayer
             = TfStringCatPaths(TfGetPathName(TfAbsPath(rootLayerIdentifier)),
-                               "excludedDirectory/layer.usda");
+                    "excludedDirectory/layer.usda");
 
         std::filesystem::path parentDir
             = std::filesystem::path(realUsdzPath).parent_path();
@@ -99,22 +104,22 @@ TestPackageEncapsulationValidator()
 
         std::array<std::string, 2> expectedErrorMessages
             = { TfStringPrintf(("Found referenced layer '%s' that does not "
-                                "belong to the package '%s'."),
-                               errorLayer.c_str(), realUsdzPath.c_str()),
+                        "belong to the package '%s'."),
+                    errorLayer.c_str(), realUsdzPath.c_str()),
                 TfStringPrintf(("Found asset reference '%s' that does not belong"
-                                " to the package '%s'."),
-                               errorAsset.c_str(), realUsdzPath.c_str()) };
+                            " to the package '%s'."),
+                        errorAsset.c_str(), realUsdzPath.c_str()) };
 
         std::array<TfToken, 2> expectedErrorIdentifiers = {
             TfToken(
-                "usdUtilsValidators:PackageEncapsulationValidator.LayerNotInPackage"),
+                    "usdUtilsValidators:PackageEncapsulationValidator.LayerNotInPackage"),
             TfToken(
-                "usdUtilsValidators:PackageEncapsulationValidator.AssetNotInPackage")
+                    "usdUtilsValidators:PackageEncapsulationValidator.AssetNotInPackage")
         };
 
         for (size_t i = 0; i < errors.size(); ++i) {
             ValidateError(errors[i], expectedErrorMessages[i],
-                expectedErrorIdentifiers[i], UsdValidationErrorType::Warn);
+                    expectedErrorIdentifiers[i], UsdValidationErrorType::Warn);
         }
     }
 
@@ -160,12 +165,114 @@ TestFileExtensionValidator()
     TF_AXIOM(errors.empty());
 }
 
+static void
+TestMissingReferenceValidator()
+{
+    UsdValidationRegistry& registry = UsdValidationRegistry::GetInstance();
+
+    // Verify the validator exists
+    const UsdValidationValidator *validator = registry.GetOrLoadValidatorByName(
+            UsdUtilsValidatorNameTokens->missingReferenceValidator);
+
+    TF_AXIOM(validator);
+
+    const UsdStageRefPtr& stage = UsdStage::CreateInMemory();
+
+    const UsdPrim xform = stage->DefinePrim(SdfPath("/Prim"), 
+                                            UsdGeomTokens->Xform);
+    const SdfReference badLayerReference("doesNotExist.usd");
+    xform.GetReferences().AddReference(badLayerReference);
+
+    // Validate an error occurs for a missing layer reference
+    {
+        const UsdValidationErrorVector errors = validator->Validate(stage);
+        TF_AXIOM(errors.size() == 1);
+        const std::string expectedErrorMessage = "Found unresolvable external "
+                                                 "dependency 'doesNotExist.usd'.";
+        const TfToken expectedIdentifier =
+            TfToken(
+            "usdUtilsValidators:MissingReferenceValidator.UnresolvableDependency");
+
+        ValidateError(errors[0], expectedErrorMessage,
+                expectedIdentifier);
+    }
+
+    // Remove the bad layer reference and add a shader prim for the next test
+    xform.GetReferences().RemoveReference(badLayerReference);
+    UsdShadeShader shader = UsdShadeShader::Define(stage,
+        SdfPath("/Prim/Shader"));
+    const TfToken notFoundAsset("notFoundAsset");
+    UsdShadeInput notFoundAssetInput = shader.CreateInput(
+        notFoundAsset, SdfValueTypeNames->Asset);
+    notFoundAssetInput.Set(SdfAssetPath("doesNotExist.jpg"));
+
+    // Validate an error occurs for a missing asset reference
+    {
+        const UsdValidationErrorVector errors = validator->Validate(stage);
+        TF_AXIOM(errors.size() == 1);
+        const std::string expectedErrorMessage = "Found unresolvable external "
+            "dependency 'doesNotExist.jpg'.";
+        const TfToken expectedIdentifier =
+            TfToken(
+            "usdUtilsValidators:MissingReferenceValidator.UnresolvableDependency");
+
+        ValidateError(errors[0], expectedErrorMessage,
+                expectedIdentifier);
+    }
+
+    // Remove shader prim and add a variant set for the next test
+    stage->RemovePrim(shader.GetPath());
+    UsdVariantSets variantSets = xform.GetVariantSets();
+    UsdVariantSet testVariantSet = variantSets.AddVariantSet("testVariantSet");
+
+    testVariantSet.AddVariant("invalid");
+    testVariantSet.AddVariant("valid");
+
+    testVariantSet.SetVariantSelection("invalid");
+
+    {
+        UsdEditContext context(testVariantSet.GetVariantEditContext());
+        UsdShadeShader s = UsdShadeShader::Define(
+            stage, xform.GetPath().AppendChild(TfToken("Shader")));
+        UsdShadeInput invalidAssetInput = s.CreateInput(
+            TfToken("invalidAsset"), SdfValueTypeNames->Asset);
+        invalidAssetInput.Set(SdfAssetPath("doesNotExistOnVariant.jpg"));
+    }
+    testVariantSet.SetVariantSelection("valid");
+
+    // Validate an error occurs on a nonexistent asset on an inactive variant
+    {
+        const UsdValidationErrorVector errors = validator->Validate(stage);
+        TF_AXIOM(errors.size() == 1);
+        const std::string expectedErrorMessage = 
+            "Found unresolvable external dependency "
+            "'doesNotExistOnVariant.jpg'.";
+        const TfToken expectedIdentifier =
+            TfToken(
+            "usdUtilsValidators:MissingReferenceValidator.UnresolvableDependency");
+
+        ValidateError(errors[0], expectedErrorMessage,
+                expectedIdentifier);
+    }
+
+    // Remove the variant set and add a valid reference
+    SdfPrimSpecHandle primSpec = 
+        stage->GetRootLayer()->GetPrimAtPath(xform.GetPath());
+    primSpec->RemoveVariantSet("testVariantSet");
+    xform.GetPrim().GetReferences().AddReference("pass.usdz");
+
+    const UsdValidationErrorVector errors = validator->Validate(stage);
+
+    TF_AXIOM(errors.empty());
+}
+
 int
 main()
 {
     TestUsdUsdzValidators();
     TestPackageEncapsulationValidator();
     TestFileExtensionValidator();
+    TestMissingReferenceValidator();
 
     return EXIT_SUCCESS;
 }

pxr/usdValidation/usdUtilsValidators/validatorTokens.h

@@ -20,7 +20,9 @@ PXR_NAMESPACE_OPEN_SCOPE
     ((packageEncapsulationValidator,                                           \
       "usdUtilsValidators:PackageEncapsulationValidator"))                     \
     ((fileExtensionValidator,                                                  \
-      "usdUtilsValidators:FileExtensionValidator"))
+      "usdUtilsValidators:FileExtensionValidator"))                            \
+    ((missingReferenceValidator,                                               \
+      "usdUtilsValidators:MissingReferenceValidator"))                         \
 
 #define USD_UTILS_VALIDATOR_KEYWORD_TOKENS                                     \
     (UsdUtilsValidators)                                                       \
@@ -31,7 +33,8 @@ PXR_NAMESPACE_OPEN_SCOPE
     ((assetNotInPackage, "AssetNotInPackage"))                                 \
     ((invalidLayerInPackage, "InvalidLayerInPackage"))                         \
     ((unsupportedFileExtensionInPackage,                                       \
-        "UnsupportedFileExtensionInPackage"))
+        "UnsupportedFileExtensionInPackage"))                                  \
+    ((unresolvableDependency, "UnresolvableDependency"))
 
 ///\def
 /// Tokens representing validator names. Note that for plugin provided

pxr/usdValidation/usdUtilsValidators/validators.cpp

@@ -17,6 +17,8 @@
 
 #include "pxr/usd/sdf/fileFormat.h"
 
+#include <string>
+
 PXR_NAMESPACE_OPEN_SCOPE
 
 static UsdValidationErrorVector
@@ -37,7 +39,7 @@ _PackageEncapsulationValidator(
     }
 
     SdfLayerRefPtrVector layers;
-    std::vector<std::basic_string<char>> assets, unresolvedPaths;
+    std::vector<std::string> assets, unresolvedPaths;
     const SdfAssetPath &path = SdfAssetPath(rootLayer->GetIdentifier());
 
     UsdUtilsComputeAllDependencies(path, &layers, &assets, &unresolvedPaths,
@@ -62,15 +64,15 @@ _PackageEncapsulationValidator(
                     "a valid layer to be bundled in a package.");
                 continue;
             }
-            const std::string &realPath = referencedLayer->GetRealPath();
+            const std::string &refRealPath = referencedLayer->GetRealPath();
 
             // We don't want to validate in-memory or session layers
             // since these layers will not have a real path, we skip here
-            if (realPath.empty()) {
+            if (refRealPath.empty()) {
                 continue;
             }
 
-            if (!TfStringStartsWith(realPath, packagePath)) {
+            if (!TfStringStartsWith(refRealPath, packagePath)) {
                 errors.emplace_back(
                     UsdUtilsValidationErrorNameTokens->layerNotInPackage,
                     UsdValidationErrorType::Warn,
@@ -148,6 +150,39 @@ _FileExtensionValidator(const UsdStagePtr& usdStage,
     return errors;
 }
 
+static
+UsdValidationErrorVector
+_MissingReferenceValidator(const UsdStagePtr& usdStage,
+                           const UsdValidationTimeRange &/*timeRange*/) 
+{
+    const SdfLayerRefPtr& rootLayer = usdStage->GetRootLayer();
+
+    SdfLayerRefPtrVector layers;
+    std::vector<std::string> unresolvedPaths;
+    const SdfAssetPath& path = SdfAssetPath(rootLayer->GetIdentifier());
+
+    UsdUtilsComputeAllDependencies(path, &layers, nullptr /*assets*/, 
+                                   &unresolvedPaths, nullptr);
+
+    UsdValidationErrorVector errors;
+    for(const std::string &unresolvedPath : unresolvedPaths)
+    {
+        errors.emplace_back(
+            UsdUtilsValidationErrorNameTokens->unresolvableDependency,
+            UsdValidationErrorType::Error,
+            UsdValidationErrorSites {
+                UsdValidationErrorSite(
+                    rootLayer, SdfPath(unresolvedPath))
+            },
+            TfStringPrintf(
+            ("Found unresolvable external dependency "
+                "'%s'."), unresolvedPath.c_str())
+        );
+    }
+
+    return errors;
+}
+
 TF_REGISTRY_FUNCTION(UsdValidationRegistry)
 {
     UsdValidationRegistry &registry = UsdValidationRegistry::GetInstance();
@@ -159,6 +194,11 @@ TF_REGISTRY_FUNCTION(UsdValidationRegistry)
     registry.RegisterPluginValidator(
         UsdUtilsValidatorNameTokens->fileExtensionValidator,
         _FileExtensionValidator);
+
+    registry.RegisterPluginValidator(
+       UsdUtilsValidatorNameTokens->missingReferenceValidator, 
+        _MissingReferenceValidator);
+
 }
 
 PXR_NAMESPACE_CLOSE_SCOPE