Max 5 API Reference

jit.curve.linear.c

/*
 *  jit.curve.linear.c
 *
 *  Copyright 2001-2005 - Cycling '74
 *  Derek Gerstmann - derek@cycling74.com
 *
 *  functor for a one-dimensional linearly interpolated curve
 *
 */

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

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

#include <math.h>

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

typedef struct _jit_functor_curve_linear
{
    t_jit_object                    ob;
    double                          *knots;
    long                            knotcount;
} t_jit_functor_curve_linear;

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

t_jit_object *jit_functor_curve_linear_new(void);
t_jit_err jit_functor_curve_linear_free(t_jit_functor_curve_linear *x);
t_jit_err jit_functor_curve_linear_setattr_knots(t_jit_functor_curve_linear *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_curve_linear_recalc(t_jit_functor_curve_linear *x);

long jit_functor_curve_linear_eval_fixed(t_jit_functor_curve_linear *x, long dimcount, long *vals);
float jit_functor_curve_linear_eval_float32(t_jit_functor_curve_linear *x, long dimcount, float *vals);
double jit_functor_curve_linear_eval_float64(t_jit_functor_curve_linear *x, long dimcount, double *vals);
long jit_functor_curve_linear_eval_fixed_scalar(t_jit_functor_curve_linear *x, long val);
float jit_functor_curve_linear_eval_float32_scalar(t_jit_functor_curve_linear *x, float val);
double jit_functor_curve_linear_eval_float64_scalar(t_jit_functor_curve_linear *x, double val);

t_class * _jit_functor_curve_linear_class;

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

t_jit_err jit_functor_curve_linear_init(void)
{
    t_jit_object *attr;

    // create the class
    _jit_functor_curve_linear_class = jit_class_new("jit_functor_curve_linear",
        (method)jit_functor_curve_linear_new,(method)jit_functor_curve_linear_free,
        sizeof(t_jit_functor_curve_linear),0L);

    // add attribute methods
    attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset, "knots",
        _jit_sym_float64, 0, (method)0L,(method)jit_functor_curve_linear_setattr_knots,
        calcoffset(t_jit_functor_curve_linear, knots)   );
    jit_class_addattr(_jit_functor_curve_linear_class,attr);

    // add functor evaluation methods
    jit_class_addmethod(_jit_functor_curve_linear_class, 
        (method)jit_functor_curve_linear_eval_fixed,    "evalfixed", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_curve_linear_class, 
        (method)jit_functor_curve_linear_eval_float32, "evalfloat32", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_curve_linear_class, 
        (method)jit_functor_curve_linear_eval_float64, "evalfloat64", A_CANT, 0L);

    // add to functor registry and register class
    jit_functor_setup_class(_jit_functor_curve_linear_class,"curve","linear");
    jit_class_register(_jit_functor_curve_linear_class);

    return JIT_ERR_NONE;
}

t_jit_object *jit_functor_curve_linear_new(void)
{
    t_jit_functor_curve_linear *x;

    if (x = (t_jit_functor_curve_linear *)jit_object_alloc(_jit_functor_curve_linear_class)) {

        // initialization
        x->knots = NULL;
        x->knotcount = 0;
        jit_functor_curve_linear_recalc(x);
    }

    return (t_jit_object *)x;
}

t_jit_err jit_functor_curve_linear_free(t_jit_functor_curve_linear *x)
{
    return JIT_ERR_NONE;
}

t_jit_err jit_functor_curve_linear_setattr_knots(
    t_jit_functor_curve_linear *x, void *attr, long argc, t_atom *argv)
{
    long i;
    double v;

    if (x) {

        // allocate mem for knot array
        if(x->knots) jit_disposeptr((char*)x->knots);
        x->knots = NULL;
        x->knots = (double*)jit_newptr(argc * sizeof(double));
        if(!x->knots) return JIT_ERR_INVALID_PTR;

        // copy all data values
        for(i = 0; i < argc; i++)
            x->knots[i] = jit_atom_getfloat(argv + i);

        // recalc
        jit_functor_curve_linear_recalc(x);

        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_curve_linear_recalc(t_jit_functor_curve_linear *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_curve_linear_eval_fixed(
    t_jit_functor_curve_linear *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_curve_linear_eval_float64);
}

float jit_functor_curve_linear_eval_float32(
    t_jit_functor_curve_linear *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_curve_linear_eval_float32_scalar);
}

double jit_functor_curve_linear_eval_float64(
    t_jit_functor_curve_linear *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_curve_linear_eval_float64_scalar);
}

// --------------------------------------------------------------------------
// scalar evaluation functions
// --------------------------------------------------------------------------
long jit_functor_curve_linear_eval_fixed_scalar(
    t_jit_functor_curve_linear *x, long val)
{
    return FloatToFixed(jit_functor_curve_linear_eval_float32_scalar(x,FixedToFloat(val)));
}

float jit_functor_curve_linear_eval_float32_scalar(
    t_jit_functor_curve_linear *x, float val)
{
    float fx, g[2];
    long span;
    long index = 0;
    long spancount = x->knotcount - 1;
    
    if (spancount < 1)
        return 0.0f;

    // find the appropriate 1-point span
    fx = CLAMP(val, 0.0f, 1.0f) * spancount;
    span = (long)fx;

    if (span >= x->knotcount - 1)
      span = x->knotcount - 1;

    // determine the section to eval
    fx -= span;
    index += span;
  
    // get the control points
    g[0] = x->knots[ 0 + index ];
    g[1] = x->knots[ 1 + index ];
    
    // linearly interpolate from g0 to g1
    return ( g[0] + fx * (g[1] - g[0]) );
}

double jit_functor_curve_linear_eval_float64_scalar(
    t_jit_functor_curve_linear *x, double val)
{
    double dx, g[2];
    long span;
    long index = 0;
    long spancount = x->knotcount - 1;
    
    if (spancount < 1)
        return 0.0;

    // find the appropriate 1-point span
    dx = CLAMP(val, 0.0, 1.0) * spancount;
    span = (long)dx;

    if (span >= x->knotcount - 1)
      span = x->knotcount - 1;

    // determine the section to eval
    dx -= span;
    index += span;
  
    // get the control points
    g[0] = x->knots[ 0 + index ];
    g[1] = x->knots[ 1 + index ];
    
    // linearly interpolate from g0 to g1
    return ( g[0] + dx * (g[1] - g[0]) );
}
// --------------------------------------------------------------------------

Copyright © 2008, Cycling '74