自学教程：C++ GetPrim函数代码示例

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

UsdAttributeUsdSchemaBase::_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;}

UsdShadeNodeGraph::InterfaceInputConsumersMapUsdRiMaterialAPI::ComputeInterfaceInputConsumersMap(        bool computeTransitiveConsumers) const{    return UsdShadeNodeGraph(GetPrim())._ComputeInterfaceInputConsumersMap(        computeTransitiveConsumers, _tokens->ri);}

UsdVolVolume::FieldMapUsdVolVolume::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;}

boolUsdGeomPointInstancer::ActivateAllIds() const{    SdfInt64ListOp  op;    op.SetExplicitItems(std::vector<int64_t>());        return GetPrim().SetMetadata(UsdGeomTokens->inactiveIds, op);}

UsdGeomPrimvarUsdGeomPrimvarsAPI::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::stringUsdSkelSkeletonQuery::GetDescription() const{    if(IsValid()) {        return TfStringPrintf(            "UsdSkelSkeletonQuery (skel = <%s>, anim = <%s>)",            GetPrim().GetPath().GetText(),            _animQuery.GetPrim().GetPath().GetText());    }    return "invalid UsdSkelSkeletonQuery";}

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

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

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

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

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

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

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

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