protected override void CreateNode()
{
if (comm == null)
{
comm = new RACommNode(nodeTransform)
{
OnNetworkPreUpdate = new Action(OnNetworkPreUpdate),
isHome = true,
isControlSource = true,
isControlSourceMultiHop = true
};
}
comm.name = nodeName;
comm.displayName = displaynodeName;
comm.antennaRelay.Update(!isPermanent ? GameVariables.Instance.GetDSNRange(ScenarioUpgradeableFacilities.GetFacilityLevel(SpaceCenterFacility.TrackingStation)) : antennaPower, GameVariables.Instance.GetDSNRangeCurve(), false);
// Vector3d pos = (nodeTransform == null) ? transform.position : nodeTransform.position;
// body.GetLatLonAlt(pos, out lat, out lon, out alt);
RACommNode t = comm as RACommNode;
t.ParentBody = body;
int maxTL = HighLogic.CurrentGame.Parameters.CustomParams <RAParameters>().MaxTechLevel;
float fTSLvl = ScenarioUpgradeableFacilities.GetFacilityLevel(SpaceCenterFacility.TrackingStation);
int tsLevel = (HighLogic.CurrentGame.Mode == Game.Modes.CAREER) ? Convert.ToInt32(1 + (fTSLvl * maxTL)) : maxTL;
// Config node contains a list of antennas to build.
//Debug.LogFormat("Building all antennas for tech level {0} from {1}", tsLevel, config);
t.RAAntennaList = new List <RealAntenna> {
};
foreach (ConfigNode antNode in config.GetNodes("Antenna"))
{
//Debug.LogFormat("Building an antenna for {0}", antNode);
int targetLevel = Int32.Parse(antNode.GetValue("TechLevel"));
if (tsLevel >= targetLevel)
{
RealAntenna ant = new RealAntennaDigital(name)
{
ParentNode = comm
};
ant.LoadFromConfigNode(antNode);
ant.ProcessUpgrades(tsLevel, antNode);
ant.TechLevelInfo = TechLevelInfo.GetTechLevel(tsLevel);
t.RAAntennaList.Add(ant);
}
else
{
//Debug.LogFormat("Skipped because current techLevel {0} is less than required {1}", tsLevel, targetLevel);
}
}
}
public void GatherAntennaCones(RACommNode node, ref List <Vector3> targetPoints, ref List <Vector3> cone3Points, ref List <Vector3> cone10Points)
{
if (node == null || node.RAAntennaList.Count == 0)
{
return;
}
foreach (RealAntenna ra in node.RAAntennaList)
{
if (ra.CanTarget && ra.Target != null)
{
targetPoints.Add(node.position);
targetPoints.Add(ra.Target.GetTransform().position);
//Vector3d perpToCamera = new Vector3d(1, 0, 0);
Vector3 toTarget = ra.Target.GetTransform().position - node.position;
Vector3 perpToCamera = Vector3.Cross(toTarget, Vector3.up);
perpToCamera.Normalize();
float bw10 = Convert.ToSingle(ra.Beamwidth * Math.PI / 180);
float bw3 = bw10 / 2;
Vector3 leftbound10 = Vector3.RotateTowards(toTarget, perpToCamera, bw10, 0);
Vector3 rightbound10 = Vector3.RotateTowards(toTarget, perpToCamera, -1 * bw10, 0);
Vector3 leftbound3 = Vector3.RotateTowards(toTarget, perpToCamera, bw3, 0);
Vector3 rightbound3 = Vector3.RotateTowards(toTarget, perpToCamera, -1 * bw3, 0);
float coneScale = Convert.ToSingle(1e7);
leftbound3.Normalize();
leftbound10.Normalize();
rightbound3.Normalize();
rightbound10.Normalize();
leftbound3 *= coneScale;
leftbound10 *= coneScale;
rightbound3 *= coneScale;
rightbound10 *= coneScale;
cone3Points.Add(leftbound3 + node.position);
cone3Points.Add(node.position);
cone3Points.Add(rightbound3 + node.position);
cone3Points.Add(node.position);
cone10Points.Add(leftbound10 + node.position);
cone10Points.Add(node.position);
cone10Points.Add(rightbound10 + node.position);
cone10Points.Add(node.position);
}
}
}
protected override void CreateNode()
{
if (comm == null)
{
comm = new RACommNode(nodeTransform)
{
OnNetworkPreUpdate = new Action(OnNetworkPreUpdate),
isHome = true,
isControlSource = true,
isControlSourceMultiHop = true
};
}
comm.name = nodeName;
comm.displayName = displaynodeName;
comm.antennaRelay.Update(!isPermanent ? GameVariables.Instance.GetDSNRange(ScenarioUpgradeableFacilities.GetFacilityLevel(SpaceCenterFacility.TrackingStation)) : antennaPower, GameVariables.Instance.GetDSNRangeCurve(), false);
// Vector3d pos = (nodeTransform == null) ? transform.position : nodeTransform.position;
// body.GetLatLonAlt(pos, out lat, out lon, out alt);
RACommNode t = comm as RACommNode;
t.ParentBody = body;
int tsLevel = RACommNetScenario.GroundStationTechLevel;
// Config node contains a list of antennas to build.
t.RAAntennaList = new List <RealAntenna> {
};
foreach (ConfigNode antNode in config.GetNodes("Antenna"))
{
//Debug.LogFormat("Building an antenna for {0}", antNode);
int targetLevel = Int32.Parse(antNode.GetValue("TechLevel"));
if (tsLevel >= targetLevel)
{
RealAntenna ant = new RealAntennaDigital(name)
{
ParentNode = comm
};
ant.LoadFromConfigNode(antNode);
ant.ProcessUpgrades(tsLevel, antNode);
ant.TechLevelInfo = TechLevelInfo.GetTechLevel(tsLevel);
t.RAAntennaList.Add(ant);
}
}
}
protected override void UpdateList()
{
if (FlightGlobals.ActiveVessel.Connection?.Comm is RACommNode comm &&
FlightGlobals.ActiveVessel.Connection?.ControlPath is CommPath path)
{
if (items.Count != path.Count)
{
ClearList();
foreach (CommLink link in path)
{
Tooltip_SignalStrengthItem x = Instantiate(itemPrefab);
x.transform.SetParent(tooltip.listParent, false);
items.Add(new KeyValuePair <CommLink, Tooltip_SignalStrengthItem>(link, x));
}
}
foreach (KeyValuePair <CommLink, Tooltip_SignalStrengthItem> item in items)
{
RACommLink link = item.Key.start[item.Key.end] as RACommLink;
double linkRate = link.start.Equals(item.Key.start) ? link.FwdDataRate : link.RevDataRate;
RACommNode curNode = (link.start.Equals(item.Key.start) ? link.start : link.end) as RACommNode;
RACommNode oppNode = (link.start.Equals(item.Key.start) ? link.end : link.start) as RACommNode;
Tooltip_SignalStrengthItem x = item.Value;
x.Setup(item.Key.signal, $"{oppNode.displayName}: {RATools.PrettyPrintDataRate(linkRate)}");
x.transform.SetAsLastSibling();
}
if (path.Count > 0 && path.First is CommLink link1)
{
if (link1.start[link1.end] is RACommLink raLink)
{
double rate = (comm.Net as RACommNetwork).MaxDataRateToHome(comm);
double txMetric = raLink.start.Equals(comm) ? raLink.FwdMetric : raLink.RevMetric;
double rxMetric = raLink.start.Equals(comm) ? raLink.RevMetric : raLink.FwdMetric;
tooltip.title.SetText($"Signal (Tx/Rx) : {txMetric * 100:F0}%/{rxMetric*100:F0}% - {RATools.PrettyPrintDataRate(rate)}");
}
}
}
}
public void GatherDebugInfo(RealAntenna debugAntenna, List <CommNet.CommNode> Nodes, ref Network.ConnectionDebugger connectionDebugger, bool log = true)
{
var nodePairs = StringBuilderCache.Acquire();
var antPairs = StringBuilderCache.Acquire();
allAntennas.TryGetValue(debugAntenna, out int targetIndex);
foreach (var pair in allNodePairs)
{
if (pair.x <= pair.y)
{
var p2 = new int2(pair.y, pair.x);
if (validMap.TryGetValue(pair, out bool valid) &&
validMap.TryGetValue(p2, out bool valid2))
{
RACommNode a = Nodes[pair.x] as RACommNode;
RACommNode b = Nodes[pair.y] as RACommNode;
if (a == debugAntenna.ParentNode || b == debugAntenna.ParentNode)
{
nodePairs.AppendLine($"Nodes: {a.name} -> {b.name} Valid: {valid} / {valid2}");
}
}
}
}
for (int i = 0; i < allValidAntennaPairs.Length; i++)
{
var quad = allValidAntennaPairs[i];
if (targetIndex == quad.z || targetIndex == quad.w)
{
RealAntenna tx = allAntennasReverse[quad.z];
RealAntenna rx = allAntennasReverse[quad.w];
var otherAntenna = (tx == debugAntenna) ? rx : tx;
if (tx == debugAntenna || rx == debugAntenna)
{
double3 txToRx = rxPos[i] - txPos[i];
double3 rxToTx = txPos[i] - rxPos[i];
double txToRxAngle = MathUtils.Angle2(txToRx, txDir[i]);
double rxToTxAngle = MathUtils.Angle2(rxToTx, rxDir[i]);
var debugData = new Network.LinkDetails
{
txNode = Nodes[quad.x] as RACommNode,
rxNode = Nodes[quad.y] as RACommNode,
tx = tx,
rx = rx,
txPower = txPower[i],
rxPower = rxPower[i],
txPos = txPos[i],
rxPos = rxPos[i],
txToRx = txToRx,
rxToTx = rxToTx,
txDir = txDir[i],
rxDir = rxDir[i],
txBeamwidth = txBeamwidth[i],
rxBeamwidth = rxBeamwidth[i],
txToRxAngle = txToRxAngle,
rxToTxAngle = rxToTxAngle,
txPointLoss = Physics.PointingLoss(txToRxAngle, txBeamwidth[i]),
rxPointLoss = Physics.PointingLoss(rxToTxAngle, rxBeamwidth[i]),
pointingLoss = pointingLoss[i],
pathLoss = pathLoss[i],
atmosphereNoise = atmosphereNoise[i],
bodyNoise = bodyNoise[i],
noiseTemp = noiseTemp[i],
noise = atmosphereNoise[i] + bodyNoise[i] + noiseTemp[i],
N0 = n0[i],
minEb = minEb[i],
minDataRate = minDataRate[i],
dataRate = dataRate[i],
maxDataRate = maxDataRate[i],
rateSteps = rateSteps[i],
};
if (!connectionDebugger.items.ContainsKey(otherAntenna))
{
connectionDebugger.items.Add(otherAntenna, new List <Network.LinkDetails>());
}
var item = connectionDebugger.items[otherAntenna];
string sData = $"{debugData}";
item.Add(debugData);
antPairs.AppendLine(sData);
}
else
{
antPairs.AppendLine($"Thought indices {quad.z} or {quad.w} matched target {targetIndex} but discovered antennas {tx} | {rx} | looking for {debugAntenna}");
}
}
}
if (log)
{
UnityEngine.Debug.Log($"[RealAntennas.Jobs] {nodePairs}");
UnityEngine.Debug.Log($"[RealAntennas.Jobs] {antPairs}");
}
nodePairs.Release();
antPairs.Release();
connectionDebugger = null;
}
public void Complete(RACommNetwork RACN)
{
if (!tempAllocationsActive)
{
return;
}
Profiler.BeginSample("RealAntennas PreCompute.Complete.Gather");
precomputeJobHandle.Complete();
Profiler.EndSample();
Profiler.BeginSample("RealAntennas PreCompute.Complete.Linkages");
foreach (var pair in allNodePairs)
{
if (pair.x <= pair.y && pair.y < RACN.Nodes.Count)
{
var p2 = new int2(pair.y, pair.x);
if (validMap.TryGetValue(pair, out bool valid) && valid &&
validMap.TryGetValue(p2, out bool valid2) && valid2 &&
bestMap.TryGetValue(pair, out int row) &&
bestMap.TryGetValue(p2, out int row2) &&
row >= 0 && row2 >= 0 &&
dataRate[row] > 0 && dataRate[row2] > 0)
{
// Connect Successful
RACommNode a = RACN.Nodes[pair.x] as RACommNode;
RACommNode b = RACN.Nodes[pair.y] as RACommNode;
int4 fwdQuad = allValidAntennaPairs[row];
int4 revQuad = allValidAntennaPairs[row2];
/*
* RealAntenna fwdTx = allAntennasReverse[fwdQuad.z];
* RealAntenna fwdRx = allAntennasReverse[fwdQuad.w];
* RealAntenna revTx = allAntennasReverse[revQuad.z];
* RealAntenna revRx = allAntennasReverse[revQuad.w];
* double fwd = dataRate[row];
* double rev = dataRate[row2];
* double FwdBestDataRate = maxDataRate[row];
* double RevBestDataRate = maxDataRate[row2];
*/
double FwdMetric = 1.0 - ((float)rateSteps[row] / (maxSteps[row] + 1));
double RevMetric = 1.0 - ((float)rateSteps[row2] / (maxSteps[row2] + 1));
//RACN.MakeLink(fwdTx, fwdRx, revTx, revRx, a, b, (a.position - b.position).magnitude, fwd, rev, FwdBestDataRate, FwdMetric, RevMetric);
RACN.MakeLink(allAntennasReverse[fwdQuad.z],
allAntennasReverse[fwdQuad.w],
allAntennasReverse[revQuad.z],
allAntennasReverse[revQuad.w],
a,
b,
(a.position - b.position).magnitude,
dataRate[row],
dataRate[row2],
maxDataRate[row],
FwdMetric,
RevMetric);
}
else
{
RACN.DoDisconnect(RACN.Nodes[pair.x], RACN.Nodes[pair.y]);
}
}
}
if (RACN.connectionDebugger is Network.ConnectionDebugger)
{
GatherDebugInfo(RACN.DebugAntenna, RACN.Nodes, ref RACN.connectionDebugger);
}
DisposeJobData();
Profiler.EndSample();
}
public GroundStationSiteNode(RACommNode node)
{
this.node = node;
}
public void GatherAntennaCones(RACommNode node)
{
if (node == null || node.RAAntennaList.Count == 0)
{
return;
}
CheckRenderers(node);
foreach (RealAntenna ra in node.RAAntennaList)
{
if (ra.CanTarget && ra.Target != null)
{
CheckRenderer(targetRenderers[node], ra);
CheckRenderer(cone3Renderers[node], ra);
CheckRenderer(cone10Renderers[node], ra);
LineRenderer targetRenderer = targetRenderers[node][ra].GetComponent <LineRenderer>();
LineRenderer cone3Renderer = cone3Renderers[node][ra].GetComponent <LineRenderer>();
LineRenderer cone10Renderer = cone10Renderers[node][ra].GetComponent <LineRenderer>();
Vector3d axis = ra.ToTargetByTransform;
double len = Math.Min(1e8f, axis.magnitude);
if (ra.Target is CelestialBody body)
{
len = Math.Min(len, axis.magnitude - body.Radius);
}
axis.Normalize();
axis *= len;
Cone cone10 = new Cone(node.position, axis, Vector3.up, ra.Beamwidth);
Cone cone3 = new Cone(node.position, axis, Vector3.up, ra.Beamwidth / 2);
targetPoints.Clear();
cone3Points.Clear();
cone10Points.Clear();
Camera cam = PlanetariumCamera.Camera;
Vector3 camPos = cam.transform.position;
if (drawTarget)
{
targetPoints.Add(node.position);
targetPoints.Add(node.position + ra.ToTargetByTransform);
ScaledSpace.LocalToScaledSpace(targetPoints);
float dStart = Vector3.Distance(camPos, targetPoints[0]);
float dEnd = Vector3.Distance(camPos, targetPoints[1]);
targetRenderer.startWidth = dStart * lineScaleWidth / 1000;
targetRenderer.endWidth = dEnd * lineScaleWidth / 1000;
SetColorGradient(targetRenderer, colorToTarget, colorToTarget, ConeOpacity, ConeOpacity);
}
if (drawCone3 && drawConesMode != DrawConesMode.None)
{
cone3Points.Add(cone3.end1);
cone3Points.Add(cone3.vertex);
if (drawConesMode == DrawConesMode.Cone3D)
{
MakeCircles(cone3Points, cone3, numCircles);
}
else
{
cone3Points.Add(cone3.end2);
}
ScaledSpace.LocalToScaledSpace(cone3Points);
float dStart = Vector3.Distance(camPos, ScaledSpace.LocalToScaledSpace(cone3.vertex));
cone3Renderer.startWidth = dStart * lineScaleWidth / 1000;
cone3Renderer.endWidth = dStart * lineScaleWidth / 1000;
SetColorGradient(cone3Renderer, color3dB, color3dB, ConeOpacity, ConeOpacity);
}
if (drawCone10 && drawConesMode != DrawConesMode.None)
{
cone10Points.Add(cone10.end1);
cone10Points.Add(cone10.vertex);
if (drawConesMode == DrawConesMode.Cone3D)
{
MakeCircles(cone10Points, cone10, numCircles);
}
else
{
cone10Points.Add(cone10.end2);
}
ScaledSpace.LocalToScaledSpace(cone10Points);
float dStart = Vector3.Distance(camPos, ScaledSpace.LocalToScaledSpace(cone10.vertex));
cone10Renderer.startWidth = dStart * lineScaleWidth / 1000;
cone10Renderer.endWidth = dStart * lineScaleWidth / 1000;
SetColorGradient(cone10Renderer, color10dB, color10dB, ConeOpacity, ConeOpacity);
}
targetRenderer.positionCount = targetPoints.Count;
targetRenderer.SetPositions(targetPoints.ToArray());
targetRenderer.enabled = drawTarget;
cone3Renderer.positionCount = cone3Points.Count;
cone3Renderer.SetPositions(cone3Points.ToArray());
cone3Renderer.enabled = drawCone3 && drawConesMode != DrawConesMode.None;
cone10Renderer.positionCount = cone10Points.Count;
cone10Renderer.SetPositions(cone10Points.ToArray());
cone10Renderer.enabled = drawCone10 && drawConesMode != DrawConesMode.None;
}
}
}
public void GatherAntennaCones(RACommNode node)
{
if (node == null || node.RAAntennaList.Count == 0)
{
return;
}
var settings = RACommNetScenario.MapUISettings;
CheckRenderers(node);
foreach (RealAntenna ra in node.RAAntennaList)
{
if (ra.CanTarget && ra.Target != null)
{
CheckRenderer(targetRenderers[node], ra);
CheckRenderer(cone3Renderers[node], ra);
CheckRenderer(cone10Renderers[node], ra);
LineRenderer targetRenderer = targetRenderers[node][ra].GetComponent <LineRenderer>();
LineRenderer cone3Renderer = cone3Renderers[node][ra].GetComponent <LineRenderer>();
LineRenderer cone10Renderer = cone10Renderers[node][ra].GetComponent <LineRenderer>();
Vector3d axis = ra.ToTarget;
double len = Math.Min(1e8f, axis.magnitude);
axis.Normalize();
axis *= len;
cone10.Init(node.precisePosition, axis, Vector3.up, ra.Beamwidth);
cone3.Init(node.precisePosition, axis, Vector3.up, ra.Beamwidth / 2);
targetPoints.Clear();
cone3Points.Clear();
cone10Points.Clear();
Camera cam = PlanetariumCamera.Camera;
Vector3 camPos = cam.transform.position;
if (settings.drawTarget)
{
targetPoints.Add(node.precisePosition);
targetPoints.Add(node.precisePosition + ra.ToTarget);
LocalToScaledSpace(targetPoints, targetPoints_out);
float dStart = Vector3.Distance(camPos, targetPoints_out[0]);
float dEnd = Vector3.Distance(camPos, targetPoints_out[1]);
targetRenderer.startWidth = dStart * settings.lineScaleWidth / 1000;
targetRenderer.endWidth = dEnd * settings.lineScaleWidth / 1000;
SetColorGradient(targetRenderer, colorToTarget, colorToTarget, settings.coneOpacity, settings.coneOpacity);
}
if (settings.drawCone3 && settings.drawConesMode != DrawConesMode.None)
{
cone3Points.Add(cone3.end1);
cone3Points.Add(cone3.vertex);
if (settings.drawConesMode == DrawConesMode.Cone3D)
{
MakeCircles(cone3Points, cone3, settings.coneCircles);
}
else
{
cone3Points.Add(cone3.end2);
}
LocalToScaledSpace(cone3Points, cone3Points_out);
float dStart = Vector3.Distance(camPos, ScaledSpace.LocalToScaledSpace(cone3.vertex));
cone3Renderer.startWidth = dStart * settings.lineScaleWidth / 1000;
cone3Renderer.endWidth = dStart * settings.lineScaleWidth / 1000;
SetColorGradient(cone3Renderer, color3dB, color3dB, settings.coneOpacity, settings.coneOpacity);
}
if (settings.drawCone10 && settings.drawConesMode != DrawConesMode.None)
{
cone10Points.Add(cone10.end1);
cone10Points.Add(cone10.vertex);
if (settings.drawConesMode == DrawConesMode.Cone3D)
{
MakeCircles(cone10Points, cone10, settings.coneCircles);
}
else
{
cone10Points.Add(cone10.end2);
}
LocalToScaledSpace(cone10Points, cone10Points_out);
float dStart = Vector3.Distance(camPos, ScaledSpace.LocalToScaledSpace(cone10.vertex));
cone10Renderer.startWidth = dStart * settings.lineScaleWidth / 1000;
cone10Renderer.endWidth = dStart * settings.lineScaleWidth / 1000;
SetColorGradient(cone10Renderer, color10dB, color10dB, settings.coneOpacity, settings.coneOpacity);
}
targetRenderer.positionCount = targetPoints.Count;
targetRenderer.SetPositions(targetPoints_out.ToArray());
targetRenderer.enabled = settings.drawTarget;
cone3Renderer.positionCount = cone3Points.Count;
cone3Renderer.SetPositions(cone3Points_out.ToArray());
cone3Renderer.enabled = settings.drawCone3 && settings.drawConesMode != DrawConesMode.None;
cone10Renderer.positionCount = cone10Points.Count;
cone10Renderer.SetPositions(cone10Points_out.ToArray());
cone10Renderer.enabled = settings.drawCone10 && settings.drawConesMode != DrawConesMode.None;
}
}
}
