1013 lines
40 KiB
C#
1013 lines
40 KiB
C#
#region "Imports"
|
|
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
#endregion
|
|
|
|
|
|
namespace RoadArchitect
|
|
{
|
|
public class RoadIntersection : MonoBehaviour
|
|
{
|
|
#region "Vars"
|
|
public SplineN node1;
|
|
public SplineN node2;
|
|
|
|
public string node1uID;
|
|
public string node2uID;
|
|
|
|
//Unique ID
|
|
protected string uID;
|
|
public string intersectionName = "";
|
|
|
|
public bool isSameSpline = false;
|
|
public bool isDrawingGizmo = true;
|
|
public bool isFlipped = false;
|
|
public bool isUsingDefaultMaterials = true;
|
|
public bool isAutoUpdatingIntersection = true;
|
|
public bool isNode2BLeftTurnLane = true;
|
|
public bool isNode2BRightTurnLane = true;
|
|
public bool isNode2FLeftTurnLane = true;
|
|
public bool isNode2FRightTurnLane = true;
|
|
public bool isFirstSpecialFirst = false;
|
|
public bool isFirstSpecialLast = false;
|
|
public bool isSecondSpecialFirst = false;
|
|
public bool isSecondSpecialLast = false;
|
|
public bool isCornerRR1Enabled = false;
|
|
public bool isCornerRR2Enabled = false;
|
|
public bool isCornerRL1Enabled = false;
|
|
public bool isCornerRL2Enabled = false;
|
|
public bool isCornerLR1Enabled = false;
|
|
public bool isCornerLR2Enabled = false;
|
|
public bool isCornerLL1Enabled = false;
|
|
public bool isCornerLL2Enabled = false;
|
|
|
|
#region "Marker materials"
|
|
public Material markerCenter1 = null;
|
|
public Material markerCenter2 = null;
|
|
public Material markerCenter3 = null;
|
|
public Material markerExtStretch1 = null;
|
|
public Material markerExtStretch2 = null;
|
|
public Material markerExtStretch3 = null;
|
|
public Material markerExtTiled1 = null;
|
|
public Material markerExtTiled2 = null;
|
|
public Material markerExtTiled3 = null;
|
|
#endregion
|
|
|
|
#region "Lane materials"
|
|
public Material lane0Mat1 = null;
|
|
public Material lane0Mat2 = null;
|
|
public Material lane1Mat1 = null;
|
|
public Material lane1Mat2 = null;
|
|
public Material lane2Mat1 = null;
|
|
public Material lane2Mat2 = null;
|
|
public Material lane3Mat1 = null;
|
|
public Material lane3Mat2 = null;
|
|
|
|
public Material lane1Mat1Disabled = null;
|
|
public Material lane1Mat2Disabled = null;
|
|
public Material lane1Mat1DisabledActive = null;
|
|
public Material lane1Mat2DisabledActive = null;
|
|
public Material lane2Mat1Disabled = null;
|
|
public Material lane2Mat2Disabled = null;
|
|
public Material lane2Mat1DisabledActive = null;
|
|
public Material lane2Mat2DisabledActive = null;
|
|
public Material lane2Mat1DisabledActiveR = null;
|
|
public Material lane2Mat2DisabledActiveR = null;
|
|
public Material lane3Mat1Disabled = null;
|
|
public Material lane3Mat2Disabled = null;
|
|
#endregion
|
|
|
|
//Width of the largest of road connected
|
|
/// <summary> 10 * 1.25f = intersectionWidth; Never written, only read </summary>
|
|
public int intersectionWidth = 10;
|
|
/// <summary> Amount of lanes from road of node1 </summary>
|
|
public int lanesAmount;
|
|
public int ignoreSide = -1;
|
|
public int ignoreCorner = -1;
|
|
|
|
public IntersectionTypeEnum intersectionType = IntersectionTypeEnum.FourWay;
|
|
public iStopTypeEnum intersectionStopType = iStopTypeEnum.StopSign_AllWay;
|
|
public RoadTypeEnum roadType = RoadTypeEnum.NoTurnLane;
|
|
public LightTypeEnum lightType = LightTypeEnum.Timed;
|
|
|
|
#region "CalculationData"
|
|
public CornerPositionMaker[] cornerPoints;
|
|
|
|
public Vector3 cornerRR;
|
|
public Vector3 cornerRROuter;
|
|
public Vector3 cornerRRRampOuter;
|
|
public Vector3 cornerRL;
|
|
public Vector3 cornerRLOuter;
|
|
public Vector3 cornerRLRampOuter;
|
|
public Vector3 cornerLR;
|
|
public Vector3 cornerLROuter;
|
|
public Vector3 cornerLRRampOuter;
|
|
public Vector3 cornerLL;
|
|
public Vector3 cornerLLOuter;
|
|
public Vector3 cornerLLRampOuter;
|
|
|
|
public Vector2 cornerRR2D;
|
|
public Vector2 cornerRL2D;
|
|
public Vector2 cornerLR2D;
|
|
public Vector2 cornerLL2D;
|
|
|
|
public Vector3[] cornerLRCornerRR;
|
|
public Vector3[] cornerLLCornerRL;
|
|
public Vector3[] cornerLLCornerLR;
|
|
public Vector3[] cornerRLCornerRR;
|
|
#endregion
|
|
|
|
public float gradeMod = 0.375f;
|
|
public float gradeModNegative = 0.75f;
|
|
public float scalingSense = 3f;
|
|
public float oddAngle;
|
|
public float evenAngle;
|
|
public float maxInterDistance = 0f;
|
|
public float maxInterDistanceSQ = 0f;
|
|
public float height = 50000f;
|
|
public float signHeight = -2000f;
|
|
|
|
#region "Traffic Light Vars"
|
|
public bool isLightsEnabled = true;
|
|
public bool isRegularPoleAlignment = true;
|
|
public bool isTrafficPoleStreetLight = true;
|
|
public bool isTrafficLightGray = false;
|
|
public bool isLeftTurnYieldOnGreen = true;
|
|
public float streetLightRange = 30f;
|
|
public float streetLightIntensity = 1f;
|
|
public Color streetLightColor = new Color(1f, 0.7451f, 0.27451f, 1f);
|
|
private int fixedTimeIndex = 0;
|
|
public TrafficLightController lightsRR;
|
|
public TrafficLightController lightsRL;
|
|
public TrafficLightController lightsLL;
|
|
public TrafficLightController lightsLR;
|
|
public float fixedTimeRegularLightLength = 10f;
|
|
public float fixedTimeLeftTurnLightLength = 5f;
|
|
public float fixedTimeAllRedLightLength = 1f;
|
|
public float fixedTimeYellowLightLength = 2f;
|
|
public List<TrafficLightSequence> fixedTimeSequenceList;
|
|
#endregion
|
|
#endregion
|
|
|
|
|
|
public enum IntersectionTypeEnum { ThreeWay, FourWay };
|
|
public enum iStopTypeEnum { StopSign_AllWay, TrafficLight1, None, TrafficLight2 };
|
|
public enum RoadTypeEnum { NoTurnLane, TurnLane, BothTurnLanes };
|
|
public enum LightTypeEnum { Timed, Sensors };
|
|
|
|
|
|
// A struct may be better and faster
|
|
public class CornerPositionMaker
|
|
{
|
|
public Vector3 position;
|
|
public Quaternion rotation;
|
|
public Vector3 directionFromCenter;
|
|
}
|
|
|
|
|
|
private Construction2DRect boundsRect;
|
|
|
|
|
|
#region "Setup"
|
|
/// <summary> Links nodes and intersection </summary>
|
|
public void Setup(SplineN _node1, SplineN _node2)
|
|
{
|
|
if (_node1.spline == _node2.spline)
|
|
{
|
|
isSameSpline = true;
|
|
}
|
|
|
|
if (_node1.idOnSpline < _node2.idOnSpline || _node1.isEndPoint || (!isSameSpline && !_node2.isEndPoint))
|
|
{
|
|
node1 = _node1;
|
|
node2 = _node2;
|
|
}
|
|
else
|
|
{
|
|
node1 = _node2;
|
|
node2 = _node1;
|
|
}
|
|
|
|
if (node1.isEndPoint || node2.isEndPoint)
|
|
{
|
|
intersectionType = IntersectionTypeEnum.ThreeWay;
|
|
}
|
|
else
|
|
{
|
|
intersectionType = IntersectionTypeEnum.FourWay;
|
|
}
|
|
|
|
node1.intersectionOtherNode = node2;
|
|
node2.intersectionOtherNode = node1;
|
|
|
|
node1.ToggleHideFlags(true);
|
|
node2.ToggleHideFlags(true);
|
|
|
|
node1uID = node1.uID;
|
|
node2uID = node2.uID;
|
|
node1.isIntersection = true;
|
|
node2.isIntersection = true;
|
|
node1.intersection = this;
|
|
node2.intersection = this;
|
|
}
|
|
|
|
|
|
/// <summary> Deletes Meshes based on road name and the centermarker if _node is intersections node1 </summary>
|
|
public void DeleteRelevantChildren(SplineN _node, string _string)
|
|
{
|
|
Transform transformChild;
|
|
int childCount = transform.childCount;
|
|
for (int index = childCount - 1; index >= 0; index--)
|
|
{
|
|
transformChild = transform.GetChild(index);
|
|
if (transformChild.name.ToLower().Contains(_string.ToLower()))
|
|
{
|
|
Object.DestroyImmediate(transformChild.gameObject);
|
|
}
|
|
else if (_node == node1)
|
|
{
|
|
if (transformChild.name.ToLower().Contains("centermarkers"))
|
|
{
|
|
Object.DestroyImmediate(transformChild.gameObject);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region "Utility"
|
|
/// <summary> Attach other spline to PiggyBacks if not same spline and setup </summary>
|
|
public void UpdateRoads()
|
|
{
|
|
if (!isSameSpline)
|
|
{
|
|
SplineC[] piggys = new SplineC[1];
|
|
piggys[0] = node2.spline;
|
|
node1.spline.road.PiggyBacks = piggys;
|
|
node1.spline.TriggerSetup();
|
|
}
|
|
else
|
|
{
|
|
node1.spline.TriggerSetup();
|
|
}
|
|
}
|
|
|
|
|
|
public void ConstructBoundsRect()
|
|
{
|
|
boundsRect = null;
|
|
boundsRect = new Construction2DRect(new Vector2(cornerRR.x, cornerRR.z), new Vector2(cornerRL.x, cornerRL.z), new Vector2(cornerLR.x, cornerLR.z), new Vector2(cornerLL.x, cornerLL.z));
|
|
}
|
|
|
|
|
|
/// <summary> Creates boundsRect if null and returns true if _vector is inside the rect </summary>
|
|
public bool Contains(ref Vector3 _vector)
|
|
{
|
|
Vector2 vector2D = new Vector2(_vector.x, _vector.z);
|
|
if (boundsRect == null)
|
|
{
|
|
ConstructBoundsRect();
|
|
}
|
|
return boundsRect.Contains(ref vector2D);
|
|
}
|
|
|
|
|
|
private bool ContainsLineOld(Vector3 _vector1, Vector3 _vector2, int _lineDef = 30)
|
|
{
|
|
int MaxDef = _lineDef;
|
|
float MaxDefF = (float)MaxDef;
|
|
|
|
Vector3[] tVects = new Vector3[MaxDef];
|
|
|
|
tVects[0] = _vector1;
|
|
float mMod = 0f;
|
|
float fcounter = 1f;
|
|
for (int index = 1; index < (MaxDef - 1); index++)
|
|
{
|
|
mMod = fcounter / MaxDefF;
|
|
tVects[index] = ((_vector2 - _vector1) * mMod) + _vector1;
|
|
fcounter += 1f;
|
|
}
|
|
tVects[MaxDef - 1] = _vector2;
|
|
|
|
Vector2 xVect = default(Vector2);
|
|
for (int index = 0; index < MaxDef; index++)
|
|
{
|
|
xVect = new Vector2(tVects[index].x, tVects[index].z);
|
|
if (boundsRect.Contains(ref xVect))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
/// <summary> Returns true when the Vectors or the line between them are inside the intersection </summary>
|
|
public bool ContainsLine(Vector3 _vector1, Vector3 _vector2)
|
|
{
|
|
Vector2 tVectStart = new Vector2(_vector1.x, _vector1.z);
|
|
Vector2 tVectEnd = new Vector2(_vector2.x, _vector2.z);
|
|
bool bIntersects = Intersects2D(ref tVectStart, ref tVectEnd, ref cornerRR2D, ref cornerRL2D);
|
|
if (bIntersects)
|
|
{
|
|
return true;
|
|
}
|
|
bIntersects = Intersects2D(ref tVectStart, ref tVectEnd, ref cornerRL2D, ref cornerLL2D);
|
|
if (bIntersects)
|
|
{
|
|
return true;
|
|
}
|
|
bIntersects = Intersects2D(ref tVectStart, ref tVectEnd, ref cornerLL2D, ref cornerLR2D);
|
|
if (bIntersects)
|
|
{
|
|
return true;
|
|
}
|
|
bIntersects = Intersects2D(ref tVectStart, ref tVectEnd, ref cornerLR2D, ref cornerRR2D);
|
|
return bIntersects;
|
|
}
|
|
|
|
|
|
// Returns true if the lines intersect, otherwise false. If the lines
|
|
// intersect, intersectionPoint holds the intersection point.
|
|
private static bool Intersects2D(ref Vector2 _line1S, ref Vector2 _line1E, ref Vector2 _line2S, ref Vector2 _line2E)
|
|
{
|
|
float firstLineSlopeX, firstLineSlopeY, secondLineSlopeX, secondLineSlopeY;
|
|
|
|
firstLineSlopeX = _line1E.x - _line1S.x;
|
|
firstLineSlopeY = _line1E.y - _line1S.y;
|
|
|
|
secondLineSlopeX = _line2E.x - _line2S.x;
|
|
secondLineSlopeY = _line2E.y - _line2S.y;
|
|
|
|
float s, t;
|
|
s = (-firstLineSlopeY * (_line1S.x - _line2S.x) + firstLineSlopeX * (_line1S.y - _line2S.y)) / (-secondLineSlopeX * firstLineSlopeY + firstLineSlopeX * secondLineSlopeY);
|
|
t = (secondLineSlopeX * (_line1S.y - _line2S.y) - secondLineSlopeY * (_line1S.x - _line2S.x)) / (-secondLineSlopeX * firstLineSlopeY + firstLineSlopeX * secondLineSlopeY);
|
|
|
|
if (s >= 0 && s <= 1 && t >= 0 && t <= 1)
|
|
{
|
|
return true;
|
|
}
|
|
// No collision
|
|
return false;
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region "Gizmos"
|
|
private void OnDrawGizmos()
|
|
{
|
|
if (!isDrawingGizmo)
|
|
{
|
|
return;
|
|
}
|
|
Gizmos.color = Color.blue;
|
|
Gizmos.DrawCube(transform.position + new Vector3(0f, 5f, 0f), new Vector3(2f, 11f, 2f));
|
|
}
|
|
|
|
|
|
private void OnDrawGizmosSelected()
|
|
{
|
|
if (!isDrawingGizmo)
|
|
{
|
|
return;
|
|
}
|
|
Gizmos.color = new Color(0f, 0f, 0.7f);
|
|
Gizmos.DrawCube(transform.position + new Vector3(0f, 6f, 0f), new Vector3(2.5f, 12f, 2.5f));
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region "Traffic light controlling"
|
|
private void Start()
|
|
{
|
|
lightsRR.Setup(isLeftTurnYieldOnGreen);
|
|
lightsRL.Setup(isLeftTurnYieldOnGreen);
|
|
lightsLL.Setup(isLeftTurnYieldOnGreen);
|
|
lightsLR.Setup(isLeftTurnYieldOnGreen);
|
|
if (lightType == LightTypeEnum.Timed)
|
|
{
|
|
CreateFixedSequence();
|
|
FixedTimeIncrement();
|
|
}
|
|
else
|
|
{
|
|
//Do your custom stuff
|
|
//A Traffic addon could include sensor mode.
|
|
}
|
|
}
|
|
|
|
|
|
private void CreateFixedSequence()
|
|
{
|
|
TrafficLightSequence SequenceMaker = null;
|
|
fixedTimeSequenceList = new List<TrafficLightSequence>();
|
|
if (roadType != RoadTypeEnum.NoTurnLane)
|
|
{
|
|
SequenceMaker = new TrafficLightSequence(true, TrafficLightController.iLightControllerEnum.LeftTurn, TrafficLightController.iLightSubStatusEnum.Green, fixedTimeLeftTurnLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
}
|
|
if (roadType != RoadTypeEnum.NoTurnLane)
|
|
{
|
|
SequenceMaker = new TrafficLightSequence(true, TrafficLightController.iLightControllerEnum.LeftTurn, TrafficLightController.iLightSubStatusEnum.Yellow, fixedTimeYellowLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
}
|
|
SequenceMaker = new TrafficLightSequence(true, TrafficLightController.iLightControllerEnum.Red, TrafficLightController.iLightSubStatusEnum.Green, fixedTimeAllRedLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
SequenceMaker = new TrafficLightSequence(true, TrafficLightController.iLightControllerEnum.Regular, TrafficLightController.iLightSubStatusEnum.Green, fixedTimeRegularLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
SequenceMaker = new TrafficLightSequence(true, TrafficLightController.iLightControllerEnum.Regular, TrafficLightController.iLightSubStatusEnum.Yellow, fixedTimeYellowLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
SequenceMaker = new TrafficLightSequence(true, TrafficLightController.iLightControllerEnum.Red, TrafficLightController.iLightSubStatusEnum.Green, fixedTimeAllRedLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
|
|
if (roadType != RoadTypeEnum.NoTurnLane)
|
|
{
|
|
SequenceMaker = new TrafficLightSequence(false, TrafficLightController.iLightControllerEnum.LeftTurn, TrafficLightController.iLightSubStatusEnum.Green, fixedTimeLeftTurnLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
}
|
|
if (roadType != RoadTypeEnum.NoTurnLane)
|
|
{
|
|
SequenceMaker = new TrafficLightSequence(false, TrafficLightController.iLightControllerEnum.LeftTurn, TrafficLightController.iLightSubStatusEnum.Yellow, fixedTimeYellowLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
}
|
|
SequenceMaker = new TrafficLightSequence(true, TrafficLightController.iLightControllerEnum.Red, TrafficLightController.iLightSubStatusEnum.Green, fixedTimeAllRedLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
SequenceMaker = new TrafficLightSequence(false, TrafficLightController.iLightControllerEnum.Regular, TrafficLightController.iLightSubStatusEnum.Green, fixedTimeRegularLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
SequenceMaker = new TrafficLightSequence(false, TrafficLightController.iLightControllerEnum.Regular, TrafficLightController.iLightSubStatusEnum.Yellow, fixedTimeYellowLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
SequenceMaker = new TrafficLightSequence(false, TrafficLightController.iLightControllerEnum.Red, TrafficLightController.iLightSubStatusEnum.Green, fixedTimeAllRedLightLength);
|
|
fixedTimeSequenceList.Add(SequenceMaker);
|
|
}
|
|
|
|
|
|
private IEnumerator TrafficLightFixedUpdate(float _time)
|
|
{
|
|
yield return new WaitForSeconds(_time);
|
|
FixedTimeIncrement();
|
|
}
|
|
|
|
|
|
/// <summary> Executes the next traffic light sequence and shedules a new increment </summary>
|
|
private void FixedTimeIncrement()
|
|
{
|
|
TrafficLightSequence SequenceMaker = fixedTimeSequenceList[fixedTimeIndex];
|
|
fixedTimeIndex += 1;
|
|
if (fixedTimeIndex > (fixedTimeSequenceList.Count - 1))
|
|
{
|
|
fixedTimeIndex = 0;
|
|
}
|
|
|
|
TrafficLightController lights1 = null;
|
|
TrafficLightController lights2 = null;
|
|
|
|
TrafficLightController lightsOuter1 = null;
|
|
TrafficLightController lightsOuter2 = null;
|
|
|
|
if (SequenceMaker.isLightMasterPath1)
|
|
{
|
|
lights1 = lightsRL;
|
|
lights2 = lightsLR;
|
|
|
|
if (isFlipped)
|
|
{
|
|
lightsOuter1 = lightsRR;
|
|
lightsOuter2 = lightsLL;
|
|
}
|
|
else
|
|
{
|
|
lightsOuter1 = lightsRR;
|
|
lightsOuter2 = lightsLL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (isFlipped)
|
|
{
|
|
lights1 = lightsRR;
|
|
lights2 = lightsLL;
|
|
}
|
|
else
|
|
{
|
|
lights1 = lightsRR;
|
|
lights2 = lightsLL;
|
|
}
|
|
|
|
lightsOuter1 = lightsRL;
|
|
lightsOuter2 = lightsLR;
|
|
}
|
|
|
|
TrafficLightController.iLightControllerEnum LCE = SequenceMaker.lightController;
|
|
TrafficLightController.iLightSubStatusEnum LCESub = SequenceMaker.lightSubcontroller;
|
|
|
|
if (LCE == TrafficLightController.iLightControllerEnum.Regular)
|
|
{
|
|
lights1.UpdateLights(TrafficLightController.iLightStatusEnum.Regular, LCESub, isLightsEnabled);
|
|
lights2.UpdateLights(TrafficLightController.iLightStatusEnum.Regular, LCESub, isLightsEnabled);
|
|
lightsOuter1.UpdateLights(TrafficLightController.iLightStatusEnum.Red, LCESub, isLightsEnabled);
|
|
lightsOuter2.UpdateLights(TrafficLightController.iLightStatusEnum.Red, LCESub, isLightsEnabled);
|
|
}
|
|
else if (LCE == TrafficLightController.iLightControllerEnum.LeftTurn)
|
|
{
|
|
lights1.UpdateLights(TrafficLightController.iLightStatusEnum.LeftTurn, LCESub, isLightsEnabled);
|
|
lights2.UpdateLights(TrafficLightController.iLightStatusEnum.LeftTurn, LCESub, isLightsEnabled);
|
|
lightsOuter1.UpdateLights(TrafficLightController.iLightStatusEnum.RightTurn, LCESub, isLightsEnabled);
|
|
lightsOuter2.UpdateLights(TrafficLightController.iLightStatusEnum.RightTurn, LCESub, isLightsEnabled);
|
|
}
|
|
else if (LCE == TrafficLightController.iLightControllerEnum.Red)
|
|
{
|
|
lights1.UpdateLights(TrafficLightController.iLightStatusEnum.Red, LCESub, isLightsEnabled);
|
|
lights2.UpdateLights(TrafficLightController.iLightStatusEnum.Red, LCESub, isLightsEnabled);
|
|
lightsOuter1.UpdateLights(TrafficLightController.iLightStatusEnum.Red, LCESub, isLightsEnabled);
|
|
lightsOuter2.UpdateLights(TrafficLightController.iLightStatusEnum.Red, LCESub, isLightsEnabled);
|
|
}
|
|
|
|
//Debug.Log ("Starting: " + SMaker.ToString());
|
|
StartCoroutine(TrafficLightFixedUpdate(SequenceMaker.time));
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region "Materials"
|
|
public void ResetMaterialsAll()
|
|
{
|
|
ResetCenterMaterials(false);
|
|
ResetExtStrechtedMaterials(false);
|
|
ResetExtTiledMaterials(false);
|
|
ResetLanesMaterials(false);
|
|
UpdateMaterials();
|
|
}
|
|
|
|
|
|
public void ResetCenterMaterials(bool _isUpdate = true)
|
|
{
|
|
string lanesNumber = "-2L";
|
|
lanesAmount = node1.spline.road.laneAmount;
|
|
if (lanesAmount == 4)
|
|
{
|
|
lanesNumber = "-4L";
|
|
}
|
|
else if (lanesAmount == 6)
|
|
{
|
|
lanesNumber = "-6L";
|
|
}
|
|
if (intersectionType == IntersectionTypeEnum.ThreeWay)
|
|
{
|
|
lanesNumber += "-3";
|
|
if (node1.idOnSpline < 2 || node2.idOnSpline < 2)
|
|
{
|
|
//if(isFirstSpecialFirst || isFirstSpecialLast)
|
|
//{
|
|
//Reverse if from node 0
|
|
//stands for "Center Reversed"
|
|
lanesNumber += "-crev";
|
|
//}
|
|
}
|
|
}
|
|
|
|
string basePath = RoadEditorUtility.GetBasePath();
|
|
|
|
if (roadType == RoadTypeEnum.BothTurnLanes)
|
|
{
|
|
markerCenter1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterCenter-Both" + lanesNumber + ".mat");
|
|
markerCenter2 = null;
|
|
markerCenter3 = null;
|
|
}
|
|
else if (roadType == RoadTypeEnum.TurnLane)
|
|
{
|
|
markerCenter1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterCenter-Left" + lanesNumber + ".mat");
|
|
markerCenter2 = null;
|
|
markerCenter3 = null;
|
|
}
|
|
else if (roadType == RoadTypeEnum.NoTurnLane)
|
|
{
|
|
markerCenter1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterCenter-None" + lanesNumber + ".mat");
|
|
markerCenter2 = null;
|
|
markerCenter3 = null;
|
|
}
|
|
if (_isUpdate)
|
|
{
|
|
UpdateMaterials();
|
|
}
|
|
}
|
|
|
|
|
|
public void ResetExtStrechtedMaterials(bool _isUpdate = true)
|
|
{
|
|
string lanesNumber = "-2L";
|
|
lanesAmount = node1.spline.road.laneAmount;
|
|
if (lanesAmount == 4)
|
|
{
|
|
lanesNumber = "-4L";
|
|
}
|
|
else if (lanesAmount == 6)
|
|
{
|
|
lanesNumber = "-6L";
|
|
}
|
|
|
|
string basePath = RoadEditorUtility.GetBasePath();
|
|
|
|
if (roadType == RoadTypeEnum.BothTurnLanes)
|
|
{
|
|
markerExtStretch1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterStretch-Both" + lanesNumber + ".mat");
|
|
markerExtStretch2 = null;
|
|
markerExtStretch3 = null;
|
|
}
|
|
else if (roadType == RoadTypeEnum.TurnLane)
|
|
{
|
|
markerExtStretch1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterStretch-Left" + lanesNumber + ".mat");
|
|
markerExtStretch2 = null;
|
|
markerExtStretch3 = null;
|
|
}
|
|
else if (roadType == RoadTypeEnum.NoTurnLane)
|
|
{
|
|
markerExtStretch1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterStretch-None" + lanesNumber + ".mat");
|
|
markerExtStretch2 = null;
|
|
markerExtStretch3 = null;
|
|
}
|
|
if (_isUpdate)
|
|
{
|
|
UpdateMaterials();
|
|
}
|
|
}
|
|
|
|
|
|
public void ResetExtTiledMaterials(bool _isUpdate = true)
|
|
{
|
|
string basePath = RoadEditorUtility.GetBasePath();
|
|
|
|
if (roadType == RoadTypeEnum.BothTurnLanes)
|
|
{
|
|
markerExtTiled1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Road1.mat");
|
|
markerExtTiled2 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/RoadDetailOverlay1.mat");
|
|
markerExtTiled3 = null;
|
|
}
|
|
else if (roadType == RoadTypeEnum.TurnLane)
|
|
{
|
|
markerExtTiled1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Road1.mat");
|
|
markerExtTiled2 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/RoadDetailOverlay1.mat");
|
|
markerExtTiled3 = null;
|
|
}
|
|
else if (roadType == RoadTypeEnum.NoTurnLane)
|
|
{
|
|
markerExtTiled1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Road1.mat");
|
|
markerExtTiled2 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/RoadDetailOverlay1.mat");
|
|
markerExtTiled3 = null;
|
|
}
|
|
if (_isUpdate)
|
|
{
|
|
UpdateMaterials();
|
|
}
|
|
}
|
|
|
|
|
|
public void ResetLanesMaterials(bool _isUpdate = true)
|
|
{
|
|
string lanesNumber = "";
|
|
lanesAmount = node1.spline.road.laneAmount;
|
|
if (lanesAmount == 4)
|
|
{
|
|
lanesNumber = "-4L";
|
|
}
|
|
else if (lanesAmount == 6)
|
|
{
|
|
lanesNumber = "-6L";
|
|
}
|
|
|
|
string basePath = RoadEditorUtility.GetBasePath();
|
|
|
|
if (intersectionType == IntersectionTypeEnum.ThreeWay)
|
|
{
|
|
lane1Mat1Disabled = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterLaneDisabled.mat");
|
|
lane1Mat2Disabled = null;
|
|
if (roadType == RoadTypeEnum.BothTurnLanes)
|
|
{
|
|
lane1Mat1DisabledActive = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterLaneDisabledOuterRR.mat");
|
|
lane1Mat2DisabledActive = null;
|
|
lane2Mat1Disabled = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterLaneDisabledR.mat");
|
|
lane2Mat2Disabled = null;
|
|
}
|
|
else
|
|
{
|
|
lane2Mat1Disabled = null;
|
|
lane2Mat2Disabled = null;
|
|
lane2Mat1DisabledActive = null;
|
|
lane2Mat2DisabledActive = null;
|
|
}
|
|
lane2Mat1DisabledActive = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterLaneDisabledOuter" + lanesNumber + ".mat");
|
|
lane2Mat2DisabledActive = null;
|
|
if (roadType == RoadTypeEnum.BothTurnLanes)
|
|
{
|
|
lane2Mat1DisabledActiveR = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterLaneDisabledOuterR.mat");
|
|
lane2Mat2DisabledActiveR = null;
|
|
lane3Mat1Disabled = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterLaneDisabledR.mat");
|
|
lane3Mat2Disabled = null;
|
|
}
|
|
else
|
|
{
|
|
lane2Mat1DisabledActiveR = null;
|
|
lane2Mat2DisabledActiveR = null;
|
|
lane3Mat1Disabled = null;
|
|
lane3Mat2Disabled = null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lane1Mat1Disabled = null;
|
|
lane1Mat2Disabled = null;
|
|
lane2Mat1Disabled = null;
|
|
lane2Mat2Disabled = null;
|
|
lane2Mat1DisabledActive = null;
|
|
lane2Mat2DisabledActive = null;
|
|
lane2Mat1DisabledActiveR = null;
|
|
lane2Mat2DisabledActiveR = null;
|
|
lane3Mat1Disabled = null;
|
|
lane3Mat2Disabled = null;
|
|
}
|
|
|
|
if (roadType == RoadTypeEnum.BothTurnLanes)
|
|
{
|
|
lane0Mat1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterWhiteLYellowR" + lanesNumber + ".mat");
|
|
lane0Mat2 = null;
|
|
lane1Mat1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterYellowLWhiteR.mat");
|
|
lane1Mat2 = null;
|
|
lane2Mat1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterWhiteR" + lanesNumber + ".mat");
|
|
lane2Mat2 = null;
|
|
lane3Mat1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterWhiteR.mat");
|
|
lane3Mat2 = null;
|
|
}
|
|
else if (roadType == RoadTypeEnum.TurnLane)
|
|
{
|
|
lane0Mat1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterWhiteLYellowR" + lanesNumber + ".mat");
|
|
lane0Mat2 = null;
|
|
lane1Mat1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterYellowLWhiteR.mat");
|
|
lane1Mat2 = null;
|
|
lane2Mat1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterWhiteR" + lanesNumber + ".mat");
|
|
lane2Mat2 = null;
|
|
lane3Mat1 = null;
|
|
lane3Mat2 = null;
|
|
}
|
|
else if (roadType == RoadTypeEnum.NoTurnLane)
|
|
{
|
|
lane0Mat1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterWhiteLYellowR" + lanesNumber + ".mat");
|
|
lane0Mat2 = null;
|
|
lane1Mat1 = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Markers/InterYellowLWhiteR" + lanesNumber + ".mat");
|
|
lane1Mat2 = null;
|
|
lane2Mat1 = null;
|
|
lane2Mat2 = null;
|
|
lane3Mat1 = null;
|
|
lane3Mat2 = null;
|
|
}
|
|
|
|
if (_isUpdate)
|
|
{
|
|
UpdateMaterials();
|
|
}
|
|
}
|
|
|
|
|
|
private void ApplyMaterials(List<MeshRenderer> _meshRenderers, Material _material1 = null, Material _material2 = null, Material _material3 = null)
|
|
{
|
|
if (_meshRenderers != null && _meshRenderers.Count > 0)
|
|
{
|
|
List<Material> MarkerExtStretchMats = new List<Material>();
|
|
|
|
if (_material1 != null)
|
|
{
|
|
MarkerExtStretchMats.Add(_material1);
|
|
if (_material2 != null)
|
|
{
|
|
MarkerExtStretchMats.Add(_material2);
|
|
if (_material3 != null)
|
|
{
|
|
MarkerExtStretchMats.Add(_material3);
|
|
}
|
|
}
|
|
}
|
|
|
|
Material[] meshMaterials = MarkerExtStretchMats.ToArray();
|
|
for (int i = 0; i < _meshRenderers.Count; i++)
|
|
{
|
|
_meshRenderers[i].materials = meshMaterials;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public void UpdateMaterials()
|
|
{
|
|
int childCount = transform.childCount;
|
|
List<MeshRenderer> extStretchMR = new List<MeshRenderer>();
|
|
List<MeshRenderer> extTiledMR = new List<MeshRenderer>();
|
|
MeshRenderer centerMR = null;
|
|
List<MeshRenderer> lane0MR = new List<MeshRenderer>();
|
|
List<MeshRenderer> lane1MR = new List<MeshRenderer>();
|
|
List<MeshRenderer> lane2MR = new List<MeshRenderer>();
|
|
List<MeshRenderer> lane3MR = new List<MeshRenderer>();
|
|
List<MeshRenderer> laneD1MR = new List<MeshRenderer>();
|
|
List<MeshRenderer> laneD3MR = new List<MeshRenderer>();
|
|
List<MeshRenderer> laneDA2MR = new List<MeshRenderer>();
|
|
List<MeshRenderer> laneDAR2MR = new List<MeshRenderer>();
|
|
List<MeshRenderer> laneD2MR = new List<MeshRenderer>();
|
|
List<MeshRenderer> laneDA1MR = new List<MeshRenderer>();
|
|
|
|
MeshRenderer childMesh;
|
|
string transformName = "";
|
|
for (int i = 0; i < childCount; i++)
|
|
{
|
|
childMesh = transform.GetChild(i).GetComponent<MeshRenderer>();
|
|
if(childMesh == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
transformName = childMesh.transform.name.ToLower();
|
|
if (transformName.Contains("-stretchext"))
|
|
{
|
|
extStretchMR.Add(childMesh);
|
|
continue;
|
|
}
|
|
if (transformName.Contains("-tiledext"))
|
|
{
|
|
extTiledMR.Add(childMesh);
|
|
continue;
|
|
}
|
|
if (transformName.Contains("centermarkers"))
|
|
{
|
|
centerMR = childMesh;
|
|
continue;
|
|
}
|
|
if (transformName.Contains("lane0"))
|
|
{
|
|
lane0MR.Add(childMesh);
|
|
continue;
|
|
}
|
|
if (transformName.Contains("lane1"))
|
|
{
|
|
lane1MR.Add(childMesh);
|
|
continue;
|
|
}
|
|
if (transformName.Contains("lane2"))
|
|
{
|
|
lane2MR.Add(childMesh);
|
|
continue;
|
|
}
|
|
if (transformName.Contains("lane3"))
|
|
{
|
|
lane3MR.Add(childMesh);
|
|
continue;
|
|
}
|
|
if (intersectionType == IntersectionTypeEnum.ThreeWay)
|
|
{
|
|
if (transformName.Contains("laned1"))
|
|
{
|
|
laneD1MR.Add(childMesh);
|
|
continue;
|
|
}
|
|
if (transformName.Contains("laned3"))
|
|
{
|
|
laneD3MR.Add(childMesh);
|
|
continue;
|
|
}
|
|
if (transformName.Contains("laneda2"))
|
|
{
|
|
laneDA2MR.Add(childMesh);
|
|
continue;
|
|
}
|
|
if (transformName.Contains("lanedar2"))
|
|
{
|
|
laneDAR2MR.Add(childMesh);
|
|
continue;
|
|
}
|
|
if (transformName.Contains("laned2"))
|
|
{
|
|
laneD2MR.Add(childMesh);
|
|
continue;
|
|
}
|
|
if (transformName.Contains("laneda1"))
|
|
{
|
|
laneDA1MR.Add(childMesh);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
ApplyMaterials(extStretchMR, markerExtStretch1, markerExtStretch2, markerExtStretch3);
|
|
ApplyMaterials(extTiledMR, markerExtTiled1, markerExtTiled2, markerExtTiled3);
|
|
|
|
// Center only uses 1 mesh renderer
|
|
if (centerMR != null)
|
|
{
|
|
List<Material> centerMats = new List<Material>();
|
|
|
|
if (markerCenter1 != null)
|
|
{
|
|
centerMats.Add(markerCenter1);
|
|
if (markerCenter2 != null)
|
|
{
|
|
centerMats.Add(markerCenter2);
|
|
if (markerCenter3 != null)
|
|
{
|
|
centerMats.Add(markerCenter3);
|
|
}
|
|
}
|
|
}
|
|
|
|
centerMR.materials = centerMats.ToArray();
|
|
}
|
|
|
|
|
|
ApplyMaterials(lane0MR, lane0Mat1, lane0Mat2);
|
|
ApplyMaterials(lane1MR, lane1Mat1, lane1Mat2);
|
|
ApplyMaterials(lane2MR, lane2Mat1, lane2Mat2);
|
|
ApplyMaterials(lane3MR, lane3Mat1, lane3Mat2);
|
|
ApplyMaterials(laneD1MR, lane1Mat1Disabled, lane1Mat2Disabled);
|
|
ApplyMaterials(laneD3MR, lane3Mat1Disabled, lane3Mat2Disabled);
|
|
ApplyMaterials(laneDA2MR, lane2Mat1DisabledActive, lane2Mat2DisabledActive);
|
|
ApplyMaterials(laneDAR2MR, lane2Mat1DisabledActiveR, lane2Mat2DisabledActiveR);
|
|
ApplyMaterials(laneD2MR, lane2Mat1Disabled, lane2Mat2Disabled);
|
|
ApplyMaterials(laneDA1MR, lane1Mat1DisabledActive, lane1Mat2DisabledActive);
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region "TrafficLights"
|
|
public void ToggleTrafficLightPoleColor()
|
|
{
|
|
string basePath = RoadEditorUtility.GetBasePath();
|
|
|
|
Material trafficLightMaterial = null;
|
|
if (isTrafficLightGray)
|
|
{
|
|
trafficLightMaterial = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Signs/InterTLB2.mat");
|
|
}
|
|
else
|
|
{
|
|
trafficLightMaterial = RoadEditorUtility.LoadMaterial(basePath + "/Materials/Signs/InterTLB1.mat");
|
|
}
|
|
int childCount = transform.childCount;
|
|
string transformName = "";
|
|
MeshRenderer MR = null;
|
|
Material[] materials = new Material[1];
|
|
materials[0] = trafficLightMaterial;
|
|
for (int index = 0; index < childCount; index++)
|
|
{
|
|
transformName = transform.GetChild(index).name.ToLower();
|
|
if (transformName.Contains("trafficlight"))
|
|
{
|
|
MR = transform.GetChild(index).GetComponent<MeshRenderer>();
|
|
MR.materials = materials;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public void TogglePointLights(bool _isLightsEnabled)
|
|
{
|
|
isLightsEnabled = _isLightsEnabled;
|
|
int cCount = transform.childCount;
|
|
Light[] fLights = null;
|
|
Transform tTrans = null;
|
|
for (int index = 0; index < cCount; index++)
|
|
{
|
|
if (transform.GetChild(index).name.ToLower().Contains("trafficlight"))
|
|
{
|
|
tTrans = transform.GetChild(index);
|
|
int childCount = tTrans.childCount;
|
|
for (int k = 0; k < childCount; k++)
|
|
{
|
|
if (tTrans.GetChild(k).name.ToLower().Contains("streetlight"))
|
|
{
|
|
fLights = tTrans.GetChild(k).GetComponentsInChildren<Light>();
|
|
if (fLights != null)
|
|
{
|
|
for (int j = 0; j < fLights.Length; j++)
|
|
{
|
|
fLights[j].enabled = isLightsEnabled;
|
|
fLights[j].range = streetLightRange;
|
|
fLights[j].intensity = streetLightIntensity;
|
|
fLights[j].color = streetLightColor;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public void ResetStreetLightSettings()
|
|
{
|
|
streetLightRange = 30f;
|
|
streetLightIntensity = 1f;
|
|
streetLightColor = new Color(1f, 0.7451f, 0.27451f, 1f);
|
|
TogglePointLights(isLightsEnabled);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|