foreach(Entity e1 in Data.entities.OfType<Player>())
            {
                foreach(Entity e2 in Data.entities.OfType<Collidable>())
                {
                    Matrix entityTransform;

                    entityTransform =
                        Matrix.CreateTranslation(new Vector3(-e2.origin, 0.0f)) *
                        Matrix.CreateRotationZ(e2.rotation) *
                        Matrix.CreateTranslation(new Vector3(e2.position, 0.0f)) *
                        Matrix.CreateScale(e2.scale.X, e2.scale.Y, 0.0f);

                    Rectangle entityRect = CalculateBoundingRectangle(new Rectangle(0, 0, e2.srcRect.Width, e2.srcRect.Height), entityTransform);

                    // The per-pixel check is expensive, so check the bounding rectangles
                    // first to prevent testing pixels when collisions are impossible.
                    if(e1.rectangle.Intersects(entityRect))
                    {
                        if(Sprite.IntersectPixels(e1.transform, e1.srcRect.Width, e1.srcRect.Height, e1.sprite.textureData,
                                                    e2.transform, e2.srcRect.Width, e2.srcRect.Height, e2.sprite.textureData))
                        {
                            e1.CollisionEvent(e2, gameTime);
                        }
                    }

                    /*
                    if (e1 != e2 && (e1.sprite.textureData != null && e2.sprite.textureData != null))
                    {
                        if (e1.rectangle.Intersects(e2.rectangle))
                        {
                            if (e1.sprite.IntersectsPixel(e1.rectangle, e1.sprite.textureData, e2.rectangle, e2.sprite.textureData))
                            {
                                e1.CollisionEvent(e2, gameTime);
                            }
                        }
                    }
                    */
                }
            }

            Data.entities.AddRange(Data.tempEntities);
            Data.tempEntities.Clear();
        }

        /*
        entityTransform =
                            Matrix.CreateTranslation(new Vector3(-e2.origin, 0.0f)) *
                            Matrix.CreateScale(e2.scale.X, e2.scale.Y, 0.0f) *
                            Matrix.CreateRotationZ(e2.rotation) *
                            Matrix.CreateTranslation(new Vector3(e2.position, 0.0f));
        */


        /// <summary>
        /// Calculates an axis aligned rectangle which fully contains an arbitrarily
        /// transformed axis aligned rectangle.
        /// </summary>
        /// <param name="rectangle">Original bounding rectangle.</param>
        /// <param name="transform">World transform of the rectangle.</param>
        /// <returns>A new rectangle which contains the trasnformed rectangle.</returns>
        public static Rectangle CalculateBoundingRectangle(Rectangle rectangle,
                                                           Matrix transform)
        {
            // Get all four corners in local space
            Vector2 leftTop = new Vector2(rectangle.Left, rectangle.Top);
            Vector2 rightTop = new Vector2(rectangle.Right, rectangle.Top);
            Vector2 leftBottom = new Vector2(rectangle.Left, rectangle.Bottom);
            Vector2 rightBottom = new Vector2(rectangle.Right, rectangle.Bottom);

            // Transform all four corners into work space
            Vector2.Transform(ref leftTop, ref transform, out leftTop);
            Vector2.Transform(ref rightTop, ref transform, out rightTop);
            Vector2.Transform(ref leftBottom, ref transform, out leftBottom);
            Vector2.Transform(ref rightBottom, ref transform, out rightBottom);

            // Find the minimum and maximum extents of the rectangle in world space
            Vector2 min = Vector2.Min(Vector2.Min(leftTop, rightTop),
                                      Vector2.Min(leftBottom, rightBottom));
            Vector2 max = Vector2.Max(Vector2.Max(leftTop, rightTop),
                                      Vector2.Max(leftBottom, rightBottom));

            // Return that as a rectangle
            return new Rectangle((int)min.X, (int)min.Y,
                                 (int)(max.X - min.X), (int)(max.Y - min.Y));
        }