More untested Worker code

Author: dpolugic

src/draw/patterns.worker.ts

@@ -1,45 +1,50 @@
-import { State, ViewportPattern } from '../types'
+import { AbsolutePattern, RelativePattern, State, ViewportPattern } from '../types'
+import { streamBatchedDrawablePatterns } from './stream-batched-drawable-patterns'
 
 type WorkerState =
   | {
-      type: 'idle'
+      type: 'stopped'
     }
   | {
       type: 'generating'
       state: State
     }
-  | {
-      type: 'paused'
-      state: State
-    }
 
 type WorkerMessageInput =
+  | {
+      type: 'initialize'
+      ctx: OffscreenCanvasRenderingContext2D
+    }
   | {
       type: 'generate'
       state: State
     }
   | {
       type: 'stop'
     }
+
+type WorkerMessageOutput =
   | {
-      type: 'pause'
+      type: 'batch'
+      depth: number
+      patterns: ViewportPattern[]
     }
   | {
-      type: 'resume'
+      type: 'done'
     }
 
-type WorkerMessageOutput = {
-  type: 'batch'
-  patterns: ViewportPattern[]
-}
-
 let state: WorkerState = {
-  type: 'idle',
+  type: 'stopped',
 }
 
 function handleMessage(message: WorkerMessageInput) {
   switch (message.type) {
     case 'generate': {
+      if (state.type === 'generating') {
+        console.warn('Already generating patterns')
+        break
+      }
+
       // Start generating patterns
       state = {
         type: 'generating',
@@ -49,7 +54,9 @@ function handleMessage(message: WorkerMessageInput) {
       break
     }
     case 'stop': {
-      // Stop
+      state = {
+        type: 'stopped',
+      }
       break
     }
     default: {
@@ -68,9 +75,26 @@ self.onmessage = event => {
 }
 
 function generatePatterns() {
-  // Post batches of patterns back to main thread
+  for (const { depth, patterns } of streamBatchedDrawablePatterns({
+    state: {
+      patterns: [{ anchor: [0, 0], target: [0.5, 0.5] } as RelativePattern],
+      screens: [{ anchor: [0.2, 0.2], target: [0.8, 0.8] } as AbsolutePattern],
+    },
+    chunkSize: 5,
+    screenSize: [600, 400],
+  })) {
+    if (state.type !== 'generating') {
+      break
+    }
+
+    sendMessage({
+      type: 'batch',
+      depth,
+      patterns,
+    })
+  }
+
   sendMessage({
-    type: 'batch',
-    patterns: [], // TODO: Generate actual patterns
+    type: 'done',
   })
 }

src/draw/stream-batched-drawable-patterns.ts

@@ -1,21 +1,16 @@
 import { Size, State, ViewportPattern } from '../types'
 import { streamDrawablePatterns } from './stream-drawable-patterns'
 
-type Chunk = {
+export type DrawableChunk = {
   depth: number
   patterns: ViewportPattern[]
 }
 
 /**
- * Creates a generator that groups drawable patterns from `streamDrawablePatterns` into chunks.
+ * Creates a generator that groups drawable patterns from {@link streamDrawablePatterns} into chunks.
  *
  * Patterns are batched together based on their generation depth or a maximum
  * chunk size. This is useful for processing or rendering patterns in groups.
- *
- * @param state The current application state.
- * @param chunkSize The maximum number of patterns to include in a single chunk.
- * @param screenSize The current size of the screen/viewport.
- * @returns A generator yielding `Chunk` objects ({ depth: number, patterns: ViewportPattern[] }).
  */
 export function* streamBatchedDrawablePatterns({
   state,
@@ -25,10 +20,10 @@ export function* streamBatchedDrawablePatterns({
   state: State
   chunkSize: number
   screenSize: Size
-}): Generator<Chunk, void, void> {
+}): Generator<DrawableChunk, void, void> {
   const drawQueueIterator = streamDrawablePatterns({ state, screenSize })
 
-  let chunk: Chunk = {
+  let chunk: DrawableChunk = {
     depth: 0,
     patterns: [],
   }

src/draw/stream-drawable-patterns.ts

@@ -15,6 +15,11 @@ function getViewportBoundaries(screenSize: Size): Boundaries<ViewportNumber> {
   }
 }
 
+type QueueEntry = {
+  currentPattern: ViewportPattern
+  depth: number
+}
+
 // We'll use a global queue to avoid reallocating it on every preview frame.
 const patternQueue = new Queue<QueueEntry>({
   initialItems: [],
@@ -48,10 +53,7 @@ const isValidPattern = (() => {
   }
 })()
 
-type QueueEntry = {
-  currentPattern: ViewportPattern
-  depth: number
-}
+
 
 /**
  * Creates a generator that yields drawable patterns one by one.