/// <summary>
/// Sets the coordinates of all the individual lines in the visual.
/// </summary>
/// <param name="args">
/// The <c>DependencyPropertyChangedEventArgs</c> object associated
/// with the property-changed event that resulted in this method
/// being called.
/// </param>
/// <param name="lines">
/// The <c>Point3DCollection</c> to be filled.
/// </param>
/// <remarks>
/// <para>
/// Classes that derive from <c>WireBase</c> override this
/// method to fill the <c>lines</c> collection.
/// It is custmary for implementations of this method to clear
/// the <c>lines</c> collection first before filling it.
/// Each pair of successive members of the <c>lines</c>
/// collection indicate one straight line.
/// </para>
/// <para>
/// The <c>WireLine</c> class implements this method by
/// clearing the <c>lines</c> collection and then adding
/// <c>Point1</c> and <c>Point2</c> to the collection.
/// </para>
/// </remarks>
protected override void Generate(DependencyPropertyChangedEventArgs args,
Point3DCollection lines)
{
lines.Clear();
lines.Add(Point1);
lines.Add(Point2);
}
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
MeshGeometry3D mesh = MeshGenerator.Geometry;
foreach (Point3D vertex in mesh.Positions)
vertices.Add(vertex);
foreach (Vector3D normal in mesh.Normals)
normals.Add(normal);
foreach (int index in mesh.TriangleIndices)
indices.Add(index);
foreach (Point texture in mesh.TextureCoordinates)
textures.Add(texture);
}
protected override void Triangulate(
DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
// Clear all four collections.
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
// Convert TextGeometry to series of closed polylines.
PathGeometry path =
TextGeometry.GetFlattenedPathGeometry(0.001,
ToleranceType.Relative);
foreach (PathFigure fig in path.Figures)
{
list.Clear();
list.Add(fig.StartPoint);
foreach (PathSegment seg in fig.Segments)
{
if (seg is LineSegment)
{
LineSegment lineseg = seg as LineSegment;
list.Add(lineseg.Point);
}
else if (seg is PolyLineSegment)
{
PolyLineSegment polyline = seg as PolyLineSegment;
for (int i = 0; i < polyline.Points.Count; i++)
list.Add(polyline.Points[i]);
}
}
// Figure is complete. Post-processing follows.
if (list.Count > 0)
{
// Remove last point if it's the same as the first.
if (list[0] == list[list.Count - 1])
list.RemoveAt(list.Count - 1);
// Convert points to Y increasing up.
for (int i = 0; i < list.Count; i++)
{
Point pt = list[i];
pt.Y = 2 * Origin.Y - pt.Y;
list[i] = pt;
}
// For each figure, process the points.
ProcessFigure(list, vertices, normals, indices, textures);
}
}
}
/// <summary>
/// Sets the coordinates of all the individual lines in the visual.
/// </summary>
/// <param name="args">
/// The <c>DependencyPropertyChangedEventArgs</c> object associated
/// with the property-changed event that resulted in this method
/// being called.
/// </param>
/// <param name="lines">
/// The <c>Point3DCollection</c> to be filled.
/// </param>
/// <remarks>
/// <para>
/// Classes that derive from <c>WireBase</c> override this
/// method to fill the <c>lines</c> collection.
/// It is custmary for implementations of this method to clear
/// the <c>lines</c> collection first before filling it.
/// Each pair of successive members of the <c>lines</c>
/// collection indicate one straight line.
/// </para>
/// </remarks>
protected override void Generate(DependencyPropertyChangedEventArgs args,
Point3DCollection lines)
{
lines.Clear();
if (Data == null)
return;
Transform3D xform = Data.Transform;
foreach (PathFigure3D fig in Data.Figures)
{
PathFigure3D figFlattened = fig.GetFlattenedPathFigure();
Point3D pointStart = xform.Transform(figFlattened.StartPoint);
foreach (PathSegment3D seg in figFlattened.Segments)
{
PolyLineSegment3D segPoly = seg as PolyLineSegment3D;
for (int i = 0; i < segPoly.Points.Count; i++)
{
lines.Add(pointStart);
Point3D point = xform.Transform(segPoly.Points[i]);
lines.Add(point);
pointStart = point;
}
}
}
}
/// <summary>
/// Sets the coordinates of all the individual lines in the visual.
/// </summary>
/// <param name="args">
/// The <c>DependencyPropertyChangedEventArgs</c> object associated
/// with the property-changed event that resulted in this method
/// being called.
/// </param>
/// <param name="lines">
/// The <c>Point3DCollection</c> to be filled.
/// </param>
/// <remarks>
/// <para>
/// Classes that derive from <c>WireBase</c> override this
/// method to fill the <c>lines</c> collection.
/// It is custmary for implementations of this method to clear
/// the <c>lines</c> collection first before filling it.
/// Each pair of successive members of the <c>lines</c>
/// collection indicate one straight line.
/// </para>
/// <para>
/// The <c>WireLines</c> class implements this method by
/// clearing the <c>lines</c> collection and then copying
/// its own <c>Lines</c> collection to it.
/// </para>
/// </remarks>
protected override void Generate(DependencyPropertyChangedEventArgs args,
Point3DCollection lines)
{
lines.Clear();
foreach (Point3D point in Lines)
lines.Add(point);
}
/// <summary>
/// Sets the coordinates of all the individual lines in the visual.
/// </summary>
/// <param name="args">
/// The <c>DependencyPropertyChangedEventArgs</c> object associated
/// with the property-changed event that resulted in this method
/// being called.
/// </param>
/// <param name="lines">
/// The <c>Point3DCollection</c> to be filled.
/// </param>
/// <remarks>
/// <para>
/// Classes that derive from <c>WireBase</c> override this
/// method to fill the <c>lines</c> collection.
/// It is custmary for implementations of this method to clear
/// the <c>lines</c> collection first before filling it.
/// Each pair of successive members of the <c>lines</c>
/// collection indicate one straight line.
/// </para>
/// <para>
/// The <c>WirePolyline</c> class implements this method by
/// clearing the <c>lines</c> collection and then breaking
/// down its <c>Points</c> collection into individual lines
/// and then adding the start and end points to the collection.
/// </para>
/// </remarks>
protected override void Generate(DependencyPropertyChangedEventArgs args,
Point3DCollection lines)
{
Point3DCollection points = Points;
lines.Clear();
for (int i = 0; i < points.Count - 1; i++)
{
lines.Add(points[i]);
lines.Add(points[i + 1]);
}
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
/// <param name="vertices"></param>
/// <param name="normals"></param>
/// <param name="indices"></param>
/// <param name="textures"></param>
protected override void Triangulate(
DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
// Clear all four collections.
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
// Fill the vertices, normals, and textures collections.
for (int stack = 0; stack <= Stacks; stack++)
{
double y = Length - stack * Length / Stacks;
for (int slice = 0; slice <= Slices; slice++)
{
double theta = slice * 2 * Math.PI / Slices;
double x = -Radius * Math.Sin(theta);
double z = -Radius * Math.Cos(theta);
normals.Add(new Vector3D(x, 0, z));
vertices.Add(new Point3D(x, y, z));
textures.Add(new Point((double)slice / Slices,
(double)stack / Stacks));
}
}
// Fill the indices collection.
for (int stack = 0; stack < Stacks; stack++)
{
for (int slice = 0; slice < Slices; slice++)
{
indices.Add((stack + 0) * (Slices + 1) + slice);
indices.Add((stack + 1) * (Slices + 1) + slice);
indices.Add((stack + 0) * (Slices + 1) + slice + 1);
indices.Add((stack + 0) * (Slices + 1) + slice + 1);
indices.Add((stack + 1) * (Slices + 1) + slice);
indices.Add((stack + 1) * (Slices + 1) + slice + 1);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
/// <param name="vertices"></param>
/// <param name="normals"></param>
/// <param name="indices"></param>
/// <param name="textures"></param>
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
// Clear all four collections.
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
double x, y, z;
int indexBase = 0;
// Front side.
// -----------
z = Depth / 2;
// Fill the vertices, normals, textures collections.
for (int stack = 0; stack <= Stacks; stack++)
{
y = Height / 2 - stack * Height / Stacks;
for (int slice = 0; slice <= Slices; slice++)
{
x = -Width / 2 + slice * Width / Slices;
Point3D point = new Point3D(x, y, z);
vertices.Add(point);
normals.Add(point - new Point3D(x, y, 0));
textures.Add(new Point((double)slice / Slices,
(double)stack / Stacks));
}
}
// Fill the indices collection.
for (int stack = 0; stack < Stacks; stack++)
{
for (int slice = 0; slice < Slices; slice++)
{
indices.Add((stack + 0) * (Slices + 1) + slice);
indices.Add((stack + 1) * (Slices + 1) + slice);
indices.Add((stack + 0) * (Slices + 1) + slice + 1);
indices.Add((stack + 0) * (Slices + 1) + slice + 1);
indices.Add((stack + 1) * (Slices + 1) + slice);
indices.Add((stack + 1) * (Slices + 1) + slice + 1);
}
}
// Rear side.
// -----------
indexBase = vertices.Count;
z = -Depth / 2;
// Fill the vertices, normals, textures collections.
for (int stack = 0; stack <= Stacks; stack++)
{
y = Height / 2 - stack * Height / Stacks;
for (int slice = 0; slice <= Slices; slice++)
{
x = Width / 2 - slice * Width / Slices;
Point3D point = new Point3D(x, y, z);
vertices.Add(point);
normals.Add(point - new Point3D(x, y, 0));
textures.Add(new Point((double)slice / Slices,
(double)stack / Stacks));
}
}
// Fill the indices collection.
for (int stack = 0; stack < Stacks; stack++)
{
for (int slice = 0; slice < Slices; slice++)
{
indices.Add(indexBase + (stack + 0) * (Slices + 1) + slice);
indices.Add(indexBase + (stack + 1) * (Slices + 1) + slice);
indices.Add(indexBase + (stack + 0) * (Slices + 1) + slice + 1);
indices.Add(indexBase + (stack + 0) * (Slices + 1) + slice + 1);
indices.Add(indexBase + (stack + 1) * (Slices + 1) + slice);
indices.Add(indexBase + (stack + 1) * (Slices + 1) + slice + 1);
}
}
// Left side.
// -----------
indexBase = vertices.Count;
x = -Width / 2;
// Fill the vertices, normals, textures collections.
for (int stack = 0; stack <= Stacks; stack++)
{
y = Height / 2 - stack * Height / Stacks;
for (int layer = 0; layer <= Layers; layer++)
{
z = -Depth / 2 + layer * Depth / Layers;
Point3D point = new Point3D(x, y, z);
vertices.Add(point);
normals.Add(point - new Point3D(0, y, z));
textures.Add(new Point((double)layer / Layers,
(double)stack / Stacks));
}
}
// Fill the indices collection.
for (int stack = 0; stack < Stacks; stack++)
{
for (int layer = 0; layer < Layers; layer++)
{
indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer);
indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer);
indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer + 1);
indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer + 1);
indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer);
indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer + 1);
}
}
// Right side.
// -----------
indexBase = vertices.Count;
x = Width / 2;
// Fill the vertices, normals, textures collections.
for (int stack = 0; stack <= Stacks; stack++)
{
y = Height / 2 - stack * Height / Stacks;
for (int layer = 0; layer <= Layers; layer++)
{
z = Depth / 2 - layer * Depth / Layers;
Point3D point = new Point3D(x, y, z);
vertices.Add(point);
normals.Add(point - new Point3D(0, y, z));
textures.Add(new Point((double)layer / Layers,
(double)stack / Stacks));
}
}
// Fill the indices collection.
for (int stack = 0; stack < Stacks; stack++)
{
for (int layer = 0; layer < Layers; layer++)
{
indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer);
indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer);
indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer + 1);
indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer + 1);
indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer);
indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer + 1);
}
}
// Top side.
// -----------
indexBase = vertices.Count;
y = Height / 2;
// Fill the vertices, normals, textures collections.
for (int layer = 0; layer <= Layers; layer++)
{
z = -Depth / 2 + layer * Depth / Layers;
for (int slice = 0; slice <= Slices; slice++)
{
x = -Width / 2 + slice * Width / Slices;
Point3D point = new Point3D(x, y, z);
vertices.Add(point);
normals.Add(point - new Point3D(x, 0, z));
textures.Add(new Point((double)slice / Slices,
(double)layer / Layers));
}
}
// Fill the indices collection.
for (int layer = 0; layer < Layers; layer++)
{
for (int slice = 0; slice < Slices; slice++)
{
indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice);
indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice);
indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice + 1);
indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice + 1);
indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice);
indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice + 1);
}
}
// Bottom side.
// -----------
indexBase = vertices.Count;
y = -Height / 2;
// Fill the vertices, normals, textures collections.
for (int layer = 0; layer <= Layers; layer++)
{
z = Depth / 2 - layer * Depth / Layers;
for (int slice = 0; slice <= Slices; slice++)
{
x = -Width / 2 + slice * Width / Slices;
Point3D point = new Point3D(x, y, z);
vertices.Add(point);
normals.Add(point - new Point3D(x, 0, z));
textures.Add(new Point((double)slice / Slices,
(double)layer / Layers));
}
}
// Fill the indices collection.
for (int layer = 0; layer < Layers; layer++)
{
for (int slice = 0; slice < Slices; slice++)
{
indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice);
indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice);
indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice + 1);
indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice + 1);
indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice);
indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice + 1);
}
}
}
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
Point3D[,] faces = Faces;
PointCollection texturesBase = TextureCoordinates;
int indexTextures = 0;
for (int face = 0; face < faces.GetLength(0); face++)
{
Vector3D normal = Vector3D.CrossProduct(faces[face, 1] - faces[face, 0],
faces[face, 2] - faces[face, 0]);
// For faces that are triangles.
if (faces.GetLength(1) == 3)
{
int indexBase = vertices.Count;
for (int i = 0; i < 3; i++)
{
vertices.Add(faces[face, i]);
normals.Add(normal);
indices.Add(indexBase + i);
if (texturesBase != null && texturesBase.Count > 0)
{
textures.Add(texturesBase[indexTextures]);
indexTextures = (indexTextures + 1) % texturesBase.Count;
}
}
if (Slices > 1)
TriangleSubdivide(vertices, normals, indices, textures);
}
// For faces that are not triangles.
else
{
for (int i = 0; i < faces.GetLength(1) - 1; i++)
{
int indexBase = vertices.Count;
int num = faces.GetLength(1) - 1;
vertices.Add(faces[face, 0]);
vertices.Add(faces[face, i + 1]);
vertices.Add(faces[face, (i + 1) % num + 1]);
if (texturesBase != null && texturesBase.Count >= faces.GetLength(1))
{
textures.Add(texturesBase[indexTextures + 0]);
textures.Add(texturesBase[indexTextures + i + 1]);
textures.Add(texturesBase[indexTextures + (i + 1) % num + 1]);
}
normals.Add(normal);
normals.Add(normal);
normals.Add(normal);
indices.Add(indexBase + 0);
indices.Add(indexBase + 1);
indices.Add(indexBase + 2);
if (Slices > 1)
TriangleSubdivide(vertices, normals, indices, textures);
}
if (texturesBase != null && texturesBase.Count > 0)
indexTextures = (indexTextures + faces.GetLength(1)) % texturesBase.Count;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
/// <param name="lines"></param>
protected override void Generate(DependencyPropertyChangedEventArgs args,
Point3DCollection lines)
{
Point3DCollection vertices = Positions;
Int32Collection indices = TriangleIndices;
lines.Clear();
if (vertices != null && vertices.Count > 0 &&
indices != null && indices.Count > 0)
{
// Check that this doesn't overflow !!!!!!
// -----------------------------------------
// Special logic if there are no indices !!!!
// -------------------------------------------
for (int i = 0; i < indices.Count; i += 3)
{
lines.Add(vertices[indices[i + 0]]);
lines.Add(vertices[indices[i + 1]]);
lines.Add(vertices[indices[i + 1]]);
lines.Add(vertices[indices[i + 2]]);
lines.Add(vertices[indices[i + 2]]);
lines.Add(vertices[indices[i + 0]]);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="args">
/// The DependencyPropertyChangedEventArgs object originally
/// passed to the PropertyChanged handler that initiated this
/// recalculation.
/// </param>
/// <param name="vertices">
/// The Point3DCollection corresponding to the Positions property
/// of the MeshGeometry3D.
/// </param>
/// <param name="normals">
/// The Vector3DCollection corresponding to the Normals property
/// of the MeshGeometry3D.
/// </param>
/// <param name="indices">
/// The Int32Collection corresponding to the TriangleIndices
/// property of the MeshGeometry3D.
/// </param>
/// <param name="textures">
/// The PointCollection corresponding to the TextureCoordinates
/// property of the MeshGeometry3D.
/// </param>
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
// Clear all four collections.
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
// Loop for outside (side = 1) and inside (side = -1).
for (int side = 1; side >= -1; side -= 2)
{
int offset = vertices.Count;
// Begin at the top end. Fill the collections.
for (int stack = 0; stack <= EndStacks; stack++)
{
double y = Length;
double radius = Radius + side * stack * Thickness / 2 / EndStacks;
int top = offset + (stack + 0) * (Slices + 1);
int bot = offset + (stack + 1) * (Slices + 1);
for (int slice = 0; slice <= Slices; slice++)
{
double theta = slice * 2 * Math.PI / Slices;
double x = -radius * Math.Sin(theta);
double z = -radius * Math.Cos(theta);
vertices.Add(new Point3D(x, y, z));
normals.Add(new Vector3D(0, side, 0));
textures.Add(new Point((double)slice / Slices,
Fold * stack / EndStacks));
if (stack < EndStacks && slice < Slices)
{
indices.Add(top + slice);
indices.Add(bot + slice);
indices.Add(top + slice + 1);
indices.Add(top + slice + 1);
indices.Add(bot + slice);
indices.Add(bot + slice + 1);
}
}
}
offset = vertices.Count;
// Length of the tube: Fill in the collections.
for (int stack = 0; stack <= Stacks; stack++)
{
double y = Length - stack * Length / Stacks;
int top = offset + (stack + 0) * (Slices + 1);
int bot = offset + (stack + 1) * (Slices + 1);
for (int slice = 0; slice <= Slices; slice++)
{
double theta = slice * 2 * Math.PI / Slices;
double x = -(Radius + side * Thickness / 2) * Math.Sin(theta);
double z = -(Radius + side * Thickness / 2) * Math.Cos(theta);
vertices.Add(new Point3D(x, y, z));
normals.Add(new Vector3D(side * x, 0, side * z));
textures.Add(new Point((double)slice / Slices,
Fold + (1 - 2 * Fold) * stack / Stacks));
if (stack < Stacks && slice < Slices)
{
indices.Add(top + slice);
indices.Add(bot + slice);
indices.Add(top + slice + 1);
indices.Add(top + slice + 1);
indices.Add(bot + slice);
indices.Add(bot + slice + 1);
}
}
}
offset = vertices.Count;
// Finish with the bottom end. Fill the collections.
for (int stack = 0; stack <= EndStacks; stack++)
{
double y = 0;
double radius = Radius + side * Thickness / 2 * (1 - (double)stack / EndStacks);
int top = offset + (stack + 0) * (Slices + 1);
int bot = offset + (stack + 1) * (Slices + 1);
for (int slice = 0; slice <= Slices; slice++)
{
double theta = slice * 2 * Math.PI / Slices;
double x = -radius * Math.Sin(theta);
double z = -radius * Math.Cos(theta);
vertices.Add(new Point3D(x, y, z));
normals.Add(new Vector3D(0, -side, 0));
textures.Add(new Point((double)slice / Slices,
(1 - Fold) + Fold * stack / EndStacks));
if (stack < EndStacks && slice < Slices)
{
indices.Add(top + slice);
indices.Add(bot + slice);
indices.Add(top + slice + 1);
indices.Add(top + slice + 1);
indices.Add(bot + slice);
indices.Add(bot + slice + 1);
}
}
}
}
}
// Define a plane consisting of two triangles.
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
if (TextGeometry == null)
return;
Rect rect = TextGeometry.Bounds;
double top = 2 * Origin.Y - rect.Top;
double bot = 2 * Origin.Y - rect.Bottom;
// Define triangle vertices.
vertices.Add(new Point3D(rect.Left, top, Z));
vertices.Add(new Point3D(rect.Right, top, Z));
vertices.Add(new Point3D(rect.Left, bot, Z));
vertices.Add(new Point3D(rect.Right, bot, Z));
// Define texture coordinates.
textures.Add(new Point(0, 0));
textures.Add(new Point(1, 0));
textures.Add(new Point(0, 1));
textures.Add(new Point(1, 1));
// Define triangle indices.
indices.Add(0);
indices.Add(2);
indices.Add(1);
indices.Add(1);
indices.Add(2);
indices.Add(3);
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
/// <param name="vertices"></param>
/// <param name="normals"></param>
/// <param name="indices"></param>
/// <param name="textures"></param>
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
// Clear all four collections.
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
// Begin at the top end. Fill the collections.
for (int stack = 0; stack <= EndStacks; stack++)
{
double y = Length;
double radius = stack * Radius / EndStacks;
int top = (stack + 0) * (Slices + 1);
int bot = (stack + 1) * (Slices + 1);
for (int slice = 0; slice <= Slices; slice++)
{
double theta = slice * 2 * Math.PI / Slices;
double x = -radius * Math.Sin(theta);
double z = -radius * Math.Cos(theta);
vertices.Add(new Point3D(x, y, z));
normals.Add(new Vector3D(0, 1, 0));
textures.Add(new Point((double)slice / Slices,
Fold * stack / EndStacks));
if (stack < EndStacks && slice < Slices)
{
if (stack != 0)
{
indices.Add(top + slice);
indices.Add(bot + slice);
indices.Add(top + slice + 1);
}
indices.Add(top + slice + 1);
indices.Add(bot + slice);
indices.Add(bot + slice + 1);
}
}
}
int offset = vertices.Count;
// Length of the cylinder: Fill in the collections.
for (int stack = 0; stack <= Stacks; stack++)
{
double y = Length - stack * Length / Stacks;
int top = offset + (stack + 0) * (Slices + 1);
int bot = offset + (stack + 1) * (Slices + 1);
for (int slice = 0; slice <= Slices; slice++)
{
double theta = slice * 2 * Math.PI / Slices;
double x = -Radius * Math.Sin(theta);
double z = -Radius * Math.Cos(theta);
vertices.Add(new Point3D(x, y, z));
normals.Add(new Vector3D(x, 0, z));
textures.Add(new Point((double)slice / Slices,
Fold + (1 - 2 * Fold) * stack / Stacks));
if (stack < Stacks && slice < Slices)
{
indices.Add(top + slice);
indices.Add(bot + slice);
indices.Add(top + slice + 1);
indices.Add(top + slice + 1);
indices.Add(bot + slice);
indices.Add(bot + slice + 1);
}
}
}
offset = vertices.Count;
// Finish with the bottom end. Fill the collections.
for (int stack = 0; stack <= EndStacks; stack++)
{
double y = 0;
double radius = (EndStacks - stack) * Radius / EndStacks;
int top = offset + (stack + 0) * (Slices + 1);
int bot = offset + (stack + 1) * (Slices + 1);
for (int slice = 0; slice <= Slices; slice++)
{
double theta = slice * 2 * Math.PI / Slices;
double x = -radius * Math.Sin(theta);
double z = -radius * Math.Cos(theta);
vertices.Add(new Point3D(x, y, z));
normals.Add(new Vector3D(0, -1, 0));
textures.Add(new Point((double)slice / Slices,
(1 - Fold) + Fold * stack / EndStacks));
if (stack < EndStacks && slice < Slices)
{
indices.Add(top + slice);
indices.Add(bot + slice);
indices.Add(top + slice + 1);
if (stack != EndStacks - 1)
{
indices.Add(top + slice + 1);
indices.Add(bot + slice);
indices.Add(bot + slice + 1);
}
}
}
}
}
protected override void Generate(DependencyPropertyChangedEventArgs args,
Point3DCollection lines)
{
lines.Clear();
txtgen.Font = Font;
txtgen.FontSize = FontSize;
txtgen.Rounding = Rounding;
txtgen.Thickness = Thickness;
txtgen.BaselineDirection = BaselineDirection;
txtgen.Origin = Origin;
txtgen.UpDirection = UpDirection;
txtgen.VerticalAlignment = VerticalAlignment;
txtgen.HorizontalAlignment = HorizontalAlignment;
txtgen.Generate(lines, Text);
}
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
// Front.
for (int iy = 0; iy <= Stacks; iy++)
{
double y = Origin.Y + Height - iy * Height / Stacks;
for (int ix = 0; ix <= Slices; ix++)
{
double x = Origin.X + ix * Width / Slices;
vertices.Add(new Point3D(x, y, Origin.Z + Depth));
}
}
// Back
for (int iy = 0; iy <= Stacks; iy++)
{
double y = Origin.Y + Height - iy * Height / Stacks;
for (int ix = 0; ix <= Slices; ix++)
{
double x = Origin.X + Width - ix * Width / Slices;
vertices.Add(new Point3D(x, y, Origin.Z));
}
}
// Left
for (int iy = 0; iy <= Stacks; iy++)
{
double y = Origin.Y + Height - iy * Height / Stacks;
for (int iz = 0; iz <= Slivers; iz++)
{
double z = Origin.Z + iz * Depth / Slivers;
vertices.Add(new Point3D(Origin.X, y, z));
}
}
// Right
for (int iy = 0; iy <= Stacks; iy++)
{
double y = Origin.Y + Height - iy * Height / Stacks;
for (int iz = 0; iz <= Slivers; iz++)
{
double z = Origin.Z + Depth - iz * Depth / Slivers;
vertices.Add(new Point3D(Origin.X + Width, y, z));
}
}
// Top
for (int iz = 0; iz <= Slivers; iz++)
{
double z = Origin.Z + iz * Depth / Slivers;
for (int ix = 0; ix <= Slices; ix++)
{
double x = Origin.X + ix * Width / Slices;
vertices.Add(new Point3D(x, Origin.Y + Height, z));
}
}
// Top
for (int iz = 0; iz <= Slivers; iz++)
{
double z = Origin.Z + Depth - iz * Depth / Slivers;
for (int ix = 0; ix <= Slices; ix++)
{
double x = Origin.X + ix * Width / Slices;
vertices.Add(new Point3D(x, Origin.Y, z));
}
}
for (int side = 0; side < 6; side++)
{
for (int iy = 0; iy <= Stacks; iy++)
{
double y = (double)iy / Stacks;
for (int ix = 0; ix <= Slices; ix++)
{
double x = (double)ix / Slices;
textures.Add(new Point(x, y));
}
}
}
// Front, back, left, right
for (int side = 0; side < 6; side++)
{
for (int iy = 0; iy < Stacks; iy++)
for (int ix = 0; ix < Slices; ix++)
{
indices.Add(side * (Slices + 1) * (Stacks + 1) + iy * (Slices + 1) + ix);
indices.Add(side * (Slices + 1) * (Stacks + 1) + (iy + 1) * (Slices + 1) + ix);
indices.Add(side * (Slices + 1) * (Stacks + 1) + iy * (Slices + 1) + ix + 1);
indices.Add(side * (Slices + 1) * (Stacks + 1) + iy * (Slices + 1) + ix + 1);
indices.Add(side * (Slices + 1) * (Stacks + 1) + (iy + 1) * (Slices + 1) + ix);
indices.Add(side * (Slices + 1) * (Stacks + 1) + (iy + 1) * (Slices + 1) + ix + 1);
}
}
}
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
// Variables for vertices collection.
Vector3D UL = (Vector3D)UpperLeft;
Vector3D UR = (Vector3D)UpperRight;
Vector3D LL = (Vector3D)LowerLeft;
Vector3D LR = (Vector3D)LowerRight;
int product = Slices * Stacks;
// Variables for textures collection
Point ptOrigin = new Point(0, 0);
Vector vectSlice = (new Point(1, 0) - ptOrigin) / Slices;
Vector vectStack = (new Point(0, 1) - ptOrigin) / Stacks;
for (int stack = 0; stack <= Stacks; stack++)
{
for (int slice = 0; slice <= Slices; slice++)
{
vertices.Add((Point3D)(((Stacks - stack) * (Slices - slice) * UL +
stack * (Slices - slice) * LL +
(Stacks - stack) * slice * UR +
stack * slice * LR) / product));
textures.Add(ptOrigin + stack * vectStack + slice * vectSlice);
if (slice < Slices && stack < Stacks)
{
indices.Add((Slices + 1) * stack + slice);
indices.Add((Slices + 1) * (stack + 1) + slice);
indices.Add((Slices + 1) * stack + slice + 1);
indices.Add((Slices + 1) * stack + slice + 1);
indices.Add((Slices + 1) * (stack + 1) + slice);
indices.Add((Slices + 1) * (stack + 1) + slice + 1);
}
}
}
}
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
// Copy properties to local variables to improve speed
int slices = Slices;
int stacks = Stacks;
double radius = Radius;
Point3D ctr = Center;
double lat1 = Math.Max(LatitudeFrom, LatitudeTo); // default is 90
double lat2 = Math.Min(LatitudeFrom, LatitudeTo); // default is -90
double lng1 = LongitudeFrom; // default is -180
double lng2 = LongitudeTo; // default is 180
for (int lat = 0; lat <= stacks; lat++)
{
double degrees = lat1 - lat * (lat1 - lat2) / stacks;
double angle = Math.PI * degrees / 180;
double y = radius * Math.Sin(angle);
double scale = Math.Cos(angle);
for (int lng = 0; lng <= slices; lng++)
{
double diff = lng2 - lng1;
if (diff < 0)
diff += 360;
degrees = lng1 + lng * diff / slices;
angle = Math.PI * degrees / 180;
double x = radius * scale * Math.Sin(angle);
double z = radius * scale * Math.Cos(angle);
Vector3D vect = new Vector3D(x, y, z);
vertices.Add(ctr + vect);
normals.Add(vect);
textures.Add(new Point((double)lng / slices,
(double)lat / stacks));
}
}
for (int lat = 0; lat < stacks; lat++)
{
int start = lat * (slices + 1);
int next = start + slices + 1;
for (int lng = 0; lng < slices; lng++)
{
indices.Add(start + lng);
indices.Add(next + lng);
indices.Add(next + lng + 1);
indices.Add(start + lng);
indices.Add(next + lng + 1);
indices.Add(start + lng + 1);
}
}
}
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
// vectRearRadius points towards -Z (when possible).
Vector3D vectCylinder = Point2 - Point1;
Vector3D vectRearRadius;
if (vectCylinder.X == 0 && vectCylinder.Y == 0)
{
// Special case: set rear-radius vector
vectRearRadius = new Vector3D(0, -1, 0);
}
else
{
// Find vector axis 90 degrees from cylinder where Z == 0
rotate.Axis = Vector3D.CrossProduct(vectCylinder, new Vector3D(0, 0, 1));
rotate.Angle = -90;
// Rotate cylinder 90 degrees to find radius vector
vectRearRadius = vectCylinder * xform.Value;
vectRearRadius.Normalize();
}
// Will rotate radius around cylinder axis
rotate.Axis = -vectCylinder;
// Begin at the top end. Fill the collections.
for (int stack = 0; stack <= EndStacks; stack++)
{
double radius = stack * Radius1 / EndStacks;
Vector3D vectRadius = radius * vectRearRadius;
int top = (stack + 0) * (Slices + 1);
int bot = (stack + 1) * (Slices + 1);
for (int slice = 0; slice <= Slices; slice++)
{
rotate.Angle = slice * 360.0 / Slices;
vertices.Add(Point1 + vectRadius * xform.Value);
normals.Add(-vectCylinder);
textures.Add(new Point((double)slice / Slices,
Fold1 * stack / EndStacks));
if (stack < EndStacks && slice < Slices)
{
if (stack != 0)
{
indices.Add(top + slice);
indices.Add(bot + slice);
indices.Add(top + slice + 1);
}
indices.Add(top + slice + 1);
indices.Add(bot + slice);
indices.Add(bot + slice + 1);
}
}
}
int offset = vertices.Count;
// Go down length of cylinder and fill in the collections.
for (int stack = 0; stack <= Stacks; stack++)
{
double radius = ((Stacks - stack) * Radius1 + stack * Radius2) / Stacks;
Vector3D vectRadius = radius * vectRearRadius;
Point3D center = (Point3D) (Point1 + stack * vectCylinder / Stacks);
int top = offset + (stack + 0) * (Slices + 1);
int bot = offset + (stack + 1) * (Slices + 1);
for (int slice = 0; slice <= Slices; slice++)
{
rotate.Angle = slice * 360.0 / Slices;
Vector3D normal = vectRadius * xform.Value;
normals.Add(normal);
vertices.Add(center + normal);
textures.Add(new Point((double)slice / Slices,
Fold1 + (Fold2 - Fold1) * stack / Stacks));
if (stack < Stacks && slice < Slices)
{
indices.Add(top + slice);
indices.Add(bot + slice);
indices.Add(top + slice + 1);
indices.Add(top + slice + 1);
indices.Add(bot + slice);
indices.Add(bot + slice + 1);
}
}
}
offset = vertices.Count;
// Finish with bottom.
for (int stack = 0; stack <= EndStacks; stack++)
{
double radius = Radius2 * (1 - (double)stack / EndStacks);
Vector3D vectRadius = radius * vectRearRadius;
int top = offset + (stack + 0) * (Slices + 1);
int bot = offset + (stack + 1) * (Slices + 1);
for (int slice = 0; slice <= Slices; slice++)
{
rotate.Angle = slice * 360.0 / Slices;
vertices.Add(Point2 + vectRadius * xform.Value);
normals.Add(vectCylinder);
textures.Add(new Point((double)slice / Slices,
Fold2 + (1 - Fold2) * stack / EndStacks));
if (stack < EndStacks && slice < Slices)
{
indices.Add(top + slice);
indices.Add(bot + slice);
indices.Add(top + slice + 1);
if (stack != EndStacks - 1)
{
indices.Add(top + slice + 1);
indices.Add(bot + slice);
indices.Add(bot + slice + 1);
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
/// <param name="vertices"></param>
/// <param name="normals"></param>
/// <param name="indices"></param>
/// <param name="textures"></param>
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
Vector3D normal = new Vector3D(0, 0, 1);
double angleInner = 2 * Math.PI / Sides;
double radius = Length / 2 / Math.Sin(angleInner / 2);
double angle = 3 * Math.PI / 2 + angleInner / 2;
double xMin = 0, xMax = 0, yMin = 0, yMax = 0;
for (int side = 0; side < Sides; side++)
{
double x = Math.Cos(angle);
double y = Math.Sin(angle);
xMin = Math.Min(xMin, x);
xMax = Math.Max(xMax, x);
yMin = Math.Min(yMin, y);
yMax = Math.Max(yMax, y);
angle += angleInner;
}
angle = 3 * Math.PI / 2 + angleInner / 2;
for (int side = 0; side < Sides; side++)
{
vertices.Add(new Point3D(0, 0, 0));
textures.Add(new Point(-xMin / (xMax - xMin), yMax / (yMax - yMin)));
normals.Add(normal);
double x = Math.Cos(angle);
double y = Math.Sin(angle);
vertices.Add(new Point3D(x, y, 0));
textures.Add(new Point((x - xMin) / (xMax - xMin),
(yMax - y) / (yMax - yMin)));
normals.Add(normal);
angle += angleInner;
x = Math.Cos(angle);
y = Math.Sin(angle);
vertices.Add(new Point3D(x, y, 0));
textures.Add(new Point((x - xMin) / (xMax - xMin),
(yMax - y) / (yMax - yMin)));
normals.Add(normal);
int index = vertices.Count - 3;
indices.Add(index);
indices.Add(index + 1);
indices.Add(index + 2);
if (Slices > 1)
TriangleSubdivide(vertices, normals, indices, textures);
}
}
protected override void Generate(DependencyPropertyChangedEventArgs args,
Point3DCollection lines)
{
lines.Clear();
// X axis.
lines.Add(new Point3D(-Extent, 0, 0));
lines.Add(new Point3D(Extent, 0, 0));
// Y axis.
lines.Add(new Point3D(0, -Extent, 0));
lines.Add(new Point3D(0, Extent, 0));
// Z axis.
lines.Add(new Point3D(0, 0, -Extent));
lines.Add(new Point3D(0, 0, Extent));
double extent = ((int)Extent + UnitsPerBigTick - 1) / UnitsPerBigTick * UnitsPerBigTick;
int smallTicks = (int)(extent * SmallTicksPerBigTick / UnitsPerBigTick);
for (int i = -smallTicks; i <= smallTicks; i++)
{
double tick = (i % SmallTicksPerBigTick == 0) ? LargeTick : SmallTick;
tick *= UnitsPerBigTick;
double d = (double)i * UnitsPerBigTick / SmallTicksPerBigTick;
// X axis tick marks.
lines.Add(new Point3D(d, -tick, 0));
lines.Add(new Point3D(d, tick, 0));
// Y axis tick marks.
lines.Add(new Point3D(-tick, d, 0));
lines.Add(new Point3D(tick, d, 0));
// Z axis tick marks.
lines.Add(new Point3D(0, -tick, d));
lines.Add(new Point3D(0, tick, d));
txtgen.Font = Font;
txtgen.FontSize = FontSize * UnitsPerBigTick;
txtgen.Thickness = Thickness;
txtgen.Rounding = Rounding;
txtgen.BaselineDirection = new Vector3D(1, 0, 0);
txtgen.UpDirection = new Vector3D(0, 1, 0);
if (i != 0 && i % SmallTicksPerBigTick == 0)
{
string str = ((int)d).ToString();
bool isEnd = (i == -smallTicks) || (i == smallTicks);
string strPrefix = (i == -smallTicks) ? "-" : "+";
// X axis numbers and labels.
if (isEnd && Labels != null)
str = strPrefix + Labels.Substring(0, Labels.Length / 3);
if (isEnd || ShowNumbers)
{
txtgen.Origin = new Point3D(d, -tick * 1.25, 0);
txtgen.HorizontalAlignment = HorizontalAlignment.Center;
txtgen.VerticalAlignment = VerticalAlignment.Top;
txtgen.Generate(lines, str);
}
// Y axis numbers and labels.
if (isEnd)
str = strPrefix + Labels.Substring(Labels.Length / 3, Labels.Length / 3);
if (isEnd || ShowNumbers)
{
txtgen.Origin = new Point3D(tick * 1.25, d, 0);
txtgen.HorizontalAlignment = HorizontalAlignment.Left;
txtgen.VerticalAlignment = VerticalAlignment.Center;
txtgen.Generate(lines, str);
}
// Want to make Z either viewed from left or right !!!!!!!!!!!!!!!!!!
// Z axis numbers and labels.
if (isEnd)
str = strPrefix + Labels.Substring(2 * Labels.Length / 3);
if (isEnd || ShowNumbers)
{
txtgen.Origin = new Point3D(0, -tick * 1.25, d);
txtgen.BaselineDirection = new Vector3D(0, 0, 1);
txtgen.HorizontalAlignment = HorizontalAlignment.Center;
txtgen.VerticalAlignment = VerticalAlignment.Top;
txtgen.Generate(lines, str);
}
}
}
}
/*
// Static method called for any property change.
static void PropertyChanged(DependencyObject obj,
DependencyPropertyChangedEventArgs args)
{
(obj as TorusMesh).PropertyChanged(args);
}
*/
/// <summary>
///
/// </summary>
/// <param name="args"></param>
/// <param name="vertices"></param>
/// <param name="normals"></param>
/// <param name="indices"></param>
/// <param name="textures"></param>
protected override void Triangulate(DependencyPropertyChangedEventArgs args,
Point3DCollection vertices,
Vector3DCollection normals,
Int32Collection indices,
PointCollection textures)
{
// Clear all four collections.
vertices.Clear();
normals.Clear();
indices.Clear();
textures.Clear();
// Fill the vertices, normals, and textures collections.
for (int stack = 0; stack <= Stacks; stack++)
{
double phi = stack * 2 * Math.PI / Stacks;
double xCenter = Radius * Math.Sin(phi);
double yCenter = Radius * Math.Cos(phi);
Point3D pointCenter = new Point3D(xCenter, yCenter, 0);
for (int slice = 0; slice <= Slices; slice++)
{
double theta = slice * 2 * Math.PI / Slices + Math.PI;
double x = (Radius + TubeRadius * Math.Cos(theta)) * Math.Sin(phi);
double y = (Radius + TubeRadius * Math.Cos(theta)) * Math.Cos(phi);
double z = -TubeRadius * Math.Sin(theta);
Point3D point = new Point3D(x, y, z);
vertices.Add(point);
normals.Add(point - pointCenter);
textures.Add(new Point((double)slice / Slices,
(double)stack / Stacks));
}
}
// Fill the indices collection.
for (int stack = 0; stack < Stacks; stack++)
{
for (int slice = 0; slice < Slices; slice++)
{
indices.Add((stack + 0) * (Slices + 1) + slice);
indices.Add((stack + 1) * (Slices + 1) + slice);
indices.Add((stack + 0) * (Slices + 1) + slice + 1);
indices.Add((stack + 0) * (Slices + 1) + slice + 1);
indices.Add((stack + 1) * (Slices + 1) + slice);
indices.Add((stack + 1) * (Slices + 1) + slice + 1);
}
}
}