protected override void RenderGroupBG(RenderManager.CameraInfo cameraInfo) => LeaveBounds.Render(cameraInfo, Colors.White, LeaveBounds.Size - 0.43f, false);
public static void RenderCloneGeometryImplementation(InstanceState instanceState, ref Matrix4x4 matrix4x, Vector3 deltaPosition, float deltaAngle, Vector3 center, bool followTerrain, RenderManager.CameraInfo cameraInfo)
{
BuildingInfo info = instanceState.Info.Prefab as BuildingInfo;
Color color = GetColor(instanceState.instance.id.Building, info);
Vector3 newPosition = matrix4x.MultiplyPoint(instanceState.position - center);
newPosition.y = instanceState.position.y + deltaPosition.y;
if (followTerrain)
{
newPosition.y = newPosition.y - instanceState.terrainHeight + TerrainManager.instance.SampleOriginalRawHeightSmooth(newPosition);
}
float newAngle = instanceState.angle + deltaAngle;
info.m_buildingAI.RenderBuildGeometry(cameraInfo, newPosition, newAngle, 0);
BuildingTool.RenderGeometry(cameraInfo, info, info.GetLength(), newPosition, newAngle, false, color);
if (info.m_subBuildings != null && info.m_subBuildings.Length != 0)
{
Matrix4x4 subMatrix4x = default;
subMatrix4x.SetTRS(newPosition, Quaternion.AngleAxis(newAngle * Mathf.Rad2Deg, Vector3.down), Vector3.one);
for (int i = 0; i < info.m_subBuildings.Length; i++)
{
BuildingInfo buildingInfo2 = info.m_subBuildings[i].m_buildingInfo;
Vector3 position = subMatrix4x.MultiplyPoint(info.m_subBuildings[i].m_position);
float angle = info.m_subBuildings[i].m_angle * Mathf.Deg2Rad + newAngle;
buildingInfo2.m_buildingAI.RenderBuildGeometry(cameraInfo, position, angle, 0);
BuildingTool.RenderGeometry(cameraInfo, buildingInfo2, 0, position, angle, true, color);
}
}
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
//Log._Debug($"TppLaneConnectorTool: RenderOverlay. SelectedNodeId={SelectedNodeId} SelectedSegmentId={SelectedSegmentId} HoveredNodeId={HoveredNodeId} HoveredSegmentId={HoveredSegmentId} IsInsideUI={MainTool.GetToolController().IsInsideUI}");
// draw lane markers and connections
hoveredMarker = null;
ShowOverlay(false, cameraInfo);
// draw bezier from source marker to mouse position in target marker selection
if (SelectedNodeId != 0)
{
if (GetMarkerSelectionMode() == MarkerSelectionMode.SelectTarget)
{
Vector3 selNodePos = NetManager.instance.m_nodes.m_buffer[SelectedNodeId].m_position;
ToolBase.RaycastOutput output;
if (RayCastSegmentAndNode(out output))
{
RenderLane(cameraInfo, selectedMarker.position, output.m_hitPos, selNodePos, selectedMarker.color);
}
}
bool deleteAll = Input.GetKeyDown(KeyCode.Delete) || Input.GetKeyDown(KeyCode.Backspace);
bool stayInLane = Input.GetKeyDown(KeyCode.S) && (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift)) && Singleton <NetManager> .instance.m_nodes.m_buffer[SelectedNodeId].CountSegments() == 2;
if (stayInLane)
{
deleteAll = true;
}
if (deleteAll)
{
// remove all connections at selected node
LaneConnectionManager.Instance.RemoveLaneConnectionsFromNode(SelectedNodeId);
RefreshCurrentNodeMarkers(SelectedNodeId);
}
if (stayInLane)
{
// "stay in lane"
switch (stayInLaneMode)
{
case StayInLaneMode.None:
stayInLaneMode = StayInLaneMode.Both;
break;
case StayInLaneMode.Both:
stayInLaneMode = StayInLaneMode.Forward;
break;
case StayInLaneMode.Forward:
stayInLaneMode = StayInLaneMode.Backward;
break;
case StayInLaneMode.Backward:
stayInLaneMode = StayInLaneMode.None;
break;
}
if (stayInLaneMode != StayInLaneMode.None)
{
List <NodeLaneMarker> nodeMarkers = GetNodeMarkers(SelectedNodeId, ref Singleton <NetManager> .instance.m_nodes.m_buffer[SelectedNodeId]);
if (nodeMarkers != null)
{
selectedMarker = null;
foreach (NodeLaneMarker sourceLaneMarker in nodeMarkers)
{
if (!sourceLaneMarker.isSource)
{
continue;
}
if (stayInLaneMode == StayInLaneMode.Forward || stayInLaneMode == StayInLaneMode.Backward)
{
if (sourceLaneMarker.segmentIndex == 0 ^ stayInLaneMode == StayInLaneMode.Backward)
{
continue;
}
}
foreach (NodeLaneMarker targetLaneMarker in nodeMarkers)
{
if (!targetLaneMarker.isTarget || targetLaneMarker.segmentId == sourceLaneMarker.segmentId)
{
continue;
}
if (targetLaneMarker.innerSimilarLaneIndex == sourceLaneMarker.innerSimilarLaneIndex)
{
Log._Debug($"Adding lane connection {sourceLaneMarker.laneId} -> {targetLaneMarker.laneId}");
LaneConnectionManager.Instance.AddLaneConnection(sourceLaneMarker.laneId, targetLaneMarker.laneId, sourceLaneMarker.startNode);
}
}
}
}
RefreshCurrentNodeMarkers(SelectedNodeId);
}
}
}
if (GetMarkerSelectionMode() == MarkerSelectionMode.None && HoveredNodeId != 0)
{
// draw hovered node
MainTool.DrawNodeCircle(cameraInfo, HoveredNodeId, Input.GetMouseButton(0));
}
}
public void Render(RenderManager.CameraInfo cameraInfo) => CurrentEditor?.Render(cameraInfo);
public override void RenderCloneOverlay(InstanceState instanceState, ref Matrix4x4 matrix4x, Vector3 deltaPosition, float deltaAngle, Vector3 center, bool followTerrain, RenderManager.CameraInfo cameraInfo, Color toolColor)
{
if (MoveItTool.m_isLowSensitivity)
{
return;
}
BuildingState state = instanceState as BuildingState;
BuildingInfo buildingInfo = state.Info.Prefab as BuildingInfo;
Vector3 newPosition = matrix4x.MultiplyPoint(state.position - center);
newPosition.y = state.position.y + deltaPosition.y;
if (followTerrain)
{
newPosition.y = newPosition.y - state.terrainHeight + TerrainManager.instance.SampleOriginalRawHeightSmooth(newPosition);
}
float newAngle = state.angle + deltaAngle;
buildingInfo.m_buildingAI.RenderBuildOverlay(cameraInfo, toolColor, newPosition, newAngle, default);
BuildingTool.RenderOverlay(cameraInfo, buildingInfo, state.length, newPosition, newAngle, toolColor, false);
if (buildingInfo.m_subBuildings != null && buildingInfo.m_subBuildings.Length != 0)
{
Matrix4x4 subMatrix4x = default;
subMatrix4x.SetTRS(newPosition, Quaternion.AngleAxis(newAngle * Mathf.Rad2Deg, Vector3.down), Vector3.one);
for (int i = 0; i < buildingInfo.m_subBuildings.Length; i++)
{
BuildingInfo buildingInfo2 = buildingInfo.m_subBuildings[i].m_buildingInfo;
Vector3 position = subMatrix4x.MultiplyPoint(buildingInfo.m_subBuildings[i].m_position);
float angle = buildingInfo.m_subBuildings[i].m_angle * 0.0174532924f + newAngle;
buildingInfo2.m_buildingAI.RenderBuildOverlay(cameraInfo, toolColor, position, angle, default);
BuildingTool.RenderOverlay(cameraInfo, buildingInfo2, 0, position, angle, toolColor, true);
}
}
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
base.RenderOverlay(cameraInfo);
if (m_selectedNode != 0)
{
FastList <NodeLaneMarker> nodeMarkers;
if (m_nodeMarkers.TryGetValue(m_selectedNode, out nodeMarkers))
{
Vector3 nodePos = NetManager.instance.m_nodes.m_buffer[m_selectedNode].m_position;
for (int i = 0; i < nodeMarkers.m_size; i++)
{
NodeLaneMarker laneMarker = nodeMarkers.m_buffer[i];
for (int j = 0; j < laneMarker.m_connections.m_size; j++)
{
RenderLane(cameraInfo, laneMarker.m_position, laneMarker.m_connections.m_buffer[j].m_position, nodePos, laneMarker.m_connections.m_buffer[j].m_color);
}
if (m_selectedMarker != laneMarker && !IsActive(laneMarker))
{
continue;
}
if (m_selectedMarker == laneMarker)
{
RaycastOutput output;
if (RayCastSegmentAndNode(out output))
{
RenderLane(cameraInfo, m_selectedMarker.m_position, output.m_hitPos, nodePos, m_selectedMarker.m_color);
m_selectedMarker.m_size = 2f;
}
}
RenderManager.instance.OverlayEffect.DrawCircle(cameraInfo, laneMarker.m_color, laneMarker.m_position, laneMarker.m_size, 0, 500, false, true);
}
}
}
else
{
foreach (KeyValuePair <int, FastList <SegmentLaneMarker> > keyValuePair in m_hoveredLaneMarkers)
{
bool renderBig = false;
if (m_hoveredLanes == keyValuePair.Key)
{
renderBig = true;
}
FastList <SegmentLaneMarker> laneMarkers = keyValuePair.Value;
for (int i = 0; i < laneMarkers.m_size; i++)
{
RenderManager.instance.OverlayEffect.DrawBezier(cameraInfo, new Color(0f, 0f, 1f, 0.75f), laneMarkers.m_buffer[i].m_bezier, renderBig ? 2f : laneMarkers.m_buffer[i].m_size, 0, 0, 0, 500, false, false);
}
}
foreach (SegmentLaneMarker marker in m_selectedLaneMarkers)
{
RenderManager.instance.OverlayEffect.DrawBezier(cameraInfo, new Color(0f, 1f, 0f, 0.75f), marker.m_bezier, 2f, 0, 0, 0, 500, false, false);
}
}
foreach (ushort node in m_nodeMarkers.Keys)
{
if (node == m_selectedNode || (NetManager.instance.m_nodes.m_buffer[node].m_flags & CUSTOMIZED_NODE_FLAG) != CUSTOMIZED_NODE_FLAG)
{
continue;
}
FastList <NodeLaneMarker> list = m_nodeMarkers[node];
Vector3 nodePos = NetManager.instance.m_nodes.m_buffer[node].m_position;
for (int i = 0; i < list.m_size; i++)
{
NodeLaneMarker laneMarker = list.m_buffer[i];
for (int j = 0; j < laneMarker.m_connections.m_size; j++)
{
if (((NetLane.Flags)NetManager.instance.m_lanes.m_buffer[laneMarker.m_connections.m_buffer[j].m_lane].m_flags & NetLane.Flags.Created) == NetLane.Flags.Created)
{
Color color = laneMarker.m_connections.m_buffer[j].m_color;
color.a = 0.75f;
RenderLane(cameraInfo, laneMarker.m_position, laneMarker.m_connections.m_buffer[j].m_position, nodePos, color);
}
}
}
}
if (m_hoveredNode != 0)
{
NetNode node = NetManager.instance.m_nodes.m_buffer[m_hoveredNode];
RenderManager.instance.OverlayEffect.DrawCircle(cameraInfo, new Color(0f, 0f, 0.5f, 0.75f), node.m_position, 15f, 0, 500, false, true);
}
}
public override void RenderCloneOverlay(InstanceState instanceState, ref Matrix4x4 matrix4x, Vector3 deltaPosition, float deltaAngle, Vector3 center, bool followTerrain, RenderManager.CameraInfo cameraInfo, Color toolColor)
{
if (MoveItTool.m_isLowSensitivity && MoveItTool.hideSelectorsOnLowSensitivity)
{
return;
}
PropState state = instanceState as PropState;
PropInfo info = state.Info.Prefab as PropInfo;
Randomizer randomizer = new Randomizer(state.instance.id.Prop);
float scale = info.m_minScale + (float)randomizer.Int32(10000u) * (info.m_maxScale - info.m_minScale) * 0.0001f;
Vector3 newPosition = matrix4x.MultiplyPoint(state.position - center);
newPosition.y = state.position.y + deltaPosition.y;
if (followTerrain)
{
newPosition.y = newPosition.y - state.terrainHeight + TerrainManager.instance.SampleOriginalRawHeightSmooth(newPosition);
}
float newAngle = state.angle + deltaAngle;
PropTool.RenderOverlay(cameraInfo, info, newPosition, scale, newAngle, toolColor);
}
public static bool EndRenderingImplPrefix(CitizenManager __instance, RenderManager.CameraInfo cameraInfo, ulong[] ___m_renderBuffer)
{
float levelOfDetailFactor = RenderManager.LevelOfDetailFactor;
float near = cameraInfo.m_near;
float d = Mathf.Min(Mathf.Min(levelOfDetailFactor * 800f, levelOfDetailFactor * 400f + cameraInfo.m_height * 0.5f), cameraInfo.m_far);
Vector3 lhs = cameraInfo.m_position + cameraInfo.m_directionA * near;
Vector3 rhs = cameraInfo.m_position + cameraInfo.m_directionB * near;
Vector3 lhs2 = cameraInfo.m_position + cameraInfo.m_directionC * near;
Vector3 rhs2 = cameraInfo.m_position + cameraInfo.m_directionD * near;
Vector3 lhs3 = cameraInfo.m_position + cameraInfo.m_directionA * d;
Vector3 rhs3 = cameraInfo.m_position + cameraInfo.m_directionB * d;
Vector3 lhs4 = cameraInfo.m_position + cameraInfo.m_directionC * d;
Vector3 rhs4 = cameraInfo.m_position + cameraInfo.m_directionD * d;
Vector3 vector = Vector3.Min(Vector3.Min(Vector3.Min(lhs, rhs), Vector3.Min(lhs2, rhs2)), Vector3.Min(Vector3.Min(lhs3, rhs3), Vector3.Min(lhs4, rhs4)));
Vector3 vector2 = Vector3.Max(Vector3.Max(Vector3.Max(lhs, rhs), Vector3.Max(lhs2, rhs2)), Vector3.Max(Vector3.Max(lhs3, rhs3), Vector3.Max(lhs4, rhs4)));
int num = Mathf.Max((int)((vector.x - 1f) / 8f + 1080f), 0);
int num2 = Mathf.Max((int)((vector.z - 1f) / 8f + 1080f), 0);
int num3 = Mathf.Min((int)((vector2.x + 1f) / 8f + 1080f), 2159);
int num4 = Mathf.Min((int)((vector2.z + 1f) / 8f + 1080f), 2159);
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num5 = __instance.m_citizenGrid[i * 2160 + j];
if (num5 != 0)
{
___m_renderBuffer[num5 >> 6] |= (ulong)(1L << (int)num5);
}
}
}
int num6 = ___m_renderBuffer.Length;
for (int k = 0; k < num6; k++)
{
ulong num7 = ___m_renderBuffer[k];
if (num7 == 0)
{
continue;
}
for (int l = 0; l < 64; l++)
{
ulong num8 = (ulong)(1L << l);
if ((num7 & num8) == 0)
{
continue;
}
ushort num9 = (ushort)((k << 6) | l);
if (!__instance.m_instances.m_buffer[num9].RenderInstance(cameraInfo, num9))
{
num7 &= ~num8;
}
ushort nextGridInstance = __instance.m_instances.m_buffer[num9].m_nextGridInstance;
int num10 = 0;
while (nextGridInstance != 0)
{
int num11 = nextGridInstance >> 6;
num8 = (ulong)(1L << (int)nextGridInstance);
if (num11 == k)
{
if ((num7 & num8) != 0)
{
break;
}
num7 |= num8;
}
else
{
ulong num12 = ___m_renderBuffer[num11];
if ((num12 & num8) != 0)
{
break;
}
___m_renderBuffer[num11] = (num12 | num8);
}
if (nextGridInstance > num9)
{
break;
}
nextGridInstance = __instance.m_instances.m_buffer[nextGridInstance].m_nextGridInstance;
if (++num10 > 65536)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
___m_renderBuffer[k] = num7;
}
var action = new Action(() =>
{
int num13 = PrefabCollection <CitizenInfo> .PrefabCount();
for (int m = 0; m < num13; m++)
{
CitizenInfo prefab = PrefabCollection <CitizenInfo> .GetPrefab((uint)m);
if ((object)prefab != null)
{
prefab.UpdatePrefabInstances();
if (prefab.m_lodCount != 0)
{
CitizenInstance.RenderLod(cameraInfo, prefab);
}
if (prefab.m_undergroundLodCount != 0)
{
CitizenInstance.RenderUndergroundLod(cameraInfo, prefab);
}
}
}
});
#if UseTask
Patcher.Dispatcher.Add(action);
#else
action.Invoke();
#endif
return(false);
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
base.RenderOverlay(cameraInfo);
RenderIntersections(cameraInfo);
}
public void AfterRenderExtraStuff(VehicleAI thiz, ushort vehicleID, ref Vehicle vehicleData, RenderManager.CameraInfo cameraInfo, InstanceID id, Vector3 position, Quaternion rotation, Vector4 tyrePosition, Vector4 lightState, Vector3 scale, Vector3 swayPosition, bool underground, bool overground)
{
if (thiz.m_info == null || thiz.m_info.m_vehicleAI == null || thiz.m_info.m_subMeshes == null)
{
return;
}
GetTargetDescriptor(thiz.m_info.name, out _, out LayoutDescriptorVehicleXml targetDescriptor);
if (targetDescriptor != null)
{
Vehicle.Flags flags = VehicleManager.instance.m_vehicles.m_buffer[vehicleID].m_flags;
Matrix4x4 vehicleMatrix = thiz.m_info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref rotation, ref scale, ref swayPosition);
MaterialPropertyBlock materialBlock = VehicleManager.instance.m_materialBlock;
materialBlock.Clear();
RenderDescriptor(ref vehicleData, cameraInfo, vehicleID, position, vehicleMatrix, ref targetDescriptor);
}
}
public virtual void RenderInfoOverlay(RenderManager.CameraInfo cameraInfo)
{
}
public static void NetNodeRenderInstancePostfix(RenderManager.CameraInfo cameraInfo, ushort nodeID, ref RenderManager.Instance data) => NodeManager.Render(cameraInfo, nodeID, ref data);
internal static void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
//Log.DebugWait($"Managers_RenderOverlay.Postfix(): LaneIndex={LaneIndex} Info={Info}");
if (HoveredInfo is NetInfo.Lane laneInfo)
{
for (ushort segmentID = 1; segmentID < NetManager.MAX_SEGMENT_COUNT; ++segmentID)
{
if (!NetUtil.IsSegmentValid(segmentID))
{
continue;
}
var m_lanes = segmentID.ToSegment().Info.m_lanes;
int laneIndex = m_lanes.IndexOf(laneInfo);
if (laneIndex < 0)
{
continue;
}
uint laneID = NetUtil.GetlaneID(segmentID, laneIndex);
LaneData lane = new LaneData(laneID, laneIndex);
RenderUtil.RenderLaneOverlay(cameraInfo, lane, Color.yellow);
}
}
while (SegmentQueue.Count > 0)
{
var item = SegmentQueue.Dequeue();
Color color = item.TurnAround ? ORANGE : Color.yellow;
RenderUtil.RenderSegmnetOverlay(cameraInfo, item.SegmentID, color);
}
while (NodeQueue.Count > 0)
{
var item = NodeQueue.Dequeue();
bool end = item.NodeID.ToNode().m_flags.IsFlagSet(NetNode.Flags.End);
if (item.IsBendNode || end)
{
RenderUtil.DrawNodeCircle(cameraInfo, Color.yellow, item.NodeID);
}
else if (item.IsDC)
{
DrawDC(cameraInfo, item.SegmentID, item.SegmentID2, item.NodeID);
}
else
{
HighlightSegmentEnd(cameraInfo, item.SegmentID, item.NodeID, Color.yellow);
}
}
while (PropQueue.Count > 0)
{
var item = PropQueue.Dequeue();
PropTool.RenderOverlay(
cameraInfo, item.Prop, item.Pos, item.Scale, item.Angle, Color.yellow);
}
while (TreeQueue.Count > 0)
{
var item = TreeQueue.Dequeue();
TreeTool.RenderOverlay(cameraInfo, item.Tree, item.Pos, item.Scale, Color.yellow);
}
}
protected override void RenderGroupFG(RenderManager.CameraInfo cameraInfo) => LeaveBounds.Render(cameraInfo, Colors.Blue, LeaveBounds.Size);
private void ShowOverlay(bool viewOnly, RenderManager.CameraInfo cameraInfo)
{
if (viewOnly && !Options.connectedLanesOverlay)
{
return;
}
NetManager netManager = Singleton <NetManager> .instance;
var camPos = Singleton <SimulationManager> .instance.m_simulationView.m_position;
Bounds bounds = new Bounds(Vector3.zero, Vector3.one);
Ray mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition);
//for (ushort nodeId = 1; nodeId < NetManager.MAX_NODE_COUNT; ++nodeId) {
foreach (KeyValuePair <ushort, List <NodeLaneMarker> > e in currentNodeMarkers)
{
ushort nodeId = e.Key;
List <NodeLaneMarker> nodeMarkers = e.Value;
Vector3 nodePos = NetManager.instance.m_nodes.m_buffer[nodeId].m_position;
var diff = nodePos - camPos;
if (diff.magnitude > TrafficManagerTool.PriorityCloseLod)
{
continue; // do not draw if too distant
}
foreach (NodeLaneMarker laneMarker in nodeMarkers)
{
foreach (NodeLaneMarker targetLaneMarker in laneMarker.connectedMarkers)
{
// render lane connection from laneMarker to targetLaneMarker
RenderLane(cameraInfo, laneMarker.position, targetLaneMarker.position, nodePos, laneMarker.color);
}
if (!viewOnly && nodeId == SelectedNodeId)
{
bounds.center = laneMarker.position;
bool markerIsHovered = bounds.IntersectRay(mouseRay);
// draw source marker in source selection mode,
// draw target marker (if segment turning angles are within bounds) and selected source marker in target selection mode
bool drawMarker = (GetMarkerSelectionMode() == MarkerSelectionMode.SelectSource && laneMarker.isSource) ||
(GetMarkerSelectionMode() == MarkerSelectionMode.SelectTarget && (
(!laneMarker.isSource &&
(laneMarker.vehicleType & selectedMarker.vehicleType) != VehicleInfo.VehicleType.None &&
CheckSegmentsTurningAngle(selectedMarker.segmentId, ref netManager.m_segments.m_buffer[selectedMarker.segmentId], selectedMarker.startNode, laneMarker.segmentId, ref netManager.m_segments.m_buffer[laneMarker.segmentId], laneMarker.startNode)
) || laneMarker == selectedMarker));
// highlight hovered marker and selected marker
bool highlightMarker = drawMarker && (laneMarker == selectedMarker || markerIsHovered);
if (drawMarker)
{
if (highlightMarker)
{
laneMarker.radius = 2f;
}
else
{
laneMarker.radius = 1f;
}
}
else
{
markerIsHovered = false;
}
if (markerIsHovered)
{
/*if (hoveredMarker != sourceLaneMarker)
* Log._Debug($"Marker @ lane {sourceLaneMarker.laneId} hovered");*/
hoveredMarker = laneMarker;
}
if (drawMarker)
{
RenderManager.instance.OverlayEffect.DrawCircle(cameraInfo, laneMarker.color, laneMarker.position, laneMarker.radius, -1f, 1280f, false, true);
}
}
}
}
}
public new void Render(RenderManager.CameraInfo cameraInfo, Color?color = null, float?width = null, bool?alphaBlend = null, bool?cut = null)
{
First.Render(cameraInfo, color, width, alphaBlend, cut);
Second.Render(cameraInfo, color, width, alphaBlend, cut);
}
public override void RenderCloneOverlay(InstanceState state, ref Matrix4x4 matrix4x, Vector3 deltaPosition, float deltaAngle, Vector3 center, bool followTerrain, RenderManager.CameraInfo cameraInfo, Color toolColor)
{
}
public void Render(RenderManager.CameraInfo cameraInfo, Color?color = null, float?width = null, bool?alphaBlend = null, bool?cut = null) => NodeMarkupTool.RenderCircle(cameraInfo, Position, color, width ?? DefaultWidth, alphaBlend);
void RenderLane(RenderManager.CameraInfo cameraInfo, Vector3 start, Vector3 end, Color color, float size = 0.1f)
{
Vector3 middlePoint = (start + end) / 2f;
RenderLane(cameraInfo, start, end, middlePoint, color, size);
}
public static void NetNodeRenderInstancePostfix(RenderManager.CameraInfo cameraInfo, ushort nodeID, ref RenderManager.Instance data) => SingletonManager <NodeMarkupManager> .Instance.Render(cameraInfo, nodeID, ref data);
public static void RenderCloneGeometryImplementation(InstanceState instanceState, ref Matrix4x4 matrix4x, Vector3 deltaPosition, float deltaAngle, Vector3 center, bool followTerrain, RenderManager.CameraInfo cameraInfo)
{
InstanceID id = instanceState.instance.id;
PropInfo info = instanceState.Info.Prefab as PropInfo;
Randomizer randomizer = new Randomizer(id.Prop);
float scale = info.m_minScale + (float)randomizer.Int32(10000u) * (info.m_maxScale - info.m_minScale) * 0.0001f;
Vector3 newPosition = matrix4x.MultiplyPoint(instanceState.position - center);
newPosition.y = instanceState.position.y + deltaPosition.y;
if (followTerrain)
{
newPosition.y = newPosition.y - instanceState.terrainHeight + TerrainManager.instance.SampleOriginalRawHeightSmooth(newPosition);
}
float newAngle = instanceState.angle + deltaAngle;
if (info.m_requireHeightMap)
{
TerrainManager.instance.GetHeightMapping(newPosition, out Texture heightMap, out Vector4 heightMapping, out Vector4 surfaceMapping);
PropInstance.RenderInstance(cameraInfo, info, id, newPosition, scale, newAngle, info.GetColor(ref randomizer), RenderManager.DefaultColorLocation, true, heightMap, heightMapping, surfaceMapping);
}
else
{
PropInstance.RenderInstance(cameraInfo, info, id, newPosition, scale, newAngle, info.GetColor(ref randomizer), RenderManager.DefaultColorLocation, true);
}
}
public static void NetSegmentRenderInstancePostfix(RenderManager.CameraInfo cameraInfo, ushort segmentID, ref RenderManager.Instance data) => SingletonManager <SegmentMarkupManager> .Instance.Render(cameraInfo, segmentID, ref data);
public abstract void Render(RenderManager.CameraInfo cameraInfo);
/// <summary>
/// Perform rendering of a measurement.
/// </summary>
private void HandleMeasurement(RenderManager.CameraInfo cameraInfo, Measurement m)
{
// TODO: Move out of this slightly monolithic manager class
if ((m.Flags & MeasurementFlags.Secondary) != 0 && !_secondaryDetailEnabled)
{
return;
}
if ((m.Flags & MeasurementFlags.Guide) != 0 && !SnapController.EnableAdvancedSnapping)
{
return;
}
if ((m.Flags & MeasurementFlags.Snap) != 0 && !SnapController.EnableSnapping)
{
return;
}
if (m is AngleMeasurement)
{
var am = m as AngleMeasurement;
if (am.AngleSize < 1f)
{
return;
}
AngleRenderer.Render(cameraInfo, am);
var label = _ui.GetMeasurementLabel();
label.SetValue(string.Format("{0:#.0}{1}", am.AngleSize.RoundToNearest(0.1f), "°"));
label.SetWorldPosition(cameraInfo, AngleRenderer.GetLabelWorldPosition(am));
return;
}
if (m is DistanceMeasurement)
{
var dm = m as DistanceMeasurement;
if (Mathf.Abs(dm.Length) < Settings.MinimumDistanceMeasure)
{
return;
}
DistanceRenderer.Render(cameraInfo, dm);
var label = _ui.GetMeasurementLabel();
string dist;
if ((dm.Flags & MeasurementFlags.Height) != 0)
{
dist = string.Format("H: {0}", StringUtil.GetHeightMeasurementString(dm.Length));
}
else
{
dist = StringUtil.GetDistanceMeasurementString(dm.Length, _secondaryDetailEnabled);
if (_secondaryDetailEnabled)
{
var heightdiff = (int)dm.RelativeHeight.RoundToNearest(1);
if (Mathf.Abs(heightdiff) > 0)
{
dist += string.Format("\n(Elev: {0})", StringUtil.GetHeightMeasurementString(heightdiff));
}
}
}
label.SetValue(dist);
label.SetWorldPosition(cameraInfo, DistanceRenderer.GetLabelWorldPosition(dm));
return;
}
Debug.LogError("Measurement has no renderer: " + m);
}
public override void RenderCloneGeometry(InstanceState instanceState, ref Matrix4x4 matrix4x, Vector3 deltaPosition, float deltaAngle, Vector3 center, bool followTerrain, RenderManager.CameraInfo cameraInfo, Color toolColor)
{
RenderCloneGeometryImplementation(instanceState, ref matrix4x, deltaPosition, deltaAngle, center, followTerrain, cameraInfo);
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
if (MainTool.GetToolController().IsInsideUI || !Cursor.visible)
{
return;
}
bool ctrlDown = Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl);
bool shiftDown = Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
MassEditOVerlay.Show = ctrlDown;
if (ctrlDown)
{
massEditMode = PrioritySignsMassEditMode.MainYield;
}
if (HoveredSegmentId == 0)
{
if (shiftDown)
{
massEditMode = PrioritySignsMassEditMode.MainYield;
}
return;
}
if (shiftDown)
{
bool isRAbout = RoundaboutMassEdit.Instance.TraverseLoop(HoveredSegmentId, out var segmentList);
Color color = MainTool.GetToolColor(Input.GetMouseButton(0), false);
if (isRAbout)
{
foreach (uint segmentId in segmentList)
{
ref NetSegment seg = ref Singleton <NetManager> .instance.m_segments.m_buffer[segmentId];
NetTool.RenderOverlay(
cameraInfo,
ref seg,
color,
color);
} // end foreach
}
else
{
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);
});
}
return;
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
}
public override void RenderEffect(InstanceID id, SpawnArea area, Vector3 velocity, float acceleration, float magnitude, float timeOffset, float timeDelta, RenderManager.CameraInfo cameraInfo)
{
this.velocity = velocity.magnitude;
if (velocity.magnitude >= m_params.m_minSpeed && velocity.magnitude <= m_params.m_maxSpeed)
{
base.RenderEffect(id, area, velocity, acceleration, magnitude, timeOffset, timeDelta, cameraInfo);
}
}
public override void RenderInfoOverlay(RenderManager.CameraInfo cameraInfo)
{
ShowOverlay(true, cameraInfo);
}
protected override void RenderGroupFG(RenderManager.CameraInfo cameraInfo) => RenderGroup(cameraInfo, Colors.Blue, Width);
