int main(void)
{	
	void *p,*q;
	
	union { void **v_ptr; t_messlist **m_ptr; } alias_ptr;
	alias_ptr.v_ptr = &max_cv_jit_blobs_recon_class;
	cv_jit_blobs_recon_init();
	setup(
			alias_ptr.m_ptr,	//A pointer to the Max class pointer
			(method)max_cv_jit_blobs_recon_new,			//The constructor function
			(method)max_cv_jit_blobs_recon_free,			//The destructor function
			(short)sizeof(t_max_cv_jit_blobs_recon),		//The size of the Max class
			0L,											//Use only for GUI objects, null for standard Jitter objects
			A_GIMME,									//Pass arguments as a list of t_atoms
			0);											//End of type list

	p = max_jit_classex_setup(calcoffset(t_max_cv_jit_blobs_recon,obex));	//Setup Max class
	q = jit_class_findbyname(gensym("cv_jit_blobs_recon"));				//Get a pointer to the Jitter object class
    max_jit_classex_mop_wrap(p,q,0); 		
    max_jit_classex_standard_wrap(p,q,0); 	

    addmess((method)max_jit_mop_assist, "assist", A_CANT,0);	//Add outlet assistance to object
	
	return 0;
}
Exemple #2
0
void
main(void)
	
	{
	const long kAttrFlags = MAX_JIT_MOP_FLAGS_OWN_OUTPUTMATRIX
								| MAX_JIT_MOP_FLAGS_OWN_BANG;
	
	voidPtr	p,									// Have to guess about what these two do
			q;									// Not much is documented in the Jitter SDK
	
	LITTER_CHECKTIMEOUT(kClassName);
	
	PenizeJitInit();
	
	// Standard Max setup() call
	setup(	&gPenizeMaxClass,					// Pointer to our class definition
			(method) PenizeNewMaxShell,			// Instance creation function
			(method) PenizeFreeMaxShell,		// Custom deallocation function
			(short) sizeof(msobPenize),			// Class object size
			NIL,								// No menu function
			A_GIMME,							// Jitter objects always parse their own
			0);									// arguments
	
	// Jitter Magic... 
	p	= max_jit_classex_setup(
					calcoffset(msobPenize, jitObEx)
					);
	q	= jit_class_findbyname(
					gensym((char*) kMaxClassName)
					);    
    max_jit_classex_mop_wrap(p, q, kAttrFlags); 		
    max_jit_classex_mop_mproc(p, q, PenizeMaxMProc);	// Custom MProc
    max_jit_classex_standard_wrap(p, q, 0); 	
	
	// Add messages...
	LITTER_TIMEBOMB addbang	((method) PenizeBang);
	addmess	((method) PenizeTattle,	"dblclick",	A_CANT, 0);
	addmess	((method) PenizeTattle,	"tattle",	A_NOTHING);
	addmess	((method) PenizeAssist,	"assist",	A_CANT, 0);
	addmess	((method) PenizeInfo,	"info",		A_CANT, 0);
	
	// Define global symbols
	gSymGetDiffs	= gensym("getdiffs");
	
	// Initialize Litter Library
	LitterInit(kMaxClassName, 0);
	}
Exemple #3
0
void main(void)
{	
	void *p,*q;
	
	jit_str_op_init();	
	setup(&max_jit_str_op_class, max_jit_str_op_new, (method)max_jit_str_op_free, (short)sizeof(t_max_jit_str_op), 
		0L, A_GIMME, 0);

	p = max_jit_classex_setup(calcoffset(t_max_jit_str_op,obex));
	q = jit_class_findbyname(gensym("jit_str_op"));    
    max_jit_classex_mop_wrap(p,q,MAX_JIT_MOP_FLAGS_OWN_JIT_MATRIX);
    max_jit_classex_mop_mproc(p,q,max_jit_str_op_mproc);
    max_jit_classex_standard_wrap(p,q,0); 	

	addmess((method)max_jit_str_op_jit_matrix, "jit_matrix", A_GIMME,0);	
    addmess((method)max_jit_mop_assist, "assist", A_CANT,0);  
}
Exemple #4
0
void main(void) {

	ps_rectangular = gensym("rectangular");
	ps_hanning = gensym("hanning");
	ps_hamming = gensym("hamming");
	ps_blackman = gensym("blackman");

	setup( &centroid_class, centroid_new, (method)centroid_free, (short)sizeof(t_centroid), 0L, A_GIMME, 0);
		
	addmess((method)centroid_dsp, "dsp", A_CANT, 0);
	addmess((method)centroid_assist, "assist", A_CANT, 0);
	addfloat((method)centroid_float);
	addint((method)centroid_int);
	dsp_initclass();

	rescopy('STR#', RES_ID);
}
Exemple #5
0
        /*
         * fexpr~ initialization
         */
        fexpr_tilde_class = class_new(gensym("fexpr~"), (t_newmethod)expr_new,
            (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0);
        class_addmethod(fexpr_tilde_class, nullfn, gensym("signal"), 0);
        class_addmethod(fexpr_tilde_class,(t_method)expr_start,
                                                        gensym("start"), 0);
        class_addmethod(fexpr_tilde_class,(t_method)expr_stop,
                                                        gensym("stop"), 0);

        class_addmethod(fexpr_tilde_class,(t_method)expr_dsp,gensym("dsp"), 0);
        class_addmethod(fexpr_tilde_class, (t_method)fexpr_tilde_set,
                        gensym("set"), A_GIMME, 0);
        class_addmethod(fexpr_tilde_class, (t_method)fexpr_tilde_clear,
                        gensym("clear"), A_GIMME, 0);
        class_addmethod(fexpr_tilde_class,(t_method)expr_verbose,
                                                        gensym("verbose"), 0);
        class_addmethod(fexpr_tilde_class,(t_method)expr_version,
                                                        gensym("version"), 0);
        class_sethelpsymbol(fexpr_tilde_class, gensym("expr"));

}

void
expr_tilde_setup(void)
{
        expr_setup();
}

void
fexpr_tilde_setup(void)
{
        expr_setup();
}
#else /* MSP */
void
main(void)
{
        setup((t_messlist **)&expr_tilde_class, (method)Nexpr_new,
                (method)expr_ff, (short)sizeof(t_expr), 0L, A_GIMME, 0);
        addmess((method)expr_dsp, "dsp", A_CANT, 0); // dsp method
        dsp_initclass();
}
Exemple #6
0
int main(void)
{
	setup((t_messlist **)&wlet_class, (method)wlet_new, (method)wlet_free, (short)sizeof(t_wlet), 0L, A_SYM, A_DEFSYM, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0); 
	
	version(0);

	addmess((method) version, "version", 0);
	addmess((method)wlet_dsp, "dsp", A_CANT, 0);
	addmess((method)wlet_anything, "anything", A_GIMME, 0);
	addint((method)wlet_int);
	addmess((method)wlet_assist, "assist", A_CANT, 0);
	addmess((method)wlet_tellmeeverything, "tellmeeverything", 0);
	
	dsp_initclass();
	
	return 0;
}
Exemple #7
0
int main(void) {

    setup((t_messlist **)&xtract_tilde_class,
    	(method)xtract_tilde_new,
    	(method)xtract_tilde_free, 
    	sizeof(t_xtract_tilde),
    	0L, 
    	A_GIMME, 0);

    addmess((method)xtract_tilde_dsp, "dsp", A_CANT,  0);
    addmess((method)xtract_tilde_get_args, "list", A_GIMME, 0);
    addmess((method)xtract_tilde_show_help, "help", A_DEFSYM, 0); 
    dsp_initclass();
    //class_setname("xtract~", "xtract~");

    return 0;

}
Exemple #8
0
void main(void)
{
  setup((t_messlist **)&leaker_class, (method)leaker_new, (method)leaker_free, 
	(short)sizeof(t_leaker), 0, A_GIMME, 0);
  addmess((method)leaker_dsp, "dsp", A_CANT, 0);
  addmess((method)leaker_assist,"assist",A_CANT,0);
  addmess((method)leaker_upsieve, "upsieve", 0);
  addmess((method)leaker_downsieve, "downsieve", 0);
  addmess((method)leaker_randsieve, "randsieve", 0);
  addmess((method)leaker_bypass,"bypass",A_DEFFLOAT,0);
  addmess((method)leaker_mute,"mute",A_DEFFLOAT,0);
  addmess((method)leaker_overlap,"overlap",A_DEFFLOAT,0);
  addmess((method)leaker_winfac,"winfac",A_DEFFLOAT,0);
  addmess((method)leaker_fftinfo,"fftinfo",0);
  addfloat((method)leaker_float);
  dsp_initclass();
  post("%s %s",OBJECT_NAME,FFTEASE_ANNOUNCEMENT);
}
Exemple #9
0
int main(void)
{
    setup((t_messlist **)&rvbap_class, (method)rvbap_new, 0L, (short)sizeof(t_rvbap), 0L, A_GIMME, 0); 
    /* rvbap_new = creation function, A_DEFLONG = its (optional) arguement is a long (32-bit) int */
    addmess((method)rvbap_assist, "assist", A_CANT, 0);
    addbang((method)rvbap_bang);         /* the procedure it uses when it gets a bang in the left inlet */
    addinx((method)rvbap_in1, 1);        /* the rocedure for an int in the right inlet (inlet 1) */
    addinx((method)rvbap_in2, 2);        /* the rocedure for an int in the right inlet (inlet 2) */
    addinx((method)rvbap_in3, 3);
    addinx((method)rvbap_in4, 4);
    addftx((method)rvbap_ft1, 1);        /* the rocedure for an int in the right inlet (inlet 1) */
    addftx((method)rvbap_ft2, 2);        /* the rocedure for an int in the right inlet (inlet 2) */
    addftx((method)rvbap_ft3, 3);
    addftx((method)rvbap_ft4, 4);
    addmess((method)rvbap_matrix, "loudspeaker-matrices", A_GIMME, 0);
    post("rvbap v1.1, © 2003-2007 by Olaf Matthes, based on vbap by Ville Pulkki");
	return 0;
}
void main(void)
{	
	void *classex, *jitclass;
	
	/*
	// Debug console window so printf works
	FILE* pCout; // should really be freed on exit 
	AllocConsole();
	freopen_s(&pCout, "CONOUT$", "w", stdout); 
	printf("jit_gl_spout_receiverSDK\n");
	*/
	post("jit_gl_spout_receiver - SDK Vers 2.001");

	// initialize our Jitter class
	jit_gl_spout_receiver_init();	
	
	// create our Max class
	setup((t_messlist **)&max_jit_gl_spout_receiver_class, 
		  (method)max_jit_gl_spout_receiver_new, 
		  (method)max_jit_gl_spout_receiver_free, 
		  (short)sizeof(t_max_jit_gl_spout_receiver), 
		  0L, A_GIMME, 0);
	
	// specify a byte offset to keep additional information about our object
	classex = max_jit_classex_setup(calcoffset(t_max_jit_gl_spout_receiver, obex));
	
	// look up our Jitter class in the class registry
	jitclass = jit_class_findbyname(gensym("jit_gl_spout_receiver"));	
	
	// wrap our Jitter class with the standard methods for Jitter objects
    max_jit_classex_standard_wrap(classex, jitclass, 0); 	
	
	// custom draw handler so we can output our texture.
	// override default ob3d bang/draw methods
	addbang((method)max_jit_gl_spout_receiver_bang);
	max_addmethod_defer_low((method)max_jit_gl_spout_receiver_draw, "draw");  
	
    #ifdef UseServers
	max_addmethod_defer_low((method)max_jit_gl_spout_receiver_getavailableservers, "getavailableservers");
	#else
	max_addmethod_defer_low((method)max_jit_gl_spout_receiver_getavailablesenders, "getavailablesenders");
	#endif
    
   	// use standard ob3d assist method
    addmess((method)max_jit_ob3d_assist, "assist", A_CANT,0);  
	
	// add methods for 3d drawing
    max_ob3d_setup();

	ps_jit_gl_texture = gensym("jit_gl_texture");
	ps_maxdraw = gensym("maxdraw");
	ps_out_name = gensym("out_name");
	ps_spoutsendername = gensym("SpoutSender");
    ps_clear = gensym("clear");

}
void ext_main(void *r)
{
	long attrflags;
	void *p,*attr;

	setup((t_messlist **)&max_jit_peek_class, (method)max_jit_peek_new, (method)max_jit_peek_free, (short)sizeof(t_max_jit_peek),
		  0L, A_GIMME, 0);

	addmess((method)max_jit_peek_dsp, "dsp", A_CANT, 0);
	addmess((method)max_jit_peek_dsp64, "dsp64", A_CANT, 0);
	dsp_initclass();

	p = max_jit_classex_setup(calcoffset(t_max_jit_peek,obex));

	attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW ;
	attr = jit_object_new(_jit_sym_jit_attr_offset,"matrix_name",_jit_sym_symbol,attrflags,
						  (method)0L,(method)max_jit_peek_matrix_name,calcoffset(t_max_jit_peek,matrix_name));
	max_jit_classex_addattr(p,attr);
	object_addattr_parse(attr,"label",_jit_sym_symbol,0,"\"Matrix Name\"");
	
	attr = jit_object_new(_jit_sym_jit_attr_offset,"plane",_jit_sym_long,attrflags,
						  (method)0L,(method)0L,calcoffset(t_max_jit_peek,plane));
	max_jit_classex_addattr(p,attr);
	object_addattr_parse(attr,"label",_jit_sym_symbol,0,"Plane");
	
	attr = jit_object_new(_jit_sym_jit_attr_offset,"interp",_jit_sym_long,attrflags,
						  (method)0L,(method)0L,calcoffset(t_max_jit_peek,interp));
	max_jit_classex_addattr(p,attr);
	object_addattr_parse(attr,"label",_jit_sym_symbol,0,"Interp");
	
	attr = jit_object_new(_jit_sym_jit_attr_offset,"normalize",_jit_sym_long,attrflags,
						  (method)0L,(method)0L,calcoffset(t_max_jit_peek,normalize));
	max_jit_classex_addattr(p,attr);
	object_addattr_parse(attr,"label",_jit_sym_symbol,0,"Normalize");

	// because it is not safe to call jitter methods inside the perform routine,
	// we need notify message to find out when our matrix data is changing
	addmess((method)max_jit_peek_notify, "notify", A_CANT,0);

	max_jit_classex_standard_wrap(p,NULL,0);
	addmess((method)max_jit_peek_assist, "assist", A_CANT,0);
	return 0;
}
Exemple #12
0
void main(fptr *f)

{

	long oldA4;

	

	// this code is a 68K-only macro

	oldA4 = SetCurrentA4();			// get correct value of A4

	RememberA4();					// store inside code resource

	// this is not necessary (but harmless) on PowerPC

	FNS = f;	

	

	/* tell Max about your class. The cast to short is important for 68K */

	setup(&myobject_class, myobject_new,0L, (short)sizeof(MyObject), 0L, A_DEFLONG, 0);

	/* bind your methods to symbols */

	addbang((method)myobject_bang);

	addint((method)myobject_int);

	addmess((method)myobject_FullPacket, "FullPacket", A_LONG, A_LONG, 0);

	addmess((method)myobject_set, "set", A_LONG, 0);

	/* list object in the new object list */

	finder_addclass("Data","dereffer");

	// restore old value of A4 (68K only)

	RestoreA4(oldA4);

}
void ext_main(void *r)
{
	void *p, *q;

	jit_scissors_init();
	setup(&max_jit_scissors_class, max_jit_scissors_new, (method)max_jit_scissors_free, (short)sizeof(t_max_jit_scissors),
		  0L, A_GIMME, 0);

	p = max_jit_classex_setup(calcoffset(t_max_jit_scissors, obex));
	q = jit_class_findbyname(gensym("jit_scissors"));
	max_jit_classex_mop_wrap(p, q, MAX_JIT_MOP_FLAGS_OWN_BANG|MAX_JIT_MOP_FLAGS_OWN_OUTPUTMATRIX); //no bang/outputmatrix...doesn't make sense for this object
	max_jit_classex_standard_wrap(p, q, 0);
	addmess((method)max_jit_scissors_assist, "assist", A_CANT, 0);
	addmess((method)max_jit_mop_variable_anything, "anything", A_GIMME, 0);

	ps_rows 	= gensym("rows");
	ps_columns	= gensym("columns");

}
Exemple #14
0
void flext_base::SetProxies(t_class *c,bool dsp)
{
#if FLEXT_SYS == FLEXT_SYS_PD
    // for leftmost inlet
    class_addbang(c,cb_bang);
    if(!dsp) class_addfloat(c,cb_float);
    class_addsymbol(c,cb_symbol);
//    class_addpointer(c,cb_pointer);
    class_addlist(c,cb_anything);
    class_addanything(c,cb_anything);

    // proxy for extra inlets
    if(UNLIKELY(!px_class)) {
        // only once
        px_class = class_new(gensym(const_cast<char *>(" flext_base proxy ")),NULL,NULL,sizeof(px_object),CLASS_PD|CLASS_NOINLET, A_NULL);
        class_addbang(px_class,px_object::px_bang); // for other inlets
        class_addfloat(px_class,px_object::px_float); // for other inlets
        class_addsymbol(px_class,px_object::px_symbol); // for other inlets
//        class_addpointer(px_class,px_object::px_pointer); // for other inlets
        class_addlist(px_class,px_object::px_anything); // for other inlets
        class_addanything(px_class,px_object::px_anything); // for other inlets
    }
#elif FLEXT_SYS == FLEXT_SYS_MAX
    addbang((method)cb_bang);
    addint((method)cb_int);  
    addfloat((method)cb_float);  
    addmess((method)cb_anything,"list",A_GIMME,A_NOTHING); // must be explicitly given, otherwise list elements are distributed over inlets
    addmess((method)cb_anything,"anything",A_GIMME,A_NOTHING);
#else
#error Not implemented!
#endif  

    // setup non-leftmost ints and floats
    ADD_PROXYMSG(c,1);
    ADD_PROXYMSG(c,2);
    ADD_PROXYMSG(c,3);
    ADD_PROXYMSG(c,4);
    ADD_PROXYMSG(c,5);
    ADD_PROXYMSG(c,6);
    ADD_PROXYMSG(c,7);
    ADD_PROXYMSG(c,8);
    ADD_PROXYMSG(c,9);
}
Exemple #15
0
void main(void)
{
	setup((t_messlist **)&vdb_class, (method)vdb_new, (method)vdb_free, 
	(short)sizeof(t_vdb), 0, A_GIMME, 0);
	addmess((method)vdb_dsp, "dsp", A_CANT, 0);
  addfloat((method)vdb_float);
  addint((method)vdb_int);
	addmess((method)vdb_assist, "assist", A_CANT, 0);
  addmess((method)vdb_protect,"protect",A_FLOAT,0);
  addmess((method)vdb_inf_hold,"inf_hold",A_FLOAT,0);
  addmess((method)vdb_maxdelay,"maxdelay",A_FLOAT,0);
  addmess((method)vdb_always_update,"always_update",A_FLOAT,0);
	addmess((method)vdb_mute, "mute", A_FLOAT, 0);
	addmess((method)vdb_show, "show", 0);
	addmess((method)vdb_update_buffer, "update_buffer", 0);
	addmess((method)vdb_interpolate, "interpolate", A_FLOAT, 0);

	dsp_initclass();
	post("%s %s",OBJECT_NAME, LYONPOTPOURRI_MSG);
}
Exemple #16
0
void main(void)
{	
	long attrflags;
	void *p,*attr;
	
	setup(&max_jit_turtle_class, max_jit_turtle_new, (method)max_jit_turtle_free, (short)sizeof(t_max_jit_turtle), 
		0L, A_GIMME, 0);

	p = max_jit_classex_setup(calcoffset(t_max_jit_turtle,obex));
	
 	attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW ;

	// origin -- where to start drawing from (or reset to with a 'reset' message)
	attr = jit_object_new(_jit_sym_jit_attr_offset_array,"origin",_jit_sym_long,2,attrflags,
		(method)0,(method)0,calcoffset(t_max_jit_turtle,origincount),calcoffset(t_max_jit_turtle,origin));
	max_jit_classex_addattr(p,attr);

	// angle -- angle factor for turning the turtle
	attr = jit_object_new(_jit_sym_jit_attr_offset,"angle",_jit_sym_long,attrflags,
		(method)0,(method)0,calcoffset(t_max_jit_turtle,angle));
	max_jit_classex_addattr(p,attr);

	// scale -- stepsize for moving the turtle
	attr = jit_object_new(_jit_sym_jit_attr_offset,"scale",_jit_sym_long,attrflags,
		(method)0,(method)0,calcoffset(t_max_jit_turtle,scale));
	max_jit_classex_addattr(p,attr);

	// clearmode -- send a clear on reset or not
	attr = jit_object_new(_jit_sym_jit_attr_offset,"clearmode",_jit_sym_long,attrflags,
		(method)0,(method)0,calcoffset(t_max_jit_turtle,clearmode));
	max_jit_classex_addattr(p,attr);
	
	addmess((method)max_jit_turtle_reset,			"reset",			A_GIMME,0);
	
	max_jit_classex_standard_wrap(p,NULL,0);	
	addmess((method)max_jit_turtle_assist,			"assist",			A_CANT,0);
// 	addbang((method)max_jit_turtle_bang);
	addint((method)max_jit_turtle_int);
	
    max_jit_class_addmethods(jit_class_findbyname(gensym("jit_turtle")));	
}
void main(void)				// main recieves a copy of the Max function macros table
{

 long int tick = gettime();

	setup((t_messlist **)&red_noise_class, (method)red_noise_new, (method)dsp_free, (short)sizeof(t_red_noise), 0L, A_DEFFLOAT, 0);

	addmess((method)red_noise_dsp, "dsp", A_CANT, 0);					
	addmess((method)red_noise_assist, "assist", A_CANT, 0);				
//	addint((method)red_noise_param);									
	addfloat((method)red_noise_setphaseinc);									

	addmess((method)red_noise_min, "min",A_DEFFLOAT, 0);				
	addmess((method)red_noise_max, "max",A_DEFFLOAT, 0);				

	addmess((method)red_noise_reset, "reset", 0);				
//	addmess((method)red_noise_setphasetime, "phasetime", A_DEFFLOAT, 0);				// Bind method "red_noise_assist" to assistance calls
//	addmess((method)red_noise_setphaseinc, "phaseinc", A_DEFFLOAT, 0);				// Bind method "red_noise_assist" to assistance calls
 	post("a-rednoise~ © andrŽ sier 2007 "__DATE__" \t \a \t  "__TIME__"\t \a \t %08xd ",tick, 0);
	dsp_initclass();												// Setup object's class to work with MSP
}
Exemple #18
0
void main(void)
{	
	void *p,*q;
	
	jit_notify_init();	
	setup(&max_jit_notify_class, max_jit_notify_new, (method)max_jit_notify_free, (short)sizeof(t_max_jit_notify), 
		0L, A_GIMME, 0);

	p = max_jit_classex_setup(calcoffset(t_max_jit_notify,obex));
	q = jit_class_findbyname(gensym("jit_notify"));    
	
	//NOTIFY EXAMPLE: WE NEED TO OVERRIDE THE DEFAULT MOP NOTIFY METHOD
    max_jit_classex_mop_wrap(p,q,MAX_JIT_MOP_FLAGS_OWN_NOTIFY); 		//name/type/dim/planecount/bang/outputmatrix/etc
    
    max_jit_classex_standard_wrap(p,q,0); 	//getattributes/dumpout/maxjitclassaddmethods/etc
    addmess((method)max_jit_mop_assist, "assist", A_CANT,0);  //standard mop assist fn

	//NOTIFY EXAMPLE: HERE'S WHERE WE DECLARE OUR OWN NOTIFY METHOD
    addmess((method)max_jit_notify_notify, "notify", A_CANT,0);  

}
Exemple #19
0
// Main function
void main(void) 
{
	post("gaussdraw object version " VERSION " by Tristan Jehan");
    post("copyright © 2001 Massachusetts Institute of Technology");
	post("");
	
	setup(								// Setup Object
		(Messlist**) &gaussdraw_class,	// Pointer to class
		(method) gaussdraw_new,			// Constructor
		(method) gaussdraw_free,		// Destructor
		(short) sizeof(t_gaussdraw),	// Class Size
		0L,	A_GIMME, 0);

	/* bind your methods to symbols */
	addbang((method)gaussdraw_bang);
	addfloat((method)gaussdraw_float);
	addint((method)gaussdraw_int);
	addinx((method)gaussdraw_int_1,1);
	addinx((method)gaussdraw_int_2,2);
	addftx((method)gaussdraw_float_1,1);
	addftx((method)gaussdraw_float_2,2);
	addmess((method)gaussdraw_assist,"assist",A_CANT,0);
	addmess((method)gaussdraw_min,"min",A_GIMME,0);
	addmess((method)gaussdraw_max,"max",A_GIMME,0);
	addmess((method)gaussdraw_numpts,"numbars",A_GIMME,0);
	addmess((method)gaussdraw_default,"default",A_GIMME,0);
	addmess((method)gaussdraw_print,"print",A_GIMME,0);

	/* list object in the new object list */
	finder_addclass("Statistics", "gaussdraw");

	rescopy('STR#', RES_ID);
}
void main(void)
{
    setup((t_messlist **)&markov_class,(method) markov_new, (method)markov_free, (short)sizeof(t_markov), 0L, A_DEFFLOAT, 0);
    addmess((method)markov_dsp, "dsp", A_CANT, 0);
    addmess((method)markov_assist,"assist",A_CANT,0);
    addmess((method)markov_subdiv,"subdiv",A_FLOAT,0);
    addmess((method)markov_tempo,"tempo",A_FLOAT,0);
    addmess((method)markov_values,"values",A_GIMME,0);
    addmess((method)markov_event_odds,"event_odds",A_GIMME,0);
    addmess((method)markov_set_length,"set_length",A_FLOAT,0);
    addmess((method)markov_manual_override,"manual_override",A_FLOAT,0);
    addbang((method)markov_bang);
    dsp_initclass();
	post("%s %s",OBJECT_NAME, LYONPOTPOURRI_MSG);}
Exemple #21
0
void
main(void)
	
	{
	LITTER_CHECKTIMEOUT(kClassName);
	
	// Standard Max setup() call
	setup(	&gObjectClass,			// Pointer to our class definition
			(method) SssNew,		// Instance creation function
			(method) SssFree,		// Custom deallocation function
			sizeof(tPink),			// Class object size
			NIL,					// No menu function
			A_DEFLONG,				// Optional arguments:	1. NN Factor
			A_DEFLONG,				// 						3. Seed value
			0);		
	

	// Messages
	LITTER_TIMEBOMB addbang	((method) SssBang);
	addmess	((method) SssNN,		"in1",		A_LONG);
	addmess ((method) SssSeed,		"seed",		A_DEFLONG, 0);
	addmess	((method) SssTattle,	"dblclick",	A_CANT, 0);
	addmess	((method) SssTattle,	"tattle",	A_NOTHING);
	addmess	((method) SssAssist,	"assist",	A_CANT, 0);
	addmess	((method) SssInfo,		"info",		A_CANT, 0);
	
	//Initialize Litter Library
	LitterInit(kClassName, 0);
	Taus88Init();
	
	}
void C74_EXPORT main(void)
{
	void *p,*q;

	xray_jit_keepcell_init();
	setup((t_messlist **)&max_xray_jit_keepcell_class, max_xray_jit_keepcell_new, (method)max_xray_jit_keepcell_free, (short)sizeof(t_max_xray_jit_keepcell),
		0L, A_GIMME, 0);

	p = max_jit_classex_setup(calcoffset(t_max_xray_jit_keepcell,obex));
	q = jit_class_findbyname(gensym("xray_jit_keepcell"));
    max_jit_classex_mop_wrap(p,q,0);
    max_jit_classex_standard_wrap(p,q,0);
    addmess((method)max_jit_mop_assist, "assist", A_CANT,0);
}
void ext_main(void *r)
{
	void *p,*q;

	jit_split_init();
	setup(&max_jit_split_class, max_jit_split_new, (method)max_jit_split_free, (short)sizeof(t_max_jit_split),
		  0L, A_GIMME, 0);

	p = max_jit_classex_setup(calcoffset(t_max_jit_split,obex));
	q = jit_class_findbyname(gensym("jit_split"));
	max_jit_classex_mop_wrap(p,q,0);
	max_jit_classex_standard_wrap(p,q,0);
	addmess((method)max_jit_mop_assist, "assist", A_CANT,0);
}
void main()
{
	setup((t_messlist **)&akabookmotion_class, 
			(method)akabookmotion_new, 
			(method)akabookmotion_free, 
			(short)sizeof(t_akabookmotion), 
			0L, 
			A_GIMME, 0);
	
	addbang((method)akabookmotion_bang);
	addmess((method)akabookmotion_assist,"assist",A_CANT,0);
	
	post("aka.bookmotion 1.0-UB by Masayuki Akamatsu");
}
Exemple #25
0
void C74_EXPORT main(void)
{	
	void *p,*q;
	
	jit_transpose_init();
	setup(&max_jit_transpose_class, max_jit_transpose_new, (method)max_jit_transpose_free, (short)sizeof(t_max_jit_transpose), 
		0L, A_GIMME, 0);

	p = max_jit_classex_setup(calcoffset(t_max_jit_transpose,obex));
	q = jit_class_findbyname(gensym("jit_transpose"));    
    max_jit_classex_mop_wrap(p,q,0); 		
    max_jit_classex_standard_wrap(p,q,0); 	
    addmess((method)max_jit_mop_assist, "assist", A_CANT,0);  
}
void C74_EXPORT main(void)
{
    void *p,*q;

    jit_alphablend_init();
    setup((t_messlist **)&max_jit_alphablend_class, (method)max_jit_alphablend_new, (method)max_jit_alphablend_free, (short)sizeof(t_max_jit_alphablend),
          0L, A_GIMME, 0);

    p = max_jit_classex_setup(calcoffset(t_max_jit_alphablend,obex));
    q = jit_class_findbyname(gensym("jit_alphablend"));
    max_jit_classex_mop_wrap(p,q,0);
    max_jit_classex_standard_wrap(p,q,0);
    addmess((method)max_jit_mop_assist, "assist", A_CANT,0);
}
Exemple #27
0
void main(void)
{
  setup((t_messlist **)&pvcompand_class, (method)pvcompand_new, 
  (method)pvcompand_free, (short)sizeof(t_pvcompand), 0, A_GIMME, 0);
  addmess((method)pvcompand_dsp, "dsp", A_CANT, 0);
  addmess((method)pvcompand_normalize, "normalize", A_LONG, 0);
  addmess((method)pvcompand_winfac,"winfac", A_FLOAT, 0);
  addmess((method)pvcompand_overlap,"overlap", A_FLOAT, 0);
  addmess((method)pvcompand_fftinfo,"fftinfo", 0);
  addmess((method)pvcompand_bypass,"bypass", A_FLOAT, 0);
  addmess((method)pvcompand_mute,"mute", A_FLOAT, 0);
  addmess((method)pvcompand_assist,"assist",A_CANT,0);
  addfloat((method)pvcompand_float);
  dsp_initclass();
  post("%s %s",OBJECT_NAME,FFTEASE_ANNOUNCEMENT);
}
Exemple #28
0
void C74_EXPORT main(void)
{	
	void *p,*q;
	
	jit_clip_init();	
	setup(&max_jit_clip_class, max_jit_clip_new, (method)max_jit_clip_free, (short)sizeof(t_max_jit_clip), 
		0L, A_GIMME, 0);

	p = max_jit_classex_setup(calcoffset(t_max_jit_clip,obex));
	q = jit_class_findbyname(gensym("jit_clip"));    
    max_jit_classex_mop_wrap(p,q,0); 		//name/type/dim/planecount/bang/outputmatrix/etc
    max_jit_classex_standard_wrap(p,q,0); 	//getattributes/dumpout/maxjitclassaddmethods/etc
    addmess((method)max_jit_mop_assist, "assist", A_CANT,0);  //standard mop assist fn
}
void ext_main(void *r)
{
	void *p,*q;

	jit_submatrix_init();
	setup(&max_jit_submatrix_class, max_jit_submatrix_new, (method)max_jit_submatrix_free, (short)sizeof(t_max_jit_submatrix),
		  0L, A_GIMME, 0);

	p = max_jit_classex_setup(calcoffset(t_max_jit_submatrix,obex));
	q = jit_class_findbyname(gensym("jit_submatrix"));
	max_jit_classex_mop_wrap(p,q,MAX_JIT_MOP_FLAGS_OWN_ALL & ~MAX_JIT_MOP_FLAGS_OWN_JIT_MATRIX);
	max_jit_classex_mop_mproc(p,q,max_jit_submatrix_mproc); 	//custom mproc
	max_jit_classex_standard_wrap(p,q,0); 	//getattributes/dumpout/maxjitclassaddmethods/etc
	addmess((method)max_jit_mop_assist, "assist", A_CANT,0);  //standard mop assist fn
}
Exemple #30
0
void main(void) {

    post("Noisiness~ object version " VERSION " by Tristan Jehan (Media Laboratory)");
    post("copyright © 2001 Massachusetts Institute of Technology");
    post("");

    ps_rectangular = gensym("rectangular");
    ps_hanning = gensym("hanning");
    ps_hamming = gensym("hamming");
    ps_blackman62 = gensym("blackman62");
    ps_blackman70 = gensym("blackman70");
    ps_blackman74 = gensym("blackman74");
    ps_blackman92 = gensym("blackman92");

    setup((Messlist **)&noisiness_class, (method)noisiness_new, (method)noisiness_free, (short)sizeof(t_noisiness), 0L, A_GIMME, 0);

    addmess((method)noisiness_dsp, "dsp", A_CANT, 0);
    addmess((method)noisiness_assist, "assist", A_CANT, 0);
    addfloat((method)noisiness_float);
    addint((method)noisiness_int);
    dsp_initclass();

    rescopy('STR#', RES_ID);
}