t_jit_err jit_findbounds_init(void) 
{
	long attrflags=0;
	t_jit_object *attr,*mop;
	
	_jit_findbounds_class = jit_class_new("jit_findbounds",(method)jit_findbounds_new,(method)jit_findbounds_free,
		sizeof(t_jit_findbounds),0L);

	//add mop
	mop = jit_object_new(_jit_sym_jit_mop,1,0);
	jit_class_addadornment(_jit_findbounds_class,mop);
	//add methods
	jit_class_addmethod(_jit_findbounds_class, (method)jit_findbounds_matrix_calc, 		"matrix_calc", 		A_CANT, 0L);
	//add attributes	
	attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
	
	CLASS_STICKY_ATTR(_jit_findbounds_class,"category",0,"Behavior");
	CLASS_STICKY_ATTR(_jit_findbounds_class,"basic",0,"1");

	attr = jit_object_new(_jit_sym_jit_attr_offset_array,"min",_jit_sym_float64,JIT_MATRIX_MAX_PLANECOUNT,attrflags,
		(method)0L,(method)0L,calcoffset(t_jit_findbounds, mincount),calcoffset(t_jit_findbounds,min));
	jit_class_addattr(_jit_findbounds_class,attr);
	CLASS_ATTR_LABEL(_jit_findbounds_class,"min",0,"Minimum");	

	attr = jit_object_new(_jit_sym_jit_attr_offset_array,"max",_jit_sym_float64,JIT_MATRIX_MAX_PLANECOUNT,attrflags,
		(method)0L,(method)0L,calcoffset(t_jit_findbounds, maxcount),calcoffset(t_jit_findbounds,max));
	jit_class_addattr(_jit_findbounds_class,attr);
	CLASS_ATTR_LABEL(_jit_findbounds_class,"max",0,"Maximum");	

	CLASS_STICKY_ATTR_CLEAR(_jit_findbounds_class, "basic");
	
	CLASS_STICKY_ATTR(_jit_findbounds_class,"category",0,"Value");

	attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_OPAQUE_USER;
	attr = jit_object_new(_jit_sym_jit_attr_offset_array,"boundmin",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
		(method)0L,(method)0L,calcoffset(t_jit_findbounds, boundmincount),calcoffset(t_jit_findbounds,boundmin));
	jit_class_addattr(_jit_findbounds_class,attr);
	CLASS_ATTR_LABEL(_jit_findbounds_class,"boundmin",0,"Bounding Box Minimum");	

	attr = jit_object_new(_jit_sym_jit_attr_offset_array,"boundmax",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
		(method)0L,(method)0L,calcoffset(t_jit_findbounds, boundmaxcount),calcoffset(t_jit_findbounds,boundmax));
	jit_class_addattr(_jit_findbounds_class,attr);
	CLASS_ATTR_LABEL(_jit_findbounds_class,"boundmax",0,"Bounding Box Maximum");	
	
	CLASS_STICKY_ATTR_CLEAR(_jit_findbounds_class, "category");
	
	jit_class_register(_jit_findbounds_class);

	return JIT_ERR_NONE;
}

int main(void)
{	
	void *p, *q;
	t_jit_object	*attr;
	
	post("jit.openni %s, Copyright (c) 2011 Dale Phurrough. This program comes with ABSOLUTELY NO WARRANTY.", JIT_OPENNI_VERSION);
	post("jit.openni %s, Licensed under the GNU General Public License v3.0 (GPLv3) available at http://www.gnu.org/licenses/gpl-3.0.html", JIT_OPENNI_VERSION);

	// initialize the Jitter class by calling Jitter class's registration function
	jit_openni_init();
	
	// create the Max wrapper class
	setup((t_messlist**)&max_jit_openni_class, (method)max_jit_openni_new, (method)max_jit_openni_free, sizeof(t_max_jit_openni), 0, A_GIMME, 0);
	
	// specify a byte offset to keep additional OBEX information
	p = max_jit_classex_setup(calcoffset(t_max_jit_openni, obex));
	
	// look up the Jitter class in the class registry
	q = jit_class_findbyname(gensym("jit_openni"));    
    
	// add default methods and attributes for MOP max wrapper class, e.g. name, type, dim, planecount, bang, outputmatrix, etc
	max_jit_classex_mop_wrap(p, q, MAX_JIT_MOP_FLAGS_OWN_OUTPUTMATRIX|MAX_JIT_MOP_FLAGS_OWN_JIT_MATRIX|MAX_JIT_MOP_FLAGS_OWN_ADAPT);

	// add custom max wrapper attributes
	attr = jit_object_new(_jit_sym_jit_attr_offset, "skeleton_format", _jit_sym_char, JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW,
			NULL, NULL, calcoffset(t_max_jit_openni, chrSkeletonOutputFormat));
	jit_attr_addfilterset_clip(attr,0,2,TRUE,TRUE);
	max_jit_classex_addattr(p, attr);

	// wrap the Jitter class with the standard methods for Jitter objects, e.g. getattributes, dumpout, maxjitclassaddmethods, etc
	max_jit_classex_standard_wrap(p, q, 0);

    // add methods to the Max wrapper class
	max_addmethod_usurp_low((method)max_jit_openni_outputmatrix, "outputmatrix");	
	max_addmethod_usurp_low((method)max_jit_openni_XMLConfig_read, "read");

	// add an inlet/outlet assistance method; in this case the default matrix-operator (mop) assist fn 
	addmess((method)max_jit_openni_assist, "assist", A_CANT, 0);
	return 0;
}

t_jit_err jit_3m_init(void) 
{
	long attrflags=0;
	t_jit_object *attr,*mop;
	
	_jit_3m_class = jit_class_new("jit_3m",(method)jit_3m_new,(method)jit_3m_free,
		sizeof(t_jit_3m),0L);

	//add mop
	mop = jit_object_new(_jit_sym_jit_mop,1,0);
	jit_class_addadornment(_jit_3m_class,mop);
	//add methods
	jit_class_addmethod(_jit_3m_class, (method)jit_3m_matrix_calc, 		"matrix_calc", 		A_CANT, 0L);
	//add attributes	
	attrflags = JIT_ATTR_SET_OPAQUE_USER | JIT_ATTR_GET_DEFER_LOW;
	attr = jit_object_new(_jit_sym_jit_attr_offset_array,"min",_jit_sym_atom,JIT_MATRIX_MAX_PLANECOUNT,attrflags,
		(method)0L,(method)0L,calcoffset(t_jit_3m,planecount),calcoffset(t_jit_3m,min));
	jit_class_addattr(_jit_3m_class,attr);
	attr = jit_object_new(_jit_sym_jit_attr_offset_array,"mean",_jit_sym_atom,JIT_MATRIX_MAX_PLANECOUNT,attrflags,
		(method)0L,(method)0L,calcoffset(t_jit_3m,planecount),calcoffset(t_jit_3m,mean));
	jit_class_addattr(_jit_3m_class,attr);
	attr = jit_object_new(_jit_sym_jit_attr_offset_array,"max",_jit_sym_atom,JIT_MATRIX_MAX_PLANECOUNT,attrflags,
		(method)0L,(method)0L,calcoffset(t_jit_3m,planecount),calcoffset(t_jit_3m,max));
	jit_class_addattr(_jit_3m_class,attr);
	
	jit_class_register(_jit_3m_class);

	return JIT_ERR_NONE;
}

int JAMOMA_EXPORT_MAXOBJ main(void)
{
	long 		attrflags = 0;
	t_class 	*c;
	t_object 	*attr = NULL;
	
	jamoma_init();
	common_symbols_init();

	// Define our class
#ifdef JCOM_OUT_TILDE
	c = class_new("jcom.out~",(method)out_new, (method)out_free, sizeof(t_out), (method)0L, A_GIMME, 0);
#else
	c = class_new("jcom.out",(method)out_new, (method)out_free, sizeof(t_out), (method)0L, A_GIMME, 0);
#endif

	// Make methods accessible for our class: 
	class_addmethod(c, (method)out_dispatched,			"dispatched",			A_GIMME, 0L);
	class_addmethod(c, (method)out_algorithm_message,	"algorithm_message",	A_GIMME, 0L);
	class_addmethod(c, (method)out_link_to_in_object,	"link_in", 				A_CANT, 0L);
	class_addmethod(c, (method)out_unlink,				"unlink_in",			0L);
	class_addmethod(c, (method)out_register_meter,		"register_meter",		A_CANT, 0L);
	class_addmethod(c, (method)out_remove_meters,		"remove_meters",		A_CANT, 0L);
	class_addmethod(c, (method)out_register_preview,	"register_preview",		A_CANT, 0L);
#ifdef JCOM_OUT_TILDE
	class_addmethod(c, (method)out_getAudioForChannel,	"getAudioForChannel",	A_CANT, 0);
	class_addmethod(c, (method)out_dsp,					"dsp", 					A_CANT, 0L);
#else
	class_addmethod(c, (method)out_anything,			"anything",				A_GIMME, 0L);
	class_addmethod(c, (method)out_sendbypassedvalue,	"sendbypassedvalue",	A_CANT, 0L);
	class_addmethod(c, (method)out_sendlastvalue,		"sendlastvalue",		A_CANT, 0L);
#endif
	class_addmethod(c, (method)out_release,				"release",				A_CANT, 0L);	// notification of hub being freed
    class_addmethod(c, (method)out_assist,				"assist", 				A_CANT, 0L);

	jcom_core_subscriber_classinit_common(c, attr);	
		
	// ATTRIBUTE: num_inputs
	attr = attr_offset_new("num_outputs", _sym_long, attrflags,
		(method)0, (method)0, calcoffset(t_out, numOutputs));
	class_addattr(c, attr);	

#ifdef JCOM_OUT_TILDE
	// Setup our class to work with MSP
	class_dspinit(c);
#endif 

	// Finalize our class
	class_register(CLASS_BOX, c);
	out_class = c;
	return 0;
}

	static inline void
	AddInfo(void)
		{
		Object*	attr;
		Symbol*	symFloat64		= gensym("float64");
		Symbol*	symLong			= gensym("long");
		
		// Read-Write Attributes
		attr = attr_offset_new("seed", symLong, 0, NULL, NULL, calcoffset(objLili, seed));
		class_addattr(gObjectClass, attr);
		attr = attr_offset_new("mul", symLong, 0, NULL, NULL, calcoffset(objLili, mul));
		class_addattr(gObjectClass, attr);
		attr = attr_offset_new("add", symLong, 0, NULL, NULL, calcoffset(objLili, add));
		class_addattr(gObjectClass, attr);
		attr = attr_offset_new("mod", symLong, 0, NULL, NULL, calcoffset(objLili, mod));
		class_addattr(gObjectClass, attr);
		
		// Read-Only Attributes
		attr = attribute_new("min", symLong, kAttrFlagsReadOnly, (method) LiliGetMin, NULL);
		class_addattr(gObjectClass, attr);
		attr = attribute_new("max", symLong, kAttrFlagsReadOnly, (method) LiliGetMax, NULL);
		class_addattr(gObjectClass, attr);
		attr = attribute_new("mean", symFloat64, kAttrFlagsReadOnly, (method) LiliGetMean, NULL);
		class_addattr(gObjectClass, attr);
		attr = attribute_new("median", symFloat64, kAttrFlagsReadOnly, (method) LiliGetMedian, NULL);
		class_addattr(gObjectClass, attr);
		attr = attribute_new("mode", symFloat64, kAttrFlagsReadOnly, (method) LiliGetMode, NULL);
		class_addattr(gObjectClass, attr);
		attr = attribute_new("var", symFloat64, kAttrFlagsReadOnly, (method) LiliGetVar, NULL);
		class_addattr(gObjectClass, attr);
		attr = attribute_new("stddev", symFloat64, kAttrFlagsReadOnly, (method) LiliGetStdDev, NULL);
		class_addattr(gObjectClass, attr);
		attr = attribute_new("skew", symFloat64, kAttrFlagsReadOnly, (method) LiliGetSkew, NULL);
		class_addattr(gObjectClass, attr);
		attr = attribute_new("kurtosis", symFloat64, kAttrFlagsReadOnly, (method) LiliGetKurtosis, NULL);
		class_addattr(gObjectClass, attr);
		attr = attribute_new("entropy", symFloat64, kAttrFlagsReadOnly, (method) LiliGetEntropy, NULL);
		class_addattr(gObjectClass, attr);
		}

t_jit_err jit_demultiplex_init(void) 
{
	long attrflags=0;
	t_jit_object *attr;	
	t_jit_object *mop, *o;
	
	_jit_demultiplex_class = jit_class_new("jit_demultiplex",(method)jit_demultiplex_new,(method)jit_demultiplex_free,
		sizeof(t_jit_demultiplex),0L);

	//add mop
	mop = jit_object_new(_jit_sym_jit_mop,1,2);
	jit_mop_output_nolink(mop,1);
	jit_mop_output_nolink(mop,2);

	jit_class_addadornment(_jit_demultiplex_class,mop);
	//add methods
	jit_class_addmethod(_jit_demultiplex_class, (method)jit_demultiplex_matrix_calc, "matrix_calc", A_CANT, 0L);

	//add attributes	
	attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
	attr = jit_object_new(_jit_sym_jit_attr_offset,"demultiplexdim",_jit_sym_char,attrflags, 
		(method)0L,(method)0L,calcoffset(t_jit_demultiplex,demultiplexdim));
	jit_class_addattr(_jit_demultiplex_class,attr);
	attr = jit_object_new(_jit_sym_jit_attr_offset,"autoclear",_jit_sym_char,attrflags, 
		(method)0L,(method)0L,calcoffset(t_jit_demultiplex,autoclear));
	jit_class_addattr(_jit_demultiplex_class,attr);
	attr = jit_object_new(_jit_sym_jit_attr_offset,"scan_a",_jit_sym_long,attrflags, 
		(method)0L,(method)0L,calcoffset(t_jit_demultiplex,scan_a));
	jit_class_addattr(_jit_demultiplex_class,attr);
	attr = jit_object_new(_jit_sym_jit_attr_offset,"scan_b",_jit_sym_long,attrflags, 
		(method)0L,(method)0L,calcoffset(t_jit_demultiplex,scan_b));
	jit_class_addattr(_jit_demultiplex_class,attr);

	//add methods
		
	jit_class_register(_jit_demultiplex_class);

	return JIT_ERR_NONE;
}

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

t_jit_err cv_jit_mass_init(void) 
{
	long attrflags=0;
	t_jit_object *attr,*mop;
	
	_cv_jit_mass_class = jit_class_new("cv_jit_mass",(method)cv_jit_mass_new,(method)cv_jit_mass_free,
		sizeof(t_cv_jit_mass),0L);

	//add mop
	mop = jit_object_new(_jit_sym_jit_mop,1,0);
	jit_class_addadornment(_cv_jit_mass_class,mop);
	//add methods
	jit_class_addmethod(_cv_jit_mass_class, (method)cv_jit_mass_matrix_calc, 		"matrix_calc", 		A_CANT, 0L);
	//add attributes	
	attrflags = JIT_ATTR_SET_OPAQUE_USER | JIT_ATTR_GET_OPAQUE_USER;
	attr = jit_object_new(_jit_sym_jit_attr_offset_array,"Mass",_jit_sym_atom,JIT_MATRIX_MAX_PLANECOUNT,attrflags,
		(method)0L,(method)0L,calcoffset(t_cv_jit_mass,planecount),calcoffset(t_cv_jit_mass,Mass));
	jit_class_addattr(_cv_jit_mass_class,attr);
	
	jit_class_register(_cv_jit_mass_class);

	return JIT_ERR_NONE;
}

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

	static inline void AddPenizeAttribute(const char iName[], long iDataOffset)
		{
		const long kAttrFlags = JIT_ATTR_SET_OPAQUE_USER | JIT_ATTR_GET_OPAQUE_USER;
		
		jit_class_addattr(
				gPenizeJitClass,
				jit_object_new(
						_jit_sym_jit_attr_offset_array, iName,
						_jit_sym_atom, JIT_MATRIX_MAX_PLANECOUNT,
						kAttrFlags, (method) NIL, (method) NIL,
						calcoffset(jcobPenize, planeCount), iDataOffset
						)
				);
		}

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

int TTCLASSWRAPPERMAX_EXPORT main(void)
{
	void *p, *q;
	
	TTFoundationInit();
	StencilClassInit();	
	setup((t_messlist**)&sMaxStencilClass, (method)MaxStencilNew, (method)MaxStencilFree, sizeof(MaxStencilObject), 0, A_GIMME, 0);
	
	p = max_jit_classex_setup(calcoffset(MaxStencilObject, obex));
	q = jit_class_findbyname(gensym("jcom_stencil"));    
    max_jit_classex_mop_wrap(p, q, 0);							// attrs & methods for name, type, dim, planecount, bang, outputmatrix, etc
    max_jit_classex_standard_wrap(p, q, 0);						// attrs & methods for getattributes, dumpout, maxjitclassaddmethods, etc
    addmess((method)max_jit_mop_assist, (char*)"assist", A_CANT, 0);	// standard matrix-operator (mop) assist fn
	return 0;
}

t_jit_err jit_map_init(void) 
{
	long attrflags=0;
	t_jit_object *attr,*mop;
	
	_jit_map_class = jit_class_new("jit_map",(method)jit_map_new,(method)jit_map_free,
		sizeof(t_jit_map),0L);

	//add mop
	mop = jit_object_new(_jit_sym_jit_mop,1,1); //#inputs,#outputs
	jit_class_addadornment(_jit_map_class,mop);
	//add methods
	jit_class_addmethod(_jit_map_class, (method)jit_map_matrix_calc, 		"matrix_calc", 		A_CANT, 0L);
	//add attributes	
	attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
	
	CLASS_STICKY_ATTR(_jit_map_class,"category",0,"Behavior");
	CLASS_STICKY_ATTR(_jit_map_class,"basic",0,"1");

	attr = jit_object_new(_jit_sym_jit_attr_offset_array,"map",_jit_sym_float64,4,attrflags,
		(method)0L,(method)0L,0/*fix*/,calcoffset(t_jit_map,map));
	jit_class_addattr(_jit_map_class,attr);
	CLASS_ATTR_LABEL(_jit_map_class,"map",0,"Input to Output Map");	
	
	attr = jit_object_new(_jit_sym_jit_attr_offset,"clip",_jit_sym_long,attrflags,
		(method)0L,(method)0L,calcoffset(t_jit_map,clip));
	jit_class_addattr(_jit_map_class,attr);
	CLASS_ATTR_STYLE_LABEL(_jit_map_class,"clip",0,"onoff","Clip Values");	
	
	CLASS_STICKY_ATTR_CLEAR(_jit_map_class, "category");
	CLASS_STICKY_ATTR_CLEAR(_jit_map_class, "basic");

	jit_class_register(_jit_map_class);

	return JIT_ERR_NONE;
}

int main(void)
{	
	void *p,*q;
	
	jit_dmxmap_init();
	setup((t_messlist**)&class_max_jit_dmxmap, (method)max_jit_dmxmap_new, (method)max_jit_dmxmap_free, (short)sizeof(t_max_jit_dmxmap), NULL, A_GIMME, 0);

	p = max_jit_classex_setup(calcoffset(t_max_jit_dmxmap,obex));
	q = jit_class_findbyname(gensym("jit_dmxmap"));
	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);

	return 0;
}

t_jit_err xray_jit_cellcoords_init(void)
{
	long attrflags=0;
	t_jit_object *attr;
	t_jit_object *mop, *o;

	_xray_jit_cellcoords_class = jit_class_new("xray_jit_cellcoords",(method)xray_jit_cellcoords_new,(method)xray_jit_cellcoords_free,
		sizeof(t_xray_jit_cellcoords),0L);

	//add mop
	mop = jit_object_new(_jit_sym_jit_mop,1,1);
	o = jit_object_method(mop,_jit_sym_getoutput,1);
	jit_attr_setlong(o,_jit_sym_dimlink,0);

	jit_class_addadornment(_xray_jit_cellcoords_class,mop);

	//add methods
	jit_class_addmethod(_xray_jit_cellcoords_class, (method)xray_jit_cellcoords_matrix_calc, "matrix_calc", A_CANT, 0L);

	//add attributes
	attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;

	//plane
	attr = jit_object_new(_jit_sym_jit_attr_offset,"plane",_jit_sym_char,attrflags,
		(method)0L,(method)0L,calcoffset(t_xray_jit_cellcoords,plane));
	jit_class_addattr(_xray_jit_cellcoords_class,attr);

	//out_mode
	attr = jit_object_new(_jit_sym_jit_attr_offset,"out_mode",_jit_sym_char,attrflags,
		(method)0L,(method)0L,calcoffset(t_xray_jit_cellcoords,out_mode));
	jit_class_addattr(_xray_jit_cellcoords_class,attr);

	jit_class_register(_xray_jit_cellcoords_class);

	return JIT_ERR_NONE;
}

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
}

void C74_EXPORT main(void)
{	
	void *p,*q;
	
	jit_noise_init();	
	setup(&max_jit_noise_class, max_jit_noise_new, (method)max_jit_noise_free, (short)sizeof(t_max_jit_noise), 
		0L, A_GIMME, 0);

	p = max_jit_classex_setup(calcoffset(t_max_jit_noise,obex));
	q = jit_class_findbyname(gensym("jit_noise"));    
    max_jit_classex_mop_wrap(p,q,MAX_JIT_MOP_FLAGS_OWN_OUTPUTMATRIX|MAX_JIT_MOP_FLAGS_OWN_JIT_MATRIX); 		
    max_jit_classex_standard_wrap(p,q,0); 	
	max_addmethod_usurp_low((method)max_jit_noise_outputmatrix, "outputmatrix");	
    addmess((method)max_jit_mop_assist, "assist", A_CANT,0);
}

// MAX 7
void ext_main(void *r)
{

/*
// MAX 6
int C74_EXPORT main(void)
{	
*/

	t_class *maxclass, *jitclass;

	#ifdef ENV64BIT
	post("jit_gl_spout_sender - Vers 2.0.6.0 (64 bit)");
	#else
	post("jit_gl_spout_sender - Vers 2.0.6.0 (32 bit)");
	#endif


	// initialize our Jitter class
	jit_gl_spoutsender_init();	
	
	// create our Max class
	maxclass = class_new("jit.gl.spoutsender", 
						(method)max_jit_gl_spoutsender_new,
						(method)max_jit_gl_spoutsender_free, 
						sizeof(t_max_jit_gl_spoutsender),
						NULL, A_GIMME, 0);

	// specify a byte offset to keep additional information about our object
	max_jit_class_obex_setup(maxclass, calcoffset(t_max_jit_gl_spoutsender, obex));

	// look up our Jitter class in the class registry
	jitclass = (t_class *)jit_class_findbyname(gensym("jit_gl_spoutsender"));

	// wrap our Jitter class with the standard methods for Jitter objects
	max_jit_class_wrap_standard(maxclass, jitclass, 0);
	
   	// use standard ob3d assist method
	class_addmethod(maxclass, (method)max_jit_ob3d_assist, "assist", A_CANT, 0);

	// add methods for 3d drawing
	max_jit_class_ob3d_wrap(maxclass);

	// register our class with max
	class_register(CLASS_BOX, maxclass);
	max_jit_gl_spoutsender_class = maxclass;

}