public override void computeAABB(AABB aabb, Transform xf, int childIndex)
        {
            Debug.Assert(childIndex < m_count);
            Vec2 lower = aabb.lowerBound;
            Vec2 upper = aabb.upperBound;

            int i1 = childIndex;
            int i2 = childIndex + 1;
            if (i2 == m_count)
            {
                i2 = 0;
            }

            Vec2 vi1 = m_vertices[i1];
            Vec2 vi2 = m_vertices[i2];
            Rot xfq = xf.q;
            Vec2 xfp = xf.p;
            float v1x = (xfq.c*vi1.x - xfq.s*vi1.y) + xfp.x;
            float v1y = (xfq.s*vi1.x + xfq.c*vi1.y) + xfp.y;
            float v2x = (xfq.c*vi2.x - xfq.s*vi2.y) + xfp.x;
            float v2y = (xfq.s*vi2.x + xfq.c*vi2.y) + xfp.y;

            lower.x = v1x < v2x ? v1x : v2x;
            lower.y = v1y < v2y ? v1y : v2y;
            upper.x = v1x > v2x ? v1x : v2x;
            upper.y = v1y > v2y ? v1y : v2y;
        }

    public virtual Body GetBodyAtMouse(bool includeStatic)
    {
        // Make a small box
        mousePVec.X = MouseXWorldPhys;
        mousePVec.Y = MouseYWorldPhys;
        FVector2 lowerBound = new FVector2(MouseXWorldPhys - 0.001f, MouseYWorldPhys - 0.001f);
        FVector2 upperBound = new FVector2(MouseXWorldPhys + 0.001f, MouseYWorldPhys + 0.001f);
        AABB aabb = new AABB(lowerBound, upperBound);
        Body body = null;

        // Query the world for overlapping shapes
        System.Func<Fixture, bool> GetBodyCallback = delegate (Fixture fixture0)
        {
            Shape shape = fixture0.Shape;
            if(fixture0.Body.BodyType != BodyType.Static || includeStatic)
            {
                FarseerPhysics.Common.Transform transform0;
                fixture0.Body.GetTransform(out transform0);
                bool inside = shape.TestPoint(ref transform0, ref mousePVec);
                if(inside)
                {
                    body = fixture0.Body;
                    return false;
                }
            }
            return true;
        };
        FSWorldComponent.PhysicsWorld.QueryAABB(GetBodyCallback, ref aabb);
        return body;
    }

        public void CalculateBounds()
        {
            Bounds = new AABB
            {
                Max = Zone.ZoneMax.ToVector3(),
                Min = Zone.ZoneMin.ToVector3()
            };

            Max = Bounds.Max;
            Min = Bounds.Min;

            // Create a persistable way to uniquely identify a scene at a location
            SceneHash = string.Format("{0}_[{1},{2}][{3},{4}]", _scene.Name, Min.X, Min.Y, Max.X, Max.Y);

            EdgeLength = Bounds.Max.X - Bounds.Min.X / 2;
            HalfEdgeLength = EdgeLength / 2;
            
            SouthWest = new Vector3(Bounds.Max.X, Bounds.Min.Y, 0);
            SouthEast = new Vector3(Bounds.Max.X, Bounds.Max.Y, 0);
            NorthWest = new Vector3(Bounds.Min.X, Bounds.Min.Y, 0);
            NorthEast = new Vector3(Bounds.Min.X, Bounds.Max.Y, 0);
            CenterX = Bounds.Min.X + (Bounds.Max.X - Bounds.Min.X) / 2;
            CenterY = Bounds.Min.Y + (Bounds.Max.Y - Bounds.Min.Y) / 2;
            Center = new Vector3(CenterX, CenterY, 0);            
        }

        /// <summary>
        /// Handles what happens when a user clicks the mouse
        /// </summary>
        /// <param name="p">
        /// The position of the mouse click in relative coordinates.
        /// </param>
        public void MouseDown(Vector point)
        {
            Vector p = RelativeToWorld(point);

            if (mouseJoint != null)
                throw new Exception("ASSERT: mouseJoint should be null");

            // Make a small box.
            Vector d = new Vector(.001f, .001f);
            AABB aabb = new AABB(p - d, p + d);

            // Query the world for overlapping shapes.
            IList<Shape> shapes = world.Query(aabb);
            Body body = null;
            foreach (Shape shape in shapes)
            {
                if (shape.Body.Static == false &&
                    shape.TestPoint(shape.Body.GetXForm(), p))
                {
                    body = shape.Body;
                    break;
                }
            }

            if (body != null)
            {
                MouseJointDef md = new MouseJointDef();
                md.Body1 = world.GetGroundBody();
                md.Body2 = body;
                md.Target = p;
                md.MaxForce = 1000 * body.Mass;
                mouseJoint = new MouseJoint(world.CreateJoint(md));
                body.WakeUp();
            }
        }

 // DensityRegion Public Methods
 public DensityRegion(Spectrum sa, Spectrum ss, float gg, Spectrum emit, AABB b) {
     sig_a = sa;
     sig_s = ss;
     le = emit;
     g = gg;
     worldBound = b;
 }

 public AABB WorldBound(Point[] vertices)
 {
     var pts = vertices;
     var res = new AABB(pts[this.v0.VertexIndex], pts[this.v1.VertexIndex]);
     res.Union(pts[v2.VertexIndex]);
     return res;
 }

 public NavCell(float minX, float minY, float minZ, float maxX, float maxY, float maxZ, int flags)
 {
     BoundingBox = new AABB(
         new Vector3f(minX, minY, minZ),
         new Vector3f(maxX, maxY, maxZ));
     Flags = (NavCellFlags)flags;
 }

 public AABB WorldBound(Point[] vertices)
 {
     var pts = vertices;
     var res = new AABB(pts[this.v0], pts[this.v1]);
     res.Union(pts[v2]);
     return res;
 }

 public ExploreCell(AABB aabb, List<Cell> cells, Vec3 position, int id = -1)
     : base(aabb.Min.X, aabb.Min.Y, 0, aabb.Max.X, aabb.Max.Y, 0, MovementFlag.None, id)
 {
     InitExploreCell();
     Position = position;
     Cells = cells;            
 }

 /// <summary>
 /// Creates a new quad tree broadphase with the specified span.
 /// </summary>
 /// <param name="span">the maximum span of the tree (world size)</param>
 public QuadTreeBroadPhase(AABB span)
 {
     _quadTree = new QuadTree<FixtureProxy>(span, 5, 10);
     _idRegister = new Dictionary<int, Element<FixtureProxy>>();
     _moveBuffer = new List<Element<FixtureProxy>>();
     _pairBuffer = new List<Pair>();
 }

 public void GetFatAABB(int proxyID, out AABB aabb)
 {
     if (_idRegister.ContainsKey(proxyID))
         aabb = _idRegister[proxyID].Span;
     else
         throw new KeyNotFoundException("proxyID not found in register");
 }

 public int createProxy(AABB aabb, object userData)
 {
     int proxyId = m_tree.createProxy(aabb, userData);
     ++m_proxyCount;
     bufferMove(proxyId);
     return proxyId;
 }

 public KdTreePhotonMap(int max) {
     this.max_photons = max;
     this.prev_scale = 1;
     this.photonsCount = 0;
     this.bbox = new AABB();
     this.photons = new Photon[max];
 }

    public DungeonRoom(int id, AABB b)
    {
        boundary = b;

        this.id = id;
        this.color = new Color(Random.Range(0f, 1f), Random.Range(0f, 1f), Random.Range(0f, 1f));
        this.tiles = new List<DungeonTile>();
    }

 public void SetProxyAABB(BroadphaseProxy proxy, ref AABB aabb)
 {
     // maintain the uniform grid as the aabb moves. this works by removing
     // the stale aabb proxies and then adding the fresh aabb proxies.
     RemoveProxyFromCells(proxy);
     proxy.AABB = aabb;
     AddProxyToCells(proxy);
 }

 public override EPlacement Placement(AABB bound)
 {
     EPlacement ap = a.Placement(bound);
     EPlacement bp = b.Placement(bound);
     if (ap == EPlacement.BInsideA || bp == EPlacement.BInsideA) return EPlacement.BInsideA; //this one isn't quite right, might be BInsideA also if there's an intersection
     if (ap == EPlacement.Outside && bp == EPlacement.Outside) return EPlacement.Outside;
     if (ap == EPlacement.AInsideB && bp == EPlacement.AInsideB) return EPlacement.AInsideB;
     return EPlacement.Intersect;
 }

 public AABB BoundingBox()
 {
     var bbox = new AABB();
     foreach (var vertex in Vertices)
     {
         bbox.Union(vertex);
     }
     return bbox;
 }

    private QuadTree<FixtureProxy>[] _quadTrees; // array indexed by log2(Fixture.Category)

    #endregion Fields

    #region Constructors

    /// <summary>
    /// Creates a new quad tree broadphase with the specified span.
    /// </summary>
    /// <param name="span">world size</param>
    public QuadTreeBroadPhase(AABB span)
    {
        var fatSpan = span.Fattened;
        _quadTrees = new QuadTree<FixtureProxy>[32];
        for (int i=0;i<_quadTrees.Length;i++) _quadTrees[i] = new QuadTree<FixtureProxy>(fatSpan, 5, 10);
        _idRegister = new Dictionary<int, Element<FixtureProxy>>();
        _moveBuffer = new List<Element<FixtureProxy>>();
        _pairBuffer = new List<Pair>();
    }

	// Use this for initialization
	void Start ()
	{
		Vector3 p = transform.position;
		FVector2 aa = new FVector2(p.x + StartPoint.x, p.y + StartPoint.y);
		FVector2 bb = new FVector2(p.x + EndPoint.x, p.y + EndPoint.y);
		aabb = new AABB(aa, bb);
		buoyancyController = new BuoyancyController(aabb, Density, LinearDragCoef, RotationalDragCoef, FSWorldComponent.PhysicsWorld.Gravity);
		FSWorldComponent.PhysicsWorld.AddController(buoyancyController);
	}

     SingleScatteringIntegrator(AABB bbox, float step, float prob,
                                RgbSpectrum inScattering, RgbSpectrum emission)
 {
     region = bbox;
     stepSize = step;
     rrProb = prob;
     sig_s = inScattering;
     lightEmission = emission;
 }