Bypass loading of clipped tiles

exts/cesium.omniverse/cesium/omniverse/ui/attributes/polygon_raster_overlay_attributes_widget.py

@@ -25,6 +25,8 @@ def _customize_props_layout(self, props):
                 CustomLayoutProperty("cesium:cartographicPolygonBinding")
             with CustomLayoutGroup("Invert Selection"):
                 CustomLayoutProperty("cesium:invertSelection")
+            with CustomLayoutGroup("Exclude Selected Tiles"):
+                CustomLayoutProperty("cesium:excludeSelectedTiles")
             with CustomLayoutGroup("Rendering"):
                 CustomLayoutProperty("cesium:alpha", build_fn=build_slider(0, 1))
                 CustomLayoutProperty("cesium:overlayRenderMethod")

exts/cesium.usd.plugins/schemas/cesium_schemas.usda

@@ -509,6 +509,14 @@ class CesiumPolygonRasterOverlayPrim "CesiumPolygonRasterOverlayPrim" (
         doc = "Whether to invert the selection specified by the polygons. If this is true, only the areas outside of the polygons will be rasterized."
     )
 
+    bool cesium:excludeSelectedTiles = true (
+        customData = {
+            string apiName = "excludeSelectedTiles"
+        }
+        displayName = "Exclude Selected Tiles"
+        doc = "Whether tiles that fall entirely within the rasterized selection should be excluded from loading and rendering. For better performance, this should be enabled when this overlay will be used for clipping. But when this overlay is used for other effects, this option should be disabled to avoid missing tiles. Note that if InvertSelection is true, this will cull tiles that are outside of all the polygons. If it is false, this will cull tiles that are completely inside at least one polygon."
+    )
+
     uniform token cesium:overlayRenderMethod = "clip"
 }
 

src/core/include/cesium/omniverse/OmniPolygonRasterOverlay.h

@@ -2,6 +2,7 @@
 
 #include "cesium/omniverse/OmniRasterOverlay.h"
 
+#include <Cesium3DTilesSelection/RasterizedPolygonsTileExcluder.h>
 #include <CesiumRasterOverlays/RasterizedPolygonsOverlay.h>
 #include <CesiumUtility/IntrusivePointer.h>
 
@@ -19,9 +20,12 @@ class OmniPolygonRasterOverlay final : public OmniRasterOverlay {
     [[nodiscard]] std::vector<pxr::SdfPath> getCartographicPolygonPaths() const;
     [[nodiscard]] CesiumRasterOverlays::RasterOverlay* getRasterOverlay() const override;
     [[nodiscard]] bool getInvertSelection() const;
+    [[nodiscard]] bool getExcludeSelectedTiles() const;
+    [[nodiscard]] std::shared_ptr<Cesium3DTilesSelection::RasterizedPolygonsTileExcluder> getExcluder();
     void reload() override;
 
   private:
     CesiumUtility::IntrusivePointer<CesiumRasterOverlays::RasterizedPolygonsOverlay> _pPolygonRasterOverlay;
+    std::shared_ptr<Cesium3DTilesSelection::RasterizedPolygonsTileExcluder> _pExcluder;
 };
 } // namespace cesium::omniverse

src/core/src/OmniPolygonRasterOverlay.cpp

@@ -16,7 +16,8 @@
 namespace cesium::omniverse {
 
 OmniPolygonRasterOverlay::OmniPolygonRasterOverlay(Context* pContext, const pxr::SdfPath& path)
-    : OmniRasterOverlay(pContext, path) {}
+    : OmniRasterOverlay(pContext, path)
+    , _pExcluder(nullptr) {}
 
 std::vector<pxr::SdfPath> OmniPolygonRasterOverlay::getCartographicPolygonPaths() const {
     const auto cesiumPolygonRasterOverlay = UsdUtil::getCesiumPolygonRasterOverlay(_pContext->getUsdStage(), _path);
@@ -38,6 +39,17 @@ bool OmniPolygonRasterOverlay::getInvertSelection() const {
     return invertSelection;
 }
 
+bool OmniPolygonRasterOverlay::getExcludeSelectedTiles() const {
+    auto cesiumPolygonRasterOverlay = UsdUtil::getCesiumPolygonRasterOverlay(_pContext->getUsdStage(), _path);
+    bool val;
+    cesiumPolygonRasterOverlay.GetExcludeSelectedTilesAttr().Get(&val);
+    return val;
+}
+
+std::shared_ptr<Cesium3DTilesSelection::RasterizedPolygonsTileExcluder> OmniPolygonRasterOverlay::getExcluder() {
+    return _pExcluder;
+}
+
 void OmniPolygonRasterOverlay::reload() {
     const auto rasterOverlayName = UsdUtil::getName(_pContext->getUsdStage(), _path);
 
@@ -104,6 +116,14 @@ void OmniPolygonRasterOverlay::reload() {
 
     _pPolygonRasterOverlay = new CesiumRasterOverlays::RasterizedPolygonsOverlay(
         rasterOverlayName, polygons, getInvertSelection(), *pEllipsoid, projection, options);
+
+    auto cesiumPolygonRasterOverlay = UsdUtil::getCesiumPolygonRasterOverlay(_pContext->getUsdStage(), _path);
+    bool excludeSelectedTiles;
+    cesiumPolygonRasterOverlay.GetExcludeSelectedTilesAttr().Get(&excludeSelectedTiles);
+    if (excludeSelectedTiles) {
+        auto pPolygons = _pPolygonRasterOverlay.get();
+        _pExcluder = std::make_shared<Cesium3DTilesSelection::RasterizedPolygonsTileExcluder>(pPolygons);
+    }
 }
 
 } // namespace cesium::omniverse

src/core/src/OmniTileset.cpp

@@ -458,6 +458,7 @@ void OmniTileset::reload() {
     options.culledScreenSpaceError = getCulledScreenSpaceError();
     options.mainThreadLoadingTimeLimit = getMainThreadLoadingTimeLimit();
     options.showCreditsOnScreen = getShowCreditsOnScreen();
+    options.excluders = std::vector<std::shared_ptr<Cesium3DTilesSelection::ITileExcluder>>();
 
     options.loadErrorCallback =
         [this, tilesetPath, ionAssetId, name](const Cesium3DTilesSelection::TilesetLoadFailureDetails& error) {
@@ -504,6 +505,30 @@ void OmniTileset::reload() {
             }
         }
     }
+
+    const auto& allOmniPolygonRasterOverlays = _pContext->getAssetRegistry().getPolygonRasterOverlays();
+    const auto& boundNativeRasterOverlays =
+        _pTileset->getOverlays().getOverlays(); // get RasterOverlays from RasterOverlayCollection
+    for (const auto& pOmniPolygonRasterOverlay : allOmniPolygonRasterOverlays) {
+        const auto& pNativeOverlay = pOmniPolygonRasterOverlay->getRasterOverlay();
+
+        auto matchIterator = std::find_if(
+            boundNativeRasterOverlays.begin(),
+            boundNativeRasterOverlays.end(),
+            [&pNativeOverlay](const auto& possibleMatch) { return possibleMatch.get() == pNativeOverlay; });
+
+        if (matchIterator == boundNativeRasterOverlays.end()) {
+            continue;
+        }
+
+        const auto exclude = pOmniPolygonRasterOverlay->getExcludeSelectedTiles();
+        if (exclude) {
+            const auto excluder = pOmniPolygonRasterOverlay->getExcluder();
+            if (excluder) {
+                _pTileset->getOptions().excluders.push_back(excluder);
+            }
+        }
+    }
 }
 
 pxr::SdfPath OmniTileset::getRasterOverlayPath(const CesiumRasterOverlays::RasterOverlay& rasterOverlay) const {

src/core/src/UsdNotificationHandler.cpp

@@ -303,7 +303,8 @@ void processCesiumPolygonRasterOverlayChanged(
 
     for (const auto& property : properties) {
         if (property == pxr::CesiumTokens->cesiumCartographicPolygonBinding ||
-            property == pxr::CesiumTokens->cesiumInvertSelection) {
+            property == pxr::CesiumTokens->cesiumInvertSelection ||
+            property == pxr::CesiumTokens->cesiumExcludeSelectedTiles) {
             reload = true;
             updateBindings = true;
         }

src/plugins/CesiumUsdSchemas/generatedSchema.usda.in

@@ -385,6 +385,10 @@ class CesiumPolygonRasterOverlayPrim "CesiumPolygonRasterOverlayPrim" (
         displayName = "Cartographic Polygon Binding"
         doc = "Specifies which Cartographic Polygons to use in the raster overlay"
     )
+    bool cesium:excludeSelectedTiles = 1 (
+        displayName = "Exclude Selected Tiles"
+        doc = "Whether tiles that fall entirely within the rasterized selection should be excluded from loading and rendering. For better performance, this should be enabled when this overlay will be used for clipping. But when this overlay is used for other effects, this option should be disabled to avoid missing tiles. Note that if InvertSelection is true, this will cull tiles that are outside of all the polygons. If it is false, this will cull tiles that are completely inside at least one polygon."
+    )
     bool cesium:invertSelection = 0 (
         displayName = "Invert Selection"
         doc = "Whether to invert the selection specified by the polygons. If this is true, only the areas outside of the polygons will be rasterized."

src/plugins/CesiumUsdSchemas/src/CesiumUsdSchemas/polygonRasterOverlay.cpp

@@ -97,6 +97,23 @@ CesiumPolygonRasterOverlay::CreateInvertSelectionAttr(VtValue const &defaultValu
                        writeSparsely);
 }
 
+UsdAttribute
+CesiumPolygonRasterOverlay::GetExcludeSelectedTilesAttr() const
+{
+    return GetPrim().GetAttribute(CesiumTokens->cesiumExcludeSelectedTiles);
+}
+
+UsdAttribute
+CesiumPolygonRasterOverlay::CreateExcludeSelectedTilesAttr(VtValue const &defaultValue, bool writeSparsely) const
+{
+    return UsdSchemaBase::_CreateAttr(CesiumTokens->cesiumExcludeSelectedTiles,
+                       SdfValueTypeNames->Bool,
+                       /* custom = */ false,
+                       SdfVariabilityVarying,
+                       defaultValue,
+                       writeSparsely);
+}
+
 UsdAttribute
 CesiumPolygonRasterOverlay::GetCesiumOverlayRenderMethodAttr() const
 {
@@ -145,6 +162,7 @@ CesiumPolygonRasterOverlay::GetSchemaAttributeNames(bool includeInherited)
 {
     static TfTokenVector localNames = {
         CesiumTokens->cesiumInvertSelection,
+        CesiumTokens->cesiumExcludeSelectedTiles,
         CesiumTokens->cesiumOverlayRenderMethod,
     };
     static TfTokenVector allNames =

src/plugins/CesiumUsdSchemas/src/CesiumUsdSchemas/polygonRasterOverlay.h

@@ -152,6 +152,28 @@ class CesiumPolygonRasterOverlay : public CesiumRasterOverlay
     CESIUMUSDSCHEMAS_API
     UsdAttribute CreateInvertSelectionAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
 
+public:
+    // --------------------------------------------------------------------- //
+    // EXCLUDESELECTEDTILES 
+    // --------------------------------------------------------------------- //
+    /// Whether tiles that fall entirely within the rasterized selection should be excluded from loading and rendering. For better performance, this should be enabled when this overlay will be used for clipping. But when this overlay is used for other effects, this option should be disabled to avoid missing tiles. Note that if InvertSelection is true, this will cull tiles that are outside of all the polygons. If it is false, this will cull tiles that are completely inside at least one polygon.
+    ///
+    /// | ||
+    /// | -- | -- |
+    /// | Declaration | `bool cesium:excludeSelectedTiles = 1` |
+    /// | C++ Type | bool |
+    /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool |
+    CESIUMUSDSCHEMAS_API
+    UsdAttribute GetExcludeSelectedTilesAttr() const;
+
+    /// See GetExcludeSelectedTilesAttr(), and also 
+    /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
+    /// If specified, author \p defaultValue as the attribute's default,
+    /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
+    /// the default for \p writeSparsely is \c false.
+    CESIUMUSDSCHEMAS_API
+    UsdAttribute CreateExcludeSelectedTilesAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
+
 public:
     // --------------------------------------------------------------------- //
     // CESIUMOVERLAYRENDERMETHOD 

src/plugins/CesiumUsdSchemas/src/CesiumUsdSchemas/tokens.cpp

@@ -28,6 +28,7 @@ CesiumTokensType::CesiumTokensType() :
     cesiumEnableFogCulling("cesium:enableFogCulling", TfToken::Immortal),
     cesiumEnableFrustumCulling("cesium:enableFrustumCulling", TfToken::Immortal),
     cesiumEnforceCulledScreenSpaceError("cesium:enforceCulledScreenSpaceError", TfToken::Immortal),
+    cesiumExcludeSelectedTiles("cesium:excludeSelectedTiles", TfToken::Immortal),
     cesiumForbidHoles("cesium:forbidHoles", TfToken::Immortal),
     cesiumGeoreferenceBinding("cesium:georeferenceBinding", TfToken::Immortal),
     cesiumGeoreferenceOriginHeight("cesium:georeferenceOrigin:height", TfToken::Immortal),
@@ -87,6 +88,7 @@ CesiumTokensType::CesiumTokensType() :
         cesiumEnableFogCulling,
         cesiumEnableFrustumCulling,
         cesiumEnforceCulledScreenSpaceError,
+        cesiumExcludeSelectedTiles,
         cesiumForbidHoles,
         cesiumGeoreferenceBinding,
         cesiumGeoreferenceOriginHeight,

src/plugins/CesiumUsdSchemas/src/CesiumUsdSchemas/tokens.h

@@ -139,6 +139,10 @@ struct CesiumTokensType {
     /// 
     /// CesiumTileset
     const TfToken cesiumEnforceCulledScreenSpaceError;
+    /// \brief "cesium:excludeSelectedTiles"
+    /// 
+    /// CesiumPolygonRasterOverlay
+    const TfToken cesiumExcludeSelectedTiles;
     /// \brief "cesium:forbidHoles"
     /// 
     /// CesiumTileset

src/plugins/CesiumUsdSchemas/src/CesiumUsdSchemas/wrapPolygonRasterOverlay.cpp

@@ -33,6 +33,13 @@ _CreateInvertSelectionAttr(CesiumPolygonRasterOverlay &self,
         UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Bool), writeSparsely);
 }
 
+static UsdAttribute
+_CreateExcludeSelectedTilesAttr(CesiumPolygonRasterOverlay &self,
+                                      object defaultVal, bool writeSparsely) {
+    return self.CreateExcludeSelectedTilesAttr(
+        UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Bool), writeSparsely);
+}
+
 static UsdAttribute
 _CreateCesiumOverlayRenderMethodAttr(CesiumPolygonRasterOverlay &self,
                                       object defaultVal, bool writeSparsely) {
@@ -89,6 +96,13 @@ void wrapCesiumPolygonRasterOverlay()
              (arg("defaultValue")=object(),
               arg("writeSparsely")=false))
 
+        .def("GetExcludeSelectedTilesAttr",
+             &This::GetExcludeSelectedTilesAttr)
+        .def("CreateExcludeSelectedTilesAttr",
+             &_CreateExcludeSelectedTilesAttr,
+             (arg("defaultValue")=object(),
+              arg("writeSparsely")=false))
+
         .def("GetCesiumOverlayRenderMethodAttr",
              &This::GetCesiumOverlayRenderMethodAttr)
         .def("CreateCesiumOverlayRenderMethodAttr",

src/plugins/CesiumUsdSchemas/src/CesiumUsdSchemas/wrapTokens.cpp

@@ -66,6 +66,7 @@ void wrapCesiumTokens()
     _AddToken(cls, "cesiumEnableFogCulling", CesiumTokens->cesiumEnableFogCulling);
     _AddToken(cls, "cesiumEnableFrustumCulling", CesiumTokens->cesiumEnableFrustumCulling);
     _AddToken(cls, "cesiumEnforceCulledScreenSpaceError", CesiumTokens->cesiumEnforceCulledScreenSpaceError);
+    _AddToken(cls, "cesiumExcludeSelectedTiles", CesiumTokens->cesiumExcludeSelectedTiles);
     _AddToken(cls, "cesiumForbidHoles", CesiumTokens->cesiumForbidHoles);
     _AddToken(cls, "cesiumGeoreferenceBinding", CesiumTokens->cesiumGeoreferenceBinding);
     _AddToken(cls, "cesiumGeoreferenceOriginHeight", CesiumTokens->cesiumGeoreferenceOriginHeight);