Exemple #1
0
        /// <summary>
        /// Generates a square grid with a step of 1.0
        /// </summary>
        /// <returns></returns>
        public static LineGeometry3D GenerateGrid(Vector3 plane, int min = 0, int max = 10)
        {
            var grid = new LineBuilder();

            //int width = max - min;
            if (plane == Vector3.UnitX)
            {
                for (int i = min; i <= max; i++)
                {
                    grid.AddLine(new Vector3(0, i, min), new Vector3(0, i, max));
                    grid.AddLine(new Vector3(0, min, i), new Vector3(0, max, i));
                }
            }
            else if (plane == Vector3.UnitY)
            {
                for (int i = min; i <= max; i++)
                {
                    grid.AddLine(new Vector3(i, 0, min), new Vector3(i, 0, max));
                    grid.AddLine(new Vector3(min, 0, i), new Vector3(max, 0, i));
                }
            }
            else
            {
                for (int i = min; i <= max; i++)
                {
                    grid.AddLine(new Vector3(i, min, 0), new Vector3(i, max, 0));
                    grid.AddLine(new Vector3(min, i, 0), new Vector3(max, i, 0));
                }
            }

            return(grid.ToLineGeometry3D());
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="plane"></param>
        /// <param name="radius"></param>
        /// <param name="segments"></param>
        /// <returns></returns>
        public static LineGeometry3D GenerateCircle(Vector3 plane, float radius, int segments)
        {
            var bd = new LineBuilder();

            bd.AddCircle(Vector3.Zero, plane, radius, segments);
            return(bd.ToLineGeometry3D());
        }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="p1"></param>
 /// <param name="p2"></param>
 public void AddLine(Point3D p1, Point3D p2)
 {
     int i0 = positions.Count;
     this.positions.Add(p1);
     this.positions.Add(p2);
     this.lineListIndices.Add(i0);
     this.lineListIndices.Add(i0 + 1);
 }
Exemple #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="ray"></param>
        /// <param name="t0"></param>
        /// <param name="t1"></param>
        /// <param name="sp"></param>
        /// <param name="tp"></param>
        /// <param name="sc"></param>
        /// <param name="tc"></param>
        /// <returns></returns>
        public static float GetRayToLineDistance(
            Ray ray, Vector3 t0, Vector3 t1, out Vector3 sp, out Vector3 tp, out float sc, out float tc)
        {
            var s0 = ray.Position;
            var s1 = ray.Position + ray.Direction;

            return(GetLineToLineDistance(s0, s1, t0, t1, out sp, out tp, out sc, out tc, true));
        }
Exemple #5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="p1"></param>
        /// <param name="p2"></param>
        public void AddLine(Point3D p1, Point3D p2)
        {
            int i0 = positions.Count;

            this.positions.Add(p1);
            this.positions.Add(p2);
            this.lineListIndices.Add(i0);
            this.lineListIndices.Add(i0 + 1);
        }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="center"></param>
 /// <param name="xlength"></param>
 /// <param name="ylength"></param>
 /// <param name="zlength"></param>
 public void AddBox(Point3D center, double xlength, double ylength, double zlength)
 {
     int i0 = positions.Count;
     var dx = new Vector3D((float)xlength/2f, 0, 0);
     var dy = new Vector3D(0, (float)ylength/2f, 0);
     var dz = new Vector3D(0, 0, (float)zlength/2f);
     this.Add(true, center - dx - dy - dz, center + dx - dy - dz, center + dx + dy - dz, center - dx + dy - dz);
     this.Add(true, center - dx - dy + dz, center + dx - dy + dz, center + dx + dy + dz, center - dx + dy + dz);
     lineListIndices.AddRange(new[] { i0 + 0, i0 + 4, i0 + 1, i0 + 5, i0 + 2, i0 + 6, i0 + 3, i0 + 7 });
 }
Exemple #7
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="center"></param>
        /// <param name="xlength"></param>
        /// <param name="ylength"></param>
        /// <param name="zlength"></param>
        public void AddBox(Point3D center, double xlength, double ylength, double zlength)
        {
            int i0 = positions.Count;
            var dx = new Vector3D((float)xlength / 2f, 0, 0);
            var dy = new Vector3D(0, (float)ylength / 2f, 0);
            var dz = new Vector3D(0, 0, (float)zlength / 2f);

            this.Add(true, center - dx - dy - dz, center + dx - dy - dz, center + dx + dy - dz, center - dx + dy - dz);
            this.Add(true, center - dx - dy + dz, center + dx - dy + dz, center + dx + dy + dz, center - dx + dy + dz);
            lineListIndices.AddRange(new[] { i0 + 0, i0 + 4, i0 + 1, i0 + 5, i0 + 2, i0 + 6, i0 + 3, i0 + 7 });
        }
        /// <summary>
        /// Adds the circle.
        /// </summary>
        /// <param name="position">The position.</param>
        /// <param name="normal">The normal.</param>
        /// <param name="radius">The radius.</param>
        /// <param name="segments">The segments.</param>
        public void AddCircle(Vector3 position, Vector3 normal, float radius, int segments)
        {
            if (segments < 3)
            {
                throw new ArgumentNullException("too few segments, at least 3");
            }
            normal.Normalize();
            float sectionAngle = (float)(2.0 * Math.PI / segments);
            var   start        = new Vector3(radius, 0.0f, 0.0f);
            var   current      = new Vector3(radius, 0.0f, 0.0f);
            var   next         = new Vector3(0.0f, 0.0f, 0.0f);
            int   posStart     = positions.Count;

            positions.Add(current);
            int currIndex = posStart;

            for (int i = 1; i < segments; i++)
            {
                next.X  = radius * (float)Math.Cos(i * sectionAngle);
                next.Z  = radius * (float)Math.Sin(i * sectionAngle);
                current = next;
                positions.Add(current);
                lineListIndices.Add(currIndex);
                lineListIndices.Add(++currIndex);
            }

            lineListIndices.Add(currIndex);
            lineListIndices.Add(posStart);
            var axis      = Vector3.Cross(Vector3.UnitY, normal);
            var transform = Matrix.Translation(position);

            if (axis.LengthSquared() > 1e-6)
            {
                axis.Normalize();
                transform = Matrix.RotationAxis(axis, (float)Math.Acos(Vector3.Dot(Vector3.UnitY, normal))) * transform;
            }

            for (int i = posStart; i < positions.Count; ++i)
            {
                positions[i] = Vector3.TransformCoordinate(positions[i], transform);
            }
        }
Exemple #9
0
        /// <summary>
        /// ~7874015 tests per second, 3.36 times faster than GetRayToLineDistance()
        /// </summary>
        /// <param name="pt"></param>
        /// <param name="p0"></param>
        /// <param name="p1"></param>
        /// <param name="closest"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public static float GetPointToLineDistance2D(ref Vector3 pt, ref Vector3 p0, ref Vector3 p1, out Vector3 closest, out float t)
        {
            float dx = p1.X - p0.X;
            float dy = p1.Y - p0.Y;

            if (Math.Abs(dx) < float.Epsilon && Math.Abs(dy) < float.Epsilon)
            {
                // The points are too close together.
                closest = p0;
                dx      = pt.X - p0.X;
                dy      = pt.Y - p0.Y;
                t       = 0f;
                return((float)Math.Sqrt(dx * dx + dy * dy));
            }

            // Calculate scale factor t of intersection.
            t = ((pt.X - p0.X) * dx + (pt.Y - p0.Y) * dy) / (dx * dx + dy * dy);

            // Test, if t inside line bounds.
            if (t < 0)
            {
                closest = new Vector3(p0.X, p0.Y, p0.Z);
                t       = 0f;
                dx      = pt.X - p0.X;
                dy      = pt.Y - p0.Y;
            }
            else if (t > 1)
            {
                closest = new Vector3(p1.X, p1.Y, p1.Z);
                t       = 1f;
                dx      = pt.X - p1.X;
                dy      = pt.Y - p1.Y;
            }
            else
            {
                closest = new Vector3(p0.X + t * dx, p0.Y + t * dy, pt.Z);
                dx      = pt.X - closest.X;
                dy      = pt.Y - closest.Y;
            }

            return((float)Math.Sqrt(dx * dx + dy * dy));
        }
Exemple #10
0
        public static LineGeometry3D GenerateGrid(Vector3 plane, int min0 = 0, int max0 = 10, int min1 = 0, int max1 = 10, int sizew = 1, int sizeh = 1)
        {
            var grid = new LineBuilder();

            //int width = max - min;
            if (plane == Vector3.UnitX)
            {
                for (int i = min0; i <= max0; i += sizew)
                {
                    grid.AddLine(new Vector3(0, i, min1), new Vector3(0, i, max1));
                }
                for (int i = min1; i <= max1; i += sizeh)
                {
                    grid.AddLine(new Vector3(0, min0, i), new Vector3(0, max0, i));
                }
            }
            else if (plane == Vector3.UnitY)
            {
                for (int i = min0; i <= max0; i += sizew)
                {
                    grid.AddLine(new Vector3(i, 0, min1), new Vector3(i, 0, max1));
                }
                for (int i = min1; i <= max1; i += sizeh)
                {
                    grid.AddLine(new Vector3(min0, 0, i), new Vector3(max0, 0, i));
                }
            }
            else
            {
                for (int i = min0; i <= max0; i += sizew)
                {
                    grid.AddLine(new Vector3(i, min1, 0), new Vector3(i, max1, 0));
                }
                for (int i = min1; i <= max1; i += sizeh)
                {
                    grid.AddLine(new Vector3(min0, i, 0), new Vector3(max0, i, 0));
                }
            }

            return(grid.ToLineGeometry3D());
        }
Exemple #11
0
        /// <summary>
        /// Source: http://geomalgorithms.com/a07-_distance.html
        /// ~2341920 tests per second</summary>
        /// <param name="s0"></param>
        /// <param name="s1"></param>
        /// <param name="t0"></param>
        /// <param name="t1"></param>
        /// <param name="sp"></param>
        /// <param name="tp"></param>
        /// <param name="sc"></param>
        /// <param name="tc"></param>
        /// <param name="sIsRay"></param>
        /// <returns></returns>
        public static float GetLineToLineDistance(
            Vector3 s0, Vector3 s1, Vector3 t0, Vector3 t1, out Vector3 sp, out Vector3 tp, out float sc, out float tc, bool sIsRay = false)
        {
            Vector3 u = s1 - s0;
            Vector3 v = t1 - t0;
            Vector3 w = s0 - t0;

            float a = Vector3.Dot(u, u); // always >= 0
            float b = Vector3.Dot(u, v);
            float c = Vector3.Dot(v, v); // always >= 0
            float d = Vector3.Dot(u, w);
            float e = Vector3.Dot(v, w);
            float D = a * c - b * b;     // always >= 0
            float sN, sD = D;            // sc = sN / sD, default sD = D >= 0
            float tN, tD = D;            // tc = tN / tD, default tD = D >= 0

            // compute the line parameters of the two closest points
            if (D < float.Epsilon)
            {
                // the lines are almost parallel
                sN = 0.0f; // force using point P0 on segment S1
                sD = 1.0f; // to prevent possible division by 0.0 later
                tN = e;
                tD = c;
            }
            else
            {
                // get the closest points on the infinite lines
                sN = (b * e - c * d);
                tN = (a * e - b * d);

                if (!sIsRay)
                {
                    if (sN < 0.0f)
                    {
                        // sc < 0 => the s=0 edge is visible
                        sN = 0.0f;
                        tN = e;
                        tD = c;
                    }
                    else if (sN > sD)
                    {
                        // sc > 1  => the s=1 edge is visible
                        sN = sD;
                        tN = e + b;
                        tD = c;
                    }
                }
            }

            if (tN < 0.0f)
            {
                // tc < 0 => the t=0 edge is visible
                tN = 0.0f;
                // recompute sc for this edge
                if (-d < 0.0f)
                {
                    sN = 0.0f;
                }
                else if (-d > a)
                {
                    sN = sD;
                }
                else
                {
                    sN = -d;
                    sD = a;
                }
            }
            else if (tN > tD)
            {
                // tc > 1  => the t=1 edge is visible
                tN = tD;
                // recompute sc for this edge
                if ((-d + b) < 0.0f)
                {
                    sN = 0;
                }
                else if ((-d + b) > a)
                {
                    sN = sD;
                }
                else
                {
                    sN = (-d + b);
                    sD = a;
                }
            }

            // finally do the division to get sc and tc
            sc = (Math.Abs(sN) < float.Epsilon ? 0.0f : sN / sD);
            tc = (Math.Abs(tN) < float.Epsilon ? 0.0f : tN / tD);

            // get the difference of the two closest points
            sp = s0 + (sc * u);
            tp = t0 + (tc * v);
            var tv = sp - tp;

            return(tv.Length()); // return the closest distance
        }
Exemple #12
0
 public static global::SharpDX.Color4 ToColor4(this global::SharpDX.Vector3 vector, float w = 1f)
 {
     return(new global::SharpDX.Color4((float)vector.X, (float)vector.Y, (float)vector.Z, w));
 }
Exemple #13
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="plane"></param>
        /// <param name="radius"></param>
        /// <param name="segments"></param>
        /// <returns></returns>
        public static LineGeometry3D GenerateCircle(Vector3 plane, float radius, int segments)
        {
            if (segments < 3)
            {
                throw new ArgumentNullException("too few segments, at least 3");
            }

            var circle = new LineBuilder();

            float sectionAngle = (float)(2.0 * Math.PI / segments);

            if (plane == Vector3.UnitX)
            {
                Point3D start   = new Point3D(0.0f, 0.0f, radius);
                Point3D current = new Point3D(0.0f, 0.0f, radius);
                Point3D next    = new Point3D(0.0f, 0.0f, 0.0f);

                for (int i = 1; i < segments; i++)
                {
                    next.Z = radius * (float)Math.Cos(i * sectionAngle);
                    next.Y = radius * (float)Math.Sin(i * sectionAngle);

                    circle.AddLine(current, next);

                    current = next;
                }

                circle.AddLine(current, start);
            }
            else if (plane == Vector3.UnitY)
            {
                Point3D start   = new Point3D(radius, 0.0f, 0.0f);
                Point3D current = new Point3D(radius, 0.0f, 0.0f);
                Point3D next    = new Point3D(0.0f, 0.0f, 0.0f);

                for (int i = 1; i < segments; i++)
                {
                    next.X = radius * (float)Math.Cos(i * sectionAngle);
                    next.Z = radius * (float)Math.Sin(i * sectionAngle);

                    circle.AddLine(current, next);

                    current = next;
                }

                circle.AddLine(current, start);
            }
            else
            {
                Point3D start   = new Point3D(0.0f, radius, 0.0f);
                Point3D current = new Point3D(0.0f, radius, 0.0f);
                Point3D next    = new Point3D(0.0f, 0.0f, 0.0f);

                for (int i = 1; i < segments; i++)
                {
                    next.Y = radius * (float)Math.Cos(i * sectionAngle);
                    next.X = radius * (float)Math.Sin(i * sectionAngle);

                    circle.AddLine(current, next);

                    current = next;
                }

                circle.AddLine(current, start);
            }

            return(circle.ToLineGeometry3D());
        }
Exemple #14
0
 public static global::SharpDX.Vector3 Normalized(this global::SharpDX.Vector3 vector)
 {
     vector.Normalize();
     return(vector);
 }
        /// <summary>
        /// Generates a square grid with a step of 1.0 
        /// </summary>
        /// <returns></returns>
        public static LineGeometry3D GenerateGrid(Vector3 plane, int min = 0, int max = 10)
        {
            var grid = new LineBuilder();
            //int width = max - min;
            if (plane == Vector3.UnitX)
            {
                for (int i = min; i <= max; i++)
                {
                    grid.AddLine(new Vector3(0, i, min), new Vector3(0, i, max));
                    grid.AddLine(new Vector3(0, min, i), new Vector3(0, max, i));
                }
            }
            else if (plane == Vector3.UnitY)
            {
                for (int i = min; i <= max; i++)
                {
                    grid.AddLine(new Vector3(i, 0, min), new Vector3(i, 0, max));
                    grid.AddLine(new Vector3(min, 0, i), new Vector3(max, 0, i));
                }
            }
            else
            {
                for (int i = min; i <= max; i++)
                {
                    grid.AddLine(new Vector3(i, min, 0), new Vector3(i, max, 0));
                    grid.AddLine(new Vector3(min, i, 0), new Vector3(max, i, 0));
                }
            }

            return grid.ToLineGeometry3D();
        }
 /// <summary>
 /// Returns a line geometry of the axis-aligned bounding-box of the given mesh.
 /// </summary>
 /// <param name="mesh">Input mesh for the computation of the b-box</param>
 /// <returns></returns>
 public static LineGeometry3D GenerateBoundingBox(Vector3[] points)
 {
     var bb = global::SharpDX.BoundingBox.FromPoints(points);
     return GenerateBoundingBox(bb);
 }
        /// <summary>
        /// Source: http://geomalgorithms.com/a07-_distance.html
        /// ~2341920 tests per second</summary>
        /// <param name="s0"></param>
        /// <param name="s1"></param>
        /// <param name="t0"></param>
        /// <param name="t1"></param>
        /// <param name="sp"></param>
        /// <param name="tp"></param>
        /// <param name="sc"></param>
        /// <param name="tc"></param>
        /// <param name="sIsRay"></param>
        /// <returns></returns>
        public static float GetLineToLineDistance(
            Vector3 s0, Vector3 s1, Vector3 t0, Vector3 t1, out Vector3 sp, out Vector3 tp, out float sc, out float tc, bool sIsRay = false)
        {
            Vector3 u = s1 - s0;
            Vector3 v = t1 - t0;
            Vector3 w = s0 - t0;

            float a = Vector3.Dot(u, u); // always >= 0
            float b = Vector3.Dot(u, v);
            float c = Vector3.Dot(v, v); // always >= 0
            float d = Vector3.Dot(u, w);
            float e = Vector3.Dot(v, w);
            float D = a * c - b * b;     // always >= 0
            float sN, sD = D;            // sc = sN / sD, default sD = D >= 0
            float tN, tD = D;            // tc = tN / tD, default tD = D >= 0

            // compute the line parameters of the two closest points
            if (D < float.Epsilon)
            {
                // the lines are almost parallel
                sN = 0.0f; // force using point P0 on segment S1
                sD = 1.0f; // to prevent possible division by 0.0 later
                tN = e;
                tD = c;
            }
            else
            {
                // get the closest points on the infinite lines
                sN = (b * e - c * d);
                tN = (a * e - b * d);

                if (!sIsRay)
                {
                    if (sN < 0.0f)
                    {
                        // sc < 0 => the s=0 edge is visible
                        sN = 0.0f;
                        tN = e;
                        tD = c;
                    }
                    else if (sN > sD)
                    {
                        // sc > 1  => the s=1 edge is visible
                        sN = sD;
                        tN = e + b;
                        tD = c;
                    }                    
                }
            }

            if (tN < 0.0f)
            {
                // tc < 0 => the t=0 edge is visible
                tN = 0.0f;
                // recompute sc for this edge
                if (-d < 0.0f)
                {
                    sN = 0.0f;
                }
                else if (-d > a)
                {
                    sN = sD;
                }
                else
                {
                    sN = -d;
                    sD = a;
                }
            }
            else if (tN > tD)
            {
                // tc > 1  => the t=1 edge is visible
                tN = tD;
                // recompute sc for this edge
                if ((-d + b) < 0.0f)
                {
                    sN = 0;
                }
                else if ((-d + b) > a)
                {
                    sN = sD;
                }
                else
                {
                    sN = (-d + b);
                    sD = a;
                }
            }

            // finally do the division to get sc and tc
            sc = (Math.Abs(sN) < float.Epsilon ? 0.0f : sN / sD);
            tc = (Math.Abs(tN) < float.Epsilon ? 0.0f : tN / tD);

            // get the difference of the two closest points
            sp = s0 + (sc * u);
            tp = t0 + (tc * v);
            var tv = sp - tp;

            return tv.Length(); // return the closest distance
        }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="ray"></param>
 /// <param name="t0"></param>
 /// <param name="t1"></param>
 /// <param name="sp"></param>
 /// <param name="tp"></param>
 /// <param name="sc"></param>
 /// <param name="tc"></param>
 /// <returns></returns>
 public static float GetRayToLineDistance(
     Ray ray, Vector3 t0, Vector3 t1, out Vector3 sp, out Vector3 tp, out float sc, out float tc)
 {
     var s0 = ray.Position;
     var s1 = ray.Position + ray.Direction;
     return GetLineToLineDistance(s0, s1, t0, t1, out sp, out tp, out sc, out tc, true);
 }
        /// <summary>
        /// ~7874015 tests per second, 3.36 times faster than GetRayToLineDistance()
        /// </summary>
        /// <param name="pt"></param>
        /// <param name="p0"></param>
        /// <param name="p1"></param>
        /// <param name="closest"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public static float GetPointToLineDistance2D(ref Vector3 pt, ref Vector3 p0, ref Vector3 p1, out Vector3 closest, out float t)
        {
            float dx = p1.X - p0.X;
            float dy = p1.Y - p0.Y;
            if (Math.Abs(dx) < float.Epsilon && Math.Abs(dy) < float.Epsilon)
            {
                // The points are too close together.
                closest = p0;
                dx = pt.X - p0.X;
                dy = pt.Y - p0.Y;
                t = 0f;
                return (float)Math.Sqrt(dx * dx + dy * dy);
            }

            // Calculate scale factor t of intersection.
            t = ((pt.X - p0.X) * dx + (pt.Y - p0.Y) * dy) / (dx * dx + dy * dy);

            // Test, if t inside line bounds.
            if (t < 0)
            {
                closest = new Vector3(p0.X, p0.Y, p0.Z);
                t = 0f;
                dx = pt.X - p0.X;
                dy = pt.Y - p0.Y;
            }
            else if (t > 1)
            {
                closest = new Vector3(p1.X, p1.Y, p1.Z);
                t = 1f;
                dx = pt.X - p1.X;
                dy = pt.Y - p1.Y;
            }
            else
            {
                closest = new Vector3(p0.X + t * dx, p0.Y + t * dy, pt.Z);
                dx = pt.X - closest.X;
                dy = pt.Y - closest.Y;
            }

            return (float)Math.Sqrt(dx * dx + dy * dy);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="plane"></param>
        /// <param name="radius"></param>
        /// <param name="segments"></param>
        /// <returns></returns>
        public static LineGeometry3D GenerateCircle(Vector3 plane, float radius, int segments)
        {
            if (segments < 3)
            {
                throw new ArgumentNullException("too few segments, at least 3");
            }

            var circle = new LineBuilder();

            float sectionAngle = (float)(2.0 * Math.PI / segments);

            if (plane == Vector3.UnitX)
            {
                Point3D start = new Point3D(0.0f, 0.0f, radius);
                Point3D current = new Point3D(0.0f, 0.0f, radius);
                Point3D next = new Point3D(0.0f, 0.0f, 0.0f);

                for (int i = 1; i < segments; i++)
                {
                    next.Z = radius * (float)Math.Cos(i * sectionAngle);
                    next.Y = radius * (float)Math.Sin(i * sectionAngle);

                    circle.AddLine(current, next);

                    current = next;
                }

                circle.AddLine(current, start);
            }
            else if (plane == Vector3.UnitY)
            {
                Point3D start = new Point3D(radius, 0.0f, 0.0f);
                Point3D current = new Point3D(radius, 0.0f, 0.0f);
                Point3D next = new Point3D(0.0f, 0.0f, 0.0f);

                for (int i = 1; i < segments; i++)
                {
                    next.X = radius * (float)Math.Cos(i * sectionAngle);
                    next.Z = radius * (float)Math.Sin(i * sectionAngle);

                    circle.AddLine(current, next);

                    current = next;
                }

                circle.AddLine(current, start);
            }
            else
            {
                Point3D start = new Point3D(0.0f, radius, 0.0f);
                Point3D current = new Point3D(0.0f, radius, 0.0f);
                Point3D next = new Point3D(0.0f, 0.0f, 0.0f);

                for (int i = 1; i < segments; i++)
                {
                    next.Y = radius * (float)Math.Cos(i * sectionAngle);
                    next.X = radius * (float)Math.Sin(i * sectionAngle);

                    circle.AddLine(current, next);

                    current = next;
                }

                circle.AddLine(current, start);
            }

            return circle.ToLineGeometry3D();
        }