Max 5 API Reference

jit.noise.gradient.c

/*
 * Copyright 2001-2005 - Cycling '74
 * Derek Gerstmann - derek@cycling74.com
 *
 * Coherent cubic spline interpolated value noise functor object
 *
 */

/*************************************************************************/

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

/*************************************************************************/

// the value noise object
typedef struct _jit_functor_noise_gradient
{
    t_jit_object    ob;

    // type of filtering transfer function
    t_symbol        *filter;

    // pseudo random permutation table
    long            *p;

    // lattice of uniform values [0-1]
    t_jit_functor_combined_dynarray lattice;

    // array of gradient directions
    t_jit_functor_combined_dimvalue *gradients;

    // current dimcount for gradient directions
    long            dimcount;

    // size and mask for tables
    long            tablesize;
    long            tablemask;

    // seed for random number generation
    long            seed;

    // signed mode (0 = unsigned, 1 = signed)
    long            sign;

    // abs mode (0 = normal, 1 = absolute)
    long            abs;

    // cubic spline basis data for interpolation
    t_jit_functor_wrapper evaluator;

    // lock on our dir init which can be called during parallel evaluation
    long            spinwait;

} t_jit_functor_noise_gradient;

t_class *_jit_functor_noise_gradient_class;
t_symbol *ps_jit_functor_noise_gradient_filter;

/*************************************************************************/

t_jit_object *jit_functor_noise_gradient_new(void);
t_jit_err jit_functor_noise_gradient_free(t_jit_functor_noise_gradient *x);

t_jit_err jit_functor_noise_gradient_abs(t_jit_functor_noise_gradient *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_gradient_sign(t_jit_functor_noise_gradient *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_gradient_seed(t_jit_functor_noise_gradient *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_gradient_tablesize(t_jit_functor_noise_gradient *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_gradient_filter(t_jit_functor_noise_gradient *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_gradient_recalc(t_jit_functor_noise_gradient *x);

long jit_functor_noise_gradient_eval_fixed_ndim(
    t_jit_functor_noise_gradient *x, long dimcount, long *vals);

float jit_functor_noise_gradient_eval_float32_ndim(
    t_jit_functor_noise_gradient *x, long dimcount, float *vals);

double jit_functor_noise_gradient_eval_float64_ndim(
    t_jit_functor_noise_gradient *x, long dimcount, double *vals);

long jit_functor_noise_gradient_eval_fixed(
    t_jit_functor_noise_gradient *x, long dimcount, long *vals);

float jit_functor_noise_gradient_eval_float32(
    t_jit_functor_noise_gradient *x, long dimcount, float *vals);

double jit_functor_noise_gradient_eval_float64(
    t_jit_functor_noise_gradient *x, long dimcount, double *vals);

t_jit_object *jit_functor_noise_gradient_subfunctor(
    t_jit_functor_noise_gradient *x, t_symbol *name);

t_jit_err jit_functor_noise_gradient_dir_init(
    t_jit_functor_noise_gradient *x);

t_jit_err jit_functor_noise_gradient_evaluator_init(
    t_jit_functor_wrapper *x, t_symbol *name );

/*************************************************************************/

t_jit_err jit_functor_noise_gradient_init(void)
{
    t_jit_object *attr;

    // create class
    _jit_functor_noise_gradient_class = jit_class_new("jit_functor_noise_gradient",
        (method)jit_functor_noise_gradient_new,(method)jit_functor_noise_gradient_free,
        sizeof(t_jit_functor_noise_gradient),0L);

    // add attribute methods
    attr = jit_object_new(_jit_sym_jit_attr_offset,"abs",_jit_sym_long,0,
        (method)0L,(method)jit_functor_noise_gradient_abs,
        calcoffset(t_jit_functor_noise_gradient,abs));
    jit_class_addattr(_jit_functor_noise_gradient_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"sign",_jit_sym_long,0,
        (method)0L,(method)jit_functor_noise_gradient_sign,
        calcoffset(t_jit_functor_noise_gradient,sign));
    jit_class_addattr(_jit_functor_noise_gradient_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"seed",_jit_sym_long,0,
        (method)0L,(method)jit_functor_noise_gradient_seed,
        calcoffset(t_jit_functor_noise_gradient,seed));
    jit_class_addattr(_jit_functor_noise_gradient_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"tablesize",_jit_sym_long,0,
        (method)0L,(method)jit_functor_noise_gradient_tablesize,
        calcoffset(t_jit_functor_noise_gradient,tablesize));
    jit_class_addattr(_jit_functor_noise_gradient_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"filter",_jit_sym_long,0,
        (method)0L,(method)jit_functor_noise_gradient_filter,
        calcoffset(t_jit_functor_noise_gradient,filter));
    jit_class_addattr(_jit_functor_noise_gradient_class,attr);

    // add evaluation methods
    jit_class_addmethod(_jit_functor_noise_gradient_class,
        (method)jit_functor_noise_gradient_eval_fixed, "evalfixed", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_noise_gradient_class,
        (method)jit_functor_noise_gradient_eval_float32, "evalfloat32", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_noise_gradient_class,
        (method)jit_functor_noise_gradient_eval_float64, "evalfloat64", A_CANT, 0L);

    // exposing subfunctor to set/getattr interface
    jit_class_addmethod(_jit_functor_noise_gradient_class,
        (method)jit_functor_noise_gradient_subfunctor, "subfunctor", A_CANT, 0L);

    // register functor *then* class
    jit_functor_setup_class(_jit_functor_noise_gradient_class,"noise","gradient");
    jit_class_register(_jit_functor_noise_gradient_class);

    // generate symbols
    ps_jit_functor_noise_gradient_filter = gensym("filter");
    return JIT_ERR_NONE;
}

t_jit_object *jit_functor_noise_gradient_new(void)
{
    long i, j;
    t_jit_functor_noise_gradient *x;

    if (x = (t_jit_functor_noise_gradient *)jit_object_alloc(_jit_functor_noise_gradient_class)) {

        // initialization
        x->p = NULL;

        x->lattice.fixed = NULL;
        x->lattice.float32 = NULL;
        x->lattice.float64 = NULL;

        x->abs = FALSE;
        x->sign = FALSE;

        x->seed = JIT_NOISE_DEFAULT_SEED;
        x->tablesize = jit_math_roundup_poweroftwo(JIT_NOISE_DEFAULT_TABLESIZE);
        x->tablemask = x->tablesize - 1;

        // default to cubic filtering
        x->filter = gensym("cubic");

        // default to 2d gradients
        x->dimcount = 0;
        x->gradients = NULL;

        x->evaluator.fm = NULL;
        x->evaluator.ob = NULL;

        x->spinwait = 0;        

        // allocate permutation and uniform tables
        jit_functor_noise_permutations_init(&x->p, x->tablesize, x->seed);
        jit_functor_noise_lattice_init(&x->lattice, x->tablesize, x->seed);
        
        // init evaluator
        jit_functor_noise_gradient_evaluator_init(&x->evaluator, x->filter);
        jit_functor_noise_gradient_recalc(x);
    }

    return (t_jit_object *)x;
}

t_jit_err jit_functor_noise_gradient_free(t_jit_functor_noise_gradient *x)
{
    // free any allocated memory
    jit_functor_combined_dynarray_destroy(&x->lattice);

    if(x->p)
        jit_disposeptr((char*)x->p);
    x->p = NULL;

    if(x->gradients)
        jit_disposeptr((char*)x->gradients);
    x->gradients = NULL;

    if(x->evaluator.ob)
        jit_object_free(x->evaluator.ob);
    x->evaluator.ob = NULL;
    x->evaluator.fm = NULL;

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_noise_gradient_abs(
    t_jit_functor_noise_gradient *x, void *attr, long argc, t_atom *argv)
{
    long v;

    if (x) {
        v = jit_atom_getlong(argv);
        if (x->abs != v) {
            x->abs = (v > 0) ? TRUE : FALSE;
            jit_functor_noise_gradient_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_noise_gradient_sign(
    t_jit_functor_noise_gradient *x, void *attr, long argc, t_atom *argv)
{
    long v;

    if (x) {
        v = jit_atom_getlong(argv);
        if (x->sign != v) {
            x->sign = (v > 0) ? TRUE : FALSE;
            jit_functor_noise_gradient_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_noise_gradient_seed(
    t_jit_functor_noise_gradient *x, void *attr, long argc, t_atom *argv)
{
    long v;

    if (x) {
        v = jit_atom_getlong(argv);
        if (x->seed != v) {
            x->seed = v;

            // allocate permutation and uniform tables
            jit_functor_noise_permutations_init(&x->p, x->tablesize, x->seed);
            jit_functor_noise_lattice_init(&x->lattice, x->tablesize, x->seed);
            jit_functor_noise_gradient_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_noise_gradient_tablesize(
    t_jit_functor_noise_gradient *x, void *attr, long argc, t_atom *argv)
{
    long v;

    if (x) {
        v = jit_atom_getlong(argv);
        if (x->tablesize != v && v > 0) {

            x->tablesize = jit_math_roundup_poweroftwo(v);
            x->tablemask = x->tablesize - 1;

            // allocate permutation and uniform tables
            jit_functor_noise_permutations_init(&x->p, x->tablesize, x->seed);
            jit_functor_noise_lattice_init(&x->lattice, x->tablesize, x->seed);
            jit_functor_noise_gradient_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

t_jit_err jit_functor_noise_gradient_filter(
    t_jit_functor_noise_gradient *x, void *attr, long argc, t_atom *argv)
{
    long i;
    t_jit_err err;
    t_symbol *v;

    if (x)
    {
        v = jit_atom_getsym(argv);
        if(x->filter != v)
        {
            x->filter = v;
            err = jit_functor_noise_gradient_evaluator_init(&x->evaluator, x->filter);
            if(err) return err;

            jit_functor_noise_gradient_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

long jit_functor_noise_gradient_eval_fixed_ndim(
    t_jit_functor_noise_gradient *x, long dimcount, long *vals)
{
    long cell[JIT_MATRIX_MAX_DIMCOUNT];     // cell coord
    long rem[JIT_MATRIX_MAX_DIMCOUNT];          // remainders
    long frac[JIT_MATRIX_MAX_DIMCOUNT];     // fractions
    long weight[JIT_MATRIX_MAX_DIMCOUNT];       // weights
    long knots[JIT_MATRIX_MAX_DIMCOUNT][2]; // knots
    long lattice[JIT_MATRIX_MAX_DIMCOUNT];      // lattice position
    long length, signal;

    long iterators[JIT_MATRIX_MAX_DIMCOUNT];    // iterators
    long i, c, dim;
    long hash;
    long start = 0;
    long end = 1;
    long step = 1;
    long dir = JIT_NOISE_DOWN;

    // init the values, integer coords, and remainders
    for(i = 0; i < dimcount; i++)
    {
        cell[i] = FixedFloor(vals[i]);
        rem[i] = vals[i] - cell[i];
        weight[i] = x->evaluator.fm->evalfixed(x->evaluator.ob, 1, rem + i);
        iterators[i] = start;
    }

    dim = -1;
    while(dim < dimcount)
    {
        if(dim < 0)
            dim = dimcount - 1;

        // calculate lattice coordinates
        lattice[dim] = cell[dim] + iterators[dim];
        frac[dim] = rem[dim] - IntToFixed(iterators[dim]);

        if(dir == JIT_NOISE_DOWN && dim > 0)
        {
            dim--;
            continue;
        }
        else if(dim == 0)
        {
            // get the value at the current lattice point
            hash = jit_functor_noise_hash_fixed_eval(dimcount, lattice, x->p, x->tablemask);

            // get the length of the gradients
            length = 0;
            for(i = 0; i < dimcount; i++)
                length += FixMul(x->gradients[hash].fixed[i], frac[i]);

            // save the gradient lengths
            knots[dim][ iterators[dim] ] = length;
        }
        else if(dir == JIT_NOISE_UP)
        {
            // linearly interpolate between the two knots and the weighted value
            length = JIT_MATH_FIXED_LERP(weight[dim-1], knots[dim-1][0], knots[dim-1][1]);
            knots[ dim ][ iterators[dim] ] = length;
            dir = JIT_NOISE_DOWN;
        }

        // step in current dim
        iterators[dim] += step;
        if(iterators[dim] > end)
        {
            // reset iterator and ascend
            iterators[dim] = start;
            dir = JIT_NOISE_UP;
            dim++;
        }
    }

    // post loop evaluation
    signal = JIT_MATH_FIXED_LERP(weight[dim-1], knots[dim-1][0], knots[dim-1][1]);

    // remap
    if(!x->sign)
        signal = FixMul(FloatToFixed(0.5f), signal) + FloatToFixed(0.5f);

    if(x->abs)
        signal = JIT_MATH_FIXED_ABS(signal);

    return signal;
}

float jit_functor_noise_gradient_eval_float32_ndim(
    t_jit_functor_noise_gradient *x, long dimcount, float *vals)
{
    float cell[JIT_MATRIX_MAX_DIMCOUNT];        // cell coord
    float rem[JIT_MATRIX_MAX_DIMCOUNT];         // remainders
    float frac[JIT_MATRIX_MAX_DIMCOUNT];        // fractions
    float weight[JIT_MATRIX_MAX_DIMCOUNT];      // weights
    float knots[JIT_MATRIX_MAX_DIMCOUNT][2];    // knots
    float lattice[JIT_MATRIX_MAX_DIMCOUNT];     // lattice position
    float length, signal;

    long iterators[JIT_MATRIX_MAX_DIMCOUNT];    // iterators
    long i, c, dim;
    long hash;
    long start = 0;
    long end = 1;
    long step = 1;
    long dir = JIT_NOISE_DOWN;

    // init the values, integer coords, and remainders
    for(i = 0; i < dimcount; i++)
    {
        cell[i] = JIT_MATH_F32_FLOOR(vals[i]);
        rem[i] = vals[i] - cell[i];
        weight[i] = x->evaluator.fm->evalfloat32(x->evaluator.ob, 1, rem + i);
        iterators[i] = start;
    }

    dim = -1;
    while(dim < dimcount)
    {
        if(dim < 0)
            dim = dimcount - 1;

        // calculate lattice coordinates
        lattice[dim] = cell[dim] + iterators[dim];
        frac[dim] = rem[dim] - iterators[dim];

        if(dir == JIT_NOISE_DOWN && dim > 0)
        {
            dim--;
            continue;
        }
        else if(dim == 0)
        {
            // get the value at the current lattice point
            hash = jit_functor_noise_hash_float32_eval(dimcount, lattice, x->p, x->tablemask);

            // get the length of the gradients
            length = 0.0f;
            for(i = 0; i < dimcount; i++)
                length += x->gradients[hash].float32[i] * frac[i];

            // save the gradient lengths
            knots[dim][ iterators[dim] ] = length;
        }
        else if(dir == JIT_NOISE_UP)
        {
            // linearly interpolate between the two knots and the weighted value
            length = JIT_MATH_LERP(weight[dim-1], knots[dim-1][0], knots[dim-1][1]);
            knots[ dim ][ iterators[dim] ] = length;
            dir = JIT_NOISE_DOWN;
        }

        // step in current dim
        iterators[dim] += step;
        if(iterators[dim] > end)
        {
            // reset iterator and ascend
            iterators[dim] = start;
            dir = JIT_NOISE_UP;
            dim++;
        }
    }

    // post loop evaluation
    signal = JIT_MATH_LERP(weight[dim-1], knots[dim-1][0], knots[dim-1][1]);

    // remap
    if(!x->sign)
        signal = 0.5f * signal + 0.5f;

    if(x->abs)
        signal = JIT_MATH_F32_ABS(signal);

    return signal;
}

double jit_functor_noise_gradient_eval_float64_ndim(
    t_jit_functor_noise_gradient *x, long dimcount, double *vals)
{
    double cell[JIT_MATRIX_MAX_DIMCOUNT];       // cell coord
    double rem[JIT_MATRIX_MAX_DIMCOUNT];        // remainders
    double frac[JIT_MATRIX_MAX_DIMCOUNT];       // fractions
    double weight[JIT_MATRIX_MAX_DIMCOUNT];     // weights
    double knots[JIT_MATRIX_MAX_DIMCOUNT][2];   // knots
    double lattice[JIT_MATRIX_MAX_DIMCOUNT];    // lattice position
    double length, signal;

    long iterators[JIT_MATRIX_MAX_DIMCOUNT];    // iterators
    long i, c, dim;
    long hash;
    long start = 0;
    long end = 1;
    long step = 1;
    long dir = JIT_NOISE_DOWN;

    // init the values, integer coords, and remainders
    for(i = 0; i < dimcount; i++)
    {
        cell[i] = JIT_MATH_F32_FLOOR(vals[i]);
        rem[i] = vals[i] - cell[i];
        weight[i] = x->evaluator.fm->evalfloat64(x->evaluator.ob, 1, rem + i);
        iterators[i] = start;
    }

    dim = -1;
    while(dim < dimcount)
    {
        if(dim < 0)
            dim = dimcount - 1;

        // calculate lattice coordinates
        lattice[dim] = cell[dim] + iterators[dim];
        frac[dim] = rem[dim] - iterators[dim];

        if(dir == JIT_NOISE_DOWN && dim > 0)
        {
            dim--;
            continue;
        }
        else if(dim == 0)
        {
            // get the value at the current lattice point
            hash = jit_functor_noise_hash_float64_eval(dimcount, lattice, x->p, x->tablemask);

            // get the length of the gradients
            length = 0.0f;
            for(i = 0; i < dimcount; i++)
                length += x->gradients[hash].float64[i] * frac[i];

            // save the gradient lengths
            knots[dim][ iterators[dim] ] = length;
        }
        else if(dir == JIT_NOISE_UP)
        {
            // linearly interpolate between the two knots and the weighted value
            length = JIT_MATH_LERP(weight[dim-1], knots[dim-1][0], knots[dim-1][1]);
            knots[ dim ][ iterators[dim] ] = length;
            dir = JIT_NOISE_DOWN;
        }

        // step in current dim
        iterators[dim] += step;
        if(iterators[dim] > end)
        {
            // reset iterator and ascend
            iterators[dim] = start;
            dir = JIT_NOISE_UP;
            dim++;
        }
    }

    // post loop evaluation
    signal = JIT_MATH_LERP(weight[dim-1], knots[dim-1][0], knots[dim-1][1]);

    // remap
    if(!x->sign)
        signal = 0.5 * signal + 0.5;

    if(x->abs)
        signal = JIT_MATH_F64_ABS(signal);

    return signal;
}

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

t_jit_err jit_functor_noise_gradient_dir_init(
    t_jit_functor_noise_gradient *x)
{
    long i, j;
    double theta, fx, fy, fz, fr, fv;
    double ndim[JIT_MATRIX_MAX_DIMCOUNT];
    double mag;
    t_jit_err err = JIT_ERR_NONE;   

    if(x->gradients)
        jit_disposeptr((char*)x->gradients);
    x->gradients = NULL;

    x->gradients = (t_jit_functor_combined_dimvalue*)jit_newptr(x->tablesize * sizeof(t_jit_functor_combined_dimvalue));
    if(!x->gradients) {
        err = JIT_ERR_INVALID_PTR;
        goto out;
    }

    jit_rand_setseed(x->seed);
    switch(x->dimcount)
    {
        case 1:
        case 2:
        case 3:
        {
            // calc spherical gradient directions
            for(i = 0; i < x->tablesize; i++)
            {
                // get a pseudo random uniform float
                fv = (jit_rand() % x->tablesize) / (double)x->tablesize;

                // calc signed z value
                fz = 1.0 - 2.0 * fv;

                // calc radius
                fr = jit_math_sqrt(JIT_MATH_MAX(0.0, 1.0 - JIT_MATH_SQR(fz)));

                // get a pseudo random uniform float
                fv = (jit_rand() % x->tablesize) / (double)x->tablesize;

                // determine angle
                theta = 2 * JIT_MATH_F64_PI * fv;

                // calc spherical gradient directions
                x->gradients[i].float64[0] = fr * jit_math_cos(theta);

                if(x->dimcount > 1)
                    x->gradients[i].float64[1] = fr * jit_math_sin(theta);

                if(x->dimcount > 2)
                    x->gradients[i].float64[2] = fz;
            }
            break;
        }
        default:
        {
            // just normalize vectors in n-dim space
            for(i = 0; i < x->tablesize; i++)
            {
                // get n-dim pseudo random signed values
                for(j = 0; j < x->dimcount; j++)
                {
                    fv = (jit_rand() % x->tablesize) / (double)x->tablesize;
                    fv = 1.0 - 2.0 * fv;
                    ndim[j] = fv;
                }

                // calculate vector's magnitude
                mag = 0;
                for(j = 0; j < x->dimcount; j++)
                    mag += JIT_MATH_SQR(ndim[i]);
            
                // calculate scale factor
                if(mag > 0.0f) {
                    fv = jit_math_sqrt(mag);
                    fv = 1.0 / fv;
                } else {
                    fv = 1.0f;
                }

                // normalize and assign
                for(j = 0; j < x->dimcount; j++)
                {
                    ndim[j] *= fv;
                    x->gradients[i].float64[j] = ndim[j];
                }
            }
        }
    };

    // copy and convert
    for(i = 0; i < x->tablesize; i++)
    {
        for(j = 0; j < x->dimcount; j++)
        {
            x->gradients[i].float32[j] = (float)x->gradients[i].float64[j];
            x->gradients[i].fixed[j] = DoubleToFixed(x->gradients[i].float64[j]);
        }
    }

out:
    return err;
}

long jit_functor_noise_gradient_eval_fixed(
    t_jit_functor_noise_gradient *x, long dimcount, long *vals)
{
    // safety
    if(!x->evaluator.ob)
        return FloatToFixed(0.0f);

    if(!x->p)
        jit_functor_noise_permutations_init(&x->p, x->tablesize, x->seed);

    if(!x->lattice.fixed)
        jit_functor_noise_lattice_init(&x->lattice, x->tablesize, x->seed);

    if(!x->gradients || dimcount != x->dimcount)
    {
        x->dimcount = dimcount;
        jit_functor_noise_gradient_dir_init(x);
    }

    return jit_functor_noise_gradient_eval_fixed_ndim(x, dimcount, vals);
}

float jit_functor_noise_gradient_eval_float32(
    t_jit_functor_noise_gradient *x, long dimcount, float *vals)
{
    // safety
    if(!x->evaluator.ob)
        return 0.0f;

    if(!x->p)
        jit_functor_noise_permutations_init(&x->p, x->tablesize, x->seed);

    if(!x->lattice.float32)
        jit_functor_noise_lattice_init(&x->lattice, x->tablesize, x->seed);

    if(!x->gradients || dimcount != x->dimcount)
    {
        x->dimcount = dimcount;
        jit_functor_noise_gradient_dir_init(x);
    }

    return jit_functor_noise_gradient_eval_float32_ndim(x, dimcount, vals);
}

double jit_functor_noise_gradient_eval_float64(
    t_jit_functor_noise_gradient *x, long dimcount, double *vals)
{
    // safety
    if(!x->evaluator.ob)
        return 0.0;

    if(!x->p)
        jit_functor_noise_permutations_init(&x->p, x->tablesize, x->seed);

    if(!x->lattice.float64)
        jit_functor_noise_lattice_init(&x->lattice, x->tablesize, x->seed);

    if(!x->gradients || dimcount != x->dimcount)
    {
        x->dimcount = dimcount;
        jit_functor_noise_gradient_dir_init(x);
    }

    return jit_functor_noise_gradient_eval_float64_ndim(x, dimcount, vals);
}

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

t_jit_err jit_functor_noise_gradient_evaluator_init(
    t_jit_functor_wrapper *x, t_symbol *name )
{
    t_jit_err err = JIT_ERR_NONE;

    if(x)
    {
        // create the new object and get it's interface
        err = jit_functor_wrapper_init(x, NULL, name);
    }
    else
    {
        err = JIT_ERR_INVALID_PTR;
    }

    if(err && name && name->s_name) {
        jit_object_error((t_object *)x,"jit.functor.noise.gradient: unable to create filter object '%s'.", name->s_name);
        if(x) {
            x->ob = NULL;
            x->fm = NULL;
        }
    }

    return err;
}

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

t_jit_object *jit_functor_noise_gradient_subfunctor(
    t_jit_functor_noise_gradient *x, t_symbol *name)
{
    if (name == ps_jit_functor_noise_gradient_filter)
        return (t_jit_object *)x->evaluator.ob;
    else
        return NULL;
}

Copyright © 2008, Cycling '74