[render] split texture into another module

Author: ARessegetesStery

crates/eqx_core/src/util_macros.rs

@@ -1,18 +1,18 @@
 #[macro_export]
-macro_rules! shader_src {
-    ($path:literal) => {
-        include_str!(concat!(
+macro_rules! shader_src_from {
+    ($path:expr) => {{
+        let path = format!(
+            "{}/../../shaders/{}.wgsl",
             env!("CARGO_MANIFEST_DIR"),
-            "/../../shaders/",
-            $path,
-            ".wgsl"
-        ))
-    };
+            $path
+        );
+        std::fs::read_to_string(path).unwrap()
+    }};
 }
 
 #[macro_export]
-macro_rules! asset_file {
-    ($path:literal) => {
-        include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/", $path))
+macro_rules! asset_file_path {
+    ($path:expr) => {
+        format!("{}/../../assets/{}", env!("CARGO_MANIFEST_DIR"), $path)
     };
 }

crates/eqx_window/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+anyhow = "1.0"
 bytemuck = { version = "1.22", features = ["derive"] }
 eqx_core = { path = "../eqx_core", version = "0.1.0" }
 cgmath = "0.18"

crates/eqx_window/src/lib.rs

@@ -1,4 +1,5 @@
 mod primitives;
+mod texture;
 mod window;
 
 pub mod prelude {

crates/eqx_window/src/texture.rs

@@ -0,0 +1,71 @@
+use anyhow::Result;
+use eqx_core::asset_file_path;
+use std::fs;
+
+pub struct Texture {
+    #[allow(unused)]
+    texture: wgpu::Texture,
+    pub view: wgpu::TextureView,
+    pub sampler: wgpu::Sampler,
+}
+
+impl Texture {
+    pub fn new_from(path: String, device: &wgpu::Device, queue: &wgpu::Queue) -> Result<Self> {
+        let path = asset_file_path!(path);
+        let bytes = fs::read(path)?;
+        let raw_bytes = bytes.as_slice();
+        let img = image::load_from_memory(raw_bytes)?;
+        let rgba = img.to_rgba8();
+        let dimensions = rgba.dimensions();
+        let size = wgpu::Extent3d {
+            width: dimensions.0,
+            height: dimensions.1,
+            depth_or_array_layers: 1,
+        };
+
+        let texture = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some("Texture"),
+            size,
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::Rgba8UnormSrgb,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+            view_formats: &[],
+        });
+
+        queue.write_texture(
+            wgpu::TexelCopyTextureInfo {
+                texture: &texture,
+                mip_level: 0,
+                origin: wgpu::Origin3d::ZERO,
+                aspect: wgpu::TextureAspect::All,
+            },
+            &rgba,
+            wgpu::TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(4 * dimensions.0), // 4 = rgba
+                rows_per_image: Some(dimensions.1),
+            },
+            size,
+        );
+
+        let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: Some("TextureSampler"),
+            address_mode_u: wgpu::AddressMode::ClampToEdge,
+            address_mode_v: wgpu::AddressMode::ClampToEdge,
+            address_mode_w: wgpu::AddressMode::ClampToEdge,
+            mag_filter: wgpu::FilterMode::Linear,
+            min_filter: wgpu::FilterMode::Linear,
+            mipmap_filter: wgpu::FilterMode::Nearest,
+            ..Default::default()
+        });
+
+        Ok(Self {
+            texture,
+            view,
+            sampler,
+        })
+    }
+}

crates/eqx_window/src/window.rs

@@ -1,4 +1,5 @@
 use crate::primitives::{Vertex, TEST_INDICES, TEST_VERTICES};
+use crate::texture::Texture;
 use eqx_app::prelude::Module;
 use wgpu::util::{BufferInitDescriptor, DeviceExt};
 
@@ -9,6 +10,7 @@ use winit::{
     window::WindowBuilder,
 };
 
+use eqx_core::shader_src_from;
 use winit::window::Window as WInitWindow;
 
 const VS_MAIN: &str = "vs_main";
@@ -81,53 +83,8 @@ impl<'a> State<'a> {
             desired_maximum_frame_latency: 2,
         };
 
-        let texture_bytes = eqx_core::asset_file!("texture/test_tree.png");
-        let texture_img = image::load_from_memory(texture_bytes).unwrap();
-        let texture_rgba = texture_img.to_rgba8();
-        let texture_dimensions = texture_rgba.dimensions();
-        let texture_size = wgpu::Extent3d {
-            width: texture_dimensions.0,
-            height: texture_dimensions.1,
-            depth_or_array_layers: 1,
-        };
-
-        let texture = device.create_texture(&wgpu::TextureDescriptor {
-            label: Some("Texture"),
-            size: texture_size,
-            mip_level_count: 1,
-            sample_count: 1,
-            dimension: wgpu::TextureDimension::D2,
-            format: wgpu::TextureFormat::Rgba8UnormSrgb,
-            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-            view_formats: &[],
-        });
-        queue.write_texture(
-            wgpu::TexelCopyTextureInfo {
-                texture: &texture,
-                mip_level: 0,
-                origin: wgpu::Origin3d::ZERO,
-                aspect: wgpu::TextureAspect::All,
-            },
-            &texture_rgba,
-            wgpu::TexelCopyBufferLayout {
-                offset: 0,
-                bytes_per_row: Some(4 * texture_dimensions.0), // 4 = rgba
-                rows_per_image: Some(texture_dimensions.1),
-            },
-            texture_size,
-        );
-
-        let texture_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
-        let texture_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
-            label: Some("TextureSampler"),
-            address_mode_u: wgpu::AddressMode::ClampToEdge,
-            address_mode_v: wgpu::AddressMode::ClampToEdge,
-            address_mode_w: wgpu::AddressMode::ClampToEdge,
-            mag_filter: wgpu::FilterMode::Linear,
-            min_filter: wgpu::FilterMode::Linear,
-            mipmap_filter: wgpu::FilterMode::Nearest,
-            ..Default::default()
-        });
+        let texture =
+            Texture::new_from(String::from("texture/test_tree.png"), &device, &queue).unwrap();
 
         let texture_bind_group_layout =
             device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
@@ -159,18 +116,20 @@ impl<'a> State<'a> {
             entries: &[
                 wgpu::BindGroupEntry {
                     binding: 0,
-                    resource: wgpu::BindingResource::TextureView(&texture_view),
+                    resource: wgpu::BindingResource::TextureView(&texture.view),
                 },
                 wgpu::BindGroupEntry {
                     binding: 1,
-                    resource: wgpu::BindingResource::Sampler(&texture_sampler),
+                    resource: wgpu::BindingResource::Sampler(&texture.sampler),
                 },
             ],
         });
 
+        let shader_str = shader_src_from!("trig/shader");
+
         let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some("TrigShader"),
-            source: wgpu::ShaderSource::Wgsl(eqx_core::shader_src!("trig/shader").into()),
+            source: wgpu::ShaderSource::Wgsl(shader_str.as_str().into()),
         });
 
         let render_pipeline_layout =