Projects tagged ‘actionscript’ and ‘tween’

Tweener (caurina.transitions.Tweener) is a Class used to create tweenings and other transitions via ActionScript code for projects built on the Flash platform. It's released and maintained for these ... [More] versions: ActionScript 2.0, for Flash 7+ and Flash Lite 2.0+ ActionScript 2.0, for Flash 8+ ActionSctipt 3.0, for Flash 9+ Ported/inspired versions for other languages are also available: haXe version (ported by Baluta Cristian) JavaScript version (ported by Yuichi Tateno) JavaScript version (ported by Michael MacMillan) vvvv version using nodes vvvv version using a native C# dll (faster) (ported by by Rene Westhof) Python version (ported by Benjamin Harling) C++ version (ported by Wesley Marques) In layman's terms, Tweener helps you move things around on the screen using only code, instead of the timeline. The general idea of a tweening Class is that dynamic animation and transitions (created by code) are easier to maintain and control, and more stable than animation based on the regular Flash timeline, since you can control it by time rather than by frames. Aimed both for designers and advanced developers, the Tweener syntax is created with simplicity of use in mind, while still allowing access to more advanced features. Because of this, it follows a 'one-line' design mentality when creating new tweenings, with no instancing required (as it's a static Class) and a set of optional parameters. Also, there are no initialization methods required by Tweener, other than the mandatory 'import' command. Its fluid syntax allows it to be used to tween any numeric property of any object of any class, so it is not tied to specific properties of built-in Classes such as MovieClips or TextFields. This flexibility grants a wider control on how transitions are performed, and makes creating complex sequential transitions on any kind of object easier. Small file overhead is also one of the main goals of Tweener - once included on SWF movies, Tweener currently takes 8.8kb (AS2 FL2), 9.2kb (AS2) or 10.4kb (AS3) of the total compiled file size. It can be compiled with the Flash IDE, MTASC, or Flex SDK (even with strict rules on), with no errors or warnings thrown during compilation. Tweener is also the spiritual successor to MC Tween. However, it follows ActionScript's more strict OOP rules, and gets rid of the fixed parameter order syntax imposed by MC Tween. As a result, code written with Tweener is a lot more readable even for developers not versed on the Class. Development wise, modularity is one of the main aspects of Tweener. The code is built in a way that new features such as transitions and special tweenings can be added (or removed) easily: for example, properties that are only acessible through methods and functions can be tweened by creating and registering new special properties. Expanding the feature set of the original Class can be done on a per-project basis, with no change to the original files. From this page, you can download the latest stable (heavily tested) version of Tweener, check out a few examples with source, or read the documentation. There's also a mailing list for Tweener discussion. If you prefer, you can also get the very latest versions from Subversion, before they're considered stable and featured on the download list (the changelog is available here). The repository can also be viewed with a web browser. [Less]

AS3 rich graphic and geometric opensource library based on the Maashaack and VEGAS frameworks.

The Go ActionScript Animation Platform is a lightweight, portable set of generic base classes for buliding your own AS3 animation tools. Go provides structure and core functionality, but leaves the ... [More] specifics to you. This Googlecode page is used for the SVN repository and to host files. For docs & more about Go, please visit goasap.org. The go package now includes the open source TweenBencher utility plus tests & tutorials packages. For Video Tutorial source please visit the Go Playground. Following the build? Be sure to click on source > changes to see what's new. Talk to you on the Go List! [Less]

This class serves as a wrapper around the caurina.transitions Actionscript 3 Tween library. It adds the ability to store Tweens in a queue with an associated priority level for later execution. The ... [More] priority for tweens to fire can be specified at the time of execution (it doesn't always have to fire in a specified order, 1, 2, 3...) This is a work in progress. It is being developed for use in a game I am writing. Please let me know what kind of interest is out there for this functionality. I would be happy to write up some sample usage code in the near future. Note: You will need both "TweenHolder.as" and "TweenManager.as" to get this to run. Change the namespace as you need. [Less]

GTweener has been succeeded by ActuateActuate is a way faster, packs more features and has an even cooler API!Check it out!IntroductionCreating tweens is foundational to nearly any project in Flash. ... [More] While there are always many choices in tweening engines, Tweener has long been an industry standard. A recent but exciting newcomer is GTween. It is fast, has many features and is making headway in the Flash community. The Case for CombiningTweener provides excellent "set it and forget it" simplicity. Since it is global, Tweener can automatically stop old tweens that conflict with new ones. Tweener.addTween (MyClip, { time: 1, alpha: 0 } ); Tweener.addTween (MyClip, { time: 2, alpha: 1 } );However, instance-based engines like GTween require that you maintain context with your old tweens in order to prevent collisions. var myTween:GTween = new GTween (MyClip, 1, { alpha: 0 } ); myTween.pause (); var myTween2:GTween = new GTween (MyClip, 2, { alpha: 1 } );GTween includes more features and operates faster than Tweener. That is why I combined the best qualities of both into one library. Personal tests showed that GTweener adds only a nominal amount of overhead to GTween. Performance using GTweener compared to GTween and other popular libraries, and was nearly three times faster than using Tweener. Using GTweenerCreating a new tween using GTweener is easy. GTweener.addTween (MyClip, 1, { alpha: 1 } );The addTween method accepts the same parameters as a new GTween object, and is similar to creating a tween using Tweener. Pausing, resuming and removing tweens is also simple: GTweener.pauseTweens (MyClip); GTweener.resumeTweens (MyClip); GTweener.removeTweens (MyClip); GTweener.removeAllTweens ();The addTween, addTweenFilter and addTweenTimeline methods return the actual GTween object which is created, but you can also retrieve these objects later using the getTween or getTweens method: var alphaTween:GTween = GTweener.getTween (MyClip, "alpha"); var allTweens:Array = GTweener.getTweens (MyClip);Finally, you can also register your own tweens with GTweener. This is useful when you want to create your own tweens by hand, or are using a different kind of tween like GTweenFilter or GTweenTimeline. var myClipTween:GTween = new GTween (MyClip, 1, { alpha: 1 } ); GTweener.registerTween (myClipTween);Updates(07/03/09) Version 1.2Added new aliases to make GTweener easier to use for developers familiar with Tweener. rounded will set the snapping property transition will set the ease property transition also supports Tweener string values. "easeOutExpo" will set the ease property to Equations.easeOutExpo (07/01/09) Version 1.1While overwriting previous tweens is usually a great feature, sometimes you still want to add a delay and set up multiple tweens that affect the same property. It is now possible to disable GTweener's overwriting feature to register multiple tweens for the same property. When you do choose to overwrite this property, every one of these previous tweens will be overwritten. GTweener.addTween (MyClip, 1, { alpha: 1 } ); GTweener.addTween (MyClip, 1, { alpha: 0 }, { delay: 2 }, false);GTweener 1.1 extends the GTween class to provide additional properties to better mirror Tweener. In addition to GTween's initListener, changeListener and completeListener properties, GTweener includes onStart, onStartParams, onUpdate, onUpdateParams, onComplete and onCompleteParams. This is especially useful for reducing code or preventing your listener from being deleted by garbage collection. GTweener.addTween (MyClip, 1, { alpha: 0 }, { onComplete: removeChild, onCompleteParams: [ MyClip ] );GTweener also includes a new method to make it easy to use tween-based timers. GTweener.setTimer (10, { onComplete: trace, onCompleteParams: [ "Timer complete" ] } );Finally, setProperties will clear previous tweens and apply properties to your target object instantly. This is similar in functionality to creating a tween with a duration of zero, but zero duration motion tweens have not been supported since GTween Beta 5 was released. Although this is primarily designed for objects you have previously tweened, you can also use the method as a quick way to copy properties from one object to another. if (animate) { GTweener.addTween (MyClip, 1, { alpha: 1 } ); } else { GTweener.setProperties (MyClip, { alpha: 1 } ); }DownloadGTweener includes GTween beta 5 as well as Robert Penner's easing equations, as they are included with Tweener. There is an example FlashDevelop project available which includes ASDoc documentation for GTweener, or you may download the library by itself. GTweener Example.zip GTweener.zip FeedbackFeel free to send me an email or write a comment on this forum post if you have any feedback or suggestions. [Less]

IntroThis project has the objective to host all as3 classes related to tweening. There will be 2 main focus: 1) ByteTweenLight weight engine (focusing in low Kb increase and not being a do-it-all ... [More] engine). v1.3Fixes some bugs from v1.2 that causes malfunction on large number of tweens. Adds new modules to the module list, they are the Gradients module. Added too the ShortTween wich is a shortcut for the most common tweens (x,y,alpha,...). Correction of bugs added some bytes to the basic version. FeaturesSame as v1.2 and bug fixes. New modules! Added GradientRGB and GradientARGB (call for "gradientRGB" and "gradientARGB" respectively). ShortTween = static class with shortcut to most common tweens (alpha,x,y,...). Modules AvailableSimpleVersion(1.0Kb) Actually not a Module. Just the ByteTween without overlap check,pause,unpause,cancel. Just the basic Numeric Tween. The smallest size the code will generate. ColorModule(+0.4Kb) Adds the 'color' tween feature. ControlModule(+0.2Kb) Adds the 'pause','unpause','cancel' functions to the engine. FrameModule(+0.1Kb) Adds the 'frame' tween feature. OverlapModule(+0.1Kb) Adds the overlap check in the tween execution (remove older tweens of same property when a new one of same property arrives). ScaleModule(+0.1Kb) Adds the 'scale' tween feature (tween both scaleX and scaleY). New ModulesGradientRGB(+0.4Kb) Given an Array of RGB uint values, tween all colors through time. GradientARGB(+0.4Kb) Given an Array of ARGB uint values, tween all colors (including alpha channel) through time. ShortTween Listx,y,position (both x/y),scaleX,scaleY,scale (both scaleX/Y),shrink (scale=0),expand (scale=1),alpha,fadeIn (alpha=1),fadeOut (alpha=-1),color,rotation,width,height. Usage: //has_overlap: Flag that says if the engine will check overlap. //has_control: Flag that says if the engine can do pause,unpause,cancel actions. //... args: Adds 0 or more modules by just adding the module classes separated by commas. //Ex.: ByteTween.init(stage,true,true,OverlapModule,ControlModule,ColorModule); ByteTween.init(stage,has_overlap:Boolean,has_control:Boolean,... args); ByteTween.add(target:*, property:String,value:*,duration:Number,delay:Number, ease:Function,p_callback:Function,... arguments); //New ShortTween **some examples ShortTween.x(target:*,pos_x:Number,duration:Number,delay:Number, ease:Function,p_callback:Function,... arguments); ShortTween.alpha(target:*,alpha:Number,duration:Number,delay:Number, ease:Function,p_callback:Function,... arguments); //Same as alpha but tween directly to alpha=1.0 ShortTween.fadeIn(target:*,duration:Number,delay:Number, ease:Function,p_callback:Function,... arguments); //Same as alpha but tween directly to alpha=-0.1 ShortTween.fadeOut(target:*,duration:Number,delay:Number, ease:Function,p_callback:Function,... arguments); v1.2Upgrade of version 1.1 with pratically same features. The difference is now the system can be configured by setting wich functionality module you want active on compile time. With this system you can setup from just a numeric tweener to the full functional tween engine with color,scale,... tweens. Well this is the most stable version. I think that new versions will come in form of modules but now I'm busy in finishing the MotionPack and new useful classes for ya! FeaturesSame as v1.1 but now you can add/remove functionalities on compile time. Module System that permits to add the funcionality you want and control the size of your swf. Most simple version of ByteTween starts now with just 0.8Kb!! Ok actually 885 bytes.. sorry.. Functinonality Modules. Choose what you wan just insert it :) Even with all funcionalities inserted the max size that the code will achieve is ~2Kb!! Alpha tween with visibility test is included in the basic package. Well it's just a boolean check :) v1.1First official version. v1.0 is a gold version :). FeaturesRidiculous amount of Kb increase: Just 1.2Kb! numeric properties tweening. 'color'. Using ColorTransform. 'alpha' with visibility control (negative alpha sets visible=false). 'frame' tweening. 'scale' tween. Both scaleX and Y at the same time. 21 easing functions + All Robert Penner's classic functions. Tween pause,unpause,cancel control. Operation pointed by the target and its properties. Tween overlap control. A starting tween checks for older tweens of same property and cancel them). 2) MotionPackPackage of classes,events and interfaces that allows the developer not only to do the common tweening tasks (with the BaseTween class), but also develop its own tweening classes. It uses a Interface system that allow easy implementation and do not use the only "slot" of the "extends" keyword :). Easing Functions ExpansionWithin the "org.thelab.motion.transition" package are the most common transitions used in tweens, and also the well known Robert Penner's transition functions. But one can also implement its own tween functions. Both tween engines uses default functions for it. The template for them is: function ease_name(r:Number):Number;Where the "r" parameter is a Number inside 0.0 -> 1.0 range. Where 0.0 is the tween start and 1.0 is the tween end. The result of this function is used in the following equation: target[property] = initial_value + (delta_value)*ease_name(r); [Less]

This is the svn clone of the git repository http://github.com/andrewfitz/desuade/ for all Desuade classes. Desuade Partigen 2 - AS3 Flash particle effects class Desuade Motion Package - Tweening ... [More] and physics engine for ActionScript 3 The example flas that come with the downloads have all the syntax, demos, description, and usage. Documentation is available at http://api.desuade.com/ Note: This may not have the bleeding edge revisions as it is only a mirror of the GIT repo. It is advised to switch to git for the best experience. The featured downloads will always be the latest release available. [Less]

About TweenManTweenMan is yet another set of tweening / animation classes for Actionscript. It was written primarily using AS3, but was ported back to AS2 for Flash Player 8 compatibility. The idea ... [More] behind TweenMan was to create an alternate tweening engine which makes use of some of the more common ideas found in other engines (Tweener, ZigoEngine), while remaining light on file size and easy on the frame rate. TweenMan can also change between time-based and frame-based animation on a per tween basis. TweenMan compiles down to approximately 10kb for AS3 and 9k for AS2. Special thanks to Jack Doyle for writing TweenLite- the old trusty grandfather that TweenMan never had. Recent ChangesChangeLogAs2, ChangeLogAs3 DocumentationTweenManDocAs2, TweenManDocAs3, EasingFunctions, EasingShortcuts SourceTweenMan is open source. Feel free to browse the subversion repository: http://tweenman.googlecode.com/svn/trunk/ UtilitiesConstantEase is a utility included in TweenMan AS3, for those special times when you must tween things like mouse positioning or preload bar updates. See ConstantEaseDoc [Less]

This AS3 library leverages an open source ActionScript 3.0 Tweening engine (TweenMax / TweenLite) to conveniently build and transition text with embedded fonts. This library was originally written ... [More] by Timothy Jordan while at Daemon Creative, the interactive group at Dmax Imaging. [Less]

A collection of public AS3 classes released under MIT Licensing by gskinner.com Classes LibraryDisplayObjectWrapper Using Flash Symbols with ActionScript in Flex Free Extension: AS3 String ... [More] Utils Free Extension: gAlign Panel Variable Scrollbar Width for CS3 Components StyleCollection for CS3 Components Replace actions on labeled frames in AS3 Squeeze Effect Source Code Fire Effect Component & Source Code ColorMatrix Class in AS3 ProximityManager updated for AS3 Source Code: Random Methods Utility Class Adding CSS Support to the CS3 Components Parsing Tags and Text From HTML Simple Component For Monitoring Memory and FrameRate SparkTable: Visualize Easing Equations Drawing Curved Lines Simplified Programatically Drawing Trees With Recursion gTween: A New Tweening Engine for AS3 Developers [Less]