summaryrefslogtreecommitdiffstats
path: root/glow/src/triangle.rs
diff options
context:
space:
mode:
Diffstat (limited to 'glow/src/triangle.rs')
-rw-r--r--glow/src/triangle.rs640
1 files changed, 464 insertions, 176 deletions
diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs
index ae4f83ef..d0205e08 100644
--- a/glow/src/triangle.rs
+++ b/glow/src/triangle.rs
@@ -1,204 +1,145 @@
//! Draw meshes of triangles.
-use crate::program::{self, Shader};
+use crate::program;
use crate::Transformation;
+
+use iced_graphics::gradient::Gradient;
+use iced_graphics::layer::mesh::{self, Mesh};
+use iced_graphics::triangle::{ColoredVertex2D, Vertex2D};
+
use glow::HasContext;
-use iced_graphics::layer;
use std::marker::PhantomData;
-pub use iced_graphics::triangle::{Mesh2D, Vertex2D};
-
-const VERTEX_BUFFER_SIZE: usize = 10_000;
-const INDEX_BUFFER_SIZE: usize = 10_000;
+const DEFAULT_VERTICES: usize = 1_000;
+const DEFAULT_INDICES: usize = 1_000;
#[derive(Debug)]
pub(crate) struct Pipeline {
- program: <glow::Context as HasContext>::Program,
- vertex_array: <glow::Context as HasContext>::VertexArray,
- vertices: Buffer<Vertex2D>,
indices: Buffer<u32>,
- transform_location: <glow::Context as HasContext>::UniformLocation,
- current_transform: Transformation,
+ solid: solid::Program,
+ gradient: gradient::Program,
}
impl Pipeline {
- pub fn new(
- gl: &glow::Context,
- shader_version: &program::Version,
- ) -> Pipeline {
- let program = unsafe {
- let vertex_shader = Shader::vertex(
- gl,
- shader_version,
- include_str!("shader/common/triangle.vert"),
- );
- let fragment_shader = Shader::fragment(
- gl,
- shader_version,
- include_str!("shader/common/triangle.frag"),
- );
-
- program::create(
- gl,
- &[vertex_shader, fragment_shader],
- &[(0, "i_Position"), (1, "i_Color")],
- )
- };
-
- let transform_location =
- unsafe { gl.get_uniform_location(program, "u_Transform") }
- .expect("Get transform location");
-
- unsafe {
- gl.use_program(Some(program));
-
- let transform: [f32; 16] = Transformation::identity().into();
- gl.uniform_matrix_4_f32_slice(
- Some(&transform_location),
- false,
- &transform,
- );
-
- gl.use_program(None);
- }
-
- let vertex_array =
- unsafe { gl.create_vertex_array().expect("Create vertex array") };
-
- unsafe {
- gl.bind_vertex_array(Some(vertex_array));
- }
-
- let vertices = unsafe {
- Buffer::new(
- gl,
- glow::ARRAY_BUFFER,
- glow::DYNAMIC_DRAW,
- VERTEX_BUFFER_SIZE,
- )
- };
-
- let indices = unsafe {
+ pub fn new(gl: &glow::Context, shader_version: &program::Version) -> Self {
+ let mut indices = unsafe {
Buffer::new(
gl,
glow::ELEMENT_ARRAY_BUFFER,
glow::DYNAMIC_DRAW,
- INDEX_BUFFER_SIZE,
+ DEFAULT_INDICES,
)
};
+ let solid = solid::Program::new(gl, shader_version);
+ let gradient = gradient::Program::new(gl, shader_version);
+
unsafe {
- let stride = std::mem::size_of::<Vertex2D>() as i32;
-
- gl.enable_vertex_attrib_array(0);
- gl.vertex_attrib_pointer_f32(0, 2, glow::FLOAT, false, stride, 0);
-
- gl.enable_vertex_attrib_array(1);
- gl.vertex_attrib_pointer_f32(
- 1,
- 4,
- glow::FLOAT,
- false,
- stride,
- 4 * 2,
- );
+ gl.bind_vertex_array(Some(solid.vertex_array));
+ indices.bind(gl, 0);
+
+ gl.bind_vertex_array(Some(gradient.vertex_array));
+ indices.bind(gl, 0);
gl.bind_vertex_array(None);
}
- Pipeline {
- program,
- vertex_array,
- vertices,
+ Self {
indices,
- transform_location,
- current_transform: Transformation::identity(),
+ solid,
+ gradient,
}
}
pub fn draw(
&mut self,
+ meshes: &[Mesh<'_>],
gl: &glow::Context,
target_height: u32,
transformation: Transformation,
scale_factor: f32,
- meshes: &[layer::Mesh<'_>],
) {
unsafe {
gl.enable(glow::MULTISAMPLE);
gl.enable(glow::SCISSOR_TEST);
- gl.use_program(Some(self.program));
- gl.bind_vertex_array(Some(self.vertex_array));
}
- // This looks a bit crazy, but we are just counting how many vertices
- // and indices we will need to handle.
- // TODO: Improve readability
- let (total_vertices, total_indices) = meshes
- .iter()
- .map(|layer::Mesh { buffers, .. }| {
- (buffers.vertices.len(), buffers.indices.len())
- })
- .fold((0, 0), |(total_v, total_i), (v, i)| {
- (total_v + v, total_i + i)
- });
-
- // Then we ensure the current buffers are big enough, resizing if
- // necessary
+ // Count the total amount of vertices & indices we need to handle
+ let count = mesh::attribute_count_of(meshes);
+
+ // Then we ensure the current attribute buffers are big enough, resizing if necessary
unsafe {
- self.vertices.bind(gl, total_vertices);
- self.indices.bind(gl, total_indices);
+ self.indices.bind(gl, count.indices);
}
// We upload all the vertices and indices upfront
- let mut last_vertex = 0;
- let mut last_index = 0;
+ let mut solid_vertex_offset = 0;
+ let mut gradient_vertex_offset = 0;
+ let mut index_offset = 0;
- for layer::Mesh { buffers, .. } in meshes {
- unsafe {
- gl.buffer_sub_data_u8_slice(
- glow::ARRAY_BUFFER,
- (last_vertex * std::mem::size_of::<Vertex2D>()) as i32,
- bytemuck::cast_slice(&buffers.vertices),
- );
+ for mesh in meshes {
+ let indices = mesh.indices();
+ unsafe {
gl.buffer_sub_data_u8_slice(
glow::ELEMENT_ARRAY_BUFFER,
- (last_index * std::mem::size_of::<u32>()) as i32,
- bytemuck::cast_slice(&buffers.indices),
+ (index_offset * std::mem::size_of::<u32>()) as i32,
+ bytemuck::cast_slice(indices),
);
- last_vertex += buffers.vertices.len();
- last_index += buffers.indices.len();
+ index_offset += indices.len();
+ }
+
+ match mesh {
+ Mesh::Solid { buffers, .. } => {
+ unsafe {
+ self.solid.vertices.bind(gl, count.solid_vertices);
+
+ gl.buffer_sub_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ (solid_vertex_offset
+ * std::mem::size_of::<ColoredVertex2D>())
+ as i32,
+ bytemuck::cast_slice(&buffers.vertices),
+ );
+ }
+
+ solid_vertex_offset += buffers.vertices.len();
+ }
+ Mesh::Gradient { buffers, .. } => {
+ unsafe {
+ self.gradient
+ .vertices
+ .bind(gl, count.gradient_vertices);
+
+ gl.buffer_sub_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ (gradient_vertex_offset
+ * std::mem::size_of::<Vertex2D>())
+ as i32,
+ bytemuck::cast_slice(&buffers.vertices),
+ );
+ }
+
+ gradient_vertex_offset += buffers.vertices.len();
+ }
}
}
// Then we draw each mesh using offsets
- let mut last_vertex = 0;
+ let mut last_solid_vertex = 0;
+ let mut last_gradient_vertex = 0;
let mut last_index = 0;
- for layer::Mesh {
- buffers,
- origin,
- clip_bounds,
- } in meshes
- {
+ for mesh in meshes {
+ let indices = mesh.indices();
+ let origin = mesh.origin();
+
let transform =
transformation * Transformation::translate(origin.x, origin.y);
- let clip_bounds = (*clip_bounds * scale_factor).snap();
+ let clip_bounds = (mesh.clip_bounds() * scale_factor).snap();
unsafe {
- if self.current_transform != transform {
- let matrix: [f32; 16] = transform.into();
- gl.uniform_matrix_4_f32_slice(
- Some(&self.transform_location),
- false,
- &matrix,
- );
-
- self.current_transform = transform;
- }
-
gl.scissor(
clip_bounds.x as i32,
(target_height - (clip_bounds.y + clip_bounds.height))
@@ -206,56 +147,138 @@ impl Pipeline {
clip_bounds.width as i32,
clip_bounds.height as i32,
);
+ }
- gl.draw_elements_base_vertex(
- glow::TRIANGLES,
- buffers.indices.len() as i32,
- glow::UNSIGNED_INT,
- (last_index * std::mem::size_of::<u32>()) as i32,
- last_vertex as i32,
- );
+ match mesh {
+ Mesh::Solid { buffers, .. } => unsafe {
+ gl.use_program(Some(self.solid.program));
+ gl.bind_vertex_array(Some(self.solid.vertex_array));
+
+ if transform != self.solid.uniforms.transform {
+ gl.uniform_matrix_4_f32_slice(
+ Some(&self.solid.uniforms.transform_location),
+ false,
+ transform.as_ref(),
+ );
+
+ self.solid.uniforms.transform = transform;
+ }
+
+ gl.draw_elements_base_vertex(
+ glow::TRIANGLES,
+ indices.len() as i32,
+ glow::UNSIGNED_INT,
+ (last_index * std::mem::size_of::<u32>()) as i32,
+ last_solid_vertex as i32,
+ );
- last_vertex += buffers.vertices.len();
- last_index += buffers.indices.len();
+ last_solid_vertex += buffers.vertices.len();
+ },
+ Mesh::Gradient {
+ buffers, gradient, ..
+ } => unsafe {
+ gl.use_program(Some(self.gradient.program));
+ gl.bind_vertex_array(Some(self.gradient.vertex_array));
+
+ if transform != self.gradient.uniforms.transform {
+ gl.uniform_matrix_4_f32_slice(
+ Some(&self.gradient.uniforms.locations.transform),
+ false,
+ transform.as_ref(),
+ );
+
+ self.gradient.uniforms.transform = transform;
+ }
+
+ if &self.gradient.uniforms.gradient != *gradient {
+ match gradient {
+ Gradient::Linear(linear) => {
+ gl.uniform_4_f32(
+ Some(
+ &self
+ .gradient
+ .uniforms
+ .locations
+ .gradient_direction,
+ ),
+ linear.start.x,
+ linear.start.y,
+ linear.end.x,
+ linear.end.y,
+ );
+
+ gl.uniform_1_i32(
+ Some(
+ &self
+ .gradient
+ .uniforms
+ .locations
+ .color_stops_size,
+ ),
+ (linear.color_stops.len() * 2) as i32,
+ );
+
+ let mut stops = [0.0; 128];
+
+ for (index, stop) in linear
+ .color_stops
+ .iter()
+ .enumerate()
+ .take(16)
+ {
+ let [r, g, b, a] = stop.color.into_linear();
+
+ stops[index * 8] = r;
+ stops[(index * 8) + 1] = g;
+ stops[(index * 8) + 2] = b;
+ stops[(index * 8) + 3] = a;
+ stops[(index * 8) + 4] = stop.offset;
+ stops[(index * 8) + 5] = 0.;
+ stops[(index * 8) + 6] = 0.;
+ stops[(index * 8) + 7] = 0.;
+ }
+
+ gl.uniform_4_f32_slice(
+ Some(
+ &self
+ .gradient
+ .uniforms
+ .locations
+ .color_stops,
+ ),
+ &stops,
+ );
+ }
+ }
+
+ self.gradient.uniforms.gradient = (*gradient).clone();
+ }
+
+ gl.draw_elements_base_vertex(
+ glow::TRIANGLES,
+ indices.len() as i32,
+ glow::UNSIGNED_INT,
+ (last_index * std::mem::size_of::<u32>()) as i32,
+ last_gradient_vertex as i32,
+ );
+
+ last_gradient_vertex += buffers.vertices.len();
+ },
}
+
+ last_index += indices.len();
}
unsafe {
gl.bind_vertex_array(None);
- gl.use_program(None);
gl.disable(glow::SCISSOR_TEST);
gl.disable(glow::MULTISAMPLE);
}
}
}
-#[repr(C)]
-#[derive(Debug, Clone, Copy)]
-struct Uniforms {
- transform: [f32; 16],
-}
-
-unsafe impl bytemuck::Zeroable for Uniforms {}
-unsafe impl bytemuck::Pod for Uniforms {}
-
-impl Default for Uniforms {
- fn default() -> Self {
- Self {
- transform: *Transformation::identity().as_ref(),
- }
- }
-}
-
-impl From<Transformation> for Uniforms {
- fn from(transformation: Transformation) -> Uniforms {
- Self {
- transform: transformation.into(),
- }
- }
-}
-
#[derive(Debug)]
-struct Buffer<T> {
+pub struct Buffer<T> {
raw: <glow::Context as HasContext>::Buffer,
target: u32,
usage: u32,
@@ -299,3 +322,268 @@ impl<T> Buffer<T> {
}
}
}
+
+mod solid {
+ use crate::program;
+ use crate::triangle;
+ use glow::{Context, HasContext, NativeProgram};
+ use iced_graphics::triangle::ColoredVertex2D;
+ use iced_graphics::Transformation;
+
+ #[derive(Debug)]
+ pub struct Program {
+ pub program: <Context as HasContext>::Program,
+ pub vertex_array: <glow::Context as HasContext>::VertexArray,
+ pub vertices: triangle::Buffer<ColoredVertex2D>,
+ pub uniforms: Uniforms,
+ }
+
+ impl Program {
+ pub fn new(gl: &Context, shader_version: &program::Version) -> Self {
+ let program = unsafe {
+ let vertex_shader = program::Shader::vertex(
+ gl,
+ shader_version,
+ include_str!("shader/common/solid.vert"),
+ );
+
+ let fragment_shader = program::Shader::fragment(
+ gl,
+ shader_version,
+ include_str!("shader/common/solid.frag"),
+ );
+
+ program::create(
+ gl,
+ &[vertex_shader, fragment_shader],
+ &[(0, "i_Position"), (1, "i_Color")],
+ )
+ };
+
+ let vertex_array = unsafe {
+ gl.create_vertex_array().expect("Create vertex array")
+ };
+
+ let vertices = unsafe {
+ triangle::Buffer::new(
+ gl,
+ glow::ARRAY_BUFFER,
+ glow::DYNAMIC_DRAW,
+ super::DEFAULT_VERTICES,
+ )
+ };
+
+ unsafe {
+ gl.bind_vertex_array(Some(vertex_array));
+
+ let stride = std::mem::size_of::<ColoredVertex2D>() as i32;
+
+ gl.enable_vertex_attrib_array(0);
+ gl.vertex_attrib_pointer_f32(
+ 0,
+ 2,
+ glow::FLOAT,
+ false,
+ stride,
+ 0,
+ );
+
+ gl.enable_vertex_attrib_array(1);
+ gl.vertex_attrib_pointer_f32(
+ 1,
+ 4,
+ glow::FLOAT,
+ false,
+ stride,
+ 4 * 2,
+ );
+
+ gl.bind_vertex_array(None);
+ };
+
+ Self {
+ program,
+ vertex_array,
+ vertices,
+ uniforms: Uniforms::new(gl, program),
+ }
+ }
+ }
+
+ #[derive(Debug)]
+ pub struct Uniforms {
+ pub transform: Transformation,
+ pub transform_location: <Context as HasContext>::UniformLocation,
+ }
+
+ impl Uniforms {
+ fn new(gl: &Context, program: NativeProgram) -> Self {
+ let transform = Transformation::identity();
+ let transform_location =
+ unsafe { gl.get_uniform_location(program, "u_Transform") }
+ .expect("Solid - Get u_Transform.");
+
+ unsafe {
+ gl.use_program(Some(program));
+
+ gl.uniform_matrix_4_f32_slice(
+ Some(&transform_location),
+ false,
+ transform.as_ref(),
+ );
+
+ gl.use_program(None);
+ }
+
+ Self {
+ transform,
+ transform_location,
+ }
+ }
+ }
+}
+
+mod gradient {
+ use crate::program;
+ use crate::triangle;
+ use glow::{Context, HasContext, NativeProgram};
+ use iced_graphics::gradient::{self, Gradient};
+ use iced_graphics::triangle::Vertex2D;
+ use iced_graphics::Transformation;
+
+ #[derive(Debug)]
+ pub struct Program {
+ pub program: <Context as HasContext>::Program,
+ pub vertex_array: <glow::Context as HasContext>::VertexArray,
+ pub vertices: triangle::Buffer<Vertex2D>,
+ pub uniforms: Uniforms,
+ }
+
+ impl Program {
+ pub fn new(gl: &Context, shader_version: &program::Version) -> Self {
+ let program = unsafe {
+ let vertex_shader = program::Shader::vertex(
+ gl,
+ shader_version,
+ include_str!("shader/common/gradient.vert"),
+ );
+
+ let fragment_shader = program::Shader::fragment(
+ gl,
+ shader_version,
+ include_str!("shader/common/gradient.frag"),
+ );
+
+ program::create(
+ gl,
+ &[vertex_shader, fragment_shader],
+ &[(0, "i_Position")],
+ )
+ };
+
+ let vertex_array = unsafe {
+ gl.create_vertex_array().expect("Create vertex array")
+ };
+
+ let vertices = unsafe {
+ triangle::Buffer::new(
+ gl,
+ glow::ARRAY_BUFFER,
+ glow::DYNAMIC_DRAW,
+ super::DEFAULT_VERTICES,
+ )
+ };
+
+ unsafe {
+ gl.bind_vertex_array(Some(vertex_array));
+
+ let stride = std::mem::size_of::<Vertex2D>() as i32;
+
+ gl.enable_vertex_attrib_array(0);
+ gl.vertex_attrib_pointer_f32(
+ 0,
+ 2,
+ glow::FLOAT,
+ false,
+ stride,
+ 0,
+ );
+
+ gl.bind_vertex_array(None);
+ };
+
+ Self {
+ program,
+ vertex_array,
+ vertices,
+ uniforms: Uniforms::new(gl, program),
+ }
+ }
+ }
+
+ #[derive(Debug)]
+ pub struct Uniforms {
+ pub gradient: Gradient,
+ pub transform: Transformation,
+ pub locations: Locations,
+ }
+
+ #[derive(Debug)]
+ pub struct Locations {
+ pub gradient_direction: <Context as HasContext>::UniformLocation,
+ pub color_stops_size: <Context as HasContext>::UniformLocation,
+ //currently the maximum number of stops is 16 due to lack of SSBO in GL2.1
+ pub color_stops: <Context as HasContext>::UniformLocation,
+ pub transform: <Context as HasContext>::UniformLocation,
+ }
+
+ impl Uniforms {
+ fn new(gl: &Context, program: NativeProgram) -> Self {
+ let gradient_direction = unsafe {
+ gl.get_uniform_location(program, "gradient_direction")
+ }
+ .expect("Gradient - Get gradient_direction.");
+
+ let color_stops_size =
+ unsafe { gl.get_uniform_location(program, "color_stops_size") }
+ .expect("Gradient - Get color_stops_size.");
+
+ let color_stops = unsafe {
+ gl.get_uniform_location(program, "color_stops")
+ .expect("Gradient - Get color_stops.")
+ };
+
+ let transform = Transformation::identity();
+ let transform_location =
+ unsafe { gl.get_uniform_location(program, "u_Transform") }
+ .expect("Solid - Get u_Transform.");
+
+ unsafe {
+ gl.use_program(Some(program));
+
+ gl.uniform_matrix_4_f32_slice(
+ Some(&transform_location),
+ false,
+ transform.as_ref(),
+ );
+
+ gl.use_program(None);
+ }
+
+ Self {
+ gradient: Gradient::Linear(gradient::Linear {
+ start: Default::default(),
+ end: Default::default(),
+ color_stops: vec![],
+ }),
+ transform: Transformation::identity(),
+ locations: Locations {
+ gradient_direction,
+ color_stops_size,
+ color_stops,
+ transform: transform_location,
+ },
+ }
+ }
+ }
+}
generated by cgit (git 2.34.1) at 2025-04-29 00:51:30 +0000