public override void Draw(RenderTarget target, Vector2f position)
        {
            _icon.Position = position;
            target.Draw(_icon);

            if (_amount == 0)
            {
                var darken = new RectangleShape(new Vector2f(Hud.IconSize - Hud.IconBorderTwice, Hud.IconSize - Hud.IconBorderTwice));
                darken.Origin = new Vector2f(Hud.IconSizeHalf - Hud.IconBorder, Hud.IconSizeHalf - Hud.IconBorder);
                darken.FillColor = new Color(0, 0, 0, 200);
                darken.Position = position;
                target.Draw(darken);
            }

            if (_time > 0)
            {
                var per = _time / BuildTime;
                var box = new RectangleShape(new Vector2f(per * (Hud.IconSize - Hud.IconBorderTwice), 8));
                box.FillColor = new Color(0, 180, 0, 128);
                box.Position = position - new Vector2f(Hud.IconSizeHalf - Hud.IconBorder, Hud.IconSizeHalf - Hud.IconBorder);
                target.Draw(box);
            }

            _amountText.DisplayedString = _amount.ToString("G");
            _amountText.Position = position + new Vector2f(Hud.IconSizeHalf - Hud.Padding, Hud.IconSizeHalf - Hud.Padding);

            var bounds = _amountText.GetLocalBounds();
            _amountText.Origin = new Vector2f(bounds.Width + bounds.Left, bounds.Height + bounds.Top);

            target.Draw(_amountText);
        }

        public override void Draw(RenderTarget rt)
        {
            Text title = new Text("Oh no! Something went wrong!", Assets.LoadFont(Program.DefaultFont))
            {
                Position = new Vector2f(GameOptions.Width / 2.0f, 48.0f),
                CharacterSize = 48,
                Color = Color.White
            };

            title.Center();
            title.Round();
            rt.Draw(title);

            Text blackCardText = new Text(value, Assets.LoadFont(Program.DefaultFont))
            {
                Position = new Vector2f(GameOptions.Width / 2.0f, GameOptions.Height / 2.0f),
                CharacterSize = 36,
                Color = Color.White
            };

            blackCardText.Center();
            blackCardText.Round();
            rt.Draw(blackCardText);

            base.Draw(rt);
        }

        public override void Draw(RenderTarget rt)
        {
            Vector2f actualPosition = Position + (Selected ? new Vector2f(0, -12.0f - 5.0f * GetSelectedIndex()) : new Vector2f());

            // Draw card
            Sprite sprite = new Sprite(Assets.LoadTexture(Info.Type == CardType.White ? "CardWhite.png" : "CardBlack.png"));
            Size = new Vector2f(sprite.GetGlobalBounds().Width, sprite.GetGlobalBounds().Height);
            sprite.Position = actualPosition;
            sprite.Scale = Scale;
            rt.Draw(sprite);

            // Draw text
            Text text = GameUtility.Wrap(Info.Value, Assets.LoadFont("arialbd.ttf"), (uint)Math.Floor(24.0f * Scale.X),
                                     Math.Floor(207.0f * Scale.X));

            text.Color = Info.Type == CardType.White ? Color.Black : Color.White;
            text.Position = actualPosition + new Vector2f(16.0f * Scale.X, 10.0f * Scale.Y);
            text.Round();
            rt.Draw(text);

            // Draw decorations
            if (Info.PickCount > 1)
            {
                Sprite pickMultiple = new Sprite(Assets.LoadTexture(Info.PickCount == 2 ? "PickTwo.png" : "PickThree.png"))
                {
                    Position =
                        actualPosition +
                        new Vector2f((241.0f - 56.0f - 10.0f - 4.0f) * Scale.X, (320.0f - 10.0f - 20.0f) * Scale.Y),
                    Scale = Scale
                };

                rt.Draw(pickMultiple);
            }
        }

 public void Draw(RenderTarget window, Location offset)
 {
     rect.Rotation = -Rotation - 90;
     rect.Position = Location.Vec2f + offset.Vec2f;
     rect.Texture = texture;
     window.Draw(rect);
 }

        public MeshShape(RenderTarget initialRenderTarget, Random random, D2DFactory d2DFactory, D2DBitmap bitmap)
            : base(initialRenderTarget, random, d2DFactory, bitmap)
        {
            FillBrush = RandomBrush();

            mesh = CoinFlip ? MeshFromRandomGeometry() : MeshFromRandomTriangles();
        }

 protected internal override void Draw(RenderTarget renderTarget)
 {
     if (StrokeStyle != null)
         renderTarget.DrawLine(point0, point1, PenBrush, StrokeWidth, StrokeStyle);
     else
         renderTarget.DrawLine(point0, point1, PenBrush, StrokeWidth);
 }

        public override void Draw(RenderTarget window)
        {
            if (BackgroundShape != null)
                BackgroundShape.Draw(window);

            base.Draw(window);
        }

        public BloomTest(RenderTexture target_tex, RenderTarget target)
        {
            _target = target;

            _bloom = new Shader(null, "bloom.glsl");
            _texture = new RenderTexture((uint)GlobalProps.Width, (uint)GlobalProps.Height);
            _states.BlendMode = BlendMode.Alpha;
            _states.Shader = _bloom;
            _states.Transform = Transform.Identity;
            _states.Texture = target_tex.Texture;
            _bloom.SetParameter("referenceTex", Shader.CurrentTexture);
            _bloom.SetParameter("pixelWidth", 4);
            _bloom.SetParameter("pixelHeight", 4);

            int w = GlobalProps.Width, h = GlobalProps.Height;
            Vector2f v0 = new Vector2f(0, 0);
            Vector2f v1 = new Vector2f(w, 0);
            Vector2f v2 = new Vector2f(w, h);
            Vector2f v3 = new Vector2f(0, h);

            _verts = new Vertex[4];
            _verts[0] = new Vertex(v0, Color.White, v0);
            _verts[1] = new Vertex(v1, Color.White, v1);
            _verts[2] = new Vertex(v2, Color.White, v2);
            _verts[3] = new Vertex(v3, Color.White, v3);
        }

        /// <summary>
        /// Contains the shared constructor code
        /// </summary>
        /// <param name="target"></param>
        private Gui(RenderTarget target)
        {
            _renderer = new Gwen.Renderer.SFML(target);

            skin = new TexturedBase(_renderer, "DefaultSkin.png");

            // load font. TODO: remove hardcoding
            using (var font = new Gwen.Font(_renderer, "OpenSans.ttf", 14))
            {
                if (_renderer.LoadFont(font))
                    _renderer.FreeFont(font);
                else
                {
                    font.FaceName = "Arial Unicode MS";
                    if (_renderer.LoadFont(font))
                        _renderer.FreeFont(font);
                    else
                    {
                        font.FaceName = "Arial";
                        _renderer.LoadFont(font);
                    }
                }

                skin.SetDefaultFont(font.FaceName, 14);
            }

            GuiCanvas = new Canvas(skin);
            GuiCanvas.SetSize((int)target.Size.X, (int)target.Size.Y);
            GuiCanvas.ShouldDrawBackground = false;
            GuiCanvas.BackgroundColor = System.Drawing.Color.Black;
            GuiCanvas.KeyboardInputEnabled = true;

            _input = new Gwen.Input.SFML();
            _input.Initialize(GuiCanvas, target);
        }

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

        public override void Draw(RenderTarget rt)
        {
            RectangleShape bgOverlay = new RectangleShape(new Vector2f(GameOptions.Width, GameOptions.Height)) { FillColor = Color.Black };
            rt.Draw(bgOverlay);

            Text title = new Text("Game Over", Assets.LoadFont(Program.DefaultFont))
            {
                Position = new Vector2f(GameOptions.Width / 2.0f, 48.0f),
                CharacterSize = 48,
                Color = Color.White
            };

            title.Center();
            title.Round();
            rt.Draw(title);

            Text winnerTitle = new Text(GetWinnerText(), Assets.LoadFont(Program.DefaultFont))
            {
                Position = new Vector2f(GameOptions.Width / 2.0f, GameOptions.Height / 2.0f),
                CharacterSize = 48,
                Color = Color.White
            };

            winnerTitle.Center();
            winnerTitle.Round();
            rt.Draw(winnerTitle);

            base.Draw(rt);
        }

        public override void Draw(RenderTarget rt)
        {
            RectangleShape overylay = new RectangleShape(new Vector2f(GameOptions.Width, GameOptions.Height))
            {
                FillColor = new Color(0, 0, 0, 128)
            };

            rt.Draw(overylay);

            RectangleShape window = new RectangleShape(new Vector2f(GameOptions.Width * (1.0f - PaddingHorizontal * 2.0f), GameOptions.Height * (1.0f - PaddingVertical * 2.0f)))
            {
                Position = new Vector2f(GameOptions.Width * PaddingHorizontal, GameOptions.Height * PaddingVertical),
                FillColor = Color.White,
                OutlineColor = Color.Black,
                OutlineThickness = 2.0f
            };

            rt.Draw(window);

            Text labelSettings = new Text("Join by IP", Assets.LoadFont(Program.DefaultFont))
            {
                Position = new Vector2f(GameOptions.Width / 2.0f, GameOptions.Height * PaddingVertical + 48.0f),
                Color = Color.Black,
                CharacterSize = 32
            };

            labelSettings.Center();
            labelSettings.Round();
            rt.Draw(labelSettings);

            base.Draw(rt);
        }

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

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

        public string GetHeader(RenderTarget target)
        {
            var jsQuery = new NameValueCollection();
            jsQuery["file"] = "js";

            var cssQuery = new NameValueCollection();
            cssQuery["file"] = "css";

            return string.Format(@"
            <script src=""{0}""></script>
            <link rel=""stylesheet"" href=""{1}"" type=""text/css"" />
            <script type=""text/javascript"">
            (function($){{
            $.telligent.evolution.ui.components.poll.configure({{deleteMessage:'{2}',voteMessage:'{3}',votingEndsMessage:'{4}',votingEndsResultsHiddenMessage:'{5}',votingEndedMessage:'{6}'}});
            }}(jQuery));
            </script>
            ",
                _callbackController.GetUrl(jsQuery),
                _callbackController.GetUrl(cssQuery),
                TEApi.Javascript.Encode(_translation.GetLanguageResourceValue("poll_vote_delete")),
                TEApi.Javascript.Encode(_translation.GetLanguageResourceValue("poll_vote")),
                TEApi.Javascript.Encode(_translation.GetLanguageResourceValue("poll_voting_ends")),
                TEApi.Javascript.Encode(_translation.GetLanguageResourceValue("poll_voting_ends_results_hidden")),
                TEApi.Javascript.Encode(_translation.GetLanguageResourceValue("poll_voting_ended"))
                );
        }

        public static SurfacePattern CreateTileBrush(TileBrush brush, Size targetSize)
        {
            var helper = new TileBrushImplHelper(brush, targetSize);
            if (!helper.IsValid)
                return null;
            
			using (var intermediate = new ImageSurface(Format.ARGB32, (int)helper.IntermediateSize.Width, (int)helper.IntermediateSize.Height))
            using (var ctx = new RenderTarget(intermediate).CreateDrawingContext())
            {
                helper.DrawIntermediate(ctx);

                var result = new SurfacePattern(intermediate);

                if ((brush.TileMode & TileMode.FlipXY) != 0)
                {
                    // TODO: Currently always FlipXY as that's all cairo supports natively. 
                    // Support separate FlipX and FlipY by drawing flipped images to intermediate
                    // surface.
                    result.Extend = Extend.Reflect;
                }
                else
                {
                    result.Extend = Extend.Repeat;
                }

                if (brush.TileMode != TileMode.None)
                {
                    var matrix = result.Matrix;
                    matrix.InitTranslate(-helper.DestinationRect.X, -helper.DestinationRect.Y);
                    result.Matrix = matrix;
                }

                return result;
            }
        }

 public override void Draw(RenderTarget r)
 {
     var text = ((int)(1000/EntityManager.FrameTime)).ToString () + " FPS";
     DebugText = new Text(text, DebugText.Font)
     {Position = r.GetView ().Center - r.GetView ().Size/2, Color = DebugText.Color};
     r.Draw (DebugText);
 }

 /// <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 void Render(HDRSettings settings, RenderTarget input, RenderTarget output, RenderTarget bloom, RenderTarget lensFlares, RenderTarget luminance)
        {
            if (ShaderParams == null)
            {
                ShaderParams = new TonemapShaderParams();
                Shader.GetUniformLocations(ShaderParams);
            }

            Backend.BeginPass(output, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));

            Textures[0] = input.Textures[0].Handle;
            Textures[1] = luminance.Textures[0].Handle;

            var activeTexture = 2;
            if (settings.EnableBloom)
                Textures[activeTexture++] = bloom.Textures[0].Handle;
            if (settings.EnableLensFlares)
                Textures[activeTexture++] = lensFlares.Textures[0].Handle;

            Backend.BeginInstance(Shader.Handle, Textures, samplers: Samplers);
            Backend.BindShaderVariable(ShaderParams.SamplerScene, 0);
            Backend.BindShaderVariable(ShaderParams.SamplerBloom, 2);
            Backend.BindShaderVariable(ShaderParams.SamplerLensFlares, 3);
            Backend.BindShaderVariable(ShaderParams.SamplerLuminance, 1);
            Backend.BindShaderVariable(ShaderParams.KeyValue, settings.KeyValue);
            Backend.BindShaderVariable(ShaderParams.EnableBloom, settings.EnableBloom ? 1 : 0);
            Backend.BindShaderVariable(ShaderParams.EnableLensFlares, settings.EnableLensFlares ? 1 : 0);

            Backend.DrawMesh(QuadMesh.MeshHandle);
            Backend.EndPass();
        }

 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 override void Draw(RenderTarget target, RenderStates states)
        {
            states.Transform *= Transform;
            graphic.Draw(target, states);

            base.Draw(target, states);
        }