diff --git a/.gitignore b/.gitignore index 0321173..afb674a 100644 --- a/.gitignore +++ b/.gitignore @@ -13,5 +13,9 @@ env/ *.egg .venv/ +# Generated by import_objs() +maxpylang/data/OBJ_INFO/ +maxpylang/data/OBJ_ALIASES/ + # macOS .DS_Store diff --git a/maxpylang/__init__.py b/maxpylang/__init__.py index e82cb32..99a2854 100644 --- a/maxpylang/__init__.py +++ b/maxpylang/__init__.py @@ -1,5 +1,192 @@ +""" +maxpylang - Python library for programmatically creating and editing Max/MSP patches (.maxpat files). + +Quick Start:: + + import maxpylang as mp + + patch = mp.MaxPatch() + osc = patch.place("cycle~ 440")[0] + dac = patch.place("ezdac~")[0] + patch.connect([osc.outs[0], dac.ins[0]]) + patch.save("hello_world") + +Core API +-------- + +**MaxPatch**:: + + patch = mp.MaxPatch(template=None, load_file=None, reorder=True, verbose=True) + + patch.place(*objs, num_objs=1, spacing_type="grid", spacing=[80,80], + starting_pos=None, verbose=False) -> list[MaxObject] + patch.connect(*connections, verbose=True) + patch.save(filename="default.maxpat", verbose=True, check=True) + patch.set_position(new_x, new_y) + +- ``place()`` **always returns a list** — use ``[0]`` for a single object. +- Each connection is ``[outlet, inlet]``: ``patch.connect([obj1.outs[0], obj2.ins[0]])``. +- ``save()`` auto-appends ``.maxpat`` if missing. + +Properties: ``patch.objs`` (dict), ``patch.num_objs`` (int), ``patch.curr_position`` (list). + +**MaxObject**:: + + obj = mp.MaxObject("cycle~ 440") + obj = mp.MaxObject("metro 500 @active 1") # with attributes + +Properties: ``obj.name``, ``obj.ins`` (list of Inlets, 0-indexed), ``obj.outs`` (list of Outlets, 0-indexed). + +Methods: ``obj.edit(text_add="append", text=None, **extra_attribs)``, ``obj.move(x, y)``. + +Stub Objects +------------ + +Pre-instantiated MaxObject stubs for IDE autocomplete:: + + from maxpylang.objects import cycle_tilde, ezdac_tilde, metro, toggle + +Naming rules: + +- ``~`` becomes ``_tilde`` (``cycle~`` → ``cycle_tilde``) +- ``.`` becomes ``_`` (``jit.movie`` → ``jit_movie``) +- ``-`` becomes ``_`` (``live.dial`` → ``live_dial``) +- Leading digit gets ``_`` prefix (``2d.wave~`` → ``_2d_wave_tilde``) +- Python keywords get ``_`` suffix (``in`` → ``in_``) + +Stubs have no arguments. Use string syntax when arguments are needed:: + + osc = patch.place("cycle~ 440")[0] # string: has arguments + dac = patch.place(ezdac_tilde)[0] # stub: no arguments needed + +Available Objects +----------------- + +All valid object names are in ``maxpylang/objects/`` (stubs by package: ``max.py``, ``msp.py``, ``jit.py``). + +Common objects by category: + +- **Audio sources**: cycle~, noise~, pink~, rect~, saw~, tri~, phasor~ +- **Audio I/O**: adc~, dac~, ezdac~, ezadc~ +- **Audio processing**: gain~, lores~, reson~, biquad~, delay~, tapin~, tapout~ +- **Math (audio)**: +~, *~, -~, /~, clip~, abs~, scale~ +- **Control**: metro, counter, toggle, button, number, flonum, dial +- **Routing**: gate, switch, route, select, trigger, pack, unpack +- **Data**: coll, dict, table, buffer~, preset +- **MIDI**: notein, noteout, ctlin, ctlout, midiin, midiout +- **UI**: multislider, slider, comment, message, panel, live.dial +- **Timing**: delay, pipe, timer, transport, tempo +- **Math (control)**: +, *, -, /, %, random, drunk, scale + +Common Patterns +--------------- + +Audio chain:: + + from maxpylang.objects import gain_tilde, ezdac_tilde + + patch = mp.MaxPatch() + osc = patch.place("cycle~ 440")[0] + gain = patch.place(gain_tilde)[0] + dac = patch.place(ezdac_tilde)[0] + patch.connect([osc.outs[0], gain.ins[0]], + [gain.outs[0], dac.ins[0]], + [gain.outs[0], dac.ins[1]]) + patch.save("audio_chain") + +Multiple objects with loops:: + + n = 10 + toggles = patch.place("toggle", num_objs=n, starting_pos=[0, 100]) + gates = patch.place("gate", num_objs=n, starting_pos=[0, 200]) + + for t, g in zip(toggles, gates): + patch.connect([t.outs[0], g.ins[0]]) + +Attributes via @ syntax:: + + patch.place("metro 500 @active 1")[0] + patch.place("jit.movie @moviefile crashtest.mov")[0] + +Loading existing patches:: + + patch = mp.MaxPatch(load_file="existing.maxpat") + for key, obj in patch.objs.items(): + print(obj.name) + patch.save("modified") + +Abstractions +------------ + +For custom Max abstractions (sub-patches), use ``abstraction=True`` to declare +objects without needing the ``.maxpat`` file in the current directory:: + + # Declare abstraction with known I/O (file doesn't need to exist) + synth = mp.MaxObject("my_synth", abstraction=True, inlets=2, outlets=2) + + # Then place it in a patch + patch.place(synth) + + # If the file exists in cwd, auto-detection still works as before + synth = mp.MaxObject("my_synth") + +Key Rules +--------- + +- ``place()`` **always returns a list** — use ``[0]`` for single objects. +- Object names are **case-sensitive** and must match Max names exactly. +- Coordinates are floats. Inlet/outlet indices are **0-based**. +- ``save()`` auto-appends ``.maxpat``. ``verbose=False`` suppresses console output. +- **Typos raise UnknownObjectWarning** — if you see this warning, fix the object name + immediately. The object will have 0 inlets/outlets and won't work. + Use ``obj.notknown()`` to check programmatically. + +Patch Layout +------------ + +Call ``set_position(x, y)`` **before every ``place()`` call**. +Without it, objects pile up and cords cross:: + + Y_STEP = 40 # between objects in a chain + SECTION_GAP = 80 # between logical sections + COL_WIDTH = 150 # between parallel columns + + patch.set_position(30, 100) + osc = patch.place("cycle~")[0] + + patch.set_position(30, 140) # +Y_STEP + filt = patch.place("lores~")[0] + + patch.set_position(30 + COL_WIDTH, 100) # parallel column + lfo = patch.place("cycle~ 2")[0] + +Layout rules: + +- Top-to-bottom signal flow (increasing y). +- Parallel chains side by side (same y, different x). +- Labels (comment) 20px above their object. +- Section headers: ``patch.place("comment === SECTION NAME ===")``. +- loadbang/defaults to the right of main flow. +- Group ``connect()`` calls by section, not scattered throughout. + +Regenerate Stubs +---------------- + +Optional, requires Max open:: + + mp.import_objs() + +Vanilla stubs (max, msp, jit) ship with the package. +Use ``import_objs()`` to add third-party packages or refresh stubs. +""" + from .tools import constants from .maxobject import MaxObject from .maxpatch import MaxPatch from .importobjs import import_objs from .xlet import Inlet, Outlet + +try: + from . import objects +except ImportError: + pass # objects not yet generated diff --git a/maxpylang/exceptions.py b/maxpylang/exceptions.py new file mode 100644 index 0000000..f312c0b --- /dev/null +++ b/maxpylang/exceptions.py @@ -0,0 +1,8 @@ +""" +Custom warning classes for MaxPyLang. +""" + + +class UnknownObjectWarning(UserWarning): + """Raised when a Max object name is not recognized.""" + pass diff --git a/maxpylang/importobjs.py b/maxpylang/importobjs.py index a4eabde..6f360e6 100644 --- a/maxpylang/importobjs.py +++ b/maxpylang/importobjs.py @@ -8,6 +8,8 @@ import time import xml.etree.ElementTree as ET import collections +import keyword +import builtins #import some constants... @@ -52,8 +54,11 @@ def import_objs(*packages, overwrite=False): #store object info save_obj_info(package_paths, package_info_folders) - - return + + #generate python stub modules + generate_stubs(package_paths, package_info_folders) + + return @@ -186,15 +191,21 @@ def save_obj_info(package_paths, package_info_folders): #get inlet/outlet info (from io files) print("\tgetting inlet/outlet info...") objinout_info = get_objinout_info(package, obj_names) - print("\tinlet/outlet info retrieved\n") - - #save maxpy obj info files + print("\tinlet/outlet info retrieved\n") + + #get doc info (digest, description, inlets, outlets, methods, seealso) + print("\tgetting doc info...") + obj_doc_info = get_obj_doc_info(obj_refs, obj_names) + print("\tdoc info retrieved\n") + + #save maxpy obj info files print("\tsaving object info files...") for name in obj_names: - obj_info = {'default': default_obj_info[name], - 'args': objarg_info[name], + obj_info = {'default': default_obj_info[name], + 'args': objarg_info[name], 'attribs': objattrib_info[name], - 'in/out': objinout_info[name]} + 'in/out': objinout_info[name], + 'doc': obj_doc_info[name]} obj_file = os.path.join(info_folder, name + '.json') with open(obj_file, 'w') as f: @@ -476,13 +487,309 @@ def get_objinout_info(package, names): return objinout_info - - - - +#************************************************************ +#*************** GETTING OBJ DOC INFO *********************** +#************************************************************ - - - \ No newline at end of file + +def strip_xml_text(element): + """ + Extract plain text from an XML element, stripping inline tags like , ,
. + Returns joined text or empty string if element is None. + """ + if element is None: + return "" + return "".join(element.itertext()).strip() + + +def get_obj_doc_info(refs, names): + """ + Helper func for import_objs. + + Extracts semantic documentation from XML ref files: + digest, description, inlets, outlets, methods, and seealso. + + Returns dict of {name: doc_dict}. + """ + + obj_doc_info = {} + + for ref, name in zip(refs, names): + + xmltree = ET.parse(ref) + root = xmltree.getroot() + + doc = {} + + # digest + digest_text = strip_xml_text(root.find("digest")) + if digest_text and digest_text != "TEXT_HERE": + doc["digest"] = digest_text + + # description + desc_text = strip_xml_text(root.find("description")) + if desc_text and desc_text != "TEXT_HERE": + doc["description"] = desc_text + + # inlets + inlets = [] + for inlet in root.findall("./inletlist/inlet"): + inlet_info = dict(inlet.attrib) + inlet_digest = strip_xml_text(inlet.find("digest")) + if inlet_digest and inlet_digest != "TEXT_HERE": + inlet_info["digest"] = inlet_digest + inlet_desc = strip_xml_text(inlet.find("description")) + if inlet_desc and inlet_desc != "TEXT_HERE": + inlet_info["description"] = inlet_desc + inlets.append(inlet_info) + if inlets: + doc["inlets"] = inlets + + # outlets + outlets = [] + for outlet in root.findall("./outletlist/outlet"): + outlet_info = dict(outlet.attrib) + outlet_digest = strip_xml_text(outlet.find("digest")) + if outlet_digest and outlet_digest != "TEXT_HERE": + outlet_info["digest"] = outlet_digest + outlet_desc = strip_xml_text(outlet.find("description")) + if outlet_desc and outlet_desc != "TEXT_HERE": + outlet_info["description"] = outlet_desc + outlets.append(outlet_info) + if outlets: + doc["outlets"] = outlets + + # methods + methods = [] + for method in root.findall("./methodlist/method"): + method_info = dict(method.attrib) + method_digest = strip_xml_text(method.find("digest")) + if method_digest and method_digest != "TEXT_HERE": + method_info["digest"] = method_digest + method_desc = strip_xml_text(method.find("description")) + if method_desc and method_desc != "TEXT_HERE": + method_info["description"] = method_desc + # method args + arglist = method.find("arglist") + if arglist is not None: + args = [dict(arg.attrib) for arg in arglist.findall("arg")] + if args: + method_info["args"] = args + methods.append(method_info) + if methods: + doc["methods"] = methods + + + obj_doc_info[name] = doc + + return obj_doc_info + + +#************************************************************ +#*************** PYTHON STUB GENERATION ********************* +#************************************************************ + + +def sanitize_py_name(max_name): + """Convert a Max object name to a valid Python identifier.""" + name = max_name.replace("~", "_tilde") + name = name.replace(".", "_") + name = name.replace("-", "_") + if name and name[0].isdigit(): + name = "_" + name + if keyword.iskeyword(name) or name in dir(builtins): + name = name + "_" + return name + + +def _build_docstring(max_name, obj_info): + """Build a docstring for a Max object from its JSON info.""" + doc = obj_info.get("doc", {}) + args = obj_info.get("args", {}) + attribs = obj_info.get("attribs", []) + + lines = [] + + # line 1: name - digest + digest = doc.get("digest", "") + if digest: + lines.append(f"{max_name} - {digest}") + else: + lines.append(max_name) + + # description + description = doc.get("description", "") + if description: + lines.append("") + lines.append(description) + + # Args section + req_args = args.get("required", []) + opt_args = args.get("optional", []) + if req_args or opt_args: + lines.append("") + lines.append("Args:") + for arg in req_args: + arg_type = ", ".join(arg.get("type", [])) if isinstance(arg.get("type"), list) else arg.get("type", "") + lines.append(f" {arg.get('name', '?')} ({arg_type}, required)") + for arg in opt_args: + arg_type = ", ".join(arg.get("type", [])) if isinstance(arg.get("type"), list) else arg.get("type", "") + lines.append(f" {arg.get('name', '?')} ({arg_type}, optional)") + + # Inlets section + inlets = doc.get("inlets", []) + if inlets: + lines.append("") + lines.append("Inlets:") + for i, inlet in enumerate(inlets): + idx = inlet.get("id", str(i)) + inlet_type = inlet.get("type", "") + digest_text = inlet.get("digest", "") + if inlet_type and digest_text: + lines.append(f" {idx} ({inlet_type}): {digest_text}") + elif digest_text: + lines.append(f" {idx}: {digest_text}") + elif inlet_type: + lines.append(f" {idx} ({inlet_type})") + + # Outlets section + outlets = doc.get("outlets", []) + if outlets: + lines.append("") + lines.append("Outlets:") + for i, outlet in enumerate(outlets): + idx = outlet.get("id", str(i)) + outlet_type = outlet.get("type", "") + digest_text = outlet.get("digest", "") + if outlet_type and digest_text: + lines.append(f" {idx} ({outlet_type}): {digest_text}") + elif digest_text: + lines.append(f" {idx}: {digest_text}") + elif outlet_type: + lines.append(f" {idx} ({outlet_type})") + + # Messages section (one-liner, just names) + methods = doc.get("methods", []) + if methods: + method_names = [m.get("name", "") for m in methods if m.get("name")] + if method_names: + lines.append("") + lines.append("Messages: " + ", ".join(method_names)) + + # Attributes section (one-liner, just names, skip COMMON) + if attribs: + attrib_names = [a.get("name", "") for a in attribs + if a.get("name") and a.get("name") != "COMMON"] + if attrib_names: + lines.append("") + lines.append("Attributes: " + ", ".join(attrib_names)) + + + return "\n".join(lines) + + +def generate_stubs(package_paths, package_info_folders): + """ + Generate Python stub modules for imported Max objects. + + Creates maxpylang/objects/{package}.py with pre-instantiated MaxObject + variables so users get IDE autocomplete. + """ + + # path to maxpylang/objects/ + objects_dir = os.path.join( + os.path.abspath(os.path.join(os.path.realpath(__file__), os.pardir)), + "objects" + ) + os.makedirs(objects_dir, exist_ok=True) + + for package, info_folder in package_info_folders.items(): + + # read all JSON files for this package + json_files = sorted(glob.glob(os.path.join(info_folder, "*.json"))) + if not json_files: + continue + + names_map = {} # py_name -> max_name + obj_infos = {} # max_name -> parsed json + + for jf in json_files: + max_name = Path(jf).stem + with open(jf, "r") as f: + obj_info = json.load(f) + py_name = sanitize_py_name(max_name) + names_map[py_name] = max_name + obj_infos[max_name] = obj_info + + # build the stub module + stub_lines = [] + stub_lines.append(f'"""MaxObject stubs for {package} objects. Auto-generated by import_objs()."""') + stub_lines.append("import os as _os") + stub_lines.append("import sys as _sys") + stub_lines.append("from maxpylang.maxobject import MaxObject") + stub_lines.append("") + + # __all__ + all_names = sorted(names_map.keys()) + stub_lines.append("__all__ = [") + for py_name in all_names: + stub_lines.append(f" '{py_name}',") + stub_lines.append("]") + stub_lines.append("") + + # _NAMES dict + stub_lines.append("_NAMES = {") + for py_name in all_names: + stub_lines.append(f" '{py_name}': '{names_map[py_name]}',") + stub_lines.append("}") + stub_lines.append("") + + # suppress all stdout during stub instantiation + stub_lines.append("_devnull = open(_os.devnull, 'w')") + stub_lines.append("_old_stdout = _sys.stdout") + stub_lines.append("_sys.stdout = _devnull") + stub_lines.append("") + + # per-object docstrings + variable declarations + for py_name in all_names: + max_name = names_map[py_name] + obj_info = obj_infos[max_name] + docstring = _build_docstring(max_name, obj_info) + docstring = docstring.replace('"""', '\\"""') + + # write triple-quoted docstring + stub_lines.append('"""') + stub_lines.append(docstring) + stub_lines.append('"""') + stub_lines.append(f"{py_name} = MaxObject('{max_name}')") + stub_lines.append("") + + # restore stdout + stub_lines.append("_sys.stdout = _old_stdout") + stub_lines.append("_devnull.close()") + stub_lines.append("del _devnull, _old_stdout") + stub_lines.append("") + + # write the stub file + stub_path = os.path.join(objects_dir, f"{package}.py") + with open(stub_path, "w") as f: + f.write("\n".join(stub_lines)) + + print(f"\tstub module generated: objects/{package}.py ({len(names_map)} objects)") + + # regenerate __init__.py based on existing stub files + init_path = os.path.join(objects_dir, "__init__.py") + existing_stubs = [Path(p).stem for p in sorted(glob.glob(os.path.join(objects_dir, "*.py"))) + if Path(p).stem != "__init__"] + init_lines = ['"""Pre-instantiated MaxObject stubs for all imported packages."""'] + for stem in existing_stubs: + init_lines.append("try:") + init_lines.append(f" from .{stem} import *") + init_lines.append("except ImportError:") + init_lines.append(" pass") + with open(init_path, "w") as f: + f.write("\n".join(init_lines) + "\n") + + print("stub generation complete\n") diff --git a/maxpylang/maxobject.py b/maxpylang/maxobject.py index 8e35506..4dc00a9 100644 --- a/maxpylang/maxobject.py +++ b/maxpylang/maxobject.py @@ -29,7 +29,7 @@ class MaxObject(): from .tools.constants import unknown_obj_dict #dictionary of unknown object - def __init__(self, text, from_dict=False, **extra_attribs): + def __init__(self, text, from_dict=False, abstraction=False, inlets=None, outlets=None, **extra_attribs): """ Initialize a MaxObject. @@ -42,6 +42,10 @@ def __init__(self, text, from_dict=False, **extra_attribs): text --> json dict extra_attribs --> not used + abstraction = True --> treat as abstraction without needing the .maxpat file in cwd + inlets --> number of inlets (default 0) + outlets --> number of outlets (default 0) + """ #instance vars @@ -58,7 +62,7 @@ def __init__(self, text, from_dict=False, **extra_attribs): self.build_from_dict(text) else: - self.build_from_specs(text, extra_attribs) + self.build_from_specs(text, extra_attribs, abstraction=abstraction, inlets=inlets, outlets=outlets) return @@ -132,6 +136,7 @@ def outs(self): from .tools.objfuncs.specialobjs import create_js, get_js_filename, get_js_io, update_js_from_file, link_js, \ create_abstraction, get_abstraction_io, \ update_abstraction_from_file, link_abstraction, \ + create_declared_abstraction, \ get_trigger_out_types, get_unpack_out_types, update_vst diff --git a/maxpylang/objects/__init__.py b/maxpylang/objects/__init__.py new file mode 100644 index 0000000..dbe8887 --- /dev/null +++ b/maxpylang/objects/__init__.py @@ -0,0 +1,19 @@ +"""Pre-instantiated MaxObject stubs for all imported packages.""" +import warnings +from maxpylang.exceptions import UnknownObjectWarning + +# Stubs intentionally create objects without args; suppress warnings during import +with warnings.catch_warnings(): + warnings.simplefilter("ignore", UnknownObjectWarning) + try: + from .jit import * + except ImportError: + pass + try: + from .max import * + except ImportError: + pass + try: + from .msp import * + except ImportError: + pass diff --git a/maxpylang/objects/jit.py b/maxpylang/objects/jit.py new file mode 100644 index 0000000..5b68979 --- /dev/null +++ b/maxpylang/objects/jit.py @@ -0,0 +1,4007 @@ +"""MaxObject stubs for jit objects. Auto-generated by import_objs().""" +import os as _os +import sys as _sys +from maxpylang.maxobject import MaxObject + +__all__ = [ + 'jit_3m', + 'jit_alphablend', + 'jit_altern', + 'jit_ameba', + 'jit_anim_drive', + 'jit_anim_node', + 'jit_anim_path', + 'jit_argb2ayuv', + 'jit_argb2grgb', + 'jit_argb2uyvy', + 'jit_avc', + 'jit_avg4', + 'jit_axis2quat', + 'jit_ayuv2argb', + 'jit_ayuv2luma', + 'jit_ayuv2uyvy', + 'jit_bfg', + 'jit_brass', + 'jit_brcosa', + 'jit_bsort', + 'jit_buffer_tilde', + 'jit_catch_tilde', + 'jit_change', + 'jit_charmap', + 'jit_chromakey', + 'jit_clip', + 'jit_coerce', + 'jit_colorspace', + 'jit_concat', + 'jit_convolve', + 'jit_conway', + 'jit_cycle', + 'jit_demultiplex', + 'jit_desktop', + 'jit_dimmap', + 'jit_dimop', + 'jit_displays', + 'jit_dx_grab', + 'jit_dx_videoout', + 'jit_eclipse', + 'jit_euler2quat', + 'jit_expr', + 'jit_fastblur', + 'jit_fft', + 'jit_fill', + 'jit_findbounds', + 'jit_fluoride', + 'jit_fprint', + 'jit_fpsgui', + 'jit_freeframe', + 'jit_gen', + 'jit_gen_codebox', + 'jit_gencoord', + 'jit_gl_asyncread', + 'jit_gl_bfg', + 'jit_gl_camera', + 'jit_gl_cornerpin', + 'jit_gl_cubemap', + 'jit_gl_graph', + 'jit_gl_gridshape', + 'jit_gl_handle', + 'jit_gl_isosurf', + 'jit_gl_light', + 'jit_gl_lua', + 'jit_gl_material', + 'jit_gl_mesh', + 'jit_gl_model', + 'jit_gl_multiple', + 'jit_gl_node', + 'jit_gl_nurbs', + 'jit_gl_pass', + 'jit_gl_path', + 'jit_gl_physdraw', + 'jit_gl_picker', + 'jit_gl_pix', + 'jit_gl_pix_codebox', + 'jit_gl_plato', + 'jit_gl_render', + 'jit_gl_shader', + 'jit_gl_sketch', + 'jit_gl_skybox', + 'jit_gl_slab', + 'jit_gl_text', + 'jit_gl_texture', + 'jit_gl_videoplane', + 'jit_gl_volume', + 'jit_glop', + 'jit_glue', + 'jit_grab', + 'jit_gradient', + 'jit_graph', + 'jit_grgb2argb', + 'jit_hatch', + 'jit_hello', + 'jit_histogram', + 'jit_hsl2rgb', + 'jit_hue', + 'jit_iter', + 'jit_keyscreen', + 'jit_la_determinant', + 'jit_la_diagproduct', + 'jit_la_inverse', + 'jit_la_mult', + 'jit_la_trace', + 'jit_la_uppertri', + 'jit_lcd', + 'jit_linden', + 'jit_luma2ayuv', + 'jit_luma2uyvy', + 'jit_lumakey', + 'jit_map', + 'jit_matrix', + 'jit_matrixinfo', + 'jit_matrixset', + 'jit_mgraphics', + 'jit_movie', + 'jit_multiplex', + 'jit_mxform2d', + 'jit_net_recv', + 'jit_net_send', + 'jit_noise', + 'jit_normalize', + 'jit_obref', + 'jit_op', + 'jit_openexr', + 'jit_p_bounds', + 'jit_p_shiva', + 'jit_p_vishnu', + 'jit_pack', + 'jit_path', + 'jit_peek_tilde', + 'jit_phys_6dof', + 'jit_phys_barslide', + 'jit_phys_body', + 'jit_phys_conetwist', + 'jit_phys_ghost', + 'jit_phys_hinge', + 'jit_phys_multiple', + 'jit_phys_picker', + 'jit_phys_point2point', + 'jit_phys_world', + 'jit_pix', + 'jit_pix_codebox', + 'jit_planeop', + 'jit_playlist', + 'jit_plot', + 'jit_plume', + 'jit_plur', + 'jit_poke_tilde', + 'jit_print', + 'jit_proxy', + 'jit_pwindow', + 'jit_pworld', + 'jit_qball', + 'jit_qfaker', + 'jit_qt_grab', + 'jit_qt_movie', + 'jit_qt_record', + 'jit_qt_videoout', + 'jit_quat', + 'jit_quat2axis', + 'jit_quat2euler', + 'jit_record', + 'jit_release_tilde', + 'jit_repos', + 'jit_resamp', + 'jit_reverse', + 'jit_rgb2hsl', + 'jit_rgb2luma', + 'jit_robcross', + 'jit_rota', + 'jit_roy', + 'jit_rubix', + 'jit_scalebias', + 'jit_scanoffset', + 'jit_scanslide', + 'jit_scanwrap', + 'jit_scissors', + 'jit_scope', + 'jit_shade', + 'jit_slide', + 'jit_sobel', + 'jit_spill', + 'jit_split', + 'jit_sprinkle', + 'jit_str_fromsymbol', + 'jit_str_op', + 'jit_str_regexp', + 'jit_str_tosymbol', + 'jit_streak', + 'jit_submatrix', + 'jit_textfile', + 'jit_thin', + 'jit_tiffany', + 'jit_traffic', + 'jit_transpose', + 'jit_turtle', + 'jit_uldl', + 'jit_unpack', + 'jit_uyvy2argb', + 'jit_uyvy2ayuv', + 'jit_uyvy2luma', + 'jit_vcr', + 'jit_wake', + 'jit_window', + 'jit_world', + 'jit_xfade', + 'mc_jit_peek_tilde', +] + +_NAMES = { + 'jit_3m': 'jit.3m', + 'jit_alphablend': 'jit.alphablend', + 'jit_altern': 'jit.altern', + 'jit_ameba': 'jit.ameba', + 'jit_anim_drive': 'jit.anim.drive', + 'jit_anim_node': 'jit.anim.node', + 'jit_anim_path': 'jit.anim.path', + 'jit_argb2ayuv': 'jit.argb2ayuv', + 'jit_argb2grgb': 'jit.argb2grgb', + 'jit_argb2uyvy': 'jit.argb2uyvy', + 'jit_avc': 'jit.avc', + 'jit_avg4': 'jit.avg4', + 'jit_axis2quat': 'jit.axis2quat', + 'jit_ayuv2argb': 'jit.ayuv2argb', + 'jit_ayuv2luma': 'jit.ayuv2luma', + 'jit_ayuv2uyvy': 'jit.ayuv2uyvy', + 'jit_bfg': 'jit.bfg', + 'jit_brass': 'jit.brass', + 'jit_brcosa': 'jit.brcosa', + 'jit_bsort': 'jit.bsort', + 'jit_buffer_tilde': 'jit.buffer~', + 'jit_catch_tilde': 'jit.catch~', + 'jit_change': 'jit.change', + 'jit_charmap': 'jit.charmap', + 'jit_chromakey': 'jit.chromakey', + 'jit_clip': 'jit.clip', + 'jit_coerce': 'jit.coerce', + 'jit_colorspace': 'jit.colorspace', + 'jit_concat': 'jit.concat', + 'jit_convolve': 'jit.convolve', + 'jit_conway': 'jit.conway', + 'jit_cycle': 'jit.cycle', + 'jit_demultiplex': 'jit.demultiplex', + 'jit_desktop': 'jit.desktop', + 'jit_dimmap': 'jit.dimmap', + 'jit_dimop': 'jit.dimop', + 'jit_displays': 'jit.displays', + 'jit_dx_grab': 'jit.dx.grab', + 'jit_dx_videoout': 'jit.dx.videoout', + 'jit_eclipse': 'jit.eclipse', + 'jit_euler2quat': 'jit.euler2quat', + 'jit_expr': 'jit.expr', + 'jit_fastblur': 'jit.fastblur', + 'jit_fft': 'jit.fft', + 'jit_fill': 'jit.fill', + 'jit_findbounds': 'jit.findbounds', + 'jit_fluoride': 'jit.fluoride', + 'jit_fprint': 'jit.fprint', + 'jit_fpsgui': 'jit.fpsgui', + 'jit_freeframe': 'jit.freeframe', + 'jit_gen': 'jit.gen', + 'jit_gen_codebox': 'jit.gen.codebox', + 'jit_gencoord': 'jit.gencoord', + 'jit_gl_asyncread': 'jit.gl.asyncread', + 'jit_gl_bfg': 'jit.gl.bfg', + 'jit_gl_camera': 'jit.gl.camera', + 'jit_gl_cornerpin': 'jit.gl.cornerpin', + 'jit_gl_cubemap': 'jit.gl.cubemap', + 'jit_gl_graph': 'jit.gl.graph', + 'jit_gl_gridshape': 'jit.gl.gridshape', + 'jit_gl_handle': 'jit.gl.handle', + 'jit_gl_isosurf': 'jit.gl.isosurf', + 'jit_gl_light': 'jit.gl.light', + 'jit_gl_lua': 'jit.gl.lua', + 'jit_gl_material': 'jit.gl.material', + 'jit_gl_mesh': 'jit.gl.mesh', + 'jit_gl_model': 'jit.gl.model', + 'jit_gl_multiple': 'jit.gl.multiple', + 'jit_gl_node': 'jit.gl.node', + 'jit_gl_nurbs': 'jit.gl.nurbs', + 'jit_gl_pass': 'jit.gl.pass', + 'jit_gl_path': 'jit.gl.path', + 'jit_gl_physdraw': 'jit.gl.physdraw', + 'jit_gl_picker': 'jit.gl.picker', + 'jit_gl_pix': 'jit.gl.pix', + 'jit_gl_pix_codebox': 'jit.gl.pix.codebox', + 'jit_gl_plato': 'jit.gl.plato', + 'jit_gl_render': 'jit.gl.render', + 'jit_gl_shader': 'jit.gl.shader', + 'jit_gl_sketch': 'jit.gl.sketch', + 'jit_gl_skybox': 'jit.gl.skybox', + 'jit_gl_slab': 'jit.gl.slab', + 'jit_gl_text': 'jit.gl.text', + 'jit_gl_texture': 'jit.gl.texture', + 'jit_gl_videoplane': 'jit.gl.videoplane', + 'jit_gl_volume': 'jit.gl.volume', + 'jit_glop': 'jit.glop', + 'jit_glue': 'jit.glue', + 'jit_grab': 'jit.grab', + 'jit_gradient': 'jit.gradient', + 'jit_graph': 'jit.graph', + 'jit_grgb2argb': 'jit.grgb2argb', + 'jit_hatch': 'jit.hatch', + 'jit_hello': 'jit.hello', + 'jit_histogram': 'jit.histogram', + 'jit_hsl2rgb': 'jit.hsl2rgb', + 'jit_hue': 'jit.hue', + 'jit_iter': 'jit.iter', + 'jit_keyscreen': 'jit.keyscreen', + 'jit_la_determinant': 'jit.la.determinant', + 'jit_la_diagproduct': 'jit.la.diagproduct', + 'jit_la_inverse': 'jit.la.inverse', + 'jit_la_mult': 'jit.la.mult', + 'jit_la_trace': 'jit.la.trace', + 'jit_la_uppertri': 'jit.la.uppertri', + 'jit_lcd': 'jit.lcd', + 'jit_linden': 'jit.linden', + 'jit_luma2ayuv': 'jit.luma2ayuv', + 'jit_luma2uyvy': 'jit.luma2uyvy', + 'jit_lumakey': 'jit.lumakey', + 'jit_map': 'jit.map', + 'jit_matrix': 'jit.matrix', + 'jit_matrixinfo': 'jit.matrixinfo', + 'jit_matrixset': 'jit.matrixset', + 'jit_mgraphics': 'jit.mgraphics', + 'jit_movie': 'jit.movie', + 'jit_multiplex': 'jit.multiplex', + 'jit_mxform2d': 'jit.mxform2d', + 'jit_net_recv': 'jit.net.recv', + 'jit_net_send': 'jit.net.send', + 'jit_noise': 'jit.noise', + 'jit_normalize': 'jit.normalize', + 'jit_obref': 'jit.obref', + 'jit_op': 'jit.op', + 'jit_openexr': 'jit.openexr', + 'jit_p_bounds': 'jit.p.bounds', + 'jit_p_shiva': 'jit.p.shiva', + 'jit_p_vishnu': 'jit.p.vishnu', + 'jit_pack': 'jit.pack', + 'jit_path': 'jit.path', + 'jit_peek_tilde': 'jit.peek~', + 'jit_phys_6dof': 'jit.phys.6dof', + 'jit_phys_barslide': 'jit.phys.barslide', + 'jit_phys_body': 'jit.phys.body', + 'jit_phys_conetwist': 'jit.phys.conetwist', + 'jit_phys_ghost': 'jit.phys.ghost', + 'jit_phys_hinge': 'jit.phys.hinge', + 'jit_phys_multiple': 'jit.phys.multiple', + 'jit_phys_picker': 'jit.phys.picker', + 'jit_phys_point2point': 'jit.phys.point2point', + 'jit_phys_world': 'jit.phys.world', + 'jit_pix': 'jit.pix', + 'jit_pix_codebox': 'jit.pix.codebox', + 'jit_planeop': 'jit.planeop', + 'jit_playlist': 'jit.playlist', + 'jit_plot': 'jit.plot', + 'jit_plume': 'jit.plume', + 'jit_plur': 'jit.plur', + 'jit_poke_tilde': 'jit.poke~', + 'jit_print': 'jit.print', + 'jit_proxy': 'jit.proxy', + 'jit_pwindow': 'jit.pwindow', + 'jit_pworld': 'jit.pworld', + 'jit_qball': 'jit.qball', + 'jit_qfaker': 'jit.qfaker', + 'jit_qt_grab': 'jit.qt.grab', + 'jit_qt_movie': 'jit.qt.movie', + 'jit_qt_record': 'jit.qt.record', + 'jit_qt_videoout': 'jit.qt.videoout', + 'jit_quat': 'jit.quat', + 'jit_quat2axis': 'jit.quat2axis', + 'jit_quat2euler': 'jit.quat2euler', + 'jit_record': 'jit.record', + 'jit_release_tilde': 'jit.release~', + 'jit_repos': 'jit.repos', + 'jit_resamp': 'jit.resamp', + 'jit_reverse': 'jit.reverse', + 'jit_rgb2hsl': 'jit.rgb2hsl', + 'jit_rgb2luma': 'jit.rgb2luma', + 'jit_robcross': 'jit.robcross', + 'jit_rota': 'jit.rota', + 'jit_roy': 'jit.roy', + 'jit_rubix': 'jit.rubix', + 'jit_scalebias': 'jit.scalebias', + 'jit_scanoffset': 'jit.scanoffset', + 'jit_scanslide': 'jit.scanslide', + 'jit_scanwrap': 'jit.scanwrap', + 'jit_scissors': 'jit.scissors', + 'jit_scope': 'jit.scope', + 'jit_shade': 'jit.shade', + 'jit_slide': 'jit.slide', + 'jit_sobel': 'jit.sobel', + 'jit_spill': 'jit.spill', + 'jit_split': 'jit.split', + 'jit_sprinkle': 'jit.sprinkle', + 'jit_str_fromsymbol': 'jit.str.fromsymbol', + 'jit_str_op': 'jit.str.op', + 'jit_str_regexp': 'jit.str.regexp', + 'jit_str_tosymbol': 'jit.str.tosymbol', + 'jit_streak': 'jit.streak', + 'jit_submatrix': 'jit.submatrix', + 'jit_textfile': 'jit.textfile', + 'jit_thin': 'jit.thin', + 'jit_tiffany': 'jit.tiffany', + 'jit_traffic': 'jit.traffic', + 'jit_transpose': 'jit.transpose', + 'jit_turtle': 'jit.turtle', + 'jit_uldl': 'jit.uldl', + 'jit_unpack': 'jit.unpack', + 'jit_uyvy2argb': 'jit.uyvy2argb', + 'jit_uyvy2ayuv': 'jit.uyvy2ayuv', + 'jit_uyvy2luma': 'jit.uyvy2luma', + 'jit_vcr': 'jit.vcr', + 'jit_wake': 'jit.wake', + 'jit_window': 'jit.window', + 'jit_world': 'jit.world', + 'jit_xfade': 'jit.xfade', + 'mc_jit_peek_tilde': 'mc.jit.peek~', +} + +_devnull = open(_os.devnull, 'w') +_old_stdout = _sys.stdout +_sys.stdout = _devnull + +jit_3m = MaxObject('jit.3m') +""" +jit.3m - Report min/mean/max values + +Reports the minimum, mean, and maximum values for each plane of a given input matrix as lists of size + + planecount + + , one value for each plane. The list of minimum values are sent out the left outlet of the object, the list of mean values are sent out the middle outlet, and the list of maximum values is sent out the right outlet. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (list): min + 1 (list): mean + 2 (list): max + 3 (list): dumpout + +Attributes: max, mean, min +""" + +jit_alphablend = MaxObject('jit.alphablend') +""" +jit.alphablend - Blend two images with an alpha channel image + +Accesses the alpha channel (plane 0) of the input matrix in the left inlet as a per-cell crossfade value, and crossfades between the input matrices in the left and right inlets. In mode 0, a low value means more of the right input matrix, while a high value means more of the left input matrix. In mode 1, a low value means more of the left input matrix, while a high value means more of the right input matrix. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: mode +""" + +jit_altern = MaxObject('jit.altern') +""" +jit.altern - Color screen with threshold + +Overlays a color screen onto incoming matrices. The original matrix values are revealed through "gaps" in the screen. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: bgcolor, colwidth, ignore_zero, rowheight, thresh, xinterval, yinterval +""" + +jit_ameba = MaxObject('jit.ameba') +""" +jit.ameba - Downsample/upsample with non-obvious results + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: gain, mode, x, y +""" + +jit_anim_drive = MaxObject('jit.anim.drive') +""" +jit.anim.drive - Animate a 3D transform + +Animates relative transforms over time with easing. The jit.anim.drive object works in conjunction with jit.anim.node and OpenGL objects to perform this function. Double clicking the object will open a ui mapping dictionary, allowing certain user interface actions to be mapped to animation messages. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): messages to anim.node objects + 1 (OUTLET_TYPE): dumpout + +Messages: bang, anim_reset, (mouse), dictionary, grow, move, moveto, rotateto, scaleto, springto, turn, ui_dict, ui_key, ui_keyup, ui_mouse, update_drive + +Attributes: active, automatic, drawto, ease, easefunc, easein, easeout, evalreport, fixed_delta, name, position, quat, scale, speed, spring_damp, spring_mass, spring_stiff, spring_thresh, ui_dict_layout, targetname, ui_listen, ui_map, ui_map_clone, ui_priority +""" + +jit_anim_node = MaxObject('jit.anim.node') +""" +jit.anim.node - Perform hierarchical transformation + +The jit.anim.node object represents a transformation (position, orientation and scale) in 3D space. OpenGL objects bind to a jit.anim.node and receive position, rotate, and scale attributes. In addition, parent-child relationships can be established in a hierarchical transformation structure, where child jit.anim.node objects are transformed relative to their parents. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): bind objects or position/rotate/scale messages + 1 (OUTLET_TYPE): dumpout + +Messages: bang, anim_grow, anim_move, anim_reset, anim_turn, concat, grow, localtoworld, localtoworld_quat, move, reset, turn, update_node, worldtolocal, worldtolocal_quat + +Attributes: anchor, anim, animmode, automatic, direction, inherit_position, inherit_rotate, inherit_scale, invtransform, locklook, lockplane, lookat, movemode, name, parentpos, parentquat, parentrot, parentscale, position, quat, rotate, rotate_order, rotatexyz, scale, transform, tripod, turnmode, worlddir, worldpos, worldquat, worldrot, worldscale, worldtransform +""" + +jit_anim_path = MaxObject('jit.anim.path') +""" +jit.anim.path - Evaluate a path of 3D transform points + +Takes a series of 3D transform points and interpolates between them. See the jit.path object for more information on this interpolation. Each point stores 11 values: a time value, 3 position values, 3 scale values and 4 quaternion rotation values. + +Inlets: + 0 (INLET_TYPE): messages or matrix in + +Outlets: + 0 (OUTLET_TYPE): evaluated position/scale/quat values + 1 (OUTLET_TYPE): dumpout + +Messages: bang, addquat, addrotate, addrotatexyz, addscale, append, calchandles, clear, closepath, delete, edit, edithandle, eval, evallength, evaltime, gethandle, getpoint, insert, next, prev, setquat, setrotate, setrotatexyz, setscale, settime, sorttime, start, stop + +Attributes: autohandles, automatic, closed, drawpath, drawto, duration, endreport, evalquat, evalreport, evalscale, fixed_delta, interpmode, length, loop, loopreport, name, play, pointcount, position, quat, rate, scale, shortestrot, targetname, time, timemode +""" + +jit_argb2ayuv = MaxObject('jit.argb2ayuv') +""" +jit.argb2ayuv - Convert ARGB to AYUV + +Converts 4-plane char matrix a 4-plane char ARGB (alpha, red, green, blue) matrix into a 4-plane AYUV (alpha, luminance, signed chroma blue, signed chroma red) matrix. Unlike UYVY data, AYUV data has an alpha channel and full resolution chroma data. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_argb2grgb = MaxObject('jit.argb2grgb') +""" +jit.argb2grgb - Convert ARGB to GRGB + +Converts a 4-plane char ARGB (alpha, red, green, blue) matrix into a 4-plane char GRGB (green left, red, green right, blue) matrix. Alpha channel is lost and horizontal dimension is halved to support this half red and blue chroma, macro pixel output format. The GRGB format is typically useful for conserving memory and/or bandwidth for continuous tone images with less expense than colorspace conversion. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_argb2uyvy = MaxObject('jit.argb2uyvy') +""" +jit.argb2uyvy - Convert ARGB to UYVY + +Converts a 4-plane char ARGB (alpha, red, green, blue) matrix into a 4-plane char UYVY (signed chroma blue, luminance left, signed chroma red, luminance right) matrix. Alpha channel is lost and horizontal dimension is halved to support this half chroma, macro pixel output format. The UYVY format is typically useful for efficiently transferring chroma reduced codecs to the GPU without the expense of colorspace conversion, or bandwidth requirements of a full chroma format. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_avc = MaxObject('jit.avc') +""" +jit.avc - Control a FireWire VTR + +Communicates with FireWire VTR devices, such as digital cameras and DV decks, using the 1394 AV/C protocol. Use it to control the transport of these devices with messages. + +Inlets: + 0 (INLET_TYPE): messages in + 1 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): dumpout + +Messages: close, custom, fastwind, ff, getdevice, gettime, gettransport, open, pause, play, record, recpause, rewind, stop, time +""" + +jit_avg4 = MaxObject('jit.avg4') +""" +jit.avg4 - Average four points + +Replaces the values in each cell of an incoming matrix with average values derived from four cells at a specified distance from the original. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: mode, x, y +""" + +jit_axis2quat = MaxObject('jit.axis2quat') +""" +jit.axis2quat - Convert angle-axis to quaternion + +Convert an angle-axis representation of an orientation to a quaternion. Jitter quaternions are ordered X Y Z W. + +Inlets: + 0 (INLET_TYPE): angle axis in + +Outlets: + 0 (OUTLET_TYPE): quat out + 1 (OUTLET_TYPE): dumpout + +Messages: bang, list + +Attributes: angleaxis, normalize, quat +""" + +jit_ayuv2argb = MaxObject('jit.ayuv2argb') +""" +jit.ayuv2argb - Convert AYUV to ARGB + +Converts 4-plane char AYUV (alpha, luminance, signed chroma blue, signed chroma red) matrix into a 4-plane char ARGB (alpha, red, green, blue) matrix. Unlike UYVY data, AYUV data has an alpha channel and full resolution chroma data. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_ayuv2luma = MaxObject('jit.ayuv2luma') +""" +jit.ayuv2luma - Convert AYUV to monochrome (luminance) + +Converts 4-plane char AYUV (alpha, luminance, signed chroma blue, signed chroma red) matrix into into a 1-plane char monochrome matrix containing the luminosity of the original matrix. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_ayuv2uyvy = MaxObject('jit.ayuv2uyvy') +""" +jit.ayuv2uyvy - Convert AYUV to UYVY + +Converts a 4-plane char AYUV (alpha, luminance, signed chroma blue, signed chroma red) matrix into a 4-plane char UYVY (signed chroma blue, luminance left, signed chroma red, luminance right) matrix. Alpha channel is lost and the horizontal dimension is halved to account for this half chroma, macro pixel out format. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_bfg = MaxObject('jit.bfg') +""" +jit.bfg - Evaluate a procedural basis function graph + +Evaluates and exposes a library of procedural basis functions. Each of these basis functions can be evaluated in any number of dimensions, across any coordinate, without any need of referencing existing calculations. In addition, since they all share a common interface, basis functions can be combined together and evaluated in a function graph by cross-referencing several jit.bfg objects. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: setattr + +Attributes: align, autocenter, basis, classname, offset, origin, precision, rotation, scale, seed, weight +""" + +jit_brass = MaxObject('jit.brass') +""" +jit.brass - Emboss image + +Provides a quick and dirty embossing effect on an 4-plane char input matrix. You can specify the amount and direction of the emboss effect and apply an overall tint to the output matrix. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: atint, btint, gtint, mask, rtint +""" + +jit_brcosa = MaxObject('jit.brcosa') +""" +jit.brcosa - Adjust image brightness/contrast/saturation + +Permits you to simultaneously adjust an image's brightness, contrast and saturation. This is useful for achieving a variety of color effects. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: brightness, contrast, saturation +""" + +jit_bsort = MaxObject('jit.bsort') +""" +jit.bsort - Bubble sort + +Performs a bubble sort on an incoming matrix, sorting the cells in ascending order. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: dimmode, maxiter, planemode, summode +""" + +jit_buffer_tilde = MaxObject('jit.buffer~') +""" +jit.buffer~ - Access an MSP buffer~ in matrix form + +Represents audio in a float32 matrix with time across dim[0]. Multi-channel audio uses a separate plane for each channel. The object arguments are the same as those for the buffer~ object. jit.buffer~ responds to all the same messages as buffer~. + +Inlets: + 0 (matrix): dim[0] + +Outlets: + 0 (matrix): value + 1 (matrix): dumpout + 2 (matrix) + +Messages: anything, (mouse), getframes, getlength, output, viz + +Attributes: inputfirst, inputstart, outputfirst, outputlast, outputlength, outputstart, vizchecktime, vizfirst, vizheight, vizmode, vizlast, vizlength, vizmemoryratio, vizstart, vizwidth +""" + +jit_catch_tilde = MaxObject('jit.catch~') +""" +jit.catch~ - Transform signal data into matrices + +Transforms MSP signals into a stream of jitter matrices. + +Inlets: + 0 (signal): input channel 0 + +Outlets: + 0 (matrix): a matrix of floats representing the input signal(s) + 1 (matrix): a matrix of floats representing the input signal(s) + +Messages: bang, bufsize, signal + +Attributes: downsample, framesize, mode, trigdir, trigchan, trigthresh +""" + +jit_change = MaxObject('jit.change') +""" +jit.change - Only pass different frames + +Calculates the number of cells in which the current matrix differs from the previously received matrix, and based on this difference either passes the matrix or not. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: mode, report, thresh +""" + +jit_charmap = MaxObject('jit.charmap') +""" +jit.charmap - Map 256-point input to output + +Creates a 256-point input to output map. Input values are replaced by the corresponding output value. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_chromakey = MaxObject('jit.chromakey') +""" +jit.chromakey - Key images based on chromatic distance + +Produces an chromakey effect based on a reference color. Tolerance and fade settings allow for control over the resulting combined image. An alternate mode outputs a matrix with the keying values, which can be used by other Jitter objects. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: alphaignore, color, fade, maxkey, minkey, mode, tol +""" + +jit_clip = MaxObject('jit.clip') +""" +jit.clip - Limit data to a range + +Limits matrix values to a range specified the object's min and max attributes. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: max, min +""" + +jit_coerce = MaxObject('jit.coerce') +""" +jit.coerce - Coerce a matrix into different types/planecount + +Coerces a matrix into different types/planecount without copying data (sometimes called "header munging"). This may be useful for treating integers as floating point data and vice versa, or treating a four-plane char matrix as a single plane long matrix. + + + Similar to jit.submatrix, jit.coerce only outputs a reference matrix and does not create a separate memory allocation. To use the resulting reference matrix with some jitter objects such as jit.cellblock, you may need to pass the output into another jit.matrix object first. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_colorspace = MaxObject('jit.colorspace') +""" +jit.colorspace - Convert between colorspaces + +Converts a 4-plane char matrix between two different colorspaces. Output matrices are always 4-plane char, even if the colorspace is normally described in a different format. The alpha channel (plane 0) remains untouched in all conversions except for the KCMY colorspace. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: input, output +""" + +jit_concat = MaxObject('jit.concat') +""" +jit.concat - Concatenate two matrices + +Accepts two matrices as input, and sends a single concatenated matrix out. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: autoclear, concatdim, mode, truncate +""" + +jit_convolve = MaxObject('jit.convolve') +""" +jit.convolve - Convolve two matrices + +Computes the correlation between two matrices (an image and a kernel). For true convolution, rotate the kernel 180º. This may be used for typical image processing tasks like blurring, sharpening, and edge detection. By default, the convolution kernel is a 3 by 3 float32 matrix. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: boundmode, origin +""" + +jit_conway = MaxObject('jit.conway') +""" +jit.conway - Play Conway's game of life + +Performs Conway's Game of Life (a cellular automata function) on incoming 1- or 4-plane character matrices. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: birthmark, deathmask, lifemask, neighborhood +""" + +jit_cycle = MaxObject('jit.cycle') +""" +jit.cycle - Cycle messages through outputs + +Route messages, unchanged, through the object's outlets sequentially. Lists remain intact, unlike the Max cycle object. The jit.cycle object takes a single integer argument, which sets the number of outlets. + +Inlets: + 0 (INLET_TYPE): anything in + +Outlets: + 0 (OUTLET_TYPE): jit.cycle outlet 1 + 1 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything, reset + +Attributes: index, hi, mode, lo +""" + +jit_demultiplex = MaxObject('jit.demultiplex') +""" +jit.demultiplex - Demultiplex (deinterleave) one matrix into two + +Accepts a single matrix as input, and derives two output matrices from it by demultiplexing across a specified dimension. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): out2 + 2 (matrix): dumpout + +Attributes: autoclear, demultiplexdim, scan_a, scan_b +""" + +jit_desktop = MaxObject('jit.desktop') +""" +jit.desktop - Copy the display into a matrix + +Grabs the contents of the computer display, taking a screen shot of whatever lies at the specified screen coordinates and placing that data into a Jitter matrix. + +Inlets: + 0 (INLET_TYPE) + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: rect +""" + +jit_dimmap = MaxObject('jit.dimmap') +""" +jit.dimmap - Remap and/or invert matrix dimensions + +Provides remapping and/or inversion of matrix dimensions. Similar to the jit.transpose object, however any dimension may be mapped to any other dimension as well as inverted. Note that the input to output map may not contain any duplicates. Redundant dimensions of size 1 may be inserted by using a map value of -1 at the corresponding dimension index. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: invert, map +""" + +jit_dimop = MaxObject('jit.dimop') +""" +jit.dimop - Downsample using operators across dimensions + +Applies an operator to elements within a subregion, across one or more dimensions, downsampling the input matrix in the process. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: op, step +""" + +jit_displays = MaxObject('jit.displays') +""" +jit.displays - Set and query monitor attributes + +Senses additional display hardware attached to your computer and allows you to use standard Jitter get* and set* messages to enumerate the number and coordinates of any and all monitors. The object remembers the original state of your system's display settings when the object is instantiated, which can be easily recalled, and you can also use the object to enable display mirroring. + + Typically, the jit.displays object is saved as a portion of a performance patch setup to automatically determine the exact position of your attached hardware and move your output window as needed. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): dumpout + +Messages: bang, coords, count, currentstate, getmode, manual, mirror, move, reset, setmode, snapshot, unmirror + +Attributes: resetmode +""" + +jit_dx_grab = MaxObject('jit.dx.grab') +""" +jit.dx.grab - Digitize video using DirectX (Windows) + +Digitizes video from any DirectX-compatible video digitizer, and decompresses the signal into a Jitter matrix. It also offers a grab-to-disk mode. Although numerous parameters for control are offered, not all features are supported by all digitizers. + +Inlets: + 0 (INLET_TYPE): bang, messages in + 1 (INLET_TYPE): bang, messages in + +Outlets: + 0 (matrix): (matrix) out + 1 (matrix): dumpout + +Messages: settings, snd_settings, stop, defaults, exportimage, open, close, write, getvdevlist, getinputlist, getsnddevlist, getsndinputlist, getformatlist + +Attributes: backlight, bitrate, brightness, channels, colorenable, colormode, contrast, dropreport, dstrect, format, gain, gamma, hue, input, interp, resolution, samplerate, saturation, sharpness, snddevice, srcrect, unique, uniqueid, usedstrect, usesrcrect, vdevice, whitebalance, write_audio, write_video +""" + +jit_dx_videoout = MaxObject('jit.dx.videoout') +""" +jit.dx.videoout - Output video to DirectX (Windows) + +The jit.dx.videoout object takes a matrix as input, compresses the data and sends it directly over FireWire to an attached DV camera. + +Inlets: + 0 (matrix): (matrix) in + 1 (matrix) + +Outlets: + 0 (matrix): (matrix) out + 1 (matrix): dumpout + +Messages: open, close +""" + +jit_eclipse = MaxObject('jit.eclipse') +""" +jit.eclipse - Create images from images + +Divides a matrix sent into the left inlet into a grid with a specified number of rows and columns. Each box in the grid contains a scaled-down representation of the overall matrix. Each box is then tinted so that the overall image resembles a second matrix (sent into the right inlet). If the same image is used in both inputs, the result is a self-similar (or meta-) image. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: blue, columns, green, inv, mode, op, red, rows, thresh, tint +""" + +jit_euler2quat = MaxObject('jit.euler2quat') +""" +jit.euler2quat - Convert Euler angles to quaternion + +Convert Euler X/Y/Z representation of an orientation to a quaternion. Jitter quaternions are ordered X Y Z W. + +Inlets: + 0 (INLET_TYPE): euler xyz in + +Outlets: + 0 (OUTLET_TYPE): quat out + 1 (OUTLET_TYPE): dumpout + +Messages: bang, list + +Attributes: euler, normalize, quat, rotate_order +""" + +jit_expr = MaxObject('jit.expr') +""" +jit.expr - Evaluate an expression to fill a matrix + +Evaluates expressions to fill an output matrix. The expression can contain any operator available from within jit.op, any functor available from within jit.bfg, and many jitter MOPs. A variable number of inputs can be specified with an attribute argument setting the inputs attribute. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: int, float, list + +Attributes: cache, expr, inputs, precision, verbose +""" + +jit_fastblur = MaxObject('jit.fastblur') +""" +jit.fastblur - Blur/sharpen using optimized algorithm + +Performs several special-case convolution blur/sharpen operations on incoming matrices. Although it is less flexible than the jit.convolve object, the jit.fastblur object will be quicker and easier to set up for the equivalent convolution, in most cases. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: center, mode, range, ring, ripple +""" + +jit_fft = MaxObject('jit.fft') +""" +jit.fft - Perform a matrix-based FFT + +Performs both the Fast Fourier Transform and Inverse Fast Fourier Transform on an input matrix. It requires that the input has two planes that represent complex numbers--plane 0 is the real component, and plane 1 is the imaginary component. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: inverse +""" + +jit_fill = MaxObject('jit.fill') +""" +jit.fill - Fill a matrix with a list + +Fills one plane of a named matrix with the values of a list received in its left inlet. The offset and plane attributes determine the cells to be filled. Upon completion, the jit.fill object sends a bang message out its left outlet. + +Inlets: + 0 (INLET_TYPE): list + +Outlets: + 0 (OUTLET_TYPE): bang when done + 1 (OUTLET_TYPE): dumpout + +Messages: int, float, list + +Attributes: matrix_name, plane, offset +""" + +jit_findbounds = MaxObject('jit.findbounds') +""" +jit.findbounds - Locate bounding dimensions for a value range + +Scans a matrix for values in the range [ min, max] and sends out the minimum and maximum points that contain those values. The minimum point is sent as a list out the leftmost outlet, and the maximum point is sent as a list out the second outlet. If both points are all -1 values, then there are no points within the range. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (list): min bounds + 1 (list): max bounds + 2 (list): dumpout + +Attributes: boundmax, boundmin, max, min +""" + +jit_fluoride = MaxObject('jit.fluoride') +""" +jit.fluoride - Add a neon glow + +Provides an approximation of a neon glow effect. Individual cell values fade into a specified color as they approach a luminance value. Cell values greater than the luminance value fade to black. Values outside of a tolerance boundary are passed. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: glow, lum, mode, tol +""" + +jit_fprint = MaxObject('jit.fprint') +""" +jit.fprint - Read/write a matrix as a text file + +Imports or exports a single matrix from or to a text file. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: read, write + +Attributes: default_dir, defaultdir, coldelim, planedelim, precision, rowdelim, writemode +""" + +jit_fpsgui = MaxObject('jit.fpsgui') +""" +jit.fpsgui - FPS meter + +Reports timing and matrix information. Currently available reports: fps (frames per second), ms (milliseconds between incoming data), matrix type, dimensions, planecount, and name. + +Inlets: + 0 (INLET_TYPE): Messages In + +Outlets: + 0 (OUTLET_TYPE): Passout + 1 (OUTLET_TYPE): Dumpout + +Messages: anything, getstate, jit_gl_texture, (mouse) + +Attributes: bgcolor, bgcolor2, bordercolor, dim, fps, htextcolor, interval, mode, ms, name, planecount, style, textcolor, timeout, type, usetimeout +""" + +jit_freeframe = MaxObject('jit.freeframe') +""" +jit.freeframe - Utilize FreeFrame effects + +Provides support for using FreeFrame effects within Jitter. It supports both single and dual input effects, and 32-bit and 16-bit data sizes. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: anything, geteffectlist, getparam, getparamlist, loadeffect, param, reload + +Attributes: fx, inmode, numparams, outmode +""" + +jit_gen = MaxObject('jit.gen') +""" +jit.gen - Generate new Jitter MOP objects + +Generates new Jitter Matrix Operator (MOP) objects from Gen patcher and code expressions. The patcher and code describes how each cell of a jit.matrix will be processed by the jit.gen object. + +Inlets: + 0 (INLET_TYPE): in1 + +Outlets: + 0 (OUTLET_TYPE): out1 + 1 (OUTLET_TYPE): dumpout + +Messages: anything, (drag), compile, (mouse), destroy, open, param, wclose + +Attributes: dirty, gen, precision, t, title +""" + +jit_gen_codebox = MaxObject('jit.gen.codebox') +""" +jit.gen.codebox - Generate new Jitter MOP objects + +Generates new Jitter Matrix Operator (MOP) objects from GenExpr code. The code describes how each cell of a jit.matrix will be processed. + +Inlets: + 0 (INLET_TYPE): in1 + +Outlets: + 0 (OUTLET_TYPE): out1 + 1 (OUTLET_TYPE): dumpout + +Messages: anything, (drag), (mouse), open, param, wclose, compile, destroy + +Attributes: bgcolor, linenumbers, linenumberwidth, margin, style, textcolor, gen, dirty, precision, t, title +""" + +jit_gencoord = MaxObject('jit.gencoord') +""" +jit.gencoord - Evaluate a procedural basis function graph + +Generates spatial coordinates across a grid. The output matrix will contain coordinate dimensional values in each plane (eg. RGB == XYZ) + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: offset, scale +""" + +jit_gl_asyncread = MaxObject('jit.gl.asyncread') +""" +jit.gl.asyncread - Read back from an OpenGL framebuffer + +Uses Pixel Buffer Objects (PBOs) to perform asynchronous reads of the OpenGL context at high framerates. The performance gain comes from using two pixel buffer objects in tandem to amortize the cost of the read operation over time without blocking other rendering commands from executing as is typically the case when naive methods are used. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): matrix output if enabled + 1 (OUTLET_TYPE): dumpout + +Attributes: matrixoutput, mode, out_name, texture +""" + +jit_gl_bfg = MaxObject('jit.gl.bfg') +""" +jit.gl.bfg - Procedural basis function texture generator + +Generates OpenGL texture output from a library of procedural basis functions. The functions are processed on the graphics card as OpenGL GLSL shaders. The three categories of functions include noise, fractal and distorted. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): texture output 0 + 1 (OUTLET_TYPE): dumpout + +Messages: full_source_code, getparamdefault, getparamdescription, getparamlist, getparamtype, getparamval, param, sendinput, sendoutput, sendshader + +Attributes: activeinput, adapt, basis, basis.inner, basis.outer, colorize, colormode, dim, dimscale, distortion, file, filter, fractal_params, inputs, offset, out_name, outputs, palette, rect, rectangle, scale, time, type, voronoi_crackle, voronoi_jitter, voronoi_shade, voronoi_smooth, voronoise_amt, zoom +""" + +jit_gl_camera = MaxObject('jit.gl.camera') +""" +jit.gl.camera - Set a rendering view + +Sets the properties needed to define a view in OpenGL. These include field of view, clipping planes, and perspective or orthographic projection modes. In addition a position and orientation can be defined for a virtual camera in 3D space, and the proper view will be generated from these transforms. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): texture output if capture enabled + 1 (OUTLET_TYPE): dumpout + +Messages: getviewportray, screentoworld, sendoutput, worldtoscreen + +Attributes: adapt, capture, colormask, dim, direction, drawto, erase_color, far_clip, frustum, fsaa, layer, lens_angle, locklook, lookat, near_clip, ortho, out_name, out_names, proj_matrix, projection_mode, tripod, type, view_matrix, viewport, viewproj_matrix, vp_mode +""" + +jit_gl_cornerpin = MaxObject('jit.gl.cornerpin') +""" +jit.gl.cornerpin - Map textures in a window + +Provides controls for mapping textures and matrices to an output window by repositioning the image corners. Mouse input is received from the context window allowing for easy manipulation of corner positions. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): matrix output if enabled + 1 (OUTLET_TYPE): dumpout + +Messages: reset, sendtexture + +Attributes: colormode, corner_color, corner_radius, cornermode, drawcorners, enable_mouse, hover, interp, invert_corners, lower_left, lower_right, mousereport, preserve_aspect, rect_tex, texturename, ui_priority, upper_left, upper_right +""" + +jit_gl_cubemap = MaxObject('jit.gl.cubemap') +""" +jit.gl.cubemap - Manage a cubemap texture target + +Maintains a cubemap texture target in an OpenGL context. It has 6 inputs -- one for each face of the cube. Cubemaps are typically used to map an environment for material effects such as reflection and refraction. When sent a texture to any inlet, jit.gl.cubemap adapts to the input type of the texture. + +Inlets: + 0 (INLET_TYPE): Positive X Matrix + 1 (INLET_TYPE): Negative X Matrix + 2 (INLET_TYPE): Positive Y Matrix + 3 (INLET_TYPE): Negative Y Matrix + 4 (INLET_TYPE): Positive Z Matrix + 5 (INLET_TYPE): Negative Z Matrix + +Outlets: + 0 (OUTLET_TYPE): matrix output if enabled + 1 (OUTLET_TYPE): dumpout + +Messages: (drag), bind, equirect_matrix, panorama_matrix, read, unbind + +Attributes: adapt, autotype, bordercolor, edge_length, file, filter, gamma_correct, gamma_correction, level, matrix_name, mipmap, type, wrap +""" + +jit_gl_graph = MaxObject('jit.gl.graph') +""" +jit.gl.graph - Graph floats into 3D space + +Renders one-dimensional floating point data as a three-dimensional shape. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (disabled): matrix output if enabled + 1 (disabled): dumpout + +Attributes: circpoints, radial, radialphase, radialradius +""" + +jit_gl_gridshape = MaxObject('jit.gl.gridshape') +""" +jit.gl.gridshape - Generate simple geometric shapes as a grid + +Creates one of several simple shapes (sphere, torus, cylinder, opencyclinder, cube, opencube, plane, circle) laid out on a connected grid. These shapes may be either rendered directly, or sent out the leftmost outlet as a matrix of values. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (disabled): matrix output if enabled + 1 (disabled): dumpout + +Messages: (drag) + +Attributes: dim, gridmode, rad_minor, shape +""" + +jit_gl_handle = MaxObject('jit.gl.handle') +""" +jit.gl.handle - Use mouse movement to control position/rotation + +jit.gl.handle responds to mouse clicks and drags in the destination by generating rotate and position messages out its left outlet. + +Inlets: + 0 (INLET_TYPE): attribute settings, reset + +Outlets: + 0 (OUTLET_TYPE): position/rotate to ob3d + 1 (OUTLET_TYPE): dumpout + +Messages: reset + +Attributes: auto_handle, auto_rotate, auto_time, filters, fixed_delta, hilite_color, hover, radius, rgb_axes, select_mode, tracking, ui_priority, visible +""" + +jit_gl_isosurf = MaxObject('jit.gl.isosurf') +""" +jit.gl.isosurf - Generate a GL based surface extraction + +Creates a geometric surface from a volumetric density field. The polygonization occurs at locations where the density values intersect the edges of cells inside a subdivided cartesian grid. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (disabled): matrix output if enabled + 1 (disabled): dumpout + +Messages: (drag) + +Attributes: autocolor, autonormals, dim, epsilon, isolevel, mode, trianglecount +""" + +jit_gl_light = MaxObject('jit.gl.light') +""" +jit.gl.light - Place a light source in a 3D scene + +Contains the properties needed to define a light source in OpenGL. These include light type (directional, point and spot), light color, attenuation, and spot angle and falloff. In addition a position (for point and spot) and orientation (for directional and spot) can be defined for a virtual light in 3D space. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): dumpout + +Messages: sendoutput + +Attributes: ambient, atten_const, atten_linear, atten_quad, diffuse, direction, layer, lookat, shadowblur, shadowquality, shadowrange, shadows, shadowtexoutname, specular, spot_angle, spot_falloff, type, viewproj_matrix +""" + +jit_gl_lua = MaxObject('jit.gl.lua') +""" +jit.gl.lua - Script OpenGL and Jitter with Lua. + +jit.gl.lua provides and interface to both OpenGL and Jitter through the Lua scripting language. jit.gl.lua is similar to the js object for JavaScript. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): script outlet + 1 (OUTLET_TYPE): matrix output if enabled + +Messages: int, float, list, anything, call, closebang, (mouse), loadbang, open, read, wclose + +Attributes: args, autowatch, file, gc, inlets, last_inlet, outlets, path +""" + +jit_gl_material = MaxObject('jit.gl.material') +""" +jit.gl.material - Generate materials for 3D objects + +Produces shaders for high quality rendering that automatically adapt to texture inputs and the number of active lights. + +Inlets: + 0 (INLET_TYPE): Diffuse texture or matrix + 1 (texture/matrix): Specular texture or matrix + 2 (texture/matrix): Ambient texture or matrix + 3 (texture/matrix): Emission texture or matrix + 4 (texture/matrix): Normals texture or matrix + 5 (texture/matrix): Environment texture or matrix + 6 (texture/matrix): Heightmap texture or matrix + 7 (texture/matrix): Glossmap texture or matrix + +Outlets: + 0 (OUTLET_TYPE): dumpout + 1 (OUTLET_TYPE): dumpout + +Messages: (drag), ambient_texture, clear, (mouse), diffuse_texture, emission_texture, environment_texture, getparamdefault, getparamlist, getparamtype, getparamval, glossmap_texture, heightmap_texture, normals_texture, open, param, reset, reset_colors, reset_shading_model, specular_texture, wclose + +Attributes: darkness, diffuse_model, diffuse_size, diffuse_smooth, drawto, fog, heightmap_mode, override, roughness, shadow_eps, shadow_hard, shadow_radius, shadow_soft, specular_model, specular_size, specular_smooth, type +""" + +jit_gl_mesh = MaxObject('jit.gl.mesh') +""" +jit.gl.mesh - Generate GL geometry from matrices + +Creates a geometric surface from a jit.matrix connected to the left-most inlet containing spatial coordinates. Additional geometry can be specified by attaching other jit.matrix or jit.gl.buffer objects to the other inlets. + +Inlets: + 0 (matrix): vertex array + 1 (matrix): texcoord array + 2 (matrix): normal array + 3 (matrix): color array + 4 (matrix): specular unused in glcore + 5 (matrix): edgeflag unused in glcore + 6 (matrix): tangent array + 7 (matrix): bitangent unused in glcore + 8 (matrix): index array + +Outlets: + 0 (OUTLET_TYPE): disabled + 1 (OUTLET_TYPE): dumpout + +Messages: (drag), color_matrix, index_matrix, jit_gl_buffer, normal_matrix, reset, tangent_matrix, texcoord_matrix, vertex_attr_matrix, vertex_matrix + +Attributes: auto_colors, auto_normals, auto_tangents, color_mode, draw_mode, input_type, smooth_tangents, tf_name +""" + +jit_gl_model = MaxObject('jit.gl.model') +""" +jit.gl.model - Read and draw various 3D model formats + +jit.gl.model Reads and draws a variety of 3D model formats, such as OBJ, Collada, and Blender. Only tessellated polygons are drawn, and surfaces that are not tessellated are converted before drawing. Certain model formats, such as Collada, support skinned animation. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (disabled): matrix output if enabled + 1 (disabled): dumpout + +Messages: (drag), animenable, animloop, animlooppoints, animrate, animreset, animtime, animweight, copynodestoclipboard, dispose, getanim_dict, getanimnames, getbonenames, getmaterial_dict, getnodenames, gettexnames, nodeanimenable, nodebind, nodereset, nodesetinitial, read, sendmaterial, sendtexture, texgroup + +Attributes: animblendmode, drawgroup, drawskeleton, file, find_instances, fix_normals, gen_normals, gen_tangents, hasbones, index_matrixoutput, material_mode, nodeaxes, normalize, numanimations, numgroups, optimize, smoothing_angle, verbose +""" + +jit_gl_multiple = MaxObject('jit.gl.multiple') +""" +jit.gl.multiple - Create multiple object instances + +Uses several jit.matrix objects to repeatedly draw an instance of a jit.gl object like jit.gl.mesh or jit.gl.gridshape. It attaches to a named instance of a jit.gl (OB3D) object provided by the targetname attribute. + +Inlets: + 0 (matrix): position array + 1 (matrix): scale array + +Outlets: + 0 (OUTLET_TYPE): bind gl objects + 1 (OUTLET_TYPE): dumpout + +Messages: (drag), color_matrix, position_matrix, rotate_matrix, rotatexyz_matrix, scale_matrix, texture_matrix + +Attributes: dimparam, glparams, targetmode, targetname, texture +""" + +jit_gl_node = MaxObject('jit.gl.node') +""" +jit.gl.node - Create hierarchical rendering groups + +Use jit.gl.node to construct hierarchical rendering groups. jit.gl.node creates sub-contexts of child objects that can be modified, rendered, and captured together as a functional group. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): texture output if capture enabled + 1 (OUTLET_TYPE): connect to 3d objects to draw to this gl.node + 2 (OUTLET_TYPE): dumpout + +Messages: draw, getscene_dict, sendoutput + +Attributes: adapt, capture, dim, erase_color, fsaa, out_name, out_names, type +""" + +jit_gl_nurbs = MaxObject('jit.gl.nurbs') +""" +jit.gl.nurbs - Generate NURBS surface + +Renders a Non-Uniform Rational B-Spline (NURBS) surface. A NURBS is a mathematical model that lets you represent virtually any desired shape, from points, straight lines, and polylines to conic sections (circles, ellipses, parabolas, and hyperbolas) to free-form curves with arbitrary shapes. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (disabled): matrix output if enabled + 1 (disabled): dumpout + +Messages: ctlmatrix, rand + +Attributes: auto_tangents, closed, ctlshow, dim, order +""" + +jit_gl_pass = MaxObject('jit.gl.pass') +""" +jit.gl.pass - Render scene passes with shader processing + +The jit.gl.pass object encapsulates processing of one or more sub-passes. A sub-pass consists of a single frame of gl, and post-processing shader, and is defined in a xml pass description file (JXP). Complex scene-processing hierarchies can be obtained by chaining multiple jit.gl.pass objects. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): texture output + 1 (OUTLET_TYPE): connect to child jit.gl.pass objects + 2 (OUTLET_TYPE): dumpout + +Messages: anything, (drag), (mouse), param, read + +Attributes: amount, autowatch, child, embed, depth_drawto, file, fxname, out_name, quality +""" + +jit_gl_path = MaxObject('jit.gl.path') +""" +jit.gl.path - Generate and render a path in OpenGL + +The jit.gl.path object generates and renders a 3D path. See the jit.path object for more information on the underlying path structure. The 3D visualization can be rendered as either a line, an extruded line (ribbon), an extruded circle (tube), or an extruded 2D contour. The path stores 10 values: position x/y/z, color r/g/b/a, scale x/y, and orient angle. + + For more information on how the extrusion is handled, see the GLE library: + + http://www.linas.org/gle + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): matrix output if enabled + 1 (OUTLET_TYPE): dumpout + +Messages: addcolor, addcontour, addorient, addscale, append, calchandles, clear, closepath, delete, edit, edithandle, gethandle, getpoint, insert, setcolor, setorient, setscale + +Attributes: autohandles, closed, displaylist, drawhandles, endcap, evalin, evalout, extrudescale, interpmode, joinstyle, normgen, pathstyle, pointcount, segments, texscale, texturemode +""" + +jit_gl_physdraw = MaxObject('jit.gl.physdraw') +""" +jit.gl.physdraw - A physics opengl debug drawer + +The jit.gl.physdraw object performs debug drawing of the objects in a physics simulation, including jit.phys.body, jit.phys.multiple, and constraint objects such as jit.phys.hinge and jit.phys.6dof. A valid opengl context and a valid jit.phys.world context are required for debug drawing of the physics world. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE) + +Attributes: constraintsize, contactsize, draw_aabb, draw_bodies, draw_worldbox, rgb, worldname +""" + +jit_gl_picker = MaxObject('jit.gl.picker') +""" +jit.gl.picker - Mouse picking in an opengl context + +The jit.gl.picker object responds to mouse interaction in the destination by reporting the name of jit.gl (OB3D) objects intersecting with the mouse. If an intersection occurs object outputs the message mouse followed by the intersecting object name, followed by a 0 or 1 representing the left mouse button state. If a previously intersecting object is no longer intersecting, a mouseout message is output followed by the object name and mouse button state. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): mouse picker messages + 1 (OUTLET_TYPE): dumpout + +Messages: touch, touch_ray + +Attributes: filters, fixed_delta, hover, ui_priority +""" + +jit_gl_pix = MaxObject('jit.gl.pix') +""" +jit.gl.pix - Generates pixel processing shaders from a gen patcher + +The jit.gl.pix object generates new pixel processing shaders from a patcher. jit.gl.pix is essentially a jit.gl.slab object whose shader files are generated from Gen patchers. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + 1 (INLET_TYPE) + +Outlets: + 0 (OUTLET_TYPE): matrix output if enabled + 1 (OUTLET_TYPE): dumpout + +Messages: anything, (drag), compile, (mouse), exportcode, full_source_code, getparamdefault, getparamdescription, getparamlist, getparamtype, getparamval, open, param, sendinput, sendoutput, sendshader, wclose + +Attributes: bypass, activeinput, adapt, colormode, dim, dimscale, dirty, exportfolder, file, filter, gen, inputs, out_name, outputs, rect, rectangle, t, thru, title, type +""" + +jit_gl_pix_codebox = MaxObject('jit.gl.pix.codebox') +""" +jit.gl.pix.codebox - Generates pixel processing shaders from GenExpr code + +The jit.gl.pix.codebox object generates new pixel processing shaders from GenExpr code. jit.gl.pix.codebox is essentially a jit.gl.slab object whose shader files are generated from GenExpr code. + +Inlets: + 0 (INLET_TYPE): in0 + 1 (INLET_TYPE): in1 + +Outlets: + 0 (OUTLET_TYPE): out1 + 1 (OUTLET_TYPE): dumpout + +Messages: anything, (drag), (mouse), exportcode, full_source_code, getparamdefault, getparamlist, getparamtype, getparamval, open, param, sendinput, sendoutput, sendshader, wclose, compile, getparamdescription + +Attributes: bgcolor, linenumbers, linenumberwidth, margin, style, textcolor, displaylist, edges, file, shape, subdiv, wrap, title, t, dirty, type, thru, texrect, rectangle, rect, outputs, out_name, inputs, gen, exportfolder, dimscale, dim, depth, colormode, adapt, activeinput, filter +""" + +jit_gl_plato = MaxObject('jit.gl.plato') +""" +jit.gl.plato - Generate platonic solids + +Produces one of five platonic solids: tetrahedron, cube, octahedron, dodecahedron, or icosahedron. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (disabled): matrix output if enabled + 1 (disabled): dumpout + +Messages: (drag) + +Attributes: shape +""" + +jit_gl_render = MaxObject('jit.gl.render') +""" +jit.gl.render - Render Jitter OpenGL objects + +Use jit.gl.render to render Jitter OpenGL objects to a rendering destination. jit.gl.render drives the rendering of 3D graphics, setting up and invoking the drawing of each frame. jit.gl.render can draw to jit.window and jit.pwindow. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): bang upon render completion + 1 (OUTLET_TYPE): dumpout + +Messages: drawclients, drawswap, erase, getscene_dict, screentoworld, swap, worldtoscreen + +Attributes: camera, drawto, erase_color, far_clip, geom_rows, high_res, lens_angle, light_ambient, light_diffuse, light_global_ambient, light_position, light_specular, lookat, near_clip, primitive, rotate_order, up +""" + +jit_gl_shader = MaxObject('jit.gl.shader') +""" +jit.gl.shader - Manage a GL shader + +Manages the process of compiling, binding and submitting a shader to OpenGL. A shader consists of both a vertex program and a fragment (aka pixel) program, which can be defined in a xml shader description file (JXS), or submitted individually. Currently the high level language GLSL is supported. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): matrix output if enabled + 1 (OUTLET_TYPE): dumpout + +Messages: (drag), bind, compile, (mouse), dispose, dump, getparamdefault, getparamdescription, getparamlist, getparamtype, getparamval, link, param, program_param, read, unbind + +Attributes: autowatch, embed, file, verbose +""" + +jit_gl_sketch = MaxObject('jit.gl.sketch') +""" +jit.gl.sketch - Use drawing commands with OpenGL + +Records and draws based on 3-D drawing commands. These commands range from simple turtle graphics to the majority of the OpenGL API. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): matrix output if enabled + 1 (OUTLET_TYPE): dumpout + +Messages: beginstroke, circle, cmd_delete, cmd_enable, cmd_insert, cmd_replace, cube, cylinder, drawmatrix, drawobject, ellipse, endstroke, framecircle, frameellipse, framequad, frametri, getcamera, getcmd_index, getcmdlist, glbegin, glcolor, glcullface, gldisable, glenable, glend, glget, gllinestipple, gllinewidth, glnormal, glpointsize, glpolygonmode, glpolygonoffset, glpopmatrix, glpushmatrix, glrect, glrotate, glscale, glshademodel, gltexcoord, gltranslate, glvertex, line, linesegment, lineto, move, moveto, plane, point, quad, reset, roundedplane, screentoworld, shapeorient, shapeprim, shapeslice, sphere, strokeparam, strokepoint, torus, tri, worldtoscreen +""" + +jit_gl_skybox = MaxObject('jit.gl.skybox') +""" +jit.gl.skybox - Render a skybox in OpenGL + +The jit.gl.skybox object renders a skybox in a opengl world. A skybox is a cube that remains infinitely far away from the camera, and gives the illusion of distant 3D surroundings. The jit.gl.cubemap object is used to texture the skybox. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): matrix output if enabled + 1 (OUTLET_TYPE): dumpout + +Attributes: displaylist, infinite +""" + +jit_gl_slab = MaxObject('jit.gl.slab') +""" +jit.gl.slab - Process texture data + +Generate, process and combine images efficiently using fragment shaders. Develop custom texture effects for processing on the graphics card. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + 1 (INLET_TYPE) + +Outlets: + 0 (OUTLET_TYPE): matrix output if enabled + 1 (OUTLET_TYPE): dumpout + +Messages: anything, (drag), (mouse), getparamdefault, getparamdescription, getparamlist, getparamtype, getparamval, param, read, sendinput, sendoutput, sendshader + +Attributes: autowatch, bypass, activeinput, adapt, colormode, embed, dim, dimscale, file, filter, inputs, out_name, outputs, rect, rectangle, thru, scale, type +""" + +jit_gl_text = MaxObject('jit.gl.text') +""" +jit.gl.text - Render text in a GL context + +Draws text in the named drawing context. The text is drawn as 2D, 3D, or outline, depending on the mode attribute. The text can be sent as a symbol, a list of symbols, or as a jit.matrix containing char data. When a jit.matrix is used, each row of the matrix is interpreted as one line of text. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (disabled): matrix output if enabled + 1 (disabled): dumpout + +Messages: append, clear, face, font, size, style, text + +Attributes: align, concat_geometry, depth, floatchomp, floatplaces, fontname, fontsize, leadscale, line_length, mode, plane, precision, screenmode, slant, tracking, weight +""" + +jit_gl_texture = MaxObject('jit.gl.texture') +""" +jit.gl.texture - Create OpenGL textures + +Creates OpenGL textures - buffers of image data used in drawing 3D geometry. jit.gl.texture is similar to jit.matrix except that textures reside on the graphics card. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): matrix output if enabled + 1 (OUTLET_TYPE): dumpout + +Messages: (drag), begin_capture, bind, end_capture, read, subtex_matrix, tomatrix, unbind + +Attributes: adapt, anisotropy, autoclear, autoscale, autotype, bordercolor, colormode, compare_func, compare_mode, defaultimage, dim, dstdimend, dstdimstart, erase_color, file, filter, flip, level, mipmap, rectangle, thru, slice, srcdimend, srcdimstart, type, usedstdim, usesrcdim, wrap +""" + +jit_gl_videoplane = MaxObject('jit.gl.videoplane') +""" +jit.gl.videoplane - Display video in OpenGL + +Provides a quick way to show video in OpenGL. Unlike other Jitter OpenGL objects it also has video specific controls. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (disabled): matrix output if enabled + 1 (disabled): dumpout + +Messages: sendtexture + +Attributes: colormode, dim, interp, preserve_aspect, rect_tex, texturename +""" + +jit_gl_volume = MaxObject('jit.gl.volume') +""" +jit.gl.volume - Create a volume visualization + +Creates a transparent volume from a volumetric density field. This process is GL accelerated by using graphics hardware. + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (disabled): matrix output if enabled + 1 (disabled): dumpout + +Attributes: bounds, density, distance, intensity, slices +""" + +jit_glop = MaxObject('jit.glop') +""" +jit.glop - Produce feedback with gain staging + +Performs feedback on either the input matrix or the output matrix, and provides a gain stage for control. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: gain, mode +""" + +jit_glue = MaxObject('jit.glue') +""" +jit.glue - Glue many matrices into one + +Composites multiple input matrices together as if they were rectangular pieces of a whole. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: columns, syncinlet, rows +""" + +jit_grab = MaxObject('jit.grab') +""" +jit.grab - Digitize video from an external source + +Use the jit.grab object to digitize video from any video digitizer and decompress the signal into a Jitter matrix or GL texture. + +Inlets: + 0 (INLET_TYPE): bang, messages in + +Outlets: + 0 (matrix / texture): out + 1 (matrix / texture): dumpout + +Messages: int, close, exportimage, getformatlist, getframeratelist, getinputlist, getvdevlist, open + +Attributes: adapt, automatic, colormode, drawto, dstrect, engine, format, framerate, framereport, input, interp, output_texture, srcrect, texture_name, unique, uniqueid, usedstrect, usesrcrect, vdevice +""" + +jit_gradient = MaxObject('jit.gradient') +""" +jit.gradient - Generate Chebyshev gradients + +Generates a 4-plane char matrix containing a gradient curve that runs along the horizontal axis (i.e. it smoothly fades from left to right). You can select the cell values to fade between as well as Chebyshev coefficients to generate more complex curves and ripples. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: cheby, end, start +""" + +jit_graph = MaxObject('jit.graph') +""" +jit.graph - Perform floating-point data visualization + +Renders floating point data as a two-dimensional plot. + +Attributes: brgb, clearit, frgb, height, mode, rangehi, rangelo +""" + +jit_grgb2argb = MaxObject('jit.grgb2argb') +""" +jit.grgb2argb - Convert GRGB to ARGB + +Converts a 4-plane char GRGB (green left, red, green right, blue) matrix into a 4-plane char ARGB (alpha, red, green, blue) matrix. A default alpha channel (all on) is added and horizontal dimension is doubled for the output to account for this half red and blue chroma, macro pixel input format. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_hatch = MaxObject('jit.hatch') +""" +jit.hatch - Perform crosshatch filtering + +Divides an incoming matrix into a grid. Along the central axes of each square, the color value of the original top-left pixel is visible. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: bgcolor, grid, thresh +""" + +jit_hello = MaxObject('jit.hello') +""" +jit.hello - Show an example of Jitter attributes + +Stores text in the text attribute. This object only exists as an illustration of how attributes work. + +Inlets: + 0 (INLET_TYPE) + +Outlets: + 0 (OUTLET_TYPE) + +Attributes: text +""" + +jit_histogram = MaxObject('jit.histogram') +""" +jit.histogram - Calculate matrix histogram + +Calculates the histogram for a series of input matrices. The histogram is the distribution of values for each of the matrix's planes. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: autoclear, normalize, normval +""" + +jit_hsl2rgb = MaxObject('jit.hsl2rgb') +""" +jit.hsl2rgb - Convert HSL to RGB + +Converts a 4 plane matrix of AHSL (alpha, hue, saturation, lightness) data to ARGB (alpha, red, green, blue) data. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_hue = MaxObject('jit.hue') +""" +jit.hue - Rotate hue + +Performs a hue rotation, preserving the luminance values. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: hue_angle +""" + +jit_iter = MaxObject('jit.iter') +""" +jit.iter - Iterate a matrix as lists or values + +Iterates through all the cells of a matrix, sending a message or list for each cell out the object's left outlet. Output is one item per plane of data. A list of ints is sent out the middle outlet that containing the current cell coordinates. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (list): values + 1 (list): coordinates + 2 (list): dumpout + +Attributes: mode +""" + +jit_keyscreen = MaxObject('jit.keyscreen') +""" +jit.keyscreen - Choke chromakey from 3 sources + +Takes three 4-plane char matrix and does an interchangeable choke chromakey between the three sources. Any of the three input matrices can be designated as the key image (from which the image mask is created), the target image (which the mask is overlaid onto), or the mask image (which is placed on top of the target in the shape of the key). + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + 2 (matrix): in3 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: alpha, alphatol, blue, bluetol, green, greentol, key, mask, mode, red, redtol, target +""" + +jit_la_determinant = MaxObject('jit.la.determinant') +""" +jit.la.determinant - Calculate the determinant of a matrix + +jit.la.determinant calculates the determinant of a given input matrix, and send the result out the leftmost outlet. The input matrices must be 1-plane or 2-plane matrices of the type float32 or float64. If a 2-plane matrix is used, it is assumed that the data is from the set of complex numbers and the output product is a list of 2 floating point values. The first element is the real component and the second element is the imaginary component. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (float/list): determinant + 1 (float/list): dumpout + +Attributes: thresh +""" + +jit_la_diagproduct = MaxObject('jit.la.diagproduct') +""" +jit.la.diagproduct - Calculate the product across the main diagonal + +jit.la.diagproduct calculates the product across the main diagonal of a given input matrix, and send the result out the leftmost outlet. The input matrices must be 1-plane or 2-plane matrices of the type float32 or float64. If a 2-plane matrix is used, it is assumed that the data is from the set of complex numbers and the output product is a list of 2 floating point values. The first element is the real component and the second element is the imaginary component. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (float/list): diagproduct + 1 (float/list): dumpout +""" + +jit_la_inverse = MaxObject('jit.la.inverse') +""" +jit.la.inverse - Calculate the inverse of a matrix + +jit.la.inverse calculates the inverse with respect to multiplication of a given input matrix. The input matrices must be 1-plane or 2-plane matrices of the type float32 or float64. If a 2-plane matrix is used, it is assumed that the data is from the set of complex numbers. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: thresh +""" + +jit_la_mult = MaxObject('jit.la.mult') +""" +jit.la.mult - True matrix multiplication + +jit.la.mult calculates the matrix product of two input matrices (as opposed to multiplication performed by the jit.op object, which is pointwise multiplication). The input matrices must be 1-plane or 2-plane matrices of the type float32 or float64. If a 2-plane matrix is used, it is assumed that the data is from the set of complex numbers. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_la_trace = MaxObject('jit.la.trace') +""" +jit.la.trace - Calculate the sum across the main diagonal + +jit.la.trace calculates the sum across the main diagonal of a given input matrix, and send the result out the leftmost outlet. The input matrices must be 1 or 2-plane matrices of the type float32 or float64. If a 2-plane matrix is used, it is assumed that the data is from the set of complex numbers and the output product is a list of 2 floating point values. The first element is the real component and the second element is the imaginary component. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (float/list): trace + 1 (float/list): dumpout +""" + +jit_la_uppertri = MaxObject('jit.la.uppertri') +""" +jit.la.uppertri - Convert a matrix into an upper triangular matrix + +The jit.la.uppertri object converts a given input matrix to an upper triangular matrix via Gaussian elimination. The input matrices must be 1-plane or 2-plane matrices of the type float32 or float64. If a 2-plane matrix is used, it is assumed that the data is from the set of complex numbers. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: swapcount, thresh +""" + +jit_lcd = MaxObject('jit.lcd') +""" +jit.lcd - QuickDraw wrapper (deprecated) + +The jit.lcd object is a wrapper for many QuickDraw commands. + +Inlets: + 0 (INLET_TYPE): messages + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: ascii, brgb, clearpicts, clipoval, clippoly, cliprect, cliproundrect, color, deletepict, drawpict, font, framearc, frameoval, framepoly, framerect, frameroundrect, frgb, getpenloc, getpixel, line, linesegment, lineto, move, moveto, noclip, oprgb, paintarc, paintoval, paintpoly, paintrect, paintroundrect, penmode, pensize, readpict, reset, scrollrect, setpixel, textface, textmode, tilepict, write, writepict +""" + +jit_linden = MaxObject('jit.linden') +""" +jit.linden - Lindenmayer string expansion (L-systems) + +The jit.linden object interprets an incoming 1-dim, 1-plane char matrix as a Lindenmayer System (L-system). + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: boundmode, ignore, leftbranch, production, rightbranch, wildcard +""" + +jit_luma2ayuv = MaxObject('jit.luma2ayuv') +""" +jit.luma2ayuv - Converts monochrome (luminance) to AYUV + +The jit.luma2ayuv object converts a 1-plane monochrome (lumninance) matrix to a 4-plane char AYUV (alpha, luminance, signed chroma blue, signed chroma red) matrix. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_luma2uyvy = MaxObject('jit.luma2uyvy') +""" +jit.luma2uyvy - Converts monochrome (luminance) to UYVY + +The jit.luma2uyvy object converts a 1-plane monochrome (lumninance) matrix to a 4-plane char UYVY (signed chroma blue, luminance left, signed chroma red, luminance right) matrix. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_lumakey = MaxObject('jit.lumakey') +""" +jit.lumakey - Key based on distance from a luminance value + +The jit.lumakey object measures the chromatic distance of each of the left input's cells (pixels) with a reference luminance calulated by the formula lum = (ascale * alpha_value) + (rscale * r_value) + (gscale * g_value) + (bscale * b_value). + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: ascale, bscale, fade, gscale, lum, maxkey, minkey, mode, rscale, tol +""" + +jit_map = MaxObject('jit.map') +""" +jit.map - Map input range to output range + +The jit.map object maps input range to output range as specified by map attribute settings that specify input and output value ranges. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: clip, map +""" + +jit_matrix = MaxObject('jit.matrix') +""" +jit.matrix - The Jitter Matrix! + +The jit.matrix object is a named matrix which may be used for data storage and retrieval, resampling, and matrix type and planecount conversion operations. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: bang, int, float, list, (drag), clear, exportimage, exportmovie, exprfill, fillplane, getcell, importmovie, jit_gl_texture, op, read, setall, setcell, setcell1d, setcell2d, setcell3d, setplane1d, setplane2d, setplane3d, val, write + +Attributes: adapt, dim, dimstride, dstdimend, dstdimstart, interp, name, planecount, planemap, thru, size, srcdimend, srcdimstart, usedstdim, usesrcdim, type +""" + +jit_matrixinfo = MaxObject('jit.matrixinfo') +""" +jit.matrixinfo - Report matrix planecount, type, dimensions + +jit.matrix reports a given matrix's planecount, type, and dim attributes in the form + + planecount number-of-planes + type data-type + dim dimension0... dimensionN. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out +""" + +jit_matrixset = MaxObject('jit.matrixset') +""" +jit.matrixset - A set of matrices for storage/resequencing + +The jit.matrixset object keeps a set of internal matrices which may be written to or read from. This may be useful for data storage and/or matrix resequencing. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: bang, clear, exportmovie, importmovie, read, write + +Attributes: dim, dstdimend, dstdimstart, index, interp, matrixcount, planecount, planemap, thru, type, srcdimend, srcdimstart, usedstdim, usesrcdim +""" + +jit_mgraphics = MaxObject('jit.mgraphics') +""" +jit.mgraphics - 2D Vector Graphics + +The jit.mgraphics object supports drawing 2D vector graphics with the MGraphics API. + +Inlets: + 0 (INLET_TYPE) + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: append_path, arc, arc_negative, attr_setfill, clear_surface, close_path, curve_to, device_to_user, ellipse, fill, fill_extents, fill_preserve, fill_preserve_with_alpha, fill_with_alpha, font_extents, get_current_point, get_line_cap, get_line_join, get_line_width, get_matrix, getfontlist, identity_matrix, image_surface_create, image_surface_destroy, image_surface_draw, image_surface_draw_fast, image_surface_get_size, in_fill, line_to, move_to, new_path, ovalarc, paint, paint_with_alpha, parentpaint, path_roundcorners, pattern_add_color_stop_rgba, pattern_create_for_surface, pattern_create_linear, pattern_create_radial, pattern_create_rgba, pattern_destroy, pattern_get_extend, pattern_get_matrix, pattern_get_type, pattern_identity_matrix, pattern_rotate, pattern_scale, pattern_set_extend, pattern_set_matrix, pattern_translate, pop_group_to_source, push_group, rectangle, rectangle_rounded, rel_curve_to, rel_line_to, rel_move_to, restore, rotate, save, scale, scale_source_rgba, select_font_face, set_dash, set_font_size, set_line_cap, set_line_join, set_line_width, set_matrix, set_source, set_source_rgb, set_source_rgba, set_source_surface, show_text, stroke, stroke_preserve, stroke_preserve_with_alpha, stroke_with_alpha, svg_create, svg_destroy, svg_get_size, svg_render, svg_set, text_measure, text_path, transform, translate, translate_source_rgba, user_to_device + +Attributes: autofill, dim, relative_coords, textfieldvisible +""" + +jit_movie = MaxObject('jit.movie') +""" +jit.movie - Play a movie file + +The jit.movie object plays and manipulates movie files. It comes in two forms: jit.movie, which outputs matrices, and jit.gl.movie, which outputs OpenGL textures. The OpenGL version is recommended for smoother playback and better performance. + +Inlets: + 0 (INLET_TYPE): bang, messages in + +Outlets: + 0 (matrix / texture): out + 1 (matrix / texture): dumpout + +Messages: (drag), asyncread, cancelframedump, dispose, frame, frame_coarse, framedump, jump, jump_coarse, read, start, stop + +Attributes: adapt, automatic, autostart, colormode, drawto, dstrect, duration, engine, fps, framecount, framereport, interp, loop, loopend, looppoints, looppoints_ms, looppoints_secs, loopreport, loopstart, milliseconds, movie_dim, moviedim, moviefile, moviename, moviepath, output_texture, position, rate, seamless_loopcount, seconds, srcrect, texture_name, time, time_ms, time_secs, timescale, unique, usedstrect, usesrcrect, vol +""" + +jit_multiplex = MaxObject('jit.multiplex') +""" +jit.multiplex - Multiplex (interleave) two matrices into one matrix + +The jit.multiplex object takes two matrices as input, and derives a single output matrix from it by interleaving the input matrices across a specified dimension. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: autoclear, mode, multiplexdim, scan_a, scan_b, truncate +""" + +jit_mxform2d = MaxObject('jit.mxform2d') +""" +jit.mxform2d - Spatial transform using 3x3 matrix + +The jit.mxform2d object performs a 2-dimensional matrix transform on an input matrix. It can be used to perform scaling, rotation, skewing, and perspective operations. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: boundmode, interp, mxform, offset_x, offset_y +""" + +jit_net_recv = MaxObject('jit.net.recv') +""" +jit.net.recv - Receive matrices from a jit.net.send object via TCP/IP + +Use jit.net.recv to output matrices and messages sent over a network connection by jit.net.send. + +Inlets: + 0 (INLET_TYPE) + +Outlets: + 0 (OUTLET_TYPE): out + 1 (OUTLET_TYPE): dumpout + 2 (OUTLET_TYPE): dumpout + +Messages: getmatrix, getmessage + +Attributes: connected, ip, port +""" + +jit_net_send = MaxObject('jit.net.send') +""" +jit.net.send - Send matrices to a jit.net.recv object via TCP/IP + +Use jit.net.send to send matrices and messages over a network connection to an instance of jit.net.recv. + +Inlets: + 0 (INLET_TYPE): in + 1 (INLET_TYPE) + +Outlets: + 0 (OUTLET_TYPE): dumpout + +Messages: int, float, list, anything + +Attributes: connected, host, ip, latency, nagle, port, report +""" + +jit_noise = MaxObject('jit.noise') +""" +jit.noise - Generate white noise + +jit.noise generates matrices of random values. + +Inlets: + 0 (INLET_TYPE) + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: seed +""" + +jit_normalize = MaxObject('jit.normalize') +""" +jit.normalize - Normalizes a matrix. + +jit.normalize examines a jit.matrix and scales the minimum and maximum values to a normalized range. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: amp, global +""" + +jit_obref = MaxObject('jit.obref') +""" +jit.obref - Launch html object reference + +The jit.obref object takes one object-name argument. When double clicked, the jit.obref object will find the html object reference file corresponding to the object specified by object-name and launch it in Max's Documentation Window. The html object reference file must be located in the Max search path. + +Inlets: + 0 (INLET_TYPE): anything + +Messages: bang, anything, (mouse) +""" + +jit_op = MaxObject('jit.op') +""" +jit.op - Apply binary or unary operators + +The jit.op object applies either a binary operator to two input matrices, or a unary operator to the left input matrix. A different operator may be specified for each plane, or a scalar may be specified via the val attribute as an alternate to using a second matrix. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: int, float, list + +Attributes: op, val +""" + +jit_openexr = MaxObject('jit.openexr') +""" +jit.openexr - Read or write an OpenEXR image. + +Converts an OpenEXR image to and from a jit.matrix object for an arbitrary number of planes or color components. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: (drag), read, write + +Attributes: adjust, channels, defog, exposure, gamma, kneehigh, kneelow, normalize, outputfile, verbose +""" + +jit_p_bounds = MaxObject('jit.p.bounds') +""" +jit.p.bounds - Limit particles to a region of space + +The jit.p.bounds object creates limits in a particle system. Limits may be applied to any of the qualities of the system (with the exception of the reserved life and ID qualities). + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: bounds_hi, bounds_lo, mode, squish, squish_var +""" + +jit_p_shiva = MaxObject('jit.p.shiva') +""" +jit.p.shiva - Generate/eliminate particles + +The jit.p.shiva object generates Jitter matrices conforming to the Jitter particle system specification. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: emit, emit_var, init, init_var, life, life_var, mode +""" + +jit_p_vishnu = MaxObject('jit.p.vishnu') +""" +jit.p.vishnu - Apply single force to particles + +The jit.p.vishnu object takes a Jitter particle systems matrix as input, and applies a specific single force world model to it. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: force, mode, pitch, pitch_var, pos, pos_var, speed, speed_var, yaw, yaw_var +""" + +jit_pack = MaxObject('jit.pack') +""" +jit.pack - Make a multiplane matrix out of single plane matrices + +The jit.pack object merges N single-plane matrices to make one N-plane matrix. This is useful for combining separate alpha, red, green, and blue matrices to make one ARGB matrix, and similar types of merging. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + 2 (matrix): in3 + 3 (matrix): in4 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: index, jump, offset, plane +""" + +jit_path = MaxObject('jit.path') +""" +jit.path - Evaluates a series of N-dim points as a path + +The jit.path object takes a series of N-dimensional points retrieves interpolated values based on an input parameter. It is useful for creating user interfaces for parameter morphing. + +Inlets: + 0 (INLET_TYPE): point matrix in + +Outlets: + 0 (OUTLET_TYPE): point matrix + 1 (OUTLET_TYPE): evaluated matrix + 2 (OUTLET_TYPE): evaluated values + 3 (OUTLET_TYPE): dumpout + +Messages: bang, append, calc_evalmatrix, calc_outmatrix, calchandles, clear, closepath, delete, edit, edithandle, eval, evallength, evaltime, gethandle, getpoint, insert, next, outputeval, prev, settime, sorttime, start, stop + +Attributes: autohandles, closed, dim, duration, evalmatrixmode, evalmatrixname, evalmatrixsize, grain, interpmode, length, loop, outmatrixname, play, pointcount, rate, thru, time, timemode, usetime +""" + +jit_peek_tilde = MaxObject('jit.peek~') +""" +jit.peek~ - Read matrix data as an audio signal + +jit.peek~ reads the value of one plane of a matrix cell at the position specified by the signal inputs. This value is output as a signal. The object arguments are [matrix_name] [dim_inputcount] [plane]. + +Inlets: + 0 (signal): dim[0] + 1 (signal): dim[1] + +Outlets: + 0 (signal): value + 1 (signal): dumpout + +Messages: signal + +Attributes: interp, matrix_name, normalize, plane +""" + +jit_phys_6dof = MaxObject('jit.phys.6dof') +""" +jit.phys.6dof - A six degrees of freedom constraint in a physics world + +The jit.phys.6dof allows for linear and angular constraints of any of the three axes. Each axis can be either locked, free or limited. If only a single body is bound, it is constrained to a point in world space. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): connect to jit.phys.body 1 + 1 (OUTLET_TYPE): connect to jit.phys.body 2 + 2 (OUTLET_TYPE): dumpout + +Messages: reset + +Attributes: bias, body1, body2, collisions, enable, lowerlimit_ang, lowerlimit_lin, motorstrength, motorvelocity_ang, motorvelocity_lin, position1, position2, quat1, quat2, relaxation, rotate1, rotate2, rotatexyz1, rotatexyz2, spring_ang, spring_lin, springdamp_ang, springdamp_lin, springeq_ang, springeq_lin, springstiff_ang, springstiff_lin, strength, stretch, upperlimit_ang, upperlimit_lin, worldname, worldpos, worldquat +""" + +jit_phys_barslide = MaxObject('jit.phys.barslide') +""" +jit.phys.barslide - A bar constraint in a physics world + +The jit.phys.barslide object constrains attached jit.phys.body objects to rotate and translate around a single axis. Limits and motor forces can be specified for both the linear translation and angular rotation around the constraint. If only a single body is bound, it is constrained to a point in world space. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): connect to jit.phys.body 1 + 1 (OUTLET_TYPE): connect to jit.phys.body 2 + 2 (OUTLET_TYPE): dumpout + +Messages: reset + +Attributes: body1, body2, collisions, damping, enable, linearposition, lowerlimit_ang, lowerlimit_lin, motorstrength_ang, motorstrength_lin, motorvelocity_ang, motorvelocity_lin, position1, position2, quat1, quat2, restitution, rotate1, rotate2, rotatexyz1, rotatexyz2, softness, strength, stretch, upperlimit_ang, upperlimit_lin, worldname, worldpos, worldquat +""" + +jit_phys_body = MaxObject('jit.phys.body') +""" +jit.phys.body - A rigid body and collision shape + +The jit.phys.body object represents a rigid body and collision shape in a physics simulation. The collision shape is either one of several simple shapes, a compound shape (combination of simple shapes), or defined by a matrix of vertices. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): connect to bind objects or position/quat values + 1 (OUTLET_TYPE): dumpout + +Messages: bang, addchild, getchild_dict, impulse, removechild, removechildren, reset, setchild_position, setchild_quat, setchild_scale, setchild_shape, setresetstate, torque_impulse + +Attributes: anim, collisions, damping, enable, enable_sleep, filterclass, filters, force, forces_relative, friction, kinematic, local_scaling, mass, name, position, quat, reduce_hull, resetpos, resetquat, restitution, rolling_friction, rotate, rotate_order, rotatexyz, scale, send_scale, shape, targetname, torque, total_force, total_torque, velocity, velocity_ang, worldname +""" + +jit_phys_conetwist = MaxObject('jit.phys.conetwist') +""" +jit.phys.conetwist - A conetwist constraint in a physics world + +jit.phys.conetwist is a special point-to-point constraint that restricts the translation and allows limits on the rotation. The x-axis serves as a twist axis. This can be useful to represent limbs of a body, such as arms and legs. Motor forces can be applied to the constraint. If only a single body is bound, it is constrained to a point in world space. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): connect to jit.phys.body 1 + 1 (OUTLET_TYPE): connect to jit.phys.body 2 + 2 (OUTLET_TYPE): dumpout + +Messages: reset + +Attributes: bias, body1, body2, collisions, enable, position1, position2, quat1, quat2, relaxation, rotate1, rotate2, rotatexyz1, rotatexyz2, strength, stretch, swing1limit, swing2limit, twistlimit, worldname, worldpos, worldquat +""" + +jit_phys_ghost = MaxObject('jit.phys.ghost') +""" +jit.phys.ghost - A collision sensor and forcefield + +The jit.phys.ghost object represents a sensor area defined by a basic collision shape in a physics world. The collision shape is either one of several simple shapes. Additionally a force field can be enabled to act on colliding objects. The direction vector of the force field can be either in world coordinates, or relative to the jit.phys.ghost object. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): ghost collision dict + 1 (OUTLET_TYPE): dumpout + +Messages: bang, central_impulse, impulse, reset, torque_impulse + +Attributes: central_exp, central_force, central_mode, collision_mode, collisions, enable, filters, force, name, position, quat, rotate, rotate_order, rotatexyz, scale, shape, torque, worldname +""" + +jit_phys_hinge = MaxObject('jit.phys.hinge') +""" +jit.phys.hinge - A hinge constraint in a physics world + +The jit.phys.hinge object restricts two additional angular degrees of freedom so an attached jit.phys.body object can only rotate around the hinge axis. This can be useful to represent doors or wheels rotating around one axis. Limits and Motor forces can be specified for the hinge. If only a single body is bound, it is constrained to a point in world space. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): connect to jit.phys.body 1 + 1 (OUTLET_TYPE): connect to jit.phys.body 2 + 2 (OUTLET_TYPE): dumpout + +Messages: reset + +Attributes: bias, body1, body2, collisions, enable, hingeangle, lowerlimit, motorstrength, motortarget, motorvelocity, position1, position2, quat1, quat2, relaxation, rotate1, rotate2, rotatexyz1, rotatexyz2, strength, stretch, upperlimit, worldname, worldpos, worldquat +""" + +jit_phys_multiple = MaxObject('jit.phys.multiple') +""" +jit.phys.multiple - Uses matrices to simulate multiple rigid bodies + +The jit.phys.multiple object uses several jit.matrix objects to simulate rigid bodies in a physics world. The two outlets connect to the position and rotate matrix inputs of a jit.gl.multiple object allowing for easy visualization of the rigid body shapes. + +Inlets: + 0 (matrix): position array + 1 (matrix): scale array + +Outlets: + 0 (OUTLET_TYPE): position matrix + 1 (OUTLET_TYPE): rotate matrix + 2 (OUTLET_TYPE): dumpout + +Messages: bang, damping_matrix, force_matrix, friction_matrix, getconstraint_dict, impulse, mass_matrix, mesh_matrix, position_matrix, reset, restitution_matrix, rotate_matrix, rotatexyz_matrix, scale_matrix, sendbody, sendbody_reset, sendconstraint, torque_impulse, torque_matrix + +Attributes: constraint, constraint_matrix, constraintoutname, damping, enable, enable_sleep, filterclass, filters, force, forces_relative, friction, kinematic, local_scaling, mass, name, physparams, posoutname, reduce_hull, restitution, rolling_friction, rotoutname, shape, shareshape, torque, worldname +""" + +jit_phys_picker = MaxObject('jit.phys.picker') +""" +jit.phys.picker - Constraint picking in a physics world + +The jit.phys.picker object responds to mouse clicks and drags in the destination by creating a constraint on jit.phys.body objects intersecting with the mouse. Multi-touch picking is facilitated by the touch message. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): mouse picker messages + 1 (OUTLET_TYPE): dumpout + +Messages: touch + +Attributes: body, dynamics, enable, filterclass, filters, hover, local_position, output_positions, pickmode, position, strength, stretch, ui_priority, worldname +""" + +jit_phys_point2point = MaxObject('jit.phys.point2point') +""" +jit.phys.point2point - A point to point constraint in a physics world + +The jit.phys.point2point object limits the translation so that the local pivot points of 2 jit.phys.body objects match in worldspace. If only a single body is bound, it is constrained to a point in world space. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): connect to jit.phys.body 1 + 1 (OUTLET_TYPE): connect to jit.phys.body 2 + 2 (OUTLET_TYPE): dumpout + +Messages: reset + +Attributes: body1, body2, collisions, enable, position1, position2, strength, stretch, worldname, worldpos, worldquat +""" + +jit_phys_world = MaxObject('jit.phys.world') +""" +jit.phys.world - Collision detection and rigid body dynamics + +The jit.phys.world object encapsulates a physics simulation context to perform collision detection and rigid body dynamics on its child objects. Other physics objects in the same patch as a jit.phys.world object are automatically added to the world. Multiple contexts can be managed by explicitly setting the name attribute of the jit.phys.world object and the worldname attribute of the child physics objects. Dynamics can be disabled, allowing the world to be used solely for collision detections. A 2D simulation is achieved with the remove_plane attribute. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): collision list + 1 (OUTLET_TYPE): dumpout + +Messages: bang, raytest, reset, screenraytest + +Attributes: automatic, collision_mode, collisions, drawto, dynamics, enable, fixed_delta, fixedtimestep, gravity, maxsubsteps, name, numcollisions, numthreads, raytest_mode, remove_plane, split_impulse, targetname, worldbox, worldbox_scale +""" + +jit_pix = MaxObject('jit.pix') +""" +jit.pix - Generates Jitter mop pixel processing objects from a patcher. + +The jit.pix object generates new Jitter mop objects from Gen patchers specifically for pixel processing. The patcher describes how each cell of a jit.matrix should be processed. jit.pix is exactly the same as jit.gl.pix except that all processing happens on the CPU as with standard Jitter mop objets. jit.pix always outputs a 4-plane matrix. + +Inlets: + 0 (INLET_TYPE) + +Outlets: + 0 (OUTLET_TYPE) + 1 (OUTLET_TYPE) + +Messages: anything, (drag), compile, (mouse), destroy, open, param, wclose + +Attributes: dirty, gen, precision, t, title +""" + +jit_pix_codebox = MaxObject('jit.pix.codebox') +""" +jit.pix.codebox - Generate Jitter MOP pixel processing objects + +Generates new Jitter Matrix Operator (MOP) objects from GenExpr code. The code describes how each cell of a jit.matrix will be processed. + +Inlets: + 0 (INLET_TYPE): in1 + +Outlets: + 0 (OUTLET_TYPE): out1 + 1 (OUTLET_TYPE): out2 + +Messages: anything, (drag), compile, (mouse), destroy, open, param, wclose + +Attributes: bgcolor, linenumbers, linenumberwidth, margin, style, textcolor, dirty, gen, precision, t, title +""" + +jit_planeop = MaxObject('jit.planeop') +""" +jit.planeop - Operator across planes + +jit.planeop applies an operator to all the planar elements, converting multi-plane input to single-plane output. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: op +""" + +jit_playlist = MaxObject('jit.playlist') +""" +jit.playlist - Play video files + +Use jit.playlist to organize sets of video files and play them back. Each video is given a visual representation in a clip where a selection from the entire video file may be choosen. Clips may be dragged within a jit.playlist to re-order them, or they maybe dragged to other jit.playlist objects by using the handle (dot) on the left side of the clip. + +Inlets: + 0 (INLET_TYPE): Trigger Playlist Cues + +Outlets: + 0 (matrix/texture): Playback Stream + 1 (matrix/texture): Playback Notifications + 2 (dict): (dict) content + +Messages: int, append, clear, (drag), getclipattr, getcontent, (mouse), next, pause, remove, resume, selection, selectionms, setclip + +Attributes: accentcolor, allowreorder, bgcolor, clipheight, color, drawto, elementcolor, expansion, loop, loopreport, output_texture, parameter_enable, parameter_mappable, reportprogress, selectioncolor, showname, style, textcolor +""" + +jit_plot = MaxObject('jit.plot') +""" +jit.plot - (x,y) plotting of a two-plane matrix + +Use jit.plot to render a cartesian plot of a two-plane matrix. + +Attributes: brgb, clearit, frgb, height, width, xmax, xmin, ymax, ymin +""" + +jit_plume = MaxObject('jit.plume') +""" +jit.plume - Displace points based on luminance + +jit.plume takes two input matrices and uses an average value of all planes for each cell in a second input (control) matrix to displace the corresponding cell of the first (input) matrix. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: planeselect + +Attributes: intervalmode, wrap, x_interval, xamount, xinterval, xoffset, y_interval, yamount, yinterval, yoffset +""" + +jit_plur = MaxObject('jit.plur') +""" +jit.plur - Peace Love Unity Rave + +Use the jit.plur object to performs linear interpolation on incoming matrix frames. This object resamples an image and then interpolates back to the original size. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: colormode, gang, hi, lo, mode, scale, x_range, x_step, y_range, y_step +""" + +jit_poke_tilde = MaxObject('jit.poke~') +""" +jit.poke~ - Write an audio signal into a matrix + +jit.poke~ writes the value specified by the leftmost signal input into one plane of a matrix cell at the position specified by the signal inputs (following the leftmost input). The object arguments are [matrix_name] [dim_inputcount] [plane]. + +Inlets: + 0 (signal): value + 1 (signal): dim[0] + 2 (signal): dim[1] + +Outlets: + 0 (OUTLET_TYPE): dumpout + +Messages: signal + +Attributes: matrix_name, normalize, plane +""" + +jit_print = MaxObject('jit.print') +""" +jit.print - Print a matrix in the Max Console + +Use the jit.print object to print values for small matrices display and display them in the Max Console. For larger matrices, use jit.fprint which prints its contents to a file. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: coldelim, fieldwidth, info, mode, planedelim, precision, rowdelim, title, zeropad +""" + +jit_proxy = MaxObject('jit.proxy') +""" +jit.proxy - Proxy a Jitter object. + +jit.proxy proxies named Jitter objects. When an object is proxied, jit.proxy will forward any messages it receives to that object and output messages that return values such as the attribute 'get' messages. + +Inlets: + 0 (INLET_TYPE) + +Outlets: + 0 (OUTLET_TYPE) + 1 (OUTLET_TYPE) + +Messages: bang, int, float, list, anything, send + +Attributes: class, name +""" + +jit_pwindow = MaxObject('jit.pwindow') +""" +jit.pwindow - Display Jitter data and images + +Use jit.pwindow to draw pixels (jit_matrix data) or OpenGL 3D graphics scenes (jit_texture data) within a patcher. When it receives jit_matrix messages it displays them as pixel data and when it receives jit_texture messages it displays them using a passive OpenGL render context. + +Inlets: + 0 (INLET_TYPE): (Matrix) In + +Outlets: + 0 (OUTLET_TYPE): (Matrix) Out + 1 (OUTLET_TYPE): Dumpout + +Messages: bang, jit_gl_texture, jit_matrix, (mouse) + +Attributes: border, bordercolor, colormode, depthbuffer, doublebuffer, dstrect, fsaa, idlemouse, interp, name, onscreen, pickray, planemap, shared, size, srcrect, stereo, sync, usedstrect, usesrcrect +""" + +jit_pworld = MaxObject('jit.pworld') +""" +jit.pworld - Display a Jitter GL context + +Use jit.pworld to draw pixels or graphics within a patcher - it displays jit.matrix data as well as OpenGL 3D graphics. + +Inlets: + 0 (INLET_TYPE): (Matrix) In + +Outlets: + 0 (OUTLET_TYPE): (Matrix) Out + 1 (OUTLET_TYPE): Dumpout + +Messages: bang, int, jit_gl_texture, jit_matrix, (mouse), sendrender, sendvideoplane + +Attributes: auto_handle, border, bordercolor, colormode, depthbuffer, doublebuffer, dstrect, enable, erase_color, fps, fsaa, gizmos, idlemouse, interp, name, onscreen, pickray, planemap, running_fps, shared, size, srcrect, stereo, sync, usedstrect, usesrcrect +""" + +jit_qball = MaxObject('jit.qball') +""" +jit.qball - Convert messages at scheduler time to low priority + +The jit.qball object places all messages received at scheduler time in the low priority queue, even if overdrive is turned off. + +Inlets: + 0 (INLET_TYPE): input + +Outlets: + 0 (OUTLET_TYPE): output + 1 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything, defer, usurp + +Attributes: mode +""" + +jit_qfaker = MaxObject('jit.qfaker') +""" +jit.qfaker - Fake queue status + +Use the jit.qfaker object to set the low priority queue status so that messages received at scheduler time can be executed at scheduler time even in the instance that Max would normally place such events on the low priority queue. + +Inlets: + 0 (INLET_TYPE): input + +Outlets: + 0 (OUTLET_TYPE): output + 1 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything +""" + +jit_qt_grab = MaxObject('jit.qt.grab') +""" +jit.qt.grab - Digitize video from an external source + +Use the jit.grab object to digitize video from any video digitizer and decompress the signal into a Jitter matrix. On OSX, QuickTime is used; on Windows, DirectX is used. + +Inlets: + 0 (INLET_TYPE): bang, messages in + 1 (INLET_TYPE): bang, messages in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: close, exportimage, getinputlist, getvdevlist, open, int + +Attributes: adapt, automatic, colormode, drawto, dstrect, engine, framerate, framereport, input, interp, output_texture, srcrect, texture_name, unique, usedstrect, usesrcrect, vdevice, format +""" + +jit_qt_movie = MaxObject('jit.qt.movie') +""" +jit.qt.movie - Play or edit a movie + +Use the jit.movie for working with movie files - playback, editing, import, export, effect generation and direct-to-video-output-component streaming. + +Inlets: + 0 (INLET_TYPE): bang, messages in + 1 (INLET_TYPE): bang, messages in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: read, framedump, cancelframedump, asyncread, (drag) + +Attributes: adapt, automatic, autostart, colormode, drawto, dstrect, duration, engine, fps, framecount, framereport, interp, loop, loopend, looppoints, loopreport, loopstart, movie_dim, moviedim, moviefile, moviename, moviepath, output_texture, rate, srcrect, texture_name, time, timescale, unique, usedstrect, usesrcrect, vol, time_secs, time_ms, seconds, position, milliseconds, looppoints_secs, looppoints_ms +""" + +jit_qt_record = MaxObject('jit.qt.record') +""" +jit.qt.record - Record a movie + +The jit.record object take a sequence of Jitter matrices as input, saving the sequence to disk as a movie. + +Inlets: + 0 (matrix): in + 1 (matrix) + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: stop + +Attributes: adapt, engine, preview, dstrect, interp, planemap, realtime, srcrect, time, usedstrect, usesrcrect, fps, codec +""" + +jit_qt_videoout = MaxObject('jit.qt.videoout') +""" +jit.qt.videoout - Output video to QuickTime video output component + +jit.qt.videoout takes a matrix as input, compresses the data and sends it directly to a video output component (VOC). + +Inlets: + 0 (matrix): in + 1 (matrix) + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: close, getvoclist, getvocmodes, open + +Attributes: codecquality, colormode, voc, vocmode +""" + +jit_quat = MaxObject('jit.quat') +""" +jit.quat - Quaternion multiplication + +jit.quat will perform quaternion multiplication, with optional normalization of the input quaternions. In relation to 3D transforms, quaternion multiplication is the concatenation of two orientations. Jitter quaternions are ordered X Y Z W. + +Inlets: + 0 (INLET_TYPE): quat 1 + 1 (INLET_TYPE): quat 2 + +Outlets: + 0 (OUTLET_TYPE): quat out + 1 (OUTLET_TYPE): dumpout + +Messages: bang, list + +Attributes: inverse, normalize, quat1, quat2, quatout, xaxis, yaxis, zaxis +""" + +jit_quat2axis = MaxObject('jit.quat2axis') +""" +jit.quat2axis - Quaternion to angle-axis conversion + +Convert a quaternion (a four-dimensional vector) to an angle-axis representation. Jitter quaternions are ordered X Y Z W. + +Inlets: + 0 (INLET_TYPE): quat in + +Outlets: + 0 (OUTLET_TYPE): angle axis out + 1 (OUTLET_TYPE): dumpout + +Messages: bang, list + +Attributes: angleaxis, normalize, quat +""" + +jit_quat2euler = MaxObject('jit.quat2euler') +""" +jit.quat2euler - Quaternion to Euler conversion + +Convert a quaternion (a four-dimensional vector) to Euler X Y Z angles. Jitter quaternions are ordered X Y Z W. + +Inlets: + 0 (INLET_TYPE): quat in + +Outlets: + 0 (OUTLET_TYPE): euler xyz out + 1 (OUTLET_TYPE): dumpout + +Messages: bang, list + +Attributes: euler, normalize, quat, rotate_order +""" + +jit_record = MaxObject('jit.record') +""" +jit.record - Record a movie + +The jit.record object take a sequence of Jitter matrices as input, saving the sequence to disk as a movie. Currently only 4 plane, char type matrix input is supported. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: stop, write + +Attributes: adapt, codec, dstrect, engine, fps, interp, planemap, preview, realtime, srcrect, time, usedstrect, usesrcrect +""" + +jit_release_tilde = MaxObject('jit.release~') +""" +jit.release~ - Transforms matrix data into signals + +jit.release~ takes floating-point jitter matrices as input and transforms the stream of jitter matrices into MSP signals. + +Inlets: + 0 (matrix): incoming matrices + +Outlets: + 0 (signal): channel 1 + 1 (signal): dumpout + +Attributes: mode, latency +""" + +jit_repos = MaxObject('jit.repos') +""" +jit.repos - Reposition spatially + +jit.repos performs cell positioning on an input matrix received in its left inlet using the input from a second input matrix received in its right Inlet as a spatial map. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: boundmode, interpbits, mode, offset_x, offset_y +""" + +jit_resamp = MaxObject('jit.resamp') +""" +jit.resamp - Resample spatially + +jit.resamp spatially resamples the input matrix. This can be used to scale (zoom in/out) and offset (move) an image horizontally, vertically, or in both directions. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: interp_x, interp_y, wrap, xscale, xshift, yscale, yshift +""" + +jit_reverse = MaxObject('jit.reverse') +""" +jit.reverse - Reverse output with respect to input + +jit.reverse reverses the sequential order of data coming in its inlets, relative to its outlets; a jit.reverse object with 5 inlets will pass input sent to the left inlet to its rightmost outlet, pass inlet 2 data to outlet 4, and so on. + +Inlets: + 0 (INLET_TYPE): inlet 1 (anything) + 1 (INLET_TYPE): inlet 2 (anything) + +Outlets: + 0 (OUTLET_TYPE): outlet 1 + 1 (OUTLET_TYPE): outlet 2 + +Messages: bang, int, float, list, anything, clear + +Attributes: immediate, reverse +""" + +jit_rgb2hsl = MaxObject('jit.rgb2hsl') +""" +jit.rgb2hsl - Convert RGB to HSL + +jit.hsl2rgb converts a 4 plane matrix of ARGB (alpha, red, green, blue) data to AHSL (alpha, hue, saturation, lightness) data. An offset and a scaling factor can be applied to the hue, saturation, and lightness data individually. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: hoffset, hscale, loffset, lscale, soffset, sscale +""" + +jit_rgb2luma = MaxObject('jit.rgb2luma') +""" +jit.rgb2luma - Converts RGB to monochrome (luminance) + +jit.rgb2luma converts a 4-plane char ARGB (alpha, red, green, blue) matrix into a 1-plane char monochrome matrix containing the luminosity of the original matrix using the equation L = (.299 * R value) + (.587 * G value) + (.114 * B value). + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: ascale, bscale, gscale, rscale +""" + +jit_robcross = MaxObject('jit.robcross') +""" +jit.robcross - Robert's Cross edge detection + +jit.robcross implements the Robert's Cross method of edge detection. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: thresh +""" + +jit_rota = MaxObject('jit.rota') +""" +jit.rota - Scale/rotate in 2D + +Use the jit.rota object for quick 2-dimemsional scaling and rotation of matrices. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: anchor_x, anchor_y, boundmode, cosoffset_x, cosoffset_y, cosscale_x, cosscale_y, interp, offset_x, offset_y, sinoffset_x, sinoffset_y, sinscale_x, sinscale_y, theta, thetaoffsetcos_x, thetaoffsetcos_y, thetaoffsetsin_x, thetaoffsetsin_y, thetascalecos_x, thetascalecos_y, thetascalesin_x, thetascalesin_y, zoom_x, zoom_y +""" + +jit_roy = MaxObject('jit.roy') +""" +jit.roy - Convert image to halftone image + +jit.roy is a halftone screen emulator. It takes an input matrix and splits it into a grid. Each element in the grid is then replaced by regions of a second matrix based on the mean value of each slot in the grid. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: shades, x, y +""" + +jit_rubix = MaxObject('jit.rubix') +""" +jit.rubix - Reorder grid of rectangles + +jit.rubix segments a matrix into a grid of rectangular cells whose cells can be reordered, flipped both horizontally and vertically, frozen, and filled with a single color value derived from a cell in the grid area (monochromatic). + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: colrot, freeze, hflip, mono, nomono, reset, rowrot, setcell, vflip + +Attributes: cols, dots, prob, probmono, rows +""" + +jit_scalebias = MaxObject('jit.scalebias') +""" +jit.scalebias - Multiply and add + +jit.scalebias scales the values of a 4-plane input matrix of type char (ARGB) and adds to an offset value (bias). + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: abias, ascale, bbias, bias, bscale, gbias, gscale, mode, rbias, rscale, scale +""" + +jit_scanoffset = MaxObject('jit.scanoffset') +""" +jit.scanoffset - Uses a 1-dimensional matrix to offset scanlines + +jit.scanoffset uses a 1-dimensional slice of one matrix as a map for the offset and scale of the scanlines of another matrix. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: displacement_map, interp, mode, offset, scale +""" + +jit_scanslide = MaxObject('jit.scanslide') +""" +jit.scanslide - Cellwise spatial envelope follower + +Use the jit.scanslide object to perform cellwise spatial envelope following across dimension 0 or 1. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: dimmode, mode, offset, slide_down, slide_up +""" + +jit_scanwrap = MaxObject('jit.scanwrap') +""" +jit.scanwrap - Resample by scanline wrapping + +The jit.scanwrap object rewraps an input matrix into an output matrix. Matrix output handling is specified by a mode attribute. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: purge, reset + +Attributes: mode +""" + +jit_scissors = MaxObject('jit.scissors') +""" +jit.scissors - Cut up a matrix into evenly spaced sub matrices + +jit.scissors takes a single matrix and cuts it into uniform rectangular regions, outputting each one out a separate outlet as a new matrix. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: anything + +Attributes: columns, rows +""" + +jit_scope = MaxObject('jit.scope') +""" +jit.scope - Visual matrix analysis tools + +jit.scope lets you visually inspecting matrix values and display them as waveform, vectorscope, histogram or parade visual data. + +Inlets: + 0 (INLET_TYPE): (Matrix) In + +Outlets: + 0 (OUTLET_TYPE): (Matrix) Out + 1 (OUTLET_TYPE): Dumpout + +Messages: bang, jit_matrix, (mouse) + +Attributes: accum, accum_desat, bgcolor, border, colormode, dstrect, graphcolor, graphmode, hgraphcolor, hpopupbackgcolor, hpopupcolor, interp, mode, planemap, popupbackgcolor, popupcolor, size, srcrect, style +""" + +jit_shade = MaxObject('jit.shade') +""" +jit.shade - Map-based crossfader + +jit.shade performs a linear crossfade between corresponding cells in two input matrices at a rate determined by the values of the cells of a third "map" matrix. The crossfade rate is calculated in frames rather than units of time. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + 2 (matrix): in3 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: reset + +Attributes: max, min, mode +""" + +jit_slide = MaxObject('jit.slide') +""" +jit.slide - Cellwise temporal envelope follower + +The jit.slide object performs cellwise temporal envelope following.` + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: slide_down, slide_up +""" + +jit_sobel = MaxObject('jit.sobel') +""" +jit.sobel - Sobel and Prewitt gradient edge detector + +jit.sobel provides two different kinds of edge detection algorithms. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: mode, thresh +""" + +jit_spill = MaxObject('jit.spill') +""" +jit.spill - Unroll a matrix into a list + +jit.spill outputs matrix values as a Max list, starting from a specified offset. The object will only wrap around two dimensions. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (list): spill + 1 (list): spill + +Attributes: listlength, offset, plane +""" + +jit_split = MaxObject('jit.split') +""" +jit.split - Split a matrix into two matrices + +jit.split takes a single matrix, divides it along a specified dimension at a specified point, and outputs the two resulting matrices. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): out2 + 2 (matrix): dumpout + +Attributes: autoclear, splitdim, splitpoint +""" + +jit_sprinkle = MaxObject('jit.sprinkle') +""" +jit.sprinkle - Introduce spatial noise + +jit.sprinkle probabilistically determines whether a matrix cell will be displaced by a random amount along the horizontal or vertical axes to produce a "cloud" of data surrounding the original cell values. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: prob, x_range, y_range +""" + +jit_str_fromsymbol = MaxObject('jit.str.fromsymbol') +""" +jit.str.fromsymbol - Convert Max symbol to Jitter string matrix + +Use the jit.str.tosymbol object to convert Max symbols into string matrices. An optional argument can be used to specify the length of the 1-dim matrix. + +Inlets: + 0 (anything): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: int, float, list, anything +""" + +jit_str_op = MaxObject('jit.str.op') +""" +jit.str.op - Apply common string operations + +Use the jit.str.op object to perform common string operations on string matrices. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: end, multiline_in, multiline_out, op, start +""" + +jit_str_regexp = MaxObject('jit.str.regexp') +""" +jit.str.regexp - Use PERL-compatible regular expressions on Jitter matrices + +jit.str.regexp performs regular expression analysis to Jitter matrices with optional substitution. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): descriptor matrix + 1 (matrix): substitution output + 2 (matrix): backreferences + 3 (matrix): substrings + 4 (matrix): dumpout + +Attributes: descriptor, re, substitute +""" + +jit_str_tosymbol = MaxObject('jit.str.tosymbol') +""" +jit.str.tosymbol - Convert Jitter string matrix to Max symbol + +Use the jit.str.tosymbol object to convert a string matrix into a Max symbol. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (symbol): out + 1 (symbol): dumpout + +Attributes: outsym +""" + +jit_streak = MaxObject('jit.streak') +""" +jit.streak - Probability lines + +The jit.streak object uses a specified probability to determine the chance that a given matrix cell's value will be extended to subsequent cells (with an optional scaling factor). The result is a streaky good time. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: direction, mode, prob, scale +""" + +jit_submatrix = MaxObject('jit.submatrix') +""" +jit.submatrix - Reference a sub-region of a matrix + +Use the jit.submatrix object when you want to reference a sub region of an input matrix without copying data. + + + Some objects, such as jit.cellblock, are unable to use the reference matrix, so it may be necessary to pass the output through another jit.matrix in certain cases. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: offset +""" + +jit_textfile = MaxObject('jit.textfile') +""" +jit.textfile - Read and write a matrix as an ASCII text file + +The jit.textfile object maintains a text buffer, into which a text file or char matrix can be imported. The buffer can also be edited directly by double-clicking on the object to open an editor window. A bang to the object causes the text buffer to be sent out the left outlet as a matrix. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): out2 + 2 (matrix): dumpout + +Messages: (mouse), erase, line, open, outputline, read, wclose, write + +Attributes: autoclear, defaultdir, convert, title +""" + +jit_thin = MaxObject('jit.thin') +""" +jit.thin - Remove redundant dimensions of size 1 + +The jit.thin object removes redundant dimensions of size 1. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_tiffany = MaxObject('jit.tiffany') +""" +jit.tiffany - Arbitrary rectangular resampling + +The jit.tiffany object performs an arbitrary rectangular resampling of a matrix. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: x, xy, y + +Attributes: bgcolor, grid, xrange, xskip, yrange, yskip +""" + +jit_traffic = MaxObject('jit.traffic') +""" +jit.traffic - Multiply the planar vector by a matrix + +The jit.traffic object takes an input matrix and multiplies its cells using an N x N+1 float32 matrix (where N is the planecount of the input matrix). The left input matrix can be of any type. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_transpose = MaxObject('jit.transpose') +""" +jit.transpose - Calculate the transpose of a matrix + +Use the jit.transpose object to calculate the transpose of a matrix: rows become columns, and vice versa. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_turtle = MaxObject('jit.turtle') +""" +jit.turtle - 2-d turtle graphics interpreter + +The jit.turtle object emulates simple LOGO-style graphics. It interprets single char values in its inlet as ASCII letters that describe turtle graphics commands. A valid ASCII input will generate appropriate drawing commands for use with either the Max lcd object or the jit.lcd object. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: int, reset + +Attributes: angle, clearmode, origin, scale +""" + +jit_uldl = MaxObject('jit.uldl') +""" +jit.uldl - Internet upload/download + +The jit.uldl object provides asynchronous file upload and download. Download is possible from http://, https://, ftp://, and file:/// URLs. Upload is only possible to ftp:// URLs. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: abort, download, upload + +Attributes: defaultdir, convert, dir_list, dirlist, passive, password, percent, report, url_dl, url_ul, urldl, urlul, username +""" + +jit_unpack = MaxObject('jit.unpack') +""" +jit.unpack - Make multiple single plane matrices out of a multiplane matrix + +The jit.unpack object splits one N-plane matrix into N single-plane matrices. This is useful for splitting one ARGB matrix into separate alpha, red, green, and blue matrices, and similar types of splitting. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): out2 + 2 (matrix): out3 + 3 (matrix): out4 + 4 (matrix): dumpout + +Messages: anything + +Attributes: jump, offset +""" + +jit_uyvy2argb = MaxObject('jit.uyvy2argb') +""" +jit.uyvy2argb - Converts UYVY to ARGB + +The jit.uyvy2argb object converts a 4-plane char UYVY (signed chroma blue, luminance left, signed chroma red, luminance right) matrix into a 4-plane char ARGB (alpha, red, green, blue) matrix. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: noalpha +""" + +jit_uyvy2ayuv = MaxObject('jit.uyvy2ayuv') +""" +jit.uyvy2ayuv - Converts UYVY to AYUV + +The jit.uyvy2ayuv object converts a 4-plane char UYVY (signed chroma blue, luminance left, signed chroma red, luminance right) matrix into a 4-plane char AYUV (alpha, luminance, signed chroma blue, signed chroma red) matrix. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: noalpha +""" + +jit_uyvy2luma = MaxObject('jit.uyvy2luma') +""" +jit.uyvy2luma - Converts UYVY to monochrome (luminance) + +The jit.uyvy2luma object converts a 4-plane char UYVY (signed chroma blue, luminance left, signed chroma red, luminance right) matrix into a 1-plane char monochrome (luma) matrix. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout +""" + +jit_vcr = MaxObject('jit.vcr') +""" +jit.vcr - Record a movie with MSP audio + +Use the jit.vcr object combine a sequence of Jitter matrices and MSP audio and save the sequence to disk as a synchronized movie. The two left inlets accept MSP audio signals (if only 1 inlet is used, the movie's audio will be monophonic). The right inlet accepts a Jitter matrix. + +Inlets: + 0 (INLET_TYPE): MSP audio in 1 + 1 (INLET_TYPE): MSP audio in 2 + 2 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Messages: signal, stop, write + +Attributes: adapt, codec, dstrect, engine, fps, interp, planemap, preview, srcrect, time, usedstrect, usesrcrect +""" + +jit_wake = MaxObject('jit.wake') +""" +jit.wake - Feedback with convolution stage + +Use the jit.wake object to perform video feedback with a convolution stage. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: bdownbleed, bfb, bff, bgain, bleed, bleftbleed, brightbleed, bupbleed, fb, ff, gain, gdownbleed, gfb, gff, ggain, gleftbleed, grightbleed, gupbleed, normalize, rdownbleed, rfb, rff, rgain, rleftbleed, rrightbleed, rupbleed +""" + +jit_window = MaxObject('jit.window') +""" +jit.window - Display data in a window + +Use the jit.window object to draw pixels or graphics to a window. jit.window displays jit.matrix data as well as OpenGL 3D graphics. + +Inlets: + 0 (matrix): in + +Outlets: + 0 (OUTLET_TYPE): bangout + 1 (OUTLET_TYPE): dumpout + +Messages: (mouse), front, sendtexture + +Attributes: border, clamp, colormode, depthbuffer, doublebuffer, dstrect, floating, fsaa, fsmenubar, fullscreen, grow, idlemouse, interp, mousewheel, name, noaccel, pickray, planemap, pos, rect, shared, size, srcrect, stereo, sync, title, usedstrect, usesrcrect, visible +""" + +jit_world = MaxObject('jit.world') +""" +jit.world - The Jitter world context + +The jit.world object encapsulates the functionality of several jitter objects, including jit.window, jit.gl.render, jit.gl.node, jit.gl.cornerpin and jit.phys.world. Physics and GL objects are automatically added to the jit.world context and video objects have their automatic output enabled, when in the same patch. + +Args: + name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): messages to this 3d object + +Outlets: + 0 (OUTLET_TYPE): texture or matrix output if enabled + 1 (OUTLET_TYPE): render draw bang + 2 (OUTLET_TYPE): dumpout + +Messages: bang, int, clear, (mouse), draw, front, jit_gl_texture, sendcornerpin, sendhandle, sendnode, sendphys, sendrender, sendwindow + +Attributes: border, auto_handle, enable, depth_sort, dim, displaylink, drawbang, drawto, capture, fixed_delta, floating, fps, fsaa, fsmenubar, fullscreen, enable_cornerpin, erase_color, esc_fullscreen, interval, high_res, gizmos, matrix_mode_async, ortho, output_matrix, output_texture, name, phys_worldname, position, preserve_aspect, size, rect, shared, sync, rotate, quat, rotatexyz, scale, running_fps, transparency, windowposition, visible +""" + +jit_xfade = MaxObject('jit.xfade') +""" +jit.xfade - Crossfade between 2 matrices + +Use the jit.xfade object to crossfade between two matrices. A crossfade value of 0. results in output values equivalent to the left input values, while a crossfade value of 1.0 results in output values equivalent to the right input matrix. + +Inlets: + 0 (matrix): in + 1 (matrix): in2 + +Outlets: + 0 (matrix): out + 1 (matrix): dumpout + +Attributes: xfade +""" + +mc_jit_peek_tilde = MaxObject('mc.jit.peek~') +""" +mc.jit.peek~ - Read matrix data as an audio signal (multichannel) + +jit.peek~ reads the value of one plane of a matrix cell at the position specified by the signal inputs. This value is output as a signal. The object arguments are [matrix_name] [dim_inputcount] [plane]. + +Inlets: + 0 (signal): dim[0] + 1 (signal): dim[1] + +Outlets: + 0 (signal): value + 1 (signal): dumpout + +Messages: signal + +Attributes: interp, matrix_name, normalize, plane +""" + +_sys.stdout = _old_stdout +_devnull.close() +del _devnull, _old_stdout diff --git a/maxpylang/objects/max.py b/maxpylang/objects/max.py new file mode 100644 index 0000000..5694bb1 --- /dev/null +++ b/maxpylang/objects/max.py @@ -0,0 +1,9901 @@ +"""MaxObject stubs for max objects. Auto-generated by import_objs().""" +import os as _os +import sys as _sys +from maxpylang.maxobject import MaxObject + +__all__ = [ + 'abs_', + 'absolutepath', + 'accum', + 'acos', + 'acosh', + 'active', + 'anal', + 'append', + 'array', + 'array_change', + 'array_compare', + 'array_concat', + 'array_deserialize', + 'array_every', + 'array_expr', + 'array_fill', + 'array_filter', + 'array_flatten', + 'array_foreach', + 'array_frombuffer', + 'array_group', + 'array_index', + 'array_indexmap', + 'array_indexof', + 'array_insert', + 'array_iter', + 'array_join', + 'array_length', + 'array_map', + 'array_max', + 'array_mean', + 'array_median', + 'array_min', + 'array_mode', + 'array_pop', + 'array_push', + 'array_random', + 'array_reduce', + 'array_regexp', + 'array_remove', + 'array_replace', + 'array_reverse', + 'array_rotate', + 'array_routepass', + 'array_scramble', + 'array_sect', + 'array_shift', + 'array_slice', + 'array_some', + 'array_sort', + 'array_split', + 'array_stddev', + 'array_stream', + 'array_subarray', + 'array_thin', + 'array_tobuffer', + 'array_tolist', + 'array_tostring', + 'array_tosymbol', + 'array_tuplewise', + 'array_union', + 'array_unique', + 'array_unshift', + 'array_wrap', + 'asin', + 'asinh', + 'atan', + 'atan2', + 'atanh', + 'atodb', + 'atoi', + 'attrui', + 'autopattr', + 'bag', + 'bangbang', + 'bendin', + 'bendout', + 'bgcolor', + 'bitand', + 'bitor', + 'bline', + 'bondo', + 'borax', + 'bpatcher', + 'bucket', + 'buddy', + 'button', + 'capture', + 'cartopol', + 'change', + 'chooser', + 'clip', + 'clocker', + 'closebang', + 'coll', + 'coll_codebox', + 'colorpicker', + 'combine', + 'comment', + 'conformpath', + 'console', + 'cos', + 'cosh', + 'counter', + 'cpuclock', + 'crosspatch', + 'ctlin', + 'ctlout', + 'cycle', + 'date', + 'dbtoa', + 'decide', + 'decode', + 'defer', + 'deferlow', + 'delay', + 'detonate', + 'dial', + 'dialog', + 'dict_', + 'dict_codebox', + 'dict_compare', + 'dict_deserialize', + 'dict_group', + 'dict_iter', + 'dict_join', + 'dict_pack', + 'dict_print', + 'dict_route', + 'dict_serialize', + 'dict_slice', + 'dict_strip', + 'dict_unpack', + 'dict_view', + 'div', + 'dropfile', + 'drunk', + 'equals', + 'error', + 'expr', + 'filedate', + 'filein', + 'filepath', + 'filewatch', + 'float_', + 'flonum', + 'flush', + 'folder', + 'follow', + 'fontlist', + 'forward', + 'fpic', + 'freebang', + 'fromsymbol', + 'fswap', + 'ftom', + 'funbuff', + 'function', + 'funnel', + 'gamepad', + 'gate', + 'gestalt', + 'getattr_', + 'grab', + 'greaterthan', + 'greaterthaneq', + 'gswitch', + 'gswitch2', + 'hi', + 'hid', + 'hint', + 'histo', + 'hover', + 'if_', + 'imovie', + 'incdec', + 'inlet', + 'int_', + 'itable', + 'iter_', + 'itoa', + 'jit_cellblock', + 'join', + 'js', + 'jstrigger', + 'jsui', + 'jweb', + 'jweb_tilde', + 'key', + 'keyup', + 'kslider', + 'lcd', + 'led', + 'lessthan', + 'lessthaneq', + 'line', + 'linedrive', + 'listbox', + 'listfunnel', + 'loadbang', + 'loadmess', + 'logand', + 'logor', + 'makenote', + 'mappings', + 'match', + 'matrix', + 'matrixctrl', + 'maximum', + 'maxurl', + 'mc_function', + 'mc_getattr', + 'mc_line', + 'mean', + 'menubar', + 'message', + 'messageview', + 'metro', + 'midiflush', + 'midiformat', + 'midiin', + 'midiinfo', + 'midiout', + 'midiparse', + 'minimum', + 'minus', + 'modifiers', + 'modulo', + 'mousefilter', + 'mousestate', + 'movie', + 'mpeconfig', + 'mpeformat', + 'mpeparse', + 'mtof', + 'mtr', + 'multirange', + 'multislider', + 'mxj', + 'next_', + 'nodes', + 'notein', + 'noteout', + 'notequals', + 'nrpnin', + 'nrpnout', + 'nslider', + 'number', + 'numkey', + 'offer', + 'onebang', + 'onecopy', + 'opendialog', + 'osc_codebox', + 'osc_packet', + 'outlet', + 'pack', + 'pak', + 'panel', + 'param', + 'param_osc', + 'past', + 'patcher', + 'patcherargs', + 'pattr', + 'pattrforward', + 'pattrhub', + 'pattrmarker', + 'pattrstorage', + 'pcontrol', + 'peak', + 'pgmin', + 'pgmout', + 'pictctrl', + 'pictslider', + 'pipe', + 'playbar', + 'plus', + 'poltocar', + 'poly', + 'polyin', + 'polymidiin', + 'polyout', + 'pong', + 'pow_', + 'prepend', + 'preset', + 'print_', + 'prob', + 'project', + 'pv', + 'pvar', + 'qlim', + 'qlist', + 'qmetro', + 'quickthresh', + 'radiogroup', + 'random', + 'rdiv', + 'receive', + 'regexp', + 'relativepath', + 'repl', + 'rminus', + 'round_', + 'route', + 'routepass', + 'router', + 'rpnin', + 'rpnout', + 'rslider', + 'rtin', + 'savebang', + 'savedialog', + 'scale', + 'schedule', + 'screensize', + 'select', + 'send', + 'seq', + 'serial', + 'setclock', + 'shiftleft', + 'shiftright', + 'sin', + 'sinh', + 'slide', + 'slider', + 'speedlim', + 'spell', + 'split', + 'spray', + 'sprintf', + 'sqrt', + 'standalone', + 'stepcounter', + 'string', + 'string_append', + 'string_bytes', + 'string_change', + 'string_compare', + 'string_concat', + 'string_contains', + 'string_endswith', + 'string_frombytes', + 'string_fromsymlist', + 'string_fromutf8', + 'string_index', + 'string_indexof', + 'string_iter', + 'string_length', + 'string_prepend', + 'string_regexp', + 'string_remove', + 'string_replace', + 'string_replaceall', + 'string_reverse', + 'string_rotate', + 'string_slice', + 'string_split', + 'string_sprintf', + 'string_startswith', + 'string_substring', + 'string_toarray', + 'string_tolist', + 'string_tolower', + 'string_tosymbol', + 'string_toupper', + 'string_trim', + 'string_trimend', + 'string_trimstart', + 'string_utf8', + 'string_withpass', + 'stripnote', + 'strippath', + 'substitute', + 'suckah', + 'suspend', + 'sustain', + 'swap', + 'swatch', + 'switch', + 'sxformat', + 'sysexin', + 'tab', + 'tabcontroller', + 'table', + 'tan', + 'tanh', + 'tempo', + 'text', + 'text_codebox', + 'textbox', + 'textbutton', + 'textedit', + 'themecolor', + 'thisobject', + 'thispatcher', + 'threadcheck', + 'thresh', + 'timepoint', + 'timer', + 'times', + 'togedge', + 'toggle', + 'tosymbol', + 'touchin', + 'touchout', + 'translate', + 'transport', + 'trigger', + 'trough', + 'ubutton', + 'udpreceive', + 'udpsend', + 'umenu', + 'universal', + 'unjoin', + 'unpack', + 'urn', + 'uzi', + 'v8', + 'v8_codebox', + 'v8ui', + 'value', + 'vdp', + 'vexpr', + 'vstscan', + 'when', + 'xbendin', + 'xbendout', + 'xctlin', + 'xctlout', + 'xmidiin', + 'xnotein', + 'xnoteout', + 'zl', + 'zl_change', + 'zl_compare', + 'zl_delace', + 'zl_ecils', + 'zl_filter', + 'zl_group', + 'zl_indexmap', + 'zl_iter', + 'zl_join', + 'zl_lace', + 'zl_len', + 'zl_lookup', + 'zl_median', + 'zl_mth', + 'zl_nth', + 'zl_queue', + 'zl_reg', + 'zl_rev', + 'zl_rot', + 'zl_scramble', + 'zl_sect', + 'zl_slice', + 'zl_sort', + 'zl_stack', + 'zl_stream', + 'zl_sub', + 'zl_sum', + 'zl_swap', + 'zl_thin', + 'zl_union', + 'zl_unique', + 'zmap', +] + +_NAMES = { + 'abs_': 'abs', + 'absolutepath': 'absolutepath', + 'accum': 'accum', + 'acos': 'acos', + 'acosh': 'acosh', + 'active': 'active', + 'anal': 'anal', + 'append': 'append', + 'array': 'array', + 'array_change': 'array.change', + 'array_compare': 'array.compare', + 'array_concat': 'array.concat', + 'array_deserialize': 'array.deserialize', + 'array_every': 'array.every', + 'array_expr': 'array.expr', + 'array_fill': 'array.fill', + 'array_filter': 'array.filter', + 'array_flatten': 'array.flatten', + 'array_foreach': 'array.foreach', + 'array_frombuffer': 'array.frombuffer', + 'array_group': 'array.group', + 'array_index': 'array.index', + 'array_indexmap': 'array.indexmap', + 'array_indexof': 'array.indexof', + 'array_insert': 'array.insert', + 'array_iter': 'array.iter', + 'array_join': 'array.join', + 'array_length': 'array.length', + 'array_map': 'array.map', + 'array_max': 'array.max', + 'array_mean': 'array.mean', + 'array_median': 'array.median', + 'array_min': 'array.min', + 'array_mode': 'array.mode', + 'array_pop': 'array.pop', + 'array_push': 'array.push', + 'array_random': 'array.random', + 'array_reduce': 'array.reduce', + 'array_regexp': 'array.regexp', + 'array_remove': 'array.remove', + 'array_replace': 'array.replace', + 'array_reverse': 'array.reverse', + 'array_rotate': 'array.rotate', + 'array_routepass': 'array.routepass', + 'array_scramble': 'array.scramble', + 'array_sect': 'array.sect', + 'array_shift': 'array.shift', + 'array_slice': 'array.slice', + 'array_some': 'array.some', + 'array_sort': 'array.sort', + 'array_split': 'array.split', + 'array_stddev': 'array.stddev', + 'array_stream': 'array.stream', + 'array_subarray': 'array.subarray', + 'array_thin': 'array.thin', + 'array_tobuffer': 'array.tobuffer', + 'array_tolist': 'array.tolist', + 'array_tostring': 'array.tostring', + 'array_tosymbol': 'array.tosymbol', + 'array_tuplewise': 'array.tuplewise', + 'array_union': 'array.union', + 'array_unique': 'array.unique', + 'array_unshift': 'array.unshift', + 'array_wrap': 'array.wrap', + 'asin': 'asin', + 'asinh': 'asinh', + 'atan': 'atan', + 'atan2': 'atan2', + 'atanh': 'atanh', + 'atodb': 'atodb', + 'atoi': 'atoi', + 'attrui': 'attrui', + 'autopattr': 'autopattr', + 'bag': 'bag', + 'bangbang': 'bangbang', + 'bendin': 'bendin', + 'bendout': 'bendout', + 'bgcolor': 'bgcolor', + 'bitand': 'bitand', + 'bitor': 'bitor', + 'bline': 'bline', + 'bondo': 'bondo', + 'borax': 'borax', + 'bpatcher': 'bpatcher', + 'bucket': 'bucket', + 'buddy': 'buddy', + 'button': 'button', + 'capture': 'capture', + 'cartopol': 'cartopol', + 'change': 'change', + 'chooser': 'chooser', + 'clip': 'clip', + 'clocker': 'clocker', + 'closebang': 'closebang', + 'coll': 'coll', + 'coll_codebox': 'coll.codebox', + 'colorpicker': 'colorpicker', + 'combine': 'combine', + 'comment': 'comment', + 'conformpath': 'conformpath', + 'console': 'console', + 'cos': 'cos', + 'cosh': 'cosh', + 'counter': 'counter', + 'cpuclock': 'cpuclock', + 'crosspatch': 'crosspatch', + 'ctlin': 'ctlin', + 'ctlout': 'ctlout', + 'cycle': 'cycle', + 'date': 'date', + 'dbtoa': 'dbtoa', + 'decide': 'decide', + 'decode': 'decode', + 'defer': 'defer', + 'deferlow': 'deferlow', + 'delay': 'delay', + 'detonate': 'detonate', + 'dial': 'dial', + 'dialog': 'dialog', + 'dict_': 'dict', + 'dict_codebox': 'dict.codebox', + 'dict_compare': 'dict.compare', + 'dict_deserialize': 'dict.deserialize', + 'dict_group': 'dict.group', + 'dict_iter': 'dict.iter', + 'dict_join': 'dict.join', + 'dict_pack': 'dict.pack', + 'dict_print': 'dict.print', + 'dict_route': 'dict.route', + 'dict_serialize': 'dict.serialize', + 'dict_slice': 'dict.slice', + 'dict_strip': 'dict.strip', + 'dict_unpack': 'dict.unpack', + 'dict_view': 'dict.view', + 'div': 'div', + 'dropfile': 'dropfile', + 'drunk': 'drunk', + 'equals': 'equals', + 'error': 'error', + 'expr': 'expr', + 'filedate': 'filedate', + 'filein': 'filein', + 'filepath': 'filepath', + 'filewatch': 'filewatch', + 'float_': 'float', + 'flonum': 'flonum', + 'flush': 'flush', + 'folder': 'folder', + 'follow': 'follow', + 'fontlist': 'fontlist', + 'forward': 'forward', + 'fpic': 'fpic', + 'freebang': 'freebang', + 'fromsymbol': 'fromsymbol', + 'fswap': 'fswap', + 'ftom': 'ftom', + 'funbuff': 'funbuff', + 'function': 'function', + 'funnel': 'funnel', + 'gamepad': 'gamepad', + 'gate': 'gate', + 'gestalt': 'gestalt', + 'getattr_': 'getattr', + 'grab': 'grab', + 'greaterthan': 'greaterthan', + 'greaterthaneq': 'greaterthaneq', + 'gswitch': 'gswitch', + 'gswitch2': 'gswitch2', + 'hi': 'hi', + 'hid': 'hid', + 'hint': 'hint', + 'histo': 'histo', + 'hover': 'hover', + 'if_': 'if', + 'imovie': 'imovie', + 'incdec': 'incdec', + 'inlet': 'inlet', + 'int_': 'int', + 'itable': 'itable', + 'iter_': 'iter', + 'itoa': 'itoa', + 'jit_cellblock': 'jit.cellblock', + 'join': 'join', + 'js': 'js', + 'jstrigger': 'jstrigger', + 'jsui': 'jsui', + 'jweb': 'jweb', + 'jweb_tilde': 'jweb~', + 'key': 'key', + 'keyup': 'keyup', + 'kslider': 'kslider', + 'lcd': 'lcd', + 'led': 'led', + 'lessthan': 'lessthan', + 'lessthaneq': 'lessthaneq', + 'line': 'line', + 'linedrive': 'linedrive', + 'listbox': 'listbox', + 'listfunnel': 'listfunnel', + 'loadbang': 'loadbang', + 'loadmess': 'loadmess', + 'logand': 'logand', + 'logor': 'logor', + 'makenote': 'makenote', + 'mappings': 'mappings', + 'match': 'match', + 'matrix': 'matrix', + 'matrixctrl': 'matrixctrl', + 'maximum': 'maximum', + 'maxurl': 'maxurl', + 'mc_function': 'mc.function', + 'mc_getattr': 'mc.getattr', + 'mc_line': 'mc.line', + 'mean': 'mean', + 'menubar': 'menubar', + 'message': 'message', + 'messageview': 'messageview', + 'metro': 'metro', + 'midiflush': 'midiflush', + 'midiformat': 'midiformat', + 'midiin': 'midiin', + 'midiinfo': 'midiinfo', + 'midiout': 'midiout', + 'midiparse': 'midiparse', + 'minimum': 'minimum', + 'minus': 'minus', + 'modifiers': 'modifiers', + 'modulo': 'modulo', + 'mousefilter': 'mousefilter', + 'mousestate': 'mousestate', + 'movie': 'movie', + 'mpeconfig': 'mpeconfig', + 'mpeformat': 'mpeformat', + 'mpeparse': 'mpeparse', + 'mtof': 'mtof', + 'mtr': 'mtr', + 'multirange': 'multirange', + 'multislider': 'multislider', + 'mxj': 'mxj', + 'next_': 'next', + 'nodes': 'nodes', + 'notein': 'notein', + 'noteout': 'noteout', + 'notequals': 'notequals', + 'nrpnin': 'nrpnin', + 'nrpnout': 'nrpnout', + 'nslider': 'nslider', + 'number': 'number', + 'numkey': 'numkey', + 'offer': 'offer', + 'onebang': 'onebang', + 'onecopy': 'onecopy', + 'opendialog': 'opendialog', + 'osc_codebox': 'osc.codebox', + 'osc_packet': 'osc.packet', + 'outlet': 'outlet', + 'pack': 'pack', + 'pak': 'pak', + 'panel': 'panel', + 'param': 'param', + 'param_osc': 'param.osc', + 'past': 'past', + 'patcher': 'patcher', + 'patcherargs': 'patcherargs', + 'pattr': 'pattr', + 'pattrforward': 'pattrforward', + 'pattrhub': 'pattrhub', + 'pattrmarker': 'pattrmarker', + 'pattrstorage': 'pattrstorage', + 'pcontrol': 'pcontrol', + 'peak': 'peak', + 'pgmin': 'pgmin', + 'pgmout': 'pgmout', + 'pictctrl': 'pictctrl', + 'pictslider': 'pictslider', + 'pipe': 'pipe', + 'playbar': 'playbar', + 'plus': 'plus', + 'poltocar': 'poltocar', + 'poly': 'poly', + 'polyin': 'polyin', + 'polymidiin': 'polymidiin', + 'polyout': 'polyout', + 'pong': 'pong', + 'pow_': 'pow', + 'prepend': 'prepend', + 'preset': 'preset', + 'print_': 'print', + 'prob': 'prob', + 'project': 'project', + 'pv': 'pv', + 'pvar': 'pvar', + 'qlim': 'qlim', + 'qlist': 'qlist', + 'qmetro': 'qmetro', + 'quickthresh': 'quickthresh', + 'radiogroup': 'radiogroup', + 'random': 'random', + 'rdiv': 'rdiv', + 'receive': 'receive', + 'regexp': 'regexp', + 'relativepath': 'relativepath', + 'repl': 'repl', + 'rminus': 'rminus', + 'round_': 'round', + 'route': 'route', + 'routepass': 'routepass', + 'router': 'router', + 'rpnin': 'rpnin', + 'rpnout': 'rpnout', + 'rslider': 'rslider', + 'rtin': 'rtin', + 'savebang': 'savebang', + 'savedialog': 'savedialog', + 'scale': 'scale', + 'schedule': 'schedule', + 'screensize': 'screensize', + 'select': 'select', + 'send': 'send', + 'seq': 'seq', + 'serial': 'serial', + 'setclock': 'setclock', + 'shiftleft': 'shiftleft', + 'shiftright': 'shiftright', + 'sin': 'sin', + 'sinh': 'sinh', + 'slide': 'slide', + 'slider': 'slider', + 'speedlim': 'speedlim', + 'spell': 'spell', + 'split': 'split', + 'spray': 'spray', + 'sprintf': 'sprintf', + 'sqrt': 'sqrt', + 'standalone': 'standalone', + 'stepcounter': 'stepcounter', + 'string': 'string', + 'string_append': 'string.append', + 'string_bytes': 'string.bytes', + 'string_change': 'string.change', + 'string_compare': 'string.compare', + 'string_concat': 'string.concat', + 'string_contains': 'string.contains', + 'string_endswith': 'string.endswith', + 'string_frombytes': 'string.frombytes', + 'string_fromsymlist': 'string.fromsymlist', + 'string_fromutf8': 'string.fromutf8', + 'string_index': 'string.index', + 'string_indexof': 'string.indexof', + 'string_iter': 'string.iter', + 'string_length': 'string.length', + 'string_prepend': 'string.prepend', + 'string_regexp': 'string.regexp', + 'string_remove': 'string.remove', + 'string_replace': 'string.replace', + 'string_replaceall': 'string.replaceall', + 'string_reverse': 'string.reverse', + 'string_rotate': 'string.rotate', + 'string_slice': 'string.slice', + 'string_split': 'string.split', + 'string_sprintf': 'string.sprintf', + 'string_startswith': 'string.startswith', + 'string_substring': 'string.substring', + 'string_toarray': 'string.toarray', + 'string_tolist': 'string.tolist', + 'string_tolower': 'string.tolower', + 'string_tosymbol': 'string.tosymbol', + 'string_toupper': 'string.toupper', + 'string_trim': 'string.trim', + 'string_trimend': 'string.trimend', + 'string_trimstart': 'string.trimstart', + 'string_utf8': 'string.utf8', + 'string_withpass': 'string.withpass', + 'stripnote': 'stripnote', + 'strippath': 'strippath', + 'substitute': 'substitute', + 'suckah': 'suckah', + 'suspend': 'suspend', + 'sustain': 'sustain', + 'swap': 'swap', + 'swatch': 'swatch', + 'switch': 'switch', + 'sxformat': 'sxformat', + 'sysexin': 'sysexin', + 'tab': 'tab', + 'tabcontroller': 'tabcontroller', + 'table': 'table', + 'tan': 'tan', + 'tanh': 'tanh', + 'tempo': 'tempo', + 'text': 'text', + 'text_codebox': 'text.codebox', + 'textbox': 'textbox', + 'textbutton': 'textbutton', + 'textedit': 'textedit', + 'themecolor': 'themecolor', + 'thisobject': 'thisobject', + 'thispatcher': 'thispatcher', + 'threadcheck': 'threadcheck', + 'thresh': 'thresh', + 'timepoint': 'timepoint', + 'timer': 'timer', + 'times': 'times', + 'togedge': 'togedge', + 'toggle': 'toggle', + 'tosymbol': 'tosymbol', + 'touchin': 'touchin', + 'touchout': 'touchout', + 'translate': 'translate', + 'transport': 'transport', + 'trigger': 'trigger', + 'trough': 'trough', + 'ubutton': 'ubutton', + 'udpreceive': 'udpreceive', + 'udpsend': 'udpsend', + 'umenu': 'umenu', + 'universal': 'universal', + 'unjoin': 'unjoin', + 'unpack': 'unpack', + 'urn': 'urn', + 'uzi': 'uzi', + 'v8': 'v8', + 'v8_codebox': 'v8.codebox', + 'v8ui': 'v8ui', + 'value': 'value', + 'vdp': 'vdp', + 'vexpr': 'vexpr', + 'vstscan': 'vstscan', + 'when': 'when', + 'xbendin': 'xbendin', + 'xbendout': 'xbendout', + 'xctlin': 'xctlin', + 'xctlout': 'xctlout', + 'xmidiin': 'xmidiin', + 'xnotein': 'xnotein', + 'xnoteout': 'xnoteout', + 'zl': 'zl', + 'zl_change': 'zl.change', + 'zl_compare': 'zl.compare', + 'zl_delace': 'zl.delace', + 'zl_ecils': 'zl.ecils', + 'zl_filter': 'zl.filter', + 'zl_group': 'zl.group', + 'zl_indexmap': 'zl.indexmap', + 'zl_iter': 'zl.iter', + 'zl_join': 'zl.join', + 'zl_lace': 'zl.lace', + 'zl_len': 'zl.len', + 'zl_lookup': 'zl.lookup', + 'zl_median': 'zl.median', + 'zl_mth': 'zl.mth', + 'zl_nth': 'zl.nth', + 'zl_queue': 'zl.queue', + 'zl_reg': 'zl.reg', + 'zl_rev': 'zl.rev', + 'zl_rot': 'zl.rot', + 'zl_scramble': 'zl.scramble', + 'zl_sect': 'zl.sect', + 'zl_slice': 'zl.slice', + 'zl_sort': 'zl.sort', + 'zl_stack': 'zl.stack', + 'zl_stream': 'zl.stream', + 'zl_sub': 'zl.sub', + 'zl_sum': 'zl.sum', + 'zl_swap': 'zl.swap', + 'zl_thin': 'zl.thin', + 'zl_union': 'zl.union', + 'zl_unique': 'zl.unique', + 'zmap': 'zmap', +} + +_devnull = open(_os.devnull, 'w') +_old_stdout = _sys.stdout +_sys.stdout = _devnull + + +abs_ = MaxObject('abs') + +""" +absolutepath - Convert a file name to an absolute path + +Converts a file name or path to an absolute path. If the file is not found, the symbol notfound is output. + +Inlets: + 0 (symbol): (symbol) file path + +Outlets: + 0 (symbol): (symbol) resolved path + +Messages: anything, types +""" +absolutepath = MaxObject('absolutepath') + +""" +accum - Store, add to, and multiply a number + +Stores a value (int or float), then adds or multiplies into it. If the argument is an integer, the multiplication is done in floating-point then converted to integer. + +Args: + initial (int, float, optional) + +Inlets: + 0 (INLET_TYPE): int Sets and Outputs Value, bang Outputs Value + 1 (INLET_TYPE): Add Input to Current Value + 2 (INLET_TYPE): Multiplies Current Value by Input + +Outlets: + 0 (OUTLET_TYPE): Accumulator Output + +Messages: bang, int, float, ft1, in1, in2, set +""" +accum = MaxObject('accum') + +""" +acos - Arc-cosine function + +Use the acos object to calculate and output the arc-cosine of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Acos (x) + +Messages: bang, int, float +""" +acos = MaxObject('acos') + +""" +acosh - Hyperbolic arc-cosine function + +Use the acosh object to calculate and output the hyperbolic arc-cosine of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Acosh (x) + +Messages: bang, int, float +""" +acosh = MaxObject('acosh') + +""" +active - Send 1 when patcher window is active, 0 when inactive + +active will output a 1 when the Patcher window becomes active (i.e., it is the front-most window and its title bar is highlighted), and output a 0 when the Patcher window becomes inactive. You can use this to change the user interface of your window. For example, messages from the key object can be turned off when the window is made inactive. + +Messages: int +""" +active = MaxObject('active') + +""" +anal - Make a histogram of number pairs + +Reports how many times a number pair has been received. + +Args: + input-limit (int, optional) + +Inlets: + 0 (INLET_TYPE): Incoming Number Stream + +Outlets: + 0 (OUTLET_TYPE): Transitions Seen Between Current and Previous + +Messages: int, clear, reset +""" +anal = MaxObject('anal') + +""" +append - Append arguments to the end of a message + +append will add arguments to the end of any message you input. + +Args: + appended-message (any, optional) + +Inlets: + 0 (INLET_TYPE): Message to append to + +Outlets: + 0 (OUTLET_TYPE): Resulting Appended Message + +Messages: bang, int, float, list, anything, set +""" +append = MaxObject('append') + +""" +array - Create or duplicate an array object + +Create or duplicate a named array object. + +Args: + value (, optional) + +Inlets: + 0 (INLET_TYPE): messages in + 1 (INLET_TYPE): set array value, messages in + +Outlets: + 0 (OUTLET_TYPE): arrayobj out + 1 (OUTLET_TYPE): atoms out + 2 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything, append, array, atoms, clear, delete, dictionary, get, insert, prepend, replace, reserve, shrink, string + +Attributes: name, parameter_enable, parameter_mappable, size +""" +array = MaxObject('array') + +""" +array.change - Detect array changes + +Output an array if the order or value of the elements if different from the previous. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): 1 if different, 0 if identical + 1 (OUTLET_TYPE): 1 if different, 0 if equivalent + +Messages: bang, int, float, list, anything, array, dictionary, string + +Attributes: unordered +""" +array_change = MaxObject('array.change') + +""" +array.compare - Compare two arrays for equality + +Arrays are compared for their value and order. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): 1 if identical, 0 if different + +Messages: bang, int, float, list, anything, array, dictionary, string + +Attributes: unordered +""" +array_compare = MaxObject('array.compare') + +""" +array.concat - Concatenate two array objects + +The data in the array received in the right inlet will be appended to the data in the array received in the left inlet and a new array will be output. The original array objects are not modified. + +Inlets: + 0 (INLET_TYPE): left array in will be concatenated with the right array + 1 (INLET_TYPE): set right array + +Outlets: + 0 (OUTLET_TYPE): array out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_concat = MaxObject('array.concat') + +""" +array.deserialize - Parse a string, symbol or list to an array. + +A string/symbol/list representing an array in JSON format (e.g. "[ 25, 50, 75, 100 ]") will be converted into an array object. + +Inlets: + 0 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): deserializeped array out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_deserialize = MaxObject('array.deserialize') + +""" +array.every - Tests all elements in the array + +Tests whether all elements in the array pass the provided test. While testing, return the value of the test to the right inlet. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): test response (0/1) + +Outlets: + 0 (OUTLET_TYPE): every element of input array passes test (0/1) + 1 (OUTLET_TYPE): test output + 2 (OUTLET_TYPE): element index + +Messages: bang, int, float, list, anything, array, cancel, dictionary, in1, string +""" +array_every = MaxObject('array.every') + +""" +array.expr - Evaluate a math expression for an array + +Performs mathematical calculations using C language-style mathematical operations. Operates on inputs that are arrays rather than collections of single values. + +Args: + expression (list, required) + constant (number, required) + format (symbol, required) + table (symbol, required) + (other) (symbol, required) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): array result out + +Messages: bang, int, float, list, anything, array, dictionary, string + +Attributes: fillmode +""" +array_expr = MaxObject('array.expr') + +""" +array.fill - Generate an array of a specified length + +Creates a new array object of a specified length, pre-filled with elements. + +Args: + length (int, required) + initial-contents (list, optional) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): new array length + +Outlets: + 0 (OUTLET_TYPE): filled array + +Messages: bang, int, float, list, anything, array, dictionary, in1, string + +Attributes: mode, range, seed, urn +""" +array_fill = MaxObject('array.fill') + +""" +array.filter - Output elements of an array matching a condition + +If the condition set for the object is '0' the element is excluded in the filtered array output. In the case the condition is '1' it is included in the array. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): filter inclusion response (0/1) + +Outlets: + 0 (OUTLET_TYPE): filtered array out + 1 (OUTLET_TYPE): filter inclusion output + 2 (OUTLET_TYPE): element index + +Messages: bang, int, float, list, anything, array, cancel, dictionary, in1, string +""" +array_filter = MaxObject('array.filter') + +""" +array.flatten - Flatten a multi-dimensional array object to a single dimension + +Flattening can be simple sequential, or recursive sequential, depending on mode. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): flattened array out + +Messages: bang, int, float, list, anything, array, dictionary, string + +Attributes: mode +""" +array_flatten = MaxObject('array.flatten') + +""" +array.foreach - Iterate the elements of an array + +Iterate the elements of an array, with index and a done-iterating bang. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): bang when finished + 1 (OUTLET_TYPE): element value + 2 (OUTLET_TYPE): element index + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_foreach = MaxObject('array.foreach') + +""" +array.frombuffer - Read audio buffer values into an array object + +Determine the properties of a buffer that has been read into an array object. + +Args: + buffername (symbol, optional) + +Inlets: + 0 (INLET_TYPE): array, messages in + 1 (INLET_TYPE): array, messages in + +Outlets: + 0 (OUTLET_TYPE) + 1 (OUTLET_TYPE): channel count out + +Messages: bang, list + +Attributes: buffername, channelcount, channelstart, flatsinglechannel, framelength, frameoffset +""" +array_frombuffer = MaxObject('array.frombuffer') + +""" +array.group - Output an array when it reaches a certain size + +Outputs an array after the number of elements specified by the group size are received. Incoming arrays larger than the group size are split into multiple output arrays. + +Args: + initial-size (int, optional) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): number of elements to group (currently 0) + +Outlets: + 0 (OUTLET_TYPE): grouped array + +Messages: bang, int, float, list, anything, array, clear, dictionary, in1, string +""" +array_group = MaxObject('array.group') + +""" +array.index - Output the indexed element of an array object + +Extract an element from an incoming array object, based on the index specified (0-based). + +Args: + index (int, optional) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): position in array to extract + +Outlets: + 0 (OUTLET_TYPE): indexed element of the array + 1 (OUTLET_TYPE): array with indexed element removed + +Messages: bang, int, float, list, anything, array, dictionary, in1, string + +Attributes: remainder +""" +array_index = MaxObject('array.index') + +""" +array.indexmap - Reorder the elements of an array object based on an indexed map + +Use an array of integers (an index map) to reorder the elements of another array. + +Args: + index-map (list, optional) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): indices list + +Outlets: + 0 (OUTLET_TYPE): array out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_indexmap = MaxObject('array.indexmap') + +""" +array.indexof - Search for the index of an array element + +Output the position of an array element within a longer array as an integer index (0-based). Output -1 if the element cannot be found. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): index out + +Messages: bang, int, float, list, anything, array, dictionary, string + +Attributes: all, offset +""" +array_indexof = MaxObject('array.indexof') + +""" +array.insert - Insert elements into an array object + +Elements can be inserted at the beginning, the end, or in the middle, based on the index specified (0-based). + +Args: + index (int, optional) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): position in array to extract + 2 (INLET_TYPE): position in array to insert + +Outlets: + 0 (OUTLET_TYPE): inserted element of the array + +Messages: bang, int, float, list, anything, array, dictionary, in2, string +""" +array_insert = MaxObject('array.insert') + +""" +array.iter - Iterate every element of an array object + +Outputs each element in an array object sequentially, as a series of messages. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): iterated array members + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_iter = MaxObject('array.iter') + +""" +array.join - Convert an array object to a string object with an optional separator string + +Join the elements of an array together to form a string. The optional separator string will be placed between each element. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): separator string in + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything, array, clear, string +""" +array_join = MaxObject('array.join') + +""" +array.length - Determine the length of an array object + +Length is determined by sending a message to the left inlet. + +Inlets: + 0 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): length out + +Messages: bang, int, float, list, anything, array, clear, dictionary, string +""" +array_length = MaxObject('array.length') + +""" +array.map - Perform an operation on every element of an array object, replacing elements in-place + +Each element of an incoming array will be output sequentially. After processing the element, it should be passed back into the right inlet of the array.map object, replacing the element in the array. When iteration is complete, the substituted array will be output. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): map response + +Outlets: + 0 (OUTLET_TYPE): mapped array out + 1 (OUTLET_TYPE): mapping entry output + 2 (OUTLET_TYPE): element index + +Messages: bang, int, float, list, anything, array, cancel, dictionary, string +""" +array_map = MaxObject('array.map') + +""" +array.max - Calculate the maximum of the numerical elements of an array + +Non-numerical elements (symbols, arrays, strings, dictionaries) are ignored. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): result out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_max = MaxObject('array.max') + +""" +array.mean - Calculate the mean of the numerical elements of an array + +The mean is the total of all numerical values divided by the number of values (and is also known as the average). Non-numerical elements (symbols, arrays, strings, dictionaries) are ignored. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): result out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_mean = MaxObject('array.mean') + +""" +array.median - Calculate the median of the numerical elements of an array + +The median is the value halfway between the minimum and maximum of the set of numerical elements. Non-numerical elements (symbols, arrays, strings, dictionaries) are ignored. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): result out + +Messages: bang, int, float, list, anything, array, dictionary, string + +Attributes: evenmode +""" +array_median = MaxObject('array.median') + +""" +array.min - Calculate the minimum of the numerical elements of an array + +Non-numerical elements (symbols, arrays, strings, dictionaries) are ignored. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): result out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_min = MaxObject('array.min') + +""" +array.mode - Calculate the mode of the numerical elements of an array + +The mode is the element or elements which appear with the highest frequency. Non-numerical elements (symbols, arrays, strings, dictionaries) are ignored. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): result out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_mode = MaxObject('array.mode') + +""" +array.pop - Remove an element from the end of an array + +A bang sent to the left inlet will shift elements from the end of the output array (the remaining array from the right outlet and the popped element is sent via the middle outlet) until the array is empty, at which point a bang is sent from the left outlet. Unlike the JavaScript implementation, the input array is not changed in place. + +Inlets: + 0 (INLET_TYPE): bang to pop off last element + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): array is empty bang + 1 (OUTLET_TYPE): popped element + 2 (OUTLET_TYPE): popped array out + +Messages: bang, int, float, list, anything, array, clear, dictionary, string + +Attributes: wrapmode +""" +array_pop = MaxObject('array.pop') + +""" +array.push - Add one or more elements to the end of an array + +The base array is sent to the right inlet, which clears any elements sent to the left inlet. Additional elements are sent to the left inlet, and can be repeatedly placed at the end of the output array, without the user needing to update the array in the right inlet. Unlike the JavaScript implementation, the input array is not changed in place. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): pushed array out + +Messages: bang, int, float, list, anything, array, clear, dictionary, string + +Attributes: wrapmode +""" +array_push = MaxObject('array.push') + +""" +array.random - Generate a random array of a specified length + +Creates a new array object of a specified length, pre-filled with random numbers. + +Args: + length (int, required) + initial-range (list, optional) + +Inlets: + 0 (INLET_TYPE): range in (array) + 1 (INLET_TYPE): new array length + +Outlets: + 0 (OUTLET_TYPE): filled array + +Messages: bang, int, float, list, anything, array, dictionary, in1, string + +Attributes: mode, range, seed, urn +""" +array_random = MaxObject('array.random') + +""" +array.reduce - Combine array elements based on a custom function + +Perform an operation on every element of an array object, outputting the accumulated response. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): reduce response + +Outlets: + 0 (OUTLET_TYPE): reduced value out + 1 (OUTLET_TYPE): accumulated value + 2 (OUTLET_TYPE): element value + 3 (OUTLET_TYPE): element index + +Messages: bang, int, float, list, anything, array, cancel, dictionary, string + +Attributes: initial +""" +array_reduce = MaxObject('array.reduce') + +""" +array.regexp - Use regular expressions to process input + +With array.regexp, it's possible to use PERL-compatible regular expressions (PCRE) to match or make substitutions within arrays. + +Args: + expression (symbol, optional) + substitution (, optional) + +Inlets: + 0 (INLET_TYPE): re, substitute, or text in + 1 (INLET_TYPE): re (regular expression) in + 2 (INLET_TYPE): substitute in + +Outlets: + 0 (OUTLET_TYPE): substitutions + 1 (OUTLET_TYPE): capture groups + 2 (OUTLET_TYPE): subarrays + 3 (OUTLET_TYPE): unmatched + 4 (OUTLET_TYPE): subarray offsets + +Messages: bang, int, float, list, anything, array, dictionary, string + +Attributes: re, substitute +""" +array_regexp = MaxObject('array.regexp') + +""" +array.remove - Remove a range of elements from an array object + +Args: + index-range (list, optional) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): remove start index (0-based) + 2 (INLET_TYPE): remove end index (0-based) + +Outlets: + 0 (OUTLET_TYPE): array out + +Messages: bang, int, float, list, anything, array, dictionary, in1, in2, string +""" +array_remove = MaxObject('array.remove') + +""" +array.replace - Replace elements in an array + +Inlets: + 0 (INLET_TYPE): replacement array + 1 (INLET_TYPE): base array + 2 (INLET_TYPE): replacement start index (0-based, -1 = bypass) + +Outlets: + 0 (OUTLET_TYPE): array out + +Messages: bang, int, float, list, anything, array, dictionary, in2, string +""" +array_replace = MaxObject('array.replace') + +""" +array.reverse - Reverse the order of elements in an array object + +The output array will contain the elements of the incoming array, but backward. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): reversed array out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_reverse = MaxObject('array.reverse') + +""" +array.rotate - Rotate the elements in any array object + +Move elements forward or backwards in the array. Values will wrap around. + +Args: + rotation amount (int, required) + +Inlets: + 0 (INLET_TYPE): array to rotate + 1 (INLET_TYPE): positions to rotate (negative to rotate left) + +Outlets: + 0 (OUTLET_TYPE): array out + +Messages: bang, int, float, list, anything, array, dictionary, in1, string +""" +array_rotate = MaxObject('array.rotate') + +""" +array.routepass - Route a complete input array object based on input matching + +Like routepass, but for array objects. + +Args: + match keys (list, required) + +Inlets: + 0 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): array out if there are no matches + +Messages: bang, int, float, list, anything, array, dictionary, string + +Attributes: match +""" +array_routepass = MaxObject('array.routepass') + +""" +array.scramble - Randomize the order of elements in an array object + +When triggered, output the scrambled array and the reordered index list. + +Inlets: + 0 (INLET_TYPE): array in (trigger output) + 1 (INLET_TYPE): set array + +Outlets: + 0 (OUTLET_TYPE): scrambled array out + 1 (OUTLET_TYPE): reordered indexes list + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_scramble = MaxObject('array.scramble') + +""" +array.sect - Return the elements of an array object which intersect with another array object + +Intersection means that the elements are identical or equivalent (in the case of array, dictionary and string objects). + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): array out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_sect = MaxObject('array.sect') + +""" +array.shift - Remove an element from the beginning of an array + +Set the array to shift, then send bangs repeatedly to output the elements of the array one at a time. The remainder of the array is sent out the right outlet, and a bang is sent out the leftmost outlet when the array is empty. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): array is empty bang + 1 (OUTLET_TYPE): shifted element + 2 (OUTLET_TYPE): shifted array out + +Messages: bang, int, float, list, anything, array, clear, dictionary, string + +Attributes: wrapmode +""" +array_shift = MaxObject('array.shift') + +""" +array.slice - Output a range of elements of an array object as a new array object + +array.slice is similar to array.subarray, but attempts to conform to the JavaScript Array.slice() behavior. + +Args: + slice-indeces (list, optional) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): slice indices (0-based) + +Outlets: + 0 (OUTLET_TYPE): sliced array out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_slice = MaxObject('array.slice') + +""" +array.some - Test the elements of an array object for a matching condition + +Each element of an incoming array will be output sequentially. Each element can be tested and a 0 or 1 passed back into the right inlet of the array.some object, indicating whether the element passed the test. When iteration is complete, either a 0 or 1 will be output, signalling whether some elements of the array matched the testing condition. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): test response (0/1) + +Outlets: + 0 (OUTLET_TYPE): some elements of input array pass test (0/1) + 1 (OUTLET_TYPE): test output + 2 (OUTLET_TYPE): element index + +Messages: bang, int, float, list, anything, array, cancel, dictionary, in1, string +""" +array_some = MaxObject('array.some') + +""" +array.sort - Sort the elements of an array object according to a test + +Each pair of entries is output, the user compares them and then passes a 1 (left is > right) or a 0 (left is <= right) to determine a final sorted order. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): sort comparison response (0/1) + +Outlets: + 0 (OUTLET_TYPE): sorted array out + 1 (OUTLET_TYPE): sort comparison output 1 + 2 (OUTLET_TYPE): sort comparison output 2 + +Messages: bang, int, float, list, anything, array, cancel, dictionary, in1, string + +Attributes: simple +""" +array_sort = MaxObject('array.sort') + +""" +array.split - Split an array object into two new array objects at a specified index + +The position set as an argument or + +Args: + position (int, optional) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): position in array to split + +Outlets: + 0 (OUTLET_TYPE): array < of split point + 1 (OUTLET_TYPE): array >= of split point + +Messages: bang, int, float, list, anything, array, dictionary, in1, string +""" +array_split = MaxObject('array.split') + +""" +array.stddev - Calculate the standard deviation of the numerical elements of an array + +The standard deviation is a quantity expressing by how much the members of a group differ from the mean value for the group. Non-numerical elements (symbols, arrays, strings, dictionaries) are ignored. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): result out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_stddev = MaxObject('array.stddev') + +""" +array.stream - Make an array of a certain size + +array.stream accepts a number in the right inlet which specifies the length of the output array. Following the receipt of this number, the object will collect this number of elements input through the left inlet. After the array-length is complete, and with each subsequent input, the array will be output from the left outlet. A 1 or a 0 will be output from the right outlet depending on whether the array-length has been reached or not. A 1 signifies that the array-length has been reached and that the object is now collecting the stream. Use the clear message to reset the array. + +Args: + array-length (int, optional) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): length in + +Outlets: + 0 (OUTLET_TYPE): streamed array out + 1 (OUTLET_TYPE): 1 if 0 elements are defined + +Messages: bang, int, float, list, anything, array, clear, dictionary, string +""" +array_stream = MaxObject('array.stream') + +""" +array.subarray - Output a range of elements of an array object as a new array object + +array.subarray is similar to array.slice, but doesn't conform to the JavaScript Array.slice() behavior. + +Args: + subarray-indexes (list, optional) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): subarray indices (0-based) + +Outlets: + 0 (OUTLET_TYPE): subarray out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_subarray = MaxObject('array.subarray') + +""" +array.thin - Remove duplicated entries from an array object + +Inlets: + 0 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): thinned array out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_thin = MaxObject('array.thin') + +""" +array.tobuffer - Write array object values to an audio buffer + +Values are assumed to be between -1 and 1. If the array contains multichannel data, each channel should be wrapped inside of a subarray (e.g. [ [ -1, 0, 1 ], [ -1, 0, -1 ] ]). + +Args: + buffer-name (symbol, required) + +Inlets: + 0 (INLET_TYPE): array, messages in + 1 (INLET_TYPE): array, messages in + +Outlets: + 0 (OUTLET_TYPE): bang on successful buffer write + +Messages: bang, int, float, list, anything, array, dictionary, string + +Attributes: buffername, channelstart, framelength, frameoffset, resize +""" +array_tobuffer = MaxObject('array.tobuffer') + +""" +array.tolist - Convert an array object to a list + +Nested arrays (arrays within arrays) can be automatically flattened with the flatten attribute. + +Inlets: + 0 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): list out + +Messages: bang, int, float, list, anything, array, dictionary, string + +Attributes: flatten, stringmode +""" +array_tolist = MaxObject('array.tolist') + +""" +array.tostring - Convert an array object to a string object + +The string object contains a serialized representation of the array's contents. + +Inlets: + 0 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): list out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_tostring = MaxObject('array.tostring') + +""" +array.tosymbol - Convert an array object to a symbol + +This object is particularly useful for visualization of an array object's contents. + +Inlets: + 0 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): list out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_tosymbol = MaxObject('array.tosymbol') + +""" +array.tuplewise - Make an array of a certain size (counting iterations) + +Args: + array-length (int, optional) + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): length in + +Outlets: + 0 (OUTLET_TYPE): streamed array out + 1 (OUTLET_TYPE): 0-based output index since the last clear message was received + +Messages: bang, int, float, list, anything, array, clear, dictionary, string +""" +array_tuplewise = MaxObject('array.tuplewise') + +""" +array.union - Combine two arrays into a new array object containing non-duplicate entries of both arrays + +Combine two arrays into a new array object containing non-duplicate entries of both arrays. For instance, the arrays [ 0, 1, 1, 2, 8 ] and [ 2, 2, 3, 3, 5 ] would become a new array [ 0, 1, 2, 8, 3, 5 ]. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): array out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_union = MaxObject('array.union') + +""" +array.unique - Filtering duplicates and subtract arrays + +Combine two arrays into a new array object containing non-duplicate entries of the first array which do not appear in the second array. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): array out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_unique = MaxObject('array.unique') + +""" +array.unshift - Add one or more elements to the beginning of an array + +The base array is sent to the right inlet, which clears any elements send to the left inlet. Additional elements are sent to the left inlet, and can be repeatedly placed at the front of the output array, without the user needing to update the array in the right inlet. Unlike the JavaScript implementation, the input array is not changed in place. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): unshifted array out + +Messages: bang, int, float, list, anything, array, clear, dictionary, string + +Attributes: wrapmode +""" +array_unshift = MaxObject('array.unshift') + +""" +array.wrap - Wrap an array inside of an array + +Among other things, you can use wrapped arrays in conjunction with array.concat to create multidimensional arrays. + +Inlets: + 0 (INLET_TYPE): array in + 1 (INLET_TYPE): array in + +Outlets: + 0 (OUTLET_TYPE): wrapped array out + +Messages: bang, int, float, list, anything, array, dictionary, string +""" +array_wrap = MaxObject('array.wrap') + +""" +asin - Arc-sine function + +Use the asin object to calculate and output the arc-sine of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Asin (x) + +Messages: bang, int, float +""" +asin = MaxObject('asin') + +""" +asinh - Hyperbolic arc-sine function + +Use the asinh object to calculate and output the hyperbolic arc-sine of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Asinh (x) + +Messages: bang, int, float +""" +asinh = MaxObject('asinh') + +""" +atan - Arc-tangent function + +Use the atan object to calculate and output the arc-tangent of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Atan (x) + +Messages: bang, int, float +""" +atan = MaxObject('atan') + +""" +atan2 - Two-variable arc-tangent function + +Use the atan2 object to calculate and output the arc-tangent of any two given numbers where the left input is the y value and the right input is the x value. + +Args: + x-value (number, optional) + +Inlets: + 0 (INLET_TYPE): Y value + 1 (INLET_TYPE): X value + +Outlets: + 0 (OUTLET_TYPE): atan2(y/x) + +Messages: bang, int, float, ft1, in1 +""" +atan2 = MaxObject('atan2') + +""" +atanh - Hyperbolic arc-tangent function + +Use the atanh object to calculate and output the hyperbolic arc-tangent of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Atanh (x) + +Messages: bang, int, float +""" +atanh = MaxObject('atanh') + +""" +atodb - Convert a linear value to decibels + +Converts any given linear value to its corresponding decibel value. + +Inlets: + 0 (float): (float) Amplitude Scalar + +Outlets: + 0 (float): (float) Gain/Attenuation dB + +Messages: bang, int, float, list, set +""" +atodb = MaxObject('atodb') + +""" +atoi - Convert characters to integers + +Inlets: + 0 (INLET_TYPE): Any message, bang triggers output + 1 (INLET_TYPE): Appends message to current contents + 2 (INLET_TYPE): Any message sets current contents + +Outlets: + 0 (list): List of ints output + +Messages: bang, int, float, list, anything, clear + +Attributes: utf8 +""" +atoi = MaxObject('atoi') + +""" +attrui - Inspect attributes + +Use attrui object to inspect the attribute values of the object(s) it is connected to. + +Inlets: + 0 (INLET_TYPE): Messages In + +Outlets: + 0 (OUTLET_TYPE): Connect to Objects whose Attribute you Want to Explore + +Messages: int, float, list, anything, (mouse) + +Attributes: align, annotation_name, arrowcolor, attr, attr_display, attrfilter, bgcolor, bgcolor2, bordercolor, displaymode, htricolor, lock, menu_display, orientation, parameter_enable, paramonly, rounded, showcaption, showgetonly, storeinpreset, style, text_width, textcolor, textjustification, tricolor +""" +attrui = MaxObject('attrui') + +""" +autopattr - Expose multiple objects to the pattr system + +Causes multiple objects within a patcher to be automatically included in the pattr system. + + + Note: you should use only one instance of an autopattr object per level in a patch. + +Args: + name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): messages or data in + +Outlets: + 0 (OUTLET_TYPE): include connection + 1 (OUTLET_TYPE): exclude connection + 2 (OUTLET_TYPE): passout + 3 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything, getattributes, getstate + +Attributes: autoname, autorestore, dirty, greedy, name +""" +autopattr = MaxObject('autopattr') + +""" +bag - Store a collection of numbers + +Stores and manages a collection of numbers. You can add to or delete an integer from a bag as well as report its contents. bag with any argument maintains multiple entries with the same item; otherwise it holds only one of each. + +Args: + duplicate-flag (symbol, optional) + +Inlets: + 0 (INLET_TYPE): list Adds Items, bang Dumps Items + 1 (INLET_TYPE): Item Value in List + +Outlets: + 0 (OUTLET_TYPE): Output for Items When bang is Received + +Messages: bang, int, float, clear, cut, in1, length, send, list +""" +bag = MaxObject('bag') + +""" +bangbang - Output a bang from many outlets + +Outputs bang messages out of each outlet (in right-to-left order) when it receives any input. The number of outlets is determined by an argument. + +Args: + outlets (number, optional) + +Inlets: + 0 (INLET_TYPE): Any Message, Repeated as One or More bangs + +Outlets: + 0 (OUTLET_TYPE): Last bang Output + 1 (OUTLET_TYPE): First bang Output + +Messages: bang, int, float, anything +""" +bangbang = MaxObject('bangbang') + +""" +bendin - Output MIDI pitch bend values + +Outputs pitch bend values received from a MIDI device. The MIDI port and channel can be chosen with messages or by double-clicking on the object. + +Args: + port-and-channel (symbol, required) + channel (int, required) + port (symbol, optional) + midi-device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): port Message Sets MIDI Input Port/Device + +Outlets: + 0 (OUTLET_TYPE): Pitch Bend Amount + 1 (OUTLET_TYPE): MIDI Channel + +Messages: anything, (mouse), (MIDI), port + +Attributes: matchport, name +""" +bendin = MaxObject('bendin') + +""" +bendout - Send MIDI pitch bend messages + +Transmits MIDI pitchbend values to a MIDI device. + +Args: + port-and-channel (list, required) + channel (int, required) + port (symbol, optional) + midi-device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Pitch Bend Amount + 1 (INLET_TYPE): MIDI Channel + +Messages: int, float, anything, (mouse), in1, port + +Attributes: matchport, name +""" +bendout = MaxObject('bendout') + +""" +bgcolor - Set background color + +Set the background color of the patcher window. The bgcolor object's functionality is equivalent to a brgb message sent to thispatcher. + +Args: + red (int, optional) + green (int, optional) + blue (int, optional) + +Inlets: + 0 (INLET_TYPE): Red Value or list of RGB Values + 1 (INLET_TYPE): Green Value + 2 (INLET_TYPE): Blue Value + 3 (INLET_TYPE): Alpha Value (0.-1.) + +Messages: bang, int, list, ft3, in1, in2, set +""" +bgcolor = MaxObject('bgcolor') + +""" +bitand - Bitwise intersection of two numbers + +Performs a bit-by-bit AND of two numbers as expressed in binary. Outputs a number composed of all those bits which are 1 in both of the two numbers. + +Args: + initial-value (int, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left & Right + +Messages: bang, int, float, in1, set, list +""" +bitand = MaxObject('bitand') + +""" +bitor - Bitwise union of two numbers + +Performs a bit-by-bit OR of two numbers (expressed in binary for the task). Outputs a number composed of all those bits which are 1 in either of the two numbers. + +Args: + initial-value (int, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left | Right + +Messages: bang, int, float, in1, set, list +""" +bitor = MaxObject('bitor') + +""" +bline - Generate ramps using bang + +Generates a linear ramp driven by incoming bang messages. It takes a list of breakpoint segments (and the number of events to span) and outputs a smooth ramp between values. + +Args: + initial-value (number, optional) + +Inlets: + 0 (INLET_TYPE): bang, list, stop + +Outlets: + 0 (OUTLET_TYPE): ramp output + 1 (OUTLET_TYPE): bang when bline reaches destination + +Messages: bang, int, float, list, set, stop +""" +bline = MaxObject('bline') + +""" +bondo - Synchronize a group of messages + +Synchronizes and outputs a set of inputs when any input is received. It can also be set with a time interval value (in milliseconds) to wait before sending its output. + +Args: + inlets-outlets (int, optional) + delay (int, optional) + list-flag (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Input 1 to be Synchronized + 1 (INLET_TYPE): Input 2 to be Synchronized + +Outlets: + 0 (OUTLET_TYPE): Output of Inlet 1 + 1 (OUTLET_TYPE): Output of Inlet 2 + +Messages: bang, int, float, list, anything, set +""" +bondo = MaxObject('bondo') + +""" +borax - Report note-on and note-off information + +Acquires and outputs comprehensive information regarding note-on and note-off events. Information includes note counts, event details and time between note events. + +Inlets: + 0 (INLET_TYPE): Pitch (Also Delta Message) + 1 (INLET_TYPE): Velocity + 2 (INLET_TYPE): Reset, Turns Off All Sounding Notes + +Outlets: + 0 (OUTLET_TYPE): Number of Notes Since Last Reset + 1 (OUTLET_TYPE): Voice Allocation Number + 2 (OUTLET_TYPE): Number of Notes Currently Active + 3 (OUTLET_TYPE): Pitch + 4 (OUTLET_TYPE): Velocity + 5 (OUTLET_TYPE): Duration Count + 6 (OUTLET_TYPE): Duration Output + 7 (OUTLET_TYPE): Note Delta Count + 8 (OUTLET_TYPE): Delta Time + +Messages: bang, int, delta, in1, list + +Attributes: size +""" +borax = MaxObject('borax') + +""" +bpatcher - Embed a subpatch with a visible UI + +The bpatcher object holds the contents of a patcher or subpatcher, displaying only those visual elements that fall within its box rectangle. The number of inlets and outlets in a bpatcher object is determined by the number of inlet and outlet objects contained in its contained subpatcher. + +Messages: (drag), (mouse), replace + +Attributes: args, bgcolor, bgmode, border, clickthrough, embed, enablehscroll, enablevscroll, lockeddragscroll, lockedsize, name, offset +""" +bpatcher = MaxObject('bpatcher') + +""" +bucket - Pass numbers from outlet to outlet + +Outputs incoming values to outlets in bucket-brigade fashion. bucket acts as an n-stage shift register which can shift its contents from outlet to outlet in either direction. + +Args: + outlets (int, optional) + output-flag (int, optional) + +Inlets: + 0 (INLET_TYPE): Number to Bucket-brigade + +Outlets: + 0 (OUTLET_TYPE): Delay Stage 1 + +Messages: bang, int, float, L2R, R2L, clear, freeze, l2r, r2l, roll, set, thaw +""" +bucket = MaxObject('bucket') + +""" +buddy - Synchronize arriving data + +Outputs incoming data after something has been received in all inlets. + +Args: + inlets (int, optional) + +Inlets: + 0 (INLET_TYPE): Input to be Synchronized + 1 (INLET_TYPE): Input to be Synchronized + +Outlets: + 0 (OUTLET_TYPE): Synchronized Output of Inlet 1 + 1 (OUTLET_TYPE): Synchronized Output of Inlet 2 + +Messages: bang, int, float, list, anything, clear +""" +buddy = MaxObject('buddy') + +""" +button - Blink and send a bang + +button blinks when you send it any message, and it sends out a bang when you click on it. + +Inlets: + 0 (INLET_TYPE): Cause Indicator to Flash and bang Output + +Outlets: + 0 (OUTLET_TYPE): Output Received Message as bang + +Messages: bang, int, float, list, anything, (mouse) + +Attributes: annotation_name, bgcolor, blinkcolor, blinktime, fgcolor, outlinecolor, param_connect, parameter_enable, parameter_mappable, style +""" +button = MaxObject('button') + +""" +capture - Store values to view or edit + +Stores items in the order they are received for viewing, editing, and saving. + +Args: + maximum (int, optional) + display-format (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Data to be Captured + +Outlets: + 0 (OUTLET_TYPE): Sequential Output from dump Message + 1 (OUTLET_TYPE): Item Count Outlet + +Messages: int, float, list, anything, clear, count, (mouse), dump, open, wclose, write + +Attributes: listout, precision, size +""" +capture = MaxObject('capture') + +""" +cartopol - Convert cartesian to polar coordinates + +Converts a cartesian-coordinate pair consisting of real and imaginary values into a polar-coordinate pair consisting of distance and angle values. + +Inlets: + 0 (INLET_TYPE): real/x input + 1 (INLET_TYPE): imaginary/y input + +Outlets: + 0 (OUTLET_TYPE): amplitude/alpha output + 1 (OUTLET_TYPE): phase/theta output + +Messages: bang, int, float +""" +cartopol = MaxObject('cartopol') + +""" +change - Filter out repetitions of a number + +Output a number only if it is different from the stored number and will reset the stored number to that differing input number. Alternate modes of operation also identify greater-than or less-than the conditions. + +Args: + initial-value (int, float, optional) + mode (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Repeated to Output if Number Changes + +Outlets: + 0 (OUTLET_TYPE): Number if it Changes + 1 (OUTLET_TYPE): 1 for Logical Transition from 0 to Non-Zero + 2 (OUTLET_TYPE): 1 for Logical Transition from Non-Zero to 0 + +Messages: int, float, mode, set +""" +change = MaxObject('change') + +""" +chooser - Display a scrolling list of selectable items + +The chooser object is similar to the umenu object, but it displays a scrolling list of selectable items rather than a pop-up menu. + +Inlets: + 0 (INLET_TYPE): Messages + +Outlets: + 0 (OUTLET_TYPE): Index (Message or Single-Click) + 1 (OUTLET_TYPE): Item (Message or Single-Click) + 2 (OUTLET_TYPE): Index (Double-Click) + 3 (OUTLET_TYPE): Item (Double-Click) + 4 (OUTLET_TYPE): Preview Control + 5 (OUTLET_TYPE): Dump Outlet + +Messages: bang, int, float, anything, append, clear, count, delete, deselect, dictionary, insert, (mouse), next, play, prev, progress, set, setnext, setprev, sort, stop + +Attributes: autopopulate, bgcolor, collection, depth, enabledrag, factorycontent, filekind, filtertext, headerheight, headerlabel, items, keynavigate, margin, multiselect, parameter_enable, parameter_mappable, prefix, prefix_mode, preview, selectedclick, selectioncolor, showdotfiles, stripecolor, style, textcolor, types, useselectioncolor +""" +chooser = MaxObject('chooser') + +""" +clip - Limit numbers to a range + +Args: + minimum (number, optional) + maximum (number, optional) + +Inlets: + 0 (INLET_TYPE): value to be constrained + 1 (INLET_TYPE): minimum value + 2 (INLET_TYPE): maximum value + +Outlets: + 0 (OUTLET_TYPE): output value + +Messages: int, float, list, set + +Attributes: mode +""" +clip = MaxObject('clip') + +""" +clocker - Report elapsed time, at regular intervals + +The clocker object is a metronome that reports the time elapsed since it was started. This object uses the Max time format syntax, so the interval that the clocker object uses can be either fixed or tempo-relative. Its output can be quantized using tempo-relative syntax, and if the autostarttime attribute is set, the object can also start at a tempo-relative point. + +Args: + time-interval (int, symbol, float, required) + +Inlets: + 0 (INLET_TYPE): Start/Stop Metronome + 1 (INLET_TYPE): Set Metronome Time Interval + +Outlets: + 0 (OUTLET_TYPE): Output Ticks of Metronome + +Messages: bang, int, float, list, anything, clock, reset, stop + +Attributes: active, autostart, autostarttime, defer, interval, quantize, transport +""" +clocker = MaxObject('clocker') + +""" +closebang - Send a bang on close + +Sends a bang whenever the patcher window within which it resides is closed. + +Inlets: + 0 (INLET_TYPE): Sends bang When Patcher Window Is Closed + +Outlets: + 0 (OUTLET_TYPE): Output bang + +Messages: bang, (mouse) +""" +closebang = MaxObject('closebang') + +""" +coll - Store and edit a collection of data + +Allows for the storage, organization, editing, and retrieval of different messages. + +Args: + name (symbol, optional) + no-search (any, optional) + +Inlets: + 0 (INLET_TYPE): Single Item Outputs Data, Multiple Items Store Data + +Outlets: + 0 (OUTLET_TYPE): Data Contents + 1 (OUTLET_TYPE): Number or Symbol Associated With Data + 2 (OUTLET_TYPE): bang When Finished Reading Data File + 3 (OUTLET_TYPE): bang When Finished With Dump Output + +Messages: bang, int, float, list, anything, append, assoc, clear, (mouse), deassoc, delete, dump, end, filetype, flags, goto, insert, insert2, length, max, merge, min, next, nstore, nsub, nth, open, prev, read, readagain, refer, remove, renumber, renumber2, separate, sort, start, store, sub, subsym, swap, symbol, wclose, write, writeagain + +Attributes: embed, name, precision +""" +coll = MaxObject('coll') + +""" +coll.codebox - Store and edit a collection of data + +Allows for the storage, organization, editing, and retrieval of different messages, using a UI object for display and editing. + +Inlets: + 0 (INLET_TYPE): Single Item Outputs Data, Multiple Items Store Data + +Outlets: + 0 (OUTLET_TYPE): Data Contents + 1 (OUTLET_TYPE): Number or Symbol Associated With Data + 2 (OUTLET_TYPE): bang When Finished Reading Data File + 3 (OUTLET_TYPE): bang When Finished With Dump Output + +Messages: int, float, list, (mouse), anything, append, assoc, bang, symbol, clear, deassoc, delete, dump, end, filetype, flags, goto, insert, insert2, length, max, merge, min, next, nstore, nsub, nth, open, prev, read, readagain, refer, remove, renumber, renumber2, separate, sort, start, store, sub, subsym, swap, wclose, write, writeagain + +Attributes: bgcolor, editlocked, embed, linenumbers, linenumberwidth, margin, style, textcolor, precision, name +""" +coll_codebox = MaxObject('coll.codebox') + +""" +colorpicker - Select and output a color + +Inlets: + 0 (INLET_TYPE): bang opens picker, list sets initial color value + +Outlets: + 0 (OUTLET_TYPE): List of RGB Color Values + 1 (OUTLET_TYPE): bang when mouse is released and when color window closes + +Messages: bang, list, (mouse) + +Attributes: compatibility, currentcolor +""" +colorpicker = MaxObject('colorpicker') + +""" +combine - Combine multiple items into a single symbol + +Combines a list of items into a single symbol. It works similar to pack and sprintf. The behavior can be modified with attributes that provide number padding and triggered output. + +Args: + inlets (any, optional) + +Inlets: + 0 (INLET_TYPE): (0) + +Outlets: + 0 (OUTLET_TYPE): merged output + 1 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything + +Attributes: padding, triggers +""" +combine = MaxObject('combine') + +""" +comment - Explanatory note or label + +comment displays text which is typed into it in order to serve as a label or explanatory text. + +Inlets: + 0 (INLET_TYPE): Messages in + +Messages: append, prepend, set, setwithtruncation, string + +Attributes: bgcolor, bubble, bubble_bgcolor, bubble_outlinecolor, bubblepoint, bubbleside, bubbletextmargin, bubbleusescolors, style, suppressinlet, underline +""" +comment = MaxObject('comment') + +""" +conformpath - Convert file paths styles + +Converts paths between the older colon style formats and the current slash style. It can also be used to conform paths to either absolute, relative, boot volume relative, or Cycling 74 folder relative types. + +Args: + pathstyle (symbol, optional) + pathtype (symbol, optional) + +Inlets: + 0 (symbol): (symbol) Path Input + +Outlets: + 0 (symbol): (symbol) Conformed Path Output + 1 (int): (int) Success + +Messages: anything, pathstyle, pathtype +""" +conformpath = MaxObject('conformpath') + +""" +console - Console Output in Patcher + +Mirror and filter messages to the Max window in your patcher. + +Inlets: + 0 (INLET_TYPE): Change Filter Attributes + +Outlets: + 0 (OUTLET_TYPE): Object Name + 1 (OUTLET_TYPE): Message + 2 (int): Message Type + +Messages: clear, write + +Attributes: classfilter, patcherfilter, showonlyerrors, textfilter +""" +console = MaxObject('console') + +""" +cos - Cosine function + +Use the cos object to calculate and output the cosine of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Cos (x) + +Messages: bang, int, float +""" +cos = MaxObject('cos') + +""" +cosh - Hyperbolic cosine function + +Use the cosh object to calculate and output the hyperbolic cosine of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Cosh (x) + +Messages: bang, int, float +""" +cosh = MaxObject('cosh') + +""" +counter - Keep count based on bang messages + +Outputs the current count of bang message constrained to a specified range. Can be set to count up, down, or up-then-down. + +Args: + options (int, optional) + +Inlets: + 0 (INLET_TYPE): int, bang are Counted, set Sets Counter Value + 1 (INLET_TYPE): Set Direction: 0 = Up, 1 = Down, 2 = UpDown + 2 (INLET_TYPE): Resets Counter to Number on Next Clock + 3 (INLET_TYPE): Resets Counter to Number Immediately + 4 (INLET_TYPE): Sets Count Maximum + +Outlets: + 0 (OUTLET_TYPE): Current Count + 1 (OUTLET_TYPE): Underflow (Counter Hit Minimum) Flag + 2 (OUTLET_TYPE): Carry (Counter Hit Maximum) Flag + 3 (OUTLET_TYPE): Carry Count + +Messages: bang, int, float, carrybang, carryint, dec, down, flags, goto, inc, jam, max, min, next, set, setmin, state, up, updown + +Attributes: carryflag, compatmode +""" +counter = MaxObject('counter') + +""" +cpuclock - Retrieve the CPU time + +Accesses a precise value from the system timer. This allows for timing calculations with very high resolution. + +Inlets: + 0 (INLET_TYPE): Bang to get the current system time. + +Outlets: + 0 (OUTLET_TYPE): Current system time. + +Messages: bang, reset +""" +cpuclock = MaxObject('cpuclock') + +""" +crosspatch - Patching Editor for Matrix Objects + +Connect a crosspatch to a client object (including matrix~, mcs.matrix~, mc.matrix~, matrix, gate~, mc.gate~, mcs.gate~, gate, selector, mc.selector~, mcs.selector~, and switch) to use a patching interface to edit connections between inputs and outputs. + +Inlets: + 0 (INLET_TYPE): list Adds or Deletes a Connection + +Outlets: + 0 (OUTLET_TYPE): Connect to matrix~ or matrix Object + 1 (dictionary): From dump Message + +Messages: bang, list, clear, dictionary, dump, dumpconnections, indisable, (mouse), outdisable + +Attributes: allowdisabled, annotation_name, bgcolor, candycane, candycane2, candycane3, candycane4, candycane5, candycane6, candycane7, candycane8, candymode, colorlabels, connectacrossdividers, dimmedconnectionalpha, dividercolor, dividers, embed, exclusive, gaincaption, gaindragmode, gainradius, gainstyle, incolormap, initialgain, inlabels, labelheight, labelwidth, linecolor, maxgain, numins, numouts, outcolormap, outlabels, overgaincolor, parameter_enable, parameter_mappable, preservegain, showgain, showlabels, style, textcolor +""" +crosspatch = MaxObject('crosspatch') + +""" +ctlin - Output received MIDI control values + +Output the value from a specific controller number and MIDI channel. + +Args: + port (symbol, optional) + device (symbol, optional) + ctrllr-channel (list, optional) + +Inlets: + 0 (INLET_TYPE): port Message Sets MIDI Input Port/Device + +Outlets: + 0 (OUTLET_TYPE): Controller Value + 1 (OUTLET_TYPE): Controller Number + 2 (OUTLET_TYPE): MIDI Channel + +Messages: anything, (mouse), (MIDI), port, set + +Attributes: matchport, name +""" +ctlin = MaxObject('ctlin') + +""" +ctlout - Transmit MIDI controller messages + +Transmits MIDI continuous controller values to a MIDI device. + +Args: + port (symbol, optional) + device (symbol, optional) + ctrllr-channel (list, optional) + +Inlets: + 0 (INLET_TYPE): Controller Value + 1 (INLET_TYPE): Controller Number + 2 (INLET_TYPE): MIDI Channel + +Messages: int, float, anything, (mouse), in1, in2, port + +Attributes: matchport, name +""" +ctlout = MaxObject('ctlout') + +""" +cycle - Round-robin messages to outlets + +Each incoming number is sent to the next outlet, wrapping around to the first outlet after the last has been reached. + +Args: + outlets (int, optional) + mode (int, optional) + +Inlets: + 0 (INLET_TYPE): Number to Send to Successive Outlets + +Outlets: + 0 (OUTLET_TYPE): Output of Item 1 + +Messages: bang, int, float, list, anything, set, symbol, thresh +""" +cycle = MaxObject('cycle') + +""" +date - Report current date and time + +Reports the current date, time, or the number of 1/60th-second ticks since startup. + +Inlets: + 0 (INLET_TYPE): date, time, or ticks Message + +Outlets: + 0 (OUTLET_TYPE): Date (Month/Day/Year) + 1 (OUTLET_TYPE): Time (Hour/Minute/Second) + 2 (OUTLET_TYPE): Ticks (1/60th Second) + +Messages: date, ticks, time +""" +date = MaxObject('date') + +""" +dbtoa - Convert decibels to a linear value + +Converts a decibel value to its corresponding linear value. + +Inlets: + 0 (float): (float) Gain/Attenuation dB + +Outlets: + 0 (float): (float) Amplitude Scalar + +Messages: bang, int, float, list, set +""" +dbtoa = MaxObject('dbtoa') + +""" +decide - Choose randomly between 1 and 0 + +Outputs random 1 and 0 messages. The output sequence depends on the seed value to determine the sequence of values. + +Args: + seed (int, optional) + +Inlets: + 0 (INLET_TYPE): Make A Decision + 1 (INLET_TYPE): Set Seed (0 = Use System Time) + +Outlets: + 0 (OUTLET_TYPE): Randomly Generated 0 or 1 + +Messages: bang, int, in1 +""" +decide = MaxObject('decide') + +""" +decode - Send 1 or 0 out a specific outlet + +Provides hierarchical switching. The right inlet turns all outlets off, switch, while the middle inlet turns all outlets on. The right inlet overrides the middle inlet, and the middle inlet overrides numnbers sent to the left inlet that turn individual outlets on or off. + +Args: + outlets (int, optional) + outlets (float, optional) + +Inlets: + 0 (INLET_TYPE): Number to decode (lowest priority) + 1 (INLET_TYPE): Enable (medium priority) + 2 (INLET_TYPE): Disable All (highest priority) + +Outlets: + 0 (OUTLET_TYPE): Decode 0 (high if input = 0) + +Messages: bang, int, in1, in2 +""" +decode = MaxObject('decode') + +""" +defer - Defer execution of a message + +Defers the output of all messages sent through it to the lower priority main thread. This is most applicable when using Overdrive mode. + +Inlets: + 0 (INLET_TYPE): Message To Be Deferred + +Outlets: + 0 (OUTLET_TYPE): The Deferred Message + +Messages: bang, int, float, list, anything +""" +defer = MaxObject('defer') + +""" +deferlow - Defer the execution of a message (always) + +The deferlow object places all incoming messages at the tail of the low priority queue. This is unlike the defer object, however, which places high priority messages at the front of the low priority queue, and passes low priority messages immediately. The deferlow object is useful to preserve message sequencing that might otherwise be reversed with the defer object and/or guarantee that an incoming message will be deferred to a future servicing of the low priority queue even if that message is low priority itself. + +Inlets: + 0 (INLET_TYPE): Message To Be Deferred + +Outlets: + 0 (OUTLET_TYPE): The Deferred Message + +Messages: bang, int, float, list, anything +""" +deferlow = MaxObject('deferlow') + +""" +delay - Delay a bang + +Holds a bang for a specified amount of time before sending it to the next object. This object uses the Max time format syntax, so the delay time (which is normally specified in milliseconds) can also be set to other fixed or tempo-relative values. + +Args: + time (any, required) + +Inlets: + 0 (INLET_TYPE): bang Gets Delayed, stop Cancels + 1 (INLET_TYPE): Set Delay Time in Milliseconds + +Outlets: + 0 (OUTLET_TYPE): Delayed bang + +Messages: bang, int, float, list, anything, clock, stop + +Attributes: delaytime, quantize, transport +""" +delay = MaxObject('delay') + +""" +detonate - Play a score of note events + +Provides score playback managed using Max messages. The score may be loaded from a MIDI file, or generated using Max functions. The score is not limited to MIDI notes and values; any information can be stored and played back with detonate. + +Args: + label (symbol, required) + +Inlets: + 0 (INLET_TYPE): Control Messages, Time Parameter When Recording + 1 (INLET_TYPE): Pitch Parameter When Recording + 2 (INLET_TYPE): Vel Parameter When Recording + 3 (INLET_TYPE): Dur Parameter When Recording + 4 (INLET_TYPE): Chan Parameter When Recording + 5 (INLET_TYPE): Track Parameter When Recording + 6 (INLET_TYPE): X1 Parameter When Recording + 7 (INLET_TYPE): X2 Parameter When Recording + +Outlets: + 0 (OUTLET_TYPE): Time Parameter Output + 1 (OUTLET_TYPE): Pitch Parameter Output + 2 (OUTLET_TYPE): Vel Parameter Output + 3 (OUTLET_TYPE): Dur Parameter Output + 4 (OUTLET_TYPE): Chan Parameter Output + 5 (OUTLET_TYPE): Track Parameter Output + 6 (OUTLET_TYPE): X1 Parameter Output + 7 (OUTLET_TYPE): X2 Parameter Output + +Messages: bang, int, float, list, clear, (mouse), delay, export, follow, followat, import, in1, in2, in3, in4, in5, in6, in7, mute, next, nth, open, params, read, record, restore, setparam, start, startat, stop, unmute, unmuteall, wclose, write, writemax +""" +detonate = MaxObject('detonate') + +""" +dial - Output numbers using an onscreen dial + +Outputs numbers according to its degree of rotation. dial can be set with a certain range, offset, multiplier, as well as numerous visual settings. + +Inlets: + 0 (INLET_TYPE): Dial Displays Value Received + +Outlets: + 0 (OUTLET_TYPE): Outputs Value Received or Entered + +Messages: bang, int, float, (mouse), resize, set, setminmax + +Attributes: annotation_name, bgcolor, clip, degrees, fgcolor, floatoutput, inputrangemode, min, mode, mult, needlecolor, outlinecolor, param_connect, parameter_enable, parameter_mappable, size, style, thickness, vtracking +""" +dial = MaxObject('dial') + +""" +dialog - Open a dialog box + +Displays a dialog box with a selection of appearance modes. In Default mode, the dialog object permits entry of a symbol (as text) and sends it out the outlet when you click on the "OK" button in the dialog box. In the other modes, the dialog object displays text, but doesn't permit data entry. + +Args: + label (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Show Dialog + 1 (INLET_TYPE): 0 Sets Output as Symbol, 1 as List/Message + +Outlets: + 0 (OUTLET_TYPE): Text Entered in Dialog / bang + 1 (OUTLET_TYPE): bang When User Cancels + 2 (OUTLET_TYPE): bang When User Clicks No in Extended mode + +Messages: bang, int, float, clearsymbol, in1, symbol + +Attributes: label, mask, mode +""" +dialog = MaxObject('dialog') + +""" +dict - Create and access dictionaries + +Use the dict object to create named dictionaries, clone existing dictionaries, and query existing dictionaries to access their data. + +Args: + name (symbol, optional) + filename (symbol, optional) + +Inlets: + 0 (INLET_TYPE): dictionary input clones and sends, bang sends + 1 (INLET_TYPE): dictionary input clones but does not send + +Outlets: + 0 (OUTLET_TYPE): dictionary + 1 (OUTLET_TYPE): value for an invidual key in response to the 'get' message + 2 (OUTLET_TYPE): list of keys in response to 'getkeys' message + 3 (OUTLET_TYPE): list of dictionaries in response to 'getnames' message + 4 (OUTLET_TYPE): file operation success/failure notifications + +Messages: bang, append, clear, clone, contains, (mouse), dictionary, edit, export, get, getkeys, getnames, getsize, gettype, import, parse, pull_from_coll, push_to_coll, read, readagain, readany, remove, replace, set, setparse, wclose, write, writeagain + +Attributes: annotation_name, embed, legacy, name, parameter_enable, parameter_mappable, quiet +""" +dict_ = MaxObject('dict') + +""" +dict.codebox - Create and access dictionaries + +The dict.codebox object is a UI object for display and editing of dictionaries. Use the dict.codebox object to create named dictionaries, clone existing dictionaries, and query existing dictionaries to access their data. + +Inlets: + 0 (INLET_TYPE): dictionary input clones and sends, bang sends + 1 (INLET_TYPE): dictionary input clones but does not send + +Outlets: + 0 (OUTLET_TYPE): dictionary + 1 (OUTLET_TYPE): value for an invidual key in response to the 'get' message + 2 (OUTLET_TYPE): list of keys in response to 'getkeys' message + 3 (OUTLET_TYPE): list of dictionaries in response to 'getnames' message + 4 (OUTLET_TYPE): file operation success/failure notifications + +Messages: bang, clear, remove, getkeys, contains, getnames, getsize, gettype, get, set, append, replace, setparse, parse, clone, dictionary, read, readagain, import, readany, write, export, writeagain, (mouse), edit, wclose, pull_from_coll, push_to_coll + +Attributes: bgcolor, editlocked, embed, linenumbers, linenumberwidth, margin, style, textcolor, legacy, name, parameter_enable, parameter_mappable, quiet +""" +dict_codebox = MaxObject('dict.codebox') + +""" +dict.compare - Compare two dictionaries for equivalence. + +Dictionaries are considered equivalent if they contain the identical keys, and if those keys contain identical data. + +Inlets: + 0 (INLET_TYPE): dictionary to compare with dictionary at right inlet + 1 (INLET_TYPE): dictionary to compare with dictionary at left inlet + +Outlets: + 0 (OUTLET_TYPE): 1 if equivalent, 0 if different + +Messages: bang, dictionary + +Attributes: unordered +""" +dict_compare = MaxObject('dict.compare') + +""" +dict.deserialize - Create a dictionary from text + +Use the dict.deserialize object to create a dictionary from text passed in using Max's dictionary syntax or JSON. Alternatively, compressed forms of either format may be used. + +Args: + name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): dictionary whose contents will be deserialized + +Outlets: + 0 (OUTLET_TYPE): deserialized data from dictionary + +Messages: anything + +Attributes: name +""" +dict_deserialize = MaxObject('dict.deserialize') + +""" +dict.group - Build a dictionary iteratively + +Use the dict.group object to build up a dictionary by sending key-value pairs as lists. The key-value pairs will be collected into the dictionary until a 'bang' is received. The 'bang' will send out the dictionary and start the process over again. + +Args: + name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): dictionary syntax for appending a key/value pair, bang sends the dictionary and resets + +Outlets: + 0 (OUTLET_TYPE): dictionary output + +Messages: bang, list, anything + +Attributes: name +""" +dict_group = MaxObject('dict.group') + +""" +dict.iter - Stream the content of a dictionary + +Use the dict.iter object to send all key-value pairs out from a dictionary as a series of standard Max list messages. + +Inlets: + 0 (INLET_TYPE): dictionary input + +Outlets: + 0 (OUTLET_TYPE) + +Messages: array, dictionary +""" +dict_iter = MaxObject('dict.iter') + +""" +dict.join - Merge the content of two dictionaries + +Use the dict.join object to merge the content of two dictionaries together into a single dictionary. + +Args: + default-values (list, optional) + +Inlets: + 0 (INLET_TYPE): dictionary to combined with dictionary at right inlet + 1 (INLET_TYPE): dictionary to combined with dictionary at left inlet + +Outlets: + 0 (OUTLET_TYPE): dictionary of entries combined from both inlets + +Messages: bang, array, dictionary +""" +dict_join = MaxObject('dict.join') + +""" +dict.pack - Create a dictionary and set its values + +Use the dict.pack object to create a dictionary and set its values using dedicated inlets. + +Args: + name (symbol, optional) + default-values (list, optional) + +Inlets: + 0 (INLET_TYPE): value for the 'foo' key + +Outlets: + 0 (OUTLET_TYPE): dictionary output + +Messages: bang, int, float, list, anything, array, dictionary, string + +Attributes: keys, name, triggers, unmatched +""" +dict_pack = MaxObject('dict.pack') + +""" +dict.print - Post a dictionary to the Max Console + +Use the dict.print object to post the content of a dictionary to the Max Console. For more control over how the printing is formatted, use dict.iter and print. + +Args: + identifier (any, optional) + +Inlets: + 0 (INLET_TYPE): dictionary input + +Messages: array, dictionary +""" +dict_print = MaxObject('dict.print') + +""" +dict.route - Compare dictionaries + +Use the dict.route object to compare two dictionaries. If the dictionary received at the left inlet meets the specifications set by the dictionary at the right inlet, then pass the dictionary through the left outlet. Otherwise passes the dictionary through the right outlet. + +Args: + default-values (list, optional) + +Inlets: + 0 (INLET_TYPE): dictionary input + 1 (INLET_TYPE): dictionary input + +Outlets: + 0 (OUTLET_TYPE): dictionary matching specified keys/values + 1 (OUTLET_TYPE): dictionary not-matching specified keys/values + +Messages: dictionary +""" +dict_route = MaxObject('dict.route') + +""" +dict.serialize - Convert a dictionary's content to text + +Use the dict.serialize object to output a serialized form of the contents of dictionary in text format. The text may be Dictionary Syntax, JSON, or Base64-compressed forms of these formats. + +Inlets: + 0 (INLET_TYPE): dictionary whose contents will be serialized + +Outlets: + 0 (OUTLET_TYPE): serialized data from dictionary + +Messages: dictionary + +Attributes: compress, mode +""" +dict_serialize = MaxObject('dict.serialize') + +""" +dict.slice - Split a dictionary into two dictionaries + +Use the dict.slice object to split a dictionary into two dictionaries. The first dictionary will be created from a set of keys you provide, sent to the left outlet. The remaining dictionary content will form the second dictionary, sent to the right outlet. + +Inlets: + 0 (INLET_TYPE): dictionary input + +Outlets: + 0 (OUTLET_TYPE): dictionary output sliced of specified keys + 1 (OUTLET_TYPE): series of key/value pairs sliced from the dictionary + +Messages: dictionary + +Attributes: keys +""" +dict_slice = MaxObject('dict.slice') + +""" +dict.strip - Remove keys from a dictionary + +Use the dict.strip object to remove the specified keys from a dictionary and return their values through an outlet. Following this operation, the dictionary will no longer contain the specified keys. + +Args: + keys (list, optional) + +Inlets: + 0 (INLET_TYPE): dictionary input + +Outlets: + 0 (OUTLET_TYPE): dictionary output stripped of specified keys + 1 (OUTLET_TYPE): series of key/value pairs stripped from the dictionary + +Messages: dictionary + +Attributes: keys +""" +dict_strip = MaxObject('dict.strip') + +""" +dict.unpack - Extract values from a dictionary + +Use the dict.unpack object to return the values of specified keys through dedicated outlets. + +Args: + name (symbol, optional) + default-values (list, optional) + +Inlets: + 0 (INLET_TYPE): dictionary input + +Outlets: + 0 (OUTLET_TYPE): value for the 'foo' key + 1 (OUTLET_TYPE): dictionary: unmatched keys + +Messages: bang, array, dictionary + +Attributes: keys, legacy, unmatched +""" +dict_unpack = MaxObject('dict.unpack') + +""" +dict.view - View the contents of a dictionary + +Use the dict.view object to view the contents of a dictionary. + +Messages: bang, dictionary, expand, expandall, (mouse) + +Attributes: bgcolor, stripecolor, style, textcolor +""" +dict_view = MaxObject('dict.view') + +""" +div - Divide two numbers + +Divides two numbers (according to the specified divisor assignment), and then outputs the result. + +Args: + initial (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left / Right + +Messages: bang, int, float, in1, set, list +""" +div = MaxObject('div') + +""" +dropfile - Drag and drop files + +dropfile defines a region for dragging and dropping files into and then outputs the filepath and filetype upon file input. + +Inlets: + 0 (INLET_TYPE): types Specifies Acceptable File Types + +Outlets: + 0 (OUTLET_TYPE): Pathname of Dropped File + 1 (OUTLET_TYPE): Type Code of Dropped File + +Messages: (drag) + +Attributes: border, bordercolor, folderslash, rounded, types +""" +dropfile = MaxObject('dropfile') + +""" +drunk - Output random numbers within a step range + +Performs a "drunken" walk by outputting random numbers within a specified step range. + +Args: + maximum value (int, float, optional) + step size (int, float, optional) + +Inlets: + 0 (INLET_TYPE): bang Outputs Random Step, int Sets Value + 1 (INLET_TYPE): Sets Range Size + 2 (INLET_TYPE): Sets Step Size + +Outlets: + 0 (OUTLET_TYPE): Random Walk Output + +Messages: bang, int, float, list, reset, set, setresetvalue + +Attributes: cycle, floatoutput, range, seed, stepsize +""" +drunk = MaxObject('drunk') + +""" +equals - Compare numbers for equal-to condition + +Compares two values to see if one value is equal to a second. Outputs a 1 if the number is equal to the comparison-number or 0 if it is not. + +Args: + comparison-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left == Right + +Messages: bang, int, float, in1, set, list + +Attributes: fuzzy +""" +equals = MaxObject('equals') + +""" +error - Report Max errors + +Listens for and reports Max errors as message output. This will allow for error management in cases where it is not appropriate to display the Max window. + +Args: + on (int, optional) + +Inlets: + 0 (INLET_TYPE): 1 Turns Error Listening On, 0 Turns It Off + +Outlets: + 0 (OUTLET_TYPE): Error Message Output + +Messages: int, float, error +""" +error = MaxObject('error') + +""" +expr - Evaluate a mathematical expression + +Evaluate an expression using a C-like language. Variables and operators are used to create output values. + +Args: + expression (list, required) + constant (number, required) + inlet-format (symbol, required) + table-info (, required) + (other) (symbol, required) + +Inlets: + 0 (INLET_TYPE): Evaluate Expression, int $i1, float $f1, table $s1 + +Outlets: + 0 (OUTLET_TYPE): Expression Result + +Messages: bang, int, float, ft1, ft2, ft3, ft4, ft5, ft6, ft7, ft8, ft9, in1, in2, in3, in4, in5, in6, in7, in8, in9, set, sm1, sm2, sm3, sm4, sm5, sm6, sm7, sm8, sm9, symbol, list +""" +expr = MaxObject('expr') + +""" +filedate - Report the modification date of a file + +Inlets: + 0 (INLET_TYPE): File/Folder to Check Modification Date + +Outlets: + 0 (OUTLET_TYPE): Mod Date (Month/Day/Year/Hour/Min/Sec) + +Messages: anything +""" +filedate = MaxObject('filedate') + +""" +filein - Read and access a file of binary data + +filein reads a file of binary data and outputs the data at various points in the file given the appropriate input. + +Args: + filename (symbol, optional) + spool (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Read Byte from File + 1 (INLET_TYPE): Read Word from File + 2 (INLET_TYPE): Read Long from File + +Outlets: + 0 (OUTLET_TYPE): File Data Output + 1 (OUTLET_TYPE): bang On End of File + 2 (OUTLET_TYPE): bang When Read/Spool Finished + +Messages: int, fclose, in1, in2, read, spool +""" +filein = MaxObject('filein') + +""" +filepath - Manage and report on the Max search path + +Provides access to the Max search path, and allows modification to the search path used by a patch. + +Args: + path-type (symbol, required) + preference (int, optional) + +Inlets: + 0 (INLET_TYPE): set Changes Path, append Adds Path + +Outlets: + 0 (OUTLET_TYPE): Path Stored in Preferences + +Messages: bang, append, clear, revert, set +""" +filepath = MaxObject('filepath') + +""" +filewatch - Watch a file for changes + +Watch a specific file and reports a bang whenever that file is altered. + +Args: + filename (symbol, optional) + +Inlets: + 0 (INLET_TYPE): File/Folder Name, bang Starts Watching + +Outlets: + 0 (OUTLET_TYPE): bang If File Changes + +Messages: bang, int, anything, stop +""" +filewatch = MaxObject('filewatch') + +""" +float - Store a decimal number + +float can store and output any given floating-point number. + +Args: + initial-value (float, optional) + +Inlets: + 0 (INLET_TYPE): bang Outputs Value, int Sets and Outputs Value + 1 (INLET_TYPE): Set Value Without Output + +Outlets: + 0 (OUTLET_TYPE): Value + +Messages: bang, int, float, in1, send, set +""" +float_ = MaxObject('float') + +""" +flonum - Display and output a number + +Display, input, and output floating-point numbers in a number box. + +Inlets: + 0 (INLET_TYPE): Set Displayed Number and Repeat to Output + +Outlets: + 0 (OUTLET_TYPE): Output Incoming or Entered Number + 1 (OUTLET_TYPE): bang When Tab Key Pressed + +Messages: bang, int, float, max, min, (mouse), select, set + +Attributes: bgcolor, bordercolor, cantchange, hbgcolor, htextcolor, htricolor, maximum, minimum, mouseup, numdecimalplaces, outputonclick, parameter_enable, textcolor, triangle, tricolor, triscale +""" +flonum = MaxObject('flonum') + +""" +flush - Output MIDI note-offs for held notes + +Outputss note-off messages for any held note-ons. flush keeps track of all note-ons passed through it, and produces note-off messages for any held notes when it receives a bang message. + +Inlets: + 0 (INLET_TYPE): Pitch Input, bang Flushes Held Notes + 1 (INLET_TYPE): Velocity Input + +Outlets: + 0 (OUTLET_TYPE): Pitch Output + 1 (OUTLET_TYPE): Velocity Output + +Messages: bang, int, clear, in1 +""" +flush = MaxObject('flush') + +""" +folder - List the files in a folder + +Outputs all of the file names in a given folder. This can be especially useful for loading a umenu. + +Args: + pathname (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Path Name of Folder to List + +Outlets: + 0 (OUTLET_TYPE): File Name List, Connect to Menu + 1 (OUTLET_TYPE): Count of Items Listed + +Messages: bang, int, anything, symbol, types +""" +folder = MaxObject('folder') + +""" +follow - Compare a live performance to a recorded performance + +follow records pitches, or you can give it a MIDI file, in which case it looks at the file's note-ons and ignores other events. When it is "following" it outputs the index of the last note matched. + +Args: + filename (symbol, optional) + +Inlets: + 0 (INLET_TYPE): MIDI Pitch Input, Many Other Messages + +Outlets: + 0 (OUTLET_TYPE): Number of Note In Score + 1 (OUTLET_TYPE): MIDI Pitch Output + +Messages: bang, int, float, append, delay, dump, follow, in1, next, print, read, record, start, stop, write +""" +follow = MaxObject('follow') + +""" +fontlist - List system fonts + +Outputs a list of system fonts and, optionally, their system identification numbers. Optionally filters the list by font-family. + +Args: + font-type (symbol, optional) + +Inlets: + 0 (INLET_TYPE): bang to output font list + +Outlets: + 0 (OUTLET_TYPE): connect to an umenu object + +Messages: bang +""" +fontlist = MaxObject('fontlist') + +""" +forward - Send messages to specified receive objects + +Relays messages to other objects remotely. Unlike the send object, the destination receive object of forward can be changed with each message. + +Args: + receiver (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Message To Remote, send Changes Receiver + +Messages: bang, int, float, list, anything, send +""" +forward = MaxObject('forward') + +""" +fpic - Display an image + +Inlets: + 0 (INLET_TYPE): read Changes File, offset Changes Visible Area + +Outlets: + 0 (matrix): out + +Messages: bang, (drag), (mouse), noscale, offset, pict, read, readany, rect + +Attributes: alpha, autofit, destrect, embed, forceaspect, pic, xoffset, yoffset +""" +fpic = MaxObject('fpic') + +""" +freebang - Send a bang when a patcher is freed + +Inlets: + 0 (INLET_TYPE): Sends bang When Patcher Is Freed + +Outlets: + 0 (OUTLET_TYPE): Sends bang When Patcher Is Freed + +Messages: bang, (mouse) +""" +freebang = MaxObject('freebang') + +""" +fromsymbol - Convert a symbol into numbers/messages + +fromsymbol will take the individual characters in a symbol and convert them from a symbol back to numbers/messages. + +Inlets: + 0 (INLET_TYPE): Symbol Input to be Analyzed + +Outlets: + 0 (OUTLET_TYPE): Input Converted from Symbol + +Messages: bang, int, float, anything + +Attributes: separator +""" +fromsymbol = MaxObject('fromsymbol') + +""" +fswap - Swap position of two numbers + +Swaps the values of its inlets, preserving right-to-left ordering. The first outlet type is determined by its argument. The second outlet's type is always a float. + +Args: + initial (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Sets Value for Right Outlet, Causes Output + 1 (INLET_TYPE): Sets Value for Left Outlet + +Outlets: + 0 (OUTLET_TYPE): Value From Right Inlet + 1 (OUTLET_TYPE): Value From Left Inlet + +Messages: bang, int, float, ft1, in1 +""" +fswap = MaxObject('fswap') + +""" +ftom - Convert frequency to a MIDI note number + +ftom converts frequency to MIDI note numbers + +Args: + format (float, optional) + +Inlets: + 0 (INLET_TYPE): Frequency In + +Outlets: + 0 (OUTLET_TYPE): MIDI Note Number Out + +Messages: int, float, list + +Attributes: base, map, mapname, mid, ref, round, scale, scalename +""" +ftom = MaxObject('ftom') + +""" +funbuff - Store pairs of numbers + +Stores, manages, and recalls pairs of numbers. + +Args: + filename (symbol, optional) + +Inlets: + 0 (INLET_TYPE): list Inserts Element, int Retrieves Element + 1 (INLET_TYPE): Sets Stored Element Value for Insertion + +Outlets: + 0 (OUTLET_TYPE): Stored Element Output + 1 (OUTLET_TYPE): Index Output for next Message + 2 (OUTLET_TYPE): bang Output When next Message Reaches End + +Messages: bang, int, float, clear, copy, cut, delete, dump, embed, find, goto, in1, interp, interptab, max, min, next, paste, print, read, select, set, undo, write +""" +funbuff = MaxObject('funbuff') + +""" +function - Breakpoint function editor + +Draw or store a set of x, y points as floating-point numbers. The output the entire function is useful as an input for line~. You can also get an interpolated y value for any x value. + +Inlets: + 0 (INLET_TYPE): bang Outputs All, float Outputs Y at X, list Edits + +Outlets: + 0 (OUTLET_TYPE): Interpolated Y (float) for Input X Interpolated Y (float) for Input X + 1 (OUTLET_TYPE): All Points in line Format + 2 (OUTLET_TYPE): dump Message Output (list) + 3 (OUTLET_TYPE): bang When Changed With Mouse + +Messages: bang, int, float, list, clear, clearfix, clearsustain, color, copy, dump, fix, getfix, getsustain, lineout, listdump, (mouse), next, nth, paste, quantize_x, quantize_y, set, setcurve, setdomain, setrange, sustain, xyc + +Attributes: annotation_name, autosustain, bgcolor, bordercolor, classic_curve, clickadd, clickmove, clicksustain, constrainpointchanges, cursor, cursorcolor, domain, grid, gridcolor, gridstep_x, gridstep_y, legend, linecolor, linethickness, mode, mousemode, mousereport, outputmode, param_connect, parameter_enable, parameter_mappable, pointalign, pointcolor, pointsize, range, shadowalpha, shadowblend, shadowproportion, shadowreflectionpoint, shadowsigned, snap2grid, style, sustaincolor, textcolor, zoom_x, zoom_y +""" +function = MaxObject('function') + +""" +funnel - Tag data with its inlet number + +Identifies the inlet of incoming data. It can be used to store values into a table or coll based on their source, or used to set a destination with an object such as spray. + +Args: + inlets (int, optional) + offset (int, optional) + +Messages: bang, int, float, list, anything, offset, set +""" +funnel = MaxObject('funnel') + +""" +gamepad - Report gamepad controller events + +Tracks and outputs the button, joystick, trigger, and sensor events from all connected gamepad controllers. Send a device control messages for haptic feedback rumble events and device led color with the senddevice message. The gamepad object is a lightweight wrapper for the Simple DirectMedia Layer 2.0 Library's gamepad implementation. + +Inlets: + 0 (message): control messages + +Outlets: + 0 (list): event message + 1 (list): device info for event (instance_id device_index controller_name controller_type) + 2 (message): dumpoutlet + +Messages: addmapping, addmappingfile, senddevice, sendinstance + +Attributes: interval, rawdata +""" +gamepad = MaxObject('gamepad') + +""" +gate - Pass input to an outlet + +Args: + outlets (int, optional) + initial-state (int, optional) + +Inlets: + 0 (INLET_TYPE): 0 Closes gate, Non-zero Opens Gate Outlet + 1 (INLET_TYPE): Incoming Gated Messages + +Outlets: + 0 (OUTLET_TYPE): Output of Messages if Open + +Messages: bang, int, float, next +""" +gate = MaxObject('gate') + +""" +gestalt - Retrieve system information + +Inlets: + 0 (INLET_TYPE): symbol Reports System Information + +Outlets: + 0 (OUTLET_TYPE): Response to System Information Query + 1 (OUTLET_TYPE): Error Code Returned by Query + +Messages: bang, anything, keys, symbol + +Attributes: outputmode, selector +""" +gestalt = MaxObject('gestalt') + +""" +getattr - Query object attributes + +Provides a user interface to query attribute values from an object. You can also retrieve a list of all available attributes for the attached object. + +Args: + attribute (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Message in + +Outlets: + 0 (OUTLET_TYPE): Attribute Value + 1 (OUTLET_TYPE): Connect to An Object + 2 (OUTLET_TYPE): dumpout + +Messages: bang, getattrlist + +Attributes: attr, listen, prefix +""" +getattr_ = MaxObject('getattr') + +""" +grab - Intercept the output of another object + +grab can send a message and extract the result from the receiving object. + + Note: The grab object cannot be used to communicate from a send to a receive between Max for Live devices. + +Args: + number-of-outlets (int, optional) + receive-name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Message to Send to Object + +Outlets: + 0 (OUTLET_TYPE): Result of Remote Message + 1 (OUTLET_TYPE): Connect to Object That Will Receive Message + +Messages: bang, int, float, list, anything, set +""" +grab = MaxObject('grab') + +""" +greaterthan - Compare numbers for greater than condition + +Compares two values to see if one value is greater than a second. Outputs a 1 if the number is greater than the comparison-number or 0 if it is less than or equal to it. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left > Right + +Messages: bang, int, float, in1, set +""" +greaterthan = MaxObject('greaterthan') + +""" +greaterthaneq - Compare numbers for greater than or equal to condition + +Compares two values to see if one value is greater than or equal to a second. Outputs a 1 if the number is greater than or equal to the comparison-number or 0 if it is less. + +Args: + comparison-value (number, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left >= Right + +Messages: bang, int, float, in1, set + +Attributes: fuzzy +""" +greaterthaneq = MaxObject('greaterthaneq') + +""" +gswitch - Select output from two inlets + +Inlets: + 0 (bang/int): Control Inlet (0=Left, 1=Right) + 1 (bang/int): Left Data Inlet + 2 (bang/int): Right Data Inlet + +Outlets: + 0 (OUTLET_TYPE): Output of Selected Inlet + +Messages: bang, int, float, list, anything, (mouse) + +Attributes: annotation_name, bgcolor, color, inputs, int, param_connect, parameter_enable, parameter_mappable, style, switchcolor +""" +gswitch = MaxObject('gswitch') + +""" +gswitch2 - Send input to one of two outlets + +Switches the right inlet between two output pathways. + +Inlets: + 0 (bang/int): Control Inlet (0=Left, 1=Right) + 1 (bang/int): Data inlet + +Outlets: + 0 (OUTLET_TYPE): Left outlet + 1 (OUTLET_TYPE): Right outlet + +Messages: bang, int, float, (mouse) + +Attributes: annotation_name, bgcolor, color, int, outputs, param_connect, parameter_enable, parameter_mappable, style, switchcolor +""" +gswitch2 = MaxObject('gswitch2') + +""" +hi - Human Interface device input (legacy) + +Provides input from human interface peripherals (i.e. Trackpad, Keyboard, and others). + +Args: + device (symbol, optional) + +Inlets: + 0 (message): (message) control messages + +Outlets: + 0 (list): (list) element and value, both integers + 1 (message): (message) device enumeration output in menu format + +Messages: bang, int, anything, clear, delta, ignore, info, menu, poll +""" +hi = MaxObject('hi') + +""" +hid - Human Interface Device input (modern) + +Provides input from human interface peripherals (i.e. Trackpad, Keyboard, and others). The hid object is similar to the legacy hi object but is cross platform with more information and capabilities. This includes providing usage pages, usages, types, and ranges for the information received. (see + + https://www.usb.org/hid + + for more information) + +Args: + device (symbol, optional) + +Inlets: + 0 (message): control messages + +Outlets: + 0 (list): hid report element info and value + 1 (message): device enumeration output in menu format + 2 (message): dumpoutlet + +Messages: bang, int, anything, close, info, menu, poll + +Attributes: exclusive +""" +hid = MaxObject('hid') + +""" +hint - Display hint text + +When you mouse over a hint, you'll see a message appear on the screen below the area defined by the hint. The hint object has a number of messages you can use to change its appearance. + +Inlets: + 0 (INLET_TYPE): 1 Enables Hint, 0 Disables + +Messages: int, float, (mouse), set + +Attributes: delay, enabled +""" +hint = MaxObject('hint') + +""" +histo - Create a histogram of numbers received + +Records and outputs histogram data of the numbers it receives. + +Args: + size (int, optional) + +Inlets: + 0 (INLET_TYPE): Numbers to Keep Track Of (and 'clear' Message) + 1 (INLET_TYPE): How Many of a Number + +Outlets: + 0 (OUTLET_TYPE): Number Out + 1 (OUTLET_TYPE): Quantity of a Given Number + +Messages: bang, int, clear, in1 +""" +histo = MaxObject('histo') + +""" +hover - Report object scripting names + +Sends out the scripting names of any object over which the cursor is hovering. + +Inlets: + 0 (INLET_TYPE): controls/attributes + +Outlets: + 0 (OUTLET_TYPE): Reports the scripting name of the object over which the mouse is hovering at any given time. + 1 (OUTLET_TYPE): dumpout + 2 (OUTLET_TYPE): Scripting Name of Object Mouse Has Just Left + 3 (OUTLET_TYPE): none if Object Mouse Has Just Left Has No Scripting Name + +Attributes: mode +""" +hover = MaxObject('hover') + +""" +if - Conditional statement in if/then/else form + +Evaluates input according to a conditional statement specified in an if-then-else form. + +Args: + if (symbol, required) + then, else (symbol, required) + $i1, $f1, $s1 (symbol, required) + send (symbol, required) + out2 (symbol, required) + +Messages: bang, int, float, ft1, ft2, ft3, ft4, ft5, ft6, ft7, ft8, ft9, in1, in2, in3, in4, in5, in6, in7, in8, in9, set, symbol +""" +if_ = MaxObject('if') + +""" +imovie - Play video + +Plays a movie in a user-interface object within the patcher window. + +Inlets: + 0 (INLET_TYPE): int Locates, start Plays, Many Other Commands + +Outlets: + 0 (OUTLET_TYPE): Movie Time in Response To time Message + 1 (OUTLET_TYPE): Horiz Mouse Location When Clicked in Movie + 2 (OUTLET_TYPE): Vert Mouse Location When Clicked in Movie + +Messages: bang, int, (drag), active, clear, dispose, duration, getduration, getrate, gettime, length, loadintoram, loop, loopend, looppoints, loopset, loopstart, matrix, (mouse), mute, next, nextmovie, palindrome, passive, pause, prev, quality, rate, rd, read, readany, rect, reload, resume, start, startat, stop, switch, time, timescale, vol + +Attributes: autofit, border, moviedim, name +""" +imovie = MaxObject('imovie') + +""" +incdec - Increment and decrement a value + +Increment or Decrement a value. When connected to a number box, Click the upper half of the object to increment, click the lower half to decrement. + +Inlets: + 0 (INLET_TYPE): Number to Inc/Dec + +Outlets: + 0 (OUTLET_TYPE): Changed Number + +Messages: bang, int, float, dec, inc, (mouse), set + +Attributes: annotation_name, bgcolor, bordercolor, elementcolor, fgcolor, increment, param_connect, parameter_enable, parameter_mappable, style +""" +incdec = MaxObject('incdec') + +""" +inlet - Receive messages from outside a patcher + +Receive messages from outside the patcher wherever it is embedded. Each inlet object in a patcher will show up as an inlet at the top of an object box when the patch is used inside another patcher (as an object or a subpatch). Messages sent into such an inlet will be received by the inlet object in the subpatch. + +Inlets: + 0 (INLET_TYPE): Outputs Incoming Messages to Patcher + +Outlets: + 0 (OUTLET_TYPE): Outputs Incoming Messages to Patcher + +Messages: (mouse) + +Attributes: comment, cool, style, tricolor +""" +inlet = MaxObject('inlet') + +""" +int - Store an integer value + +int can store and output any given integer number. + +Args: + initial-value (number, optional) + +Inlets: + 0 (INLET_TYPE): bang Outputs Value, int Sets and Outputs Value + 1 (INLET_TYPE): Set Value Without Output + +Outlets: + 0 (OUTLET_TYPE): Value + +Messages: bang, int, float, in1, send, set +""" +int_ = MaxObject('int') + +""" +itable - Data table editor + +Provides visual display of the table contents in your patcher window. + +Args: + tablename (symbol, required) + +Inlets: + 0 (INLET_TYPE): int Outputs Value at Index, list Stores Value + 1 (INLET_TYPE): Sets Y Value for Next int at Left Inlet + +Outlets: + 0 (OUTLET_TYPE): Outputs Requested Indices or Values + 1 (OUTLET_TYPE): Outputs bang When Table Window Edited + +Messages: bang, int, float, list, clear, const, dump, fquantile, getbits, goto, handtool, in1, inv, length, linetool, load, max, min, (mouse), next, normal, penciltool, prev, quantile, read, refer, selecttool, send, set, setbits, sum, write + +Attributes: annotation_name, autohint, bgcolor, bgcolor2, bordercolor, embed, legend, linecolor, name, notename, param_connect, parameter_enable, parameter_mappable, pointcolor, range, selectioncolor, setresizes, shadowalpha, shadowblend, shadowproportion, signed, size, style, textcolor, tool +""" +itable = MaxObject('itable') + +""" +iter - Break a list into individual messages + +Unpacks and outputs list contents one element at a time. + +Inlets: + 0 (INLET_TYPE): list to be Unraveled + +Outlets: + 0 (OUTLET_TYPE): Sequential Output of Incoming list + +Messages: bang, int, float, list, anything +""" +iter_ = MaxObject('iter') + +""" +itoa - Convert character codes to symbol + +Convert a stream or list of up to 256 integer character codes into a symbol. + +Inlets: + 0 (int, list): Integer list converted to symbol, bang outputs current symbol + 1 (int, list): Integer list converted and concatenated to current symbol + 2 (int, list): Integer list converted and sets contents of symbol + +Outlets: + 0 (OUTLET_TYPE): Symbol output + +Messages: bang, int, float, list, clear + +Attributes: utf8 +""" +itoa = MaxObject('itoa') + +""" +jit.cellblock - Edit rows and columns of data + +Provides storage, viewing and editing of two-dimensional data. The format is similar to the "grid" display tools found in many other development environments. The current cell location, format, display and contents within jit.cellblock can be set with the mouse or by using Max messages. + +Inlets: + 0 (INLET_TYPE): anything in, bang outputs value + 1 (list): sync input + +Outlets: + 0 (list): column, row and value + 1 (list): edit values for cell + 2 (list): sync output + 3 (list): dumpout + +Messages: bang, list, append, cell, clear, col, deref, dump, jit_deref, jit_matrix, mode, plane, prepend, read, refer, refresh, row, rowblend, select, send, set, setwithoutdirty, signal, sync, text, write, writeagain + +Attributes: automouse, bblend, bgcolor, border, bordercolor, colhead, cols, colwidth, datadirty, fblend, fgcolor, grid, gridlinecolor, hcellcolor, headercolor, hscroll, hsync, interval, just, neverdirty, outmode, precision, readonly, rowhead, rowheight, rows, savemode, sccolor, selmode, selsync, sgcolor, signalmode, signalusecols, stcolor, textcolor, vscroll, vsync +""" +jit_cellblock = MaxObject('jit.cellblock') + +""" +join - Combine items into a list + +Takes separate untyped items and combines them into an output list. + +Args: + inlets (int, required) + +Inlets: + 0 (INLET_TYPE): Input (0) + 1 (INLET_TYPE): Input (1) + +Outlets: + 0 (OUTLET_TYPE): Output + +Messages: bang, int, float, list, anything, set + +Attributes: triggers +""" +join = MaxObject('join') + +""" +js - Execute Javascript (Legacy Engine) + +Exposes the Javascript language (ECMAScript 5) and some Max specific extensions. The js object can be instantiated with a javascript filename or with numerical arguments to specify the number of outlets and inlets respectively. The default number of outlets and inlets are both 1. + +Args: + filename (symbol, optional) + inlets-outlets (list, optional) + jsarguments (list, optional) + +Inlets: + 0 (INLET_TYPE): js: Inlet 0 + +Outlets: + 0 (OUTLET_TYPE): js: Outlet 0 + +Messages: bang, int, float, list, anything, autowatch, compile, delprop, editfontsize, getprop, loadbang, open, setprop, statemessage, wclose + +Attributes: annotation_name, parameter_enable, parameter_mappable, template +""" +js = MaxObject('js') + +""" +jstrigger - Execute Javascript instructions sequentially + +The jstrigger object is similar to the trigger object, except that typed-in arguments within parentheses are passed to the Javascript evaluator. For more information on the Max implementation of Javascript, refer to the Javascript in Max manual. For complete information about Javascript itself, consult a reference book such as Javascript: The Definitive Guide by David Flanagan, published by O'Reilly. + +Args: + sequential-Javascript-instructions (symbol, number, required) + +Inlets: + 0 (INLET_TYPE): Message Used for Actions + +Messages: bang, int, float, list, anything +""" +jstrigger = MaxObject('jstrigger') + +""" +jsui - Javascript user interfaces and graphics (Legacy Engine) + +Provides an environment to make user interface elements using Javascript (ECMAScript 5). This provides all of the programming tools available in the js object, but also exposes the mgraphics and sketch drawing routines for visual output. + +Inlets: + 0 (INLET_TYPE): none: Inlet 0 + +Outlets: + 0 (OUTLET_TYPE): none: Outlet 0 + +Messages: bang, int, float, list, anything, (drag), autowatch, compile, delprop, editfontsize, getprop, jsargs, jsfile, loadbang, (mouse), open, setprop, size, statemessage, wclose + +Attributes: annotation_name, border, filename, jsarguments, nofsaa, param_connect, parameter_enable, parameter_mappable, template +""" +jsui = MaxObject('jsui') + +""" +jweb - Web browser + +The jweb object uses the cross-platform Chromium Embedded Framework (CEF) to host web pages within a Max UI object. + +Inlets: + 0 (INLET_TYPE): Control Input + +Outlets: + 0 (OUTLET_TYPE): Status and Javascript Output + +Messages: anything, back, executejavascript, forward, gotohistory, (mouse), mute, read, readfile, reload + +Attributes: disablefind, history, historysize, nonstandardoutletcalls, rendermode, url +""" +jweb = MaxObject('jweb') + +""" +jweb~ - Web browser with audio output + +The jweb~ object uses the cross-platform Chromium Embedded Framework (CEF) to host web pages within a Max UI object. Audio signals generated by the page are sent out the object's outlets. + +Inlets: + 0 (INLET_TYPE): Control Input + +Outlets: + 0 (signal): Audio Output + 1 (signal): Audio Output + 2 (signal): Status and Javascript Output + +Messages: anything, back, executejavascript, forward, gotohistory, (mouse), mute, read, readfile, reload, signal + +Attributes: disablefind, history, historysize, latency, rendermode, url +""" +jweb_tilde = MaxObject('jweb~') + +""" +key - Report keyboard presses + +Tracks and outputs the key-codes, ASCII values, and modifier-key values of key presses on the computer keyboard. + +Outlets: + 0 (OUTLET_TYPE): ASCII Code of Key Pressed + 1 (OUTLET_TYPE): Platform-Specific Keyboard Code of Key Pressed + 2 (OUTLET_TYPE): Modifier Keys of Key Pressed + 3 (OUTLET_TYPE): Platform-Independent Keyboard Code of Key Pressed + +Messages: (keyboard) +""" +key = MaxObject('key') + +""" +keyup - Report key information on release + +Tracks and outputs the key-codes, ASCII values, and modifier-key values of key releases on the computer keyboard. + +Outlets: + 0 (OUTLET_TYPE): ASCII Code of Key Released + 1 (OUTLET_TYPE): Platform-Specific Keyboard Code of Key Released + 2 (OUTLET_TYPE): Modifier Keys of Key Released + 3 (OUTLET_TYPE): Platform-Independent Keyboard Code of Key Released + +Messages: (keyboard) +""" +keyup = MaxObject('keyup') + +""" +kslider - Output numbers from an onscreen keyboard + +Outputs and displays note and velocity information using an on-screen keyboard. + +Inlets: + 0 (INLET_TYPE): Displays Value Received + 1 (INLET_TYPE): Velocity Value Received + +Outlets: + 0 (OUTLET_TYPE): Outputs Key Value Changed or Received + 1 (OUTLET_TYPE): 'Velocity' from Mouse Height on Key + +Messages: bang, int, float, chord, clear, flush, ft1, in1, (mouse), set, size + +Attributes: annotation_name, blackkeycolor, bordercolor, hkeycolor, inputmode, mode, offset, param_connect, parameter_enable, parameter_mappable, range, selectioncolor, style, whitekeycolor +""" +kslider = MaxObject('kslider') + +""" +lcd - Display graphics (deprecated) + +Inlets: + 0 (INLET_TYPE): Drawing Commands + +Outlets: + 0 (OUTLET_TYPE): Mouse (X,Y) Location When Clicked + 1 (OUTLET_TYPE): Mouse Idle (X,Y) Position + 2 (OUTLET_TYPE): Mouse Down (1/0) + 3 (OUTLET_TYPE): Dump Output + +Messages: anything, ascii, backsprite, brgb, clear, clearpicts, clearsprites, closesprite, color, deletepict, deletesprite, drawpict, drawsprite, font, framearc, frameoval, framepoly, framerect, frameroundrect, frgb, frontsprite, getpenloc, getpixel, getsize, hidesprite, line, linesegment, lineto, (mouse), move, moveto, oprgb, paintarc, paintoval, paintpoly, paintrect, paintroundrect, penmode, pensize, readpict, recordsprite, reset, scrollrect, setpixel, size, textface, tilepict, write, writepict + +Attributes: bgtransparent, border, enablesprites, idle, local +""" +lcd = MaxObject('lcd') + +""" +led - Color on/off button + +Inlets: + 0 (INLET_TYPE): int Sets LED, bang Reverses It + +Outlets: + 0 (OUTLET_TYPE): Outputs 1 or 0 When LED is Changed or Set + +Messages: bang, int, float, (mouse), pict, set, toggle + +Attributes: annotation_name, bgcolor, blinktime, offcolor, oncolor, param_connect, parameter_enable, parameter_mappable, style, thickness, useoffcolor +""" +led = MaxObject('led') + +""" +lessthan - Compare numbers for less than condition + +Compares two values to see if one value is less than a second. Outputs a 1 if the number is less than the comparison-number or 0 if it is equal to or greater than it. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left < Right + +Messages: bang, int, float, in1, set +""" +lessthan = MaxObject('lessthan') + +""" +lessthaneq - Compare numbers as less than or equal to + +Compares two values to see if one value is less than or equal to a second. Outputs a 1 if the number is less than or equal to the comparison-number or 0 if it is greater to it. + +Args: + intitial-value (number, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left <= Right + +Messages: bang, int, float, in1, set + +Attributes: fuzzy +""" +lessthaneq = MaxObject('lessthaneq') + +""" +line - Generate timed ramp + +Generate ramps and line segments from one value to another within a specified amount of time. + +Args: + initial (number, optional) + grain (number, optional) + +Inlets: + 0 (INLET_TYPE): Destination Value of Ramp + 1 (INLET_TYPE): Total Ramp Time in Milliseconds + 2 (INLET_TYPE): Time Grain in Milliseconds + +Outlets: + 0 (OUTLET_TYPE): Ramp Output + 1 (OUTLET_TYPE): Signals End of Ramp + +Messages: int, float, list, clock, pause, resume, set, stop + +Attributes: compatmode, floatoutput, grain, maxpoints +""" +line = MaxObject('line') + +""" +linedrive - Scale numbers exponentially + +Scales number from one range to another with an exponential curve. Both the input and output ranges are expressed as single arguments representing the maximum value. The minimum values are the negative values of the ranges (argument * -1). + +Args: + input (number, required) + output (number, required) + curve (number, required) + delay (int, required) + +Messages: int, float, in1 +""" +linedrive = MaxObject('linedrive') + +""" +listbox - Display and output numbers, lists, and messages + +The number object displays and outputs either integers, floats, lists of numbers, or any message, depending on its format. flonum is a synonym for number in Float format, listbox is a synonym for number in List format, and textbox is a synonym for number in Text format. + +Inlets: + 0 (INLET_TYPE): Set Displayed Input and Repeat to Output + +Outlets: + 0 (OUTLET_TYPE): Output Incoming or Entered Values + 1 (OUTLET_TYPE): bang When Tab Key Pressed + +Messages: bang, int, float, list, anything, clear, max, min, (mouse), select, set + +Attributes: annotation_name, bgcolor, bordercolor, cantchange, format, hbgcolor, htextcolor, htricolor, maximum, minimum, mousefilter, numdecimalplaces, outputonclick, param_connect, parameter_enable, parameter_mappable, style, textcolor, triangle, tricolor, triscale +""" +listbox = MaxObject('listbox') + +""" +listfunnel - Index and output list elements + +Outputs the elements of an incoming list in the format: + + [index] [element] + + for each element of the list. + +Args: + offset (int, optional) + +Inlets: + 0 (INLET_TYPE): list in, Elements Will Be Output Preceded by Their Index + +Outlets: + 0 (OUTLET_TYPE): list, (Index, Element) + +Messages: int, float, list, anything, offset +""" +listfunnel = MaxObject('listfunnel') + +""" +loadbang - Send a bang when a patcher is loaded + +Outputs a bang automatically when the file is opened or when the patch is part of another file that is opened. + +Inlets: + 0 (INLET_TYPE): Outputs bang When Patcher Window is Loaded + +Outlets: + 0 (OUTLET_TYPE): Outputs bang When Patcher Window is Loaded + +Messages: bang, (mouse), loadbang +""" +loadbang = MaxObject('loadbang') + +""" +loadmess - Send a message when a patch is loaded + +Outputs a message automatically when the file is opened, or when the patch is part of another file that is opened. + +Args: + message (symbol, required) + +Inlets: + 0 (INLET_TYPE): Double-Click or bang to Re-Trigger Message + +Outlets: + 0 (OUTLET_TYPE): Message Output When Patcher Is Loaded + +Messages: bang, (mouse), set + +Attributes: defer +""" +loadmess = MaxObject('loadmess') + +""" +logand - Perform a logical AND + +Compares one number to another and outputs a 1 if the two numbers are both non-zero or a 0 if either number is 0. + +Args: + comparison-value (int, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left && Right + +Messages: bang, int, float, in1, set +""" +logand = MaxObject('logand') + +""" +logor - Perform a logical OR + +Compares one number to another and outputs a 1 if the either number is non-zero or a 0 if both number are 0. + +Args: + comparison-value (int, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left || Right + +Messages: bang, int, float, in1, set +""" +logor = MaxObject('logor') + +""" +makenote - Generate a note-on/note-off pair + +Outputs a MIDI note-on message paired with a velocity value followed by a note-off message after a specified amount of time. This allows for generative MIDI output without having to manage note-off generation. + +Args: + velocity (number, optional) + duration (number, optional) + channel (number, optional) + +Inlets: + 0 (INLET_TYPE): Pitch + 1 (INLET_TYPE): Velocity + 2 (INLET_TYPE): Duration + +Outlets: + 0 (OUTLET_TYPE): Pitch Output + 1 (OUTLET_TYPE): Velocity Output (Note-on Velocity, Then 0) + +Messages: int, float, list, anything, clear, clock, stop + +Attributes: duration, repeatmode +""" +makenote = MaxObject('makenote') + +""" +mappings - Utility object for Mappings + +The mappings object allows you to enable and disable keyboard and MIDI mapping from your Max patcher, as well as some other useful utilities. + +Messages: (mouse), key, midi, open, read, write + +Attributes: file +""" +mappings = MaxObject('mappings') + +""" +match - Watch for a message match, then output the message + +Watches an incoming stream of ints, floats, symbols, lists, or messages, and outputs the stream after it has met the specification of its arguments. + +Args: + match-list (list, required) + +Inlets: + 0 (INLET_TYPE): Input Sequence to be Matched + +Outlets: + 0 (OUTLET_TYPE): list of Matched Sequence + +Messages: int, float, list, anything, clear, set +""" +match = MaxObject('match') + +""" +matrix - Event routing matrix + +The matrix object controls the connections between inlets and outlets. You can route any inlet to any combination of outlets. Each connection has an associated gain factor and all values travelling through matrix can be scaled. It shares the same control protocol with the signal matrix~ object, but unlike matrix~, the outlets of the matrix object do not add the values of multiple inputs. matrix is best understood as a combination of gate and switch with many more features. + +Args: + number-of-inputs (int, optional) + number-of-outputs (int, optional) + default-connect-gain (float, optional) + +Inlets: + 0 (list): Connect or Disconnect + 1 (list): Input 0 + 2 (list): Input 1 + +Outlets: + 0 (dictionary): Current Connections + 1 (dictionary): Output 0 + 2 (dictionary): Output 1 + +Messages: list, clear, connect, dictionary, disconnect, dumpconnections + +Attributes: defaultgain, exclusive, inhibit, inrange, outscale, scalemode +""" +matrix = MaxObject('matrix') + +""" +matrixctrl - Matrix switch control + +Provides a user interface control containing a group of cells in a grid. Cell states can either be on/off or incremental steps. This object is especially useful for controlling the matrix~ object. + +Inlets: + 0 (INLET_TYPE): bang Outputs All Cells, list Sets Cells + +Outlets: + 0 (OUTLET_TYPE): Cell Value (Column, Row, Value) + 1 (OUTLET_TYPE): Row/Column Values As list + +Messages: bang, list, bkgndpicture, cellpicture, clear, dictionary, disable, disablecell, enablecell, getcolumn, getrow, (mouse), readanybkgnd, readanycell, set + +Attributes: active, annotation_name, autosize, bgcolor, bkgndpict, cellpict, clickedimage, clickvalue, color, columns, dialmode, dialtracking, elementcolor, horizontalmargin, horizontalspacing, imagemask, inactiveimage, invisiblebkgnd, one/column, one/matrix, one/row, parameter_enable, range, rows, scale, style, verticalmargin, verticalspacing +""" +matrixctrl = MaxObject('matrixctrl') + +""" +maximum - Output the highest value + +Watches an input stream for any numbers which are greater than its most recently set maximum. If the input value is less than or equal to the maximum, the maximum value is output. If the input value is greater, that value is output. + +Args: + initial (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Compares Left and Right Inlets + 1 (INLET_TYPE): Value to be Compared + +Outlets: + 0 (OUTLET_TYPE): Maximum of Left and Right Inlets + 1 (OUTLET_TYPE): Index of the Maximum Value + +Messages: bang, int, float, list, ft1, in1 +""" +maximum = MaxObject('maximum') + +""" +maxurl - Make HTTP requests + +maxurl is a wrapper around libcurl that can perform HTTP requests. Use it to fetch and post web content. For more information on curl please refer to the + + Curl Docs Page. + + To learn about and practice HTTP Requests, check out + + httpbin.org. + +Args: + thread count (int, optional) + +Inlets: + 0 (INLET_TYPE): Start an HTTP request (dictionary or message) + 1 (INLET_TYPE): Dictionary or Messages In + +Outlets: + 0 (OUTLET_TYPE): Output dictionary + 1 (OUTLET_TYPE): Progress info (list) + +Messages: abort, abortall, delete, dictionary, get, post, put, verbosity +""" +maxurl = MaxObject('maxurl') + +""" +mc.function - Breakpoint function editor + +Draw or store a set of x, y points as floating-point numbers. The output the entire function is useful as an input for line~. You can also get an interpolated y value for any x value. + +Inlets: + 0 (INLET_TYPE): bang Outputs All, float Outputs Y at X, list Edits + +Outlets: + 0 (OUTLET_TYPE): Interpolated Y (float) for Input X + 1 (OUTLET_TYPE): All Points in line Format + 2 (OUTLET_TYPE): dump Message Output (list) + 3 (OUTLET_TYPE): bang When Changed With Mouse + 4 (OUTLET_TYPE): Output Channel + +Messages: bang, int, float, list, clear, clearchans, clearfix, clearsustain, color, copy, dump, fix, getfix, getsustain, lineout, listdump, (mouse), next, nth, paste, quantize_x, quantize_y, set, setcurve, setdomain, setrange, setvalue, sustain, target, xyc + +Attributes: annotation_name, autosustain, bgcolor, bordercolor, candycane, candycane2, candycane3, candycane4, candycane5, candycane6, candycane7, candycane8, chans, classic_curve, clickadd, clickinactive, clickmove, clicksustain, constrainpointchanges, cursor, cursorcolor, displaychan, domain, grid, gridcolor, gridstep_x, gridstep_y, legend, linecolor, linethickness, mode, mousemode, mousereport, outputmode, param_connect, parameter_enable, parameter_mappable, pointalign, pointcolor, pointsize, range, shadowactive, shadowalpha, shadowblend, shadowproportion, shadowreflectionpoint, shadowsigned, snap2grid, style, sustaincolor, textcolor, zoom_x, zoom_y +""" +mc_function = MaxObject('mc.function') + +""" +mc.getattr - Query object attributes (multichannel) + +Provides a user interface to query attribute values from an object. You can also retrieve a list of all available attributes for the attached object. + +Args: + attribute (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Message in + +Outlets: + 0 (OUTLET_TYPE): Attribute Value + 1 (OUTLET_TYPE): Connect to An Object + 2 (OUTLET_TYPE): dumpout + +Messages: bang, getattrlist + +Attributes: attr, listen, prefix +""" +mc_getattr = MaxObject('mc.getattr') + +""" +mc.line - Generate timed ramp (multichannel) + +Generate ramps and line segments from one value to another within a specified amount of time. + +Args: + initial (number, optional) + grain (number, optional) + +Inlets: + 0 (INLET_TYPE): Destination Value of Ramp + 1 (INLET_TYPE): Total Ramp Time in Milliseconds + 2 (INLET_TYPE): Time Grain in Milliseconds + +Outlets: + 0 (OUTLET_TYPE): Ramp Output + 1 (OUTLET_TYPE): Signals End of Ramp + +Messages: int, float, list, clock, pause, resume, set, stop + +Attributes: compatmode, floatoutput, grain, maxpoints +""" +mc_line = MaxObject('mc.line') + +""" +mean - Calculate a running average + +Calculates the mean (average) of all the numbers it has received and outputs it. + +Inlets: + 0 (int/float/list): (int/float/list) Numbers to be averaged + +Outlets: + 0 (float): (float) Mean value + 1 (int): (int) Sample size + +Messages: bang, int, float, list, clear +""" +mean = MaxObject('mean') + +""" +menubar - Put up a custom menu bar + +The menubar object provides control over the menu bar. It allows your patch to put up its own menus, and add items to standard File and Edit menus. When a menu item is chosen, the item number is sent out the outlet corresponding to the menu containing the item. + +Args: + display and behavior (int, optional) + +Inlets: + 0 (INLET_TYPE): 1 Enables Menus, 0 Disables Menus + +Outlets: + 0 (OUTLET_TYPE): Application Menu Item Index Chosen + 1 (OUTLET_TYPE): File Menu Item Index Chosen + 2 (OUTLET_TYPE): Edit Menu Item Index Chosen + 3 (OUTLET_TYPE): Window Menu Item Index Chosen + +Messages: int, about, append, appendpermanent, apple, checkitem, closeitem, (mouse), edit, enableitem, end, file, item, markitem, menutitle, newitem, open, saveas +""" +menubar = MaxObject('menubar') + +""" +message - Send any message + +message displays and sends any given message with the capability to handle specified arguments. + +Args: + message (list, required) + changeable-arg (symbol, required) + comma (symbol, required) + backslash (symbol, required) + +Inlets: + 0 (INLET_TYPE): Trigger the Message, set Changes It + 1 (INLET_TYPE): Set the Message Without Output + +Outlets: + 0 (OUTLET_TYPE): Message Result + +Messages: bang, int, float, list, anything, append, (mouse), prepend, set, setargs, symbol + +Attributes: bgcolor, bgcolor2, bgfillcolor, convertobj, dontreplace, gradient, style +""" +message = MaxObject('message') + +""" +messageview - View a stream of messages + +Use the messageview object to view a stream of messages. + +Inlets: + 0 (INLET_TYPE): message input + +Outlets: + 0 (OUTLET_TYPE): message output when double clicked + +Messages: bang, int, float, list, anything, append, clear, scrolltoend + +Attributes: autoscroll, bgcolor, stripe2, style, textcolor +""" +messageview = MaxObject('messageview') + +""" +metro - Output a bang message at regular intervals + +Acts as a metronome which outputs bang s at a regular, specified interval. This object uses the Max time format syntax, so the interval that the metro object uses can be either fixed or tempo-relative. + +Args: + interval (number, optional) + +Inlets: + 0 (INLET_TYPE): Start/Stop Metronome + 1 (INLET_TYPE): Set Metronome Time Interval + +Outlets: + 0 (OUTLET_TYPE): Output Ticks of Metronome + +Messages: bang, int, float, list, anything, clock, stop + +Attributes: active, autostart, autostarttime, defer, interval, quantize, transport +""" +metro = MaxObject('metro') + +""" +midiflush - Send MIDI note-offs for hanging note-ons + +Analyzes a raw MIDI stream (from midiin or seq), counting the number of note-ons received for each note and MIDI channel. When it is sent a bang, MIDI note-off messages are sent for any notes which have not been turned off. + +Inlets: + 0 (INLET_TYPE): Raw MIDI Data, bang flushes held notes + +Outlets: + 0 (OUTLET_TYPE): Raw MIDI Data + +Messages: bang, int, clear +""" +midiflush = MaxObject('midiflush') + +""" +midiformat - Prepare data in the form of a MIDI message + +Numbers received in the inlets are used as data for MIDI messages. The data is formatted into a complete MIDI message (with the status byte determined by the inlet) and sent out the outlet as individual bytes. + +Args: + initial-MIDI-channel-number (int, optional) + initial-MIDI-channel-number (float, optional) + +Outlets: + 0 (OUTLET_TYPE): MIDI Message Output + 1 (OUTLET_TYPE): midievent Message Output + +Messages: int, float, list, in1, in2, in3, in4, in5, in7 + +Attributes: hires +""" +midiformat = MaxObject('midiformat') + +""" +midiin - Output raw MIDI data + +Listens to a specified MIDI port and output the raw MIDI data received. + +Args: + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): port Message Sets MIDI Input Port/Device + +Outlets: + 0 (OUTLET_TYPE): Raw MIDI Messages + +Messages: anything, (mouse), (MIDI), port + +Attributes: matchport, name +""" +midiin = MaxObject('midiin') + +""" +midiinfo - Fill a pop-up menu with MIDI device names + +Outputs a series of messages which will set up a pop-up menu to a list of MIDI output devices when a bang is received. A number in midiinfo's right inlet creates a list of MIDI input devices. + +Inlets: + 0 (INLET_TYPE): bang, int List Outputs, int Sets Menu Item + 1 (INLET_TYPE): bang, int List Inputs, int Sets Menu Item + +Outlets: + 0 (OUTLET_TYPE): Connect to menu Object + +Messages: bang, int, controllers + +Attributes: autopollcontrollers, autopollinput, autopolloutput +""" +midiinfo = MaxObject('midiinfo') + +""" +midiout - Transmit raw MIDI data + +Transmits raw MIDI data to a specified port. + +Args: + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Raw MIDI Messages + +Messages: int, float, list, anything, (mouse), port + +Attributes: matchport, name +""" +midiout = MaxObject('midiout') + +""" +midiparse - Interpret raw MIDI data + +Separates raw MIDI bytes into standard message types. This object works particularly well formatting the output of the midiin and seq objects. + +Inlets: + 0 (INLET_TYPE): MIDI Message Input + +Outlets: + 0 (OUTLET_TYPE): Note-on and Note-off (list: Pitch, Velocity) + 1 (OUTLET_TYPE): Poly Key Pressure (list: Key, Value) + 2 (OUTLET_TYPE): Control Change (list: Controller Number, Value) + 3 (OUTLET_TYPE): Program Change + 4 (OUTLET_TYPE): Aftertouch + 5 (OUTLET_TYPE): Pitch Bend + 6 (OUTLET_TYPE): MIDI Channel + 7 (OUTLET_TYPE): midievent Message + +Messages: bang, int, float + +Attributes: hires +""" +midiparse = MaxObject('midiparse') + +""" +minimum - Output the smallest value + +Watches an input stream for any numbers which are less than its most recently set minimum. If the input value is greater than or equal to the minimum, the minimum value is output. If the input value is less, that value is output. + +Args: + initial (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Compares Left and Right Inlets + 1 (INLET_TYPE): Value to be Compared + +Outlets: + 0 (OUTLET_TYPE): Minimum of Left and Right Inlets + 1 (OUTLET_TYPE): Index of the Minimum Value + +Messages: bang, int, float, list, ft1, in1 +""" +minimum = MaxObject('minimum') + +""" +minus - Subtract two numbers, output the result + +Args: + initial (number, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left - Right + +Messages: bang, int, float, in1, set, list +""" +minus = MaxObject('minus') + +""" +modifiers - Report modifier key presses + +Polls and reports the state of the keyboard's modifier keys. + +Args: + rate (int, optional) + +Inlets: + 0 (INLET_TYPE): bang Triggers Modifier Info + +Outlets: + 0 (OUTLET_TYPE): 1 if Shift Key Down, 0 if Up + 1 (OUTLET_TYPE): 1 if Caps Lock Down, 0 if Up + 2 (OUTLET_TYPE): 1 if Option/Alt Key Down, 0 if Up + 3 (OUTLET_TYPE): 1 if Ctrl Key Down, 0 if Up + 4 (OUTLET_TYPE): 1 if Command/Fn Key Down, 0 if Up + +Messages: bang, (keyboard), interval +""" +modifiers = MaxObject('modifiers') + +""" +modulo - Divide two numbers, output the remainder + +% takes two numbers, divides one by the other and outputs the remainder of the division. + +Args: + initial-value (int, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left % Right + +Messages: bang, int, float, in1, set, list +""" +modulo = MaxObject('modulo') + +""" +mousefilter - Gate messages with the mouse + +Allows messages to pass only when the mouse button is up (un-clicked). + +Inlets: + 0 (INLET_TYPE): Values To Be Filtered + +Outlets: + 0 (OUTLET_TYPE): Output If Mouse Button Is Up + +Messages: bang, int, float, list, anything +""" +mousefilter = MaxObject('mousefilter') + +""" +mousestate - Report the mouse information + +Provides button status and cursor position information about the mouse/cursor when the cursor is positioned within a Max patcher window. The mouse buttons are sampled every 50ms, while the mouse position is sampled every input bang. + +Inlets: + 0 (INLET_TYPE): bang Triggers Mouse Location Reporte + +Outlets: + 0 (OUTLET_TYPE): 1 if Button Down, 0 if Up + 1 (OUTLET_TYPE): Mouse Horizontal Location + 2 (OUTLET_TYPE): Mouse Vertical Location + 3 (OUTLET_TYPE): Mouse Delta Horizontal + 4 (OUTLET_TYPE): Mouse Delta Vertical + 5 (OUTLET_TYPE): 1 if Middle Button Down, 0 if Up + 6 (OUTLET_TYPE): 1 if Right Button Down, 0 if Up + 7 (OUTLET_TYPE): Mousewheel Delta Horizontal + 8 (OUTLET_TYPE): Mousewheel Delta Vertical + 9 (OUTLET_TYPE): Mousewheel Flags (smooth, inertial + +Messages: bang, mode, (mouse), nopoll, poll, reset, zero +""" +mousestate = MaxObject('mousestate') + +""" +movie - Play a movie in a window + +Plays a movie in a separate window. All movie playback control is managed by messages to the object. + +Args: + filename (symbol, optional) + +Inlets: + 0 (INLET_TYPE): int Locates, start Plays, Many Other Commands + +Outlets: + 0 (OUTLET_TYPE): Movie Time in Response To time Message + 1 (OUTLET_TYPE): Horiz Mouse Location When Clicked in Movie + 2 (OUTLET_TYPE): Vert Mouse Location When Clicked in Movie + +Messages: bang, int, (drag), active, clear, (mouse), dispose, duration, ff, getduration, getrate, gettime, length, loadintoram, loop, loopend, looppoints, loopset, loopstart, matrix, mute, next, nextmovie, open, palindrome, passive, pause, pos, prev, quality, rate, rd, read, readany, rect, reload, resume, rw, start, startat, stop, switch, time, timescale, toggleplay, vol, wclose, windowpos + +Attributes: autofit, border, name +""" +movie = MaxObject('movie') + +""" +mpeconfig - Configure a MIDI device that supports Multidimensional Polyphonic Expression (MPE) messages + +The mpeconfig object is used to set up and configure zones for interpreting incoming MIDI to MPE devices. + +Inlets: + 0 (INLET_TYPE): MPE Configuration Messages + +Outlets: + 0 (OUTLET_TYPE): MIDI Output + 1 (OUTLET_TYPE): midievent Message Output + +Messages: bang, clear, createzone, masterbendrange, notebendrange + +Attributes: chanrange, masterchan +""" +mpeconfig = MaxObject('mpeconfig') + +""" +mpeformat - Prepare data in the form of a Multidimensional Polyphonic Expression (MPE) MIDI message + +Numbers received in the inlets from midiformat objects are routed as MPE-compatible MIDI messages. In addition, the object outputs mpeevent messages for use with instruments hosted by the vst~ object. + +Args: + channels (int, required) + +Inlets: + 0 (INLET_TYPE): MIDI Input (Zone Master Channel) + 1 (INLET_TYPE): MIDI Input (for MIDI Output Channel 2) + 2 (INLET_TYPE): MIDI Input (for MIDI Output Channel 3) + 3 (INLET_TYPE): MIDI Input (for MIDI Output Channel 4) + 4 (INLET_TYPE): MIDI Input (for MIDI Output Channel 5) + 5 (INLET_TYPE): MIDI Input (for MIDI Output Channel 6) + 6 (INLET_TYPE): MIDI Input (for MIDI Output Channel 7) + 7 (INLET_TYPE): MIDI Input (for MIDI Output Channel 8) + 8 (INLET_TYPE): MIDI Input (for MIDI Output Channel 9) + 9 (INLET_TYPE): MIDI Input (for MIDI Output Channel 10) + 10 (INLET_TYPE): MIDI Input (for MIDI Output Channel 11) + 11 (INLET_TYPE): MIDI Input (for MIDI Output Channel 12) + 12 (INLET_TYPE): MIDI Input (for MIDI Output Channel 13) + 13 (INLET_TYPE): MIDI Input (for MIDI Output Channel 14) + 14 (INLET_TYPE): MIDI Input (for MIDI Output Channel 15) + 15 (INLET_TYPE): MIDI Input (for MIDI Output Channel 16) + +Outlets: + 0 (OUTLET_TYPE): MIDI Output + 1 (OUTLET_TYPE): mpeevent Message Output + +Messages: bang, int, float, midievent, mpeevent, reset + +Attributes: chanrange, masterchan, zone +""" +mpeformat = MaxObject('mpeformat') + +""" +mpeparse - Interpret raw MPE MIDI data + +Separates raw Multidimensional Polyphonic Expression (MPE) MIDI bytes into standard message types. + +Inlets: + 0 (INLET_TYPE): MIDI Message Input + +Outlets: + 0 (OUTLET_TYPE): Note-on and Note-off (list: Pitch, Velocity) + 1 (OUTLET_TYPE): Poly Key Pressure (list: Key, Value) + 2 (OUTLET_TYPE): Control Change (list: Controller Number, Value) + 3 (OUTLET_TYPE): Program Change + 4 (OUTLET_TYPE): Aftertouch + 5 (OUTLET_TYPE): Pitch Bend + 6 (OUTLET_TYPE): Voice Number (-1 if Global) + 7 (OUTLET_TYPE): Zone First Channel + 8 (OUTLET_TYPE): Zone Index (-1 if Global) + 9 (OUTLET_TYPE): mpeevent Message (list: mpeevent, Zone First Channel, Zone Index, Voice Number, Channel Number, MIDI Message Number, Data) + +Messages: bang, int, float, mpeevent + +Attributes: hires, index, strict +""" +mpeparse = MaxObject('mpeparse') + +""" +mtof - Convert a MIDI note number to frequency + +Performs MIDI-note-number to frequency conversion. Frequency is reported in as a float in Hertz (Hz). + +Inlets: + 0 (INLET_TYPE): MIDI note number input + +Outlets: + 0 (OUTLET_TYPE): frequency output + +Messages: int, float, list + +Attributes: base, map, mapname, mid, ref, scale, scalename +""" +mtof = MaxObject('mtof') + +""" +mtr - Record and sequence messages + +Records messages and provides sequenced playback. + +Args: + tracks (int, optional) + +Inlets: + 0 (INLET_TYPE): Control Input for All Tracks + 1 (INLET_TYPE): Track 1 Record/Control Input + +Outlets: + 0 (OUTLET_TYPE): next Outputs list with Track and Duration + 1 (OUTLET_TYPE): Track 1 Play Output + +Messages: bang, int, float, list, anything, addevent, clear, cleareventat, definelengthandstop, delay, deleteeventat, dictionary, dump, first, info, mute, next, play, playat, playatms, read, record, rewind, stop, timescale, touch, touchdisable, touchenable, unmute, write, writejson + +Attributes: autostart, autostarttime, bindto, embed, length, loop, mode, nextmode, quantize, selection, speed, sync, trackspeed, transport +""" +mtr = MaxObject('mtr') + +""" +multirange - Graphical function breakpoint editor + +multirange is designed to work with mc.evolve~ and mc.gradient to set their breakpoints + +Inlets: + 0 (INLET_TYPE): bang Outputs All, float Outputs Y at X, list Edits + +Outlets: + 0 (OUTLET_TYPE): Interpolated Y1, Y2, Phase for Input X + 1 (OUTLET_TYPE): All Points in line Format + 2 (OUTLET_TYPE): dump Message Output (list) + 3 (OUTLET_TYPE): bang When Changed With Mouse + +Messages: bang, int, float, list, clear, dump, listdump, (mouse) + +Attributes: annotation_name, bgcolor, color, domain, elementcolor, legend, param_connect, parameter_enable, parameter_mappable, range, style, textcolor +""" +multirange = MaxObject('multirange') + +""" +multislider - Display data as sliders or a scrolling display + +Displays data as either an array of sliders or a scrolling display. When configured as sliders, the values are set (and output) as numeric lists. When configured as a scrolling display, multislider receives numbers, plots them, and scrolls the display area. + +Inlets: + 0 (list): Sets Sliders + +Outlets: + 0 (list): Values of All Sliders + 1 (int/float): Value of One Slider + +Messages: bang, int, float, list, anything, copy, drawbars, drawlines, echo, fetch, interp, max, maximum, min, minimum, normalize, paste, pastereplace, peakreset, quantiles, range, scrollclear, select, set, setlist, setmax, setmin, sum + +Attributes: annotation_name, bgcolor, border_bottom, border_left, border_right, border_top, bordercolor, candicane2, candicane3, candicane4, candicane5, candicane6, candicane7, candicane8, candycane, compatibility, contdata, drawpeaks, ghostbar, listresize, orientation, param_connect, parameter_enable, parameter_mappable, peakcolor, setminmax, setstyle, settype, shadowalpha, shadowblend, shadoworientation, shadowperbar, shadowproportion, signed, size, slidercolor, spacing, style, thickness +""" +multislider = MaxObject('multislider') + +""" +mxj - Execute Java in Max + +Execute Java classes as Max objects. The Java classes must be specially written for Max, but work identically within the JVM (Java Virtual Machine) on both Windows and Macintosh. + +Args: + Java-class (symbol, required) + attributes (list, required) + +Messages: bang, int, float, list, anything, (mouse), get, viewsource, zap +""" +mxj = MaxObject('mxj') + +""" +next - Detect separation of messages + +Sends a bang out its left outlet when an incoming message is not part of the same Max "event" as a previous message. (An "event" is a mouse click, key press, MIDI event, or tick of the scheduler.) Otherwise, next sends a bang out its right outlet. + +Inlets: + 0 (INLET_TYPE): Any Message + +Outlets: + 0 (OUTLET_TYPE): bang if Message is a New Event + 1 (OUTLET_TYPE): bang if Message is the Same Event + +Messages: bang, int, float, anything +""" +next_ = MaxObject('next') + +""" +nodes - Interpolate data graphically + +The nodes object displays overlapping circular regions ("nodes") and outputs a list of interpolated weights based on the distance between a slider position and each node's center point. You can drag the slider with the mouse or set its position with a list of coordinates. + +Inlets: + 0 (INLET_TYPE): list of 2 (0.-1.) floats gives x,y for interpolation + +Outlets: + 0 (list): Interpolated weights for each active node + 1 (list): dumpout + 2 (list): Mouse Information (x, y, button) + +Messages: bang, list, active, ad, clear, getactive, getad, getnode, getsize, getxy, (mouse), setnode, setnodead, setnodename, setsize + +Attributes: annotation_name, bgcolor, bordercolor, candycane, candycane2, candycane3, candycane4, candycane5, candycane6, candycane7, candycane8, clickmoveinactive, disabledalpha, displayknob, dynamic, filternodeschanges, knobbordercolor, knobcolor, knobpict, knobsize, maxdynamicnodes, mousemode, nodecolor, nodenumber, nodesnames, nsize, param_connect, parameter_enable, parameter_mappable, pointcolor, style, textcolor, xplace, yplace +""" +nodes = MaxObject('nodes') + +""" +notein - Receive MIDI note messages + +Receives its input from a MIDI note-on or note-off message sent by a MIDI input device. + +Args: + port-channel (list, required) + channel (int, required) + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): port Message Sets MIDI Input Port/Device + +Outlets: + 0 (OUTLET_TYPE): Pitch + 1 (OUTLET_TYPE): Velocity + 2 (OUTLET_TYPE): MIDI Channel + +Messages: anything, (mouse), (MIDI), port + +Attributes: matchport, name +""" +notein = MaxObject('notein') + +""" +noteout - Transmit MIDI note messages + +Transmits note-on and note-off messages to a MIDI device. + +Args: + port-channel (list, required) + channel (int, required) + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Pitch + 1 (INLET_TYPE): Velocity (0 for Note-off) + 2 (INLET_TYPE): MIDI Channel + +Messages: int, float, anything, (mouse), in1, in2, port + +Attributes: matchport, name +""" +noteout = MaxObject('noteout') + +""" +notequals - Compare numbers for not-equal-to condition + +Compares two values to see if one value is not equal to a second. Outputs a 1 if the number is not equal to the comparison-number or 0 if it is equal to it. + +Args: + initial-comparison-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left != Right + +Messages: bang, int, float, in1, set, list + +Attributes: fuzzy +""" +notequals = MaxObject('notequals') + +""" +nrpnin - Output received NRPN values + +Output the value from a specific Non-Registered Parameter Number (NRPN) and MIDI channel. + +Args: + param-channel (list, optional) + +Inlets: + 0 (INLET_TYPE): Raw MIDI Bytes From midiin + +Outlets: + 0 (OUTLET_TYPE): Parameter Value + 1 (OUTLET_TYPE): Parameter Change Delta + 2 (OUTLET_TYPE): Non-Registered Parameter Number + 3 (OUTLET_TYPE): MIDI Channel + +Messages: int, list, set + +Attributes: hires, permissive +""" +nrpnin = MaxObject('nrpnin') + +""" +nrpnout - Format 14-bit MIDI NRPN messages + +Format 14-bit MIDI Non-Registered Parameter Number messages to be transmitted using the midiout object. + +Args: + parameter-channel (list, optional) + +Inlets: + 0 (INLET_TYPE): Parameter Value (0-16383 or list MSB LSB) + 1 (INLET_TYPE): Parameter Delta Change (0-127) + 2 (INLET_TYPE): Non-Registered Parameter Number (0-16383) + 3 (INLET_TYPE): MIDI Channel + +Outlets: + 0 (OUTLET_TYPE): Raw MIDI Bytes to midiout + +Messages: bang, int, list, in1, in2, in3, set + +Attributes: hires, running +""" +nrpnout = MaxObject('nrpnout') + +""" +nslider - Output numbers from a notation display + +nslider or "Note Slider" is a musical-notation-based integer value slider. + +Inlets: + 0 (INLET_TYPE): Note Value In + 1 (INLET_TYPE): Velocity Value In + +Outlets: + 0 (OUTLET_TYPE): Note Value Out + 1 (OUTLET_TYPE): Velocity Value Out + +Messages: bang, int, float, list, anything, chord, clear, flush, ft1, in1, (mouse), set + +Attributes: annotation_name, bgcolor, bordercolor, clefs, fgcolor, mode, param_connect, parameter_enable, parameter_mappable, rounded, staffs, style +""" +nslider = MaxObject('nslider') + +""" +number - Display and output numbers, lists, and messages + +The number object displays and outputs either integers, floats, lists of numbers, or any message, depending on its format. flonum is a synonym for number in Float format, listbox is a synonym for number in List format, and textbox is a synonym for number in Text format. + +Inlets: + 0 (INLET_TYPE): Set Displayed Input and Repeat to Output + +Outlets: + 0 (OUTLET_TYPE): Output Incoming or Entered Values + 1 (OUTLET_TYPE): bang When Tab Key Pressed + +Messages: bang, int, float, list, anything, clear, max, min, (mouse), select, set + +Attributes: annotation_name, bgcolor, bordercolor, cantchange, format, hbgcolor, htextcolor, htricolor, maximum, minimum, mousefilter, numdecimalplaces, outputonclick, param_connect, parameter_enable, parameter_mappable, style, textcolor, triangle, tricolor, triscale +""" +number = MaxObject('number') + +""" +numkey - Interpret numbers typed on the keyboard + +Args: + format (float, optional) + +Inlets: + 0 (INLET_TYPE): ASCII Key Codes From key + +Outlets: + 0 (OUTLET_TYPE): Value of Number Typed When Entered + 1 (OUTLET_TYPE): Value of Number While It's Being Typed + +Messages: bang, int, clear +""" +numkey = MaxObject('numkey') + +""" +offer - Store one-time number pairs + +Store two ints as an x, y pair, and access them by x value. When a pair is retrieved, it is deleted from the collection. + +Inlets: + 0 (INLET_TYPE): X After Y Stores, X Alone Outputs Y, Deletes + 1 (INLET_TYPE): Y Value To Be Stored + +Outlets: + 0 (OUTLET_TYPE): Y When Corresponding X Is Input + +Messages: bang, int, clear, in1 +""" +offer = MaxObject('offer') + +""" +onebang - Gate bangs using a bang + +Allows a bang in the left inlet to pass through ONLY if a bang has been received in the right inlet. After that, a bang in the left inlet will not get through again until a bang has been received again in the right inlet. + +Args: + initialization (int, optional) + +Inlets: + 0 (bang/anything): (bang/anything) Only first bang gets through + 1 (bang/anything): (bang/anything) Set to let one bang through + +Outlets: + 0 (bang): (bang) First bang + 1 (bang): (bang) All other bangs + +Messages: bang, int, float, list, anything, stop +""" +onebang = MaxObject('onebang') + +""" +onecopy - Prevent multiple copies of the same patcher from being opened + +Use the onecopy object inside a patcher that you want to place in the extras folder for inclusion in the Extras menu. When the patcher's name is chosen using the Extras menu, its window will be brought to the front instead of opened a second time if it has already been loaded. The patch will be loaded if it is not currently open. The onecopy object cooperates with the Extras menu to ensure that only one copy of the patcher is opened at a time. However, opening the patcher containing a onecopy object by choosing Open... from the File menu will open additional copies. +""" +onecopy = MaxObject('onecopy') + +""" +opendialog - Open a dialog to ask for a file or folder + +Use the opendialog object to select a file of a specific type or folder from a standard dialog window. To choose a folder, use the "fold" type. opendialog reports the entire pathname of the file or folder chosen, which can be passed to any Max object after the word read or load. + +Args: + folder (symbol, optional) + soundfile (symbol, optional) + file-types (symbol, optional) + +Inlets: + 0 (INLET_TYPE): bang Shows Dialog, symbol(s) Set File Types + +Outlets: + 0 (OUTLET_TYPE): Complete Path of Chosen File + 1 (OUTLET_TYPE): bang When User Cancels + +Messages: bang, anything, path, set, setpath, sound, types +""" +opendialog = MaxObject('opendialog') + +""" +osc.codebox - Display OSC packets as Dictionaries + +The osc.codebox object is a UI object for the display of OSC packets as dictionaries. + +Inlets: + 0 (INLET_TYPE): OSC packet to display in dictionary format + +Messages: FullPacket, clear, osc_packet + +Attributes: bgcolor, editlocked, embed, linenumbers, linenumberwidth, margin, style, textcolor +""" +osc_codebox = MaxObject('osc.codebox') + +""" +osc.packet - Store and recall an OSC packet + +The osc.packet object stores and recalls OSC packets, and can convert them into different formats. + +Inlets: + 0 (INLET_TYPE): OSC packet to store and output immediately + 1 (INLET_TYPE): OSC packet to store + +Outlets: + 0 (OUTLET_TYPE): stored OSC packet + +Messages: bang, FullPacket, clear, osc_packet + +Attributes: outputformat +""" +osc_packet = MaxObject('osc.packet') + +""" +outlet - Send messages out of a patcher + +Show up as an outlet at the bottom of an object box when the patcher is used inside another patcher (as an object or a subpatch). Messages received by the outlet object will come out of the corresponding outlet in the subpatch's object box. + +Inlets: + 0 (INLET_TYPE): Sends Messages Out Patcher's Outlet + 1 (INLET_TYPE): Sends Messages Out Patcher's Outlet + +Messages: (mouse) + +Attributes: comment, style, tricolor +""" +outlet = MaxObject('outlet') + +""" +pack - Create a list + +Combine items into an output list. The arguments determine the list format and types of the list elements. The number of inlets is based on the number of arguments. + +Args: + list-elements (any, optional) + +Inlets: + 0 (INLET_TYPE): value for the first list element, causes output + 1 (INLET_TYPE): value for the second list element + +Outlets: + 0 (OUTLET_TYPE): Output list + +Messages: bang, int, float, list, anything, nth, send, set, symbol +""" +pack = MaxObject('pack') + +""" +pak - Output a list when any element changes + +The pak object (pronounced "pock") offers much of the functionality of pack, but outputs the entire list whenever input is received in any inlet. + +Args: + list-elements (any, optional) + +Inlets: + 0 (INLET_TYPE): int to be Element 1 in the list + 1 (INLET_TYPE): int to be Element 2 in the list + +Outlets: + 0 (OUTLET_TYPE): Combined list from Inputs + +Messages: bang, int, float, list, anything, set +""" +pak = MaxObject('pak') + +""" +panel - Colored background area + +The panel object lets you create colored panels for use in creating user interfaces. The panel can be a variety of shapes, including circles, triangles, arrows, and rectangles with optional rounded corners. Shadows and gradients can also be used. + +Inlets: + 0 (INLET_TYPE): Graphics commands + +Messages: (mouse), size + +Attributes: angle, arrow_orientation, bgcolor, bgfillcolor, border, bordercolor, drag_window, grad1, grad2, horizontal_direction, mode, rounded, shadow, shape, style, vertical_direction +""" +panel = MaxObject('panel') + +""" +param - Define a polyphonic-compatible parameter in poly~ + +The param object appears as an attribute on the poly~ object, in addition to being published to the Parameter system, and can be attached to UI objects via the Parameter Connect feature. It currently only supports single numeric values (int/float), but not symbols nor lists. + + Parameters defined with the param object will only appear once in the Parameter Window for the top-level patcher containing the hosting poly~ object, regardless of how many voices of polyphony are configured, and changes will be propagated to all voices. This feature is useful for defining "monophonic" parameters which apply to every voice of a polyphonic structure (such as amplitude envelope attack). + +Args: + name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): messages or data in + +Outlets: + 0 (OUTLET_TYPE): value out + 1 (OUTLET_TYPE): normalized value out + +Messages: bang, int, float + +Attributes: annotation_name, default, max, min +""" +param = MaxObject('param') + +""" +param.osc - Control and report info about parameters using OSC. + +Controls and reports info about parameters using OpenSoundControl (OSC). + +Inlets: + 0 (INLET_TYPE): OSC in + +Outlets: + 0 (OUTLET_TYPE) + +Messages: bang, anything, FullPacket, allparams, info, osc_packet, param, set + +Attributes: auto, outputformat, outputmode +""" +param_osc = MaxObject('param.osc') + +""" +past - Notify when a threshold is passed + +Sends a bang when a number rises above a certain specified value. + +Args: + list (list, required) + number (int, required) + +Inlets: + 0 (INLET_TYPE): Input to be Synchronized + +Outlets: + 0 (OUTLET_TYPE): bang When Numbers Rise Above Specified Value + +Messages: int, float, list, clear, set +""" +past = MaxObject('past') + +""" +patcher - Create a subpatch within a patch + +Creates patches within patches. + +Args: + subpatch (symbol, optional) + +Inlets: + 0 (INLET_TYPE) + +Attributes: accentcolor, assistshowspatchername, bgcolor, bgfillcolor, bottomtoolbarpinned, boxanimatetime, bubble_bgcolor, bubble_outlinecolor, clearcolor, cluebar, color, commentary, defaultfocusbox, description, digest, editing_bgcolor, elementcolor, enablehscroll, enabletransparentbgwithtitlebar, enablevscroll, filepath, fontface, fontname, fontsize, globalpatchername, gridonopen, gridsize, gridsnaponopen, helpsidebarclosed, integercoordinates, isolateaudio, lefttoolbarpinned, locked_bgcolor, objectsnaponopen, openinpresentation, openrect, openrectmode, oscdefer, oscparamenableddefault, oscprefix, oscprefixmode, oscqueryenable, oscreceivemode, oscreceivequantize, oscreceivethreshold, oscreceiveudpport, oscsendmode, oscsendthreshold, oscsendudpaddr, oscsendudpport, oscuseparamprefix, oscvaluemode, patchlinecolor, righttoolbarpinned, selectioncolor, showcommentary, showontab, stripecolor, style, subpatcher_template, syntax_attrargcolor, syntax_attributecolor, syntax_objargcolor, syntax_objectcolor, taborientation, tags, tallnewobj, textcolor, textcolor_inverse, textjustification, title, toolbarvisible, toptoolbarpinned, workspacedisabled, external_mpe_tuning_enabled, is_mpe, latency, minimum_live_version, minimum_max_version, platform_compatibility +""" +patcher = MaxObject('patcher') + +""" +patcherargs - Retrieve patcher arguments + +Retrieves patcher arguments and parses attribute style arguments. "normal" arguments are sent out the left outlet (first), and attribute style arguments are sent out the right outlet (second). + +Args: + defaults (int, symbol, float, required) + +Inlets: + 0 (bang): (bang) trigger output + +Outlets: + 0 (list): (list) normal arguments + 1 (list): (list) attribute arguments + +Messages: bang, (mouse) +""" +patcherargs = MaxObject('patcherargs') + +""" +pattr - Provide an alias with a named data wrapper + +Stores its own data, or binds to another object to share its contents with other pattr-based objects (such as pattrstorage). Can be used for data routing or preset creation. + +Args: + name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): messages or data in + +Outlets: + 0 (OUTLET_TYPE): attribute value + 1 (OUTLET_TYPE): bindto connection + 2 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything, assign, (mouse), dictionary, init + +Attributes: annotation_name, autorestore, bindto, default_active, default_interp, default_priority, dirty, initial, invisible, max, min, parameter_enable, parameter_mappable, thru, type +""" +pattr = MaxObject('pattr') + +""" +pattrforward - Send any message to a named object + +Routes messages or selects new message routing destinations according to the messages it receives. You can also use the pattrforward object to route messages directly to a specific inlet of an object exposed by pattr or autopattr objects, and also send messages directly to a subpatcher, abstraction or bpatcher. + +Args: + target (symbol, optional) + +Inlets: + 0 (INLET_TYPE): messages or data in + +Outlets: + 0 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything, (mouse) + +Attributes: send +""" +pattrforward = MaxObject('pattrforward') + +""" +pattrhub - Access all pattr objects in a patcher + +Centralizes communication with all pattr objects in a patcher. + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): passout + 1 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything, getattributes, getstate + +Attributes: bound, patcher +""" +pattrhub = MaxObject('pattrhub') + +""" +pattrmarker - Provide pattr communication between patchers + +The pattrmarker object associates a patcher with a global name, which can be used when looking up named objects. This permits, among other conveniences, name lookup and communication between two or more independent patcher hierarchies. + +Args: + name (symbol, required) + +Inlets: + 0 (INLET_TYPE): set name + +Outlets: + 0 (OUTLET_TYPE): dumpout + +Messages: getmarkerlist, reveal + +Attributes: invisible, name +""" +pattrmarker = MaxObject('pattrmarker') + +""" +pattrstorage - Save and recall pattr presets + +View and modify client object data, and store or recall presets. + +Args: + name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): int, float, messages + +Outlets: + 0 (OUTLET_TYPE): dumpout + +Messages: int, float, anything, active, alias, clear, client_close, clientwindow, copy, (mouse), delete, dump, fade, fillempty, getactive, getalias, getclientlist, getcurrent, getedited, getinterp, getlockedslots, getpriority, getslotlist, getslotname, getslotnamelist, getstoredvalue, getsubscriptionlist, grab, insert, interp, locate, lock, lockall, priority, purge, read, readagain, recall, recallmulti, remove, renumber, resolvealias, setall, setstoredvalue, slotname, storage_close, storagewindow, store, storeagain, storenext, subscribe, unsubscribe, write, writeagain, writejson, writexml + +Attributes: activewritemode, annotation_name, autopattr_vis, autorestore, autowatch, backupmode, changemode, client_rect, dirty, fileusagemode, flat, greedy, notifymode, outputmode, parameter_enable, savemode, storage_rect, subscribemode, writefilter +""" +pattrstorage = MaxObject('pattrstorage') + +""" +pcontrol - Open and close subwindows + +Serves as a remote control for patcher/subpatcher windows and functions. + +Inlets: + 0 (INLET_TYPE): Control Message to Send to Patcher Window + +Outlets: + 0 (OUTLET_TYPE): Connect to Inlet of Patcher to be Controlled + +Messages: close, help, load, loadunique, open, shroud, shroudunique +""" +pcontrol = MaxObject('pcontrol') + +""" +peak - Output larger numbers + +Compares a number to a previous peak-value and, if larger, it is sent out the output while the new peak-value is set to that number. + +Args: + format (float, optional) + +Inlets: + 0 (INLET_TYPE): Find the highest number (the peak) + 1 (INLET_TYPE): Sets the peak + +Outlets: + 0 (OUTLET_TYPE): The highest number so far + 1 (OUTLET_TYPE): Goes high for a new peak + 2 (OUTLET_TYPE): Goes high for a number that isn't a new peak + +Messages: bang, int, float, ft1, in1, list +""" +peak = MaxObject('peak') + +""" +pgmin - Receive MIDI program changes + +Args: + port-channel (list, required) + channel (int, required) + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): port Message Sets MIDI Input Port/Device + +Outlets: + 0 (OUTLET_TYPE): Program Change + 1 (OUTLET_TYPE): MIDI Channel + +Messages: anything, (mouse), (MIDI), port + +Attributes: matchport, name, zerobased +""" +pgmin = MaxObject('pgmin') + +""" +pgmout - Send MIDI program changes + +Args: + port-channel (list, required) + channel (int, required) + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Program Change + 1 (INLET_TYPE): MIDI Channel + +Messages: int, float, anything, (mouse), in1, port, list + +Attributes: matchport, name, zerobased +""" +pgmout = MaxObject('pgmout') + +""" +pictctrl - Picture-based control + +Creating buttons, switches, knobs, and other controls using images from a picture file for its appearance. + +Inlets: + 0 (INLET_TYPE): int (0-1) Sets Value, read Opens File + +Outlets: + 0 (OUTLET_TYPE): Button or Dial Value + +Messages: bang, int, float, (drag), link, (mouse), picture, read, readany, set + +Attributes: active, annotation_name, clickedimage, clickincrement, clip, degrees, frames, imagemask, inactiveimage, mode, multiplier, name, offset, param_connect, parameter_enable, parameter_mappable, range, ratio, snap, threshold, trackcircular, trackhorizontal, tracking, trackvertical +""" +pictctrl = MaxObject('pictctrl') + +""" +pictslider - Picture-based slider control + +A slider control that uses pictures in external files for its appearance. It uses two pictures--one for the "knob" and one for the background over which the knob moves. The pictslider object has default pictures that are used if you do not want to supply pictures of your own, but its intended use is creating controls with customized appearances. + +Inlets: + 0 (INLET_TYPE): int: Horizontal Value; list: Both Values + 1 (INLET_TYPE): int: Vertical Value + +Outlets: + 0 (OUTLET_TYPE): Horizontal Value + 1 (OUTLET_TYPE): Vertical Value + +Messages: bang, int, float, list, (drag), bkgndpicture, knobpicture, (mouse), readanybkgnd, readanyknob, set, track + +Attributes: active, annotation_name, bgcolor, bkgnddrag, bkgndpict, bkgndsize, bottommargin, bottomvalue, clickedimage, color, elementcolor, horizontaltracking, imagemask, inactiveimage, invisiblebkgnd, jump, knobpict, leftmargin, leftvalue, movehorizontal, movevertical, param_connect, parameter_enable, parameter_mappable, rightmargin, rightvalue, scaleknob, style, topmargin, topvalue, verticaltracking +""" +pictslider = MaxObject('pictslider') + +""" +pipe - Delay numbers, lists or symbols + +Delays numbers, lists of numbers or symbols. pipe uses the Max time format syntax, so the delay interval can be either fixed or tempo-relative. + +Args: + initialization (list, optional) + +Inlets: + 0 (INLET_TYPE): Anything to be Delayed + 1 (INLET_TYPE): Set Delay Time + +Outlets: + 0 (OUTLET_TYPE): Delayed Output + +Messages: bang, int, float, list, anything, clear, flush, stop + +Attributes: clock, delaytime, quantize +""" +pipe = MaxObject('pipe') + +""" +playbar - Control video or audio file playback + +Interacts with movie, imovie, sfplay~ or jit.movie to control the playback, position and looping of the media + +Inlets: + 0 (INLET_TYPE): Commands For Controller and Its Movie + +Outlets: + 0 (OUTLET_TYPE): Connect to Movie to be Controlled + 1 (OUTLET_TYPE): Command Numbers + +Messages: bang, loop, (mouse), palindrome + +Attributes: bgcolor, color, disabledcolor, hideloop, hiderwff, refreshrate, selectioncolor, style +""" +playbar = MaxObject('playbar') + +""" +plus - Add two numbers, output the result + +Args: + initial (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left + Right + +Messages: bang, int, float, in1, set, list +""" +plus = MaxObject('plus') + +""" +poltocar - Convert polar to cartesian coordinates + +Converts a polar-coordinate pair consisting of distance and angle values into a cartesian-coordinate pair consisting of real and imaginary values. + +Inlets: + 0 (INLET_TYPE): amplitude/alpha input + 1 (INLET_TYPE): phase/theta input + +Outlets: + 0 (OUTLET_TYPE): real/x output + 1 (OUTLET_TYPE): imaginary/y output + +Messages: bang, int, float +""" +poltocar = MaxObject('poltocar') + +""" +poly - Allocate notes to different voices + +Provides polyphonic voice-allocation by allocating data to different individual voices. + +Args: + voices (number, optional) + steal-mode (int, optional) + +Inlets: + 0 (INLET_TYPE): Pitch or list with Pitch and Velocity + 1 (INLET_TYPE): Velocity + +Outlets: + 0 (OUTLET_TYPE): Voice Number + 1 (OUTLET_TYPE): Pitch + 2 (OUTLET_TYPE): Velocity + 3 (OUTLET_TYPE): Overflow Notes + +Messages: int, in1, stop +""" +poly = MaxObject('poly') + +""" +polyin - Received MIDI poly pressure + +Args: + port-channel (list, required) + key-channel (list, required) + channel (int, required) + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): port Message Sets MIDI Input Port/Device + +Outlets: + 0 (OUTLET_TYPE): Key Pressure + 1 (OUTLET_TYPE): Key Number + 2 (OUTLET_TYPE): MIDI Channel + +Messages: anything, (mouse), (MIDI), port + +Attributes: matchport, name +""" +polyin = MaxObject('polyin') + +""" +polymidiin - Output Multidimensional Polyphonic Expression (MPE) MIDI data + +The polymidiin object is used inside a poly~ instance. It outputs MPE MIDI data. + +Outlets: + 0 (OUTLET_TYPE): Raw MIDI Messages +""" +polymidiin = MaxObject('polymidiin') + +""" +polyout - Send MIDI poly pressure + +Args: + port-channel (list, required) + channel (int, required) + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Key Pressure + 1 (INLET_TYPE): Key Number + 2 (INLET_TYPE): MIDI Channel + +Messages: int, float, anything, (mouse), in1, in2, port, list + +Attributes: matchport, name +""" +polyout = MaxObject('polyout') + +""" +pong - Range limiting + +Use the pong object to clip, fold, or wrap its input within the range of a low value and a high value. + +Args: + low-value (float, optional) + high-value (float, optional) + +Inlets: + 0 (INLET_TYPE): Float Input + 1 (INLET_TYPE): (float) Lo val + 2 (INLET_TYPE): (float) Hi val + +Outlets: + 0 (signal): (float) Output + +Messages: int, float, list + +Attributes: mode, range +""" +pong = MaxObject('pong') + +""" +pow - Computes input to the nth power + +Raises the base value (set in the left inlet) to the power of the exponent (set in the right inlet). + +Args: + exponent (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Raise X... + 1 (INLET_TYPE): ...To Y + +Outlets: + 0 (OUTLET_TYPE): Result of X ^ Y + +Messages: bang, int, float, list, ft1 +""" +pow_ = MaxObject('pow') + +""" +prepend - Add a message in front of input + +Prepends any input messages with a stored message. + +Args: + message (symbol, required) + +Inlets: + 0 (INLET_TYPE): Message to be Followed by Arguments + +Outlets: + 0 (OUTLET_TYPE): Resulting Prepended Message + +Messages: bang, int, float, list, anything, set +""" +prepend = MaxObject('prepend') + +""" +preset - Store and recall settings + +preset can store and recall the parameters of any specified user interface objects at the click of a mouse. It can also be used as a user interface link to a named pattrstorage object. + +Inlets: + 0 (INLET_TYPE): Store or Recall Presets + +Outlets: + 0 (OUTLET_TYPE): Connect to Objects to Include in a Preset + 1 (OUTLET_TYPE): Preset Number When Recalled + 2 (OUTLET_TYPE): Connect to Objects to Exclude From a Preset + 3 (OUTLET_TYPE): Preset Number When Stored + 4 (OUTLET_TYPE): Connect to Object to Capture Attributes + +Messages: bang, int, float, list, anything, clear, clearall, (mouse), name, read, recallmulti, setname, store, write + +Attributes: active1, active2, bgcolor, bordercolor, bubblesize, circlecolor, clicked1, clicked2, dirty, embed, emptycolor, ignoreconnected, ignoreemptyinterp, margin, paramonly, pattrstorage, showtrack, spacing, stored1, stored2, style, textcolor +""" +preset = MaxObject('preset') + +""" +print - Print any message in the Max Console + +print will print any input into the Max Console for debugging, messaging, or analysis purposes. Selecting "Show Output" from the Object Action Menu opens the sidebar Max console and filters output to only show posts from the print object. + +Args: + identifier (any, optional) + +Inlets: + 0 (INLET_TYPE): Anything to be Printed in Max Console + +Messages: bang, int, float, list, anything, array, (mouse), dictionary, string + +Attributes: bettersymquotes, deltatime, floatprecision, level, popup, time +""" +print_ = MaxObject('print') + +""" +prob - Create a weighted transition table + +Creates a table of weighted numeric transitions. A bang message causes the weighting, and a potential transition, to be calculated. + +Inlets: + 0 (INLET_TYPE): bang Chooses State, list Assigns Transition + +Outlets: + 0 (OUTLET_TYPE): State Chosen (int) + 1 (OUTLET_TYPE): bang When In Stuck State + +Messages: bang, int, list, clear, dump, reset + +Attributes: embed +""" +prob = MaxObject('prob') + +""" +project + +Attributes: amxdtype, autolocalize, autoorganize, browsertext, devpath, devpathtype, hideprojectwindow, includepackages, readonly, showdependencies, sortmode +""" +project = MaxObject('project') + +""" +pv - Share data within a patch hierarchy + +Creates a value that is shared between objects, but only within a single patcher. Unlike the value object, pv objects that share the same name only share the same value if they are in the same patcher, or one of its subpatches. + +Args: + name (symbol, required) + message (any, optional) + +Inlets: + 0 (INLET_TYPE): bang Outputs, Anything Else Sets Value + +Outlets: + 0 (OUTLET_TYPE): Value Shared by All Local pv a Objects + +Messages: bang, int, float, list, anything, status, symbol +""" +pv = MaxObject('pv') + +""" +pvar - Connect to a named object in a patcher + +The pvar object lets you build user interfaces in one part of your patcher that are associated with the "process" part in another part of the patcher. Unlike the send and receive objects, pvar does not work globally; the pvar object and its associated object must be in the same patcher. To set an object's name, select the object, open the inspector, then enter a name under Name > Scripting Name. The name cannot be a number, although it can contain numbers. + +Args: + object-name (symbol, optional) + number-of-outlets (int, optional) + +Inlets: + 0 (INLET_TYPE): Messages for Object (Disconnected) + +Outlets: + 0 (OUTLET_TYPE): Object (Disconnected) output 1 (Not In Use) + +Messages: bang, int, float, list, anything, loadbang, setname +""" +pvar = MaxObject('pvar') + +""" +qlim - Queue-based message limiter + +Slows down throughput of messages. Limiting is based on a minimum amount of time between passed message. + +Args: + minimum (int, required) + +Inlets: + 0 (INLET_TYPE): Incoming Continuous Value + 1 (INLET_TYPE): Sets Output Interval to Send Input + +Outlets: + 0 (OUTLET_TYPE): Speed-limited Output of Incoming Values + +Messages: bang, int, float, list, anything + +Attributes: defer, quantize, threshold, usurp +""" +qlim = MaxObject('qlim') + +""" +qlist - Store a collection of messages + +Stores a collection of timed or untimed "cues" in the form of messages which can be sent either out its outlet or remotely to various receive objects in your patch. + +Inlets: + 0 (INLET_TYPE): Control Messages to qlist + +Outlets: + 0 (OUTLET_TYPE): Direct Message Output + 1 (OUTLET_TYPE): bang on End of Cue List + 2 (OUTLET_TYPE): bang When File Is Read + +Messages: bang, append, clear, (mouse), fwd, insert, next, open, read, rewind, set, stop, tempo, wclose, write +""" +qlist = MaxObject('qlist') + +""" +qmetro - Queue-based metronome + +Outputs bang messages at a set interval. Similar to metro, qmetro will drop output if the processing queue is overloaded. + +Args: + interval (number, optional) + +Inlets: + 0 (INLET_TYPE): Start/Stop Metronome + 1 (INLET_TYPE): Set Metronome Time Interval + +Outlets: + 0 (OUTLET_TYPE): Output Ticks of Metronome + +Messages: bang, int, float, list, anything, clock, reset, stop + +Attributes: active, autostart, autostarttime, defer, interval, quantize, transport +""" +qmetro = MaxObject('qmetro') + +""" +quickthresh - Fast chord detection + +Combines numbers when they are received close together. quickthresh is a faster, low-latency alternative to thresh that is optimized for chord detection. + +Args: + threshold (number, optional) + fudge (number, optional) + extension (number, optional) + +Inlets: + 0 (INLET_TYPE): Numbers to be Gathered Into list + 1 (INLET_TYPE): First Arrival Threshold (ms.) + 2 (INLET_TYPE): Fudge Factor Threshold (ms.) + 3 (INLET_TYPE): Threshold Extension (ms.) + +Outlets: + 0 (OUTLET_TYPE): List of Gathered Values + +Messages: bang, int, float, ft1, ft2, ft3, in1, in2, in3, set +""" +quickthresh = MaxObject('quickthresh') + +""" +radiogroup - Radio button or check box + +Provides a user interface for option selection. There are two modes of operation: radio button and checkbox. + +Inlets: + 0 (INLET_TYPE): Flags and Commands + +Outlets: + 0 (OUTLET_TYPE): Flags Out + +Messages: bang, int, list, disableitem, enableitem, (mouse), set + +Attributes: activecolor, annotation_name, bgcolor, elementcolor, enabled, flagmode, inactive, inactivecolor, itemtype, offset, param_connect, parameter_enable, parameter_mappable, selection, shape, size, style +""" +radiogroup = MaxObject('radiogroup') + +""" +random - Generate a random number + +Outputs random numbers within the range between 0 and 1 less than the argument specified. + +Args: + range (int, float, optional) + seed (int, optional) + +Inlets: + 0 (INLET_TYPE): Causes Random Number Output + 1 (INLET_TYPE): Causes Random Number Output + +Outlets: + 0 (OUTLET_TYPE): Random Number Output + +Messages: bang, int, float, list, reset + +Attributes: classic, cycle, floatoutput, range, seed +""" +random = MaxObject('random') + +""" +rdiv - Divide input from a number + +Divides a number by the incoming value. Functions like the / object, but the inlets' functions are reversed. + +Args: + divisor (number, optional) + +Inlets: + 0 (INLET_TYPE): Right Operand in Left Inlet! + 1 (INLET_TYPE): Left Operand in Right Inlet! + +Outlets: + 0 (OUTLET_TYPE): Quotient Out + +Messages: bang, int, float, ft1, in1 +""" +rdiv = MaxObject('rdiv') + +""" +receive - Receive messages without patch cords + +Receives and outputs messages from send objects sharing the same name. This allows you to send any kind of message between Patcher windows or within a window without using patch cords. A receive object can be instantiated with its short-form: the letter "r". + +Args: + name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): set Changes Receive Source (currently not assigned) + +Outlets: + 0 (OUTLET_TYPE): Message Received from send + +Messages: (mouse), set +""" +receive = MaxObject('receive') + +""" +regexp - Use regular expressions to process input + +With regexp, it's possible to use PERL-compatible regular expressions (PCRE) to match or make substitutions within symbols and lists. + +Args: + expression (symbol, optional) + substitution (symbol, optional) + +Inlets: + 0 (INLET_TYPE): re, substitute, or text in + +Outlets: + 0 (OUTLET_TYPE): substitutions + 1 (OUTLET_TYPE): capture groups + 2 (OUTLET_TYPE): substrings + 3 (OUTLET_TYPE): unmatched + 4 (OUTLET_TYPE): dumpout + +Messages: int, float, list, anything + +Attributes: binary, legacyoutputorder, re, substitute, tosymbol +""" +regexp = MaxObject('regexp') + +""" +relativepath - Convert an absolute to a relative path + +Converts an absolute path to one that is relative to the Max application folder. + +Inlets: + 0 (INLET_TYPE): Absolute Path + +Outlets: + 0 (OUTLET_TYPE): Path Relative to Max Application Folder + +Messages: anything +""" +relativepath = MaxObject('relativepath') + +""" +repl - Send, receive and output Max Console commands + +The repl object creates a named destination ("target") for commands you type into the Max Console window, creating a way to control patchers with a command line interface. (REPL is an acronym for Read Evaluate Print Loop.) Targets are either global -- receiving commands from any Max Console window -- or local to the patcher for which a Max Console is in the right sidebar. You can send a response to a command back to the user by sending any message to the inlet of repl. + + You can also use repl as a way to evalate commands as if they were typed into the Max Console window as well as print to the console. + +Inlets: + 0 (INLET_TYPE): Evaluate and/or Print Messages to the Max Console + 1 (INLET_TYPE) + +Outlets: + 0 (OUTLET_TYPE): Message to Target + 1 (OUTLET_TYPE): Target Name + Message + 2 (OUTLET_TYPE): Command Result + +Messages: anything, array, string + +Attributes: defer, exec, global, mirror, name, print +""" +repl = MaxObject('repl') + +""" +rminus - Subtraction object (inlets reversed) + +Subtracts the input from a specified value The !- object functions just like the - object, but the inlets' functions are reversed. + +Args: + value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Right Operand in Left Inlet! + 1 (INLET_TYPE): Left Operand in Right Inlet! + +Outlets: + 0 (OUTLET_TYPE): Difference Out + +Messages: bang, int, float, ft1, in1 +""" +rminus = MaxObject('rminus') + +""" +round - Round to a value + +Calculates and outputs an integer multiple of any given number. + +Args: + multiple (number, optional) + +Inlets: + 0 (int/float/list): Value(s) to be Rounded + 1 (int/float): Round to nearest this + +Outlets: + 0 (OUTLET_TYPE): Rounded Value(s) + +Messages: int, float, list, anything + +Attributes: nearest +""" +round_ = MaxObject('round') + +""" +route - Select outlet based on input matching + +Tries to match a message's first argument to the route object's own arguments. The rightmost outlet passes any message that matched no other choice, so you may gang route objects to get more choices + +Args: + selectors (any, optional) + +Inlets: + 0 (INLET_TYPE): Number or list to be Routed + 1 (INLET_TYPE): Number or list to be Routed + +Outlets: + 0 (OUTLET_TYPE): Outputs if Input Matches 0 + 1 (OUTLET_TYPE): Input if Input Doesn't Match + +Messages: bang, int, float, list, anything +""" +route = MaxObject('route') + +""" +routepass - Route a complete incoming message based on input matching + +Tries to match a message's first argument to the route object's own arguments. Unlike the route object, routepass does not strip off the matched portion of the message. The rightmost outlet passes any message that matched no other choice, so you may gang route objects to get more choices + +Args: + selectors (any, optional) + +Inlets: + 0 (INLET_TYPE): Number or list to be Routed + 1 (INLET_TYPE): Change Selector for Match 0 + +Outlets: + 0 (OUTLET_TYPE): Outputs if Input Matches 0 + 1 (OUTLET_TYPE): Output if Input Doesn't Match + +Messages: bang, int, float, list, anything +""" +routepass = MaxObject('routepass') + +""" +router - Route messages to multiple locations + +Args: + inlets (int, required) + outlets (int, required) + +Inlets: + 0 (INLET_TYPE): connect, disconnect, patch, clear, dump, print + 1 (INLET_TYPE): inlet 0 + +Outlets: + 0 (OUTLET_TYPE): outlet 0 + 1 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything, clear, connect, disconnect, dump, patch, print +""" +router = MaxObject('router') + +""" +rpnin - Output received RPN values + +Output the value from a specific Registered Parameter Number (RPN) and MIDI channel. + +Args: + param-channel (list, optional) + +Inlets: + 0 (INLET_TYPE): Raw MIDI Bytes From midiin + +Outlets: + 0 (OUTLET_TYPE): Parameter Value + 1 (OUTLET_TYPE): Parameter Change Delta + 2 (OUTLET_TYPE): Registered Parameter Number + 3 (OUTLET_TYPE): MIDI Channel + +Messages: int, list, set + +Attributes: hires, permissive +""" +rpnin = MaxObject('rpnin') + +""" +rpnout - Format 14-bit MIDI RPN messages + +Format 14-bit MIDI Registered Parameter Number messages to be transmitted using the midiout object. + +Args: + parameter-channel (list, optional) + +Inlets: + 0 (INLET_TYPE): Parameter Value (0-16383 or list MSB LSB) + 1 (INLET_TYPE): Parameter Delta Change (0-127) + 2 (INLET_TYPE): Registered Parameter Number (0-16383) + 3 (INLET_TYPE): MIDI Channel + +Outlets: + 0 (OUTLET_TYPE): Raw MIDI Bytes to midiout + +Messages: bang, int, list, in1, in2, in3, set + +Attributes: hires, running +""" +rpnout = MaxObject('rpnout') + +""" +rslider - Display or change a range of numbers + +Set a value range from the lowest to highest value. + +Inlets: + 0 (INLET_TYPE): int Sets Current Low Value + 1 (INLET_TYPE): int Sets Current High Value + +Outlets: + 0 (OUTLET_TYPE): Low Value + 1 (OUTLET_TYPE): High Value + +Messages: bang, int, float, list, ft1, in1, (mouse), set, setminmax + +Attributes: annotation_name, bgcolor, bordercolor, drawline, fgcolor, floatoutput, listmode, min, mult, orientation, param_connect, parameter_enable, parameter_mappable, size, style, thickness +""" +rslider = MaxObject('rslider') + +""" +rtin - Receive MIDI real time messages + +Receives and outputs MIDI real time messages transmitted from a specified MIDI input device. + +Args: + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): port Message Sets MIDI Input Port/Device + +Outlets: + 0 (OUTLET_TYPE): Incoming MIDI Clock Messages + +Messages: anything, (mouse), (MIDI), port + +Attributes: matchport, name +""" +rtin = MaxObject('rtin') + +""" +savebang - Send a bang on save + +Sends a bang whenever the patcher window within which it resides is saved. + +Inlets: + 0 (INLET_TYPE): Sends bang When Patcher Window Is Saved + +Outlets: + 0 (OUTLET_TYPE): Output bang + +Messages: bang, (mouse) +""" +savebang = MaxObject('savebang') + +""" +savedialog - Open a dialog asking for a filename + +Opens a file dialog for selection or entry of a filename to write. savedialog takes a list of one or more file types and allows you to save a file and choose a type for it. + +Args: + filetypes (symbol, optional) + +Inlets: + 0 (INLET_TYPE): bang Shows Dialog, symbol(s) Set File Types + +Outlets: + 0 (OUTLET_TYPE): Complete Path of Chosen Filename + 1 (OUTLET_TYPE): Type Code Chosen + 2 (OUTLET_TYPE): bang When User Cancels + +Messages: bang, anything, name, path, set, setpath +""" +savedialog = MaxObject('savedialog') + +""" +scale - Map values to an output range + +The scale object maps an input range of float or integer values to an output range. The output range can be larger or smaller than the input range, can be inverted and can change numeric type. If specified, the mapping can also be exponential. Please note that unanticipated results can occur when using integer arguments, as output values are truncated rather than rounded. For precise output values, use float arguments. + +Args: + input-low (number, optional) + input-high (number, optional) + output-low (number, optional) + output-high (number, optional) + exponential (float, optional) + +Inlets: + 0 (INLET_TYPE): input value + 1 (INLET_TYPE): input range low + 2 (INLET_TYPE): input range high + 3 (INLET_TYPE): output range low + 4 (INLET_TYPE): output range high + 5 (INLET_TYPE): exponential base value + +Outlets: + 0 (OUTLET_TYPE): Output value + +Messages: bang, int, float, list + +Attributes: classic +""" +scale = MaxObject('scale') + +""" +schedule - Schedule messages on high priority scheduler thread + +The schedule object schedules messages to execute on the high priority scheduler thread, optionally with a delay time (ms), and optionally deferring to main application thread after the delay time. Similar to the delay and pipe objects, but supports arbitrary messages. + +Args: + delay (number, optional) + +Inlets: + 0 (INLET_TYPE): Message To Be Scheduled + +Outlets: + 0 (OUTLET_TYPE): The Scheduled Message + +Messages: bang, int, float, list, anything, clear, sendmessage + +Attributes: defer, delay +""" +schedule = MaxObject('schedule') + +""" +screensize - Output the monitor size + +Reports the resolution to which the computer's monitor is currently set. + +Inlets: + 0 (INLET_TYPE): bang Reports Screen Size + +Outlets: + 0 (list): (list) Coordinates of Main Screen + 1 (list): (list) Coordinates Enclosing All Monitors + +Messages: bang +""" +screensize = MaxObject('screensize') + +""" +select - Output bangs based on input matching + +Selectively outputs a bang in response to any input which matches its arguments and will output non-matching messages out its right-most outlet. + +Args: + inlet (int, required) + selectors (any, optional) + +Inlets: + 0 (INLET_TYPE): Number to be Tested + 1 (INLET_TYPE): Set Number to Match + +Outlets: + 0 (OUTLET_TYPE): bang if Input Matches 0 + 1 (OUTLET_TYPE): Input if Input Doesn't Match + +Messages: bang, int, float, list, anything, in1, symbol + +Attributes: fuzzy, matchfloat +""" +select = MaxObject('select') + +""" +send - Send messages without patch cords + +send will transmit given messages to receive objects which are named by the same argument and will allow you to send any kind of message between Patcher windows or within a window without using patch cords. A send object can be instantiated simply by typing into an object box the short-form letter "s". + +Args: + name (symbol, required) + +Inlets: + 0 (INLET_TYPE): Message to Send to receive a + +Messages: bang, int, float, list, anything, (mouse) +""" +send = MaxObject('send') + +""" +seq - Sequencer for recording and playing MIDI data + +seq is a sequencer of raw MIDI bytes. You can control the speed of playback (only at the time you start it), read and write from files, and record from live MIDI input. See also midiparse and midiformat which you may need to get to and from raw MIDI. + +Args: + filename (symbol, optional) + +Inlets: + 0 (INLET_TYPE): MIDI Data In, Many Other Messages + +Outlets: + 0 (OUTLET_TYPE): MIDI Data Out When Playing + 1 (OUTLET_TYPE): bang When Sequence Done + 2 (OUTLET_TYPE): MIDI Meta Messages When Playing + +Messages: bang, int, float, addeventdelay, append, clear, delay, dump, hook, print, read, record, start, stop, tick, write + +Attributes: overridetempo, sequencetempo, tempo +""" +seq = MaxObject('seq') + +""" +serial - Send and receive from a serial port + +Args: + portname (symbol, required) + port (symbol, optional) + rate (int, optional) + data (int, optional) + stop (int, optional) + parity (int, symbol, optional) + +Inlets: + 0 (INLET_TYPE): int, list Send Chars, bang Polls Output + +Outlets: + 0 (OUTLET_TYPE): Output As Integer Characters + 1 (OUTLET_TYPE): Status Signals + +Messages: bang, int, float, list, break, close, getport, open, port, print, refresh, reset + +Attributes: asyncread, autoopen, baud, break_duration, bufsize, chunk, databits, defer, drain, dtr, parity, poll, postbreak_duration, rts, serport, stopbits, xonxoff +""" +serial = MaxObject('serial') + +""" +setclock - Create and control an alternative clock + +Allows the creation of alternatives to the standard millisecond clock. This includes several modes of timing that change timing activities. Each setclock is associated with a name (its first argument), and this name may be passed as the argument to a "clock" message to numerous objects that use timing in Max, such as metro, line, and pipe. + +Args: + name (symbol, required) + mode (symbol, required) + multiplier (float, required) + +Inlets: + 0 (INLET_TYPE): Time Values or Adjustments + 1 (INLET_TYPE): Time Update Interval + +Outlets: + 0 (OUTLET_TYPE): Current Time of Clock (bang Message) + +Messages: bang, int, float, clock, (mouse), ft1, reset, set +""" +setclock = MaxObject('setclock') + +""" +shiftleft - Bit shift to the left + +Shifts all bit values to the left. This has the effect of multiplying a number by a power of two, but is less expensive in computer time. + +Args: + initial-value (int, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left << Right + +Messages: bang, int, float, in1, set, list +""" +shiftleft = MaxObject('shiftleft') + +""" +shiftright - Bit shift to the right + +Shifts all bit values to the right. This has the effect of dividing a number by a power of two, but is less expensive in computer resources. + +Args: + initial-value (int, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left >> Right + +Messages: bang, int, float, in1, set, list +""" +shiftright = MaxObject('shiftright') + +""" +sin - Sine function + +Use the sin object to calculate and output the sine of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Sin (x) + +Messages: bang, int, float +""" +sin = MaxObject('sin') + +""" +sinh - Hyperbolic sine function + +Use the sinh object to calculate and output the hyperbolic sine of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Sinh (x) + +Messages: bang, int, float +""" +sinh = MaxObject('sinh') + +""" +slide - Smooth values logarithmically + +Filters an input value logarithmically between changes. It's particularly useful for envelope following and lowpass filtering to smooth a stream of continuous data. + +Args: + slide-up (float, optional) + slide-down-value (float, optional) + +Inlets: + 0 (float): (float) Input + 1 (float): (float) Slide up + 2 (float): (float) Slide down + +Outlets: + 0 (float): (float) Output + +Messages: bang, int, float, ft1, ft2, reset, set +""" +slide = MaxObject('slide') + +""" +slider - Move a slider to output values + +Resembles a sliding potentiometer, outputting numbers restricted to a specified range, offset by a specified number, and multiplied by a specified number. + +Inlets: + 0 (INLET_TYPE): Displays Value Received + +Outlets: + 0 (OUTLET_TYPE): Outputs Value When Slider is Changed + +Messages: bang, int, float, (mouse), set, setminmax + +Attributes: annotation_name, bgcolor, bordercolor, drawoffcolor, elementcolor, floatoutput, inputrangemode, knobcolor, knobshape, min, mult, orientation, param_connect, parameter_enable, parameter_mappable, relative, size, style, thickness +""" +slider = MaxObject('slider') + +""" +speedlim - Limit the speed of message throughput + +Limit the throughput speed of incoming messages to a fixed time limit. The time can be specified in milliseconds or using a tempo-relative interval. + +Args: + delta-time (int, symbol, float, optional) + +Inlets: + 0 (INLET_TYPE): Incoming Continuous Value + 1 (INLET_TYPE): Sets Output Interval to Send Input + +Outlets: + 0 (OUTLET_TYPE): Speed-limited Output of Incoming Values + +Messages: bang, int, float, list, anything + +Attributes: defer, quantize, threshold, usurp +""" +speedlim = MaxObject('speedlim') + +""" +spell - Convert input to UTF-8 (Unicode) codes + +Accepts a numeric stream and outputs and outputs ASCII characters. Options arguments provide for forced-length messages. + +Args: + size (int, optional) + character (int, optional) + +Inlets: + 0 (INLET_TYPE): Symbol to be Spelled + +Outlets: + 0 (OUTLET_TYPE): Symbol's Characters, As Integers + +Messages: int, list, anything, symbol +""" +spell = MaxObject('spell') + +""" +split - Look for a range of numbers + +Check if input can fall within a specified range. If it falls within that range, it sends the number out the left outlet and if it does not, then it sends the number out the right outlet. + +Args: + minimum (number, required) + maximum (number, required) + +Inlets: + 0 (INLET_TYPE): Value to be Sent to One of the Two Outlets + 1 (INLET_TYPE): Set Lower Limit for Left Outlet + 2 (INLET_TYPE): Set Upper Limit for Left Outlet + +Outlets: + 0 (OUTLET_TYPE): Output if Within Limits + 1 (OUTLET_TYPE): Output if Not Within Limits + +Messages: int, float +""" +split = MaxObject('split') + +""" +spray - Distribute a value to a numbered outlet + +Accepts lists as input, where the first number is taken as the outlet number, and one or more values that follow are sent out that outlet and those to its right, in right-to-left order. The argument sets the number of outlets (there is no set limit). The default number of outlets is 2. + +Args: + outlets (int, optional) + offset (int, optional) + listmode (int, optional) + +Inlets: + 0 (INLET_TYPE): list: Outlet Number Followed by Data + +Outlets: + 0 (OUTLET_TYPE): Outlet Number 0 + 1 (OUTLET_TYPE): Outlet Number 1 + +Messages: int, list, offset +""" +spray = MaxObject('spray') + +""" +sprintf - Format a message of words and numbers + +Uses the common C-language "printf" function inside Max. You can combine symbols, organize lists of numbers, or format messages or menu items. For complete documentation, refer to a standard C library reference manual. + +Args: + format (symbol, required) + symout (symbol, optional) + +Inlets: + 0 (INLET_TYPE): First Argument, Causes Output + +Outlets: + 0 (OUTLET_TYPE): Formatted String as a Message + +Messages: bang, int, float, list, anything, symbol +""" +sprintf = MaxObject('sprintf') + +""" +sqrt - Square root function + +Calculates and outputs the square-root of any given number. + +Args: + initial (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Sqrt (x) + +Messages: bang, int, float +""" +sqrt = MaxObject('sqrt') + +""" +standalone - Configure parameters for standalone applications + +The standalone object lets you set options for creating a standalone application from a Max patch, and is used in conjunction with the Build Application/Collective... item found in the File menu. You should only have one standalone object in your top-level patch. + +Inlets: + 0 (INLET_TYPE): Messages to Configure Standalone Application + +Attributes: allwindowsactive, appicon_mac, appicon_win, bundleidentifier, cantclosetoplevelpatchers, cefsupport, copysupport, database, gensupport, noloadbangdefeating, overdrive, preffilename, searchformissingfiles, statusvisible, usesearchpath +""" +standalone = MaxObject('standalone') + +""" +stepcounter - Count messages in a sequence + +The stepcounter object uses messages to advance through a sequence of count values. The output producted by stepcounter can be used to generate a sequence of durations from a metro. + +Inlets: + 0 (anything): Messages to Count + +Outlets: + 0 (OUTLET_TYPE): bang When Current Count Reached + 1 (OUTLET_TYPE): bang When Sequence Resets + 2 (OUTLET_TYPE): Step Index (0-Relative) + 3 (OUTLET_TYPE): Counter Index (0-Relative) + +Messages: bang, int, float, anything, reset + +Attributes: seq, startmode, syncupdate +""" +stepcounter = MaxObject('stepcounter') + +""" +string - Create or duplicate a string object + +Create a string, a block of text in memory that is not stored in Max's symbol table. + +Args: + value (, optional) + +Inlets: + 0 (INLET_TYPE): messages in + 1 (INLET_TYPE): set string value, messages in + +Outlets: + 0 (OUTLET_TYPE): string out + 1 (OUTLET_TYPE): atoms out + 2 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything, append, atoms, clear, prepend, string + +Attributes: length, name, parameter_enable, parameter_mappable +""" +string = MaxObject('string') + +""" +string.append - Append a string to another string object, with an optional separator + +Args: + initial-string (list, optional) + +Inlets: + 0 (INLET_TYPE): left string in will be concatenated with the right string + 1 (INLET_TYPE): set right string + 2 (INLET_TYPE): set separator string (or 'emptystring') + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything, string + +Attributes: separator +""" +string_append = MaxObject('string.append') + +""" +string.bytes - Iterate the UTF-8 data in a string as bytes (ints) + +Multibyte characters are output as a series of up to 4 bytes. + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): iterated string characters + +Messages: bang, int, float, list, anything, string +""" +string_bytes = MaxObject('string.bytes') + +""" +string.change - Detect string changes + +Output a string if it is different from the previous string received. Use the right inlet to set the test string without output. + +Args: + comparison-string (list, optional) + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): 1 if different, 0 if identical + 1 (OUTLET_TYPE): 1 if different, 0 if identical + +Messages: bang, int, float, list, anything, string +""" +string_change = MaxObject('string.change') + +""" +string.compare - Compare two string objects for equality + +When triggered, the object will reveal a '0' if unequal and a '1' if equal. + +Args: + initial-string (list, optional) + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): 1 if identical, 0 if different + +Messages: bang, int, float, list, anything, string + +Attributes: casemode, cmpmode +""" +string_compare = MaxObject('string.compare') + +""" +string.concat - Concatenate two string objects + +The string received in the right inlet will be appended to the string received in the left inlet, and a new string will be set to the outlet. The original string objects are not modified. + +Inlets: + 0 (INLET_TYPE): left string in will be concatenated with the right string + 1 (INLET_TYPE): set right string + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything, string +""" +string_concat = MaxObject('string.concat') + +""" +string.contains - Test whether a string object contains another string + +The substring can occur at any point inside the test string object. + +Args: + search string (symbol, optional) + +Inlets: + 0 (INLET_TYPE): string to search in (string1) + 1 (INLET_TYPE): string to search for (string2) + +Outlets: + 0 (OUTLET_TYPE): 1 if string1 contains string2, 0 if not + +Messages: bang, int, float, list, anything, string +""" +string_contains = MaxObject('string.contains') + +""" +string.endswith - Test whether a string object ends with a substring + +Args: + comparison-string (list, optional) + +Inlets: + 0 (INLET_TYPE): string in (string1) + 1 (INLET_TYPE): comparison string in (string2) + +Outlets: + 0 (OUTLET_TYPE): 1 if string1 ends with string2, 0 if not + +Messages: bang, int, float, list, anything, string +""" +string_endswith = MaxObject('string.endswith') + +""" +string.frombytes - Construct a new string object from bytes (ints) + +Construct a new string object from bytes (ints). Similar to itoa. + +Inlets: + 0 (INLET_TYPE): chars (list) in + 1 (INLET_TYPE): chars (list) in + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything +""" +string_frombytes = MaxObject('string.frombytes') + +""" +string.fromsymlist - Construct a new string from a list of symbols + +The individual symbols are concatenated together to create a new string, without any separator. + +Inlets: + 0 (INLET_TYPE): symbol list in + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything +""" +string_fromsymlist = MaxObject('string.fromsymlist') + +""" +string.fromutf8 - Construct a new string object from UTF-8 characters, as integer values + +Multibyte characters are expected to arrive as a single large value. + +Inlets: + 0 (INLET_TYPE): bytes (list) in + 1 (INLET_TYPE): bytes (list) in + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything +""" +string_fromutf8 = MaxObject('string.fromutf8') + +""" +string.index - Output the character at an index in a string object (0-based) + +Extract a character from an incoming string object, based on the index specified (0-based). Indices can be negative to refer to characters starting from the end of the string (-1 refers to the last character, -2 the next to last character, etc.). + +Args: + index (int, optional) + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): position in string to extract (0-based) + +Outlets: + 0 (OUTLET_TYPE): nth element of the string + 1 (OUTLET_TYPE): string with nth element removed + +Messages: bang, int, float, list, anything, in1, string +""" +string_index = MaxObject('string.index') + +""" +string.indexof - Search for the index of a string + +Output the position of a substring within a longer string as an integer index. Output -1 if the substring cannot be found. + +Inlets: + 0 (INLET_TYPE): string to search for + 1 (INLET_TYPE): string to search in + +Outlets: + 0 (OUTLET_TYPE): index out + +Messages: bang, int, float, list, anything, string +""" +string_indexof = MaxObject('string.indexof') + +""" +string.iter - Iterate the UTF-8 characters of a string object as individual symbols + +Inlets: + 0 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): iterated string characters + +Messages: bang, int, float, list, anything, string +""" +string_iter = MaxObject('string.iter') + +""" +string.length - Determine the length of a string object + +The length is the number of UTF-8 characters in the string, and might be different from the count of bytes in the string. + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): length out + +Messages: bang, int, float, list, anything, clear, string +""" +string_length = MaxObject('string.length') + +""" +string.prepend - Prepend a string to another string object, with an optional separator + +Args: + initial-string (list, optional) + +Inlets: + 0 (INLET_TYPE): left string in will be concatenated with the right string + 1 (INLET_TYPE): set right string + 2 (INLET_TYPE): set separator string (or 'emptystring') + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything, string + +Attributes: separator +""" +string_prepend = MaxObject('string.prepend') + +""" +string.regexp - Use regular expressions to process input + +Args: + expression (symbol, optional) + substitution (symbol, list, optional) + +Inlets: + 0 (INLET_TYPE): re, substitute, or text in + 1 (INLET_TYPE): re (regular expression) in + 2 (INLET_TYPE): substitute in + +Outlets: + 0 (OUTLET_TYPE): substitutions + 1 (OUTLET_TYPE): capture groups + 2 (OUTLET_TYPE): substrings + 3 (OUTLET_TYPE): unmatched + 4 (OUTLET_TYPE): substring offsets + +Messages: bang, int, float, list, anything, string + +Attributes: re, substitute +""" +string_regexp = MaxObject('string.regexp') + +""" +string.remove - Remove a range of characters from a string object + +The range is 0-based and inclusive (a range of 2 4 removes character 2, 3 and 4 of the incoming string). + +Args: + remove-start (int, optional) + remove-end (int, optional) + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): remove start index (0-based) + 2 (INLET_TYPE): remove end index (0-based) + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything, in1, in2, string +""" +string_remove = MaxObject('string.remove') + +""" +string.replace - Replace the first instance of a substring with a substitution string + +Will only replace the first instance of the substring, if any. To replace all occurences of a given string, use string.replaceall. + +Args: + search string (any, optional) + replacement (any, optional) + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): search string + 2 (INLET_TYPE): replacement string + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything, string +""" +string_replace = MaxObject('string.replace') + +""" +string.replaceall - Replace all instances of a substring with a substitution string + +Args: + substitution-string (list, optional) + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): search string + 2 (INLET_TYPE): replacement string + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything, string +""" +string_replaceall = MaxObject('string.replaceall') + +""" +string.reverse - Reverse a string + +The output string will contain the characters of the incoming string, but backward. + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): reversed string out + +Messages: bang, int, float, list, anything, string +""" +string_reverse = MaxObject('string.reverse') + +""" +string.rotate - Rotate the characters within a string object + +Positive values rotate right, negative rotate left. + +Args: + rotations (int, optional) + +Inlets: + 0 (INLET_TYPE): string to rotate + 1 (INLET_TYPE): positions to rotate (negative to rotate left) + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything, in1, string +""" +string_rotate = MaxObject('string.rotate') + +""" +string.slice - Generate a new string from a range of characters in an incoming string + +string.slice is similar to string.substring, but attempts to conform to the JavaScript String.slice() behavior. + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): slice indices (0-based) + +Outlets: + 0 (OUTLET_TYPE): sliced string out + +Messages: bang, int, float, list, anything, string +""" +string_slice = MaxObject('string.slice') + +""" +string.split - Split a string object + +Two new string objects will be generated from the characters in the incoming string, one from the beginning up to the split point (0-indexed, but not including the split point character itself), and one from the split point to the end. + +Args: + split-point (int, optional) + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): string < of split point + 1 (OUTLET_TYPE): string >= of split point + +Messages: bang, int, float, list, anything, in1, string +""" +string_split = MaxObject('string.split') + +""" +string.sprintf - Generate a string using C-style message formatting + +Uses the common C-language "printf" function to generate strings. You can combine symbols, organize lists of numbers, or format messages or menu items. For complete documentation, refer to a standard C library reference manual. + +Args: + format (symbol, required) + +Inlets: + 0 (INLET_TYPE): string in (argument 1 in format string) + 1 (INLET_TYPE): string in (argument 2 in format string) + +Outlets: + 0 (OUTLET_TYPE): string out + +Messages: bang, int, float, list, anything, string +""" +string_sprintf = MaxObject('string.sprintf') + +""" +string.startswith - Test whether a string object starts with a substring + +Args: + comparison string (any, optional) + +Inlets: + 0 (INLET_TYPE): string in (string1) + 1 (INLET_TYPE): comparison string in (string2) + +Outlets: + 0 (OUTLET_TYPE): 1 if string1 starts with string2, 0 if not + +Messages: bang, int, float, list, anything, string +""" +string_startswith = MaxObject('string.startswith') + +""" +string.substring - Generate a new string from a range of characters in an incoming string + +string.substring is similar to string.slice, but doesn't conform to the JavaScript String.slice() behavior. + +Args: + substring-indexes (list, optional) + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): substring indices (0-based) + +Outlets: + 0 (OUTLET_TYPE): substring out + +Messages: bang, int, float, list, anything, string +""" +string_substring = MaxObject('string.substring') + +""" +string.toarray - Construct a new array object from a string object + +Construct a new array object from a string object. An optional separator string can be used to determine how the string is split into individual array entries (default = ). + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): separator string in + +Outlets: + 0 (OUTLET_TYPE): array out + +Messages: bang, int, float, list, anything, clear, string +""" +string_toarray = MaxObject('string.toarray') + +""" +string.tolist - Construct a new list from a string object + +An optional separator string can be used to determine how the string is split into individual list entries (default = ). + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): separator string in + +Outlets: + 0 (OUTLET_TYPE): list out + +Messages: bang, int, float, list, anything, clear, string +""" +string_tolist = MaxObject('string.tolist') + +""" +string.tolower - Convert uppercase characters in a string object to lowercase + +Note that this only works for ASCII letters, not for complex UTF-8 characters. + +Inlets: + 0 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): lowercase string out + +Messages: bang, int, float, list, anything, string +""" +string_tolower = MaxObject('string.tolower') + +""" +string.tosymbol - Convert a string to a symbol + +Adds a string to Max's symbol table (if not already present) and sends the symbol to the outlet. + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): symbol out + +Messages: bang, int, float, list, anything, string +""" +string_tosymbol = MaxObject('string.tosymbol') + +""" +string.toupper - Convert lowercase characters in a string object to uppercase + +Note that this only works for ASCII letters, not for complex UTF-8 characters. + +Inlets: + 0 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): uppercase string out + +Messages: bang, int, float, list, anything, string +""" +string_toupper = MaxObject('string.toupper') + +""" +string.trim - Trim whitespace from the beginning and end of a string object + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): trimmed string out + +Messages: bang, int, float, list, anything, string +""" +string_trim = MaxObject('string.trim') + +""" +string.trimend - Trim whitespace from the end of a string object + +Whitespace at the beginning of the string is ignored. Whitespace includes space, tab and newline characters. + +Inlets: + 0 (INLET_TYPE): string in + 1 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): trimmed string out + +Messages: bang, int, float, list, anything, string +""" +string_trimend = MaxObject('string.trimend') + +""" +string.trimstart - Remove whitespace from the beginning of a string object + +Whitespace includes spaces, newlines, tabs, and carriage returns. + +Inlets: + 0 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): trimmed string out + +Messages: bang, int, float, list, anything, string +""" +string_trimstart = MaxObject('string.trimstart') + +""" +string.utf8 - Iterate the UTF-8 characters in a string as integers + +Multibyte characters are output as multibyte (> 127) integers. + +Inlets: + 0 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): iterated string characters + +Messages: bang, int, float, list, anything, string +""" +string_utf8 = MaxObject('string.utf8') + +""" +string.withpass - Route a string by a matching substring + +Route a string to one of several outputs based on a substring match. Similar to routepass but for strings. This object was renamed from string.passcmp (which is now an alias to this object), the functionality remains the same. + +Args: + match substrings (list, required) + +Inlets: + 0 (INLET_TYPE): string in + +Outlets: + 0 (OUTLET_TYPE): string out if there are no matches + +Messages: bang, int, float, list, anything, string + +Attributes: match +""" +string_withpass = MaxObject('string.withpass') + +""" +stripnote - Filter out note-off messages + +Only pass note-on messages: those having any velocity above 0. + +Inlets: + 0 (INLET_TYPE): Pitch (from notein Left Outlet) + 1 (INLET_TYPE): Velocity (from notein Velocity Outlet) + +Outlets: + 0 (OUTLET_TYPE): Pitch + 1 (OUTLET_TYPE): Velocity if Note-on Message + +Messages: int, float, ft1, in1 +""" +stripnote = MaxObject('stripnote') + +""" +strippath - Separate filename from a full pathname + +Removes path information from a complete file path. strippath also tells you whether the resulting filename is in the search path or not. + +Inlets: + 0 (INLET_TYPE): Absolute Path + +Outlets: + 0 (OUTLET_TYPE): File Name + 1 (OUTLET_TYPE): 1 if Path/File in Search Path, 0 Otherwise + +Messages: anything +""" +strippath = MaxObject('strippath') + +""" +substitute - Substitute symbols within a message + +Matches messages to its own arguments; whenever it finds a match, will make the appropriate substitution. + +Args: + match (any, optional) + replacement (any, optional) + mode (any, optional) + +Inlets: + 0 (INLET_TYPE): Message For Substitution + 1 (INLET_TYPE): Change Substitution + +Outlets: + 0 (OUTLET_TYPE): Newly Substituted Message + 1 (OUTLET_TYPE): Message That Was Left Intact + +Messages: bang, int, float, list, anything, set +""" +substitute = MaxObject('substitute') + +""" +suckah - Get a pixel from the display + +Creates a click-able area that returns an RGB color, or can accept any screen coordinates to get the RGB values of that pixel. + +Inlets: + 0 (INLET_TYPE): Coordinates in + +Outlets: + 0 (OUTLET_TYPE): RGBA list Out (0. -1.) + +Messages: list, (mouse) + +Attributes: boundmode, compatibility, outputalpha +""" +suckah = MaxObject('suckah') + +""" +suspend - Reports when the application is in the background or foreground + +Outputs a 0 when the application is in the background, and a 1 when the application is in the foreground. + +Inlets: + 0 (INLET_TYPE): 1 When Application Is In Foreground, 0 When In Background + +Outlets: + 0 (OUTLET_TYPE): 1 When Application Is In Foreground, 0 When In Background +""" +suspend = MaxObject('suspend') + +""" +sustain - Hold note-off messages for release + +Holds any notes with velocities of 0 until instructed to release them. This provides for sustain pedal-like behavior when working with incoming MIDI notes. + +Inlets: + 0 (INLET_TYPE): Pitch + 1 (INLET_TYPE): Velocity + 2 (INLET_TYPE): Sustain On = 1, Off = 0 + +Outlets: + 0 (OUTLET_TYPE): Pitch + 1 (OUTLET_TYPE): Velocity + +Messages: int, float, list, clear, flush + +Attributes: repeatmode, sustain +""" +sustain = MaxObject('sustain') + +""" +swap - Swap position of two numbers + +Swaps the values of its inlets, preserving right-to-left ordering. The first outlet type is determined by its argument. The second outlet's type is always an int. + +Args: + initial (number, optional) + +Inlets: + 0 (INLET_TYPE): Sets Value for Right Outlet, Causes Output + 1 (INLET_TYPE): Sets Value for Left Outlet + +Outlets: + 0 (OUTLET_TYPE): Value From Right Inlet + 1 (OUTLET_TYPE): Value From Left Inlet + +Messages: bang, int, float, ft1, in1, list +""" +swap = MaxObject('swap') + +""" +swatch - Choose a color + +Provides 2-dimensional selection and display of colors, representing hue along the horizontal axis and lightness along the vertical axis. A third color dimension, saturation, may be set by means of the saturation message. + +Inlets: + 0 (INLET_TYPE): RGB List(0. -1.) + 1 (INLET_TYPE): Green (0. -1.) + 2 (INLET_TYPE): Blue (0. -1.) + +Outlets: + 0 (OUTLET_TYPE): RGBA Color List Out + 1 (OUTLET_TYPE): Saturation (0. -1.) + +Messages: bang, int, float, list, alpha, ft1, ft2, hsl, in1, in2, (mouse), set, sethsl + +Attributes: annotation_name, compatibility, param_connect, parameter_enable, parameter_mappable, saturation +""" +swatch = MaxObject('swatch') + +""" +switch - Accept messages from a specific inlet + +Args: + inlets (int, optional) + initial (int, optional) + +Inlets: + 0 (INLET_TYPE): 0 Turns switch Off, Non-zero Selects Input + 1 (INLET_TYPE): Switch Input 1 (Currently Closed) + 2 (INLET_TYPE): Switch Input 2 (Currently Closed) + +Outlets: + 0 (OUTLET_TYPE): Output if Open Input Receives Anything + +Messages: bang, int, float, next +""" +switch = MaxObject('switch') + +""" +sxformat - Prepare MIDI system exclusive messages + +Accepts, as arguments, a list of numbers which are sent out sequentially. In addition, you may use one or more "expr"-style statements, which start with the word "is", which will be evaluated with the result being sent out. "is" statements need to be separated by slashes. + +Args: + SysEx (list, required) + +Inlets: + 0 (INLET_TYPE): First Argument, Causes Output + +Outlets: + 0 (OUTLET_TYPE): Formatted String as a Message + +Messages: bang, int, in1, in2, in3, in4, in5, in6, in7, in8, in9, list +""" +sxformat = MaxObject('sxformat') + +""" +sysexin - Receive MIDI system exclusive messages + +Receives MIDI system exclusive messages from a MIDI input device. It takes an optional argument for port selection. If a MIDI system exclusive message is received, sysexin outputs raw MIDI as integers. + +Args: + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): port Message Sets MIDI Input Port/Device + +Outlets: + 0 (OUTLET_TYPE): System-Exclusive Messages + +Messages: anything, (mouse), (MIDI), port + +Attributes: matchport, name +""" +sysexin = MaxObject('sysexin') + +""" +tab - Tab control + +The tab can be used to create multiple button and multiple column displays and interfaces. + +Inlets: + 0 (INLET_TYPE): Messages in + +Outlets: + 0 (OUTLET_TYPE): Item Index + 1 (OUTLET_TYPE): Item Symbol + 2 (OUTLET_TYPE): Idle Item Index + +Messages: bang, int, float, (mouse), next, prev, set, setsymbol, symbol + +Attributes: activesafe, annotation_name, bgcolor, border, bordercolor, borderoncolor, button, clicktabcolor, clicktextcolor, colorselectedtext, contrastactivetab, fadetime, fadeunselect, gradient, hovertabcolor, hovertextcolor, htabcolor, htextcolor, margin, mode, multiline, param_connect, parameter_enable, parameter_mappable, rounded, segmented, spacing_x, spacing_y, style, tabcolor, tabs, textcolor, truncate, valign +""" +tab = MaxObject('tab') + +""" +tabcontroller - Define and manage patcher tabs + +The tabcontroller object is placed in a top-level patcher. When provided with a dictionary of tab names and patcher references, it will create tabs in that patcher for each dictionary entry. References in the dictionary can refer to embedded subpatchers or patcher files. When patcher files are used, they will not be loaded until you click on the tab. Moreoever, tabs can be shown in a vertically scrolling list at the left side of the patcher window. These features permit a patcher using tabcontroller to show an arbitrarily large list of patchers, making it ideal for presenting a set of related tutorials or examples. Note that RNBO or Gen subpatchers in tabs are loaded immediately when loading their parent patchers. + +Inlets: + 0 (INLET_TYPE): Control Tabs + +Messages: add, addfolder, clear, dictionary, remove, setactive, setactivefilename + +Attributes: disableinternals, exclusivemidi, folder, orientation, recursive, showroot +""" +tabcontroller = MaxObject('tabcontroller') + +""" +table - Store and edit an array of numbers + +Args: + name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): int Outputs Value at Index, list Stores Value + 1 (INLET_TYPE): Sets Y Value for Next int at Left Inlet + +Outlets: + 0 (OUTLET_TYPE): Outputs Requested Indices or Values + 1 (OUTLET_TYPE): Outputs bang When Table Window Edited + +Messages: bang, int, float, list, cancel, clear, const, (mouse), dump, flags, fquantile, getbits, goto, in1, inv, length, load, max, min, next, normal, open, prev, quantile, read, refer, send, set, setbits, sum, wclose, write + +Attributes: annotation_name, embed, name, notename, parameter_enable, parameter_mappable, range, setresizes, signed, size +""" +table = MaxObject('table') + +""" +tan - Tangent function + +Use the tan object to calculate and output the tangent of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Tan (x) + +Messages: bang, int, float +""" +tan = MaxObject('tan') + +""" +tanh - Hyperbolic tangent function + +Use the tanh object to calculate and output the hyperbolic tangent of any given number. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Input Value X + +Outlets: + 0 (OUTLET_TYPE): Tanh (x) + +Messages: bang, int, float +""" +tanh = MaxObject('tanh') + +""" +tempo - Output numbers at a metronomic tempo + +Produces metronomic output controllable in beats per minute, and with specifiable whole-note divisions. + +Args: + tempo (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Start/Stop Metronome + 1 (INLET_TYPE): Tempo in Beats Per Minute + 2 (INLET_TYPE): Beat Multiplier + 3 (INLET_TYPE): Beat Divisions of a Whole Note + +Outlets: + 0 (OUTLET_TYPE): Beat Count at Current Tempo + +Messages: bang, int, float, clock, stop, tempo +""" +tempo = MaxObject('tempo') + +""" +text - Format messages as a text file + +Collects and formats incoming messages as text to be output as lines of text. + +Args: + filename (symbol, required) + +Inlets: + 0 (INLET_TYPE): Incoming Numbers or Symbols to be Collected + +Outlets: + 0 (OUTLET_TYPE): Text Output By line Message + 1 (OUTLET_TYPE): bang When Read Completed + 2 (OUTLET_TYPE): query result (number of lines) + +Messages: int, float, list, anything, clear, cr, (mouse), dump, filetype, line, open, query, read, settitle, symbol, t_symbol, tab, wclose, write + +Attributes: precision, stringout +""" +text = MaxObject('text') + +""" +text.codebox - Display and edit text + +The dict.codebox object is a UI object for display and editing of text, optionally backed by a file on disk. Clicking on the hammer icon will output the text as a string and optionally write the file back to disk (autowrite must be enabled). Beware of losing work when enabling autowrite. It can use a syntax highlighting style (.js, .json, ,jxs, .coll, .genexpr, .lua, or .cpp) + +Inlets: + 0 (INLET_TYPE): messages in + 1 (INLET_TYPE): set string value, messages in + +Outlets: + 0 (OUTLET_TYPE): string out + 1 (OUTLET_TYPE): atoms out + 2 (OUTLET_TYPE): dumpout + +Messages: bang, int, float, list, anything, append, atoms, clear, prepend, string + +Attributes: autowatch, autowrite, bgcolor, editlocked, embed, filename, linenumbers, linenumberwidth, margin, style, syntax, textcolor, length, name +""" +text_codebox = MaxObject('text.codebox') + +""" +textbox - Display and output numbers, lists, and messages + +The number object displays and outputs either integers, floats, lists of numbers, or any message, depending on its format. flonum is a synonym for number in Float format, listbox is a synonym for number in List format, and textbox is a synonym for number in Text format. + +Inlets: + 0 (INLET_TYPE): Set Displayed Input and Repeat to Output + +Outlets: + 0 (OUTLET_TYPE): Output Incoming or Entered Values + 1 (OUTLET_TYPE): bang When Tab Key Pressed + +Messages: bang, int, float, list, anything, clear, max, min, (mouse), select, set + +Attributes: annotation_name, bgcolor, bordercolor, cantchange, format, hbgcolor, htextcolor, htricolor, maximum, minimum, mousefilter, numdecimalplaces, outputonclick, param_connect, parameter_enable, parameter_mappable, style, textcolor, triangle, tricolor, triscale +""" +textbox = MaxObject('textbox') + +""" +textbutton - Button with text + +Inlets: + 0 (INLET_TYPE): Messages in + +Outlets: + 0 (OUTLET_TYPE): Bang when Mouse Up + 1 (OUTLET_TYPE): Item Symbol + 2 (OUTLET_TYPE): Idle Mouse + +Messages: bang, int, float, (mouse), set, setsymbol, symbol + +Attributes: active, align, annotation_name, bgcolor, bgoncolor, bgovercolor, bgoveroncolor, blinktime, border, bordercolor, borderoncolor, fontlink, legacytextcolor, mode, outputmode, param_connect, parameter_enable, parameter_mappable, rounded, spacing_x, spacing_y, style, text, textcolor, texton, textoncolor, textovercolor, textoveroncolor, tosymbol, truncate, underline, usebgoncolor, usetextovercolor +""" +textbutton = MaxObject('textbutton') + +""" +textedit - Enter text + +Provides a user interface within a patcher which can collect typed-in text from the computer-keyboard. + +Inlets: + 0 (INLET_TYPE): bang Reports Text + +Outlets: + 0 (OUTLET_TYPE): Text Output + 1 (OUTLET_TYPE): ASCII Value of Character Typed + 2 (OUTLET_TYPE): Item or Character Clicked On + 3 (OUTLET_TYPE): Sends "textchanged" when Text is Changed While Typing + +Messages: bang, int, float, list, (mouse), (typing), (drag), append, clear, dictionary, select, set + +Attributes: annotation_name, autoscroll, bangmode, bgcolor, border, bordercolor, clickmode, keymode, lines, nosymquotes, outputmode, param_connect, parameter_enable, parameter_mappable, readonly, rounded, separator, style, tabmode, textcolor, valuemode, wordwrap +""" +textedit = MaxObject('textedit') + +""" +themecolor - Change and/or listen for changes in interface colors + +Output the interface color whenever it changes, query Max for current color settings, and change an interface color. + +Args: + UI element name (symbol, required) + +Inlets: + 0 (INLET_TYPE): list Sets Color, bang Reports Color + +Outlets: + 0 (list): Color Value + 1 (list): bang When Color Changes + +Messages: bang, list, anything + +Attributes: color +""" +themecolor = MaxObject('themecolor') + +""" +thisobject - Monitor and control named objects + +Use thisobject as a connection to objects by name. thisobject can be used with global named objects including max and dsp. It can also connect to objects with scripting names, including objects in other patchers using pattr paths. You can also use the name patcher for connecting to the patcher containing the thisobject, which works similarly to the thispatcher object. thisobject is similar to getattr but permits you to change the named target object using the target attribute, whereas getattr uses a patch cord to establish a connection to its target. + +Args: + target object (symbol, optional) + selected attribute (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Control Inlet, bang Reports Attribute Value + +Outlets: + 0 (OUTLET_TYPE): Attribute Value + 1 (dictionary): Response to targetattrdict + +Messages: bang, int, float, list, anything, targetattach, targetattrdict, targetbang, targetvalue + +Attributes: attr, listen, listenvalue, prefix, target +""" +thisobject = MaxObject('thisobject') + +""" +thispatcher - Send messages to a patcher + +Allows modification of a patcher window with Max messages. + +Inlets: + 0 (INLET_TYPE): Messages (write,dispose,etc.) to Send to Patcher + +Outlets: + 0 (OUTLET_TYPE): Output From window info Messages + 1 (OUTLET_TYPE): Pathname If patcher Is a File + +Messages: anything, end, savewindow, setactivetab +""" +thispatcher = MaxObject('thispatcher') + +""" +threadcheck - Report the thread of execution for a message + +Report the thread of execution for a message + +Inlets: + 0 (anything): message to check + +Outlets: + 0 (bang): message received on main thread + 1 (bang): message received on scheduler thread + 2 (bang): message received on audio thread + 3 (bang): message received on unknown thread + +Messages: bang, int, float, list, anything +""" +threadcheck = MaxObject('threadcheck') + +""" +thresh - Combine numbers, symbols and lists when received close together + +Collects items into a list if they appear within a certain specifiable amount of time. Each time an item arrives, the time is reset. + +Args: + threshold (int, optional) + threshold-time (float, optional) + +Inlets: + 0 (INLET_TYPE): Numbers to be Gathered Into list + 1 (INLET_TYPE): Arrival Threshold + +Outlets: + 0 (OUTLET_TYPE): Gathered list + +Messages: int, float, list, anything, symbol +""" +thresh = MaxObject('thresh') + +""" +timepoint - Bang at a specific time + +Outputs a bang when the clock reaches a specific time. The clock has to be moving forward in order for the bang to be output. + +Args: + time (int, symbol, float, required) + +Inlets: + 0 (INLET_TYPE): Set Target Time + +Outlets: + 0 (OUTLET_TYPE): bang When Clock Reaches Target Time + +Messages: int, float, list, anything + +Attributes: time, transport +""" +timepoint = MaxObject('timepoint') + +""" +timer - Report elapsed time between two events + +timer starts keeping time when a bang is sent to the left inlet. The right outlet can report elapsed time in milliseconds or one of the Max time format options, with the exception of notevalues. + +Inlets: + 0 (INLET_TYPE): Start of Interval to be Timed + 1 (INLET_TYPE): End of Interval to be Timed + +Outlets: + 0 (OUTLET_TYPE): Milliseconds Between bangs at Left and Right Inlets + 1 (OUTLET_TYPE): Formatted Value of Time Between bangs at Left and Right Inlets + +Messages: bang, clock + +Attributes: format, transport +""" +timer = MaxObject('timer') + +""" +times - Multiply two numbers + +Multiplies two numbers together, and outputs the result upon receiving input in the left inlet. + +Args: + initial (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Set Left Operand, Trigger the Calculation + 1 (INLET_TYPE): Set Right Operand + +Outlets: + 0 (OUTLET_TYPE): Result = Left * Right + +Messages: bang, int, float, in1, set, list +""" +times = MaxObject('times') + +""" +togedge - Report zero/non-zero transitions + +Output bangs for 0-to-1 transitions out the left outlet, and bangs the right outlet for 1-to-0 transitions. Outlets alternate output when bangs are received. + +Inlets: + 0 (INLET_TYPE): Connect to a checkbox (or bang it to toggle outs) + +Outlets: + 0 (OUTLET_TYPE): In Phase With Input + 1 (OUTLET_TYPE): Out Of Phase With Input + +Messages: bang, int +""" +togedge = MaxObject('togedge') + +""" +toggle - Switch between off and on (0 and 1) + +When clicked, toggle outputs a 0 when turned off and a 1 when turned on. When giving input, a non-zero number will turn it on, a 0 will turn it off, and a bang will alternate the state of the toggle. All numbers are converted to integer and passed through unchanged. + +Inlets: + 0 (INLET_TYPE): int Sets Toggle, bang Reverses It + +Outlets: + 0 (OUTLET_TYPE): Output 1 or 0 When Toggle Is Set + +Messages: bang, int, float, (drag), (mouse), outputvalue, read, set + +Attributes: annotation_name, bgcolor, bordercolor, checkedcolor, param_connect, parameter_enable, parameter_mappable, size, style, svg, thickness, uncheckedcolor +""" +toggle = MaxObject('toggle') + +""" +tosymbol - Convert messages, numbers, or lists to a single symbol + +tosymbol accepts any message, number, or list, and converts it into a single symbol. The symbol has a maximum length of 2048 characters. + +Inlets: + 0 (INLET_TYPE): Input to be Symbolized + +Outlets: + 0 (OUTLET_TYPE): The Input, as a Symbol + +Messages: bang, int, float, list, anything + +Attributes: separator +""" +tosymbol = MaxObject('tosymbol') + +""" +touchin - Receive MIDI aftertouch values + +Outputs from MIDI aftertouch (channel pressure) messages received from a MIDI input device. + +Args: + port-channel (list, required) + channel (int, required) + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): port Message Sets MIDI Input Port/Device + +Outlets: + 0 (OUTLET_TYPE): After Touch + 1 (OUTLET_TYPE): MIDI Channel + +Messages: anything, (mouse), (MIDI), port + +Attributes: matchport, name +""" +touchin = MaxObject('touchin') + +""" +touchout - Transmit MIDI aftertouch messages + +Transmits MIDI aftertouch values to a MIDI device. + +Args: + port-channel (list, required) + channel (int, required) + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): After Touch + 1 (INLET_TYPE): MIDI Channel + +Messages: int, float, anything, (mouse), in1, port + +Attributes: matchport, name +""" +touchout = MaxObject('touchout') + +""" +translate - Convert between different time formats + +The translate object converts from any of the fixed or relative Max time values to any other fixed or relative time value. + +Args: + input-format (symbol, optional) + output-format (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Time Value to Convert + +Outlets: + 0 (OUTLET_TYPE): Converted time value + +Messages: bang, int, float, list, anything + +Attributes: in, listen, listmode, mode, out, transport +""" +translate = MaxObject('translate') + +""" +transport - Control a clock + +Starts and stops the passage of time for objects linked to a transport. If given a name, the transport object will control a time context of the given name, otherwise it will control Max's global 'internal' transport. The transport object reports time consistent with the time formats used in Max. + +Inlets: + 0 (INLET_TYPE): Non-zero Starts Transport, Zero Stops + 1 (INLET_TYPE): Set Transport Position in Ticks + +Outlets: + 0 (OUTLET_TYPE): Bars + 1 (OUTLET_TYPE): Beats + 2 (OUTLET_TYPE): Units + 3 (OUTLET_TYPE): Current Resolution (PPQ) + 4 (OUTLET_TYPE): Tempo + 5 (OUTLET_TYPE): Time Signature (list) + 6 (OUTLET_TYPE): Transport State + 7 (OUTLET_TYPE): Raw Ticks + 8 (OUTLET_TYPE): Clocksource List + +Messages: bang, int, float, list, (mouse), dump, getclocksources, timesig + +Attributes: clocksource, name, resetbarcount, tempo +""" +transport = MaxObject('transport') + +""" +trigger - Send input to many places + +Outputs any input received in order from right to left and formatted according to the object-argument specified. + +Args: + formats (symbol, optional) + constant (any, optional) + +Inlets: + 0 (INLET_TYPE): Message to be Fanned to Multiple Outputs + +Outlets: + 0 (OUTLET_TYPE): Output Order 2 (int) + 1 (OUTLET_TYPE): Output Order 1 (int) + +Messages: bang, int, float, list, anything +""" +trigger = MaxObject('trigger') + +""" +trough - Output a number if it is less than previous numbers + +Compares an input value to the stored value and, if it's smaller it sends the input to the output and sets it as the new trough. + +Args: + value (float, optional) + +Inlets: + 0 (INLET_TYPE): Find the lowest number (the trough) + 1 (INLET_TYPE): Sets the trough + +Outlets: + 0 (OUTLET_TYPE): The lowest number so far + 1 (OUTLET_TYPE): Goes high for a new trough + 2 (OUTLET_TYPE): Goes high for a number that isn't a new trough + +Messages: bang, int, float, ft1, in1 +""" +trough = MaxObject('trough') + +""" +ubutton - Transparent button + +Creates a transparant click-able region that can be placed over graphics or other objects. Produces a bang message when clicked. + +Inlets: + 0 (INLET_TYPE): Inverts Button and Sends bang out Left Outlet + +Outlets: + 0 (OUTLET_TYPE): bang on Mouse-Up or Incoming Message + 1 (OUTLET_TYPE): bang on Mouse-Down + 2 (OUTLET_TYPE): Click Cursor Location + 3 (OUTLET_TYPE): 1 if Mouse Clicked Inside Button, 0 if Outside + +Messages: bang, int, float, anything, (mouse), set + +Attributes: annotation_name, dragtrack, hilite, hltcolor, param_connect, parameter_enable, parameter_mappable, rounded, stay, toggle +""" +ubutton = MaxObject('ubutton') + +""" +udpreceive - Receive messages over a network + +Receives messages transmitted over a network using the User Datagram Protocol (UDP). + +Args: + port (int, required) + full-packet (symbol, optional) + +Inlets: + 0 (INLET_TYPE): messages in + +Outlets: + 0 (OUTLET_TYPE): data out + +Messages: maxqueuesize, port + +Attributes: defer, outputformat, quiet +""" +udpreceive = MaxObject('udpreceive') + +""" +udpsend - Send messages over a network + +Transmits messages over a network using the User Datagram Protocol (UDP). + +Args: + host (symbol, required) + port (int, required) + +Messages: bang, int, float, list, anything, FullPacket, host, maxpacketsize, maxqueuesize, osc_packet, port, rawbytes +""" +udpsend = MaxObject('udpsend') + +""" +umenu - Pop-up menu + +Displays text as a pop-up menu. Selections can be made manually, or set incoming numbers. Outputs both selection number and selection text. + +Inlets: + 0 (INLET_TYPE): Messages in + +Outlets: + 0 (OUTLET_TYPE): Item Number Chosen + 1 (OUTLET_TYPE): Menu Item Text Evaluated as a Message + 2 (OUTLET_TYPE): Dumpout + +Messages: bang, int, float, (drag), append, checkitem, clear, clearchecks, count, delete, dictionary, dump, enableitem, gettoggle, insert, mode, (mouse), next, populate, prev, set, setcheck, setitem, setrgb, setsymbol, settoggle, showchecked, symbol, toggle + +Attributes: align, allowdrag, annotation_name, applycolors, arrow, arrowbgcolor, arrowcolor, arrowframe, arrowlink, autopopulate, bgcolor, bgcolor2, bgfillcolor, blanksym, collection, color, depth, discolor, elementcolor, framecolor, hltcolor, items, labelclick, menumode, param_connect, parameter_enable, parameter_mappable, pattrmode, prefix, prefix_mode, rounded, showdotfiles, style, textcolor, textcolor2, togcolor, truncate, types, underline +""" +umenu = MaxObject('umenu') + +""" +universal - Send messages to all objects of the same type + +Sends a input message to all instances of the same class of object in a patcher. The order in which the messages arrive is not defined. + +Args: + mode (int, optional) + +Inlets: + 0 (INLET_TYPE): Class Name and Message + +Messages: bang, int, float, list, anything, send + +Attributes: descend +""" +universal = MaxObject('universal') + +""" +unjoin - Break a list into messages + +Separates a list's elements by group, and send each group of items out a separate outlet. + +Args: + outlets (int, required) + +Inlets: + 0 (INLET_TYPE): Input + +Outlets: + 0 (OUTLET_TYPE): Output (0) + 1 (OUTLET_TYPE): Output (1) + 2 (OUTLET_TYPE): Extra + +Messages: int, float, list, anything + +Attributes: outsize +""" +unjoin = MaxObject('unjoin') + +""" +unpack - Break a list into individual messages + +Breaks a list into its elements, and sends each item out a separate outlet. + +Args: + list-elements (any, optional) + +Inlets: + 0 (INLET_TYPE): List to be Unpacked + +Outlets: + 0 (OUTLET_TYPE): Element 1 of List + 1 (OUTLET_TYPE): Element 2 of List + +Messages: bang, int, float, list, anything +""" +unpack = MaxObject('unpack') + +""" +urn - Generate random numbers without duplicates + +Outputs random numbers and keeps track of each number that has been generated. When all numbers up to the maximum (set via an argument or the right inlet) have been output, a bang is send out the right outlet. + +Args: + limit (int, optional) + seed (int, optional) + +Inlets: + 0 (INLET_TYPE): bang Generates Random Number + 1 (INLET_TYPE): Set Range of Random Numbers + +Outlets: + 0 (OUTLET_TYPE): Random Number Output + 1 (OUTLET_TYPE): bang If All Numbers in Range Chosen + +Messages: bang, int, clear, in1, seed +""" +urn = MaxObject('urn') + +""" +uzi - Send many bang messages + +Outputs a specified number of bang messages quickly. uzi is designed for rapid-fire output of a large number of bang messages. + +Args: + initial (int, optional) + base (int, optional) + +Inlets: + 0 (INLET_TYPE): Start shooting bangs (bang or int) + 1 (INLET_TYPE): How many bangs to shoot (int) + +Outlets: + 0 (OUTLET_TYPE): Watch out + 1 (OUTLET_TYPE): Done banging bang (carry) + 2 (OUTLET_TYPE): Current Index + +Messages: bang, int, break, continue, in1, offset, pause, resume +""" +uzi = MaxObject('uzi') + +""" +v8 - Execute Javascript (Modern Engine) + +Exposes the Javascript language (ECMAScript 6+) and some Max specific extensions. The v8 object can be instantiated with a javascript filename or with numerical arguments to specify the number of outlets and inlets respectively. The default number of outlets and inlets are both 1. + +Args: + filename (symbol, optional) + inlets-outlets (list, optional) + jsarguments (list, optional) + +Inlets: + 0 (INLET_TYPE): none: Inlet 0 + +Outlets: + 0 (OUTLET_TYPE): none: Outlet 0 + +Messages: bang, int, float, list, anything, array, assiststr, compile, (mouse), delprop, getprop, jsfile, loadbang, open, read, setprop, string, wclose + +Attributes: embed, parameter_enable, parameter_mappable +""" +v8 = MaxObject('v8') + +""" +v8.codebox - Execute Javascript (Modern Engine) + +Exposes the Javascript language (ECMAScript 6+) and some Max specific extensions, using a UI object for display and editing. + +Inlets: + 0 (INLET_TYPE): none: Inlet 0 + 1 (INLET_TYPE): none: Inlet 1 + +Outlets: + 0 (OUTLET_TYPE): none: Outlet 0 + +Messages: wclose, open, int, float, bang, list, anything, compile, setprop, getprop, delprop, loadbang, autowatch + +Attributes: bgcolor, linenumbers, linenumberwidth, margin, textcolor +""" +v8_codebox = MaxObject('v8.codebox') + +""" +v8ui - Javascript user interfaces and graphics (Modern Engine) + +Provides an environment to make user interface elements using Javascript (ECMAScript 6+). This provides all of the programming tools available in the v8 object, but also exposes the mgraphics and sketch drawing routines for visual output. + +Inlets: + 0 (INLET_TYPE): none: Inlet 0 + +Outlets: + 0 (OUTLET_TYPE): none: Outlet 0 + +Messages: bang, int, float, list, anything, (drag), array, assiststr, compile, (mouse), delprop, getprop, jsfile, loadbang, open, read, setprop, size, string, wclose + +Attributes: border, embed, filename, jsarguments, nofsaa, param_connect, parameter_enable, parameter_mappable +""" +v8ui = MaxObject('v8ui') + +""" +value - Share data between other value objects + +Shares data with other value objects of the same name. If you send a message (number, list, or anything else) to one value object, it is set for all value objects with the same 'name' argument. You can get the contents out of a particular value object by sending it a bang. + +Args: + name (symbol, required) + initial (any, optional) + +Inlets: + 0 (INLET_TYPE): int or float Sets Value, bang Causes Output + +Outlets: + 0 (OUTLET_TYPE): Value Shared by All value a Objects + +Messages: bang, int, float, list, anything, (mouse), symbol +""" +value = MaxObject('value') + +""" +vdp - Control a videodisk player through a serial port + +The vdp object works with serially-controlled videodisk players (remember them?) that are compatible with the Pioneer 4200 or 8000 standard. Each command received by the vdp object sends a stream of numbers out the object's left outlet, intended to be connected to the serial object. The description of each command discusses what effect the command has on the player, not the exact character stream sent by vdp. + + Because videodisc players have relatively buffer-less serial interfaces, vdp places each command it receives in a queue, and sends it out only when the player has finished executing its most recent command. This "feature" may cause a delay between the time a command is sent to the vdp object and the time it is actually sent out the serial port. + + + Any message received in the right inlet will behave exactly as if it had been received in the left inlet, except that it will be put at the front of the queue, to be the very next command sent out to the player. + +Inlets: + 0 (INLET_TYPE): Regular Priority Commands + 1 (INLET_TYPE): Handshaking from Serial Port + 2 (INLET_TYPE): High Priority Commands + +Outlets: + 0 (OUTLET_TYPE): Command Output + 1 (OUTLET_TYPE): Polling Output + 2 (OUTLET_TYPE): Frame Number + 3 (OUTLET_TYPE): Time + +Messages: int, chapter, clear, cmd, control, fps, frame, name, play, restrict, scan, search, setskip, skip, step, stop +""" +vdp = MaxObject('vdp') + +""" +vexpr - Evaluate a math expression for a list + +Performs mathematical calculations using C language-style mathematical operations. Operates on inputs that are lists rather than collections of single values. + +Args: + expression (list, required) + constant (number, required) + format (symbol, required) + table (symbol, required) + (other) (symbol, required) + +Inlets: + 0 (INLET_TYPE): Evaluate Expression, int $i1, float $f1, table $s1 + +Outlets: + 0 (OUTLET_TYPE): Expression Result + +Messages: bang, int, float, list, anything + +Attributes: maxsize, scalarmode +""" +vexpr = MaxObject('vexpr') + +""" +vstscan - Audio Plugin Scanner + +Vstscan provides an interface to audio plugin scanning so that this functionality may be presented in patchers and standalones. You can use vstscan to build menus of plugin names for use in patcher code. + +Inlets: + 0 (symbol): scan, listvst, listvst3, listau + +Outlets: + 0 (list): plug_vst/plug_vst3/plug_au <pluginname> + 1 (list): scan status (0/1) + +Messages: cancel, listau, listvst, listvst3, scan, skip +""" +vstscan = MaxObject('vstscan') + +""" +when - Report the current transport time + +Outputs the current time of a transport in ticks and bars/beats/units. + +Args: + transport (symbol, required) + +Inlets: + 0 (INLET_TYPE): bang Reports Current Transport Time + +Outlets: + 0 (OUTLET_TYPE): Time in Bars/Beats/Units + 1 (OUTLET_TYPE): Time in Ticks + +Messages: bang, int, float, list, anything + +Attributes: transport +""" +when = MaxObject('when') + +""" +xbendin - Interpret extra precision MIDI pitch bend values + +Acts as a 14-bit pitch bend filter/processor and xbendin2 serves as a 2-byte pitch bend filter/processor. + +Args: + channel (int, optional) + xbendin2 (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Raw MIDI Bytes From midiin + +Outlets: + 0 (OUTLET_TYPE): MSB of Pitch Bend + 1 (OUTLET_TYPE): LSB of Pitch Bend + +Messages: int +""" +xbendin = MaxObject('xbendin') + +""" +xbendout - Format extra precision MIDI pitch bend messages + +Formats messages which occupy both bytes of the MIDI pitch bend message. xbendout2 allows you to send the pitch bend data as two bytes from 0-127. + +Args: + xbendout2 (symbol, required) + channel (int, optional) + +Inlets: + 0 (INLET_TYPE): MSB of Pitch Bend + 1 (INLET_TYPE): LSB of Pitch Bend + +Outlets: + 0 (OUTLET_TYPE): Raw MIDI Bytes to midiout + +Messages: bang, int, in1, in2, list +""" +xbendout = MaxObject('xbendout') + +""" +xctlin - Output received 14-bit MIDI control values + +Output the value from a specific 14-bit controller pair and MIDI channel. + +Args: + ctrllr-channel (list, optional) + +Inlets: + 0 (INLET_TYPE): Raw MIDI Bytes From midiin + +Outlets: + 0 (OUTLET_TYPE): Controller Value (14-bit) + 1 (OUTLET_TYPE): Controller Number (MSB) + 2 (OUTLET_TYPE): MIDI Channel + +Messages: int, list, set + +Attributes: lsbfirst +""" +xctlin = MaxObject('xctlin') + +""" +xctlout - Format 14-bit MIDI controller messages + +Format 14-bit MIDI continuous controller messages to be transmitted using the midiout object. + +Args: + ctrllr-channel (list, optional) + +Inlets: + 0 (INLET_TYPE): Controller Value (0-16383 or list MSB LSB) + 1 (INLET_TYPE): Controller Number (MSB, 0-95) + 2 (INLET_TYPE): MIDI Channel + +Outlets: + 0 (OUTLET_TYPE): Raw MIDI Bytes to midiout + +Messages: bang, int, float, list, in1, in2 + +Attributes: lsbfirst, running +""" +xctlout = MaxObject('xctlout') + +""" +xmidiin - Output raw MIDI data + +Listens to a specified MIDI port and output the raw MIDI data received. + +Args: + port (symbol, optional) + device (symbol, optional) + +Inlets: + 0 (INLET_TYPE): port Message Sets MIDI Input Port/Device + 1 (INLET_TYPE) + +Outlets: + 0 (OUTLET_TYPE): Raw MIDI Messages + +Messages: anything, (mouse), (MIDI), lastport, port + +Attributes: matchport, name +""" +xmidiin = MaxObject('xmidiin') + +""" +xnotein - Interpret MIDI note messages with release velocity + +Args: + channel (int, optional) + +Inlets: + 0 (INLET_TYPE): Raw MIDI Bytes From midiin + +Outlets: + 0 (OUTLET_TYPE): Pitch + 1 (OUTLET_TYPE): Velocity + 2 (OUTLET_TYPE): 1 for Note-on, 0 for Note-off + 3 (OUTLET_TYPE): MIDI Channel + +Messages: int +""" +xnotein = MaxObject('xnotein') + +""" +xnoteout - Format MIDI note messages with release velocity + +Args: + channel (int, optional) + +Inlets: + 0 (INLET_TYPE): Pitch + 1 (INLET_TYPE): Velocity + 2 (INLET_TYPE): 1 for Note-on, 0 for Note-off + 3 (INLET_TYPE): MIDI Channel + +Outlets: + 0 (OUTLET_TYPE): Raw MIDI Bytes to midiout + +Messages: bang, int, list, in1, in2, in3 +""" +xnoteout = MaxObject('xnoteout') + +""" +zl - Process lists in many ways + +Performs several kinds of list processing functions. You set the function with an argument, and can change the function performed with the mode message. The behavior of the zl object's inlets and outlets vary according to the selected mode. + +Args: + mode (symbol, required) + length (int, optional) + function-int (int, optional) + function-list (list, optional) + +Inlets: + 0 (inactive): (inactive) + 1 (inactive): (inactive) + +Outlets: + 0 (inactive): (inactive) + 1 (inactive): (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl = MaxObject('zl') + +""" +zl.change - Filter out list repetitions + +Args: + initial-list (list, optional) + +Inlets: + 0 (anything): list input + 1 (anything): set input list (without triggering) + +Outlets: + 0 (anything): output list if it changed + 1 (int): 1 if the list changed, 0 otherwise + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_change = MaxObject('zl.change') + +""" +zl.compare - Compare two lists + +Args: + initial-list (list, optional) + +Inlets: + 0 (anything): left list input + 1 (anything): right list input + +Outlets: + 0 (int): 1 when lists are equals, 0 otherwise + 1 (int/list): index(es) of the non equal item(s) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_compare = MaxObject('zl.compare') + +""" +zl.delace - De-interleave a list + +Splits the input list into two lists consisting of every other item. The left outlet will start with the first element, and the right outlet will start with the second element. If the input list is 6.2 3 5.6 5.3 3.8 2.4 the left output list is 6.2 5.6 3.8 and the right output list is 3 5.3 2.4). + +Inlets: + 0 (anything): list input + 1 (inactive) + +Outlets: + 0 (anything): deinterlaced left list + 1 (anything): deinterlaced right list + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_delace = MaxObject('zl.delace') + +""" +zl.ecils - Slice a list in reverse order + +Slices a list in reverse order: output last N out right outlet, the rest out the left. The right outlet is output first. + +Args: + size (int, optional) + +Inlets: + 0 (anything): list to split into two slices + 1 (int): size of right slice + +Outlets: + 0 (list): left slice of input list + 1 (list): right slice of input list + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_ecils = MaxObject('zl.ecils') + +""" +zl.filter - Remove items in a list + +Args: + filter (list, optional) + +Inlets: + 0 (anything): items to filter + 1 (anything): filtering items + +Outlets: + 0 (anything): filtered items + 1 (list): indexes of filtered items + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_filter = MaxObject('zl.filter') + +""" +zl.group - Store and output a list + +Output a list after the number of items specified by the maximum output length are received. + +Args: + initial-size (int, optional) + +Inlets: + 0 (anything): items to collect into a list + 1 (int): maximum output list length + +Outlets: + 0 (list): collected items as list + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_group = MaxObject('zl.group') + +""" +zl.indexmap - Create new list from list of indexes + +Creates a new list based on indices of an incoming list (0-based). + +Args: + initial-index (list, optional) + +Inlets: + 0 (anything): list input + 1 (anything): indices list + +Outlets: + 0 (anything): output list + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_indexmap = MaxObject('zl.indexmap') + +""" +zl.iter - Successively output lists of specific size + +Outputs lists of specific sizes successively. The final list output may be shorter than the number, depending on the stored contents of the object. + +Args: + initial-size (int, optional) + +Inlets: + 0 (anything): list to output in chunks + 1 (int): maximum size of output chunk + +Outlets: + 0 (list): input list as consecutive chunks + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_iter = MaxObject('zl.iter') + +""" +zl.join - Combine two lists + +Combines two lists and outputs a single list. + +Args: + initial-list (list, optional) + +Inlets: + 0 (anything): first segment of list + 1 (anything): second segment of list + +Outlets: + 0 (list): both segments joined as one list + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_join = MaxObject('zl.join') + +""" +zl.lace - Interleave two lists + +Interleaves two lists. If the left input list is 6.2 5.6 3.8 and the right input list is 3 5.3 2.4 the output list is 6.2 3 5.6 5.3 3.8 2.4 + +Args: + initial-list (list, optional) + +Inlets: + 0 (anything): left list input + 1 (anything): right list input + +Outlets: + 0 (anything): interlaced list + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_lace = MaxObject('zl.lace') + +""" +zl.len - Get list length + +Inlets: + 0 (anything): list to test + 1 (inactive) + +Outlets: + 0 (int): length of list + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_len = MaxObject('zl.len') + +""" +zl.lookup - Output elements of a list + +Outputs the elements of an input list. Element indexing begins at 0. + +Args: + initial-list (list, optional) + +Inlets: + 0 (int/list): position (start at 0) in list to extract + 1 (anything): list from which to extract element + +Outlets: + 0 (anything): extracted element(s) of list + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_lookup = MaxObject('zl.lookup') + +""" +zl.median - Get the median value of a list of numbers + +Inlets: + 0 (list): list of numbers + 1 (inactive) + +Outlets: + 0 (int/float): median value of the list + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_median = MaxObject('zl.median') + +""" +zl.mth - Extract item from list + +Extract an item from an incoming list, based on the index specified (zero-based). + +Args: + initial-index (int, optional) + index-sub (list, optional) + +Inlets: + 0 (anything): list from which to extract mth element + 1 (int): position in list to extract + +Outlets: + 0 (anything): mth element of list + 1 (list): source list with mth element removed + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_mth = MaxObject('zl.mth') + +""" +zl.nth - Extract item from list + +Extract an item from an incoming list, based on the index specified (starting at 1). + +Args: + initial-index (int, optional) + index-sub (list, optional) + +Inlets: + 0 (anything): list from which to extract nth element + 1 (int): position in list to extract + +Outlets: + 0 (anything): nth element of list + 1 (list): source list with nth element removed + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_nth = MaxObject('zl.nth') + +""" +zl.queue - Output elements of a list in the order they are received + +Functions as a first-in-first-out (FIFO) stack. Each bang outputs the oldest message received and removes it from the list. + +Inlets: + 0 (anything): items to add to queue + 1 (inactive) + +Outlets: + 0 (anything): FIFO items on bang + 1 (int): number of items in queue + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_queue = MaxObject('zl.queue') + +""" +zl.reg - Store and output a list + +zl.reg functions as a register that holds a list. A list received in the left inlet is sent out the left outlet immediately. A list received in the right inlet is stored. A bang sends the stored list out the left outlet. + +Args: + initial-list (list, optional) + +Inlets: + 0 (anything): list to store and output immediately + 1 (anything): list to store + +Outlets: + 0 (list): stored list + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_reg = MaxObject('zl.reg') + +""" +zl.rev - Reverse a list + +Inlets: + 0 (anything): list to reverse + 1 (inactive) + +Outlets: + 0 (list): input list in reverse order + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_rev = MaxObject('zl.rev') + +""" +zl.rot - Rotate a list + +zl.rot is used to rotate the contents of a list. An argument is used to specify the number of places a list item is to be rotated - positive numbers rotate the list to the right, and negative numbers rotate left. This value can also be specified as an int input in the right inlet. + +Args: + distance (int, optional) + +Inlets: + 0 (anything): list to rotate + 1 (int): rotate distance (positive=right, negative=left) + +Outlets: + 0 (list): rotated input list + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_rot = MaxObject('zl.rot') + +""" +zl.scramble - Scramble a list + +zl.scramble accepts a list in either inlet. A list in the left inlet will cause the object to immediately output a scrambled version of the input-list (a list containing the same elements as the input-list but in a randomized order). A list in the right inlet will set the input-list without causing output (a subsequent bang received in the left inlet will cause a randomized version of the right-input list to be sent out the object's left outlet). On receiving a bang or list in the left inlet, a list of the reordered indexes will be sent out the objects' right outlet. + +Args: + initial-list (list, optional) + +Inlets: + 0 (anything): items to scramble + 1 (anything): set items to scramble + +Outlets: + 0 (anything): scrambled items + 1 (list): reordered indexes list + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_scramble = MaxObject('zl.scramble') + +""" +zl.sect - Find common items between two lists + +zl.sect accepts a list in both inlets and sends a list out the left outlet that contains the elements that are common to both lists. + +Args: + initial-list (list, required) + +Inlets: + 0 (anything): first list to intersect + 1 (anything): second list to intersect + +Outlets: + 0 (list): list of items in common between both input lists + 1 (bang): bang if nothing is common between both input lists + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_sect = MaxObject('zl.sect') + +""" +zl.slice - Slice a list in two + +zl.slice is used to divide a list into two lists. This mode takes a number argument which specifies the size, in elements, of a list. This value can also be specified as an int to the right inlet. A list received in the left inlet will be split into two lists - the first list contains the number of items specified by the argument, and is sent out the left outlet. Any remaining list elements are sent out the right outlet of the object. Note: Lists are sent out the right outlet first. + +Args: + initial-size (int, optional) + +Inlets: + 0 (anything): list to split into two slices + 1 (int): size of left slice + +Outlets: + 0 (list): left slice of input list + 1 (list): right slice of input list + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_slice = MaxObject('zl.slice') + +""" +zl.sort - Arrange a list in alphanumeric order + +zl.sort is used to sort the contents of a list. An argument is used to specify the sorting order. An int of -1 sorts the input list in descending order, and any other value sorts the input list in ascending order. This value can also be specified as an input in the right inlet. + +Args: + order (int, optional) + +Inlets: + 0 (anything): list to sort + 1 (int): sort direction + +Outlets: + 0 (anything): sorted list + 1 (list): reordered indexes list + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_sort = MaxObject('zl.sort') + +""" +zl.stack - Output elements of a list in reverse order + +zl.stack functions as a last-in-first-out (LIFO) stack; a bang outputs the most recently received message and removes it from the currently held list. + +Inlets: + 0 (anything): items to push onto stack + 1 (inactive) + +Outlets: + 0 (anything): items popped from stack + 1 (int): number of items in stack + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_stack = MaxObject('zl.stack') + +""" +zl.stream - Make a list of a certain size + +zl.stream accepts a number in the right inlet which specifies the length of the output list. Following the receipt of this number, the object will collect this number of items input through the left inlet. After the list-length is complete, and with each subsequent input, the list will be output the left outlet. A 1 or a 0 will be output from the right outlet depending on whether the list-length has been reached or not. A 1 signifies that the list-length has been reached and that the object is now collecting the stream. Use the zlclear message to reset the list. + +Args: + initial-length (int, required) + +Inlets: + 0 (anything): item to collect + 1 (int): defines output list length + +Outlets: + 0 (anything): last 256 elements + 1 (int): 1 if the 256 elements are defined + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_stream = MaxObject('zl.stream') + +""" +zl.sub - Output position for each occurance of right list in left + +zl.sub accepts a list in both inlets and sends the output position (starting at 1) for each occurrence of right list in the left list out the left outlet. + +Args: + initial-list (list, required) + +Inlets: + 0 (anything): list to search for sub-list + 1 (anything): sub-list to find + +Outlets: + 0 (int): position of sub-list matches (if any) + 1 (int): number of sub-list matches (0 if none) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_sub = MaxObject('zl.sub') + +""" +zl.sum - Sum a list of numbers + +Returns the sum of a list of numbers. + +Inlets: + 0 (list): list of numbers + 1 (inactive) + +Outlets: + 0 (int/float): sum of the list + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_sum = MaxObject('zl.sum') + +""" +zl.swap - Swap two list indexes + +zl.swap accepts a list as an argument. A list of two numbers (0-based) in the right inlet will indicate a pair of indices to swap in the list received in the left inlet. For instance, if 1 3 is received in the right inlet, A B C D received in the left inlet will cause the object to output A D C B from the left output. + +Args: + initial-swap (list, required) + +Inlets: + 0 (anything): list input + 1 (anything): indices to swap + +Outlets: + 0 (anything): output list + 1 (list): reordered indices list + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_swap = MaxObject('zl.swap') + +""" +zl.thin - Remove duplicates from list + +Removes all of the elements of the input list which are duplicates and outputs a new list. + +Inlets: + 0 (anything): list input + 1 (inactive) + +Outlets: + 0 (anything): output list with no duplicate + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_thin = MaxObject('zl.thin') + +""" +zl.union - Combine two lists without duplicating shared items + +zl.union accepts a list in both inlets and sends a list out the left outlet that contains the contents of both input lists. The output does not duplicate items in the right list that are in the left list. + +Args: + initial-list (list, required) + +Inlets: + 0 (anything): first list to union + 1 (anything): second list to union + +Outlets: + 0 (list): all items in both input lists, no duplicates + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_union = MaxObject('zl.union') + +""" +zl.unique - Remove items from a list + +zl.unique removes any items found in the left input that are present in the right input and outputs a new list. + +Args: + initial-list (list, required) + +Inlets: + 0 (anything): left list input + 1 (anything): right list input + +Outlets: + 0 (anything): list of items in the left list which are not in the right list + 1 (inactive) + +Messages: bang, int, float, list, anything, mode, zlclear, zlreset + +Attributes: fuzzy, zlmaxsize +""" +zl_unique = MaxObject('zl.unique') + +""" +zmap - Maps input range of values to output range + +Maps an input range of values and to an output range of values. Similar to scale, but clips values to the ranges, and does not allow inverted scaling. + +Args: + minimum-input (number, required) + maximum-input (number, required) + minimum-output (number, required) + maximum-output (number, required) + +Inlets: + 0 (INLET_TYPE): Input to be scaled + 1 (INLET_TYPE): Input Minimum + 2 (INLET_TYPE): Input Maximum + 3 (INLET_TYPE): Output Minimum + 4 (INLET_TYPE): Output Maximum + +Outlets: + 0 (OUTLET_TYPE): Scaled Output + +Messages: bang, int, float, list, ft1, ft2, ft3, ft4 +""" +zmap = MaxObject('zmap') + +_sys.stdout = _old_stdout +_devnull.close() +del _devnull, _old_stdout diff --git a/maxpylang/objects/msp.py b/maxpylang/objects/msp.py new file mode 100644 index 0000000..03a2feb --- /dev/null +++ b/maxpylang/objects/msp.py @@ -0,0 +1,10038 @@ +"""MaxObject stubs for msp objects. Auto-generated by import_objs().""" +import os as _os +import sys as _sys +from maxpylang.maxobject import MaxObject + +__all__ = [ + '_2d_wave_tilde', + 'abs_tilde', + 'acos_tilde', + 'acosh_tilde', + 'adc_tilde', + 'adoutput_tilde', + 'adsr_tilde', + 'adstatus', + 'allpass_tilde', + 'amxd_tilde', + 'asin_tilde', + 'asinh_tilde', + 'atan2_tilde', + 'atan_tilde', + 'atanh_tilde', + 'atodb_tilde', + 'average_tilde', + 'avg_tilde', + 'begin_tilde', + 'biquad_tilde', + 'bitand_tilde', + 'bitnot_tilde', + 'bitor_tilde', + 'bitsafe_tilde', + 'bitshift_tilde', + 'bitxor_tilde', + 'buffer_tilde', + 'buffir_tilde', + 'capture_tilde', + 'cartopol_tilde', + 'cascade_tilde', + 'change_tilde', + 'click_tilde', + 'clip_tilde', + 'comb_tilde', + 'cos_tilde', + 'cosh_tilde', + 'cosx_tilde', + 'count_tilde', + 'cross_tilde', + 'curve_tilde', + 'cycle_tilde', + 'dac_tilde', + 'dbtoa_tilde', + 'degrade_tilde', + 'delay_tilde', + 'delta_tilde', + 'deltaclip_tilde', + 'div_tilde', + 'downsamp_tilde', + 'dspstate_tilde', + 'dsptime_tilde', + 'edge_tilde', + 'equals_tilde', + 'ezadc_tilde', + 'ezdac_tilde', + 'fbinshift_tilde', + 'fffb_tilde', + 'fft_tilde', + 'fftin_tilde', + 'fftinfo_tilde', + 'fftout_tilde', + 'filtercoeff_tilde', + 'filterdesign', + 'filterdetail', + 'filtergraph_tilde', + 'frame_tilde', + 'frameaccum_tilde', + 'frameaverage_tilde', + 'framedelta_tilde', + 'framesmooth_tilde', + 'framesnap_tilde', + 'freqshift_tilde', + 'ftom_tilde', + 'fzero_tilde', + 'gain_tilde', + 'gate_tilde', + 'gen', + 'gen_codebox', + 'gen_codebox_tilde', + 'gen_tilde', + 'gizmo_tilde', + 'greaterthan_tilde', + 'greaterthaneq_tilde', + 'gridmeter_tilde', + 'groove_tilde', + 'hilbert_tilde', + 'ifft_tilde', + 'in_', + 'in_tilde', + 'index_tilde', + 'info_tilde', + 'ioscbank_tilde', + 'kink_tilde', + 'lessthan_tilde', + 'lessthaneq_tilde', + 'levelmeter_tilde', + 'limi_tilde', + 'line_tilde', + 'log_tilde', + 'lookup_tilde', + 'lores_tilde', + 'loudness_tilde', + 'matrix_tilde', + 'maximum_tilde', + 'mc_2d_wave_tilde', + 'mc_abs_tilde', + 'mc_acos_tilde', + 'mc_acosh_tilde', + 'mc_adc_tilde', + 'mc_adsr_tilde', + 'mc_allpass_tilde', + 'mc_amxd_tilde', + 'mc_apply_tilde', + 'mc_asin_tilde', + 'mc_asinh_tilde', + 'mc_assign', + 'mc_atan2_tilde', + 'mc_atan_tilde', + 'mc_atanh_tilde', + 'mc_atodb_tilde', + 'mc_average_tilde', + 'mc_avg_tilde', + 'mc_bands_tilde', + 'mc_biquad_tilde', + 'mc_bitand_tilde', + 'mc_bitnot_tilde', + 'mc_bitor_tilde', + 'mc_bitsafe_tilde', + 'mc_bitshift_tilde', + 'mc_bitxor_tilde', + 'mc_buffir_tilde', + 'mc_cartopol_tilde', + 'mc_cascade_tilde', + 'mc_cell', + 'mc_change_tilde', + 'mc_channelcount_tilde', + 'mc_chord_tilde', + 'mc_click_tilde', + 'mc_clip_tilde', + 'mc_comb_tilde', + 'mc_combine_tilde', + 'mc_cos_tilde', + 'mc_cosh_tilde', + 'mc_cosx_tilde', + 'mc_count_tilde', + 'mc_cross_tilde', + 'mc_curve_tilde', + 'mc_cycle_tilde', + 'mc_dac_tilde', + 'mc_dbtoa_tilde', + 'mc_degrade_tilde', + 'mc_deinterleave_tilde', + 'mc_delay_tilde', + 'mc_delta_tilde', + 'mc_deltaclip_tilde', + 'mc_div_tilde', + 'mc_downsamp_tilde', + 'mc_dup_tilde', + 'mc_edge_tilde', + 'mc_equals_tilde', + 'mc_evolve_tilde', + 'mc_ezadc_tilde', + 'mc_ezdac_tilde', + 'mc_fffb_tilde', + 'mc_fft_tilde', + 'mc_filtercoeff_tilde', + 'mc_frameaccum_tilde', + 'mc_frameaverage_tilde', + 'mc_framedelta_tilde', + 'mc_framesmooth_tilde', + 'mc_freqshift_tilde', + 'mc_ftom_tilde', + 'mc_fzero_tilde', + 'mc_gain_tilde', + 'mc_gate_tilde', + 'mc_gen', + 'mc_gen_tilde', + 'mc_generate_tilde', + 'mc_gradient_tilde', + 'mc_greaterthan_tilde', + 'mc_greaterthaneq_tilde', + 'mc_groove_tilde', + 'mc_hilbert_tilde', + 'mc_ifft_tilde', + 'mc_in_tilde', + 'mc_index_tilde', + 'mc_interleave_tilde', + 'mc_kink_tilde', + 'mc_lessthan_tilde', + 'mc_lessthaneq_tilde', + 'mc_limi_tilde', + 'mc_line_tilde', + 'mc_list_tilde', + 'mc_log_tilde', + 'mc_lookup_tilde', + 'mc_lores_tilde', + 'mc_loudness_tilde', + 'mc_makelist', + 'mc_matrix_tilde', + 'mc_maximum_tilde', + 'mc_midiplayer_tilde', + 'mc_miditarget', + 'mc_minimum_tilde', + 'mc_minmax_tilde', + 'mc_minus_tilde', + 'mc_mixdown_tilde', + 'mc_modulo_tilde', + 'mc_mstosamps_tilde', + 'mc_mtof_tilde', + 'mc_noise_tilde', + 'mc_normalize_tilde', + 'mc_noteallocator_tilde', + 'mc_notequals_tilde', + 'mc_number_tilde', + 'mc_omx_4band_tilde', + 'mc_omx_5band_tilde', + 'mc_omx_comp_tilde', + 'mc_omx_peaklim_tilde', + 'mc_onepole_tilde', + 'mc_op_tilde', + 'mc_out_tilde', + 'mc_overdrive_tilde', + 'mc_pack_tilde', + 'mc_pattern_tilde', + 'mc_peakamp_tilde', + 'mc_peek_tilde', + 'mc_pfft_tilde', + 'mc_phasegroove_tilde', + 'mc_phaseshift_tilde', + 'mc_phasewrap_tilde', + 'mc_phasor_tilde', + 'mc_pink_tilde', + 'mc_pitchshift_tilde', + 'mc_play_tilde', + 'mc_playlist_tilde', + 'mc_plus_tilde', + 'mc_plusequals_tilde', + 'mc_poltocar_tilde', + 'mc_poly_tilde', + 'mc_pong_tilde', + 'mc_pow_tilde', + 'mc_ramp_tilde', + 'mc_rampsmooth_tilde', + 'mc_rand_tilde', + 'mc_range_tilde', + 'mc_rate_tilde', + 'mc_rdiv_tilde', + 'mc_receive_tilde', + 'mc_record_tilde', + 'mc_rect_tilde', + 'mc_resize_tilde', + 'mc_reson_tilde', + 'mc_retune_tilde', + 'mc_rminus_tilde', + 'mc_round_tilde', + 'mc_route', + 'mc_sah_tilde', + 'mc_sampstoms_tilde', + 'mc_sash_tilde', + 'mc_saw_tilde', + 'mc_scale_tilde', + 'mc_selector_tilde', + 'mc_send_tilde', + 'mc_separate_tilde', + 'mc_seq_tilde', + 'mc_sfizz_tilde', + 'mc_sfplay_tilde', + 'mc_sfrecord_tilde', + 'mc_shape_tilde', + 'mc_sig_tilde', + 'mc_sinh_tilde', + 'mc_sinx_tilde', + 'mc_slide_tilde', + 'mc_snapshot_tilde', + 'mc_snowfall_tilde', + 'mc_snowphasor_tilde', + 'mc_spike_tilde', + 'mc_sqrt_tilde', + 'mc_stash_tilde', + 'mc_stepdiv_tilde', + 'mc_stepfun_tilde', + 'mc_stereo_tilde', + 'mc_stutter_tilde', + 'mc_subdiv_tilde', + 'mc_svf_tilde', + 'mc_swing_tilde', + 'mc_sync_tilde', + 'mc_table_tilde', + 'mc_tanh_tilde', + 'mc_tanx_tilde', + 'mc_tapin_tilde', + 'mc_tapout_tilde', + 'mc_target', + 'mc_targetlist', + 'mc_teeth_tilde', + 'mc_thresh_tilde', + 'mc_times_tilde', + 'mc_train_tilde', + 'mc_transpose_tilde', + 'mc_trapezoid_tilde', + 'mc_tri_tilde', + 'mc_triangle_tilde', + 'mc_trunc_tilde', + 'mc_twist_tilde', + 'mc_unpack_tilde', + 'mc_updown_tilde', + 'mc_vectral_tilde', + 'mc_voiceallocator_tilde', + 'mc_vst_tilde', + 'mc_wave_tilde', + 'mc_what_tilde', + 'mc_where_tilde', + 'mc_zerox_tilde', + 'mc_zigzag_tilde', + 'mcs_2d_wave_tilde', + 'mcs_amxd_tilde', + 'mcs_fffb_tilde', + 'mcs_gate_tilde', + 'mcs_gen_tilde', + 'mcs_groove_tilde', + 'mcs_limi_tilde', + 'mcs_matrix_tilde', + 'mcs_play_tilde', + 'mcs_poly_tilde', + 'mcs_selector_tilde', + 'mcs_sig_tilde', + 'mcs_tapout_tilde', + 'mcs_vst_tilde', + 'mcs_wave_tilde', + 'meter_tilde', + 'minimum_tilde', + 'minmax_tilde', + 'minus_tilde', + 'modulo_tilde', + 'mstosamps_tilde', + 'mtof_tilde', + 'mute_tilde', + 'mxj_tilde', + 'noise_tilde', + 'normalize_tilde', + 'notequals_tilde', + 'number_tilde', + 'omx_4band_tilde', + 'omx_5band_tilde', + 'omx_comp_tilde', + 'omx_peaklim_tilde', + 'onepole_tilde', + 'oscbank_tilde', + 'out', + 'out_tilde', + 'overdrive_tilde', + 'pass_tilde', + 'peakamp_tilde', + 'peek_tilde', + 'pfft_tilde', + 'phasegroove_tilde', + 'phaseshift_tilde', + 'phasewrap_tilde', + 'phasor_tilde', + 'pink_tilde', + 'pitchshift_tilde', + 'play_tilde', + 'playlist_tilde', + 'plot_tilde', + 'plugin_tilde', + 'plugout_tilde', + 'plugphasor_tilde', + 'plugreceive_tilde', + 'plugsend_tilde', + 'plugsync_tilde', + 'plus_tilde', + 'plusequals_tilde', + 'poke_tilde', + 'poltocar_tilde', + 'poly_tilde', + 'polybuffer_tilde', + 'pong_tilde', + 'pow_tilde', + 'ramp_tilde', + 'rampsmooth_tilde', + 'rand_tilde', + 'rate_tilde', + 'rdiv_tilde', + 'receive_tilde', + 'record_tilde', + 'rect_tilde', + 'reson_tilde', + 'retune_tilde', + 'rminus_tilde', + 'round_tilde', + 'sah_tilde', + 'sampstoms_tilde', + 'sash_tilde', + 'saw_tilde', + 'scale_tilde', + 'scope_tilde', + 'selector_tilde', + 'send_tilde', + 'seq_tilde', + 'sfinfo_tilde', + 'sfizz_tilde', + 'sflist_tilde', + 'sfplay_tilde', + 'sfrecord_tilde', + 'shape_tilde', + 'sig_tilde', + 'sinh_tilde', + 'sinx_tilde', + 'slide_tilde', + 'snapshot_tilde', + 'snowfall_tilde', + 'spectroscope_tilde', + 'spike_tilde', + 'sqrt_tilde', + 'stash_tilde', + 'stepcounter_tilde', + 'stepdiv_tilde', + 'stepfun_tilde', + 'stretch_tilde', + 'stutter_tilde', + 'subdiv_tilde', + 'svf_tilde', + 'swing_tilde', + 'sync_tilde', + 'table_tilde', + 'tanh_tilde', + 'tanx_tilde', + 'tapin_tilde', + 'tapout_tilde', + 'techno_tilde', + 'teeth_tilde', + 'thispoly_tilde', + 'thresh_tilde', + 'times_tilde', + 'train_tilde', + 'trapezoid_tilde', + 'tri_tilde', + 'triangle_tilde', + 'trunc_tilde', + 'twist_tilde', + 'typeroute_tilde', + 'updown_tilde', + 'vectral_tilde', + 'vst_tilde', + 'wave_tilde', + 'waveform_tilde', + 'what_tilde', + 'where_tilde', + 'windowed_fft_tilde', + 'zerox_tilde', + 'zigzag_tilde', + 'zplane_tilde', +] + +_NAMES = { + '_2d_wave_tilde': '2d.wave~', + 'abs_tilde': 'abs~', + 'acos_tilde': 'acos~', + 'acosh_tilde': 'acosh~', + 'adc_tilde': 'adc~', + 'adoutput_tilde': 'adoutput~', + 'adsr_tilde': 'adsr~', + 'adstatus': 'adstatus', + 'allpass_tilde': 'allpass~', + 'amxd_tilde': 'amxd~', + 'asin_tilde': 'asin~', + 'asinh_tilde': 'asinh~', + 'atan2_tilde': 'atan2~', + 'atan_tilde': 'atan~', + 'atanh_tilde': 'atanh~', + 'atodb_tilde': 'atodb~', + 'average_tilde': 'average~', + 'avg_tilde': 'avg~', + 'begin_tilde': 'begin~', + 'biquad_tilde': 'biquad~', + 'bitand_tilde': 'bitand~', + 'bitnot_tilde': 'bitnot~', + 'bitor_tilde': 'bitor~', + 'bitsafe_tilde': 'bitsafe~', + 'bitshift_tilde': 'bitshift~', + 'bitxor_tilde': 'bitxor~', + 'buffer_tilde': 'buffer~', + 'buffir_tilde': 'buffir~', + 'capture_tilde': 'capture~', + 'cartopol_tilde': 'cartopol~', + 'cascade_tilde': 'cascade~', + 'change_tilde': 'change~', + 'click_tilde': 'click~', + 'clip_tilde': 'clip~', + 'comb_tilde': 'comb~', + 'cos_tilde': 'cos~', + 'cosh_tilde': 'cosh~', + 'cosx_tilde': 'cosx~', + 'count_tilde': 'count~', + 'cross_tilde': 'cross~', + 'curve_tilde': 'curve~', + 'cycle_tilde': 'cycle~', + 'dac_tilde': 'dac~', + 'dbtoa_tilde': 'dbtoa~', + 'degrade_tilde': 'degrade~', + 'delay_tilde': 'delay~', + 'delta_tilde': 'delta~', + 'deltaclip_tilde': 'deltaclip~', + 'div_tilde': 'div~', + 'downsamp_tilde': 'downsamp~', + 'dspstate_tilde': 'dspstate~', + 'dsptime_tilde': 'dsptime~', + 'edge_tilde': 'edge~', + 'equals_tilde': 'equals~', + 'ezadc_tilde': 'ezadc~', + 'ezdac_tilde': 'ezdac~', + 'fbinshift_tilde': 'fbinshift~', + 'fffb_tilde': 'fffb~', + 'fft_tilde': 'fft~', + 'fftin_tilde': 'fftin~', + 'fftinfo_tilde': 'fftinfo~', + 'fftout_tilde': 'fftout~', + 'filtercoeff_tilde': 'filtercoeff~', + 'filterdesign': 'filterdesign', + 'filterdetail': 'filterdetail', + 'filtergraph_tilde': 'filtergraph~', + 'frame_tilde': 'frame~', + 'frameaccum_tilde': 'frameaccum~', + 'frameaverage_tilde': 'frameaverage~', + 'framedelta_tilde': 'framedelta~', + 'framesmooth_tilde': 'framesmooth~', + 'framesnap_tilde': 'framesnap~', + 'freqshift_tilde': 'freqshift~', + 'ftom_tilde': 'ftom~', + 'fzero_tilde': 'fzero~', + 'gain_tilde': 'gain~', + 'gate_tilde': 'gate~', + 'gen': 'gen', + 'gen_codebox': 'gen.codebox', + 'gen_codebox_tilde': 'gen.codebox~', + 'gen_tilde': 'gen~', + 'gizmo_tilde': 'gizmo~', + 'greaterthan_tilde': 'greaterthan~', + 'greaterthaneq_tilde': 'greaterthaneq~', + 'gridmeter_tilde': 'gridmeter~', + 'groove_tilde': 'groove~', + 'hilbert_tilde': 'hilbert~', + 'ifft_tilde': 'ifft~', + 'in_': 'in', + 'in_tilde': 'in~', + 'index_tilde': 'index~', + 'info_tilde': 'info~', + 'ioscbank_tilde': 'ioscbank~', + 'kink_tilde': 'kink~', + 'lessthan_tilde': 'lessthan~', + 'lessthaneq_tilde': 'lessthaneq~', + 'levelmeter_tilde': 'levelmeter~', + 'limi_tilde': 'limi~', + 'line_tilde': 'line~', + 'log_tilde': 'log~', + 'lookup_tilde': 'lookup~', + 'lores_tilde': 'lores~', + 'loudness_tilde': 'loudness~', + 'matrix_tilde': 'matrix~', + 'maximum_tilde': 'maximum~', + 'mc_2d_wave_tilde': 'mc.2d.wave~', + 'mc_abs_tilde': 'mc.abs~', + 'mc_acos_tilde': 'mc.acos~', + 'mc_acosh_tilde': 'mc.acosh~', + 'mc_adc_tilde': 'mc.adc~', + 'mc_adsr_tilde': 'mc.adsr~', + 'mc_allpass_tilde': 'mc.allpass~', + 'mc_amxd_tilde': 'mc.amxd~', + 'mc_apply_tilde': 'mc.apply~', + 'mc_asin_tilde': 'mc.asin~', + 'mc_asinh_tilde': 'mc.asinh~', + 'mc_assign': 'mc.assign', + 'mc_atan2_tilde': 'mc.atan2~', + 'mc_atan_tilde': 'mc.atan~', + 'mc_atanh_tilde': 'mc.atanh~', + 'mc_atodb_tilde': 'mc.atodb~', + 'mc_average_tilde': 'mc.average~', + 'mc_avg_tilde': 'mc.avg~', + 'mc_bands_tilde': 'mc.bands~', + 'mc_biquad_tilde': 'mc.biquad~', + 'mc_bitand_tilde': 'mc.bitand~', + 'mc_bitnot_tilde': 'mc.bitnot~', + 'mc_bitor_tilde': 'mc.bitor~', + 'mc_bitsafe_tilde': 'mc.bitsafe~', + 'mc_bitshift_tilde': 'mc.bitshift~', + 'mc_bitxor_tilde': 'mc.bitxor~', + 'mc_buffir_tilde': 'mc.buffir~', + 'mc_cartopol_tilde': 'mc.cartopol~', + 'mc_cascade_tilde': 'mc.cascade~', + 'mc_cell': 'mc.cell', + 'mc_change_tilde': 'mc.change~', + 'mc_channelcount_tilde': 'mc.channelcount~', + 'mc_chord_tilde': 'mc.chord~', + 'mc_click_tilde': 'mc.click~', + 'mc_clip_tilde': 'mc.clip~', + 'mc_comb_tilde': 'mc.comb~', + 'mc_combine_tilde': 'mc.combine~', + 'mc_cos_tilde': 'mc.cos~', + 'mc_cosh_tilde': 'mc.cosh~', + 'mc_cosx_tilde': 'mc.cosx~', + 'mc_count_tilde': 'mc.count~', + 'mc_cross_tilde': 'mc.cross~', + 'mc_curve_tilde': 'mc.curve~', + 'mc_cycle_tilde': 'mc.cycle~', + 'mc_dac_tilde': 'mc.dac~', + 'mc_dbtoa_tilde': 'mc.dbtoa~', + 'mc_degrade_tilde': 'mc.degrade~', + 'mc_deinterleave_tilde': 'mc.deinterleave~', + 'mc_delay_tilde': 'mc.delay~', + 'mc_delta_tilde': 'mc.delta~', + 'mc_deltaclip_tilde': 'mc.deltaclip~', + 'mc_div_tilde': 'mc.div~', + 'mc_downsamp_tilde': 'mc.downsamp~', + 'mc_dup_tilde': 'mc.dup~', + 'mc_edge_tilde': 'mc.edge~', + 'mc_equals_tilde': 'mc.equals~', + 'mc_evolve_tilde': 'mc.evolve~', + 'mc_ezadc_tilde': 'mc.ezadc~', + 'mc_ezdac_tilde': 'mc.ezdac~', + 'mc_fffb_tilde': 'mc.fffb~', + 'mc_fft_tilde': 'mc.fft~', + 'mc_filtercoeff_tilde': 'mc.filtercoeff~', + 'mc_frameaccum_tilde': 'mc.frameaccum~', + 'mc_frameaverage_tilde': 'mc.frameaverage~', + 'mc_framedelta_tilde': 'mc.framedelta~', + 'mc_framesmooth_tilde': 'mc.framesmooth~', + 'mc_freqshift_tilde': 'mc.freqshift~', + 'mc_ftom_tilde': 'mc.ftom~', + 'mc_fzero_tilde': 'mc.fzero~', + 'mc_gain_tilde': 'mc.gain~', + 'mc_gate_tilde': 'mc.gate~', + 'mc_gen': 'mc.gen', + 'mc_gen_tilde': 'mc.gen~', + 'mc_generate_tilde': 'mc.generate~', + 'mc_gradient_tilde': 'mc.gradient~', + 'mc_greaterthan_tilde': 'mc.greaterthan~', + 'mc_greaterthaneq_tilde': 'mc.greaterthaneq~', + 'mc_groove_tilde': 'mc.groove~', + 'mc_hilbert_tilde': 'mc.hilbert~', + 'mc_ifft_tilde': 'mc.ifft~', + 'mc_in_tilde': 'mc.in~', + 'mc_index_tilde': 'mc.index~', + 'mc_interleave_tilde': 'mc.interleave~', + 'mc_kink_tilde': 'mc.kink~', + 'mc_lessthan_tilde': 'mc.lessthan~', + 'mc_lessthaneq_tilde': 'mc.lessthaneq~', + 'mc_limi_tilde': 'mc.limi~', + 'mc_line_tilde': 'mc.line~', + 'mc_list_tilde': 'mc.list~', + 'mc_log_tilde': 'mc.log~', + 'mc_lookup_tilde': 'mc.lookup~', + 'mc_lores_tilde': 'mc.lores~', + 'mc_loudness_tilde': 'mc.loudness~', + 'mc_makelist': 'mc.makelist', + 'mc_matrix_tilde': 'mc.matrix~', + 'mc_maximum_tilde': 'mc.maximum~', + 'mc_midiplayer_tilde': 'mc.midiplayer~', + 'mc_miditarget': 'mc.miditarget', + 'mc_minimum_tilde': 'mc.minimum~', + 'mc_minmax_tilde': 'mc.minmax~', + 'mc_minus_tilde': 'mc.minus~', + 'mc_mixdown_tilde': 'mc.mixdown~', + 'mc_modulo_tilde': 'mc.modulo~', + 'mc_mstosamps_tilde': 'mc.mstosamps~', + 'mc_mtof_tilde': 'mc.mtof~', + 'mc_noise_tilde': 'mc.noise~', + 'mc_normalize_tilde': 'mc.normalize~', + 'mc_noteallocator_tilde': 'mc.noteallocator~', + 'mc_notequals_tilde': 'mc.notequals~', + 'mc_number_tilde': 'mc.number~', + 'mc_omx_4band_tilde': 'mc.omx.4band~', + 'mc_omx_5band_tilde': 'mc.omx.5band~', + 'mc_omx_comp_tilde': 'mc.omx.comp~', + 'mc_omx_peaklim_tilde': 'mc.omx.peaklim~', + 'mc_onepole_tilde': 'mc.onepole~', + 'mc_op_tilde': 'mc.op~', + 'mc_out_tilde': 'mc.out~', + 'mc_overdrive_tilde': 'mc.overdrive~', + 'mc_pack_tilde': 'mc.pack~', + 'mc_pattern_tilde': 'mc.pattern~', + 'mc_peakamp_tilde': 'mc.peakamp~', + 'mc_peek_tilde': 'mc.peek~', + 'mc_pfft_tilde': 'mc.pfft~', + 'mc_phasegroove_tilde': 'mc.phasegroove~', + 'mc_phaseshift_tilde': 'mc.phaseshift~', + 'mc_phasewrap_tilde': 'mc.phasewrap~', + 'mc_phasor_tilde': 'mc.phasor~', + 'mc_pink_tilde': 'mc.pink~', + 'mc_pitchshift_tilde': 'mc.pitchshift~', + 'mc_play_tilde': 'mc.play~', + 'mc_playlist_tilde': 'mc.playlist~', + 'mc_plus_tilde': 'mc.plus~', + 'mc_plusequals_tilde': 'mc.plusequals~', + 'mc_poltocar_tilde': 'mc.poltocar~', + 'mc_poly_tilde': 'mc.poly~', + 'mc_pong_tilde': 'mc.pong~', + 'mc_pow_tilde': 'mc.pow~', + 'mc_ramp_tilde': 'mc.ramp~', + 'mc_rampsmooth_tilde': 'mc.rampsmooth~', + 'mc_rand_tilde': 'mc.rand~', + 'mc_range_tilde': 'mc.range~', + 'mc_rate_tilde': 'mc.rate~', + 'mc_rdiv_tilde': 'mc.rdiv~', + 'mc_receive_tilde': 'mc.receive~', + 'mc_record_tilde': 'mc.record~', + 'mc_rect_tilde': 'mc.rect~', + 'mc_resize_tilde': 'mc.resize~', + 'mc_reson_tilde': 'mc.reson~', + 'mc_retune_tilde': 'mc.retune~', + 'mc_rminus_tilde': 'mc.rminus~', + 'mc_round_tilde': 'mc.round~', + 'mc_route': 'mc.route', + 'mc_sah_tilde': 'mc.sah~', + 'mc_sampstoms_tilde': 'mc.sampstoms~', + 'mc_sash_tilde': 'mc.sash~', + 'mc_saw_tilde': 'mc.saw~', + 'mc_scale_tilde': 'mc.scale~', + 'mc_selector_tilde': 'mc.selector~', + 'mc_send_tilde': 'mc.send~', + 'mc_separate_tilde': 'mc.separate~', + 'mc_seq_tilde': 'mc.seq~', + 'mc_sfizz_tilde': 'mc.sfizz~', + 'mc_sfplay_tilde': 'mc.sfplay~', + 'mc_sfrecord_tilde': 'mc.sfrecord~', + 'mc_shape_tilde': 'mc.shape~', + 'mc_sig_tilde': 'mc.sig~', + 'mc_sinh_tilde': 'mc.sinh~', + 'mc_sinx_tilde': 'mc.sinx~', + 'mc_slide_tilde': 'mc.slide~', + 'mc_snapshot_tilde': 'mc.snapshot~', + 'mc_snowfall_tilde': 'mc.snowfall~', + 'mc_snowphasor_tilde': 'mc.snowphasor~', + 'mc_spike_tilde': 'mc.spike~', + 'mc_sqrt_tilde': 'mc.sqrt~', + 'mc_stash_tilde': 'mc.stash~', + 'mc_stepdiv_tilde': 'mc.stepdiv~', + 'mc_stepfun_tilde': 'mc.stepfun~', + 'mc_stereo_tilde': 'mc.stereo~', + 'mc_stutter_tilde': 'mc.stutter~', + 'mc_subdiv_tilde': 'mc.subdiv~', + 'mc_svf_tilde': 'mc.svf~', + 'mc_swing_tilde': 'mc.swing~', + 'mc_sync_tilde': 'mc.sync~', + 'mc_table_tilde': 'mc.table~', + 'mc_tanh_tilde': 'mc.tanh~', + 'mc_tanx_tilde': 'mc.tanx~', + 'mc_tapin_tilde': 'mc.tapin~', + 'mc_tapout_tilde': 'mc.tapout~', + 'mc_target': 'mc.target', + 'mc_targetlist': 'mc.targetlist', + 'mc_teeth_tilde': 'mc.teeth~', + 'mc_thresh_tilde': 'mc.thresh~', + 'mc_times_tilde': 'mc.times~', + 'mc_train_tilde': 'mc.train~', + 'mc_transpose_tilde': 'mc.transpose~', + 'mc_trapezoid_tilde': 'mc.trapezoid~', + 'mc_tri_tilde': 'mc.tri~', + 'mc_triangle_tilde': 'mc.triangle~', + 'mc_trunc_tilde': 'mc.trunc~', + 'mc_twist_tilde': 'mc.twist~', + 'mc_unpack_tilde': 'mc.unpack~', + 'mc_updown_tilde': 'mc.updown~', + 'mc_vectral_tilde': 'mc.vectral~', + 'mc_voiceallocator_tilde': 'mc.voiceallocator~', + 'mc_vst_tilde': 'mc.vst~', + 'mc_wave_tilde': 'mc.wave~', + 'mc_what_tilde': 'mc.what~', + 'mc_where_tilde': 'mc.where~', + 'mc_zerox_tilde': 'mc.zerox~', + 'mc_zigzag_tilde': 'mc.zigzag~', + 'mcs_2d_wave_tilde': 'mcs.2d.wave~', + 'mcs_amxd_tilde': 'mcs.amxd~', + 'mcs_fffb_tilde': 'mcs.fffb~', + 'mcs_gate_tilde': 'mcs.gate~', + 'mcs_gen_tilde': 'mcs.gen~', + 'mcs_groove_tilde': 'mcs.groove~', + 'mcs_limi_tilde': 'mcs.limi~', + 'mcs_matrix_tilde': 'mcs.matrix~', + 'mcs_play_tilde': 'mcs.play~', + 'mcs_poly_tilde': 'mcs.poly~', + 'mcs_selector_tilde': 'mcs.selector~', + 'mcs_sig_tilde': 'mcs.sig~', + 'mcs_tapout_tilde': 'mcs.tapout~', + 'mcs_vst_tilde': 'mcs.vst~', + 'mcs_wave_tilde': 'mcs.wave~', + 'meter_tilde': 'meter~', + 'minimum_tilde': 'minimum~', + 'minmax_tilde': 'minmax~', + 'minus_tilde': 'minus~', + 'modulo_tilde': 'modulo~', + 'mstosamps_tilde': 'mstosamps~', + 'mtof_tilde': 'mtof~', + 'mute_tilde': 'mute~', + 'mxj_tilde': 'mxj~', + 'noise_tilde': 'noise~', + 'normalize_tilde': 'normalize~', + 'notequals_tilde': 'notequals~', + 'number_tilde': 'number~', + 'omx_4band_tilde': 'omx.4band~', + 'omx_5band_tilde': 'omx.5band~', + 'omx_comp_tilde': 'omx.comp~', + 'omx_peaklim_tilde': 'omx.peaklim~', + 'onepole_tilde': 'onepole~', + 'oscbank_tilde': 'oscbank~', + 'out': 'out', + 'out_tilde': 'out~', + 'overdrive_tilde': 'overdrive~', + 'pass_tilde': 'pass~', + 'peakamp_tilde': 'peakamp~', + 'peek_tilde': 'peek~', + 'pfft_tilde': 'pfft~', + 'phasegroove_tilde': 'phasegroove~', + 'phaseshift_tilde': 'phaseshift~', + 'phasewrap_tilde': 'phasewrap~', + 'phasor_tilde': 'phasor~', + 'pink_tilde': 'pink~', + 'pitchshift_tilde': 'pitchshift~', + 'play_tilde': 'play~', + 'playlist_tilde': 'playlist~', + 'plot_tilde': 'plot~', + 'plugin_tilde': 'plugin~', + 'plugout_tilde': 'plugout~', + 'plugphasor_tilde': 'plugphasor~', + 'plugreceive_tilde': 'plugreceive~', + 'plugsend_tilde': 'plugsend~', + 'plugsync_tilde': 'plugsync~', + 'plus_tilde': 'plus~', + 'plusequals_tilde': 'plusequals~', + 'poke_tilde': 'poke~', + 'poltocar_tilde': 'poltocar~', + 'poly_tilde': 'poly~', + 'polybuffer_tilde': 'polybuffer~', + 'pong_tilde': 'pong~', + 'pow_tilde': 'pow~', + 'ramp_tilde': 'ramp~', + 'rampsmooth_tilde': 'rampsmooth~', + 'rand_tilde': 'rand~', + 'rate_tilde': 'rate~', + 'rdiv_tilde': 'rdiv~', + 'receive_tilde': 'receive~', + 'record_tilde': 'record~', + 'rect_tilde': 'rect~', + 'reson_tilde': 'reson~', + 'retune_tilde': 'retune~', + 'rminus_tilde': 'rminus~', + 'round_tilde': 'round~', + 'sah_tilde': 'sah~', + 'sampstoms_tilde': 'sampstoms~', + 'sash_tilde': 'sash~', + 'saw_tilde': 'saw~', + 'scale_tilde': 'scale~', + 'scope_tilde': 'scope~', + 'selector_tilde': 'selector~', + 'send_tilde': 'send~', + 'seq_tilde': 'seq~', + 'sfinfo_tilde': 'sfinfo~', + 'sfizz_tilde': 'sfizz~', + 'sflist_tilde': 'sflist~', + 'sfplay_tilde': 'sfplay~', + 'sfrecord_tilde': 'sfrecord~', + 'shape_tilde': 'shape~', + 'sig_tilde': 'sig~', + 'sinh_tilde': 'sinh~', + 'sinx_tilde': 'sinx~', + 'slide_tilde': 'slide~', + 'snapshot_tilde': 'snapshot~', + 'snowfall_tilde': 'snowfall~', + 'spectroscope_tilde': 'spectroscope~', + 'spike_tilde': 'spike~', + 'sqrt_tilde': 'sqrt~', + 'stash_tilde': 'stash~', + 'stepcounter_tilde': 'stepcounter~', + 'stepdiv_tilde': 'stepdiv~', + 'stepfun_tilde': 'stepfun~', + 'stretch_tilde': 'stretch~', + 'stutter_tilde': 'stutter~', + 'subdiv_tilde': 'subdiv~', + 'svf_tilde': 'svf~', + 'swing_tilde': 'swing~', + 'sync_tilde': 'sync~', + 'table_tilde': 'table~', + 'tanh_tilde': 'tanh~', + 'tanx_tilde': 'tanx~', + 'tapin_tilde': 'tapin~', + 'tapout_tilde': 'tapout~', + 'techno_tilde': 'techno~', + 'teeth_tilde': 'teeth~', + 'thispoly_tilde': 'thispoly~', + 'thresh_tilde': 'thresh~', + 'times_tilde': 'times~', + 'train_tilde': 'train~', + 'trapezoid_tilde': 'trapezoid~', + 'tri_tilde': 'tri~', + 'triangle_tilde': 'triangle~', + 'trunc_tilde': 'trunc~', + 'twist_tilde': 'twist~', + 'typeroute_tilde': 'typeroute~', + 'updown_tilde': 'updown~', + 'vectral_tilde': 'vectral~', + 'vst_tilde': 'vst~', + 'wave_tilde': 'wave~', + 'waveform_tilde': 'waveform~', + 'what_tilde': 'what~', + 'where_tilde': 'where~', + 'windowed_fft_tilde': 'windowed-fft~', + 'zerox_tilde': 'zerox~', + 'zigzag_tilde': 'zigzag~', + 'zplane_tilde': 'zplane~', +} + +_devnull = open(_os.devnull, 'w') +_old_stdout = _sys.stdout +_sys.stdout = _devnull + +_2d_wave_tilde = MaxObject('2d.wave~') +""" +2d.wave~ - Two-dimensional wavetable + +2d.wave~ is similar to wave~, but with an additional axis. A given ms range of an audio file will be divided into n rows. Y phase input will determine which row(s) will be used for playback. When the 2d.wave~ object is instantiated as mcs.2d.wave~ its outputs are combined into a single multichannel output but otherwise it functions identically to 2d.wave~. + +Args: + buffer-name (symbol, required) + start and end-points (number, optional) + number-of-output-channels (int, optional) + rows (int, optional) + +Inlets: + 0 (signal): (signal) X Table Position (from 0 to 1) + 1 (signal): (signal) Y Table Position (from 0 to 1) + 2 (signal/float): (signal/float) Starting Table Location in ms + 3 (signal/float): (signal/float) Ending Table Location in ms + +Outlets: + 0 (signal): (signal) Channel 1 Output + +Messages: int, float, list, (mouse), rows, set, signal +""" + +abs_tilde = MaxObject('abs~') +""" +abs~ - Absolute value of a signal + +Use the abs~ object to take any given signal and output only the absolute (non-negative) translation of that signal (i.e. a rectified waveform). All negative values in the input signal are converted to positive values in the output. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Absolute Value of Input + +Messages: signal +""" + +acos_tilde = MaxObject('acos~') +""" +acos~ - Signal arc-cosine function + +Use the acos~ object to calculate and output a signal that is the arc-cosine function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Acos (x) Out + +Messages: signal +""" + +acosh_tilde = MaxObject('acosh~') +""" +acosh~ - Signal hyperbolic arc-cosine function + +Use the acosh~ object to calculate and output a signal that is the hyperbolic arc-cosine function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Acosh (x) Out + +Messages: signal +""" + +adc_tilde = MaxObject('adc~') +""" +adc~ - Audio input and on/off + +The adc~ ("analog-to-digital converter") object outputs one or more signals (one per outlet) with audio from hardware input devices. + +Args: + inputs (int, optional) + +Inlets: + 0 (INLET_TYPE): start, stop Turn Audio On and Off + +Outlets: + 0 (signal): (signal) Audio In Ch 1 + 1 (signal): (signal) Audio In Ch 2 + +Messages: int, list, (mouse), open, set, start, startwindow, stop, wclose +""" + +adoutput_tilde = MaxObject('adoutput~') +""" +adoutput~ - Access audio driver output channel + +Use the adoutput~ object to record the current audio output or to feed it back into your patcher. The output of adoutput~ is delayed by one signal vector with respect to the actual output. + +Args: + audiodriver-output-channels (int, optional) + +Inlets: + 0 (INLET_TYPE): set Changes Output Channel + +Outlets: + 0 (signal): (signal) Output of Audio Channel 1 + 1 (signal): (signal) Output of Audio Channel 2 + +Messages: set +""" + +adsr_tilde = MaxObject('adsr~') +""" +adsr~ - ADSR envelope generator + +The adsr~ object is an Attack-Decay-Sustain-Release signal controllable by signals. In some situations, a combination of the function and line~ objects may be a useful alternative. + +Args: + attack (float, optional) + decay (float, optional) + sustain (float, optional) + release (float, optional) + +Inlets: + 0 (signal/float): trigger + 1 (signal/float): attack + 2 (signal/float): decay + 3 (signal/float): sustain + 4 (signal/float): release + +Outlets: + 0 (signal): ADSR envelope + 1 (signal): new envelope trigger + 2 (message): mute outlet + 3 (message): dump outlet + +Messages: int, float, list, anything, signal + +Attributes: attack, decay, legato, maxsustain, release, retrigger, sustain, triggermode +""" + +adstatus = MaxObject('adstatus') +""" +adstatus - Report and control audio driver settings + +Use the adstatus object to control Max audio settings. + +Args: + Controllable-settings: (symbol, required) + +Messages: bang, int, float, in1, loadbang, override, set, update +""" + +allpass_tilde = MaxObject('allpass~') +""" +allpass~ - Apply an allpass filter effect + +Use the allpass~ object to filter an input with an allpass filter. The allpass filter has a flat magnitude response but a complex phase response, typically delaying sharp transients. + +Args: + max-delay (float, optional) + initial-delay (float, optional) + gain (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Delay in ms + 2 (signal/float): (signal/float) Gain Coefficient + +Outlets: + 0 (signal): (signal) Filter Output + +Messages: float, clear, signal +""" + +amxd_tilde = MaxObject('amxd~') +""" +amxd~ - Host Max for Live devices + +Use the amxd~ object to load a Max for Live device and use it in MSP. When the amxd~ object is instantiated as mcs.amxd~ its audio inputs combined into a single multichannel input and its audio outputs are combined into a single multichannel output. + +Args: + devicename (symbol, required) + +Inlets: + 0 (signal): Channel 1 in + 1 (signal): Channel 2 in + 2 (signal): MIDI In + +Outlets: + 0 (signal): Channel 1 out + 1 (signal): Channel 2 out + 2 (signal): MIDI Out + 3 (signal): Info Out + +Messages: anything, (drag), (mouse), drag_replace, getinfo, getparams, getvalue, midievent, midiin, open, signal + +Attributes: active, annotation_name, autosave, autosize, latency, mcisolate, parameter_enable, patchername, realtime_params, showheader +""" + +asin_tilde = MaxObject('asin~') +""" +asin~ - Signal arc-sine function + +Use the asin~ object to calculate and output a signal that is the arc-sine function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Asin (x) Out + +Messages: signal +""" + +asinh_tilde = MaxObject('asinh~') +""" +asinh~ - Signal hyperbolic arc-sine function + +Use the asinh~ object to calculate and output a signal that is the hyperbolic arc-sine function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Asinh (x) Out + +Messages: signal +""" + +atan2_tilde = MaxObject('atan2~') +""" +atan2~ - Signal arc-tangent function (two variables) + +Use the acosh~ object to take two given x and y values and output a signal which is their arc-tangent function, calculated as follows: + + Arc-tangent (y/x) + +Inlets: + 0 (signal): Y value + 1 (signal): X value + +Outlets: + 0 (signal): atan2(y/x) + +Messages: int, float, signal +""" + +atan_tilde = MaxObject('atan~') +""" +atan~ - Signal arc-tangent function + +Use the atan~ object to calculate and output a signal that is the arc-tangent function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Atan (x) Out + +Messages: signal +""" + +atanh_tilde = MaxObject('atanh~') +""" +atanh~ - Signal hyperbolic arc-tangent function + +Use the atanh~ object to calculate and output a signal that is the hyperbolic arc-tangent function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Atanh (x) Out + +Messages: signal +""" + +atodb_tilde = MaxObject('atodb~') +""" +atodb~ - Convert a linear value to a signal-rate deciBel value + +Use the atodb~ to convert a signal representing a linear value to a deciBel equivalent. + +Inlets: + 0 (signal): (signal) Amplitude Scalar + +Outlets: + 0 (signal): (signal) Gain/Attenuation dB + +Messages: signal +""" + +average_tilde = MaxObject('average~') +""" +average~ - Multi-mode signal average + +Use the average~ to perform bipolar, absolute, or rms averaging on any input signal. + +Args: + max-averaging-interval (int, optional) + averaging-mode (symbol, optional) + +Inlets: + 0 (signal): (signal) Input and Messages + +Outlets: + 0 (signal): (signal) Running Mean Average Out + +Messages: int, absolute, bipolar, rms, signal + +Attributes: mode +""" + +avg_tilde = MaxObject('avg~') +""" +avg~ - Signal average + +Use the avg~ object to keep track of the average (absolute) amplitude of the input signal received over a specified time interval. + +Inlets: + 0 (signal): (signal) Input, bang Outputs Average + +Outlets: + 0 (float): (float) Average Value of Input Signal + +Messages: bang, signal +""" + +begin_tilde = MaxObject('begin~') +""" +begin~ - Define a switchable part of a signal network + +The begin~ object is OBSOLETE. For controlling audio processing in a patcher, please use the poly~ object. The begin~ designated the beginning portion of a signal network that could be turned off when not needed. The outlet of begin~ was connected to the signal inlet of another object to define the beginning of a signal network that would eventually pass through a gate~ or selector~. This feature became obsolete in Max 6 and begin~ no longer does anything at all. + +Outlets: + 0 (signal): (signal) Connect to Objects to Turn On and Off +""" + +biquad_tilde = MaxObject('biquad~') +""" +biquad~ - Two-pole, two-zero filter + +biquad~ implements a two-pole, two-zero filter using the following equation: + + + y[n] = a0 * x[n] + a1 * x[n-1] + a2 * x[n-2] - b1 * y[n-1] - b2 * y[n-2] + + + You can specify the coefficients a0, a1, a2, b1, and b2 as signals or floats (if you make the filter explode by making the b coefficients too high, you can recover (after lowering them) with the clear message, or by turning the audio on and off). + +Args: + a0 (float, required) + a1 (float, required) + a2 (float, required) + b1 (float, required) + b2 (float, required) + +Inlets: + 0 (signal): Input + 1 (signal/float): Input Gain (Filter coefficient a0) + 2 (signal/float): Filter coefficient a1 + 3 (signal/float): Filter coefficient a2 + 4 (signal/float): Filter coefficient b1 + 5 (signal/float): Filter coefficient b2 + +Outlets: + 0 (signal): Output + +Messages: int, float, list, clear, dictionary, signal, stoke + +Attributes: smooth +""" + +bitand_tilde = MaxObject('bitand~') +""" +bitand~ - Bitwise and-operation of floating point signals + +Use the bitand~ object to perform a bitwise intersection (a bitwise "and") on two incoming floating-point signals as either raw 32-bit data or as integer values. The output is a floating-point signal composed of those bits which are 1 in both numbers. + +Args: + bitmask (int, optional) + operational-mode (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/int): (signal/int) Bitwise mask + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, bits, signal + +Attributes: mode +""" + +bitnot_tilde = MaxObject('bitnot~') +""" +bitnot~ - Bitwise inversion of a floating point signal + +Use the bitnot~ object to perform a bitwise inversion on an incoming floating-point signal as either raw 32-bit data or as an integer value. All bit values of 1 are set to 0, and vice versa. + +Args: + operational-mode (int, optional) + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal + +Attributes: mode +""" + +bitor_tilde = MaxObject('bitor~') +""" +bitor~ - Bitwise or-operation of floating point signals + +Use the bitor~ object to perform a bitwise "or" on two incoming floating-point signals as either raw 32-bit data or as integer values. The bits of both incoming signals are compared, and a 1 is output if either of the two bit values is 1. The output is a floating-point signal composed of the resulting bit pattern. + +Args: + bitmask (int, optional) + operational-mode (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/int): (signal/int) Bitwise mask + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, bits, signal + +Attributes: mode +""" + +bitsafe_tilde = MaxObject('bitsafe~') +""" +bitsafe~ - Replace NaN and infinite signal values with 0 + +Use the bitsafe~ object to detect NaN (not a number) and +/- infinity values in an incoming signal and replace those occurences with zero. This is useful in conjunction with the bitwise operators, or any other situation where these values are possible. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Output + +Messages: signal +""" + +bitshift_tilde = MaxObject('bitshift~') +""" +bitshift~ - Bit shifting for floating point signals + +Use the bitshift~ object to perform bitwise operations on a floating point signal as bits or as an integer. + +Args: + number-of-bits/direction-of-shift (int, optional) + operational-mode (int, optional) + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, shift, signal + +Attributes: mode +""" + +bitxor_tilde = MaxObject('bitxor~') +""" +bitxor~ - Bitwise exclusive-or-operation of floating point signals + +Use the bitxor~ object to perform a bitwise "exclusive or" operation on two incoming floating-point signals as either raw 32-bit data or as integer values. The bits of both incoming signals are compared, and the corresponding output bit will be set to 1 if the two bit values are different, and 0 if the two values are the same. The output is a floating-point signal composed of the resulting bit pattern. + +Args: + bitmask (int, optional) + operational-mode (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/int): (signal/int) Bitwise mask + +Outlets: + 0 (signal): (signal) Output + +Messages: int, bits, signal + +Attributes: mode +""" + +buffer_tilde = MaxObject('buffer~') +""" +buffer~ - Store audio samples + +Use the buffer~ object as a buffer of memory in which samples are stored to be saved, edited, or referenced. + +Args: + name (symbol, required) + filename (symbol, optional) + duration (number, optional) + channels (int, optional) + +Inlets: + 0 (INLET_TYPE): size Resizes, File Operations: read, write + +Outlets: + 0 (OUTLET_TYPE): msec Mouse Position in Editing Window + 1 (OUTLET_TYPE): bang when File Read or File Write operation completed + +Messages: bang, (remote), (drag), apply, clear, clearlow, crop, (mouse), duplicate, enumerate, fill, import, importreplace, name, normalize, open, printmodtime, read, readagain, readraw, replace, samptype, set, setsize, sizeinsamps, wclose, write, writeaiff, writeflac, writeraw, writewave + +Attributes: chans, dither, file, filetype, format, quantization, samps, size, sr +""" + +buffir_tilde = MaxObject('buffir~') +""" +buffir~ - buffer-based FIR filter + +Use buffir~ object when you need a finite impulse response (FIR) filter that convolves an input signal with samples from an input buffer. + +Args: + buffer-name (symbol, required) + read-offset (int, float, optional) + read-duration (int, float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (int/float/sig): (int/float/sig) Begin (samples) + 2 (int/float/sig): (int/float/sig) Length (samples) + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, clear, (mouse), set, signal +""" + +capture_tilde = MaxObject('capture~') +""" +capture~ - Store a signal to view as text + +Use the capture object to collect signal values for signal debugging or investigation. To record signal values, use the record~ or sfrecord~ object. + +Args: + behavioral-flag (f) (symbol, optional) + maximum-samples (int, optional) + signal-vector-indices (up to 10 ints) (list, optional) + +Inlets: + 0 (INLET_TYPE): (signal) Data to be Captured, write Saves File + +Messages: clear, (mouse), open, signal, wclose, write +""" + +cartopol_tilde = MaxObject('cartopol~') +""" +cartopol~ - Signal Cartesian to Polar coordinate conversion + +Use the cartopol~ object to convert signal values representing cartesian coordinates to a signal composed of polar coordinates. + +Inlets: + 0 (signal): (signal) real/x input + 1 (signal): (signal) imaginary/y input + +Outlets: + 0 (signal): (signal) amplitude/alpha output + 1 (signal): (signal) phase/theta output + +Messages: signal +""" + +cascade_tilde = MaxObject('cascade~') +""" +cascade~ - Cascaded series of biquad filters + +Use the cascade~ to filter an input signal using a series of biquad filters. + +Inlets: + 0 (signal): (signal) signal to be filtered + 1 (list): (signal) list of filter coefficients + +Outlets: + 0 (signal): (signal) filtered signal out + +Messages: list, bypass, clear, dictionary, signal, zero +""" + +change_tilde = MaxObject('change~') +""" +change~ - Report signal direction + +Use the change object to monitor increase, decrease, or no change in a signal value. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) 0. if Unchanged; -1. (decreasing) or 1. (increasing) if Changed. + +Messages: float, signal +""" + +click_tilde = MaxObject('click~') +""" +click~ - Create an impulse + +Use the click~ to create and output an impulse which can be used as an impulse-trigger. + +Args: + wavetable-values (list, optional) + +Inlets: + 0 (INLET_TYPE): bang to Trigger Impulse + +Outlets: + 0 (signal): (signal) Impulse Signal Out + +Messages: bang, int, float, set, signal +""" + +clip_tilde = MaxObject('clip~') +""" +clip~ - Limit signal amplitude + +Use the clip~ to constrain input signals between two specified values. + +Args: + minimum (float, optional) + maximum (float, optional) + +Inlets: + 0 (signal): (signal) Input to be Clipped + 1 (signal): Minimum Level + 2 (signal): Maximum Level + +Outlets: + 0 (signal): (signal) Clipped Output + +Messages: int, float, signal + +Attributes: mode +""" + +comb_tilde = MaxObject('comb~') +""" +comb~ - Apply a comb filter effect + +Use the comb~ object to apply the classic comb filtering effect to an audio input. The comb~ object mixes the current input sample with earlier input and/or output samples, according to the formula: + + + yn = axn + bxn-(DR/1000) + cyn-(DR/1000) + + + where R is the sampling rate and D is a delay time in milliseconds. + +Args: + max-delay (float, optional) + initial-delay (float, optional) + gain-coefficient (float, optional) + feedforward-coefficient (float, optional) + feedback-coefficient (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Delay in ms + 2 (signal/float): (signal/float) Gain Coefficient + 3 (signal/float): (signal/float) Feedforward Coefficient + 4 (signal/float): (signal/float) Feedback Coefficient + +Outlets: + 0 (signal): (signal) Filter Output + +Messages: float, clear, signal +""" + +cos_tilde = MaxObject('cos~') +""" +cos~ - Signal cosine function (0-1 range) + +Use the cos~ object to calculate and output a signal that is the cosine function of each sample of the input signal. + +Inlets: + 0 (signal): (signal) Phase (0-1) + +Outlets: + 0 (signal): (signal) Cosine Output + +Messages: signal +""" + +cosh_tilde = MaxObject('cosh~') +""" +cosh~ - Signal hyperbolic cosine function + +Use the cosh~ object to calculate and output a signal that is the hyperbolic cosine function of each sample of the input signal. + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Cosh (x) Out + +Messages: signal +""" + +cosx_tilde = MaxObject('cosx~') +""" +cosx~ - Signal cosine function + +Use the cosx~ object to calculate and output a signal that is the cosine function of each sample of the input signal. The cosx~ object is a true π based function - it varies from the cos~ object, whose output is based around a value range of 0. - 1.0 and is intended for use as a lookup table with the phasor~ object. + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Cos (x) Out + +Messages: signal +""" + +count_tilde = MaxObject('count~') +""" +count~ - Count samples elapsed + +Use the count~ object count samples elapsed and thus drive processes tightly synchronized to the sample rate. It outputs a signal increasing by 1 for each sample elapsed. It can be set to loop, and can be used to drive objects such as index~ with sample accuracy. + +Args: + initial-value (int, optional) + count-limit (int, optional) + enable (int, optional) + autoreset-state (int, optional) + +Inlets: + 0 (INLET_TYPE): int, bang Start Count, stop Stops It + 1 (INLET_TYPE): int sets Count Limit + +Outlets: + 0 (signal): Count Output + +Messages: bang, int, float, list, in1, min, set, signal, stop + +Attributes: autoreset +""" + +cross_tilde = MaxObject('cross~') +""" +cross~ - Third-order crossover filter + +Use the cross~ object as a pair of symmetrical low+high pass 3rd order filters with lowpass and highpass outlets you can use separately or in combination to form a crossover filter. + +Args: + cutoff-frequency (float, required) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Crossover Frequency (Hz) + +Outlets: + 0 (signal): (signal) Lowpass Filtered Output + 1 (signal): (signal) Highpass Filtered Output + +Messages: int, float, clear, signal +""" + +curve_tilde = MaxObject('curve~') +""" +curve~ - Exponential ramp generator + +Use the curve~ object to produce a signal that goes from an initial to target value over a specified time. It is similar to the line~ object, it produces non-linear ramps using a piecewise approximation of an exponential function. + +Args: + initial-value (number, optional) + curve-parameter (number, optional) + +Inlets: + 0 (INLET_TYPE): Destination Value + 1 (INLET_TYPE): Ramp Time + 2 (INLET_TYPE): Curve Parameter (-1.0 to 1.0) + +Outlets: + 0 (signal): Output Ramp + 1 (signal): bang When Curve Reaches Destination + +Messages: int, float, list, anything, factor, pause, resume, stop + +Attributes: activeout, maxpoints, shapemode +""" + +cycle_tilde = MaxObject('cycle~') +""" +cycle~ - Sinusoidal oscillator + +Use the cycle~ object to generate a periodic waveform. The default waveform is one cycle of a cosine wave. You can also use the wave~ object, which offers additional flexibility though slightly less optimization. + +Args: + frequency (number, optional) + buffer-name (symbol, optional) + sample-offset (int, optional) + +Inlets: + 0 (signal/float): Frequency + 1 (signal/float): Phase (0-1) + +Outlets: + 0 (signal): Output + +Messages: float, (mouse), reset, set, setall, signal + +Attributes: buffer, buffer_offset, buffer_sizeinsamps, frequency, phase +""" + +dac_tilde = MaxObject('dac~') +""" +dac~ - Audio output and on/off + +The dac~ ("digital-to-analog converter") object sends its signal inputs to audio hardware. Double-click on a dac~ to open the Audio Status window to configure audio settings and hardware. + +Args: + outputs (int, symbol, optional) + +Inlets: + 0 (signal): (signal) Audio Out Ch 1, start (1) and stop (0) + 1 (signal): (signal) Audio Out Ch 2 + +Messages: int, list, (mouse), open, set, signal, start, startwindow, stop, wclose +""" + +dbtoa_tilde = MaxObject('dbtoa~') +""" +dbtoa~ - Convert a deciBel value to a linear value at signal rate + +dbtoa~ takes any given signal representing a deciBel value and outputs a signal which is a linear value conversion of the input. + +Inlets: + 0 (signal): (signal) Gain/Attenuation dB + +Outlets: + 0 (signal): (signal) Amplitude Scalar + +Messages: signal +""" + +degrade_tilde = MaxObject('degrade~') +""" +degrade~ - Signal quality reducer + +degrade~ takes any given signal and reduces the sampling rate and bit-depth as specified/desired. + +Args: + resampling-frequency-ratio (float, optional) + number-of-quantization-bits (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (float / signal): (float) Sampling-Rate Ratio + 2 (int / signal): (int) Resolution in bits + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal +""" + +delay_tilde = MaxObject('delay~') +""" +delay~ - Delay a signal + +Use the delay~ object to delay a signal by a certain amount of time. The delay time can be specified in samples (determined by the sampling rate), or using the Max time format syntax for tempo-relative values. + +Args: + maximum-delay-memory (int, required) + initial-delay-time (list, optional) + ramp-time (int, optional) + +Inlets: + 0 (signal): Input to be Delayed + 1 (int/signal): Delay Time in Samples + +Outlets: + 0 (signal): Delayed Output + +Messages: int, float, list, anything, clear, maxsize, ramp, signal + +Attributes: delay +""" + +delta_tilde = MaxObject('delta~') +""" +delta~ - Signal of sample differences + +delta~ outputs a signal which represents the differences between each incoming sample value in the input signal. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Differences Between Input Samples + +Messages: signal +""" + +deltaclip_tilde = MaxObject('deltaclip~') +""" +deltaclip~ - Limit changes in signal amplitude + +deltaclip~ limits the change between samples in an incoming signal. It is similar to the clip~ object, but it limits amplitude changes with respect to slope rather than amplitude. + +Args: + minimum-slope-value (float, optional) + minimum and maximum-slope-values (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (double): (float) Delta min + 2 (double): (float) Delta max + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, ft1, ft2, reset, signal +""" + +div_tilde = MaxObject('div~') +""" +div~ - Divide one signal by another + +Use the /~ object is to multiply a signal coming into the left inlet by the reciprocal of either the initial argument or an int or float received in the right inlet. + +Args: + initial-divisor (number, optional) + +Inlets: + 0 (signal/float): (signal/float) This / Right Inlet + 1 (signal/float): (signal/float) Left Inlet / This + +Outlets: + 0 (signal): (signal) Division Result + +Messages: int, float, signal +""" + +downsamp_tilde = MaxObject('downsamp~') +""" +downsamp~ - Downsample a signal + +downsamp~ samples and holds a signal received in the left inlet at a rate set by an argument to the object of the value received in the right inlet, expressed in samples. No interpolation of the output is performed. + +Args: + downsampled-rate (number, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Sampling interval + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal +""" + +dspstate_tilde = MaxObject('dspstate~') +""" +dspstate~ - Report current DSP settings + +dspstate~ can be used for calculations that require the sampling rate of current DSP processing block size. You can also use the leftmost outlet to trigger some event when the audio is turned on or off. + +Inlets: + 0 (INLET_TYPE): Connect signal, bang reports Info + +Outlets: + 0 (OUTLET_TYPE): 1 When Audio Turns On, 0 When It Turns Off + 1 (OUTLET_TYPE): Current Sampling Rate + 2 (OUTLET_TYPE): Current DSP Signal Vector Size + 3 (OUTLET_TYPE): Current I/O Vector Size + +Messages: bang, signal +""" + +dsptime_tilde = MaxObject('dsptime~') +""" +dsptime~ - Report milliseconds of audio processed + +dsptime~ reports the time in milliseconds since the audio was last turned on when triggered by a bang. + +Inlets: + 0 (INLET_TYPE): bang Reports Time + +Outlets: + 0 (OUTLET_TYPE): Milliseconds of Samples Processed + +Messages: bang, signal +""" + +edge_tilde = MaxObject('edge~') +""" +edge~ - Detect logical signal transitions + +Use the edge~ to detect zero to non-zero (and vice versa) signal transitions and report a bang out of one of its two outlets according to which direction the transition has occurred. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (bang): (bang) Output on zero to non-zero transition + 1 (bang): (bang) Output on non-zero to zero transition + +Messages: signal +""" + +equals_tilde = MaxObject('equals~') +""" +equals~ - Is equal to, comparison of two signals + +==~ outputs a 1 signal when the left input is equal to the right input and a 0 when it is not equal to the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (signal/float): (signal) This == Right Inlet + 1 (signal/float): (signal/float) Left Inlet == This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal + +Attributes: fuzzy +""" + +ezadc_tilde = MaxObject('ezadc~') +""" +ezadc~ - Audio input and on/off button + +ezadc~ works as a user interface version of the adc~ object. It appears as a button which can be clicked with the mouse to turn audio on or off. + +Inlets: + 0 (INLET_TYPE): Start/Stop Audio + +Outlets: + 0 (signal): Audio In ch 1 + 1 (signal): Audio In ch 2 + +Messages: int, list, (mouse), local, open, set, start, startwindow, stop, wclose + +Attributes: bgcolor, border, bordercolor, color, elementcolor, local, offgradcolor1, offgradcolor2, ongradcolor1, ongradcolor2, style +""" + +ezdac_tilde = MaxObject('ezdac~') +""" +ezdac~ - Audio output and on/off button + +ezdac~ works as a user interface version of the dac~ object. It appears as a button which can be clicked with the mouse to turn audio on or off. + +Inlets: + 0 (signal): (signal) start/stop, Audio Out Ch 1 + 1 (signal): (signal) Audio Out Ch 2 + +Messages: int, list, (mouse), local, open, set, signal, start, startwindow, stop, wclose + +Attributes: bgcolor, border, bordercolor, color, elementcolor, local, offgradcolor1, offgradcolor2, ongradcolor1, ongradcolor2, style +""" + +fbinshift_tilde = MaxObject('fbinshift~') +""" +fbinshift~ - Frequency domain frequency shifter for pfft~ + +The fbinshift~ object implements a frequency-domain frequency shifter that can be used inside a patch loaded by a pfft~ object. + +Args: + frequency-shift (int, required) + frequency-shift (float, optional) + +Inlets: + 0 (signal): real/x input + 1 (signal): imaginary/y input + 2 (double): Amount of Frequency Shift (Hz) + +Outlets: + 0 (signal): bin-shifted real/x output + 1 (signal): bin-shifted imaginary/y output + +Messages: ft2, signal +""" + +fffb_tilde = MaxObject('fffb~') +""" +fffb~ - Fast fixed filter bank + +The fffb~ object implements a bank of bandpass filter objects, each of which is similar to the reson~ filter object. An input signal is applied to all filters, and the outputs of each filter are available separately. When the fffb~ object is instantiated as mcs.fffb~ the object has a single multichannel output containing the individual filters. Otherwise it has a separate outlet for each filter. + +Args: + number-of-filters (int, required) + 1st-filter-frequency (float, optional) + filter-frequency-ratios (float) (float, optional) + Q (list, optional) + harmonic-series-flag (H) (symbol, optional) + +Inlets: + 0 (signal): signal input, lists for setting parameters + +Outlets: + 0 (signal): signal output from filter 0 + 1 (signal): Output from Filter 1 + 2 (signal): Output from Filter 2 + 3 (signal): Output from Filter 3 + +Messages: list, anything, Q, QAll, clear, freq, freqAll, freqRatio, gain, gainAll, signal +""" + +fft_tilde = MaxObject('fft~') +""" +fft~ - Fast Fourier transform + +fft~ performs a Fast Fourier transform on any incoming signal and outputs the real and imaginary parts of that transform as well as a synchronization signal. + +Args: + number-of-FFT-samples (int, optional) + interval (int, optional) + offset (int, optional) + +Inlets: + 0 (signal): (signal) Real Input + 1 (signal): (signal) Imaginary Input + +Outlets: + 0 (signal): (signal) Real Output + 1 (signal): (signal) Imaginary Output + 2 (signal): (signal) Ramp from 0 to Number of Points - 1 + +Messages: phase, signal + +Attributes: fftsize, float32, interval, legacy, offset +""" + +fftin_tilde = MaxObject('fftin~') +""" +fftin~ - Input for a patcher loaded by pfft~ + +The fftin~ object provides an signal input to a patcher loaded by a pfft~ object. + +Args: + inlet-assignment (int, required) + window-envelope-function (symbol, optional) + +Inlets: + 0 (signal): Dummy + +Outlets: + 0 (signal): Real Input 1 to Patcher + 1 (signal): Imaginary Input 1 to Patcher + 2 (signal): FFT Bin Index + +Messages: signal + +Attributes: nofft, userwindow, window +""" + +fftinfo_tilde = MaxObject('fftinfo~') +""" +fftinfo~ - Report information about a patcher loaded by pfft~ + +fftinfo~ gets info about the fft frames in a patcher loaded by a pfft~. It reports the information when sent a bang or whenever DSP is turned on via a dac~ ( fftinfo~ only functions within a pfft~). + +Inlets: + 0 (signal): (signal) Dummy + +Outlets: + 0 (int): (int) FFT Frame Size + 1 (int): (int) Spectral Frame Size + 2 (int): (int) FFT Hop Size + 3 (int): (int) Full Spectrum Flag (0/1) + +Messages: bang, signal +""" + +fftout_tilde = MaxObject('fftout~') +""" +fftout~ - Output for a patcher loaded by pfft~ + +The fftout~ object provides an signal output to a pfft~ object. + +Args: + outlet-assignment (int, required) + phase-offset (float, optional) + window-envelope-function (symbol, optional) + +Inlets: + 0 (signal): Real Output 1 of Patcher + 1 (signal): Imaginary Output 1 of Patcher + +Messages: signal + +Attributes: nofft, overlapscale, userwindow, window, windowsqueeze +""" + +filtercoeff_tilde = MaxObject('filtercoeff~') +""" +filtercoeff~ - Signal-rate filter coefficient generator + +The filtercoeff~ object is a signal-rate filter coefficient calculator for the biquad~ object. It calculates the filter coefficients from three higher-level parameters: frequency, amplitude and resonance (Q) or slope (S). Its internal calculations are based on those of the filtergraph~ object. + +Args: + default-filter-type (symbol, optional) + resampling-factor (int, optional) + +Inlets: + 0 (signal/float): (signal/float) Frequency + 1 (signal/float): (signal/float) Gain + 2 (signal/float): (signal/float) Q + +Outlets: + 0 (signal): (signal) Gain (FF Coefficient 0) + 1 (signal): (signal) FF Coefficient 1 + 2 (signal): (signal) FF Coefficient 2 + 3 (signal): (signal) FB Coefficient 1 + 4 (signal): (signal) FB Coefficient 2 + +Messages: int, float, list, allpass, bandpass, bandstop, gainapass, gainbpass, gainbstop, gainhpass, gainlpass, gainresonant, highpass, highshelf, lowpass, lowshelf, off, peaknotch, resamp, resonant, signal +""" + +filterdesign = MaxObject('filterdesign') +""" +filterdesign - Create a filter specification + +Use the filterdesign object to create a dictionary containing a specification for a filter that can be realized by several other objects including the cascade~ object. + +Inlets: + 0 (INLET_TYPE): bang generates filter responses + +Outlets: + 0 (OUTLET_TYPE): filter coefficients + +Messages: bang, (mouse) + +Attributes: frequency, name, order, passband_ripple, response, samplerate, sos_output, stopband_attenuation, tf_output, topology, units, zpk_output +""" + +filterdetail = MaxObject('filterdetail') +""" +filterdetail - Detail the characteristics of a filter + +Use the filterdetail object to produce details from a filter specification provided as input. The filter specification may be generated by the filterdesign object, or by other means. The output includes the impulse response, step response, magnitude and phase responses, as well as phase and group delay. + +Inlets: + 0 (INLET_TYPE): bang generates filter responses + +Outlets: + 0 (OUTLET_TYPE): magnitude response + 1 (OUTLET_TYPE): phase response + 2 (OUTLET_TYPE): phase delay + 3 (OUTLET_TYPE): group delay + 4 (OUTLET_TYPE): impulse response + 5 (OUTLET_TYPE): step response + +Messages: list, dictionary + +Attributes: numpoints +""" + +filtergraph_tilde = MaxObject('filtergraph~') +""" +filtergraph~ - Filter editor + +Use the filtergraph~ object to generate filter coefficients for the biquad~ or cascade~ objects with a graphical interface. + +Inlets: + 0 (float): a0 coefficient + 1 (float): a1 coefficient + 2 (float): a2 coefficient + 3 (float): b1 coefficient + 4 (float): b2 coefficient + 5 (float): Cutoff or Center Frequency + 6 (float): Gain (Linear) + 7 (float): Q (Resonance) or S (Slope) + +Outlets: + 0 (list): List of Filter Coefficients + 1 (float): Frequency Out + 2 (float): Gain (Linear) Out + 3 (float): Q (Resonance) or S (Slope) Out + 4 (float): Bandwidth Out + 5 (list): Query Result (amp, phase) + 6 (int): Filter Index Out + +Messages: bang, int, float, list, anything, allpass, analog, bandpass, bandstop, cascade, constraints, dictionary, display, displaydot, flat, gainmode, highorder, highpass, highshelf, lowpass, lowshelf, markers, mode, (mouse), options, params, peaknotch, query, resonant, selectfilt, set, setconstraints, setfilter, setoptions, setparams, whichfilt + +Attributes: annotation_name, autoout, bgcolor, bordercolor, bwidthcolor, curvecolor, dbdisplay, display_flat, domain, edit_Q, edit_amp, edit_analog, edit_displaydot, edit_filter, edit_freq, edit_gainmode, edit_maxQ, edit_maxamp, edit_maxfreq, edit_minQ, edit_minamp, edit_minfreq, edit_mode, fgcolor, fullspect, hbwidthcolor, hcurvecolor, hfgcolor, linmarkers, logamp, logfreq, logmarkers, markercolor, nfilters, numdisplay, param_connect, parameter_enable, parameter_mappable, phasespect, range, style, textcolor +""" + +frame_tilde = MaxObject('frame~') +""" +frame~ - Output a list as an FFT frame or a signal vector + +The frame~ object is similar to the MSP sig~ object, but it provides a way to output lists inside a patcher loaded by the pfft~ object or to provide signal vector information outside of the pfft~ domain. + +Inlets: + 0 (list): a list of floating point values + +Outlets: + 0 (signal): output frame + +Messages: int, float, list, anything, fill, mirror +""" + +frameaccum_tilde = MaxObject('frameaccum~') +""" +frameaccum~ - Compute "running phase" of successive phase deviation frames + +frameaccum~ computes a running phase by keeping a sum of the values in each position of its incoming signal vectors. When used inside a pfft~ object, it can keep a running phase of the FFT because the FFT size is equal to the signal vector size. + +Args: + phasewrap-flag (0 or nonzero) (int, optional) + +Inlets: + 0 (signal): (signal) Input FFT Phase Deviation + +Outlets: + 0 (signal): (signal) FFT Running Phase Output + +Messages: clear, signal +""" + +frameaverage_tilde = MaxObject('frameaverage~') +""" +frameaverage~ - Perform a piece-wise running averaging of consecutive frames of audio. + +The frameaverage~ object performs a piece-wise running averaging of consecutive frames of audio. Where the framesmooth~ object can be seen as smoothing in the frequency domain (when using FFT as input), the frameaverage~ object can be seen as performing temporal smoothing, more analogous to the vectral~ object. + +Inlets: + 0 (signal): Input FFT Phase Deviation + +Outlets: + 0 (signal): FFT Running Phase Output + +Messages: clear, signal + +Attributes: framecount, framesize +""" + +framedelta_tilde = MaxObject('framedelta~') +""" +framedelta~ - Compute phase deviation between successive FFT frames + +framedelta~ computes a running phase deviation by subtracting values in each position of its previously received signal vector from the current signal vector. When used inside a pfft~ object, it keeps a running phase deviation of the FFT because the FFT size is equal to the signal vector size. + +Inlets: + 0 (signal): (signal) FFT Phase Frame + +Outlets: + 0 (signal): (signal) FFT Phase Deviation + +Messages: clear, signal +""" + +framesmooth_tilde = MaxObject('framesmooth~') +""" +framesmooth~ - Perform averaging of consecutive samples, grouped into frames, without blurring across the frames. + +The framesmooth~ object performs averaging of consecutive samples, grouped into frames, without blurring across the frames. + +Inlets: + 0 (signal): Input FFT Phase Deviation + +Outlets: + 0 (signal): FFT Running Phase Output + +Messages: clear, signal + +Attributes: framesize, smoothness +""" + +framesnap_tilde = MaxObject('framesnap~') +""" +framesnap~ - Output an FFT frame or signal vector as a list + +The framesnap~ object is similar to snapshot~ but outputs a list with the contents of a signal vector convenient for capturing an FFT frame when used inside a pfft~ object. + +Args: + interval (int, optional) + +Inlets: + 0 (signal): Input, bang Reports Frame + 1 (signal): Internal Clock Interval in ms + +Outlets: + 0 (list): Output Frame as a list + +Messages: bang, int, float, list, anything, sampleinterval, signal, start, stop + +Attributes: active, interval +""" + +freqshift_tilde = MaxObject('freqshift~') +""" +freqshift~ - Time-domain frequency shifter + +freqshift~ is a time-domain frequency shifter (also known as a single-sideband ring modulator). + +Args: + frequency-shift (int, required) + frequency-shift (float, optional) + +Inlets: + 0 (signal): (signal) Audio Signal to be Shifted + 1 (signal/float): (signal/float) Amount of Frequency Shift (Hz) + +Outlets: + 0 (signal): (signal) Frequency-shifted Signal (Positive Sideband) + 1 (signal): (signal) Frequency-shifted Signal (Negative Sideband) + +Messages: int, float, clear, resetphase, signal +""" + +ftom_tilde = MaxObject('ftom~') +""" +ftom~ - Convert frequency to MIDI note numbers at signal-rate + +Use ftom~ to convert frequency to MIDI note numbers at signal rate + +Inlets: + 0 (signal): Frequency in Hz + +Outlets: + 0 (signal): Floating-point MIDI Note Number + +Messages: signal + +Attributes: base, map, mapname, mid, ref, scale, scalename +""" + +fzero_tilde = MaxObject('fzero~') +""" +fzero~ - Fundamental frequency and pitch estimator + +The fzero~ object estimates the fundamental frequency of an an incoming, monophonic audio signal. It performs multiple layers of wavelet transforms on an incoming vector, comparing the spacing between the peaks in each. + +Inlets: + 0 (signal): Audio to be analyzed + +Outlets: + 0 (float): Estimated fundamental pitch + 1 (float): Peak amplitude in analysis vector + 2 (bang): onset detected + +Messages: signal + +Attributes: freqmax, freqmin, onsetamp, onsetlist, onsetperiod, onsetpitch, period, quiet, size, threshold +""" + +gain_tilde = MaxObject('gain~') +""" +gain~ - Gain control + +gain~ is a slider that scales signals. It can also make a smooth transition as you move from one value of the slider to the next. + +Inlets: + 0 (signal): Input to Scale, int Sets Value + +Outlets: + 0 (signal): Scaled Output + 1 (signal): Slider Value + +Messages: bang, int, float, list, color, ft1, (mouse), set, setvalue, signal + +Attributes: annotation_name, bgcolor, bordercolor, inc, interp, interpinlet, knobcolor, multislider, orientation, param_connect, parameter_enable, parameter_mappable, relative, scale, size, stripecolor, style +""" + +gate_tilde = MaxObject('gate~') +""" +gate~ - Route a signal to one of several outlets + +Use gate~ to route an input signal at the second inlet to one of several outlets, or to no outlet at all. When there is only one outlet (the default case), it acts as a simple switch. Unlike the Max gate object, any outlet which is not selected outputs a signal composed of zero values. + + When the gate~ object is created as mcs.gate~ all of its signal outlets are combined into a single multichannel outlet. The behavior of mcs.gate~ is otherwise identical to gate~. + +Args: + number-of-outlets (int, optional) + initial-open-outlet (int, optional) + +Inlets: + 0 (int/signal): int/signal Turns Input Off or Routes to Output + 1 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Output + +Messages: bang, int, float, next, signal + +Attributes: ramptime, stepmode +""" + +gen = MaxObject('gen') +""" +gen - Generate native audio event processing routines + +The gen object turns an embedded Gen patcher into event processing routines analagous to what the gen~ object does for audio signals. The Gen patcher can be built from a wide set of low-level Gen operator objects as well as embedded code expressions. + +Args: + patcher-name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): in 1 + 1 (INLET_TYPE): in 2 + +Outlets: + 0 (OUTLET_TYPE): out 1 + +Messages: bang, int, float, (mouse), exportcode, open, reload, reset, reset_param, set, wclose + +Attributes: active, autoexport, cpu, cpumeasure, dumpoutlet, exportfolder, exportname, exportnotifier, exportscript, exportscriptargs, gen, hot, interval, nocache, poll, title +""" + +gen_codebox = MaxObject('gen.codebox') +""" +gen.codebox + +Inlets: + 0 (INLET_TYPE): in1 + 1 (INLET_TYPE): in2 + +Outlets: + 0 (OUTLET_TYPE): out1 + +Messages: (mouse), exportcode, open, int, float, set, bang, reload, wclose, reset, reset_param + +Attributes: bgcolor, linenumbers, linenumberwidth, margin, style, textcolor, title, poll, exportscriptargs, exportscript, exportnotifier, exportname, exportfolder, dumpoutlet, gen, cpumeasure, cpu, autoexport, hot, active, interval, nocache +""" + +gen_codebox_tilde = MaxObject('gen.codebox~') +""" +gen.codebox~ - Generate native audio signal processing routines + +The gen.codebox~ object is a UI object for display and editing of GenExpr code to be converted into signal processing routines of optimized native machine code. + +Inlets: + 0 (INLET_TYPE): in 1 + 1 (INLET_TYPE): in 2 + +Outlets: + 0 (OUTLET_TYPE): out 1 + +Messages: reset_param, reset, wclose, reload, float, int, signal, open, exportcode, (mouse) + +Attributes: bgcolor, linenumbers, linenumberwidth, margin, style, textcolor, autoexport, cpu, cpumeasure, gen, dumpoutlet, exportfolder, title, nocache, poll, exportscriptargs, exportscript, exportnotifier, exportname +""" + +gen_tilde = MaxObject('gen~') +""" +gen~ - Generate native audio signal processing routines + +The gen~ object turns an embedded Gen patcher into signal processing routines of optimized native machine code. The Gen patcher can be built from a wide set of low-level Gen operator objects as well as embedded code expressions. + +Args: + patcher-name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): in 1 + 1 (INLET_TYPE): in 2 + +Outlets: + 0 (OUTLET_TYPE): out 1 + +Messages: int, float, (mouse), exportcode, open, reload, reset, reset_param, signal, wclose + +Attributes: autoexport, cpu, cpumeasure, dumpoutlet, exportfolder, exportname, exportnotifier, exportscript, exportscriptargs, gen, nocache, poll, title +""" + +gizmo_tilde = MaxObject('gizmo~') +""" +gizmo~ - Frequency-domain pitch shifter for pfft~ + +The gizmo~ object implements a frequency-domain pitch shifter. It works by analyzing the frequency bins of an FFT'd signal, finding the peaks in the spectrum, and shifting them along the frequency axis to transpose the sound. + +Args: + default-pitch-scalar (int, float, optional) + +Inlets: + 0 (signal): (signal) Real Signal from fftin~ + 1 (signal): (signal) Imaginary Signal from fftin~ + 2 (float): (float) Scalar to Shift Pitch (1.0 = No Transposition) + +Outlets: + 0 (signal): (signal) Pitch-shifted Real Signal + 1 (signal): (signal) Pitch-shifted Imaginary Signal + +Messages: clip, freqshift, ft2, signal +""" + +greaterthan_tilde = MaxObject('greaterthan~') +""" +greaterthan~ - Is greater than, comparison of two signals + +>~ outputs a 1 signal when the left input is greater-than the right input and a 0 when it is less-than or equal-to the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (signal/float): (signal) This > Right Inlet + 1 (signal/float): (signal/float) Left Inlet > This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal +""" + +greaterthaneq_tilde = MaxObject('greaterthaneq~') +""" +greaterthaneq~ - Is greater than or equal to, comparison of two signals + +>=~ outputs a 1 signal when the left input is greater-than or equal-to the right input and a 0 when it is less-than the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (signal/float): (signal) This >= Right Inlet + 1 (signal/float): (signal/float) Left Inlet >= This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal + +Attributes: fuzzy +""" + +gridmeter_tilde = MaxObject('gridmeter~') +""" +gridmeter~ - Display signal levels as brightness + +The gridmeter~ object displays the RMS levels of multiple signals (usually from a multichannel Max object) as brightness, and will indicate the presence or absence of an input signal. + +Inlets: + 0 (multi-channel signal): Input + +Outlets: + 0 (multi-channel signal): Output + +Messages: int, float, list, (mouse), mute, muteall, signal, solo + +Attributes: attack, bgcolor, cellheight, cellwidth, color, columns, contrast, dividersize, elementcolor, hotcolor, interval, range, release, shape, style +""" + +groove_tilde = MaxObject('groove~') +""" +groove~ - Variable-rate looping sample playback + +The groove~ object is a variable-rate, looping, sample-playback object which references the audio information stored in a buffer~ object having the same name. When the groove~ object is instantiated as mcs.groove~ its audio outputs are combined into a single multichannel output. + +Args: + buffer-name (symbol, required) + number-of-outputs (int, optional) + +Inlets: + 0 (signal): Sample Playback Increment + 1 (signal/float): Loop Min + 2 (signal/float): Loop Max + +Outlets: + 0 (signal): Channel 1 Output + 1 (signal): Loop Sync Output + +Messages: int, float, list, anything, clearspeedcues, (mouse), dictionary, endloop, printspeedcues, reset, set, setloop, signal, startloop, stop + +Attributes: basictuning, followglobaltempo, formant, formantcorrection, lock, loop, loopend, loopinterp, loopstart, mode, name, originallength, originaltempo, phase, pitchcorrection, pitchshift, pitchshiftcent, quality, slurtime, timestretch, transport +""" + +hilbert_tilde = MaxObject('hilbert~') +""" +hilbert~ - Phase quadrature filter + +hilbert~ is a 6th order hilbert transformer with a minimum of error. + +Inlets: + 0 (signal): (signal) input signal + +Outlets: + 0 (signal): (signal) cosine/real output + 1 (signal): (signal) sine/imag output + +Messages: clear, signal +""" + +ifft_tilde = MaxObject('ifft~') +""" +ifft~ - Inverse fast Fourier transform + +ifft~ performs an Inverse FFT (inverse fast Fourier transform) on an input signal. + +Args: + number-of-IFFT-samples (int, optional) + interval (int, optional) + offset (int, optional) + +Inlets: + 0 (signal): (signal) Real Input + 1 (signal): (signal) Imaginary Input + +Outlets: + 0 (signal): (signal) Real Output + 1 (signal): (signal) Imaginary Output + 2 (signal): (signal) Ramp from 0 to Number of Points - 1 + +Messages: phase, signal + +Attributes: fftsize, float32, interval, legacy, offset +""" + +in_ = MaxObject('in') +""" +in - Message input for a patcher loaded by poly~ or pfft~ + +in defines a message inlet for a patcher loaded by poly~ or pfft~. + +Args: + inlet-number/positioning (int, required) + +Inlets: + 0 (INLET_TYPE): Dummy + +Outlets: + 0 (OUTLET_TYPE): Input 1 to Patcher + +Messages: comment + +Attributes: attr_comment +""" + +in_tilde = MaxObject('in~') +""" +in~ - Signal input for a patcher loaded by poly~ + +Use the in~ object inside a patcher loaded by the poly~ object to create a patcher signal inlet. + +Args: + inlet-number (int, required) + +Inlets: + 0 (signal): Dummy + +Outlets: + 0 (signal): Input 1 + +Messages: comment, signal + +Attributes: attr_comment, chans +""" + +index_tilde = MaxObject('index~') +""" +index~ - Read from a buffer~ with no interpolation + +Use index~ to read from a buffer~ object at a signal-driven sample index with no interpolation on the output. + +Args: + buffer-name (symbol, required) + buffer-channel-to-index (int, optional) + +Inlets: + 0 (signal): Sample Index + 1 (signal): Audio Channel In buffer~ + +Outlets: + 0 (signal): Sample Value at Index + 1 (signal): Audio Channel In buffer~ + +Messages: int, float, (mouse), set, signal +""" + +info_tilde = MaxObject('info~') +""" +info~ - Report information about a sample + +Use the info~ object to report the information in a file read into a buffer~ object in response to a bang. If the information is not present, it will be 0. info~ does not require that the audio be turned on in order to work. Looping and tuning information is found in AIFF files. + +Args: + buffer-name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): bang Outputs the Information + +Outlets: + 0 (OUTLET_TYPE): Sampling Rate + 1 (OUTLET_TYPE): Sample Instrument Info (list) + 2 (OUTLET_TYPE): Sustain Loop Start (msec) + 3 (OUTLET_TYPE): Sustain Loop End (msec) + 4 (OUTLET_TYPE): Release Loop Start (msec) + 5 (OUTLET_TYPE): Release Loop End (msec) + 6 (OUTLET_TYPE): Total Time (msec) + 7 (OUTLET_TYPE): Most Recent Filename + 8 (OUTLET_TYPE): Number of Channel(s) + 9 (OUTLET_TYPE): Most Recent File Full Pathname + +Messages: bang, (mouse), set +""" + +ioscbank_tilde = MaxObject('ioscbank~') +""" +ioscbank~ - Interpolating oscillator bank + +ioscbank~ is an interpolated oscillator bank with signal inputs to set oscillator frequency and magnitude. + +Args: + number-of-oscillators (int, optional) + frequency-smoothing-factor (int, optional) + amplitude-smoothing-factor (int, optional) + +Inlets: + 0 (signal/float): (signal/float) Freq + 1 (signal/float): (signal/float) Mag + 2 (signal/float): (signal/float) Phase + 3 (signal/float): (signal/float) Index + +Outlets: + 0 (signal): (signal) output + +Messages: int, float, clear, copybuf, framesync, freqsmooth, magsmooth, set, signal, silence, size +""" + +kink_tilde = MaxObject('kink~') +""" +kink~ - Distort a sawtooth waveform + +kink~ takes phasor~ values and distorts them according to a slope factor. If the input times the slope is less than 0.5, that value is output. Otherwise, a complentary slope is used, equal to 0.5 at the same input value but equal to 1 when the input is 1. This creates a bend or "kink" in the phase waveform when the slope is not equal to 1. + +Args: + slope-multiplier (float, optional) + +Inlets: + 0 (signal): (signal) Phase Input from 0-1 + 1 (signal/float): (signal/float) Slope (Kinkiness) + +Outlets: + 0 (signal): (signal) Disorted Phase Output + +Messages: int, float, signal +""" + +lessthan_tilde = MaxObject('lessthan~') +""" +lessthan~ - Is less than, comparison of two signals + +<~ outputs a 1 signal when the left input is less-than the right input and a 0 when it is greater-than or equal-to the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (int, float, optional) + +Inlets: + 0 (signal/float): (signal) This < Right Inlet + 1 (signal/float): (signal/float) Left Inlet < This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal +""" + +lessthaneq_tilde = MaxObject('lessthaneq~') +""" +lessthaneq~ - Is less than or equal to, comparison of two signals + +<=~ outputs a 1 signal when the left input is less-than or equal-to the right input and a 0 when it is less-than the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (signal/float): (signal) This <= Right Inlet + 1 (signal/float): (signal/float) Left Inlet <= This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal + +Attributes: fuzzy +""" + +levelmeter_tilde = MaxObject('levelmeter~') +""" +levelmeter~ - RMS level meter + +Use the levelmeter~ when you need a signal level-meter with ballistics. The meter~ object provides metering in a simpler and more compact form. + +Inlets: + 0 (INLET_TYPE): signal to be monitored + +Outlets: + 0 (OUTLET_TYPE): volume unit (dB) + +Messages: bang, int, clear, mode, (mouse), signal + +Attributes: attack, bgcolor, bordercolor, coolcolor, displaychan, fgcolor, hotcolor, inactivealpha, interval, markercolor, markers, markersused, needlecolor, offset, overloadcolor, range, release, rounded, style, tepidcolor, warmcolor +""" + +limi_tilde = MaxObject('limi~') +""" +limi~ - Lookahead peak-limiter + +Lookahead peak-limiter. + +Args: + channel_count (int, optional) + buffer_size (int, optional) + +Inlets: + 0 (signal): Input + +Outlets: + 0 (signal): Output + +Messages: clear, signal + +Attributes: bypass, dcblock, lookahead, mode, postamp, preamp, release, threshold +""" + +line_tilde = MaxObject('line~') +""" +line~ - Linear signal ramp generator + +Use the line~ object to generate a signal ramp or envelope. It uses the Max time format syntax; envelope times can be either single valued fixed or tempo-relative. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Destination Value + 1 (INLET_TYPE): Ramp Time + +Outlets: + 0 (signal): Output Ramp + 1 (signal): bang When Line Reaches Destination + +Messages: int, float, list, anything, pause, resume, stop + +Attributes: activeout, maxpoints +""" + +log_tilde = MaxObject('log~') +""" +log~ - Logarithm of a signal + +Use the log~ object to output a signal composed of the logarithms of its input values. You can specify the logarithmic base. + +Args: + logarithmic-base (number, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): Base + +Outlets: + 0 (signal): (signal) log of Input to Base + +Messages: float, signal +""" + +lookup_tilde = MaxObject('lookup~') +""" +lookup~ - Transfer function lookup table + +lookup~ allows you to use a table of samples (buffer~ object) to do waveshaping on a signal, in which the Y values of an input signal are used as X values to look up new signal values. Input values of -1 to +1 are mapped to table values between 0 (or the specified sample offset) and the size of the table. + +Args: + buffer-name (symbol, required) + sample-offset (int, optional) + +Inlets: + 0 (signal): Input To Distort + 1 (signal/float): Sample Offset + 2 (signal/float): Lookup Table Size + +Outlets: + 0 (signal): Distorted Output + +Messages: int, float, (mouse), set, signal + +Attributes: chan, offset, size +""" + +lores_tilde = MaxObject('lores~') +""" +lores~ - Resonant lowpass filter + +lores~ implements an inexpensive lowpass with an adjustment that lets you add a specified resonance. The middle inlet sets a kind of cutoff frequency, but the sharpness of the filter depends on the resonance passed in through the right inlet (0 is a little bit sharp and 1 as sharp as possible). + +Args: + cutoff (number, optional) + resonance (number, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Cutoff Frequency + 2 (signal/float): (signal/float) Resonance Control (0-1) + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, clear, signal + +Attributes: cutoff, resonance +""" + +loudness_tilde = MaxObject('loudness~') +""" +loudness~ - Report loudness of a signal + +The loudness~ object reports the loudness of a signal according to the EBU R 128 standard. Momentary, short term, and integrated loudness measures are reported in LUFS (loudness units referenced to full scale). Additionally, the signal's loudness range is reported in loudness units, while sample peak true peak values are reported in dB. You can use these measurements to normalize audio signals for various broadcast and streaming platforms. + +Args: + channelcount (int, optional) + +Inlets: + 0 (signal): (signal) any signal, (bang) report peak amplitude + +Outlets: + 0 (float): Momentary Loudness in LUFS + 1 (float): Short-Term Loudness in LUFS + 2 (float): Integrated Loudness in LUFS + 3 (float): Loudness Range + 4 (float): Peak Sample Value + 5 (float): True Peak Value + +Messages: bang, int, float, reset, signal + +Attributes: channel, inputs, interval +""" + +matrix_tilde = MaxObject('matrix~') +""" +matrix~ - Signal routing and mixing matrix + +matrix~ is an array of signal connectors and mixers (adders). It can have any number of inlets and outlets. Signals entering at each inlet can be routed to one or more of the outlets, with a variable amount of gain. If an outlet is connected to more than one inlet, its output signal is the sum of the signals from the inlets. + + When the matrix~ object is created as mcs.matrix~ all of its signal inlets are combined into a single multichannel inlet and all of its signal outlets are combined into a single multichannel outlet. The behavior of mcs.matrix~ is otherwise identical to matrix~. + +Args: + inlets (int, required) + outlets (int, required) + default-connect-gain (float, optional) + +Inlets: + 0 (signal): Input 0, connect (list), disconnect (list) + 1 (signal): Input 1 + +Outlets: + 0 (signal): Output 0 + 1 (signal): Output 1 + 2 (list): Inlets Outlets Gains + +Messages: list, clear, connect, dictionary, disconnect, dump, dumpconnections, dumptarget, print + +Attributes: exclusive, ramp +""" + +maximum_tilde = MaxObject('maximum~') +""" +maximum~ - Compare two signals, output the maximum + +maximum~ outputs a signal which is the maximum of two input signals. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (Signal): (signal) Signal to be compared with Right Inlet + 1 (Signal): (signal) Signal to be compared with Left Inlet + +Outlets: + 0 (Signal): (signal) Maximum of Left and Right Signals + +Messages: int, float, signal +""" + +mc_2d_wave_tilde = MaxObject('mc.2d.wave~') +""" +mc.2d.wave~ - Two-dimensional wavetable (multichannel) + +2d.wave~ is similar to wave~, but with an additional axis. A given ms range of an audio file will be divided into n rows. Y phase input will determine which row(s) will be used for playback. When the 2d.wave~ object is instantiated as mcs.2d.wave~ its outputs are combined into a single multichannel output but otherwise it functions identically to 2d.wave~. + +Args: + buffer-name (symbol, required) + start and end-points (number, optional) + number-of-output-channels (int, optional) + rows (int, optional) + +Inlets: + 0 (signal): (signal) X Table Position (from 0 to 1) + 1 (signal): (signal) Y Table Position (from 0 to 1) + 2 (signal/float): (signal/float) Starting Table Location in ms + 3 (signal/float): (signal/float) Ending Table Location in ms + +Outlets: + 0 (signal): (signal) Channel 1 Output + +Messages: int, float, list, (mouse), rows, set, signal +""" + +mc_abs_tilde = MaxObject('mc.abs~') +""" +mc.abs~ - Absolute value of a signal (multichannel) + +Use the abs~ object to take any given signal and output only the absolute (non-negative) translation of that signal (i.e. a rectified waveform). All negative values in the input signal are converted to positive values in the output. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Absolute Value of Input + +Messages: signal +""" + +mc_acos_tilde = MaxObject('mc.acos~') +""" +mc.acos~ - Signal arc-cosine function (multichannel) + +Use the acos~ object to calculate and output a signal that is the arc-cosine function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Acos (x) Out + +Messages: signal +""" + +mc_acosh_tilde = MaxObject('mc.acosh~') +""" +mc.acosh~ - Signal hyperbolic arc-cosine function (multichannel) + +Use the acosh~ object to calculate and output a signal that is the hyperbolic arc-cosine function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Acosh (x) Out + +Messages: signal +""" + +mc_adc_tilde = MaxObject('mc.adc~') +""" +mc.adc~ - Multichannel audio input and on/off + +The mc.adc~ ("analog-to-digital converter") object outputs a multichannel signal with audio from hardware input devices. + +Args: + inputs (symbol, optional) + +Inlets: + 0 (INLET_TYPE): start, stop Turn Audio On and Off + +Outlets: + 0 (multi-channel signal): Audio Input (multichannel) + +Messages: int, list, (mouse), open, set, start, startwindow, stop, wclose +""" + +mc_adsr_tilde = MaxObject('mc.adsr~') +""" +mc.adsr~ - ADSR envelope generator (multichannel) + +The adsr~ object is an Attack-Decay-Sustain-Release signal controllable by signals. In some situations, a combination of the function and line~ objects may be a useful alternative. + +Args: + attack (float, optional) + decay (float, optional) + sustain (float, optional) + release (float, optional) + +Inlets: + 0 (signal/float): trigger + 1 (signal/float): attack + 2 (signal/float): decay + 3 (signal/float): sustain + 4 (signal/float): release + +Outlets: + 0 (signal): ADSR envelope + 1 (signal): new envelope trigger + 2 (message): mute outlet + 3 (message): dump outlet + +Messages: int, float, list, anything, signal + +Attributes: attack, decay, legato, maxsustain, release, retrigger, sustain, triggermode +""" + +mc_allpass_tilde = MaxObject('mc.allpass~') +""" +mc.allpass~ - Apply an allpass filter effect (multichannel) + +Use the allpass~ object to filter an input with an allpass filter. The allpass filter has a flat magnitude response but a complex phase response, typically delaying sharp transients. + +Args: + max-delay (float, optional) + initial-delay (float, optional) + gain (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Delay in ms + 2 (signal/float): (signal/float) Gain Coefficient + +Outlets: + 0 (signal): (signal) Filter Output + +Messages: float, clear, signal +""" + +mc_amxd_tilde = MaxObject('mc.amxd~') +""" +mc.amxd~ - Host Max for Live devices (multichannel) + +Use the amxd~ object to load a Max for Live device and use it in MSP. When the amxd~ object is instantiated as mcs.amxd~ its audio inputs combined into a single multichannel input and its audio outputs are combined into a single multichannel output. + +Args: + devicename (symbol, required) + +Inlets: + 0 (signal): Channel 1 in + 1 (signal): Channel 2 in + 2 (signal): MIDI In + +Outlets: + 0 (signal): Channel 1 out + 1 (signal): Channel 2 out + 2 (signal): MIDI Out + 3 (signal): Info Out + +Messages: anything, (drag), (mouse), drag_replace, getinfo, getparams, getvalue, midievent, midiin, open, signal + +Attributes: active, annotation_name, autosave, autosize, latency, mcisolate, parameter_enable, patchername, realtime_params, showheader +""" + +mc_apply_tilde = MaxObject('mc.apply~') +""" +mc.apply~ - Apply a Function to a Multichannel Signal + +The mc.apply~ object accepts a breakpoint function in the same format as line~ and applies it over the space of channels of a multi-channel signal. Each channel contains a sample of the function evenly divided in the X dimension. In addition, mc.apply~ can store up to 64 functions, edited by mc.function, which you can recall and continuously interpolate using a signal input. + +Args: + channels (int, optional) + +Inlets: + 0 (signal, float): Function Index + 1 (float, list): Define Function in line~ Format + 2 (int): Current Function Number + +Outlets: + 0 (multi-channel signal): Function Applied to Channels + +Messages: int, float, list, signal + +Attributes: chans, functions, ramptime +""" + +mc_asin_tilde = MaxObject('mc.asin~') +""" +mc.asin~ - Signal arc-sine function (multichannel) + +Use the asin~ object to calculate and output a signal that is the arc-sine function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Asin (x) Out + +Messages: signal +""" + +mc_asinh_tilde = MaxObject('mc.asinh~') +""" +mc.asinh~ - Signal hyperbolic arc-sine function (multichannel) + +Use the asinh~ object to calculate and output a signal that is the hyperbolic arc-sine function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Asinh (x) Out + +Messages: signal +""" + +mc_assign = MaxObject('mc.assign') +""" +mc.assign - Assign Messages to MC Objects + +The mc.assign object assigns MC channels to incoming messages (numbers, lists, and symbols) according to patterns of channels and delays you define. + +Inlets: + 0 (INLET_TYPE): Message In + +Outlets: + 0 (OUTLET_TYPE): setvalue Message Output + +Messages: bang, int, float, list, anything + +Attributes: chans, delays, density, mode, pattern, pos +""" + +mc_atan2_tilde = MaxObject('mc.atan2~') +""" +mc.atan2~ - Signal arc-tangent function (two variables) (multichannel) + +Use the acosh~ object to take two given x and y values and output a signal which is their arc-tangent function, calculated as follows: + + Arc-tangent (y/x) + +Inlets: + 0 (signal): Y value + 1 (signal): X value + +Outlets: + 0 (signal): atan2(y/x) + +Messages: int, float, signal +""" + +mc_atan_tilde = MaxObject('mc.atan~') +""" +mc.atan~ - Signal arc-tangent function (multichannel) + +Use the atan~ object to calculate and output a signal that is the arc-tangent function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Atan (x) Out + +Messages: signal +""" + +mc_atanh_tilde = MaxObject('mc.atanh~') +""" +mc.atanh~ - Signal hyperbolic arc-tangent function (multichannel) + +Use the atanh~ object to calculate and output a signal that is the hyperbolic arc-tangent function of each sample of the input signal. + +Inlets: + 0 (signal): Input Signal + +Outlets: + 0 (signal): Atanh (x) Out + +Messages: signal +""" + +mc_atodb_tilde = MaxObject('mc.atodb~') +""" +mc.atodb~ - Convert a linear value to a signal-rate deciBel value (multichannel) + +Use the atodb~ to convert a signal representing a linear value to a deciBel equivalent. + +Inlets: + 0 (signal): (signal) Amplitude Scalar + +Outlets: + 0 (signal): (signal) Gain/Attenuation dB + +Messages: signal +""" + +mc_average_tilde = MaxObject('mc.average~') +""" +mc.average~ - Multi-mode signal average (multichannel) + +Use the average~ to perform bipolar, absolute, or rms averaging on any input signal. + +Args: + max-averaging-interval (int, optional) + averaging-mode (symbol, optional) + +Inlets: + 0 (signal): (signal) Input and Messages + +Outlets: + 0 (signal): (signal) Running Mean Average Out + +Messages: int, absolute, bipolar, rms, signal + +Attributes: mode +""" + +mc_avg_tilde = MaxObject('mc.avg~') +""" +mc.avg~ - Signal average (multichannel) + +Use the avg~ object to keep track of the average (absolute) amplitude of the input signal received over a specified time interval. + +Inlets: + 0 (signal): (signal) Input, bang Outputs Average + +Outlets: + 0 (float): (float) Average Value of Input Signal + +Messages: bang, signal +""" + +mc_bands_tilde = MaxObject('mc.bands~') +""" +mc.bands~ - Filter bank for MC + +mc.bands~ divides the spectrum of an audio signal into separate bands + with each band represented as it's own channel of audio. + +Args: + number-of-bands (int, required) + +Messages: signal, float +""" + +mc_biquad_tilde = MaxObject('mc.biquad~') +""" +mc.biquad~ - Two-pole, two-zero filter (multichannel) + +biquad~ implements a two-pole, two-zero filter using the following equation: + + + y[n] = a0 * x[n] + a1 * x[n-1] + a2 * x[n-2] - b1 * y[n-1] - b2 * y[n-2] + + + You can specify the coefficients a0, a1, a2, b1, and b2 as signals or floats (if you make the filter explode by making the b coefficients too high, you can recover (after lowering them) with the clear message, or by turning the audio on and off). + +Args: + a0 (float, required) + a1 (float, required) + a2 (float, required) + b1 (float, required) + b2 (float, required) + +Inlets: + 0 (signal): Input + 1 (signal/float): Input Gain (Filter coefficient a0) + 2 (signal/float): Filter coefficient a1 + 3 (signal/float): Filter coefficient a2 + 4 (signal/float): Filter coefficient b1 + 5 (signal/float): Filter coefficient b2 + +Outlets: + 0 (signal): Output + +Messages: int, float, list, clear, dictionary, signal, stoke + +Attributes: smooth +""" + +mc_bitand_tilde = MaxObject('mc.bitand~') +""" +mc.bitand~ - Bitwise and-operation of floating point signals (multichannel) + +Use the bitand~ object to perform a bitwise intersection (a bitwise "and") on two incoming floating-point signals as either raw 32-bit data or as integer values. The output is a floating-point signal composed of those bits which are 1 in both numbers. + +Args: + bitmask (int, optional) + operational-mode (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/int): (signal/int) Bitwise mask + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, bits, signal + +Attributes: mode +""" + +mc_bitnot_tilde = MaxObject('mc.bitnot~') +""" +mc.bitnot~ - Bitwise inversion of a floating point signal (multichannel) + +Use the bitnot~ object to perform a bitwise inversion on an incoming floating-point signal as either raw 32-bit data or as an integer value. All bit values of 1 are set to 0, and vice versa. + +Args: + operational-mode (int, optional) + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal + +Attributes: mode +""" + +mc_bitor_tilde = MaxObject('mc.bitor~') +""" +mc.bitor~ - Bitwise or-operation of floating point signals (multichannel) + +Use the bitor~ object to perform a bitwise "or" on two incoming floating-point signals as either raw 32-bit data or as integer values. The bits of both incoming signals are compared, and a 1 is output if either of the two bit values is 1. The output is a floating-point signal composed of the resulting bit pattern. + +Args: + bitmask (int, optional) + operational-mode (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/int): (signal/int) Bitwise mask + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, bits, signal + +Attributes: mode +""" + +mc_bitsafe_tilde = MaxObject('mc.bitsafe~') +""" +mc.bitsafe~ - Replace NaN and infinite signal values with 0 (multichannel) + +Use the bitsafe~ object to detect NaN (not a number) and +/- infinity values in an incoming signal and replace those occurences with zero. This is useful in conjunction with the bitwise operators, or any other situation where these values are possible. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Output + +Messages: signal +""" + +mc_bitshift_tilde = MaxObject('mc.bitshift~') +""" +mc.bitshift~ - Bit shifting for floating point signals (multichannel) + +Use the bitshift~ object to perform bitwise operations on a floating point signal as bits or as an integer. + +Args: + number-of-bits/direction-of-shift (int, optional) + operational-mode (int, optional) + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, shift, signal + +Attributes: mode +""" + +mc_bitxor_tilde = MaxObject('mc.bitxor~') +""" +mc.bitxor~ - Bitwise exclusive-or-operation of floating point signals (multichannel) + +Use the bitxor~ object to perform a bitwise "exclusive or" operation on two incoming floating-point signals as either raw 32-bit data or as integer values. The bits of both incoming signals are compared, and the corresponding output bit will be set to 1 if the two bit values are different, and 0 if the two values are the same. The output is a floating-point signal composed of the resulting bit pattern. + +Args: + bitmask (int, optional) + operational-mode (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/int): (signal/int) Bitwise mask + +Outlets: + 0 (signal): (signal) Output + +Messages: int, bits, signal + +Attributes: mode +""" + +mc_buffir_tilde = MaxObject('mc.buffir~') +""" +mc.buffir~ - buffer-based FIR filter (multichannel) + +Use buffir~ object when you need a finite impulse response (FIR) filter that convolves an input signal with samples from an input buffer. + +Args: + buffer-name (symbol, required) + read-offset (int, float, optional) + read-duration (int, float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (int/float/sig): (int/float/sig) Begin (samples) + 2 (int/float/sig): (int/float/sig) Length (samples) + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, clear, (mouse), set, signal +""" + +mc_cartopol_tilde = MaxObject('mc.cartopol~') +""" +mc.cartopol~ - Signal Cartesian to Polar coordinate conversion (multichannel) + +Use the cartopol~ object to convert signal values representing cartesian coordinates to a signal composed of polar coordinates. + +Inlets: + 0 (signal): (signal) real/x input + 1 (signal): (signal) imaginary/y input + +Outlets: + 0 (signal): (signal) amplitude/alpha output + 1 (signal): (signal) phase/theta output + +Messages: signal +""" + +mc_cascade_tilde = MaxObject('mc.cascade~') +""" +mc.cascade~ - Cascaded series of biquad filters (multichannel) + +Use the cascade~ to filter an input signal using a series of biquad filters. + +Inlets: + 0 (signal): (signal) signal to be filtered + 1 (list): (signal) list of filter coefficients + +Outlets: + 0 (signal): (signal) filtered signal out + +Messages: list, bypass, clear, dictionary, signal, zero +""" + +mc_cell = MaxObject('mc.cell') +""" +mc.cell - Format messages from a jit.cellblock for use with MC objects + +The mc.cell objects takes a message from the left outlet of the jit.cellblock object and produces a corresponding setvalue message for use with MC objects to set a value for a specific channel. Since jit.cellblock column numbers are 0-relative and MC channel numbers are 1-relative, mc.cell adds 1 to the incoming column number. + +Inlets: + 0 (list): Column, Row, Value + +Outlets: + 0 (OUTLET_TYPE): setvalue Message Output + +Messages: list + +Attributes: columns, constant, message, numeric, row +""" + +mc_change_tilde = MaxObject('mc.change~') +""" +mc.change~ - Report signal direction (multichannel) + +Use the change object to monitor increase, decrease, or no change in a signal value. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) 0. if Unchanged; -1. (decreasing) or 1. (increasing) if Changed. + +Messages: float, signal +""" + +mc_channelcount_tilde = MaxObject('mc.channelcount~') +""" +mc.channelcount~ - Report channel count + +mc.channelcount~ outputs the number of channels in a multichannel signal connected to its inlet. Any message sent to its inlet triggers the channel count out its left outlet. A signal reports the channel count out the right outlet when the audio is turned on. + +Inlets: + 0 (multi-channel signal): input + +Outlets: + 0 (int): Channel Count of Input as int + 1 (signal): Channel Count of Input as signal + +Messages: bang, int, float, anything, signal + +Attributes: active +""" + +mc_chord_tilde = MaxObject('mc.chord~') +""" +mc.chord~ - Store and Recall Signal Values Associated with an Index + +The mc.chord~ object is something like a version of the Max coll object that generates audio signals. You can store lists (which you can think of as chords) of numbers associated with a unique index, then recall your lists with messages or signals. When recalled, list values are assigned to channels in a multi-channel signal according to one of several allocation modes. + +Args: + channels (int, optional) + +Inlets: + 0 (signal, list): Input + +Outlets: + 0 (multi-channel signal): List Values + 1 (multi-channel signal): 1 if On, 0 if Off + 2 (list): Chord as a List + 3 (int): Last Index Recalled + +Messages: bang, int, float, list, clear, delete, dictionary, signal, store + +Attributes: allocmode, busymapname, chans, embed, extendmode, inputmode, offmode, triggermode, usebusymap +""" + +mc_click_tilde = MaxObject('mc.click~') +""" +mc.click~ - Create an impulse (multichannel) + +Use the click~ to create and output an impulse which can be used as an impulse-trigger. + +Args: + wavetable-values (list, optional) + +Inlets: + 0 (INLET_TYPE): bang to Trigger Impulse + +Outlets: + 0 (signal): (signal) Impulse Signal Out + +Messages: bang, int, float, set, signal +""" + +mc_clip_tilde = MaxObject('mc.clip~') +""" +mc.clip~ - Limit signal amplitude (multichannel) + +Use the clip~ to constrain input signals between two specified values. + +Args: + minimum (float, optional) + maximum (float, optional) + +Inlets: + 0 (signal): (signal) Input to be Clipped + 1 (signal): Minimum Level + 2 (signal): Maximum Level + +Outlets: + 0 (signal): (signal) Clipped Output + +Messages: int, float, signal + +Attributes: mode +""" + +mc_comb_tilde = MaxObject('mc.comb~') +""" +mc.comb~ - Apply a comb filter effect (multichannel) + +Use the comb~ object to apply the classic comb filtering effect to an audio input. The comb~ object mixes the current input sample with earlier input and/or output samples, according to the formula: + + + yn = axn + bxn-(DR/1000) + cyn-(DR/1000) + + + where R is the sampling rate and D is a delay time in milliseconds. + +Args: + max-delay (float, optional) + initial-delay (float, optional) + gain-coefficient (float, optional) + feedforward-coefficient (float, optional) + feedback-coefficient (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Delay in ms + 2 (signal/float): (signal/float) Gain Coefficient + 3 (signal/float): (signal/float) Feedforward Coefficient + 4 (signal/float): (signal/float) Feedback Coefficient + +Outlets: + 0 (signal): (signal) Filter Output + +Messages: float, clear, signal +""" + +mc_combine_tilde = MaxObject('mc.combine~') +""" +mc.combine~ - Combine inputs into a multichannel signal + +The mc.combine~ object combines inputs (signals, multichannel signals, floats) into one multichannel signal. Unlike mc.pack~, every channel of an input multichannel signal will be included in the output. + +Args: + number-of-inlets (int, optional) + +Inlets: + 0 (signal, float): Input + 1 (signal, float): Input + +Outlets: + 0 (multi-channel signal): Output + +Messages: int, float, list, mute, signal + +Attributes: chans +""" + +mc_cos_tilde = MaxObject('mc.cos~') +""" +mc.cos~ - Signal cosine function (0-1 range) (multichannel) + +Use the cos~ object to calculate and output a signal that is the cosine function of each sample of the input signal. + +Inlets: + 0 (signal): (signal) Phase (0-1) + +Outlets: + 0 (signal): (signal) Cosine Output + +Messages: signal +""" + +mc_cosh_tilde = MaxObject('mc.cosh~') +""" +mc.cosh~ - Signal hyperbolic cosine function (multichannel) + +Use the cosh~ object to calculate and output a signal that is the hyperbolic cosine function of each sample of the input signal. + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Cosh (x) Out + +Messages: signal +""" + +mc_cosx_tilde = MaxObject('mc.cosx~') +""" +mc.cosx~ - Signal cosine function (multichannel) + +Use the cosx~ object to calculate and output a signal that is the cosine function of each sample of the input signal. The cosx~ object is a true π based function - it varies from the cos~ object, whose output is based around a value range of 0. - 1.0 and is intended for use as a lookup table with the phasor~ object. + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Cos (x) Out + +Messages: signal +""" + +mc_count_tilde = MaxObject('mc.count~') +""" +mc.count~ - Count samples elapsed (multichannel) + +Use the count~ object count samples elapsed and thus drive processes tightly synchronized to the sample rate. It outputs a signal increasing by 1 for each sample elapsed. It can be set to loop, and can be used to drive objects such as index~ with sample accuracy. + +Args: + initial-value (int, optional) + count-limit (int, optional) + enable (int, optional) + autoreset-state (int, optional) + +Inlets: + 0 (INLET_TYPE): int, bang Start Count, stop Stops It + 1 (INLET_TYPE): int sets Count Limit + +Outlets: + 0 (signal): Count Output + +Messages: bang, int, float, list, in1, min, set, signal, stop + +Attributes: autoreset +""" + +mc_cross_tilde = MaxObject('mc.cross~') +""" +mc.cross~ - Third-order crossover filter (multichannel) + +Use the cross~ object as a pair of symmetrical low+high pass 3rd order filters with lowpass and highpass outlets you can use separately or in combination to form a crossover filter. + +Args: + cutoff-frequency (float, required) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Crossover Frequency (Hz) + +Outlets: + 0 (signal): (signal) Lowpass Filtered Output + 1 (signal): (signal) Highpass Filtered Output + +Messages: int, float, clear, signal +""" + +mc_curve_tilde = MaxObject('mc.curve~') +""" +mc.curve~ - Exponential ramp generator (multichannel) + +Use the curve~ object to produce a signal that goes from an initial to target value over a specified time. It is similar to the line~ object, it produces non-linear ramps using a piecewise approximation of an exponential function. + +Args: + initial-value (number, optional) + curve-parameter (number, optional) + +Inlets: + 0 (INLET_TYPE): Destination Value + 1 (INLET_TYPE): Ramp Time + 2 (INLET_TYPE): Curve Parameter (-1.0 to 1.0) + +Outlets: + 0 (signal): Output Ramp + 1 (signal): bang When Curve Reaches Destination + +Messages: int, float, list, anything, factor, pause, resume, stop + +Attributes: activeout, maxpoints, shapemode +""" + +mc_cycle_tilde = MaxObject('mc.cycle~') +""" +mc.cycle~ - Sinusoidal oscillator (multichannel) + +Use the cycle~ object to generate a periodic waveform. The default waveform is one cycle of a cosine wave. You can also use the wave~ object, which offers additional flexibility though slightly less optimization. + +Args: + frequency (number, optional) + buffer-name (symbol, optional) + sample-offset (int, optional) + +Inlets: + 0 (signal/float): Frequency + 1 (signal/float): Phase (0-1) + +Outlets: + 0 (signal): Output + +Messages: float, (mouse), reset, set, setall, signal + +Attributes: buffer, buffer_offset, buffer_sizeinsamps, frequency, phase +""" + +mc_dac_tilde = MaxObject('mc.dac~') +""" +mc.dac~ - Multichannel audio output and on/off + +The mc.dac~ ("digital-to-analog converter") object sends its signal inputs to audio hardware. Double-click on an mc.dac~ to open the Audio Status window to configure audio settings and hardware. + +Args: + outputs (symbol, optional) + +Inlets: + 0 (multi-channel signal): Audio outputs, start (1) and stop (0) + +Messages: int, list, (mouse), open, set, signal, start, startwindow, stop, wclose +""" + +mc_dbtoa_tilde = MaxObject('mc.dbtoa~') +""" +mc.dbtoa~ - Convert a deciBel value to a linear value at signal rate (multichannel) + +dbtoa~ takes any given signal representing a deciBel value and outputs a signal which is a linear value conversion of the input. + +Inlets: + 0 (signal): (signal) Gain/Attenuation dB + +Outlets: + 0 (signal): (signal) Amplitude Scalar + +Messages: signal +""" + +mc_degrade_tilde = MaxObject('mc.degrade~') +""" +mc.degrade~ - Signal quality reducer (multichannel) + +degrade~ takes any given signal and reduces the sampling rate and bit-depth as specified/desired. + +Args: + resampling-frequency-ratio (float, optional) + number-of-quantization-bits (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (float / signal): (float) Sampling-Rate Ratio + 2 (int / signal): (int) Resolution in bits + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal +""" + +mc_deinterleave_tilde = MaxObject('mc.deinterleave~') +""" +mc.deinterleave~ - Deinterleave a multichannel audio signal + +The mc.deinterleave~ object separates a multichannel signal into two or more deinterleaved multichannel signals. + +Args: + outputs (int, optional) + +Inlets: + 0 (signal or multi-channel signal): Input 1 + +Outlets: + 0 (multi-channel signal): Deinterleaved Output + 1 (multi-channel signal): Deinterleaved Output + +Messages: signal +""" + +mc_delay_tilde = MaxObject('mc.delay~') +""" +mc.delay~ - Delay a signal (multichannel) + +Use the delay~ object to delay a signal by a certain amount of time. The delay time can be specified in samples (determined by the sampling rate), or using the Max time format syntax for tempo-relative values. + +Args: + maximum-delay-memory (int, required) + initial-delay-time (list, optional) + ramp-time (int, optional) + +Inlets: + 0 (signal): Input to be Delayed + 1 (int/signal): Delay Time in Samples + +Outlets: + 0 (signal): Delayed Output + +Messages: int, float, list, anything, clear, maxsize, ramp, signal + +Attributes: delay +""" + +mc_delta_tilde = MaxObject('mc.delta~') +""" +mc.delta~ - Signal of sample differences (multichannel) + +delta~ outputs a signal which represents the differences between each incoming sample value in the input signal. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Differences Between Input Samples + +Messages: signal +""" + +mc_deltaclip_tilde = MaxObject('mc.deltaclip~') +""" +mc.deltaclip~ - Limit changes in signal amplitude (multichannel) + +deltaclip~ limits the change between samples in an incoming signal. It is similar to the clip~ object, but it limits amplitude changes with respect to slope rather than amplitude. + +Args: + minimum-slope-value (float, optional) + minimum and maximum-slope-values (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (double): (float) Delta min + 2 (double): (float) Delta max + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, ft1, ft2, reset, signal +""" + +mc_div_tilde = MaxObject('mc.div~') +""" +mc.div~ - Divide one signal by another (multichannel) + +Use the /~ object is to multiply a signal coming into the left inlet by the reciprocal of either the initial argument or an int or float received in the right inlet. + +Args: + initial-divisor (number, optional) + +Inlets: + 0 (signal/float): (signal/float) This / Right Inlet + 1 (signal/float): (signal/float) Left Inlet / This + +Outlets: + 0 (signal): (signal) Division Result + +Messages: int, float, signal +""" + +mc_downsamp_tilde = MaxObject('mc.downsamp~') +""" +mc.downsamp~ - Downsample a signal (multichannel) + +downsamp~ samples and holds a signal received in the left inlet at a rate set by an argument to the object of the value received in the right inlet, expressed in samples. No interpolation of the output is performed. + +Args: + downsampled-rate (number, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Sampling interval + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal +""" + +mc_dup_tilde = MaxObject('mc.dup~') +""" +mc.dup~ - Create a multichannel signal that duplicates a single-channel input + +The mc.dup~ object creates multichannel signals from a single-channel signals by duplicating the input across all channels of the output. + +Args: + channel count (int, optional) + +Inlets: + 0 (signal): input + +Outlets: + 0 (multi-channel signal): input duplicated + +Messages: signal + +Attributes: chans +""" + +mc_edge_tilde = MaxObject('mc.edge~') +""" +mc.edge~ - Detect logical signal transitions (multichannel) + +Use the edge~ to detect zero to non-zero (and vice versa) signal transitions and report a bang out of one of its two outlets according to which direction the transition has occurred. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (bang): (bang) Output on zero to non-zero transition + 1 (bang): (bang) Output on non-zero to zero transition + +Messages: signal +""" + +mc_equals_tilde = MaxObject('mc.equals~') +""" +mc.equals~ - Is equal to, comparison of two signals (multichannel) + +==~ outputs a 1 signal when the left input is equal to the right input and a 0 when it is not equal to the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (signal/float): (signal) This == Right Inlet + 1 (signal/float): (signal/float) Left Inlet == This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal + +Attributes: fuzzy +""" + +mc_evolve_tilde = MaxObject('mc.evolve~') +""" +mc.evolve~ - Generate a periodic multichannel function from breakpoint ranges + +The mc.evolve~ object accepts breakpoints consisting of ranges where both the domain and range go from 0 to 1. It maps this set of ranges across the space of a multichannel output signal, where the first channel in the output signal outputs the low end of the range and the last channel outputs the high end. Connect a phasor~ or another time-varying signal to mc.evolve~ to drive the output. + +Args: + chans (int, required) + +Inlets: + 0 (multi-channel signal): Driving Phase, list Sets Function + +Outlets: + 0 (multi-channel signal): Output + 1 (float): Query value for an output channel + 2 (list): Query value of the output range + +Messages: int, float, list, chanval, clear, printfunction, signal + +Attributes: chans, inclusive +""" + +mc_ezadc_tilde = MaxObject('mc.ezadc~') +""" +mc.ezadc~ - Audio input and on/off button + +mc.ezadc~ works as a user interface version of the mc.adc~ object. It appears as a button which can be clicked with the mouse to turn audio on or off. + +Inlets: + 0 (INLET_TYPE): Start/Stop Audio + +Outlets: + 0 (multi-channel signal): Output from Audio Device Input + +Messages: int, list, (mouse), local, open, set, start, startwindow, stop, wclose + +Attributes: bgcolor, border, bordercolor, color, elementcolor, local, offgradcolor1, offgradcolor2, ongradcolor1, ongradcolor2, style +""" + +mc_ezdac_tilde = MaxObject('mc.ezdac~') +""" +mc.ezdac~ - Audio output and on/off button + +mc.ezdac~ works as a user interface version of the mc.dac~ object. It appears as a button which can be clicked with the mouse to turn audio on or off. + +Inlets: + 0 (multi-channel signal): (signal) start/stop, audio output (multichannel) + +Messages: int, list, (mouse), local, open, set, signal, start, startwindow, stop, wclose + +Attributes: bgcolor, border, bordercolor, color, elementcolor, local, offgradcolor1, offgradcolor2, ongradcolor1, ongradcolor2, style +""" + +mc_fffb_tilde = MaxObject('mc.fffb~') +""" +mc.fffb~ - Fast fixed filter bank (multichannel) + +The fffb~ object implements a bank of bandpass filter objects, each of which is similar to the reson~ filter object. An input signal is applied to all filters, and the outputs of each filter are available separately. When the fffb~ object is instantiated as mcs.fffb~ the object has a single multichannel output containing the individual filters. Otherwise it has a separate outlet for each filter. + +Args: + number-of-filters (int, required) + 1st-filter-frequency (float, optional) + filter-frequency-ratios (float) (float, optional) + Q (list, optional) + harmonic-series-flag (H) (symbol, optional) + +Inlets: + 0 (signal): signal input, lists for setting parameters + +Outlets: + 0 (signal): signal output from filter 0 + 1 (signal): Output from Filter 1 + 2 (signal): Output from Filter 2 + 3 (signal): Output from Filter 3 + +Messages: list, anything, Q, QAll, clear, freq, freqAll, freqRatio, gain, gainAll, signal +""" + +mc_fft_tilde = MaxObject('mc.fft~') +""" +mc.fft~ - Fast Fourier transform (multichannel) + +fft~ performs a Fast Fourier transform on any incoming signal and outputs the real and imaginary parts of that transform as well as a synchronization signal. + +Args: + number-of-FFT-samples (int, optional) + interval (int, optional) + offset (int, optional) + +Inlets: + 0 (signal): (signal) Real Input + 1 (signal): (signal) Imaginary Input + +Outlets: + 0 (signal): (signal) Real Output + 1 (signal): (signal) Imaginary Output + 2 (signal): (signal) Ramp from 0 to Number of Points - 1 + +Messages: phase, signal + +Attributes: fftsize, float32, interval, legacy, offset +""" + +mc_filtercoeff_tilde = MaxObject('mc.filtercoeff~') +""" +mc.filtercoeff~ - Signal-rate filter coefficient generator (multichannel) + +The filtercoeff~ object is a signal-rate filter coefficient calculator for the biquad~ object. It calculates the filter coefficients from three higher-level parameters: frequency, amplitude and resonance (Q) or slope (S). Its internal calculations are based on those of the filtergraph~ object. + +Args: + default-filter-type (symbol, optional) + resampling-factor (int, optional) + +Inlets: + 0 (signal/float): (signal/float) Frequency + 1 (signal/float): (signal/float) Gain + 2 (signal/float): (signal/float) Q + +Outlets: + 0 (signal): (signal) Gain (FF Coefficient 0) + 1 (signal): (signal) FF Coefficient 1 + 2 (signal): (signal) FF Coefficient 2 + 3 (signal): (signal) FB Coefficient 1 + 4 (signal): (signal) FB Coefficient 2 + +Messages: int, float, list, allpass, bandpass, bandstop, gainapass, gainbpass, gainbstop, gainhpass, gainlpass, gainresonant, highpass, highshelf, lowpass, lowshelf, off, peaknotch, resamp, resonant, signal +""" + +mc_frameaccum_tilde = MaxObject('mc.frameaccum~') +""" +mc.frameaccum~ - Compute "running phase" of successive phase deviation frames (multichannel) + +frameaccum~ computes a running phase by keeping a sum of the values in each position of its incoming signal vectors. When used inside a pfft~ object, it can keep a running phase of the FFT because the FFT size is equal to the signal vector size. + +Args: + phasewrap-flag (0 or nonzero) (int, optional) + +Inlets: + 0 (signal): (signal) Input FFT Phase Deviation + +Outlets: + 0 (signal): (signal) FFT Running Phase Output + +Messages: clear, signal +""" + +mc_frameaverage_tilde = MaxObject('mc.frameaverage~') +""" +mc.frameaverage~ - Perform a piece-wise running averaging of consecutive frames of audio. (multichannel) + +The frameaverage~ object performs a piece-wise running averaging of consecutive frames of audio. Where the framesmooth~ object can be seen as smoothing in the frequency domain (when using FFT as input), the frameaverage~ object can be seen as performing temporal smoothing, more analogous to the vectral~ object. + +Inlets: + 0 (signal): Input FFT Phase Deviation + +Outlets: + 0 (signal): FFT Running Phase Output + +Messages: clear, signal + +Attributes: framecount, framesize +""" + +mc_framedelta_tilde = MaxObject('mc.framedelta~') +""" +mc.framedelta~ - Compute phase deviation between successive FFT frames (multichannel) + +framedelta~ computes a running phase deviation by subtracting values in each position of its previously received signal vector from the current signal vector. When used inside a pfft~ object, it keeps a running phase deviation of the FFT because the FFT size is equal to the signal vector size. + +Inlets: + 0 (signal): (signal) FFT Phase Frame + +Outlets: + 0 (signal): (signal) FFT Phase Deviation + +Messages: clear, signal +""" + +mc_framesmooth_tilde = MaxObject('mc.framesmooth~') +""" +mc.framesmooth~ - Perform averaging of consecutive samples, grouped into frames, without blurring across the frames. (multichannel) + +The framesmooth~ object performs averaging of consecutive samples, grouped into frames, without blurring across the frames. + +Inlets: + 0 (signal): Input FFT Phase Deviation + +Outlets: + 0 (signal): FFT Running Phase Output + +Messages: clear, signal + +Attributes: framesize, smoothness +""" + +mc_freqshift_tilde = MaxObject('mc.freqshift~') +""" +mc.freqshift~ - Time-domain frequency shifter (multichannel) + +freqshift~ is a time-domain frequency shifter (also known as a single-sideband ring modulator). + +Args: + frequency-shift (int, required) + frequency-shift (float, optional) + +Inlets: + 0 (signal): (signal) Audio Signal to be Shifted + 1 (signal/float): (signal/float) Amount of Frequency Shift (Hz) + +Outlets: + 0 (signal): (signal) Frequency-shifted Signal (Positive Sideband) + 1 (signal): (signal) Frequency-shifted Signal (Negative Sideband) + +Messages: int, float, clear, resetphase, signal +""" + +mc_ftom_tilde = MaxObject('mc.ftom~') +""" +mc.ftom~ - Convert frequency to MIDI note numbers at signal-rate (multichannel) + +Use ftom~ to convert frequency to MIDI note numbers at signal rate + +Inlets: + 0 (signal): Frequency in Hz + +Outlets: + 0 (signal): Floating-point MIDI Note Number + +Messages: signal + +Attributes: base, map, mapname, mid, ref, scale, scalename +""" + +mc_fzero_tilde = MaxObject('mc.fzero~') +""" +mc.fzero~ - Fundamental frequency and pitch estimator (multichannel) + +The fzero~ object estimates the fundamental frequency of an an incoming, monophonic audio signal. It performs multiple layers of wavelet transforms on an incoming vector, comparing the spacing between the peaks in each. + +Inlets: + 0 (signal): Audio to be analyzed + +Outlets: + 0 (float): Estimated fundamental pitch + 1 (float): Peak amplitude in analysis vector + 2 (bang): onset detected + +Messages: signal + +Attributes: freqmax, freqmin, onsetamp, onsetlist, onsetperiod, onsetpitch, period, quiet, size, threshold +""" + +mc_gain_tilde = MaxObject('mc.gain~') +""" +mc.gain~ - Multichannel gain control + +The mc.gain~ object is a slider that scales multichannel signals. It can also make a smooth transition as you move from one value of the slider to the next. + +Inlets: + 0 (signal): Input to Scale, int Sets Value + +Outlets: + 0 (signal): Scaled Output + 1 (signal): Slider Value + +Messages: bang, int, float, list, color, ft1, (mouse), set, setvalue, signal + +Attributes: annotation_name, bgcolor, bordercolor, inc, interp, interpinlet, knobcolor, multislider, orientation, param_connect, parameter_enable, parameter_mappable, relative, scale, size, stripecolor, style +""" + +mc_gate_tilde = MaxObject('mc.gate~') +""" +mc.gate~ - Route a signal to one of several outlets (multichannel) + +Use gate~ to route an input signal at the second inlet to one of several outlets, or to no outlet at all. When there is only one outlet (the default case), it acts as a simple switch. Unlike the Max gate object, any outlet which is not selected outputs a signal composed of zero values. + + When the gate~ object is created as mcs.gate~ all of its signal outlets are combined into a single multichannel outlet. The behavior of mcs.gate~ is otherwise identical to gate~. + +Args: + number-of-outlets (int, optional) + initial-open-outlet (int, optional) + +Inlets: + 0 (int/signal): int/signal Turns Input Off or Routes to Output + 1 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Output + +Messages: bang, int, float, next, signal + +Attributes: ramptime, stepmode +""" + +mc_gen = MaxObject('mc.gen') +""" +mc.gen - Generate native audio event processing routines (multichannel) + +The gen object turns an embedded Gen patcher into event processing routines analagous to what the gen~ object does for audio signals. The Gen patcher can be built from a wide set of low-level Gen operator objects as well as embedded code expressions. + +Args: + patcher-name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): in 1 + 1 (INLET_TYPE): in 2 + +Outlets: + 0 (OUTLET_TYPE): out 1 + +Messages: bang, int, float, (mouse), exportcode, open, reload, reset, reset_param, set, wclose + +Attributes: active, autoexport, cpu, cpumeasure, dumpoutlet, exportfolder, exportname, exportnotifier, exportscript, exportscriptargs, gen, hot, interval, nocache, poll, title +""" + +mc_gen_tilde = MaxObject('mc.gen~') +""" +mc.gen~ - Generate native audio signal processing routines (multichannel) + +The gen~ object turns an embedded Gen patcher into signal processing routines of optimized native machine code. The Gen patcher can be built from a wide set of low-level Gen operator objects as well as embedded code expressions. + +Args: + patcher-name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): in 1 + 1 (INLET_TYPE): in 2 + +Outlets: + 0 (OUTLET_TYPE): out 1 + +Messages: int, float, (mouse), exportcode, open, reload, reset, reset_param, signal, wclose + +Attributes: autoexport, cpu, cpumeasure, dumpoutlet, exportfolder, exportname, exportnotifier, exportscript, exportscriptargs, gen, nocache, poll, title +""" + +mc_generate_tilde = MaxObject('mc.generate~') +""" +mc.generate~ - Generate Values for a Range of Channels + +The mc.generate~ object allows signal-rate updating of MC Wrapper features such as deviate, spread, and harmonic as a trigger signal or parameter inputs change. One wrapper message is assigned as an operator. + +Args: + initial-parameter-1 (float, optional) + initial-parameter-2 (float, optional) + initial-parameter-3 (float, optional) + +Inlets: + 0 (multi-channel signal): Trigger Input + 1 (multi-channel signal, float): Parameter 1 Value + 2 (multi-channel signal, float): Parameter 2 Value + 3 (multi-channel signal, float): Parameter 3 Value + +Outlets: + 0 (multi-channel signal): Output + +Messages: int, float, signal + +Attributes: chans, op, p1, p2, p3, ramptime +""" + +mc_gradient_tilde = MaxObject('mc.gradient~') +""" +mc.gradient~ - Generate a time-varying function over the space of a multichannel signal + +Add breakpoints to the mc.gradient~ to specify a function where both the domain and range go from 0 to 1. The output range is mapped across the space of a multichannel signal. Connect a phasor~ or another time-varying single- or multichannel signal to the mc.gradient~ object to drive its output. + +Args: + chans (int, required) + +Inlets: + 0 (multi-channel signal): Driving function + +Outlets: + 0 (multi-channel signal): Output + 1 (float): Channel value in response to chanval message + 2 (list): Output function values for input + +Messages: int, float, list, chanval, clear, printfunction, signal + +Attributes: chans, mode +""" + +mc_greaterthan_tilde = MaxObject('mc.greaterthan~') +""" +mc.greaterthan~ - Is greater than, comparison of two signals (multichannel) + +>~ outputs a 1 signal when the left input is greater-than the right input and a 0 when it is less-than or equal-to the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (signal/float): (signal) This > Right Inlet + 1 (signal/float): (signal/float) Left Inlet > This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal +""" + +mc_greaterthaneq_tilde = MaxObject('mc.greaterthaneq~') +""" +mc.greaterthaneq~ - Is greater than or equal to, comparison of two signals (multichannel) + +>=~ outputs a 1 signal when the left input is greater-than or equal-to the right input and a 0 when it is less-than the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (signal/float): (signal) This >= Right Inlet + 1 (signal/float): (signal/float) Left Inlet >= This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal + +Attributes: fuzzy +""" + +mc_groove_tilde = MaxObject('mc.groove~') +""" +mc.groove~ - Variable-rate looping sample playback (multichannel) + +The groove~ object is a variable-rate, looping, sample-playback object which references the audio information stored in a buffer~ object having the same name. When the groove~ object is instantiated as mcs.groove~ its audio outputs are combined into a single multichannel output. + +Args: + buffer-name (symbol, required) + number-of-outputs (int, optional) + +Inlets: + 0 (signal): Sample Playback Increment + 1 (signal/float): Loop Min + 2 (signal/float): Loop Max + +Outlets: + 0 (signal): Channel 1 Output + 1 (signal): Loop Sync Output + +Messages: int, float, list, anything, clearspeedcues, (mouse), dictionary, endloop, printspeedcues, reset, set, setloop, signal, startloop, stop + +Attributes: basictuning, followglobaltempo, formant, formantcorrection, lock, loop, loopend, loopinterp, loopstart, mode, name, originallength, originaltempo, phase, pitchcorrection, pitchshift, pitchshiftcent, quality, slurtime, timestretch, transport +""" + +mc_hilbert_tilde = MaxObject('mc.hilbert~') +""" +mc.hilbert~ - Phase quadrature filter (multichannel) + +hilbert~ is a 6th order hilbert transformer with a minimum of error. + +Inlets: + 0 (signal): (signal) input signal + +Outlets: + 0 (signal): (signal) cosine/real output + 1 (signal): (signal) sine/imag output + +Messages: clear, signal +""" + +mc_ifft_tilde = MaxObject('mc.ifft~') +""" +mc.ifft~ - Inverse fast Fourier transform (multichannel) + +ifft~ performs an Inverse FFT (inverse fast Fourier transform) on an input signal. + +Args: + number-of-IFFT-samples (int, optional) + interval (int, optional) + offset (int, optional) + +Inlets: + 0 (signal): (signal) Real Input + 1 (signal): (signal) Imaginary Input + +Outlets: + 0 (signal): (signal) Real Output + 1 (signal): (signal) Imaginary Output + 2 (signal): (signal) Ramp from 0 to Number of Points - 1 + +Messages: phase, signal + +Attributes: fftsize, float32, interval, legacy, offset +""" + +mc_in_tilde = MaxObject('mc.in~') +""" +mc.in~ - Signal inputs for a patcher loaded by poly~ + +The mc.in~ object receives signals from multiple inlets to the poly~ object (or multiple channels within the input to mcs.poly~), and outputs those signals as one multichannel signal. The number of signal inlets is determined by the chans attribute. + +Args: + starting-inlet-number (int, required) + +Inlets: + 0 (signal): Dummy + +Outlets: + 0 (multi-channel signal): Inputs + +Messages: comment, signal + +Attributes: attr_comment, chans +""" + +mc_index_tilde = MaxObject('mc.index~') +""" +mc.index~ - Read from a (multichannel) buffer~ with no interpolation + +Use index~ to read from a buffer~ object at a signal-driven sample index with no interpolation on the output. + +Args: + buffer-name (symbol, required) + buffer-channel-to-index (int, optional) + +Inlets: + 0 (signal): Sample Index + 1 (signal): Audio Channel In buffer~ + +Outlets: + 0 (signal): Sample Value at Index + 1 (signal): Audio Channel In buffer~ + +Messages: int, float, (mouse), set, signal +""" + +mc_interleave_tilde = MaxObject('mc.interleave~') +""" +mc.interleave~ - Interleave two or more multichannel signals + +The mc.interleave~ object combines two or more multichannel signals into a single multichannel signal by interleaving channels. This is useful for re-combining stereo pairs from MC sample playback objects prior to sending to mc.mixdown~ or mc.stereo~. + +Args: + inputs (int, optional) + +Inlets: + 0 (multi-channel signal): Input 1 + 1 (multi-channel signal): Input 2 + +Outlets: + 0 (multi-channel signal): Interleaved Output + +Messages: signal +""" + +mc_kink_tilde = MaxObject('mc.kink~') +""" +mc.kink~ - Distort a sawtooth waveform (multichannel) + +kink~ takes phasor~ values and distorts them according to a slope factor. If the input times the slope is less than 0.5, that value is output. Otherwise, a complentary slope is used, equal to 0.5 at the same input value but equal to 1 when the input is 1. This creates a bend or "kink" in the phase waveform when the slope is not equal to 1. + +Args: + slope-multiplier (float, optional) + +Inlets: + 0 (signal): (signal) Phase Input from 0-1 + 1 (signal/float): (signal/float) Slope (Kinkiness) + +Outlets: + 0 (signal): (signal) Disorted Phase Output + +Messages: int, float, signal +""" + +mc_lessthan_tilde = MaxObject('mc.lessthan~') +""" +mc.lessthan~ - Is less than, comparison of two signals (multichannel) + +<~ outputs a 1 signal when the left input is less-than the right input and a 0 when it is greater-than or equal-to the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (int, float, optional) + +Inlets: + 0 (signal/float): (signal) This < Right Inlet + 1 (signal/float): (signal/float) Left Inlet < This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal +""" + +mc_lessthaneq_tilde = MaxObject('mc.lessthaneq~') +""" +mc.lessthaneq~ - Is less than or equal to, comparison of two signals (multichannel) + +<=~ outputs a 1 signal when the left input is less-than or equal-to the right input and a 0 when it is less-than the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (signal/float): (signal) This <= Right Inlet + 1 (signal/float): (signal/float) Left Inlet <= This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal + +Attributes: fuzzy +""" + +mc_limi_tilde = MaxObject('mc.limi~') +""" +mc.limi~ - Lookahead peak-limiter (multichannel) + +Lookahead peak-limiter. + +Args: + channel_count (int, optional) + buffer_size (int, optional) + +Inlets: + 0 (signal): Input + +Outlets: + 0 (signal): Output + +Messages: clear, signal + +Attributes: bypass, dcblock, lookahead, mode, postamp, preamp, release, threshold +""" + +mc_line_tilde = MaxObject('mc.line~') +""" +mc.line~ - Linear signal ramp generator (multichannel) + +Use the line~ object to generate a signal ramp or envelope. It uses the Max time format syntax; envelope times can be either single valued fixed or tempo-relative. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Destination Value + 1 (INLET_TYPE): Ramp Time + +Outlets: + 0 (signal): Output Ramp + 1 (signal): bang When Line Reaches Destination + +Messages: int, float, list, anything, pause, resume, stop + +Attributes: activeout, maxpoints +""" + +mc_list_tilde = MaxObject('mc.list~') +""" +mc.list~ - Create a multichannel signal from a list of values + +Use mc.list~ to create a multichannel signal from a list of values. The number of output channels is determined by the number of arguments provided to the object. + +Args: + initial values (list, required) + +Inlets: + 0 (INLET_TYPE): list Sets Signal Values + +Outlets: + 0 (multi-channel signal): Output + +Messages: int, float, list, signal + +Attributes: chans +""" + +mc_log_tilde = MaxObject('mc.log~') +""" +mc.log~ - Logarithm of a signal (multichannel) + +Use the log~ object to output a signal composed of the logarithms of its input values. You can specify the logarithmic base. + +Args: + logarithmic-base (number, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): Base + +Outlets: + 0 (signal): (signal) log of Input to Base + +Messages: float, signal +""" + +mc_lookup_tilde = MaxObject('mc.lookup~') +""" +mc.lookup~ - Transfer function lookup table (multichannel) + +lookup~ allows you to use a table of samples (buffer~ object) to do waveshaping on a signal, in which the Y values of an input signal are used as X values to look up new signal values. Input values of -1 to +1 are mapped to table values between 0 (or the specified sample offset) and the size of the table. + +Args: + buffer-name (symbol, required) + sample-offset (int, optional) + +Inlets: + 0 (signal): Input To Distort + 1 (signal/float): Sample Offset + 2 (signal/float): Lookup Table Size + +Outlets: + 0 (signal): Distorted Output + +Messages: int, float, (mouse), set, signal + +Attributes: chan, offset, size +""" + +mc_lores_tilde = MaxObject('mc.lores~') +""" +mc.lores~ - Resonant lowpass filter (multichannel) + +lores~ implements an inexpensive lowpass with an adjustment that lets you add a specified resonance. The middle inlet sets a kind of cutoff frequency, but the sharpness of the filter depends on the resonance passed in through the right inlet (0 is a little bit sharp and 1 as sharp as possible). + +Args: + cutoff (number, optional) + resonance (number, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Cutoff Frequency + 2 (signal/float): (signal/float) Resonance Control (0-1) + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, clear, signal + +Attributes: cutoff, resonance +""" + +mc_loudness_tilde = MaxObject('mc.loudness~') +""" +mc.loudness~ - Report loudness of a signal (multichannel) + +The loudness~ object reports the loudness of a signal according to the EBU R 128 standard. Momentary, short term, and integrated loudness measures are reported in LUFS (loudness units referenced to full scale). Additionally, the signal's loudness range is reported in loudness units, while sample peak true peak values are reported in dB. You can use these measurements to normalize audio signals for various broadcast and streaming platforms. + +Args: + channelcount (int, optional) + +Inlets: + 0 (signal): (signal) any signal, (bang) report peak amplitude + +Outlets: + 0 (float): Momentary Loudness in LUFS + 1 (float): Short-Term Loudness in LUFS + 2 (float): Integrated Loudness in LUFS + 3 (float): Loudness Range + 4 (float): Peak Sample Value + 5 (float): True Peak Value + +Messages: bang, int, float, reset, signal + +Attributes: channel, inputs, interval +""" + +mc_makelist = MaxObject('mc.makelist') +""" +mc.makelist - Create a list from non-signal output of MC objects + +The mc.makelist object creates a list of values whose size is determined by the highest voice number it receives in its right inlet or specified by the value of its voices attribute. + +Inlets: + 0 (INLET_TYPE): Trigger List Output + 1 (INLET_TYPE): Items to Assemble Into a List + 2 (int): Voice Index + +Outlets: + 0 (OUTLET_TYPE): List Output + +Messages: bang, int, float, list, anything, clear, voice + +Attributes: fixed, mode, voices +""" + +mc_matrix_tilde = MaxObject('mc.matrix~') +""" +mc.matrix~ - Signal routing and mixing matrix (multichannel) + +matrix~ is an array of signal connectors and mixers (adders). It can have any number of inlets and outlets. Signals entering at each inlet can be routed to one or more of the outlets, with a variable amount of gain. If an outlet is connected to more than one inlet, its output signal is the sum of the signals from the inlets. + + When the matrix~ object is created as mcs.matrix~ all of its signal inlets are combined into a single multichannel inlet and all of its signal outlets are combined into a single multichannel outlet. The behavior of mcs.matrix~ is otherwise identical to matrix~. + +Args: + inlets (int, required) + outlets (int, required) + default-connect-gain (float, optional) + +Inlets: + 0 (signal): Input 0, connect (list), disconnect (list) + 1 (signal): Input 1 + +Outlets: + 0 (signal): Output 0 + 1 (signal): Output 1 + 2 (list): Inlets Outlets Gains + +Messages: list, clear, connect, dictionary, disconnect, dump, dumpconnections, dumptarget, print + +Attributes: exclusive, ramp +""" + +mc_maximum_tilde = MaxObject('mc.maximum~') +""" +mc.maximum~ - Compare two signals, output the maximum (multichannel) + +maximum~ outputs a signal which is the maximum of two input signals. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (Signal): (signal) Signal to be compared with Right Inlet + 1 (Signal): (signal) Signal to be compared with Left Inlet + +Outlets: + 0 (Signal): (signal) Maximum of Left and Right Signals + +Messages: int, float, signal +""" + +mc_midiplayer_tilde = MaxObject('mc.midiplayer~') +""" +mc.midiplayer~ - Generate MIDI Events from Audio Signals + +The mc.midiplayer~ object generates midievent note-on and note-off messages from audio signals representing triggers, note numbers, and velocity values. Typically you'll connect mc.midiplayer~ to vst~ which allows sample-accurate MIDI events at audio rates (assuming the hosted plug-in supports it). + +Inlets: + 0 (multi-channel signal): Note Trigger Input + 1 (multi-channel signal, float): Note Number + 2 (multi-channel signal, float): Velocity + +Outlets: + 0 (signal): MIDI Events for vst~ + 1 (midievent): MIDI Event Output Not for vst~ + +Messages: int, float, setvalue, signal + +Attributes: chanmod, defaultdur, defaultnote, defaultvelocity, mpemode, playzero, triggermode, velcurve +""" + +mc_miditarget = MaxObject('mc.miditarget') +""" +mc.miditarget - Map MIDI / MPE Channels to MC Channels + +The mc.miditarget object lets you use the channel number of incoming MIDI data (in the form of midievent messages produced by the midiparse object) to target individual instances of objects inside the MC wrapper. Normally MIDI channel 1 is mapped to MC channel 1, but mc.miditarget also has an MPE mode that maps MPE global MIDI channel 1 to MC channel 0 (targeting all instances) and MIDI channel 2 to MC channel 1. Objects that can work with messages from mc.miditarget include mc.vst~ and mc.sfizz~. + +Inlets: + 0 (INLET_TYPE): midievent Message + +Outlets: + 0 (OUTLET_TYPE): setvalue Index Followed by midievent Message + +Messages: midievent + +Attributes: mpemode +""" + +mc_minimum_tilde = MaxObject('mc.minimum~') +""" +mc.minimum~ - Compare two signals, output the minimum (multichannel) + +minimum~ outputs a signal which is the minimum of two input signals. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (Signal): (signal) Signal to be compared with Right Inlet + 1 (Signal): (signal) Signal to be compared with Left Inlet + +Outlets: + 0 (Signal): (signal) Minimum of Left and Right Signals + +Messages: int, float, signal +""" + +mc_minmax_tilde = MaxObject('mc.minmax~') +""" +mc.minmax~ - Compute minimum/maximum signal values (multichannel) + +minmax~ computes the minimum and maximum values of an input signal and outputs signals which are the maximum signal and the minimum signal as well as outputs of the minimum and maximum floats. + +Inlets: + 0 (signal): (signal) Input + 1 (signal): Reset Input + +Outlets: + 0 (signal): (signal) Minimum + 1 (signal): (signal) Maximum + 2 (double): (float) Minimum + 3 (double): (float) Maximum + +Messages: bang, reset, signal +""" + +mc_minus_tilde = MaxObject('mc.minus~') +""" +mc.minus~ - Signal subtraction (multichannel) + +Use the -~ object to perform signal subtraction (to output a signal which is the difference between two signals). + +Args: + initial-subtraction-value (number, optional) + +Inlets: + 0 (signal/float): (signal/float) This - Right Inlet + 1 (signal/float): (signal/float) Left Inlet - This + +Outlets: + 0 (signal): (signal) Subtraction Result + +Messages: int, float, signal +""" + +mc_mixdown_tilde = MaxObject('mc.mixdown~') +""" +mc.mixdown~ - Mix and pan a multichannel signal + +The mc.mixdown~ object mixes channels in a multichannel signal connected to its left inlet to a multichannel output. mc.mixdown~ can use a signal connected to its right inlet to pan the channels of its left (mix) input signal. + +Args: + output-channel-count (int, optional) + +Inlets: + 0 (multi-channel signal): Input + 1 (multi-channel signal): Pan Positions + +Outlets: + 0 (multi-channel signal): Output + +Messages: signal + +Attributes: activechans, autogain, busymapname, chans, linearpanmode, linearpanscalefactor, pancontrolmode, pans, usebusymap +""" + +mc_modulo_tilde = MaxObject('mc.modulo~') +""" +mc.modulo~ - Divide two signals, output the remainder (multichannel) + +%~ is a signal remainder operator. If signals are connected to both inlets, the left signal is divided by the right signal, and the remainder is output. If a signal is only connected to left inlet, it is divided to the argument or a float in the right inlet. Note that multiple signals in the same inlet add together automatically. + +Args: + initial-divisor (number, optional) + +Inlets: + 0 (signal/float): (signal/float) This Right Inlet + 1 (signal/float): (signal/float) Left Inlet This + +Outlets: + 0 (signal): (signal) Modulo Result + +Messages: int, float, signal +""" + +mc_mstosamps_tilde = MaxObject('mc.mstosamps~') +""" +mc.mstosamps~ - Convert milliseconds to samples (multichannel) + +Use the mstosamps~ object to convert an incoming signal carrying a millisecond value and output a signal which converts those millisecond values to a number of samples (at the current sampling rate). + +Inlets: + 0 (INLET_TYPE): Milliseconds In, signal To Use For Sampling Rate + +Outlets: + 0 (signal): (signal) Samples At Input signal or Current Sampling Rate + 1 (double): (float) Samples At Input signal or Current Sampling Rate + +Messages: int, float, list, signal +""" + +mc_mtof_tilde = MaxObject('mc.mtof~') +""" +mc.mtof~ - Convert a MIDI note number to frequency at signal rate (multichannel) + +Use mtof~ to convert MIDI note numbers to frequency at signal rate + +Inlets: + 0 (signal): Floating-point MIDI Value + +Outlets: + 0 (signal): Frequency in Hz + +Messages: signal + +Attributes: base, map, mapname, mid, ref, scale, scalename +""" + +mc_noise_tilde = MaxObject('mc.noise~') +""" +mc.noise~ - Generate white noise (multichannel) + +Use the noise~ object to generate a signal consisting of uniformly distributed random white-noise with values between -1.0 and 1.0. + +Inlets: + 0 (INLET_TYPE): (signal) Ignore This Inlet + +Outlets: + 0 (signal): (signal) The Noise + +Attributes: classic +""" + +mc_normalize_tilde = MaxObject('mc.normalize~') +""" +mc.normalize~ - Scale on the basis of maximum amplitude (multichannel) + +normalize~ performs real-time normalization of its input by multiplying each input sample value by a scaling factor - computed as the maximum output value (sent either as a signal or a float in the right inlet) over the maximum signal input value received thus far. + +Args: + initial-maximum-output-amplitude (float, optional) + +Inlets: + 0 (signal): (signal) Input To Be Normalized + 1 (signal/float): (signal/float) Maximum Value of Output + +Outlets: + 0 (signal): (signal) Normalized Output + +Messages: int, float, reset, signal +""" + +mc_noteallocator_tilde = MaxObject('mc.noteallocator~') +""" +mc.noteallocator~ - Manage voice numbers for MIDI note events + +The mc.noteallocator~ object assigns voice numbers for MIDI and MPE note events using an optional multichannel signal to determine voice busy state. It also maintains a voice busy map used by other MC objects to avoid unnecessary processing for channels that are not actively playing notes. + +Args: + voice count (int, optional) + +Inlets: + 0 (multi-channel signal): Multichannel signal representing busy state; midievent or mpeevent Messages + +Outlets: + 0 (OUTLET_TYPE): Note-on (Pitch, Attack Velocity) + 1 (OUTLET_TYPE): Note-off (Pitch, Release Velocity) + 2 (OUTLET_TYPE): Controller (Number, Value) + 3 (OUTLET_TYPE): Aftertouch + 4 (OUTLET_TYPE): Pitch Bend + 5 (OUTLET_TYPE): Voice Number + +Messages: midievent, mpeevent, signal + +Attributes: direct, hires, mpemode, name, steal, voices +""" + +mc_notequals_tilde = MaxObject('mc.notequals~') +""" +mc.notequals~ - Not equal to, comparison of two signals (multichannel) + +!=~ outputs a 1 signal when the left input is not-equal to the right input and a 0 when it is equal to the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (signal/float): (signal) This != Right Inlet + 1 (signal/float): (signal/float) Left Inlet != This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal + +Attributes: fuzzy +""" + +mc_number_tilde = MaxObject('mc.number~') +""" +mc.number~ - Multichannel signal monitor and constant generator + +Use the mc.number~ object to display or generate multichannel signal values. + +Inlets: + 0 (multi-channel signal): Input to Display + 1 (float): Output ramp time in Milliseconds + +Outlets: + 0 (multi-channel signal): Entered or received float values as a multichannel signal + 1 (float): Sampled values from incoming signal + 2 (float): Output Channel for Signal Value + +Messages: bang, int, float, list, allow, flags, ft1, max, min, mode, (mouse), set, signal + +Attributes: bgcolor, bgcolor2, bordercolor, chans, color, displaychan, ft1, hbgcolor, htextcolor, interval, maximum, minimum, monitormode, numdecimalplaces, sigoutmode, style, textcolor +""" + +mc_omx_4band_tilde = MaxObject('mc.omx.4band~') +""" +mc.omx.4band~ - OctiMax 4-band Compressor (multichannel) + +omx.4band~ delivers the signal-processing power of Octimax in a 4-band compressor. + +Inlets: + 0 (signal): (signal) Left Input Channel + 1 (signal): (signal) Right Input Channel + +Outlets: + 0 (signal): (signal) Left Output Channel + 1 (signal): (signal) Right Output Channel + 2 (list): (list) Parameter Output + 3 (list): (list) Meter Output + +Messages: bypass, choosePreset, gating_threshold, inagc_b1_atk, inagc_b1_rel, inagc_range, lim_drive, mbagc_b1_atk, mbagc_b1_drv, mbagc_b1_rel, mbagc_b2_atk, mbagc_b2_drv, mbagc_b2_rel, mbagc_b3_atk, mbagc_b3_drv, mbagc_b3_rel, mbagc_b4_atk, mbagc_b4_drv, mbagc_b4_rel, mbagc_range, meterData, meterRate, meters, ngenabled, ngthresh1, ngthresh2, noisegate, outmix1, outmix2, outmix3, outmix4, saveSettings, signal +""" + +mc_omx_5band_tilde = MaxObject('mc.omx.5band~') +""" +mc.omx.5band~ - OctiMax 5-band Compressor (multichannel) + +omx.5band~ delivers the signal-processing power of Octimax in a 5-band compressor. + +Inlets: + 0 (signal): (signal) Left Input Channel + 1 (signal): (signal) Right Input Channel + +Outlets: + 0 (signal): (signal) Left Output Channel + 1 (signal): (signal) Right Output Channel + 2 (list): (list) Parameter Output + 3 (list): (list) Meter Output + +Messages: bands_enum, bassenhancement, bassenhancement_mixlevel, bypass, choosePreset, freeze_threshold, gating_threshold, inagc_atk, inagc_progressive, inagc_range, inagc_ratio, inagc_rel, inagc_threshold, inf_ratio_above_threshold_1, inf_ratio_above_threshold_2, inf_ratio_above_threshold_3, inf_ratio_above_threshold_4, inf_ratio_above_threshold_5, lim_drive, lim_smoothrelease, mbagc_b1_atk, mbagc_b1_drv, mbagc_b1_rel, mbagc_b1_threshold, mbagc_b2_atk, mbagc_b2_drv, mbagc_b2_rel, mbagc_b2_threshold, mbagc_b3_atk, mbagc_b3_drv, mbagc_b3_rel, mbagc_b3_threshold, mbagc_b4_atk, mbagc_b4_drv, mbagc_b4_rel, mbagc_b4_threshold, mbagc_b5_atk, mbagc_b5_drv, mbagc_b5_rel, mbagc_b5_threshold, mbagc_progressive, mbclip_b1_threshold, mblim_b1_threshold, mblim_b2_threshold, mblim_b3_threshold, mblim_b4_threshold, mblim_b5_threshold, mbrange, mbratio, meterData, meterRate, meters, multiband_limiters, ng_enabled_maxch, ngenabled, ngthresh1, ngthresh2, ngthresh3, ngthresh4, ngthresh5, outlevel_lf, outlevel_rf, outmix1, outmix2, outmix3, outmix4, outmix5, output_level, saveSettings, signal, spatial_desired, spatial_enabled, spatial_maximum, spatial_speed +""" + +mc_omx_comp_tilde = MaxObject('mc.omx.comp~') +""" +mc.omx.comp~ - OctiMax Compressor (multichannel) + +omx.comp~ is a fully-featured signal compressor with limiting, gating, sidechain, and dual-band options. + +Inlets: + 0 (signal): (signal) Left Input Channel + 1 (signal): (signal) Right Input Channel + +Outlets: + 0 (signal): (signal) Left Output Channel + 1 (signal): (signal) Right Output Channel + 2 (list): (list) Parameter Output + 3 (list): (list) Meter Output + +Messages: agcEnabled, agcThreshold, attack, bypass, channelCoupling, choosePreset, delay, dualBandEnabled, freezeLevel, gatingLevel, limEnabled, limMode, meterData, meterRate, meters, ngEnabled, ngThreshold, progressiveRelease, range, ratio, release, saveSettings, sidechainFilterEnabled, signal, smoothGain +""" + +mc_omx_peaklim_tilde = MaxObject('mc.omx.peaklim~') +""" +mc.omx.peaklim~ - OctiMax Peak Limiter (multichannel) + +omx.peaklim~ is a peak-limiter which allows for the specified control of signal amplitude. + +Inlets: + 0 (signal): (signal) Left Input Channel + 1 (signal): (signal) Right Input Channel + +Outlets: + 0 (signal): (signal) Left Output Channel + 1 (signal): (signal) Right Output Channel + 2 (list): (list) Parameter Output + 3 (list): (list) Meter Output + +Messages: bypass, ingain, meterData, meterRate, meters, mode, outgain, saveSettings, signal, threshold +""" + +mc_onepole_tilde = MaxObject('mc.onepole~') +""" +mc.onepole~ - Single-pole lowpass filter (multichannel) + +The onepole~ object implements the simplest of IIR filters, providing a 6dB per octave attenuation. This filter is very efficient and useful for gently rolling off harsh high end and for smoothing out control signals. + +Args: + center-frequency (float, optional) + Hz/linear/radians (symbol, optional) + +Inlets: + 0 (signal): (signal) filter input + 1 (signal or float): (signal or float) Cutoff Frequency (Hz) + +Outlets: + 0 (signal): (signal) filter output + +Messages: int, float, Hz, clear, linear, radians, signal +""" + +mc_op_tilde = MaxObject('mc.op~') +""" +mc.op~ - Apply arithmetic operators to a multichannel signal + +The mc.op~ object, similar to jit.planeop, performs one of several arithmetic operations combining each sample of a multichannel input to produce a single-channel output. + +Inlets: + 0 (multi-channel signal): Input + +Outlets: + 0 (signal): Computed Output + +Messages: signal + +Attributes: op +""" + +mc_out_tilde = MaxObject('mc.out~') +""" +mc.out~ - Signal outputs for a patcher loaded by poly~ + +The mc.out~ object sends signals to multiple outlets of its poly~ object (or multiple channels within the output of mcs.poly~). The number of signal outlets is determined by the chans attribute. The maximum number of channels for any single mc.out~ object is 128. + +Args: + starting-outlet-number (int, required) + +Inlets: + 0 (multi-channel signal): Outputs 1-1 + +Messages: comment, signal + +Attributes: attr_comment, chans +""" + +mc_overdrive_tilde = MaxObject('mc.overdrive~') +""" +mc.overdrive~ - Soft-clipping signal distortion (multichannel) + +The overdrive~ object uses a waveshaping function to distort audio signals. It amplifies signals, limiting the maximum value of the signal to +/- 1. Values outside of this range are removed using "soft clipping" somewhat like that of an overdriven tube-based circuit. + +Args: + drive-factor (int, required) + drive-factor (float, optional) + +Inlets: + 0 (signal): (signal) Input signal, (float) Drive factor (1, 10) + 1 (signal or float): (signal or float) Drive factor (1, 10) + +Outlets: + 0 (OUTLET_TYPE): Signal Output + +Messages: int, float, signal +""" + +mc_pack_tilde = MaxObject('mc.pack~') +""" +mc.pack~ - Combine single inputs into a multichannel signal + +The mc.pack~ object combines inputs (signals, multichannel signals, floats) into a multi-channel signal. Unlike mc.combine~, mc.pack~ creates an output multichannel signal that contains exactly the number of channels as its number of inlets. + +Args: + size (int, required) + +Inlets: + 0 (signal, float): Input + 1 (signal, float): Input + +Outlets: + 0 (multi-channel signal): Output + +Messages: int, float, list, mute, signal + +Attributes: chans +""" + +mc_pattern_tilde = MaxObject('mc.pattern~') +""" +mc.pattern~ - Signal Pattern Sequencer and Recorder + +The mc.pattern~ object holds patterns -- sequences of signal values. Like seq~, playback is driven by a phasor, but unlike seq~, the output consists of signals on one or more audio channels. In addition to event recording, mc.pattern~ has an interface for generating events from Max messages or via algorithms. + +Args: + channels (int, required) + +Inlets: + 0 (multi-channel signal): Input Phasor(s) + +Outlets: + 0 (multi-channel signal): Pattern(s) + 1 (multi-channel signal): Pattern Data in Response to getcontent Message + 2 (dictionary): Pattern Data in Response to getcontent Message + +Messages: int, float, list, add, addrange, addrangeinclusive, clear, delete, deleterange, dictionary, dump, filldeviate, fillrange, getcontent, mute, quantize, ramp, read, record, setvalue, signal, wrap, write + +Attributes: autorecord, chans, defaultmute, defaultquantize, defaultramp, defaultwrap, embed, immediate, in, individual, ref +""" + +mc_peakamp_tilde = MaxObject('mc.peakamp~') +""" +mc.peakamp~ - Report the maximum amplitude of a signal (multichannel) + +Use the peakamp~ object to monitor an incoming signal and reports the absolute value of the peak amplitude of the signal it has received since the last time it was reported. + +Args: + ms-output-interval (int, optional) + +Inlets: + 0 (signal): (signal) any signal, (bang) report peak amplitude + 1 (int): (int) reporting interval + +Outlets: + 0 (float): (float) peak amplitude of input + +Messages: bang, ft1, in1, signal + +Attributes: interval, signed +""" + +mc_peek_tilde = MaxObject('mc.peek~') +""" +mc.peek~ - Read and write sample values (multichannel) + +Use peek~ to read and write sample values to a named buffer~. Unlike related objects index~ and poke~, values and indices are specified as Max messages, and the object will function even when the audio is not turned on. + +Args: + buffer-name (symbol, required) + buffer-channel (int, optional) + clipping-enable-flag (int, optional) + +Inlets: + 0 (INLET_TYPE): Sample Index + 1 (INLET_TYPE): Sample Value For Writing Into buffer~ + 2 (INLET_TYPE): Channel + +Outlets: + 0 (OUTLET_TYPE): buffer~ Value at Sample Index + +Messages: int, float, list, clip, (mouse), set +""" + +mc_pfft_tilde = MaxObject('mc.pfft~') +""" +mc.pfft~ - Spectral processing manager for patchers (multichannel) + +The pfft~ object is designed to simplify spectral audio processing using the Fast Fourier Transform (FFT). In addition to performing the FFT and the Inverse Fast Fourier Transform (IFFT), pfft~ (with the help of its companion fftin~ and fftout~ objects) manages the necessary signal windowing, overlapping and adding needed to create a real-time Short Term Fourier Transform (STFT) analysis/resynthesis system. + +Args: + subpatch-name (symbol, required) + FFT-size (int, optional) + overlap-factor (hop-size-denominator) (int, optional) + start-offset (int, optional) + full-spectrum-flag (0 or nonzero) (int, optional) + 'args' and list-of-argument-values (symbol, optional) + +Inlets: + 0 (signal, message): Input 1 + +Messages: bang, int, float, list, anything, clear, (mouse), mute, open, wclose + +Attributes: args, fftsize, float32, fullspectrum, legacy, overlap, patchername, startoffset +""" + +mc_phasegroove_tilde = MaxObject('mc.phasegroove~') +""" +mc.phasegroove~ - Control groove~ With phasor~ (multichannel) + +The phasegroove~ object converts ramps between 0 and 1 into a sample-increment signal that you can use to control the groove~ object. phasegroove~ must be connected to a groove~. Once connected, it knows about the groove~ object's loop points and the sample it is playing. + +Inlets: + 0 (signal): Phase Input + +Outlets: + 0 (signal): Connect to groove~ + +Messages: signal + +Attributes: conflict +""" + +mc_phaseshift_tilde = MaxObject('mc.phaseshift~') +""" +mc.phaseshift~ - Distort the phase of a signal (multichannel) + +The phaseshift~ object is a 2nd-order allpass filter. + +Args: + frequency (number, optional) + q (number, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Frequency + 2 (signal/float): (signal/float) Q + +Outlets: + 0 (signal): (signal) Output + +Messages: float, clear, signal +""" + +mc_phasewrap_tilde = MaxObject('mc.phasewrap~') +""" +mc.phasewrap~ - Wrap a signal between π and -π (multichannel) + +phasewrap~ takes any input signal and wrap it between π and -π values. + +Inlets: + 0 (INLET_TYPE): Input Signal to Phase-Wrap + +Outlets: + 0 (OUTLET_TYPE): Phase-Wrapped Signal Out + +Messages: signal +""" + +mc_phasor_tilde = MaxObject('mc.phasor~') +""" +mc.phasor~ - Generate sawtooth signals (multichannel) + +Use the phasor~ object to generate sawtooth waves suitable for sample-accurate control and timing tasks. For smoother sounding sawtooth generation, use the bandlimited saw~ object instead. The ramp rate can be set by frequency (Hz), or as an interval using the tempo-relative Max time format syntax. + +Args: + initial-frequency (list, optional) + +Inlets: + 0 (signal/float/symbol): Frequency or Time Period + 1 (float): Phase (float), Trigger Reset (signal) + +Outlets: + 0 (signal): Output (ramp cycle from 0 to 1) + +Messages: bang, int, float, list, anything, reset, signal + +Attributes: frequency, jitter, limit, lock, phaseoffset, syncupdate, transport +""" + +mc_pink_tilde = MaxObject('mc.pink~') +""" +mc.pink~ - Pink noise generator (multichannel) + +pink~ generates pink noise, as distinguished from white noise (which the MSP object noise~ generates). White noise has constant spectral power per hertz of bandwidth, while pink noise has constant power per octave. Subjectively, pink noise sounds less hissy than white noise. + +Inlets: + 0 (signal): (signal) Ignore This Inlet + +Outlets: + 0 (signal): (signal) The Noise +""" + +mc_pitchshift_tilde = MaxObject('mc.pitchshift~') +""" +mc.pitchshift~ - Ztx-based real-time pitchshifting (multichannel) + +Use the pitchshift~ object to load a perform pitch-shifting on an input signal. + +Args: + channels (int, optional) + +Inlets: + 0 (Signal): original signal, channel: 1 + 1 (Signal): Pitchshift factor (int or float) + +Outlets: + 0 (Signal): pitchshifted signal, channel: 1 + 1 (Signal): Current latency, reported in samples + +Messages: getlatency, signal + +Attributes: constantlatency, enabled, pitchshift, pitchshiftcent, quality, reportlatency, usecents +""" + +mc_play_tilde = MaxObject('mc.play~') +""" +mc.play~ - Position-based sample playback (multichannel) + +Use the play~ object as a playback interface for a buffer~. that plays back samples based on an offset within the buffer. It is typically used with the line~ object, but can be used with any signal that generates a changing position value in milliseconds. The groove~ object provides another option for sample playback. + + When the play~ object is created as mcs.play~ all of its signal outlets are combined into a single multichannel outlet. The behavior of mcs.play~ is otherwise identical to play~. + +Args: + buffer-name (symbol, required) + number-of-output-channels (int, optional) + +Inlets: + 0 (signal): Sample Time to Play in ms + +Outlets: + 0 (signal): (signal) Channel 1 Output + 1 (signal): bang When playback reaches destination or when playback is stopped with a 0 or stop message + +Messages: int, (mouse), pause, resume, set, signal, start, stop + +Attributes: interptime, loop, loopinterp +""" + +mc_playlist_tilde = MaxObject('mc.playlist~') +""" +mc.playlist~ - Play sound files with multichannel output + +Use mc.playlist~ to organize sound files and play them back using multichannel outputs. Each file's waveform is shown in a clip where you can select a portion of the file for playback. Drag clips within an mc.playlist~ to re-order them, or drag clips to other mc.playlist~ objects by using the dotted handle on the clip's left edge. + +Inlets: + 0 (INLET_TYPE): Messages + +Outlets: + 0 (multi-channel signal): Output + 1 (signal): Sync Output + 2 (signal): Playback Notifications + 3 (dict): Current content + +Messages: int, append, clear, (drag), getcontent, (mouse), next, pause, remove, resume, selection, selectionms, setclip, signal + +Attributes: accentcolor, allowreorder, annotation_name, basictuning, bgcolor, candicane2, candicane3, candicane4, candicane5, candicane6, candicane7, candicane8, candycane, channelcount, clipheight, color, elementcolor, expansion, followglobaltempo, formant, formantcorrection, loop, loopreport, mode, name, originallength, originaltempo, parameter_enable, parameter_mappable, pitchcorrection, pitchshift, pitchshiftcent, quality, reportprogress, selectioncolor, shadowalpha, shadowblend, shadowproportion, showname, slurtime, speed, style, textcolor, timestretch, waveformdisplay +""" + +mc_plus_tilde = MaxObject('mc.plus~') +""" +mc.plus~ - Add signals (multichannel) + +Use the +~ object to add two signals together, or to add an offset value to a signal. + +Args: + initial-offset (number, optional) + +Inlets: + 0 (signal/float): (signal/float) This + Right Inlet + 1 (signal/float): (signal/float) Left Inlet + This + +Outlets: + 0 (signal): (signal) Addition Result + +Messages: int, float, signal +""" + +mc_plusequals_tilde = MaxObject('mc.plusequals~') +""" +mc.plusequals~ - Signal accumulator (multichannel) + ++=~ adds all the values it receives. The result can grow very large, very fast. + +Args: + initial-sum (float, optional) + +Inlets: + 0 (signal): (signal) Accumulator Input + 1 (signal): (signal) Accumulator Input + +Outlets: + 0 (signal): (signal) Accumulator Output + +Messages: bang, set, signal +""" + +mc_poltocar_tilde = MaxObject('mc.poltocar~') +""" +mc.poltocar~ - Signal Polar to Cartesian coordinate conversion (multichannel) + +poltocar~ will take any given signal as a polar coordinate and output the cartesian conversion of that signal. + +Inlets: + 0 (INLET_TYPE): amplitude/alpha input + 1 (INLET_TYPE): phase/theta input + +Outlets: + 0 (OUTLET_TYPE): real/x output + 1 (OUTLET_TYPE): imaginary/y output + +Messages: signal +""" + +mc_poly_tilde = MaxObject('mc.poly~') +""" +mc.poly~ - Manage polyphony/DSP for patchers + +Use the mc.poly~ to encapsulate a patcher inside an object box, to specify the patcher filename and the number of instances you want to load as arguments to the poly~ object, and to control object processing and routing in the loaded patcher instances. + +Args: + patcher-name (symbol, required) + number-of-instances (int, optional) + local and flag (0 or 1) (symbol, optional) + 'up' and up-sampling-factor (symbol, optional) + 'down' and down-sampling factor (symbol, optional) + 'args' and list-of-argument-values (symbol, optional) + +Inlets: + 0 (multi-channel signal, message): Input 1 of + +Messages: bang, int, float, list, anything, (drag), allnotesoff, assignpatcher, busymap, bypass, (mouse), down, exclude, midievent, midinote, mpeevent, mute, mutemap, note, notemessage, open, setvalue, threadcount, up, wclose + +Attributes: args, filterparams, legacynotemode, midimode, mpemode, parallel, patchername, replicate, resampling, steal, target, voices, vs, zone +""" + +mc_pong_tilde = MaxObject('mc.pong~') +""" +mc.pong~ - Variable range signal folding (multichannel) + +Use the pong~ object to clip, fold, or wrap its input within the range of a low value and a high value. + +Args: + folding-mode (int, optional) + low-value (float, optional) + high-value (float, optional) + +Inlets: + 0 (signal/float): (signal/float) Input + 1 (signal/float): (signal/float) Lo val + 2 (signal/float): (signal/float) Hi val + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal + +Attributes: mode, range +""" + +mc_pow_tilde = MaxObject('mc.pow~') +""" +mc.pow~ - Signal power function (multichannel) + +pow~ raises the base value (set in the right inlet) to the power of the exponent (set in the left inlet). Either inlet can receive a signal, float or int. + +Args: + base-value (number, optional) + +Inlets: + 0 (signal/float): (signal/float) Input + 1 (signal/float): (signal/float) Base + +Outlets: + 0 (signal): (signal) Base raised to Input + +Messages: int, float, signal +""" + +mc_ramp_tilde = MaxObject('mc.ramp~') +""" +mc.ramp~ - Trigger a Single Ramp With an Audio Signal (multichannel) + +The ramp~ object generates a single signal ramp between a start and end value when it detects a change in an audio signal connected to its left inlet. The duration of the ramp can be a fixed value or based on the signal in ramp~'s second inlet. + +Args: + duration (float, optional) + +Inlets: + 0 (signal): Trigger Input + 1 (signal, float, timevalue): Duration Input + 2 (signal, float): Start + 3 (signal, float): End + +Outlets: + 0 (signal): Ramp Output + 1 (signal): bang When Ramp Completes + +Messages: int, float, anything, signal + +Attributes: curve, duration, end, interval, mode, reset, retrigger, start +""" + +mc_rampsmooth_tilde = MaxObject('mc.rampsmooth~') +""" +mc.rampsmooth~ - Smooth an incoming signal (multichannel) + +Smooths an incoming signal across n samples. Each time an incoming value changes, it begins a linear ramp to reach this value. + +Args: + ramp-up-samples (int, optional) + ramp-down-samples (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal, int): Ramp up + 2 (signal, int): Ramp down + +Outlets: + 0 (signal): (signal) Smoothed result + +Messages: int, float, ramp, signal + +Attributes: rampdown, rampup +""" + +mc_rand_tilde = MaxObject('mc.rand~') +""" +mc.rand~ - Band-limited random signal (multichannel) + +Use the rand~ object to generate a signal consisting of random values between -1 and 1 generated at a frequency specified by its input. It interpolates linearly between these values. + +Args: + initial-frequency (number, optional) + +Inlets: + 0 (signal/float): (signal/float) Frequency + +Outlets: + 0 (signal): (signal) The Noise Path + +Messages: int, float, signal +""" + +mc_range_tilde = MaxObject('mc.range~') +""" +mc.range~ - Generate a multichannel signal with a range of constant values + +The mc.range~ object generates a multichannel signal filled with constant values distributed across a defined range. + +Args: + size (int, required) + +Inlets: + 0 (multi-channel signal): Define Range + +Outlets: + 0 (multi-channel signal): Range + 1 (list): Range + 2 (setvalue): Range + +Messages: bang, signal + +Attributes: chans, exp, hi, inclusive, lo, reflection +""" + +mc_rate_tilde = MaxObject('mc.rate~') +""" +mc.rate~ - Time-scale the output of a phasor~ (multichannel) + +The rate~ object accepts an input signal from a phasor~ and time scales it by a multiplier received as a float in its right inlet. Numbers less than 1 create several ramps per phase cycle. Numbers greater than 1 create fewer ramps. This can be useful for implementing a phasor~-synchronized system in MSP. + +Args: + multiplier (float, optional) + sync-mode-flag (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (float/signal): (float/signal) Rate Multiplier + +Outlets: + 0 (signal): (signal) Time-Scaled Version of the Input + +Messages: int, float, goto, oneshot, reset, signal + +Attributes: sync +""" + +mc_rdiv_tilde = MaxObject('mc.rdiv~') +""" +mc.rdiv~ - Signal division (inlets reversed) (multichannel) + +The !/~ object functions just like the /~ object, but the inlet order is reversed. + +Args: + initial-divisor (number, optional) + +Inlets: + 0 (signal): (signal) Right Operand in Left Inlet! + 1 (signal/float): (signal/float) Left Operand in Right Inlet! + +Outlets: + 0 (signal): (signal) Quotient Out + +Messages: int, float, signal +""" + +mc_receive_tilde = MaxObject('mc.receive~') +""" +mc.receive~ + +Args: + object-name (symbol, required) + channel-count (int, optional) + +Inlets: + 0 (INLET_TYPE): set Changes Source + +Outlets: + 0 (multi-channel signal): Output + +Messages: (mouse), set, signal + +Attributes: chans, name +""" + +mc_record_tilde = MaxObject('mc.record~') +""" +mc.record~ - Record sound into a buffer (multichannel) + +record~ records a signal into a buffer~ object. You can specify how many channels to record with the optional input-channels argument. Recording stops when the buffer~ is filled. + +Args: + buffer-name (symbol, required) + input-channels (int, optional) + +Inlets: + 0 (signal): Record Ch 1 In, 1 Starts, 0 Stops + 1 (double): Recording Start Point in ms + 2 (double): Recording End Point in ms + +Outlets: + 0 (signal): Sync Out + +Messages: int, float, list, anything, (mouse), reset, set, signal + +Attributes: append, loop, loopend, loopstart, transport +""" + +mc_rect_tilde = MaxObject('mc.rect~') +""" +mc.rect~ - Antialiased rectangular (pulse) oscillator (multichannel) + +Use the rect~ object to generate an anti-aliased rectangle wave. + +Args: + frequency (number, optional) + pulse-width (number, optional) + +Inlets: + 0 (signal/float): (signal/float) frequency + 1 (signal/float): (signal/float) duty cycle + 2 (signal): (signal) sync input + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal, synctrig +""" + +mc_resize_tilde = MaxObject('mc.resize~') +""" +mc.resize~ - Resize a multichannel signal using selected channels + +The mc.resize~ object changes the number of channels in a connected single- or multichannel signal, producing an output multichannel signal with a number of channels specified by its argument. Optionally, the output can consist of selected channels of the input, or, when increasing the number of channels, the additional output channels can replicate the existing inputs. + +Args: + channels (int, required) + +Inlets: + 0 (signal or multi-channel signal): Input + +Outlets: + 0 (multi-channel signal): Output + +Messages: signal + +Attributes: chans, replicate, select +""" + +mc_reson_tilde = MaxObject('mc.reson~') +""" +mc.reson~ - Resonant bandpass filter (multichannel) + +Use the reson~ object when you need a resonant bandpass filter. + +Args: + initial-gain (float, optional) + center-frequency (float, optional) + Q (float, optional) + +Inlets: + 0 (signal): (signal) Input to Filter + 1 (signal/float): (signal/float) Input Gain + 2 (signal/float): (signal/float) Center Frequency + 3 (signal/float): (signal/float) Q (Resonance) + +Outlets: + 0 (signal): (signal) Filtered Output + +Messages: int, float, list, clear, signal + +Attributes: cf, gain, q +""" + +mc_retune_tilde = MaxObject('mc.retune~') +""" +mc.retune~ - Ztx-based pitch detection and pitchshift (multichannel) + +Args: + standard pitch (int, required) + +Inlets: + 0 (Signal): original signal + 1 (Signal): pitch (Hz) + 2 (Signal): detune modulation (Cents) + +Outlets: + 0 (Signal): retuned signal + 1 (Signal): detected frequency + 2 (Signal): closest note + 3 (Signal): deviation in cents + 4 (List): closest note and deviation in cents + +Messages: list, defaulttuning, flush, getlatency, signal + +Attributes: correction_ambience_threshold, correction_amount, correction_bypass, correction_threshold, enablednotes, notebase, notelist, pitchdetection, quality, reportlatency, retune, use_16bit, windowsize +""" + +mc_rminus_tilde = MaxObject('mc.rminus~') +""" +mc.rminus~ - Signal subtraction (inlets reversed) (multichannel) + +The !-~ object functions just like the -~ object, but the inlet order is reversed. + +Args: + initial-subtraction-value (number, optional) + +Inlets: + 0 (signal): (signal) Right Operand in Left Inlet! + 1 (signal/float): (signal/float) Left Operand in Right Inlet! + +Outlets: + 0 (signal): (signal) Difference Out + +Messages: int, float, signal +""" + +mc_round_tilde = MaxObject('mc.round~') +""" +mc.round~ - Round an input signal value (multichannel) + +Use the round~ object to round a signal input to an integer multiple. + +Args: + int or float (number, optional) + +Inlets: + 0 (signal): Input + 1 (signal/float): Round to nearest this + +Outlets: + 0 (signal): Output + +Messages: int, float, signal + +Attributes: nearest +""" + +mc_route = MaxObject('mc.route') +""" +mc.route - Direct output of messages based on an index received + +The mc.route objects works with the non-signal output of objects such as mc.snapshot~, mc.peakamp~, poly~ and mc.poly~ (when non-signal outputs are used). These objects precede non-signal output with a voice index identifying the channel or patcher instance that produced the value. mc.route can use this index to direct the value to an outlet. + +Args: + Outlets (int, optional) + +Inlets: + 0 (INLET_TYPE): Message to Route + 1 (int): Voice Index + +Outlets: + 0 (int): Per-Voice Output + 1 (int): Output for Voice 2 + +Messages: bang, int, float, list, anything, voice +""" + +mc_sah_tilde = MaxObject('mc.sah~') +""" +mc.sah~ - Sample and hold a signal (multichannel) + +Use sah~ to capture ("sample") and output ("hold") a value from an input signal whenever a trigger signal satisfies a threshold value according to one of several trigger conditions. The default trigger mode (Ascending) requires the signal to go from being at or below the threshold value to above it. At the moment the trigger condition is satisfied, the input signal is sampled and "held" until the trigger condition is satisfied again, at which point the input is sampled again. Generally this allows one signal to be synchronized to the behavior of another. + +Args: + initial-trigger-value (number, optional) + +Inlets: + 0 (signal): Values To Sample, double Sets Trigger Threshold + 1 (signal): Trigger Input + +Outlets: + 0 (signal): Output + +Messages: float, signal + +Attributes: duration, thresh, triggermode +""" + +mc_sampstoms_tilde = MaxObject('mc.sampstoms~') +""" +mc.sampstoms~ - Convert time from samples to milliseconds (multichannel) + +Use the sampstoms~ object to convert an incoming signal carrying a time value in samples and output a signal which converts that number of samples to a number of milliseconds (at the current sampling rate). + +Inlets: + 0 (INLET_TYPE): Number of Samples In, signal to Use For Sampling Rate + +Outlets: + 0 (signal): (signal) Milliseconds At Input signal or Current Sampling Rate + 1 (double): (float) Milliseconds At Input signal or Current Sampling Rate + +Messages: int, float, list, signal +""" + +mc_sash_tilde = MaxObject('mc.sash~') +""" +mc.sash~ - Sample and Hold with Memory (multichannel) + +The sash~ object performs sample-and-hold operations on an input signal but unlike the sah~ includes a buffer (the extra "s" in sash~ is for "storage") that can holds samples of the input. Sample capture and sample output are triggered independently of each other, and sash~ includes a variety of methods for selecting the output sample from the memory buffer. + +Inlets: + 0 (signal): Input + 1 (signal, float): Sample Trigger + 2 (signal, float): Advance Trigger + +Outlets: + 0 (signal): Output + +Messages: int, float, list, signal + +Attributes: advancelevel, dir, maxsize, mode, samplelevel, size +""" + +mc_saw_tilde = MaxObject('mc.saw~') +""" +mc.saw~ - Antialiased sawtooth oscillator (multichannel) + +Use the saw~ object to generate an anti-aliased sawtooth wave. + +Args: + initial-frequency (number, optional) + +Inlets: + 0 (signal/float): (signal/float) frequency + 1 (signal): (signal) sync trigger + +Outlets: + 0 (signal): (signal) Input signal + +Messages: int, float, signal, synctrig +""" + +mc_scale_tilde = MaxObject('mc.scale~') +""" +mc.scale~ - Map an input range of signal values to an output range (multichannel) + +Use the scale~ object to map an input range of signal values to an output range. The ranges can be specified with hi and lo reversed for inverted mapping. If specified, the mapping can also be exponential. + +Args: + minimum-in-value (number, required) + maximum-in-value (number, required) + minimum-out-value (number, required) + maximum-out-value (number, required) + scaling-curve (float, optional) + +Inlets: + 0 (signal): (signal) value to be scaled + 1 (signal/float): (signal/float) low input value + 2 (signal/float): (signal/float) high input value + 3 (signal/float): (signal/float) low output value + 4 (signal/float): (signal/float) high output value + 5 (signal/float): (signal/float) exponential base value + +Outlets: + 0 (signal): (signal) scaled output value + +Messages: int, float, signal + +Attributes: classic +""" + +mc_selector_tilde = MaxObject('mc.selector~') +""" +mc.selector~ - Assign one of several inputs to an outlet (multichannel) + +Use the selector~ object to choose between one of several input signals (or none). The selector~ is similar to the Max switch object but for signals, however if no input is chosen, it outputs a signal composed of zero values. + + When the selector~ object is created as mcs.selector~ all of its signal inlets are combined into a single multichannel inlet. The behavior of mcs.selector~ is otherwise identical to selector~ with the exception that mcs.selector~ changes its number of inputs (auto-adapts) as the number of inputs in the multi-channel signal connected to its right inlet change. + +Args: + number-of-inputs (int, optional) + initially-open-inlet (int, optional) + +Inlets: + 0 (int/signal): int/signal Turns Input Off or Routes to Output + 1 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Output + +Messages: bang, int, float, next, signal + +Attributes: ramptime, stepmode +""" + +mc_send_tilde = MaxObject('mc.send~') +""" +mc.send~ + +Args: + object-name (symbol, required) + channel-count (int, optional) + +Inlets: + 0 (multi-channel signal): Send to receive~ + +Messages: clear, (mouse), set, signal + +Attributes: name +""" + +mc_separate_tilde = MaxObject('mc.separate~') +""" +mc.separate~ - Split a multichannel signal + +The mc.separate~ object splits a multichannel signal into two or more multichannel signals with specific channel counts. + +Args: + channels per outlet (int, optional) + +Inlets: + 0 (multi-channel signal): Input to Separate + +Outlets: + 0 (multi-channel signal): Separated Output + 1 (multi-channel signal): Separated Output 2 (1 Channels) + +Messages: signal + +Attributes: chans +""" + +mc_seq_tilde = MaxObject('mc.seq~') +""" +mc.seq~ - Signal-driven event sequencer (multichannel) + +The seq~ object is an event sequencer that is driven by a signal input. seq~ can be used to create looping sequences of control data that are synchronized to a phasor~. + +Inlets: + 0 (signal): phasor~ input, commands, messages to be sequenced + +Outlets: + 0 (anything): sequence output + 1 (list): dump output + 2 (symbol): id on read, (bang) when done reading + +Messages: bang, int, float, list, anything, add, clear, delete, dump, erase, offset, overdub, play, read, record, seq, seqnum, signal, symbol, write +""" + +mc_sfizz_tilde = MaxObject('mc.sfizz~') +""" +mc.sfizz~ - Sfz format sample player (multichannel) + +sfizz~ is a player for files in the Sfz format. The format uses simple text files that specify how audio sample files are triggered by MIDI notes and controllers. (Information on the format is available at + + sfzformat.com + + .) The object accepts MIDI messages and produces two or more audio outputs. sfizz~ makes use of the open source + + Sfizz library project + + that supports a + + large subset of standard Sfz opcodes + +Args: + filename (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Note Number or midievent Message + 1 (INLET_TYPE): Velocity + +Outlets: + 0 (OUTLET_TYPE): Audio Output 1 + 1 (OUTLET_TYPE): Audio Output 2 + +Messages: int, float, list, (drag), (mouse), dictionary, midievent, read, readagain, signal + +Attributes: base, defaultpathname, filename, map, mapname, mid, outputs, pathmode, ref, scale, scalename, silent, voices, volume +""" + +mc_sfplay_tilde = MaxObject('mc.sfplay~') +""" +mc.sfplay~ - Play audio file from disk (multi-channel) + +Use the mc.sfplay~ object to play audio files from disk. Supported formats include AIFF, WAVE, MP3, OGG, FLAC, M4A, CAF, WF64, WAVE64, and Raw Data. + +Args: + sflist-object-name (symbol, optional) + number-of-output-channels (int, optional) + buffer-size (int, optional) + position-outlet-flag (int, optional) + object-reference-name (symbol, optional) + +Inlets: + 0 (signal/msg): open Opens File, int Plays Cue, 0 Stops + 1 (signal/float): Speed Input + +Outlets: + 0 (signal): Multi-Channel Signal Output + 1 (signal): bang When Done Playing + +Messages: int, float, list, anything, (drag), clear, dictionary, embed, fclose, loopone, modout, offset, open, openraw, pause, preload, preloadn, print, resume, samptype, seek, set, signal, srate, srcchans + +Attributes: audiofile, basictuning, chans, followglobaltempo, formant, formantcorrection, loop, mode, name, originallength, originaltempo, pitchcorrection, pitchshift, pitchshiftcent, quality, slurtime, speed, timestretch +""" + +mc_sfrecord_tilde = MaxObject('mc.sfrecord~') +""" +mc.sfrecord~ - Record to audio file on disk (multi-channel) + +Use the mc.sfrecord~ object to record and save multi-channel MSP output as an audio file. + +Args: + number-of-channels (int, optional) + buffer-size (int, optional) + +Inlets: + 0 (multi-channel signal): (multi-channel signal) Record Input, 1/0 Record On/Off + +Outlets: + 0 (signal): (signal) elapsed time (ms) + +Messages: int, loop, open, print, record, samptype, signal + +Attributes: beginramp, bitdepth, dither, endramp, nchans, quantization, resample, sortloop +""" + +mc_shape_tilde = MaxObject('mc.shape~') +""" +mc.shape~ - Time-scaled Breakpoint Envelope Generator (multichannel) + +An envelope for the shape~ object can be defined using the same format as the line~ or zigzag~ objects (and edited graphically by connecting a function object). Unlike line~ the time values of shape~ are normalized so that the output occurs within signal ramp of a phasor from 0 to 1 (or 1 to 0). This means you can trigger the output sample-accurately and determine the time of the function by using different ramp durations (or phasor~ frequencies). + +Inlets: + 0 (signal): Input Phasor, Define Function + +Outlets: + 0 (signal): Time-Scaled Function + +Messages: int, float, list, signal + +Attributes: constant, curvemode, syncupdate +""" + +mc_sig_tilde = MaxObject('mc.sig~') +""" +mc.sig~ - Convert numbers into audio signals (multichannel) + +Use the sig~ object to convert regular numbers into audio signals. + +Args: + initial-output-value (number, optional) + +Inlets: + 0 (float): (signal) Order Forcing, float Sets Value + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, list, set, signal +""" + +mc_sinh_tilde = MaxObject('mc.sinh~') +""" +mc.sinh~ - Signal hyperbolic sine function (multichannel) + +Use the sinh~ object to calculate and output a signal that is the hyperbolic sine function of each sample of the input signal. + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Sinh (x) Out + +Messages: signal +""" + +mc_sinx_tilde = MaxObject('mc.sinx~') +""" +mc.sinx~ - Signal sine function (multichannel) + +sinx~ is a real sine function whose input expects values between 0 and 2π (similar to cosx~ but unlike cos~ which is designed to work with phasor~'s output from 0 to 1). + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Sin (x) Out + +Messages: signal +""" + +mc_slide_tilde = MaxObject('mc.slide~') +""" +mc.slide~ - Filter a signal logarithmically (multichannel) + +Use the slide~ object for envelope following and lowpass filtering. + +Args: + slide-up (float, optional) + slide-down (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal, float): Slide up + 2 (signal, float): Slide down + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, reset, signal + +Attributes: slidedown, slideup +""" + +mc_snapshot_tilde = MaxObject('mc.snapshot~') +""" +mc.snapshot~ - Convert signal values to numbers (multichannel) + +Use the snapshot~ object to convert a signal value into a float message when a bang is received or according to a specified interval. The interval can be set to a fixed or tempo-relative rate using the Max time format syntax. + +Args: + reporting-interval (list, optional) + +Inlets: + 0 (signal): In, bang Reports Signal Value + 1 (signal): Internal Clock Interval in ms + +Outlets: + 0 (float): Signal Values + +Messages: bang, int, float, list, anything, sampleinterval, signal, start, stop + +Attributes: active, interval, offset +""" + +mc_snowfall_tilde = MaxObject('mc.snowfall~') +""" +mc.snowfall~ - Phasor-Driven Particle (multichannel) + +The snowfall~ object controls a multi-dimensional particle as one or more audio ramps whose lifetime is triggered and controlled by an input phasor ramp from 0 to 1. The object will typically be used within a larger system of quasi-independent particles using the MC Wrapper as mc.snowfall~. + +Args: + dimenions (int, optional) + +Inlets: + 0 (signal): Phasor Input + +Outlets: + 0 (signal): Particle Output + +Messages: signal + +Attributes: boundarymode, dimensions, direction, directiondev, endmode, endvalue, energyramp, initial, initialdev, interval, intervaldev, max, min, scalemax, scalemin, squish, startmode, wanderprob +""" + +mc_snowphasor_tilde = MaxObject('mc.snowphasor~') +""" +mc.snowphasor~ - Control a Population of Phasors + +The mc.snowphasor~ object generates phasor ramps in multiple audio channels according to global controls such as an average rate. The object can also trigger ramps from a multi-channel audio signal. + +Inlets: + 0 (INLET_TYPE): Audio Trigger + 1 (signal): Ramp Duration + +Outlets: + 0 (multi-channel signal): Phasors + +Messages: signal + +Attributes: busymapname, chans, interval, intervalcycle, intervaldev, mode, perchantriggers, prob, probdev, rampdev, ramptime, rate, ratedev, threshold, usebusymap +""" + +mc_spike_tilde = MaxObject('mc.spike~') +""" +mc.spike~ - Report intervals of zero to non-zero transitions (multichannel) + +spike~ reports intervals of zero to non-zero transitions. + +Args: + refractory-period (int, float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (double): (float) Refractory period + +Outlets: + 0 (double): (float) Outputs interval on zero to non-zero transition + +Messages: bang, ft1, in1, signal +""" + +mc_sqrt_tilde = MaxObject('mc.sqrt~') +""" +mc.sqrt~ - Square root of a signal (multichannel) + +sqrt~ will output a signal which is the square-root function of the input signal. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Square Root + +Messages: signal +""" + +mc_stash_tilde = MaxObject('mc.stash~') +""" +mc.stash~ - Store and Recall Audio Signal Values (multichannel) + +Use the stash~ object to store and recall a buffer of signal values. In one mode, stash~ can perform sample-and-hold operations on an input signal but unlike the sah~, stash~ reads from a buffer rather than holds a single sample. stash~ can be a simple interpolating lookup table or audio-rate step sequencer. + +Args: + sample-thresh (float, optional) + advance-thresh (float, optional) + +Inlets: + 0 (signal, float): Input + 1 (signal, float): Sample Trigger + 2 (signal, float): Advance Trigger or Index + 3 (signal, float): Write Index + +Outlets: + 0 (signal): Output + 1 (signal): Index + +Messages: bang, int, float, list, signal + +Attributes: advancelevel, advancetriggermode, dir, duration, extend, interp, maxsize, mode, samplelevel, sampletriggermode, size, writemode +""" + +mc_stepdiv_tilde = MaxObject('mc.stepdiv~') +""" +mc.stepdiv~ - Generate Phasors for Each Step of a Function (multichannel) + +The stepdiv~ object produces a signal output consisting of a sequence of phasors according to the delta times in a breakpoint function list produced by the function object. When a phasor signal is connected to the left inlet, stepdiv~ subdivides the phasor according to the relative times of the breakpoints. When no signal input is connected, stepdiv~ produces phasors over the specified delta times. Connect the left and right outputs of stepdiv~ to stepfun~ to generate the actual function data. + +Inlets: + 0 (signal): Input + +Outlets: + 0 (signal): Output + 1 (signal): Step Number + +Messages: bang, int, float, list, signal, what + +Attributes: curvemode, loop, pattern, syncupdate +""" + +mc_stepfun_tilde = MaxObject('mc.stepfun~') +""" +mc.stepfun~ - Generate a Function Sequenced by Input Phasors (multichannel) + +The stepfun~ object generates a breakpoint function whose timing is determined by a seqeuence of input phasor ramps. If the input ramps are non-linear, the output of stepfun~ will be similarly non-linear. + +Inlets: + 0 (signal): Input + 1 (signal, int): Step Number + +Outlets: + 0 (signal): Output + 1 (signal): Step Number + +Messages: bang, int, float, list, signal, step + +Attributes: curvemode, curvepattern, pattern, syncupdate +""" + +mc_stereo_tilde = MaxObject('mc.stereo~') +""" +mc.stereo~ + +Inlets: + 0 (multi-channel signal): Input + 1 (multi-channel signal): Pan Positions (0 - 1) + +Outlets: + 0 (multi-channel signal): Output (2 Channels) + +Messages: signal + +Attributes: activechans, autogain, busymapname, chans, linearpanmode, linearpanscalefactor, pancontrolmode, pans, usebusymap +""" + +mc_stutter_tilde = MaxObject('mc.stutter~') +""" +mc.stutter~ - Signal capture buffer for granular playback (multichannel) + +The stutter~ object keeps a history of its signal input (left inlet). Upon receiving an int (left inlet), it copies that number of the most recently received samples to another playback buffer. This buffer may be cycled through by its phase, 0-1 (right inlet). On receiving a bang (left inlet) or a trigger signal (middle inlet), the last integer number of samples are copied to the playback buffer. + +Args: + max-buffer-length (int, required) + initial-buffer-size (int, required) + trigger-polarity (int, required) + number-of-copied-samples (int, required) + number-of-outputs (int, optional) + +Inlets: + 0 (signal): (signal) Memory Input + 1 (signal): (signal) Trigger + 2 (signal): (signal) Playback Input 1 + +Outlets: + 0 (signal): (signal) Playback Output 1 + +Messages: bang, int, ampvar, clear, dropout, maxsize, polarity, print, repeat, setbuf, signal +""" + +mc_subdiv_tilde = MaxObject('mc.subdiv~') +""" +mc.subdiv~ - Integer Subdivision of a Phasor (multichannel) + +The subdiv~ object evenly subdivides an input phasor signal into any integer number of output phasor signals. + +Args: + subdivisions (int, required) + +Inlets: + 0 (signal): Phasor Input + +Outlets: + 0 (signal): Output + 1 (signal): Step Number + 2 (int) + +Messages: int, float, signal + +Attributes: div, lockprob, pattern, prob, silentmode, syncupdate +""" + +mc_svf_tilde = MaxObject('mc.svf~') +""" +mc.svf~ - State-variable filter with simultaneous outputs (multichannel) + +The svf~ object is an implementation of a state-variable filter algorithm described in Hal Chamberlin's book, "Musical Applications of Microprocessors." A unique feature of this filter object is that it produces lowpass, highpass, bandpass, and bandreject (notch) output simultaneously - all four are available as outlets. + +Args: + center-frequency (float, optional) + resonance (float, optional) + Hz (symbol, optional) + linear (symbol, optional) + radians (symbol, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Cutoff Frequency (Hz) + 2 (signal/float): (signal/float) Resonance (0-1) + +Outlets: + 0 (signal): (signal) Low-pass Output + 1 (signal): (signal) High-pass Output + 2 (signal): (signal) Band-pass Output + 3 (signal): (signal) Notch Output + +Messages: int, float, Hz, clear, linear, radians, signal +""" + +mc_swing_tilde = MaxObject('mc.swing~') +""" +mc.swing~ - Subdivide a phasor into two unequal phasors (multichannel) + +The swing~ object outputs two phasor signals in the space of one input phasor, with the ability to adjust the "swing" or proportion of the time of the input phasor given to the first of the two output phasors. If the swing is set to 0.5, both the first and second output phasors are equal. But if the swing is set to 0.75, the first phasor lasts for three fourths of the input and the second phasor lasts for one fourth of the time. + +Args: + swing (float, optional) + +Inlets: + 0 (signal): Phasor Input + +Outlets: + 0 (signal): Output + 1 (signal): Step Number + 2 (int): Step Number + +Messages: int, float, signal + +Attributes: swing, syncupdate +""" + +mc_sync_tilde = MaxObject('mc.sync~') +""" +mc.sync~ - Synchronize MSP with an external source (multichannel) + +sync~ outputs a 0-1 ramp, like phasor~. The frequency of the ramp can be specified in beats per minute (BPM), or by sending sync~ a tempo reference via tap tempo, MIDI beat clock, or an audio signal containing a 'click track.' Also, sync~ generates MIDI beat clock to synchronize external devices. + +Inlets: + 0 (INLET_TYPE): synchronization input and messages to sync~ + +Outlets: + 0 (OUTLET_TYPE): synchronized ramp (0-1) + 1 (OUTLET_TYPE): BPM and beat detect information + 2 (OUTLET_TYPE): MIDI beat clock + +Messages: bang, int, float, bpm, midioffset, offset, ppq, signal, start, stop + +Attributes: rtport +""" + +mc_table_tilde = MaxObject('mc.table~') +""" +mc.table~ - Signal Table Lookup (multichannel) + +Use table~ to remap incoming signal values with a table object. + +Inlets: + 0 (signal): Input + +Outlets: + 0 (signal): Output + +Messages: bang, int, float, (mouse), goto, next, prev, signal + +Attributes: annotation_name, embed, extend, inmap, inputmode, interp, name, outscale, parameter_enable, parameter_mappable, range, signed, size, triggermode +""" + +mc_tanh_tilde = MaxObject('mc.tanh~') +""" +mc.tanh~ - Signal hyperbolic tangent function (multichannel) + +Use the tanh~ object to calculate and output a signal that is the hyperbolic tangent function of each sample of the input signal. + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Tanh (x) Out + +Messages: signal +""" + +mc_tanx_tilde = MaxObject('mc.tanx~') +""" +mc.tanx~ - Signal tangent function (multichannel) + +Use the tanx~ object to calculate and output a signal that is the tangent function of each sample of the input signal. The tanx~ object is a true π based function - it varies from the tanh~ object, whose output is based around 1 and is intended for use as a lookup table with the phasor~ object. + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Tan (x) Out + +Messages: signal +""" + +mc_tapin_tilde = MaxObject('mc.tapin~') +""" +mc.tapin~ - Input to a delay line + +mc.tapin~ receives a multichannel in and copies into a delay line. Using mc.tapout~, you can read from the delay line at various delay times. You must connect the outlet of an mc.tapin~ object to the mc.tapout~ object you want to use with the delay line. Note that this is not a signal connection, since no signal travels between the objects. It is merely a way to indicate that the objects share the same delay memory. + +Args: + maximum-delay (number, optional) + +Inlets: + 0 (multi-channel signal): Input Written To Delay Line + +Outlets: + 0 (OUTLET_TYPE): Connect To One Or More mc.tapout~ Objects + +Messages: int, float, clear, freeze, signal +""" + +mc_tapout_tilde = MaxObject('mc.tapout~') +""" +mc.tapout~ - Output from a delay line + +The outlet of an mc.tapin~ object must be connected to the left inlet of mc.tapout~ in order for the delay line to function. + + + The mc.tapout~ object has one or more inlets and one or more outlets. A delay time signal or number received in an inlet affects the output signal coming out of the outlet directly below the inlet. + +Args: + initial-delay (number, optional) + +Inlets: + 0 (signal/float): (signal/float) Delay Time in ms. Signal-based delay uses interpolation, which introduces a one-sample delay + +Outlets: + 0 (signal): (signal) Delayed Output + +Messages: int, float, list, signal, tapconnect + +Attributes: unique +""" + +mc_target = MaxObject('mc.target') +""" +mc.target - Format messages to control MC objects + +The mc.target object simpifies creating the setvalue messages used to target specific instances within MC wrapper objects. + +Args: + prepend (symbol, optional) + initial voice (int, optional) + +Inlets: + 0 (INLET_TYPE): Message to Target + 1 (int): Voice Index + +Outlets: + 0 (OUTLET_TYPE): setvalue Message Output + 1 (int, voice): Voice Index + +Messages: bang, int, float, list, anything, voice + +Attributes: append, prepend +""" + +mc_targetlist = MaxObject('mc.targetlist') +""" +mc.targetlist - Format messages based on inlet number for controlling MC objects + +The mc.targetlist object simplifies creating the setvalue messages used to target specific instances within MC wrapper objects. The object maps the index of an inlet where a message was received to a voice index used in the resulting setvalue message. + +Args: + prepend (symbol, optional) + voice index (int, optional) + inlet count (int, optional) + +Inlets: + 0 (INLET_TYPE): Message for Channel 1 + 1 (INLET_TYPE): Message for Channel 2 + +Outlets: + 0 (OUTLET_TYPE): setvalue Message Output + 1 (int): Voice Index + +Messages: bang, int, float, list, anything + +Attributes: listmode +""" + +mc_teeth_tilde = MaxObject('mc.teeth~') +""" +mc.teeth~ - Comb filter with feedforward and feedback delay control (multichannel) + +The teeth~ object implements a comb filter, in which a slightly delayed version of a signal is added to itself, causing phase cancellations and a spectrum that looks like a comb. + +Args: + maxdelaytime (float, optional) + feedforward-delay (float, optional) + feedback-delay (float, optional) + gain (float, optional) + feedforward-gain (float, optional) + feedback-gain (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Feedforward Delay in ms + 2 (signal/float): (signal/float) Feedback Delay in ms + 3 (signal/float): (signal/float) Gain Coefficient + 4 (signal/float): (signal/float) Feedforward Coefficient + 5 (signal/float): (signal/float) Feedback Coefficient + +Outlets: + 0 (signal): (signal) Filter Output + +Messages: int, float, clear, signal, list +""" + +mc_thresh_tilde = MaxObject('mc.thresh~') +""" +mc.thresh~ - Detect signal above a set level (multichannel) + +Use the thresh~ object to detect signals which exceed a specified level. + +Args: + low/reset-threshold (float, required) + high/set-threshold (float, required) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Low Threshold + 2 (signal/float): (signal/float) High Threshold + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, list, signal +""" + +mc_times_tilde = MaxObject('mc.times~') +""" +mc.times~ - Multiply two signals (multichannel) + +*~ is a signal multiplier-operator that outputs a signal which is the multiplication between two signals. + +Args: + initial-multiplier (number, optional) + +Inlets: + 0 (Signal/Float): (Signal/Float) This * Right Inlet + 1 (Signal/Float): (Signal/Float) Left Inlet * This + +Outlets: + 0 (Signal): (signal) Multiplication Result + +Messages: int, float, signal +""" + +mc_train_tilde = MaxObject('mc.train~') +""" +mc.train~ - Pulse train generator (multichannel) + +train~ generates a pulse signal whose period is specifiable in terms of milliseconds (see <~ for a method of making a pulse wave at a specified frequency). It also sends out a bang when going from 0 to 1, so it can be used as a metronome with a floating-point interval. + +Args: + inter-pulse-interval (number, optional) + pulse-width (number, optional) + phase (number, optional) + +Inlets: + 0 (signal/float): (signal/float) Pulse Interval in ms + 1 (signal/float): (signal/float) Pulse Width from 0 to 1 + 2 (signal/float): (signal/float) Phase from 0 to 1 + +Outlets: + 0 (signal): (signal) Pulse Output + 1 (signal): bang on 0 to 1 Transition + +Messages: bang, int, float, signal + +Attributes: interval, phase, resetmode, width +""" + +mc_transpose_tilde = MaxObject('mc.transpose~') +""" +mc.transpose~ - Reorganize multichannel signals + +The mc.transpose~ object groups one or more multichannel signal inputs into multichannel signal outputs where channels in the outputs share the same channel index in the inputs. + +Args: + inlets (int, optional) + outlets (int, optional) + +Inlets: + 0 (multi-channel signal): Input to Transpose + 1 (multi-channel signal): Input 2 to Transpose + +Outlets: + 0 (multi-channel signal): Transposed Output + 1 (multi-channel signal): Transposed Output 2 + +Messages: signal +""" + +mc_trapezoid_tilde = MaxObject('mc.trapezoid~') +""" +mc.trapezoid~ - Trapezoidal wavetable (multichannel) + +trapezoid~ is a trapezoidal wavetable with signal inputs to change ramp up/down phase position. The default lo/hi points are 0. and 1., but may be changed using the lo/hi messages. + +Args: + ramp-up (float, optional) + ramp-down (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Point 1 + 2 (signal/float): (signal/float) Point 2 + +Outlets: + 0 (signal): (signal) Output + +Messages: float, signal + +Attributes: hi, lo, wrapmode +""" + +mc_tri_tilde = MaxObject('mc.tri~') +""" +mc.tri~ - Antialiased triangular oscillator (multichannel) + +tri~ generates a triangle wave whose component frequencies are resistant to aliasing. + +Args: + initial-frequency (number, optional) + duty-cycle (float, optional) + +Inlets: + 0 (signal/float): (signal/float) Frequency + 1 (signal/float): (signal/float) Duty Cycle + 2 (signal): (signal/float) Sync Input + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal +""" + +mc_triangle_tilde = MaxObject('mc.triangle~') +""" +mc.triangle~ - Triangle/ramp wavetable (multichannel) + +triangle~ is a triangle/ramp wavetable with signal input to change phase offset of the peak value. The default lo/hi points are -1. and 1., but may be changed using the lo/hi messages. + +Args: + peak-value-phase-offset (float, optional) + +Inlets: + 0 (signal): (signal) Phase + 1 (signal/float): (signal/float) Point 1 + +Outlets: + 0 (signal): (signal) Output + +Messages: float, signal + +Attributes: hi, lo +""" + +mc_trunc_tilde = MaxObject('mc.trunc~') +""" +mc.trunc~ - Truncate fractional signal values (multichannel) + +trunc~ converts signals with values such as 1.75 to 1.0. Negative values are modified so that -1.75 becomes -1.0. This object is very simple but computationally expensive. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Integer Part of Input + +Messages: signal +""" + +mc_twist_tilde = MaxObject('mc.twist~') +""" +mc.twist~ - Make Linear Ramps Curved (multichannel) + +The twist~ object accepts a ramp between 0 and 1 (such as one generated by phasor~) and produces a piecewise linear approximation of an expoential function using the same algorithm as the curve~ object. The curvature of the ramp is controlled by the curve attribute that ranges from -1 to 1. A curve value of 0 produces an output ramp identical to the input. + +Inlets: + 0 (signal): Ramp Input + 1 (signal/float): Curve Amount + +Outlets: + 0 (signal): Curved Ramp Out + +Messages: int, float, signal, test + +Attributes: curve, shapemode, syncupdate +""" + +mc_unpack_tilde = MaxObject('mc.unpack~') +""" +mc.unpack~ - Split a multichannel signal into single-channel signals + +The mc.unpack~ object splits a multichannel signal connected to its inlet into single-channel signals. The number of single-channel outputs is specified by its argument. + +Args: + size (int, required) + +Inlets: + 0 (multi-channel signal): Input + +Outlets: + 0 (signal): Output 1 + 1 (signal): Output 2 + +Messages: signal + +Attributes: replicate, select +""" + +mc_updown_tilde = MaxObject('mc.updown~') +""" +mc.updown~ - Trapezoidal Function Generator With Constant Attack and Release (multichannel) + +The updown~ object is driven by a ramp from 0 - 1 or 1 - 0. It generates a trapezoidal function where the attack and release times are independent of the speed of the input ramp, unlike trapezoid~ where start and end times are specified as a proportion of the total input ramp cycle and thus will vary with the speed of the input ramp. + + + Note that the up phase of the updown~ object's output occurs after the reset of a phasor or a zero-to-non-zero transition, whether the input ramp moves up or down. The down phase of the output occurs in the time before a reset (or the end of the ramp) is expected to occur. + +Inlets: + 0 (signal): Phasor Input + +Outlets: + 0 (signal): Trapezoidal Output + +Messages: bang, signal + +Attributes: down, level, reset, up +""" + +mc_vectral_tilde = MaxObject('mc.vectral~') +""" +mc.vectral~ - Vector-based envelope follower (multichannel) + +Use the vectral~ object to filter frame-based signal data such as the output of the fft~ object. + +Args: + vector-size (int, optional) + +Inlets: + 0 (signal): (signal) Output Index + 1 (signal): (signal) Input Index + 2 (signal): (signal) Input Value + +Outlets: + 0 (signal): (signal) Output Value + +Messages: clear, deltaclip, rampsmooth, signal, size, slide +""" + +mc_voiceallocator_tilde = MaxObject('mc.voiceallocator~') +""" +mc.voiceallocator~ - Manage voice numbers for events + +The mc.voiceallocator~ object assigns voice numbers to incoming messages using an optional multichannel signal to determine voice busy state. It also maintains a voice busy map used by other MC objects to avoid unnecessary processing for channels that are not actively producing audio in response to events. + +Args: + voice count (int, optional) + +Inlets: + 0 (multi-channel signal): Multichannel signal representing busy state; any message along with specific messages to manage allocating and releasing voices. + +Outlets: + 0 (OUTLET_TYPE): Messages Out + 1 (OUTLET_TYPE): Voice Number + +Messages: bang, int, float, list, anything, endevent, event, holdevent, printbusymap, release, releaseevent, signal + +Attributes: initialbusystate, name, steal, voices +""" + +mc_vst_tilde = MaxObject('mc.vst~') +""" +mc.vst~ - Host VST, VST3 and Audio Unit plug-ins (multichannel) + +Use the vst~ object to load a real-time VST, VST3 or Audio Unit plug-in and use its audio processing in MSP. When vst~ is instantiated as mcs.vst~, the plug-in's audio inputs are combined into a single multichannel inlet and its audio outputs are combined into a single multichannel outlet. + +Args: + number-of-inputs/outputs (int, optional) + VST-plugin-filename (symbol, optional) + preset-effects-name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Audio/Control Input + 1 (signal): Audio Input 2 + +Outlets: + 0 (signal): Audio Output 1 + 1 (signal): Audio Output 2 + 2 (signal): Parameter Names + 3 (signal): Parameter Index and Value When Changed + 4 (signal): Plug-in Generated MIDI Events + 5 (signal): Program Names + 6 (signal): Subnames (VST Shell Plug-ins Only) + 7 (signal): Preset Names (Audio Unit Plug-ins Only) + +Messages: int, float, list, anything, (drag), (mouse), disable, drop, get, getsubnames, midievent, mpeevent, open, params, pgmnames, plug, plug_au, plug_vst, plug_vst3, presetnames, printids, read, scan, set, signal, subname, sysexevent, unplug, wclose, write, writebank, writepgm + +Attributes: annotation_name, autosave, bypass, currentplug, enablehscroll, enablevscroll, floateditorwindow, genericeditor, legacytransport, mcisolate, parameter_enable, prefer, transport, valuemode +""" + +mc_wave_tilde = MaxObject('mc.wave~') +""" +mc.wave~ - Variable size wavetable (multichannel) + +wave~ reads from a portion of a buffer~ to produce a repeating waveform, given a signal input that goes between 0 and 1 (for example, using a phasor~) to define the position in the buffer. When the wave~ object is instantiated as mcs.wave~ its outputs are combined into a single multichannel output but otherwise it functions identically to wave~. + +Args: + buffer-name (symbol, required) + start-point (number, optional) + end-point (number, optional) + number-of-output-channels (int, optional) + +Inlets: + 0 (signal): (signal) Table Position (from 0 to 1) + 1 (signal/float): ((signal/float) Starting Table Location in ms + 2 (signal/float): (signal/float) Ending Table Location in ms + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, list, (mouse), set, signal + +Attributes: interp, interp_bias, interp_tension +""" + +mc_what_tilde = MaxObject('mc.what~') +""" +mc.what~ - Generate Impulses for a List of Audio Values (multichannel) + +The what~ object generates an impulse -- a signal value of 1 for one sample -- when its input signal crosses a value threshold. The object accepts a list of threshold values and will generate impulses for all of them. Connect a phasor~ to what~ to create a repeating rhythm. For example, when sending in a list of 0 0.25 0.5 and 0.75, what~ will output an impulse four times for each phasor~ ramp. + +Args: + values (list, optional) + +Inlets: + 0 (signal): Input + +Outlets: + 0 (signal): Impulse if Values Detect, 0 Otherwise + 1 (int): Index of Matched Item + +Messages: int, float, list, clear, signal + +Attributes: matches, syncupdate, triggermode +""" + +mc_where_tilde = MaxObject('mc.where~') +""" +mc.where~ - Report Elapsed and Remaining Time of a Phasor (multichannel) + +The where~ object generates two signals: one reports the elapsed time since the reset of a phasor ramp; the other predicts of the remaining time until the phasor resets again. You can use these time values to synchronize events to specific times within a ramp instead of its relative phase. For example, if you want something to happen at 30 milliseconds before the phasor is scheduled to reset, you can wait until the remaining time signal has a value of 30 or less. where~ has a direction detection feature so it can report the elapsed and remaining time of ramps that go from 1 to 0 (as produced by a phasor~ object with negative frequency) in addition to ramps that go from 0 to 1. + +Inlets: + 0 (signal): Input + +Outlets: + 0 (signal): Elapsed Time + 1 (signal): Predicted Time Until Reset + +Messages: signal +""" + +mc_zerox_tilde = MaxObject('mc.zerox~') +""" +mc.zerox~ - Detect zero crossings (multichannel) + +zerox~ functions as a zero-crossing counter or transient detector. + +Args: + click-volume (float, optional) + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Number of Zero-Crossings per Signal Vector + 1 (signal): Clicks at Zero-Crossings + +Messages: set, signal +""" + +mc_zigzag_tilde = MaxObject('mc.zigzag~') +""" +mc.zigzag~ - Linked list function editor (multichannel) + +Use zigzag~ to generate multisegment linear ramps. This object is similar to line~, but retains information about the ramp after it has been output, and allows modification of the list values for the ramp. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Destination Value + 1 (INLET_TYPE): Speed + +Outlets: + 0 (signal): (signal) Output Ramp + 1 (signal): (signal) Current Index + 2 (signal): Contents of Current List + 3 (signal): bang When Line Reaches Destination + +Messages: bang, int, float, list, append, bangdelta, bound, delete, dump, end, insert, jump, jumpend, jumpstart, line, next, prev, print, ramptime, set, setindex, setline, signal, skip, speed, start, stop + +Attributes: loopmode, maxpoints, mode +""" + +mcs_2d_wave_tilde = MaxObject('mcs.2d.wave~') +""" +mcs.2d.wave~ - Two-dimensional wavetable (multichannel I/O) + +2d.wave~ is similar to wave~, but with an additional axis. A given ms range of an audio file will be divided into n rows. Y phase input will determine which row(s) will be used for playback. When the 2d.wave~ object is instantiated as mcs.2d.wave~ its outputs are combined into a single multichannel output but otherwise it functions identically to 2d.wave~. + +Args: + buffer-name (symbol, required) + start and end-points (number, optional) + number-of-output-channels (int, optional) + rows (int, optional) + +Inlets: + 0 (signal): (signal) X Table Position (from 0 to 1) + 1 (signal): (signal) Y Table Position (from 0 to 1) + 2 (signal/float): (signal/float) Starting Table Location in ms + 3 (signal/float): (signal/float) Ending Table Location in ms + +Outlets: + 0 (multi-channel signal): (signal) Channel 1 Output + +Messages: int, float, list, (mouse), rows, set, signal +""" + +mcs_amxd_tilde = MaxObject('mcs.amxd~') +""" +mcs.amxd~ - Host Max for Live devices + +Use the mcs.amxd~ object to load a Max for Live device and use it in MSP. With mcs.amxd~ the audio inputs are combined into a single multichannel input and its audio outputs are combined into a single multichannel output. + +Args: + devicename (symbol, required) + +Inlets: + 0 (multi-channel signal): Input + 1 (multi-channel signal): MIDI In + +Outlets: + 0 (multi-channel signal): Output + 1 (multi-channel signal): MIDI Out + 2 (multi-channel signal): Info Out + +Messages: anything, (drag), (mouse), drag_replace, getinfo, getparams, getvalue, midievent, midiin, open, signal + +Attributes: active, annotation_name, autosize, mcisolate, parameter_enable, patchername, showheader +""" + +mcs_fffb_tilde = MaxObject('mcs.fffb~') +""" +mcs.fffb~ - Fast fixed filter bank (multichannel I/O) + +The fffb~ object implements a bank of bandpass filter objects, each of which is similar to the reson~ filter object. An input signal is applied to all filters, and the outputs of each filter are available separately. When the fffb~ object is instantiated as mcs.fffb~ the object has a single multichannel output containing the individual filters. Otherwise it has a separate outlet for each filter. + +Args: + number-of-filters (int, required) + 1st-filter-frequency (float, optional) + filter-frequency-ratios (float) (float, optional) + Q (list, optional) + harmonic-series-flag (H) (symbol, optional) + +Inlets: + 0 (signal): signal input, lists for setting parameters + +Outlets: + 0 (multi-channel signal): signal output from filter 0 + +Messages: list, anything, Q, QAll, clear, freq, freqAll, freqRatio, gain, gainAll, signal +""" + +mcs_gate_tilde = MaxObject('mcs.gate~') +""" +mcs.gate~ - Route a signal to a channel within a multi-channel output + +Use gate~ to route an input signal at the second inlet to one of several outlets, or to no outlet at all. When there is only one outlet (the default case), it acts as a simple switch. Unlike the Max gate object, any outlet which is not selected outputs a signal composed of zero values. + + When the gate~ object is created as mcs.gate~ all of its signal outlets are combined into a single multichannel outlet. The behavior of mcs.gate~ is analogous to gate~. + +Args: + number-of-outlets (int, optional) + initial-open-outlet (int, optional) + +Inlets: + 0 (int/signal): int/signal Turns Input Off or Routes to Output + 1 (signal): (signal) Input + +Outlets: + 0 (multi-channel signal): (signal) Output + +Messages: bang, int, float, next, signal + +Attributes: ramptime, stepmode +""" + +mcs_gen_tilde = MaxObject('mcs.gen~') +""" +mcs.gen~ - Generate native audio signal processing routines + +The mcs.gen~ object turns an embedded Gen patcher into signal processing routines of optimized native machine code. The Gen patcher can be built from a wide set of low-level Gen operator objects as well as embedded code expressions. + +Args: + patcher-name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): in 1 + +Outlets: + 0 (OUTLET_TYPE): out 1 + +Messages: int, float, (mouse), exportcode, open, reload, reset, reset_param, signal, wclose + +Attributes: autoexport, cpu, cpumeasure, dumpoutlet, exportfolder, exportname, exportnotifier, exportscript, exportscriptargs, gen, nocache, poll, title +""" + +mcs_groove_tilde = MaxObject('mcs.groove~') +""" +mcs.groove~ - Variable-rate looping sample playback + +The groove~ object is a variable-rate, looping, sample-playback object which references the audio information stored in a buffer~ object having the same name. When the groove~ object is instantiated as mcs.groove~ its audio outputs are combined into a single multichannel output. + +Args: + buffer-name (symbol, required) + number-of-outputs (int, optional) + +Inlets: + 0 (signal): Sample Playback Increment + 1 (signal/float): Loop Min + 2 (signal/float): Loop Max + +Outlets: + 0 (multi-channel signal): Multichannel output + 1 (signal): Loop Sync Output + +Messages: int, float, list, anything, clearspeedcues, (mouse), dictionary, endloop, printspeedcues, reset, set, setloop, signal, startloop, stop + +Attributes: basictuning, followglobaltempo, formant, formantcorrection, lock, loop, loopend, loopinterp, loopstart, mode, name, originallength, originaltempo, phase, pitchcorrection, pitchshift, pitchshiftcent, quality, slurtime, timestretch, transport +""" + +mcs_limi_tilde = MaxObject('mcs.limi~') +""" +mcs.limi~ - Lookahead peak-limiter + +Lookahead peak-limiter. + +Args: + channel_count (int, optional) + buffer_size (int, optional) + +Inlets: + 0 (multi-channel signal): Input + +Outlets: + 0 (multi-channel signal): Output + +Messages: clear, signal + +Attributes: bypass, dcblock, lookahead, mode, postamp, preamp, release, threshold +""" + +mcs_matrix_tilde = MaxObject('mcs.matrix~') +""" +mcs.matrix~ - Signal routing and mixing matrix (multichannel I/O) + +matrix~ is an array of signal connectors and mixers (adders). It can have any number of inlets and outlets. Signals entering at each inlet can be routed to one or more of the outlets, with a variable amount of gain. If an outlet is connected to more than one inlet, its output signal is the sum of the signals from the inlets. + + When the matrix~ object is created as mcs.matrix~ all of its signal inlets are combined into a single multichannel inlet and all of its signal outlets are combined into a single multichannel outlet. The behavior of mcs.matrix~ is otherwise identical to matrix~. + +Args: + inlets (int, required) + outlets (int, required) + default-connect-gain (float, optional) + +Inlets: + 0 (multi-channel signal): Input, connect (list), disconnect (list), ramp (int), clear + +Outlets: + 0 (multi-channel signal): Output + 1 (list): inlets outlets gains + +Messages: list, clear, connect, dictionary, disconnect, dump, dumpconnections, dumptarget, print + +Attributes: exclusive, numouts, ramp +""" + +mcs_play_tilde = MaxObject('mcs.play~') +""" +mcs.play~ - Position-based sample playback (multichannel I/O) + +Use the play~ object as a playback interface for a buffer~. that plays back samples based on an offset within the buffer. It is typically used with the line~ object, but can be used with any signal that generates a changing position value in milliseconds. The groove~ object provides another option for sample playback. + + When the play~ object is created as mcs.play~ all of its signal outlets are combined into a single multichannel outlet. The behavior of mcs.play~ is otherwise identical to play~. + +Args: + buffer-name (symbol, required) + number-of-output-channels (int, optional) + +Inlets: + 0 (signal): Sample Time to Play in ms + +Outlets: + 0 (multi-channel signal): (signal) Channel 1 Output + 1 (multi-channel signal): bang When playback reaches destination or when playback is stopped with a 0 or stop message + +Messages: int, (mouse), pause, resume, set, signal, start, stop + +Attributes: interptime, loop, loopinterp +""" + +mcs_poly_tilde = MaxObject('mcs.poly~') +""" +mcs.poly~ - Manage polyphony/DSP for patchers + +Use the mcs.poly~ to encapsulate a patcher inside an object box, to specify the patcher filename and the number of instances you want to load as arguments to the poly~ object, and to control object processing and routing in the loaded patcher instances. + +Args: + patcher-name (symbol, required) + number-of-instances (int, optional) + local and flag (0 or 1) (symbol, optional) + 'up' and up-sampling-factor (symbol, optional) + 'down' and down-sampling factor (symbol, optional) + 'args' and list-of-argument-values (symbol, optional) + +Inlets: + 0 (multi-channel signal, message): Input 1 of + +Messages: bang, int, float, list, anything, (drag), allnotesoff, assignpatcher, busymap, bypass, (mouse), down, exclude, midievent, midinote, mpeevent, mute, mutemap, note, notemessage, open, setvalue, threadcount, up, wclose + +Attributes: args, filterparams, legacynotemode, midimode, mpemode, parallel, patchername, replicate, resampling, steal, target, voices, vs, zone +""" + +mcs_selector_tilde = MaxObject('mcs.selector~') +""" +mcs.selector~ - Assign a channel of a multi-channel signal to an outlet + +Use the selector~ object to choose between one of several input signals (or none). The selector~ is similar to the Max switch object but for signals, however if no input is chosen, it outputs a signal composed of zero values. + + When the selector~ object is created as mcs.selector~ all of its signal inlets are combined into a single multichannel inlet. The behavior of mcs.selector~ is otherwise analogous to selector~ with the exception that mcs.selector~ changes its number of inputs (auto-adapts) as the number of inputs in the multi-channel signal connected to its right inlet change. + +Args: + number-of-inputs (int, optional) + initially-open-inlet (int, optional) + +Inlets: + 0 (int/signal): int/signal Turns Input Off or Routes to Output + 1 (multi-channel signal): (multi-channel signal) Inputs + +Outlets: + 0 (signal): (signal) Output + +Messages: bang, int, float, next, signal + +Attributes: ramptime, stepmode +""" + +mcs_sig_tilde = MaxObject('mcs.sig~') +""" +mcs.sig~ - Convert numbers to audio signals (multichannel output) + +Use the mcs.sig~ object to convert a list of numbers into a multi-channel audio signal. + +Args: + initial-output-value (number, optional) + +Inlets: + 0 (float): Sets Value + +Outlets: + 0 (multi-channel signal): Output + +Messages: int, float, list, set, signal + +Attributes: chans +""" + +mcs_tapout_tilde = MaxObject('mcs.tapout~') +""" +mcs.tapout~ - Output from a delay line (multichannel I/O) + +The outlet of a tapin~ object must be connected to the left inlet of tapout~ in order for the delay line to function. + + + The tapout~ object has one or more inlets and one or more outlets. A delay time signal or number received in an inlet affects the output signal coming out of the outlet directly below the inlet. + + + The tapout~ object is sub-sample accurate specifically when receiving a delay time signal in an inlet. It is not sub-sample accurate when receiving a delay time number in an inlet. + +Args: + initial-delay (number, optional) + +Inlets: + 0 (signal/float): (signal/float) Delay Time in ms. Signal-based delay uses interpolation, which introduces a one-sample delay + +Outlets: + 0 (signal): (signal) Delayed Output + +Messages: int, float, list, signal, tapconnect + +Attributes: unique +""" + +mcs_vst_tilde = MaxObject('mcs.vst~') +""" +mcs.vst~ - Host VST, VST3 and Audio Unit plug-ins (multichannel I/O) + +Use the vst~ object to load a real-time VST, VST3 or Audio Unit plug-in and use its audio processing in MSP. When vst~ is instantiated as mcs.vst~, the plug-in's audio inputs are combined into a single multichannel inlet and its audio outputs are combined into a single multichannel outlet. + +Args: + number-of-inputs/outputs (int, optional) + VST-plugin-filename (symbol, optional) + preset-effects-name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Audio/Control Input + +Outlets: + 0 (multi-channel signal): Audio Output 1 + 1 (multi-channel signal): Audio Output 2 + 2 (multi-channel signal): Parameter Names + 3 (multi-channel signal): Parameter Index and Value When Changed + 4 (multi-channel signal): Plug-in Generated MIDI Events + 5 (multi-channel signal): Program Names + 6 (multi-channel signal): Subnames (VST Shell Plug-ins Only) + +Messages: int, float, list, anything, (drag), (mouse), disable, drop, get, getsubnames, midievent, mpeevent, open, params, pgmnames, plug, plug_au, plug_vst, plug_vst3, presetnames, printids, read, scan, set, signal, subname, sysexevent, unplug, wclose, write, writebank, writepgm + +Attributes: annotation_name, autosave, bypass, currentplug, enablehscroll, enablevscroll, floateditorwindow, genericeditor, legacytransport, mcisolate, parameter_enable, prefer, transport, valuemode +""" + +mcs_wave_tilde = MaxObject('mcs.wave~') +""" +mcs.wave~ - Variable size wavetable (multichannel I/O) + +wave~ reads from a portion of a buffer~ to produce a repeating waveform, given a signal input that goes between 0 and 1 (for example, using a phasor~) to define the position in the buffer. When the wave~ object is instantiated as mcs.wave~ its outputs are combined into a single multichannel output but otherwise it functions identically to wave~. + +Args: + buffer-name (symbol, required) + start-point (number, optional) + end-point (number, optional) + number-of-output-channels (int, optional) + +Inlets: + 0 (signal): (signal) Table Position (from 0 to 1) + 1 (signal/float): ((signal/float) Starting Table Location in ms + 2 (signal/float): (signal/float) Ending Table Location in ms + +Outlets: + 0 (multi-channel signal): (signal) Output + +Messages: int, float, list, (mouse), set, signal + +Attributes: interp, interp_bias, interp_tension +""" + +meter_tilde = MaxObject('meter~') +""" +meter~ - Visual peak level indicator + +Use the meter~ object to monitor any signal in the range -1 and 1 (other signals should be scaled first). + +Inlets: + 0 (signal): Input Between 0-1 to Meter + +Outlets: + 0 (OUTLET_TYPE): Peak Value For Each Metering Interval + +Messages: int, float, (mouse), signal + +Attributes: bgcolor, bordercolor, coldcolor, dbperled, hotcolor, interval, monotone, nhotleds, ntepidleds, numleds, nwarmleds, offcolor, oncolor, orientation, overloadcolor, style, tepidcolor, warmcolor +""" + +minimum_tilde = MaxObject('minimum~') +""" +minimum~ - Compare two signals, output the minimum + +minimum~ outputs a signal which is the minimum of two input signals. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (Signal): (signal) Signal to be compared with Right Inlet + 1 (Signal): (signal) Signal to be compared with Left Inlet + +Outlets: + 0 (Signal): (signal) Minimum of Left and Right Signals + +Messages: int, float, signal +""" + +minmax_tilde = MaxObject('minmax~') +""" +minmax~ - Compute minimum/maximum signal values + +minmax~ computes the minimum and maximum values of an input signal and outputs signals which are the maximum signal and the minimum signal as well as outputs of the minimum and maximum floats. + +Inlets: + 0 (signal): (signal) Input + 1 (signal): Reset Input + +Outlets: + 0 (signal): (signal) Minimum + 1 (signal): (signal) Maximum + 2 (double): (float) Minimum + 3 (double): (float) Maximum + +Messages: bang, reset, signal +""" + +minus_tilde = MaxObject('minus~') +""" +minus~ - Signal subtraction + +Use the -~ object to perform signal subtraction (to output a signal which is the difference between two signals). + +Args: + initial-subtraction-value (number, optional) + +Inlets: + 0 (signal/float): (signal/float) This - Right Inlet + 1 (signal/float): (signal/float) Left Inlet - This + +Outlets: + 0 (signal): (signal) Subtraction Result + +Messages: int, float, signal +""" + +modulo_tilde = MaxObject('modulo~') +""" +modulo~ - Divide two signals, output the remainder + +%~ is a signal remainder operator. If signals are connected to both inlets, the left signal is divided by the right signal, and the remainder is output. If a signal is only connected to left inlet, it is divided to the argument or a float in the right inlet. Note that multiple signals in the same inlet add together automatically. + +Args: + initial-divisor (number, optional) + +Inlets: + 0 (signal/float): (signal/float) This Right Inlet + 1 (signal/float): (signal/float) Left Inlet This + +Outlets: + 0 (signal): (signal) Modulo Result + +Messages: int, float, signal +""" + +mstosamps_tilde = MaxObject('mstosamps~') +""" +mstosamps~ - Convert milliseconds to samples + +Use the mstosamps~ object to convert an incoming signal carrying a millisecond value and output a signal which converts those millisecond values to a number of samples (at the current sampling rate). + +Inlets: + 0 (INLET_TYPE): Milliseconds In, signal To Use For Sampling Rate + +Outlets: + 0 (signal): (signal) Samples At Input signal or Current Sampling Rate + 1 (double): (float) Samples At Input signal or Current Sampling Rate + +Messages: int, float, list, signal +""" + +mtof_tilde = MaxObject('mtof~') +""" +mtof~ - Convert a MIDI note number to frequency at signal rate + +Use mtof~ to convert MIDI note numbers to frequency at signal rate + +Inlets: + 0 (signal): Floating-point MIDI Value + +Outlets: + 0 (signal): Frequency in Hz + +Messages: signal + +Attributes: base, map, mapname, mid, ref, scale, scalename +""" + +mute_tilde = MaxObject('mute~') +""" +mute~ - Disable signal processing in a subpatch + +mute~ provides an easy way to disable only the signal objects in a subpatcher. (An alternative is to use pcontrol, but this disables all objects (i.e. MIDI) and is slightly slower.) + +Inlets: + 0 (INLET_TYPE): 1 Mutes Signal Objects In patcher, 0 Unmutes + +Outlets: + 0 (OUTLET_TYPE): Connect To patcher + +Messages: int, list +""" + +mxj_tilde = MaxObject('mxj~') +""" +mxj~ - Java in MSP + +The mxj~ object (and its Max equivalent mxj) instantiate specially-written Java classes and acts as a Max-level peer object, passing data that originates in Max to the Java object and vice versa. + +Args: + Java-class (symbol, required) + attributes (list, required) + +Messages: bang, int, float, list, anything, benchmark, (mouse), exceptioncheck, get, viewsource, zap +""" + +noise_tilde = MaxObject('noise~') +""" +noise~ - Generate white noise + +Use the noise~ object to generate a signal consisting of uniformly distributed random white-noise with values between -1.0 and 1.0. + +Inlets: + 0 (INLET_TYPE): (signal) Ignore This Inlet + +Outlets: + 0 (signal): (signal) The Noise + +Attributes: classic +""" + +normalize_tilde = MaxObject('normalize~') +""" +normalize~ - Scale on the basis of maximum amplitude + +normalize~ performs real-time normalization of its input by multiplying each input sample value by a scaling factor - computed as the maximum output value (sent either as a signal or a float in the right inlet) over the maximum signal input value received thus far. + +Args: + initial-maximum-output-amplitude (float, optional) + +Inlets: + 0 (signal): (signal) Input To Be Normalized + 1 (signal/float): (signal/float) Maximum Value of Output + +Outlets: + 0 (signal): (signal) Normalized Output + +Messages: int, float, reset, signal +""" + +notequals_tilde = MaxObject('notequals~') +""" +notequals~ - Not equal to, comparison of two signals + +!=~ outputs a 1 signal when the left input is not-equal to the right input and a 0 when it is equal to the right input. The right input can be a signal or a float. + +Args: + initial-comparison-value (number, optional) + +Inlets: + 0 (signal/float): (signal) This != Right Inlet + 1 (signal/float): (signal/float) Left Inlet != This + +Outlets: + 0 (signal): (signal) Comparison Result (1 or 0) + +Messages: int, float, signal + +Attributes: fuzzy +""" + +number_tilde = MaxObject('number~') +""" +number~ - Signal monitor and constant generator + +Use the number~ object to display signal values or generate them. + +Inlets: + 0 (signal): Input to Display + 1 (float): Ramp time in Milliseconds + +Outlets: + 0 (signal): Number Value as a Signal + 1 (float): Signal Value + +Messages: bang, int, float, list, allow, flags, ft1, max, min, mode, (mouse), set, signal + +Attributes: bgcolor, bgcolor2, bordercolor, ft1, hbgcolor, htextcolor, interval, maximum, minimum, monitormode, numdecimalplaces, sigoutmode, style, textcolor +""" + +omx_4band_tilde = MaxObject('omx.4band~') +""" +omx.4band~ - OctiMax 4-band Compressor + +omx.4band~ delivers the signal-processing power of Octimax in a 4-band compressor. + +Inlets: + 0 (signal): (signal) Left Input Channel + 1 (signal): (signal) Right Input Channel + +Outlets: + 0 (signal): (signal) Left Output Channel + 1 (signal): (signal) Right Output Channel + 2 (list): (list) Parameter Output + 3 (list): (list) Meter Output + +Messages: bypass, choosePreset, gating_threshold, inagc_b1_atk, inagc_b1_rel, inagc_range, lim_drive, mbagc_b1_atk, mbagc_b1_drv, mbagc_b1_rel, mbagc_b2_atk, mbagc_b2_drv, mbagc_b2_rel, mbagc_b3_atk, mbagc_b3_drv, mbagc_b3_rel, mbagc_b4_atk, mbagc_b4_drv, mbagc_b4_rel, mbagc_range, meterData, meterRate, meters, ngenabled, ngthresh1, ngthresh2, noisegate, outmix1, outmix2, outmix3, outmix4, saveSettings, signal +""" + +omx_5band_tilde = MaxObject('omx.5band~') +""" +omx.5band~ - OctiMax 5-band Compressor + +omx.5band~ delivers the signal-processing power of Octimax in a 5-band compressor. + +Inlets: + 0 (signal): (signal) Left Input Channel + 1 (signal): (signal) Right Input Channel + +Outlets: + 0 (signal): (signal) Left Output Channel + 1 (signal): (signal) Right Output Channel + 2 (list): (list) Parameter Output + 3 (list): (list) Meter Output + +Messages: bands_enum, bassenhancement, bassenhancement_mixlevel, bypass, choosePreset, freeze_threshold, gating_threshold, inagc_atk, inagc_progressive, inagc_range, inagc_ratio, inagc_rel, inagc_threshold, inf_ratio_above_threshold_1, inf_ratio_above_threshold_2, inf_ratio_above_threshold_3, inf_ratio_above_threshold_4, inf_ratio_above_threshold_5, lim_drive, lim_smoothrelease, mbagc_b1_atk, mbagc_b1_drv, mbagc_b1_rel, mbagc_b1_threshold, mbagc_b2_atk, mbagc_b2_drv, mbagc_b2_rel, mbagc_b2_threshold, mbagc_b3_atk, mbagc_b3_drv, mbagc_b3_rel, mbagc_b3_threshold, mbagc_b4_atk, mbagc_b4_drv, mbagc_b4_rel, mbagc_b4_threshold, mbagc_b5_atk, mbagc_b5_drv, mbagc_b5_rel, mbagc_b5_threshold, mbagc_progressive, mbclip_b1_threshold, mblim_b1_threshold, mblim_b2_threshold, mblim_b3_threshold, mblim_b4_threshold, mblim_b5_threshold, mbrange, mbratio, meterData, meterRate, meters, multiband_limiters, ng_enabled_maxch, ngenabled, ngthresh1, ngthresh2, ngthresh3, ngthresh4, ngthresh5, outlevel_lf, outlevel_rf, outmix1, outmix2, outmix3, outmix4, outmix5, output_level, saveSettings, signal, spatial_desired, spatial_enabled, spatial_maximum, spatial_speed +""" + +omx_comp_tilde = MaxObject('omx.comp~') +""" +omx.comp~ - OctiMax Compressor + +omx.comp~ is a fully-featured signal compressor with limiting, gating, sidechain, and dual-band options. + +Inlets: + 0 (signal): (signal) Left Input Channel + 1 (signal): (signal) Right Input Channel + +Outlets: + 0 (signal): (signal) Left Output Channel + 1 (signal): (signal) Right Output Channel + 2 (list): (list) Parameter Output + 3 (list): (list) Meter Output + +Messages: agcEnabled, agcThreshold, attack, bypass, channelCoupling, choosePreset, delay, dualBandEnabled, freezeLevel, gatingLevel, limEnabled, limMode, meterData, meterRate, meters, ngEnabled, ngThreshold, progressiveRelease, range, ratio, release, saveSettings, sidechainFilterEnabled, signal, smoothGain +""" + +omx_peaklim_tilde = MaxObject('omx.peaklim~') +""" +omx.peaklim~ - OctiMax Peak Limiter + +omx.peaklim~ is a peak-limiter which allows for the specified control of signal amplitude. + +Inlets: + 0 (signal): (signal) Left Input Channel + 1 (signal): (signal) Right Input Channel + +Outlets: + 0 (signal): (signal) Left Output Channel + 1 (signal): (signal) Right Output Channel + 2 (list): (list) Parameter Output + 3 (list): (list) Meter Output + +Messages: bypass, ingain, meterData, meterRate, meters, mode, outgain, saveSettings, signal, threshold +""" + +onepole_tilde = MaxObject('onepole~') +""" +onepole~ - Single-pole lowpass filter + +The onepole~ object implements the simplest of IIR filters, providing a 6dB per octave attenuation. This filter is very efficient and useful for gently rolling off harsh high end and for smoothing out control signals. + +Args: + center-frequency (float, optional) + Hz/linear/radians (symbol, optional) + +Inlets: + 0 (signal): (signal) filter input + 1 (signal or float): (signal or float) Cutoff Frequency (Hz) + +Outlets: + 0 (signal): (signal) filter output + +Messages: int, float, Hz, clear, linear, radians, signal +""" + +oscbank_tilde = MaxObject('oscbank~') +""" +oscbank~ - Non-interpolating oscillator bank + +oscbank~ is a non-interpolating oscillator bank with signal inputs to set oscillator frequency and magnitude. + +Args: + number-of-oscillators (int, optional) + frequency-smoothing-factor (samples) (int, optional) + amplitude-smoothing-factor (samples) (int, optional) + lookup-table-size (samples) (int, optional) + +Inlets: + 0 (signal/float): (signal/float) Freq + 1 (signal/float): (signal/float) Mag + 2 (signal/float): (signal/float) Phase + 3 (signal/float): (signal/float) Index + +Outlets: + 0 (signal): (signal) output + +Messages: int, float, clear, copybuf, framesync, freqsmooth, magsmooth, set, signal, silence, size, tabpoints +""" + +out = MaxObject('out') +""" +out - Message output for a patcher loaded by poly~ or pfft~ + +out defines a message outlet for a patcher loaded by poly~ or pfft~. + +Inlets: + 0 (INLET_TYPE): Send Messages Out Patcher Outlet 1 + +Messages: bang, int, float, list, anything, comment + +Attributes: attr_comment +""" + +out_tilde = MaxObject('out~') +""" +out~ - Signal output for a patcher loaded by poly~ + +Use the out~ object inside a patcher loaded by the poly~ object to create a patcher signal outlet. + +Args: + outlet-number (int, required) + +Inlets: + 0 (signal): Output 1 of Patcher + +Messages: comment, signal + +Attributes: attr_comment, chans +""" + +overdrive_tilde = MaxObject('overdrive~') +""" +overdrive~ - Soft-clipping signal distortion + +The overdrive~ object uses a waveshaping function to distort audio signals. It amplifies signals, limiting the maximum value of the signal to +/- 1. Values outside of this range are removed using "soft clipping" somewhat like that of an overdriven tube-based circuit. + +Args: + drive-factor (int, required) + drive-factor (float, optional) + +Inlets: + 0 (signal): (signal) Input signal, (float) Drive factor (1, 10) + 1 (signal or float): (signal or float) Drive factor (1, 10) + +Outlets: + 0 (OUTLET_TYPE): Signal Output + +Messages: int, float, signal +""" + +pass_tilde = MaxObject('pass~') +""" +pass~ - Eliminate noise in a muted subpatcher + +pass~ is used above any outlet object that will handle a signal. When the audio in the subpatch is enabled, the pass~ object will pass its input to its output. However, when the audio in the subpatch is disabled using mute~ or the enable 0 message to pcontrol, pass~ will send a zero signal out its outlet. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Output + +Messages: signal +""" + +peakamp_tilde = MaxObject('peakamp~') +""" +peakamp~ - Report the maximum amplitude of a signal + +Use the peakamp~ object to monitor an incoming signal and reports the absolute value of the peak amplitude of the signal it has received since the last time it was reported. + +Args: + ms-output-interval (int, optional) + +Inlets: + 0 (signal): (signal) any signal, (bang) report peak amplitude + 1 (int): (int) reporting interval + +Outlets: + 0 (float): (float) peak amplitude of input + +Messages: bang, ft1, in1, signal + +Attributes: interval, signed +""" + +peek_tilde = MaxObject('peek~') +""" +peek~ - Read and write sample values + +Use peek~ to read and write sample values to a named buffer~. Unlike related objects index~ and poke~, values and indices are specified as Max messages, and the object will function even when the audio is not turned on. + +Args: + buffer-name (symbol, required) + buffer-channel (int, optional) + clipping-enable-flag (int, optional) + +Inlets: + 0 (INLET_TYPE): Sample Index + 1 (INLET_TYPE): Sample Value For Writing Into buffer~ + 2 (INLET_TYPE): Channel + +Outlets: + 0 (OUTLET_TYPE): buffer~ Value at Sample Index + +Messages: int, float, list, clip, (mouse), set +""" + +pfft_tilde = MaxObject('pfft~') +""" +pfft~ - Spectral processing manager for patchers + +The pfft~ object is designed to simplify spectral audio processing using the Fast Fourier Transform (FFT). In addition to performing the FFT and the Inverse Fast Fourier Transform (IFFT), pfft~ (with the help of its companion fftin~ and fftout~ objects) manages the necessary signal windowing, overlapping and adding needed to create a real-time Short Term Fourier Transform (STFT) analysis/resynthesis system. + +Args: + subpatch-name (symbol, required) + FFT-size (int, optional) + overlap-factor (hop-size-denominator) (int, optional) + start-offset (int, optional) + full-spectrum-flag (0 or nonzero) (int, optional) + 'args' and list-of-argument-values (symbol, optional) + +Inlets: + 0 (signal, message): Input 1 + +Messages: bang, int, float, list, anything, clear, (mouse), mute, open, wclose + +Attributes: args, fftsize, float32, fullspectrum, legacy, overlap, patchername, startoffset +""" + +phasegroove_tilde = MaxObject('phasegroove~') +""" +phasegroove~ - Control groove~ With phasor~ + +The phasegroove~ object converts ramps between 0 and 1 into a sample-increment signal that you can use to control the groove~ object. phasegroove~ must be connected to a groove~. Once connected, it knows about the groove~ object's loop points and the sample it is playing. + +Inlets: + 0 (signal): Phase Input + +Outlets: + 0 (signal): Connect to groove~ + +Messages: signal + +Attributes: conflict +""" + +phaseshift_tilde = MaxObject('phaseshift~') +""" +phaseshift~ - Distort the phase of a signal + +The phaseshift~ object is a 2nd-order allpass filter. + +Args: + frequency (number, optional) + q (number, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Frequency + 2 (signal/float): (signal/float) Q + +Outlets: + 0 (signal): (signal) Output + +Messages: float, clear, signal +""" + +phasewrap_tilde = MaxObject('phasewrap~') +""" +phasewrap~ - Wrap a signal between π and -π + +phasewrap~ takes any input signal and wrap it between π and -π values. + +Inlets: + 0 (INLET_TYPE): Input Signal to Phase-Wrap + +Outlets: + 0 (OUTLET_TYPE): Phase-Wrapped Signal Out + +Messages: signal +""" + +phasor_tilde = MaxObject('phasor~') +""" +phasor~ - Generate sawtooth signals + +Use the phasor~ object to generate sawtooth waves suitable for sample-accurate control and timing tasks. For smoother sounding sawtooth generation, use the bandlimited saw~ object instead. The ramp rate can be set by frequency (Hz), or as an interval using the tempo-relative Max time format syntax. + +Args: + initial-frequency (list, optional) + +Inlets: + 0 (signal/float/symbol): Frequency or Time Period + 1 (float): Phase (float), Trigger Reset (signal) + +Outlets: + 0 (signal): Output (ramp cycle from 0 to 1) + +Messages: bang, int, float, list, anything, reset, signal + +Attributes: frequency, jitter, limit, lock, phaseoffset, syncupdate, transport +""" + +pink_tilde = MaxObject('pink~') +""" +pink~ - Pink noise generator + +pink~ generates pink noise, as distinguished from white noise (which the MSP object noise~ generates). White noise has constant spectral power per hertz of bandwidth, while pink noise has constant power per octave. Subjectively, pink noise sounds less hissy than white noise. + +Inlets: + 0 (signal): (signal) Ignore This Inlet + +Outlets: + 0 (signal): (signal) The Noise +""" + +pitchshift_tilde = MaxObject('pitchshift~') +""" +pitchshift~ - Ztx-based real-time pitchshifting + +Use the pitchshift~ object to load a perform pitch-shifting on an input signal. + +Args: + channels (int, optional) + +Inlets: + 0 (Signal): original signal, channel: 1 + 1 (Signal): Pitchshift factor (int or float) + +Outlets: + 0 (Signal): pitchshifted signal, channel: 1 + 1 (Signal): Current latency, reported in samples + +Messages: getlatency, signal + +Attributes: constantlatency, enabled, pitchshift, pitchshiftcent, quality, reportlatency, usecents +""" + +play_tilde = MaxObject('play~') +""" +play~ - Position-based sample playback + +Use the play~ object as a playback interface for a buffer~. that plays back samples based on an offset within the buffer. It is typically used with the line~ object, but can be used with any signal that generates a changing position value in milliseconds. The groove~ object provides another option for sample playback. + + When the play~ object is created as mcs.play~ all of its signal outlets are combined into a single multichannel outlet. The behavior of mcs.play~ is otherwise identical to play~. + +Args: + buffer-name (symbol, required) + number-of-output-channels (int, optional) + +Inlets: + 0 (signal): Sample Time to Play in ms + +Outlets: + 0 (signal): (signal) Channel 1 Output + 1 (signal): bang When playback reaches destination or when playback is stopped with a 0 or stop message + +Messages: int, (mouse), pause, resume, set, signal, start, stop + +Attributes: interptime, loop, loopinterp +""" + +playlist_tilde = MaxObject('playlist~') +""" +playlist~ - Play sound files + +Use playlist~ to organize sets of soundfiles and play them back. Each sound is given a visual representation in a clip where a selection from the entire sound file may be choosen. Clips may be dragged within a playlist~ to re-order them, or they may be dragged to other playlist~ objects by using the handle (dot) on the left side of the clip. + +Inlets: + 0 (INLET_TYPE): Messages + +Outlets: + 0 (signal) + 1 (signal): Sync Output + 2 (signal): Playback Notifications + 3 (signal): content + 4 (dict): content + +Messages: int, append, clear, (drag), getcontent, (mouse), next, pause, remove, resume, selection, selectionms, setclip, signal + +Attributes: accentcolor, allowreorder, annotation_name, basictuning, bgcolor, candicane2, candicane3, candicane4, candicane5, candicane6, candicane7, candicane8, candycane, channelcount, clipheight, color, elementcolor, expansion, followglobaltempo, formant, formantcorrection, loop, loopreport, mode, name, originallength, originaltempo, parameter_enable, parameter_mappable, pitchcorrection, pitchshift, pitchshiftcent, quality, reportprogress, selectioncolor, shadowalpha, shadowblend, shadowproportion, showname, slurtime, speed, style, textcolor, timestretch, waveformdisplay +""" + +plot_tilde = MaxObject('plot~') +""" +plot~ - Visualize two-dimensional data + +Use the plot~ object to graph sets of data as points across a domain. The source of the data to be visualized may be a Max list, an MSP buffer~, or an audio signal. The number of plots may be changed with the @numplots attribute, and each of these "subplots" is addressed through a dedicated inlet. A variety of out-of-the-box configurations are provided as Max object prototypes. + +Inlets: + 0 (INLET_TYPE): Messages or Data for subplot 0 + +Outlets: + 0 (OUTLET_TYPE) + +Messages: int, float, list, definecolor, definedomain, definefilter, defineline, definenumber, definepoint, definerange, definethickness, definexgrid, definexlabels, definexorigin, defineygrid, defineylabels, defineyorigin, dictionary, edit, getdictionary, (mouse), refer, signal + +Attributes: applyfont, audioframerate, audioframesize, bgcolor, domainlabel, fillhorizontalspace, fontname, fontsize, gridcolor, gridorigincolor, margins, numplots, numpoints, rangelabel, thinmode, thinthresh, thinto +""" + +plugin_tilde = MaxObject('plugin~') +""" +plugin~ - Define a Max for Live device's audio inputs + +The plugin~ object receives its input from the Live application as part of a Max for Live audio device. + +Args: + input-channels (list, optional) + +Inlets: + 0 (signal): (signal) Test input to pass thru for audio device channel 1. + 1 (signal): (signal) Test input to pass thru for audio device channel 2. + +Outlets: + 0 (signal): (signal) Channel 1 audio input from the Live application. + 1 (signal): (signal) Channel 2 audio input from the Live application. + +Messages: signal + +Attributes: chans +""" + +plugout_tilde = MaxObject('plugout~') +""" +plugout~ - Define a Max for Live Device's audio outputs + +The plugout~ object sends its output to the Live application as part of a Max for Live Audio device or Instrument. + +Args: + output-channel-destination (int, optional) + +Inlets: + 0 (signal): (signal) Channel 1 audio from a Max patch in a Max for Live Audio device or Instrument to be sent to the Live application + 1 (signal): (signal) Channel 2 audio from a Max patch in a Max for Live Audio device or Instrument to be sent to the Live application + +Outlets: + 0 (signal): (signal) Test output to pass thru for audio device channel 1. + 1 (signal): (signal) Test output to pass thru for audio device channel 2. + +Messages: signal + +Attributes: chans +""" + +plugphasor_tilde = MaxObject('plugphasor~') +""" +plugphasor~ - Host-synchronized sawtooth wave + +The plugphasor~ object outputs an audio-rate sawtooth wave that is sample-synchronized to the beat of the Ableton Live sequencer. The waveform can be fed to other audio objects to lock audio processes to the audio of the host. + +Inlets: + 0 (INLET_TYPE): Unused + +Outlets: + 0 (signal): Beat-Synchronized 0-1 Ramp + 1 (list): Debug Output +""" + +plugreceive_tilde = MaxObject('plugreceive~') +""" +plugreceive~ - Receive audio from another plug-in + +The use of the plugsend~ and plugreceive~ objects to pass audio between Max for Live devices is not supported. + The plugreceive~ and plugsend~ objects were used to send audio signals from one pluggo plug-in to another. They were used in the implementation of the PluggoBus feature of many of the plug-ins included with pluggo. + +Args: + object-name (symbol, required) + +Inlets: + 0 (INLET_TYPE): A Functionless Inlet + +Outlets: + 0 (signal): Receive From plugsend~ + +Messages: set, signal +""" + +plugsend_tilde = MaxObject('plugsend~') +""" +plugsend~ - Send audio to another plug-in + +The use of the plugsend~ and plugreceive~ objects to pass audio between Max for Live devices is not supported. + The plugsend~ and plugreceive~ objects are used to send audio signals from one pluggo plug-in to another. They are used in the implementation of the PluggoBus feature of many of the plug-ins included with pluggo. + +Args: + object-name (symbol, required) + +Inlets: + 0 (signal): Send To plugreceive~ + +Messages: signal +""" + +plugsync_tilde = MaxObject('plugsync~') +""" +plugsync~ - Report host synchronization information + +The plugsync~ object provides information about the current state of Ableton Live host applicaiton. + +Inlets: + 0 (INLET_TYPE): bang Polls Timing Info + +Outlets: + 0 (int): (int) Transport State (1 = Play, 0 = Off) + 1 (int): (int) Current Bar Count + 2 (int): (int) Current Beat Count + 3 (double): (float) Current Ticks Within a Beat (1 PPQ) + 4 (list): (list) Time Signature + 5 (double): (float) Tempo + 6 (double): (float) Ticks (1 PPQ) + 7 (int): (int) Sample Count + 8 (long): (long) Flags Indicating Which Data Are Valid + +Messages: bang +""" + +plus_tilde = MaxObject('plus~') +""" +plus~ - Add signals + +Use the +~ object to add two signals together, or to add an offset value to a signal. + +Args: + initial-offset (number, optional) + +Inlets: + 0 (signal/float): (signal/float) This + Right Inlet + 1 (signal/float): (signal/float) Left Inlet + This + +Outlets: + 0 (signal): (signal) Addition Result + +Messages: int, float, signal +""" + +plusequals_tilde = MaxObject('plusequals~') +""" +plusequals~ - Signal accumulator + ++=~ adds all the values it receives. The result can grow very large, very fast. + +Args: + initial-sum (float, optional) + +Inlets: + 0 (signal): (signal) Accumulator Input + 1 (signal): (signal) Accumulator Input + +Outlets: + 0 (signal): (signal) Accumulator Output + +Messages: bang, set, signal +""" + +poke_tilde = MaxObject('poke~') +""" +poke~ - Write sample values to a buffer by index + +poke~ allows you to write samples into a buffer~ at sample locations specified by a signal. + +Args: + buffer-object-name (symbol, required) + channel-number (int, optional) + +Inlets: + 0 (signal, float): Sample Value to Write + 1 (signal, float): Sample Index + 2 (signal, float): Channel + +Outlets: + 0 (signal): Channel + +Messages: int, float, list, (mouse), set, signal +""" + +poltocar_tilde = MaxObject('poltocar~') +""" +poltocar~ - Signal Polar to Cartesian coordinate conversion + +poltocar~ will take any given signal as a polar coordinate and output the cartesian conversion of that signal. + +Inlets: + 0 (INLET_TYPE): amplitude/alpha input + 1 (INLET_TYPE): phase/theta input + +Outlets: + 0 (OUTLET_TYPE): real/x output + 1 (OUTLET_TYPE): imaginary/y output + +Messages: signal +""" + +poly_tilde = MaxObject('poly~') +""" +poly~ - Manage polyphony/DSP for patchers + +Use the poly~ to encapsulate a patcher inside an object box, to specify the patcher filename and the number of instances you want to load as arguments to the poly~ object, and to control object processing and routing in the loaded patcher instances. + +Args: + patcher-name (symbol, required) + number-of-instances (int, optional) + 'up' and up-sampling-factor (symbol, optional) + 'down' and down-sampling factor (symbol, optional) + 'args' and list-of-argument-values (symbol, optional) + +Inlets: + 0 (signal, message): Input 1 of + +Messages: bang, int, float, list, anything, (drag), allnotesoff, assignpatcher, busymap, bypass, (mouse), down, exclude, midievent, midinote, mpeevent, mute, mutemap, note, notemessage, open, setvalue, threadcount, up, wclose + +Attributes: args, filterparams, legacynotemode, midimode, mpemode, parallel, patchername, replicate, resampling, steal, target, voices, vs, zone +""" + +polybuffer_tilde = MaxObject('polybuffer~') +""" +polybuffer~ - Manage multiple buffer~ objects + +polybuffer~ lets you operate with a group of buffer~ objects. Each buffer~ will be named after polybuffer~ first argument and an index (aka for a polybuffer~ toto object, each buffer~ will be named toto.N where N is the index). + +Args: + name (symbol, required) + +Inlets: + 0 (INLET_TYPE): Message in + +Outlets: + 0 (OUTLET_TYPE): dumpout + 1 (OUTLET_TYPE): bang When File/Folder Read Operation Completed + +Messages: (drag), append, appendempty, clear, (mouse), dump, getbufferlist, getcount, getshortname, getsize, open, readfolder, send, wclose, writetofolder + +Attributes: embed, quiet +""" + +pong_tilde = MaxObject('pong~') +""" +pong~ - Variable range signal folding + +Use the pong~ object to clip, fold, or wrap its input within the range of a low value and a high value. + +Args: + folding-mode (int, optional) + low-value (float, optional) + high-value (float, optional) + +Inlets: + 0 (signal/float): (signal/float) Input + 1 (signal/float): (signal/float) Lo val + 2 (signal/float): (signal/float) Hi val + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal + +Attributes: mode, range +""" + +pow_tilde = MaxObject('pow~') +""" +pow~ - Signal power function + +pow~ raises the base value (set in the right inlet) to the power of the exponent (set in the left inlet). Either inlet can receive a signal, float or int. + +Args: + base-value (number, optional) + +Inlets: + 0 (signal/float): (signal/float) Input + 1 (signal/float): (signal/float) Base + +Outlets: + 0 (signal): (signal) Base raised to Input + +Messages: int, float, signal +""" + +ramp_tilde = MaxObject('ramp~') +""" +ramp~ - Trigger a Single Ramp With an Audio Signal + +The ramp~ object generates a single signal ramp between a start and end value when it detects a change in an audio signal connected to its left inlet. The duration of the ramp can be a fixed value or based on the signal in ramp~'s second inlet. + +Args: + duration (float, optional) + +Inlets: + 0 (signal): Trigger Input + 1 (signal, float, timevalue): Duration Input + 2 (signal, float): Start + 3 (signal, float): End + +Outlets: + 0 (signal): Ramp Output + 1 (signal): bang When Ramp Completes + +Messages: int, float, anything, signal + +Attributes: curve, duration, end, interval, mode, reset, retrigger, start +""" + +rampsmooth_tilde = MaxObject('rampsmooth~') +""" +rampsmooth~ - Smooth an incoming signal + +Smooths an incoming signal across n samples. Each time an incoming value changes, it begins a linear ramp to reach this value. + +Args: + ramp-up-samples (int, optional) + ramp-down-samples (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal, int): Ramp up + 2 (signal, int): Ramp down + +Outlets: + 0 (signal): (signal) Smoothed result + +Messages: int, float, ramp, signal + +Attributes: rampdown, rampup +""" + +rand_tilde = MaxObject('rand~') +""" +rand~ - Band-limited random signal + +Use the rand~ object to generate a signal consisting of random values between -1 and 1 generated at a frequency specified by its input. It interpolates linearly between these values. + +Args: + initial-frequency (number, optional) + +Inlets: + 0 (signal/float): (signal/float) Frequency + +Outlets: + 0 (signal): (signal) The Noise Path + +Messages: int, float, signal +""" + +rate_tilde = MaxObject('rate~') +""" +rate~ - Time-scale the output of a phasor~ + +The rate~ object accepts an input signal from a phasor~ and time scales it by a multiplier received as a float in its right inlet. Numbers less than 1 create several ramps per phase cycle. Numbers greater than 1 create fewer ramps. This can be useful for implementing a phasor~-synchronized system in MSP. + +Args: + multiplier (float, optional) + sync-mode-flag (int, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (float/signal): (float/signal) Rate Multiplier + +Outlets: + 0 (signal): (signal) Time-Scaled Version of the Input + +Messages: int, float, goto, oneshot, reset, signal + +Attributes: sync +""" + +rdiv_tilde = MaxObject('rdiv~') +""" +rdiv~ - Signal division (inlets reversed) + +The !/~ object functions just like the /~ object, but the inlet order is reversed. + +Args: + initial-divisor (number, optional) + +Inlets: + 0 (signal): (signal) Right Operand in Left Inlet! + 1 (signal/float): (signal/float) Left Operand in Right Inlet! + +Outlets: + 0 (signal): (signal) Quotient Out + +Messages: int, float, signal +""" + +receive_tilde = MaxObject('receive~') +""" +receive~ - Signals can be received from any loaded patcher, without patch cords + +Use the receive~ object to grab signals put out by send~ objects and outputs them out its signal outlet. A receive~ object can be instantiated simply by typing into an object box the short-form letter "r~". + +Args: + object-name (symbol, required) + +Inlets: + 0 (INLET_TYPE): set Changes Source + +Outlets: + 0 (signal): Output + +Messages: (mouse), set, signal + +Attributes: chans, name +""" + +record_tilde = MaxObject('record~') +""" +record~ - Record sound into a buffer + +record~ records a signal into a buffer~ object. You can specify how many channels to record with the optional input-channels argument. Recording stops when the buffer~ is filled. + +Args: + buffer-name (symbol, required) + input-channels (int, optional) + +Inlets: + 0 (signal): Record Ch 1 In, 1 Starts, 0 Stops + 1 (double): Recording Start Point in ms + 2 (double): Recording End Point in ms + +Outlets: + 0 (signal): Sync Out + +Messages: int, float, list, anything, (mouse), reset, set, signal + +Attributes: append, loop, loopend, loopstart, transport +""" + +rect_tilde = MaxObject('rect~') +""" +rect~ - Antialiased rectangular (pulse) oscillator + +Use the rect~ object to generate an anti-aliased rectangle wave. + +Args: + frequency (number, optional) + pulse-width (number, optional) + +Inlets: + 0 (signal/float): (signal/float) frequency + 1 (signal/float): (signal/float) duty cycle + 2 (signal): (signal) sync input + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal, synctrig +""" + +reson_tilde = MaxObject('reson~') +""" +reson~ - Resonant bandpass filter + +Use the reson~ object when you need a resonant bandpass filter. + +Args: + initial-gain (float, optional) + center-frequency (float, optional) + Q (float, optional) + +Inlets: + 0 (signal): (signal) Input to Filter + 1 (signal/float): (signal/float) Input Gain + 2 (signal/float): (signal/float) Center Frequency + 3 (signal/float): (signal/float) Q (Resonance) + +Outlets: + 0 (signal): (signal) Filtered Output + +Messages: int, float, list, clear, signal + +Attributes: cf, gain, q +""" + +retune_tilde = MaxObject('retune~') +""" +retune~ - Ztx-based pitch detection and pitchshift + +Args: + standard pitch (int, required) + +Inlets: + 0 (Signal): original signal + 1 (Signal): pitch (Hz) + 2 (Signal): detune modulation (Cents) + +Outlets: + 0 (Signal): retuned signal + 1 (Signal): detected frequency + 2 (Signal): closest note + 3 (Signal): deviation in cents + 4 (List): closest note and deviation in cents + +Messages: list, defaulttuning, flush, getlatency, signal + +Attributes: correction_ambience_threshold, correction_amount, correction_bypass, correction_threshold, enablednotes, notebase, notelist, pitchdetection, quality, reportlatency, retune, use_16bit, windowsize +""" + +rminus_tilde = MaxObject('rminus~') +""" +rminus~ - Signal subtraction (inlets reversed) + +The !-~ object functions just like the -~ object, but the inlet order is reversed. + +Args: + initial-subtraction-value (number, optional) + +Inlets: + 0 (signal): (signal) Right Operand in Left Inlet! + 1 (signal/float): (signal/float) Left Operand in Right Inlet! + +Outlets: + 0 (signal): (signal) Difference Out + +Messages: int, float, signal +""" + +round_tilde = MaxObject('round~') +""" +round~ - Round an input signal value + +Use the round~ object to round a signal input to an integer multiple. + +Args: + int or float (number, optional) + +Inlets: + 0 (signal): Input + 1 (signal/float): Round to nearest this + +Outlets: + 0 (signal): Output + +Messages: int, float, signal + +Attributes: nearest +""" + +sah_tilde = MaxObject('sah~') +""" +sah~ - Sample and hold a signal + +Use sah~ to capture ("sample") and output ("hold") a value from an input signal whenever a trigger signal satisfies a threshold value according to one of several trigger conditions. The default trigger mode (Ascending) requires the signal to go from being at or below the threshold value to above it. At the moment the trigger condition is satisfied, the input signal is sampled and "held" until the trigger condition is satisfied again, at which point the input is sampled again. Generally this allows one signal to be synchronized to the behavior of another. + +Args: + initial-trigger-value (number, optional) + +Inlets: + 0 (signal): Values To Sample, double Sets Trigger Threshold + 1 (signal): Trigger Input + +Outlets: + 0 (signal): Output + +Messages: float, signal + +Attributes: duration, thresh, triggermode +""" + +sampstoms_tilde = MaxObject('sampstoms~') +""" +sampstoms~ - Convert time from samples to milliseconds + +Use the sampstoms~ object to convert an incoming signal carrying a time value in samples and output a signal which converts that number of samples to a number of milliseconds (at the current sampling rate). + +Inlets: + 0 (INLET_TYPE): Number of Samples In, signal to Use For Sampling Rate + +Outlets: + 0 (signal): (signal) Milliseconds At Input signal or Current Sampling Rate + 1 (double): (float) Milliseconds At Input signal or Current Sampling Rate + +Messages: int, float, list, signal +""" + +sash_tilde = MaxObject('sash~') +""" +sash~ - Sample and Hold with Memory + +The sash~ object performs sample-and-hold operations on an input signal but unlike the sah~ includes a buffer (the extra "s" in sash~ is for "storage") that can holds samples of the input. Sample capture and sample output are triggered independently of each other, and sash~ includes a variety of methods for selecting the output sample from the memory buffer. + +Inlets: + 0 (signal): Input + 1 (signal, float): Sample Trigger + 2 (signal, float): Advance Trigger + +Outlets: + 0 (signal): Output + +Messages: int, float, list, signal + +Attributes: advancelevel, dir, maxsize, mode, samplelevel, size +""" + +saw_tilde = MaxObject('saw~') +""" +saw~ - Antialiased sawtooth oscillator + +Use the saw~ object to generate an anti-aliased sawtooth wave. + +Args: + initial-frequency (number, optional) + +Inlets: + 0 (signal/float): (signal/float) frequency + 1 (signal): (signal) sync trigger + +Outlets: + 0 (signal): (signal) Input signal + +Messages: int, float, signal, synctrig +""" + +scale_tilde = MaxObject('scale~') +""" +scale~ - Map an input range of signal values to an output range + +Use the scale~ object to map an input range of signal values to an output range. The ranges can be specified with hi and lo reversed for inverted mapping. If specified, the mapping can also be exponential. + +Args: + minimum-in-value (number, required) + maximum-in-value (number, required) + minimum-out-value (number, required) + maximum-out-value (number, required) + scaling-curve (float, optional) + +Inlets: + 0 (signal): (signal) value to be scaled + 1 (signal/float): (signal/float) low input value + 2 (signal/float): (signal/float) high input value + 3 (signal/float): (signal/float) low output value + 4 (signal/float): (signal/float) high output value + 5 (signal/float): (signal/float) exponential base value + +Outlets: + 0 (signal): (signal) scaled output value + +Messages: int, float, signal + +Attributes: classic +""" + +scope_tilde = MaxObject('scope~') +""" +scope~ - Visualize an audio signal + +Use the scope~ object to visualize an audio signal using an oscilloscope-style display. + +Inlets: + 0 (signal): (signal) X Display, int Sets Buffers Per Pixel + 1 (signal): (signal) Y Display, Samples Per Buffer + +Messages: int, (mouse), signal + +Attributes: automatic, bgcolor, bordercolor, bufsize, calccount, delay, displaychan, displaysinglechannel, drawstyle, fgcolor, gridcolor, inactivealpha, mctrigchan, range, rounded, style, trigger, triglevel +""" + +selector_tilde = MaxObject('selector~') +""" +selector~ - Assign one of several inputs to an outlet + +Use the selector~ object to choose between one of several input signals (or none). The selector~ is similar to the Max switch object but for signals, however if no input is chosen, it outputs a signal composed of zero values. + + When the selector~ object is created as mcs.selector~ all of its signal inlets are combined into a single multichannel inlet. The behavior of mcs.selector~ is otherwise identical to selector~ with the exception that mcs.selector~ changes its number of inputs (auto-adapts) as the number of inputs in the multi-channel signal connected to its right inlet change. + +Args: + number-of-inputs (int, optional) + initially-open-inlet (int, optional) + +Inlets: + 0 (int/signal): int/signal Turns Input Off or Routes to Output + 1 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Output + +Messages: bang, int, float, next, signal + +Attributes: ramptime, stepmode +""" + +send_tilde = MaxObject('send~') +""" +send~ - Send signals without patch cords + +The send~ object lets you send a signal to another patcher window or to another location within the same patcher window without using a patch cord. A send~ object can be instantiated simply by typing into an object box the short-form letter "s~". + +Args: + object-name (symbol, required) + +Inlets: + 0 (signal): Send to receive~ a + +Messages: clear, (mouse), set, signal + +Attributes: name +""" + +seq_tilde = MaxObject('seq~') +""" +seq~ - Signal-driven event sequencer + +The seq~ object is an event sequencer that is driven by a signal input. seq~ can be used to create looping sequences of control data that are synchronized to a phasor~. + +Inlets: + 0 (signal): phasor~ input, commands, messages to be sequenced + +Outlets: + 0 (anything): sequence output + 1 (list): dump output + 2 (symbol): id on read, (bang) when done reading + +Messages: bang, int, float, list, anything, add, clear, delete, dump, erase, offset, overdub, play, read, record, seq, seqnum, signal, symbol, write +""" + +sfinfo_tilde = MaxObject('sfinfo~') +""" +sfinfo~ - Report audio file information + +sfinfo~ gives you the number of channels, sample size, sampling rate, sampletype, filename, and duration of a soundfile. + +Args: + filename (symbol, optional) + +Inlets: + 0 (INLET_TYPE): open Opens File, bang Reports Info + +Outlets: + 0 (OUTLET_TYPE): Number of Channels + 1 (OUTLET_TYPE): Sample Size in Bits + 2 (OUTLET_TYPE): Sampling Rate + 3 (OUTLET_TYPE): File Length in Milliseconds + 4 (OUTLET_TYPE): Sample Type + 5 (OUTLET_TYPE): File Name + +Messages: bang, (drag), getnamed, open +""" + +sfizz_tilde = MaxObject('sfizz~') +""" +sfizz~ - Sfz format sample player + +sfizz~ is a player for files in the Sfz format. The format uses simple text files that specify how audio sample files are triggered by MIDI notes and controllers. (Information on the format is available at + + sfzformat.com + + .) The object accepts MIDI messages and produces two or more audio outputs. sfizz~ makes use of the open source + + Sfizz library project + + that supports a + + large subset of standard Sfz opcodes + +Args: + filename (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Note Number or midievent Message + 1 (INLET_TYPE): Velocity + +Outlets: + 0 (OUTLET_TYPE): Audio Output 1 + 1 (OUTLET_TYPE): Audio Output 2 + +Messages: int, float, list, (drag), (mouse), dictionary, midievent, read, readagain, signal + +Attributes: base, defaultpathname, filename, map, mapname, mid, outputs, pathmode, ref, scale, scalename, silent, voices, volume +""" + +sflist_tilde = MaxObject('sflist~') +""" +sflist~ - Store audio file cues + +sflist~ stores a list of preloaded cues for sound files that can be accessed by multiple sfplay~ objects. Each sflist~ object has a unique name that sfplay~ objects use to refer to its cues. Defining a cue is the same for sflist~ as for sfplay~. You can preload cues for sflist~ without the audio being on. + +Args: + object-name (symbol, required) + buffer-size (int, optional) + +Inlets: + 0 (INLET_TYPE): open Opens File, preload Defines Cue + +Outlets: + 0 (OUTLET_TYPE): Cue Reporting + +Messages: clear, embed, fclose, open, openraw, preload, print + +Attributes: name +""" + +sfplay_tilde = MaxObject('sfplay~') +""" +sfplay~ - Play audio file from disk + +Use the sfplay~ object to play audio files from disk. Supported formats include AIFF, WAVE, MP3, OGG, FLAC, M4A, CAF, WF64, WAVE64, and Raw Data. + +Args: + sflist-object-name (symbol, optional) + number-of-output-channels (int, optional) + buffer-size (int, optional) + position-outlet-flag (int, optional) + object-reference-name (symbol, optional) + +Inlets: + 0 (signal/msg): open Opens File, int Plays Cue, 0 Stops + 1 (signal/float): Speed Input + +Outlets: + 0 (signal): File Ch 1 Output + 1 (signal): bang When Done Playing + +Messages: int, float, list, anything, (drag), clear, dictionary, embed, fclose, loopone, modout, offset, open, openraw, pause, preload, preloadn, print, resume, samptype, seek, set, signal, srate, srcchans + +Attributes: audiofile, basictuning, followglobaltempo, formant, formantcorrection, loop, mode, name, originallength, originaltempo, pitchcorrection, pitchshift, pitchshiftcent, quality, slurtime, speed, timestretch +""" + +sfrecord_tilde = MaxObject('sfrecord~') +""" +sfrecord~ - Record to audio file on disk + +Use the sfrecord~ object to record and save MSP output as an audio file. + +Args: + number-of-input-channels (int, optional) + buffer-size (int, optional) + +Inlets: + 0 (signal): (signal) Record Ch 1, 1/0 Record On/Off + +Outlets: + 0 (signal): (signal) elapsed time (ms) + +Messages: int, loop, open, print, record, samptype, signal + +Attributes: beginramp, bitdepth, dither, endramp, nchans, quantization, resample, sortloop +""" + +shape_tilde = MaxObject('shape~') +""" +shape~ - Time-scaled Breakpoint Envelope Generator + +An envelope for the shape~ object can be defined using the same format as the line~ or zigzag~ objects (and edited graphically by connecting a function object). Unlike line~ the time values of shape~ are normalized so that the output occurs within signal ramp of a phasor from 0 to 1 (or 1 to 0). This means you can trigger the output sample-accurately and determine the time of the function by using different ramp durations (or phasor~ frequencies). + +Inlets: + 0 (signal): Input Phasor, Define Function + +Outlets: + 0 (signal): Time-Scaled Function + +Messages: int, float, list, signal + +Attributes: constant, curvemode, syncupdate +""" + +sig_tilde = MaxObject('sig~') +""" +sig~ - Convert numbers into audio signals + +Use the sig~ object to convert regular numbers into audio signals. + +Args: + initial-output-value (number, optional) + +Inlets: + 0 (float): (signal) Order Forcing, float Sets Value + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, list, set, signal +""" + +sinh_tilde = MaxObject('sinh~') +""" +sinh~ - Signal hyperbolic sine function + +Use the sinh~ object to calculate and output a signal that is the hyperbolic sine function of each sample of the input signal. + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Sinh (x) Out + +Messages: signal +""" + +sinx_tilde = MaxObject('sinx~') +""" +sinx~ - Signal sine function + +sinx~ is a real sine function whose input expects values between 0 and 2π (similar to cosx~ but unlike cos~ which is designed to work with phasor~'s output from 0 to 1). + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Sin (x) Out + +Messages: signal +""" + +slide_tilde = MaxObject('slide~') +""" +slide~ - Filter a signal logarithmically + +Use the slide~ object for envelope following and lowpass filtering. + +Args: + slide-up (float, optional) + slide-down (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal, float): Slide up + 2 (signal, float): Slide down + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, reset, signal + +Attributes: slidedown, slideup +""" + +snapshot_tilde = MaxObject('snapshot~') +""" +snapshot~ - Convert signal values to numbers + +Use the snapshot~ object to convert a signal value into a float message when a bang is received or according to a specified interval. The interval can be set to a fixed or tempo-relative rate using the Max time format syntax. + +Args: + reporting-interval (list, optional) + +Inlets: + 0 (signal): In, bang Reports Signal Value + 1 (signal): Internal Clock Interval in ms + +Outlets: + 0 (float): Signal Values + +Messages: bang, int, float, list, anything, sampleinterval, signal, start, stop + +Attributes: active, interval, offset +""" + +snowfall_tilde = MaxObject('snowfall~') +""" +snowfall~ - Phasor-Driven Particle + +The snowfall~ object controls a multi-dimensional particle as one or more audio ramps whose lifetime is triggered and controlled by an input phasor ramp from 0 to 1. The object will typically be used within a larger system of quasi-independent particles using the MC Wrapper as mc.snowfall~. + +Args: + dimenions (int, optional) + +Inlets: + 0 (signal): Phasor Input + +Outlets: + 0 (signal): Particle Output + +Messages: signal + +Attributes: boundarymode, dimensions, direction, directiondev, endmode, endvalue, energyramp, initial, initialdev, interval, intervaldev, max, min, scalemax, scalemin, squish, startmode, wanderprob +""" + +spectroscope_tilde = MaxObject('spectroscope~') +""" +spectroscope~ - Signal spectrogram or sonogram + +spectroscope~ serves as a visual spectrogram or sonogram interface for the analysis of signals. + +Inlets: + 0 (signal): Input signal + 1 (signal): Imaginary Signal (Inside pfft~) + +Outlets: + 0 (OUTLET_TYPE): undefined + +Messages: (mouse), signal + +Attributes: bgcolor, border, bordercolor, curvecolor, displaychan, domain, fgcolor, interval, logamp, logfreq, markercolor, monochrome, orientation, phasespect, range, rounded, scroll, sono, sonohicolor, sonolocolor, sonomedcolor, sonomedhicolor, sonomedlocolor, sonomonobgcolor, sonomonofgcolor, style +""" + +spike_tilde = MaxObject('spike~') +""" +spike~ - Report intervals of zero to non-zero transitions + +spike~ reports intervals of zero to non-zero transitions. + +Args: + refractory-period (int, float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (double): (float) Refractory period + +Outlets: + 0 (double): (float) Outputs interval on zero to non-zero transition + +Messages: bang, ft1, in1, signal +""" + +sqrt_tilde = MaxObject('sqrt~') +""" +sqrt~ - Square root of a signal + +sqrt~ will output a signal which is the square-root function of the input signal. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Square Root + +Messages: signal +""" + +stash_tilde = MaxObject('stash~') +""" +stash~ - Store and Recall Audio Signal Values + +Use the stash~ object to store and recall a buffer of signal values. In one mode, stash~ can perform sample-and-hold operations on an input signal but unlike the sah~, stash~ reads from a buffer rather than holds a single sample. stash~ can be a simple interpolating lookup table or audio-rate step sequencer. + +Args: + sample-thresh (float, optional) + advance-thresh (float, optional) + +Inlets: + 0 (signal, float): Input + 1 (signal, float): Sample Trigger + 2 (signal, float): Advance Trigger or Index + 3 (signal, float): Write Index + +Outlets: + 0 (signal): Output + 1 (signal): Index + +Messages: bang, int, float, list, signal + +Attributes: advancelevel, advancetriggermode, dir, duration, extend, interp, maxsize, mode, samplelevel, sampletriggermode, size, writemode +""" + +stepcounter_tilde = MaxObject('stepcounter~') +""" +stepcounter~ - Count signal jumps in a sequence + +The stepcounter~ object uses signal jumps -- impulses and/or phasor resets -- to advance through a sequence of count values. The signal outputs of stepcounter~ can be used to generate a sequence of durations from a regular signal input pulse, such as is provided by the phasor~ object. + +Inlets: + 0 (signal): Count Impulses or Signal Jumps + +Outlets: + 0 (signal): Impulse When Current Step Count Reached + 1 (signal): Impulse When Sequence Resets + 2 (signal): Step Index (0-Relative) + 3 (signal): Counter Index (0-Relative) + +Messages: reset, signal + +Attributes: direction, seq, startmode, syncupdate, thresh +""" + +stepdiv_tilde = MaxObject('stepdiv~') +""" +stepdiv~ - Generate Phasors for Each Step of a Function + +The stepdiv~ object produces a signal output consisting of a sequence of phasors according to the delta times in a breakpoint function list produced by the function object. When a phasor signal is connected to the left inlet, stepdiv~ subdivides the phasor according to the relative times of the breakpoints. When no signal input is connected, stepdiv~ produces phasors over the specified delta times. Connect the left and right outputs of stepdiv~ to stepfun~ to generate the actual function data. + +Inlets: + 0 (signal): Input + +Outlets: + 0 (signal): Output + 1 (signal): Step Number + +Messages: bang, int, float, list, signal, what + +Attributes: curvemode, loop, pattern, syncupdate +""" + +stepfun_tilde = MaxObject('stepfun~') +""" +stepfun~ - Generate a Function Sequenced by Input Phasors + +The stepfun~ object generates a breakpoint function whose timing is determined by a seqeuence of input phasor ramps. If the input ramps are non-linear, the output of stepfun~ will be similarly non-linear. + +Inlets: + 0 (signal): Input + 1 (signal, int): Step Number + +Outlets: + 0 (signal): Output + 1 (signal): Step Number + +Messages: bang, int, float, list, signal, step + +Attributes: curvemode, curvepattern, pattern, syncupdate +""" + +stretch_tilde = MaxObject('stretch~') +""" +stretch~ - Ztx-based pitch/time modification of an audio buffer + +Use the stretch~ object to perform destructive pitch and time modifications to the contents of a buffer~. object. + +Args: + buffer-name (symbol, required) + +Inlets: + 0 (INLET_TYPE): bang to start time stretching + +Outlets: + 0 (OUTLET_TYPE): timestretch progress information + 1 (OUTLET_TYPE): bang when done + +Messages: bang, apply, cancel, (mouse), dictionary, set + +Attributes: basictuning, followglobaltempo, formant, formantcorrection, mode, originallength, originaltempo, pitchcorrection, pitchshift, pitchshiftcent, progress_enable, quality, readagain, slurtime, stretch +""" + +stutter_tilde = MaxObject('stutter~') +""" +stutter~ - Signal capture buffer for granular playback + +The stutter~ object keeps a history of its signal input (left inlet). Upon receiving an int (left inlet), it copies that number of the most recently received samples to another playback buffer. This buffer may be cycled through by its phase, 0-1 (right inlet). On receiving a bang (left inlet) or a trigger signal (middle inlet), the last integer number of samples are copied to the playback buffer. + +Args: + max-buffer-length (int, required) + initial-buffer-size (int, required) + trigger-polarity (int, required) + number-of-copied-samples (int, required) + number-of-outputs (int, optional) + +Inlets: + 0 (signal): (signal) Memory Input + 1 (signal): (signal) Trigger + 2 (signal): (signal) Playback Input 1 + +Outlets: + 0 (signal): (signal) Playback Output 1 + +Messages: bang, int, ampvar, clear, dropout, maxsize, polarity, print, repeat, setbuf, signal +""" + +subdiv_tilde = MaxObject('subdiv~') +""" +subdiv~ - Integer Subdivision of a Phasor + +The subdiv~ object evenly subdivides an input phasor signal into any integer number of output phasor signals. + +Args: + subdivisions (int, required) + +Inlets: + 0 (signal): Phasor Input + +Outlets: + 0 (signal): Output + 1 (signal): Step Number + 2 (int) + +Messages: int, float, signal + +Attributes: div, lockprob, pattern, prob, silentmode, syncupdate +""" + +svf_tilde = MaxObject('svf~') +""" +svf~ - State-variable filter with simultaneous outputs + +The svf~ object is an implementation of a state-variable filter algorithm described in Hal Chamberlin's book, "Musical Applications of Microprocessors." A unique feature of this filter object is that it produces lowpass, highpass, bandpass, and bandreject (notch) output simultaneously - all four are available as outlets. + +Args: + center-frequency (float, optional) + resonance (float, optional) + Hz (symbol, optional) + linear (symbol, optional) + radians (symbol, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Cutoff Frequency (Hz) + 2 (signal/float): (signal/float) Resonance (0-1) + +Outlets: + 0 (signal): (signal) Low-pass Output + 1 (signal): (signal) High-pass Output + 2 (signal): (signal) Band-pass Output + 3 (signal): (signal) Notch Output + +Messages: int, float, Hz, clear, linear, radians, signal +""" + +swing_tilde = MaxObject('swing~') +""" +swing~ - Subdivide a phasor into two unequal phasors + +The swing~ object outputs two phasor signals in the space of one input phasor, with the ability to adjust the "swing" or proportion of the time of the input phasor given to the first of the two output phasors. If the swing is set to 0.5, both the first and second output phasors are equal. But if the swing is set to 0.75, the first phasor lasts for three fourths of the input and the second phasor lasts for one fourth of the time. + +Args: + swing (float, optional) + +Inlets: + 0 (signal): Phasor Input + +Outlets: + 0 (signal): Output + 1 (signal): Step Number + 2 (int): Step Number + +Messages: int, float, signal + +Attributes: swing, syncupdate +""" + +sync_tilde = MaxObject('sync~') +""" +sync~ - Synchronize MSP with an external source + +sync~ outputs a 0-1 ramp, like phasor~. The frequency of the ramp can be specified in beats per minute (BPM), or by sending sync~ a tempo reference via tap tempo, MIDI beat clock, or an audio signal containing a 'click track.' Also, sync~ generates MIDI beat clock to synchronize external devices. + +Inlets: + 0 (INLET_TYPE): synchronization input and messages to sync~ + +Outlets: + 0 (OUTLET_TYPE): synchronized ramp (0-1) + 1 (OUTLET_TYPE): BPM and beat detect information + 2 (OUTLET_TYPE): MIDI beat clock + +Messages: bang, int, float, bpm, midioffset, offset, ppq, signal, start, stop + +Attributes: rtport +""" + +table_tilde = MaxObject('table~') +""" +table~ - Signal Table Lookup + +Use table~ to remap incoming signal values with a table object. + +Inlets: + 0 (signal): Input + +Outlets: + 0 (signal): Output + +Messages: bang, int, float, (mouse), goto, next, prev, signal + +Attributes: annotation_name, embed, extend, inmap, inputmode, interp, name, outscale, parameter_enable, parameter_mappable, range, signed, size, triggermode +""" + +tanh_tilde = MaxObject('tanh~') +""" +tanh~ - Signal hyperbolic tangent function + +Use the tanh~ object to calculate and output a signal that is the hyperbolic tangent function of each sample of the input signal. + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Tanh (x) Out + +Messages: signal +""" + +tanx_tilde = MaxObject('tanx~') +""" +tanx~ - Signal tangent function + +Use the tanx~ object to calculate and output a signal that is the tangent function of each sample of the input signal. The tanx~ object is a true π based function - it varies from the tanh~ object, whose output is based around 1 and is intended for use as a lookup table with the phasor~ object. + +Inlets: + 0 (INLET_TYPE): Input Signal + +Outlets: + 0 (OUTLET_TYPE): Tan (x) Out + +Messages: signal +""" + +tapin_tilde = MaxObject('tapin~') +""" +tapin~ - Input to a delay line + +tapin~ receives a signal in and copies into a delay line. Using tapout~ objects, you can read from the delay line at various delay times. You must connect the outlet of a tapin~ object to the tapout~ objects you want to use with the delay line. Note that this is not a signal connection, since no signal travels between the objects. It is merely a way to indicate that the objects share the same delay memory. + +Args: + maximum-delay (number, optional) + +Inlets: + 0 (signal): (signal) Input Written To Delay Line + +Outlets: + 0 (OUTLET_TYPE): Connect To One Or More tapout~ Objects + +Messages: int, float, clear, freeze, signal +""" + +tapout_tilde = MaxObject('tapout~') +""" +tapout~ - Output from a delay line + +The outlet of a tapin~ object must be connected to the left inlet of tapout~ in order for the delay line to function. + + + The tapout~ object has one or more inlets and one or more outlets. A delay time signal or number received in an inlet affects the output signal coming out of the outlet directly below the inlet. + + + The tapout~ object is sub-sample accurate specifically when receiving a delay time signal in an inlet. It is not sub-sample accurate when receiving a delay time number in an inlet. + +Args: + initial-delay (number, optional) + +Inlets: + 0 (signal/float): (signal/float) Delay Time in ms. Signal-based delay uses interpolation, which introduces a one-sample delay + +Outlets: + 0 (signal): (signal) Delayed Output + +Messages: int, float, list, signal, tapconnect + +Attributes: unique +""" + +techno_tilde = MaxObject('techno~') +""" +techno~ - Signal-driven step sequencer + +techno~ is a signal-based step-sequencer that facilitates sample-accurate timing of events. + +Inlets: + 0 (signal/message): (signal/message) phasor/note messages + +Outlets: + 0 (signal): (signal) frequency + 1 (signal): (signal) amplitude envelope + 2 (signal): (signal) step position + +Messages: amplitude, attack, curve, decay, length, pitch, pos, repeatpos, signal +""" + +teeth_tilde = MaxObject('teeth~') +""" +teeth~ - Comb filter with feedforward and feedback delay control + +The teeth~ object implements a comb filter, in which a slightly delayed version of a signal is added to itself, causing phase cancellations and a spectrum that looks like a comb. + +Args: + maxdelaytime (float, optional) + feedforward-delay (float, optional) + feedback-delay (float, optional) + gain (float, optional) + feedforward-gain (float, optional) + feedback-gain (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Feedforward Delay in ms + 2 (signal/float): (signal/float) Feedback Delay in ms + 3 (signal/float): (signal/float) Gain Coefficient + 4 (signal/float): (signal/float) Feedforward Coefficient + 5 (signal/float): (signal/float) Feedback Coefficient + +Outlets: + 0 (signal): (signal) Filter Output + +Messages: int, float, clear, signal, list +""" + +thispoly_tilde = MaxObject('thispoly~') +""" +thispoly~ - Control poly~ voice allocation and muting + +Use the thispoly~ object to control poly~ voice allocation and muting. When placed inside a patcher loaded by the poly~ object, it sends and receives messages from the poly~ object that loads it. + +Inlets: + 0 (INLET_TYPE): bang Reports Index and Mute, int Sets Voice Busy + +Outlets: + 0 (OUTLET_TYPE): Instance Index of Patcher + 1 (OUTLET_TYPE): Mute Flag (0/1) for Instance + 2 (OUTLET_TYPE): Total poly~ voice count + +Messages: bang, int, mute, signal + +Attributes: automute +""" + +thresh_tilde = MaxObject('thresh~') +""" +thresh~ - Detect signal above a set level + +Use the thresh~ object to detect signals which exceed a specified level. + +Args: + low/reset-threshold (float, required) + high/set-threshold (float, required) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Low Threshold + 2 (signal/float): (signal/float) High Threshold + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, list, signal +""" + +times_tilde = MaxObject('times~') +""" +times~ - Multiply two signals + +*~ is a signal multiplier-operator that outputs a signal which is the multiplication between two signals. + +Args: + initial-multiplier (number, optional) + +Inlets: + 0 (Signal/Float): (Signal/Float) This * Right Inlet + 1 (Signal/Float): (Signal/Float) Left Inlet * This + +Outlets: + 0 (Signal): (signal) Multiplication Result + +Messages: int, float, signal +""" + +train_tilde = MaxObject('train~') +""" +train~ - Pulse train generator + +train~ generates a pulse signal whose period is specifiable in terms of milliseconds (see <~ for a method of making a pulse wave at a specified frequency). It also sends out a bang when going from 0 to 1, so it can be used as a metronome with a floating-point interval. + +Args: + inter-pulse-interval (number, optional) + pulse-width (number, optional) + phase (number, optional) + +Inlets: + 0 (signal/float): (signal/float) Pulse Interval in ms + 1 (signal/float): (signal/float) Pulse Width from 0 to 1 + 2 (signal/float): (signal/float) Phase from 0 to 1 + +Outlets: + 0 (signal): (signal) Pulse Output + 1 (signal): bang on 0 to 1 Transition + +Messages: bang, int, float, signal + +Attributes: interval, phase, resetmode, width +""" + +trapezoid_tilde = MaxObject('trapezoid~') +""" +trapezoid~ - Trapezoidal wavetable + +trapezoid~ is a trapezoidal wavetable with signal inputs to change ramp up/down phase position. The default lo/hi points are 0. and 1., but may be changed using the lo/hi messages. + +Args: + ramp-up (float, optional) + ramp-down (float, optional) + +Inlets: + 0 (signal): (signal) Input + 1 (signal/float): (signal/float) Point 1 + 2 (signal/float): (signal/float) Point 2 + +Outlets: + 0 (signal): (signal) Output + +Messages: float, signal + +Attributes: hi, lo, wrapmode +""" + +tri_tilde = MaxObject('tri~') +""" +tri~ - Antialiased triangular oscillator + +tri~ generates a triangle wave whose component frequencies are resistant to aliasing. + +Args: + initial-frequency (number, optional) + duty-cycle (float, optional) + +Inlets: + 0 (signal/float): (signal/float) Frequency + 1 (signal/float): (signal/float) Duty Cycle + 2 (signal): (signal/float) Sync Input + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, signal +""" + +triangle_tilde = MaxObject('triangle~') +""" +triangle~ - Triangle/ramp wavetable + +triangle~ is a triangle/ramp wavetable with signal input to change phase offset of the peak value. The default lo/hi points are -1. and 1., but may be changed using the lo/hi messages. + +Args: + peak-value-phase-offset (float, optional) + +Inlets: + 0 (signal): (signal) Phase + 1 (signal/float): (signal/float) Point 1 + +Outlets: + 0 (signal): (signal) Output + +Messages: float, signal + +Attributes: hi, lo +""" + +trunc_tilde = MaxObject('trunc~') +""" +trunc~ - Truncate fractional signal values + +trunc~ converts signals with values such as 1.75 to 1.0. Negative values are modified so that -1.75 becomes -1.0. This object is very simple but computationally expensive. + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Integer Part of Input + +Messages: signal +""" + +twist_tilde = MaxObject('twist~') +""" +twist~ - Make Linear Ramps Curved + +The twist~ object accepts a ramp between 0 and 1 (such as one generated by phasor~) and produces a piecewise linear approximation of an expoential function using the same algorithm as the curve~ object. The curvature of the ramp is controlled by the curve attribute that ranges from -1 to 1. A curve value of 0 produces an output ramp identical to the input. + +Inlets: + 0 (signal): Ramp Input + 1 (signal/float): Curve Amount + +Outlets: + 0 (signal): Curved Ramp Out + +Messages: int, float, signal, test + +Attributes: curve, shapemode, syncupdate +""" + +typeroute_tilde = MaxObject('typeroute~') +""" +typeroute~ - Route input based on the type of data received + +typeroute~ directs input based on the type of data received. + +Inlets: + 0 (INLET_TYPE): Input + +Outlets: + 0 (signal): (signal) An audio signal, if the input type is an audio signal + 1 (bang): (bang) A bang, if the input type is a bang + 2 (int): (int) An int, if the input type is an int + 3 (float): (float) A float, if the input type is a float + 4 (symbol): (symbol) A symbol, if the input type is a symbol + 5 (list): (list) A list, if the input type is a list + +Messages: bang, int, float, list, anything, signal +""" + +updown_tilde = MaxObject('updown~') +""" +updown~ - Trapezoidal Function Generator With Constant Attack and Release + +The updown~ object is driven by a ramp from 0 - 1 or 1 - 0. It generates a trapezoidal function where the attack and release times are independent of the speed of the input ramp, unlike trapezoid~ where start and end times are specified as a proportion of the total input ramp cycle and thus will vary with the speed of the input ramp. + + + Note that the up phase of the updown~ object's output occurs after the reset of a phasor or a zero-to-non-zero transition, whether the input ramp moves up or down. The down phase of the output occurs in the time before a reset (or the end of the ramp) is expected to occur. + +Inlets: + 0 (signal): Phasor Input + +Outlets: + 0 (signal): Trapezoidal Output + +Messages: bang, signal + +Attributes: down, level, reset, up +""" + +vectral_tilde = MaxObject('vectral~') +""" +vectral~ - Vector-based envelope follower + +Use the vectral~ object to filter frame-based signal data such as the output of the fft~ object. + +Args: + vector-size (int, optional) + +Inlets: + 0 (signal): (signal) Output Index + 1 (signal): (signal) Input Index + 2 (signal): (signal) Input Value + +Outlets: + 0 (signal): (signal) Output Value + +Messages: clear, deltaclip, rampsmooth, signal, size, slide +""" + +vst_tilde = MaxObject('vst~') +""" +vst~ - Host VST, VST3 and Audio Unit plug-ins + +Use the vst~ object to load a real-time VST, VST3 or Audio Unit plug-in and use its audio processing in MSP. When vst~ is instantiated as mcs.vst~, the plug-in's audio inputs are combined into a single multichannel inlet and its audio outputs are combined into a single multichannel outlet. + +Args: + number-of-inputs/outputs (int, optional) + VST-plugin-filename (symbol, optional) + preset-effects-name (symbol, optional) + +Inlets: + 0 (INLET_TYPE): Audio/Control Input + 1 (signal): Audio Input 2 + +Outlets: + 0 (signal): Audio Output 1 + 1 (signal): Audio Output 2 + 2 (signal): Parameter Names + 3 (signal): Parameter Index and Value When Changed + 4 (signal): Plug-in Generated MIDI Events + 5 (signal): Program Names + 6 (signal): Subnames (VST Shell Plug-ins Only) + 7 (signal): Preset Names (Audio Unit Plug-ins Only) + +Messages: int, float, list, anything, (drag), (mouse), disable, drop, get, getsubnames, midievent, mpeevent, open, params, pgmnames, plug, plug_au, plug_vst, plug_vst3, presetnames, printids, read, scan, set, signal, subname, sysexevent, unplug, wclose, write, writebank, writepgm + +Attributes: annotation_name, autosave, bypass, currentplug, enablehscroll, enablevscroll, floateditorwindow, genericeditor, legacytransport, mcisolate, parameter_enable, prefer, transport, valuemode +""" + +wave_tilde = MaxObject('wave~') +""" +wave~ - Variable size wavetable + +wave~ reads from a portion of a buffer~ to produce a repeating waveform, given a signal input that goes between 0 and 1 (for example, using a phasor~) to define the position in the buffer. When the wave~ object is instantiated as mcs.wave~ its outputs are combined into a single multichannel output but otherwise it functions identically to wave~. + +Args: + buffer-name (symbol, required) + start-point (number, optional) + end-point (number, optional) + number-of-output-channels (int, optional) + +Inlets: + 0 (signal): (signal) Table Position (from 0 to 1) + 1 (signal/float): ((signal/float) Starting Table Location in ms + 2 (signal/float): (signal/float) Ending Table Location in ms + +Outlets: + 0 (signal): (signal) Output + +Messages: int, float, list, (mouse), set, signal + +Attributes: interp, interp_bias, interp_tension +""" + +waveform_tilde = MaxObject('waveform~') +""" +waveform~ - buffer~ viewer and editor + +Use the waveform~ object to view or edit the contents of a buffer~. + +Inlets: + 0 (float): Display Start (ms) + 1 (float): Display Length (ms) + 2 (float): Selection Start (ms) / (list) Selection Start - Selection End + 3 (float): Selection End (ms) + 4 (float): Link In (for multi-channel viewing) + +Outlets: + 0 (float): Display Start (ms) + 1 (float): Display Length (ms) + 2 (float): Selection Start (ms) + 3 (float): Selection End (ms) + 4 (float): Mouse Output (x,y,state) + 5 (float): Link Out (for multi-channel viewing) + +Messages: bang, int, float, list, (drag), bpm, buftime, crop, line, mode, (mouse), mouseoutput, name, normalize, replacebuffercontents, set, setbpm, snap, undo, unit + +Attributes: allowdrag, attr_bpm, beats, bgcolor, bordercolor, buffername, chanoffset, clipdraw, grid, gridcolor, invert, labelbgcolor, labels, labeltextcolor, linecolor, norulerclick, offset, outmode, quiet, reflection, reflectioncolor, selectalpha, selectioncolor, setmode, setunit, shadowalpha, shadowblend, shadowline, shadowproportion, snapto, style, ticks, vlabels, voffset, vticks, vzoom, waveformcolor, zoom_orientation, zoomstyle, zoomthresh +""" + +what_tilde = MaxObject('what~') +""" +what~ - Generate Impulses for a List of Audio Values + +The what~ object generates an impulse -- a signal value of 1 for one sample -- when its input signal crosses a value threshold. The object accepts a list of threshold values and will generate impulses for all of them. Connect a phasor~ to what~ to create a repeating rhythm. For example, when sending in a list of 0 0.25 0.5 and 0.75, what~ will output an impulse four times for each phasor~ ramp. + +Args: + values (list, optional) + +Inlets: + 0 (signal): Input + +Outlets: + 0 (signal): Impulse if Values Detect, 0 Otherwise + 1 (int): Index of Matched Item + +Messages: int, float, list, clear, signal + +Attributes: matches, syncupdate, triggermode +""" + +where_tilde = MaxObject('where~') +""" +where~ - Report Elapsed and Remaining Time of a Phasor + +The where~ object generates two signals: one reports the elapsed time since the reset of a phasor ramp; the other predicts of the remaining time until the phasor resets again. You can use these time values to synchronize events to specific times within a ramp instead of its relative phase. For example, if you want something to happen at 30 milliseconds before the phasor is scheduled to reset, you can wait until the remaining time signal has a value of 30 or less. where~ has a direction detection feature so it can report the elapsed and remaining time of ramps that go from 1 to 0 (as produced by a phasor~ object with negative frequency) in addition to ramps that go from 0 to 1. + +Inlets: + 0 (signal): Input + +Outlets: + 0 (signal): Elapsed Time + 1 (signal): Predicted Time Until Reset + +Messages: signal +""" + +windowed_fft_tilde = MaxObject('windowed-fft~') +""" +windowed-fft~ - Windowed/Overlapped Fast Fourier Transform + +windowed-fft~ is an abstraction wrapping a pair of fft~ objects and performing the necessary windowing and overlap to use the output for analysis. + +Args: + number-of-FFT-samples (int, required) + +Messages: signal +""" + +zerox_tilde = MaxObject('zerox~') +""" +zerox~ - Detect zero crossings + +zerox~ functions as a zero-crossing counter or transient detector. + +Args: + click-volume (float, optional) + +Inlets: + 0 (signal): (signal) Input + +Outlets: + 0 (signal): (signal) Number of Zero-Crossings per Signal Vector + 1 (signal): Clicks at Zero-Crossings + +Messages: set, signal +""" + +zigzag_tilde = MaxObject('zigzag~') +""" +zigzag~ - Linked list function editor + +Use zigzag~ to generate multisegment linear ramps. This object is similar to line~, but retains information about the ramp after it has been output, and allows modification of the list values for the ramp. + +Args: + initial-value (int, float, optional) + +Inlets: + 0 (INLET_TYPE): Destination Value + 1 (INLET_TYPE): Speed + +Outlets: + 0 (signal): (signal) Output Ramp + 1 (signal): (signal) Current Index + 2 (signal): Contents of Current List + 3 (signal): bang When Line Reaches Destination + +Messages: bang, int, float, list, append, bangdelta, bound, delete, dump, end, insert, jump, jumpend, jumpstart, line, next, prev, print, ramptime, set, setindex, setline, signal, skip, speed, start, stop + +Attributes: loopmode, maxpoints, mode +""" + +zplane_tilde = MaxObject('zplane~') +""" +zplane~ - Graph filter poles and zeros on the Z-plane + +The zplane~ object provides a way to graph filter poles and zeros in the Z-plane for display. Use the zplane~ object in conjunction with the filtergraph~ object, or provide it with a list of biquad~ coefficients. + +Inlets: + 0 (float): Filter coefficient a0 + 1 (float): Filter coefficient a1 + 2 (float): Filter coefficient a2 + 3 (float): Filter coefficient b1 + 4 (float): Filter coefficient b2 + +Outlets: + 0 (list): List of 2nd Order Filter Coefficients + 1 (float): List of Zero Coordinate Pairs + 2 (float): List of Pole Coordinate Pairs + 3 (float): List of 2nd Order Filter Gains + +Messages: bang, float, list, dictionary, ft1, ft2, ft3, ft4, logscale, (mouse), range + +Attributes: axiscolor, bgcolor, bordercolor, circlebordercolor, fgcolor, gridlinecolor, hlcolor, order, pconstrain, polezerocolor, rounded, style +""" + +_sys.stdout = _old_stdout +_devnull.close() +del _devnull, _old_stdout diff --git a/maxpylang/tools/objfuncs/args.py b/maxpylang/tools/objfuncs/args.py index e61f853..45283d7 100644 --- a/maxpylang/tools/objfuncs/args.py +++ b/maxpylang/tools/objfuncs/args.py @@ -8,7 +8,10 @@ """ +import warnings + from maxpylang.tools import typechecks as tc +from maxpylang.exceptions import UnknownObjectWarning import tabulate def args_valid(self, name, args, arg_info): @@ -22,31 +25,36 @@ def args_valid(self, name, args, arg_info): #check that we have enough args if len(args_req) > len(args): - print("ObjectError:", name, ": missing required arguments") - print() - print (tabulate.tabulate([[x['name'], x['type']] for x in args_req], - ['req arg', 'type'], tablefmt='pretty')) + req_table = tabulate.tabulate([[x['name'], x['type']] for x in args_req], + ['req arg', 'type'], tablefmt='pretty') + warnings.warn( + f"'{name}': missing required arguments\n{req_table}", + UnknownObjectWarning, stacklevel=4 + ) return False #check all type, argument pairs are valid req_types = [arg['type'] for arg in args_req] if not all([tc.check_type(t, a) for t, a in zip(req_types, args[:len(args_req)])]): - print("ObjectError:", name, ": bad type(s) for required arguments") - print() - print (tabulate.tabulate([[x['name'], x['type']] for x in args_req], - ['req arg', 'type'], tablefmt='pretty')) + req_table = tabulate.tabulate([[x['name'], x['type']] for x in args_req], + ['req arg', 'type'], tablefmt='pretty') + warnings.warn( + f"'{name}': bad type(s) for required arguments\n{req_table}", + UnknownObjectWarning, stacklevel=4 + ) return False #check remaining args against optional args opt_types = [arg['type'] for arg in args_opt] if not all([tc.check_type(t, a) for t, a in zip(opt_types, args[len(args_req):])]): - print("ObjectError:", name, ": bad type(s) for optional arguments") - print() - print (tabulate.tabulate([[x['name'], x['type']] for x in args_req], - ['req arg', 'type'], tablefmt='pretty')) - print() - print (tabulate.tabulate([[x['name'], x['type']] for x in args_opt], - ['opt arg', 'type'], tablefmt='pretty')) + req_table = tabulate.tabulate([[x['name'], x['type']] for x in args_req], + ['req arg', 'type'], tablefmt='pretty') + opt_table = tabulate.tabulate([[x['name'], x['type']] for x in args_opt], + ['opt arg', 'type'], tablefmt='pretty') + warnings.warn( + f"'{name}': bad type(s) for optional arguments\n{req_table}\n{opt_table}", + UnknownObjectWarning, stacklevel=4 + ) return False if self.arg_warning: diff --git a/maxpylang/tools/objfuncs/instantiation.py b/maxpylang/tools/objfuncs/instantiation.py index 40b90ff..c4d609f 100644 --- a/maxpylang/tools/objfuncs/instantiation.py +++ b/maxpylang/tools/objfuncs/instantiation.py @@ -5,16 +5,22 @@ """ -def build_from_specs(self, text, extra_attribs): +def build_from_specs(self, text, extra_attribs, abstraction=False, inlets=None, outlets=None): """ Helper function for initialization. Builds object from in-box text and extra attributes given. """ - #parse into name, args, text_attribs + #parse into name, args, text_attribs self._name, self._args, self._text_attribs = self.parse_text(text) + #if declared as abstraction, skip ref lookup and build directly + if abstraction: + self._ref_file = "abstraction" + self.create_declared_abstraction(text, inlets or 0, outlets or 0, extra_attribs) + return + #find reference file ref_file = self.get_ref(self._name) diff --git a/maxpylang/tools/objfuncs/reffile.py b/maxpylang/tools/objfuncs/reffile.py index eb24ab8..d8fc080 100644 --- a/maxpylang/tools/objfuncs/reffile.py +++ b/maxpylang/tools/objfuncs/reffile.py @@ -11,8 +11,11 @@ import os import json +import warnings from pathlib import Path +from maxpylang.exceptions import UnknownObjectWarning + def get_ref(self, name): @@ -42,7 +45,7 @@ def get_ref(self, name): if os.path.exists(name) or os.path.exists(name + '.maxpat'): ref_file = "abstraction" else: - print("ObjectError:", name, ": creation : object unknown") + warnings.warn(f"Unknown Max object: '{name}'", UnknownObjectWarning, stacklevel=4) ref_file = "not_found" return ref_file diff --git a/maxpylang/tools/objfuncs/specialobjs.py b/maxpylang/tools/objfuncs/specialobjs.py index 386cd13..208f6e2 100644 --- a/maxpylang/tools/objfuncs/specialobjs.py +++ b/maxpylang/tools/objfuncs/specialobjs.py @@ -252,6 +252,42 @@ def update_abstraction_from_file(self, text, extra_attribs, log_var=None): return +def create_declared_abstraction(self, text, numinlets, numoutlets, extra_attribs): + """ + Create an abstraction with user-declared I/O counts (no file needed). + + Used when abstraction=True is passed to MaxObject, allowing users to declare + abstractions that don't exist in the current working directory. + """ + + #fill in ext_file + self._ext_file = self.name + if ".maxpat" not in self.name: + self._ext_file += ".maxpat" + + #fill in dict + self._dict = copy.deepcopy(self.unknown_obj_dict) + self._dict['box']['numinlets'] = numinlets + self._dict['box']['numoutlets'] = numoutlets + self._dict['box']['outlettype'] = [""] * numoutlets + self._dict['box']['patching_rect'] = [0.0, 0.0] + self._dict['box']['text'] = self._name #start with just the name + + #fill in attribs + self._text_attribs, extra_attribs = self.get_all_valid_attribs( + self._text_attribs, extra_attribs, [{"name": "COMMON"}] + ) + self.add_extra_attribs(extra_attribs) + + #update text with args and attribs + self.update_text() + + #create ins/outs from dict + self.make_xlets_from_self_dict() + + return + + def get_abstraction_io(self): """ Returns the number of inlets and outlets in an abstraction file. diff --git a/maxpylang/tools/patchfuncs/placing.py b/maxpylang/tools/patchfuncs/placing.py index 1cf886c..a3216ad 100644 --- a/maxpylang/tools/patchfuncs/placing.py +++ b/maxpylang/tools/patchfuncs/placing.py @@ -385,14 +385,10 @@ def get_obj_from_spec(self, obj_spec): Helper function to get object from specification, either from string or from MaxObject. """ - # if given as string, make object + # if given as string, make object (warning fires from MaxObject constructor) if isinstance(obj_spec, str): obj = MaxObject(obj_spec) - # report if object not known - if obj.notknown(): - print(" PatchError: unknown obj : ", obj._dict["box"]["text"]) - # otherwise, make sure it's a MaxObject else: assert isinstance(