private void RenderLanes(RenderManager.CameraInfo cameraInfo)
{
if (!MultiSegmentMode)
{
RenderLaneOverlay(cameraInfo, renderData_.LaneId);
}
else
{
bool LaneVisitorFun(SegmentLaneTraverser.SegmentLaneVisitData data)
{
if (data.SortedLaneIndex == renderData_.SortedLaneIndex)
{
RenderLaneOverlay(cameraInfo, data.CurLanePos.laneId);
}
return(true);
}
SegmentLaneTraverser.Traverse(
renderData_.SegmentId,
SegmentTraverser.TraverseDirection.AnyDirection,
SegmentTraverser.TraverseSide.AnySide,
SegmentLaneTraverser.LaneStopCriterion.LaneCount,
SegmentTraverser.SegmentStopCriterion.Junction,
SpeedLimitManager.LANE_TYPES,
SpeedLimitManager.VEHICLE_TYPES,
LaneVisitorFun);
}
}
private void RenderRoadParkings(RenderManager.CameraInfo cameraInfo)
{
NetLane[] laneBuffer = NetManager.instance.m_lanes.m_buffer;
bool LaneVisitor(SegmentLaneVisitData data)
{
ushort segmentId = data.SegVisitData.CurSeg.segmentId;
int laneIndex = data.CurLanePos.laneIndex;
NetInfo.Lane laneInfo = segmentId.ToSegment().Info.m_lanes[laneIndex];
NetInfo.Direction finalDirection = laneInfo.m_finalDirection;
if (!data.SegVisitData.Initial)
{
bool reverse =
data.SegVisitData.ViaStartNode ==
data.SegVisitData.ViaInitialStartNode;
bool invert1 = segmentId.ToSegment().m_flags.IsFlagSet(NetSegment.Flags.Invert);
bool invert2 = renderInfo_.SegmentId.ToSegment().m_flags.IsFlagSet(NetSegment.Flags.Invert);
bool invert = invert1 != invert2;
if (reverse ^ invert)
{
finalDirection = NetInfo.InvertDirection(finalDirection);
}
}
if (finalDirection == renderInfo_.FinalDirection)
{
bool pressed = Input.GetMouseButton(0);
Color color = MainTool.GetToolColor(pressed, false);
uint otherLaneId = data.CurLanePos.laneId;
var laneMarker = new SegmentLaneMarker(laneBuffer[otherLaneId].m_bezier);
laneMarker.RenderOverlay(cameraInfo, color, enlarge: pressed);
}
return(true);
}
SegmentLaneTraverser.Traverse(
renderInfo_.SegmentId,
SegmentTraverser.TraverseDirection.AnyDirection,
SegmentTraverser.TraverseSide.AnySide,
SegmentLaneTraverser.LaneStopCriterion.LaneCount,
SegmentTraverser.SegmentStopCriterion.Junction,
ParkingRestrictionsManager.LANE_TYPES,
ParkingRestrictionsManager.VEHICLE_TYPES,
LaneVisitor);
}
private void ApplyRestrictionsToAllSegments(int?sortedLaneIndex = null)
{
NetManager netManager = Singleton <NetManager> .instance;
NetInfo selectedSegmentInfo = netManager.m_segments.m_buffer[SelectedSegmentId].Info;
ushort selectedStartNodeId = netManager.m_segments.m_buffer[SelectedSegmentId].m_startNode;
ushort selectedEndNodeId = netManager.m_segments.m_buffer[SelectedSegmentId].m_endNode;
SegmentLaneTraverser.Traverse(SelectedSegmentId, SegmentTraverser.TraverseDirection.AnyDirection, SegmentTraverser.TraverseSide.AnySide, SegmentLaneTraverser.LaneStopCriterion.LaneCount, SegmentTraverser.SegmentStopCriterion.Junction, VehicleRestrictionsManager.LANE_TYPES, VehicleRestrictionsManager.VEHICLE_TYPES, delegate(SegmentLaneVisitData data) {
if (data.segVisitData.initial)
{
return(true);
}
if (sortedLaneIndex != null && data.sortedLaneIndex != sortedLaneIndex)
{
return(true);
}
ushort segmentId = data.segVisitData.curGeo.SegmentId;
NetInfo segmentInfo = netManager.m_segments.m_buffer[segmentId].Info;
uint selectedLaneId = data.initLanePos.laneId;
byte selectedLaneIndex = data.initLanePos.laneIndex;
NetInfo.Lane selectedLaneInfo = selectedSegmentInfo.m_lanes[selectedLaneIndex];
uint laneId = data.curLanePos.laneId;
byte laneIndex = data.curLanePos.laneIndex;
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
ExtVehicleType baseMask = VehicleRestrictionsManager.Instance.GetBaseMask(laneInfo, VehicleRestrictionsMode.Configured);
if (baseMask == ExtVehicleType.None)
{
return(true);
}
// apply restrictions of selected segment & lane
ExtVehicleType mask = ~VehicleRestrictionsManager.EXT_VEHICLE_TYPES & baseMask; // ban all possible controllable vehicles
mask |= VehicleRestrictionsManager.EXT_VEHICLE_TYPES & VehicleRestrictionsManager.Instance.GetAllowedVehicleTypes(SelectedSegmentId, selectedSegmentInfo, selectedLaneIndex, selectedLaneInfo, VehicleRestrictionsMode.Configured); // allow all enabled and controllable vehicles
VehicleRestrictionsManager.Instance.SetAllowedVehicleTypes(segmentId, segmentInfo, laneIndex, laneInfo, laneId, mask);
RefreshCurrentRestrictedSegmentIds(segmentId);
return(true);
});
}
/// <summary>
/// highlitghts all the lanes with the same sorted index as the current lane.
/// </summary>
private void RenderRoadLane(RenderManager.CameraInfo cameraInfo)
{
SegmentLaneTraverser.Traverse(
renderData_.segmentId,
SegmentTraverser.TraverseDirection.AnyDirection,
SegmentTraverser.TraverseSide.AnySide,
SegmentLaneTraverser.LaneStopCriterion.LaneCount,
SegmentTraverser.SegmentStopCriterion.Junction,
SpeedLimitManager.LANE_TYPES,
SpeedLimitManager.VEHICLE_TYPES,
data => {
if (renderData_.SortedLaneIndex == data.SortedLaneIndex)
{
RenderLaneOverlay(cameraInfo, data.CurLanePos.laneId);
}
return(true);
});
}
private void DrawSpeedLimitHandles(ushort segmentId,
ref NetSegment segment,
bool viewOnly,
ref Vector3 camPos)
{
if (viewOnly && !Options.speedLimitsOverlay)
{
return;
}
Vector3 center = segment.m_bounds.center;
NetManager netManager = Singleton <NetManager> .instance;
SpeedValue speedLimitToSet = viewOnly
? new SpeedValue(-1f)
: currentPaletteSpeedLimit;
bool showPerLane = showLimitsPerLane;
if (!viewOnly)
{
showPerLane = showLimitsPerLane ^
(Input.GetKey(KeyCode.LeftControl) ||
Input.GetKey(KeyCode.RightControl));
}
// US signs are rectangular, all other are round
float speedLimitSignVerticalScale = GetVerticalTextureScale();
if (showPerLane)
{
// show individual speed limit handle per lane
int numLanes = TrafficManagerTool.GetSegmentNumVehicleLanes(
segmentId,
null,
out int numDirections,
SpeedLimitManager.VEHICLE_TYPES);
NetInfo segmentInfo = segment.Info;
Vector3 yu = (segment.m_endDirection - segment.m_startDirection).normalized;
Vector3 xu = Vector3.Cross(yu, new Vector3(0, 1f, 0)).normalized;
// if ((segment.m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) {
// xu = -xu; }
float f = viewOnly ? 4f : 7f; // reserved sign size in game coordinates
Vector3 zero = center - (0.5f * (((numLanes - 1) + numDirections) - 1) * f * xu);
uint x = 0;
IList <LanePos> sortedLanes = Constants.ServiceFactory.NetService.GetSortedLanes(
segmentId,
ref segment,
null,
SpeedLimitManager.LANE_TYPES,
SpeedLimitManager.VEHICLE_TYPES);
bool onlyMonorailLanes = sortedLanes.Count > 0;
if (!viewOnly)
{
foreach (LanePos laneData in sortedLanes)
{
byte laneIndex = laneData.laneIndex;
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Monorail) ==
VehicleInfo.VehicleType.None)
{
onlyMonorailLanes = false;
break;
}
}
}
var directions = new HashSet <NetInfo.Direction>();
int sortedLaneIndex = -1;
foreach (LanePos laneData in sortedLanes)
{
++sortedLaneIndex;
uint laneId = laneData.laneId;
byte laneIndex = laneData.laneIndex;
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
if (!directions.Contains(laneInfo.m_finalDirection))
{
if (directions.Count > 0)
{
++x; // space between different directions
}
directions.Add(laneInfo.m_finalDirection);
}
SpeedValue laneSpeedLimit = new SpeedValue(
SpeedLimitManager.Instance.GetCustomSpeedLimit(laneId));
bool hoveredHandle = MainTool.DrawGenericOverlayGridTexture(
SpeedLimitTextures.GetSpeedLimitTexture(laneSpeedLimit),
camPos,
zero,
f,
f,
xu,
yu,
x,
0,
speedLimitSignSize,
speedLimitSignSize * speedLimitSignVerticalScale,
!viewOnly);
if (!viewOnly &&
!onlyMonorailLanes &&
((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Monorail) !=
VehicleInfo.VehicleType.None))
{
Texture2D tex1 = RoadUITextures.VehicleInfoSignTextures[
LegacyExtVehicleType.ToNew(ExtVehicleType.PassengerTrain)];
MainTool.DrawStaticSquareOverlayGridTexture(
tex1,
camPos,
zero,
f,
xu,
yu,
x,
1,
speedLimitSignSize);
}
if (hoveredHandle)
{
}
if (hoveredHandle && Input.GetMouseButton(0) && !IsCursorInPanel())
{
SpeedLimitManager.Instance.SetSpeedLimit(
segmentId,
laneIndex,
laneInfo,
laneId,
speedLimitToSet.GameUnits);
if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
{
int slIndexCopy = sortedLaneIndex;
SegmentLaneTraverser.Traverse(
segmentId,
SegmentTraverser.TraverseDirection.AnyDirection,
SegmentTraverser.TraverseSide.AnySide,
SegmentLaneTraverser.LaneStopCriterion.LaneCount,
SegmentTraverser.SegmentStopCriterion.Junction,
SpeedLimitManager.LANE_TYPES,
SpeedLimitManager.VEHICLE_TYPES,
data => {
if (data.SegVisitData.Initial)
{
return(true);
}
if (slIndexCopy != data.SortedLaneIndex)
{
return(true);
}
Constants.ServiceFactory.NetService.ProcessSegment(
data.SegVisitData.CurSeg.segmentId,
(ushort curSegmentId, ref NetSegment curSegment) =>
{
NetInfo.Lane curLaneInfo = curSegment.Info.m_lanes[
data.CurLanePos.laneIndex];
SpeedLimitManager.Instance.SetSpeedLimit(
curSegmentId,
data.CurLanePos.laneIndex,
curLaneInfo,
data.CurLanePos.laneId,
speedLimitToSet.GameUnits);
return(true);
});
return(true);
});
}
}
++x;
}
}
else
{
// draw speedlimits over mean middle points of lane beziers
if (!segmentCenterByDir.TryGetValue(
segmentId,
out Dictionary <NetInfo.Direction, Vector3> segCenter))
{
segCenter = new Dictionary <NetInfo.Direction, Vector3>();
segmentCenterByDir.Add(segmentId, segCenter);
TrafficManagerTool.CalculateSegmentCenterByDir(segmentId, segCenter);
}
foreach (KeyValuePair <NetInfo.Direction, Vector3> e in segCenter)
{
bool visible = MainTool.WorldToScreenPoint(e.Value, out Vector3 screenPos);
if (!visible)
{
continue;
}
float zoom = (1.0f / (e.Value - camPos).magnitude) * 100f * MainTool.GetBaseZoom();
float size = (viewOnly ? 0.8f : 1f) * speedLimitSignSize * zoom;
Color guiColor = GUI.color;
var boundingBox = new Rect(screenPos.x - (size / 2),
screenPos.y - (size / 2),
size,
size * speedLimitSignVerticalScale);
bool hoveredHandle = !viewOnly && TrafficManagerTool.IsMouseOver(boundingBox);
guiColor.a = TrafficManagerTool.GetHandleAlpha(hoveredHandle);
if (hoveredHandle)
{
// mouse hovering over sign
}
// Draw something right here, the road sign texture
GUI.color = guiColor;
SpeedValue displayLimit = new SpeedValue(
SpeedLimitManager.Instance.GetCustomSpeedLimit(segmentId, e.Key));
Texture2D tex = SpeedLimitTextures.GetSpeedLimitTexture(displayLimit);
GUI.DrawTexture(boundingBox, tex);
if (hoveredHandle && Input.GetMouseButton(0) && !IsCursorInPanel())
{
// change the speed limit to the selected one
// Log._Debug($"Setting speed limit of segment {segmentId}, dir {e.Key.ToString()}
// to {speedLimitToSet}");
SpeedLimitManager.Instance.SetSpeedLimit(segmentId,
e.Key,
currentPaletteSpeedLimit.GameUnits);
if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
{
NetInfo.Direction normDir = e.Key;
if ((netManager.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Invert) != NetSegment.Flags.None)
{
normDir = NetInfo.InvertDirection(normDir);
}
SegmentLaneTraverser.Traverse(
segmentId,
SegmentTraverser.TraverseDirection.AnyDirection,
SegmentTraverser.TraverseSide.AnySide,
SegmentLaneTraverser.LaneStopCriterion.LaneCount,
SegmentTraverser.SegmentStopCriterion.Junction,
SpeedLimitManager.LANE_TYPES,
SpeedLimitManager.VEHICLE_TYPES,
data =>
{
if (data.SegVisitData.Initial)
{
return(true);
}
bool reverse =
data.SegVisitData.ViaStartNode
== data.SegVisitData.ViaInitialStartNode;
ushort otherSegmentId = data.SegVisitData.CurSeg.segmentId;
NetInfo otherSegmentInfo =
netManager.m_segments.m_buffer[otherSegmentId].Info;
byte laneIndex = data.CurLanePos.laneIndex;
NetInfo.Lane laneInfo = otherSegmentInfo.m_lanes[laneIndex];
NetInfo.Direction otherNormDir = laneInfo.m_finalDirection;
if (((netManager.m_segments.m_buffer[otherSegmentId].m_flags
& NetSegment.Flags.Invert)
!= NetSegment.Flags.None) ^ reverse)
{
otherNormDir = NetInfo.InvertDirection(otherNormDir);
}
if (otherNormDir == normDir)
{
SpeedLimitManager.Instance.SetSpeedLimit(
otherSegmentId,
laneInfo.m_finalDirection,
speedLimitToSet.GameUnits);
}
return(true);
});
}
}
guiColor.a = 1f;
GUI.color = guiColor;
}
}
}
private bool DrawParkingRestrictionHandles(ushort segmentId,
bool clicked,
ref NetSegment segment,
bool viewOnly,
ref Vector3 camPos)
{
if (viewOnly && !Options.parkingRestrictionsOverlay)
{
return(false);
}
NetManager netManager = Singleton <NetManager> .instance;
ParkingRestrictionsManager parkingManager = ParkingRestrictionsManager.Instance;
bool hovered = false;
// draw parking restriction signs over mean middle points of lane beziers
if (!segmentCenterByDir.TryGetValue(
segmentId,
out Dictionary <NetInfo.Direction, Vector3> segCenter))
{
segCenter = new Dictionary <NetInfo.Direction, Vector3>();
segmentCenterByDir.Add(segmentId, segCenter);
TrafficManagerTool.CalculateSegmentCenterByDir(segmentId, segCenter);
}
foreach (KeyValuePair <NetInfo.Direction, Vector3> e in segCenter)
{
bool allowed = parkingManager.IsParkingAllowed(segmentId, e.Key);
if (allowed && viewOnly)
{
continue;
}
bool visible = MainTool.WorldToScreenPoint(e.Value, out Vector3 screenPos);
if (!visible)
{
continue;
}
float zoom = (1.0f / (e.Value - camPos).magnitude) * 100f * MainTool.GetBaseZoom();
float size = (viewOnly ? 0.8f : 1f) * SIGN_SIZE * zoom;
Color guiColor = GUI.color;
Rect boundingBox = new Rect(
screenPos.x - (size / 2),
screenPos.y - (size / 2),
size,
size);
if (Options.speedLimitsOverlay)
{
boundingBox.y -= size + 10f;
}
bool hoveredHandle = !viewOnly && TrafficManagerTool.IsMouseOver(boundingBox);
guiColor.a = TrafficManagerTool.GetHandleAlpha(hoveredHandle);
if (hoveredHandle)
{
// mouse hovering over sign
hovered = true;
}
GUI.color = guiColor;
GUI.DrawTexture(boundingBox, RoadUITextures.ParkingRestrictionTextures[allowed]);
if (hoveredHandle && clicked && !IsCursorInPanel() &&
parkingManager.ToggleParkingAllowed(segmentId, e.Key))
{
allowed = !allowed;
if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
{
NetInfo.Direction normDir = e.Key;
if ((netManager.m_segments.m_buffer[segmentId].m_flags &
NetSegment.Flags.Invert) != NetSegment.Flags.None)
{
normDir = NetInfo.InvertDirection(normDir);
}
bool LaneVisitor(SegmentLaneVisitData data)
{
if (data.SegVisitData.Initial)
{
return(true);
}
bool reverse = data.SegVisitData.ViaStartNode ==
data.SegVisitData.ViaInitialStartNode;
ushort otherSegmentId = data.SegVisitData.CurSeg.segmentId;
NetInfo otherSegmentInfo =
netManager.m_segments.m_buffer[otherSegmentId].Info;
byte laneIndex = data.CurLanePos.laneIndex;
NetInfo.Lane laneInfo = otherSegmentInfo.m_lanes[laneIndex];
NetInfo.Direction otherNormDir = laneInfo.m_finalDirection;
if (((netManager.m_segments.m_buffer[otherSegmentId].m_flags &
NetSegment.Flags.Invert) != NetSegment.Flags.None) ^ reverse)
{
otherNormDir = NetInfo.InvertDirection(otherNormDir);
}
if (otherNormDir == normDir)
{
parkingManager.SetParkingAllowed(
otherSegmentId,
laneInfo.m_finalDirection,
allowed);
}
return(true);
}
SegmentLaneTraverser.Traverse(
segmentId,
SegmentTraverser.TraverseDirection.AnyDirection,
SegmentTraverser.TraverseSide.AnySide,
SegmentLaneTraverser.LaneStopCriterion.LaneCount,
SegmentTraverser.SegmentStopCriterion.Junction,
ParkingRestrictionsManager.LANE_TYPES,
ParkingRestrictionsManager.VEHICLE_TYPES,
LaneVisitor);
}
}
guiColor.a = 1f;
GUI.color = guiColor;
}
return(hovered);
}
/// <summary>
/// coppies vehicle restrictions of the current segment
/// and applies them to all segments until the next junction.
/// </summary>
/// <param name="sortedLaneIndex">if provided only current lane is considered</param>
/// <param name="vehicleTypes">
/// if provided only bits for which vehicleTypes is set are considered.
/// </param>
private void ApplyRestrictionsToAllSegments(
int?sortedLaneIndex = null,
ExtVehicleType?vehicleTypes = null)
{
NetManager netManager = Singleton <NetManager> .instance;
NetInfo selectedSegmentInfo = netManager.m_segments.m_buffer[SelectedSegmentId].Info;
bool LaneVisitorFun(SegmentLaneVisitData data)
{
if (data.SegVisitData.Initial)
{
return(true);
}
if (sortedLaneIndex != null && data.SortedLaneIndex != sortedLaneIndex)
{
return(true);
}
ushort segmentId = data.SegVisitData.CurSeg.segmentId;
NetInfo segmentInfo = netManager.m_segments.m_buffer[segmentId].Info;
byte selectedLaneIndex = data.InitLanePos.laneIndex;
NetInfo.Lane selectedLaneInfo = selectedSegmentInfo.m_lanes[selectedLaneIndex];
uint laneId = data.CurLanePos.laneId;
byte laneIndex = data.CurLanePos.laneIndex;
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
// apply restrictions of selected segment & lane
ExtVehicleType mask =
VehicleRestrictionsManager.Instance.GetAllowedVehicleTypes(
SelectedSegmentId,
selectedSegmentInfo,
selectedLaneIndex,
selectedLaneInfo,
VehicleRestrictionsMode.Configured);;
if (vehicleTypes != null)
{
ExtVehicleType currentMask =
VehicleRestrictionsManager.Instance.GetAllowedVehicleTypes(
segmentId,
segmentInfo,
laneIndex,
laneInfo,
VehicleRestrictionsMode.Configured);
// only apply changes where types is 1. that means:
// for bits where types is 0, use currentMask,
// for bits where types is 1, use initial mask.
ExtVehicleType types2 = (ExtVehicleType)vehicleTypes; //cast
mask = (types2 & mask) | (~types2 & currentMask);
}
VehicleRestrictionsManager.Instance.SetAllowedVehicleTypes(
segmentId,
segmentInfo,
laneIndex,
laneInfo,
laneId,
mask);
RefreshCurrentRestrictedSegmentIds(segmentId);
return(true);
}
SegmentLaneTraverser.Traverse(
SelectedSegmentId,
SegmentTraverser.TraverseDirection.AnyDirection,
SegmentTraverser.TraverseSide.AnySide,
SegmentLaneTraverser.LaneStopCriterion.LaneCount,
SegmentTraverser.SegmentStopCriterion.Junction,
VehicleRestrictionsManager.LANE_TYPES,
VehicleRestrictionsManager.VEHICLE_TYPES,
LaneVisitorFun);
}
private bool drawSpeedLimitHandles(ushort segmentId, ref NetSegment segment, bool viewOnly, ref Vector3 camPos)
{
if (viewOnly && !Options.speedLimitsOverlay)
{
return(false);
}
Vector3 center = segment.m_bounds.center;
NetManager netManager = Singleton <NetManager> .instance;
bool hovered = false;
ushort speedLimitToSet = viewOnly ? (ushort)0 : SpeedLimitManager.Instance.AvailableSpeedLimits[curSpeedLimitIndex];
bool showPerLane = showLimitsPerLane;
if (!viewOnly)
{
showPerLane = showLimitsPerLane ^ (Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl));
}
if (showPerLane)
{
// show individual speed limit handle per lane
int numDirections;
int numLanes = TrafficManagerTool.GetSegmentNumVehicleLanes(segmentId, null, out numDirections, SpeedLimitManager.VEHICLE_TYPES);
NetInfo segmentInfo = segment.Info;
Vector3 yu = (segment.m_endDirection - segment.m_startDirection).normalized;
Vector3 xu = Vector3.Cross(yu, new Vector3(0, 1f, 0)).normalized;
/*if ((segment.m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) {
* xu = -xu;
* }*/
float f = viewOnly ? 4f : 7f; // reserved sign size in game coordinates
Vector3 zero = center - 0.5f * (float)(numLanes - 1 + numDirections - 1) * f * xu;
uint x = 0;
var guiColor = GUI.color;
IList <LanePos> sortedLanes = Constants.ServiceFactory.NetService.GetSortedLanes(segmentId, ref segment, null, SpeedLimitManager.LANE_TYPES, SpeedLimitManager.VEHICLE_TYPES);
bool onlyMonorailLanes = sortedLanes.Count > 0;
if (!viewOnly)
{
foreach (LanePos laneData in sortedLanes)
{
byte laneIndex = laneData.laneIndex;
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Monorail) == VehicleInfo.VehicleType.None)
{
onlyMonorailLanes = false;
break;
}
}
}
HashSet <NetInfo.Direction> directions = new HashSet <NetInfo.Direction>();
int sortedLaneIndex = -1;
foreach (LanePos laneData in sortedLanes)
{
++sortedLaneIndex;
uint laneId = laneData.laneId;
byte laneIndex = laneData.laneIndex;
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
if (!directions.Contains(laneInfo.m_finalDirection))
{
if (directions.Count > 0)
{
++x; // space between different directions
}
directions.Add(laneInfo.m_finalDirection);
}
bool hoveredHandle = MainTool.DrawGenericSquareOverlayGridTexture(TextureResources.SpeedLimitTextures[SpeedLimitManager.Instance.GetCustomSpeedLimit(laneId)], camPos, zero, f, xu, yu, x, 0, speedLimitSignSize, !viewOnly, 0.5f, 0.8f);
if (!viewOnly && !onlyMonorailLanes && (laneInfo.m_vehicleType & VehicleInfo.VehicleType.Monorail) != VehicleInfo.VehicleType.None)
{
MainTool.DrawStaticSquareOverlayGridTexture(TextureResources.VehicleInfoSignTextures[ExtVehicleType.PassengerTrain], camPos, zero, f, xu, yu, x, 1, speedLimitSignSize, 0.5f);
}
if (hoveredHandle)
{
hovered = true;
}
if (hoveredHandle && Input.GetMouseButton(0) && !IsCursorInPanel())
{
SpeedLimitManager.Instance.SetSpeedLimit(segmentId, laneIndex, laneInfo, laneId, speedLimitToSet);
if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
{
SegmentLaneTraverser.Traverse(segmentId, SegmentTraverser.TraverseDirection.AnyDirection, SegmentTraverser.TraverseSide.AnySide, SegmentLaneTraverser.LaneStopCriterion.LaneCount, SegmentTraverser.SegmentStopCriterion.Junction, SpeedLimitManager.LANE_TYPES, SpeedLimitManager.VEHICLE_TYPES, delegate(SegmentLaneVisitData data) {
if (data.segVisitData.initial)
{
return(true);
}
if (sortedLaneIndex != data.sortedLaneIndex)
{
return(true);
}
Constants.ServiceFactory.NetService.ProcessSegment(data.segVisitData.curGeo.SegmentId, delegate(ushort curSegmentId, ref NetSegment curSegment) {
NetInfo.Lane curLaneInfo = curSegment.Info.m_lanes[data.curLanePos.laneIndex];
SpeedLimitManager.Instance.SetSpeedLimit(curSegmentId, data.curLanePos.laneIndex, curLaneInfo, data.curLanePos.laneId, speedLimitToSet);
return(true);
});
return(true);
});
}
}
++x;
}
}
else
{
// draw speedlimits over mean middle points of lane beziers
Dictionary <NetInfo.Direction, Vector3> segCenter;
if (!segmentCenterByDir.TryGetValue(segmentId, out segCenter))
{
segCenter = new Dictionary <NetInfo.Direction, Vector3>();
segmentCenterByDir.Add(segmentId, segCenter);
TrafficManagerTool.CalculateSegmentCenterByDir(segmentId, segCenter);
}
foreach (KeyValuePair <NetInfo.Direction, Vector3> e in segCenter)
{
Vector3 screenPos;
bool visible = MainTool.WorldToScreenPoint(e.Value, out screenPos);
if (!visible)
{
continue;
}
float zoom = 1.0f / (e.Value - camPos).magnitude * 100f * MainTool.GetBaseZoom();
float size = (viewOnly ? 0.8f : 1f) * speedLimitSignSize * zoom;
Color guiColor = GUI.color;
Rect boundingBox = new Rect(screenPos.x - size / 2, screenPos.y - size / 2, size, size);
bool hoveredHandle = !viewOnly && TrafficManagerTool.IsMouseOver(boundingBox);
if (hoveredHandle)
{
// mouse hovering over sign
hovered = true;
guiColor.a = 0.8f;
}
else
{
guiColor.a = 0.5f;
}
GUI.color = guiColor;
GUI.DrawTexture(boundingBox, TextureResources.SpeedLimitTextures[SpeedLimitManager.Instance.GetCustomSpeedLimit(segmentId, e.Key)]);
if (hoveredHandle && Input.GetMouseButton(0) && !IsCursorInPanel())
{
// change the speed limit to the selected one
//Log._Debug($"Setting speed limit of segment {segmentId}, dir {e.Key.ToString()} to {speedLimitToSet}");
SpeedLimitManager.Instance.SetSpeedLimit(segmentId, e.Key, speedLimitToSet);
if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
{
NetInfo.Direction normDir = e.Key;
if ((netManager.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Invert) != NetSegment.Flags.None)
{
normDir = NetInfo.InvertDirection(normDir);
}
SegmentLaneTraverser.Traverse(segmentId, SegmentTraverser.TraverseDirection.AnyDirection, SegmentTraverser.TraverseSide.AnySide, SegmentLaneTraverser.LaneStopCriterion.LaneCount, SegmentTraverser.SegmentStopCriterion.Junction, SpeedLimitManager.LANE_TYPES, SpeedLimitManager.VEHICLE_TYPES, delegate(SegmentLaneVisitData data) {
if (data.segVisitData.initial)
{
return(true);
}
bool reverse = data.segVisitData.viaStartNode == data.segVisitData.viaInitialStartNode;
ushort otherSegmentId = data.segVisitData.curGeo.SegmentId;
NetInfo otherSegmentInfo = netManager.m_segments.m_buffer[otherSegmentId].Info;
uint laneId = data.curLanePos.laneId;
byte laneIndex = data.curLanePos.laneIndex;
NetInfo.Lane laneInfo = otherSegmentInfo.m_lanes[laneIndex];
NetInfo.Direction otherNormDir = laneInfo.m_finalDirection;
if ((netManager.m_segments.m_buffer[otherSegmentId].m_flags & NetSegment.Flags.Invert) != NetSegment.Flags.None ^
reverse)
{
otherNormDir = NetInfo.InvertDirection(otherNormDir);
}
if (otherNormDir == normDir)
{
SpeedLimitManager.Instance.SetSpeedLimit(otherSegmentId, laneInfo.m_finalDirection, speedLimitToSet);
}
return(true);
});
}
}
guiColor.a = 1f;
GUI.color = guiColor;
}
}
return(hovered);
}