/// <summary> /// Move edge vertices /// </summary> protected void UpdateEdgeVertex() { foreach (int index in _groundMesh.indexes.edgeVertexIndex) { foreach (Cell fneighbor in _neighbors) { foreach (int fIndex in fneighbor.Indexes.edgeVertexIndex) { Vector3 nVertex1 = _groundMesh.smoothVertex[index].normalized; Vector3 nVertex2 = fneighbor.GroundMesh.smoothVertex[fIndex].normalized; if (nVertex1 == nVertex2) { List <int> myLinkedInternIndex = GetLinkedInternVertexIndexes(_groundMesh, index); List <int> linkedInternIndex = GetLinkedInternVertexIndexes(fneighbor.GroundMesh, fIndex); Vector3 internVertex = GetNearestTypedVertex(_groundMesh.indexes.internVertexIndex, nVertex1, _groundMesh); Vector3 internNeighborVertex = GetNearestTypedVertex(fneighbor.GroundMesh.indexes.internVertexIndex, nVertex2, fneighbor.GroundMesh); Vector3[] cloudOfPoint = new Vector3[] { internVertex, internNeighborVertex }; Vector3 G = MathCustom.GetBarycenter(cloudOfPoint); _groundMesh.smoothVertex[index] = G; fneighbor.UpdateVertexPos(fIndex, G); } } } } }
public void TransformCameraTarget(Transform targetTransform, out Vector3 outPosition, out Quaternion outRotation, ECameraTargetType view) { if (view == ECameraTargetType.MAP) { Vector3 lpos = targetTransform.position; outPosition = lpos + (lpos.normalized * MapViewDistance); Vector3 upVector = lpos.normalized; Vector3 rightVector = Vector3.Cross(upVector, Vector3.up).normalized; Vector3 forwardVector = MathCustom.GetFaceNormalVector(Vector3.zero, rightVector, upVector); outRotation = Quaternion.LookRotation(-upVector, forwardVector); } else if (view == ECameraTargetType.ZOOM) { Vector3 lpos = targetTransform.position; Vector3 newPosition; MathCustom.SphericalToCartesian(DistanceToplayer, -Mathf.PI / 2, Elevation, out newPosition); outPosition = targetTransform.TransformPoint(newPosition + Vector3.up * StepHeight); Vector3 newPos = targetTransform.TransformPoint(newPosition); Vector3 cross = Vector3.Cross(newPos, targetTransform.forward); outRotation = Quaternion.LookRotation(lpos - newPos, Vector3.Cross(cross, -(lpos - newPos))); } else { outPosition = Vector3.zero; outRotation = Quaternion.identity; } }
/// <summary> /// Recalculate peak to make ground flat /// </summary> /// <param name="groundMesh">GroundMesh</param> protected void RecalculatePeak(GroundMesh groundMesh, Vector3 origin) { int nbVertex = groundMesh.computedVertex.Length; Vector3[] planPoints = new Vector3[3]; int ite = 0; for (int i = 0; i < nbVertex; i++) { if (groundMesh.computedVertex[i] != groundMesh.centerPosition) { planPoints[ite] = groundMesh.computedVertex[i]; ite++; if (ite >= 3) { break; } } } Vector4 groundPlan = MathCustom.GetPlaneValues(planPoints[0], planPoints[1], planPoints[2]); Vector3 newCenterPosition = MathCustom.LineCutPlaneCoordinates(origin, groundMesh.centerPosition * int.MaxValue, groundPlan); for (int i = 0; i < nbVertex; i++) { if (groundMesh.computedVertex[i] == groundMesh.centerPosition) { groundMesh.centerPosition = newCenterPosition; groundMesh.computedVertex[i] = newCenterPosition; } } }
protected IEnumerator MoveToTargetCell(Vector3 basePosition, Quaternion baseRotation) { _controlEnable = false; float t = 0; Vector3 targetPos; Quaternion targetRot; MathCustom.SphericalToCartesian(movingDistance, ActualPolar, Elevation, out targetPos); targetPos = baseTransform.TransformPoint(targetPos); Vector3 cross = Vector3.Cross(baseTransform.position - targetPos, baseTransform.up); targetRot = Quaternion.LookRotation(baseTransform.position - targetPos, Vector3.Cross(cross, baseTransform.position - targetPos)); while (t < 1) { if (t > 1) { t = 1; } else { t += Time.deltaTime * 1.25f; } transform.position = Vector3.Slerp(basePosition, targetPos, t); transform.rotation = Quaternion.Slerp(baseRotation, targetRot, t); yield return(null); } _controlEnable = true; StopAllCoroutines(); }
protected void Reoriente() { Vector3 forwardVector = -transform.position.normalized; Vector3 rightVector = Vector3.Cross(forwardVector, Vector3.up).normalized; Vector3 upVector = MathCustom.GetFaceNormalVector(transform.position, transform.position + rightVector, transform.position + forwardVector); transform.rotation = Quaternion.LookRotation(forwardVector, -upVector); }
public void SetPos(float x) { if (relative) { _targetTransform.localPosition = MathCustom.LerpUnClampVector(_startPos, targetPos, x); } else { _targetTransform.position = MathCustom.LerpUnClampVector(_startPos, targetPos, x); } }
protected void Update() { if (_controlEnable) { Vector3 newPosition; MathCustom.SphericalToCartesian(movingDistance, ActualPolar, Elevation, out newPosition); transform.position = baseTransform.TransformPoint(newPosition); Vector3 cross = Vector3.Cross(baseTransform.position - transform.position, baseTransform.up); transform.rotation = Quaternion.LookRotation(baseTransform.position - transform.position, Vector3.Cross(cross, baseTransform.position - transform.position)); } }
private void Pop() { popUpDirection = transform.position.normalized; float randomAngle = Random.Range(0f, 360f); Vector3 groundVec = (_player.transform.position - transform.position).normalized; popDirection = MathCustom.RotateDirectionAround(Vector3.Cross(popUpDirection, groundVec), randomAngle, popUpDirection); Cell cell = GetComponentInParent <Cell>(); GameObject newProps = EarthManager.Instance.CreateProps(popItem.prefab, transform.position, cell); StartCoroutine(PopJumpCoroutine(newProps.transform)); }
private Vector3 GetRosacePosition(float deltaTime) { for (int i = 0; i < angularSpeeds.Count; i++) { Vector3 nVector; nVector = MathCustom.RotateDirectionAround(vectors[i], deltaTime * angularSpeeds[i], Vector3.forward); nVector = nVector.normalized * nTime * 2f; vectors[i] = nVector; nVector.z = 0f; activeVectors.Add(nVector); } Vector3 pos = MathCustom.GetBarycenter(activeVectors.ToArray()); activeVectors.Clear(); return(pos); }
private void GenerateRoomsConnections() { // R3 rooms List <Room> rooms = roomsList.FindAll(r => portalCouples.Find(pc => pc.exRoomID == r.ID) != null); foreach (Room r in rooms) { r.layoutType = ELayoutType.L3; } // R1 rooms rooms = roomsList.FindAll(r => portalCouples.Find(pc => pc.exRoomID == r.ID) == null); foreach (Room r in rooms) { r.layoutType = ELayoutType.L1; } // R2 rooms rooms = roomsList.FindAll(r => roomsList.Find(ir => ir.gridPos.x == r.gridPos.x && ir.gridPos.y == r.gridPos.y + 1) != null); foreach (Room r in rooms) { r.layoutType = MathCustom.RandomBool() ? ELayoutType.L2 : r.layoutType; if (r.layoutType == ELayoutType.L2) { _rooms[r.gridPos.x, r.gridPos.y + 1].openSides.Add(ERoomDirection.Bottom); r.openSides.Add(ERoomDirection.Top); } } foreach (Room r in roomsList) { if (portalCouples.Find(pc => pc.enRoomID == r.ID) == null) { if (r.exDirection == ERoomDirection.Right) { r.openSides.Add(ERoomDirection.Right); _rooms[r.gridPos.x + 1, r.gridPos.y].openSides.Add(ERoomDirection.Left); } else if (r.exDirection == ERoomDirection.Left) { r.openSides.Add(ERoomDirection.Left); _rooms[r.gridPos.x - 1, r.gridPos.y].openSides.Add(ERoomDirection.Right); } } } }
/// <summary> /// Move corner vertices /// </summary> protected void UpdateCornerHeight() { foreach (int myindex in _groundMesh.indexes.cornerVertexIndex) { int iterator = 0; int[] internVertexIndexes = new int[2]; int[] cornerVertexIndexes = new int[2]; Cell[] linkedCells = new Cell[2]; foreach (Cell fneighbor in _neighbors) { foreach (int index in fneighbor.Indexes.cornerVertexIndex) { Vector3 nVertex1 = _groundMesh.smoothVertex[myindex].normalized; Vector3 nVertex2 = fneighbor.GroundMesh.smoothVertex[index].normalized; if (nVertex1 == nVertex2) { List <int> internVertexIndex = GetLinkedInternVertexIndexes(fneighbor.GroundMesh, index); linkedCells[iterator] = fneighbor; internVertexIndexes[iterator] = internVertexIndex[0]; cornerVertexIndexes[iterator] = index; iterator++; } } } if (iterator == 2) { List <int> myInternVertexIndex = GetLinkedInternVertexIndexes(_groundMesh, myindex); Vector3[] cloudOfPoint = new Vector3[3] { _groundMesh.smoothVertex[myInternVertexIndex[0]], linkedCells[0].GroundMesh.smoothVertex[internVertexIndexes[0]], linkedCells[1].GroundMesh.smoothVertex[internVertexIndexes[1]] }; Vector3 G = MathCustom.GetBarycenter(cloudOfPoint); _groundMesh.smoothVertex[myindex] = G; linkedCells[0].UpdateVertexPos(cornerVertexIndexes[0], G); linkedCells[1].UpdateVertexPos(cornerVertexIndexes[1], G); } } }
protected void AddRoadPart(RoadEdge startEdge, RoadEdge targetEdge) { SortPoints(startEdge, targetEdge); List <Vector3[]> preTris = new List <Vector3[]>(); preTris.Add(new Vector3[3] { startEdge.meshPoints[1], startEdge.meshPoints[0], targetEdge.meshPoints[0] }); preTris.Add(new Vector3[3] { targetEdge.meshPoints[0], targetEdge.meshPoints[1], startEdge.meshPoints[1] }); for (int i = 0; i < 2; i++) { if (Vector3.Angle(MathCustom.GetFaceNormalVector(preTris[i][0], preTris[i][1], preTris[i][2]).normalized, MathCustom.GetBarycenter(preTris[i]).normalized) < 90f) { roadVertice.AddTriangle(new Vector3[3] { preTris[i][2], preTris[i][1], preTris[i][0] }); } else { roadVertice.AddTriangle(preTris[i]); } } preTris.Clear(); int[] lTriangles = new int[roadVertice.triangles.Count * 3]; for (int i = 0; i < lTriangles.Length / 3; i++) { lTriangles[i * 3] = roadVertice.triangles[i].verticesindex[0]; lTriangles[(i * 3) + 1] = roadVertice.triangles[i].verticesindex[1]; lTriangles[(i * 3) + 2] = roadVertice.triangles[i].verticesindex[2]; } roadMeshObject.mesh.vertices = roadVertice.vertex.ToArray(); roadMeshObject.mesh.triangles = lTriangles; roadMeshObject.mesh.normals = roadVertice.normals.ToArray(); SetUV(); roadMeshObject.mesh.uv = roadVertice.UV.ToArray(); roadMeshCollider.sharedMesh = roadMeshObject.mesh; }
/// <summary> /// Generate UV mapping /// </summary> /// <param name="groundMesh"></param> protected void GenerateTextureMap(GroundMesh groundMesh) { Vector3 cross = Vector3.Cross(Vector3.up, groundMesh.centerPosition); Vector3 py = groundMesh.centerPosition + cross; Vector3 pz = groundMesh.centerPosition + Vector3.Cross(cross, groundMesh.centerPosition); Vector4 cellPlan = MathCustom.GetPlaneValues(groundMesh.centerPosition, py, pz); for (int i = 0; i < groundMesh.smoothVertex.Length; i++) { Vector3 vertex = groundMesh.smoothVertex[i]; if (vertex == groundMesh.centerPosition) { groundMesh.UVs[i] = new Vector2(0.5f, 0.5f); } else { Vector3 planeCoord = MathCustom.LineCutPlaneCoordinates(Vector3.zero, vertex, cellPlan); Vector3 cartesianPos = Quaternion.FromToRotation(groundMesh.centerPosition, Vector3.up) * planeCoord; float lRadius; float lPolar; float lElevation; MathCustom.CartesianToSpherical(cartesianPos, out lRadius, out lPolar, out lElevation); float xAngle = Vector3.SignedAngle(groundMesh.centerPosition, vertex, groundMesh.centerPosition); float yAngle = Vector3.SignedAngle(Vector3.Cross(groundMesh.centerPosition, -Vector3.up), vertex, groundMesh.centerPosition); if (CustomGeneric.IntArrayContain(groundMesh.indexes.internVertexIndex, i) != -1) { groundMesh.UVs[i] = new Vector2(0.5f + (Mathf.Cos(lPolar) * 0.9f), 0.5f + (Mathf.Sin(lPolar) * 0.9f)); } else { groundMesh.UVs[i] = new Vector2(0.5f + Mathf.Cos(lPolar), 0.5f + Mathf.Sin(lPolar)); } } } }
public void SetScale(float x) { _targetTransform.localScale = MathCustom.LerpUnClampVector(startScale, targetScale, x); }
/// <summary> /// Get the dual transformation of a GroundMesh /// </summary> /// <param name="groundMesh">GroundMesh</param> protected void DualTransformation(GroundMesh groundMesh) { Vector3[] computedVertices = new Vector3[groundMesh.computedVertex.Length]; Vector3[] computedNormals = new Vector3[groundMesh.computedVertex.Length]; for (int i = 0; i < groundMesh.triangles.Length / 3; i++) { Vector3 addVector = Vector3.zero + groundMesh.centerPosition; if (groundMesh.vertex[groundMesh.triangles[i * 3]] != groundMesh.centerPosition) { addVector += groundMesh.vertex[groundMesh.triangles[i * 3]]; } if (groundMesh.vertex[groundMesh.triangles[i * 3 + 1]] != groundMesh.centerPosition) { addVector += groundMesh.vertex[groundMesh.triangles[i * 3 + 1]]; } if (groundMesh.vertex[groundMesh.triangles[i * 3 + 2]] != groundMesh.centerPosition) { addVector += groundMesh.vertex[groundMesh.triangles[i * 3 + 2]]; } computedVertices[i] = addVector.normalized * radius; computedNormals[i] = computedVertices[i].normalized; } computedVertices[computedVertices.Length - 2] = Vector3.zero; computedNormals[computedNormals.Length - 2] = -groundMesh.centerPosition.normalized; computedVertices[computedVertices.Length - 1] = groundMesh.centerPosition; computedNormals[computedNormals.Length - 1] = groundMesh.centerPosition.normalized; groundMesh.computedVertex = computedVertices; groundMesh.computedNormals = computedNormals; // Creation of the dual triangles array int nbTriangle = groundMesh.triangles.Length / 3; VertexCouple[] couples = new VertexCouple[nbTriangle]; for (int i = 0; i < nbTriangle; i++) { couples[i] = new VertexCouple(Vector3.zero, Vector3.zero); } int ite = 0; for (int j = 0; j < groundMesh.computedVertex.Length; j++) { for (int k = 0; k < groundMesh.computedVertex.Length; k++) { if (groundMesh.computedVertex[j] != groundMesh.centerPosition && groundMesh.computedVertex[k] != groundMesh.centerPosition && groundMesh.computedVertex[j] != Vector3.zero && groundMesh.computedVertex[k] != Vector3.zero) { float angle = Vector3.Angle(groundMesh.centerPosition - groundMesh.computedVertex[j], groundMesh.centerPosition - groundMesh.computedVertex[k]); if (angle > 2 && angle < 70) { VertexCouple newCouple = new VertexCouple(groundMesh.computedVertex[j], groundMesh.computedVertex[k]); if (!CoupleExist(couples, newCouple)) { couples[ite] = newCouple; ite++; } } } } } int[] lTriangles = new int[groundMesh.triangles.Length * 2]; for (int i = 0; i < couples.Length; i++) { Vector3 surfaceNormal = Vector3.Cross(groundMesh.centerPosition + couples[i].vertices[0], groundMesh.centerPosition + couples[i].vertices[1]); float angle = Vector3.Angle(gameObject.transform.position + groundMesh.centerPosition, surfaceNormal); if (angle < 90) { lTriangles[i * 3] = ArrayContain(groundMesh.computedVertex, groundMesh.centerPosition); lTriangles[i * 3 + 1] = ArrayContain(groundMesh.computedVertex, couples[i].vertices[0]); lTriangles[i * 3 + 2] = ArrayContain(groundMesh.computedVertex, couples[i].vertices[1]); } else { lTriangles[i * 3] = ArrayContain(groundMesh.computedVertex, groundMesh.centerPosition); lTriangles[i * 3 + 1] = ArrayContain(groundMesh.computedVertex, couples[i].vertices[1]); lTriangles[i * 3 + 2] = ArrayContain(groundMesh.computedVertex, couples[i].vertices[0]); } Vector4 face = MathCustom.GetPlaneValues(Vector3.zero, couples[i].vertices[1], couples[i].vertices[0]); if (MathCustom.GetDistanceToPlane(groundMesh.centerPosition, face) > 0) { lTriangles[groundMesh.triangles.Length + i * 3] = ArrayContain(groundMesh.computedVertex, Vector3.zero); lTriangles[groundMesh.triangles.Length + i * 3 + 1] = ArrayContain(groundMesh.computedVertex, couples[i].vertices[0]); lTriangles[groundMesh.triangles.Length + i * 3 + 2] = ArrayContain(groundMesh.computedVertex, couples[i].vertices[1]); } else { lTriangles[groundMesh.triangles.Length + i * 3] = ArrayContain(groundMesh.computedVertex, Vector3.zero); lTriangles[groundMesh.triangles.Length + i * 3 + 1] = ArrayContain(groundMesh.computedVertex, couples[i].vertices[1]); lTriangles[groundMesh.triangles.Length + i * 3 + 2] = ArrayContain(groundMesh.computedVertex, couples[i].vertices[0]); } } groundMesh.computedTriangles = lTriangles; }