@andespindola/brainlink 1.6.1 → 1.6.2

package/dist/application/frontend/client/worker-bootstrap.js

@@ -12,7 +12,7 @@ const mainThreadWebGlAvailable = () => {
 // Uma vez que o controle do canvas é transferido para o worker (OffscreenCanvas),
 // o elemento original não fornece mais nenhum contexto (2D ou WebGL). Quando o
 // worker falha ao iniciar o WebGL, trocamos por um canvas novo para que o
-// fallback 2D consiga desenhar o grafo.
+// renderer da thread principal (WebGL ou o fallback 2D) consiga desenhar.
 const replaceGraphCanvas = () => {
   const replacement = canvas.cloneNode(false)
   if (canvas.parentNode) {
@@ -24,6 +24,8 @@ const replaceGraphCanvas = () => {
 
 const enterFallbackMode = (rebindInput) => {
   state.rendererMode = 'fallback'
+  state.renderWorker = null
+  state.workerReady = false
   if (rebindInput) {
     setupInput()
   }
@@ -31,58 +33,126 @@ const enterFallbackMode = (rebindInput) => {
   drawFallback()
 }
 
+// Renderiza com WebGL na própria thread principal quando o worker não está
+// disponível ou falhou. Reaproveita exatamente o mesmo renderer do worker,
+// dirigido por chamadas diretas em vez de mensagens de Worker: state.renderWorker
+// recebe um shim com .postMessage/.terminate, então todos os call-sites do
+// cliente (chunk/camera/pick/etc.) continuam iguais.
+const setupMainThreadWebGl = (rebindInput) => {
+  if (!mainThreadWebGlAvailable()) {
+    enterFallbackMode(rebindInput)
+    return false
+  }
+
+  try {
+    const renderer = createGraphRenderer({
+      postMessage: (message) => handleRendererMessage(message),
+      requestAnimationFrame: (callback) => window.requestAnimationFrame(callback)
+    })
+
+    state.rendererMode = 'mainthread'
+    state.renderWorker = {
+      postMessage: (message) => renderer.handleMessage(message),
+      terminate: () => {}
+    }
+
+    if (rebindInput) {
+      setupInput()
+    }
+
+    renderer.handleMessage({
+      type: 'init',
+      canvas,
+      width: state.viewport.width,
+      height: state.viewport.height,
+      devicePixelRatio: state.viewport.ratio,
+      camera: state.camera,
+      theme: graphTheme
+    })
+    return true
+  } catch (error) {
+    console.error(error)
+    state.renderWorker = null
+    enterFallbackMode(rebindInput)
+    return false
+  }
+}
+
+// Canal único de mensagens do renderer, compartilhado pelo worker e pela thread
+// principal. As saídas (ready/pick-result/frame-stats/fatal) chegam aqui igual
+// nos dois modos.
+const handleRendererMessage = (payload) => {
+  if (!payload || typeof payload !== 'object') {
+    return
+  }
+
+  if (payload.type === 'ready') {
+    state.workerReady = true
+    scheduleChunkFetch({ fit: true })
+    return
+  }
+
+  if (payload.type === 'pick-result') {
+    if (payload.node && typeof payload.node.id === 'string' && payload.node.id.length > 0) {
+      handlePickedNode(payload.node)
+    }
+    return
+  }
+
+  if (payload.type === 'frame-stats') {
+    state.lastVisibleNodes = Number.isFinite(payload.visibleNodes) ? payload.visibleNodes : state.lastVisibleNodes
+    state.lastVisibleEdges = Number.isFinite(payload.visibleEdges) ? payload.visibleEdges : state.lastVisibleEdges
+    return
+  }
+
+  if (payload.type === 'fatal') {
+    console.error(payload.message)
+    state.workerReady = false
+
+    // Já estamos no WebGL da thread principal: não há degrau acelerado
+    // adicional, então cai no canvas 2D.
+    if (state.rendererMode === 'mainthread') {
+      state.renderWorker = null
+      enterFallbackMode(true)
+      return
+    }
+
+    // O WebGL falhou dentro do worker. O canvas já foi transferido para ele,
+    // então troca por um novo e tenta WebGL na thread principal antes de
+    // desistir para o fallback 2D.
+    if (state.renderWorker && typeof state.renderWorker.terminate === 'function') {
+      state.renderWorker.terminate()
+    }
+    state.renderWorker = null
+    replaceGraphCanvas()
+    setupMainThreadWebGl(true)
+  }
+}
+
 const setupRenderWorker = () => {
   const hasWorker = typeof Worker !== 'undefined'
   const canTransfer = typeof canvas.transferControlToOffscreen === 'function'
 
-  if (!hasWorker || !canTransfer || !mainThreadWebGlAvailable()) {
+  // Sem WebGL em lugar nenhum: só resta o canvas 2D.
+  if (!mainThreadWebGlAvailable()) {
     enterFallbackMode(false)
     return
   }
 
+  // Tem WebGL, mas não dá para usar o worker (sem Worker ou sem OffscreenCanvas):
+  // renderiza WebGL na thread principal em vez de cair direto no 2D.
+  if (!hasWorker || !canTransfer) {
+    setupMainThreadWebGl(false)
+    return
+  }
+
   try {
     const offscreen = canvas.transferControlToOffscreen()
     const worker = new Worker('/render-worker.js')
+    state.rendererMode = 'worker'
     state.renderWorker = worker
 
-    worker.onmessage = (event) => {
-      const payload = event.data
-      if (!payload || typeof payload !== 'object') {
-        return
-      }
-
-      if (payload.type === 'ready') {
-        state.workerReady = true
-        scheduleChunkFetch({ fit: true })
-        return
-      }
-
-      if (payload.type === 'pick-result') {
-        if (payload.node && typeof payload.node.id === 'string' && payload.node.id.length > 0) {
-          handlePickedNode(payload.node)
-        }
-        return
-      }
-
-      if (payload.type === 'frame-stats') {
-        state.lastVisibleNodes = Number.isFinite(payload.visibleNodes) ? payload.visibleNodes : state.lastVisibleNodes
-        state.lastVisibleEdges = Number.isFinite(payload.visibleEdges) ? payload.visibleEdges : state.lastVisibleEdges
-        return
-      }
-
-      if (payload.type === 'fatal') {
-        console.error(payload.message)
-        state.workerReady = false
-        if (state.renderWorker) {
-          state.renderWorker.terminate()
-        }
-        state.renderWorker = null
-        // O canvas já foi transferido para o worker: troca por um novo e
-        // religa os eventos de interação antes de cair no fallback 2D.
-        replaceGraphCanvas()
-        enterFallbackMode(true)
-      }
-    }
+    worker.onmessage = (event) => handleRendererMessage(event && event.data)
 
     worker.postMessage({
       type: 'init',
@@ -95,8 +165,10 @@ const setupRenderWorker = () => {
     }, [offscreen])
   } catch (error) {
     console.error(error)
+    // O canvas pode já ter sido transferido: troca por um novo e tenta WebGL
+    // na thread principal antes do fallback 2D.
     replaceGraphCanvas()
-    enterFallbackMode(false)
+    setupMainThreadWebGl(false)
   }
 }
 

package/dist/application/frontend/client-js.js

@@ -8,6 +8,7 @@ import { createChunkFetchJs } from './client/chunk-fetch.js';
 import { createInputJs } from './client/input.js';
 import { createUploadJs } from './client/upload.js';
 import { createControlsJs } from './client/controls.js';
+import { createGraphRendererJs } from './client/graph-renderer.js';
 import { createWorkerBootstrapJs } from './client/worker-bootstrap.js';
 export const createClientJs = () => [
     createElementsJs(),
@@ -20,5 +21,6 @@ export const createClientJs = () => [
     createInputJs(),
     createUploadJs(),
     createControlsJs(),
+    createGraphRendererJs(),
     createWorkerBootstrapJs()
 ].join('');