PcpNodeRef
PcpNodeRef::GetOriginNode() const
{
const size_t originIndex = _GetOriginIndex();
return (originIndex == PCP_INVALID_INDEX ?
PcpNodeRef() : PcpNodeRef(_graph, originIndex));
}
PcpNodeRef
PcpNodeRef::GetParentNode() const
{
const size_t parentIndex = _GetParentIndex();
return (parentIndex == PCP_INVALID_INDEX ?
PcpNodeRef() : PcpNodeRef(_graph, parentIndex));
}
PcpNodeRef
PcpPrimIndex_Graph::GetNodeUsingSite(const PcpLayerStackSite& site) const
{
TRACE_FUNCTION();
for (size_t i = 0, numNodes = _data->nodes.size(); i != numNodes; ++i) {
const _Node& node = _data->nodes[i];
if (!(node.smallInts.inert || node.smallInts.culled)
&& node.layerStack == site.layerStack
&& _nodeSitePaths[i] == site.path) {
return PcpNodeRef(const_cast<PcpPrimIndex_Graph*>(this), i);
}
}
return PcpNodeRef();
}
PcpNodeRef
Usd_Resolver::GetNode() const
{
if (not IsValid())
return PcpNodeRef();
return *_curNode;
}
PcpNodeRef
PcpPrimIndex_Graph::_InsertChildInStrengthOrder(
size_t parentNodeIdx, size_t childNodeIdx)
{
TF_VERIFY(parentNodeIdx < _GetNumNodes());
TF_VERIFY(childNodeIdx < _GetNumNodes());
// Insert the child in the list of children, maintaining
// the relative strength order.
_Node& parentNode = _data->nodes[parentNodeIdx];
_Node& childNode = _data->nodes[childNodeIdx];
_ArcStrengthOrder comp(this);
if (FIRST_CHILD(parentNode) == _Node::_invalidNodeIndex) {
// No children yet so this is the first child.
TF_VERIFY(LAST_CHILD(parentNode) == _Node::_invalidNodeIndex);
FIRST_CHILD(parentNode) =
LAST_CHILD(parentNode) = childNodeIdx;
}
else if (comp(childNodeIdx, FIRST_CHILD(parentNode))) {
// New first child.
TF_VERIFY(LAST_CHILD(parentNode) != _Node::_invalidNodeIndex);
_Node& nextNode = _data->nodes[FIRST_CHILD(parentNode)];
NEXT_SIBLING(childNode) = FIRST_CHILD(parentNode);
PREV_SIBLING(nextNode) = childNodeIdx;
FIRST_CHILD(parentNode) = childNodeIdx;
}
else if (!comp(childNodeIdx, LAST_CHILD(parentNode))) {
// New last child.
_Node& prevNode = _data->nodes[LAST_CHILD(parentNode)];
PREV_SIBLING(childNode) = LAST_CHILD(parentNode);
NEXT_SIBLING(prevNode) = childNodeIdx;
LAST_CHILD(parentNode) = childNodeIdx;
}
else {
// Child goes somewhere internal to the sibling linked list.
for (size_t index = FIRST_CHILD(parentNode);
index != _Node::_invalidNodeIndex;
index = NEXT_SIBLING(_data->nodes[index])) {
if (comp(childNodeIdx, index)) {
_Node& nextNode = _data->nodes[index];
TF_VERIFY(PREV_SIBLING(nextNode) != _Node::_invalidNodeIndex);
_Node& prevNode =_data->nodes[PREV_SIBLING(nextNode)];
PREV_SIBLING(childNode) = PREV_SIBLING(nextNode);
NEXT_SIBLING(childNode) = index;
PREV_SIBLING(nextNode) = childNodeIdx;
NEXT_SIBLING(prevNode) = childNodeIdx;
break;
}
}
}
return PcpNodeRef(this, childNodeIdx);
}
PcpNodeIterator::reference
PcpNodeIterator::dereference() const
{
return PcpNodeRef(_graph, _nodeIdx);
}
PcpNodeRef
PcpPrimIndex_Graph::GetRootNode() const
{
return PcpNodeRef(const_cast<PcpPrimIndex_Graph*>(this), 0);
}