OniSplit/Akira/Room.cs

using System;
using System.Collections.Generic;

namespace Oni.Akira
{
    internal class Room
    {
        private Polygon floorPolygon;
        private RoomBspNode bspTree;
        private BoundingBox boundingBox;
        private RoomGrid grid;
        private Plane floorPlane;
        private float height;
        private readonly List<RoomAdjacency> adjacencies = new List<RoomAdjacency>();

        public BoundingBox BoundingBox
        {
            get { return boundingBox; }
            set { boundingBox = value; }
        }

        public RoomBspNode BspTree
        {
            get { return bspTree; }
            set { bspTree = value; }
        }

        public RoomGrid Grid
        {
            get { return grid; }
            set { grid = value; }
        }

        public Polygon FloorPolygon
        {
            get { return floorPolygon; }
            set { floorPolygon = value; }
        }

        public Plane FloorPlane
        {
            get { return floorPlane; }
            set { floorPlane = value; }
        }

        public bool IsStairs => floorPlane.Normal.Y < 0.999f;

        public float Height
        {
            get { return height; }
            set { height = value; }
        }

        public List<RoomAdjacency> Ajacencies => adjacencies;

        public bool Contains(Vector3 point)
        {
            if (!boundingBox.Contains(point))
                return false;

            bool front = false;
            RoomBspNode node = bspTree;

            while (node != null)
            {
                front = (node.Plane.DotCoordinate(point) >= MathHelper.Eps);
                node = front ? node.FrontChild : node.BackChild;
            }

            return !front;
        }

        public bool Intersect(BoundingBox bbox)
        {
            if (!boundingBox.Intersects(bbox))
                return false;

            bool front = false;
            RoomBspNode node = bspTree;

            while (node != null)
            {
                int intersects = node.Plane.Intersects(bbox);

                if (intersects == 0)
                    return true;

                front = intersects > 0;
                node = front ? node.FrontChild : node.BackChild;
            }

            return !front;
        }

        public List<Vector3[]> GetFloorPolygons()
        {
            var polys = new List<Vector3[]>();

            if (floorPolygon != null)
            {
                polys.Add(floorPolygon.Points.ToArray());
                return polys;
            }

            var min = new Vector2(boundingBox.Min.X, boundingBox.Min.Z);
            var max = new Vector2(boundingBox.Max.X, boundingBox.Max.Z);

            var root = new Polygon2(new[]
            {
                new Vector2(min.X, min.Y),
                new Vector2(max.X, min.Y),
                new Vector2(max.X, max.Y),
                new Vector2(min.X, max.Y)
            });

            var cutter = new Polygon2Clipper(bspTree);

            foreach (Polygon2 polygon in cutter.Clip(root))
            {
                var points = new Vector3[polygon.Length];

                for (int i = 0; i < points.Length; i++)
                {
                    var point = polygon[i];

                    points[i].X = point.X;
                    points[i].Y = (-floorPlane.D - floorPlane.Normal.Z * point.Y - floorPlane.Normal.X * point.X) / floorPlane.Normal.Y;
                    points[i].Z = point.Y;
                }

                Array.Reverse(points);

                polys.Add(points);
            }

            return polys;
        }
    }
}
Revision:	1114
Committed:	Wed Jan 22 14:08:57 2020 UTC (5 years, 8 months ago) by iritscen
File size:	3775 byte(s)
Log Message:	Adding OniSplit source code (v0.9.99.0). Many thanks to Neo for all his work over the years.
#	Content
1	using System;
2	using System.Collections.Generic;
3
4	namespace Oni.Akira
5	{
6	internal class Room
7	{
8	private Polygon floorPolygon;
9	private RoomBspNode bspTree;
10	private BoundingBox boundingBox;
11	private RoomGrid grid;
12	private Plane floorPlane;
13	private float height;
14	private readonly List<RoomAdjacency> adjacencies = new List<RoomAdjacency>();
15
16	public BoundingBox BoundingBox
17	{
18	get { return boundingBox; }
19	set { boundingBox = value; }
20	}
21
22	public RoomBspNode BspTree
23	{
24	get { return bspTree; }
25	set { bspTree = value; }
26	}
27
28	public RoomGrid Grid
29	{
30	get { return grid; }
31	set { grid = value; }
32	}
33
34	public Polygon FloorPolygon
35	{
36	get { return floorPolygon; }
37	set { floorPolygon = value; }
38	}
39
40	public Plane FloorPlane
41	{
42	get { return floorPlane; }
43	set { floorPlane = value; }
44	}
45
46	public bool IsStairs => floorPlane.Normal.Y < 0.999f;
47
48	public float Height
49	{
50	get { return height; }
51	set { height = value; }
52	}
53
54	public List<RoomAdjacency> Ajacencies => adjacencies;
55
56	public bool Contains(Vector3 point)
57	{
58	if (!boundingBox.Contains(point))
59	return false;
60
61	bool front = false;
62	RoomBspNode node = bspTree;
63
64	while (node != null)
65	{
66	front = (node.Plane.DotCoordinate(point) >= MathHelper.Eps);
67	node = front ? node.FrontChild : node.BackChild;
68	}
69
70	return !front;
71	}
72
73	public bool Intersect(BoundingBox bbox)
74	{
75	if (!boundingBox.Intersects(bbox))
76	return false;
77
78	bool front = false;
79	RoomBspNode node = bspTree;
80
81	while (node != null)
82	{
83	int intersects = node.Plane.Intersects(bbox);
84
85	if (intersects == 0)
86	return true;
87
88	front = intersects > 0;
89	node = front ? node.FrontChild : node.BackChild;
90	}
91
92	return !front;
93	}
94
95	public List<Vector3[]> GetFloorPolygons()
96	{
97	var polys = new List<Vector3[]>();
98
99	if (floorPolygon != null)
100	{
101	polys.Add(floorPolygon.Points.ToArray());
102	return polys;
103	}
104
105	var min = new Vector2(boundingBox.Min.X, boundingBox.Min.Z);
106	var max = new Vector2(boundingBox.Max.X, boundingBox.Max.Z);
107
108	var root = new Polygon2(new[]
109	{
110	new Vector2(min.X, min.Y),
111	new Vector2(max.X, min.Y),
112	new Vector2(max.X, max.Y),
113	new Vector2(min.X, max.Y)
114	});
115
116	var cutter = new Polygon2Clipper(bspTree);
117
118	foreach (Polygon2 polygon in cutter.Clip(root))
119	{
120	var points = new Vector3[polygon.Length];
121
122	for (int i = 0; i < points.Length; i++)
123	{
124	var point = polygon[i];
125
126	points[i].X = point.X;
127	points[i].Y = (-floorPlane.D - floorPlane.Normal.Z * point.Y - floorPlane.Normal.X * point.X) / floorPlane.Normal.Y;
128	points[i].Z = point.Y;
129	}
130
131	Array.Reverse(points);
132
133	polys.Add(points);
134	}
135
136	return polys;
137	}
138	}
139	}