From ac3c1c63e47cf4a5a603de679f2dbc7869778901 Mon Sep 17 00:00:00 2001 From: Steve Block Date: Tue, 17 Dec 2013 12:42:28 +1100 Subject: [PATCH 1/2] Fix current iteration when iteration duration is zero --- index.html | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/index.html b/index.html index 9747b2a..695d43e 100644 --- a/index.html +++ b/index.html @@ -2078,7 +2078,8 @@

Calculating the current iteration

  • If the iteration duration is zero, return - floor(iteration start + iteration count). + ceil(iteration start + iteration count) - + 1.
  • If the iteration time equals the iteration From 48a72566d680dfb463f03beb7d36b1462bc81577 Mon Sep 17 00:00:00 2001 From: Steve Block Date: Tue, 17 Dec 2013 12:15:54 +1100 Subject: [PATCH 2/2] Overflow fill --- index.html | 138 +++++++++++++++++++++++++++++++++++------------------ 1 file changed, 91 insertions(+), 47 deletions(-) diff --git a/index.html b/index.html index 695d43e..fa527a2 100644 --- a/index.html +++ b/index.html @@ -1207,6 +1207,29 @@

    Local time and inherited time

    If the     inherited time is null then the local time is also null.

    +

    + For a timed item, the inherited overflow boundary at + a given moment is based on the first matching condition from the + following: +

    +
    +
    If the timed item has a parent timing group,
    +
    + the inherited overflow boundary is the parent timing + group's overflow boundary. +
    +
    Otherwise,
    +
    + the inherited overflow boundary is null. +
    +
    +

    + The parent overflow boundary of a timed item is + the timed item's inherited overflow boundary minus its + start time. + If the inherited overflow boundary is null then + the parent overflow boundary is also null. +

    Timed item phases and states

    @@ -1267,7 +1290,8 @@

    Timed item phases and states

    Corresponds to a timed item whose active time is changing on each sample. This occurs when the timed item and all its - ancestors are in the active phase. + ancestors are in play and the root ancestor is in + the active phase. Animations only “move” when they are in play.

    @@ -1281,6 +1305,17 @@

    Timed item phases and states

    snapshotted within the active phase despite no longer being in play.

    +

    + Conversely, it is possible for a timed item to be in + play without being in the active phase. + For example, a parent timing group that is in + play may have a timing function which causes it to + be overflowing. + The child timed item of such a parent timing + group may be in in play even if its local time + falls outside its active interval, causing it to not be + in the active phase. +

    Transitions to and from the in play state trigger timing events as defined in Timed item phases and states duration.

    - A timed item is in play if all + A timed item is in play if any of the following conditions are met:

    -
      -
    1. the timed item is in the active phase, and -
    2. the timed item has a parent timing group that is - in play or else is directly associated with a player - that is not bounded. -
    +

    A timed item is current if it any of the following - conditions is true: + conditions are true:

    • it is in the before phase, or @@ -1381,6 +1417,15 @@

      Timed item phases and states

      href="#calculating-the-active-time" class="sectionRef"> is not null.

      +

      + A timed item is overflowing if its parent overflow + boundary is not null and falls inside its active + interval. +

      +
      + Note that this definition of overflow means that the property is not + inherited. It is possible for a timed item to not overflow even + though its parent is overflowing.
    @@ -1475,26 +1520,6 @@

    Fill modes

    item is only defined (that is, not null) inside the active interval or when a fill is applied.

    -
    -

    - Currently timing functions that generate results outside the - range [0, 1] will behave unexpectedly when applied to animation - groups, as children will increase iterations or enter into fill mode - rather than continuing to extrapolate along their defined behavior - (which is what they would do if the timing function applied to them - directly). -

    -

    - To fix this it is possible we will wish to introduce 'overflow' fill - modes that respond to time values larger than or smaller than the - active time range by extrapolating rather than filling. -

    -

    - See section - 15 (Overflowing fill) of minuted discussion from Tokyo 2013 F2F. -

    -
    @@ -1909,11 +1934,17 @@

    Calculating the active time

    The active time is based on the local time and start delay. However, it is only defined when the timed item should - produce an output and hence depends on its fill mode and - phase as well as the phase of its parent timing group, if - any, as follows, + produce an output and hence depends on its fill mode, phase + and whether it is overflowing, as well as the phase of its + parent timing group. + It is calculated using the first matching condition from the + following,

    +
    If the timed item is overflowing,
    +
    + Return local time - start delay. +
    If the timed item is in the before phase,
    The result depends on the fill mode as follows. @@ -2048,16 +2079,17 @@

    Calculating the iteration time

    If the iteration duration is zero, return zero.
  • - If scaled active time - start - offset is equal to the repeated duration, - and iteration count is not zero, - and (iteration count + iteration start) - % 1 is zero, - return the iteration duration. + If the current iteration is zero, return scaled active + time. +

    + This clarification is needed since the iteration duration + may be infinity and the result of infinity multiplied by zero is + undefined according to IEEE 754-2008. +

  • - Otherwise, return scaled active time - % iteration duration. + Otherwise, return scaled active time - current + iteration × iteration duration.
    • @@ -2082,13 +2114,10 @@

    Calculating the current iteration

    1.
  • - If the iteration time equals the iteration - duration, return iteration start - + iteration count - 1. -
    • -
  • - Return floor(scaled active time / - iteration duration). + Return the result of evaluating floor(scaled active + time / iteration duration), clamped to the range + [0, ceil(iteration start + iteration count) - + 1].

    If the iteration duration is infinite, the result of floor(scaled active time / @@ -3096,6 +3125,21 @@

    Calculating the transformed time

    +
    +

    Calculating the overflow boundary

    +

    + The overflow boundary is calculated from the + transformed time using the following steps: +

    +
      +
    1. If the transformed time is null, return + null. +
    2. If the transformed time is less than zero, return zero. +
    3. If the transformed time is greater than or equal to the + iteration duration, return the iteration duration. +
    4. Otherwise, return null. +
    +