Max 5 API Reference

jit.transfer.smoothpulse.c

/*
 *  jit.transfer.smoothpulse.c
 *
 *  Copyright 2001-2005 - Cycling '74
 *  Derek Gerstmann - derek@cycling74.com
 *
 *  functor for a transfer smoothed pulse
 *
 */

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

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

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

typedef struct _jit_functor_transfer_smoothpulse
{
    t_jit_object    ob;
    double          startlow;
    double          starthigh;
    double          endlow;
    double          endhigh;
} t_jit_functor_transfer_smoothpulse;

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

t_jit_object *jit_functor_transfer_smoothpulse_new(void);
t_jit_err jit_functor_transfer_smoothpulse_free(t_jit_functor_transfer_smoothpulse *x);
t_jit_err jit_functor_transfer_smoothpulse_startlow(t_jit_functor_transfer_smoothpulse *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_transfer_smoothpulse_starthigh(t_jit_functor_transfer_smoothpulse *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_transfer_smoothpulse_endlow(t_jit_functor_transfer_smoothpulse *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_transfer_smoothpulse_endhigh(t_jit_functor_transfer_smoothpulse *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_transfer_smoothpulse_recalc(t_jit_functor_transfer_smoothpulse *x);

long jit_functor_transfer_smoothpulse_eval_fixed(t_jit_functor_transfer_smoothpulse *x, long dimcount, long *vals);
float jit_functor_transfer_smoothpulse_eval_float32(t_jit_functor_transfer_smoothpulse *x, long dimcount, float *vals);
double jit_functor_transfer_smoothpulse_eval_float64(t_jit_functor_transfer_smoothpulse *x, long dimcount, double *vals);

long jit_functor_transfer_smoothpulse_eval_fixed_scalar(t_jit_functor_transfer_smoothpulse *x, long val);
float jit_functor_transfer_smoothpulse_eval_float32_scalar(t_jit_functor_transfer_smoothpulse *x, float val);
double jit_functor_transfer_smoothpulse_eval_float64_scalar(t_jit_functor_transfer_smoothpulse *x, double val);

t_class * _jit_functor_transfer_smoothpulse_class;

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

t_jit_err jit_functor_transfer_smoothpulse_init(void)
{
    t_jit_object *attr;

    // create functor class
    _jit_functor_transfer_smoothpulse_class = jit_class_new("jit_functor_transfer_smoothpulse",
        (method)jit_functor_transfer_smoothpulse_new,(method)jit_functor_transfer_smoothpulse_free,
        sizeof(t_jit_functor_transfer_smoothpulse),0L);

    // add attribute methods
    attr = jit_object_new(_jit_sym_jit_attr_offset,"startlow",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_transfer_smoothpulse_startlow,
        calcoffset(t_jit_functor_transfer_smoothpulse,startlow));
    jit_class_addattr(_jit_functor_transfer_smoothpulse_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"starthigh",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_transfer_smoothpulse_starthigh,
        calcoffset(t_jit_functor_transfer_smoothpulse,starthigh));
    jit_class_addattr(_jit_functor_transfer_smoothpulse_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"endlow",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_transfer_smoothpulse_endlow,
        calcoffset(t_jit_functor_transfer_smoothpulse,endlow));
    jit_class_addattr(_jit_functor_transfer_smoothpulse_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"endhigh",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_transfer_smoothpulse_endhigh,
        calcoffset(t_jit_functor_transfer_smoothpulse,endhigh));
    jit_class_addattr(_jit_functor_transfer_smoothpulse_class,attr);

    // add evaluation methods
    jit_class_addmethod(_jit_functor_transfer_smoothpulse_class, 
        (method)jit_functor_transfer_smoothpulse_eval_fixed, "evalfixed", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_transfer_smoothpulse_class, 
        (method)jit_functor_transfer_smoothpulse_eval_float32, "evalfloat32",   A_CANT, 0L);
    jit_class_addmethod(_jit_functor_transfer_smoothpulse_class,
        (method)jit_functor_transfer_smoothpulse_eval_float64, "evalfloat64",   A_CANT, 0L);

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

    return JIT_ERR_NONE;
}

t_jit_object *jit_functor_transfer_smoothpulse_new(void)
{
    t_jit_functor_transfer_smoothpulse *x;

    if (x = (t_jit_functor_transfer_smoothpulse *)jit_object_alloc(_jit_functor_transfer_smoothpulse_class)) {

        // initialization
        x->startlow = 0.0;
        x->starthigh = 0.1;
        x->endlow = 0.9;
        x->endhigh = 1.0;
        jit_functor_transfer_smoothpulse_recalc(x);
    }

    return (t_jit_object *)x;
}

t_jit_err jit_functor_transfer_smoothpulse_free(t_jit_functor_transfer_smoothpulse *x)
{
    return JIT_ERR_NONE;
}

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

    if (x) {
        v=jit_atom_getfloat(argv);
        if (x->startlow != v) {
            x->startlow = v;
            jit_functor_transfer_smoothpulse_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

    if (x) {
        v=jit_atom_getfloat(argv);
        if (x->starthigh != v) {
            x->starthigh = v;
            jit_functor_transfer_smoothpulse_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}


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

    if (x) {
        v=jit_atom_getfloat(argv);
        if (x->endlow != v) {
            x->endlow = v;
            jit_functor_transfer_smoothpulse_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

    if (x) {
        v=jit_atom_getfloat(argv);
        if (x->endhigh != v) {
            x->endhigh = v;
            jit_functor_transfer_smoothpulse_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_transfer_smoothpulse_recalc(
    t_jit_functor_transfer_smoothpulse *x)
{
    // calculate intermediary values for efficiency
    double t;
    if(x->startlow > x->starthigh)
    {
        t = x->startlow;
        x->startlow = x->starthigh;
        x->starthigh = t;
    }
    
    if(x->endlow > x->endhigh)
    {
        t = x->endlow;
        x->endlow = x->endhigh;
        x->endhigh = t;
    }
    return JIT_ERR_NONE;
}

// --------------------------------------------------------------------------
// vector evaluation functions (calls scalar functions and generates a product of scalar evaluation for each dimension)
// --------------------------------------------------------------------------
long jit_functor_transfer_smoothpulse_eval_fixed(
    t_jit_functor_transfer_smoothpulse *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_smoothpulse_eval_float64);
}

float jit_functor_transfer_smoothpulse_eval_float32(
    t_jit_functor_transfer_smoothpulse *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_smoothpulse_eval_float32_scalar);
}

double jit_functor_transfer_smoothpulse_eval_float64(
    t_jit_functor_transfer_smoothpulse *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_smoothpulse_eval_float64_scalar);
}

// --------------------------------------------------------------------------
// scalar evaluation functions
// --------------------------------------------------------------------------
long jit_functor_transfer_smoothpulse_eval_fixed_scalar(
    t_jit_functor_transfer_smoothpulse *x, long val)
{
    return FloatToFixed(jit_functor_transfer_smoothpulse_eval_float32_scalar(x,FixedToFloat(val)));
}

float jit_functor_transfer_smoothpulse_eval_float32_scalar(
    t_jit_functor_transfer_smoothpulse *x, float val)
{
    if (val < x->startlow || val >= x->endhigh)
        return 0.0;
    
    if (val >= x->starthigh) {
    
        if (val < x->endlow)
            return 1.0f;
    
        val = (val - x->endlow) / (x->endhigh - x->endlow);
        return 1.0f - (val*val * (3.0f - 2.0f*val));
    }
    
    val = (val - x->startlow) / (x->starthigh - x->startlow);
    return val*val * (3.0f - 2.0f*val);
}

double jit_functor_transfer_smoothpulse_eval_float64_scalar(
    t_jit_functor_transfer_smoothpulse *x, double val)
{
    if (val < x->startlow || val >= x->endhigh)
        return 0.0;
        
    if (val >= x->starthigh) {
    
        if (val < x->endlow)
            return 1.0;
        
        val = (val - x->endlow) / (x->endhigh - x->endlow);
        return 1.0 - (val*val * (3.0 - 2.0*val));
    }
    
    val = (val - x->startlow) / (x->starthigh - x->startlow);
    return val*val * (3.0 - 2.0*val);
}
// --------------------------------------------------------------------------

Copyright © 2008, Cycling '74