bool PxrUsdKatana_AreRelTargetsFromBaseMaterial(const UsdRelationship &rel) { // Find the strongest opinion about the relationship targets. SdfRelationshipSpecHandle strongestRelSpec; SdfPropertySpecHandleVector propStack = rel.GetPropertyStack(); for (const SdfPropertySpecHandle &prop: propStack) { if (SdfRelationshipSpecHandle relSpec = TfDynamic_cast<SdfRelationshipSpecHandle>(prop)) { if (relSpec->HasTargetPathList()) { strongestRelSpec = relSpec; break; } } } // Find which prim node introduced that opinion. if (strongestRelSpec) { for(const PcpNodeRef &node: rel.GetPrim().GetPrimIndex().GetNodeRange()) { if (node.GetPath() == strongestRelSpec->GetPath().GetPrimPath() && node.GetLayerStack()->HasLayer(strongestRelSpec->GetLayer())) { return _NodeRepresentsLiveBaseMaterial(node); } } } return false; }
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(); } } }
UsdRelationship UsdPrim::CreateRelationship(const TfToken& name, bool custom) const { UsdRelationship rel = GetRelationship(name); rel._Create(custom); return rel; }
void UsdRiStatementsAPI::SetScopedCoordinateSystem(const std::string &coordSysName) { UsdAttribute attr = GetPrim().CreateAttribute(_tokens->scopedCoordsys, SdfValueTypeNames->String, /* custom = */ false); if (TF_VERIFY(attr)) { attr.Set(coordSysName); UsdPrim currPrim = GetPrim(); while (currPrim) { if (currPrim.IsModel() && !currPrim.IsGroup() && currPrim.GetPath() != SdfPath::AbsoluteRootPath()) { UsdRelationship rel = currPrim.CreateRelationship(_tokens->modelScopedCoordsys, /* custom = */ false); if (TF_VERIFY(rel)) { rel.AddTarget(GetPrim().GetPath()); } break; } currPrim = currPrim.GetParent(); } } }
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; }
static string __repr__(const UsdRelationship &self) { if (self) { return TfStringPrintf("%s.GetRelationship(%s)", TfPyRepr(self.GetPrim()).c_str(), TfPyRepr(self.GetName()).c_str()); } else { return "invalid " + self.GetDescription(); } }
bool UsdRiStatementsAPI::GetModelScopedCoordinateSystems(SdfPathVector *targets) const { if (GetPrim().IsModel()) { UsdRelationship rel = GetPrim().GetRelationship(_tokens->modelScopedCoordsys); return rel && rel.GetForwardedTargets(targets); } return true; }
bool UsdGeomCollectionAPI::IsEmpty() const { UsdRelationship targetsRel = _GetTargetsRel(); if (targetsRel) { SdfPathVector targets; targetsRel.GetTargets(&targets); return targets.empty(); } return true; }
bool UsdVolVolume::BlockFieldRelationship(const TfToken &name) const { UsdRelationship fieldRel = GetPrim().GetRelationship(_MakeNamespaced(name)); if (fieldRel){ fieldRel.BlockTargets(); return true; } else { 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; }
static SdfPathVector _GetForwardedTargets(const UsdRelationship &self, bool forwardToObjectsInMasters) { SdfPathVector result; self.GetForwardedTargets(&result, forwardToObjectsInMasters); return result; }
PXR_NAMESPACE_OPEN_SCOPE // TODO: We should centralize this logic in a UsdImaging ShaderAdapter. /*static*/ UsdPrim UsdImaging_MaterialStrategy::GetTargetedShader(UsdPrim const& materialPrim, UsdRelationship const& materialRel) { SdfPathVector targets; if (!materialRel.GetForwardedTargets(&targets)) return UsdPrim(); if (targets.size() != 1) { // XXX: This should really be a validation error once USD gets that // feature. TF_WARN("We expect only one target on relationship %s of prim <%s>, " "but got %zu.", materialRel.GetName().GetText(), materialPrim.GetPath().GetText(), targets.size()); return UsdPrim(); } if (!targets[0].IsPrimPath()) { // XXX: This should really be a validation error once USD gets that // feature. TF_WARN("We expect the target of the relationship %s of prim <%s> " "to be a prim, instead it is <%s>.", materialRel.GetName().GetText(), materialPrim.GetPath().GetText(), targets[0].GetText()); return UsdPrim(); } return materialPrim.GetStage()->GetPrimAtPath(targets[0]); }
bool UsdGeomCollectionAPI::GetTargets(SdfPathVector *targets) const { UsdRelationship rel = _GetTargetsRel(); return rel && rel.GetTargets(targets); }
void PxrUsdKatanaReadPointInstancer( const UsdGeomPointInstancer& instancer, const PxrUsdKatanaUsdInPrivateData& data, PxrUsdKatanaAttrMap& instancerAttrMap, PxrUsdKatanaAttrMap& sourcesAttrMap, PxrUsdKatanaAttrMap& instancesAttrMap, PxrUsdKatanaAttrMap& inputAttrMap) { const double currentTime = data.GetCurrentTime(); PxrUsdKatanaReadXformable(instancer, data, instancerAttrMap); // Get primvars for setting later. Unfortunatley, the only way to get them // out of the attr map is to build it, which will cause its contents to be // cleared. We'll need to restore its contents before continuing. // FnKat::GroupAttribute instancerAttrs = instancerAttrMap.build(); FnKat::GroupAttribute primvarAttrs = instancerAttrs.getChildByName("geometry.arbitrary"); for (int64_t i = 0; i < instancerAttrs.getNumberOfChildren(); ++i) { instancerAttrMap.set(instancerAttrs.getChildName(i), instancerAttrs.getChildByIndex(i)); } instancerAttrMap.set("type", FnKat::StringAttribute("usd point instancer")); const std::string fileName = data.GetUsdInArgs()->GetFileName(); instancerAttrMap.set("info.usd.fileName", FnKat::StringAttribute(fileName)); FnKat::GroupAttribute inputAttrs = inputAttrMap.build(); const std::string katOutputPath = FnKat::StringAttribute( inputAttrs.getChildByName("outputLocationPath")).getValue("", false); if (katOutputPath.empty()) { _LogAndSetError(instancerAttrMap, "No output location path specified"); return; } // // Validate instancer data. // const std::string instancerPath = instancer.GetPath().GetString(); UsdStageWeakPtr stage = instancer.GetPrim().GetStage(); // Prototypes (required) // SdfPathVector protoPaths; instancer.GetPrototypesRel().GetTargets(&protoPaths); if (protoPaths.empty()) { _LogAndSetError(instancerAttrMap, "Instancer has no prototypes"); return; } _PathToPrimMap primCache; for (auto protoPath : protoPaths) { const UsdPrim &protoPrim = stage->GetPrimAtPath(protoPath); primCache[protoPath] = protoPrim; } // Indices (required) // VtIntArray protoIndices; if (!instancer.GetProtoIndicesAttr().Get(&protoIndices, currentTime)) { _LogAndSetError(instancerAttrMap, "Instancer has no prototype indices"); return; } const size_t numInstances = protoIndices.size(); if (numInstances == 0) { _LogAndSetError(instancerAttrMap, "Instancer has no prototype indices"); return; } for (auto protoIndex : protoIndices) { if (protoIndex < 0 || static_cast<size_t>(protoIndex) >= protoPaths.size()) { _LogAndSetError(instancerAttrMap, TfStringPrintf( "Out of range prototype index %d", protoIndex)); return; } } // Mask (optional) // std::vector<bool> pruneMaskValues = instancer.ComputeMaskAtTime(currentTime); if (!pruneMaskValues.empty() and pruneMaskValues.size() != numInstances) { _LogAndSetError(instancerAttrMap, "Mismatch in length of indices and mask"); return; } // Positions (required) // UsdAttribute positionsAttr = instancer.GetPositionsAttr(); if (!positionsAttr.HasValue()) { _LogAndSetError(instancerAttrMap, "Instancer has no positions"); return; } // // Compute instance transform matrices. // const double timeCodesPerSecond = stage->GetTimeCodesPerSecond(); // Gather frame-relative sample times and add them to the current time to // generate absolute sample times. // const std::vector<double> &motionSampleTimes = data.GetMotionSampleTimes(positionsAttr); const size_t sampleCount = motionSampleTimes.size(); std::vector<UsdTimeCode> sampleTimes(sampleCount); for (size_t a = 0; a < sampleCount; ++a) { sampleTimes[a] = UsdTimeCode(currentTime + motionSampleTimes[a]); } // Get velocityScale from the opArgs. // float velocityScale = FnKat::FloatAttribute( inputAttrs.getChildByName("opArgs.velocityScale")).getValue(1.0f, false); // XXX Replace with UsdGeomPointInstancer::ComputeInstanceTransformsAtTime. // std::vector<std::vector<GfMatrix4d>> xformSamples(sampleCount); const size_t numXformSamples = _ComputeInstanceTransformsAtTime(xformSamples, instancer, sampleTimes, UsdTimeCode(currentTime), timeCodesPerSecond, numInstances, positionsAttr, velocityScale); if (numXformSamples == 0) { _LogAndSetError(instancerAttrMap, "Could not compute " "sample/topology-invarying instance " "transform matrix"); return; } // // Compute prototype bounds. // bool aggregateBoundsValid = false; std::vector<double> aggregateBounds; // XXX Replace with UsdGeomPointInstancer::ComputeExtentAtTime. // VtVec3fArray aggregateExtent; if (_ComputeExtentAtTime( aggregateExtent, data.GetUsdInArgs(), xformSamples, motionSampleTimes, protoIndices, protoPaths, primCache, pruneMaskValues)) { aggregateBoundsValid = true; aggregateBounds.resize(6); aggregateBounds[0] = aggregateExtent[0][0]; // min x aggregateBounds[1] = aggregateExtent[1][0]; // max x aggregateBounds[2] = aggregateExtent[0][1]; // min y aggregateBounds[3] = aggregateExtent[1][1]; // max y aggregateBounds[4] = aggregateExtent[0][2]; // min z aggregateBounds[5] = aggregateExtent[1][2]; // max z } // // Build sources. Keep track of which instances use them. // FnGeolibServices::StaticSceneCreateOpArgsBuilder sourcesBldr(false); std::vector<int> instanceIndices; instanceIndices.reserve(numInstances); std::vector<std::string> instanceSources; instanceSources.reserve(protoPaths.size()); std::map<std::string, int> instanceSourceIndexMap; std::vector<int> omitList; omitList.reserve(numInstances); std::map<SdfPath, std::string> protoPathsToKatPaths; for (size_t i = 0; i < numInstances; ++i) { int index = protoIndices[i]; // Check to see if we are pruned. // bool isPruned = (!pruneMaskValues.empty() and pruneMaskValues[i] == false); if (isPruned) { omitList.push_back(i); } const SdfPath &protoPath = protoPaths[index]; // Compute the full (Katana) path to this prototype. // std::string fullProtoPath; std::map<SdfPath, std::string>::const_iterator pptkpIt = protoPathsToKatPaths.find(protoPath); if (pptkpIt != protoPathsToKatPaths.end()) { fullProtoPath = pptkpIt->second; } else { _PathToPrimMap::const_iterator pcIt = primCache.find(protoPath); const UsdPrim &protoPrim = pcIt->second; if (!protoPrim) { continue; } // Determine where (what path) to start building the prototype prim // such that its material bindings will be preserved. This could be // the prototype path itself or an ancestor path. // SdfPathVector commonPrefixes; UsdRelationship materialBindingsRel = UsdShadeMaterial::GetBindingRel(protoPrim); auto assetAPI = UsdModelAPI(protoPrim); std::string assetName; bool isReferencedModelPrim = assetAPI.IsModel() and assetAPI.GetAssetName(&assetName); if (!materialBindingsRel or isReferencedModelPrim) { // The prim has no material bindings or is a referenced model // prim (meaning that materials are defined below it); start // building at the prototype path. // commonPrefixes.push_back(protoPath); } else { SdfPathVector materialPaths; materialBindingsRel.GetForwardedTargets(&materialPaths); for (auto materialPath : materialPaths) { const SdfPath &commonPrefix = protoPath.GetCommonPrefix(materialPath); if (commonPrefix.GetString() == "/") { // XXX Unhandled case. // The prototype prim and its material are not under the // same parent; start building at the prototype path // (although it is likely that bindings will be broken). // commonPrefixes.push_back(protoPath); } else { // Start building at the common ancestor between the // prototype prim and its material. // commonPrefixes.push_back(commonPrefix); } } } // XXX Unhandled case. // We'll use the first common ancestor even if there is more than // one (which shouldn't appen if the prototype prim and its bindings // are under the same parent). // SdfPath::RemoveDescendentPaths(&commonPrefixes); const std::string buildPath = commonPrefixes[0].GetString(); // See if the path is a child of the point instancer. If so, we'll // match its hierarchy. If not, we'll put it under a 'prototypes' // group. // std::string relBuildPath; if (pystring::startswith(buildPath, instancerPath + "/")) { relBuildPath = pystring::replace( buildPath, instancerPath + "/", ""); } else { relBuildPath = "prototypes/" + FnGeolibUtil::Path::GetLeafName(buildPath); } // Start generating the full path to the prototype. // fullProtoPath = katOutputPath + "/" + relBuildPath; // Make the common ancestor our instance source. // sourcesBldr.setAttrAtLocation(relBuildPath, "type", FnKat::StringAttribute("instance source")); // Author a tracking attr. // sourcesBldr.setAttrAtLocation(relBuildPath, "info.usd.sourceUsdPath", FnKat::StringAttribute(buildPath)); // Tell the BuildIntermediate op to start building at the common // ancestor. // sourcesBldr.setAttrAtLocation(relBuildPath, "usdPrimPath", FnKat::StringAttribute(buildPath)); sourcesBldr.setAttrAtLocation(relBuildPath, "usdPrimName", FnKat::StringAttribute("geo")); if (protoPath.GetString() != buildPath) { // Finish generating the full path to the prototype. // fullProtoPath = fullProtoPath + "/geo" + pystring::replace( protoPath.GetString(), buildPath, ""); } // Create a mapping that will link the instance's index to its // prototype's full path. // instanceSourceIndexMap[fullProtoPath] = instanceSources.size(); instanceSources.push_back(fullProtoPath); // Finally, store the full path in the map so we won't have to do // this work again. // protoPathsToKatPaths[protoPath] = fullProtoPath; } instanceIndices.push_back(instanceSourceIndexMap[fullProtoPath]); } // // Build instances. // FnGeolibServices::StaticSceneCreateOpArgsBuilder instancesBldr(false); instancesBldr.createEmptyLocation("instances", "instance array"); instancesBldr.setAttrAtLocation("instances", "geometry.instanceSource", FnKat::StringAttribute(instanceSources, 1)); instancesBldr.setAttrAtLocation("instances", "geometry.instanceIndex", FnKat::IntAttribute(&instanceIndices[0], instanceIndices.size(), 1)); FnKat::DoubleBuilder instanceMatrixBldr(16); for (size_t a = 0; a < numXformSamples; ++a) { double relSampleTime = motionSampleTimes[a]; // Shove samples into the builder at the frame-relative sample time. If // motion is backwards, make sure to reverse time samples. std::vector<double> &matVec = instanceMatrixBldr.get( data.IsMotionBackward() ? PxrUsdKatanaUtils::ReverseTimeSample(relSampleTime) : relSampleTime); matVec.reserve(16 * numInstances); for (size_t i = 0; i < numInstances; ++i) { GfMatrix4d instanceXform = xformSamples[a][i]; const double *matArray = instanceXform.GetArray(); for (int j = 0; j < 16; ++j) { matVec.push_back(matArray[j]); } } } instancesBldr.setAttrAtLocation("instances", "geometry.instanceMatrix", instanceMatrixBldr.build()); if (!omitList.empty()) { instancesBldr.setAttrAtLocation("instances", "geometry.omitList", FnKat::IntAttribute(&omitList[0], omitList.size(), 1)); } instancesBldr.setAttrAtLocation("instances", "geometry.pointInstancerId", FnKat::StringAttribute(katOutputPath)); // // Transfer primvars. // FnKat::GroupBuilder instancerPrimvarsBldr; FnKat::GroupBuilder instancesPrimvarsBldr; for (int64_t i = 0; i < primvarAttrs.getNumberOfChildren(); ++i) { const std::string primvarName = primvarAttrs.getChildName(i); // Use "point" scope for the instancer. instancerPrimvarsBldr.set(primvarName, primvarAttrs.getChildByIndex(i)); instancerPrimvarsBldr.set(primvarName + ".scope", FnKat::StringAttribute("point")); // User "primitive" scope for the instances. instancesPrimvarsBldr.set(primvarName, primvarAttrs.getChildByIndex(i)); instancesPrimvarsBldr.set(primvarName + ".scope", FnKat::StringAttribute("primitive")); } instancerAttrMap.set("geometry.arbitrary", instancerPrimvarsBldr.build()); instancesBldr.setAttrAtLocation("instances", "geometry.arbitrary", instancesPrimvarsBldr.build()); // // Set the final aggregate bounds. // if (aggregateBoundsValid) { instancerAttrMap.set("bound", FnKat::DoubleAttribute(&aggregateBounds[0], 6, 2)); } // // Set proxy attrs. // instancerAttrMap.set("proxies", PxrUsdKatanaUtils::GetViewerProxyAttr(data)); // // Transfer builder results to our attr maps. // FnKat::GroupAttribute sourcesAttrs = sourcesBldr.build(); for (int64_t i = 0; i < sourcesAttrs.getNumberOfChildren(); ++i) { sourcesAttrMap.set( sourcesAttrs.getChildName(i), sourcesAttrs.getChildByIndex(i)); } FnKat::GroupAttribute instancesAttrs = instancesBldr.build(); for (int64_t i = 0; i < instancesAttrs.getNumberOfChildren(); ++i) { instancesAttrMap.set( instancesAttrs.getChildName(i), instancesAttrs.getChildByIndex(i)); } }
bool PxrUsdTranslators_InstancerWriter::writeInstancerAttrs( const UsdTimeCode& usdTime, const UsdGeomPointInstancer& instancer) { MStatus status = MS::kSuccess; MFnDagNode dagNode(GetDagPath(), &status); CHECK_MSTATUS_AND_RETURN(status, false); // Note: In this function, we don't read instances using the provided // MFnInstancer API. One reason is that it breaks up prototypes into their // constituent shapes, and there's no way to figure out which hierarchy // they came from. Another reason is that it only provides computed matrices // and not separate position, rotation, scale attrs. const SdfPath prototypesGroupPath = instancer.GetPrim().GetPath().AppendChild(_tokens->Prototypes); // At the default time, setup all the prototype instances. if (usdTime.IsDefault()) { const MPlug inputHierarchy = dagNode.findPlug("inputHierarchy", true, &status); CHECK_MSTATUS_AND_RETURN(status, false); // Note that the "Prototypes" prim needs to be a model group to ensure // contiguous model hierarchy. const UsdPrim prototypesGroupPrim = GetUsdStage()->DefinePrim( prototypesGroupPath); UsdModelAPI(prototypesGroupPrim).SetKind(KindTokens->group); _modelPaths.push_back(prototypesGroupPath); UsdRelationship prototypesRel = instancer.CreatePrototypesRel(); const unsigned int numElements = inputHierarchy.numElements(); for (unsigned int i = 0; i < numElements; ++i) { const MPlug plug = inputHierarchy[i]; const MPlug source(UsdMayaUtil::GetConnected(plug)); if (source.isNull()) { TF_WARN("Cannot read prototype: the source plug %s was null", plug.name().asChar()); return false; } MFnDagNode sourceNode(source.node(), &status); CHECK_MSTATUS_AND_RETURN(status, false); MDagPath prototypeDagPath; sourceNode.getPath(prototypeDagPath); // Prototype names are guaranteed unique by virtue of having a // unique numerical suffix _# indicating the prototype index. const TfToken prototypeName( TfStringPrintf("%s_%d", sourceNode.name().asChar(), i)); const SdfPath prototypeUsdPath = prototypesGroupPrim.GetPath() .AppendChild(prototypeName); UsdPrim prototypePrim = GetUsdStage()->DefinePrim( prototypeUsdPath); _modelPaths.push_back(prototypeUsdPath); // Try to be conservative and only create an intermediary xformOp // with the instancerTranslate if we can ensure that we don't need // to compensate for the translation on the prototype root. // // XXX: instancerTranslate does not behave well when added to a // reference that has an existing transform on the far side of the // reference. However, its behavior at least matches the // behavior in UsdMayaTranslatorModelAssembly. If we fix the // behavior there, we need to make sure that this is also // fixed to match. bool instancerTranslateAnimated = false; if (_NeedsExtraInstancerTranslate( prototypeDagPath, &instancerTranslateAnimated)) { UsdGeomXformable xformable(prototypePrim); UsdGeomXformOp newOp = xformable.AddTranslateOp( UsdGeomXformOp::PrecisionDouble, _tokens->instancerTranslate); _instancerTranslateOps.push_back( {prototypeDagPath, newOp, instancerTranslateAnimated}); } // Two notes: // (1) We don't un-instance here, because it's OK for the prototype // to just be a reference to an instance master if the prototype // participates in Maya native instancing. // (2) The prototype root must be visible to match Maya's behavior, // which always vis'es the prototype root, even if it is marked // hidden. _writeJobCtx.CreatePrimWriterHierarchy( prototypeDagPath, prototypeUsdPath, /*forceUninstance*/ false, /*exportRootVisibility*/ false, &_prototypeWriters); prototypesRel.AddTarget(prototypeUsdPath); } _numPrototypes = numElements; } // If there aren't any prototypes, fail and don't export on subsequent // time-sampled exports. if (_numPrototypes == 0) { return false; } // Actual write of prototypes (@ both default time and animated time). for (UsdMayaPrimWriterSharedPtr& writer : _prototypeWriters) { writer->Write(usdTime); if (usdTime.IsDefault()) { // Prototype roots should have kind component or derived. // Calling Write() above may have populated kinds, so don't stomp // over existing component-derived kinds. // (Note that ModelKindWriter's fix-up stage might change this.) if (writer->GetUsdPath().GetParentPath() == prototypesGroupPath) { if (const UsdPrim writerPrim = writer->GetUsdPrim()) { UsdModelAPI primModelAPI(writerPrim); TfToken kind; primModelAPI.GetKind(&kind); if (!KindRegistry::IsA(kind, KindTokens->component)) { primModelAPI.SetKind(KindTokens->component); } } } } } // Write the instancerTranslate xformOp for all prims that need it. // (This should happen @ default time or animated time depending on whether // the xform is animated.) for (const _TranslateOpData& opData : _instancerTranslateOps) { if (opData.isAnimated != usdTime.IsDefault()) { GfVec3d origin; if (_GetTransformedOriginInLocalSpace(opData.mayaPath, &origin)) { UsdGeomXformOp translateOp = opData.op; _SetAttribute(translateOp.GetAttr(), -origin, usdTime); } } } // Grab the inputPoints data from the source plug. // (This attribute's value must come from a source plug; it isn't // directly writeable. Thus reading it directly may not give the right // value depending on Maya's execution behavior.) MPlug inputPointsDest = dagNode.findPlug("inputPoints", true, &status); CHECK_MSTATUS_AND_RETURN(status, false); MPlug inputPointsSrc = UsdMayaUtil::GetConnected(inputPointsDest); if (inputPointsSrc.isNull()) { TF_WARN("inputPoints not connected on instancer '%s'", GetDagPath().fullPathName().asChar()); return false; } auto holder = UsdMayaUtil::GetPlugDataHandle(inputPointsSrc); if (!holder) { TF_WARN("Unable to read inputPoints data handle for instancer '%s'", GetDagPath().fullPathName().asChar()); return false; } MFnArrayAttrsData inputPointsData(holder->GetDataHandle().data(), &status); CHECK_MSTATUS_AND_RETURN(status, false); if (!UsdMayaWriteUtil::WriteArrayAttrsToInstancer( inputPointsData, instancer, _numPrototypes, usdTime, _GetSparseValueWriter())) { return false; } // Load the completed point instancer to compute and set its extent. instancer.GetPrim().GetStage()->Load(instancer.GetPath()); VtArray<GfVec3f> extent(2); if (instancer.ComputeExtentAtTime(&extent, usdTime, usdTime)) { _SetAttribute(instancer.CreateExtentAttr(), &extent, usdTime); } return true; }
void _Visit(UsdRelationship const &rel) { SdfPathVector targets; rel._GetForwardedTargets(&targets, /*includeForwardingRels=*/true); _VisitImpl(targets); }
bool UsdGeomPointInstancer::ComputeInstanceTransformsAtTime( VtArray<GfMatrix4d>* xforms, const UsdTimeCode time, const UsdTimeCode baseTime, const ProtoXformInclusion doProtoXforms, const MaskApplication applyMask) const { // XXX: Need to add handling of velocities/angularVelocities and baseTime. (void)baseTime; if (!xforms) { TF_WARN("%s -- null container passed to ComputeInstanceTransformsAtTime()", GetPrim().GetPath().GetText()); return false; } VtIntArray protoIndices; if (!GetProtoIndicesAttr().Get(&protoIndices, time)) { TF_WARN("%s -- no prototype indices", GetPrim().GetPath().GetText()); return false; } if (protoIndices.empty()) { xforms->clear(); return true; } VtVec3fArray positions; if (!GetPositionsAttr().Get(&positions, time)) { TF_WARN("%s -- no positions", GetPrim().GetPath().GetText()); return false; } if (positions.size() != protoIndices.size()) { TF_WARN("%s -- positions.size() [%zu] != protoIndices.size() [%zu]", GetPrim().GetPath().GetText(), positions.size(), protoIndices.size()); return false; } VtVec3fArray scales; GetScalesAttr().Get(&scales, time); if (!scales.empty() && scales.size() != protoIndices.size()) { TF_WARN("%s -- scales.size() [%zu] != protoIndices.size() [%zu]", GetPrim().GetPath().GetText(), scales.size(), protoIndices.size()); return false; } VtQuathArray orientations; GetOrientationsAttr().Get(&orientations, time); if (!orientations.empty() && orientations.size() != protoIndices.size()) { TF_WARN("%s -- orientations.size() [%zu] != protoIndices.size() [%zu]", GetPrim().GetPath().GetText(), orientations.size(), protoIndices.size()); return false; } // If we're going to include the prototype transforms, verify that we have // prototypes and that all of the protoIndices are in bounds. SdfPathVector protoPaths; if (doProtoXforms == IncludeProtoXform) { const UsdRelationship prototypes = GetPrototypesRel(); if (!prototypes.GetTargets(&protoPaths) || protoPaths.empty()) { TF_WARN("%s -- no prototypes", GetPrim().GetPath().GetText()); return false; } TF_FOR_ALL(iter, protoIndices) { const int protoIndex = *iter; if (protoIndex < 0 || static_cast<size_t>(protoIndex) >= protoPaths.size()) { TF_WARN("%s -- invalid prototype index: %d. Should be in [0, %zu)", GetPrim().GetPath().GetText(), protoIndex, protoPaths.size()); return false; } } } // Compute the mask only if applyMask says we should, otherwise we leave // mask empty so that its application below is a no-op. std::vector<bool> mask; if (applyMask == ApplyMask) { mask = ComputeMaskAtTime(time); if (!mask.empty() && mask.size() != protoIndices.size()) { TF_WARN("%s -- mask.size() [%zu] != protoIndices.size() [%zu]", GetPrim().GetPath().GetText(), mask.size(), protoIndices.size()); return false; } } UsdStageWeakPtr stage = GetPrim().GetStage(); UsdGeomXformCache xformCache(time); xforms->assign(protoIndices.size(), GfMatrix4d(1.0)); for (size_t instanceId = 0; instanceId < protoIndices.size(); ++instanceId) { if (!mask.empty() && !mask[instanceId]) { continue; } GfTransform instanceTransform; if (!scales.empty()) { instanceTransform.SetScale(scales[instanceId]); } if (!orientations.empty()) { instanceTransform.SetRotation(GfRotation(orientations[instanceId])); } instanceTransform.SetTranslation(positions[instanceId]); GfMatrix4d protoXform(1.0); if (doProtoXforms == IncludeProtoXform) { const int protoIndex = protoIndices[instanceId]; const SdfPath& protoPath = protoPaths[protoIndex]; const UsdPrim& protoPrim = stage->GetPrimAtPath(protoPath); if (protoPrim) { // Get the prototype's local transformation. bool resetsXformStack; protoXform = xformCache.GetLocalTransformation(protoPrim, &resetsXformStack); } } (*xforms)[instanceId] = protoXform * instanceTransform.GetMatrix(); } return ApplyMaskToArray(mask, xforms); }
static FnKat::Attribute _GetMaterialAssignAttr( const UsdPrim& prim, const PxrUsdKatanaUsdInPrivateData& data) { if (not prim or prim.GetPath() == SdfPath::AbsoluteRootPath()) { // Special-case to pre-empt coding errors. return FnKat::Attribute(); } UsdRelationship usdRel = UsdShadeLook::GetBindingRel(prim); if (usdRel) { // USD shading binding SdfPathVector targetPaths; usdRel.GetForwardedTargets(&targetPaths); if (targetPaths.size() > 0) { if (not targetPaths[0].IsPrimPath()) { FnLogWarn("Target path " << prim.GetPath().GetString() << " is not a prim"); return FnKat::Attribute(); } // This is a copy as it could be modified below. SdfPath targetPath = targetPaths[0]; UsdPrim targetPrim = data.GetUsdInArgs()->GetStage()->GetPrimAtPath(targetPath); // If the target is inside a master, then it needs to be re-targeted // to the instance. // // XXX remove this special awareness once GetMasterWithContext is // is available as the provided prim will automatically // retarget (or provide enough context to retarget without // tracking manually). if (targetPrim and targetPrim.IsInMaster()) { if (not data.GetInstancePath().IsEmpty() and not data.GetMasterPath().IsEmpty()) { // Check if the source and the target of the relationship // belong to the same master. // If they do, we have the context necessary to do the // re-mapping. if (data.GetMasterPath().GetCommonPrefix(targetPath). GetPathElementCount() > 0) { targetPath = data.GetInstancePath().AppendPath( targetPath.ReplacePrefix(targetPath.GetPrefixes()[0], SdfPath::ReflexiveRelativePath())); } else { // Warn saying the target of relationship isn't within // the same master as the source. FnLogWarn("Target path " << prim.GetPath().GetString() << " isn't within the master " << data.GetMasterPath()); return FnKat::Attribute(); } } else { // XXX // When loading beneath a master via an isolatePath // opArg, we can encounter targets which are within masters // but not within the context of a material. // While that would be an error according to the below // warning, it produces the expected results. // This case can occur when expanding pointinstancers as // the sources are made via execution of PxrUsdIn again // at the sub-trees. // Warn saying target of relationship is in a master, // but the associated instance path is unknown! // FnLogWarn("Target path " << prim.GetPath().GetString() // << " is within a master, but the associated " // "instancePath is unknown."); // return FnKat::Attribute(); } } // Convert the target path to the equivalent katana location. // XXX: Looks may have an atypical USD->Katana // path mapping std::string location = PxrUsdKatanaUtils::ConvertUsdLookPathToKatLocation(targetPath, data); // XXX Looks containing only display terminals are causing issues // with katana material manipulation workflows. // For now: exclude any material assign which doesn't include // /Looks/ in the path if (location.find(UsdKatanaTokens->katanaLooksScopePathSubstring) == std::string::npos) { return FnKat::Attribute(); } // location = TfStringReplace(location, "/Looks/", "/Materials/"); // XXX handle multiple assignments return FnKat::StringAttribute(location); } } return FnKat::Attribute(); }
bool UsdGeomPointInstancer::ComputeExtentAtTime( VtVec3fArray* extent, const UsdTimeCode time, const UsdTimeCode baseTime) const { if (!extent) { TF_WARN("%s -- null container passed to ComputeExtentAtTime()", GetPrim().GetPath().GetText()); return false; } VtIntArray protoIndices; if (!GetProtoIndicesAttr().Get(&protoIndices, time)) { TF_WARN("%s -- no prototype indices", GetPrim().GetPath().GetText()); return false; } const std::vector<bool> mask = ComputeMaskAtTime(time); if (!mask.empty() && mask.size() != protoIndices.size()) { TF_WARN("%s -- mask.size() [%zu] != protoIndices.size() [%zu]", GetPrim().GetPath().GetText(), mask.size(), protoIndices.size()); return false; } const UsdRelationship prototypes = GetPrototypesRel(); SdfPathVector protoPaths; if (!prototypes.GetTargets(&protoPaths) || protoPaths.empty()) { TF_WARN("%s -- no prototypes", GetPrim().GetPath().GetText()); return false; } // verify that all the protoIndices are in bounds. TF_FOR_ALL(iter, protoIndices) { const int protoIndex = *iter; if (protoIndex < 0 || static_cast<size_t>(protoIndex) >= protoPaths.size()) { TF_WARN("%s -- invalid prototype index: %d. Should be in [0, %zu)", GetPrim().GetPath().GetText(), protoIndex, protoPaths.size()); return false; } } // Note that we do NOT apply any masking when computing the instance // transforms. This is so that for a particular instance we can determine // both its transform and its prototype. Otherwise, the instanceTransforms // array would have masked instances culled out and we would lose the // mapping to the prototypes. // Masked instances will be culled before being applied to the extent below. VtMatrix4dArray instanceTransforms; if (!ComputeInstanceTransformsAtTime(&instanceTransforms, time, baseTime, IncludeProtoXform, IgnoreMask)) { TF_WARN("%s -- could not compute instance transforms", GetPrim().GetPath().GetText()); return false; } UsdStageWeakPtr stage = GetPrim().GetStage(); const TfTokenVector purposes { UsdGeomTokens->default_, UsdGeomTokens->proxy, UsdGeomTokens->render }; UsdGeomBBoxCache bboxCache(time, purposes); bboxCache.SetTime(time); GfRange3d extentRange; for (size_t instanceId = 0; instanceId < protoIndices.size(); ++instanceId) { if (!mask.empty() && !mask[instanceId]) { continue; } const int protoIndex = protoIndices[instanceId]; const SdfPath& protoPath = protoPaths[protoIndex]; const UsdPrim& protoPrim = stage->GetPrimAtPath(protoPath); // Get the prototype bounding box. GfBBox3d thisBounds = bboxCache.ComputeUntransformedBound(protoPrim); // Apply the instance transform. thisBounds.Transform(instanceTransforms[instanceId]); extentRange.UnionWith(thisBounds.ComputeAlignedRange()); } const GfVec3d extentMin = extentRange.GetMin(); const GfVec3d extentMax = extentRange.GetMax(); *extent = VtVec3fArray(2); (*extent)[0] = GfVec3f(extentMin[0], extentMin[1], extentMin[2]); (*extent)[1] = GfVec3f(extentMax[0], extentMax[1], extentMax[2]); return true; }