Getting ready to leave for MN and I'm very excited to be a part of Moses' presentation at Flashbelt 2008! I will be providing a brief introduction to HydroTween. HydroTween is a multi-purpose tweening parser that runs on top of the Go framework. If you are familiar with ZigoEngine, Fuse, or Tweener, then using HydroTween should be a seamless transition. In this post, you will find the examples shown during the presentation. I've also put together an online version of what I will be showing. I was hoping to also include a demonstration of the Making Things controller running a tween on a servo, but my laptop isn't being cooperative. I will provide a separate post with an update on that as well as a library I am working on for controlling modules.
Back to the subject at hand, here are the 3 examples that I will be showing. The first is an example of generic tweening with most of the basic properties, filters, and image/hsb tweening. The second is a Fuse type example using navigation with multiple tweening properties running at once. The last is a Papervision3D example that is tweening a number of properties including brightness. Thanks to Andy Zupko's heroic efforts of merging the GreatWhite and Effects branches of Papervision together, we have alpha and the other none-positioning properties at our tweening disposal for 3D objects!
I also urge you to check out my previous post that has useful information and source examples, along with changes and important features that have been added. HydroTween will call you renderer for automatic updating of your Papervision scene by registering with HydroTween using the init3D() method. One important new addition is the ability to pass a DisplayObject3D target into this init method for automatic use of the lookAt() method.
The latest rev is 32. I have added the changes to this document in addition to the other updates.
Update 31d Fixed a bug from the removal of OverlapMonitor. Thanks John!
Update 32 Smoothness issue has been fixed with pulseInterval and example updated for 0.4.9. Start Values have been added for non-color/image matrix properties
Update 33 Made a couple updates and a post for the FlashBelt 2008 conference. A few more examples. I also added a DisplayObject3D target argument in the init3D() method for running a lookAt() during scene renders. Click here for the recent post.
After a short hiatus from the blog, and a wedding, I've been able to knock out some much needed changes and additions to HydroTween. I'm excited about this because now I can move onto the fun stuff and I've started putting together a roadmap of sorts. Go has been picking up steam and examples have been popping up which is great to see. Most people seem to think there are two types of users of Go. The ones that simply want to tween away, have something functioning, and useful right away. The other types are interested in developing their own tweening system and animation utilities either for all around use or for specialized applications. I'm excited about the 3rd group which falls in the middle. These are the people that want the first, but find themselves becoming the latter just because of the Methodology of Go. I used to be in the first group for quite some time until Go came along and then I found myself thrown intro the world of tweening. I've been saying this for some time now, but the beauty of Go is that you might find yourself in the middle with very little effort. Once you it that point, consider yourself an addict. This post should help with a general understanding of HydroTween. I also hope this post will open some eyes to the idea of going it along and giving their own parser a shot. That said I will start with the usage of HydroTween and it's updates, then I will follow with my own trial and tribulations of reaching this recent version. The example below along with the source is located at the end of this post.
Image/Bitmap/ColorMatrix property refactoring such as contrast, brightness, etc. Color tweening has been added as well. Worked out some bugs and streamlined.
Fuse style sequencing.
An autostart parameter.
Updated reverse and cycle structure.
Started porting over the previous textfield tweening functionality.
Tweening of multiple targets as Arrays
Papervision3D tweening functions
start_ values for non image/color matrix tweening. (This will be addded soon!)
Autostart:
Autostart has been deprecated from version 30. In version 31, go calls() and sequence() methods start automatically. To setup a sequence that doesn't start, use the parseSequence() method.
LinearGoRepeater:
The static go() method and the constructor have been updated to reflect the changes in version 0.4.8. An object has been added that provides parameters for cycling back and forth. You can either input a LinearGoRepeater instance, or you can use a generic object.
I have added a convenient function for setting up your renderer for HydroTween. This is called once before you call any tweens and runs the renderer during any tween.
// Call once to setup a 3D tweens renderer
HydroTween.init3D(renderer, scene, camera, viewport);
// Simple Papervision3D Tween
HydroTween.go(plane, {rotationX:100, z:500}, 2, 0, Elastic.easeOut);
Also be sure to check out John Grden's kickass Go3D parser.
Roadmap and upcoming updates:
Text tweening to support prefix and suffix String values
Even more modular format for adding tweenable properties
Drawning and spline/bezier tweening/Catmull Rom/etc
Continuing with speed enhancements
The Making of HydroTween
For those of you interested in setting up your own tweening parser, hopefully this section will offer some insight. Getting these updates was a bit of a challenge and I learned quite a bit. Because of this, I think my ultimate vision for HydroTween has changed a bit. With the flexibility Go offers, the task of how to manage tweens and properties falls in the hands of the Go practitioner. The efficiency of a tweening engine really boils down to the simplicity of it's core and the reading and routing of updating property values. How this is achieved can explain the large number of different tweening systems out there. My hope is to eventually set up HydroTween to extend the open foundation of the Go system to it's tweenable properties making them more modular and easy to tweek. Let's forget about how the Go core engine works for a minute and look at the bare bones processes invloved in tweening.
First we need some way to parse a syntax of our choosing.
We need to keep track of where/what the end result of our tween will be.
We need to figure out the starting value of the tween.
We need to figure out the difference of the starting and ending value.
We need to update the values of that difference over a period of time.
We need to route the updated values to the tweens target based on the type of property that's being tweened.
This is a very general idea of what's going on here. Now some of the above has been taken out of the equation and/or made easier to accomplish. The parsing is being left up to us, along with how we store and route the updating property values. We have a place to figure out the starting point as well as where to update the data. The trick is how to do it.
I've found that most tweenable properties fall into a few categories:
Some are direct properties of an object, such as the x value of a Sprite.
The above examples are straight forward, but they point out the process of parsing. We are using a String reference to the Objects property which allows us to match it up in our property list. This is where we define our syntax and essentially becomes our "key". Every key in our parser must be unique so we can match up a respective property. In the case of blurX, we have to specify that it is either the BlurFilter, GlowFilter, etc. So Blur_blurX is added to a key/property list which matches that property with the functions needed to update the BlurFilter and target in the Objects filter Array.
Some use a combination of Filter and Matrix math such as contrast, color, hue. Some use value pairs, such as drawing. The rest I have found use either a single or double value, along with some constants such as spline animation, text, etc. You can refer to the source for the more complicated examples as they require a couple extra steps. Just to give you the general idea. With ColorMatrix we are tweening an entire array of values. What HydroTween does is depending on the property settings, an "adjustment" function is called. This changes the end values for the array, and the write function updates the entire array from point A to B. Since an Object can have multiple ColorMatrix adjustments made to it, we need to call these first before running the tween. Thanks again to Grant Skinner for letting me import and tweek his ColorMatrix class.
All of these items are easy to tween in their own right, but when you combine them all together, that's when things get tricky. I've organized my functions in a read, write, and for some an adjust and path category. "Read" simply gets the objects existing state, "write" updates the objects property value, "adjust" modifies a property prior to writing it (such as ColorMatrix transformations of a ColorMatrix Array before tweening it), and "path" is a param that accesses an objects property.
My goal now is to continue to make this more efficient and modular in a way that the average user can create a read function, a write function, and register it to the property list along with any additional params it might need. It's sorta there, but there is much work to be done:)
I'm still no tweening Jedi and this is an ongoing work in progress. Any suggestions, complaints, and contributions are welcome.
Also I will be at Flashbelt. Hit me up if you are interested in meeting up. Looking forward to Moses' presentation!
QueueLoaderLite has been deprecated. Regular QueueLoader 3.1.7 and later can be made into a lite version by removing loadable items!
I've stripped down some of the heavier features for an alternate "lite" version for those wishing a bare bones QueueLoader with low file size. QueueLoader will continue to thrive and there are some enhancements to the regular version that will be made shortly.
The lite version is focused exclusively on image and swf asset loading. Application Domain/Loader Context is still there so you can load other items within a swf and have access to its class references in the library. I will add another guide page on the Google page shortly. I'm including all the listening function in the example below just so you can see it in action, but any/all of them can be removed. More examples and documentation on this version to come, but in the meantime… Basic usage:
And for instantiating library assets in an external swf library:
import com.hydrotik.utils.QueueLoaderLite;
import com.hydrotik.utils.QueueLoaderEventLite;
var addedDefinitions:LoaderContext = new LoaderContext();
addedDefinitions.applicationDomain = ApplicationDomain.currentDomain;
var qlLoader:QueueLoaderLite = new QueueLoaderLite(false, addedDefinitions);
var soundSWF = newMovieClip();
soundSWF.name = "externalSounds";
addChild(soundSWF);
var soundChannel:SoundChannel = new SoundChannel();
qlLoader.addItem(prefix("") + "flashassets/swf/externalsounds.swf", soundSWF});
qlLoader.addEventListener(QueueLoaderLiteEvent.QUEUE_COMPLETE, onQueueComplete,false, 0, true);
qlLoader.execute();
function onQueueComplete(event:QueueLoaderLiteEvent):void{trace("** "+event.type);
var Loop1Reference:Class = getDefinitionByName("Loop1") as Class;
var loop1:Sound = new Loop1Reference();
soundChannel = loop1.play();
}
The example above is included in the source at the bottom of the post.
Continuing with the adventure that is Go, I have added tinting, brightness, contrast, hue, saturation, and a lineTo feature. Grant Skinner was kind enough to let me peel some code from his ColorMatrix class. Just to reiterate, I am not a tweening guru. I have an increased respect for people such as Moses, Ryan Taylor, Jack Doyle, Zeh Fernando, and anyone else crazy enough to enter the world of tweening. Tweening engines become incredibly complicated when you start dealing with how properties are organized and how to get the most speed out of the system. That being said I think it is a testament to the Go architecture that I was able to get such a universal tweening class running on Go in such a short time. I should also state that HydroTween is not a tweening engine. HydroTween sits on top of Go and simply allows you to create your own syntax and system for parsing the properties you wish to tween.
I know there is a mad race with who has the fastest tweening system and even more so since the release of TweenBencher. I'm sure the #1 spot will continue to change. This is great as it will push the most out of every system. Because of the way Go is set up, anyone can enter. I've set up HydroTween so it uses syntax similar to Zigo/Fuse with a couple tweaks. HydroTween doesn't have sequencing capabilities yet, but that will come soon along with start properties and property overlap. I put together an example above and the list below of how to use HydroTween with its current properties.
If you've played with HydroTween before, I've taken the liberty of slightly changing the property key structure by doing away with leading underscores in keeping with AS3's format. I've also grouped contrast, matrix, brightness, hue, and saturation into it's own object. Here's a simple code example of how HydroTween currently works:
The guide above shows most of the features in HydroTween. When you tween an example, the code is pasted into system memory in case you want to
HydroTween.go(copy_tf, {alpha:1}, 2, 2, Quartic.easeInOut);
HydroTween.go(target, // Target DisplayObject
propsToObject, // {x:10, y:10} Contains the tweening properties and values
seconds, // tweening duration in seconds
delay, // tweening start delay in seconds
easingFunction, // Easing function i.e. Quadratic.easeOut
onCompleteHandler, // Function called when tween completes
onUpdateHandler, // Function called on each update i.e. a screen rendering function
extraEasingParams, // Additional arameters for the easing function
loopCycles, // Number of times the Tween plays back and forth
cycleEasing // Easing function for the additional cycles);
/*
Filter Properties:
Bevel_angle
Bevel_blurX
Bevel_blurY
Bevel_color
Bevel_distance
Bevel_highlightAlpha
Bevel_highlightColor
Bevel_quality
Bevel_shadowAlpha
Bevel_shadowColor
Bevel_strength
Blur_blurX
Blur_blurY
Blur_quality
DropShadow_alpha
DropShadow_angle
DropShadow_blurX
DropShadow_blurY
DropShadow_color
DropShadow_distance
DropShadow_quality
DropShadow_strength
Glow_alpha
Glow_blurX
Glow_blurY
Glow_color
Glow_quality
Glow_strength
*/
HydroTween.go(copy_tf, {
Glow_color:0x00FF00,
Glow_blurX:8,
Glow_blurY:8,
Glow_alpha:1,
Glow_strength:3}, 2, 2, Quartic.easeInOut);
/*
Transform Properties:
{prop:value ...}
volume
pan
*/
HydroTween.go(sound, {
volume:0}, 2, 2, Quartic.easeOut);
/*
Tint Properties:
{tint:{prop:value ...}}
color
percent
*/
HydroTween.go(mc, {
tint:{color:0xFF0000, percent:.9}}, 2, 2, Quartic.easeOut);
/*
Image Processing Properties:
{image{prop:value ...}}
matrix
brightness
contrast
saturation
hue
*/
HydroTween.go(mc, {
image:{brightness:1, contrast:.9}}, 2, 2, Quartic.easeOut);
/*
Text Properties:
{text{prop:value ...}}
text
text_prepend
text_append
*/
HydroTween.go(textfield, {
text_prepend:"VOTES: ", // String that comes before tweening numbertext:1000// A number that is tweened within the string}, 2, 2, Quartic.easeOut);
/*
Line Properties:
{lineTo{prop:value ...}}
x
y
thickness
color
*/
HydroTween.go(textfield, {lineTo:{
x:580,
thickness:2,
color:0xFF0000
}}, 2, 2, Quartic.easeOut);
_brightness, _saturation, _hue, _contrast are next on my list. I've had them working in some form here and there, but the problem I need to get around is when you are tweening more then one of those properties at once. I'm no tweening guru, so this has been an educational experience. I also started and got results with a _lineTo, but want to get the _curveTo done before releasing it.
HydroTween and Go have successfully consumed my actionscript life again for the last week. I need to get back to some projects that I have procrastinated on:) I am proud to say that I've already used HydroTween/Go on commercial projects and current work.
It's still in it's infancy, but I've made some progress with HydoTween after working with Moses on some different direction with Go over the weekend. During the R&D process with him, I took a little of what we did and merged it into HydroTween. Because Go is still very new and still evolving, it's very likely that HydroTween will evolve quickly as well. I haven't fully tested multiple targets in an array yet, but on individual tweens I've been able to add a number of tweenable features. Also with the help of Grant Skinner's ColorMatrix class, I've added image tweening capability.
Here's an example of using HydroTween. Should be somehwat familiar to Fuse/Zigo users:
I will probably change the sound tweening keys at some point, but you get the idea:)
Next on the list are start props, or what Moses and I discussed as tween "const" variables. Items that are params but aren't necessarily tweenable. Such as quality, filter colors in some instances, etc.
Also I've been out of the Papervision3D loop since xmas, but I'm looking to jump back onto that. I'll have to see if the the guys have made progress on tweening DisplayObject3D with the new version yet.
Go has been progressing quickly as of late. I will begin to post my progress here as well as add HydroTween to the svn at some point.
I discovered a few things when trying to add img tags to html content on a site I have been working on. Mabye this is common knowledge, but I thought I'd share my experience since I had a hard time getting anymore info on it.
Nesting an <a href> tag around an <img> tag doesn't work.
When you embed an image into text using the img tag the image is added to the TextField's DisplayList. For example if you embed an image in the TextField "contentfield", it's the same as doing contentfield.addChild(htmlImage); Which brings me to…
The TextField has a method called getImageReference(id:String):DisplayObject; Basically this method returns the DisplayObject or image that is contained within a given TextField. This is great, but I noticed it only works when there is one image in a TextField. If someone can confirm this, that would be great.
Basically I wanted to link the embedded images in my TextField so the popup a larger version of the image. Simple enough, yet when I wrapped the img tag with an href, the outside of the image would show the hand cursor, but the image wouldn't link. Now if the parent of the img is the TextField, then wouldn't it make sense to have numChildren as a TextField Method? Then I could loop through the children of the text field and create buttons. I've made this request to Adobe, and so far they have been receptive to the idea. Hopefully this will get passed through.
I did however, come up with another way to dynamically load images into a TextField. When loading a swf into a TextField using the img tag you can set the instance name of that swf using the id attribute. I use this id attribute to pass the path to the image, as well as an image id that is passed into the popup window that loads the larger image. Here's an example of the html source that is passed into the TextField.
Turns out when I modify the wiki, the revision number jumps since the wiki is considered a commit. Makes sense since you can edit the wiki locally and upload to the server.
Updates:
Modified the FLV loading so it doesn't use the Playback component source. It does simple streaming, event.file returns the NetStream Object. No more issues of having to link, import, or embed the component code.
Also included is Jesse Graupmann's suggestion and implementation of prioritizing and bundling of sub loaders. Basically it let's you do this:
Currently it requires setting the MIME type manually, but soon it will be set up so that if QueueLoader is in the path, it will recognize it as well. More enhancements and examples of this feature to come.
Here's the updated Flip class using the Go tweening engine:
package com.hydrotik.bannerflip3d{/**
* @author Donovan Adams
* @version December 9, 2007
* @usage Example:<code></code>
* @description
* @history
* @sends
* @todo
*
*/import flash.display.*;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.TimerEvent;
import flash.utils.Timer;
import flash.utils.setTimeout;
import org.papervision3d.cameras.Camera3D;
import org.papervision3d.core.proto.SceneObject3D;
import org.papervision3d.events.FileLoadEvent;
import org.papervision3d.materials.BitmapFileMaterial;
import org.papervision3d.materials.ColorMaterial;
import org.papervision3d.objects.DisplayObject3D;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.render.BasicRenderEngine;
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.view.Viewport3D;
import com.hydrotik.go.PapervisionTween;
import fl.motion.easing.*;
import org.papervision3d.core.proto.MaterialObject3D;
[Event(name="COMPLETE", type="com.hydrotik.bannerflip3d.FlipEvent")][Event(name="ON_FLIP", type="com.hydrotik.bannerflip3d.FlipEvent")]publicclass Flip extends EventDispatcher {publicstatic const VERBOSE:Boolean = true;
privatevar _scope:Sprite;
privatevar _stage:Stage;
privatevar _oCore:*;
privatevar _assetPath:String;
privatevar _materialArray:Array;
privatevar _planeArray:Array;
privatevar _array:XMLList;
privatevar _count:int = 0;
privatevar _next:int;
privatevar _prev:int;
privatevar _loader:Sprite;
privatevar _seconds:int;
//New 2.0 Privatesprivatevar renderer:BasicRenderEngine;
privatevarcamera:Camera3D;
privatevar viewport:Viewport3D;
privatevar debug : Function;
privatevar scene : Scene3D;
privatevar white : MaterialObject3D;
privatevar bg : Plane;
publicfunction Flip(scope:Sprite, stage:Stage, core:*, a:XMLList, assetPath:String = "../flashassets/", s:int = 10):void{
debug = trace;
stage.align = StageAlign.TOP_LEFT;
stage.scaleMode = StageScaleMode.NO_SCALE;
_scope = scope;
_stage = stage;
_oCore = core;
_array = a;
_assetPath = assetPath;
_seconds = s;
_materialArray = [];
_planeArray = [];
scene = new Scene3D();
renderer = new BasicRenderEngine();
camera = new Camera3D();
camera.z = -100;
viewport = new Viewport3D(500,300,true);
viewport.alpha = 0;
_scope.addChild(viewport);
white = new ColorMaterial(0xFFFFFF);
setTimeout(addedToStage, 100);
}privatefunction addedToStage():void{if(VERBOSE) debug("\n\n>> Flip.addedToStage(); - args: "+[]);
_loader = new Sprite();
_loader.graphics.beginFill(0x000000);
_loader.graphics.drawRect(0, 0, 1, 4);
_scope.addChild(_loader);
_loader.x = (_stage.stageWidth/2) - 50;
_loader.y = (_stage.stageHeight/2) - 2;
for(var i:int = 0; i < _array.length(); i++){
_materialArray[i] = new BitmapFileMaterial(_array[i].attribute('src'));
_materialArray[i].oneSide = true;
_materialArray[i].smooth = true;
_materialArray[i].addEventListener(FileLoadEvent.LOAD_PROGRESS, onFileProgress);
_materialArray[i].addEventListener(FileLoadEvent.LOAD_COMPLETE, onFileComplete);
_planeArray[i] = new Plane( _materialArray[i], 300, 156, 6, 6);
scene.addChild(_planeArray[i]);
_planeArray[i].name = i.toString();
_planeArray[i].rotationY = -180;
}// PapervisionTween is extending LinearGo. PapervisionTween is a custom extension using custom syntax, running on the Go system // The init function passes the rendering info so that PapervisionTween can take care of updating the renderer
PapervisionTween.init(renderer, scene, camera, viewport);
}privatefunction onFileProgress(event:FileLoadEvent):void{if(VERBOSE) debug("\t percentage: "+Math.round((event.bytesLoaded/event.bytesTotal)*100) + "%");
var sec:Number = 100/_array.length();
_loader.width = ((_count * sec) + ((event.bytesLoaded/event.bytesTotal)* sec));
}privatefunction onFileComplete(event:FileLoadEvent):void{if(VERBOSE) debug("complete!");
//
_count++;
if(_count == _array.length()){
onImageQueueCompleteHandler();
}}privatefunction onImageQueueCompleteHandler():void{// PapervisionTween is extending LinearGo. PapervisionTween is a custom extension using custom syntax, running on the Go system var l:PapervisionTween = new PapervisionTween(_loader, {alpha:0}, 0, .2, Quintic.easeInOut, loaderFade);
l.start();
// PapervisionTween is extending LinearGo. PapervisionTween is a custom extension using custom syntax, running on the Go system var b:PapervisionTween = new PapervisionTween(_planeArray[0], {rotationY:0}, 0, 1, Quintic.easeInOut, onFlipDone);
b.start();
// PapervisionTween is extending LinearGo. PapervisionTween is a custom extension using custom syntax, running on the Go system var c:PapervisionTween = new PapervisionTween(camera, {z:-100}, 0, 1, Quintic.easeInOut, onFlipDone);
c.start();
_next = 0;
_count = -1;
bg = new Plane(white,5120,2560,10,10);
bg.y = -200;
bg.z = 500;
bg.pitch(0);
scene.addChild(bg);
dispatchEvent(new FlipEvent(FlipEvent.COMPLETE, _next, _array[0].attribute('link'), _array[0].attribute('target')));
var myTimer:Timer = new Timer(_seconds *1000);
myTimer.addEventListener(TimerEvent.TIMER, timerHandler);
myTimer.start();
}privatefunction flip(id:int):void{// PapervisionTween is extending LinearGo. PapervisionTween is a custom extension using custom syntax, running on the Go system var a:PapervisionTween = new PapervisionTween(_planeArray[_next], {rotationY:180}, 0, 1, Quintic.easeInOut, onOldFlipDone);
a.start();
// Update Data
_prev = _next;
_next = (id == _array.length() - 1) ? 0 : id + 1;
varurl:String = _array[_next].attribute('link');
var targ:String = _array[_next].attribute('target');
trace(url, targ);
dispatchEvent(new FlipEvent(FlipEvent.ON_FLIP, _next, url, targ));
// PapervisionTween is extending LinearGo. PapervisionTween is a custom extension using custom syntax, running on the Go system var b:PapervisionTween = new PapervisionTween(_planeArray[_next], {rotationY:0}, 0, 1, Quintic.easeInOut, onFlipDone);
b.start();
// PapervisionTween is extending LinearGo. PapervisionTween is a custom extension using custom syntax, running on the Go system var c:PapervisionTween = new PapervisionTween(camera, {z:-350}, 0, .5, Quintic.easeIn, onCameraHalf);
c.start();
}privatefunction onCameraHalf(event:Event = null):void{
viewport.alpha = 1;
var c:PapervisionTween = new PapervisionTween(camera, {z:-100}, 0, .5, Quintic.easeOut);
c.start();
}publicfunction timerHandler(event:TimerEvent):void{if(VERBOSE) debug("timerHandler: " + event);
_count = (_count == _array.length() - 1) ? 0 : _count + 1;
flip(_count);
}privatefunction onFlipDone(event:Event = null):void{if(VERBOSE) debug("flip done!");
}privatefunction loaderFade(event:Event = null):void{
viewport.alpha = 1;
_scope.removeChild(_loader);
}privatefunction onOldFlipDone(event:Event = null):void{if(VERBOSE) debug("old flip done!");
_planeArray[_prev].rotationY = -180;
}}}
And if you are curious here is the PapervisionTween extension of Go:
/**
* Copyright (c) 2007 Moses Gunesch, MosesSupposes.com - Donovan Adams, blog.hydrotik.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package com.hydrotik.go{import flash.display.DisplayObject;
import org.fuseproject.go.items.LinearGo;
import org.papervision3d.objects.DisplayObject3D;
//import flash.geom.ColorTransform;//import flash.filters.BlurFilter;//import flash.geom.Point; /**
* A basic example of how you could build a tween on LinearGo.
*/publicclass PapervisionTween extends LinearGo {// -== Public Properties ==-publicfunctiongetwidth() : Number{return _rotationY;
}publicfunctionsetwidth(value : Number) : void{if(_state == STOPPED)
_rotationY = value;
}publicfunctionget startWidth() : Number{return _startRotationY;
}publicfunctionset startWidth(value : Number) : void{if(_state == STOPPED)
_startRotationY = value;
}publicfunctiongettarget() : DisplayObject {return_target;
}publicfunctionsettarget(obj : DisplayObject) : void{if(_state == STOPPED)_target = obj;
}// -== Protected Properties ==-
protected var_target : *;
protected var _rotationY : Number;
privatestaticvar _viewport:*;
privatestaticvar _camera:*;
privatestaticvar _scene:*;
privatestaticvar _renderer : *;
privatevar _closure : Function;
privatevar debug : Function;
protected var _startRotationY : Number;
protected var _changeRotationY : Number;
protected var _startProps : Object = {};
protected var _changeProps : Object = {};
protected var _propsTo : Object = {};
publicstaticfunction init(renderer:*, scene:*, camera:*, viewport:*):void{
_renderer = renderer;
_scene = scene;
_camera = camera;
_viewport = viewport;
}// -== Public Methods ==-publicfunction PapervisionTween(target:* = null,
propsTo:Object = null,
delay:Number = NaN,
duration:Number = NaN,
easing:Function = null,
closure:Function = null){super(delay, duration, easing);
debug = trace;
_target = target;
if(closure != null) addCallback(closure);
for(var prop in propsTo){switch(prop){case"alpha":
if(_target is DisplayObject){
_propsTo[prop] = (propsTo[prop]!= undefined) ? propsTo[prop] : _target[prop];
}if(_target is DisplayObject3D){if(propsTo[prop]!= undefined){
_propsTo[prop] = propsTo[prop];
}else{_target.extra[prop] = newNumber(1);
_propsTo[prop] = _target.extra[prop] = _target.extra[prop];
}}break;
default:
_propsTo[prop] = (propsTo[prop]!= undefined) ? propsTo[prop] : _target[prop];
}}}
override publicfunctionstart() :Boolean{if(!_target)returnfalse;
var prop:String;
for(prop in _propsTo){switch(prop){case"alpha":
if(_target is DisplayObject){
_startProps[prop] = _target[prop];
}if(_target is DisplayObject3D){trace("start: "+_target.extra[prop]);
_startProps[prop] = _target.extra[prop];
}break;
default:
_startProps[prop] = _target[prop];
}}if(useRelative){for(prop in _propsTo){
_changeProps[prop] = _propsTo[prop];
}}else{for(prop in _propsTo){
_changeProps[prop] = (_propsTo[prop] - _startProps[prop]); //_propsTo[prop];}}return(super.start());
}//TODO add alpha tweening syntax when released in 2.0 update
override protected functiononUpdate(type:String) : void{for(var prop in _propsTo){switch(prop){case"alpha":
if(_target is DisplayObject3D){//var val:Number = super.correctValue(_startProps[prop] + _changeProps[prop] * _position);//_target.material.bitmap.colorTransform(_target.material.bitmap.rect, new ColorTransform(1, 1, 1, val, 0, 0, 0, 0));//_target.extra[prop] = val;
debug("Current version of Pv3D does not support alpha tweening");
}if(_target is DisplayObject)_target[prop] = super.correctValue(_startProps[prop] + _changeProps[prop]* _position);
break;
default:
_target[prop] = super.correctValue(_startProps[prop] + _changeProps[prop]* _position);
}}if(_target is DisplayObject3D) _renderer.renderScene(_scene,_camera,_viewport);
}}}
I plan on adding effects as well as the alpha property when 2.0 is able to support that. Shadows, layer effects, and more still to come!