|
public AddTriangleFan ( IList |
||
| fanPositions | IList |
/// The points of the triangle fan. /// |
| fanNormals | IList |
/// The normal vectors of the triangle fan. /// |
| fanTextureCoordinates | IList |
/// The texture coordinates of the triangle fan. /// |
| Résultat | void | |
/// <summary>
/// Do the tessellation and return the <see cref="MeshGeometry3D"/> .
/// </summary>
/// <returns>
/// A triangular mesh geometry.
/// </returns>
protected override MeshGeometry3D Tessellate()
{
if (this.Path == null || this.Path.Count < 2)
{
return null;
}
// See also "The GLE Tubing and Extrusion Library":
// http://linas.org/gle/
// http://sharpmap.codeplex.com/Thread/View.aspx?ThreadId=18864
var builder = new MeshBuilder(false, this.TextureCoordinates != null);
var sectionXAxis = this.SectionXAxis;
if (sectionXAxis.Length < 1e-6)
{
sectionXAxis = new Vector3D(1, 0, 0);
}
var forward = this.Path[1] - this.Path[0];
var up = Vector3D.CrossProduct(forward, sectionXAxis);
if (up.LengthSquared < 1e-6)
{
sectionXAxis = forward.FindAnyPerpendicular();
}
builder.AddTube(
this.Path,
this.Angles,
this.TextureCoordinates,
this.Diameters,
this.Section,
sectionXAxis,
this.IsPathClosed,
this.IsSectionClosed);
// Add Caps if wanted and needed
if (this.AddCaps && !this.IsPathClosed && builder.Positions.Count >= Section.Count)
{
var sCount = Section.Count;
var normals = new Vector3D[sCount];
var vertices = new Point3D[sCount];
var pCount = Path.Count;
//Add back cap
var circleBack = builder.Positions.Skip(builder.Positions.Count - sCount).Take(sCount).ToArray();
var normal = Path[pCount - 1] - Path[pCount - 2];
normal.Normalize();
for (int i = 0; i < normals.Length; ++i)
{
normals[i] = normal;
}
builder.AddTriangleFan(circleBack, normals);
//Add front cap
var circleFront = builder.Positions.Take(sCount).ToArray();
normal = Path[0] - Path[1];
normal.Normalize();
for (int i = 0; i < normals.Length; ++i)
{
normals[i] = normal;
}
builder.AddTriangleFan(circleFront, normals);
}
return builder.ToMesh();
}
private static void AddCircleInZCross(MeshBuilder mb, Point3D centre, double radius, int div)
{
var points = MeshBuilder.GetCircle(div);
var vectors = new Point3DCollection();
var normals = new Vector3DCollection();
var textures = new PointCollection();
vectors.Add(new Point3D(centre.X, centre.Y, 0));
normals.Add(new Vector3D(0, 0, 1));
textures.Add(new Point(0.5, 0.5));
for (int i = 0; i < points.Count - 1; i++)
{
vectors.Add(new Point3D(points[i].X * radius + centre.X, points[i].Y * radius + centre.Y, centre.Z));
normals.Add(new Vector3D(0, 0, -1));
textures.Add(new Point(points[i].X * 0.5 + 0.5, points[i].Y * 0.5 + 0.5));
vectors.Add(new Point3D(points[i + 1].X * radius + centre.X, points[i + 1].Y * radius + centre.Y, centre.Z));
normals.Add(new Vector3D(0, 0, 01));
textures.Add(new Point(points[i + 1].X * 0.5 + 0.5, points[i + 1].Y * 0.5 + 0.5));
}
mb.AddTriangleFan(vectors, normals, textures);
}
public Model3D ToModel3D()
{
var m = new Model3DGroup();
TriangleIndexToPanelIndex = new List<int>();
// Add the triangles
var tm = new MeshBuilder(false, false);
int panelIndex = 0;
foreach (var p in Panels)
{
p.TriangleIndex = tm.Positions.Count;
tm.AddTriangleFan(p.Points);
for (int i = 0; i < p.Points.Length - 2; i++) TriangleIndexToPanelIndex.Add(panelIndex);
panelIndex++;
}
var panelsGeometry = tm.ToMesh();
m.Children.Add(new GeometryModel3D(panelsGeometry, Materials.Red) { BackMaterial = Materials.Blue });
// Add the nodes
var gm = new MeshBuilder();
foreach (var p in panelsGeometry.Positions)
{
gm.AddSphere(p, 0.05);
}
m.Children.Add(new GeometryModel3D(gm.ToMesh(), Materials.Gold));
// Add the edges
var em = new MeshBuilder();
foreach (var p in Panels)
{
for (int i = 0; i < p.Points.Length; i += 1)
{
em.AddCylinder(p.Points[i], p.Points[(i + 1) % p.Points.Length], 0.05, 10);
}
}
m.Children.Add(new GeometryModel3D(em.ToMesh(), Materials.Gray));
return m;
}
/// <summary>
/// Creates a <see cref="MeshGeometry3D" /> object from the loaded file. Polygons are triangulated using triangle fans.
/// </summary>
/// <returns>
/// A <see cref="MeshGeometry3D" />.
/// </returns>
public MeshGeometry3D CreateMeshGeometry3D()
{
var mb = new MeshBuilder(false, false);
foreach (var p in this.Vertices)
{
mb.Positions.Add(p);
}
foreach (var face in this.Faces)
{
mb.AddTriangleFan(face);
}
return mb.ToMesh();
}
/// <summary>
/// Converts the mesh to a MeshGeometry3D.
/// </summary>
/// <param name="sharedVertices">
/// Allow shared vertices (smooth shading) if set to <c>true</c> .
/// </param>
/// <param name="shrinkFactor">
/// The shrink factor.
/// </param>
/// <param name="faceIndices">
/// The face indices.
/// </param>
/// <returns>
/// A mesh geometry.
/// </returns>
public MeshGeometry3D ToMeshGeometry3D(
bool sharedVertices = true, double shrinkFactor = 0.0, List<int> faceIndices = null)
{
bool shrink = Math.Abs(shrinkFactor) > double.Epsilon;
if (!sharedVertices || shrink)
{
// not shared vertices - flat shading
var tm = new MeshBuilder(false, this.TextureCoordinates != null);
int faceIndex = 0;
foreach (var face in this.Faces)
{
var vertices = new int[face.Length];
int j = 0;
var centroid = this.FindCentroid(faceIndex);
// var n = GetFaceNormal(faceIndex);
// for (int i = 0; i < face.Length; i++)
// tm.Normals.Add(n);
foreach (int v in face)
{
vertices[j++] = tm.Positions.Count;
var vertex = this.Vertices[v];
if (shrink)
{
vertex = vertex + (shrinkFactor * (centroid - vertex));
}
tm.Positions.Add(vertex);
if (tm.CreateTextureCoordinates)
{
tm.TextureCoordinates.Add(this.TextureCoordinates[v]);
}
}
tm.AddTriangleFan(vertices);
if (faceIndices != null)
{
int numberOfTriangles = vertices.Length - 2;
for (int i = 0; i < numberOfTriangles; i++)
{
faceIndices.Add(faceIndex);
}
}
faceIndex++;
}
return tm.ToMesh();
}
else
{
// shared vertices - smooth shading
var tm = new MeshBuilder(false, this.TextureCoordinates != null);
foreach (var v in this.Vertices)
{
tm.Positions.Add(v);
}
if (this.TextureCoordinates != null)
{
foreach (var uv in this.TextureCoordinates)
{
tm.TextureCoordinates.Add(uv);
}
}
int faceIndex = 0;
foreach (var face in this.Faces)
{
tm.AddTriangleFan(face);
if (faceIndices != null)
{
int numberOfTriangles = face.Length - 2;
for (int i = 0; i < numberOfTriangles; i++)
{
faceIndices.Add(faceIndex);
}
}
faceIndex++;
}
return tm.ToMesh();
}
}
/// <summary>
/// Updates the visuals.
/// </summary>
protected void UpdateVisuals()
{
this.vertexVisuals = new Dictionary<HalfEdgeMesh.Vertex, ModelUIElement3D>();
this.halfEdgeVisuals = new Dictionary<HalfEdgeMesh.HalfEdge, ModelUIElement3D>();
this.faceVisuals = new Dictionary<HalfEdgeMesh.Face, ModelUIElement3D>();
this.Children.Clear();
if (this.Mesh == null)
{
return;
}
if (this.VertexRadius > 0)
{
// Add the vertices
foreach (var vertex in this.Mesh.Vertices)
{
var gm = new MeshBuilder(false, false);
gm.AddSubdivisionSphere(vertex.Position, this.VertexRadius, 4);
var vertexElement = new ModelUIElement3D
{
Model = new GeometryModel3D(gm.ToMesh(), this.VertexMaterial)
};
var currentVertex = vertex;
vertexElement.MouseLeftButtonDown += (s, e) => this.HighlightVertex(currentVertex);
this.vertexVisuals.Add(vertex, vertexElement);
this.Add(vertexElement);
}
}
var faceCenter = new Dictionary<HalfEdgeMesh.Face, Point3D>();
foreach (var face in this.Mesh.Faces)
{
var faceVertices = face.Vertices.Select(v => v.Position).ToList();
// Find the face centroid
var center = this.FindCentroid(faceVertices);
faceCenter.Add(face, center);
if (this.ShrinkFactor < 1)
{
// Add the faces
for (int i = 0; i < faceVertices.Count; i++)
{
faceVertices[i] += (center - faceVertices[i]) * this.ShrinkFactor;
}
var gm = new MeshBuilder(false, false);
gm.AddTriangleFan(faceVertices);
var faceElement = new ModelUIElement3D
{
Model =
new GeometryModel3D(gm.ToMesh(), this.FaceMaterial)
{
BackMaterial = this.FaceBackMaterial
}
};
var currentFace = face;
faceElement.MouseLeftButtonDown += (s, e) => this.HighlightFace(currentFace);
this.faceVisuals.Add(face, faceElement);
this.Add(faceElement);
}
}
if (this.EdgeDiameter > 0)
{
// Add the edges
foreach (var edge in this.Mesh.Edges)
{
var start = edge.StartVertex.Position;
var end = edge.EndVertex.Position;
var center = faceCenter[edge.Face];
start = start + (center - start) * this.ShrinkFactor;
end = end + (center - end) * this.ShrinkFactor;
var gm = new MeshBuilder(false, false);
gm.AddArrow(start, end, this.EdgeDiameter);
var edgeElement = new ModelUIElement3D
{
Model = new GeometryModel3D(gm.ToMesh(), this.EdgeMaterial)
};
var currentEdge = edge;
edgeElement.MouseLeftButtonDown += (s, e) => { this.HighlightEdge(currentEdge); };
this.halfEdgeVisuals.Add(edge, edgeElement);
this.Add(edgeElement);
}
}
}
