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

finished moving out render_state

Browse Source
This commit is contained in:
Shadow Cat
2026-01-19 18:00:24 -05:00
parent 79813db3ba
commit 06dd015092
26 changed files with 497 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/default/attr.rs
View File

@@ -12,12 +12,20 @@ where
fn run(rsc: &mut Rsc, container: WeakWidget<W>, id: Self::Input) {
rsc.register_event(container, CursorSense::click_or_drag(), move |ctx, rsc| {
let region = rsc.ui().window_region(&id).unwrap();
let region = ctx.data.render.window_region(&id).unwrap();
let id_pos = region.top_left;
let container_pos = rsc.ui().window_region(&container).unwrap().top_left;
let container_pos = ctx.data.render.window_region(&container).unwrap().top_left;
let pos = ctx.data.pos + container_pos - id_pos;
let size = region.size();
select(rsc, ctx.state, id, pos, size, ctx.data.sense.is_dragging());
select(
rsc,
ctx.data.render,
ctx.state,
id,
pos,
size,
ctx.data.sense.is_dragging(),
);
});
}
}
@@ -34,6 +42,7 @@ where
rsc.register_event(id, CursorSense::click_or_drag(), move |ctx, rsc| {
select(
rsc,
ctx.data.render,
ctx.state,
id,
ctx.data.pos,
@@ -45,7 +54,8 @@ where
}
fn select(
rsc: &mut impl HasUi,
rsc: &mut impl UiRsc,
render: &UiRenderState,
state: &mut impl HasDefaultUiState,
id: WeakWidget<TextEdit>,
pos: Vec2,
@@ -57,7 +67,7 @@ fn select(
let recent = (now - state.last_click) < Duration::from_millis(300);
state.last_click = now;
id.edit(rsc).select(pos, size, dragging, recent);
if let Some(region) = rsc.ui().window_region(&id) {
if let Some(region) = render.window_region(&id) {
state.window.set_ime_allowed(true);
state.window.set_ime_cursor_area(
LogicalPosition::<f32>::from(region.top_left.tuple()),

94
src/default/mod.rs
View File

@@ -30,6 +30,7 @@ pub use task::*;
pub type Proxy<Event> = EventLoopProxy<Event>;
pub struct DefaultUiState {
pub root: Option<StrongWidget>,
pub renderer: UiRenderer,
pub input: Input,
pub focus: Option<WeakWidget<TextEdit>>,
@@ -39,10 +40,17 @@ pub struct DefaultUiState {
pub last_click: Instant,
}
impl HasRoot for DefaultUiState {
fn set_root(&mut self, root: StrongWidget) {
self.root = Some(root);
}
}
impl DefaultUiState {
pub fn new(window: impl Into<Arc<Window>>) -> Self {
let window = window.into();
Self {
root: None,
renderer: UiRenderer::new(window.clone()),
window,
input: Input::default(),
@@ -64,18 +72,30 @@ pub trait DefaultAppState: HasDefaultUiState {
fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self::Event>)
-> Self;
#[allow(unused_variables)]
fn event(&mut self, event: Self::Event, rsc: &mut DefaultRsc<Self>) {}
fn event(
&mut self,
event: Self::Event,
rsc: &mut DefaultRsc<Self>,
render: &mut UiRenderState,
) {
}
#[allow(unused_variables)]
fn exit(&mut self, rsc: &mut DefaultRsc<Self>) {}
fn exit(&mut self, rsc: &mut DefaultRsc<Self>, render: &mut UiRenderState) {}
#[allow(unused_variables)]
fn window_event(&mut self, event: WindowEvent, rsc: &mut DefaultRsc<Self>) {}
fn window_event(
&mut self,
event: WindowEvent,
rsc: &mut DefaultRsc<Self>,
render: &mut UiRenderState,
) {
}
fn window_attributes() -> WindowAttributes {
Default::default()
}
}
pub struct DefaultRsc<State: 'static> {
pub ui: Ui,
pub ui: UiData,
pub events: EventManager<Self>,
pub tasks: Tasks<Self>,
_state: PhantomData<State>,
@@ -96,14 +116,26 @@ impl<State> DefaultRsc<State> {
}
}
impl<State> HasUi for DefaultRsc<State> {
fn ui(&self) -> &Ui {
impl<State> UiRsc for DefaultRsc<State> {
fn ui(&self) -> &UiData {
&self.ui
}
fn ui_mut(&mut self) -> &mut Ui {
fn ui_mut(&mut self) -> &mut UiData {
&mut self.ui
}
fn on_draw(&mut self, active: &ActiveData) {
self.events.draw(active);
}
fn on_undraw(&mut self, active: &ActiveData) {
self.events.undraw(active);
}
fn on_remove(&mut self, id: WidgetId) {
self.events.remove(id);
}
}
impl<State: 'static> HasState for DefaultRsc<State> {
@@ -128,6 +160,7 @@ impl<State: 'static> HasTasks for DefaultRsc<State> {
pub struct DefaultApp<State: DefaultAppState> {
rsc: DefaultRsc<State>,
render: UiRenderState,
state: State,
task_recv: TaskMsgReceiver<DefaultRsc<State>>,
}
@@ -142,23 +175,32 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
let default_state = DefaultUiState::new(window);
let (mut rsc, task_recv) = DefaultRsc::init(default_state.window.clone());
let state = State::new(default_state, &mut rsc, proxy);
let render = UiRenderState::new();
Self {
rsc,
state,
render,
task_recv,
}
}
fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
self.state.event(event, &mut self.rsc);
self.state.event(event, &mut self.rsc, &mut self.render);
}
fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
for update in self.task_recv.try_iter() {
update(&mut self.state, &mut self.rsc);
let Self {
rsc,
render,
state,
task_recv,
} = self;
for update in task_recv.try_iter() {
update(state, rsc);
}
let ui_state = self.state.default_state_mut();
let ui_state = state.default_state_mut();
let input_changed = ui_state.input.event(&event);
let cursor_state = ui_state.cursor_state().clone();
let old = ui_state.focus;
@@ -167,45 +209,43 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
}
if input_changed {
let window_size = ui_state.window_size();
self.rsc
.run_sensors(&mut self.state, cursor_state, window_size);
render.run_sensors(rsc, state, cursor_state, window_size);
}
let ui = &mut self.rsc.ui;
let ui_state = self.state.default_state_mut();
let ui_state = state.default_state_mut();
if old != ui_state.focus
&& let Some(old) = old
{
old.edit(ui).deselect();
old.edit(rsc).deselect();
}
match &event {
WindowEvent::CloseRequested => event_loop.exit(),
WindowEvent::RedrawRequested => {
ui.update(&mut self.rsc.events);
ui_state.renderer.update(ui);
render.update(&ui_state.root, rsc);
ui_state.renderer.update(&mut rsc.ui, render);
ui_state.renderer.draw();
}
WindowEvent::Resized(size) => {
ui.resize((size.width, size.height));
render.resize((size.width, size.height));
ui_state.renderer.resize(size)
}
WindowEvent::KeyboardInput { event, .. } => {
if let Some(sel) = ui_state.focus
&& event.state.is_pressed()
{
let mut text = sel.edit(ui);
let mut text = sel.edit(rsc);
match text.apply_event(event, &ui_state.input.modifiers) {
TextInputResult::Unfocus => {
ui_state.focus = None;
ui_state.window.set_ime_allowed(false);
}
TextInputResult::Submit => {
self.rsc.run_event::<Submit>(sel, (), &mut self.state);
rsc.run_event::<Submit>(sel, (), state);
}
TextInputResult::Paste => {
if let Ok(t) = ui_state.clipboard.get_text() {
text.insert(&t);
}
self.rsc.run_event::<Edited>(sel, (), &mut self.state);
rsc.run_event::<Edited>(sel, (), state);
}
TextInputResult::Copy(text) => {
if let Err(err) = ui_state.clipboard.set_text(text) {
@@ -213,7 +253,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
}
}
TextInputResult::Used => {
self.rsc.run_event::<Edited>(sel, (), &mut self.state);
rsc.run_event::<Edited>(sel, (), state);
}
TextInputResult::Unused => {}
}
@@ -221,7 +261,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
}
WindowEvent::Ime(ime) => {
if let Some(sel) = ui_state.focus {
let mut text = sel.edit(ui);
let mut text = sel.edit(rsc);
match ime {
Ime::Enabled | Ime::Disabled => (),
Ime::Preedit(content, _pos) => {
@@ -237,15 +277,15 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
}
_ => (),
}
self.state.window_event(event, &mut self.rsc);
state.window_event(event, rsc, render);
let ui_state = self.state.default_state_mut();
if self.rsc.ui.needs_redraw() {
if render.needs_redraw(&ui_state.root, rsc.widgets()) {
ui_state.renderer.window().request_redraw();
}
ui_state.input.end_frame();
}
fn exit(&mut self) {
self.state.exit(&mut self.rsc);
self.state.exit(&mut self.rsc, &mut self.render);
}
}

6
src/default/render.rs
View File

@@ -1,4 +1,4 @@
use iris_core::{Ui, UiLimits, UiRenderNode};
use iris_core::{UiData, UiLimits, UiRenderNode, UiRenderState};
use pollster::FutureExt;
use std::sync::Arc;
use wgpu::*;
@@ -17,8 +17,8 @@ pub struct UiRenderer {
}
impl UiRenderer {
pub fn update(&mut self, ui: &mut Ui) {
self.ui.update(&self.device, &self.queue, ui);
pub fn update(&mut self, ui: &mut UiData, render: &mut UiRenderState) {
self.ui.update(&self.device, &self.queue, ui, render);
}
pub fn draw(&mut self) {

44
src/default/sense.rs
View File

@@ -26,9 +26,9 @@ pub enum CursorSense {
pub struct CursorSenses(Vec<CursorSense>);
impl Event for CursorSenses {
type Data = CursorData;
type Data<'a> = CursorData<'a>;
type State = SensorState;
fn should_run(&self, data: &Self::Data) -> Option<Self::Data> {
fn should_run<'a>(&self, data: &Self::Data<'a>) -> Option<Self::Data<'a>> {
if let Some(sense) = should_run(self, &data.cursor, data.hover) {
let mut data = data.clone();
data.sense = sense;
@@ -129,7 +129,7 @@ pub struct SensorState {
}
#[derive(Clone)]
pub struct CursorData {
pub struct CursorData<'a> {
/// where this widget was hit
pub pos: Vec2,
pub size: Vec2,
@@ -138,20 +138,36 @@ pub struct CursorData {
pub cursor: CursorState,
/// the first sense that triggered this
pub sense: CursorSense,
pub render: &'a UiRenderState,
}
pub trait SensorUi<Rsc: HasEvents> {
fn run_sensors(&mut self, state: &mut Rsc::State, cursor: CursorState, window_size: Vec2);
pub trait SensorUi {
fn run_sensors<Rsc: HasEvents>(
&self,
rsc: &mut Rsc,
state: &mut Rsc::State,
cursor: CursorState,
window_size: Vec2,
);
}
impl<Rsc: HasEvents> SensorUi<Rsc> for Rsc {
fn run_sensors(&mut self, state: &mut Rsc::State, cursor: CursorState, window_size: Vec2) {
let layers = std::mem::take(&mut self.ui_mut().layers);
let mut active = std::mem::take(&mut self.events_mut().get_type::<CursorSense>().active);
for layer in layers.indices().rev() {
impl SensorUi for UiRenderState {
fn run_sensors<Rsc: HasEvents>(
&self,
rsc: &mut Rsc,
state: &mut Rsc::State,
cursor: CursorState,
window_size: Vec2,
) {
// in order to remove this take, need to store active list in UiRenderState somehow
// this would probably be done through a generic parameter that adds yet another rsc /
// state like thing, but local to render state, and is passed to UiRsc events so you can
// update it there?
let mut active = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().active);
for layer in self.layers.indices().rev() {
let mut sensed = false;
for (id, sensor) in active.get_mut(&layer).into_flat_iter() {
let shape = self.ui().active.get(id).unwrap().region;
let shape = self.active.get(id).unwrap().region;
let region = shape.to_px(window_size);
let in_shape = cursor.exists && region.contains(cursor.pos);
sensor.hover.update(in_shape);
@@ -171,15 +187,15 @@ impl<Rsc: HasEvents> SensorUi<Rsc> for Rsc {
// this does not have any meaning;
// might wanna set up Event to have a prepare stage
sense: CursorSense::Hovering,
render: self,
};
self.run_event::<CursorSense>(*id, data, state);
rsc.run_event::<CursorSense>(*id, data, state);
}
if sensed {
break;
}
}
self.events_mut().get_type::<CursorSense>().active = active;
self.ui_mut().layers = layers;
rsc.events_mut().get_type::<CursorSense>().active = active;
}
}

37
src/event.rs
View File

@@ -2,13 +2,13 @@ use iris_core::*;
use iris_macro::*;
use std::sync::Arc;
use crate::default::{TaskCtx, Tasks};
use crate::default::{TaskCtx, TaskUpdate, Tasks};
pub trait Eventable<Rsc: HasEvents, Tag>: WidgetLike<Rsc, Tag> {
fn on<E: EventLike>(
self,
event: E,
f: impl WidgetEventFn<Rsc, <E::Event as Event>::Data, Self::Widget>,
f: impl for<'a> WidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, Self::Widget>,
) -> impl WidgetIdFn<Rsc, Self::Widget> {
move |rsc| {
let id = self.add(rsc);
@@ -30,24 +30,22 @@ impl<WL: WidgetLike<Rsc, Tag>, Rsc: HasEvents, Tag> Eventable<Rsc, Tag> for WL {
widget_trait! {
pub trait TaskEventable<Rsc: HasEvents + HasTasks>;
fn task_on<E: EventLike, F: AsyncWidgetEventFn<Rsc, <E::Event as Event>::Data, WL::Widget>>(
fn task_on<'a, E: EventLike, F: AsyncWidgetEventFn<Rsc, WL::Widget>>(
self,
event: E,
f: F,
) -> impl WidgetIdFn<Rsc, WL::Widget>
where <E::Event as Event>::Data: Send,
for<'a> F::CallRefFuture<'a>: Send,
where <E::Event as Event>::Data<'a>: Send,
for<'b> F::CallRefFuture<'b>: Send,
{
let f = Arc::new(f);
move |rsc| {
let id = self.add(rsc);
rsc.register_event(id, event.into_event(), move |ctx, rsc| {
let data = ctx.data;
rsc.register_event(id, event.into_event(), move |_, rsc| {
let f = f.clone();
rsc.tasks_mut().spawn(async move |task| {
f(AsyncEventIdCtx {
widget: id,
data,
task,
}).await;
});
@@ -61,21 +59,22 @@ pub trait HasTasks: Sized + HasState + HasEvents {
fn tasks_mut(&mut self) -> &mut Tasks<Self>;
}
pub trait AsyncWidgetEventFn<Rsc: HasEvents, Data, W: ?Sized>:
AsyncFn(AsyncEventIdCtx<Rsc, Data, W>) + Send + Sync + 'static
pub trait AsyncWidgetEventFn<Rsc: HasEvents, W: ?Sized>:
AsyncFn(AsyncEventIdCtx<Rsc, W>) + Send + Sync + 'static
{
}
impl<
Rsc: HasEvents,
F: AsyncFn(AsyncEventIdCtx<Rsc, Data, W>) + Send + Sync + 'static,
Data,
W: ?Sized,
> AsyncWidgetEventFn<Rsc, Data, W> for F
impl<Rsc: HasEvents, F: AsyncFn(AsyncEventIdCtx<Rsc, W>) + Send + Sync + 'static, W: ?Sized>
AsyncWidgetEventFn<Rsc, W> for F
{
}
pub struct AsyncEventIdCtx<Rsc: HasEvents, Data, W: ?Sized> {
pub struct AsyncEventIdCtx<Rsc: HasEvents, W: ?Sized> {
pub widget: WeakWidget<W>,
pub data: Data,
pub task: TaskCtx<Rsc>,
task: TaskCtx<Rsc>,
}
impl<Rsc: HasEvents, W: ?Sized> AsyncEventIdCtx<Rsc, W> {
pub fn update(&mut self, f: impl TaskUpdate<Rsc> + 'static) {
self.task.update(f);
}
}

4
src/widget/image.rs
View File

@@ -19,10 +19,10 @@ impl Widget for Image {
}
}
pub fn image<State: HasUi>(image: impl LoadableImage) -> impl WidgetFn<State, Image> {
pub fn image<State: UiRsc>(image: impl LoadableImage) -> impl WidgetFn<State, Image> {
let image = image.get_image().expect("Failed to load image");
move |state| Image {
handle: state.ui_mut().add_texture(image),
handle: state.ui_mut().textures.add(image),
}
}

6
src/widget/text/build.rs
View File

@@ -51,7 +51,7 @@ impl<State, O, H: WidgetOption<State>> TextBuilder<State, O, H> {
}
}
impl<Rsc: HasUi, O> TextBuilder<Rsc, O> {
impl<Rsc: UiRsc, O> TextBuilder<Rsc, O> {
pub fn hint<W: WidgetLike<Rsc, Tag>, Tag>(
self,
hint: W,
@@ -75,7 +75,7 @@ pub trait TextBuilderOutput<State>: Sized {
}
pub struct TextOutput;
impl<Rsc: HasUi> TextBuilderOutput<Rsc> for TextOutput {
impl<Rsc: UiRsc> TextBuilderOutput<Rsc> for TextOutput {
type Output = Text;
fn run<H: WidgetOption<Rsc>>(
@@ -103,7 +103,7 @@ pub struct TextEditOutput {
mode: EditMode,
}
impl<State: HasUi> TextBuilderOutput<State> for TextEditOutput {
impl<State: UiRsc> TextBuilderOutput<State> for TextEditOutput {
type Output = TextEdit;
fn run<H: WidgetOption<State>>(

4
src/widget/text/edit.rs
View File

@@ -617,11 +617,11 @@ impl DerefMut for TextEdit {
}
pub trait TextEditable {
fn edit<'a>(&self, ui: &'a mut impl HasUi) -> TextEditCtx<'a>;
fn edit<'a>(&self, ui: &'a mut impl UiRsc) -> TextEditCtx<'a>;
}
impl<I: IdLike<Widget = TextEdit>> TextEditable for I {
fn edit<'a>(&self, ui: &'a mut impl HasUi) -> TextEditCtx<'a> {
fn edit<'a>(&self, ui: &'a mut impl UiRsc) -> TextEditCtx<'a> {
let ui = ui.ui_mut();
TextEditCtx {
text: ui.widgets.get_mut(self).unwrap(),

6
src/widget/trait_fns.rs
View File

@@ -3,7 +3,7 @@ use crate::prelude::*;
// these methods should "not require any context" (require unit) because they're in core
widget_trait! {
pub trait CoreWidget<Rsc: HasUi + 'static>;
pub trait CoreWidget<Rsc: UiRsc + 'static>;
fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Rsc, Pad> {
|state| Pad {
@@ -26,7 +26,7 @@ widget_trait! {
fn label(self, label: impl Into<String>) -> impl WidgetIdFn<Rsc, WL::Widget> {
|state| {
let id = self.add(state);
state.ui_mut().set_label(id, label.into());
state.ui_mut().widgets.set_label(id, label.into());
id
}
}
@@ -127,7 +127,7 @@ widget_trait! {
fn set_ptr(self, ptr: WeakWidget<WidgetPtr>, state: &mut Rsc) {
let id = self.add_strong(state);
state.ui_mut()[ptr].inner = Some(id);
state.ui_mut().widgets[ptr].inner = Some(id);
}
}