private void Awake() { mesh = new Mesh(); triangleMesh = new TriangleMesh(); lodMeshFilter = GetComponent<MeshFilter>(); lodMeshRenderer = GetComponent<MeshRenderer>(); lodMeshCollider = GetComponent<MeshCollider>(); lodMeshRenderer.sharedMaterial = Material; lodMeshFilter.mesh = mesh; }
public void AddTriangleWithoutMergingAndWithDestroyedLists() { var mesh = new TriangleMesh(); // Destroy lists. mesh.Vertices = null; mesh.Indices = null; Assert.AreEqual(0, mesh.NumberOfTriangles); mesh.Add(new Triangle(new Vector3F(1, 1, 1), new Vector3F(1, 1, 1), new Vector3F(1, 1, 1.000001f)), false, 0.001f, false); Assert.AreEqual(3, mesh.Vertices.Count); }
public void AddMesh() { TriangleMesh mesh = new TriangleMesh(); mesh.Add(new Triangle(new Vector3F(0, 0, 0), new Vector3F(1, 1, 1), new Vector3F(1, 0, 2)), true); mesh.Add(new Triangle(new Vector3F(0, 1, 0), new Vector3F(1, 2, 1), new Vector3F(1, 1, 1)), true); var mesh2 = new TriangleMesh(); mesh2.Add(new Triangle(new Vector3F(0, 0, 0), new Vector3F(1, 1, 1), new Vector3F(1, 0, 1)), true); mesh2.Add(mesh, true); Assert.AreEqual(3, mesh2.NumberOfTriangles); Assert.AreEqual(new Triangle(new Vector3F(0, 1, 0), new Vector3F(1, 2, 1), new Vector3F(1, 1, 1)), mesh2.GetTriangle(2)); }
public void Clone() { var mesh = new TriangleMesh(); mesh.Add(new Triangle(new Vector3F(0, 1, 2), new Vector3F(3, 4, 5), new Vector3F(6, 7, 8)), true); mesh.Add(new Triangle(new Vector3F(-0, -1, -2), new Vector3F(-3, -4, -5), new Vector3F(-6, -7, -8)), true); mesh.Tag = new SphereShape(3); var clone = mesh.Clone(); Assert.AreEqual(mesh.NumberOfTriangles, clone.NumberOfTriangles); Assert.AreEqual(mesh.GetTriangle(0), clone.GetTriangle(0)); Assert.AreEqual(mesh.GetTriangle(1), clone.GetTriangle(1)); Assert.AreSame(mesh.Tag, clone.Tag); mesh.Tag = new MemoryStream(); clone = mesh.Clone(); Assert.AreSame(mesh.Tag, clone.Tag); }
/// <summary> /// Allows us to specify a lowPoly collision skin model /// </summary> /// <param name="id"></param> /// <param name="actorType"></param> /// <param name="transform"></param> /// <param name="effectParameters"></param> /// <param name="model"></param> /// <param name="lowPolygonModel"></param> /// <param name="materialProperties"></param> public TriangleMeshObject(string id, ActorType actorType, StatusType statusType, Transform3D transform, EffectParameters effectParameters, Model model, Model lowPolygonModel, MaterialProperties materialProperties) : base(id, actorType, statusType, transform, effectParameters, model) { //get the primitive mesh which forms the skin - use low poly if it has been provided in the constructor TriangleMesh triangleMesh = null; if (lowPolygonModel != null) { triangleMesh = GetTriangleMesh(lowPolygonModel, this.Transform3D); } else { triangleMesh = GetTriangleMesh(model, this.Transform3D); } //add the primitive mesh to the collision skin this.Body.CollisionSkin.AddPrimitive(triangleMesh, materialProperties); }
public static IEnumerable <IShape> CreatePlane(Point min, Point max) { var tr = Transform.Identity; return(TriangleMesh.CreateTriangleMesh( tr, Transform.Invert(tr), false, 2, new[] { 0, 1, 2, 0, 2, 3 }, 4, new[] { min, new Point(min.X, max.Y, max.Z), max, new Point(max.X, min.Y, min.Z), }, null, null, null, null, null, null)); }
private static TriangleMesh CreateTriangleMesh(List <int> indices, List <Vector3> vertices, Vector3 localScaling) { var triangleMesh = new TriangleMesh(); int triangleCount = indices.Count / 3; for (int i = 0; i < triangleCount; i++) { int index0 = indices[i * 3]; int index1 = indices[i * 3 + 1]; int index2 = indices[i * 3 + 2]; Vector3 vertex0 = vertices[index0] * localScaling; Vector3 vertex1 = vertices[index1] * localScaling; Vector3 vertex2 = vertices[index2] * localScaling; triangleMesh.AddTriangleRef(ref vertex0, ref vertex1, ref vertex2); } return(triangleMesh); }
public void ShadingNormals_ShouldBeSet() { var vertices = new Vector3[] { new Vector3(-1, 0, -1), new Vector3(1, 0, -1), new Vector3(1, 0, 1), new Vector3(-1, 0, -1), new Vector3(1, 0, -1), new Vector3(-1, 0, 1) }; var indices = new int[] { 0, 1, 2, 3, 4, 5 }; var normals = new Vector3[] { new Vector3(1, 0, 0), new Vector3(1, 0, 0), new Vector3(1, 0, 0), new Vector3(1, 0, -1), new Vector3(1, 0, -1), new Vector3(1, 0, -1), }; TriangleMesh mesh = new TriangleMesh(vertices, indices, shadingNormals: normals); var n1 = mesh.ComputeShadingNormal(0, new Vector2(0.5f, 0.5f)); var n2 = mesh.ComputeShadingNormal(1, new Vector2(0.5f, 0.5f)); Assert.Equal(1, n1.X, 3); Assert.Equal(0, n1.Y, 3); Assert.Equal(0, n1.Z, 3); Assert.Equal(1.0f / MathF.Sqrt(2), n2.X, 3); Assert.Equal(0, n2.Y, 3); Assert.Equal(-1.0f / MathF.Sqrt(2), n2.Z, 3); }
/// <summary> /// Calculates the Vertex normals as an average of the normals of the normals of the incident Edges, /// that are calculated as the average of the normals of the incident Triangles weighted by the inverse of their area. /// </summary> /// <param name="mesh">Reference to the TriangleMesh to calculate the vertex normals for.</param> public void GetVertexNormals(ref TriangleMesh mesh) { for (int i = 0; i < mesh.Vertices.Count; i++) { Vertex vertex = mesh.Vertices[i]; vertex.Normal = new Vector(0, 0, 0); for (int j = 0; j < vertex.Triangles.Count; j++) { Triangle triangle = mesh[vertex.Triangles[j]]; int[] neighbors = triangle.GetNeighborsOf(i); double weight = 1 / (Vector.Distance(mesh.Vertices[i], mesh.Vertices[neighbors[0]]) * Triangle.GetAreaOf(vertex, triangle.Centroid, mesh.Vertices[neighbors[0]])); weight += 1 / (Vector.Distance(mesh.Vertices[i], mesh.Vertices[neighbors[1]]) * Triangle.GetAreaOf(vertex, triangle.Centroid, mesh.Vertices[neighbors[1]])); vertex.Normal += weight * triangle.Normal; } vertex.Normal.Normalize(); } }
/// <summary> /// Called when a mesh should be generated for the shape. /// </summary> /// <param name="absoluteDistanceThreshold">The absolute distance threshold.</param> /// <param name="iterationLimit">The iteration limit.</param> /// <returns>The triangle mesh for this shape.</returns> /// <remarks> /// A deep copy of the <see cref="Mesh"/> is returned. /// </remarks> protected override TriangleMesh OnGetMesh(float absoluteDistanceThreshold, int iterationLimit) { var triangleMesh = Mesh as TriangleMesh; if (triangleMesh != null) { return(triangleMesh.Clone()); } // Return a copy of the mesh. TriangleMesh mesh = new TriangleMesh(); int numberOfTriangles = _mesh.NumberOfTriangles; for (int i = 0; i < numberOfTriangles; i++) { Triangle triangle = _mesh.GetTriangle(i); mesh.Add(triangle, false); } mesh.WeldVertices(); return(mesh); }
public TriangleMeshObject(Game game, Model model, Matrix orientation, Vector3 position) : base(game, model) { body = new Body(); collision = new CollisionSkin(null); triangleMesh = new TriangleMesh(); List <Vector3> vertexList = new List <Vector3>(); List <TriangleVertexIndices> indexList = new List <TriangleVertexIndices>(); ExtractData(vertexList, indexList, model); triangleMesh.CreateMesh(vertexList, indexList, 4, 1.0f); collision.AddPrimitive(triangleMesh, new MaterialProperties(0.8f, 0.7f, 0.6f)); PhysicsSystem.CurrentPhysicsSystem.CollisionSystem.AddCollisionSkin(collision); // Transform collision.ApplyLocalTransform(new JigLibX.Math.Transform(position, orientation)); // we also need to move this dummy, so the object is *rendered* at the correct positiob body.MoveTo(position, orientation); }
/// <summary> /// Performs parameterization with the chosen method on the given mesh /// The mesh is assumed to be non-closed with proper boundary /// </summary> /// <param name="meshIn">input mesh, after solving its texture coordinates in vertex traits will be adjusted</param> /// <param name="meshOut">an flattened output mesh with only X,Y coordinates set, Z is set to 0</param> public void PerformParameterization(TriangleMesh meshin, out TriangleMesh meshout) { switch (this.SelectedMethod) { default: case Method.Barycentric: BarycentricMapping(meshin, out meshout); break; case Method.LSCM: LSCM(meshin, out meshout); break; case Method.DCP: DCP(meshin, out meshout); break; case Method.LinearABF: LinearABF(meshin, out meshout); break; } }
/// </summary> public static TripletMatrix CreateUniformLaplacian(TriangleMesh mesh, double lambda = 0.0, double eye = 0.0, bool normalized = false) { int n = mesh.Vertices.Count; int nz = mesh.Vertices.Aggregate(0, (c, x) => x.VertexCount()); var L = new TripletMatrix(n, n, nz, true); /// build adjacence A and uniform L matrix for (int i = 0; i < n; i++) { var v = mesh.Vertices[i]; var wsum = (double)v.VertexCount(); var wij = 1.0; foreach (var vj in v.Vertices) { int j = vj.Index; if (normalized) { L[i, j] = lambda * (wij / wsum); } else { L[i, j] = lambda * (wij); } } if (normalized) { L[i, i] = eye - lambda * 1; } else { L[i, i] = eye - lambda * wsum; } } return(L); }
public void WriteRawFormatToFile(BinaryWriter writer, TriangleMesh mesh) { writer.Write(mesh.NumVertices); foreach (var Entry in mesh.Vertices) { Vector3Utils.WriteToFile(Entry, writer); } writer.Write(mesh.NumTriangles * 3); // Write Number of Indices, not triangles. foreach (var Entry in mesh.Triangles) { writer.Write(Entry.v0); writer.Write(Entry.v1); writer.Write(Entry.v2); } writer.Write(mesh.MaterialIndices.Count); foreach (var Entry in mesh.MaterialIndices) { writer.Write(Entry); } }
///<summary> /// Constructs a new mobile mesh shape. ///</summary> ///<param name="vertices">Vertices of the mesh.</param> ///<param name="indices">Indices of the mesh.</param> ///<param name="localTransform">Local transform to apply to the shape.</param> ///<param name="solidity">Solidity state of the shape.</param> /// <param name="center">Center of the shape.</param> public MobileMeshShape(Vector3[] vertices, int[] indices, AffineTransform localTransform, MobileMeshSolidity solidity, out Vector3 center) { this.solidity = solidity; TransformableMeshData data = new TransformableMeshData(vertices, indices, localTransform); ShapeDistributionInformation shapeDistributionInformation = ComputeVolumeDistribution(data); data.worldTransform.Translation -= shapeDistributionInformation.Center; center = shapeDistributionInformation.Center; TriangleMesh = new TriangleMesh(data); UpdateEntityShapeVolume(new EntityShapeVolumeDescription { Volume = shapeDistributionInformation.Volume, VolumeDistribution = shapeDistributionInformation.VolumeDistribution }); ComputeSolidSidedness(); UpdateSurfaceVertices(); }
// Token: 0x06001E27 RID: 7719 RVA: 0x001BDEC8 File Offset: 0x001BC0C8 public override void InitiateSprites(RoomCamera.SpriteLeaser sLeaser, RoomCamera rCam) { sLeaser.sprites = new FSprite[this.TotalSprites]; sLeaser.sprites[this.BodySprite] = new FSprite("pixel", true); sLeaser.sprites[this.BodySprite].scale = Mathf.Lerp(0.4f, 0.7f, this.fish.iVars.fatness); sLeaser.sprites[this.HeadSprite] = new FSprite("pixel", true); sLeaser.sprites[this.HeadSprite].scale = 0.6f; sLeaser.sprites[this.JawSprite] = new FSprite("pixel", true); sLeaser.sprites[this.JawSprite].scale = 0.7f; sLeaser.sprites[NeckSprite] = TriangleMesh.MakeLongMesh(fish.neck.tChunks.Length, false, false); (sLeaser.sprites[NeckSprite] as TriangleMesh).alpha = 1f; for (int i = 0; i < this.danglers.Length; i++) { this.danglers[i].InitSprite(sLeaser, HeadDanglerSprite(i)); sLeaser.sprites[HeadDanglerSprite(i)].shader = rCam.room.game.rainWorld.Shaders["TentaclePlant"]; sLeaser.sprites[HeadDanglerSprite(i)].alpha = Mathf.InverseLerp(2f, 12f, (float)this.danglers[i].segments.Length) * 0.9f + 0.1f * this.danglerProps[i, 2]; } for (int i = 0; i < 2; i++) { for (int j = 0; j < this.fish.iVars.whiskers; j++) { sLeaser.sprites[this.WhiskerSprite(i, j)] = TriangleMesh.MakeLongMesh(4, true, false); } } sLeaser.sprites[this.TentacleSprite()] = TriangleMesh.MakeLongMesh(this.tail.Length, true, false); sLeaser.sprites[this.WingSprite(0)] = TriangleMesh.MakeLongMesh(10, true, false); sLeaser.sprites[this.WingSprite(1)] = TriangleMesh.MakeLongMesh(10, true, false); for (int k = 0; k < 2; k++) { sLeaser.sprites[this.FlipperSprite(k)] = new FSprite("JetFishFlipper" + this.fish.iVars.flipper, true); this.flipperGraphWidth = Futile.atlasManager.GetElementWithName("JetFishFlipper" + this.fish.iVars.flipper).sourcePixelSize.x; sLeaser.sprites[this.FlipperSprite(k)].alpha = 0f; sLeaser.sprites[this.FlipperSprite(k)].anchorX = 0f; sLeaser.sprites[this.FlipperSprite(k)].anchorY = SeaDrakeGraphics.flipperGraphConPointHeights[this.fish.iVars.flipper] / Futile.atlasManager.GetElementWithName("JetFishFlipper" + this.fish.iVars.flipper).sourcePixelSize.y; } this.AddToContainer(sLeaser, rCam, null); base.InitiateSprites(sLeaser, rCam); }
/// <summary> /// Called when a mesh should be generated for the shape. /// </summary> /// <param name="absoluteDistanceThreshold">The absolute distance threshold.</param> /// <param name="iterationLimit">The iteration limit.</param> /// <returns>The triangle mesh for this shape.</returns> /// <remarks> /// This method creates a triangle mesh that represents a square lying in the plane. The square /// has an edge length of <see cref="MeshSize"/>. /// </remarks> protected override TriangleMesh OnGetMesh(float absoluteDistanceThreshold, int iterationLimit) { Vector3 center = Normal * DistanceFromOrigin; Vector3 orthoNormal1 = Normal.Orthonormal1; Vector3 orthoNormal2 = Normal.Orthonormal2; // Plane // Make 4 triangles around the center. TriangleMesh mesh = new TriangleMesh(); mesh.Add(new Triangle { Vertex0 = center, Vertex1 = center + orthoNormal1 * MeshSize / 2 - orthoNormal2 * MeshSize / 2, Vertex2 = center + orthoNormal1 * MeshSize / 2 + orthoNormal2 * MeshSize / 2, }, true); mesh.Add(new Triangle { Vertex0 = center, Vertex1 = center + orthoNormal1 * MeshSize / 2 + orthoNormal2 * MeshSize / 2, Vertex2 = center - orthoNormal1 * MeshSize / 2 + orthoNormal2 * MeshSize / 2, }, true); mesh.Add(new Triangle { Vertex0 = center, Vertex1 = center - orthoNormal1 * MeshSize / 2 + orthoNormal2 * MeshSize / 2, Vertex2 = center - orthoNormal1 * MeshSize / 2 - orthoNormal2 * MeshSize / 2, }, true); mesh.Add(new Triangle { Vertex0 = center, Vertex1 = center - orthoNormal1 * MeshSize / 2 - orthoNormal2 * MeshSize / 2, Vertex2 = center + orthoNormal1 * MeshSize / 2 - orthoNormal2 * MeshSize / 2, }, true); return(mesh); }
/// <summary> /// Calculates the Vertex normals as an average of the normals of the incident Triangles, /// weighted by the angle between the neighboring Vertices. /// As the Triangle normal can be calculated from the neighboring Vertices, /// the actual Triangle normals and the angles are not needed. /// (More exact, since the calculation of the angle requires calculating an arcus cosine.) /// The cross product of the neighbors is calculated and divided by the product of their length instead. /// </summary> /// <param name="mesh">Reference to the TriangleMesh to calculate the vertex normals for.</param> public void GetVertexNormals(ref TriangleMesh mesh) { Vector pro1, pro2; double factor; int[] neighbors; for (int i = 0; i < mesh.Vertices.Count; i++) { Vertex vertex = mesh.Vertices[i]; vertex.Normal = new Vector(0, 0, 0); for (int j = 0; j < vertex.Triangles.Count; j++) { neighbors = mesh[vertex.Triangles[j]].GetNeighborsOf(i); pro1 = mesh.Vertices[neighbors[0]] - vertex; pro2 = mesh.Vertices[neighbors[1]] - vertex; factor = pro1.SquaredLength() * pro2.SquaredLength(); vertex.Normal += (pro1 % pro2) / factor; } vertex.Normal.Normalize(); } }
/// </summary> public static TripletMatrix CreateBoundedUniformLaplacian(TriangleMesh mesh, double lambda = 0.0, double eye = 0.0, bool normalized = false) { var vertexCount = mesh.Vertices.Count; int neighborCount = mesh.Vertices.Aggregate(0, (c, x) => x.VertexCount()); var L = new TripletMatrix(vertexCount, vertexCount, neighborCount, true); foreach (var currentVertex in mesh.Vertices) { if (currentVertex.OnBoundary) { L.Entry(currentVertex.Index, currentVertex.Index, 1d); continue; } // Diagonal entry v(i,i) = eye*1 + λ*L(i,i) var diagonalVal = eye + GetNormalized(currentVertex.Vertices.Count(), currentVertex.VertexCount(), normalized) * lambda; L.Entry(currentVertex.Index, currentVertex.Index, diagonalVal); currentVertex.Vertices.Apply(nb => L.Entry(currentVertex.Index, nb.Index, GetNormalized(-1, currentVertex.VertexCount(), normalized) * lambda)); } return(L); }
private static RigidBody CreateRigidBodyFromTgcMesh(TgcMesh mesh, TGCVector3 position, float mass) { var vertexCoords = mesh.getVertexPositions(); TriangleMesh triangleMesh = new TriangleMesh(); for (int i = 0; i < vertexCoords.Length; i = i + 3) { triangleMesh.AddTriangle(vertexCoords[i].ToBsVector, vertexCoords[i + 1].ToBsVector, vertexCoords[i + 2].ToBsVector); } var transformationMatrix = TGCMatrix.RotationYawPitchRoll(0, 0, 0).ToBsMatrix; transformationMatrix.Origin = position.ToBsVector; DefaultMotionState motionState = new DefaultMotionState(transformationMatrix); var bulletShape = new ConvexTriangleMeshShape(triangleMesh, true); var localInertia = bulletShape.CalculateLocalInertia(mass); var bodyInfo = new RigidBodyConstructionInfo(mass, motionState, bulletShape, localInertia); var rigidBody = new RigidBody(bodyInfo); return(rigidBody); }
public override void InitiateSprites(RoomCamera.SpriteLeaser sLeaser, RoomCamera rCam) { sLeaser.sprites = new FSprite[1]; var tris = new TriangleMesh.Triangle[] { new TriangleMesh.Triangle(0, 1, 2), new TriangleMesh.Triangle(2, 1, 3) }; var mesh = new TriangleMesh(spriteName, tris, false); mesh.MoveVertice(0, new Vector2(0f, 0f)); mesh.MoveVertice(1, new Vector2(0f, rCam.sSize.y)); mesh.MoveVertice(2, new Vector2(rCam.sSize.x, 0f)); mesh.MoveVertice(3, new Vector2(rCam.sSize.x, rCam.sSize.y)); mesh.UVvertices[0] = new Vector2(0f, 0f); mesh.UVvertices[1] = new Vector2(0f, 2f); mesh.UVvertices[2] = new Vector2(2f, 0f); mesh.UVvertices[3] = new Vector2(2f, 2f); sLeaser.sprites[0] = mesh; sLeaser.sprites[0].alpha = 0f; this.AddToContainer(sLeaser, rCam, rCam.ReturnFContainer("HUD")); }
// Creates a TriangleMeshShape for the water surface. The surface is curved and // inclined. private static Shape GetSpiralShape() { var triangleMesh = new TriangleMesh(); const int numberOfQuads = 12; const float innerRadius = 1; const float outerRadius = 2; float angle = 0; float y = 0; for (int i = 0; i <= numberOfQuads; i++, angle += 0.4f, y -= 0.02f) { float cos = (float)Math.Cos(angle); float sin = (float)Math.Sin(angle); triangleMesh.Vertices.Add(new Vector3(outerRadius * cos, y, outerRadius * sin)); triangleMesh.Vertices.Add(new Vector3(innerRadius * cos, y, innerRadius * sin)); if (i == 5) { y -= 0.2f; } } // Add 2 triangles per quad. for (int i = 0; i < numberOfQuads; i++) { triangleMesh.Indices.Add(i * 2 + 0); triangleMesh.Indices.Add(i * 2 + 1); triangleMesh.Indices.Add(i * 2 + 2); triangleMesh.Indices.Add(i * 2 + 1); triangleMesh.Indices.Add(i * 2 + 3); triangleMesh.Indices.Add(i * 2 + 2); } return(new TriangleMeshShape(triangleMesh)); }
/// <summary> /// /// </summary> /// <param name="mesh"></param> /// <returns></returns> public bool Smooth(TriangleMesh mesh) { switch (this.SelectedMethod) { default: case Method.Explicit_Euler: this.ExplicitEulerSmoothing(mesh, this.Iterations); break; case Method.Implicit_Euler: this.ImplicitEulerSmoothing(mesh); break; case Method.LS_Optimization: this.GlobalLeastSquaresSmoothing(mesh); break; case Method.TriangleQuality: this.TriangleQualityOptimization(mesh); break; } return(true); }
public static RigidBody CreateRigidBodyFromTgcMesh(TgcMesh mesh, TGCVector3 position) { var meshAxisRadius = mesh.BoundingBox.calculateAxisRadius().ToBsVector; var boxShape = new BoxShape(meshAxisRadius); var transformationMatrix = TGCMatrix.RotationYawPitchRoll(0, 0, 0).ToBsMatrix; transformationMatrix.Origin = position.ToBsVector; DefaultMotionState motionState = new DefaultMotionState(transformationMatrix); var boxLocalInertia = boxShape.CalculateLocalInertia(0); var qwe = new TriangleMesh(); var asd = new BvhTriangleMeshShape(qwe, false); var bodyInfo = new RigidBodyConstructionInfo(0, motionState, asd, boxLocalInertia); var rigidBody = new RigidBody(bodyInfo); rigidBody.Friction = 0.4f; rigidBody.RollingFriction = 1; // ballBody.SetDamping(0.1f, 0.9f); rigidBody.Restitution = 1f; return(rigidBody); }
public void FromTriangleMesh2() { var mesh = new TriangleMesh(); mesh.Vertices.Add(new Vector3F(0, 0, 0)); mesh.Vertices.Add(new Vector3F(1, 1, 1)); mesh.Vertices.Add(new Vector3F(2, 2, 2)); mesh.Vertices.Add(new Vector3F(3, 3, 3)); //mesh.Vertices.Add(new Vector3F(405, 322, 0)); mesh.Indices.Add(0); mesh.Indices.Add(1); mesh.Indices.Add(2); mesh.Indices.Add(1); mesh.Indices.Add(3); mesh.Indices.Add(2); var dcel = DcelMesh.FromTriangleMesh((ITriangleMesh)mesh); Assert.AreEqual(4, dcel.Vertices.Count); Assert.AreEqual(2, dcel.Faces.Count); Assert.AreEqual(10, dcel.Edges.Count); Assert.IsTrue(dcel.IsValid()); Assert.IsFalse(dcel.IsClosed()); Assert.IsTrue(dcel.IsTriangleMesh()); }
public void AddTriangleToleranceMustBeGreaterNull() { TriangleMesh mesh = new TriangleMesh(); mesh.Add(new Triangle(), true, 0, true); }
public void AddTriangleShouldRemoveDegenerateTriangle2() { var mesh = new TriangleMesh(); mesh.Add(new Triangle(new Vector3F(1, 1, 1), new Vector3F(1, 1, 1), new Vector3F(1, 1, 1.000001f)), false, 0.001f, true); Assert.AreEqual(0, mesh.NumberOfTriangles); }
public void WeldVertices() { TriangleMesh mesh = new TriangleMesh(); Assert.AreEqual(0, mesh.WeldVertices()); mesh.Add(new Triangle(new Vector3F(1, 2, 3), new Vector3F(3, 4, 5), new Vector3F(1.00001f, 2.00001f, 3f)), false); Assert.AreEqual(3, mesh.Vertices.Count); Assert.Throws(typeof(ArgumentOutOfRangeException), () => mesh.WeldVertices(-0.1f)); Assert.AreEqual(1, mesh.WeldVertices(0.0001f)); Assert.AreEqual(2, mesh.Vertices.Count); var w = Stopwatch.StartNew(); mesh = new SphereShape(0.5f).GetMesh(0.001f, 7); w.Stop(); //Assert.AreEqual(0, w.Elapsed.TotalMilliseconds); for (int i = 0; i < mesh.Vertices.Count; i++) { for (int j = i + 1; j < mesh.Vertices.Count; j++) { Assert.IsFalse(Vector3F.AreNumericallyEqual(mesh.Vertices[i], mesh.Vertices[j])); } } // Second time does nothing. Assert.AreEqual(0, mesh.WeldVertices()); }
public static Mesh Construct(TriangleMesh metaResource) { var mesh = new Mesh { MeshType = MeshType.Indexed, VertexStreamLayout = Vertex.Position3Normal3Texcoord3.Instance }; if (!metaResource.TwoSided) { mesh.NVertices = 3; mesh.NFaces = 1; } else { mesh.NVertices = 6; mesh.NFaces = 2; } Vector3 an = Vector3.Cross(metaResource.PositionB - metaResource.PositionA, metaResource.PositionC - metaResource.PositionA); an.Normalize(); Vector3 bn = Vector3.Cross(metaResource.PositionC - metaResource.PositionB, metaResource.PositionA - metaResource.PositionB); bn.Normalize(); Vector3 cn = Vector3.Cross(metaResource.PositionA - metaResource.PositionC, metaResource.PositionB - metaResource.PositionC); cn.Normalize(); List<Vertex.Position3Normal3Texcoord3> verts = new List<Vertex.Position3Normal3Texcoord3>(); verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionA, an, Common.Math.ToVector3(metaResource.UVA))); verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionB, bn, Common.Math.ToVector3(metaResource.UVB))); verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionC, cn, Common.Math.ToVector3(metaResource.UVC))); if (metaResource.TwoSided) { verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionA, -an, Common.Math.ToVector3(metaResource.UVA))); verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionB, -bn, Common.Math.ToVector3(metaResource.UVB))); verts.Add(new Vertex.Position3Normal3Texcoord3(metaResource.PositionC, -cn, Common.Math.ToVector3(metaResource.UVC))); } mesh.VertexBuffer = new VertexBuffer<Vertex.Position3Normal3Texcoord3>(verts.ToArray()); List<int> indices = new List<int>(); indices.Add(0); indices.Add(1); indices.Add(2); if (metaResource.TwoSided) { indices.Add(2 + 3); indices.Add(1 + 3); indices.Add(0 + 3); } mesh.IndexBuffer = new IndexBuffer(indices.ToArray()); return mesh; }
public void Transform() { var mesh = new TriangleMesh(); mesh.Add(new Triangle(new Vector3F(0, 1, 2), new Vector3F(3, 4, 5), new Vector3F(6, 7, 8)), true); mesh.Add(new Triangle(new Vector3F(-0, -1, -2), new Vector3F(-3, -4, -5), new Vector3F(-6, -7, -8)), true); var trans = RandomHelper.Random.NextMatrix44F(-1, 1); mesh.Transform(trans); Assert.AreEqual(trans.TransformPosition(new Vector3F(0, 1, 2)), mesh.Vertices[0]); Assert.AreEqual(trans.TransformPosition(new Vector3F(-6, -7, -8)), mesh.Vertices[5]); }
public void SerializationBinary() { var a = new TriangleMesh(); a.Add(new Triangle(new Vector3F(0, 1, 2), new Vector3F(3, 4, 5), new Vector3F(6, 7, 8)), false); a.Add(new Triangle(new Vector3F(-0, -1, -2), new Vector3F(-3, -4, -5), new Vector3F(-6, -7, -8)), false); // Serialize object. var stream = new MemoryStream(); var formatter = new BinaryFormatter(); formatter.Serialize(stream, a); // Deserialize object. stream.Position = 0; var deserializer = new BinaryFormatter(); var b = (TriangleMesh)deserializer.Deserialize(stream); Assert.AreEqual(a.NumberOfTriangles, b.NumberOfTriangles); for (int i = 0; i < a.Vertices.Count; i++) Assert.AreEqual(a.Vertices[i], b.Vertices[i]); for (int i = 0; i < a.Indices.Count; i++) Assert.AreEqual(a.Indices[i], b.Indices[i]); }
public void GetTriangleException2() { TriangleMesh mesh = new TriangleMesh(); mesh.Add(new Triangle(new Vector3F(0, 0, 0), new Vector3F(1, 1, 1), new Vector3F(1, 0, 1)), false); mesh.GetTriangle(1); }
/// <summary> /// Generic OBJ-loading scene definition routine. /// </summary> /// <param name="dir">Viewing direction of a camera.</param> /// <param name="FoVy">Field of View in degrees.</param> /// <param name="correction">Value less than 1.0 brings camera nearer.</param> /// <param name="name">OBJ file-name.</param> /// <param name="names">Substitute file-name[s].</param> /// <returns>Number of triangles.</returns> protected static long SceneObj( IRayScene sc, Vector3d dir, double FoVy, double correction, string name, string[] names, double[] surfaceColor ) { Debug.Assert( sc != null ); Vector3 center = Vector3.Zero; // center of the mesh dir.Normalize(); // normalized viewing vector of the camera float diameter = 2.0f; // default scene diameter int faces = 0; // CSG scene: CSGInnerNode root = new CSGInnerNode( SetOperation.Union ); // OBJ file to read: if ( names.Length == 0 || names[ 0 ].Length == 0 ) names = new string[] { name }; string[] paths = Scenes.SmartFindFiles( names ); if ( paths[ 0 ] == null || paths[ 0 ].Length == 0 ) { for ( int i = 0; i < names.Length; i++ ) if ( names[ i ].Length > 0 ) names[ i ] += ".gz"; paths = Scenes.SmartFindFiles( names ); } if ( paths[ 0 ] == null || paths[ 0 ].Length == 0 ) root.InsertChild( new Sphere(), Matrix4d.Identity ); else { // B-rep scene construction: WavefrontObj objReader = new WavefrontObj(); objReader.MirrorConversion = false; SceneBrep brep = new SceneBrep(); faces = objReader.ReadBrep( paths[ 0 ], brep ); brep.BuildCornerTable(); diameter = brep.GetDiameter( out center ); TriangleMesh m = new TriangleMesh( brep ); root.InsertChild( m, Matrix4d.Identity ); } root.SetAttribute( PropertyName.REFLECTANCE_MODEL, new PhongModel() ); root.SetAttribute( PropertyName.MATERIAL, new PhongMaterial( surfaceColor, 0.2, 0.5, 0.4, 32 ) ); root.SetAttribute( PropertyName.COLOR, surfaceColor ); sc.Intersectable = root; // Background color: sc.BackgroundColor = new double[] { 0.0, 0.05, 0.07 }; // Camera: double dist = (0.5 * diameter * correction) / Math.Tan( MathHelper.DegreesToRadians( (float)(0.5 * FoVy) ) ); Vector3d cam = (Vector3d)center - dist * dir; sc.Camera = new StaticCamera( cam, dir, FoVy ); // Light sources: sc.Sources = new LinkedList<ILightSource>(); sc.Sources.Add( new AmbientLightSource( 0.8 ) ); Vector3d lightDir = Vector3d.TransformVector( dir, Matrix4d.CreateRotationY( -2.0 ) ); lightDir = Vector3d.TransformVector( lightDir, Matrix4d.CreateRotationZ( -0.8 ) ); sc.Sources.Add( new PointLightSource( (Vector3d)center + diameter * lightDir, 1.0 ) ); return faces; }
private void Evaluate(TriangleMesh triangleMesh, Corner start, Corner mid, Corner end, bool startEnabled, bool midEnabled, bool endEnabled, Vector2 reference) { if (startEnabled && endEnabled && midEnabled) { triangleMesh.AddTriangle(new Triangle( (Center.Position - reference).XYZ(Center.Height), (mid.Position - reference).XYZ(mid.Height), (start.Position - reference).XYZ(start.Height))); triangleMesh.AddTriangle(new Triangle( (end.Position - reference).XYZ(end.Height), (mid.Position - reference).XYZ(mid.Height), (Center.Position - reference).XYZ(Center.Height))); } else if (startEnabled && endEnabled) { triangleMesh.AddTriangle(new Triangle( (start.Position - reference).XYZ(start.Height), (Center.Position - reference).XYZ(Center.Height), (end.Position - reference).XYZ(end.Height))); } else if (startEnabled && !endEnabled) { triangleMesh.AddTriangle(new Triangle( (Center.Position - reference).XYZ(Center.Height), (mid.Position - reference).XYZ(mid.Height), (start.Position - reference).XYZ(start.Height))); } else if (!startEnabled && endEnabled) { triangleMesh.AddTriangle(new Triangle( (end.Position - reference).XYZ(end.Height), (mid.Position - reference).XYZ(mid.Height), (Center.Position - reference).XYZ(Center.Height))); } }
public void Triangulate(TriangleMesh mesh, Vector2 reference) { if (!CornerReference[0]) return; Corner lowerLeft = Corner[0]; Corner left = Corner[1]; Corner upperLeft = Corner[2]; Corner top = Corner[3]; Corner upperRight = Corner[4]; Corner right = Corner[5]; Corner lowerRight = Corner[6]; Corner bottom = Corner[7]; bool refLowerLeft = CornerReference[1]; bool refUpperLeft = CornerReference[2]; bool refUpperRight = CornerReference[3]; bool refLowerRight = CornerReference[4]; Evaluate(mesh, lowerLeft, bottom, lowerRight, refLowerLeft, bottom.Enabled, refLowerRight, reference); Evaluate(mesh, upperLeft, left, lowerLeft, refUpperLeft, left.Enabled, refLowerLeft, reference); Evaluate(mesh, upperRight, top, upperLeft, refUpperRight, top.Enabled, refUpperLeft, reference); Evaluate(mesh, lowerRight, right, upperRight, refLowerRight, right.Enabled, refUpperRight, reference); }
/// <summary> /// LoadContent will be called once per game and is the place to load /// all of your content. /// </summary> protected override void LoadContent() { // call LoadContent on all used components that implement it. testRasterizer.loadContent(GraphicsDevice, Content); // Load a triangle mesh. testMesh = new TriangleMesh("imrod_walk_high", Content); // Create a BFSOctree out of that mesh. testObj = new Object3D(testMesh.toBFSOctree(7), false); // Store the octree into a binary file. //testObj.getData().export("imrod.asvo"); testObj.rotate(Vector3.UnitX, MathHelper.PiOver2); System.GC.Collect(); ks = Keyboard.GetState(); }
public void SerializationXml() { var a = new TriangleMesh(); a.Add(new Triangle(new Vector3F(0, 1, 2), new Vector3F(3, 4, 5), new Vector3F(6, 7, 8)), true); a.Add(new Triangle(new Vector3F(-0, -1, -2), new Vector3F(-3, -4, -5), new Vector3F(-6, -7, -8)), true); // Serialize object. var stream = new MemoryStream(); var serializer = new XmlSerializer(typeof(TriangleMesh)); serializer.Serialize(stream, a); // Output generated xml. Can be manually checked in output window. stream.Position = 0; var xml = new StreamReader(stream).ReadToEnd(); Trace.WriteLine("Serialized Object:\n" + xml); // Deserialize object. stream.Position = 0; var deserializer = new XmlSerializer(typeof(TriangleMesh)); var b = (TriangleMesh)deserializer.Deserialize(stream); Assert.AreEqual(a.NumberOfTriangles, b.NumberOfTriangles); for (int i = 0; i < a.Vertices.Count; i++) Assert.AreEqual(a.Vertices[i], b.Vertices[i]); for (int i = 0; i < a.Indices.Count; i++) Assert.AreEqual(a.Indices[i], b.Indices[i]); }
public void GetTriangle() { Triangle t1 = new Triangle(new Vector3F(0, 0, 0), new Vector3F(1, 1, 1), new Vector3F(1, 0, 1)); TriangleMesh mesh = new TriangleMesh(); mesh.Add(t1, false); var t2 = mesh.GetTriangle(0); Assert.AreEqual(t1.Vertex0, t2.Vertex0); Assert.AreEqual(t1.Vertex1, t2.Vertex1); Assert.AreEqual(t1.Vertex2, t2.Vertex2); }
protected override void shown() { try { root = new RootDisposable(); // video objects VideoTypes videoType; #if METRO VideoTypes createVideoTypes = VideoTypes.D3D11; #elif WIN32 VideoTypes createVideoTypes = VideoTypes.D3D11 | VideoTypes.D3D9 | VideoTypes.OpenGL; #elif XNA VideoTypes createVideoTypes = VideoTypes.XNA; #endif #if WIN32 || METRO video = Video.Init(createVideoTypes, out videoType, root, this, true); #elif XNA video = Video.Create(createVideoTypes, out videoType, root, this); #endif // shaders DiffuseTextureMaterial.Init(video, "Data/", video.FileTag, ShaderVersions.Max, null); DiffuseTextureMaterial.ApplyInstanceConstantsCallback = applyDiffuseCallbackMethod; QuickDraw3ColorMaterial.Init(video, "Data/", video.FileTag, ShaderVersions.Max, null); material = new QuickDraw3ColorMaterial(); texture = Texture2DAPI.New(video, "Data/Rocks.dds", null); qd = QuickDrawAPI.New(video, QuickDraw3ColorMaterial.BufferLayoutDesc); var frame = FrameSize; viewPort = ViewPortAPI.New(video, 0, 0, frame.Width, frame.Height); float camDis = 50; camera = new Camera(viewPort, new Vector3(0, 5, camDis), new Vector3(), new Vector3(0, 5+1, camDis)); // states rasterizerState = RasterizerStateAPI.New(video, RasterizerStateDescAPI.New(RasterizerStateTypes.Solid_CullCW)); samplerState = SamplerStateAPI.New(video, SamplerStateDescAPI.New(SamplerStateTypes.Linear_Wrap)); blendState = BlendStateAPI.New(video, BlendStateDescAPI.New(BlendStateTypes.None)); depthStencilState = DepthStencilStateAPI.New(video, DepthStencilStateDescAPI.New(DepthStencilStateTypes.ReadWrite_Less)); // models var materialTypes = new Dictionary<string,Type>(); materialTypes.Add("Material", typeof(DiffuseTextureMaterial)); var materialFieldTypes = new List<MaterialFieldBinder>(); materialFieldTypes.Add(new MaterialFieldBinder("Material", "Paint_dds", "Diffuse")); var extOverrides = new Dictionary<string,string>(); var emptyBinders = new List<MaterialFieldBinder>(); sphereModel = new Model(video, "Data/sphere.rm", "Data/", materialTypes, emptyBinders, emptyBinders, emptyBinders, emptyBinders, materialFieldTypes, extOverrides, 0, null); //capsuleModel = Model.Create(videoType, video, "Data/capsule.rm", "Data/", materialTypes, emptyBinders, emptyBinders, emptyBinders, emptyBinders, materialFieldTypes, extOverrides); boxModel = new Model(video, "Data/box.rm", "Data/", materialTypes, emptyBinders, emptyBinders, emptyBinders, emptyBinders, materialFieldTypes, extOverrides, 0, null); monkeyModel = new Model(video, "Data/monkeyFlat.rm", "Data/", materialTypes, emptyBinders, emptyBinders, emptyBinders, emptyBinders, materialFieldTypes, extOverrides, 0, null); // physics collisionSystem = new CollisionSystemPersistentSAP(); world = new World(collisionSystem); world.Gravity = new JVector(0, -9.81f, 0); spheres = new RigidBody[35]; for (int i = 0; i != spheres.Length; ++i) { spheres[i] = new RigidBody(new SphereShape(1)); spheres[i].Position = new JVector(spheres.Length/(float)(i+1), (i*3)+5, 0); world.AddBody(spheres[i]); } floorBox = new RigidBody(new BoxShape(30, 1, 30)); floorBox.Shape.TransformScale = new Vector3(30, 1, 30) * .5f; floorBox.Position = new JVector(0, -7, 0); floorBox.IsStatic = true; //floorBox.Orientation = JMatrix.CreateFromYawPitchRoll(0, -.25f, 0); world.AddBody(floorBox); triangleMesh = new TriangleMesh("Data/monkeyFlat.rtmm", loadTiangleMesh); loaded = true; } catch (Exception e) { Message.Show("Error", e.Message); dispose(); } }