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