static void _AddSchema(SdfLayerRefPtr const &source, SdfLayerRefPtr const &target, std::vector<TfToken> const &disallowedFields) { for (SdfPrimSpecHandle const &prim: source->GetRootPrims()) { if (!target->GetPrimAtPath(prim->GetPath())) { SdfPrimSpecHandle newPrim = SdfPrimSpec::New(target, prim->GetName(), prim->GetSpecifier(), prim->GetTypeName()); _CopySpec(prim, newPrim, disallowedFields); for (SdfAttributeSpecHandle const &attr: prim->GetAttributes()) { SdfAttributeSpecHandle newAttr = SdfAttributeSpec::New( newPrim, attr->GetName(), attr->GetTypeName(), attr->GetVariability(), attr->IsCustom()); _CopySpec(attr, newAttr, disallowedFields); } for (SdfRelationshipSpecHandle const &rel: prim->GetRelationships()) { SdfRelationshipSpecHandle newRel = SdfRelationshipSpec::New( newPrim, rel->GetName(), rel->IsCustom()); _CopySpec(rel, newRel, disallowedFields); } } } }
bool UsdUtilsStitchClips(const SdfLayerHandle& resultLayer, const _ClipFileVector& clipLayerFiles, const SdfPath& clipPath, const double startTimeCode, const double endTimeCode, const TfToken& clipSet) { // XXX: See comment in UsdUtilsStitchClipsTopology above. TF_PY_ALLOW_THREADS_IN_SCOPE(); // Prepare result layer for editing if (!_LayerIsWritable(resultLayer)) { return false; } else { resultLayer->Clear(); } // Prepare topology layer for editing, create if necessary bool topologyPreExisting = true; std::string topologyLayerId = UsdUtilsGenerateClipTopologyName(resultLayer->GetIdentifier()); SdfLayerRefPtr topologyLayer = SdfLayer::FindOrOpen(topologyLayerId); if (!topologyLayer) { topologyPreExisting = false; topologyLayer = SdfLayer::CreateNew(topologyLayerId); } if (!_LayerIsWritable(topologyLayer)) { return false; } else { topologyLayer->Clear(); } // Open all clip layers and validate clipPath SdfLayerRefPtrVector clipLayers; const bool clipLayersAreValid = _OpenClipLayers(&clipLayers, clipLayerFiles, clipPath); if (!clipLayersAreValid || !_UsdUtilsStitchClipsImpl(resultLayer, topologyLayer, clipLayers, clipPath, startTimeCode, endTimeCode, clipSet)) { if (!topologyPreExisting) { TfDeleteFile(topologyLayer->GetIdentifier()); } return false; } // Note that we don't apply edits until all other // actions have completed. topologyLayer->Save(); resultLayer->Save(); return true; }
// XXX: i don't even know if it's important to distinguish where // these asset paths are coming from.. if it's not important, maybe this // should just go into Sdf's _GatherPrimAssetReferences? if it is important, // we could also have another function that takes 3 vectors. static void _ExtractDependenciesForBinary( const std::string& filePath, std::vector<std::string>* sublayers, std::vector<std::string>* references, std::vector<std::string>* payloads) { TRACE_FUNCTION(); SdfLayerRefPtr layer = SdfLayer::OpenAsAnonymous(filePath); if (not TF_VERIFY(layer)) return; *sublayers = layer->GetSubLayerPaths(); std::stack<SdfPrimSpecHandle> dfs; dfs.push(layer->GetPseudoRoot()); while (not dfs.empty()) { SdfPrimSpecHandle curr = dfs.top(); dfs.pop(); if (curr != layer->GetPseudoRoot()) { // references const SdfReferencesProxy refList = curr->GetReferenceList(); for (const SdfReference& ref : refList.GetAddedOrExplicitItems()) { _AppendAssetPathIfNotEmpty(ref, references); } // payloads if (curr->HasPayload()) { const SdfPayload payload = curr->GetPayload(); _AppendAssetPathIfNotEmpty(payload, payloads); } // attributes // // XXX:2016-04-14 Note that we use the field access API // here rather than calling GetAttributes, as creating specs for // large numbers of attributes, most of which are *not* asset // path-valued and therefore not useful here, is expensive. // const VtValue propertyNames = curr->GetField(SdfChildrenKeys->PropertyChildren); if (propertyNames.IsHolding<vector<TfToken>>()) { for (const auto& name : propertyNames.UncheckedGet<vector<TfToken>>()) { const SdfPath path = curr->GetPath().AppendProperty(name); const VtValue vtTypeName = layer->GetField( path, SdfFieldKeys->TypeName); if (not vtTypeName.IsHolding<TfToken>()) continue; const TfToken typeName = vtTypeName.UncheckedGet<TfToken>(); if (typeName == SdfValueTypeNames->Asset or typeName == SdfValueTypeNames->AssetArray) { _AppendAssetValue(layer->GetField( path, SdfFieldKeys->Default), references); } } } // meta data for (const TfToken& infoKey : curr->GetMetaDataInfoKeys()) { _AppendAssetValue(curr->GetInfo(infoKey), references); } } // variants "children" for (const SdfVariantSetsProxy::value_type& p : curr->GetVariantSets()) { for (const SdfVariantSpecHandle& variantSpec : p.second->GetVariantList()) { dfs.push(variantSpec->GetPrimSpec()); } } // children for (const SdfPrimSpecHandle& child : curr->GetNameChildren()) { dfs.push(child); } } }
PXR_NAMESPACE_USING_DIRECTIVE void TestTemplates() { // --------------------------------------------------------------------- // // This test operates on /RootPrim.foo // and /RootPrim.foo:hidden // --------------------------------------------------------------------- // SdfPath primPath("/RootPrim"); TfToken prop("foo"); TfToken metaField("hidden"); std::string propPath(primPath.GetString() + "." + prop.GetString()); // --------------------------------------------------------------------- // // Author scene and compose the Stage // --------------------------------------------------------------------- // SdfLayerRefPtr layer = SdfLayer::CreateAnonymous(); UsdStageRefPtr stage = UsdStage::Open(layer->GetIdentifier()); TF_VERIFY(stage->OverridePrim(primPath), "Failed to create prim at %s", primPath.GetText()); UsdPrim prim(stage->GetPrimAtPath(primPath)); TF_VERIFY(prim, "Failed to get Prim from %s", primPath.GetText()); // Grab the attribute we will be testing with. UsdAttribute attr = prim.CreateAttribute(prop, SdfValueTypeNames->Double3Array); TF_VERIFY(attr, "Failed to create property at %s", propPath.c_str()); // --------------------------------------------------------------------- // // Setup some test data // --------------------------------------------------------------------- // VtVec3dArray vtVecOut(1); VtVec3dArray vtVecIn; std::string tmp; VtValue value; // ===================================================================== // // TEST READING METADATA // ===================================================================== // // --------------------------------------------------------------------- // // GetMetadata & SetMetadata the value as a VtValue // --------------------------------------------------------------------- // TF_VERIFY(attr.SetMetadata(metaField, VtValue(true)), "VtValue: Failed to set hidden metadata at %s", propPath.c_str()); // Print the layer for debugging. layer->ExportToString(&tmp); std::cout << "-----------------------------------------" << std::endl; std::cout << "Metadata -- VtValue:" << std::endl; std::cout << tmp << std::endl; // Verify the result. TF_VERIFY(attr.GetMetadata(metaField, &value), "Metadata -- VtValue: Failed to get property value at %s", propPath.c_str()); TF_VERIFY(value.IsHolding<bool>(), "Metadata -- VtValue: not holding bool%s", propPath.c_str()); TF_VERIFY(value.Get<bool>(), "Metadata -- VtValue: value was not true %s", propPath.c_str()); // --------------------------------------------------------------------- // // GetMetadata & SetMetadata the value as bool // --------------------------------------------------------------------- // bool valueIn = false; TF_VERIFY(attr.SetMetadata(metaField, true), "Metadata -- bool: Failed to set property at %s", propPath.c_str()); // Print the layer for debugging. tmp = ""; layer->ExportToString(&tmp); std::cout << "-----------------------------------------" << std::endl; std::cout << "Metadata -- bool:" << std::endl; std::cout << tmp << std::endl; // Verify Result. TF_VERIFY(attr.GetMetadata(metaField, &valueIn), "Metadata -- bool: Failed to get property value at %s", propPath.c_str()); TF_VERIFY(valueIn, "Metadata -- bool: value was not true %s", propPath.c_str()); // ===================================================================== // // TEST READING VALUES // ===================================================================== // // --------------------------------------------------------------------- // // Get & Set the value as a VtValue // --------------------------------------------------------------------- // vtVecOut[0] = GfVec3d(9,8,7); TF_VERIFY(attr.Set(VtValue(vtVecOut)), "VtValue: Failed to set property at %s", propPath.c_str()); // Print the layer for debugging. layer->ExportToString(&tmp); std::cout << "-----------------------------------------" << std::endl; std::cout << "VtValue:" << std::endl; std::cout << tmp << std::endl; // Verify the result. TF_VERIFY(attr.Get(&value), "VtValue: Failed to get property value at %s", propPath.c_str()); TF_VERIFY(value.IsHolding<VtVec3dArray>(), "VtValue: not holding VtVec3dArray %s", propPath.c_str()); TF_VERIFY(value.Get<VtVec3dArray>()[0] == vtVecOut[0], "VtValue: VtVec3d[0] does not match %s", propPath.c_str()); // --------------------------------------------------------------------- // // Get & Set the value as a VtArray // --------------------------------------------------------------------- // vtVecOut[0] = GfVec3d(6,5,4); TF_VERIFY(attr.Set(vtVecOut), "Failed to set property at %s", propPath.c_str()); // Print the layer for debugging. tmp = ""; layer->ExportToString(&tmp); std::cout << "-----------------------------------------" << std::endl; std::cout << "VtArray:" << std::endl; std::cout << tmp << std::endl; // Verify Result. TF_VERIFY(attr.Get(&vtVecIn), "VtArray: Failed to get property value at %s", propPath.c_str()); TF_VERIFY(vtVecIn[0] == vtVecOut[0], "VtArray: VtVec3d[0] does not match %s", propPath.c_str()); // --------------------------------------------------------------------- // // Get & Set the value as a VtDictionary (Dictionary composition semantics // are exercised in testUsdMetadata). // --------------------------------------------------------------------- // VtDictionary inDict; inDict["$Side"] = "R"; TF_VERIFY(!prim.HasAuthoredMetadata(SdfFieldKeys->PrefixSubstitutions)); TF_VERIFY(prim.SetMetadata(SdfFieldKeys->PrefixSubstitutions, inDict)); VtDictionary outDict; TF_VERIFY(prim.HasAuthoredMetadata(SdfFieldKeys->PrefixSubstitutions)); // Verify bug 97783 - GetMetadata should return true if Usd was able to // retrieve/compose a VtDictionary. TF_VERIFY(prim.GetMetadata(SdfFieldKeys->PrefixSubstitutions,&outDict)); TF_VERIFY(inDict == outDict); std::cout << "-----------------------------------------" << std::endl; std::cout << "VtDictionary:" << std::endl; tmp = ""; layer->ExportToString(&tmp); std::cout << tmp << std::endl; }