summaryrefslogtreecommitdiffstats
path: root/wgpu
diff options
context:
space:
mode:
Diffstat (limited to 'wgpu')
-rw-r--r--wgpu/src/buffers.rs2
-rw-r--r--wgpu/src/buffers/dynamic.rs40
-rw-r--r--wgpu/src/shader/gradient.wgsl (renamed from wgpu/src/shader/triangle_gradient.wgsl)6
-rw-r--r--wgpu/src/shader/solid.wgsl17
-rw-r--r--wgpu/src/shader/triangle_solid.wgsl17
-rw-r--r--wgpu/src/triangle.rs34
-rw-r--r--wgpu/src/triangle/gradient.rs67
-rw-r--r--wgpu/src/triangle/solid.rs55
8 files changed, 115 insertions, 123 deletions
diff --git a/wgpu/src/buffers.rs b/wgpu/src/buffers.rs
index 6b9f487c..dc9fc6e2 100644
--- a/wgpu/src/buffers.rs
+++ b/wgpu/src/buffers.rs
@@ -56,7 +56,7 @@ impl<T: Pod + Zeroable> StaticBuffer<T> {
/// Returns whether or not the buffer needs to be recreated. This can happen whenever mesh data
/// changes & a redraw is requested.
- pub fn recreate_if_needed(
+ pub fn resize(
&mut self,
device: &wgpu::Device,
new_count: usize,
diff --git a/wgpu/src/buffers/dynamic.rs b/wgpu/src/buffers/dynamic.rs
index dc30c56f..63955b6e 100644
--- a/wgpu/src/buffers/dynamic.rs
+++ b/wgpu/src/buffers/dynamic.rs
@@ -4,23 +4,23 @@ use encase::ShaderType;
use std::marker::PhantomData;
// Currently supported dynamic buffers.
-enum DynamicBufferType {
+enum BufferType {
Uniform(encase::DynamicUniformBuffer<Vec<u8>>),
Storage(encase::DynamicStorageBuffer<Vec<u8>>),
}
-impl DynamicBufferType {
+impl BufferType {
/// Writes the current value to its CPU buffer with proper alignment.
pub(super) fn write<T: ShaderType + WriteInto>(
&mut self,
value: &T,
) -> wgpu::DynamicOffset {
match self {
- DynamicBufferType::Uniform(buf) => buf
+ BufferType::Uniform(buf) => buf
.write(value)
.expect("Error when writing to dynamic uniform buffer.")
as u32,
- DynamicBufferType::Storage(buf) => buf
+ BufferType::Storage(buf) => buf
.write(value)
.expect("Error when writing to dynamic storage buffer.")
as u32,
@@ -30,19 +30,19 @@ impl DynamicBufferType {
/// Returns bytearray of aligned CPU buffer.
pub(super) fn get_ref(&self) -> &Vec<u8> {
match self {
- DynamicBufferType::Uniform(buf) => buf.as_ref(),
- DynamicBufferType::Storage(buf) => buf.as_ref(),
+ BufferType::Uniform(buf) => buf.as_ref(),
+ BufferType::Storage(buf) => buf.as_ref(),
}
}
/// Resets the CPU buffer.
pub(super) fn clear(&mut self) {
match self {
- DynamicBufferType::Uniform(buf) => {
+ BufferType::Uniform(buf) => {
buf.as_mut().clear();
buf.set_offset(0);
}
- DynamicBufferType::Storage(buf) => {
+ BufferType::Storage(buf) => {
buf.as_mut().clear();
buf.set_offset(0);
}
@@ -51,21 +51,21 @@ impl DynamicBufferType {
}
/// A dynamic buffer is any type of buffer which does not have a static offset.
-pub(crate) struct DynamicBuffer<T: ShaderType> {
+pub(crate) struct Buffer<T: ShaderType> {
offsets: Vec<wgpu::DynamicOffset>,
- cpu: DynamicBufferType,
+ cpu: BufferType,
gpu: wgpu::Buffer,
label: &'static str,
size: u64,
_data: PhantomData<T>,
}
-impl<T: ShaderType + WriteInto> DynamicBuffer<T> {
+impl<T: ShaderType + WriteInto> Buffer<T> {
/// Creates a new dynamic uniform buffer.
pub fn uniform(device: &wgpu::Device, label: &'static str) -> Self {
- DynamicBuffer::new(
+ Buffer::new(
device,
- DynamicBufferType::Uniform(encase::DynamicUniformBuffer::new(
+ BufferType::Uniform(encase::DynamicUniformBuffer::new(
Vec::new(),
)),
label,
@@ -75,9 +75,9 @@ impl<T: ShaderType + WriteInto> DynamicBuffer<T> {
/// Creates a new dynamic storage buffer.
pub fn storage(device: &wgpu::Device, label: &'static str) -> Self {
- DynamicBuffer::new(
+ Buffer::new(
device,
- DynamicBufferType::Storage(encase::DynamicStorageBuffer::new(
+ BufferType::Storage(encase::DynamicStorageBuffer::new(
Vec::new(),
)),
label,
@@ -87,7 +87,7 @@ impl<T: ShaderType + WriteInto> DynamicBuffer<T> {
fn new(
device: &wgpu::Device,
- dynamic_buffer_type: DynamicBufferType,
+ dynamic_buffer_type: BufferType,
label: &'static str,
usage: wgpu::BufferUsages,
) -> Self {
@@ -96,7 +96,7 @@ impl<T: ShaderType + WriteInto> DynamicBuffer<T> {
Self {
offsets: Vec::new(),
cpu: dynamic_buffer_type,
- gpu: DynamicBuffer::<T>::create_gpu_buffer(
+ gpu: Buffer::<T>::create_gpu_buffer(
device,
label,
usage,
@@ -139,15 +139,15 @@ impl<T: ShaderType + WriteInto> DynamicBuffer<T> {
if self.size < new_size {
let usages = match self.cpu {
- DynamicBufferType::Uniform(_) => {
+ BufferType::Uniform(_) => {
wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST
}
- DynamicBufferType::Storage(_) => {
+ BufferType::Storage(_) => {
wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST
}
};
- self.gpu = DynamicBuffer::<T>::create_gpu_buffer(
+ self.gpu = Buffer::<T>::create_gpu_buffer(
device, self.label, usages, new_size,
);
self.size = new_size;
diff --git a/wgpu/src/shader/triangle_gradient.wgsl b/wgpu/src/shader/gradient.wgsl
index 03ba9d88..63825aec 100644
--- a/wgpu/src/shader/triangle_gradient.wgsl
+++ b/wgpu/src/shader/gradient.wgsl
@@ -1,4 +1,4 @@
-struct GradientUniforms {
+struct Uniforms {
transform: mat4x4<f32>,
//xy = start, wz = end
position: vec4<f32>,
@@ -12,7 +12,7 @@ struct Stop {
};
@group(0) @binding(0)
-var<uniform> uniforms: GradientUniforms;
+var<uniform> uniforms: Uniforms;
@group(0) @binding(1)
var<storage, read> color_stops: array<Stop>;
@@ -33,7 +33,7 @@ fn vs_main(@location(0) input: vec2<f32>) -> VertexOutput {
//TODO: rewrite without branching
@fragment
-fn fs_gradient(input: VertexOutput) -> @location(0) vec4<f32> {
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
let start = uniforms.position.xy;
let end = uniforms.position.zw;
let start_stop = uniforms.stop_range.x;
diff --git a/wgpu/src/shader/solid.wgsl b/wgpu/src/shader/solid.wgsl
new file mode 100644
index 00000000..68a8fea3
--- /dev/null
+++ b/wgpu/src/shader/solid.wgsl
@@ -0,0 +1,17 @@
+struct Uniforms {
+ transform: mat4x4<f32>,
+ color: vec4<f32>
+}
+
+@group(0) @binding(0)
+var<uniform> uniforms: Uniforms;
+
+@vertex
+fn vs_main(@location(0) input: vec2<f32>) -> @builtin(position) vec4<f32> {
+ return uniforms.transform * vec4<f32>(input.xy, 0.0, 1.0);
+}
+
+@fragment
+fn fs_main() -> @location(0) vec4<f32> {
+ return uniforms.color;
+}
diff --git a/wgpu/src/shader/triangle_solid.wgsl b/wgpu/src/shader/triangle_solid.wgsl
deleted file mode 100644
index 9eb2df24..00000000
--- a/wgpu/src/shader/triangle_solid.wgsl
+++ /dev/null
@@ -1,17 +0,0 @@
-struct SolidUniforms {
- transform: mat4x4<f32>,
- color: vec4<f32>
-}
-
-@group(0) @binding(0)
-var<uniform> solid_uniforms: SolidUniforms;
-
-@vertex
-fn vs_main(@location(0) input: vec2<f32>) -> @builtin(position) vec4<f32> {
- return solid_uniforms.transform * vec4<f32>(input.xy, 0.0, 1.0);
-}
-
-@fragment
-fn fs_solid() -> @location(0) vec4<f32> {
- return solid_uniforms.color;
-}
diff --git a/wgpu/src/triangle.rs b/wgpu/src/triangle.rs
index feca72dc..0956c57d 100644
--- a/wgpu/src/triangle.rs
+++ b/wgpu/src/triangle.rs
@@ -3,12 +3,10 @@ use crate::{settings, Transformation};
use core::fmt;
use std::fmt::Formatter;
-use iced_graphics::layer::{Mesh, mesh, mesh::attribute_count_of};
+use iced_graphics::layer::{Mesh, mesh};
use iced_graphics::Size;
use crate::buffers::StaticBuffer;
-use crate::triangle::gradient::GradientPipeline;
-use crate::triangle::solid::SolidPipeline;
pub use iced_graphics::triangle::{Mesh2D, Vertex2D};
mod solid;
@@ -22,22 +20,22 @@ pub(crate) struct Pipeline {
vertex_buffer: StaticBuffer<Vertex2D>,
index_buffer: StaticBuffer<u32>,
index_strides: Vec<u32>,
- pipelines: TrianglePipelines,
+ pipelines: PipelineList,
}
/// Supported triangle pipelines for different fills.
-pub(crate) struct TrianglePipelines {
- solid: SolidPipeline,
- gradient: GradientPipeline,
+pub(crate) struct PipelineList {
+ solid: solid::Pipeline,
+ gradient: gradient::Pipeline,
}
-impl fmt::Debug for TrianglePipelines {
+impl fmt::Debug for PipelineList {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
f.debug_struct("TrianglePipelines").finish()
}
}
-impl TrianglePipelines {
+impl PipelineList {
/// Resets each pipeline's buffers.
fn clear(&mut self) {
self.solid.buffer.clear();
@@ -78,9 +76,9 @@ impl Pipeline {
wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
),
index_strides: Vec::new(),
- pipelines: TrianglePipelines {
- solid: SolidPipeline::new(device, format, antialiasing),
- gradient: GradientPipeline::new(device, format, antialiasing),
+ pipelines: PipelineList {
+ solid: solid::Pipeline::new(device, format, antialiasing),
+ gradient: gradient::Pipeline::new(device, format, antialiasing),
},
}
}
@@ -98,7 +96,7 @@ impl Pipeline {
meshes: &[Mesh<'_>],
) {
//count the total amount of vertices & indices we need to handle
- let (total_vertices, total_indices) = attribute_count_of(meshes);
+ let (total_vertices, total_indices) = mesh::attribute_count_of(meshes);
// Then we ensure the current attribute buffers are big enough, resizing if necessary.
@@ -107,8 +105,8 @@ impl Pipeline {
//the majority of use cases. Therefore we will write GPU data every frame (for now).
let _ = self
.vertex_buffer
- .recreate_if_needed(device, total_vertices);
- let _ = self.index_buffer.recreate_if_needed(device, total_indices);
+ .resize(device, total_vertices);
+ let _ = self.index_buffer.resize(device, total_indices);
//prepare dynamic buffers & data store for writing
self.index_strides.clear();
@@ -258,7 +256,7 @@ fn vertex_buffer_layout<'a>() -> wgpu::VertexBufferLayout<'a> {
}
}
-fn default_fragment_target(
+fn fragment_target(
texture_format: wgpu::TextureFormat,
) -> Option<wgpu::ColorTargetState> {
Some(wgpu::ColorTargetState {
@@ -268,7 +266,7 @@ fn default_fragment_target(
})
}
-fn default_triangle_primitive_state() -> wgpu::PrimitiveState {
+fn primitive_state() -> wgpu::PrimitiveState {
wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
front_face: wgpu::FrontFace::Cw,
@@ -276,7 +274,7 @@ fn default_triangle_primitive_state() -> wgpu::PrimitiveState {
}
}
-fn default_multisample_state(
+fn multisample_state(
antialiasing: Option<settings::Antialiasing>,
) -> wgpu::MultisampleState {
wgpu::MultisampleState {
diff --git a/wgpu/src/triangle/gradient.rs b/wgpu/src/triangle/gradient.rs
index 07551368..92c176af 100644
--- a/wgpu/src/triangle/gradient.rs
+++ b/wgpu/src/triangle/gradient.rs
@@ -1,28 +1,25 @@
-use crate::buffers::dynamic::DynamicBuffer;
+use crate::buffers::dynamic;
use crate::settings;
-use crate::triangle::{
- default_fragment_target, default_multisample_state,
- default_triangle_primitive_state, vertex_buffer_layout,
-};
+use crate::triangle;
use encase::ShaderType;
use glam::{IVec4, Vec4};
use iced_graphics::gradient::Gradient;
use iced_graphics::Transformation;
-pub struct GradientPipeline {
+pub struct Pipeline {
pipeline: wgpu::RenderPipeline,
- pub(super) uniform_buffer: DynamicBuffer<GradientUniforms>,
- pub(super) storage_buffer: DynamicBuffer<GradientStorage>,
+ pub(super) uniform_buffer: dynamic::Buffer<Uniforms>,
+ pub(super) storage_buffer: dynamic::Buffer<Storage>,
color_stop_offset: i32,
//Need to store these and then write them all at once
//or else they will be padded to 256 and cause gaps in the storage buffer
- color_stops_pending_write: GradientStorage,
+ color_stops_pending_write: Storage,
bind_group_layout: wgpu::BindGroupLayout,
bind_group: wgpu::BindGroup,
}
#[derive(Debug, ShaderType)]
-pub(super) struct GradientUniforms {
+pub(super) struct Uniforms {
transform: glam::Mat4,
//xy = start, zw = end
direction: Vec4,
@@ -37,33 +34,33 @@ pub(super) struct ColorStop {
}
#[derive(ShaderType)]
-pub(super) struct GradientStorage {
+pub(super) struct Storage {
#[size(runtime)]
pub color_stops: Vec<ColorStop>,
}
-impl GradientPipeline {
- /// Creates a new [GradientPipeline] using `triangle_gradient.wgsl` shader.
+impl Pipeline {
+ /// Creates a new [GradientPipeline] using `gradient.wgsl` shader.
pub(super) fn new(
device: &wgpu::Device,
format: wgpu::TextureFormat,
antialiasing: Option<settings::Antialiasing>,
) -> Self {
- let uniform_buffer = DynamicBuffer::uniform(
+ let uniform_buffer = dynamic::Buffer::uniform(
device,
- "iced_wgpu::triangle [GRADIENT] uniforms",
+ "iced_wgpu::triangle::gradient uniforms",
);
//Note: with a WASM target storage buffers are not supported. Will need to use UBOs & static
// sized array (eg like the 32-sized array on OpenGL side right now) to make gradients work
- let storage_buffer = DynamicBuffer::storage(
+ let storage_buffer = dynamic::Buffer::storage(
device,
- "iced_wgpu::triangle [GRADIENT] storage",
+ "iced_wgpu::triangle::gradient storage",
);
let bind_group_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
- label: Some("iced_wgpu::triangle [GRADIENT] bind group layout"),
+ label: Some("iced_wgpu::triangle::gradient bind group layout"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
@@ -71,7 +68,7 @@ impl GradientPipeline {
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: true,
- min_binding_size: Some(GradientUniforms::min_size()),
+ min_binding_size: Some(Uniforms::min_size()),
},
count: None,
},
@@ -83,14 +80,14 @@ impl GradientPipeline {
read_only: true,
},
has_dynamic_offset: false,
- min_binding_size: Some(GradientStorage::min_size()),
+ min_binding_size: Some(Storage::min_size()),
},
count: None,
},
],
});
- let bind_group = GradientPipeline::bind_group(
+ let bind_group = Pipeline::bind_group(
device,
uniform_buffer.raw(),
storage_buffer.raw(),
@@ -99,7 +96,7 @@ impl GradientPipeline {
let layout =
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
- label: Some("iced_wgpu::triangle [GRADIENT] pipeline layout"),
+ label: Some("iced_wgpu::triangle::gradient pipeline layout"),
bind_group_layouts: &[&bind_group_layout],
push_constant_ranges: &[],
});
@@ -107,30 +104,30 @@ impl GradientPipeline {
let shader =
device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some(
- "iced_wgpu::triangle [GRADIENT] create shader module",
+ "iced_wgpu::triangle::gradient create shader module",
),
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
- include_str!("../shader/triangle_gradient.wgsl"),
+ include_str!("../shader/gradient.wgsl"),
)),
});
let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
- label: Some("iced_wgpu::triangle [GRADIENT] pipeline"),
+ label: Some("iced_wgpu::triangle::gradient pipeline"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: "vs_main",
- buffers: &[vertex_buffer_layout()],
+ buffers: &[triangle::vertex_buffer_layout()],
},
fragment: Some(wgpu::FragmentState {
module: &shader,
- entry_point: "fs_gradient",
- targets: &[default_fragment_target(format)],
+ entry_point: "fs_main",
+ targets: &[triangle::fragment_target(format)],
}),
- primitive: default_triangle_primitive_state(),
+ primitive: triangle::primitive_state(),
depth_stencil: None,
- multisample: default_multisample_state(antialiasing),
+ multisample: triangle::multisample_state(antialiasing),
multiview: None,
});
@@ -139,7 +136,7 @@ impl GradientPipeline {
uniform_buffer,
storage_buffer,
color_stop_offset: 0,
- color_stops_pending_write: GradientStorage {
+ color_stops_pending_write: Storage {
color_stops: vec![],
},
bind_group_layout,
@@ -155,7 +152,7 @@ impl GradientPipeline {
let end_offset =
(linear.color_stops.len() as i32) + start_offset - 1;
- self.uniform_buffer.push(&GradientUniforms {
+ self.uniform_buffer.push(&Uniforms {
transform: transform.into(),
direction: Vec4::new(
linear.start.x,
@@ -194,7 +191,7 @@ impl GradientPipeline {
layout: &wgpu::BindGroupLayout,
) -> wgpu::BindGroup {
device.create_bind_group(&wgpu::BindGroupDescriptor {
- label: Some("iced_wgpu::triangle [GRADIENT] bind group"),
+ label: Some("iced_wgpu::triangle::gradient bind group"),
layout,
entries: &[
wgpu::BindGroupEntry {
@@ -203,7 +200,7 @@ impl GradientPipeline {
wgpu::BufferBinding {
buffer: uniform_buffer,
offset: 0,
- size: Some(GradientUniforms::min_size()),
+ size: Some(Uniforms::min_size()),
},
),
},
@@ -232,7 +229,7 @@ impl GradientPipeline {
if uniforms_resized || storage_resized {
//recreate bind groups if any buffers were resized
- self.bind_group = GradientPipeline::bind_group(
+ self.bind_group = Pipeline::bind_group(
device,
self.uniform_buffer.raw(),
self.storage_buffer.raw(),
diff --git a/wgpu/src/triangle/solid.rs b/wgpu/src/triangle/solid.rs
index abba4851..4000b059 100644
--- a/wgpu/src/triangle/solid.rs
+++ b/wgpu/src/triangle/solid.rs
@@ -1,27 +1,24 @@
-use crate::buffers::dynamic::DynamicBuffer;
-use crate::triangle::{
- default_fragment_target, default_multisample_state,
- default_triangle_primitive_state, vertex_buffer_layout,
-};
+use crate::buffers::dynamic;
+use crate::triangle;
use crate::{settings, Color};
use encase::ShaderType;
use glam::Vec4;
use iced_graphics::Transformation;
-pub struct SolidPipeline {
+pub struct Pipeline {
pipeline: wgpu::RenderPipeline,
- pub(super) buffer: DynamicBuffer<SolidUniforms>,
+ pub(super) buffer: dynamic::Buffer<Uniforms>,
bind_group_layout: wgpu::BindGroupLayout,
bind_group: wgpu::BindGroup,
}
#[derive(Debug, Clone, Copy, ShaderType)]
-pub(super) struct SolidUniforms {
+pub(super) struct Uniforms {
transform: glam::Mat4,
color: Vec4,
}
-impl SolidUniforms {
+impl Uniforms {
pub fn new(transform: Transformation, color: Color) -> Self {
Self {
transform: transform.into(),
@@ -30,34 +27,34 @@ impl SolidUniforms {
}
}
-impl SolidPipeline {
- /// Creates a new [SolidPipeline] using `triangle_solid.wgsl` shader.
+impl Pipeline {
+ /// Creates a new [SolidPipeline] using `solid.wgsl` shader.
pub fn new(
device: &wgpu::Device,
format: wgpu::TextureFormat,
antialiasing: Option<settings::Antialiasing>,
) -> Self {
- let buffer = DynamicBuffer::uniform(
+ let buffer = dynamic::Buffer::uniform(
device,
- "iced_wgpu::triangle [SOLID] uniforms",
+ "iced_wgpu::triangle::solid uniforms",
);
let bind_group_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
- label: Some("iced_wgpu::triangle [SOLID] bind group layout"),
+ label: Some("iced_wgpu::triangle::solid bind group layout"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: true,
- min_binding_size: Some(SolidUniforms::min_size()),
+ min_binding_size: Some(Uniforms::min_size()),
},
count: None,
}],
});
- let bind_group = SolidPipeline::bind_group(
+ let bind_group = Pipeline::bind_group(
device,
&buffer.raw(),
&bind_group_layout,
@@ -65,36 +62,36 @@ impl SolidPipeline {
let layout =
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
- label: Some("iced_wgpu::triangle [SOLID] pipeline layout"),
+ label: Some("iced_wgpu::triangle::solid pipeline layout"),
bind_group_layouts: &[&bind_group_layout],
push_constant_ranges: &[],
});
let shader =
device.create_shader_module(wgpu::ShaderModuleDescriptor {
- label: Some("iced_wgpu::triangle [SOLID] create shader module"),
+ label: Some("iced_wgpu::triangle::solid create shader module"),
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
- include_str!("../shader/triangle_solid.wgsl"),
+ include_str!("../shader/solid.wgsl"),
)),
});
let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
- label: Some("iced_wgpu::triangle [SOLID] pipeline"),
+ label: Some("iced_wgpu::triangle::solid pipeline"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: "vs_main",
- buffers: &[vertex_buffer_layout()],
+ buffers: &[triangle::vertex_buffer_layout()],
},
fragment: Some(wgpu::FragmentState {
module: &shader,
- entry_point: "fs_solid",
- targets: &[default_fragment_target(format)],
+ entry_point: "fs_main",
+ targets: &[triangle::fragment_target(format)],
}),
- primitive: default_triangle_primitive_state(),
+ primitive: triangle::primitive_state(),
depth_stencil: None,
- multisample: default_multisample_state(antialiasing),
+ multisample: triangle::multisample_state(antialiasing),
multiview: None,
});
@@ -112,14 +109,14 @@ impl SolidPipeline {
layout: &wgpu::BindGroupLayout,
) -> wgpu::BindGroup {
device.create_bind_group(&wgpu::BindGroupDescriptor {
- label: Some("iced_wgpu::triangle [SOLID] bind group"),
+ label: Some("iced_wgpu::triangle::solid bind group"),
layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer,
offset: 0,
- size: Some(SolidUniforms::min_size()),
+ size: Some(Uniforms::min_size()),
}),
}],
})
@@ -127,7 +124,7 @@ impl SolidPipeline {
/// Pushes a new solid uniform to the CPU buffer.
pub fn push(&mut self, transform: Transformation, color: &Color) {
- self.buffer.push(&SolidUniforms::new(transform, *color));
+ self.buffer.push(&Uniforms::new(transform, *color));
}
/// Writes the contents of the solid CPU buffer to the GPU buffer, resizing the GPU buffer
@@ -141,7 +138,7 @@ impl SolidPipeline {
let uniforms_resized = self.buffer.resize(device);
if uniforms_resized {
- self.bind_group = SolidPipeline::bind_group(
+ self.bind_group = Pipeline::bind_group(
device,
self.buffer.raw(),
&self.bind_group_layout,
generated by cgit (git 2.34.1) at 2025-04-16 05:43:18 +0000