Max 5 API Reference

jit.noise.cell.c

/*
 * Copyright 2001-2005 - Cycling '74
 * Derek Gerstmann - derek@cycling74.com
 *
 * Coherent cell/blocky noise functor object
 *
 */

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

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

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

// the cell noise object
typedef struct _jit_functor_noise_cell
{
    t_jit_object ob;

    // pseudo random permutation table
    long *p;

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

    // 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;

} t_jit_functor_noise_cell;

t_class *_jit_functor_noise_cell_class;

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

t_jit_object *jit_functor_noise_cell_new(void);
t_jit_err jit_functor_noise_cell_free(t_jit_functor_noise_cell *x);

t_jit_err jit_functor_noise_cell_abs(t_jit_functor_noise_cell *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_cell_sign(t_jit_functor_noise_cell *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_cell_seed(t_jit_functor_noise_cell *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_cell_tablesize(t_jit_functor_noise_cell *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_cell_recalc(t_jit_functor_noise_cell *x);

long jit_functor_noise_cell_eval_fixed(t_jit_functor_noise_cell *x, long dimcount, long *vals);
float jit_functor_noise_cell_eval_float32(t_jit_functor_noise_cell *x, long dimcount, float *vals);
double jit_functor_noise_cell_eval_float64(t_jit_functor_noise_cell *x, long dimcount, double *vals);

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

t_jit_err jit_functor_noise_cell_init(void)
{
    t_jit_object *attr;

    // create class
    _jit_functor_noise_cell_class = jit_class_new("jit_functor_noise_cell",
        (method)jit_functor_noise_cell_new,(method)jit_functor_noise_cell_free,
        sizeof(t_jit_functor_noise_cell), A_GIMME, 0L);

    // add attributes
    attr = jit_object_new(_jit_sym_jit_attr_offset,"abs",_jit_sym_long,0,
        (method)0L,(method)jit_functor_noise_cell_abs,calcoffset(t_jit_functor_noise_cell,abs));
    jit_class_addattr(_jit_functor_noise_cell_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"sign",_jit_sym_long,0,
        (method)0L,(method)jit_functor_noise_cell_sign,calcoffset(t_jit_functor_noise_cell,sign));
    jit_class_addattr(_jit_functor_noise_cell_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"seed",_jit_sym_long,0,
        (method)0L,(method)jit_functor_noise_cell_seed,calcoffset(t_jit_functor_noise_cell,seed));
    jit_class_addattr(_jit_functor_noise_cell_class,attr);

    // add methods
    jit_class_addmethod(_jit_functor_noise_cell_class,
        (method)jit_functor_noise_cell_eval_fixed, "evalfixed", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_noise_cell_class,
        (method)jit_functor_noise_cell_eval_float32, "evalfloat32", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_noise_cell_class,
        (method)jit_functor_noise_cell_eval_float64, "evalfloat64", A_CANT, 0L);

    // register functor *then* class
    jit_functor_setup_class(_jit_functor_noise_cell_class,"noise","cell");
    jit_class_register(_jit_functor_noise_cell_class);

    return JIT_ERR_NONE;
}

t_jit_object *jit_functor_noise_cell_new(void)
{
    t_jit_functor_noise_cell *x;

    if (x = (t_jit_functor_noise_cell *)jit_object_alloc(_jit_functor_noise_cell_class)) {

        // initialization
        x->p = NULL;
        x->lattice.fixed = NULL;
        x->lattice.float32 = NULL;
        x->lattice.float64 = NULL;

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

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

        // 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_cell_recalc(x);
    }

    return (t_jit_object *)x;
}

t_jit_err jit_functor_noise_cell_free(t_jit_functor_noise_cell *x)
{
    if(x->p)
        jit_disposeptr((char*)x->p);
    x->p = NULL;

    jit_functor_combined_dynarray_destroy(&x->lattice);
    return JIT_ERR_NONE;
}

t_jit_err jit_functor_noise_cell_abs(
    t_jit_functor_noise_cell *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_cell_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_noise_cell_sign(
    t_jit_functor_noise_cell *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_cell_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_noise_cell_seed(
    t_jit_functor_noise_cell *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_cell_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_noise_cell_tablesize(
    t_jit_functor_noise_cell *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_cell_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

long jit_functor_noise_cell_eval_fixed(
    t_jit_functor_noise_cell *x, long dimcount, long *vals)
{
    long i;
    long hash;
    long val;
    long cell[JIT_MATRIX_MAX_DIMCOUNT];

    // convert to long
    for(i = 0; i < dimcount; i++)
        cell[i] = FixedFloor(vals[i] + JIT_NOISE_FIXED_DISALIGN);

    // hash the dimensional value
    hash = cell[0];
    for (i = 1; i < dimcount; i++) {
        hash += x->p[hash & x->tablemask] + cell[i];
    }

    // get value via lut
    val = x->lattice.fixed[hash & x->tablemask];

    if(x->sign)
        val = FixMul(FloatToFixed(2.0f), val) - FloatToFixed(1.0f);

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

    return val;
}

float jit_functor_noise_cell_eval_float32(
    t_jit_functor_noise_cell *x, long dimcount, float *vals)
{
    long i;
    long hash;
    float val;
    long cell[JIT_MATRIX_MAX_DIMCOUNT];

    // convert to long
    for(i = 0; i < dimcount; i++)
        cell[i] = JIT_MATH_F32_FLOOR(vals[i] + JIT_NOISE_F32_DISALIGN);

    // hash the dimensional value
    hash = cell[0];
    for (i = 1; i < dimcount; i++) {
        hash += x->p[hash & x->tablemask] + cell[i];
    }

    // get value via lut
    val = x->lattice.float32[hash & x->tablemask];

    if(x->sign)
        val = 2.0f * val - 1.0f;

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

    return val;
}

double jit_functor_noise_cell_eval_float64(
    t_jit_functor_noise_cell *x, long dimcount, double *vals)
{
    long i;
    long hash;
    double val;
    long cell[JIT_MATRIX_MAX_DIMCOUNT];

    // convert to long
    for(i = 0; i < dimcount; i++)
        cell[i] = JIT_MATH_F64_FLOOR(vals[i] + JIT_NOISE_F64_DISALIGN);

    // hash the dimensional value
    hash = cell[0];
    for (i = 1; i < dimcount; i++) {
        hash += x->p[hash & x->tablemask] + cell[i];
    }

    // get value via lut
    val = x->lattice.float64[hash & x->tablemask];

    if(x->sign)
        val = 2.0 * val - 1.0;

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

    return val;
}

Copyright © 2008, Cycling '74