Max 5 API Reference

jit.noise.c

/*
 * Copyright 2001-2005 - Cycling '74
 * Derek Gerstmann - derek@cycling74.com
 *
 * Common utilities for the coherent noise functor objects
 *
 */

#include "jit.noise.h"

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

t_jit_err jit_functor_noise_lattice_fixed_init(
    double *src, long **dest, long count)
{
    long i;

    // safety
    if(!dest)
        return JIT_ERR_INVALID_PTR;

    // dispose of any allocated mem
    if(*dest)
        jit_disposeptr((char*)(*dest));
    (*dest) = NULL;

    // allocate
    (*dest) = (long*)jit_newptr(count * sizeof(long));
    if(!(*dest))
        return JIT_ERR_INVALID_PTR;

    // copy and convert
    for(i = 0; i < count; i++)
        (*dest)[i] = DoubleToFixed(src[i]);

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_noise_lattice_float32_init(
    double *src, float **dest, long count)
{
    long i;

    // safety
    if(!dest)
        return JIT_ERR_INVALID_PTR;

    // dispose of any allocated mem
    if((*dest))
        jit_disposeptr((char*)(*dest));
    (*dest) = NULL;

    // allocate
    (*dest) = (float*)jit_newptr(count * sizeof(float));
    if(!(*dest))
        return JIT_ERR_INVALID_PTR;

    // copy and convert
    for(i = 0; i < count; i++)
        (*dest)[i] = (float)src[i];

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_noise_lattice_float64_init(
    double *src, double **dest, long count)
{
    long i;

    // safety
    if(!dest)
        return JIT_ERR_INVALID_PTR;

    // dispose of any allocated mem
    if((*dest))
        jit_disposeptr((char*)(*dest));
    (*dest) = NULL;

    // allocate
    (*dest) = (double*)jit_newptr(count * sizeof(double));
    if(!(*dest))
        return JIT_ERR_INVALID_PTR;

    // copy and convert
    for(i = 0; i < count; i++)
        (*dest)[i] = (double)src[i];

    return JIT_ERR_NONE;
}

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

t_jit_err jit_functor_noise_permutations_init(
    long **perm, long count, long seed)
{
    long i, j, t, n;

    // safety
    if(!perm)
        return JIT_ERR_INVALID_PTR;

    // dispose of allocated mem
    if((*perm))
        jit_disposeptr((char*)(*perm));
    (*perm) = NULL;

    // allocate
    (*perm) = (long*)jit_newptr(count * sizeof(long));
    if(!(*perm))
        return JIT_ERR_INVALID_PTR;

    // set the seed
    jit_rand_setseed(seed);

    // fill the tables with pseudo random integers
    for (i = 0; i < count; i++){
        (*perm)[i] = jit_rand() % count;
    }

    // mess up the order by randomly swapping values
    for (n = 0; n < 11; n++) {
        for(i = 0; i < count; i++){
            j = jit_rand() % count;
            t = (*perm)[j];
            (*perm)[j] = (*perm)[i];
            (*perm)[i] = t;
        }
    }

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_noise_lattice_init(
    t_jit_functor_combined_dynarray *lattice, long count, long seed)
{
    long i;
    t_jit_err err;
    double *uniform = NULL;

    // safety
    if(!lattice)
        return JIT_ERR_INVALID_PTR;

    // allocate
    uniform = (double*)jit_newptr(count * sizeof(double));
    if(!uniform)
        return JIT_ERR_INVALID_PTR;

    // set the seed
    jit_rand_setseed(seed);

    // fill table with uniform random values [0-1]
    for (i = 0; i < count; i++){
        uniform[i] = (jit_rand() % count) / (double)count;
    }

    // init all datatypes
    err = jit_functor_noise_lattice_fixed_init(uniform, &lattice->fixed, count);
    if(err) return err;

    err = jit_functor_noise_lattice_float32_init(uniform, &lattice->float32, count);
    if(err) return err;

    err = jit_functor_noise_lattice_float64_init(uniform, &lattice->float64, count);
    if(err) return err;

    jit_disposeptr((char *)uniform);

    return JIT_ERR_NONE;
}

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

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

    if(x && category && name)
    {
        // create the new object and get its interface
        err = jit_functor_wrapper_init(x, category, name);
    }
    else
    {
        err = JIT_ERR_INVALID_PTR;
    }

    if(err && category && category->s_name && name && name->s_name)
        jit_object_error((t_object *)x,"jit.functor.noise: unable to create evaluator object '%s.%s'.",
            category->s_name, name->s_name);

    return err;
}

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

long jit_functor_noise_hash_fixed_eval(
    long dimcount, long *vals, long *perm, long mask)
{
    long i;
    long hash;
    long cell[JIT_MATRIX_MAX_DIMCOUNT];

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

    // hash the dimensional value
    hash = cell[0];
    for (i = 1; i < dimcount; i++) {
        hash += perm[hash & mask] + cell[i];
    }
    return (hash & mask);
}

long jit_functor_noise_hash_float32_eval(
    long dimcount, float *vals, long *perm, long mask)
{
    long i;
    long hash;
    long cell[JIT_MATRIX_MAX_DIMCOUNT];

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

    // hash the dimensional value
    hash = cell[0];
    for (i = 1; i < dimcount; i++) {
        hash += perm[hash & mask] + cell[i];
    }
    return (hash & mask);
}

long jit_functor_noise_hash_float64_eval(
    long dimcount, double *vals, long *perm, long mask)
{
    long i;
    long hash;
    long cell[JIT_MATRIX_MAX_DIMCOUNT];

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

    // hash the dimensional value
    hash = cell[0];
    for (i = 1; i < dimcount; i++) {
        hash += perm[hash & mask] + cell[i];
    }
    return (hash & mask);
}


long jit_functor_noise_lattice_fixed_eval(
    long dimcount, long *vals, long *perm, 
    long *lattice, long mask)
{
    long i;
    long hash;
    long cell[JIT_MATRIX_MAX_DIMCOUNT];

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

    // hash the dimensional value
    hash = cell[0];
    for (i = 1; i < dimcount; i++) {
        hash += perm[hash & mask] + cell[i];
    }

    // return value via lut
    return lattice[hash & mask];
}

float jit_functor_noise_lattice_float32_eval(
    long dimcount, float *vals, long *perm, 
    float *lattice, long mask)
{
    long i;
    long hash;
    long cell[JIT_MATRIX_MAX_DIMCOUNT];

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

    // hash the dimensional value
    hash = cell[0];
    for (i = 1; i < dimcount; i++) {
        hash += perm[hash & mask] + cell[i];
    }

    // return value via lut
    return lattice[hash & mask];
}

double jit_functor_noise_lattice_float64_eval(
    long dimcount, double *vals, long *perm, 
    double *lattice, long mask)
{
    long i;
    long hash;
    long cell[JIT_MATRIX_MAX_DIMCOUNT];

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

    // hash the dimensional value
    hash = cell[0];
    for (i = 1; i < dimcount; i++) {
        hash += perm[hash & mask] + cell[i];
    }

    // return value via lut
    return lattice[hash & mask];
}

Copyright © 2008, Cycling '74