forked from kaka3286/RoadRunner
2265 lines
94 KiB
C#
2265 lines
94 KiB
C#
#if UNITY_EDITOR
|
|
#region "Imports"
|
|
using UnityEngine;
|
|
using UnityEditor;
|
|
using System.Collections.Generic;
|
|
#endregion
|
|
|
|
|
|
//=====================================================
|
|
//== NOTE THAT CUSTOM SERIALIZATION IS USED HERE ==
|
|
//== SOLELY TO COMPLY WITH UNDO REQUIREMENTS ==
|
|
//=====================================================
|
|
|
|
|
|
namespace RoadArchitect
|
|
{
|
|
[CustomEditor(typeof(SplineN))]
|
|
public class SplineNEditor : Editor
|
|
{
|
|
#region "Vars"
|
|
private SplineN node;
|
|
private int count = -1;
|
|
private int currentCount = 0;
|
|
public bool isSplinatedObjectHelp = false;
|
|
public bool isEdgeObjectHelp = false;
|
|
private bool isRemovingAll = false;
|
|
private float horizRoadMax = 0;
|
|
|
|
private SplineN node1 = null;
|
|
private SplineN node2 = null;
|
|
private bool isCreatingIntersection = false;
|
|
|
|
|
|
#region "Button icons"
|
|
private Texture deleteButtonTexture = null;
|
|
private Texture copyButtonTexture = null;
|
|
private Texture saveButtonTexture = null;
|
|
private Texture loadButtonTexture = null;
|
|
private Texture extrudeButtonTexture = null;
|
|
private Texture edgeButtonTexture = null;
|
|
private Texture helpButtonTexture = null;
|
|
private Texture refreshButtonTexture = null;
|
|
private Texture defaultButtonTexture = null;
|
|
private Texture2D loadButtonBG = null;
|
|
private Texture2D textAreaBG = null;
|
|
private Texture2D loadButtonBGGlow = null;
|
|
private Texture2D manualBG = null;
|
|
#endregion
|
|
|
|
|
|
public bool isLoadingEOS = false;
|
|
public int loadingEOSIndex = 0;
|
|
public List<string> loadingEOSNames = null;
|
|
public List<string> loadingEOSPaths = null;
|
|
|
|
public bool isLoadingEOM = false;
|
|
public int loadingEOMIndex = 0;
|
|
public List<string> loadingEOMNames = null;
|
|
public List<string> loadingEOMPaths = null;
|
|
|
|
//Checkers:
|
|
private Splination.SplinatedMeshMaker SMM = null;
|
|
private EndObjectsDefaultsEnum endObjectAdd = EndObjectsDefaultsEnum.None;
|
|
private SMMDefaultsEnum SMMQuickAdd = SMMDefaultsEnum.None;
|
|
private BridgeTopBaseDefaultsEnum BridgeTopBaseQuickAdd = BridgeTopBaseDefaultsEnum.None;
|
|
private BridgeBottomBaseDefaultsEnum BridgeBottomBaseQuickAdd = BridgeBottomBaseDefaultsEnum.None;
|
|
private HorizMatchingDefaultsEnum horizMatching = HorizMatchingDefaultsEnum.None;
|
|
|
|
//BridgeWizardDefaultsEnum bridgeWizardQuickAdd = BridgeWizardDefaultsEnum.None;
|
|
//RoadArchitect.Splination.CollisionTypeEnum collisionType = RoadArchitect.Splination.CollisionTypeEnum.SimpleMeshTriangle;
|
|
//RoadArchitect.Splination.RepeatUVTypeEnum repeatUVType = RoadArchitect.Splination.RepeatUVTypeEnum.None;
|
|
private EdgeObjects.EdgeObjectMaker EOM = null;
|
|
private GUIStyle imageButton = null;
|
|
private GUIStyle loadButton = null;
|
|
private GUIStyle manualButton = null;
|
|
private GUIStyle guiButton = null;
|
|
|
|
private bool isSceneRectSet = false;
|
|
private Rect sceneRect = default(Rect);
|
|
private Event currentEvent;
|
|
private bool isInitialized = false;
|
|
|
|
// Bridge
|
|
private bool isBridgeStart = false;
|
|
private bool isBridgeEnd = false;
|
|
private bool isRoadCut = false;
|
|
|
|
private bool isSingleTemp;
|
|
|
|
private string[] HorizMatchSubTypeDescriptions;
|
|
#endregion
|
|
|
|
|
|
#region "Enums"
|
|
public enum EndObjectsDefaultsEnum
|
|
{
|
|
None,
|
|
WarningSign1_Static,
|
|
WarningSign2_Static,
|
|
Atten_Static,
|
|
Barrel1_Static,
|
|
Barrel1_Rigid,
|
|
Barrel3_Static,
|
|
Barrel3_Rigid,
|
|
Barrel7_Static,
|
|
Barrel7_Rigid
|
|
};
|
|
|
|
|
|
private static string[] EndObjectsDefaultsEnumDesc = new string[]{
|
|
"Quick add",
|
|
"WarningSign1",
|
|
"WarningSign2",
|
|
"Attenuator",
|
|
"1 Sand barrel Static",
|
|
"1 Sand barrel Rigid",
|
|
"3 Sand barrels Static",
|
|
"3 Sand barrels Rigid",
|
|
"7 Sand barrels Static",
|
|
"7 Sand barrels Rigid"
|
|
};
|
|
|
|
|
|
public enum SMMDefaultsEnum
|
|
{
|
|
None, Custom,
|
|
KRail,
|
|
WBeamR,
|
|
WBeamL,
|
|
Railing1,
|
|
Railing2,
|
|
Railing3,
|
|
Railing4,
|
|
RailingBase05m,
|
|
RailingBase1m
|
|
};
|
|
|
|
|
|
public enum BridgeTopBaseDefaultsEnum
|
|
{
|
|
None,
|
|
BaseExact,
|
|
Base1MOver,
|
|
Base2MOver,
|
|
Base3MDeep,
|
|
};
|
|
|
|
|
|
public enum BridgeBottomBaseDefaultsEnum
|
|
{
|
|
None,
|
|
BridgeBase6,
|
|
BridgeBase7,
|
|
BridgeBase8,
|
|
BridgeBaseGrid,
|
|
BridgeSteel,
|
|
BridgeBase2,
|
|
BridgeBase3,
|
|
BridgeBase4,
|
|
BridgeBase5,
|
|
};
|
|
|
|
|
|
public enum BridgeWizardDefaultsEnum
|
|
{
|
|
None,
|
|
ArchBridge12m,
|
|
ArchBridge24m,
|
|
ArchBridge48m,
|
|
SuspensionBridgeSmall,
|
|
SuspensionBridgeLarge,
|
|
CausewayBridge1,
|
|
CausewayBridge2,
|
|
CausewayBridge3,
|
|
CausewayBridge4,
|
|
ArchBridge1,
|
|
ArchBridge2,
|
|
ArchBridge3,
|
|
GridBridge,
|
|
SteelBeamBridge
|
|
};
|
|
|
|
|
|
public enum HorizMatchingDefaultsEnum
|
|
{
|
|
None,
|
|
MatchCenter,
|
|
MatchRoadLeft,
|
|
MatchShoulderLeft,
|
|
MatchRoadRight,
|
|
MatchShoulderRight
|
|
};
|
|
|
|
|
|
public enum EOMDefaultsEnum { None, Custom, StreetLightSingle, StreetLightDouble };
|
|
|
|
|
|
private static string[] TheAxisDescriptionsSpline = new string[]{
|
|
"X axis",
|
|
"Z axis"
|
|
};
|
|
|
|
|
|
private static string[] RepeatUVTypeDescriptionsSpline = new string[]{
|
|
"None",
|
|
"X axis",
|
|
"Y axis"
|
|
};
|
|
|
|
|
|
private static string[] TheCollisionTypeEnumDescSpline = new string[]{
|
|
"None",
|
|
"Simple triangle",
|
|
"Simple trapezoid",
|
|
"Meshfilter collision mesh",
|
|
"Straight line box collider"
|
|
};
|
|
#endregion
|
|
|
|
|
|
private void OnEnable()
|
|
{
|
|
node = (SplineN)target;
|
|
}
|
|
|
|
|
|
private void Init()
|
|
{
|
|
isInitialized = true;
|
|
EditorStyles.label.wordWrap = true;
|
|
EditorStyles.miniLabel.wordWrap = true;
|
|
string basePath = RoadEditorUtility.GetBasePath();
|
|
|
|
EditorUtilities.LoadTexture(ref deleteButtonTexture, basePath + "/Editor/Icons/delete.png");
|
|
EditorUtilities.LoadTexture(ref copyButtonTexture, basePath + "/Editor/Icons/copy.png");
|
|
EditorUtilities.LoadTexture(ref loadButtonTexture, basePath + "/Editor/Icons/load.png");
|
|
EditorUtilities.LoadTexture(ref saveButtonTexture, basePath + "/Editor/Icons/save.png");
|
|
EditorUtilities.LoadTexture(ref extrudeButtonTexture, basePath + "/Editor/Icons/extrude.png");
|
|
EditorUtilities.LoadTexture(ref edgeButtonTexture, basePath + "/Editor/Icons/edge.png");
|
|
EditorUtilities.LoadTexture(ref helpButtonTexture, basePath + "/Editor/Icons/help.png");
|
|
EditorUtilities.LoadTexture(ref refreshButtonTexture, basePath + "/Editor/Icons/refresh.png");
|
|
EditorUtilities.LoadTexture(ref defaultButtonTexture, basePath + "/Editor/Icons/refresh2.png");
|
|
EditorUtilities.LoadTexture(ref textAreaBG, basePath + "/Editor/Icons/popupbg.png");
|
|
EditorUtilities.LoadTexture(ref loadButtonBG, basePath + "/Editor/Icons/loadbg.png");
|
|
EditorUtilities.LoadTexture(ref loadButtonBGGlow, basePath + "/Editor/Icons/loadbgglow.png");
|
|
EditorUtilities.LoadTexture(ref manualBG, basePath + "/Editor/Icons/manualbg.png");
|
|
|
|
if (imageButton == null)
|
|
{
|
|
imageButton = new GUIStyle(GUI.skin.button);
|
|
imageButton.contentOffset = new Vector2(0f, -2f);
|
|
imageButton.border = new RectOffset(0, 0, 0, 0);
|
|
imageButton.fixedHeight = 16f;
|
|
imageButton.padding = new RectOffset(0, 0, 0, 0);
|
|
imageButton.normal.background = null;
|
|
}
|
|
|
|
if (loadButton == null)
|
|
{
|
|
loadButton = new GUIStyle(GUI.skin.button);
|
|
loadButton.contentOffset = new Vector2(0f, 1f);
|
|
loadButton.normal.textColor = new Color(1f, 1f, 1f, 1f);
|
|
loadButton.normal.background = loadButtonBG;
|
|
loadButton.active.background = loadButtonBGGlow;
|
|
loadButton.focused.background = loadButtonBGGlow;
|
|
loadButton.hover.background = loadButtonBGGlow;
|
|
loadButton.fixedHeight = 16f;
|
|
loadButton.fixedWidth = 128f;
|
|
loadButton.padding = new RectOffset(0, 35, 0, 0);
|
|
}
|
|
|
|
if (manualButton == null)
|
|
{
|
|
manualButton = new GUIStyle(GUI.skin.button);
|
|
manualButton.contentOffset = new Vector2(0f, 1f);
|
|
manualButton.normal.textColor = new Color(1f, 1f, 1f, 1f);
|
|
manualButton.normal.background = manualBG;
|
|
manualButton.fixedHeight = 16f;
|
|
manualButton.fixedWidth = 128f;
|
|
}
|
|
|
|
if (guiButton == null)
|
|
{
|
|
guiButton = new GUIStyle(GUI.skin.button);
|
|
guiButton.normal.textColor = new Color(0.5f, 1f, 0.5f, 1f);
|
|
}
|
|
|
|
float halfRoadWidth = node.spline.road.RoadWidth() * 0.5f;
|
|
HorizMatchSubTypeDescriptions = new string[6];
|
|
HorizMatchSubTypeDescriptions[0] = "Select preset";
|
|
HorizMatchSubTypeDescriptions[1] = "Match center: 0 meters";
|
|
HorizMatchSubTypeDescriptions[2] = "Match road left edge: -" + halfRoadWidth.ToString("F1") + " meters";
|
|
HorizMatchSubTypeDescriptions[4] = "Match road right edge: " + halfRoadWidth.ToString("F1") + " meters";
|
|
|
|
if (node.spline.road.isShouldersEnabled)
|
|
{
|
|
HorizMatchSubTypeDescriptions[3] = "Match shoulder left edge: -" + (halfRoadWidth + node.spline.road.shoulderWidth).ToString("F1") + " meters";
|
|
HorizMatchSubTypeDescriptions[5] = "Match shoulder right edge: " + (halfRoadWidth + node.spline.road.shoulderWidth).ToString("F1") + " meters";
|
|
}
|
|
else
|
|
{
|
|
HorizMatchSubTypeDescriptions[2] = "Match shoulder left edge: -" + halfRoadWidth.ToString("F1") + " meters";
|
|
HorizMatchSubTypeDescriptions[4] = "Match shoulder right edge: " + halfRoadWidth.ToString("F1") + " meters";
|
|
}
|
|
|
|
horizRoadMax = node.spline.road.RoadWidth() * 20;
|
|
}
|
|
|
|
|
|
public override void OnInspectorGUI()
|
|
{
|
|
#region "Event"
|
|
if (Event.current.type == EventType.ValidateCommand)
|
|
{
|
|
switch (Event.current.commandName)
|
|
{
|
|
case "UndoRedoPerformed":
|
|
UpdateSplineObjectsOnUndo();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (Event.current.type != EventType.Layout && isCreatingIntersection)
|
|
{
|
|
isCreatingIntersection = false;
|
|
Selection.activeGameObject = Intersections.CreateIntersection(node1, node2);
|
|
return;
|
|
}
|
|
#endregion
|
|
|
|
|
|
//Graphic null checks:
|
|
if (!isInitialized)
|
|
{
|
|
Init();
|
|
}
|
|
|
|
EditorUtilities.DrawLine();
|
|
|
|
#region "Manuals on Top of SplineN Scripts"
|
|
EditorGUILayout.LabelField(node.spline.road.name + "-" + node.name, EditorStyles.boldLabel);
|
|
|
|
if (GUILayout.Button("Online manual", EditorStyles.miniButton, GUILayout.Width(128f)))
|
|
{
|
|
// formerly, which redirect to the master github http://microgsd.com/Support/RoadArchitectManual.aspx
|
|
Application.OpenURL("https://github.com/MicroGSD/RoadArchitect/wiki");
|
|
}
|
|
|
|
if (GUILayout.Button("Offline manual", EditorStyles.miniButton, GUILayout.Width(120f)))
|
|
{
|
|
RoadArchitect.EditorUtilities.OpenOfflineManual();
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region "Option: Manual road cut"
|
|
if (node.idOnSpline > 0 && node.idOnSpline < (node.spline.GetNodeCount() - 1) && !node.isIntersection && !node.isSpecialEndNode)
|
|
{
|
|
// && !cNode.bIsBridge_PreNode && !cNode.bIsBridge_PostNode){
|
|
if (node.spline.road.isDynamicCutsEnabled)
|
|
{
|
|
EditorUtilities.DrawLine();
|
|
isRoadCut = EditorGUILayout.Toggle("Cut road at this node: ", node.isRoadCut);
|
|
}
|
|
EditorUtilities.DrawLine();
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region "Option: Bridge options"
|
|
bool isBridgeDisplayed = false;
|
|
if (!node.isEndPoint)
|
|
{
|
|
//Bridge start:
|
|
if (!node.isBridgeEnd && node.CanBridgeStart())
|
|
{
|
|
isBridgeStart = EditorGUILayout.Toggle(" Bridge start", node.isBridgeStart);
|
|
isBridgeDisplayed = true;
|
|
}
|
|
//Bridge end:
|
|
if (!node.isBridgeStart && node.CanBridgeEnd())
|
|
{
|
|
isBridgeEnd = EditorGUILayout.Toggle(" Bridge end", node.isBridgeEnd);
|
|
isBridgeDisplayed = true;
|
|
}
|
|
|
|
if (isBridgeDisplayed)
|
|
{
|
|
RoadArchitect.EditorUtilities.DrawLine();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
if ((Selection.objects.Length == 1 && Selection.objects[0] is SplineN) || (node.specialNodeCounterpart == null && !node.isSpecialRoadConnPrimary))
|
|
{
|
|
//Do extrusion and edge objects overview:
|
|
DoExtAndEdgeOverview();
|
|
}
|
|
else
|
|
{
|
|
EditorGUILayout.BeginHorizontal();
|
|
if (GUILayout.Button("Road objects"))
|
|
{
|
|
Selection.objects = new Object[1] { node.specialNodeCounterpart };
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
|
|
if (node.isSpecialRoadConnPrimary)
|
|
{
|
|
EditorGUILayout.LabelField("Road connection:", EditorStyles.boldLabel);
|
|
EditorGUILayout.BeginVertical();
|
|
if (GUILayout.Button("Update road connection"))
|
|
{
|
|
SplineN node1 = node.originalConnectionNodes[0];
|
|
SplineN node2 = node.originalConnectionNodes[1];
|
|
node.specialNodeCounterpart.BreakConnection();
|
|
node.spline.road.UpdateRoad();
|
|
node1.spline.ActivateEndNodeConnection(node1, node2);
|
|
}
|
|
if (GUILayout.Button("Break road connection"))
|
|
{
|
|
node.specialNodeCounterpart.BreakConnection();
|
|
}
|
|
if (GUILayout.Button("Access objects on other node"))
|
|
{
|
|
Selection.objects = new Object[] { node.specialNodeCounterpart };
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
if (node.specialNodeCounterpart != null)
|
|
{
|
|
EditorGUILayout.LabelField(node.specialNodeCounterpart.spline.road.transform.name + " to " + node.specialNodeCounterpart.specialNodeCounterpart.spline.road.transform.name);
|
|
}
|
|
EditorGUILayout.LabelField("To break this road connection, click the \"Break road connection\" button.");
|
|
EditorUtilities.DrawLine();
|
|
}
|
|
|
|
//Statistics:
|
|
DoStats();
|
|
EditorGUILayout.EndVertical();
|
|
|
|
if (GUI.changed)
|
|
{
|
|
//Set snapshot for undo:
|
|
Undo.RecordObject(node, "Modify node");
|
|
|
|
//Option: Manual cut:
|
|
if (node.idOnSpline > 0 && node.idOnSpline < (node.spline.GetNodeCount() - 1) && !node.isIntersection && !node.isSpecialEndNode)
|
|
{
|
|
// && !cNode.bIsBridge_PreNode && !cNode.bIsBridge_PostNode){
|
|
if (node.spline.road.isDynamicCutsEnabled)
|
|
{
|
|
if (isRoadCut != node.isRoadCut)
|
|
{
|
|
node.isRoadCut = isRoadCut;
|
|
}
|
|
}
|
|
}
|
|
|
|
#region "Option: Bridge options"
|
|
//Bridge start:
|
|
if (!node.isEndPoint)
|
|
{
|
|
if (!node.isBridgeEnd && node.CanBridgeStart())
|
|
{
|
|
if (isBridgeStart != node.isBridgeStart)
|
|
{
|
|
node.isBridgeStart = isBridgeStart;
|
|
node.BridgeToggleStart();
|
|
}
|
|
}
|
|
}
|
|
//Bridge end:
|
|
if (!node.isEndPoint)
|
|
{
|
|
if (!node.isBridgeStart && node.CanBridgeEnd())
|
|
{
|
|
if (isBridgeEnd != node.isBridgeEnd)
|
|
{
|
|
node.isBridgeEnd = isBridgeEnd;
|
|
node.BridgeToggleEnd();
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
if (node.CanSplinate())
|
|
{
|
|
UpdateSplineObjects();
|
|
UpdateEdgeObjects();
|
|
}
|
|
|
|
EditorUtility.SetDirty(target);
|
|
}
|
|
}
|
|
|
|
|
|
private void OnSelectionChanged()
|
|
{
|
|
Repaint();
|
|
}
|
|
|
|
|
|
private void DoExtAndEdgeOverview()
|
|
{
|
|
EditorGUILayout.LabelField("Extrusion & edge objects", EditorStyles.boldLabel);
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField("");
|
|
|
|
if (GUILayout.Button("Save group", EditorStyles.miniButton, GUILayout.Width(108f)) || GUILayout.Button(saveButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
SaveWindow saveWindow = EditorWindow.GetWindow<SaveWindow>();
|
|
if (node.isBridge)
|
|
// Todo: needs to be updated, currently only saves groups as bridges?!
|
|
{
|
|
saveWindow.Initialize(ref sceneRect, SaveWindow.WindowTypeEnum.BridgeWizard, node);
|
|
}
|
|
else
|
|
{
|
|
saveWindow.Initialize(ref sceneRect, SaveWindow.WindowTypeEnum.BridgeWizard, node);
|
|
}
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
GUILayout.Space(4f);
|
|
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField("");
|
|
if (GUILayout.Button("Open Wizard", loadButton, GUILayout.Width(128f)))
|
|
{
|
|
// || GUILayout.Button(btnLoadText,GSDImageButton,GUILayout.Width(16f))){
|
|
Wizard wizard = EditorWindow.GetWindow<Wizard>();
|
|
if (sceneRect.x < 0)
|
|
{
|
|
sceneRect.x = 0f;
|
|
}
|
|
if (sceneRect.y < 0)
|
|
{
|
|
sceneRect.y = 0f;
|
|
}
|
|
wizard.rect = sceneRect;
|
|
if (node.isBridgeStart)
|
|
{
|
|
wizard.Initialize(Wizard.WindowTypeEnum.BridgeComplete, node);
|
|
}
|
|
else
|
|
{
|
|
wizard.Initialize(Wizard.WindowTypeEnum.Extrusion, node);
|
|
}
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
|
|
GUILayout.Space(4f);
|
|
isEdgeObjectHelp = EditorGUILayout.Foldout(isEdgeObjectHelp, "Quick help");
|
|
if (isEdgeObjectHelp)
|
|
{
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Button(extrudeButtonTexture, imageButton, GUILayout.Width(32f));
|
|
EditorGUILayout.LabelField("= Extrusion objects", EditorStyles.miniLabel);
|
|
EditorGUILayout.LabelField("");
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.LabelField("Railings, bridge pieces, center dividers and other connected objects.", EditorStyles.miniLabel);
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Button(edgeButtonTexture, imageButton, GUILayout.Width(32f));
|
|
EditorGUILayout.LabelField("= Edge objects", EditorStyles.miniLabel);
|
|
EditorGUILayout.LabelField("");
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.LabelField("Signs, street lights, bridge pillars and other unconnected road objects.", EditorStyles.miniLabel);
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Button(saveButtonTexture, imageButton, GUILayout.Width(16f));
|
|
EditorGUILayout.LabelField("= Saves object config to library for use on other nodes.", EditorStyles.miniLabel);
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Button(copyButtonTexture, imageButton, GUILayout.Width(16f));
|
|
EditorGUILayout.LabelField("= Duplicates object onto current node.", EditorStyles.miniLabel);
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Button(deleteButtonTexture, imageButton, GUILayout.Width(16f));
|
|
EditorGUILayout.LabelField("= Deletes object.", EditorStyles.miniLabel);
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Button(refreshButtonTexture, imageButton, GUILayout.Width(16f));
|
|
EditorGUILayout.LabelField("= Refreshes object.", EditorStyles.miniLabel);
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f));
|
|
EditorGUILayout.LabelField("= Resets setting(s) to default.", EditorStyles.miniLabel);
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorUtilities.DrawLine();
|
|
}
|
|
GUILayout.Space(4f);
|
|
|
|
if (node.CanSplinate())
|
|
{
|
|
DoSplineObjects();
|
|
DoEdgeObjects();
|
|
}
|
|
|
|
GUILayout.Space(4f);
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField("");
|
|
if (GUILayout.Button("Add custom extrusion object", EditorStyles.miniButton))
|
|
{
|
|
node.AddSplinatedObject();
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
GUILayout.Space(4f);
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField("");
|
|
if (GUILayout.Button("Add custom edge object", EditorStyles.miniButton))
|
|
{
|
|
node.AddEdgeObject();
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField("");
|
|
isRemovingAll = EditorGUILayout.Toggle(isRemovingAll, GUILayout.Width(20f));
|
|
if (GUILayout.Button("Remove all", EditorStyles.miniButton, GUILayout.Width(100f)))
|
|
{
|
|
if (isRemovingAll)
|
|
{
|
|
node.RemoveAllSplinatedObjects();
|
|
node.RemoveAllEdgeObjects();
|
|
isRemovingAll = false;
|
|
}
|
|
}
|
|
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorUtilities.DrawLine();
|
|
}
|
|
|
|
|
|
private void DoStats()
|
|
{
|
|
EditorGUILayout.LabelField("Statistics:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.LabelField("Grade to next node: " + node.gradeToNext);
|
|
EditorGUILayout.LabelField("Grade to prev node: " + node.gradeToPrev);
|
|
EditorGUILayout.LabelField("Distance from start: " + node.dist.ToString("F3") + " meters");
|
|
EditorGUILayout.LabelField("% of spline: " + ((node.dist / node.spline.distance) * 100f).ToString("F2") + "%");
|
|
EditorGUILayout.LabelField("Parameter: " + node.time);
|
|
EditorGUILayout.LabelField("Tangent: " + node.tangent);
|
|
EditorGUILayout.LabelField("POS: " + node.pos);
|
|
EditorGUILayout.LabelField("ID on spline: " + node.idOnSpline);
|
|
EditorGUILayout.LabelField("Is intersection node: " + node.isIntersection);
|
|
EditorGUILayout.LabelField("Is end node: " + node.isEndPoint);
|
|
EditorGUILayout.LabelField("Is bridge start: " + node.isBridgeStart);
|
|
EditorGUILayout.LabelField("Is bridge end: " + node.isBridgeEnd);
|
|
EditorGUILayout.LabelField("Road: " + node.spline.road.transform.name);
|
|
EditorGUILayout.LabelField("System: " + node.spline.road.roadSystem.transform.name);
|
|
EditorGUILayout.SelectableLabel("UID: " + node.uID);
|
|
}
|
|
|
|
|
|
public void DoSplineObjects()
|
|
{
|
|
if (node.SplinatedObjects == null)
|
|
{
|
|
node.SplinatedObjects = new List<Splination.SplinatedMeshMaker>();
|
|
}
|
|
count = node.SplinatedObjects.Count;
|
|
|
|
SMM = null;
|
|
count = node.SplinatedObjects.Count;
|
|
if (count == 0)
|
|
{
|
|
|
|
}
|
|
|
|
currentCount = 0;
|
|
for (int index = 0; index < node.SplinatedObjects.Count; index++)
|
|
{
|
|
currentCount += 1;
|
|
SMM = node.SplinatedObjects[index];
|
|
|
|
//RoadArchitect.Splination.AxisTypeEnum tAxisTypeSpline = RoadArchitect.Splination.AxisTypeEnum.Z;
|
|
EditorGUILayout.BeginVertical("TextArea");
|
|
|
|
if (SMM.isRequiringUpdate)
|
|
{
|
|
SMM.Setup(true);
|
|
}
|
|
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
|
|
SMM.isToggled = EditorGUILayout.Foldout(SMM.isToggled, "#" + currentCount.ToString() + ": " + SMM.objectName);
|
|
|
|
GUILayout.Button(extrudeButtonTexture, imageButton, GUILayout.Width(32f));
|
|
if (GUILayout.Button(refreshButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
SMM.Setup();
|
|
}
|
|
if (GUILayout.Button(saveButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
SaveWindow saveDialog = EditorWindow.GetWindow<SaveWindow>();
|
|
saveDialog.Initialize(ref sceneRect, SaveWindow.WindowTypeEnum.Extrusion, node, SMM);
|
|
}
|
|
if (GUILayout.Button(copyButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
Undo.RecordObject(node, "Copy");
|
|
node.CopySplinatedObject(ref SMM);
|
|
EditorUtility.SetDirty(node);
|
|
}
|
|
if (GUILayout.Button(deleteButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
Undo.RecordObject(node, "Delete");
|
|
node.RemoveSplinatedObject(index);
|
|
EditorUtility.SetDirty(node);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
if (!SMM.isToggled)
|
|
{
|
|
EditorGUILayout.EndVertical();
|
|
continue;
|
|
}
|
|
|
|
GUILayout.Space(8f);
|
|
EditorGUILayout.LabelField("General options:");
|
|
|
|
EditorGUILayout.BeginVertical("box");
|
|
//Name:
|
|
SMM.objectName = EditorGUILayout.TextField("Name:", SMM.objectName);
|
|
|
|
//Game object (prefab):
|
|
SMM.currentSplination = (GameObject)EditorGUILayout.ObjectField("Prefab:", SMM.currentSplination, typeof(GameObject), false);
|
|
|
|
//Game object (prefab start cap):
|
|
SMM.currentSplinationCap1 = (GameObject)EditorGUILayout.ObjectField("Prefab start cap:", SMM.currentSplinationCap1, typeof(GameObject), false);
|
|
//Prefab start cap height offset:
|
|
if (SMM.currentSplinationCap1 != null)
|
|
{
|
|
SMM.capHeightOffset1 = EditorGUILayout.FloatField(" Height offset:", SMM.capHeightOffset1);
|
|
}
|
|
|
|
//Game object (prefab end cap):
|
|
SMM.currentSplinationCap2 = (GameObject)EditorGUILayout.ObjectField("Prefab end cap:", SMM.currentSplinationCap2, typeof(GameObject), false);
|
|
//Prefab end cap height offset:
|
|
if (SMM.currentSplinationCap2 != null)
|
|
{
|
|
SMM.capHeightOffset2 = EditorGUILayout.FloatField(" Height offset:", SMM.capHeightOffset2);
|
|
}
|
|
|
|
//Material overrides:
|
|
SMM.isMaterialOverriden = EditorGUILayout.Toggle("Material override: ", SMM.isMaterialOverriden);
|
|
if (SMM.isMaterialOverriden)
|
|
{
|
|
SMM.SplinatedMaterial1 = (Material)EditorGUILayout.ObjectField("Override mat #1: ", SMM.SplinatedMaterial1, typeof(Material), false);
|
|
SMM.SplinatedMaterial2 = (Material)EditorGUILayout.ObjectField("Override mat #2: ", SMM.SplinatedMaterial2, typeof(Material), false);
|
|
}
|
|
|
|
//Axis:
|
|
SMM.Axis = (Splination.AxisTypeEnum)EditorGUILayout.Popup("Extrusion axis: ", (int)SMM.Axis, TheAxisDescriptionsSpline, GUILayout.Width(250f));
|
|
|
|
//Start time:
|
|
if (SMM.StartTime < node.minSplination)
|
|
{
|
|
SMM.StartTime = node.minSplination;
|
|
}
|
|
if (SMM.EndTime > node.maxSplination)
|
|
{
|
|
SMM.EndTime = node.maxSplination;
|
|
}
|
|
EditorGUILayout.BeginHorizontal();
|
|
|
|
SMM.StartTime = EditorGUILayout.Slider("Start param: ", SMM.StartTime, node.minSplination, node.maxSplination - 0.01f);
|
|
if (GUILayout.Button("match node", EditorStyles.miniButton, GUILayout.Width(80f)))
|
|
{
|
|
SMM.StartTime = node.time;
|
|
}
|
|
if (SMM.StartTime >= SMM.EndTime)
|
|
{
|
|
SMM.EndTime = (SMM.StartTime + 0.01f);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
|
|
//End time:
|
|
EditorGUILayout.BeginHorizontal();
|
|
SMM.EndTime = EditorGUILayout.Slider("End param: ", SMM.EndTime, SMM.StartTime, node.maxSplination);
|
|
if (GUILayout.Button("match next", EditorStyles.miniButton, GUILayout.Width(80f)))
|
|
{
|
|
SMM.EndTime = node.nextTime;
|
|
}
|
|
if (SMM.StartTime >= SMM.EndTime)
|
|
{
|
|
SMM.EndTime = (SMM.StartTime + 0.01f);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
|
|
//Straight line options:
|
|
if (node.IsStraight())
|
|
{
|
|
EditorGUILayout.BeginVertical("box");
|
|
SMM.isStretched = EditorGUILayout.Toggle("Straight line stretch:", SMM.isStretched);
|
|
if (SMM.isStretched)
|
|
{
|
|
//Stretch_UVThreshold:
|
|
SMM.stretchUVThreshold = EditorGUILayout.Slider("UV stretch threshold:", SMM.stretchUVThreshold, 0.01f, 0.5f);
|
|
//UV repeats:
|
|
SMM.RepeatUVType = (Splination.RepeatUVTypeEnum)EditorGUILayout.Popup("UV stretch axis: ", (int)SMM.RepeatUVType, RepeatUVTypeDescriptionsSpline, GUILayout.Width(250f));
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
else
|
|
{
|
|
SMM.isStretched = false;
|
|
}
|
|
|
|
SMM.isTrimStart = EditorGUILayout.Toggle("Trim start:", SMM.isTrimStart);
|
|
SMM.isTrimEnd = EditorGUILayout.Toggle("Trim end:", SMM.isTrimEnd);
|
|
|
|
//Static option:
|
|
SMM.isStatic = EditorGUILayout.Toggle("Static: ", SMM.isStatic);
|
|
|
|
//Splination method
|
|
// SMM.EM.bMatchRoadIncrements = EditorGUILayout.Toggle("Match road increments: ",SMM.bMatchRoadIncrements);
|
|
SMM.isMatchingTerrain = EditorGUILayout.Toggle("Match ground: ", SMM.isMatchingTerrain);
|
|
|
|
//Vector min/max threshold:
|
|
EditorGUILayout.BeginHorizontal();
|
|
SMM.minMaxMod = EditorGUILayout.Slider("Vertex min/max threshold: ", SMM.minMaxMod, 0.01f, 0.2f);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
SMM.minMaxMod = 0.05f;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
//Vertex matching precision:
|
|
EditorGUILayout.BeginHorizontal();
|
|
SMM.vertexMatchingPrecision = EditorGUILayout.Slider("Vertex matching precision: ", SMM.vertexMatchingPrecision, 0f, 0.01f);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
SMM.vertexMatchingPrecision = 0.005f;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
//UV repeats:
|
|
if (!SMM.isStretched)
|
|
{
|
|
SMM.RepeatUVType = (Splination.RepeatUVTypeEnum)EditorGUILayout.Popup("UV repeat axis: ", (int)SMM.RepeatUVType, RepeatUVTypeDescriptionsSpline, GUILayout.Width(250f));
|
|
}
|
|
|
|
if (SMM.isMatchingRoadDefinition)
|
|
{
|
|
EditorGUILayout.BeginVertical("TextArea");
|
|
EditorGUILayout.BeginHorizontal();
|
|
SMM.isMatchingRoadDefinition = EditorGUILayout.Toggle("Match road definition: ", SMM.isMatchingRoadDefinition);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
SMM.isMatchingRoadDefinition = false;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
if (SMM.isMatchingRoadDefinition)
|
|
{
|
|
EditorGUILayout.LabelField(" Only use this option if object length doesn't match the road definition.", EditorStyles.miniLabel);
|
|
EditorGUILayout.LabelField(" Matching road definition requires a UV repeat type.", EditorStyles.miniLabel);
|
|
EditorGUILayout.LabelField(" If the material fails to scale properly, try flipping the Y rotation.", EditorStyles.miniLabel);
|
|
}
|
|
//Flip rotation option:
|
|
SMM.isFlippingRotation = EditorGUILayout.Toggle(" Flip Y rotation: ", SMM.isFlippingRotation);
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
else
|
|
{
|
|
EditorGUILayout.BeginHorizontal();
|
|
SMM.isMatchingRoadDefinition = EditorGUILayout.Toggle("Match road definition: ", SMM.isMatchingRoadDefinition);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
SMM.isMatchingRoadDefinition = false;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
|
|
#region "Vertical offset"
|
|
EditorGUILayout.LabelField("Vertical options:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.BeginHorizontal();
|
|
SMM.verticalRaise = EditorGUILayout.Slider("Vertical raise magnitude:", SMM.verticalRaise, -512f, 512f);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
SMM.verticalRaise = 0f;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
#endregion
|
|
|
|
|
|
#region "Vertical curve"
|
|
if (SMM.verticalCurve == null || SMM.verticalCurve.keys.Length < 2)
|
|
{
|
|
EnforceCurve(ref SMM.verticalCurve);
|
|
}
|
|
EditorGUILayout.BeginHorizontal();
|
|
SMM.verticalCurve = EditorGUILayout.CurveField("Curve: ", SMM.verticalCurve);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
ResetCurve(ref SMM.verticalCurve);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
#endregion
|
|
EditorGUILayout.EndVertical();
|
|
|
|
|
|
#region "Horizontal offsets"
|
|
EditorGUILayout.LabelField("Horizontal offset options:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
horizMatching = HorizMatchingDefaultsEnum.None;
|
|
horizMatching = (HorizMatchingDefaultsEnum)EditorGUILayout.Popup((int)horizMatching, HorizMatchSubTypeDescriptions, GUILayout.Width(100f));
|
|
if (horizMatching != HorizMatchingDefaultsEnum.None)
|
|
{
|
|
if (horizMatching == HorizMatchingDefaultsEnum.MatchCenter)
|
|
{
|
|
SMM.horizontalSep = 0f;
|
|
}
|
|
else if (horizMatching == HorizMatchingDefaultsEnum.MatchRoadLeft)
|
|
{
|
|
SMM.horizontalSep = (node.spline.road.RoadWidth() / 2) * -1;
|
|
}
|
|
else if (horizMatching == HorizMatchingDefaultsEnum.MatchShoulderLeft)
|
|
{
|
|
SMM.horizontalSep = ((node.spline.road.RoadWidth() / 2) + node.spline.road.shoulderWidth) * -1;
|
|
}
|
|
else if (horizMatching == HorizMatchingDefaultsEnum.MatchRoadRight)
|
|
{
|
|
SMM.horizontalSep = (node.spline.road.RoadWidth() / 2);
|
|
}
|
|
else if (horizMatching == HorizMatchingDefaultsEnum.MatchShoulderRight)
|
|
{
|
|
SMM.horizontalSep = (node.spline.road.RoadWidth() / 2) + node.spline.road.shoulderWidth;
|
|
}
|
|
horizMatching = HorizMatchingDefaultsEnum.None;
|
|
}
|
|
EditorGUILayout.BeginHorizontal();
|
|
SMM.horizontalSep = EditorGUILayout.Slider("Horiz offset magnitude:", SMM.horizontalSep, (-1f * horizRoadMax), horizRoadMax);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
SMM.horizontalSep = 0f;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
#endregion
|
|
|
|
|
|
//Horizontal curve:
|
|
if (SMM.horizontalCurve == null || SMM.horizontalCurve.keys.Length < 2)
|
|
{
|
|
EnforceCurve(ref SMM.horizontalCurve);
|
|
}
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
SMM.horizontalCurve = EditorGUILayout.CurveField("Curve: ", SMM.horizontalCurve);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
ResetCurve(ref SMM.horizontalCurve);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.EndVertical();
|
|
|
|
//Vertical cutoff:
|
|
EditorGUILayout.LabelField("Vertical cutoff:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
SMM.isVerticalCutoff = EditorGUILayout.Toggle("Height cutoff enabled:", SMM.isVerticalCutoff);
|
|
if (SMM.isVerticalCutoff)
|
|
{
|
|
SMM.isVerticalCutoffMatchingZero = EditorGUILayout.Toggle("Match spline height:", SMM.isVerticalCutoffMatchingZero);
|
|
SMM.isVerticalCutoffDownwards = EditorGUILayout.Toggle("Cut direction toggle:", SMM.isVerticalCutoffDownwards);
|
|
SMM.VerticalCutoff = EditorGUILayout.Slider("Height cut offset: ", SMM.VerticalCutoff, -50f, 50f);
|
|
SMM.isVerticalMeshCutoffOppositeDir = EditorGUILayout.Toggle("Opposite dir mesh cut:", SMM.isVerticalMeshCutoffOppositeDir);
|
|
SMM.VerticalMeshCutoffOffset = EditorGUILayout.Slider("Mesh cut offset: ", SMM.VerticalMeshCutoffOffset, -5f, 5f);
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
//End type:
|
|
EditorGUILayout.LabelField("Extrusion ending options:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
SMM.isStartDown = EditorGUILayout.Toggle("Push start down:", SMM.isStartDown);
|
|
SMM.isEndDown = EditorGUILayout.Toggle("Push end down:", SMM.isEndDown);
|
|
if (SMM.isStartDown)
|
|
{
|
|
SMM.isStartTypeDownOverriden = EditorGUILayout.Toggle("Override start down value: ", SMM.isStartTypeDownOverriden);
|
|
if (SMM.isStartTypeDownOverriden)
|
|
{
|
|
SMM.startTypeDownOverride = EditorGUILayout.Slider("Downward movement: ", SMM.startTypeDownOverride, -10f, 10f);
|
|
}
|
|
}
|
|
if (SMM.isEndDown)
|
|
{
|
|
SMM.isEndTypeDownOverriden = EditorGUILayout.Toggle("Override end down value: ", SMM.isEndTypeDownOverriden);
|
|
if (SMM.isEndTypeDownOverriden)
|
|
{
|
|
SMM.endTypeDownOverride = EditorGUILayout.Slider("Downward movement: ", SMM.endTypeDownOverride, -10f, 10f);
|
|
}
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
//Start and end objects:
|
|
EditorGUILayout.LabelField("Start & end objects:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
//End cap custom match start:
|
|
SMM.isEndCapCustomMatchStart = EditorGUILayout.Toggle("Match objects to ends:", SMM.isEndCapCustomMatchStart);
|
|
|
|
//End objects match ground:
|
|
SMM.isEndObjectsMatchingGround = EditorGUILayout.Toggle("Force origins to ground:", SMM.isEndObjectsMatchingGround);
|
|
|
|
//Start cap:
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField("Start object:");
|
|
endObjectAdd = (EndObjectsDefaultsEnum)EditorGUILayout.Popup((int)endObjectAdd, EndObjectsDefaultsEnumDesc);
|
|
if (endObjectAdd != EndObjectsDefaultsEnum.None)
|
|
{
|
|
SMM.EndCapStart = GetEndObjectQuickAdd();
|
|
endObjectAdd = EndObjectsDefaultsEnum.None;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
|
|
SMM.EndCapStart = (GameObject)EditorGUILayout.ObjectField("Prefab:", SMM.EndCapStart, typeof(GameObject), false);
|
|
if (SMM.EndCapStart != null)
|
|
{
|
|
SMM.EndCapCustomOffsetStart = EditorGUILayout.Vector3Field("Position offset:", SMM.EndCapCustomOffsetStart);
|
|
SMM.EndCapCustomRotOffsetStart = EditorGUILayout.Vector3Field("Rotation offset:", SMM.EndCapCustomRotOffsetStart);
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
//End cap:
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField("End object:");
|
|
endObjectAdd = (EndObjectsDefaultsEnum)EditorGUILayout.Popup((int)endObjectAdd, EndObjectsDefaultsEnumDesc);
|
|
if (endObjectAdd != EndObjectsDefaultsEnum.None)
|
|
{
|
|
SMM.EndCapEnd = GetEndObjectQuickAdd();
|
|
SMM.EndCapCustomRotOffsetEnd = new Vector3(0f, 180f, 0f);
|
|
endObjectAdd = EndObjectsDefaultsEnum.None;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
|
|
SMM.EndCapEnd = (GameObject)EditorGUILayout.ObjectField("Prefab:", SMM.EndCapEnd, typeof(GameObject), false);
|
|
if (SMM.EndCapEnd != null)
|
|
{
|
|
SMM.EndCapCustomOffsetEnd = EditorGUILayout.Vector3Field("Position offset:", SMM.EndCapCustomOffsetEnd);
|
|
SMM.EndCapCustomRotOffsetEnd = EditorGUILayout.Vector3Field("Rotation offset:", SMM.EndCapCustomRotOffsetEnd);
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorGUILayout.EndVertical();
|
|
|
|
//Collision:
|
|
EditorGUILayout.LabelField("Collision options:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
SMM.CollisionType = (Splination.CollisionTypeEnum)EditorGUILayout.Popup("Collision type: ", (int)SMM.CollisionType, TheCollisionTypeEnumDescSpline, GUILayout.Width(320f));
|
|
//Mesh collison convex option
|
|
if (SMM.CollisionType != Splination.CollisionTypeEnum.None && SMM.CollisionType != Splination.CollisionTypeEnum.BoxCollision)
|
|
{
|
|
SMM.isCollisionConvex = EditorGUILayout.Toggle(" Convex: ", SMM.isCollisionConvex);
|
|
SMM.isCollisionTrigger = EditorGUILayout.Toggle(" Trigger: ", SMM.isCollisionTrigger);
|
|
}
|
|
|
|
if (SMM.CollisionType == Splination.CollisionTypeEnum.SimpleMeshTriangle || SMM.CollisionType == Splination.CollisionTypeEnum.SimpleMeshTrapezoid)
|
|
{
|
|
SMM.isSimpleCollisionAutomatic = EditorGUILayout.Toggle(" Automatic simple collision: ", SMM.isSimpleCollisionAutomatic);
|
|
}
|
|
//If not automatic simple collisions:
|
|
if (!SMM.isSimpleCollisionAutomatic)
|
|
{
|
|
if (SMM.CollisionType == Splination.CollisionTypeEnum.SimpleMeshTriangle)
|
|
{
|
|
EditorGUILayout.LabelField("Bottom left:");
|
|
SMM.CollisionTriBL.x = EditorGUILayout.Slider(" x-axis: ", SMM.CollisionTriBL.x, SMM.mMinX - 5f, SMM.mMaxX + 5f);
|
|
SMM.CollisionTriBL.y = EditorGUILayout.Slider(" y-axis: ", SMM.CollisionTriBL.y, SMM.mMinY - 5f, SMM.mMaxY + 5f);
|
|
SMM.CollisionTriBL.z = EditorGUILayout.Slider(" z-axis: ", SMM.CollisionTriBL.z, SMM.mMinZ - 5f, SMM.mMaxZ + 5f);
|
|
|
|
EditorGUILayout.LabelField("Bottom right:");
|
|
SMM.CollisionTriBR.x = EditorGUILayout.Slider(" x-axis: ", SMM.CollisionTriBR.x, SMM.mMinX - 5f, SMM.mMaxX + 5f);
|
|
SMM.CollisionTriBR.y = EditorGUILayout.Slider(" y-axis: ", SMM.CollisionTriBR.y, SMM.mMinY - 5f, SMM.mMaxY + 5f);
|
|
SMM.CollisionTriBR.z = EditorGUILayout.Slider(" z-axis: ", SMM.CollisionTriBR.z, SMM.mMinZ - 5f, SMM.mMaxZ + 5f);
|
|
|
|
EditorGUILayout.LabelField("Top:");
|
|
SMM.CollisionTriT.x = EditorGUILayout.Slider(" x-axis: ", SMM.CollisionTriT.x, SMM.mMinX - 5f, SMM.mMaxX + 5f);
|
|
SMM.CollisionTriT.y = EditorGUILayout.Slider(" y-axis: ", SMM.CollisionTriT.y, SMM.mMinY - 5f, SMM.mMaxY + 5f);
|
|
SMM.CollisionTriT.z = EditorGUILayout.Slider(" z-axis: ", SMM.CollisionTriT.z, SMM.mMinZ - 5f, SMM.mMaxZ + 5f);
|
|
|
|
}
|
|
else if (SMM.CollisionType == Splination.CollisionTypeEnum.SimpleMeshTrapezoid)
|
|
{
|
|
SMM.CollisionBoxBL = EditorGUILayout.Vector3Field(" Bottom left:", SMM.CollisionBoxBL);
|
|
SMM.CollisionBoxBR = EditorGUILayout.Vector3Field(" Bottom right:", SMM.CollisionBoxBR);
|
|
SMM.CollisionBoxTL = EditorGUILayout.Vector3Field(" Top left:", SMM.CollisionBoxTL);
|
|
SMM.CollisionBoxTR = EditorGUILayout.Vector3Field(" Top right:", SMM.CollisionBoxTR);
|
|
}
|
|
}
|
|
|
|
if (SMM.CollisionType == Splination.CollisionTypeEnum.BoxCollision)
|
|
{
|
|
SMM.boxColliderOffset = EditorGUILayout.Vector3Field("Box collider center offset:", SMM.boxColliderOffset);
|
|
SMM.isBoxColliderFlippedOnX = EditorGUILayout.Toggle("Flip center X:", SMM.isBoxColliderFlippedOnX);
|
|
SMM.isBoxColliderFlippedOnZ = EditorGUILayout.Toggle("Flip center Z:", SMM.isBoxColliderFlippedOnZ);
|
|
|
|
|
|
SMM.isStretchedSize = EditorGUILayout.Toggle("Box collider size edit:", SMM.isStretchedSize);
|
|
if (SMM.isStretchedSize)
|
|
{
|
|
SMM.boxColliderSize = EditorGUILayout.Vector3Field("Size:", SMM.boxColliderSize);
|
|
}
|
|
else
|
|
{
|
|
EditorGUILayout.LabelField("Size:", SMM.boxColliderSize.ToString());
|
|
}
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
|
|
EditorGUILayout.LabelField("Rotation options:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
|
|
//Custom rotation:
|
|
//EOM.CustomRotation = EditorGUILayout.Vector3Field("Custom rotation: ",EOM.CustomRotation);
|
|
EditorGUILayout.BeginHorizontal();
|
|
//Flip rotation option:
|
|
SMM.isFlippingRotation = EditorGUILayout.Toggle("Flip Y rotation: ", SMM.isFlippingRotation);
|
|
|
|
|
|
//if(GUILayout.Button("Reset custom rotation",EditorStyles.miniButton,GUILayout.Width(160f))){
|
|
// SMM.CustomRotation = new Vector3(0f,0f,0f);
|
|
//}
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
SMM.CustomRotation = new Vector3(0f, 0f, 0f);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
//SMM.CustomRotation = EditorGUILayout.Vector3Field("",SMM.CustomRotation);
|
|
//SMM.CustomRotation.x = EditorGUILayout.Slider("x-axis: ",SMM.CustomRotation.x,-360f,360f);
|
|
//SMM.CustomRotation.y = EditorGUILayout.Slider("y-axis: ",SMM.CustomRotation.y,-360f,360f);
|
|
//SMM.CustomRotation.z = EditorGUILayout.Slider("z-axis: ",SMM.CustomRotation.z,-360f,360f);
|
|
EditorGUILayout.EndVertical();
|
|
EditorGUILayout.EndVertical();
|
|
|
|
|
|
EditorGUILayout.LabelField("Deprecated options:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
SMM.isExactSplination = EditorGUILayout.Toggle("Directional extrusion: ", SMM.isExactSplination);
|
|
|
|
EditorGUILayout.EndVertical();
|
|
// Big Lines
|
|
EditorUtilities.DrawLine(4f, 4f);
|
|
EditorUtilities.DrawLine(4f, 4f);
|
|
}
|
|
}
|
|
|
|
|
|
public void UpdateSplineObjects()
|
|
{
|
|
if (node.SplinatedObjects == null)
|
|
{
|
|
node.SplinatedObjects = new List<Splination.SplinatedMeshMaker>();
|
|
}
|
|
count = node.SplinatedObjects.Count;
|
|
for (int index = 0; index < count; index++)
|
|
{
|
|
SMM = node.SplinatedObjects[index];
|
|
|
|
SMM.UpdatePositions();
|
|
if (SMM.isStretched)
|
|
{
|
|
SMM.CollisionType = Splination.CollisionTypeEnum.BoxCollision;
|
|
SMM.isMatchingRoadDefinition = false;
|
|
SMM.isMatchingTerrain = false;
|
|
SMM.isCollisionConvex = false;
|
|
SMM.isStartDown = false;
|
|
SMM.isEndDown = false;
|
|
SMM.isVerticalCutoff = false;
|
|
SMM.isExactSplination = false;
|
|
SMM.isEndTypeDownOverriden = false;
|
|
}
|
|
|
|
SMM.Setup(true);
|
|
}
|
|
}
|
|
|
|
|
|
public void UpdateSplineObjectsOnUndo()
|
|
{
|
|
if (!node.CanSplinate())
|
|
{
|
|
return;
|
|
}
|
|
if (node.SplinatedObjects == null)
|
|
{
|
|
node.SplinatedObjects = new List<Splination.SplinatedMeshMaker>();
|
|
}
|
|
|
|
//Destroy all children:
|
|
for (int index = node.transform.childCount - 1; index >= 0; index--)
|
|
{
|
|
Object.DestroyImmediate(node.transform.GetChild(index).gameObject);
|
|
}
|
|
|
|
//Re-setup the SMM:
|
|
count = node.SplinatedObjects.Count;
|
|
for (int index = 0; index < count; index++)
|
|
{
|
|
SMM = node.SplinatedObjects[index];
|
|
SMM.UpdatePositions();
|
|
if (SMM.isStretched)
|
|
{
|
|
SMM.CollisionType = Splination.CollisionTypeEnum.BoxCollision;
|
|
SMM.isMatchingRoadDefinition = false;
|
|
SMM.isMatchingTerrain = false;
|
|
SMM.isCollisionConvex = false;
|
|
SMM.isStartDown = false;
|
|
SMM.isEndDown = false;
|
|
SMM.isVerticalCutoff = false;
|
|
SMM.isExactSplination = false;
|
|
SMM.isEndTypeDownOverriden = false;
|
|
}
|
|
|
|
SMM.Setup(true);
|
|
}
|
|
|
|
UpdateEdgeObjectsOnUndo();
|
|
}
|
|
|
|
|
|
/// <summary> Renders the EdgeObject items in the Editor </summary>
|
|
public void DoEdgeObjects()
|
|
{
|
|
if (node.EdgeObjects == null)
|
|
{
|
|
node.EdgeObjects = new List<EdgeObjects.EdgeObjectMaker>();
|
|
}
|
|
count = node.EdgeObjects.Count;
|
|
|
|
EOM = null;
|
|
|
|
for (int index = 0; index < node.EdgeObjects.Count; index++)
|
|
{
|
|
EOM = node.EdgeObjects[index];
|
|
|
|
currentCount += 1;
|
|
EditorGUILayout.BeginVertical("TextArea");
|
|
|
|
if (EOM.isRequiringUpdate)
|
|
{
|
|
EOM.Setup();
|
|
}
|
|
EOM.isRequiringUpdate = false;
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
|
|
EOM.isToggled = EditorGUILayout.Foldout(EOM.isToggled, "#" + currentCount.ToString() + ": " + EOM.objectName);
|
|
|
|
GUILayout.Button(edgeButtonTexture, imageButton, GUILayout.Width(32f));
|
|
if (GUILayout.Button(refreshButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
EOM.Setup();
|
|
}
|
|
if (GUILayout.Button(saveButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
SaveWindow saveWindow = EditorWindow.GetWindow<SaveWindow>();
|
|
saveWindow.Initialize(ref sceneRect, SaveWindow.WindowTypeEnum.Edge, node, null, EOM);
|
|
}
|
|
|
|
if (GUILayout.Button(copyButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
Undo.RecordObject(node, "Copy");
|
|
node.CopyEdgeObject(index);
|
|
EditorUtility.SetDirty(node);
|
|
}
|
|
if (GUILayout.Button(deleteButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
Undo.RecordObject(node, "Delete");
|
|
node.RemoveEdgeObject(index);
|
|
EditorUtility.SetDirty(node);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
if (!EOM.isToggled)
|
|
{
|
|
EditorGUILayout.EndVertical();
|
|
continue;
|
|
}
|
|
|
|
GUILayout.Space(8f);
|
|
EditorGUILayout.LabelField("General options:");
|
|
|
|
EditorGUILayout.BeginVertical("box");
|
|
//Name:
|
|
EOM.objectName = EditorGUILayout.TextField("Name: ", EOM.objectName);
|
|
|
|
//Edge object:
|
|
EOM.edgeObject = (GameObject)EditorGUILayout.ObjectField("Edge object: ", EOM.edgeObject, typeof(GameObject), false);
|
|
|
|
#region "Material override"
|
|
EOM.isMaterialOverriden = EditorGUILayout.Toggle("Material override: ", EOM.isMaterialOverriden);
|
|
if (!EOM.isMaterialOverriden)
|
|
{
|
|
EOM.edgeMaterial1 = null;
|
|
EOM.edgeMaterial2 = null;
|
|
}
|
|
|
|
if (EOM.isMaterialOverriden)
|
|
{
|
|
EOM.edgeMaterial1 = (Material)EditorGUILayout.ObjectField("Override mat #1: ", EOM.edgeMaterial1, typeof(Material), false);
|
|
EOM.edgeMaterial2 = (Material)EditorGUILayout.ObjectField("Override mat #2: ", EOM.edgeMaterial2, typeof(Material), false);
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region "Combine Mesh / MeshCollider"
|
|
if (EOM.isSingle)
|
|
{
|
|
EOM.isCombinedMesh = false;
|
|
}
|
|
else
|
|
{
|
|
EOM.isCombinedMesh = EditorGUILayout.Toggle("Combine meshes: ", EOM.isCombinedMesh);
|
|
|
|
if (EOM.isCombinedMesh)
|
|
{
|
|
EOM.isCombinedMeshCollider = EditorGUILayout.Toggle("Combined mesh collider: ", EOM.isCombinedMeshCollider);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region "SingleObject"
|
|
isSingleTemp = EditorGUILayout.Toggle("Single object only: ", EOM.isSingle);
|
|
if (isSingleTemp != EOM.isSingle)
|
|
{
|
|
EOM.endTime = node.nextTime;
|
|
//EOM.endPos = node.spline.GetSplineValue(EOM.endTime, false);
|
|
EOM.singlePosition = node.time + 0.025f;
|
|
|
|
EOM.isSingle = isSingleTemp;
|
|
|
|
if (EOM.isSingle)
|
|
{
|
|
EOM.isCombinedMesh = false;
|
|
}
|
|
}
|
|
|
|
if (EOM.isSingle)
|
|
{
|
|
EOM.singlePosition = EditorGUILayout.Slider("Single location: ", EOM.singlePosition, node.time, 1f);
|
|
|
|
if (node.isBridgeStart && node.isBridgeMatched)
|
|
{
|
|
EOM.singleOnlyBridgePercent = EditorGUILayout.Slider("Bridge %: ", EOM.singleOnlyBridgePercent, 0f, 1f);
|
|
float dist = (EOM.singleOnlyBridgePercent * (node.bridgeCounterpartNode.dist - node.dist) + node.dist);
|
|
EOM.singlePosition = node.spline.TranslateDistBasedToParam(dist);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
EOM.isStatic = EditorGUILayout.Toggle("Static: ", EOM.isStatic);
|
|
EOM.isMatchingTerrain = EditorGUILayout.Toggle("Match ground height: ", EOM.isMatchingTerrain);
|
|
|
|
if (!EOM.isSingle)
|
|
{
|
|
EOM.meterSep = EditorGUILayout.Slider("Dist between objects: ", EOM.meterSep, 1f, 256f);
|
|
}
|
|
|
|
|
|
#region "Match Road"
|
|
EOM.isStartMatchRoadDefinition = EditorGUILayout.Toggle("Match road definition: ", EOM.isStartMatchRoadDefinition);
|
|
if (EOM.isStartMatchRoadDefinition)
|
|
{
|
|
EOM.startMatchRoadDef = EditorGUILayout.Slider("Position fine tuning: ", EOM.startMatchRoadDef, 0f, 1f);
|
|
}
|
|
#endregion
|
|
|
|
|
|
// Multi placed edge objects
|
|
if (!EOM.isSingle)
|
|
{
|
|
if (EOM.startTime < node.minSplination)
|
|
{
|
|
EOM.startTime = node.minSplination;
|
|
}
|
|
if (EOM.endTime > node.maxSplination)
|
|
{
|
|
EOM.endTime = node.maxSplination;
|
|
}
|
|
|
|
|
|
#region "Start param"
|
|
EditorGUILayout.BeginHorizontal();
|
|
EOM.startTime = EditorGUILayout.Slider("Start param: ", EOM.startTime, node.minSplination, EOM.endTime);
|
|
|
|
if (EOM.endTime < EOM.startTime)
|
|
{
|
|
EOM.endTime = Mathf.Clamp(EOM.startTime + 0.01f, 0f, 1f);
|
|
}
|
|
|
|
|
|
if (GUILayout.Button("match node", EditorStyles.miniButton, GUILayout.Width(80f)))
|
|
{
|
|
EOM.startTime = node.time;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
#endregion
|
|
|
|
|
|
#region "End param"
|
|
EditorGUILayout.BeginHorizontal();
|
|
EOM.endTime = EditorGUILayout.Slider("End param: ", EOM.endTime, EOM.startTime, node.maxSplination);
|
|
//Mathf.Clamp(EditorGUILayout.Slider( "End param: ", EOM.EndTime, 0f/*EOM.StartTime*/, 1f/*tNode.MaxSplination*/ ), 0f, 1f);
|
|
// FH EXPERIMENTAL fix for EdgeObjects???
|
|
|
|
if (EOM.startTime > EOM.endTime)
|
|
{
|
|
EOM.startTime = Mathf.Clamp(EOM.endTime - 0.01f, 0f, 1f);
|
|
}
|
|
|
|
if (GUILayout.Button("match next", EditorStyles.miniButton, GUILayout.Width(80f)))
|
|
{
|
|
EOM.endTime = node.nextTime;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
#endregion
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
|
|
#region "Vertical offset"
|
|
EditorGUILayout.LabelField("Vertical options:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
EOM.verticalRaise = EditorGUILayout.Slider("Vertical raise magnitude:", EOM.verticalRaise, -512f, 512f);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
EOM.verticalRaise = 0f;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
if (EOM.verticalCurve == null || EOM.verticalCurve.keys.Length < 2)
|
|
{
|
|
EnforceCurve(ref EOM.verticalCurve);
|
|
}
|
|
EditorGUILayout.BeginHorizontal();
|
|
EOM.verticalCurve = EditorGUILayout.CurveField("Curve: ", EOM.verticalCurve);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
ResetCurve(ref EOM.verticalCurve);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.EndVertical();
|
|
#endregion
|
|
|
|
|
|
#region "Horizontal offsets"
|
|
EditorGUILayout.LabelField("Horizontal offset options:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
horizMatching = HorizMatchingDefaultsEnum.None;
|
|
horizMatching = (HorizMatchingDefaultsEnum)EditorGUILayout.Popup((int)horizMatching, HorizMatchSubTypeDescriptions, GUILayout.Width(100f));
|
|
if (horizMatching != HorizMatchingDefaultsEnum.None)
|
|
{
|
|
if (horizMatching == HorizMatchingDefaultsEnum.MatchCenter)
|
|
{
|
|
EOM.horizontalSep = 0f;
|
|
}
|
|
else if (horizMatching == HorizMatchingDefaultsEnum.MatchRoadLeft)
|
|
{
|
|
EOM.horizontalSep = (node.spline.road.RoadWidth() * 0.5f) * -1;
|
|
}
|
|
else if (horizMatching == HorizMatchingDefaultsEnum.MatchShoulderLeft)
|
|
{
|
|
if (node.spline.road.isShouldersEnabled)
|
|
{
|
|
EOM.horizontalSep = ((node.spline.road.RoadWidth() * 0.5f) + node.spline.road.shoulderWidth) * -1;
|
|
}
|
|
else
|
|
{
|
|
EOM.horizontalSep = ((node.spline.road.RoadWidth() * 0.5f)) * -1;
|
|
}
|
|
}
|
|
else if (horizMatching == HorizMatchingDefaultsEnum.MatchRoadRight)
|
|
{
|
|
EOM.horizontalSep = (node.spline.road.RoadWidth() * 0.5f);
|
|
}
|
|
else if (horizMatching == HorizMatchingDefaultsEnum.MatchShoulderRight)
|
|
{
|
|
if (node.spline.road.isShouldersEnabled)
|
|
{
|
|
EOM.horizontalSep = (node.spline.road.RoadWidth() * 0.5f) + node.spline.road.shoulderWidth;
|
|
}
|
|
else
|
|
{
|
|
EOM.horizontalSep = (node.spline.road.RoadWidth() * 0.5f);
|
|
}
|
|
}
|
|
horizMatching = HorizMatchingDefaultsEnum.None;
|
|
}
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
EOM.horizontalSep = EditorGUILayout.Slider("Horiz offset magnitude:", EOM.horizontalSep, (-1f * horizRoadMax), horizRoadMax);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
EOM.horizontalSep = 0f;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
if (EOM.horizontalCurve == null || EOM.horizontalCurve.keys.Length < 2)
|
|
{
|
|
EnforceCurve(ref EOM.horizontalCurve);
|
|
}
|
|
EditorGUILayout.BeginHorizontal();
|
|
EOM.horizontalCurve = EditorGUILayout.CurveField("Curve: ", EOM.horizontalCurve);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
ResetCurve(ref EOM.horizontalCurve);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.EndVertical();
|
|
#endregion
|
|
|
|
|
|
#region "Rotation/scale options"
|
|
EditorGUILayout.LabelField("Rotation/scale options:");
|
|
EditorGUILayout.BeginVertical("box");
|
|
if (EOM.horizontalSep < 0f)
|
|
{
|
|
EOM.isOncomingRotation = EditorGUILayout.Toggle("Auto rotate oncoming objects: ", EOM.isOncomingRotation);
|
|
EOM.subType = SignPlacementSubTypeEnum.Left;
|
|
}
|
|
else
|
|
{
|
|
EOM.subType = SignPlacementSubTypeEnum.Right;
|
|
}
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField("Custom rotation: ");
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
EOM.customRotation = new Vector3(0f, 0f, 0f);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
EOM.customRotation.x = EditorGUILayout.Slider("x-axis: ", EOM.customRotation.x, -360f, 360f);
|
|
EOM.customRotation.y = EditorGUILayout.Slider("y-axis: ", EOM.customRotation.y, -360f, 360f);
|
|
EOM.customRotation.z = EditorGUILayout.Slider("z-axis: ", EOM.customRotation.z, -360f, 360f);
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorGUILayout.BeginVertical();
|
|
EditorGUILayout.LabelField("Lock align rotation: ");
|
|
EOM.isRotationAligning = EditorGUILayout.Toggle("Align objects to road rotation: ", EOM.isRotationAligning);
|
|
if (!EOM.isRotationAligning)
|
|
{
|
|
EOM.isXRotationLocked = EditorGUILayout.Toggle("Lock x axis: ", EOM.isXRotationLocked);
|
|
EOM.isYRotationLocked = EditorGUILayout.Toggle("Lock y axis: ", EOM.isYRotationLocked);
|
|
EOM.isZRotationLocked = EditorGUILayout.Toggle("Lock z axis: ", EOM.isZRotationLocked);
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
EditorGUILayout.BeginVertical("box");
|
|
EditorGUILayout.BeginHorizontal();
|
|
float scale = EditorGUILayout.Slider("Custom scale: ", EOM.customScale.x, 1f, 10f);
|
|
EOM.customScale = new Vector3(scale, scale, scale);
|
|
if (GUILayout.Button(defaultButtonTexture, imageButton, GUILayout.Width(16f)))
|
|
{
|
|
EOM.customScale = new Vector3(1f, 1f, 1f);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.EndVertical();
|
|
EditorGUILayout.EndVertical();
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
|
|
public void UpdateEdgeObjects()
|
|
{
|
|
count = node.EdgeObjects.Count;
|
|
for (int index = 0; index < node.EdgeObjects.Count; index++)
|
|
{
|
|
EOM = node.EdgeObjects[index];
|
|
EOM.UpdatePositions();
|
|
EOM.Setup();
|
|
}
|
|
}
|
|
|
|
|
|
public void UpdateEdgeObjectsOnUndo()
|
|
{
|
|
if (!node.CanSplinate())
|
|
{
|
|
return;
|
|
}
|
|
count = node.EdgeObjects.Count;
|
|
for (int index = 0; index < node.EdgeObjects.Count; index++)
|
|
{
|
|
EOM = node.EdgeObjects[index];
|
|
EOM.Setup();
|
|
}
|
|
}
|
|
|
|
|
|
#region "Quick adds"
|
|
private void BridgeAddTopBase(float _horizSep = 0f, float _vertRaise = -0.01f, string _mat = "", bool _isOverridenPrefab = false, string _overridePrefab = "")
|
|
{
|
|
string basePath = RoadEditorUtility.GetBasePath();
|
|
|
|
if (_mat == "")
|
|
{
|
|
_mat = basePath + "/Materials/Concrete2.mat";
|
|
}
|
|
SMM = node.AddSplinatedObject();
|
|
string tBridgeTopBaseToAdd = "";
|
|
string tName = "";
|
|
if (node.spline.road.laneAmount == 2)
|
|
{
|
|
if (BridgeTopBaseQuickAdd == BridgeTopBaseDefaultsEnum.Base1MOver)
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-19w-5l-1d.fbx";
|
|
tName = "BridgeTop1M-1M";
|
|
}
|
|
else if (BridgeTopBaseQuickAdd == BridgeTopBaseDefaultsEnum.Base2MOver)
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-20w-5l-1d.fbx";
|
|
tName = "BridgeTop2M-1M";
|
|
}
|
|
else if (BridgeTopBaseQuickAdd == BridgeTopBaseDefaultsEnum.Base3MDeep)
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-18w-5l-3d.fbx";
|
|
tName = "BridgeTop0M-3M";
|
|
}
|
|
else
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-18w-5l-1d.fbx";
|
|
tName = "BridgeTop0M-1M";
|
|
}
|
|
}
|
|
else if (node.spline.road.laneAmount == 4)
|
|
{
|
|
if (BridgeTopBaseQuickAdd == BridgeTopBaseDefaultsEnum.Base1MOver)
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-29w-5l-1d.fbx";
|
|
tName = "BridgeTop1M-1M";
|
|
}
|
|
else if (BridgeTopBaseQuickAdd == BridgeTopBaseDefaultsEnum.Base2MOver)
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-30w-5l-1d.fbx";
|
|
tName = "BridgeTop2M-1M";
|
|
}
|
|
else if (BridgeTopBaseQuickAdd == BridgeTopBaseDefaultsEnum.Base3MDeep)
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-28w-5l-3d.fbx";
|
|
tName = "BridgeTop0M-3M";
|
|
}
|
|
else
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-28w-5l-1d.fbx";
|
|
tName = "BridgeTop0M-1M";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (BridgeTopBaseQuickAdd == BridgeTopBaseDefaultsEnum.Base1MOver)
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-39w-5l-1d.fbx";
|
|
tName = "BridgeTop1M-1M";
|
|
}
|
|
else if (BridgeTopBaseQuickAdd == BridgeTopBaseDefaultsEnum.Base2MOver)
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-40w-5l-1d.fbx";
|
|
tName = "BridgeTop2M-1M";
|
|
}
|
|
else if (BridgeTopBaseQuickAdd == BridgeTopBaseDefaultsEnum.Base3MDeep)
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-38w-5l-3d.fbx";
|
|
tName = "BridgeTop0M-3M";
|
|
}
|
|
else
|
|
{
|
|
tBridgeTopBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase-38w-5l-1d.fbx";
|
|
tName = "BridgeTop0M-1M";
|
|
}
|
|
}
|
|
|
|
if (_isOverridenPrefab)
|
|
{
|
|
tBridgeTopBaseToAdd = _overridePrefab;
|
|
}
|
|
|
|
SMM.objectName = tName;
|
|
SMM.currentSplination = EngineIntegration.LoadAssetFromPath<GameObject>(tBridgeTopBaseToAdd);
|
|
SMM.horizontalSep = _horizSep;
|
|
SMM.verticalRaise = _vertRaise;
|
|
SMM.isMaterialOverriden = true;
|
|
SMM.SplinatedMaterial1 = RoadEditorUtility.LoadMaterial(_mat);
|
|
SMM.Axis = Splination.AxisTypeEnum.Z;
|
|
|
|
BridgeTopBaseQuickAdd = BridgeTopBaseDefaultsEnum.None;
|
|
if (SMM.StartTime < node.minSplination)
|
|
{
|
|
SMM.StartTime = node.minSplination;
|
|
}
|
|
if (SMM.EndTime > node.maxSplination)
|
|
{
|
|
SMM.EndTime = node.maxSplination;
|
|
}
|
|
}
|
|
|
|
|
|
private void BridgeAddBottomBase(float _horizSep = 0f, float _vertRaise = -1.01f, string _mat = "", bool _isOverridenPrefab = false, string _overridePrefab = "")
|
|
{
|
|
string basePath = RoadEditorUtility.GetBasePath();
|
|
|
|
if (_mat == "")
|
|
{
|
|
_mat = basePath + "/Materials/Concrete2.mat";
|
|
}
|
|
SMM = node.AddSplinatedObject();
|
|
string tBridgeBottomBaseToAdd = "";
|
|
string tName = "";
|
|
if (node.spline.road.laneAmount == 2)
|
|
{
|
|
if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase2)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase2-18w-5l-3d.fbx";
|
|
tName = "BridgeBase2";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase3)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase3-18w-5l-5d.fbx";
|
|
tName = "BridgeBase3";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase4)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase4-18w-5l-5d.fbx";
|
|
tName = "BridgeBase4";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase5)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase5-18w-5l-5d.fbx";
|
|
tName = "BridgeBase5";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase6)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase6On2Lanes.fbx";
|
|
tName = "BridgeArchBeam80";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase7)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase7On2Lanes.fbx";
|
|
tName = "BridgeArchSolid80";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase8)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase8On2Lanes.fbx";
|
|
tName = "BridgeArchSolid180";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBaseGrid)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBaseGrid-18w-5l-5d.fbx";
|
|
tName = "BridgeGrid";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeSteel)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBaseSteelBeam-18w-20l-3d.fbx";
|
|
tName = "BridgeSteelBeams";
|
|
}
|
|
}
|
|
else if (node.spline.road.laneAmount == 4)
|
|
{
|
|
if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase2)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase2-28w-5l-3d.fbx";
|
|
tName = "BridgeBase2";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase3)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase3-28w-5l-5d.fbx";
|
|
tName = "BridgeBase3";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase4)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase4-28w-5l-5d.fbx";
|
|
tName = "BridgeBase4";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase5)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase5-28w-5l-5d.fbx";
|
|
tName = "BridgeBase5";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase6)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase6On4Lanes.fbx";
|
|
tName = "BridgeArchBeam80";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase7)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase7On4Lanes.fbx";
|
|
tName = "BridgeArchSolid80";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase8)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase8On4Lanes.fbx";
|
|
tName = "BridgeArchSolid180";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBaseGrid)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBaseGrid-28w-5l-5d.fbx";
|
|
tName = "BridgeGrid";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeSteel)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBaseSteelBeam-28w-20l-3d.fbx";
|
|
tName = "BridgeSteelBeams";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase2)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase2-38w-5l-3d.fbx";
|
|
tName = "BridgeBase2";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase3)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase3-38w-5l-5d.fbx";
|
|
tName = "BridgeBase3";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase4)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase4-38w-5l-5d.fbx";
|
|
tName = "BridgeBase4";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase5)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase5-38w-5l-5d.fbx";
|
|
tName = "BridgeBase5";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase6)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase6On6Lanes.fbx";
|
|
tName = "BridgeArchBeam80";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase7)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase7On6Lanes.fbx";
|
|
tName = "BridgeArchSolid80";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase8)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBase8On6Lanes.fbx";
|
|
tName = "BridgeArchSolid180";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBaseGrid)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBaseGrid-38w-5l-5d.fbx";
|
|
tName = "BridgeGrid";
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeSteel)
|
|
{
|
|
tBridgeBottomBaseToAdd = basePath + "/Mesh/Bridges/BridgeBaseSteelBeam-38w-20l-3d.fbx";
|
|
tName = "BridgeBeams";
|
|
}
|
|
}
|
|
|
|
if (_isOverridenPrefab)
|
|
{
|
|
tBridgeBottomBaseToAdd = _overridePrefab;
|
|
}
|
|
|
|
SMM.currentSplination = EngineIntegration.LoadAssetFromPath<GameObject>(tBridgeBottomBaseToAdd);
|
|
SMM.horizontalSep = _horizSep;
|
|
SMM.verticalRaise = _vertRaise;
|
|
SMM.isMaterialOverriden = true;
|
|
SMM.objectName = tName;
|
|
|
|
if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase2)
|
|
{
|
|
SMM.SplinatedMaterial1 = RoadEditorUtility.LoadMaterial(_mat);
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase3)
|
|
{
|
|
SMM.SplinatedMaterial1 = RoadEditorUtility.LoadMaterial(_mat);
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase4)
|
|
{
|
|
SMM.SplinatedMaterial1 = RoadEditorUtility.LoadMaterial(_mat);
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase5)
|
|
{
|
|
SMM.SplinatedMaterial1 = RoadEditorUtility.LoadMaterial(_mat);
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase6)
|
|
{
|
|
SMM.SplinatedMaterial1 = RoadEditorUtility.LoadMaterial(_mat);
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase7)
|
|
{
|
|
SMM.SplinatedMaterial1 = RoadEditorUtility.LoadMaterial(_mat);
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBase8)
|
|
{
|
|
SMM.SplinatedMaterial1 = RoadEditorUtility.LoadMaterial(_mat);
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeBaseGrid)
|
|
{
|
|
SMM.SplinatedMaterial1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Steel7.mat");
|
|
}
|
|
else if (BridgeBottomBaseQuickAdd == BridgeBottomBaseDefaultsEnum.BridgeSteel)
|
|
{
|
|
SMM.SplinatedMaterial1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Steel7.mat");
|
|
}
|
|
|
|
SMM.Axis = Splination.AxisTypeEnum.Z;
|
|
|
|
BridgeTopBaseQuickAdd = BridgeTopBaseDefaultsEnum.None;
|
|
if (SMM.StartTime < node.minSplination)
|
|
{
|
|
SMM.StartTime = node.minSplination;
|
|
}
|
|
if (SMM.EndTime > node.maxSplination)
|
|
{
|
|
SMM.EndTime = node.maxSplination;
|
|
}
|
|
}
|
|
|
|
|
|
private void ExtrusionQuickAdd(bool _isHorizOverriden = false, float _horizSep = 0f, bool _isVertOverriden = false, float _vertRaise = 0f)
|
|
{
|
|
try
|
|
{
|
|
ExtrusionQuickAddDo();
|
|
}
|
|
catch (System.Exception exception)
|
|
{
|
|
SMMQuickAdd = SMMDefaultsEnum.None;
|
|
throw exception;
|
|
}
|
|
}
|
|
|
|
|
|
private void ExtrusionQuickAddDo()
|
|
{
|
|
if (SMMQuickAdd == SMMDefaultsEnum.KRail)
|
|
{
|
|
node.SplinatedObjectQuickAdd("KRail");
|
|
}
|
|
}
|
|
|
|
|
|
private void ExtrudeHelper(string _path, string _name, float DefaultHoriz, Splination.AxisTypeEnum _axisType = Splination.AxisTypeEnum.Z, bool _isHorizOverriden = false, float _horizSep = 0f, bool _isVertOverriden = false, float _vertRaise = 0f, bool _isFlippingRot = false)
|
|
{
|
|
SMM = node.AddSplinatedObject();
|
|
SMM.currentSplination = EngineIntegration.LoadAssetFromPath<GameObject>(_path);
|
|
|
|
if (_isHorizOverriden)
|
|
{
|
|
SMM.horizontalSep = _horizSep;
|
|
}
|
|
else
|
|
{
|
|
SMM.horizontalSep = ((node.spline.road.RoadWidth() / 2) + node.spline.road.shoulderWidth) * -1f;
|
|
}
|
|
|
|
if (_isVertOverriden)
|
|
{
|
|
SMM.verticalRaise = _vertRaise;
|
|
}
|
|
else
|
|
{
|
|
if (node.isBridgeStart)
|
|
{
|
|
SMM.verticalRaise = -0.01f;
|
|
}
|
|
}
|
|
|
|
SMM.isFlippingRotation = _isFlippingRot;
|
|
SMM.Axis = _axisType;
|
|
if (SMM.StartTime < node.minSplination)
|
|
{
|
|
SMM.StartTime = node.minSplination;
|
|
}
|
|
if (SMM.EndTime > node.maxSplination)
|
|
{
|
|
SMM.EndTime = node.maxSplination;
|
|
}
|
|
SMM.objectName = _name;
|
|
}
|
|
#endregion
|
|
|
|
|
|
public void OnSceneGUI()
|
|
{
|
|
currentEvent = Event.current;
|
|
|
|
if (!isSceneRectSet)
|
|
{
|
|
try
|
|
{
|
|
sceneRect = EditorWindow.GetWindow<SceneView>().position;
|
|
}
|
|
catch
|
|
{
|
|
sceneRect = EditorWindow.GetWindow<EditorWindow>().position;
|
|
}
|
|
isSceneRectSet = true;
|
|
}
|
|
|
|
if (currentEvent.type == EventType.ValidateCommand)
|
|
{
|
|
switch (currentEvent.commandName)
|
|
{
|
|
case "UndoRedoPerformed":
|
|
UpdateSplineObjectsOnUndo();
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Drag with left click release:
|
|
if (Event.current.type == EventType.MouseUp && Event.current.button == 0)
|
|
{
|
|
Object[] nodeObjects = GameObject.FindObjectsOfType<SplineN>();
|
|
foreach (SplineN xNode in nodeObjects)
|
|
{
|
|
if (Vector3.Distance(xNode.transform.position, node.transform.position) < 2f)
|
|
{
|
|
if (xNode == node)
|
|
{
|
|
continue;
|
|
}
|
|
if (node.isSpecialEndNode || xNode.isSpecialEndNode)
|
|
{
|
|
continue;
|
|
}
|
|
if (xNode.isEndPoint && node.isEndPoint)
|
|
{
|
|
//End point connection.
|
|
node.transform.position = xNode.transform.position;
|
|
//Activate special end node for tnode
|
|
TriggerRoadConnection(node, xNode);
|
|
break;
|
|
}
|
|
if (xNode.isIntersection)
|
|
{
|
|
continue;
|
|
}
|
|
if (xNode.isNeverIntersect)
|
|
{
|
|
continue;
|
|
}
|
|
if (node.isEndPoint && xNode.isEndPoint)
|
|
{
|
|
continue;
|
|
}
|
|
if (xNode.spline == node.spline)
|
|
{
|
|
//Don't let intersection be created on consecutive nodes:
|
|
if ((node.idOnSpline + 1) == xNode.idOnSpline || (node.idOnSpline - 1) == xNode.idOnSpline)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
node.transform.position = xNode.transform.position;
|
|
TriggerIntersection(node, xNode);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//Enforce maximum road grade:
|
|
if (VectorDiff(node.transform.position, node.pos))
|
|
{
|
|
node.pos = node.transform.position;
|
|
if (node.IsLegitimate() && node.spline.road.isMaxGradeEnabled)
|
|
{
|
|
node.EnsureGradeValidity();
|
|
}
|
|
TriggerRoadUpdate();
|
|
}
|
|
}
|
|
|
|
if (Selection.activeGameObject == node.transform.gameObject)
|
|
{
|
|
if (currentEvent.keyCode == KeyCode.F5)
|
|
{
|
|
TriggerRoadUpdate();
|
|
}
|
|
}
|
|
|
|
if (GUI.changed)
|
|
{
|
|
EditorUtility.SetDirty(node);
|
|
}
|
|
}
|
|
|
|
|
|
private bool VectorDiff(Vector3 _vect1, Vector3 _vect2)
|
|
{
|
|
if (!RootUtils.IsApproximately(_vect1.x, _vect2.x, 0.0001f))
|
|
{
|
|
return true;
|
|
}
|
|
if (!RootUtils.IsApproximately(_vect1.y, _vect2.y, 0.0001f))
|
|
{
|
|
return true;
|
|
}
|
|
if (!RootUtils.IsApproximately(_vect1.z, _vect2.z, 0.0001f))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
private bool VectorEquals(ref Vector3 _v1, ref Vector3 _v2)
|
|
{
|
|
if (!RootUtils.IsApproximately(_v1.x, _v2.x, 0.001f))
|
|
{
|
|
return false;
|
|
}
|
|
if (!RootUtils.IsApproximately(_v1.y, _v2.y, 0.001f))
|
|
{
|
|
return false;
|
|
}
|
|
if (!RootUtils.IsApproximately(_v1.z, _v2.z, 0.001f))
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
#region "Triggers Intersections; Connections; Update"
|
|
private void TriggerRoadConnection(SplineN _node1, SplineN _node2)
|
|
{
|
|
node.spline.ActivateEndNodeConnection(_node1, _node2);
|
|
}
|
|
|
|
|
|
private void TriggerIntersection(SplineN _node1, SplineN _node2)
|
|
{
|
|
isCreatingIntersection = true;
|
|
node1 = _node1;
|
|
node2 = _node2;
|
|
Selection.activeGameObject = Intersections.CreateIntersection(_node1, _node2);
|
|
}
|
|
|
|
|
|
private void TriggerRoadUpdate()
|
|
{
|
|
if (node != null)
|
|
{
|
|
node.spline.road.isUpdateRequired = true;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
private void ResetCurve(ref AnimationCurve _curve)
|
|
{
|
|
_curve = null;
|
|
_curve = new AnimationCurve();
|
|
EnforceCurve(ref _curve);
|
|
}
|
|
|
|
|
|
private void EnforceCurve(ref AnimationCurve _curve)
|
|
{
|
|
if (_curve == null)
|
|
{
|
|
return;
|
|
}
|
|
if (_curve.keys.Length == 0)
|
|
{
|
|
_curve.AddKey(0f, 1f);
|
|
_curve.AddKey(1f, 1f);
|
|
}
|
|
else if (_curve.keys.Length == 1)
|
|
{
|
|
_curve.keys[0].time = 0f;
|
|
_curve.AddKey(1f, 1f);
|
|
}
|
|
}
|
|
|
|
|
|
private GameObject GetEndObjectQuickAdd()
|
|
{
|
|
string basePath = RoadEditorUtility.GetBasePath();
|
|
|
|
string path = "";
|
|
if (endObjectAdd == EndObjectsDefaultsEnum.WarningSign1_Static)
|
|
{
|
|
path = basePath + "/Prefabs/Interactive/WarningSignStatic.prefab";
|
|
}
|
|
else if (endObjectAdd == EndObjectsDefaultsEnum.WarningSign2_Static)
|
|
{
|
|
path = basePath + "/Prefabs/Interactive/WarningSignStatic2.prefab";
|
|
}
|
|
else if (endObjectAdd == EndObjectsDefaultsEnum.Atten_Static)
|
|
{
|
|
path = basePath + "/Prefabs/Interactive/AttenStatic.prefab";
|
|
}
|
|
else if (endObjectAdd == EndObjectsDefaultsEnum.Barrel1_Static)
|
|
{
|
|
path = basePath + "/Prefabs/Interactive/RoadBarrelStatic.prefab";
|
|
}
|
|
else if (endObjectAdd == EndObjectsDefaultsEnum.Barrel1_Rigid)
|
|
{
|
|
path = basePath + "/Prefabs/Interactive/RoadBarrelRigid.prefab";
|
|
}
|
|
else if (endObjectAdd == EndObjectsDefaultsEnum.Barrel3_Static)
|
|
{
|
|
path = basePath + "/Prefabs/Interactive/RoadBarrelStatic3.prefab";
|
|
}
|
|
else if (endObjectAdd == EndObjectsDefaultsEnum.Barrel3_Rigid)
|
|
{
|
|
path = basePath + "/Prefabs/Interactive/RoadBarrelRigid3.prefab";
|
|
}
|
|
else if (endObjectAdd == EndObjectsDefaultsEnum.Barrel7_Static)
|
|
{
|
|
path = basePath + "/Prefabs/Interactive/RoadBarrelStatic7.prefab";
|
|
}
|
|
else if (endObjectAdd == EndObjectsDefaultsEnum.Barrel7_Rigid)
|
|
{
|
|
path = basePath + "/Prefabs/Interactive/RoadBarrelRigid7.prefab";
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return EngineIntegration.LoadAssetFromPath<GameObject>(path);
|
|
}
|
|
}
|
|
}
|
|
#endif
|