Add per-viewport cull style option

Exposes UsdImagingGLCullStyle as a Cull Style sub-menu in the gear popup
(Back Unless Double-Sided / Back / Front / Nothing / No Opinion). Defaults
to BackUnlessDoubleSided, matching usdview. Setting persists per-viewport
to viewport_settings.ini.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/core/UsdSceneRenderer.cpp

@@ -167,10 +167,14 @@ void main() { outColor = color; }
 UsdSceneRenderer::UsdSceneRenderer()
     : m_showGrid(true)
     , m_showCameraGuide(false)
+    , m_showGuides(false)
+    , m_showProxy(true)
+    , m_showRender(false)
     , m_currentAov(pxr::TfToken("color"))
     , m_aaEnabled(false)
     , m_backgroundColor(0.15f, 0.15f, 0.15f)
     , m_shadingMode(ShadingMode::SmoothShaded)
+    , m_cullStyle(CullStyle::BackUnlessDoubleSided)
     , m_colorCorrectionMode(ColorCorrectionMode::sRGB)
     , m_ambientLightOnly(true)
     , m_domeLightEnabled(false)
@@ -720,12 +724,12 @@ void UsdSceneRenderer::Render(int width, int height)
             m_renderParams.drawMode     = pxr::UsdImagingGLDrawMode::DRAW_SHADED_SMOOTH;
             m_renderParams.enableLighting = true;  break;
     }
-    m_renderParams.showGuides               = true;
+    m_renderParams.showGuides               = m_showGuides;
-    m_renderParams.showProxy                = true;
+    m_renderParams.showProxy                = m_showProxy;
-    m_renderParams.showRender               = false;
+    m_renderParams.showRender               = m_showRender;
     m_renderParams.enableSampleAlphaToCoverage = true;
     m_renderParams.gammaCorrectColors       = false;
-    m_renderParams.cullStyle                = pxr::UsdImagingGLCullStyle::CULL_STYLE_BACK_UNLESS_DOUBLE_SIDED;
+    m_renderParams.cullStyle                = static_cast<pxr::UsdImagingGLCullStyle>(m_cullStyle);
     m_renderParams.enableSceneMaterials     = true;
     m_renderParams.enableSceneLights        = true;
     m_renderParams.highlight                = true;

src/core/UsdSceneRenderer.h

@@ -43,6 +43,15 @@ enum class ShadingMode {
     Unlit,               ///< Smooth geometry, lighting disabled
 };
 
+/// Back-face culling style — maps directly to UsdImagingGLCullStyle.
+enum class CullStyle {
+    NoOpinion           = 0,
+    Nothing             = 1,
+    Back                = 2,
+    Front               = 3,
+    BackUnlessDoubleSided = 4,
+};
+
 /// Viewport color correction mode — maps to UsdImagingGLRenderParams::colorCorrectionMode.
 enum class ColorCorrectionMode {
     Disabled,    ///< No correction (raw linear output)
@@ -185,6 +194,13 @@ public:
     bool              ShowCameraGuide()         const { return m_showCameraGuide; }
     void              SetShowCameraGuide(bool show)   { m_showCameraGuide = show; }
 
+    bool              ShowGuides()              const { return m_showGuides; }
+    void              SetShowGuides(bool show)        { m_showGuides = show; }
+    bool              ShowProxy()               const { return m_showProxy; }
+    void              SetShowProxy(bool show)         { m_showProxy = show; }
+    bool              ShowRender()              const { return m_showRender; }
+    void              SetShowRender(bool show)        { m_showRender = show; }
+
     const pxr::TfToken& GetCurrentAov()        const { return m_currentAov; }
     pxr::TfTokenVector  GetRendererAovs()       const;
     bool                SetCurrentAov(const pxr::TfToken& aov);
@@ -233,6 +249,9 @@ public:
     ShadingMode GetShadingMode()             const { return m_shadingMode; }
     void        SetShadingMode(ShadingMode m)     { m_shadingMode = m; m_forceRefresh = true; }
 
+    CullStyle   GetCullStyle()               const { return m_cullStyle; }
+    void        SetCullStyle(CullStyle c)          { m_cullStyle = c; m_forceRefresh = true; }
+
     ColorCorrectionMode GetColorCorrectionMode()              const { return m_colorCorrectionMode; }
     void                SetColorCorrectionMode(ColorCorrectionMode m) { m_colorCorrectionMode = m; m_forceRefresh = true; }
 
@@ -342,12 +361,16 @@ private:
 
     bool            m_showGrid;
     bool            m_showCameraGuide;
+    bool            m_showGuides;
+    bool            m_showProxy;
+    bool            m_showRender;
     pxr::TfToken    m_currentAov;
     bool            m_aaEnabled;        ///< GL_LINE_SMOOTH anti-aliasing for all line overlays
     pxr::GfVec3f    m_backgroundColor;
 
     // Lighting settings (mirrors stageView.py viewSettings)
     ShadingMode          m_shadingMode;            // draw mode + lighting flags
+    CullStyle            m_cullStyle;              // back/front/none face culling
     ColorCorrectionMode  m_colorCorrectionMode;    // viewport color correction
     std::string          m_ocioDisplay;
     std::string          m_ocioView;

src/ui/ViewportPanel.cpp

@@ -659,6 +659,9 @@ void ViewportPanel::SaveSettings(const std::string& path) const
         f << "ShowGrid="         << (s.showGrid        ? 1 : 0) << "\n";
         f << "ShowCameraGuide="  << (s.showCameraGuide ? 1 : 0) << "\n";
         f << "Aov="              << s.aov              << "\n";
+        f << "ShowGuides="       << (s.showGuides      ? 1 : 0) << "\n";
+        f << "ShowProxy="        << (s.showProxy       ? 1 : 0) << "\n";
+        f << "ShowRender="       << (s.showRender      ? 1 : 0) << "\n";
         f << "AAEnabled="        << (s.aaEnabled        ? 1 : 0) << "\n";
         f << "BgColorR="         << s.bgColorR          << "\n";
         f << "BgColorG="         << s.bgColorG          << "\n";
@@ -667,6 +670,7 @@ void ViewportPanel::SaveSettings(const std::string& path) const
         f << "AmbientLightOnly=" << (s.ambientLightOnly ? 1 : 0) << "\n";
         f << "DomeLightEnabled=" << (s.domeLightEnabled ? 1 : 0) << "\n";
         f << "ShadingMode="      << s.shadingMode        << "\n";
+        f << "CullStyle="        << s.cullStyle          << "\n";
     }
 }
 
@@ -727,6 +731,9 @@ void ViewportPanel::LoadSettings(const std::string& path)
             else if (key == "ShowGrid")         ts.showGrid         = (val == "1");
             else if (key == "ShowCameraGuide")  ts.showCameraGuide  = (val == "1");
             else if (key == "Aov")              ts.aov              = val;
+            else if (key == "ShowGuides")       ts.showGuides       = (val == "1");
+            else if (key == "ShowProxy")        ts.showProxy        = (val == "1");
+            else if (key == "ShowRender")       ts.showRender       = (val == "1");
             else if (key == "AAEnabled")        ts.aaEnabled        = (val == "1");
             else if (key == "BgColorR")         ts.bgColorR         = toFloat(val, ts.bgColorR);
             else if (key == "BgColorG")         ts.bgColorG         = toFloat(val, ts.bgColorG);
@@ -735,6 +742,7 @@ void ViewportPanel::LoadSettings(const std::string& path)
             else if (key == "AmbientLightOnly") ts.ambientLightOnly = (val == "1");
             else if (key == "DomeLightEnabled") ts.domeLightEnabled = (val == "1");
             else if (key == "ShadingMode")      ts.shadingMode      = toInt(val, ts.shadingMode);
+            else if (key == "CullStyle")        ts.cullStyle        = toInt(val, ts.cullStyle);
         }
     }
 

src/ui/ViewportTile.cpp

@@ -96,6 +96,9 @@ ViewportTileSettings ViewportTile::GetSettings() const
     s.showGrid         = m_renderer.ShowGrid();
     s.showCameraGuide  = m_renderer.ShowCameraGuide();
     s.aov              = m_renderer.GetCurrentAov().GetString();
+    s.showGuides       = m_renderer.ShowGuides();
+    s.showProxy        = m_renderer.ShowProxy();
+    s.showRender       = m_renderer.ShowRender();
     s.aaEnabled        = m_renderer.GetAAEnabled();
     const pxr::GfVec3f& bg = m_renderer.GetBackgroundColor();
     s.bgColorR = bg[0]; s.bgColorG = bg[1]; s.bgColorB = bg[2];
@@ -103,6 +106,7 @@ ViewportTileSettings ViewportTile::GetSettings() const
     s.ambientLightOnly = m_renderer.GetAmbientLightOnly();
     s.domeLightEnabled = m_renderer.GetDomeLightEnabled();
     s.shadingMode      = static_cast<int>(m_renderer.GetShadingMode());
+    s.cullStyle        = static_cast<int>(m_renderer.GetCullStyle());
     return s;
 }
 
@@ -114,12 +118,16 @@ void ViewportTile::ApplySettings(const ViewportTileSettings& s)
     m_renderer.SetShowCameraGuide(s.showCameraGuide);
     if (!s.aov.empty())
         m_renderer.SetCurrentAov(pxr::TfToken(s.aov));
+    m_renderer.SetShowGuides(s.showGuides);
+    m_renderer.SetShowProxy(s.showProxy);
+    m_renderer.SetShowRender(s.showRender);
     m_renderer.SetAAEnabled(s.aaEnabled);
     m_renderer.SetBackgroundColor(pxr::GfVec3f(s.bgColorR, s.bgColorG, s.bgColorB));
     m_renderer.SetBBoxMode(static_cast<BBoxMode>(s.bboxMode));
     m_renderer.SetAmbientLightOnly(s.ambientLightOnly);
     m_renderer.SetDomeLightEnabled(s.domeLightEnabled);
     m_renderer.SetShadingMode(static_cast<ShadingMode>(s.shadingMode));
+    m_renderer.SetCullStyle(static_cast<CullStyle>(s.cullStyle));
 }
 
 // ---------------------------------------------------------------------------
@@ -1012,6 +1020,21 @@ void ViewportTile::RenderCompactToolbar(int tileIndex)
                 ImGui::EndMenu();
             }
 
+            // -- Cull Style --------------------------------------------------
+            if (ImGui::BeginMenu("Cull Style")) {
+                CullStyle curCull = m_renderer.GetCullStyle();
+                auto cullItem = [&](const char* label, CullStyle style) {
+                    if (ImGui::MenuItem(label, nullptr, curCull == style))
+                        m_renderer.SetCullStyle(style);
+                };
+                cullItem("Back Unless Double-Sided", CullStyle::BackUnlessDoubleSided);
+                cullItem("Back",                     CullStyle::Back);
+                cullItem("Front",                    CullStyle::Front);
+                cullItem("Nothing",                  CullStyle::Nothing);
+                cullItem("No Opinion",               CullStyle::NoOpinion);
+                ImGui::EndMenu();
+            }
+
             // -- AOV ---------------------------------------------------------
             {
                 pxr::TfTokenVector aovs = m_renderer.GetRendererAovs();
@@ -1052,6 +1075,19 @@ void ViewportTile::RenderCompactToolbar(int tileIndex)
                 if (ImGui::MenuItem("Camera Guide", nullptr, guide))
                     m_renderer.SetShowCameraGuide(!guide);
 
+                if (ImGui::BeginMenu("Purpose")) {
+                    bool purGuide = m_renderer.ShowGuides();
+                    if (ImGui::MenuItem("Guide",  nullptr, purGuide))
+                        m_renderer.SetShowGuides(!purGuide);
+                    bool purProxy = m_renderer.ShowProxy();
+                    if (ImGui::MenuItem("Proxy",  nullptr, purProxy))
+                        m_renderer.SetShowProxy(!purProxy);
+                    bool purRender = m_renderer.ShowRender();
+                    if (ImGui::MenuItem("Render", nullptr, purRender))
+                        m_renderer.SetShowRender(!purRender);
+                    ImGui::EndMenu();
+                }
+
                 bool aaItem = m_renderer.GetAAEnabled();
                 if (ImGui::MenuItem("Anti-Aliasing", nullptr, aaItem))
                     m_renderer.SetAAEnabled(!aaItem);

src/ui/ViewportTile.h

@@ -32,6 +32,10 @@ struct ViewportTileSettings {
     bool        ambientLightOnly = true;
     bool        domeLightEnabled = false;
     int         shadingMode      = 0;
+    int         cullStyle        = 4; // CullStyle::BackUnlessDoubleSided
+    bool        showGuides       = false;
+    bool        showProxy        = true;
+    bool        showRender       = false;
 };
 
 /// Named orthographic view directions.