public static void CalculateJoinAngles(NetToolProxy netTool, ICollection<Measurement> measurements)
{
if (netTool.ControlPointsCount < 1)
{
return;
}
if (netTool.ControlPoints[netTool.ControlPointsCount].m_segment == 0)
{
return;
}
var sourceControlPoint = netTool.ControlPoints[netTool.ControlPointsCount - 1];
var lastControlPoint = netTool.ControlPoints[netTool.ControlPointsCount];
if (sourceControlPoint.m_segment == lastControlPoint.m_segment)
{
return;
}
var lineDirection =
lastControlPoint.m_position.Flatten().DirectionTo(sourceControlPoint.m_position.Flatten());
Vector3 segmentDirection;
Vector3 segmentPosition;
NetManager.instance.m_segments.m_buffer[lastControlPoint.m_segment].GetClosestPositionAndDirection(
lastControlPoint.m_position, out segmentPosition, out segmentDirection);
CalculateAngles(segmentPosition, segmentDirection.Flatten(), lineDirection, measurements);
}
/// <summary>
/// Calculate the angles to other segments branching from the same node
/// </summary>
/// <param name="netTool"></param>
/// <param name="measurements">Collection to populate with measurements</param>
public static void CalculateJoinAngles(NetToolProxy netTool, ICollection <Measurement> measurements)
{
if (netTool.ControlPoints.Count < 1)
{
return;
}
if (netTool.ControlPoints[0].m_node == netTool.ControlPoints[1].m_node)
{
return;
}
var controlPoint = netTool.ControlPoints[netTool.ControlPointsCount];
var destNodeId = controlPoint.m_node;
if (destNodeId == 0)
{
return;
}
if (netTool.NodePositions.m_size < 2)
{
return;
}
//var lastNode = netTool.NodePositions[netTool.NodePositions.m_size-1];
CalculateAngles(destNodeId, -controlPoint.m_direction, measurements);
}
/// <summary>
/// Calculate the angles between branch and the segment it branches from
/// </summary>
/// <param name="netTool"></param>
/// <param name="measurements">Collection to populate with measurements</param>
public static void CalculateSegmentBranchAngles(NetToolProxy netTool, ICollection<Measurement> measurements)
{
if (netTool.ControlPointsCount < 1)
{
return;
}
if (netTool.ControlPoints[0].m_segment == 0)
{
return;
}
var sourceControlPoint = netTool.ControlPoints[0];
var destControlPoint = netTool.ControlPoints[1];
if (sourceControlPoint.m_segment == destControlPoint.m_segment)
{
return;
}
var lineDirection =
sourceControlPoint.m_position.Flatten().DirectionTo(destControlPoint.m_position.Flatten());
CalculateAngles(sourceControlPoint.m_position, sourceControlPoint.m_direction.Flatten(), lineDirection,
measurements);
}
/// <summary>
/// Calculate the angles to other segments branching from the same node
/// </summary>
/// <param name="netTool"></param>
/// <param name="measurements">Collection to populate with measurements</param>
public static void CalculateJoinAngles(NetToolProxy netTool, ICollection<Measurement> measurements)
{
if (netTool.ControlPoints.Count < 1)
{
return;
}
if (netTool.ControlPoints[0].m_node == netTool.ControlPoints[1].m_node)
{
return;
}
var controlPoint = netTool.ControlPoints[netTool.ControlPointsCount];
var destNodeId = controlPoint.m_node;
if (destNodeId == 0)
{
return;
}
if (netTool.NodePositions.m_size < 2)
{
return;
}
//var lastNode = netTool.NodePositions[netTool.NodePositions.m_size-1];
CalculateAngles(destNodeId, -controlPoint.m_direction, measurements);
}
/// <summary>
/// Calculate the angles to other segments branching from the same node
/// </summary>
/// <param name="netTool"></param>
/// <param name="measurements">Collection to populate with measurements</param>
public static void CalculateBranchAngles(NetToolProxy netTool, ICollection <Measurement> measurements)
{
if (netTool.ControlPoints.Count < 1)
{
return;
}
if (netTool.ControlPoints[0].m_node == netTool.ControlPoints[1].m_node)
{
return;
}
var sourceNodeId = netTool.ControlPoints[0].m_node;
if (sourceNodeId == 0)
{
return;
}
if (netTool.ControlPointsCount < 1)
{
return;
}
var firstNewNode = netTool.NodePositions[0];
var direction = firstNewNode.m_direction;
if (netTool.NodePositions.m_size <= 1)
{
direction = netTool.ControlPoints[1].m_direction;
}
CalculateAngles(sourceNodeId, direction, measurements);
}
public static void CalculateJoinAngles(NetToolProxy netTool, ICollection <Measurement> measurements)
{
if (netTool.ControlPointsCount < 1)
{
return;
}
if (netTool.ControlPoints[netTool.ControlPointsCount].m_segment == 0)
{
return;
}
var sourceControlPoint = netTool.ControlPoints[netTool.ControlPointsCount - 1];
var lastControlPoint = netTool.ControlPoints[netTool.ControlPointsCount];
if (sourceControlPoint.m_segment == lastControlPoint.m_segment)
{
return;
}
var lineDirection =
lastControlPoint.m_position.Flatten().DirectionTo(sourceControlPoint.m_position.Flatten());
Vector3 segmentDirection;
Vector3 segmentPosition;
NetManager.instance.m_segments.m_buffer[lastControlPoint.m_segment].GetClosestPositionAndDirection(
lastControlPoint.m_position, out segmentPosition, out segmentDirection);
CalculateAngles(segmentPosition, segmentDirection.Flatten(), lineDirection, measurements);
}
/// <summary>
/// Calculate the angles to other segments branching from the same node
/// </summary>
/// <param name="netTool"></param>
/// <param name="measurements">Collection to populate with measurements</param>
public static void CalculateBranchAngles(NetToolProxy netTool, ICollection<Measurement> measurements)
{
if (netTool.ControlPoints.Count < 1)
{
return;
}
if (netTool.ControlPoints[0].m_node == netTool.ControlPoints[1].m_node)
{
return;
}
var sourceNodeId = netTool.ControlPoints[0].m_node;
if (sourceNodeId == 0)
{
return;
}
if (netTool.ControlPointsCount < 1)
{
return;
}
var firstNewNode = netTool.NodePositions[0];
var direction = firstNewNode.m_direction;
if (netTool.NodePositions.m_size <= 1)
{
direction = netTool.ControlPoints[1].m_direction;
}
CalculateAngles(sourceNodeId, direction, measurements);
}
/// <summary>
/// Calculate the angles between branch and the segment it branches from
/// </summary>
/// <param name="netTool"></param>
/// <param name="measurements">Collection to populate with measurements</param>
public static void CalculateSegmentBranchAngles(NetToolProxy netTool, ICollection <Measurement> measurements)
{
if (netTool.ControlPointsCount < 1)
{
return;
}
if (netTool.ControlPoints[0].m_segment == 0)
{
return;
}
var sourceControlPoint = netTool.ControlPoints[0];
var destControlPoint = netTool.ControlPoints[1];
if (sourceControlPoint.m_segment == destControlPoint.m_segment)
{
return;
}
var lineDirection =
sourceControlPoint.m_position.Flatten().DirectionTo(destControlPoint.m_position.Flatten());
CalculateAngles(sourceControlPoint.m_position, sourceControlPoint.m_direction.Flatten(), lineDirection,
measurements);
}
private void Unload()
{
Debug.Log("Manager Unload");
_netToolProxy = null;
_isLoaded = false;
_ui.ReleaseAll();
}
private void Update()
{
// Search for NetTool if not already loaded.
// Performing this in the default MonoBehaviour so that we will
// correctly catch any modded NetTools that replace the default.
if (_isLoaded && !IsEnabled)
{
Debug.Log("Loading NetTool");
_netToolProxy = NetToolLocator.Locate();
if (_netToolProxy != null)
{
Settings.BlueprintColor = _netToolProxy.ToolController.m_validColor;
_ui.NetToolProxy = _netToolProxy;
}
}
}
public static void CalculateGuideLineAngle(NetToolProxy netTool, IList<Measurement> measurements)
{
if (netTool.ControlPointsCount == 0)
return;
lock (SnapController.GuideLineLock) {
if (!SnapController.SnappedGuideLine.HasValue)
return;
var lastControlPoint = netTool.ControlPoints[netTool.ControlPointsCount];
var guideLine = SnapController.SnappedGuideLine.Value;
var incomingDirection = lastControlPoint.m_direction;
CalculateAngles(guideLine.Intersect, guideLine.Direction, -incomingDirection, measurements);
}
}
public static void CalculateGuideLineDistance(NetToolProxy netTool, ICollection<Measurement> measurements)
{
if (netTool.ControlPointsCount == 0)
return;
lock (SnapController.GuideLineLock) {
if (!SnapController.SnappedGuideLine.HasValue)
return;
var guideLine = SnapController.SnappedGuideLine.Value;
var dist = Vector3.Distance(guideLine.Origin.Flatten(), guideLine.Intersect.Flatten());
var pos = Vector3Extensions.Average(guideLine.Origin, guideLine.Intersect);
measurements.Add(new DistanceMeasurement(dist, pos, true, guideLine.Origin, guideLine.Intersect,
MeasurementFlags.HideOverlay | MeasurementFlags.Guide));
}
}
public static void CalculateGuideLineAngle(NetToolProxy netTool, IList <Measurement> measurements)
{
if (netTool.ControlPointsCount == 0)
{
return;
}
lock (SnapController.GuideLineLock)
{
if (!SnapController.SnappedGuideLine.HasValue)
{
return;
}
var lastControlPoint = netTool.ControlPoints[netTool.ControlPointsCount];
var guideLine = SnapController.SnappedGuideLine.Value;
var incomingDirection = lastControlPoint.m_direction;
CalculateAngles(guideLine.Intersect, guideLine.Direction, -incomingDirection, measurements);
}
}
public static void CalculateGuideLineDistance(NetToolProxy netTool, ICollection <Measurement> measurements)
{
if (netTool.ControlPointsCount == 0)
{
return;
}
lock (SnapController.GuideLineLock)
{
if (!SnapController.SnappedGuideLine.HasValue)
{
return;
}
var guideLine = SnapController.SnappedGuideLine.Value;
var dist = Vector3.Distance(guideLine.Origin.Flatten(), guideLine.Intersect.Flatten());
var pos = Vector3Extensions.Average(guideLine.Origin, guideLine.Intersect);
measurements.Add(new DistanceMeasurement(dist, pos, true, guideLine.Origin, guideLine.Intersect,
MeasurementFlags.HideOverlay | MeasurementFlags.Guide));
}
}
