Projects tagged ‘easing’ 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]

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]

agTweener provides a toolkit for Silverlight designers and developers to achieve animation and transition effects similar to toolkits currently available for Flash/Flex developers by defining ... [More] transition effects in .NET code and applying these effects to any FrameworkElement. The best way to understand what this is all about is to take a look at some samples. The features and techniques to integrate this library into a Silverlight application have been blogged about in these posts: http://home.exetel.com.au/thesandpit/?p=11 http://home.exetel.com.au/thesandpit/?p=13 agTweener is a c# Silverlight library based on the Tweener Actionscript library for Flash/Flex. A preset list of transition functions based on Robert Penner's easing equations is available. The library has now been updated to support Silverlight 2 Beta 2. The code for all of the samples is also available in the Releases sections. [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]

The main purpose of this project is to provide a very simple way to animate any Xaml Objects you want in Silverlight. To reach this goal you just have to Reference Tweened.dll in a Silverlight 2 ... [More] project. You will have access to color, RenderTransform and simple propertie Animation easily with many options like AutoReverse, BeginTime, SpeedRatio . It's released and maintained for Silverlight 2 or higher. In layman's terms, Tweened 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 Silverlight timeline. The Tweened syntax is created with simplicity of use in mind, while still allowing access to more advanced features. the general idea is to make the automatic creation of resource types Storyboard. Internally class Tween operates two Storyboards, the first is used for animation to go, the other is used if necessary to animation back. Storyboards Each of these contains a number of objects DoubleAnimation XAML. They serve as animated sequences. Each DoubleAnimation refers to an Xaml object and a lively targeted property, for example X or ScaleX. So a tween can animate lot of objects in several different equation of movement with different duration and behavior. For example a double animation could loop. Online Documentation :: http://library.tweened.org/doc/html/ Chm Documentation :: http://library.tweened.org/doc/Tweened.chm Blog around Silverlight :: http://www.tweened.org [Less]

SlickFx is a flexible animation framework for the Slick2D library. See the thread for details. Brought to you by davedes. :-)

My Own AS3 Repository Actual Features: Charts, Fps Counter, Particles, Reflection, Rotation2D, Tree, Ptween (Simple Tween engine), all Documented. Ptween is a lite as3 tween engine that ... [More] features: Multiple properties in a single command line; Overwrite tweens automatically; Garbage Collection; Pause Tweens; Reverse Tweens; Tween by Frames/Time; [Less]

KitchenSync is an ActionScript 3.0 library for sequencing animations and other time-based actions. Read More...NewsYou may have noticed that the framework has had few updates in the past few months. ... [More] I've been working on other projects but have been using KS more in the field. I'm finding several things I'd like to improve on. I've implemented some of these in an interim build but version 2 will have many more updates to the overall structure and ease of use. All your comments, bug reports, suggestions, and help are appreciated as usual. Color tweening and some fixes added in the latest build. Still experimental though. See TintTweenTarget and SaturationTweenTarget. 20 Reasons to use KitchenSync on your next project. GoalsKitchenSync aims to be the best framework for working with time-based animations and other time-based events. Read more... Getting started... [Less]