hjkhjjkh
using UnityEngine;
using System.Collections;
using UnityEngine.Networking;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System.Collections.Generic;
public class Argos_VR_Navigate : MonoBehaviour
{
public float ArrowSpeed = 1f;
public float MouseLLnearSpeed = 60f;
public float MouseAngularSpeed = 60f;
public float damping = 0.1f;
public float ReleaseTime = 1.2f;
bool bLMButtonisDown = false;
bool bRMButtonisDown = false;
bool bMMMouseButtonisDown = false;
bool bLMButtonWasDown = false;
bool bRMButtonWasDown = false;
bool bMMMouseButtonWasDown = false;
bool bAnyMouseButton = false;
float xMouse_Damped;
float yMouse_Damped;
float[] arrowsDamped = new float[4];
bool[] bArrow = new bool[4];
bool[] bArrowWasDown = new bool[4];
float[] MTimer = new float[3];
float[] ATimer = new float[4];
GameObject argosSphere;
//GameObject userMovement;
//GameObject NavSphere_Pivot;
//GameObject NavSphere;
//UI_Control ui_control;
public Text txtInputIndicator;
Vector2 touchPos;
Vector3 vHoldPivot;
bool bRotaPivot_On = false;
bool m_bAllowInput = true;
public RMF_RadialMenu rmf_Radial_Menu;
public enum Arrows
{
UP = 0,
DOWN,
LEFT,
RIGHT,
}
public static class Arrow
{
public const int UP = 0;
public const int DOWN = 1;
public const int LEFT = 2;
public const int RIGHT = 3;
}
public enum MouseButts
{
LMB,
RMB,
MMB,
}
public static class MouseButt
{
public const int LMB = 0;
public const int RMB = 1;
public const int MMB = 2;
}
public Vector3 baseOVR_Pos;
public Quaternion baseOVR_Rota;
public int iMode_GearVR;
public static class GVR_MODE
{
public const int LMB = 0;
public const int RMB = 1;
public const int HOME = 2;
public const int MMB = 3;
}
public GameObject OVR_Main_Cam;
public float seeX;
public float seeY;
public void Start()
{
argosSphere = GameObject.Find("ARGOS_Fibonacci_Second_Generation");
//userMovement = GameObject.Find("User_Movement");
//ui_control = GameObject.Find("UI_Control_Canvas").GetComponent<UI_Control>();
//NavSphere_Pivot = GameObject.Find("NavSphere_Pivot");
//NavSphere = GameObject.Find("Argos_NavSphere");
OVRTouchpad.Create();
OVRTouchpad.TouchHandler += HandleTouchHandler;
baseOVR_Pos = OVR_Main_Cam.transform.position;
baseOVR_Rota = OVR_Main_Cam.transform.rotation;
}
void HandleTouchHandler(object sender, System.EventArgs e)
{
OVRTouchpad.TouchArgs touchArgs = (OVRTouchpad.TouchArgs)e;
OVRTouchpad.TouchEvent touchEvent = touchArgs.TouchType;
/*if(touchArgs.TouchType == OVRTouchpad.TouchEvent.SingleTap)
{
//TODO: Insert code here to handle a single tap. Note that there are other TouchTypes you can check for like directional swipes, but double tap is not currently implemented I believe.
}*/
switch (touchEvent)
{
case OVRTouchpad.TouchEvent.SingleTap:
txtInputIndicator.text = "SingleTap";
rmf_Radial_Menu.onNavSelect();
TouchPadHandler();
break;
case OVRTouchpad.TouchEvent.Left:
txtInputIndicator.text = "Left";
break;
case OVRTouchpad.TouchEvent.Right:
txtInputIndicator.text = "Right";
break;
case OVRTouchpad.TouchEvent.Up:
txtInputIndicator.text = "Up";
break;
case OVRTouchpad.TouchEvent.Down:
txtInputIndicator.text = "Down";
break;
}
}
public void onGreenButton()
{
m_bAllowInput = true;
}
public void onRedButton()
{
m_bAllowInput = !m_bAllowInput;
}
void TouchPadHandler()
{
if (rmf_Radial_Menu.idxSelected == GVR_MODE.HOME)
{
OVR_Main_Cam.transform.position = baseOVR_Pos;
OVR_Main_Cam.transform.rotation = baseOVR_Rota;
}
if (rmf_Radial_Menu.idxSelected == GVR_MODE.LMB)
{
bLMButtonisDown = true;
bLMButtonWasDown = true;
MTimer[MouseButt.RMB] = 0f;
bRMButtonWasDown = false;
MTimer[MouseButt.MMB] = 0f;
bMMMouseButtonWasDown = false;
}
else
{
bLMButtonisDown = false;
}
if (rmf_Radial_Menu.idxSelected == GVR_MODE.RMB)
{
bRMButtonisDown = true;
bRMButtonWasDown = true;
MTimer[MouseButt.LMB] = 0f;
bLMButtonWasDown = false;
MTimer[MouseButt.MMB] = 0f;
bMMMouseButtonWasDown = false;
}
else
{
bRMButtonisDown = false;
}
if (rmf_Radial_Menu.idxSelected == GVR_MODE.MMB)
{
bMMMouseButtonisDown = true;
bMMMouseButtonWasDown = true;
MTimer[MouseButt.LMB] = 0f;
bLMButtonWasDown = false;
MTimer[MouseButt.RMB] = 0f;
bRMButtonWasDown = false;
}
else
{
bMMMouseButtonisDown = false;
}
bAnyMouseButton = bLMButtonisDown || bRMButtonisDown || bMMMouseButtonisDown || Input.GetKey("right ctrl") || Input.GetKey("e");
}
void checkMouseButts()
{
if (Input.GetMouseButtonDown(0))
{
bLMButtonisDown = true;
bLMButtonWasDown = true;
MTimer[MouseButt.RMB] = 0f;
bRMButtonWasDown = false;
MTimer[MouseButt.MMB] = 0f;
bMMMouseButtonWasDown = false;
}
if (Input.GetMouseButtonUp(0))
{
bLMButtonisDown = false;
}
if (Input.GetMouseButtonDown(1))
{
bRMButtonisDown = true;
bRMButtonWasDown = true;
MTimer[MouseButt.LMB] = 0f;
bLMButtonWasDown = false;
MTimer[MouseButt.MMB] = 0f;
bMMMouseButtonWasDown = false;
}
if (Input.GetMouseButtonUp(1))
{
bRMButtonisDown = false;
}
if (Input.GetMouseButtonDown(2))
{
bMMMouseButtonisDown = true;
bMMMouseButtonWasDown = true;
MTimer[MouseButt.LMB] = 0f;
bLMButtonWasDown = false;
MTimer[MouseButt.RMB] = 0f;
bRMButtonWasDown = false;
}
if (Input.GetMouseButtonUp(2))
{
bMMMouseButtonisDown = false;
}
bAnyMouseButton = bLMButtonisDown || bRMButtonisDown || bMMMouseButtonisDown || Input.GetKey("right ctrl") || Input.GetKey("e");
}
void Update()
{
//test OVR single tap
if(Input.GetMouseButtonDown(0))
{
rmf_Radial_Menu.onNavSelect();
}
iMode_GearVR = rmf_Radial_Menu.idxSelected;
MouseHandler();
if (!EventSystem.current.IsPointerOverGameObject())
{
//NavSphere_Pivot.transform.position = transform.position;
//if(ui_control.isLocked_NavSpheretoCam)
//{
// NavSphere_Pivot.transform.rotation = transform.rotation;
//}
}
//if (Input.touchCount > 0)
//{
// if (Input.GetTouch(0).phase == TouchPhase.Began)
// {
// PointerEventData ped = new PointerEventData(null);
// ped.position = Input.GetTouch(0).position;
// List<RaycastResult> results = new List<RaycastResult>();
// GR.Raycast(ped, results);
// if (results.Count == 0)
// {
// }
// }
//}
}
void MouseHandler()
{
//checkMouseButts();
float x = GearVRInput.GetAxisX;
float y = GearVRInput.GetAxisY;
seeX = x; seeY = y;
if (bAnyMouseButton)
{
xMouse_Damped = Mathf.Lerp(xMouse_Damped, x, damping);
yMouse_Damped = Mathf.Lerp(yMouse_Damped, y, damping);
//MTimer[MouseButt.LMB] = MTimer[MouseButt.RMB] = MTimer[MouseButt.MMB] = 0f;
}
else
{
xMouse_Damped = Mathf.Lerp(xMouse_Damped, 0f, damping);
yMouse_Damped = Mathf.Lerp(yMouse_Damped, 0f, damping);
}
float xMD_TimeScaled_AngVel = xMouse_Damped * MouseAngularSpeed * Time.deltaTime;
float yMD_TimeScaled_AngVel = yMouse_Damped * MouseAngularSpeed * Time.deltaTime;
float xMD_TimeScaled_LinVel = xMouse_Damped * MouseLLnearSpeed * Time.deltaTime;
float yMD_TimeScaled_LinVel = yMouse_Damped * MouseLLnearSpeed * Time.deltaTime;
//bArrow[Arrow.UP] = Input.GetKey(KeyCode.UpArrow);
//bArrow[Arrow.DOWN] = Input.GetKey(KeyCode.DownArrow);
//bArrow[Arrow.LEFT] = Input.GetKey(KeyCode.LeftArrow);
//bArrow[Arrow.RIGHT] = Input.GetKey(KeyCode.RightArrow);
//arrowsDamped[Arrow.UP] = Mathf.Lerp(arrowsDamped[Arrow.UP], ArrowSpeed*(bArrow[Arrow.UP] ?1f:0f), damping);
//arrowsDamped[Arrow.DOWN] = Mathf.Lerp(arrowsDamped[Arrow.DOWN], ArrowSpeed * (bArrow[Arrow.DOWN] ? 1f : 0f), damping);
//arrowsDamped[Arrow.LEFT] = Mathf.Lerp(arrowsDamped[Arrow.LEFT], ArrowSpeed * (bArrow[Arrow.LEFT] ? 1f : 0f), damping);
//arrowsDamped[Arrow.RIGHT] = Mathf.Lerp(arrowsDamped[Arrow.RIGHT], ArrowSpeed * (bArrow[Arrow.RIGHT] ? 1f : 0f), damping);
for (int i = 0; i<4; i++)
{
if (bArrow[i])
{
if (ATimer[i] > 0.0f)
{
bArrowWasDown[i] = false;
ATimer[i] = 0f;
}
else
{
bArrowWasDown[i] = true;
}
}
}
if (bLMButtonisDown || bLMButtonWasDown)
{
OVR_Main_Cam.transform.Translate(0, -yMD_TimeScaled_LinVel, xMD_TimeScaled_LinVel);
if (!bLMButtonisDown)
{
MTimer[MouseButt.LMB] += Time.deltaTime;
if (MTimer[MouseButt.LMB] > ReleaseTime)
{
MTimer[MouseButt.LMB] = 0f;
bLMButtonWasDown = false;
}
}
}
if (bRMButtonisDown || bRMButtonWasDown)
{
OVR_Main_Cam.transform.Translate(-xMD_TimeScaled_LinVel, -yMD_TimeScaled_LinVel, 0);
if (!bRMButtonisDown)
{
MTimer[MouseButt.RMB] += Time.deltaTime;
if (MTimer[MouseButt.RMB] > ReleaseTime)
{
MTimer[MouseButt.RMB] = 0f;
bRMButtonWasDown = false;
}
}
}
if (bMMMouseButtonisDown || bMMMouseButtonWasDown)
{
OVR_Main_Cam.transform.Translate(0, 0, yMD_TimeScaled_LinVel);
OVR_Main_Cam.transform.RotateAround(argosSphere.transform.position, OVR_Main_Cam.transform.up, xMD_TimeScaled_AngVel);
if (!bMMMouseButtonisDown)
{
MTimer[MouseButt.MMB] += Time.deltaTime;
if (MTimer[MouseButt.MMB] > ReleaseTime)
{
MTimer[MouseButt.MMB] = 0f;
bMMMouseButtonWasDown = false;
}
}
}
if (Input.GetKey("right ctrl") || Input.GetKey("left ctrl"))
{
//if (!bRotaPivot_On)
//{
// vHoldPivot = userMovement.GetComponent<UserMovement>().getCursorPostiion() + argosSphere.transform.position;
// bRotaPivot_On = true;
//}
OVR_Main_Cam.transform.RotateAround(vHoldPivot, OVR_Main_Cam.transform.up, xMD_TimeScaled_AngVel);
OVR_Main_Cam.transform.RotateAround(vHoldPivot, OVR_Main_Cam.transform.right, yMD_TimeScaled_AngVel);
return;
}
else
{
bRotaPivot_On = false;
}
if (Input.GetKey("e"))
{
Vector3 pos = argosSphere.transform.position;
OVR_Main_Cam.transform.RotateAround(pos, OVR_Main_Cam.transform.up, xMD_TimeScaled_AngVel);
OVR_Main_Cam.transform.RotateAround(pos, transform.right, -yMD_TimeScaled_AngVel);
return;
}
if (bArrow[Arrow.UP] || bArrowWasDown[Arrow.UP])
{
//transform.Translate(0,arrowsDamped[Arrow.UP]*Time.deltaTime, 0);
Vector3 pos = argosSphere.transform.position;
//if (ui_control.rotateOnNavSphere)
//{
// transform.RotateAround(pos, NavSphere.transform.right, -arrowsDamped[Arrow.UP] * Time.deltaTime);
//}
//else
//{
OVR_Main_Cam.transform.RotateAround(pos, transform.right, -arrowsDamped[Arrow.UP] * Time.deltaTime);
//}
if (!bArrow[Arrow.UP])
{
ATimer[Arrow.UP] += Time.deltaTime;
if (ATimer[Arrow.UP] > ReleaseTime)
{
ATimer[Arrow.UP] = 0f;
bArrowWasDown[Arrow.UP] = false;
}
}
}
if (bArrow[Arrow.DOWN] || bArrowWasDown[Arrow.DOWN])
{
//transform.Translate(0, -arrowsDamped[Arrow.DOWN] * Time.deltaTime, 0);
Vector3 pos = argosSphere.transform.position;
transform.RotateAround(pos, transform.right, arrowsDamped[Arrow.DOWN] * Time.deltaTime);
//if (ui_control.rotateOnNavSphere)
//{
// transform.RotateAround(pos, NavSphere.transform.right, arrowsDamped[Arrow.DOWN] * Time.deltaTime);
//}
//else
//{
transform.RotateAround(pos, transform.right, arrowsDamped[Arrow.DOWN] * Time.deltaTime);
//}
if (!bArrow[Arrow.DOWN])
{
ATimer[Arrow.DOWN] += Time.deltaTime;
if (ATimer[Arrow.DOWN] > ReleaseTime)
{
ATimer[Arrow.DOWN] = 0f;
bArrowWasDown[Arrow.DOWN] = false;
}
}
}
if (bArrow[Arrow.LEFT] || bArrowWasDown[Arrow.LEFT])
{
//transform.Translate(-arrowsDamped[Arrow.LEFT] * Time.deltaTime, 0, 0);
Vector3 pos = argosSphere.transform.position;
//if (ui_control.rotateOnNavSphere)
//{
// transform.RotateAround(pos, NavSphere.transform.up, arrowsDamped[Arrow.LEFT] * Time.deltaTime);
//}
//else
//{
transform.RotateAround(pos, transform.up, arrowsDamped[Arrow.LEFT] * Time.deltaTime);
//}
if (!bArrow[Arrow.LEFT])
{
ATimer[Arrow.LEFT] += Time.deltaTime;
if (ATimer[Arrow.LEFT] > ReleaseTime)
{
ATimer[Arrow.LEFT] = 0f;
bArrowWasDown[Arrow.LEFT] = false;
}
}
}
if (bArrow[Arrow.RIGHT] || bArrowWasDown[Arrow.RIGHT])
{
//transform.Translate(arrowsDamped[Arrow.RIGHT] * Time.deltaTime, 0, 0);
Vector3 pos = argosSphere.transform.position;
transform.RotateAround(pos, transform.up, -arrowsDamped[Arrow.RIGHT] * Time.deltaTime);
//if (ui_control.rotateOnNavSphere)
//{
// transform.RotateAround(pos, NavSphere.transform.up, -arrowsDamped[Arrow.RIGHT] * Time.deltaTime);
//}
//else
//{
transform.RotateAround(pos, transform.up, -arrowsDamped[Arrow.RIGHT] * Time.deltaTime);
//}
if (!bArrow[Arrow.RIGHT])
{
ATimer[Arrow.RIGHT] += Time.deltaTime;
if (ATimer[Arrow.RIGHT] > ReleaseTime)
{
ATimer[Arrow.RIGHT] = 0f;
bArrowWasDown[Arrow.RIGHT] = false;
}
}
}
}
}
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System;
public class Hexsphere : MonoBehaviour {
public static Hexsphere instance;
public Transform core;
public int TileCount;
[Range(1, 4)]
public int detailLevel;
public int numColors;
public static float unitScale;
public Material hexMat;
public Material pentMat;
public Material hexInsideMat;
public Material pentInsideMat;
private float radialScale;
private float maxEdgeLength;
private float maxTileRadius;
private float worldRadius;
private List<Vector3> vectors = new List<Vector3>();
private List<int> indices = new List<int>();
private List<GameObject> Tiles = new List<GameObject>();
void Start()
{
instance = this;
//radialScale = detailLevel;
//Build the HexSphere
BuildWorld ();
//Set Tile colors, Generate Regions, Spawn gameobjects etc
MapBuilder ();
}
private void BuildWorld(){
if (detailLevel < 1)
{
detailLevel = 1;
}
//Mesh generation freezes up for detail levels greater than 4
if (detailLevel > 4) {
detailLevel = 4;
}
radialScale = detailLevel;
unitScale = detailLevel;
#region Generate Icosahedron Vertices
//HEX VERTICES
Geometry.Icosahedron(vectors, indices);
//subdivide
for (int i = 0; i < detailLevel; i++)
Geometry.Subdivide(vectors, indices, true);
/// normalize vectors to "inflate" the icosahedron into a sphere.
for (int i = 0; i < vectors.Count; i++)
vectors[i]=Vector3.Normalize(vectors[i]) * radialScale;// * Mathf.Pow(2.17f, (float)detailLevel);
#endregion
List<Vector3> centers = getTriangleIncenter(vectors, indices);
maxEdgeLength = getMaxEdgeDistance (centers);
maxTileRadius = getMaxTileRadius (centers, vectors);
generateSubMeshes (centers, vectors);
TileCount = Tiles.Count;
worldRadius = Vector3.Magnitude (centers [0]);
}
private void generateSubMeshes(List<Vector3> centers, List<Vector3> vertices)
{
//Generate the hex/pent mesh for each vertex in the main mesh by associating it to its surrounding triangle centers
for(int i = 0; i < vertices.Count; i++)
{
GameObject tile = new GameObject ("Tile");
Mesh submesh = new Mesh ();
tile.AddComponent<MeshFilter> ();
//tile.transform.localPosition = vertices[i];
List<Vector3> submeshVs = new List<Vector3>();
for(int j = 0; j < centers.Count; j++)
{
if(Vector3.Distance(vertices[i], centers[j]) <= maxTileRadius)
{
submeshVs.Add(centers[j]);
}
}
//If its a pentagon
if(submeshVs.Count == 5)
{
bool[] isUsed = new bool[5];
List<int> orderedIndices = new List<int>();
Vector3 current = submeshVs[0];
orderedIndices.Add(0);
isUsed[0] = true;
//starting at the first point in submeshVs, find a point on the perimeter of the tile that is within one edgelength from point current, then add its index to the list
while(orderedIndices.Count < 5)
{
foreach(Vector3 c in submeshVs)
{
if(Vector3.Distance(c, current) <= maxEdgeLength && Vector3.Distance(c, current) >= 0.001f && !isUsed[submeshVs.IndexOf(c)])
{
//triangles[h + j] = submeshVs.IndexOf(c);
orderedIndices.Add(submeshVs.IndexOf(c));
isUsed[submeshVs.IndexOf(c)] = true;
current = c;
break;
}
}
}
int[] triangles = new int[9];
triangles[0] = 0;
triangles[1] = orderedIndices[1];
triangles[2] = orderedIndices[2];
triangles[3] = orderedIndices[2];
triangles[4] = orderedIndices[3];
triangles[5] = orderedIndices[0];
triangles[6] = orderedIndices[3];
triangles[7] = orderedIndices[4];
triangles[8] = orderedIndices[0];
Vector3[] subVsArray = submeshVs.ToArray();
submesh.vertices = subVsArray;
submesh.triangles = triangles;
Vector2[] uvs = new Vector2[submeshVs.Count];
uvs[orderedIndices[0]] = new Vector2(0f, 0.625f);
uvs[orderedIndices[1]] = new Vector2(0.5f, 1f);
uvs[orderedIndices[2]] = new Vector2(1f, 0.625f);
uvs[orderedIndices[3]] = new Vector2(0.8f, 0.0162f);
uvs[orderedIndices[4]] = new Vector2(.1875f, 0.0162f);
submesh.uv = uvs;
//tile.AddComponent<MeshRenderer>().material = pentMat;
tile.AddComponent<MeshRenderer>();
//When using multiple materials..
// Material[] pentMats = new Material[2];
// pentMats[0] = pentInsideMat;
// pentMats[1] = pentMat;
// tile.GetComponent<Renderer>().materials = pentMats;
//Single material
tile.GetComponent<Renderer>().material = pentMat;
}
//If its a hexagon
else if(submeshVs.Count == 6){
bool[] isUsed = new bool[6];
List<int> orderedIndices = new List<int>();
Vector3 current = submeshVs[0];
orderedIndices.Add(0);
isUsed[0] = true;
//starting at the first point in submeshVs, find a point on the perimeter of the tile that is within one edgelength from point current, then add its index to the list
while(orderedIndices.Count < 6)
{
foreach(Vector3 c in submeshVs)
{
if(Vector3.Distance(c, current) <= maxEdgeLength && Vector3.Distance(c, current) >= 0.001f && !isUsed[submeshVs.IndexOf(c)])
{
orderedIndices.Add(submeshVs.IndexOf(c));
isUsed[submeshVs.IndexOf(c)] = true;
current = c;
break;
}
}
}
int[] triangles = new int[12];
triangles[0] = 0;
triangles[1] = orderedIndices[1];
triangles[2] = orderedIndices[2];
triangles[3] = orderedIndices[2];
triangles[4] = orderedIndices[3];
triangles[5] = 0;
triangles[6] = orderedIndices[3];
triangles[7] = orderedIndices[4];
triangles[8] = 0;
triangles[9] = orderedIndices[4];
triangles[10] = orderedIndices[5];
triangles[11] = 0;
Vector3[] subVsArray = submeshVs.ToArray();
submesh.vertices = subVsArray;
submesh.triangles = triangles;
//Vector2[] uvs = new Vector2[submeshVs.Count];
Vector2[] uvs = new Vector2[6];
//UV Coords based on geometry of hexagon
uvs[orderedIndices[0]] = new Vector2(0.0543f, 0.2702f);
uvs[orderedIndices[1]] = new Vector2(0.0543f, 0.7272f);
uvs[orderedIndices[2]] = new Vector2(0.5f, 1f);
uvs[orderedIndices[3]] = new Vector2(0.946f, 0.7272f);
uvs[orderedIndices[4]] = new Vector2(0.946f, 0.2702f);
uvs[orderedIndices[5]] = new Vector2(0.5f, 0f);
submesh.uv = uvs;
//tile.AddComponent<MeshRenderer>().material = hexMat;
tile.AddComponent<MeshRenderer>();
// Material[] hexMats = new Material[2];
// hexMats[0] = hexInsideMat;
// hexMats[1] = hexMat;
// tile.GetComponent<Renderer>().materials = hexMats;
//Single material
tile.GetComponent<Renderer>().material = hexMat;
}
//Assign mesh
tile.GetComponent<MeshFilter>().mesh = submesh;
submesh.RecalculateBounds();
submesh.RecalculateNormals();
tile.AddComponent<Tile>();
//Fix any upsidedown tiles by checking their normal vector
if((submesh.normals[0] + vertices[i]).magnitude < vertices[i].magnitude)
{
submesh.triangles = submesh.triangles.Reverse().ToArray();
submesh.RecalculateBounds();
submesh.RecalculateNormals();
}
//Initialize tile attributes
tile.AddComponent<MeshCollider>();
//tile.GetComponent<MeshCollider>().convex = true;
//tile.GetComponent<MeshCollider>().isTrigger = true;
tile.transform.parent = this.transform;
tile.isStatic = true;
tile.GetComponent<Tile>().Initialize(vertices[i]);
tile.GetComponent<Renderer>().material.color = Color.white;
tile.tag = "Tile";
tile.GetComponent<Tile>().setTileRadius(maxTileRadius);
Tiles.Add(tile);
}
}
private void MapBuilder(){
//Randomly assign colors
for (int i = 0; i < Tiles.Count; i++) {
Tiles[i].GetComponent<Tile>().setColor(UnityEngine.Random.Range(1, numColors+1));
}
//find each tiles neighbors
for (int i = 0; i < Tiles.Count; i++) {
Tiles[i].GetComponent<Tile>().FindNeighbors();
}
}
private float getMaxTileRadius(List<Vector3> centers, List<Vector3> vertices){
float delta = 1.5f;
Vector3 v = Vector3.zero;
if (detailLevel != 0) {
v = vertices [12];
}
else{
v = vertices [0];
}
float minDistance = Mathf.Infinity;
foreach (Vector3 c in centers) {
float dist = Vector3.Distance(v, c);
if (dist < minDistance){
minDistance = dist;
}
}
minDistance = minDistance * (delta);
return minDistance;
}
private float getMaxEdgeDistance(List<Vector3> centers) {
//Returns the approximate distance between adjacent triangle centers
//delta is the approximate variation in edge lengths, as not all edges are the same length
float delta = 1.4f;
Vector3 point = centers [0];
// scan all vertices to find nearest
float minDistance = Mathf.Infinity;
foreach (Vector3 n in centers) {
if(!point.Equals(n)){
float dist = Vector3.Distance(point, n);
if (dist < minDistance){
minDistance = dist;
}
}
}
minDistance = minDistance * (delta);
return minDistance;
}
private List<Vector3> getTriangleIncenter(List<Vector3> vertices, List<int> triangles){
List<Vector3> centers = new List<Vector3> ();
for (int i = 0; i < triangles.Count - 2; i += 3) {
Vector3 A = vertices[triangles[i]];
Vector3 B = vertices[triangles[i + 1]];
Vector3 C = vertices[triangles[i + 2]];
float a = Vector3.Distance(C, B);
float b = Vector3.Distance(A, C);
float c = Vector3.Distance(A, B);
float P = a + b + c;
Vector3 abc = new Vector3(a, b, c);
float x = Vector3.Dot (abc, new Vector3(A.x, B.x, C.x)) / P;
float y = Vector3.Dot (abc, new Vector3(A.y, B.y, C.y)) / P;
float z = Vector3.Dot (abc, new Vector3(A.z, B.z, C.z)) / P;
Vector3 center = new Vector3(x, y, z);
centers.Add(center);
}
return centers;
}
}
