(root)/iphone/tappity : 60 : common/source/ElAnimation.m

//

//  ElAnimation.m

//  Jigs

//

//  Created by döme on 11.08.2009.

//  Copyright 2009 __MyCompanyName__. All rights reserved.

//

 

#import "ElAnimation.h"

 

#import <mach/mach_time.h>

#import "geometry.h"

 

float linearInterpolation(float a, float b, float t)

{

        return a + t*(b-a);

}

 

float easyOutInterpolation(float a, float b, float t)

{

        return a + t*t*(b-a);

}

 

float easyInInterpolation(float a, float b, float t)

{

        float x = t-1.0f;

        return a + (1.0f - x*x)*(b-a);

}

 

float smoothInterpolation(float a, float b, float t)

{

        return a + (3*t*t - 2*t*t*t)*(b-a);

}

 

@interface ElAnimationController : NSObject

{

        NSMutableDictionary*            queuedAnimations;

        NSTimeInterval                          lastTime;

 

        mach_timebase_info_data_t       timebase;

        uint64_t                                        machTimingStart;

}

+ (ElAnimationController*) sharedController;

 

- (void) queueAnimation: (ElAnimation*) anim forKey: (id) key atBeginning: (BOOL) atBegin cancelPending: (BOOL) cancelPending;

- (NSTimeInterval) now;

 

@end;

 

 

@implementation ElAnimation

 

- (void) queueForKey: (NSString*) key atBeginning: (BOOL) atBeginning cancelPending: (BOOL) cancelPending;

{

        [[ElAnimationController sharedController] queueAnimation: self forKey: key atBeginning: atBeginning cancelPending: cancelPending];

}

 

- (BOOL) animateForTime: (NSTimeInterval) time delta: (NSTimeInterval) deltaTime

{

        if (time > startTime + duration)

                return NO;

        else

                return YES;

}

 

+ (NSTimeInterval) now

{

        return [[ElAnimationController sharedController] now];

}

 

- (void) setStartTime: (NSTimeInterval) time

{

        startTime = time;

}

- (NSTimeInterval) startTime

{

        return startTime;

}

 

+ (ElAnimation*) delayedAnimationWithDelay: (float) seconds

{

        ElAnimation* anim = [[[ElAnimation alloc] init] autorelease];

        [anim setDuration: seconds];

        return anim;

}

 

@synthesize duration, interpolation;

 

@end

 

@implementation ElFloatAnimation

 

- (BOOL) animateForTime: (NSTimeInterval) time delta: (NSTimeInterval) delta

{

        BOOL result = [super animateForTime: time delta: delta];

 

        double t = fclamp((time - startTime)/duration, 0.0, 1.0);

        

        float y = 0.0;

        switch (interpolation)

        {

                case kElLinearInterpolation:

                        y = linearInterpolation(startValue, endValue, t);

                        break;

                case kElEaseInInterpolation:

                        y = easyInInterpolation(startValue, endValue, t);

                        break;

                case kElEaseOutInterpolation:

                        y = easyOutInterpolation(startValue, endValue, t);

                        break;

                case kElSmoothInterpolation:

                        y = smoothInterpolation(startValue, endValue, t);

                        break;

        }

        

        [target setValue: [NSNumber numberWithFloat: y] forKey: property];

 

        return result;

}

 

- (void) dealloc

{

        [target release];

        [super dealloc];

}

 

@synthesize startValue, endValue, target, property;

 

@end

 

@implementation ElV3Animation

 

- (BOOL) animateForTime: (NSTimeInterval) time delta: (NSTimeInterval) delta

{

        BOOL result = [super animateForTime: time delta: delta];

 

        double t = fclamp((time - startTime)/duration, 0.0, 1.0);

        

        v3 y = vcreate(0.0f, 0.0f, 0.0f);

        switch (interpolation)

        {

                case kElLinearInterpolation:

                        y.v.x = linearInterpolation(startv.v.x, endv.v.x, t);

                        y.v.y = linearInterpolation(startv.v.y, endv.v.y, t);

                        y.v.z = linearInterpolation(startv.v.z, endv.v.z, t);

                        break;

                case kElEaseInInterpolation:

                        y.v.x = easyInInterpolation(startv.v.x, endv.v.x, t);

                        y.v.y = easyInInterpolation(startv.v.y, endv.v.y, t);

                        y.v.z = easyInInterpolation(startv.v.z, endv.v.z, t);

                        break;

                case kElEaseOutInterpolation:

                        y.v.x = easyOutInterpolation(startv.v.x, endv.v.x, t);

                        y.v.y = easyOutInterpolation(startv.v.y, endv.v.y, t);

                        y.v.z = easyOutInterpolation(startv.v.z, endv.v.z, t);

                        break;

                case kElSmoothInterpolation:

                        y.v.x = smoothInterpolation(startv.v.x, endv.v.x, t);

                        y.v.y = smoothInterpolation(startv.v.y, endv.v.y, t);

                        y.v.z = smoothInterpolation(startv.v.z, endv.v.z, t);

                        break;

        }

        

        [target performSelector: setter withObject: (void*)&y];

 

        return result;

}

 

- (void) dealloc

{

        [target release];

        [super dealloc];

}

 

@synthesize startv, endv, target, setter;

 

@end

 

 

@implementation ElAnimationController

 

- (id) init

{

        if (!(self = [super init]))

                return nil;

 

        queuedAnimations = [[NSMutableDictionary alloc] init];

 

        mach_timebase_info(&timebase);

        machTimingStart = mach_absolute_time();

 

        return self;

}

 

- (NSTimeInterval) currentTime

{

        uint64_t mtime = mach_absolute_time();

        

        uint64_t elapsed = mtime - machTimingStart;

        

        return (NSTimeInterval)((elapsed*timebase.numer)/timebase.denom)*1e-9;

}

 

+ (id) sharedController

{

        static ElAnimationController* sharedController = nil;

        if (!sharedController)

                sharedController = [[ElAnimationController alloc] init];

        return sharedController;

}

 

- (void) timerCallback

{

        NSTimeInterval time = [self currentTime];

        NSTimeInterval delta = time - lastTime;

        

//      NSLog(@"%f %f", time, delta);

        

        NSMutableArray* keysToRemove = [NSMutableArray array];

        for (id key in queuedAnimations)

        {

                NSMutableArray* animArray = [queuedAnimations objectForKey: key];

                if (![animArray count])

                {

                        [keysToRemove addObject: key];

                        continue;

                }

                

                ElAnimation* anim = [animArray objectAtIndex: 0];

                

                if ([anim startTime] == 0.0)

                        [anim setStartTime: lastTime];

                        

                [anim animateForTime: time delta: delta];

 

                if ([anim startTime] + [anim duration] < time)

                {

                        [animArray removeObjectAtIndex: 0];

                        //NSLog(@"dequeued animation");

                }

        }

        [queuedAnimations removeObjectsForKeys: keysToRemove];

        lastTime = time;

}

 

- (void) queueAnimation: (ElAnimation*) anim forKey: (id) key atBeginning: (BOOL) atBeginning cancelPending: (BOOL) cancelPending

{

        static NSTimer* animationTimer = nil;

        if (!animationTimer)

        {

                animationTimer = [NSTimer scheduledTimerWithTimeInterval: 0.01 target: self selector: @selector(timerCallback) userInfo: nil repeats: YES];

                lastTime = [self currentTime];

        }

        

        if (!key)

                key = [NSNull null];

        

        NSMutableArray* animArray = [queuedAnimations objectForKey: key];

        if (!animArray)

        {

                animArray = [NSMutableArray array];

                [queuedAnimations setObject: animArray forKey: key];

        }

        

        if (!cancelPending && !atBeginning)

                [animArray addObject: anim];

        else if (cancelPending && !atBeginning)

        {

                if ([animArray count] > 1)

                        [animArray removeObjectsInRange: (NSRange){1, [animArray count]-1}];

                [animArray addObject: anim];

        }

        else if (!cancelPending && atBeginning)

        {

                if ([animArray count])

                        [animArray replaceObjectAtIndex: 0 withObject: anim];

                else

                        [animArray addObject: anim];

        }

        else

        {

                [animArray removeAllObjects];

                [animArray addObject: anim];

        }

}

 

- (NSTimeInterval) now

{

        return lastTime;

}

 

@end

 

NSString*       AnimationAbsoluteTimeKey = @"animationAbsoluteTime";

NSString*       AnimationPassedTimeKey  = @"animationPassedTime";

NSString*       AnimationDeltaTimeKey   = @"animationDeltaTime";

NSString*       AnimationUserInfoKey    = @"animationUserInfo";

 

@implementation ElCallbackAnimation

 

- (BOOL) animateForTime: (NSTimeInterval) time delta: (NSTimeInterval) delta

{

        BOOL result = [super animateForTime: time delta: delta];

 

        NSDictionary* dict = [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithDouble: time], AnimationAbsoluteTimeKey, [NSNumber numberWithDouble: time - startTime], AnimationPassedTimeKey, [NSNumber numberWithDouble: delta], AnimationDeltaTimeKey, userInfo, AnimationUserInfoKey, nil];

 

        

        [target performSelector: callback withObject: dict];

 

        return result;

}

 

- (void) dealloc

{

        [target release];

        [userInfo release];

        [super dealloc];

}

 

@synthesize target, userInfo, callback;

 

@end