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

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]

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]

UPDATEThis project will be soon be deleted! For news and updated source go to:http://code.google.com/p/thelaboratory-tween/Thanks!Litr ClassDescriptionWell described here: ... [More] http://thelaborat.org/?page_id=63 Changelog Flash AS Versionversion 0.9aDeprecated because of compiler errors in Flash IDE version 0.9.1aDeprecated because bugs in Glow tween, some errors inside Flash IDE, and anoying forgotten trace functions :) version 0.9.2aFixesAll preview bugs. FeaturesStatic Class to create animations and effects in Flash. Allow users to tween most of the properties of MovieClips, TextFields or any Object with numeric parameters. Allow tween of filters like Blur,Glow and FilterMatrix. Besides "normal" tweening allow Path tweens controled by Cartesian Points or MovieClips references. It has a WaveTween function that make properties oscilate according some harmonic function (like sin() and cos()). Works with String Tween commands or Object tween parametrization like other examples of tweening classes. Allow tween duration by Time in seconds or Frames. version 0.9.3aFixesLittle bug on WaveTween Parsing and Gradient/GradFilter tween continuity. AddedCatmull Path tween now with orientation towards the direction of the curve. Gradient/GradFilter Tween (given an array of colors the target tween along each one smoothly). Stroboscopic function added to WaveTween. version 0.9.4aFixesBug in the WaveTween for Special Properties as Filters and others. Changelog C# Versionversion 0.5aFeaturesClass to create numerical and color interpolation along time, aimed to graphical application (e.g. XNA) Allow users to tween Numbers and Colors. There are plans to extends the data that is possible to tween. Supports OnStart, OnUpdate and OnComplete callbacks with an Object passed as parameter if necessary. [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]

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]