[changelog:
2.0 Final
- fixed Launchpad controller (thanks danoise)
2.0 Beta 2
- Updated/Tested on Renoise 2.8 beta 8
- Handle closing of song while Cells! is running
- Fixed preferences not initialised before rendering patterns bug
- Updated the controller API and associated documentation (also added to this post)
- Updated Ohm64 support for the new controller API
- Updated Launchpad support for the new controller API (to be tested)
2.0 Beta 1.1
- Quick fix release which fixes a bug making note patterns on Renoise 2.8 beta 7
2.0 Beta 1
- Inital public release of Cells! 2.0
Cells! 2.0 is a complete rewrite of Cells! 0.9. This has been based upon further code experimentation and user feedback. However, due to the improved approach and cleaner code, it has been possible to add many more features.
Screenshot
Demo Video
Thanks to Void Pointer for kindly supplying the samples used in the demo video
Major New Features
Realtime ‘Granular’ Timestretch
Cells! 2.0 allows realtime timestretch in a ‘granular style’. This allows full independant control of both tempo and pitch while still keeping playback syncronised to the beat. Granular timestretch applies to samples which have both a beat sync value and autoseek enabled but beat sync is disabled.
Realtime ‘Slice Based’ Timestretch
Similar to the ‘granular’ timestretch, Cells! 2.0 adds support for sliced loops with independant tempo and pitch control. Each slice will be played back at the correct time to maintain the overall tempo of the entire loop. Slice-stretch applies to samples which are sliced. The length of the cell is assigned through the beat-sync value.
Pattern ‘Riff’ Storage and Playback
Cells! 2.0 allows you to quickly save individual pattern tracks as riffs for use live in Cells!. The riffs are stored in compressed format within the instrument itself, so you can quickly and easily save all samples, sample mappings and riffs self-contained within a single XRNI file. Note that any Renoise instrument is be supported. This means you should be able to send note riffs to external instruments or VSTi’s.
Live Jamming Mode
For specific types of samples, Cells! 2.0 allows real-time ‘live jamming’ playback mode. Play your samples directly with either the mouse or a physical controller for improvising over your mixes to add that extra sparkle. Individual slices from sliced loops and plain one-shot samples can be played in ‘live jamming’ mode.
Bidirectional Controller Support
Cells! 2.0 now has it’s own native controller framework. This allows full bidirectional support for supported hardware controllers. Livid Instruments Ohm64 and Novation Launchpad (beta) are available with the inital release. If you would like further support for any additional controllers, feel free to either send them to me for development or contact me directly to work together and implement support.
[edit: controller API - 'doc/controler-api.txt]
[details=“Click to view contents”] Introduction / API
To implement controller support for a new device all that is required is to
create a new class definition and ‘require’ that file from main.lua in the
correct section.
All controller classes must implement the following functions:
Functions:
__init(midi_in, midi_out)
API Functions:
Reset()
Tick()
SetPlayState(state)
SetCellState(channel, cell, state)
SetStopState(channel, state)
SetMute(channel, state)
SetCue(channel, state)
SetJam(channel, state)
SetSelected(channel)
SetRouting(channel, routing)
SetBasskill(channel, state)
SetFilter(channel, position)
SetTranspose(channel, position)
SetPanning(channel, position)
SetVolume(channel, position)
SetCrossfader(position)
SetCrossfaderCut(ab, state)
SetFXRate(rate)
SetFXAmount(amount)
SetFXType(type_id)
SetFXState(state)
SetMasterVolume(value)
SetCueVolume(value)
Cells! Core Functions
To handle events received from the controller just call the same functions
within Cells! as the UI would call. A useful list of these follows:
Functions updated since beta 1.1 are marked with an *
cc[i] - Cells! channel ‘i’ class instances
cc[]:SelectTrack()
Selects the specified track as the current track
- cc[]:IsSelectedTrack()
Returns if the current track is the same as the specified channel
Returns true or false
cc[]:CueCell(1…#cells)
Cues the specified cell (if available)
If the cell doesn’t exist, the request will silently drop
cc[]:CueStop()
Cues the stop cell for the specified channel
- cc[]:GetCue()
Returns the cue state for the specified channel
Returns true if enabled, false if disabled
cc[]:ToggleCue()
Toggles the cue state for the specified channel
- cc[]:GetMute()
Returns the mute state for the specified channel
Returns true is muted, false if unmuted
cc[]:ToggleMute()
Toggles the mute state for the specified channel
- cc[]:GetBassKill()
Returns the bass kill state for the specified channel
Returns true is enabled, false if disabled
cc[]:ToggleBassKill()
Toggles the bass kill state for the specified channel
-
cc[]:GetLiveJamMode()
Returns the current state of live jam mode for the specified channel
Return true if enabled, false if disabled -
cc[]:CanLiveJamMode()
Returns if live jam mode can be enabled for the specified channel
Returns true if possible, otherwise false
cc[]:ToggleLiveJamMode()
Toggles the live jam mode for the specified channel if available.
Nothing bad will occur if this is called and it is not available.
- cc[]:GetPanning()
Returns a channel panning value
Returns 0 to 1 (0 = hard left, 1 = hard right)
cc[]:MovePanning(0…1)
Sets a panning value on a channel
0 = hard left, 1 = hard right
- cc[]:GetVolume()
Returns the volume for the specified channel
Returns from 0 to 1 (0 = -200dB (off), 1 = +3dB)
cc[]:MoveVolume(0…1)
Sets the volume for the specified channel
0 = -200dB (off), 1 = +3dB
-
cc[]:GetRouting()
Returns the channel routing setting
Returns enum:
CELLS_ROUTING_A
CELLS_ROUTING_MASTER
CELLS_ROUTING_B -
cc[]:MoveRouting(enum)
Sets the channel routing for the specified channel
CELLS_ROUTING_A
CELLS_ROUTING_MASTER
CELLS_ROUTING_B -
cc[]:GetFilter()
Returns a channel low pass filter value
Returns 0 to 1 (0 = 0hz, 1 = 22.05khz (off))
cc[]:MoveFilter(0…1)
Sets the low pass filter value on a channel
0 = 0hz, 1 = 22.05khz (off)
- cc[]:GetTranspose()
Returns the transpose value for the loaded instrument in the specified channel
Return 0 to 1 (= -12 to +12 semitones)
cc[]:MoveTranspose(0…1)
Sets a transpose value for an instrument loaded into the specified channel
0 = -12 semitones, 1 = +12 semitones
- cc[]:GetInstrument()
Returns the selected instrument index for the specified channel
0 = none (first instrument) to 1 (last instrument available)
cc[]:MoveInstrument(0…1)
Sets the selected instrument for the specified channel
0 = none (first instrument) to 1 (last instrument available)
cm - Cells! Mixer FX Unit class instance
- cm:GetCrossfader()
Returns the crossfader position
Returns 0 = fully A group (left) , 1 = fully B group (right)
cm:MoveCrossfader(0…1)
Moves the crossfader to the specified position
0 = fully A group (left) , 1 = fully B group (right)
- cm:GetCutState(group)
Returns the cut state for the specified group
group: 0 = A, 1 = B
cm:SetCutState(group, state)
Sets the cut state for the specified group
group: 0 = A, 1 = B
state: cut state (boolean)
- cm:GetMasterVolume()
Returns the master volume level
Returns 0 (-200dB (off)) to 1 (+3dB)
cm:MoveMasterVolume(0…1)
Sets the master volume level
0 (-200dB (off)) to 1 (+3dB)
- cm:GetCueVolume()
Returns the cue volume level
Returns 0 (-200dB (off)) to 1 (+3dB)
cm:MoveCueVolume(0…1)
Sets the cue volume level
0 (-200dB (off)) to 1 (+3dB)
- cm:GetEffectRate()
Returns the current effect rate
Returns 0 = slowest rate, 1 = fastest, 5 discrete steps
cm:MoveEffectRate(0…1)
Sets the effect rate
0 = slowest rate, 1 = fastest, 5 discrete steps
- cm:GetEffectAmount()
Returns the current effect amount
Returns 0 = least (off), 1 = most
cm:MoveEffectAmount(0…1)
Sets the effect amount
0 = least (off), 1 = most
- cm:GetEffectState()
Returns wether effects are enabled
Return true if applied, false if disabled
cm:ToggleEffectState()
Toggles whether effects are applied
-
cm:GetEffectTarget()
Returns the current effect target
Returns enum:
CELLS_ROUTING_A
CELLS_ROUTING_MASTER
CELLS_ROUTING_B -
cm:MoveEffectTarget(enum)
Sets the effect target
CELLS_ROUTING_A
CELLS_ROUTING_MASTER
CELLS_ROUTING_B -
cm:GetEffectType()
Returns the effect type
Returns enum:
CELLS_FX_FILTER
CELLS_FX_REPEAT
CELLS_FX_DELAY
CELLS_FX_FLANGER -
cm:MoveEffectType(enum)
Sets the effect type:
CELLS_FX_FILTER
CELLS_FX_REPEAT
CELLS_FX_DELAY
CELLS_FX_FLANGER
ct - Cells! Transport class instance
ct:TogglePlayState()
Toggles transport playback start/stop
ct:SetBpm(bpm, true)
Sets the transport BPM from 32 to 999 BPM.
Ensure that the second parameter is passed as true
Is master node, changes will propegate to slave nodes
No effect on slave nodes
ct:NudgeBPM(delta, apply)
Nudge the bpm by delta amount, apply is a boolean flag
delta is usually -1 or +1
apply is true when pressed, false when released (non-latching)
-
ct:GetQuantizeValue()
Returns the current quantize value
Returns enum:
CELLS_QUANTIZE_HALFBEAT
CELLS_QUANTIZE_1BEAT
CELLS_QUANTIZE_2BEATS
CELLS_QUANTIZE_4BEATS -
ct:MoveQuantizeValue(enum)
Set the cell trigger quantize value:
CELLS_QUANTIZE_HALFBEAT
CELLS_QUANTIZE_1BEAT
CELLS_QUANTIZE_2BEATS
CELLS_QUANTIZE_4BEATS
[/details]
MultiFX
Cells! 2.0 incorporates a simple ‘DJ style’ effects processor into the main UI. Effects supported are a low-pass filter, beat repeat, delay and phaser. All effects are controlled through simple common amount and rate controls. All time based effects are syncronised to the beat.
Sample Preparation Tools
Cells! 2.0 incorporates simple methods to quickly create and prepare samples for use. Both the sample editor and the sample list box contain a ‘Cells! menu’ from which the sample can easily assigned to a specific playback mode and length. A ‘sample report’ feature is also available which allows you to quickly identify how the selected sample will play within Cells! 2.0.
Additionally, Cells! 2.0 allows quick rendering of either entire patterns or specific tracks within patterns from your existing songs. Only the instrument of the first note within the pattern track will be saved. It will automatically assign the correct beat sync values even if the original song is not written at 4 LPB. All rendered samples will be contained within an ‘Unsorted Cells! Renders’ instrument within the song to easily allow saving of all samples to disk. This menu is present in the pattern editor context menu.
Multiplayer Networking (beta)
Cells! 2.0 has built in support for up to four machines to link together over a lan (via OSC) and keep in sync. Make huge mixes across multiple machines or get some friends around and all play together. Setup network connections on the master and ensure Renoise OSC servers are running on all machines.
Minor improvements
- Variable channels from 4 to 16.
- Variable cells per channel from 4 to 16.
- Variable cell height and width (for touch screen usage).
- Automatic sample selection option (for waveform view in the sample editor).
- Safe cueing option to automatically mute cue output if set to the same as the main audio output.
- Single output mode (splits the audio so master output on one channel and cue output on the other).
- Slightly tweaked user interface to cater for the additional features.
- Better audio routing (A/B crossfader or crossfader bypass (M))
- Various other optimisations (too many to list)
Downloads
The tool can be downloaded from its tools page here.
Download the updated 2.0 beta manual here.
Acknowledgements
There are many people I wish to thank who have assisted or supported Cells! during it’s development. In no particular order: taktik, dblue, danoise, void pointer, miron_man, Peter Kirn, Livid Instruments and everyone on #renoise. Sorry if I have missed anyone.
Enjoy!
