Esempio n. 1
0
        protected override void OnUpdateFrame(FrameEventArgs e)
        {
            base.OnUpdateFrame(e);

            var w = 10f;
            var d = w;

            _proj3D = Matrix4.CreateOrthographic(w, w * Height / Width, -d / 2, d / 2);

            if (_pause)
            {
                return;
            }

            _t += e.Time;

            var pln = MVec4D.UnitXy + MVec4D.UnitXz + MVec4D.UnitYw;
            var r   = MVec4D.Rotor(e.Time / 10, pln.Normalized);

            foreach (var pent in _simplexes)
            {
                for (var i = 0; i < pent.Verts.Length; i++)
                {
                    pent.Verts[i] |= r;
                }
            }

            var blade = MVec4D.UnitXyz;
            var pivot = MVec4D.Zero;

            for (var i = 0; i < _simplexes.Length; i++)
            {
                _intersections[i] = _simplexes[i].Intersect(blade, pivot);
            }
        }
Esempio n. 2
0
        public static void Vertex4(MVec4D m)
        {
            var i = m.W / 2;

            GL.Color3(.5 + i, 0, .5 - i);
            GL.Vertex3(m.X, m.Y, m.Z);
        }
Esempio n. 3
0
        public bool[] Sides(MVec4D blade, MVec4D pivot)
        {
            var sides = new bool[Verts.Length];

            var perp = blade.Dual;

            for (var i = 0; i < Verts.Length; i++)
            {
                var m   = Verts[i];
                var p   = m - pivot;
                var rej = (p ^ blade) * ~blade;
                if (!rej.HasValue)
                {
                    continue;
                }
                var dot = rej & perp;

                sides[i] = dot.Value.S > 0;
            }

            return(sides);
        }
Esempio n. 4
0
        public Simplex Intersect(MVec4D blade, MVec4D pivot)
        {
            var sides = Sides(blade, pivot);
            var verts = new List <MVec4D>();
            var edges = new List <int>();

            var face_verts = new List <int> [Verts.Length];

            for (var i = 0; i < face_verts.Length; i++)
            {
                face_verts[i] = new List <int>();
            }

            {
                var k = 0;
                for (var i = 0; i < Verts.Length; i++)
                {
                    for (var j = i + 1; j < Verts.Length; j++)
                    {
                        if (sides[i] == sides[j])
                        {
                            continue;
                        }
                        var m = Verts[i] - pivot;
                        var n = Verts[j] - pivot;

                        var v    = m - n;
                        var alph = (blade ^ m) * ~(blade ^ v);
                        if (!alph.HasValue)
                        {
                            continue;
                        }
                        var p = m - v * alph.Value;

                        verts.Add(p);
                        face_verts[i].Add(k);
                        face_verts[j].Add(k);

                        k++;
                    }
                }
            }

            var faces = new List <int>();

            foreach (var vlst in face_verts)
            {
                for (var i = 0; i < vlst.Count - 2; i++)
                {
                    for (var j = i + 1; j < vlst.Count - 1; j++)
                    {
                        for (var k = j + 1; k < vlst.Count; k++)
                        {
                            faces.Add(vlst[i]);
                            faces.Add(vlst[j]);
                            faces.Add(vlst[k]);

                            edges.Add(vlst[i]);
                            edges.Add(vlst[j]);
                            edges.Add(vlst[j]);
                            edges.Add(vlst[k]);
                            edges.Add(vlst[k]);
                            edges.Add(vlst[i]);
                        }
                    }
                }
            }

            if (faces.Count == 6)
            {
                for (var i = 0; i < 3; i++)
                {
                    var a = faces[i];
                    var b = faces[(1 + i) % 3];
                    var c = faces[3 + i];
                    var d = faces[3 + (1 + i) % 3];

                    faces.Add(c);
                    faces.Add(a);
                    faces.Add(b);
                    faces.Add(b);
                    faces.Add(d);
                    faces.Add(c);

                    edges.Add(a);
                    edges.Add(c);
                    edges.Add(b);
                    edges.Add(d);
                }
            }

            return(new Simplex(verts, faces, edges));
        }
Esempio n. 5
0
 public static void Color3(MVec4D m)
 {
     m *= .5;
     GL.Color3(.5 + m.X, .5 + m.Y, .5 * m.Z);
 }
Esempio n. 6
0
 public static void Vertex3(MVec4D m)
 {
     GL.Vertex3(m.X, m.Y, m.Z);
 }