AdamRedwoods Animation Tween Module

Monkey Forums/Monkey Code/AdamRedwoods Animation Tween Module

AdamRedwoods

(Posted 2011) [#1]

Here's a tween module for people to use. It's robust, but requires some setup on the programmers part. I didn't make an elegant class package (for various reasons), but it's not hard to do.

Features:
- layerable to create custom effects
- reversable, hold on last state
- written with performance in mind
- Added SetAlphaINOUT(handle, step, duration in ms ) for easy fadein/out of images

Todo:
- color tweens
- wrap another class around this to make tweens automatic

Usage:
- tweens are in format Command(unique handle, step, start, end, starty, endy)
- layer tweens in order: Translate, Scale, Rotate
- default setting is EaseOut, optional EaseIn available
- you need to make global handles for each tween (a simple process), it's nice to keep them in a class as a global

Example:

''Do this however you want, but you need to provide unique integers per tween set
Class Tweennum
	Global tweenForImage1:int = 1
	Global othertween:int = 2
End

'' (in Main Routine)
''create a trigger and begin the tween

If someTrigger
	Tween.Begin(Tweennum.tweenForImage1)
	Tween.EaseIn(Tweennum.tweenForImage1)
	someTrigger =0
EndIf

If Tween.IsActive(Tweennum.tweenForImage1)
	''if you need x,y position set that before rotation
	Translate(x,y)

	Tween.Rotate(Tweennum.tweenForImage1, 0.1, 0, 360)
	
	''will fade in as well
	Tween.SetAlpha(Tweennum.tweenForImage1, 0.1, 0.0, 1.0)
	
	DrawImage image1,0,0
	
	''restore will wipe out any previous matrix commands, colors, and alphas, and return to normal drawing operations
	Tween.Restore()
	
	''to chain tweens, add another trigger:
	If Not Tween.IsActive(Tweennum.tweenForImage1)
		Tween.Begin(Tweennum.othertween)
	endif

Else
	''hold image when finished use this:
	Translate(x,y)
	UseFinalState(Tweennum.tweenForImage1)
	DrawImage image1,0,0
	Tween.Restore()

EndIf

'' Animation Tween class
'' Adam of the Redwoods 2011

''usage:
'' - layer tweens in order: Translate, Scale, Rotate
'' - default set to EaseOut
'' - make global handles for each tween (you need to do this yourself)
'' - it's nice to keep them in the class as a global

Import mojo

Class Tween
	Const MAXTWEENOBJ:Int = 30 ''up to 30 sets, add more if you like
	
	Const TWALPHA:Int = 1
	Const TWTRANS:Int = 2
	Const TWROT:Int = 4
	Const TWSCALE:Int = 8
	
	Global tween:TweenObj[MAXTWEENOBJ]
	
	
	
	Function SetAlpha:Float(  var:Int, st:Float, startx:Float=0.0, endx:Float=1.0)
		If Not tween[var] Then Return

		If tween[var].dir < 0
			Local temp:Float
			temp = startx
			startx = endx
			endx = temp
		Endif
		
		tween[var].otherTweens = tween[var].otherTweens | TWALPHA
		
		mojo.SetAlpha(tween[var].alpha)
		
		Local dif:Float = (startx - endx)
		Local a:Float
		
		If tween[var].easing >= 0
			a = tween[var].alpha - dif*st
		Else
			If dif <0 Then a = tween[var].alpha + tween[var].alpha *st Else a = tween[var].alpha - tween[var].alpha *st
		Endif

		If (dif<0.0) And a > endx Then a=endx Elseif (dif>0.0) And (a-0.01)<endx Then a=endx
		tween[var].alpha = a
		
		''turn off only is there's no other tweens
		
		If a=endx And Not tween[var].alphaAction
			If Not ( (~ TWALPHA) & tween[var].otherTweens) Then tween[var].dir=0
			tween[var].otherTweens = (~ TWALPHA) & tween[var].otherTweens
		'Elseif a=endx And tween[var].action =2
			'tween[var].dir = tween[var].dir * -1
		Endif
		
		Return a
	End
	
	Function Translate:Void(  var:Int, st:Float, startx:Float=0.0, endx:Float=0.0, starty:Float=0.0, endy:Float=0.0)
		If Not tween[var] Then Return
		
		If tween[var].dir < 0
			Local temp:Float
			temp = startx
			startx = endx
			endx = temp
		Endif
		
		tween[var].otherTweens = tween[var].otherTweens | TWTRANS
		
		Local difx:Float = startx - endx
		Local dify:Float = starty - endy
		Local x:Float, y:Float
		
		mojo.Transform(1.0,0,0,1.0,-tween[var].x + startx,-tween[var].y + starty)
		
		tween[var].lastx = -tween[var].x + startx
		tween[var].lasty = -tween[var].y + starty
		
		If tween[var].easing >= 0
			x = tween[var].x - (tween[var].x - difx)*st 
			y = tween[var].y - (tween[var].y - dify)*st
		Else
			Local kick:Float = 0.0 ''keep values from getting too small
			If difx<0 Then kick = -0.1 Else If difx>0 Then kick = 0.1
			x = tween[var].x + (tween[var].x)*st +kick
			kick = 0.0
			If dify<0 Then kick = -0.1 Else If dify>0 Then kick = 0.1
			y = tween[var].y + (tween[var].y)*st +kick
		Endif
		
	'Print "t:"+x+" d "+(-difx)
		If (difx<0.0) And x > -difx Then x=-difx Elseif (difx>0.0) And x>difx Then x=difx 
		If (dify<0.0) And y > -dify Then y=-dify Elseif (dify>0.0) And y>dify Then y=dify
		
		tween[var].x = x
		tween[var].y = y
		
		''turn off only is there's no other tweens
		If Abs(tween[var].x - difx) < 1.0 And Abs(tween[var].y - dify) < 1.0 And Not tween[var].transAction
			If Not ( (~ TWTRANS) & tween[var].otherTweens) Then tween[var].dir = 0
			tween[var].otherTweens = (~ TWTRANS) & tween[var].otherTweens
		Endif
		
		Return
	End
	
	Function Scale:Void(  var:Int, st:Float, startx:Float=1.0, endx:Float=2.0, starty:Float=1.0, endy:Float=1.0)
		If Not tween[var] Then Return
		
		If tween[var].dir < 0
			Local temp:Float
			temp = startx
			startx = endx
			endx = temp
		Endif
		
		tween[var].otherTweens = tween[var].otherTweens | TWSCALE
		
		Local difx:Float = startx - endx
		Local dify:Float = starty - endy
		Local x:Float, y:Float
		
		mojo.Scale(-tween[var].scalex + startx,-tween[var].scaley + starty)
		
		tween[var].lastscx = -tween[var].scalex + startx
		tween[var].lastscy = -tween[var].scaley + starty
		
		If tween[var].easing >= 0
			x= tween[var].scalex - (tween[var].scalex - difx)*st 
			y= tween[var].scaley - (tween[var].scaley - dify)*st
		Else
			Local kick:Float = 0.0 ''keep values from getting too small
			If difx<0 Then kick = -0.005 Else If difx>0 Then kick = 0.005
			x= tween[var].scalex + (tween[var].scalex )*st + kick
			kick =0.0
			If dify<0 Then kick = -0.005 Else If dify>0 Then kick = 0.005
			y= tween[var].scaley + (tween[var].scaley )*st + kick
		Endif 
		
	'Print "s:"+x+" d "+difx
		If (difx<0.0) And x < difx Then x=difx Elseif (difx>0.0) And x>difx Then x=difx 
		If (dify<0.0) And y < dify Then y=dify Elseif (dify>0.0) And y>dify Then y=dify
		
		tween[var].scalex = x
		tween[var].scaley = y
			
		''turn off only is there's no other tweens
		If Abs(x - difx) < 0.1 And Abs(y - dify) < 0.1 And Not tween[var].scaleAction
			If Not ( (~ TWSCALE) & tween[var].otherTweens) Then tween[var].dir = 0 
			tween[var].otherTweens = (~ TWSCALE) & tween[var].otherTweens
		Endif
		
		Return
	End
	
	Function Rotate:Float(  var:Int, st:Float, startx:Float=0.0, endx:Float=360.0)
		If Not tween[var] Then Return
		
		If tween[var].dir < 0
			Local temp:Float
			temp = startx
			startx = endx
			endx = temp
		Endif
		
		tween[var].otherTweens = tween[var].otherTweens | TWROT
		
		Local rot:Float
		Local dif:Float = startx - endx
		Local ang:Float = tween[var].rot + startx
		Local ca:Float = Cos(ang)
		Local sa:Float = Sin(ang)
		mojo.Transform(ca,-sa,sa,ca, 0,0)
		
		If tween[var].easing >= 0
			rot = tween[var].rot - (tween[var].rot - dif)*st
		Else
			Local kick:Float = 0.0
			If dif<0 Then kick = -0.1 Else If dif>0 Then kick = 0.1
			rot = tween[var].rot + (tween[var].rot)*st + kick
		Endif
	
	'Print "r: "+rot	+" d "+dif
		If (dif<0.0) And rot < dif Then rot=dif Elseif (dif>0.0) And rot>dif Then rot=dif 
		
		tween[var].rot = rot

		''turn off only is there's no other tweens
		If Abs(rot - dif) < 1.0
			If Not ( (~ TWROT) & tween[var].otherTweens) Then tween[var].dir = 0 And Not tween[var].rotAction
			tween[var].otherTweens = (~ TWROT) & tween[var].otherTweens
			
		Endif
		
		tween[var].lastang = ang
		
		Return ang
	End
	
	''SetAlphaINOUT
	''create our own function for bouncing, as to not disturb other tweens
	
	Function SetAlphaINOUT:Float( var:Int, st:Float, dur:Int)
		If Not tween[var] Then Return 0.0
		
		If Not tween[var].alphaAction Then tween[var].alphaAction = 1
		
		If tween[var].alphaAction = 1
			If SetAlpha( var, st, 0.0, 1.0) >= 1.0
				tween[var].pause = Millisecs()
				tween[var].alphaAction = 2
			Endif
		Elseif tween[var].alphaAction = 2
			If tween[var].pause > Millisecs() -dur
				''pause
			Else
				''fadeout
				If SetAlpha( var, st, 1.0, 0.0) <= 0.0
					If Not ( (~ TWALPHA) & tween[var].otherTweens) Then tween[var].dir = 0
					tween[var].alphaAction = 2
				Endif
			Endif
		Endif
		Return tween[var].alpha
	End
	
	
	Function GetAlpha:Float(var:Int)
		If Not tween[var] Then Return 0.0
		Return tween[var].alpha
	End
	
	''Begin(handle, start variable: x,y or alpha or rotation)
	'' - will reset any prior tweens on that handle
	Function Begin(var:Int, x:Float=0.01, y:Float = 0.0)
		If Not tween[var] Then tween[var] = New TweenObj
		tween[var].alpha = x
		tween[var].x = x
		tween[var].y = y
		tween[var].scalex = 0.0
		tween[var].scaley = 0.0
		tween[var].rot = x
		tween[var].pause = Millisecs()
		tween[var].dir = 1
		tween[var].alphaAction = 0
		tween[var].transAction = 0
		tween[var].scaleAction = 0
		tween[var].rotAction = 0
		tween[var].otherTweens = 0
	End
	
	Function IsActive?(var:Int)
		If Not tween[var] Then Return False
		If tween[var].dir <>0 Then Return True
		Return False
	End
	
	'' UseFinalState(handle)
	'' - this function is when you want to HOLD on your last tween frame, when the tween is NOT active (IsActive())
	'' - this function is faster than running persistant tweens
	'' - if this runs before your first tween, the alpha is 0.0
	'' - could be used like : If Not (FinalMatrix(handle)) Then DoTweenHere()
	
	Function UseFinalState:Int(var:Int)
		If Not tween[var] Then Return 0
		If IsActive(var) Then Return 0

		mojo.SetAlpha(tween[var].alpha)
		Local ca:Float = Cos(tween[var].lastang)
		Local sa:Float = Sin(tween[var].lastang)
		Local scx:Float = tween[var].lastscx
		Local scy:Float = tween[var].lastscy
		
		''use mojo.Transform so we can overlap tweens, but mojo.SetMatrix would be faster
		mojo.Transform(ca*scx,-sa*scy,sa*scy,ca*scx,tween[var].lastx,tween[var].lasty)
		 
		Return 1

	End
	
	Function EaseOut(var:Int)
		tween[var].easing = 1
	End
	Function EaseIn(var:Int)
		tween[var].easing = -1
	End
	Function SetBounce(var:Int)
		tween[var].action = 2 ''future use
	End
	Function SetReverse(var:Int)
		tween[var].dir = tween[var].dir * -1
	End
	
	Function Restore()
		mojo.SetAlpha(1.0)
		SetMatrix(1.0,0,0,1.0,0,0)
		mojo.SetColor(255,255,255)
	End
	
End

Class TweenObj
	Field x:Float
	Field y:Float
	Field scalex:Float = 1.0
	Field scaley:Float = 1.0
	Field rot:Float
	Field alpha:Float = 0.0
	Field easing:Int = 1
	Field pause:Int =0
	Field dir:Int =0
	'Field action:Int=0 ''future use 1=hold, 2=bounce
	Field alphaAction:Int =0
	Field transAction:Int =0
	Field scaleAction:Int =0
	Field rotAction:Int =0
	
	Field otherTweens:Int = 0 ''used to allow all tweens to finish
	
	''persistance
	Field lastang:Float = 0.0
	Field lastx:Float = 0.0
	Field lasty:Float = 0.0
	Field lastscx:Float = 1.0
	Field lastscy:Float = 1.0
End

Martian Watts

(Posted 2012) [#2]

It's really helpfull! I will to use it..