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;
}
