[render] test texture loading

ARessegetesStery · ARessegetesStery · commit 707c2286d650 · 2025-04-10T19:30:10.000-04:00
diff --git a/assets/texture/test_tree.png b/assets/texture/test_tree.png
diff --git a/crates/eqx_core/src/util_macros.rs b/crates/eqx_core/src/util_macros.rs
@@ -13,6 +13,6 @@ macro_rules! shader_src {
 #[macro_export]
 macro_rules! asset_file {
     ($path:literal) => {
-        include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/", $path))
+        include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/", $path))
     };
 }
diff --git a/crates/eqx_window/src/primitives.rs b/crates/eqx_window/src/primitives.rs
@@ -1,13 +1,15 @@
+// TODO: change from bytemuck to encase for automatic padding/alignment
 #[repr(C)]
 #[derive(Copy, Clone, Debug, bytemuck::Zeroable, bytemuck::Pod)]
 pub struct Vertex {
     position: [f32; 3],
     color: [f32; 3],
+    tex_coords: [f32; 2],
 }
 
 impl Vertex {
-    const ATTRIBUTE: [wgpu::VertexAttribute; 2] =
-        wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3];
+    const ATTRIBUTE: [wgpu::VertexAttribute; 3] =
+        wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3, 2 => Float32x2];
 
     pub fn descriptor() -> wgpu::VertexBufferLayout<'static> {
         wgpu::VertexBufferLayout {
@@ -22,22 +24,27 @@ pub const TEST_VERTICES: &[Vertex] = &[
     Vertex {
         position: [-0.0868241, 0.49240386, 0.0],
         color: [0.5, 0.0, 0.5],
+        tex_coords: [0.4131759, 0.00759614],
     }, // A
     Vertex {
         position: [-0.49513406, 0.06958647, 0.0],
         color: [0.5, 0.0, 0.5],
+        tex_coords: [0.0048659444, 0.43041354],
     }, // B
     Vertex {
         position: [-0.21918549, -0.44939706, 0.0],
         color: [0.5, 0.0, 0.5],
+        tex_coords: [0.28081453, 0.949397],
     }, // C
     Vertex {
         position: [0.35966998, -0.3473291, 0.0],
         color: [0.5, 0.0, 0.5],
+        tex_coords: [0.85967, 0.84732914],
     }, // D
     Vertex {
         position: [0.44147372, 0.2347359, 0.0],
         color: [0.5, 0.0, 0.5],
+        tex_coords: [0.9414737, 0.2652641],
     }, // E
 ];
 
diff --git a/crates/eqx_window/src/window.rs b/crates/eqx_window/src/window.rs
@@ -1,8 +1,6 @@
-use wgpu::util::{BufferInitDescriptor, DeviceExt};
-
 use crate::primitives::{Vertex, TEST_INDICES, TEST_VERTICES};
-
 use eqx_app::prelude::Module;
+use wgpu::util::{BufferInitDescriptor, DeviceExt};
 
 use winit::{
     event::*,
@@ -26,6 +24,7 @@ struct State<'a> {
     render_pipeline: wgpu::RenderPipeline,
     vertex_buffer: wgpu::Buffer,
     index_buffer: wgpu::Buffer,
+    texture_bind_group: wgpu::BindGroup,
 }
 
 impl<'a> State<'a> {
@@ -82,6 +81,93 @@ 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_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: Some("TextureBindGroupLayout"),
+                entries: &[
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 0,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        ty: wgpu::BindingType::Texture {
+                            multisampled: false,
+                            view_dimension: wgpu::TextureViewDimension::D2,
+                            sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 1,
+                        visibility: wgpu::ShaderStages::FRAGMENT,
+                        // This should match the filterable field of the
+                        // corresponding Texture entry above.
+                        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                        count: None,
+                    },
+                ],
+            });
+        let texture_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("TextureBindGroup"),
+            layout: &texture_bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(&texture_view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::Sampler(&texture_sampler),
+                },
+            ],
+        });
+
         let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some("TrigShader"),
             source: wgpu::ShaderSource::Wgsl(eqx_core::shader_src!("trig/shader").into()),
@@ -90,7 +176,7 @@ impl<'a> State<'a> {
         let render_pipeline_layout =
             device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
                 label: Some("RenderPipelineLayout"),
-                bind_group_layouts: &[],
+                bind_group_layouts: &[&texture_bind_group_layout],
                 push_constant_ranges: &[],
             });
 
@@ -154,6 +240,7 @@ impl<'a> State<'a> {
             render_pipeline,
             vertex_buffer,
             index_buffer,
+            texture_bind_group,
         }
     }
 
@@ -211,6 +298,7 @@ impl<'a> State<'a> {
             });
 
             render_pass.set_pipeline(&self.render_pipeline);
+            render_pass.set_bind_group(0, &self.texture_bind_group, &[]);
             render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
             render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
             render_pass.draw_indexed(0..TEST_INDICES.len() as u32, 0, 0..1);
diff --git a/shaders/trig/shader.wgsl b/shaders/trig/shader.wgsl
@@ -1,11 +1,13 @@
 struct VertexInput {
     @location(0) vert_pos: vec3<f32>,
     @location(1) vert_color: vec3<f32>,
+    @location(2) vert_tex: vec2<f32>,
 }
 
 struct VertexOutput {
     @builtin(position) clip_position: vec4<f32>,
     @location(0) color: vec3<f32>,
+    @location(1) tex_coord: vec2<f32>,
 }
 
 @vertex
@@ -15,13 +17,19 @@ fn vs_main(
     var out: VertexOutput;
     out.clip_position = vec4<f32>(model.vert_pos, 1.0);
     out.color = model.vert_color;
+    out.tex_coord = model.vert_tex;
     return out;
 }
 
+@group(0) @binding(0)
+var t_diffuse: texture_2d<f32>;
+@group(0) @binding(1)
+var s_diffuse: sampler;
+
 @fragment
 fn fs_main(
     in: VertexOutput
 ) -> @location(0) vec4<f32> {
-    return vec4<f32>(in.color, 1.0);
+    return textureSample(t_diffuse, s_diffuse, in.tex_coord);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,6 @@ macro_rules! shader_src {`
`13`	`13`	`#[macro_export]`
`14`	`14`	`macro_rules! asset_file {`
`15`	`15`	`($path:literal) => {`
`16`		`- include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/", $path))`
	`16`	`+ include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/", $path))`
`17`	`17`	`};`
`18`	`18`	`}`