gladly-plot 0.0.5 → 0.0.7

package/src/core/GlBase.js

@@ -0,0 +1,141 @@
+import reglInit from "regl"
+import { FilterAxisRegistry } from "../axes/FilterAxisRegistry.js"
+import { Axis } from "../axes/Axis.js"
+import { DataGroup, ComputedDataNode } from "../data/Data.js"
+import { getComputedData } from "../compute/ComputationRegistry.js"
+
+export class GlBase {
+  constructor() {
+    this.regl = null
+    this.currentData = null
+    this._rawData = null
+    this._dataTransformNodes = []
+    this.filterAxisRegistry = null
+    this._axisCache = new Map()
+    this._axesProxy = null
+    this._initEpoch = 0
+  }
+
+  _initRegl(canvas) {
+    const gl = canvas.getContext('webgl2', { desynchronized: true })
+    if (!gl) throw new Error('WebGL 2.0 is required but not supported')
+
+    const origGetExtension = gl.getExtension.bind(gl)
+    gl.getExtension = (name) => {
+      const lname = name.toLowerCase()
+      const wgl2CoreExts = ['oes_texture_float', 'oes_texture_float_linear']
+      if (wgl2CoreExts.includes(lname)) return origGetExtension(name) ?? {}
+      if (lname === 'angle_instanced_arrays') {
+        return origGetExtension(name) ?? {
+          vertexAttribDivisorANGLE: gl.vertexAttribDivisor.bind(gl),
+          drawArraysInstancedANGLE: gl.drawArraysInstanced.bind(gl),
+          drawElementsInstancedANGLE: gl.drawElementsInstanced.bind(gl),
+          VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 0x88FE
+        }
+      }
+      return origGetExtension(name)
+    }
+
+    const GL_RGBA = 0x1908, GL_FLOAT = 0x1406, GL_RGBA32F = 0x8814
+    const origTexImage2D = gl.texImage2D.bind(gl)
+    gl.texImage2D = function (...args) {
+      if (args.length >= 8 && args[2] === GL_RGBA && args[7] === GL_FLOAT) {
+        args = [...args]
+        args[2] = GL_RGBA32F
+      }
+      return origTexImage2D(...args)
+    }
+
+    this.regl = reglInit({
+      gl,
+      extensions: ['OES_texture_float', 'EXT_color_buffer_float', 'ANGLE_instanced_arrays'],
+      optionalExtensions: ['OES_texture_float_linear'],
+    })
+  }
+
+  /**
+   * Returns a stable Axis instance for the given axis name, creating one on first access.
+   * The same instance is returned across update() calls so links survive updates.
+   *
+   * Usage: plot.axes.xaxis_bottom, pipeline.axes["velocity_ms"], etc.
+   */
+  get axes() {
+    if (!this._axesProxy) {
+      this._axesProxy = new Proxy(this._axisCache, {
+        get: (cache, name) => {
+          if (typeof name !== 'string') return undefined
+          if (!cache.has(name)) cache.set(name, new Axis(this, name))
+          return cache.get(name)
+        }
+      })
+    }
+    return this._axesProxy
+  }
+
+  _getAxis(name) {
+    if (!this._axisCache.has(name)) this._axisCache.set(name, new Axis(this, name))
+    return this._axisCache.get(name)
+  }
+
+  // For filter axes the axis ID is the quantity kind. Overridden by Plot for spatial axes.
+  getAxisQuantityKind(axisId) {
+    return axisId
+  }
+
+  // Default: filter axes only. Overridden by Plot to add spatial + color axes.
+  getAxisDomain(axisId) {
+    const filterRange = this.filterAxisRegistry?.getRange(axisId)
+    if (filterRange) return [filterRange.min, filterRange.max]
+    return null
+  }
+
+  // Default: filter axes only. Overridden by Plot to add spatial + color axes.
+  setAxisDomain(axisId, domain) {
+    if (this.filterAxisRegistry?.hasAxis(axisId)) {
+      this.filterAxisRegistry.setRange(axisId, domain[0], domain[1])
+    }
+  }
+
+  // No-op in base class. Overridden by Plot to schedule a WebGL render frame.
+  scheduleRender() {}
+
+  async _processTransforms(transforms, epoch) {
+    if (!transforms || transforms.length === 0) return
+
+    const TDR_STEP_MS = 500
+    for (const { name, transform: spec } of transforms) {
+      const entries = Object.entries(spec)
+      if (entries.length !== 1) throw new Error(`Transform '${name}' must have exactly one key`)
+      const [className, params] = entries[0]
+
+      const computedData = getComputedData(className)
+      if (!computedData) throw new Error(`Unknown computed data type: '${className}'`)
+
+      const filterAxes = computedData.filterAxes(params, this.currentData)
+      for (const quantityKind of Object.values(filterAxes)) {
+        this.filterAxisRegistry.ensureFilterAxis(quantityKind)
+      }
+
+      const node = new ComputedDataNode(computedData, params)
+      const stepStart = performance.now()
+      try {
+        await node._initialize(this.regl, this.currentData, this)
+      } catch (e) {
+        throw new Error(`Transform '${name}' (${className}) failed to initialize: ${e.message}`, { cause: e })
+      }
+      if (performance.now() - stepStart > TDR_STEP_MS)
+        await new Promise(r => requestAnimationFrame(r))
+      if (this._initEpoch !== epoch) return
+
+      const filterDataExtents = node._meta?.filterDataExtents ?? {}
+      for (const [qk, extent] of Object.entries(filterDataExtents)) {
+        if (this.filterAxisRegistry.hasAxis(qk)) {
+          this.filterAxisRegistry.setDataExtent(qk, extent[0], extent[1])
+        }
+      }
+
+      this.currentData._children[name] = node
+      this._dataTransformNodes.push(node)
+    }
+  }
+}

package/src/core/Layer.js

@@ -1,5 +1,5 @@
 export class Layer {
-  constructor({ type, attributes, uniforms, nameMap = {}, domains = {}, lineWidth = 1, primitive = "points", xAxis = "xaxis_bottom", yAxis = "yaxis_left", xAxisQuantityKind, yAxisQuantityKind, colorAxes = [], filterAxes = [], vertexCount = null, instanceCount = null, attributeDivisors = {}, blend = null }) {
+  constructor({ type, attributes, uniforms, domains = {}, lineWidth = 1, primitive = "points", xAxis = "xaxis_bottom", yAxis = "yaxis_left", zAxis = null, xAxisQuantityKind, yAxisQuantityKind, zAxisQuantityKind, colorAxes = {}, colorAxes2d = {}, filterAxes = {}, vertexCount = null, instanceCount = null, attributeDivisors = {}, blend = null }) {
     // Validate that all attributes are non-null/undefined
     // (Float32Array, regl textures, numbers, and expression objects are all valid)
     for (const [key, value] of Object.entries(attributes)) {
@@ -8,34 +8,48 @@ export class Layer {
       }
     }
 
-    // Validate colorAxes: must be an array of quantity kind strings
-    for (const quantityKind of colorAxes) {
+    // Validate colorAxes: must be a dict mapping GLSL name suffix to quantity kind string
+    for (const quantityKind of Object.values(colorAxes)) {
       if (typeof quantityKind !== 'string') {
         throw new Error(`Color axis quantity kind must be a string, got ${typeof quantityKind}`)
       }
     }
 
-    // Validate filterAxes: must be an array of quantity kind strings
-    for (const quantityKind of filterAxes) {
+    // Validate filterAxes: must be a dict mapping GLSL name suffix to quantity kind string
+    for (const quantityKind of Object.values(filterAxes)) {
       if (typeof quantityKind !== 'string') {
         throw new Error(`Filter axis quantity kind must be a string, got ${typeof quantityKind}`)
       }
     }
 
+    if (!type?.suppressWarnings) {
+      if (vertexCount !== null && vertexCount === 0) {
+        console.warn(`[gladly] Layer '${type?.name ?? 'unknown'}': vertexCount is 0 — this layer will draw nothing`)
+      }
+      if (instanceCount !== null && instanceCount === 0) {
+        console.warn(`[gladly] Layer '${type?.name ?? 'unknown'}': instanceCount is 0 — this layer will draw nothing`)
+      }
+    }
+
     this.type = type
     this.attributes = attributes
     this.uniforms = uniforms
-    this.nameMap = nameMap
     this.domains = domains
     this.lineWidth = lineWidth
     this.primitive = primitive
     this.xAxis = xAxis
     this.yAxis = yAxis
+    this.zAxis = zAxis
     this.xAxisQuantityKind = xAxisQuantityKind
     this.yAxisQuantityKind = yAxisQuantityKind
-    // colorAxes: string[] — quantity kinds of color axes; attribute named by quantityKind holds the data
+    this.zAxisQuantityKind = zAxisQuantityKind
+    // colorAxes: Record<suffix, qk> — maps GLSL name suffix to quantity kind for each color axis
+    // e.g. { '': 'temperature_K' } or { '': 'temp_K', '2': 'pressure_Pa' }
     this.colorAxes = colorAxes
-    // filterAxes: string[] — quantity kinds of filter axes; attribute named by quantityKind holds the data
+    // colorAxes2d: Record<suffix2d, [suffix1, suffix2]> — maps a 2D function name suffix to a pair
+    // of colorAxes suffixes; generates map_color_2d_SUFFIX(vec2) GLSL wrapper
+    this.colorAxes2d = colorAxes2d
+    // filterAxes: Record<suffix, qk> — maps GLSL name suffix to quantity kind for each filter axis
     this.filterAxes = filterAxes
     this.vertexCount = vertexCount
     this.instanceCount = instanceCount