private void ReadTriangle(string[] items, Group group)
{
var ns = items.Skip(1).Select(int.Parse).ToArray();
var n1 = ns[0];
for (int i = 0; i < ns.Length - 2; i++)
{
var n2 = ns[i + 1];
var n3 = ns[i + 2];
var p1 = Vertices[n1 - 1];
var p2 = Vertices[n2 - 1];
var p3 = Vertices[n3 - 1];
var triangle = new Triangle(p1, p2, p3);
Triangles.Add(triangle);
group.Add(triangle);
}
}
public void SetTriangle(TriangleData triangle)
{
Triangles.Add(triangle.T0);
Triangles.Add(triangle.T1);
Triangles.Add(triangle.T2);
Vertices.Add(triangle.V0);
Vertices.Add(triangle.V1);
Vertices.Add(triangle.V2);
Normals.Add(triangle.N0);
Normals.Add(triangle.N1);
Normals.Add(triangle.N2);
Uvs.Add(triangle.Uv0);
Uvs.Add(triangle.Uv1);
Uvs.Add(triangle.Uv2);
}
public override void Add(Vector3 scale, Vector3 origin, Quaternion rotation)
{
int verticesLength = Vertices.Count;
for (int i = 0; i < QuadVertices.Length; i++)
{
Vertices.Add(TransformVert(QuadVertices[i], scale, origin, rotation));
}
for (int i = 0; i < QuadUV.Length; i++)
{
Uv.Add(QuadUV[i]);
}
for (int i = 0; i < QuadTriangles.Length; i++)
{
Triangles.Add(verticesLength + QuadTriangles[i]);
}
}
private void AddTriangles(params Node[] nodes)
{
foreach (Node node in nodes)
{
if (!node.VertexId.HasValue)
{
node.VertexId = Vertices.Count;
Vertices.Add(node);
}
}
for (int i = 2; i < nodes.Length; i++)
{
Triangles.Add(nodes[0]);
Triangles.Add(nodes[i - 1]);
Triangles.Add(nodes[i]);
}
}
/// <summary>
/// Adds a triangle to the geometry
/// List the three vertices in clockwise order as seen from the outside
/// The indices must exist in the geometry, i.e. they first need to be added using AddVertex()
/// </summary>
/// <param name="v0">Index of vertex 1</param>
/// <param name="v1">Index of vertex 2</param>
/// <param name="v2">Index of vertex 3</param>
/// <param name="flipNormal">If set to true, the triangle will face the other way</param>
public void AddTriangle(int v0, int v1, int v2, bool flipNormal = false)
{
if (CheckVertexIndex(v0) && CheckVertexIndex(v1) && CheckVertexIndex(v2))
{
if (flipNormal)
{
Triangles.Add(v0);
Triangles.Add(v2);
Triangles.Add(v1);
}
else
{
Triangles.Add(v0);
Triangles.Add(v1);
Triangles.Add(v2);
}
}
}
private Triangle3D InternalAddTriangle(Triangle3D triangle)
{
if (triangle.IsDegenerated())
{
triangle.Edges[0].DisconnectTriangle(triangle);
triangle.Edges[1].DisconnectTriangle(triangle);
triangle.Edges[2].DisconnectTriangle(triangle);
triangle.Vertices[0].DisconnectTriangle(triangle);
triangle.Vertices[1].DisconnectTriangle(triangle);
triangle.Vertices[2].DisconnectTriangle(triangle);
}
else
{
Triangles.Add(triangle);
}
return(triangle);
}
///<summary>
/// Add quad
///</summary>
void AddQuad(Vector2 p0, Vector2 p1, Vector2 p2, Vector2 p3, Color32 color1, Color32 color2)
{
float z = mode_3d ? -size.z / 2 : 0.0f;
Vertices.Add(new Vector3(p0.x * size.x, p0.y * size.y, z));
Vertices.Add(new Vector3(p1.x * size.x, p1.y * size.y, z));
Vertices.Add(new Vector3(p2.x * size.x, p2.y * size.y, z));
Vertices.Add(new Vector3(p3.x * size.x, p3.y * size.y, z));
VertexColors.Add(color1);
VertexColors.Add(color2);
VertexColors.Add(color2);
VertexColors.Add(color1);
Triangles.Add(Vertices.Count - 4);
Triangles.Add(Vertices.Count - 3);
Triangles.Add(Vertices.Count - 2);
Triangles.Add(Vertices.Count - 4);
Triangles.Add(Vertices.Count - 2);
Triangles.Add(Vertices.Count - 1);
}
public void AddTriangleToMesh(Vector3[] triangleVertices, Vector3[] normals, Vector2[] uvs)
{
for (int i = 0; i < 3; i++)
{
Vector3 vertex = triangleVertices[i];
/*this.Vertices.Add (vertex);
* this.Normals.Add (normals [i]);
* this.UVs.Add (uvs [i]);
* this.Triangles.Add(this.Vertices.Count - 1);*/
if (!Vertices.Contains(vertex))
{
Vertices.Add(vertex);
Normals.Add(normals[i]);
UVs.Add(uvs[i]);
Triangles.Add(Vertices.Count - 1);
}
else
{
int[] indicesForVertex = IndexOfAllOccurences(Vertices, vertex);
bool itAlreadyExisted = false;
foreach (int vertexIndex in indicesForVertex)
{
if (Normals[vertexIndex] == normals[i] && UVs[vertexIndex] == uvs[i])
{
Triangles.Add(vertexIndex);
itAlreadyExisted = true;
break;
}
}
if (!itAlreadyExisted)
{
Vertices.Add(vertex);
Normals.Add(normals[i]);
UVs.Add(uvs[i]);
Triangles.Add(Vertices.Count - 1);
}
}
}
}
///<summary>
/// Add a quad
///</summary>
void AddQuad(Vector3 a, Vector3 b, Vector3 c, Vector3 d, Color32 color1, Color32 color2)
{
Vertices.Add(a);
Vertices.Add(b);
Vertices.Add(c);
Vertices.Add(d);
VertexColors.Add(color1);
VertexColors.Add(color1);
VertexColors.Add(color2);
VertexColors.Add(color2);
Triangles.Add(Vertices.Count - 4);
Triangles.Add(Vertices.Count - 3);
Triangles.Add(Vertices.Count - 2);
Triangles.Add(Vertices.Count - 3);
Triangles.Add(Vertices.Count - 1);
Triangles.Add(Vertices.Count - 2);
}
///<summary>
/// Add quad
///</summary>
void AddQuad(Vector2 p0, Vector2 p1, Vector2 p2, Vector2 p3, Color32 color1, Color32 color2)
{
Vertices.Add(new Vector3(p0.x * rectTransform.rect.width, p0.y * rectTransform.rect.height, 0));
Vertices.Add(new Vector3(p1.x * rectTransform.rect.width, p1.y * rectTransform.rect.height, 0));
Vertices.Add(new Vector3(p2.x * rectTransform.rect.width, p2.y * rectTransform.rect.height, 0));
Vertices.Add(new Vector3(p3.x * rectTransform.rect.width, p3.y * rectTransform.rect.height, 0));
VertexColors.Add(color1);
VertexColors.Add(color2);
VertexColors.Add(color2);
VertexColors.Add(color1);
Triangles.Add(Vertices.Count - 4);
Triangles.Add(Vertices.Count - 3);
Triangles.Add(Vertices.Count - 2);
Triangles.Add(Vertices.Count - 2);
Triangles.Add(Vertices.Count - 1);
Triangles.Add(Vertices.Count - 4);
}
public void CreateAdvancingFront()
{
AdvancingFrontNode head, tail, middle;
DelaunayTriangle iTriangle = new DelaunayTriangle(Points[0], Tail, Head);
Triangles.Add(iTriangle);
head = new AdvancingFrontNode(iTriangle.Points[1]);
head.Triangle = iTriangle;
middle = new AdvancingFrontNode(iTriangle.Points[0]);
middle.Triangle = iTriangle;
tail = new AdvancingFrontNode(iTriangle.Points[2]);
Front = new AdvancingFront(head, tail);
Front.AddNode(middle);
Front.Head.Next = middle;
middle.Next = Front.Tail;
middle.Prev = Front.Head;
Front.Tail.Prev = middle;
}
public void AddQuadTriangles()
{
Triangles.Add(Vertices.Count - 4);
Triangles.Add(Vertices.Count - 3);
Triangles.Add(Vertices.Count - 2);
Triangles.Add(Vertices.Count - 4);
Triangles.Add(Vertices.Count - 2);
Triangles.Add(Vertices.Count - 1);
if (UseRenderDataForCollider)
{
ColliderTriangles.Add(ColliderVertices.Count - 4);
ColliderTriangles.Add(ColliderVertices.Count - 3);
ColliderTriangles.Add(ColliderVertices.Count - 2);
ColliderTriangles.Add(ColliderVertices.Count - 4);
ColliderTriangles.Add(ColliderVertices.Count - 2);
ColliderTriangles.Add(ColliderVertices.Count - 1);
}
}
/// <summary>indices是组成改三角形的顶点数组索引</summary>
public void AddTriangle(int[] indices)
{
for (int i = 0; i < Triangles.Count / 3; i++)
{
if (Triangles[i * 3] == indices[0] && Triangles[i * 3 + 1] == indices[1] && Triangles[i * 3 + 2] == indices[2])//三角形已经添加过
{
return;
}
}
//正反面都要添加
Triangles.Add(indices[0]);
Triangles.Add(indices[1]);
Triangles.Add(indices[2]);
Triangles.Add(indices[1]);
Triangles.Add(indices[0]);
Triangles.Add(indices[2]);
UpdateMesh();
}
private void CalculateIndices(int p1, int p2, int p3, int vv)
{
Triangle triangle = new Triangle(Measurements[p1], Measurements[p2], Measurements[p3]);
Triangles.Add(triangle);
Vector3 v = Measurements[vv];
float dotp = Vector3.Dot(triangle.Normal, v - Measurements[p1]);
Indices.Add(p1);
if (dotp < 0)
{
Indices.Add(p2);
Indices.Add(p3);
}
else
{
Indices.Add(p3);
Indices.Add(p2);
}
}
///<summary>
/// Add quad
///</summary>
void AddQuad(Vector2 p0, Vector2 p1, Vector2 p2, Vector2 p3, Color32 color)
{
Vertices.Add(p0);
VertexColors.Add(color);
Vertices.Add(p1);
VertexColors.Add(color);
Vertices.Add(p2);
VertexColors.Add(color);
Vertices.Add(p3);
VertexColors.Add(color);
Triangles.Add(Vertices.Count - 4);
Triangles.Add(Vertices.Count - 3);
Triangles.Add(Vertices.Count - 2);
Triangles.Add(Vertices.Count - 2);
Triangles.Add(Vertices.Count - 1);
Triangles.Add(Vertices.Count - 4);
}
public void CreateAdvancingFront()
{
AdvancingFrontNode head, tail, middle;
// Initial triangle
DelaunayTriangle dtri = new DelaunayTriangle(Points[0], Tail, Head);
Triangles.Add(dtri);
head = new AdvancingFrontNode(dtri.P1);
head.Triangle = dtri;
middle = new AdvancingFrontNode(dtri.P0);
middle.Triangle = dtri;
tail = new AdvancingFrontNode(dtri.P2);
Front = new AdvancingFront(head, tail);
//Front.AddNode(middle);
// TODO: I think it would be more intuitive if head is middles next and not previous
//so swap head and tail
Front.Head.Next = middle;
middle.Next = Front.Tail;
middle.Prev = Front.Head;
Front.Tail.Prev = middle;
}
public override void SetTriangles()
{
for (int i = 0; i < Vertices.Count; i += 6)
{
Triangles.Add(i);
Triangles.Add(i + 1);
Triangles.Add(i + 2);
Triangles.Add(i + 2);
Triangles.Add(i + 3);
Triangles.Add(i);
Triangles.Add(i + 4);
Triangles.Add(i + 3);
Triangles.Add(i + 2);
Triangles.Add(i + 2);
Triangles.Add(i + 5);
Triangles.Add(i + 4);
}
GeneralFunctions.CreateObject(Vertices, Triangles);
}
//assumes a 2.5 D point cloud (i.e. for a given x,y there is only ONE z value
public void Triangulate25D(float distMin)
{
float meanDistance, standardDeviation;
float[] distances;
//1. get standard deviation, meanDistance and array of distances
Outliers.StandardDeviation(this, 10, out meanDistance, out standardDeviation, out distances);
distMin = meanDistance * 100;
this.Triangles = new List <Triangle>();
List <List <VertexKDTree> > listNew = SortVectorsWithIndex();
for (int i = listNew.Count - 1; i > 0; i--)
{
List <VertexKDTree> columnx = listNew[i];
List <VertexKDTree> columny = listNew[i - 1];
for (int j = 1; j < columnx.Count; j++)
{
VertexKDTree vx = columnx[j];
float dist_x = columnx[j - 1].Vector.Distance(vx.Vector);
if (dist_x < distMin)
{
foreach (VertexKDTree vy in columny)
{
float dist_xy = vx.Vector.Distance(vy.Vector);
if (dist_xy < distMin)
{
Triangles.Add(new Triangle(columnx[j - 1].Index, vx.Index, vy.Index));
}
}
}
}
}
CreateIndicesFromTriangles();
}
/// <summary>
/// 重新读取数据
/// </summary>
public void ReadData()
{
//重新读取顶点
_mesh.vertices.CopyTo(_vertices, 0);
for (int i = 0; i < _vertices.Length; i++)
{
Signer[i].Position = _vertices[i];
}
//重新读取三角面（如果三角面数量改变）
if ((Triangles.Count * 3) != _originalTriangles.Length)
{
//重新生成三角面数据
ClearTriangles();
for (int i = 0; (i + 2) < _originalTriangles.Length; i += 3)
{
Vertex vertex1 = Signer[_originalTriangles[i]];
Vertex vertex2 = Signer[_originalTriangles[i + 1]];
Vertex vertex3 = Signer[_originalTriangles[i + 2]];
Triangle triangle = new Triangle(vertex1, vertex2, vertex3, _originalTriangles[i], _originalTriangles[i + 1], _originalTriangles[i + 2]);
Triangles.Add(triangle);
}
}
}
public void CreateAdvancingFront()
{
AdvancingFrontNode head, tail, middle;
// Initial triangle
DelaunayTriangle iTriangle = new DelaunayTriangle(Points[0], Tail, Head);
Triangles.Add(iTriangle);
head = new AdvancingFrontNode(iTriangle.Points[1]);
head.Triangle = iTriangle;
middle = new AdvancingFrontNode(iTriangle.Points[0]);
middle.Triangle = iTriangle;
tail = new AdvancingFrontNode(iTriangle.Points[2]);
aFront = new AdvancingFront(head, tail);
aFront.AddNode(middle);
// FARSEER_TODO: I think it would be more intuitive if head is middles next and not previous
// so swap head and tail
aFront.Head.Next = middle;
middle.Next = aFront.Tail;
middle.Prev = aFront.Head;
aFront.Tail.Prev = middle;
}
public void AddTriangle(DelaunayTriangle t)
{
Triangles.Add(t);
}
public Cube(float size)
{
float sizeHalf = size / 2f;
// BACK
Triangles.Add(new Triangle(
new Vector3f(-sizeHalf, -sizeHalf, -sizeHalf),
new Vector3f(-sizeHalf, sizeHalf, -sizeHalf),
new Vector3f(sizeHalf, sizeHalf, -sizeHalf)));
Triangles.Add(new Triangle(
new Vector3f(-sizeHalf, -sizeHalf, -sizeHalf),
new Vector3f(sizeHalf, sizeHalf, -sizeHalf),
new Vector3f(sizeHalf, -sizeHalf, -sizeHalf)));
// LEFT
Triangles.Add(new Triangle(
new Vector3f(sizeHalf, -sizeHalf, -sizeHalf),
new Vector3f(sizeHalf, sizeHalf, -sizeHalf),
new Vector3f(sizeHalf, sizeHalf, sizeHalf)));
Triangles.Add(new Triangle(
new Vector3f(sizeHalf, -sizeHalf, -sizeHalf),
new Vector3f(sizeHalf, sizeHalf, sizeHalf),
new Vector3f(sizeHalf, -sizeHalf, sizeHalf)));
// FRONT
Triangles.Add(new Triangle(
new Vector3f(sizeHalf, -sizeHalf, sizeHalf),
new Vector3f(sizeHalf, sizeHalf, sizeHalf),
new Vector3f(-sizeHalf, sizeHalf, sizeHalf)));
Triangles.Add(new Triangle(
new Vector3f(sizeHalf, -sizeHalf, sizeHalf),
new Vector3f(-sizeHalf, sizeHalf, sizeHalf),
new Vector3f(-sizeHalf, -sizeHalf, sizeHalf)));
// RIGHT
Triangles.Add(new Triangle(
new Vector3f(-sizeHalf, -sizeHalf, sizeHalf),
new Vector3f(-sizeHalf, sizeHalf, sizeHalf),
new Vector3f(-sizeHalf, sizeHalf, -sizeHalf)));
Triangles.Add(new Triangle(
new Vector3f(-sizeHalf, -sizeHalf, sizeHalf),
new Vector3f(-sizeHalf, sizeHalf, -sizeHalf),
new Vector3f(-sizeHalf, -sizeHalf, -sizeHalf)));
// TOP
Triangles.Add(new Triangle(
new Vector3f(-sizeHalf, sizeHalf, -sizeHalf),
new Vector3f(-sizeHalf, sizeHalf, sizeHalf),
new Vector3f(sizeHalf, sizeHalf, sizeHalf)));
Triangles.Add(new Triangle(
new Vector3f(-sizeHalf, sizeHalf, -sizeHalf),
new Vector3f(sizeHalf, sizeHalf, sizeHalf),
new Vector3f(sizeHalf, sizeHalf, -sizeHalf)));
// BOTTOM
Triangles.Add(new Triangle(
new Vector3f(sizeHalf, -sizeHalf, sizeHalf),
new Vector3f(-sizeHalf, -sizeHalf, sizeHalf),
new Vector3f(-sizeHalf, -sizeHalf, -sizeHalf)));
Triangles.Add(new Triangle(
new Vector3f(sizeHalf, -sizeHalf, sizeHalf),
new Vector3f(-sizeHalf, -sizeHalf, -sizeHalf),
new Vector3f(sizeHalf, -sizeHalf, -sizeHalf)));
}
public void AddTriangle(Triangle triangle)
{
Triangles.Add(triangle);
}
public MeshCube()
{
Vector3d a = new Vector3d(0, 0, 0);
Vector3d b = new Vector3d(1, 0, 0);
Vector3d c = new Vector3d(1, 1, 0);
Vector3d d = new Vector3d(0, 1, 0);
Vector3d n = new Vector3d(0, 0, 1);
Vector3d m = new Vector3d(1, 0, 1);
Vector3d k = new Vector3d(0, 1, 1);
Vector3d l = new Vector3d(1, 1, 1);
Vector2d[] uv1 = new Vector2d[] { new Vector2d(0, 1), new Vector2d(0, 0), new Vector2d(1, 0) };
Vector2d[] uv2 = new Vector2d[] { new Vector2d(0, 1), new Vector2d(1, 0), new Vector2d(1, 1) };
Triangle bad = new Triangle(b, a, d);
Triangle cbd = new Triangle(c, b, d);
bad.uv = uv1;
cbd.uv = uv2;
Triangle lcd = new Triangle(l, c, d);
Triangle kld = new Triangle(k, l, d);
lcd.uv = uv1;
kld.uv = uv2;
Triangle and = new Triangle(a, n, d);
Triangle nkd = new Triangle(n, k, d);
and.uv = uv1;
nkd.uv = uv2;
Triangle abm = new Triangle(a, b, m);
Triangle nam = new Triangle(n, a, m);
abm.uv = uv1;
nam.uv = uv2;
Triangle bcm = new Triangle(b, c, m);
Triangle clm = new Triangle(c, l, m);
bcm.uv = uv1;
clm.uv = uv2;
Triangle knm = new Triangle(k, n, m);
Triangle lkm = new Triangle(l, k, m);
knm.uv = uv1;
lkm.uv = uv2;
Triangles.Add(bad);
Triangles.Add(cbd);
Triangles.Add(lcd);
Triangles.Add(kld);
Triangles.Add(and);
Triangles.Add(nkd);
Triangles.Add(abm);
Triangles.Add(nam);
Triangles.Add(bcm);
Triangles.Add(clm);
Triangles.Add(knm);
Triangles.Add(lkm);
foreach (var triangle in Triangles)
{
for (int i = 0; i < triangle.p.Length; i++)
{
triangle.uv[i].u = triangle.p[i].x;
triangle.uv[i].v = triangle.p[i].y;
}
}
}
private void AddTriangle(int a, int b, int c)
{
Triangles.Add(a);
Triangles.Add(b);
Triangles.Add(c);
}
public override void UpdateTriangles(Vector3 p1, Vector3 p2, Vector3 p3)
{
Triangles.Add(p1);
Triangles.Add(p2);
Triangles.Add(p3);
}
public override void AddTriangle(DelaunayTriangle t)
{
Triangles.Add(t);
}
/// <summary>
/// 新增三角面
/// </summary>
/// <param name="triangle">三角面</param>
public void AddTriangle(Triangle triangle)
{
triangle.LinkVertex();
Triangles.Add(triangle);
}
private void ReadObjFile(string pathObjFile)
{
using (var myStream = new FileStream(pathObjFile, FileMode.Open))
{
var myReader = new StreamReader(myStream);
var coord = new double[3];
var tri = new int[3];
var tex = new int[4];
var quad = new int[4];
string line;
while ((line = myReader.ReadLine()) != null)
{
if (line != "")
{
line = line.Trim(' ');
string[] array;
switch (line[0])
{
case 'v':
{
if (line[1] != 't' && line[1] != 'n')
{
line = line.Trim('v', ' ');
array = line.Split(' ');
for (var i = 0; i < 3; i++)
{
coord[i] = double.Parse(array[i], CultureInfo.InvariantCulture);
}
var v = new Vertex(coord[0], coord[1], coord[2]);
Vertices.Add(v);
}
else
{
if (line[1] == 't')
{
line = line.Trim('t', 'v', ' ');
array = line.Split(' ');
for (var i = 0; i < 2; i++)
{
coord[i] = double.Parse(array[i], CultureInfo.InvariantCulture);
}
var v = new Vertex2D(coord[0], coord[1]);
TextureCoordinates.Add(v);
}
}
break;
}
case 'f':
{
line = line.Trim('f', ' ');
array = line.Split(new[] { ' ', '/' },
StringSplitOptions.RemoveEmptyEntries);
if (array.Length == 9)
{
for (int i = 0, j = 0; i < 3 && j < array.Length; i++, j += 3)
{
tri[i] = int.Parse(array[j]);
tex[i] = int.Parse(array[j + 1]);
}
var t = new Triangle(Vertices[tri[0] - 1], Vertices[tri[1] - 1],
Vertices[tri[2] - 1], TextureCoordinates[tex[0] - 1],
TextureCoordinates[tex[1] - 1], TextureCoordinates[tex[2] - 1]);
Triangles.Add(t);
}
if (array.Length == 12)
{
for (int i = 0, j = 0; i < 4 && j < array.Length; i++, j += 3)
{
quad[i] = int.Parse(array[j]);
tex[i] = int.Parse(array[j + 1]);
}
var q = new Quad(Vertices[quad[0] - 1], Vertices[quad[1] - 1],
Vertices[quad[2] - 1],
Vertices[quad[3] - 1], TextureCoordinates[tex[0] - 1],
TextureCoordinates[tex[1] - 1], TextureCoordinates[tex[2] - 1],
TextureCoordinates[tex[3] - 1]);
Quads.Add(q);
}
}
break;
}
}
}
}
}
public void ReadFile(string path)
{
var transformStack = new Stack <Matrix4x4>();
transformStack.Push(Matrix4x4.Identity);
var contents = File.ReadLines(path);
var vertCount = 0;
foreach (var line in contents)
{
string[] splitLine;
ObjectProperties objProps;
Vector4 lightPos;
Vector3 lightCol;
if (line.StartsWith("#") || line == string.Empty)
{
continue;
}
else
{
splitLine = line.Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
}
var cmd = splitLine[0];
switch (cmd)
{
case "size":
ImageWidth = int.Parse(splitLine[1]);
ImageHeight = int.Parse(splitLine[2]);
SetAspectRatio();
break;
case "maxdepth":
RecursionMaxDepth = int.Parse(splitLine[1]);
break;
case "maxverts":
Vertices = new Vector3[int.Parse(splitLine[1])];
break;
case "vertex":
GetFloatCmdValues(splitLine);
Vertices[vertCount++] = Get3dVectorFromFirstValues();
break;
case "tri":
GetFloatCmdValues(splitLine);
var vert1 = Vertices[(int)CmdValues[0]];
var vert2 = Vertices[(int)CmdValues[1]];
var vert3 = Vertices[(int)CmdValues[2]];
objProps = CreateObjectProperties();
Triangles.Add(new Triangle(vert1, vert2, vert3, objProps, transformStack.Peek()));
break;
case "sphere":
GetFloatCmdValues(splitLine);
objProps = CreateObjectProperties();
var spherePos = new Vector3(CmdValues[0], CmdValues[1], CmdValues[2]);
Spheres.Add(new Sphere(spherePos, CmdValues[3], objProps, transformStack.Peek()));
break;
case "output":
OutputFilename = splitLine[1];
break;
case "camera":
GetFloatCmdValues(splitLine);
EyeInit = new Vector3(CmdValues[0], CmdValues[1], CmdValues[2]);
LookAtPoint = new Vector3(CmdValues[3], CmdValues[4], CmdValues[5]);
UpInit = new Vector3(CmdValues[6], CmdValues[7], CmdValues[8]);
FovYRad = Transform.ToRadians(CmdValues[9]);
SetFovX();
ModelView = SetLookAtMatrix();
break;
case "attenuation":
GetFloatCmdValues(splitLine);
Attenuation = new[] { CmdValues[0], CmdValues[1], CmdValues[2] };
break;
case "ambient":
GetFloatCmdValues(splitLine);
Ambient = Get3dVectorFromFirstValues();
break;
case "diffuse":
GetFloatCmdValues(splitLine);
Diffuse = Get3dVectorFromFirstValues();
break;
case "specular":
GetFloatCmdValues(splitLine);
Specular = Get3dVectorFromFirstValues();
break;
case "emission":
GetFloatCmdValues(splitLine);
Emission = Get3dVectorFromFirstValues();
break;
case "shininess":
Shininess = float.Parse(splitLine[1]);
break;
case "directional":
GetFloatCmdValues(splitLine);
lightPos = new Vector4(CmdValues[0], CmdValues[1], CmdValues[2], 0);
lightCol = new Vector3(CmdValues[3], CmdValues[4], CmdValues[5]);
Lights.Add(new Light(lightPos, lightCol, new float[] { 1, 0, 0 }));
break;
case "point":
GetFloatCmdValues(splitLine);
lightPos = new Vector4(CmdValues[0], CmdValues[1], CmdValues[2], 1);
lightCol = new Vector3(CmdValues[3], CmdValues[4], CmdValues[5]);
Lights.Add(new Light(lightPos, lightCol, Attenuation));
break;
case "translate":
GetFloatCmdValues(splitLine);
var translateMat = GetTranslationMatrix(Get3dVectorFromFirstValues());
RightMultiplyTopStack(translateMat, transformStack);
break;
case "rotate":
GetFloatCmdValues(splitLine);
var angle = CmdValues[3];
var rotMat = GetRotationMatrix(Get3dVectorFromFirstValues(), angle);
RightMultiplyTopStack(rotMat, transformStack);
break;
case "scale":
GetFloatCmdValues(splitLine);
var scaleMat = GetScaleMatrix(Get3dVectorFromFirstValues());
RightMultiplyTopStack(scaleMat, transformStack);
break;
case "pushTransform":
transformStack.Push(transformStack.Peek());
break;
case "popTransform":
transformStack.Pop();
break;
default:
if (cmd == "maxvertnorms" ||
cmd == "vertexnormal" || cmd == "trinormal")
{
break;
}
throw new InvalidEnumArgumentException($"There is no such command as {cmd}");
}
}
}
