Beispiel #1
0
        public Window()
            : base(640, 480, GraphicsMode.Default, "XSharp")
        {
            GL.Enable(EnableCap.DepthTest);

            ISharpShape shape = new Sphere().Subsect(new Vector(0.5, 0.5, 0.5), new Vector(0.5, 0.5, 0.5));
            this.Tree = OctoTree.Create(shape, 5);

            PointCloud.Point[] points = new PointCloud.Point[80000];
            for (int t = 0; t < points.Length; t++)
            {
                double ang = (double)t / (double)points.Length * Math.PI * 2.0;
                double elv = (double)Math.Sin(ang * 100.0);
                double x = (double)Math.Sin(ang);
                double z = (double)Math.Cos(ang);
                points[t] = new PointCloud.Point()
                {
                    Position = new Vector(x, z, elv),
                    A = 255,
                    R = 0,
                    G = 255,
                    B = 0
                };
            }

            this.MyPointCloud = new PointCloud();
            this.MyPointCloud.Submit(points, 2.0f);
        }
Beispiel #2
0
 private OctoTree()
 {
     // Self referential for completely full or completely empty
     this.PPP = this;
     this.PPN = this;
     this.PNP = this;
     this.PNN = this;
     this.NPP = this;
     this.NPN = this;
     this.NNP = this;
     this.NNN = this;
 }
Beispiel #3
0
 static OctoTree()
 {
     _Full = new OctoTree();
     _Full._Hash = 0xDEADBEEF;
     _Full._FillLevel = 1.0;
     _Empty = new OctoTree();
     _Empty._Hash = 0x1337BED5;
     _Empty._FillLevel = 0.0;
     _Hashes = new Hashtable();
     _Hashes.Add(_Full._Hash, _Full);
     _Hashes.Add(_Empty._Hash, _Empty);
     _Hashes.Add(_CalcHash(_Full.Children), _Full);
     _Hashes.Add(_CalcHash(_Empty.Children), _Empty);
 }
Beispiel #4
0
        private void _DrawOctoTree(Vector Offset, Vector Scale, OctoTree Tree)
        {
            if (Tree == OctoTree.Full)
            {
                GL.Color3(Color.FromArgb(192, (int)(Offset.X * 126 + 127), (int)(Offset.Y * 126 + 127), (int)(Offset.Z * 126 + 127)));
                GL.Vertex3(Offset);
            }
            else if (Tree == OctoTree.Empty)
            {

            }
            else
            {
                OctoTree[] children = Tree.Children;
                for (int t = 0; t < 8; t++)
                {
                    Vector offset = OctoTree.Offset(t);
                    offset.Scale(Scale);
                    _DrawOctoTree(Offset + offset, Scale * 0.5, children[t]);
                }
            }
        }
Beispiel #5
0
 private OctoTree(OctoTree[] Children)
 {
     this.PPP = Children[0];
     this.PPN = Children[1];
     this.PNP = Children[2];
     this.PNN = Children[3];
     this.NPP = Children[4];
     this.NPN = Children[5];
     this.NNP = Children[6];
     this.NNN = Children[7];
 }
Beispiel #6
0
 /// <summary>
 /// Computes the hash for an octotree with the specified children.
 /// </summary>
 private static uint _CalcHash(OctoTree[] Children)
 {
     uint hash = 0x1234ABCD;
     for (uint t = 0; t < 8; t++)
     {
         hash += Children[t]._Hash;
         hash += t * 2 + 1;
         hash = hash << 1;
     }
     return hash;
 }
Beispiel #7
0
        /// <summary>
        /// Loads an octrotree from a steam.
        /// </summary>
        public static OctoTree Load(Stream Stream)
        {
            List<uint> data = new List<uint>();
            byte[] buffer = new byte[4];
            while (Stream.Read(buffer, 0, 4) == 4)
            {
                data.Add(BitConverter.ToUInt32(buffer, 0));
            }

            uint target = 0;
            List<uint> curgroup = null;
            LinkedList<uint[]> groups = null;
            foreach (uint datum in data)
            {
                if (groups == null)
                {
                    groups = new LinkedList<uint[]>();
                    target = datum;
                }
                else
                {
                    if (curgroup == null)
                    {
                        curgroup = new List<uint>();
                        curgroup.Add(datum);
                    }
                    else
                    {
                        curgroup.Add(datum);
                        if (curgroup.Count == 8)
                        {
                            groups.AddFirst(curgroup.ToArray());
                            curgroup = null;
                        }
                    }
                }
            }

            // Try to reach target hash with given information
            OctoTree targettree;
            while((targettree = _Hashes[target] as OctoTree) == null)
            {
                LinkedListNode<uint[]> grouppointer = groups.First;
                while(grouppointer != null)
                {
                    OctoTree[] childrens = new OctoTree[8];
                    for (int t = 0; t < 8; t++)
                    {
                        if ((childrens[t] = _Hashes[grouppointer.Value[t]] as OctoTree) == null)
                        {
                            childrens = null;
                            break;
                        }
                    }
                    if (childrens != null)
                    {
                        LinkedListNode<uint[]> lgrouppointer = grouppointer;
                        grouppointer = grouppointer.Next;
                        groups.Remove(lgrouppointer);
                        Get(childrens); // get hash for group
                    }
                    if (grouppointer != null)
                    {
                        grouppointer = grouppointer.Next;
                    }
                }
            }

            return targettree;
        }
Beispiel #8
0
        /// <summary>
        /// Gets an octotree with the specified children.
        /// </summary>
        public static OctoTree Get(OctoTree[] Children)
        {
            uint hash = _CalcHash(Children);

            object hasheditem = _Hashes[hash];
            if (hasheditem == null)
            {
                OctoTree newtree = new OctoTree(Children);
                double filllevel = 0.0;
                for (int t = 0; t < 8; t++)
                {
                    filllevel += (Children[t]._FillLevel) / 8.0;
                }
                newtree._FillLevel = filllevel;
                newtree._Hash = hash;
                _Hashes[hash] = newtree;
                return newtree;
            }
            else
            {
                return _Hashes[hash] as OctoTree;
            }
        }
Beispiel #9
0
 /// <summary>
 /// Creates an octotree representation of a shape with the specified resolution(Tree depth).
 /// </summary>
 public static OctoTree Create(ISharpShape Shape, int Resolution)
 {
     if (Resolution > 0)
     {
         OctoTree[] children = new OctoTree[8];
         for (int t = 0; t < 8; t++)
         {
             children[t] = Create(Shape.Subsect(Offset(t), new Vector(0.5, 0.5, 0.5)), Resolution - 1);
         }
         return Get(children);
     }
     else
     {
         if (Shape.Occupies(new Vector(0.0, 0.0, 0.0)))
         {
             return _Full;
         }
         else
         {
             return _Empty;
         }
     }
 }