Refactor image importer

Author: Looooong

Runtime/AsyncImageLoader/FreeImage.cs

@@ -70,6 +70,76 @@ internal enum ColorType {
       FIC_CMYK = 5
     }
 
+    [System.Flags]
+    internal enum LoadFlags {
+      /// <summary>
+      /// Default option for all types.
+      /// </summary>
+      DEFAULT = 0,
+      /// <summary>
+      /// Load the image as a 256 color image with ununsed palette entries, if it's 16 or 2 color.
+      /// </summary>
+      GIF_LOAD256 = 1,
+      /// <summary>
+      /// 'Play' the GIF to generate each frame (as 32bpp) instead of returning raw frame data when loading.
+      /// </summary>
+      GIF_PLAYBACK = 2,
+      /// <summary>
+      /// Convert to 32bpp and create an alpha channel from the AND-mask when loading.
+      /// </summary>
+      ICO_MAKEALPHA = 1,
+      /// <summary>
+      /// Load the file as fast as possible, sacrificing some quality.
+      /// </summary>
+      JPEG_FAST = 0x0001,
+      /// <summary>
+      /// Load the file with the best quality, sacrificing some speed.
+      /// </summary>
+      JPEG_ACCURATE = 0x0002,
+      /// <summary>
+      /// Load separated CMYK "as is" (use | to combine with other load flags).
+      /// </summary>
+      JPEG_CMYK = 0x0004,
+      /// <summary>
+      /// Load and rotate according to Exif 'Orientation' tag if available.
+      /// </summary>
+      JPEG_EXIFROTATE = 0x0008,
+      /// <summary>
+      /// Load the bitmap sized 768 x 512.
+      /// </summary>
+      PCD_BASE = 1,
+      /// <summary>
+      /// Load the bitmap sized 384 x 256.
+      /// </summary>
+      PCD_BASEDIV4 = 2,
+      /// <summary>
+      /// Load the bitmap sized 192 x 128.
+      /// </summary>
+      PCD_BASEDIV16 = 3,
+      /// <summary>
+      /// Avoid gamma correction.
+      /// </summary>
+      PNG_IGNOREGAMMA = 1,
+      /// <summary>
+      /// If set the loader converts RGB555 and ARGB8888 -> RGB888.
+      /// </summary>
+      TARGA_LOAD_RGB888 = 1,
+      /// <summary>
+      /// Reads tags for separated CMYK.
+      /// </summary>
+      TIFF_CMYK = 0x0001,
+      /// <summary>
+      /// Tries to load the JPEG preview image, embedded in
+      /// Exif Metadata or load the image as RGB 24-bit if no 
+      /// preview image is available.
+      /// </summary>
+      RAW_PREVIEW = 0x1,
+      /// <summary>
+      /// Loads the image as RGB 24-bit.
+      /// </summary>
+      RAW_DISPLAY = 0x2,
+    }
+
     const string FreeImageLibrary = "FreeImage";
 
     [DllImport(FreeImageLibrary, EntryPoint = "FreeImage_GetFileTypeFromMemory")]

Runtime/AsyncImageLoader/MipmapJobs.cs

@@ -0,0 +1,45 @@
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Jobs;
+using Unity.Mathematics;
+using static Unity.Mathematics.math;
+
+public partial class AsyncImageLoader {
+  interface IMipmapJob<TChannel> : IJobParallelFor where TChannel : struct {
+    int2 InputSize { get; set; }
+    int2 OutputSize { get; set; }
+    NativeSlice<TChannel> InputChannel { get; set; }
+    NativeSlice<TChannel> OutputChannel { get; set; }
+  }
+
+  [BurstCompile(CompileSynchronously = true)]
+  struct ByteChannelMipmapJob : IMipmapJob<byte> {
+    public int2 InputSize { get; set; }
+    public int2 OutputSize { get; set; }
+
+    public NativeSlice<byte> InputChannel { get => _inputChannel; set => _inputChannel = value; }
+    public NativeSlice<byte> OutputChannel { get => _outputChannel; set => _outputChannel = value; }
+
+    [ReadOnly] NativeSlice<byte> _inputChannel;
+    [WriteOnly] NativeSlice<byte> _outputChannel;
+
+    public void Execute(int outputIndex) {
+      var outputPosition = int2(
+        outputIndex % OutputSize.x,
+        outputIndex / OutputSize.x
+      );
+      var offset = int2(0);
+      var total = 0u;
+
+      for (offset.y = 0; offset.y < 2; offset.y++) {
+        for (offset.x = 0; offset.x < 2; offset.x++) {
+          var inputPosition = min(mad(2, outputPosition, offset), InputSize - 1);
+          var inputIndex = mad(InputSize.x, inputPosition.y, inputPosition.x);
+          total += _inputChannel[inputIndex];
+        }
+      }
+
+      _outputChannel[outputIndex] = (byte)(total >> 2);
+    }
+  }
+}

Runtime/AsyncImageLoader/MipmapJobs.cs.meta

@@ -0,0 +1,20 @@
+public partial class AsyncImageLoader {
+  interface IPixel<TChannel> where TChannel : struct {
+    static int ChannelCount() => throw new System.NotImplementedException();
+    static int ChannelByteCount() => throw new System.NotImplementedException();
+  }
+
+  struct RGB24Pixel : IPixel<byte> {
+    public static int ChannelCount() => 3;
+    public static int ChannelByteCount() => sizeof(byte);
+
+    public byte r, g, b;
+  }
+
+  struct RGBA32Pixel : IPixel<byte> {
+    public static int ChannelCount() => 4;
+    public static int ChannelByteCount() => sizeof(byte);
+
+    public byte r, g, b, a;
+  }
+}