public void CreateSharedNodeInstanceScene()
{
// SceneBuilder API supports reusing a NodeBuilder in multiple instances with different content.
// but glTF nodes can only hold one mesh per node, so if we find this case we need to internally
// add an additional child node to give room to the the extra mesh.
TestContext.CurrentContext.AttachGltfValidatorLinks();
var m = MaterialBuilder.CreateDefault();
var cube = new Cube <MaterialBuilder>(m, 1.7f, 1.7f, 1.7f).ToMesh(Matrix4x4.Identity);
var sphere = new IcoSphere <MaterialBuilder>(m).ToMesh(Matrix4x4.Identity);
var armature1 = new NodeBuilder("Skeleton1");
var joint0 = armature1
.CreateNode("Joint 0")
.WithLocalTranslation(new Vector3(0, 1, 0));
var scene = new SceneBuilder();
scene.AddRigidMesh(cube, joint0);
scene.AddRigidMesh(sphere, joint0);
scene.AttachToCurrentTest("instanced.glb");
scene.AttachToCurrentTest("instanced.gltf");
}
public Mesh CreateTerrain(Vector3 origin)
{
Mesh mesh = new Mesh();
mesh.Clear();
if (meshType == SphereMeshType.Icosphere)
{
mesh = IcoSphere.GetIcosphereMesh(resolution);
}
else
{
mesh = CubicSphere.GetSphereMesh(resolution);
}
if (hasCraters)
{
GenerateCraters(mesh, nrOfCraters);
}
AddMeshDetail(mesh, origin, terrainRadius, true);
UpdateTerrainMinMax(mesh);
mesh.RecalculateNormals();
mesh.colors = GetColors(mesh.vertices, mesh.normals);
mesh.bounds = new Bounds(origin, new Vector3(float.MaxValue, float.MaxValue, float.MaxValue));
return(mesh);
}
public static Mesh GenerateMesh(IcoSphere icosphere, bool faceted)
{
List <Vertex> vertices = icosphere.Vertices;
List <Triangle> triangles = icosphere.Triangles;
return(GenerateMesh(vertices, triangles, faceted, icosphere.minHeight, icosphere.maxHeight));
}
public void EditorTest()
{
var gameObject = new GameObject();
icoSphere = gameObject.AddComponent <IcoSphere>();
icoSphere.recursionLevel = 1;
icoSphere.Create();
}
public static float Detect(IcoSphere obstacle, Player player)
{
var r1 = obstacle.GetRadius();
var r2 = player.GetRadius();
var d = (obstacle.GetPosition() - player.GetPosition()).Length;
return(d - r1 - r2);
}
private void OnValidate()
{
points = IcoSphere.GetIcoSpherePoints(radius, icoSphereRecursions);
if (!Application.isPlaying)
{
Debug.Log("Number of points: " + points.Length);
}
}
protected override DX11IndexedGeometry GetGeom(DX11RenderContext context, int slice)
{
IcoSphere sph = new IcoSphere();
sph.Radius = this.FSize[slice];
sph.SubDivisions = this.FSubDiv[slice];
return(context.Primitives.IcoSphere(sph));
}
void OnSceneGUI () {
icoSphere = target as IcoSphere;
if ( isTrianglesVisible ) {
DrawTriangles();
}
if ( isPolygonsVisible ) {
DrawPolygons();
}
}
void CreatePlanetGameObject()
{
planet = new GameObject();
planetMeshFilter = planet.AddComponent <MeshFilter>();
planetMesh = planetMeshFilter.mesh;
planetMeshRenderer = planet.AddComponent <MeshRenderer>();
//need to set the material up top
planetMeshRenderer.material = planetMaterial;
planet.transform.localScale = new Vector3(planetSize, planetSize, planetSize);
IcoSphere.Create(planet);
}
public HexaSphere(IcoSphere icosphere)
{
cells = new List <Cell> ();
vertices = new Dictionary <Vertex, Vertex>();
Cell newCell;
foreach (Vertex vertex in icosphere.Vertices)
{
newCell = new Cell(vertex);
cells.Add(newCell);
foreach (Triangle t in vertex.Triangles)
{
Vertex cellVertex = new Vertex(t.Center);
if (!vertices.ContainsKey(cellVertex))
{
vertices.Add(cellVertex, cellVertex);
newCell += cellVertex;
}
else
{
newCell += vertices [cellVertex];
}
}
newCell.ConnectVerices();
}
foreach (Cell c1 in cells)
{
if (c1.NeighbourCount > 5)
{
continue;
}
foreach (Cell c2 in cells)
{
if (c2.NeighbourCount > 5)
{
continue;
}
if (c1 != c2 && !c1.IsNeighbour(c2))
{
if (c1.CheckForNeighbourConditions(c2))
{
c2.AddNeighbour(c1);
}
}
if (c1.NeighbourCount > 5)
{
break;
}
}
}
}
ColliderSliceResult[] SliceColliders(Plane plane)
{
var colliders = GetComponentsInChildren <Collider>();
ColliderSliceResult[] results = new ColliderSliceResult[colliders.Length];
bool ColliderExistsNeg = false;
bool ColliderExistsPos = false;
for (int i = 0; i < colliders.Length; i++)
{
var collider = colliders[i];
var colliderB = collider as BoxCollider;
var colliderS = collider as SphereCollider;
var colliderC = collider as CapsuleCollider;
var colliderM = collider as MeshCollider;
ColliderSliceResult result;
if (colliderB != null)
{
var mesh = Cube.Create(colliderB.size, colliderB.center);
result = TrySliceCollider(colliderB.center, colliderB, mesh, plane);
}
else if (colliderS != null)
{
var mesh = IcoSphere.Create(colliderS.radius, colliderS.center);
result = TrySliceCollider(colliderS.center, colliderS, mesh, plane);
}
else if (colliderC != null)
{
var mesh = Capsule.Create(colliderC.radius, colliderC.height, colliderC.direction, colliderC.center);
result = TrySliceCollider(colliderC.center, colliderC, mesh, plane);
}
else if (colliderM != null)
{
Mesh mesh = Instantiate(colliderM.sharedMesh);
result = TrySliceCollider(Vector3.zero, colliderM, mesh, plane);
}
else
{
throw new NotSupportedException("Not supported collider type '" + collider.GetType().Name + "'");
}
ColliderExistsNeg |= result.SliceResult == SliceResult.Sliced | result.SliceResult == SliceResult.Neg;
ColliderExistsPos |= result.SliceResult == SliceResult.Sliced | result.SliceResult == SliceResult.Pos;
results[i] = result;
}
bool sliced = ColliderExistsNeg & ColliderExistsPos;
return(sliced ? results : null);
}
public void CreateDetailedPlanet()
{
if (randomSeed)
{
seed = (int)System.DateTime.Now.Ticks;
}
Random.InitState(seed);
//scale = Random.Range (0.5f, 1.1f);
icosphere = new IcoSphere(subdivisions, octaves, persistance, lacunarity, scale, heightCurve, heighMultiplyer, seed, Vector3.one);
icosphere.mesh = MeshGenerator.GenerateMesh(icosphere, flatShading);
GetComponent <MeshFilter> ().mesh = icosphere.mesh;
}
private static ColliderSliceResult[] SliceColliders(Plane plane, Collider[] colliders)
{
ColliderSliceResult[] results = new ColliderSliceResult[colliders.Length];
bool ColliderExistsNeg = false;
bool ColliderExistsPos = false;
for (int i = 0; i < colliders.Length; i++)
{
var collider = colliders[i];
var colliderB = collider as BoxCollider;
var colliderS = collider as SphereCollider;
var colliderC = collider as CapsuleCollider;
var colliderM = collider as MeshCollider;
ColliderSliceResult result;
if (colliderB != null)
{
var mesh = Cube.Create(colliderB.size, colliderB.center);
result = PrepareSliceCollider(collider, mesh, plane);
}
else if (colliderS != null)
{
var mesh = IcoSphere.Create(colliderS.radius, colliderS.center);
result = PrepareSliceCollider(collider, mesh, plane);
}
else if (colliderC != null)
{
var mesh = Capsule.Create(colliderC.radius, colliderC.height, colliderC.direction, colliderC.center);
result = PrepareSliceCollider(collider, mesh, plane);
}
else if (colliderM != null)
{
Mesh mesh = UnityEngine.Object.Instantiate(colliderM.sharedMesh);
result = PrepareSliceCollider(collider, mesh, plane);
}
else
{
throw new NotSupportedException("Not supported collider type '" + collider.GetType().Name + "'");
}
ColliderExistsNeg |= result.SliceResult == SliceResult.Sliced | result.SliceResult == SliceResult.Neg;
ColliderExistsPos |= result.SliceResult == SliceResult.Sliced | result.SliceResult == SliceResult.Pos;
results[i] = result;
}
bool sliced = ColliderExistsNeg & ColliderExistsPos;
return(sliced ? results : null);
}
void OnValidate()
{
MeshFilter meshFilter = this.gameObject.GetComponent <MeshFilter>();
MeshRenderer meshRenderer = this.gameObject.GetComponent <MeshRenderer>();
if (meshFilter != null)
{
meshFilter.mesh = IcoSphere.GetIcosphereMesh(resolution);
}
if (meshRenderer != null)
{
meshRenderer.sharedMaterial = new Material(shader);
}
}
public override void Initialize()
{
if (shapeSettings == null || colorSettings == null)
{
shapeSettings = SettingSpawner.CopyShapeSettings();
colorSettings = SettingSpawner.CopyColorSettings();
}
shapeSettings = SettingSpawner.CopyShapeSettings();
colorSettings = SettingSpawner.CopyColorSettings();
if (craterSettings == null)
{
craterSettings = SettingSpawner.CopyCraterSettings();
}
interaction = (Interactor)GameObject.Find("Interactor").GetComponent <Interactor>();
if (this.GetComponent <SphereCollider>() == null)
{
this.gameObject.AddComponent <SphereCollider>();
}
if (this.transform.Find("mesh") == null) // no meshObj initialized yet
{
GameObject meshObj = new GameObject("mesh");
meshObj.transform.parent = transform;
meshObj.AddComponent <MeshRenderer>(); //.material = (Material) Resources.Load("defaultMat");
meshFilter = meshObj.AddComponent <MeshFilter>();
meshFilter.sharedMesh = new Mesh();
meshObj.GetComponent <MeshRenderer>().sharedMaterial = colorSettings.planetMaterial;
}
else
{
GameObject meshObj = this.transform.Find("mesh").gameObject;
meshFilter = meshObj.GetComponent <MeshFilter>();
meshObj.GetComponent <MeshRenderer>(); //.material = (Material) Resources.Load("defaultMat");
meshFilter.sharedMesh = new Mesh();
meshObj.GetComponent <MeshRenderer>().sharedMaterial = colorSettings.planetMaterial;
}
craterGenerator = new CraterGenerator(craterSettings);
shapeGenerator = new ShapeGenerator(shapeSettings, interaction, craterGenerator);
colorGenerator = new ColorGenerator();
colorGenerator.UpdateSettings(colorSettings);
icoSphere = new IcoSphere(shapeGenerator, shapeSettings.radius, LOD, meshFilter.sharedMesh);
icoSphere.SetUVs(colorGenerator);
}
public Mesh CreateWater(Vector3 origin)
{
Mesh mesh = new Mesh();
mesh.Clear();
mesh = IcoSphere.GetIcosphereMesh(resolution);
AddMeshDetail(mesh, origin, waterRadius, false);
mesh.RecalculateNormals();
mesh.bounds = new Bounds(origin, new Vector3(float.MaxValue, float.MaxValue, float.MaxValue));
mesh.tangents = waterLevelData;
return(mesh);
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
IcoSphere myScript = (IcoSphere)target;
if (GUILayout.Button("Build IcoSphere"))
{
myScript.CreateIcosphere();
myScript.UpdateMesh();
}
serializedObject.Update();
radius.floatValue = Mathf.Max(0.5f, radius.floatValue);
serializedObject.ApplyModifiedProperties();
}
public IEnumerator RedoSphere()
{
for (; ;)
{
GameObject tmp = Sphere;
Sphere = IcoSphere.Create("HitSphere", SphereOptions.SpherePrediction ? 15.5f : SphereOptions.SphereRadius, SphereOptions.RecursionLevel);
Sphere.layer = LayerMasks.AGENT;
Sphere.transform.parent = base.transform;
Sphere.transform.localPosition = Vector3.zero;
UnityEngine.Object.Destroy(tmp);
yield return(new WaitForSeconds(1f));
tmp = null;
}
}
public override void OnInspectorGUI () {
if(EditorPrefs.HasKey(POLYGONS_VISIBLE)) {isPolygonsVisible = EditorPrefs.GetBool(POLYGONS_VISIBLE);}
if(EditorPrefs.HasKey(POLYGONS_VISIBLE)) {isTrianglesVisible = EditorPrefs.GetBool(TRIANGLES_VISIBLE);}
icoSphere = target as IcoSphere;
DrawDefaultInspector();
isPolygonsVisible = GUILayout.Toggle(isPolygonsVisible, "Show Polygons");
if (GUI.changed) EditorPrefs.SetBool(POLYGONS_VISIBLE, isPolygonsVisible);
isTrianglesVisible = GUILayout.Toggle(isTrianglesVisible, "Show Triangles");
if (GUI.changed) EditorPrefs.SetBool(TRIANGLES_VISIBLE, isTrianglesVisible);
if(GUILayout.Button("Create")) {
icoSphere.Create();
}
OnSceneGUI ();
}
IEnumerator RedoSphere()
{
while (true)
{
GameObject tmp = Sphere;
Sphere = IcoSphere.Create("HitSphere", SphereOptions.SpherePrediction ? 15.5f : SphereOptions.SphereRadius, SphereOptions.RecursionLevel);
Sphere.layer = LayerMasks.AGENT;
Sphere.transform.parent = transform;
Sphere.transform.localPosition = Vector3.zero;
Destroy(tmp);
yield return(new WaitForSeconds(1f));
}
}
public void ChangeLOD(IcoSphere lodSphere, int resolution, bool flatShading)
{
current = lodSphere;
if (lodSphere == null && resolution < 6)
{
lodSphere = LODs[resolution] = new IcoSphere(resolution, octaves, persistance, lacunarity, scale, heightCurve, heighMultiplyer, variableMaxHeight, seed);
lodSphere.mesh = MeshGenerator.GenerateMesh(lodSphere, flatShading);
}
else if (lodSphere.mesh == null && resolution < 6)
{
lodSphere.Recreate(octaves, persistance, lacunarity, scale, heightCurve, heighMultiplyer, variableMaxHeight, seed);
lodSphere.mesh = MeshGenerator.GenerateMesh(lodSphere, flatShading);
}
GetComponent <MeshFilter> ().mesh = lodSphere.mesh;
//GetComponent<MeshCollider>().sharedMesh = mesh;
//animator.SetTrigger ("Grow");
}
private void CreateMeshes()
{
meshes = new Mesh[points.Length];
meshPositions = new Vector3[points.Length];
for (int x = 0; x < size.x; x++)
{
for (int y = 0; y < size.y; y++)
{
for (int z = 0; z < size.z; z++)
{
//creating the icospheres and setting their positions
meshes[x + (y * size.x) + (z * size.x * size.y)] = IcoSphere.Create(dotSize);
meshPositions[x + (y * size.x) + (z * size.x * size.y)] = Utility.CalculatePointPosition(new Vector3Int(x, y, z), center, gridSize, size);
}
}
}
}
public void CreatePlanet()
{
if (randomSeed)
{
seed = (int)System.DateTime.Now.Ticks;
}
Random.InitState(seed);
//scale = Random.Range (0.5f, 1.5f);
if (icosphere == null)
{
icosphere = new IcoSphere(subdivisions, octaves, persistance, lacunarity, scale, heightCurve, heighMultiplyer, variableMaxHeight, seed);
}
else
{
icosphere.Recreate(octaves, persistance, lacunarity, scale, heightCurve, heighMultiplyer, variableMaxHeight, seed);
}
icosphere.mesh = MeshGenerator.GenerateMesh(icosphere, flatShading);
GetComponent <MeshFilter>().mesh = icosphere.mesh;
//GetComponent<MeshCollider>().sharedMesh = mesh;
foreach (IcoSphere LOD in LODs)
{
if (LOD != null)
{
LOD.mesh = null;
}
}
if (LODs [3] == null)
{
LODs [3] = new IcoSphere(3, octaves, persistance, lacunarity, scale, heightCurve, heighMultiplyer, variableMaxHeight, seed);
}
else
{
LODs[3].Recreate(octaves, persistance, lacunarity, scale, heightCurve, heighMultiplyer, variableMaxHeight, seed);
}
current = icosphere;
LODs[3].mesh = MeshGenerator.GenerateMesh(LODs [3], true);
GetComponent <MeshCollider> ().sharedMesh = LODs[3].mesh;
animator.SetTrigger("Grow");
}
private void ApplyCollision(IcoSphere obstacle, Player targetPlayer)
{
var detector = CollisionDetector.Detect(obstacle, targetPlayer);
if (detector > 0.0f)
{
return;
}
var playerToObstacle = targetPlayer.GetPosition() - obstacle.GetPosition();
if (!(playerToObstacle.Length > Constants.EPS))
{
return;
}
var obstacleNormal = playerToObstacle.Normalized();
targetPlayer.SetPosition((obstacle.GetRadius() + targetPlayer.GetRadius()) * obstacleNormal + obstacle.GetPosition());
}
void Update()
{
if (cachedIterations != Iterations)
{
cachedIterations = Iterations;
icoSphere = new IcoSphere(Iterations);
Mesh mesh = new Mesh();
MeshFilter meshFilter = gameObject.GetComponent <MeshFilter> ();
meshFilter.sharedMesh = mesh;
mesh.vertices = icoSphere
.Vertices
.ConvertAll(vertex => {
return(vertex.normalized * scale);
})
.ToArray();
mesh.triangles = icoSphere.Triangles.ToArray();
mesh.RecalculateBounds();
mesh.RecalculateNormals();
}
}
private void Window_Load(object sender, EventArgs e)
{
GL.ClearColor(Color.FromArgb(0, 0, 0, 0));
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.Texture2D);
player = new Player(100f);
shaderProgram = new ShaderProgram();
shaderProgram.CreateVertexShader(Utils.LoadShaderCode("vertex.glsl"));
shaderProgram.CreateFragmentShader(Utils.LoadShaderCode("fragment.glsl"));
shaderProgram.Link();
shaderProgram.CreateUniform("viewMatrix");
shaderProgram.CreateUniform("worldMatrix");
shaderProgram.CreateUniform("projectionMatrix");
shaderProgram.CreateUniform("lightViewMatrix");
shaderProgram.CreateUniform("lightProjectionMatrix");
shaderProgram.CreateUniform("viewPos");
shaderProgram.CreateUniform("light.color");
shaderProgram.CreateUniform("light.direction");
shaderProgram.CreateUniform("light.ambientStrength");
shaderProgram.CreateUniform("light.position");
shaderProgram.CreateUniform("material.color");
shaderProgram.CreateUniform("material.specularStrength");
shaderProgram.CreateUniform("material.shininess");
shaderProgram.CreateUniform("shadowMap");
depthFbo = new ShadowMapFbo(shadowMapWidth, shadowMapHeight);
depthShaderProgram = new ShaderProgram();
depthShaderProgram.CreateVertexShader(Utils.LoadShaderCode("depth_shadowmap_vertex.glsl"));
depthShaderProgram.CreateFragmentShader(Utils.LoadShaderCode("depth_shadowmap_fragment.glsl"));
depthShaderProgram.Link();
depthShaderProgram.CreateUniform("lightViewMatrix");
depthShaderProgram.CreateUniform("lightProjectionMatrix");
depthShaderProgram.CreateUniform("worldMatrix");
light = new Light();
light.SetDirection(new Vector3(-1f, -1f, -1f));
light.SetPosition(new Vector3(ncRooms / 2f * (rmWidth + gap), rmHeight + 2 * player.GetRadius() + lightHeightOffset, nrRooms / 2f * (rmWidth + gap)));
light.InitiateBeam(100000f);
player.SetPosition(light.GetPosition() - 1.2f * light.GetRadius() * Vector3.One);
ico = new IcoSphere(100f, 5);
ico.SetPosition(light.GetPosition() + 1000 * light.GetDirection());
stack = new Stack <int>();
rooms = new Room[nrRooms * ncRooms];
for (var i = 0; i < nrRooms; ++i)
{
for (var j = 0; j < ncRooms; ++j)
{
var offset = new Vector3(j * (rmWidth + gap), 0.0f, i * (rmWidth + gap));
rooms[GetFlatteredIndex(i, j)] = new Room(offset, rmWidth, rmHeight);
}
}
plane = new Quad(Vector3.Zero, ncRooms * (rmWidth + gap), nrRooms * (rmWidth + gap), Vector3.UnitZ, Vector4.One);
plane.UpdateRotation(MathHelper.DegreesToRadians(-90f), 0.0f, 0.0f);
plane.UpdatePosition(Vector3.UnitZ * nrRooms * (rmWidth + gap));
curInd = GetFlatteredIndex(0, 0);
rooms[curInd].Visit();
}
public static void Main(string[] args)
{
//Test level
int icoLevel = 8;
int raycastLoops = 100000;
bool neighbourTest = false;
bool indexTest = false;
//Info
Console.WriteLine("===ICOSAHEDRON INFO===");
for (int i = 0; i < 20; i++)
{
long vert = IcoCommon.VerticiesInLevel(i);
long edge = IcoCommon.EdgesInLevel(i);
long faces = IcoCommon.FacesInLevel(i);
Console.WriteLine("Level: " + i + ", verticies: " + vert + ", edges: " + edge + ", faces: " + faces);
}
//Performance testing
Console.WriteLine("===PREFORMANCE TESTING===");
for (int i = 0; i <= icoLevel; i++)
{
Stopwatch sw = new Stopwatch();
sw.Start();
IcoCommon.Precalculate(i);
sw.Stop();
Stopwatch sw2 = new Stopwatch();
sw2.Start();
IcoCommon.PrecalculateNeighboursVertex(i);
sw2.Stop();
Stopwatch sw3 = new Stopwatch();
sw3.Start();
IcoCommon.PrecalculateNeighboursFaces(i);
sw3.Stop();
Console.WriteLine("Precalculate " + i + ", verticies: " + IcoCommon.VerticiesInLevel(i) + ", faces: " + IcoCommon.FacesInLevel(i) + ", vertex/face time: " + sw.ElapsedMilliseconds + " ms, vertex neighbour time: " + sw2.ElapsedMilliseconds + " ms, face neighbour time: " + sw3.ElapsedMilliseconds + " ms.");
}
IcoSphere icos = new IcoSphere(icoLevel);
Console.WriteLine("Icosphere level: " + icoLevel + ", verticies: " + icos.verticies.Length + ", faces: " + icos.faces.Length);
//Index neighbour common
IcoCollection <int> icoc = new IcoCollection <int>(icoLevel);
for (int i = 0; i < icoc.Length; i++)
{
icoc[i] = i;
}
if (indexTest)
{
Console.WriteLine("===INDEX ENUMERATOR TESTING===");
int i = 0;
foreach (int j in icoc)
{
if (i != j)
{
throw new Exception("Index 1 failed");
}
Console.WriteLine(i + " : " + j);
i++;
}
}
if (neighbourTest)
{
Console.WriteLine("===NEIGHBOUR ENUMERATOR TESTING===");
for (int i = 0; i < icoc.Length; i++)
{
Console.WriteLine("Index " + i);
int[] neighbourIndexes = icoc.GetNeighboursIndex(i);
int count = 0;
foreach (int j in icoc.GetNeighbours(i))
{
int testj = icoc[neighbourIndexes[count]];
Console.WriteLine(j + " == " + testj);
if (j != testj)
{
throw new Exception("Neighbour 1 failed");
}
count++;
}
if (count != neighbourIndexes.Length)
{
throw new Exception("Neighbour 2 failed");
}
Console.WriteLine("---");
}
}
//Raycast setup common
Vector3d dirVector = new Vector3d(1, 1, 1).normalized;
List <Vector3d> rawVertex = IcoCommon.GetVerticiesRaw(icoLevel);
//Raycast vertex
Console.WriteLine("===TREE RAYCAST VERTEX TESTING===");
Console.WriteLine("Source Direction: " + dirVector);
for (int i = 0; i <= icoLevel; i++)
{
int closestVertexID = 0;
Stopwatch swRaycast = new Stopwatch();
swRaycast.Start();
for (int currentLoop = 0; currentLoop < raycastLoops; currentLoop++)
{
closestVertexID = IcoCommon.RaycastVertex(dirVector, i, false);
}
swRaycast.Stop();
Vector3d closestVertex = rawVertex[closestVertexID];
double error = (closestVertex - dirVector).magnitude;
double vertexDot = Vector3d.Dot(dirVector, closestVertex);
Console.WriteLine("Level: " + i + ", Closest: " + closestVertexID + ", Direction: " + closestVertex + ", Dot: " + vertexDot + ", error: " + error + ", time: " + swRaycast.ElapsedMilliseconds + " ms.");
}
//Raycast vertex
Console.WriteLine("===TREE RAYCAST FACE TESTING===");
Console.WriteLine("Source Direction: " + dirVector);
for (int i = 0; i <= icoLevel; i++)
{
int closestFaceID = 0;
Stopwatch swRaycastFace = new Stopwatch();
swRaycastFace.Start();
for (int currentLoop = 0; currentLoop < raycastLoops; currentLoop++)
{
closestFaceID = IcoCommon.RaycastFace(dirVector, i, false);
}
swRaycastFace.Stop();
List <Face> rawFaces = IcoCommon.GetFacesRaw(i);
Face closestFace = rawFaces[closestFaceID];
Vector3d faceCentre = (rawVertex[closestFace.point1] + rawVertex[closestFace.point2] + rawVertex[closestFace.point3]).normalized;
double error = (faceCentre - dirVector).magnitude;
double centerDot = Vector3d.Dot(dirVector, faceCentre);
Console.WriteLine("Level: " + i + ", Closest: " + closestFaceID + ", Vertex edges: [" + closestFace.point1 + "," + closestFace.point2 + "," + closestFace.point3 + "], Center: " + faceCentre + ", Dot: " + centerDot + ", error: " + error + ", time: " + swRaycastFace.ElapsedMilliseconds + " ms.");
}
}
public void CreatePlanet()
{
icosphere = new IcoSphere(divisions);
hexaSphere = new HexaSphere(icosphere);
}
void Awake()
{
icoSphere = new IcoSphere(Iterations);
cachedIterations = Iterations;
}
public static GameObject Create(string name, float radius, float recursionLevel)
{
GameObject gameObject = new GameObject(name);
Mesh mesh = new Mesh
{
name = name
};
List <Vector3> list = new List <Vector3>();
Dictionary <long, int> dictionary = new Dictionary <long, int>();
float num = (1f + Mathf.Sqrt(5f)) / 2f;
list.Add(new Vector3(-1f, num, 0f).normalized *radius);
list.Add(new Vector3(1f, num, 0f).normalized *radius);
list.Add(new Vector3(-1f, -num, 0f).normalized *radius);
list.Add(new Vector3(1f, -num, 0f).normalized *radius);
list.Add(new Vector3(0f, -1f, num).normalized *radius);
list.Add(new Vector3(0f, 1f, num).normalized *radius);
list.Add(new Vector3(0f, -1f, -num).normalized *radius);
list.Add(new Vector3(0f, 1f, -num).normalized *radius);
list.Add(new Vector3(num, 0f, -1f).normalized *radius);
list.Add(new Vector3(num, 0f, 1f).normalized *radius);
list.Add(new Vector3(-num, 0f, -1f).normalized *radius);
list.Add(new Vector3(-num, 0f, 1f).normalized *radius);
List <IcoSphere.TriangleIndices> list2 = new List <IcoSphere.TriangleIndices>
{
new IcoSphere.TriangleIndices(0, 11, 5),
new IcoSphere.TriangleIndices(0, 5, 1),
new IcoSphere.TriangleIndices(0, 1, 7),
new IcoSphere.TriangleIndices(0, 7, 10),
new IcoSphere.TriangleIndices(0, 10, 11),
new IcoSphere.TriangleIndices(1, 5, 9),
new IcoSphere.TriangleIndices(5, 11, 4),
new IcoSphere.TriangleIndices(11, 10, 2),
new IcoSphere.TriangleIndices(10, 7, 6),
new IcoSphere.TriangleIndices(7, 1, 8),
new IcoSphere.TriangleIndices(3, 9, 4),
new IcoSphere.TriangleIndices(3, 4, 2),
new IcoSphere.TriangleIndices(3, 2, 6),
new IcoSphere.TriangleIndices(3, 6, 8),
new IcoSphere.TriangleIndices(3, 8, 9),
new IcoSphere.TriangleIndices(4, 9, 5),
new IcoSphere.TriangleIndices(2, 4, 11),
new IcoSphere.TriangleIndices(6, 2, 10),
new IcoSphere.TriangleIndices(8, 6, 7),
new IcoSphere.TriangleIndices(9, 8, 1)
};
int num2 = 0;
while (num2 < recursionLevel)
{
List <IcoSphere.TriangleIndices> list3 = new List <IcoSphere.TriangleIndices>();
for (int i = 0; i < list2.Count; i++)
{
IcoSphere.TriangleIndices triangleIndices = list2[i];
int middlePoint = IcoSphere.getMiddlePoint(triangleIndices.v1, triangleIndices.v2, ref list, ref dictionary, radius);
int middlePoint2 = IcoSphere.getMiddlePoint(triangleIndices.v2, triangleIndices.v3, ref list, ref dictionary, radius);
int middlePoint3 = IcoSphere.getMiddlePoint(triangleIndices.v3, triangleIndices.v1, ref list, ref dictionary, radius);
list3.Add(new IcoSphere.TriangleIndices(triangleIndices.v1, middlePoint, middlePoint3));
list3.Add(new IcoSphere.TriangleIndices(triangleIndices.v2, middlePoint2, middlePoint));
list3.Add(new IcoSphere.TriangleIndices(triangleIndices.v3, middlePoint3, middlePoint2));
list3.Add(new IcoSphere.TriangleIndices(middlePoint, middlePoint2, middlePoint3));
}
list2 = list3;
num2++;
}
mesh.vertices = list.ToArray();
List <int> list4 = new List <int>();
for (int j = 0; j < list2.Count; j++)
{
list4.Add(list2[j].v1);
list4.Add(list2[j].v2);
list4.Add(list2[j].v3);
}
mesh.triangles = list4.ToArray();
Vector3[] vertices = mesh.vertices;
Vector2[] array = new Vector2[vertices.Length];
for (int k = 0; k < vertices.Length; k++)
{
Vector3 normalized = vertices[k].normalized;
Vector2 vector;
vector = new Vector2(0f, 0f)
{
x = (Mathf.Atan2(normalized.x, normalized.z) + 3.14159274f) / 3.14159274f / 2f,
y = (Mathf.Acos(normalized.y) + 3.14159274f) / 3.14159274f - 1f
};
array[k] = new Vector2(vector.x, vector.y);
}
mesh.uv = array;
Vector3[] array2 = new Vector3[list.Count];
for (int l = 0; l < array2.Length; l++)
{
array2[l] = list[l].normalized;
}
mesh.normals = array2;
mesh.RecalculateBounds();
gameObject.AddComponent <MeshCollider>().sharedMesh = mesh;
return(gameObject);
}
