void
UsdImagingCubeAdapter::UpdateForTime(UsdPrim const& prim,
SdfPath const& cachePath,
UsdTimeCode time,
HdDirtyBits requestedBits,
UsdImagingInstancerContext const*
instancerContext) const
{
BaseAdapter::UpdateForTime(
prim, cachePath, time, requestedBits, instancerContext);
UsdImagingValueCache* valueCache = _GetValueCache();
if (requestedBits & HdChangeTracker::DirtyTransform) {
// Update the transform with the size authored for the cube.
GfMatrix4d& ctm = valueCache->GetTransform(cachePath);
GfMatrix4d xf = GetMeshTransform(prim, time);
ctm = xf * ctm;
}
if (requestedBits & HdChangeTracker::DirtyTopology) {
valueCache->GetTopology(cachePath) = GetMeshTopology();
}
if (_IsRefined(cachePath)) {
if (requestedBits & HdChangeTracker::DirtySubdivTags) {
valueCache->GetSubdivTags(cachePath);
}
}
}
void
UsdImagingGprimAdapter::UpdateForTimePrep(UsdPrim const& prim,
SdfPath const& cachePath,
UsdTimeCode time,
int requestedBits,
UsdImagingInstancerContext const*
instancerContext)
{
UsdImagingValueCache* valueCache = _GetValueCache();
// Prepopulate cache entries to avoid mutation during multi-threaded data
// fetch.
if (requestedBits & HdChangeTracker::DirtyPrimVar)
valueCache->GetColor(cachePath);
if (requestedBits & HdChangeTracker::DirtyDoubleSided)
valueCache->GetDoubleSided(cachePath);
if (requestedBits & HdChangeTracker::DirtyTransform)
valueCache->GetTransform(cachePath);
if (requestedBits & HdChangeTracker::DirtyExtent)
valueCache->GetExtent(cachePath);
if (requestedBits & HdChangeTracker::DirtyVisibility)
valueCache->GetVisible(cachePath);
if (requestedBits & HdChangeTracker::DirtySurfaceShader)
valueCache->GetSurfaceShader(cachePath);
valueCache->GetPrimvars(cachePath);
}
void
UsdImagingCubeAdapter::UpdateForTime(UsdPrim const& prim,
SdfPath const& cachePath,
UsdTimeCode time,
HdDirtyBits requestedBits,
HdDirtyBits* resultBits,
UsdImagingInstancerContext const*
instancerContext)
{
BaseAdapter::UpdateForTime(
prim, cachePath, time, requestedBits, resultBits, instancerContext);
UsdImagingValueCache* valueCache = _GetValueCache();
if (requestedBits & HdChangeTracker::DirtyTransform) {
// Update the transform with the size authored for the cube.
GfMatrix4d& ctm = valueCache->GetTransform(cachePath);
GfMatrix4d xf = GetMeshTransform(prim, time);
ctm = xf * ctm;
}
if (requestedBits & HdChangeTracker::DirtyTopology) {
valueCache->GetTopology(cachePath) = GetMeshTopology();
}
if (requestedBits & HdChangeTracker::DirtyPoints) {
valueCache->GetPoints(cachePath)= GetMeshPoints(prim, time);
// Expose points as a primvar.
UsdImagingValueCache::PrimvarInfo primvar;
primvar.name = HdTokens->points;
primvar.interpolation = UsdGeomTokens->vertex;
PrimvarInfoVector& primvars = valueCache->GetPrimvars(cachePath);
_MergePrimvar(primvar, &primvars);
}
}
/* virtual */
void
UsdImagingMaterialAdapter::UpdateForTime(UsdPrim const& prim,
SdfPath const& cachePath,
UsdTimeCode time,
HdDirtyBits requestedBits,
UsdImagingInstancerContext const*
instancerContext) const
{
UsdImagingValueCache* valueCache = _GetValueCache();
if (requestedBits & HdMaterial::DirtyResource) {
// Walk the material network and generate a HdMaterialNetworkMap
// structure to store it in the value cache.
HdMaterialNetworkMap materialNetworkMap;
_GetMaterialNetworkMap(prim, &materialNetworkMap);
valueCache->GetMaterialResource(cachePath) = materialNetworkMap;
// Compute union of primvars from all networks
std::vector<TfToken> primvars;
for (const auto& entry: materialNetworkMap.map) {
primvars.insert(primvars.end(),
entry.second.primvars.begin(),
entry.second.primvars.end());
}
std::sort(primvars.begin(), primvars.end());
primvars.erase(std::unique(primvars.begin(), primvars.end()),
primvars.end());
valueCache->GetMaterialPrimvars(cachePath) = primvars;
}
}
void
UsdImagingMeshAdapter::UpdateForTime(UsdPrim const& prim,
SdfPath const& cachePath,
UsdTimeCode time,
HdDirtyBits requestedBits,
HdDirtyBits* resultBits,
UsdImagingInstancerContext const*
instancerContext)
{
BaseAdapter::UpdateForTime(
prim, cachePath, time, requestedBits, resultBits, instancerContext);
UsdImagingValueCache* valueCache = _GetValueCache();
PrimvarInfoVector& primvars = valueCache->GetPrimvars(cachePath);
if (requestedBits & HdChangeTracker::DirtyTopology) {
VtValue& topology = valueCache->GetTopology(cachePath);
_GetMeshTopology(prim, &topology, time);
}
if (requestedBits & HdChangeTracker::DirtyPoints) {
VtValue& points = valueCache->GetPoints(cachePath);
_GetPoints(prim, &points, time);
UsdImagingValueCache::PrimvarInfo primvar;
primvar.name = HdTokens->points;
primvar.interpolation = UsdGeomTokens->vertex;
_MergePrimvar(primvar, &primvars);
}
if (requestedBits & HdChangeTracker::DirtySubdivTags) {
SubdivTags& tags = valueCache->GetSubdivTags(cachePath);
_GetSubdivTags(prim, &tags, time);
}
}
// Thread safe.
// * Populate dirty bits for the given \p time.
void
UsdImagingConeAdapter::UpdateForTime(UsdPrim const& prim,
SdfPath const& cachePath,
UsdTimeCode time,
int requestedBits,
int* resultBits,
UsdImagingInstancerContext const*
instancerContext)
{
BaseAdapter::UpdateForTime(
prim, cachePath, time, requestedBits, resultBits, instancerContext);
UsdImagingValueCache* valueCache = _GetValueCache();
if (requestedBits & HdChangeTracker::DirtyTopology) {
valueCache->GetTopology(cachePath) = GetMeshTopology();
}
if (requestedBits & HdChangeTracker::DirtyPoints) {
valueCache->GetPoints(cachePath) = GetMeshPoints(prim, time);
// Expose points as a primvar.
UsdImagingValueCache::PrimvarInfo primvar;
primvar.name = HdTokens->points;
primvar.interpolation = UsdGeomTokens->vertex;
_MergePrimvar(primvar, &valueCache->GetPrimvars(cachePath));
}
}
void
UsdImagingPointsAdapter::UpdateForTime(UsdPrim const& prim,
SdfPath const& cachePath,
UsdTimeCode time,
HdDirtyBits requestedBits,
HdDirtyBits* resultBits,
UsdImagingInstancerContext const*
instancerContext)
{
BaseAdapter::UpdateForTime(
prim, cachePath, time, requestedBits, resultBits, instancerContext);
UsdImagingValueCache* valueCache = _GetValueCache();
PrimvarInfoVector& primvars = valueCache->GetPrimvars(cachePath);
VtValue& pointsValues = valueCache->GetPoints(cachePath);
if (requestedBits & HdChangeTracker::DirtyPoints) {
_GetPoints(prim, &pointsValues, time);
UsdImagingValueCache::PrimvarInfo primvar;
primvar.name = HdTokens->points;
primvar.interpolation = UsdGeomTokens->vertex;
_MergePrimvar(primvar, &primvars);
}
if (requestedBits & HdChangeTracker::DirtyWidths) {
UsdImagingValueCache::PrimvarInfo primvar;
UsdGeomPoints points(prim);
VtFloatArray widths;
primvar.name = UsdGeomTokens->widths;
// XXX Add support for real constant interpolation
primvar.interpolation = UsdGeomTokens->vertex;
// Read the widths, if there is no widths create a buffer
// and fill it with default widths of 1.0f
if (!points.GetWidthsAttr().Get(&widths, time)) {
// Check if we have just updated the points because in that
// case we don't need to read the points again
if (!(requestedBits & HdChangeTracker::DirtyPoints)) {
_GetPoints(prim, &pointsValues, time);
}
for(size_t i = 0; i < pointsValues.Get<VtVec3fArray>().size() ; i ++) {
widths.push_back(1.0f);
}
}
_MergePrimvar(primvar, &primvars);
valueCache->GetWidths(cachePath) = VtValue(widths);
}
}
void
UsdImagingCubeAdapter::UpdateForTimePrep(UsdPrim const& prim,
SdfPath const& cachePath,
UsdTimeCode time,
HdDirtyBits requestedBits,
UsdImagingInstancerContext const*
instancerContext)
{
BaseAdapter::UpdateForTimePrep(prim, cachePath, time, requestedBits);
UsdImagingValueCache* valueCache = _GetValueCache();
// This adapter will never mark these as dirty, however the client may
// explicitly ask for them, after the initial cached value is gone.
if (requestedBits & HdChangeTracker::DirtyPoints)
valueCache->GetPoints(cachePath);
if (requestedBits & HdChangeTracker::DirtyTopology)
valueCache->GetTopology(cachePath);
}
void
UsdImagingPointsAdapter::UpdateForTimePrep(UsdPrim const& prim,
SdfPath const& cachePath,
UsdTimeCode time,
HdDirtyBits requestedBits,
UsdImagingInstancerContext const*
instancerContext)
{
BaseAdapter::UpdateForTimePrep(
prim, cachePath, time, requestedBits, instancerContext);
UsdImagingValueCache* valueCache = _GetValueCache();
if (requestedBits & HdChangeTracker::DirtyPoints)
valueCache->GetPoints(cachePath);
if (requestedBits & HdChangeTracker::DirtyWidths)
valueCache->GetWidths(cachePath);
}
void
UsdImagingGprimAdapter::TrackVariabilityPrep(UsdPrim const& prim,
SdfPath const& cachePath,
int requestedBits,
UsdImagingInstancerContext const*
instancerContext)
{
// Prepopulate cache entries to avoid mutation during multi-threaded data
// fetch.
UsdImagingValueCache* valueCache = _GetValueCache();
if (requestedBits & HdChangeTracker::DirtyVisibility) {
valueCache->GetVisible(cachePath);
valueCache->GetPurpose(cachePath);
}
if (requestedBits & HdChangeTracker::DirtyPrimVar) {
valueCache->GetPrimvars(cachePath);
}
}
void
UsdImagingGprimAdapter::TrackVariability(UsdPrim const& prim,
SdfPath const& cachePath,
int requestedBits,
int* dirtyBits,
UsdImagingInstancerContext const*
instancerContext)
{
// WARNING: This method is executed from multiple threads, the value cache
// has been carefully pre-populated to avoid mutating the underlying
// container during update.
// Why is this OK?
// Either the value is unvarying, in which case the time ordinate doesn't
// matter; or the value is varying, in which case we will update it upon
// first call to Delegate::SetTime().
UsdTimeCode time(1.0);
UsdImagingValueCache* valueCache = _GetValueCache();
if (requestedBits & HdChangeTracker::DirtyPrimVar) {
if (not _IsVarying(prim,
UsdGeomTokens->primvarsDisplayColor,
HdChangeTracker::DirtyPrimVar,
UsdImagingTokens->usdVaryingPrimVar,
dirtyBits,
false)) {
// Only do this second check if the displayColor isn't already known
// to be varying.
_IsVarying(prim,
UsdGeomTokens->primvarsDisplayOpacity,
HdChangeTracker::DirtyPrimVar,
UsdImagingTokens->usdVaryingPrimVar,
dirtyBits,
false);
}
}
if (requestedBits & HdChangeTracker::DirtyExtent) {
// Discover time-varying extent.
_IsVarying(prim,
UsdGeomTokens->extent,
HdChangeTracker::DirtyExtent,
UsdImagingTokens->usdVaryingExtent,
dirtyBits,
false);
}
if (requestedBits & HdChangeTracker::DirtyTransform) {
// Discover time-varying transforms.
_IsTransformVarying(prim,
HdChangeTracker::DirtyTransform,
UsdImagingTokens->usdVaryingXform,
dirtyBits);
}
if (requestedBits & HdChangeTracker::DirtyVisibility) {
valueCache->GetVisible(cachePath) = GetVisible(prim, time);
// Discover time-varying visibility.
_IsVarying(prim,
UsdGeomTokens->visibility,
HdChangeTracker::DirtyVisibility,
UsdImagingTokens->usdVaryingVisibility,
dirtyBits,
true);
TfToken purpose = _GetPurpose(prim, time);
// Empty purpose means there is no opinion, fall back to geom.
if (purpose.IsEmpty())
purpose = UsdGeomTokens->default_;
valueCache->GetPurpose(cachePath) = purpose;
}
}