diff --git a/lib/mayaUsd/render/vp2RenderDelegate/draw_item.h b/lib/mayaUsd/render/vp2RenderDelegate/draw_item.h index 1bfbf363b5..38d011cd9c 100644 --- a/lib/mayaUsd/render/vp2RenderDelegate/draw_item.h +++ b/lib/mayaUsd/render/vp2RenderDelegate/draw_item.h @@ -157,10 +157,6 @@ class HdVP2DrawItem final : public HdDrawItem */ const MString& GetDrawItemName() const { return _drawItemName; } - /*! \brief Get render item name - */ - const MString& GetRenderItemName() const { return GetRenderItemData()._renderItemName; } - /*! \brief Get pointer of the associated render item */ MHWRender::MRenderItem* GetRenderItem() const { return GetRenderItemData()._renderItem; } @@ -185,10 +181,6 @@ class HdVP2DrawItem final : public HdDrawItem */ bool MatchesUsage(RenderItemUsage usage) const { return _renderItemUsage == usage; } - /*! \brief Bitwise OR with the input dirty bits. - */ - void SetDirtyBits(HdDirtyBits bits) { GetRenderItemData().SetDirtyBits(bits); } - /*! \brief Reset the dirty bits to clean. */ void ResetDirtyBits() { GetRenderItemData().ResetDirtyBits(); } @@ -199,6 +191,25 @@ class HdVP2DrawItem final : public HdDrawItem static SdfPath RenderItemToPrimPath(const MHWRender::MRenderItem& item); + /*! Mods are used in instanced primitives to represent particular instances which visual + properties were modified by a display layer. Example: instances with hide-on-playback + flag enabled will have their own mod. A mod associated with the main draw item may have + another mod attached to it and so on, thus forming a linked list of mods. + */ + void SetMod(std::unique_ptr&& mod) { _mod = std::move(mod); } + + /*! \brief Get the mod assotiated with the given draw item. + */ + HdVP2DrawItem* GetMod() { return _mod.get(); } + + /*! \brief Mark this draw item as being a mod for instances with hide-on-playback enabled. + */ + void SetModFlagHideOnPlayback(bool prop) { _modFlagHideOnPlayback = prop; } + + /*! \brief Verify if this draw item is a mod for instances with hide-on-playback enabled. + */ + bool GetModFlagHideOnPlayback() const { return _modFlagHideOnPlayback; } + private: /* Data stored directly on the HdVP2DrawItem can be shared across all the MRenderItems @@ -216,6 +227,15 @@ class HdVP2DrawItem final : public HdDrawItem The list of MRenderItems used to represent *this in VP2. */ RenderItemDataVector _renderItems; //!< VP2 render item data + + /* + Mod associated with the given draw item. + This mod may have another one attached to it, thus forming a linked list + */ + std::unique_ptr _mod; + + //! flag marking the given draw item as a mod for instances with hide-on-playback enabled. + bool _modFlagHideOnPlayback = false; }; PXR_NAMESPACE_CLOSE_SCOPE diff --git a/lib/mayaUsd/render/vp2RenderDelegate/mayaPrimCommon.cpp b/lib/mayaUsd/render/vp2RenderDelegate/mayaPrimCommon.cpp index 779f55ad64..0542c912a8 100644 --- a/lib/mayaUsd/render/vp2RenderDelegate/mayaPrimCommon.cpp +++ b/lib/mayaUsd/render/vp2RenderDelegate/mayaPrimCommon.cpp @@ -226,25 +226,16 @@ void MayaUsdRPrim::_FirstInitRepr(HdDirtyBits* dirtyBits, SdfPath const& id) void MayaUsdRPrim::_SetDirtyRepr(const HdReprSharedPtr& repr) { - const auto& items = repr->GetDrawItems(); -#if HD_API_VERSION < 35 - for (HdDrawItem* item : items) { - HdVP2DrawItem* drawItem = static_cast(item); -#else - for (const HdRepr::DrawItemUniquePtr& item : items) { - HdVP2DrawItem* const drawItem = static_cast(item.get()); -#endif - if (drawItem) { - for (auto& renderItemData : drawItem->GetRenderItems()) { - if (renderItemData.GetDirtyBits() & HdChangeTracker::AllDirty) { - // About to be drawn, but the Repr is dirty. Add DirtyRepr so we know in - // _PropagateDirtyBits that we need to propagate the dirty bits of this draw - // items to ensure proper Sync - renderItemData.SetDirtyBits(HdChangeTracker::DirtyRepr); - } - } + RenderItemFunc setDirtyRepr = [](HdVP2DrawItem::RenderItemData& renderItemData) { + if (renderItemData.GetDirtyBits() & HdChangeTracker::AllDirty) { + // About to be drawn, but the Repr is dirty. Add DirtyRepr so we know in + // _PropagateDirtyBits that we need to propagate the dirty bits of this draw + // items to ensure proper Sync + renderItemData.SetDirtyBits(HdChangeTracker::DirtyRepr); } - } + }; + + _ForEachRenderItemInRepr(repr, setDirtyRepr); } void DisableRenderItem(HdVP2DrawItem::RenderItemData& renderItemData, HdVP2RenderDelegate* delegate) @@ -390,43 +381,21 @@ void MayaUsdRPrim::_PropagateDirtyBitsCommon(HdDirtyBits& bits, const ReprVector { if (bits & HdChangeTracker::AllDirty) { // RPrim is dirty, propagate dirty bits to all draw items. - for (const std::pair& pair : reprs) { - const HdReprSharedPtr& repr = pair.second; - const auto& items = repr->GetDrawItems(); -#if HD_API_VERSION < 35 - for (HdDrawItem* item : items) { - if (HdVP2DrawItem* drawItem = static_cast(item)) { -#else - for (const HdRepr::DrawItemUniquePtr& item : items) { - if (HdVP2DrawItem* const drawItem = static_cast(item.get())) { -#endif - for (auto& renderItemData : drawItem->GetRenderItems()) { - renderItemData.SetDirtyBits(bits); - } - } - } - } + RenderItemFunc setDirtyBitsToItem = [bits](HdVP2DrawItem::RenderItemData& renderItemData) { + renderItemData.SetDirtyBits(bits); + }; + + _ForEachRenderItem(reprs, setDirtyBitsToItem); } else { // RPrim is clean, find out if any drawItem about to be shown is dirty: - for (const std::pair& pair : reprs) { - const HdReprSharedPtr& repr = pair.second; - const auto& items = repr->GetDrawItems(); -#if HD_API_VERSION < 35 - for (const HdDrawItem* item : items) { - if (const HdVP2DrawItem* drawItem = static_cast(item)) { -#else - for (const HdRepr::DrawItemUniquePtr& item : items) { - if (const HdVP2DrawItem* const drawItem = static_cast(item.get())) { -#endif - // Is this Repr dirty and in need of a Sync? - for (auto& renderItemData : drawItem->GetRenderItems()) { - if (renderItemData.GetDirtyBits() & HdChangeTracker::DirtyRepr) { - bits |= (renderItemData.GetDirtyBits() & ~HdChangeTracker::DirtyRepr); - } - } - } - } - } + RenderItemFunc setDirtyBitsFromItem + = [&bits](HdVP2DrawItem::RenderItemData& renderItemData) { + if (renderItemData.GetDirtyBits() & HdChangeTracker::DirtyRepr) { + bits |= (renderItemData.GetDirtyBits() & ~HdChangeTracker::DirtyRepr); + } + }; + + _ForEachRenderItem(reprs, setDirtyBitsFromItem); } } @@ -576,27 +545,16 @@ void MayaUsdRPrim::_MakeOtherReprRenderItemsInvisible( const TfToken& reprToken, const ReprVector& reprs) { + RenderItemFunc disableRenderItem = [this](HdVP2DrawItem::RenderItemData& renderItemData) { + _delegate->GetVP2ResourceRegistry().EnqueueCommit([&renderItemData]() { + renderItemData._enabled = false; + renderItemData._renderItem->enable(false); + }); + }; + for (const std::pair& pair : reprs) { if (pair.first != reprToken) { - // For each relevant draw item, update dirty buffer sources. - const HdReprSharedPtr& repr = pair.second; - const auto& items = repr->GetDrawItems(); - -#if HD_API_VERSION < 35 - for (HdDrawItem* item : items) { - if (HdVP2DrawItem* drawItem = static_cast(item)) { -#else - for (const HdRepr::DrawItemUniquePtr& item : items) { - if (HdVP2DrawItem* const drawItem = static_cast(item.get())) { -#endif - for (auto& renderItemData : drawItem->GetRenderItems()) { - _delegate->GetVP2ResourceRegistry().EnqueueCommit([&renderItemData]() { - renderItemData._enabled = false; - renderItemData._renderItem->enable(false); - }); - } - } - } + _ForEachRenderItemInRepr(pair.second, disableRenderItem); } } } @@ -622,11 +580,12 @@ void MayaUsdRPrim::_ForEachRenderItemInRepr(const HdReprSharedPtr& curRepr, Rend #if HD_API_VERSION < 35 for (HdDrawItem* item : items) { - if (HdVP2DrawItem* drawItem = static_cast(item)) { + HdVP2DrawItem* drawItem = static_cast(item); #else for (const HdRepr::DrawItemUniquePtr& item : items) { - if (HdVP2DrawItem* const drawItem = static_cast(item.get())) { + HdVP2DrawItem* drawItem = static_cast(item.get()); #endif + for (; drawItem; drawItem = drawItem->GetMod()) { for (auto& renderItemData : drawItem->GetRenderItems()) { func(renderItemData); } @@ -811,6 +770,7 @@ void MayaUsdRPrim::_SyncDisplayLayerModesInstanced(SdfPath const& id, unsigned i _displayLayerModesInstancedFrame = drawScene.GetFrameCounter(); _needForcedBBox = false; + _needHideOnPlaybackMod = false; if (drawScene.SupportPerInstanceDisplayLayers(id)) { _displayLayerModesInstanced.resize(instanceCount); for (unsigned int usdInstanceId = 0; usdInstanceId < instanceCount; usdInstanceId++) { @@ -821,6 +781,10 @@ void MayaUsdRPrim::_SyncDisplayLayerModesInstanced(SdfPath const& id, unsigned i if (displayLayerModes._reprOverride == kBBox) { _needForcedBBox = true; } + + if (displayLayerModes._hideOnPlayback) { + _needHideOnPlaybackMod = true; + } } } else { _displayLayerModesInstanced.clear(); @@ -1047,7 +1011,10 @@ bool MayaUsdRPrim::_GetMaterialPrimvars( return true; } -bool MayaUsdRPrim::_ShouldSkipInstance(unsigned int usdInstanceId, const TfToken& reprToken) const +bool MayaUsdRPrim::_ShouldSkipInstance( + unsigned int usdInstanceId, + const TfToken& reprToken, + bool hideOnPlaybackItem) const { if (_displayLayerModesInstanced.size() <= usdInstanceId) { return false; @@ -1068,6 +1035,10 @@ bool MayaUsdRPrim::_ShouldSkipInstance(unsigned int usdInstanceId, const TfToken } } + if (displayLayerModes._hideOnPlayback != hideOnPlaybackItem) { + return true; + } + return false; } diff --git a/lib/mayaUsd/render/vp2RenderDelegate/mayaPrimCommon.h b/lib/mayaUsd/render/vp2RenderDelegate/mayaPrimCommon.h index e4bc7a18c4..6113105fcf 100644 --- a/lib/mayaUsd/render/vp2RenderDelegate/mayaPrimCommon.h +++ b/lib/mayaUsd/render/vp2RenderDelegate/mayaPrimCommon.h @@ -268,7 +268,10 @@ class MayaUsdRPrim void _SyncDisplayLayerModes(SdfPath const& id); void _SyncDisplayLayerModesInstanced(SdfPath const& id, unsigned int instanceCount); - bool _ShouldSkipInstance(unsigned int usdInstanceId, const TfToken& reprToken) const; + bool _ShouldSkipInstance( + unsigned int usdInstanceId, + const TfToken& reprToken, + bool hideOnPlaybackItem) const; void _SyncForcedReprs( HdRprim& refThis, @@ -295,8 +298,8 @@ class MayaUsdRPrim void _HideAllDrawItems(HdReprSharedPtr const& curRepr); - void _ForEachRenderItemInRepr(const HdReprSharedPtr& curRepr, RenderItemFunc& func); - void _ForEachRenderItem(const ReprVector& reprs, RenderItemFunc& func); + static void _ForEachRenderItemInRepr(const HdReprSharedPtr& curRepr, RenderItemFunc& func); + static void _ForEachRenderItem(const ReprVector& reprs, RenderItemFunc& func); //! Helper utility function to adapt Maya API changes. static void _SetWantConsolidation(MHWRender::MRenderItem& renderItem, bool state); @@ -346,6 +349,9 @@ class MayaUsdRPrim uint64_t _displayLayerModesFrame { 0 }; uint64_t _displayLayerModesInstancedFrame { 0 }; + // For instanced primitives, specifies if at least one istance has to be hidden on playback + bool _needHideOnPlaybackMod = false; + // forced representations runtime state bool _needForcedBBox = false; uint64_t _forcedReprsFrame { 0 }; diff --git a/lib/mayaUsd/render/vp2RenderDelegate/mesh.cpp b/lib/mayaUsd/render/vp2RenderDelegate/mesh.cpp index fbe5f88922..c3fb9f305c 100644 --- a/lib/mayaUsd/render/vp2RenderDelegate/mesh.cpp +++ b/lib/mayaUsd/render/vp2RenderDelegate/mesh.cpp @@ -1164,137 +1164,140 @@ void HdVP2Mesh::_InitRepr(const TfToken& reprToken, HdDirtyBits* dirtyBits) #if HD_API_VERSION < 35 auto* drawItem = new HdVP2DrawItem(_delegate, &_sharedData); + _AddNewRenderItem(drawItem, desc, reprToken, subSceneContainer); #else std::unique_ptr drawItem = std::make_unique(_delegate, &_sharedData); + _AddNewRenderItem(drawItem.get(), desc, reprToken, subSceneContainer); #endif - const MString& renderItemName = drawItem->GetDrawItemName(); - - MHWRender::MRenderItem* renderItem = nullptr; + if (desc.geomStyle == HdMeshGeomStyleHull) { + if (desc.flatShadingEnabled) { + if (!(_customDirtyBitsInUse & DirtyFlatNormals)) { + _customDirtyBitsInUse |= DirtyFlatNormals; + *dirtyBits |= DirtyFlatNormals; + } + } else { + if (!(_customDirtyBitsInUse & DirtySmoothNormals)) { + _customDirtyBitsInUse |= DirtySmoothNormals; + *dirtyBits |= DirtySmoothNormals; + } + } + } - switch (desc.geomStyle) { - case HdMeshGeomStyleHull: - // Creating the smoothHull hull render items requires geom subsets from the topology, - // and we can't access that here. -#ifdef HAS_DEFAULT_MATERIAL_SUPPORT_API - if (reprToken == HdVP2ReprTokens->defaultMaterial) { - // But default material mode does not use geom subsets, so we create the render item - MHWRender::MRenderItem* defaultMaterialItem - = _CreateSmoothHullRenderItem( #if HD_API_VERSION < 35 - renderItemName, *drawItem, reprToken, *subSceneContainer, nullptr) + repr->AddDrawItem(drawItem); #else - renderItemName, *drawItem.get(), reprToken, *subSceneContainer, nullptr) + repr->AddDrawItem(std::move(drawItem)); #endif - ._renderItem; + } +} + +void HdVP2Mesh::_AddNewRenderItem( + HdVP2DrawItem* drawItem, + const HdMeshReprDesc& desc, + const TfToken& reprToken, + MSubSceneContainer* subSceneContainer, + const bool shareHighlightItem) +{ + const MString& renderItemName = drawItem->GetDrawItemName(); + + MHWRender::MRenderItem* renderItem = nullptr; + + switch (desc.geomStyle) { + case HdMeshGeomStyleHull: + // Creating the smoothHull hull render items requires geom subsets from the topology, + // and we can't access that here. +#ifdef HAS_DEFAULT_MATERIAL_SUPPORT_API + if (reprToken == HdVP2ReprTokens->defaultMaterial) { + // But default material mode does not use geom subsets, so we create the render item + MHWRender::MRenderItem* defaultMaterialItem + = _CreateSmoothHullRenderItem( + renderItemName, *drawItem, reprToken, *subSceneContainer, nullptr) + ._renderItem; + defaultMaterialItem->setDefaultMaterialHandling( + MRenderItem::DrawOnlyWhenDefaultMaterialActive); + defaultMaterialItem->setShader(_delegate->Get3dDefaultMaterialShader()); +#ifdef MAYA_NEW_POINT_SNAPPING_SUPPORT + if (!GetInstancerId().IsEmpty()) { + defaultMaterialItem = _CreateShadedSelectedInstancesItem( + renderItemName, *drawItem, reprToken, *subSceneContainer, nullptr); defaultMaterialItem->setDefaultMaterialHandling( MRenderItem::DrawOnlyWhenDefaultMaterialActive); defaultMaterialItem->setShader(_delegate->Get3dDefaultMaterialShader()); -#ifdef MAYA_NEW_POINT_SNAPPING_SUPPORT - if (!GetInstancerId().IsEmpty()) { - defaultMaterialItem = _CreateShadedSelectedInstancesItem( -#if HD_API_VERSION < 35 - renderItemName, *drawItem, reprToken, *subSceneContainer, nullptr); -#else - renderItemName, *drawItem.get(), reprToken, *subSceneContainer, nullptr); -#endif - defaultMaterialItem->setDefaultMaterialHandling( - MRenderItem::DrawOnlyWhenDefaultMaterialActive); - defaultMaterialItem->setShader(_delegate->Get3dDefaultMaterialShader()); - } -#endif } #endif - break; - case HdMeshGeomStyleHullEdgeOnly: - // The hull reprs use the wireframe item for selection highlight only. - if (reprToken == HdReprTokens->smoothHull - || reprToken == HdVP2ReprTokens->smoothHullUntextured - || reprToken == HdVP2ReprTokens->defaultMaterial) { - // Share selection highlight render item between hull reprs - bool foundShared = false; - for (auto it = _reprs.begin(); (it != _reprs.end()) && !foundShared; ++it) { - const HdReprSharedPtr& repr = it->second; - const auto& items = repr->GetDrawItems(); + } +#endif + break; + case HdMeshGeomStyleHullEdgeOnly: + // The hull reprs use the wireframe item for selection highlight only. + if (reprToken == HdReprTokens->smoothHull + || reprToken == HdVP2ReprTokens->smoothHullUntextured + || reprToken == HdVP2ReprTokens->defaultMaterial) { + // Share selection highlight render item between hull reprs + bool foundShared = false; + for (auto it = _reprs.begin(); + shareHighlightItem && (it != _reprs.end()) && !foundShared; + ++it) { + const HdReprSharedPtr& repr = it->second; + const auto& items = repr->GetDrawItems(); #if HD_API_VERSION < 35 - for (HdDrawItem* item : items) { - HdVP2DrawItem* shDrawItem = static_cast(item); + for (HdDrawItem* item : items) { + HdVP2DrawItem* shDrawItem = static_cast(item); #else - for (const HdRepr::DrawItemUniquePtr& item : items) { - HdVP2DrawItem* const shDrawItem = static_cast(item.get()); + for (const HdRepr::DrawItemUniquePtr& item : items) { + HdVP2DrawItem* const shDrawItem = static_cast(item.get()); #endif - if (shDrawItem - && shDrawItem->MatchesUsage(HdVP2DrawItem::kSelectionHighlight)) { - drawItem->ShareRenderItem(*shDrawItem); - foundShared = true; - break; - } + if (shDrawItem + && shDrawItem->MatchesUsage(HdVP2DrawItem::kSelectionHighlight)) { + drawItem->ShareRenderItem(*shDrawItem); + foundShared = true; + break; } } - if (!foundShared) { - renderItem = _CreateSelectionHighlightRenderItem(renderItemName); - } - drawItem->SetUsage(HdVP2DrawItem::kSelectionHighlight); - } - // The item is used for wireframe display and selection highlight. - else if (reprToken == HdReprTokens->wire) { - renderItem = _CreateWireframeRenderItem( - renderItemName, - kOpaqueBlue, - MSelectionMask::kSelectMeshes, - MHWRender::MFrameContext::kExcludeMeshes); - drawItem->AddUsage(HdVP2DrawItem::kSelectionHighlight); } - // The item is used for bbox display and selection highlight. - else if ( - reprToken == HdVP2ReprTokens->bbox || reprToken == HdVP2ReprTokens->forcedBbox) { - renderItem = _CreateBoundingBoxRenderItem( - renderItemName, - kOpaqueBlue, - MSelectionMask::kSelectMeshes, - MHWRender::MFrameContext::kExcludeMeshes); - drawItem->AddUsage(HdVP2DrawItem::kSelectionHighlight); - if (reprToken == HdVP2ReprTokens->forcedBbox) { - renderItem->enable(false); - renderItem->setDrawMode(MHWRender::MGeometry::kAll); - } + if (!foundShared) { + renderItem = _CreateSelectionHighlightRenderItem(renderItemName); } - break; -#ifndef MAYA_NEW_POINT_SNAPPING_SUPPORT - case HdMeshGeomStylePoints: - renderItem = _CreatePointsRenderItem( + drawItem->SetUsage(HdVP2DrawItem::kSelectionHighlight); + } + // The item is used for wireframe display and selection highlight. + else if (reprToken == HdReprTokens->wire) { + renderItem = _CreateWireframeRenderItem( renderItemName, - MSelectionMask::kSelectMeshVerts, + kOpaqueBlue, + MSelectionMask::kSelectMeshes, MHWRender::MFrameContext::kExcludeMeshes); - break; -#endif - default: TF_WARN("Unsupported geomStyle"); break; - } - - if (renderItem) { - _AddRenderItem(*drawItem, renderItem, *subSceneContainer); + drawItem->AddUsage(HdVP2DrawItem::kSelectionHighlight); } - - if (desc.geomStyle == HdMeshGeomStyleHull) { - if (desc.flatShadingEnabled) { - if (!(_customDirtyBitsInUse & DirtyFlatNormals)) { - _customDirtyBitsInUse |= DirtyFlatNormals; - *dirtyBits |= DirtyFlatNormals; - } - } else { - if (!(_customDirtyBitsInUse & DirtySmoothNormals)) { - _customDirtyBitsInUse |= DirtySmoothNormals; - *dirtyBits |= DirtySmoothNormals; - } + // The item is used for bbox display and selection highlight. + else if (reprToken == HdVP2ReprTokens->bbox || reprToken == HdVP2ReprTokens->forcedBbox) { + renderItem = _CreateBoundingBoxRenderItem( + renderItemName, + kOpaqueBlue, + MSelectionMask::kSelectMeshes, + MHWRender::MFrameContext::kExcludeMeshes); + drawItem->AddUsage(HdVP2DrawItem::kSelectionHighlight); + if (reprToken == HdVP2ReprTokens->forcedBbox) { + renderItem->enable(false); + renderItem->setDrawMode(MHWRender::MGeometry::kAll); } } - -#if HD_API_VERSION < 35 - repr->AddDrawItem(drawItem); -#else - repr->AddDrawItem(std::move(drawItem)); + break; +#ifndef MAYA_NEW_POINT_SNAPPING_SUPPORT + case HdMeshGeomStylePoints: + renderItem = _CreatePointsRenderItem( + renderItemName, + MSelectionMask::kSelectMeshVerts, + MHWRender::MFrameContext::kExcludeMeshes); + break; #endif + default: TF_WARN("Unsupported geomStyle"); break; + } + + if (renderItem) { + _AddRenderItem(*drawItem, renderItem, *subSceneContainer); } } @@ -1435,6 +1438,62 @@ void HdVP2Mesh::_UpdateRepr(HdSceneDelegate* sceneDelegate, const TfToken& reprT for (auto& renderItemData : drawItem->GetRenderItems()) { _UpdateDrawItem(sceneDelegate, drawItem, renderItemData, desc, reprToken); } + + // Instanced prims may require additional draw items/mods + _UpdateMods(*this, drawItem, sceneDelegate, reprToken, desc, subSceneContainer); + } +} + +void HdVP2Mesh::_UpdateMods( + HdRprim& refThis, + HdVP2DrawItem* drawItem, + HdSceneDelegate* sceneDelegate, + const TfToken& reprToken, + const HdMeshReprDesc& desc, + MSubSceneContainer* subSceneContainer) +{ + // Mods are required only for instanced primitives + if (refThis.GetInstancerId().IsEmpty()) { + return; + } + + HdVP2DrawItem* mod = drawItem->GetMod(); + if (_needHideOnPlaybackMod) { + // Create the mod if needed + if (!mod) { + drawItem->SetMod(std::make_unique(_delegate, &_sharedData)); + mod = drawItem->GetMod(); + + // Add render items to the mod in the same way it is done for the original draw item + _AddNewRenderItem(mod, desc, reprToken, subSceneContainer, false); + if (desc.geomStyle == HdMeshGeomStyleHull) { + if (mod->GetRenderItems().size() == 0) { + _CreateSmoothHullRenderItems(*mod, reprToken, *subSceneContainer); + } + } + + // Make sure to enable hide-on-playback on the mod + mod->SetModFlagHideOnPlayback(true); +#ifdef MAYA_HAS_RENDER_ITEM_HIDE_ON_PLAYBACK_API + for (auto& renderItemData : mod->GetRenderItems()) { + renderItemData._renderItem->setHideOnPlayback(true); + } +#endif + } + + // Update the mod + for (auto& renderItemData : mod->GetRenderItems()) { + _UpdateDrawItem(sceneDelegate, mod, renderItemData, desc, reprToken); + } + } else if (mod) { + // Disable the mod + for (auto& renderItemData : mod->GetRenderItems()) { + if (renderItemData._enabled) { + renderItemData._enabled = false; + _delegate->GetVP2ResourceRegistry().EnqueueCommit( + [&renderItemData]() { renderItemData._renderItem->enable(false); }); + } + } } } @@ -1868,6 +1927,7 @@ void HdVP2Mesh::_UpdateDrawItem( #endif _SyncDisplayLayerModesInstanced(id, instanceCount); + const bool hideOnPlaybackItem = drawItem->GetModFlagHideOnPlayback(); stateToCommit._instanceTransforms = std::make_shared(); stateToCommit._instanceColors = std::make_shared(); @@ -1877,7 +1937,7 @@ void HdVP2Mesh::_UpdateDrawItem( continue; // Check display layer modes of this instance - if (_ShouldSkipInstance(usdInstanceId, reprToken)) + if (_ShouldSkipInstance(usdInstanceId, reprToken, hideOnPlaybackItem)) continue; #ifndef MAYA_UPDATE_UFE_IDENTIFIER_SUPPORT diff --git a/lib/mayaUsd/render/vp2RenderDelegate/mesh.h b/lib/mayaUsd/render/vp2RenderDelegate/mesh.h index 9deeeb8aca..4b1d75ca2c 100644 --- a/lib/mayaUsd/render/vp2RenderDelegate/mesh.h +++ b/lib/mayaUsd/render/vp2RenderDelegate/mesh.h @@ -144,6 +144,21 @@ class HdVP2Mesh final TfToken& _RenderTag() override { return _meshSharedData->_renderTag; } + void _AddNewRenderItem( + HdVP2DrawItem* drawItem, + const HdMeshReprDesc& desc, + const TfToken& reprToken, + MSubSceneContainer* subSceneContainer, + const bool shareHighlightItem = true); + + void _UpdateMods( + HdRprim& refThis, + HdVP2DrawItem* drawItem, + HdSceneDelegate* sceneDelegate, + const TfToken& reprToken, + const HdMeshReprDesc& desc, + MSubSceneContainer* subSceneContainer); + void _UpdateDrawItem( HdSceneDelegate*, HdVP2DrawItem*,