@alpsckr/unitycli 0.4.0

package/unitypkg/Editor/Tools/graphics/skybox-get.cs

@@ -0,0 +1,33 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>graphics.skybox-get — 读取天空盒/环境/雾/反射设置。</summary>
+    public class GraphicsSkyboxGetTool : IUnityCliTool<GraphicsSkyboxGetTool.Request, GraphicsSkyboxGetTool.Result>
+    {
+        public sealed class Request { }
+        public sealed class Result { public SkyboxInfo Skybox { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.skybox-get", Summary = "Read skybox material, sun, ambient, fog and reflection environment settings.", Description = "Read-only: returns RenderSettings skybox, sun, ambient mode/intensity/color, fog settings, and reflection settings.", Group = "graphics",DestructiveHint = false, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Read skybox settings", Input = new Request { } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var skybox = RenderSettings.skybox;
+            var sun = RenderSettings.sun;
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                Skybox = new SkyboxInfo
+                {
+                    Skybox = skybox == null ? null : new AssetRef { Name = skybox.name, Path = SceneToolSupport.NormalizeAssetPath(AssetDatabase.GetAssetPath(skybox)), Guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(skybox)) },
+                    Sun = sun == null ? null : new SunInfo { Name = sun.name, Path = GameObjectToolSupport.HierarchyPath(sun.gameObject) },
+                    Ambient = new AmbientInfo { AmbientMode = RenderSettings.ambientMode.ToString(), AmbientIntensity = RenderSettings.ambientIntensity, AmbientLight = new Vector3Data(new Vector3(RenderSettings.ambientLight.r, RenderSettings.ambientLight.g, RenderSettings.ambientLight.b)) },
+                    Fog = new FogInfo { Enabled = RenderSettings.fog, FogMode = RenderSettings.fogMode.ToString(), FogColor = GraphicsToolSupport.ColorHtml(RenderSettings.fogColor), FogDensity = RenderSettings.fogDensity, FogStartDistance = RenderSettings.fogStartDistance, FogEndDistance = RenderSettings.fogEndDistance },
+                    Reflection = new ReflectionInfo { AmbientMode = RenderSettings.defaultReflectionMode.ToString(), ReflectionBounces = RenderSettings.reflectionBounces, ReflectionIntensity = RenderSettings.reflectionIntensity }
+                }
+            });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/skybox-set-ambient.cs

@@ -0,0 +1,24 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+namespace UnityCli
+{
+    public class GraphicsSkyboxSetAmbientTool : IUnityCliTool<GraphicsSkyboxSetAmbientTool.Request, GraphicsSkyboxSetAmbientTool.Result>
+    {
+        public sealed class Request { public string Mode { get; set; } public float? Intensity { get; set; } public string Color { get; set; } public string AmbientEquatorColor { get; set; } public string AmbientGroundColor { get; set; } public string AmbientSkyColor { get; set; } }
+        public sealed class Result { public string AmbientMode { get; set; } public double AmbientIntensity { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.skybox-set-ambient", Summary = "Set ambient lighting.", Description = "Set RenderSettings ambient values.", Group = "graphics",SideEffects = new[] { "settings-write" }, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Set flat ambient lighting", Input = new Request { Mode = "Flat", Intensity = 1f, Color = "#808080" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            AmbientMode? mode = string.IsNullOrEmpty(r.Mode) ? (AmbientMode?)null : GraphicsToolSupport.ParseEnum<AmbientMode>(r.Mode, "mode");
+            var intensity = r.Intensity.HasValue ? GraphicsToolSupport.ParseFinite(r.Intensity.Value.ToString(System.Globalization.CultureInfo.InvariantCulture), "intensity", 0f, 8f) : (float?)null;
+            Color? color = string.IsNullOrEmpty(r.Color) ? (Color?)null : GraphicsToolSupport.ParseColor(r.Color); Color? equator = string.IsNullOrEmpty(r.AmbientEquatorColor) ? (Color?)null : GraphicsToolSupport.ParseColor(r.AmbientEquatorColor); Color? ground = string.IsNullOrEmpty(r.AmbientGroundColor) ? (Color?)null : GraphicsToolSupport.ParseColor(r.AmbientGroundColor); Color? sky = string.IsNullOrEmpty(r.AmbientSkyColor) ? (Color?)null : GraphicsToolSupport.ParseColor(r.AmbientSkyColor);
+            if (!mode.HasValue && !intensity.HasValue && !color.HasValue && !equator.HasValue && !ground.HasValue && !sky.HasValue) return new System.Threading.Tasks.ValueTask<Result>(new Result { AmbientMode = RenderSettings.ambientMode.ToString(), AmbientIntensity = RenderSettings.ambientIntensity, PlannedEffects = new List<GraphicsPlannedEffect>() });
+            ctx.CommitEffect(); if (mode.HasValue) RenderSettings.ambientMode = mode.Value; if (intensity.HasValue) RenderSettings.ambientIntensity = intensity.Value; if (color.HasValue) RenderSettings.ambientLight = color.Value; if (equator.HasValue) RenderSettings.ambientEquatorColor = equator.Value; if (ground.HasValue) RenderSettings.ambientGroundColor = ground.Value; if (sky.HasValue) RenderSettings.ambientSkyColor = sky.Value;
+            if ((mode.HasValue && RenderSettings.ambientMode != mode.Value) || (intensity.HasValue && !Mathf.Approximately(RenderSettings.ambientIntensity, intensity.Value)) || (color.HasValue && !GraphicsToolSupport.SameColor(RenderSettings.ambientLight, color.Value)) || (equator.HasValue && !GraphicsToolSupport.SameColor(RenderSettings.ambientEquatorColor, equator.Value)) || (ground.HasValue && !GraphicsToolSupport.SameColor(RenderSettings.ambientGroundColor, ground.Value)) || (sky.HasValue && !GraphicsToolSupport.SameColor(RenderSettings.ambientSkyColor, sky.Value))) throw new UnityCliBridge.BridgeCommandException("E_AMBIENT_STATE_MISMATCH", "Ambient settings readback did not match the request.", "Retry after the editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { AmbientMode = RenderSettings.ambientMode.ToString(), AmbientIntensity = RenderSettings.ambientIntensity, PlannedEffects = new List<GraphicsPlannedEffect> { new GraphicsPlannedEffect { Type = "graphics.skybox-set-ambient", Property = "ambient", Value = "updated" } } });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/skybox-set-fog.cs

@@ -0,0 +1,24 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEngine;
+namespace UnityCli
+{
+    public class GraphicsSkyboxSetFogTool : IUnityCliTool<GraphicsSkyboxSetFogTool.Request, GraphicsSkyboxSetFogTool.Result>
+    {
+        public sealed class Request { public bool? Enabled { get; set; } public string Mode { get; set; } public string Color { get; set; } public float? Density { get; set; } public float? StartDistance { get; set; } public float? EndDistance { get; set; } }
+        public sealed class Result { public bool Fog { get; set; } public string FogMode { get; set; } public string FogColor { get; set; } public double FogDensity { get; set; } public double FogStartDistance { get; set; } public double FogEndDistance { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.skybox-set-fog", Summary = "Set fog.", Description = "Set RenderSettings fog values.", Group = "graphics",SideEffects = new[] { "settings-write" }, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Enable linear fog", Input = new Request { Enabled = true, Mode = "Linear", Color = "#808080", StartDistance = 0f, EndDistance = 100f } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            FogMode? mode = string.IsNullOrEmpty(r.Mode) ? (FogMode?)null : GraphicsToolSupport.ParseEnum<FogMode>(r.Mode, "mode"); var color = string.IsNullOrEmpty(r.Color) ? (Color?)null : GraphicsToolSupport.ParseColor(r.Color);
+            var density = r.Density.HasValue ? GraphicsToolSupport.ParseFinite(r.Density.Value.ToString(System.Globalization.CultureInfo.InvariantCulture), "density", 0f, 10f) : (float?)null; var start = r.StartDistance.HasValue ? GraphicsToolSupport.ParseFinite(r.StartDistance.Value.ToString(System.Globalization.CultureInfo.InvariantCulture), "startDistance", 0f, float.MaxValue) : (float?)null; var end = r.EndDistance.HasValue ? GraphicsToolSupport.ParseFinite(r.EndDistance.Value.ToString(System.Globalization.CultureInfo.InvariantCulture), "endDistance", 0f, float.MaxValue) : (float?)null;
+            if (start.HasValue && end.HasValue && end.Value < start.Value) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_RANGE_INVALID", "endDistance must not be less than startDistance.", "Pass an ordered fog distance range.");
+            if (!r.Enabled.HasValue && !mode.HasValue && !color.HasValue && !density.HasValue && !start.HasValue && !end.HasValue) return new System.Threading.Tasks.ValueTask<Result>(Read(new List<GraphicsPlannedEffect>()));
+            ctx.CommitEffect(); if (r.Enabled.HasValue) RenderSettings.fog = r.Enabled.Value; if (mode.HasValue) RenderSettings.fogMode = mode.Value; if (color.HasValue) RenderSettings.fogColor = color.Value; if (density.HasValue) RenderSettings.fogDensity = density.Value; if (start.HasValue) RenderSettings.fogStartDistance = start.Value; if (end.HasValue) RenderSettings.fogEndDistance = end.Value;
+            if ((r.Enabled.HasValue && RenderSettings.fog != r.Enabled.Value) || (mode.HasValue && RenderSettings.fogMode != mode.Value) || (color.HasValue && !GraphicsToolSupport.SameColor(RenderSettings.fogColor, color.Value)) || (density.HasValue && !Mathf.Approximately(RenderSettings.fogDensity, density.Value)) || (start.HasValue && !Mathf.Approximately(RenderSettings.fogStartDistance, start.Value)) || (end.HasValue && !Mathf.Approximately(RenderSettings.fogEndDistance, end.Value))) throw new UnityCliBridge.BridgeCommandException("E_FOG_STATE_MISMATCH", "Fog settings readback did not match the request.", "Retry after the editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(Read(new List<GraphicsPlannedEffect> { new GraphicsPlannedEffect { Type = "graphics.skybox-set-fog", Property = "fog", Value = "updated" } }));
+        }
+        private static Result Read(List<GraphicsPlannedEffect> effects) { return new Result { Fog = RenderSettings.fog, FogMode = RenderSettings.fogMode.ToString(), FogColor = GraphicsToolSupport.ColorHtml(RenderSettings.fogColor), FogDensity = RenderSettings.fogDensity, FogStartDistance = RenderSettings.fogStartDistance, FogEndDistance = RenderSettings.fogEndDistance, PlannedEffects = effects }; }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/skybox-set-material.cs

@@ -0,0 +1,33 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>graphics.skybox-set-material — 设置 RenderSettings.skybox 材质。</summary>
+    public class GraphicsSkyboxSetMaterialTool : IUnityCliTool<GraphicsSkyboxSetMaterialTool.Request, GraphicsSkyboxSetMaterialTool.Result>
+    {
+        public sealed class Request { public string Material { get; set; } }
+        public sealed class Result { public string Skybox { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.skybox-set-material", Summary = "Set the RenderSettings skybox material from an Assets/*.mat path.", Description = "Set RenderSettings.skybox. Accepts builtin:Default-Skybox to restore the built-in skybox.", Group = "graphics",DestructiveHint = false, SideEffects = new[] { "settings-write" }, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Set skybox material", Input = new Request { Material = "Assets/Skyboxes/Day.mat" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (string.IsNullOrEmpty(r.Material)) throw new UnityCliBridge.BridgeCommandException("E_MATERIAL_PATH_REQUIRED", "Pass --material <Assets/*.mat path>.", "Use tools run graphics.skybox-set-material --input '{\"material\":\"Assets/Skyboxes/Day.mat\"}'.");
+            var material = GraphicsToolSupport.ResolveSkyboxMaterial(r.Material);
+            if (material == null) throw new UnityCliBridge.BridgeCommandException("E_MATERIAL_NOT_FOUND", "Skybox material not found: " + r.Material, "Pass an existing Assets/*.mat path.");
+            var materialPath = AssetDatabase.GetAssetPath(material);
+            var materialGuid = string.IsNullOrEmpty(materialPath) ? null : AssetDatabase.AssetPathToGUID(materialPath);
+            ctx.CommitEffect();
+            RenderSettings.skybox = material;
+            UnityCliSceneMutation.MarkSceneDirty(UnityEngine.SceneManagement.SceneManager.GetActiveScene());
+            var observed = RenderSettings.skybox;
+            var observedPath = observed == null ? null : AssetDatabase.GetAssetPath(observed);
+            var observedGuid = string.IsNullOrEmpty(observedPath) ? null : AssetDatabase.AssetPathToGUID(observedPath);
+            if (observed == null || !string.Equals(observedGuid, materialGuid, System.StringComparison.Ordinal) || (materialGuid == null && observed != material)) throw new UnityCliBridge.BridgeCommandException("E_SKYBOX_MATERIAL_STATE_MISMATCH", "Skybox material GUID readback did not match the request.", "Retry after the editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { Skybox = observed.name, PlannedEffects = new List<GraphicsPlannedEffect> { new GraphicsPlannedEffect { Type = "graphics.skybox-set-material", Property = "skybox", Value = r.Material } } });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/skybox-set-properties.cs

@@ -0,0 +1,51 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>graphics.skybox-set-properties — 设置当前 skybox 材质的 shader 属性。</summary>
+    public class GraphicsSkyboxSetPropertiesTool : IUnityCliTool<GraphicsSkyboxSetPropertiesTool.Request, GraphicsSkyboxSetPropertiesTool.Result>
+    {
+        public sealed class Request { public string Property { get; set; } public string Value { get; set; } }
+        public sealed class Result { public string Skybox { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.skybox-set-properties", Summary = "Set a shader property on the current skybox material.", Description = "Set a float or color property on RenderSettings.skybox. Requires a skybox to be assigned first.", Group = "graphics",DestructiveHint = true, SideEffects = new[] { "settings-write" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Set exposure", Input = new Request { Property = "_Exposure", Value = "1.5" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var skybox = RenderSettings.skybox;
+            if (skybox == null) throw new UnityCliBridge.BridgeCommandException("E_SKYBOX_NOT_SET", "No skybox material is assigned to RenderSettings.", "Use graphics.skybox-set-material first.");
+            var effects = new List<GraphicsPlannedEffect>();
+            if (string.IsNullOrEmpty(r.Property) != string.IsNullOrEmpty(r.Value)) throw new UnityCliBridge.BridgeCommandException("E_SKYBOX_PROPERTY_INPUT_INVALID", "property and value must be provided together.", "Pass a material property and value.");
+            if (!string.IsNullOrEmpty(r.Property))
+            {
+                if (!skybox.HasProperty(r.Property)) throw new UnityCliBridge.BridgeCommandException("E_SKYBOX_PROPERTY_NOT_FOUND", "Skybox material does not contain property: " + r.Property, "Inspect the assigned skybox shader properties.");
+#if UNITY_2023_2_OR_NEWER
+                var pt = skybox.GetPropertyType(r.Property).ToString();
+#else
+                var shader = skybox.shader; var idx = shader.FindPropertyIndex(r.Property); var pt = UnityEditor.ShaderUtil.GetPropertyType(shader, idx).ToString();
+#endif
+                var color = pt == "Color" ? (Color?)GraphicsToolSupport.ParseColor(r.Value) : (Color?)null;
+                var number = pt == "Float" || pt == "Range" ? (float?)GraphicsToolSupport.ParseFinite(r.Value, r.Property, -1000000f, 1000000f) : (float?)null;
+                int parsedInt = 0;
+                var isInt = pt == "Int";
+                if (isInt && !int.TryParse(r.Value, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out parsedInt)) throw new UnityCliBridge.BridgeCommandException("E_SKYBOX_PROPERTY_INPUT_INVALID", "Invalid integer value for " + r.Property + ".", "Pass an integer value for an Int shader property.");
+                if (!color.HasValue && !number.HasValue && !isInt) throw new UnityCliBridge.BridgeCommandException("E_SKYBOX_PROPERTY_TYPE_UNSUPPORTED", "Skybox property " + r.Property + " has unsupported shader type " + pt + ".", "Only Color, Float, Range, and Int properties can be set by this command.");
+                var skyboxPath = AssetDatabase.GetAssetPath(skybox);
+                var skyboxGuid = string.IsNullOrEmpty(skyboxPath) ? null : AssetDatabase.AssetPathToGUID(skyboxPath);
+                if (string.IsNullOrEmpty(skyboxPath) || string.IsNullOrEmpty(skyboxGuid) || !skyboxPath.StartsWith("Assets/", System.StringComparison.OrdinalIgnoreCase)) throw new UnityCliBridge.BridgeCommandException("E_SKYBOX_ASSET_PATH_INVALID", "Skybox material must be a writable Assets/ material for verified property writes.", "Assign an Assets/*.mat skybox material first.");
+                ctx.CommitEffect();
+                if (color.HasValue) skybox.SetColor(r.Property, color.Value); else if (number.HasValue) skybox.SetFloat(r.Property, number.Value); else skybox.SetInt(r.Property, parsedInt);
+                EditorUtility.SetDirty(skybox);
+                AssetDatabase.SaveAssetIfDirty(skybox);
+                var observed = GraphicsToolSupport.ReloadAsset<Material>(skyboxPath, skyboxGuid);
+                if (observed == null || (color.HasValue && !GraphicsToolSupport.SameColor(observed.GetColor(r.Property), color.Value)) || (number.HasValue && !Mathf.Approximately(observed.GetFloat(r.Property), number.Value)) || (isInt && observed.GetInt(r.Property) != parsedInt)) throw new UnityCliBridge.BridgeCommandException("E_SKYBOX_PROPERTY_STATE_MISMATCH", "Skybox property readback did not match the request.", "Retry after the editor is idle.");
+                skybox = observed;
+                effects.Add(new GraphicsPlannedEffect { Type = "graphics.skybox-set-properties", Property = r.Property, Value = r.Value });
+            }
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { Skybox = skybox.name, PlannedEffects = effects });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/skybox-set-reflection.cs

@@ -0,0 +1,31 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+namespace UnityCli
+{
+    public class GraphicsSkyboxSetReflectionTool : IUnityCliTool<GraphicsSkyboxSetReflectionTool.Request, GraphicsSkyboxSetReflectionTool.Result>
+    {
+        public sealed class Request { public string Mode { get; set; } public int? Bounces { get; set; } public float? Intensity { get; set; } public string Resolution { get; set; } }
+        public sealed class Result { public string DefaultReflectionMode { get; set; } public long ReflectionBounces { get; set; } public double ReflectionIntensity { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.skybox-set-reflection", Summary = "Set reflection settings.", Description = "Set RenderSettings reflection values.", Group = "graphics",SideEffects = new[] { "settings-write" }, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Configure skybox reflections", Input = new Request { Mode = "Skybox", Bounces = 1, Intensity = 1f, Resolution = "128" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            DefaultReflectionMode? mode = string.IsNullOrEmpty(r.Mode) ? (DefaultReflectionMode?)null : GraphicsToolSupport.ParseEnum<DefaultReflectionMode>(r.Mode, "mode"); if (r.Bounces.HasValue && (r.Bounces.Value < 0 || r.Bounces.Value > 100)) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_RANGE_INVALID", "Invalid reflection bounces.", "Pass bounces from 0 to 100."); var intensity = r.Intensity.HasValue ? GraphicsToolSupport.ParseFinite(r.Intensity.Value.ToString(System.Globalization.CultureInfo.InvariantCulture), "intensity", 0f, 8f) : (float?)null;
+            int? resolution = null;
+            if (!string.IsNullOrEmpty(r.Resolution))
+            {
+                int parsed;
+                if (!int.TryParse(r.Resolution, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out parsed) || parsed < 16 || parsed > 8192 || (parsed & (parsed - 1)) != 0)
+                    throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_RANGE_INVALID", "Invalid reflection resolution.", "Pass a power-of-two resolution from 16 to 8192.");
+                resolution = parsed;
+            }
+            if (!mode.HasValue && !r.Bounces.HasValue && !intensity.HasValue && !resolution.HasValue) return new System.Threading.Tasks.ValueTask<Result>(Read(new List<GraphicsPlannedEffect>()));
+            ctx.CommitEffect(); if (mode.HasValue) RenderSettings.defaultReflectionMode = mode.Value; if (r.Bounces.HasValue) RenderSettings.reflectionBounces = r.Bounces.Value; if (intensity.HasValue) RenderSettings.reflectionIntensity = intensity.Value; if (resolution.HasValue) RenderSettings.defaultReflectionResolution = resolution.Value;
+            if ((mode.HasValue && RenderSettings.defaultReflectionMode != mode.Value) || (r.Bounces.HasValue && RenderSettings.reflectionBounces != r.Bounces.Value) || (intensity.HasValue && !Mathf.Approximately(RenderSettings.reflectionIntensity, intensity.Value)) || (resolution.HasValue && RenderSettings.defaultReflectionResolution != resolution.Value)) throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_STATE_MISMATCH", "Reflection settings readback did not match the request.", "Retry after the editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(Read(new List<GraphicsPlannedEffect> { new GraphicsPlannedEffect { Type = "graphics.skybox-set-reflection", Property = "reflection", Value = "updated" } }));
+        }
+        private static Result Read(List<GraphicsPlannedEffect> effects) { return new Result { DefaultReflectionMode = RenderSettings.defaultReflectionMode.ToString(), ReflectionBounces = RenderSettings.reflectionBounces, ReflectionIntensity = RenderSettings.reflectionIntensity, PlannedEffects = effects }; }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/skybox-set-sun.cs

@@ -0,0 +1,35 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>graphics.skybox-set-sun — 设置 RenderSettings.sun 方向光。</summary>
+    public class GraphicsSkyboxSetSunTool : IUnityCliTool<GraphicsSkyboxSetSunTool.Request, GraphicsSkyboxSetSunTool.Result>
+    {
+        public sealed class Request { public string Target { get; set; } }
+        public sealed class Result { public string Sun { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.skybox-set-sun", Summary = "Set the directional Light used as the scene sun for RenderSettings.", Description = "Set RenderSettings.sun from a target GameObject with a Light component. Pass null/empty to clear.", Group = "graphics",DestructiveHint = false, SideEffects = new[] { "settings-write" }, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Set sun light", Input = new Request { Target = "DirectionalLight" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            Light sun = null;
+            var expectedId = 0;
+            if (!string.IsNullOrEmpty(r.Target))
+            {
+                var go = GameObjectToolSupport.ResolveUniqueTarget(r.Target, "graphics.skybox-set-sun requires --target <go>.");
+                sun = go.GetComponent<Light>();
+                if (sun == null || sun.type != LightType.Directional) throw new UnityCliBridge.BridgeCommandException("E_DIRECTIONAL_LIGHT_REQUIRED", "Target must have a Directional Light component: " + GameObjectToolSupport.HierarchyPath(go), "Pass a GameObject with a directional Light component.");
+                expectedId = sun.GetInstanceID();
+            }
+            ctx.CommitEffect();
+            RenderSettings.sun = sun;
+            var observed = RenderSettings.sun;
+            if ((expectedId == 0 && observed != null) || (expectedId != 0 && (observed == null || observed.GetInstanceID() != expectedId))) throw new UnityCliBridge.BridgeCommandException("E_SKYBOX_SUN_STATE_MISMATCH", "Skybox sun readback did not match the requested target.", "Retry after the editor is idle.");
+            var sunPath = observed == null ? "null" : GameObjectToolSupport.HierarchyPath(observed.gameObject);
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { Sun = sunPath, PlannedEffects = new List<GraphicsPlannedEffect> { new GraphicsPlannedEffect { Type = "graphics.skybox-set-sun", Property = "sun", Value = sunPath } } });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/stats-counters.cs

@@ -0,0 +1,28 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>graphics.stats-counters — 读取渲染统计计数器列表。</summary>
+    public class GraphicsStatsCountersTool : IUnityCliTool<GraphicsStatsCountersTool.Request, GraphicsStatsCountersTool.Result>
+    {
+        public sealed class Request { }
+        public sealed class Result { public List<GraphicsPlannedEffect> Counters { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.stats-counters", Summary = "Read render stats as a flat counter list (drawCalls, batches, triangles, vertices, setPass, renderTextures).", Description = "Read-only: returns render stats as key-value counter entries.", Group = "graphics",DestructiveHint = false, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Read counters", Input = new Request { } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var s = GraphicsToolSupport.BuildRenderStats();
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { Counters = new List<GraphicsPlannedEffect> {
+                new GraphicsPlannedEffect { Property = "drawCalls", Value = s.DrawCalls.ToString() },
+                new GraphicsPlannedEffect { Property = "batches", Value = s.Batches.ToString() },
+                new GraphicsPlannedEffect { Property = "triangles", Value = s.Triangles.ToString() },
+                new GraphicsPlannedEffect { Property = "vertices", Value = s.Vertices.ToString() },
+                new GraphicsPlannedEffect { Property = "setPassCalls", Value = s.SetPassCalls.ToString() },
+                new GraphicsPlannedEffect { Property = "renderTextureCount", Value = s.RenderTextureCount.ToString() },
+            } });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/stats-memory.cs

@@ -0,0 +1,21 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>graphics.stats-memory — 读取渲染内存统计。</summary>
+    public class GraphicsStatsMemoryTool : IUnityCliTool<GraphicsStatsMemoryTool.Request, GraphicsStatsMemoryTool.Result>
+    {
+        public sealed class Request { }
+        public sealed class Result { public long UsedTextureMemory { get; set; } public long RenderTextureBytes { get; set; } public long UsedVertexBuffer { get; set; } public long UsedVertexBufferVRAM { get; set; } public long RenderTextureCount { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.stats-memory", Summary = "Read render memory statistics (texture memory, render texture bytes, vertex buffer).", Description = "Read-only: returns GPU memory usage from render stats.", Group = "graphics",DestructiveHint = false, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Read memory stats", Input = new Request { } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var s = GraphicsToolSupport.BuildRenderStats();
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { UsedTextureMemory = s.UsedTextureMemory, RenderTextureBytes = s.RenderTextureBytes, UsedVertexBuffer = s.UsedVertexBuffer, UsedVertexBufferVRAM = s.UsedVertexBufferVRAM, RenderTextureCount = s.RenderTextureCount });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/stats.cs

@@ -0,0 +1,17 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>graphics.stats — 读取渲染统计(drawCalls/batches/triangles/vertices 等)。</summary>
+    public class GraphicsStatsTool : IUnityCliTool<GraphicsStatsTool.Request, GraphicsStatsTool.Result>
+    {
+        public sealed class Request { }
+        public sealed class Result { public RenderStatsInfo Stats { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.stats", Summary = "Read current render statistics (draw calls, batches, triangles, vertices, memory).", Description = "Read-only: returns a unified render stats snapshot from RenderStats (Unity 6) or UnityStats (2022.3).", Group = "graphics",DestructiveHint = false, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Read render stats", Input = new Request { } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default) => new System.Threading.Tasks.ValueTask<Result>(new Result { Stats = GraphicsToolSupport.BuildRenderStats() });
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/volume.cs

@@ -0,0 +1,59 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>graphics.volume — 列出场景中的 Volume 组件(通过反射,兼容 URP/HDRP)。</summary>
+    public class GraphicsVolumeTool : IUnityCliTool<GraphicsVolumeTool.Request, GraphicsVolumeTool.Result>
+    {
+        public sealed class Request { public string Target { get; set; } public int PageSize { get; set; } public string Cursor { get; set; } }
+        public sealed class Result { public List<VolumeInfo> Volumes { get; set; } public long Count { get; set; } public PageInfo PageInfo { get; set; } }
+        public sealed class PageInfo { public bool HasMore { get; set; } public long PageSize { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.volume", Summary = "List Volume components in the scene, optionally filtered by target.", Description = "Find Volume components (URP/HDRP) via reflection. Filter by GameObject name or hierarchy path and return count plus page metadata. This Tool is read-only.", Group = "graphics",DestructiveHint = false, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "List all volumes", Input = new Request { PageSize = 100 } } } };
+        /// <summary>读取 pipeline-neutral Volume 列表，并保留旧读取入口的 count/pageInfo contract。</summary>
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            r = r ?? new Request();
+            var pageSize = r.PageSize == 0 ? 100 : r.PageSize;
+            var volumes = new List<VolumeInfo>();
+            var volumeType = GraphicsToolSupport.FindType("UnityEngine.Rendering.Volume");
+            if (volumeType == null) return new System.Threading.Tasks.ValueTask<Result>(BuildResult(volumes, pageSize));
+            foreach (var component in Resources.FindObjectsOfTypeAll(volumeType))
+            {
+                var typed = component as Component;
+                if (typed == null || typed.gameObject == null) continue;
+                if (EditorUtility.IsPersistent(typed.gameObject)) continue;
+                if (!string.IsNullOrEmpty(r.Target) && !GameObjectToolSupport.HierarchyPath(typed.gameObject).Equals(r.Target, System.StringComparison.OrdinalIgnoreCase) && !typed.gameObject.name.Equals(r.Target, System.StringComparison.OrdinalIgnoreCase)) continue;
+                var type = typed.GetType();
+                var enabledProp = type.GetProperty("enabled", BindingFlags.Instance | BindingFlags.Public);
+                var isGlobalField = type.GetField("isGlobal", BindingFlags.Instance | BindingFlags.Public);
+                var priorityField = type.GetField("priority", BindingFlags.Instance | BindingFlags.Public);
+                var weightField = type.GetField("weight", BindingFlags.Instance | BindingFlags.Public);
+                var profile = GraphicsToolSupport.MemberValue(type, typed, "profile") as UnityEngine.Object;
+                var sharedProfile = GraphicsToolSupport.MemberValue(type, typed, "sharedProfile") as UnityEngine.Object;
+                var effectiveProfile = profile ?? sharedProfile;
+                volumes.Add(new VolumeInfo
+                {
+                    Target = new GameObjectTargetRef { Id = typed.gameObject.GetInstanceID(), Name = typed.gameObject.name, Path = GameObjectToolSupport.HierarchyPath(typed.gameObject) },
+                    Enabled = enabledProp == null || (bool)enabledProp.GetValue(typed, null),
+                    IsGlobal = isGlobalField != null && (bool)isGlobalField.GetValue(typed),
+                    Priority = priorityField == null ? 0 : (float)priorityField.GetValue(typed),
+                    Weight = weightField == null ? 0 : (float)weightField.GetValue(typed),
+                    Profile = effectiveProfile == null ? null : new AssetRef { Name = effectiveProfile.name, Path = AssetDatabase.GetAssetPath(effectiveProfile) }
+                });
+            }
+            return new System.Threading.Tasks.ValueTask<Result>(BuildResult(volumes, pageSize));
+        }
+
+        // 当前读取保持全量结果；pageInfo 仅投影请求 pageSize 与 terminal 状态。
+        private static Result BuildResult(List<VolumeInfo> volumes, int pageSize)
+        {
+            return new Result { Volumes = volumes, Count = volumes.Count, PageInfo = new PageInfo { HasMore = false, PageSize = pageSize } };
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/instances/list.cs

@@ -0,0 +1,71 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using System.IO;
+using UnityEngine;
+
+namespace UnityCli.Tools.Instances
+{
+    /// <summary>
+    /// instances.list 只读 Tool：读取当前 Unity Bridge 进程自身实例摘要。
+    /// </summary>
+    public class InstancesListTool : IUnityCliTool<InstancesListTool.Request, InstancesListTool.Result>
+    {
+        public sealed class Request { }
+
+        public sealed class InstanceInfo
+        {
+            public string InstanceId { get; set; }
+            public string ProjectPath { get; set; }
+            public string UnityVersion { get; set; }
+            public string Status { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public List<InstanceInfo> Instances { get; set; }
+            public long Count { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "instances.list",
+            Summary = "Read the current logical Unity project instance summary from the live Editor process.",
+            Description = "Read the CanonicalPath v1 project identity, canonical project path, Unity version, and ready status visible to the current Editor process.",
+            DestructiveHint = false,
+            Group = "instances",
+            Target = "editor",
+            PlayModeSupport = "supported",
+            Examples = new[] { new ToolExample { Description = "Read the current Bridge instance", Input = new Request { } } }
+        };
+
+        /// <summary>读取当前 Editor 的逻辑项目 identity 和业务 readiness 摘要。</summary>
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var identity = UnityCliCanonicalProjectPath.Resolve(ProjectRoot(ctx));
+            var instances = new List<InstanceInfo>
+            {
+                new InstanceInfo
+                {
+                    InstanceId = identity.InstanceId,
+                    ProjectPath = identity.CanonicalProjectPath,
+                    UnityVersion = Application.unityVersion,
+                    Status = "ready"
+                }
+            };
+
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                Instances = instances,
+                Count = instances.Count
+            });
+        }
+
+        // 优先使用 registry 注入的项目路径；缺失时回退到当前 Unity project root。
+        private static string ProjectRoot(UnityCliProjectToolContext ctx)
+        {
+            if (ctx != null && !string.IsNullOrEmpty(ctx.ProjectPath)) return ctx.ProjectPath;
+            return Path.GetDirectoryName(Application.dataPath);
+        }
+    }
+}
+#endif