Max 5 API Reference

jit.noise.checker.c

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

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

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

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

// the checker noise object
typedef struct _jit_functor_noise_checker
{
    t_jit_object ob;

    // pseudo random permutation table
    long *p;

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

    // smoothing factor
    t_jit_functor_combined_value    smooth;

} t_jit_functor_noise_checker;

t_class *_jit_functor_noise_checker_class;

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

t_jit_object *jit_functor_noise_checker_new(void);
t_jit_err jit_functor_noise_checker_free(t_jit_functor_noise_checker *x);

t_jit_err jit_functor_noise_checker_abs(t_jit_functor_noise_checker *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_checker_sign(t_jit_functor_noise_checker *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_checker_seed(t_jit_functor_noise_checker *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_checker_smooth(t_jit_functor_noise_checker *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_checker_tablesize(t_jit_functor_noise_checker *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_noise_checker_recalc(t_jit_functor_noise_checker *x);

long jit_functor_noise_checker_eval_fixed(t_jit_functor_noise_checker *x, long dimcount, long *vals);
float jit_functor_noise_checker_eval_float32(t_jit_functor_noise_checker *x, long dimcount, float *vals);
double jit_functor_noise_checker_eval_float64(t_jit_functor_noise_checker *x, long dimcount, double *vals);

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

t_jit_err jit_functor_noise_checker_init(void)
{
    t_jit_object *attr;

    // create class
    _jit_functor_noise_checker_class = jit_class_new("jit_functor_noise_checker",
        (method)jit_functor_noise_checker_new,(method)jit_functor_noise_checker_free,
        sizeof(t_jit_functor_noise_checker), 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_checker_abs,calcoffset(t_jit_functor_noise_checker,abs));
    jit_class_addattr(_jit_functor_noise_checker_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"sign",_jit_sym_long,0,
        (method)0L,(method)jit_functor_noise_checker_sign,calcoffset(t_jit_functor_noise_checker,sign));
    jit_class_addattr(_jit_functor_noise_checker_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"seed",_jit_sym_long,0,
        (method)0L,(method)jit_functor_noise_checker_seed,calcoffset(t_jit_functor_noise_checker,seed));
    jit_class_addattr(_jit_functor_noise_checker_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"smooth",_jit_sym_long,0,
        (method)0L,(method)jit_functor_noise_checker_smooth,calcoffset(t_jit_functor_noise_checker,smooth.float64));
    jit_class_addattr(_jit_functor_noise_checker_class,attr);

    // add methods
    jit_class_addmethod(_jit_functor_noise_checker_class,
        (method)jit_functor_noise_checker_eval_fixed, "evalfixed", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_noise_checker_class,
        (method)jit_functor_noise_checker_eval_float32, "evalfloat32", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_noise_checker_class,
        (method)jit_functor_noise_checker_eval_float64, "evalfloat64", A_CANT, 0L);

    // register functor *then* class
    jit_functor_setup_class(_jit_functor_noise_checker_class,"noise","checker");
    jit_class_register(_jit_functor_noise_checker_class);

    return JIT_ERR_NONE;
}

t_jit_object *jit_functor_noise_checker_new(void)
{
    t_jit_functor_noise_checker *x;

    if (x = (t_jit_functor_noise_checker *)jit_object_alloc(_jit_functor_noise_checker_class)) {

        // initialization
        x->p = 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;
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->smooth, 0.0);


        // allocate permutation and uniform tables
        jit_functor_noise_permutations_init(&x->p, x->tablesize, x->seed);
        jit_functor_noise_checker_recalc(x);
    }

    return (t_jit_object *)x;
}

t_jit_err jit_functor_noise_checker_free(t_jit_functor_noise_checker *x)
{
    if(x->p)
        jit_disposeptr((char*)x->p);
    x->p = NULL;

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_noise_checker_abs(
    t_jit_functor_noise_checker *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_checker_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_noise_checker_sign(
    t_jit_functor_noise_checker *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_checker_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_noise_checker_seed(
    t_jit_functor_noise_checker *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_checker_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

    if (x)
    {
        v = jit_atom_getfloat(argv);
        v *= 0.5;
        if (x->smooth.float64 != v && v >= 0.0 && v <= 1.0) 
        {
            JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->smooth, v);
            jit_functor_noise_checker_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}
t_jit_err jit_functor_noise_checker_tablesize(
    t_jit_functor_noise_checker *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_checker_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

// fixes % for negative numbers
static long jit_math_mod_fixed(long a, long b) 
{
    long n = (long)FixDiv(a,b);
    a -= n*b;
    if (a < 0)
        return a + b;
    return a;
}

static float jit_math_mod_float32(float a, float b) 
{
    long n = (long)(a/b);
    a -= n*b;
    if (a < 0)
        return a + b;
    return a;
}

static double jit_math_mod_float64(double a, double b) 
{
    long n = (long)(a/b);
    a -= n*b;
    if (a < 0)
        return a + b;
    return a;
}

float smooth_pulse_float32(float a1, float a2, float b1, float b2, float x) 
{
    if (x < a1 || x >= b2)
        return 0.0f;
    
    if (x >= a2) 
    {
        if (x < b1)
            return 1.0f;

        x = (x - b1) / (b2 - b1);
        return 1.0f - (x*x * (3.0f - 2.0f*x));
    }
    
    x = (x - a1) / (a2 - a1);
    return x*x * (3.0f - 2.0f*x);
}

double smooth_pulse_float64(double a1, double a2, double b1, double b2, double x) 
{
    if (x < a1 || x >= b2)
        return 0.0;
    
    if (x >= a2) 
    {
        if (x < b1)
            return 1.0;
        x = (x - b1) / (b2 - b1);
        return 1.0 - (x*x * (3.0 - 2.0*x));
    }
    
    x = (x - a1) / (a2 - a1);
    return x*x * (3.0 - 2.0*x);
}

long jit_functor_noise_checker_eval_fixed(
    t_jit_functor_noise_checker *x, long dimcount, long *vals)
{
    long i;
    long check;
    long val;
    float conv;
    float fuzz;
    float temp;
    long checker[JIT_MATRIX_MAX_DIMCOUNT];

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

    // check the dimensional value for oddness
    check = checker[0] & 1;
    for (i = 1; i < dimcount; i++) {
        check = check ^ (checker[i] & 1);
    }

    if (x->smooth.float32 != 0.0f) 
    {
        conv = FixedToFloat(vals[0]);
        temp  = jit_math_mod_float32(conv, 1.0f);
        fuzz = smooth_pulse_float32(0.0f, x->smooth.float32, 1.0f - x->smooth.float32, 1.0f, temp);
        for(i = 1; i < dimcount; i++)
        {
            conv = FixedToFloat(vals[i]);
            temp  = jit_math_mod_float32(conv, 1.0f);
            fuzz = fuzz * smooth_pulse_float32(0.0f, x->smooth.float32, 1.0f - x->smooth.float32, 1.0, temp);
        }

        // assign value based on oddness
        val = check ? FloatToFixed(0.5f - fuzz) : FloatToFixed(0.5f + fuzz);
    }
    else
    {
        // assign value based on oddness
        val = check ? FloatToFixed(-1.0f) : FloatToFixed(1.0f);
    }

    // do conversion
    if(!x->sign)
        val = FixMul(FloatToFixed(0.5f), val) + FloatToFixed(0.5f);

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

    return val;
}

float jit_functor_noise_checker_eval_float32(
    t_jit_functor_noise_checker *x, long dimcount, float *vals)
{
    long i;
    long check;
    float val;
    float fuzz;
    float temp;
    long checker[JIT_MATRIX_MAX_DIMCOUNT];

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

    // check the dimensional value for oddness
    check = checker[0] & 1;
    for (i = 1; i < dimcount; i++) {
        check = check ^ (checker[i] & 1);
    }

    if (x->smooth.float32 != 0.0f) 
    {
        temp  = jit_math_mod_float32(vals[0], 1.0f);
        fuzz = smooth_pulse_float32(0.0f, x->smooth.float32, 1.0f - x->smooth.float32, 1.0f, temp);
        for(i = 1; i < dimcount; i++)
        {
            temp  = jit_math_mod_float32(vals[i], 1.0f);
            fuzz = fuzz * smooth_pulse_float32(0.0f, x->smooth.float32, 1.0f - x->smooth.float32, 1.0, temp);
        }

        // assign value based on oddness
        val = check ? 0.5f - fuzz : 0.5f + fuzz;
    }
    else
    {
        // assign value based on oddness
        val = check ? -1.0 : 1.0;
    }

    // do conversion
    if(!x->sign)
        val = 0.5 * val + 0.5;

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

    return val;
}

double jit_functor_noise_checker_eval_float64(
    t_jit_functor_noise_checker *x, long dimcount, double *vals)
{
    long i;
    long check;
    double val;
    double fuzz;
    double temp;
    long checker[JIT_MATRIX_MAX_DIMCOUNT];

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

    // check the dimensional value for oddness
    check = checker[0] & 1;
    for (i = 1; i < dimcount; i++) {
        check = check ^ (checker[i] & 1);
    }

    if (x->smooth.float64 != 0.0) 
    {
        temp  = jit_math_mod_float64(vals[0], 1.0);
        fuzz = smooth_pulse_float64(0.0, x->smooth.float64, 1 - x->smooth.float64, 1.0, temp);
        for(i = 1; i < dimcount; i++)
        {
            temp  = jit_math_mod_float64(vals[i], 1.0);
            fuzz = fuzz * smooth_pulse_float64(0.0, x->smooth.float64, 1 - x->smooth.float64, 1.0, temp);
        }

        // assign value based on oddness
        val = check ? 0.5 - fuzz : 0.5 + fuzz;
    }
    else
    {
        // assign value based on oddness
        val = check ? -1.0 : 1.0;
    }

    // do conversion
    if(!x->sign)
        val = 0.5 * val + 0.5;

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

    return val;
}

Copyright © 2008, Cycling '74