PcpPrimIndex UsdPrim::ComputeExpandedPrimIndex() const { // Get the prim index path to compute from the index stored in the prim // data. This ensures we get consistent behavior when dealing with // instancing and instance proxies. const PcpPrimIndex& cachedPrimIndex = _Prim()->GetPrimIndex(); if (!cachedPrimIndex.IsValid()) { return PcpPrimIndex(); } const SdfPath& primIndexPath = cachedPrimIndex.GetPath(); PcpCache* cache = _GetStage()->_GetPcpCache(); PcpPrimIndexOutputs outputs; PcpComputePrimIndex( primIndexPath, cache->GetLayerStack(), cache->GetPrimIndexInputs().Cull(false), &outputs); _GetStage()->_ReportPcpErrors( outputs.allErrors, TfStringPrintf( "Computing expanded prim index for <%s>", GetPath().GetText())); return outputs.primIndex; }
SdfPath UsdRelationship::_GetTargetForAuthoring(const SdfPath &target, std::string* whyNot) const { if (!target.IsEmpty()) { SdfPath absTarget = target.MakeAbsolutePath(GetPath().GetAbsoluteRootOrPrimPath()); if (Usd_InstanceCache::IsPathMasterOrInMaster(absTarget)) { if (whyNot) { *whyNot = "Cannot target a master or an object within a " "master."; } return SdfPath(); } } UsdStage *stage = _GetStage(); SdfPath mappedPath = _MapTargetPath(stage, GetPath(), target); if (mappedPath.IsEmpty()) { if (whyNot) { *whyNot = TfStringPrintf("Cannot map <%s> to layer @%s@ via stage's " "EditTarget", target.GetText(), stage->GetEditTarget(). GetLayer()->GetIdentifier().c_str()); } } return mappedPath; }
SdfRelationshipSpecHandle UsdRelationship::_CreateSpec(bool fallbackCustom) const { UsdStage *stage = _GetStage(); // Try to create a spec for editing either from the definition or from // copying existing spec info. TfErrorMark m; if (SdfRelationshipSpecHandle relSpec = stage->_CreateRelationshipSpecForEditing(*this)) { return relSpec; } // If creating the spec on the stage failed without issuing an error, that // means there was no existing authored scene description to go on (i.e. no // builtin info from prim type, and no existing authored spec). Stamp a // spec with the provided default values. if (m.IsClean()) { SdfChangeBlock block; return SdfRelationshipSpec::New( stage->_CreatePrimSpecForEditing(GetPrimPath()), _PropName().GetString(), /* custom = */ fallbackCustom, SdfVariabilityUniform); } return TfNullPtr; }
UsdPrim UsdPrim::GetMaster() const { Usd_PrimDataConstPtr masterPrimData = _GetStage()->_GetMasterForInstance(get_pointer(_Prim())); return UsdPrim(masterPrimData, SdfPath()); }
PXR_NAMESPACE_OPEN_SCOPE SdfPropertySpecHandleVector UsdProperty::GetPropertyStack(UsdTimeCode time) const { return _GetStage()->_GetPropertyStack(*this, time); }
UsdProperty UsdPrim::GetProperty(const TfToken &propName) const { SdfSpecType specType = _GetStage()->_GetDefiningSpecType(*this, propName); if (specType == SdfSpecTypeAttribute) { return GetAttribute(propName); } else if (specType == SdfSpecTypeRelationship) { return GetRelationship(propName); } return UsdProperty(UsdTypeProperty, _Prim(), _ProxyPrimPath(), propName); }
std::vector<UsdProperty> UsdPrim::_MakeProperties(const TfTokenVector &names) const { std::vector<UsdProperty> props; UsdStage *stage = _GetStage(); props.reserve(names.size()); for (auto const &propName : names) { SdfSpecType specType = stage->_GetDefiningSpecType(*this, propName); if (specType == SdfSpecTypeAttribute) { props.push_back(GetAttribute(propName)); } else if (TF_VERIFY(specType == SdfSpecTypeRelationship)) { props.push_back(GetRelationship(propName)); } } return props; }
bool UsdRelationship::GetTargets(SdfPathVector* targets) const { TRACE_FUNCTION(); UsdStage *stage = _GetStage(); PcpErrorVector pcpErrors; std::vector<std::string> otherErrors; PcpTargetIndex targetIndex; { // Our intention is that the following code requires read-only // access to the PcpCache, so use a const-ref. const PcpCache& pcpCache(*stage->_GetPcpCache()); // In USD mode, Pcp does not cache property indexes, so we // compute one here ourselves and use that. First, we need // to get the prim index of the owning prim. const PcpPrimIndex &primIndex = _Prim()->GetPrimIndex(); // PERFORMANCE: Here we can't avoid constructing the full property path // without changing the Pcp API. We're about to do serious // composition/indexing, though, so the added expense may be neglible. const PcpSite propSite(pcpCache.GetLayerStackIdentifier(), GetPath()); PcpPropertyIndex propIndex; PcpBuildPrimPropertyIndex(propSite.path, pcpCache, primIndex, &propIndex, &pcpErrors); PcpBuildTargetIndex(propSite, propIndex, SdfSpecTypeRelationship, &targetIndex, &pcpErrors); } targets->swap(targetIndex.paths); if (!targets->empty() && _Prim()->IsInMaster()) { Usd_PrimDataConstPtr master = get_pointer(_Prim()); while (!master->IsMaster()) { master = master->GetParent(); } // Paths that point to an object under the master's source prim index // are internal to the master and need to be translated to either // the master or instance we're currently looking at. const SdfPath& masterSourcePrimIndexPath = master->GetSourcePrimIndex().GetPath(); if (GetPrim().IsInMaster()) { // Translate any paths that point to an object at or under the // source prim index to our master. for (SdfPath& target : *targets) { target = target.ReplacePrefix( masterSourcePrimIndexPath, master->GetPath()); } } else if (GetPrim().IsInstanceProxy()) { // Translate any paths that point to an object at or under the // source prim index to our instance. UsdPrim instance = GetPrim(); while (!instance.IsInstance()) { instance = instance.GetParent(); } for (SdfPath& target : *targets) { target = target.ReplacePrefix( masterSourcePrimIndexPath, instance.GetPath()); } } } // TODO: handle errors const bool hasErrors = !(pcpErrors.empty() && otherErrors.empty()); if (hasErrors) { stage->_ReportErrors( pcpErrors, otherErrors, TfStringPrintf("Getting targets for relationship <%s>", GetPath().GetText())); } return !hasErrors; }
UsdProperty UsdProperty::FlattenTo(const UsdProperty &property) const { return _GetStage()->_FlattenProperty( *this, property.GetPrim(), property.GetName()); }
UsdProperty UsdProperty::FlattenTo(const UsdPrim &parent, const TfToken &propName) const { return _GetStage()->_FlattenProperty(*this, parent, propName); }
UsdProperty UsdProperty::FlattenTo(const UsdPrim &parent) const { return _GetStage()->_FlattenProperty(*this, parent, GetName()); }
bool UsdProperty::IsCustom() const { return _GetStage()->_IsCustom(*this); }
void UsdPrim::Unload() const { _GetStage()->Unload(GetPath()); }
void UsdPrim::Load(UsdLoadPolicy policy) const { _GetStage()->Load(GetPath(), policy); }
bool UsdPrim::RemoveProperty(const TfToken &propName) { SdfPath propPath = GetPath().AppendProperty(propName); return _GetStage()->_RemoveProperty(propPath); }
void UsdPrim::Load() const { _GetStage()->Load(GetPath()); }