302 lines
12 KiB
Rust
302 lines
12 KiB
Rust
|
use wgpu::{include_wgsl, util::DeviceExt};
|
||
|
|
use winit::{event::*, window::Window};
|
||
|
|
|
||
|
|
use super::types::Vertex;
|
||
|
|
|
||
|
|
// test data
|
||
|
|
const VERTICES: &[Vertex] = &[
|
||
|
|
Vertex { position: [-0.0868241, 0.49240386, 0.0], tex_coords: [0.4131759, 0.99240386], }, // A
|
||
|
|
Vertex { position: [-0.49513406, 0.06958647, 0.0], tex_coords: [0.0048659444, 0.56958647], }, // B
|
||
|
|
Vertex { position: [-0.21918549, -0.44939706, 0.0], tex_coords: [0.28081453, 0.05060294], }, // C
|
||
|
|
Vertex { position: [0.35966998, -0.3473291, 0.0], tex_coords: [0.85967, 0.1526709], }, // D
|
||
|
|
Vertex { position: [0.44147372, 0.2347359, 0.0], tex_coords: [0.9414737, 0.7347359], }, // E
|
||
|
|
];
|
||
|
|
const INDICES: &[u16] = &[0, 1, 4, 1, 2, 4, 2, 3, 4];
|
||
|
|
|
||
|
|
pub struct State {
|
||
|
|
pub size: winit::dpi::PhysicalSize<u32>,
|
||
|
|
|
||
|
|
surface: wgpu::Surface,
|
||
|
|
device: wgpu::Device,
|
||
|
|
queue: wgpu::Queue,
|
||
|
|
config: wgpu::SurfaceConfiguration,
|
||
|
|
render_pipeline: wgpu::RenderPipeline,
|
||
|
|
vertex_buffer: wgpu::Buffer,
|
||
|
|
index_buffer: wgpu::Buffer,
|
||
|
|
num_indices: u32,
|
||
|
|
diffuse_bind_group: wgpu::BindGroup,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl State {
|
||
|
|
// Creating some of the wgpu types requires async code
|
||
|
|
pub async fn new(window: &Window) -> Self {
|
||
|
|
let size = window.inner_size();
|
||
|
|
let instance = wgpu::Instance::new(wgpu::Backends::all());
|
||
|
|
let surface = unsafe { instance.create_surface(window) };
|
||
|
|
|
||
|
|
let adapter = instance
|
||
|
|
.request_adapter(&wgpu::RequestAdapterOptions {
|
||
|
|
power_preference: wgpu::PowerPreference::HighPerformance,
|
||
|
|
compatible_surface: Some(&surface),
|
||
|
|
force_fallback_adapter: false,
|
||
|
|
})
|
||
|
|
.await
|
||
|
|
.unwrap();
|
||
|
|
|
||
|
|
let (device, queue) = adapter
|
||
|
|
.request_device(
|
||
|
|
&wgpu::DeviceDescriptor {
|
||
|
|
features: wgpu::Features::empty(),
|
||
|
|
limits: wgpu::Limits::default(),
|
||
|
|
label: None,
|
||
|
|
},
|
||
|
|
None, // Trace path
|
||
|
|
)
|
||
|
|
.await
|
||
|
|
.unwrap();
|
||
|
|
|
||
|
|
let config = wgpu::SurfaceConfiguration {
|
||
|
|
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
|
||
|
|
format: surface.get_supported_formats(&adapter)[0],
|
||
|
|
width: size.width,
|
||
|
|
height: size.height,
|
||
|
|
present_mode: wgpu::PresentMode::Fifo,
|
||
|
|
};
|
||
|
|
|
||
|
|
surface.configure(&device, &config);
|
||
|
|
|
||
|
|
// Test image
|
||
|
|
let diffuse_bytes = include_bytes!("../../assets/test.png");
|
||
|
|
let diffuse_image = image::load_from_memory(diffuse_bytes).unwrap();
|
||
|
|
let diffuse_rgba = diffuse_image.to_rgba8();
|
||
|
|
use image::GenericImageView;
|
||
|
|
let dimensions = diffuse_image.dimensions();
|
||
|
|
let texture_size = wgpu::Extent3d {
|
||
|
|
width: dimensions.0,
|
||
|
|
height: dimensions.1,
|
||
|
|
depth_or_array_layers: 1,
|
||
|
|
};
|
||
|
|
let diffuse_texture = device.create_texture(&wgpu::TextureDescriptor {
|
||
|
|
// All textures are stored as 3D, we represent our 2D texture
|
||
|
|
// by setting depth to 1.
|
||
|
|
size: texture_size,
|
||
|
|
mip_level_count: 1, // We'll talk about this a little later
|
||
|
|
sample_count: 1,
|
||
|
|
dimension: wgpu::TextureDimension::D2,
|
||
|
|
// Most images are stored using sRGB so we need to reflect that here.
|
||
|
|
format: wgpu::TextureFormat::Rgba8UnormSrgb,
|
||
|
|
// TEXTURE_BINDING tells wgpu that we want to use this texture in shaders
|
||
|
|
// COPY_DST means that we want to copy data to this texture
|
||
|
|
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
|
||
|
|
label: Some("diffuse_texture"),
|
||
|
|
});
|
||
|
|
queue.write_texture(
|
||
|
|
// Tells wgpu where to copy the pixel data
|
||
|
|
wgpu::ImageCopyTexture {
|
||
|
|
texture: &diffuse_texture,
|
||
|
|
mip_level: 0,
|
||
|
|
origin: wgpu::Origin3d::ZERO,
|
||
|
|
aspect: wgpu::TextureAspect::All,
|
||
|
|
},
|
||
|
|
// The actual pixel data
|
||
|
|
&diffuse_rgba,
|
||
|
|
// The layout of the texture
|
||
|
|
wgpu::ImageDataLayout {
|
||
|
|
offset: 0,
|
||
|
|
bytes_per_row: std::num::NonZeroU32::new(4 * dimensions.0),
|
||
|
|
rows_per_image: std::num::NonZeroU32::new(dimensions.1),
|
||
|
|
},
|
||
|
|
texture_size,
|
||
|
|
);
|
||
|
|
let diffuse_texture_view =
|
||
|
|
diffuse_texture.create_view(&wgpu::TextureViewDescriptor::default());
|
||
|
|
let diffuse_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
|
||
|
|
address_mode_u: wgpu::AddressMode::Repeat,
|
||
|
|
address_mode_v: wgpu::AddressMode::Repeat,
|
||
|
|
address_mode_w: wgpu::AddressMode::Repeat,
|
||
|
|
mag_filter: wgpu::FilterMode::Linear,
|
||
|
|
min_filter: wgpu::FilterMode::Linear,
|
||
|
|
mipmap_filter: wgpu::FilterMode::Linear,
|
||
|
|
..Default::default()
|
||
|
|
});
|
||
|
|
let texture_bind_group_layout =
|
||
|
|
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||
|
|
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,
|
||
|
|
},
|
||
|
|
],
|
||
|
|
label: Some("texture_bind_group_layout"),
|
||
|
|
});
|
||
|
|
let diffuse_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||
|
|
layout: &texture_bind_group_layout,
|
||
|
|
entries: &[
|
||
|
|
wgpu::BindGroupEntry {
|
||
|
|
binding: 0,
|
||
|
|
resource: wgpu::BindingResource::TextureView(&diffuse_texture_view),
|
||
|
|
},
|
||
|
|
wgpu::BindGroupEntry {
|
||
|
|
binding: 1,
|
||
|
|
resource: wgpu::BindingResource::Sampler(&diffuse_sampler),
|
||
|
|
},
|
||
|
|
],
|
||
|
|
label: Some("diffuse_bind_group"),
|
||
|
|
});
|
||
|
|
|
||
|
|
// let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
||
|
|
// label: Some("Shader"),
|
||
|
|
// source: wgpu::ShaderSource::Wgsl(include_str!("../shaders/test.wgsl").into()),
|
||
|
|
// });
|
||
|
|
let shader = device.create_shader_module(include_wgsl!("../shaders/test.wgsl"));
|
||
|
|
|
||
|
|
let render_pipeline_layout =
|
||
|
|
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||
|
|
label: Some("Render Pipeline Layout"),
|
||
|
|
bind_group_layouts: &[&texture_bind_group_layout],
|
||
|
|
push_constant_ranges: &[],
|
||
|
|
});
|
||
|
|
|
||
|
|
let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
||
|
|
label: Some("Render Pipeline"),
|
||
|
|
layout: Some(&render_pipeline_layout),
|
||
|
|
vertex: wgpu::VertexState {
|
||
|
|
module: &shader,
|
||
|
|
entry_point: "vs_main",
|
||
|
|
buffers: &[Vertex::desc()],
|
||
|
|
},
|
||
|
|
fragment: Some(wgpu::FragmentState {
|
||
|
|
// 3.
|
||
|
|
module: &shader,
|
||
|
|
entry_point: "fs_main",
|
||
|
|
targets: &[Some(wgpu::ColorTargetState {
|
||
|
|
format: config.format,
|
||
|
|
blend: Some(wgpu::BlendState::REPLACE),
|
||
|
|
write_mask: wgpu::ColorWrites::ALL,
|
||
|
|
})],
|
||
|
|
}),
|
||
|
|
primitive: wgpu::PrimitiveState {
|
||
|
|
topology: wgpu::PrimitiveTopology::TriangleList,
|
||
|
|
strip_index_format: None,
|
||
|
|
front_face: wgpu::FrontFace::Ccw,
|
||
|
|
cull_mode: Some(wgpu::Face::Back),
|
||
|
|
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
|
||
|
|
polygon_mode: wgpu::PolygonMode::Fill,
|
||
|
|
// Requires Features::DEPTH_CLIP_CONTROL
|
||
|
|
unclipped_depth: false,
|
||
|
|
// Requires Features::CONSERVATIVE_RASTERIZATION
|
||
|
|
conservative: false,
|
||
|
|
},
|
||
|
|
depth_stencil: None,
|
||
|
|
multisample: wgpu::MultisampleState {
|
||
|
|
count: 1,
|
||
|
|
mask: !0,
|
||
|
|
alpha_to_coverage_enabled: false,
|
||
|
|
},
|
||
|
|
multiview: None,
|
||
|
|
});
|
||
|
|
|
||
|
|
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||
|
|
label: Some("Vertex Buffer"),
|
||
|
|
contents: bytemuck::cast_slice(VERTICES),
|
||
|
|
usage: wgpu::BufferUsages::VERTEX,
|
||
|
|
});
|
||
|
|
|
||
|
|
let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||
|
|
label: Some("Index Buffer"),
|
||
|
|
contents: bytemuck::cast_slice(INDICES),
|
||
|
|
usage: wgpu::BufferUsages::INDEX,
|
||
|
|
});
|
||
|
|
let num_indices = INDICES.len() as u32;
|
||
|
|
|
||
|
|
return Self {
|
||
|
|
size,
|
||
|
|
surface,
|
||
|
|
device,
|
||
|
|
queue,
|
||
|
|
config,
|
||
|
|
render_pipeline,
|
||
|
|
vertex_buffer,
|
||
|
|
index_buffer,
|
||
|
|
num_indices,
|
||
|
|
diffuse_bind_group,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
|
||
|
|
if new_size.width > 0 && new_size.height > 0 {
|
||
|
|
self.size = new_size;
|
||
|
|
self.config.width = new_size.width;
|
||
|
|
self.config.height = new_size.height;
|
||
|
|
self.surface.configure(&self.device, &self.config);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn input(&mut self, event: &WindowEvent) -> bool {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn update(&mut self) {}
|
||
|
|
|
||
|
|
pub fn render(&mut self) -> Result<(), wgpu::SurfaceError> {
|
||
|
|
let output = self.surface.get_current_texture()?;
|
||
|
|
let view = output
|
||
|
|
.texture
|
||
|
|
.create_view(&wgpu::TextureViewDescriptor::default());
|
||
|
|
let mut encoder = self
|
||
|
|
.device
|
||
|
|
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
|
||
|
|
label: Some("Render Encoder"),
|
||
|
|
});
|
||
|
|
|
||
|
|
{
|
||
|
|
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||
|
|
label: Some("Render Pass"),
|
||
|
|
color_attachments: &[
|
||
|
|
// This is what @location(0) in the fragment shader targets
|
||
|
|
Some(wgpu::RenderPassColorAttachment {
|
||
|
|
view: &view,
|
||
|
|
resolve_target: None,
|
||
|
|
ops: wgpu::Operations {
|
||
|
|
load: wgpu::LoadOp::Clear(wgpu::Color {
|
||
|
|
r: 0.1,
|
||
|
|
g: 0.2,
|
||
|
|
b: 0.3,
|
||
|
|
a: 1.0,
|
||
|
|
}),
|
||
|
|
store: true,
|
||
|
|
},
|
||
|
|
}),
|
||
|
|
],
|
||
|
|
depth_stencil_attachment: None,
|
||
|
|
});
|
||
|
|
|
||
|
|
render_pass.set_pipeline(&self.render_pipeline);
|
||
|
|
render_pass.set_bind_group(0, &self.diffuse_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..self.num_indices, 0, 0..1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// submit will accept anything that implements IntoIter
|
||
|
|
self.queue.submit(std::iter::once(encoder.finish()));
|
||
|
|
output.present();
|
||
|
|
|
||
|
|
return Ok(());
|
||
|
|
}
|
||
|
|
}
|