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);