private void SetAlpha(int segmentId, int buttonId)
{
Color guiColor = GUI.color;
guiColor.a = TrafficManagerTool.GetHandleAlpha(
hoveredButton[0] == segmentId &&
hoveredButton[1] == buttonId);
GUI.color = guiColor;
}
private bool RenderManualPedestrianLightSwitch(float zoom,
int segmentId,
Vector3 screenPos,
float lightWidth,
ICustomSegmentLights segmentLights,
bool hoveredSegment)
{
if (segmentLights.PedestrianLightState == null)
{
return(false);
}
Color guiColor = GUI.color;
float manualPedestrianWidth = 36f * zoom;
float manualPedestrianHeight = 35f * zoom;
guiColor.a = TrafficManagerTool.GetHandleAlpha(
hoveredButton[0] == segmentId &&
(hoveredButton[1] == 1 ||
hoveredButton[1] == 2));
GUI.color = guiColor;
var myRect2 = new Rect(
screenPos.x - (manualPedestrianWidth / 2) - lightWidth + (5f * zoom),
screenPos.y - (manualPedestrianHeight / 2) - (9f * zoom),
manualPedestrianWidth,
manualPedestrianHeight);
GUI.DrawTexture(
myRect2,
segmentLights.ManualPedestrianMode
? TrafficLightTextures.PedestrianModeManual
: TrafficLightTextures.PedestrianModeAutomatic);
if (!myRect2.Contains(Event.current.mousePosition))
{
return(hoveredSegment);
}
hoveredButton[0] = segmentId;
hoveredButton[1] = 1;
if (!MainTool.CheckClicked())
{
return(true);
}
segmentLights.ManualPedestrianMode = !segmentLights.ManualPedestrianMode;
return(true);
}
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 * x * xu) + (f * y * yu); // in game coordinates
Vector3 signScreenPos;
bool visible = MainTool.WorldToScreenPoint(signCenter, out signScreenPos);
if (!visible)
{
hoveredHandle = false;
return;
}
Vector3 diff = signCenter - camPos;
float zoom = 1.0f / diff.magnitude * 100f * MainTool.GetBaseZoom();
float 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 = TrafficManagerTool.GetHandleAlpha(hoveredHandle);
GUI.color = guiColor;
GUI.DrawTexture(boundingBox, signTexture);
}
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);
}
public override void OnToolGUI(Event e)
{
IExtSegmentManager segMan = Constants.ManagerFactory.ExtSegmentManager;
IExtSegmentEndManager segEndMan = Constants.ManagerFactory.ExtSegmentEndManager;
var hoveredSegment = false;
if (SelectedNodeId != 0)
{
CustomSegmentLightsManager customTrafficLightsManager = CustomSegmentLightsManager.Instance;
TrafficLightSimulationManager tlsMan = TrafficLightSimulationManager.Instance;
JunctionRestrictionsManager junctionRestrictionsManager = JunctionRestrictionsManager.Instance;
if (!tlsMan.HasManualSimulation(SelectedNodeId))
{
return;
}
tlsMan.TrafficLightSimulations[SelectedNodeId].Housekeeping();
// TODO check
// if (Singleton<NetManager>.instance.m_nodes.m_buffer[SelectedNode].CountSegments() == 2) {
// _guiManualTrafficLightsCrosswalk(
// ref Singleton<NetManager>.instance.m_nodes.m_buffer[SelectedNode]);
// return;
// }
NetNode[] nodesBuffer = Singleton <NetManager> .instance.m_nodes.m_buffer;
NetSegment[] segmentsBuffer = Singleton <NetManager> .instance.m_segments.m_buffer;
for (int i = 0; i < 8; ++i)
{
ushort segmentId = nodesBuffer[SelectedNodeId].GetSegment(i);
if (segmentId == 0)
{
continue;
}
bool startNode =
(bool)Constants.ServiceFactory.NetService.IsStartNode(
segmentId,
SelectedNodeId);
Vector3 position = CalculateNodePositionForSegment(
nodesBuffer[SelectedNodeId],
ref segmentsBuffer[segmentId]);
ICustomSegmentLights segmentLights =
customTrafficLightsManager.GetSegmentLights(segmentId, startNode, false);
if (segmentLights == null)
{
continue;
}
bool showPedLight = segmentLights.PedestrianLightState != null &&
junctionRestrictionsManager.IsPedestrianCrossingAllowed(
segmentLights.SegmentId,
segmentLights.StartNode);
bool visible = MainTool.WorldToScreenPoint(position, out Vector3 screenPos);
if (!visible)
{
continue;
}
Vector3 diff = position - Camera.main.transform.position;
float zoom = 1.0f / diff.magnitude * 100f;
// original / 2.5
float lightWidth = 41f * zoom;
float lightHeight = 97f * zoom;
float pedestrianWidth = 36f * zoom;
float pedestrianHeight = 61f * zoom;
// SWITCH MODE BUTTON
float modeWidth = 41f * zoom;
float modeHeight = 38f * zoom;
Color guiColor = GUI.color;
if (showPedLight)
{
// pedestrian light
// SWITCH MANUAL PEDESTRIAN LIGHT BUTTON
hoveredSegment = RenderManualPedestrianLightSwitch(
zoom,
segmentId,
screenPos,
lightWidth,
segmentLights,
hoveredSegment);
// SWITCH PEDESTRIAN LIGHT
guiColor.a = TrafficManagerTool.GetHandleAlpha(
hoveredButton[0] == segmentId && hoveredButton[1] == 2 &&
segmentLights.ManualPedestrianMode);
GUI.color = guiColor;
var myRect3 = new Rect(
screenPos.x - pedestrianWidth / 2 - lightWidth + 5f * zoom,
screenPos.y - pedestrianHeight / 2 + 22f * zoom,
pedestrianWidth,
pedestrianHeight);
switch (segmentLights.PedestrianLightState)
{
case RoadBaseAI.TrafficLightState.Green: {
GUI.DrawTexture(
myRect3,
TrafficLightTextures.PedestrianGreenLight);
break;
}
// also: case RoadBaseAI.TrafficLightState.Red:
default: {
GUI.DrawTexture(
myRect3,
TrafficLightTextures.PedestrianRedLight);
break;
}
}
hoveredSegment = IsPedestrianLightHovered(
myRect3,
segmentId,
hoveredSegment,
segmentLights);
}
int lightOffset = -1;
foreach (ExtVehicleType vehicleType in segmentLights.VehicleTypes)
{
++lightOffset;
ICustomSegmentLight segmentLight = segmentLights.GetCustomLight(vehicleType);
Vector3 offsetScreenPos = screenPos;
offsetScreenPos.y -= (lightHeight + 10f * zoom) * lightOffset;
SetAlpha(segmentId, -1);
var myRect1 = new Rect(
offsetScreenPos.x - modeWidth / 2,
offsetScreenPos.y - modeHeight / 2 + modeHeight - 7f * zoom,
modeWidth,
modeHeight);
GUI.DrawTexture(myRect1, TrafficLightTextures.LightMode);
hoveredSegment = GetHoveredSegment(
myRect1,
segmentId,
hoveredSegment,
segmentLight);
// COUNTER
hoveredSegment = RenderCounter(
segmentId,
offsetScreenPos,
modeWidth,
modeHeight,
zoom,
segmentLights,
hoveredSegment);
if (vehicleType != ExtVehicleType.None)
{
// Info sign
float infoWidth = 56.125f * zoom;
float infoHeight = 51.375f * zoom;
int numInfos = 0;
for (int k = 0; k < TrafficManagerTool.InfoSignsToDisplay.Length; ++k)
{
if ((TrafficManagerTool.InfoSignsToDisplay[k] & vehicleType) ==
ExtVehicleType.None)
{
continue;
}
var infoRect = new Rect(
offsetScreenPos.x + modeWidth / 2f +
(7f * zoom * (float)(numInfos + 1)) + (infoWidth * (float)numInfos),
offsetScreenPos.y - (infoHeight / 2f),
infoWidth,
infoHeight);
guiColor.a = TrafficManagerTool.GetHandleAlpha(false);
GUI.DrawTexture(
infoRect,
RoadUITextures.VehicleInfoSignTextures[TrafficManagerTool.InfoSignsToDisplay[k]]);
++numInfos;
}
}
ExtSegment seg = segMan.ExtSegments[segmentId];
ExtSegmentEnd segEnd =
segEndMan.ExtSegmentEnds[segEndMan.GetIndex(segmentId, startNode)];
if (seg.oneWay && segEnd.outgoing)
{
continue;
}
segEndMan.CalculateOutgoingLeftStraightRightSegments(
ref segEnd,
ref nodesBuffer[segmentId],
out bool hasLeftSegment,
out bool hasForwardSegment,
out bool hasRightSegment);
switch (segmentLight.CurrentMode)
{
case LightMode.Simple: {
hoveredSegment = SimpleManualSegmentLightMode(
segmentId,
offsetScreenPos,
lightWidth,
pedestrianWidth,
zoom,
lightHeight,
segmentLight,
hoveredSegment);
break;
}
case LightMode.SingleLeft: {
hoveredSegment = LeftForwardRManualSegmentLightMode(
hasLeftSegment,
segmentId,
offsetScreenPos,
lightWidth,
pedestrianWidth,
zoom,
lightHeight,
segmentLight,
hoveredSegment,
hasForwardSegment,
hasRightSegment);
break;
}
case LightMode.SingleRight: {
hoveredSegment = RightForwardLSegmentLightMode(
segmentId,
offsetScreenPos,
lightWidth,
pedestrianWidth,
zoom,
lightHeight,
hasForwardSegment,
hasLeftSegment,
segmentLight,
hasRightSegment,
hoveredSegment);
break;
}
default: {
// left arrow light
if (hasLeftSegment)
{
hoveredSegment = LeftArrowLightMode(
segmentId,
lightWidth,
hasRightSegment,
hasForwardSegment,
offsetScreenPos,
pedestrianWidth,
zoom,
lightHeight,
segmentLight,
hoveredSegment);
}
// forward arrow light
if (hasForwardSegment)
{
hoveredSegment = ForwardArrowLightMode(
segmentId,
lightWidth,
hasRightSegment,
offsetScreenPos,
pedestrianWidth,
zoom,
lightHeight,
segmentLight,
hoveredSegment);
}
// right arrow light
if (hasRightSegment)
{
hoveredSegment = RightArrowLightMode(
segmentId,
offsetScreenPos,
lightWidth,
pedestrianWidth,
zoom,
lightHeight,
segmentLight,
hoveredSegment);
}
break;
}
} // end switch
} // end foreach all vehicle type
} // end for all 8 segments
} // end if a node is selected
if (hoveredSegment)
{
return;
}
hoveredButton[0] = 0;
hoveredButton[1] = 0;
}
private bool RightForwardLSegmentLightMode(int segmentId,
Vector3 screenPos,
float lightWidth,
float pedestrianWidth,
float zoom,
float lightHeight,
bool hasForwardSegment,
bool hasLeftSegment,
ICustomSegmentLight segmentDict,
bool hasRightSegment,
bool hoveredSegment)
{
SetAlpha(segmentId, 3);
var myRect4 = new Rect(
screenPos.x - (lightWidth / 2) - (lightWidth * 2) - pedestrianWidth + (5f * zoom),
screenPos.y - (lightHeight / 2),
lightWidth,
lightHeight);
if (hasForwardSegment && hasLeftSegment)
{
switch (segmentDict.LightLeft)
{
case RoadBaseAI.TrafficLightState.Green: {
GUI.DrawTexture(myRect4, TrafficLightTextures.GreenLightForwardLeft);
break;
}
case RoadBaseAI.TrafficLightState.Red: {
GUI.DrawTexture(myRect4, TrafficLightTextures.RedLightForwardLeft);
break;
}
}
}
else if (!hasLeftSegment)
{
if (!hasRightSegment)
{
myRect4 = new Rect(
screenPos.x - (lightWidth / 2) - lightWidth - pedestrianWidth + (5f * zoom),
screenPos.y - (lightHeight / 2),
lightWidth,
lightHeight);
}
switch (segmentDict.LightMain)
{
case RoadBaseAI.TrafficLightState.Green: {
GUI.DrawTexture(myRect4, TrafficLightTextures.GreenLightStraight);
break;
}
case RoadBaseAI.TrafficLightState.Red: {
GUI.DrawTexture(myRect4, TrafficLightTextures.RedLightStraight);
break;
}
}
}
else
{
if (!hasRightSegment)
{
myRect4 = new Rect(
screenPos.x - (lightWidth / 2) - lightWidth - pedestrianWidth + (5f * zoom),
screenPos.y - (lightHeight / 2),
lightWidth,
lightHeight);
}
switch (segmentDict.LightMain)
{
case RoadBaseAI.TrafficLightState.Green: {
GUI.DrawTexture(myRect4, TrafficLightTextures.GreenLightLeft);
break;
}
case RoadBaseAI.TrafficLightState.Red: {
GUI.DrawTexture(myRect4, TrafficLightTextures.RedLightLeft);
break;
}
}
}
if (myRect4.Contains(Event.current.mousePosition))
{
hoveredButton[0] = segmentId;
hoveredButton[1] = 3;
hoveredSegment = true;
if (MainTool.CheckClicked())
{
segmentDict.ChangeMainLight();
}
}
Color guiColor = GUI.color;
// right arrow light
if (hasRightSegment)
{
guiColor.a = TrafficManagerTool.GetHandleAlpha(
hoveredButton[0] == segmentId && hoveredButton[1] == 4);
}
GUI.color = guiColor;
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, TrafficLightTextures.GreenLightRight);
break;
}
case RoadBaseAI.TrafficLightState.Red: {
GUI.DrawTexture(myRect5, TrafficLightTextures.RedLightRight);
break;
}
}
if (!myRect5.Contains(Event.current.mousePosition))
{
return(hoveredSegment);
}
hoveredButton[0] = segmentId;
hoveredButton[1] = 4;
if (!MainTool.CheckClicked())
{
return(true);
}
segmentDict.ChangeRightLight();
return(true);
}