C++ class_new函数代码示例

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;
}

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;
}

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;
}

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);
}

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;
}

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;
}

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;
}

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;
}

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);


}

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;
}

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");
}

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;
}

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;
}