Improve animations' encoding structure

[AzurIce]

Currently, Ranim decide using Method | remove state out of timeline for now.

---

Currently, Ranim maintains animations with timelines with inner item state tracked by ItemId<T>.

And that makes coding inconvinience:

• If we want to play an anim, we have to determine which timeline to play, and get the timeline.
• If we want to get an items state, we have to store it in previous timeline call, or get the timeline first then get its inner state.
• If we want to insert item (create a new timeline) in the center of whole animation, we'll have to manually sync its time.
• ...

So, in Ranim v0.2, I'll attempt to get rid of ItemId<T>, as well as timelines.

First, rethink about timeline and ItemId<T>:

• For animations visualization of preview app, we want that all animations about the same logical item should lay on a single line, so we have timeline to organize animations, and use id to reference them.
• Since timelines are stored in a vec, they are type erased
• Since item's state is also maintained in timeline for features like forward, show and hide, we need type info for us to "recover" state's type, so the id turns in a form of TypeId<T>
• So, when the element animation's output type is changed, the TypeId<T> has to be changed to TypeId<E>. And for safty, TypeId<T> has to be consumed.

That leads to this kind of code:

let r_item_a = r.insert(/* ... */);

let item_a = r.timeline_mut(&r_item_a)
    .play_with(|x| x.anim_a())
    .forward(1.0)
    .play_with(|x| x.anim_b())
    .snapshot();

// Such a pain
let r_item_a_lower_level = r.map(r_item_a, LowerType::from);
r.timeline_mut(&r_item_a)
    .play_with(|x| x.anim_lower_level());
let r_item_a = r.map(r_item_a, || item_a);


let r_item_b = r.insert(/* ... */);

// Another pain
let t = r.timelines().max_total_secs();
r.timeline_mut(r_item_b).forward_to(t);
// Or
// r.timelines_mut().sync();
r.timeline_mut(&r_item_b)
    .play(/* ... */)
    /* ... */;

The ideal design should introduce minimum indirection to both item data manuplating and animations organizing.

[AzurIce]

Method | Using DAG to describe animations

All animations will be simply flattened into a single vector, and the whole animation will be represented as a DAG of animation nodes.

Why? and how?

We can easily come up with following conclusion:

• Aniamtions are immutable since they are places on the whole "timeline"
  Therefore, if two animations are somehow overlapped on time, they must be on different "timeline"
• We define a consecutive relationship of two animations as they happends consecutive on time, and we make this relationship transitive. Then, if anim A and anim B are thought to describing a same logical item, they must be consecutive

Then actually we can assume that If we want an animation be "append to a timeline", then there must be some information of the successor animation in the scope..

So we can make r.play(xxx) returns a kind of "handle" or "reference" of the animation:

let item = /* ... */; 
let anim = r.play(item.anim());

This anim can contain some related information to the animation:

• the start time of anim
• the end time of anim
• ...

Then related animation can be created with:

let item = /* ... */;

let anim_a = r.play(item.anim());
r.play(item.anim().after(anim_a)); // consecutive to anim_a

r.play(another_item.anim().at(anim_a.end_time)); // An individual animation

Sometimes we may want to make an animation apply its effect on the item, then we can actually make the animation method has a reciever of &mut Self. Since Items are Clone, when we want keep item's state, we can simply clone item then create animation.

Actually, it can be designed into proc-macro gened derived methods:

	anim(self)	anim_ref(&self)	anim_mut(&mut self)
Implementation	manually	proc_macro generated	proc_macro generated
Aniamtion creation	-	self.clone().anim()	self.anim_ref()
Additional effect	-	-	*self = anim.output();

And forward, show and hide actually uses the output of the previous animation.

// Previous
let r_item_a = r.insert(/* ... */);

let item_a = r.timeline_mut(&r_item_a)
    .play_with(|x| x.anim_a())
    .forward(1.0)
    .play_with(|x| x.anim_b())
    .snapshot();

// Such a pain
let r_item_a_lower_level = r.map(r_item_a, LowerType::from);
r.timeline_mut(&r_item_a)
    .play_with(|x| x.anim_lower_level());
let r_item_a = r.map(r_item_a, || item_a);

// New rethinked animation encoding api
let mut item_a = /* ... */;
let anim_a = r.play(item.anim_a_mut());
let anim_static = r.play(item.static_ref().after(anim_a)); // Play after an anim ("append after timeline")
let anim_b = r.play(item.anim_b_mut().after(anim_static); // Play at specific time, no more sync needed
r.play(LowerType::from(item.clone()).anim_lower_level().after(anim_b);

// Can be collapsed into
let mut item_a = /* ... */;
let anims = r.play([
    item.anim_a_mut(),
    item.static_ref(),
    item.anim_b_mut(),
]);

let mut lower_level_item_a = LowerType::from(item_a);
r.play(lower_level_item_a.anim_lower_level_mut());

[AzurIce]

Method | remove state out of timeline

Timeline has its pros, and can be hardly thrown away. But we can still do some improvement by removing the internal item state of timeline.

The item type signature on ItemId and the complicated map operations exist because timeline has a inner state:

let r_item_a: ItemId<Item> = r.insert(item_a);

let item_a = r.timeline_mut(&r_item_a)
    .play_with(|x| x.anim_a())
    .forward(1.0)
    .play_with(|x| x.anim_b())
    .snapshot();

// Such a pain
let r_item_a_lower_level: ItemId<LowerItem> = r.map(r_item_a, LowerType::from);
r.timeline_mut(&r_item_a)
    .play_with(|x| x.anim_lower_level());
let r_item_a = r.map(r_item_a, || item_a);

If we move the state out of the timeline, and let user manuplate it, we can get rid of the item type signature on ItemId and the complicated map operations.

let timeline: TimelineId = r.create_timeline();

let mut item_a: Item = /* ... */;
timeline
    .play(item_a.anim_a_mut())
    .forward(1.0)
    .play(item_a.anim_b_mut());

timeline.play(LowerType::from(item_a.clone()).anim_lower_level())