2885 lines
163 KiB
C#
2885 lines
163 KiB
C#
using UnityEngine;
|
|
using UnityEditor;
|
|
using System.Collections.Generic;
|
|
using UnityEditor.SceneManagement;
|
|
|
|
// Sci-Fi Ship Controller. Copyright (c) 2018-2022 SCSM Pty Ltd. All rights reserved.
|
|
namespace SciFiShipController
|
|
{
|
|
[CustomEditor(typeof(SSCManager))]
|
|
public class SSCManagerEditor : Editor
|
|
{
|
|
#region Custom Editor private variables
|
|
|
|
private SSCManager sscManager;
|
|
|
|
// Formatting and style variables
|
|
private string txtColourName = "Black";
|
|
private Color defaultTextColour = Color.black;
|
|
private string labelText;
|
|
private GUIStyle labelFieldRichText;
|
|
private GUIStyle helpBoxRichText;
|
|
private GUIStyle buttonCompact;
|
|
private GUIStyle buttonCompactBoldBlue;
|
|
private GUIStyle foldoutStyleNoLabel;
|
|
private static GUIStyle toggleCompactButtonStyleNormal = null; // Small Toggle button. e.g. G(izmo) on/off
|
|
private static GUIStyle toggleCompactButtonStyleToggled = null;
|
|
private float defaultEditorLabelWidth = 0f;
|
|
private float defaultEditorFieldWidth = 0f;
|
|
private int selectedTabInt = 0;
|
|
private GUIStyle searchTextFieldStyle = null;
|
|
private GUIStyle searchCancelButtonStyle = null;
|
|
private float defaultSearchTextFieldWidth = 200f;
|
|
|
|
private bool isDebuggingEnabled = false;
|
|
private List<ProjectileTemplate> projectileTemplatesList;
|
|
private List<BeamTemplate> beamTemplateList;
|
|
private List<DestructTemplate> destructTemplateList;
|
|
private List<EffectsObjectTemplate> effectsObjectTemplatesList;
|
|
|
|
// location data variables
|
|
private int numLocations = 0;
|
|
private int numFilteredLocations = 0;
|
|
private int locationDataMoveDownPos = -1;
|
|
private int locationDataInsertPos = -1;
|
|
private int locationDataDeletePos = -1;
|
|
private Vector2 locationScrollPosition = Vector2.zero;
|
|
private bool isModifySelectedMode = false;
|
|
private float modifySelectedPosY = 0f;
|
|
private float modifySelectedAddPosY = 0f;
|
|
|
|
// path data variables
|
|
private int numPaths = 0;
|
|
private int numFilteredPaths = 0;
|
|
private int pathDataMoveDownPos = -1;
|
|
private int pathDataInsertPos = -1;
|
|
private int pathDataDeletePos = -1;
|
|
private int numPathLocations = 0;
|
|
private int pathDataLocationMoveDownPos = -1;
|
|
private int pathDataLocationInsertPos = -1;
|
|
private int pathDataLocationDeletePos = -1;
|
|
private bool pathLocationDataIsSelected = false; // Temp variable
|
|
|
|
private string sscHelpPDF;
|
|
|
|
#endregion
|
|
|
|
#region Custom Editor Sceneview variables
|
|
|
|
private bool isSceneDirtyRequired = false;
|
|
private bool isSetFocusEnabled = false; // has the manager just been enabled and we need to set focus to the sceneview?
|
|
private LocationData locationDataItem;
|
|
private Vector3 itemHandlePosition = Vector3.zero;
|
|
//private Vector3 gizmoPosition = Vector3.zero;
|
|
private Quaternion itemHandleRotation = Quaternion.identity;
|
|
private Vector3 itemHandleScale = Vector3.one;
|
|
private Vector3 controlHandleSnap = Vector3.one * 0.3f;
|
|
private Vector3 newControlPoint;
|
|
private Color fadedGizmoColour;
|
|
private float startFadeDistSqr = 4000000f; // 2km x 2km
|
|
private float maxFadeDistSqr = 400000000f;
|
|
|
|
|
|
// Draw Path variables
|
|
private GUIStyle distanceLabel;
|
|
private Vector3 pointLabelOffset = Vector3.up * 2f;
|
|
private Vector3 locationPosition;
|
|
private string locationName;
|
|
|
|
#endregion
|
|
|
|
#region GUIContent - General
|
|
|
|
private GUIContent[] tabTexts = { new GUIContent("Locations"), new GUIContent("Paths"), new GUIContent("Options") };
|
|
|
|
private readonly static GUIContent headerContent = new GUIContent("The Manager is automatically added to " +
|
|
"the scene if it doesn't already exist at runtime. It includes projectile and effects object management for all ships along with Location and Path management.");
|
|
|
|
private readonly static GUIContent debugModeContent = new GUIContent("Debug Mode", "Use this to display pool sizes at runtime in the editor. This can help optimise the min/max pool size values.");
|
|
private readonly static GUIContent projectileHeaderContent = new GUIContent("<b>Projectile Templates</b>", "The Projectile Templates that use pooling or DOTS");
|
|
private readonly static GUIContent projectilePoolingContent = new GUIContent(" Current Pool Size", "The current size of the projectile pool");
|
|
#if SSC_ENTITIES
|
|
private readonly static GUIContent projectileDOTSContent = new GUIContent(" Use DOTS is enabled", "The projectiles will be converted to Entities");
|
|
#else
|
|
private readonly static GUIContent projectileDOTSNotAvailableContent = new GUIContent(" Use DOTS is enabled but DOTS is not configured", "The projectile cannot use DOTS because it is not available in the project");
|
|
#endif
|
|
private readonly static GUIContent minmaxPoolSizeContent = new GUIContent("Min/Max", "The minimum and maximum size of the pool");
|
|
private readonly static GUIContent beamHeaderContent = new GUIContent("<b>Beam Templates</b>", "The Beam Templates that use pooling");
|
|
private readonly static GUIContent beamPoolingContent = new GUIContent(" Current Pool Size", "The current size of the beam pool");
|
|
private readonly static GUIContent destructHeaderContent = new GUIContent("<b>Destruct Templates</b>", "The Destruct Templates that use pooling");
|
|
private readonly static GUIContent destructPoolingContent = new GUIContent(" Current Pool Size", "The current size of the destruct pool");
|
|
|
|
private readonly static GUIContent effectsHeaderContent = new GUIContent("<b>Effects Templates</b>", "The Effects Object Templates that use pooling");
|
|
private readonly static GUIContent effectsPoolingContent = new GUIContent(" Current Pool Size", "The current size of the effects pool");
|
|
private readonly static GUIContent noneWithPoolingContent = new GUIContent(" (None with <i>Use Pooling</i> enabled)");
|
|
|
|
private readonly static GUIContent findBtnContent = new GUIContent("F", "Find in the scene view");
|
|
private readonly static GUIContent gizmoBtnContent = new GUIContent("G", "Toggle gizmos on/off in the scene view");
|
|
private readonly static GUIContent gizmoToggleBtnContent = new GUIContent("G", "Toggle gizmos and visualisations on/off for all items in the scene view");
|
|
private readonly static GUIContent selectBtnContent = new GUIContent("S", "Toggle selection on/off in the scene view");
|
|
private readonly static GUIContent modifyToggleBtnContent = new GUIContent("M", "Modify an attribute of all selected Locations");
|
|
private readonly static GUIContent reversePathBtnContent = new GUIContent("<->", "Reverse the direction of the path");
|
|
private readonly static GUIContent filterContent = new GUIContent("<b>Filter</b>", "Filter the items in the list by entering part of the item name");
|
|
|
|
private readonly static GUIContent modifySelectedPosYContent = new GUIContent(" New Position Y-axis", "The new Position Y value for all selected Locations in this Path");
|
|
private readonly static GUIContent modifySelectedAddPosYContent = new GUIContent(" Add Position Y-axis", "Add (or subtract) amount to Position Y value for all selected Locations in this Path");
|
|
|
|
#endregion
|
|
|
|
#region GUIContent - Locations
|
|
private readonly static GUIContent locationHeaderContent = new GUIContent("To create a Location, move the mouse over scene view and press the + key. " +
|
|
"The scene window needs to have the focus. Hold SHIFT key to multi-select Locations.");
|
|
private readonly static GUIContent locationDefaultNormalOffsetContent = new GUIContent("Default Normal Offset", "The distance to place a new Location away from the line of sight object");
|
|
private readonly static GUIContent locationDataNameContent = new GUIContent("Location Name", "Name of the Location. E.g. Enemy Base, Route Marker 2, Command Post");
|
|
private readonly static GUIContent locationDataPositionContent = new GUIContent("Location Position", "World-space coordinates of the Location");
|
|
private readonly static GUIContent locationDataIsRadarEnabledContent = new GUIContent("Visible to Radar", "Is this Location visible to the radar system?");
|
|
private readonly static GUIContent locationDataRadarBlipSizedContent = new GUIContent("Radar Blip Size", "The relative size of the blip on the radar mini-map.");
|
|
private readonly static GUIContent locationDataFactionIdContent = new GUIContent("Faction Id", "The faction or alliance the Location belongs to. This can be used to identify if a Location is friend or foe. Neutral = 0.");
|
|
#endregion
|
|
|
|
#region GUIContent - Paths
|
|
private readonly static GUIContent pathDataHeaderContent = new GUIContent("A Path is an ordered list of Locations. Add a new Path, select the Scene view, move the mouse over the " +
|
|
" Scene, and press the + key where you want to add Locations. OR Add a Location slot in the Inspector before assigning an existing Location to that slot. " +
|
|
" Deleting a Location slot does not delete the Location. There is also a context menu in the scene view. Hold SHIFT key to move all selected Locations in a Path.");
|
|
private readonly static GUIContent pathDataNameContent = new GUIContent("Path Name", "Name of the path.");
|
|
private readonly static GUIContent pathDataActiveContent = new GUIContent("A", "Make this the Path active for editing in the scene");
|
|
private readonly static GUIContent pathDataActivateContent = new GUIContent("Activate for editing", "Make this the Path active for editing in the scene");
|
|
private readonly static GUIContent pathDataActivatedContent = new GUIContent("Stop Editing", "Stop editing this Path in the scene");
|
|
private readonly static GUIContent pathDataExportJsonContent = new GUIContent("Export Json", "Export the Path to a Json file");
|
|
private readonly static GUIContent pathDataSnapToMeshContent = new GUIContent("Snap To Mesh", "Will attempt to position all locations on the Path above the top mesh in the scene.");
|
|
private readonly static GUIContent pathDataImportJsonContent = new GUIContent("Import", "Import Path data from a Json file (should be from the same version of Sci-Fi Ship Controller)");
|
|
private readonly static GUIContent pathDataTotalDistanceContent = new GUIContent("Total Distance", "The total spline length or distance of the Path");
|
|
private readonly static GUIContent pathDataIsClosedCircuitContent = new GUIContent("Closed Circuit", "Is this Path a closed circuit or loop?");
|
|
private readonly static GUIContent pathDataLineColourContent = new GUIContent("Line Colour", "The colour of the Path drawn in the scene.");
|
|
private readonly static GUIContent pathDataLocationDefaultNormalOffsetContent = new GUIContent("Default Normal Offset", "The distance to place a new Location on the Path away from the line of sight object");
|
|
private readonly static GUIContent pathDataLocationSnapMinMaxHeightContent = new GUIContent("Snap Min/Max Height", "The minimum and maximum heights checked when Snap To Mesh is used.");
|
|
private readonly static GUIContent pathDataShowPointNumberLabelsInSceneContent = new GUIContent("Display Number Labels", "Display the Location number labels in the scene view");
|
|
private readonly static GUIContent pathDataShowPointNameLabelsInSceneContent = new GUIContent("Display Name Labels", "Display the Location name labels in the scene view");
|
|
private readonly static GUIContent pathDataShowDistanceLabelsInSceneContent = new GUIContent("Display Distances", "Display cumulative distances in the scene view");
|
|
|
|
#endregion
|
|
|
|
#region GUIContent - Options
|
|
private readonly static GUIContent optionLocationContent = new GUIContent("<b>Location Options</b>");
|
|
private readonly static GUIContent optionIsAutosizeLocationGizmoContent = new GUIContent("Autosize Gizmos", "Autosize Location gizmos in scene view so they are visible a long way away.");
|
|
private readonly static GUIContent optionLocationGizmoColourContent = new GUIContent("Gizmo Colour", "Colour of the Location gizmos in the scene view");
|
|
private readonly static GUIContent optionFindZoomDistanceContent = new GUIContent("Zoom Distance", "The default zoom distance when using the (F)ind buttons in the inspector, or Zoom content menu in the scene");
|
|
private readonly static GUIContent optionPathContent = new GUIContent("<b>Path Options</b>");
|
|
private readonly static GUIContent optionPathControlGizmoColourContent = new GUIContent("Control Gizmo Colour", "Colour of the Path tangent control gizmos in the scene view");
|
|
private readonly static GUIContent optionPathDisplayResolutionContent = new GUIContent("Display Resolution", "The appromiate length of each Path segment drawn in the scene view");
|
|
private readonly static GUIContent optionPathPrecisionContent = new GUIContent("Path Precision", "Determines how precisely the Path distance should be calculated. Keep as low as possible when editing in the scene.");
|
|
private readonly static GUIContent optionPathControlOffsetContent = new GUIContent("Default Control Offset", "Default control point offset distance from the Path Location");
|
|
//private readonly static GUIContent optionRadarContent = new GUIContent("<b>Radar Options</b>");
|
|
|
|
#endregion
|
|
|
|
#region Serialized Properties - Locations
|
|
private SerializedProperty locationDataListProp;
|
|
private SerializedProperty locationDefaultNormalOffsetProp;
|
|
private SerializedProperty locationDataProp;
|
|
private SerializedProperty locationDataNameProp;
|
|
private SerializedProperty locationDataPositionProp;
|
|
private SerializedProperty locationDataSelectedProp;
|
|
private SerializedProperty locationDataGUIDHashProp;
|
|
private SerializedProperty isLocationDataListExpandedProp;
|
|
private SerializedProperty locationDataShowInEditorProp;
|
|
private SerializedProperty locationDataShowGizmosInSceneViewProp;
|
|
#endregion
|
|
|
|
#region Serialized Properties - Paths
|
|
private SerializedProperty pathDataListProp;
|
|
private SerializedProperty pathDataActiveGUIDHashProp;
|
|
private SerializedProperty pathDataProp;
|
|
private SerializedProperty pathDataNameProp;
|
|
private SerializedProperty pathDataGUIDHashProp;
|
|
private SerializedProperty isPathDataListExpandedProp;
|
|
private SerializedProperty pathDataShowInEditorProp;
|
|
private SerializedProperty pathDataShowLocationsInEditorProp;
|
|
private SerializedProperty pathDataShowInSceneViewProp;
|
|
private SerializedProperty pathDataIsClosedCircuitProp;
|
|
private SerializedProperty pathDataLineColourProp;
|
|
private SerializedProperty pathDataShowNumberLabelsProp;
|
|
private SerializedProperty pathDataShowNameLabelsProp;
|
|
private SerializedProperty pathLocationDataListProp;
|
|
private SerializedProperty pathLocationDataProp;
|
|
private SerializedProperty pathLocationDataLocationProp;
|
|
private SerializedProperty pathDataLocationNameProp;
|
|
private SerializedProperty pathDataLocationPositionProp;
|
|
private SerializedProperty pathDataLocationSelectedProp;
|
|
private SerializedProperty pathDataLocationUnassignedProp;
|
|
private SerializedProperty pathDataLocationGUIDHashProp;
|
|
private SerializedProperty pathDataLocationShowGizmosInSceneViewProp;
|
|
private SerializedProperty pathDataLocationShowInEditorProp;
|
|
#endregion
|
|
|
|
#region Serialized Properties - Options
|
|
private SerializedProperty isAutosizeLocationGizmoProp;
|
|
private SerializedProperty locationGizmoColourProp;
|
|
private SerializedProperty findZoomDistanceProp;
|
|
private SerializedProperty defaultPathControlGizmoColourProp;
|
|
private SerializedProperty pathDisplayResolutionProp;
|
|
private SerializedProperty pathPrecisionProp;
|
|
private SerializedProperty defaultPathControlOffsetProp;
|
|
|
|
#endregion
|
|
|
|
#region Events
|
|
|
|
public void OnEnable()
|
|
{
|
|
sscManager = (SSCManager)target;
|
|
|
|
// Only use if require scene view interaction
|
|
#if UNITY_2019_1_OR_NEWER
|
|
SceneView.duringSceneGui -= SceneGUI;
|
|
SceneView.duringSceneGui += SceneGUI;
|
|
#else
|
|
SceneView.onSceneGUIDelegate -= SceneGUI;
|
|
SceneView.onSceneGUIDelegate += SceneGUI;
|
|
#endif
|
|
|
|
//Used in Richtext labels
|
|
if (EditorGUIUtility.isProSkin) { txtColourName = "White"; defaultTextColour = new Color(180f / 255f, 180f / 255f, 180f / 255f, 1f); }
|
|
|
|
//Keep compiler happy - can remove this later if it isn't required
|
|
if (defaultTextColour.a > 0f) { }
|
|
|
|
// Reset guistyles to avoid issues - forces reinitialisation of button styles etc
|
|
helpBoxRichText = null;
|
|
labelFieldRichText = null;
|
|
buttonCompact = null;
|
|
buttonCompactBoldBlue = null;
|
|
foldoutStyleNoLabel = null;
|
|
toggleCompactButtonStyleNormal = null;
|
|
toggleCompactButtonStyleToggled = null;
|
|
searchTextFieldStyle = null;
|
|
searchCancelButtonStyle = null;
|
|
|
|
defaultEditorLabelWidth = 150f; // EditorGUIUtility.labelWidth;
|
|
defaultEditorFieldWidth = EditorGUIUtility.fieldWidth;
|
|
|
|
#region FindProperties
|
|
// Locations
|
|
locationDataListProp = serializedObject.FindProperty("locationDataList");
|
|
locationDefaultNormalOffsetProp = serializedObject.FindProperty("locationDefaultNormalOffset");
|
|
isLocationDataListExpandedProp = serializedObject.FindProperty("isLocationDataListExpanded");
|
|
|
|
// Paths
|
|
pathDataListProp = serializedObject.FindProperty("pathDataList");
|
|
isPathDataListExpandedProp = serializedObject.FindProperty("isPathDataListExpanded");
|
|
pathDataActiveGUIDHashProp = serializedObject.FindProperty("pathDataActiveGUIDHash");
|
|
|
|
// Options
|
|
isAutosizeLocationGizmoProp = serializedObject.FindProperty("isAutosizeLocationGizmo");
|
|
locationGizmoColourProp = serializedObject.FindProperty("locationGizmoColour");
|
|
findZoomDistanceProp = serializedObject.FindProperty("findZoomDistance");
|
|
defaultPathControlGizmoColourProp = serializedObject.FindProperty("defaultPathControlGizmoColour");
|
|
defaultPathControlOffsetProp = serializedObject.FindProperty("defaultPathControlOffset");
|
|
pathDisplayResolutionProp = serializedObject.FindProperty("pathDisplayResolution");
|
|
pathPrecisionProp = serializedObject.FindProperty("pathPrecision");
|
|
#endregion
|
|
|
|
sscHelpPDF = SSCEditorHelper.GetHelpURL();
|
|
|
|
// Deselect all Locations in the scene view
|
|
//SelectAllLocations(false, false);
|
|
|
|
// Turn off the gizmos for the selected Path Gameobject
|
|
Tools.hidden = true;
|
|
// Switch to the Move tool
|
|
Tools.current = Tool.Move;
|
|
|
|
if (!EditorApplication.isPlayingOrWillChangePlaymode)
|
|
{
|
|
// This is a workaround to make the scene active so that
|
|
// adding locations works first time without first having to
|
|
// select the scene (right click, click the scene window title etc)
|
|
isSetFocusEnabled = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called automatically by Unity when the gameobject loses focus
|
|
/// </summary>
|
|
private void OnDisable()
|
|
{
|
|
// Turn on the default scene handles
|
|
Tools.hidden = false;
|
|
Tools.current = Tool.Move;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the gameobject loses focus or Unity Editor enters/exits
|
|
/// play mode
|
|
/// </summary>
|
|
private void OnDestroy()
|
|
{
|
|
#if UNITY_2019_1_OR_NEWER
|
|
SceneView.duringSceneGui -= SceneGUI;
|
|
#else
|
|
SceneView.onSceneGUIDelegate -= SceneGUI;
|
|
#endif
|
|
|
|
// Always unhide Unity tools when losing focus on this gameObject
|
|
Tools.hidden = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets called automatically 10 times per second
|
|
/// Comment out if not required
|
|
/// </summary>
|
|
private void OnInspectorUpdate()
|
|
{
|
|
// OnInspectorGUI() only registers events when the mouse is positioned over the custom editor window
|
|
// This code forces OnInspectorGUI() to run every frame, so it registers events even when the mouse
|
|
// is positioned over the scene view
|
|
if (sscManager != null && sscManager.allowRepaint) { Repaint(); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Static Methods
|
|
// Add a menu item so that a SSCManager can be created via the GameObject > 3D Object menu
|
|
[MenuItem("GameObject/3D Object/Sci-Fi Ship Controller/SSC Manager")]
|
|
public static void CreateSSCManager()
|
|
{
|
|
SSCManager mgr = SSCManager.GetOrCreateManager();
|
|
if (!Application.isPlaying)
|
|
{
|
|
EditorSceneManager.MarkSceneDirty(mgr.gameObject.scene);
|
|
EditorUtility.SetDirty(mgr);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Private Member Methods
|
|
|
|
/// <summary>
|
|
/// Add (or subtract) to the y-axis position for all the selected Locations in the Path
|
|
/// </summary>
|
|
/// <param name="listProp"></param>
|
|
/// <param name="searchFilter"></param>
|
|
/// <param name="addPositionY"></param>
|
|
private void AddPosYSelectList(PathData pathData, float addPositionY)
|
|
{
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Path y-axis on selected");
|
|
|
|
int numInList = pathData == null || pathData.pathLocationDataList == null ? 0 : pathData.pathLocationDataList.Count;
|
|
|
|
for (int idx = 0; idx < numInList; idx++)
|
|
{
|
|
// Get the PathLocationData class instance from the list
|
|
PathLocationData pathLocationData = pathData.pathLocationDataList[idx];
|
|
|
|
// Get the LocationData class reference from within the PathLocationData class instance
|
|
LocationData locationData = pathLocationData.locationData;
|
|
|
|
if (!locationData.isUnassigned && locationData.selectedInSceneView)
|
|
{
|
|
Vector3 wsPosition = locationData.position;
|
|
wsPosition.y += addPositionY;
|
|
|
|
locationData.position = wsPosition;
|
|
|
|
// Update the control points to match the new Y position
|
|
Vector3 newControlPoint = pathLocationData.inControlPoint;
|
|
newControlPoint.y += addPositionY;
|
|
pathLocationData.inControlPoint = newControlPoint;
|
|
pathLocationData.outControlPoint = wsPosition + ((wsPosition - newControlPoint).normalized * (wsPosition - pathLocationData.outControlPoint).magnitude);
|
|
}
|
|
}
|
|
|
|
if (numInList > 0) { sscManager.RefreshPathDistances(pathData); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Attempt to find a path for the first selected location, and being to edit it
|
|
/// </summary>
|
|
private void EditLocationPath()
|
|
{
|
|
if (sscManager != null)
|
|
{
|
|
int numLocations = sscManager.locationDataList == null ? 0 : sscManager.locationDataList.Count;
|
|
int numPaths = sscManager.pathDataList == null ? 0 : sscManager.pathDataList.Count;
|
|
|
|
// If no paths or no locations, then nothing to edit
|
|
if (numPaths > 0 && numLocations > 0)
|
|
{
|
|
LocationData locationData = null;
|
|
|
|
for (int locIdx = 0; locIdx < numLocations; locIdx++)
|
|
{
|
|
locationData = sscManager.locationDataList[locIdx];
|
|
int locDataGUIDHash = locationData.guidHash;
|
|
if (locationData != null && locationData.selectedInSceneView)
|
|
{
|
|
// Is this location a member of a path?
|
|
for (int pIdx = 0; pIdx < numPaths; pIdx++)
|
|
{
|
|
PathData pathData = sscManager.pathDataList[pIdx];
|
|
if (pathData != null && pathData.pathLocationDataList != null && pathData.pathLocationDataList.Exists(locData => !locData.locationData.isUnassigned && locData.locationData.guidHash == locDataGUIDHash))
|
|
{
|
|
// Found a path for this selected location
|
|
// Set as active path
|
|
sscManager.pathDataActiveGUIDHash = pathData.guidHash;
|
|
// Make sure we're on the Path tab
|
|
selectedTabInt = 1;
|
|
// Get out of these loops and exit the function
|
|
locIdx = numLocations;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the Position Y from the first selected locations in the path list of locations
|
|
/// </summary>
|
|
/// <param name="listProp"></param>
|
|
/// <param name="searchFilter"></param>
|
|
private float GetPosYSelectList(SerializedProperty listProp)
|
|
{
|
|
float positionY = 0f;
|
|
if (listProp != null)
|
|
{
|
|
int numInList = listProp.arraySize;
|
|
|
|
for (int idx = 0; idx < numInList; idx++)
|
|
{
|
|
// Get the PathLocationData class instance from the list
|
|
pathLocationDataProp = listProp.GetArrayElementAtIndex(idx);
|
|
// Get the LocationData class reference from within the PathLocationData class instance
|
|
pathLocationDataLocationProp = pathLocationDataProp.FindPropertyRelative("locationData");
|
|
|
|
pathDataLocationPositionProp = pathLocationDataLocationProp.FindPropertyRelative("position");
|
|
pathDataLocationSelectedProp = pathLocationDataLocationProp.FindPropertyRelative("selectedInSceneView");
|
|
pathDataLocationUnassignedProp = pathLocationDataLocationProp.FindPropertyRelative("isUnassigned");
|
|
|
|
if (!pathDataLocationUnassignedProp.boolValue && pathDataLocationSelectedProp.boolValue)
|
|
{
|
|
positionY = pathDataLocationPositionProp.vector3Value.y;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
return positionY;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set all the selected Locations in the Path to have a new y-axis position
|
|
/// </summary>
|
|
/// <param name="listProp"></param>
|
|
/// <param name="searchFilter"></param>
|
|
/// <param name="newPositionY"></param>
|
|
private void SetPosYSelectList(PathData pathData, float newPositionY)
|
|
{
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Path y-axis on selected");
|
|
|
|
int numInList = pathData == null || pathData.pathLocationDataList == null ? 0 : pathData.pathLocationDataList.Count;
|
|
|
|
for (int idx = 0; idx < numInList; idx++)
|
|
{
|
|
// Get the PathLocationData class instance from the list
|
|
PathLocationData pathLocationData = pathData.pathLocationDataList[idx];
|
|
|
|
// Get the LocationData class reference from within the PathLocationData class instance
|
|
LocationData locationData = pathLocationData.locationData;
|
|
|
|
if (!locationData.isUnassigned && locationData.selectedInSceneView)
|
|
{
|
|
Vector3 wsPosition = locationData.position;
|
|
wsPosition.y = newPositionY;
|
|
|
|
locationData.position = wsPosition;
|
|
|
|
// Update the control points to match the new Y position
|
|
Vector3 newControlPoint = pathLocationData.inControlPoint;
|
|
newControlPoint.y = wsPosition.y;
|
|
pathLocationData.inControlPoint = newControlPoint;
|
|
pathLocationData.outControlPoint = wsPosition + ((wsPosition - newControlPoint).normalized * (wsPosition - pathLocationData.outControlPoint).magnitude);
|
|
}
|
|
}
|
|
|
|
if (numInList > 0) { sscManager.RefreshPathDistances(pathData); }
|
|
}
|
|
|
|
private void SceneGUI(SceneView sv)
|
|
{
|
|
if (sscManager != null && sscManager.gameObject.activeInHierarchy)
|
|
{
|
|
isSceneDirtyRequired = false;
|
|
Event currentEvent = Event.current;
|
|
bool isRightButton = (currentEvent.button == 1);
|
|
bool isCtrlKey = currentEvent.control;
|
|
bool isShiftKey = currentEvent.shift;
|
|
|
|
// Make the scene active so that it receives key events correctly
|
|
// when the sscmanger is selected
|
|
if (isSetFocusEnabled) { sv.Focus(); isSetFocusEnabled = false; }
|
|
|
|
#region Context Menu
|
|
if (currentEvent.type == EventType.MouseDown && isRightButton && Tools.current != Tool.View && Tools.current != Tool.None)
|
|
{
|
|
// If user has Path tab selected, see if there is an active path
|
|
PathData activePath = selectedTabInt == 1 ? sscManager.GetPath(sscManager.pathDataActiveGUIDHash) : null;
|
|
bool isEditPath = activePath != null;
|
|
|
|
GenericMenu menu = new GenericMenu();
|
|
menu.AddDisabledItem(new GUIContent(isEditPath ? (string.IsNullOrEmpty(activePath.name) ? "Edit (unnamed) Path" : activePath.name) : "Edit Locations")); // Header
|
|
if (isEditPath)
|
|
{
|
|
menu.AddItem(new GUIContent("Stop Editing Path"), false, () => { sscManager.pathDataActiveGUIDHash = -1; isEditPath = false; activePath = null; } );
|
|
}
|
|
else
|
|
{
|
|
menu.AddItem(new GUIContent("Start Editing Path for location"), false, () => { EditLocationPath(); });
|
|
}
|
|
|
|
#region Context Menu - Selection
|
|
menu.AddSeparator("");
|
|
if (isEditPath)
|
|
{
|
|
menu.AddItem(new GUIContent("Select All (Active Path)"), false, () => { SelectPathLocations(activePath, true); });
|
|
menu.AddItem(new GUIContent("Unselect All (Active Path)"), false, () => { SelectPathLocations(activePath, false); });
|
|
}
|
|
menu.AddItem(new GUIContent("Select All Locations"), false, () => { SelectAllLocations(true, false); });
|
|
menu.AddItem(new GUIContent("Unselect All Locations"), false, () => { SelectAllLocations(false, false); });
|
|
#endregion
|
|
|
|
#region Context Menu - Add Location
|
|
menu.AddSeparator("");
|
|
if (isEditPath)
|
|
{
|
|
menu.AddItem(new GUIContent("Insert Before 1st Selected (Active Path)"), false, () =>
|
|
{
|
|
int _firstSelected = activePath.pathLocationDataList.FindIndex(locData => locData.locationData.selectedInSceneView == true);
|
|
|
|
if (_firstSelected >= 0)
|
|
{
|
|
Undo.RecordObject(sscManager, "Insert in Active Path");
|
|
LocationData locationData = sscManager.InsertLocationAt(activePath, _firstSelected, true, true);
|
|
if (locationData != null) { locationData.selectedInSceneView = true; }
|
|
isSceneDirtyRequired = true;
|
|
}
|
|
}
|
|
);
|
|
|
|
menu.AddItem(new GUIContent("Append Location (Active Path)"), false, () =>
|
|
{
|
|
Vector3 posWS = Vector3.zero;
|
|
if (SSCEditorHelper.GetPositionFromMouse(sv, currentEvent.mousePosition, sscManager.locationDefaultNormalOffset, ref posWS, true))
|
|
{
|
|
currentEvent.Use();
|
|
Undo.RecordObject(sscManager, "Append Path Location");
|
|
|
|
// Unselect existing path locations so only extended location path is selected afterwards
|
|
SelectPathLocations(activePath, false);
|
|
|
|
LocationData locationData = sscManager.AppendLocation(activePath, posWS, true, true);
|
|
if (locationData != null) { locationData.selectedInSceneView = true; }
|
|
isSceneDirtyRequired = true;
|
|
}
|
|
});
|
|
|
|
menu.AddItem(new GUIContent("Extend Active Path"), false, () =>
|
|
{
|
|
int numPathPoints = activePath.pathLocationDataList == null ? 0 : activePath.pathLocationDataList.Count;
|
|
Vector3 posWS = Vector3.zero;
|
|
|
|
// If no points in Path add one at the current mouse point
|
|
if (numPathPoints < 1)
|
|
{
|
|
if (SSCEditorHelper.GetPositionFromMouse(sv, currentEvent.mousePosition, sscManager.locationDefaultNormalOffset, ref posWS, true))
|
|
{
|
|
currentEvent.Use();
|
|
Undo.RecordObject(sscManager, "Append Path Location");
|
|
LocationData locationData = sscManager.AppendLocation(activePath, posWS, true, true);
|
|
if (locationData != null) { locationData.selectedInSceneView = true; }
|
|
isSceneDirtyRequired = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Undo.RecordObject(sscManager, "Extend Active Path");
|
|
LocationData locationData = sscManager.AppendLocation(activePath, true, true);
|
|
if (locationData != null) { locationData.selectedInSceneView = true; }
|
|
isSceneDirtyRequired = true;
|
|
}
|
|
});
|
|
}
|
|
else
|
|
{
|
|
menu.AddItem(new GUIContent("Add Location"), false, () =>
|
|
{
|
|
Vector3 posWS = Vector3.zero;
|
|
if (SSCEditorHelper.GetPositionFromMouse(sv, currentEvent.mousePosition, sscManager.locationDefaultNormalOffset, ref posWS, true))
|
|
{
|
|
currentEvent.Use();
|
|
Undo.RecordObject(sscManager, "Add Location");
|
|
LocationData locationData = sscManager.AppendLocation(posWS, true);
|
|
if (locationData != null) { locationData.selectedInSceneView = true; }
|
|
isSceneDirtyRequired = true;
|
|
}
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region Context Menu - Control Points and Snap Location(s)
|
|
if (isEditPath)
|
|
{
|
|
menu.AddItem(new GUIContent("Set Controls to Location Y (Selected)"), false, () =>
|
|
{
|
|
SetPathControlPointsY(activePath);
|
|
isSceneDirtyRequired = true;
|
|
});
|
|
|
|
menu.AddItem(new GUIContent("Snap Locations to Mesh Below (Selected)"), false, () =>
|
|
{
|
|
sscManager.SnapPathSelectedLocationsToMesh(activePath, Vector3.up, ~0, true);
|
|
isSceneDirtyRequired = true;
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
menu.AddSeparator("");
|
|
|
|
#region Context Menu - Display
|
|
if (isEditPath)
|
|
{
|
|
menu.AddItem(new GUIContent("Display/Distances"), activePath.showDistancesInScene, () =>
|
|
{
|
|
activePath.showDistancesInScene = !activePath.showDistancesInScene;
|
|
isSceneDirtyRequired = true;
|
|
});
|
|
menu.AddItem(new GUIContent("Display/Number Labels"), activePath.showPointNumberLabelsInScene, () =>
|
|
{
|
|
activePath.showPointNumberLabelsInScene = !activePath.showPointNumberLabelsInScene;
|
|
if (activePath.showPointNumberLabelsInScene) { activePath.showPointNameLabelsInScene = false; }
|
|
isSceneDirtyRequired = true;
|
|
});
|
|
menu.AddItem(new GUIContent("Display/Name Labels"), activePath.showPointNameLabelsInScene, () =>
|
|
{
|
|
activePath.showPointNameLabelsInScene = !activePath.showPointNameLabelsInScene;
|
|
if (activePath.showPointNameLabelsInScene) { activePath.showPointNumberLabelsInScene = false; }
|
|
isSceneDirtyRequired = true;
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region Context Menu - Zoom
|
|
menu.AddItem(new GUIContent("Zoom/Selected Locations"), false, () => { ZoomExtent(sv, false, null); });
|
|
if (isEditPath)
|
|
{
|
|
menu.AddItem(new GUIContent("Zoom/Active Path"), false, () => { ZoomExtent(sv, true, activePath); });
|
|
}
|
|
#endregion
|
|
|
|
menu.AddSeparator("");
|
|
menu.AddItem(new GUIContent("Delete All Selected Locations"), false, () => { DeleteSelectedLocations(); sv.Focus(); });
|
|
menu.AddSeparator("");
|
|
menu.AddItem(new GUIContent("Allow Scene View Rotation"), false, () => { Tools.current = Tool.View; });
|
|
|
|
// The Cancel option is not really necessary as use can just click anywhere else. However, it may help some users.
|
|
menu.AddItem(new GUIContent("Cancel"), false, () => { });
|
|
menu.ShowAsContext();
|
|
currentEvent.Use();
|
|
}
|
|
#endregion
|
|
|
|
#region Add Locations
|
|
// Did the user press "+" key to add a location in the scene?
|
|
// Allow for + or = which are mostly the same key (+ is typically shift and '=' key).
|
|
else if (currentEvent.type == EventType.KeyUp && (currentEvent.keyCode == KeyCode.Equals || currentEvent.keyCode == KeyCode.KeypadPlus))
|
|
{
|
|
Vector3 posWS = Vector3.zero;
|
|
if (SSCEditorHelper.GetPositionFromMouse(sv, currentEvent.mousePosition, sscManager.locationDefaultNormalOffset, ref posWS, true))
|
|
{
|
|
currentEvent.Use();
|
|
|
|
// If user has Path tab selected, see if there is an active path
|
|
PathData activePath = selectedTabInt == 1 ? sscManager.GetPath(sscManager.pathDataActiveGUIDHash) : null;
|
|
|
|
Undo.RecordObject(sscManager, activePath != null ? "Add Path Location" : "Add Location");
|
|
// If the user has Path tab selected and there is an active Path, add the new Location to the Path,
|
|
// else just create a new Location in the scene.
|
|
LocationData locationData = activePath != null ? sscManager.AppendLocation(activePath, posWS, true, true) : sscManager.AppendLocation(posWS, true);
|
|
if (locationData != null) { locationData.selectedInSceneView = true; }
|
|
}
|
|
|
|
isSceneDirtyRequired = true;
|
|
}
|
|
#endregion Add Locations
|
|
|
|
#region Modify Locations and Active Path in the scene
|
|
else
|
|
{
|
|
#region Locations in the scene
|
|
int numLocations = sscManager.locationDataList == null ? 0 : sscManager.locationDataList.Count;
|
|
|
|
// If cannot find the camera, use the middle of the sceneview (not ideal but better than nothing)
|
|
Vector3 svCamPos = sv.camera != null ? sv.camera.transform.position : sv.pivot;
|
|
fadedGizmoColour = sscManager.locationGizmoColour;
|
|
|
|
using (new Handles.DrawingScope(sscManager.locationGizmoColour))
|
|
{
|
|
for (int lnIdx = 0; lnIdx < numLocations; lnIdx++)
|
|
{
|
|
locationDataItem = sscManager.locationDataList[lnIdx];
|
|
|
|
if (locationDataItem != null)
|
|
{
|
|
if (locationDataItem.showGizmosInSceneView)
|
|
{
|
|
itemHandlePosition = locationDataItem.position;
|
|
|
|
// Currently rotation and scale aren't being used.
|
|
itemHandleRotation = Quaternion.identity;
|
|
itemHandleScale.x = 0f;
|
|
itemHandleScale.y = 0f;
|
|
itemHandleScale.z = 0f;
|
|
|
|
// Draw location in the scene that is non-interactable
|
|
//if (Event.current.type == EventType.Repaint)
|
|
//{
|
|
// //Handles.ArrowHandleCap(0, itemHandlePosition, itemHandleRotation, 1f, EventType.Repaint);
|
|
// Handles.SphereHandleCap(0, itemHandlePosition, itemHandleRotation, 1f, EventType.Repaint);
|
|
//}
|
|
|
|
// Here is where we would draw any shape that identifies this location type
|
|
|
|
if (locationDataItem.selectedInSceneView)
|
|
{
|
|
// Choose which handle to draw based on which Unity tool is selected
|
|
if (Tools.current == Tool.Rotate)
|
|
{
|
|
// Currently not required
|
|
}
|
|
else if (Tools.current == Tool.Scale)
|
|
{
|
|
// Currently not required
|
|
}
|
|
else if (Tools.current == Tool.Move || Tools.current == Tool.Transform)
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
// Draw a movement handle
|
|
itemHandlePosition = Handles.PositionHandle(itemHandlePosition, itemHandleRotation);
|
|
// Use the position handle to edit the position of the location
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
isSceneDirtyRequired = true;
|
|
|
|
if (currentEvent.shift)
|
|
{
|
|
// Move all selected Locations in the Active Path
|
|
if (selectedTabInt == 1)
|
|
{
|
|
// This could be a little slow
|
|
PathData activePath = sscManager.GetPath(sscManager.pathDataActiveGUIDHash);
|
|
if (activePath != null)
|
|
{
|
|
Undo.RecordObject(sscManager, "Move Path Locations");
|
|
sscManager.MoveLocations(activePath, locationDataItem, itemHandlePosition, true);
|
|
}
|
|
}
|
|
// Move all selected Locations in the scene
|
|
else
|
|
{
|
|
Undo.RecordObject(sscManager, "Move Selected Locations");
|
|
sscManager.MoveLocations(locationDataItem, itemHandlePosition, true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Undo.RecordObject(sscManager, "Move Location");
|
|
// WARNING: Refreshing the Distances could get expensive on long Paths..
|
|
sscManager.UpdateLocation(locationDataItem, itemHandlePosition, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
float itemHandleSize = sscManager.isAutosizeLocationGizmo ? HandleUtility.GetHandleSize(itemHandlePosition) * 0.1f : 0.5f;
|
|
|
|
// Determine how far this item is from the scene view camera and set the alpha value of the buttons
|
|
float sqrDistToCamera = ((svCamPos.x - itemHandlePosition.x) * (svCamPos.x - itemHandlePosition.x)) + ((svCamPos.y - itemHandlePosition.y) * (svCamPos.y - itemHandlePosition.y)) + ((svCamPos.z - itemHandlePosition.z) * (svCamPos.z - itemHandlePosition.z));
|
|
float gizmoAlpha = 1f - (sscManager.locationGizmoColour.a - 0.1f) * ((sqrDistToCamera - startFadeDistSqr) / maxFadeDistSqr);
|
|
fadedGizmoColour.a = gizmoAlpha < 0.1f ? 0.1f : gizmoAlpha > 1f ? 1f : gizmoAlpha;
|
|
|
|
using (new Handles.DrawingScope(fadedGizmoColour))
|
|
{
|
|
// Allow the user to select/deselect the location
|
|
if (Handles.Button(itemHandlePosition, Quaternion.identity, itemHandleSize, itemHandleSize, Handles.SphereHandleCap))
|
|
{
|
|
if (locationDataItem.selectedInSceneView)
|
|
{
|
|
// If in multi-select mode or single selected, just unselect the clicked Location
|
|
locationDataItem.selectedInSceneView = false;
|
|
locationDataItem.showInEditor = false;
|
|
}
|
|
else
|
|
{
|
|
if (!isShiftKey)
|
|
{
|
|
// If not in multi-select mode (Shift key held down), unselect all
|
|
SelectAllLocations(false, true);
|
|
ExpandList(sscManager.locationDataList, false);
|
|
}
|
|
// Select the Location clicked on
|
|
locationDataItem.selectedInSceneView = true;
|
|
locationDataItem.showInEditor = true;
|
|
isSceneDirtyRequired = true;
|
|
// Hide Unity tools
|
|
Tools.hidden = true;
|
|
}
|
|
|
|
isSceneDirtyRequired = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Locations in the scene
|
|
|
|
#region Edit Tangent Control Points for Active Path in the scene
|
|
// NOTE: Path lines are drawn in SSManager.OnDrawGizmosSelected()
|
|
using (new Handles.DrawingScope(sscManager.defaultPathControlGizmoColour))
|
|
{
|
|
PathData pathData = sscManager.GetPath(sscManager.pathDataActiveGUIDHash);
|
|
// Only show the tangents for the active Path which has show Gizmos enabled
|
|
if (pathData != null && pathData.showGizmosInSceneView)
|
|
{
|
|
int numPathLocationDatas = pathData.pathLocationDataList == null ? 0 : pathData.pathLocationDataList.Count;
|
|
|
|
// We "could" only set this once but it may have issues going in and out of play mode in the editor
|
|
if (pathData.showPointNumberLabelsInScene || pathData.showPointNameLabelsInScene || pathData.showDistancesInScene)
|
|
{
|
|
distanceLabel = new GUIStyle("Box");
|
|
distanceLabel.fontSize = 10;
|
|
distanceLabel.border = new RectOffset(1, 1, 1, 1);
|
|
distanceLabel.onFocused.textColor = UnityEngine.Color.white;
|
|
}
|
|
|
|
fadedGizmoColour = sscManager.defaultPathControlGizmoColour;
|
|
|
|
for (int pldIdx = 0; pldIdx < numPathLocationDatas; pldIdx++)
|
|
{
|
|
PathLocationData pathLocationData = pathData.pathLocationDataList[pldIdx];
|
|
if (pathLocationData != null && pathLocationData.locationData != null && !pathLocationData.locationData.isUnassigned)
|
|
{
|
|
float controlHandleSize = sscManager.isAutosizeLocationGizmo ? HandleUtility.GetHandleSize(pathLocationData.inControlPoint) * 0.07f : 0.4f;
|
|
locationPosition = pathLocationData.locationData.position;
|
|
|
|
// Determine how far this Location is from the scene view camera and set the alpha value of the buttons, handles and Control Point lines
|
|
float sqrDistToCamera = ((svCamPos.x - locationPosition.x) * (svCamPos.x - locationPosition.x)) + ((svCamPos.y - locationPosition.y) * (svCamPos.y - locationPosition.y)) + ((svCamPos.z - locationPosition.z) * (svCamPos.z - locationPosition.z));
|
|
float gizmoAlpha = 1f - (sscManager.defaultPathControlGizmoColour.a - 0.1f) * ((sqrDistToCamera - startFadeDistSqr) / maxFadeDistSqr);
|
|
fadedGizmoColour.a = gizmoAlpha < 0.1f ? 0.1f : gizmoAlpha > 1f ? 1f : gizmoAlpha;
|
|
|
|
using (new Handles.DrawingScope(fadedGizmoColour))
|
|
{
|
|
#region FreeMove Control Handles
|
|
if (Tools.current == Tool.View)
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
#if UNITY_2022_1_OR_NEWER
|
|
newControlPoint = Handles.FreeMoveHandle(pathLocationData.inControlPoint, controlHandleSize, controlHandleSnap, Handles.SphereHandleCap);
|
|
#else
|
|
newControlPoint = Handles.FreeMoveHandle(pathLocationData.inControlPoint, Quaternion.identity, controlHandleSize, controlHandleSnap, Handles.SphereHandleCap);
|
|
#endif
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
isSceneDirtyRequired = true;
|
|
UpdatePathControlPoint(pathLocationData, newControlPoint, true);
|
|
pathData.isDirty = true;
|
|
}
|
|
|
|
EditorGUI.BeginChangeCheck();
|
|
#if UNITY_2022_1_OR_NEWER
|
|
newControlPoint = Handles.FreeMoveHandle(pathLocationData.outControlPoint, controlHandleSize, controlHandleSnap, Handles.SphereHandleCap);
|
|
#else
|
|
newControlPoint = Handles.FreeMoveHandle(pathLocationData.outControlPoint, Quaternion.identity, controlHandleSize, controlHandleSnap, Handles.SphereHandleCap);
|
|
#endif
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
isSceneDirtyRequired = true;
|
|
UpdatePathControlPoint(pathLocationData, newControlPoint, false);
|
|
pathData.isDirty = true;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Position Move Control Handles
|
|
else if (Tools.current == Tool.Move || Tools.current == Tool.Transform)
|
|
{
|
|
// If the Location is selected, turn off the control handles
|
|
// Check if in/out controls are enabled before marking scene dirty.
|
|
if (pathLocationData.locationData.selectedInSceneView && (pathLocationData.inControlSelectedInSceneView || pathLocationData.outControlSelectedInSceneView))
|
|
{
|
|
pathLocationData.inControlSelectedInSceneView = false;
|
|
pathLocationData.outControlSelectedInSceneView = false;
|
|
isSceneDirtyRequired = true;
|
|
}
|
|
|
|
// If the controls are selected, display the movable Position Handles
|
|
if (pathLocationData.inControlSelectedInSceneView)
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
newControlPoint = Handles.PositionHandle(pathLocationData.inControlPoint, Quaternion.identity);
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
isSceneDirtyRequired = true;
|
|
UpdatePathControlPoint(pathLocationData, newControlPoint, true);
|
|
pathData.isDirty = true;
|
|
}
|
|
}
|
|
|
|
if (pathLocationData.outControlSelectedInSceneView)
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
newControlPoint = Handles.PositionHandle(pathLocationData.outControlPoint, Quaternion.identity);
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
isSceneDirtyRequired = true;
|
|
UpdatePathControlPoint(pathLocationData, newControlPoint, false);
|
|
pathData.isDirty = true;
|
|
}
|
|
}
|
|
|
|
// Buttons which let you select or unselect the control points. When selected the above handles appear
|
|
if (Handles.Button(pathLocationData.inControlPoint, Quaternion.identity, controlHandleSize, controlHandleSize, Handles.SphereHandleCap))
|
|
{
|
|
ToggleControl(pathData, pathLocationData, true);
|
|
isSceneDirtyRequired = true;
|
|
}
|
|
|
|
if (Handles.Button(pathLocationData.outControlPoint, Quaternion.identity, controlHandleSize, controlHandleSize, Handles.SphereHandleCap))
|
|
{
|
|
ToggleControl(pathData, pathLocationData, false);
|
|
isSceneDirtyRequired = true;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
Handles.DrawLine(pathLocationData.inControlPoint, locationPosition);
|
|
Handles.DrawLine(pathLocationData.outControlPoint, locationPosition);
|
|
}
|
|
|
|
#region Display labels
|
|
if (pathData.showPointNumberLabelsInScene || pathData.showPointNameLabelsInScene || pathData.showDistancesInScene)
|
|
{
|
|
// Only show the Point labels if they are enabled in Editor AND infront of the scene view camera
|
|
// This prevents a ghosted handle being displayed when it is behind the camera.
|
|
if (SSCUtils.IsPointInCameraView(SceneView.lastActiveSceneView.camera, locationPosition))
|
|
{
|
|
if (pathData.showPointNameLabelsInScene) { locationName = string.IsNullOrEmpty(pathLocationData.locationData.name) ? "no name" : pathLocationData.locationData.name.Trim(); }
|
|
|
|
// Display Point number and Distance labels
|
|
if (pathData.showPointNumberLabelsInScene && pathData.showDistancesInScene)
|
|
{
|
|
if (pldIdx == 0 && pathData.isClosedCircuit)
|
|
{
|
|
Handles.Label(locationPosition + pointLabelOffset, "Pt: " + (pldIdx + 1).ToString("000") + " Distance: 0.00 [Total " + pathLocationData.distanceCumulative.ToString("0.00") + "]", distanceLabel);
|
|
}
|
|
else
|
|
{
|
|
Handles.Label(locationPosition + pointLabelOffset, "Pt: " + (pldIdx + 1).ToString("000") + " Distance: " + pathLocationData.distanceCumulative.ToString("0.00"), distanceLabel);
|
|
}
|
|
}
|
|
// Display Point name and Distance labels
|
|
else if (pathData.showPointNameLabelsInScene && pathData.showDistancesInScene)
|
|
{
|
|
if (pldIdx == 0 && pathData.isClosedCircuit)
|
|
{
|
|
Handles.Label(locationPosition + pointLabelOffset, locationName + " Distance: 0.00 [Total " + pathLocationData.distanceCumulative.ToString("0.00") + "]", distanceLabel);
|
|
}
|
|
else
|
|
{
|
|
Handles.Label(locationPosition + pointLabelOffset, locationName + " Distance: " + pathLocationData.distanceCumulative.ToString("0.00"), distanceLabel);
|
|
}
|
|
}
|
|
else if (pathData.showPointNumberLabelsInScene)
|
|
{
|
|
Handles.Label(locationPosition + pointLabelOffset, "Pt: " + (pldIdx + 1).ToString("000"), distanceLabel);
|
|
}
|
|
else if (pathData.showPointNameLabelsInScene)
|
|
{
|
|
Handles.Label(locationPosition + pointLabelOffset, locationName, distanceLabel);
|
|
}
|
|
// Just display distance
|
|
else if (pldIdx == 0 && pathData.isClosedCircuit)
|
|
{
|
|
Handles.Label(locationPosition + pointLabelOffset, "Distance: 0.00 [" + pathLocationData.distanceCumulative.ToString("0.00") + "]", distanceLabel);
|
|
}
|
|
else
|
|
{
|
|
Handles.Label(locationPosition + pointLabelOffset, "Distance: " + pathLocationData.distanceCumulative.ToString("0.00"), distanceLabel);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pathData != null && pathData.isDirty) { sscManager.RefreshPathDistances(pathData); }
|
|
}
|
|
#endregion Edit Tangent Control Points for Active Path in the scene
|
|
}
|
|
#endregion
|
|
|
|
if (isSceneDirtyRequired && !Application.isPlaying)
|
|
{
|
|
isSceneDirtyRequired = false;
|
|
EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Always unhide Unity tools and deselect all Locations when the object is disabled
|
|
Tools.hidden = false;
|
|
SelectAllLocations(false, true);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// When Control Points can be manipulated with Position Handles, they need to be selected from
|
|
/// a button. When they are selected, all other Control points (and positions) on the Path should be unselected.
|
|
/// </summary>
|
|
/// <param name="pathData"></param>
|
|
/// <param name="controlPathLocationData"></param>
|
|
/// <param name="isInControl"></param>
|
|
private void ToggleControl(PathData pathData, PathLocationData controlPathLocationData, bool isInControl)
|
|
{
|
|
if (pathData != null && controlPathLocationData != null)
|
|
{
|
|
int numPathLocationDatas = pathData.pathLocationDataList == null ? 0 : pathData.pathLocationDataList.Count;
|
|
bool isSelected = false;
|
|
|
|
// Toggle the InControl Point selection
|
|
if (isInControl)
|
|
{
|
|
controlPathLocationData.inControlSelectedInSceneView = !controlPathLocationData.inControlSelectedInSceneView;
|
|
|
|
if (controlPathLocationData.inControlSelectedInSceneView)
|
|
{
|
|
controlPathLocationData.outControlSelectedInSceneView = false;
|
|
controlPathLocationData.locationData.selectedInSceneView = false;
|
|
isSelected = true;
|
|
}
|
|
}
|
|
// Toggle the OutControl Point selection
|
|
else
|
|
{
|
|
controlPathLocationData.outControlSelectedInSceneView = !controlPathLocationData.outControlSelectedInSceneView;
|
|
|
|
if (controlPathLocationData.outControlSelectedInSceneView)
|
|
{
|
|
controlPathLocationData.inControlSelectedInSceneView = false;
|
|
controlPathLocationData.locationData.selectedInSceneView = false;
|
|
isSelected = true;
|
|
}
|
|
}
|
|
|
|
// Only unselect all other positions and Control points if the current Control point has been selected
|
|
for (int pldIdx = 0; isSelected && pldIdx < numPathLocationDatas; pldIdx++)
|
|
{
|
|
PathLocationData pathLocationData = pathData.pathLocationDataList[pldIdx];
|
|
// Skip the current Control point being toggled
|
|
if (pathLocationData != null && pathLocationData.guidHash != controlPathLocationData.guidHash)
|
|
{
|
|
// Unselect all other Control points
|
|
pathLocationData.inControlSelectedInSceneView = false;
|
|
pathLocationData.outControlSelectedInSceneView = false;
|
|
|
|
// Added SSC v1.06. Unselect Location too
|
|
if (pathLocationData.locationData != null) { pathLocationData.locationData.selectedInSceneView = false; }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Toggle the selected status of list of filtered Locations based on the first item.
|
|
/// </summary>
|
|
/// <param name="listProp"></param>
|
|
/// <param name="searchFilter"></param>
|
|
private void ToggleSelectList(SerializedProperty listProp, string searchFilter)
|
|
{
|
|
if (listProp != null)
|
|
{
|
|
int numInList = listProp.arraySize;
|
|
bool isFirstItem = true;
|
|
bool isSelected = false;
|
|
|
|
for (int idx = 0; idx < numInList; idx++)
|
|
{
|
|
SerializedProperty itemProp = listProp.GetArrayElementAtIndex(idx);
|
|
if (itemProp != null)
|
|
{
|
|
SerializedProperty nameProp = itemProp.FindPropertyRelative("name");
|
|
|
|
if (!SSCEditorHelper.IsInSearchFilter(nameProp, searchFilter)) { continue; }
|
|
|
|
SerializedProperty isSelectedProp = itemProp.FindPropertyRelative("selectedInSceneView");
|
|
|
|
// Get the selction status of the first item in the list
|
|
if (isFirstItem)
|
|
{
|
|
isSelected = isSelectedProp.boolValue;
|
|
isFirstItem = false;
|
|
}
|
|
|
|
// Set selectedInSceneView to the toggled value based on the first item in the list
|
|
isSelectedProp.boolValue = !isSelected;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Select or Deselect all Locations in the scene view edit mode.
|
|
/// If unHideUnityTools is false, Tools are not changed. If you want to hide the Unity Tools,
|
|
/// then it must be done outside this method.
|
|
/// </summary>
|
|
/// <param name="unHideUnityTools"></param>
|
|
private void SelectAllLocations(bool isSelected, bool unHideUnityTools)
|
|
{
|
|
// Avoid situation where sscmanager is destroyed in play mode while it is selected.
|
|
if (sscManager != null)
|
|
{
|
|
int numLocations = sscManager.locationDataList == null ? 0 : sscManager.locationDataList.Count;
|
|
LocationData locationData = null;
|
|
|
|
for (int idx = 0; idx < numLocations; idx++)
|
|
{
|
|
locationData = sscManager.locationDataList[idx];
|
|
if (locationData != null)
|
|
{
|
|
locationData.selectedInSceneView = isSelected;
|
|
}
|
|
}
|
|
|
|
// Added SSC v1.0.6
|
|
if (!isSelected)
|
|
{
|
|
PathData activePath = numLocations > 0 ? sscManager.GetPath(sscManager.pathDataActiveGUIDHash) : null;
|
|
DeselectAllControlPoints(activePath);
|
|
}
|
|
}
|
|
// Unhide Unity tools
|
|
if (unHideUnityTools) { Tools.hidden = false; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deselect all Control Points on a given Path
|
|
/// </summary>
|
|
/// <param name="pathData"></param>
|
|
private static void DeselectAllControlPoints(PathData pathData)
|
|
{
|
|
if (pathData != null)
|
|
{
|
|
int numPathLocationDatas = pathData.pathLocationDataList == null ? 0 : pathData.pathLocationDataList.Count;
|
|
for (int pldIdx = 0; pldIdx < numPathLocationDatas; pldIdx++)
|
|
{
|
|
PathLocationData pathLocationData = pathData.pathLocationDataList[pldIdx];
|
|
if (pathLocationData != null)
|
|
{
|
|
// Unselect all other Control points
|
|
pathLocationData.inControlSelectedInSceneView = false;
|
|
pathLocationData.outControlSelectedInSceneView = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Select or unselect all the Locations in a Path.
|
|
/// Always unselect in/out Controls for a valid Path Location
|
|
/// </summary>
|
|
/// <param name="pathData"></param>
|
|
/// <param name="isSelected"></param>
|
|
private void SelectPathLocations(PathData pathData, bool isSelected)
|
|
{
|
|
if (sscManager != null && pathData != null)
|
|
{
|
|
int numLocations = pathData.pathLocationDataList == null ? 0 : pathData.pathLocationDataList.Count;
|
|
PathLocationData pathLocationData = null;
|
|
LocationData locationData = null;
|
|
for (int idx = 0; idx < numLocations; idx++)
|
|
{
|
|
pathLocationData = pathData.pathLocationDataList[idx];
|
|
locationData = pathLocationData == null ? null : pathLocationData.locationData;
|
|
if (locationData != null)
|
|
{
|
|
locationData.selectedInSceneView = isSelected;
|
|
pathLocationData.inControlSelectedInSceneView = false;
|
|
pathLocationData.outControlSelectedInSceneView = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Expand or collapse all locations within the list.
|
|
/// If it is a list of Paths, always collapse the Locations in the Path
|
|
/// </summary>
|
|
/// <param name="listProp"></param>
|
|
/// <param name="isExpanded"></param>
|
|
private void ExpandList(SerializedProperty listProp, bool isExpanded)
|
|
{
|
|
if (listProp != null)
|
|
{
|
|
int numInList = listProp.arraySize;
|
|
for (int idx = 0; idx < numInList; idx++)
|
|
{
|
|
SerializedProperty itemProp = listProp.GetArrayElementAtIndex(idx);
|
|
if (itemProp != null)
|
|
{
|
|
// Locations and Paths have the same showInEditor field.
|
|
SerializedProperty showInEditorProp = itemProp.FindPropertyRelative("showInEditor");
|
|
if (showInEditorProp != null)
|
|
{
|
|
showInEditorProp.boolValue = isExpanded;
|
|
}
|
|
|
|
// If this is Path, then it will have a field to show or hide Locations
|
|
SerializedProperty showLocationsInEditorProp = itemProp.FindPropertyRelative("showLocationsInEditor");
|
|
if (showLocationsInEditorProp != null)
|
|
{
|
|
showLocationsInEditorProp.boolValue = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Expand or collapse all locations within the list
|
|
/// </summary>
|
|
/// <param name="locationDataList"></param>
|
|
/// <param name="isExpanded"></param>
|
|
private void ExpandList(List<LocationData> locationDataList, bool isExpanded)
|
|
{
|
|
int numInList = locationDataList == null ? 0 : locationDataList.Count;
|
|
for (int idx = 0; idx < numInList; idx++)
|
|
{
|
|
LocationData locationData = locationDataList[idx];
|
|
if (locationData != null)
|
|
{
|
|
locationData.showInEditor = isExpanded;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Toggle all items in the list based on the value of showGizmosInSceneView for the first item.
|
|
/// </summary>
|
|
/// <param name="listProp"></param>
|
|
private void ToggleGizmos(SerializedProperty listProp)
|
|
{
|
|
if (listProp != null)
|
|
{
|
|
int numInList = listProp.arraySize;
|
|
|
|
if (numInList > 0)
|
|
{
|
|
// Examine the first item in the list
|
|
SerializedProperty itemProp = listProp.GetArrayElementAtIndex(0);
|
|
if (itemProp != null)
|
|
{
|
|
SerializedProperty showGizmosInSceneViewProp = itemProp.FindPropertyRelative("showGizmosInSceneView");
|
|
|
|
if (showGizmosInSceneViewProp != null)
|
|
{
|
|
bool showGizmos = showGizmosInSceneViewProp.boolValue;
|
|
|
|
for (int idx = 0; idx < numInList; idx++)
|
|
{
|
|
itemProp = listProp.GetArrayElementAtIndex(idx);
|
|
if (itemProp != null)
|
|
{
|
|
showGizmosInSceneViewProp = itemProp.FindPropertyRelative("showGizmosInSceneView");
|
|
if (showGizmosInSceneViewProp != null) { showGizmosInSceneViewProp.boolValue = !showGizmos; }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete all selected Locations. Also removes them from an Paths.
|
|
/// Prompts user for confirmation.
|
|
/// </summary>
|
|
private void DeleteSelectedLocations()
|
|
{
|
|
if (SSCEditorHelper.PromptForDelete("Delete Locations?", "Do you want to delete ALL selected Locations in the scene?\n\nThis will also remove them from any Paths"))
|
|
{
|
|
sscManager.DeleteSelectedLocations(true);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Given a location, remove it from all paths in the list supplied.
|
|
/// </summary>
|
|
/// <param name="pathListProp"></param>
|
|
/// <param name="locationGUIDHash"></param>
|
|
private void DeleteLocationFromPaths(SerializedProperty pathListProp, int locationGUIDHash, bool refreshPath)
|
|
{
|
|
if (pathListProp != null)
|
|
{
|
|
// Loop through all the paths
|
|
int numPathsInList = pathListProp.arraySize;
|
|
bool isPathAffected = false;
|
|
for (int idx = 0; idx < numPathsInList; idx++)
|
|
{
|
|
// Get the Path
|
|
SerializedProperty _pathProp = pathListProp.GetArrayElementAtIndex(idx);
|
|
if (_pathProp != null)
|
|
{
|
|
// Get the list of Location slots in the Path
|
|
SerializedProperty _pathLocationDataListProp = _pathProp.FindPropertyRelative("pathLocationDataList");
|
|
|
|
if (_pathLocationDataListProp != null)
|
|
{
|
|
isPathAffected = false;
|
|
// Loop backwards through all the PathLocationData instances in the Path
|
|
for (int lIdx = _pathLocationDataListProp.arraySize - 1; lIdx >= 0; lIdx--)
|
|
{
|
|
// Get the PathLocationData instance
|
|
SerializedProperty _pathLocationDataProp = _pathLocationDataListProp.GetArrayElementAtIndex(lIdx);
|
|
if (_pathLocationDataProp != null)
|
|
{
|
|
SerializedProperty _locationDataProp = _pathLocationDataProp.FindPropertyRelative("locationData");
|
|
if (_locationDataProp != null)
|
|
{
|
|
SerializedProperty _locGUIDHashProp = _locationDataProp.FindPropertyRelative("guidHash");
|
|
// If we find a match, remove the Location from the Path
|
|
if (_locGUIDHashProp != null && _locGUIDHashProp.intValue == locationGUIDHash)
|
|
{
|
|
_pathLocationDataListProp.DeleteArrayElementAtIndex(lIdx);
|
|
isPathAffected = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isPathAffected)
|
|
{
|
|
serializedObject.ApplyModifiedProperties();
|
|
PathData _pathData = sscManager.GetPath(_pathProp.FindPropertyRelative("guidHash").intValue);
|
|
if (_pathData != null)
|
|
{
|
|
if (refreshPath) { sscManager.RefreshPathDistances(_pathData); }
|
|
else { _pathData.isDirty = true; }
|
|
}
|
|
serializedObject.Update();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// When the Location and Path Location lists are updated, especially during an Undo
|
|
/// operation, the connect between the Location in the Path and the Location in the
|
|
/// Location list can be lost. The method checks for and fixings that issue.
|
|
/// </summary>
|
|
private void VerifyPathConnections()
|
|
{
|
|
if (sscManager != null)
|
|
{
|
|
bool isConnected = false;
|
|
bool isCheckConnection = true; // Used to check the first item for broken connection
|
|
bool isUpdated = false;
|
|
|
|
// Loop through all the paths
|
|
int numPathsInList = sscManager.pathDataList == null ? 0 : sscManager.pathDataList.Count;
|
|
for (int idx = 0; !isConnected && idx < numPathsInList; idx++)
|
|
{
|
|
PathData _pathData = sscManager.pathDataList[idx];
|
|
if (_pathData != null)
|
|
{
|
|
List<PathLocationData> _pathLocationList = _pathData.pathLocationDataList;
|
|
int numLocationsInList = _pathLocationList == null ? 0 : _pathLocationList.Count;
|
|
|
|
// Loop through all the locations in the Path
|
|
for (int lIdx = 0; lIdx < numLocationsInList; lIdx++)
|
|
{
|
|
// Get the location within the Path
|
|
PathLocationData _pathLocation = _pathLocationList[lIdx];
|
|
|
|
if (_pathLocation != null)
|
|
{
|
|
// Get the guidHash code for the location within the Path
|
|
// Lookup the Location in the full Location list (not the location list in the Path)
|
|
LocationData locationDataToAssign = sscManager.locationDataList.Find(l => l.guidHash == _pathLocation.locationData.guidHash);
|
|
// Only examine assigned slots
|
|
if (locationDataToAssign != null)
|
|
{
|
|
// Checked and confirmed that first location needs reconnecting.
|
|
if (isCheckConnection)
|
|
{
|
|
// Only do the check once
|
|
isCheckConnection = false;
|
|
// Is first item check, connected?
|
|
if (_pathLocation.locationData == locationDataToAssign)
|
|
{
|
|
// Assume all are connected
|
|
isConnected = true;
|
|
//Debug.Log("[DEBUG] " + _pathLocation.name + " is connected");
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!isConnected)
|
|
{
|
|
// If this is the first item to be reconnected, make the sscManager object as dirty in the scene
|
|
if (!isUpdated)
|
|
{
|
|
Undo.RecordObject(sscManager, "Update Path Connections");
|
|
isUpdated = true;
|
|
}
|
|
|
|
// Reconnect Path Location with the instance in the Location list
|
|
//Debug.Log("[DEBUG] reconnecting " + _pathLocation.locationData.name + " " + Time.realtimeSinceStartup);
|
|
_pathLocationList[lIdx].locationData = locationDataToAssign;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update the position of an in or out control point. Then reflect this position for the other corresponding in/out control point.
|
|
/// </summary>
|
|
/// <param name="pathLocationData"></param>
|
|
/// <param name="newControlPoint"></param>
|
|
/// <param name="isInControl"></param>
|
|
private void UpdatePathControlPoint(PathLocationData pathLocationData, Vector3 newControlPoint, bool isInControl)
|
|
{
|
|
Undo.RecordObject(sscManager, isInControl ? "Change In Control Point" : "Change Out Control Point");
|
|
|
|
Vector3 wsPosition = pathLocationData.locationData.position;
|
|
|
|
if (isInControl)
|
|
{
|
|
pathLocationData.inControlPoint = newControlPoint;
|
|
pathLocationData.outControlPoint = wsPosition + ((wsPosition - newControlPoint).normalized * (wsPosition - pathLocationData.outControlPoint).magnitude);
|
|
}
|
|
else
|
|
{
|
|
pathLocationData.outControlPoint = newControlPoint;
|
|
pathLocationData.inControlPoint = wsPosition + ((wsPosition - newControlPoint).normalized * (wsPosition - pathLocationData.inControlPoint).magnitude);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the control point Y-axis value to the same as the Location
|
|
/// for the selected Locations on the Path.
|
|
/// </summary>
|
|
/// <param name="pathData"></param>
|
|
private void SetPathControlPointsY(PathData pathData)
|
|
{
|
|
int numPathLocationSlots = pathData == null || pathData.pathLocationDataList == null ? 0 : pathData.pathLocationDataList.Count;
|
|
|
|
if (numPathLocationSlots > 0)
|
|
{
|
|
Undo.RecordObject(sscManager, "Set Control Points Y");
|
|
|
|
for (int plIdx = 0; plIdx < numPathLocationSlots; plIdx++)
|
|
{
|
|
PathLocationData pathLocationData = pathData.pathLocationDataList[plIdx];
|
|
if (pathLocationData != null && pathLocationData.locationData != null && !pathLocationData.locationData.isUnassigned && pathLocationData.locationData.selectedInSceneView)
|
|
{
|
|
Vector3 wsPosition = pathLocationData.locationData.position;
|
|
Vector3 newControlPoint = pathLocationData.inControlPoint;
|
|
newControlPoint.y = wsPosition.y;
|
|
pathLocationData.inControlPoint = newControlPoint;
|
|
pathLocationData.outControlPoint = wsPosition + ((wsPosition - newControlPoint).normalized * (wsPosition - pathLocationData.outControlPoint).magnitude);
|
|
}
|
|
}
|
|
|
|
sscManager.RefreshPathDistances(pathData);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dropdown menu callback method used when a location is selected for a path
|
|
/// </summary>
|
|
/// <param name="obj"></param>
|
|
private void UpdatePathLocation(object obj)
|
|
{
|
|
// The menu data is passed as 3 integers in a Vector3Int
|
|
// as Path guidHash, path Location LocationData guidHash, and the selected Location guidHash
|
|
// which is being assigned to the location slot on the path.
|
|
if (obj != null && obj.GetType() == typeof(Vector3Int))
|
|
{
|
|
Vector3Int objData = (Vector3Int)obj;
|
|
|
|
if (sscManager != null && sscManager.pathDataList != null)
|
|
{
|
|
// Find the path
|
|
PathData pathData = sscManager.pathDataList.Find(p => p.guidHash == objData.x);
|
|
if (pathData != null)
|
|
{
|
|
// Look up the guidHash of the LocationData within the PathLocationData (not the hash of the PathLocationData itself)
|
|
int pathLocIdx = pathData.pathLocationDataList.FindIndex(l => l.locationData.guidHash == objData.y);
|
|
LocationData locationDataToAssign = sscManager.locationDataList.Find(l => l.guidHash == objData.z);
|
|
|
|
// Replace this existing location reference with a reference to the one being assigned
|
|
if (pathLocIdx >= 0 && pathLocIdx < pathData.pathLocationDataList.Count)
|
|
{
|
|
Undo.RecordObject(sscManager, "Assign Location to Path");
|
|
pathData.pathLocationDataList[pathLocIdx].locationData = locationDataToAssign;
|
|
|
|
// Reset distances to force a new estimated distance
|
|
// See ssManager.CalcPathSegments(..) for more details.
|
|
pathData.pathLocationDataList[pathLocIdx].distanceFromPreviousLocation = 0f;
|
|
pathData.pathLocationDataList[pathLocIdx].distanceCumulative = 0f;
|
|
|
|
// Set the default tangent control points
|
|
pathData.pathLocationDataList[pathLocIdx].inControlPoint = locationDataToAssign.position + Vector3.left;
|
|
pathData.pathLocationDataList[pathLocIdx].outControlPoint = locationDataToAssign.position + Vector3.right;
|
|
|
|
sscManager.RefreshPathDistances(pathData);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Zoom to the extent of the selected locations or the current active path
|
|
/// </summary>
|
|
/// <param name="sceneView"></param>
|
|
/// <param name="zoomActivePath"></param>
|
|
/// <param name="pathData"></param>
|
|
private void ZoomExtent(SceneView sceneView, bool zoomActivePath, PathData pathData)
|
|
{
|
|
if (sceneView != null && sscManager != null)
|
|
{
|
|
Camera svCamera = sceneView.camera;
|
|
if (svCamera != null)
|
|
{
|
|
List<LocationData> zoomLocations = null;
|
|
|
|
if (zoomActivePath)
|
|
{
|
|
// Get all the assigned Locations on the active Path
|
|
int numPathLocationSlots = pathData == null || pathData.pathLocationDataList == null ? 0 : pathData.pathLocationDataList.Count;
|
|
|
|
if (numPathLocationSlots > 0) { zoomLocations = new List<LocationData>(numPathLocationSlots); }
|
|
|
|
for (int plIdx = 0; plIdx < numPathLocationSlots; plIdx++)
|
|
{
|
|
PathLocationData pathLocationData = pathData.pathLocationDataList[plIdx];
|
|
if (pathLocationData.locationData != null && !pathLocationData.locationData.isUnassigned)
|
|
{
|
|
zoomLocations.Add(pathLocationData.locationData);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Get selected locations
|
|
zoomLocations = sscManager.locationDataList.FindAll(l => l.selectedInSceneView == true);
|
|
}
|
|
|
|
int numSelected = zoomLocations == null ? 0 : zoomLocations.Count;
|
|
|
|
if (numSelected > 0)
|
|
{
|
|
// calculate the bounds of the Locations
|
|
Bounds selectedBounds = new Bounds();
|
|
|
|
for (int locIdx = 0; locIdx < numSelected; locIdx++)
|
|
{
|
|
// Override the 0,0,0 default centre of an empty Bounds struct.
|
|
if (locIdx == 0) { selectedBounds.center = zoomLocations[locIdx].position; }
|
|
selectedBounds.Encapsulate(zoomLocations[locIdx].position);
|
|
}
|
|
|
|
float size = Mathf.Abs(selectedBounds.size.x);
|
|
sceneView.size = size < sscManager.findZoomDistance ? sscManager.findZoomDistance : size;
|
|
|
|
// Place the scene view camera 8m above the position of the Location
|
|
Vector3 pivotPosition = selectedBounds.min;
|
|
// Raise scene view camera 25% of the height above the selected points
|
|
pivotPosition.y = selectedBounds.max.y + (selectedBounds.extents.y * 1.25f);
|
|
// Move the scene view camera 20% of the distance infront of the selected points
|
|
pivotPosition.z -= selectedBounds.extents.z * 0.2f;
|
|
sceneView.pivot = pivotPosition;
|
|
|
|
//sceneView.LookAt(selectedBounds.center, Quaternion.Euler(0f, 0f, 0f));
|
|
sceneView.LookAt(selectedBounds.center);
|
|
|
|
//SSCEditorHelper.PositionSceneView(pos, size, GetType());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnInspectorGUI
|
|
|
|
// This function overides what is normally seen in the inspector window
|
|
// This allows stuff like buttons to be drawn there
|
|
public override void OnInspectorGUI()
|
|
{
|
|
#region Initialise
|
|
|
|
EditorGUIUtility.labelWidth = defaultEditorLabelWidth;
|
|
EditorGUIUtility.fieldWidth = defaultEditorFieldWidth;
|
|
|
|
// BUG - this is currently preventing selection of Locations AND moving them in list
|
|
VerifyPathConnections();
|
|
#endregion
|
|
|
|
#region Configure Buttons and Styles
|
|
|
|
// Set up rich text GUIStyles
|
|
if (helpBoxRichText == null)
|
|
{
|
|
helpBoxRichText = new GUIStyle("HelpBox");
|
|
helpBoxRichText.richText = true;
|
|
}
|
|
|
|
if (labelFieldRichText == null)
|
|
{
|
|
labelFieldRichText = new GUIStyle("Label");
|
|
labelFieldRichText.richText = true;
|
|
}
|
|
|
|
if (buttonCompact == null)
|
|
{
|
|
buttonCompact = new GUIStyle("Button");
|
|
buttonCompact.fontSize = 10;
|
|
}
|
|
|
|
if (buttonCompactBoldBlue == null)
|
|
{
|
|
buttonCompactBoldBlue = new GUIStyle("Button");
|
|
buttonCompactBoldBlue.fontSize = 10;
|
|
buttonCompactBoldBlue.fontStyle = FontStyle.Bold;
|
|
buttonCompactBoldBlue.normal.textColor = Color.blue;
|
|
}
|
|
|
|
if (foldoutStyleNoLabel == null)
|
|
{
|
|
// When using a no-label foldout, don't forget to set the global
|
|
// EditorGUIUtility.fieldWidth to a small value like 15, then back
|
|
// to the original afterward.
|
|
foldoutStyleNoLabel = new GUIStyle(EditorStyles.foldout);
|
|
foldoutStyleNoLabel.fixedWidth = 0.01f;
|
|
}
|
|
|
|
// Set up the toggle buttons styles
|
|
if (toggleCompactButtonStyleNormal == null)
|
|
{
|
|
// Create a new button or else will effect the Button style for other buttons too
|
|
toggleCompactButtonStyleNormal = new GUIStyle("Button");
|
|
toggleCompactButtonStyleNormal.fontSize = 10;
|
|
toggleCompactButtonStyleToggled = new GUIStyle(toggleCompactButtonStyleNormal);
|
|
toggleCompactButtonStyleNormal.fontStyle = FontStyle.Normal;
|
|
toggleCompactButtonStyleToggled.fontStyle = FontStyle.Bold;
|
|
toggleCompactButtonStyleToggled.normal.background = toggleCompactButtonStyleToggled.active.background;
|
|
}
|
|
|
|
if (searchTextFieldStyle == null)
|
|
{
|
|
searchTextFieldStyle = new GUIStyle(GUI.skin.FindStyle("ToolbarSeachTextField"));
|
|
searchTextFieldStyle.stretchHeight = false;
|
|
searchTextFieldStyle.stretchWidth = false;
|
|
searchTextFieldStyle.fontSize = 10;
|
|
searchTextFieldStyle.fixedHeight = 16f;
|
|
searchTextFieldStyle.fixedWidth = defaultSearchTextFieldWidth;
|
|
}
|
|
|
|
if (searchCancelButtonStyle == null)
|
|
{
|
|
searchCancelButtonStyle = new GUIStyle(GUI.skin.FindStyle("ToolbarSeachCancelButton"));
|
|
}
|
|
|
|
#endregion
|
|
|
|
// Read in all the properties
|
|
serializedObject.Update();
|
|
|
|
#region Header
|
|
GUILayout.BeginVertical("HelpBox");
|
|
EditorGUILayout.LabelField("<b>Sci-Fi Ship Controller</b> Version " + ShipControlModule.SSCVersion + " " + ShipControlModule.SSCBetaVersion, labelFieldRichText);
|
|
GUILayout.EndVertical();
|
|
|
|
EditorGUILayout.LabelField(headerContent, helpBoxRichText);
|
|
|
|
#endregion
|
|
|
|
#region Debug Mode
|
|
// Place above Locations etc so it is not affected by ScrollView when not many Locations.
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
isDebuggingEnabled = EditorGUILayout.Toggle(debugModeContent, isDebuggingEnabled);
|
|
|
|
if (isDebuggingEnabled && sscManager != null)
|
|
{
|
|
#region Projectiles
|
|
EditorGUILayout.LabelField(projectileHeaderContent, labelFieldRichText);
|
|
|
|
// Display the size of the current pool for projectiles that use pooling
|
|
projectileTemplatesList = sscManager.ProjectileTemplatesList;
|
|
int numProjectileTemplates = projectileTemplatesList == null ? 0 : projectileTemplatesList.Count;
|
|
|
|
if (numProjectileTemplates > 0)
|
|
{
|
|
foreach (ProjectileTemplate projectileTemplate in projectileTemplatesList)
|
|
{
|
|
if (projectileTemplate.projectilePrefab != null)
|
|
{
|
|
EditorGUILayout.LabelField(projectileTemplate.projectilePrefab.name);
|
|
if (projectileTemplate.projectilePrefab.usePooling)
|
|
{
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField(projectilePoolingContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|
EditorGUILayout.LabelField(projectileTemplate.currentPoolSize.ToString("0000"), GUILayout.MaxWidth(40f));
|
|
EditorGUILayout.LabelField(minmaxPoolSizeContent, GUILayout.MaxWidth(55f));
|
|
EditorGUILayout.LabelField(projectileTemplate.projectilePrefab.minPoolSize.ToString("0000"), GUILayout.MaxWidth(32f));
|
|
EditorGUILayout.LabelField(projectileTemplate.projectilePrefab.maxPoolSize.ToString("0000"), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
else if (projectileTemplate.projectilePrefab.useECS)
|
|
{
|
|
#if SSC_ENTITIES
|
|
EditorGUILayout.LabelField(projectileDOTSContent);
|
|
#else
|
|
EditorGUILayout.LabelField(projectileDOTSNotAvailableContent);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EditorGUILayout.LabelField(noneWithPoolingContent, labelFieldRichText);
|
|
}
|
|
EditorGUILayout.Space();
|
|
|
|
#endregion
|
|
|
|
#region Beams
|
|
EditorGUILayout.LabelField(beamHeaderContent, labelFieldRichText);
|
|
|
|
// Display the size of the current pool for beams that use pooling
|
|
beamTemplateList = sscManager.BeamTemplatesList;
|
|
int numBeamTemplates = beamTemplateList == null ? 0 : beamTemplateList.Count;
|
|
|
|
if (numBeamTemplates > 0)
|
|
{
|
|
foreach (BeamTemplate beamTemplate in beamTemplateList)
|
|
{
|
|
if (beamTemplate.beamPrefab != null && beamTemplate.beamPrefab.usePooling)
|
|
{
|
|
EditorGUILayout.LabelField(beamTemplate.beamPrefab.name);
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField(beamPoolingContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|
EditorGUILayout.LabelField(beamTemplate.currentPoolSize.ToString("0000"), GUILayout.MaxWidth(40f));
|
|
EditorGUILayout.LabelField(minmaxPoolSizeContent, GUILayout.MaxWidth(55f));
|
|
EditorGUILayout.LabelField(beamTemplate.beamPrefab.minPoolSize.ToString("0000"), GUILayout.MaxWidth(32f));
|
|
EditorGUILayout.LabelField(beamTemplate.beamPrefab.maxPoolSize.ToString("0000"), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EditorGUILayout.LabelField(noneWithPoolingContent, labelFieldRichText);
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
#endregion
|
|
|
|
#region Destructs
|
|
|
|
EditorGUILayout.LabelField(destructHeaderContent, labelFieldRichText);
|
|
|
|
// Display the size of the current pool for destructs that use pooling
|
|
destructTemplateList = sscManager.DestructTemplatesList;
|
|
int numDestructTemplates = destructTemplateList == null ? 0 : destructTemplateList.Count;
|
|
|
|
if (numDestructTemplates > 0)
|
|
{
|
|
foreach (DestructTemplate destructTemplate in destructTemplateList)
|
|
{
|
|
if (destructTemplate.destructPrefab != null && destructTemplate.destructPrefab.usePooling)
|
|
{
|
|
EditorGUILayout.LabelField(destructTemplate.destructPrefab.name);
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField(destructPoolingContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|
EditorGUILayout.LabelField(destructTemplate.currentPoolSize.ToString("0000"), GUILayout.MaxWidth(40f));
|
|
EditorGUILayout.LabelField(minmaxPoolSizeContent, GUILayout.MaxWidth(55f));
|
|
EditorGUILayout.LabelField(destructTemplate.destructPrefab.minPoolSize.ToString("0000"), GUILayout.MaxWidth(32f));
|
|
EditorGUILayout.LabelField(destructTemplate.destructPrefab.maxPoolSize.ToString("0000"), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EditorGUILayout.LabelField(noneWithPoolingContent, labelFieldRichText);
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
#endregion
|
|
|
|
#region Effects
|
|
EditorGUILayout.Space();
|
|
|
|
EditorGUILayout.LabelField(effectsHeaderContent, labelFieldRichText);
|
|
|
|
// Display the size of the current pool for effects that use pooling
|
|
effectsObjectTemplatesList = sscManager.EffectsObjectTemplatesList;
|
|
int numEffectObjectTemplates = effectsObjectTemplatesList == null ? 0 : effectsObjectTemplatesList.Count;
|
|
|
|
if (numEffectObjectTemplates > 0)
|
|
{
|
|
foreach (EffectsObjectTemplate effectsObjectTemplate in effectsObjectTemplatesList)
|
|
{
|
|
if (effectsObjectTemplate.effectsObjectPrefab != null && effectsObjectTemplate.effectsObjectPrefab.usePooling)
|
|
{
|
|
EditorGUILayout.LabelField(effectsObjectTemplate.effectsObjectPrefab.name);
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField(effectsPoolingContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|
EditorGUILayout.LabelField(effectsObjectTemplate.currentPoolSize.ToString("0000"), GUILayout.MaxWidth(40f));
|
|
EditorGUILayout.LabelField(minmaxPoolSizeContent, GUILayout.MaxWidth(55f));
|
|
EditorGUILayout.LabelField(effectsObjectTemplate.effectsObjectPrefab.minPoolSize.ToString("0000"), GUILayout.MaxWidth(32f));
|
|
EditorGUILayout.LabelField(effectsObjectTemplate.effectsObjectPrefab.maxPoolSize.ToString("0000"), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EditorGUILayout.LabelField(noneWithPoolingContent, labelFieldRichText);
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
EditorGUILayout.EndVertical();
|
|
#endregion
|
|
|
|
#region Help Toolbar
|
|
GUILayout.BeginHorizontal();
|
|
if (GUILayout.Button(SSCEditorHelper.btnTxtGetSupport, buttonCompact)) { Application.OpenURL(SSCEditorHelper.urlGetSupport); }
|
|
if (GUILayout.Button(SSCEditorHelper.btnDiscordContent, buttonCompact)) { Application.OpenURL(SSCEditorHelper.urlDiscordChannel); }
|
|
if (GUILayout.Button(SSCEditorHelper.btnHelpContent, buttonCompact)) { Application.OpenURL(sscHelpPDF); }
|
|
if (GUILayout.Button(SSCEditorHelper.tutorialsURLContent, buttonCompact)) { Application.OpenURL(SSCEditorHelper.urlTutorials); }
|
|
EditorGUILayout.EndHorizontal();
|
|
#endregion
|
|
|
|
#region Grid Tab control
|
|
//selectedTabInt = -1;
|
|
EditorGUI.BeginChangeCheck();
|
|
selectedTabInt = GUILayout.SelectionGrid(selectedTabInt, tabTexts, 3, EditorStyles.toolbarButton);
|
|
if (EditorGUI.EndChangeCheck()) { GUI.FocusControl(null); }
|
|
#endregion
|
|
|
|
#region Locations Tab
|
|
if (selectedTabInt == 0)
|
|
{
|
|
if (sscManager.locationDataList == null)
|
|
{
|
|
// Apply property changes
|
|
serializedObject.ApplyModifiedProperties();
|
|
sscManager.locationDataList = new List<LocationData>(5);
|
|
// Read in the properties
|
|
serializedObject.Update();
|
|
}
|
|
|
|
EditorGUILayout.LabelField(locationHeaderContent, helpBoxRichText);
|
|
|
|
// Reset button variables
|
|
locationDataMoveDownPos = -1;
|
|
locationDataInsertPos = -1;
|
|
locationDataDeletePos = -1;
|
|
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
|
|
#region Gizmos-Add-Remove Location Buttons
|
|
|
|
numLocations = locationDataListProp.arraySize;
|
|
GUILayout.BeginHorizontal();
|
|
|
|
EditorGUI.indentLevel += 1;
|
|
EditorGUIUtility.fieldWidth = 15f;
|
|
EditorGUI.BeginChangeCheck();
|
|
isLocationDataListExpandedProp.boolValue = EditorGUILayout.Foldout(isLocationDataListExpandedProp.boolValue, "", foldoutStyleNoLabel);
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
ExpandList(locationDataListProp, isLocationDataListExpandedProp.boolValue);
|
|
}
|
|
EditorGUI.indentLevel -= 1;
|
|
EditorGUIUtility.fieldWidth = defaultEditorFieldWidth;
|
|
EditorGUILayout.LabelField("<color=" + txtColourName + "><b>Locations: " + numFilteredLocations + " of " + numLocations + "</b></color>", labelFieldRichText);
|
|
|
|
if (numLocations > 0)
|
|
{
|
|
if (GUILayout.Button(gizmoToggleBtnContent, GUILayout.MaxWidth(22f)))
|
|
{
|
|
ToggleGizmos(locationDataListProp);
|
|
}
|
|
}
|
|
if (GUILayout.Button("+", GUILayout.MaxWidth(30f)))
|
|
{
|
|
// Apply property changes
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Add Location");
|
|
sscManager.locationDataList.Add(new LocationData());
|
|
// Read in the properties
|
|
serializedObject.Update();
|
|
|
|
numLocations = locationDataListProp.arraySize;
|
|
if (numLocations > 0)
|
|
{
|
|
// Force new location to be serialized in scene
|
|
locationDataProp = locationDataListProp.GetArrayElementAtIndex(numLocations - 1);
|
|
locationDataShowInEditorProp = locationDataProp.FindPropertyRelative("showInEditor");
|
|
locationDataShowInEditorProp.boolValue = !locationDataShowInEditorProp.boolValue;
|
|
// Show the new location
|
|
locationDataShowInEditorProp.boolValue = true;
|
|
// Select new Locations to make them more visible to user
|
|
locationDataProp.FindPropertyRelative("selectedInSceneView").boolValue = true;
|
|
locationDataProp.FindPropertyRelative("name").stringValue = "new location " + numLocations.ToString();
|
|
}
|
|
|
|
SceneView.RepaintAll();
|
|
}
|
|
if (GUILayout.Button("-", GUILayout.MaxWidth(30f)))
|
|
{
|
|
if (numLocations > 0)
|
|
{
|
|
// Get the last location in the list
|
|
locationDataProp = locationDataListProp.GetArrayElementAtIndex(locationDataListProp.arraySize - 1);
|
|
|
|
// Perform the delete in one place so that we can clean up the paths too.
|
|
locationDataDeletePos = locationDataListProp.arraySize - 1;
|
|
}
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
|
|
#endregion
|
|
|
|
#region Location Search Filter and filtering buttons
|
|
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label("", GUILayout.Width(2f));
|
|
GUILayout.Label(filterContent, labelFieldRichText, GUILayout.Width(50f));
|
|
if (sscManager.editorSearchLocationFilter == null) { sscManager.editorSearchLocationFilter = string.Empty; }
|
|
sscManager.editorSearchLocationFilter = GUILayout.TextField(sscManager.editorSearchLocationFilter, searchTextFieldStyle);
|
|
|
|
// Sometimes the search text is reverse search almost seems invisible (small search icon and cancel cannot be seen)
|
|
// Not sure how this occurs.
|
|
if (GUILayout.Button("", searchCancelButtonStyle))
|
|
{
|
|
sscManager.editorSearchLocationFilter = string.Empty;
|
|
GUI.FocusControl(null);
|
|
}
|
|
|
|
// Force buttons to be right justified
|
|
GUILayoutUtility.GetRect(1f, 1f);
|
|
|
|
// Toggle selection based on the first filtered one in the list
|
|
if (GUILayout.Button(selectBtnContent, buttonCompact, GUILayout.MaxWidth(20f)))
|
|
{
|
|
ToggleSelectList(locationDataListProp, sscManager.editorSearchLocationFilter);
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
// Provide space between previous controls and next ones
|
|
GUILayoutUtility.GetRect(1f, 3f);
|
|
|
|
#endregion
|
|
|
|
#region General Location Settings
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label("", GUILayout.Width(2f));
|
|
EditorGUILayout.PropertyField(locationDefaultNormalOffsetProp, locationDefaultNormalOffsetContent);
|
|
GUILayout.EndHorizontal();
|
|
#endregion
|
|
|
|
EditorGUILayout.EndVertical();
|
|
|
|
#region Location List
|
|
|
|
numLocations = locationDataListProp.arraySize;
|
|
numFilteredLocations = 0;
|
|
locationScrollPosition = EditorGUILayout.BeginScrollView(locationScrollPosition);
|
|
|
|
for (int idx = 0; idx < numLocations; idx++)
|
|
{
|
|
#region Get Location Properties (fields) and Filter if required
|
|
locationDataProp = locationDataListProp.GetArrayElementAtIndex(idx);
|
|
locationDataNameProp = locationDataProp.FindPropertyRelative("name");
|
|
|
|
// BUG: Debug Mode appear significantly below the end of the location list.
|
|
// This is due to the use of BeginScrollView which seems to have a minimum height/view area.
|
|
// Check if the list of Locations is being filtered. Ignore Locations not in the filter
|
|
if (!SSCEditorHelper.IsInSearchFilter(locationDataNameProp, sscManager.editorSearchLocationFilter)) { continue; }
|
|
numFilteredLocations++;
|
|
|
|
locationDataPositionProp = locationDataProp.FindPropertyRelative("position");
|
|
locationDataShowInEditorProp = locationDataProp.FindPropertyRelative("showInEditor");
|
|
locationDataShowGizmosInSceneViewProp = locationDataProp.FindPropertyRelative("showGizmosInSceneView");
|
|
locationDataSelectedProp = locationDataProp.FindPropertyRelative("selectedInSceneView");
|
|
#endregion
|
|
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
|
|
#region Location Find/Gizmos/Move/Insert/Delete buttons
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
|
|
EditorGUI.indentLevel += 1;
|
|
// A Foldout with no label must have a style fixedWidth of low non-zero value, and have a small (global) fieldWidth.
|
|
EditorGUIUtility.fieldWidth = 15f;
|
|
locationDataShowInEditorProp.boolValue = EditorGUILayout.Foldout(locationDataShowInEditorProp.boolValue, GUIContent.none, foldoutStyleNoLabel);
|
|
EditorGUIUtility.fieldWidth = defaultEditorFieldWidth;
|
|
EditorGUI.indentLevel -= 1;
|
|
|
|
EditorGUILayout.PropertyField(locationDataSelectedProp, GUIContent.none, GUILayout.Width(15f));
|
|
GUILayout.Label((idx + 1).ToString("0000") + " " + locationDataNameProp.stringValue, GUILayout.MaxWidth(125f));
|
|
|
|
// Force remaining buttons to be right justified
|
|
GUILayoutUtility.GetRect(1f, 1f);
|
|
|
|
if (locationDataShowGizmosInSceneViewProp.boolValue)
|
|
{
|
|
if (GUILayout.Button(findBtnContent, buttonCompact, GUILayout.MaxWidth(20f)))
|
|
{
|
|
// Move the scene view camera to the selected point
|
|
SSCEditorHelper.PositionSceneView(locationDataPositionProp.vector3Value, sscManager.findZoomDistance, this.GetType());
|
|
}
|
|
}
|
|
|
|
// Show Gizmos button
|
|
if (locationDataShowGizmosInSceneViewProp.boolValue) { if (GUILayout.Button(gizmoBtnContent, toggleCompactButtonStyleToggled, GUILayout.MaxWidth(22f))) { locationDataShowGizmosInSceneViewProp.boolValue = false; } }
|
|
else { if (GUILayout.Button(gizmoBtnContent, toggleCompactButtonStyleNormal, GUILayout.MaxWidth(22f))) { locationDataShowGizmosInSceneViewProp.boolValue = true; } }
|
|
|
|
// Move down button
|
|
if (GUILayout.Button("V", buttonCompact, GUILayout.MaxWidth(20f)) && numLocations > 1) { locationDataMoveDownPos = idx; }
|
|
// Create duplicate button
|
|
if (GUILayout.Button("I", buttonCompact, GUILayout.MaxWidth(20f))) { locationDataInsertPos = idx; }
|
|
// Delete button
|
|
if (GUILayout.Button("X", buttonCompact, GUILayout.MaxWidth(20f))) { locationDataDeletePos = idx; }
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
#endregion
|
|
|
|
if (locationDataShowInEditorProp.boolValue)
|
|
{
|
|
EditorGUILayout.PropertyField(locationDataNameProp, locationDataNameContent);
|
|
EditorGUILayout.PropertyField(locationDataPositionProp, locationDataPositionContent);
|
|
EditorGUILayout.PropertyField(locationDataProp.FindPropertyRelative("isRadarEnabled"), locationDataIsRadarEnabledContent);
|
|
EditorGUILayout.PropertyField(locationDataProp.FindPropertyRelative("radarBlipSize"), locationDataRadarBlipSizedContent);
|
|
EditorGUILayout.PropertyField(locationDataProp.FindPropertyRelative("factionId"), locationDataFactionIdContent);
|
|
}
|
|
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
EditorGUILayout.EndScrollView();
|
|
|
|
#endregion Location List
|
|
|
|
#region Move/Remove/Insert Locations
|
|
|
|
if (locationDataDeletePos >= 0 || locationDataInsertPos >= 0 || locationDataMoveDownPos >= 0)
|
|
{
|
|
GUI.FocusControl(null);
|
|
|
|
// Don't permit multiple operations in the same pass
|
|
if (locationDataMoveDownPos >= 0)
|
|
{
|
|
// Update lists directly rather than using MoveArrayElement to avoid issues with
|
|
// the Locations within each Path.
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Move Location in List");
|
|
LocationData moveLocationData = sscManager.locationDataList[locationDataMoveDownPos];
|
|
if (locationDataMoveDownPos < locationDataListProp.arraySize - 1)
|
|
{
|
|
sscManager.locationDataList.RemoveAt(locationDataMoveDownPos);
|
|
sscManager.locationDataList.Insert(locationDataMoveDownPos + 1, moveLocationData);
|
|
}
|
|
else
|
|
{
|
|
sscManager.locationDataList.Insert(0, moveLocationData);
|
|
sscManager.locationDataList.RemoveAt(sscManager.locationDataList.Count - 1);
|
|
|
|
}
|
|
serializedObject.Update();
|
|
|
|
locationDataMoveDownPos = -1;
|
|
}
|
|
else if (locationDataInsertPos >= 0)
|
|
{
|
|
// Apply property changes before potential list changes
|
|
serializedObject.ApplyModifiedProperties();
|
|
|
|
sscManager.locationDataList.Insert(locationDataInsertPos, new LocationData(sscManager.locationDataList[locationDataInsertPos]));
|
|
|
|
serializedObject.Update();
|
|
|
|
// Hide original locationData and unselect it
|
|
locationDataListProp.GetArrayElementAtIndex(locationDataInsertPos + 1).FindPropertyRelative("showInEditor").boolValue = false;
|
|
locationDataListProp.GetArrayElementAtIndex(locationDataInsertPos + 1).FindPropertyRelative("selectedInSceneView").boolValue = false;
|
|
locationDataShowInEditorProp = locationDataListProp.GetArrayElementAtIndex(locationDataInsertPos).FindPropertyRelative("showInEditor");
|
|
|
|
// Update Location with a unique hashcode
|
|
locationDataGUIDHashProp = locationDataListProp.GetArrayElementAtIndex(locationDataInsertPos).FindPropertyRelative("guidHash");
|
|
locationDataGUIDHashProp.intValue = SSCMath.GetHashCodeFromGuid();
|
|
|
|
locationDataNameProp = locationDataListProp.GetArrayElementAtIndex(locationDataInsertPos).FindPropertyRelative("name");
|
|
locationDataNameProp.stringValue += " (dup)";
|
|
|
|
// Force new locationData to be serialized in scene
|
|
locationDataShowInEditorProp.boolValue = !locationDataShowInEditorProp.boolValue;
|
|
|
|
// Show inserted duplicate locationData
|
|
locationDataShowInEditorProp.boolValue = true;
|
|
|
|
locationDataInsertPos = -1;
|
|
}
|
|
else if (locationDataDeletePos >= 0)
|
|
{
|
|
// In U2019.4+ DisplayDialog seems to trigger another OnInspectorGUI() and locationDataDeletePos is reset to -1.
|
|
int _deleteIndex = locationDataDeletePos;
|
|
|
|
if (EditorUtility.DisplayDialog("Delete Location " + (_deleteIndex + 1) + "?", "Location " + (_deleteIndex + 1) + " will be deleted\n\nThis action will remove the location from the list and all the paths.", "Delete Now", "Cancel"))
|
|
{
|
|
DeleteLocationFromPaths(pathDataListProp, locationDataListProp.GetArrayElementAtIndex(_deleteIndex).FindPropertyRelative("guidHash").intValue, true);
|
|
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Delete Location");
|
|
sscManager.locationDataList.RemoveAt(_deleteIndex);
|
|
serializedObject.Update();
|
|
}
|
|
|
|
locationDataDeletePos = -1;
|
|
}
|
|
|
|
SceneView.RepaintAll();
|
|
serializedObject.ApplyModifiedProperties();
|
|
GUIUtility.ExitGUI();
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
#endregion Locations Tab
|
|
|
|
#region Paths Tab
|
|
else if (selectedTabInt == 1)
|
|
{
|
|
if (sscManager.pathDataList == null)
|
|
{
|
|
// Apply property changes
|
|
serializedObject.ApplyModifiedProperties();
|
|
sscManager.pathDataList = new List<PathData>(5);
|
|
// Read in the properties
|
|
serializedObject.Update();
|
|
}
|
|
|
|
EditorGUILayout.LabelField(pathDataHeaderContent, helpBoxRichText);
|
|
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
|
|
#region Add-Remove-Import Path Buttons
|
|
|
|
numPaths = pathDataListProp.arraySize;
|
|
GUILayout.BeginHorizontal();
|
|
// Indent the Foldout 7px
|
|
GUILayout.Label("", GUILayout.Width(7f));
|
|
// Give a 2px gap between Foldout and Label
|
|
EditorGUIUtility.fieldWidth = 2f;
|
|
EditorGUI.BeginChangeCheck();
|
|
isPathDataListExpandedProp.boolValue = EditorGUILayout.Foldout(isPathDataListExpandedProp.boolValue, "", foldoutStyleNoLabel);
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
ExpandList(pathDataListProp, isPathDataListExpandedProp.boolValue);
|
|
}
|
|
EditorGUIUtility.fieldWidth = defaultEditorFieldWidth;
|
|
EditorGUILayout.LabelField("<color=" + txtColourName + "><b>Paths: " + numFilteredPaths + " of " + numPaths + "</b></color>", labelFieldRichText);
|
|
|
|
if (GUILayout.Button(pathDataImportJsonContent, GUILayout.MaxWidth(65f)))
|
|
{
|
|
string importPath = string.Empty, importFileName = string.Empty;
|
|
if (SSCEditorHelper.GetFilePathFromUser("Import Path Data", SSCSetup.sscFolder, new string[] { "JSON", "json" }, false, ref importPath, ref importFileName))
|
|
{
|
|
PathData importedPathData = SSCManager.ImportPathDataFromJson(importPath, importFileName);
|
|
if (importedPathData != null)
|
|
{
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Import Path");
|
|
|
|
// Check to see if Locations already exist
|
|
numPathLocations = importedPathData.pathLocationDataList == null ? 0 : importedPathData.pathLocationDataList.Count;
|
|
for (int pathLocIdx = 0; pathLocIdx < numPathLocations; pathLocIdx++)
|
|
{
|
|
PathLocationData pathLocationData = importedPathData.pathLocationDataList[pathLocIdx];
|
|
if (pathLocationData != null)
|
|
{
|
|
// If the Location already exists, re-link it to the imported Path
|
|
LocationData existingLocationData = sscManager.locationDataList.Find(loc => loc.guidHash == pathLocationData.locationData.guidHash);
|
|
if (existingLocationData != null)
|
|
{
|
|
pathLocationData.locationData = existingLocationData;
|
|
}
|
|
else
|
|
{
|
|
// Create new Locations for ones that don't already exist
|
|
sscManager.locationDataList.Add(pathLocationData.locationData);
|
|
}
|
|
}
|
|
}
|
|
|
|
sscManager.pathDataList.Add(importedPathData);
|
|
serializedObject.Update();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (numPaths > 0)
|
|
{
|
|
if (GUILayout.Button(gizmoToggleBtnContent, GUILayout.MaxWidth(22f)))
|
|
{
|
|
ToggleGizmos(pathDataListProp);
|
|
}
|
|
}
|
|
|
|
if (GUILayout.Button("+", GUILayout.MaxWidth(30f)))
|
|
{
|
|
// Apply property changes
|
|
serializedObject.ApplyModifiedProperties();
|
|
GUI.FocusControl(null);
|
|
Undo.RecordObject(sscManager, "Add Path");
|
|
sscManager.pathDataList.Add(new PathData() { locationDefaultNormalOffset = sscManager.locationDefaultNormalOffset });
|
|
// Read in the properties
|
|
serializedObject.Update();
|
|
|
|
numPaths = pathDataListProp.arraySize;
|
|
if (numPaths > 0)
|
|
{
|
|
// Force new path to be serialized in scene
|
|
pathDataProp = pathDataListProp.GetArrayElementAtIndex(numPaths - 1);
|
|
pathDataShowInEditorProp = pathDataProp.FindPropertyRelative("showInEditor");
|
|
pathDataShowInEditorProp.boolValue = !pathDataShowInEditorProp.boolValue;
|
|
// Show the new path
|
|
pathDataShowInEditorProp.boolValue = true;
|
|
// Make it the active path
|
|
pathDataActiveGUIDHashProp.intValue = pathDataProp.FindPropertyRelative("guidHash").intValue;
|
|
}
|
|
|
|
SceneView.RepaintAll();
|
|
}
|
|
if (GUILayout.Button("-", GUILayout.MaxWidth(30f)))
|
|
{
|
|
if (numPaths > 0)
|
|
{
|
|
// Get the last path in the list
|
|
pathDataProp = pathDataListProp.GetArrayElementAtIndex(pathDataListProp.arraySize - 1);
|
|
if (EditorUtility.DisplayDialog("Delete Path?", "Do you wish to delete Path " + (pathDataListProp.arraySize).ToString("00") + "?", "Delete Now", "Cancel"))
|
|
{
|
|
GUI.FocusControl(null);
|
|
pathDataListProp.arraySize -= 1;
|
|
serializedObject.ApplyModifiedProperties();
|
|
SceneView.RepaintAll();
|
|
}
|
|
GUIUtility.ExitGUI();
|
|
}
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
|
|
#endregion
|
|
|
|
#region Path Search Filter and filtering buttons
|
|
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label("", GUILayout.Width(2f));
|
|
GUILayout.Label(filterContent, labelFieldRichText, GUILayout.Width(50f));
|
|
if (sscManager.editorSearchPathFilter == null) { sscManager.editorSearchPathFilter = string.Empty; }
|
|
sscManager.editorSearchPathFilter = GUILayout.TextField(sscManager.editorSearchPathFilter, searchTextFieldStyle);
|
|
|
|
// Sometimes the search text is reverse search almost seems invisible (small search icon and cancel cannot be seen)
|
|
// Not sure how this occurs.
|
|
if (GUILayout.Button("", searchCancelButtonStyle))
|
|
{
|
|
sscManager.editorSearchPathFilter = string.Empty;
|
|
GUI.FocusControl(null);
|
|
}
|
|
|
|
//// Force buttons to be right justified
|
|
//GUILayoutUtility.GetRect(1f, 1f);
|
|
//// Toggle selection based on the first filtered one in the list
|
|
//if (GUILayout.Button(selectBtnContent, buttonCompact, GUILayout.MaxWidth(20f)))
|
|
//{
|
|
// ToggleSelectList(pathDataListProp, sscManager.editorSearchPathFilter);
|
|
//}
|
|
|
|
GUILayout.EndHorizontal();
|
|
// Provide space between previous controls and next ones
|
|
GUILayoutUtility.GetRect(1f, 3f);
|
|
|
|
#endregion
|
|
|
|
EditorGUILayout.EndVertical();
|
|
|
|
#region Path List
|
|
|
|
// Reset Path button variables
|
|
pathDataMoveDownPos = -1;
|
|
pathDataInsertPos = -1;
|
|
pathDataDeletePos = -1;
|
|
|
|
numPaths = pathDataListProp.arraySize;
|
|
numFilteredPaths = 0;
|
|
|
|
for (int pathIdx = 0; pathIdx < numPaths; pathIdx++)
|
|
{
|
|
#region Get Path Properties and Filter if required
|
|
pathDataProp = pathDataListProp.GetArrayElementAtIndex(pathIdx);
|
|
|
|
pathDataNameProp = pathDataProp.FindPropertyRelative("name");
|
|
|
|
// Check if the list of Paths is being filtered. Ignore Locations not in the filter
|
|
if (!SSCEditorHelper.IsInSearchFilter(pathDataNameProp, sscManager.editorSearchPathFilter)) { continue; }
|
|
numFilteredPaths++;
|
|
|
|
pathDataGUIDHashProp = pathDataProp.FindPropertyRelative("guidHash");
|
|
pathDataShowInEditorProp = pathDataProp.FindPropertyRelative("showInEditor");
|
|
pathDataShowLocationsInEditorProp = pathDataProp.FindPropertyRelative("showLocationsInEditor");
|
|
pathDataShowInSceneViewProp = pathDataProp.FindPropertyRelative("showGizmosInSceneView");
|
|
pathDataIsClosedCircuitProp = pathDataProp.FindPropertyRelative("isClosedCircuit");
|
|
pathDataLineColourProp = pathDataProp.FindPropertyRelative("pathLineColour");
|
|
pathDataShowNumberLabelsProp = pathDataProp.FindPropertyRelative("showPointNumberLabelsInScene");
|
|
pathDataShowNameLabelsProp = pathDataProp.FindPropertyRelative("showPointNameLabelsInScene");
|
|
#endregion
|
|
|
|
GUILayout.BeginVertical(EditorStyles.helpBox);
|
|
|
|
#region Path Active/Move/Insert/Delete buttons
|
|
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label("", GUILayout.Width(7f));
|
|
pathDataShowInEditorProp.boolValue = EditorGUILayout.Foldout(pathDataShowInEditorProp.boolValue, (pathIdx + 1).ToString("000") + " " + pathDataNameProp.stringValue);
|
|
|
|
#region Active Path
|
|
// Bold the "A" text on the button if this is the active layer
|
|
if (GUILayout.Button(pathDataActiveContent, pathDataActiveGUIDHashProp.intValue == pathDataGUIDHashProp.intValue ? buttonCompactBoldBlue : buttonCompact, GUILayout.Width(20f)))
|
|
{
|
|
pathDataActiveGUIDHashProp.intValue = pathDataGUIDHashProp.intValue;
|
|
}
|
|
#endregion
|
|
|
|
// Show Gizmos button
|
|
if (pathDataShowInSceneViewProp.boolValue) { if (GUILayout.Button(gizmoBtnContent, toggleCompactButtonStyleToggled, GUILayout.MaxWidth(22f))) { pathDataShowInSceneViewProp.boolValue = false; } }
|
|
else { if (GUILayout.Button(gizmoBtnContent, toggleCompactButtonStyleNormal, GUILayout.MaxWidth(22f))) { pathDataShowInSceneViewProp.boolValue = true; } }
|
|
|
|
// Move down button
|
|
if (GUILayout.Button("V", buttonCompact, GUILayout.MaxWidth(20f)) && numPaths > 1) { pathDataMoveDownPos = pathIdx; }
|
|
// Create duplicate button
|
|
if (GUILayout.Button("I", buttonCompact, GUILayout.MaxWidth(20f))) { pathDataInsertPos = pathIdx; }
|
|
// Delete button
|
|
if (GUILayout.Button("X", buttonCompact, GUILayout.MaxWidth(20f))) { pathDataDeletePos = pathIdx; }
|
|
GUILayout.EndHorizontal();
|
|
|
|
#endregion
|
|
|
|
if (pathDataShowInEditorProp.boolValue)
|
|
{
|
|
#region General Path Settings
|
|
EditorGUILayout.PropertyField(pathDataNameProp, pathDataNameContent);
|
|
|
|
GUILayout.BeginHorizontal();
|
|
if (pathDataActiveGUIDHashProp.intValue == pathDataGUIDHashProp.intValue)
|
|
{
|
|
if (GUILayout.Button(pathDataActivatedContent, buttonCompactBoldBlue, GUILayout.Width(defaultEditorLabelWidth - 5f)))
|
|
{
|
|
pathDataActiveGUIDHashProp.intValue = -1;
|
|
}
|
|
}
|
|
else if (GUILayout.Button(pathDataActivateContent, buttonCompact, GUILayout.Width(defaultEditorLabelWidth - 5f)))
|
|
{
|
|
pathDataActiveGUIDHashProp.intValue = pathDataGUIDHashProp.intValue;
|
|
// Auto-show path in scene
|
|
pathDataShowInSceneViewProp.boolValue = true;
|
|
// In case where Path name has the focus, disable it so that when user presses +/= key in the scene it doesn't
|
|
// just update the path name.
|
|
GUI.FocusControl(null);
|
|
}
|
|
|
|
#region PathData Export To Json
|
|
if (GUILayout.Button(pathDataExportJsonContent, buttonCompact, GUILayout.Width(100f)))
|
|
{
|
|
string exportPath = EditorUtility.SaveFilePanel("Save Path Data", "Assets", sscManager.pathDataList[pathIdx].name, "json");
|
|
|
|
if (SSCManager.SavePathDataAsJson(sscManager.pathDataList[pathIdx], exportPath))
|
|
{
|
|
// Check if path is in Project folder
|
|
if (exportPath.Contains(Application.dataPath))
|
|
{
|
|
// Get the folder to highlight in the Project folder
|
|
string folderPath = "Assets" + System.IO.Path.GetDirectoryName(exportPath).Replace(Application.dataPath, "");
|
|
|
|
// Get the json file in the Project folder
|
|
exportPath = "Assets" + exportPath.Replace(Application.dataPath, "");
|
|
AssetDatabase.ImportAsset(exportPath);
|
|
|
|
SSCEditorHelper.HighlightFolderInProjectWindow(folderPath, true, true);
|
|
}
|
|
Debug.Log("PathData exported to " + exportPath);
|
|
}
|
|
GUIUtility.ExitGUI();
|
|
}
|
|
#endregion
|
|
|
|
#region Snap To Mesh
|
|
if (GUILayout.Button(new GUIContent(pathDataSnapToMeshContent), buttonCompact, GUILayout.Width(100f)))
|
|
{
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Path Snap To Mesh");
|
|
sscManager.SnapPathToMesh(sscManager.pathDataList[pathIdx], Vector3.up, ~0, true);
|
|
serializedObject.Update();
|
|
SceneView.RepaintAll();
|
|
}
|
|
#endregion
|
|
|
|
GUILayout.EndHorizontal();
|
|
|
|
EditorGUILayout.LabelField(pathDataTotalDistanceContent, new GUIContent(pathDataProp.FindPropertyRelative("splineTotalDistance").floatValue.ToString("0.00")));
|
|
EditorGUI.BeginChangeCheck();
|
|
EditorGUILayout.PropertyField(pathDataIsClosedCircuitProp, pathDataIsClosedCircuitContent);
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
serializedObject.ApplyModifiedProperties();
|
|
// Potentially adjust tangents when circuit is closed...
|
|
sscManager.RefreshPathDistances(sscManager.pathDataList[pathIdx]);
|
|
serializedObject.Update();
|
|
}
|
|
// Don't allow Number and Name labels to be displayed at the same time
|
|
EditorGUI.BeginChangeCheck();
|
|
EditorGUILayout.PropertyField(pathDataShowNumberLabelsProp, pathDataShowPointNumberLabelsInSceneContent);
|
|
if (EditorGUI.EndChangeCheck() && pathDataShowNumberLabelsProp.boolValue)
|
|
{
|
|
pathDataShowNameLabelsProp.boolValue = false;
|
|
}
|
|
EditorGUI.BeginChangeCheck();
|
|
EditorGUILayout.PropertyField(pathDataShowNameLabelsProp, pathDataShowPointNameLabelsInSceneContent);
|
|
if (EditorGUI.EndChangeCheck() && pathDataShowNameLabelsProp.boolValue)
|
|
{
|
|
pathDataShowNumberLabelsProp.boolValue = false;
|
|
}
|
|
EditorGUILayout.PropertyField(pathDataProp.FindPropertyRelative("showDistancesInScene"), pathDataShowDistanceLabelsInSceneContent);
|
|
|
|
// We store the colour as a vector4 so it can be more portable so use a ColorField rather than a PropertyField.
|
|
pathDataLineColourProp.vector4Value = EditorGUILayout.ColorField(pathDataLineColourContent, pathDataLineColourProp.vector4Value);
|
|
EditorGUILayout.PropertyField(pathDataProp.FindPropertyRelative("locationDefaultNormalOffset"), pathDataLocationDefaultNormalOffsetContent);
|
|
|
|
GUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField(pathDataLocationSnapMinMaxHeightContent, GUILayout.Width(defaultEditorLabelWidth));
|
|
EditorGUILayout.PropertyField(pathDataProp.FindPropertyRelative("snapMinHeight"), GUIContent.none);
|
|
EditorGUILayout.PropertyField(pathDataProp.FindPropertyRelative("snapMaxHeight"), GUIContent.none);
|
|
GUILayout.EndHorizontal();
|
|
|
|
#endregion
|
|
|
|
pathLocationDataListProp = pathDataProp.FindPropertyRelative("pathLocationDataList");
|
|
|
|
if (pathLocationDataListProp != null)
|
|
{
|
|
#region Add-Remove Path Location slot, Modify Attribute, Reverse Buttons
|
|
|
|
// Reset path location slot variables
|
|
pathDataLocationMoveDownPos = -1;
|
|
pathDataLocationInsertPos = -1;
|
|
pathDataLocationDeletePos = -1;
|
|
|
|
numPathLocations = pathLocationDataListProp.arraySize;
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label("", GUILayout.Width(7f));
|
|
pathDataShowLocationsInEditorProp.boolValue = EditorGUILayout.Foldout(pathDataShowLocationsInEditorProp.boolValue, "Path Locations: " + numPathLocations.ToString("000"));
|
|
|
|
// Toggle modify selected path location attributes
|
|
if (GUILayout.Button(modifyToggleBtnContent, GUILayout.MaxWidth(22f)))
|
|
{
|
|
GUI.FocusControl(null);
|
|
isModifySelectedMode = !isModifySelectedMode;
|
|
|
|
if (isModifySelectedMode)
|
|
{
|
|
modifySelectedPosY = GetPosYSelectList(pathLocationDataListProp);
|
|
}
|
|
}
|
|
|
|
if (GUILayout.Button(reversePathBtnContent, GUILayout.MaxWidth(40f)))
|
|
{
|
|
GUI.FocusControl(null);
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Reverse Path");
|
|
sscManager.ReversePath(sscManager.pathDataList[pathIdx]);
|
|
SceneView.RepaintAll();
|
|
GUIUtility.ExitGUI();
|
|
}
|
|
|
|
if (GUILayout.Button("+", GUILayout.MaxWidth(30f)))
|
|
{
|
|
// Apply property changes
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Add Path Location slot");
|
|
sscManager.pathDataList[pathIdx].pathLocationDataList.Add(new PathLocationData());
|
|
|
|
// Read in the properties
|
|
serializedObject.Update();
|
|
|
|
numPathLocations = pathLocationDataListProp.arraySize;
|
|
if (numPathLocations > 0)
|
|
{
|
|
// Force new path location slot to be serialized in scene
|
|
pathLocationDataProp = pathLocationDataListProp.GetArrayElementAtIndex(numPathLocations - 1);
|
|
pathDataShowInEditorProp = pathLocationDataProp.FindPropertyRelative("showInEditor");
|
|
pathDataShowInEditorProp.boolValue = !pathDataShowInEditorProp.boolValue;
|
|
// Show the new path location slot
|
|
pathDataShowInEditorProp.boolValue = true;
|
|
pathDataShowLocationsInEditorProp.boolValue = true;
|
|
}
|
|
|
|
SceneView.RepaintAll();
|
|
}
|
|
if (GUILayout.Button("-", GUILayout.MaxWidth(30f)))
|
|
{
|
|
if (numPathLocations > 0)
|
|
{
|
|
pathDataLocationDeletePos = pathLocationDataListProp.arraySize - 1;
|
|
}
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
|
|
#endregion
|
|
|
|
#region Modify Selected
|
|
if (isModifySelectedMode)
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
modifySelectedPosY = EditorGUILayout.FloatField(modifySelectedPosYContent, modifySelectedPosY);
|
|
|
|
if (GUILayout.Button("Change", GUILayout.Width(65f)))
|
|
{
|
|
SetPosYSelectList(sscManager.pathDataList[pathIdx], modifySelectedPosY);
|
|
|
|
isModifySelectedMode = false;
|
|
GUIUtility.ExitGUI();
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
|
|
GUILayout.BeginHorizontal();
|
|
modifySelectedAddPosY = EditorGUILayout.FloatField(modifySelectedAddPosYContent, modifySelectedAddPosY);
|
|
|
|
if (GUILayout.Button("Change", GUILayout.Width(65f)))
|
|
{
|
|
AddPosYSelectList(sscManager.pathDataList[pathIdx], modifySelectedAddPosY);
|
|
|
|
isModifySelectedMode = false;
|
|
GUIUtility.ExitGUI();
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Path Location List
|
|
numPathLocations = pathLocationDataListProp.arraySize;
|
|
|
|
if (pathDataShowLocationsInEditorProp.boolValue)
|
|
{
|
|
for (int pathLocIdx = 0; pathLocIdx < numPathLocations; pathLocIdx++)
|
|
{
|
|
#region Get Path Location Data properties (fields)
|
|
// Get the PathLocationData class instance from the list
|
|
pathLocationDataProp = pathLocationDataListProp.GetArrayElementAtIndex(pathLocIdx);
|
|
// Get the LocationData class reference from within the PathLocationData class instance
|
|
pathLocationDataLocationProp = pathLocationDataProp.FindPropertyRelative("locationData");
|
|
// Get the properties (fields) of the LocationData within the PathLocationData class instance
|
|
pathDataLocationNameProp = pathLocationDataLocationProp.FindPropertyRelative("name");
|
|
pathDataLocationPositionProp = pathLocationDataLocationProp.FindPropertyRelative("position");
|
|
pathDataLocationSelectedProp = pathLocationDataLocationProp.FindPropertyRelative("selectedInSceneView");
|
|
pathDataLocationGUIDHashProp = pathLocationDataLocationProp.FindPropertyRelative("guidHash");
|
|
pathDataLocationUnassignedProp = pathLocationDataLocationProp.FindPropertyRelative("isUnassigned");
|
|
pathDataLocationShowGizmosInSceneViewProp = pathLocationDataLocationProp.FindPropertyRelative("showGizmosInSceneView");
|
|
#endregion
|
|
|
|
GUILayout.BeginHorizontal();
|
|
|
|
// Find in scene if it is assigned to Location from the SSSManager.locationDataList (not just a member of the Path)
|
|
if (GUILayout.Button(findBtnContent, buttonCompact, GUILayout.MaxWidth(20f)) && !pathDataLocationUnassignedProp.boolValue)
|
|
{
|
|
// Move the scene view camera to the selected point
|
|
SSCEditorHelper.PositionSceneView(pathDataLocationPositionProp.vector3Value, sscManager.findZoomDistance, this.GetType());
|
|
// Show it in the scene
|
|
pathDataLocationShowGizmosInSceneViewProp.boolValue = true;
|
|
// Select it in the scene (doesn't unselect other locations)
|
|
pathDataLocationSelectedProp.boolValue = true;
|
|
}
|
|
|
|
// When using VerifyPathConnections() for some reason cannot update the Properties.
|
|
EditorGUI.BeginChangeCheck();
|
|
pathLocationDataIsSelected = EditorGUILayout.Toggle(GUIContent.none, pathDataLocationSelectedProp.boolValue, GUILayout.Width(15f));
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Path Location Selection");
|
|
sscManager.pathDataList[pathIdx].pathLocationDataList[pathLocIdx].locationData.selectedInSceneView = pathLocationDataIsSelected;
|
|
serializedObject.Update();
|
|
SceneView.RepaintAll();
|
|
}
|
|
|
|
if (GUILayout.Button("..", buttonCompact, GUILayout.MaxWidth(20f)))
|
|
{
|
|
// Apply property changes
|
|
serializedObject.ApplyModifiedProperties();
|
|
|
|
int selectedIdx = sscManager.locationDataList.FindIndex(loc => loc.guidHash == pathDataLocationGUIDHashProp.intValue);
|
|
|
|
// TODO - filter the drop down list by default (could be 100s or 1000s of locations in the scene).
|
|
// Create a drop down list of all the locations
|
|
GenericMenu dropdown = new GenericMenu();
|
|
for (int i = 0; i < sscManager.locationDataList.Count; i++)
|
|
{
|
|
// Replace space #/%/& with different chars as Unity treats them as SHIFT/CTRL/ALT in menus.
|
|
string _locationName = string.IsNullOrEmpty(sscManager.locationDataList[i].name) ? "No Name" : sscManager.locationDataList[i].name.Replace(" #", "_#").Replace(" &", " &&").Replace(" %", "_%");
|
|
dropdown.AddItem(new GUIContent(_locationName), i == selectedIdx, UpdatePathLocation, new Vector3Int(pathDataGUIDHashProp.intValue, pathDataLocationGUIDHashProp.intValue, sscManager.locationDataList[i].guidHash));
|
|
}
|
|
dropdown.ShowAsContext();
|
|
SceneView.RepaintAll();
|
|
|
|
serializedObject.Update();
|
|
}
|
|
EditorGUILayout.LabelField(string.IsNullOrEmpty(pathDataLocationNameProp.stringValue) ? "unknown" : pathDataLocationNameProp.stringValue);
|
|
|
|
// Move down button
|
|
if (GUILayout.Button("V", buttonCompact, GUILayout.MaxWidth(20f)) && numPathLocations > 1) { pathDataLocationMoveDownPos = pathLocIdx; }
|
|
// Create duplicate button
|
|
if (GUILayout.Button("I", buttonCompact, GUILayout.MaxWidth(20f))) { pathDataLocationInsertPos = pathLocIdx; }
|
|
|
|
if (GUILayout.Button("X", buttonCompact, GUILayout.MaxWidth(20f))) { pathDataLocationDeletePos = pathLocIdx; }
|
|
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
}
|
|
#endregion Path Location List
|
|
|
|
#region Move/Remove/Insert Path Location
|
|
|
|
if (pathDataLocationDeletePos >= 0 || pathDataLocationInsertPos >= 0 || pathDataLocationMoveDownPos >= 0)
|
|
{
|
|
GUI.FocusControl(null);
|
|
|
|
// Don't permit multiple operations in the same pass
|
|
if (pathDataLocationMoveDownPos >= 0)
|
|
{
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Move Location in Path List");
|
|
PathLocationData movePathLocationData = sscManager.pathDataList[pathIdx].pathLocationDataList[pathDataLocationMoveDownPos];
|
|
if (pathDataLocationMoveDownPos < pathLocationDataListProp.arraySize - 1)
|
|
{
|
|
sscManager.pathDataList[pathIdx].pathLocationDataList.RemoveAt(pathDataLocationMoveDownPos);
|
|
sscManager.pathDataList[pathIdx].pathLocationDataList.Insert(pathDataLocationMoveDownPos + 1, movePathLocationData);
|
|
}
|
|
else
|
|
{
|
|
sscManager.pathDataList[pathIdx].pathLocationDataList.Insert(0, movePathLocationData);
|
|
sscManager.pathDataList[pathIdx].pathLocationDataList.RemoveAt(sscManager.pathDataList[pathIdx].pathLocationDataList.Count - 1);
|
|
}
|
|
sscManager.RefreshPathDistances(sscManager.pathDataList[pathIdx]);
|
|
serializedObject.Update();
|
|
pathDataLocationMoveDownPos = -1;
|
|
}
|
|
else if (pathDataLocationInsertPos >= 0)
|
|
{
|
|
// Apply property changes before potential list changes
|
|
serializedObject.ApplyModifiedProperties();
|
|
|
|
// Insert a new default location. The user will replace this with one from the list of Locations
|
|
// For locations in a path, there is no advantage of duplicated an existing location slot
|
|
Undo.RecordObject(sscManager, "Insert Path Location slot");
|
|
sscManager.pathDataList[pathIdx].pathLocationDataList.Insert(pathDataLocationInsertPos, new PathLocationData());
|
|
|
|
serializedObject.Update();
|
|
|
|
// Hide original pathDataLocation
|
|
pathLocationDataListProp.GetArrayElementAtIndex(pathDataLocationInsertPos + 1).FindPropertyRelative("showInEditor").boolValue = false;
|
|
|
|
SerializedProperty pathLocationDataInsertedProp = pathLocationDataListProp.GetArrayElementAtIndex(pathDataLocationInsertPos);
|
|
pathDataLocationShowInEditorProp = pathLocationDataInsertedProp.FindPropertyRelative("showInEditor");
|
|
pathLocationDataInsertedProp.FindPropertyRelative("locationData").FindPropertyRelative("isUnassigned").boolValue = true;
|
|
|
|
// Force new pathDataLocation to be serialized in scene
|
|
pathDataLocationShowInEditorProp.boolValue = !pathDataLocationShowInEditorProp.boolValue;
|
|
|
|
// Show inserted duplicate pathDataLocation
|
|
pathDataLocationShowInEditorProp.boolValue = true;
|
|
|
|
pathDataLocationInsertPos = -1;
|
|
}
|
|
else if (pathDataLocationDeletePos >= 0)
|
|
{
|
|
// In U2019.4+ DisplayDialog seems to trigger another OnInspectorGUI() and pathDataLocationDeletePos is reset to -1.
|
|
int _deleteIndex = pathDataLocationDeletePos;
|
|
int _pathIndex = pathIdx;
|
|
|
|
// Get the last Path Location slot in the list
|
|
pathLocationDataProp = pathLocationDataListProp.GetArrayElementAtIndex(_deleteIndex);
|
|
if (SSCEditorHelper.PromptForDelete("Delete Path Location slot?", "Do you wish to delete Path Location slot " + (_deleteIndex+1).ToString("00") + "?"))
|
|
{
|
|
pathDataShowLocationsInEditorProp.boolValue = true;
|
|
|
|
// Change the list rather than use DeleteArrayElementAtIndex which has issues with undo.
|
|
serializedObject.ApplyModifiedProperties();
|
|
Undo.RecordObject(sscManager, "Delete Path Location Slot");
|
|
sscManager.pathDataList[_pathIndex].pathLocationDataList.RemoveAt(_deleteIndex);
|
|
sscManager.RefreshPathDistances(sscManager.pathDataList[_pathIndex]);
|
|
pathDataLocationDeletePos = -1;
|
|
|
|
SceneView.RepaintAll();
|
|
GUIUtility.ExitGUI();
|
|
|
|
//serializedObject.Update();
|
|
}
|
|
}
|
|
|
|
SceneView.RepaintAll();
|
|
}
|
|
|
|
#endregion Move/Remove/Insert Path Location
|
|
}
|
|
}
|
|
|
|
// There is a bug here in 2019.4 and 2020.1 where the DisplayDialog causes formatting issues.
|
|
// EndLayoutGroup: BeginLayoutGroup must be called first.
|
|
// No 2019_4 define but earlier versions still seem to work.
|
|
#if UNITY_2019_3_OR_NEWER
|
|
//if (pathDataLocationDeletePos >= 0 ) { GUILayout.BeginVertical(); }
|
|
if (pathDataLocationDeletePos >= 0 ) { GUIUtility.ExitGUI(); }
|
|
#endif
|
|
|
|
GUILayout.EndVertical();
|
|
}
|
|
|
|
#endregion Path List
|
|
|
|
#region Move/Remove/Insert Paths
|
|
|
|
if (pathDataDeletePos >= 0 || pathDataInsertPos >= 0 || pathDataMoveDownPos >= 0)
|
|
{
|
|
GUI.FocusControl(null);
|
|
|
|
// Don't permit multiple operations in the same pass
|
|
if (pathDataMoveDownPos >= 0)
|
|
{
|
|
// Move down one position, or wrap round to start of list
|
|
if (pathDataMoveDownPos < pathDataListProp.arraySize - 1)
|
|
{
|
|
pathDataListProp.MoveArrayElement(pathDataMoveDownPos, pathDataMoveDownPos + 1);
|
|
}
|
|
else { pathDataListProp.MoveArrayElement(pathDataMoveDownPos, 0); }
|
|
|
|
pathDataMoveDownPos = -1;
|
|
}
|
|
else if (pathDataInsertPos >= 0)
|
|
{
|
|
// Apply property changes before potential list changes
|
|
serializedObject.ApplyModifiedProperties();
|
|
|
|
sscManager.pathDataList.Insert(pathDataInsertPos, new PathData(sscManager.pathDataList[pathDataInsertPos]));
|
|
|
|
serializedObject.Update();
|
|
|
|
// Hide original pathData
|
|
pathDataListProp.GetArrayElementAtIndex(pathDataInsertPos + 1).FindPropertyRelative("showInEditor").boolValue = false;
|
|
pathDataShowInEditorProp = pathDataListProp.GetArrayElementAtIndex(pathDataInsertPos).FindPropertyRelative("showInEditor");
|
|
|
|
// Update Path with a unique hashcode
|
|
pathDataGUIDHashProp = pathDataListProp.GetArrayElementAtIndex(pathDataInsertPos).FindPropertyRelative("guidHash");
|
|
pathDataGUIDHashProp.intValue = SSCMath.GetHashCodeFromGuid();
|
|
|
|
// Force new pathData to be serialized in scene
|
|
pathDataShowInEditorProp.boolValue = !pathDataShowInEditorProp.boolValue;
|
|
|
|
// Show inserted duplicate pathData
|
|
pathDataShowInEditorProp.boolValue = true;
|
|
|
|
pathDataInsertPos = -1;
|
|
}
|
|
else if (pathDataDeletePos >= 0)
|
|
{
|
|
// In U2019.4+ DisplayDialog seems to trigger another OnInspectorGUI() and pathDataDeletePos is reset to -1.
|
|
int _deleteIndex = pathDataDeletePos;
|
|
|
|
if (EditorUtility.DisplayDialog("Delete Path " + (_deleteIndex + 1).ToString("00") + "?", "Path " + (_deleteIndex + 1).ToString("00") + " will be deleted\n\nThis action will remove the path from the list and cannot be undone.", "Delete Now", "Cancel"))
|
|
{
|
|
pathDataListProp.DeleteArrayElementAtIndex(_deleteIndex);
|
|
pathDataDeletePos = -1;
|
|
}
|
|
}
|
|
|
|
SceneView.RepaintAll();
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
#endregion Paths Tab
|
|
|
|
#region Options Tab
|
|
else if (selectedTabInt == 2)
|
|
{
|
|
GUILayout.BeginVertical(EditorStyles.helpBox);
|
|
// Location Options
|
|
GUILayout.Label(optionLocationContent, labelFieldRichText);
|
|
EditorGUILayout.PropertyField(isAutosizeLocationGizmoProp, optionIsAutosizeLocationGizmoContent);
|
|
EditorGUILayout.PropertyField(locationGizmoColourProp, optionLocationGizmoColourContent);
|
|
EditorGUILayout.PropertyField(findZoomDistanceProp, optionFindZoomDistanceContent);
|
|
|
|
// Path Options
|
|
GUILayout.Label(optionPathContent, labelFieldRichText);
|
|
EditorGUILayout.PropertyField(defaultPathControlGizmoColourProp, optionPathControlGizmoColourContent);
|
|
EditorGUILayout.PropertyField(pathDisplayResolutionProp, optionPathDisplayResolutionContent);
|
|
EditorGUILayout.PropertyField(pathPrecisionProp, optionPathPrecisionContent);
|
|
EditorGUILayout.PropertyField(defaultPathControlOffsetProp, optionPathControlOffsetContent);
|
|
|
|
//// Radar Options
|
|
//GUILayout.Label(optionRadarContent, labelFieldRichText);
|
|
|
|
GUILayout.EndVertical();
|
|
}
|
|
#endregion
|
|
|
|
// Apply property changes
|
|
serializedObject.ApplyModifiedProperties();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|