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;
}
void C74_EXPORT main(void)
{
void *p,*q;
setup(&max_jit_la_diagproduct_class, max_jit_la_diagproduct_new, (method)max_jit_la_diagproduct_free, (short)sizeof(t_max_jit_la_diagproduct),
0L, A_GIMME, 0);
p = max_jit_classex_setup(calcoffset(t_max_jit_la_diagproduct,obex));
q = jit_class_findbyname(gensym("jit_la_diagproduct"));
max_jit_classex_mop_wrap(p,q,MAX_JIT_MOP_FLAGS_OWN_BANG|MAX_JIT_MOP_FLAGS_OWN_OUTPUTMATRIX); //custom bang/outputmatrix
max_jit_classex_mop_mproc(p,q,max_jit_la_diagproduct_mproc); //custom mproc
max_jit_classex_standard_wrap(p,q,0);
addmess((method)max_jit_la_diagproduct_assist, "assist", A_CANT,0);
ps_getresult = gensym("getresult");
}
void ext_main(void* unused)
{
void *p,*q;
union { void **v_ptr; t_messlist **m_ptr; } alias_ptr;
alias_ptr.v_ptr = &max_cv_jit_trackpoints_class;
cv_jit_trackpoints_init();
setup(alias_ptr.m_ptr, (method)max_cv_jit_trackpoints_new, (method)max_cv_jit_trackpoints_free, (short)sizeof(t_max_cv_jit_trackpoints),
0L, A_GIMME, 0);
p = max_jit_classex_setup(calcoffset(t_max_cv_jit_trackpoints,obex));
q = jit_class_findbyname(gensym("cv_jit_trackpoints"));
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
}
int main(void){
void *p,*q;
jit_SDIF_buffer_init();
setup((t_messlist **)&max_jit_SDIF_buffer_class, (method)max_jit_SDIF_buffer_new, (method)max_jit_SDIF_buffer_free, (short)sizeof(t_max_jit_SDIF_buffer),
0L, A_GIMME, 0);
p = max_jit_classex_setup(calcoffset(t_max_jit_SDIF_buffer,obex));
q = jit_class_findbyname(gensym("jit_SDIF_buffer"));
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_SDIF_buffer_outputmatrix, "outputmatrix");
addmess((method)max_jit_mop_assist, "assist", A_CANT,0);
addfloat((method)max_jit_SDIF_buffer_float);
return 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);
}
void ext_main(void *r)
{
void *classex, *jitclass;
jit_gl_videoplane_init();
setup((t_messlist **)&max_jit_gl_videoplane_class, (method)max_jit_gl_videoplane_new, (method)max_jit_gl_videoplane_free, (short)sizeof(t_max_jit_gl_videoplane),
0L, A_GIMME, 0);
classex = max_jit_classex_setup(calcoffset(t_max_jit_gl_videoplane, obex));
jitclass = jit_class_findbyname(gensym("jit_gl_videoplane"));
max_jit_classex_standard_wrap(classex, jitclass, 0); // getattributes/dumpout/maxjitclassaddmethods/etc
addmess((method)max_jit_ob3d_assist, "assist", A_CANT,0);
// add methods for 3d drawing
max_ob3d_setup();
}
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);
}
void main(void)
{
void *p,*q;
jit_findbounds_init();
setup(&max_jit_findbounds_class, max_jit_findbounds_new, (method)max_jit_findbounds_free, (short)sizeof(t_max_jit_findbounds),
0L, A_GIMME, 0);
p = max_jit_classex_setup(calcoffset(t_max_jit_findbounds,obex));
q = jit_class_findbyname(gensym("jit_findbounds"));
max_jit_classex_mop_wrap(p,q,MAX_JIT_MOP_FLAGS_OWN_BANG|MAX_JIT_MOP_FLAGS_OWN_OUTPUTMATRIX); //custom bang/outputmatrix
max_jit_classex_mop_mproc(p,q,max_jit_findbounds_mproc); //custom mproc
max_jit_classex_standard_wrap(p,q,0);
addmess((method)max_jit_findbounds_assist, "assist", A_CANT,0);
ps_getboundmin = gensym("getboundmin");
ps_getboundmax = gensym("getboundmax");
}
int main(void)
{
void *p,*q;
union { void **v_ptr; t_messlist **m_ptr; } alias_ptr;
alias_ptr.v_ptr = &max_cv_jit_hough_class;
cv_jit_hough_init();
setup(alias_ptr.m_ptr, (method)max_cv_jit_hough_new, (method)max_cv_jit_hough_free, (short)sizeof(t_max_cv_jit_hough),
0L, A_GIMME, 0);
p = max_jit_classex_setup(calcoffset(t_max_cv_jit_hough,obex));
q = jit_class_findbyname(gensym("cv_jit_hough"));
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 jit_hello_init(void)
{
long attrflags=0;
t_jit_object *attr;
_jit_hello_class = jit_class_new("jit_hello",(method)jit_hello_new,(method)jit_hello_free,
sizeof(t_jit_hello),0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = jit_object_new(_jit_sym_jit_attr_offset,"text",_jit_sym_symbol,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_hello,text));
jit_class_addattr(_jit_hello_class,attr);
jit_class_register(_jit_hello_class);
return JIT_ERR_NONE;
}
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");
}
