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