Max 5 API Reference

jit.transfer.solarize.c

/*
*   jit.transfer.solarize.c
*
*   Copyright 2001-2005 - Cycling '74
*   Derek Gerstmann - derek@cycling74.com
*
*   functor for a solarize transfer function (aka solarize interpolation)
*
*/

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

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

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

typedef struct _jit_functor_transfer_solarize
{
    t_jit_object                    ob;
    t_jit_functor_combined_value    threshold;  // middle threshold
    t_jit_functor_combined_value    scale;      // scale factor for result

} t_jit_functor_transfer_solarize;

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

t_jit_object *jit_functor_transfer_solarize_new(void);
t_jit_err jit_functor_transfer_solarize_free(t_jit_functor_transfer_solarize *x);
t_jit_err jit_functor_transfer_solarize_scale(t_jit_functor_transfer_solarize *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_transfer_solarize_threshold(t_jit_functor_transfer_solarize *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_transfer_solarize_recalc(t_jit_functor_transfer_solarize *x);

long jit_functor_transfer_solarize_eval_fixed(t_jit_functor_transfer_solarize *x, long dimcount, long *vals);
float jit_functor_transfer_solarize_eval_float32(t_jit_functor_transfer_solarize *x, long dimcount, float *vals);
double jit_functor_transfer_solarize_eval_float64(t_jit_functor_transfer_solarize *x, long dimcount, double *vals);

long jit_functor_transfer_solarize_eval_fixed_scalar(t_jit_functor_transfer_solarize *x, long val);
float jit_functor_transfer_solarize_eval_float32_scalar(t_jit_functor_transfer_solarize *x, float val);
double jit_functor_transfer_solarize_eval_float64_scalar(t_jit_functor_transfer_solarize *x, double val);

t_class * _jit_functor_transfer_solarize_class;

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

t_jit_err jit_functor_transfer_solarize_init(void)
{
    t_jit_object *attr;

    // create functor class
    _jit_functor_transfer_solarize_class = jit_class_new("jit_functor_transfer_solarize",
                                           (method)jit_functor_transfer_solarize_new, (method)jit_functor_transfer_solarize_free,
                                           sizeof(t_jit_functor_transfer_solarize), 0L);

    // add attribute methods
    attr = jit_object_new(_jit_sym_jit_attr_offset, "threshold", _jit_sym_float64, 0,
                          (method)0L, (method)jit_functor_transfer_solarize_threshold, calcoffset(t_jit_functor_transfer_solarize, threshold.float64));
    jit_class_addattr(_jit_functor_transfer_solarize_class, attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset, "scale", _jit_sym_float64, 0,
                          (method)0L, (method)jit_functor_transfer_solarize_scale, calcoffset(t_jit_functor_transfer_solarize, scale.float64));
    jit_class_addattr(_jit_functor_transfer_solarize_class, attr);

    // add evaluation methods
    jit_class_addmethod(_jit_functor_transfer_solarize_class,
                        (method)jit_functor_transfer_solarize_eval_fixed, "evalfixed", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_transfer_solarize_class,
                        (method)jit_functor_transfer_solarize_eval_float32, "evalfloat32", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_transfer_solarize_class,
                        (method)jit_functor_transfer_solarize_eval_float64, "evalfloat64", A_CANT, 0L);

    // add to functor registry
    jit_functor_setup_class(_jit_functor_transfer_solarize_class, "transfer", "solarize");
    jit_class_register(_jit_functor_transfer_solarize_class);
    return JIT_ERR_NONE;
}

t_jit_object *jit_functor_transfer_solarize_new(void)
{
    t_jit_functor_transfer_solarize *x;

    if (x = (t_jit_functor_transfer_solarize *)jit_object_alloc(_jit_functor_transfer_solarize_class))
    {

        // initialization
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->threshold, 0.5);
        JIT_FUNCTOR_COMBINED_VALUE_SETALL(x->scale, 2.0);
        jit_functor_transfer_solarize_recalc(x);
    }

    return (t_jit_object *)x;
}

t_jit_err jit_functor_transfer_solarize_free(t_jit_functor_transfer_solarize *x)
{
    return JIT_ERR_NONE;
}

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

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

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// vector evaluation functions
// -----------------------------------------------------------------------------

long jit_functor_transfer_solarize_eval_fixed(
    t_jit_functor_transfer_solarize *x, long dimcount, long *vals)
{
    return jit_functor_eval_fixed_with_float64((t_jit_object *)x, dimcount, vals,
            (t_jit_functor_float64_sig)jit_functor_transfer_solarize_eval_float64);
}

float jit_functor_transfer_solarize_eval_float32(
    t_jit_functor_transfer_solarize *x, long dimcount, float *vals)
{
    return jit_functor_eval_float32_with_scalar_product((t_jit_object *)x, dimcount, vals,
            (t_jit_functor_float32_scalar_sig)jit_functor_transfer_solarize_eval_float32_scalar);
}

double jit_functor_transfer_solarize_eval_float64(
    t_jit_functor_transfer_solarize *x, long dimcount, double *vals)
{
    return jit_functor_eval_float64_with_scalar_product((t_jit_object *)x, dimcount, vals,
            (t_jit_functor_float64_scalar_sig)jit_functor_transfer_solarize_eval_float64_scalar);
}

// -----------------------------------------------------------------------------
// scalar evaluation functions
// -----------------------------------------------------------------------------

long jit_functor_transfer_solarize_eval_fixed_scalar(
    t_jit_functor_transfer_solarize *x, long val)
{
    return FloatToFixed(jit_functor_transfer_solarize_eval_float32_scalar(x, FixedToFloat(val)));
}

float jit_functor_transfer_solarize_eval_float32_scalar(
    t_jit_functor_transfer_solarize *x, float val)
{
    return val > x->threshold.float32 ? x->scale.float32 * (val - x->threshold.float32) : x->scale.float32 * (x->threshold.float32 - val);
}

double jit_functor_transfer_solarize_eval_float64_scalar(
    t_jit_functor_transfer_solarize *x, double val)
{
    return val > x->threshold.float64 ? x->scale.float64 * (val - x->threshold.float64) : x->scale.float64 * (x->threshold.float64 - val);
}

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

Copyright © 2008, Cycling '74