gladly-plot 0.0.5 → 0.0.6

package/src/core/LayerType.js

@@ -2,20 +2,52 @@ import { Layer } from "./Layer.js"
 import { buildColorGlsl } from "../colorscales/ColorscaleRegistry.js"
 import { buildFilterGlsl } from "../axes/FilterAxisRegistry.js"
 import { resolveAttributeExpr } from "../compute/ComputationRegistry.js"
+import { SAMPLE_COLUMN_GLSL, SAMPLE_COLUMN_ND_GLSL } from "../data/ColumnData.js"
 
 function buildSpatialGlsl() {
-  return `float normalize_axis(float v, vec2 domain, float scaleType) {
+  return `uniform vec2 xDomain;
+uniform vec2 yDomain;
+uniform vec2 zDomain;
+uniform float xScaleType;
+uniform float yScaleType;
+uniform float zScaleType;
+uniform float u_is3D;
+uniform mat4 u_mvp;
+out vec3 v_clip_pos;
+float normalize_axis(float v, vec2 domain, float scaleType) {
   float vt = scaleType > 0.5 ? log(v) : v;
   float d0 = scaleType > 0.5 ? log(domain.x) : domain.x;
   float d1 = scaleType > 0.5 ? log(domain.y) : domain.y;
   return (vt - d0) / (d1 - d0);
+}
+vec4 plot_pos_3d(vec3 pos) {
+  float nx = normalize_axis(pos.x, xDomain, xScaleType);
+  float ny = normalize_axis(pos.y, yDomain, yScaleType);
+  float nz = normalize_axis(pos.z, zDomain, zScaleType);
+  v_clip_pos = vec3(nx, ny, nz);
+  return u_mvp * vec4(nx*2.0-1.0, ny*2.0-1.0, nz*2.0-1.0, 1.0);
+}
+vec4 plot_pos(vec2 pos) {
+  float nx = normalize_axis(pos.x, xDomain, xScaleType);
+  float ny = normalize_axis(pos.y, yDomain, yScaleType);
+  if (u_is3D > 0.5) {
+    return plot_pos_3d(vec3(pos, zDomain.x));
+  }
+  v_clip_pos = vec3(nx, ny, 0.5);
+  return u_mvp * vec4(nx*2.0-1.0, ny*2.0-1.0, 0.0, 1.0);
 }`
 }
 
+function buildClipFragGlsl() {
+  return `in vec3 v_clip_pos;
+uniform float u_is3D;`
+}
+
 function buildApplyColorGlsl() {
-  return `uniform float u_pickingMode;
+  return `out vec4 fragColor;
+uniform float u_pickingMode;
 uniform float u_pickLayerIndex;
-varying float v_pickId;
+in float v_pickId;
 vec4 gladly_apply_color(vec4 color) {
   if (u_pickingMode > 0.5) {
     float layerIdx = u_pickLayerIndex + 1.0;
@@ -31,15 +63,20 @@ vec4 gladly_apply_color(vec4 color) {
 }`
 }
 
-// Removes `attribute [precision] type varName;` from GLSL source.
 function removeAttributeDecl(src, varName) {
   return src.replace(
-    new RegExp(`[ \\t]*attribute\\s+(?:(?:lowp|mediump|highp)\\s+)?\\w+\\s+${varName}\\s*;[ \\t]*\\n?`, 'g'),
+    new RegExp(`[ \\t]*in\\s+(?:(?:lowp|mediump|highp)\\s+)?\\w+\\s+${varName}\\s*;[ \\t]*\\n?`, 'g'),
+    ''
+  )
+}
+
+function removeUniformDecl(src, varName) {
+  return src.replace(
+    new RegExp(`[ \\t]*uniform\\s+(?:(?:lowp|mediump|highp)\\s+)?\\w+\\s+${varName}\\s*;[ \\t]*\\n?`, 'g'),
     ''
   )
 }
 
-// Injects code immediately after `void main() {`.
 function injectIntoMainStart(src, code) {
   return src.replace(
     /void\s+main\s*\(\s*(?:void\s*)?\)\s*\{/,
@@ -69,24 +106,27 @@ function injectInto(src, helpers) {
 export class LayerType {
   constructor({
     name,
-    // Optional static axis declarations (for schema/introspection — no function call needed)
     xAxis, xAxisQuantityKind,
     yAxis, yAxisQuantityKind,
+    zAxis, zAxisQuantityKind,
     colorAxisQuantityKinds,
+    colorAxis2dQuantityKinds,
     filterAxisQuantityKinds,
-    // Optional dynamic resolver — overrides statics wherever it returns a non-undefined value
     getAxisConfig,
-    // GPU rendering
-    vert, frag, schema, createLayer, createDrawCommand
+    vert, frag, schema, createLayer, createDrawCommand,
+    suppressWarnings = false
   }) {
     this.name = name
-    // Static declarations stored as-is (undefined = not declared)
+    this.suppressWarnings = suppressWarnings
     this.xAxis = xAxis
     this.xAxisQuantityKind = xAxisQuantityKind
     this.yAxis = yAxis
     this.yAxisQuantityKind = yAxisQuantityKind
-    this.colorAxisQuantityKinds = colorAxisQuantityKinds ?? []
-    this.filterAxisQuantityKinds = filterAxisQuantityKinds ?? []
+    this.zAxis = zAxis ?? null
+    this.zAxisQuantityKind = zAxisQuantityKind ?? null
+    this.colorAxisQuantityKinds = colorAxisQuantityKinds ?? {}
+    this.colorAxis2dQuantityKinds = colorAxis2dQuantityKinds ?? {}
+    this.filterAxisQuantityKinds = filterAxisQuantityKinds ?? {}
     this.vert = vert
     this.frag = frag
 
@@ -96,122 +136,235 @@ export class LayerType {
     if (createDrawCommand) this.createDrawCommand = createDrawCommand
   }
 
-  createDrawCommand(regl, layer, plot) {
-    const nm = layer.nameMap
-    // Rename an internal name to the shader-visible name via nameMap (identity if absent).
-    const shaderName = (internalName) => nm[internalName] ?? internalName
-    // Build a single-entry uniform object with renamed key reading from the internal prop name.
-    const u = (internalName) => ({ [shaderName(internalName)]: regl.prop(internalName) })
-
-    // --- Resolve computed attributes ---
+  async createDrawCommand(regl, layer, plot) {
+    // --- Resolve attributes ---
     let vertSrc = this.vert
-    const originalBufferAttrs = {}   // internal_name → Float32Array
-    const computedBufferAttrs = {}   // shader_name   → Float32Array  (from context.bufferAttrs)
-    const allTextureUniforms = {}
-    const allScalarUniforms = {}
-    const allGlobalDecls = []
-    const mainInjections = []
-    const allAxisUpdaters = []
+    const bufferAttrs = {}         // name → Float32Array (fixed geometry)
+    const allTextures = {}         // uniformName → () => texture
+    const allDataColumns = []      // ColumnData instances for refresh()
+    const mainInjections = []      // float name = expr; injected inside main()
+
+    const ndTextures = {}          // sampler2D textures for nD columns only (also in allTextures)
+    const ndColumnHelperLines = [] // shape uniform decls + typed wrapper fns
+    const ndShapeUniforms = {}     // { u_col_name_shape: [x, y, z, w] }
 
     for (const [key, expr] of Object.entries(layer.attributes)) {
-      const result = resolveAttributeExpr(regl, expr, shaderName(key), plot)
+      const result = await resolveAttributeExpr(regl, expr, key, plot)
       if (result.kind === 'buffer') {
-        originalBufferAttrs[key] = result.value
+        bufferAttrs[key] = result.value
       } else {
-        vertSrc = removeAttributeDecl(vertSrc, shaderName(key))
-        Object.assign(computedBufferAttrs, result.context.bufferAttrs)
-        Object.assign(allTextureUniforms, result.context.textureUniforms)
-        Object.assign(allScalarUniforms, result.context.scalarUniforms)
-        allGlobalDecls.push(...result.context.globalDecls)
-        mainInjections.push(`float ${shaderName(key)} = ${result.glslExpr};`)
-        allAxisUpdaters.push(...result.context.axisUpdaters)
+        vertSrc = removeAttributeDecl(vertSrc, key)
+        Object.assign(allTextures, result.textures)
+        allDataColumns.push(result.col)
+
+        if (result.col.ndim === 1) {
+          mainInjections.push(`float ${key} = ${result.glslExpr};`)
+        } else {
+          // nD column: inject shape uniform + typed wrapper; skip auto-assignment
+          const uName = `u_col_${key}`
+          const s = result.col.shape
+          ndShapeUniforms[`${uName}_shape`] = [s[0] ?? 1, s[1] ?? 1, s[2] ?? 1, s[3] ?? 1]
+          Object.assign(ndTextures, result.textures)
+          const ndim = result.col.ndim
+          const ivecType = ndim <= 2 ? 'ivec2' : ndim === 3 ? 'ivec3' : 'ivec4'
+          const idxExpand = ndim <= 2 ? `ivec4(idx, 0, 0)` : ndim === 3 ? `ivec4(idx, 0)` : `idx`
+          ndColumnHelperLines.push(
+            `uniform ivec4 ${uName}_shape;`,
+            `float sample_${key}(${ivecType} idx) {`,
+            `  return sampleColumnND(${uName}, ${uName}_shape, ${idxExpand});`,
+            `}`
+          )
+        }
       }
     }
 
-    layer._axisUpdaters = allAxisUpdaters
+    layer._dataColumns = allDataColumns
 
     if (mainInjections.length > 0) {
       vertSrc = injectIntoMainStart(vertSrc, mainInjections.join('\n  '))
     }
 
-    // Merged buffer attrs by shader name — used for vertex count fallback.
-    const allShaderBuffers = {
-      ...Object.fromEntries(Object.entries(originalBufferAttrs).map(([k, v]) => [shaderName(k), v])),
-      ...computedBufferAttrs
+    // Validate buffer attributes
+    if (!this.suppressWarnings) {
+      for (const [key, buf] of Object.entries(bufferAttrs)) {
+        if (buf instanceof Float32Array && buf.length === 0) {
+          console.warn(`[gladly] Layer '${this.name}': buffer attribute '${key}' is an empty Float32Array — this layer may draw nothing`)
+        }
+      }
     }
 
+    // Pick IDs
     const isInstanced = layer.instanceCount !== null
     const pickCount = isInstanced ? layer.instanceCount :
-      (layer.vertexCount ?? allShaderBuffers[shaderName('x')]?.length
-        ?? Object.values(layer.attributes).find(v => v instanceof Float32Array)?.length ?? 0)
+      (layer.vertexCount ??
+        Object.values(bufferAttrs).find(v => v instanceof Float32Array)?.length ?? 0)
+    if (pickCount === 0 && !this.suppressWarnings) {
+      console.warn(
+        `[gladly] Layer '${this.name}': ` +
+        `${isInstanced ? 'instanceCount' : 'vertex count'} resolved to 0 — ` +
+        `this layer will draw nothing. Check that data columns are non-empty.`
+      )
+    }
     const pickIds = new Float32Array(pickCount)
     for (let i = 0; i < pickCount; i++) pickIds[i] = i
 
-    // --- Build regl attributes ---
+    // Sampler declarations for column textures
+    const samplerDecls = Object.keys(allTextures)
+      .map(n => `uniform sampler2D ${n};`)
+      .join('\n')
+
+    // Build regl attributes
     const attributes = {
-      // Original buffer attrs with possible divisors
       ...Object.fromEntries(
-        Object.entries(originalBufferAttrs).map(([key, buffer]) => {
+        Object.entries(bufferAttrs).map(([key, buffer]) => {
           const divisor = layer.attributeDivisors[key]
-          const attrObj = divisor !== undefined ? { buffer, divisor } : { buffer }
-          return [shaderName(key), attrObj]
+          return [key, divisor !== undefined ? { buffer, divisor } : { buffer }]
         })
       ),
-      // Computed buffer attrs (no divisors; already shader-named)
-      ...Object.fromEntries(
-        Object.entries(computedBufferAttrs).map(([shaderKey, buffer]) => [shaderKey, { buffer }])
-      ),
-      a_pickId: isInstanced ? { buffer: regl.buffer(pickIds), divisor: 1 } : regl.buffer(pickIds)
+      a_pickId: isInstanced ? { buffer: pickIds, divisor: 1 } : { buffer: pickIds }
     }
 
-    // --- Build uniforms ---
+    // Build uniforms
     const uniforms = {
-      ...u("xDomain"),
-      ...u("yDomain"),
-      ...u("xScaleType"),
-      ...u("yScaleType"),
-      u_pickingMode: regl.prop('u_pickingMode'),
+      ...ndShapeUniforms,
+      xDomain:    regl.prop("xDomain"),
+      yDomain:    regl.prop("yDomain"),
+      zDomain:    regl.prop("zDomain"),
+      xScaleType: regl.prop("xScaleType"),
+      yScaleType: regl.prop("yScaleType"),
+      zScaleType: regl.prop("zScaleType"),
+      u_is3D:     regl.prop("u_is3D"),
+      u_mvp:      regl.prop("u_mvp"),
+      u_pickingMode:    regl.prop('u_pickingMode'),
       u_pickLayerIndex: regl.prop('u_pickLayerIndex'),
-      ...Object.fromEntries(
-        Object.entries(layer.uniforms).map(([key, value]) => [shaderName(key), value])
-      ),
-      ...allTextureUniforms,
-      ...allScalarUniforms
+      ...layer.uniforms,
+      ...Object.fromEntries(Object.entries(allTextures).map(([k, fn]) => [k, fn]))
     }
 
-    // Add per-color-axis uniforms (colorscale index + range + scale type), keyed by quantity kind
-    for (const qk of layer.colorAxes) {
-      Object.assign(uniforms, u(`colorscale_${qk}`), u(`color_range_${qk}`), u(`color_scale_type_${qk}`))
+    for (const [suffix, qk] of Object.entries(layer.colorAxes)) {
+      uniforms[`colorscale${suffix}`]       = regl.prop(`colorscale_${qk}`)
+      uniforms[`color_range${suffix}`]      = regl.prop(`color_range_${qk}`)
+      uniforms[`color_scale_type${suffix}`] = regl.prop(`color_scale_type_${qk}`)
+      uniforms[`alpha_blend${suffix}`]      = regl.prop(`alpha_blend_${qk}`)
     }
 
-    // Add per-filter-axis uniforms (vec4: [min, max, hasMin, hasMax] + scale type), keyed by quantity kind
-    for (const qk of layer.filterAxes) {
-      Object.assign(uniforms, u(`filter_range_${qk}`), u(`filter_scale_type_${qk}`))
+    for (const [suffix, qk] of Object.entries(layer.filterAxes)) {
+      uniforms[`filter_range${suffix}`]      = regl.prop(`filter_range_${qk}`)
+      uniforms[`filter_scale_type${suffix}`] = regl.prop(`filter_scale_type_${qk}`)
     }
 
-    // Inject GLSL helpers before the layer shader body.
+    // Strip spatial uniforms from vert (re-declared in buildSpatialGlsl)
+    vertSrc = removeUniformDecl(vertSrc, 'xDomain')
+    vertSrc = removeUniformDecl(vertSrc, 'yDomain')
+    vertSrc = removeUniformDecl(vertSrc, 'zDomain')
+    vertSrc = removeUniformDecl(vertSrc, 'xScaleType')
+    vertSrc = removeUniformDecl(vertSrc, 'yScaleType')
+    vertSrc = removeUniformDecl(vertSrc, 'zScaleType')
+    vertSrc = removeUniformDecl(vertSrc, 'u_is3D')
+    vertSrc = removeUniformDecl(vertSrc, 'u_mvp')
+
     const spatialGlsl = buildSpatialGlsl()
-    const colorGlsl = layer.colorAxes.length > 0 ? buildColorGlsl() : ''
-    const filterGlsl = layer.filterAxes.length > 0 ? buildFilterGlsl() : ''
-    const pickVertDecls = `attribute float a_pickId;\nvarying float v_pickId;`
+    const colorGlsl = (Object.keys(layer.colorAxes).length > 0 || Object.keys(layer.colorAxes2d).length > 0) ? buildColorGlsl() : ''
+    const filterGlsl = Object.keys(layer.filterAxes).length > 0 ? buildFilterGlsl() : ''
+    const pickVertDecls = `in float a_pickId;\nout float v_pickId;`
+
+    const hasNdColumns = ndColumnHelperLines.length > 0
+    const ndColumnHelpersStr = ndColumnHelperLines.join('\n')
+
+    // Column helpers for vert: precision + all samplers + sampleColumn + sampleColumnND + wrappers
+    const columnHelpers = allDataColumns.length > 0
+      ? [
+          'precision highp sampler2D;',
+          samplerDecls,
+          SAMPLE_COLUMN_GLSL,
+          hasNdColumns ? SAMPLE_COLUMN_ND_GLSL : '',
+          ndColumnHelpersStr,
+        ].filter(Boolean).join('\n')
+      : ''
+
+    // Column helpers for frag: only nD column samplers + sampleColumnND + wrappers
+    // (1D columns stay in vert; their a_pickId is a vertex attribute)
+    const ndFragHelpers = hasNdColumns
+      ? [
+          'precision highp sampler2D;',
+          ...Object.keys(ndTextures).map(n => `uniform sampler2D ${n};`),
+          SAMPLE_COLUMN_ND_GLSL,
+          ndColumnHelpersStr,
+        ].join('\n')
+      : ''
+
+    const fnSuffix = (s) => s.replace(/^_+/, '')
+
+    const colorHelperLines = []
+    let fragSrc = this.frag
+    for (const [suffix] of Object.entries(layer.colorAxes)) {
+      colorHelperLines.push(
+        `uniform int colorscale${suffix};`,
+        `uniform vec2 color_range${suffix};`,
+        `uniform float color_scale_type${suffix};`,
+        `uniform float alpha_blend${suffix};`,
+        `vec4 map_color_${fnSuffix(suffix)}(float value) {`,
+        `  return map_color_s(colorscale${suffix}, color_range${suffix}, value, color_scale_type${suffix}, alpha_blend${suffix});`,
+        `}`,
+        `vec4 map_color_2d_x_${fnSuffix(suffix)}(float value) {`,
+        `  return map_color_s_2d(colorscale${suffix}, color_range${suffix}, value, color_scale_type${suffix}, alpha_blend${suffix},`,
+        `                        colorscale${suffix}, color_range${suffix}, 0.0/0.0, color_scale_type${suffix}, 0.0);`,
+        `}`,
+        `vec4 map_color_2d_y_${fnSuffix(suffix)}(float value) {`,
+        `  return map_color_s_2d(colorscale${suffix}, color_range${suffix}, 0.0/0.0, color_scale_type${suffix}, 0.0,`,
+        `                        colorscale${suffix}, color_range${suffix}, value, color_scale_type${suffix}, alpha_blend${suffix});`,
+        `}`
+      )
+      fragSrc = removeUniformDecl(fragSrc, `colorscale${suffix}`)
+      fragSrc = removeUniformDecl(fragSrc, `color_range${suffix}`)
+      fragSrc = removeUniformDecl(fragSrc, `color_scale_type${suffix}`)
+      fragSrc = removeUniformDecl(fragSrc, `alpha_blend${suffix}`)
+    }
+    const colorHelpers = colorHelperLines.join('\n')
+
+    const color2dHelperLines = []
+    for (const [suffix2d, [s1, s2]] of Object.entries(layer.colorAxes2d)) {
+      color2dHelperLines.push(
+        `vec4 map_color_2d_${fnSuffix(suffix2d)}(vec2 values) {`,
+        `  return map_color_s_2d(colorscale${s1}, color_range${s1}, values.x, color_scale_type${s1}, alpha_blend${s1},`,
+        `                        colorscale${s2}, color_range${s2}, values.y, color_scale_type${s2}, alpha_blend${s2});`,
+        `}`
+      )
+    }
+    const color2dHelpers = color2dHelperLines.join('\n')
+
+    const filterHelperLines = []
+    for (const [suffix] of Object.entries(layer.filterAxes)) {
+      filterHelperLines.push(
+        `uniform vec4 filter_range${suffix};`,
+        `bool filter_${fnSuffix(suffix)}(float value) {`,
+        `  return filter_in_range(filter_range${suffix}, value);`,
+        `}`
+      )
+      vertSrc = removeUniformDecl(vertSrc, `filter_range${suffix}`)
+    }
+    const filterHelpers = filterHelperLines.join('\n')
 
+    const clipFragDiscard = `if (u_is3D > 0.5 && (v_clip_pos.x < 0.0 || v_clip_pos.x > 1.0 || v_clip_pos.y < 0.0 || v_clip_pos.y > 1.0 || v_clip_pos.z < 0.0 || v_clip_pos.z > 1.0)) discard;`
     const drawConfig = {
-      vert: injectPickIdAssignment(injectInto(vertSrc, [spatialGlsl, filterGlsl, pickVertDecls, ...allGlobalDecls])),
-      frag: injectInto(this.frag, [buildApplyColorGlsl(), colorGlsl, filterGlsl]),
+      vert: injectPickIdAssignment(injectInto(vertSrc, [spatialGlsl, filterGlsl, filterHelpers, columnHelpers, pickVertDecls])),
+      frag: injectIntoMainStart(injectInto(fragSrc, [buildApplyColorGlsl(), buildClipFragGlsl(), colorGlsl, colorHelpers, color2dHelpers, filterGlsl, filterHelpers, ndFragHelpers]), clipFragDiscard),
       attributes,
       uniforms,
       viewport: regl.prop("viewport"),
       primitive: layer.primitive,
       lineWidth: layer.lineWidth,
       count: regl.prop("count"),
-      ...(layer.blend ? { blend: layer.blend } : {})
+      ...(Object.keys(layer.colorAxes).length > 0 || Object.keys(layer.colorAxes2d).length > 0
+        ? { blend: { enable: true, func: { srcRGB: 'src alpha', dstRGB: 'one minus src alpha', srcAlpha: 0, dstAlpha: 1 } } }
+        : layer.blend ? { blend: layer.blend } : {})
     }
 
     if (layer.instanceCount !== null) {
       drawConfig.instances = regl.prop("instances")
     }
 
-    return regl(drawConfig)
+    return drawConfig
   }
 
   schema(data) {
@@ -219,43 +372,46 @@ export class LayerType {
     throw new Error(`LayerType '${this.name}' does not implement schema()`)
   }
 
-  // Resolves axis config by merging static declarations with dynamic getAxisConfig output.
-  // Dynamic values (non-undefined) override static values.
   resolveAxisConfig(parameters, data) {
     const resolved = {
       xAxis: this.xAxis,
       xAxisQuantityKind: this.xAxisQuantityKind,
       yAxis: this.yAxis,
       yAxisQuantityKind: this.yAxisQuantityKind,
-      colorAxisQuantityKinds: [...this.colorAxisQuantityKinds],
-      filterAxisQuantityKinds: [...this.filterAxisQuantityKinds],
+      zAxis: this.zAxis,
+      zAxisQuantityKind: this.zAxisQuantityKind,
+      colorAxisQuantityKinds: { ...this.colorAxisQuantityKinds },
+      colorAxis2dQuantityKinds: { ...this.colorAxis2dQuantityKinds },
+      filterAxisQuantityKinds: { ...this.filterAxisQuantityKinds },
     }
 
     if (this._getAxisConfig) {
       const dynamic = this._getAxisConfig.call(this, parameters, data)
-      if (dynamic.xAxis !== undefined)                  resolved.xAxis = dynamic.xAxis
-      if (dynamic.xAxisQuantityKind !== undefined)      resolved.xAxisQuantityKind = dynamic.xAxisQuantityKind
-      if (dynamic.yAxis !== undefined)                  resolved.yAxis = dynamic.yAxis
-      if (dynamic.yAxisQuantityKind !== undefined)      resolved.yAxisQuantityKind = dynamic.yAxisQuantityKind
-      if (dynamic.colorAxisQuantityKinds !== undefined) resolved.colorAxisQuantityKinds = dynamic.colorAxisQuantityKinds
-      if (dynamic.filterAxisQuantityKinds !== undefined) resolved.filterAxisQuantityKinds = dynamic.filterAxisQuantityKinds
+      if (dynamic.xAxis !== undefined)                    resolved.xAxis = dynamic.xAxis
+      if (dynamic.xAxisQuantityKind !== undefined)        resolved.xAxisQuantityKind = dynamic.xAxisQuantityKind
+      if (dynamic.yAxis !== undefined)                    resolved.yAxis = dynamic.yAxis
+      if (dynamic.yAxisQuantityKind !== undefined)        resolved.yAxisQuantityKind = dynamic.yAxisQuantityKind
+      if (dynamic.zAxis !== undefined)                    resolved.zAxis = dynamic.zAxis
+      if (dynamic.zAxisQuantityKind !== undefined)        resolved.zAxisQuantityKind = dynamic.zAxisQuantityKind
+      if (dynamic.colorAxisQuantityKinds !== undefined)   resolved.colorAxisQuantityKinds = dynamic.colorAxisQuantityKinds
+      if (dynamic.colorAxis2dQuantityKinds !== undefined) resolved.colorAxis2dQuantityKinds = dynamic.colorAxis2dQuantityKinds
+      if (dynamic.filterAxisQuantityKinds !== undefined)  resolved.filterAxisQuantityKinds = dynamic.filterAxisQuantityKinds
     }
 
     return resolved
   }
 
-  createLayer(parameters, data) {
+  async createLayer(regl, parameters, data, plot) {
     if (!this._createLayer) {
       throw new Error(`LayerType '${this.name}' does not implement createLayer()`)
     }
-    const gpuConfigs = this._createLayer.call(this, parameters, data)
+    const gpuConfigs = await this._createLayer.call(this, regl, parameters, data, plot)
     const axisConfig = this.resolveAxisConfig(parameters, data)
 
     return gpuConfigs.map(gpuConfig => new Layer({
       type: this,
       attributes: gpuConfig.attributes ?? {},
       uniforms: gpuConfig.uniforms ?? {},
-      nameMap: gpuConfig.nameMap ?? {},
       domains: gpuConfig.domains ?? {},
       lineWidth: gpuConfig.lineWidth ?? 1,
       primitive: gpuConfig.primitive ?? "points",
@@ -265,9 +421,12 @@ export class LayerType {
       blend: gpuConfig.blend ?? null,
       xAxis: axisConfig.xAxis,
       yAxis: axisConfig.yAxis,
+      zAxis: axisConfig.zAxis,
       xAxisQuantityKind: axisConfig.xAxisQuantityKind,
       yAxisQuantityKind: axisConfig.yAxisQuantityKind,
+      zAxisQuantityKind: axisConfig.zAxisQuantityKind,
       colorAxes: axisConfig.colorAxisQuantityKinds,
+      colorAxes2d: axisConfig.colorAxis2dQuantityKinds,
       filterAxes: axisConfig.filterAxisQuantityKinds,
     }))
   }