Example #1
0
int main(void)
{	
	t_class *c;
	
	c = class_new("hoa.delay~", (method)HoaDelay_new, (method)dsp_free, (long)sizeof(t_HoaDelay), 0L, A_GIMME, 0);
	
	class_addmethod(c, (method)HoaDelay_float,		"float",	A_FLOAT, 0);
	class_addmethod(c, (method)HoaDelay_int,		"int",		A_LONG, 0);
	class_addmethod(c, (method)HoaDelay_dsp64,		"dsp64",	A_CANT, 0);
	class_addmethod(c, (method)HoaDelay_assist,		"assist",	A_CANT, 0);
    
    CLASS_ATTR_DOUBLE			(c, "ramp", 0, t_HoaDelay, f_ramp_time);
	CLASS_ATTR_CATEGORY			(c, "ramp", 0, "Behavior");
	CLASS_ATTR_LABEL			(c, "ramp", 0, "Ramp time (ms)");
	CLASS_ATTR_ORDER			(c, "ramp", 0, "1");
	CLASS_ATTR_ACCESSORS		(c, "ramp", NULL, ramp_set);
	CLASS_ATTR_SAVE				(c, "ramp", 1);
    
    CLASS_ATTR_LONG             (c, "compensation", 0, t_HoaDelay, f_encoding_compensation);
	CLASS_ATTR_CATEGORY			(c, "compensation", 0, "Behavior");
    CLASS_ATTR_STYLE_LABEL      (c, "compensation", 0, "onoff", "Encoding compensation")
	CLASS_ATTR_ORDER			(c, "compensation", 0, "2");
	CLASS_ATTR_ACCESSORS		(c, "compensation", NULL, comp_set);
	CLASS_ATTR_SAVE				(c, "compensation", 1);
    
    CLASS_ATTR_DOUBLE			(c, "delay", 0, t_HoaDelay, f_delay);
	CLASS_ATTR_CATEGORY			(c, "delay", 0, "Parameters");
	CLASS_ATTR_LABEL			(c, "delay", 0, "Delay time (ms)");
	CLASS_ATTR_ORDER			(c, "delay", 0, "1");
	CLASS_ATTR_ACCESSORS		(c, "delay", NULL, delay_set);
	CLASS_ATTR_SAVE				(c, "delay", 1);
    
    CLASS_ATTR_DOUBLE			(c, "diffusion", 0, t_HoaDelay, f_diffuse_factor);
	CLASS_ATTR_CATEGORY			(c, "diffusion", 0, "Parameters");
	CLASS_ATTR_LABEL			(c, "diffusion", 0, "Diffusion factor");
	CLASS_ATTR_ORDER			(c, "diffusion", 0, "2");
	CLASS_ATTR_ACCESSORS		(c, "diffusion", NULL, diff_set);
	CLASS_ATTR_SAVE				(c, "diffusion", 1);
	
	class_dspinit(c);				
	class_register(CLASS_BOX, c);	
	HoaDelay_class = c;
	
	class_findbyname(CLASS_NOBOX, gensym("hoa.encoder~"));
	return 0;
}
Example #2
0
int main(void) 
{    
	t_class *c;
	
	c = class_new("simplethread", (method)simplethread_new, (method)simplethread_free, sizeof(t_simplethread), 0L, 0); 
	
	class_addmethod(c, (method)simplethread_bang,		"bang",			0);
	class_addmethod(c, (method)simplethread_foo,		"foo",			A_DEFLONG, 0);
	class_addmethod(c, (method)simplethread_sleeptime,	"sleeptime",	A_DEFLONG, 0);
    class_addmethod(c, (method)simplethread_cancel,		"cancel",		0);
    class_addmethod(c, (method)simplethread_assist,		"assist",		A_CANT, 0);
    
	class_register(CLASS_BOX,c);
	simplethread_class = c;
	
	return 0;
}
Example #3
0
int setup_o0x2etimetag(void)
{
	t_class *c = class_new(gensym("o.timetag"), (t_newmethod)otimetag_new, (t_method)otimetag_free, sizeof(t_otimetag), 0L, A_GIMME, 0);
    
	class_addmethod(c, (t_method)otimetag_fullPacket, gensym("FullPacket"), A_GIMME, 0);
	class_addmethod(c, (t_method)otimetag_anything, gensym("anything"), A_GIMME, 0);
	class_addmethod(c, (t_method)otimetag_bang, gensym("bang"), 0);
	//class_addmethod(c, (t_method)otimetag_set, gensym("set"), A_GIMME, 0);
	class_addmethod(c, (t_method)odot_version, gensym("version"), 0);
    class_addmethod(c, (t_method)otimetag_doc, gensym("doc"), 0);

	otimetag_class = c;
    
	ps_FullPacket = gensym("FullPacket");
	ODOT_PRINT_VERSION;
	return 0;
}
int C74_EXPORT main(void)
#endif
{
    t_class *c;
    
    c = class_new("hoa.play~", (method)play_new, (method)NULL, (short)sizeof(0), 0L, A_GIMME, 0);
    class_setname((char *)"hoa.play~", (char *)"hoa.play~");
    class_setname((char *)"hoa.2d.play~", (char *)"hoa.play~");
    class_setname((char *)"hoa.3d.play~", (char *)"hoa.play~");
    
    hoa_initclass(c, NULL);
    class_register(CLASS_BOX, c);
    class_alias(c, gensym("hoa.2d.play~"));
    class_alias(c, gensym("hoa.3d.play~"));
    play_class = c;
    return 0;
}
Example #5
0
void C74_EXPORT ext_main(void *r)
{
	t_class *c;
	
	c = class_new("posit", (method)posit_new, (method)posit_free, (long)sizeof(t_posit), 0L, A_GIMME, 0);
	
	class_addmethod(c, (method)posit_bang,			"bang",			0);
    class_addmethod(c, (method)posit_assist,		"assist",		A_CANT, 0);  

	class_addmethod(c, (method)posit_assist,		"assist",A_CANT,0);

	class_addmethod(c, (method)posit_getname,		"getname",0);
	class_addmethod(c, (method)posit_setname, 		"setname",A_GIMME,0);

	class_addmethod(c, (method)posit_getinfo,		"getinfo",0);

	class_addmethod(c, (method)posit_names,			"names",0);
	class_addmethod(c, (method)posit_namesglobal,	"names.global",0);

	class_addmethod(c, (method)posit_boxes,			"objects",0);
	class_addmethod(c, (method)posit_boxesglobal,	"objects.global",0);

	class_addmethod(c, (method)posit_query, 		"query",A_GIMME,0);
	class_addmethod(c, (method)posit_queryglobal, 	"query.global",A_GIMME,0);

	class_addmethod(c, (method)posit_rename, 		"rename",A_GIMME,0);
	class_addmethod(c, (method)posit_renameglobal,	"rename.global",A_GIMME,0);

	class_addmethod(c, (method)posit_classquery,	"class",A_GIMME,0);
	class_addmethod(c, (method)posit_classglobal,	"class.global",A_GIMME,0);

	class_addmethod(c, (method)posit_buffers,		"buffers",0);
	class_addmethod(c, (method)posit_colls,			"colls",0);

	class_register(CLASS_BOX, c);
	posit_class = c;	
	
	post("·    posit    ·    jasch    ·    "__DATE__"    ·    © all rights reserved",0);
	
	ps_nothing = gensym("");
	ps_coll = gensym("coll");
	ps_buff = gensym("buffer~");
	ps_none = gensym("<none>");

	return;
}
Example #6
0
void cd4516_setup(void)
{
    cd4516_class = class_new(gensym("cd4516"),
                    (t_newmethod)cd4516_new,
                    (t_method)cd4516_free,
                    sizeof(t_cd4516), 0, 0); /* no arguments */
    class_addbang(cd4516_class, cd4516_bang);
    class_addfloat(cd4516_class, cd4516_float);
    class_addmethod(cd4516_class, (t_method)cd4516_up_down, gensym("updown"), A_FLOAT, 0);
    class_addmethod(cd4516_class, (t_method)cd4516_preset_enable, gensym("presetenable"), A_FLOAT, 0);
    class_addmethod(cd4516_class, (t_method)cd4516_reset, gensym("reset"), A_FLOAT, 0);
    class_addmethod(cd4516_class, (t_method)cd4516_carry, gensym("carry"), A_FLOAT, 0);
    class_addmethod(cd4516_class, (t_method)cd4516_P1, gensym("P1"), A_FLOAT, 0);
    class_addmethod(cd4516_class, (t_method)cd4516_P2, gensym("P2"), A_FLOAT, 0);
    class_addmethod(cd4516_class, (t_method)cd4516_P3, gensym("P3"), A_FLOAT, 0);
    class_addmethod(cd4516_class, (t_method)cd4516_P4, gensym("P4"), A_FLOAT, 0);
}
Example #7
0
int C74_EXPORT main(void)
{	

	t_class *c;
	
	c = class_new("hoa.scope3D~", (method)hoa_scope_new, (method)hoa_scope_free, (long)sizeof(t_hoa_scope), 0L, A_GIMME, 0);
	
	class_addmethod(c, (method)hoa_scope_dsp64,		"dsp64",	A_CANT, 0);
	class_addmethod(c, (method)hoa_scope_assist,    "assist",	A_CANT, 0);
	
	class_dspinit(c);
	class_register(CLASS_BOX, c);	
	hoa_scope_class = c;
    hoa_credit();
    
	return 0;
}
Example #8
0
int C74_EXPORT main(void)
{	
	t_class *c;
	
	c = class_new("hoa.restitution~", (method)HoaStereo_new, (method)HoaStereo_free, (long)sizeof(t_HoaStereo), 0L, A_GIMME, 0);
	
	class_addmethod(c, (method)HoaStereo_dsp,		"dsp",		A_CANT, 0);
	class_addmethod(c, (method)HoaStereo_dsp64,		"dsp64",	A_CANT, 0);
	class_addmethod(c, (method)HoaStereo_assist,	"assist",	A_CANT, 0);
	
	class_dspinit(c);				
	class_register(CLASS_BOX, c);	
	HoaStereo_class = c;
	
	class_findbyname(CLASS_BOX, gensym("hoa.encoder~"));
	return 0;
}
Example #9
0
int main(void)
{
    t_class *c;

	c = class_new("dspstress~", (method)dspstress_new, (method)dsp_free, (short)sizeof(t_dspstress), 0L, A_DEFFLOAT, 0);
    
    class_addmethod(c, (method)dspstress_dsp64, "dsp64", A_CANT, 0); 	// respond to the dsp message 
																		// (sent to MSP objects when audio is turned on/off)
    class_addmethod(c, (method)dspstress_float, "float", A_FLOAT, 0);
    class_addmethod(c, (method)dspstress_int, "int", A_LONG, 0);
    class_addmethod(c, (method)dspstress_assist,"assist",A_CANT,0);
    class_dspinit(c);													// must call this function for MSP object classes

	class_register(CLASS_BOX, c);
	dspstress_class = c;
	return 0;
}
Example #10
0
File: ear~.c Project: Angeldude/pd
void ear_tilde_setup(void)
{
    //post("ear~ v0.1");
    ear_class = class_new(gensym("ear~"), (t_newmethod)ear_new,
    	(t_method)ear_free, sizeof(t_ear), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
    class_addmethod(ear_class, (t_method)ear_float, gensym("float"), A_FLOAT, 0);
    class_addmethod(ear_class, (t_method)ear_start, gensym("start"), 0);
    class_addmethod(ear_class, (t_method)ear_start, gensym("bang"), 0);
    class_addmethod(ear_class, (t_method)ear_stop, gensym("stop"), 0);
    class_addmethod(ear_class, (t_method)ear_dsp, gensym("dsp"), 0); 
    class_addmethod(ear_class, 
		    (t_method)ear_attack, gensym("attack"), A_FLOAT, 0);
    class_addmethod(ear_class, 
		    (t_method)ear_release, gensym("release"), A_FLOAT, 0);


}
int C74_EXPORT main(void) {
	// Initialize the class - first argument: VERY important to match the name of the object in the procect settings!!!
	cmgrainlabs_class = class_new("cm.grainlabs~", (method)cmgrainlabs_new, (method)cmgrainlabs_free, sizeof(t_cmgrainlabs), 0, A_GIMME, 0);
	
	class_addmethod(cmgrainlabs_class, (method)cmgrainlabs_dsp64, 		"dsp64", 	A_CANT, 0);  // Bind the 64 bit dsp method
	class_addmethod(cmgrainlabs_class, (method)cmgrainlabs_assist, 		"assist", 	A_CANT, 0); // Bind the assist message
	class_addmethod(cmgrainlabs_class, (method)cmgrainlabs_float, 		"float", 	A_FLOAT, 0); // Bind the float message (allowing float input)
	class_addmethod(cmgrainlabs_class, (method)cmgrainlabs_dblclick, 	"dblclick",	A_CANT, 0); // Bind the double click message
	class_addmethod(cmgrainlabs_class, (method)cmgrainlabs_notify, 		"notify", 	A_CANT, 0); // Bind the notify message
	class_addmethod(cmgrainlabs_class, (method)cmgrainlabs_set, 		"set", 		A_GIMME, 0); // Bind the set message for user buffer set
	class_addmethod(cmgrainlabs_class, (method)cmgrainlabs_limit, 		"limit", 	A_GIMME, 0); // Bind the limit message
	
	CLASS_ATTR_ATOM_LONG(cmgrainlabs_class, "stereo", 0, t_cmgrainlabs, attr_stereo);
	CLASS_ATTR_ACCESSORS(cmgrainlabs_class, "stereo", (method)NULL, (method)cmgrainlabs_stereo_set);
	CLASS_ATTR_BASIC(cmgrainlabs_class, "stereo", 0);
	CLASS_ATTR_SAVE(cmgrainlabs_class, "stereo", 0);
	CLASS_ATTR_STYLE_LABEL(cmgrainlabs_class, "stereo", 0, "onoff", "Multichannel playback");
	
	CLASS_ATTR_ATOM_LONG(cmgrainlabs_class, "w_interp", 0, t_cmgrainlabs, attr_winterp);
	CLASS_ATTR_ACCESSORS(cmgrainlabs_class, "w_interp", (method)NULL, (method)cmgrainlabs_winterp_set);
	CLASS_ATTR_BASIC(cmgrainlabs_class, "w_interp", 0);
	CLASS_ATTR_SAVE(cmgrainlabs_class, "w_interp", 0);
	CLASS_ATTR_STYLE_LABEL(cmgrainlabs_class, "w_interp", 0, "onoff", "Window interpolation on/off");
	
	CLASS_ATTR_ATOM_LONG(cmgrainlabs_class, "s_interp", 0, t_cmgrainlabs, attr_sinterp);
	CLASS_ATTR_ACCESSORS(cmgrainlabs_class, "s_interp", (method)NULL, (method)cmgrainlabs_sinterp_set);
	CLASS_ATTR_BASIC(cmgrainlabs_class, "s_interp", 0);
	CLASS_ATTR_SAVE(cmgrainlabs_class, "s_interp", 0);
	CLASS_ATTR_STYLE_LABEL(cmgrainlabs_class, "s_interp", 0, "onoff", "Sample interpolation on/off");
	
	CLASS_ATTR_ATOM_LONG(cmgrainlabs_class, "zero", 0, t_cmgrainlabs, attr_zero);
	CLASS_ATTR_ACCESSORS(cmgrainlabs_class, "zero", (method)NULL, (method)cmgrainlabs_zero_set);
	CLASS_ATTR_BASIC(cmgrainlabs_class, "zero", 0);
	CLASS_ATTR_SAVE(cmgrainlabs_class, "zero", 0);
	CLASS_ATTR_STYLE_LABEL(cmgrainlabs_class, "zero", 0, "onoff", "Zero crossing trigger mode on/off");
	
	CLASS_ATTR_ORDER(cmgrainlabs_class, "stereo", 0, "1");
	CLASS_ATTR_ORDER(cmgrainlabs_class, "w_interp", 0, "2");
	CLASS_ATTR_ORDER(cmgrainlabs_class, "s_interp", 0, "3");
	
	class_dspinit(cmgrainlabs_class); // Add standard Max/MSP methods to your class
	class_register(CLASS_BOX, cmgrainlabs_class); // Register the class with Max
	ps_buffer_modified = gensym("buffer_modified"); // assign the buffer modified message to the static pointer created above
	ps_stereo = gensym("stereo");
	return 0;
}
Example #12
0
int main(void){
    version_post_copyright();
    tta_class = class_new("2threshattack~", (method)tta_new, (method)dsp_free,
          (short)sizeof(t_tta), 0L, A_DEFFLOAT, A_DEFFLOAT, 0);
    class_addmethod(tta_class, (method)version, "version", 0);
    class_addmethod(tta_class, (method)tta_dsp, "dsp", A_CANT, 0);
    class_addmethod(tta_class, (method)tta_dsp64, "dsp64", A_CANT, 0);
    class_addmethod(tta_class, (method)tta_set_low, "low", A_FLOAT, 0);
    class_addmethod(tta_class, (method)tta_set_high, "high", A_FLOAT, 0);
    class_addmethod(tta_class, (method)tta_tellmeeverything, "tellmeeverything", 0);
    
    //class_dspinit(tta_class);
    class_dspinit(tta_class);

	class_register(CLASS_BOX, tta_class);
	return 0;
}
Example #13
0
void pdp_rawin_setup(void)
{
    int i;

    /* create a standard pd class: [pdp_rawin pipe type] */
    rawin_class = class_new(gensym("pdp_rawin"), (t_newmethod)rawin_new,
   	(t_method)rawin_free, sizeof(t_rawin), 0, A_DEFSYMBOL, A_DEFSYMBOL, A_NULL);

    /* add global message handlers */
    class_addmethod(rawin_class, (t_method)rawin_type, gensym("type"), A_SYMBOL, A_NULL);
    class_addmethod(rawin_class, (t_method)rawin_open, gensym("open"), A_DEFSYMBOL, A_NULL);
    class_addmethod(rawin_class, (t_method)rawin_close, gensym("close"), A_NULL);
    class_addmethod(rawin_class, (t_method)rawin_sync, gensym("sync"), A_FLOAT, A_NULL);
    class_addmethod(rawin_class, (t_method)rawin_bang, gensym("bang"), A_NULL);


}
Example #14
0
int main(void)
{	
	t_class* c = class_new("split~", (method)split_new, (method)dsp_free, sizeof(t_split), NULL, A_GIMME, 0);
	
	common_symbols_init();
	class_addmethod(c, (method)split_int,		"int",		A_LONG, 0);
	class_addmethod(c, (method)split_float,		"float",	A_FLOAT, 0);
	class_addmethod(c, (method)split_dsp,		"dsp",		A_CANT, 0);		// Old 32-bit MSP dsp chain compilation for Max 5 and earlier
	class_addmethod(c, (method)split_dsp64,		"dsp64",	A_CANT, 0);		// New 64-bit MSP dsp chain compilation for Max 6
	class_addmethod(c, (method)split_assist,	"assist",	A_CANT, 0);
	
	class_dspinit(c);
	class_register(_sym_box, c);
	s_split_class = c;

	return 0;
}
Example #15
0
void mtx_cumsum_setup (void)
{
   mtx_cumsum_class = class_new 
      (gensym("mtx_cumsum"),
       (t_newmethod) newMTXCumsum,
       (t_method) deleteMTXCumsum,
       sizeof (MTXCumsum),
       CLASS_DEFAULT, A_GIMME, 0);
   class_addbang (mtx_cumsum_class, (t_method) mTXCumsumBang);
   class_addmethod (mtx_cumsum_class, (t_method) mTXCumsumMatrix, gensym("matrix"), A_GIMME,0);
   class_addmethod (mtx_cumsum_class, (t_method) mTXSetCumsumMode, gensym("mode"), A_DEFSYMBOL,0);
   class_addmethod (mtx_cumsum_class, (t_method) mTXSetCumsumDirection, gensym("direction"), A_DEFFLOAT,0);

   row_sym = gensym("row");
   col_sym = gensym("col");
   col_sym2 = gensym("column");
}
Example #16
0
int C74_EXPORT main(void) {
    t_class *c= class_new("f0.ultimate_counter", (method)f0ext_new, (method)NULL, (long)sizeof(t_f0ext), 0L, A_GIMME, 0);
    class_addmethod(c, (method)f0ext_assist, "assist", A_CANT, 0);
    class_addmethod(c, (method)f0ext_bang, "bang", 0);
    class_addmethod(c, (method)f0ext_int, "int", A_LONG, 0);
    class_addmethod(c, (method)f0ext_float, "float", A_FLOAT, 0);
    class_addmethod(c, (method)f0ext_step, "ft1", A_FLOAT, 0);
    class_addmethod(c, (method)f0ext_loop, "in2", A_LONG, 0);
    class_addmethod(c, (method)f0ext_reset_next, "ft3", A_FLOAT, 0);
    class_addmethod(c, (method)f0ext_reset_now, "ft4", A_FLOAT, 0);
    class_addmethod(c, (method)f0ext_min, "ft5", A_FLOAT, 0);
    class_addmethod(c, (method)f0ext_max, "ft6", A_FLOAT, 0);
    class_register(CLASS_BOX, c);
    f0ext_class= c;
    post("f0.ultimate_counter v2.01-64/32bit; distributed under GNU GPL license");
    return 0;
}
Example #17
0
int main(void){
	t_class *c = class_new("thread.which", (method)threadwhich_new, (method)threadwhich_free, sizeof(t_threadwhich), 0L, A_GIMME, 0);
	class_addmethod(c, (method)threadwhich_assist, "assist", A_CANT, 0);
	class_addmethod(c, (method)threadwhich_bang, "bang", 0);
	class_addmethod(c, (method)threadwhich_long, "int", 0);
	class_addmethod(c, (method)threadwhich_float, "float", 0);
	class_addmethod(c, (method)threadwhich_list, "list", A_GIMME, 0);
	class_addmethod(c, (method)threadwhich_anything, "anything", A_GIMME, 0);

	class_register(CLASS_BOX, c);
	threadwhich_class = c;

	common_symbols_init();

	version_post_copyright();
	return 0;
}
Example #18
0
int C74_EXPORT main(void)
{	
	t_class *c;
	
	c = class_new("hoa.decoder3D~", (method)hoa_decoder_new, (method)hoa_decoder_free, (long)sizeof(t_hoa_decoder), 0L, A_GIMME, 0);
	
	hoa_initclass(c, (method)hoa_getinfos);
	
	class_addmethod(c, (method)hoa_decoder_dsp64,             "dsp64",      A_CANT, 0);
	class_addmethod(c, (method)hoa_decoder_assist,            "assist",     A_CANT, 0);
    class_addmethod(c, (method)hoa_decoder_setLoudspeakers,   "lscoord",    A_GIMME, 0);
    
	class_dspinit(c);				
	class_register(CLASS_BOX, c);	
	hoa_decoder_class = c;
	return 0;
}
Example #19
0
File: pan~.c Project: Angeldude/pd
/**
 * define the function-space of the class
 * within a single-object external the name of this function is very special
 */
void pan_tilde_setup(void) {
  pan_tilde_class = class_new(gensym("pan~"),
        (t_newmethod)pan_tilde_new,
        0, sizeof(t_pan_tilde),
        CLASS_DEFAULT, 
        A_DEFFLOAT, 0);

  /* whenever the audio-engine is turned on, the "pan_tilde_dsp()" 
   * function will get called
   */
  class_addmethod(pan_tilde_class,
        (t_method)pan_tilde_dsp, gensym("dsp"), 0);
  /* if no signal is connected to the first inlet, we can as well 
   * connect a number box to it and use it as "signal"
   */
  CLASS_MAINSIGNALIN(pan_tilde_class, t_pan_tilde, f);
}
Example #20
0
void leaker_tilde_setup(void)
{
  leaker_class = class_new(gensym("leaker~"), (t_newmethod)leaker_new, 
    (t_method)leaker_free ,sizeof(t_leaker), 0,A_GIMME,0);
  CLASS_MAINSIGNALIN(leaker_class, t_leaker, x_f);
  class_addmethod(leaker_class, (t_method)leaker_dsp, gensym("dsp"), 0);
  class_addmethod(leaker_class, (t_method)leaker_mute, gensym("mute"), A_DEFFLOAT,0);
  class_addmethod(leaker_class, (t_method)leaker_bypass, gensym("bypass"), A_DEFFLOAT,0);
  class_addmethod(leaker_class, (t_method)leaker_mute, gensym("mute"), A_DEFFLOAT,0);
  class_addmethod(leaker_class, (t_method)leaker_overlap, gensym("overlap"), A_DEFFLOAT,0);
  class_addmethod(leaker_class, (t_method)leaker_winfac, gensym("winfac"), A_DEFFLOAT,0);
  class_addmethod(leaker_class, (t_method)leaker_fftinfo, gensym("fftinfo"),0);
  class_addmethod(leaker_class, (t_method)leaker_upsieve, gensym("upsieve"), 0);
  class_addmethod(leaker_class, (t_method)leaker_downsieve, gensym("downsieve"),0);
  class_addmethod(leaker_class, (t_method)leaker_randsieve, gensym("randsieve"),0);
  post("%s %s",OBJECT_NAME,FFTEASE_ANNOUNCEMENT);
}
int C74_EXPORT main(void)
{
    // object initialization, note the use of dsp_free for the freemethod, which is required
    // unless you need to free allocated memory, in which case you should call dsp_free from
    // your custom free function.

    t_class *c = class_new("aubioOnset~", (method)aubioOnset_new, (method)dsp_free, (long)sizeof(t_aubioOnset), 0L, A_GIMME, 0);

    class_dspinit(c);
    class_register(CLASS_BOX, c);
    aubioOnset_class = c;

    class_addmethod(c, (method)aubioOnset_dsp,		"dsp",		A_CANT, 0);		// Old 32-bit MSP dsp chain compilation for Max 5 and earlier
    class_addmethod(c, (method)aubioOnset_dsp64,		"dsp64",	A_CANT, 0);		// New 64-bit MSP dsp chain compilation for Max 6
    //class_addmethod(c, (method)aubioOnset_assist,	"assist",	A_CANT, 0);

    class_addmethod(aubioOnset_class,
                    (method)aubioOnset_threshold,
                    "threshold",
                    A_DEFFLOAT,
                    0
                   );

    class_addmethod(aubioOnset_class,
                    (method)aubioOnset_silence,
                    "silence",
                    A_DEFLONG,
                    0
                   );

    class_addmethod(aubioOnset_class,
                    (method)aubioOnset_minioi,
                    "minioi",
                    A_DEFLONG,
                    0
                   );

    class_addmethod(aubioOnset_class,
                    (method)aubioOnset_debug,
                    "debug",
                    0
                   );

    return 0;
}
Example #22
0
int setup_o0x2eprintbytes(void){
	t_class *c = class_new(gensym("o.printbytes"), (t_newmethod)opbytes_new, (t_method)opbytes_free, sizeof(t_opbytes), 0L, A_GIMME, 0);
    
	//class_addmethod(c, (method)opbytes_fullPacket, "FullPacket", A_LONG, A_LONG, 0);
	class_addmethod(c, (t_method)opbytes_fullPacket, gensym("FullPacket"), A_GIMME, 0);
	
    
	class_addmethod(c, (t_method)opbytes_doc, gensym("doc"), 0);
//	class_addmethod(c, (t_method)opbytes_assist, gensym("assist"), A_CANT, 0);
    
	class_addmethod(c, (t_method)odot_version, gensym("version"), 0);
    
	opbytes_class = c;
    
//	common_symbols_init();
	ODOT_PRINT_VERSION;
	return 0;
}
Example #23
0
int main(void){
	t_class *c = class_new("template", (method)temp_new, (method)temp_free, sizeof(t_temp), 0L, 0);

	class_addmethod(c, (method)temp_bang, "bang", 0);
	class_addmethod(c, (method)temp_int, "int", A_LONG, 0);
	class_addmethod(c, (method)temp_float, "float", A_FLOAT, 0);
	class_addmethod(c, (method)temp_list, "list", A_GIMME, 0);
	class_addmethod(c, (method)temp_anything, "anything", A_GIMME, 0);
	class_addmethod(c, (method)temp_assist, "assist", A_CANT, 0);
	class_addmethod(c, (method)stdinletinfo, "inletinfo", A_CANT, 0);

	class_register(CLASS_BOX, c);
	temp_class = c;

	common_symbols_init();

	return 0;
}
Example #24
0
int main(void)
{	
	t_class *c = class_new("granusoids~", (method)grans_new, (method)grans_free, (long)sizeof(t_grans), NULL,   0);
	
    class_addmethod(c, (method)grans_clear,		"clear",     0);
    class_addmethod(c, (method)grans_printstack,"printstack",     0);
    class_addmethod(c, (method)grans_testStack, "teststack",     0);
    
	class_addmethod(c, (method)grans_dsp64,		"dsp64",	A_CANT, 0);
	
    class_addmethod(c, (method)grans_assist,	"assist",	A_CANT, 0);
	
	class_dspinit(c);
	class_register(CLASS_BOX, c);
	grans_class = c;

	return 0;
}
Example #25
0
void zunpack_setup(void)
{

  zunpack_class = class_new(gensym("zexy/unpack"),
                            (t_newmethod)zunpack_new, (t_method)zunpack_free, sizeof(t_zunpack),
                            0,  A_GIMME, 0);
#if 0
  /* oops Pd-0.42 allows us to override built-ins
   * this is bad as long as the 2 objects are not compatible */
  class_addcreator((t_newmethod)zunpack_new, gensym("unpack"), A_GIMME, 0);
#endif

  class_addbang(zunpack_class, zunpack_bang);
  class_addlist(zunpack_class, zunpack_list);
  class_addanything(zunpack_class, zunpack_any);

  zexy_register("unpack");
}
Example #26
0
void autoabstraction_setup(void)
{
  /* relies on t.grill's loader functionality, fully added in 0.40 */
  post("automatic abstraction creator %s",version);  
  post("\twritten by IOhannes m zmoelnig, IEM <*****@*****.**>");
  post("\tcompiled on "__DATE__" at "__TIME__ " ");
  post("\tcompiled against Pd version %d.%d.%d.%s", PD_MAJOR_VERSION, PD_MINOR_VERSION, PD_BUGFIX_VERSION, PD_TEST_VERSION);
#ifdef AUTOABSTRACTION_ENABLED
  autoabstraction_initialize();
  sys_register_loader(autoabstraction_loader);
#else
  error("to function, this needs to be compiled against Pd 0.40 or higher,\n");
  error("\tor a version that has sys_register_loader()");
#endif

  autoabstraction_class = class_new(gensym("autoabstraction"), (t_newmethod)autoabstraction_new, 0, sizeof(t_autoabstraction), 0, A_GIMME, 0);
  class_addfloat(autoabstraction_class, (t_method)autoabstraction_state);
}
Example #27
0
File: hist.c Project: Angeldude/pd
void hist_setup(void)
{
    hist_class = class_new(gensym("hist"),
    	(t_newmethod)hist_new, (t_method)hist_free,
		sizeof(t_hist), 
		CLASS_DEFAULT,
	    A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT,0);

	class_addmethod(hist_class, (t_method)hist_clear, gensym("clear"),0);
	class_addmethod(hist_class, (t_method)hist_bang, gensym("absolute"),0);
	class_addmethod(hist_class, (t_method)hist_relative, gensym("relative"),0);

	class_addmethod(hist_class, (t_method)hist_set, gensym("set"),A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT,0);

    class_addlist(hist_class, (t_method)hist_perform_list);
    class_addfloat(hist_class, (t_method)hist_perform_float);
    class_addbang(hist_class, (t_method)hist_bang);
}
Example #28
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);
    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);
}
Example #29
0
int implicitmap_setup(void)
{
    t_class *c;
    c = class_new(gensym("implicitmap"), (t_newmethod)impmap_new, (t_method)impmap_free,
                  (long)sizeof(impmap), 0L, A_GIMME, 0);
    class_addmethod(c, (t_method)impmap_snapshot,         gensym("snapshot"),  A_GIMME, 0);
    class_addmethod(c, (t_method)impmap_randomize,        gensym("randomize"), A_GIMME, 0);
    class_addmethod(c, (t_method)impmap_list,             gensym("list"),      A_GIMME, 0);
    class_addmethod(c, (t_method)impmap_print_properties, gensym("print"),     A_GIMME, 0);
    class_addmethod(c, (t_method)impmap_clear_snapshots,  gensym("clear"),     A_GIMME, 0);
    class_addmethod(c, (t_method)impmap_mute_output,      gensym("mute"),      A_GIMME, 0);
    class_addmethod(c, (t_method)impmap_process,          gensym("process"),   A_GIMME, 0);
    class_addmethod(c, (t_method)impmap_save,             gensym("export"),      A_GIMME, 0);
    class_addmethod(c, (t_method)impmap_load,             gensym("import"),      A_GIMME, 0);
    mapper_class = c;
    ps_list = gensym("list");
    return 0;
}
Example #30
0
void ext_main(void *r)
{
	t_class *c;

	c = class_new("minimum", (method)minimum_new, (method)minimum_free, sizeof(t_minimum), 0L, A_GIMME, 0);
	class_addmethod(c, (method)minimum_bang, "bang", 0);
	class_addmethod(c, (method)minimum_int, "int", A_LONG, 0);
	class_addmethod(c, (method)minimum_in1, "in1", A_LONG, 0);
	class_addmethod(c, (method)minimum_float, "float", A_FLOAT, 0);
	class_addmethod(c, (method)minimum_ft1, "ft1", A_FLOAT, 0);
	class_addmethod(c, (method)minimum_list,"list",A_GIMME,0);
	class_addmethod(c, (method)minimum_assist,"assist",A_CANT,0);
	class_addmethod(c, (method)minimum_inletinfo, "inletinfo", A_CANT, 0);
	class_register(CLASS_BOX, c);
	minimum_class = c;

	return 0;
}