Merge pull request #51 from xi-editor/anim_frame

Add basic support for animations

Author: raphlinus

xi-win-ui/examples/anim.rs

@@ -0,0 +1,89 @@
+// Copyright 2018 The xi-editor Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Example of animation frames.
+
+extern crate xi_win_shell;
+extern crate xi_win_ui;
+extern crate direct2d;
+extern crate directwrite;
+
+use direct2d::brush::SolidColorBrush;
+use direct2d::RenderTarget;
+
+use xi_win_shell::win_main;
+use xi_win_shell::window::WindowBuilder;
+
+use xi_win_ui::{UiMain, UiState, UiInner};
+
+use xi_win_ui::{BoxConstraints, Geometry, LayoutResult};
+use xi_win_ui::{HandlerCtx, Id, LayoutCtx, MouseEvent, PaintCtx};
+use xi_win_ui::widget::Widget;
+
+/// A custom widget with animations.
+struct AnimWidget(f32);
+
+impl Widget for AnimWidget {
+    fn paint(&mut self, paint_ctx: &mut PaintCtx, geom: &Geometry) {
+        let rt = paint_ctx.render_target();
+        let fg = SolidColorBrush::create(rt).with_color(0xf0f0ea).build().unwrap();
+        let (x, y) = geom.pos;
+        rt.draw_line((x, y), (x + geom.size.0, y + self.0 * geom.size.1),
+                &fg, 1.0, None);
+    }
+
+    fn layout(&mut self, bc: &BoxConstraints, _children: &[Id], _size: Option<(f32, f32)>,
+        _ctx: &mut LayoutCtx) -> LayoutResult
+    {
+        LayoutResult::Size(bc.constrain((100.0, 100.0)))
+    }
+
+    fn anim_frame(&mut self, interval: u64, ctx: &mut HandlerCtx) {
+        println!("anim frame, interval={}", interval);
+        if self.0 > 0.0 {
+            ctx.request_anim_frame();
+            self.0 = (self.0 - 1e-9 * (interval as f32)).max(0.0);
+        }
+        ctx.invalidate();
+    }
+
+    fn mouse(&mut self, event: &MouseEvent, ctx: &mut HandlerCtx) -> bool {
+        if event.count > 0 {
+            self.0 = 1.0;
+            ctx.request_anim_frame();
+        }
+        true
+    }
+}
+
+impl AnimWidget {
+    fn ui(self, ctx: &mut UiInner) -> Id {
+        ctx.add(self, &[])
+    }
+}
+
+fn main() {
+    xi_win_shell::init();
+
+    let mut run_loop = win_main::RunLoop::new();
+    let mut builder = WindowBuilder::new();
+    let mut state = UiState::new();
+    let anim = AnimWidget(1.0).ui(&mut state);
+    state.set_root(anim);
+    builder.set_handler(Box::new(UiMain::new(state)));
+    builder.set_title("Animation example");
+    let window = builder.build().unwrap();
+    window.show();
+    run_loop.run();
+}

xi-win-ui/src/lib.rs

@@ -25,6 +25,7 @@ use std::char;
 use std::collections::BTreeMap;
 use std::mem;
 use std::ops::{Deref, DerefMut};
+use std::time::Instant;
 
 use direct2d::math::*;
 use direct2d::RenderTarget;
@@ -81,6 +82,18 @@ pub struct LayoutCtx {
     /// Bounding box of each widget. The position is relative to the parent.
     geom: Vec<Geometry>,
 
+    /// Additional state per widget.
+    ///
+    /// A case can be made to fold `geom` here instead of having a separate array;
+    /// this is the general SOA vs AOS discussion.
+    per_widget: Vec<PerWidgetState>,
+
+    /// State of animation request.
+    anim_state: AnimState,
+
+    /// The time of the last paint cycle.
+    prev_paint_time: Option<Instant>,
+
     /// Queue of events to distribute to listeners
     event_q: Vec<(Id, Box<Any>)>,
 
@@ -108,6 +121,18 @@ pub struct Geometry {
     pub size: (f32, f32),
 }
 
+#[derive(Default)]
+struct PerWidgetState {
+    anim_frame_requested: bool,
+}
+
+enum AnimState {
+    Idle,
+    InvalidationRequested,
+    AnimFrameStart,
+    AnimFrameRequested,
+}
+
 #[derive(Clone, Copy)]
 pub struct BoxConstraints {
     min_width: f32,
@@ -188,6 +213,9 @@ impl UiState {
                 c: LayoutCtx {
                     dwrite_factory: directwrite::Factory::new().unwrap(),
                     geom: Vec::new(),
+                    per_widget: Vec::new(),
+                    anim_state: AnimState::Idle,
+                    prev_paint_time: None,
                     handle: Default::default(),
                     event_q: Vec::new(),
                     focused: None,
@@ -385,6 +413,35 @@ impl UiState {
         }
     }
 
+    // Process an animation frame. This consists mostly of calling anim_frame on
+    // widgets that have requested a frame.
+    fn anim_frame(&mut self) {
+        // TODO: this is just wall-clock time, which will have jitter making
+        // animations not as smooth. Should be extracting actual refresh rate
+        // from presentation statistics and then doing some processing.
+        let this_paint_time = Instant::now();
+        let interval = if let Some(last) = self.c.prev_paint_time {
+            let duration = this_paint_time.duration_since(last);
+            1_000_000_000 * duration.as_secs() + (duration.subsec_nanos() as u64)
+        } else {
+            0
+        };
+        self.c.anim_state = AnimState::AnimFrameStart;
+        for node in 0..self.widgets.len() {
+            if self.c.per_widget[node].anim_frame_requested {
+                self.c.per_widget[node].anim_frame_requested = false;
+                self.inner.widgets[node].anim_frame(interval,
+                    &mut HandlerCtx {
+                        id: node,
+                        c: &mut self.inner.c,
+                    }
+                );
+            }
+        }
+        self.c.prev_paint_time = Some(this_paint_time);
+        self.dispatch_events();
+    }
+
     /// Translate coordinates to local coordinates of widget
     fn xy_to_local(&mut self, mut node: Id, mut x: f32, mut y: f32) -> (f32, f32) {
         loop {
@@ -444,6 +501,7 @@ impl UiInner {
         let id = self.graph.alloc_node();
         self.widgets.push(Box::new(widget));
         self.c.geom.push(Default::default());
+        self.c.per_widget.push(Default::default());
         for &child in children {
             self.graph.append_child(id, child);
         }
@@ -545,8 +603,14 @@ impl LayoutCtx {
 impl<'a> HandlerCtx<'a> {
     /// Invalidate this widget. Finer-grained invalidation is not yet implemented,
     /// but when it is, this method will invalidate the widget's bounding box.
-    pub fn invalidate(&self) {
-        self.c.handle.invalidate();
+    pub fn invalidate(&mut self) {
+        match self.c.anim_state {
+            AnimState::Idle => {
+                self.c.handle.invalidate();
+                self.c.anim_state = AnimState::InvalidationRequested;
+            }
+            _ => (),
+        }
     }
 
     /// Send an event, to be handled by listeners.
@@ -570,6 +634,23 @@ impl<'a> HandlerCtx<'a> {
     pub fn is_hot(&self) -> bool {
         self.c.hot == Some(self.id) && (self.is_active() || self.c.active.is_none())
     }
+
+    /// Request an animation frame.
+    ///
+    /// Calling this schedules an animation frame, and also causes `anim_frame` to be
+    /// called on this widget at the beginning of that frame.
+    pub fn request_anim_frame(&mut self) {
+        self.c.per_widget[self.id].anim_frame_requested = true;
+        match self.c.anim_state {
+            AnimState::Idle => {
+                self.invalidate();
+            }
+            AnimState::AnimFrameStart => {
+                self.c.anim_state = AnimState::AnimFrameRequested;
+            }
+            _ => (),
+        }
+    }
 }
 
 impl<'a> Deref for ListenerCtx<'a> {
@@ -640,6 +721,8 @@ impl WinHandler for UiMain {
     }
 
     fn paint(&self, paint_ctx: &mut paint::PaintCtx) -> bool {
+        let mut state = self.state.borrow_mut();
+        state.anim_frame();
         let size;
         {
             let rt = paint_ctx.render_target();
@@ -648,13 +731,19 @@ impl WinHandler for UiMain {
             let bg = SolidColorBrush::create(rt).with_color(0x272822).build().unwrap();
             rt.fill_rectangle(rect, &bg);
         }
-        let mut state = self.state.borrow_mut();
         let root = state.graph.root;
         let bc = BoxConstraints::tight((size.width, size.height));
         // TODO: be lazier about relayout
         state.layout(&bc, root);
         state.paint(paint_ctx, root);
-        false
+        match state.c.anim_state {
+            AnimState::AnimFrameRequested => true,
+            _ => {
+                state.c.anim_state = AnimState::Idle;
+                state.c.prev_paint_time = None;
+                false
+            }
+        }
     }
 
     fn command(&self, id: u32) {

xi-win-ui/src/widget/mod.rs

@@ -98,6 +98,30 @@ pub trait Widget {
     /// Returns true if the event is handled.
     #[allow(unused)]
     fn key(&mut self, event: &KeyEvent, ctx: &mut HandlerCtx) -> bool { false }
+
+    /// Called at the beginning of a new animation frame.
+    ///
+    /// The `interval` argument is the time in nanoseconds between frames, for
+    /// the purpose of computing animations. When framerate is steady, it should
+    /// be exactly the reciprocal of the refresh rate of the monitor. If we are
+    /// skipping frames, its cumulative sum should approximately track the
+    /// passage of wall clock time and otherwise should be chosen to optimize
+    /// for smoothness of animations.
+    ///
+    /// The ideal heuristic for computing this interval is a deep topic, ideally
+    /// the subject of a blog post when I figure it out.
+    ///
+    /// On the first frame when transitioning from idle to animating, `interval`
+    /// will be 0. (This logic is presently per-window but might change to
+    /// per-widget to make it more consistent).
+    ///
+    /// This method should call `invalidate` on the context if the visual display
+    /// updates. In the current implementation, that's not very useful, but it
+    /// will become much more so when there's fine grained invalidation.
+    ///
+    /// The method can also call `request_anim_frame` to keep the animation running.
+    #[allow(unused)]
+    fn anim_frame(&mut self, interval: u64, ctx: &mut HandlerCtx) {}
 }
 
 pub struct MouseEvent {