bool
GusdUSD_StageProxy::MultiAccessor::ClampTimes(
UT_Array<UsdTimeCode>& times) const
{
UT_ASSERT(times.size() == _size);
for(exint i = 0; i < times.size(); ++i) {
if(const auto* accessor = (*this)(i))
times(i) = accessor->ClampTime(times(i));
}
return true;
}
bool
GusdUSD_StageProxy::MultiAccessor::Bind(
const UT_Array<GusdUSD_StageProxyHandle>& proxies,
const UT_Array<SdfPath>& paths,
UT_Array<UsdPrim>& prims,
UsdStage::InitialLoadSet loadSet,
GusdUT_ErrorContext* err)
{
Release();
UT_ASSERT(paths.isEmpty() || paths.size() == proxies.size());
if(proxies.size() == 0)
return true;
/* We have an input arrays of proxies and paths.
Many of the paths will be associated with the same proxy,
but they may also point at different proxies.
To avoid having to lock every individual prim, we want to compute
a mapping of indices from those input arrays into indices in
an array containing just the unique set of proxies.*/
UT_Array<GusdUSD_StageProxyHandle> uniqueProxies;
if(!_ComputeUniqueProxies(uniqueProxies, _indexMap, proxies))
return false;
_numAccessors = uniqueProxies.size();
_accessors = new Accessor[_numAccessors];
_size = proxies.size();
/* Now the unique set of proxies is known, so acquire accessors
(I.e., lock and load stages) */
std::atomic_bool workerInterrupt(false);
UTparallelForHeavyItems(UT_BlockedRange<size_t>(0, _numAccessors),
_BindAccessorsFn(_accessors, uniqueProxies,
loadSet, err, workerInterrupt));
if(UTgetInterrupt()->opInterrupt() || workerInterrupt)
return false;
/* Any entries referencing proxies that couldn't be bound
should have an invalid index; no point in accessing invalid accessors.*/
for(exint i = 0; i < _indexMap.size(); ++i) {
int idx = _indexMap(i);
if(idx >= 0) {
if(!_accessors[idx])
_indexMap(i) = -1;
}
}
return _GetPrims(paths, prims, err);
}
bool
GusdUSD_StageProxy::MultiAccessor::_GetPrims(
const UT_Array<SdfPath>& primPaths,
UT_Array<UsdPrim>& prims,
GusdUT_ErrorContext* err)
{
if(!_Load(primPaths))
return false;
prims.setSize(primPaths.size());
std::atomic_bool workerInterrupt(false);
UTparallelFor(UT_BlockedRange<size_t>(0, primPaths.size()),
_GetPrimsFn(*this, primPaths, prims, err, workerInterrupt));
return !UTgetInterrupt()->opInterrupt() && !workerInterrupt;
}
OP_ERROR
SOP_Smoke_Source::cookMySop(OP_Context &context)
{
// We must lock our inputs before we try to access their geometry.
// OP_AutoLockInputs will automatically unlock our inputs when we return.
// NOTE: Don't call unlockInputs yourself when using this!
OP_AutoLockInputs inputs(this);
if (inputs.lock(context) >= UT_ERROR_ABORT)
return error();
fpreal now = context.getTime();
duplicateSource(0, context);
// These three lines enable the local variable support. This allows
// $CR to get the red colour, for example, as well as supporting
// any varmap created by the Attribute Create SOP.
// Note that if you override evalVariableValue for your own
// local variables (like SOP_Star does) it is essential you
// still call the SOP_Node::evalVariableValue or you'll not
// get any of the benefit of the built in local variables.
// The variable order controls precedence for which attribute will be
// be bound first if the same named variable shows up in multiple
// places. This ordering ensures point attributes get precedence.
setVariableOrder(3, 2, 0, 1);
// The setCur* functions track which part of the gdp is currently
// being processed - it is what is used in the evalVariableValue
// callback as the current point. The 0 is for the first input,
// you can have two inputs so $CR2 would get the second input's
// value.
setCurGdh(0, myGdpHandle);
// Builds the lookup table matching attributes to the local variables.
setupLocalVars();
// Here we determine which groups we have to work on. We only
// handle point groups.
if (error() < UT_ERROR_ABORT && cookInputGroups(context) < UT_ERROR_ABORT &&
(!myGroup || !myGroup->isEmpty()))
{
UT_AutoInterrupt progress("Flattening Points");
// Handle all position, normal, and vector attributes.
// It's not entirely clear what to do for quaternion or transform attributes.
// We bump the data IDs of the attributes to modify in advance,
// since we're already looping over them, and we want to avoid
// bumping them all for each point, in case that's slow.
UT_Array<GA_RWHandleV3> positionattribs(1);
UT_Array<GA_RWHandleV3> normalattribs;
UT_Array<GA_RWHandleV3> vectorattribs;
GA_Attribute *attrib;
GA_FOR_ALL_POINT_ATTRIBUTES(gdp, attrib)
{
// Skip non-transforming attributes
if (!attrib->needsTransform())
continue;
GA_TypeInfo typeinfo = attrib->getTypeInfo();
if (typeinfo == GA_TYPE_POINT || typeinfo == GA_TYPE_HPOINT)
{
GA_RWHandleV3 handle(attrib);
if (handle.isValid())
{
positionattribs.append(handle);
attrib->bumpDataId();
}
}
else if (typeinfo == GA_TYPE_NORMAL)
{
GA_RWHandleV3 handle(attrib);
if (handle.isValid())
{
normalattribs.append(handle);
attrib->bumpDataId();
}
}
else if (typeinfo == GA_TYPE_VECTOR)
{
GA_RWHandleV3 handle(attrib);
if (handle.isValid())
{
vectorattribs.append(handle);
attrib->bumpDataId();
}
}
}
// Iterate over points up to GA_PAGE_SIZE at a time using blockAdvance.
GA_Offset start;
GA_Offset end;
for (GA_Iterator it(gdp->getPointRange(myGroup)); it.blockAdvance(start, end);)
{
// Check if user requested abort
if (progress.wasInterrupted())
break;
for (GA_Offset ptoff = start; ptoff < end; ++ptoff)
{
// This sets the current point that is beint processed to
// ptoff. This means that ptoff will be used for any
// local variable for any parameter evaluation that occurs
// after this point.
// NOTE: Local variables and repeated parameter evaluation
// is significantly slower and sometimes more complicated
// than having a string parameter that specifies the name
// of an attribute whose values should be used instead.
// That parameter would only need to be evaluated once,
// the attribute could be looked up once, and quickly
// accessed; however, a separate point attribute would
// be needed for each property that varies per point.
// Local variable evaluation isn't threadsafe either,
// whereas attributes can be read safely from multiple
// threads.
//
// Long story short: *Local variables are terrible.*
myCurPtOff[0] = ptoff;
float dist = DIST(now);
UT_Vector3 normal;
if (!DIRPOP())
{
switch (ORIENT())
{
case 0 : // XY Plane
normal.assign(0, 0, 1);
break;
case 1 : // YZ Plane
normal.assign(1, 0, 0);
break;
case 2 : // XZ Plane
normal.assign(0, 1, 0);
break;
}
}
else
{
normal.assign(NX(now), NY(now), NZ(now));
normal.normalize();
}
// Project positions onto the plane by subtracting
// off the normal component.
for (exint i = 0; i < positionattribs.size(); ++i)
{
UT_Vector3 p = positionattribs(i).get(ptoff);
p -= normal * (dot(normal, p) - dist);
positionattribs(i).set(ptoff, p);
}
// Normals will now all either be normal or -normal.
for (exint i = 0; i < normalattribs.size(); ++i)
{
UT_Vector3 n = normalattribs(i).get(ptoff);
if (dot(normal, n) < 0)
n = -normal;
else
n = normal;
normalattribs(i).set(ptoff, n);
}
// Project vectors onto the plane through the origin by
// subtracting off the normal component.
for (exint i = 0; i < vectorattribs.size(); ++i)
{
UT_Vector3 v = vectorattribs(i).get(ptoff);
v -= normal * dot(normal, v);
vectorattribs(i).set(ptoff, v);
}
}
}
}
OP_ERROR
GusdSOP_usdimport::_CreateNewPrims(OP_Context& ctx,
const GusdUSD_Traverse* traverse,
GusdUT_ErrorContext& err)
{
fpreal t = ctx.getTime();
UT_String file, primPath;
evalString(file, "import_file", 0, t);
evalString(primPath, "import_primpath", 0, t);
if(!file.isstring() || !primPath.isstring()) {
// Nothing to do.
return UT_ERROR_NONE;
}
/* The prim path may be a list of prims.
Additionally, those prim paths may include variants
(eg., /some/model{variant=sel}/subscope ).
Including multiple variants may mean that we need to access
multiple stages.
Resolve the actual set of prims and variants first.*/
UT_Array<SdfPath> primPaths, variants;
if(!GusdUSD_Utils::GetPrimAndVariantPathsFromPathList(
primPath, primPaths, variants, &err))
return err();
GusdDefaultArray<UT_StringHolder> filePaths;
filePaths.SetConstant(file);
// Get stage edits applying any of our variants.
GusdDefaultArray<GusdStageEditPtr> edits;
edits.GetArray().setSize(variants.size());
for(exint i = 0; i < variants.size(); ++i) {
if(!variants(i).IsEmpty()) {
GusdStageBasicEdit* edit = new GusdStageBasicEdit;
edit->GetVariants().append(variants(i));
edits.GetArray()(i).reset(edit);
}
}
// Load the root prims.
UT_Array<UsdPrim> rootPrims;
{
rootPrims.setSize(primPaths.size());
GusdStageCacheReader cache;
if(!cache.GetPrims(filePaths, primPaths, edits,
rootPrims.data(),
GusdStageOpts::LoadAll(), &err))
return err();
}
GusdDefaultArray<UsdTimeCode> times;
times.SetConstant(evalFloat("import_time", 0, t));
UT_String purpose;
evalString(purpose, "purpose", 0, t);
GusdDefaultArray<GusdPurposeSet> purposes;
purposes.SetConstant(GusdPurposeSet(
GusdPurposeSetFromMask(purpose)|
GUSD_PURPOSE_DEFAULT));
UT_Array<UsdPrim> prims;
if(traverse) {
// Before traversal, make a copy of the variants list.
const UT_Array<SdfPath> variantsPreTraverse(variants);
UT_Array<GusdUSD_Traverse::PrimIndexPair> primIndexPairs;
UT_UniquePtr<GusdUSD_Traverse::Opts> opts(traverse->CreateOpts());
if(opts) {
if(!opts->Configure(*this, t))
return err();
}
if(!traverse->FindPrims(rootPrims, times, purposes, primIndexPairs,
/*skip root*/ false, opts.get())) {
return err();
}
// Resize the prims and variants lists to match the size of
// primIndexPairs.
exint size = primIndexPairs.size();
prims.setSize(size);
variants.setSize(size);
// Now iterate through primIndexPairs to populate the prims
// and variants lists.
for (exint i = 0; i < size; i++) {
prims(i) = primIndexPairs(i).first;
exint index = primIndexPairs(i).second;
variants(i) = index < variantsPreTraverse.size() ?
variantsPreTraverse(index) : SdfPath();
}
} else {
std::swap(prims, rootPrims);
}
/* Have the resolved set of USD prims.
Now create prims or points on the detail.*/
bool packedPrims = !evalInt("import_class", 0, t);
if(packedPrims) {
UT_String vpLOD;
evalString(vpLOD, "viewportlod", 0, t);
GusdDefaultArray<UT_StringHolder> lods;
lods.SetConstant(vpLOD);
GusdGU_USD::AppendPackedPrims(*gdp, prims, variants,
times, lods, purposes, &err);
} else {
GusdGU_USD::AppendRefPoints(*gdp, prims, GUSD_PATH_ATTR,
GUSD_PRIMPATH_ATTR, &err);
}
return err();
}
bool
GusdUSD_StageProxy::MultiAccessor::_Load(const UT_Array<SdfPath>& paths)
{
if(paths.isEmpty())
return true;
UT_ASSERT_P(paths.size() == _size);
typedef tbb::concurrent_unordered_set<
SdfPath,SdfPath::Hash> ConcurrentPathSet;
struct _ComputeUnloadedPrimsFn
{
_ComputeUnloadedPrimsFn(const UT_Array<SdfPath>& paths,
const UT_Array<exint>& indexMap,
const UT_Array<_PrimLoader*>& loaders,
UT_Array<ConcurrentPathSet*>& pathSets)
: _paths(paths), _indexMap(indexMap),
_loaders(loaders), _pathSets(pathSets) {}
void operator()(const UT_BlockedRange<size_t>& r) const
{
auto* boss = UTgetInterrupt();
char bcnt = 0;
for(size_t i = r.begin(); i < r.end(); ++i) {
if(BOOST_UNLIKELY(!++bcnt && boss->opInterrupt()))
return;
exint idx = _indexMap(i);
if(idx >= 0) {
if(auto* loader = _loaders(idx)) {
const SdfPath& path = _paths(i);
if(!path.IsEmpty() && !loader->IsLoaded(path))
_pathSets(idx)->insert(path);
}
}
}
}
private:
const UT_Array<SdfPath>& _paths;
const UT_Array<exint>& _indexMap;
const UT_Array<_PrimLoader*>& _loaders;
UT_Array<ConcurrentPathSet*> _pathSets;
};
/* Compute sets of unloaded prims.
This constitutes the bulk of binding time, so do this parallel.*/
UT_Array<_PrimLoader*> loaders(_numAccessors, _numAccessors);
UT_Array<ConcurrentPathSet*> pathSets(_numAccessors, _numAccessors);
for(exint i = 0; i < _numAccessors; ++i) {
if ( _accessors[i] ) {
auto* loader = _accessors[i].GetProxy()->_primLoader;
if(loader) {
loaders(i) = loader;
pathSets(i) = new ConcurrentPathSet;
}
}
}
UTparallelFor(UT_BlockedRange<size_t>(0, _size),
_ComputeUnloadedPrimsFn(paths, _indexMap, loaders, pathSets));
if(UTgetInterrupt()->opInterrupt())
return false;
/* Load the actual prims.
This could be done in parallel, but is probably not worth it since
there's only work to perform the first time a prim load is requested.*/
for(exint i = 0; i < _numAccessors; ++i) {
if(auto* pathSet = pathSets(i)) {
SdfPathSet pathsToLoad(pathSet->begin(), pathSet->end());
_accessors[i]._Load(pathsToLoad);
delete pathSet;
}
}
return true;
}