extern "C" int TTCLASSWRAPPERMAX_EXPORT main(void)
{
t_class *c;
c = class_new("tap.colorspace",(method)cs_new, (method)cs_free, sizeof(t_cs), (method)0L, A_GIMME, 0);
common_symbols_init();
class_addmethod(c, (method)cs_bang, "bang", 0L);
class_addmethod(c, (method)cs_int, "int", A_LONG, 0L); // Input as int
class_addmethod(c, (method)cs_float, "float", A_FLOAT, 0L); // Input as float
class_addmethod(c, (method)cs_list, "list", A_GIMME, 0L);
class_addmethod(c, (method)cs_assist, "assist", A_CANT, 0L);
class_addmethod(c, (method)object_obex_dumpout, "dumpout", A_CANT,0);
class_addmethod(c, (method)cs_inletinfo, "inletinfo", A_CANT, 0);
CLASS_ATTR_SYM(c, "mode", 0, t_cs, attr_mode);
CLASS_ATTR_ENUM(c, "mode", 0,
"no_transform rgb2cmy cmy2rgb rgb2hsv hsv2rgb rgb2xyz xyz2rgb rgb2uvw uvw2rgb rgb2retinalcone retinalcone2rgb rgb2lab lab2rgb rgb2yiq yiq2rgb rgb2hls hls2rgb rgb2rgbcie rgbcie2rgb rgb2rgbsmpte rgbsmpte2rgb rgb2hsl hsl2rgb");
CLASS_ATTR_SYM(c, "outputtype", 0, t_cs, attr_outputtype);
CLASS_ATTR_ENUM(c, "outputtype", 0, "split packed");
CLASS_ATTR_LONG(c, "autopack", 0, t_cs, attr_autopack);
CLASS_ATTR_STYLE(c, "autopack", 0, "onoff");
this_class = c; class_register(_sym_box, c);
// initialize class globals
ps_no_transform = gensym("no_transform");
ps_rgb2cmy = gensym("rgb2cmy");
ps_cmy2rgb = gensym("cmy2rgb");
ps_rgb2hsv = gensym("rgb2hsv");
ps_hsv2rgb = gensym("hsv2rgb");
ps_rgb2xyz = gensym("rgb2xyz");
ps_xyz2rgb = gensym("xyz2rgb");
ps_rgb2uvw = gensym("rgb2uvw");
ps_uvw2rgb = gensym("uvw2rgb");
ps_rgb2retinalcone = gensym("rgb2retinalcone");
ps_retinalcone2rgb = gensym("retinalcone2rgb");
ps_rgb2lab = gensym("rgb2lab");
ps_lab2rgb = gensym("lab2rgb");
ps_rgb2yiq = gensym("rgb2yiq");
ps_yiq2rgb = gensym("yiq2rgb");
ps_rgb2hls = gensym("rgb2hls");
ps_hls2rgb = gensym("hls2rgb");
ps_rgb2rgbcie = gensym("rgb2rgbcie");
ps_rgbcie2rgb = gensym("rgbcie2rgb");
ps_rgb2rgbsmpte = gensym("rgb2rgbsmpte");
ps_rgbsmpte2rgb = gensym("rgbsmpte2rgb");
ps_rgb2hsl = gensym("rgb2hsl");
ps_hsl2rgb = gensym("hsl2rgb");
ps_split = gensym("split");
ps_packed = gensym("packed");
// Finalize our class
class_register(CLASS_BOX, c);
this_class = c;
}
int C74_EXPORT main(void)
{
t_class *c;
c = class_new("hoa.3d.decoder~", (method)hoa_decoder_new, (method)hoa_decoder_free, (long)sizeof(t_hoa_decoder), 0L, A_GIMME, 0);
hoa_initclass(c, (method)hoa_getinfos);
// @method signal @digest Array of spherical harmonic signals to decode for a set of loudspeakers
// @description Array of spherical harmonic signals to decode for a set of loudspeakers
class_addmethod(c, (method)hoa_decoder_dsp64, "dsp64", A_CANT, 0);
class_addmethod(c, (method)hoa_decoder_assist, "assist", A_CANT, 0);
CLASS_ATTR_SYM (c, "mode", 0, t_hoa_decoder, f_mode);
CLASS_ATTR_LABEL (c, "mode", 0, "Mode");
CLASS_ATTR_ENUM (c, "mode", 0, "ambisonic binaural irregular");
CLASS_ATTR_ACCESSORS (c, "mode", NULL, mode_set);
CLASS_ATTR_ORDER (c, "mode", 0, "1");
CLASS_ATTR_SAVE (c, "mode", 1);
// @description There is three decoding <m>mode</m> :
// <ul>
// <li><b>Ambisonics</b> : for a regular loudspeakers repartition over a sphere.</li>
// <li><b>Binaural</b> : for headphones.</li>
// <li><b>Irregular</b> : for an irregular loudspeakers repartition</li>
// </ul>
CLASS_ATTR_DOUBLE_VARSIZE (c, "angles", ATTR_SET_DEFER_LOW, t_hoa_decoder, f_angles_of_channels, f_number_of_angles, MAX_CHANNELS*2);
CLASS_ATTR_LABEL (c, "angles", 0, "Angles of Channels");
CLASS_ATTR_ACCESSORS (c, "angles", NULL, angles_set);
CLASS_ATTR_ORDER (c, "angles", 0, "2");
// @description Set the angles of each channels in degrees. The angles of channels are only settable in <b>irregular</b> <m>mode</m>. Each angles are in degrees, wrapped between 0. and 360. You must specify 2 values per channel corresponding to the azimuth value followed by the elevation value.
CLASS_ATTR_DOUBLE_ARRAY (c, "offset", 0, t_hoa_decoder, f_offset, 2);
CLASS_ATTR_LABEL (c, "offset", 0, "Offset of Channels");
CLASS_ATTR_ACCESSORS (c, "offset", NULL, offset_set);
CLASS_ATTR_DEFAULT (c, "offset", 0, "0 0");
CLASS_ATTR_ORDER (c, "offset", 0, "3");
// @description Set the offsets of channels with a list of 2 float values corresponding to the azimuth and elevation offset, in degrees between 0. and 360.
CLASS_ATTR_SYM (c, "pinna", 0, t_hoa_decoder, f_pinna);
CLASS_ATTR_LABEL (c, "pinna", 0, "Pinna Size");
CLASS_ATTR_ENUM (c, "pinna", 0, "small large");
CLASS_ATTR_ACCESSORS (c, "pinna", NULL, pinna_set);
CLASS_ATTR_ORDER (c, "pinna", 0, "4");
// @description The pinna size to use for the binaural restitution. The <m>pinna</m> message followed by the <b>symbol</b> <b>small</b> or <b>large</b> set the pinna size of the HRTF responses for the binaural restitution. Choose the one that suits you best.
class_dspinit(c);
class_register(CLASS_BOX, c);
hoa_decoder_class = c;
return 0;
}
int C74_EXPORT main(void)
{
WrappedClassOptionsPtr options = new WrappedClassOptions;
WrappedClassPtr c = NULL;
TTValue v(2);
TTDSPInit();
options->append(TT("fixedNumOutputChannels"), v);
wrapTTClassAsMaxClass(TT("panorama"), "j.panorama~", &c, options);
CLASS_ATTR_ENUM(c->maxClass, "mode", 0, "calculate lookup");
CLASS_ATTR_ENUM(c->maxClass, "shape", 0, "equalPower linear squareRoot");
return 0;
}
int TTCLASSWRAPPERMAX_EXPORT main(void)
{
ClassPtr c;
TTAudioGraphInit();
common_symbols_init();
c = class_new("jcom.op≈", (method)OpNew, (method)OpFree, sizeof(Op), (method)0L, A_GIMME, 0);
class_addmethod(c, (method)OpResetAudio, "audio.reset", A_CANT, 0);
class_addmethod(c, (method)OpSetupAudio, "audio.setup", A_CANT, 0);
class_addmethod(c, (method)OpConnectAudio, "audio.connect", A_OBJ, A_LONG, 0);
class_addmethod(c, (method)OpDropAudio, "audio.drop", A_CANT, 0);
class_addmethod(c, (method)MaxAudioGraphObject, "audio.object", A_CANT, 0);
class_addmethod(c, (method)MaxAudioGraphReset, "graph.reset", A_CANT, 0);
//class_addmethod(c, (method)OpSetup, "graph.setup", A_CANT, 0); // no setup -- no graph outlets
class_addmethod(c, (method)MaxGraphConnect, "graph.connect", A_OBJ, A_LONG, 0);
class_addmethod(c, (method)MaxGraphDrop, "graph.drop", A_CANT, 0);
class_addmethod(c, (method)MaxGraphObject, "graph.object", A_CANT, 0);
class_addmethod(c, (method)OpAssist, "assist", A_CANT, 0);
class_addmethod(c, (method)object_obex_dumpout, "dumpout", A_CANT, 0);
CLASS_ATTR_SYM(c, "operator", 0, Op, attrOperator);
CLASS_ATTR_ACCESSORS(c, "operator", OpGetOperator, OpSetOperator);
CLASS_ATTR_ENUM(c, "operator", 0, "+ - * / % > >= == != <= < abs acos asin atan ceil cos cosh exp floor log log10 sin sinh sqrt tan tanh");
CLASS_ATTR_FLOAT(c, "operand", 0, Op, attrOperand);
CLASS_ATTR_ACCESSORS(c, "operand", OpGetOperand, OpSetOperand);
class_register(_sym_box, c);
sOpClass = c;
return 0;
}
int C74_EXPORT main(void)
{
t_class *c;
c = class_new("hoa.optim~", (method)HoaOptim_new, (method)dsp_free, (long)sizeof(t_HoaOptim), 0L, A_GIMME, 0);
class_addmethod(c, (method)HoaOptim_dsp64, "dsp64", A_CANT, 0);
class_addmethod(c, (method)HoaOptim_assist, "assist", A_CANT, 0);
CLASS_ATTR_SYM (c, "optim", 0, t_HoaOptim, f_optim_mode);
CLASS_ATTR_CATEGORY (c, "optim", 0, "Behavior");
CLASS_ATTR_LABEL (c, "optim", 0, "Optimization");
CLASS_ATTR_ENUM (c, "optim", 0, "basic maxRe inPhase");
CLASS_ATTR_ORDER (c, "optim", 0, "1");
CLASS_ATTR_ACCESSORS (c, "optim", NULL, HoaOptim_optim);
CLASS_ATTR_SAVE (c, "optim", 1);
class_dspinit(c);
class_register(CLASS_BOX, c);
HoaOptim_class = c;
class_findbyname(CLASS_BOX, gensym("hoa.encoder~"));
return 0;
}
t_jit_err jit_field_mesh_init(void)
{
long attrflags=0;
t_jit_object *attr;
_jit_field_mesh_class = jit_class_new("jit_field_mesh",(method)jit_field_mesh_new,(method)jit_field_mesh_free,
sizeof(t_jit_field_mesh),0L);
// add attributes
attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
jit_class_addmethod(_jit_field_mesh_class, (method)jit_field_mesh_jit_field, "jit_field", A_GIMME, 0L);
jit_class_addmethod(_jit_field_mesh_class, (method)jit_field_mesh_get_vertex_matrix, "get_vertex_matrix", A_CANT, 0L);
jit_class_addmethod(_jit_field_mesh_class, (method)jit_field_mesh_get_normal_matrix, "get_normal_matrix", A_CANT, 0L);
jit_class_addmethod(_jit_field_mesh_class, (method)jit_field_mesh_get_index_matrix, "get_index_matrix", A_CANT, 0L);
jit_class_addmethod(_jit_field_mesh_class, (method)jit_field_mesh_volume_to_mesh, "volume_to_mesh", A_CANT, 0L);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset, "isolevel", _jit_sym_float32, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_field_mesh, isolevel));
jit_class_addattr(_jit_field_mesh_class, (t_jit_object*)attr);
attr = (t_jit_object *)jit_object_new(_jit_sym_jit_attr_offset, "mode", _jit_sym_symbol, attrflags,
(method)0L, (method)0L, calcoffset(t_jit_field_mesh, mode));
jit_class_addattr(_jit_field_mesh_class, (t_jit_object*)attr);
CLASS_ATTR_ENUM((t_class *)_jit_field_mesh_class, "mode", 0, "mesh particles");
jit_class_register(_jit_field_mesh_class);
return JIT_ERR_NONE;
}
extern "C" int TTCLASSWRAPPERMAX_EXPORT main(void)
{
t_class *c;
c = class_new("tap.bits",(method)bits_new, (method)0L, sizeof(t_bits), (method)0L, A_GIMME, 0);
common_symbols_init();
class_addmethod(c, (method)bits_int, "int", A_LONG, 0L);
class_addmethod(c, (method)bits_list, "list", A_GIMME, 0L);
class_addmethod(c, (method)bits_assist, "assist", A_CANT, 0L);
class_addmethod(c, (method)stdinletinfo, "inletinfo", A_CANT, 0);
CLASS_ATTR_SYM(c, "mode", 0, t_bits, mode);
CLASS_ATTR_ENUM(c, "mode", 0, "bits2ints ints2bits matrixctrl2ints ints2matrixctrl");
CLASS_ATTR_LONG(c, "matrix_width", 0, t_bits, matrix_width);
class_register(_sym_box, c);
bits_class = c;
// Initialize Globals
ps_bits2ints = gensym("bits2ints"); // Initialize these globals (so we don't have to constantly run a gensym for them in our methods)
ps_ints2bits = gensym("ints2bits");
ps_matrixctrl2ints = gensym("matrixctrl2ints");
ps_ints2matrixctrl = gensym("ints2matrixctrl");
return 0;
}
int C74_EXPORT main(void)
{
t_class *c;
c = class_new("hoa.binaural~", (method)HoaBinaural_new, (method)HoaBinaural_free, (long)sizeof(t_HoaBinaural), 0L, A_GIMME, 0);
class_addmethod(c, (method)HoaBinaural_dsp, "dsp", A_CANT, 0);
class_addmethod(c, (method)HoaBinaural_dsp64, "dsp64", A_CANT, 0);
class_addmethod(c, (method)HoaBinaural_assist, "assist", A_CANT, 0);
CLASS_ATTR_SYM (c,"pinnasize", 0, t_HoaBinaural, f_pinna_size);
CLASS_ATTR_ACCESSORS (c,"pinnasize", NULL, HoaBinaural_set_pinnasize);
CLASS_ATTR_LABEL (c,"pinnasize", 0, "Pinna Size");
CLASS_ATTR_CATEGORY (c,"pinnasize", 0, "Behavior");
CLASS_ATTR_ENUM (c,"pinnasize", 0, "small large");
CLASS_ATTR_DEFAULT (c,"pinnasize", 0, "small");
CLASS_ATTR_ORDER (c,"pinnasize", 0, "1");
CLASS_ATTR_SAVE (c,"pinnasize", 1);
class_dspinit(c);
class_register(CLASS_BOX, c);
HoaBinaural_class = c;
class_findbyname(CLASS_NOBOX, gensym("hoa.encoder~"));
return 0;
}
int TTCLASSWRAPPERMAX_EXPORT main(void)
{
t_class *c;
TTDSPInit();
common_symbols_init();
c = class_new("jcom.op~",(method)op_new, (method)op_free, sizeof(t_op), (method)0L, A_GIMME, 0);
class_addmethod(c, (method)op_dsp, "dsp", A_CANT, 0);
class_addmethod(c, (method)op_dsp64, "dsp64", A_CANT, 0);
class_addmethod(c, (method)op_assist, "assist", A_CANT, 0);
class_addmethod(c, (method)object_obex_dumpout, "dumpout", A_CANT, 0);
CLASS_ATTR_SYM(c, "operator", 0, t_op, attrOperator);
CLASS_ATTR_ACCESSORS(c, "operator", NULL, op_setOperator);
CLASS_ATTR_ENUM(c, "operator", 0, "+ - * / % > >= == != <= < abs acos asin atan ceil cos cosh exp floor log log10 sin sinh sqrt tan tanh");
CLASS_ATTR_FLOAT(c, "operand", 0, t_op, attrOperand);
CLASS_ATTR_ACCESSORS(c, "operand", NULL, op_setOperand);
class_dspinit(c); // Setup object's class to work with MSP
class_register(CLASS_BOX, c);
s_op_class = c;
return 0;
}
extern "C" int TTCLASSWRAPPERMAX_EXPORT main(void)
{
t_class *c;
c = class_new("tap.decibels~",(method)decibels_new, (method)dsp_free, sizeof(t_decibels),
(method)0L, A_GIMME, 0);
common_symbols_init();
class_addmethod(c, (method)decibels_dsp, "dsp", A_CANT, 0L);
class_addmethod(c, (method)decibels_dsp64, "dsp64", A_CANT, 0);
class_addmethod(c, (method)decibels_int, "int", A_LONG, 0L); // Input as int
class_addmethod(c, (method)decibels_float, "float", A_FLOAT, 0L); // Input as double
class_addmethod(c, (method)decibels_assist, "assist", A_CANT, 0L);
class_addmethod(c, (method)stdinletinfo, "inletinfo", A_CANT, 0);
CLASS_ATTR_SYM(c, "mode", 0, t_decibels, attr_mode);
CLASS_ATTR_ACCESSORS(c, "mode", NULL, attr_set_mode);
CLASS_ATTR_ENUM(c, "mode", 0, "amp2db db2amp mm2db db2mm mm2amp amp2mm db2midi midi2db");
class_dspinit(c); // Setup object's class to work with MSP
class_register(_sym_box, c); decibels_class = c;
// initialize class globals
ps_amp2db = gensym("amp2db");
ps_db2amp = gensym("db2amp");
ps_mm2db = gensym("mm2db");
ps_db2mm = gensym("db2mm");
ps_mm2amp = gensym("mm2amp");
ps_amp2mm = gensym("amp2mm");
ps_db2midi = gensym("db2midi");
ps_midi2db = gensym("midi2db");
}
int C74_EXPORT main(void)
{
MaxAudioGraphWrappedClassOptionsPtr options = new MaxAudioGraphWrappedClassOptions;
TTValue value(0);
MaxAudioGraphWrappedClassPtr c = NULL;
TTAudioGraphInit();
wrapAsMaxAudioGraph(TT("soundfile.recorder"), "j.soundfile.recorder=", &c, options);
CLASS_ATTR_ENUM(c->maxClass, "format", 0, "AIFF AIFF-16bit AIFF-24bit AIFF-32bit CAF CAF-16bit CAF-24bit CAF-32bit FLAC FLAC-16bit FLAC-24bit FLAC-32bit Matlab-16bit Matlab-32bit Matlab-64bit WAV WAV-16bit WAV-24bit WAV-32bit");
wrapAsMaxAudioGraph(TT("soundfile.recorder"), "soundfile.recorder=", &c, options);
CLASS_ATTR_ENUM(c->maxClass, "format", 0, "AIFF AIFF-16bit AIFF-24bit AIFF-32bit CAF CAF-16bit CAF-24bit CAF-32bit FLAC FLAC-16bit FLAC-24bit FLAC-32bit Matlab-16bit Matlab-32bit Matlab-64bit WAV WAV-16bit WAV-24bit WAV-32bit");
return 0;
}
int TTCLASSWRAPPERMAX_EXPORT main(void)
{
MaxAudioGraphWrappedClassOptionsPtr options = new MaxAudioGraphWrappedClassOptions;
TTValue value(0);
MaxAudioGraphWrappedClassPtr c = NULL;
TTAudioGraphInit();
wrapAsMaxAudioGraph(TT("average"), "jcom.average≈", &c, options);
CLASS_ATTR_ENUM(c->maxClass, "mode", 0, "absolute bipolar rms");
wrapAsMaxAudioGraph(TT("average"), "average≈", &c, options);
CLASS_ATTR_ENUM(c->maxClass, "mode", 0, "absolute bipolar rms");
return 0;
}
int TTCLASSWRAPPERMAX_EXPORT main(void)
{
MaxAudioGraphWrappedClassOptionsPtr options = new MaxAudioGraphWrappedClassOptions;
// TTValue value(0);
MaxAudioGraphWrappedClassPtr c = NULL;
TTAudioGraphInit();
// options->append(TT("generator"), value);
options->append(TT("generator"), YES);
options->append(TT("userCanSetNumChannels"), YES);
wrapAsMaxAudioGraph(TT("noise"), "j.noise=", &c, options);
CLASS_ATTR_ENUM(c->maxClass, "mode", 0, "white pink brown blue gauss");
wrapAsMaxAudioGraph(TT("noise"), "noise=", &c, options);
CLASS_ATTR_ENUM(c->maxClass, "mode", 0, "white pink brown blue gauss");
return 0;
}
int JAMOMA_EXPORT_MAXOBJ main(void)
{
t_class *c;
t_object *attr = NULL;
long numDataspaces = 0;
SymbolPtr* dataspaceNames = NULL;
char dataspaces[2048];
short i;
jamoma_init();
common_symbols_init();
jamoma_getDataspaceList(&numDataspaces, &dataspaceNames);
dataspaces[0] = 0;
for (i=0; i<numDataspaces; i++)
{
strcat(dataspaces, dataspaceNames[i]->s_name);
strcat(dataspaces, " ");
}
// Define our class
c = class_new("jcom.return",(method)return_new, (method)return_free, sizeof(t_return), (method)0L, A_GIMME, 0);
// Make methods accessible for our class:
class_addmethod(c, (method)return_bang, "bang", A_CANT, 0L);
class_addmethod(c, (method)return_int, "int", A_DEFLONG, 0L);
class_addmethod(c, (method)return_float, "float", A_DEFFLOAT, 0L);
class_addmethod(c, (method)return_list, "list", A_GIMME, 0L);
class_addmethod(c, (method)return_symbol, "anything", A_GIMME, 0L);
class_addmethod(c, (method)return_dump, "dump", 0L);
class_addmethod(c, (method)return_updatename, "update_name", A_CANT, 0L);
class_addmethod(c, (method)return_assist, "assist", A_CANT, 0L);
jcom_core_subscriber_classinit_extended(c, attr);
// ATTRIBUTE: type - options are generic, integer, decimal, string, boolean
jamoma_class_attr_new(c, "type", _sym_symbol, (method)return_attr_settype, (method)return_attr_gettype);
// ATTRIBUTES: dataspace stuff
CLASS_ATTR_SYM(c, "dataspace", 0, t_return, attrDataspace);
CLASS_ATTR_LABEL(c, "dataspace", 0, "dataspace");
CLASS_ATTR_ENUM(c, "dataspace", 0, dataspaces);
CLASS_ATTR_SYM(c, "dataspace/unit/native", 0, t_return, attrUnitNative);
CLASS_ATTR_LABEL(c, "dataspace/unit/native", 0, "dataspace/unit/native");
CLASS_ATTR_CHAR(c, "enable", 0, t_return, attrEnable);
CLASS_ATTR_STYLE(c, "enable", 0, "onoff");
// Finalize our class
class_register(CLASS_BOX, c);
return_class = c;
return 0;
}
void ext_main(void *r)
#endif
{
t_class *c;
c = class_new("hoa.3d.decoder~", (method)hoa_3d_decoder_new, (method)hoa_3d_decoder_free, (long)sizeof(t_hoa_3d_decoder), 0L, A_GIMME, 0);
class_setname((char *)"hoa.3d.decoder~", (char *)"hoa.3d.decoder~");
hoa_initclass(c, (method)hoa_getinfos);
// @method signal @digest Array of spherical harmonic signals to decode for a set of loudspeakers.
// @description Array of spherical harmonic signals to decode for a set of loudspeakers.
class_addmethod(c, (method)hoa_3d_decoder_dsp64, "dsp64", A_CANT, 0);
class_addmethod(c, (method)hoa_3d_decoder_assist, "assist", A_CANT, 0);
CLASS_ATTR_SYM (c, "mode", 0, t_hoa_3d_decoder, f_mode);
CLASS_ATTR_LABEL (c, "mode", 0, "Mode");
CLASS_ATTR_ENUM (c, "mode", 0, "ambisonic binaural");
CLASS_ATTR_ACCESSORS (c, "mode", NULL, mode_set);
CLASS_ATTR_ORDER (c, "mode", 0, "1");
// @description There is two decoding <m>mode</m> :
// <ul>
// <li><b>regular</b> : for a regular or irregular loudspeakers repartition over a sphere.</li>
// <li><b>binaural</b> : for headphones.</li>
// </ul>
CLASS_ATTR_DOUBLE_VARSIZE (c, "angles", ATTR_SET_DEFER_LOW, t_hoa_3d_decoder, f_angles_of_channels, f_number_of_angles, HOA_MAX_PLANEWAVES*2);
CLASS_ATTR_LABEL (c, "angles", 0, "Angles of Channels");
CLASS_ATTR_ACCESSORS (c, "angles", NULL, angles_set);
CLASS_ATTR_ORDER (c, "angles", 0, "2");
// @description Set the angles of each channels in degrees. The angles of channels are only settable in <b>irregular</b> <m>mode</m>. Each angles are in degrees, wrapped between 0. and 360. You must specify 2 values per channel corresponding to the azimuth value followed by the elevation value.
CLASS_ATTR_DOUBLE_ARRAY (c, "offset", ATTR_SET_DEFER_LOW, t_hoa_3d_decoder, f_offsets, 3);
CLASS_ATTR_LABEL (c, "offset", 0, "Offset of Channels");
CLASS_ATTR_ACCESSORS (c, "offset", NULL, offset_set);
CLASS_ATTR_ORDER (c, "offset", 0, "3");
// @description Set the offsets of channels with a list of 2 float values corresponding to the azimuth and elevation offset, in degrees between 0. and 360.
CLASS_ATTR_LONG (c, "channels", ATTR_SET_DEFER_LOW, t_hoa_3d_decoder, f_number_of_channels);
CLASS_ATTR_LABEL (c, "channels", 0, "Number of Channels");
CLASS_ATTR_ACCESSORS (c, "channels", NULL, channel_set);
CLASS_ATTR_ORDER (c, "channels", 0, "4");
// @description The number of channels.
CLASS_ATTR_LONG (c, "crop", 0, t_hoa_3d_decoder, f_cropsize);
CLASS_ATTR_ACCESSORS (c, "crop", NULL, crop_set);
CLASS_ATTR_LABEL (c, "crop", 0, "Crop of the Responses");
CLASS_ATTR_ORDER (c, "crop", 0, "5");
// @description The crop attribute can be used in binaural mode to reduce the CPU usage by cropping the impulse responses (between 0 and 512) 0 means no crop
class_dspinit(c);
class_register(CLASS_BOX, c);
hoa_3d_decoder_class = c;
}
int C74_EXPORT main(void)
{
t_class *c;
c = class_new("hoa.2d.decoder~", (method)hoa_decoder_new, (method)hoa_decoder_free, (long)sizeof(t_hoa_decoder), 0L, A_GIMME, 0);
class_alias(c, gensym("hoa.decoder~"));
hoa_initclass(c, (method)hoa_getinfos);
class_addmethod(c, (method)hoa_decoder_dsp64, "dsp64", A_CANT, 0);
class_addmethod(c, (method)hoa_decoder_assist, "assist", A_CANT, 0);
CLASS_ATTR_LONG (c, "autoconnect", 0, t_hoa_decoder, f_send_config);
CLASS_ATTR_CATEGORY (c, "autoconnect", 0, "Behavior");
CLASS_ATTR_STYLE_LABEL (c, "autoconnect", 0, "onoff", "Auto connection");
CLASS_ATTR_ORDER (c, "autoconnect", 0, "1");
CLASS_ATTR_SAVE (c, "autoconnect", 1);
CLASS_ATTR_SYM (c, "mode", 0, t_hoa_decoder, f_attr);
CLASS_ATTR_CATEGORY (c, "mode", 0, "Planewaves");
CLASS_ATTR_LABEL (c, "mode", 0, "Mode");
CLASS_ATTR_ENUM (c, "mode", 0, "ambisonic binaural irregular");
CLASS_ATTR_ACCESSORS (c, "mode", mode_get, mode_set);
CLASS_ATTR_ORDER (c, "mode", 0, "1");
CLASS_ATTR_SAVE (c, "mode", 1);
CLASS_ATTR_LONG (c, "channels", 0, t_hoa_decoder, f_attr);
CLASS_ATTR_CATEGORY (c, "channels", 0, "Planewaves");
CLASS_ATTR_LABEL (c, "channels", 0, "Number of Channels");
CLASS_ATTR_ACCESSORS (c, "channels", channel_get, channel_set);
CLASS_ATTR_DEFAULT (c, "channels", 0, "4");
CLASS_ATTR_ORDER (c, "channels", 0, "2");
CLASS_ATTR_SAVE (c, "channels", 0);
CLASS_ATTR_DOUBLE (c, "offset", 0, t_hoa_decoder, f_attr);
CLASS_ATTR_CATEGORY (c, "offset", 0, "Planewaves");
CLASS_ATTR_LABEL (c, "offset", 0, "Offset of Channels");
CLASS_ATTR_ACCESSORS (c, "offset", offset_get, offset_set);
CLASS_ATTR_DEFAULT (c, "offset", 0, "0");
CLASS_ATTR_ORDER (c, "offset", 0, "3");
CLASS_ATTR_SAVE (c, "offset", 0);
CLASS_ATTR_DOUBLE_VARSIZE (c, "angles", 0, t_hoa_decoder, f_attr, f_attr, MAX_CHANNELS);
CLASS_ATTR_CATEGORY (c, "angles", 0, "Planewaves");
CLASS_ATTR_LABEL (c, "angles", 0, "Angles of Channels");
CLASS_ATTR_ACCESSORS (c, "angles", angles_get, angles_set);
CLASS_ATTR_ORDER (c, "angles", 0, "4");
CLASS_ATTR_SAVE (c, "angles", 0);
class_dspinit(c);
class_register(CLASS_BOX, c);
hoa_decoder_class = c;
return 0;
}
int TTCLASSWRAPPERMAX_EXPORT main(void)
{
WrappedClassOptionsPtr options = new WrappedClassOptions;
TTValue value;
WrappedClassPtr c = NULL;
TTFoundationInit();
value.clear();
value.append(0);
options->append(TT("fixedNumChannels"), value);
wrapTTClassAsMaxClass(TT("net.send"), "jcom.net.send", &c, options);
CLASS_ATTR_ENUM(c->maxClass, "mode", 0, "tcp udp");
return 0;
}
void jcom_core_subscriber_classinit_extended(t_class *c, t_object *attr, bool define_name)
{
jcom_core_subscriber_classinit_common(c, attr, define_name);
// TODO: The name of the attributes should be substituted for their jps_* symbol pointers.
// ATTRIBUTE: range <low, high>
jamoma_class_attr_array_new(c, "range/bounds", _sym_float32, 2, (method)jcom_core_attr_setrange, (method)jcom_core_attr_getrange);
// ATTRIBUTE: clipmode - options are none, low, high, both, wrap, fold
jamoma_class_attr_new(c, "range/clipmode", _sym_symbol, (method)jcom_core_attr_setclipmode, (method)jcom_core_attr_getclipmode);
CLASS_ATTR_ENUM(c, "range/clipmode", 0, (char*)"none low high both wrap fold");
// ATTRIBUTE: repetitions - 0 means repetitive values are not allowed, 1 means they are
jamoma_class_attr_new(c, "repetitions/allow", _sym_long, (method)jcom_core_attr_setrepetitions, (method)jcom_core_attr_getrepetitions);
// ATTRIBUTE: type
// this is not defined here because some objects (i.e jcom.parameter) need to treat this in different ways
// ATTRIBUTE: description - does nothing, but is accessed by jcom.dispatcher for /autodoc generation
jamoma_class_attr_new(c, "description", _sym_symbol, (method)jcom_core_attr_setdescription, (method)jcom_core_attr_getdescription);
CLASS_ATTR_STYLE(c, "description", 0, "text_onesymbol");
}
int C74_EXPORT main(void)
{
t_class *c;
c = class_new("hoa.recomposer~", (method)HoaRecomposer_new, (method)HoaRecomposer_free, (long)sizeof(t_HoaRecomposer), 0L, A_GIMME, 0);
;
class_addmethod(c, (method)HoaRecomposer_dsp64, "dsp64", A_CANT, 0);
class_addmethod(c, (method)HoaRecomposer_assist, "assist", A_CANT, 0);
class_addmethod(c, (method)HoaRecomposer_angle, "angles", A_GIMME,0);
class_addmethod(c, (method)HoaRecomposer_wide, "directivities", A_GIMME,0);
class_addmethod(c, (method)HoaRecomposer_float, "float", A_FLOAT,0);
CLASS_ATTR_SYM (c,"mode", 0, t_HoaRecomposer, f_mode);
CLASS_ATTR_LABEL (c,"mode", 0, "Mode");
CLASS_ATTR_ENUM (c,"mode", 0, "fixe fisheye free");
CLASS_ATTR_CATEGORY (c,"mode", 0, "Behavior");
CLASS_ATTR_ACCESSORS (c,"mode", NULL, HoaRecomposer_set_attr_mode);
CLASS_ATTR_ORDER (c,"mode", 0, "1");
CLASS_ATTR_SAVE (c,"mode", 1);
CLASS_ATTR_DOUBLE (c,"ramp", 0, t_HoaRecomposer, f_ramp_time);
CLASS_ATTR_LABEL (c,"ramp", 0, "Ramp Time in milliseconds");
CLASS_ATTR_CATEGORY (c,"ramp", 0, "Behavior");
CLASS_ATTR_ACCESSORS (c,"ramp", NULL, HoaRecomposer_ramp);
CLASS_ATTR_ORDER (c,"ramp", 0, "2");
CLASS_ATTR_SAVE (c,"ramp", 1);
class_dspinit(c);
class_register(CLASS_BOX, c);
HoaRecomposer_class = c;
class_findbyname(CLASS_BOX, gensym("hoa.encoder~"));
return 0;
}
int C74_EXPORT main(void)
{
t_class *c;
c = class_new("hoa.decoder~", (method)HoaDecode_new, (method)HoaDecode_free, (long)sizeof(t_HoaDecode), 0L, A_GIMME, 0);
class_addmethod(c, (method)HoaDecode_dsp64, "dsp64", A_CANT, 0);
class_addmethod(c, (method)HoaDecode_assist, "assist", A_CANT, 0);
/* Attribut Global */
CLASS_ATTR_SYM (c, "mode", 0, t_HoaDecode, f_mode);
CLASS_ATTR_CATEGORY (c, "mode", 0, "Behavior");
CLASS_ATTR_LABEL (c, "mode", 0, "Mode");
CLASS_ATTR_ENUM (c, "mode", 0, "ambisonic binaural irregular");
CLASS_ATTR_ACCESSORS (c, "mode", NULL, configuration_set);
CLASS_ATTR_ORDER (c, "mode", 0, "1");
CLASS_ATTR_SAVE (c, "mode", 1);
CLASS_ATTR_LONG (c, "channels", 0, t_HoaDecode, f_number_of_loudspeakers);
CLASS_ATTR_CATEGORY (c, "channels", 0, "Behavior");
CLASS_ATTR_LABEL (c, "channels", 0, "Number of Loudspeakers");
CLASS_ATTR_ACCESSORS (c, "channels", NULL, loudspeakers_set);
CLASS_ATTR_ORDER (c, "channels", 0, "2");
CLASS_ATTR_SAVE (c, "channels", 1);
CLASS_ATTR_ALIAS (c, "channels", "loudspeakers");
CLASS_ATTR_ALIAS (c, "channels", "ychannels");
/* Binaural */
CLASS_ATTR_SYM (c, "pinnaesize", 0, t_HoaDecode, f_pinna_size);
CLASS_ATTR_CATEGORY (c, "pinnaesize", 0, "Behavior");
CLASS_ATTR_LABEL (c, "pinnaesize", 0, "Pinnae Size");
CLASS_ATTR_ENUM (c, "pinnaesize", 0, "small large");
CLASS_ATTR_ACCESSORS (c, "pinnaesize", NULL, pinnaesize_set);
CLASS_ATTR_ORDER (c, "pinnaesize", 0, "4");
CLASS_ATTR_SAVE (c, "pinnaesize", 1);
/* Irregular */
CLASS_ATTR_DOUBLE_VARSIZE (c, "angles", 0, t_HoaDecode, f_angles_of_loudspeakers, f_number_of_loudspeakers, MAX_SPEAKER);
CLASS_ATTR_CATEGORY (c, "angles", 0, "Behavior");
CLASS_ATTR_LABEL (c, "angles", 0, "Angles of Loudspeakers");
CLASS_ATTR_ACCESSORS (c, "angles", NULL, angles_set);
CLASS_ATTR_ORDER (c, "angles", 0, "5");
CLASS_ATTR_SAVE (c, "angles", 1);
CLASS_ATTR_ALIAS (c, "angles", "zchannels");
CLASS_ATTR_SYM (c, "restitution", 0, t_HoaDecode, f_resitution_mode);
CLASS_ATTR_CATEGORY (c, "restitution", 0, "Behavior");
CLASS_ATTR_LABEL (c, "restitution", 0, "Restitution Mode");
CLASS_ATTR_ENUM (c, "restitution", 0, "panning projection");
CLASS_ATTR_ACCESSORS (c, "restitution", NULL, restitution_set);
CLASS_ATTR_ORDER (c, "restitution", 0, "6");
CLASS_ATTR_SAVE (c, "restitution", 1);
CLASS_ATTR_LONG (c, "autoconnect", 0, t_HoaDecode, f_send_config);
CLASS_ATTR_CATEGORY (c, "autoconnect", 0, "Behavior");
CLASS_ATTR_STYLE_LABEL (c, "autoconnect", 0, "onoff", "Auto connection");
CLASS_ATTR_ORDER (c, "autoconnect", 0, "7");
CLASS_ATTR_SAVE (c, "autoconnect", 1);
class_dspinit(c);
class_register(CLASS_BOX, c);
HoaDecode_class = c;
class_findbyname(CLASS_BOX, gensym("hoa.encoder~"));
return 0;
}
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;
}
int JAMOMA_EXPORT_MAXOBJ main(void)
{
long flags;
t_class* c;
long numDataspaces = 0;
t_symbol** dataspaceNames = NULL;
TTValue functionNames;
TTSymbol* functionName;
char dataspaces[2048];
char functions[2048];
char tempstr[64];
short i;
jamoma_init();
common_symbols_init();
jamoma_getDataspaceList(&numDataspaces, &dataspaceNames);
dataspaces[0] = 0;
for(i=0; i<numDataspaces; i++){
strcat(dataspaces, dataspaceNames[i]->s_name);
strcat(dataspaces, " ");
}
FunctionLib::getUnitNames(functionNames);
functions[0] = 0;
for(i=0; i<functionNames.getSize(); i++){
functionNames.get(i, &functionName);
strcat(functions, functionName->getCString());
strcat(functions, " ");
}
c = class_new("jcom.paramui",
(method)paramui_new,
(method)paramui_free,
sizeof(t_paramui),
(method)NULL,
A_GIMME,
0L);
flags = JBOX_TEXTFIELD | JBOX_COLOR;
jbox_initclass(c, flags);
c->c_flags |= CLASS_FLAG_NEWDICTIONARY; // to specify dictionary constructor
class_addmethod(c, (method)paramui_notify, "notify", A_CANT, 0);
class_addmethod(c, (method)paramui_paint, "paint", A_CANT, 0);
class_addmethod(c, (method)paramui_mousedown, "mousedown", A_CANT, 0);
class_addmethod(c, (method)paramui_mousedragdelta, "mousedragdelta", A_CANT, 0);
class_addmethod(c, (method)paramui_mouseup, "mouseup", A_CANT, 0);
class_addmethod(c, (method)paramui_oksize, "oksize", A_CANT, 0);
CLASS_ATTR_DEFAULT(c, "patching_rect", 0, "0. 0. 144. 20.");
CLASS_ATTR_DEFAULT(c, "fontname", 0, JAMOMA_DEFAULT_FONT);
snprintf(tempstr, 64, "%f", JAMOMA_DEFAULT_FONTSIZE);
CLASS_ATTR_DEFAULT(c, "fontsize", 0, tempstr);
CLASS_STICKY_ATTR(c, "category", 0, "Jamoma");
CLASS_ATTR_SYM(c, "name", 0, t_paramui, attr_name);
CLASS_ATTR_LABEL(c, "name", 0, "Parameter Name");
CLASS_ATTR_DEFAULT(c, "name", 0, "my/parameter");
CLASS_ATTR_SAVE(c, "name", 0);
CLASS_ATTR_ACCESSORS(c, "name", paramui_getName, paramui_setName);
CLASS_ATTR_SYM(c, "label", 0, t_paramui, attr_label);
CLASS_ATTR_LABEL(c, "label", 0, "Parameter Label");
CLASS_ATTR_STYLE(c, "label", 0, "text_onesymbol");
CLASS_ATTR_DEFAULT(c, "label", 0, "");
CLASS_ATTR_SAVE(c, "label", 0);
CLASS_ATTR_SYM(c, "type", 0, t_paramui, attr_type);
CLASS_ATTR_LABEL(c, "type", 0, "Data Type");
CLASS_ATTR_ENUM(c, "type", 0, "decimal integer string boolean");
CLASS_ATTR_DEFAULT(c, "type", 0, "decimal");
CLASS_ATTR_SAVE(c, "type", 0);
CLASS_ATTR_ACCESSORS(c, "type", paramui_getType, paramui_setType);
CLASS_ATTR_FLOAT_VARSIZE(c, "value/default", 0, t_paramui, attr_default, attr_defaultSize, LISTSIZE);
CLASS_ATTR_LABEL(c, "value/default", 0, "Default Value");
CLASS_ATTR_DEFAULT(c, "value/default", 0, "0.");
CLASS_ATTR_SAVE(c, "value/default", 0);
CLASS_ATTR_ACCESSORS(c, "value/default", paramui_getDefault, paramui_setDefault);
CLASS_ATTR_SYM(c, "ramp/drive", 0, t_paramui, attr_rampDrive);
CLASS_ATTR_LABEL(c, "ramp/drive", 0, "Ramp Drive");
CLASS_ATTR_DEFAULT(c, "ramp/drive", 0, "none");
CLASS_ATTR_SAVE(c, "ramp/drive", 0);
CLASS_ATTR_ACCESSORS(c, "ramp/drive", paramui_getRampDrive, paramui_setRampDrive);
CLASS_ATTR_SYM(c, "ramp/function", 0, t_paramui, attr_rampFunction);
CLASS_ATTR_LABEL(c, "ramp/function", 0, "Ramp Function/Shape");
CLASS_ATTR_ENUM(c, "ramp/function", 0, functions);
CLASS_ATTR_DEFAULT(c, "ramp/function", 0, "linear");
CLASS_ATTR_SAVE(c, "ramp/function", 0);
CLASS_ATTR_ACCESSORS(c, "ramp/function", paramui_getRampFunction, paramui_setRampFunction);
CLASS_ATTR_LONG(c, "view/freeze", 0, t_paramui, attr_uiFreeze);
CLASS_ATTR_LABEL(c, "view/freeze", 0, "Freeze the UI");
CLASS_ATTR_STYLE(c, "view/freeze", 0, "onoff");
CLASS_ATTR_DEFAULT(c, "view/freeze", 0, "0");
CLASS_ATTR_SAVE(c, "view/freeze", 0);
CLASS_ATTR_ACCESSORS(c, "view/freeze", paramui_getUIFreeze, paramui_setUIFreeze);
CLASS_ATTR_FLOAT(c, "value/stepsize", 0, t_paramui, attr_stepsize);
CLASS_ATTR_LABEL(c, "value/stepsize", 0, "Step Size for inc/dec");
CLASS_ATTR_DEFAULT(c, "value/stepsize", 0, "1.0");
CLASS_ATTR_SAVE(c, "value/stepsize", 0);
CLASS_ATTR_ACCESSORS(c, "value/stepsize", paramui_getStepsize, paramui_setStepsize);
CLASS_ATTR_LONG(c, "priority", 0, t_paramui, attr_priority);
CLASS_ATTR_LABEL(c, "priority", 0, "Priority when Recalled from Presets");
CLASS_ATTR_DEFAULT(c, "priority", 0, "0");
CLASS_ATTR_SAVE(c, "priority", 0);
CLASS_ATTR_ACCESSORS(c, "priority", paramui_getPriority, paramui_setPriority);
CLASS_ATTR_FLOAT_ARRAY(c, "range/bounds", 0, t_paramui, attr_range, 2);
CLASS_ATTR_LABEL(c, "range/bounds", 0, "Range");
CLASS_ATTR_DEFAULT(c, "range/bounds", 0, "0.0 1.0");
CLASS_ATTR_SAVE(c, "range/bounds", 0);
CLASS_ATTR_ACCESSORS(c, "range/bounds", paramui_getRange, paramui_setRange);
CLASS_ATTR_LONG(c, "repetitions/allow", 0, t_paramui, attr_repetitions);
CLASS_ATTR_LABEL(c, "repetitions/allow", 0, "Allow Repeated Values");
CLASS_ATTR_STYLE(c, "repetitions/allow", 0, "onoff");
CLASS_ATTR_DEFAULT(c, "repetitions/allow", 0, "0");
CLASS_ATTR_SAVE(c, "repetitions/allow", 0);
CLASS_ATTR_ACCESSORS(c, "repetitions/allow", paramui_getRepetitions, paramui_setRepetitions);
CLASS_ATTR_SYM(c, "range/clipmode", 0, t_paramui, attr_clipmode);
CLASS_ATTR_LABEL(c, "range/clipmode", 0, "Mode for Clipping to Range");
CLASS_ATTR_ENUM(c, "range/clipmode", 0, "none low high both");
CLASS_ATTR_DEFAULT(c, "range/clipmode", 0, "none");
CLASS_ATTR_SAVE(c, "range/clipmode", 0);
CLASS_ATTR_ACCESSORS(c, "range/clipmode", paramui_getClipmode, paramui_setClipmode);
CLASS_ATTR_SYM(c, "description", 0, t_paramui, attr_description);
CLASS_ATTR_LABEL(c, "description", 0, "Parameter Description");
//CLASS_ATTR_STYLE(c, "description", 0, "text_large");
CLASS_ATTR_STYLE(c, "description", 0, "text_onesymbol");
CLASS_ATTR_DEFAULT(c, "description", 0, "This parameter should do something.");
CLASS_ATTR_SAVE(c, "description", 0);
CLASS_ATTR_ACCESSORS(c, "description", paramui_getDescription, paramui_setDescription);
CLASS_ATTR_SYM(c, "dataspace", 0, t_paramui, attr_dataspace);
CLASS_ATTR_LABEL(c, "dataspace", 0, "Dataspace");
CLASS_ATTR_ENUM(c, "dataspace", 0, dataspaces);
CLASS_ATTR_DEFAULT(c, "dataspace", 0, "none");
CLASS_ATTR_SAVE(c, "dataspace", 0);
CLASS_ATTR_ACCESSORS(c, "dataspace", paramui_getDataspace, paramui_setDataspace);
CLASS_ATTR_SYM(c, "dataspace/unit/active", 0, t_paramui, attr_unitActive);
CLASS_ATTR_LABEL(c, "dataspace/unit/active", 0, "Active Unit within the Dataspace");
CLASS_ATTR_DEFAULT(c, "dataspace/unit/active", 0, "none");
CLASS_ATTR_SAVE(c, "dataspace/unit/active", 0);
CLASS_ATTR_ACCESSORS(c, "dataspace/unit/active", paramui_getUnitActive, paramui_setUnitActive);
CLASS_ATTR_SYM(c, "dataspace/unit/native", 0, t_paramui, attr_unitNative);
CLASS_ATTR_LABEL(c, "dataspace/unit/native", 0, "Native Unit within the Dataspace");
CLASS_ATTR_DEFAULT(c, "dataspace/unit/native", 0, "none");
CLASS_ATTR_SAVE(c, "dataspace/unit/native", 0);
CLASS_ATTR_ACCESSORS(c, "dataspace/unit/native", paramui_getUnitNative, paramui_setUnitNative);
CLASS_STICKY_ATTR_CLEAR(c, "category");
class_register(CLASS_BOX, c);
s_ui_class = c;
sysmem_freeptr(dataspaceNames);
return 0;
}
TTErr wrapTTModularClassAsMaxClass(TTSymbol& ttblueClassName, const char* maxClassName, WrappedClassPtr* c, ModularSpec* specificities)
{
TTObject o;
TTValue v, args;
WrappedClass* wrappedMaxClass = NULL;
TTSymbol TTName;
t_symbol *MaxName = NULL;
TTUInt16 i;
jamoma_init();
common_symbols_init();
if (!wrappedMaxClasses)
wrappedMaxClasses = hashtab_new(0);
wrappedMaxClass = new WrappedClass;
wrappedMaxClass->maxClassName = gensym(maxClassName);
wrappedMaxClass->maxClass = class_new( maxClassName,
(method)wrappedModularClass_new,
(method)wrappedModularClass_free,
sizeof(WrappedModularInstance),
(method)0L,
A_GIMME,
0);
wrappedMaxClass->ttblueClassName = ttblueClassName;
wrappedMaxClass->validityCheck = NULL;
wrappedMaxClass->validityCheckArgument = NULL;
wrappedMaxClass->options = NULL;
wrappedMaxClass->maxNamesToTTNames = hashtab_new(0);
wrappedMaxClass->specificities = specificities;
#ifdef AUDIO_EXTERNAL
// Setup our class to work with MSP
class_dspinit(wrappedMaxClass->maxClass);
#endif
// Create a temporary instance of the class so that we can query it.
o = TTObject(ttblueClassName);
// Register Messages as Max method
o.messages(v);
for (i = 0; i < v.size(); i++)
{
TTName = v[i];
if (TTName == TTSymbol("test") ||
TTName == TTSymbol("getProcessingBenchmark") ||
TTName == TTSymbol("resetBenchmarking"))
continue;
else if ((MaxName = jamoma_TTName_To_MaxName(TTName)))
{
hashtab_store(wrappedMaxClass->maxNamesToTTNames, MaxName, (t_object*)(TTName.rawpointer()));
class_addmethod(wrappedMaxClass->maxClass, (method)wrappedModularClass_anything, MaxName->s_name, A_GIMME, 0);
}
}
// Register Attributes as Max attr
o.attributes(v);
for (i = 0; i < v.size(); i++) {
TTAttributePtr attr = NULL;
t_symbol *maxType = _sym_atom;
TTName = v[i];
#ifdef AUDIO_EXTERNAL
// the enable word is already used by a message declared in the dsp_init method
if (TTName == TTSymbol("enable"))
continue;
#endif
// we want to hide service attribute for Max external
if (TTName == TTSymbol("service"))
continue;
if ((MaxName = jamoma_TTName_To_MaxName(TTName))) {
if (TTName == kTTSym_bypass && wrappedMaxClass->maxClassName != gensym("j.in") && wrappedMaxClass->maxClassName != gensym("j.in~"))
continue;
o.instance()->findAttribute(TTName, &attr);
if (attr->type == kTypeFloat32)
maxType = _sym_float32;
else if (attr->type == kTypeFloat64)
maxType = _sym_float64;
else if (attr->type == kTypeSymbol || attr->type == kTypeString)
maxType = _sym_symbol;
else if (attr->type == kTypeLocalValue)
maxType = _sym_atom;
hashtab_store(wrappedMaxClass->maxNamesToTTNames, MaxName, (t_object*)(TTName.rawpointer()));
class_addattr(wrappedMaxClass->maxClass, attr_offset_new(MaxName->s_name, maxType, 0, (method)wrappedModularClass_attrGet, (method)wrappedModularClass_attrSet, 0));
// Add display styles for the Max 5 inspector
if (attr->type == kTypeBoolean)
CLASS_ATTR_STYLE(wrappedMaxClass->maxClass, (char*)TTName.c_str(), 0, "onoff");
if (TTName == TTSymbol("fontFace"))
CLASS_ATTR_STYLE(wrappedMaxClass->maxClass, "fontFace", 0, "font");
}
}
// standalone support:
class_addmethod(wrappedMaxClass->maxClass, (method)jamoma_fileusage, "fileusage", A_CANT, 0);
class_addmethod(wrappedMaxClass->maxClass, (method)stdinletinfo, "inletinfo", A_CANT, 0);
class_addmethod(wrappedMaxClass->maxClass, (method)wrappedModularClass_notify, "notify", A_CANT, 0);
class_addmethod(wrappedMaxClass->maxClass, (method)wrappedModularClass_shareContextNode, "share_context_node", A_CANT, 0);
class_addmethod(wrappedMaxClass->maxClass, (method)wrappedModularClass_anything, "anything", A_GIMME, 0);
// Register specific methods and do specific things
if (specificities) {
if (specificities->_wrap)
specificities->_wrap(wrappedMaxClass);
}
class_addmethod(wrappedMaxClass->maxClass, (method)wrappedModularClass_dump, "dump", A_GIMME, 0);
#ifdef ARRAY_EXTERNAL
class_addmethod(wrappedMaxClass->maxClass, (method)wrappedModularClass_ArraySelect, "array/select", A_GIMME,0);
class_addmethod(wrappedMaxClass->maxClass, (method)wrappedModularClass_ArrayResize, "array/resize", A_LONG,0);
CLASS_ATTR_SYM(wrappedMaxClass->maxClass, "format", 0, WrappedModularInstance, arrayAttrFormat);
CLASS_ATTR_ACCESSORS(wrappedMaxClass->maxClass, "format", wrappedModularClass_FormatGet, wrappedModularClass_FormatSet);
CLASS_ATTR_ENUM(wrappedMaxClass->maxClass, "format", 0, "single array");
#endif
class_register(_sym_box, wrappedMaxClass->maxClass);
if (c)
*c = wrappedMaxClass;
hashtab_store(wrappedMaxClasses, wrappedMaxClass->maxClassName, (t_object*)(wrappedMaxClass));
return kTTErrNone;
}
