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