[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!