Friends of Ed is now giving you the chance to catch up on this little revolution with their new book, The Essential Guide to Open Source Flash Development, and I’m proud to say that I’m one of the contributing authors! My chapter covers several Open Source animation tools that I’ve released for ActionScript 2.0 and 3.0.

It’s also no secret that part of GoASAP’s mission is to promote the idea of various animation systems being able to combine their processing. Large numbers of animations process the fastest when they’re all kept in a single list, and that list is updated “on the beat” all at once.

Adobe could address these issues with an additional player-level timer class:

package flash.animation {
public final class SyncTimer {
  public static function addCallback(closure:Function,
                                   interval:Object="enterFrame",
                                   priority:int=0):void;
  public static function removeCallback(closure:Function):Boolean;
  public static function pause(interval:Object=null):void;
  public static function resume(interval:Object=null):void;
}}

This hypothetical class might use callbacks instead of events for speed. It would always use weak references to avoid trapping object references. Intervals other than ENTER_FRAME would ideally be corrected for lag, so they stay as close to accurate as possible.

This might provide a real performance boost for larger numbers of animations. And importantly, all animation systems could be synced very tightly from one centralized update list, making them work much better together.

This feature would lay the groundwork for Adobe to provide a base animation package in AS3, a set of core classes that both their own and also 3rd-party systems could be built on, eliminating a lot of the redundancies between these overlapping systems. (Currently Flash and Flex don’t even share an easing package!)

import flash.animation.easing.*;
import flash.animation.SyncTimer;
import flash.animation.AnimationEngine;
import flash.animation.AnimationEvent;
import flash.animation.IPlayable;
import flash.animation.PlayStates;
import flash.animation.BaseTween;

Sure, that’s basically a suggestion that Adobe adopt the concepts behind GoASAP, why not? If they wanted to go all the way and make a statement in a Silverlight-tinged world, they would consider the creation of a standardized ECMA animation library that could be ported to AS3, JavaScript, and After Effects; however that’s a different and much bigger proposal and one I’ve already made (see earlier posts at this blog). For now, simply by adding a centralized SyncTimer feature to the player and a few slim base classes, at least AS3 animation systems would share a common core instead of all having to reinvent the wheel.

I will be joined on stage at FlashBelt by Donovan Adams of Scifi.com and Jud Holliday of ZAAZ!

Donovan has been doing great work on HydroTween. It has a Tweener-like syntax plus sequencing, it’s compact (one extension class), very fast and does a load of fancy tricks: color & HSB tweening, filter tweening, 3D tweening with automatic scene updating, start properties and more. Tween groups and sequences as quick as you can say “Fuse.”

Jud and Graeme have been taking a nearly opposite approach at ZAAZ, with a fully OO strictly-typed tween library (and sequence extensions), but no syntax parsers so far. Graeme’s also been working with John Grden on expanding his Go3D library. When this library lands it’s gonna be with a thud, and my guess is that it will become a standard in the Go community.

Why I’m excited and honored to have these guys co-present with me is that their different approaches really illustrate the wide range of possibilities with Go. There is no wrong answer!

I hope to get a chance to talk a bit more about Go’s decoupled management architecture. This is one feature that makes Go unique and so sexily flexible. While other kits “bake in” management features and lock you to them, this is a way to be able to infinitely expand the automated side of your animation tools, while leaving them entirely optional for the end user. ‘Managers’ – it sounds dry… but in fact it’s a richly creative opportunity. For example I made an AutoBlurrer manager that adds horizontal and vertical blur to any moving object based on its velocity.

The other point of excitement around FlashBelt 2008 is just the killer lineup of speakers, one of the best I’ve seen at any conference.
http://www.flashbelt.com/

Tim Knip and John Grden from the PaperVision3D team are getting into the groove.

Tim and I are creating a Go-based system for animating the data exported from 3D programs called Timeline3D. John has started coming up with his own strict-typed syntax for tweening DisplayObject3D’s and Go community member Graeme Asher is planning on contributing some classes of his own for animating cameras and other 3D objects.

John’s latest blog post on his Go3D system
John’s blog

Be sure to join the Go mailing list to keep up on all of this fun!

The latest drop, GoASAP 0.4.7 is a major improvement in the tweening arena, adding a “useFrames” alternative to time-synced updates and more cycling options. Looping has also been added to group & sequence utilities. This update also affects any LinearGo extensions you’ve already written so be sure to read this article!

New Event Types

GoEvent has some new types: PAUSE, RESUME, and CYCLE (cycle is between loops or back-and-forth cycling animations). These events are now dispatched from LinearGo, PlayableGroup and all Go Sequence utils.

Repeater Repeater

To handle looping and cycling, LinearGo, PlayableGroup and all Sequence classes now contain a property called repeater. The property holds an instance of an iterator object – for groups and sequences this is simply a Repeater, and for LinearGo it is a LinearGoRepeater. You can set the repeater’s cycles property to any uint higher than 1 to make these “playables” repeat their play. For example:

myGroup.repeater.cycles = 2;
mySequence.repeater.cycles = Repeater.INFINITE;

LinearGo’s special repeater has more options. Its property reverseOnCycle is true by default, which means that a tween will cycle back and forth in a ‘yoyo’ motion. If you set that property to false the tween will loop forwards. One problem with back-and-forth tweens is that easing tends to look bad one way or the other. So LinearGoRepeater also lets you set easingOnCycle. (It also has an extraEaseParams parameter like LinearGo does, for easing functions like Elastic and Back that take more than 4 inputs.) So to make a tween play forward then back in a smooth arc you could set the tween’s easing to a strong ease-out, then set myTween.repeater.easingOnCycle to a similar ease-in.

Like everything else in GoASAP, repeaters are made to be universal and extensible. As you create your own Go utilities, you can make use of this simple iterator object to help you implement complex functionality. For example, Repeater’s skipTo() method will calculate jumps across cycles and return a new position value for you.

“Frames” Support for Tweens

The ability to tween in frames instead of seconds was the last big one to fall. It’s not a recommended feature, since normally tweens sync to realtime which is a lot more accurate and intuitive. Frames work like the timeline, they will slow down your animation if the player is lagging.. but in special cases such as syncing to a timeline animation you might need to use it.

Surprisingly enough, it didn’t add too much complexity or slow LinearGo down. “Frames” are actually update-counts, so when you set:

mytween.useFrames = true;

… you’re really stating that you want delay and duration to be treated as the number of times the tween is updated on its pulse.

Normally you want the pulse to be synced to the player, which you can do by setting:

GoItem.defaultPulseInterval = GoEngine.ENTER_FRAME;

Or by setting your tween’s pulseInterval individually. But this can be a hassle if you simply want to work in a frames metaphor for a whole project. If that’s the case, simply call this setup command once at the beginning of your program:

LinearGo.setupUseFramesMode();

This changes the default pulse to ENTER_FRAME and makes all new LinearGo instances default to useFrames. This method also provides the option to switch to a zero-based index, instead of using a 1-based frame index like the Flash timeline.

The new currentFrame getter always steps forward through delay, duration, and all cycles (as if cycled tweens were back-to-back tweens in a timeine),

The timePosition getter also works in frames mode – works the same as in time mode. That property’s values always range between negative-delay and zero during the delay; then zero to duration during all cycles. So during cycles this property acts more like a timeline playhead that loops in a single tween.

Critical Update Warning!

Sorry to sound like the Window OS there but, you need to know that if you’ve been writing subclasses of LinearGo this update will force you to tweak them just a tiny bit, because LinearGo’s constructor inputs have changed. It is also now mandatory that your subclasses make a super() call, since LinearGo’s constructor instantiates the repeater instance and adjusts class defaults.

Other non-critical items in this version include a new EasingFormatError for use with malformed easing functions, and a few minor improvements to PlayableGroup’s internals.

Enjoy!

All classes and documentation available from the GoASAP website.

Having written Fuse myself I have to say that the simplicity of this system is pretty shocking. I can’t tell you how happy I am to open up this kind of functionality for you to be able to work with directly instead of just being stuck with the API’s others create for you.

Tutorial: Creating a simple parser with Go

Accompanying video tutorials are available at GoPlayground.

Want to get involved with Go? First get the Go source files, check out the official website and online documentation. Browse the Playground to see what the community is up to, join the mailing list so you can get involved, then join up when you’ve started to make your own tools with Go and wanna share the love!

http://www.goasap.org/

What do you think?