Feature/new clock

hydra/app/extensions/extra/clock.js

@@ -0,0 +1,79 @@
+const {
+  range,
+  bpmToMs,
+  wrapAt,
+  foldAt,
+  wrapBetween,
+  foldBetween,
+  wrapSeq,
+  foldSeq
+} = require('./utils')
+
+// class Clock {
+//   constructor({
+//     bpm, // if bpm is specified, then interval will not be used
+//     interval = 1000, // tick interval in milliseconds
+//     startAt = 0, 
+//     countBy = 1,
+//     countWith = null,
+//     onTick = [() => {}]
+//   } = {}) { 
+//     this.dt = 0
+//     this.currentVal = startAt
+//     this.countBy = countBy
+//     this.countWith = countWith 
+//       ? countWith 
+//       : last => last + countBy
+//     this.interval = bpm ? bpmToMs(bpm) : interval
+//     this.onTick = onTick
+
+//     // Clock methods as function properties: shaders may crash if passed in a method instead of a function, so this is why.
+//     this.val = () => this.currentVal
+//     this.wrapAt = modulo => wrapAt(modulo, this.val())
+//     this.warpBetween = (bottom, top) => wrapBetween(bottom, top, this.val())
+//     this.warpSeq = (numberArray) => wrapSeq(numberArray, this.val())
+//     this.foldAt = modulo => foldAt(modulo, this.val())
+//     this.foldBetween = (bottom, top) => foldBetween(bottom, top, this.val())
+//     this.foldSeq = (numberArray) => foldSeq(numberArray, this.val())
+//   }
+
+//   update(dt) {
+//     this.dt = dt
+//   }
+// }
+
+// module.exports = Clock
+
+
+// const loop = require('raf-loop')
+
+// loop(dt)
+
+const opable = (fn, initialVal, ops = []) => ({
+
+})
+
+
+function makeClock() {
+  let dt_ = 0
+  const getVal = interval => dt_/interval
+  const clock = (interval) => ({
+    val: () => getVal(interval),
+    wrapAt: modulo => wrapAt(modulo, getVal(interval)),
+    wrapBetween: (bottom, top) =>  wrapBetween(bottom, top, getVal(interval)),
+    wrapSeq: (numberArray) =>  wrapSeq(numberArray, getVal(interval)),
+    foldAt: modulo =>  foldAt(modulo, getVal(interval)),
+    foldBetween: (bottom, top) =>  foldBetween(bottom, top, getVal(interval)),
+    foldSeq: (numberArray) =>  foldSeq(numberArray, getVal(interval)),
+  })
+  clock.update = dt => {dt_ = dt}
+  return clock
+}
+
+module.exports = makeClock
+// const osc = console.log
+// const clock = makeClock()
+// range(0, 20).forEach(dt => {
+//   clock.update(dt)
+//   osc(clock(2).wrapAt(5))
+// })

hydra/app/extensions/extra/utils-tests.js

@@ -0,0 +1,4 @@
+console.log(range(0, 20).map(x => wrapBetween(5, 10, x)))
+console.log(range(0, 20).map(x => foldBetween(5, 10, x)))
+console.log(range(0, 20).map(x => wrapSeq([4, 5 ,2, 3], x)))
+console.log(range(0, 20).map(x => foldSeq([4, 5 ,2, 3], x)))

hydra/app/extensions/extra/utils.js

@@ -0,0 +1,59 @@
+// beats per minute to milliseconds
+function bpmToMs(bpm) {
+  return 60/bpm*1000 
+}
+
+function range(from, to) {
+  const res = []
+  for(let i = from; i<to; i++) {
+    res.push(i)
+  }
+  return res
+}
+
+// inspired by sclang's warpAt
+function wrapAt(modulo, index) {
+  return index%(modulo+1)
+}
+
+function wrapBetween(bottom, top, index) {
+  return wrapAt(top - bottom, index) + bottom
+}
+
+// inspired by sclang's foldAt
+function foldAt(modulo, index) { 
+  let res;
+  res = index % modulo
+  let isUp = parseInt(index / modulo) % 2 === 0
+  if (isUp) {
+    return res
+  } else {
+    return modulo - res
+  }
+}
+
+function foldBetween(bottom, top, index) {
+  return foldAt(top - bottom, index) + bottom
+}
+
+function wrapSeq(numberArray, index) {
+  const length = numberArray.length
+  return numberArray[index%(length)]
+}
+
+function foldSeq(numberArray, index) {
+  const length = numberArray.length
+  const index_ = foldAt(length - 1, index)
+  return numberArray[index_]
+}
+
+module.exports = {
+  bpmToMs,
+  range,
+  wrapAt,
+  foldAt,
+  wrapBetween,
+  foldBetween,
+  wrapSeq,
+  foldSeq
+}

hydra/app/startup.js

@@ -4,6 +4,7 @@ const loop = require('raf-loop')
 // Core
 const HydraSynth = require('hydra-synth')
 const Editor = require('./core/hydra-editor')
+const makeClock = require('./extensions/extra/clock')
 
 // Extensions
 window.Clock = require('./extensions/clock.js')
@@ -12,13 +13,14 @@ function init () {
   // init hydra
   hydra = new HydraSynth({ canvas: initCanvas(), autoLoop: false })
   editor = new Editor({ loadFromStorage: true})
-
+  window.clock = makeClock()
   // special functions for running hydra in electron
   utils.initElectron(hydra)
 
 // loop function run on each frame
   var engine = loop(function(dt) {
     hydra.tick(dt)
+    window.clock.update(dt)
     if(window.update) {
       try { window.update(dt) } catch (e) {editor.log(e.message, "log-error")}
     }