/// <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); } } }