shadowcat/iris
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mistakes were fixed and sins were committed

Browse Source
This commit is contained in:
shadow cat
2025-11-20 00:18:30 -05:00
parent db248de8f4
commit a952b34a72
18 changed files with 418 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

224
src/layout/painter.rs
View File

@@ -1,7 +1,7 @@
use crate::{
layout::{
Layers, Modules, Size, TextAttrs, TextBuffer, TextData, TextTexture, TextureHandle,
Textures, UiRegion, UiVec2, Vec2, WidgetId, Widgets,
Axis, Layers, Len, Modules, Size, TextAttrs, TextBuffer, TextData, TextTexture,
TextureHandle, Textures, UiRegion, UiVec2, Vec2, WidgetId, Widgets,
},
render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
util::{HashMap, HashSet, Id, TrackedArena},
@@ -14,7 +14,8 @@ pub struct Painter<'a, 'c> {
textures: Vec<TextureHandle>,
primitives: Vec<PrimitiveHandle>,
children: Vec<Id>,
sized_children: HashMap<Id, Size>,
children_width: HashMap<Id, (UiVec2, Len)>,
children_height: HashMap<Id, (UiVec2, Len)>,
/// whether this widget depends on region's final pixel size or not
/// TODO: decide if point (pt) should be used here instead of px
pub layer: usize,
@@ -31,9 +32,17 @@ pub struct PainterCtx<'a> {
pub screen_size: Vec2,
pub modules: &'a mut Modules,
pub px_dependent: &'a mut HashSet<Id>,
pub cache_width: HashMap<Id, (UiVec2, Len)>,
pub cache_height: HashMap<Id, (UiVec2, Len)>,
draw_started: HashSet<Id>,
}
#[derive(Default)]
pub struct ResizeRef {
x: Option<(Id, (UiVec2, Len))>,
y: Option<(Id, (UiVec2, Len))>,
}
pub struct WidgetInstance {
pub id: Id,
pub region: UiRegion,
@@ -41,10 +50,9 @@ pub struct WidgetInstance {
pub textures: Vec<TextureHandle>,
pub primitives: Vec<PrimitiveHandle>,
pub children: Vec<Id>,
pub resize: Option<Id>,
pub resize: ResizeRef,
pub mask: MaskIdx,
pub layer: usize,
pub desired_size: Size,
}
#[derive(Default)]
@@ -72,7 +80,9 @@ impl<'a> PainterCtx<'a> {
modules: &mut data.modules,
px_dependent: &mut data.px_dependent,
masks: &mut data.masks,
draw_started: HashSet::default(),
cache_width: Default::default(),
cache_height: Default::default(),
draw_started: Default::default(),
}
}
@@ -84,19 +94,51 @@ impl<'a> PainterCtx<'a> {
return;
};
if let Some(rid) = active.resize {
let desired = SizeCtx {
checked: &mut Default::default(),
// TODO: this is stupid having 2 of these
if let Some((rid, (outer, old_desired))) = active.resize.x {
let new_desired = SizeCtx {
source: id,
cache_width: &mut self.cache_width,
cache_height: &mut self.cache_height,
text: self.text,
textures: self.textures,
widgets: self.widgets,
size: UiVec2::FULL_SIZE,
screen_size: self.screen_size,
outer,
output_size: self.screen_size,
checked_width: &mut Default::default(),
checked_height: &mut Default::default(),
px_dependent: &mut Default::default(),
id,
}
.size_inner(id, active.region.size());
if active.desired_size != desired {
.width_inner(id);
if new_desired != old_desired {
self.redraw(rid);
if self.draw_started.contains(&id) {
return;
}
}
}
let Some(active) = self.active.get(&id) else {
return;
};
if let Some((rid, (outer, old_desired))) = active.resize.y {
let new_desired = SizeCtx {
source: id,
cache_width: &mut self.cache_width,
cache_height: &mut self.cache_height,
text: self.text,
textures: self.textures,
widgets: self.widgets,
outer,
output_size: self.screen_size,
checked_width: &mut Default::default(),
checked_height: &mut Default::default(),
px_dependent: &mut Default::default(),
id,
}
.height_inner(id);
if new_desired != old_desired {
self.redraw(rid);
if self.draw_started.contains(&id) {
return;
@@ -147,7 +189,7 @@ impl<'a> PainterCtx<'a> {
);
}
let mut old_children = old_children.unwrap_or_default();
let mut resize = None;
let mut resize = ResizeRef::default();
if let Some(active) = self.active.get_mut(&id) {
if active.parent != parent {
panic!("Cannot draw the same widget twice (2)");
@@ -167,18 +209,6 @@ impl<'a> PainterCtx<'a> {
self.draw_started.insert(id);
let desired_size = SizeCtx {
text: self.text,
textures: self.textures,
widgets: self.widgets,
checked: &mut Default::default(),
screen_size: self.screen_size,
px_dependent: &mut Default::default(),
id,
size: region.size(),
}
.size_raw(id);
let mut painter = Painter {
region,
mask,
@@ -188,13 +218,15 @@ impl<'a> PainterCtx<'a> {
primitives: Vec::new(),
ctx: self,
children: Vec::new(),
sized_children: Default::default(),
children_width: Default::default(),
children_height: Default::default(),
};
// draw widgets
painter.ctx.widgets.get_dyn_dynamic(id).draw(&mut painter);
let sized_children = painter.sized_children;
let children_width = painter.children_width;
let children_height = painter.children_height;
// add to active
let instance = WidgetInstance {
@@ -206,14 +238,20 @@ impl<'a> PainterCtx<'a> {
children: painter.children,
resize,
mask: painter.mask,
desired_size,
layer,
};
for cid in sized_children.keys() {
if let Some(w) = self.active.get_mut(cid)
&& w.resize.is_none()
for (cid, outer) in children_width {
if let Some(w) = self.active.get_mut(&cid)
&& w.resize.x.is_none()
{
w.resize = Some(id)
w.resize.x = Some((id, outer))
}
}
for (cid, outer) in children_height {
if let Some(w) = self.active.get_mut(&cid)
&& w.resize.y.is_none()
{
w.resize.y = Some((id, outer))
}
}
for c in &old_children {
@@ -230,8 +268,6 @@ impl<'a> PainterCtx<'a> {
fn mov(&mut self, id: Id, from: UiRegion, to: UiRegion) {
let active = self.active.get_mut(&id).unwrap();
// children will not be changed, so this technically should not be needed
// probably need unsafe
for h in &active.primitives {
let region = self.layers[h.layer].primitives.region_mut(h);
*region = region.outside(&from).within(&to);
@@ -240,6 +276,8 @@ impl<'a> PainterCtx<'a> {
for m in self.modules.iter_mut() {
m.on_move(active);
}
// children will not be changed, so this technically should not be needed
// probably need unsafe
let children = active.children.clone();
for child in children {
self.mov(child, from, to);
@@ -354,8 +392,11 @@ impl<'a, 'c> Painter<'a, 'c> {
self.size_ctx().size(id)
}
pub fn region_size<W>(&mut self, id: &WidgetId<W>) -> UiVec2 {
self.size_ctx().size(id).to_uivec2(self.region.size().rel)
pub fn len_axis<W>(&mut self, id: &WidgetId<W>, axis: Axis) -> Len {
match axis {
Axis::X => self.size_ctx().width(id),
Axis::Y => self.size_ctx().height(id),
}
}
pub fn size_ctx(&mut self) -> SizeCtx<'_> {
@@ -363,11 +404,15 @@ impl<'a, 'c> Painter<'a, 'c> {
text: self.ctx.text,
textures: self.ctx.textures,
widgets: self.ctx.widgets,
checked: &mut self.sized_children,
screen_size: self.ctx.screen_size,
output_size: self.ctx.screen_size,
px_dependent: self.ctx.px_dependent,
checked_width: &mut self.children_width,
checked_height: &mut self.children_height,
cache_width: &mut self.ctx.cache_width,
cache_height: &mut self.ctx.cache_height,
source: self.id,
id: self.id,
size: self.region.size(),
outer: self.region.size(),
}
}
@@ -396,41 +441,98 @@ impl<'a, 'c> Painter<'a, 'c> {
pub struct SizeCtx<'a> {
pub text: &'a mut TextData,
pub textures: &'a mut Textures,
source: Id,
widgets: &'a Widgets,
px_dependent: &'a mut HashSet<Id>,
checked: &'a mut HashMap<Id, Size>,
cache_width: &'a mut HashMap<Id, (UiVec2, Len)>,
cache_height: &'a mut HashMap<Id, (UiVec2, Len)>,
checked_width: &'a mut HashMap<Id, (UiVec2, Len)>,
checked_height: &'a mut HashMap<Id, (UiVec2, Len)>,
/// TODO: should this be pub? rn used for sized
pub size: UiVec2,
screen_size: Vec2,
pub outer: UiVec2,
output_size: Vec2,
id: Id,
}
impl SizeCtx<'_> {
fn size_inner(&mut self, id: Id, size: UiVec2) -> Size {
let self_size = self.size;
self.size = size;
let size = self.widgets.get_dyn_dynamic(id).desired_size(self);
self.size = self_size;
self.checked.insert(id, size);
size
pub fn id(&self) -> &Id {
&self.id
}
pub fn source(&self) -> &Id {
&self.source
}
fn width_inner(&mut self, id: Id) -> Len {
if let Some(&(outer, len)) = self.cache_width.get(&id)
&& outer == self.outer
{
self.checked_width.insert(id, (self.outer, len));
return len;
}
let self_outer = self.outer;
let self_id = self.id;
self.id = id;
let len = self.widgets.get_dyn_dynamic(id).desired_width(self);
self.outer = self_outer;
self.id = self_id;
self.cache_width.insert(id, (self.outer, len));
self.checked_width.insert(id, (self.outer, len));
len
}
// TODO: should be refactored to share code w width_inner
fn height_inner(&mut self, id: Id) -> Len {
if let Some(&(outer, len)) = self.cache_height.get(&id)
&& outer == self.outer
{
self.checked_height.insert(id, (self.outer, len));
return len;
}
let self_outer = self.outer;
let self_id = self.id;
self.id = id;
let len = self.widgets.get_dyn_dynamic(id).desired_height(self);
self.outer = self_outer;
self.id = self_id;
self.cache_height.insert(id, (self.outer, len));
self.checked_height.insert(id, (self.outer, len));
len
}
pub fn width<W>(&mut self, id: &WidgetId<W>) -> Len {
self.width_inner(id.id)
}
pub fn height<W>(&mut self, id: &WidgetId<W>) -> Len {
self.height_inner(id.id)
}
pub fn len_axis<W>(&mut self, id: &WidgetId<W>, axis: Axis) -> Len {
match axis {
Axis::X => self.width(id),
Axis::Y => self.height(id),
}
}
pub fn size<W>(&mut self, id: &WidgetId<W>) -> Size {
// if let Some(&size) = self.checked.get(&id.id) {
// return size;
// }
self.size_inner(id.id, self.size)
}
fn size_raw(&mut self, id: Id) -> Size {
self.size_inner(id, self.size)
Size {
x: self.width(id),
y: self.height(id),
}
}
pub fn px_size(&mut self) -> Vec2 {
self.px_dependent.insert(self.id);
self.size.to_abs(self.screen_size)
// WARNING IF UNCOMMENT: self.id is no longer valid
// self.px_dependent.insert(self.id);
self.outer.to_abs(self.output_size)
}
pub fn draw_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> TextTexture {
self.text.draw(buffer, attrs, self.textures)
}
pub fn label(&self) -> &String {
self.widgets.label(&self.id)
pub fn label(&self, id: &Id) -> &String {
self.widgets.label(id)
}
}