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