Max 5 API Reference

jit.fractal.fbm.c

/*
 *  jit.fractal.fbm.c
 *
 *  Copyright 2001-2005 - Cycling '74
 *  Derek Gerstmann - derek@cycling74.com
 *
 *  Functor for evaluating fractional Brownian motion (fBm) (an additive 
 *  fractal) using an arbitrary signed basis function.
 *
 */

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

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

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

#define JIT_FRACTAL_FBM_DEFAULT_INCREMENT   1.0
#define JIT_FRACTAL_FBM_DEFAULT_OCTAVES     3.0
#define JIT_FRACTAL_FBM_DEFAULT_LACUNARITY  2.0345

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

typedef struct _jit_functor_fractal_fbm
{
    t_jit_object                                    ob;
    t_symbol                                        *basis;
    t_symbol                                        *category;
    long                                            seed;
    long                                            rotate;
    long                                            dimcount;
    t_jit_functor_combined_value                    increment;
    t_jit_functor_combined_value                    lacunarity;
    t_jit_functor_combined_value                    octaves;
    t_jit_functor_combined_dynarray                 exponents;
    t_jit_functor_fractal_combined_matrix_dynarray  rotations;
    t_jit_functor_evaluator                         evaluator;

} t_jit_functor_fractal_fbm;

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

t_jit_object *jit_functor_fractal_fbm_new(void);
t_jit_err jit_functor_fractal_fbm_free(t_jit_functor_fractal_fbm *x);

t_jit_err jit_functor_fractal_fbm_alter(
    t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv);

t_jit_err jit_functor_fractal_fbm_grab(
    t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv);

t_jit_err jit_functor_fractal_fbm_category(t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_fbm_basis(t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_fbm_seed(t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_fbm_rotate(t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_fbm_octaves(t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_fbm_increment(t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_fbm_lacunarity(t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_fbm_recalc(t_jit_functor_fractal_fbm *x);
t_jit_err jit_functor_fractal_fbm_exponents_init(t_jit_functor_fractal_fbm *x);

long jit_functor_fractal_fbm_eval_fixed(t_jit_functor_fractal_fbm *x, long dimcount, long *vals);
float jit_functor_fractal_fbm_eval_float32(t_jit_functor_fractal_fbm *x, long dimcount, float *vals);
double jit_functor_fractal_fbm_eval_float64(t_jit_functor_fractal_fbm *x, long dimcount, double *vals);

t_class * _jit_functor_fractal_fbm_class;

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

t_jit_err jit_functor_fractal_fbm_init(void)
{
    t_jit_object *attr;

    // create functor class
    _jit_functor_fractal_fbm_class = jit_class_new("jit_functor_fractal_fbm",
        (method)jit_functor_fractal_fbm_new,(method)jit_functor_fractal_fbm_free,
        sizeof(t_jit_functor_fractal_fbm),0L);

    // add attribute methods
    attr = jit_object_new(_jit_sym_jit_attr_offset,"category",_jit_sym_symbol,0,
        (method)0L,(method)jit_functor_fractal_fbm_category,
        calcoffset(t_jit_functor_fractal_fbm,category));
    jit_class_addattr(_jit_functor_fractal_fbm_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"basis",_jit_sym_symbol,0,
        (method)0L,(method)jit_functor_fractal_fbm_basis,
        calcoffset(t_jit_functor_fractal_fbm,basis));
    jit_class_addattr(_jit_functor_fractal_fbm_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"seed",_jit_sym_long,0,
        (method)0L,(method)jit_functor_fractal_fbm_seed, 
        calcoffset(t_jit_functor_fractal_fbm,seed));
    jit_class_addattr(_jit_functor_fractal_fbm_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"rotate",_jit_sym_long,0,
        (method)0L,(method)jit_functor_fractal_fbm_rotate, 
        calcoffset(t_jit_functor_fractal_fbm,rotate));
    jit_class_addattr(_jit_functor_fractal_fbm_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"increment",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_fractal_fbm_increment, 0);
    jit_class_addattr(_jit_functor_fractal_fbm_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"octaves",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_fractal_fbm_octaves, 0);
    jit_class_addattr(_jit_functor_fractal_fbm_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"lacunarity",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_fractal_fbm_lacunarity, 0);
    jit_class_addattr(_jit_functor_fractal_fbm_class,attr);

    // add delegate methods
    attr = jit_object_new(_jit_sym_jit_attr_offset,"alter",_jit_sym_symbol,0,
        (method)0L,(method)jit_functor_fractal_fbm_alter,0L);
    jit_class_addattr(_jit_functor_fractal_fbm_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"grab",_jit_sym_symbol,0,
        (method)jit_functor_fractal_fbm_grab, (method)0L, 0L);
    jit_class_addattr(_jit_functor_fractal_fbm_class,attr);

    // add evaluation methods
    jit_class_addmethod(_jit_functor_fractal_fbm_class,
        (method)jit_functor_fractal_fbm_eval_fixed, "evalfixed", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_fractal_fbm_class,
        (method)jit_functor_fractal_fbm_eval_float32, "evalfloat32",    A_CANT, 0L);
    jit_class_addmethod(_jit_functor_fractal_fbm_class,
        (method)jit_functor_fractal_fbm_eval_float64, "evalfloat64",    A_CANT, 0L);

    // important to add last for subclassing methods
    jit_functor_setup_class(_jit_functor_fractal_fbm_class,"fractal","fbm");
    jit_class_register(_jit_functor_fractal_fbm_class);

    return JIT_ERR_NONE;
}

t_jit_object *jit_functor_fractal_fbm_new(void)
{
    t_jit_functor_fractal_fbm *x;
    t_atom a;

    if (x = (t_jit_functor_fractal_fbm *)jit_object_alloc(_jit_functor_fractal_fbm_class)) {

        // initialization
        x->category = gensym("noise");
        x->basis = gensym("gradient");
        x->rotate = FALSE;
        x->seed = JIT_FRACTAL_DEFAULT_SEED;
        x->dimcount = 2;

        // set all data members
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->increment, JIT_FRACTAL_FBM_DEFAULT_INCREMENT);
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->octaves, JIT_FRACTAL_FBM_DEFAULT_OCTAVES);
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->lacunarity, JIT_FRACTAL_FBM_DEFAULT_LACUNARITY);
        
        x->exponents.float64 = NULL;
        x->exponents.float32 = NULL;
        x->exponents.fixed = NULL;
        x->exponents.count = 0;

        x->rotations.m = NULL;
        x->rotations.count = 0;

        x->evaluator.ob = NULL;
        x->evaluator.fm = NULL;
        
        jit_functor_evaluator_init(&x->evaluator, x->category, x->basis);

        // enable signed evaluation
        jit_atom_setlong(&a, 1);
        jit_object_method(x->evaluator.ob, gensym("sign"), 1, &a);

        // init exponents
        jit_functor_fractal_exponents_init(
            &x->exponents, x->octaves.float64,
            x->increment.float64, x->lacunarity.float64);

        jit_functor_fractal_fbm_recalc(x);
    }

    return (t_jit_object *)x;
}

t_jit_err jit_functor_fractal_fbm_free(t_jit_functor_fractal_fbm *x)
{
    // dispose allocated mem
    jit_functor_combined_dynarray_destroy(&x->exponents);
    jit_functor_fractal_rotations_destroy(&x->rotations);

    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_fractal_fbm_alter(
    t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv)
{
    t_jit_err rv = JIT_ERR_GENERIC;
    t_symbol *s = NULL;

    if(!x)
        return rv;

    s = jit_atom_getsym(argv);
    if(s && s->s_name)
    {
        rv = (t_jit_err) jit_object_method(x->evaluator.ob, s, argc-1, argv+1);
    }
    jit_functor_fractal_fbm_recalc(x);
    return rv;
}

t_jit_err jit_functor_fractal_fbm_grab(
    t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv)
{
    t_jit_err rv = JIT_ERR_GENERIC;
    t_symbol *s = NULL;
    char tmp[256];

    if(!x)
        return rv;

    s = jit_atom_getsym(argv);
    if(s && s->s_name)
    {
        sprintf(tmp,"get%s",s->s_name);
        s = gensym(tmp);
        rv = (t_jit_err) jit_object_method(x->evaluator.ob, s, argc-1, argv+1);
    }

    return rv;
}

t_jit_err jit_functor_fractal_fbm_category(
    t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv)
{
    t_jit_err err;
    t_symbol *v;
    t_atom a;

    if (x) {
        v = jit_atom_getsym(argv);
        if (x->category != v) {
            x->category = v;

            err = jit_functor_evaluator_init(&x->evaluator, x->category, x->basis);
            if(err) return err;

            jit_atom_setlong(&a, 1);
            err = (t_jit_err) jit_object_method(x->evaluator.ob, gensym("sign"), 1, &a);
            if(err)
                jit_object_post((t_object *)x,"jit.fractal.fbm: selected evaluator may not produce an appropriate output range");

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

t_jit_err jit_functor_fractal_fbm_basis(
    t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv)
{
    t_jit_err err;
    t_symbol *v;
    t_atom a;

    if (x) {
        v = jit_atom_getsym(argv);
        if (x->basis != v) {
            x->basis = v;

            err = jit_functor_evaluator_init(&x->evaluator, x->category, x->basis);
            if(err) return err;

            jit_atom_setlong(&a, 1);
            err = (t_jit_err) jit_object_method(x->evaluator.ob, gensym("sign"), 1, &a);
            if(err)
                jit_object_post((t_object *)x,"jit.fractal.fbm: selected evaluator may not produce an appropriate output range");

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

t_jit_err jit_functor_fractal_fbm_rotate(
    t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv)
{
    long v;

    if (x) {
        v = jit_atom_getlong(argv);
        if (x->rotate != v) {
            x->rotate = (v > 0) ? TRUE : FALSE;
            jit_functor_fractal_rotations_init(&x->rotations, x->octaves.float64, x->dimcount, x->seed);
            jit_functor_fractal_fbm_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_fractal_fbm_seed(
    t_jit_functor_fractal_fbm *x, void *attr, long argc, t_atom *argv)
{
    long v;

    if (x) {
        v = jit_atom_getlong(argv);
        if (x->seed != v) {
            x->seed = v;
            jit_functor_fractal_rotations_init(&x->rotations, x->octaves.float64, x->dimcount, x->seed);
            jit_functor_fractal_fbm_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

    if (x) {
        v = jit_atom_getfloat(argv);
        if (x->increment.float64 != v) {

            // copy and convert
            JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->increment, v);

            // init exponents
            jit_functor_fractal_exponents_init(
                &x->exponents, x->octaves.float64,
                x->increment.float64, x->lacunarity.float64);

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


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

    if (x) {
        v = jit_atom_getfloat(argv);
        if (x->octaves.float64 != v && v > 0.0) {

            // copy and convert
            JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->octaves, v);

            // init exponents
            jit_functor_fractal_exponents_init(
                &x->exponents, x->octaves.float64,
                x->increment.float64, x->lacunarity.float64);

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

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

    if (x) {
        v = jit_atom_getfloat(argv);
        if (x->lacunarity.float64 != v) {

            // copy and convert
            JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->lacunarity, v);

            // init exponents
            jit_functor_fractal_exponents_init(
                &x->exponents, x->octaves.float64,
                x->increment.float64, x->lacunarity.float64);

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

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

// --------------------------------------------------------------------------
// vector evaluation functions
// --------------------------------------------------------------------------
long jit_functor_fractal_fbm_eval_fixed(
    t_jit_functor_fractal_fbm *x, long dimcount, long *vals)
{
    /* TODO! */
    return jit_functor_eval_fixed_with_float32((t_jit_object *)x,dimcount,vals,
            (t_jit_functor_float32_sig)jit_functor_fractal_fbm_eval_float32);
}

float jit_functor_fractal_fbm_eval_float32(
    t_jit_functor_fractal_fbm *x, long dimcount, float *vals)
{
    long i, j, k;
    long count = (long)x->octaves.float32;
    float pos[JIT_MATRIX_MAX_DIMCOUNT];
    float rot[JIT_MATRIX_MAX_DIMCOUNT];
    
    float basis;
    float value;
    float rem;

    // safety
    if(!x->evaluator.ob || !x->evaluator.fm || !x->exponents.float32)
        return 0.0f;

    // reinit rotations if dimcount has changed
    if(dimcount != x->dimcount && x->rotate) {
        x->dimcount = dimcount;
        jit_functor_fractal_rotations_init(&x->rotations, x->octaves.float64, x->dimcount, x->seed);
    }
    
    // make a local copy of the position
    for( i = 0; i < dimcount; i++)
        pos[i] = vals[i];

    value = 0.0f;
    for ( i = 0; i < count; i++ )
    {
        // evaluate the basis function to create the spectrum
        basis = x->evaluator.fm->evalfloat32(x->evaluator.ob, dimcount, pos );
        value += basis * x->exponents.float32[i];

        // multipy in the lacunarity to create the gaps between octaves
        for( j = 0; j < dimcount; j++ )
            pos[j] *= x->lacunarity.float32;

        // apply rotation to reduce alignment artifacts
        if(x->rotate) {
            for( j = 0; j < dimcount; j++ ) {
                rot[j] = 0;
                for( k = 0; k < dimcount; k++ ) {
                    rot[j] += x->rotations.m[i].float32[j][k] * pos[k];
                }
            }
            for( j = 0; j < dimcount; j++ ) 
                pos[j] = rot[j];
        }
    }

    // take care of remainder in octaves using i from above
    rem = x->octaves.float32 - count;
    if ( rem )
    {
        basis = x->evaluator.fm->evalfloat32(x->evaluator.ob, dimcount, pos );
        value += rem * basis * x->exponents.float32[i];
    }

    return value;
}

double jit_functor_fractal_fbm_eval_float64(
    t_jit_functor_fractal_fbm *x, long dimcount, double *vals)
{
    long i, j, k;
    long count = (long)x->octaves.float64;
    double pos[JIT_MATRIX_MAX_DIMCOUNT];
    double rot[JIT_MATRIX_MAX_DIMCOUNT];
    
    double basis;
    double value;
    double rem;

    // safety
    if(!x->evaluator.ob || !x->evaluator.fm || !x->exponents.float64)
        return 0.0f;

    // reinit rotations if dimcount has changed
    if(dimcount != x->dimcount && x->rotate) {
        x->dimcount = dimcount;
        jit_functor_fractal_rotations_init(&x->rotations, x->octaves.float64, x->dimcount, x->seed);
    }

    // make a local copy of the position
    for( i = 0; i < dimcount; i++)
        pos[i] = vals[i];

    value = 0.0;
    for ( i = 0; i < count; i++ )
    {
        // evaluate the basis function to create the spectrum
        basis = x->evaluator.fm->evalfloat64(x->evaluator.ob, dimcount, pos );
        value += basis * x->exponents.float64[i];

        // multipy in the lacunarity to create the gaps between octaves
        for( j = 0; j < dimcount; j++ )
            pos[j] *= x->lacunarity.float64;

        // apply rotation to reduce alignment artifacts
        if(x->rotate) {
            for( j = 0; j < dimcount; j++ ) {
                rot[j] = 0;
                for( k = 0; k < dimcount; k++ ) {
                    rot[j] += x->rotations.m[i].float64[j][k] * pos[k];
                }
            }
            for( j = 0; j < dimcount; j++ ) 
                pos[j] = rot[j];
        }
    }

    // take care of remainder in octaves using i from above
    rem = x->octaves.float64 - count;
    if ( rem )
    {
        basis = x->evaluator.fm->evalfloat64(x->evaluator.ob, dimcount, pos );
        value += rem * basis * x->exponents.float64[i];
    }

    return value;
}
// --------------------------------------------------------------------------

Copyright © 2008, Cycling '74