void asin_tilde_setup(void)
{
asin_class = class_new(gensym("asin~"),
(t_newmethod)asin_new, 0,
sizeof(t_asin), 0, 0);
sic_setup(asin_class, asin_dsp, SIC_FLOATTOSIGNAL);
}
void cosh_tilde_setup(void)
{
cosh_class = class_new(gensym("cosh~"),
(t_newmethod)cosh_new, 0,
sizeof(t_cosh), 0, 0);
sic_setup(cosh_class, cosh_dsp, SIC_FLOATTOSIGNAL);
}
void atan2_tilde_setup(void)
{
atan2_class = class_new(gensym("atan2~"),
(t_newmethod)atan2_new, 0,
sizeof(t_atan2), 0, A_DEFFLOAT, 0);
sic_setup(atan2_class, atan2_dsp, SIC_FLOATTOSIGNAL);
}
void modulo_tilde_setup(void)
{
modulo_class = class_new(gensym("modulo~"),
(t_newmethod)modulo_new, 0,
sizeof(t_modulo), 0, A_GIMME, 0);
sic_setup(modulo_class, modulo_dsp, SIC_FLOATTOSIGNAL);
}
void poltocar_tilde_setup(void)
{
poltocar_class = class_new(gensym("poltocar~"),
(t_newmethod)poltocar_new, 0,
sizeof(t_poltocar), 0, 0);
sic_setup(poltocar_class, poltocar_dsp, SIC_FLOATTOSIGNAL);
}
void mstosamps_tilde_setup(void)
{
mstosamps_class = class_new(gensym("mstosamps~"),
(t_newmethod)mstosamps_new, 0,
sizeof(t_mstosamps), 0, 0);
sic_setup(mstosamps_class, mstosamps_dsp, mstosamps_float);
}
void cartopol_tilde_setup(void)
{
cartopol_class = class_new(gensym("cartopol~"),
(t_newmethod)cartopol_new, 0,
sizeof(t_cartopol), 0, 0);
sic_setup(cartopol_class, cartopol_dsp, SIC_FLOATTOSIGNAL);
}
void Clip_tilde_setup(void)
{
clip_class = class_new(gensym("Clip~"),
(t_newmethod)clip_new, 0,
sizeof(t_clip), 0, A_GIMME, 0);
sic_setup(clip_class, clip_dsp, SIC_FLOATTOSIGNAL);
}
void pow_tilde_setup(void)
{
pow_class = class_new(gensym("pow~"),
(t_newmethod)pow_new, 0,
sizeof(t_pow), 0, A_DEFFLOAT, 0);
sic_setup(pow_class, pow_dsp, SIC_FLOATTOSIGNAL);
}
void matrix_tilde_setup(void)
{
matrixps_matrixtilde = gensym("matrix~");
matrix_class = class_new(matrixps_matrixtilde,
(t_newmethod)matrix_new,
(t_method)matrix_free,
sizeof(t_matrix), 0, A_GIMME, 0);
fragile_class_raise(matrixps_matrixtilde, (t_newmethod)matrix_new);
sic_setup(matrix_class, matrix_dsp, matrix_float);
class_addlist(matrix_class, matrix_list);
class_addmethod(matrix_class, (t_method)matrix_clear,
gensym("clear"), 0);
class_addmethod(matrix_class, (t_method)matrix_set,
gensym("set"), A_FLOAT, A_DEFFLOAT, 0);
class_addmethod(matrix_class, (t_method)matrix_connect,
gensym("connect"), A_GIMME, 0);
class_addmethod(matrix_class, (t_method)matrix_connect,
gensym("disconnect"), A_GIMME, 0);
class_addmethod(matrix_class, (t_method)matrix_ramp,
gensym("ramp"), A_FLOAT, 0);
class_addmethod(matrix_class, (t_method)matrix_dump,
gensym("dump"), 0);
class_addmethod(matrix_class, (t_method)matrix_dumptarget,
gensym("dumptarget"), 0);
class_addmethod(matrix_class, (t_method)matrix_print,
gensym("print"), 0);
#ifdef MATRIX_DEBUG
class_addmethod(matrix_class, (t_method)matrix_debug,
gensym("debug"), A_DEFSYM, 0);
#endif
fitter_setup(matrix_class, 0);
}
void kink_tilde_setup(void)
{
kink_class = class_new(gensym("kink~"),
(t_newmethod)kink_new, 0,
sizeof(t_kink), 0, A_GIMME, 0);
sic_setup(kink_class, kink_dsp, SIC_FLOATTOSIGNAL);
}
void sampstoms_tilde_setup(void)
{
sampstoms_class = class_new(gensym("sampstoms~"),
(t_newmethod)sampstoms_new, 0,
sizeof(t_sampstoms), 0, 0);
sic_setup(sampstoms_class, sampstoms_dsp, sampstoms_float);
}
/* optional: freefn, blockfn, floatfn */
t_class *riddle_setup(t_symbol *name, t_newmethod newfn, t_method freefn,
size_t sz, t_method floatfn,
t_rdblockfn blockfn, t_rddspfn dspfn)
{
t_class *c = class_new(name, (t_newmethod)riddle_new,
(t_method)riddle_free, sz, 0, A_GIMME, 0);
/* IFBUILTIN remove: this is a bad hack */
t_pd *en = riddle_getenvironment();
class_addmethod(*en, (t_method)newfn, name, 0);
if (strlen(name->s_name) < 60)
{
char rdstr[64];
sprintf(rdstr, "rd.%s", name->s_name);
class_addcreator((t_newmethod)riddle_new, gensym(rdstr), A_GIMME, 0);
class_addmethod(*en, (t_method)newfn, gensym(rdstr), 0);
}
rdps__reblock = gensym("_reblock");
rdps__ = gensym("_");
sic_setup(c, riddle_dsp, floatfn);
if (blockfn)
class_addmethod(c, (t_method)blockfn, gensym("dspblock"), 0);
/* IFBUILTIN "_dsp" -> "dsp" */
class_addmethod(c, (t_method)dspfn, gensym("_dsp"), 0);
/* IFBUILTIN remove these two */
class_addmethod(c, (t_method)newfn, gensym("_new"), 0);
if (freefn)
class_addmethod(c, (t_method)freefn, gensym("_free"), 0);
class_addmethod(c, (t_method)riddle__reblock,
rdps__reblock, A_FLOAT, A_SYMBOL, A_FLOAT, A_FLOAT, 0);
return (c);
}
void tanx_tilde_setup(void)
{
tanx_class = class_new(gensym("tanx~"),
(t_newmethod)tanx_new, 0,
sizeof(t_tanx), 0, 0);
sic_setup(tanx_class, tanx_dsp, SIC_FLOATTOSIGNAL);
}
void sah_tilde_setup(void)
{
sah_class = class_new(gensym("sah~"),
(t_newmethod)sah_new, 0,
sizeof(t_sah), 0, A_DEFFLOAT, 0);
sic_setup(sah_class, sah_dsp, sah_float);
}
void acos_tilde_setup(void)
{
acos_class = class_new(gensym("acos~"),
(t_newmethod)acos_new, 0,
sizeof(t_acos), 0, 0);
sic_setup(acos_class, acos_dsp, SIC_FLOATTOSIGNAL);
}
void atanh_tilde_setup(void)
{
atanh_class = class_new(gensym("atanh~"),
(t_newmethod)atanh_new, 0,
sizeof(t_atanh), 0, 0);
sic_setup(atanh_class, atanh_dsp, SIC_FLOATTOSIGNAL);
}
void rand_tilde_setup(void)
{
rand_class = class_new(gensym("rand~"),
(t_newmethod)rand_new, 0,
sizeof(t_rand), 0,
A_DEFFLOAT, 0);
sic_setup(rand_class, rand_dsp, SIC_FLOATTOSIGNAL);
}
void minmax_tilde_setup(void)
{
minmax_class = class_new(gensym("minmax~"),
(t_newmethod)minmax_new, 0, sizeof(t_minmax), 0, 0);
sic_setup(minmax_class, minmax_dsp, SIC_FLOATTOSIGNAL);
class_addbang(minmax_class, minmax_bang);
class_addmethod(minmax_class, (t_method)minmax_reset, gensym("reset"), 0);
}
void train_tilde_setup(void)
{
train_class = class_new(gensym("train~"),
(t_newmethod)train_new,
(t_method)train_free,
sizeof(t_train), 0, A_GIMME, 0);
sic_setup(train_class, train_dsp, SIC_FLOATTOSIGNAL);
}
void cycle_tilde_setup(void)
{
cycle_class = class_new(gensym("cycle~"),
(t_newmethod)cycle_new, 0,
sizeof(t_cycle), 0, A_GIMME, 0);
sic_setup(cycle_class, cycle_dsp, SIC_FLOATTOSIGNAL);
class_addmethod(cycle_class, (t_method)cycle_set,
gensym("set"), A_DEFSYMBOL, A_DEFFLOAT, 0);
}
void delay_tilde_setup(void)
{
delay_class = class_new(gensym("delay~"),
(t_newmethod)delay_new, (t_method)delay_free,
sizeof(t_delay), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
sic_setup(delay_class, delay_dsp, SIC_FLOATTOSIGNAL);
class_addmethod(delay_class, (t_method)delay_ft1,
gensym("ft1"), A_FLOAT, 0);
}
void zerox_tilde_setup(void)
{
zerox_class = class_new(gensym("zerox~"),
(t_newmethod)zerox_new, 0,
sizeof(t_zerox), 0, A_DEFFLOAT, 0);
sic_setup(zerox_class, zerox_dsp, SIC_FLOATTOSIGNAL);
class_addmethod(zerox_class, (t_method)zerox_set,
gensym("set"), A_FLOAT, 0); /* CHECKED arg obligatory */
}
void log_tilde_setup(void)
{
log_class = class_new(gensym("cyclone/log~"),
(t_newmethod)log_new, 0,
sizeof(t_log), 0, A_DEFFLOAT, 0);
sic_setup(log_class, log_dsp, SIC_FLOATTOSIGNAL);
class_addmethod(log_class, (t_method)log_ft1,
gensym("ft1"), A_FLOAT, 0);
}
void abs_tilde_setup(void)
{
abs_class = class_new(gensym("abs~"),
(t_newmethod)abs_new, 0,
sizeof(t_abs), 0, 0);
sic_setup(abs_class, abs_dsp, SIC_FLOATTOSIGNAL);
#ifdef ABS_TEST
fitter_setup(abs_class, 0);
#endif
}
void overdrive_tilde_setup(void)
{
overdrive_class = class_new(gensym("overdrive~"),
(t_newmethod)overdrive_new, 0,
sizeof(t_overdrive), 0, A_DEFFLOAT, 0);
/* CHECKED no float-to-signal conversion */
sic_setup(overdrive_class, overdrive_dsp, overdrive_float);
class_addmethod(overdrive_class, (t_method)overdrive_ft1,
gensym("ft1"), A_FLOAT, 0);
}
void pink_tilde_setup(void)
{
pink_class = class_new(gensym("pink~"),
(t_newmethod)pink_new, 0,
sizeof(t_pink), 0, 0);
/* dummy float method: we need signal in (for begin~), but neither
float-to-signal conversion, nor a float method (the only control
input is 'enable'). LATER rethink. */
sic_setup(pink_class, pink_dsp, pink_float);
}
void bitnot_tilde_setup(void)
{
bitnot_class = class_new(gensym("bitnot~"),
(t_newmethod)bitnot_new, 0,
sizeof(t_bitnot), 0,
A_DEFFLOAT, 0);
sic_setup(bitnot_class, bitnot_dsp, SIC_FLOATTOSIGNAL);
class_addmethod(bitnot_class, (t_method)bitnot_mode,
gensym("mode"), A_FLOAT, 0);
}
void triangle_tilde_setup(void)
{
triangle_class = class_new(gensym("triangle~"),
(t_newmethod)triangle_new, 0,
sizeof(t_triangle), 0, A_GIMME, 0);
sic_setup(triangle_class, triangle_dsp, SIC_FLOATTOSIGNAL);
class_addmethod(triangle_class, (t_method)triangle_lo,
gensym("lo"), A_DEFFLOAT, 0); /* CHECKED */
class_addmethod(triangle_class, (t_method)triangle_hi,
gensym("hi"), A_DEFFLOAT, 0); /* CHECKED */
}
void peakamp_tilde_setup(void)
{
peakamp_class = class_new(gensym("peakamp~"),
(t_newmethod)peakamp_new,
(t_method)peakamp_free,
sizeof(t_peakamp), 0,
A_DEFFLOAT, 0);
sic_setup(peakamp_class, peakamp_dsp, SIC_FLOATTOSIGNAL);
class_addbang(peakamp_class, peakamp_bang);
class_addmethod(peakamp_class, (t_method)peakamp_ft1,
gensym("ft1"), A_FLOAT, 0);
}