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

TAG TECHNOLOGY

Browse Source
This commit is contained in:
Shadow Cat
2025-08-14 12:21:26 -04:00
parent 4d68fa476d
commit e41970287d
19 changed files with 267 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
src/base/trait_fns.rs
View File

@@ -1,37 +0,0 @@
use super::*;
use crate::{UIRegion, Ui, Vec2, WidgetArrLike, WidgetFn, WidgetFnRet, WidgetLike};
pub trait BaseWidget {
fn pad(self, padding: impl Into<Padding>) -> WidgetFnRet!(Regioned);
fn center(self, size: impl Into<Vec2>) -> WidgetFnRet!(Regioned);
}
impl<W: WidgetLike> BaseWidget for W {
fn pad(self, padding: impl Into<Padding>) -> WidgetFnRet!(Regioned) {
WidgetFn(|ui| Regioned {
region: padding.into().region(),
inner: self.add(ui).erase_type(),
})
}
fn center(self, size: impl Into<Vec2>) -> WidgetFnRet!(Regioned) {
WidgetFn(|ui| Regioned {
region: UIRegion::center(size.into()),
inner: self.add(ui).erase_type(),
})
}
}
pub trait BaseWidgetArr<const LEN: usize> {
fn span(self, dir: Dir, lengths: [impl Into<SpanLen>; LEN]) -> WidgetFnRet!(Span);
}
impl<const LEN: usize, Wa: WidgetArrLike<LEN>> BaseWidgetArr<LEN> for Wa {
fn span(self, dir: Dir, lengths: [impl Into<SpanLen>; LEN]) -> WidgetFnRet!(Span) {
let lengths = lengths.map(Into::into);
WidgetFn(move |ui| Span {
dir,
children: self.ui(ui).arr.into_iter().zip(lengths).collect(),
})
}
}

12
src/base/frame.rs → src/core/frame.rs
View File

@@ -1,12 +1,12 @@
use crate::{Painter, UINum, UIRegion, Widget, WidgetId};
use crate::{Painter, UINum, UiRegion, Widget, WidgetId};
pub struct Regioned {
pub region: UIRegion,
pub region: UiRegion,
pub inner: WidgetId,
}
impl Widget for Regioned {
fn draw(&self, painter: &mut Painter) {
impl<Ctx: 'static> Widget<Ctx> for Regioned {
fn draw(&self, painter: &mut Painter<Ctx>) {
painter.region.select(&self.region);
painter.draw(&self.inner);
}
@@ -28,8 +28,8 @@ impl Padding {
bottom: amt,
}
}
pub fn region(&self) -> UIRegion {
let mut region = UIRegion::full();
pub fn region(&self) -> UiRegion {
let mut region = UiRegion::full();
region.top_left.offset.x += self.left;
region.top_left.offset.y += self.top;
region.bot_right.offset.x -= self.right;

2
src/base/mod.rs → src/core/mod.rs
View File

@@ -1,11 +1,13 @@
mod frame;
mod num;
mod rect;
mod sense;
mod span;
mod trait_fns;
pub use frame::*;
pub use num::*;
pub use rect::*;
pub use sense::*;
pub use span::*;
pub use trait_fns::*;

0
src/base/num.rs → src/core/num.rs
View File

4
src/base/rect.rs → src/core/rect.rs
View File

@@ -23,8 +23,8 @@ impl Rect {
}
}
impl Widget for Rect {
fn draw(&self, painter: &mut Painter) {
impl<Ctx> Widget<Ctx> for Rect {
fn draw(&self, painter: &mut Painter<Ctx>) {
painter.write(RoundedRectData {
color: self.color,
radius: self.radius,

35
src/core/sense.rs Normal file
View File

@@ -0,0 +1,35 @@
use std::marker::PhantomData;
use crate::{Painter, Widget, WidgetFn, WidgetId, WidgetLike};
pub struct Sensor<F: SenseFn<Ctx>, Ctx> {
inner: WidgetId,
f: F,
_pd: PhantomData<Ctx>,
}
impl<F: SenseFn<Ctx>, Ctx: 'static> Widget<Ctx> for Sensor<F, Ctx> {
fn draw(&self, painter: &mut Painter<Ctx>) {
(self.f)(painter.ctx_mut());
painter.draw(&self.inner);
}
}
pub trait SenseFn<Ctx> = Fn(&mut Ctx) + 'static;
pub trait Sensable<Ctx: 'static, Tag> {
fn sense<F: SenseFn<Ctx>>(self, f: F) -> impl WidgetFn<Sensor<F, Ctx>, Ctx>;
}
impl<W: WidgetLike<Ctx, Tag>, Ctx: 'static, Tag> Sensable<Ctx, Tag> for W {
fn sense<F: SenseFn<Ctx>>(self, f: F) -> impl WidgetFn<Sensor<F, Ctx>, Ctx> {
|ui| {
let inner = self.add(ui).erase_type();
Sensor {
inner,
f,
_pd: PhantomData,
}
}
}
}

8
src/base/span.rs → src/core/span.rs
View File

@@ -1,16 +1,16 @@
use crate::{Dir, Painter, Sign, UINum, UIRegion, UIScalar, Widget, WidgetId};
use crate::{Dir, Painter, Sign, UINum, UiRegion, UIScalar, Widget, WidgetId};
pub struct Span {
pub children: Vec<(WidgetId, SpanLen)>,
pub dir: Dir,
}
impl Widget for Span {
fn draw(&self, painter: &mut Painter) {
impl<Ctx: 'static> Widget<Ctx> for Span {
fn draw(&self, painter: &mut Painter<Ctx>) {
let total = self.sums();
let mut start = UIScalar::min();
for (child, length) in &self.children {
let mut child_region = UIRegion::full();
let mut child_region = UiRegion::full();
let mut axis = child_region.axis_mut(self.dir.axis);
axis.top_left.set(start);
match *length {

39
src/core/trait_fns.rs Normal file
View File

@@ -0,0 +1,39 @@
use super::*;
use crate::{UiRegion, Vec2, WidgetArrLike, WidgetFn, WidgetLike};
pub trait CoreWidget<Ctx: 'static, Tag> {
fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Regioned, Ctx>;
fn center(self, size: impl Into<Vec2>) -> impl WidgetFn<Regioned, Ctx>;
}
impl<W: WidgetLike<Ctx, Tag>, Ctx: 'static, Tag> CoreWidget<Ctx, Tag> for W {
fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Regioned, Ctx> {
|ui| Regioned {
region: padding.into().region(),
inner: self.add(ui).erase_type(),
}
}
fn center(self, size: impl Into<Vec2>) -> impl WidgetFn<Regioned, Ctx> {
|ui| Regioned {
region: UiRegion::center(size.into()),
inner: self.add(ui).erase_type(),
}
}
}
pub trait CoreWidgetArr<const LEN: usize, Ctx: 'static, Tag> {
fn span(self, dir: Dir, lengths: [impl Into<SpanLen>; LEN]) -> impl WidgetFn<Span, Ctx>;
}
impl<const LEN: usize, Wa: WidgetArrLike<LEN, Ctx, Tag>, Ctx: 'static, Tag> CoreWidgetArr<LEN, Ctx, Tag>
for Wa
{
fn span(self, dir: Dir, lengths: [impl Into<SpanLen>; LEN]) -> impl WidgetFn<Span, Ctx> {
let lengths = lengths.map(Into::into);
move |ui| Span {
dir,
children: self.ui(ui).arr.into_iter().zip(lengths).collect(),
}
}
}

2
src/layout/mod.rs
View File

@@ -6,10 +6,10 @@ mod vec2;
mod widget;
pub use color::*;
pub use painter::*;
pub use region::*;
pub use ui::*;
pub use vec2::*;
pub use widget::*;
pub use painter::*;
pub type UiColor = Color<u8>;

28
src/layout/painter.rs
View File

@@ -1,20 +1,22 @@
use crate::{
UIRegion, WidgetId, Widgets,
UiRegion, WidgetId, Widgets,
primitive::{PrimitiveData, PrimitiveInstance, Primitives},
};
pub struct Painter<'a> {
nodes: &'a Widgets,
pub struct Painter<'a, Ctx> {
nodes: &'a Widgets<Ctx>,
ctx: &'a mut Ctx,
primitives: Primitives,
pub region: UIRegion,
pub region: UiRegion,
}
impl<'a> Painter<'a> {
pub fn new(nodes: &'a Widgets) -> Self {
impl<'a, Ctx> Painter<'a, Ctx> {
pub fn new(nodes: &'a Widgets<Ctx>, ctx: &'a mut Ctx) -> Self {
Self {
nodes,
ctx,
primitives: Primitives::default(),
region: UIRegion::full(),
region: UiRegion::full(),
}
}
pub fn write<Data: PrimitiveData>(&mut self, data: Data) {
@@ -28,10 +30,12 @@ impl<'a> Painter<'a> {
.data
.extend_from_slice(bytemuck::cast_slice::<_, u32>(&[data]));
}
pub fn draw(&mut self, node: &WidgetId) {
self.nodes.get_dyn(node).draw(self);
pub fn draw(&mut self, id: &WidgetId) where Ctx: 'static {
self.nodes.get_dyn(id).draw(self);
}
pub fn draw_within(&mut self, node: &WidgetId, region: UIRegion) {
pub fn draw_within(&mut self, node: &WidgetId, region: UiRegion) where Ctx: 'static {
let old = self.region;
self.region.select(&region);
self.draw(node);
@@ -41,4 +45,8 @@ impl<'a> Painter<'a> {
pub fn finish(self) -> Primitives {
self.primitives
}
pub fn ctx_mut(&mut self) -> &mut Ctx {
&mut self.ctx
}
}

6
src/layout/region.rs
View File

@@ -36,7 +36,7 @@ impl UIPos {
self
}
pub const fn within(&self, region: &UIRegion) -> UIPos {
pub const fn within(&self, region: &UiRegion) -> UIPos {
let anchor = self
.anchor
.lerp(region.top_left.anchor, region.bot_right.anchor);
@@ -110,12 +110,12 @@ impl UIScalar {
#[repr(C)]
#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
pub struct UIRegion {
pub struct UiRegion {
pub top_left: UIPos,
pub bot_right: UIPos,
}
impl UIRegion {
impl UiRegion {
pub const fn full() -> Self {
Self {
top_left: UIPos::top_left(),

99
src/layout/ui.rs
View File

@@ -1,46 +1,60 @@
use crate::{
HashMap, Painter, Widget, WidgetId, WidgetLike,
HashMap, Painter, Vec2, Widget, WidgetId, WidgetLike,
primitive::Primitives,
util::{ID, IDTracker},
util::{IDTracker, Id},
};
use std::{
any::{Any, TypeId},
ops::{Index, IndexMut},
};
#[derive(Default)]
pub struct Ui {
pub struct Ui<Ctx> {
ids: IDTracker,
base: Option<WidgetId>,
widgets: Widgets,
widgets: Widgets<Ctx>,
updates: Vec<WidgetId>,
primitives: Primitives,
full_redraw: bool,
}
#[derive(Default)]
pub struct Widgets(HashMap<ID, Box<dyn Widget>>);
pub struct MouseState {
pos: Vec2,
primary: ButtonState,
secondary: ButtonState,
}
impl Ui {
pub fn add<W: Widget>(&mut self, w: impl WidgetLike<Widget = W>) -> WidgetId<W> {
pub enum ButtonState {
JustPressed,
Pressed,
Released,
}
#[derive(Default)]
pub struct Widgets<Ctx>(HashMap<Id, Box<dyn Widget<Ctx>>>);
impl<Ctx> Ui<Ctx> {
pub fn add<W: Widget<Ctx>, Tag>(
&mut self,
w: impl WidgetLike<Ctx, Tag, Widget = W>,
) -> WidgetId<W> {
w.add(self)
}
pub fn add_widget<W: Widget>(&mut self, w: W) -> WidgetId<W> {
pub fn add_widget<W: Widget<Ctx>>(&mut self, w: W) -> WidgetId<W> {
self.push(w)
}
pub fn push<W: Widget>(&mut self, w: W) -> WidgetId<W> {
pub fn push<W: Widget<Ctx>>(&mut self, w: W) -> WidgetId<W> {
let id = self.ids.next();
self.widgets.insert(id.duplicate(), w);
WidgetId::new(id, TypeId::of::<W>())
}
pub fn set<W: Widget>(&mut self, i: &WidgetId<W>, w: W) {
pub fn set<W: Widget<Ctx>>(&mut self, i: &WidgetId<W>, w: W) {
self.widgets.insert(i.id.duplicate(), w);
}
pub fn set_base(&mut self, w: impl WidgetLike) {
pub fn set_base<Tag>(&mut self, w: impl WidgetLike<Ctx, Tag>) {
self.base = Some(w.add(self).erase_type());
self.full_redraw = true;
}
@@ -49,36 +63,42 @@ impl Ui {
Self::default()
}
pub fn get<W: Widget>(&self, id: &WidgetId<W>) -> Option<&W> {
pub fn get<W: Widget<Ctx>>(&self, id: &WidgetId<W>) -> Option<&W> {
self.widgets.get(id)
}
pub fn get_mut<W: Widget>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
pub fn get_mut<W: Widget<Ctx>>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
self.widgets.get_mut(id)
}
pub fn id<W: Widget>(&mut self) -> WidgetId<W> {
pub fn id<W: Widget<Ctx>>(&mut self) -> WidgetId<W> {
WidgetId::new(self.ids.next(), TypeId::of::<W>())
}
pub fn redraw_all(&mut self) {
let mut painter = Painter::new(&self.widgets);
pub fn redraw_all(&mut self, ctx: &mut Ctx)
where
Ctx: 'static,
{
let mut painter = Painter::new(&self.widgets, ctx);
if let Some(base) = &self.base {
painter.draw(base);
}
self.primitives = painter.finish();
}
pub fn update(&mut self) -> Option<&Primitives> {
pub fn update(&mut self, ctx: &mut Ctx) -> Option<&Primitives>
where
Ctx: 'static,
{
if self.full_redraw {
self.redraw_all();
self.redraw_all(ctx);
self.full_redraw = false;
return Some(&self.primitives);
}
if self.updates.is_empty() {
return None;
}
self.redraw_all();
self.redraw_all(ctx);
self.updates.drain(..);
Some(&self.primitives)
}
@@ -86,9 +106,11 @@ impl Ui {
pub fn needs_redraw(&self) -> bool {
self.full_redraw || !self.updates.is_empty()
}
pub fn set_mouse_pos(&mut self) {}
}
impl<W: Widget> Index<&WidgetId<W>> for Ui {
impl<W: Widget<Ctx>, Ctx> Index<&WidgetId<W>> for Ui<Ctx> {
type Output = W;
fn index(&self, id: &WidgetId<W>) -> &Self::Output {
@@ -96,36 +118,40 @@ impl<W: Widget> Index<&WidgetId<W>> for Ui {
}
}
impl<W: Widget> IndexMut<&WidgetId<W>> for Ui {
impl<W: Widget<Ctx>, Ctx> IndexMut<&WidgetId<W>> for Ui<Ctx> {
fn index_mut(&mut self, id: &WidgetId<W>) -> &mut Self::Output {
self.updates.push(id.clone().erase_type());
self.get_mut(id).unwrap()
}
}
impl Widgets {
pub fn get_dyn(&self, id: &WidgetId) -> &dyn Widget {
impl<Ctx> Widgets<Ctx> {
pub fn new() -> Self {
Self(HashMap::new())
}
pub fn get_dyn(&self, id: &WidgetId) -> &dyn Widget<Ctx> {
self.0.get(&id.id).unwrap().as_ref()
}
pub fn get<W: Widget>(&self, id: &WidgetId<W>) -> Option<&W> {
pub fn get<W: Widget<Ctx>>(&self, id: &WidgetId<W>) -> Option<&W> {
self.0.get(&id.id).unwrap().as_any().downcast_ref()
}
pub fn get_mut<W: Widget>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
pub fn get_mut<W: Widget<Ctx>>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
self.0.get_mut(&id.id).unwrap().as_any_mut().downcast_mut()
}
pub fn insert(&mut self, id: ID, widget: impl Widget) {
pub fn insert(&mut self, id: Id, widget: impl Widget<Ctx>) {
self.0.insert(id, Box::new(widget));
}
pub fn insert_any(&mut self, id: ID, widget: Box<dyn Widget>) {
pub fn insert_any(&mut self, id: Id, widget: Box<dyn Widget<Ctx>>) {
self.0.insert(id, widget);
}
}
impl dyn Widget {
impl<Ctx> dyn Widget<Ctx> {
pub fn as_any(&self) -> &dyn Any {
self
}
@@ -134,3 +160,16 @@ impl dyn Widget {
self
}
}
impl<Ctx> Default for Ui<Ctx> {
fn default() -> Self {
Self {
ids: Default::default(),
base: Default::default(),
widgets: Widgets::new(),
updates: Default::default(),
primitives: Default::default(),
full_redraw: Default::default(),
}
}
}

106
src/layout/widget.rs
View File

@@ -3,10 +3,10 @@ use std::{
marker::PhantomData,
};
use crate::{Painter, Ui, util::ID};
use crate::{Painter, Ui, util::Id};
pub trait Widget: 'static + Any {
fn draw(&self, painter: &mut Painter);
pub trait Widget<Ctx>: Any {
fn draw(&self, painter: &mut Painter<Ctx>);
}
pub struct AnyWidget;
@@ -19,7 +19,7 @@ pub struct AnyWidget;
#[derive(Eq, Hash, PartialEq, Debug)]
pub struct WidgetId<W = AnyWidget> {
pub(super) ty: TypeId,
pub(super) id: ID,
pub(super) id: Id,
_pd: PhantomData<W>,
}
@@ -31,7 +31,7 @@ impl<W> Clone for WidgetId<W> {
}
impl<W> WidgetId<W> {
pub(super) fn new(id: ID, ty: TypeId) -> Self {
pub(super) fn new(id: Id, ty: TypeId) -> Self {
Self {
ty,
id,
@@ -51,85 +51,81 @@ impl<W> WidgetId<W> {
}
}
pub trait WidgetLike {
pub struct WidgetTag;
pub struct FnTag;
pub struct IdTag;
pub trait WidgetLike<Ctx, Tag> {
type Widget;
fn add(self, ui: &mut Ui) -> WidgetId<Self::Widget>;
fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<Self::Widget>;
}
/// A function that returns a widget given a UI.
/// Useful for defining trait functions on widgets that create a parent widget so that the children
/// don't need to be IDs yet
pub trait WFn<W> = FnOnce(&mut Ui) -> W;
pub struct WidgetFn<F: FnOnce(&mut Ui) -> W, W>(pub F);
pub struct WidgetIdFn<F: FnOnce(&mut Ui) -> WidgetId<W>, W>(pub F);
pub trait WidgetFn<W: Widget<Ctx>, Ctx> = FnOnce(&mut Ui<Ctx>) -> W;
pub trait WidgetIdFn<W: Widget<Ctx>, Ctx> = FnOnce(&mut Ui<Ctx>) -> WidgetId<W>;
macro_rules! WidgetFnRet {
($W:ident) => {
WidgetFn<impl FnOnce(&mut Ui) -> $W, $W>
};
}
pub(crate) use WidgetFnRet;
pub trait Idable {
type Widget: Widget;
fn set(self, ui: &mut Ui, id: &WidgetId<Self::Widget>);
pub trait Idable<Ctx, Tag> {
type Widget: Widget<Ctx>;
fn set(self, ui: &mut Ui<Ctx>, id: &WidgetId<Self::Widget>);
}
pub trait WidgetFns<W> {
fn id(self, id: &WidgetId<W>) -> impl WidgetLike<Widget = W>;
pub trait WidgetFns<W: Widget<Ctx>, Ctx, Tag> {
fn id(self, id: &WidgetId<W>) -> impl WidgetIdFn<W, Ctx>;
}
impl<I: Idable> WidgetFns<I::Widget> for I {
fn id(self, id: &WidgetId<I::Widget>) -> impl WidgetLike<Widget = I::Widget> {
WidgetIdFn(|ui| {
impl<I: Idable<Ctx, Tag>, Ctx, Tag> WidgetFns<I::Widget, Ctx, Tag> for I {
fn id(self, id: &WidgetId<I::Widget>) -> impl WidgetIdFn<I::Widget, Ctx> {
|ui| {
self.set(ui, id);
id.clone()
})
}
}
}
impl<W: Widget> Idable for W {
impl<W: Widget<Ctx>, Ctx> Idable<Ctx, WidgetTag> for W {
type Widget = W;
fn set(self, ui: &mut Ui, id: &WidgetId<Self::Widget>) {
fn set(self, ui: &mut Ui<Ctx>, id: &WidgetId<Self::Widget>) {
ui.set(id, self);
}
}
impl<F: for<'a> FnOnce(&'a mut Ui) -> W, W: Widget> Idable for WidgetFn<F, W> {
impl<F: FnOnce(&mut Ui<Ctx>) -> W, W: Widget<Ctx>, Ctx> Idable<Ctx, FnTag> for F {
type Widget = W;
fn set(self, ui: &mut Ui, id: &WidgetId<Self::Widget>) {
let w = self.0(ui);
fn set(self, ui: &mut Ui<Ctx>, id: &WidgetId<Self::Widget>) {
let w = self(ui);
ui.set(id, w);
}
}
impl<W: Widget, F: FnOnce(&mut Ui) -> W> WidgetLike for WidgetFn<F, W> {
impl<W: Widget<Ctx>, Ctx, F: FnOnce(&mut Ui<Ctx>) -> W> WidgetLike<Ctx, FnTag> for F {
type Widget = W;
fn add(self, ui: &mut Ui) -> WidgetId<W> {
let w = (self.0)(ui);
fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<W> {
let w = self(ui);
ui.add(w)
}
}
impl<W: Widget, F: FnOnce(&mut Ui) -> WidgetId<W>> WidgetLike for WidgetIdFn<F, W> {
impl<W: Widget<Ctx>, F: FnOnce(&mut Ui<Ctx>) -> WidgetId<W>, Ctx> WidgetLike<Ctx, IdTag> for F {
type Widget = W;
fn add(self, ui: &mut Ui) -> WidgetId<W> {
(self.0)(ui)
fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<W> {
self(ui)
}
}
impl<W: Widget> WidgetLike for W {
impl<W: Widget<Ctx>, Ctx> WidgetLike<Ctx, WidgetTag> for W {
type Widget = W;
fn add(self, ui: &mut Ui) -> WidgetId<W> {
fn add(self, ui: &mut Ui<Ctx>) -> WidgetId<W> {
ui.add_widget(self)
}
}
impl<W> WidgetLike for WidgetId<W> {
impl<W: Widget<Ctx>, Ctx> WidgetLike<Ctx, FnTag> for WidgetId<W> {
type Widget = W;
fn add(self, _: &mut Ui) -> WidgetId<W> {
fn add(self, _: &mut Ui<Ctx>) -> WidgetId<W> {
self
}
}
@@ -148,35 +144,39 @@ impl<const LEN: usize, Ws> WidgetArr<LEN, Ws> {
}
}
pub trait WidgetArrLike<const LEN: usize> {
pub struct ArrTag;
pub trait WidgetArrLike<const LEN: usize, Ctx, Tags> {
type Ws;
fn ui(self, ui: &mut Ui) -> WidgetArr<LEN, Self::Ws>;
fn ui(self, ui: &mut Ui<Ctx>) -> WidgetArr<LEN, Self::Ws>;
}
impl<const LEN: usize, Ws> WidgetArrLike<LEN> for WidgetArr<LEN, Ws> {
impl<const LEN: usize, Ws, Ctx> WidgetArrLike<LEN, Ctx, ArrTag> for WidgetArr<LEN, Ws> {
type Ws = Ws;
fn ui(self, _: &mut Ui) -> WidgetArr<LEN, Ws> {
fn ui(self, _: &mut Ui<Ctx>) -> WidgetArr<LEN, Ws> {
self
}
}
impl<W: WidgetLike> WidgetArrLike<1> for W {
impl<W: WidgetLike<Ctx, WidgetTag>, Ctx> WidgetArrLike<1, Ctx, WidgetTag> for W {
type Ws = (W::Widget,);
fn ui(self, ui: &mut Ui) -> WidgetArr<1, (W::Widget,)> {
fn ui(self, ui: &mut Ui<Ctx>) -> WidgetArr<1, (W::Widget,)> {
WidgetArr::new([self.add(ui).erase_type()])
}
}
// I hate this language it's so bad why do I even use it
macro_rules! impl_widget_arr {
($n:expr;$($T:tt)*) => {
impl<$($T: WidgetLike,)*> WidgetArrLike<$n> for ($($T,)*) {
type Ws = ($($T::Widget,)*);
fn ui(self, ui: &mut Ui) -> WidgetArr<$n, ($($T::Widget,)*)> {
($n:expr;$($W:ident)*) => {
impl_widget_arr!($n;$($W)*;$(${concat($W,Tag)})*);
};
($n:expr;$($W:ident)*;$($Tag:ident)*) => {
impl<$($W: WidgetLike<Ctx, $Tag>,$Tag,)* Ctx> WidgetArrLike<$n, Ctx, ($($Tag,)*)> for ($($W,)*) {
type Ws = ($($W::Widget,)*);
fn ui(self, ui: &mut Ui<Ctx>) -> WidgetArr<$n, ($($W::Widget,)*)> {
#[allow(non_snake_case)]
let ($($T,)*) = self;
let ($($W,)*) = self;
WidgetArr::new(
[$($T.add(ui).cast_type(),)*],
[$($W.add(ui).cast_type(),)*],
)
}
}

6
src/lib.rs
View File

@@ -3,14 +3,16 @@
#![feature(const_trait_impl)]
#![feature(const_from)]
#![feature(trait_alias)]
#![feature(negative_impls)]
mod layout;
mod render;
mod util;
mod base;
mod core;
pub use layout::*;
pub use render::*;
pub use base::*;
pub use core::*;
pub type HashMap<K, V> = std::collections::HashMap<K, V>;
pub type HashSet<K> = std::collections::HashSet<K>;

4
src/render/data.rs
View File

@@ -1,6 +1,6 @@
use wgpu::VertexAttribute;
use crate::UIRegion;
use crate::UiRegion;
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable, Default)]
@@ -12,7 +12,7 @@ pub struct WindowUniform {
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
pub struct PrimitiveInstance {
pub region: UIRegion,
pub region: UiRegion,
pub ptr: u32,
}

14
src/render/mod.rs
View File

@@ -1,4 +1,7 @@
use crate::{Ui, primitive::PrimitiveInstance, render::util::ArrBuf};
use crate::{
primitive::{PrimitiveInstance, Primitives},
render::util::ArrBuf,
};
use data::WindowUniform;
use wgpu::{
util::{BufferInitDescriptor, DeviceExt},
@@ -32,8 +35,13 @@ impl UIRenderNode {
}
}
pub fn update(&mut self, device: &Device, queue: &Queue, ui: &mut Ui) {
if let Some(primitives) = ui.update() {
pub fn update(
&mut self,
device: &Device,
queue: &Queue,
primitives: Option<&Primitives>,
) {
if let Some(primitives) = primitives {
self.instance.update(device, queue, &primitives.instances);
self.data.update(device, queue, &primitives.data);
self.bind_group = Self::bind_group(

12
src/testing/mod.rs
View File

@@ -12,9 +12,13 @@ pub fn main() {
App::run();
}
struct Data {
x: u32,
}
pub struct Client {
renderer: Renderer,
ui: Ui,
ui: Ui<Data>,
test: WidgetId<Span>,
}
@@ -32,7 +36,8 @@ impl Client {
ui.set_base(
(
(
rect.color(UiColor::BLUE),
rect.color(UiColor::BLUE)
.sense(|d: &mut Data| println!("{}", d.x)),
(
rect.color(UiColor::RED).center((100.0, 100.0)),
(
@@ -77,7 +82,8 @@ impl Client {
match event {
WindowEvent::CloseRequested => event_loop.exit(),
WindowEvent::RedrawRequested => {
self.renderer.update(&mut self.ui);
let primitives = self.ui.update(&mut Data { x: 39 });
self.renderer.update(primitives);
self.renderer.draw()
}
WindowEvent::Resized(size) => self.renderer.resize(&size),

6
src/testing/render/mod.rs
View File

@@ -1,4 +1,4 @@
use gui::{UIRenderNode, Ui};
use gui::{primitive::Primitives, UIRenderNode, Ui};
use pollster::FutureExt;
use std::sync::Arc;
use wgpu::util::StagingBelt;
@@ -18,8 +18,8 @@ pub struct Renderer {
}
impl Renderer {
pub fn update(&mut self, ui: &mut Ui) {
self.ui_node.update(&self.device, &self.queue, ui);
pub fn update(&mut self, primitives: Option<&Primitives>) {
self.ui_node.update(&self.device, &self.queue, primitives);
}
pub fn draw(&mut self) {

12
src/util/id.rs
View File

@@ -4,11 +4,11 @@
/// point to something valid, although duplicate
/// gets around this if needed
#[derive(Eq, Hash, PartialEq, Debug)]
pub struct ID(u64);
pub struct Id(u64);
#[derive(Default)]
pub struct IDTracker {
free: Vec<ID>,
free: Vec<Id>,
cur: u64,
}
@@ -18,22 +18,22 @@ impl IDTracker {
}
#[allow(clippy::should_implement_trait)]
pub fn next(&mut self) -> ID {
pub fn next(&mut self) -> Id {
if let Some(id) = self.free.pop() {
return id;
}
let id = ID(self.cur);
let id = Id(self.cur);
self.cur += 1;
id
}
#[allow(dead_code)]
pub fn free(&mut self, id: ID) {
pub fn free(&mut self, id: Id) {
self.free.push(id);
}
}
impl ID {
impl Id {
/// this must be used carefully to make sure
/// all IDs are still valid references;
/// named weirdly to indicate this.