////////////////////////////////////////////////////////////
 /// <summary>
 /// Copy constructor
 /// </summary>
 /// <param name="copy">States to copy</param>
 ////////////////////////////////////////////////////////////
 public RenderStates(RenderStates copy)
 {
     BlendMode = copy.BlendMode;
     Transform = copy.Transform;
     Texture = copy.Texture;
     Shader = copy.Shader;
 }

        public void Initialize()
        {
            SelectedShader = new Shader(null, "Shader/SelectedShader.frag");
            SelectedState = new RenderStates(SelectedShader);

            AddControls();
        }

 public void Draw(RenderTarget target, RenderStates states)
 {
     target.Draw(background, states);
     foreach (Layer l in layers) {
         target.Draw(l, states);
     }
 }

        public RenderTarget(SFML.Graphics.RenderTarget renderTarget)
        {
            this.renderTarget = renderTarget;
            m_VertexCache = new Vertex[CacheSize];

            m_RenderState = RenderStates.Default;
        }

        public Deathmatch()
            : base()
        {
            Projectiles = new List<Projectile>();
            BackgroundImages = new List<Sprite>();
            BackgroundImagesFar = new List<Sprite>();
            BackgroundTracks = new List<Sprite>();
            BackgroundGameObjects = new List<GameObject>();
            Players = new List<Actor>();
            Mailman = new ClientMailman(this);

            shader = new RenderStates(new Shader(null, "Content/bgPrlx.frag"));
            Image mapImg = new Image("Content/mapCol.png");
            mapBytes = mapImg.Pixels;
            mapSprite = new Sprite(new Texture(mapImg));
            mapWidth = (int)mapImg.Size.X;
            mapHeight = (int)mapImg.Size.Y;

            player = new ClientPlayer(this);
            player.Pos = new Vector2f(46, 62);
            Players.Add(player);

            trainSoundExterior = new SoundInstance(Content.GetSound("trainSpeed2.wav"), 1f, 0, 15, true);
            trainSoundInterior = new SoundInstance(Content.GetSound("trainSpeed0.wav"), 1, 0, 15, true);
            trainSound = trainSoundExterior;

            MainGame.Camera.Center = player.Pos - new Vector2f(0, 90);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="SFML"/> class.
 /// </summary>
 /// <param name="target">SFML render target.</param>
 public SFML(RenderTarget target)
 {
     m_Target = target;
     m_VertexCache = new Vertex[CacheSize];
     m_RenderState = new RenderStates(BlendMode.Alpha);
         // somehow worked without this in previous SFML version (May 9th 2010)
 }

        public override void Draw(RenderTarget target, RenderStates states)
        {
            states.Transform *= Transform;
            graphic.Draw(target, states);

            base.Draw(target, states);
        }

        public void Draw(RenderTarget target, RenderStates states)
        {
            body.FillColor = data.FillColor;

            target.Draw(body);
            target.Draw(text);
        }

        public Menu()
            : base()
        {
            hoverCursor = Content.GetTexture("cursorHover.png");
            defaultCursor = Content.GetTexture("cursorPointer.png");
            currentCursor = defaultCursor;
            char1 = new Animation(Content.GetTexture("idle.png"), 4, 0, 0, true);
            char2 = new Animation(Content.GetTexture("char2_idle.png"), 4, 0, 0, true);
            shader = new RenderStates(new Shader(null, "Content/bgPrlx.frag"));

            rectConnect = new RectangleShape()
            {
                Size = new Vector2f(150, 30),
                Position = new Vector2f(-25, 70)
            };
            rectIP = new RectangleShape()
            {
                Size = new Vector2f(150, 20),
                Position = new Vector2f(-25, 40)
            };
            rectUsername = new RectangleShape()
            {
                Size = new Vector2f(150, 20),
                Position = new Vector2f(-25, 10)
            };

            MainGame.window.TextEntered += TextEnteredEvent;
        }

 public override void Draw(RenderTarget target, RenderStates states)
 {
     var sprite = sprites[type];
     sprite.Position = new Vector2f(x, y);
     sprite.Rotation = rotation;
     target.Draw(sprite);
 }

        public void Draw(RenderTarget target, RenderStates states)
        {
            states.Transform.Combine(Transform);

            target.Draw(m_QuadArray, states);
            target.Draw(m_LineArray, states);
        }

        public void Draw(VertexArray vertices, RenderStates states) {
            if (!drawing) return;

            // Render states have changed, so flush and clear.
            if (!CompareStates(renderStates, states)) {
                Flush();
                vertexArray.Clear();
                renderStates = states;
            }

            // Exceeding maximum sprites, so flush and clear.
            if (DrawCount >= MaxSprites) {
                Flush();
                DrawCount = 0;
                vertexArray.Clear();
            }

            // Apply the transform to the four points
            var transform = states.Transform;
            
            // Append the vertices
            for (uint i = 0; i < vertices.VertexCount; i++) {
                var vertex = vertices[i];
                var pos = transform.TransformPoint(vertex.Position.X, vertex.Position.Y);
                vertex.Position.X = pos.X;
                vertex.Position.Y = pos.Y;
                vertexArray.Append(vertex);
            }

            DrawCount++;
            // I think that's it?
        }

        public void Draw(RenderTarget target, RenderStates states)
        {
            if (data.PictureSprite != null)
                curentPicture = data.PictureSprite;

            target.Draw(frame);
            target.Draw(curentPicture);
        }

        public void Draw(RenderTarget target, RenderStates states)
        {
            if (_dirty)
                Rebuild();

            states.Transform *= Transform;
            target.Draw(_vertices, states);
        }

 public void Draw(RenderTarget target, RenderStates states)
 {
     target.Draw(rectangleShape);
     target.Draw(unitPictureBoxRenderer);
     target.Draw(healthBarRenderer);
     target.Draw(MoveButtonRenderer);
     target.Draw(AttackButtonRenderer);
 }

 public ShieldGenerator(Vector2f position)
 {
     tex = Content.GetTexture("generatorStand.png");
     col = Content.GetTexture("genBlue.png");
     shader = new RenderStates(new Shader(null, "Content/shield.frag"));
     whenPlaced = DateTime.Now;
     Pos = position;
 }

   bool CompareStates(RenderStates a, RenderStates b) {
       if (a.Texture != b.Texture) return false;
       if (a.Shader != b.Shader) return false;
       if (a.BlendMode != b.BlendMode) return false;
       // Dont care about transform right now.
 
       return true;
   }

 private void DrawBackground(RenderTarget target, Texture background, Vector2f cameraPosition)
 {
     var renderState = new RenderStates(BlendMode.Add);
     var offset = new Vector2f(0.12f * cameraPosition.X % background.Size.X, 0.12f * cameraPosition.Y % background.Size.Y);
     renderState.Transform.Translate(-offset);
     var bgSprite = new Sprite(background, new IntRect(0, 0, (int)target.Size.X * 2, (int)target.Size.Y * 2));
     target.Draw(bgSprite, renderState);
 }

 public void Draw(RenderTarget target, RenderStates states)
 {
     target.Draw(mapRenderer);
     for (int i = 0; i < UnitRenderers.Length; i++)
     {
         target.Draw(UnitRenderers[i]);
     }
     target.Draw(interfaceBarRenderer);
 }

 public FastTextureAtlas(TextureAtlas atlas)
 {
     TextureAtlas = atlas;
     _atlas = new Sprite(TextureAtlas.Texture);
     RenderTexture = new RenderTexture(atlas.Size, atlas.Size);
     RenderTexture.Draw(_atlas);
     RenderTexture.Display();
     _replace = new RenderStates(BlendMode.None, Transform.Identity, null, null);
 }