Add Maya-style Render Layer panel

Render layers built on the existing USD sublayer architecture: each layer is a
file-backed SdfLayer mounted as a sublayer and tagged via custom layer data,
with membership stored in a UsdCollectionAPI on a hidden /RenderLayerData prim.
Activating a layer applies its overrides and isolates it to its members.
"Default" is virtual -- it means all render-layer sublayers muted.

See docs/adr/0002-render-layer.md for the design and rationale.

- RenderLayerManager: create/delete/rename/activate, membership, mute-based
  isolation. Sdf-level APIs are used while a layer is muted (Usd-level APIs
  can't see muted layers) and Usd-level APIs when active.
- Commands: create/delete/rename/activate and add/remove members, all undoable.
- RenderLayerPanel: layer list with one-click activation and a membership
  editor for the selected prims.
- StageEditorPanel / SceneHierarchyPanel: badge render-layer-owned sublayers,
  disable their mute/remove controls (they're managed from the Render Layer
  panel so the two can't desync), and lock the edit target while a non-Default
  layer is active.
- ConnectShaderAttrs/DisconnectShaderAttr: take an explicit editLayer captured
  at construction, so undo targets the same layer as execute even if the
  ambient edit target changed in between (e.g. a render-layer switch).

Note: SceneHierarchyPanel.h also carries declarations for the sublayers
section added in the following commit.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

docs/adr/0002-render-layer.md

@@ -0,0 +1,315 @@
+# ADR 0002 — Render Layer 面板（Maya 風格,建構於 USD Sublayer 架構之上）
+
+- **Status:** Proposed（尚未實作)
+- **Date:** 2026-07-12
+- **Component:** `src/core/RenderLayerManager`（新)、`src/ui/RenderLayerPanel`（新)、
+  `src/core/commands/RenderLayerCommands`（新)、
+  `src/core/commands/ConnectShaderAttrsCommand`、
+  `src/core/commands/DisconnectShaderAttrCommand`、`src/ui/MaterialEditorPanel`、
+  `src/core/UsdStageManager`、`src/ui/StageEditorPanel`、
+  `src/ui/SceneHierarchyPanel`、`src/ui/Application`
+- **Commit:** （尚未實作,無對應 commit)
+
+## Context
+
+使用者希望在本應用中加入一個「Render Layer」面板,行為比照 Maya 的
+Render Layers:使用者可以把場景中的燈光與可渲染物件加入某個具名圖層,
+該圖層記錄對這些物件的屬性調整——包含 shading 連線的修改——而不影響
+場景的基礎資料;切換目前作用中的圖層時,viewport 套用該圖層的所有覆寫,
+並且**只顯示該圖層的成員燈光與物件**;預設圖層(Default)則等同於目前
+未經任何 render layer 修改的 base stage。
+
+為了先弄清楚該怎麼設計,再動手實作,我們先派出三個平行的研究/探索
+subagent:一個研究 Maya Render Layers(含舊版 Render Layers 與後續的
+Render Setup)的實際資料模型與行為語意;一個深入探索本專案既有的
+layer/stage/command 架構(`LayerManager`、`UsdStageManager`、
+`CommandHistory`、既有的 command 範本、`PropertyManager`、
+`StageEditorPanel`);一個探索 viewport 可見度控制與既有的材質覆寫機制
+(`UsdSceneRenderer`/`UsdImagingGLEngine`、`SceneHierarchyPanel` 的
+眼睛圖示隱藏機制、`MaterialEditorPanel` 的材質綁定與 shader 連線
+command)。三份研究都完成後,再交由一個 Plan agent 讀取實際原始碼,
+驗證並修正整體設計——這個過程中抓到兩個既有程式碼裡的真實正確性問題
+(見下方 D3、D4)。本 ADR 記錄這輪研究與規劃後定案的設計決策。
+
+**與真實 Maya 行為的刻意偏離:** Maya 切換 render layer 預設**不會**
+自動 isolate viewport——那只是純粹的 render-time/override-time 概念,
+非成員物件只有在該圖層明確加了 visibility override 時才會被隱藏。
+但本專案的使用者明確要求「切換到圖層時,只顯示該圖層內的燈光與物件」,
+這是經與使用者確認過的刻意設計,而非誤解 Maya 行為。
+
+## Goals / Non-Goals
+
+**Goals:**
+- 非破壞性地記錄每個圖層的屬性覆寫(未來階段含 shading connection 與
+  material binding 覆寫),不修改場景的基礎資料。
+- 切換作用中圖層時,viewport 即時反映該圖層的所有覆寫。
+- 切換作用中圖層時,viewport 只顯示該圖層的成員燈光/物件(isolate)。
+- 正確的存檔/重新開檔 round-trip(圖層清單、成員資格、覆寫內容、目前
+  作用中的圖層都要能還原)。
+- 圖層切換與圖層內的編輯都要能正確 Undo/Redo。
+
+**Non-Goals(本階段,MVP 範圍之外,留待後續 Phase):**
+- Shading connection 覆寫的使用者介面(底層機制在 Phase 0 就會修正到
+  可正確運作,但本階段不在 Render Layer 面板上開放這個操作)。
+- Material binding(材質指派)覆寫的使用者介面。
+- 每圖層覆寫清單的檢視/還原(revert)UI,比照 Maya Render Setup 的
+  Property Editor 覆寫堆疊視圖。
+- 從 Scene Hierarchy 拖放物件到 Render Layer 面板做成員編輯(MVP 先用
+  「加入所選」按鈕取代)。
+
+這些項目會在後續 Phase(見 Consequences 與另一份實作計畫
+`misty-watching-stardust.md`)補齊,此處先列出以留紀錄,避免日後誤以為
+被遺漏。
+
+## Decision
+
+### D1 — 每個 Render Layer 對應一個獨立、檔案化的 `SdfLayer`
+
+**決策:** 每建立一個 render layer,就建立一個實體(檔案化,而非
+anonymous)的 `SdfLayer`,掛載為 stage root layer 的 sublayer,並以
+`SdfLayer::SetCustomLayerData` 標記
+(例如 `usdLayerManager:renderLayer = true`、
+`usdLayerManager:renderLayerName = "<名稱>"`),藉此與一般內容 sublayer
+區分。絕對不可放進 session layer。
+
+**理由:** `UsdStageManager::MergeSessionLayerIntoRoot()` 會在每次存檔
+時把 session layer 的內容攤平合併進 root layer、再清空 session
+layer——若 render layer 的資料放在 session layer,存檔當下就會被摧毀。
+另外,anonymous `SdfLayer` 的 identifier(`anon:0x...`)只在執行期有效,
+寫進 `subLayerPaths` 之後無法在 `SaveStageAs`/重新開檔時被正確解析,
+因此每個 render layer 必須是真正的檔案(沿用
+`LayerManager::CreateNewSublayer` 既有的「建立檔案 → 存檔 → 插入
+sublayer」流程)。
+
+---
+
+### D2 — Default 圖層是虛擬的,沒有對應的 `SdfLayer`
+
+**決策:** 「Default」不是一個真正的 render layer 物件,選取它只代表
+「把所有 render-layer sublayer 全部靜音(mute)」。
+
+**理由:** 這正好等同於今天應用程式既有的行為——沒有任何 render layer
+生效時,viewport 顯示的就是未經修改的 base stage。不需要為 Default
+另外設計一套資料結構或程式碼路徑。
+
+---
+
+### D3 — 成員資格以 `UsdCollectionAPI` 表示,並修正「非現用圖層無法讀寫」的問題
+
+**決策:** 每個 render layer 的成員資格,用 `UsdCollectionAPI`
+(instance name 固定為 `"members"`)表示,掛在該圖層自己 `SdfLayer`
+內部一個固定保留路徑(`/RenderLayerData`)的 `over`-only admin prim
+上。這個 prim 只有 `over`、沒有任何 `def`,所以是合法、可定址的
+`UsdPrim`,但 `IsDefined() == false`,不會出現在
+`UsdStage::Traverse()`、Scene Hierarchy 面板、或
+`PropertyManager::GetPrimPaths()` 的預設列舉結果中,不需要額外過濾。
+
+規劃過程中發現一個關鍵問題:由於同一時間只有一個 render layer 是
+「現用」(unmuted)的,其餘全部處於 muted 狀態,而
+`UsdStage::MuteLayer` 會讓該圖層**完全**退出 stage 的合成
+(composition)——也就是說,對一個目前被 mute 的圖層呼叫
+`stage->GetPrimAtPath("/RenderLayerData")` 會拿到一個**無效**的
+`UsdPrim`,`Usd` 層級的 `UsdCollectionAPI` 便完全無法讀寫該圖層的成員
+資料(例如使用者想在 Render Layer 面板編輯一個目前非現用圖層的成員
+清單時)。
+
+**修正做法:** 對於非現用圖層的成員資格讀寫,一律改走**Sdf 層級 API**,
+直接對該圖層的 `SdfLayerHandle` 操作(`SdfCreatePrimInLayer`
+建立/取得 `/RenderLayerData` 的 prim spec,再用 `SdfRelationshipSpec`
+操作 `collection:members:includes` 這個 relationship 的
+target path 清單)——這條路徑完全不經過 stage 合成,因此不受 mute
+狀態影響,而且寫入的 opinion 名稱與 `UsdCollectionAPI` 完全一致。
+只有在計算「目前現用圖層」的 isolate 用成員集合時,才使用一般
+`Usd` 層級 API(`UsdCollectionAPI::GetCollection` +
+`ComputeMembershipQuery` + `UsdComputeIncludedObjectsFromCollection`),
+因為此時該圖層必然已經是 unmuted 的。兩條路徑存取的是同一份
+authored opinion,只是兩種不同的入口,不是兩套 schema。
+
+---
+
+### D4 — 重用既有的 edit-target 機制做屬性覆寫,並修正三個既有的正確性缺陷
+
+**決策:** 切換作用中的 render layer 時,把 stage 的
+ambient edit target 指向該圖層的 `SdfLayer`(沿用
+`LayerManager::SetEditTarget`)。
+
+**理由與驗證:** 重新閱讀 `PropertyManager.cpp` 與 `TransformCommand`
+後確認,`PropertyManager::SetPropertyValue`(Property Panel 一般屬性
+編輯的路徑)與 `TransformCommand`(viewport 操作桿與 Property Panel
+的 Transform 編輯路徑)都是在編輯提交的當下,從 stage 目前的
+ambient edit target 解析要寫入哪個 `SdfLayer`。因此,只要把 ambient
+edit target 換成 render layer 的 `SdfLayer`,這兩條既有的寫入路徑
+**完全不需要修改任何程式碼**,就會自動把編輯正確記錄到對應的 render
+layer 裡。
+
+但在驗證過程中,發現另外三個既有的寫入路徑目前**沒有**捕捉/套用
+`UsdEditContext`,而是在 `Execute()`/`Undo()` 真正執行的當下才讀取
+ambient edit target:`ConnectShaderAttrsCommand`、
+`DisconnectShaderAttrCommand`、以及
+`MaterialEditorPanel::BindMaterialToTarget` 的材質綁定/解除綁定
+closure。具體會出錯的情境:使用者在 Render Layer A 生效時連接了一條
+shader 連線(此時正確寫入 A);接著切換到 Render Layer B(ambient
+edit target 也隨之換成 B);此時按下復原(Undo),`Undo()` 會在
+**B** 這個圖層上執行「移除連線」,而不是回到原本執行 `Execute()`
+時的 A——結果是 A 留下一條沒被正確復原的連線 opinion,B 卻多了一條
+不該存在的覆寫。這其實是既有程式碼中已經存在、但目前很少被觸發到的
+潛在 bug(任何在「連線」與「復原連線」之間發生 edit target 變更的
+情境都會中招),必須在導入 render layer 之前先修正,否則問題會被
+render layer 的切換行為放大成使用者能輕易踩到的日常錯誤。
+
+**修正做法:** 比照 `TransformCommand` 既有的寫法,為
+`ConnectShaderAttrsCommand`、`DisconnectShaderAttrCommand`
+新增一個建構參數 `SdfLayerHandle editLayer`,並在 `Execute()`/
+`Undo()` 內以 `UsdEditContext(m_stage, m_editLayer)`
+包裹實際的連線/解除連線呼叫;`MaterialEditorPanel` 在建立這些
+command 與綁定/解除綁定的 closure 時,一併在建構當下捕捉
+`stage->GetEditTarget().GetLayer()` 並傳入。這個修正不影響現有
+(尚無 render layer 時)的行為——沒有明確傳入圖層時,維持原本讀取
+ambient edit target 的行為不變。
+
+---
+
+### D5 — Viewport Isolate 採用「authored visibility opinion」,而非重建渲染引擎或整個 stage 的 population mask
+
+**決策:** 圖層啟用、或該圖層成員資格變動時,對場景做一次由上而下的
+遍歷:若某個子樹完全不含任何成員,就在該子樹**最上層**的 prim 上,
+用 `UsdGeomImageable`(與 Scene Hierarchy 面板既有的眼睛圖示隱藏
+機制完全相同的原語)authoring 一個 `visibility = invisible`,並且
+**停止往下遞迴**(子孫節點靠繼承取得隱藏效果);若子樹內含成員,則不
+寫入任何東西、繼續往下遞迴。規則上永遠不主動 authoring
+`visible`——只利用預設的「inherited」語意,避免蓋掉場景中原本就刻意
+隱藏的物件。所有自動寫入的路徑,記錄在該圖層自己的
+`customLayerData`(例如 `usdLayerManager:autoHiddenPaths`)中,
+以便下次重新計算前可以精準只清除這些自動產生的 opinion,不誤刪
+使用者手動authoring 的覆寫。
+
+**理由(排除的替代方案見下方 Alternatives Considered):**
+重新閱讀
+`third_party/OpenUSD-v25.05/include/pxr/usdImagingGL/engine.h`
+確認,`UsdImagingGLEngine::Parameters::invisedPaths`
+只能在**建構時**指定,整個類別沒有任何執行期可用的
+setter——每次切換圖層都重建 engine 的代價太高(會丟失 Hydra
+scene-index 狀態,以及 Arnold/Cycles/Embree 等漸進式渲染委派已累積
+的取樣結果,並造成 viewport 明顯的畫面閃爍)。而
+`UsdStage::SetPopulationMask()`/`SetLoadRules()`
+雖然可在執行期呼叫,但作用範圍是整個 stage 的合成,會連帶讓
+Scene Hierarchy 面板、Property Panel 的選取、viewport 的
+pick 都看不到/選不到非成員物件——這遠超出「只讓 viewport
+isolate」的需求,等於把物件從整個場景圖裡「拿掉」而非「隱藏」。
+以真正的 authored opinion 達成 isolate,則是可檢視、可除錯的
+USD 資料(能在 Stage Editor 等既有工具中直接看到),而且已經證實
+Hydra 能對這類編輯即時反應而不需要重建 engine(既有的 Property
+Panel 編輯、Scene Hierarchy 的眼睛圖示隱藏,都是同一套機制)。
+開銷與被隱藏的「子樹根節點」數量成正比,而非與場景總物件數成正比,
+對一般場景規模而言可忽略。
+
+---
+
+### D6 — 圖層切換本身也是一個可 Undo 的操作
+
+**決策:** 新增 `RenderLayerActivateCommand`,和其他編輯一樣推入
+`CommandHistory`。建構時就先記錄「切換前的 edit target」,以便
+Undo 或切回 Default 時正確還原。
+
+**理由:** 切換圖層會 authoring 真正的狀態(isolate 用的 visibility
+opinion、edit target 的變更),如果不納入 Undo 堆疊,使用者連續按
+Ctrl+Z 時會「跳過」圖層切換這一步,卻仍然復原了在該圖層內做的編輯,
+造成不一致、難以理解的復原歷史。此設計已與使用者確認。
+
+---
+
+### D7 — 圖層生效期間,鎖定既有的 edit-target 相關 UI
+
+**決策:** 當某個非 Default 的 render layer 是現用狀態時,停用
+Stage Editor 面板的 edit-target checkbox,以及 Scene Hierarchy
+面板的圖層下拉選單,並加上提示文字說明原因。
+
+**理由:** 這兩個既有的 UI 都是直接讀寫 stage 的 ambient edit
+target。如果放任使用者在 render layer 生效期間透過這些既有 UI
+把 edit target 改到別的地方,「編輯會正確落在目前作用中的 render
+layer」這個核心不變量就會被悄悄破壞,且沒有任何提示。鎖定雖然犧牲
+一些彈性,但能避免使用者在不知情的狀況下把覆寫寫錯地方。此設計已
+與使用者確認(相對於「保留可操作、只顯示警告」的替代方案)。
+
+---
+
+### D8 — 存檔與重新開檔的持久化
+
+**決策:** `UsdStageManager::SaveStage`/`SaveStageAs`
+除了既有的存檔呼叫之外,額外明確逐一存下**每一個** render-layer
+`SdfLayer`(不論目前是否被 mute)。哪個圖層目前是「現用」這件事,
+額外以 root layer 的 custom layer data 記錄
+(例如 `usdLayerManager:activeRenderLayer`),並在
+`Application::RefreshManagers()`/開啟 stage 時讀回,重新套用對應的
+`MuteLayer`/`UnmuteLayer` 與 `SetEditTarget`。
+
+**理由:** `UsdStage::Save()`
+只會走訪目前在合成(composition)中的 layer 存檔,而同一時間必然有
+N-1 個 render-layer sublayer 處於 muted、不在合成中的狀態——若不
+額外處理,這些圖層的編輯內容在存檔時會被靜默遺漏。另外,mute 狀態
+本身只是 `UsdStage` 的執行期旗標,並不會被序列化進任何檔案,因此
+「目前是哪個圖層生效」這件事也必須另外顯式持久化,否則重新開檔後
+會遺失,退回成 Default 生效的狀態。
+
+## Consequences
+
+**正面:**
+- 幾乎完全重用既有的 `SdfLayer`/`UsdEditContext`/`CommandHistory`/
+  `LayerManager` 機制,不需要引入新的渲染或合成機制,實作與既有
+  程式碼風格高度一致。
+- 每個圖層的覆寫都是真正、可檢視的 USD opinion,能在 Stage Editor
+  等既有工具中直接檢視、除錯,不是一個只存在於應用程式記憶體裡的
+  「影子」狀態。
+- Isolate 邏輯的開銷與「被隱藏的子樹根節點數」成正比,不隨場景總
+  物件數線性增加。
+- 圖層切換、圖層內編輯,都能正確納入既有的 Undo/Redo 體系,使用者
+  操作心智模型一致。
+
+**負面/取捨:**
+- 成員資格需要維護兩條存取路徑(現用圖層走 `Usd` 層級 API、非現用
+  圖層走 `Sdf` 層級 API),增加一些實作複雜度與日後維護成本。
+- 鎖定既有 edit-target UI 犧牲了一部分操作彈性。
+- 每個 render layer 都對應一個實體檔案(而非 anonymous layer),
+  會在專案目錄下產生額外的附屬檔案,需要一致的檔名/存放規則。
+- 本階段(MVP)尚未支援 shading connection、material binding 的
+  每圖層覆寫 UI,也還沒有覆寫清單的檢視/還原介面——這些留待後續
+  Phase,在此之前 Render Layer 面板的覆寫能力僅限一般屬性數值與
+  Transform。
+- `ConnectShaderAttrsCommand`/`DisconnectShaderAttrCommand`/
+  `BindMaterialToTarget` 的修正屬於既有程式碼的行為調整,雖然設計上
+  刻意保持向下相容(未傳入圖層時行為不變),仍需要在導入 render
+  layer 之前完成並個別驗證,不能與 render layer 本身的功能驗證
+  混在一起。
+
+## Alternatives Considered
+
+- **用 `UsdStage::SetPopulationMask()`/`SetLoadRules()` 做 isolate。**
+  否決:這兩者作用在整個 stage 的合成層級,會讓 Scene Hierarchy
+  面板、Property Panel 的選取與 viewport 的 pick 一併看不到/選不到
+  非成員物件,遠超出「只讓 viewport isolate」的實際需求。
+- **用 `UsdImagingGLEngine` 建構期的 `invisedPaths`,每次切換圖層就
+  重建 engine。** 否決:代價過高——會丟失 Hydra scene-index 狀態,
+  以及漸進式渲染委派(Arnold/Cycles/Embree)已累積的取樣結果,並造成
+  viewport 明顯閃爍,不適合互動式的頻繁圖層切換。
+- **用 anonymous `SdfLayer` 存放每個 render layer 的資料。**
+  否決:anonymous layer 的 identifier 只在執行期有效,寫進
+  `subLayerPaths` 後,在 `SaveStageAs`/重新開檔時無法被正確解析,
+  資料會在存檔/重載之間遺失。
+- **用 `UsdVariantSet` 表示 render layer 之間互斥的選擇。**
+  否決:Maya 的 collection + override 模型本質上更接近可疊加、
+  可獨立排序的 sublayer/override 合成,而非彼此互斥、一次只能選一
+  個的 variant 切換,語意上不夠貼合(尤其考慮到未來允許同一物件
+  同時屬於多個圖層的情境)。
+
+## Verification
+
+本 ADR 記錄的是**實作前**的設計決策——目前尚未進行任何程式碼變更,
+因此本節暫不回報建置或手動驗證結果。待對應的實作計畫
+(`misty-watching-stardust.md` 中記錄的 Phase 0/Phase 1 MVP)實際
+執行完成後,應在本節或另外新增一則後續紀錄中,補上實際的建置結果與
+手動驗證步驟/結果(圖層建立與切換、viewport isolate 是否正確、
+屬性覆寫是否正確落在對應圖層且不外洩到其他圖層、存檔重新開檔的
+round-trip、跨圖層切換的 Undo/Redo 行為),寫法比照
+`0001-viewport-color-correction.md` 文末的「Supersession Note」
+——以追加的方式記錄後續進展或設計變動,而非直接覆寫、抹除本次
+決策當下的紀錄。

src/core/RenderLayerManager.cpp

@@ -0,0 +1,456 @@
+#include "RenderLayerManager.h"
+#include "LayerManager.h"
+#include "../utils/Logger.h"
+
+#include <pxr/usd/usd/editContext.h>
+#include <pxr/usd/usd/editTarget.h>
+#include <pxr/usd/usd/prim.h>
+#include <pxr/usd/sdf/primSpec.h>
+#include <pxr/usd/sdf/relationshipSpec.h>
+#include <pxr/usd/sdf/proxyTypes.h>
+#include <pxr/usd/usdGeom/imageable.h>
+#include <pxr/usd/usdGeom/tokens.h>
+#include <pxr/base/vt/dictionary.h>
+#include <pxr/base/vt/array.h>
+#include <pxr/base/tf/token.h>
+
+#include <algorithm>
+#include <cctype>
+#include <filesystem>
+#include <functional>
+#include <set>
+
+PXR_NAMESPACE_USING_DIRECTIVE
+
+namespace UsdLayerManager {
+
+namespace {
+// Reserved, undefined ("over"-only) admin prim path each render layer's own
+// SdfLayer carries its membership relationship on. Never a `def`, so it never
+// shows up in UsdStage::Traverse() / the Scene Hierarchy panel / GetChildren().
+const SdfPath kAdminPrimPath("/RenderLayerData");
+const TfToken kMembersIncludesName("collection:members:includes");
+
+// SdfLayer custom-layer-data keys.
+const std::string kMarkerKey       = "usdLayerManager:renderLayer";
+const std::string kNameKey         = "usdLayerManager:renderLayerName";
+const std::string kAutoHiddenKey   = "usdLayerManager:autoHiddenPaths";
+// Root-layer-only key: persists which render layer was active across save/reload.
+const std::string kActiveLayerKey  = "usdLayerManager:activeRenderLayer";
+
+std::string SanitizeFileStem(const std::string& raw) {
+    std::string result;
+    result.reserve(raw.size());
+    for (char c : raw) {
+        if (std::isalnum(static_cast<unsigned char>(c)) || c == '_' || c == '-')
+            result += c;
+        else
+            result += '_';
+    }
+    return result;
+}
+
+SdfPath MembersIncludesPath() {
+    return kAdminPrimPath.AppendProperty(kMembersIncludesName);
+}
+} // namespace
+
+RenderLayerManager::RenderLayerManager() {}
+RenderLayerManager::~RenderLayerManager() {}
+
+void RenderLayerManager::SetStage(UsdStageRefPtr stage) {
+    m_stage = stage;
+    Refresh();
+}
+
+void RenderLayerManager::Refresh() {
+    BuildList();
+}
+
+void RenderLayerManager::BuildList() {
+    m_layers.clear();
+    m_layerRefs.clear();
+
+    RenderLayerInfo def;
+    def.name      = "Default";
+    def.isDefault = true;
+    m_layers.push_back(def);
+
+    if (!m_stage) return;
+    SdfLayerHandle rootLayer = m_stage->GetRootLayer();
+    if (!rootLayer) return;
+
+    bool anyActive = false;
+    for (const auto& subPath : rootLayer->GetSubLayerPaths()) {
+        SdfLayerRefPtr sub = SdfLayer::FindOrOpenRelativeToLayer(rootLayer, subPath);
+        if (!sub) continue;
+
+        VtDictionary cld = sub->GetCustomLayerData();
+        auto markerIt = cld.find(kMarkerKey);
+        if (markerIt == cld.end() || !markerIt->second.IsHolding<bool>() ||
+            !markerIt->second.Get<bool>())
+            continue; // not a render layer sublayer — leave for LayerManager/StageEditorPanel
+
+        m_layerRefs.push_back(sub);
+
+        RenderLayerInfo info;
+        info.layer           = SdfLayerHandle(sub);
+        info.layerIdentifier = sub->GetIdentifier();
+        auto nameIt = cld.find(kNameKey);
+        info.name = (nameIt != cld.end() && nameIt->second.IsHolding<std::string>())
+            ? nameIt->second.Get<std::string>()
+            : LayerManager::ExtractDisplayName(info.layerIdentifier);
+        info.isActive = !m_stage->IsLayerMuted(info.layerIdentifier);
+        if (info.isActive) anyActive = true;
+
+        m_layers.push_back(info);
+    }
+
+    m_layers[0].isActive = !anyActive;
+}
+
+/*static*/ bool RenderLayerManager::IsRenderLayerSublayer(const SdfLayerHandle& layer) {
+    if (!layer) return false;
+    VtDictionary cld = layer->GetCustomLayerData();
+    auto it = cld.find(kMarkerKey);
+    return it != cld.end() && it->second.IsHolding<bool>() && it->second.Get<bool>();
+}
+
+void RenderLayerManager::RefreshLayerManager() {
+    if (m_layerManager) m_layerManager->Refresh();
+}
+
+SdfLayerHandle RenderLayerManager::FindRenderLayer(const std::string& layerId) const {
+    for (const auto& info : m_layers)
+        if (!info.isDefault && info.layerIdentifier == layerId)
+            return info.layer;
+    return SdfLayerHandle();
+}
+
+// ---------------------------------------------------------------------------
+// CRUD
+// ---------------------------------------------------------------------------
+
+std::string RenderLayerManager::CreateRenderLayer(const std::string& name) {
+    if (!m_stage) return {};
+    SdfLayerHandle rootLayer = m_stage->GetRootLayer();
+    if (!rootLayer) return {};
+
+    namespace fs = std::filesystem;
+    fs::path baseDir;
+    std::string realPath = rootLayer->GetRealPath();
+    baseDir = !realPath.empty()
+        ? fs::path(realPath).parent_path() / ".renderlayers"
+        : fs::current_path() / ".renderlayers";
+    std::error_code ec;
+    fs::create_directories(baseDir, ec);
+
+    std::string stem = SanitizeFileStem(name.empty() ? "RenderLayer" : name);
+    if (stem.empty()) stem = "RenderLayer";
+    std::string finalStem = stem;
+    fs::path filePath = baseDir / (finalStem + ".usda");
+    int suffix = 1;
+    while (fs::exists(filePath)) {
+        finalStem = stem + "_" + std::to_string(suffix++);
+        filePath  = baseDir / (finalStem + ".usda");
+    }
+
+    SdfLayerRefPtr newLayer = SdfLayer::CreateNew(filePath.string());
+    if (!newLayer) {
+        LOG_ERROR("RenderLayerManager: failed to create layer file: " + filePath.string());
+        return {};
+    }
+
+    VtDictionary cld;
+    cld[kMarkerKey] = VtValue(true);
+    cld[kNameKey]   = VtValue(name.empty() ? finalStem : name);
+    newLayer->SetCustomLayerData(cld);
+
+    SdfPrimSpecHandle adminPrim = SdfCreatePrimInLayer(newLayer, kAdminPrimPath);
+    if (adminPrim)
+        SdfRelationshipSpec::New(adminPrim, kMembersIncludesName.GetString(),
+                                 /*custom=*/false, SdfVariabilityUniform);
+
+    newLayer->Save();
+
+    rootLayer->InsertSubLayerPath(filePath.string(), 0);
+    m_stage->MuteLayer(filePath.string()); // starts inactive until explicitly activated
+
+    Refresh();
+    RefreshLayerManager();
+    return newLayer->GetIdentifier();
+}
+
+bool RenderLayerManager::DeleteRenderLayer(const std::string& layerId) {
+    if (!m_stage) return false;
+    SdfLayerHandle rootLayer = m_stage->GetRootLayer();
+    if (!rootLayer) return false;
+    if (!FindRenderLayer(layerId)) return false;
+
+    if (GetActiveRenderLayerId() == layerId)
+        ActivateDefaultLayer();
+
+    SdfSubLayerProxy subPaths = rootLayer->GetSubLayerPaths();
+    for (size_t i = 0; i < subPaths.size(); ++i) {
+        SdfLayerRefPtr sub = SdfLayer::FindOrOpenRelativeToLayer(rootLayer, subPaths[i]);
+        if (sub && sub->GetIdentifier() == layerId) {
+            subPaths.erase(subPaths.begin() + static_cast<long>(i));
+            Refresh();
+            RefreshLayerManager();
+            return true;
+        }
+    }
+    return false;
+}
+
+bool RenderLayerManager::RestoreDeletedRenderLayer(const std::string& layerIdentifier) {
+    if (!m_stage) return false;
+    SdfLayerHandle rootLayer = m_stage->GetRootLayer();
+    if (!rootLayer) return false;
+    rootLayer->InsertSubLayerPath(layerIdentifier, 0);
+    Refresh();
+    RefreshLayerManager();
+    return true;
+}
+
+bool RenderLayerManager::RenameRenderLayer(const std::string& layerId, const std::string& newName) {
+    SdfLayerHandle layer = FindRenderLayer(layerId);
+    if (!layer || newName.empty()) return false;
+    VtDictionary cld = layer->GetCustomLayerData();
+    cld[kNameKey] = VtValue(newName);
+    layer->SetCustomLayerData(cld);
+    Refresh();
+    RefreshLayerManager();
+    return true;
+}
+
+// ---------------------------------------------------------------------------
+// Switching
+// ---------------------------------------------------------------------------
+
+bool RenderLayerManager::ActivateRenderLayer(const std::string& layerId) {
+    if (!m_stage) return false;
+    SdfLayerHandle target = FindRenderLayer(layerId);
+    if (!target) return false;
+
+    // First entry into render-layer mode this "session" (Default -> a render
+    // layer): remember the edit target so ActivateDefaultLayer() can restore
+    // it later, no matter how many render-layer-to-render-layer switches
+    // happen in between.
+    if (IsDefaultActive()) {
+        SdfLayerHandle currentEt = m_stage->GetEditTarget().GetLayer();
+        m_savedEditTargetIdBeforeMode = currentEt ? currentEt->GetIdentifier() : std::string();
+    }
+
+    for (const auto& info : m_layers) {
+        if (info.isDefault || info.layerIdentifier == layerId) continue;
+        if (!m_stage->IsLayerMuted(info.layerIdentifier))
+            m_stage->MuteLayer(info.layerIdentifier);
+    }
+    if (m_stage->IsLayerMuted(layerId))
+        m_stage->UnmuteLayer(layerId);
+
+    if (m_layerManager) m_layerManager->SetEditTarget(layerId);
+    else                 m_stage->SetEditTarget(UsdEditTarget(target));
+
+    RecomputeIsolation(target, layerId);
+    PersistActiveLayerId(layerId);
+    Refresh();
+    RefreshLayerManager();
+    return true;
+}
+
+void RenderLayerManager::ActivateDefaultLayer() {
+    if (!m_stage) return;
+    for (const auto& info : m_layers) {
+        if (info.isDefault) continue;
+        if (!m_stage->IsLayerMuted(info.layerIdentifier))
+            m_stage->MuteLayer(info.layerIdentifier);
+    }
+
+    if (!m_savedEditTargetIdBeforeMode.empty()) {
+        if (m_layerManager) {
+            m_layerManager->SetEditTarget(m_savedEditTargetIdBeforeMode);
+        } else if (SdfLayerHandle saved = SdfLayer::Find(m_savedEditTargetIdBeforeMode)) {
+            m_stage->SetEditTarget(UsdEditTarget(saved));
+        }
+    }
+    m_savedEditTargetIdBeforeMode.clear();
+
+    PersistActiveLayerId("");
+    Refresh();
+    RefreshLayerManager();
+}
+
+std::string RenderLayerManager::GetActiveRenderLayerId() const {
+    for (const auto& info : m_layers)
+        if (!info.isDefault && info.isActive)
+            return info.layerIdentifier;
+    return {};
+}
+
+void RenderLayerManager::PersistActiveLayerId(const std::string& layerId) {
+    if (!m_stage) return;
+    SdfLayerHandle rootLayer = m_stage->GetRootLayer();
+    if (!rootLayer) return;
+    VtDictionary cld = rootLayer->GetCustomLayerData();
+    if (layerId.empty()) cld.erase(kActiveLayerKey);
+    else                 cld[kActiveLayerKey] = VtValue(layerId);
+    rootLayer->SetCustomLayerData(cld);
+}
+
+void RenderLayerManager::RestorePersistedActiveLayer() {
+    if (!m_stage) return;
+    SdfLayerHandle rootLayer = m_stage->GetRootLayer();
+    if (!rootLayer) return;
+    VtDictionary cld = rootLayer->GetCustomLayerData();
+    auto it = cld.find(kActiveLayerKey);
+    if (it == cld.end() || !it->second.IsHolding<std::string>()) return;
+    std::string layerId = it->second.Get<std::string>();
+    if (FindRenderLayer(layerId))
+        ActivateRenderLayer(layerId);
+}
+
+// ---------------------------------------------------------------------------
+// Membership (Sdf-level — works regardless of mute state)
+// ---------------------------------------------------------------------------
+
+std::vector<SdfPath> RenderLayerManager::GetMembers(const std::string& layerId) const {
+    std::vector<SdfPath> result;
+    SdfLayerHandle layer = FindRenderLayer(layerId);
+    if (!layer) return result;
+    SdfRelationshipSpecHandle rel = layer->GetRelationshipAtPath(MembersIncludesPath());
+    if (!rel) return result;
+    for (const SdfPath& p : rel->GetTargetPathList().GetAddedOrExplicitItems())
+        result.push_back(p);
+    return result;
+}
+
+bool RenderLayerManager::AddMember(const std::string& layerId, const SdfPath& path) {
+    SdfLayerHandle layer = FindRenderLayer(layerId);
+    if (!layer) return false;
+
+    SdfRelationshipSpecHandle rel = layer->GetRelationshipAtPath(MembersIncludesPath());
+    if (!rel) {
+        SdfPrimSpecHandle adminPrim = SdfCreatePrimInLayer(layer, kAdminPrimPath);
+        if (!adminPrim) return false;
+        rel = SdfRelationshipSpec::New(adminPrim, kMembersIncludesName.GetString(),
+                                       /*custom=*/false, SdfVariabilityUniform);
+    }
+    if (!rel) return false;
+
+    // Add() doesn't de-duplicate against existing explicit items — guard
+    // here so repeated adds of the same path (e.g. re-running a command, or
+    // a redundant drag) don't pile up duplicate targets.
+    auto existing = rel->GetTargetPathList().GetAddedOrExplicitItems();
+    if (std::find(existing.begin(), existing.end(), path) == existing.end())
+        rel->GetTargetPathList().Add(path);
+
+    if (GetActiveRenderLayerId() == layerId)
+        RecomputeIsolation(layer, layerId);
+    RefreshLayerManager(); // keeps StageEditorPanel's dirty-flag asterisk current
+    return true;
+}
+
+bool RenderLayerManager::RemoveMember(const std::string& layerId, const SdfPath& path) {
+    SdfLayerHandle layer = FindRenderLayer(layerId);
+    if (!layer) return false;
+    SdfRelationshipSpecHandle rel = layer->GetRelationshipAtPath(MembersIncludesPath());
+    if (!rel) return false;
+
+    rel->GetTargetPathList().Remove(path);
+
+    if (GetActiveRenderLayerId() == layerId)
+        RecomputeIsolation(layer, layerId);
+    RefreshLayerManager();
+    return true;
+}
+
+// ---------------------------------------------------------------------------
+// Viewport isolation
+// ---------------------------------------------------------------------------
+
+void RenderLayerManager::ClearAutoHiddenPaths(const SdfLayerHandle& layer) {
+    if (!layer) return;
+    VtDictionary cld = layer->GetCustomLayerData();
+    auto it = cld.find(kAutoHiddenKey);
+    if (it == cld.end()) return;
+
+    if (it->second.IsHolding<VtArray<std::string>>()) {
+        for (const std::string& p : it->second.Get<VtArray<std::string>>()) {
+            SdfPath primPath(p);
+            SdfPrimSpecHandle owner = layer->GetPrimAtPath(primPath);
+            SdfAttributeSpecHandle attrSpec =
+                layer->GetAttributeAtPath(primPath.AppendProperty(TfToken("visibility")));
+            if (owner && attrSpec)
+                owner->RemoveProperty(attrSpec);
+        }
+    }
+    cld.erase(it);
+    layer->SetCustomLayerData(cld);
+}
+
+void RenderLayerManager::RecomputeIsolation(const SdfLayerHandle& layer, const std::string& layerId) {
+    if (!m_stage || !layer) return;
+
+    ClearAutoHiddenPaths(layer);
+
+    std::vector<SdfPath> memberList = GetMembers(layerId);
+    std::set<SdfPath> members(memberList.begin(), memberList.end());
+
+    // Every strict prefix of every member path: a subtree rooted at one of
+    // these paths might still contain a member somewhere below it, so it
+    // must be recursed into rather than hidden outright.
+    std::set<SdfPath> ancestors;
+    for (const SdfPath& m : memberList) {
+        SdfPath p = m.GetParentPath();
+        while (!p.IsEmpty()) {
+            if (!ancestors.insert(p).second) break; // already inserted by another member
+            if (p == SdfPath::AbsoluteRootPath()) break;
+            p = p.GetParentPath();
+        }
+    }
+
+    std::vector<std::string> newHidden;
+
+    std::function<void(const UsdPrim&)> visit = [&](const UsdPrim& prim) {
+        for (const UsdPrim& child : prim.GetChildren()) {
+            SdfPath cp = child.GetPath();
+            if (cp == kAdminPrimPath) continue;
+
+            if (members.count(cp)) {
+                // Exact member: whole subtree stays default-visible (expandPrims
+                // semantics — everything under a member is implicitly included),
+                // nothing to author, no need to recurse.
+                continue;
+            }
+            if (ancestors.count(cp)) {
+                visit(child); // a member lies somewhere below — keep exploring
+                continue;
+            }
+
+            UsdGeomImageable img(child);
+            if (img) {
+                UsdEditContext ec(m_stage, layer);
+                img.GetVisibilityAttr().Set(UsdGeomTokens->invisible);
+                newHidden.push_back(cp.GetString());
+                // Minimal cut: stop here, children inherit the hidden state.
+            } else {
+                // Can't author visibility on a non-imageable prim (e.g. a pure
+                // Scope holding unrelated data) — look deeper for an imageable
+                // descendant to hide instead, rather than silently failing to
+                // isolate this whole branch.
+                visit(child);
+            }
+        }
+    };
+    visit(m_stage->GetPseudoRoot());
+
+    if (!newHidden.empty()) {
+        VtDictionary cld = layer->GetCustomLayerData();
+        cld[kAutoHiddenKey] = VtValue(VtArray<std::string>(newHidden.begin(), newHidden.end()));
+        layer->SetCustomLayerData(cld);
+    }
+}
+
+} // namespace UsdLayerManager

src/core/RenderLayerManager.h

@@ -0,0 +1,135 @@
+#pragma once
+
+#include <pxr/usd/usd/stage.h>
+#include <pxr/usd/sdf/layer.h>
+#include <pxr/usd/sdf/path.h>
+#include <string>
+#include <vector>
+
+namespace UsdLayerManager {
+
+class LayerManager;
+
+/// One row for the Render Layer panel. The "Default" entry (isDefault=true)
+/// has no backing layer — it represents the unmodified base stage, i.e. every
+/// render-layer sublayer muted.
+struct RenderLayerInfo {
+    std::string          name;
+    pxr::SdfLayerHandle  layer;            ///< empty for Default
+    std::string          layerIdentifier;  ///< empty for Default; the stable key used everywhere below
+    bool                 isActive  = false;
+    bool                 isDefault = false;
+};
+
+/// Maya-Render-Layers-style layers built on the stage's own sublayer stack.
+///
+/// Each render layer is a dedicated, file-backed SdfLayer inserted as a
+/// sublayer of the stage's root layer (tagged via SdfLayer custom layer data
+/// so it's distinguishable from ordinary content sublayers). At most one is
+/// ever unmuted ("active") at a time; activating one mutes the rest and
+/// repoints the stage's ambient edit target at it, so every existing
+/// attribute/transform/shader-connection/material-binding command in the app
+/// already lands its edits in the right place with no changes of its own
+/// (see docs/adr/0002-render-layer.md).
+///
+/// Membership (which lights/objects belong to a layer) is stored as a
+/// UsdCollectionAPI-compatible relationship (`collection:members:includes`)
+/// on a reserved, undefined ("over"-only, never rendered) admin prim inside
+/// that layer's own SdfLayer. All reads/writes of it go through raw Sdf-level
+/// API rather than UsdCollectionAPI/UsdStage, because muted layers are fully
+/// excluded from stage composition — GetPrimAtPath would fail for every
+/// layer except the currently-active one, and the panel needs to edit
+/// membership on layers that aren't active.
+///
+/// Switching layers also isolates the viewport to that layer's members: a
+/// single top-down traversal authors the minimal set of
+/// `visibility = invisible` opinions (into the active layer's own SdfLayer)
+/// needed to hide every subtree that contains no member, tracked via that
+/// layer's custom layer data so it can be precisely cleared and recomputed
+/// without disturbing deliberate visibility overrides.
+class RenderLayerManager {
+public:
+    RenderLayerManager();
+    ~RenderLayerManager();
+
+    void SetStage(pxr::UsdStageRefPtr stage);
+    void SetLayerManager(LayerManager* mgr) { m_layerManager = mgr; }
+    void Refresh();
+
+    /// Default first, then user-created render layers in sublayer order.
+    std::vector<RenderLayerInfo> GetRenderLayers() const { return m_layers; }
+
+    /// Creates a new file-backed render layer next to the stage's root layer
+    /// (under a ".renderlayers" subdirectory), muted, with an empty member
+    /// list. Returns the new layer's identifier, or empty on failure.
+    std::string CreateRenderLayer(const std::string& name);
+    bool DeleteRenderLayer(const std::string& layerId);
+    /// Re-inserts a render layer previously removed by DeleteRenderLayer — its
+    /// backing file is left on disk untouched by DeleteRenderLayer, so this
+    /// just restores the sublayer reference (always at the top of the stack,
+    /// same as a newly-created layer). Used by RenderLayerDeleteCommand::Undo().
+    bool RestoreDeletedRenderLayer(const std::string& layerIdentifier);
+    bool RenameRenderLayer(const std::string& layerId, const std::string& newName);
+
+    /// Mutes every other render-layer sublayer, unmutes layerId, repoints the
+    /// stage's ambient edit target at it, and recomputes viewport isolation.
+    /// The first time this is called while Default is active, it remembers
+    /// the current edit target so ActivateDefaultLayer() can restore it later
+    /// — callers (e.g. an undoable switch command) don't need to manage that
+    /// themselves; it's tracked here so it stays correct across Undo/Redo.
+    bool ActivateRenderLayer(const std::string& layerId);
+    /// Mutes every render-layer sublayer (back to the unmodified base stage)
+    /// and restores whatever the edit target was before render-layer mode
+    /// was first entered (see ActivateRenderLayer's note).
+    void ActivateDefaultLayer();
+    std::string GetActiveRenderLayerId() const;
+    bool IsDefaultActive() const { return GetActiveRenderLayerId().empty(); }
+
+    /// Sdf-level: the raw, unexpanded `includes` target list. Works
+    /// regardless of whether layerId is currently muted.
+    std::vector<pxr::SdfPath> GetMembers(const std::string& layerId) const;
+    bool AddMember(const std::string& layerId, const pxr::SdfPath& path);
+    bool RemoveMember(const std::string& layerId, const pxr::SdfPath& path);
+
+    /// Re-applies whichever render layer was active the last time this stage
+    /// was saved (persisted as root-layer custom layer data, since USD mute
+    /// state itself is a runtime flag and isn't serialized). Call once after
+    /// SetStage(). No-op if nothing was persisted, or the persisted layer no
+    /// longer exists.
+    void RestorePersistedActiveLayer();
+
+    /// True if this layer carries the "this sublayer is a render layer"
+    /// marker RenderLayerManager itself authors on creation. Exposed so
+    /// other panels (e.g. StageEditorPanel) that walk the raw sublayer list
+    /// can recognize and guard-rail render-layer sublayers without
+    /// duplicating the custom-layer-data key.
+    static bool IsRenderLayerSublayer(const pxr::SdfLayerHandle& layer);
+
+private:
+    void BuildList();
+    // LayerManager keeps its own cached sublayer/mute-state snapshot,
+    // rebuilt only on its own SetStage()/Refresh()/mutator calls — it has no
+    // way to know when RenderLayerManager mutates the root layer's sublayer
+    // stack or a layer's mute state directly (bypassing LayerManager's own
+    // methods, which every RenderLayerManager mutator below does). Called
+    // after every such mutation so StageEditorPanel (backed by LayerManager)
+    // doesn't show a stale sublayer list.
+    void RefreshLayerManager();
+    pxr::SdfLayerHandle FindRenderLayer(const std::string& layerId) const;
+    void RecomputeIsolation(const pxr::SdfLayerHandle& layer, const std::string& layerId);
+    void ClearAutoHiddenPaths(const pxr::SdfLayerHandle& layer);
+    void PersistActiveLayerId(const std::string& layerId);
+
+    pxr::UsdStageRefPtr m_stage;
+    LayerManager*        m_layerManager = nullptr;
+    std::vector<RenderLayerInfo> m_layers; // [0] is always the Default entry
+    // Strong refs so muted render-layer SdfLayers stay alive between
+    // Refresh() calls (mirrors LayerManager::m_layerRefs).
+    std::vector<pxr::SdfLayerRefPtr> m_layerRefs;
+    // Edit target identifier captured the moment render-layer mode is first
+    // entered (Default -> any render layer); restored and cleared by
+    // ActivateDefaultLayer(). Empty when not currently "in mode".
+    std::string m_savedEditTargetIdBeforeMode;
+};
+
+} // namespace UsdLayerManager

src/core/commands/ConnectShaderAttrsCommand.cpp

@@ -1,5 +1,6 @@
 #include "ConnectShaderAttrsCommand.h"
 #include "../../utils/Logger.h"
+#include <pxr/usd/usd/editContext.h>
 #include <pxr/usd/usdShade/shader.h>
 #include <pxr/usd/usdShade/connectableAPI.h>
 #include <pxr/base/tf/token.h>
@@ -12,7 +13,8 @@ ConnectShaderAttrsCommand::ConnectShaderAttrsCommand(pxr::UsdStageRefPtr stage,
                                                      const pxr::SdfValueTypeName& destType,
                                                      const pxr::SdfPath&  sourceNode,
                                                      const std::string&   sourceOutput,
-                                                     const pxr::SdfValueTypeName& sourceType)
+                                                     const pxr::SdfValueTypeName& sourceType,
+                                                     pxr::SdfLayerHandle  editLayer)
     : m_stage(stage)
     , m_destNode(destNode)
     , m_destInput(destInput)
@@ -20,6 +22,7 @@ ConnectShaderAttrsCommand::ConnectShaderAttrsCommand(pxr::UsdStageRefPtr stage,
     , m_sourceNode(sourceNode)
     , m_sourceOutput(sourceOutput)
     , m_sourceType(sourceType)
+    , m_editLayer(editLayer)
     , m_description("Connect " + sourceNode.GetName() + "." + sourceOutput +
                     " -> " + destNode.GetName() + "." + destInput)
 {
@@ -50,9 +53,16 @@ void ConnectShaderAttrsCommand::Execute() {
             return;
         }
 
-        pxr::UsdShadeInput destInput = destShader.CreateInput(pxr::TfToken(m_destInput), m_destType);
+        if (m_editLayer) {
-        pxr::UsdShadeOutput sourceOutput = sourceShader.CreateOutput(pxr::TfToken(m_sourceOutput), m_sourceType);
+            pxr::UsdEditContext ec(m_stage, m_editLayer);
-        pxr::UsdShadeConnectableAPI::ConnectToSource(destInput, sourceOutput);
+            pxr::UsdShadeInput destInput = destShader.CreateInput(pxr::TfToken(m_destInput), m_destType);
+            pxr::UsdShadeOutput sourceOutput = sourceShader.CreateOutput(pxr::TfToken(m_sourceOutput), m_sourceType);
+            pxr::UsdShadeConnectableAPI::ConnectToSource(destInput, sourceOutput);
+        } else {
+            pxr::UsdShadeInput destInput = destShader.CreateInput(pxr::TfToken(m_destInput), m_destType);
+            pxr::UsdShadeOutput sourceOutput = sourceShader.CreateOutput(pxr::TfToken(m_sourceOutput), m_sourceType);
+            pxr::UsdShadeConnectableAPI::ConnectToSource(destInput, sourceOutput);
+        }
     } catch (const std::exception& e) {
         LOG_ERROR(std::string("ConnectShaderAttrsCommand::Execute error: ") + e.what());
     }
@@ -66,13 +76,22 @@ void ConnectShaderAttrsCommand::Undo() {
         pxr::UsdShadeInput destInput = destShader.GetInput(pxr::TfToken(m_destInput));
         if (!destInput) return;
 
-        if (m_hadPriorConnection) {
+        auto doUndo = [&]() {
-            pxr::UsdShadeShader priorSourceShader(m_stage->GetPrimAtPath(m_priorSourceNode));
+            if (m_hadPriorConnection) {
-            pxr::UsdShadeOutput priorSourceOutput = priorSourceShader.GetOutput(pxr::TfToken(m_priorSourceOutput));
+                pxr::UsdShadeShader priorSourceShader(m_stage->GetPrimAtPath(m_priorSourceNode));
-            if (priorSourceShader && priorSourceOutput)
+                pxr::UsdShadeOutput priorSourceOutput = priorSourceShader.GetOutput(pxr::TfToken(m_priorSourceOutput));
-                pxr::UsdShadeConnectableAPI::ConnectToSource(destInput, priorSourceOutput);
+                if (priorSourceShader && priorSourceOutput)
+                    pxr::UsdShadeConnectableAPI::ConnectToSource(destInput, priorSourceOutput);
+            } else {
+                pxr::UsdShadeConnectableAPI::DisconnectSource(destInput);
+            }
+        };
+
+        if (m_editLayer) {
+            pxr::UsdEditContext ec(m_stage, m_editLayer);
+            doUndo();
         } else {
-            pxr::UsdShadeConnectableAPI::DisconnectSource(destInput);
+            doUndo();
         }
     } catch (const std::exception& e) {
         LOG_ERROR(std::string("ConnectShaderAttrsCommand::Undo error: ") + e.what());

src/core/commands/ConnectShaderAttrsCommand.h

@@ -4,6 +4,7 @@
 #include <pxr/usd/usd/stage.h>
 #include <pxr/usd/sdf/path.h>
 #include <pxr/usd/sdf/valueTypeName.h>
+#include <pxr/usd/sdf/layer.h>
 #include <string>
 
 namespace UsdLayerManager {
@@ -14,13 +15,19 @@ namespace UsdLayerManager {
 /// Undo can restore it exactly rather than merely disconnecting.
 class ConnectShaderAttrsCommand : public ICommand {
 public:
+    /// editLayer: layer to author into (mirrors TransformCommand's pattern).
+    /// Captured at construction time so Undo() targets the same layer as
+    /// Execute() even if the stage's ambient edit target changes in between
+    /// (e.g. a render-layer switch) — pass null/empty to fall back to
+    /// whatever the ambient edit target is at call time (today's behavior).
     ConnectShaderAttrsCommand(pxr::UsdStageRefPtr stage,
                               const pxr::SdfPath&  destNode,
                               const std::string&   destInput,
                               const pxr::SdfValueTypeName& destType,
                               const pxr::SdfPath&  sourceNode,
                               const std::string&   sourceOutput,
-                              const pxr::SdfValueTypeName& sourceType);
+                              const pxr::SdfValueTypeName& sourceType,
+                              pxr::SdfLayerHandle  editLayer = pxr::SdfLayerHandle());
 
     void Execute() override;
     void Undo()    override;
@@ -34,6 +41,7 @@ private:
     pxr::SdfPath          m_sourceNode;
     std::string           m_sourceOutput;
     pxr::SdfValueTypeName m_sourceType;
+    pxr::SdfLayerHandle   m_editLayer;
     std::string           m_description;
 
     bool        m_hadPriorConnection = false;

src/core/commands/DisconnectShaderAttrCommand.cpp

@@ -1,5 +1,6 @@
 #include "DisconnectShaderAttrCommand.h"
 #include "../../utils/Logger.h"
+#include <pxr/usd/usd/editContext.h>
 #include <pxr/usd/usdShade/shader.h>
 #include <pxr/usd/usdShade/connectableAPI.h>
 #include <pxr/base/tf/token.h>
@@ -8,10 +9,12 @@ namespace UsdLayerManager {
 
 DisconnectShaderAttrCommand::DisconnectShaderAttrCommand(pxr::UsdStageRefPtr stage,
                                                          const pxr::SdfPath&  destNode,
-                                                         const std::string&   destInput)
+                                                         const std::string&   destInput,
+                                                         pxr::SdfLayerHandle  editLayer)
     : m_stage(stage)
     , m_destNode(destNode)
     , m_destInput(destInput)
+    , m_editLayer(editLayer)
     , m_description("Disconnect " + destNode.GetName() + "." + destInput)
 {
     if (!stage) return;
@@ -38,7 +41,13 @@ void DisconnectShaderAttrCommand::Execute() {
         if (!destShader) return;
         pxr::UsdShadeInput input = destShader.GetInput(pxr::TfToken(m_destInput));
         if (!input) return;
-        pxr::UsdShadeConnectableAPI::DisconnectSource(input);
+
+        if (m_editLayer) {
+            pxr::UsdEditContext ec(m_stage, m_editLayer);
+            pxr::UsdShadeConnectableAPI::DisconnectSource(input);
+        } else {
+            pxr::UsdShadeConnectableAPI::DisconnectSource(input);
+        }
     } catch (const std::exception& e) {
         LOG_ERROR(std::string("DisconnectShaderAttrCommand::Execute error: ") + e.what());
     }
@@ -53,8 +62,14 @@ void DisconnectShaderAttrCommand::Undo() {
 
         pxr::UsdShadeInput input = destShader.GetInput(pxr::TfToken(m_destInput));
         pxr::UsdShadeOutput output = sourceShader.GetOutput(pxr::TfToken(m_sourceOutput));
-        if (input && output)
+        if (!input || !output) return;
+
+        if (m_editLayer) {
+            pxr::UsdEditContext ec(m_stage, m_editLayer);
             pxr::UsdShadeConnectableAPI::ConnectToSource(input, output);
+        } else {
+            pxr::UsdShadeConnectableAPI::ConnectToSource(input, output);
+        }
     } catch (const std::exception& e) {
         LOG_ERROR(std::string("DisconnectShaderAttrCommand::Undo error: ") + e.what());
     }

src/core/commands/DisconnectShaderAttrCommand.h

@@ -3,6 +3,7 @@
 #include "../CommandHistory.h"
 #include <pxr/usd/usd/stage.h>
 #include <pxr/usd/sdf/path.h>
+#include <pxr/usd/sdf/layer.h>
 #include <string>
 
 namespace UsdLayerManager {
@@ -11,9 +12,13 @@ namespace UsdLayerManager {
 /// source at construction time so Undo can restore it.
 class DisconnectShaderAttrCommand : public ICommand {
 public:
+    /// editLayer: see ConnectShaderAttrsCommand's constructor doc — same
+    /// capture-at-construction-time pattern, null/empty falls back to the
+    /// ambient edit target at call time (today's behavior).
     DisconnectShaderAttrCommand(pxr::UsdStageRefPtr stage,
                                 const pxr::SdfPath&  destNode,
-                                const std::string&   destInput);
+                                const std::string&   destInput,
+                                pxr::SdfLayerHandle  editLayer = pxr::SdfLayerHandle());
 
     void Execute() override;
     void Undo()    override;
@@ -23,6 +28,7 @@ private:
     pxr::UsdStageRefPtr m_stage;
     pxr::SdfPath        m_destNode;
     std::string         m_destInput;
+    pxr::SdfLayerHandle m_editLayer;
     std::string         m_description;
 
     bool         m_hadConnection = false;

src/core/commands/RenderLayerCommands.cpp

@@ -0,0 +1,102 @@
+#include "RenderLayerCommands.h"
+
+namespace UsdLayerManager {
+
+// ─── RenderLayerCreateCommand ─────────────────────────────────────────────
+
+RenderLayerCreateCommand::RenderLayerCreateCommand(RenderLayerManager* mgr, std::string name)
+    : m_mgr(mgr)
+    , m_name(std::move(name))
+    , m_description("Create Render Layer " + m_name)
+{
+}
+
+void RenderLayerCreateCommand::Execute() {
+    if (!m_mgr) return;
+    m_layerId = m_mgr->CreateRenderLayer(m_name);
+}
+
+void RenderLayerCreateCommand::Undo() {
+    if (!m_mgr || m_layerId.empty()) return;
+    m_mgr->DeleteRenderLayer(m_layerId);
+}
+
+// ─── RenderLayerDeleteCommand ─────────────────────────────────────────────
+
+RenderLayerDeleteCommand::RenderLayerDeleteCommand(RenderLayerManager* mgr, std::string layerId)
+    : m_mgr(mgr)
+    , m_layerId(std::move(layerId))
+    , m_description("Delete Render Layer")
+{
+    if (!mgr) return;
+    for (const auto& info : mgr->GetRenderLayers()) {
+        if (!info.isDefault && info.layerIdentifier == m_layerId) {
+            m_description = "Delete Render Layer " + info.name;
+            break;
+        }
+    }
+}
+
+void RenderLayerDeleteCommand::Execute() {
+    if (!m_mgr) return;
+    m_mgr->DeleteRenderLayer(m_layerId);
+}
+
+void RenderLayerDeleteCommand::Undo() {
+    if (!m_mgr || m_layerId.empty()) return;
+    m_mgr->RestoreDeletedRenderLayer(m_layerId);
+}
+
+// ─── RenderLayerRenameCommand ─────────────────────────────────────────────
+
+RenderLayerRenameCommand::RenderLayerRenameCommand(RenderLayerManager* mgr, std::string layerId,
+                                                   std::string newName)
+    : m_mgr(mgr)
+    , m_layerId(std::move(layerId))
+    , m_newName(std::move(newName))
+    , m_description("Rename Render Layer")
+{
+    if (!mgr) return;
+    for (const auto& info : mgr->GetRenderLayers()) {
+        if (!info.isDefault && info.layerIdentifier == m_layerId) {
+            m_oldName     = info.name;
+            m_description = "Rename Render Layer " + info.name + " -> " + m_newName;
+            break;
+        }
+    }
+}
+
+void RenderLayerRenameCommand::Execute() {
+    if (!m_mgr) return;
+    m_mgr->RenameRenderLayer(m_layerId, m_newName);
+}
+
+void RenderLayerRenameCommand::Undo() {
+    if (!m_mgr || m_oldName.empty()) return;
+    m_mgr->RenameRenderLayer(m_layerId, m_oldName);
+}
+
+// ─── RenderLayerActivateCommand ───────────────────────────────────────────
+
+RenderLayerActivateCommand::RenderLayerActivateCommand(RenderLayerManager* mgr, std::string targetLayerId)
+    : m_mgr(mgr)
+    , m_targetLayerId(std::move(targetLayerId))
+    , m_description(m_targetLayerId.empty() ? "Activate Render Layer: Default"
+                                            : "Activate Render Layer")
+{
+    if (mgr) m_priorLayerId = mgr->GetActiveRenderLayerId();
+}
+
+void RenderLayerActivateCommand::Execute() {
+    if (!m_mgr) return;
+    if (m_targetLayerId.empty()) m_mgr->ActivateDefaultLayer();
+    else                          m_mgr->ActivateRenderLayer(m_targetLayerId);
+}
+
+void RenderLayerActivateCommand::Undo() {
+    if (!m_mgr) return;
+    if (m_priorLayerId.empty()) m_mgr->ActivateDefaultLayer();
+    else                         m_mgr->ActivateRenderLayer(m_priorLayerId);
+}
+
+} // namespace UsdLayerManager

src/core/commands/RenderLayerCommands.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include "../CommandHistory.h"
+#include "../RenderLayerManager.h"
+#include <string>
+
+namespace UsdLayerManager {
+
+/// Undo removes the created layer via RenderLayerManager::DeleteRenderLayer.
+class RenderLayerCreateCommand : public ICommand {
+public:
+    RenderLayerCreateCommand(RenderLayerManager* mgr, std::string name);
+    void Execute() override;
+    void Undo()    override;
+    std::string GetDescription() const override { return m_description; }
+
+    /// Valid after Execute() — the new layer's identifier, so the panel can
+    /// select it immediately.
+    const std::string& GetCreatedLayerId() const { return m_layerId; }
+
+private:
+    RenderLayerManager* m_mgr;
+    std::string          m_name;
+    std::string          m_layerId;
+    std::string          m_description;
+};
+
+/// The backing file is left on disk by RenderLayerManager::DeleteRenderLayer
+/// (only the sublayer reference is removed), so Undo just re-inserts it.
+class RenderLayerDeleteCommand : public ICommand {
+public:
+    RenderLayerDeleteCommand(RenderLayerManager* mgr, std::string layerId);
+    void Execute() override;
+    void Undo()    override;
+    std::string GetDescription() const override { return m_description; }
+
+private:
+    RenderLayerManager* m_mgr;
+    std::string          m_layerId;
+    std::string          m_description;
+};
+
+class RenderLayerRenameCommand : public ICommand {
+public:
+    RenderLayerRenameCommand(RenderLayerManager* mgr, std::string layerId, std::string newName);
+    void Execute() override;
+    void Undo()    override;
+    std::string GetDescription() const override { return m_description; }
+
+private:
+    RenderLayerManager* m_mgr;
+    std::string          m_layerId;
+    std::string          m_newName;
+    std::string          m_oldName;
+    std::string          m_description;
+};
+
+/// Switches the active render layer (or back to Default). RenderLayerManager
+/// itself tracks the edit target to restore on returning to Default, so this
+/// command only needs to remember which layer was active before the switch.
+class RenderLayerActivateCommand : public ICommand {
+public:
+    /// targetLayerId empty = activate Default.
+    RenderLayerActivateCommand(RenderLayerManager* mgr, std::string targetLayerId);
+    void Execute() override;
+    void Undo()    override;
+    std::string GetDescription() const override { return m_description; }
+
+private:
+    RenderLayerManager* m_mgr;
+    std::string          m_targetLayerId; // "" = Default
+    std::string          m_priorLayerId;  // captured at construction; "" = Default
+    std::string          m_description;
+};
+
+} // namespace UsdLayerManager

src/core/commands/RenderLayerMembershipCommand.cpp

@@ -0,0 +1,57 @@
+#include "RenderLayerMembershipCommand.h"
+
+namespace UsdLayerManager {
+
+// ─── RenderLayerAddMembersCommand ─────────────────────────────────────────
+
+RenderLayerAddMembersCommand::RenderLayerAddMembersCommand(RenderLayerManager* mgr,
+                                                           std::string layerId,
+                                                           std::vector<pxr::SdfPath> paths)
+    : m_mgr(mgr)
+    , m_layerId(std::move(layerId))
+    , m_paths(std::move(paths))
+    , m_description(m_paths.size() == 1
+          ? ("Add " + m_paths.front().GetString() + " to Render Layer")
+          : ("Add " + std::to_string(m_paths.size()) + " Members to Render Layer"))
+{
+}
+
+void RenderLayerAddMembersCommand::Execute() {
+    if (!m_mgr) return;
+    for (const auto& p : m_paths)
+        m_mgr->AddMember(m_layerId, p);
+}
+
+void RenderLayerAddMembersCommand::Undo() {
+    if (!m_mgr) return;
+    for (const auto& p : m_paths)
+        m_mgr->RemoveMember(m_layerId, p);
+}
+
+// ─── RenderLayerRemoveMembersCommand ──────────────────────────────────────
+
+RenderLayerRemoveMembersCommand::RenderLayerRemoveMembersCommand(RenderLayerManager* mgr,
+                                                                 std::string layerId,
+                                                                 std::vector<pxr::SdfPath> paths)
+    : m_mgr(mgr)
+    , m_layerId(std::move(layerId))
+    , m_paths(std::move(paths))
+    , m_description(m_paths.size() == 1
+          ? ("Remove " + m_paths.front().GetString() + " from Render Layer")
+          : ("Remove " + std::to_string(m_paths.size()) + " Members from Render Layer"))
+{
+}
+
+void RenderLayerRemoveMembersCommand::Execute() {
+    if (!m_mgr) return;
+    for (const auto& p : m_paths)
+        m_mgr->RemoveMember(m_layerId, p);
+}
+
+void RenderLayerRemoveMembersCommand::Undo() {
+    if (!m_mgr) return;
+    for (const auto& p : m_paths)
+        m_mgr->AddMember(m_layerId, p);
+}
+
+} // namespace UsdLayerManager

src/core/commands/RenderLayerMembershipCommand.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "../CommandHistory.h"
+#include "../RenderLayerManager.h"
+#include <pxr/usd/sdf/path.h>
+#include <string>
+#include <vector>
+
+namespace UsdLayerManager {
+
+/// Adds one or more prim paths to a render layer's membership (Sdf-level, so
+/// this works whether or not layerId is currently active). Re-runs viewport
+/// isolation if layerId happens to be the active layer.
+class RenderLayerAddMembersCommand : public ICommand {
+public:
+    RenderLayerAddMembersCommand(RenderLayerManager* mgr, std::string layerId,
+                                 std::vector<pxr::SdfPath> paths);
+    void Execute() override;
+    void Undo()    override;
+    std::string GetDescription() const override { return m_description; }
+
+private:
+    RenderLayerManager*       m_mgr;
+    std::string                m_layerId;
+    std::vector<pxr::SdfPath>  m_paths;
+    std::string                m_description;
+};
+
+class RenderLayerRemoveMembersCommand : public ICommand {
+public:
+    RenderLayerRemoveMembersCommand(RenderLayerManager* mgr, std::string layerId,
+                                    std::vector<pxr::SdfPath> paths);
+    void Execute() override;
+    void Undo()    override;
+    std::string GetDescription() const override { return m_description; }
+
+private:
+    RenderLayerManager*       m_mgr;
+    std::string                m_layerId;
+    std::vector<pxr::SdfPath>  m_paths;
+    std::string                m_description;
+};
+
+} // namespace UsdLayerManager

src/ui/Application.cpp

@@ -41,6 +41,7 @@ Application::Application()
     : m_showDemoWindow(false)
     , m_showStageInfo(true)
     , m_showStageEditor(true)
+    , m_showRenderLayerPanel(true)
     , m_showSceneHierarchy(true)
     , m_showViewport(true)
     , m_showPropertyPanel(true)
@@ -67,15 +68,23 @@ bool Application::Initialize(const std::string& windowTitle, int width, int heig
     // Create managers
     m_stageManager = std::make_unique<UsdStageManager>();
     m_layerManager = std::make_unique<LayerManager>();
+    m_renderLayerManager = std::make_unique<RenderLayerManager>();
+    m_renderLayerManager->SetLayerManager(m_layerManager.get());
     m_propertyManager = std::make_unique<PropertyManager>();
     m_propertyManager->SetCommandHistory(&m_commandHistory);
     m_stageEditorPanel = std::make_unique<StageEditorPanel>();
     m_stageEditorPanel->SetLayerManager(m_layerManager.get());
     m_stageEditorPanel->SetCommandHistory(&m_commandHistory);
+    m_stageEditorPanel->SetRenderLayerManager(m_renderLayerManager.get());
     m_sceneHierarchyPanel = std::make_unique<SceneHierarchyPanel>();
     m_sceneHierarchyPanel->SetPropertyManager(m_propertyManager.get());
     m_sceneHierarchyPanel->SetCommandHistory(&m_commandHistory);
     m_sceneHierarchyPanel->SetLayerManager(m_layerManager.get());
+    m_sceneHierarchyPanel->SetRenderLayerManager(m_renderLayerManager.get());
+    m_renderLayerPanel = std::make_unique<RenderLayerPanel>();
+    m_renderLayerPanel->SetRenderLayerManager(m_renderLayerManager.get());
+    m_renderLayerPanel->SetCommandHistory(&m_commandHistory);
+    m_renderLayerPanel->SetSceneHierarchyPanel(m_sceneHierarchyPanel.get());
     m_viewportPanel = std::make_unique<ViewportPanel>();
     m_viewportPanel->SetCommandHistory(&m_commandHistory);
     m_propertyPanel = std::make_unique<PropertyPanel>();
@@ -116,6 +125,7 @@ bool Application::Initialize(const std::string& windowTitle, int width, int heig
     m_timelinePanel->SetIconManager(m_iconManager.get());
     m_stageEditorPanel->SetIconManager(m_iconManager.get());
     m_materialEditorPanel->SetIconManager(m_iconManager.get());
+    m_renderLayerPanel->SetIconManager(m_iconManager.get());
 
     m_sceneHierarchyPanel->SetOnPrimSelected(
         [this](const std::string& path) {
@@ -235,10 +245,12 @@ void Application::Shutdown() {
     m_sceneHierarchyPanel.reset();
     m_propertyPanel.reset();
     m_stageEditorPanel.reset();
+    m_renderLayerPanel.reset();
     // Owns the shader-ball preview's Hydra engine + GL draw target — must be
     // destroyed while the GL context still exists, like m_viewportPanel.
     m_materialEditorPanel.reset();
     m_propertyManager.reset();
+    m_renderLayerManager.reset();
     m_layerManager.reset();
 
     if (m_iconManager) {
@@ -263,8 +275,12 @@ void Application::RefreshManagers() {
     if (m_stageManager->HasStage()) {
         auto stage = m_stageManager->GetStage();
         m_layerManager->SetStage(stage);
+        // After LayerManager (ActivateRenderLayer routes edit-target changes
+        // through it) but before RestorePersistedActiveLayer needs it.
+        m_renderLayerManager->SetStage(stage);
         m_propertyManager->SetStage(stage);
         m_sceneHierarchyPanel->SetStage(stage);
+        m_renderLayerPanel->SetStage(stage);
         m_viewportPanel->SetStage(stage);
         m_viewportPanel->FrameScene();
         m_propertyPanel->SetStage(stage);
@@ -272,10 +288,16 @@ void Application::RefreshManagers() {
         m_curveEditorPanel->SetStage(stage);
         m_materialManager->SetStage(stage);
         m_materialEditorPanel->SetStage(stage);
+        // Re-applies whichever render layer was active last time this stage
+        // was saved (mute state itself isn't serialized — see
+        // RenderLayerManager::RestorePersistedActiveLayer).
+        m_renderLayerManager->RestorePersistedActiveLayer();
     } else {
         m_layerManager->SetStage(nullptr);
+        m_renderLayerManager->SetStage(nullptr);
         m_propertyManager->SetStage(nullptr);
         m_sceneHierarchyPanel->SetStage(nullptr);
+        m_renderLayerPanel->SetStage(nullptr);
         m_viewportPanel->SetStage(nullptr);
         m_propertyPanel->SetStage(nullptr);
         m_timelinePanel->SetStage(nullptr);
@@ -327,6 +349,12 @@ void Application::RenderUI() {
         ImGui::End();
     }
 
+    if (m_showRenderLayerPanel) {
+        ImGui::Begin("Render Layers", &m_showRenderLayerPanel, ImGuiWindowFlags_NoCollapse);
+        m_renderLayerPanel->Render();
+        ImGui::End();
+    }
+
     if (m_showViewport) {
         m_viewportPanel->Render(&m_showViewport);
     }
@@ -777,6 +805,7 @@ void Application::RenderMenuBar() {
         
         if (ImGui::BeginMenu("View")) {
             ImGui::MenuItem("Stage Editor",     nullptr, &m_showStageEditor);
+            ImGui::MenuItem("Render Layers",    nullptr, &m_showRenderLayerPanel);
             ImGui::MenuItem("Scene Hierarchy",  nullptr, &m_showSceneHierarchy);
             ImGui::MenuItem("Viewport",         nullptr, &m_showViewport);
             ImGui::MenuItem("Property Panel",   nullptr, &m_showPropertyPanel);
@@ -872,7 +901,9 @@ void Application::SaveUsdFile() {
 
     if (!m_stageManager->SaveStage()) {
         LOG_ERROR("Failed to save USD file: " + m_stageManager->GetLastError());
+        return;
     }
+    SaveDirtyRenderLayers();
 }
 
 void Application::SaveUsdFileAs() {
@@ -891,6 +922,11 @@ void Application::SaveUsdFileAs() {
         if (!m_stageManager->SaveStageAs(filePath)) {
             LOG_ERROR("Failed to save USD file: " + m_stageManager->GetLastError());
         } else {
+            // m_renderLayerManager's layer refs are identifier-keyed SdfLayer
+            // objects, independent of which UsdStage currently references
+            // them — safe to save before the stage swap RefreshManagers()
+            // below performs.
+            SaveDirtyRenderLayers();
             // SaveStageAs reopens m_stageManager's stage from the new file path.
             // RefreshManagers syncs m_layerManager (and others) to that new stage;
             // without this, subsequent sublayer edits go to the old (now stale) stage
@@ -900,6 +936,15 @@ void Application::SaveUsdFileAs() {
     }
 }
 
+void Application::SaveDirtyRenderLayers() {
+    if (!m_renderLayerManager) return;
+    for (const auto& info : m_renderLayerManager->GetRenderLayers()) {
+        if (info.isDefault || !info.layer) continue;
+        if (info.layer->IsDirty())
+            info.layer->Save();
+    }
+}
+
 void Application::CloseUsdFile() {
     m_stageManager->CloseStage();
     // Re-create a fresh default stage so the app is always in an editable state.

src/ui/Application.h

@@ -4,6 +4,7 @@
 #include "IconManager.h"
 #include "StageEditorPanel.h"
 #include "SceneHierarchyPanel.h"
+#include "RenderLayerPanel.h"
 #include "ViewportPanel.h"
 #include "PropertyPanel.h"
 #include "TimelinePanel.h"
@@ -11,6 +12,7 @@
 #include "MaterialEditorPanel.h"
 #include "../core/UsdStageManager.h"
 #include "../core/LayerManager.h"
+#include "../core/RenderLayerManager.h"
 #include "../core/PropertyManager.h"
 #include "../core/MaterialManager.h"
 #include "../core/CommandHistory.h"
@@ -65,6 +67,12 @@ private:
     void AddReferenceToStage();
     void CreatePrimOnStage(const std::string& typeName);
 
+    /// Explicitly saves every render-layer SdfLayer, since at most one is
+    /// ever in the stage's composition (unmuted) at a time and
+    /// UsdStage::Save() only walks layers currently in composition — the
+    /// rest would otherwise be silently dropped on save.
+    void SaveDirtyRenderLayers();
+
     // Playblast
     void CapturePlayblastFrame();
 
@@ -78,11 +86,13 @@ private:
     std::unique_ptr<IconManager> m_iconManager;
     std::unique_ptr<UsdStageManager> m_stageManager;
     std::unique_ptr<LayerManager> m_layerManager;
+    std::unique_ptr<RenderLayerManager> m_renderLayerManager;
     std::unique_ptr<PropertyManager> m_propertyManager;
     std::unique_ptr<MaterialManager> m_materialManager;
     CommandHistory m_commandHistory;
     std::unique_ptr<StageEditorPanel> m_stageEditorPanel;
     std::unique_ptr<SceneHierarchyPanel> m_sceneHierarchyPanel;
+    std::unique_ptr<RenderLayerPanel> m_renderLayerPanel;
     std::unique_ptr<ViewportPanel> m_viewportPanel;
     std::unique_ptr<PropertyPanel> m_propertyPanel;
     std::unique_ptr<TimelinePanel> m_timelinePanel;
@@ -91,6 +101,7 @@ private:
     bool m_showDemoWindow;
     bool m_showStageInfo;
     bool m_showStageEditor;
+    bool m_showRenderLayerPanel;
     bool m_showSceneHierarchy;
     bool m_showViewport;
     bool m_showPropertyPanel;

src/ui/MaterialEditorPanel.cpp

@@ -9,6 +9,7 @@
 #include "../utils/Logger.h"
 #include "../utils/FileDialog.h"
 #include "../utils/OcioConfigParser.h"
+#include <pxr/usd/usd/editContext.h>
 #include <pxr/usd/usdShade/shader.h>
 #include <pxr/usd/usdShade/material.h>
 #include <pxr/usd/usdShade/materialBindingAPI.h>
@@ -1428,25 +1429,42 @@ void MaterialEditorPanel::BindMaterialToTarget(const pxr::SdfPath& materialPath,
     }
 
     pxr::UsdStageRefPtr stage = m_stage;
-    auto doBind = [stage, targetPath, materialPath]() {
+    // Captured at construction time so Undo() lands in the same layer as
+    // Execute() even if the ambient edit target changes in between (e.g. a
+    // render-layer switch) — mirrors ConnectShaderAttrsCommand's pattern.
+    pxr::SdfLayerHandle editLayer = m_stage->GetEditTarget().GetLayer();
+    auto doBind = [stage, targetPath, materialPath, editLayer]() {
         pxr::UsdPrim target = stage->GetPrimAtPath(targetPath);
         pxr::UsdShadeMaterial material(stage->GetPrimAtPath(materialPath));
-        if (target && material)
+        if (!target || !material) return;
+        if (editLayer) {
+            pxr::UsdEditContext ec(stage, editLayer);
             pxr::UsdShadeMaterialBindingAPI::Apply(target).Bind(material);
+        } else {
+            pxr::UsdShadeMaterialBindingAPI::Apply(target).Bind(material);
+        }
     };
 
     if (m_commandHistory) {
         m_commandHistory->Push(std::make_unique<AttributeSetCommand>(
             "Bind Material",
             doBind,
-            [stage, targetPath, hadPriorRel, priorTargets]() {
+            [stage, targetPath, hadPriorRel, priorTargets, editLayer]() {
                 pxr::UsdPrim target = stage->GetPrimAtPath(targetPath);
                 if (!target) return;
-                pxr::UsdShadeMaterialBindingAPI bindAPI(target);
+                auto doUnbind = [&]() {
-                if (hadPriorRel && !priorTargets.empty())
+                    pxr::UsdShadeMaterialBindingAPI bindAPI(target);
-                    bindAPI.GetDirectBindingRel().SetTargets(priorTargets);
+                    if (hadPriorRel && !priorTargets.empty())
-                else
+                        bindAPI.GetDirectBindingRel().SetTargets(priorTargets);
-                    bindAPI.UnbindDirectBinding();
+                    else
+                        bindAPI.UnbindDirectBinding();
+                };
+                if (editLayer) {
+                    pxr::UsdEditContext ec(stage, editLayer);
+                    doUnbind();
+                } else {
+                    doUnbind();
+                }
             }
         ));
     } else {
@@ -2355,9 +2373,13 @@ pxr::SdfPath MaterialEditorPanel::CreateShaderNode(const std::string& shaderId,
 void MaterialEditorPanel::CreateConnection(const PinInfo& destInput, const PinInfo& sourceOutput) {
     if (!m_stage || !m_commandHistory) return;
 
+    // Captured now so Undo() (which may run after the ambient edit target
+    // has since changed, e.g. a render-layer switch) still targets the same
+    // layer this connection was authored into.
+    pxr::SdfLayerHandle editLayer = m_stage->GetEditTarget().GetLayer();
     m_commandHistory->Push(std::make_unique<ConnectShaderAttrsCommand>(
         m_stage, destInput.nodePath, destInput.name, destInput.typeName,
-        sourceOutput.nodePath, sourceOutput.name, sourceOutput.typeName));
+        sourceOutput.nodePath, sourceOutput.name, sourceOutput.typeName, editLayer));
     SyncFromUsd();
 }
 
@@ -2369,7 +2391,8 @@ void MaterialEditorPanel::DeleteNode(const pxr::SdfPath& nodePath) {
 
 void MaterialEditorPanel::DisconnectAttr(const pxr::SdfPath& destNode, const std::string& destInput) {
     if (!m_stage || !m_commandHistory) return;
-    m_commandHistory->Push(std::make_unique<DisconnectShaderAttrCommand>(m_stage, destNode, destInput));
+    pxr::SdfLayerHandle editLayer = m_stage->GetEditTarget().GetLayer();
+    m_commandHistory->Push(std::make_unique<DisconnectShaderAttrCommand>(m_stage, destNode, destInput, editLayer));
     SyncFromUsd();
 }
 

src/ui/RenderLayerPanel.cpp

@@ -0,0 +1,263 @@
+#include "RenderLayerPanel.h"
+#include "../core/commands/RenderLayerCommands.h"
+#include "../core/commands/RenderLayerMembershipCommand.h"
+#include <pxr/usd/usd/prim.h>
+#include <imgui.h>
+#include <cstring>
+
+namespace UsdLayerManager {
+
+RenderLayerPanel::RenderLayerPanel() {}
+RenderLayerPanel::~RenderLayerPanel() {}
+
+void RenderLayerPanel::SetStage(pxr::UsdStageRefPtr stage) {
+    m_stage = stage;
+    m_defaultSelected = true;
+    m_selectedLayerId.clear();
+}
+
+// ---------------------------------------------------------------------------
+void RenderLayerPanel::Render() {
+    if (!m_renderLayerManager) {
+        ImGui::TextDisabled("No stage loaded");
+        return;
+    }
+
+    ImGui::Text("Render Layers");
+    ImGui::Separator();
+
+    ImGui::SetNextItemWidth(180.0f);
+    ImGui::InputText("##newLayerName", m_newLayerNameBuf, sizeof(m_newLayerNameBuf));
+    ImGui::SameLine();
+    if (ImGui::Button("Create Layer")) {
+        std::string name = m_newLayerNameBuf[0] ? m_newLayerNameBuf : "RenderLayer";
+        std::string newId;
+        if (m_commandHistory) {
+            auto cmd = std::make_unique<RenderLayerCreateCommand>(m_renderLayerManager, name);
+            RenderLayerCreateCommand* raw = cmd.get();
+            m_commandHistory->Push(std::move(cmd));
+            newId = raw->GetCreatedLayerId();
+        } else {
+            newId = m_renderLayerManager->CreateRenderLayer(name);
+        }
+        if (!newId.empty()) {
+            m_defaultSelected  = false;
+            m_selectedLayerId  = newId;
+        }
+    }
+
+    ImGui::Spacing();
+    RenderLayerList();
+
+    ImGui::Spacing();
+    ImGui::Separator();
+    ImGui::TextDisabled("Membership");
+    ImGui::Separator();
+    RenderMembershipPanel();
+
+    RenderRenameModal();
+}
+
+// ---------------------------------------------------------------------------
+void RenderLayerPanel::RenderLayerList() {
+    auto layers = m_renderLayerManager->GetRenderLayers();
+
+    if (!ImGui::BeginTable("RenderLayerTable", 3,
+            ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersInnerV |
+            ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_ScrollY,
+            ImVec2(0, 150)))
+        return;
+
+    ImGui::TableSetupColumn("##active", ImGuiTableColumnFlags_WidthFixed, 24.0f);
+    ImGui::TableSetupColumn("Name",     ImGuiTableColumnFlags_WidthStretch);
+    ImGui::TableSetupColumn("##dirty",  ImGuiTableColumnFlags_WidthFixed, 14.0f);
+
+    for (int i = 0; i < static_cast<int>(layers.size()); ++i) {
+        const auto& li = layers[i];
+        ImGui::TableNextRow();
+        ImGui::PushID(i);
+
+        // Col 0: activate radio button.
+        ImGui::TableSetColumnIndex(0);
+        {
+            bool isActive = li.isActive;
+            if (ImGui::RadioButton("##act", isActive) && !isActive) {
+                std::string target = li.isDefault ? std::string() : li.layerIdentifier;
+                if (m_commandHistory)
+                    m_commandHistory->Push(
+                        std::make_unique<RenderLayerActivateCommand>(m_renderLayerManager, target));
+                else if (li.isDefault)
+                    m_renderLayerManager->ActivateDefaultLayer();
+                else
+                    m_renderLayerManager->ActivateRenderLayer(target);
+            }
+            if (ImGui::IsItemHovered())
+                ImGui::SetTooltip(isActive ? "Active" : "Click to activate");
+        }
+
+        // Col 1: name — selecting a row picks which layer's membership shows below.
+        ImGui::TableSetColumnIndex(1);
+        {
+            bool selected = li.isDefault
+                ? m_defaultSelected
+                : (!m_defaultSelected && m_selectedLayerId == li.layerIdentifier);
+            ImVec4 nameColor = li.isActive ? ImVec4(0.5f, 1.0f, 0.5f, 1.0f)
+                                            : ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
+            ImGui::PushStyleColor(ImGuiCol_Text, nameColor);
+            if (ImGui::Selectable(li.name.c_str(), selected,
+                    ImGuiSelectableFlags_SpanAllColumns)) {
+                m_defaultSelected = li.isDefault;
+                m_selectedLayerId = li.isDefault ? std::string() : li.layerIdentifier;
+            }
+            ImGui::PopStyleColor();
+
+            if (!li.isDefault && ImGui::BeginPopupContextItem()) {
+                if (ImGui::MenuItem("Rename")) {
+                    m_openRenameModal = true;
+                    m_renameTargetId  = li.layerIdentifier;
+                    std::strncpy(m_renameBuf, li.name.c_str(), sizeof(m_renameBuf) - 1);
+                    m_renameBuf[sizeof(m_renameBuf) - 1] = '\0';
+                }
+                if (ImGui::MenuItem("Delete")) {
+                    if (m_commandHistory)
+                        m_commandHistory->Push(
+                            std::make_unique<RenderLayerDeleteCommand>(m_renderLayerManager, li.layerIdentifier));
+                    else
+                        m_renderLayerManager->DeleteRenderLayer(li.layerIdentifier);
+                    if (!m_defaultSelected && m_selectedLayerId == li.layerIdentifier) {
+                        m_defaultSelected = true;
+                        m_selectedLayerId.clear();
+                    }
+                }
+                ImGui::EndPopup();
+            }
+        }
+
+        // Col 2: dirty indicator.
+        ImGui::TableSetColumnIndex(2);
+        if (!li.isDefault && li.layer && li.layer->IsDirty())
+            ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.2f, 1.0f), "*");
+        else
+            ImGui::TextDisabled(" ");
+
+        ImGui::PopID();
+    }
+
+    ImGui::EndTable();
+}
+
+// ---------------------------------------------------------------------------
+void RenderLayerPanel::RenderMembershipPanel() {
+    if (m_defaultSelected) {
+        ImGui::TextDisabled("Default has no membership of its own - it always shows the full, unmodified stage.");
+        return;
+    }
+    if (m_selectedLayerId.empty()) {
+        ImGui::TextDisabled("Select a render layer above to edit its membership.");
+        return;
+    }
+
+    std::string displayName = m_selectedLayerId;
+    for (const auto& li : m_renderLayerManager->GetRenderLayers())
+        if (!li.isDefault && li.layerIdentifier == m_selectedLayerId) { displayName = li.name; break; }
+    ImGui::Text("Members of \"%s\"", displayName.c_str());
+
+    auto members = m_renderLayerManager->GetMembers(m_selectedLayerId);
+
+    auto isValid = [&](const pxr::SdfPath& p) {
+        return m_stage && m_stage->GetPrimAtPath(p).IsValid();
+    };
+
+    bool anyMissing = false;
+    for (const auto& p : members)
+        if (!isValid(p)) { anyMissing = true; break; }
+
+    if (m_sceneHierarchyPanel && ImGui::Button("Add Selected")) {
+        auto paths = m_sceneHierarchyPanel->GetSelectedPaths();
+        if (!paths.empty()) {
+            std::vector<pxr::SdfPath> sdfPaths;
+            sdfPaths.reserve(paths.size());
+            for (const auto& p : paths) sdfPaths.emplace_back(p);
+            if (m_commandHistory)
+                m_commandHistory->Push(std::make_unique<RenderLayerAddMembersCommand>(
+                    m_renderLayerManager, m_selectedLayerId, sdfPaths));
+            else
+                for (const auto& sp : sdfPaths) m_renderLayerManager->AddMember(m_selectedLayerId, sp);
+        }
+    }
+    if (anyMissing) {
+        ImGui::SameLine();
+        if (ImGui::Button("Remove Missing")) {
+            std::vector<pxr::SdfPath> toRemove;
+            for (const auto& p : members)
+                if (!isValid(p)) toRemove.push_back(p);
+            if (m_commandHistory)
+                m_commandHistory->Push(std::make_unique<RenderLayerRemoveMembersCommand>(
+                    m_renderLayerManager, m_selectedLayerId, toRemove));
+            else
+                for (const auto& p : toRemove) m_renderLayerManager->RemoveMember(m_selectedLayerId, p);
+        }
+    }
+
+    if (members.empty()) {
+        ImGui::TextDisabled("No members. Select lights/objects in Scene Hierarchy and click \"Add Selected\".");
+        return;
+    }
+
+    if (ImGui::BeginChild("RenderLayerMembersList", ImVec2(0, 0), true)) {
+        for (const auto& path : members) {
+            ImGui::PushID(path.GetString().c_str());
+            bool missing = !isValid(path);
+
+            if (missing) ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.45f, 0.45f, 1.0f));
+            ImGui::TextUnformatted(path.GetText());
+            if (missing) {
+                ImGui::PopStyleColor();
+                ImGui::SameLine();
+                ImGui::TextDisabled("(missing)");
+            }
+
+            ImGui::SameLine();
+            ImGui::SetCursorPosX(ImGui::GetWindowContentRegionMax().x - 24.0f);
+            if (ImGui::SmallButton("x")) {
+                if (m_commandHistory)
+                    m_commandHistory->Push(std::make_unique<RenderLayerRemoveMembersCommand>(
+                        m_renderLayerManager, m_selectedLayerId, std::vector<pxr::SdfPath>{path}));
+                else
+                    m_renderLayerManager->RemoveMember(m_selectedLayerId, path);
+            }
+            ImGui::PopID();
+        }
+    }
+    ImGui::EndChild();
+}
+
+// ---------------------------------------------------------------------------
+void RenderLayerPanel::RenderRenameModal() {
+    if (m_openRenameModal) {
+        ImGui::OpenPopup("Rename Render Layer");
+        m_openRenameModal = false;
+    }
+    if (ImGui::BeginPopupModal("Rename Render Layer", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
+        ImGui::SetNextItemWidth(240.0f);
+        bool enterPressed = ImGui::InputText("Name", m_renameBuf, sizeof(m_renameBuf),
+                                             ImGuiInputTextFlags_EnterReturnsTrue);
+        bool okClicked = ImGui::Button("OK");
+        ImGui::SameLine();
+        bool cancelClicked = ImGui::Button("Cancel");
+
+        if ((enterPressed || okClicked) && m_renameBuf[0]) {
+            if (m_commandHistory)
+                m_commandHistory->Push(std::make_unique<RenderLayerRenameCommand>(
+                    m_renderLayerManager, m_renameTargetId, std::string(m_renameBuf)));
+            else
+                m_renderLayerManager->RenameRenderLayer(m_renameTargetId, m_renameBuf);
+            ImGui::CloseCurrentPopup();
+        } else if (cancelClicked) {
+            ImGui::CloseCurrentPopup();
+        }
+        ImGui::EndPopup();
+    }
+}
+
+} // namespace UsdLayerManager

src/ui/RenderLayerPanel.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "../core/RenderLayerManager.h"
+#include "../core/CommandHistory.h"
+#include "SceneHierarchyPanel.h"
+#include "IconManager.h"
+#include <pxr/usd/usd/stage.h>
+#include <string>
+
+namespace UsdLayerManager {
+
+/// Maya-Render-Layers-style panel: layer list with one-click activation,
+/// create/rename/delete, and a membership editor for whichever layer is
+/// selected (independent of which one is active — you can inspect/edit a
+/// layer's members without switching to it).
+class RenderLayerPanel {
+public:
+    RenderLayerPanel();
+    ~RenderLayerPanel();
+
+    void SetRenderLayerManager(RenderLayerManager* mgr) { m_renderLayerManager = mgr; }
+    void SetCommandHistory(CommandHistory* history) { m_commandHistory = history; }
+    /// Optional — powers the "Add Selected" membership button.
+    void SetSceneHierarchyPanel(SceneHierarchyPanel* panel) { m_sceneHierarchyPanel = panel; }
+    void SetIconManager(IconManager* icons) { m_iconManager = icons; }
+    void SetStage(pxr::UsdStageRefPtr stage);
+    void Render();
+
+private:
+    void RenderLayerList();
+    void RenderMembershipPanel();
+    void RenderRenameModal();
+
+    RenderLayerManager*  m_renderLayerManager = nullptr;
+    CommandHistory*        m_commandHistory      = nullptr;
+    SceneHierarchyPanel*   m_sceneHierarchyPanel = nullptr;
+    IconManager*            m_iconManager         = nullptr;
+    pxr::UsdStageRefPtr     m_stage;
+
+    /// Which layer's membership the lower panel shows — independent of which
+    /// layer is currently active.
+    bool         m_defaultSelected = true;
+    std::string  m_selectedLayerId;
+
+    char         m_newLayerNameBuf[128] = "RenderLayer";
+
+    bool         m_openRenameModal = false;
+    std::string  m_renameTargetId;
+    char         m_renameBuf[128] = {};
+};
+
+} // namespace UsdLayerManager

src/ui/SceneHierarchyPanel.h

@@ -3,6 +3,7 @@
 #include "../core/PropertyManager.h"
 #include "../core/CommandHistory.h"
 #include "../core/LayerManager.h"
+#include "../core/RenderLayerManager.h"
 #include "IconManager.h"
 #include <pxr/usd/usd/stage.h>
 #include <pxr/usd/sdf/path.h>
@@ -26,13 +27,24 @@ public:
     void SetPropertyManager(PropertyManager* manager);
     void SetCommandHistory(CommandHistory* history) { m_commandHistory = history; }
     void SetLayerManager(LayerManager* lm) { m_layerManager = lm; }
+    /// Optional. When set and a non-Default render layer is active, the
+    /// edit-target layer switcher below is disabled — repointing the ambient
+    /// edit target away from the active render layer's SdfLayer would break
+    /// the invariant that edits made while it's active land in that layer.
+    void SetRenderLayerManager(RenderLayerManager* mgr) { m_renderLayerManager = mgr; }
     void SetStage(UsdStageRefPtr stage);
     void SetIconManager(IconManager* iconManager) { m_iconManager = iconManager; }
     void Render();
-    
+
     std::string GetSelectedPrimPath() const { return m_primarySelectedPath; }
     UsdPrim GetSelectedPrim() const;
 
+    /// Full multi-selection (rect pick or Ctrl/Shift click), in no
+    /// particular order. Empty when nothing is selected.
+    std::vector<std::string> GetSelectedPaths() const {
+        return std::vector<std::string>(m_selectedPaths.begin(), m_selectedPaths.end());
+    }
+
     /// Set single selection from hierarchy click (fires callback).
     /// Also clears any rect multi-selection.
     void SetSelectedPathFromClick(const std::string& path);
@@ -79,10 +91,13 @@ private:
     void RenderRemovePrimModal();
     void RenderArcModal();
     void ProcessPendingReplaceRef();
+    void RenderSublayerSection();
+    void RenderSublayerContextMenu(int i, const std::vector<LayerInfo>& sublayers);
     
     PropertyManager*             m_propertyManager;
     CommandHistory*              m_commandHistory = nullptr;
     LayerManager*                m_layerManager   = nullptr;
+    RenderLayerManager*          m_renderLayerManager = nullptr;
     IconManager*                 m_iconManager = nullptr;
     UsdStageRefPtr               m_stage;
 
@@ -94,6 +109,9 @@ private:
 
     bool                         m_scrollToSelected  = false;
 
+    /// Selected row in the Sublayers section (context menu / drag anchor).
+    int                          m_sublayerSelectedIdx = -1;
+
     /// Stage-local layer identifiers rebuilt once per Render() for override detection.
     /// Contains only the stage's own layers (root + sublayers + session),
     /// NOT layers that came in through references or payloads.

src/ui/StageEditorPanel.cpp

@@ -123,13 +123,18 @@ void StageEditorPanel::RenderFixedLayers(const std::vector<LayerInfo>& layers) {
 
         ImGui::TableSetColumnIndex(3);
         {
+            bool renderLayerActive = m_renderLayerManager && !m_renderLayerManager->IsDefaultActive();
             bool isET = li.isEditTarget;
             ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(2.0f, 1.0f));
+            ImGui::BeginDisabled(renderLayerActive);
             if (ImGui::Checkbox("##et", &isET) && isET)
                 m_layerManager->SetEditTarget(li.identifier);
+            ImGui::EndDisabled();
             ImGui::PopStyleVar();
             if (ImGui::IsItemHovered())
-                ImGui::SetTooltip(li.isEditTarget ? "Edit target (active)" : "Set as edit target");
+                ImGui::SetTooltip(renderLayerActive ? "Edit target is locked to the active render layer"
+                                  : li.isEditTarget  ? "Edit target (active)"
+                                                      : "Set as edit target");
         }
 
         ImGui::PopID();
@@ -242,6 +247,9 @@ void StageEditorPanel::RenderSublayerList(const std::vector<LayerInfo>& sublayer
         else
             ImGui::TextDisabled(" ");
 
+        bool isRenderLayer = RenderLayerManager::IsRenderLayerSublayer(li.layer);
+        bool renderLayerActive = m_renderLayerManager && !m_renderLayerManager->IsDefaultActive();
+
         // Col 2: layer name
         ImGui::TableSetColumnIndex(2);
         ImVec4 nameColor = li.isMuted
@@ -250,6 +258,12 @@ void StageEditorPanel::RenderSublayerList(const std::vector<LayerInfo>& sublayer
         ImGui::TextColored(nameColor, "%s", li.displayName.c_str());
         if (ImGui::IsItemHovered() && !li.realPath.empty())
             ImGui::SetTooltip("%s\n%s", li.identifier.c_str(), li.realPath.c_str());
+        if (isRenderLayer) {
+            ImGui::SameLine();
+            ImGui::TextColored(ImVec4(0.9f, 0.7f, 0.2f, 1.0f), "[RL]");
+            if (ImGui::IsItemHovered())
+                ImGui::SetTooltip("Managed from the Render Layer panel");
+        }
 
         // Col 3: edit target checkbox — checking sets this layer as edit target;
         // unchecking does nothing (there is always an active edit target).
@@ -257,23 +271,32 @@ void StageEditorPanel::RenderSublayerList(const std::vector<LayerInfo>& sublayer
         {
             bool isET = li.isEditTarget;
             ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(2.0f, 1.0f));
+            ImGui::BeginDisabled(renderLayerActive);
             if (ImGui::Checkbox("##et", &isET) && isET)
                 m_layerManager->SetEditTarget(li.identifier);
+            ImGui::EndDisabled();
             ImGui::PopStyleVar();
             if (ImGui::IsItemHovered())
-                ImGui::SetTooltip(li.isEditTarget ? "Edit target (active)" : "Set as edit target");
+                ImGui::SetTooltip(renderLayerActive ? "Edit target is locked to the active render layer"
+                                  : li.isEditTarget  ? "Edit target (active)"
+                                                      : "Set as edit target");
         }
 
-        // Col 4: mute checkbox
+        // Col 4: mute checkbox — disabled for render-layer sublayers, which
+        // RenderLayerManager mutes/unmutes exclusively as layers are switched.
         ImGui::TableSetColumnIndex(4);
         {
             bool muted = li.isMuted;
             ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(2.0f, 1.0f));
+            ImGui::BeginDisabled(isRenderLayer);
             if (ImGui::Checkbox("##muted", &muted)) {
                 if (muted) m_layerManager->MuteLayer(li.identifier);
                 else       m_layerManager->UnmuteLayer(li.identifier);
             }
+            ImGui::EndDisabled();
             ImGui::PopStyleVar();
+            if (isRenderLayer && ImGui::IsItemHovered())
+                ImGui::SetTooltip("Managed from the Render Layer panel");
         }
 
         ImGui::PopID();
@@ -289,14 +312,21 @@ void StageEditorPanel::RenderSublayerContextMenu(int i,
         return;
 
     const auto& li = sublayers[i];
+    bool isRenderLayer = RenderLayerManager::IsRenderLayerSublayer(li.layer);
+    bool renderLayerActive = m_renderLayerManager && !m_renderLayerManager->IsDefaultActive();
 
-    if (ImGui::MenuItem(li.isMuted ? "Unmute" : "Mute")) {
+    if (ImGui::MenuItem(li.isMuted ? "Unmute" : "Mute", nullptr, false, !isRenderLayer)) {
         if (li.isMuted) m_layerManager->UnmuteLayer(li.identifier);
         else            m_layerManager->MuteLayer(li.identifier);
     }
+    if (isRenderLayer && ImGui::IsItemHovered())
+        ImGui::SetTooltip("Managed from the Render Layer panel");
 
-    if (!li.isEditTarget && ImGui::MenuItem("Set as Edit Target"))
+    if (!li.isEditTarget &&
+        ImGui::MenuItem("Set as Edit Target", nullptr, false, !renderLayerActive))
         m_layerManager->SetEditTarget(li.identifier);
+    if (renderLayerActive && !li.isEditTarget && ImGui::IsItemHovered())
+        ImGui::SetTooltip("Edit target is locked to the active render layer");
 
     ImGui::Separator();
 
@@ -337,13 +367,15 @@ void StageEditorPanel::RenderSublayerContextMenu(int i,
 
     ImGui::Separator();
 
-    if (ImGui::MenuItem("Remove")) {
+    if (ImGui::MenuItem("Remove", nullptr, false, !isRenderLayer)) {
         if (m_commandHistory)
             m_commandHistory->Push(
                 std::make_unique<LayerRemoveCommand>(m_layerManager, i));
         else
             m_layerManager->RemoveSublayer(i);
     }
+    if (isRenderLayer && ImGui::IsItemHovered())
+        ImGui::SetTooltip("Managed from the Render Layer panel");
 
     ImGui::EndPopup();
 }

src/ui/StageEditorPanel.h

@@ -2,6 +2,7 @@
 
 #include "../core/LayerManager.h"
 #include "../core/CommandHistory.h"
+#include "../core/RenderLayerManager.h"
 #include "IconManager.h"
 #include <imgui.h>
 #include <memory>
@@ -17,6 +18,12 @@ public:
     void SetLayerManager(LayerManager* manager) { m_layerManager = manager; }
     void SetCommandHistory(CommandHistory* history) { m_commandHistory = history; }
     void SetIconManager(IconManager* icons) { m_iconManager = icons; }
+    /// Optional. When set: sublayers RenderLayerManager created are badged
+    /// and have their mute/remove controls disabled here (they're managed
+    /// exclusively from the Render Layer panel so the two can't desync), and
+    /// every row's edit-target checkbox is disabled while a non-Default
+    /// render layer is active.
+    void SetRenderLayerManager(RenderLayerManager* mgr) { m_renderLayerManager = mgr; }
     void Render();
 
 private:
@@ -24,9 +31,10 @@ private:
     void RenderSublayerList(const std::vector<LayerInfo>& sublayers);
     void RenderSublayerContextMenu(int i, const std::vector<LayerInfo>& sublayers);
 
-    LayerManager*   m_layerManager    = nullptr;
+    LayerManager*        m_layerManager       = nullptr;
-    CommandHistory* m_commandHistory  = nullptr;
+    CommandHistory*      m_commandHistory     = nullptr;
-    IconManager*    m_iconManager     = nullptr;
+    IconManager*         m_iconManager        = nullptr;
+    RenderLayerManager*  m_renderLayerManager = nullptr;
     int             m_selectedIdx     = -1;
 };