use std::mem;
use cgmath::Vector2;
use crevice::std140::AsStd140;
use num_traits::Zero;
use wgpu::util::DeviceExt;
use crate::WgpuState;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct Vertex {
pub position: Vector2<f32>,
}
unsafe impl bytemuck::Pod for Vertex {}
unsafe impl bytemuck::Zeroable for Vertex {}
impl Vertex {
pub fn new(x: f32, y: f32) -> Self {
Self {
position: Vector2::new(x, y),
}
}
pub fn desc<'a>() -> wgpu::VertexBufferLayout<'a> {
wgpu::VertexBufferLayout {
array_stride: mem::size_of::<Vertex>() as wgpu::BufferAddress,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &[wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float32x2,
}],
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone, AsStd140)]
pub struct Uniform {
pub start: Vector2<f32>,
pub end: Vector2<f32>,
pub size: Vector2<f32>,
}
impl Default for Uniform {
fn default() -> Self {
Self {
start: Vector2::zero(),
end: Vector2::zero(),
size: Vector2::zero(),
}
}
}
impl Uniform {
fn get_bind_group_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}],
label: Some("image_fragment_bind_group_layout"),
})
}
}
pub struct Renderer {
pipeline: wgpu::RenderPipeline,
uniform_buffer: wgpu::Buffer,
uniform_bind_group: wgpu::BindGroup,
vertices: wgpu::Buffer,
indices: wgpu::Buffer,
}
impl Renderer {
pub fn new(wgpu: &WgpuState) -> Self {
let render_pipeline_layout =
wgpu.device
.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("Crop Render Pipeline Layout"),
bind_group_layouts: &[&Uniform::get_bind_group_layout(&wgpu.device)],
push_constant_ranges: &[],
});
let vertex = wgpu
.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Crop vertex"),
source: wgpu::ShaderSource::Glsl {
shader: include_str!("../../shader/crop.vert").into(),
stage: wgpu::naga::ShaderStage::Vertex,
defines: Default::default(),
},
});
let fragment = wgpu
.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Crop fragment"),
source: wgpu::ShaderSource::Glsl {
shader: include_str!("../../shader/crop.frag").into(),
stage: wgpu::naga::ShaderStage::Fragment,
defines: Default::default(),
},
});
let pipeline = wgpu
.device
.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Crop Render Pipeline"),
layout: Some(&render_pipeline_layout),
vertex: wgpu::VertexState {
module: &vertex,
entry_point: "main",
buffers: &[Vertex::desc()],
compilation_options: Default::default(),
},
fragment: Some(wgpu::FragmentState {
module: &fragment,
entry_point: "main",
targets: &[Some(wgpu::ColorTargetState {
format: wgpu.config.format,
blend: Some(wgpu::BlendState::ALPHA_BLENDING),
write_mask: wgpu::ColorWrites::ALL,
})],
compilation_options: Default::default(),
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: Some(wgpu::Face::Back),
polygon_mode: wgpu::PolygonMode::Fill,
unclipped_depth: false,
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
count: 1,
mask: !0,
alpha_to_coverage_enabled: false,
},
multiview: None,
cache: None,
});
let value_std140 = Uniform::default().as_std140();
let uniform_buffer = wgpu
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Uniform Buffer"),
contents: value_std140.as_bytes(),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
let uniform_bind_group_layout = Uniform::get_bind_group_layout(&wgpu.device);
let uniform_bind_group = wgpu.device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &uniform_bind_group_layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: uniform_buffer.as_entire_binding(),
}],
label: Some("Vertex Uniform Bind Group"),
});
let shape = [
Vertex::new(-1.0, 1.0),
Vertex::new(-1.0, -1.0),
Vertex::new(1.0, 1.0),
Vertex::new(1.0, -1.0),
];
let index_buffer: [u32; 6] = [0, 1, 2, 2, 1, 3];
let vertices = wgpu
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(&shape),
usage: wgpu::BufferUsages::VERTEX,
});
let indices = wgpu
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Triangle Index Buffer"),
contents: bytemuck::cast_slice(&index_buffer),
usage: wgpu::BufferUsages::INDEX,
});
Self {
pipeline,
uniform_buffer,
uniform_bind_group,
vertices,
indices,
}
}
pub fn prepare(&mut self, wgpu: &WgpuState, uniform: Uniform) {
let value_std140 = uniform.as_std140();
wgpu.queue
.write_buffer(&self.uniform_buffer, 0, value_std140.as_bytes());
}
pub fn render<'rpass>(&'rpass mut self, rpass: &mut wgpu::RenderPass<'rpass>) {
rpass.set_pipeline(&self.pipeline);
rpass.set_bind_group(0, &self.uniform_bind_group, &[]);
rpass.set_vertex_buffer(0, self.vertices.slice(..));
rpass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
rpass.draw_indexed(0..6, 0, 0..1);
}
}