UsdSkelAnimQuery UsdSkel_CacheImpl::ReadScope::FindOrCreateAnimQuery(const UsdPrim& prim) { TRACE_FUNCTION(); if(ARCH_UNLIKELY(!prim || !prim.IsActive())) return UsdSkelAnimQuery(); if(prim.IsInstanceProxy()) return FindOrCreateAnimQuery(prim.GetPrimInMaster()); { _PrimToAnimMap::const_accessor a; if(_cache->_animQueryCache.find(a, prim)) return UsdSkelAnimQuery(a->second); } if (UsdSkelIsSkelAnimationPrim(prim)) { _PrimToAnimMap::accessor a; if(_cache->_animQueryCache.insert(a, prim)) { a->second = UsdSkel_AnimQueryImpl::New(prim); } return UsdSkelAnimQuery(a->second); } return UsdSkelAnimQuery(); }
UT_StringHolder GusdGU_PackedUSD::intrinsicType() const { // Return the USD prim type so it can be displayed in the spreadsheet. UsdPrim prim = getUsdPrim(); return GusdUSD_Utils::TokenToStringHolder( prim.GetTypeName() ); }
SdfPath UsdImagingMaterialAdapter::Populate(UsdPrim const& prim, UsdImagingIndexProxy* index, UsdImagingInstancerContext const* instancerContext) { // Since material are populated by reference, they need to take care not to // be populated multiple times. SdfPath cachePath = prim.GetPath(); if (index->IsPopulated(cachePath)) { return cachePath; } index->InsertSprim(HdPrimTypeTokens->material, cachePath, prim, shared_from_this()); HD_PERF_COUNTER_INCR(UsdImagingTokens->usdPopulatedPrimCount); // Also register this adapter on behalf of any descendent // UsdShadeShader prims, since they are consumed to // create the material network. for (UsdPrim const& child: prim.GetDescendants()) { if (child.IsA<UsdShadeShader>()) { index->AddPrimInfo(child.GetPath(), child, shared_from_this()); } } return prim.GetPath(); }
UsdSkel_SkelDefinitionRefPtr UsdSkel_CacheImpl::ReadScope::FindOrCreateSkelDefinition(const UsdPrim& prim) { TRACE_FUNCTION(); if(ARCH_UNLIKELY(!prim || !prim.IsActive())) return nullptr; if(prim.IsInstanceProxy()) return FindOrCreateSkelDefinition(prim.GetPrimInMaster()); { _PrimToSkelDefinitionMap::const_accessor a; if(_cache->_skelDefinitionCache.find(a, prim)) return a->second; } if(prim.IsA<UsdSkelSkeleton>()) { _PrimToSkelDefinitionMap::accessor a; if(_cache->_skelDefinitionCache.insert(a, prim)) { a->second = UsdSkel_SkelDefinition::New(UsdSkelSkeleton(prim)); } return a->second; } return nullptr; }
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; }
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; }
/* static */ GfMatrix4d GusdPrimWrapper::computeTransform( const UsdPrim& prim, UsdTimeCode time, const UT_Matrix4D& houXform, const GusdSimpleXformCache& xformCache ) { // We need the transform into the prims space. // If the prim is in a hierarchy that we have written on this frame, // its transform will be in the xformCache. Otherwise, we can read it // from the global cache. // // The transform cache is necessary because the gobal cache // will only contain transform that we read from the stage and // not anything that we have modified. UT_Matrix4D primXform; auto it = xformCache.find( prim.GetPath() ); if( it != xformCache.end() ) { primXform = it->second; } else if( !GusdUSD_XformCache::GetInstance().GetLocalToWorldTransform( prim, time, primXform )) { TF_WARN( "Failed to get transform for %s.", prim.GetPath().GetText() ); primXform.identity(); } return GusdUT_Gf::Cast( houXform ) / GusdUT_Gf::Cast( primXform ); }
bool GusdGU_PackedUSD::unpackGeometry(GU_Detail &destgdp, const char* primvarPattern) const { UsdPrim usdPrim = getUsdPrim(); if( !usdPrim ) { TF_WARN( "Invalid prim found" ); return false; } UT_Matrix4D xform(1); const GU_PrimPacked *prim = getPrim(); if( prim ) { prim->getFullTransform4(xform); } GT_RefineParms rparms; // Need to manually force polysoup to be turned off. rparms.setAllowPolySoup( false ); if (primvarPattern) { rparms.set("usd:primvarPattern", primvarPattern); } GT_PrimitiveHandle gtPrim; DBG( cerr << "GusdGU_PackedUSD::unpackGeometry: " << usdPrim.GetTypeName() << ", " << usdPrim.GetPath() << endl; )
bool GusdXformWrapper:: initUsdPrim(const UsdStagePtr& stage, const SdfPath& path, bool asOverride) { bool newPrim = true; if( asOverride ) { UsdPrim existing = stage->GetPrimAtPath( path ); if( existing ) { // Note that we are creating a Xformable rather than a Xform. // If we are writing an overlay and the ROP sees a geometry packed prim, // we want to write just the xform. In that case we can use a xform // wrapper to write the xform on any prim type. m_usdXformForWrite = UsdGeomXformable(stage->OverridePrim( path )); newPrim = false; } else { m_usdXformForWrite = UsdGeomXform::Define( stage, path ); // Make sure our ancestors have proper types. UsdPrim p = m_usdXformForWrite.GetPrim().GetParent(); while( p && p.GetTypeName().IsEmpty() ) { UsdGeomXform::Define( stage, p.GetPath() ); p = p.GetParent(); } } } else { m_usdXformForWrite = UsdGeomXform::Define( stage, path ); } if( !m_usdXformForWrite || !m_usdXformForWrite.GetPrim().IsValid() ) { TF_WARN( "Unable to create %s xform '%s'.", newPrim ? "new" : "override", path.GetText() ); } return bool(m_usdXformForWrite); }
UsdAttribute PxrUsdMayaWriteUtil::GetOrCreateUsdAttr( const MPlug& plg, const UsdPrim& usdPrim, const std::string &attrName, bool custom) { MObject attrObj(plg.attribute()); TfToken usdAttrName(attrName); if (usdAttrName.IsEmpty()) { printf("Invalid attrName '%s' for %s\n", attrName.c_str(), plg.name().asChar()); return UsdAttribute(); } // See if usdAttr already exists. If so, return. UsdAttribute usdAttr = usdPrim.GetAttribute(usdAttrName); if (usdAttr) { return usdAttr; } SdfValueTypeName attrType = PxrUsdMayaWriteUtil::GetUsdTypeName(plg); // --------------------- // CreateAttribute on USD Prim if specified above if (attrType) { usdAttr = usdPrim.CreateAttribute(usdAttrName, attrType, custom); } else { // Skipping. Unsupported type. } return usdAttr; }
static bool _GatherRibAttributes( const UsdPrim &prim, double currentTime, FnKat::GroupBuilder& attrsBuilder) { bool hasAttrs = false; // USD SHADING STYLE ATTRIBUTES UsdRiStatements riStatements(prim); if (riStatements) { const std::vector<UsdProperty> props = riStatements.GetRiAttributes(); std::string attrName; TF_FOR_ALL(propItr, props) { UsdProperty prop = *propItr; if (!prop) continue; std::string nameSpace = riStatements.GetRiAttributeNameSpace(prop).GetString(); nameSpace = TfStringReplace(nameSpace, ":", ".") + "."; attrName = nameSpace + riStatements.GetRiAttributeName(prop).GetString(); VtValue vtValue; UsdAttribute usdAttr = prim.GetAttribute(prop.GetName()); if (usdAttr) { if (not usdAttr.Get(&vtValue, currentTime)) continue; // XXX asShaderParam really means: // "For arrays, as a single attr vs a type/value pair group" // The type/value pair group is meaningful for attrs who don't // have a formal type definition -- like a "user" RiAttribute. // // However, other array values (such as two-element shadingrate) // are not expecting the type/value pair form and will not // generate rib correctly. As such, we'll handle the "user" // attribute as a special case. bool asShaderParam = true; if (nameSpace == "user.") { asShaderParam = false; } attrsBuilder.set(attrName, PxrUsdKatanaUtils::ConvertVtValueToKatAttr(vtValue, asShaderParam) ); } else { UsdRelationship usdRel = prim.GetRelationship(prop.GetName()); attrsBuilder.set(attrName, PxrUsdKatanaUtils::ConvertRelTargetsToKatAttr(usdRel, /* asShaderParam */ false) ); } hasAttrs = true; } }
void usdWriteJob::endJob() { mJobCtx.processInstances(); UsdPrimSiblingRange usdRootPrims = mJobCtx.mStage->GetPseudoRoot().GetChildren(); // Write Variants (to first root prim path) UsdPrim usdRootPrim; TfToken defaultPrim; if (!usdRootPrims.empty()) { usdRootPrim = *usdRootPrims.begin(); defaultPrim = usdRootPrim.GetName(); } if (usdRootPrim && mRenderLayerObjs.length() > 1 && !mJobCtx.mArgs.usdModelRootOverridePath.IsEmpty()) { // Get RenderLayers // mArgs.usdModelRootOverridePath: // Require mArgs.usdModelRootOverridePath to be set so that // the variants are put under a UsdPrim that references a BaseModel // prim that has all of the geometry, transforms, and other details. // This needs to be done since "local" values have stronger precedence // than "variant" values, but "referencing" will cause the variant values // to take precedence. defaultPrim = writeVariants(usdRootPrim); } // Restoring the currentRenderLayer MFnRenderLayer currentLayer(MFnRenderLayer::currentLayer()); if (currentLayer.name() != mCurrentRenderLayerName) { MGlobal::executeCommand(MString("editRenderLayerGlobals -currentRenderLayer ")+ mCurrentRenderLayerName, false, false); } postCallback(); // Unfortunately, MGlobal::isZAxisUp() is merely session state that does // not get recorded in Maya files, so we cannot rely on it being set // properly. Since "Y" is the more common upAxis, we'll just use // isZAxisUp as an override to whatever our pipeline is configured for. TfToken upAxis = UsdGeomGetFallbackUpAxis(); if (MGlobal::isZAxisUp()){ upAxis = UsdGeomTokens->z; } UsdGeomSetStageUpAxis(mJobCtx.mStage, upAxis); if (usdRootPrim){ // We have already decided above that 'usdRootPrim' is the important // prim for the export... usdVariantRootPrimPath mJobCtx.mStage->GetRootLayer()->SetDefaultPrim(defaultPrim); } if (mJobCtx.mStage->GetRootLayer()->PermissionToSave()) { mJobCtx.mStage->GetRootLayer()->Save(); } mJobCtx.mStage->Close(); mJobCtx.mMayaPrimWriterList.clear(); // clear this so that no stage references are left around MGlobal::displayInfo("usdWriteJob::endJob Saving Stage"); }
SdfPath UsdImagingSphereLightAdapter::Populate(UsdPrim const& prim, UsdImagingIndexProxy* index, UsdImagingInstancerContext const* instancerContext) { index->InsertSprim(HdPrimTypeTokens->sphereLight, prim.GetPath(), prim); HD_PERF_COUNTER_INCR(UsdImagingTokens->usdPopulatedPrimCount); return prim.GetPath(); }
UsdShadeInterfaceAttribute::UsdShadeInterfaceAttribute( const UsdPrim& prim, TfToken const& interfaceAttrName, SdfValueTypeName const& typeName) : _name(interfaceAttrName) { TfToken attrName = _GetName(interfaceAttrName); _attr = prim.GetAttribute(attrName); if (not _attr) { _attr = prim.CreateAttribute(attrName, typeName, /* custom = */ false); } }
UsdShadeOutput::UsdShadeOutput( UsdPrim prim, TfToken const &name, SdfValueTypeName const &typeName) { // XXX what do we do if the type name doesn't match and it exists already? TfToken attrName = _GetOutputAttrName(name); _prop = prim.GetAttribute(attrName); if (!_prop) { _prop = prim.CreateAttribute(attrName, typeName, /* custom = */ false); } }
SdfPath UsdImagingPointsAdapter::Populate(UsdPrim const& prim, UsdImagingIndexProxy* index, UsdImagingInstancerContext const* instancerContext) { index->InsertPoints(prim.GetPath(), GetShaderBinding(prim), instancerContext); HD_PERF_COUNTER_INCR(UsdImagingTokens->usdPopulatedPrimCount); return prim.GetPath(); }
UsdShadeParameter::UsdShadeParameter( UsdPrim prim, TfToken const &name, SdfValueTypeName const &typeName) { // XXX what do we do if the type name doesn't match and it exists already? _attr = prim.GetAttribute(name); if (!_attr) { _attr = prim.CreateAttribute(name, typeName, /* custom = */ false); } }
static void _RecurseForInheritablePrimvars(const UsdPrim &prim, const TfToken &pvPrefix, std::vector<UsdGeomPrimvar> *primvars, bool acceptAll = false) { if (prim.IsPseudoRoot()) return; // The `acceptAll` override is only useful for the prim we are actually // querying, i.e. the *first* prim on which this function is called _RecurseForInheritablePrimvars(prim.GetParent(), pvPrefix, primvars); _AddPrimToInheritedPrimvars(prim, pvPrefix, primvars, primvars, acceptAll); }
UsdSkelSkeletonQuery UsdSkel_CacheImpl::ReadScope::GetInheritedSkelQuery(const UsdPrim& prim) const { _PrimToSkelQueryMap::const_accessor a; for(UsdPrim p = prim; p; p = p.GetParent()) { if(_cache->_skelQueryCache.find(a, p)) { return a->second; } if(prim.IsA<UsdSkelRoot>()) { break; } } return UsdSkelSkeletonQuery(); }
void GusdPrimWrapper::updateActiveFromGTPrim( const GT_PrimitiveHandle& sourcePrim, UsdTimeCode time) { UsdPrim prim = getUsdPrimForWrite().GetPrim(); GT_Owner attrOwner; GT_DataArrayHandle houAttr = sourcePrim->findAttribute(GUSD_ACTIVE_ATTR, attrOwner, 0); if (houAttr) { int active = houAttr->getI32(0); prim.SetActive((bool)active); } }
/// Finds the rootmost ancestor of the prim at \p path that is an Xform /// or SkelRoot type prim. The result may be the prim itself. static UsdPrim _FindRootmostXformOrSkelRoot(const UsdStagePtr& stage, const SdfPath& path) { UsdPrim currentPrim = stage->GetPrimAtPath(path); UsdPrim rootmost; while (currentPrim) { if (currentPrim.IsA<UsdGeomXform>()) { rootmost = currentPrim; } else if (currentPrim.IsA<UsdSkelRoot>()) { rootmost = currentPrim; } currentPrim = currentPrim.GetParent(); } return rootmost; }
UsdGeomXformOp::UsdGeomXformOp( UsdPrim const& prim, UsdGeomXformOp::Type const opType, UsdGeomXformOp::Precision const precision, TfToken const &opSuffix, bool isInverseOp) : _opType(opType) , _isInverseOp(isInverseOp) { // Determine the typeName of the xformOp attribute to be created. const SdfValueTypeName &typeName = GetValueTypeName(opType, precision); if (!typeName) { TF_CODING_ERROR("Invalid xform-op: incompatible combination of " "opType (%s) and precision (%s).", TfEnum::GetName(opType).c_str(), TfEnum::GetName(precision).c_str()); return; } TfToken attrName = UsdGeomXformOp::GetOpName(opType, opSuffix, // isInverseOp is handled below /*isInverseOp*/ false); // attrName can never be empty. TF_VERIFY(!attrName.IsEmpty()); // Create an attribute in the xformOp: namespace with the // computed typeName. _attr = prim.CreateAttribute(attrName, typeName, /* custom */ false); // If a problem occurred, an error should already have been issued, // and _attr will be invalid, which is what we want }
void UsdRiStatementsAPI::SetCoordinateSystem(const std::string &coordSysName) { UsdAttribute attr = GetPrim().CreateAttribute(_tokens->coordsys, SdfValueTypeNames->String, /* custom = */ false); if (TF_VERIFY(attr)) { attr.Set(coordSysName); UsdPrim currPrim = GetPrim(); while (currPrim && currPrim.GetPath() != SdfPath::AbsoluteRootPath()) { if (currPrim.IsModel() && !currPrim.IsGroup() && currPrim.GetPath() != SdfPath::AbsoluteRootPath()) { UsdRelationship rel = currPrim.CreateRelationship(_tokens->modelCoordsys, /* custom = */ false); if (TF_VERIFY(rel)) { // Order should not matter, since these are a set, // but historically we have appended these. rel.AddTarget(GetPrim().GetPath()); } break; } currPrim = currPrim.GetParent(); } } }
// For now, this is only used by the mesh op. If this logic needs to be // accessed elsewhere, it should move down into usdKatana. static void _CreateFaceSetsFromFaceSetAPI( const UsdPrim& prim, const PxrUsdKatanaUsdInPrivateData &data, FnKat::GeolibCookInterface& interface) { UsdGeomFaceSetAPI faceSet = UsdShadeMaterial::GetMaterialFaceSet(prim); bool isPartition = faceSet.GetIsPartition();; if (!isPartition) { TF_WARN("Found face set on prim <%s> that is not a partition.", prim.GetPath().GetText()); // continue here? } const double currentTime = data.GetCurrentTime(); VtIntArray faceCounts, faceIndices; faceSet.GetFaceCounts(&faceCounts, currentTime); faceSet.GetFaceIndices(&faceIndices, currentTime); SdfPathVector bindingTargets; faceSet.GetBindingTargets(&bindingTargets); size_t faceSetIdxStart = 0; for(size_t faceSetIdx = 0; faceSetIdx < faceCounts.size(); ++faceSetIdx) { size_t faceCount = faceCounts[faceSetIdx]; FnKat::GroupBuilder faceSetAttrs; faceSetAttrs.set("type", FnKat::StringAttribute("faceset")); faceSetAttrs.set("materialAssign", FnKat::StringAttribute( PxrUsdKatanaUtils::ConvertUsdMaterialPathToKatLocation( bindingTargets[faceSetIdx], data))); FnKat::IntBuilder facesBuilder; { std::vector<int> faceIndicesVec(faceCount); for (size_t faceIndicesIdx = 0; faceIndicesIdx < faceCount; ++faceIndicesIdx) { faceIndicesVec[faceIndicesIdx] = faceIndices[faceSetIdxStart + faceIndicesIdx]; } faceSetIdxStart += faceCount; facesBuilder.set(faceIndicesVec); } faceSetAttrs.set("geometry.faces", facesBuilder.build()); std::string faceSetName = TfStringPrintf("faceset_%zu", faceSetIdx); FnKat::GroupBuilder staticSceneCreateAttrs; staticSceneCreateAttrs.set("a", faceSetAttrs.build()); interface.createChild( faceSetName, "StaticSceneCreate", staticSceneCreateAttrs.build()); } }
/* virtual */ void UsdImagingMaterialAdapter::MarkMaterialDirty(UsdPrim const& prim, SdfPath const& cachePath, UsdImagingIndexProxy* index) { // If this is invoked on behalf of a Shader prim underneath a // Material prim, walk up to the enclosing Material. SdfPath materialCachePath = cachePath; UsdPrim materialPrim = prim; while (materialPrim && !materialPrim.IsA<UsdShadeMaterial>()) { materialPrim = materialPrim.GetParent(); materialCachePath = materialCachePath.GetParentPath(); } if (!TF_VERIFY(materialPrim)) { return; } index->MarkSprimDirty(materialCachePath, HdMaterial::DirtyResource); }
void UsdImagingPointsAdapter::_GetPoints(UsdPrim const& prim, VtValue* value, UsdTimeCode time) { HD_TRACE_FUNCTION(); if (!prim.GetAttribute(UsdGeomTokens->points).Get(value, time)) { *value = VtVec3fArray(); } }
bool GusdBoundsCache::_ComputeBound( const UsdPrim &prim, UsdTimeCode time, const TfTokenVector &includedPurposes, ComputeFunc boundFunc, UT_BoundingBox &bounds ) { if( !prim.IsValid() ) return false; TfToken stageId( prim.GetStage()->GetRootLayer()->GetRealPath() ); MapType::accessor accessor; if( !m_map.find( accessor, Key( stageId, includedPurposes ))) { m_map.insert( accessor, Key( stageId, includedPurposes ) ); accessor->second = new Item( time, includedPurposes ); } std::lock_guard<std::mutex> lock(accessor->second->lock); UsdGeomBBoxCache& cache = accessor->second->bboxCache; cache.SetTime( time ); // boundFunc is either ComputeWorldBound or ComputeLocalBound GfBBox3d primBBox = (cache.*boundFunc)(prim); if( !primBBox.GetRange().IsEmpty() ) { const GfRange3d rng = primBBox.ComputeAlignedRange(); bounds = UT_BoundingBox( rng.GetMin()[0], rng.GetMin()[1], rng.GetMin()[2], rng.GetMax()[0], rng.GetMax()[1], rng.GetMax()[2]); return true; } return false; }
void _writeUsdInfo( const MDagPath& dag, const UsdTimeCode& usdTime, const UsdPrim& prim) { MFnDependencyNode depFn(dag.node()); bool instanceable = false; if (PxrUsdMayaUtil::getPlugValue(depFn, "USD_instanceable", &instanceable)) { prim.SetInstanceable(instanceable); } // We only author hidden if it's to set it to true. bool hidden = false; if (PxrUsdMayaUtil::getPlugValue(depFn, "USD_hidden", &hidden) and hidden) { prim.SetHidden(hidden); } }
static void _AddPrimToInheritedPrimvars(const UsdPrim &prim, const TfToken &pvPrefix, const std::vector<UsdGeomPrimvar> *inputPrimvars, std::vector<UsdGeomPrimvar> *outputPrimvars, bool acceptAll) { auto copyPrimvars = [&inputPrimvars,&outputPrimvars]() { if (inputPrimvars != outputPrimvars){ *outputPrimvars = *inputPrimvars; inputPrimvars = outputPrimvars; } }; for (UsdProperty const& prop: prim.GetAuthoredPropertiesInNamespace(pvPrefix)) { if (UsdGeomPrimvar pv = UsdGeomPrimvar(prop.As<UsdAttribute>())) { // If the primvar does not provide a value, then it is as if it // does not exist on prim if (!pv.HasAuthoredValue()) { continue; } // If pv is constant it will replace an instance already on the list; // if non-constant we'll just remove it. const TfToken &name = pv.GetName(); size_t i; bool pvIsConstant = pv.GetInterpolation() == UsdGeomTokens->constant; bool foundMatch = false; for (i=0; i < inputPrimvars->size(); ++i) { if (name == (*inputPrimvars)[i].GetName()) { copyPrimvars(); foundMatch = true; if (pvIsConstant || acceptAll){ (*outputPrimvars)[i] = std::move(pv); break; } else { // Swap to the end and truncate the vector. // Don't bother to preserve order. std::swap((*outputPrimvars)[i], outputPrimvars->back()); outputPrimvars->pop_back(); break; } } } if ( !foundMatch && (pvIsConstant || acceptAll)) { copyPrimvars(); outputPrimvars->push_back(std::move(pv)); } } } }
UsdImagingPrimAdapterSharedPtr UsdImagingIndexProxy::GetMaterialAdapter(UsdPrim const& materialPrim) { if (!TF_VERIFY(!materialPrim.IsInstance())) { return nullptr; } UsdImagingPrimAdapterSharedPtr materialAdapter = _delegate->_AdapterLookup(materialPrim, false); return materialAdapter && materialAdapter->IsSupported(this) ? materialAdapter : nullptr; }