Move GraphicsOptions parameter

8 years ago · bf9b3cfd3f
29 changed files with 243 additions and 258 deletions
--- a/src/ImageSharp.Drawing/Processing/Drawing/DrawBezierExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/DrawBezierExtensions.cs
@ -19,14 +19,14 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="points">The points.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawBeziers<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, float thickness, PointF[] points, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawBeziers<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, float thickness, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(new Pen<TPixel>(brush, thickness), new Path(new CubicBezierLineSegment(points)), options);
+            => source.Draw(options, new Pen<TPixel>(brush, thickness), new Path(new CubicBezierLineSegment(points)));

        /// <summary>
        /// Draws the provided points as an open Bezier path at the provided thickness with the supplied brush
@ -59,27 +59,27 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="points">The points.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawBeziers<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, float thickness, PointF[] points, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawBeziers<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, float thickness, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawBeziers(new SolidBrush<TPixel>(color), thickness, points, options);
+            => source.DrawBeziers(options, new SolidBrush<TPixel>(color), thickness, points);

        /// <summary>
        /// Draws the provided points as an open Bezier path with the supplied pen
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="pen">The pen.</param>
        /// <param name="points">The points.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawBeziers<TPixel>(this IImageProcessingContext<TPixel> source, IPen<TPixel> pen, PointF[] points, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawBeziers<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IPen<TPixel> pen, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(pen, new Path(new CubicBezierLineSegment(points)), options);
+            => source.Draw(options, pen, new Path(new CubicBezierLineSegment(points)));

        /// <summary>
        /// Draws the provided points as an open Bezier path with the supplied pen
--- a/src/ImageSharp.Drawing/Processing/Drawing/DrawImageExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/DrawImageExtensions.cs
@ -42,10 +42,10 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
-        /// <param name="image">The image to blend with the currently processing image.</param>
        /// <param name="options">The options, including the blending type and blending amount.</param>
+        /// <param name="image">The image to blend with the currently processing image.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Blend<TPixel>(this IImageProcessingContext<TPixel> source, Image<TPixel> image, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Blend<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, Image<TPixel> image)
            where TPixel : struct, IPixel<TPixel>
        {
            return source.ApplyProcessor(new DrawImageProcessor<TPixel>(image, options));
@ -82,12 +82,12 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// Draws the given image together with the current one by blending their pixels.
        /// </summary>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options containing the blend mode and opacity.</param>
        /// <param name="image">The image to blend with the currently processing image.</param>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="location">The location to draw the blended image.</param>
-        /// <param name="options">The options containing the blend mode and opacity.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawImage<TPixel>(this IImageProcessingContext<TPixel> source, Image<TPixel> image, Point location, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawImage<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, Image<TPixel> image, Point location)
            where TPixel : struct, IPixel<TPixel>
            => source.ApplyProcessor(new DrawImageProcessor<TPixel>(image, location, options));
    }
--- a/src/ImageSharp.Drawing/Processing/Drawing/DrawLineExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/DrawLineExtensions.cs
@ -19,14 +19,14 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="points">The points.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawLines<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, float thickness, PointF[] points, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawLines<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, float thickness, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(new Pen<TPixel>(brush, thickness), new Path(new LinearLineSegment(points)), options);
+            => source.Draw(options, new Pen<TPixel>(brush, thickness), new Path(new LinearLineSegment(points)));

        /// <summary>
        /// Draws the provided Points as an open Linear path at the provided thickness with the supplied brush
@ -59,27 +59,27 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="points">The points.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>>
-        public static IImageProcessingContext<TPixel> DrawLines<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, float thickness, PointF[] points, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawLines<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, float thickness, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawLines(new SolidBrush<TPixel>(color), thickness, points, options);
+            => source.DrawLines(options, new SolidBrush<TPixel>(color), thickness, points);

        /// <summary>
        /// Draws the provided Points as an open Linear path with the supplied pen
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="pen">The pen.</param>
        /// <param name="points">The points.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawLines<TPixel>(this IImageProcessingContext<TPixel> source, IPen<TPixel> pen, PointF[] points, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawLines<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IPen<TPixel> pen, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(pen, new Path(new LinearLineSegment(points)), options);
+            => source.Draw(options, pen, new Path(new LinearLineSegment(points)));

        /// <summary>
        /// Draws the provided Points as an open Linear path with the supplied pen
@ -93,4 +93,4 @@ namespace SixLabors.ImageSharp.Processing.Drawing
            where TPixel : struct, IPixel<TPixel>
            => source.Draw(pen, new Path(new LinearLineSegment(points)));
    }
-}
+}
--- a/src/ImageSharp.Drawing/Processing/Drawing/DrawPathCollectionExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/DrawPathCollectionExtensions.cs
@ -18,16 +18,16 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="pen">The pen.</param>
        /// <param name="paths">The paths.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, IPen<TPixel> pen, IPathCollection paths, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IPen<TPixel> pen, IPathCollection paths)
           where TPixel : struct, IPixel<TPixel>
        {
            foreach (IPath path in paths)
            {
-                source.Draw(pen, path, options);
+                source.Draw(options, pen, path);
            }

            return source;
@ -43,21 +43,21 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, IPen<TPixel> pen, IPathCollection paths)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(pen, paths, GraphicsOptions.Default);
+            => source.Draw(GraphicsOptions.Default, pen, paths);

        /// <summary>
        /// Draws the outline of the polygon with the provided brush at the provided thickness.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="paths">The shapes.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, float thickness, IPathCollection paths, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, float thickness, IPathCollection paths)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(new Pen<TPixel>(brush, thickness), paths, options);
+            => source.Draw(options, new Pen<TPixel>(brush, thickness), paths);

        /// <summary>
        /// Draws the outline of the polygon with the provided brush at the provided thickness.
@ -77,14 +77,14 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="paths">The paths.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, float thickness, IPathCollection paths, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, float thickness, IPathCollection paths)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(new SolidBrush<TPixel>(color), thickness, paths, options);
+            => source.Draw(options, new SolidBrush<TPixel>(color), thickness, paths);

        /// <summary>
        /// Draws the outline of the polygon with the provided brush at the provided thickness.
--- a/src/ImageSharp.Drawing/Processing/Drawing/DrawPathExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/DrawPathExtensions.cs
@ -19,13 +19,13 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="pen">The pen.</param>
        /// <param name="path">The path.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, IPen<TPixel> pen, IPath path, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IPen<TPixel> pen, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(pen.StrokeFill, new ShapePath(path, pen), options);
+            => source.Fill(options, pen.StrokeFill, new ShapePath(path, pen));

        /// <summary>
        /// Draws the outline of the polygon with the provided pen.
@ -37,21 +37,21 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, IPen<TPixel> pen, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(pen, path, GraphicsOptions.Default);
+            => source.Draw(GraphicsOptions.Default, pen, path);

        /// <summary>
        /// Draws the outline of the polygon with the provided brush at the provided thickness.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="path">The shape.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, float thickness, IPath path, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, float thickness, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(new Pen<TPixel>(brush, thickness), path, options);
+            => source.Draw(options, new Pen<TPixel>(brush, thickness), path);

        /// <summary>
        /// Draws the outline of the polygon with the provided brush at the provided thickness.
@ -71,14 +71,14 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="path">The path.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, float thickness, IPath path, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, float thickness, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(new SolidBrush<TPixel>(color), thickness, path, options);
+            => source.Draw(options, new SolidBrush<TPixel>(color), thickness, path);

        /// <summary>
        /// Draws the outline of the polygon with the provided brush at the provided thickness.
@ -93,4 +93,4 @@ namespace SixLabors.ImageSharp.Processing.Drawing
            where TPixel : struct, IPixel<TPixel>
            => source.Draw(new SolidBrush<TPixel>(color), thickness, path);
    }
-}
+}
--- a/src/ImageSharp.Drawing/Processing/Drawing/DrawPolygonExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/DrawPolygonExtensions.cs
@ -19,14 +19,14 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="points">The points.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawPolygon<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, float thickness, PointF[] points, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawPolygon<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, float thickness, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(new Pen<TPixel>(brush, thickness), new Polygon(new LinearLineSegment(points)), options);
+            => source.Draw(options, new Pen<TPixel>(brush, thickness), new Polygon(new LinearLineSegment(points)));

        /// <summary>
        /// Draws the provided Points as a closed Linear Polygon with the provided brush at the provided thickness.
@ -59,14 +59,14 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="points">The points.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawPolygon<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, float thickness, PointF[] points, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawPolygon<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, float thickness, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawPolygon(new SolidBrush<TPixel>(color), thickness, points, options);
+            => source.DrawPolygon(options, new SolidBrush<TPixel>(color), thickness, points);

        /// <summary>
        /// Draws the provided Points as a closed Linear Polygon with the provided Pen.
@ -78,19 +78,19 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> DrawPolygon<TPixel>(this IImageProcessingContext<TPixel> source, IPen<TPixel> pen, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(pen, new Polygon(new LinearLineSegment(points)), GraphicsOptions.Default);
+            => source.Draw(GraphicsOptions.Default, pen, new Polygon(new LinearLineSegment(points)));

        /// <summary>
        /// Draws the provided Points as a closed Linear Polygon with the provided Pen.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="pen">The pen.</param>
        /// <param name="points">The points.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawPolygon<TPixel>(this IImageProcessingContext<TPixel> source, IPen<TPixel> pen, PointF[] points, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawPolygon<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IPen<TPixel> pen, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(pen, new Polygon(new LinearLineSegment(points)), options);
+            => source.Draw(options, pen, new Polygon(new LinearLineSegment(points)));
    }
 }
--- a/src/ImageSharp.Drawing/Processing/Drawing/DrawRectangleExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/DrawRectangleExtensions.cs
@ -19,13 +19,13 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="pen">The pen.</param>
        /// <param name="shape">The shape.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, IPen<TPixel> pen, RectangleF shape, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IPen<TPixel> pen, RectangleF shape)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(pen, new RectangularePolygon(shape.X, shape.Y, shape.Width, shape.Height), options);
+            => source.Draw(options, pen, new RectangularePolygon(shape.X, shape.Y, shape.Width, shape.Height));

        /// <summary>
        /// Draws the outline of the rectangle with the provided pen.
@ -37,21 +37,21 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, IPen<TPixel> pen, RectangleF shape)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(pen, shape, GraphicsOptions.Default);
+            => source.Draw(GraphicsOptions.Default, pen, shape);

        /// <summary>
        /// Draws the outline of the rectangle with the provided brush at the provided thickness.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="shape">The shape.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, float thickness, RectangleF shape, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, float thickness, RectangleF shape)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(new Pen<TPixel>(brush, thickness), shape, options);
+            => source.Draw(options, new Pen<TPixel>(brush, thickness), shape);

        /// <summary>
        /// Draws the outline of the rectangle with the provided brush at the provided thickness.
@ -71,14 +71,14 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="thickness">The thickness.</param>
        /// <param name="shape">The shape.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, float thickness, RectangleF shape, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Draw<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, float thickness, RectangleF shape)
            where TPixel : struct, IPixel<TPixel>
-            => source.Draw(new SolidBrush<TPixel>(color), thickness, shape, options);
+            => source.Draw(options, new SolidBrush<TPixel>(color), thickness, shape);

        /// <summary>
        /// Draws the outline of the rectangle with the provided brush at the provided thickness.
--- a/src/ImageSharp.Drawing/Processing/Drawing/FillPathBuilderExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/FillPathBuilderExtensions.cs
@ -18,17 +18,17 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The graphics options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="path">The shape.</param>
-        /// <param name="options">The graphics options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, Action<PathBuilder> path, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, Action<PathBuilder> path)
          where TPixel : struct, IPixel<TPixel>
        {
            var pb = new PathBuilder();
            path(pb);

-            return source.Fill(brush, pb.Build(), options);
+            return source.Fill(options, brush, pb.Build());
        }

        /// <summary>
@ -41,20 +41,20 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, Action<PathBuilder> path)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(brush, path, GraphicsOptions.Default);
+            => source.Fill(GraphicsOptions.Default, brush, path);

        /// <summary>
        /// Flood fills the image in the shape of the provided polygon with the specified brush.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="path">The path.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, Action<PathBuilder> path, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, Action<PathBuilder> path)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(new SolidBrush<TPixel>(color), path, options);
+            => source.Fill(options, new SolidBrush<TPixel>(color), path);

        /// <summary>
        /// Flood fills the image in the shape of the provided polygon with the specified brush.
--- a/src/ImageSharp.Drawing/Processing/Drawing/FillPathCollectionExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/FillPathCollectionExtensions.cs
@ -17,16 +17,16 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The graphics options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="paths">The shapes.</param>
-        /// <param name="options">The graphics options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, IPathCollection paths, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, IPathCollection paths)
          where TPixel : struct, IPixel<TPixel>
        {
            foreach (IPath s in paths)
            {
-                source.Fill(brush, s, options);
+                source.Fill(options, brush, s);
            }

            return source;
@ -42,20 +42,20 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, IPathCollection paths)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(brush, paths, GraphicsOptions.Default);
+            => source.Fill(GraphicsOptions.Default, brush, paths);

        /// <summary>
        /// Flood fills the image in the shape of the provided polygon with the specified brush.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="paths">The paths.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, IPathCollection paths, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, IPathCollection paths)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(new SolidBrush<TPixel>(color), paths, options);
+            => source.Fill(options, new SolidBrush<TPixel>(color), paths);

        /// <summary>
        /// Flood fills the image in the shape of the provided polygon with the specified brush.
--- a/src/ImageSharp.Drawing/Processing/Drawing/FillPathExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/FillPathExtensions.cs
@ -18,13 +18,13 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The graphics options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="path">The shape.</param>
-        /// <param name="options">The graphics options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, IPath path, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(brush, new ShapeRegion(path), options);
+            => source.Fill(options, brush, new ShapeRegion(path));

        /// <summary>
        /// Flood fills the image in the shape of the provided polygon with the specified brush.
@ -36,20 +36,20 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(brush, new ShapeRegion(path), GraphicsOptions.Default);
+            => source.Fill(GraphicsOptions.Default, brush, new ShapeRegion(path));

        /// <summary>
        /// Flood fills the image in the shape of the provided polygon with the specified brush..
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="path">The path.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, IPath path, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(new SolidBrush<TPixel>(color), path, options);
+            => source.Fill(options, new SolidBrush<TPixel>(color), path);

        /// <summary>
        /// Flood fills the image in the shape of the provided polygon with the specified brush..
--- a/src/ImageSharp.Drawing/Processing/Drawing/FillPolygonExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/FillPolygonExtensions.cs
@ -18,13 +18,13 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="points">The points.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> FillPolygon<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, PointF[] points, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> FillPolygon<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(brush, new Polygon(new LinearLineSegment(points)), options);
+            => source.Fill(options, brush, new Polygon(new LinearLineSegment(points)));

        /// <summary>
        /// Flood fills the image in the shape of a Linear polygon described by the points
@ -43,13 +43,13 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="points">The points.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> FillPolygon<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, PointF[] points, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> FillPolygon<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, PointF[] points)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(new SolidBrush<TPixel>(color), new Polygon(new LinearLineSegment(points)), options);
+            => source.Fill(options, new SolidBrush<TPixel>(color), new Polygon(new LinearLineSegment(points)));

        /// <summary>
        /// Flood fills the image in the shape of a Linear polygon described by the points
--- a/src/ImageSharp.Drawing/Processing/Drawing/FillRectangleExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/FillRectangleExtensions.cs
@ -18,13 +18,13 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="shape">The shape.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, RectangleF shape, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, RectangleF shape)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(brush, new RectangularePolygon(shape.X, shape.Y, shape.Width, shape.Height), options);
+            => source.Fill(options, brush, new RectangularePolygon(shape.X, shape.Y, shape.Width, shape.Height));

        /// <summary>
        /// Flood fills the image in the shape of the provided rectangle with the specified brush.
@ -43,13 +43,13 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="shape">The shape.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, RectangleF shape, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, RectangleF shape)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(new SolidBrush<TPixel>(color), shape, options);
+            => source.Fill(options, new SolidBrush<TPixel>(color), shape);

        /// <summary>
        /// Flood fills the image in the shape of the provided rectangle with the specified brush.
--- a/src/ImageSharp.Drawing/Processing/Drawing/FillRegionExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Drawing/FillRegionExtensions.cs
@ -22,7 +22,7 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(brush, GraphicsOptions.Default);
+            => source.Fill(GraphicsOptions.Default, brush);

        /// <summary>
        /// Flood fills the image with the specified color.
@ -45,20 +45,20 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, Region region)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(brush, region, GraphicsOptions.Default);
+            => source.Fill(GraphicsOptions.Default, brush, region);

        /// <summary>
        /// Flood fills the image with in the region with the specified color.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="color">The color.</param>
        /// <param name="region">The region.</param>
-        /// <param name="options">The options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, Region region, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, Region region)
            where TPixel : struct, IPixel<TPixel>
-            => source.Fill(new SolidBrush<TPixel>(color), region, options);
+            => source.Fill(options, new SolidBrush<TPixel>(color), region);

        /// <summary>
        /// Flood fills the image with in the region with the specified color.
@ -77,11 +77,11 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The graphics options.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="region">The region.</param>
-        /// <param name="options">The graphics options.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, Region region, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush, Region region)
            where TPixel : struct, IPixel<TPixel>
            => source.ApplyProcessor(new FillRegionProcessor<TPixel>(brush, region, options));

@ -90,10 +90,10 @@ namespace SixLabors.ImageSharp.Processing.Drawing
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
-        /// <param name="brush">The details how to fill the region of interest.</param>
        /// <param name="options">The graphics options.</param>
+        /// <param name="brush">The details how to fill the region of interest.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, IBrush<TPixel> brush, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Fill<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, IBrush<TPixel> brush)
            where TPixel : struct, IPixel<TPixel>
            => source.ApplyProcessor(new FillProcessor<TPixel>(brush, options));
    }
--- a/src/ImageSharp.Drawing/Processing/Text/DrawTextExtensions.Path.cs
+++ b/src/ImageSharp.Drawing/Processing/Text/DrawTextExtensions.Path.cs
@ -29,24 +29,24 @@ namespace SixLabors.ImageSharp.Processing.Text
        /// </returns>
        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, TPixel color, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, color, path, TextGraphicsOptions.Default);
+            => source.DrawText(TextGraphicsOptions.Default, text, font, color, path);

        /// <summary>
        /// Draws the text onto the the image filled via the brush.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="text">The text.</param>
        /// <param name="font">The font.</param>
        /// <param name="color">The color.</param>
        /// <param name="path">The path.</param>
-        /// <param name="options">The options.</param>
        /// <returns>
        /// The <see cref="Image{TPixel}" />.
        /// </returns>
-        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, TPixel color, IPath path, TextGraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, TextGraphicsOptions options, string text, Font font, TPixel color, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, Brushes.Solid(color), null, path, options);
+            => source.DrawText(options, text, font, Brushes.Solid(color), null, path);

        /// <summary>
        /// Draws the text onto the the image filled via the brush.
@ -62,24 +62,24 @@ namespace SixLabors.ImageSharp.Processing.Text
        /// </returns>
        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IBrush<TPixel> brush, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, brush, path, TextGraphicsOptions.Default);
+            => source.DrawText(TextGraphicsOptions.Default, text, font, brush, path);

        /// <summary>
        /// Draws the text onto the the image filled via the brush.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="text">The text.</param>
        /// <param name="font">The font.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="path">The path.</param>
-        /// <param name="options">The options.</param>
        /// <returns>
        /// The <see cref="Image{TPixel}" />.
        /// </returns>
-        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IBrush<TPixel> brush, IPath path, TextGraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, TextGraphicsOptions options, string text, Font font, IBrush<TPixel> brush, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, brush, null, path, options);
+            => source.DrawText(options, text, font, brush, null, path);

        /// <summary>
        /// Draws the text onto the the image outlined via the pen.
@ -95,24 +95,24 @@ namespace SixLabors.ImageSharp.Processing.Text
        /// </returns>
        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IPen<TPixel> pen, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, pen, path, TextGraphicsOptions.Default);
+            => source.DrawText(TextGraphicsOptions.Default, text, font, pen, path);

        /// <summary>
        /// Draws the text onto the the image outlined via the pen.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="text">The text.</param>
        /// <param name="font">The font.</param>
        /// <param name="pen">The pen.</param>
        /// <param name="path">The path.</param>
-        /// <param name="options">The options.</param>
        /// <returns>
        /// The <see cref="Image{TPixel}" />.
        /// </returns>
-        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IPen<TPixel> pen, IPath path, TextGraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, TextGraphicsOptions options, string text, Font font, IPen<TPixel> pen, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, null, pen, path, options);
+            => source.DrawText(options, text, font, null, pen, path);

        /// <summary>
        /// Draws the text onto the the image filled via the brush then outlined via the pen.
@ -129,23 +129,23 @@ namespace SixLabors.ImageSharp.Processing.Text
        /// </returns>
        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IBrush<TPixel> brush, IPen<TPixel> pen, IPath path)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, brush, pen, path, TextGraphicsOptions.Default);
+            => source.DrawText(TextGraphicsOptions.Default, text, font, brush, pen, path);

        /// <summary>
        /// Draws the text onto the the image filled via the brush then outlined via the pen.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="text">The text.</param>
        /// <param name="font">The font.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="pen">The pen.</param>
        /// <param name="path">The path.</param>
-        /// <param name="options">The options.</param>
        /// <returns>
        /// The <see cref="Image{TPixel}" />.
        /// </returns>
-        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IBrush<TPixel> brush, IPen<TPixel> pen, IPath path, TextGraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, TextGraphicsOptions options, string text, Font font, IBrush<TPixel> brush, IPen<TPixel> pen, IPath path)
           where TPixel : struct, IPixel<TPixel>
        {
            float dpiX = DefaultTextDpi;
@ -165,12 +165,12 @@ namespace SixLabors.ImageSharp.Processing.Text
            var pathOptions = (GraphicsOptions)options;
            if (brush != null)
            {
-                source.Fill(brush, glyphs, pathOptions);
+                source.Fill(pathOptions, brush, glyphs);
            }

            if (pen != null)
            {
-                source.Draw(pen, glyphs, pathOptions);
+                source.Draw(pathOptions, pen, glyphs);
            }

            return source;
--- a/src/ImageSharp.Drawing/Processing/Text/DrawTextExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Text/DrawTextExtensions.cs
@ -32,24 +32,24 @@ namespace SixLabors.ImageSharp.Processing.Text
        /// </returns>
        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, TPixel color, PointF location)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, color, location, TextGraphicsOptions.Default);
+            => source.DrawText(TextGraphicsOptions.Default, text, font, color, location);

        /// <summary>
        /// Draws the text onto the the image filled via the brush.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="text">The text.</param>
        /// <param name="font">The font.</param>
        /// <param name="color">The color.</param>
        /// <param name="location">The location.</param>
-        /// <param name="options">The options.</param>
        /// <returns>
        /// The <see cref="Image{TPixel}" />.
        /// </returns>
-        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, TPixel color, PointF location, TextGraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, TextGraphicsOptions options, string text, Font font, TPixel color, PointF location)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, Brushes.Solid(color), null, location, options);
+            => source.DrawText(options, text, font, Brushes.Solid(color), null, location);

        /// <summary>
        /// Draws the text onto the the image filled via the brush.
@ -65,24 +65,24 @@ namespace SixLabors.ImageSharp.Processing.Text
        /// </returns>
        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IBrush<TPixel> brush, PointF location)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, brush, location, TextGraphicsOptions.Default);
+            => source.DrawText(TextGraphicsOptions.Default, text, font, brush, location);

        /// <summary>
        /// Draws the text onto the the image filled via the brush.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="text">The text.</param>
        /// <param name="font">The font.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="location">The location.</param>
-        /// <param name="options">The options.</param>
        /// <returns>
        /// The <see cref="Image{TPixel}" />.
        /// </returns>
-        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IBrush<TPixel> brush, PointF location, TextGraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, TextGraphicsOptions options, string text, Font font, IBrush<TPixel> brush, PointF location)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, brush, null, location, options);
+            => source.DrawText(options, text, font, brush, null, location);

        /// <summary>
        /// Draws the text onto the the image outlined via the pen.
@ -98,24 +98,24 @@ namespace SixLabors.ImageSharp.Processing.Text
        /// </returns>
        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IPen<TPixel> pen, PointF location)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, pen, location, TextGraphicsOptions.Default);
+            => source.DrawText(TextGraphicsOptions.Default, text, font, pen, location);

        /// <summary>
        /// Draws the text onto the the image outlined via the pen.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="text">The text.</param>
        /// <param name="font">The font.</param>
        /// <param name="pen">The pen.</param>
        /// <param name="location">The location.</param>
-        /// <param name="options">The options.</param>
        /// <returns>
        /// The <see cref="Image{TPixel}" />.
        /// </returns>
-        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IPen<TPixel> pen, PointF location, TextGraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, TextGraphicsOptions options, string text, Font font, IPen<TPixel> pen, PointF location)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, null, pen, location, options);
+            => source.DrawText(options, text, font, null, pen, location);

        /// <summary>
        /// Draws the text onto the the image filled via the brush then outlined via the pen.
@ -132,23 +132,23 @@ namespace SixLabors.ImageSharp.Processing.Text
        /// </returns>
        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IBrush<TPixel> brush, IPen<TPixel> pen, PointF location)
            where TPixel : struct, IPixel<TPixel>
-            => source.DrawText(text, font, brush, pen, location, TextGraphicsOptions.Default);
+            => source.DrawText(TextGraphicsOptions.Default, text, font, brush, pen, location);

        /// <summary>
        /// Draws the text using the default resolution of <value>72dpi</value> onto the the image filled via the brush then outlined via the pen.
        /// </summary>
        /// <typeparam name="TPixel">The type of the color.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options.</param>
        /// <param name="text">The text.</param>
        /// <param name="font">The font.</param>
        /// <param name="brush">The brush.</param>
        /// <param name="pen">The pen.</param>
        /// <param name="location">The location.</param>
-        /// <param name="options">The options.</param>
        /// <returns>
        /// The <see cref="Image{TPixel}" />.
        /// </returns>
-        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, string text, Font font, IBrush<TPixel> brush, IPen<TPixel> pen, PointF location, TextGraphicsOptions options)
+        public static IImageProcessingContext<TPixel> DrawText<TPixel>(this IImageProcessingContext<TPixel> source, TextGraphicsOptions options, string text, Font font, IBrush<TPixel> brush, IPen<TPixel> pen, PointF location)
           where TPixel : struct, IPixel<TPixel>
        {
            float dpiX = DefaultTextDpi;
@ -168,12 +168,12 @@ namespace SixLabors.ImageSharp.Processing.Text
            var pathOptions = (GraphicsOptions)options;
            if (brush != null)
            {
-                source.Fill(brush, glyphs, pathOptions);
+                source.Fill(pathOptions, brush, glyphs);
            }

            if (pen != null)
            {
-                source.Draw(pen, glyphs, pathOptions);
+                source.Draw(pathOptions, pen, glyphs);
            }

            return source;
--- a/src/ImageSharp/Processing/Overlays/BackgroundColorExtensions.cs
+++ b/src/ImageSharp/Processing/Overlays/BackgroundColorExtensions.cs
@ -21,7 +21,7 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> BackgroundColor<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color)
            where TPixel : struct, IPixel<TPixel>
-            => BackgroundColor(source, color, GraphicsOptions.Default);
+            => BackgroundColor(source, GraphicsOptions.Default, color);

        /// <summary>
        /// Replaces the background color of image with the given one.
@ -35,17 +35,17 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> BackgroundColor<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
-            => BackgroundColor(source, color, rectangle, GraphicsOptions.Default);
+            => BackgroundColor(source, GraphicsOptions.Default, color, rectangle);

        /// <summary>
        /// Replaces the background color of image with the given one.
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
-        /// <param name="color">The color to set as the background.</param>
        /// <param name="options">The options effecting pixel blending.</param>
+        /// <param name="color">The color to set as the background.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> BackgroundColor<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> BackgroundColor<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color)
            where TPixel : struct, IPixel<TPixel>
            => source.ApplyProcessor(new BackgroundColorProcessor<TPixel>(color, options));

@ -54,13 +54,13 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options effecting pixel blending.</param>
        /// <param name="color">The color to set as the background.</param>
        /// <param name="rectangle">
        /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
        /// </param>
-        /// <param name="options">The options effecting pixel blending.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> BackgroundColor<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, Rectangle rectangle, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> BackgroundColor<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
            => source.ApplyProcessor(new BackgroundColorProcessor<TPixel>(color, options), rectangle);
    }
--- a/src/ImageSharp/Processing/Overlays/GlowExtensions.cs
+++ b/src/ImageSharp/Processing/Overlays/GlowExtensions.cs
@ -33,7 +33,7 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color)
            where TPixel : struct, IPixel<TPixel>
        {
-            return Glow(source, color, GraphicsOptions.Default);
+            return Glow(source, GraphicsOptions.Default, color);
        }

        /// <summary>
@ -45,7 +45,7 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, float radius)
            where TPixel : struct, IPixel<TPixel>
-            => Glow(source, radius, GraphicsOptions.Default);
+            => Glow(source, GraphicsOptions.Default, radius);

        /// <summary>
        /// Applies a radial glow effect to an image.
@ -58,7 +58,7 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
-            => source.Glow(rectangle, GraphicsOptions.Default);
+            => source.Glow(GraphicsOptions.Default, rectangle);

        /// <summary>
        /// Applies a radial glow effect to an image.
@ -73,7 +73,7 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, float radius, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
-            => source.Glow(color, ValueSize.Absolute(radius), rectangle, GraphicsOptions.Default);
+            => source.Glow(GraphicsOptions.Default, color, ValueSize.Absolute(radius), rectangle);

        /// <summary>
        /// Applies a radial glow effect to an image.
@ -84,75 +84,75 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options)
            where TPixel : struct, IPixel<TPixel>
-            => source.Glow(NamedColors<TPixel>.Black, ValueSize.PercentageOfWidth(0.5f), options);
+            => source.Glow(options, NamedColors<TPixel>.Black, ValueSize.PercentageOfWidth(0.5f));

        /// <summary>
        /// Applies a radial glow effect to an image.
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
-        /// <param name="color">The color to set as the glow.</param>
        /// <param name="options">The options effecting things like blending.</param>
+        /// <param name="color">The color to set as the glow.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color)
            where TPixel : struct, IPixel<TPixel>
-            => source.Glow(color, ValueSize.PercentageOfWidth(0.5f), options);
+            => source.Glow(options, color, ValueSize.PercentageOfWidth(0.5f));

        /// <summary>
        /// Applies a radial glow effect to an image.
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
-        /// <param name="radius">The the radius.</param>
        /// <param name="options">The options effecting things like blending.</param>
+        /// <param name="radius">The the radius.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, float radius, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, float radius)
            where TPixel : struct, IPixel<TPixel>
-            => source.Glow(NamedColors<TPixel>.Black, ValueSize.Absolute(radius), options);
+            => source.Glow(options, NamedColors<TPixel>.Black, ValueSize.Absolute(radius));

        /// <summary>
        /// Applies a radial glow effect to an image.
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options effecting things like blending.</param>
        /// <param name="rectangle">
        /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
        /// </param>
-        /// <param name="options">The options effecting things like blending.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, Rectangle rectangle, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
-            => source.Glow(NamedColors<TPixel>.Black, ValueSize.PercentageOfWidth(0.5f), rectangle, options);
+            => source.Glow(options, NamedColors<TPixel>.Black, ValueSize.PercentageOfWidth(0.5f), rectangle);

        /// <summary>
        /// Applies a radial glow effect to an image.
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options effecting things like blending.</param>
        /// <param name="color">The color to set as the glow.</param>
        /// <param name="radius">The the radius.</param>
        /// <param name="rectangle">
        /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
        /// </param>
-        /// <param name="options">The options effecting things like blending.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, float radius, Rectangle rectangle, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, float radius, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
-            => source.Glow(color, ValueSize.Absolute(radius), rectangle, options);
+            => source.Glow(options, color, ValueSize.Absolute(radius), rectangle);

        /// <summary>
        /// Applies a radial glow effect to an image.
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options effecting things like blending.</param>
        /// <param name="color">The color to set as the glow.</param>
        /// <param name="radius">The the radius.</param>
        /// <param name="rectangle">
        /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
        /// </param>
-        /// <param name="options">The options effecting things like blending.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        private static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, ValueSize radius, Rectangle rectangle, GraphicsOptions options)
+        private static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, ValueSize radius, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
            => source.ApplyProcessor(new GlowProcessor<TPixel>(color, radius, options), rectangle);

@ -161,12 +161,12 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options effecting things like blending.</param>
        /// <param name="color">The color to set as the glow.</param>
        /// <param name="radius">The the radius.</param>
-        /// <param name="options">The options effecting things like blending.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        private static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, ValueSize radius, GraphicsOptions options)
+        private static IImageProcessingContext<TPixel> Glow<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, ValueSize radius)
            where TPixel : struct, IPixel<TPixel>
            => source.ApplyProcessor(new GlowProcessor<TPixel>(color, radius, options));
    }
-}
+}
--- a/src/ImageSharp/Processing/Overlays/VignetteExtensions.cs
+++ b/src/ImageSharp/Processing/Overlays/VignetteExtensions.cs
@ -32,7 +32,7 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color)
            where TPixel : struct, IPixel<TPixel>
-            => Vignette(source, color, GraphicsOptions.Default);
+            => Vignette(source, GraphicsOptions.Default, color);

        /// <summary>
        /// Applies a radial vignette effect to an image.
@ -44,7 +44,7 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, float radiusX, float radiusY)
            where TPixel : struct, IPixel<TPixel>
-            => Vignette(source, radiusX, radiusY, GraphicsOptions.Default);
+            => Vignette(source, GraphicsOptions.Default, radiusX, radiusY);

        /// <summary>
        /// Applies a radial vignette effect to an image.
@ -57,7 +57,7 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
-            => Vignette(source, rectangle, GraphicsOptions.Default);
+            => Vignette(source, GraphicsOptions.Default, rectangle);

        /// <summary>
        /// Applies a radial vignette effect to an image.
@ -73,7 +73,7 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, float radiusX, float radiusY, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
-            => source.Vignette(color, radiusX, radiusY, rectangle, GraphicsOptions.Default);
+            => source.Vignette(GraphicsOptions.Default, color, radiusX, radiusY, rectangle);

        /// <summary>
        /// Applies a radial vignette effect to an image.
@ -84,69 +84,69 @@ namespace SixLabors.ImageSharp.Processing.Overlays
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options)
            where TPixel : struct, IPixel<TPixel>
-            => source.VignetteInternal(NamedColors<TPixel>.Black, ValueSize.PercentageOfWidth(.5f), ValueSize.PercentageOfHeight(.5f), options);
+            => source.VignetteInternal(options, NamedColors<TPixel>.Black, ValueSize.PercentageOfWidth(.5f), ValueSize.PercentageOfHeight(.5f));

        /// <summary>
        /// Applies a radial vignette effect to an image.
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
-        /// <param name="color">The color to set as the vignette.</param>
        /// <param name="options">The options effecting pixel blending.</param>
+        /// <param name="color">The color to set as the vignette.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color)
            where TPixel : struct, IPixel<TPixel>
-            => source.VignetteInternal(color, ValueSize.PercentageOfWidth(.5f), ValueSize.PercentageOfHeight(.5f), options);
+            => source.VignetteInternal(options, color, ValueSize.PercentageOfWidth(.5f), ValueSize.PercentageOfHeight(.5f));

        /// <summary>
        /// Applies a radial vignette effect to an image.
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options effecting pixel blending.</param>
        /// <param name="radiusX">The the x-radius.</param>
        /// <param name="radiusY">The the y-radius.</param>
-        /// <param name="options">The options effecting pixel blending.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, float radiusX, float radiusY, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, float radiusX, float radiusY)
            where TPixel : struct, IPixel<TPixel>
-            => source.VignetteInternal(NamedColors<TPixel>.Black, radiusX, radiusY, options);
+            => source.VignetteInternal(options, NamedColors<TPixel>.Black, radiusX, radiusY);

        /// <summary>
        /// Applies a radial vignette effect to an image.
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options effecting pixel blending.</param>
        /// <param name="rectangle">
        /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
        /// </param>
-        /// <param name="options">The options effecting pixel blending.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, Rectangle rectangle, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
-            => source.VignetteInternal(NamedColors<TPixel>.Black, ValueSize.PercentageOfWidth(.5f), ValueSize.PercentageOfHeight(.5f), rectangle, options);
+            => source.VignetteInternal(options, NamedColors<TPixel>.Black, ValueSize.PercentageOfWidth(.5f), ValueSize.PercentageOfHeight(.5f), rectangle);

        /// <summary>
        /// Applies a radial vignette effect to an image.
        /// </summary>
        /// <typeparam name="TPixel">The pixel format.</typeparam>
        /// <param name="source">The image this method extends.</param>
+        /// <param name="options">The options effecting pixel blending.</param>
        /// <param name="color">The color to set as the vignette.</param>
        /// <param name="radiusX">The the x-radius.</param>
        /// <param name="radiusY">The the y-radius.</param>
        /// <param name="rectangle">
        /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
        /// </param>
-        /// <param name="options">The options effecting pixel blending.</param>
        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, float radiusX, float radiusY, Rectangle rectangle, GraphicsOptions options)
+        public static IImageProcessingContext<TPixel> Vignette<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, float radiusX, float radiusY, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
-            => source.VignetteInternal(color, radiusX, radiusY, rectangle, options);
+            => source.VignetteInternal(options, color, radiusX, radiusY, rectangle);

-        private static IImageProcessingContext<TPixel> VignetteInternal<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, ValueSize radiusX, ValueSize radiusY, Rectangle rectangle, GraphicsOptions options)
+        private static IImageProcessingContext<TPixel> VignetteInternal<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, ValueSize radiusX, ValueSize radiusY, Rectangle rectangle)
            where TPixel : struct, IPixel<TPixel>
            => source.ApplyProcessor(new VignetteProcessor<TPixel>(color, radiusX, radiusY, options), rectangle);

-        private static IImageProcessingContext<TPixel> VignetteInternal<TPixel>(this IImageProcessingContext<TPixel> source, TPixel color, ValueSize radiusX, ValueSize radiusY, GraphicsOptions options)
+        private static IImageProcessingContext<TPixel> VignetteInternal<TPixel>(this IImageProcessingContext<TPixel> source, GraphicsOptions options, TPixel color, ValueSize radiusX, ValueSize radiusY)
            where TPixel : struct, IPixel<TPixel>
            => source.ApplyProcessor(new VignetteProcessor<TPixel>(color, radiusX, radiusY, options));
    }
--- a/tests/ImageSharp.Tests/Drawing/BlendedShapes.cs
+++ b/tests/ImageSharp.Tests/Drawing/BlendedShapes.cs
@ -29,10 +29,8 @@ namespace SixLabors.ImageSharp.Tests.Drawing
                var scaleY = (img.Height / 100);
                img.Mutate(x => x
                            .Fill(NamedColors<TPixel>.DarkBlue, new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY))
-                            .Fill(NamedColors<TPixel>.HotPink, new Rectangle(20 * scaleX, 0 * scaleY, 30 * scaleX, 100 * scaleY), new ImageSharp.GraphicsOptions(true)
-                            {
-                                BlenderMode = mode
-                            }));
+                            .Fill(new GraphicsOptions(true) { BlenderMode = mode }, NamedColors<TPixel>.HotPink, new Rectangle(20 * scaleX, 0 * scaleY, 30 * scaleX, 100 * scaleY)
+                            ));
                img.DebugSave(provider, new { mode });
            }
        }
@ -47,14 +45,8 @@ namespace SixLabors.ImageSharp.Tests.Drawing
                var scaleX = (img.Width / 100);
                var scaleY = (img.Height / 100);
                img.Mutate(x => x.Fill(NamedColors<TPixel>.DarkBlue, new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)));
-                img.Mutate(x => x.Fill(NamedColors<TPixel>.HotPink, new Rectangle(20 * scaleX, 0 * scaleY, 30 * scaleX, 100 * scaleY), new ImageSharp.GraphicsOptions(true)
-                {
-                    BlenderMode = mode
-                }));
-                img.Mutate(x => x.Fill(NamedColors<TPixel>.Transparent, new SixLabors.Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY), new ImageSharp.GraphicsOptions(true)
-                {
-                    BlenderMode = mode
-                }));
+                img.Mutate(x => x.Fill(new GraphicsOptions(true) { BlenderMode = mode }, NamedColors<TPixel>.HotPink, new Rectangle(20 * scaleX, 0 * scaleY, 30 * scaleX, 100 * scaleY)));
+                img.Mutate(x => x.Fill(new GraphicsOptions(true) { BlenderMode = mode }, NamedColors<TPixel>.Transparent, new Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
                img.DebugSave(provider, new { mode });
            }
        }
@ -69,19 +61,13 @@ namespace SixLabors.ImageSharp.Tests.Drawing
                var scaleX = (img.Width / 100);
                var scaleY = (img.Height / 100);
                img.Mutate(x => x.Fill(NamedColors<TPixel>.DarkBlue, new Rectangle(0 * scaleX, 40, 100 * scaleX, 20 * scaleY)));
-                img.Mutate(x => x.Fill(NamedColors<TPixel>.HotPink, new Rectangle(20 * scaleX, 0, 30 * scaleX, 100 * scaleY), new ImageSharp.GraphicsOptions(true)
-                {
-                    BlenderMode = mode
-                }));
+                img.Mutate(x => x.Fill(new GraphicsOptions(true) { BlenderMode = mode }, NamedColors<TPixel>.HotPink, new Rectangle(20 * scaleX, 0, 30 * scaleX, 100 * scaleY)));
                var c = NamedColors<TPixel>.Red.ToVector4();
                c.W *= 0.5f;
                TPixel pixel = default(TPixel);
                pixel.PackFromVector4(c);

-                img.Mutate(x => x.Fill(pixel, new SixLabors.Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY), new ImageSharp.GraphicsOptions(true)
-                {
-                    BlenderMode = mode
-                }));
+                img.Mutate(x => x.Fill(new GraphicsOptions(true) { BlenderMode = mode }, pixel, new Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
                img.DebugSave(provider, new { mode });
            }
        }
@ -98,10 +84,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing
                var scaleX = (img.Width / 100);
                var scaleY = (img.Height / 100);
                img.Mutate(x => x.Fill(NamedColors<TPixel>.DarkBlue, new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)));
-                img.Mutate(x => x.Fill(NamedColors<TPixel>.Black, new SixLabors.Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY), new ImageSharp.GraphicsOptions(true)
-                {
-                    BlenderMode = mode
-                }));
+                img.Mutate(x => x.Fill(new GraphicsOptions(true) { BlenderMode = mode }, NamedColors<TPixel>.Black, new Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
                img.DebugSave(provider, new { mode });
            }
        }
--- a/tests/ImageSharp.Tests/Drawing/LineTests.cs
+++ b/tests/ImageSharp.Tests/Drawing/LineTests.cs
@ -50,13 +50,15 @@ namespace SixLabors.ImageSharp.Tests.Drawing
            {
                image.Mutate(x => x
                    .BackgroundColor(Rgba32.Blue)
-                    .DrawLines(Rgba32.HotPink, 5,
-                    new SixLabors.Primitives.PointF[] {
-                            new Vector2(10, 10),
-                            new Vector2(200, 150),
-                            new Vector2(50, 300)
-                    },
-                    new GraphicsOptions(false)));
+                    .DrawLines(
+                        new GraphicsOptions(false),
+                        Rgba32.HotPink, 
+                        5,
+                        new SixLabors.Primitives.PointF[] {
+                                new Vector2(10, 10),
+                                new Vector2(200, 150),
+                                new Vector2(50, 300)
+                        }));
                image.Save($"{path}/Simple_noantialias.png");

                using (PixelAccessor<Rgba32> sourcePixels = image.Lock())
--- a/tests/ImageSharp.Tests/Drawing/Paths/FillPath.cs
+++ b/tests/ImageSharp.Tests/Drawing/Paths/FillPath.cs
@ -44,7 +44,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Paths
        [Fact]
        public void CorrectlySetsBrushPathOptions()
        {
-            this.operations.Fill(this.brush, this.path, this.noneDefault);
+            this.operations.Fill(this.noneDefault, this.brush, this.path);
            var processor = this.Verify<FillRegionProcessor<Rgba32>>();

            Assert.Equal(this.noneDefault, processor.Options);
@ -75,7 +75,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Paths
        [Fact]
        public void CorrectlySetsColorPathAndOptions()
        {
-            this.operations.Fill(this.color, this.path, this.noneDefault);
+            this.operations.Fill(this.noneDefault, this.color, this.path);
            var processor = this.Verify<FillRegionProcessor<Rgba32>>();

            Assert.Equal(this.noneDefault, processor.Options);
--- a/tests/ImageSharp.Tests/Drawing/Paths/FillPathCollection.cs
+++ b/tests/ImageSharp.Tests/Drawing/Paths/FillPathCollection.cs
@ -31,7 +31,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Paths
                }));

        IPathCollection pathCollection;
-        
+
        public FillPathCollection()
        {
            this.pathCollection = new PathCollection(this.path1, this.path2);
@ -61,7 +61,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Paths
        [Fact]
        public void CorrectlySetsBrushPathOptions()
        {
-            this.operations.Fill(this.brush, this.pathCollection, this.noneDefault);
+            this.operations.Fill(this.noneDefault, this.brush, this.pathCollection);

            for (int i = 0; i < 2; i++)
            {
@ -100,7 +100,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Paths
        [Fact]
        public void CorrectlySetsColorPathAndOptions()
        {
-            this.operations.Fill(this.color, this.pathCollection, this.noneDefault);
+            this.operations.Fill(this.noneDefault, this.color, this.pathCollection);

            for (int i = 0; i < 2; i++)
            {
--- a/tests/ImageSharp.Tests/Drawing/Paths/FillPolygon.cs
+++ b/tests/ImageSharp.Tests/Drawing/Paths/FillPolygon.cs
@ -44,7 +44,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Paths
        [Fact]
        public void CorrectlySetsBrushPathAndOptions()
        {
-            this.operations.FillPolygon(this.brush, this.path, this.noneDefault);
+            this.operations.FillPolygon(this.noneDefault, this.brush, this.path);
            FillRegionProcessor<Rgba32> processor = this.Verify<FillRegionProcessor<Rgba32>>();

            Assert.Equal(this.noneDefault, processor.Options);
@ -76,7 +76,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Paths
        [Fact]
        public void CorrectlySetsColorPathAndOptions()
        {
-            this.operations.FillPolygon(this.color, this.path, this.noneDefault);
+            this.operations.FillPolygon(this.noneDefault, this.color, this.path);
            FillRegionProcessor<Rgba32> processor = this.Verify<FillRegionProcessor<Rgba32>>();


--- a/tests/ImageSharp.Tests/Drawing/Paths/FillRectangle.cs
+++ b/tests/ImageSharp.Tests/Drawing/Paths/FillRectangle.cs
@ -38,7 +38,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Paths
        [Fact]
        public void CorrectlySetsBrushRectangleAndOptions()
        {
-            this.operations.Fill(this.brush, this.rectangle, this.noneDefault);
+            this.operations.Fill(this.noneDefault, this.brush, this.rectangle);
            FillRegionProcessor<Rgba32> processor = this.Verify<FillRegionProcessor<Rgba32>>();

            Assert.Equal(this.noneDefault, processor.Options);
@ -75,7 +75,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Paths
        [Fact]
        public void CorrectlySetsColorRectangleAndOptions()
        {
-            this.operations.Fill(this.color, this.rectangle, this.noneDefault);
+            this.operations.Fill(this.noneDefault, this.color, this.rectangle);
            FillRegionProcessor<Rgba32> processor = this.Verify<FillRegionProcessor<Rgba32>>();

            Assert.Equal(this.noneDefault, processor.Options);
--- a/tests/ImageSharp.Tests/Drawing/SolidPolygonTests.cs
+++ b/tests/ImageSharp.Tests/Drawing/SolidPolygonTests.cs
@ -29,7 +29,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing
            using (var image = new Image<Rgba32>(500, 500))
            {
                image.Mutate(x => x
-                    .FillPolygon(Rgba32.HotPink, simplePath, new GraphicsOptions(true)));
+                    .FillPolygon(new GraphicsOptions(true), Rgba32.HotPink, simplePath));
                image.Save($"{path}/Simple.png");

                using (PixelAccessor<Rgba32> sourcePixels = image.Lock())
@ -52,7 +52,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing
            using (var image = new Image<Rgba32>(500, 500))
            {
                image.Mutate(x => x
-                    .FillPolygon(Brushes.Horizontal(Rgba32.HotPink), simplePath, new GraphicsOptions(true)));
+                    .FillPolygon(new GraphicsOptions(true), Brushes.Horizontal(Rgba32.HotPink), simplePath));
                image.Save($"{path}/Pattern.png");

                using (PixelAccessor<Rgba32> sourcePixels = image.Lock())
@ -76,7 +76,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing
            {
                image.Mutate(x => x
                    .BackgroundColor(Rgba32.Blue)
-                    .FillPolygon(Rgba32.HotPink, simplePath, new GraphicsOptions(false)));
+                    .FillPolygon(new GraphicsOptions(false), Rgba32.HotPink, simplePath));
                image.Save($"{path}/Simple_NoAntialias.png");

                using (PixelAccessor<Rgba32> sourcePixels = image.Lock())
--- a/tests/ImageSharp.Tests/Drawing/Text/DrawText.Path.cs
+++ b/tests/ImageSharp.Tests/Drawing/Text/DrawText.Path.cs
@ -37,12 +37,12 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        public void FillsForEachACharachterWhenBrushSetAndNotPen()
        {
            this.operations.DrawText(
+                new TextGraphicsOptions(true),
                "123",
                this.Font,
                Brushes.Solid(Rgba32.Red),
                null,
-                this.path,
-                new TextGraphicsOptions(true));
+                this.path);

            this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -62,7 +62,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        [Fact]
        public void FillsForEachACharachterWhenBrushSet()
        {
-            this.operations.DrawText("123", this.Font, Brushes.Solid(Rgba32.Red), this.path, new TextGraphicsOptions(true));
+            this.operations.DrawText(new TextGraphicsOptions(true), "123", this.Font, Brushes.Solid(Rgba32.Red), this.path);

            this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -82,7 +82,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        [Fact]
        public void FillsForEachACharachterWhenColorSet()
        {
-            this.operations.DrawText("123", this.Font, Rgba32.Red, this.path, new TextGraphicsOptions(true));
+            this.operations.DrawText(new TextGraphicsOptions(true), "123", this.Font, Rgba32.Red, this.path);

            var processor = this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -109,12 +109,12 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        public void DrawForEachACharachterWhenPenSetAndNotBrush()
        {
            this.operations.DrawText(
+                new TextGraphicsOptions(true),
                "123",
                this.Font,
                null,
                Pens.Dash(Rgba32.Red, 1),
-                this.path,
-                new TextGraphicsOptions(true));
+                this.path);

            var processor = this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -134,7 +134,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        [Fact]
        public void DrawForEachACharachterWhenPenSet()
        {
-            this.operations.DrawText("123", this.Font, Pens.Dash(Rgba32.Red, 1), this.path, new TextGraphicsOptions(true));
+            this.operations.DrawText(new TextGraphicsOptions(true), "123", this.Font, Pens.Dash(Rgba32.Red, 1), this.path);

            var processor = this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -155,12 +155,12 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        public void DrawForEachACharachterWhenPenSetAndFillFroEachWhenBrushSet()
        {
            this.operations.DrawText(
+                new TextGraphicsOptions(true),
                "123",
                this.Font,
                Brushes.Solid(Rgba32.Red),
                Pens.Dash(Rgba32.Red, 1),
-                this.path,
-                new TextGraphicsOptions(true));
+                this.path);

            var processor = this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -187,12 +187,12 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        public void BrushAppliesBeforPen()
        {
            this.operations.DrawText(
+                new TextGraphicsOptions(true),
                "1",
                this.Font,
                Brushes.Solid(Rgba32.Red),
                Pens.Dash(Rgba32.Red, 1),
-                this.path,
-            new TextGraphicsOptions(true));
+                this.path);

            var processor = this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
--- a/tests/ImageSharp.Tests/Drawing/Text/DrawText.cs
+++ b/tests/ImageSharp.Tests/Drawing/Text/DrawText.cs
@ -37,12 +37,12 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        public void FillsForEachACharachterWhenBrushSetAndNotPen()
        {
            this.operations.DrawText(
+                new TextGraphicsOptions(true),
                "123",
                this.Font,
                Brushes.Solid(Rgba32.Red),
                null,
-                Vector2.Zero,
-                new TextGraphicsOptions(true));
+                Vector2.Zero);

            this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -62,7 +62,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        [Fact]
        public void FillsForEachACharachterWhenBrushSet()
        {
-            this.operations.DrawText("123", this.Font, Brushes.Solid(Rgba32.Red), Vector2.Zero, new TextGraphicsOptions(true));
+            this.operations.DrawText(new TextGraphicsOptions(true), "123", this.Font, Brushes.Solid(Rgba32.Red), Vector2.Zero);

            this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -82,7 +82,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        [Fact]
        public void FillsForEachACharachterWhenColorSet()
        {
-            this.operations.DrawText("123", this.Font, Rgba32.Red, Vector2.Zero, new TextGraphicsOptions(true));
+            this.operations.DrawText(new TextGraphicsOptions(true), "123", this.Font, Rgba32.Red, Vector2.Zero);

            var processor = this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -109,12 +109,12 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        public void DrawForEachACharachterWhenPenSetAndNotBrush()
        {
            this.operations.DrawText(
+                new TextGraphicsOptions(true),
                "123",
                this.Font,
                null,
                Pens.Dash(Rgba32.Red, 1),
-                Vector2.Zero,
-                new TextGraphicsOptions(true));
+                Vector2.Zero);

            var processor = this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -134,7 +134,7 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        [Fact]
        public void DrawForEachACharachterWhenPenSet()
        {
-            this.operations.DrawText("123", this.Font, Pens.Dash(Rgba32.Red, 1), Vector2.Zero, new TextGraphicsOptions(true));
+            this.operations.DrawText(new TextGraphicsOptions(true), "123", this.Font, Pens.Dash(Rgba32.Red, 1), Vector2.Zero);

            var processor = this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -155,12 +155,12 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        public void DrawForEachACharachterWhenPenSetAndFillFroEachWhenBrushSet()
        {
            this.operations.DrawText(
+                new TextGraphicsOptions(true),
                "123",
                this.Font,
                Brushes.Solid(Rgba32.Red),
                Pens.Dash(Rgba32.Red, 1),
-                Vector2.Zero,
-                new TextGraphicsOptions(true));
+                Vector2.Zero);

            var processor = this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
@ -188,12 +188,12 @@ namespace SixLabors.ImageSharp.Tests.Drawing.Text
        public void BrushAppliesBeforePen()
        {
            this.operations.DrawText(
+                new TextGraphicsOptions(true),
                "1",
                this.Font,
                Brushes.Solid(Rgba32.Red),
                Pens.Dash(Rgba32.Red, 1),
-                Vector2.Zero,
-                new TextGraphicsOptions(true));
+                Vector2.Zero);

            var processor = this.Verify<FillRegionProcessor<Rgba32>>(0);
            this.Verify<FillRegionProcessor<Rgba32>>(1);
--- a/tests/ImageSharp.Tests/Issues/Issue412.cs
+++ b/tests/ImageSharp.Tests/Issues/Issue412.cs
@ -22,24 +22,24 @@ namespace SixLabors.ImageSharp.Tests.Issues
                        for (var i = 0; i < 40; ++i)
                        {
                            context.DrawLines(
+                                new GraphicsOptions(false),
                                NamedColors<TPixel>.Black,
                                1,
                                new[]
                                {
                                new PointF(i, 0.1066f),
                                new PointF(i, 10.1066f)
-                                },
-                                new GraphicsOptions(true));
+                                });

                            context.DrawLines(
+                                new GraphicsOptions(false),
                                NamedColors<TPixel>.Red,
                                1,
                                new[]
                                {
                                new PointF(i, 15.1066f),
                                new PointF(i, 25.1066f)
-                                },
-                                new GraphicsOptions(false));
+                                });
                        }
                    });

--- a/tests/ImageSharp.Tests/Processing/Effects/BackgroundColorTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Effects/BackgroundColorTest.cs
@ -35,7 +35,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Effects
        [Fact]
        public void BackgroundColor_amount_options_BackgroundColorProcessorDefaultsSet()
        {
-            this.operations.BackgroundColor(Rgba32.BlanchedAlmond, this.options);
+            this.operations.BackgroundColor(this.options, Rgba32.BlanchedAlmond);
            var processor = this.Verify<BackgroundColorProcessor<Rgba32>>();

            Assert.Equal(this.options, processor.GraphicsOptions);
@ -45,7 +45,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Effects
        [Fact]
        public void BackgroundColor_amount_rect_options_BackgroundColorProcessorDefaultsSet()
        {
-            this.operations.BackgroundColor(Rgba32.BlanchedAlmond, this.rect, this.options);
+            this.operations.BackgroundColor(this.options, Rgba32.BlanchedAlmond, this.rect);
            var processor = this.Verify<BackgroundColorProcessor<Rgba32>>(this.rect);

            Assert.Equal(this.options, processor.GraphicsOptions);