From ffb38a301c3203ad3600028b867b8afc892f0942 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Mon, 29 May 2023 18:40:02 +0200
Subject: [PATCH 01/19] Add PNG decoding

---
 NoiseEngine.Native/Cargo.toml                 |   2 +
 .../interop/rendering/cpu_texture_interop.rs  |  28 +++++++
 .../src/interop/rendering/mod.rs              |   1 +
 .../src/interop/result_error_kind.rs          |   1 +
 NoiseEngine.Native/src/rendering/cpu.rs       |  77 ++++++++++++++++++
 .../src/rendering/encoding/mod.rs             |   1 +
 .../src/rendering/encoding/png.rs             |  67 +++++++++++++++
 NoiseEngine.Native/src/rendering/mod.rs       |   2 +
 .../Rendering/CpuTextureInteropTest.cs        |  58 +++++++++++++
 NoiseEngine.Tests/NoiseEngine.Tests.csproj    |  10 +++
 .../Resources/Textures/colors.png             | Bin 0 -> 129 bytes
 .../Interop/Rendering/CpuTextureInterop.cs    |  11 +++
 NoiseEngine/Interop/ResultError.cs            |   1 +
 NoiseEngine/Interop/ResultErrorKind.cs        |   1 +
 NoiseEngine/Rendering/Cpu/CpuTextureData.cs   |  15 ++++
 NoiseEngine/Rendering/Cpu/CpuTextureFormat.cs |  10 +++
 NoiseEngine/Rendering/CpuTexture.cs           |  21 +++++
 NoiseEngine/Rendering/CpuTexture2D.cs         |  17 ++++
 18 files changed, 323 insertions(+)
 create mode 100644 NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
 create mode 100644 NoiseEngine.Native/src/rendering/cpu.rs
 create mode 100644 NoiseEngine.Native/src/rendering/encoding/mod.rs
 create mode 100644 NoiseEngine.Native/src/rendering/encoding/png.rs
 create mode 100644 NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
 create mode 100644 NoiseEngine.Tests/Resources/Textures/colors.png
 create mode 100644 NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
 create mode 100644 NoiseEngine/Rendering/Cpu/CpuTextureData.cs
 create mode 100644 NoiseEngine/Rendering/Cpu/CpuTextureFormat.cs
 create mode 100644 NoiseEngine/Rendering/CpuTexture.cs
 create mode 100644 NoiseEngine/Rendering/CpuTexture2D.cs

diff --git a/NoiseEngine.Native/Cargo.toml b/NoiseEngine.Native/Cargo.toml
index b56a4a4b..3d13437e 100644
--- a/NoiseEngine.Native/Cargo.toml
+++ b/NoiseEngine.Native/Cargo.toml
@@ -19,6 +19,8 @@ arc-cell = "0.3.3"
 const-utf16 = "0.2.1"
 cgmath = "0.18.0"
 crossbeam-queue = "0.3.8"
+png = "0.17.8"
+anyhow = "1.0.71"
 
 [dependencies.uuid]
 version = "1.2.2"
diff --git a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
new file mode 100644
index 00000000..8d9cfaae
--- /dev/null
+++ b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
@@ -0,0 +1,28 @@
+use crate::{
+    interop::prelude::{
+        InteropReadOnlySpan,
+        InteropResult,
+        ResultError,
+        ResultErrorKind,
+    },
+    rendering::{cpu::CpuTextureData, encoding}
+};
+
+#[no_mangle]
+extern "C" fn rendering_cpu_texture_interop_decode_png(
+    file_data: InteropReadOnlySpan<u8>,
+) -> InteropResult<CpuTextureData> {
+    let result = encoding::png::decode(file_data.into());
+
+    match result {
+        Ok(data) => {
+            InteropResult::with_ok(data)
+        },
+        Err(error) => {
+            InteropResult::with_err(ResultError::with_kind(
+                &*Box::<dyn std::error::Error>::from(error),
+                ResultErrorKind::Argument,
+            ))
+        },
+    }
+}
diff --git a/NoiseEngine.Native/src/interop/rendering/mod.rs b/NoiseEngine.Native/src/interop/rendering/mod.rs
index e2b21a0e..bba2873a 100644
--- a/NoiseEngine.Native/src/interop/rendering/mod.rs
+++ b/NoiseEngine.Native/src/interop/rendering/mod.rs
@@ -4,3 +4,4 @@ pub mod vulkan;
 
 pub mod fence_interop;
 pub mod texture_interop;
+pub mod cpu_texture_interop;
diff --git a/NoiseEngine.Native/src/interop/result_error_kind.rs b/NoiseEngine.Native/src/interop/result_error_kind.rs
index da4addf5..11cf9709 100644
--- a/NoiseEngine.Native/src/interop/result_error_kind.rs
+++ b/NoiseEngine.Native/src/interop/result_error_kind.rs
@@ -7,6 +7,7 @@ pub enum ResultErrorKind {
     NullReference = 2,
     InvalidOperation = 3,
     Overflow = 4,
+    Argument = 5,
 
     GraphicsUniversal = 1000,
     GraphicsInstanceCreate = 1001,
diff --git a/NoiseEngine.Native/src/rendering/cpu.rs b/NoiseEngine.Native/src/rendering/cpu.rs
new file mode 100644
index 00000000..a4de83e1
--- /dev/null
+++ b/NoiseEngine.Native/src/rendering/cpu.rs
@@ -0,0 +1,77 @@
+use crate::interop::prelude::InteropArray;
+
+#[repr(C)]
+pub enum CpuTextureFormat {
+    R8G8B8A8,
+    R8G8B8,
+    R8,
+    R16G16B16A16,
+    R16G16B16,
+    R16,
+}
+
+impl CpuTextureFormat {
+    pub fn pixel_size(&self) -> usize {
+        match self {
+            CpuTextureFormat::R8G8B8A8 => 4,
+            CpuTextureFormat::R8G8B8 => 3,
+            CpuTextureFormat::R8 => 1,
+            CpuTextureFormat::R16G16B16A16 => 8,
+            CpuTextureFormat::R16G16B16 => 6,
+            CpuTextureFormat::R16 => 2,
+        }
+    }
+}
+
+#[repr(C)]
+pub struct CpuTextureData {
+    extent_x: u32,
+    extent_y: u32,
+    extent_z: u32,
+    format: CpuTextureFormat,
+    data: InteropArray<u8>,
+}
+
+impl CpuTextureData {
+    pub fn new(
+        extent_x: u32,
+        extent_y: u32,
+        extent_z: u32,
+        format: CpuTextureFormat,
+        data: InteropArray<u8>,
+    ) -> Self {
+        assert_ne!(extent_x, 0);
+        assert_ne!(extent_y, 0);
+        assert_ne!(extent_z, 0);
+        let size = extent_x * extent_y * extent_z * format.pixel_size() as u32;
+        assert_eq!(size, data.as_slice().len() as u32);
+
+        Self {
+            extent_x,
+            extent_y,
+            extent_z,
+            format,
+            data,
+        }
+    }
+
+    pub fn extent_x(&self) -> u32 {
+        self.extent_x
+    }
+
+    pub fn extent_y(&self) -> u32 {
+        self.extent_y
+    }
+
+    pub fn extent_z(&self) -> u32 {
+        self.extent_z
+    }
+
+    pub fn format(&self) -> &CpuTextureFormat {
+        &self.format
+    }
+
+    pub fn data(&self) -> &InteropArray<u8> {
+        &self.data
+    }
+}
diff --git a/NoiseEngine.Native/src/rendering/encoding/mod.rs b/NoiseEngine.Native/src/rendering/encoding/mod.rs
new file mode 100644
index 00000000..6717f3e5
--- /dev/null
+++ b/NoiseEngine.Native/src/rendering/encoding/mod.rs
@@ -0,0 +1 @@
+pub mod png;
diff --git a/NoiseEngine.Native/src/rendering/encoding/png.rs b/NoiseEngine.Native/src/rendering/encoding/png.rs
new file mode 100644
index 00000000..d035eec6
--- /dev/null
+++ b/NoiseEngine.Native/src/rendering/encoding/png.rs
@@ -0,0 +1,67 @@
+use crate::{
+    interop::interop_array::InteropArray,
+    rendering::cpu::{CpuTextureFormat, CpuTextureData},
+};
+
+use anyhow::{anyhow, Result};
+
+pub fn decode(
+    file_data: &[u8],
+) -> Result<CpuTextureData> {
+    let decoder = png::Decoder::new(file_data);
+
+    let mut info = decoder.read_info()?;
+    let (mut color_type, mut bit_depth) = info.output_color_type();
+
+    match bit_depth {
+        png::BitDepth::Eight | png::BitDepth::Sixteen => {
+        },
+        _ => {
+            let mut decoder = png::Decoder::new(file_data);
+            decoder.set_transformations(
+                png::Transformations::normalize_to_color8()
+            );
+
+            info = decoder.read_info()?;
+            (color_type, bit_depth) = info.output_color_type();
+        },
+    };
+
+    let format = match (color_type, bit_depth) {
+        (png::ColorType::Grayscale, png::BitDepth::Eight) => {
+            CpuTextureFormat::R8
+        },
+        (png::ColorType::Grayscale, png::BitDepth::Sixteen) => {
+            CpuTextureFormat::R16
+        },
+        (png::ColorType::GrayscaleAlpha, _) => {
+            return Err(anyhow!("GrayscaleAlpha is not supported"));
+        },
+        (png::ColorType::Rgb, png::BitDepth::Eight) => {
+            CpuTextureFormat::R8G8B8
+        },
+        (png::ColorType::Rgb, png::BitDepth::Sixteen) => {
+            CpuTextureFormat::R16G16B16
+        },
+        (png::ColorType::Rgba, png::BitDepth::Eight) => {
+            CpuTextureFormat::R8G8B8A8
+        },
+        (png::ColorType::Rgba, png::BitDepth::Sixteen) => {
+            CpuTextureFormat::R16G16B16A16
+        },
+        _ => unreachable!("set_transformations should disallow other state"),
+    };
+
+    let mut data = InteropArray::new(info.output_buffer_size() as i32);
+
+    // I think this just works? Probably?
+    let frame = info.next_frame(data.as_mut_slice())?;
+
+    Ok(CpuTextureData::new(
+        frame.width,
+        frame.height,
+        1,
+        format,
+        data,
+    ))
+}
diff --git a/NoiseEngine.Native/src/rendering/mod.rs b/NoiseEngine.Native/src/rendering/mod.rs
index 90a85ea7..d90fdb11 100644
--- a/NoiseEngine.Native/src/rendering/mod.rs
+++ b/NoiseEngine.Native/src/rendering/mod.rs
@@ -4,5 +4,7 @@ pub mod presentation;
 pub mod vulkan;
 
 pub mod camera_clear;
+pub mod cpu;
+pub mod encoding;
 pub mod fence;
 pub mod texture;
diff --git a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
new file mode 100644
index 00000000..63ff6694
--- /dev/null
+++ b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
@@ -0,0 +1,58 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using NoiseEngine.Interop;
+using NoiseEngine.Interop.Rendering;
+using NoiseEngine.Mathematics;
+using NoiseEngine.Rendering;
+using NoiseEngine.Rendering.Cpu;
+
+namespace NoiseEngine.Tests.Interop.Rendering;
+
+public class CpuTextureInteropTest {
+
+    private readonly Dictionary<Vector2<uint>, Color32> textureColors = new Dictionary<Vector2<uint>, Color32> {
+        { new Vector2<uint>(0, 0), new Color32(255, 0, 0) },
+        { new Vector2<uint>(1, 0), new Color32(0, 255, 0) },
+        { new Vector2<uint>(2, 0), new Color32(0, 0, 0) },
+        { new Vector2<uint>(0, 1), new Color32(0, 0, 255) },
+        { new Vector2<uint>(1, 1), new Color32(255, 255, 0) },
+        { new Vector2<uint>(2, 1), new Color32(255, 0, 255) }
+    };
+
+    [Fact]
+    public void DecodePng() {
+        byte[] fileData = File.ReadAllBytes("./Resources/Textures/colors.png");
+        InteropResult<CpuTextureData> result = CpuTextureInterop.DecodePng(fileData);
+
+        Assert.True(result.IsOk);
+        CpuTextureData data = result.Value;
+
+        Assert.Equal<uint>(3, data.ExtentX);
+        Assert.Equal<uint>(2, data.ExtentY);
+        Assert.Equal<uint>(1, data.ExtentZ);
+        Assert.Equal(CpuTextureFormat.R8G8B8, data.Format);
+
+        byte[] expected = GetColorDataRgb(textureColors, new Vector2<uint>(data.ExtentX, data.ExtentY));
+
+        Assert.Equal(expected, data.Data.ToArray());
+    }
+
+    private static byte[] GetColorDataRgb(IDictionary<Vector2<uint>, Color32> colors, Vector2<uint> size) {
+        byte[] result = new byte[size.X * size.Y * 3];
+
+        int i = 0;
+
+        for (uint y = 0; y < size.Y; y++) {
+            for (uint x = 0; x < size.X; x++) {
+                result[i + 0] = colors[new Vector2<uint>(x, y)].R;
+                result[i + 1] = colors[new Vector2<uint>(x, y)].G;
+                result[i + 2] = colors[new Vector2<uint>(x, y)].B;
+                i += 3;
+            }
+        }
+
+        return result;
+    }
+
+}
diff --git a/NoiseEngine.Tests/NoiseEngine.Tests.csproj b/NoiseEngine.Tests/NoiseEngine.Tests.csproj
index 2f216e53..664c2cb7 100644
--- a/NoiseEngine.Tests/NoiseEngine.Tests.csproj
+++ b/NoiseEngine.Tests/NoiseEngine.Tests.csproj
@@ -33,6 +33,16 @@
         <ProjectReference Include="../NoiseEngine/NoiseEngine.csproj" />
     </ItemGroup>
 
+    <ItemGroup>
+      <Folder Include="Resources\Textures\" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <None Update="Resources\Textures\colors.png">
+        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      </None>
+    </ItemGroup>
+
     <Import Project="../NoiseEngine.Shared.xml" />
 
     <!--
diff --git a/NoiseEngine.Tests/Resources/Textures/colors.png b/NoiseEngine.Tests/Resources/Textures/colors.png
new file mode 100644
index 0000000000000000000000000000000000000000..0ca32a3a94710433320d403a7051814ce03a2771
GIT binary patch
literal 129
zcmeAS@N?(olHy`uVBq!ia0vp^%s|Y<!2~3Q#6J20DaPU;cPEB*=VV?2IV|apzK#qG
z8~eHcB(eheoCO|{#XzMcAk26#O}+vsDCX(n7$Om#{NwxqhGPmJ{{OFU`_J>A(fkhE
VFLsIT%YZ5vJYD@<);T3K0RZjWB6R=&

literal 0
HcmV?d00001

diff --git a/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
new file mode 100644
index 00000000..495cfcc5
--- /dev/null
+++ b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
@@ -0,0 +1,11 @@
+using System;
+using NoiseEngine.Rendering.Cpu;
+
+namespace NoiseEngine.Interop.Rendering;
+
+internal static partial class CpuTextureInterop {
+
+    [InteropImport("rendering_cpu_texture_interop_decode_png")]
+    public static partial InteropResult<CpuTextureData> DecodePng(ReadOnlySpan<byte> fileData);
+
+}
diff --git a/NoiseEngine/Interop/ResultError.cs b/NoiseEngine/Interop/ResultError.cs
index d1ef17f7..20d985c1 100644
--- a/NoiseEngine/Interop/ResultError.cs
+++ b/NoiseEngine/Interop/ResultError.cs
@@ -48,6 +48,7 @@ internal struct ResultError : IDisposable {
             ResultErrorKind.NullReference => new NullReferenceException(Message, innerException),
             ResultErrorKind.InvalidOperation => new InvalidOperationException(Message, innerException),
             ResultErrorKind.Overflow => new OverflowException(Message, innerException),
+            ResultErrorKind.Argument => new ArgumentException(Message, innerException),
 
             ResultErrorKind.GraphicsUniversal => new GraphicsException(Message, innerException),
             ResultErrorKind.GraphicsInstanceCreate => new GraphicsInstanceCreateException(Message, innerException),
diff --git a/NoiseEngine/Interop/ResultErrorKind.cs b/NoiseEngine/Interop/ResultErrorKind.cs
index b2888ea6..0838bd95 100644
--- a/NoiseEngine/Interop/ResultErrorKind.cs
+++ b/NoiseEngine/Interop/ResultErrorKind.cs
@@ -6,6 +6,7 @@ internal enum ResultErrorKind : uint {
     NullReference = 2,
     InvalidOperation = 3,
     Overflow = 4,
+    Argument = 5,
 
     GraphicsUniversal = 1000,
     GraphicsInstanceCreate = 1001,
diff --git a/NoiseEngine/Rendering/Cpu/CpuTextureData.cs b/NoiseEngine/Rendering/Cpu/CpuTextureData.cs
new file mode 100644
index 00000000..1e4547cc
--- /dev/null
+++ b/NoiseEngine/Rendering/Cpu/CpuTextureData.cs
@@ -0,0 +1,15 @@
+using System.Runtime.InteropServices;
+using NoiseEngine.Interop;
+
+namespace NoiseEngine.Rendering.Cpu;
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct CpuTextureData {
+
+    public uint ExtentX { get; init; }
+    public uint ExtentY { get; init; }
+    public uint ExtentZ { get; init; }
+    public CpuTextureFormat Format { get; init; }
+    public InteropArray<byte> Data { get; init; }
+
+}
diff --git a/NoiseEngine/Rendering/Cpu/CpuTextureFormat.cs b/NoiseEngine/Rendering/Cpu/CpuTextureFormat.cs
new file mode 100644
index 00000000..4377e472
--- /dev/null
+++ b/NoiseEngine/Rendering/Cpu/CpuTextureFormat.cs
@@ -0,0 +1,10 @@
+namespace NoiseEngine.Rendering.Cpu;
+
+public enum CpuTextureFormat {
+    R8G8B8A8,
+    R8G8B8,
+    R8,
+    R16G16B16A16,
+    R16G16B16,
+    R16
+}
diff --git a/NoiseEngine/Rendering/CpuTexture.cs b/NoiseEngine/Rendering/CpuTexture.cs
new file mode 100644
index 00000000..a6604463
--- /dev/null
+++ b/NoiseEngine/Rendering/CpuTexture.cs
@@ -0,0 +1,21 @@
+using System;
+using NoiseEngine.Mathematics;
+
+namespace NoiseEngine.Rendering;
+
+public abstract class CpuTexture {
+
+    private readonly byte[] data;
+
+    public ReadOnlySpan<byte> Data => data;
+
+    public TextureFormat Format { get; }
+
+    internal abstract Vector3<uint> Extent { get; }
+
+    private protected CpuTexture(byte[] data, TextureFormat format) {
+        this.data = data;
+        Format = format;
+    }
+
+}
diff --git a/NoiseEngine/Rendering/CpuTexture2D.cs b/NoiseEngine/Rendering/CpuTexture2D.cs
new file mode 100644
index 00000000..12d5006e
--- /dev/null
+++ b/NoiseEngine/Rendering/CpuTexture2D.cs
@@ -0,0 +1,17 @@
+namespace NoiseEngine.Rendering;
+
+// public class CpuTexture2D : CpuTexture {
+//
+//     private readonly byte[] pixelData;
+//     private readonly TextureDecoderSettings settings;
+//
+//     private CpuTexture2D(byte[] pixelData, TextureDecoderSettings settings) {
+//         this.pixelData = pixelData;
+//         this.settings = settings;
+//     }
+//
+//     public static CpuTexture2D FromPng(byte[] data, PngDecoderSettings? settings = null) {
+//
+//     }
+//
+// }

From c120f993423f814780971aceebd688581f30f7e9 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Mon, 29 May 2023 18:48:36 +0200
Subject: [PATCH 02/19] Remove being human

---
 NoiseEngine.Native/src/rendering/encoding/png.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/NoiseEngine.Native/src/rendering/encoding/png.rs b/NoiseEngine.Native/src/rendering/encoding/png.rs
index d035eec6..c250d1d4 100644
--- a/NoiseEngine.Native/src/rendering/encoding/png.rs
+++ b/NoiseEngine.Native/src/rendering/encoding/png.rs
@@ -54,7 +54,6 @@ pub fn decode(
 
     let mut data = InteropArray::new(info.output_buffer_size() as i32);
 
-    // I think this just works? Probably?
     let frame = info.next_frame(data.as_mut_slice())?;
 
     Ok(CpuTextureData::new(

From 2e825f87ae0029ced8802b06a2598cfd11c58374 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Mon, 29 May 2023 20:18:05 +0200
Subject: [PATCH 03/19] Edit texture data to be able to represent invalid state

---
 NoiseEngine.Native/src/rendering/cpu.rs       | 48 ++++++++-----------
 .../src/rendering/encoding/png.rs             | 24 ++++++----
 .../Rendering/CpuTextureInteropTest.cs        |  2 +-
 NoiseEngine/Rendering/Cpu/CpuTextureData.cs   |  2 +-
 NoiseEngine/Rendering/TextureFormat.cs        | 11 +++++
 5 files changed, 48 insertions(+), 39 deletions(-)

diff --git a/NoiseEngine.Native/src/rendering/cpu.rs b/NoiseEngine.Native/src/rendering/cpu.rs
index a4de83e1..27c38533 100644
--- a/NoiseEngine.Native/src/rendering/cpu.rs
+++ b/NoiseEngine.Native/src/rendering/cpu.rs
@@ -1,34 +1,13 @@
-use crate::interop::prelude::InteropArray;
-
-#[repr(C)]
-pub enum CpuTextureFormat {
-    R8G8B8A8,
-    R8G8B8,
-    R8,
-    R16G16B16A16,
-    R16G16B16,
-    R16,
-}
+use ash::vk;
 
-impl CpuTextureFormat {
-    pub fn pixel_size(&self) -> usize {
-        match self {
-            CpuTextureFormat::R8G8B8A8 => 4,
-            CpuTextureFormat::R8G8B8 => 3,
-            CpuTextureFormat::R8 => 1,
-            CpuTextureFormat::R16G16B16A16 => 8,
-            CpuTextureFormat::R16G16B16 => 6,
-            CpuTextureFormat::R16 => 2,
-        }
-    }
-}
+use crate::interop::prelude::InteropArray;
 
 #[repr(C)]
 pub struct CpuTextureData {
     extent_x: u32,
     extent_y: u32,
     extent_z: u32,
-    format: CpuTextureFormat,
+    format: vk::Format,
     data: InteropArray<u8>,
 }
 
@@ -37,13 +16,14 @@ impl CpuTextureData {
         extent_x: u32,
         extent_y: u32,
         extent_z: u32,
-        format: CpuTextureFormat,
+        format: vk::Format,
         data: InteropArray<u8>,
     ) -> Self {
         assert_ne!(extent_x, 0);
         assert_ne!(extent_y, 0);
         assert_ne!(extent_z, 0);
-        let size = extent_x * extent_y * extent_z * format.pixel_size() as u32;
+        let size =
+            extent_x * extent_y * extent_z * Self::pixel_size(format) as u32;
         assert_eq!(size, data.as_slice().len() as u32);
 
         Self {
@@ -67,11 +47,25 @@ impl CpuTextureData {
         self.extent_z
     }
 
-    pub fn format(&self) -> &CpuTextureFormat {
+    pub fn format(&self) -> &vk::Format {
         &self.format
     }
 
     pub fn data(&self) -> &InteropArray<u8> {
         &self.data
     }
+
+    fn pixel_size(format: vk::Format) -> usize {
+        match format {
+            vk::Format::R8_UINT => 1,
+            vk::Format::R8G8_UINT => 2,
+            vk::Format::R8G8B8_UINT => 3,
+            vk::Format::R8G8B8A8_UINT => 4,
+            vk::Format::R16_UINT => 2,
+            vk::Format::R16G16_UINT => 4,
+            vk::Format::R16G16B16_UINT => 6,
+            vk::Format::R16G16B16A16_UINT => 8,
+            _ => unimplemented!("unsupported format: {:?}", format),
+        }
+    }
 }
diff --git a/NoiseEngine.Native/src/rendering/encoding/png.rs b/NoiseEngine.Native/src/rendering/encoding/png.rs
index c250d1d4..d9f788f7 100644
--- a/NoiseEngine.Native/src/rendering/encoding/png.rs
+++ b/NoiseEngine.Native/src/rendering/encoding/png.rs
@@ -1,9 +1,10 @@
 use crate::{
     interop::interop_array::InteropArray,
-    rendering::cpu::{CpuTextureFormat, CpuTextureData},
+    rendering::cpu::CpuTextureData,
 };
 
-use anyhow::{anyhow, Result};
+use anyhow::Result;
+use ash::vk;
 
 pub fn decode(
     file_data: &[u8],
@@ -29,25 +30,28 @@ pub fn decode(
 
     let format = match (color_type, bit_depth) {
         (png::ColorType::Grayscale, png::BitDepth::Eight) => {
-            CpuTextureFormat::R8
+            vk::Format::R8_UINT
         },
         (png::ColorType::Grayscale, png::BitDepth::Sixteen) => {
-            CpuTextureFormat::R16
+            vk::Format::R16_UINT
         },
-        (png::ColorType::GrayscaleAlpha, _) => {
-            return Err(anyhow!("GrayscaleAlpha is not supported"));
+        (png::ColorType::GrayscaleAlpha, png::BitDepth::Eight) => {
+            vk::Format::R8G8_UINT
+        },
+        (png::ColorType::GrayscaleAlpha, png::BitDepth::Sixteen) => {
+            vk::Format::R16G16_UINT
         },
         (png::ColorType::Rgb, png::BitDepth::Eight) => {
-            CpuTextureFormat::R8G8B8
+            vk::Format::R8G8B8_UINT
         },
         (png::ColorType::Rgb, png::BitDepth::Sixteen) => {
-            CpuTextureFormat::R16G16B16
+            vk::Format::R16G16B16_UINT
         },
         (png::ColorType::Rgba, png::BitDepth::Eight) => {
-            CpuTextureFormat::R8G8B8A8
+            vk::Format::R8G8B8A8_UINT
         },
         (png::ColorType::Rgba, png::BitDepth::Sixteen) => {
-            CpuTextureFormat::R16G16B16A16
+            vk::Format::R16G16B16A16_UINT
         },
         _ => unreachable!("set_transformations should disallow other state"),
     };
diff --git a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
index 63ff6694..0deb2507 100644
--- a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
+++ b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
@@ -31,7 +31,7 @@ public class CpuTextureInteropTest {
         Assert.Equal<uint>(3, data.ExtentX);
         Assert.Equal<uint>(2, data.ExtentY);
         Assert.Equal<uint>(1, data.ExtentZ);
-        Assert.Equal(CpuTextureFormat.R8G8B8, data.Format);
+        Assert.Equal(TextureFormat.R8G8B8_UINT, data.Format);
 
         byte[] expected = GetColorDataRgb(textureColors, new Vector2<uint>(data.ExtentX, data.ExtentY));
 
diff --git a/NoiseEngine/Rendering/Cpu/CpuTextureData.cs b/NoiseEngine/Rendering/Cpu/CpuTextureData.cs
index 1e4547cc..d2875afa 100644
--- a/NoiseEngine/Rendering/Cpu/CpuTextureData.cs
+++ b/NoiseEngine/Rendering/Cpu/CpuTextureData.cs
@@ -9,7 +9,7 @@ internal struct CpuTextureData {
     public uint ExtentX { get; init; }
     public uint ExtentY { get; init; }
     public uint ExtentZ { get; init; }
-    public CpuTextureFormat Format { get; init; }
+    public TextureFormat Format { get; init; }
     public InteropArray<byte> Data { get; init; }
 
 }
diff --git a/NoiseEngine/Rendering/TextureFormat.cs b/NoiseEngine/Rendering/TextureFormat.cs
index 0328e9f3..38814f39 100644
--- a/NoiseEngine/Rendering/TextureFormat.cs
+++ b/NoiseEngine/Rendering/TextureFormat.cs
@@ -1,8 +1,19 @@
 namespace NoiseEngine.Rendering;
 
 public enum TextureFormat : uint {
+
+    R8_UINT = 13,
+    R8G8_UINT = 20,
+    R8G8B8_UINT = 27,
+    R8G8B8A8_UINT = 41,
+
     R8G8B8A8_UNORM = 37,
     R8G8B8A8_SRGB = 43,
 
+    R16_UINT = 74,
+    R16G16_UINT = 81,
+    R16G16B16_UINT = 88,
+    R16G16B16A16_UINT = 95,
+
     D32_SFloat = 126
 }

From 422bae0de62e5b9f36a83ddbea226334e43de1b0 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Mon, 29 May 2023 20:24:41 +0200
Subject: [PATCH 04/19] Test not decoding PNG

---
 .../Interop/Rendering/CpuTextureInteropTest.cs        | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
index 0deb2507..4777608b 100644
--- a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
+++ b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using NoiseEngine.Interop;
@@ -38,6 +39,14 @@ public class CpuTextureInteropTest {
         Assert.Equal(expected, data.Data.ToArray());
     }
 
+    [Fact]
+    public void NotDecodePng() {
+        byte[] fileData = new byte[256];
+        Random.Shared.NextBytes(fileData);
+        InteropResult<CpuTextureData> result = CpuTextureInterop.DecodePng(fileData);
+        Assert.False(result.IsOk);
+    }
+
     private static byte[] GetColorDataRgb(IDictionary<Vector2<uint>, Color32> colors, Vector2<uint> size) {
         byte[] result = new byte[size.X * size.Y * 3];
 

From 102d923d0d15f10e43a10020befc299e168da1c3 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Tue, 30 May 2023 20:41:08 +0200
Subject: [PATCH 05/19] Make png into image

---
 NoiseEngine.Native/Cargo.toml                 |   2 +-
 .../interop/rendering/cpu_texture_interop.rs  |   7 +-
 NoiseEngine.Native/src/rendering/cpu.rs       |  18 +++++
 NoiseEngine.Native/src/rendering/encoding.rs  |  69 +++++++++++++++++
 .../src/rendering/encoding/mod.rs             |   1 -
 .../src/rendering/encoding/png.rs             |  70 ------------------
 .../Rendering/CpuTextureInteropTest.cs        |  46 +++++++++---
 NoiseEngine.Tests/NoiseEngine.Tests.csproj    |   6 ++
 .../Resources/Textures/colors.jpeg            | Bin 0 -> 9479 bytes
 .../Resources/Textures/colors.webp            | Bin 0 -> 56 bytes
 .../Interop/Rendering/CpuTextureInterop.cs    |   4 +-
 NoiseEngine/Rendering/Cpu/CpuTextureFormat.cs |  10 ---
 12 files changed, 134 insertions(+), 99 deletions(-)
 create mode 100644 NoiseEngine.Native/src/rendering/encoding.rs
 delete mode 100644 NoiseEngine.Native/src/rendering/encoding/mod.rs
 delete mode 100644 NoiseEngine.Native/src/rendering/encoding/png.rs
 create mode 100644 NoiseEngine.Tests/Resources/Textures/colors.jpeg
 create mode 100644 NoiseEngine.Tests/Resources/Textures/colors.webp
 delete mode 100644 NoiseEngine/Rendering/Cpu/CpuTextureFormat.cs

diff --git a/NoiseEngine.Native/Cargo.toml b/NoiseEngine.Native/Cargo.toml
index 3d13437e..63ac21a5 100644
--- a/NoiseEngine.Native/Cargo.toml
+++ b/NoiseEngine.Native/Cargo.toml
@@ -19,8 +19,8 @@ arc-cell = "0.3.3"
 const-utf16 = "0.2.1"
 cgmath = "0.18.0"
 crossbeam-queue = "0.3.8"
-png = "0.17.8"
 anyhow = "1.0.71"
+image = "0.24.6"
 
 [dependencies.uuid]
 version = "1.2.2"
diff --git a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
index 8d9cfaae..49bca4db 100644
--- a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
+++ b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
@@ -5,14 +5,15 @@ use crate::{
         ResultError,
         ResultErrorKind,
     },
-    rendering::{cpu::CpuTextureData, encoding}
+    rendering::{cpu::{CpuTextureData, TextureFileFormat}, encoding}
 };
 
 #[no_mangle]
-extern "C" fn rendering_cpu_texture_interop_decode_png(
+extern "C" fn rendering_cpu_texture_interop_decode(
     file_data: InteropReadOnlySpan<u8>,
+    format: TextureFileFormat,
 ) -> InteropResult<CpuTextureData> {
-    let result = encoding::png::decode(file_data.into());
+    let result = encoding::decode(file_data.into(), format);
 
     match result {
         Ok(data) => {
diff --git a/NoiseEngine.Native/src/rendering/cpu.rs b/NoiseEngine.Native/src/rendering/cpu.rs
index 27c38533..5d33fab1 100644
--- a/NoiseEngine.Native/src/rendering/cpu.rs
+++ b/NoiseEngine.Native/src/rendering/cpu.rs
@@ -2,6 +2,24 @@ use ash::vk;
 
 use crate::interop::prelude::InteropArray;
 
+#[repr(C)]
+pub enum TextureFileFormat {
+    Png,
+    Jpeg,
+    Webp,
+}
+
+impl From<TextureFileFormat> for image::ImageFormat {
+    fn from(format: TextureFileFormat) -> Self {
+        match format {
+            TextureFileFormat::Png => image::ImageFormat::Png,
+            TextureFileFormat::Jpeg => image::ImageFormat::Jpeg,
+            TextureFileFormat::Webp => image::ImageFormat::WebP,
+        }
+    }
+}
+
+
 #[repr(C)]
 pub struct CpuTextureData {
     extent_x: u32,
diff --git a/NoiseEngine.Native/src/rendering/encoding.rs b/NoiseEngine.Native/src/rendering/encoding.rs
new file mode 100644
index 00000000..15e37866
--- /dev/null
+++ b/NoiseEngine.Native/src/rendering/encoding.rs
@@ -0,0 +1,69 @@
+use crate::rendering::cpu::{CpuTextureData, TextureFileFormat};
+
+use anyhow::{anyhow, Result};
+use ash::vk;
+
+pub fn decode(
+    file_data: &[u8],
+    format: TextureFileFormat,
+) -> Result<CpuTextureData> {
+    let img = image::load_from_memory_with_format(file_data, format.into())?;
+    let width = img.width();
+    let height = img.height();
+
+    let (data, format) = match img.color() {
+        image::ColorType::L8 => {
+            (img.into_luma8().into_raw(), vk::Format::R8_UINT)
+        },
+        image::ColorType::La8 => {
+            (img.into_luma_alpha8().into_raw(), vk::Format::R8G8_UINT)
+        },
+        image::ColorType::Rgb8 => {
+            (img.into_rgb8().into_raw(), vk::Format::R8G8B8_UINT)
+        },
+        image::ColorType::Rgba8 => {
+            (img.into_rgba8().into_raw(), vk::Format::R8G8B8A8_UINT)
+        },
+        image::ColorType::L16 => {
+            let raw = img.into_luma16().into_raw();
+            (reinterpret_vec(raw), vk::Format::R16_UINT)
+        },
+        image::ColorType::La16 => {
+            let raw = img.into_luma_alpha16().into_raw();
+            (reinterpret_vec(raw), vk::Format::R16G16_UINT)
+        },
+        image::ColorType::Rgb16 => {
+            let raw = img.into_rgb16().into_raw();
+            (reinterpret_vec(raw), vk::Format::R16G16B16_UINT)
+        },
+        image::ColorType::Rgba16 => {
+            let raw = img.into_rgba16().into_raw();
+            (reinterpret_vec(raw), vk::Format::R16G16B16A16_UINT)
+        },
+        image::ColorType::Rgb32F => {
+            let raw = img.into_rgb32f().into_raw();
+            (reinterpret_vec(raw), vk::Format::R32G32B32_SFLOAT)
+        },
+        image::ColorType::Rgba32F => {
+            let raw = img.into_rgba32f().into_raw();
+            (reinterpret_vec(raw), vk::Format::R32G32B32A32_SFLOAT)
+        },
+        _ => return Err(anyhow!("Unknown color type: {:?}", img.color())),
+    };
+
+    Ok(CpuTextureData::new(
+        width,
+        height,
+        1,
+        format,
+        data.into(),
+    ))
+}
+
+fn reinterpret_vec<T>(vec: Vec<T>) -> Vec<u8> {
+    let len = vec.len() * std::mem::size_of::<T>();
+    let cap = vec.capacity() * std::mem::size_of::<T>();
+    let ptr = vec.as_ptr() as *const u8;
+    std::mem::forget(vec);
+    unsafe { Vec::from_raw_parts(ptr as *mut u8, len, cap) }
+}
diff --git a/NoiseEngine.Native/src/rendering/encoding/mod.rs b/NoiseEngine.Native/src/rendering/encoding/mod.rs
deleted file mode 100644
index 6717f3e5..00000000
--- a/NoiseEngine.Native/src/rendering/encoding/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod png;
diff --git a/NoiseEngine.Native/src/rendering/encoding/png.rs b/NoiseEngine.Native/src/rendering/encoding/png.rs
deleted file mode 100644
index d9f788f7..00000000
--- a/NoiseEngine.Native/src/rendering/encoding/png.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use crate::{
-    interop::interop_array::InteropArray,
-    rendering::cpu::CpuTextureData,
-};
-
-use anyhow::Result;
-use ash::vk;
-
-pub fn decode(
-    file_data: &[u8],
-) -> Result<CpuTextureData> {
-    let decoder = png::Decoder::new(file_data);
-
-    let mut info = decoder.read_info()?;
-    let (mut color_type, mut bit_depth) = info.output_color_type();
-
-    match bit_depth {
-        png::BitDepth::Eight | png::BitDepth::Sixteen => {
-        },
-        _ => {
-            let mut decoder = png::Decoder::new(file_data);
-            decoder.set_transformations(
-                png::Transformations::normalize_to_color8()
-            );
-
-            info = decoder.read_info()?;
-            (color_type, bit_depth) = info.output_color_type();
-        },
-    };
-
-    let format = match (color_type, bit_depth) {
-        (png::ColorType::Grayscale, png::BitDepth::Eight) => {
-            vk::Format::R8_UINT
-        },
-        (png::ColorType::Grayscale, png::BitDepth::Sixteen) => {
-            vk::Format::R16_UINT
-        },
-        (png::ColorType::GrayscaleAlpha, png::BitDepth::Eight) => {
-            vk::Format::R8G8_UINT
-        },
-        (png::ColorType::GrayscaleAlpha, png::BitDepth::Sixteen) => {
-            vk::Format::R16G16_UINT
-        },
-        (png::ColorType::Rgb, png::BitDepth::Eight) => {
-            vk::Format::R8G8B8_UINT
-        },
-        (png::ColorType::Rgb, png::BitDepth::Sixteen) => {
-            vk::Format::R16G16B16_UINT
-        },
-        (png::ColorType::Rgba, png::BitDepth::Eight) => {
-            vk::Format::R8G8B8A8_UINT
-        },
-        (png::ColorType::Rgba, png::BitDepth::Sixteen) => {
-            vk::Format::R16G16B16A16_UINT
-        },
-        _ => unreachable!("set_transformations should disallow other state"),
-    };
-
-    let mut data = InteropArray::new(info.output_buffer_size() as i32);
-
-    let frame = info.next_frame(data.as_mut_slice())?;
-
-    Ok(CpuTextureData::new(
-        frame.width,
-        frame.height,
-        1,
-        format,
-        data,
-    ))
-}
diff --git a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
index 4777608b..0a7fd4a2 100644
--- a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
+++ b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
@@ -21,10 +21,13 @@ public class CpuTextureInteropTest {
         { new Vector2<uint>(2, 1), new Color32(255, 0, 255) }
     };
 
-    [Fact]
-    public void DecodePng() {
-        byte[] fileData = File.ReadAllBytes("./Resources/Textures/colors.png");
-        InteropResult<CpuTextureData> result = CpuTextureInterop.DecodePng(fileData);
+    [Theory]
+    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8_UINT)]
+    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8_UINT)]
+    [InlineData(TextureFileFormat.Webp, "colors.webp", TextureFormat.R8G8B8A8_UINT)]
+    public void Decode(TextureFileFormat fileFormat, string path, TextureFormat format) {
+        byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
+        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, fileFormat);
 
         Assert.True(result.IsOk);
         CpuTextureData data = result.Value;
@@ -32,23 +35,38 @@ public class CpuTextureInteropTest {
         Assert.Equal<uint>(3, data.ExtentX);
         Assert.Equal<uint>(2, data.ExtentY);
         Assert.Equal<uint>(1, data.ExtentZ);
-        Assert.Equal(TextureFormat.R8G8B8_UINT, data.Format);
+        Assert.Equal(format, data.Format);
 
-        byte[] expected = GetColorDataRgb(textureColors, new Vector2<uint>(data.ExtentX, data.ExtentY));
+        if (fileFormat == TextureFileFormat.Jpeg) {
+            // Compression moment
+            return;
+        }
 
+        byte[] expected = GetColorData(textureColors, new Vector2<uint>(data.ExtentX, data.ExtentY), format);
         Assert.Equal(expected, data.Data.ToArray());
     }
 
-    [Fact]
-    public void NotDecodePng() {
+    [Theory]
+    [InlineData(TextureFileFormat.Png)]
+    [InlineData(TextureFileFormat.Jpeg)]
+    [InlineData(TextureFileFormat.Webp)]
+    public void NotDecode(TextureFileFormat format) {
         byte[] fileData = new byte[256];
         Random.Shared.NextBytes(fileData);
-        InteropResult<CpuTextureData> result = CpuTextureInterop.DecodePng(fileData);
+        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, format);
         Assert.False(result.IsOk);
     }
 
-    private static byte[] GetColorDataRgb(IDictionary<Vector2<uint>, Color32> colors, Vector2<uint> size) {
-        byte[] result = new byte[size.X * size.Y * 3];
+    private static byte[] GetColorData(
+        IDictionary<Vector2<uint>, Color32> colors,
+        Vector2<uint> size,
+        TextureFormat format
+    ) {
+        if (format != TextureFormat.R8G8B8_UINT && format != TextureFormat.R8G8B8A8_UINT) {
+            throw new ArgumentException("Invalid texture format.");
+        }
+
+        byte[] result = new byte[size.X * size.Y * (format == TextureFormat.R8G8B8_UINT ? 3 : 4)];
 
         int i = 0;
 
@@ -57,7 +75,11 @@ public class CpuTextureInteropTest {
                 result[i + 0] = colors[new Vector2<uint>(x, y)].R;
                 result[i + 1] = colors[new Vector2<uint>(x, y)].G;
                 result[i + 2] = colors[new Vector2<uint>(x, y)].B;
-                i += 3;
+                if (format == TextureFormat.R8G8B8A8_UINT) {
+                    result[i + 3] = colors[new Vector2<uint>(x, y)].A;
+                }
+
+                i += format == TextureFormat.R8G8B8_UINT ? 3 : 4;
             }
         }
 
diff --git a/NoiseEngine.Tests/NoiseEngine.Tests.csproj b/NoiseEngine.Tests/NoiseEngine.Tests.csproj
index 664c2cb7..cdf7b4bc 100644
--- a/NoiseEngine.Tests/NoiseEngine.Tests.csproj
+++ b/NoiseEngine.Tests/NoiseEngine.Tests.csproj
@@ -41,6 +41,12 @@
       <None Update="Resources\Textures\colors.png">
         <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
       </None>
+      <None Update="Resources\Textures\colors.webp">
+        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      </None>
+      <None Update="Resources\Textures\colors.jpeg">
+        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      </None>
     </ItemGroup>
 
     <Import Project="../NoiseEngine.Shared.xml" />
diff --git a/NoiseEngine.Tests/Resources/Textures/colors.jpeg b/NoiseEngine.Tests/Resources/Textures/colors.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..eb59883a0290096aaf312e7539b24c7e4445c838
GIT binary patch
literal 9479
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
L5b}Jz`S||<DNg5?

literal 0
HcmV?d00001

diff --git a/NoiseEngine.Tests/Resources/Textures/colors.webp b/NoiseEngine.Tests/Resources/Textures/colors.webp
new file mode 100644
index 0000000000000000000000000000000000000000..533d95678a506425523fb6b8375d3f5b7843409f
GIT binary patch
literal 56
zcmWIYbaOLcU|<M$bqWXzu<%g^vh|r9fP}$+rY5ET?!p2hKkaY*VK;Jia&T~3_GBin
J(l7bR3;>3T5K#aC

literal 0
HcmV?d00001

diff --git a/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
index 495cfcc5..60fa310c 100644
--- a/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
+++ b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
@@ -5,7 +5,7 @@ namespace NoiseEngine.Interop.Rendering;
 
 internal static partial class CpuTextureInterop {
 
-    [InteropImport("rendering_cpu_texture_interop_decode_png")]
-    public static partial InteropResult<CpuTextureData> DecodePng(ReadOnlySpan<byte> fileData);
+    [InteropImport("rendering_cpu_texture_interop_decode")]
+    public static partial InteropResult<CpuTextureData> Decode(ReadOnlySpan<byte> fileData, TextureFileFormat format);
 
 }
diff --git a/NoiseEngine/Rendering/Cpu/CpuTextureFormat.cs b/NoiseEngine/Rendering/Cpu/CpuTextureFormat.cs
deleted file mode 100644
index 4377e472..00000000
--- a/NoiseEngine/Rendering/Cpu/CpuTextureFormat.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-namespace NoiseEngine.Rendering.Cpu;
-
-public enum CpuTextureFormat {
-    R8G8B8A8,
-    R8G8B8,
-    R8,
-    R16G16B16A16,
-    R16G16B16,
-    R16
-}

From 6dc4c976dcd9726a0b7f541ea8a0455e47daa138 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Wed, 31 May 2023 16:04:56 +0200
Subject: [PATCH 06/19] Add TextureFileFormat

---
 NoiseEngine/Rendering/Cpu/TextureFileFormat.cs | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 NoiseEngine/Rendering/Cpu/TextureFileFormat.cs

diff --git a/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs b/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs
new file mode 100644
index 00000000..eab5bdd1
--- /dev/null
+++ b/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs
@@ -0,0 +1,7 @@
+namespace NoiseEngine.Rendering.Cpu;
+
+public enum TextureFileFormat {
+    Png,
+    Jpeg,
+    Webp,
+}

From 668bff575ba67a01f9adee6fd9d4d1c7c610a4ab Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Wed, 31 May 2023 19:17:36 +0200
Subject: [PATCH 07/19] Add partial CpuTexture2D implementation

---
 NoiseEngine.Native/src/rendering/cpu.rs       |  18 +--
 NoiseEngine.Native/src/rendering/encoding.rs  |  16 +--
 .../Rendering/CpuTextureInteropTest.cs        |  14 +--
 .../Rendering/CpuTexture2DTest.cs             |  98 +++++++++++++++
 NoiseEngine/Rendering/CpuTexture.cs           |  27 ++--
 NoiseEngine/Rendering/CpuTexture2D.cs         | 115 +++++++++++++++---
 NoiseEngine/Rendering/TextureFormat.cs        |  20 +--
 .../Rendering/Utils/TextureFormatUtils.cs     |  32 +++++
 8 files changed, 282 insertions(+), 58 deletions(-)
 create mode 100644 NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
 create mode 100644 NoiseEngine/Rendering/Utils/TextureFormatUtils.cs

diff --git a/NoiseEngine.Native/src/rendering/cpu.rs b/NoiseEngine.Native/src/rendering/cpu.rs
index 5d33fab1..33012387 100644
--- a/NoiseEngine.Native/src/rendering/cpu.rs
+++ b/NoiseEngine.Native/src/rendering/cpu.rs
@@ -75,14 +75,16 @@ impl CpuTextureData {
 
     fn pixel_size(format: vk::Format) -> usize {
         match format {
-            vk::Format::R8_UINT => 1,
-            vk::Format::R8G8_UINT => 2,
-            vk::Format::R8G8B8_UINT => 3,
-            vk::Format::R8G8B8A8_UINT => 4,
-            vk::Format::R16_UINT => 2,
-            vk::Format::R16G16_UINT => 4,
-            vk::Format::R16G16B16_UINT => 6,
-            vk::Format::R16G16B16A16_UINT => 8,
+            vk::Format::R8_SRGB => 1,
+            vk::Format::R8G8_SRGB => 2,
+            vk::Format::R8G8B8_SRGB => 3,
+            vk::Format::R8G8B8A8_SRGB => 4,
+            vk::Format::R16_UNORM => 2,
+            vk::Format::R16G16_UNORM => 4,
+            vk::Format::R16G16B16_UNORM => 6,
+            vk::Format::R16G16B16A16_UNORM => 8,
+            vk::Format::R32G32B32_SFLOAT => 12,
+            vk::Format::R32G32B32A32_SFLOAT => 16,
             _ => unimplemented!("unsupported format: {:?}", format),
         }
     }
diff --git a/NoiseEngine.Native/src/rendering/encoding.rs b/NoiseEngine.Native/src/rendering/encoding.rs
index 15e37866..5d99f28e 100644
--- a/NoiseEngine.Native/src/rendering/encoding.rs
+++ b/NoiseEngine.Native/src/rendering/encoding.rs
@@ -13,32 +13,32 @@ pub fn decode(
 
     let (data, format) = match img.color() {
         image::ColorType::L8 => {
-            (img.into_luma8().into_raw(), vk::Format::R8_UINT)
+            (img.into_luma8().into_raw(), vk::Format::R8_SRGB)
         },
         image::ColorType::La8 => {
-            (img.into_luma_alpha8().into_raw(), vk::Format::R8G8_UINT)
+            (img.into_luma_alpha8().into_raw(), vk::Format::R8G8_SRGB)
         },
         image::ColorType::Rgb8 => {
-            (img.into_rgb8().into_raw(), vk::Format::R8G8B8_UINT)
+            (img.into_rgb8().into_raw(), vk::Format::R8G8B8_SRGB)
         },
         image::ColorType::Rgba8 => {
-            (img.into_rgba8().into_raw(), vk::Format::R8G8B8A8_UINT)
+            (img.into_rgba8().into_raw(), vk::Format::R8G8B8A8_SRGB)
         },
         image::ColorType::L16 => {
             let raw = img.into_luma16().into_raw();
-            (reinterpret_vec(raw), vk::Format::R16_UINT)
+            (reinterpret_vec(raw), vk::Format::R16_UNORM)
         },
         image::ColorType::La16 => {
             let raw = img.into_luma_alpha16().into_raw();
-            (reinterpret_vec(raw), vk::Format::R16G16_UINT)
+            (reinterpret_vec(raw), vk::Format::R16G16_UNORM)
         },
         image::ColorType::Rgb16 => {
             let raw = img.into_rgb16().into_raw();
-            (reinterpret_vec(raw), vk::Format::R16G16B16_UINT)
+            (reinterpret_vec(raw), vk::Format::R16G16B16_UNORM)
         },
         image::ColorType::Rgba16 => {
             let raw = img.into_rgba16().into_raw();
-            (reinterpret_vec(raw), vk::Format::R16G16B16A16_UINT)
+            (reinterpret_vec(raw), vk::Format::R16G16B16A16_UNORM)
         },
         image::ColorType::Rgb32F => {
             let raw = img.into_rgb32f().into_raw();
diff --git a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
index 0a7fd4a2..1ac68fc5 100644
--- a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
+++ b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
@@ -22,9 +22,9 @@ public class CpuTextureInteropTest {
     };
 
     [Theory]
-    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8_UINT)]
-    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8_UINT)]
-    [InlineData(TextureFileFormat.Webp, "colors.webp", TextureFormat.R8G8B8A8_UINT)]
+    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8_SRGB)]
+    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8_SRGB)]
+    [InlineData(TextureFileFormat.Webp, "colors.webp", TextureFormat.R8G8B8A8_SRGB)]
     public void Decode(TextureFileFormat fileFormat, string path, TextureFormat format) {
         byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
         InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, fileFormat);
@@ -62,11 +62,11 @@ public class CpuTextureInteropTest {
         Vector2<uint> size,
         TextureFormat format
     ) {
-        if (format != TextureFormat.R8G8B8_UINT && format != TextureFormat.R8G8B8A8_UINT) {
+        if (format != TextureFormat.R8G8B8_SRGB && format != TextureFormat.R8G8B8A8_SRGB) {
             throw new ArgumentException("Invalid texture format.");
         }
 
-        byte[] result = new byte[size.X * size.Y * (format == TextureFormat.R8G8B8_UINT ? 3 : 4)];
+        byte[] result = new byte[size.X * size.Y * (format == TextureFormat.R8G8B8_SRGB ? 3 : 4)];
 
         int i = 0;
 
@@ -75,11 +75,11 @@ TextureFormat format
                 result[i + 0] = colors[new Vector2<uint>(x, y)].R;
                 result[i + 1] = colors[new Vector2<uint>(x, y)].G;
                 result[i + 2] = colors[new Vector2<uint>(x, y)].B;
-                if (format == TextureFormat.R8G8B8A8_UINT) {
+                if (format == TextureFormat.R8G8B8A8_SRGB) {
                     result[i + 3] = colors[new Vector2<uint>(x, y)].A;
                 }
 
-                i += format == TextureFormat.R8G8B8_UINT ? 3 : 4;
+                i += format == TextureFormat.R8G8B8_SRGB ? 3 : 4;
             }
         }
 
diff --git a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
new file mode 100644
index 00000000..87416d9b
--- /dev/null
+++ b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using NoiseEngine.Mathematics;
+using NoiseEngine.Rendering;
+using NoiseEngine.Rendering.Cpu;
+using NoiseEngine.Tests.Environments;
+using NoiseEngine.Tests.Fixtures;
+
+namespace NoiseEngine.Tests.Rendering; 
+
+[Collection(nameof(ApplicationCollection))]
+public class CpuTexture2DTest : GraphicsTestEnvironment {
+    
+    public CpuTexture2DTest(ApplicationFixture fixture) : base(fixture) {
+    }
+    
+    private readonly Dictionary<Vector2<uint>, Color32> textureColors = new Dictionary<Vector2<uint>, Color32> {
+        { new Vector2<uint>(0, 0), new Color32(255, 0, 0) },
+        { new Vector2<uint>(1, 0), new Color32(0, 255, 0) },
+        { new Vector2<uint>(2, 0), new Color32(0, 0, 0) },
+        { new Vector2<uint>(0, 1), new Color32(0, 0, 255) },
+        { new Vector2<uint>(1, 1), new Color32(255, 255, 0) },
+        { new Vector2<uint>(2, 1), new Color32(255, 0, 255) }
+    };
+
+    [Theory]
+    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8_SRGB)]
+    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8_SRGB)]
+    [InlineData(TextureFileFormat.Webp, "colors.webp", TextureFormat.R8G8B8A8_SRGB)]
+    public void FromFile(TextureFileFormat fileFormat, string path, TextureFormat format) {
+        byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
+        CpuTexture2D texture = CpuTexture2D.FromFile(fileData, fileFormat);
+        
+        Assert.Equal<uint>(3, texture.Width);
+        Assert.Equal<uint>(2, texture.Height);
+        Assert.Equal(format, texture.Format);
+
+        if (fileFormat == TextureFileFormat.Jpeg) {
+            // Compression moment
+            return;
+        }
+
+        byte[] expected = GetColorData(textureColors, new Vector2<uint>(texture.Width, texture.Height), format);
+        Assert.Equal(expected, texture.Data.ToArray());
+    }
+    
+    [Theory]
+    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8_SRGB)]
+    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8_SRGB)]
+    [InlineData(TextureFileFormat.Webp, "colors.webp", TextureFormat.R8G8B8A8_SRGB)]
+    public void ToTexture2D(TextureFileFormat fileFormat, string path, TextureFormat format) {
+        byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
+        CpuTexture2D texture = CpuTexture2D.FromFile(fileData, fileFormat);
+
+        byte[] expected = GetColorData(textureColors, new Vector2<uint>(texture.Width, texture.Height), format);
+        
+        foreach (GraphicsDevice device in GraphicsDevices) {
+            Texture2D texture2D = texture.ToTexture2D(device, TextureUsage.TransferAll);
+            Assert.Equal(format, texture2D.Format);
+            Assert.Equal<uint>(3, texture2D.Width);
+            Assert.Equal<uint>(2, texture2D.Height);
+            byte[] actual = new byte[expected.Length];
+            texture2D.GetPixels(actual.AsSpan());
+            Assert.Equal(expected, actual);
+        }
+    }
+    
+    private static byte[] GetColorData(
+        IDictionary<Vector2<uint>, Color32> colors,
+        Vector2<uint> size,
+        TextureFormat format
+    ) {
+        if (format != TextureFormat.R8G8B8_SRGB && format != TextureFormat.R8G8B8A8_SRGB) {
+            throw new ArgumentException("Invalid texture format.");
+        }
+
+        byte[] result = new byte[size.X * size.Y * (format == TextureFormat.R8G8B8_SRGB ? 3 : 4)];
+
+        int i = 0;
+
+        for (uint y = 0; y < size.Y; y++) {
+            for (uint x = 0; x < size.X; x++) {
+                result[i + 0] = colors[new Vector2<uint>(x, y)].R;
+                result[i + 1] = colors[new Vector2<uint>(x, y)].G;
+                result[i + 2] = colors[new Vector2<uint>(x, y)].B;
+                if (format == TextureFormat.R8G8B8A8_SRGB) {
+                    result[i + 3] = colors[new Vector2<uint>(x, y)].A;
+                }
+
+                i += format == TextureFormat.R8G8B8_SRGB ? 3 : 4;
+            }
+        }
+
+        return result;
+    }
+    
+}
diff --git a/NoiseEngine/Rendering/CpuTexture.cs b/NoiseEngine/Rendering/CpuTexture.cs
index a6604463..6131d1b8 100644
--- a/NoiseEngine/Rendering/CpuTexture.cs
+++ b/NoiseEngine/Rendering/CpuTexture.cs
@@ -1,21 +1,32 @@
 using System;
 using NoiseEngine.Mathematics;
+using NoiseEngine.Rendering.Utils;
 
 namespace NoiseEngine.Rendering;
 
 public abstract class CpuTexture {
 
-    private readonly byte[] data;
-
-    public ReadOnlySpan<byte> Data => data;
-
-    public TextureFormat Format { get; }
-
+    public abstract Span<byte> Data { get; }
     internal abstract Vector3<uint> Extent { get; }
+    
+    public TextureFormat Format { get; private set; }
 
-    private protected CpuTexture(byte[] data, TextureFormat format) {
-        this.data = data;
+    private protected CpuTexture(TextureFormat format) {
         Format = format;
     }
+    
+    /// <summary>
+    /// Allows to change <see cref="CpuTexture"/>'s format without recreating it.
+    /// Only possible if current and new formats have the same texel size.
+    /// </summary>
+    /// <param name="newFormat">New format.</param>
+    /// <exception cref="ArgumentException">Old and new format have different texel sizes.</exception>
+    public void ChangeFormat(TextureFormat newFormat) {
+        if (TextureFormatUtils.TexelSize(Format) != TextureFormatUtils.TexelSize(newFormat)) {
+            throw new ArgumentException("Cannot change texture format to a different texel size.", nameof(newFormat));
+        }
+        
+        Format = newFormat;
+    }
 
 }
diff --git a/NoiseEngine/Rendering/CpuTexture2D.cs b/NoiseEngine/Rendering/CpuTexture2D.cs
index 12d5006e..e2d5781b 100644
--- a/NoiseEngine/Rendering/CpuTexture2D.cs
+++ b/NoiseEngine/Rendering/CpuTexture2D.cs
@@ -1,17 +1,98 @@
-namespace NoiseEngine.Rendering;
-
-// public class CpuTexture2D : CpuTexture {
-//
-//     private readonly byte[] pixelData;
-//     private readonly TextureDecoderSettings settings;
-//
-//     private CpuTexture2D(byte[] pixelData, TextureDecoderSettings settings) {
-//         this.pixelData = pixelData;
-//         this.settings = settings;
-//     }
-//
-//     public static CpuTexture2D FromPng(byte[] data, PngDecoderSettings? settings = null) {
-//
-//     }
-//
-// }
+using System;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using NoiseEngine.Interop;
+using NoiseEngine.Interop.Rendering;
+using NoiseEngine.Mathematics;
+using NoiseEngine.Rendering.Cpu;
+
+namespace NoiseEngine.Rendering;
+
+public class CpuTexture2D : CpuTexture {
+
+    private readonly InteropArray<byte> data;
+
+    public uint Width => Extent.X;
+    public uint Height => Extent.Y;
+    
+    /// <summary>
+    /// Data of the image in row-major order (index = x + Size.X * y).
+    /// </summary>
+    public override Span<byte> Data => data.AsSpan();
+    
+    internal override Vector3<uint> Extent { get; }
+
+    private CpuTexture2D(InteropArray<byte> data, TextureFormat format, Vector2<uint> size) : base(format) {
+        this.data = data;
+        Extent = new Vector3<uint>(size.X, size.Y, 1);
+    }
+
+    /// <summary>
+    /// Tries to decode given <paramref name="fileData"/> to <see cref="CpuTexture2D"/>.
+    /// </summary>
+    /// <param name="fileData">File data.</param>
+    /// <param name="format">File format.</param>
+    /// <param name="texture">Result texture.</param>
+    /// <returns>True if decoding was successful; otherwise false.</returns>
+    public static bool TryFromFile(
+        ReadOnlySpan<byte> fileData,
+        TextureFileFormat format,
+        [NotNullWhen(true)] out CpuTexture2D? texture
+    ) {
+        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, format);
+        
+        if (!result.TryGetValue(out CpuTextureData data, out _)) {
+            texture = null;
+            return false;
+        }
+
+        Debug.Assert(data.ExtentZ == 1);
+        texture = new CpuTexture2D(data.Data, data.Format, new Vector2<uint>(data.ExtentX, data.ExtentY));
+        return true;
+    }
+
+    /// <summary>
+    ///  Decodes given <paramref name="fileData"/> to <see cref="CpuTexture2D"/>.
+    /// </summary>
+    /// <param name="fileData">File data.</param>
+    /// <param name="format">File format.</param>
+    /// <returns>Result texture.</returns>
+    /// <exception cref="ArgumentException">Throws if decoding file data fails.</exception>
+    public static CpuTexture2D FromFile(ReadOnlySpan<byte> fileData, TextureFileFormat format) {
+        if (!TryFromFile(fileData, format, out CpuTexture2D? texture))
+            throw new ArgumentException("Cannot decode texture from given file data.", nameof(fileData));
+        
+        return texture;
+    }
+
+    /// <summary>
+    /// Converts this <see cref="CpuTexture2D"/> to <see cref="Texture2D"/>.
+    /// </summary>
+    /// <param name="device"><see cref="GraphicsDevice"/> to use.</param>
+    /// <param name="usage">
+    /// Texture usage flags. Must contain <see cref="TextureUsage.TransferDestination"/> flag
+    /// to allow for copying CPU data into it.
+    /// </param>
+    /// <param name="mipLevels">Mipmap levels.</param>
+    /// <param name="linear">Use linear memory layout instead of optimal.</param>
+    /// <param name="sampleCount">Samples per texel.</param>
+    /// <returns>Created <see cref="Texture2D"/>.</returns>
+    /// <exception cref="InvalidOperationException">
+    /// <paramref name="usage"/> does not have a <see cref="TextureUsage.TransferDestination"/> flag.
+    /// </exception>
+    public Texture2D ToTexture2D(
+        GraphicsDevice device,
+        TextureUsage usage,
+        uint mipLevels = 1,
+        bool linear = false,
+        uint sampleCount = 1
+    ) {
+        if (!usage.HasFlag(TextureUsage.TransferDestination))
+            throw new InvalidOperationException("Usage does not have a TextureUsage.TransferDestination flag.");
+        
+        Texture2D texture = new Texture2D(device, usage, Extent.X, Extent.Y, Format, mipLevels, linear, sampleCount);
+        texture.SetPixels<byte>(Data);
+        return texture;
+    }
+
+}
diff --git a/NoiseEngine/Rendering/TextureFormat.cs b/NoiseEngine/Rendering/TextureFormat.cs
index 38814f39..9c41c71a 100644
--- a/NoiseEngine/Rendering/TextureFormat.cs
+++ b/NoiseEngine/Rendering/TextureFormat.cs
@@ -2,18 +2,18 @@
 
 public enum TextureFormat : uint {
 
-    R8_UINT = 13,
-    R8G8_UINT = 20,
-    R8G8B8_UINT = 27,
-    R8G8B8A8_UINT = 41,
-
+    R8_UNORM = 9,
+    R8_SRGB = 15,
+    R8G8_UNORM = 16,
+    R8G8_SRGB = 22,
+    R8G8B8_UNORM = 23,
+    R8G8B8_SRGB = 29,
     R8G8B8A8_UNORM = 37,
     R8G8B8A8_SRGB = 43,
-
-    R16_UINT = 74,
-    R16G16_UINT = 81,
-    R16G16B16_UINT = 88,
-    R16G16B16A16_UINT = 95,
+    R16_UNORM = 70,
+    R16G16_UNORM = 77,
+    R16G16B16_UNORM = 84,
+    R16G16B16A16_UNORM = 91,
 
     D32_SFloat = 126
 }
diff --git a/NoiseEngine/Rendering/Utils/TextureFormatUtils.cs b/NoiseEngine/Rendering/Utils/TextureFormatUtils.cs
new file mode 100644
index 00000000..1f479e0b
--- /dev/null
+++ b/NoiseEngine/Rendering/Utils/TextureFormatUtils.cs
@@ -0,0 +1,32 @@
+using System;
+
+namespace NoiseEngine.Rendering.Utils; 
+
+public static class TextureFormatUtils {
+
+    /// <summary>
+    ///   Returns the size of a texel in bytes for the given <paramref name="format"/>.
+    /// </summary>
+    /// <param name="format">Format of the texture.</param>
+    /// <returns>Size of a single texel in bytes.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">Invalid <paramref name="format"/> was provided.</exception>
+    public static int TexelSize(TextureFormat format) {
+        return format switch {
+            TextureFormat.R8_UNORM => 1,
+            TextureFormat.R8_SRGB => 1,
+            TextureFormat.R8G8_UNORM => 2,
+            TextureFormat.R8G8_SRGB => 2,
+            TextureFormat.R8G8B8_UNORM => 3,
+            TextureFormat.R8G8B8_SRGB => 3,
+            TextureFormat.R8G8B8A8_UNORM => 4,
+            TextureFormat.R8G8B8A8_SRGB => 4,
+            TextureFormat.R16_UNORM => sizeof(ushort) * 1,
+            TextureFormat.R16G16_UNORM => sizeof(ushort) * 2,
+            TextureFormat.R16G16B16_UNORM => sizeof(ushort) * 3,
+            TextureFormat.R16G16B16A16_UNORM => sizeof(ushort) * 4,
+            TextureFormat.D32_SFloat => sizeof(float) * 1,
+            _ => throw new ArgumentOutOfRangeException(nameof(format), format, null)
+        };
+    }
+    
+}

From c8fa6acf6ec5de11f10580b9d11c53cda2af88ae Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Thu, 1 Jun 2023 15:13:40 +0200
Subject: [PATCH 08/19] Edit CpuTexture2D to specify format when loading file

---
 .../interop/rendering/cpu_texture_interop.rs  | 11 ++-
 NoiseEngine.Native/src/rendering/cpu.rs       |  2 +-
 NoiseEngine.Native/src/rendering/encoding.rs  | 76 +++++++++++++++++--
 .../Rendering/CpuTextureInteropTest.cs        |  8 +-
 .../Rendering/CpuTexture2DTest.cs             | 30 +++++---
 .../Interop/Rendering/CpuTextureInterop.cs    |  7 +-
 NoiseEngine/Rendering/CpuTexture2D.cs         | 31 +++++---
 7 files changed, 124 insertions(+), 41 deletions(-)

diff --git a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
index 49bca4db..bf697942 100644
--- a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
+++ b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
@@ -1,9 +1,11 @@
+use ash::vk;
+
 use crate::{
     interop::prelude::{
         InteropReadOnlySpan,
         InteropResult,
         ResultError,
-        ResultErrorKind,
+        ResultErrorKind, InteropOption,
     },
     rendering::{cpu::{CpuTextureData, TextureFileFormat}, encoding}
 };
@@ -11,9 +13,12 @@ use crate::{
 #[no_mangle]
 extern "C" fn rendering_cpu_texture_interop_decode(
     file_data: InteropReadOnlySpan<u8>,
-    format: TextureFileFormat,
+    file_format: TextureFileFormat,
+    format: InteropOption<vk::Format>,
+
 ) -> InteropResult<CpuTextureData> {
-    let result = encoding::decode(file_data.into(), format);
+    let result =
+        encoding::decode(file_data.into(), file_format, format.into());
 
     match result {
         Ok(data) => {
diff --git a/NoiseEngine.Native/src/rendering/cpu.rs b/NoiseEngine.Native/src/rendering/cpu.rs
index 33012387..ed189192 100644
--- a/NoiseEngine.Native/src/rendering/cpu.rs
+++ b/NoiseEngine.Native/src/rendering/cpu.rs
@@ -73,7 +73,7 @@ impl CpuTextureData {
         &self.data
     }
 
-    fn pixel_size(format: vk::Format) -> usize {
+    pub fn pixel_size(format: vk::Format) -> usize {
         match format {
             vk::Format::R8_SRGB => 1,
             vk::Format::R8G8_SRGB => 2,
diff --git a/NoiseEngine.Native/src/rendering/encoding.rs b/NoiseEngine.Native/src/rendering/encoding.rs
index 5d99f28e..6de9cc74 100644
--- a/NoiseEngine.Native/src/rendering/encoding.rs
+++ b/NoiseEngine.Native/src/rendering/encoding.rs
@@ -1,13 +1,20 @@
 use crate::rendering::cpu::{CpuTextureData, TextureFileFormat};
 
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 use ash::vk;
 
 pub fn decode(
     file_data: &[u8],
-    format: TextureFileFormat,
+    file_format: TextureFileFormat,
+    format: Option<vk::Format>,
 ) -> Result<CpuTextureData> {
-    let img = image::load_from_memory_with_format(file_data, format.into())?;
+    let img =
+        image::load_from_memory_with_format(file_data, file_format.into())?;
+
+    if let Some(format) = format {
+        return decode_with_format(img, format);
+    }
+
     let width = img.width();
     let height = img.height();
 
@@ -40,15 +47,17 @@ pub fn decode(
             let raw = img.into_rgba16().into_raw();
             (reinterpret_vec(raw), vk::Format::R16G16B16A16_UNORM)
         },
+        // Note that the following formats are not supported by Vulkan
+        // so we downgrade them to the closest supported format
         image::ColorType::Rgb32F => {
-            let raw = img.into_rgb32f().into_raw();
-            (reinterpret_vec(raw), vk::Format::R32G32B32_SFLOAT)
+            let raw = img.into_rgb16().into_raw();
+            (reinterpret_vec(raw), vk::Format::R16G16B16_UNORM)
         },
         image::ColorType::Rgba32F => {
-            let raw = img.into_rgba32f().into_raw();
-            (reinterpret_vec(raw), vk::Format::R32G32B32A32_SFLOAT)
+            let raw = img.into_rgba16().into_raw();
+            (reinterpret_vec(raw), vk::Format::R16G16B16A16_UNORM)
         },
-        _ => return Err(anyhow!("Unknown color type: {:?}", img.color())),
+        _ => anyhow::bail!("Unknown color type: {:?}", img.color()),
     };
 
     Ok(CpuTextureData::new(
@@ -60,6 +69,57 @@ pub fn decode(
     ))
 }
 
+fn decode_with_format(
+    img: image::DynamicImage,
+    format: vk::Format,
+) -> Result<CpuTextureData> {
+    type F = vk::Format;
+
+    let width = img.width();
+    let height = img.height();
+
+    #[rustfmt::skip]
+    let data = match format {
+        F::R8_UNORM | F::R8_SNORM | F::R8_USCALED | F::R8_SSCALED | F::R8_UINT | F::R8_SINT | F::R8_SRGB => {
+            img.into_luma8().into_raw()
+        },
+        F::R8G8_UNORM | F::R8G8_SNORM | F::R8G8_USCALED | F::R8G8_SSCALED | F::R8G8_UINT | F::R8G8_SINT | F::R8G8_SRGB => {
+            img.into_luma_alpha8().into_raw()
+        },
+        F::R8G8B8_UNORM | F::R8G8B8_SNORM | F::R8G8B8_USCALED | F::R8G8B8_SSCALED | F::R8G8B8_UINT | F::R8G8B8_SINT | F::R8G8B8_SRGB => {
+            img.into_rgb8().into_raw()
+        },
+        F::R8G8B8A8_UNORM | F::R8G8B8A8_SNORM | F::R8G8B8A8_USCALED | F::R8G8B8A8_SSCALED | F::R8G8B8A8_UINT | F::R8G8B8A8_SINT | F::R8G8B8A8_SRGB => {
+            img.into_rgba8().into_raw()
+        },
+        F::R16_UNORM | F::R16_SNORM | F::R16_USCALED | F::R16_SSCALED | F::R16_UINT | F::R16_SINT | F::R16_SFLOAT => {
+            let raw = img.into_luma16().into_raw();
+            reinterpret_vec(raw)
+        },
+        F::R16G16_UNORM | F::R16G16_SNORM | F::R16G16_USCALED | F::R16G16_SSCALED | F::R16G16_UINT | F::R16G16_SINT | F::R16G16_SFLOAT => {
+            let raw = img.into_luma_alpha16().into_raw();
+            reinterpret_vec(raw)
+        },
+        F::R16G16B16_UNORM | F::R16G16B16_SNORM | F::R16G16B16_USCALED | F::R16G16B16_SSCALED | F::R16G16B16_UINT | F::R16G16B16_SINT | F::R16G16B16_SFLOAT => {
+            let raw = img.into_rgb16().into_raw();
+            reinterpret_vec(raw)
+        },
+        F::R16G16B16A16_UNORM | F::R16G16B16A16_SNORM | F::R16G16B16A16_USCALED | F::R16G16B16A16_SSCALED | F::R16G16B16A16_UINT | F::R16G16B16A16_SINT | F::R16G16B16A16_SFLOAT => {
+            let raw = img.into_rgba16().into_raw();
+            reinterpret_vec(raw)
+        },
+        _ => anyhow::bail!("Unsupported format: {:?}", format)
+    };
+
+    Ok(CpuTextureData::new(
+        width,
+        height,
+        1,
+        format,
+        data.into()
+    ))
+}
+
 fn reinterpret_vec<T>(vec: Vec<T>) -> Vec<u8> {
     let len = vec.len() * std::mem::size_of::<T>();
     let cap = vec.capacity() * std::mem::size_of::<T>();
diff --git a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
index 1ac68fc5..f0260529 100644
--- a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
+++ b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
@@ -22,12 +22,12 @@ public class CpuTextureInteropTest {
     };
 
     [Theory]
-    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8_SRGB)]
-    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8_SRGB)]
+    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8A8_SRGB)]
+    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8A8_SRGB)]
     [InlineData(TextureFileFormat.Webp, "colors.webp", TextureFormat.R8G8B8A8_SRGB)]
     public void Decode(TextureFileFormat fileFormat, string path, TextureFormat format) {
         byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
-        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, fileFormat);
+        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, fileFormat, format);
 
         Assert.True(result.IsOk);
         CpuTextureData data = result.Value;
@@ -53,7 +53,7 @@ public class CpuTextureInteropTest {
     public void NotDecode(TextureFileFormat format) {
         byte[] fileData = new byte[256];
         Random.Shared.NextBytes(fileData);
-        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, format);
+        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, format, TextureFormat.R8G8B8A8_SRGB);
         Assert.False(result.IsOk);
     }
 
diff --git a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
index 87416d9b..7d36be22 100644
--- a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
+++ b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
@@ -7,14 +7,14 @@
 using NoiseEngine.Tests.Environments;
 using NoiseEngine.Tests.Fixtures;
 
-namespace NoiseEngine.Tests.Rendering; 
+namespace NoiseEngine.Tests.Rendering;
 
 [Collection(nameof(ApplicationCollection))]
 public class CpuTexture2DTest : GraphicsTestEnvironment {
-    
+
     public CpuTexture2DTest(ApplicationFixture fixture) : base(fixture) {
     }
-    
+
     private readonly Dictionary<Vector2<uint>, Color32> textureColors = new Dictionary<Vector2<uint>, Color32> {
         { new Vector2<uint>(0, 0), new Color32(255, 0, 0) },
         { new Vector2<uint>(1, 0), new Color32(0, 255, 0) },
@@ -25,13 +25,13 @@ public class CpuTexture2DTest : GraphicsTestEnvironment {
     };
 
     [Theory]
-    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8_SRGB)]
-    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8_SRGB)]
+    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8A8_SRGB)]
+    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8A8_SRGB)]
     [InlineData(TextureFileFormat.Webp, "colors.webp", TextureFormat.R8G8B8A8_SRGB)]
     public void FromFile(TextureFileFormat fileFormat, string path, TextureFormat format) {
         byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
         CpuTexture2D texture = CpuTexture2D.FromFile(fileData, fileFormat);
-        
+
         Assert.Equal<uint>(3, texture.Width);
         Assert.Equal<uint>(2, texture.Height);
         Assert.Equal(format, texture.Format);
@@ -44,28 +44,34 @@ public class CpuTexture2DTest : GraphicsTestEnvironment {
         byte[] expected = GetColorData(textureColors, new Vector2<uint>(texture.Width, texture.Height), format);
         Assert.Equal(expected, texture.Data.ToArray());
     }
-    
+
     [Theory]
-    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8_SRGB)]
-    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8_SRGB)]
+    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8A8_SRGB)]
+    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8A8_SRGB)]
     [InlineData(TextureFileFormat.Webp, "colors.webp", TextureFormat.R8G8B8A8_SRGB)]
     public void ToTexture2D(TextureFileFormat fileFormat, string path, TextureFormat format) {
         byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
         CpuTexture2D texture = CpuTexture2D.FromFile(fileData, fileFormat);
 
         byte[] expected = GetColorData(textureColors, new Vector2<uint>(texture.Width, texture.Height), format);
-        
+
         foreach (GraphicsDevice device in GraphicsDevices) {
             Texture2D texture2D = texture.ToTexture2D(device, TextureUsage.TransferAll);
             Assert.Equal(format, texture2D.Format);
             Assert.Equal<uint>(3, texture2D.Width);
             Assert.Equal<uint>(2, texture2D.Height);
             byte[] actual = new byte[expected.Length];
+
+            if (fileFormat == TextureFileFormat.Jpeg) {
+                // Compression moment
+                continue;
+            }
+
             texture2D.GetPixels(actual.AsSpan());
             Assert.Equal(expected, actual);
         }
     }
-    
+
     private static byte[] GetColorData(
         IDictionary<Vector2<uint>, Color32> colors,
         Vector2<uint> size,
@@ -94,5 +100,5 @@ TextureFormat format
 
         return result;
     }
-    
+
 }
diff --git a/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
index 60fa310c..3f517da0 100644
--- a/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
+++ b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
@@ -1,4 +1,5 @@
 using System;
+using NoiseEngine.Rendering;
 using NoiseEngine.Rendering.Cpu;
 
 namespace NoiseEngine.Interop.Rendering;
@@ -6,6 +7,10 @@ namespace NoiseEngine.Interop.Rendering;
 internal static partial class CpuTextureInterop {
 
     [InteropImport("rendering_cpu_texture_interop_decode")]
-    public static partial InteropResult<CpuTextureData> Decode(ReadOnlySpan<byte> fileData, TextureFileFormat format);
+    public static partial InteropResult<CpuTextureData> Decode(
+        ReadOnlySpan<byte> fileData,
+        TextureFileFormat fileFormat,
+        InteropOption<TextureFormat> format
+    );
 
 }
diff --git a/NoiseEngine/Rendering/CpuTexture2D.cs b/NoiseEngine/Rendering/CpuTexture2D.cs
index e2d5781b..bff14cb7 100644
--- a/NoiseEngine/Rendering/CpuTexture2D.cs
+++ b/NoiseEngine/Rendering/CpuTexture2D.cs
@@ -14,12 +14,12 @@ public class CpuTexture2D : CpuTexture {
 
     public uint Width => Extent.X;
     public uint Height => Extent.Y;
-    
+
     /// <summary>
     /// Data of the image in row-major order (index = x + Size.X * y).
     /// </summary>
     public override Span<byte> Data => data.AsSpan();
-    
+
     internal override Vector3<uint> Extent { get; }
 
     private CpuTexture2D(InteropArray<byte> data, TextureFormat format, Vector2<uint> size) : base(format) {
@@ -31,16 +31,18 @@ public class CpuTexture2D : CpuTexture {
     /// Tries to decode given <paramref name="fileData"/> to <see cref="CpuTexture2D"/>.
     /// </summary>
     /// <param name="fileData">File data.</param>
-    /// <param name="format">File format.</param>
+    /// <param name="fileFormat">File format.</param>
     /// <param name="texture">Result texture.</param>
+    /// <param name="format">Target format for the texture. Null tries to use the format of the file.</param>
     /// <returns>True if decoding was successful; otherwise false.</returns>
     public static bool TryFromFile(
         ReadOnlySpan<byte> fileData,
-        TextureFileFormat format,
-        [NotNullWhen(true)] out CpuTexture2D? texture
+        TextureFileFormat fileFormat,
+        [NotNullWhen(true)] out CpuTexture2D? texture,
+        TextureFormat? format = null
     ) {
-        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, format);
-        
+        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, fileFormat, format);
+
         if (!result.TryGetValue(out CpuTextureData data, out _)) {
             texture = null;
             return false;
@@ -55,13 +57,18 @@ public class CpuTexture2D : CpuTexture {
     ///  Decodes given <paramref name="fileData"/> to <see cref="CpuTexture2D"/>.
     /// </summary>
     /// <param name="fileData">File data.</param>
-    /// <param name="format">File format.</param>
+    /// <param name="fileFormat">File format.</param>
+    /// <param name="format">Target format for the texture. Null tries to use the format of the file.</param>
     /// <returns>Result texture.</returns>
     /// <exception cref="ArgumentException">Throws if decoding file data fails.</exception>
-    public static CpuTexture2D FromFile(ReadOnlySpan<byte> fileData, TextureFileFormat format) {
-        if (!TryFromFile(fileData, format, out CpuTexture2D? texture))
+    public static CpuTexture2D FromFile(
+        ReadOnlySpan<byte> fileData,
+        TextureFileFormat fileFormat,
+        TextureFormat? format = null
+    ) {
+        if (!TryFromFile(fileData, fileFormat, out CpuTexture2D? texture, format))
             throw new ArgumentException("Cannot decode texture from given file data.", nameof(fileData));
-        
+
         return texture;
     }
 
@@ -89,7 +96,7 @@ public class CpuTexture2D : CpuTexture {
     ) {
         if (!usage.HasFlag(TextureUsage.TransferDestination))
             throw new InvalidOperationException("Usage does not have a TextureUsage.TransferDestination flag.");
-        
+
         Texture2D texture = new Texture2D(device, usage, Extent.X, Extent.Y, Format, mipLevels, linear, sampleCount);
         texture.SetPixels<byte>(Data);
         return texture;

From 89b072ccece29e200201e71dc07f8da351fc02cf Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Thu, 1 Jun 2023 19:51:30 +0200
Subject: [PATCH 09/19] Remove specifying file format when loading file

---
 .../interop/rendering/cpu_texture_interop.rs  |   5 +-
 NoiseEngine.Native/src/rendering/cpu.rs       |  18 ----
 NoiseEngine.Native/src/rendering/encoding.rs  |   5 +-
 .../Rendering/CpuTextureInteropTest.cs        |  79 +++++++-------
 .../Rendering/CpuTexture2DTest.cs             |  99 ++++++++----------
 .../Rendering/TextureTestUtils.cs             |  74 +++++++++++++
 .../Resources/Textures/colors.jpeg            | Bin 9479 -> 10383 bytes
 .../Interop/Rendering/CpuTextureInterop.cs    |   1 -
 .../Rendering/Cpu/TextureFileFormat.cs        |   7 --
 NoiseEngine/Rendering/CpuTexture2D.cs         |  12 +--
 10 files changed, 163 insertions(+), 137 deletions(-)
 create mode 100644 NoiseEngine.Tests/Rendering/TextureTestUtils.cs
 delete mode 100644 NoiseEngine/Rendering/Cpu/TextureFileFormat.cs

diff --git a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
index bf697942..70712cef 100644
--- a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
+++ b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
@@ -7,18 +7,17 @@ use crate::{
         ResultError,
         ResultErrorKind, InteropOption,
     },
-    rendering::{cpu::{CpuTextureData, TextureFileFormat}, encoding}
+    rendering::{cpu::CpuTextureData, encoding}
 };
 
 #[no_mangle]
 extern "C" fn rendering_cpu_texture_interop_decode(
     file_data: InteropReadOnlySpan<u8>,
-    file_format: TextureFileFormat,
     format: InteropOption<vk::Format>,
 
 ) -> InteropResult<CpuTextureData> {
     let result =
-        encoding::decode(file_data.into(), file_format, format.into());
+        encoding::decode(file_data.into(), format.into());
 
     match result {
         Ok(data) => {
diff --git a/NoiseEngine.Native/src/rendering/cpu.rs b/NoiseEngine.Native/src/rendering/cpu.rs
index ed189192..6de6f2d0 100644
--- a/NoiseEngine.Native/src/rendering/cpu.rs
+++ b/NoiseEngine.Native/src/rendering/cpu.rs
@@ -2,24 +2,6 @@ use ash::vk;
 
 use crate::interop::prelude::InteropArray;
 
-#[repr(C)]
-pub enum TextureFileFormat {
-    Png,
-    Jpeg,
-    Webp,
-}
-
-impl From<TextureFileFormat> for image::ImageFormat {
-    fn from(format: TextureFileFormat) -> Self {
-        match format {
-            TextureFileFormat::Png => image::ImageFormat::Png,
-            TextureFileFormat::Jpeg => image::ImageFormat::Jpeg,
-            TextureFileFormat::Webp => image::ImageFormat::WebP,
-        }
-    }
-}
-
-
 #[repr(C)]
 pub struct CpuTextureData {
     extent_x: u32,
diff --git a/NoiseEngine.Native/src/rendering/encoding.rs b/NoiseEngine.Native/src/rendering/encoding.rs
index 6de9cc74..78c05c48 100644
--- a/NoiseEngine.Native/src/rendering/encoding.rs
+++ b/NoiseEngine.Native/src/rendering/encoding.rs
@@ -1,15 +1,14 @@
-use crate::rendering::cpu::{CpuTextureData, TextureFileFormat};
+use crate::rendering::cpu::CpuTextureData;
 
 use anyhow::Result;
 use ash::vk;
 
 pub fn decode(
     file_data: &[u8],
-    file_format: TextureFileFormat,
     format: Option<vk::Format>,
 ) -> Result<CpuTextureData> {
     let img =
-        image::load_from_memory_with_format(file_data, file_format.into())?;
+        image::load_from_memory(file_data)?;
 
     if let Some(format) = format {
         return decode_with_format(img, format);
diff --git a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
index f0260529..1fd70e1d 100644
--- a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
+++ b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
@@ -7,6 +7,7 @@
 using NoiseEngine.Mathematics;
 using NoiseEngine.Rendering;
 using NoiseEngine.Rendering.Cpu;
+using NoiseEngine.Tests.Rendering;
 
 namespace NoiseEngine.Tests.Interop.Rendering;
 
@@ -22,12 +23,12 @@ public class CpuTextureInteropTest {
     };
 
     [Theory]
-    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8A8_SRGB)]
-    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8A8_SRGB)]
-    [InlineData(TextureFileFormat.Webp, "colors.webp", TextureFormat.R8G8B8A8_SRGB)]
-    public void Decode(TextureFileFormat fileFormat, string path, TextureFormat format) {
+    [InlineData("colors.png", TextureFormat.R8G8B8A8_SRGB)]
+    [InlineData("colors.webp", TextureFormat.R8G8B8A8_SRGB)]
+    [InlineData("colors.jpeg", TextureFormat.R8G8B8A8_SRGB)]
+    public void Decode(string path, TextureFormat format) {
         byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
-        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, fileFormat, format);
+        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, format);
 
         Assert.True(result.IsOk);
         CpuTextureData data = result.Value;
@@ -37,53 +38,43 @@ public class CpuTextureInteropTest {
         Assert.Equal<uint>(1, data.ExtentZ);
         Assert.Equal(format, data.Format);
 
-        if (fileFormat == TextureFileFormat.Jpeg) {
-            // Compression moment
+        byte[] expected = TextureTestUtils.GetColorData(
+            textureColors,
+            new Vector2<uint>(data.ExtentX, data.ExtentY),
+            format);
+
+        if (!path.EndsWith(".jpg") && !path.EndsWith(".jpeg")) {
+            Assert.Equal(expected, data.Data.ToArray());
             return;
         }
 
-        byte[] expected = GetColorData(textureColors, new Vector2<uint>(data.ExtentX, data.ExtentY), format);
-        Assert.Equal(expected, data.Data.ToArray());
+        for (int y = 0; y < data.ExtentY; y++) {
+            for (int x = 0; x < data.ExtentX; x++) {
+                Color32 expectedColor = textureColors[new Vector2<uint>((uint)x, (uint)y)];
+                Color32 actualColor = new Color32(
+                    data.Data[(y * (int)data.ExtentX + x) * 4 + 0],
+                    data.Data[(y * (int)data.ExtentX + x) * 4 + 1],
+                    data.Data[(y * (int)data.ExtentX + x) * 4 + 2],
+                    data.Data[(y * (int)data.ExtentX + x) * 4 + 3]
+                );
+
+                int difference =
+                    Math.Abs(expectedColor.R - actualColor.R) +
+                    Math.Abs(expectedColor.G - actualColor.G) +
+                    Math.Abs(expectedColor.B - actualColor.B) +
+                    Math.Abs(expectedColor.A - actualColor.A);
+
+                Assert.True(difference < 10);
+            }
+        }
     }
 
-    [Theory]
-    [InlineData(TextureFileFormat.Png)]
-    [InlineData(TextureFileFormat.Jpeg)]
-    [InlineData(TextureFileFormat.Webp)]
-    public void NotDecode(TextureFileFormat format) {
+    [Fact]
+    public void NotDecode() {
         byte[] fileData = new byte[256];
         Random.Shared.NextBytes(fileData);
-        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, format, TextureFormat.R8G8B8A8_SRGB);
+        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, TextureFormat.R8G8B8A8_SRGB);
         Assert.False(result.IsOk);
     }
 
-    private static byte[] GetColorData(
-        IDictionary<Vector2<uint>, Color32> colors,
-        Vector2<uint> size,
-        TextureFormat format
-    ) {
-        if (format != TextureFormat.R8G8B8_SRGB && format != TextureFormat.R8G8B8A8_SRGB) {
-            throw new ArgumentException("Invalid texture format.");
-        }
-
-        byte[] result = new byte[size.X * size.Y * (format == TextureFormat.R8G8B8_SRGB ? 3 : 4)];
-
-        int i = 0;
-
-        for (uint y = 0; y < size.Y; y++) {
-            for (uint x = 0; x < size.X; x++) {
-                result[i + 0] = colors[new Vector2<uint>(x, y)].R;
-                result[i + 1] = colors[new Vector2<uint>(x, y)].G;
-                result[i + 2] = colors[new Vector2<uint>(x, y)].B;
-                if (format == TextureFormat.R8G8B8A8_SRGB) {
-                    result[i + 3] = colors[new Vector2<uint>(x, y)].A;
-                }
-
-                i += format == TextureFormat.R8G8B8_SRGB ? 3 : 4;
-            }
-        }
-
-        return result;
-    }
-
 }
diff --git a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
index 7d36be22..817c7ed2 100644
--- a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
+++ b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
@@ -3,7 +3,6 @@
 using System.IO;
 using NoiseEngine.Mathematics;
 using NoiseEngine.Rendering;
-using NoiseEngine.Rendering.Cpu;
 using NoiseEngine.Tests.Environments;
 using NoiseEngine.Tests.Fixtures;
 
@@ -12,9 +11,6 @@ namespace NoiseEngine.Tests.Rendering;
 [Collection(nameof(ApplicationCollection))]
 public class CpuTexture2DTest : GraphicsTestEnvironment {
 
-    public CpuTexture2DTest(ApplicationFixture fixture) : base(fixture) {
-    }
-
     private readonly Dictionary<Vector2<uint>, Color32> textureColors = new Dictionary<Vector2<uint>, Color32> {
         { new Vector2<uint>(0, 0), new Color32(255, 0, 0) },
         { new Vector2<uint>(1, 0), new Color32(0, 255, 0) },
@@ -24,36 +20,54 @@ public class CpuTexture2DTest : GraphicsTestEnvironment {
         { new Vector2<uint>(2, 1), new Color32(255, 0, 255) }
     };
 
+    public CpuTexture2DTest(ApplicationFixture fixture) : base(fixture) {
+    }
+
     [Theory]
-    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8A8_SRGB)]
-    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8A8_SRGB)]
-    [InlineData(TextureFileFormat.Webp, "colors.webp", TextureFormat.R8G8B8A8_SRGB)]
-    public void FromFile(TextureFileFormat fileFormat, string path, TextureFormat format) {
+    [InlineData("colors.png", TextureFormat.R8G8B8A8_SRGB)]
+    [InlineData("colors.webp", TextureFormat.R8G8B8A8_SRGB)]
+    [InlineData("colors.jpeg", TextureFormat.R8G8B8A8_SRGB)]
+    public void FromFile(string path, TextureFormat format) {
         byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
-        CpuTexture2D texture = CpuTexture2D.FromFile(fileData, fileFormat);
+        CpuTexture2D texture = CpuTexture2D.FromFile(fileData, format);
 
         Assert.Equal<uint>(3, texture.Width);
         Assert.Equal<uint>(2, texture.Height);
         Assert.Equal(format, texture.Format);
 
-        if (fileFormat == TextureFileFormat.Jpeg) {
-            // Compression moment
-            return;
+        byte[] expected = TextureTestUtils.GetColorData(
+            textureColors,
+            new Vector2<uint>(texture.Width, texture.Height),
+            format);
+
+        if (path.EndsWith(".jpg") || path.EndsWith(".jpeg")) {
+            Assert.True(
+                TextureTestUtils.CompareLossy(
+                    texture.Data,
+                    new Vector2<uint>(texture.Width, texture.Height),
+                    textureColors,
+                    format
+                )
+            );
+        } else {
+            Assert.Equal(expected, texture.Data.ToArray());
         }
 
-        byte[] expected = GetColorData(textureColors, new Vector2<uint>(texture.Width, texture.Height), format);
-        Assert.Equal(expected, texture.Data.ToArray());
+
     }
 
     [Theory]
-    [InlineData(TextureFileFormat.Png, "colors.png", TextureFormat.R8G8B8A8_SRGB)]
-    [InlineData(TextureFileFormat.Jpeg, "colors.jpeg", TextureFormat.R8G8B8A8_SRGB)]
-    [InlineData(TextureFileFormat.Webp, "colors.webp", TextureFormat.R8G8B8A8_SRGB)]
-    public void ToTexture2D(TextureFileFormat fileFormat, string path, TextureFormat format) {
+    [InlineData("colors.png", TextureFormat.R8G8B8A8_SRGB)]
+    [InlineData("colors.webp", TextureFormat.R8G8B8A8_SRGB)]
+    [InlineData("colors.jpeg", TextureFormat.R8G8B8A8_SRGB)]
+    public void ToTexture2D(string path, TextureFormat format) {
         byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
-        CpuTexture2D texture = CpuTexture2D.FromFile(fileData, fileFormat);
+        CpuTexture2D texture = CpuTexture2D.FromFile(fileData, format);
 
-        byte[] expected = GetColorData(textureColors, new Vector2<uint>(texture.Width, texture.Height), format);
+        byte[] expected = TextureTestUtils.GetColorData(
+            textureColors,
+            new Vector2<uint>(texture.Width, texture.Height),
+            format);
 
         foreach (GraphicsDevice device in GraphicsDevices) {
             Texture2D texture2D = texture.ToTexture2D(device, TextureUsage.TransferAll);
@@ -61,44 +75,21 @@ public class CpuTexture2DTest : GraphicsTestEnvironment {
             Assert.Equal<uint>(3, texture2D.Width);
             Assert.Equal<uint>(2, texture2D.Height);
             byte[] actual = new byte[expected.Length];
-
-            if (fileFormat == TextureFileFormat.Jpeg) {
-                // Compression moment
-                continue;
-            }
-
             texture2D.GetPixels(actual.AsSpan());
-            Assert.Equal(expected, actual);
-        }
-    }
-
-    private static byte[] GetColorData(
-        IDictionary<Vector2<uint>, Color32> colors,
-        Vector2<uint> size,
-        TextureFormat format
-    ) {
-        if (format != TextureFormat.R8G8B8_SRGB && format != TextureFormat.R8G8B8A8_SRGB) {
-            throw new ArgumentException("Invalid texture format.");
-        }
 
-        byte[] result = new byte[size.X * size.Y * (format == TextureFormat.R8G8B8_SRGB ? 3 : 4)];
-
-        int i = 0;
-
-        for (uint y = 0; y < size.Y; y++) {
-            for (uint x = 0; x < size.X; x++) {
-                result[i + 0] = colors[new Vector2<uint>(x, y)].R;
-                result[i + 1] = colors[new Vector2<uint>(x, y)].G;
-                result[i + 2] = colors[new Vector2<uint>(x, y)].B;
-                if (format == TextureFormat.R8G8B8A8_SRGB) {
-                    result[i + 3] = colors[new Vector2<uint>(x, y)].A;
-                }
-
-                i += format == TextureFormat.R8G8B8_SRGB ? 3 : 4;
+            if (path.EndsWith(".jpg") || path.EndsWith(".jpeg")) {
+                Assert.True(
+                    TextureTestUtils.CompareLossy(
+                        actual,
+                        new Vector2<uint>(texture.Width, texture.Height),
+                        textureColors,
+                        format
+                    )
+                );
+            } else {
+                Assert.Equal(expected, actual);
             }
         }
-
-        return result;
     }
 
 }
diff --git a/NoiseEngine.Tests/Rendering/TextureTestUtils.cs b/NoiseEngine.Tests/Rendering/TextureTestUtils.cs
new file mode 100644
index 00000000..c15820b5
--- /dev/null
+++ b/NoiseEngine.Tests/Rendering/TextureTestUtils.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using NoiseEngine.Mathematics;
+using NoiseEngine.Rendering;
+
+namespace NoiseEngine.Tests.Rendering;
+
+internal static class TextureTestUtils {
+
+    public static byte[] GetColorData(
+        IDictionary<Vector2<uint>, Color32> colors,
+        Vector2<uint> size,
+        TextureFormat format
+    ) {
+        if (format != TextureFormat.R8G8B8_SRGB && format != TextureFormat.R8G8B8A8_SRGB) {
+            throw new ArgumentException("Invalid texture format.");
+        }
+
+        byte[] result = new byte[size.X * size.Y * (format == TextureFormat.R8G8B8_SRGB ? 3 : 4)];
+
+        int i = 0;
+
+        for (uint y = 0; y < size.Y; y++) {
+            for (uint x = 0; x < size.X; x++) {
+                result[i + 0] = colors[new Vector2<uint>(x, y)].R;
+                result[i + 1] = colors[new Vector2<uint>(x, y)].G;
+                result[i + 2] = colors[new Vector2<uint>(x, y)].B;
+                if (format == TextureFormat.R8G8B8A8_SRGB) {
+                    result[i + 3] = colors[new Vector2<uint>(x, y)].A;
+                }
+
+                i += format == TextureFormat.R8G8B8_SRGB ? 3 : 4;
+            }
+        }
+
+        return result;
+    }
+
+    public static bool CompareLossy(
+        ReadOnlySpan<byte> data,
+        Vector2<uint> size,
+        IDictionary<Vector2<uint>, Color32> expectedColors,
+        TextureFormat format,
+        int maxDifference = 10
+    ) {
+        if (format != TextureFormat.R8G8B8A8_SRGB)
+            throw new ArgumentException("Unsupported texture format.");
+
+        for (int y = 0; y < size.Y; y++) {
+            for (int x = 0; x < size.X; x++) {
+                Color32 expectedColor = expectedColors[new Vector2<uint>((uint)x, (uint)y)];
+                Color32 actualColor = new Color32(
+                    data[(y * (int)size.X + x) * 4 + 0],
+                    data[(y * (int)size.X + x) * 4 + 1],
+                    data[(y * (int)size.X + x) * 4 + 2],
+                    data[(y * (int)size.X + x) * 4 + 3]
+                );
+
+                int difference =
+                    Math.Abs(expectedColor.R - actualColor.R) +
+                    Math.Abs(expectedColor.G - actualColor.G) +
+                    Math.Abs(expectedColor.B - actualColor.B) +
+                    Math.Abs(expectedColor.A - actualColor.A);
+
+                if (difference > maxDifference)
+                    return false;
+            }
+
+        }
+
+        return true;
+    }
+
+}
diff --git a/NoiseEngine.Tests/Resources/Textures/colors.jpeg b/NoiseEngine.Tests/Resources/Textures/colors.jpeg
index eb59883a0290096aaf312e7539b24c7e4445c838..548ea8616dd080dcfeb83449c13ae6abbe562d2e 100644
GIT binary patch
literal 10383
zcmeG?X;@Q7*K=?75SBpLTtnE=kOdM#6j{QmAP5L*Z8ghHh-5Rl0kpPmXx-jg_qDa6
zb?vLIR$RKMs8y@4)_rUHg4Vj!R;+cm=9_y%0$95|{hsgF=kVN_Gv}N+bLPyM$;=sC
z=Upv8kW**W15i{15&!^9fFOZ@0wDzck;(Owk6%fZ6}LL7tTuj9q8KQ$3W})FBr(9v
z)1H$wC0V}>bAs-c<72ZMEqJjLw>fc$q!BD74!lfbwVFtd0t=2|7N?mY5HL}yOm?E~
zPqr;H))5?8Mx1Cvklivd`#`lBE6*8H4pHvT+zm?XR;#`Y!=1Kb%_uD-a=~EW060*C
zT3`eiu#h<)*nl0}1sX7h5DM5fZ#!5c1!kFWOPg*SjnintjTTZkq_aqFRngD^ZoBj$
zM4&>LwU0fp!`O>$xY25HKzb;_sj}e~&v4*yHFj^M)Zi%cR#bM2s=Z>t+be|{lfz3H
zXuxZ{l^nAv+gpJaZ5N%Ttv0lo#BDE7nwO=5+7J^DN_Bj`&g#@;SeuC|neyzG-{G=M
zzvs)c>&gdP@Z88!6EVx)lx5QKUxY7pm~awbQfJC|&CAZN!L+#5o~_2!#0W?wOAI9r
zkADy_!3;}6ZBU5m-C~~Wwj6rwi@Gh-n%wvjyEbDeA%RQ*TD#R&S%tyLg}!RE7(C|l
zBM7BXrz|UuTg@h`#n9G-<Dn2Lbin(1@TEpWRY!u4hX8f+@)N6u@{?N!PzOr{pq`Rk
zQ86UVudP#9q)z~DfAb}ARG9Z5Im0{GDR;>_i_Bq$kga0f>z3WNT%f~}8r&nf@_|UN
zhZGac=_Cee!>nAg)Qgdl!iK@z!y_Xxgy*+mNSO~|9l#X^TrW(N>je3QB-j6jM%sc&
z$o8y5Gy@J3er<N^K|p}8o7;|E2#AsiGq?6c6*hn$u_)+33#`BdKRet(JlhNeI;6Ix
zL}G|GMB7fOBZG&~zDWR!(?slQL^Ha^>a^$_&#h4{E`c;sWx}z&-UE@(c^}AX_fk@g
z(sm~#hvP6AwV0#AR7eh{Q$IA424x1qk3m)nvODy}Fxah5TPGCVYBw5;-W@WhjF4VT
z;-Cy)wG+4IVHV7;#xWg4fbuam&sNWNGZPqsQeZalVex-Geu~p>>hyy_8ox89$YJRG
zqe54k@N%`G6PKSBGnvY<I=sM<UtUz`*{qlzbSGw3mDN5r(_}PwEamSWe7*+_N6ye;
zdbN|>JXtlE9e)9Pg$Lc4-A7|kSxr`Z2jg<x^0V^11lR-&v|0#Tvv8{o{v127j=K}v
z1h=u@VL2Ld+xs2f2TpO-^X%lxiz7M$9QdK>tt9MTWjqolTo@tw2o8WI5p@D+D~WXr
zKQt7C0mOCQ^%LM^>Z}@UgsKSEe+GVJ4d^Bi{H{x&9&ngUCX2~ou{c~GwhuShpTqGF
z4hsqj4hjn6a>&$HxGT@+h_8>2ub*##pI-pa&(DuXWPUt%6Yk#;;MxPY@bCms3L*d~
z7ol(w*SB!3BCh>NI@FSekO?YGBnm)KDvi!yve-WGpw*d32=NdD076A5C>5nK=u8@g
zlLU!e3N<27LdzVa4ib!>D5dk}to%4DGAg)quO=zkKIw#t5k0r8wdIc1Aq#2PGC3xD
zUb!x(X%#LHJvsO?_RH4#eW#pP?&ikMUp?iM1^Z8b|LX_a4xG7quR>olb>W)EFVFsP
zKP9iyQ2W-Rwc8J#yY_$!P!wuQC3RxZX);oU2uUCnYA{+5M3YXO!y`1<TY923DN55~
zpEOrh7OZt7--)IZ3NT`1O(&ret3q`-gXK7O*{i}IYY^M6g6ksSP{=;HARW9v_wM`!
z6-Qhb-2N0nnzIt-2;o5fAQR}|Car;oJ3c4@RS?GE=O7{YBLsMV!NCVoAch~Y)4G2v
zsqWtc2H}xJFRm89fmJweQ;I|uN1~eW%S5f!EUHu6M3O|Y2=q;_v#GV!7|z#Va92zd
z-2Qa8fN#{L2`Xhp;v$<0t1{+~wPR&t2bOEcR%=srg7kj;zIDnvv(1d*YJQ#BWN|3#
z(gdV%C4>pINWdpq@ai-H>Hqv8MJ0Td)sFGyiDIEvESB<9QWGWe<Ya}SH(x52ibdiS
zkwh$%N|j={QkKMTO9I%NU8h%;X6Lr`1#4-7wn5d_)+W{_C0gwUkt8)WRV0>*q*5W|
z5IV+KaCM!~;)wJ}$i^I6yOBK6@(GFXwC2Rq1W;4=5X?5O*caN$!>H4G`D}1&COg+@
zMVJXQV;0;2?J6OLPYShp?jqhMokV-d<YagnLDLo$y|{sA-ppoi7Y;n91`gxTX4ye(
zv!YVWVRhQISWXR8Gm_}crc~K6H9WhPTdgL~M73X^q|!t&Kd#bf(OGL9@f{jq@T`la
z3E-?H3B_`uSW+&LDU(x_$<kh8IDKL_YmrrF)Q@=~YpPNr@5BmSMhDN&f61)VD)m;o
zSq%qlG^-7mXp{{z2>4z*D#;%Y*fUfwsUyBXrGl3rz0m{-4tRm!7v!kql2o}|C{2`*
z`W6)_3oH&?ZP8){*=Yi3okXKir_`$zGMP+~B9vk&m{6`s)(aKMDM><wM4v2?$h105
zlDB=fRqG^tfN1Yt4mztA%4k<lBbVwV^3+seN>WmaFh!A^EL6)hQem<t2}@1I#B#k>
z=F!G|CQ+L@N+q<?L5Wf<Rg)rD=!IgnELAAhLaj71okA$lr>HTBMlBPk$OykDT}hd5
zbihd-)3%bzu+eRh$;c<YN2%5l_q;TLmT(75Cul<(Uto{F)pJ|>T6jD8Q#Wz<?y&0d
zTD2X^G(g+^r5lR=P<g9`IE1vTZ&TahT^q;jjx>SZZZ-4WE@QJ8__(#LLi*1iigc)J
z+Qq%d8h_6_+{1jKH9D?@e`1X`OKYpt76S%%ZIOT&jELCZ-197Y-UUcnhrQ6l4mVf=
z^zQ8aJUj5q@}&h{THvJxURvO#1zuX<|B(gS?}nHK9xZC&&Chk2GXx%`N0gKn=N1&^
zkQZ4_excD~MPYEz4CD61*?P#(VSL6h7$IT7SR}lhs<jSVQCTkW<N@Hhn@=3T3Aio6
z%kcfPWK0E|66Tli`5waGEV){n9R~1`63CyVgSR{g*F)G;i`xi15!2ymstFh+qB%S}
zR1m^p1Z;4_y-6N7oI$`kvjv9#P(o*$&a5Ng{Scm3<0Qg@ltKtktubP?5IzmzD3jA{
zgfJ07=9w`y3{_Hzcu^FNX{#VChA_uoUaEp{Ul=gr7&^e34loYmbC4IPthO;^#EKuM
zjpxJ5t%9GA)tWFI7nZ;ayV|aU*J-m&ZGrDV?lBXsK;Z8#HzeAf{VA~n-=BfR+`8#^
z2a$7zgdA<hwYO}?SsP%~8b<3W@3iAIO90qD1%R-N?YOA-VN9eRfX3q;#uGyLONYz8
z5z{6T2KA=DWbktSG0>sEM4~_M#gL!v4sh}buhznVrPI!Lz<3G97e4RA|F~fXwL0k0
zyA;!7b_`xd`4!O1;PVcgZi~)H+|&3*OQ-8=2MPbMSqBLO==N&}1g(Ascq0-)z;Pa+
z{B#shgM0vG_<N9oc;~H<RRM!n095w8=JtCCLpqsv%Fx-ciaLyB&>W~r%lTTTy~fQ#
zB?=l~!=M-sgo7R+62t)^3~i-=J|F|+fc~Hul!Kw*HTbqs1<deeqZW(<6Twt46TAZ!
zfTdssSPj;LO<)Vy4n6~W!I$6&_!^u6mq0VP3VsBw;68W)<C+Y_7YRbbk)B92(hHFy
z3Zx&BgA^jA$WUY?Vn8g26B&n0MrI;&k)_B=WIggRvJ=^h97awc7mya@2J#E?7^R>b
zl!talV^9&QKr_(+XgT^SYCuP$W6^r_ZFDi(fPRQJqI=OJ=oz#b{Sm!K0Tdrf2ql6d
zq$nsVN-<>^MNhF)-lWW+ETlA0Hc@s_4pL50nkly^kEnEN5S33AQu|Qzse`Fn>S*el
z)LGP})OFNG>VE1eY74cM`i$mF>qhHEQ_>1(LudwCEo~}oA#Dw98|?t?4DBlIKAlbv
zp~uow==t=a^ilNJ>9gqX(l^uh&`;2>(C;xAjBrLTMjE4-p=RKWsf;Cz4;i}|CmB~6
z51Bs9o=hn-mpP1SVNPN$WNu)7!92;l#(csGU`4Z(tYVgqHHI~twVJhyb)0pT^@Po3
z$FkGd<?K=HiR{JfP3!~gZ`gNze0&5xsXl{zj6M^57W;hUbI7N~=Mg86lfY4NhI5>p
zw>fJ$dpH+3cYS?*V|+7whxy{ZZ~LzI-RJwA??b;JzeK+RKb_xrzh!=nekc8Y_GkG=
z`)B&U=0Dbdq5oF@<Nmh-SOGBsssMGsn*qxLb_SdaxW^6RO1Q;bGj|qu1NSiZdLSb(
zCNL*Z7g!&-DsW%ml^{w`WRNOI8#Fm+b<lyJt2{a{mRG<V#hc0dH}4p)H8?OhIk+OY
zE_hk+=fTY(l#rN^f)G>4?2s)XXG0!`b`Q-A#X_ftZVEja`XH=pSVkBYHY03v*qN}$
z;r#HN@aph6;oHN%?LzI6&}C4U+Ai;PInd=+S6<gXUA0|jbluYRVmGu~LbuXxuXkJ3
z?P#}q-FtM;>u&45r2D?^w|a#1$mlVu$NU~&^tjP8sAs>P#-8(g?(TV$AI#6>oA`_Q
z`}wUA-6HZMoDnM{jzv5X#0mxrCJ8nRzKvu@DkAlf^CO!gTcdhL6-AAU+8A{)niZ{x
zu8Lk1eK7h#Ol(YL%v&+rW3I=B#TLYljoldgO`LCBdfe!^hPc!5^ms*lb^N>WUnigm
zvV^LHWeLZ7p}pk2jJ@9Nb)q+|cWQ4-?}pyzgdAa}utvC1*pe8MSeQ5|aeLy=qA1ZY
z(Hzl1(KE43Y!a^)Uy=k$`b#EBc1eDbCP=l?Wzy40zDc=B<CAtI-AV41j3vL9d|nnL
zE0Vn>Ym)sYPm$Z@o8&iAqEbetEKfP7;3-NJvlNF?X{lMM<5NFNeWa8tape}}?LNXj
z)qOVfx!yOnFV=T;-z#Z?G<Dj_wB~;Nek1$6->*46B3+%{kbXHMGDDZKCgWOWeCDXk
z4>Nzx5@*@7wq-p~DOGQ%_GDAC^Rj1TAIk~M8Jx2;=et}%t|510Zfl+_@AbSr`Lz52
z`E&Bm6?8Aq7OXF5?Vr;BjsE)wa0ZkOSUTWxVM3w3a90sp)W2w6(KiF52U-ShF9yX0
z#q)~4Er~4|UGnK5`k<0Q%Le^WDk&XTdax|0Y(&|Hvis#(<+IB#4UQY^9NbjlUopI5
zeZ_;y?8>>7%|k>(-WYOZXqTbJp*w~#hE)t(Gwj|gIj<~u<?3+R@TtSkz8d>#-K&RR
z>++iEwa-WRk5G@;I+8ZBa^!}QPu0ch2K7Bnfo8d;Rjbl2(*CH+(9PG~z|yd}*fo8c
zey;wyA<Zz)aHA@{YGKtaqsq9{cxP1ps1>6gR2NsTt#+9zO`FY3^GNefOQ5CNvftXn
zT4z0B>t&m2YaXo}y<l{!eSm$91980S*n#ulVd|(e&N;=|Qq!+yS<S=RirTGp+&W9$
z(J={QrjNNcHh1g?uTx*wzTPx0V%)@WEpKGLvGPsiP0gE4<0Hq{kH0!0Z^F8X?1|MA
z|1(KEY3`(7Cs$71Ro}gSLj9E~c~dq{^_yy+dhV@0Z>^X{oo1YNY<kl4CDWhH(9QU2
zrg-MUnNMeFXMOcA$-fr=%k{SY?PIg$v)_A%{*L9HvvbntteeZ7J9h4sc}4RY=kw>!
znE&g75ep74OkTKR5qptyQS;)$#XFWnEqQ0j)1_5Q&n(MYwt0EC<<plxcvtuC$@ene
z+q9zlikT}Ozi)j1{K~wQjSVpk3s=!s)vWqqb;as~A1FRpzoyHYnQMMqYgya8u5{i0
z^(pJuZ|JsR_C|E0bK{K<hky9>zq9|nW0P>x%FQ90XMO}ea(;C4<B=bq-7;WH(^kdS
zO`k-6vV2?6wi%5`<Cw<Q?N!^GcMRQeVrT!IO}qN++V*MUr)xip_-xtd!Jp6mg8fDP
z7p~o7ci-D%+jDELVegfu5lxr&4cT{k|DgTH4h%SO=*!$M_Z`eUxcgArq0bI05AXa+
z@zwSt@*|B$Wk<LDNA{m>$K=NvkEa~p@pbCgyH4~y@x{sXlY38PpZfB2!RaGs2A(-_
zcJSHr=Z2qaKCe4}{etPjor^UWpIn;o4egs5-v)fU@Vjo`HT*aJznh!o&7Zeqw;a7(
zcKOm3?Uf(DcYOc!YW)wsKP<e~^V<6B((9ky$i4CP%~x(-{n7U0lUq}N;{LS!=eVCg
zxt($QXzP&Ht9R^oT))h^8-91~ugSkQ-7C5G-F@@@Cl6*k41c)pk>b(8$CZz-J*j=l
zc)Iwv_}_Lt8}RHKml^&~Mf*!>20RP6UrOEYkbf&j+Y`l`I<zF-1yL{I?*i_ZQWQ`q
z2z*-X{89>!wSW$vP+`%Q7)&~i%A&AQ1i+V4K&Qa|Jv0DG6b8yfSb*&l08oSi-%2Tj
zMkt--MBpnbmljBmU<3&OQ^L!XMh3G6Wre7tl0r*IPYlz{iB_%rxHTr(&JN#uLKfRn
zCZBX?ZbNptBPTZ{Pa8M5qO!}DrjwU{(M`tZ)nlu+?mKlQUZKD1Oh{Gc7xagRHA9tg
zR84K&n6Xo)zBO(7jQI-|E?T@~>FN*GtX;Q$!zbGsx9`}wYyW{S4<0)F)#)>5&z-+;
z@%yVkT)Teb=CAkeKX~})F&sYewo9eZs8lMQPBTN5x$te5CZPjCQ05?pRLvXB%$gWE
zC%AN_CM1dVan#-uDtl{a%cNxZ#2co~zSFQJMiyQ!&(X!Q9h2wf;)K3~F=s_e{S;E+
zyYXG-ul|I1<Xzx?<&Dd$)GNFXz3s2O`9rGerY&B#<Iwr*4^s<<8pljuvVP~`3pXAm
zDEki^HFn0*4ZFU&c=K`R$JmYOPnL)tebDp%?VeAkjlZ;Z_e0H!r?c+IyTJJo@XK(4
x{qtR5{qAQ`{?C@|e!BAUvCU5dUEr7hy1?4KE+BV-8#l+_KJNk-kB@L&_#cPcZFc|w

literal 9479
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
L5b}Jz`S||<DNg5?

diff --git a/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
index 3f517da0..6263367e 100644
--- a/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
+++ b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
@@ -9,7 +9,6 @@ internal static partial class CpuTextureInterop {
     [InteropImport("rendering_cpu_texture_interop_decode")]
     public static partial InteropResult<CpuTextureData> Decode(
         ReadOnlySpan<byte> fileData,
-        TextureFileFormat fileFormat,
         InteropOption<TextureFormat> format
     );
 
diff --git a/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs b/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs
deleted file mode 100644
index eab5bdd1..00000000
--- a/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs
+++ /dev/null
@@ -1,7 +0,0 @@
-namespace NoiseEngine.Rendering.Cpu;
-
-public enum TextureFileFormat {
-    Png,
-    Jpeg,
-    Webp,
-}
diff --git a/NoiseEngine/Rendering/CpuTexture2D.cs b/NoiseEngine/Rendering/CpuTexture2D.cs
index bff14cb7..bf3e6541 100644
--- a/NoiseEngine/Rendering/CpuTexture2D.cs
+++ b/NoiseEngine/Rendering/CpuTexture2D.cs
@@ -29,19 +29,18 @@ public class CpuTexture2D : CpuTexture {
 
     /// <summary>
     /// Tries to decode given <paramref name="fileData"/> to <see cref="CpuTexture2D"/>.
+    /// Makes an educated guess about file format.
     /// </summary>
     /// <param name="fileData">File data.</param>
-    /// <param name="fileFormat">File format.</param>
     /// <param name="texture">Result texture.</param>
     /// <param name="format">Target format for the texture. Null tries to use the format of the file.</param>
     /// <returns>True if decoding was successful; otherwise false.</returns>
     public static bool TryFromFile(
         ReadOnlySpan<byte> fileData,
-        TextureFileFormat fileFormat,
         [NotNullWhen(true)] out CpuTexture2D? texture,
         TextureFormat? format = null
     ) {
-        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, fileFormat, format);
+        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, format);
 
         if (!result.TryGetValue(out CpuTextureData data, out _)) {
             texture = null;
@@ -54,19 +53,18 @@ public class CpuTexture2D : CpuTexture {
     }
 
     /// <summary>
-    ///  Decodes given <paramref name="fileData"/> to <see cref="CpuTexture2D"/>.
+    /// Decodes given <paramref name="fileData"/> to <see cref="CpuTexture2D"/>.
+    /// Makes an educated guess about file format.
     /// </summary>
     /// <param name="fileData">File data.</param>
-    /// <param name="fileFormat">File format.</param>
     /// <param name="format">Target format for the texture. Null tries to use the format of the file.</param>
     /// <returns>Result texture.</returns>
     /// <exception cref="ArgumentException">Throws if decoding file data fails.</exception>
     public static CpuTexture2D FromFile(
         ReadOnlySpan<byte> fileData,
-        TextureFileFormat fileFormat,
         TextureFormat? format = null
     ) {
-        if (!TryFromFile(fileData, fileFormat, out CpuTexture2D? texture, format))
+        if (!TryFromFile(fileData, out CpuTexture2D? texture, format))
             throw new ArgumentException("Cannot decode texture from given file data.", nameof(fileData));
 
         return texture;

From f0621e35312e40776d1d206c71db2d2b50ee430b Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Fri, 2 Jun 2023 18:22:37 +0200
Subject: [PATCH 10/19] Add png and jpeg encoding

---
 .../interop/rendering/cpu_texture_interop.rs  |  26 +++-
 NoiseEngine.Native/src/rendering/cpu.rs       |  40 +++++
 NoiseEngine.Native/src/rendering/encoding.rs  | 146 ++++++++++--------
 .../Rendering/CpuTexture2DTest.cs             |  29 ++++
 .../Interop/Rendering/CpuTextureInterop.cs    |   7 +
 .../Rendering/Cpu/TextureFileFormat.cs        |   7 +
 NoiseEngine/Rendering/CpuTexture2D.cs         |  41 +++++
 7 files changed, 232 insertions(+), 64 deletions(-)
 create mode 100644 NoiseEngine/Rendering/Cpu/TextureFileFormat.cs

diff --git a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
index 70712cef..edff7954 100644
--- a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
+++ b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
@@ -5,9 +5,9 @@ use crate::{
         InteropReadOnlySpan,
         InteropResult,
         ResultError,
-        ResultErrorKind, InteropOption,
+        ResultErrorKind, InteropOption, InteropArray,
     },
-    rendering::{cpu::CpuTextureData, encoding}
+    rendering::{cpu::{CpuTextureData, self}, encoding}
 };
 
 #[no_mangle]
@@ -31,3 +31,25 @@ extern "C" fn rendering_cpu_texture_interop_decode(
         },
     }
 }
+
+#[no_mangle]
+extern "C" fn rendering_cpu_texture_interop_encode(
+    data: &CpuTextureData,
+    file_format: cpu::TextureFileFormat,
+    quality: InteropOption<u8>,
+) -> InteropResult<InteropArray<u8>> {
+    let result =
+        encoding::encode(data, file_format, quality.into());
+
+    match result {
+        Ok(data) => {
+            InteropResult::with_ok(data.into())
+        },
+        Err(error) => {
+            InteropResult::with_err(ResultError::with_kind(
+                &*Box::<dyn std::error::Error>::from(error),
+                ResultErrorKind::Argument,
+            ))
+        },
+    }
+}
diff --git a/NoiseEngine.Native/src/rendering/cpu.rs b/NoiseEngine.Native/src/rendering/cpu.rs
index 6de6f2d0..80c95bf3 100644
--- a/NoiseEngine.Native/src/rendering/cpu.rs
+++ b/NoiseEngine.Native/src/rendering/cpu.rs
@@ -2,6 +2,46 @@ use ash::vk;
 
 use crate::interop::prelude::InteropArray;
 
+#[repr(C)]
+pub enum TextureFileFormat {
+    Png,
+    Jpeg,
+    Webp
+}
+
+pub fn vk_format_to_color_type(
+    vk_format: vk::Format,
+) -> Option<image::ColorType> {
+    type F = vk::Format;
+    match vk_format {
+        F::R8_UNORM | F::R8_SNORM | F::R8_USCALED | F::R8_SSCALED | F::R8_UINT | F::R8_SINT | F::R8_SRGB => {
+            Some(image::ColorType::L8)
+        },
+        F::R8G8_UNORM | F::R8G8_SNORM | F::R8G8_USCALED | F::R8G8_SSCALED | F::R8G8_UINT | F::R8G8_SINT | F::R8G8_SRGB => {
+            Some(image::ColorType::La8)
+        },
+        F::R8G8B8_UNORM | F::R8G8B8_SNORM | F::R8G8B8_USCALED | F::R8G8B8_SSCALED | F::R8G8B8_UINT | F::R8G8B8_SINT | F::R8G8B8_SRGB => {
+            Some(image::ColorType::Rgb8)
+        },
+        F::R8G8B8A8_UNORM | F::R8G8B8A8_SNORM | F::R8G8B8A8_USCALED | F::R8G8B8A8_SSCALED | F::R8G8B8A8_UINT | F::R8G8B8A8_SINT | F::R8G8B8A8_SRGB => {
+            Some(image::ColorType::Rgba8)
+        },
+        F::R16_UNORM | F::R16_SNORM | F::R16_USCALED | F::R16_SSCALED | F::R16_UINT | F::R16_SINT | F::R16_SFLOAT => {
+            Some(image::ColorType::L16)
+        },
+        F::R16G16_UNORM | F::R16G16_SNORM | F::R16G16_USCALED | F::R16G16_SSCALED | F::R16G16_UINT | F::R16G16_SINT | F::R16G16_SFLOAT => {
+            Some(image::ColorType::La16)
+        },
+        F::R16G16B16_UNORM | F::R16G16B16_SNORM | F::R16G16B16_USCALED | F::R16G16B16_SSCALED | F::R16G16B16_UINT | F::R16G16B16_SINT | F::R16G16B16_SFLOAT => {
+            Some(image::ColorType::Rgb16)
+        },
+        F::R16G16B16A16_UNORM | F::R16G16B16A16_SNORM | F::R16G16B16A16_USCALED | F::R16G16B16A16_SSCALED | F::R16G16B16A16_UINT | F::R16G16B16A16_SINT | F::R16G16B16A16_SFLOAT => {
+            Some(image::ColorType::Rgba16)
+        },
+        _ => None,
+    }
+}
+
 #[repr(C)]
 pub struct CpuTextureData {
     extent_x: u32,
diff --git a/NoiseEngine.Native/src/rendering/encoding.rs b/NoiseEngine.Native/src/rendering/encoding.rs
index 78c05c48..aec67981 100644
--- a/NoiseEngine.Native/src/rendering/encoding.rs
+++ b/NoiseEngine.Native/src/rendering/encoding.rs
@@ -1,8 +1,12 @@
+use std::io::Cursor;
+
 use crate::rendering::cpu::CpuTextureData;
 
-use anyhow::Result;
+use anyhow::{Result, Context};
 use ash::vk;
 
+use super::cpu::{self, TextureFileFormat};
+
 pub fn decode(
     file_data: &[u8],
     format: Option<vk::Format>,
@@ -10,53 +14,88 @@ pub fn decode(
     let img =
         image::load_from_memory(file_data)?;
 
+    let mut img_color = img.color();
+
     if let Some(format) = format {
-        return decode_with_format(img, format);
+        img_color = match cpu::vk_format_to_color_type(format) {
+            Some(color_type) => color_type,
+            None => anyhow::bail!("Unsupported format: {:?}", format),
+        };
     }
 
     let width = img.width();
     let height = img.height();
 
-    let (data, format) = match img.color() {
+    let (data, format) = match img_color {
         image::ColorType::L8 => {
-            (img.into_luma8().into_raw(), vk::Format::R8_SRGB)
+            (
+                img.into_luma8().into_raw(),
+                format.unwrap_or(vk::Format::R8_SRGB),
+            )
         },
         image::ColorType::La8 => {
-            (img.into_luma_alpha8().into_raw(), vk::Format::R8G8_SRGB)
+            (
+                img.into_luma_alpha8().into_raw(),
+                format.unwrap_or(vk::Format::R8G8_SRGB),
+            )
         },
         image::ColorType::Rgb8 => {
-            (img.into_rgb8().into_raw(), vk::Format::R8G8B8_SRGB)
+            (
+                img.into_rgb8().into_raw(),
+                format.unwrap_or(vk::Format::R8G8B8_SRGB),
+            )
         },
         image::ColorType::Rgba8 => {
-            (img.into_rgba8().into_raw(), vk::Format::R8G8B8A8_SRGB)
+            (
+                img.into_rgba8().into_raw(),
+                format.unwrap_or(vk::Format::R8G8B8A8_SRGB),
+            )
         },
         image::ColorType::L16 => {
             let raw = img.into_luma16().into_raw();
-            (reinterpret_vec(raw), vk::Format::R16_UNORM)
+            (
+                reinterpret_vec(raw),
+                format.unwrap_or(vk::Format::R16_UNORM),
+            )
         },
         image::ColorType::La16 => {
             let raw = img.into_luma_alpha16().into_raw();
-            (reinterpret_vec(raw), vk::Format::R16G16_UNORM)
+            (
+                reinterpret_vec(raw),
+                format.unwrap_or(vk::Format::R16G16_UNORM),
+            )
         },
         image::ColorType::Rgb16 => {
             let raw = img.into_rgb16().into_raw();
-            (reinterpret_vec(raw), vk::Format::R16G16B16_UNORM)
+            (
+                reinterpret_vec(raw),
+                format.unwrap_or(vk::Format::R16G16B16_UNORM),
+            )
         },
         image::ColorType::Rgba16 => {
             let raw = img.into_rgba16().into_raw();
-            (reinterpret_vec(raw), vk::Format::R16G16B16A16_UNORM)
+            (
+                reinterpret_vec(raw),
+                format.unwrap_or(vk::Format::R16G16B16A16_UNORM),
+            )
         },
         // Note that the following formats are not supported by Vulkan
         // so we downgrade them to the closest supported format
         image::ColorType::Rgb32F => {
             let raw = img.into_rgb16().into_raw();
-            (reinterpret_vec(raw), vk::Format::R16G16B16_UNORM)
+            (
+                reinterpret_vec(raw),
+                format.unwrap_or(vk::Format::R16G16B16_UNORM),
+            )
         },
         image::ColorType::Rgba32F => {
             let raw = img.into_rgba16().into_raw();
-            (reinterpret_vec(raw), vk::Format::R16G16B16A16_UNORM)
+            (
+                reinterpret_vec(raw),
+                format.unwrap_or(vk::Format::R16G16B16A16_UNORM),
+            )
         },
-        _ => anyhow::bail!("Unknown color type: {:?}", img.color()),
+        _ => anyhow::bail!("Unknown color type: {:?}", img_color),
     };
 
     Ok(CpuTextureData::new(
@@ -68,61 +107,44 @@ pub fn decode(
     ))
 }
 
-fn decode_with_format(
-    img: image::DynamicImage,
-    format: vk::Format,
-) -> Result<CpuTextureData> {
-    type F = vk::Format;
+pub fn encode(
+    texture: &CpuTextureData,
+    file_format: TextureFileFormat,
+    quality: Option<u8>,
+) -> Result<Vec<u8>> {
+    anyhow::ensure!(
+        texture.extent_z() == 1,
+        "3D textures are not supported"
+    );
 
-    let width = img.width();
-    let height = img.height();
+    let color_type = cpu::vk_format_to_color_type(*texture.format())
+        .context("Invalid format")?;
 
-    #[rustfmt::skip]
-    let data = match format {
-        F::R8_UNORM | F::R8_SNORM | F::R8_USCALED | F::R8_SSCALED | F::R8_UINT | F::R8_SINT | F::R8_SRGB => {
-            img.into_luma8().into_raw()
-        },
-        F::R8G8_UNORM | F::R8G8_SNORM | F::R8G8_USCALED | F::R8G8_SSCALED | F::R8G8_UINT | F::R8G8_SINT | F::R8G8_SRGB => {
-            img.into_luma_alpha8().into_raw()
-        },
-        F::R8G8B8_UNORM | F::R8G8B8_SNORM | F::R8G8B8_USCALED | F::R8G8B8_SSCALED | F::R8G8B8_UINT | F::R8G8B8_SINT | F::R8G8B8_SRGB => {
-            img.into_rgb8().into_raw()
-        },
-        F::R8G8B8A8_UNORM | F::R8G8B8A8_SNORM | F::R8G8B8A8_USCALED | F::R8G8B8A8_SSCALED | F::R8G8B8A8_UINT | F::R8G8B8A8_SINT | F::R8G8B8A8_SRGB => {
-            img.into_rgba8().into_raw()
-        },
-        F::R16_UNORM | F::R16_SNORM | F::R16_USCALED | F::R16_SSCALED | F::R16_UINT | F::R16_SINT | F::R16_SFLOAT => {
-            let raw = img.into_luma16().into_raw();
-            reinterpret_vec(raw)
-        },
-        F::R16G16_UNORM | F::R16G16_SNORM | F::R16G16_USCALED | F::R16G16_SSCALED | F::R16G16_UINT | F::R16G16_SINT | F::R16G16_SFLOAT => {
-            let raw = img.into_luma_alpha16().into_raw();
-            reinterpret_vec(raw)
-        },
-        F::R16G16B16_UNORM | F::R16G16B16_SNORM | F::R16G16B16_USCALED | F::R16G16B16_SSCALED | F::R16G16B16_UINT | F::R16G16B16_SINT | F::R16G16B16_SFLOAT => {
-            let raw = img.into_rgb16().into_raw();
-            reinterpret_vec(raw)
-        },
-        F::R16G16B16A16_UNORM | F::R16G16B16A16_SNORM | F::R16G16B16A16_USCALED | F::R16G16B16A16_SSCALED | F::R16G16B16A16_UINT | F::R16G16B16A16_SINT | F::R16G16B16A16_SFLOAT => {
-            let raw = img.into_rgba16().into_raw();
-            reinterpret_vec(raw)
-        },
-        _ => anyhow::bail!("Unsupported format: {:?}", format)
-    };
+    let data = texture.data().into();
+    let mut result = Cursor::new(Vec::new());
 
-    Ok(CpuTextureData::new(
-        width,
-        height,
-        1,
-        format,
-        data.into()
-    ))
+    image::write_buffer_with_format(
+        &mut result,
+        data,
+        texture.extent_x(),
+        texture.extent_y(),
+        color_type,
+        match file_format {
+            TextureFileFormat::Png => image::ImageOutputFormat::Png,
+            TextureFileFormat::Jpeg => image::ImageOutputFormat::Jpeg(
+                quality.unwrap_or(75),
+            ),
+            TextureFileFormat::Webp => todo!(),
+        },
+    )?;
+
+    Ok(result.into_inner())
 }
 
 fn reinterpret_vec<T>(vec: Vec<T>) -> Vec<u8> {
     let len = vec.len() * std::mem::size_of::<T>();
     let cap = vec.capacity() * std::mem::size_of::<T>();
-    let ptr = vec.as_ptr() as *const u8;
+    let ptr = vec.as_ptr() as *mut u8;
     std::mem::forget(vec);
-    unsafe { Vec::from_raw_parts(ptr as *mut u8, len, cap) }
+    unsafe { Vec::from_raw_parts(ptr, len, cap) }
 }
diff --git a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
index 817c7ed2..b20f44d8 100644
--- a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
+++ b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
@@ -1,8 +1,11 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using NoiseEngine.Interop;
 using NoiseEngine.Mathematics;
 using NoiseEngine.Rendering;
+using NoiseEngine.Rendering.Cpu;
 using NoiseEngine.Tests.Environments;
 using NoiseEngine.Tests.Fixtures;
 
@@ -92,4 +95,30 @@ public class CpuTexture2DTest : GraphicsTestEnvironment {
         }
     }
 
+    [Theory]
+    [InlineData("colors.png", TextureFileFormat.Png, null)]
+    [InlineData("colors.jpeg", TextureFileFormat.Jpeg, (byte)100)]
+    [InlineData("colors.webp", TextureFileFormat.Webp, null)]
+    public void ToFile(string path, TextureFileFormat fileFormat, byte? quality) {
+        byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
+        CpuTexture2D expected = CpuTexture2D.FromFile(fileData, TextureFormat.R8G8B8A8_SRGB);
+        CpuTexture2D actual = CpuTexture2D.FromFile(expected.ToFile(fileFormat, quality), TextureFormat.R8G8B8A8_SRGB);
+        
+        Assert.Equal(expected.Width, actual.Width);
+        Assert.Equal(expected.Height, actual.Height);
+        
+        if (path.EndsWith(".jpg") || path.EndsWith(".jpeg")) {
+            Assert.True(
+                TextureTestUtils.CompareLossy(
+                    actual.Data.ToArray(),
+                    new Vector2<uint>(actual.Width, actual.Height),
+                    textureColors,
+                    TextureFormat.R8G8B8A8_SRGB
+                )
+            );
+        } else {
+            Assert.Equal(expected.Data.ToArray(), actual.Data.ToArray());
+        }
+    }
+
 }
diff --git a/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
index 6263367e..a8f2a62d 100644
--- a/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
+++ b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
@@ -11,5 +11,12 @@ internal static partial class CpuTextureInterop {
         ReadOnlySpan<byte> fileData,
         InteropOption<TextureFormat> format
     );
+    
+    [InteropImport("rendering_cpu_texture_interop_encode")]
+    public static partial InteropResult<InteropArray<byte>> Encode(
+        in CpuTextureData data,
+        TextureFileFormat format,
+        InteropOption<byte> quality
+    );
 
 }
diff --git a/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs b/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs
new file mode 100644
index 00000000..0d815364
--- /dev/null
+++ b/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs
@@ -0,0 +1,7 @@
+namespace NoiseEngine.Rendering.Cpu; 
+
+public enum TextureFileFormat {
+    Png,
+    Jpeg,
+    Webp
+}
diff --git a/NoiseEngine/Rendering/CpuTexture2D.cs b/NoiseEngine/Rendering/CpuTexture2D.cs
index bf3e6541..3e4fe96b 100644
--- a/NoiseEngine/Rendering/CpuTexture2D.cs
+++ b/NoiseEngine/Rendering/CpuTexture2D.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using NoiseEngine.Interop;
 using NoiseEngine.Interop.Rendering;
 using NoiseEngine.Mathematics;
@@ -99,5 +100,45 @@ public class CpuTexture2D : CpuTexture {
         texture.SetPixels<byte>(Data);
         return texture;
     }
+    /// <summary>
+    /// Converts this <see cref="CpuTexture2D"/> to a file format.
+    /// </summary>
+    /// <param name="format">Format of the file.</param>
+    /// <param name="quality">
+    /// Quality of the encoding, if lossy format is chosen.
+    /// Null uses default quality for the format.
+    /// Values higher than 100 are clamped to 100.
+    /// </param>
+    /// <returns>
+    /// File data.
+    /// </returns>
+    /// <exception cref="ArgumentException">
+    /// Conversion was not possible with the given arguments.
+    /// </exception>
+    public byte[] ToFile(TextureFileFormat format, byte? quality = null) {
+        if (format == TextureFileFormat.Png && quality != null) {
+            throw new ArgumentException("PNG does not support quality settings.", nameof(quality));
+        }
+        
+        if (quality is > 100) {
+            quality = 100;
+        }
+        
+        CpuTextureData data = new CpuTextureData {
+            Data = this.data,
+            Format = Format,
+            ExtentX = Extent.X,
+            ExtentY = Extent.Y,
+            ExtentZ = 1
+        };
+        
+        InteropResult<InteropArray<byte>> result = CpuTextureInterop.Encode(in data, format, quality);
+
+        if (result.TryGetValue(out InteropArray<byte> encoded, out ResultError error)) {
+            return encoded.AsSpan().ToArray();
+        }
+
+        throw error.ToException();
+    }
 
 }

From 211d3018fe4e23e63b774d1396c43022ca936feb Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Sat, 3 Jun 2023 11:37:57 +0200
Subject: [PATCH 11/19] Add webp encoding wip

---
 NoiseEngine.Native/Cargo.toml                 |   1 +
 NoiseEngine.Native/src/rendering/encoding.rs  | 116 ++++++++++++++++--
 .../Rendering/CpuTexture2DTest.cs             |  60 +++++----
 NoiseEngine/Rendering/CpuTexture2D.cs         |  46 ++++---
 4 files changed, 171 insertions(+), 52 deletions(-)

diff --git a/NoiseEngine.Native/Cargo.toml b/NoiseEngine.Native/Cargo.toml
index 63ac21a5..7c2e699a 100644
--- a/NoiseEngine.Native/Cargo.toml
+++ b/NoiseEngine.Native/Cargo.toml
@@ -21,6 +21,7 @@ cgmath = "0.18.0"
 crossbeam-queue = "0.3.8"
 anyhow = "1.0.71"
 image = "0.24.6"
+webp = "0.2.2"
 
 [dependencies.uuid]
 version = "1.2.2"
diff --git a/NoiseEngine.Native/src/rendering/encoding.rs b/NoiseEngine.Native/src/rendering/encoding.rs
index aec67981..b7ff1d5b 100644
--- a/NoiseEngine.Native/src/rendering/encoding.rs
+++ b/NoiseEngine.Native/src/rendering/encoding.rs
@@ -4,6 +4,7 @@ use crate::rendering::cpu::CpuTextureData;
 
 use anyhow::{Result, Context};
 use ash::vk;
+use image::{ImageBuffer, ColorType, DynamicImage};
 
 use super::cpu::{self, TextureFileFormat};
 
@@ -27,52 +28,52 @@ pub fn decode(
     let height = img.height();
 
     let (data, format) = match img_color {
-        image::ColorType::L8 => {
+        ColorType::L8 => {
             (
                 img.into_luma8().into_raw(),
                 format.unwrap_or(vk::Format::R8_SRGB),
             )
         },
-        image::ColorType::La8 => {
+        ColorType::La8 => {
             (
                 img.into_luma_alpha8().into_raw(),
                 format.unwrap_or(vk::Format::R8G8_SRGB),
             )
         },
-        image::ColorType::Rgb8 => {
+        ColorType::Rgb8 => {
             (
                 img.into_rgb8().into_raw(),
                 format.unwrap_or(vk::Format::R8G8B8_SRGB),
             )
         },
-        image::ColorType::Rgba8 => {
+        ColorType::Rgba8 => {
             (
                 img.into_rgba8().into_raw(),
                 format.unwrap_or(vk::Format::R8G8B8A8_SRGB),
             )
         },
-        image::ColorType::L16 => {
+        ColorType::L16 => {
             let raw = img.into_luma16().into_raw();
             (
                 reinterpret_vec(raw),
                 format.unwrap_or(vk::Format::R16_UNORM),
             )
         },
-        image::ColorType::La16 => {
+        ColorType::La16 => {
             let raw = img.into_luma_alpha16().into_raw();
             (
                 reinterpret_vec(raw),
                 format.unwrap_or(vk::Format::R16G16_UNORM),
             )
         },
-        image::ColorType::Rgb16 => {
+        ColorType::Rgb16 => {
             let raw = img.into_rgb16().into_raw();
             (
                 reinterpret_vec(raw),
                 format.unwrap_or(vk::Format::R16G16B16_UNORM),
             )
         },
-        image::ColorType::Rgba16 => {
+        ColorType::Rgba16 => {
             let raw = img.into_rgba16().into_raw();
             (
                 reinterpret_vec(raw),
@@ -81,14 +82,14 @@ pub fn decode(
         },
         // Note that the following formats are not supported by Vulkan
         // so we downgrade them to the closest supported format
-        image::ColorType::Rgb32F => {
+        ColorType::Rgb32F => {
             let raw = img.into_rgb16().into_raw();
             (
                 reinterpret_vec(raw),
                 format.unwrap_or(vk::Format::R16G16B16_UNORM),
             )
         },
-        image::ColorType::Rgba32F => {
+        ColorType::Rgba32F => {
             let raw = img.into_rgba16().into_raw();
             (
                 reinterpret_vec(raw),
@@ -121,6 +122,20 @@ pub fn encode(
         .context("Invalid format")?;
 
     let data = texture.data().into();
+
+    match file_format {
+        TextureFileFormat::Webp => {
+            return encode_webp(
+                data,
+                texture.extent_x(),
+                texture.extent_y(),
+                color_type,
+                quality,
+            );
+        },
+        _ => {},
+    };
+
     let mut result = Cursor::new(Vec::new());
 
     image::write_buffer_with_format(
@@ -134,7 +149,7 @@ pub fn encode(
             TextureFileFormat::Jpeg => image::ImageOutputFormat::Jpeg(
                 quality.unwrap_or(75),
             ),
-            TextureFileFormat::Webp => todo!(),
+            TextureFileFormat::Webp => unreachable!(),
         },
     )?;
 
@@ -148,3 +163,82 @@ fn reinterpret_vec<T>(vec: Vec<T>) -> Vec<u8> {
     std::mem::forget(vec);
     unsafe { Vec::from_raw_parts(ptr, len, cap) }
 }
+
+fn interpret_vec<T>(vec: Vec<u8>) -> Vec<T> {
+    if vec.len() % std::mem::size_of::<T>() != 0 {
+        panic!("Invalid size");
+    }
+
+    let len = vec.len() / std::mem::size_of::<T>();
+    let cap = vec.capacity() / std::mem::size_of::<T>();
+    let ptr = vec.as_ptr() as *mut T;
+    std::mem::forget(vec);
+    unsafe { Vec::from_raw_parts(ptr, len, cap) }
+}
+
+fn encode_webp(
+    data: &[u8],
+    width: u32,
+    height: u32,
+    color_type: ColorType,
+    quality: Option<u8>,
+) -> Result<Vec<u8>> {
+    use webp::Encoder;
+
+
+    let data = data.to_vec();
+
+    match color_type {
+        ColorType::L8 => {
+            let img = ImageBuffer::<image::Luma<u8>, _>::from_vec(
+                width,
+                height,
+                data,
+            ).context(FAIL_MSG)?;
+
+            let img = img.into();
+            let encoder = Encoder::from_image(&img);
+
+            let encoder = match encoder {
+                Ok(encoder) => encoder,
+                Err(_) => anyhow::bail!(FAIL_MSG)
+            };
+
+            let result = match quality {
+                Some(quality) => encoder.encode(quality as f32),
+                None => encoder.encode_lossless(),
+            };
+
+            return Ok(result.to_vec());
+        },
+        _ => anyhow::bail!("Unsupported color type {:?}", color_type),
+    };
+}
+
+fn encode_webp_helper<T, P: image::Pixel<Subpixel = T>>(
+    data: Vec<u8>,
+    width: u32,
+    height: u32,
+    quality: Option<u8>,
+) -> Result<Vec<u8>> where DynamicImage: From<ImageBuffer<P, Vec<T>>> {
+    let img = ImageBuffer::<P, T>::from_vec(
+        width,
+        height,
+        interpret_vec::<T>(data),
+    ).context("Failed to encode image")?;
+
+    let img = img.into();
+    let encoder = webp::Encoder::from_image(&img);
+
+    let encoder = match encoder {
+        Ok(encoder) => encoder,
+        Err(_) => anyhow::bail!("Failed to encode image")
+    };
+
+    let result = match quality {
+        Some(quality) => encoder.encode(quality as f32),
+        None => encoder.encode_lossless(),
+    };
+
+    Ok(result.to_vec())
+}
diff --git a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
index b20f44d8..196425c8 100644
--- a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
+++ b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
@@ -5,7 +5,6 @@
 using NoiseEngine.Interop;
 using NoiseEngine.Mathematics;
 using NoiseEngine.Rendering;
-using NoiseEngine.Rendering.Cpu;
 using NoiseEngine.Tests.Environments;
 using NoiseEngine.Tests.Fixtures;
 
@@ -95,30 +94,41 @@ public class CpuTexture2DTest : GraphicsTestEnvironment {
         }
     }
 
-    [Theory]
-    [InlineData("colors.png", TextureFileFormat.Png, null)]
-    [InlineData("colors.jpeg", TextureFileFormat.Jpeg, (byte)100)]
-    [InlineData("colors.webp", TextureFileFormat.Webp, null)]
-    public void ToFile(string path, TextureFileFormat fileFormat, byte? quality) {
-        byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
-        CpuTexture2D expected = CpuTexture2D.FromFile(fileData, TextureFormat.R8G8B8A8_SRGB);
-        CpuTexture2D actual = CpuTexture2D.FromFile(expected.ToFile(fileFormat, quality), TextureFormat.R8G8B8A8_SRGB);
-        
-        Assert.Equal(expected.Width, actual.Width);
-        Assert.Equal(expected.Height, actual.Height);
-        
-        if (path.EndsWith(".jpg") || path.EndsWith(".jpeg")) {
-            Assert.True(
-                TextureTestUtils.CompareLossy(
-                    actual.Data.ToArray(),
-                    new Vector2<uint>(actual.Width, actual.Height),
-                    textureColors,
-                    TextureFormat.R8G8B8A8_SRGB
-                )
-            );
-        } else {
-            Assert.Equal(expected.Data.ToArray(), actual.Data.ToArray());
-        }
+    [Fact]
+    public void ToPng() {
+        byte[] fileData = File.ReadAllBytes("./Resources/Textures/colors.png");
+        CpuTexture2D texture = CpuTexture2D.FromFile(fileData, TextureFormat.R8G8B8A8_SRGB);
+
+        byte[] expected = texture.Data.ToArray();
+        byte[] actual = CpuTexture2D.FromFile(texture.ToPng()).Data.ToArray();
+
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void ToJpeg() {
+        byte[] fileData = File.ReadAllBytes("./Resources/Textures/colors.jpeg");
+        CpuTexture2D texture = CpuTexture2D.FromFile(fileData, TextureFormat.R8G8B8A8_SRGB);
+
+        Span<byte> actual = CpuTexture2D.FromFile(texture.ToJpeg()).Data;
+
+        TextureTestUtils.CompareLossy(
+            actual,
+            new Vector2<uint>(texture.Width, texture.Height),
+            textureColors,
+            texture.Format
+        );
+    }
+
+    [Fact]
+    public void ToWebp() {
+        byte[] fileData = File.ReadAllBytes("./Resources/Textures/colors.webp");
+        CpuTexture2D texture = CpuTexture2D.FromFile(fileData, TextureFormat.R8G8B8A8_SRGB);
+
+        byte[] expected = texture.Data.ToArray();
+        byte[] actual = CpuTexture2D.FromFile(texture.ToWebp()).Data.ToArray();
+
+        Assert.Equal(expected, actual);
     }
 
 }
diff --git a/NoiseEngine/Rendering/CpuTexture2D.cs b/NoiseEngine/Rendering/CpuTexture2D.cs
index 3e4fe96b..f660a29b 100644
--- a/NoiseEngine/Rendering/CpuTexture2D.cs
+++ b/NoiseEngine/Rendering/CpuTexture2D.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using NoiseEngine.Interop;
 using NoiseEngine.Interop.Rendering;
 using NoiseEngine.Mathematics;
@@ -100,30 +99,45 @@ public class CpuTexture2D : CpuTexture {
         texture.SetPixels<byte>(Data);
         return texture;
     }
+
+    /// <summary>
+    /// Creates a PNG file from this <see cref="CpuTexture2D"/>.
+    /// </summary>
+    /// <returns>File data.</returns>
+    public byte[] ToPng() {
+        return ToFile(TextureFileFormat.Png);
+    }
+
     /// <summary>
-    /// Converts this <see cref="CpuTexture2D"/> to a file format.
+    /// Creates a JPEG file from this <see cref="CpuTexture2D"/>.
+    /// </summary>
+    /// <param name="quality">Quality of the compression between 0 and 100.</param>
+    /// <returns>File data.</returns>
+    public byte[] ToJpeg(byte quality = 75) {
+        return ToFile(TextureFileFormat.Jpeg, quality);
+    }
+
+    /// <summary>
+    /// Creates a WebP file from this <see cref="CpuTexture2D"/>.
     /// </summary>
-    /// <param name="format">Format of the file.</param>
     /// <param name="quality">
-    /// Quality of the encoding, if lossy format is chosen.
-    /// Null uses default quality for the format.
-    /// Values higher than 100 are clamped to 100.
+    /// Quality of the compression between 0 and 100.
+    /// Value of 100 is lossless compression.
     /// </param>
-    /// <returns>
-    /// File data.
-    /// </returns>
-    /// <exception cref="ArgumentException">
-    /// Conversion was not possible with the given arguments.
-    /// </exception>
-    public byte[] ToFile(TextureFileFormat format, byte? quality = null) {
+    /// <returns>File data.</returns>
+    public byte[] ToWebp(byte quality = 100) {
+        return ToFile(TextureFileFormat.Webp, quality);
+    }
+
+    private byte[] ToFile(TextureFileFormat format, byte? quality = null) {
         if (format == TextureFileFormat.Png && quality != null) {
             throw new ArgumentException("PNG does not support quality settings.", nameof(quality));
         }
-        
+
         if (quality is > 100) {
             quality = 100;
         }
-        
+
         CpuTextureData data = new CpuTextureData {
             Data = this.data,
             Format = Format,
@@ -131,7 +145,7 @@ public class CpuTexture2D : CpuTexture {
             ExtentY = Extent.Y,
             ExtentZ = 1
         };
-        
+
         InteropResult<InteropArray<byte>> result = CpuTextureInterop.Encode(in data, format, quality);
 
         if (result.TryGetValue(out InteropArray<byte> encoded, out ResultError error)) {

From 0092ec8851383cd1c57ba3b81731025a0b906c7d Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Sat, 3 Jun 2023 12:51:31 +0200
Subject: [PATCH 12/19] Add webp encoding

---
 NoiseEngine.Native/src/rendering/cpu.rs       | 14 ++-
 NoiseEngine.Native/src/rendering/encoding.rs  | 86 +++++++++----------
 .../Rendering/CpuTexture2DTest.cs             |  5 +-
 NoiseEngine/Rendering/CpuTexture2D.cs         |  4 +-
 4 files changed, 56 insertions(+), 53 deletions(-)

diff --git a/NoiseEngine.Native/src/rendering/cpu.rs b/NoiseEngine.Native/src/rendering/cpu.rs
index 80c95bf3..29760f71 100644
--- a/NoiseEngine.Native/src/rendering/cpu.rs
+++ b/NoiseEngine.Native/src/rendering/cpu.rs
@@ -26,18 +26,24 @@ pub fn vk_format_to_color_type(
         F::R8G8B8A8_UNORM | F::R8G8B8A8_SNORM | F::R8G8B8A8_USCALED | F::R8G8B8A8_SSCALED | F::R8G8B8A8_UINT | F::R8G8B8A8_SINT | F::R8G8B8A8_SRGB => {
             Some(image::ColorType::Rgba8)
         },
-        F::R16_UNORM | F::R16_SNORM | F::R16_USCALED | F::R16_SSCALED | F::R16_UINT | F::R16_SINT | F::R16_SFLOAT => {
+        F::R16_UNORM | F::R16_SNORM | F::R16_USCALED | F::R16_SSCALED | F::R16_UINT | F::R16_SINT => {
             Some(image::ColorType::L16)
         },
-        F::R16G16_UNORM | F::R16G16_SNORM | F::R16G16_USCALED | F::R16G16_SSCALED | F::R16G16_UINT | F::R16G16_SINT | F::R16G16_SFLOAT => {
+        F::R16G16_UNORM | F::R16G16_SNORM | F::R16G16_USCALED | F::R16G16_SSCALED | F::R16G16_UINT | F::R16G16_SINT => {
             Some(image::ColorType::La16)
         },
-        F::R16G16B16_UNORM | F::R16G16B16_SNORM | F::R16G16B16_USCALED | F::R16G16B16_SSCALED | F::R16G16B16_UINT | F::R16G16B16_SINT | F::R16G16B16_SFLOAT => {
+        F::R16G16B16_UNORM | F::R16G16B16_SNORM | F::R16G16B16_USCALED | F::R16G16B16_SSCALED | F::R16G16B16_UINT | F::R16G16B16_SINT => {
             Some(image::ColorType::Rgb16)
         },
-        F::R16G16B16A16_UNORM | F::R16G16B16A16_SNORM | F::R16G16B16A16_USCALED | F::R16G16B16A16_SSCALED | F::R16G16B16A16_UINT | F::R16G16B16A16_SINT | F::R16G16B16A16_SFLOAT => {
+        F::R16G16B16A16_UNORM | F::R16G16B16A16_SNORM | F::R16G16B16A16_USCALED | F::R16G16B16A16_SSCALED | F::R16G16B16A16_UINT | F::R16G16B16A16_SINT => {
             Some(image::ColorType::Rgba16)
         },
+        F::R32G32B32_SFLOAT => {
+            Some(image::ColorType::Rgb32F)
+        },
+        F::R32G32B32A32_SFLOAT => {
+            Some(image::ColorType::Rgba32F)
+        },
         _ => None,
     }
 }
diff --git a/NoiseEngine.Native/src/rendering/encoding.rs b/NoiseEngine.Native/src/rendering/encoding.rs
index b7ff1d5b..504eb0d3 100644
--- a/NoiseEngine.Native/src/rendering/encoding.rs
+++ b/NoiseEngine.Native/src/rendering/encoding.rs
@@ -80,20 +80,18 @@ pub fn decode(
                 format.unwrap_or(vk::Format::R16G16B16A16_UNORM),
             )
         },
-        // Note that the following formats are not supported by Vulkan
-        // so we downgrade them to the closest supported format
         ColorType::Rgb32F => {
             let raw = img.into_rgb16().into_raw();
             (
                 reinterpret_vec(raw),
-                format.unwrap_or(vk::Format::R16G16B16_UNORM),
+                format.unwrap_or(vk::Format::R32G32B32_SFLOAT),
             )
         },
         ColorType::Rgba32F => {
             let raw = img.into_rgba16().into_raw();
             (
                 reinterpret_vec(raw),
-                format.unwrap_or(vk::Format::R16G16B16A16_UNORM),
+                format.unwrap_or(vk::Format::R32G32B32A32_SFLOAT),
             )
         },
         _ => anyhow::bail!("Unknown color type: {:?}", img_color),
@@ -123,17 +121,14 @@ pub fn encode(
 
     let data = texture.data().into();
 
-    match file_format {
-        TextureFileFormat::Webp => {
-            return encode_webp(
-                data,
-                texture.extent_x(),
-                texture.extent_y(),
-                color_type,
-                quality,
-            );
-        },
-        _ => {},
+    if let TextureFileFormat::Webp = file_format {
+        return encode_webp(
+            data,
+            texture.extent_x(),
+            texture.extent_y(),
+            color_type,
+            quality,
+        );
     };
 
     let mut result = Cursor::new(Vec::new());
@@ -183,48 +178,53 @@ fn encode_webp(
     color_type: ColorType,
     quality: Option<u8>,
 ) -> Result<Vec<u8>> {
-    use webp::Encoder;
-
-
     let data = data.to_vec();
 
     match color_type {
         ColorType::L8 => {
-            let img = ImageBuffer::<image::Luma<u8>, _>::from_vec(
-                width,
-                height,
-                data,
-            ).context(FAIL_MSG)?;
-
-            let img = img.into();
-            let encoder = Encoder::from_image(&img);
-
-            let encoder = match encoder {
-                Ok(encoder) => encoder,
-                Err(_) => anyhow::bail!(FAIL_MSG)
-            };
-
-            let result = match quality {
-                Some(quality) => encoder.encode(quality as f32),
-                None => encoder.encode_lossless(),
-            };
-
-            return Ok(result.to_vec());
+            encode_webp_helper::<image::Luma<u8>, _>(data, width, height, quality)
+        },
+        ColorType::La8 => {
+            encode_webp_helper::<image::LumaA<u8>, _>(data, width, height, quality)
+        },
+        ColorType::Rgb8 => {
+            encode_webp_helper::<image::Rgb<u8>, _>(data, width, height, quality)
+        },
+        ColorType::Rgba8 => {
+            encode_webp_helper::<image::Rgba<u8>, _>(data, width, height, quality)
+        },
+        ColorType::L16 => {
+            encode_webp_helper::<image::Luma<u16>, _>(data, width, height, quality)
+        },
+        ColorType::La16 => {
+            encode_webp_helper::<image::LumaA<u16>, _>(data, width, height, quality)
+        },
+        ColorType::Rgb16 => {
+            encode_webp_helper::<image::Rgb<u16>, _>(data, width, height, quality)
+        },
+        ColorType::Rgba16 => {
+            encode_webp_helper::<image::Rgba<u16>, _>(data, width, height, quality)
+        },
+        ColorType::Rgb32F => {
+            encode_webp_helper::<image::Rgb<f32>, _>(data, width, height, quality)
+        },
+        ColorType::Rgba32F => {
+            encode_webp_helper::<image::Rgba<f32>, _>(data, width, height, quality)
         },
         _ => anyhow::bail!("Unsupported color type {:?}", color_type),
-    };
+    }
 }
 
-fn encode_webp_helper<T, P: image::Pixel<Subpixel = T>>(
+fn encode_webp_helper<P: image::Pixel<Subpixel = S>, S>(
     data: Vec<u8>,
     width: u32,
     height: u32,
     quality: Option<u8>,
-) -> Result<Vec<u8>> where DynamicImage: From<ImageBuffer<P, Vec<T>>> {
-    let img = ImageBuffer::<P, T>::from_vec(
+) -> Result<Vec<u8>> where DynamicImage: From<ImageBuffer<P, Vec<S>>> {
+    let img = ImageBuffer::<P, Vec<<P as image::Pixel>::Subpixel>>::from_vec(
         width,
         height,
-        interpret_vec::<T>(data),
+        interpret_vec::<S>(data),
     ).context("Failed to encode image")?;
 
     let img = img.into();
diff --git a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
index 196425c8..b4962cb5 100644
--- a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
+++ b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using NoiseEngine.Interop;
 using NoiseEngine.Mathematics;
 using NoiseEngine.Rendering;
 using NoiseEngine.Tests.Environments;
@@ -10,7 +8,6 @@
 
 namespace NoiseEngine.Tests.Rendering;
 
-[Collection(nameof(ApplicationCollection))]
 public class CpuTexture2DTest : GraphicsTestEnvironment {
 
     private readonly Dictionary<Vector2<uint>, Color32> textureColors = new Dictionary<Vector2<uint>, Color32> {
@@ -126,7 +123,7 @@ public class CpuTexture2DTest : GraphicsTestEnvironment {
         CpuTexture2D texture = CpuTexture2D.FromFile(fileData, TextureFormat.R8G8B8A8_SRGB);
 
         byte[] expected = texture.Data.ToArray();
-        byte[] actual = CpuTexture2D.FromFile(texture.ToWebp()).Data.ToArray();
+        byte[] actual = CpuTexture2D.FromFile(texture.ToWebp(), TextureFormat.R8G8B8A8_SRGB).Data.ToArray();
 
         Assert.Equal(expected, actual);
     }
diff --git a/NoiseEngine/Rendering/CpuTexture2D.cs b/NoiseEngine/Rendering/CpuTexture2D.cs
index f660a29b..75137583 100644
--- a/NoiseEngine/Rendering/CpuTexture2D.cs
+++ b/NoiseEngine/Rendering/CpuTexture2D.cs
@@ -122,10 +122,10 @@ public class CpuTexture2D : CpuTexture {
     /// </summary>
     /// <param name="quality">
     /// Quality of the compression between 0 and 100.
-    /// Value of 100 is lossless compression.
+    /// Value of null is lossless compression.
     /// </param>
     /// <returns>File data.</returns>
-    public byte[] ToWebp(byte quality = 100) {
+    public byte[] ToWebp(byte? quality = null) {
         return ToFile(TextureFileFormat.Webp, quality);
     }
 

From c6d98b6efe3ce27e0fbe807706aed29152854969 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Sat, 3 Jun 2023 13:20:39 +0200
Subject: [PATCH 13/19] Fix minor issues

---
 NoiseEngine.Native/src/rendering/cpu.rs      | 43 +++++++++++++++-----
 NoiseEngine.Native/src/rendering/encoding.rs | 14 +++----
 2 files changed, 40 insertions(+), 17 deletions(-)

diff --git a/NoiseEngine.Native/src/rendering/cpu.rs b/NoiseEngine.Native/src/rendering/cpu.rs
index 29760f71..986c3bbb 100644
--- a/NoiseEngine.Native/src/rendering/cpu.rs
+++ b/NoiseEngine.Native/src/rendering/cpu.rs
@@ -13,6 +13,7 @@ pub fn vk_format_to_color_type(
     vk_format: vk::Format,
 ) -> Option<image::ColorType> {
     type F = vk::Format;
+
     match vk_format {
         F::R8_UNORM | F::R8_SNORM | F::R8_USCALED | F::R8_SSCALED | F::R8_UINT | F::R8_SINT | F::R8_SRGB => {
             Some(image::ColorType::L8)
@@ -102,17 +103,39 @@ impl CpuTextureData {
     }
 
     pub fn pixel_size(format: vk::Format) -> usize {
+        type F = vk::Format;
+
         match format {
-            vk::Format::R8_SRGB => 1,
-            vk::Format::R8G8_SRGB => 2,
-            vk::Format::R8G8B8_SRGB => 3,
-            vk::Format::R8G8B8A8_SRGB => 4,
-            vk::Format::R16_UNORM => 2,
-            vk::Format::R16G16_UNORM => 4,
-            vk::Format::R16G16B16_UNORM => 6,
-            vk::Format::R16G16B16A16_UNORM => 8,
-            vk::Format::R32G32B32_SFLOAT => 12,
-            vk::Format::R32G32B32A32_SFLOAT => 16,
+            F::R8_UNORM | F::R8_SNORM | F::R8_USCALED | F::R8_SSCALED | F::R8_UINT | F::R8_SINT | F::R8_SRGB => {
+                1
+            },
+            F::R8G8_UNORM | F::R8G8_SNORM | F::R8G8_USCALED | F::R8G8_SSCALED | F::R8G8_UINT | F::R8G8_SINT | F::R8G8_SRGB => {
+                2
+            },
+            F::R8G8B8_UNORM | F::R8G8B8_SNORM | F::R8G8B8_USCALED | F::R8G8B8_SSCALED | F::R8G8B8_UINT | F::R8G8B8_SINT | F::R8G8B8_SRGB => {
+                3
+            },
+            F::R8G8B8A8_UNORM | F::R8G8B8A8_SNORM | F::R8G8B8A8_USCALED | F::R8G8B8A8_SSCALED | F::R8G8B8A8_UINT | F::R8G8B8A8_SINT | F::R8G8B8A8_SRGB => {
+                4
+            },
+            F::R16_UNORM | F::R16_SNORM | F::R16_USCALED | F::R16_SSCALED | F::R16_UINT | F::R16_SINT => {
+                2
+            },
+            F::R16G16_UNORM | F::R16G16_SNORM | F::R16G16_USCALED | F::R16G16_SSCALED | F::R16G16_UINT | F::R16G16_SINT => {
+                4
+            },
+            F::R16G16B16_UNORM | F::R16G16B16_SNORM | F::R16G16B16_USCALED | F::R16G16B16_SSCALED | F::R16G16B16_UINT | F::R16G16B16_SINT => {
+                6
+            },
+            F::R16G16B16A16_UNORM | F::R16G16B16A16_SNORM | F::R16G16B16A16_USCALED | F::R16G16B16A16_SSCALED | F::R16G16B16A16_UINT | F::R16G16B16A16_SINT => {
+                8
+            },
+            F::R32G32B32_SFLOAT => {
+                12
+            },
+            F::R32G32B32A32_SFLOAT => {
+                16
+            },
             _ => unimplemented!("unsupported format: {:?}", format),
         }
     }
diff --git a/NoiseEngine.Native/src/rendering/encoding.rs b/NoiseEngine.Native/src/rendering/encoding.rs
index 504eb0d3..5d9f1961 100644
--- a/NoiseEngine.Native/src/rendering/encoding.rs
+++ b/NoiseEngine.Native/src/rendering/encoding.rs
@@ -55,42 +55,42 @@ pub fn decode(
         ColorType::L16 => {
             let raw = img.into_luma16().into_raw();
             (
-                reinterpret_vec(raw),
+                uninterpret_vec(raw),
                 format.unwrap_or(vk::Format::R16_UNORM),
             )
         },
         ColorType::La16 => {
             let raw = img.into_luma_alpha16().into_raw();
             (
-                reinterpret_vec(raw),
+                uninterpret_vec(raw),
                 format.unwrap_or(vk::Format::R16G16_UNORM),
             )
         },
         ColorType::Rgb16 => {
             let raw = img.into_rgb16().into_raw();
             (
-                reinterpret_vec(raw),
+                uninterpret_vec(raw),
                 format.unwrap_or(vk::Format::R16G16B16_UNORM),
             )
         },
         ColorType::Rgba16 => {
             let raw = img.into_rgba16().into_raw();
             (
-                reinterpret_vec(raw),
+                uninterpret_vec(raw),
                 format.unwrap_or(vk::Format::R16G16B16A16_UNORM),
             )
         },
         ColorType::Rgb32F => {
             let raw = img.into_rgb16().into_raw();
             (
-                reinterpret_vec(raw),
+                uninterpret_vec(raw),
                 format.unwrap_or(vk::Format::R32G32B32_SFLOAT),
             )
         },
         ColorType::Rgba32F => {
             let raw = img.into_rgba16().into_raw();
             (
-                reinterpret_vec(raw),
+                uninterpret_vec(raw),
                 format.unwrap_or(vk::Format::R32G32B32A32_SFLOAT),
             )
         },
@@ -151,7 +151,7 @@ pub fn encode(
     Ok(result.into_inner())
 }
 
-fn reinterpret_vec<T>(vec: Vec<T>) -> Vec<u8> {
+fn uninterpret_vec<T>(vec: Vec<T>) -> Vec<u8> {
     let len = vec.len() * std::mem::size_of::<T>();
     let cap = vec.capacity() * std::mem::size_of::<T>();
     let ptr = vec.as_ptr() as *mut u8;

From 1eaabd2e6c4e939fbe162582452d00cb47e0f671 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Sat, 3 Jun 2023 13:47:31 +0200
Subject: [PATCH 14/19] Add CpuTexture2D.FromTexture2D method

---
 NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs | 14 ++++++++++++++
 NoiseEngine/Rendering/CpuTexture2D.cs           | 14 ++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
index b4962cb5..7eb6ae45 100644
--- a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
+++ b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
@@ -51,8 +51,22 @@ public class CpuTexture2DTest : GraphicsTestEnvironment {
         } else {
             Assert.Equal(expected, texture.Data.ToArray());
         }
+    }
+
+    [Fact]
+    public void FromTexture2D() {
+        byte[] fileData = File.ReadAllBytes("./Resources/Textures/colors.png");
+        CpuTexture2D expected = CpuTexture2D.FromFile(fileData, TextureFormat.R8G8B8A8_SRGB);
 
+        foreach (GraphicsDevice device in GraphicsDevices) {
+            Texture2D texture2D = expected.ToTexture2D(device, TextureUsage.TransferAll);
+            CpuTexture2D actual = CpuTexture2D.FromTexture2D(texture2D);
 
+            Assert.Equal(expected.Width, actual.Width);
+            Assert.Equal(expected.Height, actual.Height);
+            Assert.Equal(expected.Format, actual.Format);
+            Assert.Equal(expected.Data.ToArray(), actual.Data.ToArray());
+        }
     }
 
     [Theory]
diff --git a/NoiseEngine/Rendering/CpuTexture2D.cs b/NoiseEngine/Rendering/CpuTexture2D.cs
index 75137583..87b725fe 100644
--- a/NoiseEngine/Rendering/CpuTexture2D.cs
+++ b/NoiseEngine/Rendering/CpuTexture2D.cs
@@ -5,6 +5,7 @@
 using NoiseEngine.Interop.Rendering;
 using NoiseEngine.Mathematics;
 using NoiseEngine.Rendering.Cpu;
+using NoiseEngine.Rendering.Utils;
 
 namespace NoiseEngine.Rendering;
 
@@ -70,6 +71,19 @@ public class CpuTexture2D : CpuTexture {
         return texture;
     }
 
+    /// <summary>
+    /// Creates a <see cref="CpuTexture2D"/> from given <paramref name="texture"/>.
+    /// </summary>
+    /// <param name="texture">Texture to use data from.</param>
+    /// <returns>New <see cref="CpuTexture2D"/>.</returns>
+    public static CpuTexture2D FromTexture2D(Texture2D texture) {
+        InteropArray<byte> buffer = new InteropArray<byte>(
+            (int)texture.Width * (int)texture.Height * TextureFormatUtils.TexelSize(texture.Format));
+
+        texture.GetPixels(buffer.AsSpan());
+        return new CpuTexture2D(buffer, texture.Format, new Vector2<uint>(texture.Width, texture.Height));
+    }
+
     /// <summary>
     /// Converts this <see cref="CpuTexture2D"/> to <see cref="Texture2D"/>.
     /// </summary>

From b208e7ad7bacbe9487312db226fa3bbe3d8b2c14 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Sat, 3 Jun 2023 15:21:46 +0200
Subject: [PATCH 15/19] Fix change request issues

---
 .../src/{rendering => }/encoding.rs           |   8 +-
 .../interop/rendering/cpu_texture_interop.rs  |   9 +-
 .../rendering/{cpu.rs => cpu_texture_2d.rs}   |   0
 .../src/rendering/cpu_texture_2d_encoding.rs  | 244 ++++++++++++++++++
 NoiseEngine.Native/src/rendering/mod.rs       |   4 +-
 .../Rendering/CpuTextureInteropTest.cs        |  14 +-
 NoiseEngine.Tests/NoiseEngine.Tests.csproj    |  14 +-
 .../Rendering/CpuTexture2DTest.cs             |   2 +-
 NoiseEngine/Rendering/Cpu/CpuTextureData.cs   |   9 +-
 .../Rendering/Cpu/TextureFileFormat.cs        |   4 +-
 NoiseEngine/Rendering/CpuTexture2D.cs         |  58 +++--
 NoiseEngine/Rendering/TextureFormat.cs        |   4 +-
 .../Rendering/Utils/TextureFormatUtils.cs     |   8 +-
 13 files changed, 324 insertions(+), 54 deletions(-)
 rename NoiseEngine.Native/src/{rendering => }/encoding.rs (96%)
 rename NoiseEngine.Native/src/rendering/{cpu.rs => cpu_texture_2d.rs} (100%)
 create mode 100644 NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs

diff --git a/NoiseEngine.Native/src/rendering/encoding.rs b/NoiseEngine.Native/src/encoding.rs
similarity index 96%
rename from NoiseEngine.Native/src/rendering/encoding.rs
rename to NoiseEngine.Native/src/encoding.rs
index 5d9f1961..3d9dd97d 100644
--- a/NoiseEngine.Native/src/rendering/encoding.rs
+++ b/NoiseEngine.Native/src/encoding.rs
@@ -1,12 +1,12 @@
 use std::io::Cursor;
 
-use crate::rendering::cpu::CpuTextureData;
+use crate::rendering::cpu_texture_2d::CpuTextureData;
 
 use anyhow::{Result, Context};
 use ash::vk;
 use image::{ImageBuffer, ColorType, DynamicImage};
 
-use super::cpu::{self, TextureFileFormat};
+use super::cpu_texture_2d::{self, TextureFileFormat};
 
 pub fn decode(
     file_data: &[u8],
@@ -18,7 +18,7 @@ pub fn decode(
     let mut img_color = img.color();
 
     if let Some(format) = format {
-        img_color = match cpu::vk_format_to_color_type(format) {
+        img_color = match cpu_texture_2d::vk_format_to_color_type(format) {
             Some(color_type) => color_type,
             None => anyhow::bail!("Unsupported format: {:?}", format),
         };
@@ -116,7 +116,7 @@ pub fn encode(
         "3D textures are not supported"
     );
 
-    let color_type = cpu::vk_format_to_color_type(*texture.format())
+    let color_type = cpu_texture_2d::vk_format_to_color_type(*texture.format())
         .context("Invalid format")?;
 
     let data = texture.data().into();
diff --git a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
index edff7954..ccb2a9e9 100644
--- a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
+++ b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
@@ -7,17 +7,16 @@ use crate::{
         ResultError,
         ResultErrorKind, InteropOption, InteropArray,
     },
-    rendering::{cpu::{CpuTextureData, self}, encoding}
+    rendering::{cpu_texture_2d::{CpuTextureData, self}, cpu_texture_2d_encoding}
 };
 
 #[no_mangle]
 extern "C" fn rendering_cpu_texture_interop_decode(
     file_data: InteropReadOnlySpan<u8>,
     format: InteropOption<vk::Format>,
-
 ) -> InteropResult<CpuTextureData> {
     let result =
-        encoding::decode(file_data.into(), format.into());
+        cpu_texture_2d_encoding::decode(file_data.into(), format.into());
 
     match result {
         Ok(data) => {
@@ -35,11 +34,11 @@ extern "C" fn rendering_cpu_texture_interop_decode(
 #[no_mangle]
 extern "C" fn rendering_cpu_texture_interop_encode(
     data: &CpuTextureData,
-    file_format: cpu::TextureFileFormat,
+    file_format: cpu_texture_2d::TextureFileFormat,
     quality: InteropOption<u8>,
 ) -> InteropResult<InteropArray<u8>> {
     let result =
-        encoding::encode(data, file_format, quality.into());
+        cpu_texture_2d_encoding::encode(data, file_format, quality.into());
 
     match result {
         Ok(data) => {
diff --git a/NoiseEngine.Native/src/rendering/cpu.rs b/NoiseEngine.Native/src/rendering/cpu_texture_2d.rs
similarity index 100%
rename from NoiseEngine.Native/src/rendering/cpu.rs
rename to NoiseEngine.Native/src/rendering/cpu_texture_2d.rs
diff --git a/NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs b/NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs
new file mode 100644
index 00000000..3d9dd97d
--- /dev/null
+++ b/NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs
@@ -0,0 +1,244 @@
+use std::io::Cursor;
+
+use crate::rendering::cpu_texture_2d::CpuTextureData;
+
+use anyhow::{Result, Context};
+use ash::vk;
+use image::{ImageBuffer, ColorType, DynamicImage};
+
+use super::cpu_texture_2d::{self, TextureFileFormat};
+
+pub fn decode(
+    file_data: &[u8],
+    format: Option<vk::Format>,
+) -> Result<CpuTextureData> {
+    let img =
+        image::load_from_memory(file_data)?;
+
+    let mut img_color = img.color();
+
+    if let Some(format) = format {
+        img_color = match cpu_texture_2d::vk_format_to_color_type(format) {
+            Some(color_type) => color_type,
+            None => anyhow::bail!("Unsupported format: {:?}", format),
+        };
+    }
+
+    let width = img.width();
+    let height = img.height();
+
+    let (data, format) = match img_color {
+        ColorType::L8 => {
+            (
+                img.into_luma8().into_raw(),
+                format.unwrap_or(vk::Format::R8_SRGB),
+            )
+        },
+        ColorType::La8 => {
+            (
+                img.into_luma_alpha8().into_raw(),
+                format.unwrap_or(vk::Format::R8G8_SRGB),
+            )
+        },
+        ColorType::Rgb8 => {
+            (
+                img.into_rgb8().into_raw(),
+                format.unwrap_or(vk::Format::R8G8B8_SRGB),
+            )
+        },
+        ColorType::Rgba8 => {
+            (
+                img.into_rgba8().into_raw(),
+                format.unwrap_or(vk::Format::R8G8B8A8_SRGB),
+            )
+        },
+        ColorType::L16 => {
+            let raw = img.into_luma16().into_raw();
+            (
+                uninterpret_vec(raw),
+                format.unwrap_or(vk::Format::R16_UNORM),
+            )
+        },
+        ColorType::La16 => {
+            let raw = img.into_luma_alpha16().into_raw();
+            (
+                uninterpret_vec(raw),
+                format.unwrap_or(vk::Format::R16G16_UNORM),
+            )
+        },
+        ColorType::Rgb16 => {
+            let raw = img.into_rgb16().into_raw();
+            (
+                uninterpret_vec(raw),
+                format.unwrap_or(vk::Format::R16G16B16_UNORM),
+            )
+        },
+        ColorType::Rgba16 => {
+            let raw = img.into_rgba16().into_raw();
+            (
+                uninterpret_vec(raw),
+                format.unwrap_or(vk::Format::R16G16B16A16_UNORM),
+            )
+        },
+        ColorType::Rgb32F => {
+            let raw = img.into_rgb16().into_raw();
+            (
+                uninterpret_vec(raw),
+                format.unwrap_or(vk::Format::R32G32B32_SFLOAT),
+            )
+        },
+        ColorType::Rgba32F => {
+            let raw = img.into_rgba16().into_raw();
+            (
+                uninterpret_vec(raw),
+                format.unwrap_or(vk::Format::R32G32B32A32_SFLOAT),
+            )
+        },
+        _ => anyhow::bail!("Unknown color type: {:?}", img_color),
+    };
+
+    Ok(CpuTextureData::new(
+        width,
+        height,
+        1,
+        format,
+        data.into(),
+    ))
+}
+
+pub fn encode(
+    texture: &CpuTextureData,
+    file_format: TextureFileFormat,
+    quality: Option<u8>,
+) -> Result<Vec<u8>> {
+    anyhow::ensure!(
+        texture.extent_z() == 1,
+        "3D textures are not supported"
+    );
+
+    let color_type = cpu_texture_2d::vk_format_to_color_type(*texture.format())
+        .context("Invalid format")?;
+
+    let data = texture.data().into();
+
+    if let TextureFileFormat::Webp = file_format {
+        return encode_webp(
+            data,
+            texture.extent_x(),
+            texture.extent_y(),
+            color_type,
+            quality,
+        );
+    };
+
+    let mut result = Cursor::new(Vec::new());
+
+    image::write_buffer_with_format(
+        &mut result,
+        data,
+        texture.extent_x(),
+        texture.extent_y(),
+        color_type,
+        match file_format {
+            TextureFileFormat::Png => image::ImageOutputFormat::Png,
+            TextureFileFormat::Jpeg => image::ImageOutputFormat::Jpeg(
+                quality.unwrap_or(75),
+            ),
+            TextureFileFormat::Webp => unreachable!(),
+        },
+    )?;
+
+    Ok(result.into_inner())
+}
+
+fn uninterpret_vec<T>(vec: Vec<T>) -> Vec<u8> {
+    let len = vec.len() * std::mem::size_of::<T>();
+    let cap = vec.capacity() * std::mem::size_of::<T>();
+    let ptr = vec.as_ptr() as *mut u8;
+    std::mem::forget(vec);
+    unsafe { Vec::from_raw_parts(ptr, len, cap) }
+}
+
+fn interpret_vec<T>(vec: Vec<u8>) -> Vec<T> {
+    if vec.len() % std::mem::size_of::<T>() != 0 {
+        panic!("Invalid size");
+    }
+
+    let len = vec.len() / std::mem::size_of::<T>();
+    let cap = vec.capacity() / std::mem::size_of::<T>();
+    let ptr = vec.as_ptr() as *mut T;
+    std::mem::forget(vec);
+    unsafe { Vec::from_raw_parts(ptr, len, cap) }
+}
+
+fn encode_webp(
+    data: &[u8],
+    width: u32,
+    height: u32,
+    color_type: ColorType,
+    quality: Option<u8>,
+) -> Result<Vec<u8>> {
+    let data = data.to_vec();
+
+    match color_type {
+        ColorType::L8 => {
+            encode_webp_helper::<image::Luma<u8>, _>(data, width, height, quality)
+        },
+        ColorType::La8 => {
+            encode_webp_helper::<image::LumaA<u8>, _>(data, width, height, quality)
+        },
+        ColorType::Rgb8 => {
+            encode_webp_helper::<image::Rgb<u8>, _>(data, width, height, quality)
+        },
+        ColorType::Rgba8 => {
+            encode_webp_helper::<image::Rgba<u8>, _>(data, width, height, quality)
+        },
+        ColorType::L16 => {
+            encode_webp_helper::<image::Luma<u16>, _>(data, width, height, quality)
+        },
+        ColorType::La16 => {
+            encode_webp_helper::<image::LumaA<u16>, _>(data, width, height, quality)
+        },
+        ColorType::Rgb16 => {
+            encode_webp_helper::<image::Rgb<u16>, _>(data, width, height, quality)
+        },
+        ColorType::Rgba16 => {
+            encode_webp_helper::<image::Rgba<u16>, _>(data, width, height, quality)
+        },
+        ColorType::Rgb32F => {
+            encode_webp_helper::<image::Rgb<f32>, _>(data, width, height, quality)
+        },
+        ColorType::Rgba32F => {
+            encode_webp_helper::<image::Rgba<f32>, _>(data, width, height, quality)
+        },
+        _ => anyhow::bail!("Unsupported color type {:?}", color_type),
+    }
+}
+
+fn encode_webp_helper<P: image::Pixel<Subpixel = S>, S>(
+    data: Vec<u8>,
+    width: u32,
+    height: u32,
+    quality: Option<u8>,
+) -> Result<Vec<u8>> where DynamicImage: From<ImageBuffer<P, Vec<S>>> {
+    let img = ImageBuffer::<P, Vec<<P as image::Pixel>::Subpixel>>::from_vec(
+        width,
+        height,
+        interpret_vec::<S>(data),
+    ).context("Failed to encode image")?;
+
+    let img = img.into();
+    let encoder = webp::Encoder::from_image(&img);
+
+    let encoder = match encoder {
+        Ok(encoder) => encoder,
+        Err(_) => anyhow::bail!("Failed to encode image")
+    };
+
+    let result = match quality {
+        Some(quality) => encoder.encode(quality as f32),
+        None => encoder.encode_lossless(),
+    };
+
+    Ok(result.to_vec())
+}
diff --git a/NoiseEngine.Native/src/rendering/mod.rs b/NoiseEngine.Native/src/rendering/mod.rs
index d90fdb11..bd2f654a 100644
--- a/NoiseEngine.Native/src/rendering/mod.rs
+++ b/NoiseEngine.Native/src/rendering/mod.rs
@@ -4,7 +4,7 @@ pub mod presentation;
 pub mod vulkan;
 
 pub mod camera_clear;
-pub mod cpu;
-pub mod encoding;
+pub mod cpu_texture_2d;
+pub mod cpu_texture_2d_encoding;
 pub mod fence;
 pub mod texture;
diff --git a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
index 1fd70e1d..936b99ea 100644
--- a/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
+++ b/NoiseEngine.Tests/Interop/Rendering/CpuTextureInteropTest.cs
@@ -30,8 +30,11 @@ public class CpuTextureInteropTest {
         byte[] fileData = File.ReadAllBytes($"./Resources/Textures/{path}");
         InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, format);
 
-        Assert.True(result.IsOk);
-        CpuTextureData data = result.Value;
+        if (!result.IsOk) {
+            result.Error.ThrowAndDispose();
+        }
+
+        using CpuTextureData data = result.Value;
 
         Assert.Equal<uint>(3, data.ExtentX);
         Assert.Equal<uint>(2, data.ExtentY);
@@ -74,6 +77,13 @@ public class CpuTextureInteropTest {
         byte[] fileData = new byte[256];
         Random.Shared.NextBytes(fileData);
         InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, TextureFormat.R8G8B8A8_SRGB);
+
+        if (result.IsOk) {
+            result.Value.Dispose();
+        } else {
+            result.Error.Dispose();
+        }
+
         Assert.False(result.IsOk);
     }
 
diff --git a/NoiseEngine.Tests/NoiseEngine.Tests.csproj b/NoiseEngine.Tests/NoiseEngine.Tests.csproj
index cdf7b4bc..65077f12 100644
--- a/NoiseEngine.Tests/NoiseEngine.Tests.csproj
+++ b/NoiseEngine.Tests/NoiseEngine.Tests.csproj
@@ -34,19 +34,13 @@
     </ItemGroup>
 
     <ItemGroup>
-      <Folder Include="Resources\Textures\" />
+        <Folder Include="Resources\Textures\" />
     </ItemGroup>
 
     <ItemGroup>
-      <None Update="Resources\Textures\colors.png">
-        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      </None>
-      <None Update="Resources\Textures\colors.webp">
-        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      </None>
-      <None Update="Resources\Textures\colors.jpeg">
-        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      </None>
+        <None Update="Resources\**">
+            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+        </None>
     </ItemGroup>
 
     <Import Project="../NoiseEngine.Shared.xml" />
diff --git a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
index 7eb6ae45..6adadde6 100644
--- a/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
+++ b/NoiseEngine.Tests/Rendering/CpuTexture2DTest.cs
@@ -137,7 +137,7 @@ public class CpuTexture2DTest : GraphicsTestEnvironment {
         CpuTexture2D texture = CpuTexture2D.FromFile(fileData, TextureFormat.R8G8B8A8_SRGB);
 
         byte[] expected = texture.Data.ToArray();
-        byte[] actual = CpuTexture2D.FromFile(texture.ToWebp(), TextureFormat.R8G8B8A8_SRGB).Data.ToArray();
+        byte[] actual = CpuTexture2D.FromFile(texture.ToWebP(), TextureFormat.R8G8B8A8_SRGB).Data.ToArray();
 
         Assert.Equal(expected, actual);
     }
diff --git a/NoiseEngine/Rendering/Cpu/CpuTextureData.cs b/NoiseEngine/Rendering/Cpu/CpuTextureData.cs
index d2875afa..79dd2ae0 100644
--- a/NoiseEngine/Rendering/Cpu/CpuTextureData.cs
+++ b/NoiseEngine/Rendering/Cpu/CpuTextureData.cs
@@ -1,10 +1,11 @@
-using System.Runtime.InteropServices;
+using System;
+using System.Runtime.InteropServices;
 using NoiseEngine.Interop;
 
 namespace NoiseEngine.Rendering.Cpu;
 
 [StructLayout(LayoutKind.Sequential)]
-internal struct CpuTextureData {
+internal readonly struct CpuTextureData : IDisposable {
 
     public uint ExtentX { get; init; }
     public uint ExtentY { get; init; }
@@ -12,4 +13,8 @@ internal struct CpuTextureData {
     public TextureFormat Format { get; init; }
     public InteropArray<byte> Data { get; init; }
 
+    public void Dispose() {
+        Data.Dispose();
+    }
+
 }
diff --git a/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs b/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs
index 0d815364..7a79b253 100644
--- a/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs
+++ b/NoiseEngine/Rendering/Cpu/TextureFileFormat.cs
@@ -1,7 +1,7 @@
-namespace NoiseEngine.Rendering.Cpu; 
+namespace NoiseEngine.Rendering.Cpu;
 
 public enum TextureFileFormat {
     Png,
     Jpeg,
-    Webp
+    WebP
 }
diff --git a/NoiseEngine/Rendering/CpuTexture2D.cs b/NoiseEngine/Rendering/CpuTexture2D.cs
index 87b725fe..292adf1c 100644
--- a/NoiseEngine/Rendering/CpuTexture2D.cs
+++ b/NoiseEngine/Rendering/CpuTexture2D.cs
@@ -11,7 +11,7 @@ namespace NoiseEngine.Rendering;
 
 public class CpuTexture2D : CpuTexture {
 
-    private readonly InteropArray<byte> data;
+    private readonly byte[] data;
 
     public uint Width => Extent.X;
     public uint Height => Extent.Y;
@@ -19,11 +19,11 @@ public class CpuTexture2D : CpuTexture {
     /// <summary>
     /// Data of the image in row-major order (index = x + Size.X * y).
     /// </summary>
-    public override Span<byte> Data => data.AsSpan();
+    public override Span<byte> Data => data;
 
     internal override Vector3<uint> Extent { get; }
 
-    private CpuTexture2D(InteropArray<byte> data, TextureFormat format, Vector2<uint> size) : base(format) {
+    private CpuTexture2D(byte[] data, TextureFormat format, Vector2<uint> size) : base(format) {
         this.data = data;
         Extent = new Vector3<uint>(size.X, size.Y, 1);
     }
@@ -43,13 +43,18 @@ public class CpuTexture2D : CpuTexture {
     ) {
         InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, format);
 
-        if (!result.TryGetValue(out CpuTextureData data, out _)) {
+        if (!result.TryGetValue(out CpuTextureData data, out ResultError error)) {
+            error.Dispose();
             texture = null;
             return false;
         }
 
         Debug.Assert(data.ExtentZ == 1);
-        texture = new CpuTexture2D(data.Data, data.Format, new Vector2<uint>(data.ExtentX, data.ExtentY));
+        texture = new CpuTexture2D(
+            data.Data.AsSpan().ToArray(),
+            data.Format,
+            new Vector2<uint>(data.ExtentX, data.ExtentY));
+        data.Dispose();
         return true;
     }
 
@@ -65,9 +70,18 @@ public class CpuTexture2D : CpuTexture {
         ReadOnlySpan<byte> fileData,
         TextureFormat? format = null
     ) {
-        if (!TryFromFile(fileData, out CpuTexture2D? texture, format))
-            throw new ArgumentException("Cannot decode texture from given file data.", nameof(fileData));
+        InteropResult<CpuTextureData> result = CpuTextureInterop.Decode(fileData, format);
+
+        if (!result.TryGetValue(out CpuTextureData data, out ResultError error)) {
+            error.ThrowAndDispose();
+        }
 
+        Debug.Assert(data.ExtentZ == 1);
+        CpuTexture2D texture = new CpuTexture2D(
+            data.Data.AsSpan().ToArray(),
+            data.Format,
+            new Vector2<uint>(data.ExtentX, data.ExtentY));
+        data.Dispose();
         return texture;
     }
 
@@ -77,8 +91,8 @@ public class CpuTexture2D : CpuTexture {
     /// <param name="texture">Texture to use data from.</param>
     /// <returns>New <see cref="CpuTexture2D"/>.</returns>
     public static CpuTexture2D FromTexture2D(Texture2D texture) {
-        InteropArray<byte> buffer = new InteropArray<byte>(
-            (int)texture.Width * (int)texture.Height * TextureFormatUtils.TexelSize(texture.Format));
+        byte[] buffer =
+            new byte[(int)texture.Width * (int)texture.Height * TextureFormatUtils.TexelSize(texture.Format)];
 
         texture.GetPixels(buffer.AsSpan());
         return new CpuTexture2D(buffer, texture.Format, new Vector2<uint>(texture.Width, texture.Height));
@@ -115,35 +129,35 @@ public class CpuTexture2D : CpuTexture {
     }
 
     /// <summary>
-    /// Creates a PNG file from this <see cref="CpuTexture2D"/>.
+    /// Creates a PNG file data from this <see cref="CpuTexture2D"/>.
     /// </summary>
     /// <returns>File data.</returns>
     public byte[] ToPng() {
-        return ToFile(TextureFileFormat.Png);
+        return ToFileData(TextureFileFormat.Png);
     }
 
     /// <summary>
-    /// Creates a JPEG file from this <see cref="CpuTexture2D"/>.
+    /// Creates a JPEG file data from this <see cref="CpuTexture2D"/>.
     /// </summary>
     /// <param name="quality">Quality of the compression between 0 and 100.</param>
     /// <returns>File data.</returns>
     public byte[] ToJpeg(byte quality = 75) {
-        return ToFile(TextureFileFormat.Jpeg, quality);
+        return ToFileData(TextureFileFormat.Jpeg, quality);
     }
 
     /// <summary>
-    /// Creates a WebP file from this <see cref="CpuTexture2D"/>.
+    /// Creates a WebP file data from this <see cref="CpuTexture2D"/>.
     /// </summary>
     /// <param name="quality">
     /// Quality of the compression between 0 and 100.
     /// Value of null is lossless compression.
     /// </param>
     /// <returns>File data.</returns>
-    public byte[] ToWebp(byte? quality = null) {
-        return ToFile(TextureFileFormat.Webp, quality);
+    public byte[] ToWebP(byte? quality = null) {
+        return ToFileData(TextureFileFormat.WebP, quality);
     }
 
-    private byte[] ToFile(TextureFileFormat format, byte? quality = null) {
+    private byte[] ToFileData(TextureFileFormat format, byte? quality = null) {
         if (format == TextureFileFormat.Png && quality != null) {
             throw new ArgumentException("PNG does not support quality settings.", nameof(quality));
         }
@@ -153,7 +167,7 @@ public class CpuTexture2D : CpuTexture {
         }
 
         CpuTextureData data = new CpuTextureData {
-            Data = this.data,
+            Data = new InteropArray<byte>(this.data),
             Format = Format,
             ExtentX = Extent.X,
             ExtentY = Extent.Y,
@@ -162,11 +176,13 @@ public class CpuTexture2D : CpuTexture {
 
         InteropResult<InteropArray<byte>> result = CpuTextureInterop.Encode(in data, format, quality);
 
-        if (result.TryGetValue(out InteropArray<byte> encoded, out ResultError error)) {
-            return encoded.AsSpan().ToArray();
+        if (!result.TryGetValue(out InteropArray<byte> encoded, out ResultError error)) {
+            error.ThrowAndDispose();
         }
 
-        throw error.ToException();
+        byte[] resultArray = encoded.AsSpan().ToArray();
+        encoded.Dispose();
+        return resultArray;
     }
 
 }
diff --git a/NoiseEngine/Rendering/TextureFormat.cs b/NoiseEngine/Rendering/TextureFormat.cs
index 9c41c71a..be02d518 100644
--- a/NoiseEngine/Rendering/TextureFormat.cs
+++ b/NoiseEngine/Rendering/TextureFormat.cs
@@ -1,7 +1,6 @@
 namespace NoiseEngine.Rendering;
 
 public enum TextureFormat : uint {
-
     R8_UNORM = 9,
     R8_SRGB = 15,
     R8G8_UNORM = 16,
@@ -14,6 +13,7 @@ public enum TextureFormat : uint {
     R16G16_UNORM = 77,
     R16G16B16_UNORM = 84,
     R16G16B16A16_UNORM = 91,
-
+    R32G32B32_SFLOAT = 106,
+    R32G32B32A32_SFLOAT = 109,
     D32_SFloat = 126
 }
diff --git a/NoiseEngine/Rendering/Utils/TextureFormatUtils.cs b/NoiseEngine/Rendering/Utils/TextureFormatUtils.cs
index 1f479e0b..e6db232b 100644
--- a/NoiseEngine/Rendering/Utils/TextureFormatUtils.cs
+++ b/NoiseEngine/Rendering/Utils/TextureFormatUtils.cs
@@ -1,11 +1,11 @@
 using System;
 
-namespace NoiseEngine.Rendering.Utils; 
+namespace NoiseEngine.Rendering.Utils;
 
 public static class TextureFormatUtils {
 
     /// <summary>
-    ///   Returns the size of a texel in bytes for the given <paramref name="format"/>.
+    /// Returns the size of a texel in bytes for the given <paramref name="format"/>.
     /// </summary>
     /// <param name="format">Format of the texture.</param>
     /// <returns>Size of a single texel in bytes.</returns>
@@ -24,9 +24,11 @@ public static class TextureFormatUtils {
             TextureFormat.R16G16_UNORM => sizeof(ushort) * 2,
             TextureFormat.R16G16B16_UNORM => sizeof(ushort) * 3,
             TextureFormat.R16G16B16A16_UNORM => sizeof(ushort) * 4,
+            TextureFormat.R32G32B32_SFLOAT => sizeof(float) * 3,
+            TextureFormat.R32G32B32A32_SFLOAT => sizeof(float) * 4,
             TextureFormat.D32_SFloat => sizeof(float) * 1,
             _ => throw new ArgumentOutOfRangeException(nameof(format), format, null)
         };
     }
-    
+
 }

From 16e5f75f4b5ef2258a0e5d3ed92d0025f33be768 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Sat, 3 Jun 2023 15:29:40 +0200
Subject: [PATCH 16/19] Remove invalid file

---
 NoiseEngine.Native/src/encoding.rs | 244 -----------------------------
 1 file changed, 244 deletions(-)
 delete mode 100644 NoiseEngine.Native/src/encoding.rs

diff --git a/NoiseEngine.Native/src/encoding.rs b/NoiseEngine.Native/src/encoding.rs
deleted file mode 100644
index 3d9dd97d..00000000
--- a/NoiseEngine.Native/src/encoding.rs
+++ /dev/null
@@ -1,244 +0,0 @@
-use std::io::Cursor;
-
-use crate::rendering::cpu_texture_2d::CpuTextureData;
-
-use anyhow::{Result, Context};
-use ash::vk;
-use image::{ImageBuffer, ColorType, DynamicImage};
-
-use super::cpu_texture_2d::{self, TextureFileFormat};
-
-pub fn decode(
-    file_data: &[u8],
-    format: Option<vk::Format>,
-) -> Result<CpuTextureData> {
-    let img =
-        image::load_from_memory(file_data)?;
-
-    let mut img_color = img.color();
-
-    if let Some(format) = format {
-        img_color = match cpu_texture_2d::vk_format_to_color_type(format) {
-            Some(color_type) => color_type,
-            None => anyhow::bail!("Unsupported format: {:?}", format),
-        };
-    }
-
-    let width = img.width();
-    let height = img.height();
-
-    let (data, format) = match img_color {
-        ColorType::L8 => {
-            (
-                img.into_luma8().into_raw(),
-                format.unwrap_or(vk::Format::R8_SRGB),
-            )
-        },
-        ColorType::La8 => {
-            (
-                img.into_luma_alpha8().into_raw(),
-                format.unwrap_or(vk::Format::R8G8_SRGB),
-            )
-        },
-        ColorType::Rgb8 => {
-            (
-                img.into_rgb8().into_raw(),
-                format.unwrap_or(vk::Format::R8G8B8_SRGB),
-            )
-        },
-        ColorType::Rgba8 => {
-            (
-                img.into_rgba8().into_raw(),
-                format.unwrap_or(vk::Format::R8G8B8A8_SRGB),
-            )
-        },
-        ColorType::L16 => {
-            let raw = img.into_luma16().into_raw();
-            (
-                uninterpret_vec(raw),
-                format.unwrap_or(vk::Format::R16_UNORM),
-            )
-        },
-        ColorType::La16 => {
-            let raw = img.into_luma_alpha16().into_raw();
-            (
-                uninterpret_vec(raw),
-                format.unwrap_or(vk::Format::R16G16_UNORM),
-            )
-        },
-        ColorType::Rgb16 => {
-            let raw = img.into_rgb16().into_raw();
-            (
-                uninterpret_vec(raw),
-                format.unwrap_or(vk::Format::R16G16B16_UNORM),
-            )
-        },
-        ColorType::Rgba16 => {
-            let raw = img.into_rgba16().into_raw();
-            (
-                uninterpret_vec(raw),
-                format.unwrap_or(vk::Format::R16G16B16A16_UNORM),
-            )
-        },
-        ColorType::Rgb32F => {
-            let raw = img.into_rgb16().into_raw();
-            (
-                uninterpret_vec(raw),
-                format.unwrap_or(vk::Format::R32G32B32_SFLOAT),
-            )
-        },
-        ColorType::Rgba32F => {
-            let raw = img.into_rgba16().into_raw();
-            (
-                uninterpret_vec(raw),
-                format.unwrap_or(vk::Format::R32G32B32A32_SFLOAT),
-            )
-        },
-        _ => anyhow::bail!("Unknown color type: {:?}", img_color),
-    };
-
-    Ok(CpuTextureData::new(
-        width,
-        height,
-        1,
-        format,
-        data.into(),
-    ))
-}
-
-pub fn encode(
-    texture: &CpuTextureData,
-    file_format: TextureFileFormat,
-    quality: Option<u8>,
-) -> Result<Vec<u8>> {
-    anyhow::ensure!(
-        texture.extent_z() == 1,
-        "3D textures are not supported"
-    );
-
-    let color_type = cpu_texture_2d::vk_format_to_color_type(*texture.format())
-        .context("Invalid format")?;
-
-    let data = texture.data().into();
-
-    if let TextureFileFormat::Webp = file_format {
-        return encode_webp(
-            data,
-            texture.extent_x(),
-            texture.extent_y(),
-            color_type,
-            quality,
-        );
-    };
-
-    let mut result = Cursor::new(Vec::new());
-
-    image::write_buffer_with_format(
-        &mut result,
-        data,
-        texture.extent_x(),
-        texture.extent_y(),
-        color_type,
-        match file_format {
-            TextureFileFormat::Png => image::ImageOutputFormat::Png,
-            TextureFileFormat::Jpeg => image::ImageOutputFormat::Jpeg(
-                quality.unwrap_or(75),
-            ),
-            TextureFileFormat::Webp => unreachable!(),
-        },
-    )?;
-
-    Ok(result.into_inner())
-}
-
-fn uninterpret_vec<T>(vec: Vec<T>) -> Vec<u8> {
-    let len = vec.len() * std::mem::size_of::<T>();
-    let cap = vec.capacity() * std::mem::size_of::<T>();
-    let ptr = vec.as_ptr() as *mut u8;
-    std::mem::forget(vec);
-    unsafe { Vec::from_raw_parts(ptr, len, cap) }
-}
-
-fn interpret_vec<T>(vec: Vec<u8>) -> Vec<T> {
-    if vec.len() % std::mem::size_of::<T>() != 0 {
-        panic!("Invalid size");
-    }
-
-    let len = vec.len() / std::mem::size_of::<T>();
-    let cap = vec.capacity() / std::mem::size_of::<T>();
-    let ptr = vec.as_ptr() as *mut T;
-    std::mem::forget(vec);
-    unsafe { Vec::from_raw_parts(ptr, len, cap) }
-}
-
-fn encode_webp(
-    data: &[u8],
-    width: u32,
-    height: u32,
-    color_type: ColorType,
-    quality: Option<u8>,
-) -> Result<Vec<u8>> {
-    let data = data.to_vec();
-
-    match color_type {
-        ColorType::L8 => {
-            encode_webp_helper::<image::Luma<u8>, _>(data, width, height, quality)
-        },
-        ColorType::La8 => {
-            encode_webp_helper::<image::LumaA<u8>, _>(data, width, height, quality)
-        },
-        ColorType::Rgb8 => {
-            encode_webp_helper::<image::Rgb<u8>, _>(data, width, height, quality)
-        },
-        ColorType::Rgba8 => {
-            encode_webp_helper::<image::Rgba<u8>, _>(data, width, height, quality)
-        },
-        ColorType::L16 => {
-            encode_webp_helper::<image::Luma<u16>, _>(data, width, height, quality)
-        },
-        ColorType::La16 => {
-            encode_webp_helper::<image::LumaA<u16>, _>(data, width, height, quality)
-        },
-        ColorType::Rgb16 => {
-            encode_webp_helper::<image::Rgb<u16>, _>(data, width, height, quality)
-        },
-        ColorType::Rgba16 => {
-            encode_webp_helper::<image::Rgba<u16>, _>(data, width, height, quality)
-        },
-        ColorType::Rgb32F => {
-            encode_webp_helper::<image::Rgb<f32>, _>(data, width, height, quality)
-        },
-        ColorType::Rgba32F => {
-            encode_webp_helper::<image::Rgba<f32>, _>(data, width, height, quality)
-        },
-        _ => anyhow::bail!("Unsupported color type {:?}", color_type),
-    }
-}
-
-fn encode_webp_helper<P: image::Pixel<Subpixel = S>, S>(
-    data: Vec<u8>,
-    width: u32,
-    height: u32,
-    quality: Option<u8>,
-) -> Result<Vec<u8>> where DynamicImage: From<ImageBuffer<P, Vec<S>>> {
-    let img = ImageBuffer::<P, Vec<<P as image::Pixel>::Subpixel>>::from_vec(
-        width,
-        height,
-        interpret_vec::<S>(data),
-    ).context("Failed to encode image")?;
-
-    let img = img.into();
-    let encoder = webp::Encoder::from_image(&img);
-
-    let encoder = match encoder {
-        Ok(encoder) => encoder,
-        Err(_) => anyhow::bail!("Failed to encode image")
-    };
-
-    let result = match quality {
-        Some(quality) => encoder.encode(quality as f32),
-        None => encoder.encode_lossless(),
-    };
-
-    Ok(result.to_vec())
-}

From 9fefaac8f6bbd5ee1a40508a172186327a944081 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Sat, 3 Jun 2023 17:39:02 +0200
Subject: [PATCH 17/19] Fix change request issues

---
 .../interop/rendering/cpu_texture_interop.rs  | 15 ++++++++--
 .../src/rendering/cpu_texture_2d_encoding.rs  | 22 ++++++--------
 .../Interop/Rendering/CpuTextureInterop.cs    |  9 ++++--
 NoiseEngine/Rendering/CpuTexture2D.cs         | 15 +++-------
 NoiseEngine/Rendering/Texture2D.cs            | 29 +++++++++++++++++++
 5 files changed, 60 insertions(+), 30 deletions(-)

diff --git a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
index ccb2a9e9..1cc63e4b 100644
--- a/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
+++ b/NoiseEngine.Native/src/interop/rendering/cpu_texture_interop.rs
@@ -33,12 +33,21 @@ extern "C" fn rendering_cpu_texture_interop_decode(
 
 #[no_mangle]
 extern "C" fn rendering_cpu_texture_interop_encode(
-    data: &CpuTextureData,
+    data: InteropReadOnlySpan<u8>,
+    width: u32,
+    height: u32,
+    format: vk::Format,
     file_format: cpu_texture_2d::TextureFileFormat,
     quality: InteropOption<u8>,
 ) -> InteropResult<InteropArray<u8>> {
-    let result =
-        cpu_texture_2d_encoding::encode(data, file_format, quality.into());
+    let result = cpu_texture_2d_encoding::encode(
+        data.into(),
+        width,
+        height,
+        format,
+        file_format,
+        quality.into(),
+    );
 
     match result {
         Ok(data) => {
diff --git a/NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs b/NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs
index 3d9dd97d..d32c8d67 100644
--- a/NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs
+++ b/NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs
@@ -107,25 +107,21 @@ pub fn decode(
 }
 
 pub fn encode(
-    texture: &CpuTextureData,
+    data: &[u8],
+    width: u32,
+    height: u32,
+    format: vk::Format,
     file_format: TextureFileFormat,
     quality: Option<u8>,
 ) -> Result<Vec<u8>> {
-    anyhow::ensure!(
-        texture.extent_z() == 1,
-        "3D textures are not supported"
-    );
-
-    let color_type = cpu_texture_2d::vk_format_to_color_type(*texture.format())
+    let color_type = cpu_texture_2d::vk_format_to_color_type(format)
         .context("Invalid format")?;
 
-    let data = texture.data().into();
-
     if let TextureFileFormat::Webp = file_format {
         return encode_webp(
             data,
-            texture.extent_x(),
-            texture.extent_y(),
+            width,
+            height,
             color_type,
             quality,
         );
@@ -136,8 +132,8 @@ pub fn encode(
     image::write_buffer_with_format(
         &mut result,
         data,
-        texture.extent_x(),
-        texture.extent_y(),
+        width,
+        height,
         color_type,
         match file_format {
             TextureFileFormat::Png => image::ImageOutputFormat::Png,
diff --git a/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
index a8f2a62d..60a69088 100644
--- a/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
+++ b/NoiseEngine/Interop/Rendering/CpuTextureInterop.cs
@@ -11,11 +11,14 @@ internal static partial class CpuTextureInterop {
         ReadOnlySpan<byte> fileData,
         InteropOption<TextureFormat> format
     );
-    
+
     [InteropImport("rendering_cpu_texture_interop_encode")]
     public static partial InteropResult<InteropArray<byte>> Encode(
-        in CpuTextureData data,
-        TextureFileFormat format,
+        ReadOnlySpan<byte> data,
+        uint width,
+        uint height,
+        TextureFormat format,
+        TextureFileFormat fileFormat,
         InteropOption<byte> quality
     );
 
diff --git a/NoiseEngine/Rendering/CpuTexture2D.cs b/NoiseEngine/Rendering/CpuTexture2D.cs
index 292adf1c..abaa763b 100644
--- a/NoiseEngine/Rendering/CpuTexture2D.cs
+++ b/NoiseEngine/Rendering/CpuTexture2D.cs
@@ -157,8 +157,8 @@ public class CpuTexture2D : CpuTexture {
         return ToFileData(TextureFileFormat.WebP, quality);
     }
 
-    private byte[] ToFileData(TextureFileFormat format, byte? quality = null) {
-        if (format == TextureFileFormat.Png && quality != null) {
+    private byte[] ToFileData(TextureFileFormat fileFormat, byte? quality = null) {
+        if (fileFormat == TextureFileFormat.Png && quality != null) {
             throw new ArgumentException("PNG does not support quality settings.", nameof(quality));
         }
 
@@ -166,15 +166,8 @@ public class CpuTexture2D : CpuTexture {
             quality = 100;
         }
 
-        CpuTextureData data = new CpuTextureData {
-            Data = new InteropArray<byte>(this.data),
-            Format = Format,
-            ExtentX = Extent.X,
-            ExtentY = Extent.Y,
-            ExtentZ = 1
-        };
-
-        InteropResult<InteropArray<byte>> result = CpuTextureInterop.Encode(in data, format, quality);
+        InteropResult<InteropArray<byte>> result =
+            CpuTextureInterop.Encode(data, Width, Height, Format, fileFormat, quality);
 
         if (!result.TryGetValue(out InteropArray<byte> encoded, out ResultError error)) {
             error.ThrowAndDispose();
diff --git a/NoiseEngine/Rendering/Texture2D.cs b/NoiseEngine/Rendering/Texture2D.cs
index fd097600..b91a22f1 100644
--- a/NoiseEngine/Rendering/Texture2D.cs
+++ b/NoiseEngine/Rendering/Texture2D.cs
@@ -30,4 +30,33 @@ public class Texture2D : Texture {
         SampleCount = sampleCount;
     }
 
+    /// <summary>
+    /// Creates a PNG file data from this <see cref="Texture2D"/>.
+    /// </summary>
+    /// <returns>File data.</returns>
+    public byte[] ToPng() {
+        return CpuTexture2D.FromTexture2D(this).ToPng();
+    }
+
+    /// <summary>
+    /// Creates a JPEG file data from this <see cref="Texture2D"/>.
+    /// </summary>
+    /// <param name="quality">Quality of the compression between 0 and 100.</param>
+    /// <returns>File data.</returns>
+    public byte[] ToJpeg(byte quality = 75) {
+        return CpuTexture2D.FromTexture2D(this).ToJpeg(quality);
+    }
+
+    /// <summary>
+    /// Creates a WebP file data from this <see cref="Texture2D"/>.
+    /// </summary>
+    /// <param name="quality">
+    /// Quality of the compression between 0 and 100.
+    /// Value of null is lossless compression.
+    /// </param>
+    /// <returns>File data.</returns>
+    public byte[] ToWebP(byte? quality = null) {
+        return CpuTexture2D.FromTexture2D(this).ToWebP(quality);
+    }
+
 }

From 54f0557bb3890d9281127980e65b906c56164168 Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Sat, 3 Jun 2023 19:51:43 +0200
Subject: [PATCH 18/19] Fix change request issues

---
 NoiseEngine/Rendering/Texture2D.cs | 35 +++++++++++++++++++++++++++++-
 1 file changed, 34 insertions(+), 1 deletion(-)

diff --git a/NoiseEngine/Rendering/Texture2D.cs b/NoiseEngine/Rendering/Texture2D.cs
index b91a22f1..58da2bda 100644
--- a/NoiseEngine/Rendering/Texture2D.cs
+++ b/NoiseEngine/Rendering/Texture2D.cs
@@ -1,4 +1,5 @@
-using NoiseEngine.Interop;
+using System;
+using NoiseEngine.Interop;
 using NoiseEngine.Mathematics;
 using NoiseEngine.Rendering.Vulkan;
 
@@ -30,6 +31,38 @@ public class Texture2D : Texture {
         SampleCount = sampleCount;
     }
 
+    /// <summary>
+    /// Decodes given <paramref name="fileData"/> to <see cref="CpuTexture2D"/>.
+    /// Makes an educated guess about file format.
+    /// </summary>
+    /// <param name="fileData">File data.</param>
+    /// <param name="device"><see cref="GraphicsDevice"/> to use.</param>
+    /// <param name="usage">
+    /// Texture usage flags. Must contain <see cref="TextureUsage.TransferDestination"/> flag
+    /// to allow for copying CPU data into it.
+    /// </param>
+    /// <param name="format">Target format for the texture. Null tries to use the format of the file.</param>
+    /// <param name="mipLevels">Mipmap levels.</param>
+    /// <param name="linear">Use linear memory layout instead of optimal.</param>
+    /// <param name="sampleCount">Samples per texel.</param>
+    /// <returns>Created <see cref="Texture2D"/>.</returns>
+    /// <returns>Result texture.</returns>
+    /// <exception cref="InvalidOperationException">
+    /// <paramref name="usage"/> does not have a <see cref="TextureUsage.TransferDestination"/> flag.
+    /// </exception>
+    /// <exception cref="ArgumentException">Throws if decoding file data fails.</exception>
+    public static Texture2D FromFile(
+        ReadOnlySpan<byte> fileData,
+        GraphicsDevice device,
+        TextureUsage usage,
+        TextureFormat? format = null,
+        uint mipLevels = 1,
+        bool linear = false,
+        uint sampleCount = 1
+    ) {
+        return CpuTexture2D.FromFile(fileData, format).ToTexture2D(device, usage, mipLevels, linear, sampleCount);
+    }
+
     /// <summary>
     /// Creates a PNG file data from this <see cref="Texture2D"/>.
     /// </summary>

From 80c0b80be98c7be6fe5894fe8186687c6e4c122d Mon Sep 17 00:00:00 2001
From: kkard2 <kkard2.acct@gmail.com>
Date: Sat, 3 Jun 2023 19:53:39 +0200
Subject: [PATCH 19/19] Fix change request issue

---
 NoiseEngine.Native/src/rendering/cpu_texture_2d.rs          | 2 +-
 NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/NoiseEngine.Native/src/rendering/cpu_texture_2d.rs b/NoiseEngine.Native/src/rendering/cpu_texture_2d.rs
index 986c3bbb..39b5a54e 100644
--- a/NoiseEngine.Native/src/rendering/cpu_texture_2d.rs
+++ b/NoiseEngine.Native/src/rendering/cpu_texture_2d.rs
@@ -6,7 +6,7 @@ use crate::interop::prelude::InteropArray;
 pub enum TextureFileFormat {
     Png,
     Jpeg,
-    Webp
+    WebP
 }
 
 pub fn vk_format_to_color_type(
diff --git a/NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs b/NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs
index d32c8d67..e47d9e66 100644
--- a/NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs
+++ b/NoiseEngine.Native/src/rendering/cpu_texture_2d_encoding.rs
@@ -117,7 +117,7 @@ pub fn encode(
     let color_type = cpu_texture_2d::vk_format_to_color_type(format)
         .context("Invalid format")?;
 
-    if let TextureFileFormat::Webp = file_format {
+    if let TextureFileFormat::WebP = file_format {
         return encode_webp(
             data,
             width,
@@ -140,7 +140,7 @@ pub fn encode(
             TextureFileFormat::Jpeg => image::ImageOutputFormat::Jpeg(
                 quality.unwrap_or(75),
             ),
-            TextureFileFormat::Webp => unreachable!(),
+            TextureFileFormat::WebP => unreachable!(),
         },
     )?;