public static float CalculateDistance(Vector3 leftOriginLocal_mm, Vector3 leftDirection, Vector3 rightOriginLocal_mm, Vector3 rightDirection)
{
Vector3 p1;
Vector3 p2;
var linesAreNotParallel = ClosestPointsOnTwoLines(out p1, out p2, ref rightOriginLocal_mm, ref rightDirection, ref leftOriginLocal_mm, ref leftDirection);
var combinedGazeOrigin_mm = (leftOriginLocal_mm + rightOriginLocal_mm) / 2f;
var convergencePoint = (p1 + p2) / 2f;
var distance_mm = Vector3.Distance(convergencePoint, combinedGazeOrigin_mm);
if (float.IsNaN(distance_mm))
{
return(_lastDistance_mm);
}
if (!linesAreNotParallel || distance_mm > _maximumDistance_mm || float.IsInfinity(distance_mm))
{
distance_mm = _maximumDistance_mm;
}
if (distance_mm < _minimumDistance_mm)
{
distance_mm = _minimumDistance_mm;
}
_lastDistance_mm = distance_mm;
return(distance_mm);
}
public void GenerateMountains()
{
List <Vector2> PossibleMountainMidpoints = new List <Vector2>();
//get possible mountain locations
for (int x = 0; x < Size.x; x++)
{
for (int y = 0; y < Size.y; y++)
{
if (world.TileTypeXZ[LeftBottomCoordinate.x + x, LeftBottomCoordinate.y + y] == (byte)TileType.Land)
{
int WCount = GetWaterTileCount(LeftBottomCoordinate.x + x, LeftBottomCoordinate.y + y);
if (WCount > 1)
{
//Can be a mountain range
PossibleMountainMidpoints.Add(new Vector2(LeftBottomCoordinate.x + x, LeftBottomCoordinate.y + y));
}
}
}
}
//Afhankelijk van grootte van eiland maken
int MountainRangeAmount = 8;
for (int i = 0; i < MountainRangeAmount; i++)
{
int Pos = RND.Next(0, PossibleMountainMidpoints.Count);
int Radius = RND.Next(5, 23);
Vector3[,] FullTiles = new Vector3[Radius, Radius];
for (int x = -1 * (Radius / 2); x < Radius / 2; x++)
{
for (int y = -1 * (Radius / 2); y < Radius / 2; y++)
{
if (PossibleMountainMidpoints[Pos].x + x > 0 && PossibleMountainMidpoints[Pos].x <= world.WorldProps.Size.x && PossibleMountainMidpoints[Pos].y + y > 0 && PossibleMountainMidpoints[Pos].y <= world.WorldProps.Size.y)
{
float height = -1;
if (x * x + y * y <= Radius * Radius)
{
//Hoogte berekenen
float height2 = Radius / 2 - UVC3.Distance(new UVC3(PossibleMountainMidpoints[Pos].x, 5, PossibleMountainMidpoints[Pos].y), new UVC3(PossibleMountainMidpoints[Pos].x + x, 5, PossibleMountainMidpoints[Pos].y + y));
height = (height2 + world.WorldProps.HeightSegments);
}
FullTiles[x + Radius / 2, y + Radius / 2] = (new Vector3(PossibleMountainMidpoints[Pos].x + x, (int)height, PossibleMountainMidpoints[Pos].y + y));
}
}
}
Mountains.Add(new Mountain(FullTiles, PossibleMountainMidpoints[Pos], Radius, world));
}
foreach (Mountain M in Mountains)
{
try
{
M.GenerateMeshData();
}
catch (Exception e) { UnityEngine.Debug.Log(e); }
}
}
/// <summary>
/// Return the row & column of the point in the point matrix closest to the centroid.
/// </summary>
/// <param name="pointMat">The input point matrix.</param>
/// <returns>The row & column of the point closest to the centroid.</returns>
private static Tuple <int, int> GetPointClosestToCentroid(List <List <Vector3> > pointMat)
{
var centroid = GetCentroid(UnrollPointMatrix(pointMat));
var minDist = Vector3.Distance(pointMat[0][0], centroid);
var rowCol = new Tuple <int, int>(0, 0);
for (var r = 0; r < pointMat.Count; r++)
{
for (var c = 0; c < pointMat[0].Count; c++)
{
var dist = Vector3.Distance(pointMat[r][c], centroid);
if (!(dist < minDist))
{
continue;
}
minDist = dist;
rowCol = new Tuple <int, int>(r, c);
}
}
return(rowCol);
}
public static FLOAT Distance(VECTOR a, VECTOR b)
{
return(VECTOR.Distance(a, b));
}
void GetOutlineTypes(MeshData meshData)
{
for (int i = 0; i < outLines.Count; i++)
{
bool LargestOutline = true;
bool Check = false;
BeforeChecks:
if (Check)
{
continue;
}
for (int j = 0; j < outLines.Count; j++)
{
if (outLines[j].Count > outLines[i].Count)
{
LargestOutline = false;
}
}
if (LargestOutline)
{
//Kan nu geen inneroutline zijn, het is de grootste
outLineTypes.Add(false);
continue;
}
//Kan nog een inneroutline zijn....
List <UVC3> Vertices = new List <UVC3>();
for (int h = 0; h < outLines[i].Count; h++)
{
Vertices.Add(meshData.Vertices[outLines[i][h]]);
}
for (int x = 0; x < outLines[i].Count; x++)
{
float ZMin = -1;
int YIteration = -1;
for (int y = 0; y < outLines[i].Count; y++)
{
if (Vertices[x].x == Vertices[y].x && x != y && Vertices[x].z > Vertices[y].z && (UVC3.Distance(Vertices[x], Vertices[y]) < ZMin || ZMin == -1))
{
ZMin = UVC3.Distance(Vertices[x], Vertices[y]);
YIteration = y;
}
}
if (YIteration != -1)
{
bool a = CheckCoords(meshData.Vertices[outLines[i][x]], meshData.Vertices[outLines[i][YIteration]]);
if (a)
{
Check = true;
outLineTypes.Add(true);
goto BeforeChecks;
}
}
}
//Nu niet meer
outLineTypes.Add(false);
}
}
private static bool IsConnected(Vector3 point1, Vector3 point2)
{
return(Vector3.Distance(point1, point2) <= ConnectivityThreshold);
}
