public void Test_Should_Add_Vertices_To_List() { // Set List <Vector3> vertices = new List <Vector3>(); Vector3[] triangleVertices = new Vector3[] { vertex1, vertex2, vertex3 }; Color[] triangleColors = new Color[] { color1, color2, color3 }; int vertexIndex = 3; RenderTriangle renderTriangle = new RenderTriangle(vertexIndex, triangleVertices, triangleColors); // Act List <Vector3> verticesResult = renderTriangle.AddVertices(vertices); Assert.That( new Vector3(0f, 0f, 0f), Is.EqualTo(verticesResult.ToArray()[0]) ); Assert.That( new Vector3(0f, 0f, 2f), Is.EqualTo(verticesResult.ToArray()[1]) ); Assert.That( new Vector3(2f, 0f, 0f), Is.EqualTo(verticesResult.ToArray()[2]) ); }
void Start() { triangulationManager = FindObjectOfType <TriangulationManager>(); renderTriangle = FindObjectOfType <RenderTriangle>(); colorTecniqueDD.onValueChanged.AddListener(delegate { OnColorTecnique(colorTecniqueDD.value); }); triangulationAlgDD.onValueChanged.AddListener(delegate { OnTriangulationAlg(triangulationAlgDD.value); }); amountSL.onValueChanged.AddListener(delegate { OnChangeAmount(amountSL.value); }); redSL.onValueChanged.AddListener(delegate { OnChangeColor(redSL.value, greenSL.value, blueSL.value, alphaSL.value); }); greenSL.onValueChanged.AddListener(delegate { OnChangeColor(redSL.value, greenSL.value, blueSL.value, alphaSL.value); }); blueSL.onValueChanged.AddListener(delegate { OnChangeColor(redSL.value, greenSL.value, blueSL.value, alphaSL.value); }); alphaSL.onValueChanged.AddListener(delegate { OnChangeColor(redSL.value, greenSL.value, blueSL.value, alphaSL.value); }); BGredSL.onValueChanged.AddListener(delegate { OnChangeBackgroundColor(BGredSL.value, BGgreenSL.value, BGblueSL.value); }); BGgreenSL.onValueChanged.AddListener(delegate { OnChangeBackgroundColor(BGredSL.value, BGgreenSL.value, BGblueSL.value); }); BGblueSL.onValueChanged.AddListener(delegate { OnChangeBackgroundColor(BGredSL.value, BGgreenSL.value, BGblueSL.value); }); calculateAlphaT.onValueChanged.AddListener(delegate { OnChangeCalculatedAlpha(calculateAlphaT.isOn); }); invertColorsT.onValueChanged.AddListener(delegate { OnChangeInvertColors(invertColorsT.isOn); }); }
public void Test_Should_Add_Colors_To_List() { // Set List <Color> colors = new List <Color>(); Vector3[] triangleVertices = new Vector3[] { vertex1, vertex2, vertex3 }; Color[] triangleColors = new Color[] { color1, color2, color3 }; int vertexIndex = 1; RenderTriangle renderTriangle = new RenderTriangle(vertexIndex, triangleVertices, triangleColors); // Act List <Color> colorsResult = renderTriangle.AddColors(colors); // Assert Assert.That(Color.black, Is.EqualTo(colorsResult[0])); Assert.That(Color.black, Is.EqualTo(colorsResult[1])); Assert.That(Color.black, Is.EqualTo(colorsResult[2])); }
public void Test_Should_Add_Triangles_To_List() { // Set List <int> triangles = new List <int>(); Vector3[] triangleVertices = new Vector3[] { vertex1, vertex2, vertex3 }; Color[] triangleColors = new Color[] { color1, color2, color3 }; int vertexIndex = 1; RenderTriangle renderTriangle = new RenderTriangle(vertexIndex, triangleVertices, triangleColors); // Act List <int> trianglesResult = renderTriangle.AddTriangles(triangles); // Assert Assert.That(1, Is.EqualTo(trianglesResult[0])); Assert.That(2, Is.EqualTo(trianglesResult[1])); Assert.That(3, Is.EqualTo(trianglesResult[2])); }
public Blocks.RenderTriangle[] ToRenderTriangles() { RenderTriangle[] res = new RenderTriangle[vertices.Length / 3]; for (int i = 0; i < res.Length; i++) { //Debug.Log(vertices[i * 3].x + " " + vertices[i * 3].y + " " + vertices[i * 3].z); //Debug.Log(vertices[i * 3+1].x + " " + vertices[i * 3+1].y + " " + vertices[i * 3+1].z); //Debug.Log(vertices[i * 3+2].x + " " + vertices[i * 3+2].y + " " + vertices[i * 3+2].z); int pos = i * 3; RenderTriangle cur = new RenderTriangle(); cur.vertex1 = Util.MakeFloat4(vertices[pos].x, vertices[pos].y, vertices[pos].z, 0); cur.vertex2 = Util.MakeFloat4(vertices[pos + 1].x, vertices[pos + 1].y, vertices[pos + 1].z, 0); cur.vertex3 = Util.MakeFloat4(vertices[pos + 2].x, vertices[pos + 2].y, vertices[pos + 2].z, 0); cur.uv1 = Util.MakeFloat2(uvs[pos].x, uvs[pos].y); cur.uv2 = Util.MakeFloat2(uvs[pos + 1].x, uvs[pos + 1].y); cur.uv3 = Util.MakeFloat2(uvs[pos + 2].x, uvs[pos + 2].y); res[i] = cur; } return(res); }
public void GenerateUnitQuad() { Vector3[] vertices = new Vector3[] { new Vector3( 1, 0, 1), new Vector3( 1, 0, -1), new Vector3(-1, 0, 1), new Vector3(-1, 0, -1), }; Vector2[] uv = new Vector2[] { new Vector2(1, 1), new Vector2(1, 0), new Vector2(0, 1), new Vector2(0, 0), }; int[] triangles = new int[] { 0, 1, 2, 2, 1, 3, }; RenderTriangle tri1 = new RenderTriangle(); tri1.SetPoints(vertices[triangles[0]], vertices[triangles[1]], vertices[triangles[2]]); tri1.SetUV(uv[triangles[0]], uv[triangles[1]], uv[triangles[2]]); RenderTriangle tri2 = new RenderTriangle(); tri2.SetPoints(vertices[triangles[3]], vertices[triangles[4]], vertices[triangles[5]]); tri2.SetUV(uv[triangles[3]], uv[triangles[4]], uv[triangles[5]]); AddTriangle(tri1); AddTriangle(tri2); }
public void GenerateUnitQuad() { Vector3[] vertices = new Vector3[] { new Vector3(1, 0, 1), new Vector3(1, 0, -1), new Vector3(-1, 0, 1), new Vector3(-1, 0, -1), }; Vector2[] uv = new Vector2[] { new Vector2(1, 1), new Vector2(1, 0), new Vector2(0, 1), new Vector2(0, 0), }; int[] triangles = new int[] { 0, 1, 2, 2, 1, 3, }; RenderTriangle tri1 = new RenderTriangle(); tri1.SetPoints(vertices[triangles[0]], vertices[triangles[1]], vertices[triangles[2]]); tri1.SetUV(uv[triangles[0]], uv[triangles[1]], uv[triangles[2]]); RenderTriangle tri2 = new RenderTriangle(); tri2.SetPoints(vertices[triangles[3]], vertices[triangles[4]], vertices[triangles[5]]); tri2.SetUV(uv[triangles[3]], uv[triangles[4]], uv[triangles[5]]); AddTriangle(tri1); AddTriangle(tri2); }
public void AddTriangle(RenderTriangle tri) { this.tris.Add(tri); }
private void Split() { NDPlane plane = new NDPlane(); plane.ComputePlane((mpta + mptb + mptc) / 3, RandomVector3()); List <Vector3> upper = new List <Vector3>(); List <Vector3> lower = new List <Vector3>(); List <Vector3> intersection = new List <Vector3>(); plane.IntersectTriangleHull(mpta, mptb, mptc, upper, lower, intersection); upper.AddRange(intersection); lower.AddRange(intersection); List <int> indices = new List <int>(); // UPPER HULL Triangulator.TriangulateNDSlice(upper, indices); for (int i = 0; i < indices.Count; i += 3) { RenderTriangle tri = new RenderTriangle(); Vector3 pta = upper[indices[i]]; Vector3 ptb = upper[indices[i + 1]]; Vector3 ptc = upper[indices[i + 2]]; Vector2 uva = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref pta); Vector2 uvb = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref ptb); Vector2 uvc = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref ptc); tri.SetPoints(pta, ptb, ptc); tri.SetUV(uva, uvb, uvc); splits.Add(tri); } indices.Clear(); // LOWER HULL Triangulator.TriangulateNDSlice(lower, indices); for (int i = 0; i < indices.Count; i += 3) { RenderTriangle tri = new RenderTriangle(); Vector3 pta = lower[indices[i]]; Vector3 ptb = lower[indices[i + 1]]; Vector3 ptc = lower[indices[i + 2]]; Vector2 uva = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref pta); Vector2 uvb = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref ptb); Vector2 uvc = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref ptc); tri.SetPoints(pta, ptb, ptc); tri.SetUV(uva, uvb, uvc); splits.Add(tri); } }
private void Split() { NDPlane plane = new NDPlane(); plane.ComputePlane((mpta + mptb + mptc) / 3, RandomVector3()); List<Vector3> upper = new List<Vector3>(); List<Vector3> lower = new List<Vector3>(); List<Vector3> intersection = new List<Vector3>(); plane.IntersectTriangleHull(mpta, mptb, mptc, upper, lower, intersection); upper.AddRange(intersection); lower.AddRange(intersection); List<int> indices = new List<int>(); // UPPER HULL Triangulator.TriangulateNDSlice(upper, indices); for (int i = 0; i < indices.Count; i += 3) { RenderTriangle tri = new RenderTriangle(); Vector3 pta = upper[indices[i]]; Vector3 ptb = upper[indices[i+1]]; Vector3 ptc = upper[indices[i+2]]; Vector2 uva = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref pta); Vector2 uvb = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref ptb); Vector2 uvc = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref ptc); tri.SetPoints(pta, ptb, ptc); tri.SetUV(uva, uvb, uvc); splits.Add(tri); } indices.Clear(); // LOWER HULL Triangulator.TriangulateNDSlice(lower, indices); for (int i = 0; i < indices.Count; i += 3) { RenderTriangle tri = new RenderTriangle(); Vector3 pta = lower[indices[i]]; Vector3 ptb = lower[indices[i + 1]]; Vector3 ptc = lower[indices[i + 2]]; Vector2 uva = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref pta); Vector2 uvb = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref ptb); Vector2 uvc = Triangulator.GenerateUVCoords(ref mpta, ref mptb, ref mptc, ref muva, ref muvb, ref muvc, ref ptc); tri.SetPoints(pta, ptb, ptc); tri.SetUV(uva, uvb, uvc); splits.Add(tri); } }
int Triangle_ClipAgainstPlane(vec3 plane_p, vec3 plane_n, RenderTriangle in_tri, ref RenderTriangle out_tri1, ref RenderTriangle out_tri2) { // Make sure plane normal is indeed normal plane_n = RenderMath.Vector_Normalize(plane_n); // Return signed shortest distance from point to plane, plane normal must be normalised // Create two temporary storage arrays to classify points either side of plane // If distance sign is positive, point lies on "inside" of plane vec3[] inside_points = new vec3[3]; int nInsidePointCount = 0; vec3[] outside_points = new vec3[3]; int nOutsidePointCount = 0; // Get signed distance of each point in triangle to plane float d0 = dist(in_tri.points[0], plane_p, plane_n); float d1 = dist(in_tri.points[1], plane_p, plane_n); float d2 = dist(in_tri.points[2], plane_p, plane_n); if (d0 >= 0) { inside_points[nInsidePointCount++] = in_tri.points[0]; } else { outside_points[nOutsidePointCount++] = in_tri.points[0]; } if (d1 >= 0) { inside_points[nInsidePointCount++] = in_tri.points[1]; } else { outside_points[nOutsidePointCount++] = in_tri.points[1]; } if (d2 >= 0) { inside_points[nInsidePointCount++] = in_tri.points[2]; } else { outside_points[nOutsidePointCount++] = in_tri.points[2]; } // Now classify triangle points, and break the input triangle into // smaller output triangles if required. There are four possible // outcomes... if (nInsidePointCount == 0) { // All points lie on the outside of plane, so clip whole triangle // It ceases to exist return(0); // No returned triangles are valid } if (nInsidePointCount == 3) { // All points lie on the inside of plane, so do nothing // and allow the triangle to simply pass through out_tri1 = in_tri; return(1); // Just the one returned original triangle is valid } if (nInsidePointCount == 1 && nOutsidePointCount == 2) { // Triangle should be clipped. As two points lie outside // the plane, the triangle simply becomes a smaller triangle // Copy appearance info to new triangle out_tri1.lightValue = in_tri.lightValue; out_tri1.faceColor = in_tri.faceColor; // The inside point is valid, so keep that... out_tri1.points[0] = inside_points[0]; // but the two new points are at the locations where the // original sides of the triangle (lines) intersect with the plane out_tri1.points[1] = Vector_IntersectPlane(plane_p, plane_n, inside_points[0], outside_points[0]); out_tri1.points[2] = Vector_IntersectPlane(plane_p, plane_n, inside_points[0], outside_points[1]); return(1); // Return the newly formed single triangle } if (nInsidePointCount == 2 && nOutsidePointCount == 1) { // Triangle should be clipped. As two points lie inside the plane, // the clipped triangle becomes a "quad". Fortunately, we can // represent a quad with two new triangles // Copy appearance info to new triangles out_tri1.lightValue = in_tri.lightValue; out_tri1.faceColor = in_tri.faceColor; out_tri2.lightValue = in_tri.lightValue; out_tri2.faceColor = in_tri.faceColor; // The first triangle consists of the two inside points and a new // point determined by the location where one side of the triangle // intersects with the plane out_tri1.points[0] = inside_points[0]; out_tri1.points[1] = inside_points[1]; out_tri1.points[2] = Vector_IntersectPlane(plane_p, plane_n, inside_points[0], outside_points[0]); // The second triangle is composed of one of he inside points, a // new point determined by the intersection of the other side of the // triangle and the plane, and the newly created point above out_tri2.points[0] = inside_points[1]; out_tri2.points[1] = out_tri1.points[2]; out_tri2.points[2] = Vector_IntersectPlane(plane_p, plane_n, inside_points[1], outside_points[0]); return(2); // Return two newly formed triangles which form a quad } return(0); }
void RenderCustomMesh(CustomMesh renderMesh) { vec3 rotation = renderMesh.rotation * Mathf.Deg2Rad; rotMat = RenderMath.Matrix_MakeRotation(new vec3(rotation.x, 0, rotation.z)); RenderTriangle triProjected, triTransformed, triViewed; // float outputColor = 0f; Matrix4x4 transMat = RenderMath.Matrix_MakeTranslation(renderMesh.position); Matrix4x4 worldMat = RenderMath.Matrix_MakeIdentity(); worldMat = rotMat; worldMat = RenderMath.Matrix_MultiplyMatrix(worldMat, transMat); vec3 vUp = new vec3(0, 1, 0); vec3 vTarget = new vec3(0, 0, 1); Matrix4x4 cameraRotMat = RenderMath.Matrix_MakeRotationY(cameraRotation.y); vLookDir = RenderMath.Matrix_MultiplyVector(vTarget, cameraRotMat); vTarget = vCamera + vLookDir; Matrix4x4 cameraMat = RenderMath.Matrix_PointAt(vCamera, vTarget, vUp); Matrix4x4 viewMat = RenderMath.Matrix_QuickInverse(cameraMat); for (int i = 0; i < renderMesh.tris.Count; i += 3) { triProjected = new RenderTriangle(); triTransformed = new RenderTriangle(); triViewed = new RenderTriangle(); triTransformed.points[0] = RenderMath.Matrix_MultiplyVector(renderMesh.verts[renderMesh.tris[i]], worldMat); triTransformed.points[1] = RenderMath.Matrix_MultiplyVector(renderMesh.verts[renderMesh.tris[i + 1]], worldMat); triTransformed.points[2] = RenderMath.Matrix_MultiplyVector(renderMesh.verts[renderMesh.tris[i + 2]], worldMat); // triTransformed.Log(); vec3 normal, line1, line2; line1 = triTransformed.points[1] - triTransformed.points[0]; line2 = triTransformed.points[2] - triTransformed.points[0]; normal = RenderMath.Vector_CrossProduct(line1, line2); normal = RenderMath.Vector_Normalize(normal); //Debug.DrawRay(new Vector3(triTransformed.averagePos.x,triTransformed.averagePos.y,triTransformed.averagePos.z), new Vector3(normal.x,normal.y,normal.z)); //show mesh normals in scene view; if (RenderMath.Vector_DotProduct(normal, triTransformed.points[0] - vCamera) < 0f) { vec3 light_direction = new vec3(0, 1, -1); light_direction = RenderMath.Vector_Normalize(light_direction); triViewed.lightValue = Mathf.Max(0.1f, RenderMath.Vector_DotProduct(light_direction, normal)); triViewed.faceColor = (renderMesh.triColors.Count * 3 == renderMesh.tris.Count ? renderMesh.triColors[i / 3] : Color.white); triViewed.points[0] = RenderMath.Matrix_MultiplyVector(triTransformed.points[0], viewMat); triViewed.points[1] = RenderMath.Matrix_MultiplyVector(triTransformed.points[1], viewMat); triViewed.points[2] = RenderMath.Matrix_MultiplyVector(triTransformed.points[2], viewMat); int nClippedTriangles = 0; RenderTriangle[] clipped = new RenderTriangle[2]; clipped[0] = new RenderTriangle(); clipped[1] = new RenderTriangle(); nClippedTriangles = Triangle_ClipAgainstPlane(new vec3(0.0f, 0.0f, 0.1f), new vec3(0.0f, 0.0f, 1.0f), triViewed, ref clipped[0], ref clipped[1]); for (int n = 0; n < nClippedTriangles; n++) { triProjected.lightValue = clipped[n].lightValue; triProjected.faceColor = clipped[n].faceColor; triProjected.points[0] = RenderMath.Matrix_MultiplyVector(triViewed.points[0], projMat); triProjected.points[1] = RenderMath.Matrix_MultiplyVector(triViewed.points[1], projMat); triProjected.points[2] = RenderMath.Matrix_MultiplyVector(triViewed.points[2], projMat); triProjected.points[0] = RenderMath.Vector_Normalize(triProjected.points[0]); triProjected.points[1] = RenderMath.Vector_Normalize(triProjected.points[1]); triProjected.points[2] = RenderMath.Vector_Normalize(triProjected.points[2]); /* * triProjected.points[0].x *= -1.0f; * triProjected.points[1].x *= -1.0f; * triProjected.points[2].x *= -1.0f; * triProjected.points[0].y *= -1.0f; * triProjected.points[1].y *= -1.0f; * triProjected.points[2].y *= -1.0f; */ vec3 vOffsetView = new vec3(1, 1, 0); triProjected.points[0] += vOffsetView; triProjected.points[1] += vOffsetView; triProjected.points[2] += vOffsetView; triProjected.points[0].x *= 0.5f * (float)width; triProjected.points[0].y *= 0.5f * (float)height; triProjected.points[1].x *= 0.5f * (float)width; triProjected.points[1].y *= 0.5f * (float)height; triProjected.points[2].x *= 0.5f * (float)width; triProjected.points[2].y *= 0.5f * (float)height; vecTrianglesToRaster.Add(triProjected); } } } }