266 lines
11 KiB
C#
266 lines
11 KiB
C#
using System;
|
|
using System.IO;
|
|
using Newtonsoft.Json;
|
|
using Unity.Pipeline.Commands;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
|
|
namespace Unity.Pipeline.Editor.Commands.Baking
|
|
{
|
|
/// <summary>
|
|
/// CLI-215 Group C — Occlusion Culling bake commands. Trigger an async occlusion bake of the open
|
|
/// scene(s) via <see cref="StaticOcclusionCulling.GenerateInBackground"/>, poll its status, cancel
|
|
/// it, and clear the baked occlusion data.
|
|
///
|
|
/// Async pattern mirrors <see cref="BuildCommand"/> / <see cref="LightingBakeCommands"/>: trigger
|
|
/// returns immediately; completion is detected by <see cref="StaticOcclusionCulling.isRunning"/>
|
|
/// flipping false (polled in <see cref="EditorApplication.update"/>); in-flight state is held in
|
|
/// static fields and reconciled against a Temp/ status file across domain reloads.
|
|
/// </summary>
|
|
[InitializeOnLoad]
|
|
public static class OcclusionBakeCommands
|
|
{
|
|
const string StatusFile = "Temp/pipeline_occlusion_bake_status.json";
|
|
|
|
// Sentinel for "argument omitted" on the float bake parameters. float.NaN is not a
|
|
// compile-time constant (so it can't be a default parameter value), but float.MinValue is, and
|
|
// it is not a plausible real value for any of these positive bake parameters.
|
|
const float Unset = float.MinValue;
|
|
|
|
static readonly object s_Lock = new object();
|
|
static bool s_Tracking;
|
|
static string s_BakeId;
|
|
static DateTime s_StartedUtc;
|
|
|
|
static OcclusionBakeCommands()
|
|
{
|
|
OnReload();
|
|
EditorApplication.update += OnUpdate;
|
|
}
|
|
|
|
#region bake_occlusion_culling
|
|
|
|
[CliCommand("bake_occlusion_culling", "Trigger an async occlusion-culling bake of the open scene(s) via StaticOcclusionCulling.GenerateInBackground(). Returns immediately; poll occlusion_bake_status until completed.")]
|
|
public static object BakeOcclusionCulling(
|
|
[CliArg("smallest_occluder", "Smallest object that will occlude others (meters). Defaults to Unity's current value.")] float smallestOccluder = Unset,
|
|
[CliArg("smallest_hole", "Smallest gap geometry can have that the view can see through (meters). Defaults to Unity's current value.")] float smallestHole = Unset,
|
|
[CliArg("backface_threshold", "Backface threshold (1-100); lower trims more backfaces. Defaults to Unity's current value.")] float backfaceThreshold = Unset,
|
|
[CliArg("confirm", "Accepted for parity (a bake overwrites existing occlusion data); not required.")] bool confirm = false,
|
|
[CliArg("dry_run", "If true, validate there is an open scene and report the parameters that would be used without baking.")] bool dryRun = false)
|
|
{
|
|
if (!BakeSceneGuard.HasBakeableScene())
|
|
return BakeSceneGuard.NoSceneResult();
|
|
|
|
OnUpdate(); // reconcile any stale tracking flag first.
|
|
|
|
if (StaticOcclusionCulling.isRunning)
|
|
return new { code = "bake_in_progress", message = "An occlusion bake is already running. Poll occlusion_bake_status." };
|
|
|
|
// Validate explicitly provided values before resolving. An omitted arg is the Unset
|
|
// sentinel (float.MinValue); NaN is never <= Unset, so a NaN arg is treated as provided
|
|
// and rejected here. smallest_occluder / smallest_hole must be positive; backface_threshold
|
|
// is documented as 1-100.
|
|
if (!IsOmitted(smallestOccluder) && !(smallestOccluder > 0f))
|
|
throw new ArgumentException($"smallest_occluder must be greater than 0 (got {smallestOccluder}).");
|
|
if (!IsOmitted(smallestHole) && !(smallestHole > 0f))
|
|
throw new ArgumentException($"smallest_hole must be greater than 0 (got {smallestHole}).");
|
|
if (!IsOmitted(backfaceThreshold) && !(backfaceThreshold >= 1f && backfaceThreshold <= 100f))
|
|
throw new ArgumentException($"backface_threshold must be between 1 and 100 (got {backfaceThreshold}).");
|
|
|
|
// Resolve effective parameters: an omitted arg (the Unset sentinel) keeps Unity's current value.
|
|
var occluder = IsOmitted(smallestOccluder) ? StaticOcclusionCulling.smallestOccluder : smallestOccluder;
|
|
var hole = IsOmitted(smallestHole) ? StaticOcclusionCulling.smallestHole : smallestHole;
|
|
var backface = IsOmitted(backfaceThreshold) ? StaticOcclusionCulling.backfaceThreshold : backfaceThreshold;
|
|
|
|
if (dryRun)
|
|
{
|
|
return new
|
|
{
|
|
status = "dry_run",
|
|
wouldBake = true,
|
|
parameters = new { smallestOccluder = occluder, smallestHole = hole, backfaceThreshold = backface }
|
|
};
|
|
}
|
|
|
|
// Apply the (possibly overridden) bake parameters before generating.
|
|
StaticOcclusionCulling.smallestOccluder = occluder;
|
|
StaticOcclusionCulling.smallestHole = hole;
|
|
StaticOcclusionCulling.backfaceThreshold = backface;
|
|
|
|
var bakeId = Guid.NewGuid().ToString("N");
|
|
lock (s_Lock)
|
|
{
|
|
s_Tracking = true;
|
|
s_BakeId = bakeId;
|
|
s_StartedUtc = DateTime.UtcNow;
|
|
}
|
|
|
|
WriteStatus(new OcclusionBakeStatus
|
|
{
|
|
Status = "baking",
|
|
BakeId = bakeId,
|
|
StartedUtcTicks = s_StartedUtc.Ticks
|
|
});
|
|
|
|
StaticOcclusionCulling.GenerateInBackground();
|
|
return new { status = "baking", bakeId };
|
|
}
|
|
|
|
[CliCommand("occlusion_bake_status", "Get the status of the last occlusion bake: idle | baking | completed.", MainThreadRequired = false)]
|
|
public static string OcclusionBakeStatus()
|
|
{
|
|
if (File.Exists(StatusFile))
|
|
return File.ReadAllText(StatusFile);
|
|
return "{\"status\":\"idle\"}";
|
|
}
|
|
|
|
[CliCommand("cancel_occlusion_bake", "Cancel an in-progress occlusion bake (StaticOcclusionCulling.Cancel()).")]
|
|
public static object CancelOcclusionBake()
|
|
{
|
|
var wasRunning = StaticOcclusionCulling.isRunning;
|
|
if (wasRunning)
|
|
StaticOcclusionCulling.Cancel();
|
|
|
|
lock (s_Lock)
|
|
{
|
|
if (s_Tracking)
|
|
{
|
|
var ms = (int)Math.Max(0, (DateTime.UtcNow - s_StartedUtc).TotalMilliseconds);
|
|
WriteStatus(new OcclusionBakeStatus
|
|
{
|
|
Status = "completed",
|
|
Result = "cancelled",
|
|
BakeId = s_BakeId,
|
|
BakeTimeMs = ms
|
|
});
|
|
s_Tracking = false;
|
|
}
|
|
}
|
|
|
|
return new { cancelled = wasRunning };
|
|
}
|
|
|
|
[CliCommand("clear_occlusion_culling", "Clear baked occlusion-culling data for the open scene(s). Destructive: requires confirm=true.")]
|
|
public static object ClearOcclusionCulling(
|
|
[CliArg("confirm", "Must be true to actually clear (destructive, not undoable via Unity's Undo).")] bool confirm = false,
|
|
[CliArg("dry_run", "If true, report what would be cleared without clearing.")] bool dryRun = false)
|
|
{
|
|
if (!confirm)
|
|
throw new ArgumentException("Refusing to clear occlusion culling data. Pass confirm=true (destructive, not undoable via Unity's Undo).");
|
|
|
|
if (dryRun)
|
|
return new { status = "dry_run", wouldClear = true };
|
|
|
|
StaticOcclusionCulling.Clear();
|
|
return new { cleared = true };
|
|
}
|
|
|
|
// True when the caller omitted a float bake arg (left it at the Unset sentinel). NaN is never
|
|
// <= Unset, so NaN counts as provided and is caught by the range validation above.
|
|
static bool IsOmitted(float value) => value <= Unset;
|
|
|
|
#endregion
|
|
|
|
#region completion / reload bookkeeping
|
|
|
|
static void OnUpdate()
|
|
{
|
|
lock (s_Lock)
|
|
{
|
|
if (s_Tracking && !StaticOcclusionCulling.isRunning)
|
|
Finish("succeeded");
|
|
}
|
|
}
|
|
|
|
// Must be called under s_Lock.
|
|
static void Finish(string result)
|
|
{
|
|
var ms = (int)Math.Max(0, (DateTime.UtcNow - s_StartedUtc).TotalMilliseconds);
|
|
WriteStatus(new OcclusionBakeStatus
|
|
{
|
|
Status = "completed",
|
|
Result = result,
|
|
BakeId = s_BakeId,
|
|
BakeTimeMs = ms,
|
|
Stats = result == "succeeded"
|
|
? new OcclusionBakeStats { UmbraDataSizeBytes = StaticOcclusionCulling.umbraDataSize }
|
|
: null
|
|
});
|
|
s_Tracking = false;
|
|
}
|
|
|
|
static void OnReload()
|
|
{
|
|
if (!File.Exists(StatusFile))
|
|
return;
|
|
|
|
OcclusionBakeStatus prior;
|
|
try
|
|
{
|
|
prior = JsonConvert.DeserializeObject<OcclusionBakeStatus>(File.ReadAllText(StatusFile));
|
|
}
|
|
catch
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (prior == null || prior.Status != "baking")
|
|
return;
|
|
|
|
lock (s_Lock)
|
|
{
|
|
s_BakeId = prior.BakeId;
|
|
s_StartedUtc = prior.StartedUtcTicks > 0 ? new DateTime(prior.StartedUtcTicks, DateTimeKind.Utc) : DateTime.UtcNow;
|
|
s_Tracking = true;
|
|
if (!StaticOcclusionCulling.isRunning)
|
|
Finish("succeeded");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
static void WriteStatus(OcclusionBakeStatus status)
|
|
{
|
|
try
|
|
{
|
|
File.WriteAllText(StatusFile, JsonConvert.SerializeObject(status));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError($"[OcclusionBake] Failed to write status file: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>Status/result payload for <c>bake_occlusion_culling</c> / <c>occlusion_bake_status</c>.</summary>
|
|
[Serializable]
|
|
public class OcclusionBakeStatus
|
|
{
|
|
[JsonProperty("status")]
|
|
public string Status { get; set; }
|
|
|
|
[JsonProperty("bakeId")]
|
|
public string BakeId { get; set; }
|
|
|
|
[JsonProperty("result", NullValueHandling = NullValueHandling.Ignore)]
|
|
public string Result { get; set; }
|
|
|
|
[JsonProperty("bakeTimeMs")]
|
|
public int BakeTimeMs { get; set; }
|
|
|
|
[JsonProperty("stats", NullValueHandling = NullValueHandling.Ignore)]
|
|
public OcclusionBakeStats Stats { get; set; }
|
|
|
|
[JsonProperty("startedUtcTicks")]
|
|
public long StartedUtcTicks { get; set; }
|
|
}
|
|
|
|
/// <summary>Post-bake occlusion statistics (umbra data size in bytes).</summary>
|
|
[Serializable]
|
|
public class OcclusionBakeStats
|
|
{
|
|
[JsonProperty("umbraDataSizeBytes")]
|
|
public long UmbraDataSizeBytes { get; set; }
|
|
}
|
|
}
|