void
Hd_TestDriver::SetRepr(HdReprSelector const &reprSelector)
{
_reprSelector = reprSelector;
if (_geomAndGuidePass) {
TfTokenVector renderTags;
renderTags.push_back(HdTokens->geometry);
renderTags.push_back(HdTokens->guide);
HdRprimCollection col = HdRprimCollection(
HdTokens->geometry,
_reprSelector);
col.SetRenderTags(renderTags);
_geomAndGuidePass->SetRprimCollection(col);
}
if (_geomPass) {
TfTokenVector renderTags;
renderTags.push_back(HdTokens->geometry);
HdRprimCollection col = HdRprimCollection(
HdTokens->geometry,
_reprSelector);
col.SetRenderTags(renderTags);
_geomPass->SetRprimCollection(col);
}
}
HdRenderPassSharedPtr const &
Hd_TestDriver::GetRenderPass(bool withGuides)
{
if (withGuides) {
if (!_geomAndGuidePass) {
TfTokenVector renderTags;
renderTags.push_back(HdTokens->geometry);
renderTags.push_back(HdTokens->guide);
HdRprimCollection col = HdRprimCollection(
HdTokens->geometry,
_reprSelector);
col.SetRenderTags(renderTags);
_geomAndGuidePass = HdRenderPassSharedPtr(
new Hd_UnitTestNullRenderPass(&_sceneDelegate->GetRenderIndex(), col));
}
return _geomAndGuidePass;
} else {
if (!_geomPass) {
TfTokenVector renderTags;
renderTags.push_back(HdTokens->geometry);
HdRprimCollection col = HdRprimCollection(
HdTokens->geometry,
_reprSelector);
col.SetRenderTags(renderTags);
_geomPass = HdRenderPassSharedPtr(
new Hd_UnitTestNullRenderPass(&_sceneDelegate->GetRenderIndex(), col));
}
return _geomPass;
}
}
void
My_TestGLDrawing::OffscreenTest()
{
DrawScene();
WriteToFile("color", "color1_unselected.png");
// select cube0
_picker.Pick(GfVec2i(319,221), GfVec2i(320,222));
DrawScene();
WriteToFile("color", "color2_cube0_pickable.png");
HdSelectionSharedPtr selection = _picker.GetSelection();
HdSelection::HighlightMode mode = HdSelection::HighlightModeSelect;
TF_VERIFY(selection->GetSelectedPrimPaths(mode).size() == 1);
TF_VERIFY(selection->GetSelectedPrimPaths(mode)[0] == SdfPath("/cube0"));
// make cube0 unpickable; it should not let us pick cube1 since it occludes
SdfPathVector excludePaths = {SdfPath("/cube0")};
_pickablesCol.SetExcludePaths(excludePaths);
_picker.SetDoUnpickablesOcclude(true);
_picker.Pick(GfVec2i(319,221), GfVec2i(320,222));
DrawScene();
WriteToFile("color", "color3_cube0_unpickable.png");
selection = _picker.GetSelection();
//TF_VERIFY(selection->GetSelectedPrimPaths(mode).size() == 0);
}
// UsdImaging_TestDriver
void
UsdImaging_TestDriver::_Init(UsdStageRefPtr const& usdStage,
TfToken const &collectionName,
TfToken const &reprName,
TfTokenVector const &renderTags)
{
_renderIndex = HdRenderIndex::New(&_renderDelegate);
TF_VERIFY(_renderIndex != nullptr);
_delegate = new UsdImagingDelegate(_renderIndex, SdfPath::AbsoluteRootPath());
_stage = usdStage;
_delegate->Populate(_stage->GetPseudoRoot());
HdRprimCollection col = HdRprimCollection(collectionName, reprName);
col.SetRenderTags(renderTags);
_geometryPass = HdRenderPassSharedPtr(new HdSt_RenderPass(_renderIndex, col));
_renderPassState = HdRenderPassStateSharedPtr(new HdRenderPassState());
}
void
HdRenderPass::SetRprimCollection(HdRprimCollection const& col)
{
if (col == _collection){
return;
}
_collection = col;
// Force any cached data based on collection to be refreshed.
_collectionChanged = true;
// reset the cached collection version
_collectionVersion = 0;
// update dirty list subscription for the new collection.
// holding shared_ptr for the lifetime of the dirty list.
bool isMinorChange = true;
if (!_dirtyList || !_dirtyList->ApplyEdit(col)) {
_dirtyList.reset(new HdDirtyList(_collection, *_renderIndex));
isMinorChange = false;
}
if (TfDebug::IsEnabled(HD_DIRTY_LIST)) {
std::stringstream s;
s << " Include: \n";
for (auto i : col.GetRootPaths()) {
s << " - " << i << "\n";
}
s << " Exclude: \n";
for (auto i : col.GetExcludePaths()) {
s << " - " << i << "\n";
}
s << " Repr: " << col.GetReprName() << "\n";
s << " Render Tags: \n";
for (auto i : col.GetRenderTags()) {
s << " - " << i << "\n";
}
TF_DEBUG(HD_DIRTY_LIST).Msg("RenderPass(%p)::SetRprimCollection (%s) - "
"constructing new DirtyList(%p) minorChange(%d) \n%s\n",
(void*)this,
col.GetName().GetText(),
(void*)&*_dirtyList,
isMinorChange,
s.str().c_str());
}
}
/* virtual */
void
HdxLight::Sync(HdSceneDelegate *sceneDelegate,
HdRenderParam *renderParam,
HdDirtyBits *dirtyBits)
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
TF_UNUSED(renderParam);
SdfPath const &id = GetID();
if (!TF_VERIFY(sceneDelegate != nullptr)) {
return;
}
// HdxLight communicates to the scene graph and caches all interesting
// values within this class.
// later on Get() is called from TaskState (RenderPass) to perform
// aggregation/pre-computation, in order to make the shader execution
// efficient.
HdDirtyBits bits = *dirtyBits;
// Change tracking
// Transform
if (bits & DirtyTransform) {
VtValue transform = sceneDelegate->Get(id, HdxLightTokens->transform);
if (transform.IsHolding<GfMatrix4d>()) {
_params[HdxLightTokens->transform] = transform;
} else {
_params[HdxLightTokens->transform] = GfMatrix4d(1);
}
}
// Lighting Params
if (bits & DirtyParams) {
_params[HdxLightTokens->params] =
sceneDelegate->Get(id, HdxLightTokens->params);
}
// Shadow Params
if (bits & DirtyShadowParams) {
_params[HdxLightTokens->shadowParams] =
sceneDelegate->Get(id, HdxLightTokens->shadowParams);
}
// Shadow Collection
if (bits & DirtyCollection) {
VtValue vtShadowCollection =
sceneDelegate->Get(id, HdxLightTokens->shadowCollection);
// Optional
if (vtShadowCollection.IsHolding<HdRprimCollection>()) {
HdRprimCollection newCollection =
vtShadowCollection.UncheckedGet<HdRprimCollection>();
if (_params[HdxLightTokens->shadowCollection] != newCollection) {
_params[HdxLightTokens->shadowCollection] = newCollection;
HdChangeTracker& changeTracker =
sceneDelegate->GetRenderIndex().GetChangeTracker();
changeTracker.MarkCollectionDirty(newCollection.GetName());
}
} else {
_params[HdxLightTokens->shadowCollection] = HdRprimCollection();
}
}
*dirtyBits = Clean;
}
/* virtual */
void
HdStLight::Sync(HdSceneDelegate *sceneDelegate,
HdRenderParam *renderParam,
HdDirtyBits *dirtyBits)
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
TF_UNUSED(renderParam);
SdfPath const &id = GetId();
if (!TF_VERIFY(sceneDelegate != nullptr)) {
return;
}
// HdStLight communicates to the scene graph and caches all interesting
// values within this class. Later on Get() is called from
// TaskState (RenderPass) to perform aggregation/pre-computation,
// in order to make the shader execution efficient.
// Change tracking
HdDirtyBits bits = *dirtyBits;
// Transform
if (bits & DirtyTransform) {
VtValue transform = sceneDelegate->Get(id, HdLightTokens->transform);
if (transform.IsHolding<GfMatrix4d>()) {
_params[HdLightTokens->transform] = transform;
} else {
_params[HdLightTokens->transform] = GfMatrix4d(1);
}
}
// Lighting Params
if (bits & DirtyParams) {
// If it is an area light we will extract the parameters and convert
// them to a gl friendly representation.
if (_lightType == HdPrimTypeTokens->simpleLight) {
_params[HdLightTokens->params] =
sceneDelegate->Get(id, HdLightTokens->params);
} else {
_params[HdLightTokens->params] =
_ApproximateAreaLight(id, sceneDelegate);
}
}
// Shadow Params
if (bits & DirtyShadowParams) {
_params[HdLightTokens->shadowParams] =
sceneDelegate->Get(id, HdLightTokens->shadowParams);
}
// Shadow Collection
if (bits & DirtyCollection) {
VtValue vtShadowCollection =
sceneDelegate->Get(id, HdLightTokens->shadowCollection);
// Optional
if (vtShadowCollection.IsHolding<HdRprimCollection>()) {
HdRprimCollection newCollection =
vtShadowCollection.UncheckedGet<HdRprimCollection>();
if (_params[HdLightTokens->shadowCollection] != newCollection) {
_params[HdLightTokens->shadowCollection] = newCollection;
HdChangeTracker& changeTracker =
sceneDelegate->GetRenderIndex().GetChangeTracker();
changeTracker.MarkCollectionDirty(newCollection.GetName());
}
} else {
_params[HdLightTokens->shadowCollection] = HdRprimCollection();
}
}
*dirtyBits = Clean;
}
bool
HdDirtyList::ApplyEdit(HdRprimCollection const& col)
{
HD_TRACE_FUNCTION();
// Don't attempt to transition dirty lists where the collection
// fundamentally changed, we can't reused filtered paths in those cases.
//
// when repr changes, don't reuse the dirty list, since the required
// DirtyBits may change.
if (col.GetName() != _collection.GetName()
|| col.GetReprName() != _collection.GetReprName()
|| col.IsForcedRepr() != _collection.IsForcedRepr()
|| col.GetRenderTags() != _collection.GetRenderTags()) {
return false;
}
// Also don't attempt to fix-up dirty lists when the collection is radically
// different in terms of root paths; here a heuristic of 100 root paths is
// used as a threshold for when we will stop attempting to fix the list.
if (std::abs(int(col.GetRootPaths().size()) -
int(_collection.GetRootPaths().size())) > 100) {
return false;
}
// If the either the old or new collection has Exclude paths do
// the full rebuild.
if (!col.GetExcludePaths().empty() ||
!_collection.GetExcludePaths().empty()) {
return false;
}
// If the varying state has changed - Rebuild the base list
// before adding the new items
HdChangeTracker &changeTracker = _renderIndex.GetChangeTracker();
unsigned int currentVaryingStateVersion =
changeTracker.GetVaryingStateVersion();
if (_varyingStateVersion != currentVaryingStateVersion) {
TF_DEBUG(HD_DIRTY_LIST).Msg("DirtyList(%p): varying state changed "
"(%s, %d -> %d)\n",
(void*)this,
_collection.GetName().GetText(),
_varyingStateVersion,
currentVaryingStateVersion);
// populate only varying prims in the collection
_UpdateIDs(&_dirtyIds, HdChangeTracker::Varying);
_varyingStateVersion = currentVaryingStateVersion;
}
SdfPathVector added, removed;
typedef SdfPathVector::const_iterator ITR;
ITR newI = col.GetRootPaths().cbegin();
ITR newEnd = col.GetRootPaths().cend();
ITR oldI = _collection.GetRootPaths().cbegin();
ITR oldEnd = _collection.GetRootPaths().cend();
HdRenderIndex& index = _renderIndex;
TfToken const & repr = col.GetReprName();
TF_DEBUG(HD_DIRTY_LIST).Msg("DirtyList(%p): ApplyEdit\n", (void*)this);
if (TfDebug::IsEnabled(HD_DIRTY_LIST)) {
std::cout << " Old Collection: " << std::endl;
for (auto const& i : _collection.GetRootPaths()) {
std::cout << " " << i << std::endl;
}
std::cout << " Old _dirtyIds: " << std::endl;
for (auto const& i : _dirtyIds) {
std::cout << " " << i << std::endl;
}
}
const SdfPathVector &paths = _renderIndex.GetRprimIds();
while (newI != newEnd || oldI != oldEnd) {
if (newI != newEnd && oldI != oldEnd && *newI == *oldI) {
++newI;
++oldI;
continue;
}
// If any paths in the two sets are prefixed by one another, the logic
// below doesn't work, since the subtree has to be fixed up (it's not
// just a simple prefix scan). In these cases, we'll just rebuild the
// entire list.
if (newI != newEnd && oldI != oldEnd && newI->HasPrefix(*oldI)) {
return false;
}
if (newI != newEnd && oldI != oldEnd && oldI->HasPrefix(*newI)) {
return false;
}
if (newI != newEnd && (oldI == oldEnd || *newI < *oldI)) {
HdPrimGather gather;
SdfPathVector newPaths;
gather.Subtree(paths, *newI, &newPaths);
size_t numNewPaths = newPaths.size();
for (size_t newPathNum = 0;
newPathNum < numNewPaths;
++newPathNum) {
const SdfPath &newPath = newPaths[newPathNum];
if (col.HasRenderTag(index.GetRenderTag(newPath, repr))) {
_dirtyIds.push_back(newPath);
changeTracker.MarkRprimDirty(newPath,
HdChangeTracker::InitRepr);
}
}
++newI;
} else if (oldI != oldEnd) {
// oldI < newI: Item removed in new list
SdfPath const& oldPath = *oldI;
_dirtyIds.erase(std::remove_if(_dirtyIds.begin(), _dirtyIds.end(),
[&oldPath](SdfPath const& p){return p.HasPrefix(oldPath);}),
_dirtyIds.end());
++oldI;
}
}
_collection = col;
_collectionVersion
= changeTracker.GetCollectionVersion(_collection.GetName());
// make sure the next GetDirtyRprims() picks up the updated list.
_isEmpty = false;
if (TfDebug::IsEnabled(HD_DIRTY_LIST)) {
std::cout << " New Collection: " << std::endl;
for (auto const& i : _collection.GetRootPaths()) {
std::cout << " " << i << std::endl;
}
std::cout << " New _dirtyIds: " << std::endl;
for (auto const& i : _dirtyIds) {
std::cout << " " << i << std::endl;
}
}
return true;
}
