@alpsckr/unitycli 0.4.0

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

@@ -0,0 +1,396 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+using System.Security.Cryptography;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// graphics 域 IUnityCliTool 共享 helper:渲染管线摘要、QualitySettings、Volume 反射、
+    /// 渲染统计、颜色解析、天空盒环境设置。仅供 graphics 域自包含工具复用。
+    /// </summary>
+    public static class GraphicsToolSupport
+    {
+        /// <summary>拦截编译/导入/构建/PlayMode 过渡期的写入请求。</summary>
+        public static void EnsureEditorNotBusy(string command)
+        {
+            SceneToolSupport.EnsureEditorNotBusy(command);
+        }
+
+        /// <summary>Color 转 #RRGGBBAA 十六进制字符串。</summary>
+        public static string ColorHtml(Color color)
+        {
+            return string.Format(CultureInfo.InvariantCulture, "#{0:X2}{1:X2}{2:X2}{3:X2}", (int)(color.r * 255f), (int)(color.g * 255f), (int)(color.b * 255f), (int)(color.a * 255f));
+        }
+
+        /// <summary>解析并校验颜色字符串。</summary>
+        public static Color ParseColor(string value)
+        {
+            if (string.IsNullOrEmpty(value)) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_COLOR_INVALID", "Color is required.", "Pass #RRGGBB, #RRGGBBAA, or components in the range 0..1.");
+            if (value.StartsWith("#"))
+            {
+                var hex = value.Substring(1);
+                if (hex.Length != 6 && hex.Length != 8) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_COLOR_INVALID", "Invalid color: " + value, "Pass #RRGGBB or #RRGGBBAA.");
+                if (hex.Length == 6) hex += "FF";
+                int r, g, b, a;
+                if (!int.TryParse(hex.Substring(0, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out r) || !int.TryParse(hex.Substring(2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out g) || !int.TryParse(hex.Substring(4, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out b) || !int.TryParse(hex.Substring(6, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out a)) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_COLOR_INVALID", "Invalid color: " + value, "Pass hexadecimal color components.");
+                return new Color(r / 255f, g / 255f, b / 255f, a / 255f);
+            }
+            var parts = value.Split(',');
+            if (parts.Length != 3 && parts.Length != 4) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_COLOR_INVALID", "Invalid color: " + value, "Pass three or four components in the range 0..1.");
+            return new Color(ParseFinite(parts[0], "color.r", 0f, 1f), ParseFinite(parts[1], "color.g", 0f, 1f), ParseFinite(parts[2], "color.b", 0f, 1f), parts.Length == 4 ? ParseFinite(parts[3], "color.a", 0f, 1f) : 1f);
+        }
+
+        public static float ParseFinite(string value, string property, float minimum, float maximum)
+        {
+            float parsed;
+            if (!float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out parsed) || float.IsNaN(parsed) || float.IsInfinity(parsed) || parsed < minimum || parsed > maximum)
+                throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_RANGE_INVALID", "Invalid " + property + ": " + value, "Pass a finite value in the supported range.");
+            return parsed;
+        }
+
+        public static T ParseEnum<T>(string raw, string property) where T : struct
+        {
+            T value;
+            if (string.IsNullOrEmpty(raw) || !Enum.TryParse<T>(raw, true, out value) || !Enum.IsDefined(typeof(T), value)) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_ENUM_INVALID", "Invalid " + property + ": " + raw, "Pass a supported " + typeof(T).Name + " value.");
+            return value;
+        }
+
+        public static string NormalizeAssetPathRequired(string raw, string extension)
+        {
+            var path = SceneToolSupport.NormalizeAssetPath(raw);
+            if (string.IsNullOrEmpty(path) || !path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase) || !path.EndsWith(extension, StringComparison.OrdinalIgnoreCase)) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_ASSET_PATH_INVALID", "Invalid asset path: " + raw, "Pass an Assets/ path ending in " + extension + ".");
+            return path;
+        }
+
+        /// <summary>保存并从记录的 Unity asset path/GUID 重新获取资产，避免使用写入前对象作为读回证明。</summary>
+        public static T ReloadAsset<T>(string path, string guid) where T : UnityEngine.Object
+        {
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+            var resolvedPath = string.IsNullOrEmpty(guid) ? path : AssetDatabase.GUIDToAssetPath(guid);
+            if (string.IsNullOrEmpty(resolvedPath) || (!string.IsNullOrEmpty(path) && !string.Equals(path, resolvedPath, StringComparison.Ordinal))) return null;
+            return AssetDatabase.LoadAssetAtPath<T>(resolvedPath);
+        }
+
+        public static bool IsValidTextureLod(int value) { return value >= 0 && value <= 8; }
+        public static bool IsValidMaximumLod(int value) { return value >= 0 && value <= 100000; }
+
+        public static string FileSha256(byte[] bytes) { using (var sha = SHA256.Create()) return string.Concat(Array.ConvertAll(sha.ComputeHash(bytes), value => value.ToString("x2"))); }
+        public static bool SameColor(Color actual, Color expected) { return Mathf.Approximately(actual.r, expected.r) && Mathf.Approximately(actual.g, expected.g) && Mathf.Approximately(actual.b, expected.b) && Mathf.Approximately(actual.a, expected.a); }
+
+        /// <summary>解析 Vector3 数组字符串("x,y,z x,y,z ...")。</summary>
+        public static Vector3[] ParseVector3Array(string value)
+        {
+            if (string.IsNullOrEmpty(value)) return new Vector3[0];
+            var items = value.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
+            var list = new List<Vector3>();
+            foreach (var item in items)
+            {
+                var trimmed = item.Trim('[', ']', '(', ')');
+                if (!string.IsNullOrEmpty(trimmed)) list.Add(GameObjectToolSupport.ParseVector3(trimmed));
+            }
+            return list.ToArray();
+        }
+
+        /// <summary>解析 QualityLevel:数字或名称。</summary>
+        public static int ResolveQualityLevel(string rawLevel)
+        {
+            int level;
+            if (int.TryParse(rawLevel, NumberStyles.Integer, CultureInfo.InvariantCulture, out level))
+            {
+                if (level >= 0 && level < QualitySettings.names.Length) return level;
+            }
+            for (var i = 0; i < QualitySettings.names.Length; i++)
+            {
+                if (string.Equals(QualitySettings.names[i], rawLevel, StringComparison.OrdinalIgnoreCase)) return i;
+            }
+            throw new UnityCliBridge.BridgeCommandException("E_QUALITY_LEVEL_INVALID", "Quality level is invalid: " + rawLevel, "Run tools run graphics.quality --input '{}' to inspect available quality level names and indexes.");
+        }
+
+        /// <summary>构造渲染管线摘要 DTO。</summary>
+        public static GraphicsSummary BuildGraphicsSummary()
+        {
+            var pipeline = GraphicsSettings.defaultRenderPipeline;
+            return new GraphicsSummary
+            {
+                RenderPipeline = new RenderPipelineSummary
+                {
+                    Active = RenderPipelineSummaryName(),
+                    DefaultAsset = pipeline == null ? null : pipeline.name,
+                    DefaultAssetPath = pipeline == null ? null : SceneToolSupport.NormalizeAssetPath(AssetDatabase.GetAssetPath(pipeline))
+                },
+                CurrentQualityLevel = QualitySettings.GetQualityLevel(),
+                QualityLevelName = QualitySettings.names.Length > QualitySettings.GetQualityLevel() ? QualitySettings.names[QualitySettings.GetQualityLevel()] : null
+            };
+        }
+
+        private static string RenderPipelineSummaryName()
+        {
+            if (GraphicsSettings.currentRenderPipeline != null) return GraphicsSettings.currentRenderPipeline.GetType().Name;
+            return GraphicsSettings.defaultRenderPipeline != null ? GraphicsSettings.defaultRenderPipeline.GetType().Name : "Built-in";
+        }
+
+        /// <summary>构造 QualitySettings DTO。</summary>
+        public static QualitySettingsInfo BuildQualitySettings()
+        {
+            return new QualitySettingsInfo
+            {
+                Names = new List<string>(QualitySettings.names),
+                CurrentLevel = QualitySettings.GetQualityLevel(),
+                VSyncCount = QualitySettings.vSyncCount,
+                AntiAliasing = QualitySettings.antiAliasing,
+                ShadowDistance = QualitySettings.shadowDistance,
+                MasterTextureLimit = QualitySettings.globalTextureMipmapLimit,
+                LodBias = QualitySettings.lodBias,
+                MaximumLODLevel = QualitySettings.maximumLODLevel,
+                AnisotropicFiltering = QualitySettings.anisotropicFiltering.ToString(),
+                Shadows = QualitySettings.shadows.ToString(),
+                ShadowResolution = QualitySettings.shadowResolution.ToString(),
+                RealtimeReflectionProbes = QualitySettings.realtimeReflectionProbes,
+                SoftParticles = QualitySettings.softParticles
+            };
+        }
+
+        /// <summary>解析 skybox 材质路径,允许 builtin:Default-Skybox。</summary>
+        public static Material ResolveSkyboxMaterial(string path)
+        {
+            if (string.Equals(path, "builtin:Default-Skybox", StringComparison.OrdinalIgnoreCase) || string.Equals(path, "Default-Skybox", StringComparison.OrdinalIgnoreCase))
+                return AssetDatabase.GetBuiltinExtraResource<Material>("Default-Skybox.mat");
+            return AssetDatabase.LoadAssetAtPath<Material>(SceneToolSupport.NormalizeAssetPath(path));
+        }
+
+        /// <summary>通过反射查找类型(跨程序集)。</summary>
+        public static Type FindType(string fullName)
+        {
+            return GameObjectToolSupport.FindType(fullName);
+        }
+
+        /// <summary>反射读取对象成员值。</summary>
+        public static object MemberValue(Type type, object obj, string memberName)
+        {
+            var prop = type.GetProperty(memberName, BindingFlags.Instance | BindingFlags.Public);
+            if (prop != null) return prop.GetValue(obj, null);
+            var field = type.GetField(memberName, BindingFlags.Instance | BindingFlags.Public);
+            if (field != null) return field.GetValue(obj);
+            return null;
+        }
+
+        /// <summary>构造 ReflectionProbe 摘要 DTO。</summary>
+        public static ReflectionProbeInfo BuildReflectionProbeInfo(ReflectionProbe probe)
+        {
+#if UNITY_2023_2_OR_NEWER
+            return new ReflectionProbeInfo { Mode = probe.mode.ToString(), Resolution = probe.resolution, Bounces = probe.bounces, Hdr = probe.hdr, Importance = probe.importance, Size = new Vector3Data(probe.size), Center = new Vector3Data(probe.center) };
+#else
+            return new ReflectionProbeInfo { Mode = probe.mode.ToString(), Resolution = probe.resolution, Bounces = RenderSettings.reflectionBounces, Hdr = probe.hdr, Importance = probe.importance, Size = new Vector3Data(probe.size), Center = new Vector3Data(probe.center) };
+#endif
+        }
+
+        private struct RenderStatsSnapshot
+        {
+            public long DrawCalls, BatchedDrawCalls, Batches, SavedByBatches, Triangles, Vertices;
+            public string ScreenRes;
+            public long UsedTextureMemory, RenderTextureCount, RenderTextureBytes, UsedVertexBuffer, UsedVertexBufferVRAM, SetPassCalls;
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
+        private static RenderStatsSnapshot CaptureRenderStats()
+        {
+#if UNITY_2023_2_OR_NEWER
+            var stats = UnityEngine.Rendering.RenderStats.current;
+            return new RenderStatsSnapshot
+            {
+                DrawCalls = stats.drawCalls, BatchedDrawCalls = stats.batchedDrawCalls, Batches = stats.batches,
+                SavedByBatches = stats.savedByBatches, Triangles = stats.triangles, Vertices = stats.vertices,
+                ScreenRes = stats.screenRes, UsedTextureMemory = stats.usedTextureMemory,
+                RenderTextureCount = stats.renderTextureCount, RenderTextureBytes = stats.renderTextureBytes,
+                UsedVertexBuffer = stats.usedVertexBuffer, UsedVertexBufferVRAM = stats.usedVertexBufferVRAM, SetPassCalls = stats.setPass
+            };
+#else
+            var drawCalls = UnityEditor.UnityStats.drawCalls;
+            var batches = UnityEditor.UnityStats.batches;
+            var batchedDrawCalls = UnityEditor.UnityStats.dynamicBatchedDrawCalls + UnityEditor.UnityStats.staticBatchedDrawCalls + UnityEditor.UnityStats.instancedBatchedDrawCalls;
+            return new RenderStatsSnapshot
+            {
+                DrawCalls = drawCalls, BatchedDrawCalls = batchedDrawCalls, Batches = batches, SavedByBatches = drawCalls - batches,
+                Triangles = UnityEditor.UnityStats.triangles, Vertices = UnityEditor.UnityStats.vertices,
+                ScreenRes = UnityEditor.UnityStats.screenRes, UsedTextureMemory = UnityEditor.UnityStats.usedTextureMemorySize,
+                RenderTextureCount = UnityEditor.UnityStats.renderTextureCount, RenderTextureBytes = UnityEditor.UnityStats.renderTextureBytes,
+                UsedVertexBuffer = UnityEditor.UnityStats.vboTotalBytes, UsedVertexBufferVRAM = 0, SetPassCalls = UnityEditor.UnityStats.setPassCalls
+            };
+#endif
+        }
+
+        /// <summary>构造渲染统计 DTO。</summary>
+        public static RenderStatsInfo BuildRenderStats()
+        {
+            var s = CaptureRenderStats();
+            return new RenderStatsInfo
+            {
+                DrawCalls = s.DrawCalls, BatchedDrawCalls = s.BatchedDrawCalls, Batches = s.Batches, SavedByBatching = s.SavedByBatches,
+                Triangles = s.Triangles, Vertices = s.Vertices, ScreenRes = s.ScreenRes,
+                UsedTextureMemory = s.UsedTextureMemory, RenderTextureCount = s.RenderTextureCount, RenderTextureBytes = s.RenderTextureBytes,
+                UsedVertexBuffer = s.UsedVertexBuffer, UsedVertexBufferVRAM = s.UsedVertexBufferVRAM, SetPassCalls = s.SetPassCalls
+            };
+        }
+    }
+
+    // ── graphics 域 DTO ──
+
+    public sealed class GraphicsSummary
+    {
+        public RenderPipelineSummary RenderPipeline { get; set; }
+        public long CurrentQualityLevel { get; set; }
+        public string QualityLevelName { get; set; }
+    }
+
+    public sealed class RenderPipelineSummary
+    {
+        public string Active { get; set; }
+        public string DefaultAsset { get; set; }
+        public string DefaultAssetPath { get; set; }
+    }
+
+    public sealed class QualitySettingsInfo
+    {
+        public List<string> Names { get; set; }
+        public long CurrentLevel { get; set; }
+        public long VSyncCount { get; set; }
+        public long AntiAliasing { get; set; }
+        public double ShadowDistance { get; set; }
+        public long MasterTextureLimit { get; set; }
+        public double LodBias { get; set; }
+        public long MaximumLODLevel { get; set; }
+        public string AnisotropicFiltering { get; set; }
+        public string Shadows { get; set; }
+        public string ShadowResolution { get; set; }
+        public bool RealtimeReflectionProbes { get; set; }
+        public bool SoftParticles { get; set; }
+    }
+
+    public sealed class RenderStatsInfo
+    {
+        public long DrawCalls { get; set; }
+        public long BatchedDrawCalls { get; set; }
+        public long Batches { get; set; }
+        public long SavedByBatching { get; set; }
+        public long Triangles { get; set; }
+        public long Vertices { get; set; }
+        public string ScreenRes { get; set; }
+        public long UsedTextureMemory { get; set; }
+        public long RenderTextureCount { get; set; }
+        public long RenderTextureBytes { get; set; }
+        public long UsedVertexBuffer { get; set; }
+        public long UsedVertexBufferVRAM { get; set; }
+        public long SetPassCalls { get; set; }
+    }
+
+    public sealed class VolumeInfo
+    {
+        public GameObjectTargetRef Target { get; set; }
+        public bool Enabled { get; set; }
+        public bool IsGlobal { get; set; }
+        public double Priority { get; set; }
+        public double Weight { get; set; }
+        public AssetRef Profile { get; set; }
+    }
+
+    public sealed class AssetRef
+    {
+        public string Name { get; set; }
+        public string Path { get; set; }
+        public string Guid { get; set; }
+    }
+
+    public sealed class LightingSettingsInfo
+    {
+        public string LightingMode { get; set; }
+        public bool BakedGI { get; set; }
+        public bool RealtimeGI { get; set; }
+        public long DirectSamples { get; set; }
+        public long IndirectSamples { get; set; }
+        public long EnvironmentSamples { get; set; }
+        public long Bounces { get; set; }
+        public string Filtering { get; set; }
+        public double IndirectResolution { get; set; }
+    }
+
+    public sealed class BakeModeInfo
+    {
+        public string LightingMode { get; set; }
+        public long GiWorkflowMode { get; set; }
+    }
+
+    public sealed class ReflectionProbeInfo
+    {
+        public string Mode { get; set; }
+        public long Resolution { get; set; }
+        public long Bounces { get; set; }
+        public bool Hdr { get; set; }
+        public long Importance { get; set; }
+        public Vector3Data Size { get; set; }
+        public Vector3Data Center { get; set; }
+    }
+
+    public sealed class SkyboxInfo
+    {
+        public AssetRef Skybox { get; set; }
+        public SunInfo Sun { get; set; }
+        public AmbientInfo Ambient { get; set; }
+        public FogInfo Fog { get; set; }
+        public ReflectionInfo Reflection { get; set; }
+    }
+
+    public sealed class SunInfo
+    {
+        public string Name { get; set; }
+        public string Path { get; set; }
+    }
+
+    public sealed class AmbientInfo
+    {
+        public string AmbientMode { get; set; }
+        public double AmbientIntensity { get; set; }
+        public Vector3Data AmbientLight { get; set; }
+    }
+
+    public sealed class FogInfo
+    {
+        public bool Enabled { 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 sealed class ReflectionInfo
+    {
+        public string AmbientMode { get; set; }
+        public long ReflectionBounces { get; set; }
+        public double ReflectionIntensity { get; set; }
+    }
+
+    public sealed class GraphicsPlannedEffect
+    {
+        public string Type { get; set; }
+        public string Property { get; set; }
+        public string Value { get; set; }
+        public string Target { get; set; }
+    }
+
+    public sealed class ScreenshotData
+    {
+        public string ScreenshotPath { get; set; }
+        public string ArtifactPath { get; set; }
+        public string Format { get; set; }
+        public long Width { get; set; }
+        public long Height { get; set; }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/bake-cancel.cs

@@ -0,0 +1,27 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UnityCli
+{
+    /// <summary>graphics.bake-cancel — 取消正在运行的光照烘焙。</summary>
+    public class GraphicsBakeCancelTool : IUnityCliTool<GraphicsBakeCancelTool.Request, GraphicsBakeCancelTool.Result>
+    {
+        public sealed class Request { }
+        public sealed class Result { public bool Baking { get; set; } public bool Cancelled { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.bake-cancel", Summary = "Cancel a running lightmap bake.", Description = "Cancel the active Lightmapping bake if one is running. Returns cancelled=true only when a bake was in progress.", Group = "graphics",DestructiveHint = false, SideEffects = new[] { "lightmapping-bake-cancel" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Cancel bake", Input = new Request { } } } };
+        public async System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var wasRunning = Lightmapping.isRunning;
+            ctx.CommitEffect();
+            if (wasRunning) Lightmapping.Cancel();
+            var observed = await ctx.Wait.UntilStable(() => !Lightmapping.isRunning, System.TimeSpan.FromMilliseconds(ctx.TimeoutMs), ct: ct);
+            if (!observed) throw new UnityCliBridge.BridgeCommandException("E_BAKE_CANCEL_TIMEOUT", "Lightmapping did not leave the baking state before timeout.", "Wait for the current bake to finish or inspect Unity Console before retrying.");
+            var baking = Lightmapping.isRunning;
+            return new Result { Baking = baking, Cancelled = wasRunning, PlannedEffects = new List<GraphicsPlannedEffect> { new GraphicsPlannedEffect { Type = "graphics.bake-cancel", Property = "bake", Value = "cancelled" } } };
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/bake-clear.cs

@@ -0,0 +1,31 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UnityCli
+{
+    /// <summary>graphics.bake-clear — 清除光照烘焙数据。</summary>
+    public class GraphicsBakeClearTool : IUnityCliTool<GraphicsBakeClearTool.Request, GraphicsBakeClearTool.Result>
+    {
+        public sealed class Request { public bool? BakedData { get; set; } public bool? RealtimeData { get; set; } }
+        public sealed class Result { public bool ClearedBakedData { get; set; } public bool ClearedRealtimeData { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.bake-clear", Summary = "Clear the observable baked lighting data asset.", Description = "Clear the baked lighting data asset and verify Lightmapping.lightingDataAsset is null. realtimeData=true is rejected because Unity exposes no reliable realtime-data completion readback.", Group = "graphics",DestructiveHint = true, SideEffects = new[] { "bake" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Clear baked lighting data", Input = new Request { BakedData = true } } } };
+        // 清除可验证的烘焙数据，并拒绝无法可靠证明的实时数据请求。
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (r.RealtimeData == true)
+                throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_REALTIME_CLEAR_UNPROVABLE", "Unity does not expose a reliable readback proving realtime lighting data was cleared.", "Clear baked lighting data only, or inspect realtime lighting data manually in the Unity Editor.");
+            var clearedBaked = r.BakedData ?? true;
+            ctx.CommitEffect();
+            if (clearedBaked) Lightmapping.ClearLightingDataAsset();
+            AssetDatabase.SaveAssets();
+            var observedBakedCleared = Lightmapping.lightingDataAsset == null;
+            if (clearedBaked && !observedBakedCleared)
+                throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_BAKED_CLEAR_STATE_MISMATCH", "Unity still exposes a baked lighting data asset after clearing.", "Inspect the Lighting window and retry after the Editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { ClearedBakedData = clearedBaked && observedBakedCleared, ClearedRealtimeData = false, PlannedEffects = new List<GraphicsPlannedEffect> { new GraphicsPlannedEffect { Type = "graphics.bake-clear", Property = "lightingData", Value = "cleared" } } });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/bake-reflection-probe.cs

@@ -0,0 +1,35 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+namespace UnityCli
+{
+    public class GraphicsBakeReflectionProbeTool : IUnityCliTool<GraphicsBakeReflectionProbeTool.Request, GraphicsBakeReflectionProbeTool.Result>
+    {
+        public sealed class Request { public string Target { get; set; } public string Path { get; set; } }
+        public sealed class Result { public ReflectionProbeInfo Probe { get; set; } public bool Baked { get; set; } public string ArtifactPath { get; set; } public long SizeBytes { get; set; } public string Sha256 { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.bake-reflection-probe", Summary = "Bake a single ReflectionProbe to an .exr cubemap asset.", Description = "Bake a ReflectionProbe to an .exr path. The parent Assets folder must already exist; a missing parent fails before Unity starts the bake.", Group = "graphics",DestructiveHint = true, SideEffects = new[] { "bake", "asset-write" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Bake one reflection probe", Input = new Request { Target = "ReflectionProbe", Path = "Assets/Reflections/ReflectionProbe.exr" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var probe = PhysicsToolSupport.ResolveReflectionProbe(r.Target); if (probe == null) throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_NOT_FOUND", "ReflectionProbe not found: " + r.Target, "Pass an existing ReflectionProbe target.");
+            var probePath = GraphicsToolSupport.NormalizeAssetPathRequired(r.Path ?? ("Assets/" + probe.gameObject.name + "_reflection.exr"), ".exr"); var outputPath = AssetToolSupport.AssetFullPath(probePath);
+            // Unity 的 bake API 会为不存在的父目录弹出原生阻断窗口，必须在 effect barrier 前拒绝。
+            var parentAssetPath = Path.GetDirectoryName(probePath)?.Replace('\\', '/');
+            var parentOutputPath = Path.GetDirectoryName(outputPath);
+            if (string.IsNullOrEmpty(parentAssetPath) || string.IsNullOrEmpty(parentOutputPath) || !Directory.Exists(parentOutputPath))
+                throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_ASSET_DIRECTORY_NOT_FOUND", "ReflectionProbe output parent folder does not exist: " + parentAssetPath, "Run tools run asset.create with path and type=folder input, then retry with a new output path.");
+            var oldExists = File.Exists(outputPath); var oldBytes = oldExists ? File.ReadAllBytes(outputPath) : null; var oldDigest = oldBytes == null ? null : GraphicsToolSupport.FileSha256(oldBytes); var started = System.DateTime.UtcNow;
+            ctx.CommitEffect();
+            if (!Lightmapping.BakeReflectionProbe(probe, probePath)) throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_BAKE_FAILED", "Unity did not complete the ReflectionProbe bake: " + probePath, "Check lighting settings and retry.");
+            AssetDatabase.ImportAsset(probePath, ImportAssetOptions.ForceSynchronousImport);
+            var texture = AssetDatabase.LoadAssetAtPath<Cubemap>(probePath); var info = new FileInfo(outputPath); if (texture == null || !info.Exists || info.Length < 4) throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_BAKE_ARTIFACT_MISSING", "Bake completed without a readable cubemap artifact.", "Check the Unity Console and retry.");
+            var bytes = File.ReadAllBytes(outputPath); var digest = GraphicsToolSupport.FileSha256(bytes); var exr = bytes[0] == 0x76 && bytes[1] == 0x2f && bytes[2] == 0x31 && bytes[3] == 0x01;
+            if (!exr) throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_BAKE_ARTIFACT_INVALID", "Bake did not write a valid EXR artifact.", "Use an .exr output path.");
+            if (oldExists && oldDigest == digest) throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_BAKE_ARTIFACT_UNPROVEN", "The EXR digest did not change, so this bake cannot be attributed to this request.", "Choose a new output path or remove the old artifact before retrying.");
+            if (info.LastWriteTimeUtc < started || info.Length != bytes.LongLength) throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_BAKE_ARTIFACT_UNPROVEN", "The EXR metadata cannot be attributed to this request.", "Choose a new output path and retry.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { Probe = GraphicsToolSupport.BuildReflectionProbeInfo(probe), Baked = true, ArtifactPath = outputPath, SizeBytes = bytes.LongLength, Sha256 = digest, PlannedEffects = new List<GraphicsPlannedEffect> { new GraphicsPlannedEffect { Type = "graphics.bake-reflection-probe", Property = "probe", Value = GameObjectToolSupport.HierarchyPath(probe.gameObject) } } });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/bake-settings.cs

@@ -0,0 +1,131 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UnityCli
+{
+    /// <summary>graphics.bake-settings — 读取/写入 LightingSettings。</summary>
+    public class GraphicsBakeSettingsTool : IUnityCliTool<GraphicsBakeSettingsTool.Request, GraphicsBakeSettingsTool.Result>
+    {
+        public sealed class Request { public string Scene { get; set; } public string LightingMode { get; set; } public bool? BakedGI { get; set; } public bool? RealtimeGI { get; set; } public int? DirectSamples { get; set; } public int? IndirectSamples { get; set; } public int? EnvironmentSamples { get; set; } public int? Bounces { get; set; } public string Filtering { get; set; } }
+        public sealed class Result { public LightingSettingsInfo Settings { get; set; } public string ScenePath { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.bake-settings", Summary = "Read or update LightingSettings for a scene.", Description = "Read or write LightingSettings (lightingMode, bakedGI, realtimeGI, samples, bounces, filtering). scene defaults to the active scene.", Group = "graphics", DestructiveHint = true, SideEffects = new[] { "scene-modify" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Read bake settings", Input = new Request { } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var scene = ResolveLightingScene(r.Scene);
+            var ls = Lightmapping.GetLightingSettingsForScene(scene);
+            var effects = new List<GraphicsPlannedEffect>();
+            var hasWrite = !string.IsNullOrEmpty(r.LightingMode) || r.BakedGI.HasValue || r.RealtimeGI.HasValue || r.DirectSamples.HasValue || r.IndirectSamples.HasValue || r.EnvironmentSamples.HasValue || r.Bounces.HasValue || !string.IsNullOrEmpty(r.Filtering);
+#if UNITY_2023_2_OR_NEWER
+            var lightingMode = string.IsNullOrEmpty(r.LightingMode) ? (LightingMode?)null : GraphicsToolSupport.ParseEnum<LightingMode>(r.LightingMode, "lightingMode");
+#else
+            var lightingMode = string.IsNullOrEmpty(r.LightingMode) ? (MixedLightingMode?)null : GraphicsToolSupport.ParseEnum<MixedLightingMode>(r.LightingMode, "lightingMode");
+#endif
+            var filtering = string.IsNullOrEmpty(r.Filtering) ? (LightingSettings.FilterType?)null : GraphicsToolSupport.ParseEnum<LightingSettings.FilterType>(r.Filtering, "filtering");
+            if ((r.DirectSamples.HasValue && r.DirectSamples.Value <= 0) || (r.IndirectSamples.HasValue && r.IndirectSamples.Value <= 0) || (r.EnvironmentSamples.HasValue && r.EnvironmentSamples.Value <= 0) || (r.Bounces.HasValue && r.Bounces.Value < 0)) throw new UnityCliBridge.BridgeCommandException("E_BAKE_SETTINGS_RANGE_INVALID", "Bake samples must be positive and bounces non-negative.", "Pass valid bake sample and bounce values.");
+            if (hasWrite) ctx.CommitEffect();
+            if (ls == null && hasWrite) { ls = new LightingSettings(); effects.Add(new GraphicsPlannedEffect { Type = "graphics.bake-settings", Property = "lightingSettings", Value = "created" }); }
+            if (ls != null)
+            {
+                if (!string.IsNullOrEmpty(r.LightingMode))
+                {
+#if UNITY_2023_2_OR_NEWER
+                    ls.lightingMode = lightingMode.Value;
+#else
+                    ls.mixedBakeMode = lightingMode.Value;
+#endif
+                    effects.Add(new GraphicsPlannedEffect { Type = "graphics.bake-settings", Property = "lightingMode", Value = r.LightingMode });
+                }
+                if (r.BakedGI.HasValue) { ls.bakedGI = r.BakedGI.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.bake-settings", Property = "bakedGI", Value = r.BakedGI.Value.ToString().ToLowerInvariant() }); }
+                if (r.RealtimeGI.HasValue) { ls.realtimeGI = r.RealtimeGI.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.bake-settings", Property = "realtimeGI", Value = r.RealtimeGI.Value.ToString().ToLowerInvariant() }); }
+                if (r.DirectSamples.HasValue) { SetDirectSamples(ls, r.DirectSamples.Value); effects.Add(new GraphicsPlannedEffect { Type = "graphics.bake-settings", Property = "directSamples", Value = r.DirectSamples.Value.ToString() }); }
+                if (r.IndirectSamples.HasValue) { SetIndirectSamples(ls, r.IndirectSamples.Value); effects.Add(new GraphicsPlannedEffect { Type = "graphics.bake-settings", Property = "indirectSamples", Value = r.IndirectSamples.Value.ToString() }); }
+                if (r.EnvironmentSamples.HasValue) { SetEnvSamples(ls, r.EnvironmentSamples.Value); effects.Add(new GraphicsPlannedEffect { Type = "graphics.bake-settings", Property = "environmentSamples", Value = r.EnvironmentSamples.Value.ToString() }); }
+                if (r.Bounces.HasValue) { SetBounces(ls, r.Bounces.Value); effects.Add(new GraphicsPlannedEffect { Type = "graphics.bake-settings", Property = "bounces", Value = r.Bounces.Value.ToString() }); }
+                if (filtering.HasValue) { SetFiltering(ls, filtering.Value); effects.Add(new GraphicsPlannedEffect { Type = "graphics.bake-settings", Property = "filtering", Value = r.Filtering }); }
+                if (hasWrite)
+                {
+                    Lightmapping.SetLightingSettingsForScene(scene, ls);
+                    EditorUtility.SetDirty(ls);
+                    UnityCliSceneMutation.MarkSceneDirty(scene);
+                    var lightingSettingsPath = AssetDatabase.GetAssetPath(ls);
+                    if (string.IsNullOrEmpty(lightingSettingsPath)) throw new UnityCliBridge.BridgeCommandException("E_BAKE_SETTINGS_STATE_MISMATCH", "LightingSettings was not persisted at an asset path.", "Save the scene and retry after the editor is idle.");
+                    AssetDatabase.SaveAssets();
+                    AssetDatabase.Refresh();
+                    LightingSettings fresh = null;
+                    foreach (var asset in AssetDatabase.LoadAllAssetsAtPath(lightingSettingsPath)) { fresh = asset as LightingSettings; if (fresh != null) break; }
+                    if (fresh == null) throw new UnityCliBridge.BridgeCommandException("E_BAKE_SETTINGS_STATE_MISMATCH", "LightingSettings fresh asset readback failed.", "Retry after the editor is idle.");
+                    ls = fresh;
+                }
+                var observed = Lightmapping.GetLightingSettingsForScene(scene);
+                if (hasWrite && (observed == null || observed.GetInstanceID() != ls.GetInstanceID())) throw new UnityCliBridge.BridgeCommandException("E_BAKE_SETTINGS_STATE_MISMATCH", "Scene does not bind the freshly reloaded LightingSettings asset.", "Retry after the editor is idle.");
+                if (observed != null) ls = observed;
+                var readback = BuildLightingSettingsInfo(ls);
+                if ((r.BakedGI.HasValue && readback.BakedGI != r.BakedGI.Value) || (r.RealtimeGI.HasValue && readback.RealtimeGI != r.RealtimeGI.Value) || (r.DirectSamples.HasValue && readback.DirectSamples != r.DirectSamples.Value) || (r.IndirectSamples.HasValue && readback.IndirectSamples != r.IndirectSamples.Value) || (r.EnvironmentSamples.HasValue && readback.EnvironmentSamples != r.EnvironmentSamples.Value) || (r.Bounces.HasValue && readback.Bounces != r.Bounces.Value) || (lightingMode.HasValue && readback.LightingMode != lightingMode.Value.ToString()) || (filtering.HasValue && readback.Filtering != filtering.Value.ToString())) throw new UnityCliBridge.BridgeCommandException("E_BAKE_SETTINGS_STATE_MISMATCH", "LightingSettings readback did not match the request.", "Retry after the editor is idle.");
+            }
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { Settings = BuildLightingSettingsInfo(ls), ScenePath = scene.path, PlannedEffects = effects });
+        }
+        private static Scene ResolveLightingScene(string path)
+        {
+            if (string.IsNullOrEmpty(path)) return SceneManager.GetActiveScene();
+            for (var i = 0; i < SceneManager.sceneCount; i++)
+            {
+                var scene = SceneManager.GetSceneAt(i);
+                if (scene.path == path || scene.name == path) return scene;
+            }
+            throw new UnityCliBridge.BridgeCommandException("E_BAKE_SCENE_NOT_FOUND", "Scene is not loaded: " + path, "Pass the path or name of a currently loaded scene.");
+        }
+        private static void SetDirectSamples(LightingSettings ls, int v)
+        {
+#if UNITY_2023_2_OR_NEWER
+            ls.directSamples = v;
+#else
+            ls.directSampleCount = v;
+#endif
+        }
+        private static void SetIndirectSamples(LightingSettings ls, int v)
+        {
+#if UNITY_2023_2_OR_NEWER
+            ls.indirectSamples = v;
+#else
+            ls.indirectSampleCount = v;
+#endif
+        }
+        private static void SetEnvSamples(LightingSettings ls, int v)
+        {
+#if UNITY_2023_2_OR_NEWER
+            ls.environmentSamples = v;
+#else
+            ls.environmentSampleCount = v;
+#endif
+        }
+        private static void SetBounces(LightingSettings ls, int v)
+        {
+#if UNITY_2023_2_OR_NEWER
+            ls.bounces = v;
+#else
+            ls.maxBounces = v;
+#endif
+        }
+        private static void SetFiltering(LightingSettings ls, LightingSettings.FilterType ft)
+        {
+#if UNITY_2023_2_OR_NEWER
+            ls.filtering = ft;
+#else
+            ls.filterTypeDirect = ft; ls.filterTypeIndirect = ft; ls.filterTypeAO = ft;
+#endif
+        }
+        private static LightingSettingsInfo BuildLightingSettingsInfo(LightingSettings ls)
+        {
+            if (ls == null) return new LightingSettingsInfo();
+#if UNITY_2023_2_OR_NEWER
+            return new LightingSettingsInfo { LightingMode = ls.lightingMode.ToString(), BakedGI = ls.bakedGI, RealtimeGI = ls.realtimeGI, DirectSamples = ls.directSamples, IndirectSamples = ls.indirectSamples, EnvironmentSamples = ls.environmentSamples, Bounces = ls.bounces, Filtering = ls.filtering.ToString(), IndirectResolution = ls.indirectResolution };
+#else
+            return new LightingSettingsInfo { LightingMode = ls.mixedBakeMode.ToString(), BakedGI = ls.bakedGI, RealtimeGI = ls.realtimeGI, DirectSamples = ls.directSampleCount, IndirectSamples = ls.indirectSampleCount, EnvironmentSamples = ls.environmentSampleCount, Bounces = ls.maxBounces, Filtering = ls.filterTypeDirect.ToString(), IndirectResolution = ls.indirectResolution };
+#endif
+        }
+    }
+}
+#endif