| public static AreLineSegmentsCrossing ( Vector3 pointA1, Vector3 pointA2, Vector3 pointB1, Vector3 pointB2 ) : bool | ||
| pointA1 | Vector3 | |
| pointA2 | Vector3 | |
| pointB1 | Vector3 | |
| pointB2 | Vector3 | |
| return | bool | |
public void CreateEdgesBetweenNodes()
{
foreach (var node in m_graph.Nodes)
{
foreach (var dir in Graph.allDirections)
{
var nextPos = new Vector3(node.position.x + dir.x, 0f, node.position.z + dir.y);
var neighborNode = GetNodeAtPosition(nextPos);
if (neighborNode != null &&
neighborNode.nodeType != NodeType.Blocked &&
node.nodeType != NodeType.Blocked)
{
// TODO: this blocked by wall stuff works fine, but i was tired and its quite ugly.
bool isBlockedByWall = false;
foreach (var wall in walls)
{
var blocked = Math3d.AreLineSegmentsCrossing(node.position, neighborNode.position, wall.wallPoints[0].position, wall.wallPoints[1].position);
if (blocked)
{
isBlockedByWall = true;
break;
}
}
if (!isBlockedByWall)
{
m_graph.AddEdge(node.NodeIndex, neighborNode.NodeIndex, m_terrainCosts.GetCost(neighborNode.nodeType));
}
}
}
}
}
public static bool IsEdgeIntersectingPolygon(IPoly polygon, Vector3 point1, Vector3 point2)
{
for (int i = 0; i < polygon.Resolution; i++)
{
Vector3 a = polygon.GetPoint(i);
Vector3 b = polygon.GetPointWrapped(i + 1);
if ((point1 - a).sqrMagnitude < 0.0001f)
{
continue;
}
if ((point1 - b).sqrMagnitude < 0.0001f)
{
continue;
}
if ((point2 - a).sqrMagnitude < 0.0001f)
{
continue;
}
if ((point2 - b).sqrMagnitude < 0.0001f)
{
continue;
}
if (Math3d.AreLineSegmentsCrossing(a, b, point1, point2))
{
return(true);
}
}
return(false);
}
public void PopulateNodeMap()
{
roads = GetComponentsInChildren <Road>();
Vector3 road1start, road1end, road2start, road2end, road1vec, road2vec;
nodeSegments = new List <Segment>();
for (int i = 0; i < roads.Length; i++)
{
if (roads.Length > 1)
{
for (int j = 0; j < roads[i].segments.Count; j++)
{
for (int k = 0; k < roads.Length; k++)
{
if (roads[k] != roads[i])
{
for (int t = 0; t < roads[k].segments.Count; t++)
{
road1start = roads[i].segments[j].start();
road1end = roads[i].segments[j].end();
road1vec = roads[i].segments[j].vector();
if (!nodeSegments.Contains(roads[i].segments[j]))
{
nodeSegments.Add(roads[i].segments[j]);
}
road2start = roads[k].segments[t].start();
road2end = roads[k].segments[t].end();
road2vec = roads[k].segments[t].vector();
if (Math3d.AreLineSegmentsCrossing(road1start, road1end, road2start, road2end))
{
Vector3 intersection;
Math3d.LineLineIntersection(out intersection, road1start, road1vec, road2start, road2vec);
if (CheckForIntersection(intersection) == false)
{
Node node = NewNode(intersection);
node.transform.parent = roads[i].transform;
Segment seg1 = roads[i].segments[j];
Segment seg2 = roads[k].segments[t];
AddIntersection(node, roads[i], roads[k], seg1, seg2, type: Node.Type.intersection);
roads[i].SplitSegment(seg1, node);
roads[k].SplitSegment(seg2, node);
}
}
}
}
}
}
}
}
//Debug.Log(nodeSegments.Count + " road nodes in NodeMap");
CleanUpIntersections();
SetNodeSegments();
roads.ToList().ForEach(x => x.nodes = x.OrderNodes());
}
public LotInfo(Block block, List <Vector3> lotVerts, Vector3 direction, Vector3 left, Vector3 right, bool parentBlock = false, LotInfo parentLot = null)
{
ParentBlock = block;
ParentLot = parentLot;
LotVerts = lotVerts;
Direction = direction;
Left = left;
Right = right;
Center = (Left + Right) / 2;
Frontage = (right.x - left.x);
List <Segment> segments = block.boundingSegments;
RoadFacingVerts = new List <Vector3>();
LotCenter = Utils.AverageVectors(lotVerts);
Vector3 _dir = new Vector3(0, 0, (LotCenter - ParentBlock.BlockCenter).z).normalized * 3f;
Direction = _dir;
if (_dir == Vector3.zero)
{
//Debug.Log("center " + LotCenter + " parent " + ParentBlock.BlockCenter);
}
for (int i = 0; i < lotVerts.Count; i++)
{
for (int j = 0; j < segments.Count; j++)
{
Vector3 A2 = lotVerts[i] + _dir;
if (Math3d.AreLineSegmentsCrossing(lotVerts[i], A2, segments[j].start(), segments[j].end()))
{
RoadFacingVerts.Add(lotVerts[i]);
RoadSegment = segments[j];
Math3d.LineLineIntersection(out RoadPoint,
lotVerts[i], A2, segments[j].start(), segments [j].end());
}
}
}
//Debug.Log(RoadFacingVerts.Count);
//Frontage = Vector3.Distance(RoadFacingVerts[0],RoadFacingVerts[1]);
}
public List <Vector3> BlockRay(Vector3 origin, Vector3 dir, bool vertical = false, bool reciprocal = true, bool baseLine = false)
{
Vector3 point1 = origin;
var points = new List <Vector3>();
points.Add(origin);
Ray ray = new Ray(origin, dir * 1000f);
ray.origin = ray.GetPoint(20f);
foreach (var pair in shiftedPairs)
{
Vector3 intersection;
//i'm so so so so so sorry for this
if (Math3d.AreLineSegmentsCrossing(ray.origin, origin, pair[0], pair[1]))
{
Math3d.LineLineIntersection(out intersection, ray.origin, ray.origin - origin, pair[0], pair[0] - pair[1]);
if ((Mathf.Sign(dir.x) == -1 && intersection.x <= point1.x) ||
(Mathf.Sign(dir.x) == 1 && intersection.x >= point1.x) ||
(Mathf.Sign(dir.z) == 1 && vertical == true && intersection.z >= point1.z) ||
(Mathf.Sign(dir.z) == -1 && vertical == true && intersection.z <= point1.z))
{
point1 = intersection;
//Debug.Log(point1);
if (baseLine)
{
//shiftedVerts.Add(intersection);
}
points.Add(point1);
//Instantiate(marker, point1, Quaternion.identity, this.transform);
}
}
}
return(points);
}
//foreach new point, check if the segments build on i and i+1 intersect with any other old points
bool CheckIntersect(List <Vector3> newPoints, List <Vector3> oldPoints, bool lastCurve)
{
for (int i = 0; i < newPoints.Count - 2; i++)
{
for (int j = 0; j < oldPoints.Count - 3; j++) //skip the last segment
{
if (lastCurve && j == 0)
{
continue;
}
bool intersect = Math3d.AreLineSegmentsCrossing(newPoints[i], newPoints[i + 1], oldPoints[j], oldPoints[j + 1]);
if (intersect)
{
GameObject cubeObject = Instantiate(colliderPrefab, newPoints[i], Quaternion.identity) as GameObject;
//Debug.Log("new " + i + " stable " + j);
return(false);
}
}
}
return(true);
}
public void AngleCheck()
{
Ray ray = new Ray(BlockCenter, Vector3.forward * 1000f);
Ray ray2 = new Ray(BlockCenter, Vector3.back * 1000f);
Ray RayL = new Ray(BlockCenter, Vector3.left * 1000f);
Ray RayR = new Ray(BlockCenter, Vector3.right * 1000f);
Debug.DrawLine(ray.origin, ray.GetPoint(10));
AngleDown = 0;
AngleUp = 0;
AngleRight = 0;
AngleRight = 0;
float top_distance = 0;
float bot_distance = 0;
float left_distance = 0;
float right_distance = 0;
Vector3 top_intersect;
Vector3 bot_intersect;
foreach (var segment in boundingSegments) //FIND TOP AND BOTTOM INTERSECTION POINTS, CALCULATE CENTER
{
if (Math3d.AreLineSegmentsCrossing(ray.origin, ray.GetPoint(20f), segment.start(), segment.end()))
{
AngleUp = segment.Angle();
//X_angle_top = Math3d.SignedVectorAngle(segment.end() - segment.start(), Vector3.right, Vector3.forward);
Math3d.LineLineIntersection(out top_intersect, ray.origin, ray.direction, segment.start(), segment.vector());
top_distance = Vector3.Distance(ray.origin, top_intersect);
}
if (Math3d.AreLineSegmentsCrossing(ray2.origin, ray2.GetPoint(20f), segment.start(), segment.end()))
{
AngleDown = segment.Angle();
//X_angle_top = (Mathf.Sign(X_angle_top) == 1) ? X_angle_top - 90f : X_angle_top +90f;
Math3d.LineLineIntersection(out bot_intersect, ray.origin, ray2.direction, segment.start(), segment.vector());
bot_distance = Vector3.Distance(ray.origin, bot_intersect);
}
if (Math3d.AreLineSegmentsCrossing(RayL.origin, RayL.GetPoint(20f), segment.start(), segment.end()))
{
AngleLeft = segment.angleV();
Math3d.LineLineIntersection(out bot_intersect, ray.origin, ray2.direction, segment.start(), segment.vector());
left_distance = Vector3.Distance(ray.origin, bot_intersect);
}
if (Math3d.AreLineSegmentsCrossing(RayR.origin, RayR.GetPoint(20f), segment.start(), segment.end()))
{
AngleRight = segment.angleV();
Math3d.LineLineIntersection(out bot_intersect, ray.origin, ray2.direction, segment.start(), segment.vector());
right_distance = Vector3.Distance(ray.origin, bot_intersect);
}
}
float distance = bot_distance - top_distance;
//float topAdj = BlockCenter.z + top_distance;
//float botAdj = BlockCenter.z - bot_distance;
BlockCenter = BlockCenter - new Vector3(0, 0, distance / 2);
RayVectorAngleH = (AngleDown + AngleUp) / 2;
if (Mathf.Abs(RayVectorAngleH) > 10)
{
RayVectorAngleV = (AngleLeft + AngleRight) / 2;
}
else
{
RayVectorAngleV = 90;
}
//if (Mathf.Abs(RayVectorAngleH) > 10) RayVectorAngleH = RayVectorAngleV - 90;
if (RayVectorAngleV < 0)
{
RayVectorV = Quaternion.Euler(0, RayVectorAngleV, 0) * Vector3.right;
}
else
{
RayVectorV = Quaternion.Euler(0, RayVectorAngleV, 0) * Vector3.left;
}
RayVectorH = Quaternion.Euler(0, RayVectorAngleH, 0) * Vector3.right;
if (Mathf.Abs(RayVectorAngleH) >= 20f)
{
//RayVectorV = Quaternion.Euler(0,-90f,0) * RayVectorH;
}
}
