biome fix, some comments

Author: xinaesthete

packages/extensions/src/additive-colormap-extension/additive-colormap-extension.js

@@ -24,8 +24,8 @@ function colormapModuleFactory(name, apply_cmap) {
   return {
     name: extensionName,
     uniformTypes: {
-      opacity: "f32",
-      useTransparentColor: "u32",
+      opacity: 'f32',
+      useTransparentColor: 'u32'
     },
     fs: `\
 // uniform float opacity;
@@ -95,7 +95,7 @@ const AdditiveColormapExtension = class extends LayerExtension {
           opacity: this.props.opacity,
           useTransparentColor: this.props.useTransparentColor
         }
-      })
+      });
     }
   }
 };

packages/extensions/src/color-palette-3d-extensions/base-extension.js

@@ -18,8 +18,8 @@ const BaseExtension = class extends LayerExtension {
     this.opts = this.opts || {};
   }
 
-  updateState({props, oldProps, changeFlags, ...rest}) {
-    super.updateState({props, oldProps, changeFlags, ...rest});
+  updateState({ props, oldProps, changeFlags, ...rest }) {
+    super.updateState({ props, oldProps, changeFlags, ...rest });
     const { colors, channelsVisible } = this.props;
     const paddedColors = padColors({
       // probably can't have these as booleans in the shader?

packages/extensions/src/shader-utils.js

@@ -14,4 +14,4 @@ export function generateNumChannelsCode() {
   // First pass of this can be to make things work with a fixed NUM_CHANNELS...
   // prototyping what will need to be done for varying NUM_CHANNELS,
   // and what the semantics for extensions will need to be.
-}
+}

packages/layers/src/bitmap-layer.js

@@ -2,9 +2,9 @@ import { COORDINATE_SYSTEM, CompositeLayer } from '@deck.gl/core';
 import { BitmapLayer as BaseBitmapLayer } from '@deck.gl/layers';
 import { GL } from '@luma.gl/constants';
 import { Model } from '@luma.gl/engine';
+import { MAX_CHANNELS } from '@vivjs/constants';
 import { addAlpha } from './utils';
 import VivShaderAssembler from './xr-layer/viv-shader-assembler';
-import { MAX_CHANNELS } from '@vivjs/constants';
 
 const PHOTOMETRIC_INTERPRETATIONS = {
   WhiteIsZero: 0,

packages/layers/src/xr-3d-layer/xr-3d-layer-fragment.glsl.ts

@@ -1,5 +1,5 @@
-import { VIV_CHANNEL_INDEX_PLACEHOLDER } from "../xr-layer/viv-shader-assembler";
-const I = VIV_CHANNEL_INDEX_PLACEHOLDER.toString();
+import { VIV_CHANNEL_INDEX_PLACEHOLDER } from '../xr-layer/viv-shader-assembler';
+const I = String(VIV_CHANNEL_INDEX_PLACEHOLDER);
 export default `\
 #version 300 es
 precision highp int;

packages/layers/src/xr-3d-layer/xr-3d-layer.js

@@ -35,10 +35,10 @@ import { Plane } from '@math.gl/culling';
 import fs from './xr-3d-layer-fragment.glsl';
 import vs from './xr-3d-layer-vertex.glsl';
 
+import { MAX_CHANNELS } from '@vivjs/constants';
 import { ColorPalette3DExtensions } from '@vivjs/extensions';
 import { getDtypeValues, padContrastLimits, padWithDefault } from '../utils';
 import VivShaderAssembler from '../xr-layer/viv-shader-assembler';
-import { MAX_CHANNELS } from '@vivjs/constants';
 
 const channelsModule = {
   name: 'channel-intensity-module',

packages/layers/src/xr-layer/utils.js

@@ -1,13 +1,17 @@
+import { MAX_CHANNELS } from '@vivjs/constants';
 import { getDtypeValues } from '../utils';
-import { MAX_CHANNELS } from "@vivjs/constants";
 
 import fs from './xr-layer-fragment.glsl';
 import vs from './xr-layer-vertex.glsl';
 
 // still figuring out how to get bindings to work properly
-const coreShaderModule = { fs, vs, name: "xrLayer" };
+const coreShaderModule = { fs, vs, name: 'xrLayer' };
 
-export function getRenderingAttrs(dtype, interpolation, numChannels = MAX_CHANNELS) {
+export function getRenderingAttrs(
+  dtype,
+  interpolation,
+  numChannels = MAX_CHANNELS
+) {
   /// - WebGL1 is no longer supported by lumagl etc.
   /// 'device' is no longer used, possible in future we want to distinguish between WebGL and WebGPU?
   // Linear filtering only works when the data type is cast to Float32.
@@ -18,11 +22,11 @@ export function getRenderingAttrs(dtype, interpolation, numChannels = MAX_CHANNE
   // we probably want to move this kind of uniformTypes generation to some kind of helper
   // nb - this particular code isn't actually doing anything functionally useful as I write this
   const uniformTypes = {};
-  for (let i=0; i<numChannels; i++) {
+  for (let i = 0; i < numChannels; i++) {
     uniformTypes[`contrastLimits${i}`] = 'vec2<f32>';
   }
   return {
-    shaderModule: {...coreShaderModule, uniformTypes},
+    shaderModule: { ...coreShaderModule, uniformTypes },
     filter: interpolation,
     cast: isLinear ? data => new Float32Array(data) : data => data,
     ...values

packages/layers/src/xr-layer/viv-shader-assembler.ts

@@ -1,7 +1,7 @@
-import { ShaderAssembler } from "@luma.gl/shadertools";
+import { ShaderAssembler } from '@luma.gl/shadertools';
 // oops, this may cause problems for publishing... or maybe not if this is only internal.
-import type { AssembleShaderProps } from "@luma.gl/shadertools/dist/lib/shader-assembly/assemble-shaders";
-import { MAX_CHANNELS } from "@vivjs/constants";
+import type { AssembleShaderProps } from '@luma.gl/shadertools/dist/lib/shader-assembly/assemble-shaders';
+import { MAX_CHANNELS } from '@vivjs/constants';
 
 // open question - should VivShaderAssembler be exposed as public API?
 // I doubt many people would have a reason to want it... but I likely will.
@@ -10,29 +10,59 @@ import { MAX_CHANNELS } from "@vivjs/constants";
 // Users should probably be discouraged from managing their own ShaderAssemblers
 // especially until we are more confident in their use.
 // So in deciding the public form of viv extension API (which should be ergonic/well-typed & stable),
-// it should also allow where possible for somewhat arbitrary extensibility 
+// it should also allow where possible for somewhat arbitrary extensibility
 // without getting too complex... i.e. some kind of shader generation pipeline thing.
 // Viv shouldn't be the place where any complex functionality along those lines
 // is maintained... but it should expose enough to allow other applications to experiment
 // with appropriate documentation on what is considered stable & supported,
 // vs what is there for experimental purposes.
 
-export const VIV_CHANNEL_INDEX_PLACEHOLDER = Symbol('<VIV_CHANNEL_INDEX>');
+//may want to keep this as something that wouldn't make unprocessed shader code invalid syntax
+//maybe we want to use a parser to process the shader code?
+//(probably viv is not the layer at which we introduce something like that)
+export const VIV_CHANNEL_INDEX_PLACEHOLDER = Symbol('VIV_CHANNEL_INDEX');
+const I = String(VIV_CHANNEL_INDEX_PLACEHOLDER);
+//not a practical example, but the line-duplication will not work if there's a multiline expression
+//with mutable state. Not clear how we'd handle that in a simple way.
+`
+float mutableThing = 0.;
+mutableThing = opacity${I};
+float value${I} = mutableThing;
+
+mutableThing = opacity0;
+float value0 = mutableThing;
+mutableThing = opacity1;
+float value1 = mutableThing;
+
+mutableThing = opacity0;
+mutableThing = opacity1;
+float value0 = mutableThing;
+float value1 = mutableThing;
+`;
 
 /**
- * Tagged-template function that expands the VIV_CHANNEL_INDEX_PLACEHOLDER symbol to the given number of channels.
- * 
- * This is probably more appropriate for a public API once it's working.
+ * (totally broken) Tagged-template function that expands the VIV_CHANNEL_INDEX_PLACEHOLDER symbol to the given number of channels.
+ *
+ * Something like this may be more appropriate for a public API once it's working.
  */
 export function vivShader(numChannels: number) {
-  return (strings: TemplateStringsArray, ...expressions: (string | symbol)[]): string => {
+  // this is not doing remotely the right thing...
+  // maybe the proper approach is indeed rather than trying to have something that wraps an entire shader
+  // having ways of processing more local blocks of code
+  // consider that repeating individual lines may be undesirable - have a way of grouping that makes sense
+  //... comments in string above...
+  return (
+    strings: TemplateStringsArray,
+    ...expressions: (string | symbol)[]
+  ): string => {
     let result = '';
     for (let i = 0; i < strings.length; i++) {
       const str = strings[i];
       const expr = i < expressions.length ? expressions[i] : null;
 
       // Check if this line contains the channel index placeholder
-      const hasPlaceholder = expr === VIV_CHANNEL_INDEX_PLACEHOLDER ||
+      const hasPlaceholder =
+        expr === VIV_CHANNEL_INDEX_PLACEHOLDER ||
         (typeof expr === 'string' && expr.includes('<VIV_CHANNEL_INDEX>'));
 
       if (hasPlaceholder) {
@@ -63,9 +93,9 @@ export function vivShader(numChannels: number) {
 
 function processGLSLShaderLine(line: string, numChannels: number) {
   if (!line.includes(VIV_CHANNEL_INDEX_PLACEHOLDER.toString())) return line;
-  let str = "";
-  for (let i=0; i<numChannels; i++) {
-    str += `${line.replaceAll(VIV_CHANNEL_INDEX_PLACEHOLDER.toString(), i.toString())}\n`
+  let str = '';
+  for (let i = 0; i < numChannels; i++) {
+    str += `${line.replaceAll(VIV_CHANNEL_INDEX_PLACEHOLDER.toString(), i.toString())}\n`;
   }
   // Remove the trailing comma if present
   if (str.endsWith(',\n')) {
@@ -74,7 +104,10 @@ function processGLSLShaderLine(line: string, numChannels: number) {
   return str;
 }
 function processGLSLShader(shader: string, n: number) {
-  return shader.split('\n').map(line => processGLSLShaderLine(line, n)).join('\n')
+  return shader
+    .split('\n')
+    .map(line => processGLSLShaderLine(line, n))
+    .join('\n');
 }
 export default class VivShaderAssembler extends ShaderAssembler {
   static defaultVivAssemblers: Record<number, VivShaderAssembler> = {};
@@ -102,7 +135,8 @@ export default class VivShaderAssembler extends ShaderAssembler {
   }
   static getVivAssembler(NUM_CHANNELS = MAX_CHANNELS) {
     if (!VivShaderAssembler.defaultVivAssemblers[NUM_CHANNELS]) {
-      VivShaderAssembler.defaultVivAssemblers[NUM_CHANNELS] = new VivShaderAssembler(NUM_CHANNELS);
+      VivShaderAssembler.defaultVivAssemblers[NUM_CHANNELS] =
+        new VivShaderAssembler(NUM_CHANNELS);
     }
     return VivShaderAssembler.defaultVivAssemblers[NUM_CHANNELS];
     // return ShaderAssembler.getDefaultShaderAssembler();

packages/layers/src/xr-layer/xr-layer-fragment.glsl.ts

@@ -1,5 +1,8 @@
-import { VIV_CHANNEL_INDEX_PLACEHOLDER } from "../xr-layer/viv-shader-assembler";
-const I = VIV_CHANNEL_INDEX_PLACEHOLDER.toString();
+import {
+  VIV_CHANNEL_INDEX_PLACEHOLDER,
+  // vivShader
+} from '../xr-layer/viv-shader-assembler';
+const I = String(VIV_CHANNEL_INDEX_PLACEHOLDER);
 export default `\
 #version 300 es
 #define SHADER_NAME xr-layer-fragment-shader

packages/layers/src/xr-layer/xr-layer.js

@@ -4,11 +4,10 @@ import { COORDINATE_SYSTEM, Layer, picking, project32 } from '@deck.gl/core';
 // ... needed to destructure for it to build with luma.gl 9, but we probably need to change these anyway
 import { GL } from '@luma.gl/constants';
 import { Geometry, Model } from '@luma.gl/engine';
-import { ShaderAssembler } from '@luma.gl/shadertools';
+import { MAX_CHANNELS } from '@vivjs/constants';
 import { padContrastLimits } from '../utils';
 import channels from './shader-modules/channel-intensity';
 import { getRenderingAttrs } from './utils';
-import { MAX_CHANNELS } from '@vivjs/constants';
 import VivShaderAssembler from './viv-shader-assembler';
 
 const defaultProps = {
@@ -51,7 +50,11 @@ const XRLayer = class extends Layer {
    */
   getShaders() {
     const { dtype, interpolation } = this.props;
-    const { shaderModule, sampler } = getRenderingAttrs(dtype, interpolation, MAX_CHANNELS);
+    const { shaderModule, sampler } = getRenderingAttrs(
+      dtype,
+      interpolation,
+      MAX_CHANNELS
+    );
     const extensionDefinesDeckglProcessIntensity =
       this._isHookDefinedByExtensions('fs:DECKGL_PROCESS_INTENSITY');
     const newChannelsModule = { ...channels, inject: {} };
@@ -193,7 +196,10 @@ const XRLayer = class extends Layer {
       });
       const xrLayer = {};
       for (let i = 0; i < MAX_CHANNELS; i++) {
-        xrLayer[`contrastLimits${i}`] = [paddedContrastLimits[i*2], paddedContrastLimits[1 + i*2]];
+        xrLayer[`contrastLimits${i}`] = [
+          paddedContrastLimits[i * 2],
+          paddedContrastLimits[1 + i * 2]
+        ];
       }
       //>>>> this is the problem I have currently, although it seems like what I pass here should be reasonable
       //webgl-render-pipeline.ts:412 luma.gl: Binding xrLayerUniforms not found in image-sub-layer-0,240,240,0-Background-Image-TiffPixelSource-#detail#-cached