// Generate the terrain vertices and their respective biomes
void GenerateTerrain()
{
// Determine number of tiles in a row
int numTiles = chunkSize / tileSize;
// Initialize a position vector
Vector3 pos = new Vector3();
// Loop through all grid tiles plus 3 extra. 2 on the borders (which overlap with other chunk) to calculate normals from.
// And one extra to get the desired number of tiles from vertices. (numTiles = numVertex + 1)
for (int i = 0; i < numTiles + 3; i++)
{
for (int k = 0; k < numTiles + 3; k++)
{
// Set the position vector to the the position of the current vertex
pos.Set((i - 1) * tileSize, 0, (k - 1) * tileSize);
float r = Vector3.Magnitude(pos + transform.position - terrain.middlePoint);
// In case the flat area surrounded by mountains options is activated
if (terrain.isSourroundedByMountains)
{
if (Mathf.Abs(r) > terrain.flatRadius || Mathf.Abs(r) > terrain.flatRadius)
{
map[i, k] = GenerateTerrainMap(i, k, pos);
map[i, k].y *= (-(Mathf.Cos(Mathf.PI / (terrain.width / 2f) * (r - terrain.flatRadius))) + 1) / 2;
}
else
{
map[i, k] = pos;
}
}
// In other cases
else
{
// Generate the height and biome of the vertex, depending on its horizontal position.
map[i, k] = GenerateTerrainMap(i, k, pos);
if (terrain.isIsland)
{
map[i, k] += new Vector3(0, -terrain.islandSteepness * r * r + terrain.baseHeight + terrain.waterLevel, 0);
}
else if (terrain.isCoastLine)
{
map[i, k].y -= Mathf.Sin(Mathf.PI / (terrain.width * 2) * (pos.x + transform.position.x)) * (pos.x + transform.position.x) * terrain.coastSteepness - terrain.coastBaseHeight;
}
}
biomeMap[i, k] = GenerateBiomes(i, k, pos);
if (terrain.isCoastLine)
{
biomeMap[i, k] *= Mathf.Pow(Mathf.Cos(Mathf.PI / (terrain.width * 2) * (pos.x + transform.position.x)), 5) * 2;
biomeMap[i, k] = Mathf.Clamp(biomeMap[i, k], 0.1f, terrain.biomes.Length - 0.5f);
}
}
}
tempMap = (Vector3[, ])map.Clone();
}
public PoseDataFrame(Vector3[,] ufp, Vector3[] ugp, FingerShape[,] ufs, HandShape[] uhs, Vector3[] vel, Vector3[] accel)
{
FingerPosition = ufp.Clone() as Vector3[, ];
GripPosition = ugp.Clone() as Vector3[];
FingerShape = ufs.Clone() as FingerShape[, ];
HandShape = uhs.Clone() as HandShape[];
HandVelocity = vel.Clone() as Vector3[];
HandAcceleration = accel.Clone() as Vector3[];
}
///<summary>
/// Modifie la mesh de l'objet courant. Cette mesh correspond à une déformation d'impact autour d'un epicentre.
/// La nouvelle mesh est constitués des points fourni par la fonction appelante et connecte ces derniers avec des triangles générés itérativement.
/// Les normales a ses triangles sont par ailleurs calculée pour que l'objet reste compatible avec l'éclairage de la scène.
///</summary>
private void DeformSurface(Vector3 worldSpaceEpiCenter_, Vector3[,] impactSideVertices_, Vector3[,] oppositeSideVertices_, int currentMeshID_, MeshFilter mf_)
{
Vector3[,] impactSideVertices = impactSideVertices_.Clone() as Vector3[, ];
Vector3[,] oppositeSideVertices = oppositeSideVertices_.Clone() as Vector3[, ];
Vector3 localCollision = this.transform.worldToLocalMatrix.MultiplyPoint3x4(worldSpaceEpiCenter_);
(Vector3 localisedEpicenter, Vector3 oppositeSideEpicenter, bool areImpactPointsReversed) = this.getOppositeSideVertex(localCollision, impactSideVertices[0, this.addedTangentSplit], oppositeSideVertices[0, this.addedTangentSplit]);
Vector3 impactDirection = this.transform.InverseTransformDirection(Vector3.Normalize(this.transform.TransformPoint(oppositeSideEpicenter) - this.transform.TransformPoint(localisedEpicenter)));
Vector3 getOffset(float distanceFromImpact_)
{
if (distanceFromImpact_ < this.deformRadius)
{
float deformationFactor = 1 - (distanceFromImpact_ / this.deformRadius) * this.deformFalloff;
Vector3 deformation;
if (areImpactPointsReversed)
{
deformation = deformationFactor * oppositeSideEpicenter;
}
else
{
deformation = deformationFactor * localisedEpicenter;
}
return(Vector3.Scale(impactDirection, deformation) * this.deformMultiplier);
}
else
{
return(new Vector3(0, 0, 0));
}
}
for (int obliqueIndex = 0; obliqueIndex < impactSideVertices.GetLength(0); obliqueIndex++)
{
for (int tangentIndex = 0; tangentIndex < impactSideVertices.GetLength(1); tangentIndex++)
{
float distanceFromImpact = Vector3.Distance(impactSideVertices[obliqueIndex, tangentIndex], localisedEpicenter);
impactSideVertices[obliqueIndex, tangentIndex] -= getOffset(distanceFromImpact);
oppositeSideVertices[obliqueIndex, tangentIndex] -= getOffset(distanceFromImpact);
}
}
IEnumerable <int> getFrontTopRightBottomLeft()
{
int o = impactSideVertices.GetLength(0);
int t = impactSideVertices.GetLength(1);
//sens normal
for (int obliqueIndex = 0; obliqueIndex < o; obliqueIndex++)
{
for (int tangentIndex = 0; tangentIndex < t; tangentIndex++)
{
int index = (obliqueIndex * t) + tangentIndex;
if (tangentIndex == t - 1)
{
//extremité face avant ==> face avant à 4 côtés + face lattérale
yield return(index);
yield return((index + t) % (t * o));
yield return(((index + t) % (t * o)) + (t * o));
yield return(((index + t) % (t * o)) + (t * o));
yield return(((index) % (t * o)) + (t * o));
yield return(index);
if (tangentIndex == 0 && obliqueIndex % (o / 2) == 0)
{
foreach (var item in new int[] { t *(o / 2), t *(o / 4), 0 })
{
yield return((index + item) % (t * o));
}
}
else
{
foreach (var item in new int[] { 0, -1, t - 1, t - 1, t, 0 })
{
yield return((index + item) % (t * o));
}
}
}
else if (tangentIndex == 0)
{
//Intérieur face avant à trois coté, autour de l'épicentre avant
yield return(t * o * 2);
yield return((index + t) % (t * o));
yield return(index);
}
else
{
//milieu face avant à 4 côtés
foreach (var item in new int[] { 0, -1, t - 1, t - 1, t, 0 })
{
yield return((index + item) % (t * o));
}
}
}
}
}
IEnumerable <int> getBack()
{
int o = impactSideVertices.GetLength(0);
int t = impactSideVertices.GetLength(1);
//sens inverse
for (int obliqueIndex = 0; obliqueIndex < o; obliqueIndex++)
{
for (int tangentIndex = 0; tangentIndex < t; tangentIndex++)
{
int index = (t * o) + (obliqueIndex * t) + tangentIndex;
if (tangentIndex == 0)
{
//Intérieur face avant à trois coté, autour de l'épicentre arrière
yield return(index);
yield return(((index + t) % (t * o)) + (t * o));
yield return((t * o * 2) + 1);
}
else
{
//milieu face avant à 4 côtés
foreach (var item in new int[] { 0, t, t - 1, t - 1, -1, 0 })
{
yield return(((index + item) % (t * o)) + (t * o));
}
}
}
}
}
Mesh newMesh = new Mesh();
//localisedEpicenter et oppositeSideEpicenter sont ajouté dans le newMesh.vertices mais pas dans impactSideVertices et oppositeSideVertices pour simplifier la logique des index
newMesh.vertices = this.Flatten(impactSideVertices)
.Concat(this.Flatten(oppositeSideVertices))
.Append(localisedEpicenter - getOffset(0))
.Append(oppositeSideEpicenter - getOffset(0))
.ToArray();
newMesh.triangles = getFrontTopRightBottomLeft().Concat(getBack()).ToArray();
newMesh.RecalculateNormals();
mf_.mesh = newMesh;
}
