Exemple #1
0
 public override void DrawRectangle(Rectangle area, Brush brush, Thickness thickness, double radius,
     Rectangle bounds)
 {
     SetClipArea(bounds);
     if (area != Rectangle.Empty)
     {
         if (radius > 0)
         {
             FillRectangle(area, brush, radius, bounds);
         }
         else
         {
             var areaXNA = area.ToXNA();
             FillRect(new RectangleXNA(areaXNA.X,
                 areaXNA.Top, areaXNA.Width, thickness.Top), brush);
             FillRect(new RectangleXNA(areaXNA.X,
                 areaXNA.Top + thickness.Top, thickness.Left, areaXNA.Height - thickness.Top - thickness.Bottom),
                 brush);
             FillRect(new RectangleXNA(areaXNA.Right - thickness.Right,
                 areaXNA.Top + thickness.Top, thickness.Right, areaXNA.Height - thickness.Top - thickness.Bottom),
                 brush);
             FillRect(new RectangleXNA(areaXNA.X,
                 areaXNA.Bottom - thickness.Bottom, areaXNA.Width, thickness.Bottom), brush);
         }
     }
     ResetClipArea();
 }
Exemple #2
0
 public bool Equals(Rectangle other)
 {
     return X.Equals(other.X) && Y.Equals(other.Y) && Width.Equals(other.Width) && Height.Equals(other.Height);
 }
Exemple #3
0
 private void UseMaskStencil(Rectangle area)
 {
     // If the mask area doesn't overlap any previous areas, it is safe to reuse the area without clearing the buffer.
     if (stencilAreas.Any(x => x.Intersects(area)))
     {
         graphics.Clear(ClearOptions.Stencil, ColorXNA.White, 0, 0);
         stencilAreas.Clear();
         stencilAreas.Add(area);
     }
     else if (!stencilAreas.Any(x => x.Equals(area)))
         stencilAreas.Add(area);
     EndDraw();
     manager.SpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, null, maskStencil,
         manager.SpriteBatch.GraphicsDevice.RasterizerState, alphaTextEffect);
 }
Exemple #4
0
 /// <summary>
 /// Draw a gradient over the specified area. To draw in a custom area (such as rounded rectangles), use a mask.
 /// </summary>
 private void DrawGradient(Rectangle area, GradientBrush gradientBrush)
 {
     Texture2D gradientTexture;
     // Create new gradient texture if it is not cached.
     if (!gradientCache.TryGetValue(gradientBrush, out gradientTexture))
     {
         var total = 15;
         gradientTexture = new Texture2D(manager.SpriteBatch.GraphicsDevice, 1, total);
         var start = gradientBrush.Start.ToXNA();
         var end = gradientBrush.End.ToXNA();
         var colors = new ColorXNA[total];
         // Add the start and end colors to the start and end, then add colors in betweeen.
         // The default way XNA/Monogame handles just two colors will only make 1/3rd of the result
         // a gradient, so we need to add some colors in between for better interpolation.
         colors[0] = start;
         for (var i = 1; i < total - 1; i++)
         {
             colors[i] = ColorXNA.Lerp(start, end, (float) i / (total - 2));
         }
         colors[total - 1] = end;
         gradientTexture.SetData(colors);
         gradientCache.Add(gradientBrush, gradientTexture);
     }
     manager.SpriteBatch.Draw(gradientTexture, area.ToXNA(), null, ColorXNA.White, 0, Vector2.Zero,
         SpriteEffects.None, 0);
 }
Exemple #5
0
        public override void FillRectangle(Rectangle area, Brush brush, double radius, Rectangle bounds)
        {
            SetClipArea(bounds);
            if (area != Rectangle.Empty)
            {
                if (radius > 0)
                {
                    var corner = (int) Math.Round(radius);
                    var corner2 = corner * 2;
                    var areaXNA = area.ToXNA();

                    var gradientBrush = brush as GradientBrush;
                    if (gradientBrush != null)
                    {
                        UseMaskStencil(area);
                    }

                    // Draw 5 rectangles (top, bottom, left, right, center)
                    FillRect(new RectangleXNA(areaXNA.X + corner,
                        areaXNA.Top, areaXNA.Width - corner2, corner), brush);
                    FillRect(new RectangleXNA(areaXNA.X + corner,
                        areaXNA.Bottom - corner, areaXNA.Width - corner2, corner), brush);
                    FillRect(new RectangleXNA(areaXNA.X,
                        areaXNA.Top + corner, corner, areaXNA.Height - corner2), brush);
                    FillRect(new RectangleXNA(areaXNA.Right - corner,
                        areaXNA.Y + corner, corner, areaXNA.Height - corner2), brush);
                    FillRect(new RectangleXNA(areaXNA.X + corner,
                        areaXNA.Y + corner, areaXNA.Width - corner2, areaXNA.Height - corner2), brush);

                    // Draw edge corners.
                    var circle = GetCircleTexture(radius);
                    FillCorner(new RectangleXNA(areaXNA.X, areaXNA.Y, corner, corner), circle, Corner.TopLeft,
                        brush);
                    FillCorner(new RectangleXNA(areaXNA.Right - corner, areaXNA.Y, corner, corner), circle,
                        Corner.TopRight, brush);
                    FillCorner(new RectangleXNA(areaXNA.X, areaXNA.Bottom - corner, corner, corner), circle,
                        Corner.BottomLeft, brush);
                    FillCorner(new RectangleXNA(areaXNA.Right - corner, areaXNA.Bottom - corner, corner, corner),
                        circle,
                        Corner.BottomRight, brush);

                    // If using a gradient brush, draw a gradient over the mask.
                    if (gradientBrush != null)
                    {
                        UseRenderStencil();
                        DrawGradient(area, gradientBrush);
                        EndStencil();
                    }
                }
                else
                {
                    var colorBrush = brush as ColorBrush;
                    var gradientBrush = brush as GradientBrush;
                    if (colorBrush != null)
                    {
                        manager.SpriteBatch.Draw(pixel, area.ToXNA(), null, colorBrush.ToXNA(), 0, Vector2.Zero,
                            SpriteEffects.None, 0);
                    }
                    if (gradientBrush != null)
                    {
                        DrawGradient(area, gradientBrush);
                    }
                }
            }
            ResetClipArea();
        }
Exemple #6
0
        public override void DrawString(string text, Point point, Brush brush, int size, FontStyle style,
            Rectangle bounds,
            bool ignoreFormatting = false)
        {
            SetClipArea(bounds);
            var pos = new Vector2((int) Math.Round(point.X), (int) Math.Round(point.Y));
            var closest = GetClosestFontSize(size);

            var colorBrush = brush as ColorBrush;
            var gradientBrush = brush as GradientBrush;
            var defaultColor = Color.Black;
            if (colorBrush != null)
                defaultColor = colorBrush.Color;

            if (gradientBrush != null)
            {
                UseMaskStencil(bounds);
            }

            if (!ignoreFormatting) // If formatting is enabled, parse it and render each part.
            {
                var parts = ParseFormattedText(text, defaultColor, style);
                foreach (var part in parts)
                {
                    var font = GetFont(Path.Combine(part.Style.ToString(), closest.ToString()));
                    var measure = MeasureTextNoTrim(part.Text, size, part.Style);
                    var col = new ColorXNA(part.Color.R, part.Color.G, part.Color.B, defaultColor.A);

                    manager.SpriteBatch.DrawString(font, part.Text, pos,
                        col * (defaultColor.A / 255f), 0,
                        Vector2.Zero, size / (float) closest, SpriteEffects.None, 0);
                    pos = new Vector2(pos.X + (float) measure.Width, pos.Y);
                }
            }
            else // Draw plain string
            {
                var font = GetFont(Path.Combine(style.ToString(), closest.ToString()));
                var col = new ColorXNA(defaultColor.R, defaultColor.G, defaultColor.B, defaultColor.A);
                manager.SpriteBatch.DrawString(font, text, pos,
                    col * (defaultColor.A / 255f), 0,
                    Vector2.Zero, size / (float) closest, SpriteEffects.None, 0);
            }

            // If using a gradient brush, draw a gradient over the mask.
            if (gradientBrush != null)
            {
                UseRenderStencil();
                DrawGradient(bounds, gradientBrush);
                EndStencil();
            }

            ResetClipArea();
        }
Exemple #7
0
 public abstract void Render(Rectangle extendedArea, Rectangle contentArea, float delta);
Exemple #8
0
 /// <summary>
 /// Draws a rounded filled rectangle within the specified area.
 /// </summary>
 public abstract void FillRectangle(Rectangle area, Brush brush, double cornerRadius, Rectangle bounds);
Exemple #9
0
 public override void Render(Rectangle extendedArea, Rectangle contentArea, float delta)
 {
     Manager.Renderer.StretchRectangle(contentArea, Color, contentArea.AddBorder(BlurRadius));
 }
Exemple #10
0
 public Rectangle Min(Rectangle other) => new Rectangle(X, Y, Math.Min(Width, other.Width), Math.Min(Height,other.Height));
Exemple #11
0
 /// <summary>
 /// Determines if the rectangle is equal to another rectangle within margin of error (because of floating point precision).
 /// </summary>
 public bool IsClose(Rectangle rectangle) => Point.IsClose(rectangle.Point) && Size.IsClose(rectangle.Size);
Exemple #12
0
        /// <summary>
        /// Limit the area of this rectangle to the specified bounds.
        /// </summary>
        public Rectangle FitToBounds(Rectangle bounds)
        {
            var x1 = Math.Max(X, bounds.X);
            var x2 = Math.Min(X + Width, bounds.X + bounds.Width);
            var y1 = Math.Max(Y, bounds.Y);
            var y2 = Math.Min(Y + Height, bounds.Y + bounds.Height);

            return x2 >= x1 && y2 >= y1
                ? new Rectangle(x1, y1, x2 - x1, y2 - y1)
                : Empty;
        }
Exemple #13
0
 /// <summary>
 /// Offset the rectangle by the specified rectangle coordinates. (Add to the X and Y)
 /// </summary>
 public Rectangle Offset(Rectangle rectangle) => new Rectangle(X + rectangle.X, Y + rectangle.Y, Width, Height);
Exemple #14
0
 public bool Intersects(Rectangle rect) => (rect.X < X + Width) &&
                                           (X < (rect.X + rect.Width)) &&
                                           (rect.Y < Y + Height) &&
                                           (Y < rect.Y + rect.Height);
Exemple #15
0
 public bool Contains(Rectangle rect) => (X <= rect.X) &&
                                         ((rect.X + rect.Width) <= (X + Width)) &&
                                         (Y <= rect.Y) &&
                                         ((rect.Y + rect.Height) <= (Y + Height));
Exemple #16
0
 /// <summary>
 /// Draws a rounded rectangle within the specified area.
 /// </summary>
 public abstract void DrawRectangle(Rectangle area, Brush brush, Thickness border, double cornerRadius, Rectangle bounds);
Exemple #17
0
 /// <summary>
 /// Draws a filled rectangle within the specified area.
 /// </summary>
 public void FillRectangle(Rectangle area, Brush brush, Rectangle bounds) => FillRectangle(area, brush, 0, bounds);
Exemple #18
0
 /// <summary>
 /// Draws a texture loaded by the skin in the specified region.
 /// </summary>
 public void DrawTexture(string name, Rectangle rectangle, Rectangle bounds) => DrawTexture(name, rectangle, Color.White, bounds);
Exemple #19
0
 /// <summary>
 /// Stretches a rectangle to fill the bounds and create a shadow effect.
 /// </summary>
 public abstract void StretchRectangle(Rectangle area, Color color, Rectangle bounds);
Exemple #20
0
 /// <summary>
 /// Draws a texture loaded by the skin in the specified region with the specified tint.
 /// </summary>
 public abstract void DrawTexture(string name, Rectangle rectangle, ColorBrush color, Rectangle bounds);
Exemple #21
0
 public override void Draw(float delta)
 {
     // Get text alignment offset.
     if (textAlignInvalidated || textSizeInvalidated || !lastBorderSize.IsClose(Bounds))
     {
         textAlignOffset = AlignText(textSize);
         textAlignInvalidated = false;
         textSizeInvalidated = false;
     }
     Manager.Renderer.DrawString(Text, Bounds.Point + textAlignOffset, TextColor, FontSize, FontStyle,
         LogicalParentBounds.FitToBounds(Bounds));
     lastBorderSize = Bounds;
     base.Draw(delta);
 }
Exemple #22
0
 /// <summary>
 /// Draws a string at the specified point.
 /// </summary>
 public void DrawString(string text, Point point, ColorBrush color, Rectangle bounds, bool ignoreFormatting = false) => DrawString(text, point, color, defaultSize, bounds, ignoreFormatting);
Exemple #23
0
 public override void DrawTexture(string name, Rectangle rectangle, ColorBrush brush, Rectangle bounds)
 {
     var rect = new RectangleXNA((int) rectangle.X, (int) rectangle.Y, (int) rectangle.Width,
         (int) rectangle.Height);
     var texture = GetTexture(name);
     var col = new ColorXNA(brush.Color.R, brush.Color.G, brush.Color.B, brush.Color.A);
     manager.SpriteBatch.Draw(texture, rect, col);
 }
Exemple #24
0
 /// <summary>
 /// Draws a string at the specified point.
 /// </summary>
 public void DrawString(string text, Point point, int size, Rectangle bounds,bool ignoreFormatting = false) => DrawString(text, point, Color.Black, size, bounds, ignoreFormatting);
Exemple #25
0
        public override void StretchRectangle(Rectangle area, Color color, Rectangle bounds)
        {
            var shadow =
                (Texture2D) manager.Skin.Textures["shadow"];
            var a = area.ToXNA();
            var b = bounds.ToXNA();
            var half = shadow.Width / 2;
            var col = color.ToXNA();

            FillRectangle(area, color, area);
            manager.SpriteBatch.Draw(shadow, new RectangleXNA(b.X, b.Y, a.X - b.X, a.Y - b.Y),
                new RectangleXNA(0, 0, half, half), col);
            manager.SpriteBatch.Draw(shadow, new RectangleXNA(b.X, a.Y + a.Height, a.X - b.X, a.Y - b.Y),
                new RectangleXNA(0, half, half, half), col);

            manager.SpriteBatch.Draw(shadow, new RectangleXNA(a.X + a.Width, b.Y, a.X - b.X, a.Y - b.Y),
                new RectangleXNA(half, 0, half, half), col);
            manager.SpriteBatch.Draw(shadow, new RectangleXNA(a.X + a.Width, a.Y + a.Height, a.X - b.X, a.Y - b.Y),
                new RectangleXNA(half, half, half, half), col);

            manager.SpriteBatch.Draw(shadow, new RectangleXNA(a.X, b.Y, a.Width, a.Y - b.Y),
                new RectangleXNA(half, 0, 1, half), col);
            manager.SpriteBatch.Draw(shadow, new RectangleXNA(a.X, a.Y + a.Height, a.Width, a.Y - b.Y),
                new RectangleXNA(half, half, 1, half), col);

            manager.SpriteBatch.Draw(shadow, new RectangleXNA(b.X, a.Y, a.X - b.X, a.Height),
                new RectangleXNA(0, half, half, 1), col);
            manager.SpriteBatch.Draw(shadow, new RectangleXNA(a.X + a.Width, a.Y, a.X - b.X, a.Height),
                new RectangleXNA(half, half, half, 1), col);
        }
Exemple #26
0
 /// <summary>
 /// Draws a string at the specified point.
 /// </summary>
 public void DrawString(string text, Point point, Brush brush, int size, Rectangle bounds, bool ignoreFormatting = false)
     => DrawString(text, point, brush, size, FontStyle.Regular, bounds, ignoreFormatting);
Exemple #27
0
 private void SetClipArea(Rectangle bounds)
 {
     manager.SpriteBatch.GraphicsDevice.ScissorRectangle = bounds.ToXNA();
 }
Exemple #28
0
 /// <summary>
 /// Draws a string at the specified point.
 /// </summary>
 public abstract void DrawString(string text, Point point, Brush brush, int size, FontStyle style, Rectangle bounds,bool ignoreFormatting = false);
Exemple #29
0
 /// <summary>
 /// Draws a rectangle within the specified area.
 /// </summary>
 public void DrawRectangle(Rectangle area, Brush brush, Thickness border, Rectangle bounds) => DrawRectangle(area, brush, border, 0, bounds);
Exemple #30
0
        /// <summary>
        /// Retuns an offset to the elements position according to its size, container size, and alignment.
        /// </summary>
        private Point Align(Rectangle container, Size size)
        {
            if (!double.IsInfinity(size.Width)) // Infinite sizes will be handled elsewhere.
            {
                switch (HorizontalAlignment)
                {
                    case HorizontalAlignment.Stretch:
                    case HorizontalAlignment.Center:
                        container.X = container.Left + (container.Width - size.Width) / 2;
                        break;
                    case HorizontalAlignment.Right:
                        container.X = container.Left + container.Width - size.Width;
                        break;
                }
            }

            if (!double.IsInfinity(size.Height))
            {
                switch (VerticalAlignment)
                {
                    case VerticalAlignment.Stretch:
                    case VerticalAlignment.Center:
                        container.Y = container.Top + (container.Height - size.Height) / 2;
                        break;
                    case VerticalAlignment.Bottom:
                        container.Y = container.Top + container.Height - size.Height;
                        break;
                }
            }

            return container.Point;
        }