texture: First image load

src/core/render/texture.rs

@@ -0,0 +1,113 @@
+use std::{path::Path, sync::Arc};
+
+use anyhow::Error;
+use image::{DynamicImage, EncodableLayout};
+use vulkano::{
+    buffer::{Buffer, BufferCreateInfo, BufferUsage},
+    command_buffer::{AutoCommandBufferBuilder, CopyBufferToImageInfo, PrimaryAutoCommandBuffer},
+    device::Device,
+    format::Format,
+    image::{
+        Image, ImageCreateInfo, ImageType, ImageUsage,
+        sampler::{Filter, Sampler, SamplerAddressMode, SamplerCreateInfo},
+        view::ImageView,
+    },
+    memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
+};
+
+pub struct Texture {
+    texture: Arc<ImageView>,
+    sampler: Arc<Sampler>,
+}
+
+impl Texture {
+    fn new(texture: Arc<ImageView>, sampler: Arc<Sampler>) -> Self {
+        Self { texture, sampler }
+    }
+
+    pub fn from_file(
+        device: &Arc<Device>,
+        memory_allocator: &Arc<StandardMemoryAllocator>,
+        builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>,
+        path: &str,
+    ) -> Result<Self, Error> {
+        let image = image::open(path)?;
+        Self::from_dynamic_image(device, memory_allocator, builder, image)
+    }
+
+    pub fn from_bytes(
+        device: &Arc<Device>,
+        memory_allocator: &Arc<StandardMemoryAllocator>,
+        builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>,
+        bytes: &[u8],
+    ) -> Result<Self, Error> {
+        let image = image::load_from_memory(bytes)?;
+        Self::from_dynamic_image(device, memory_allocator, builder, image)
+    }
+
+    pub fn from_dynamic_image(
+        device: &Arc<Device>,
+        memory_allocator: &Arc<StandardMemoryAllocator>,
+        builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>,
+        image: DynamicImage,
+    ) -> Result<Self, Error> {
+        let image_data = image.to_rgba8();
+        let image_dimensions = image_data.dimensions();
+
+        let upload_buffer = Buffer::from_iter(
+            memory_allocator.clone(),
+            BufferCreateInfo {
+                usage: BufferUsage::TRANSFER_SRC,
+                ..Default::default()
+            },
+            AllocationCreateInfo {
+                memory_type_filter: MemoryTypeFilter::PREFER_HOST
+                    | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+                ..Default::default()
+            },
+            image_data.to_vec(),
+        )?;
+
+        let image = Image::new(
+            memory_allocator.clone(),
+            ImageCreateInfo {
+                image_type: ImageType::Dim2d,
+                format: Format::R8G8B8A8_SRGB,
+                extent: [image_dimensions.0 as u32, image_dimensions.1 as u32, 1],
+                array_layers: 1,
+                usage: ImageUsage::TRANSFER_DST | ImageUsage::SAMPLED,
+                ..Default::default()
+            },
+            AllocationCreateInfo::default(),
+        )?;
+
+        builder.copy_buffer_to_image(CopyBufferToImageInfo::buffer_image(
+            upload_buffer,
+            image.clone(),
+        ))?;
+
+        let sampler = Sampler::new(
+            device.clone(),
+            SamplerCreateInfo {
+                mag_filter: Filter::Linear,
+                min_filter: Filter::Linear,
+                address_mode: [SamplerAddressMode::Repeat; 3],
+                ..Default::default()
+            },
+        )?;
+
+        let image_view = ImageView::new_default(image)?;
+
+        log::trace!("Texture loaded with dimensions {:?}", image_dimensions);
+
+        Ok(Self::new(image_view, sampler))
+    }
+
+    pub fn get_texture(&self) -> &Arc<ImageView> {
+        &self.texture
+    }
+
+    pub fn get_sampler(&self) -> &Arc<Sampler> {
+        &self.sampler
+    }
+}