DreamScaler.control.js

/**
 * DreamScaler - Bitwig Studio Controller Script
 *
 * Tracks the current musical key (root note + scale type) via the
 * controller settings panel. On every change, shows a popup notification
 * and sends an OSC message to the DreamScaler LED bridge on localhost:9001.
 *
 * Scale Info section shows feelings, genre and usage of the selected scale.
 * Browse Scales section allows filtering by category, mood and genre, and
 * navigating through matching scales with Prev / Next buttons.
 *
 * LED Bridge: python/osc_bridge.py  (start separately)
 * OSC message: /dreamscaler/scale  <rootIndex: int 0-11>  <scaleName: string>
 */

loadAPI(25)
host.setShouldFailOnDeprecatedUse(true)
host.defineController('DreamScaler', 'DreamScaler', '1.0', 'd8e89ef4-f1c0-4c3a-a456-1a2b3c4d5e6f', 'DreamScaler')

const listRootNotes = ['C', 'C#', 'D', 'Eb', 'E', 'F', 'F#', 'G', 'G#', 'A', 'Bb', 'B']

// ── Scales and scale data — generated from scales.json (single source of truth) ──
// Edit scales.json, then run:  python generate_scales_js.py
host.load('scales_data.js')

// ── Browse / filter options ───────────────────────────────────────────────────
const CATEGORY_FILTER_OPTIONS = ['All', 'Common', 'Blues', 'Modal', 'Jazz', 'Exotic', 'Unusual']

const MOOD_FILTER_OPTIONS = [
  'All', 'Bright', 'Dark', 'Melancholic', 'Dreamy',
  'Bluesy', 'Groovy', 'Jazzy', 'Exotic', 'Oriental',
  'Dramatic', 'Tense', 'Meditative'
]

const GENRE_FILTER_OPTIONS = [
  'All', 'Rock / Blues', 'Jazz / Funk', 'Classical',
  'Folk / Country', 'Film / Ambient', 'World / Ethnic',
  'Metal', 'Pop', 'Experimental'
]

// Maps a Genre filter label to the genre_tags it matches
function genreOptionToTags(option) {
  var map = {
    'Rock / Blues': ['rock', 'blues'],
    'Jazz / Funk': ['jazz', 'funk'],
    'Classical': ['classical'],
    'Folk / Country': ['folk', 'country'],
    'Film / Ambient': ['film', 'ambient'],
    'World / Ethnic': ['world', 'flamenco'],
    'Metal': ['metal'],
    'Pop': ['pop'],
    'Experimental': ['experimental']
  }
  return map[option] || []
}

// ── Localisation ─────────────────────────────────────────────────────────────
var _CS_CATEGORY_MAP = {
  'Vše': 'All', 'Běžné': 'Common', 'Blues': 'Blues',
  'Modální': 'Modal', 'Jazz': 'Jazz', 'Exotické': 'Exotic', 'Neobvyklé': 'Unusual'
}
var _CS_GENRE_MAP = {
  'Vše': 'All', 'Rock / Blues': 'Rock / Blues', 'Jazz / Funk': 'Jazz / Funk',
  'Klasická': 'Classical', 'Folk / Country': 'Folk / Country',
  'Film / Ambient': 'Film / Ambient', 'Světová / Etnická': 'World / Ethnic',
  'Metal': 'Metal', 'Pop': 'Pop', 'Experimentální': 'Experimental'
}

var _CS_MOOD_MAP = {
  'Vše': 'All', 'Světlý': 'Bright', 'Temný': 'Dark',
  'Melancholický': 'Melancholic', 'Snivý': 'Dreamy',
  'Bluesový': 'Bluesy', 'Groovy': 'Groovy', 'Jazzový': 'Jazzy',
  'Exotický': 'Exotic', 'Orientální': 'Oriental', 'Dramatický': 'Dramatic',
  'Napjatý': 'Tense', 'Meditativní': 'Meditative'
}

function makeLabels(lang) {
  if (lang === 'Čeština') {
    return {
      sectionScale: 'Stupnice',
      rootNote: 'Základní nota',
      scaleType: 'Typ stupnice',
      scaleDisplay: 'Zobrazení stupnice',
      displayOn: 'Zap',
      displayOff: 'Vyp',
      sectionInfo: 'Info o stupnici',
      feelings: 'Pocity',
      genre: 'Žánr',
      usage: 'Použití',
      scalesRef: 'Přehled stupnic',
      scalesUrl:  'https://github.com/tomasmark79/DreamScaler/blob/main/scales_cs.md',
      scalesBtnLabel: 'Otevřít přehled stupnic ↗',
      sectionBrowse: 'Procházet stupnice',
      category: 'Kategorie',
      mood: 'Nálada',
      genreFilter: 'Žánr filtru',
      prevScale: 'Předchozí stupnice',
      nextScale: 'Další stupnice',
      prevBtn: 'Předchozí',
      nextBtn: 'Další',
      filteredScales: 'Odpovídající stupnice',
      sectionLED: 'LED',
      ledIntensity: 'Intenzita LED',
      notePlaying: 'Intenzita LED hraných not',
      categoryOptions: ['Vše', 'Běžné', 'Blues', 'Modální', 'Jazz', 'Exotické', 'Neobvyklé'],
      moodOptions: ['Vše', 'Světlý', 'Temný', 'Melancholický', 'Snivý',
        'Bluesový', 'Groovy', 'Jazzový', 'Exotický', 'Orientální',
        'Dramatický', 'Napjatý', 'Meditativní'],
      genreOptions: ['Vše', 'Rock / Blues', 'Jazz / Funk', 'Klasická',
        'Folk / Country', 'Film / Ambient', 'Světová / Etnická',
        'Metal', 'Pop', 'Experimentální'],
      mapCategory: function (v) { return _CS_CATEGORY_MAP[v] || v },
      mapMood: function (v) { return _CS_MOOD_MAP[v] || v },
      mapGenre: function (v) { return _CS_GENRE_MAP[v] || v }
    }
  }
  return {
    sectionScale: 'Scale',
    rootNote: 'Root Note',
    scaleType: 'Scale Type',
    scaleDisplay: 'Scale Display',
    displayOn: 'On',
    displayOff: 'Off',
    sectionInfo: 'Scale Info',
    feelings: 'Feelings',
    genre: 'Genre',
    usage: 'Usage',
    scalesRef: 'Scale Reference',
    scalesUrl:  'https://github.com/tomasmark79/DreamScaler/blob/main/scales_en.md',
    scalesBtnLabel: 'Open Scale Reference ↗',
    sectionBrowse: 'Browse Scales',
    category: 'Category',
    mood: 'Mood',
    genreFilter: 'Genre',
    prevScale: 'Previous Scale',
    nextScale: 'Next Scale',
    prevBtn: 'Prev',
    nextBtn: 'Next',
    filteredScales: 'Matching Scales',
    sectionLED: 'LEDs',
    ledIntensity: 'LED Intensity',
    notePlaying: 'Note Playing LED Intensity',
    categoryOptions: CATEGORY_FILTER_OPTIONS,
    moodOptions: MOOD_FILTER_OPTIONS,
    genreOptions: GENRE_FILTER_OPTIONS,
    mapCategory: function (v) { return v },
    mapMood: function (v) { return v },
    mapGenre: function (v) { return v }
  }
}

// ── Active language — set in init() ──────────────────────────────────────────
var activeScales = SCALES_EN
var activeScaleData = SCALE_DATA_EN

// ── Filter state ──────────────────────────────────────────────────────────────
var filterCategory = 'All'
var filterMood = 'All'
var filterGenre = 'All'

// Reference to the scaleType setting (set in init, used by navigateScale)
var scaleTypeRef = null

// ── Filter helpers ────────────────────────────────────────────────────────────
function getFilteredScales() {
  var result = []
  for (var i = 0; i < SCALES_EN.length; i++) {
    var name = SCALES_EN[i]
    var data = SCALE_DATA_EN[name]
    if (!data) continue

    if (filterCategory !== 'All' && data.category !== filterCategory) continue

    if (filterMood !== 'All') {
      var moodTag = filterMood.toLowerCase()
      if (data.mood_tags.indexOf(moodTag) === -1) continue
    }

    if (filterGenre !== 'All') {
      var tags = genreOptionToTags(filterGenre)
      var found = false
      for (var t = 0; t < tags.length; t++) {
        if (data.genre_tags.indexOf(tags[t]) !== -1) { found = true; break }
      }
      if (!found) continue
    }

    result.push(name)
  }
  return result
}

function navigateScale(direction) {
  if (!scaleTypeRef) return
  var filtered = getFilteredScales()
  if (filtered.length === 0) {
    println('DreamScaler: No scales match the current filter.')
    return
  }

  // Resolve current display name to English
  var currentDisplay = scaleTypeRef.get()
  var currentENIdx = activeScales.indexOf(currentDisplay)
  var currentEN = (currentENIdx >= 0) ? SCALES_EN[currentENIdx] : currentDisplay

  var filteredIdx = filtered.indexOf(currentEN)
  var nextIdx
  if (filteredIdx === -1) {
    nextIdx = (direction === 1) ? 0 : filtered.length - 1
  } else {
    nextIdx = (filteredIdx + direction + filtered.length) % filtered.length
  }

  var nextEN = filtered[nextIdx]

  // Map to active display language
  var nextDisplay = nextEN
  if (activeScales !== SCALES_EN) {
    var enIdx = SCALES_EN.indexOf(nextEN)
    if (enIdx >= 0) nextDisplay = activeScales[enIdx]
  }

  scaleTypeRef.set(nextDisplay)
  println('DreamScaler: [' + (nextIdx + 1) + '/' + filtered.length + '] ' + nextEN)
}

// ── Playing-notes state ───────────────────────────────────────────────────────
var _prevNotes = {}  // { midiPitch: velocity }

// ── OSC bridge ────────────────────────────────────────────────────────────────
const OSC_HOST = '127.0.0.1'
const OSC_PORT = 9001

var oscOut = null

// ── init ──────────────────────────────────────────────────────────────────────
function init() {
  println('-- DreamScaler Go! --')
  println('DreamScaler: Loaded ' + SCALES_EN.length + ' scales')
  const prefs = host.getPreferences()
  const langSetting = prefs.getEnumSetting('Language / Jazyk', 'DreamScaler', ['English', 'Čeština'], 'English')
  const lang = langSetting.get()
  if (lang === 'Čeština') {
    activeScales = SCALES_CS
    activeScaleData = SCALE_DATA_CS
  } else {
    activeScales = SCALES_EN
    activeScaleData = SCALE_DATA_EN
  }
  println('DreamScaler: Language = ' + lang)
  const L = makeLabels(lang)
  langSetting.addValueObserver(function (newLang) {
    println('DreamScaler: Language changed to "' + newLang + '" – please reload the controller to apply.')
  })

  // OSC output connection to LED bridge
  try {
    const oscModule = host.getOscModule()
    oscOut = oscModule.connectToUdpServer(OSC_HOST, OSC_PORT, oscModule.createAddressSpace())
    println('DreamScaler: OSC connected to ' + OSC_HOST + ':' + OSC_PORT)
  } catch (e) {
    println('DreamScaler: OSC init failed – ' + e)
  }

  const documentState = host.getDocumentState()

  // ── Scale selection (registered first so section appears at top) ─────────
  const rootNote = documentState.getEnumSetting(L.rootNote, L.sectionScale, listRootNotes, 'C')
  const scaleType = documentState.getEnumSetting(L.scaleType, L.sectionScale, activeScales, activeScales[0])
  scaleTypeRef = scaleType
  const scaleDisplay = documentState.getEnumSetting(L.scaleDisplay, L.sectionScale, [L.displayOn, L.displayOff], L.displayOn)

  // ── Scale Info (auto-updated display fields) ──────────────────────────────
  const displayFeelings = documentState.getStringSetting(L.feelings, L.sectionInfo, 80, '-')
  const displayGenre = documentState.getStringSetting(L.genre, L.sectionInfo, 80, '-')
  const displayUsage = documentState.getStringSetting(L.usage, L.sectionInfo, 100, '-')
  const scalesRefBtn = documentState.getSignalSetting(L.scalesRef, L.sectionInfo, L.scalesBtnLabel)
  scalesRefBtn.addSignalObserver(function () {
    println('DreamScaler: open_scales_ref clicked, oscOut=' + (oscOut !== null ? 'ok' : 'null'))
    if (oscOut !== null) {
      oscOut.sendMessage('/dreamscaler/open_scales_ref', L.scalesUrl)
      println('DreamScaler: sent open_scales_ref -> ' + L.scalesUrl)
    } else {
      println('DreamScaler: OSC not connected, cannot open URL')
    }
  })

  // ── Browse Scales — filters ───────────────────────────────────────────────
  const categoryFilter = documentState.getEnumSetting(L.category, L.sectionBrowse, L.categoryOptions, L.categoryOptions[0])
  const moodFilter = documentState.getEnumSetting(L.mood, L.sectionBrowse, L.moodOptions, L.moodOptions[0])
  const genreFilter = documentState.getEnumSetting(L.genreFilter, L.sectionBrowse, L.genreOptions, L.genreOptions[0])

  // ── Browse Scales — matching scales display (read-only text) ──────────────
  const displayFilteredScales = documentState.getStringSetting(L.filteredScales, L.sectionBrowse, 300, '')

  function updateFilterDisplay() {
    var filtered = getFilteredScales()
    var n = filtered.length
    if (n === 0) {
      displayFilteredScales.set('–')
      return
    }
    var names = []
    for (var i = 0; i < filtered.length; i++) {
      var enName = filtered[i]
      if (activeScales !== SCALES_EN) {
        var enIdx = SCALES_EN.indexOf(enName)
        names.push(enIdx >= 0 ? activeScales[enIdx] : enName)
      } else {
        names.push(enName)
      }
    }
    var full = n + ': ' + names.join(', ')
    if (full.length > 298) { full = full.substring(0, 295) + '...' }
    displayFilteredScales.set(full)
  }

  // ── Browse Scales — navigation buttons ───────────────────────────────────
  const prevSignal = documentState.getSignalSetting(L.prevScale, L.sectionBrowse, L.prevBtn)
  const nextSignal = documentState.getSignalSetting(L.nextScale, L.sectionBrowse, L.nextBtn)

  // ── LED brightness settings ───────────────────────────────────────────────
  const ledIntensity = documentState.getNumberSetting(L.ledIntensity, L.sectionLED, 1, 30, 1, '', 1)
  const notePlaying = documentState.getNumberSetting(L.notePlaying, L.sectionLED, 1, 50, 1, '', 10)

  ledIntensity.addRawValueObserver(function (value) {
    if (oscOut !== null) {
      oscOut.sendMessage('/dreamscaler/led_intensity', Math.round(value))
    }
  })

  notePlaying.addRawValueObserver(function (value) {
    if (oscOut !== null) {
      oscOut.sendMessage('/dreamscaler/note_playing_intensity', Math.round(value))
    }
  })

  function updateInfoDisplay(displayName, root) {
    var data = activeScaleData[displayName]
    if (!data) {
      var idx = activeScales.indexOf(displayName)
      if (idx >= 0) data = SCALE_DATA_EN[SCALES_EN[idx]]
    }
    if (data) {
      var feelings = data.feelings
      if (root && data.feelings_by_root && data.feelings_by_root[root]) {
        feelings = data.feelings_by_root[root]
      }
      displayFeelings.set(feelings.charAt(0).toLowerCase() + feelings.slice(1))
      displayGenre.set(data.genre)
      displayUsage.set(data.usage || '')
    }
  }

  rootNote.addValueObserver(function (root) {
    updateInfoDisplay(scaleType.get(), root)
    notifyScale(root, scaleType.get())
  })

  scaleType.addValueObserver(function (type) {
    updateInfoDisplay(type, rootNote.get())
    notifyScale(rootNote.get(), type)
  })

  scaleDisplay.addValueObserver(function (val) {
    var enabled = (val === L.displayOn) ? 1 : 0
    println('DreamScaler: Scale Display = ' + val)
    if (oscOut !== null) {
      oscOut.sendMessage('/dreamscaler/scale_display', enabled)
    }
  })

  categoryFilter.addValueObserver(function (val) {
    filterCategory = L.mapCategory(val)
    println('DreamScaler: Filter → Category=' + filterCategory + '  matches=' + getFilteredScales().length)
    updateFilterDisplay()
  })
  moodFilter.addValueObserver(function (val) {
    filterMood = L.mapMood(val)
    println('DreamScaler: Filter → Mood=' + filterMood + '  matches=' + getFilteredScales().length)
    updateFilterDisplay()
  })
  genreFilter.addValueObserver(function (val) {
    filterGenre = L.mapGenre(val)
    println('DreamScaler: Filter → Genre=' + filterGenre + '  matches=' + getFilteredScales().length)
    updateFilterDisplay()
  })

  prevSignal.addSignalObserver(function () { navigateScale(-1) })
  nextSignal.addSignalObserver(function () { navigateScale(1) })

  // ── Playing notes observer ────────────────────────────────────────────────
  var cursorTrack = host.createCursorTrack(0, 0)
  var playingNotes = cursorTrack.playingNotes()
  playingNotes.markInterested()
  playingNotes.addValueObserver(function (notes) {
    updateNotes(notes)
  })
}

/**
 * Diffs the new playing-notes snapshot against the previous one and sends
 * individual note_on / note_off OSC messages to the LED bridge.
 */
function updateNotes(notes) {
  if (oscOut === null) return

  var currNotes = {}
  for (var i = 0; i < notes.length; i++) {
    var p = notes[i].pitch()
    var v = notes[i].velocity()
    currNotes[p] = v
  }

  for (var pitch in currNotes) {
    oscOut.sendMessage('/dreamscaler/note_on', parseInt(pitch, 10), currNotes[pitch])
  }

  for (var pitch in _prevNotes) {
    if (!(pitch in currNotes)) {
      oscOut.sendMessage('/dreamscaler/note_off', parseInt(pitch, 10))
    }
  }

  _prevNotes = currNotes
}

function flush() { }

function exit() {
  println('-- DreamScaler Bye! --')
}

function notifyScale(root, type) {
  // Popup supports ASCII only — always use English names and feelings
  const scaleIndex = activeScales.indexOf(type)
  const enName = (scaleIndex >= 0) ? SCALES_EN[scaleIndex] : type
  const enInfo = SCALE_DATA_EN[enName]
  var feelings = enInfo ? enInfo.feelings : ''
  if (enInfo && enInfo.feelings_by_root && enInfo.feelings_by_root[root]) {
    feelings = enInfo.feelings_by_root[root]
  }
  println('DreamScaler: ' + root + '  ' + enName + (feelings ? ' - ' + feelings : ''))

  if (oscOut !== null) {
    const rootIndex = listRootNotes.indexOf(root)
    oscOut.sendMessage('/dreamscaler/scale', rootIndex, enName)
  }
}