t_jit_err jit_realsense_grab_init(void)
{
t_jit_object *mop;
s_jit_realsense_grab_class = jit_class_new("jit_realsense_grab", (method)jit_realsense_grab_new, (method)jit_realsense_grab_free, sizeof(t_jit_realsense_grab), 0);
// add matrix operator (mop)
mop = (t_jit_object*)jit_object_new(_jit_sym_jit_mop, 0, 1); // args are num inputs and num outputs
jit_class_addadornment(s_jit_realsense_grab_class, mop);
// add method(s)
jit_class_addmethod(s_jit_realsense_grab_class, (method)jit_realsense_grab_matrix_calc, "matrix_calc", A_CANT, 0);
// finalize class
jit_class_register(s_jit_realsense_grab_class);
return JIT_ERR_NONE;
}
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;
}
t_jit_err xray_jit_crossproduct_init(void)
{
long attrflags=0;
t_jit_object *attr,*mop;
t_symbol *atsym;
void *o;
t_atom a[2];
atsym = gensym("jit_attr_offset");
_xray_jit_crossproduct_class = jit_class_new("xray_jit_crossproduct",(method)xray_jit_crossproduct_new,(method)xray_jit_crossproduct_free,
sizeof(t_xray_jit_crossproduct),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,2,1);
jit_atom_setsym(a, _jit_sym_float32);
jit_atom_setsym(a+1, _jit_sym_float64);
o = jit_object_method(mop,_jit_sym_getinput,1);
jit_object_method(o,_jit_sym_types,2,a);
o = jit_object_method(mop,_jit_sym_getinput,2);
jit_object_method(o,_jit_sym_types,2,a);
o = jit_object_method(mop,_jit_sym_getoutput,1);
jit_object_method(o,_jit_sym_types,2,a);
jit_class_addadornment(_xray_jit_crossproduct_class,mop);
//add methods
jit_class_addmethod(_xray_jit_crossproduct_class, (method)xray_jit_crossproduct_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
//normalize
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"normalize",_jit_sym_char,2,attrflags,
(method)0L,(method)0L,calcoffset(t_xray_jit_crossproduct,normalizecount),calcoffset(t_xray_jit_crossproduct,normalize));
jit_class_addattr(_xray_jit_crossproduct_class,attr);
jit_class_register(_xray_jit_crossproduct_class);
return JIT_ERR_NONE;
}
t_jit_err jit_gl_simple_init(void)
{
long ob3d_flags = JIT_OB3D_NO_MATRIXOUTPUT; // no matrix output
void *ob3d;
_jit_gl_simple_class = jit_class_new("jit_gl_simple",
(method)jit_gl_simple_new, (method)jit_gl_simple_free,
sizeof(t_jit_gl_simple),A_DEFSYM,0L);
// set up object extension for 3d object, customized with flags
ob3d = jit_ob3d_setup(_jit_gl_simple_class,
calcoffset(t_jit_gl_simple, ob3d),
ob3d_flags);
// define our OB3D draw method. called in automatic mode by
// jit.gl.render or otherwise through ob3d when banged. this
// method is A_CANT because our draw setup needs to happen
// in the ob3d beforehand to initialize OpenGL state
jit_class_addmethod(_jit_gl_simple_class,
(method)jit_gl_simple_draw, "ob3d_draw", A_CANT, 0L);
// define our dest_closing and dest_changed methods.
// these methods are called by jit.gl.render when the
// destination context closes or changes: for example, when
// the user moves the window from one monitor to another. Any
// resources your object keeps in the OpenGL machine
// (e.g. textures, display lists, vertex shaders, etc.)
// will need to be freed when closing, and rebuilt when it has
// changed. In this object, these functions do nothing, and
// could be omitted.
jit_class_addmethod(_jit_gl_simple_class,
(method)jit_gl_simple_dest_closing, "dest_closing", A_CANT, 0L);
jit_class_addmethod(_jit_gl_simple_class,
(method)jit_gl_simple_dest_changed, "dest_changed", A_CANT, 0L);
// must register for ob3d use
jit_class_addmethod(_jit_gl_simple_class,
(method)jit_object_register, "register", A_CANT, 0L);
jit_class_register(_jit_gl_simple_class);
return JIT_ERR_NONE;
}
t_jit_err jit_alphablend_init(void)
{
long attrflags=0;
t_jit_object *attr,*mop,*o;
t_symbol *atsym;
t_atom a[3];
atsym = gensym("jit_attr_offset");
_jit_alphablend_class = jit_class_new("jit_alphablend",(method)jit_alphablend_new,(method)jit_alphablend_free,
sizeof(t_jit_alphablend),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,2,1);
// jit_mop_single_planecount(mop,4);
jit_atom_setsym(a,_jit_sym_char);
jit_atom_setsym(a+1,_jit_sym_float32);
jit_atom_setsym(a+2,_jit_sym_float64);
o = jit_object_method(mop,_jit_sym_getinput,2);
jit_object_method(o,_jit_sym_types,3,a);
o = jit_object_method(mop,_jit_sym_getoutput,1);
jit_object_method(o,_jit_sym_types,3,a);
jit_class_addadornment(_jit_alphablend_class,mop);
//add methods
jit_class_addmethod(_jit_alphablend_class, (method)jit_alphablend_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = jit_object_new(atsym,"mode",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_alphablend,mode));
jit_class_addattr(_jit_alphablend_class,attr);
CLASS_ATTR_BASIC(_jit_alphablend_class,"mode",0);
CLASS_ATTR_LABEL(_jit_alphablend_class,"mode",0,"Crossfade Mode");
CLASS_ATTR_ENUMINDEX2(_jit_alphablend_class, "mode", 0, "Left-to-Right", "Right-to-Left");
CLASS_ATTR_CATEGORY(_jit_alphablend_class, "mode", 0, "Mode");
jit_class_register(_jit_alphablend_class);
return JIT_ERR_NONE;
}
t_jit_err jit_dimmap_init(void)
{
long attrflags=0;
t_jit_object *attr,*mop,*o;
t_symbol *atsym;
atsym = gensym("jit_attr_offset");
_jit_dimmap_class = jit_class_new("jit_dimmap",(method)jit_dimmap_new,(method)jit_dimmap_free,
sizeof(t_jit_dimmap),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,1,1);
jit_mop_output_nolink(mop,1);
jit_class_addadornment(_jit_dimmap_class,mop);
o = jit_object_method(mop,_jit_sym_getoutput,1);
//add methods
jit_class_addmethod(_jit_dimmap_class, (method)jit_dimmap_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
CLASS_STICKY_ATTR(_jit_dimmap_class,"category",0,"Behavior");
CLASS_STICKY_ATTR(_jit_dimmap_class,"basic",0,"1");
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"map",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
(method)0L,(method)jit_dimmap_map,calcoffset(t_jit_dimmap,mapcount),calcoffset(t_jit_dimmap,map));
jit_class_addattr(_jit_dimmap_class,attr);
CLASS_ATTR_LABEL(_jit_dimmap_class,"map",0,"Dimension Map");
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"invert",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_dimmap,invertcount),calcoffset(t_jit_dimmap,invert));
jit_class_addattr(_jit_dimmap_class,attr);
CLASS_ATTR_LABEL(_jit_dimmap_class,"invert",0,"Dimension Invert");
CLASS_STICKY_ATTR_CLEAR(_jit_dimmap_class, "basic");
CLASS_STICKY_ATTR_CLEAR(_jit_dimmap_class, "category");
jit_class_register(_jit_dimmap_class);
return JIT_ERR_NONE;
}
t_jit_err jit_gradient_init(void)
{
long attrflags=0;
t_jit_object *attr;
t_jit_object *mop;
_jit_gradient_class = jit_class_new("jit_gradient",(method)jit_gradient_new,(method)jit_gradient_free,
sizeof(t_jit_gradient),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,1,1);
jit_mop_single_type(mop, _jit_sym_char);
jit_mop_single_planecount(mop, 4);
jit_class_addadornment(_jit_gradient_class,mop);
//add methods
jit_class_addmethod(_jit_gradient_class, (method)jit_gradient_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
// start - beginning gradient cell
attr = jit_object_new(_jit_sym_jit_attr_offset_array, "start", _jit_sym_float64, 4,
attrflags, (method)0L, (method)0L, calcoffset(t_jit_gradient, startcount),
calcoffset(t_jit_gradient,start));
jit_class_addattr(_jit_gradient_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset_array, "end", _jit_sym_float64, 4,
attrflags, (method)0L, (method)0L, calcoffset(t_jit_gradient, endcount),
calcoffset(t_jit_gradient,end));
jit_class_addattr(_jit_gradient_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset_array, "cheby", _jit_sym_float64, 64,
attrflags, (method)0L, (method)0L, calcoffset(t_jit_gradient, chebycount),
calcoffset(t_jit_gradient,cheby));
jit_class_addattr(_jit_gradient_class,attr);
jit_class_register(_jit_gradient_class);
return JIT_ERR_NONE;
}
t_jit_err jit_tml_vp8_encode_init(void)
{
long attrflags=0;
t_jit_object *attr;
t_jit_object *mop, *o;
//Create class with given constructors & destructors
_jit_tml_vp8_encode_class = jit_class_new("jit_tml_vp8_encode",(method)jit_tml_vp8_encode_new,(method)jit_tml_vp8_encode_free,
sizeof(t_jit_tml_vp8_encode),A_CANT,0L); //A_CANT = untyped
// 0 matrix input / 4 matrix output
mop = (t_jit_object*)jit_object_new(_jit_sym_jit_mop,1,1);
// need this for getting correct matrix_info from 2nd input matrix.... (see jit.concat.c...)
//jit_mop_input_nolink(mop,2);
// o= (t_jit_object*)jit_object_method(mop,_jit_sym_getinput,2);
//jit_object_method(o,_jit_sym_ioproc,jit_mop_ioproc_copy_adapt);
jit_class_addadornment(_jit_tml_vp8_encode_class,mop);
// add methods
jit_class_addmethod(_jit_tml_vp8_encode_class, (method)jit_tml_vp8_encode_matrix_calc, "matrix_calc", A_CANT, 0L);
jit_class_addmethod(_jit_tml_vp8_encode_class, (method)jit_tml_vp8_encode_open, "open", A_DEFLONG, 0L);
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset, "kilobitrate", _jit_sym_long,
attrflags, (method)0L,
(method)jit_tml_vp8_encode_setBitrate,
calcoffset(t_jit_tml_vp8_encode, bitRate));
jit_class_addattr(_jit_tml_vp8_encode_class, attr);
//Done!
jit_class_register(_jit_tml_vp8_encode_class);
return JIT_ERR_NONE;
}
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;
}
t_jit_err cv_jit_blobs_centroids_init(void)
{
t_jit_object *mop,*output;
t_symbol *atsym;
atsym = gensym("jit_attr_offset");
_cv_jit_blobs_centroids_class = jit_class_new("cv_jit_blobs_centroids",(method)cv_jit_blobs_centroids_new,(method)cv_jit_blobs_centroids_free,
sizeof(t_cv_jit_blobs_centroids),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,1,1); //Object has one input and one output
output = jit_object_method(mop,_jit_sym_getoutput,1); //Get a pointer to the output matrix
jit_mop_single_type(mop,_jit_sym_char); //Set input type and planecount
jit_mop_single_planecount(mop,1);
jit_mop_output_nolink(mop,1); //Turn off output linking so that output matrix does not adapt to input
jit_attr_setlong(output,_jit_sym_minplanecount,3); //Output has 3 planes: centroid coordinates + mass
jit_attr_setlong(output,_jit_sym_maxplanecount,3);
jit_attr_setlong(output,_jit_sym_mindim,1);
jit_attr_setlong(output,_jit_sym_maxdim,1);
jit_attr_setsym(output,_jit_sym_types,_jit_sym_float32);
jit_class_addadornment(_cv_jit_blobs_centroids_class,mop);
//add methods
jit_class_addmethod(_cv_jit_blobs_centroids_class, (method)cv_jit_blobs_centroids_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
/*No attributes for this object*/
jit_class_register(_cv_jit_blobs_centroids_class);
return JIT_ERR_NONE;
}
t_jit_err xray_jit_cumsum_init(void)
{
long attrflags=0;
t_jit_object *attr,*mop,*o;
t_symbol *atsym;
t_atom a[1];
atsym = gensym("jit_attr_offset");
_xray_jit_cumsum_class = jit_class_new("xray_jit_cumsum",(method)xray_jit_cumsum_new,(method)xray_jit_cumsum_free,
sizeof(t_xray_jit_cumsum),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop, 1, 1);
jit_atom_setsym(a, _jit_sym_float32);
o = jit_object_method(mop,_jit_sym_getinput,1);
jit_object_method(o,_jit_sym_types,1,a);
o = jit_object_method(mop,_jit_sym_getoutput,1);
jit_object_method(o,_jit_sym_types,1,a);
jit_class_addadornment(_xray_jit_cumsum_class,mop);
//add methods
jit_class_addmethod(_xray_jit_cumsum_class, (method)xray_jit_cumsum_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
//dimmode
attr = jit_object_new(atsym,"dimmode",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_xray_jit_cumsum,dimmode));
jit_class_addattr(_xray_jit_cumsum_class,attr);
jit_class_register(_xray_jit_cumsum_class);
return JIT_ERR_NONE;
}
t_jit_err xray_jit_colormap_init(void)
{
long attrflags=0;
t_jit_object *attr,*mop,*o;
t_symbol *atsym;
t_atom a[2];
atsym = gensym("jit_attr_offset");
_xray_jit_colormap_class = jit_class_new("xray_jit_colormap",(method)xray_jit_colormap_new,(method)xray_jit_colormap_free,
sizeof(t_xray_jit_colormap),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,1,1);
jit_mop_single_planecount(mop,1);
jit_atom_setsym(a,_jit_sym_char);
jit_atom_setsym(a+1,_jit_sym_long);
o = jit_object_method(mop,_jit_sym_getoutput,1);
jit_object_method(o,_jit_sym_types,2,a);
jit_class_addadornment(_xray_jit_colormap_class,mop);
//add methods
jit_class_addmethod(_xray_jit_colormap_class, (method)xray_jit_colormap_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
//mode
attr = jit_object_new(atsym,"mode",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_xray_jit_colormap,mode));
jit_class_addattr(_xray_jit_colormap_class,attr);
jit_class_register(_xray_jit_colormap_class);
return JIT_ERR_NONE;
}
t_jit_err StencilClassInit(void)
{
long attrflags = 0;// = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
t_jit_object *attr;
t_jit_object *mop;
sStencilClass = (ClassPtr)jit_class_new((char*)"jcom_stencil", (method)StencilNew, (method)StencilFree, sizeof(StencilObject), 0);
// add matrix operator (mop)
mop = (t_jit_object*)jit_object_new(_jit_sym_jit_mop, 1, 1); // args are num inputs and num outputs
jit_class_addadornment(sStencilClass, mop);
// add method(s)
jit_class_addmethod(sStencilClass, (method)StencilMatrixCalc, (char*)"matrix_calc", A_CANT, 0);
// add attribute(s)
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset_array,
"stepSize",
_jit_sym_long,
JIT_MATRIX_MAX_PLANECOUNT,
attrflags,
(method)StencilGetStepSize, (method)StencilSetStepSize,
NULL, NULL);
jit_class_addattr(sStencilClass, attr);
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset,
"edges",
_jit_sym_symbol,
attrflags,
(method)StencilGetEdges, (method)StencilSetEdges,
NULL);
jit_class_addattr(sStencilClass, attr);
// finalize class
jit_class_register(sStencilClass);
return JIT_ERR_NONE;
}
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;
}
t_jit_err jit_thin_init(void)
{
long attrflags=0;
t_jit_object *attr,*mop,*o;
t_symbol *atsym;
atsym = gensym("jit_attr_offset");
_jit_thin_class = jit_class_new("jit_thin",(method)jit_thin_new,(method)jit_thin_free,
sizeof(t_jit_thin),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,1,1);
jit_mop_output_nolink(mop,1);
jit_class_addadornment(_jit_thin_class,mop);
o = jit_object_method(mop,_jit_sym_getoutput,1);
//add methods
jit_class_addmethod(_jit_thin_class, (method)jit_thin_matrix_calc, "matrix_calc", A_CANT, 0L);
jit_class_register(_jit_thin_class);
return JIT_ERR_NONE;
}
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;
}
t_jit_err jit_charmap_init(void)
{
t_atom a;
void *o,*mop;
_jit_charmap_class = jit_class_new("jit_charmap",(method)jit_charmap_new,(method)jit_charmap_free,
sizeof(t_jit_charmap),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,2,1);
jit_mop_single_type(mop,_jit_sym_char);
o = jit_object_method(mop,_jit_sym_getinput,2);
jit_attr_setlong(o,_jit_sym_dimlink,0);
jit_atom_setlong(&a,256);
jit_object_method(o,_jit_sym_mindim,1,&a);
jit_object_method(o,_jit_sym_maxdim,1,&a);
jit_class_addadornment(_jit_charmap_class,mop);
//add methods
jit_class_addmethod(_jit_charmap_class, (method)jit_charmap_matrix_calc, "matrix_calc", A_CANT, 0L);
jit_class_register(_jit_charmap_class);
return JIT_ERR_NONE;
}
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;
}
t_jit_err jit_pcl_concavehull_init(void)
{
long attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
t_jit_object *attr;
t_jit_object *mop;
t_atom a[1];
s_jit_pcl_concavehull_class = jit_class_new("jit_pcl_concavehull", (method)jit_pcl_concavehull_new, (method)jit_pcl_concavehull_free, sizeof(t_jit_pcl_concavehull), 0);
// add matrix operator (mop)
// args are num inputs and num outputs
mop = (t_jit_object *)jit_object_new(_jit_sym_jit_mop, 1, 1);
jit_mop_input_nolink(mop,1);
attr = (t_jit_object *)jit_object_method(mop, _jit_sym_getinput, 1);
jit_attr_setlong(attr,_jit_sym_dimlink,0);
jit_attr_setlong(attr,_jit_sym_typelink,0);
jit_attr_setlong(attr,_jit_sym_planelink,0);
jit_object_method(attr,_jit_sym_ioproc,jit_mop_ioproc_copy_adapt);
jit_atom_setsym(a, _jit_sym_float32);
jit_object_method(attr, _jit_sym_types,1, a);
attr = (t_jit_object *)jit_object_method(mop, _jit_sym_getoutput, 1);
jit_attr_setlong(attr, _jit_sym_dimlink,0);
jit_class_addadornment(s_jit_pcl_concavehull_class, mop);
// add method(s)
jit_class_addmethod(s_jit_pcl_concavehull_class, (method)jit_pcl_concavehull_matrix_calc, "matrix_calc", A_CANT, 0);
// add attribute(s)
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,
"leafsize",
_jit_sym_float64,
attrflags,
(method)NULL, (method)NULL,
calcoffset(t_jit_pcl_concavehull, leafsize));
jit_class_addattr(s_jit_pcl_concavehull_class, attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,
"npoints",
_jit_sym_long,
attrflags,
(method)NULL, (method)NULL,
calcoffset(t_jit_pcl_concavehull, npoints));
jit_attr_addfilterget_clip(attr, 1, 10000, true, false);
jit_class_addattr(s_jit_pcl_concavehull_class, attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,
"stdthresh",
_jit_sym_float64,
attrflags,
(method)NULL, (method)NULL,
calcoffset(t_jit_pcl_concavehull, stdthresh));
jit_class_addattr(s_jit_pcl_concavehull_class, attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,
"alpha",
_jit_sym_float64,
attrflags,
(method)NULL, (method)NULL,
calcoffset(t_jit_pcl_concavehull, alpha));
jit_class_addattr(s_jit_pcl_concavehull_class, attr);
// finalize class
jit_class_register(s_jit_pcl_concavehull_class);
return JIT_ERR_NONE;
}
t_jit_err xray_jit_levelsetseg_init(void)
{
long attrflags=0;
t_jit_object *attr,*mop,*o;
t_symbol *atsym;
atsym = gensym("jit_attr_offset");
_xray_jit_levelsetseg_class = jit_class_new("xray_jit_levelsetseg",(method)xray_jit_levelsetseg_new,(method)xray_jit_levelsetseg_free,
sizeof(t_xray_jit_levelsetseg),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,1,2);
o = jit_object_method(mop,_jit_sym_getoutput,1);
jit_attr_setlong(o,_jit_sym_dimlink,0);
jit_attr_setlong(o,_jit_sym_planelink,0);
jit_class_addadornment(_xray_jit_levelsetseg_class,mop);
//add methods
jit_class_addmethod(_xray_jit_levelsetseg_class, (method)xray_jit_levelsetseg_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
//evolve
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset,"evolve",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_xray_jit_levelsetseg, evolve));
jit_class_addattr(_xray_jit_levelsetseg_class,attr);
//smooth
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset,"smooth",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_xray_jit_levelsetseg, smooth));
jit_class_addattr(_xray_jit_levelsetseg_class,attr);
//radius
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset,"radius",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_xray_jit_levelsetseg, radius));
jit_class_addattr(_xray_jit_levelsetseg_class,attr);
//point
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset_array,"point",_jit_sym_long,6,attrflags,
(method)0L,(method)xray_jit_levelsetseg_point,calcoffset(t_xray_jit_levelsetseg,pointcount),calcoffset(t_xray_jit_levelsetseg,point));
jit_class_addattr(_xray_jit_levelsetseg_class,attr);
//Na
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset,"Na",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_xray_jit_levelsetseg,Na));
jit_class_addattr(_xray_jit_levelsetseg_class,attr);
//Ng
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset,"Ng",_jit_sym_long,attrflags,
(method)0L,(method)xray_jit_levelsetseg_Ng,calcoffset(t_xray_jit_levelsetseg,Ng));
jit_class_addattr(_xray_jit_levelsetseg_class,attr);
//Ns
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset,"Ns",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_xray_jit_levelsetseg,Ns));
jit_class_addattr(_xray_jit_levelsetseg_class,attr);
//cycles
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset,"cycles",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_xray_jit_levelsetseg,cycles));
jit_class_addattr(_xray_jit_levelsetseg_class,attr);
jit_class_register(_xray_jit_levelsetseg_class);
return JIT_ERR_NONE;
}
t_jit_err cv_jit_shift_init(void)
{
long attrflags=0;
t_jit_object *attr,*mop;
t_symbol *atsym;
atsym = gensym("jit_attr_offset");
_cv_jit_shift_class = jit_class_new("cv_jit_shift",(method)cv_jit_shift_new,(method)cv_jit_shift_free,
sizeof(t_cv_jit_shift),0L);
//add mop
mop = (t_jit_object *)jit_object_new(_jit_sym_jit_mop,1,0); //Object has one input and no Jitter output
jit_mop_single_type(mop,_jit_sym_char); //Set input type and planecount
jit_mop_single_planecount(mop,1);
jit_class_addadornment(_cv_jit_shift_class,mop);
//add methods
jit_class_addmethod(_cv_jit_shift_class, (method)cv_jit_shift_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_SET_OPAQUE_USER | JIT_ATTR_GET_OPAQUE_USER;
//box: the resulting bounding rectangle, passed to the Max wrapper
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset_array,"box",_jit_sym_atom,4,attrflags,
(method)0L,(method)0L,calcoffset(t_cv_jit_shift,boxcount),calcoffset(t_cv_jit_shift,box));
jit_class_addattr(_cv_jit_shift_class,attr);
//vertices: the rotated frame that bounds the object
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset_array,"vertices",_jit_sym_atom,4,attrflags,
(method)0L,(method)0L,calcoffset(t_cv_jit_shift,framecount),calcoffset(t_cv_jit_shift,frame));
jit_class_addattr(_cv_jit_shift_class,attr);
//Mass: the area's mass
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"mass",_jit_sym_float32,attrflags,
(method)0L,(method)0L,calcoffset(t_cv_jit_shift,mass));
jit_class_addattr(_cv_jit_shift_class,attr);
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
//rect: the start bounding rectangle
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset_array,"rect",_jit_sym_long,4,attrflags,
(method)0L,(method)0L,calcoffset(t_cv_jit_shift,rectcount),calcoffset(t_cv_jit_shift,rect));
jit_class_addattr(_cv_jit_shift_class,attr);
//Maximum number of iterations
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"maxiters",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_cv_jit_shift,maxiters));
jit_class_addattr(_cv_jit_shift_class,attr);
//The minimum displacement
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"distance",_jit_sym_float64,attrflags,
(method)0L,(method)0L,calcoffset(t_cv_jit_shift,epsilon));
jit_class_addattr(_cv_jit_shift_class,attr);
//The mode, 0: meanshift -- 1: camshift
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"mode",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_cv_jit_shift,mode));
jit_attr_addfilterset_clip(attr,0,1,TRUE,TRUE);
jit_class_addattr(_cv_jit_shift_class,attr);
jit_class_register(_cv_jit_shift_class);
return JIT_ERR_NONE;
}
t_jit_err jit_openlase_trace_init(void)
{
long attrflags=0;
t_jit_object *attr, *mop;
_jit_openlase_trace_class = jit_class_new("jit_openlase_trace",(method)jit_openlase_trace_new,(method)jit_openlase_trace_free,
sizeof(t_jit_openlase_trace),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,1,0);
jit_class_addadornment(_jit_openlase_trace_class, mop);
//add methods
jit_class_addmethod(_jit_openlase_trace_class, (method)jit_openlase_trace_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
CLASS_STICKY_ATTR(_jit_openlase_trace_class,"category",0,"Laser");
CLASS_STICKY_ATTR(_jit_openlase_trace_class,"basic",0,"1");
attr = jit_object_new(_jit_sym_jit_attr_offset, "rate", _jit_sym_long, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, params.rate));
jit_class_addattr(_jit_openlase_trace_class,attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "rate", 0, "rate: Speed of Laser Scanner (Hz)");
attr = jit_object_new(_jit_sym_jit_attr_offset, "on_speed", _jit_sym_float32, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, params.on_speed));
jit_class_addattr(_jit_openlase_trace_class,attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "on_speed", 0, "");
attr = jit_object_new(_jit_sym_jit_attr_offset, "off_speed", _jit_sym_float32, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, params.off_speed));
jit_class_addattr(_jit_openlase_trace_class,attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "off_speed", 0, "");
attr = jit_object_new(_jit_sym_jit_attr_offset, "start_wait", _jit_sym_long, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, params.start_wait));
jit_class_addattr(_jit_openlase_trace_class,attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "start_wait", 0, "");
attr = jit_object_new(_jit_sym_jit_attr_offset, "end_wait", _jit_sym_long, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, params.end_wait));
jit_class_addattr(_jit_openlase_trace_class, attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "end_wait", 0, "");
attr = jit_object_new(_jit_sym_jit_attr_offset, "start_dwell", _jit_sym_long, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, params.start_dwell));
jit_class_addattr(_jit_openlase_trace_class, attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "start_dwell", 0, "");
attr = jit_object_new(_jit_sym_jit_attr_offset, "end_dwell", _jit_sym_long, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, params.end_dwell));
jit_class_addattr(_jit_openlase_trace_class, attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "end_dwell", 0, "");
attr = jit_object_new(_jit_sym_jit_attr_offset, "corner_dwell", _jit_sym_long, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, params.corner_dwell));
jit_class_addattr(_jit_openlase_trace_class, attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "corner_dwell", 0, "");
attr = jit_object_new(_jit_sym_jit_attr_offset, "min_length", _jit_sym_long, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, params.min_length));
jit_class_addattr(_jit_openlase_trace_class, attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "min_length", 0, "");
attr = jit_object_new(_jit_sym_jit_attr_offset, "overscan", _jit_sym_float32, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, overscan));
jit_class_addattr(_jit_openlase_trace_class, attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "overscan", 0, "");
attr = jit_object_new(_jit_sym_jit_attr_offset, "aspect", _jit_sym_float32, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, aspect));
jit_class_addattr(_jit_openlase_trace_class, attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "aspect", 0, "");
attr = jit_object_new(_jit_sym_jit_attr_offset, "decimate", _jit_sym_long, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, decimate));
jit_class_addattr(_jit_openlase_trace_class, attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "decimate", 0, "");
attr = jit_object_new(_jit_sym_jit_attr_offset, "snap_pix", _jit_sym_long, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_openlase_trace, snap_pix));
jit_class_addattr(_jit_openlase_trace_class, attr);
CLASS_ATTR_LABEL(_jit_openlase_trace_class, "snap_pix", 0, "");
CLASS_STICKY_ATTR_CLEAR(_jit_openlase_trace_class, "category");
CLASS_STICKY_ATTR_CLEAR(_jit_openlase_trace_class, "basic");
jit_class_register(_jit_openlase_trace_class);
return JIT_ERR_NONE;
}
t_jit_err jit_gl_hap_init(void)
{
void *ob3d;
void *attr;
long attrflags=0;
long ob3d_flags = JIT_OB3D_NO_ROTATION_SCALE;
ob3d_flags |= JIT_OB3D_NO_POLY_VARS;
ob3d_flags |= JIT_OB3D_NO_BLEND;
ob3d_flags |= JIT_OB3D_NO_TEXTURE;
ob3d_flags |= JIT_OB3D_NO_MATRIXOUTPUT;
ob3d_flags |= JIT_OB3D_AUTO_ONLY;
ob3d_flags |= JIT_OB3D_NO_DEPTH;
ob3d_flags |= JIT_OB3D_NO_ANTIALIAS;
ob3d_flags |= JIT_OB3D_NO_FOG;
ob3d_flags |= JIT_OB3D_NO_LIGHTING_MATERIAL;
ob3d_flags |= JIT_OB3D_NO_SHADER;
ob3d_flags |= JIT_OB3D_NO_BOUNDS;
ob3d_flags |= JIT_OB3D_NO_COLOR;
_jit_gl_hap_class = jit_class_new("jit_gl_hap",
(method)jit_gl_hap_new, (method)jit_gl_hap_free,
sizeof(t_jit_gl_hap),A_DEFSYM,0L);
ob3d = jit_ob3d_setup(_jit_gl_hap_class, calcoffset(t_jit_gl_hap, ob3d), ob3d_flags);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_draw, "ob3d_draw", A_CANT, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_dest_closing, "dest_closing", A_CANT, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_dest_changed, "dest_changed", A_CANT, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_object_register, "register", A_CANT, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_read, "read", A_GIMME, 0);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_sendoutput, "sendoutput", A_DEFER_LOW, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_dispose, "dispose", A_USURP_LOW, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_start, "start", A_DEFER_LOW, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_stop, "stop", A_DEFER_LOW, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_jump, "jump", A_DEFER_LOW, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_frame, "frame", A_DEFER_LOW, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_clear_looppoints, "clear_looppoints", A_DEFER_LOW, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_loadram, "loadram", A_DEFER_LOW, 0L);
jit_class_addmethod(_jit_gl_hap_class, (method)jit_gl_hap_loadram, "unloadram",A_DEFER_LOW, 0L);
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
//attr = jit_object_new(_jit_sym_jit_attr_offset,"adapt",_jit_sym_char,attrflags,
// (method)0L,(method)0L,calcoffset(t_jit_gl_hap,adapt));
//jit_class_addattr(_jit_gl_hap_class,attr);
//object_addattr_parse(attr,"style",_jit_sym_symbol,0,"onoff");
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"dim",_jit_sym_long,2,attrflags,
(method)0L,(method)0L,0,calcoffset(t_jit_gl_hap,dim));
jit_class_addattr(_jit_gl_hap_class,attr);
//attr = jit_object_new(_jit_sym_jit_attr_offset_array,"rect",_jit_sym_float32,4,attrflags,
// (method)0L,(method)0L,0,calcoffset(t_jit_gl_hap,rect));
//jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"time",_jit_sym_long,attrflags,
(method)jit_gl_hap_time_get,(method)jit_gl_hap_time_set,0L);
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"loop",_jit_sym_char,attrflags,
(method)0L,(method)jit_gl_hap_loop_set,calcoffset(t_jit_gl_hap,loop));
jit_class_addattr(_jit_gl_hap_class,attr);
object_addattr_parse(attr,"style",_jit_sym_symbol,0,"enumindex");
object_addattr_parse(attr,"enumvals",_jit_sym_atom,0,"off normal palindrome playback-limits");
attr = jit_object_new(_jit_sym_jit_attr_offset,"autostart",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_gl_hap,autostart));
jit_class_addattr(_jit_gl_hap_class,attr);
object_addattr_parse(attr,"style",_jit_sym_symbol,0,"onoff");
attr = jit_object_new(_jit_sym_jit_attr_offset,"rate",_jit_sym_float32,attrflags,
(method)0L,(method)jit_gl_hap_rate_set,calcoffset(t_jit_gl_hap,rate));
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"vol",_jit_sym_float32,attrflags,
(method)0L,(method)jit_gl_hap_vol_set,calcoffset(t_jit_gl_hap,vol));
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"rate_preserves_pitch",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_gl_hap,rate_preserves_pitch));
jit_class_addattr(_jit_gl_hap_class,attr);
object_addattr_parse(attr,"style",_jit_sym_symbol,0,"onoff");
attr = jit_object_new(_jit_sym_jit_attr_offset,"loopstart",_jit_sym_long,attrflags,
(method)0L,(method)jit_gl_hap_loopstart,calcoffset(t_jit_gl_hap,looppoints[0]));
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"loopend",_jit_sym_long,attrflags,
(method)0L,(method)jit_gl_hap_loopend,calcoffset(t_jit_gl_hap,looppoints[1]));
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"looppoints",_jit_sym_long,2,attrflags,
(method)0L,(method)jit_gl_hap_looppoints,0,calcoffset(t_jit_gl_hap,looppoints));
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"loopreport",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_gl_hap,loopreport));
jit_class_addattr(_jit_gl_hap_class,attr);
object_addattr_parse(attr,"style",_jit_sym_symbol,0,"onoff");
attr = jit_object_new(_jit_sym_jit_attr_offset,"framereport",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_gl_hap, framereport));
jit_class_addattr(_jit_gl_hap_class,attr);
object_addattr_parse(attr,"style",_jit_sym_symbol,0,"onoff");
attr = jit_object_new(_jit_sym_jit_attr_offset,"out_name",_jit_sym_symbol, attrflags,
(method)jit_gl_hap_getattr_out_name,(method)jit_gl_hap_setattr_out_name,0);
jit_class_addattr(_jit_gl_hap_class,attr);
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_OPAQUE_USER;
attr = jit_object_new(_jit_sym_jit_attr_offset,"fps",_jit_sym_float32,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_gl_hap,fps));
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"duration",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_gl_hap,duration));
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"timescale",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_gl_hap,timescale));
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"framecount",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_gl_hap,framecount));
jit_class_addattr(_jit_gl_hap_class,attr);
// hide default ob3d attrs that aren't used
attrflags = JIT_ATTR_GET_OPAQUE_USER | JIT_ATTR_SET_OPAQUE_USER;
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"position",_jit_sym_float32,3,attrflags,
(method)0L,(method)0L,0,0);
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"anchor",_jit_sym_float32,3,attrflags,
(method)0L,(method)0L,0,0);
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"anim",_jit_sym_symbol, attrflags,
(method)0L,(method)0L,0);
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"animmode",_jit_sym_symbol, attrflags,
(method)0L,(method)0L,0);
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"filterclass",_jit_sym_symbol, attrflags,
(method)0L,(method)0L,0);
jit_class_addattr(_jit_gl_hap_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"layer",_jit_sym_long,attrflags,
(method)0L,(method)0L,0L);
jit_class_addattr(_jit_gl_hap_class,attr);
jit_class_register(_jit_gl_hap_class);
ps_bind = gensym("bind");
ps_unbind = gensym("unbind");
ps_width = gensym("width");
ps_height = gensym("height");
ps_glid = gensym("glid");
ps_draw = gensym("draw");
return JIT_ERR_NONE;
}
t_jit_err jit_tml_constellations_init(void)
{
long attrflags=0;
t_jit_object *attr;
t_jit_object *mop, *o;
//Create class with given constructors & destructors
_jit_tml_constellations_class = jit_class_new("jit_tml_constellations",(method)jit_tml_constellations_new,(method)jit_tml_constellations_free,
sizeof(t_jit_tml_constellations),A_CANT,0L); //A_CANT = untyped
// 2 matrix input / 3 matrix output
mop = (t_jit_object*)jit_object_new(_jit_sym_jit_mop,2,3);
// need this for getting correct matrix_info from 2nd input matrix.... (see jit.concat.c...)
jit_mop_input_nolink(mop,2);
o= (t_jit_object*)jit_object_method(mop,_jit_sym_getinput,2);
jit_object_method(o,_jit_sym_ioproc,jit_mop_ioproc_copy_adapt);
jit_class_addadornment(_jit_tml_constellations_class,mop);
// add methods
jit_class_addmethod(_jit_tml_constellations_class, (method)jit_tml_constellations_matrix_calc, "matrix_calc", A_CANT, 0L);
// Add attribute -- invert (0 or 1) - go from white/black to black/white
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset, "invert", _jit_sym_long,
attrflags, (method)0L,
(method)jit_tml_constellations_setInvert,
calcoffset(t_jit_tml_constellations, invert));
jit_class_addattr(_jit_tml_constellations_class, attr);
// Add attribute -- minimum blob size (since blobs get huge)
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset, "minBlobSize", _jit_sym_long,
attrflags, (method)0L,
(method)jit_tml_constellations_setMinBlobSize,
calcoffset(t_jit_tml_constellations, minBlobSize));
jit_class_addattr(_jit_tml_constellations_class, attr);
// Add attribute -- threshold (error)
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset, "threshold", _jit_sym_long,
attrflags, (method)0L,
(method)jit_tml_constellations_setThreshold,
calcoffset(t_jit_tml_constellations, threshold));
jit_class_addattr(_jit_tml_constellations_class, attr);
// Add attribute -- threshold on the movement
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset, "movementThreshold", _jit_sym_long,
attrflags, (method)0L,
(method)jit_tml_constellations_setMovementThreshold,
calcoffset(t_jit_tml_constellations, movementThreshold));
jit_class_addattr(_jit_tml_constellations_class, attr);
// Add attribute -- rate of learning (how many frames until stability?)
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset, "learnRate", _jit_sym_long,
attrflags, (method)0L,
(method)jit_tml_constellations_setLearnRate,
calcoffset(t_jit_tml_constellations, learnRate));
jit_class_addattr(_jit_tml_constellations_class, attr);
// Add attribute -- ptCount - the number of points to use for outline.
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset, "ptCount", _jit_sym_long,
attrflags, (method)0L,
(method)jit_tml_constellations_setPtCount,
calcoffset(t_jit_tml_constellations, ptCount));
jit_class_addattr(_jit_tml_constellations_class, attr);
// Add attribute -- grays (error)
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset, "radius", _jit_sym_long,
attrflags, (method)0L,
(method)jit_tml_constellations_setRadius,
calcoffset(t_jit_tml_constellations, radius));
jit_class_addattr(_jit_tml_constellations_class, attr);
//Done!
jit_class_register(_jit_tml_constellations_class);
return JIT_ERR_NONE;
}
t_jit_err jit_freenect_grab_init(void)
{
long attrflags=0;
t_jit_object *attr;
t_jit_object *mop,*output;
t_atom a[4];
global_id=0;
x_systhread = NULL;
x_systhread_cancel=FALSE;
freenect_active=FALSE;
open_device_count=0;
s_rgb = gensym("rgb");
s_RGB = gensym("RGB");
s_ir = gensym("ir");
s_IR = gensym("IR");
_jit_freenect_grab_class = jit_class_new("jit_freenect_grab",(method)jit_freenect_grab_new,
(method)jit_freenect_grab_free, sizeof(t_jit_freenect_grab),0L);
//add mop
mop = (t_jit_object *)jit_object_new(_jit_sym_jit_mop,0,2); //0 inputs, 2 outputs
//Prepare depth image, all values are hard-coded, may need to be queried for safety?
output = jit_object_method(mop,_jit_sym_getoutput,1);
jit_atom_setsym(a,_jit_sym_float32); //default
jit_atom_setsym(a+1,_jit_sym_long);
jit_atom_setsym(a+2,_jit_sym_float64);
jit_object_method(output,_jit_sym_types,3,a);
jit_atom_setlong(&a[0], DEPTH_WIDTH);
jit_atom_setlong(&a[1], DEPTH_HEIGHT);
jit_object_method(output, _jit_sym_mindim, 2, a); //Two dimensions, sizes in atom array
jit_object_method(output, _jit_sym_maxdim, 2, a);
//Prepare RGB image
output = jit_object_method(mop,_jit_sym_getoutput,2);
jit_atom_setsym(a,_jit_sym_char); //default
jit_object_method(output,_jit_sym_types,1,a);
jit_attr_setlong(output,_jit_sym_minplanecount,4);
jit_attr_setlong(output,_jit_sym_maxplanecount,4);
jit_atom_setlong(&a[0], RGB_WIDTH);
jit_atom_setlong(&a[1], RGB_HEIGHT);
jit_object_method(output, _jit_sym_mindim, 2, a);
jit_object_method(output, _jit_sym_maxdim, 2, a);
jit_class_addadornment(_jit_freenect_grab_class,mop);
//add methods
jit_class_addmethod(_jit_freenect_grab_class, (method)jit_freenect_grab_open, "open", A_GIMME, 0L);
jit_class_addmethod(_jit_freenect_grab_class, (method)jit_freenect_grab_close, "close", A_GIMME, 0L);
jit_class_addmethod(_jit_freenect_grab_class, (method)jit_freenect_grab_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"unique",_jit_sym_char,
attrflags,(method)NULL,(method)NULL,calcoffset(t_jit_freenect_grab,unique));
jit_attr_addfilterset_clip(attr,0,1,TRUE,TRUE);
jit_class_addattr(_jit_freenect_grab_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"threshold",_jit_sym_float32,
attrflags,(method)NULL,(method)NULL,calcoffset(t_jit_freenect_grab,threshold));
jit_attr_addfilterset_clip(attr,0,0,TRUE,FALSE);
jit_class_addattr(_jit_freenect_grab_class,attr);
//attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"cleardepth",_jit_sym_char,
attrflags,(method)NULL,(method)NULL,calcoffset(t_jit_freenect_grab,clear_depth));
jit_attr_addfilterset_clip(attr,0,1,TRUE,TRUE);
jit_class_addattr(_jit_freenect_grab_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"mode",_jit_sym_char,
attrflags,(method)NULL,(method)jit_freenect_grab_set_mode,calcoffset(t_jit_freenect_grab,mode));
jit_class_addattr(_jit_freenect_grab_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"format",_jit_sym_atom,
attrflags,(method)NULL,(method)jit_freenect_grab_set_format,calcoffset(t_jit_freenect_grab,format));
jit_class_addattr(_jit_freenect_grab_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"tilt",_jit_sym_long,
attrflags,(method)jit_freenect_grab_get_tilt,(method)jit_freenect_grab_set_tilt,
calcoffset(t_jit_freenect_grab,tilt));
jit_class_addattr(_jit_freenect_grab_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"aligndepth",_jit_sym_char,
attrflags,(method)NULL,(method)NULL,calcoffset(t_jit_freenect_grab,aligndepth));
jit_attr_addfilterset_clip(attr,0,1,TRUE,TRUE);
jit_class_addattr(_jit_freenect_grab_class,attr);
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_OPAQUE;
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"index",_jit_sym_long,
attrflags,(method)NULL,(method)NULL,calcoffset(t_jit_freenect_grab,index));
jit_class_addattr(_jit_freenect_grab_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"ndevices",_jit_sym_long,
attrflags,(method)jit_freenect_grab_get_ndevices,(method)NULL,calcoffset(t_jit_freenect_grab,ndevices));
jit_class_addattr(_jit_freenect_grab_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset_array, "accel", _jit_sym_float64, 3,
attrflags, (method)jit_freenect_grab_get_accel,(method)NULL,
calcoffset(t_jit_freenect_grab, accelcount),calcoffset(t_jit_freenect_grab,mks_accel));
jit_class_addattr(_jit_freenect_grab_class,attr);
attrflags = JIT_ATTR_GET_OPAQUE_USER | JIT_ATTR_SET_OPAQUE_USER;
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"has_frames",_jit_sym_char,
attrflags,(method)NULL,(method)NULL,calcoffset(t_jit_freenect_grab,has_frames));
jit_class_addattr(_jit_freenect_grab_class,attr);
jit_class_register(_jit_freenect_grab_class);
post("jit.freenect.grab: Copyright 2010, Jean-Marc Pelletier, Nenad Popov and Andrew Roth. Built on %s",DEBUG_TIMESTAMP);
return JIT_ERR_NONE;
}
t_jit_err jit_keyscreen_init(void)
{
long attrflags=0;
t_jit_object *attr, *mop;
_jit_keyscreen_class = jit_class_new("jit_keyscreen",(method)jit_keyscreen_new,(method)jit_keyscreen_free,
sizeof(t_jit_keyscreen),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,3,1);
jit_mop_single_type(mop,_jit_sym_char);
jit_mop_single_planecount(mop,4);
jit_class_addadornment(_jit_keyscreen_class,mop);
//add methods
jit_class_addmethod(_jit_keyscreen_class, (method)jit_keyscreen_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
CLASS_STICKY_CATEGORY(_jit_keyscreen_class,0,"Behavior");
CLASS_STICKY_ATTR(_jit_keyscreen_class,"basic",0,"1");
// mode -- switches keying states
attr = jit_object_new(_jit_sym_jit_attr_offset,"mode",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,mode));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"mode",0,"Keying Mode");
CLASS_ATTR_ENUMINDEX3(_jit_keyscreen_class, "mode", 0, "Wrap", "Clip", "Fold");
// key,target,mask -- switches who gets keyed with whom by whom
attr = jit_object_new(_jit_sym_jit_attr_offset,"key",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,key));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"key",0,"Key Input");
attr = jit_object_new(_jit_sym_jit_attr_offset,"target",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,target));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"target",0,"Target Input");
attr = jit_object_new(_jit_sym_jit_attr_offset,"mask",_jit_sym_long,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,mask));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"mask",0,"Mask Input");
// red, green, blue, tols -- changes colors and tolerances of the key
attr = jit_object_new(_jit_sym_jit_attr_offset,"alpha",_jit_sym_float32,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,alpha));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"alpha",0,"Alpha");
attr = jit_object_new(_jit_sym_jit_attr_offset,"red",_jit_sym_float32,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,red));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"red",0,"Red");
attr = jit_object_new(_jit_sym_jit_attr_offset,"green",_jit_sym_float32,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,green));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"green",0,"Green");
attr = jit_object_new(_jit_sym_jit_attr_offset,"blue",_jit_sym_float32,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,blue));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"blue",0,"Blue");
attr = jit_object_new(_jit_sym_jit_attr_offset,"alphatol",_jit_sym_float32,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,alphatol));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"alphatol",0,"Alpha Tolerance");
attr = jit_object_new(_jit_sym_jit_attr_offset,"redtol",_jit_sym_float32,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,redtol));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"redtol",0,"Red Tolerance");
attr = jit_object_new(_jit_sym_jit_attr_offset,"greentol",_jit_sym_float32,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,greentol));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"greentol",0,"Green Tolerance");
attr = jit_object_new(_jit_sym_jit_attr_offset,"bluetol",_jit_sym_float32,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_keyscreen,bluetol));
jit_class_addattr(_jit_keyscreen_class,attr);
CLASS_ATTR_LABEL(_jit_keyscreen_class,"bluetol",0,"Blue Tolerance");
CLASS_STICKY_CATEGORY_CLEAR(_jit_keyscreen_class);
CLASS_STICKY_ATTR_CLEAR(_jit_keyscreen_class, "basic");
jit_class_register(_jit_keyscreen_class);
return JIT_ERR_NONE;
}
t_jit_err cv_jit_opticalflow_init(void)
{
long attrflags=0;
t_jit_object *attr,*mop;
//t_symbol *atsym;
//atsym = gensym("jit_attr_offset");
_cv_jit_opticalflow_class = jit_class_new("cv_jit_opticalflow",(method)cv_jit_opticalflow_new,(method)cv_jit_opticalflow_free, sizeof(t_cv_jit_opticalflow),0L);
//add mop
mop = (t_jit_object *)jit_object_new(_jit_sym_jit_mop,1,2);
jit_mop_single_type(mop,_jit_sym_float32);
jit_mop_single_planecount(mop,2);
jit_class_addadornment(_cv_jit_opticalflow_class,mop);
//add methods
jit_class_addmethod(_cv_jit_opticalflow_class, (method)cv_jit_opticalflow_matrix_calc, "matrix_calc", A_CANT, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"method",_jit_sym_atom,attrflags,(method)cv_jit_opticalflow_get_method,(method)cv_jit_opticalflow_set_method,calcoffset(t_cv_jit_opticalflow,method));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"use_previous",_jit_sym_long,attrflags,(method)0L,(method)cv_jit_opticalflow_set_use_previous,calcoffset(t_cv_jit_opticalflow,use_previous));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"bm_max_range",_jit_sym_long,attrflags,(method)0L,(method)cv_jit_opticalflow_set_bm_max_range,calcoffset(t_cv_jit_opticalflow,bm_max_range));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"bm_block_size",_jit_sym_long,attrflags,(method)0L,(method)cv_jit_opticalflow_set_bm_block_size,calcoffset(t_cv_jit_opticalflow,bm_block_size));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"bm_shift_size",_jit_sym_long,attrflags,(method)0L,(method)cv_jit_opticalflow_set_bm_shift_size,calcoffset(t_cv_jit_opticalflow,bm_shift_size));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"lk_window_size",_jit_sym_long,attrflags,(method)0L,(method)cv_jit_opticalflow_set_lk_window_size,calcoffset(t_cv_jit_opticalflow,lk_window_size));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"hs_lambda",_jit_sym_float64,attrflags,(method)0L,(method)cv_jit_opticalflow_set_hs_lambda,calcoffset(t_cv_jit_opticalflow,hs_lambda));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"fb_window_size",_jit_sym_long,attrflags,(method)0L,(method)cv_jit_opticalflow_set_fb_window_size,calcoffset(t_cv_jit_opticalflow,fb_window_size));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_OPAQUE; //Those parameters are better left to their default values
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"fb_poly_n",_jit_sym_long,attrflags,(method)0L,(method)cv_jit_opticalflow_set_fb_poly_n,calcoffset(t_cv_jit_opticalflow,fb_poly_n));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"fb_iterations",_jit_sym_long,attrflags,(method)0L,(method)cv_jit_opticalflow_set_fb_iterations,calcoffset(t_cv_jit_opticalflow,fb_iterations));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"fb_poly_sigma",_jit_sym_float64,attrflags,(method)0L,(method)cv_jit_opticalflow_set_fb_poly_sigma,calcoffset(t_cv_jit_opticalflow,fb_poly_sigma));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"fb_pyramid_scale",_jit_sym_float64,attrflags,(method)0L,(method)cv_jit_opticalflow_set_fb_pyramid_scale,calcoffset(t_cv_jit_opticalflow,fb_pyramid_scale));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"fb_levels",_jit_sym_long,attrflags,(method)0L,(method)cv_jit_opticalflow_set_fb_levels,calcoffset(t_cv_jit_opticalflow,fb_levels));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"hs_epsilon",_jit_sym_float64,attrflags,(method)0L,(method)cv_jit_opticalflow_set_hs_epsilon,calcoffset(t_cv_jit_opticalflow,hs_epsilon));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset,"hs_max_iterations",_jit_sym_long,attrflags,(method)0L,(method)cv_jit_opticalflow_set_hs_max_iterations,calcoffset(t_cv_jit_opticalflow,hs_max_iterations));
jit_class_addattr(_cv_jit_opticalflow_class,attr);
jit_class_register(_cv_jit_opticalflow_class);
return JIT_ERR_NONE;
}
t_jit_err jit_print_init(void)
{
long attrflags=0;
t_jit_object *attr;
t_jit_object *mop;
_jit_print_class = jit_class_new("jit_print",(method)jit_print_new,(method)jit_print_free,
sizeof(t_jit_print),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,1,1);
jit_class_addadornment(_jit_print_class,mop);
//add methods
jit_class_addmethod(_jit_print_class, (method)jit_print_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,"precision",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_print,precision));
jit_attr_addfilterset_clip(attr,0,0,TRUE,FALSE); //clip to 0-x
jit_class_addattr(_jit_print_class,attr);
object_addattr_parse(attr,"label",_jit_sym_symbol,0,"Precision");
attr = jit_object_new(_jit_sym_jit_attr_offset,"fieldwidth",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_print,fieldwidth));
jit_attr_addfilterset_clip(attr,0,0,TRUE,FALSE); //clip to 0-x
jit_class_addattr(_jit_print_class,attr);
object_addattr_parse(attr,"label",_jit_sym_symbol,0,"\"Field Width\"");
attr = jit_object_new(_jit_sym_jit_attr_offset,"mode",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_print,mode));
jit_attr_addfilterset_clip(attr,0,2,TRUE,TRUE); //clip to 0-2
jit_class_addattr(_jit_print_class,attr);
object_addattr_parse(attr,"label",_jit_sym_symbol,0,"Mode");
attr = jit_object_new(_jit_sym_jit_attr_offset,"zeropad",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_print,zeropad));
jit_attr_addfilterset_clip(attr,0,1,TRUE,TRUE); //clip to 0-1
jit_class_addattr(_jit_print_class,attr);
object_addattr_parse(attr,"label",_jit_sym_symbol,0,"\"Zero Pad\"");
attr = jit_object_new(_jit_sym_jit_attr_offset,"planedelim",_jit_sym_symbol,attrflags,
(method)jit_print_planedelim_get,(method)jit_print_planedelim_set,0L);
jit_class_addattr(_jit_print_class,attr);
object_addattr_parse(attr,"label",_jit_sym_symbol,0,"\"Plane Delimiter\"");
attr = jit_object_new(_jit_sym_jit_attr_offset,"coldelim",_jit_sym_symbol,attrflags,
(method)jit_print_coldelim_get,(method)jit_print_coldelim_set,0L);
jit_class_addattr(_jit_print_class,attr);
object_addattr_parse(attr,"label",_jit_sym_symbol,0,"\"Column Delimiter\"");
attr = jit_object_new(_jit_sym_jit_attr_offset,"rowdelim",_jit_sym_symbol,attrflags,
(method)jit_print_rowdelim_get,(method)jit_print_rowdelim_set,0L);
jit_class_addattr(_jit_print_class,attr);
object_addattr_parse(attr,"label",_jit_sym_symbol,0,"\"Row Delimiter\"");
attr = jit_object_new(_jit_sym_jit_attr_offset,"title",_jit_sym_symbol,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_print, title));
jit_class_addattr(_jit_print_class,attr);
object_addattr_parse(attr,"label",_jit_sym_symbol,0,"Title");
attr = jit_object_new(_jit_sym_jit_attr_offset,"info",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_print, info));
jit_attr_addfilterset_clip(attr,0,2,TRUE,TRUE); //clip to 0-1
jit_class_addattr(_jit_print_class,attr);
object_addattr_parse(attr,"label",_jit_sym_symbol,0,"Info");
jit_class_register(_jit_print_class);
ps_null = gensym("");
ps_tab = gensym("tab");
ps_cr = gensym("cr");
ps_space = gensym("space");
return JIT_ERR_NONE;
}
t_jit_err jit_gl_videoplane_init(void)
{
long attrflags=0;
long ob3d_flags=0;
t_jit_object *attr;
void * ob3d;
_jit_gl_videoplane_class = jit_class_new("jit_gl_videoplane", (method)jit_gl_videoplane_new, (method)jit_gl_videoplane_free,
sizeof(t_jit_gl_videoplane),A_DEFSYM,0L);
jit_class_addmethod(_jit_gl_videoplane_class, (method)jit_gl_videoplane_jit_matrix, "jit_matrix", A_USURP_LOW, 0);
jit_class_addmethod(_jit_gl_videoplane_class, (method)jit_gl_videoplane_sendtexture, "sendtexture", A_DEFER_LOW, 0);
// set up object extension for 3d object, customized with flags
ob3d = jit_ob3d_setup(_jit_gl_videoplane_class, calcoffset(t_jit_gl_videoplane, ob3d), ob3d_flags);
// add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"dim",_jit_sym_long,2,attrflags,
(method)0L,(method)jit_gl_videoplane_dim,0/*fix*/,calcoffset(t_jit_gl_videoplane,dim));
jit_attr_addfilterset_clip(attr,2,0,TRUE,FALSE);
jit_class_addattr(_jit_gl_videoplane_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"displaylist",_jit_sym_char,attrflags,
(method)0L,(method)jit_gl_videoplane_displaylist,calcoffset(t_jit_gl_videoplane, displaylist));
jit_class_addattr(_jit_gl_videoplane_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"gridmode",_jit_sym_char,attrflags,
(method)0L,(method)jit_gl_videoplane_attr_rebuild,calcoffset(t_jit_gl_videoplane, gridmode));
jit_class_addattr(_jit_gl_videoplane_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"interp",_jit_sym_long,attrflags,
(method)0L,(method)jit_gl_videoplane_interp,calcoffset(t_jit_gl_videoplane, interp));
jit_class_addattr(_jit_gl_videoplane_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"nudge",_jit_sym_float32,attrflags,
(method)0L,(method)jit_gl_videoplane_attr_rebuild,calcoffset(t_jit_gl_videoplane, nudge));
jit_class_addattr(_jit_gl_videoplane_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"tex_offset_x",_jit_sym_float32,attrflags,
(method)0L,(method)jit_gl_videoplane_attr_rebuild,calcoffset(t_jit_gl_videoplane, tex_offset_x));
jit_class_addattr(_jit_gl_videoplane_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"tex_offset_y",_jit_sym_float32,attrflags,
(method)0L,(method)jit_gl_videoplane_attr_rebuild,calcoffset(t_jit_gl_videoplane, tex_offset_y));
jit_class_addattr(_jit_gl_videoplane_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"tex_scale_x",_jit_sym_float32,attrflags,
(method)0L,(method)jit_gl_videoplane_attr_rebuild,calcoffset(t_jit_gl_videoplane, tex_scale_x));
jit_class_addattr(_jit_gl_videoplane_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"tex_scale_y",_jit_sym_float32,attrflags,
(method)0L,(method)jit_gl_videoplane_attr_rebuild,calcoffset(t_jit_gl_videoplane, tex_scale_y));
jit_class_addattr(_jit_gl_videoplane_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"rect_tex",_jit_sym_long,attrflags,
(method)0L,(method)jit_gl_videoplane_rect_tex,calcoffset(t_jit_gl_videoplane, rect_tex));
jit_class_addattr(_jit_gl_videoplane_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"client_storage",_jit_sym_long,attrflags,
(method)0L,(method)jit_gl_videoplane_client_storage,calcoffset(t_jit_gl_videoplane, client_storage));
jit_class_addattr(_jit_gl_videoplane_class,attr);
attr = jit_object_new(_jit_sym_jit_attr_offset,"colormode",_jit_sym_symbol,attrflags,
(method)0L,(method)jit_gl_videoplane_colormode,calcoffset(t_jit_gl_videoplane, colormode));
jit_class_addattr(_jit_gl_videoplane_class,attr);
CLASS_ATTR_ENUM(_jit_gl_videoplane_class,"colormode",0,"argb uyvy");
attr = jit_object_new(_jit_sym_jit_attr_offset,"texturename",_jit_sym_symbol,attrflags,
(method)0L,(method)jit_gl_videoplane_texturename,calcoffset(t_jit_gl_videoplane, texturename));
jit_class_addattr(_jit_gl_videoplane_class,attr);
// define our OB3D draw method. called in automatic mode by
// jit.gl.render or otherwise through ob3d when banged. this
// method is A_CANT because our draw setup needs to happen
// in the ob3d beforehand to initialize OpenGL state
jit_class_addmethod(_jit_gl_videoplane_class, (method)jit_gl_videoplane_draw, "ob3d_draw", A_CANT, 0L);
// define our dest_closing and dest_changed methods.
// these methods are called by jit.gl.render when the
// destination context closes or changes: for example, when
// the user moves the window from one monitor to another. Any
// resources your object keeps in the OpenGL machine
// (e.g. textures, display lists, vertex shaders, etc.)
// will need to be freed when closing, and rebuilt when it has
// changed.
jit_class_addmethod(_jit_gl_videoplane_class, (method)jit_gl_videoplane_dest_changed, "dest_changed", A_CANT, 0L);
jit_class_addmethod(_jit_gl_videoplane_class, (method)jit_gl_videoplane_dest_closing, "dest_closing", A_CANT, 0L);
// rebuild_geometry is called if texture units or other
// attributes change requiring a rebuild
jit_class_addmethod(_jit_gl_videoplane_class, (method)jit_gl_videoplane_rebuild_geometry, "rebuild_geometry", 0L);
// must register for ob3d
jit_class_addmethod(_jit_gl_videoplane_class, (method)jit_object_register, "register", A_CANT, 0L);
jit_class_register(_jit_gl_videoplane_class);
ps_bind = gensym("bind");
ps_unbind = gensym("unbind");
ps_jit_gl_texture = gensym("jit_gl_texture");
ps_rectangle = gensym("rectangle");
ps_colormode = gensym("colormode");
ps_mode = gensym("mode");
ps_static = gensym("static");
ps_dynamic = gensym("dynamic");
ps_drawto = gensym("drawto");
ps_texture = gensym("texture");
ps_filter = gensym("filter");
ps_linear = gensym("linear");
ps_nearest = gensym("nearest");
ps_gridmode = gensym("gridmode");
ps_nudge = gensym("nudge");
ps_tex_offset_x = gensym("tex_offset_x");
ps_tex_offset_y = gensym("tex_offset_y");
ps_tex_scale_x = gensym("tex_scale_x");
ps_tex_scale_y = gensym("tex_scale_y");
return JIT_ERR_NONE;
}
t_jit_err jit_boids2d_init(void)
{
long attrflags=0;
t_jit_object *attr,*mop,*o;
t_symbol *atsym;
atsym = gensym("jit_attr_offset");
_jit_boids2d_class = jit_class_new("jit_boids2d",(method)jit_boids2d_new,(method)jit_boids2d_free,
sizeof(t_jit_boids2d),0L);
//add mop
mop = jit_object_new(_jit_sym_jit_mop,0,1);
o = jit_object_method(mop,_jit_sym_getoutput,1);
jit_attr_setlong(o,_jit_sym_dimlink,0);
jit_class_addadornment(_jit_boids2d_class,mop);
//add methods
jit_class_addmethod(_jit_boids2d_class, (method)jit_boids2d_matrix_calc, "matrix_calc", A_CANT, 0L);
jit_class_addmethod(_jit_boids2d_class, (method)Flock_reset, "init", A_USURP_LOW, 0L);
jit_class_addmethod(_jit_boids2d_class, (method)Flock_resetBoids, "reset", A_USURP_LOW, 0L);
//add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
//mode
attr = jit_object_new(atsym,"mode",_jit_sym_char,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,mode));
jit_class_addattr(_jit_boids2d_class,attr);
//number
attr = jit_object_new(atsym,"number",_jit_sym_long,attrflags,
(method)0L,(method)jit_boids2d_number,calcoffset(t_jit_boids2d,number));
jit_class_addattr(_jit_boids2d_class,attr);
//neighbors
attr = jit_object_new(atsym,"neighbors",_jit_sym_long,attrflags,
(method)0L,(method)jit_boids2d_neighbors,calcoffset(t_jit_boids2d,neighbors));
jit_class_addattr(_jit_boids2d_class,attr);
//flyrect
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"flyrect",_jit_sym_float64,4,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,flyRectCount),calcoffset(t_jit_boids2d,flyrect));
jit_class_addattr(_jit_boids2d_class,attr);
//minspeed
attr = jit_object_new(atsym,"minspeed",_jit_sym_float64,attrflags,
(method)0L,(method)jit_boids2d_minspeed,calcoffset(t_jit_boids2d,minspeed));
jit_class_addattr(_jit_boids2d_class,attr);
//maxspeed
attr = jit_object_new(atsym,"maxspeed",_jit_sym_float64,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,maxspeed));
jit_class_addattr(_jit_boids2d_class,attr);
//center
attr = jit_object_new(atsym,"center",_jit_sym_float64,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,center));
jit_class_addattr(_jit_boids2d_class,attr);
//attract
attr = jit_object_new(atsym,"attract",_jit_sym_float64,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,attract));
jit_class_addattr(_jit_boids2d_class,attr);
//match
attr = jit_object_new(atsym,"match",_jit_sym_float64,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,match));
jit_class_addattr(_jit_boids2d_class,attr);
//avoid
attr = jit_object_new(atsym,"avoid",_jit_sym_float64,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,avoid));
jit_class_addattr(_jit_boids2d_class,attr);
//repel
attr = jit_object_new(atsym,"repel",_jit_sym_float64,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,repel));
jit_class_addattr(_jit_boids2d_class,attr);
//edgedist
attr = jit_object_new(atsym,"edgedist",_jit_sym_float64,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,edgedist));
jit_class_addattr(_jit_boids2d_class,attr);
//speed
attr = jit_object_new(atsym,"speed",_jit_sym_float64,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,speed));
jit_class_addattr(_jit_boids2d_class,attr);
//inertia
attr = jit_object_new(atsym,"inertia",_jit_sym_float64,attrflags,
(method)0L,(method)jit_boids2d_inertia,calcoffset(t_jit_boids2d,inertia));
jit_class_addattr(_jit_boids2d_class,attr);
//accel
attr = jit_object_new(atsym,"accel",_jit_sym_float64,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,accel));
jit_class_addattr(_jit_boids2d_class,attr);
//prefdist
attr = jit_object_new(atsym,"prefdist",_jit_sym_float64,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,prefdist));
jit_class_addattr(_jit_boids2d_class,attr);
//centerPt
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"centerPt",_jit_sym_float64,2,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,centerPtCount),calcoffset(t_jit_boids2d,centerPt));
jit_class_addattr(_jit_boids2d_class,attr);
//attractpt.
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"attractpt",_jit_sym_float64,2,attrflags,
(method)0L,(method)0L,calcoffset(t_jit_boids2d,attractPtCount),calcoffset(t_jit_boids2d,attractpt));
jit_class_addattr(_jit_boids2d_class,attr);
//set_pos.
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"set_pos",_jit_sym_float64,2,attrflags,
(method)0L,(method)jit_boids2d_set_pos,calcoffset(t_jit_boids2d,set_pos));
jit_class_addattr(_jit_boids2d_class,attr);
//set_dir.
attr = jit_object_new(_jit_sym_jit_attr_offset_array,"set_dir",_jit_sym_float64,2,attrflags,
(method)0L,(method)jit_boids2d_set_dir,calcoffset(t_jit_boids2d,set_pos));
jit_class_addattr(_jit_boids2d_class,attr);
//set_speed
attr = jit_object_new(atsym,"set_speed",_jit_sym_float64,attrflags,
(method)0L,(method)jit_boids2d_set_speed,calcoffset(t_jit_boids2d,set_speed));
jit_class_addattr(_jit_boids2d_class,attr);
//set_speed
attr = jit_object_new(atsym,"set_speedinv",_jit_sym_float64,attrflags,
(method)0L,(method)jit_boids2d_set_speedinv,calcoffset(t_jit_boids2d,set_speedinv));
jit_class_addattr(_jit_boids2d_class,attr);
//number
attr = jit_object_new(atsym,"set",_jit_sym_long,attrflags,
(method)0L,(method)jit_boids2d_set,calcoffset(t_jit_boids2d,set));
jit_class_addattr(_jit_boids2d_class,attr);
jit_class_register(_jit_boids2d_class);
return JIT_ERR_NONE;
}
