Added IPixel.PackFromBgra32, similarly to the PackFromArgb32.

src/ImageSharp/PixelFormats/Alpha8.cs

@@ -103,6 +103,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackedValue = source.A;
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackedValue = source.A;
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/Argb32.cs

@@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.PixelFormats
 {
     /// <summary>
     /// Packed pixel type containing four 8-bit unsigned normalized values ranging from 0 to 255.
-    /// The color components are stored in alpha, red, green, and blue order.
+    /// The color components are stored in alpha, red, green, and blue order (least significant to most significant byte).
     /// <para>
     /// Ranges from [0, 0, 0, 0] to [1, 1, 1, 1] in vector form.
     /// </para>
@@ -240,6 +240,16 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackedValue = source.PackedValue;
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.R = source.R;
+            this.G = source.G;
+            this.B = source.B;
+            this.A = source.A;
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/Bgr24.cs

@@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.PixelFormats
 {
     /// <summary>
     /// Pixel type containing three 8-bit unsigned normalized values ranging from 0 to 255.
-    /// The color components are stored in blue, green, red order.
+    /// The color components are stored in blue, green, red order (least significant to most significant byte).
     /// <para>
     /// Ranges from [0, 0, 0, 1] to [1, 1, 1, 1] in vector form.
     /// </para>
@@ -90,6 +90,15 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.B = source.B;
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.R = source.R;
+            this.G = source.G;
+            this.B = source.B;
+        }
+
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void PackFromScaledVector4(Vector4 vector)

src/ImageSharp/PixelFormats/Bgr565.cs

@@ -126,6 +126,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(source.ToVector4());
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackFromVector4(source.ToVector4());
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/Bgra32.cs

@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.PixelFormats
 {
     /// <summary>
     /// Packed pixel type containing four 8-bit unsigned normalized values ranging from 0 to 255.
-    /// The color components are stored in blue, green, red, and alpha order.
+    /// The color components are stored in blue, green, red, and alpha order (least significant to most significant byte).
     /// <para>
     /// Ranges from [0, 0, 0, 0] to [1, 1, 1, 1] in vector form.
     /// </para>
@@ -119,6 +119,16 @@ namespace SixLabors.ImageSharp.PixelFormats
             }
         }
 
+        /// <summary>
+        /// Gets the <see cref="Vector4"/> representation without normalizing to [0, 1]
+        /// </summary>
+        /// <returns>A <see cref="Vector4"/> of values in [0, 255] </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal Vector4 ToByteScaledVector4()
+        {
+            return new Vector4(this.R, this.G, this.B, this.A);
+        }
+
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void PackFromScaledVector4(Vector4 vector)
@@ -169,6 +179,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.A = source.A;
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackedValue = source.PackedValue;
+        }
+
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/Bgra4444.cs

@@ -118,6 +118,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(source.ToVector4());
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackFromVector4(source.ToVector4());
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/Bgra5551.cs

@@ -118,6 +118,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(source.ToVector4());
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackFromVector4(source.ToVector4());
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/Byte4.cs

@@ -119,6 +119,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(source.ToByteScaledVector4());
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackFromVector4(source.ToByteScaledVector4());
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/Generated/PixelOperations{TPixel}.Generated.cs

@@ -95,13 +95,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             ref Bgra32 sourceRef = ref MemoryMarshal.GetReference(source);
             ref TPixel destRef = ref MemoryMarshal.GetReference(destPixels);
 
-            Rgba32 rgba = new Rgba32(0, 0, 0, 255);
+            Bgra32 bgra = new Bgra32(0, 0, 0, 255);
 
             for (int i = 0; i < count; i++)
             {
                 ref TPixel dp = ref Unsafe.Add(ref destRef, i);
-                rgba = Unsafe.Add(ref sourceRef, i).ToRgba32();
-				dp.PackFromRgba32(rgba);
+                bgra = Unsafe.Add(ref sourceRef, i);
+				dp.PackFromBgra32(bgra);
             }
         }
 		

src/ImageSharp/PixelFormats/Generated/PixelOperations{TPixel}.Generated.tt

@@ -135,6 +135,48 @@
 		<#
     }
 
+    void GeneratePackFromMethodUsingPackFromBgra32(string pixelType, string bgraOperationCode)
+    {		
+		#>
+
+		/// <summary>
+        /// Converts 'count' elements in 'source` span of <see cref="<#=pixelType#>"/> data to a span of <typeparamref name="TPixel"/>-s.
+        /// </summary>
+        /// <param name="source">The source <see cref="Span{T}"/> of <see cref="<#=pixelType#>"/> data.</param>
+        /// <param name="destPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+        /// <param name="count">The number of pixels to convert.</param>
+        internal virtual void PackFrom<#=pixelType#>(ReadOnlySpan<<#=pixelType#>> source, Span<TPixel> destPixels, int count)
+        {
+			GuardSpans(source, nameof(source), destPixels, nameof(destPixels), count);
+            
+            ref <#=pixelType#> sourceRef = ref MemoryMarshal.GetReference(source);
+            ref TPixel destRef = ref MemoryMarshal.GetReference(destPixels);
+
+            Bgra32 bgra = new Bgra32(0, 0, 0, 255);
+
+            for (int i = 0; i < count; i++)
+            {
+                ref TPixel dp = ref Unsafe.Add(ref destRef, i);
+                <#=bgraOperationCode#>
+				dp.PackFromBgra32(bgra);
+            }
+        }
+		
+		/// <summary>
+        /// A helper for <see cref="PackFrom<#=pixelType#>(ReadOnlySpan{<#=pixelType#>}, Span{TPixel}, int)"/> that expects a byte span.
+        /// The layout of the data in 'sourceBytes' must be compatible with <see cref="<#=pixelType#>"/> layout.
+        /// </summary>
+        /// <param name="sourceBytes">The <see cref="ReadOnlySpan{T}"/> to the source bytes.</param>
+        /// <param name="destPixels">The <see cref="Span{T}"/> to the destination pixels.</param>
+        /// <param name="count">The number of pixels to convert.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void PackFrom<#=pixelType#>Bytes(ReadOnlySpan<byte> sourceBytes, Span<TPixel> destPixels, int count)
+        {
+            this.PackFrom<#=pixelType#>(MemoryMarshal.Cast<byte, <#=pixelType#>>(sourceBytes), destPixels, count);
+        }
+		<#
+    }
+
 #>
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
@@ -153,7 +195,7 @@ namespace SixLabors.ImageSharp.PixelFormats
     GeneratePackFromMethodUsingPackFromRgba32("Rgba32", "rgba = Unsafe.Add(ref sourceRef, i);");
     GenerateToDestFormatMethods("Rgba32");
 
-    GeneratePackFromMethodUsingPackFromRgba32("Bgra32", "rgba = Unsafe.Add(ref sourceRef, i).ToRgba32();");
+    GeneratePackFromMethodUsingPackFromBgra32("Bgra32", "bgra = Unsafe.Add(ref sourceRef, i);");
     GenerateToDestFormatMethods("Bgra32");
 	
 	GeneratePackFromMethodUsingPackFromRgba32("Rgb24", "rgba.Rgb = Unsafe.Add(ref sourceRef, i);");

src/ImageSharp/PixelFormats/HalfSingle.cs

@@ -132,6 +132,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(source.ToVector4());
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackFromVector4(source.ToVector4());
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/HalfVector2.cs

@@ -147,6 +147,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(source.ToVector4());
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackFromVector4(source.ToVector4());
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/HalfVector4.cs

@@ -140,6 +140,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(source.ToVector4());
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackFromVector4(source.ToVector4());
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/IPixel.cs

@@ -8,6 +8,8 @@ namespace SixLabors.ImageSharp.PixelFormats
 {
     /// <summary>
     /// An interface that represents a generic pixel type.
+    /// The naming convention of each pixel format is to order the color components from least significant to most significant, reading from left to right.
+    /// For example in the <see cref="Rgba32"/> pixel format the R component is the least significant byte, and the A component is the most significant.
     /// </summary>
     /// <typeparam name="TSelf">The type implementing this interface</typeparam>
     public interface IPixel<TSelf> : IPixel, IEquatable<TSelf>
@@ -65,6 +67,12 @@ namespace SixLabors.ImageSharp.PixelFormats
         /// <param name="source">The <see cref="Argb32"/> value.</param>
         void PackFromArgb32(Argb32 source);
 
+        /// <summary>
+        /// Packs the pixel from an <see cref="Bgra32"/> value.
+        /// </summary>
+        /// <param name="source">The <see cref="Bgra32"/> value.</param>
+        void PackFromBgra32(Bgra32 source);
+
         /// <summary>
         /// Converts the pixel to <see cref="Rgb24"/> format.
         /// </summary>

src/ImageSharp/PixelFormats/NormalizedByte2.cs

@@ -161,6 +161,18 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(vector);
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            Vector4 vector = source.ToByteScaledVector4();
+            vector -= Round;
+            vector -= Half;
+            vector -= Round;
+            vector /= Half;
+            this.PackFromVector4(vector);
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/NormalizedByte4.cs

@@ -153,6 +153,18 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(vector);
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            Vector4 vector = source.ToByteScaledVector4();
+            vector -= Round;
+            vector -= Half;
+            vector -= Round;
+            vector /= Half;
+            this.PackFromVector4(vector);
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/NormalizedShort2.cs

@@ -147,6 +147,18 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(vector);
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            Vector4 vector = source.ToByteScaledVector4();
+            vector -= Round;
+            vector -= Half;
+            vector -= Round;
+            vector /= Half;
+            this.PackFromVector4(vector);
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/NormalizedShort4.cs

@@ -156,6 +156,18 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(vector);
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            Vector4 vector = source.ToByteScaledVector4();
+            vector -= Round;
+            vector -= Half;
+            vector -= Round;
+            vector /= Half;
+            this.PackFromVector4(vector);
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/README.md

@@ -4,4 +4,7 @@ https://github.com/MonoGame/MonoGame
 
 Rgba32 is our default format. As such it positioned within the ImageSharp root namespace to ensure visibility of the format.
 
-All other pixel formats should be positioned within ImageSharp.PixelFormats to reduce intellisense burden.
+All other pixel formats should be positioned within ImageSharp.PixelFormats to reduce intellisense burden.
+
+The naming convention of each pixel format is to order the color components from least significant to most significant, reading from left to right.
+For example in the Rgba32 pixel format the R component is the least significant byte, and the A component is the most significant.

src/ImageSharp/PixelFormats/Rg32.cs

@@ -131,6 +131,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(source.ToVector4());
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackFromVector4(source.ToVector4());
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/Rgb24.cs

@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.PixelFormats
 {
     /// <summary>
     /// Pixel type containing three 8-bit unsigned normalized values ranging from 0 to 255.
-    /// The color components are stored in red, green, blue order.
+    /// The color components are stored in red, green, blue order (least significant to most significant byte).
     /// <para>
     /// Ranges from [0, 0, 0, 1] to [1, 1, 1, 1] in vector form.
     /// </para>
@@ -92,6 +92,15 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.B = source.B;
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.R = source.R;
+            this.G = source.G;
+            this.B = source.B;
+        }
+
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void PackFromScaledVector4(Vector4 vector)

src/ImageSharp/PixelFormats/Rgba1010102.cs

@@ -125,6 +125,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(source.ToVector4());
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackFromVector4(source.ToVector4());
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/Rgba32.cs

@@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.PixelFormats
 {
     /// <summary>
     /// Packed pixel type containing four 8-bit unsigned normalized values ranging from 0 to 255.
-    /// The color components are stored in red, green, blue, and alpha order.
+    /// The color components are stored in red, green, blue, and alpha order (least significant to most significant byte).
     /// <para>
     /// Ranges from [0, 0, 0, 0] to [1, 1, 1, 1] in vector form.
     /// </para>
@@ -282,6 +282,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             Pack(source.R, source.G, source.B, source.A);
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            Pack(source.R, source.G, source.B, source.A);
+        }
+
         /// <summary>
         /// Converts the value of this instance to a hexadecimal string.
         /// </summary>

src/ImageSharp/PixelFormats/Rgba64.cs

@@ -124,6 +124,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackFromVector4(source.ToVector4());
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.PackFromVector4(source.ToVector4());
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/RgbaVector.cs

@@ -225,6 +225,13 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.backingVector = source.ToVector4();
         }
 
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            this.backingVector = source.ToVector4();
+        }
+
         /// <summary>
         /// Converts the value of this instance to a hexadecimal string.
         /// </summary>

src/ImageSharp/PixelFormats/Short2.cs

@@ -144,6 +144,16 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackedValue = Pack(vector.X, vector.Y);
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            Vector2 vector = new Vector2(source.R, source.G) / 255;
+            vector *= 65534;
+            vector -= new Vector2(32767);
+            this.PackedValue = Pack(vector.X, vector.Y);
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)

src/ImageSharp/PixelFormats/Short4.cs

@@ -150,6 +150,16 @@ namespace SixLabors.ImageSharp.PixelFormats
             this.PackedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
         }
 
+        /// <inheritdoc />
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PackFromBgra32(Bgra32 source)
+        {
+            var vector = source.ToVector4();
+            vector *= 65534;
+            vector -= new Vector4(32767);
+            this.PackedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
+        }
+
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)