From 3c5ab3011772bf7dbdceafd00c0059dfac5aa40f Mon Sep 17 00:00:00 2001 From: Richard Date: Mon, 1 Nov 2021 18:37:11 -0300 Subject: Use `glutin`, `glow` and `glow_glyph` forks --- glow/Cargo.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'glow') diff --git a/glow/Cargo.toml b/glow/Cargo.toml index e40b8ba8..1fab7c53 100644 --- a/glow/Cargo.toml +++ b/glow/Cargo.toml @@ -16,8 +16,8 @@ image = [] svg = [] [dependencies] -glow = "0.6" -glow_glyph = "0.4" +glow = "0.11.1" +glow_glyph = "0.5.0" glyph_brush = "0.7" euclid = "0.22" bytemuck = "1.4" -- cgit From 381052c50e8c3458a681ec4f2df6c74a40baf5d2 Mon Sep 17 00:00:00 2001 From: Richard Date: Thu, 4 Nov 2021 19:26:49 -0300 Subject: Split `quad::Pipeline` into `core` and `compatibility` --- glow/src/quad.rs | 234 +++---------------- glow/src/quad/compatibility.rs | 347 ++++++++++++++++++++++++++++ glow/src/quad/core.rs | 233 +++++++++++++++++++ glow/src/shader/compatibility/quad.frag | 62 +++++ glow/src/shader/compatibility/quad.vert | 46 ++++ glow/src/shader/compatibility/triangle.frag | 8 + glow/src/shader/compatibility/triangle.vert | 13 ++ glow/src/shader/core/quad.frag | 70 ++++++ glow/src/shader/core/quad.vert | 52 +++++ glow/src/shader/core/triangle.frag | 9 + glow/src/shader/core/triangle.vert | 13 ++ glow/src/shader/quad.frag | 70 ------ glow/src/shader/quad.vert | 52 ----- glow/src/shader/triangle.frag | 9 - glow/src/shader/triangle.vert | 13 -- glow/src/triangle.rs | 7 +- 16 files changed, 886 insertions(+), 352 deletions(-) create mode 100644 glow/src/quad/compatibility.rs create mode 100644 glow/src/quad/core.rs create mode 100644 glow/src/shader/compatibility/quad.frag create mode 100644 glow/src/shader/compatibility/quad.vert create mode 100644 glow/src/shader/compatibility/triangle.frag create mode 100644 glow/src/shader/compatibility/triangle.vert create mode 100644 glow/src/shader/core/quad.frag create mode 100644 glow/src/shader/core/quad.vert create mode 100644 glow/src/shader/core/triangle.frag create mode 100644 glow/src/shader/core/triangle.vert delete mode 100644 glow/src/shader/quad.frag delete mode 100644 glow/src/shader/quad.vert delete mode 100644 glow/src/shader/triangle.frag delete mode 100644 glow/src/shader/triangle.vert (limited to 'glow') diff --git a/glow/src/quad.rs b/glow/src/quad.rs index a8fbb9e5..5438024c 100644 --- a/glow/src/quad.rs +++ b/glow/src/quad.rs @@ -1,77 +1,24 @@ -use crate::program; +mod compatibility; +mod core; + use crate::Transformation; use glow::HasContext; use iced_graphics::layer; use iced_native::Rectangle; -const MAX_INSTANCES: usize = 100_000; - #[derive(Debug)] -pub struct Pipeline { - program: ::Program, - vertex_array: ::VertexArray, - instances: ::Buffer, - transform_location: ::UniformLocation, - scale_location: ::UniformLocation, - screen_height_location: ::UniformLocation, - current_transform: Transformation, - current_scale: f32, - current_target_height: u32, +pub enum Pipeline { + Core(core::Pipeline), + Compatibility(compatibility::Pipeline), } impl Pipeline { pub fn new(gl: &glow::Context) -> Pipeline { - let program = unsafe { - program::create( - gl, - &[ - (glow::VERTEX_SHADER, include_str!("shader/quad.vert")), - (glow::FRAGMENT_SHADER, include_str!("shader/quad.frag")), - ], - ) - }; - - let transform_location = - unsafe { gl.get_uniform_location(program, "u_Transform") } - .expect("Get transform location"); - - let scale_location = - unsafe { gl.get_uniform_location(program, "u_Scale") } - .expect("Get scale location"); - - let screen_height_location = - unsafe { gl.get_uniform_location(program, "u_ScreenHeight") } - .expect("Get target height location"); - - unsafe { - gl.use_program(Some(program)); - - let matrix: [f32; 16] = Transformation::identity().into(); - gl.uniform_matrix_4_f32_slice( - Some(&transform_location), - false, - &matrix, - ); - - gl.uniform_1_f32(Some(&scale_location), 1.0); - gl.uniform_1_f32(Some(&screen_height_location), 0.0); - - gl.use_program(None); - } - - let (vertex_array, instances) = - unsafe { create_instance_buffer(gl, MAX_INSTANCES) }; - - Pipeline { - program, - vertex_array, - instances, - transform_location, - scale_location, - screen_height_location, - current_transform: Transformation::identity(), - current_scale: 1.0, - current_target_height: 0, + let version = gl.version(); + if version.is_embedded || version.major == 2 { + Pipeline::Compatibility(compatibility::Pipeline::new(gl)) + } else { + Pipeline::Core(core::Pipeline::new(gl)) } } @@ -84,152 +31,27 @@ impl Pipeline { scale: f32, bounds: Rectangle, ) { - unsafe { - gl.enable(glow::SCISSOR_TEST); - gl.scissor( - bounds.x as i32, - (target_height - (bounds.y + bounds.height)) as i32, - bounds.width as i32, - bounds.height as i32, - ); - - gl.use_program(Some(self.program)); - gl.bind_vertex_array(Some(self.vertex_array)); - gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.instances)); - } - - if transformation != self.current_transform { - unsafe { - let matrix: [f32; 16] = transformation.into(); - gl.uniform_matrix_4_f32_slice( - Some(&self.transform_location), - false, - &matrix, - ); - - self.current_transform = transformation; - } - } - - if scale != self.current_scale { - unsafe { - gl.uniform_1_f32(Some(&self.scale_location), scale); - } - - self.current_scale = scale; - } - - if target_height != self.current_target_height { - unsafe { - gl.uniform_1_f32( - Some(&self.screen_height_location), - target_height as f32, + match self { + Pipeline::Core(pipeline) => { + pipeline.draw( + gl, + target_height, + instances, + transformation, + scale, + bounds, ); } - - self.current_target_height = target_height; - } - - let mut i = 0; - let total = instances.len(); - - while i < total { - let end = (i + MAX_INSTANCES).min(total); - let amount = end - i; - - unsafe { - gl.buffer_sub_data_u8_slice( - glow::ARRAY_BUFFER, - 0, - bytemuck::cast_slice(&instances[i..end]), - ); - - gl.draw_arrays_instanced( - glow::TRIANGLE_STRIP, - 0, - 4, - amount as i32, + Pipeline::Compatibility(pipeline) => { + pipeline.draw( + gl, + target_height, + instances, + transformation, + scale, + bounds, ); } - - i += MAX_INSTANCES; - } - - unsafe { - gl.bind_vertex_array(None); - gl.use_program(None); - gl.disable(glow::SCISSOR_TEST); } } } - -unsafe fn create_instance_buffer( - gl: &glow::Context, - size: usize, -) -> ( - ::VertexArray, - ::Buffer, -) { - let vertex_array = gl.create_vertex_array().expect("Create vertex array"); - let buffer = gl.create_buffer().expect("Create instance buffer"); - - gl.bind_vertex_array(Some(vertex_array)); - gl.bind_buffer(glow::ARRAY_BUFFER, Some(buffer)); - gl.buffer_data_size( - glow::ARRAY_BUFFER, - (size * std::mem::size_of::()) as i32, - glow::DYNAMIC_DRAW, - ); - - let stride = std::mem::size_of::() as i32; - - gl.enable_vertex_attrib_array(0); - gl.vertex_attrib_pointer_f32(0, 2, glow::FLOAT, false, stride, 0); - gl.vertex_attrib_divisor(0, 1); - - gl.enable_vertex_attrib_array(1); - gl.vertex_attrib_pointer_f32(1, 2, glow::FLOAT, false, stride, 4 * 2); - gl.vertex_attrib_divisor(1, 1); - - gl.enable_vertex_attrib_array(2); - gl.vertex_attrib_pointer_f32(2, 4, glow::FLOAT, false, stride, 4 * (2 + 2)); - gl.vertex_attrib_divisor(2, 1); - - gl.enable_vertex_attrib_array(3); - gl.vertex_attrib_pointer_f32( - 3, - 4, - glow::FLOAT, - false, - stride, - 4 * (2 + 2 + 4), - ); - gl.vertex_attrib_divisor(3, 1); - - gl.enable_vertex_attrib_array(4); - gl.vertex_attrib_pointer_f32( - 4, - 1, - glow::FLOAT, - false, - stride, - 4 * (2 + 2 + 4 + 4), - ); - gl.vertex_attrib_divisor(4, 1); - - gl.enable_vertex_attrib_array(5); - gl.vertex_attrib_pointer_f32( - 5, - 1, - glow::FLOAT, - false, - stride, - 4 * (2 + 2 + 4 + 4 + 1), - ); - gl.vertex_attrib_divisor(5, 1); - - gl.bind_vertex_array(None); - gl.bind_buffer(glow::ARRAY_BUFFER, None); - - (vertex_array, buffer) -} diff --git a/glow/src/quad/compatibility.rs b/glow/src/quad/compatibility.rs new file mode 100644 index 00000000..e083dcf1 --- /dev/null +++ b/glow/src/quad/compatibility.rs @@ -0,0 +1,347 @@ +use crate::program; +use crate::Transformation; +use glow::HasContext; +use iced_graphics::layer; +use iced_native::Rectangle; + +// Only change `MAX_QUADS`, otherwise you could cause problems +// by splitting a triangle into different render passes. +const MAX_QUADS: usize = 100_000; +const MAX_VERTICES: usize = MAX_QUADS * 4; +const MAX_INDICES: usize = MAX_QUADS * 6; + +#[derive(Debug)] +pub struct Pipeline { + program: ::Program, + vertex_array: ::VertexArray, + vertex_buffer: ::Buffer, + index_buffer: ::Buffer, + transform_location: ::UniformLocation, + scale_location: ::UniformLocation, + screen_height_location: ::UniformLocation, + current_transform: Transformation, + current_scale: f32, + current_target_height: u32, +} + +impl Pipeline { + pub fn new(gl: &glow::Context) -> Pipeline { + let program = unsafe { + program::create( + gl, + &[ + ( + glow::VERTEX_SHADER, + include_str!("../shader/compatibility/quad.vert"), + ), + ( + glow::FRAGMENT_SHADER, + include_str!("../shader/compatibility/quad.frag"), + ), + ], + ) + }; + + let transform_location = + unsafe { gl.get_uniform_location(program, "u_Transform") } + .expect("Get transform location"); + + let scale_location = + unsafe { gl.get_uniform_location(program, "u_Scale") } + .expect("Get scale location"); + + let screen_height_location = + unsafe { gl.get_uniform_location(program, "u_ScreenHeight") } + .expect("Get target height location"); + + unsafe { + gl.use_program(Some(program)); + + let matrix: [f32; 16] = Transformation::identity().into(); + gl.uniform_matrix_4_f32_slice( + Some(&transform_location), + false, + &matrix, + ); + + gl.uniform_1_f32(Some(&scale_location), 1.0); + gl.uniform_1_f32(Some(&screen_height_location), 0.0); + + gl.use_program(None); + } + + let (vertex_array, vertex_buffer, index_buffer) = + unsafe { create_buffers(gl, MAX_VERTICES) }; + + Pipeline { + program, + vertex_array, + vertex_buffer, + index_buffer, + transform_location, + scale_location, + screen_height_location, + current_transform: Transformation::identity(), + current_scale: 1.0, + current_target_height: 0, + } + } + + pub fn draw( + &mut self, + gl: &glow::Context, + target_height: u32, + instances: &[layer::Quad], + transformation: Transformation, + scale: f32, + bounds: Rectangle, + ) { + // TODO: Remove this allocation (probably by changing the shader and removing the need of two `position`) + let vertices: Vec = instances + .iter() + .flat_map(|quad| Vertex::from_quad(quad)) + .collect(); + + // TODO: Remove this allocation (or allocate only when needed) + let indices: Vec = (0..instances.len().min(MAX_QUADS) as i32) + .flat_map(|i| { + [ + 0 + i * 4, + 1 + i * 4, + 2 + i * 4, + 2 + i * 4, + 1 + i * 4, + 3 + i * 4, + ] + }) + .cycle() + .take(instances.len() * 6) + .collect(); + + unsafe { + gl.enable(glow::SCISSOR_TEST); + gl.scissor( + bounds.x as i32, + (target_height - (bounds.y + bounds.height)) as i32, + bounds.width as i32, + bounds.height as i32, + ); + + gl.use_program(Some(self.program)); + gl.bind_vertex_array(Some(self.vertex_array)); + gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.vertex_buffer)); + gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(self.index_buffer)); + } + + if transformation != self.current_transform { + unsafe { + let matrix: [f32; 16] = transformation.into(); + gl.uniform_matrix_4_f32_slice( + Some(&self.transform_location), + false, + &matrix, + ); + + self.current_transform = transformation; + } + } + + if scale != self.current_scale { + unsafe { + gl.uniform_1_f32(Some(&self.scale_location), scale); + } + + self.current_scale = scale; + } + + if target_height != self.current_target_height { + unsafe { + gl.uniform_1_f32( + Some(&self.screen_height_location), + target_height as f32, + ); + } + + self.current_target_height = target_height; + } + + let passes = vertices + .chunks(MAX_VERTICES) + .zip(indices.chunks(MAX_INDICES)); + + for (vertices, indices) in passes { + unsafe { + gl.buffer_sub_data_u8_slice( + glow::ARRAY_BUFFER, + 0, + bytemuck::cast_slice(&vertices), + ); + + gl.buffer_sub_data_u8_slice( + glow::ELEMENT_ARRAY_BUFFER, + 0, + bytemuck::cast_slice(&indices), + ); + + gl.draw_elements( + glow::TRIANGLES, + indices.len() as i32, + glow::UNSIGNED_INT, + 0, + ); + } + } + + unsafe { + gl.bind_vertex_array(None); + gl.use_program(None); + gl.disable(glow::SCISSOR_TEST); + } + } +} + +unsafe fn create_buffers( + gl: &glow::Context, + size: usize, +) -> ( + ::VertexArray, + ::Buffer, + ::Buffer, +) { + let vertex_array = gl.create_vertex_array().expect("Create vertex array"); + let vertex_buffer = gl.create_buffer().expect("Create vertex buffer"); + let index_buffer = gl.create_buffer().expect("Create index buffer"); + + gl.bind_vertex_array(Some(vertex_array)); + + gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(index_buffer)); + gl.buffer_data_size( + glow::ELEMENT_ARRAY_BUFFER, + 12 * size as i32, + glow::DYNAMIC_DRAW, + ); + + gl.bind_buffer(glow::ARRAY_BUFFER, Some(vertex_buffer)); + gl.buffer_data_size( + glow::ARRAY_BUFFER, + (size * Vertex::SIZE) as i32, + glow::DYNAMIC_DRAW, + ); + + let stride = Vertex::SIZE 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, 2, glow::FLOAT, false, stride, 4 * 2); + + gl.enable_vertex_attrib_array(2); + gl.vertex_attrib_pointer_f32(2, 4, glow::FLOAT, false, stride, 4 * (2 + 2)); + + gl.enable_vertex_attrib_array(3); + gl.vertex_attrib_pointer_f32( + 3, + 4, + glow::FLOAT, + false, + stride, + 4 * (2 + 2 + 4), + ); + + gl.enable_vertex_attrib_array(4); + gl.vertex_attrib_pointer_f32( + 4, + 1, + glow::FLOAT, + false, + stride, + 4 * (2 + 2 + 4 + 4), + ); + + gl.enable_vertex_attrib_array(5); + gl.vertex_attrib_pointer_f32( + 5, + 1, + glow::FLOAT, + false, + stride, + 4 * (2 + 2 + 4 + 4 + 1), + ); + + gl.enable_vertex_attrib_array(6); + gl.vertex_attrib_pointer_f32( + 6, + 2, + glow::FLOAT, + false, + stride, + 4 * (2 + 2 + 4 + 4 + 1 + 1), + ); + + gl.bind_vertex_array(None); + gl.bind_buffer(glow::ARRAY_BUFFER, None); + gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, None); + + (vertex_array, vertex_buffer, index_buffer) +} + +/// The vertex of a colored rectangle with a border. +/// +/// This type can be directly uploaded to GPU memory. +#[derive(Debug, Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)] +#[repr(C)] +pub struct Vertex { + /// The position of the [`Vertex`]. + pub position: [f32; 2], + + /// The size of the [`Vertex`]. + pub size: [f32; 2], + + /// The color of the [`Vertex`], in __linear RGB__. + pub color: [f32; 4], + + /// The border color of the [`Vertex`], in __linear RGB__. + pub border_color: [f32; 4], + + /// The border radius of the [`Vertex`]. + pub border_radius: f32, + + /// The border width of the [`Vertex`]. + pub border_width: f32, + + /// The __quad__ position of the [`Vertex`]. + pub q_position: [f32; 2], +} + +impl Vertex { + const SIZE: usize = std::mem::size_of::(); + + fn from_quad(quad: &layer::Quad) -> [Vertex; 4] { + let base = Vertex { + position: quad.position, + size: quad.size, + color: quad.color, + border_color: quad.color, + border_radius: quad.border_radius, + border_width: quad.border_width, + q_position: [0.0, 0.0], + }; + + [ + base, + Self { + q_position: [0.0, 1.0], + ..base + }, + Self { + q_position: [1.0, 0.0], + ..base + }, + Self { + q_position: [1.0, 1.0], + ..base + }, + ] + } +} diff --git a/glow/src/quad/core.rs b/glow/src/quad/core.rs new file mode 100644 index 00000000..c843e8c7 --- /dev/null +++ b/glow/src/quad/core.rs @@ -0,0 +1,233 @@ +use crate::program; +use crate::Transformation; +use glow::HasContext; +use iced_graphics::layer; +use iced_native::Rectangle; + +const MAX_INSTANCES: usize = 100_000; + +#[derive(Debug)] +pub struct Pipeline { + program: ::Program, + vertex_array: ::VertexArray, + instances: ::Buffer, + transform_location: ::UniformLocation, + scale_location: ::UniformLocation, + screen_height_location: ::UniformLocation, + current_transform: Transformation, + current_scale: f32, + current_target_height: u32, +} + +impl Pipeline { + pub fn new(gl: &glow::Context) -> Pipeline { + let program = unsafe { + program::create( + gl, + &[ + ( + glow::VERTEX_SHADER, + include_str!("../shader/core/quad.vert"), + ), + ( + glow::FRAGMENT_SHADER, + include_str!("../shader/core/quad.frag"), + ), + ], + ) + }; + + let transform_location = + unsafe { gl.get_uniform_location(program, "u_Transform") } + .expect("Get transform location"); + + let scale_location = + unsafe { gl.get_uniform_location(program, "u_Scale") } + .expect("Get scale location"); + + let screen_height_location = + unsafe { gl.get_uniform_location(program, "u_ScreenHeight") } + .expect("Get target height location"); + + unsafe { + gl.use_program(Some(program)); + + let matrix: [f32; 16] = Transformation::identity().into(); + gl.uniform_matrix_4_f32_slice( + Some(&transform_location), + false, + &matrix, + ); + + gl.uniform_1_f32(Some(&scale_location), 1.0); + gl.uniform_1_f32(Some(&screen_height_location), 0.0); + + gl.use_program(None); + } + + let (vertex_array, instances) = + unsafe { create_instance_buffer(gl, MAX_INSTANCES) }; + + Pipeline { + program, + vertex_array, + instances, + transform_location, + scale_location, + screen_height_location, + current_transform: Transformation::identity(), + current_scale: 1.0, + current_target_height: 0, + } + } + + pub fn draw( + &mut self, + gl: &glow::Context, + target_height: u32, + instances: &[layer::Quad], + transformation: Transformation, + scale: f32, + bounds: Rectangle, + ) { + unsafe { + gl.enable(glow::SCISSOR_TEST); + gl.scissor( + bounds.x as i32, + (target_height - (bounds.y + bounds.height)) as i32, + bounds.width as i32, + bounds.height as i32, + ); + + gl.use_program(Some(self.program)); + gl.bind_vertex_array(Some(self.vertex_array)); + gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.instances)); + } + + if transformation != self.current_transform { + unsafe { + let matrix: [f32; 16] = transformation.into(); + gl.uniform_matrix_4_f32_slice( + Some(&self.transform_location), + false, + &matrix, + ); + + self.current_transform = transformation; + } + } + + if scale != self.current_scale { + unsafe { + gl.uniform_1_f32(Some(&self.scale_location), scale); + } + + self.current_scale = scale; + } + + if target_height != self.current_target_height { + unsafe { + gl.uniform_1_f32( + Some(&self.screen_height_location), + target_height as f32, + ); + } + + self.current_target_height = target_height; + } + + for instances in instances.chunks(MAX_INSTANCES) { + unsafe { + gl.buffer_sub_data_u8_slice( + glow::ARRAY_BUFFER, + 0, + bytemuck::cast_slice(&instances), + ); + + gl.draw_arrays_instanced( + glow::TRIANGLE_STRIP, + 0, + 4, + instances.len() as i32, + ); + } + } + + unsafe { + gl.bind_vertex_array(None); + gl.use_program(None); + gl.disable(glow::SCISSOR_TEST); + } + } +} + +unsafe fn create_instance_buffer( + gl: &glow::Context, + size: usize, +) -> ( + ::VertexArray, + ::Buffer, +) { + let vertex_array = gl.create_vertex_array().expect("Create vertex array"); + let buffer = gl.create_buffer().expect("Create instance buffer"); + + gl.bind_vertex_array(Some(vertex_array)); + gl.bind_buffer(glow::ARRAY_BUFFER, Some(buffer)); + gl.buffer_data_size( + glow::ARRAY_BUFFER, + (size * std::mem::size_of::()) as i32, + glow::DYNAMIC_DRAW, + ); + + let stride = std::mem::size_of::() as i32; + + gl.enable_vertex_attrib_array(0); + gl.vertex_attrib_pointer_f32(0, 2, glow::FLOAT, false, stride, 0); + gl.vertex_attrib_divisor(0, 1); + + gl.enable_vertex_attrib_array(1); + gl.vertex_attrib_pointer_f32(1, 2, glow::FLOAT, false, stride, 4 * 2); + gl.vertex_attrib_divisor(1, 1); + + gl.enable_vertex_attrib_array(2); + gl.vertex_attrib_pointer_f32(2, 4, glow::FLOAT, false, stride, 4 * (2 + 2)); + gl.vertex_attrib_divisor(2, 1); + + gl.enable_vertex_attrib_array(3); + gl.vertex_attrib_pointer_f32( + 3, + 4, + glow::FLOAT, + false, + stride, + 4 * (2 + 2 + 4), + ); + gl.vertex_attrib_divisor(3, 1); + + gl.enable_vertex_attrib_array(4); + gl.vertex_attrib_pointer_f32( + 4, + 1, + glow::FLOAT, + false, + stride, + 4 * (2 + 2 + 4 + 4), + ); + gl.vertex_attrib_divisor(4, 1); + + gl.enable_vertex_attrib_array(5); + gl.vertex_attrib_pointer_f32( + 5, + 1, + glow::FLOAT, + false, + stride, + 4 * (2 + 2 + 4 + 4 + 1), + ); + gl.vertex_attrib_divisor(5, 1); + + gl.bind_vertex_array(None); + gl.bind_buffer(glow::ARRAY_BUFFER, None); + + (vertex_array, buffer) +} diff --git a/glow/src/shader/compatibility/quad.frag b/glow/src/shader/compatibility/quad.frag new file mode 100644 index 00000000..c2634c65 --- /dev/null +++ b/glow/src/shader/compatibility/quad.frag @@ -0,0 +1,62 @@ +#version 100 +precision mediump float; + +uniform float u_ScreenHeight; + +varying vec4 v_Color; +varying vec4 v_BorderColor; +varying vec2 v_Pos; +varying vec2 v_Scale; +varying float v_BorderRadius; +varying float v_BorderWidth; + +float _distance(in vec2 frag_coord, in vec2 position, in vec2 size, float radius) +{ + // TODO: Try SDF approach: https://www.shadertoy.com/view/wd3XRN + vec2 inner_size = size - vec2(radius, radius) * 2.0; + vec2 top_left = position + vec2(radius, radius); + vec2 bottom_right = top_left + inner_size; + + vec2 top_left_distance = top_left - frag_coord; + vec2 bottom_right_distance = frag_coord - bottom_right; + + vec2 distance = vec2( + max(max(top_left_distance.x, bottom_right_distance.x), 0.0), + max(max(top_left_distance.y, bottom_right_distance.y), 0.0) + ); + + return sqrt(distance.x * distance.x + distance.y * distance.y); +} + +void main() { + vec2 fragCoord = vec2(gl_FragCoord.x, u_ScreenHeight - gl_FragCoord.y); + + float internal_border = max(v_BorderRadius - v_BorderWidth, 0.0); + + float internal_distance = _distance( + fragCoord, + v_Pos + vec2(v_BorderWidth), + v_Scale - vec2(v_BorderWidth * 2.0), + internal_border + ); + + float border_mix = smoothstep( + max(internal_border - 0.5, 0.0), + internal_border + 0.5, + internal_distance + ); + + vec4 mixed_color = mix(v_Color, v_BorderColor, border_mix); + + float d = _distance( + fragCoord, + v_Pos, + v_Scale, + v_BorderRadius + ); + + float radius_alpha = + 1.0 - smoothstep(max(v_BorderRadius - 0.5, 0.0), v_BorderRadius + 0.5, d); + + gl_FragColor = vec4(mixed_color.xyz, mixed_color.w * radius_alpha); +} diff --git a/glow/src/shader/compatibility/quad.vert b/glow/src/shader/compatibility/quad.vert new file mode 100644 index 00000000..0d02e9d0 --- /dev/null +++ b/glow/src/shader/compatibility/quad.vert @@ -0,0 +1,46 @@ +#version 100 + +uniform mat4 u_Transform; +uniform float u_Scale; + +attribute vec2 i_Pos; +attribute vec2 i_Scale; +attribute vec4 i_Color; +attribute vec4 i_BorderColor; +attribute float i_BorderRadius; +attribute float i_BorderWidth; +attribute vec2 q_Pos; + +varying vec4 v_Color; +varying vec4 v_BorderColor; +varying vec2 v_Pos; +varying vec2 v_Scale; +varying float v_BorderRadius; +varying float v_BorderWidth; + + +void main() { + vec2 p_Pos = i_Pos * u_Scale; + vec2 p_Scale = i_Scale * u_Scale; + + float i_BorderRadius = min( + i_BorderRadius, + min(i_Scale.x, i_Scale.y) / 2.0 + ); + + mat4 i_Transform = mat4( + vec4(p_Scale.x + 1.0, 0.0, 0.0, 0.0), + vec4(0.0, p_Scale.y + 1.0, 0.0, 0.0), + vec4(0.0, 0.0, 1.0, 0.0), + vec4(p_Pos - vec2(0.5, 0.5), 0.0, 1.0) + ); + + v_Color = i_Color; + v_BorderColor = i_BorderColor; + v_Pos = p_Pos; + v_Scale = p_Scale; + v_BorderRadius = i_BorderRadius * u_Scale; + v_BorderWidth = i_BorderWidth * u_Scale; + + gl_Position = u_Transform * i_Transform * vec4(q_Pos, 0.0, 1.0); +} diff --git a/glow/src/shader/compatibility/triangle.frag b/glow/src/shader/compatibility/triangle.frag new file mode 100644 index 00000000..58fca553 --- /dev/null +++ b/glow/src/shader/compatibility/triangle.frag @@ -0,0 +1,8 @@ +#version 100 +precision mediump float; + +varying vec4 v_Color; + +void main() { + gl_FragColor = v_Color; +} diff --git a/glow/src/shader/compatibility/triangle.vert b/glow/src/shader/compatibility/triangle.vert new file mode 100644 index 00000000..975c9781 --- /dev/null +++ b/glow/src/shader/compatibility/triangle.vert @@ -0,0 +1,13 @@ +#version 100 + +uniform mat4 u_Transform; + +attribute vec2 i_Position; +attribute vec4 i_Color; + +varying vec4 v_Color; + +void main() { + v_Color = i_Color; + gl_Position = u_Transform * vec4(i_Position, 0.0, 1.0); +} diff --git a/glow/src/shader/core/quad.frag b/glow/src/shader/core/quad.frag new file mode 100644 index 00000000..18fd5baa --- /dev/null +++ b/glow/src/shader/core/quad.frag @@ -0,0 +1,70 @@ +#version 130 + +uniform float u_ScreenHeight; + +in vec4 v_Color; +in vec4 v_BorderColor; +in vec2 v_Pos; +in vec2 v_Scale; +in float v_BorderRadius; +in float v_BorderWidth; + +out vec4 o_Color; + +float distance(in vec2 frag_coord, in vec2 position, in vec2 size, float radius) +{ + // TODO: Try SDF approach: https://www.shadertoy.com/view/wd3XRN + vec2 inner_size = size - vec2(radius, radius) * 2.0; + vec2 top_left = position + vec2(radius, radius); + vec2 bottom_right = top_left + inner_size; + + vec2 top_left_distance = top_left - frag_coord; + vec2 bottom_right_distance = frag_coord - bottom_right; + + vec2 distance = vec2( + max(max(top_left_distance.x, bottom_right_distance.x), 0.0), + max(max(top_left_distance.y, bottom_right_distance.y), 0.0) + ); + + return sqrt(distance.x * distance.x + distance.y * distance.y); +} + +void main() { + vec4 mixed_color; + + vec2 fragCoord = vec2(gl_FragCoord.x, u_ScreenHeight - gl_FragCoord.y); + + // TODO: Remove branching (?) + if(v_BorderWidth > 0) { + float internal_border = max(v_BorderRadius - v_BorderWidth, 0.0); + + float internal_distance = distance( + fragCoord, + v_Pos + vec2(v_BorderWidth), + v_Scale - vec2(v_BorderWidth * 2.0), + internal_border + ); + + float border_mix = smoothstep( + max(internal_border - 0.5, 0.0), + internal_border + 0.5, + internal_distance + ); + + mixed_color = mix(v_Color, v_BorderColor, border_mix); + } else { + mixed_color = v_Color; + } + + float d = distance( + fragCoord, + v_Pos, + v_Scale, + v_BorderRadius + ); + + float radius_alpha = + 1.0 - smoothstep(max(v_BorderRadius - 0.5, 0.0), v_BorderRadius + 0.5, d); + + o_Color = vec4(mixed_color.xyz, mixed_color.w * radius_alpha); +} diff --git a/glow/src/shader/core/quad.vert b/glow/src/shader/core/quad.vert new file mode 100644 index 00000000..30f28d52 --- /dev/null +++ b/glow/src/shader/core/quad.vert @@ -0,0 +1,52 @@ +#version 130 + +uniform mat4 u_Transform; +uniform float u_Scale; + +in vec2 i_Pos; +in vec2 i_Scale; +in vec4 i_Color; +in vec4 i_BorderColor; +in float i_BorderRadius; +in float i_BorderWidth; + +out vec4 v_Color; +out vec4 v_BorderColor; +out vec2 v_Pos; +out vec2 v_Scale; +out float v_BorderRadius; +out float v_BorderWidth; + +const vec2 positions[4] = vec2[]( + vec2(0.0, 0.0), + vec2(0.0, 1.0), + vec2(1.0, 0.0), + vec2(1.0, 1.0) +); + +void main() { + vec2 q_Pos = positions[gl_VertexID]; + vec2 p_Pos = i_Pos * u_Scale; + vec2 p_Scale = i_Scale * u_Scale; + + float i_BorderRadius = min( + i_BorderRadius, + min(i_Scale.x, i_Scale.y) / 2.0 + ); + + mat4 i_Transform = mat4( + vec4(p_Scale.x + 1.0, 0.0, 0.0, 0.0), + vec4(0.0, p_Scale.y + 1.0, 0.0, 0.0), + vec4(0.0, 0.0, 1.0, 0.0), + vec4(p_Pos - vec2(0.5, 0.5), 0.0, 1.0) + ); + + v_Color = i_Color; + v_BorderColor = i_BorderColor; + v_Pos = p_Pos; + v_Scale = p_Scale; + v_BorderRadius = i_BorderRadius * u_Scale; + v_BorderWidth = i_BorderWidth * u_Scale; + + gl_Position = u_Transform * i_Transform * vec4(q_Pos, 0.0, 1.0); +} diff --git a/glow/src/shader/core/triangle.frag b/glow/src/shader/core/triangle.frag new file mode 100644 index 00000000..39c2ff6f --- /dev/null +++ b/glow/src/shader/core/triangle.frag @@ -0,0 +1,9 @@ +#version 130 + +in vec4 v_Color; + +out vec4 o_Color; + +void main() { + o_Color = v_Color; +} diff --git a/glow/src/shader/core/triangle.vert b/glow/src/shader/core/triangle.vert new file mode 100644 index 00000000..895652ea --- /dev/null +++ b/glow/src/shader/core/triangle.vert @@ -0,0 +1,13 @@ +#version 130 + +uniform mat4 u_Transform; + +in vec2 i_Position; +in vec4 i_Color; + +out vec4 v_Color; + +void main() { + gl_Position = u_Transform * vec4(i_Position, 0.0, 1.0); + v_Color = i_Color; +} diff --git a/glow/src/shader/quad.frag b/glow/src/shader/quad.frag deleted file mode 100644 index cea36bdc..00000000 --- a/glow/src/shader/quad.frag +++ /dev/null @@ -1,70 +0,0 @@ -#version 330 - -uniform float u_ScreenHeight; - -in vec4 v_Color; -in vec4 v_BorderColor; -in vec2 v_Pos; -in vec2 v_Scale; -in float v_BorderRadius; -in float v_BorderWidth; - -out vec4 o_Color; - -float distance(in vec2 frag_coord, in vec2 position, in vec2 size, float radius) -{ - // TODO: Try SDF approach: https://www.shadertoy.com/view/wd3XRN - vec2 inner_size = size - vec2(radius, radius) * 2.0; - vec2 top_left = position + vec2(radius, radius); - vec2 bottom_right = top_left + inner_size; - - vec2 top_left_distance = top_left - frag_coord; - vec2 bottom_right_distance = frag_coord - bottom_right; - - vec2 distance = vec2( - max(max(top_left_distance.x, bottom_right_distance.x), 0.0), - max(max(top_left_distance.y, bottom_right_distance.y), 0.0) - ); - - return sqrt(distance.x * distance.x + distance.y * distance.y); -} - -void main() { - vec4 mixed_color; - - vec2 fragCoord = vec2(gl_FragCoord.x, u_ScreenHeight - gl_FragCoord.y); - - // TODO: Remove branching (?) - if(v_BorderWidth > 0) { - float internal_border = max(v_BorderRadius - v_BorderWidth, 0.0); - - float internal_distance = distance( - fragCoord, - v_Pos + vec2(v_BorderWidth), - v_Scale - vec2(v_BorderWidth * 2.0), - internal_border - ); - - float border_mix = smoothstep( - max(internal_border - 0.5, 0.0), - internal_border + 0.5, - internal_distance - ); - - mixed_color = mix(v_Color, v_BorderColor, border_mix); - } else { - mixed_color = v_Color; - } - - float d = distance( - fragCoord, - v_Pos, - v_Scale, - v_BorderRadius - ); - - float radius_alpha = - 1.0 - smoothstep(max(v_BorderRadius - 0.5, 0.0), v_BorderRadius + 0.5, d); - - o_Color = vec4(mixed_color.xyz, mixed_color.w * radius_alpha); -} diff --git a/glow/src/shader/quad.vert b/glow/src/shader/quad.vert deleted file mode 100644 index 82417856..00000000 --- a/glow/src/shader/quad.vert +++ /dev/null @@ -1,52 +0,0 @@ -#version 330 - -uniform mat4 u_Transform; -uniform float u_Scale; - -layout(location = 0) in vec2 i_Pos; -layout(location = 1) in vec2 i_Scale; -layout(location = 2) in vec4 i_Color; -layout(location = 3) in vec4 i_BorderColor; -layout(location = 4) in float i_BorderRadius; -layout(location = 5) in float i_BorderWidth; - -out vec4 v_Color; -out vec4 v_BorderColor; -out vec2 v_Pos; -out vec2 v_Scale; -out float v_BorderRadius; -out float v_BorderWidth; - -const vec2 positions[4] = vec2[]( - vec2(0.0, 0.0), - vec2(0.0, 1.0), - vec2(1.0, 0.0), - vec2(1.0, 1.0) -); - -void main() { - vec2 q_Pos = positions[gl_VertexID]; - vec2 p_Pos = i_Pos * u_Scale; - vec2 p_Scale = i_Scale * u_Scale; - - float i_BorderRadius = min( - i_BorderRadius, - min(i_Scale.x, i_Scale.y) / 2.0 - ); - - mat4 i_Transform = mat4( - vec4(p_Scale.x + 1.0, 0.0, 0.0, 0.0), - vec4(0.0, p_Scale.y + 1.0, 0.0, 0.0), - vec4(0.0, 0.0, 1.0, 0.0), - vec4(p_Pos - vec2(0.5, 0.5), 0.0, 1.0) - ); - - v_Color = i_Color; - v_BorderColor = i_BorderColor; - v_Pos = p_Pos; - v_Scale = p_Scale; - v_BorderRadius = i_BorderRadius * u_Scale; - v_BorderWidth = i_BorderWidth * u_Scale; - - gl_Position = u_Transform * i_Transform * vec4(q_Pos, 0.0, 1.0); -} diff --git a/glow/src/shader/triangle.frag b/glow/src/shader/triangle.frag deleted file mode 100644 index d186784a..00000000 --- a/glow/src/shader/triangle.frag +++ /dev/null @@ -1,9 +0,0 @@ -#version 330 - -in vec4 v_Color; - -out vec4 o_Color; - -void main() { - o_Color = v_Color; -} diff --git a/glow/src/shader/triangle.vert b/glow/src/shader/triangle.vert deleted file mode 100644 index 5723436a..00000000 --- a/glow/src/shader/triangle.vert +++ /dev/null @@ -1,13 +0,0 @@ -#version 330 - -uniform mat4 u_Transform; - -layout(location = 0) in vec2 i_Position; -layout(location = 1) in vec4 i_Color; - -out vec4 v_Color; - -void main() { - gl_Position = u_Transform * vec4(i_Position, 0.0, 1.0); - v_Color = i_Color; -} diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index 9202bcb2..d0a05be6 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -26,10 +26,13 @@ impl Pipeline { program::create( gl, &[ - (glow::VERTEX_SHADER, include_str!("shader/triangle.vert")), + ( + glow::VERTEX_SHADER, + include_str!("shader/compatibility/triangle.vert"), + ), ( glow::FRAGMENT_SHADER, - include_str!("shader/triangle.frag"), + include_str!("shader/compatibility/triangle.frag"), ), ], ) -- cgit From 94bb03c33c161015c200cd77bc6b2d73531d0917 Mon Sep 17 00:00:00 2001 From: Richard Date: Wed, 10 Nov 2021 11:18:57 -0300 Subject: Log debugging info --- glow/src/quad.rs | 2 ++ glow/src/window/compositor.rs | 7 +++++++ 2 files changed, 9 insertions(+) (limited to 'glow') diff --git a/glow/src/quad.rs b/glow/src/quad.rs index 5438024c..75740c7e 100644 --- a/glow/src/quad.rs +++ b/glow/src/quad.rs @@ -16,8 +16,10 @@ impl Pipeline { pub fn new(gl: &glow::Context) -> Pipeline { let version = gl.version(); if version.is_embedded || version.major == 2 { + log::info!("Mode: compatibility"); Pipeline::Compatibility(compatibility::Pipeline::new(gl)) } else { + log::info!("Mode: core"); Pipeline::Core(core::Pipeline::new(gl)) } } diff --git a/glow/src/window/compositor.rs b/glow/src/window/compositor.rs index a85a4560..8d7d21d3 100644 --- a/glow/src/window/compositor.rs +++ b/glow/src/window/compositor.rs @@ -20,6 +20,13 @@ impl iced_graphics::window::GLCompositor for Compositor { ) -> Result<(Self, Self::Renderer), Error> { let gl = glow::Context::from_loader_function(loader_function); + let version = gl.version(); + log::info!("Version: {:?}", version); + log::info!("Embedded: {}", version.is_embedded); + + let renderer = gl.get_parameter_string(glow::RENDERER); + log::info!("Renderer: {}", renderer); + // Enable auto-conversion from/to sRGB gl.enable(glow::FRAMEBUFFER_SRGB); -- cgit From e31566d430093fb084da2e7f4f4ed1b66326edef Mon Sep 17 00:00:00 2001 From: Richard Date: Thu, 11 Nov 2021 01:10:47 -0300 Subject: Improve shader version selection --- glow/src/backend.rs | 57 ++++++++++++++++++++++++++++- glow/src/program.rs | 5 +++ glow/src/quad.rs | 20 +++++++--- glow/src/quad/compatibility.rs | 25 +++++++++++-- glow/src/quad/core.rs | 25 +++++++++++-- glow/src/shader/common/triangle.frag | 18 +++++++++ glow/src/shader/common/triangle.vert | 11 ++++++ glow/src/shader/compatibility/quad.frag | 9 ++++- glow/src/shader/compatibility/quad.vert | 2 - glow/src/shader/compatibility/triangle.frag | 8 ---- glow/src/shader/compatibility/triangle.vert | 13 ------- glow/src/shader/core/quad.frag | 25 +++++++++---- glow/src/shader/core/quad.vert | 4 +- glow/src/shader/core/triangle.frag | 9 ----- glow/src/shader/core/triangle.vert | 13 ------- glow/src/triangle.rs | 18 +++++++-- glow/src/window/compositor.rs | 2 +- 17 files changed, 188 insertions(+), 76 deletions(-) create mode 100644 glow/src/shader/common/triangle.frag create mode 100644 glow/src/shader/common/triangle.vert delete mode 100644 glow/src/shader/compatibility/triangle.frag delete mode 100644 glow/src/shader/compatibility/triangle.vert delete mode 100644 glow/src/shader/core/triangle.frag delete mode 100644 glow/src/shader/core/triangle.vert (limited to 'glow') diff --git a/glow/src/backend.rs b/glow/src/backend.rs index 5ab7f922..69d04168 100644 --- a/glow/src/backend.rs +++ b/glow/src/backend.rs @@ -3,6 +3,7 @@ use crate::text; use crate::triangle; use crate::{Settings, Transformation, Viewport}; +use glow::HasContext; use iced_graphics::backend; use iced_graphics::font; use iced_graphics::{Layer, Primitive}; @@ -30,8 +31,60 @@ impl Backend { settings.text_multithreading, ); - let quad_pipeline = quad::Pipeline::new(gl); - let triangle_pipeline = triangle::Pipeline::new(gl); + let version = gl.version(); + let shader_version = match ( + version.major, + version.minor, + version.is_embedded, + ) { + // OpenGL 3.0+ + (3, 0 | 1 | 2, false) => ( + format!("#version 1{}0", version.minor + 3), + format!( + "#version 1{}0\n#define HIGHER_THAN_300 1", + version.minor + 3 + ), + ), + // OpenGL 3.3+ + (3 | 4, _, false) => ( + format!("#version {}{}0", version.major, version.minor), + format!( + "#version {}{}0\n#define HIGHER_THAN_300 1", + version.major, version.minor + ), + ), + // OpenGL ES 3.0+ + (3, _, true) => ( + format!("#version 3{}0 es", version.minor), + format!( + "#version 3{}0 es\n#define HIGHER_THAN_300 1", + version.minor + ), + ), + // OpenGL ES 2.0+ + (2, _, true) => ( + String::from( + "#version 100\n#define in attribute\n#define out varying", + ), + String::from("#version 100\n#define in varying"), + ), + // OpenGL 2.1 + (2, _, false) => ( + String::from( + "#version 120\n#define in attribute\n#define out varying", + ), + String::from("#version 120\n#define in varying"), + ), + // OpenGL 1.1+ + _ => panic!("Incompatible context version: {:?}", version), + }; + log::info!( + "Shader directive: {}", + shader_version.0.lines().next().unwrap() + ); + + let quad_pipeline = quad::Pipeline::new(gl, &shader_version); + let triangle_pipeline = triangle::Pipeline::new(gl, &shader_version); Self { quad_pipeline, diff --git a/glow/src/program.rs b/glow/src/program.rs index 601f9ce6..13676c70 100644 --- a/glow/src/program.rs +++ b/glow/src/program.rs @@ -3,6 +3,7 @@ use glow::HasContext; pub unsafe fn create( gl: &glow::Context, shader_sources: &[(u32, &str)], + attributes: &[(u32, &str)], ) -> ::Program { let program = gl.create_program().expect("Cannot create program"); @@ -25,6 +26,10 @@ pub unsafe fn create( shaders.push(shader); } + for (i, name) in attributes { + gl.bind_attrib_location(program, *i, name); + } + gl.link_program(program); if !gl.get_program_link_status(program) { panic!("{}", gl.get_program_info_log(program)); diff --git a/glow/src/quad.rs b/glow/src/quad.rs index 75740c7e..e965f3c9 100644 --- a/glow/src/quad.rs +++ b/glow/src/quad.rs @@ -13,14 +13,22 @@ pub enum Pipeline { } impl Pipeline { - pub fn new(gl: &glow::Context) -> Pipeline { + pub fn new( + gl: &glow::Context, + shader_version: &(String, String), + ) -> Pipeline { let version = gl.version(); - if version.is_embedded || version.major == 2 { - log::info!("Mode: compatibility"); - Pipeline::Compatibility(compatibility::Pipeline::new(gl)) - } else { + + // OpenGL 3.0+ and OpenGL ES 3.0+ have instancing (which is what separates `core` from `compatibility`) + if version.major >= 3 { log::info!("Mode: core"); - Pipeline::Core(core::Pipeline::new(gl)) + Pipeline::Core(core::Pipeline::new(gl, shader_version)) + } else { + log::info!("Mode: compatibility"); + Pipeline::Compatibility(compatibility::Pipeline::new( + gl, + shader_version, + )) } } diff --git a/glow/src/quad/compatibility.rs b/glow/src/quad/compatibility.rs index e083dcf1..28ad214d 100644 --- a/glow/src/quad/compatibility.rs +++ b/glow/src/quad/compatibility.rs @@ -25,20 +25,39 @@ pub struct Pipeline { } impl Pipeline { - pub fn new(gl: &glow::Context) -> Pipeline { + pub fn new( + gl: &glow::Context, + (vertex_version, fragment_version): &(String, String), + ) -> Pipeline { let program = unsafe { program::create( gl, &[ ( glow::VERTEX_SHADER, - include_str!("../shader/compatibility/quad.vert"), + &format!( + "{}\n{}", + vertex_version, + include_str!("../shader/compatibility/quad.vert") + ), ), ( glow::FRAGMENT_SHADER, - include_str!("../shader/compatibility/quad.frag"), + &format!( + "{}\n{}", + fragment_version, + include_str!("../shader/compatibility/quad.frag") + ), ), ], + &[ + (0, "i_Pos"), + (1, "i_Scale"), + (2, "i_Color"), + (3, "i_BorderColor"), + (4, "i_BorderRadius"), + (5, "i_BorderWidth"), + ], ) }; diff --git a/glow/src/quad/core.rs b/glow/src/quad/core.rs index c843e8c7..274ade67 100644 --- a/glow/src/quad/core.rs +++ b/glow/src/quad/core.rs @@ -20,20 +20,39 @@ pub struct Pipeline { } impl Pipeline { - pub fn new(gl: &glow::Context) -> Pipeline { + pub fn new( + gl: &glow::Context, + (vertex_version, fragment_version): &(String, String), + ) -> Pipeline { let program = unsafe { program::create( gl, &[ ( glow::VERTEX_SHADER, - include_str!("../shader/core/quad.vert"), + &format!( + "{}\n{}", + vertex_version, + include_str!("../shader/core/quad.vert") + ), ), ( glow::FRAGMENT_SHADER, - include_str!("../shader/core/quad.frag"), + &format!( + "{}\n{}", + fragment_version, + include_str!("../shader/core/quad.frag") + ), ), ], + &[ + (0, "i_Pos"), + (1, "i_Scale"), + (2, "i_Color"), + (3, "i_BorderColor"), + (4, "i_BorderRadius"), + (5, "i_BorderWidth"), + ], ) }; diff --git a/glow/src/shader/common/triangle.frag b/glow/src/shader/common/triangle.frag new file mode 100644 index 00000000..e8689f2e --- /dev/null +++ b/glow/src/shader/common/triangle.frag @@ -0,0 +1,18 @@ +#ifdef GL_ES +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +#else +precision mediump float; +#endif +#endif + +#ifdef HIGHER_THAN_300 +out vec4 fragColor; +#define gl_FragColor fragColor +#endif + +in vec4 v_Color; + +void main() { + gl_FragColor = v_Color; +} \ No newline at end of file diff --git a/glow/src/shader/common/triangle.vert b/glow/src/shader/common/triangle.vert new file mode 100644 index 00000000..d0494a5f --- /dev/null +++ b/glow/src/shader/common/triangle.vert @@ -0,0 +1,11 @@ +uniform mat4 u_Transform; + +in vec2 i_Position; +in vec4 i_Color; + +out vec4 v_Color; + +void main() { + gl_Position = u_Transform * vec4(i_Position, 0.0, 1.0); + v_Color = i_Color; +} \ No newline at end of file diff --git a/glow/src/shader/compatibility/quad.frag b/glow/src/shader/compatibility/quad.frag index c2634c65..8ea5693d 100644 --- a/glow/src/shader/compatibility/quad.frag +++ b/glow/src/shader/compatibility/quad.frag @@ -1,5 +1,10 @@ -#version 100 +#ifdef GL_ES +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +#else precision mediump float; +#endif +#endif uniform float u_ScreenHeight; @@ -10,7 +15,7 @@ varying vec2 v_Scale; varying float v_BorderRadius; varying float v_BorderWidth; -float _distance(in vec2 frag_coord, in vec2 position, in vec2 size, float radius) +float _distance(vec2 frag_coord, vec2 position, vec2 size, float radius) { // TODO: Try SDF approach: https://www.shadertoy.com/view/wd3XRN vec2 inner_size = size - vec2(radius, radius) * 2.0; diff --git a/glow/src/shader/compatibility/quad.vert b/glow/src/shader/compatibility/quad.vert index 0d02e9d0..abe70c0e 100644 --- a/glow/src/shader/compatibility/quad.vert +++ b/glow/src/shader/compatibility/quad.vert @@ -1,5 +1,3 @@ -#version 100 - uniform mat4 u_Transform; uniform float u_Scale; diff --git a/glow/src/shader/compatibility/triangle.frag b/glow/src/shader/compatibility/triangle.frag deleted file mode 100644 index 58fca553..00000000 --- a/glow/src/shader/compatibility/triangle.frag +++ /dev/null @@ -1,8 +0,0 @@ -#version 100 -precision mediump float; - -varying vec4 v_Color; - -void main() { - gl_FragColor = v_Color; -} diff --git a/glow/src/shader/compatibility/triangle.vert b/glow/src/shader/compatibility/triangle.vert deleted file mode 100644 index 975c9781..00000000 --- a/glow/src/shader/compatibility/triangle.vert +++ /dev/null @@ -1,13 +0,0 @@ -#version 100 - -uniform mat4 u_Transform; - -attribute vec2 i_Position; -attribute vec4 i_Color; - -varying vec4 v_Color; - -void main() { - v_Color = i_Color; - gl_Position = u_Transform * vec4(i_Position, 0.0, 1.0); -} diff --git a/glow/src/shader/core/quad.frag b/glow/src/shader/core/quad.frag index 18fd5baa..57e2e8e7 100644 --- a/glow/src/shader/core/quad.frag +++ b/glow/src/shader/core/quad.frag @@ -1,4 +1,15 @@ -#version 130 +#ifdef GL_ES +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +#else +precision mediump float; +#endif +#endif + +#ifdef HIGHER_THAN_300 +out vec4 fragColor; +#define gl_FragColor fragColor +#endif uniform float u_ScreenHeight; @@ -9,9 +20,7 @@ in vec2 v_Scale; in float v_BorderRadius; in float v_BorderWidth; -out vec4 o_Color; - -float distance(in vec2 frag_coord, in vec2 position, in vec2 size, float radius) +float fDistance(vec2 frag_coord, vec2 position, vec2 size, float radius) { // TODO: Try SDF approach: https://www.shadertoy.com/view/wd3XRN vec2 inner_size = size - vec2(radius, radius) * 2.0; @@ -35,10 +44,10 @@ void main() { vec2 fragCoord = vec2(gl_FragCoord.x, u_ScreenHeight - gl_FragCoord.y); // TODO: Remove branching (?) - if(v_BorderWidth > 0) { + if(v_BorderWidth > 0.0) { float internal_border = max(v_BorderRadius - v_BorderWidth, 0.0); - float internal_distance = distance( + float internal_distance = fDistance( fragCoord, v_Pos + vec2(v_BorderWidth), v_Scale - vec2(v_BorderWidth * 2.0), @@ -56,7 +65,7 @@ void main() { mixed_color = v_Color; } - float d = distance( + float d = fDistance( fragCoord, v_Pos, v_Scale, @@ -66,5 +75,5 @@ void main() { float radius_alpha = 1.0 - smoothstep(max(v_BorderRadius - 0.5, 0.0), v_BorderRadius + 0.5, d); - o_Color = vec4(mixed_color.xyz, mixed_color.w * radius_alpha); + gl_FragColor = vec4(mixed_color.xyz, mixed_color.w * radius_alpha); } diff --git a/glow/src/shader/core/quad.vert b/glow/src/shader/core/quad.vert index 30f28d52..b1fb2365 100644 --- a/glow/src/shader/core/quad.vert +++ b/glow/src/shader/core/quad.vert @@ -1,5 +1,3 @@ -#version 130 - uniform mat4 u_Transform; uniform float u_Scale; @@ -17,7 +15,7 @@ out vec2 v_Scale; out float v_BorderRadius; out float v_BorderWidth; -const vec2 positions[4] = vec2[]( +vec2 positions[4] = vec2[]( vec2(0.0, 0.0), vec2(0.0, 1.0), vec2(1.0, 0.0), diff --git a/glow/src/shader/core/triangle.frag b/glow/src/shader/core/triangle.frag deleted file mode 100644 index 39c2ff6f..00000000 --- a/glow/src/shader/core/triangle.frag +++ /dev/null @@ -1,9 +0,0 @@ -#version 130 - -in vec4 v_Color; - -out vec4 o_Color; - -void main() { - o_Color = v_Color; -} diff --git a/glow/src/shader/core/triangle.vert b/glow/src/shader/core/triangle.vert deleted file mode 100644 index 895652ea..00000000 --- a/glow/src/shader/core/triangle.vert +++ /dev/null @@ -1,13 +0,0 @@ -#version 130 - -uniform mat4 u_Transform; - -in vec2 i_Position; -in vec4 i_Color; - -out vec4 v_Color; - -void main() { - gl_Position = u_Transform * vec4(i_Position, 0.0, 1.0); - v_Color = i_Color; -} diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index d0a05be6..91bb96ba 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -21,20 +21,32 @@ pub(crate) struct Pipeline { } impl Pipeline { - pub fn new(gl: &glow::Context) -> Pipeline { + pub fn new( + gl: &glow::Context, + (vertex_version, fragment_version): &(String, String), + ) -> Pipeline { let program = unsafe { program::create( gl, &[ ( glow::VERTEX_SHADER, - include_str!("shader/compatibility/triangle.vert"), + &format!( + "{}\n{}", + vertex_version, + include_str!("shader/common/triangle.vert") + ), ), ( glow::FRAGMENT_SHADER, - include_str!("shader/compatibility/triangle.frag"), + &format!( + "{}\n{}", + fragment_version, + include_str!("shader/common/triangle.frag") + ), ), ], + &[(0, "i_Position"), (1, "i_Color")], ) }; diff --git a/glow/src/window/compositor.rs b/glow/src/window/compositor.rs index 8d7d21d3..44019fb2 100644 --- a/glow/src/window/compositor.rs +++ b/glow/src/window/compositor.rs @@ -23,7 +23,7 @@ impl iced_graphics::window::GLCompositor for Compositor { let version = gl.version(); log::info!("Version: {:?}", version); log::info!("Embedded: {}", version.is_embedded); - + let renderer = gl.get_parameter_string(glow::RENDERER); log::info!("Renderer: {}", renderer); -- cgit From 01f67a2c1f36a90e45f0ff21266bc41152f0c8d5 Mon Sep 17 00:00:00 2001 From: Richard Date: Mon, 1 Nov 2021 18:37:53 -0300 Subject: Export `glow` in `iced_glow` --- glow/src/lib.rs | 2 ++ 1 file changed, 2 insertions(+) (limited to 'glow') diff --git a/glow/src/lib.rs b/glow/src/lib.rs index 362933d4..4e5a75d7 100644 --- a/glow/src/lib.rs +++ b/glow/src/lib.rs @@ -13,6 +13,8 @@ #![forbid(rust_2018_idioms)] #![cfg_attr(docsrs, feature(doc_cfg))] +pub use glow; + mod backend; mod program; mod quad; -- cgit From 46fb27b104fda99640cca625934ababeca8fd19a Mon Sep 17 00:00:00 2001 From: Richard Date: Wed, 10 Nov 2021 19:20:16 -0300 Subject: Update documentation for built-in renderers --- glow/README.md | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 glow/README.md (limited to 'glow') diff --git a/glow/README.md b/glow/README.md new file mode 100644 index 00000000..c6b7245e --- /dev/null +++ b/glow/README.md @@ -0,0 +1,51 @@ +# `iced_glow` +[![Documentation](https://docs.rs/iced_glow/badge.svg)][documentation] +[![Crates.io](https://img.shields.io/crates/v/iced_glow.svg)](https://crates.io/crates/iced_glow) +[![License](https://img.shields.io/crates/l/iced_glow.svg)](https://github.com/hecrj/iced/blob/master/LICENSE) +[![project chat](https://img.shields.io/badge/chat-on_zulip-brightgreen.svg)](https://iced.zulipchat.com) + +`iced_glow` is a [`glow`] renderer for [`iced_native`]. This renderer supports OpenGL 3.0+ and OpenGL ES 2.0. + +This is renderer is mostly used as a fallback for hardware that doesn't support [`wgpu`] (Vulkan, Metal or DX12). + +Currently, `iced_glow` supports the following primitives: +- Text, which is rendered using [`glow_glyph`]. No shaping at all. +- Quads or rectangles, with rounded borders and a solid background color. +- Clip areas, useful to implement scrollables or hide overflowing content. +- Meshes of triangles, useful to draw geometry freely. + +

+ The native target +

+ +[documentation]: https://docs.rs/iced_glow +[`iced_native`]: ../native +[`glow`]: https://github.com/grovesNL/glow +[`wgpu`]: https://github.com/gfx-rs/wgpu +[`glow_glyph`]: https://github.com/hecrj/glow_glyph + +## Installation +Add `iced_glow` as a dependency in your `Cargo.toml`: + +```toml +iced_glow = "0.2" +``` + +__Iced moves fast and the `master` branch can contain breaking changes!__ If +you want to learn about a specific release, check out [the release list]. + +[the release list]: https://github.com/hecrj/iced/releases + +## Current limitations + +The current implementation is quite naive, it uses: + +- A different pipeline/shader for each primitive +- A very simplistic layer model: every `Clip` primitive will generate new layers +- _Many_ render passes instead of preparing everything upfront +- A glyph cache that is trimmed incorrectly when there are multiple layers (a [`glyph_brush`] limitation) + +Some of these issues are already being worked on! If you want to help, [get in touch!] + +[get in touch!]: ../CONTRIBUTING.md +[`glyph_brush`]: https://github.com/alexheretic/glyph-brush -- cgit From 424e1d3fda3c9e1764b567a3b05d33a9ed589fda Mon Sep 17 00:00:00 2001 From: Richard Date: Wed, 19 Jan 2022 22:04:53 -0300 Subject: Add `Shader` and `Version` to simplify and constrain `program::create` --- glow/src/backend.rs | 54 +----------------- glow/src/program.rs | 127 +++++++++++++++++++++++++++++++++++------ glow/src/quad.rs | 7 ++- glow/src/quad/compatibility.rs | 34 +++++------ glow/src/quad/core.rs | 34 +++++------ glow/src/triangle.rs | 34 +++++------ 6 files changed, 156 insertions(+), 134 deletions(-) (limited to 'glow') diff --git a/glow/src/backend.rs b/glow/src/backend.rs index 69d04168..89dc1aaa 100644 --- a/glow/src/backend.rs +++ b/glow/src/backend.rs @@ -1,9 +1,9 @@ +use crate::program; use crate::quad; use crate::text; use crate::triangle; use crate::{Settings, Transformation, Viewport}; -use glow::HasContext; use iced_graphics::backend; use iced_graphics::font; use iced_graphics::{Layer, Primitive}; @@ -31,57 +31,7 @@ impl Backend { settings.text_multithreading, ); - let version = gl.version(); - let shader_version = match ( - version.major, - version.minor, - version.is_embedded, - ) { - // OpenGL 3.0+ - (3, 0 | 1 | 2, false) => ( - format!("#version 1{}0", version.minor + 3), - format!( - "#version 1{}0\n#define HIGHER_THAN_300 1", - version.minor + 3 - ), - ), - // OpenGL 3.3+ - (3 | 4, _, false) => ( - format!("#version {}{}0", version.major, version.minor), - format!( - "#version {}{}0\n#define HIGHER_THAN_300 1", - version.major, version.minor - ), - ), - // OpenGL ES 3.0+ - (3, _, true) => ( - format!("#version 3{}0 es", version.minor), - format!( - "#version 3{}0 es\n#define HIGHER_THAN_300 1", - version.minor - ), - ), - // OpenGL ES 2.0+ - (2, _, true) => ( - String::from( - "#version 100\n#define in attribute\n#define out varying", - ), - String::from("#version 100\n#define in varying"), - ), - // OpenGL 2.1 - (2, _, false) => ( - String::from( - "#version 120\n#define in attribute\n#define out varying", - ), - String::from("#version 120\n#define in varying"), - ), - // OpenGL 1.1+ - _ => panic!("Incompatible context version: {:?}", version), - }; - log::info!( - "Shader directive: {}", - shader_version.0.lines().next().unwrap() - ); + let shader_version = program::Version::new(gl); let quad_pipeline = quad::Pipeline::new(gl, &shader_version); let triangle_pipeline = triangle::Pipeline::new(gl, &shader_version); diff --git a/glow/src/program.rs b/glow/src/program.rs index 13676c70..9a02d578 100644 --- a/glow/src/program.rs +++ b/glow/src/program.rs @@ -1,29 +1,118 @@ use glow::HasContext; -pub unsafe fn create( - gl: &glow::Context, - shader_sources: &[(u32, &str)], - attributes: &[(u32, &str)], -) -> ::Program { - let program = gl.create_program().expect("Cannot create program"); +/// The [`Version`] of a `Program`. +pub struct Version { + vertex: String, + fragment: String, +} + +impl Version { + pub fn new(gl: &glow::Context) -> Version { + let version = gl.version(); - let mut shaders = Vec::with_capacity(shader_sources.len()); + let (vertex, fragment) = match ( + version.major, + version.minor, + version.is_embedded, + ) { + // OpenGL 3.0+ + (3, 0 | 1 | 2, false) => ( + format!("#version 1{}0", version.minor + 3), + format!( + "#version 1{}0\n#define HIGHER_THAN_300 1", + version.minor + 3 + ), + ), + // OpenGL 3.3+ + (3 | 4, _, false) => ( + format!("#version {}{}0", version.major, version.minor), + format!( + "#version {}{}0\n#define HIGHER_THAN_300 1", + version.major, version.minor + ), + ), + // OpenGL ES 3.0+ + (3, _, true) => ( + format!("#version 3{}0 es", version.minor), + format!( + "#version 3{}0 es\n#define HIGHER_THAN_300 1", + version.minor + ), + ), + // OpenGL ES 2.0+ + (2, _, true) => ( + String::from( + "#version 100\n#define in attribute\n#define out varying", + ), + String::from("#version 100\n#define in varying"), + ), + // OpenGL 2.1 + (2, _, false) => ( + String::from( + "#version 120\n#define in attribute\n#define out varying", + ), + String::from("#version 120\n#define in varying"), + ), + // OpenGL 1.1+ + _ => panic!("Incompatible context version: {:?}", version), + }; - for (shader_type, shader_source) in shader_sources.iter() { - let shader = gl - .create_shader(*shader_type) - .expect("Cannot create shader"); + log::info!("Shader directive: {}", vertex.lines().next().unwrap()); - gl.shader_source(shader, shader_source); - gl.compile_shader(shader); + Version { vertex, fragment } + } +} + +pub struct Shader(::Shader); + +impl Shader { + fn compile(gl: &glow::Context, stage: u32, content: &str) -> Shader { + unsafe { + let shader = gl.create_shader(stage).expect("Cannot create shader"); - if !gl.get_shader_compile_status(shader) { - panic!("{}", gl.get_shader_info_log(shader)); + gl.shader_source(shader, &content); + gl.compile_shader(shader); + + if !gl.get_shader_compile_status(shader) { + panic!("{}", gl.get_shader_info_log(shader)); + } + + Shader(shader) } + } - gl.attach_shader(program, shader); + /// Creates a vertex [`Shader`]. + pub fn vertex( + gl: &glow::Context, + version: &Version, + content: &'static str, + ) -> Self { + let content = format!("{}\n{}", version.vertex, content); - shaders.push(shader); + Shader::compile(gl, glow::VERTEX_SHADER, &content) + } + + /// Creates a fragment [`Shader`]. + pub fn fragment( + gl: &glow::Context, + version: &Version, + content: &'static str, + ) -> Self { + let content = format!("{}\n{}", version.fragment, content); + + Shader::compile(gl, glow::FRAGMENT_SHADER, &content) + } +} + +pub unsafe fn create( + gl: &glow::Context, + shaders: &[Shader], + attributes: &[(u32, &str)], +) -> ::Program { + let program = gl.create_program().expect("Cannot create program"); + + for shader in shaders { + gl.attach_shader(program, shader.0); } for (i, name) in attributes { @@ -36,8 +125,8 @@ pub unsafe fn create( } for shader in shaders { - gl.detach_shader(program, shader); - gl.delete_shader(shader); + gl.detach_shader(program, shader.0); + gl.delete_shader(shader.0); } program diff --git a/glow/src/quad.rs b/glow/src/quad.rs index e965f3c9..d9f1c6ae 100644 --- a/glow/src/quad.rs +++ b/glow/src/quad.rs @@ -1,6 +1,7 @@ mod compatibility; mod core; +use crate::program; use crate::Transformation; use glow::HasContext; use iced_graphics::layer; @@ -15,12 +16,12 @@ pub enum Pipeline { impl Pipeline { pub fn new( gl: &glow::Context, - shader_version: &(String, String), + shader_version: &program::Version, ) -> Pipeline { - let version = gl.version(); + let gl_version = gl.version(); // OpenGL 3.0+ and OpenGL ES 3.0+ have instancing (which is what separates `core` from `compatibility`) - if version.major >= 3 { + if gl_version.major >= 3 { log::info!("Mode: core"); Pipeline::Core(core::Pipeline::new(gl, shader_version)) } else { diff --git a/glow/src/quad/compatibility.rs b/glow/src/quad/compatibility.rs index 28ad214d..76f98ab7 100644 --- a/glow/src/quad/compatibility.rs +++ b/glow/src/quad/compatibility.rs @@ -1,4 +1,4 @@ -use crate::program; +use crate::program::{self, Shader}; use crate::Transformation; use glow::HasContext; use iced_graphics::layer; @@ -27,29 +27,23 @@ pub struct Pipeline { impl Pipeline { pub fn new( gl: &glow::Context, - (vertex_version, fragment_version): &(String, String), + shader_version: &program::Version, ) -> Pipeline { let program = unsafe { + let vertex_shader = Shader::vertex( + gl, + shader_version, + include_str!("../shader/compatibility/quad.vert"), + ); + let fragment_shader = Shader::fragment( + gl, + shader_version, + include_str!("../shader/compatibility/quad.frag"), + ); + program::create( gl, - &[ - ( - glow::VERTEX_SHADER, - &format!( - "{}\n{}", - vertex_version, - include_str!("../shader/compatibility/quad.vert") - ), - ), - ( - glow::FRAGMENT_SHADER, - &format!( - "{}\n{}", - fragment_version, - include_str!("../shader/compatibility/quad.frag") - ), - ), - ], + &[vertex_shader, fragment_shader], &[ (0, "i_Pos"), (1, "i_Scale"), diff --git a/glow/src/quad/core.rs b/glow/src/quad/core.rs index 274ade67..f37300f6 100644 --- a/glow/src/quad/core.rs +++ b/glow/src/quad/core.rs @@ -1,4 +1,4 @@ -use crate::program; +use crate::program::{self, Shader}; use crate::Transformation; use glow::HasContext; use iced_graphics::layer; @@ -22,29 +22,23 @@ pub struct Pipeline { impl Pipeline { pub fn new( gl: &glow::Context, - (vertex_version, fragment_version): &(String, String), + shader_version: &program::Version, ) -> Pipeline { let program = unsafe { + let vertex_shader = Shader::vertex( + gl, + shader_version, + include_str!("../shader/core/quad.vert"), + ); + let fragment_shader = Shader::fragment( + gl, + shader_version, + include_str!("../shader/core/quad.frag"), + ); + program::create( gl, - &[ - ( - glow::VERTEX_SHADER, - &format!( - "{}\n{}", - vertex_version, - include_str!("../shader/core/quad.vert") - ), - ), - ( - glow::FRAGMENT_SHADER, - &format!( - "{}\n{}", - fragment_version, - include_str!("../shader/core/quad.frag") - ), - ), - ], + &[vertex_shader, fragment_shader], &[ (0, "i_Pos"), (1, "i_Scale"), diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index 91bb96ba..ae4f83ef 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -1,5 +1,5 @@ //! Draw meshes of triangles. -use crate::program; +use crate::program::{self, Shader}; use crate::Transformation; use glow::HasContext; use iced_graphics::layer; @@ -23,29 +23,23 @@ pub(crate) struct Pipeline { impl Pipeline { pub fn new( gl: &glow::Context, - (vertex_version, fragment_version): &(String, String), + 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, - &[ - ( - glow::VERTEX_SHADER, - &format!( - "{}\n{}", - vertex_version, - include_str!("shader/common/triangle.vert") - ), - ), - ( - glow::FRAGMENT_SHADER, - &format!( - "{}\n{}", - fragment_version, - include_str!("shader/common/triangle.frag") - ), - ), - ], + &[vertex_shader, fragment_shader], &[(0, "i_Position"), (1, "i_Color")], ) }; -- cgit