コード例 #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="spline"></param>
        public static void RenderSpline(HSD_Spline spline, Color c1, Color c2)
        {
            GL.UseProgram(-1);

            GL.PushAttrib(AttribMask.AllAttribBits);

            GL.LineWidth(2);
            GL.Begin(PrimitiveType.LineStrip);

            var points   = spline.Points;
            var pointMax = spline.PointCount;

            for (int i = 0; i < points.Length; i++)
            {
                GL.Color3(Mix(c1, c2, i / (float)pointMax));
                GL.Vertex3(points[i].X, points[i].Y, points[i].Z);
            }

            GL.End();

            GL.Color3(1f, 1f, 1f);
            GL.PointSize(4f);
            GL.Begin(PrimitiveType.Points);
            foreach (var p in points)
            {
                GL.Vertex3(p.X, p.Y, p.Z);
            }
            GL.End();

            GL.PopAttrib();
        }
コード例 #2
0
        public static HSD_Spline KMP_ExtractRouteSpline(string kmpFile)
        {
            List <HSD_Vector3> points = new List <HSD_Vector3>();

            using (FileStream f = new FileStream(kmpFile, FileMode.Open))
                using (BinaryReaderExt r = new BinaryReaderExt(f))
                {
                    r.BigEndian = true;

                    r.Seek(0x14);
                    var enpt = r.ReadUInt32();

                    r.Seek(enpt + 0x4C);
                    r.Skip(4);
                    int count = r.ReadInt16();
                    int unk   = r.ReadInt16();

                    for (int i = 0; i < count; i++)
                    {
                        points.Add(new HSD_Vector3()
                        {
                            X = r.ReadSingle() * Scale, Y = r.ReadSingle() * Scale + YTrans, Z = r.ReadSingle() * Scale
                        });
                        var range = r.ReadSingle();
                        r.Skip(4); // settings
                    }
                }

            HSD_Spline spline = new HSD_Spline();

            spline.Points     = points.ToArray();
            spline.PointCount = (short)points.Count;

            float totalLength = 0;

            foreach (var e in points)
            {
                totalLength += new Vector3(e.X, e.Y, e.Z).Length;
            }

            float[] lengths = new float[points.Count];
            //float length = 0;
            for (int i = 0; i < lengths.Length; i++)
            {
                lengths[i] = i / (float)(lengths.Length - 1);
                //length += new Vector3(points[i].X, points[i].Y, points[i].Z).Length;
            }

            spline.TotalLength = totalLength;
            spline.Lengths     = new HSDFloatArray()
            {
                Array = lengths
            };
            return(spline);
        }
コード例 #3
0
        public override void Open(HSDReader Reader)
        {
            var offset = Reader.ReadUInt32();
            var count  = Reader.ReadInt32();

            uint[] offsets = new uint[count];
            Reader.Seek(offset);
            for (int i = 0; i < count; i++)
            {
                offsets[i] = Reader.ReadUInt32();
            }

            for (int i = 0; i < count; i++)
            {
                if (offsets[i] == 0)
                {
                    continue;
                }
                Reader.Seek(offsets[i]);
                var path = new HSD_Spline();
                path.Open(Reader);
                Paths.Add(path);
            }
        }
コード例 #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="spline"></param>
        public static void RenderSpline(HSD_Spline spline)
        {
            GL.UseProgram(-1);

            GL.PushAttrib(AttribMask.AllAttribBits);

            GL.LineWidth(2);
            GL.Begin(PrimitiveType.Lines);

            var points = spline.Points.Array;

            for (int i = 0; i < points.Length - 1; i++)
            {
                GL.Color3(Color.Yellow);
                GL.Vertex3(points[i].X, points[i].Y, points[i].Z);

                GL.Color3(Color.Blue);
                GL.Vertex3(points[i + 1].X, points[i + 1].Y, points[i + 1].Z);
            }

            GL.End();

            GL.PopAttrib();
        }
コード例 #5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="spline"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        public static void CreateRangeSpline(HSD_Spline spline, out HSD_Spline left, out HSD_Spline right)
        {
            left = new HSD_Spline()
            {
                Tension     = spline.Tension,
                Lengths     = spline.Lengths,
                TotalLength = spline.TotalLength,
            };
            right = new HSD_Spline()
            {
                Tension     = spline.Tension,
                Lengths     = spline.Lengths,
                TotalLength = spline.TotalLength,
            };

            var points = spline.Points;

            HSD_Vector3[] lp = new HSD_Vector3[points.Length];
            HSD_Vector3[] rp = new HSD_Vector3[points.Length];
            for (int i = 0; i < points.Length; i++)
            {
                var p   = new HSD_Vector3(points[i].X, points[i].Y, points[i].Z);
                var nrm = new HSD_Vector3();

                if (i < points.Length - 1)
                {
                    var norm1 = new HSD_Vector3(-(points[i + 1].Z - points[i].Z), (points[i + 1].X - points[i].X), 0);
                    norm1.Normalize();
                    nrm = new HSD_Vector3(norm1.X, 0, norm1.Y);
                }

                if (i > 0)
                {
                    var norm1 = new HSD_Vector3(-(points[i].Z - points[i - 1].Z), (points[i].X - points[i - 1].X), 0);
                    norm1.Normalize();

                    if (nrm.X == 0 && nrm.Y == 0 && nrm.Z == 0)
                    {
                        nrm = new HSD_Vector3(norm1.X, 0, norm1.Y);
                    }
                    else
                    {
                        nrm = (nrm + new HSD_Vector3(norm1.X, 0, norm1.Y)) / 2;
                    }
                }

                nrm *= 10;

                var l = p + nrm;
                var r = p - nrm;

                lp[i] = new HSD_Vector3()
                {
                    X = l.X, Y = l.Y, Z = l.Z
                };
                rp[i] = new HSD_Vector3()
                {
                    X = r.X, Y = r.Y, Z = r.Z
                };
            }

            left.Points  = lp;
            right.Points = rp;
        }