huadexuan
c09e15dd0e
feat(Materials): 更新CoreBattleGround材质贴图和缩放参数
更换了CoreBattleGround材质的主纹理，将纹理GUID从73e4d6cf089824c0cadfcefa5b15d306
更新为c6af6f473739fb546ac7775e5c957da1，并调整纹理缩放参数从{x: 3, y: 4}修改为
{x: 1, y: 1}，同时移除了多余的_MetallicGlossMap配置项。
```
629 lines
29 KiB
C#
629 lines
29 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using Codely.Newtonsoft.Json;
|
|
using Codely.Newtonsoft.Json.Linq;
|
|
using UnityEditor;
|
|
using UnityEditor.PackageManager;
|
|
using UnityEngine;
|
|
using UnityTcp.Editor.Helpers;
|
|
|
|
namespace UnityTcp.Editor.Tools
|
|
{
|
|
/// <summary>
|
|
/// [EXPERIMENTAL] Handles baking operations (NavMesh, Lighting, etc.).
|
|
/// Compatible with Unity 2022.3 LTS.
|
|
/// </summary>
|
|
public static class ManageBake
|
|
{
|
|
// Runtime check for AI Navigation package availability
|
|
private static bool? _hasAINavigation = null;
|
|
private static Type _navMeshSurfaceType = null;
|
|
private static MethodInfo _buildNavMeshMethod = null;
|
|
private static MethodInfo _updateNavMeshMethod = null;
|
|
private static PropertyInfo _activeSurfacesProperty = null;
|
|
private static Type _navMeshType = null;
|
|
private static MethodInfo _calculateTriangulationMethod = null;
|
|
private static MethodInfo _removeAllNavMeshDataMethod = null;
|
|
|
|
/// <summary>
|
|
/// Starts a bake-related <see cref="StepJob"/> on the current request; the response is held
|
|
/// until the job finishes. Lighting bakes run for minutes, and any script edit in that
|
|
/// window reloads the domain — which used to strand the bake's update callback and leave
|
|
/// its job Pending forever.
|
|
/// </summary>
|
|
private static object RunToCompletion(StepJob job, JObject @params, int defaultTimeoutSeconds)
|
|
=> StepJobRunner.Start(
|
|
CommandContext.RequestId, CommandContext.CommandType, job,
|
|
@params["timeoutSeconds"]?.ToObject<int?>() ?? defaultTimeoutSeconds);
|
|
|
|
/// <summary>
|
|
/// True when a NavMesh has actually been produced. Checks <c>navMeshData</c> on the given
|
|
/// surfaces (or on every active surface when <paramref name="surfaces"/> is null), then
|
|
/// falls back to the global triangulation.
|
|
/// </summary>
|
|
internal static bool HasAnyNavMeshData(IList surfaces = null)
|
|
{
|
|
try
|
|
{
|
|
var navMeshDataProperty = _navMeshSurfaceType?.GetProperty("navMeshData");
|
|
if (navMeshDataProperty != null)
|
|
{
|
|
var toCheck = surfaces ?? _activeSurfacesProperty?.GetValue(null) as IList;
|
|
if (toCheck != null)
|
|
{
|
|
foreach (var surface in toCheck)
|
|
{
|
|
if (surface != null && navMeshDataProperty.GetValue(surface) != null)
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_calculateTriangulationMethod != null)
|
|
{
|
|
var triangulation = _calculateTriangulationMethod.Invoke(null, null);
|
|
var vertices = triangulation?.GetType()
|
|
.GetProperty("vertices")?.GetValue(triangulation) as Array;
|
|
return vertices != null && vertices.Length > 0;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// Reflection against an optional package — if we cannot tell, report no data
|
|
// rather than claiming a bake produced something.
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Runs a lighting bake to completion. <c>Lightmapping.BakeAsync</c> does not reload the domain
|
|
/// itself, but a bake runs for minutes and any script edit in that window does — which used to
|
|
/// strand the bake's update callback and leave its job Pending forever. Progress is read from
|
|
/// <c>Lightmapping.isRunning</c>, editor-global state that is still true after a reload, so the
|
|
/// job simply picks the wait back up.
|
|
/// </summary>
|
|
internal class BakeLightingJob : StepJob
|
|
{
|
|
public bool Started;
|
|
|
|
/// <summary>
|
|
/// How long to let the bake start before concluding it finished (or never began).
|
|
/// Wall-clock rather than a frame count: Lightmapping.isRunning goes true only once
|
|
/// Unity has finished preparing the scene, which is far more than a handful of frames
|
|
/// on a real scene. Giving up early reports "baking completed" for a bake that never
|
|
/// ran, against whatever lighting data happened to be on disk already.
|
|
/// </summary>
|
|
public double SettleSeconds = 30;
|
|
|
|
/// <summary>
|
|
/// Session-clock deadline for the detect phase, pushed forward for as long as the
|
|
/// editor is updating so the window only counts down against an idle editor.
|
|
/// </summary>
|
|
public double SettleUntil;
|
|
|
|
public bool SawRunning;
|
|
|
|
protected override JobStep[] BuildSteps() => new[]
|
|
{
|
|
new JobStep("start-bake", () =>
|
|
{
|
|
if (Started) return;
|
|
Started = true;
|
|
Lightmapping.BakeAsync();
|
|
}),
|
|
|
|
// Do not report "done" in the gap between requesting the bake and Unity starting it.
|
|
new JobStep("detect-bake",
|
|
() =>
|
|
{
|
|
// The window does not count down while the editor is still refreshing —
|
|
// see SettleWindow.
|
|
SettleUntil = SettleWindow.Advance(
|
|
SettleUntil, EditorApplication.timeSinceStartup, SettleSeconds,
|
|
EditorApplication.isUpdating);
|
|
if (Lightmapping.isRunning) SawRunning = true;
|
|
},
|
|
() => SawRunning
|
|
|| SettleWindow.Expired(SettleUntil, EditorApplication.timeSinceStartup,
|
|
EditorApplication.isUpdating)),
|
|
|
|
new JobStep("await-bake", null, () => !Lightmapping.isRunning),
|
|
|
|
new JobStep("report", () => Complete(Response.Success(
|
|
SawRunning
|
|
? "[EXPERIMENTAL] Lighting baking completed"
|
|
: "[EXPERIMENTAL] No lighting bake was observed — Unity never started one. " +
|
|
"Any lighting data reported below predates this call.",
|
|
new Dictionary<string, object>
|
|
{
|
|
["type"] = "lighting",
|
|
["hasLightingData"] = Lightmapping.lightingDataAsset != null,
|
|
["bake_observed"] = SawRunning,
|
|
}))),
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Waits out the asynchronous <c>UpdateNavMesh</c> operations started by
|
|
/// <c>bake_navmesh</c>. The operations themselves cannot be persisted, so if a domain
|
|
/// reload takes them the job falls back to waiting for the editor to settle and then
|
|
/// reports on the NavMesh data that actually exists.
|
|
/// </summary>
|
|
internal class NavMeshBakeJob : StepJob
|
|
{
|
|
public int SurfaceCount;
|
|
|
|
[JsonIgnore] public List<AsyncOperation> Operations;
|
|
|
|
/// <summary>
|
|
/// True once the operations have been lost to a domain reload. An idle editor says
|
|
/// nothing about whether they finished, so from here the baked data is the only
|
|
/// evidence there is.
|
|
/// </summary>
|
|
public bool OperationsLost;
|
|
|
|
public override void OnRestored() => OperationsLost = true;
|
|
|
|
protected override JobStep[] BuildSteps() => new[]
|
|
{
|
|
new JobStep("await-surfaces", null, () =>
|
|
Operations == null
|
|
? !EditorApplication.isCompiling && !EditorApplication.isUpdating
|
|
: Operations.All(op => op == null || op.isDone)),
|
|
|
|
new JobStep("report", Report),
|
|
};
|
|
|
|
internal void Report()
|
|
{
|
|
bool hasData = HasAnyNavMeshData();
|
|
|
|
// Waiting for the editor to go idle only proves the editor is idle. Without the
|
|
// operations to ask, unbaked surfaces mean the bake either never finished or
|
|
// produced nothing, and "completed" would be a guess.
|
|
if (OperationsLost && !hasData)
|
|
{
|
|
Fail("[EXPERIMENTAL] NavMesh baking could not be confirmed: a domain reload " +
|
|
"took the bake operations and no NavMesh data is present. Check the " +
|
|
"NavMesh surfaces and re-bake if needed.");
|
|
return;
|
|
}
|
|
|
|
Complete(Response.Success(
|
|
"[EXPERIMENTAL] NavMesh baking completed",
|
|
new Dictionary<string, object>
|
|
{
|
|
["type"] = "navmesh",
|
|
["hasNavMeshData"] = hasData,
|
|
["surfacesBaked"] = SurfaceCount,
|
|
// True when the outcome rests on the baked data alone, the bake operations
|
|
// themselves having been lost to a domain reload.
|
|
["verified_after_reload"] = OperationsLost,
|
|
}));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reset the AI Navigation package cache. Call this after installing the package
|
|
/// to force re-checking for available types.
|
|
/// </summary>
|
|
private static void ResetAINavigationCache()
|
|
{
|
|
_hasAINavigation = null;
|
|
_navMeshSurfaceType = null;
|
|
_buildNavMeshMethod = null;
|
|
_updateNavMeshMethod = null;
|
|
_activeSurfacesProperty = null;
|
|
_navMeshType = null;
|
|
_calculateTriangulationMethod = null;
|
|
_removeAllNavMeshDataMethod = null;
|
|
}
|
|
|
|
private static bool HasAINavigation()
|
|
{
|
|
if (_hasAINavigation.HasValue)
|
|
return _hasAINavigation.Value;
|
|
|
|
try
|
|
{
|
|
// First, check if the package is installed via PackageManager
|
|
bool packageInstalled = false;
|
|
try
|
|
{
|
|
#if UNITY_2021_2_OR_NEWER
|
|
// Use GetAllRegisteredPackages for Unity 2021.2+
|
|
var packages = UnityEditor.PackageManager.PackageInfo.GetAllRegisteredPackages();
|
|
packageInstalled = packages.Any(p => p.name == "com.unity.ai.navigation");
|
|
#else
|
|
// Fallback for older Unity versions
|
|
var listRequest = Client.List(true, false);
|
|
while (!listRequest.IsCompleted)
|
|
{
|
|
System.Threading.Thread.Sleep(50);
|
|
}
|
|
if (listRequest.Status == StatusCode.Success)
|
|
{
|
|
packageInstalled = listRequest.Result.Any(p => p.name == "com.unity.ai.navigation");
|
|
}
|
|
#endif
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CodelyLogger.LogWarning($"[ManageBake] Error checking package installation: {ex.Message}");
|
|
// Continue with type checking as fallback
|
|
}
|
|
|
|
// Try to find NavMeshSurface type (Unity.AI.Navigation namespace from com.unity.ai.navigation package)
|
|
// Try multiple methods to find the type
|
|
_navMeshSurfaceType = Type.GetType("Unity.AI.Navigation.NavMeshSurface, Unity.AI.Navigation");
|
|
|
|
if (_navMeshSurfaceType == null)
|
|
{
|
|
// Try with full assembly qualified name variations
|
|
_navMeshSurfaceType = Type.GetType("Unity.AI.Navigation.NavMeshSurface, Unity.AI.Navigation, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null");
|
|
}
|
|
|
|
if (_navMeshSurfaceType == null)
|
|
{
|
|
// Fallback: search in loaded assemblies by name first
|
|
System.Reflection.Assembly targetAssembly = null;
|
|
foreach (var assembly in System.AppDomain.CurrentDomain.GetAssemblies())
|
|
{
|
|
var assemblyName = assembly.GetName().Name;
|
|
if (assemblyName == "Unity.AI.Navigation" || assemblyName.Contains("Unity.AI.Navigation"))
|
|
{
|
|
targetAssembly = assembly;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (targetAssembly != null)
|
|
{
|
|
_navMeshSurfaceType = targetAssembly.GetType("Unity.AI.Navigation.NavMeshSurface");
|
|
}
|
|
}
|
|
|
|
if (_navMeshSurfaceType == null)
|
|
{
|
|
// Last resort: search all assemblies
|
|
foreach (var assembly in System.AppDomain.CurrentDomain.GetAssemblies())
|
|
{
|
|
_navMeshSurfaceType = assembly.GetType("Unity.AI.Navigation.NavMeshSurface");
|
|
if (_navMeshSurfaceType != null) break;
|
|
}
|
|
}
|
|
|
|
if (_navMeshSurfaceType != null)
|
|
{
|
|
_buildNavMeshMethod = _navMeshSurfaceType.GetMethod("BuildNavMesh", BindingFlags.Public | BindingFlags.Instance);
|
|
_updateNavMeshMethod = _navMeshSurfaceType.GetMethod("UpdateNavMesh", BindingFlags.Public | BindingFlags.Instance);
|
|
_activeSurfacesProperty = _navMeshSurfaceType.GetProperty("activeSurfaces", BindingFlags.Public | BindingFlags.Static);
|
|
}
|
|
|
|
// Try to find NavMesh type (UnityEngine.AI namespace - still used by the package)
|
|
_navMeshType = Type.GetType("UnityEngine.AI.NavMesh, UnityEngine.AIModule");
|
|
if (_navMeshType == null)
|
|
{
|
|
foreach (var assembly in System.AppDomain.CurrentDomain.GetAssemblies())
|
|
{
|
|
_navMeshType = assembly.GetType("UnityEngine.AI.NavMesh");
|
|
if (_navMeshType != null) break;
|
|
}
|
|
}
|
|
|
|
if (_navMeshType != null)
|
|
{
|
|
_calculateTriangulationMethod = _navMeshType.GetMethod("CalculateTriangulation", BindingFlags.Public | BindingFlags.Static);
|
|
_removeAllNavMeshDataMethod = _navMeshType.GetMethod("RemoveAllNavMeshData", BindingFlags.Public | BindingFlags.Static);
|
|
}
|
|
|
|
// Check both package installation and required types/methods
|
|
bool hasRequiredTypes = _navMeshSurfaceType != null && _buildNavMeshMethod != null && _navMeshType != null;
|
|
|
|
// If package is installed but types are missing, check compilation status
|
|
if (packageInstalled && !hasRequiredTypes)
|
|
{
|
|
bool isCompiling = EditorApplication.isCompiling;
|
|
string compilationStatus = isCompiling ? "compiling" : "idle";
|
|
|
|
// Collect diagnostic information
|
|
var loadedAssemblies = System.AppDomain.CurrentDomain.GetAssemblies()
|
|
.Where(a => a.GetName().Name.Contains("AI") || a.GetName().Name.Contains("Navigation"))
|
|
.Select(a => a.GetName().Name)
|
|
.ToList();
|
|
|
|
string diagnosticInfo = "";
|
|
if (loadedAssemblies.Count > 0)
|
|
{
|
|
diagnosticInfo = $" Found related assemblies: {string.Join(", ", loadedAssemblies)}.";
|
|
}
|
|
else
|
|
{
|
|
diagnosticInfo = " No AI/Navigation assemblies found in loaded assemblies.";
|
|
}
|
|
|
|
string typeStatus = "";
|
|
if (_navMeshSurfaceType == null)
|
|
{
|
|
typeStatus += " NavMeshSurface type not found.";
|
|
}
|
|
else
|
|
{
|
|
typeStatus += $" NavMeshSurface found, but methods missing: BuildNavMesh={_buildNavMeshMethod != null}, UpdateNavMesh={_updateNavMeshMethod != null}, activeSurfaces={_activeSurfacesProperty != null}.";
|
|
}
|
|
|
|
if (_navMeshType == null)
|
|
{
|
|
typeStatus += " NavMesh type not found.";
|
|
}
|
|
|
|
CodelyLogger.LogWarning(
|
|
$"[ManageBake] com.unity.ai.navigation package is installed but required types/methods are not available. " +
|
|
$"Editor is currently {compilationStatus}.{diagnosticInfo}{typeStatus} " +
|
|
(isCompiling
|
|
? "Please wait for compilation to complete, then call 'unity_editor { \"action\": \"wait_for_idle\" }' before retrying."
|
|
: "The package may need to be reloaded. Try restarting Unity or wait a moment and retry.")
|
|
);
|
|
}
|
|
|
|
// Package installation check is primary, but we also need the types to be available
|
|
// If package is installed but types are missing and we're not compiling, return false
|
|
// If we're compiling, also return false (types won't be available until compilation completes)
|
|
_hasAINavigation = packageInstalled && hasRequiredTypes && !EditorApplication.isCompiling;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CodelyLogger.LogWarning($"[ManageBake] Error checking for AI Navigation package: {ex.Message}");
|
|
_hasAINavigation = false;
|
|
}
|
|
|
|
return _hasAINavigation.Value;
|
|
}
|
|
|
|
private static readonly Dictionary<string, Func<JObject, object>> ActionHandlers =
|
|
new Dictionary<string, Func<JObject, object>>
|
|
{
|
|
{ "bake_navmesh", BakeNavMesh },
|
|
{ "bake_lighting", p => RunToCompletion(new BakeLightingJob(), p, 600) },
|
|
{ "wait_for_bake", WaitActionDeprecated },
|
|
{ "clear_navmesh", _ => ClearNavMesh() },
|
|
{ "clear_baked_data", _ => ClearBakedData() },
|
|
};
|
|
|
|
public static object HandleCommand(JObject @params)
|
|
=> ActionRouter.Route(@params, ActionHandlers);
|
|
|
|
private static object WaitActionDeprecated(JObject @params)
|
|
{
|
|
string action = @params["action"]?.ToString()?.ToLower();
|
|
return Response.ErrorWithCode(
|
|
"action_deprecated",
|
|
$"Action '{action}' is deprecated. There is no need to wait: bake_lighting and " +
|
|
"bake_navmesh return only after the bake is done. To wait for the editor to " +
|
|
"settle after external work, use 'unity_editor { \"action\": \"wait_for_idle\" }'.");
|
|
}
|
|
|
|
private static object BakeNavMesh(JObject @params)
|
|
{
|
|
try
|
|
{
|
|
// Reset cache and re-check if first check fails (in case package was just installed)
|
|
if (!HasAINavigation())
|
|
{
|
|
ResetAINavigationCache();
|
|
if (!HasAINavigation())
|
|
{
|
|
// Check if package is installed but types are not available
|
|
bool packageInstalled = false;
|
|
try
|
|
{
|
|
#if UNITY_2021_2_OR_NEWER
|
|
var packages = UnityEditor.PackageManager.PackageInfo.GetAllRegisteredPackages();
|
|
packageInstalled = packages.Any(p => p.name == "com.unity.ai.navigation");
|
|
#else
|
|
var listRequest = Client.List(true, false);
|
|
while (!listRequest.IsCompleted)
|
|
{
|
|
System.Threading.Thread.Sleep(50);
|
|
}
|
|
if (listRequest.Status == StatusCode.Success)
|
|
{
|
|
packageInstalled = listRequest.Result.Any(p => p.name == "com.unity.ai.navigation");
|
|
}
|
|
#endif
|
|
}
|
|
catch { }
|
|
|
|
bool isCompiling = EditorApplication.isCompiling;
|
|
|
|
string errorMessage;
|
|
if (packageInstalled && isCompiling)
|
|
{
|
|
errorMessage =
|
|
"[EXPERIMENTAL] NavMesh baking requires AI Navigation package types to be loaded. " +
|
|
"The package is installed but Unity is currently compiling. " +
|
|
"Please wait for compilation to complete by calling 'unity_editor { \"action\": \"wait_for_idle\" }', then retry.";
|
|
}
|
|
else if (packageInstalled)
|
|
{
|
|
errorMessage =
|
|
"[EXPERIMENTAL] NavMesh baking requires AI Navigation package types to be loaded. " +
|
|
"The package 'com.unity.ai.navigation' is installed but required types are not available. " +
|
|
"This may happen if: (1) compilation is in progress, (2) the package needs to be reloaded, or (3) Unity needs to be restarted. " +
|
|
"Try: (1) Call 'unity_editor { \"action\": \"wait_for_idle\" }' to ensure compilation is complete, " +
|
|
"(2) Wait a few seconds and retry, or (3) Restart Unity.";
|
|
}
|
|
else
|
|
{
|
|
errorMessage =
|
|
"[EXPERIMENTAL] NavMesh baking requires AI Navigation package. " +
|
|
"Install 'com.unity.ai.navigation' via Package Manager using: " +
|
|
"'unity_package { \"action\": \"install_package\", \"id_or_url\": \"com.unity.ai.navigation\" }', " +
|
|
"then wait for installation and compilation to complete using 'unity_editor { \"action\": \"wait_for_idle\" }'.";
|
|
}
|
|
|
|
return Response.Error(errorMessage);
|
|
}
|
|
}
|
|
|
|
// Get all active NavMeshSurface components in the scene
|
|
List<object> surfaces = new List<object>();
|
|
if (_activeSurfacesProperty != null)
|
|
{
|
|
var activeSurfaces = _activeSurfacesProperty.GetValue(null);
|
|
if (activeSurfaces is System.Collections.IList surfaceList)
|
|
{
|
|
foreach (var surface in surfaceList)
|
|
{
|
|
surfaces.Add(surface);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (surfaces.Count == 0)
|
|
{
|
|
// Fallback: find all NavMeshSurface components using Resources.FindObjectsOfTypeAll
|
|
if (_navMeshSurfaceType != null)
|
|
{
|
|
var allObjects = Resources.FindObjectsOfTypeAll(_navMeshSurfaceType);
|
|
foreach (var obj in allObjects)
|
|
{
|
|
if (obj != null)
|
|
{
|
|
surfaces.Add(obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (surfaces.Count == 0)
|
|
{
|
|
return Response.Error("[EXPERIMENTAL] No NavMeshSurface components found in the scene. Add a NavMeshSurface component to a GameObject to bake NavMesh.");
|
|
}
|
|
|
|
// Check if we should use async baking (UpdateNavMesh) or sync baking (BuildNavMesh)
|
|
bool useAsync = @params["async"]?.ToObject<bool?>() ?? false;
|
|
List<AsyncOperation> asyncOps = new List<AsyncOperation>();
|
|
|
|
if (useAsync && _updateNavMeshMethod != null)
|
|
{
|
|
// Use async UpdateNavMesh for each surface that has existing data
|
|
foreach (var surface in surfaces)
|
|
{
|
|
try
|
|
{
|
|
var navMeshDataProperty = _navMeshSurfaceType.GetProperty("navMeshData");
|
|
if (navMeshDataProperty != null)
|
|
{
|
|
var navMeshData = navMeshDataProperty.GetValue(surface);
|
|
if (navMeshData != null)
|
|
{
|
|
var asyncOp = _updateNavMeshMethod.Invoke(surface, new object[] { navMeshData }) as AsyncOperation;
|
|
if (asyncOp != null)
|
|
{
|
|
asyncOps.Add(asyncOp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// If UpdateNavMesh fails, fall back to BuildNavMesh
|
|
}
|
|
}
|
|
}
|
|
|
|
// If no async operations were started, use synchronous BuildNavMesh, which has
|
|
// already finished by the time it returns.
|
|
if (asyncOps.Count == 0)
|
|
{
|
|
foreach (var surface in surfaces)
|
|
{
|
|
_buildNavMeshMethod?.Invoke(surface, null);
|
|
}
|
|
|
|
return Response.Success("[EXPERIMENTAL] NavMesh baking completed", new
|
|
{
|
|
type = "navmesh",
|
|
hasNavMeshData = HasAnyNavMeshData(surfaces),
|
|
surfacesBaked = surfaces.Count,
|
|
});
|
|
}
|
|
|
|
// Async surfaces: run to completion instead of answering "pending" and leaving the
|
|
// client to poll a callback that would not survive an incidental domain reload.
|
|
return RunToCompletion(
|
|
new NavMeshBakeJob { Operations = asyncOps, SurfaceCount = surfaces.Count },
|
|
@params, 600);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return Response.Error($"[EXPERIMENTAL] Failed to start NavMesh baking: {e.Message}");
|
|
}
|
|
}
|
|
|
|
private static object ClearNavMesh()
|
|
{
|
|
try
|
|
{
|
|
if (!HasAINavigation())
|
|
{
|
|
return Response.Error("[EXPERIMENTAL] NavMesh operations require AI Navigation package.");
|
|
}
|
|
|
|
// Clear NavMesh using reflection - try RemoveAllNavMeshData first
|
|
int clearedCount = 0;
|
|
if (_removeAllNavMeshDataMethod != null)
|
|
{
|
|
_removeAllNavMeshDataMethod.Invoke(null, null);
|
|
clearedCount++;
|
|
}
|
|
|
|
// Also clear all NavMeshSurface components
|
|
if (_activeSurfacesProperty != null)
|
|
{
|
|
var activeSurfaces = _activeSurfacesProperty.GetValue(null);
|
|
if (activeSurfaces is System.Collections.IList surfaceList)
|
|
{
|
|
var removeDataMethod = _navMeshSurfaceType.GetMethod("RemoveData", BindingFlags.Public | BindingFlags.Instance);
|
|
foreach (var surface in surfaceList)
|
|
{
|
|
try
|
|
{
|
|
removeDataMethod?.Invoke(surface, null);
|
|
clearedCount++;
|
|
}
|
|
catch { }
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return Response.Success($"[EXPERIMENTAL] NavMesh data cleared ({clearedCount} surfaces).");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return Response.Error($"[EXPERIMENTAL] Failed to clear NavMesh: {e.Message}");
|
|
}
|
|
}
|
|
|
|
private static object ClearBakedData()
|
|
{
|
|
try
|
|
{
|
|
Lightmapping.Clear();
|
|
|
|
return Response.Success("[EXPERIMENTAL] Baked lighting data cleared.");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return Response.Error($"[EXPERIMENTAL] Failed to clear baked data: {e.Message}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|