private void RenderManualNodeOverlays(RenderManager.CameraInfo cameraInfo)
{
var nodeSimulation = TrafficLightSimulationManager.Instance.GetNodeSimulation(SelectedNodeId);
if (nodeSimulation == null || !nodeSimulation.IsManualLight())
{
return;
}
MainTool.DrawNodeCircle(cameraInfo, SelectedNodeId, true, false);
/*CustomSegmentLightsManager customTrafficLightsManager = CustomSegmentLightsManager.Instance;
*
* NodeGeometry nodeGeometry = NodeGeometry.Get(SelectedNodeId);
* foreach (SegmentEndGeometry end in nodeGeometry.SegmentEndGeometries) {
* if (end == null)
* continue;
*
* var colorGray = new Color(0.25f, 0.25f, 0.25f, 0.25f);
*
* var position = CalculateNodePositionForSegment(Singleton<NetManager>.instance.m_nodes.m_buffer[SelectedNodeId], end.SegmentId);
*
* var width = _hoveredButton[0] == end.SegmentId ? 11.25f : 10f;
* MainTool.DrawOverlayCircle(cameraInfo, colorGray, position, width, end.SegmentId != _hoveredButton[0]);
* }*/
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
if (MainTool.GetToolController().IsInsideUI || !Cursor.visible)
{
return;
}
// For current camera store its position and cast a ray via mouse position
Vector3 camPos = Singleton <SimulationManager> .instance.m_simulationView.m_position;
Camera currentCamera = Camera.main;
// Ray mouseRay = currentCamera.ScreenPointToRay(Input.mousePosition);
// Check if camera pos/angle has changed then re-filter the visible nodes
// Assumption: The states checked in this loop don't change while the tool is active
var currentCameraState = new CameraTransformValue(currentCamera);
if (!LastCachedCamera.Equals(currentCameraState))
{
CachedVisibleNodeIds.Clear();
LastCachedCamera = currentCameraState;
FilterVisibleNodes(camPos);
}
// Render the current hovered node as blue
if ((HoveredNodeId != 0) && Flags.MayHaveTrafficLight(HoveredNodeId))
{
MainTool.DrawNodeCircle(
cameraInfo,
HoveredNodeId,
Input.GetMouseButton(0),
false);
}
}
public override void OnPrimaryClickOverlay()
{
if (IsCursorInPanel())
{
return;
}
if (HoveredNodeId == 0)
{
return;
}
if ((Singleton <NetManager> .instance.m_nodes.m_buffer[HoveredNodeId].m_flags & NetNode.Flags.Junction) == NetNode.Flags.None)
{
return;
}
TrafficLightSimulation sim = TrafficLightSimulationManager.Instance.GetNodeSimulation(HoveredNodeId);
if (sim != null && sim.IsTimedLight())
{
MainTool.ShowTooltip(Translation.GetString("NODE_IS_TIMED_LIGHT"), Singleton <NetManager> .instance.m_nodes.m_buffer[HoveredNodeId].m_position);
return;
}
TrafficPriorityManager.Instance.RemovePrioritySegments(HoveredNodeId);
TrafficLightManager.Instance.ToggleTrafficLight(HoveredNodeId);
}
private bool IsPedestrianLightHovered(Rect myRect3, int segmentId, bool hoveredSegment, ICustomSegmentLights segmentLights)
{
if (!myRect3.Contains(Event.current.mousePosition))
{
return(hoveredSegment);
}
if (segmentLights.PedestrianLightState == null)
{
return(false);
}
_hoveredButton[0] = segmentId;
_hoveredButton[1] = 2;
if (!MainTool.CheckClicked())
{
return(true);
}
if (!segmentLights.ManualPedestrianMode)
{
segmentLights.ManualPedestrianMode = true;
}
else
{
segmentLights.ChangeLightPedestrian();
}
return(true);
}
private void PokeFace(Face face, int num)
{
var solid = face.Parent;
// Remove the face
solid.Faces.Remove(face);
face.Parent = null;
_selection.Remove(face);
var center = face.BoundingBox.Center + face.Plane.Normal * num;
foreach (var edge in face.GetEdges())
{
var v1 = face.Vertices.First(x => x.Location == edge.Start);
var v2 = face.Vertices.First(x => x.Location == edge.End);
var verts = new[] { v1.Location, v2.Location, center };
var f = new Face(Document.Map.IDGenerator.GetNextFaceID())
{
Parent = solid,
Plane = new Plane(verts[0], verts[1], verts[2]),
Colour = solid.Colour,
Texture = face.Texture.Clone()
};
f.Vertices.AddRange(verts.Select(x => new Vertex(x, face)));
f.UpdateBoundingBox();
f.AlignTextureToFace();
solid.Faces.Add(f);
_selection.Add(f);
}
solid.UpdateBoundingBox();
UpdateSelection();
MainTool.SetDirty(true, true);
}
public override void OnActivate()
{
base.OnActivate();
cursorInSecondaryPanel = false;
RefreshCurrentRestrictedSegmentIds();
MainTool.RequestOnscreenDisplayUpdate();
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
if (MainTool.GetToolController().IsInsideUI || !Cursor.visible)
{
return;
}
if (HoveredNodeId == 0)
{
return;
}
if (!Flags.mayHaveTrafficLight(HoveredNodeId))
{
return;
}
MainTool.DrawNodeCircle(cameraInfo, HoveredNodeId, Input.GetMouseButton(0), false);
/*
* var segment = Singleton<NetManager>.instance.m_segments.m_buffer[Singleton<NetManager>.instance.m_nodes.m_buffer[HoveredNodeId].m_segment0];
*
* Bezier3 bezier;
* bezier.a = Singleton<NetManager>.instance.m_nodes.m_buffer[HoveredNodeId].m_position;
* bezier.d = Singleton<NetManager>.instance.m_nodes.m_buffer[HoveredNodeId].m_position;
*
* var color = MainTool.GetToolColor(Input.GetMouseButton(0), false);
*
* NetSegment.CalculateMiddlePoints(bezier.a, segment.m_startDirection, bezier.d,
* segment.m_endDirection,
* false, false, out bezier.b, out bezier.c);
*
* MainTool.DrawOverlayBezier(cameraInfo, bezier, color);*/
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
if (MainTool.GetToolController().IsInsideUI || !Cursor.visible)
{
return;
}
// no highlight for existing priority node in sign mode
if (TrafficPriorityManager.Instance().IsPriorityNode(HoveredNodeId))
{
return;
}
if (HoveredNodeId == 0)
{
return;
}
if (!Flags.mayHaveTrafficLight(HoveredNodeId))
{
return;
}
MainTool.DrawNodeCircle(cameraInfo, HoveredNodeId, Input.GetMouseButton(0));
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
// Log._Debug($"Restrictions overlay {_cursorInSecondaryPanel} {HoveredNodeId} {SelectedNodeId} {HoveredSegmentId} {SelectedSegmentId}");
if (SelectedSegmentId != 0)
{
NetTool.RenderOverlay(
cameraInfo,
ref Singleton <NetManager> .instance.m_segments.m_buffer[SelectedSegmentId],
MainTool.GetToolColor(true, false),
MainTool.GetToolColor(true, false));
}
if (cursorInSecondaryPanel)
{
return;
}
if (HoveredSegmentId != 0 && HoveredSegmentId != SelectedSegmentId &&
!overlayHandleHovered)
{
NetTool.RenderOverlay(
cameraInfo,
ref Singleton <NetManager> .instance.m_segments.m_buffer[HoveredSegmentId],
MainTool.GetToolColor(false, false),
MainTool.GetToolColor(false, false));
}
}
public void ToggleTrafficLight(ushort nodeId, ref NetNode node, bool showMessageOnError = true)
{
ToggleTrafficLightError reason;
if (!TrafficLightManager.Instance.CanToggleTrafficLight(nodeId, !TrafficLightManager.Instance.HasTrafficLight(nodeId, ref node), ref node, out reason))
{
if (showMessageOnError)
{
switch (reason)
{
case ToggleTrafficLightError.HasTimedLight:
MainTool.ShowTooltip(Translation.GetString("NODE_IS_TIMED_LIGHT"));
break;
case ToggleTrafficLightError.IsLevelCrossing:
MainTool.ShowTooltip(Translation.GetString("Node_is_level_crossing"));
break;
default:
break;
}
}
return;
}
TrafficPriorityManager.Instance.RemovePrioritySignsFromNode(nodeId);
TrafficLightManager.Instance.ToggleTrafficLight(nodeId, ref node);
}
private int RenderSegmentSideOverlay(
RenderManager.CameraInfo cameraInfo,
ushort segmentId,
NetInfo.Direction finalDirection)
{
int count = 0;
bool pressed = Input.GetMouseButton(0);
Color color = MainTool.GetToolColor(pressed, false);
netService.IterateSegmentLanes(
segmentId,
(uint laneId,
ref NetLane lane,
NetInfo.Lane laneInfo,
ushort _,
ref NetSegment segment,
byte laneIndex) => {
bool render = (laneInfo.m_laneType & SpeedLimitManager.LANE_TYPES) != 0;
render &= (laneInfo.m_vehicleType & SpeedLimitManager.VEHICLE_TYPES) != 0;
render &= laneInfo.m_finalDirection == finalDirection;
if (render)
{
RenderLaneOverlay(cameraInfo, laneId);
count++;
}
return(true);
});
return(count);
}
private void DrawRestrictionsSign(bool viewOnly, Vector3 camPos, out Vector3 diff, Vector3 xu, Vector3 yu, float f, Vector3 zero, uint x, uint y, ref Color guiColor, Texture2D signTexture, out bool hoveredHandle)
{
Vector3 signCenter = zero + f * (float)x * xu + f * (float)y * yu; // in game coordinates
var signScreenPos = Camera.main.WorldToScreenPoint(signCenter);
signScreenPos.y = Screen.height - signScreenPos.y;
diff = signCenter - camPos;
var zoom = 1.0f / diff.magnitude * 100f * MainTool.GetBaseZoom();
var size = (viewOnly ? 0.8f : 1f) * vehicleRestrictionsSignSize * zoom;
var boundingBox = new Rect(signScreenPos.x - size / 2, signScreenPos.y - size / 2, size, size);
hoveredHandle = !viewOnly && TrafficManagerTool.IsMouseOver(boundingBox);
if (hoveredHandle)
{
// mouse hovering over sign
guiColor.a = 0.8f;
}
else
{
guiColor.a = 0.5f;
}
GUI.color = guiColor;
GUI.DrawTexture(boundingBox, signTexture);
}
private void DrawSign(bool viewOnly, bool small, ref Vector3 camPos, ref Vector3 xu, ref Vector3 yu, float f, ref Vector3 zero, int x, int y, Color guiColor, Texture2D signTexture, out bool hoveredHandle)
{
Vector3 signCenter = zero + f * (float)x * xu + f * (float)y * yu; // in game coordinates
Vector3 signScreenPos;
bool visible = MainTool.WorldToScreenPoint(signCenter, out signScreenPos);
if (!visible)
{
hoveredHandle = false;
return;
}
Vector3 diff = signCenter - camPos;
var zoom = 1.0f / diff.magnitude * 100f * MainTool.GetBaseZoom();
var size = (small ? 0.75f : 1f) * (viewOnly ? 0.8f : 1f) * junctionRestrictionsSignSize * zoom;
var boundingBox = new Rect(signScreenPos.x - size / 2, signScreenPos.y - size / 2, size, size);
hoveredHandle = !viewOnly && TrafficManagerTool.IsMouseOver(boundingBox);
guiColor.a = MainTool.GetHandleAlpha(hoveredHandle);
GUI.color = guiColor;
GUI.DrawTexture(boundingBox, signTexture);
}
private void BevelFace(Face face, int num)
{
var solid = face.Parent;
var vertexCoordinates = face.Vertices.ToDictionary(x => x, x => x.Location);
// Scale the face a bit and move it away by the bevel distance
face.Transform(new UnitScale(Coordinate.One * 0.9m, face.BoundingBox.Center), TransformFlags.TextureLock);
face.Transform(new UnitTranslate(face.Plane.Normal * num), TransformFlags.TextureLock);
foreach (var edge in face.GetEdges())
{
var v1 = face.Vertices.First(x => x.Location == edge.Start);
var v2 = face.Vertices.First(x => x.Location == edge.End);
var verts = new[] { vertexCoordinates[v1], vertexCoordinates[v2], v2.Location, v1.Location };
var f = new Face(Document.Map.IDGenerator.GetNextFaceID())
{
Parent = solid,
Plane = new Plane(verts[0], verts[1], verts[2]),
Colour = solid.Colour,
Texture = face.Texture.Clone()
};
f.Vertices.AddRange(verts.Select(x => new Vertex(x, face)));
f.UpdateBoundingBox();
f.AlignTextureToFace();
solid.Faces.Add(f);
_selection.Add(f);
}
solid.UpdateBoundingBox();
UpdateSelection();
MainTool.SetDirty(true, true);
}
private bool RightArrowLightMode(int segmentId, Vector3 screenPos, float lightWidth,
float pedestrianWidth, float zoom, float lightHeight, ICustomSegmentLight segmentDict, bool hoveredSegment)
{
SetAlpha(segmentId, 5);
var myRect5 =
new Rect(screenPos.x - lightWidth / 2 - lightWidth - pedestrianWidth + 5f * zoom,
screenPos.y - lightHeight / 2, lightWidth, lightHeight);
switch (segmentDict.LightRight)
{
case RoadBaseAI.TrafficLightState.Green:
GUI.DrawTexture(myRect5, TextureResources.GreenLightRightTexture2D);
break;
case RoadBaseAI.TrafficLightState.Red:
GUI.DrawTexture(myRect5, TextureResources.RedLightRightTexture2D);
break;
}
if (!myRect5.Contains(Event.current.mousePosition))
{
return(hoveredSegment);
}
_hoveredButton[0] = segmentId;
_hoveredButton[1] = 5;
if (!MainTool.CheckClicked())
{
return(true);
}
segmentDict.ChangeRightLight();
return(true);
}
public override void OnPrimaryClickOverlay()
{
#if DEBUG
bool logJunctions = DebugSwitch.JunctionRestrictions.Get();
#else
const bool logJunctions = false;
#endif
if (HoveredNodeId == 0)
{
return;
}
if (isAnyOverlayHandleHovered)
{
return;
}
if (!logJunctions &&
((Singleton <NetManager> .instance.m_nodes.m_buffer[HoveredNodeId].m_flags &
(NetNode.Flags.Junction | NetNode.Flags.Bend)) == NetNode.Flags.None))
{
return;
}
SelectedNodeId = HoveredNodeId;
MainTool.RequestOnscreenDisplayUpdate();
// prevent accidential activation of signs on node selection (TODO [issue #740] improve this !)
MainTool.CheckClicked();
}
public override void OnActivate()
{
base.OnActivate();
Log._Debug("LaneConnectorTool: OnActivate");
SelectedNodeId = 0;
MainTool.RequestOnscreenDisplayUpdate();
RefreshCurrentRestrictedNodeIds();
}
public override void OnSecondaryClickOverlay()
{
if (!IsCursorInPanel())
{
SelectedSegmentId = 0;
MainTool.RequestOnscreenDisplayUpdate();
}
}
public override void SelectionChanged()
{
((ScaleControl)Control).ResetValue();
if (MainTool.GetSelectedPoints().Any())
{
ResetOrigin(null);
}
}
private void SetAlpha(int segmentId, int buttonId)
{
var guiColor = GUI.color;
guiColor.a = MainTool.GetHandleAlpha(_hoveredButton[0] == segmentId && _hoveredButton[1] == buttonId);
GUI.color = guiColor;
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
if (MainTool.GetToolController().IsInsideUI || !Cursor.visible)
{
return;
}
if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
{
// draw hovered segments
if (HoveredSegmentId != 0)
{
Color color = MainTool.GetToolColor(Input.GetMouseButton(0), false);
SegmentTraverser.Traverse(
HoveredSegmentId,
TraverseDirection.AnyDirection,
TraverseSide.Straight,
SegmentStopCriterion.None,
data => {
NetTool.RenderOverlay(
cameraInfo,
ref Singleton <NetManager> .instance.m_segments.m_buffer[
data.CurSeg.segmentId],
color,
color);
return(true);
});
}
else
{
massEditMode = PrioritySignsMassEditMode.MainYield;
}
return;
}
massEditMode = PrioritySignsMassEditMode.MainYield;
if (HoveredNodeId == SelectedNodeId)
{
return;
}
// no highlight for existing priority node in sign mode
if (TrafficPriorityManager.Instance.HasNodePrioritySign(HoveredNodeId))
{
// Log._Debug($"PrioritySignsTool.RenderOverlay: HasNodePrioritySign({HoveredNodeId})=true");
return;
}
if (!TrafficPriorityManager.Instance.MayNodeHavePrioritySigns(HoveredNodeId))
{
// Log._Debug($"PrioritySignsTool.RenderOverlay: MayNodeHavePrioritySigns({HoveredNodeId})=false");
return;
}
MainTool.DrawNodeCircle(cameraInfo, HoveredNodeId, Input.GetMouseButton(0));
}
private void RenderManualSelectionOverlay(RenderManager.CameraInfo cameraInfo)
{
if (HoveredNodeId == 0)
{
return;
}
MainTool.DrawNodeCircle(cameraInfo, HoveredNodeId, false, false);
}
/// <summary>Called from GenericFsm when a segment is clicked to show lane arrows GUI.</summary>
private void OnEnterEditorState()
{
int numLanes = GeometryUtil.GetSegmentNumVehicleLanes(
SelectedSegmentId,
SelectedNodeId,
out int numDirections,
LaneArrowManager.VEHICLE_TYPES);
if (numLanes <= 0)
{
SelectedNodeId = 0;
SelectedSegmentId = 0;
return;
}
// Vector3 nodePos = Singleton<NetManager>
// .instance.m_nodes.m_buffer[SelectedNodeId].m_position;
//
// // Hide if node position is off-screen
//
// bool visible = GeometryUtil.WorldToScreenPoint(nodePos, out Vector3 screenPos);
//
// // if (!visible) {
// // return;
// // }
//
// Vector3 camPos = Singleton<SimulationManager>.instance.m_simulationView.m_position;
// Vector3 diff = nodePos - camPos;
//
// if (diff.sqrMagnitude > TrafficManagerTool.MAX_OVERLAY_DISTANCE_SQR) {
// return; // do not draw if too distant
// }
// Calculate lanes and arrows
NetSegment[] segmentsBuffer = Singleton <NetManager> .instance.m_segments.m_buffer;
IList <LanePos> laneList = Constants.ServiceFactory.NetService.GetSortedLanes(
SelectedSegmentId,
ref segmentsBuffer[SelectedSegmentId],
segmentsBuffer[SelectedSegmentId].m_startNode == SelectedNodeId,
LaneArrowManager.LANE_TYPES,
LaneArrowManager.VEHICLE_TYPES,
true);
bool?startNode = Constants.ServiceFactory.NetService.IsStartNode(SelectedSegmentId, SelectedNodeId);
if (startNode == null)
{
Log.Error(
$"LaneArrowTool._guiLaneChangeWindow: Segment {SelectedSegmentId} " +
$"is not connected to node {SelectedNodeId}");
return;
}
CreateLaneArrowsWindow(laneList.Count);
SetupLaneArrowsWindowButtons(laneList: laneList,
startNode: (bool)startNode);
MainTool.RequestOnscreenDisplayUpdate();
}
private void RenderManualNodeOverlays(RenderManager.CameraInfo cameraInfo)
{
if (!TrafficLightSimulationManager.Instance.HasManualSimulation(SelectedNodeId))
{
return;
}
MainTool.DrawNodeCircle(cameraInfo, SelectedNodeId, true, false);
}
public override void OnToolGUI(Event e)
{
// base.OnToolGUI(e);
cursorInSecondaryPanel_ = false;
if ((SelectedNodeId == 0) || (SelectedSegmentId == 0))
{
return;
}
int numLanes = TrafficManagerTool.GetSegmentNumVehicleLanes(
SelectedSegmentId,
SelectedNodeId,
out int numDirections,
LaneArrowManager.VEHICLE_TYPES);
if (numLanes <= 0)
{
SelectedNodeId = 0;
SelectedSegmentId = 0;
return;
}
Vector3 nodePos = Singleton <NetManager>
.instance.m_nodes.m_buffer[SelectedNodeId].m_position;
bool visible = MainTool.WorldToScreenPoint(nodePos, out Vector3 screenPos);
if (!visible)
{
return;
}
Vector3 camPos = Singleton <SimulationManager> .instance.m_simulationView.m_position;
Vector3 diff = nodePos - camPos;
if (diff.sqrMagnitude > TrafficManagerTool.MAX_OVERLAY_DISTANCE_SQR)
{
return; // do not draw if too distant
}
int width = numLanes * 128;
int height = 50;
bool startNode = (bool)netService.IsStartNode(SelectedSegmentId, SelectedNodeId);
if (CanReset(SelectedSegmentId, startNode))
{
height += 40;
}
var windowRect3 = new Rect(screenPos.x - (width / 2), screenPos.y - 70, width, height);
GUILayout.Window(250, windowRect3, GuiLaneChangeWindow, string.Empty, BorderlessStyle);
cursorInSecondaryPanel_ = windowRect3.Contains(Event.current.mousePosition);
}
private bool ForwardArrowLightMode(int segmentId,
float lightWidth,
bool hasRightSegment,
Vector3 screenPos,
float pedestrianWidth,
float zoom,
float lightHeight,
ICustomSegmentLight segmentDict,
bool hoveredSegment)
{
SetAlpha(segmentId, 4);
float offsetLight = lightWidth;
if (hasRightSegment)
{
offsetLight += lightWidth;
}
var myRect6 =
new Rect(
screenPos.x - (lightWidth / 2) - offsetLight - pedestrianWidth + (5f * zoom),
screenPos.y - (lightHeight / 2),
lightWidth,
lightHeight);
switch (segmentDict.LightMain)
{
case RoadBaseAI.TrafficLightState.Green: {
GUI.DrawTexture(myRect6, TrafficLightTextures.GreenLightStraight);
break;
}
case RoadBaseAI.TrafficLightState.Red: {
GUI.DrawTexture(myRect6, TrafficLightTextures.RedLightStraight);
break;
}
}
if (!myRect6.Contains(Event.current.mousePosition))
{
return(hoveredSegment);
}
hoveredButton[0] = segmentId;
hoveredButton[1] = 4;
if (!MainTool.CheckClicked())
{
return(true);
}
segmentDict.ChangeMainLight();
return(true);
}
public override void OnToolGUI(Event e)
{
//base.OnToolGUI(e);
_cursorInSecondaryPanel = false;
if (SelectedNodeId == 0 || SelectedSegmentId == 0)
{
return;
}
int numDirections;
int numLanes = TrafficManagerTool.GetSegmentNumVehicleLanes(SelectedSegmentId, SelectedNodeId, out numDirections, LaneArrowManager.VEHICLE_TYPES);
if (numLanes <= 0)
{
SelectedNodeId = 0;
SelectedSegmentId = 0;
return;
}
var style = new GUIStyle {
normal = { background = SecondPanelTexture },
alignment = TextAnchor.MiddleCenter,
border =
{
bottom = 2,
top = 2,
right = 2,
left = 2
}
};
Vector3 nodePos = Singleton <NetManager> .instance.m_nodes.m_buffer[SelectedNodeId].m_position;
Vector3 screenPos;
bool visible = MainTool.WorldToScreenPoint(nodePos, out screenPos);
if (!visible)
{
return;
}
var camPos = Singleton <SimulationManager> .instance.m_simulationView.m_position;
var diff = nodePos - camPos;
if (diff.magnitude > TrafficManagerTool.MaxOverlayDistance)
{
return; // do not draw if too distant
}
int width = numLanes * 128;
var windowRect3 = new Rect(screenPos.x - width / 2, screenPos.y - 70, width, 50);
GUILayout.Window(250, windowRect3, _guiLaneChangeWindow, "", style);
_cursorInSecondaryPanel = windowRect3.Contains(Event.current.mousePosition);
}
public override void OnPrimaryClickOverlay()
{
if ((HoveredNodeId == 0) || (HoveredSegmentId == 0))
{
return;
}
NetNode.Flags netFlags = Singleton <NetManager> .instance.m_nodes.m_buffer[HoveredNodeId].m_flags;
if ((netFlags & NetNode.Flags.Junction) == NetNode.Flags.None)
{
return;
}
NetSegment[] segmentsBuffer = Singleton <NetManager> .instance.m_segments.m_buffer;
if ((segmentsBuffer[HoveredSegmentId].m_startNode != HoveredNodeId) &&
(segmentsBuffer[HoveredSegmentId].m_endNode != HoveredNodeId))
{
return;
}
bool ctrlDown = Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl);
bool altDown = Input.GetKey(KeyCode.LeftAlt) || Input.GetKey(KeyCode.RightAlt);
SetLaneArrowError res = SetLaneArrowError.Success;
if (altDown)
{
LaneArrowManager.SeparateTurningLanes.SeparateSegmentLanes(HoveredSegmentId, HoveredNodeId, out res);
}
else if (ctrlDown)
{
LaneArrowManager.SeparateTurningLanes.SeparateNode(HoveredNodeId, out res);
}
else if (HasHoverLaneArrows())
{
SelectedSegmentId = HoveredSegmentId;
SelectedNodeId = HoveredNodeId;
}
switch (res)
{
case SetLaneArrowError.HighwayArrows: {
MainTool.ShowError(
Translation.LaneRouting.Get("Dialog.Text:Disabled due to highway rules"));
break;
}
case SetLaneArrowError.LaneConnection: {
MainTool.ShowError(
Translation.LaneRouting.Get("Dialog.Text:Disabled due to manual connection"));
break;
}
}
}
private bool RayCastSegmentAndNode(out ToolBase.RaycastOutput output)
{
ToolBase.RaycastInput input = new ToolBase.RaycastInput(Camera.main.ScreenPointToRay(Input.mousePosition), Camera.main.farClipPlane);
input.m_netService.m_service = ItemClass.Service.Road;
input.m_netService.m_itemLayers = ItemClass.Layer.Default | ItemClass.Layer.MetroTunnels;
input.m_ignoreSegmentFlags = NetSegment.Flags.None;
input.m_ignoreNodeFlags = NetNode.Flags.None;
input.m_ignoreTerrain = true;
return(MainTool.DoRayCast(input, out output));
}
private void UpdateSelection()
{
foreach (var s in MainTool.GetCopies())
{
s.IsSelected = false;
foreach (var f in s.Faces)
{
f.IsSelected = _selection.Contains(f);
}
}
}
