Max 5 API Reference

jit.transfer.ease.c

/*
 * jit.transfer.ease.c
 *
 * Copyright 2001-2005 - Cycling '74
 * Derek Gerstmann - derek@cycling74.com
 *
 * Base on Richard Parent's ease-in/ease-out curve presented in
 * his textbook on Computer Animation, 2nd Ed.
 *
 * This method uses parabolic blending at the end points                          *
 * First leg has constant acceleration from 0 to v during time 0 to t1 
 * Second leg has constant velocity of v during time t1 to t2          
 * Third leg has constant deceleration from v to 0 during time t2 to 1 
 * These are integrated to get the 'distance' traveled at any time     
 */

// --------------------------------------------------------------------------

#include "jit.common.h"
#include "jit.functor.h"

// --------------------------------------------------------------------------

typedef struct _jit_functor_transfer_ease
{
    t_jit_object                    ob;
    t_jit_functor_combined_value    start;
    t_jit_functor_combined_value    end;
} t_jit_functor_transfer_ease;

// --------------------------------------------------------------------------

t_jit_object *jit_functor_transfer_ease_new(void);
t_jit_err jit_functor_transfer_ease_free(t_jit_functor_transfer_ease *x);
t_jit_err jit_functor_transfer_ease_setattr_beta(t_jit_functor_transfer_ease *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_transfer_ease_recalc(t_jit_functor_transfer_ease *x);

long jit_functor_transfer_ease_eval_fixed(t_jit_functor_transfer_ease *x, long dimcount, long *vals);
float jit_functor_transfer_ease_eval_float32(t_jit_functor_transfer_ease *x, long dimcount, float *vals);
double jit_functor_transfer_ease_eval_float64(t_jit_functor_transfer_ease *x, long dimcount, double *vals);
long jit_functor_transfer_ease_eval_fixed_scalar(t_jit_functor_transfer_ease *x, long val);
float jit_functor_transfer_ease_eval_float32_scalar(t_jit_functor_transfer_ease *x, float val);
double jit_functor_transfer_ease_eval_float64_scalar(t_jit_functor_transfer_ease *x, double val);

t_class * _jit_functor_transfer_ease_class;

// --------------------------------------------------------------------------

t_jit_err jit_functor_transfer_ease_init(void)
{
    t_jit_object *attr;

    // create the functor class
    _jit_functor_transfer_ease_class = jit_class_new("jit_functor_transfer_ease",
        (method)jit_functor_transfer_ease_new,(method)jit_functor_transfer_ease_free,
        sizeof(t_jit_functor_transfer_ease),0L);

    // add attribute methods
    attr = jit_object_new(_jit_sym_jit_attr_offset,"start",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_transfer_ease_setattr_start,
        calcoffset(t_jit_functor_transfer_ease,start.float64));
    jit_class_addattr(_jit_functor_transfer_ease_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"end",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_transfer_ease_setattr_end,
        calcoffset(t_jit_functor_transfer_ease,end.float64));
    jit_class_addattr(_jit_functor_transfer_ease_class,attr);

    // add evaluation methods
    jit_class_addmethod(_jit_functor_transfer_ease_class, 
        (method)jit_functor_transfer_ease_eval_fixed, "evalfixed", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_transfer_ease_class, 
        (method)jit_functor_transfer_ease_eval_float32, "evalfloat32", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_transfer_ease_class, 
        (method)jit_functor_transfer_ease_eval_float64, "evalfloat64", A_CANT, 0L);

    // important to add last for subclassing methods
    jit_functor_setup_class(_jit_functor_transfer_ease_class,"transfer","ease");
    jit_class_register(_jit_functor_transfer_ease_class);

    return JIT_ERR_NONE;
}

t_jit_object *jit_functor_transfer_ease_new(void)
{
    t_jit_functor_transfer_ease *x;

    if (x = (t_jit_functor_transfer_ease *)jit_object_alloc(_jit_functor_transfer_ease_class)) {

        // initialization
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->start, 0.0);
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->end, 1.0);
        jit_functor_transfer_ease_recalc(x);
    }

    return (t_jit_object *)x;
}

t_jit_err jit_functor_transfer_ease_free(t_jit_functor_transfer_ease *x)
{
    return JIT_ERR_NONE;
}

t_jit_err jit_functor_transfer_ease_setattr_start(
    t_jit_functor_transfer_ease *x, void *attr, long argc, t_atom *argv)
{
    double v;

    if (x) 
    {
        v = jit_atom_getfloat(argv);
        if (x->start.float64 != v) 
        {
            JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->start, v);
            jit_functor_transfer_ease_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_transfer_ease_setattr_end(
    t_jit_functor_transfer_ease *x, void *attr, long argc, t_atom *argv)
{
    double v;

    if (x) 
    {
        v = jit_atom_getfloat(argv);
        if (x->end.float64 != v) 
        {
            JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->end, v);
            jit_functor_transfer_ease_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_transfer_ease_recalc(t_jit_functor_transfer_ease *x)
{
    // calculate intermediary values for efficiency
    return JIT_ERR_NONE;
}

// --------------------------------------------------------------------------
// vector evaluation functions (calls scalar functions and generates a product of scalar evaluation for each dimension)
// --------------------------------------------------------------------------
long jit_functor_transfer_ease_eval_fixed(t_jit_functor_transfer_ease *x, long dimcount, long *vals)
{
    return jit_functor_eval_fixed_with_float64((t_jit_object *)x,dimcount,vals,
            (t_jit_functor_float64_sig)jit_functor_transfer_ease_eval_float64);
}

float jit_functor_transfer_ease_eval_float32(t_jit_functor_transfer_ease *x, long dimcount, float *vals)
{
    return jit_functor_eval_float32_with_scalar_product((t_jit_object *)x,dimcount,vals,
            (t_jit_functor_float32_scalar_sig)jit_functor_transfer_ease_eval_float32_scalar);
}

double jit_functor_transfer_ease_eval_float64(t_jit_functor_transfer_ease *x, long dimcount, double *vals)
{
    return jit_functor_eval_float64_with_scalar_product((t_jit_object *)x,dimcount,vals,
            (t_jit_functor_float64_scalar_sig)jit_functor_transfer_ease_eval_float64_scalar);
}

// --------------------------------------------------------------------------
// scalar evaluation functions
// --------------------------------------------------------------------------
long jit_functor_transfer_ease_eval_fixed_scalar(t_jit_functor_transfer_ease *x, long val)
{
    return FloatToFixed(jit_functor_transfer_ease_eval_float32_scalar(x,FixedToFloat(val)));
}

float jit_functor_transfer_ease_eval_float32_scalar(t_jit_functor_transfer_ease *x, float val)
{
    float ans,s,a,b,c,nt,rt;
    float v,a1,a2;
    float t = val;
    float t1 = x->start.float32;
    float t2 = x->end.float32;

    // constant velocity attained
    v = 2/(1+t2-t1);  
    
    // acceleration of first leg
    a1 = v/t1;        
    
    // deceleration of last leg
    a2 = -v/(1-t2);   
    if (t<t1) 
    {
        // pos = 1/2 * acc * t*t
        rt = 0.5*a1*t*t;       
    }
    else if (t<t2) 
    {
        // get distance from start
        a = 0.5*a1*t1*t1;      
        
        // distance = vel * time of end
        b = v*(t-t1);            
        rt = a + b;
    }
    else 
    {
        // get distance from start
        a = 0.5*a1*t1*t1;
        
        // get distance from end
        b = v*(t2-t1);           
        
        // distance = ave vel. * time 
        c = ((v + v + (t-t2)*a2)/2) * (t-t2);
        rt = a + b + c;
    }
    return(rt);
}

double jit_functor_transfer_ease_eval_float64_scalar(t_jit_functor_transfer_ease *x, double val)
{
    double ans,s,a,b,c,nt,rt;
    double v,a1,a2;
    double t = val;
    double t1 = x->start.float64;
    double t2 = x->end.float64;

    // constant velocity attained
    v = 2/(1+t2-t1);  
    
    // acceleration of first leg
    a1 = v/t1;        
    
    // deceleration of last leg
    a2 = -v/(1-t2);   
    if (t<t1) 
    {
        // pos = 1/2 * acc * t*t
        rt = 0.5*a1*t*t;       
    }
    else if (t<t2) 
    {
        // get distance from start
        a = 0.5*a1*t1*t1;      
        
        // distance = vel * time of end
        b = v*(t-t1);            
        rt = a + b;
    }
    else 
    {
        // get distance from start
        a = 0.5*a1*t1*t1;
        
        // get distance from end
        b = v*(t2-t1);           
        
        // distance = ave vel. * time 
        c = ((v + v + (t-t2)*a2)/2) * (t-t2);
        rt = a + b + c;
    }
    return(rt);
}
// --------------------------------------------------------------------------

Copyright © 2008, Cycling '74