Update

boilerbloat/src/main/backend.ts

@@ -4,10 +4,13 @@ import { blackout } from '../patterns/blackout';
 import { Pattern, PatternOutput, Time } from '../patterns/proto';
 import { TestPattern } from '../patterns/test';
 import rust, { BeatTrackerHandle, MovingHeadState, OutputHandle } from 'rust_native_module';
+import { ChaserPattern } from '../patterns/chaser';
 
 type AppState = {
   patterns: { [key: string]: PatternOutput },
   selectedPattern: string | null,
+
+  beatProgress: number | null,
 };
 
 class Backend {
@@ -16,8 +19,10 @@ class Backend {
   dmxOutput: OutputHandle;
 
   patterns: Map<string, Pattern>;
-  patternOutputs: Map<string, PatternOutput>;
+  // patternOutputs: Map<string, PatternOutput>;
-  selectedPattern: string;
+  // selectedPattern: string;
+
+  state: AppState;
 
   constructor() {
 
@@ -50,61 +55,60 @@ class Backend {
 
     this.patterns = new Map();
     this.patterns.set("test", new TestPattern());
+    this.patterns.set("chaser", new ChaserPattern());
 
-    this.patternOutputs = new Map();
+    this.state = {
-    this.selectedPattern = "test";
+      patterns: {},
+      selectedPattern: null,
+      beatProgress: null,
+    }
 
     let time: Time = {
       absolute: 0,
-      beat_relative: null
+      beatRelative: this.state.beatProgress,
     }
 
     for (let [patternId, pattern] of this.patterns.entries()) {
-      this.patternOutputs.set(patternId, pattern.render(time));
+      let patternOutput = pattern.render(time);
+      this.state.patterns[patternId] = patternOutput;
     }
 
+    ipcMain.handle('poll', async (_) => {
+      return this.getState();
+    });
+
   }
 
   getState(): AppState {
-    let result: AppState = {
+    return this.state;
-      patterns: {},
-      selectedPattern: this.selectedPattern,
-    }
-
-    for (let [patternId, patternOutput] of this.patternOutputs) {
-      result.patterns[patternId] = patternOutput;
-    }
-
-    return result;
   }
 
   update() {
+
+    let beatProgress = this.beatTracker.getProgress();
+
+    if (beatProgress.type == 'some') {
+      this.state.beatProgress = beatProgress.value;
+    } else {
+      this.state.beatProgress = null;
+    }
+
     let date = new Date();
     let time: Time = {
       absolute: date.getTime() / 1000,
-      beat_relative: null,
+      beatRelative: this.state.beatProgress,
     }
 
-    // render all patterns
+    // render all patterns and write selected pattern to DMX
-
-    if (!this.patterns) {
-      console.log("big oof?");
-      throw new Error("???");
-    }
-
-    for (let [patternId, pattern] of this.patterns.entries()) {
-      this.patternOutputs.set(patternId, pattern.render(time));
-    }
-
-    // write selected pattern
 
     let output: Array<MovingHeadState> = blackout;
 
-    if (this.selectedPattern !== null) {
+    for (let [patternId, pattern] of this.patterns.entries()) {
-      let selectedPatternOutput = this.patternOutputs.get(this.selectedPattern)
+      let patternOutput = pattern.render(time);
+      this.state.patterns[patternId] = patternOutput;
 
-      if (selectedPatternOutput) {
+      if (patternId === this.state.selectedPattern && patternOutput) {
-        output = selectedPatternOutput;
+        output = patternOutput;
       }
     }
 

boilerbloat/src/main/main.ts

@@ -11,7 +11,7 @@
 import 'core-js/stable';
 import 'regenerator-runtime/runtime';
 import path from 'path';
-import { app, BrowserWindow, ipcMain, shell } from 'electron';
+import { app, BrowserWindow, shell } from 'electron';
 import { resolveHtmlPath } from './util';
 import Backend from './backend';
 
@@ -19,10 +19,6 @@ let backend = new Backend();
 
 let mainLoop = setInterval(() => { backend.update(); }, 20);
 
-ipcMain.handle('poll', () => {
-  return backend.getState();
-});
-
 let mainWindow: BrowserWindow | null = null;
 
 const createWindow = async () => {

boilerbloat/src/patterns/chaser.ts

@@ -4,11 +4,11 @@ import { Pattern, PatternOutput, Time } from './proto';
 export class ChaserPattern implements Pattern {
   render(time: Time): PatternOutput {
 
-    if (time.beat_relative === null) {
+    if (time.beatRelative === null) {
       return null;
     }
 
-    let head_number = Math.ceil(time.beat_relative) % 4;
+    let head_number = Math.ceil(time.beatRelative) % 4;
 
     let template: MovingHeadState = {
       startAddress: 0,
@@ -26,7 +26,7 @@ export class ChaserPattern implements Pattern {
     let result = [];
 
     for (let [i, startAddress] of [1, 15, 29, 43].entries()) {
-      result[i] = template;
+      result[i] = { ...template};
       result[i].startAddress = startAddress;
 
       if (i === head_number) {

boilerbloat/src/patterns/proto.ts

@@ -2,7 +2,7 @@ import { MovingHeadState } from "rust_native_module";
 
 export type Time = {
   absolute: number,
-  beat_relative: number | null,
+  beatRelative: number | null,
 };
 
 export type PatternOutput = Array<MovingHeadState> | null;