/// <summary>
/// highlights the given lane according.
/// the highlight is emboldened if mouse click is pressed.
/// </summary>
private void RenderLaneOverlay(RenderManager.CameraInfo cameraInfo, uint laneId)
{
var marker = new SegmentLaneMarker(laneBuffer[laneId].m_bezier);
bool pressed = Input.GetMouseButton(0);
Color color = HighlightColor;
color = pressed ? Color.magenta : color;
marker.RenderOverlay(cameraInfo, color, pressed);
}
private void RenderLaneOverlay(RenderManager.CameraInfo cameraInfo, uint laneId)
{
var marker = new SegmentLaneMarker(laneBuffer[laneId].m_bezier);
bool pressed = Input.GetMouseButton(0);
Color color = MainTool.GetToolColor(pressed, false);
if (!ShowLimitsPerLane)
{
marker.Size = 3f; // lump the lanes together.
}
marker.RenderOverlay(cameraInfo, color, pressed);
}
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);
}
void HandleLaneCustomization()
{
// Handle lane settings
Ray mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition);
m_hoveredLanes = ushort.MaxValue;
foreach (FastList <SegmentLaneMarker> laneMarkers in m_hoveredLaneMarkers.Values)
{
if (laneMarkers.m_size == 0)
{
continue;
}
for (int i = 0; i < laneMarkers.m_size; i++)
{
SegmentLaneMarker marker = laneMarkers.m_buffer[i];
if (NetManager.instance.m_lanes.m_buffer[marker.m_lane].m_segment != m_hoveredSegment)
{
continue;
}
if (marker.IntersectRay(mouseRay))
{
m_hoveredLanes = marker.m_laneIndex;
break;
}
}
if (m_hoveredLanes != ushort.MaxValue)
{
break;
}
}
if (m_hoveredLanes != ushort.MaxValue && Input.GetMouseButtonUp(0))
{
SegmentLaneMarker[] hoveredMarkers = m_hoveredLaneMarkers[m_hoveredLanes].ToArray();
HashSet <uint> hoveredLanes = new HashSet <uint>(hoveredMarkers.Select(m => m.m_lane));
if (m_selectedLaneMarkers.RemoveAll(m => hoveredLanes.Contains(m.m_lane)) == 0)
{
m_selectedLaneMarkers.AddRange(hoveredMarkers);
}
}
else if (Input.GetMouseButtonUp(1))
{
m_selectedLaneMarkers.Clear();
}
}
private void RenderSegmentParkings(RenderManager.CameraInfo cameraInfo)
{
bool allowed = parkingManager.IsParkingAllowed(renderInfo_.SegmentId, renderInfo_.FinalDirection);
bool pressed = Input.GetMouseButton(0);
Color color;
if (pressed)
{
color = MainTool.GetToolColor(true, false);
}
else if (allowed)
{
color = Color.green;
}
else
{
color = Color.red;
}
Bezier3 bezier = default;
netService.IterateSegmentLanes(
renderInfo_.SegmentId,
(uint laneId,
ref NetLane lane,
NetInfo.Lane laneInfo,
ushort _,
ref NetSegment segment,
byte laneIndex) => {
bool isParking = laneInfo.m_laneType.IsFlagSet(NetInfo.LaneType.Parking);
if (isParking && laneInfo.m_finalDirection == renderInfo_.FinalDirection)
{
bezier = lane.m_bezier;
laneMarker_ = new SegmentLaneMarker(bezier);
laneMarker_.RenderOverlay(cameraInfo, color, enlarge: pressed);
}
return(true);
});
}
private static List <NodeLaneMarker> GetNodeMarkers(ushort nodeId, ref NetNode node)
{
if (nodeId == 0)
{
return(null);
}
if ((node.m_flags & NetNode.Flags.Created) == NetNode.Flags.None)
{
return(null);
}
List <NodeLaneMarker> nodeMarkers = new List <NodeLaneMarker>();
int nodeMarkerColorIndex = 0;
LaneConnectionManager connManager = LaneConnectionManager.Instance;
int offsetMultiplier = node.CountSegments() <= 2 ? 3 : 1;
for (int i = 0; i < 8; i++)
{
ushort segmentId = node.GetSegment(i);
if (segmentId == 0)
{
continue;
}
NetSegment[] segmentsBuffer = NetManager.instance.m_segments.m_buffer;
bool startNode = segmentsBuffer[segmentId].m_startNode == nodeId;
Vector3 offset = segmentsBuffer[segmentId]
.FindDirection(segmentId, nodeId) * offsetMultiplier;
NetInfo.Lane[] lanes = segmentsBuffer[segmentId].Info.m_lanes;
uint laneId = segmentsBuffer[segmentId].m_lanes;
for (byte laneIndex = 0; (laneIndex < lanes.Length) && (laneId != 0); laneIndex++)
{
NetInfo.Lane laneInfo = lanes[laneIndex];
if (((laneInfo.m_laneType & LaneConnectionManager.LANE_TYPES) != NetInfo.LaneType.None) &&
((laneInfo.m_vehicleType & LaneConnectionManager.VEHICLE_TYPES)
!= VehicleInfo.VehicleType.None))
{
if (connManager.GetLaneEndPoint(
segmentId,
startNode,
laneIndex,
laneId,
laneInfo,
out bool isSource,
out bool isTarget,
out Vector3? pos))
{
pos = pos.Value + offset;
float terrainY =
Singleton <TerrainManager> .instance.SampleDetailHeightSmooth(pos.Value);
var finalPos = new Vector3(pos.Value.x, terrainY, pos.Value.z);
Color32 nodeMarkerColor
= isSource
? COLOR_CHOICES[nodeMarkerColorIndex % COLOR_CHOICES.Length]
: default; // or black (not used while rendering)
NetLane lane = NetManager.instance.m_lanes.m_buffer[laneId];
Bezier3 bezier = lane.m_bezier;
if (startNode)
{
bezier.a = (Vector3)pos;
}
else
{
bezier.d = (Vector3)pos;
}
SegmentLaneMarker segmentLaneMarker = new SegmentLaneMarker {
renderBezier = bezier,
raycastBezier = bezier,
laneID = laneId,
laneIndex = laneIndex,
};
nodeMarkers.Add(
new NodeLaneMarker {
SegmentId = segmentId,
LaneId = laneId,
NodeId = nodeId,
StartNode = startNode,
Position = finalPos,
SecondaryPosition = (Vector3)pos,
Color = nodeMarkerColor,
IsSource = isSource,
IsTarget = isTarget,
LaneType = laneInfo.m_laneType,
VehicleType = laneInfo.m_vehicleType,
InnerSimilarLaneIndex =
((byte)(laneInfo.m_direction & NetInfo.Direction.Forward) != 0)
? laneInfo.m_similarLaneIndex
: laneInfo.m_similarLaneCount -
laneInfo.m_similarLaneIndex - 1,
SegmentIndex = i,
segmentLaneMarker = segmentLaneMarker,
});
if (isSource)
{
nodeMarkerColorIndex++;
}
}
}
laneId = NetManager.instance.m_lanes.m_buffer[laneId].m_nextLane;
}
}
if (nodeMarkers.Count == 0)
{
return(null);
}
foreach (NodeLaneMarker laneMarker1 in nodeMarkers)
{
if (!laneMarker1.IsSource)
{
continue;
}
uint[] connections =
LaneConnectionManager.Instance.GetLaneConnections(
laneMarker1.LaneId,
laneMarker1.StartNode);
if ((connections == null) || (connections.Length == 0))
{
continue;
}
foreach (NodeLaneMarker laneMarker2 in nodeMarkers)
{
if (!laneMarker2.IsTarget)
{
continue;
}
if (connections.Contains(laneMarker2.LaneId))
{
laneMarker1.ConnectedMarkers.Add(laneMarker2);
}
}
}
return(nodeMarkers);
}
