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); } } }
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); }
/// <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); } } }
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"> /// 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); } } } } }
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) { // 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(); // 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); } } }
/// <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); } }
/// <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 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); } } }
// 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 the indices collections. indices.Clear(); // Transfer numbers in indicesTeapot array. int beg = TriangleRange.Begin; int end = TriangleRange.End; for (int i = 3 * beg; i < 3 * (end + 1); i++) indices.Add(indicesTeapot[i]); }
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); } } } }
private void showMove(object target, ExecutedRoutedEventArgs e) { CopyDialog dlg = new CopyDialog(); dlg.Owner = this; if (dlg.ShowDialog() == true) { string backupDB = dlg.txtDB.Text; if (txtDatabase.Text == backupDB) { System.Windows.MessageBox.Show(this, "Refusing to copy to the same database.", "Error", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error); return; } Int32Collection jobIDs = new Int32Collection(); IEnumerator den = dataGrid.SelectedItems.GetEnumerator(); while (den.MoveNext()) { DataRowView x = (DataRowView)den.Current; jobIDs.Add((int)x["ID"]); } Submission sdlg = null; do { Int32Collection subset = null; if (jobIDs.Count > 20) { subset = new Int32Collection(); for (int i = 0; i < 20; i++) { subset.Add(jobIDs[0]); jobIDs.RemoveAt(0); } } else { subset = new Int32Collection(jobIDs); jobIDs.Clear(); } sdlg = new Submission(txtDatabase.Text, backupDB, subset, true /* move */); sdlg.Owner = this; sdlg.ShowDialog(); } while (jobIDs.Count > 0 && sdlg.lastError == null); if (sdlg.lastError != null) System.Windows.MessageBox.Show(this, sdlg.lastError.Message, "Error", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error); } }
/* // 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); } } }