summaryrefslogtreecommitdiffstats
path: root/glow/src
diff options
context:
space:
mode:
Diffstat (limited to 'glow/src')
-rw-r--r--glow/src/backend.rs41
-rw-r--r--glow/src/image.rs248
-rw-r--r--glow/src/image/storage.rs78
-rw-r--r--glow/src/lib.rs4
-rw-r--r--glow/src/quad/compatibility.rs14
-rw-r--r--glow/src/quad/core.rs10
-rw-r--r--glow/src/shader/common/gradient.frag59
-rw-r--r--glow/src/shader/common/gradient.vert9
-rw-r--r--glow/src/shader/common/image.frag22
-rw-r--r--glow/src/shader/common/image.vert9
-rw-r--r--glow/src/shader/common/solid.frag (renamed from glow/src/shader/common/triangle.frag)2
-rw-r--r--glow/src/shader/common/solid.vert (renamed from glow/src/shader/common/triangle.vert)2
-rw-r--r--glow/src/shader/compatibility/quad.frag24
-rw-r--r--glow/src/shader/compatibility/quad.vert12
-rw-r--r--glow/src/shader/core/quad.frag24
-rw-r--r--glow/src/shader/core/quad.vert12
-rw-r--r--glow/src/triangle.rs640
-rw-r--r--glow/src/window/compositor.rs7
18 files changed, 996 insertions, 221 deletions
diff --git a/glow/src/backend.rs b/glow/src/backend.rs
index 78d4229e..416c3b94 100644
--- a/glow/src/backend.rs
+++ b/glow/src/backend.rs
@@ -1,7 +1,8 @@
-use crate::program;
+#[cfg(any(feature = "image", feature = "svg"))]
+use crate::image;
use crate::quad;
use crate::text;
-use crate::triangle;
+use crate::{program, triangle};
use crate::{Settings, Transformation, Viewport};
use iced_graphics::backend;
@@ -16,6 +17,8 @@ use iced_native::{Font, Size};
/// [`iced`]: https://github.com/iced-rs/iced
#[derive(Debug)]
pub struct Backend {
+ #[cfg(any(feature = "image", feature = "svg"))]
+ image_pipeline: image::Pipeline,
quad_pipeline: quad::Pipeline,
text_pipeline: text::Pipeline,
triangle_pipeline: triangle::Pipeline,
@@ -33,10 +36,14 @@ impl Backend {
let shader_version = program::Version::new(gl);
+ #[cfg(any(feature = "image", feature = "svg"))]
+ let image_pipeline = image::Pipeline::new(gl, &shader_version);
let quad_pipeline = quad::Pipeline::new(gl, &shader_version);
let triangle_pipeline = triangle::Pipeline::new(gl, &shader_version);
Self {
+ #[cfg(any(feature = "image", feature = "svg"))]
+ image_pipeline,
quad_pipeline,
text_pipeline,
triangle_pipeline,
@@ -71,6 +78,9 @@ impl Backend {
viewport_size.height,
);
}
+
+ #[cfg(any(feature = "image", feature = "svg"))]
+ self.image_pipeline.trim_cache(gl);
}
fn flush(
@@ -105,11 +115,26 @@ impl Backend {
* Transformation::scale(scale_factor, scale_factor);
self.triangle_pipeline.draw(
+ &layer.meshes,
gl,
target_height,
scaled,
scale_factor,
- &layer.meshes,
+ );
+ }
+
+ #[cfg(any(feature = "image", feature = "svg"))]
+ if !layer.images.is_empty() {
+ let scaled = transformation
+ * Transformation::scale(scale_factor, scale_factor);
+
+ self.image_pipeline.draw(
+ gl,
+ target_height,
+ scaled,
+ scale_factor,
+ &layer.images,
+ bounds,
);
}
@@ -239,8 +264,8 @@ impl backend::Text for Backend {
#[cfg(feature = "image")]
impl backend::Image for Backend {
- fn dimensions(&self, _handle: &iced_native::image::Handle) -> (u32, u32) {
- (50, 50)
+ fn dimensions(&self, handle: &iced_native::image::Handle) -> Size<u32> {
+ self.image_pipeline.dimensions(handle)
}
}
@@ -248,8 +273,8 @@ impl backend::Image for Backend {
impl backend::Svg for Backend {
fn viewport_dimensions(
&self,
- _handle: &iced_native::svg::Handle,
- ) -> (u32, u32) {
- (50, 50)
+ handle: &iced_native::svg::Handle,
+ ) -> Size<u32> {
+ self.image_pipeline.viewport_dimensions(handle)
}
}
diff --git a/glow/src/image.rs b/glow/src/image.rs
new file mode 100644
index 00000000..521a01e7
--- /dev/null
+++ b/glow/src/image.rs
@@ -0,0 +1,248 @@
+mod storage;
+
+use storage::Storage;
+
+pub use iced_graphics::triangle::{Mesh2D, Vertex2D};
+
+use crate::program::{self, Shader};
+use crate::Transformation;
+
+#[cfg(feature = "image")]
+use iced_graphics::image::raster;
+
+#[cfg(feature = "svg")]
+use iced_graphics::image::vector;
+
+use iced_graphics::layer;
+use iced_graphics::Rectangle;
+use iced_graphics::Size;
+
+use glow::HasContext;
+
+use std::cell::RefCell;
+
+#[derive(Debug)]
+pub(crate) struct Pipeline {
+ program: <glow::Context as HasContext>::Program,
+ vertex_array: <glow::Context as HasContext>::VertexArray,
+ vertex_buffer: <glow::Context as HasContext>::Buffer,
+ transform_location: <glow::Context as HasContext>::UniformLocation,
+ storage: Storage,
+ #[cfg(feature = "image")]
+ raster_cache: RefCell<raster::Cache<Storage>>,
+ #[cfg(feature = "svg")]
+ vector_cache: RefCell<vector::Cache<Storage>>,
+}
+
+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/image.vert"),
+ );
+ let fragment_shader = Shader::fragment(
+ gl,
+ shader_version,
+ include_str!("shader/common/image.frag"),
+ );
+
+ program::create(
+ gl,
+ &[vertex_shader, fragment_shader],
+ &[(0, "i_Position")],
+ )
+ };
+
+ 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_buffer =
+ unsafe { gl.create_buffer().expect("Create vertex buffer") };
+ let vertex_array =
+ unsafe { gl.create_vertex_array().expect("Create vertex array") };
+
+ unsafe {
+ gl.bind_vertex_array(Some(vertex_array));
+ gl.bind_buffer(glow::ARRAY_BUFFER, Some(vertex_buffer));
+
+ let vertices = &[0u8, 0, 1, 0, 0, 1, 1, 1];
+ gl.buffer_data_size(
+ glow::ARRAY_BUFFER,
+ vertices.len() as i32,
+ glow::STATIC_DRAW,
+ );
+ gl.buffer_sub_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ 0,
+ bytemuck::cast_slice(vertices),
+ );
+
+ gl.enable_vertex_attrib_array(0);
+ gl.vertex_attrib_pointer_f32(
+ 0,
+ 2,
+ glow::UNSIGNED_BYTE,
+ false,
+ 0,
+ 0,
+ );
+
+ gl.bind_buffer(glow::ARRAY_BUFFER, None);
+ gl.bind_vertex_array(None);
+ }
+
+ Pipeline {
+ program,
+ vertex_array,
+ vertex_buffer,
+ transform_location,
+ storage: Storage::default(),
+ #[cfg(feature = "image")]
+ raster_cache: RefCell::new(raster::Cache::default()),
+ #[cfg(feature = "svg")]
+ vector_cache: RefCell::new(vector::Cache::default()),
+ }
+ }
+
+ #[cfg(feature = "image")]
+ pub fn dimensions(&self, handle: &iced_native::image::Handle) -> Size<u32> {
+ self.raster_cache.borrow_mut().load(handle).dimensions()
+ }
+
+ #[cfg(feature = "svg")]
+ pub fn viewport_dimensions(
+ &self,
+ handle: &iced_native::svg::Handle,
+ ) -> Size<u32> {
+ let mut cache = self.vector_cache.borrow_mut();
+ let svg = cache.load(handle);
+
+ svg.viewport_dimensions()
+ }
+
+ pub fn draw(
+ &mut self,
+ mut gl: &glow::Context,
+ target_height: u32,
+ transformation: Transformation,
+ _scale_factor: f32,
+ images: &[layer::Image],
+ layer_bounds: Rectangle<u32>,
+ ) {
+ unsafe {
+ 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.enable(glow::SCISSOR_TEST);
+ }
+
+ #[cfg(feature = "image")]
+ let mut raster_cache = self.raster_cache.borrow_mut();
+
+ #[cfg(feature = "svg")]
+ let mut vector_cache = self.vector_cache.borrow_mut();
+
+ for image in images {
+ let (entry, bounds) = match &image {
+ #[cfg(feature = "image")]
+ layer::Image::Raster { handle, bounds } => (
+ raster_cache.upload(handle, &mut gl, &mut self.storage),
+ bounds,
+ ),
+ #[cfg(not(feature = "image"))]
+ layer::Image::Raster { handle: _, bounds } => (None, bounds),
+
+ #[cfg(feature = "svg")]
+ layer::Image::Vector {
+ handle,
+ color,
+ bounds,
+ } => {
+ let size = [bounds.width, bounds.height];
+ (
+ vector_cache.upload(
+ handle,
+ *color,
+ size,
+ _scale_factor,
+ &mut gl,
+ &mut self.storage,
+ ),
+ bounds,
+ )
+ }
+
+ #[cfg(not(feature = "svg"))]
+ layer::Image::Vector { bounds, .. } => (None, bounds),
+ };
+
+ unsafe {
+ gl.scissor(
+ layer_bounds.x as i32,
+ (target_height - (layer_bounds.y + layer_bounds.height))
+ as i32,
+ layer_bounds.width as i32,
+ layer_bounds.height as i32,
+ );
+
+ if let Some(storage::Entry { texture, .. }) = entry {
+ gl.bind_texture(glow::TEXTURE_2D, Some(*texture))
+ } else {
+ continue;
+ }
+
+ let translate = Transformation::translate(bounds.x, bounds.y);
+ let scale = Transformation::scale(bounds.width, bounds.height);
+ let transformation = transformation * translate * scale;
+ let matrix: [f32; 16] = transformation.into();
+ gl.uniform_matrix_4_f32_slice(
+ Some(&self.transform_location),
+ false,
+ &matrix,
+ );
+
+ gl.draw_arrays(glow::TRIANGLE_STRIP, 0, 4);
+
+ gl.bind_texture(glow::TEXTURE_2D, None);
+ }
+ }
+
+ unsafe {
+ gl.bind_buffer(glow::ARRAY_BUFFER, None);
+ gl.bind_vertex_array(None);
+ gl.use_program(None);
+ gl.disable(glow::SCISSOR_TEST);
+ }
+ }
+
+ pub fn trim_cache(&mut self, mut gl: &glow::Context) {
+ #[cfg(feature = "image")]
+ self.raster_cache
+ .borrow_mut()
+ .trim(&mut self.storage, &mut gl);
+
+ #[cfg(feature = "svg")]
+ self.vector_cache
+ .borrow_mut()
+ .trim(&mut self.storage, &mut gl);
+ }
+}
diff --git a/glow/src/image/storage.rs b/glow/src/image/storage.rs
new file mode 100644
index 00000000..9bc20641
--- /dev/null
+++ b/glow/src/image/storage.rs
@@ -0,0 +1,78 @@
+use iced_graphics::image;
+use iced_graphics::Size;
+
+use glow::HasContext;
+
+#[derive(Debug, Default)]
+pub struct Storage;
+
+impl image::Storage for Storage {
+ type Entry = Entry;
+ type State<'a> = &'a glow::Context;
+
+ fn upload(
+ &mut self,
+ width: u32,
+ height: u32,
+ data: &[u8],
+ gl: &mut &glow::Context,
+ ) -> Option<Self::Entry> {
+ unsafe {
+ let texture = gl.create_texture().expect("create texture");
+ gl.bind_texture(glow::TEXTURE_2D, Some(texture));
+ gl.tex_image_2d(
+ glow::TEXTURE_2D,
+ 0,
+ glow::SRGB8_ALPHA8 as i32,
+ width as i32,
+ height as i32,
+ 0,
+ glow::RGBA,
+ glow::UNSIGNED_BYTE,
+ Some(data),
+ );
+ gl.tex_parameter_i32(
+ glow::TEXTURE_2D,
+ glow::TEXTURE_WRAP_S,
+ glow::CLAMP_TO_EDGE as _,
+ );
+ gl.tex_parameter_i32(
+ glow::TEXTURE_2D,
+ glow::TEXTURE_WRAP_T,
+ glow::CLAMP_TO_EDGE as _,
+ );
+ gl.tex_parameter_i32(
+ glow::TEXTURE_2D,
+ glow::TEXTURE_MIN_FILTER,
+ glow::LINEAR as _,
+ );
+ gl.tex_parameter_i32(
+ glow::TEXTURE_2D,
+ glow::TEXTURE_MAG_FILTER,
+ glow::LINEAR as _,
+ );
+ gl.bind_texture(glow::TEXTURE_2D, None);
+
+ Some(Entry {
+ size: Size::new(width, height),
+ texture,
+ })
+ }
+ }
+
+ fn remove(&mut self, entry: &Entry, gl: &mut &glow::Context) {
+ unsafe { gl.delete_texture(entry.texture) }
+ }
+}
+
+#[derive(Debug)]
+pub struct Entry {
+ size: Size<u32>,
+ pub(super) texture: glow::NativeTexture,
+}
+
+impl image::storage::Entry for Entry {
+ fn size(&self) -> Size<u32> {
+ self.size
+ }
+}
diff --git a/glow/src/lib.rs b/glow/src/lib.rs
index de9c0002..710ac36d 100644
--- a/glow/src/lib.rs
+++ b/glow/src/lib.rs
@@ -3,7 +3,7 @@
//! ![The native path of the Iced ecosystem](https://github.com/iced-rs/iced/blob/0525d76ff94e828b7b21634fa94a747022001c83/docs/graphs/native.png?raw=true)
//!
//! [`glow`]: https://github.com/grovesNL/glow
-//! [`iced_native`]: https://github.com/iced-rs/iced/tree/0.4/native
+//! [`iced_native`]: https://github.com/iced-rs/iced/tree/0.6/native
#![doc(
html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
)]
@@ -24,6 +24,8 @@
pub use glow;
mod backend;
+#[cfg(any(feature = "image", feature = "svg"))]
+mod image;
mod program;
mod quad;
mod text;
diff --git a/glow/src/quad/compatibility.rs b/glow/src/quad/compatibility.rs
index eb3fb7e0..e909162c 100644
--- a/glow/src/quad/compatibility.rs
+++ b/glow/src/quad/compatibility.rs
@@ -70,11 +70,10 @@ impl Pipeline {
unsafe {
gl.use_program(Some(program));
- let matrix: [f32; 16] = Transformation::identity().into();
gl.uniform_matrix_4_f32_slice(
Some(&transform_location),
false,
- &matrix,
+ Transformation::identity().as_ref(),
);
gl.uniform_1_f32(Some(&scale_location), 1.0);
@@ -139,11 +138,10 @@ impl Pipeline {
if transformation != self.current_transform {
unsafe {
- let matrix: [f32; 16] = transformation.into();
gl.uniform_matrix_4_f32_slice(
Some(&self.transform_location),
false,
- &matrix,
+ transformation.as_ref(),
);
self.current_transform = transformation;
@@ -256,7 +254,7 @@ unsafe fn create_buffers(
gl.enable_vertex_attrib_array(4);
gl.vertex_attrib_pointer_f32(
4,
- 1,
+ 4,
glow::FLOAT,
false,
stride,
@@ -270,7 +268,7 @@ unsafe fn create_buffers(
glow::FLOAT,
false,
stride,
- 4 * (2 + 2 + 4 + 4 + 1),
+ 4 * (2 + 2 + 4 + 4 + 4),
);
gl.enable_vertex_attrib_array(6);
@@ -280,7 +278,7 @@ unsafe fn create_buffers(
glow::FLOAT,
false,
stride,
- 4 * (2 + 2 + 4 + 4 + 1 + 1),
+ 4 * (2 + 2 + 4 + 4 + 4 + 1),
);
gl.bind_vertex_array(None);
@@ -309,7 +307,7 @@ pub struct Vertex {
pub border_color: [f32; 4],
/// The border radius of the [`Vertex`].
- pub border_radius: f32,
+ pub border_radius: [f32; 4],
/// The border width of the [`Vertex`].
pub border_width: f32,
diff --git a/glow/src/quad/core.rs b/glow/src/quad/core.rs
index 3e51b1ca..89036530 100644
--- a/glow/src/quad/core.rs
+++ b/glow/src/quad/core.rs
@@ -65,11 +65,10 @@ impl Pipeline {
unsafe {
gl.use_program(Some(program));
- let matrix: [f32; 16] = Transformation::identity().into();
gl.uniform_matrix_4_f32_slice(
Some(&transform_location),
false,
- &matrix,
+ Transformation::identity().as_ref(),
);
gl.uniform_1_f32(Some(&scale_location), 1.0);
@@ -119,11 +118,10 @@ impl Pipeline {
if transformation != self.current_transform {
unsafe {
- let matrix: [f32; 16] = transformation.into();
gl.uniform_matrix_4_f32_slice(
Some(&self.transform_location),
false,
- &matrix,
+ transformation.as_ref(),
);
self.current_transform = transformation;
@@ -220,7 +218,7 @@ unsafe fn create_instance_buffer(
gl.enable_vertex_attrib_array(4);
gl.vertex_attrib_pointer_f32(
4,
- 1,
+ 4,
glow::FLOAT,
false,
stride,
@@ -235,7 +233,7 @@ unsafe fn create_instance_buffer(
glow::FLOAT,
false,
stride,
- 4 * (2 + 2 + 4 + 4 + 1),
+ 4 * (2 + 2 + 4 + 4 + 4),
);
gl.vertex_attrib_divisor(5, 1);
diff --git a/glow/src/shader/common/gradient.frag b/glow/src/shader/common/gradient.frag
new file mode 100644
index 00000000..9af0cb6e
--- /dev/null
+++ b/glow/src/shader/common/gradient.frag
@@ -0,0 +1,59 @@
+#ifdef GL_ES
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+#endif
+
+#ifdef HIGHER_THAN_300
+layout (location = 0) out vec4 fragColor;
+#define gl_FragColor fragColor
+#endif
+
+in vec2 raw_position;
+
+uniform vec4 gradient_direction;
+uniform int color_stops_size;
+// GLSL does not support dynamically sized arrays without SSBOs so this is capped to 16 stops
+//stored as color(vec4) -> offset(vec4) sequentially;
+uniform vec4 color_stops[32];
+
+//TODO: rewrite without branching to make ALUs happy
+void main() {
+ vec2 start = gradient_direction.xy;
+ vec2 end = gradient_direction.zw;
+ vec2 gradient_vec = vec2(end - start);
+ vec2 current_vec = vec2(raw_position.xy - start);
+ vec2 unit = normalize(gradient_vec);
+ float coord_offset = dot(unit, current_vec) / length(gradient_vec);
+ //if a gradient has a start/end stop that is identical, the mesh will have a transparent fill
+ gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+
+ float min_offset = color_stops[1].x;
+ float max_offset = color_stops[color_stops_size - 1].x;
+
+ for (int i = 0; i < color_stops_size - 2; i += 2) {
+ float curr_offset = color_stops[i+1].x;
+ float next_offset = color_stops[i+3].x;
+
+ if (coord_offset <= min_offset) {
+ //current coordinate is before the first defined offset, set it to the start color
+ gl_FragColor = color_stops[0];
+ }
+
+ if (curr_offset <= coord_offset && coord_offset <= next_offset) {
+ //current fragment is between the current offset processing & the next one, interpolate colors
+ gl_FragColor = mix(color_stops[i], color_stops[i+2], smoothstep(
+ curr_offset,
+ next_offset,
+ coord_offset
+ ));
+ }
+
+ if (coord_offset >= max_offset) {
+ //current coordinate is before the last defined offset, set it to the last color
+ gl_FragColor = color_stops[color_stops_size - 2];
+ }
+ }
+}
diff --git a/glow/src/shader/common/gradient.vert b/glow/src/shader/common/gradient.vert
new file mode 100644
index 00000000..fe505997
--- /dev/null
+++ b/glow/src/shader/common/gradient.vert
@@ -0,0 +1,9 @@
+uniform mat4 u_Transform;
+
+in vec2 i_Position;
+out vec2 raw_position;
+
+void main() {
+ gl_Position = u_Transform * vec4(i_Position, 0.0, 1.0);
+ raw_position = i_Position;
+}
diff --git a/glow/src/shader/common/image.frag b/glow/src/shader/common/image.frag
new file mode 100644
index 00000000..5e05abdf
--- /dev/null
+++ b/glow/src/shader/common/image.frag
@@ -0,0 +1,22 @@
+#ifdef GL_ES
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+#endif
+
+uniform sampler2D tex;
+in vec2 tex_pos;
+
+#ifdef HIGHER_THAN_300
+out vec4 fragColor;
+#define gl_FragColor fragColor
+#endif
+#ifdef GL_ES
+#define texture texture2D
+#endif
+
+void main() {
+ gl_FragColor = texture(tex, tex_pos);
+}
diff --git a/glow/src/shader/common/image.vert b/glow/src/shader/common/image.vert
new file mode 100644
index 00000000..93e541f2
--- /dev/null
+++ b/glow/src/shader/common/image.vert
@@ -0,0 +1,9 @@
+uniform mat4 u_Transform;
+
+in vec2 i_Position;
+out vec2 tex_pos;
+
+void main() {
+ gl_Position = u_Transform * vec4(i_Position, 0.0, 1.0);
+ tex_pos = i_Position;
+}
diff --git a/glow/src/shader/common/triangle.frag b/glow/src/shader/common/solid.frag
index e8689f2e..174ffdd3 100644
--- a/glow/src/shader/common/triangle.frag
+++ b/glow/src/shader/common/solid.frag
@@ -15,4 +15,4 @@ 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/solid.vert
index d0494a5f..59ed88e5 100644
--- a/glow/src/shader/common/triangle.vert
+++ b/glow/src/shader/common/solid.vert
@@ -8,4 +8,4 @@ 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 8ea5693d..bb9d8122 100644
--- a/glow/src/shader/compatibility/quad.frag
+++ b/glow/src/shader/compatibility/quad.frag
@@ -12,7 +12,7 @@ varying vec4 v_Color;
varying vec4 v_BorderColor;
varying vec2 v_Pos;
varying vec2 v_Scale;
-varying float v_BorderRadius;
+varying vec4 v_BorderRadius;
varying float v_BorderWidth;
float _distance(vec2 frag_coord, vec2 position, vec2 size, float radius)
@@ -33,10 +33,26 @@ float _distance(vec2 frag_coord, vec2 position, vec2 size, float radius)
return sqrt(distance.x * distance.x + distance.y * distance.y);
}
+float selectBorderRadius(vec4 radi, vec2 position, vec2 center)
+{
+ float rx = radi.x;
+ float ry = radi.y;
+ rx = position.x > center.x ? radi.y : radi.x;
+ ry = position.x > center.x ? radi.z : radi.w;
+ rx = position.y > center.y ? ry : rx;
+ return rx;
+}
+
void main() {
vec2 fragCoord = vec2(gl_FragCoord.x, u_ScreenHeight - gl_FragCoord.y);
- float internal_border = max(v_BorderRadius - v_BorderWidth, 0.0);
+ float border_radius = selectBorderRadius(
+ v_BorderRadius,
+ fragCoord,
+ (v_Pos + v_Scale * 0.5).xy
+ );
+
+ float internal_border = max(border_radius - v_BorderWidth, 0.0);
float internal_distance = _distance(
fragCoord,
@@ -57,11 +73,11 @@ void main() {
fragCoord,
v_Pos,
v_Scale,
- v_BorderRadius
+ border_radius
);
float radius_alpha =
- 1.0 - smoothstep(max(v_BorderRadius - 0.5, 0.0), v_BorderRadius + 0.5, d);
+ 1.0 - smoothstep(max(border_radius - 0.5, 0.0), border_radius + 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
index abe70c0e..89931f06 100644
--- a/glow/src/shader/compatibility/quad.vert
+++ b/glow/src/shader/compatibility/quad.vert
@@ -5,7 +5,7 @@ attribute vec2 i_Pos;
attribute vec2 i_Scale;
attribute vec4 i_Color;
attribute vec4 i_BorderColor;
-attribute float i_BorderRadius;
+attribute vec4 i_BorderRadius;
attribute float i_BorderWidth;
attribute vec2 q_Pos;
@@ -13,7 +13,7 @@ varying vec4 v_Color;
varying vec4 v_BorderColor;
varying vec2 v_Pos;
varying vec2 v_Scale;
-varying float v_BorderRadius;
+varying vec4 v_BorderRadius;
varying float v_BorderWidth;
@@ -21,9 +21,11 @@ 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
+ vec4 i_BorderRadius = vec4(
+ min(i_BorderRadius.x, min(i_Scale.x, i_Scale.y) / 2.0),
+ min(i_BorderRadius.y, min(i_Scale.x, i_Scale.y) / 2.0),
+ min(i_BorderRadius.z, min(i_Scale.x, i_Scale.y) / 2.0),
+ min(i_BorderRadius.w, min(i_Scale.x, i_Scale.y) / 2.0)
);
mat4 i_Transform = mat4(
diff --git a/glow/src/shader/core/quad.frag b/glow/src/shader/core/quad.frag
index 57e2e8e7..71147aa5 100644
--- a/glow/src/shader/core/quad.frag
+++ b/glow/src/shader/core/quad.frag
@@ -17,7 +17,7 @@ in vec4 v_Color;
in vec4 v_BorderColor;
in vec2 v_Pos;
in vec2 v_Scale;
-in float v_BorderRadius;
+in vec4 v_BorderRadius;
in float v_BorderWidth;
float fDistance(vec2 frag_coord, vec2 position, vec2 size, float radius)
@@ -38,14 +38,30 @@ float fDistance(vec2 frag_coord, vec2 position, vec2 size, float radius)
return sqrt(distance.x * distance.x + distance.y * distance.y);
}
+float selectBorderRadius(vec4 radi, vec2 position, vec2 center)
+{
+ float rx = radi.x;
+ float ry = radi.y;
+ rx = position.x > center.x ? radi.y : radi.x;
+ ry = position.x > center.x ? radi.z : radi.w;
+ rx = position.y > center.y ? ry : rx;
+ return rx;
+}
+
void main() {
vec4 mixed_color;
vec2 fragCoord = vec2(gl_FragCoord.x, u_ScreenHeight - gl_FragCoord.y);
+ float border_radius = selectBorderRadius(
+ v_BorderRadius,
+ fragCoord,
+ (v_Pos + v_Scale * 0.5).xy
+ );
+
// TODO: Remove branching (?)
if(v_BorderWidth > 0.0) {
- float internal_border = max(v_BorderRadius - v_BorderWidth, 0.0);
+ float internal_border = max(border_radius - v_BorderWidth, 0.0);
float internal_distance = fDistance(
fragCoord,
@@ -69,11 +85,11 @@ void main() {
fragCoord,
v_Pos,
v_Scale,
- v_BorderRadius
+ border_radius
);
float radius_alpha =
- 1.0 - smoothstep(max(v_BorderRadius - 0.5, 0.0), v_BorderRadius + 0.5, d);
+ 1.0 - smoothstep(max(border_radius - 0.5, 0.0), border_radius + 0.5, d);
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 b1fb2365..17c3e641 100644
--- a/glow/src/shader/core/quad.vert
+++ b/glow/src/shader/core/quad.vert
@@ -5,14 +5,14 @@ in vec2 i_Pos;
in vec2 i_Scale;
in vec4 i_Color;
in vec4 i_BorderColor;
-in float i_BorderRadius;
+in vec4 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 vec4 v_BorderRadius;
out float v_BorderWidth;
vec2 positions[4] = vec2[](
@@ -27,9 +27,11 @@ 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
+ vec4 i_BorderRadius = vec4(
+ min(i_BorderRadius.x, min(i_Scale.x, i_Scale.y) / 2.0),
+ min(i_BorderRadius.y, min(i_Scale.x, i_Scale.y) / 2.0),
+ min(i_BorderRadius.z, min(i_Scale.x, i_Scale.y) / 2.0),
+ min(i_BorderRadius.w, min(i_Scale.x, i_Scale.y) / 2.0)
);
mat4 i_Transform = mat4(
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,
+ },
+ }
+ }
+ }
+}
diff --git a/glow/src/window/compositor.rs b/glow/src/window/compositor.rs
index f6afaa68..20756032 100644
--- a/glow/src/window/compositor.rs
+++ b/glow/src/window/compositor.rs
@@ -26,8 +26,11 @@ impl<Theme> iced_graphics::window::GLCompositor for Compositor<Theme> {
log::info!("{:#?}", settings);
let version = gl.version();
- log::info!("Version: {:?}", version);
- log::info!("Embedded: {}", version.is_embedded);
+ log::info!(
+ "OpenGL version: {:?} (Embedded: {})",
+ version,
+ version.is_embedded
+ );
let renderer = gl.get_parameter_string(glow::RENDERER);
log::info!("Renderer: {}", renderer);
generated by cgit (git 2.34.1) at 2025-04-24 22:55:51 +0000