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