public void ValidOctahedron()
{
var solid = new Octahedron()
{
Size = new SharpDX.Vector3(1.0f, 1.0f, 1.0f)
};
}
// Use this for initialization
void Start()
{
rend = gameObject.GetComponent<Renderer>();
//mat = new Material(Shader.Find("Standard"));
//rend = new Renderer();
//rend.material = mat;
gMO = GameObject.Find("GameManager");
gM = gMO.GetComponent<GameManager>();
tetrahedron = gameObject.GetComponent<Tetrahedron>();
octahedron = gameObject.GetComponent<Octahedron>();
dodecahedron = gameObject.GetComponent<Dodecahedron>();
icosahedron = gameObject.GetComponent<Icosahedron>();
counter = (int)Random.Range(1f, 5f);
if(counter == 5)
counter = 4;
if(counter == 1)
tetrahedron.MakeMesh();
if(counter == 2)
octahedron.MakeMesh();
if(counter == 3)
dodecahedron.MakeMesh();
if(counter == 4)
icosahedron.MakeMesh();
gM.ZombiePlus();
}
public Star(SystemController controller, int seed, GameObject gameObject) : base(controller, gameObject, seed, new CelestialType.Star())
{
MeshFilter filter = gameObject.AddComponent <MeshFilter>();
MeshRenderer renderer = gameObject.AddComponent <MeshRenderer>();
filter.mesh = Octahedron.Create(5, radius);
Material mat = new Material(controller.materialController.starMaterial);
CelestialType starType = new CelestialType.Star();
mat.SetInt("_Temp", (int)Utility.GetRandomBetween(new System.Random(seed), starType.minTemperature, starType.maxTemperature));
renderer.material = mat;
renderer.receiveShadows = false;
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
gameObject.transform.localScale = Vector3.one;
var light = gameObject.AddComponent <Light>();
light.type = LightType.Point;
light.range = 2000000;
light.bounceIntensity = 0;
light.renderMode = LightRenderMode.ForcePixel;
light.intensity = 1;
light.shadows = LightShadows.Soft;
light.shadowNearPlane = .1f;
}
protected override DX11IndexedGeometry GetGeom(DX11RenderContext context, int slice)
{
Octahedron oct = new Octahedron();
oct.Radius = FSize[slice];
return(context.Primitives.Octahedron(oct));
}
/*[Input("Size",DefaultValues= new double[] { 1,1,1})]
* IDiffSpread<Vector3> FSize;*/
protected override DX11IndexedGeometry GetGeom(DX11RenderContext context, int slice)
{
Octahedron oct = new Octahedron();
oct.Size = new Vector3(1, 1, 1);
return(context.Primitives.Octahedron(oct));
}
void Start()
{
rotationSpeed = Random.Range(-5f, 5f);
rend = gameObject.GetComponent <Renderer>();
tetrahedron = gameObject.GetComponent <Tetrahedron>();
octahedron = gameObject.GetComponent <Octahedron>();
dodecahedron = gameObject.GetComponent <Dodecahedron>();
icosahedron = gameObject.GetComponent <Icosahedron>();
}
void Start()
{
rotationSpeed = Random.Range(-5f, 5f);
rend = gameObject.GetComponent<Renderer>();
tetrahedron = gameObject.GetComponent<Tetrahedron>();
octahedron = gameObject.GetComponent<Octahedron>();
dodecahedron = gameObject.GetComponent<Dodecahedron>();
icosahedron = gameObject.GetComponent<Icosahedron>();
}
/// <summary>
/// Draws a diamond that represents a single point.
/// </summary>
/// <param name="rCenter"></param>
/// <param name="rColor"></param>
public static void DrawPoint(Vector3 rCenter, Color rColor, Transform rTransform = null)
{
if (mOctahedron == null)
{
mOctahedron = new Octahedron();
}
for (int i = 0; i < mOctahedron.Triangles.Length; i = i + 3)
{
DrawTriangle(rCenter + (mOctahedron.Vertices[mOctahedron.Triangles[i]] * 0.1f), rCenter + (mOctahedron.Vertices[mOctahedron.Triangles[i + 1]] * 0.1f), rCenter + (mOctahedron.Vertices[mOctahedron.Triangles[i + 2]] * 0.1f), rColor, rTransform);
}
}
public void OctahedronRaiseEventsProperly()
{
int count = 0;
var solid = new Octahedron()
{
Size = new SharpDX.Vector3(1.0f, 1.0f, 1.0f)
};
solid.PropertyChanged += (s, e) => count++;
solid.Size = new SharpDX.Vector3(2.0f, 0.0f, 0.0f);
Assert.AreEqual <int>(count, 1);
}
/// <summary>
/// add a volumetric atmosphere to a celestial body
/// </summary>
public void AddAtmosphere(CelestialBody celestialBody)
{
GameObject atmo = new GameObject("atmosphere");
atmo.AddComponent <MeshFilter>().mesh = Octahedron.Create(5, 1);
Material material = controller.materialController.GetMaterialForVolumetricAtmosphere(celestialBody);
material.SetColor("_Color1", controller.materialController.GetColor1ForAtmosphere(celestialBody));
material.SetColor("_Color2", controller.materialController.GetColor2ForAtmosphere(celestialBody));
atmo.transform.parent = celestialBody.gameObject.transform;
atmo.transform.localScale = Vector3.one * celestialBody.radius * celestialBody.atmosphereRadiusMultiplier;
atmo.transform.localPosition = Vector3.zero;
atmo.AddComponent <MeshRenderer>().material = material;
}
public static Mesh Create(Seed s)
{
var mesh = new Mesh();
switch (s)
{
case Seed.Dodecahedron:
break;
case Seed.Cube:
mesh = new Cube();
break;
case Seed.Icosahedron:
mesh = new Icosahedron();
break;
case Seed.Octahedron:
mesh = new Octahedron();
break;
case Seed.Tetrahedron:
mesh = new Tetrahedron();
break;
case Seed.SquareTiling:
mesh = new Square();
break;
case Seed.TriangleTiling:
break;
case Seed.HexagonalTiling:
break;
}
return(mesh);
}
// Use this for initialization
void Start()
{
rend = gameObject.GetComponent <Renderer>();
//mat = new Material(Shader.Find("Standard"));
//rend = new Renderer();
//rend.material = mat;
gMO = GameObject.Find("GameManager");
gM = gMO.GetComponent <GameManager>();
tetrahedron = gameObject.GetComponent <Tetrahedron>();
octahedron = gameObject.GetComponent <Octahedron>();
dodecahedron = gameObject.GetComponent <Dodecahedron>();
icosahedron = gameObject.GetComponent <Icosahedron>();
counter = (int)Random.Range(1f, 5f);
if (counter == 5)
{
counter = 4;
}
if (counter == 1)
{
tetrahedron.MakeMesh();
}
if (counter == 2)
{
octahedron.MakeMesh();
}
if (counter == 3)
{
dodecahedron.MakeMesh();
}
if (counter == 4)
{
icosahedron.MakeMesh();
}
gM.ZombiePlus();
}
public DynamicPlanet(SystemController controller, GameObject gameObject, int seed, CelestialType type, CelestialBody host = null) : base(controller, gameObject, seed, type, host)
{
this.seed = seed;
this.gameObject = gameObject;
position = gameObject.transform.position;
regions = new List <Region>();
terrain = new TerrainNoise(this, seed);
craters = new List <Crater>();
Vector3[] vertices = null;
int[] triangles = null;
Octahedron.GetVerticesAndTriangles(ref vertices, ref triangles);
for (int i = 0; i < triangles.Length; i += 3)
{
int t1 = triangles[i + 0];
int t2 = triangles[i + 1];
int t3 = triangles[i + 2];
Vector3 A = vertices[t1].normalized * radius;
Vector3 B = vertices[t2].normalized * radius;
Vector3 C = vertices[t3].normalized * radius;
regions.Add(new Region(this, null, A, B, C, 0));
}
}
public async void RenderSolids()
{
double alpha = 0;
try
{
while (renderFlag)
{
BasePlatonicSolid solid = null;
switch ((string)solidComboBox.SelectedItem)
{
case "Tetrahedron":
solid = new Tetrahedron(0, 0, 0, 100);
break;
case "Hexahedron":
solid = new Hexahedron(0, 0, 0, 100);
break;
case "Octahedron":
solid = new Octahedron(0, 0, 0, 100);
break;
case "Icosahedron":
solid = new Icosahedron(0, 0, 0, 100);
break;
case "Dodecahedron":
solid = new Dodecahedron(0, 0, 0, 100);
break;
default:
MessageBox.Show("something wrong");
return;
}
switch ((string)AxisRotationComboBox.SelectedItem)
{
case "OZ":
solid.RotateByZ(alpha);
break;
case "OY":
solid.RotateByY(alpha);
break;
case "OX":
solid.RotateByX(alpha);
break;
case "OXY":
solid.RotateByX(alpha);
solid.RotateByY(alpha);
break;
case "OZY":
solid.RotateByY(alpha);
solid.RotateByZ(alpha);
break;
case "OZX":
solid.RotateByX(alpha);
solid.RotateByZ(alpha);
break;
case "OXYZ":
solid.RotateByY(alpha);
solid.RotateByX(alpha);
solid.RotateByZ(alpha);
break;
case "None":
break;
default:
MessageBox.Show("something wrong");
return;
}
if (!checkBox1.Checked)
{
solid.Scale(double.Parse(scaleBoxFx.Text), double.Parse(scaleBoxFy.Text), double.Parse(scaleBoxFz.Text));
}
solid.Shift(int.Parse(shiftXBox.Text), int.Parse(shiftYBox.Text), int.Parse(shiftZBox.Text));
graphics.Clear(pictureBox1.BackColor);
solid.DrawSolid(graphics, double.Parse(coeffBox.Text), double.Parse(angelBox.Text));
alpha += Math.PI / 60;
await Task.Delay(100);
}
}
catch (Exception e)
{
MessageBox.Show("There were exception: " + e.Message);
}
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
int transFactor = 3;
int index = 0;
Mesh seed = new Mesh();
var rc = RhinoGet.GetInteger("Select seed value between 1 and 5", false, ref index, 1, 5);
if (rc != Result.Success)
{
return(rc);
}
switch (index)
{
case 1:
seed = new Octahedron();
break;
case 2:
seed = new Icosahedron();
break;
case 3:
seed = new Tetrahedron();
break;
case 4:
seed = new Cube();
break;
case 5:
RhinoApp.WriteLine($"{index} not implemented!");
return(Result.Failure);
}
doc.Objects.AddMesh(seed);
var dual = seed.Dual();
dual.Translate(new Vector3d(transFactor, 0, 0));
doc.Objects.AddMesh(dual);
var kis = seed.Kis();
kis.Translate(new Vector3d(transFactor * 2, 0, 0));
doc.Objects.AddMesh(kis);
var ambo = seed.Ambo();
ambo.Translate(new Vector3d(transFactor * 3, 0, 0));
doc.Objects.AddMesh(ambo);
var zip = seed.Zip();
zip.Translate(new Vector3d(transFactor * 0, transFactor * 1, 0));
doc.Objects.AddMesh(zip);
var join = seed.Join();
join.Translate(new Vector3d(transFactor * 1, transFactor * 1, 0));
doc.Objects.AddMesh(join);
var needle = seed.Needle();
needle.Translate(new Vector3d(transFactor * 2, transFactor * 1, 0));
doc.Objects.AddMesh(needle);
var truncate = seed.Truncate();
truncate.Translate(new Vector3d(transFactor * 3, transFactor * 1, 0));
doc.Objects.AddMesh(truncate);
var ortho = seed.Ortho();
ortho.Translate(new Vector3d(transFactor * 0, transFactor * 2, 0));
doc.Objects.AddMesh(ortho);
var expand = seed.Expand();
expand.Translate(new Vector3d(transFactor * 1, transFactor * 2, 0));
doc.Objects.AddMesh(expand);
var meta = seed.Meta();
meta.Translate(new Vector3d(transFactor * 2, transFactor * 2, 0));
doc.Objects.AddMesh(meta);
var bevel = seed.Bevel();
bevel.Translate(new Vector3d(transFactor * 3, transFactor * 2, 0));
doc.Objects.AddMesh(bevel);
doc.Views.Redraw();
return(Result.Success);
}
public GasPlanet(SystemController controller, GameObject gameObject, int seed, CelestialBody host = null) : base(controller, gameObject, seed, new CelestialType.GasPlanet(), host)
{
gameObject.AddComponent <MeshFilter>().mesh = Octahedron.Create(5, radius);
gameObject.AddComponent <MeshRenderer>().sharedMaterial = GetMaterial();
}
/// <summary>
/// Creates the mesh for a region
/// </summary>
public void CreateMesh()
{
Vector3[] vertices = new Vector3[] { A, B, C };
int[] triangles = new int[] { 0, 1, 2 };
Vector3[] normals = new Vector3[] { A, B, C };
//subdivide
for (int i = 0; i < detailLevel; i++)
{
int len = vertices.Length * 4;
Vector3[] newVertices = new Vector3[len];
int[] newTriangles = new int[len];
int index = 0;
for (int j = 0; j < triangles.Length; j += 3)
{
int t1 = triangles[j];
int t2 = triangles[j + 1];
int t3 = triangles[j + 2];
Vector3 a = vertices[t1];
Vector3 b = vertices[t2];
Vector3 c = vertices[t3];
Vector3 ab = ((a + b) / 2);
Vector3 bc = ((b + c) / 2);
Vector3 ca = ((c + a) / 2);
CreateTriangle(newVertices, newTriangles, index, a, ab, ca);
index += 3;
CreateTriangle(newVertices, newTriangles, index, ab, b, bc);
index += 3;
CreateTriangle(newVertices, newTriangles, index, bc, c, ca);
index += 3;
CreateTriangle(newVertices, newTriangles, index, ab, bc, ca);
index += 3;
}
triangles = newTriangles;
vertices = newVertices;
}
normals = new Vector3[vertices.Length];
Dictionary <Vector3, VertexData> vertexFaces = new Dictionary <Vector3, VertexData>(new Vector3EqualityComparer());
List <int> borderVertices = new List <int>();
//create bounds to the region to avoid seams between chunks
AddBoundsAndNormals(ref vertices, ref triangles, ref normals, borderVertices);
Vector2[] uv = new Vector2[vertices.Length];
Color[] colors = new Color[vertices.Length];
Vector3[] unitVertices = new Vector3[vertices.Length];
Vector3[] unitNormals = new Vector3[vertices.Length];
for (int i = 0; i < triangles.Length; i += 3)
{
int t1 = triangles[i];
int t2 = triangles[i + 1];
int t3 = triangles[i + 2];
Face face = new Face
{
iA = t1,
iB = t2,
iC = t3
};
Vector3 a = vertices[t1].normalized;
Vector3 b = vertices[t2].normalized;
Vector3 c = vertices[t3].normalized;
//unitVertices/unitNormals are the mesh data for the water surface mesh
unitVertices[t1] = a * planet.waterLevel * planet.radius;
unitVertices[t2] = b * planet.waterLevel * planet.radius;
unitVertices[t3] = c * planet.waterLevel * planet.radius;
unitNormals[t1] = a;
unitNormals[t2] = b;
unitNormals[t3] = c;
//set neighbouring faces for all vertices
AddFace(vertexFaces, a, t1, face);
AddFace(vertexFaces, b, t2, face);
AddFace(vertexFaces, c, t3, face);
//modified vertices which contain height manipulation via terrain noise
Vector3 a_mod = a * planet.radius * planet.terrain.GetNoise(a, LOD);
Vector3 b_mod = b * planet.radius * planet.terrain.GetNoise(b, LOD);
Vector3 c_mod = c * planet.radius * planet.terrain.GetNoise(c, LOD);
vertices[t1] = a_mod;
vertices[t2] = b_mod;
vertices[t3] = c_mod;
//get the uv coordinates for the vertices
var uv_a = Octahedron.RadialCoords(a);
var uv_b = Octahedron.RadialCoords(b);
var uv_c = Octahedron.RadialCoords(c);
//get the colors for the vertices; these just contain noise values, which are used in the shader
colors[t1] = planet.terrain.GetColor(a);
colors[t2] = planet.terrain.GetColor(b);
colors[t3] = planet.terrain.GetColor(c);
//fix texture seams around the beginning of the uv texture
FixUvs(ref uv_a, ref uv_b, ref uv_c);
uv[t1] = uv_a;
uv[t2] = uv_b;
uv[t3] = uv_c;
}
//calculate normals for all vertices, by calculating the direction of all neighbouring faces
foreach (var P in vertexFaces.Keys)
{
VertexData vd = vertexFaces[P];
Vector3 sum = Vector3.zero;
//add all neighbours together
foreach (var f in vd.faces)
{
Vector3 a = vertices[f.iA];
Vector3 b = vertices[f.iB];
Vector3 c = vertices[f.iC];
sum += Vector3.Cross(b - a, c - a);
}
foreach (var i in vd.indexes)
{
normals[i] = sum.normalized;
}
}
//lower the overlapping bounds of a region by a bit to make terrain smoother
foreach (var index in borderVertices)
{
vertices[index] *= 0.995f;
unitVertices[index] *= 0.995f;
}
//save meshdata
meshData = new MeshData()
{
vertices = vertices,
normals = normals,
triangles = triangles,
uv = uv,
colors = colors,
unitVertices = unitVertices,
unitNormals = unitNormals
};
}
