jracek/secretsplash
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

psst

Browse Source
This commit is contained in:
Jan Racek
2026-03-24 13:00:54 +01:00
parent 53e993f58e
commit 4aa4e49424
145 changed files with 10853 additions and 2965 deletions
Download Patch File Download Diff File Expand all files Collapse all files

401
Editor/PSXNavRegionEditor.cs Normal file
View File

@@ -0,0 +1,401 @@
using UnityEngine;
using UnityEditor;
using SplashEdit.RuntimeCode;
using System.Collections.Generic;
namespace SplashEdit.EditorCode
{
/// <summary>
/// Editor window for PS1 navigation mesh generation.
/// Uses DotRecast (C# Recast) to voxelize scene geometry and build
/// convex navigation regions for the PS1 runtime.
/// All nav settings live on the PSXPlayer component so the editor
/// preview and the scene export always use the same values.
/// </summary>
public class PSXNavRegionEditor : EditorWindow
{
private PSXNavRegionBuilder _builder;
private bool _previewRegions = true;
private bool _previewPortals = true;
private bool _previewLabels = true;
private int _selectedRegion = -1;
private bool _showAdvanced = false;
[MenuItem("PSX/Nav Region Builder")]
public static void ShowWindow()
{
GetWindow<PSXNavRegionEditor>("Nav Region Builder");
}
private void OnEnable()
{
SceneView.duringSceneGui += OnSceneGUI;
}
private void OnDisable()
{
SceneView.duringSceneGui -= OnSceneGUI;
}
private void OnGUI()
{
EditorGUILayout.Space(5);
GUILayout.Label("PSX Nav Region Builder", EditorStyles.boldLabel);
EditorGUILayout.Space(5);
var players = FindObjectsByType<PSXPlayer>(FindObjectsSortMode.None);
if (players.Length == 0)
{
EditorGUILayout.HelpBox(
"No PSXPlayer in scene. Add a PSXPlayer component to configure navigation settings.",
MessageType.Warning);
return;
}
var player = players[0];
var so = new SerializedObject(player);
so.Update();
// Info
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
{
EditorGUILayout.HelpBox(
"Uses DotRecast (Recast voxelization) to build PS1 nav regions.\n" +
"Settings are on the PSXPlayer component so editor preview\n" +
"and scene export always match.\n" +
"1. Configure settings below (saved on PSXPlayer)\n" +
"2. Click 'Build Nav Regions' to preview\n" +
"3. Results export automatically with the scene",
MessageType.Info);
}
EditorGUILayout.Space(5);
// Agent settings (from PSXPlayer serialized fields)
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
{
GUILayout.Label("Agent Settings (PSXPlayer)", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(so.FindProperty("playerHeight"),
new GUIContent("Agent Height", "Camera eye height above feet"));
EditorGUILayout.PropertyField(so.FindProperty("playerRadius"),
new GUIContent("Agent Radius", "Collision radius for wall sliding"));
EditorGUILayout.PropertyField(so.FindProperty("maxStepHeight"),
new GUIContent("Max Step Height", "Maximum height the agent can step up"));
EditorGUILayout.PropertyField(so.FindProperty("walkableSlopeAngle"),
new GUIContent("Max Slope", "Maximum walkable slope angle in degrees"));
}
EditorGUILayout.Space(5);
// Advanced settings
_showAdvanced = EditorGUILayout.Foldout(_showAdvanced, "Advanced Settings");
if (_showAdvanced)
{
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
{
EditorGUILayout.PropertyField(so.FindProperty("navCellSize"),
new GUIContent("Cell Size", "Voxel size in XZ plane. Smaller = more accurate but slower."));
EditorGUILayout.PropertyField(so.FindProperty("navCellHeight"),
new GUIContent("Cell Height", "Voxel height. Smaller = more accurate vertical resolution."));
EditorGUILayout.Space(3);
float cs = player.NavCellSize;
float ch = player.NavCellHeight;
int walkH = (int)System.Math.Ceiling(player.PlayerHeight / ch);
int walkR = (int)System.Math.Ceiling(player.PlayerRadius / cs);
int walkC = (int)System.Math.Floor(player.MaxStepHeight / ch);
EditorGUILayout.LabelField("Voxel walkable height", $"{walkH} cells");
EditorGUILayout.LabelField("Voxel walkable radius", $"{walkR} cells");
EditorGUILayout.LabelField("Voxel walkable climb", $"{walkC} cells ({walkC * ch:F3} units)");
}
}
so.ApplyModifiedProperties();
EditorGUILayout.Space(5);
// Build button
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
{
GUILayout.Label("Generation", EditorStyles.boldLabel);
GUI.backgroundColor = new Color(0.4f, 0.8f, 0.4f);
if (GUILayout.Button("Build Nav Regions", GUILayout.Height(35)))
{
BuildNavRegions(player);
}
GUI.backgroundColor = Color.white;
if (_builder != null && _builder.RegionCount > 0)
{
EditorGUILayout.Space(3);
if (GUILayout.Button("Clear Regions"))
{
_builder = null;
_selectedRegion = -1;
SceneView.RepaintAll();
}
}
}
EditorGUILayout.Space(5);
// Visualization
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
{
GUILayout.Label("Visualization", EditorStyles.boldLabel);
_previewRegions = EditorGUILayout.Toggle("Show Regions", _previewRegions);
_previewPortals = EditorGUILayout.Toggle("Show Portals", _previewPortals);
_previewLabels = EditorGUILayout.Toggle("Show Labels", _previewLabels);
}
EditorGUILayout.Space(5);
// Statistics
if (_builder != null && _builder.RegionCount > 0)
{
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
{
GUILayout.Label("Statistics", EditorStyles.boldLabel);
EditorGUILayout.LabelField("Regions", _builder.RegionCount.ToString());
EditorGUILayout.LabelField("Portals", _builder.PortalCount.ToString());
var rooms = new HashSet<byte>();
for (int i = 0; i < _builder.RegionCount; i++)
rooms.Add(_builder.Regions[i].roomIndex);
EditorGUILayout.LabelField("Rooms", rooms.Count.ToString());
int exportSize = _builder.GetBinarySize();
EditorGUILayout.LabelField("Export Size",
$"{exportSize:N0} bytes ({exportSize / 1024f:F1} KB)");
int flat = 0, ramp = 0, stairs = 0;
for (int i = 0; i < _builder.RegionCount; i++)
{
switch (_builder.Regions[i].surfaceType)
{
case NavSurfaceType.Flat: flat++; break;
case NavSurfaceType.Ramp: ramp++; break;
case NavSurfaceType.Stairs: stairs++; break;
}
}
EditorGUILayout.LabelField("Types",
$"{flat} flat, {ramp} ramp, {stairs} stairs");
if (_selectedRegion >= 0 && _selectedRegion < _builder.RegionCount)
{
EditorGUILayout.Space(3);
GUILayout.Label($"Selected Region #{_selectedRegion}",
EditorStyles.miniLabel);
var region = _builder.Regions[_selectedRegion];
EditorGUILayout.LabelField(" Vertices",
region.vertsXZ.Count.ToString());
EditorGUILayout.LabelField(" Portals",
region.portalCount.ToString());
EditorGUILayout.LabelField(" Surface",
region.surfaceType.ToString());
EditorGUILayout.LabelField(" Room",
region.roomIndex.ToString());
EditorGUILayout.LabelField(" Floor Y",
$"{region.planeD:F2} (A={region.planeA:F3}, B={region.planeB:F3})");
}
}
ValidateRegions();
}
else
{
EditorGUILayout.HelpBox(
"No nav regions built. Click 'Build Nav Regions' to generate.",
MessageType.Warning);
}
}
// ====================================================================
// Build
// ====================================================================
private void BuildNavRegions(PSXPlayer player)
{
EditorUtility.DisplayProgressBar("Nav Region Builder", "Building nav regions with DotRecast...", 0.3f);
_builder = new PSXNavRegionBuilder();
_builder.AgentHeight = player.PlayerHeight;
_builder.AgentRadius = player.PlayerRadius;
_builder.MaxStepHeight = player.MaxStepHeight;
_builder.WalkableSlopeAngle = player.WalkableSlopeAngle;
_builder.CellSize = player.NavCellSize;
_builder.CellHeight = player.NavCellHeight;
Vector3 playerSpawn = player.transform.position;
player.FindNavmesh();
playerSpawn = player.CamPoint;
PSXObjectExporter[] exporters =
FindObjectsByType<PSXObjectExporter>(FindObjectsSortMode.None);
_builder.Build(exporters, playerSpawn);
_selectedRegion = -1;
EditorUtility.ClearProgressBar();
SceneView.RepaintAll();
}
// ====================================================================
// Validation
// ====================================================================
private void ValidateRegions()
{
if (_builder == null) return;
List<string> warnings = new List<string>();
for (int i = 0; i < _builder.RegionCount; i++)
{
var region = _builder.Regions[i];
if (region.vertsXZ.Count < 3)
warnings.Add($"Region {i}: degenerate ({region.vertsXZ.Count} verts)");
if (region.portalCount == 0 && _builder.RegionCount > 1)
warnings.Add($"Region {i}: isolated (no portals)");
if (region.vertsXZ.Count > 8)
warnings.Add($"Region {i}: too many verts ({region.vertsXZ.Count} > 8)");
}
int exportSize = _builder.GetBinarySize();
if (exportSize > 8192)
warnings.Add($"Export size {exportSize} bytes is large for PS1 (> 8KB)");
if (warnings.Count > 0)
{
EditorGUILayout.Space(5);
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
{
GUILayout.Label("Warnings", EditorStyles.boldLabel);
foreach (string w in warnings)
EditorGUILayout.LabelField(w, EditorStyles.miniLabel);
}
}
}
// ====================================================================
// Scene view drawing
// ====================================================================
private static readonly Color[] RoomColors = new Color[]
{
new Color(0.2f, 0.8f, 0.2f),
new Color(0.2f, 0.6f, 0.9f),
new Color(0.9f, 0.7f, 0.1f),
new Color(0.8f, 0.2f, 0.8f),
new Color(0.1f, 0.9f, 0.9f),
new Color(0.9f, 0.5f, 0.2f),
new Color(0.5f, 0.9f, 0.3f),
new Color(0.9f, 0.3f, 0.5f),
new Color(0.4f, 0.4f, 0.9f),
new Color(0.7f, 0.9f, 0.7f),
new Color(0.9f, 0.9f, 0.4f),
new Color(0.6f, 0.3f, 0.6f),
new Color(0.3f, 0.7f, 0.7f),
new Color(0.8f, 0.6f, 0.4f),
new Color(0.4f, 0.8f, 0.6f),
new Color(0.7f, 0.4f, 0.4f),
};
private void OnSceneGUI(SceneView sceneView)
{
if (_builder == null || _builder.RegionCount == 0) return;
var regions = _builder.Regions;
if (_previewRegions)
{
for (int i = 0; i < regions.Count; i++)
{
var region = regions[i];
bool selected = (i == _selectedRegion);
Color baseColor = RoomColors[region.roomIndex % RoomColors.Length];
float fillAlpha = selected ? 0.4f : 0.15f;
if (region.vertsXZ.Count >= 3)
{
Vector3[] worldVerts = new Vector3[region.vertsXZ.Count];
for (int v = 0; v < region.vertsXZ.Count; v++)
{
float y = region.planeA * region.vertsXZ[v].x +
region.planeB * region.vertsXZ[v].y +
region.planeD;
worldVerts[v] = new Vector3(
region.vertsXZ[v].x, y + 0.05f, region.vertsXZ[v].y);
}
Handles.color = selected
? Color.white
: new Color(baseColor.r, baseColor.g, baseColor.b, 0.8f);
for (int v = 0; v < worldVerts.Length; v++)
Handles.DrawLine(worldVerts[v],
worldVerts[(v + 1) % worldVerts.Length]);
Handles.color = new Color(baseColor.r, baseColor.g, baseColor.b,
fillAlpha);
for (int v = 1; v < worldVerts.Length - 1; v++)
Handles.DrawAAConvexPolygon(
worldVerts[0], worldVerts[v], worldVerts[v + 1]);
if (_previewLabels)
{
Vector3 center = Vector3.zero;
foreach (var wv in worldVerts) center += wv;
center /= worldVerts.Length;
string label = $"R{i}";
if (region.roomIndex != 0xFF)
label += $"\nRm{region.roomIndex}";
Handles.Label(center, label, EditorStyles.whiteBoldLabel);
if (Handles.Button(center, Quaternion.identity,
0.2f, 0.3f, Handles.SphereHandleCap))
{
_selectedRegion = i;
Repaint();
}
}
}
}
}
if (_previewPortals && _builder.Portals != null)
{
for (int i = 0; i < regions.Count; i++)
{
var region = regions[i];
int pStart = region.portalStart;
int pCount = region.portalCount;
for (int p = pStart;
p < pStart + pCount && p < _builder.Portals.Count; p++)
{
var portal = _builder.Portals[p];
float yA = region.planeA * portal.a.x +
region.planeB * portal.a.y + region.planeD;
float yB = region.planeA * portal.b.x +
region.planeB * portal.b.y + region.planeD;
Vector3 worldA = new Vector3(portal.a.x, yA + 0.08f, portal.a.y);
Vector3 worldB = new Vector3(portal.b.x, yB + 0.08f, portal.b.y);
if (Mathf.Abs(portal.heightDelta) <= 0.35f)
Handles.color = new Color(1f, 1f, 1f, 0.9f);
else
Handles.color = new Color(1f, 0.9f, 0.2f, 0.9f);
Handles.DrawLine(worldA, worldB, 3f);
}
}
}
}
}
}