Max 5 API Reference

jit.fractal.hetero.c

/*
 *  jit.fractal.hetero.c
 *
 *  Copyright 2001-2005 - Cycling '74
 *  Derek Gerstmann - derek@cycling74.com
 *
 *  Functor for evaluating an heterogenous additive fractal (a varient of 
 *  fractional Brownian motion - fBm ) using an arbitrary *signed* basis 
 *  function.  The hetero fractal is characterized by being smooth where
 *  level == 0, and increases in roughness above and below.
 *
 */

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

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

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

typedef struct _jit_functor_fractal_hetero
{
    t_jit_object                                    ob;
    t_symbol                                        *basis;
    long                                            seed;       // seed for random rotation matrix
    long                                            dimcount;   // coord dimension of last evaluation
    long                                            rotate;     // flag for rotations per octave
    t_jit_functor_combined_dimvalue                 scale;      // position scale factor for basis
    t_jit_functor_combined_dimvalue                 offset;     // position offset for basis
    t_jit_functor_combined_value                    roughness;  // determines the fractal dimension
    t_jit_functor_combined_value                    lacunarity; // spacing or gaps between detail
    t_jit_functor_combined_value                    detail;     // determines number of octaves 
    t_jit_functor_combined_value                    level;      // adjusts the zero offset
    t_jit_functor_combined_value                    result;     // scaling factor for result 
    t_jit_functor_combined_dynarray                 exponents;  // precalc-ed exponents
    t_jit_functor_fractal_combined_matrix_dynarray  rotations;  // precalc-ed rotation matrices per octave
    t_jit_functor_wrapper                           evaluator;  // basis functor

} t_jit_functor_fractal_hetero;

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

t_jit_object *jit_functor_fractal_hetero_new(void);
t_jit_err jit_functor_fractal_hetero_free(t_jit_functor_fractal_hetero *x);

t_jit_err jit_functor_fractal_hetero_basis(t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_hetero_seed(t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_hetero_rotate(t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_hetero_scale(t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_hetero_offset(t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_hetero_roughness(t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_hetero_lacunarity(t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_hetero_detail(t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_hetero_level(t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_hetero_result(t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_fractal_hetero_recalc(t_jit_functor_fractal_hetero *x);

long jit_functor_fractal_hetero_eval_fixed(t_jit_functor_fractal_hetero *x, long dimcount, long *vals);
float jit_functor_fractal_hetero_eval_float32(t_jit_functor_fractal_hetero *x, long dimcount, float *vals);
double jit_functor_fractal_hetero_eval_float64(t_jit_functor_fractal_hetero *x, long dimcount, double *vals);
t_jit_object *jit_functor_fractal_hetero_subfunctor(t_jit_functor_fractal_hetero *x, t_symbol *name);

t_class * _jit_functor_fractal_hetero_class;
t_symbol * ps_jit_functor_fractal_hetero_basis;
// --------------------------------------------------------------------------

t_jit_err jit_functor_fractal_hetero_init(void)
{
    t_jit_object *attr;

    // create functor class
    _jit_functor_fractal_hetero_class = jit_class_new("jit_functor_fractal_hetero",
        (method)jit_functor_fractal_hetero_new,(method)jit_functor_fractal_hetero_free,
        sizeof(t_jit_functor_fractal_hetero),0L);

    // add attribute methods
    attr = jit_object_new(_jit_sym_jit_attr_offset,"type",_jit_sym_symbol,0,
        (method)0L,(method)jit_functor_fractal_hetero_basis,
        calcoffset(t_jit_functor_fractal_hetero,basis));
    jit_class_addattr(_jit_functor_fractal_hetero_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"basis",_jit_sym_symbol,0,
        (method)0L,(method)jit_functor_fractal_hetero_basis,
        calcoffset(t_jit_functor_fractal_hetero,basis));
    jit_class_addattr(_jit_functor_fractal_hetero_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"seed",_jit_sym_long,0,
        (method)0L,(method)jit_functor_fractal_hetero_seed, 
        calcoffset(t_jit_functor_fractal_hetero,seed));
    jit_class_addattr(_jit_functor_fractal_hetero_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"rotate",_jit_sym_long,0,
        (method)0L,(method)jit_functor_fractal_hetero_rotate, 
        calcoffset(t_jit_functor_fractal_hetero,rotate));
    jit_class_addattr(_jit_functor_fractal_hetero_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"scale",_jit_sym_float64,JIT_MATRIX_MAX_DIMCOUNT,0,
        (method)0L,(method)jit_functor_fractal_hetero_scale, 
        calcoffset(t_jit_functor_fractal_hetero,scale.dimcount),
        calcoffset(t_jit_functor_fractal_hetero,scale.float64));
    jit_class_addattr(_jit_functor_fractal_hetero_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"offset",_jit_sym_float64,JIT_MATRIX_MAX_DIMCOUNT,0,
        (method)0L,(method)jit_functor_fractal_hetero_offset,
        calcoffset(t_jit_functor_fractal_hetero,offset.dimcount),
        calcoffset(t_jit_functor_fractal_hetero,offset.float64));
    jit_class_addattr(_jit_functor_fractal_hetero_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"roughness",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_fractal_hetero_roughness,
        calcoffset(t_jit_functor_fractal_hetero,roughness.float64));
    jit_class_addattr(_jit_functor_fractal_hetero_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"lacunarity",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_fractal_hetero_lacunarity, 
        calcoffset(t_jit_functor_fractal_hetero,lacunarity.float64));
    jit_class_addattr(_jit_functor_fractal_hetero_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"detail",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_fractal_hetero_detail, 
        calcoffset(t_jit_functor_fractal_hetero,detail.float64));
    jit_class_addattr(_jit_functor_fractal_hetero_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"level",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_fractal_hetero_level, 
        calcoffset(t_jit_functor_fractal_hetero,level.float64));
    jit_class_addattr(_jit_functor_fractal_hetero_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"result",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_fractal_hetero_result, 
        calcoffset(t_jit_functor_fractal_hetero,result.float64));
    jit_class_addattr(_jit_functor_fractal_hetero_class,attr);

    // add evaluation methods
    jit_class_addmethod(_jit_functor_fractal_hetero_class,
        (method)jit_functor_fractal_hetero_eval_fixed, "evalfixed", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_fractal_hetero_class,
        (method)jit_functor_fractal_hetero_eval_float32, "evalfloat32",     A_CANT, 0L);
    jit_class_addmethod(_jit_functor_fractal_hetero_class,
        (method)jit_functor_fractal_hetero_eval_float64, "evalfloat64",     A_CANT, 0L);

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

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

    // generate symbols
    ps_jit_functor_fractal_hetero_basis = gensym("basis");
    return JIT_ERR_NONE;
}

t_jit_object *jit_functor_fractal_hetero_new(void)
{
    long i;
    t_jit_functor_fractal_hetero *x;
    t_atom a;

    if (x = (t_jit_functor_fractal_hetero *)jit_object_alloc(_jit_functor_fractal_hetero_class)) {

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

        // set all data members
        for(i = 0; i < JIT_MATRIX_MAX_DIMCOUNT; i++) 
        {
            x->scale.float64[i] = JIT_FRACTAL_DEFAULT_SCALE;
            x->scale.float32[i] = JIT_FRACTAL_DEFAULT_SCALE;
            x->scale.fixed[i] = FloatToFixed(x->scale.float32[i]);

            x->offset.float64[i] = JIT_FRACTAL_DEFAULT_OFFSET;
            x->offset.float32[i] = JIT_FRACTAL_DEFAULT_OFFSET;
            x->offset.fixed[i] = FloatToFixed(x->offset.float32[i]);
        }

        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->roughness, JIT_FRACTAL_DEFAULT_ROUGHNESS);
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->lacunarity, JIT_FRACTAL_DEFAULT_LACUNARITY);
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->detail, JIT_FRACTAL_DEFAULT_DETAIL);
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->level, JIT_FRACTAL_DEFAULT_LEVEL);
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->result, JIT_FRACTAL_DEFAULT_RESULT);
        
        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_wrapper_init(&x->evaluator, NULL, x->basis);

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

        // init exponents
        jit_functor_fractal_exponents_init(
            &x->exponents, x->detail.float64,
            x->roughness.float64, x->lacunarity.float64);

        jit_functor_fractal_hetero_recalc(x);
    }

    return (t_jit_object *)x;
}

t_jit_err jit_functor_fractal_hetero_free(t_jit_functor_fractal_hetero *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_hetero_basis(
    t_jit_functor_fractal_hetero *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_wrapper_init(&x->evaluator, NULL, 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.hetero: selected evaluator may not produce an appropriate output range");

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

t_jit_err jit_functor_fractal_hetero_seed(
    t_jit_functor_fractal_hetero *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->detail.float64, x->dimcount, x->seed);
            jit_functor_fractal_hetero_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_fractal_hetero_rotate(
    t_jit_functor_fractal_hetero *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->detail.float64, x->dimcount, x->seed);
            jit_functor_fractal_hetero_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_fractal_hetero_offset(
    t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv)
{
    long i;
    double v;
    char changed = FALSE; // changed flag

    if (x) {
        for(i = 0; i < argc && i < JIT_MATRIX_MAX_DIMCOUNT; i++)
        {
            v = jit_atom_getfloat(argv+i);
            if(x->offset.float64[i] != v) 
            {
                // copy and convert
                JIT_FUNCTOR_COMBINED_ARRAY_SETALL(i, x->offset, v);
                changed = TRUE;
            }
        }
        if(changed) {
            x->offset.dimcount = argc;
            jit_functor_fractal_hetero_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_fractal_hetero_scale(
    t_jit_functor_fractal_hetero *x, void *attr, long argc, t_atom *argv)
{
    long i;
    double v;
    char changed = FALSE; // changed flag

    if (x) {
        for(i = 0; i < argc && i < JIT_MATRIX_MAX_DIMCOUNT; i++)
        {
            v = jit_atom_getfloat(argv+i);
            if(x->scale.float64[i] != v) 
            {
                // copy and convert
                JIT_FUNCTOR_COMBINED_ARRAY_SETALL(i, x->scale, v);
                changed = TRUE;
            }
        }
        if(changed) {
            x->scale.dimcount = argc;
            jit_functor_fractal_hetero_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

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

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

            // init exponents
            jit_functor_fractal_exponents_init(
                &x->exponents, x->detail.float64,
                x->roughness.float64, x->lacunarity.float64);

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

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

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

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

            // init exponents
            jit_functor_fractal_exponents_init(
                &x->exponents, x->detail.float64,
                x->roughness.float64, x->lacunarity.float64);

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

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

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

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

            // init exponents
            jit_functor_fractal_exponents_init(
                &x->exponents, x->detail.float64,
                x->roughness.float64, x->lacunarity.float64);

            // init rotation matrices
            if(x->rotate)
                jit_functor_fractal_rotations_init(
                    &x->rotations, x->detail.float64, x->dimcount, x->seed);

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

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

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

            // copy and convert
            JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->level, v);
            jit_functor_fractal_hetero_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

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

            // copy and convert
            JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->result, v);
            jit_functor_fractal_hetero_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

// --------------------------------------------------------------------------
// vector evaluation functions
// --------------------------------------------------------------------------
long jit_functor_fractal_hetero_eval_fixed(
    t_jit_functor_fractal_hetero *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_hetero_eval_float32);
}

float jit_functor_fractal_hetero_eval_float32(
    t_jit_functor_fractal_hetero *x, long dimcount, float *vals)
{
    long i, j, k;
    long count = (long)x->detail.float32;
    float pos[JIT_MATRIX_MAX_DIMCOUNT];
    float rot[JIT_MATRIX_MAX_DIMCOUNT];
    
    float increment;
    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->detail.float64, x->dimcount, x->seed);
    }
    
    // scale and offset position
    for( i = 0; i < dimcount; i++)
        pos[i] = (vals[i] + x->offset.float32[i]) * x->scale.float32[i];

    // evaluate the first octave and weight the basis
    basis = x->evaluator.fm->evalfloat32(x->evaluator.ob, dimcount, pos );
    value = x->level.float32 + basis;

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

    // process the rest of the octaves
    for ( i = 1; i < count; i++ )
    {
        // evaluate the basis function to create the spectrum
        basis = x->evaluator.fm->evalfloat32(x->evaluator.ob, dimcount, pos );

        // determine the increment
        increment = (basis + x->level.float32) * x->exponents.float32[i] * value;
        value += increment;

        // 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(i > 0 && x->rotate) {
            for( j = 0; j < dimcount; j++ ) {
                rot[j] = 0;
                for( k = 0; k < dimcount; k++ ) {
                    rot[j] += x->rotations.m[i-1].float32[j][k] * pos[k];
                }
            }
            for( j = 0; j < dimcount; j++ ) 
                pos[j] = rot[j];
        }
    }

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

    // weight the result
    return value * x->result.float32;
}

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

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

    // reinit rotations if dimcount has changed
    if(dimcount != x->dimcount && x->rotate) {
        x->dimcount = dimcount;
        jit_functor_fractal_rotations_init(&x->rotations, x->detail.float64, x->dimcount, x->seed);
    }
    
    // scale and offset position
    for( i = 0; i < dimcount; i++)
        pos[i] = (vals[i] + x->offset.float64[i]) * x->scale.float64[i];

    // evaluate the first octave and weight the basis
    basis = x->evaluator.fm->evalfloat64(x->evaluator.ob, dimcount, pos );
    value = x->level.float64 + basis;

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

    // process the rest of the octaves
    for ( i = 1; i < count; i++ )
    {
        // evaluate the basis function to create the spectrum
        basis = x->evaluator.fm->evalfloat64(x->evaluator.ob, dimcount, pos );

        // determine the increment
        increment = (basis + x->level.float64) * x->exponents.float64[i] * value;
        value += increment;

        // 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(i > 0 && x->rotate) {
            for( j = 0; j < dimcount; j++ ) {
                rot[j] = 0;
                for( k = 0; k < dimcount; k++ ) {
                    rot[j] += x->rotations.m[i-1].float64[j][k] * pos[k];
                }
            }
            for( j = 0; j < dimcount; j++ ) 
                pos[j] = rot[j];
        }
    }

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

    // weight the result
    return value * x->result.float64;
}

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

t_jit_object *jit_functor_fractal_hetero_subfunctor(
    t_jit_functor_fractal_hetero *x, t_symbol *name)
{
    if (name == ps_jit_functor_fractal_hetero_basis)
        return (t_jit_object *)x->evaluator.ob;
    else
        return NULL;
}

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

Copyright © 2008, Cycling '74