UsdRelationship
UsdLuxLinkingAPI::_GetExcludesRel(bool create /* =false */) const
{
const TfToken &relName = _GetCollectionPropertyName(_tokens->excludes);
return create ? GetPrim().CreateRelationship(relName, /* custom */ false) :
GetPrim().GetRelationship(relName);
}
PXR_NAMESPACE_CLOSE_SCOPE
// ===================================================================== //
// Feel free to add custom code below this line. It will be preserved by
// the code generator.
//
// Just remember to wrap code in the appropriate delimiters:
// 'PXR_NAMESPACE_OPEN_SCOPE', 'PXR_NAMESPACE_CLOSE_SCOPE'.
// ===================================================================== //
// --(BEGIN CUSTOM CODE)--
PXR_NAMESPACE_OPEN_SCOPE
UsdGeomPrimvar
UsdGeomPrimvarsAPI::CreatePrimvar(const TfToken& attrName,
const SdfValueTypeName &typeName,
const TfToken& interpolation,
int elementSize) const
{
const UsdPrim &prim = GetPrim();
UsdGeomPrimvar primvar(prim, attrName, typeName);
if (primvar){
if (!interpolation.IsEmpty())
primvar.SetInterpolation(interpolation);
if (elementSize > 0)
primvar.SetElementSize(elementSize);
}
// otherwise, errors have already been issued
return primvar;
}
UsdGeomPrimvar
UsdGeomPrimvarsAPI::FindPrimvarWithInheritance(const TfToken &name) const
{
TRACE_FUNCTION();
const TfToken attrName = UsdGeomPrimvar::_MakeNamespaced(name);
UsdPrim prim = GetPrim();
if (!prim) {
TF_CODING_ERROR("FindPrimvarWithInheritance called on invalid prim: %s",
UsdDescribe(prim).c_str());
return UsdGeomPrimvar();
}
UsdGeomPrimvar localPv = GetPrimvar(name);
if (localPv.HasAuthoredValue()){
return localPv;
}
for (prim = prim.GetParent(); prim && !prim.IsPseudoRoot();
prim = prim.GetParent()) {
UsdAttribute attr = prim.GetAttribute(attrName);
if (attr.HasAuthoredValue()) {
if (UsdGeomPrimvar pv = UsdGeomPrimvar(attr)) {
// Only constant primvars can be inherited.
if (pv.GetInterpolation() == UsdGeomTokens->constant) {
return pv;
} else {
// Non-constant interpolation blocks inheritance.
return UsdGeomPrimvar();
}
}
}
}
return localPv;
}
UsdAttribute
UsdSchemaBase::_CreateAttr(TfToken const &attrName,
SdfValueTypeName const & typeName,
bool custom, SdfVariability variability,
VtValue const &defaultValue,
bool writeSparsely) const
{
UsdPrim prim(GetPrim());
if (writeSparsely && !custom){
// We are a builtin, and we're trying to be parsimonious.
// We only need to even CREATE a propertySpec if we are
// authoring a non-fallback default value
UsdAttribute attr = prim.GetAttribute(attrName);
VtValue fallback;
if (defaultValue.IsEmpty() ||
(!attr.HasAuthoredValueOpinion()
&& attr.Get(&fallback)
&& fallback == defaultValue)){
return attr;
}
}
UsdAttribute attr(prim.CreateAttribute(attrName, typeName,
custom, variability));
if (attr && !defaultValue.IsEmpty()) {
attr.Set(defaultValue);
}
return attr;
}
UsdGeomPrimvar
UsdGeomPrimvarsAPI::FindPrimvarWithInheritance(const TfToken &name,
const std::vector<UsdGeomPrimvar>
&inheritedFromAncestors) const
{
TRACE_FUNCTION();
const UsdPrim &prim = GetPrim();
if (!prim) {
TF_CODING_ERROR("FindPrimvarWithInheritance called on invalid prim: %s",
UsdDescribe(prim).c_str());
return UsdGeomPrimvar();
}
const TfToken attrName = UsdGeomPrimvar::_MakeNamespaced(name);
UsdGeomPrimvar pv = GetPrimvar(attrName);
if (pv.HasAuthoredValue()){
return pv;
}
for (UsdGeomPrimvar const &inherited : inheritedFromAncestors) {
if (inherited.GetName() == attrName){
return inherited;
}
}
return pv;
}
bool
UsdGeomPrimvarsAPI::HasPossiblyInheritedPrimvar(const TfToken &name) const
{
TRACE_FUNCTION();
UsdPrim prim = GetPrim();
if (!prim) {
TF_CODING_ERROR("HasPossiblyInheritedPrimvar called on invalid prim: %s",
UsdDescribe(prim).c_str());
return false;
}
UsdGeomPrimvar pv = GetPrimvar(name);
if (pv.HasAuthoredValue()){
return true;
}
const TfToken attrName = UsdGeomPrimvar::_MakeNamespaced(name);
if (attrName.IsEmpty()) {
return false;
}
for (prim = prim.GetParent(); prim && !prim.IsPseudoRoot();
prim = prim.GetParent()) {
UsdAttribute attr = prim.GetAttribute(attrName);
if (attr.HasAuthoredValue() && UsdGeomPrimvar::IsPrimvar(attr)) {
// Only constant primvars can be inherited.
// Non-constant interpolation blocks inheritance.
return UsdGeomPrimvar(attr).GetInterpolation()
== UsdGeomTokens->constant;
}
}
return false;
}
UsdShadeNodeGraph::InterfaceInputConsumersMap
UsdRiMaterialAPI::ComputeInterfaceInputConsumersMap(
bool computeTransitiveConsumers) const
{
return UsdShadeNodeGraph(GetPrim())._ComputeInterfaceInputConsumersMap(
computeTransitiveConsumers, _tokens->ri);
}
UsdVolVolume::FieldMap
UsdVolVolume::GetFieldPaths() const
{
std::map<TfToken, SdfPath> fieldMap;
const UsdPrim &prim = GetPrim();
if (prim) {
std::vector<UsdProperty> fieldProps =
prim.GetPropertiesInNamespace(_tokens->fieldPrefix);
for (const UsdProperty &fieldProp : fieldProps) {
UsdRelationship fieldRel = fieldProp.As<UsdRelationship>();
SdfPathVector targets;
// All relationships starting with "field:" should point to
// UsdVolFieldBase primitives.
if (fieldRel && fieldRel.GetForwardedTargets(&targets)) {
if (targets.size() == 1 &&
targets.front().IsPrimPath()) {
fieldMap.emplace(fieldRel.GetBaseName(), targets.front());
}
}
}
}
return fieldMap;
}
bool
UsdGeomPointInstancer::ActivateAllIds() const
{
SdfInt64ListOp op;
op.SetExplicitItems(std::vector<int64_t>());
return GetPrim().SetMetadata(UsdGeomTokens->inactiveIds, op);
}
UsdGeomPrimvar
UsdGeomPrimvarsAPI::GetPrimvar(const TfToken &name) const
{
// The getter SHOULD issue an error if 'name' is malformed, which
// _MakeNamespaced() will do for us.
return UsdGeomPrimvar(GetPrim().GetAttribute
(UsdGeomPrimvar::_MakeNamespaced(name)));
}
bool
UsdSpecializes::SetSpecializes(const SdfPathVector& items)
{
// Proxy editor has no clear way of setting explicit items in a single
// call, so instead, just set the field directly.
SdfPathListOp paths;
paths.SetExplicitItems(items);
return GetPrim().SetMetadata(SdfFieldKeys->Specializes, paths);
}
std::string
UsdSkelSkeletonQuery::GetDescription() const
{
if(IsValid()) {
return TfStringPrintf(
"UsdSkelSkeletonQuery (skel = <%s>, anim = <%s>)",
GetPrim().GetPath().GetText(),
_animQuery.GetPrim().GetPath().GetText());
}
return "invalid UsdSkelSkeletonQuery";
}
bool
UsdProperty::IsAuthored() const
{
// Look for the strongest authored property spec.
for (Usd_Resolver res(
&GetPrim().GetPrimIndex()); res.IsValid(); res.NextLayer()) {
if (res.GetLayer()->HasSpec(
SdfAbstractDataSpecId(&res.GetLocalPath(), &_PropName())))
return true;
}
return false;
}
bool
UsdVolVolume::BlockFieldRelationship(const TfToken &name) const
{
UsdRelationship fieldRel = GetPrim().GetRelationship(_MakeNamespaced(name));
if (fieldRel){
fieldRel.BlockTargets();
return true;
}
else {
return false;
}
}
bool
UsdGeomPrimvarsAPI::HasPrimvar(const TfToken &name) const
{
TfToken primvarName = UsdGeomPrimvar::_MakeNamespaced(name, /* quiet */true);
const UsdPrim &prim = GetPrim();
if (!prim) {
TF_CODING_ERROR("HasPrimvar called on invalid prim: %s",
UsdDescribe(prim).c_str());
return false;
}
return primvarName.IsEmpty() ? false :
UsdGeomPrimvar::IsPrimvar(prim.GetAttribute(primvarName));
}
std::vector<UsdGeomPrimvar>
UsdGeomPrimvarsAPI::GetPrimvarsWithValues() const
{
const UsdPrim &prim = GetPrim();
if (!prim){
TF_CODING_ERROR("Called GetPrimvarsWithValues on invalid prim: %s",
UsdDescribe(prim).c_str());
return std::vector<UsdGeomPrimvar>();
}
return _MakePrimvars(prim.GetAuthoredPropertiesInNamespace(
UsdGeomPrimvar::_GetNamespacePrefix()),
[](UsdGeomPrimvar const &pv) { return pv.HasValue(); });
}
std::vector<bool>
UsdGeomPointInstancer::ComputeMaskAtTime(UsdTimeCode time,
VtInt64Array const *ids) const
{
VtInt64Array idVals, invisedIds;
std::vector<bool> mask;
SdfInt64ListOp inactiveIdsListOp;
// XXX Note we could be doing all three fetches in parallel
GetPrim().GetMetadata(UsdGeomTokens->inactiveIds, &inactiveIdsListOp);
std::vector<int64_t> inactiveIds = inactiveIdsListOp.GetExplicitItems();
GetInvisibleIdsAttr().Get(&invisedIds, time);
if (inactiveIds.size() > 0 || invisedIds.size() > 0){
bool anyPruned = false;
std::set<int64_t> maskedIds(inactiveIds.begin(), inactiveIds.end());
maskedIds.insert(invisedIds.begin(), invisedIds.end());
if (!ids){
if (GetIdsAttr().Get(&idVals, time)){
ids = &idVals;
}
if (!ids){
VtIntArray protoIndices;
if (!GetProtoIndicesAttr().Get(&protoIndices, time)){
// not a functional PointInstancer... just return
// trivial pass
return mask;
}
size_t numInstances = protoIndices.size();
idVals.reserve(numInstances);
for (size_t i = 0; i < numInstances; ++i) {
idVals.push_back(i);
}
ids = &idVals;
}
}
mask.reserve(ids->size());
for (int64_t id : *ids){
bool pruned = (maskedIds.find(id) != maskedIds.end());
anyPruned = anyPruned || pruned;
mask.push_back(!pruned);
}
if (!anyPruned){
mask.resize(0);
}
}
return mask;
}
UsdShadeOutput
UsdRiMaterialAPI::_GetShadeOutput(const UsdAttribute &outputAttr,
const TfToken &oldEncodingRelName) const
{
if (outputAttr) {
return UsdShadeOutput(outputAttr);
} else if (UsdShadeUtils::ReadOldEncoding()) {
if (UsdRelationship rel = GetPrim().GetRelationship(oldEncodingRelName))
{
return UsdShadeOutput(rel);
}
}
return UsdShadeOutput();
}
bool
UsdRiMaterialAPI::SetSurfaceSource(const SdfPath &surfacePath) const
{
if (UsdShadeUtils::WriteNewEncoding()) {
UsdShadeOutput surfaceOutput(CreateSurfaceAttr());
return UsdShadeConnectableAPI::ConnectToSource(
surfaceOutput, surfacePath.IsPropertyPath() ? surfacePath :
surfacePath.AppendProperty(_tokens->defaultOutputName));
} else if (UsdRelationship surfaceRel = GetPrim().CreateRelationship(
_tokens->riLookSurface, /*custom*/ false)) {
return surfaceRel.SetTargets(std::vector<SdfPath>{surfacePath});
}
return false;
}
bool
UsdRiMaterialAPI::SetBxdfSource(const SdfPath &bxdfPath) const
{
if (UsdShadeUtils::WriteNewEncoding()) {
UsdShadeOutput bxdfOutput(CreateBxdfAttr());
return UsdShadeConnectableAPI::ConnectToSource(
bxdfOutput, bxdfPath.IsPropertyPath() ?
bxdfPath :
bxdfPath.AppendProperty(_tokens->defaultOutputName));
} else if (UsdRelationship bxdfRel = GetPrim().CreateRelationship(
_tokens->riLookBxdf, /*custom*/ false)) {
return bxdfRel.SetTargets(std::vector<SdfPath>{bxdfPath});
}
return false;
}
bool
UsdGeomPointBased::SetNormalsInterpolation(TfToken const &interpolation)
{
if (UsdGeomPrimvar::IsValidInterpolation(interpolation)){
return GetNormalsAttr().SetMetadata(UsdGeomTokens->interpolation,
interpolation);
}
TF_CODING_ERROR("Attempt to set invalid interpolation "
"\"%s\" for normals attr on prim %s",
interpolation.GetText(),
GetPrim().GetPath().GetString().c_str());
return false;
}
bool
UsdRiMaterialAPI::SetVolumeSource(const SdfPath &volumePath) const
{
if (UsdShadeUtils::WriteNewEncoding()) {
UsdShadeOutput volumeOutput(CreateVolumeAttr());
return UsdShadeConnectableAPI::ConnectToSource(
volumeOutput, volumePath.IsPropertyPath() ?
volumePath :
volumePath.AppendProperty(_tokens->defaultOutputName));
} else if (UsdRelationship volumeRel = GetPrim().CreateRelationship(
_tokens->riLookVolume, /*custom*/ false)) {
return volumeRel.SetTargets(std::vector<SdfPath>{volumePath});
}
return false;
}
SdfPath
UsdVolVolume::GetFieldPath(const TfToken &name) const
{
UsdRelationship fieldRel = GetPrim().GetRelationship(_MakeNamespaced(name));
SdfPathVector targets;
if (fieldRel && fieldRel.GetForwardedTargets(&targets)) {
if (targets.size() == 1 &&
targets.front().IsPrimPath()) {
return targets.front();
}
}
return SdfPath::EmptyPath();
}
bool
UsdVolVolume::CreateFieldRelationship(const TfToken &name,
const SdfPath &fieldPath) const
{
if (!fieldPath.IsPrimPath() && !fieldPath.IsPrimPropertyPath()){
return false;
}
UsdRelationship fieldRel =
GetPrim().CreateRelationship(_MakeNamespaced(name), /*custom*/true);
if (fieldRel) {
return fieldRel.SetTargets({fieldPath});
}
return false;
}
bool
UsdRiMaterialAPI::SetDisplacementSource(const SdfPath &displacementPath) const
{
if (UsdShadeUtils::WriteNewEncoding()) {
UsdShadeOutput displacementOutput(CreateDisplacementAttr());
return UsdShadeConnectableAPI::ConnectToSource(
displacementOutput, displacementPath.IsPropertyPath() ?
displacementPath :
displacementPath.AppendProperty(_tokens->defaultOutputName));
} else if (UsdRelationship displacementRel = GetPrim().CreateRelationship(
_tokens->riLookDisplacement, /*custom*/ false)) {
return displacementRel.SetTargets(
std::vector<SdfPath>{displacementPath});
}
return false;
}
UsdAttribute
UsdLuxLinkingAPI::_GetIncludeByDefaultAttr(bool create /* = false */) const
{
const TfToken &attrName =
_GetCollectionPropertyName(_tokens->includeByDefault);
if (create) {
return UsdSchemaBase::_CreateAttr(attrName,
SdfValueTypeNames->Bool,
/* custom = */ false,
SdfVariabilityUniform,
/* default = */ VtValue(),
/* writeSparsely */ false);
} else {
return GetPrim().GetAttribute(attrName);
}
}
std::vector<UsdGeomPrimvar>
UsdGeomPrimvarsAPI::FindInheritablePrimvars() const
{
TRACE_FUNCTION();
// Assume the number of primvars is relatively bounded and
// just use a vector to accumulate primvars up to the root prim.
std::vector<UsdGeomPrimvar> primvars;
const UsdPrim &prim = GetPrim();
if (!prim) {
TF_CODING_ERROR("FindInheritablePrimvars called on invalid prim: %s",
UsdDescribe(prim).c_str());
return primvars;
}
TfToken const& prefix = UsdGeomPrimvar::_GetNamespacePrefix();
_RecurseForInheritablePrimvars(prim, prefix, &primvars);
return primvars;
}
std::vector<UsdGeomPrimvar>
UsdGeomPrimvarsAPI::FindIncrementallyInheritablePrimvars(
const std::vector<UsdGeomPrimvar> &inheritedFromAncestors) const
{
TRACE_FUNCTION();
std::vector<UsdGeomPrimvar> primvars;
const UsdPrim &prim = GetPrim();
if (!prim) {
TF_CODING_ERROR("FindIncrementallyInheritablePrimvars called on invalid prim: %s",
UsdDescribe(prim).c_str());
return primvars;
}
TfToken const& prefix = UsdGeomPrimvar::_GetNamespacePrefix();
_AddPrimToInheritedPrimvars(prim, prefix,
&inheritedFromAncestors,
&primvars, /* acceptAll = */ false);
return primvars;
}
bool
UsdSkelSkeletonQuery::ComputeJointWorldTransforms(VtMatrix4dArray* xforms,
UsdGeomXformCache* xfCache,
bool atRest) const
{
TRACE_FUNCTION();
if (!xfCache) {
TF_CODING_ERROR("'xfCache' pointer is null.");
return false;
}
VtMatrix4dArray localXforms;
if (ComputeJointLocalTransforms(&localXforms, xfCache->GetTime(), atRest)) {
const auto& topology = _definition->GetTopology();
GfMatrix4d rootXform = xfCache->GetLocalToWorldTransform(GetPrim());
return UsdSkelConcatJointTransforms(topology, localXforms,
xforms, &rootXform);
}
return false;
}
std::vector<UsdGeomPrimvar>
UsdGeomPrimvarsAPI::FindPrimvarsWithInheritance(
const std::vector<UsdGeomPrimvar> &inheritedFromAncestors) const
{
TRACE_FUNCTION();
std::vector<UsdGeomPrimvar> primvars;
const UsdPrim &prim = GetPrim();
if (!prim) {
TF_CODING_ERROR("FindPrimvarsWithInheritance called on invalid prim: %s",
UsdDescribe(prim).c_str());
return primvars;
}
TfToken const& prefix = UsdGeomPrimvar::_GetNamespacePrefix();
_AddPrimToInheritedPrimvars(prim, prefix,
&inheritedFromAncestors,
&primvars,
/* acceptAll = */ true);
// If this prim contributed no primvars, then `primvars` won't have
// gotten a copy of `inheritedFromAncestors`, so ensure we compensate
return primvars.empty() ? inheritedFromAncestors : primvars;
}
