コード例 #1
0
ファイル: gxtNarrowPhaseCollider.cs プロジェクト: Loko/GXT
        /// <summary>
        /// Performs a ray cast on the polygon given an optional tmax value
        /// Only process the information in the rayHit structure if Intersection = true,
        /// which is specified in the gxtRayHit instance and the return value.  If the ray origin is 
        /// inside the Polygon it is not considered an intersection
        /// </summary>
        /// <param name="ray">Ray</param>
        /// <param name="polygon">Polygon</param>
        /// <param name="rayHit">Ray Hit Info</param>
        /// <param name="tmax">Max T Value</param>
        /// <returns>If Intersecting</returns>
        public virtual bool RayCast(gxtRay ray, ref gxtPolygon polygon, out gxtRayHit rayHit, float tmax = float.MaxValue)
        {
            rayHit = new gxtRayHit();
            rayHit.Distance = tmax;

            // if a crossing is within tmax
            bool intersection = false;
            // temp holder for segment distance
            float distance;
            // number of crossings, regardless of tmax
            int crossings = 0;

            // log a message when we run a raycast on a very detailed polygon
            // to indicate that the results may not be perfect
            int testIterations = polygon.NumVertices;
            if (MaxIterations < polygon.NumVertices)
            {
                gxtLog.WriteLineV(gxtVerbosityLevel.WARNING, "Polygon vertices exceeds max collider iterations.  Not all segments will be tested!");
                testIterations = MaxIterations;
            }

            for (int j = polygon.NumVertices - 1, i = 0; i < testIterations; j = i, i++)
            {
                if (RayIntersectsSegment(ray, polygon.v[j], polygon.v[i], out distance))
                {
                    crossings++;
                    if (distance <= rayHit.Distance)
                    {
                        intersection = true;

                        rayHit.Distance = distance;
                        rayHit.Point = ray.GetPoint(distance);

                        // right perp assumes CCW polygon winding
                        Vector2 edge = polygon.v[j] - polygon.v[i];
                        rayHit.Normal = Vector2.Normalize(gxtMath.RightPerp(edge));
                    }
                }
            }
            // raycast algorithm
            rayHit.Intersection = intersection && crossings > 0 && crossings % 2 == 0;
            return rayHit.Intersection;
        }
コード例 #2
0
ファイル: KinematicTestGame.cs プロジェクト: Loko/GXT
        private bool OnOneWayPlatformCollision(gxtGeom ga, gxtGeom gb, gxtCollisionResult cr)
        {
            float tolerance = 0.5f;
            if (ga == geomC)
            {
                //gxtLog.WriteLineV(gxtVerbosityLevel.INFORMATIONAL, "here");
                float dot = Vector2.Dot(cr.Normal, Vector2.UnitY);
                if (dot >= tolerance)
                {
                    //if (gb.HasAttachedBody() && Vector2.Dot(gb.RigidBody.PrevAcceleration, Vector2.UnitY) <= 0.0f)
                        return false;
                }
                else
                {
                    gxtRayHit rayHit;
                    gxtRay downRay = new gxtRay();
                    downRay.Origin = gb.GetWorldCentroid() - new Vector2(0.0f, geomF.LocalAABB.Height * 0.45f);
                    downRay.Direction = Vector2.UnitY;
                    float halfHeight = geomF.LocalAABB.Height * 0.65f;
                    if (world.PhysicsWorld.RayCast(downRay, out rayHit, gxtCollisionGroup.ALL, halfHeight))
                    {

                        gxtRay adjRay = new gxtRay(downRay.Origin * gxtPhysicsWorld.PHYSICS_SCALE, downRay.Direction);
                        gxtDebugDrawer.Singleton.AddRay(adjRay, rayHit.Distance * gxtPhysicsWorld.PHYSICS_SCALE, Color.Green, 0.0f, TimeSpan.FromSeconds(5.0));
                        return false;
                    }
                    else
                    {
                        //return false;
                        gxtRay adjRay = new gxtRay(downRay.Origin * gxtPhysicsWorld.PHYSICS_SCALE, downRay.Direction);
                        gxtDebugDrawer.Singleton.AddRay(adjRay, halfHeight * gxtPhysicsWorld.PHYSICS_SCALE, Color.Green, 0.0f, TimeSpan.FromSeconds(5.0));
                        //return false;
                    }
                }
                //else if (gb.HasAttachedBody() && Vector2.Dot(gb.RigidBody.PrevAcceleration, Vector2.UnitY))
            } else
            {
                gxtDebug.Assert(false, "You didn't set up the swap properly");
            }
            /*
            else if (gb == geomC)
            {
                float dot = Vector2.Dot(cr.Normal, new Vector2(0.0f, -1.0f));
                if (dot >= tolerance)
                {
                    if (gb.HasAttachedBody() && Vector2.Dot(gb.RigidBody.PrevAcceleration, new Vector2(0.0f, -1.0f)) >= 0.0f)
                    return false;
                }
            }
            */
            return true;
        }
コード例 #3
0
ファイル: asgPlayerActor.cs プロジェクト: Loko/GXT
        private bool PerformRaycast(float t)
        {
            raycasts.Clear();

            gxtRay downRay = new gxtRay();
            downRay.Origin = position;
            downRay.Direction = Vector2.UnitY;

            // may want to raycast against more than just platforms
            bool anyHits = world.PhysicsWorld.RayCastAll(downRay, out raycasts, "traversable_world_geometry", 15.0f);
            gxtDebugDrawer.Singleton.CurrentScale = gxtPhysicsWorld.PHYSICS_SCALE;
            if (anyHits)
            {
                // insertion sort
                int j, i;
                gxtRayHit hit;
                for (j = 1; j < raycasts.Count - 1; ++j)
                {
                    hit = raycasts[j];
                    i = j - 1;
                    while ((i >= 0) && (hit.Distance < raycasts[i].Distance))
                    {
                        raycasts[i + 1] = raycasts[i];
                        --i;
                    }
                    raycasts[i + 1] = hit;
                }

                gxtDebugDrawer.Singleton.AddRay(downRay, raycasts[0].Distance, Color.Red);
            }
            else
            {
                gxtDebugDrawer.Singleton.AddRay(downRay, t, Color.Green);
            }

            return anyHits;
        }
コード例 #4
0
ファイル: RayTestGame.cs プロジェクト: Loko/GXT
        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            base.Update(gameTime);

            float xA = 0.0f, yA = 0.0f, rA = 0.0f;
            gxtKeyboard kb = gxtKeyboardManager.Singleton.GetKeyboard();
            gxtMouse mouse = gxtMouseManager.Singleton.GetMouse();

            // assume gravity off
            float force = 150;
            float torque = 300.0f;

            if (kb.IsDown(Keys.Left))
                xA -= force;
            if (kb.IsDown(Keys.Right))
                xA += force;
            if (kb.IsDown(Keys.Up))
                yA -= force;
            if (kb.IsDown(Keys.Down))
                yA += force;
            if (kb.IsDown(Keys.OemOpenBrackets))
                rA -= torque;
            if (kb.IsDown(Keys.OemCloseBrackets))
                rA += torque;

            if (xA != 0.0f || yA != 0.0f)
                bodyA.ApplyForce(new Vector2(xA, yA));
            if (rA != 0.0f)
                bodyA.ApplyTorque(rA);
            //bodyA.Translate(new Vector2(xA, yA));
            //bodyA.SetRotation(bodyA.Rotation + rA);

            Vector2 forceBeforeClear = bodyA.Force;

            world.Update(gameTime);

            //gxtLog.WriteLineV(gxtVerbosityLevel.INFORMATIONAL, bodyA.Acceleration.ToString());


            Color geomAColor = Color.Yellow;
            Color geomBColor = Color.Yellow;

            gxtRay ray = new gxtRay();
            ray.Origin = rayOrigin;


            if (kb.GetState(Keys.C) == gxtControlState.FIRST_PRESSED)
            {
                if (rayOrigin == new Vector2(-225, -100))
                    rayOrigin = new Vector2(250, 200);
                else
                    rayOrigin = new Vector2(-225, -100);
            }

            Vector2 d = world.Camera.GetVirtualMousePosition(mouse.GetPosition()) - ray.Origin;
            ray.Direction = Vector2.Normalize(d);

            gxtDebugDrawer.Singleton.PtSize = 10.0f;
            gxtDebugDrawer.Singleton.AddPt(ray.Origin, Color.Green, 0.0f);
            //gxtDebugDrawer.Singleton.AddLine(ray.Origin, ray.Origin + d, Color.Green, 0.0f);
            //gxtDebugDrawer.Singleton.AddRay(ray, Color.Green, 0.0f);
            float t = 0.0f;

            #if NARROWPHASE_TEST
            Vector2 polyIntersectionPt;
            Vector2 polyRayNormal;
            if (gxtGJKCollider.RayCast(ray, geomA.Polygon, float.MaxValue, out t, out polyIntersectionPt, out polyRayNormal))
            {
                geomAColor = Color.Red;
                gxtDebugDrawer.Singleton.AddLine(polyIntersectionPt, polyIntersectionPt + polyRayNormal * 50, Color.Gray, 0.0f);
                gxtDebugDrawer.Singleton.AddPt(polyIntersectionPt, Color.YellowGreen, 0.0f);
                gxtDebugDrawer.Singleton.AddRay(ray, t, Color.Green, 0.0f, System.TimeSpan.Zero);
                //gxtLog.WriteLineV(gxtVerbosityLevel.INFORMATIONAL, "t: {0}", t);
            }
            else
            {
                gxtDebugDrawer.Singleton.AddRay(ray, Color.Green, 0.0f);
            }
            #elif BROADPHASE_TEST
            Vector2 aabbIntersectionPt;
            if (ray.IntersectsAABB(geomA.AABB, out t, out aabbIntersectionPt, float.MaxValue, true))
            {
                gxtLog.WriteLineV(gxtVerbosityLevel.INFORMATIONAL, "aabb intersection");
                gxtDebugDrawer.Singleton.AddRay(ray, t, Color.Green, 0.0f, System.TimeSpan.Zero);
                gxtDebugDrawer.Singleton.AddPt(aabbIntersectionPt, Color.YellowGreen, 0.0f);
            }
            else
            {
                gxtDebugDrawer.Singleton.AddRay(ray, Color.Green, 0.0f);
                gxtLog.WriteLineV(gxtVerbosityLevel.INFORMATIONAL, "no intersection");
            }

            Color aabbColor = new Color(100, 0, 0, 100); //new Color(1.0f, 0.0f, 0.0f, 1.0f);
            gxtDebugDrawer.Singleton.AddAABB(geomA.AABB, aabbColor, 1.0f);


            #endif



            gxtDebugDrawer.Singleton.AddPolygon(geomA.Polygon, geomAColor, 0.5f);
            gxtDebugDrawer.Singleton.AddPolygon(geomB.Polygon, geomBColor, 0.5f);

            float scalar = 0.85f;
            gxtDebugDrawer.Singleton.AddLine(bodyA.Position, bodyA.Position + forceBeforeClear * scalar, Color.Blue, 0.0f);
            //gxtDebugDrawer.Singleton.AddPolygon(geomB.Polygon, color, 0.5f);
            //gxtDebugDrawer.Singleton.AddString(geomB.Position.ToString(), geomB.Position, Color.White, 0.0f);

            //gxtLog.WriteLineV(gxtVerbosityLevel.INFORMATIONAL, "{0}", float.Epsilon);

            string fpsString = "FPS: " + gxtDebug.GetFPS().ToString();
            Vector2 strSize = gxtDebugDrawer.Singleton.DebugFont.MeasureString(fpsString);
            strSize *= 0.5f;
            Vector2 topLeftCorner = new Vector2(-gxtDisplayManager.Singleton.ResolutionWidth * 0.5f, -gxtDisplayManager.Singleton.ResolutionHeight * 0.5f);
            gxtDebugDrawer.Singleton.AddString("FPS: " + gxtDebug.GetFPS(), topLeftCorner + strSize, Color.White, 0.0f);
            topLeftCorner += new Vector2(0.0f, strSize.Y);
            string infoString = "Use Arrow Keys To Move The Polygon";
            strSize = gxtDebugDrawer.Singleton.DebugFont.MeasureString(infoString);
            strSize *= 0.5f;
            gxtDebugDrawer.Singleton.AddString(infoString, topLeftCorner + strSize + new Vector2(0, 1.0f), Color.White, 0.0f);
            topLeftCorner += new Vector2(0.0f, strSize.Y);
            string infoString2 = "Use Mouse To Aim the Ray, C To Change Its Position";
            strSize = gxtDebugDrawer.Singleton.DebugFont.MeasureString(infoString2);
            strSize *= 0.5f;
            gxtDebugDrawer.Singleton.AddString(infoString2, topLeftCorner + strSize + new Vector2(0, 2.0f), Color.White, 0.0f);
            //topLeftCorner += new Vector2(0.0f, gxtDebugDrawer.Singleton.DebugFont.MeasureString("FPS").Y);
            //gxtDebugDrawer.Singleton.AddString("Use Mouse To Aim the Ray", topLeftCorner, Color.White, 0.0f);
            world.LateUpdate(gameTime);
        }
コード例 #5
0
ファイル: gxtNarrowPhaseCollider.cs プロジェクト: Loko/GXT
        /// <summary>
        /// A ray - line segment intersection test
        /// Used as a support function for polygon raycasting
        /// </summary>
        /// <param name="ray">Ray</param>
        /// <param name="pt0">First Point of the Segment</param>
        /// <param name="pt1">Second Point of the Segment</param>
        /// <param name="t">Distance</param>
        /// <param name="tmax">Max Distance</param>
        /// <returns>If intersecting</returns>
        public bool RayIntersectsSegment(gxtRay ray, Vector2 pt0, Vector2 pt1, out float t, float tmax = float.MaxValue)
        {
            Vector2 seg = pt1 - pt0;
            Vector2 segPerp = gxtMath.LeftPerp(seg);
            float perpDotd = Vector2.Dot(ray.Direction, segPerp);
            if (gxtMath.Equals(perpDotd, 0.0f, float.Epsilon))
            {
                t = float.MaxValue;
                return false;
            }

            Vector2 d = pt0 - ray.Origin;

            t = Vector2.Dot(segPerp, d) / perpDotd;
            float s = Vector2.Dot(gxtMath.LeftPerp(ray.Direction), d) / perpDotd;

            return t >= 0.0f && t <= tmax && s >= 0.0f && s <= 1.0f;
        }
コード例 #6
0
ファイル: gxtGJKCollider.cs プロジェクト: Loko/GXT
        public static bool RayCast(gxtRay ray, gxtPolygon polygon, float tmax, out float t, out Vector2 pt, out Vector2 normal)
        {
            t = float.MaxValue;
            pt = ray.Origin;
            normal = ray.Direction;

            bool intersection = false;
            // temp holder for segment distance
            float distance;
            int crossings = 0;

            for (int j = polygon.NumVertices - 1, i = 0; i < polygon.NumVertices; j = i, i++)
            {
                if (RayIntersectsSegment(ray, polygon.v[j], polygon.v[i], float.MaxValue, out distance))
                {
                    crossings++;
                    if (distance < t && distance <= tmax)
                    {
                        intersection = true;

                        t = distance;
                        pt = ray.GetPoint(t);

                        Vector2 edge = polygon.v[i] - polygon.v[j];
                        normal = Vector2.Normalize(gxtMath.RightPerp(edge));
                        //normal = gxtMath.GetReflection(ray.Direction, edgeNormal);
                    }
                }
            }
            return intersection && crossings > 0 && crossings % 2 == 0;
        }
コード例 #7
0
ファイル: gxtGJKCollider.cs プロジェクト: Loko/GXT
 public static bool RayCast(gxtRay ray, gxtPolygon polygon, float tmax, out float t)
 {
     t = float.MaxValue;
     bool intersection = false;
     int crossings = 0;
     float distance;
     for (int j = polygon.NumVertices - 1, i = 0; i < polygon.NumVertices; j = i, i++)
     {
         if (RayIntersectsSegment(ray, polygon.v[j], polygon.v[i], float.MaxValue, out distance))
         {
             crossings++;
             if (distance < tmax)
                 intersection = true;
             if (distance < t)
                 t = distance;
         }
     }
     return intersection && crossings > 0 && crossings % 2 == 0;
 }
コード例 #8
0
ファイル: gxtGJKCollider.cs プロジェクト: Loko/GXT
        public static bool RayCast(gxtRay ray, gxtPolygon polygon)
        {
            //if (polygon.Contains(ray.Origin))
            //    return false;

            int crossings = 0;
            for (int j = polygon.NumVertices - 1, i = 0; i < polygon.NumVertices; j = i, i++)
            {
                if (RayIntersectsSegment(ray, polygon.v[j], polygon.v[i]))
                    crossings++;
            }
            return crossings > 0 && crossings % 2 == 0;
        }
コード例 #9
0
ファイル: gxtGJKCollider.cs プロジェクト: Loko/GXT
 /// <summary>
 /// http://objectmix.com/graphics/132701-ray-line-segment-intersection-2d.html#post460607
 /// </summary>
 /// <param name="ray"></param>
 /// <param name="a"></param>
 /// <param name="b"></param>
 /// <returns></returns>
 public static bool RayIntersectsSegment(gxtRay ray, Vector2 pt0, Vector2 pt1)
 {
     return RayIntersectsSegment(ray, pt0, pt1, float.MaxValue);
 }
コード例 #10
0
ファイル: SAPTestGame.cs プロジェクト: Loko/GXT
        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            base.Update(gameTime);
            gxtDebugDrawer.Singleton.CurrentSceneId = debugDrawerId;

            foreach (gxtISceneNode r in nodes)
            {
                r.SetColor(Color.Blue);
            }

            gxtKeyboard kb = gxtKeyboardManager.Singleton.GetKeyboard();
            float tx = 0.0f, ty = 0.0f;
            float cameraSpeed = 3.0f;
            if (kb.IsDown(Keys.A))
                tx -= cameraSpeed;
            if (kb.IsDown(Keys.W))
                ty -= cameraSpeed;
            if (kb.IsDown(Keys.D))
                tx += cameraSpeed;
            if (kb.IsDown(Keys.S))
                ty += cameraSpeed;
            if (kb.IsDown(Keys.Q))
                camera.Rotation -= 0.005f;
            if (kb.IsDown(Keys.E))
                camera.Rotation += 0.005f;
            if (kb.IsDown(Keys.Z))
                camera.Zoom += 0.01f;
            if (kb.IsDown(Keys.C))
                camera.Zoom = gxtMath.Min(gxtCamera.MIN_CAMERA_SCALE, camera.Zoom - 0.01f);
            if (kb.GetState(Keys.Tab) == gxtControlState.FIRST_PRESSED)
                gxtDisplayManager.Singleton.SetResolution(1280, 720, false);
            if (kb.GetState(Keys.CapsLock) == gxtControlState.FIRST_PRESSED)
                gxtDisplayManager.Singleton.SetResolution(800, 600, false);
                
            if (kb.GetState(Keys.T) == gxtControlState.FIRST_PRESSED)
                gxtLog.WriteLineV(gxtVerbosityLevel.INFORMATIONAL, drawableCollider.DebugTrace());
            if (kb.GetState(Keys.I) == gxtControlState.FIRST_PRESSED)
                drawIntervals = !drawIntervals;
            if (kb.GetState(Keys.B) == gxtControlState.FIRST_PRESSED)
                drawBoundingBoxes = !drawBoundingBoxes;
            if (kb.GetState(Keys.P) == gxtControlState.FIRST_PRESSED)
                gxtLog.WriteLineV(gxtVerbosityLevel.INFORMATIONAL, drawableCollider.DebugTracePairs());

            camera.TranslateLocal(tx, ty);

            gxtOBB camOBB = camera.GetViewOBB();
            camOBB.Extents *= 0.95f;

            gxtAABB camAABB = camera.GetViewAABB();
            camAABB.Extents *= 0.95f;

            gxtLog.WriteLineV(gxtVerbosityLevel.WARNING, "Zoom: {0}", camera.Zoom); 
            gxtDebugDrawer.Singleton.AddOBB(camOBB, Color.Yellow, 0.0f);
            gxtDebugDrawer.Singleton.AddAABB(camAABB, Color.Red, 0.0f);
            gxtDebugDrawer.Singleton.AddAxes(camera.Position, camera.Rotation, Color.Red, Color.Green, 0.0f);
            //gxtLog.WriteLineV(gxtVerbosityLevel.CRITICAL, "Camera Rotation: {0}", camera.Rotation.ToString());
            gxtAABB cameraAABB = camera.GetViewAABB();
            float cameraYBoundary = cameraAABB.Max.Y;
            float cameraXBoundary = cameraAABB.Max.X;

            gxtMouse mouse = gxtMouseManager.Singleton.GetMouse();
            Vector2 virtualMousePos = camera.GetVirtualMousePosition(mouse.GetPosition());
            gxtDebugDrawer.Singleton.AddPt(virtualMousePos, Color.Yellow, 0.0f);
            if (mouse.GetState(gxtMouseButton.LEFT) == gxtControlState.FIRST_PRESSED)
            {
                foreach (gxtISceneNode drawable in nodes)
                {
                    gxtAABB aabb = drawable.GetAABB();
                    if (aabb.Contains(virtualMousePos))
                    {
                        currentSelection = drawable;
                        currentSelection.SetColor(Color.Green);
                        //currentSelection.ColorOverlay = Color.Green;
                        //currentSelection = drawable as gxtRectangle;
                        //currentSelection.ColorOverlay = Color.Green;
                    }
                }
            }
            else if (mouse.GetState(gxtMouseButton.LEFT) == gxtControlState.DOWN)
            {
                if (currentSelection != null)
                {
                    if (kb.GetState(Keys.Delete) == gxtControlState.FIRST_PRESSED)
                    {
                        drawableCollider.RemoveObject(currentSelection);
                        sceneGraph.RemoveNode(currentSelection);
                        nodes.Remove(currentSelection);
                        currentSelection = null;
                        //drawManager.Remove(currentSelection);
                        //drawables.Remove(currentSelection);
                        //currentSelection = null;
                    }
                    else
                    {
                        Vector2 prevVirtualMousePos = camera.GetVirtualMousePosition(new Vector2(mouse.PrevState.X, mouse.PrevState.Y));
                        Vector2 d = virtualMousePos - prevVirtualMousePos;
                        currentSelection.Position += d;
                        gxtAABB aabb = currentSelection.GetAABB();
                        drawableCollider.UpdateObject(currentSelection, ref aabb);
                        currentSelection.SetColor(Color.Green);
                        //currentSelection.ColorOverlay = Color.Green;
                    }
                }

            }
            else if (mouse.IsUp(gxtMouseButton.LEFT))
            {
                if (currentSelection != null)
                {
                    currentSelection.SetColor(Color.Blue);
                    currentSelection = null;
                }
            }


            
            foreach (gxtISceneNode drawable in nodes)
            {
                if (drawBoundingBoxes)
                    gxtDebugDrawer.Singleton.AddAABB(drawable.GetAABB(), new Color(255, 0, 0, 100), 1.0f);
            }

            if (drawIntervals)
                drawableCollider.DebugDraw(Color.White, Color.Red, cameraYBoundary, cameraXBoundary);

            #if RAY_CAST_TEST
            Vector2 rayOrigin = new Vector2(-100.0f, 0.0f);
            Vector2 direction = virtualMousePos - rayOrigin;
            direction.Normalize();

            gxtRay ray = new gxtRay(rayOrigin, direction);
            List<gxtISceneNode> rayHits = drawableCollider.RayCastAll(ray);
            if (rayHits.Count != 0)
            {
                for (int i = 0; i < rayHits.Count; i++)
                {
                    rayHits[i].SetColor(Color.Orange, false);
                    gxtLog.WriteLineV(gxtVerbosityLevel.WARNING, "Num Ray Hits: {0}", rayHits.Count);
                    //gxtRectangle rect = rayHits[i] as gxtRectangle;
                    //rect.ColorOverlay = Color.Orange;
                }
                gxtDebugDrawer.Singleton.AddRay(ray, float.MaxValue, Color.Green, 0.0f);
            }
            else
            {
                gxtDebugDrawer.Singleton.AddRay(ray, Color.Green, 0.0f);
            }
            #else
            gxtBroadphaseCollisionPair<gxtISceneNode>[] rectPairs = drawableCollider.GetCollisionPairs();
            foreach (gxtBroadphaseCollisionPair<gxtISceneNode> rectPair in rectPairs)
            {
                rectPair.objA.ColorOverlay = Color.Orange;
                rectPair.objB.ColorOverlay = Color.Orange;
                gxtDebugDrawer.Singleton.AddPt(rectPair.objA.GetAABB().Position, Color.Yellow, 0.0f);
            }
            #endif


            //drawManager.Update();
            // fps at top left
            /*
            string fpsString = "FPS: " + gxtDebug.GetFPS().ToString();
            Vector2 strSize = gxtDebugDrawer.Singleton.DebugFont.MeasureString(fpsString);
            strSize *= 0.5f;
            Vector2 topLeftCorner = new Vector2(-gxtDisplayManager.Singleton.WindowWidth * 0.5f, -gxtDisplayManager.Singleton.WindowHeight * 0.5f);
            topLeftCorner += camera.Position;
            gxtDebugDrawer.Singleton.AddString("FPS: " + gxtDebug.GetFPS(), topLeftCorner + strSize, Color.White, 0.0f);
            */
            sceneGraph.Update(gameTime);
        }