InfoPtr InfoNew(t_symbol* msg, long argc, t_atom* argv)
{
InfoPtr self;
TTValue v;
TTErr err;
self = InfoPtr(object_alloc(sInfoClass));
if (self) {
object_obex_store((TTPtr)self, _sym_dumpout, (t_object*)outlet_new(self, NULL));
self->outletNumChannels = outlet_new((t_pxobject*)self, 0);
self->outletVectorSize = outlet_new((t_pxobject*)self, 0);
self->outletSampleRate = outlet_new((t_pxobject*)self, 0);
self->outletSmartSignal = outlet_new((t_pxobject*)self, "audio.connect");
self->qelem = qelem_new(self, (method)InfoQfn);
v.resize(2);
v[0] = "thru";
v[1] = 1; // we set it up with 1 inlet, and later modify to 2 inlets if the connection is made
err = TTObjectBaseInstantiate(TT("audio.object"), (TTObjectBasePtr*)&self->audioGraphObject, v);
if (!self->audioGraphObject->getUnitGenerator().valid()) {
object_error(SELF, "cannot load Jamoma DSP object");
return NULL;
}
attr_args_process(self, argc, argv);
}
return self;
}
UnpackPtr UnpackNew(SymbolPtr msg, AtomCount argc, AtomPtr argv)
{
UnpackPtr self;
TTValue sr(sys_getsr());
long attrstart = attr_args_offset(argc, argv); // support normal arguments
short i;
TTValue v;
TTErr err;
self = UnpackPtr(object_alloc(sUnpackClass));
if (self) {
self->maxNumChannels = 2; // An initial argument to this object will set the maximum number of channels
if(attrstart && argv)
self->maxNumChannels = atom_getlong(argv);
ttEnvironment->setAttributeValue(kTTSym_sampleRate, sr);
v.setSize(2);
v.set(0, TT("thru"));
v.set(1, 1); // arg is the number of inlets
err = TTObjectBaseInstantiate(TT("audio.object"), (TTObjectBasePtr*)&self->audioGraphObject, v);
//self->audioGraphObject->getUnitGenerator()->setAttributeValue(TT("linearGain"), 1.0);
attr_args_process(self, argc, argv);
object_obex_store((void*)self, _sym_dumpout, (object*)outlet_new(self, NULL)); // dumpout
dsp_setup((t_pxobject*)self, 1);
for(i=0; i < self->maxNumChannels; i++)
outlet_new((t_pxobject*)self, "signal");
self->qelem = qelem_new(self, (method)UnpackQFn);
self->obj.z_misc = Z_NO_INPLACE | Z_PUT_LAST;
}
return self;
}
void *freeverb_new(t_symbol *s, long argc, t_atom *argv)
{
t_freeverb *x = NULL;
int aSide = 0;
x = ((t_freeverb *)object_alloc(freeverb_class));
if (x)
{
if(atom_gettype(argv) == A_LONG)
aSide = atom_getlong(argv);
else if(atom_gettype(argv) == A_FLOAT)
aSide = atom_getfloat(argv);
else if(atom_gettype(argv) == A_SYM)
{
if(atom_getsym(argv) == gensym("right"))
aSide = 1;
}
if(aSide <= 0)
aSide = 0;
x->f_freeverb = new Freeverb(aSide);
dsp_setup((t_pxobject *)x, 1);
outlet_new(x, "signal");
attr_args_process(x, argc, argv);
}
return (x);
}
void WrappedMapperClass_new(TTPtr self, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
t_symbol *relativeAddress;
long attrstart = attr_args_offset(argc, argv); // support normal arguments
// possible relativeAddress
if (attrstart && argv)
relativeAddress = atom_getsym(argv);
else
relativeAddress = _sym_nothing;
if (relativeAddress) x->address = TTAddress(relativeAddress->s_name);
jamoma_mapper_create((t_object*)x, x->wrappedObject);
// Make two outlets
x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr));
x->outlets[data_out] = outlet_new((t_object*)x, NULL); // anything outlet to output data
x->dumpOut = outlet_new((t_object*)x, NULL);
// handle attribute args
attr_args_process(x, argc, argv);
// Prepare extra data
x->extra = (t_extra*)malloc(sizeof(t_extra));
EXTRA->arguments = new TTValue();
jamoma_ttvalue_from_Atom(*EXTRA->arguments, _sym_nothing, argc, argv);
// The following must be deferred because we have to interrogate our box,
// and our box is not yet valid until we have finished instantiating the object.
// Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6)
// map_subscribe(x);
// defer_low((t_object*)x, (method)map_subscribe, NULL, 0, 0);
}
void *radians_new(t_symbol *msg, short argc, t_atom *argv)
{
t_atom_long myArg = 0;
long attrstart;
t_radians *x;
attrstart = attr_args_offset(argc, argv);
if(attrstart && argv)
atom_arg_getlong(&myArg, 0, attrstart, argv); // support a normal int argument for bwc
x = (t_radians *)object_alloc(radians_class);;
if(x){
object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x,NULL)); // dumpout
dsp_setup((t_pxobject *)x,1);
x->radians_out = floatout(x); // Create a floating-point Outlet
outlet_new((t_object *)x, "signal");
x->tt = new tt_audio_base; // Create object for performing radian conversions
x->tt->set_sr(sys_getsr());
x->radians_mode = myArg; // default mode
attr_args_process(x, argc, argv); //handle attribute args
}
return (x);
}
void* balance_new(t_symbol *msg, short argc, t_atom *argv)
{
t_balance *x;
TTValue sr(sys_getsr());
long attrstart = attr_args_offset(argc, argv); // support normal arguments
short i;
x = (t_balance *)object_alloc(balance_class);
if(x){
// Default values
x->attrFrequency = 10;
x->attrBypass = 0;
// An initial argument to this object will set the maximum number of channels to process
// Two input channels are required for each processed channel (source and comperator)
x->maxNumChannels = 1;
if(attrstart && argv)
x->maxNumChannels = atom_getlong(argv);
ttEnvironment->setAttributeValue(kTTSym_SampleRate, sr);
TTObjectInstantiate(TT("balance"), &x->balance, x->maxNumChannels);
TTObjectInstantiate(TT("audiosignal"), &x->audioIn, x->maxNumChannels*2);
TTObjectInstantiate(TT("audiosignal"), &x->audioOut, x->maxNumChannels);
attr_args_process(x,argc,argv); // handle attribute args
object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x,NULL)); // dumpout
dsp_setup((t_pxobject *)x, x->maxNumChannels*2); // inlets
for(i=0; i < x->maxNumChannels; i++)
outlet_new((t_pxobject *)x, "signal"); // outlets
x->obj.z_misc = Z_NO_INPLACE;
}
return (x); // Return the pointer
}
MidiOutPtr MidiOutNew(SymbolPtr msg, AtomCount argc, AtomPtr argv)
{
MidiOutPtr self;
TTValue v;
TTErr err;
self = MidiOutPtr(object_alloc(sMidiOutClass));
if (self) {
object_obex_store((void*)self, _sym_dumpout, (ObjectPtr)outlet_new(self, NULL)); // dumpout
self->graphOutlets[0] = outlet_new(self, "graph.connect");
v.setSize(2);
v.set(0, TT("midi.out"));
v.set(1, TTUInt32(1));
err = TTObjectBaseInstantiate(TT("graph.object"), (TTObjectBasePtr*)&self->graphObject, v);
if (!self->graphObject->mKernel) {
object_error(SELF, "cannot load Jamoma object");
return NULL;
}
attr_args_process(self, argc, argv);
}
return self;
}
// Create
void *fade_new(t_symbol *s, long argc, t_atom *argv)
{
long attrstart = attr_args_offset(argc, argv); // support normal arguments
short i;
t_fade *x = (t_fade *)object_alloc(s_fade_class);
if(x){
object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x, NULL)); // dumpout
x->numChannels = 1;
if(attrstart && argv){
int argument = atom_getlong(argv);
x->numChannels = TTClip(argument, 1, MAX_NUM_CHANNELS);
}
dsp_setup((t_pxobject *)x, (x->numChannels * 2) + 1); // Create Object and N Inlets (last argument)
x->x_obj.z_misc = Z_NO_INPLACE; // ESSENTIAL!
for(i=0; i< (x->numChannels); i++)
outlet_new((t_pxobject *)x, "signal"); // Create a signal Outlet
//x->xfade = new TTCrossfade(x->numChannels); // Constructors
TTObjectBaseInstantiate(TT("crossfade"), &x->xfade, x->numChannels);
TTObjectBaseInstantiate(kTTSym_audiosignal, &x->audioIn1, x->numChannels);
TTObjectBaseInstantiate(kTTSym_audiosignal, &x->audioIn2, x->numChannels);
TTObjectBaseInstantiate(kTTSym_audiosignal, &x->audioInControl, x->numChannels);
TTObjectBaseInstantiate(kTTSym_audiosignal, &x->audioOut, x->numChannels);
x->xfade->setAttributeValue(TT("mode"), TT("lookup"));
x->xfade->setAttributeValue(TT("shape"), TT("equalPower"));
x->xfade->setAttributeValue(TT("position"), 0.5);
attr_args_process(x, argc, argv); // handle attribute args
}
return (x); // Return the pointer
}
AppendPtr AppendNew(t_symbol* msg, long argc, t_atom* argv)
{
AppendPtr self;
TTValue v;
TTErr err;
self = AppendPtr(object_alloc(sAppendClass));
if (self) {
object_obex_store((void*)self, _sym_dumpout, (t_object*)outlet_new(self, NULL)); // dumpout
self->graphOutlets[0] = outlet_new(self, "graph.connect");
v.resize(2);
v[0] = "dictionary.append";
v[1] = 1;
err = TTObjectBaseInstantiate(TT("graph.object"), (TTObjectBasePtr*)&self->graphObject, v);
if (!self->graphObject->mKernel.valid()) {
object_error(SELF, "cannot load Jamoma object");
return NULL;
}
attr_args_process(self, argc, argv);
}
return self;
}
UnpackPtr UnpackNew(SymbolPtr msg, AtomCount argc, AtomPtr argv)
{
UnpackPtr self;
TTValue v;
TTErr err;
self = UnpackPtr(object_alloc(sUnpackClass));
if (self) {
object_obex_store((void*)self, _sym_dumpout, (ObjectPtr)outlet_new(self, NULL)); // dumpout
self->graphOutlets[0] = outlet_new(self, NULL);
v.setSize(2);
v.set(0, TT("graph.output"));
v.set(1, TTUInt32(1));
err = TTObjectInstantiate(TT("graph.object"), (TTObjectPtr*)&self->graphObject, v);
if (!self->graphObject->mKernel) {
object_error(SELF, "cannot load Jamoma object");
return NULL;
}
err = TTObjectInstantiate(TT("Callback"), (TTObjectPtr*)&self->callback, kTTValNONE);
self->callback->setAttributeValue(TT("Function"), TTPtr(&UnpackGraphCallback));
self->callback->setAttributeValue(TT("Baton"), TTPtr(self));
// dynamically add a message to the callback object so that it can handle the 'dictionaryReceived' notification
self->callback->registerMessage(TT("dictionaryReceived"), (TTMethod)&TTCallback::notify, kTTMessagePassValue);
// tell the graph object that we want to watch it
self->graphObject->mKernel->registerObserverForNotifications(*self->callback);
attr_args_process(self, argc, argv);
}
return self;
}
UnpackPtr UnpackNew(t_symbol *msg, long argc, t_atom* argv)
{
UnpackPtr self;
TTValue v, none;
TTErr err;
self = UnpackPtr(object_alloc(sUnpackClass));
if (self) {
object_obex_store((void*)self, _sym_dumpout, (t_object*)outlet_new(self, NULL)); // dumpout
self->graphOutlets[0] = outlet_new(self, NULL);
v.resize(2);
v[0] = "graph.output";
v[1] = 1;
err = TTObjectBaseInstantiate(TT("graph.object"), (TTObjectBasePtr*)&self->graphObject, v);
if (!self->graphObject->mKernel.valid()) {
object_error(SELF, "cannot load Jamoma object");
return NULL;
}
self->callback = new TTObject("callback");
self->callback->set(TT("function"), TTPtr(&UnpackGraphCallback));
self->callback->set(TT("baton"), TTPtr(self));
// Dynamically add a message to the callback object so that it can handle the 'dictionaryReceived' notification
self->callback->instance()->registerMessage(TT("dictionaryReceived"), (TTMethod)&TTCallback::notify, kTTMessagePassValue);
// Tell the graph object that we want to watch it
self->graphObject->mKernel.registerObserverForNotifications(*self->callback);
attr_args_process(self, argc, argv);
}
return self;
}
void *shift_new(t_symbol *msg, long argc, t_atom *argv)
{
t_shift *x = (t_shift *)object_alloc(shift_class);;
short i;
if(x){
object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x,NULL)); // dumpout
dsp_setup((t_pxobject *)x, 3); // Create Object and 3 Inlets
x->x_obj.z_misc = Z_NO_INPLACE; // ESSENTIAL?
outlet_new((t_pxobject *)x, "signal"); // Create a signal Outlet
tt_audio_base::set_global_sr(sys_getsr()); // Set Tap.Tools global SR...
tt_audio_base::set_global_vectorsize(sys_getblksize()); // Set Tap.Tools global vector size...
x->shifter = new tt_shift;
for(i=0; i<NUM_INPUTS; i++)
x->signal_in[i] = new tt_audio_signal;
for(i=0; i<NUM_OUTPUTS; i++)
x->signal_out[i] = new tt_audio_signal;
// Set initial state
x->attr_ratio = 1.0;
x->attr_window_size = 87.0;
attr_args_process(x,argc,argv); //handle attribute args
}
return (x); // Return the pointer
}
void *bezier_new(t_symbol *s, short ac, t_atom *av)
{
// t_bezier *x;
// x = (t_bezier *)newobject(bezier_class);
t_bezier *x;
x = (t_bezier *)object_alloc(bezier_class);
if(x){
x->b_outletRight = bangout(x);
x->b_outlet = outlet_new(x, 0);
x->b_mode = 0;
x->b_last = 1;
x->b_steps = 32;
attr_args_process(x, ac, av); // process attributes
// if ((arg1)&&(arg1 <= 2)){
// x->b_steps = 2;
// }
// else if(arg1){
// x->b_steps = arg1;
// }
// if ((arg2)&&(arg2 == 0)){
// x->b_last = 0;
// }
// else if((arg2)&&(arg2 != 0)){
// x->b_last = 1;
// }
}
return x;
}
void *irextract_new (t_symbol *s, short argc, t_atom *argv)
{
t_irextract *x = (t_irextract *)object_alloc (this_class);
x->process_done = bangout(x);
init_HIRT_common_attributes(x);
x->bandlimit = 1;
x->amp = -1;
x->inv_amp = 0;
x->fft_size = 0;
x->sample_rate = 0;
x->out_length_samps = 0;
x->out_length = 0;
x->gen_length = 0;
alloc_mem_swap(&x->out_mem, 0, 0);
x->measure_mode = SWEEP;
attr_args_process(x, argc, argv);
return(x);
}
void *dict_route_new(t_symbol *s, long argc, t_atom *argv)
{
t_dict_route *x = (t_dict_route *)object_alloc(s_dict_route_class);
long attrstart = attr_args_offset(argc, argv);
t_dictionary *d = NULL; // dictionary with our 'prototype' specified by args to this object
if (x) {
x->outlet_nomatch = outlet_new(x, "dictionary");
x->outlet_dict = outlet_new(x, "dictionary");
x->inlet_tomatch = proxy_new(x, 1, &x->inletnum);
if (attrstart)
dictobj_dictionaryfromatoms(&d, attrstart, argv);
if (!d) {
char errorstring[256];
t_max_err err;
err = dictobj_dictionaryfromstring(&d, "{ \"schema\" : \"*\" }", true, errorstring);
if (err)
error("dict.route: %s", errorstring);
}
x->schema_dict = dictobj_register(d, &x->schema_name);
attr_args_process(x, argc, argv);
}
return x;
}
void *HoaOptim_new(t_symbol *s, long argc, t_atom *argv)
{
t_HoaOptim *x = NULL;
t_dictionary *d = NULL;
int order = 4;
x = (t_HoaOptim *)object_alloc(HoaOptim_class);
if (x)
{
if(atom_gettype(argv) == A_LONG)
order = atom_getlong(argv);
x->f_optim_mode = gensym("inPhase");
x->f_AmbisonicsOptim = new AmbisonicOptim(order, Hoa_InPhase_Optim, sys_getblksize());
dsp_setup((t_pxobject *)x, x->f_AmbisonicsOptim->getNumberOfInputs());
for (int i = 0; i < x->f_AmbisonicsOptim->getNumberOfOutputs(); i++)
outlet_new(x, "signal");
x->f_ob.z_misc = Z_NO_INPLACE;
d = (t_dictionary *)gensym("#D")->s_thing;
if (d) attr_dictionary_process(x, d);
attr_args_process(x, argc, argv);
}
return (x);
}
void *envExp_new(Symbol *s, long argc, t_atom *argv)
{
//create the new instance and returns a pointer to it
t_envExp *x = (t_envExp *)object_alloc(this_class);
//post("new");
if (x) {
//post("new_x");
// dumpout
object_obex_store((void *)x, jps_dumpout, (object *)outlet_new(x,NULL));
// create outlet
x->outlet =outlet_new(x, 0L);
//Initialisation of attributes
x->attr_attack = 10;
x->attr_amplitude = 1.;
x->attr_decayrate = 90.;
x->attr_threshold = -90;
x->attr_steal = 1;
// handle attribute args
attr_args_process(x,argc,argv);
envExp_calculate(x);
}
return(x); //must return a pointer to the new instance
}
PackPtr PackNew(t_symbol* msg, long argc, t_atom* argv)
{
PackPtr self;
TTValue v;
TTErr err;
self = PackPtr(object_alloc(sPackClass));
if (self) {
object_obex_store((void*)self, _sym_dumpout, (t_object*)outlet_new(self, NULL));
self->graphOutlets[0] = outlet_new(self, "graph.connect");
v.resize(2);
v[0] = "graph.input";
v[1] = 1;
err = TTObjectBaseInstantiate(TT("graph.object"), (TTObjectBasePtr*)&self->graphObject, v);
((TTGraphInput*)self->graphObject->mKernel.instance())->setOwner(self->graphObject);
if (!self->graphObject->mKernel.valid()) {
object_error(SELF, "cannot load Jamoma object");
return NULL;
}
self->graphDictionary = new TTDictionary;
self->graphDictionary->setSchema(TT("none"));
self->graphDictionary->append(TT("outlet"), 0);
attr_args_process(self, argc, argv);
self->qelem = qelem_new(self, (method)PackQFn);
// PackStartTracking(self);
defer_low(self, (method)PackStartTracking, NULL, 0, NULL);
}
return self;
}
PackPtr PackNew(SymbolPtr msg, AtomCount argc, AtomPtr argv)
{
PackPtr self;
TTValue v;
TTErr err;
self = PackPtr(object_alloc(sPackClass));
if (self) {
object_obex_store((void*)self, _sym_dumpout, (ObjectPtr)outlet_new(self, NULL));
self->graphOutlets[0] = outlet_new(self, "graph.connect");
v.setSize(2);
v.set(0, TT("graph.input"));
v.set(1, TTUInt32(1));
err = TTObjectInstantiate(TT("graph.object"), (TTObjectPtr*)&self->graphObject, v);
((TTGraphInput*)self->graphObject->mKernel)->setOwner(self->graphObject);
if (!self->graphObject->mKernel) {
object_error(SELF, "cannot load Jamoma object");
return NULL;
}
self->graphDictionary = new TTDictionary;
self->graphDictionary->setSchema(TT("none"));
self->graphDictionary->append(TT("outlet"), 0);
attr_args_process(self, argc, argv);
self->qelem = qelem_new(self, (method)PackQFn);
// PackStartTracking(self);
defer_low(self, (method)PackStartTracking, NULL, 0, NULL);
}
return self;
}
OpPtr OpNew(SymbolPtr msg, AtomCount argc, AtomPtr argv)
{
OpPtr self;
TTValue v;
TTErr err;
self = OpPtr(object_alloc(sOpClass));
if (self) {
object_obex_store((void*)self, _sym_dumpout, (ObjectPtr)outlet_new(self, NULL)); // dumpout
self->outlet = outlet_new(self, "audio.connect");
self->inlet = proxy_new(self, 1, &self->inletnum);
v.setSize(2);
v.set(0, TT("operator"));
v.set(1, TTUInt32(1)); // we set it up with 1 inlet, and later modify to 2 inlets if the connection is made
err = TTObjectInstantiate(TT("audio.object"), (TTObjectPtr*)&self->audioGraphObject, v);
if (!self->audioGraphObject->getUnitGenerator()) {
object_error(SELF, "cannot load Jamoma DSP object");
return NULL;
}
attr_args_process(self, argc, argv);
}
return self;
}
void *HoaRecomposer_new(t_symbol *s, long argc, t_atom *argv)
{
t_HoaRecomposer *x = NULL;
t_dictionary *d;
int order = 4, inputs = 10;
x = (t_HoaRecomposer *)object_alloc((t_class*)HoaRecomposer_class);
if (x)
{
if(atom_gettype(argv) == A_LONG)
order = atom_getlong(argv);
if(atom_gettype(argv+1) == A_LONG)
inputs = atom_getlong(argv+1);
/* Base Attributes */
x->f_ambiRecomposer = new AmbisonicRecomposer(order, inputs, Hoa_Fixe, sys_getblksize(), sys_getsr());
x->f_ambiRecomposer->setRampInMs(20.);
x->f_ramp_time = x->f_ambiRecomposer->getRampInMs();
x->f_mode = gensym("fixe");
dsp_setup((t_pxobject *)x, x->f_ambiRecomposer->getNumberOfInputs());
for (int i = 0; i < x->f_ambiRecomposer->getNumberOfOutputs(); i++)
outlet_new(x, "signal");
x->f_ob.z_misc = Z_NO_INPLACE;
attr_args_process(x, argc, argv);
d = (t_dictionary *)gensym("#D")->s_thing;
if (d) attr_dictionary_process(x, d);
object_attr_setdisabled((t_object *)x, gensym("ramp"), (x->f_mode == gensym("fixe")) ? 1 : 0);
}
return (x);
}
void *dpoltocar_new(t_symbol *s, short ac, t_atom *av)
{
t_dpoltocar *x;
x = (t_dpoltocar *)object_alloc(dpoltocar_class);
if(x) {
x->d_outlet = listout(x);
t_ptr_size attrstart = attr_args_offset(ac, av); // support normal arguments
if((attrstart != 0) && (av)) {
int argument = atom_getlong(&av[0]);
if(argument == 0){
x->d_mode = 0;
}else{
x->d_mode = 1;
}
}
object_attr_setlong(x, gensym("mode"), x->d_mode);
attr_args_process(x, ac, av);
x->d_operational[0]=0;
x->d_operational[1]=0;
x->d_operational[2]=0;
}
return x;
}
// Create
void *audiosend_new(t_symbol *s, long argc, t_atom *argv)
{
long attrstart = attr_args_offset(argc, argv); // support normal arguments
t_audiosend *x = (t_audiosend *)object_alloc(s_audiosend_class);
short i;
if (x) {
x->dumpout = outlet_new(x, NULL);
object_obex_store(x, _sym_dumpout, (t_object *)x->dumpout);
x->attr_target = _sym_nothing;
x->num_inputs = 2; // TODO: make this dynamic from args
for (i=0; i<attrstart; i++) {
if (argv[i].a_type == A_LONG)
x->num_inputs = atom_getlong(argv+i);
else if (argv[i].a_type == A_SYM)
x->attr_target = atom_getsym(argv+i);
}
dsp_setup((t_pxobject *)x, x->num_inputs);
x->obj.z_misc = Z_NO_INPLACE;
attr_args_process(x, argc, argv); // handle attribute args
}
return x;
}
void *legion_new(t_symbol *msg, short argc, t_atom *argv){
t_legion *x = NULL;
if(x = (t_legion *)object_alloc(legion_class)){
object_obex_store(x, _sym_dumpout, outlet_new(x, NULL));
x->t_out = listout(x);
x->t_kappa = 1.0;
x->t_lambda = 0.5;
x->t_temperature = 0.0;
x->t_learningRate = 0.3;
x->t_entrainmentRate = 0.3;
x->t_radius = 3.0;
x->t_epoch = 0;
//x->t_neighborhoodFunction = legion_gaussian;
legion_setneighborhoodFunction(x, gensym("gaussian"));
x->t_nfParam = 1.0;
x->t_learn = 1;
x->t_numColumns = 10;
x->t_numRows = 10;
x->t_vectorLength = 10;
x->t_randMin = 0.;
x->t_randMax = 10.;
attr_args_process(x, argc, argv);
legion_init(x);
}
return x;
}
void data_new_address(TTPtr self, t_symbol *relativeAddress, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
// create the data
#ifdef JMOD_MESSAGE
jamoma_data_create((t_object*)x, x->wrappedObject, kTTSym_message);
#endif
#if JMOD_RETURN
jamoma_data_create((t_object*)x, x->wrappedObject, kTTSym_return);
#endif
#ifndef JMOD_MESSAGE
#ifndef JMOD_RETURN
jamoma_data_create((t_object*)x, x->wrappedObject, kTTSym_parameter);
#endif
#endif
if (argc && argv)
attr_args_process(x, argc, argv);
// The following must be deferred because we have to interrogate our box,
// and our box is not yet valid until we have finished instantiating the object.
// Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6)
defer_low((t_object*)x, (method)data_subscribe, relativeAddress, argc, argv);
}
DCBlockPtr DCBlockNew(t_symbol* msg, long argc, t_atom* argv)
{
DCBlockPtr self;
TTValue v;
TTErr err;
self = (DCBlockPtr)object_alloc(sDCBlockClass);
if (self) {
object_obex_store((void*)self, _sym_dumpout, (t_object*)outlet_new(self, NULL));
self->audioGraphOutlet = outlet_new(self, "audio.connect");
// TODO: we need to update objects to work with the correct number of channels when the network is configured
// Either that, or when we pull we just up the number of channels if when we need to ???
v.resize(2);
v[0] = "dcblock";
v[1] = 1;
err = TTObjectBaseInstantiate(TT("audio.object"), (TTObjectBasePtr*)&self->audioGraphObject, v);
if (!self->audioGraphObject->getUnitGenerator().valid()) {
object_error(SELF, "cannot load JamomaDSP object");
return NULL;
}
attr_args_process(self, argc, argv);
}
return self;
}
void *ramp_new(t_symbol *s, long argc, t_atom *argv)
{
t_ramp *x = (t_ramp *)object_alloc(ramp_class);
if (x) {
x->outlets[k_outlet_dumpout] = outlet_new(x, 0L);
x->outlets[k_outlet_value] = outlet_new(x, 0L);
object_obex_store((void *)x, _sym_dumpout, (t_object *)x->outlets[k_outlet_dumpout]);
x->parameterNames = new TTHash;
x->rampUnit = NULL;
// Set default attributes
// @drive
Atom a;
atom_setsym(&a, gensym("scheduler"));
object_attr_setvalueof(x, gensym("drive"), 1, &a);
// @function
object_attr_setsym(x, gensym("function"), jps_linear);
// Now set specified attributes, if any
attr_args_process(x, argc, argv);
}
return (x); // return the pointer to our new instantiation
}
t_ww *ww_new(t_symbol *s, short argc, t_atom *argv)
{
t_ww *x = NULL;
t_object *box = NULL;
x = (t_ww *)object_alloc(s_ww_class);
if (x) {
x->w_outlet = outlet_new(x, 0L);
attr_args_process(x, argc, argv);
object_obex_lookup(x, gensym("#P"), &x->w_patcher);
object_obex_lookup(x, gensym("#B"), &box);
// If/when instance methods are supported, we can use object_addmethod() to add the method
// (as opposed to a class method) to our box.
// Then we can be called when our box is moved.
object_addmethod(box, (method)ww_boxscreenrectchanged, "boxscreenrectchanged", A_CANT, 0);
// The patcherview is not available when the object is created as a patcher is being read from disk,
// so we have to defer to wait for it before getting it and attaching for notifications.
// if we were in a ui object then we would instead add a 'patcherview_vis' method
// (and possibly a 'patcherview_invis' method) and attach to our patcherview at that time.
defer_low(x, (method)ww_attach, NULL, 0, NULL);
}
return x;
}
void* op_new(t_symbol *msg, short argc, t_atom *argv)
{
t_op *x;
TTValue sr(sys_getsr());
long attrstart = attr_args_offset(argc, argv); // support normal arguments
short i;
x = (t_op *)object_alloc(s_op_class);
if(x){
x->maxNumChannels = 2; // An initial argument to this object will set the maximum number of channels
if(attrstart && argv)
x->maxNumChannels = atom_getlong(argv);
ttEnvironment->setAttributeValue(kTTSym_sampleRate, sr);
TTObjectBaseInstantiate(TT("operator"), &x->op, x->maxNumChannels);
TTObjectBaseInstantiate(TT("audiosignal"), &x->audioIn, x->maxNumChannels);
TTObjectBaseInstantiate(TT("audiosignal"), &x->audioOut, x->maxNumChannels);
attr_args_process(x,argc,argv); // handle attribute args
object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x,NULL)); // dumpout
dsp_setup((t_pxobject *)x, x->maxNumChannels); // inlets
for(i=0; i < x->maxNumChannels; i++)
outlet_new((t_pxobject *)x, "signal"); // outlets
x->obj.z_misc = Z_NO_INPLACE;
}
return (x); // Return the pointer
}
void *HoaConvolve_new(t_symbol *s, long argc, t_atom *argv)
{
t_HoaConvolve *x = NULL;
long order = 4;
x = (t_HoaConvolve *)object_alloc((t_class*)HoaConvolve_class);
if (x)
{
if(atom_gettype(argv) == A_LONG)
order = atom_getlong(argv);
if(order < 1)
order = 1;
x->f_ambiConvolve = new AmbisonicConvolver(order, sys_getsr(), sys_getblksize());
x->f_numberOfHarmonics = x->f_ambiConvolve->getNumberOfHarmonics();
x->f_buffer = NULL;
dsp_setup((t_pxobject *)x, x->f_ambiConvolve->getNumberOfInputs());
for (int i = 0; i < x->f_ambiConvolve->getNumberOfOutputs(); i++)
outlet_new(x, "signal");
x->f_ob.z_misc = Z_NO_INPLACE;
attr_args_process(x, argc, argv);
buffer_setup(x);
}
return (x);
}
