Exemple #1
0
void maxlib_step_setup(void)
{
    step_class = class_new(gensym("maxlib/step"), (t_newmethod)step_new,
    	(t_method)step_free, sizeof(t_step), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
	class_addcreator((t_newmethod)step_new, gensym("step"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
    class_addmethod(step_class, (t_method)step_ft1, gensym("ft1"), A_FLOAT, 0);
	class_addmethod(step_class, (t_method)step_ft2, gensym("ft2"), A_FLOAT, 0);
    class_addmethod(step_class, (t_method)step_stop, gensym("stop"), 0);
    class_addfloat(step_class, (t_method)step_float);
	class_sethelpsymbol(step_class, gensym("maxlib/step-help.pd"));
}
Exemple #2
0
void vvplus_setup(void)
{
  vvplus_class = class_new(gensym("vvplus"), (t_newmethod)vvplus_new, 
			    (t_method)vvplus_free, sizeof(t_vvplus), 0, A_GIMME, 0);
  class_addcreator((t_newmethod)vvplus_new, gensym("vv+"), A_GIMME, 0);
  class_addlist(vvplus_class, vvplus_lst);
  class_addmethod  (vvplus_class, (t_method)vvplus_lst2, gensym(""), A_GIMME, 0);
  vvplus_scal_class = class_new(gensym("vv+"), 0, (t_method)vvplus_free, 
				 sizeof(t_vvplus), 0, 0);
  class_addlist(vvplus_scal_class, vvplus_lst);
}
Exemple #3
0
void Snapshot_tilde_setup(void)
{
    snapshot_class = class_new(gensym("Snapshot~"),
			       (t_newmethod)snapshot_new,
			       (t_method)snapshot_free,
			       sizeof(t_snapshot), 0,
			       A_DEFFLOAT, A_DEFFLOAT, 0);
    class_addcreator((t_newmethod)snapshot_new, gensym("snapshot~"), A_DEFFLOAT, A_DEFFLOAT, 0);
    class_addcreator((t_newmethod)snapshot_new, gensym("cyclone/snapshot~"), A_DEFFLOAT, A_DEFFLOAT, 0);
    sic_setup(snapshot_class, snapshot_dsp, snapshot_float);
    class_addbang(snapshot_class, snapshot_bang);
    class_addmethod(snapshot_class, (t_method)snapshot_ft1,
		    gensym("ft1"), A_FLOAT, 0);
    class_addmethod(snapshot_class, (t_method)snapshot_offset,
		    gensym("offset"), A_FLOAT, 0);
    class_addmethod(snapshot_class, (t_method)snapshot_start,
		    gensym("start"), 0);
    class_addmethod(snapshot_class, (t_method)snapshot_stop,
		    gensym("stop"), 0);
}
Exemple #4
0
static void delay_setup(void)
{
    delay_class = class_new(gensym("delay"), (t_newmethod)delay_new,
    	(t_method)delay_free, sizeof(t_delay), 0, A_DEFFLOAT, 0);
    class_addcreator((t_newmethod)delay_new, gensym("del"), A_DEFFLOAT, 0);
    class_addbang(delay_class, delay_bang);
    class_addmethod(delay_class, (t_method)delay_stop, gensym("stop"), 0);
    class_addmethod(delay_class, (t_method)delay_ft1,
    	gensym("ft1"), A_FLOAT, 0);
    class_addfloat(delay_class, (t_method)delay_float);
}
Exemple #5
0
void Scope_tilde_setup(void)
{
    scope_class = class_new(gensym("Scope~"),
			    (t_newmethod)scope_new,
			    (t_method)scope_free,
			    sizeof(t_scope), 0, A_GIMME, 0);
    class_addcreator((t_newmethod)scope_new, gensym("scope~"), A_GIMME, 0);
    class_addcreator((t_newmethod)scope_new, gensym("cyclone/scope~"), A_GIMME, 0);
    sic_setup(scope_class, scope_dsp, scope_float);
    class_addmethod(scope_class, (t_method)scope_bufsize,
		    gensym("bufsize"), A_GIMME, 0);
    class_addmethod(scope_class, (t_method)scope_range,
		    gensym("range"), A_GIMME, 0);
    class_addmethod(scope_class, (t_method)scope_delay,
		    gensym("delay"), A_GIMME, 0);
    class_addmethod(scope_class, (t_method)scope_trigger,
		    gensym("trigger"), A_GIMME, 0);
    class_addmethod(scope_class, (t_method)scope_triglevel,
		    gensym("triglevel"), A_GIMME, 0);
    class_addmethod(scope_class, (t_method)scope_frgb,
		    gensym("frgb"), A_GIMME, 0);
    class_addmethod(scope_class, (t_method)scope_brgb,
		    gensym("brgb"), A_GIMME, 0);
    class_addmethod(scope_class, (t_method)scope_grgb,
		    gensym("grgb"), A_GIMME, 0);
    class_addmethod(scope_class, (t_method)scope_click,
		    gensym("click"),
		    A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, 0);
     class_addmethod(scope_class, (t_method)scope_resize,
		    gensym("resize"),
		    A_FLOAT, A_FLOAT, 0);
    class_setwidget(scope_class, &scope_widgetbehavior);
    forky_setsavefn(scope_class, scope_save);
    scopehandle_class = class_new(gensym("_scopehandle"), 0, 0,
				  sizeof(t_scopehandle), CLASS_PD, 0);
    class_addmethod(scopehandle_class, (t_method)scopehandle__clickhook,
		    gensym("_click"), A_FLOAT, 0);
    class_addmethod(scopehandle_class, (t_method)scopehandle__motionhook,
		    gensym("_motion"), A_FLOAT, A_FLOAT, 0);
    fitter_setup(scope_class, 0);
}
static void trigger_setup(void)
{
    trigger_class = class_new(gensym("trigger"), (t_newmethod)trigger_new,
    	(t_method)trigger_free, sizeof(t_trigger), 0, A_GIMME, 0);
    class_addcreator((t_newmethod)trigger_new, gensym("t"), A_GIMME, 0);
    class_addlist(trigger_class, trigger_list);
    class_addbang(trigger_class, trigger_bang);
    class_addpointer(trigger_class, trigger_pointer);
    class_addfloat(trigger_class, (t_method)trigger_float);
    class_addsymbol(trigger_class, trigger_symbol);
    class_addanything(trigger_class, trigger_anything);
}
Exemple #7
0
/////////////////////////////////////////////////////////
// static member function
//
/////////////////////////////////////////////////////////
void pix_buffer_write :: obj_setupCallback(t_class *classPtr)
{
  class_addcreator(reinterpret_cast<t_newmethod>(create_pix_buffer_write),
                   gensym("pix_put"),
                   A_DEFSYM, A_NULL);
  class_addmethod(classPtr,
                  reinterpret_cast<t_method>(&pix_buffer_write::setMessCallback),
                  gensym("set"), A_SYMBOL, A_NULL);
  class_addmethod(classPtr,
                  reinterpret_cast<t_method>(&pix_buffer_write::frameMessCallback),
                  gensym("frame"), A_FLOAT, A_NULL);
}
Exemple #8
0
void pdp_3d_push_setup(void)
{


    pdp_3d_push_class = class_new(gensym("3dp_push"), (t_newmethod)pdp_3d_push_new,
    	(t_method)pdp_3d_push_free, sizeof(t_pdp_3d_push), 0, A_DEFSYMBOL, A_NULL);

    class_addcreator((t_newmethod)pdp_3d_mode_new, gensym("3dp_mode"), A_DEFSYMBOL, A_NULL);

    pdp_3dp_base_setup(pdp_3d_push_class);

}
Exemple #9
0
void select_setup(void)
{
    sel1_proxy_class = class_new(gensym("select_inlet"),
        0, 0, sizeof(t_sel1_proxy), 0, 0);
    class_addfloat(sel1_proxy_class, (t_method)sel1_proxy_float);
    class_addsymbol(sel1_proxy_class, (t_method)sel1_proxy_symbol);
    sel1_class = class_new(gensym("select"), 0, 0,
        sizeof(t_sel1), 0, 0);
    class_addfloat(sel1_class, sel1_float);
    class_addsymbol(sel1_class, sel1_symbol);
    class_addbang(sel1_class, sel1_bang);

    sel2_class = class_new(gensym("select"), 0, (t_method)sel2_free,
        sizeof(t_sel2), 0, 0);
    class_addfloat(sel2_class, sel2_float);
    class_addsymbol(sel2_class, sel2_symbol);
	class_addbang(sel2_class, sel2_bang);

    class_addcreator((t_newmethod)select_new, gensym("select"),  A_GIMME, 0);
    class_addcreator((t_newmethod)select_new, gensym("sel"),  A_GIMME, 0);
}
static void receive_setup(void)
{
    receive_class = class_new(gensym("receive"), (t_newmethod)receive_new, 
    	(t_method)receive_free, sizeof(t_receive), CLASS_NOINLET, A_DEFSYM, 0);
    class_addcreator((t_newmethod)receive_new, gensym("r"), A_DEFSYM, 0);
    class_addbang(receive_class, receive_bang);
    class_addfloat(receive_class, (t_method)receive_float);
    class_addsymbol(receive_class, receive_symbol);
    class_addpointer(receive_class, receive_pointer);
    class_addlist(receive_class, receive_list);
    class_addanything(receive_class, receive_anything);
}
Exemple #11
0
void masse_setup(void) 
{

  masse_class = class_new(gensym("masse"),
        (t_newmethod)masse_new,
        (t_method)masse_free,
		sizeof(t_masse),
        CLASS_DEFAULT, A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT,0);
  class_addcreator((t_newmethod)masse_new, gensym("mass"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT,0);
  class_addcreator((t_newmethod)masse_new, gensym("pmpd.mass"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT,0);
  class_addfloat(masse_class, masse_float);
  class_addbang(masse_class, masse_bang);
  class_addmethod(masse_class, (t_method)masse_set_masse, gensym("setM"), A_DEFFLOAT, 0);
  class_addmethod(masse_class, (t_method)masse_setX, gensym("setX"), A_DEFFLOAT, 0);
  class_addmethod(masse_class, (t_method)masse_dX, gensym("dX"), A_DEFFLOAT, 0);
  class_addmethod(masse_class, (t_method)masse_reset, gensym("reset"), 0);
  class_addmethod(masse_class, (t_method)masse_resetF, gensym("resetF"), 0);
  class_addmethod(masse_class, (t_method)masse_minX, gensym("setXmin"), A_DEFFLOAT, 0);
  class_addmethod(masse_class, (t_method)masse_maxX, gensym("setXmax"), A_DEFFLOAT, 0);
  class_addmethod(masse_class, (t_method)masse_loadbang, gensym("loadbang"), 0);
}
Exemple #12
0
void toggle_mess_setup(void)
{
  toggle_mess_class = class_new(gensym("toggle_mess"), (t_newmethod)toggle_mess_new,
    (t_method)toggle_mess_free, sizeof(t_toggle_mess), 0, A_GIMME, 0);
  class_addcreator((t_newmethod)toggle_mess_new, gensym("tm"), A_GIMME, 0);
  class_addbang(toggle_mess_class, (t_method)toggle_mess_bang);
  class_addmethod(toggle_mess_class, (t_method)toggle_mess_set, gensym("set"), A_GIMME, 0);
  class_addfloat(toggle_mess_class, (t_method)toggle_mess_float);
  class_addsymbol(toggle_mess_class, toggle_mess_symbol);
  class_addanything(toggle_mess_class, toggle_mess_anything);
//  class_sethelpsymbol(toggle_mess_class, gensym("iemhelp/help-toggle_mess"));
}
static void send_setup(void)
{
    send_class = class_new(gensym("send"), (t_newmethod)send_new, 0,
    	sizeof(t_send), 0, A_DEFSYM, 0);
    class_addcreator((t_newmethod)send_new, gensym("s"), A_DEFSYM, 0);
    class_addbang(send_class, send_bang);
    class_addfloat(send_class, send_float);
    class_addsymbol(send_class, send_symbol);
    class_addpointer(send_class, send_pointer);
    class_addlist(send_class, send_list);
    class_addanything(send_class, send_anything);
}
Exemple #14
0
void x_list_setup(void)
{
    alist_setup();
    list_append_setup();
    list_prepend_setup();
    list_split_setup();
    list_trim_setup();
    list_length_setup();
    list_fromsymbol_setup();
    list_tosymbol_setup();
    class_addcreator((t_newmethod)list_new, &s_list, A_GIMME, 0);
}
Exemple #15
0
void maxlib_rhythm_setup(void)
{
    rhythm_class = class_new(gensym("maxlib_rhythm"), (t_newmethod)rhythm_new,
    	(t_method)rhythm_free, sizeof(t_rhythm), 0, A_DEFFLOAT, 0);
	class_addcreator((t_newmethod)rhythm_new, gensym("rhythm"), A_DEFFLOAT, 0);
    class_addfloat(rhythm_class, rhythm_float);
	class_addmethod(rhythm_class, (t_method)rhythm_ft1, gensym("ft1"), A_FLOAT, 0);
	class_addmethod(rhythm_class, (t_method)rhythm_model, gensym("model"), A_FLOAT, 0);
	class_addmethod(rhythm_class, (t_method)rhythm_reset, gensym("reset"), 0);
	class_addmethod(rhythm_class, (t_method)rhythm_print, gensym("print"), 0);
    class_sethelpsymbol(rhythm_class, gensym("maxlib/rhythm-help.pd"));
}
Exemple #16
0
void t3_delay_setup(void)
{
  t3_delay_class = class_new(gensym("t3_delay"), (t_newmethod)t3_delay_new,
    (t_method)t3_delay_free, sizeof(t_t3_delay), 0, A_DEFFLOAT, 0);
  class_addcreator((t_newmethod)t3_delay_new, gensym("t3_del"), A_DEFFLOAT, 0);
  class_addmethod(t3_delay_class, (t_method)t3_delay_stop, gensym("stop"), 0);
  class_addmethod(t3_delay_class, (t_method)t3_delay_ft1,
    gensym("ft1"), A_FLOAT, 0);
  class_addfloat(t3_delay_class, (t_method)t3_delay_float);
  class_addlist(t3_delay_class, (t_method)t3_delay_list);
//  class_sethelpsymbol(t3_delay_class, gensym("iemhelp/help-t3_delay"));
}
Exemple #17
0
void pix_sig2pix :: obj_setupCallback(t_class *classPtr)
{
    class_addcreator(reinterpret_cast<t_newmethod>(create_pix_sig2pix), gensym("pix_sig2pix~"), A_DEFFLOAT, A_DEFFLOAT, A_NULL);

    class_addmethod(classPtr, nullfn, gensym("signal"), A_NULL);
    class_addmethod(classPtr, reinterpret_cast<t_method>(pix_sig2pix::dspMessCallback),
                    gensym("dsp"), A_NULL);
    class_addmethod(classPtr, reinterpret_cast<t_method>(pix_sig2pix::dimenMessCallback),
                    gensym("dimen"), A_DEFFLOAT,A_DEFFLOAT, A_NULL);
    class_addmethod(classPtr, reinterpret_cast<t_method>(pix_sig2pix::csMessCallback),
                    gensym("colorspace"), A_DEFSYMBOL, A_NULL);
}
Exemple #18
0
void maxlib_netdist_setup(void)
{
    netdist_class = class_new(gensym("maxlib/netdist"), (t_newmethod)netdist_new,
    	(t_method)netdist_free, sizeof(t_netdist), 0, A_DEFFLOAT, 0);
	class_addcreator((t_newmethod)netdist_new, gensym("netdist"), A_DEFFLOAT, 0);
    class_addmethod(netdist_class, (t_method)netdist_connect, gensym("connect"), A_SYMBOL, A_FLOAT, 0);
    class_addmethod(netdist_class, (t_method)netdist_disconnect, gensym("disconnect"), A_SYMBOL, A_FLOAT, 0);
    class_addmethod(netdist_class, (t_method)netdist_send, gensym("send"), A_GIMME, 0);
	class_addmethod(netdist_class, (t_method)netdist_clear, gensym("clear"), 0);
	class_addmethod(netdist_class, (t_method)netdist_print, gensym("print"), 0);
	class_sethelpsymbol(netdist_class, gensym("maxlib/netdist-help.pd"));
}
Exemple #19
0
void sl_setup(void)
{
    lsend_class = class_new(gensym("sendlocal"), (t_newmethod)lsend_new, 0,
    	sizeof(t_lsend), 0, A_DEFSYM, 0);
    class_addcreator((t_newmethod)lsend_new, gensym("sl"), A_DEFSYM, 0);
    class_addbang(lsend_class, lsend_bang);
    class_addfloat(lsend_class, lsend_float);
    class_addsymbol(lsend_class, lsend_symbol);
    class_addpointer(lsend_class, lsend_pointer);
    class_addlist(lsend_class, lsend_list);
    class_addanything(lsend_class, lsend_anything);
    post("Warning: sendlocal (sl) is deprecated, please use \"send $0-var\" instead");
}
Exemple #20
0
void symbol2list_setup(void)
{
  symbol2list_class = class_new(gensym("symbol2list"), (t_newmethod)symbol2list_new, 
			 (t_method)symbol2list_free, sizeof(t_symbol2list), 0, A_GIMME, 0);

  class_addcreator((t_newmethod)symbol2list_new, gensym("s2l"), A_GIMME, 0);
  class_addsymbol (symbol2list_class, symbol2list_symbol);
  class_addbang   (symbol2list_class, symbol2list_bang);
  class_addmethod  (symbol2list_class, (t_method)symbol2list_delimiter, gensym(""), A_SYMBOL, 0);
  class_addmethod(symbol2list_class, (t_method)symbol2list_help, gensym("help"), A_NULL);

  zexy_register("symbol2list");
}
Exemple #21
0
void list2int_setup(void)
{
  list2int_class = class_new(gensym("list2int"), (t_newmethod)list2int_new,
                             (t_method)mypdlist_free, sizeof(t_mypdlist), 0, A_GIMME, 0);
  class_addcreator((t_newmethod)list2int_new, gensym("l2i"), A_GIMME, 0);
  class_addanything(list2int_class, list2int_any);
  class_addlist(list2int_class, list2int_any);
  class_addbang(list2int_class, list2int_bang);
  class_addfloat(list2int_class, list2int_float);
  class_addsymbol(list2int_class, list2int_symbol);
  class_addpointer(list2int_class, list2int_pointer);
  zexy_register("list2int");
}
Exemple #22
0
void maxlib_nchange_setup(void)
{
    nchange_class = class_new(gensym("maxlib/nchange"), (t_newmethod)nchange_new, 0,
    	sizeof(t_nchange), 0, A_SYMBOL, 0);
	class_addcreator((t_newmethod)nchange_new, gensym("nchange"), A_SYMBOL, 0);
    class_addbang(nchange_class, nchange_bang);
    class_addfloat(nchange_class, nchange_float);
    class_addsymbol(nchange_class, nchange_symbol);
    class_addlist(nchange_class, nchange_list);
    class_addanything(nchange_class, nchange_list);
    class_addmethod(nchange_class, (t_method)nchange_set, gensym("set"), A_GIMME, 0);
    class_sethelpsymbol(nchange_class, gensym("maxlib/nchange-help.pd"));
}
Exemple #23
0
void rl_setup(void)
{
    lreceive_class = class_new(gensym("receivelocal"), (t_newmethod)lreceive_new, 
    	(t_method)lreceive_free, sizeof(t_lreceive), CLASS_NOINLET, A_SYMBOL, 0);
    class_addcreator((t_newmethod)lreceive_new, gensym("rl"), A_DEFSYM, 0);
    class_addbang(lreceive_class, lreceive_bang);
    class_addfloat(lreceive_class, (t_method)lreceive_float);
    class_addsymbol(lreceive_class, lreceive_symbol);
    class_addpointer(lreceive_class, lreceive_pointer);
    class_addlist(lreceive_class, lreceive_list);
    class_addanything(lreceive_class, lreceive_anything);
    post("Warning: receivelocal (rl) is deprecated, please use \"receive $0-var\" instead");
}
Exemple #24
0
/////////////////////////////////////////////////////////
// static member function
//
/////////////////////////////////////////////////////////
void pix_movieOS :: obj_setupCallback(t_class *classPtr)
{
  class_addcreator(reinterpret_cast<t_newmethod>(create_pix_movieOS),
                   gensym("pix_movie"), A_DEFSYM, A_NULL);
  class_addmethod(classPtr,
                  reinterpret_cast<t_method>(&pix_movieOS::openMessCallback),
                  gensym("open"), A_SYMBOL, A_NULL);
  class_addmethod(classPtr,
                  reinterpret_cast<t_method>(&pix_movieOS::changeImageCallback),
                  gensym("img_num"), A_GIMME, A_NULL);
  class_addmethod(classPtr,
                  reinterpret_cast<t_method>(&pix_movieOS::autoCallback),
                  gensym("auto"), A_DEFFLOAT, A_NULL);
}
Exemple #25
0
/////////////////////////////////////////////////////////
// static member function
//
/////////////////////////////////////////////////////////
void scopeXYZ :: obj_setupCallback(t_class *classPtr)
{
  class_addcreator(reinterpret_cast<t_newmethod>(create_scopeXYZ),
                   gensym("scopeXYZ~"), A_DEFFLOAT, A_NULL);

  CPPEXTERN_MSG0(classPtr, "bang", bangMess);
  CPPEXTERN_MSG1(classPtr, "linewidth", linewidthMess, float);
  CPPEXTERN_MSG1(classPtr, "length", lengthMess, int);

  class_addmethod(classPtr,
                  reinterpret_cast<t_method>(&scopeXYZ::dspCallback),
                  gensym("dsp"), A_NULL);
  class_addmethod(classPtr, nullfn, gensym("signal"), A_NULL);
}
Exemple #26
0
void lia_setup(void) 
{
  liaKD_class = class_new(gensym("lia"),
        (t_newmethod)liaKD_new,
        (t_method)liaKD_free,
		sizeof(t_liaKD),
        CLASS_DEFAULT, A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

  class_addcreator((t_newmethod)liaKD_new, gensym("link"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
  class_addcreator((t_newmethod)liaKD_new, gensym("pmpd.link"), A_DEFSYM, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);

  class_addfloat(liaKD_class, liaKD_float);
  class_addbang(liaKD_class, liaKD_bang);
  class_addmethod(liaKD_class, (t_method)liaKD_reset, gensym("reset"), 0);
  class_addmethod(liaKD_class, (t_method)liaKD_resetl, gensym("resetL"), 0);
  class_addmethod(liaKD_class, (t_method)liaKD_resetF, gensym("resetF"), 0);
  class_addmethod(liaKD_class, (t_method)liaKD_setD, gensym("setD"), A_DEFFLOAT, 0);
  class_addmethod(liaKD_class, (t_method)liaKD_setD2, gensym("setD2"), A_DEFFLOAT, 0);
  class_addmethod(liaKD_class, (t_method)liaKD_setK, gensym("setK"), A_DEFFLOAT, 0);
  class_addmethod(liaKD_class, (t_method)liaKD_setL, gensym("setL"), A_DEFFLOAT, 0);
  class_addmethod(liaKD_class, (t_method)liaKD_Lmin, gensym("setLmin"), A_DEFFLOAT, 0);
  class_addmethod(liaKD_class, (t_method)liaKD_Lmax, gensym("setLmax"), A_DEFFLOAT, 0);
}
Exemple #27
0
/////////////////////////////////////////////////////////
// static member function
//
/////////////////////////////////////////////////////////
void pix_colorreduce :: obj_setupCallback(t_class *classPtr)
{
  class_addcreator(reinterpret_cast<t_newmethod>(create_pix_colorreduce),
                   gensym("pix_colourreduce"), A_NULL);
  class_addmethod(classPtr,
                  reinterpret_cast<t_method>(&pix_colorreduce::countCallback),
                  gensym("count"), A_DEFFLOAT, A_NULL);
  class_addmethod(classPtr,
                  reinterpret_cast<t_method>(&pix_colorreduce::persistCallback),
                  gensym("persist"), A_DEFFLOAT, A_NULL);
  class_addmethod(classPtr,
                  reinterpret_cast<t_method>(&pix_colorreduce::smoothCallback),
                  gensym("smooth"), A_DEFFLOAT, A_NULL);
}
Exemple #28
0
void maxlib_score_setup(void)
{
    score_class = class_new(gensym("maxlib_score"), (t_newmethod)score_new,
    	(t_method)score_free, sizeof(t_score), 0, A_SYMBOL, A_DEFFLOAT, A_DEFFLOAT, 0);
	class_addcreator((t_newmethod)score_new, gensym("score"), A_SYMBOL, A_DEFFLOAT, A_DEFFLOAT, 0);
    class_addmethod(score_class, (t_method)score_reset, gensym("reset"), 0);
	class_addmethod(score_class, (t_method)score_resume, gensym("resume"), 0);
    class_addmethod(score_class, (t_method)score_start, gensym("start"), A_GIMME, 0);
    class_addmethod(score_class, (t_method)score_stop, gensym("stop"), 0);
    class_addmethod(score_class, (t_method)score_ft1, gensym("ft1"), A_FLOAT, 0);
    class_addmethod(score_class, (t_method)score_reset, gensym("reset"), A_GIMME, 0);
	class_addmethod(score_class, (t_method)score_set, gensym("set"), A_SYMBOL, 0);
    class_addfloat(score_class, score_float);
    class_sethelpsymbol(score_class, gensym("maxlib/score-help.pd"));
}
Exemple #29
0
void demultiplex_tilde_setup(void)
{
  demux_class = class_new(gensym("demultiplex~"), (t_newmethod)demux_new,
                          (t_method)demux_free, sizeof(t_demux), 0, A_GIMME, 0);
  class_addcreator((t_newmethod)demux_new, gensym("demux~"), A_GIMME, 0);

  class_addfloat(demux_class, demux_output);
  class_addmethod(demux_class, (t_method)demux_dsp, gensym("dsp"),
                  A_CANT, 0);
  class_addmethod(demux_class, nullfn, gensym("signal"), 0);

  class_addmethod(demux_class, (t_method)demux_helper, gensym("help"), 0);

  zexy_register("demultiplex~");
}
Exemple #30
0
static void voutlet_setup(void)
{
    voutlet_class = class_new(gensym("outlet"), (t_newmethod)voutlet_new,
        (t_method)voutlet_free, sizeof(t_voutlet), CLASS_NOINLET, A_DEFSYM, 0);
    class_addcreator((t_newmethod)voutlet_newsig, gensym("outlet~"), A_DEFSYM, 0);
    class_addbang(voutlet_class, voutlet_bang);
    class_addpointer(voutlet_class, voutlet_pointer);
    class_addfloat(voutlet_class, (t_method)voutlet_float);
    class_addsymbol(voutlet_class, voutlet_symbol);
    class_addlist(voutlet_class, voutlet_list);
    class_addanything(voutlet_class, voutlet_anything);
    class_addmethod(voutlet_class, (t_method)voutlet_dsp,
        gensym("dsp"), A_CANT, 0);
    class_sethelpsymbol(voutlet_class, gensym("pd"));
}