static void *susloop_new(t_symbol *s, int argc, t_atom *argv)
{
t_susloop *x = (t_susloop *)pd_new(susloop_class);
int looptype = 0;
x->a = x->b = x->startpos = 0;
x->direction = 1;
x->susloop_func = susloop_forward;
switch (argc) {
case 4:
x->startpos = atom_getfloat(argv+3);
case 3:
looptype = atom_getint(argv+2);
if (looptype == 0)
x->susloop_func = susloop_forward;
else
x->susloop_func = susloop_pingpong;
case 2:
x->a = atom_getfloat(argv);
x->b = atom_getfloat(argv+1);
}
floatinlet_new(&x->x_obj, &x->a);
floatinlet_new(&x->x_obj, &x->b);
floatinlet_new(&x->x_obj, &x->startpos);
outlet_new(&x->x_obj, gensym("signal"));
return (x);
}
static void *operatord_new(t_symbol *s, int argc, t_atom *argv) {
t_operatord *x = (t_operatord *)pd_new(operatord_class);
outlet_new(&x->x_obj, &s_signal);
switch(argc) {
default:;
case 2:
floatinlet_new(&x->x_obj, &x->invals[0].val);
x->invals[0].val = atom_getfloatarg(0, argc, argv);
floatinlet_new(&x->x_obj, &x->invals[1].val);
x->invals[1].val = atom_getfloatarg(1, argc, argv);
x->num = 2;
break;
case 1:
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
floatinlet_new(&x->x_obj, &x->invals[1].val);
x->invals[1].val = atom_getfloatarg(0, argc, argv);
x->num = 1;
break;
case 0:
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
x->num = 0;
}
return(x);
}
static void *triangulator_new(t_symbol *s, int argc, t_atom *argv) {
t_triangulator *x = (t_triangulator *)pd_new(triangulator_class);
x->x_phase = 0.25;
outlet_new(&x->x_obj, &s_signal);
switch(argc) {
default:;
case 3:
x->x_f = atom_getfloatarg(2, argc, argv);
case 2:
floatinlet_new(&x->x_obj, &x->invals[0].val);
x->invals[0].val = atom_getfloatarg(0, argc, argv);
floatinlet_new(&x->x_obj, &x->invals[1].val);
x->invals[1].val = atom_getfloatarg(1, argc, argv);
x->num = 2;
break;
case 1:
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
floatinlet_new(&x->x_obj, &x->invals[1].val);
x->invals[1].val = atom_getfloatarg(0, argc, argv);
x->num = 1;
break;
case 0:
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
x->num = 0;
}
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft1"));
return(x);
}
void * hsi2rgb_new(void) {
t_hsi2rgb *x = (t_hsi2rgb*)pd_new(hsi2rgb_class);
floatinlet_new(&x->x_obj, &x->i_s);
floatinlet_new(&x->x_obj, &x->i_i);
x->o_r = outlet_new(&x->x_obj, &s_float);
x->o_g = outlet_new(&x->x_obj, &s_float);
x->o_b = outlet_new(&x->x_obj, &s_float);
return (void*)x;
}
static void *dklrnd_new(t_floatarg f, t_floatarg minmax){
t_dklrnd *x = (t_dklrnd *)pd_new(dklrnd_class);
x->x_f = f;
x->x_minmax = minmax;
x->x_state = linseed();
floatinlet_new(&x->x_obj, &x->x_f);
floatinlet_new(&x->x_obj, &x->x_minmax);
outlet_new(&x->x_obj, &s_float);
return (x);
}
static void *noteout_new(t_floatarg channel)
{
t_noteout *x = (t_noteout *)pd_new(noteout_class);
x->x_velo = 0;
if (channel < 1) channel = 1;
x->x_channel = channel;
floatinlet_new(&x->x_obj, &x->x_velo);
floatinlet_new(&x->x_obj, &x->x_channel);
return (x);
}
static void *ctlout_new(t_floatarg ctl, t_floatarg channel)
{
t_ctlout *x = (t_ctlout *)pd_new(ctlout_class);
x->x_ctl = ctl;
if (channel <= 0) channel = 1;
x->x_channel = channel;
floatinlet_new(&x->x_obj, &x->x_ctl);
floatinlet_new(&x->x_obj, &x->x_channel);
return (x);
}
static void *polytouchout_new(t_floatarg channel)
{
t_polytouchout *x = (t_polytouchout *)pd_new(polytouchout_class);
if (channel <= 0) channel = 1;
x->x_channel = channel;
x->x_pitch = 0;
floatinlet_new(&x->x_obj, &x->x_pitch);
floatinlet_new(&x->x_obj, &x->x_channel);
return (x);
}
void *lxpx_new (void)
{
t_lxpx *x = (t_lxpx *) pd_new (lxpx_class);
// floatinlet_new (&x->x_obj, &x->value);
floatinlet_new (&x->x_obj, &x->parameter);
floatinlet_new (&x->x_obj, &x->midi_channel);
outlet_new (&x->x_obj, &s_list);
return (void *) x;
}
static void *rand_weibull_new(t_floatarg s, t_floatarg t)
{
t_rand_weibull *x = (t_rand_weibull *)pd_new(rand_weibull_class);
srand( (unsigned)time( NULL ) );
floatinlet_new(&x->x_obj, &x->x_s);
floatinlet_new(&x->x_obj, &x->x_t);
outlet_new(&x->x_obj, &s_float);
x->x_s = s;
x->x_t = t;
return (x);
}
static void *clip_new(t_floatarg lo, t_floatarg hi)
{
t_clip *x = (t_clip *)pd_new(clip_class);
x->x_lo = lo;
x->x_hi = hi;
outlet_new(&x->x_obj, gensym("signal"));
floatinlet_new(&x->x_obj, &x->x_lo);
floatinlet_new(&x->x_obj, &x->x_hi);
x->x_f = 0;
return (x);
}
static void *makenote_new(t_floatarg velo, t_floatarg dur)
{
t_makenote *x = (t_makenote *)pd_new(makenote_class);
x->x_velo = velo;
x->x_dur = dur;
floatinlet_new(&x->x_obj, &x->x_velo);
floatinlet_new(&x->x_obj, &x->x_dur);
x->x_pitchout = outlet_new(&x->x_obj, &s_float);
x->x_velout = outlet_new(&x->x_obj, &s_float);
x->x_hang = 0;
return (x);
}
static void *deltas_new(t_float lo, t_float hi, t_float size)
{
t_deltas *x=(t_deltas *)pd_new(deltas_class);
outlet_new(&x->x_obj, gensym("list"));
x->m_buffer_size=0;
x->m_buffer=0;
deltas_set(x, lo, hi, size);
floatinlet_new(&x->x_obj, &x->m_lo);
floatinlet_new(&x->x_obj, &x->m_hi);
return (void *)x;
}
static void *highshelf_new(t_floatarg f,t_floatarg g,t_floatarg bw)
{
t_rbjfilter *x = (t_rbjfilter *)pd_new(highshelf_class);
x->x_rate = 44100.0;
outlet_new(&x->x_obj,&s_float);
floatinlet_new(&x->x_obj, &x->x_gain);
floatinlet_new(&x->x_obj, &x->x_bw);
if (f > 0.) x->x_freq = f;
if (bw > 0.) x->x_bw = bw;
if (g != 0.) x->x_gain = g;
return (x);
}
static void *vline_tilde_new(void)
{
t_vline *x = (t_vline *)pd_new(vline_tilde_class);
outlet_new(&x->x_obj, gensym("signal"));
floatinlet_new(&x->x_obj, &x->x_inlet1);
floatinlet_new(&x->x_obj, &x->x_inlet2);
x->x_inlet1 = x->x_inlet2 = 0;
x->x_value = x->x_inc = 0;
x->x_referencetime = clock_getlogicaltime();
x->x_list = 0;
x->x_samppermsec = 0;
return (x);
}
static void *xnoteout_new(t_floatarg f)
{
t_xnoteout *x = (t_xnoteout *)pd_new(xnoteout_class);
floatinlet_new((t_object *)x, &x->x_velocity);
floatinlet_new((t_object *)x, &x->x_flag);
floatinlet_new((t_object *)x, &x->x_channel);
outlet_new((t_object *)x, &s_float);
x->x_channel = ((int)f > 0 ? f : 1); /* CHECKME */
x->x_flag = 0; /* CHECKME */
x->x_velocity = 0; /* CHECKME */
x->x_pitch = -1; /* CHECKME */
return (x);
}
// constructor
void *gauss_new(t_floatarg mean, t_floatarg stddev)
{
t_gauss *x = (t_gauss *)pd_new(gauss_class);
x->mean = mean;
x->stddev = stddev;
floatinlet_new(&x->x_obj, &x->mean);
floatinlet_new(&x->x_obj, &x->stddev);
outlet_new(&x->x_obj, &s_float);
return (void *)x;
}
void *randomwalk_new(t_symbol *s, int argc, t_atom *argv)
/* 3 arguments: lowbound, highbound, width */
{
t_randomwalk *x = (t_randomwalk *)pd_new(randomwalk_class); // x points to new randomwalk obj
t_float lowbound = 0, highbound = 0; // initialize both bounds
x->step = 1; // set default step width to 1
switch(argc)
{
default:
case 3:
x->step = atom_getfloat(argv + 2);
case 2:
highbound = atom_getfloat(argv + 1);
case 1:
lowbound = atom_getfloat(argv);
break;
case 0:
;
}
if(argc < 2) // in case of only two arguments, set low-bound to 0
{
highbound = lowbound;
lowbound = 0;
}
if(highbound > lowbound) // make sure that low-bound is actually lower than high-bound...
{
x->lower = lowbound;
x->upper = highbound;
}
else // ...and swap the values if not
{
x->lower = highbound;
x->upper = lowbound;
}
x->current = x->lower; // initialize the current value to the low-bound, should
// this initialize to the mid-point instead?
floatinlet_new(&x->x_obj, &x->lower); // inlets for dynamic bound and step values
floatinlet_new(&x->x_obj, &x->upper);
floatinlet_new(&x->x_obj, &x->step);
x->f_out = outlet_new(&x->x_obj, &s_float); // output the float value
return (void *) x;
}
static void *clip_new(t_symbol *s, int ac, t_atom *av)
{
t_clip *x = (t_clip *)pd_new(clip_class);
x->x_f1 = 0;
x->x_f2 = 0;
x->x_size = CLIP_INISIZE;
x->x_message = x->x_messini;
x->x_entered = 0;
floatinlet_new((t_object *)x, &x->x_f1);
floatinlet_new((t_object *)x, &x->x_f2);
outlet_new(&x->x_ob, &s_anything);
clip_set(x, 0, ac, av);
return (x);
}
static void *foldback_tilde_new(t_floatarg low, t_floatarg high)
{
t_foldback_tilde *x = (t_foldback_tilde *)pd_new(foldback_tilde_class);
x->x_low = low;
x->x_high = high;
outlet_new(&x->x_obj, gensym("signal"));
floatinlet_new(&x->x_obj, &x->x_low);
floatinlet_new(&x->x_obj, &x->x_high);
x->x_f = 0;
if(low) x->x_low = low;
else x->x_low = -1;
if(high) x->x_high = high;
else x->x_high = 1;
return (x);
}
static void *foldover_tilde_new(t_floatarg drive_p, t_floatarg push)
{
t_foldover_tilde *x = (t_foldover_tilde *)pd_new(foldover_tilde_class);
x->x_drive_p = drive_p;
x->x_push = push;
outlet_new(&x->x_obj, gensym("signal"));
floatinlet_new(&x->x_obj, &x->x_drive_p);
floatinlet_new(&x->x_obj, &x->x_push);
x->x_f = 0;
if(drive_p) x->x_drive_p = drive_p;
else x->x_drive_p = 0;
if(push) x->x_push = push;
else x->x_push = 0;
return (x);
}
/////////////////////////////////////////////////////////
//
// pix_tIIRf
//
/////////////////////////////////////////////////////////
// Constructor
//
/////////////////////////////////////////////////////////
pix_tIIRf :: pix_tIIRf(t_floatarg fb_numf, t_floatarg ff_numf)
: m_set(SET),
m_ff(NULL), m_fb(NULL),
m_ffnum(0), m_fbnum(0),
m_buffer(NULL),
m_bufnum(0),
m_counter(0),
m_inlet(NULL)
{
int fb_num = (fb_numf>0.)?static_cast<int>(fb_numf):0;
int ff_num = (ff_numf>0.)?static_cast<int>(ff_numf):0;
fb_num++;
ff_num++;
m_ffnum=ff_num;
m_fbnum=fb_num;
m_inlet = new t_inlet*[fb_num+ff_num];
t_inlet **inlet = m_inlet;
m_fb = new t_float[fb_num];
m_ff = new t_float[ff_num];
int i=0;
while(i<fb_num){
m_fb[i]=0.0;
*inlet++=floatinlet_new(this->x_obj, m_fb+i);
i++;
}
m_fb[0]=1.0;
i=0;
while(i<ff_num){
m_ff[i]=0.0;
*inlet++=floatinlet_new(this->x_obj, m_ff+i);
i++;
}
m_ff[0]=1.0;
m_bufnum=1+MAX(fb_num,ff_num); // 1 for output, rest for FF/FB
m_buffer = new t_float*[m_bufnum];
for(i=0; i<m_bufnum; i++)
m_buffer[i]=NULL;
m_image.xsize=0;
m_image.ysize=0;
m_image.setCsizeByFormat(GL_RGBA_GEM);
}
static void *vvminus_new(t_symbol *s, int argc, t_atom *argv)
{
t_vvminus *x;
if (argc-1){
x = (t_vvminus *)pd_new(vvminus_class);
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("list"), gensym(""));
} else x = (t_vvminus *)pd_new(vvminus_scal_class);
outlet_new(&x->x_obj, 0);
x->n1 =1;
x->buf1 =(t_float*)getbytes(sizeof(t_float));
*x->buf1=0;
if (argc)vvminus_lst2(x, gensym("list"), argc, argv);
else {
x->n2 =1;
x->buf2 =(t_float*)getbytes(sizeof(t_float));
*x->buf2=0;
}
if (argc==1)floatinlet_new(&x->x_obj, x->buf2);
return (x);
}
static void *graid_new(t_symbol *s, int argc, t_atom *argv) {
t_graid *x = (t_graid *)pd_new(graid_class);
outlet_new(&x->x_obj, &s_float);
floatinlet_new(&x->x_obj, &x->x_min);
floatinlet_new(&x->x_obj, &x->x_max);
floatinlet_new(&x->x_obj, &x->x_scl);
t_float min=0, max=1, scale=100;
switch (argc)
{ case 3: scale=atom_getfloat(argv+2); // no break
case 2:
max=atom_getfloat(argv+1);
min=atom_getfloat(argv); break;
case 1: max=atom_getfloat(argv); }
x->x_min=min, x->x_max=max, x->x_scl=scale;
return (x);
}
void *liaKD_new(t_symbol *s, t_floatarg L, t_floatarg K, t_floatarg D, t_floatarg D2 )
{
t_liaKD *x = (t_liaKD *)pd_new(liaKD_class);
x->x_sym = s;
pd_bind(&x->x_obj.ob_pd, s);
floatinlet_new(&x->x_obj, &x->position2);
x->force1=outlet_new(&x->x_obj, 0);
x->force2=outlet_new(&x->x_obj, 0);
x->position1 = 0;
x->position2 = 0;
x->raideur=K;
x->viscosite=D;
x->D2=D2;
x->Lmin= 0;
x->Lmax= 10000;
x->longueur=L;
return (void *)x;
}
static void *dkeuclid_new(t_floatarg f1, t_floatarg f2){
int n, k, m;
t_dkeuclid *x = (t_dkeuclid *)pd_new(dkeuclid_class);
n = f1;
k = f2;
if(k > n){n=k;};
m = n-k;
x->n = (t_float)n;
x->k = (t_float)k;
x->m = (t_float)m;
floatinlet_new(&x->x_obj, &x->n);
floatinlet_new(&x->x_obj, &x->k);
outlet_new(&x->x_obj, &s_list);
x->x_flout = outlet_new(&x->x_obj, &s_float);
return (x);
}
void *template_new(t_symbol *s, int argc, t_atom *argv)
{
t_template *x = (t_template *)pd_new(template_class);
t_float f1=0, f2=0;
x->step=1;
switch(argc){
default:
case 3:
x->step=atom_getfloat(argv+2);
case 2:
f2=atom_getfloat(argv+1);
case 1:
f1=atom_getfloat(argv);
break;
case 0:
break;
}
if (argc<2)f2=f1;
x->i_down = (f1<f2)?f1:f2;
x->i_up = (f1>f2)?f1:f2;
x->i_count=x->i_down;
inlet_new(&x->x_obj, &x->x_obj.ob_pd,
gensym("list"), gensym("bound"));
floatinlet_new(&x->x_obj, &x->step);
x->f_out = outlet_new(&x->x_obj, &s_float);
x->b_out = outlet_new(&x->x_obj, &s_bang);
return (void *)x;
}
// constructor
void *annealing_new(t_symbol *s, t_float f, t_float scale)
{
srand(time(NULL)); // seed the random number generator only once
t_annealing *x = (t_annealing *)pd_new(annealing_class);
x->arrayname = s;
if (f > 0)
x->temp = f;
else
x->temp = 1;
if (scale > 0)
x->scalingFactor = scale;
else
x->scalingFactor = DEFAULT_SCALING;
x->pIndex = -1;
// inlets & outlets
floatinlet_new(&x->x_obj, &x->temp);
x->parentOut = outlet_new(&x->x_obj, &s_float);
x->bestOut = outlet_new(&x->x_obj, &s_float);
return (void *)x;
}
/*--------------------------------------------------------------------
* new
*/
static void *bytes2any_new(MOO_UNUSED t_symbol *sel, int argc, t_atom *argv)
{
t_bytes2any *x = (t_bytes2any *)pd_new(bytes2any_class);
int bufsize = BYTES2ANY_DEFAULT_BUFLEN;
//-- defaults
x->x_binbuf = binbuf_new();
x->x_eos = -1;
//-- args: 0: bufsize
if (argc > 0) {
int initial_bufsize = atom_getintarg(0,argc,argv);
if (initial_bufsize > 0) bufsize = initial_bufsize;
x->x_eos = -1; //-- backwards-compatibility hack: no default eos character if only bufsize is specified
}
//-- args: 1: separator
if (argc > 1) {
x->x_eos = atom_getfloatarg(1,argc,argv);
}
//-- allocate x_bytes
pdstring_bytes_init(&x->x_bytes, bufsize);
//-- inlets
x->x_eos_in = floatinlet_new(&x->x_obj, &x->x_eos);
//-- outlets
x->x_outlet = outlet_new(&x->x_obj, &s_list);
x->x_outlet_done = outlet_new(&x->x_obj, &s_bang);
//-- debug
S2ADEBUG(post("bytes2any_new: x=%p, binbuf=%p, bytes.alloc=%d", x, x->x_eos, x->x_binbuf, x->x_bytes.b_alloc));
return (void *)x;
}
/*--------------------------------------------------------------------
* new
*/
static void *any2bytes_new(MOO_UNUSED t_symbol *sel, int argc, t_atom *argv)
{
t_any2bytes *x = (t_any2bytes *)pd_new(any2bytes_class);
int bufsize = ANY2BYTES_DEFAULT_BUFLEN;
//-- defaults
x->x_eos = 0;
//-- args: 0: bufsize
if (argc > 0) {
int initial_bufsize = atom_getintarg(0, argc, argv);
if (initial_bufsize > 0) { bufsize = initial_bufsize; }
}
//-- args: 1: eos
if (argc > 1) {
x->x_eos = atom_getfloatarg(1, argc, argv);
}
//-- allocate
pdstring_bytes_init(&x->x_bytes, 0); //-- x_bytes gets clobbered by binbuf_gettext()
pdstring_atoms_init(&x->x_atoms, bufsize);
x->x_binbuf = binbuf_new();
//-- inlets
x->x_eos_in = floatinlet_new(&x->x_obj, &x->x_eos);
//-- outlets
x->x_outlet = outlet_new(&x->x_obj, &s_list);
//-- report
A2SDEBUG(post("any2bytes_new(): x=%p, eos=%d, binbuf=%p", x, x->x_eos, x->x_binbuf));
return (void *)x;
}
