public void OnEnable()
 {
     _Camera             = (Camera)target;
     _Camera2D           = _Camera.gameObject.GetComponent<Camera2D>();
     _Camera2D           = _Camera2D ?? _Camera.gameObject.AddComponent<Camera2D>();
     _Camera2D.hideFlags = HideFlags.HideInInspector;
 }

        public void Draw(Camera2D camera, List<Tileset> tilesets)
        {
            var destination = new Rectangle(0, 0, Engine.TileWidth, Engine.TileHeight);

            // TODO: Replace this drawcall with a single drawcall to render all grass tiles
            for (int y = 0; y < Height; y++)
            {
                destination.Y = y * Engine.TileHeight + (int)Engine.Origin.Y;

                for (int x = 0; x < Width; x++)
                {
                    Tile tile = GetTile(x, y);

                    if (tile.TileIndex == -1 || tile.Tileset == -1)
                        continue;

                    destination.X = x * Engine.TileWidth + (int)Engine.Origin.X;

                    var position = new Vector2(destination.X, destination.Y);
                    if (camera.IsVisible(position))
                    {
                        FinalBomber.Instance.SpriteBatch.Draw(
                            tilesets[tile.Tileset].Texture,
                            destination,
                            tilesets[tile.Tileset].SourceRectangles[tile.TileIndex],
                            Color.White);
                    }
                }
            }
        }

 public override void Draw(Camera2D camera)
 {
     _spriteBatch.Begin(sortMode: SpriteSortMode.Immediate, blendState: BlendState.AlphaBlend,
         samplerState: SamplerState.PointClamp, transformMatrix: camera.GetViewMatrix());
     _spriteBatch.Draw(_texture, Position, Color.White);
     _spriteBatch.End();
 }

        void DrawTile(Map map, Layer layer, Camera2D camera, Vector2 position, string selectedTileName)
        {
            if (!string.IsNullOrEmpty(selectedTileName))
            {
                var point = new Vector2((int)((camera.Position.X + position.X) / 32), (int)((camera.Position.Y + position.Y) / 32));

                if (layer.Tiles.ContainsKey(point))
                    layer.Tiles.Remove(point);

                layer.Tiles.Add(point, TileRepository.GetTile(selectedTileName));

                /*UndoService.Current[map].AddChange(new DelegateChange(null, new Action(() =>
                {
                    layer.Tiles.Remove(point);
                }), new Action(() =>
                {
                    layer.Tiles.Add(point, TileRepository.GetTile(selectedTileName));
                }), selectedTileName), "Draw a tile");*/

                /*MainForm.MapPanel.AddShadowForObject(Texture2D.FromStream(MainForm.MapPanel.GraphicsDevice, TileRepository.GetTile(selectedTileName).Texture),
                    point);*/

                base.OnMouseMove(map, layer, camera, position, selectedTileName);
            }
        }

 public Screen(ScreenManager manager)
 {
     this.manager = manager;
     this.loadComplete = false;
     this.camera = new Camera2D(manager.ViewManager.Width, manager.ViewManager.Height);
     this.inputManager = new InputManager();
 }

 public void Update(Camera2D camera)
 {
     if (this.AttachedProjectile.X <= (float)(camera.Bounds.Left + this.m_iconOffset))
     {
         base.X = (float)this.m_iconOffset;
     }
     else if (this.AttachedProjectile.X > (float)(camera.Bounds.Right - this.m_iconOffset))
     {
         base.X = (float)(1320 - this.m_iconOffset);
     }
     else
     {
         base.X = this.AttachedProjectile.X - camera.TopLeftCorner.X;
     }
     if (this.AttachedProjectile.Y <= (float)(camera.Bounds.Top + this.m_iconOffset))
     {
         base.Y = (float)this.m_iconOffset;
     }
     else if (this.AttachedProjectile.Y > (float)(camera.Bounds.Bottom - this.m_iconOffset))
     {
         base.Y = (float)(720 - this.m_iconOffset);
     }
     else
     {
         base.Y = this.AttachedProjectile.Y - camera.TopLeftCorner.Y;
     }
     base.Rotation = CDGMath.AngleBetweenPts(camera.TopLeftCorner + base.Position, this.AttachedProjectile.Position);
     this.m_iconBG.Position = base.Position;
     this.m_iconBG.Rotation = base.Rotation;
     this.m_iconProjectile.Position = base.Position;
     this.m_iconProjectile.Rotation = this.AttachedProjectile.Rotation;
     this.m_iconProjectile.GoToFrame(this.AttachedProjectile.CurrentFrame);
 }

        public void Draw(Camera2D camera, GameTime gameTime)
        {
            if (PreSteps.Count > 0)
                foreach (var s in PreSteps)
                    s(camera, this, gameTime);

            if (Skip)
                return;

            camera.GraphicsDevice.SetRenderTarget(RenderTarget);

            if (ClearColor != null)
                camera.GraphicsDevice.Clear(ClearColor.Value);

            if (ShaderSteps.Count > 0)
                foreach (var s in ShaderSteps)
                    s.Prepare(camera);

            camera.Begin(SpriteSortMode, BlendState, SamplerState, DepthStencilState, RasterizerState, Effect, TransformMatrix);

            if (DrawSteps.Count > 0)
                foreach (var s in DrawSteps)
                    s(camera, this, gameTime);

            camera.End();
        }

 public void Draw(SpriteBatch spriteBatch, Camera2D camera)
 {
     foreach (MapLayer layer in mapLayers)
     {
         layer.Draw(camera, tilesets);
     }
 }

 public Scenario(GameScreen gameScreen, GameWorld world, Camera2D camera)
     : base(gameScreen, world, camera)
 {
     levelNumber = 0;
     physics.bodys = new Body[1]{ new Body(world) };
     images = new List<SpriteSheet>();
 }

        public void UpdateParallax(Camera2D _camera)
        {
            Matrix pos = _camera.GetParallaxMatrix(_speed);
            if (_camera.IsPlayerFollow)
            {
                _position.X = -pos.M41 - (int)-pos.M41 % _width;
                _position2.X = _position.X + _width;
            }
            else
            {
                if (-pos.M41 > _position2.X + -_camera.Translation.X &&
                    -pos.M41 < _position2.X + _width)
                    _position.X = _position2.X + _width;
                else
                    _position.X = _position2.X - _width;

                if (-pos.M41 > _position.X + -_camera.Translation.X &&
                    -pos.M41 < _position.X + _width)
                    _position2.X = _position.X + _width;
                else
                    _position2.X = _position.X - _width;
            }

            _position.Y = -pos.M42;
            _position2.Y = -pos.M42;
        }

        public ControllerViewManager(GraphicsDevice graphicsDevice, ContentManager content)
        {
            controllers = new List<Controller>();
            views = new List<IView>();

            this.content = content;
            this.graphicsDevice = graphicsDevice;
            this.batch = new SpriteBatch(graphicsDevice);
            this.world = new World(new Vector2(0, Constants.GamePlayGravity));
            this.controllerQueue = new ConcurrentQueue<Tuple<Controller, QueueState>>();
            this.viewQueue = new ConcurrentQueue<Tuple<IView, QueueState>>();

            if (Constants.DebugMode && debugView == null)
            {
                debugView = new DebugViewXNA(world);
                debugView.AppendFlags(DebugViewFlags.DebugPanel);
                debugView.DefaultShapeColor = Color.Red;
                debugView.SleepingShapeColor = Color.Green;
                debugView.LoadContent(graphicsDevice, content);
            }

            if (camera == null)
            {
                Viewport v = graphicsDevice.Viewport;
                camera = new Camera2D(graphicsDevice);
                camera.Position = new Vector2(v.Width / 2, v.Height / 2);
            }
            else camera.ResetCamera();
        }

        public override void Draw(SpriteBatch spriteBatch, Camera2D camera, Vector2 mousePosition, Texture2D pixel)
        {
            spriteBatch.Draw(pixel, new Rectangle((int)((camera.Position.X + mousePosition.X) / 32) * 32 + 1, (int)((camera.Position.Y + mousePosition.Y) / 32) * 32, 32, 32),
                Color.Orange);

            base.Draw(spriteBatch, camera, mousePosition, pixel);
        }

 public override void Draw(Camera2D camera)
 {
     if ((this.ShowTerrain && CollisionMath.Intersects(this.Bounds, camera.Bounds)) || base.ForceDraw)
     {
         camera.Draw(Game.GenericTexture, base.Position, new Rectangle?(new Rectangle(0, 0, this.Width, this.Height)), base.TextureColor, MathHelper.ToRadians(base.Rotation), Vector2.Zero, 1f, SpriteEffects.None, 0f);
     }
 }

 public GameWorld(Vector2 gravity, float airDrag, Camera2D camera)
     : base(gravity)
 {
     this.camera = camera;
     this.airDrag = airDrag;
     this.BodyAdded += BodyAddedHandler;
 }

        public Engine(ContentManager content, ScreenManager screenManager)
        {
            this.ScreenManager = screenManager;

            components = new List<Component>();
            componentsToBeAdded = new List<Component>();
            componentsToBeRemoved = new List<Component>();

            Content = content;

            Audio = new Audio(this);
            Input = new InputState();
            Physics = new Physics(this);
            Video = new Video(this);

            // these things require video
            Camera = new Camera2D(this);

            // lighting needs to know the camera matrix
            Lighting = new Lighting(this);

            SpriteBatch = new SpriteBatch(Global.GraphicsDeviceManager.GraphicsDevice);

            BloomComponent = new BloomComponent(this);
            BloomComponent.DrawOrder = int.MaxValue;
            BloomComponent.LoadContent();

            Updating = false;
        }

        public override void LoadContent()
        {
            if (Camera == null)
            {
                Camera = new Camera2D(ScreenManager.GraphicsDevice);
            }

            iHUD = ScreenManager.Game.Services.GetService(typeof(IHUD)) as IHUD;
            iVisualiser = ScreenManager.Game.Services.GetService(typeof(IVisualiser)) as IVisualiser;

            //Swinger texture
            SwingerTexture = ScreenManager.Content.Load<Texture2D>("Common/slider");
            //Halo texture
            HaloTexture = ScreenManager.Content.Load<Texture2D>("Common/halo");
            //SpeedBoost texture
            SpeedBoostTexture = ScreenManager.Content.Load<Texture2D>("Common/slider");
            //bullet texture
            BulletTexture = ScreenManager.Content.Load<Texture2D>("Common/bullet");
            
            ////////////////////////////////
            //ObstacleManager
            ////////////////////////////////
            ObstacleManager = new ObstacleManager();
            ObstacleManager.LoadContent(ScreenManager);
            
            base.LoadContent();
        }

 public void Update(Camera2D _camera)
 {
     if (_isMoving)
         UpdateMove(_camera);
     else
         UpdateParallax(_camera);
 }

 public Layer(Camera2D camera, float scrollRateX = 1f, float scrollRateY = 1f)
 {
     Offset = new Vector2(0,0);
     this.Camera = camera;
     ScrollRateX = scrollRateX ;
     ScrollRateY = ScrollRateY ;
 }

 public override void Draw(SpriteBatch spritebatch, Camera2D camera = null)
 {
     Vector2 r = rotationMatrix.rotate(new Vector2((int)(xPosition), (int)(yPosition)));
     if (camera == null || camera.IsInView(r, texture))
     {
         spritebatch.Draw(texture, r, null, Color.White, 0, new Vector2(texture.Width / 2, texture.Height / 2), 1, SpriteEffects.None, 0);
     }
 }

        public void UpdateMove(Camera2D _camera)
        {
            Matrix pos = _camera.GetTransformMatrix();

            if (-pos.M41 % _width*2 == 0)
                _position.X = -pos.M41 + _width;
            _position.X += -_speed;
        }