@driftengine/core 4.8.2 → 4.8.3

package/src/render/backend/webgpu/windStreakPass.ts

@@ -9,6 +9,7 @@ import type { UniformFields } from './scatterPass.ts';
 import { DEPTH_FORMAT } from './flatPass.ts';
 import type { PipelineCache } from './pipelineCache.ts';
 import { shaderModule } from './shaderModules.ts';
+import { SCENE_ALPHA_COVERS } from '../../sceneCoverage.ts';
 
 /**
  * The wind-streak pass: a lattice of debris that follows the camera and wraps.
@@ -184,7 +185,7 @@ export function windStreakPipeline(
               dstFactor: 'one-minus-src-alpha',
               operation: 'add',
             },
-            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+            alpha: SCENE_ALPHA_COVERS,
           },
         },
       ],

package/src/render/boltBatch.ts

@@ -2,6 +2,7 @@ import { compileProgram, uniformLocations } from './shader.ts';
 import { BOLT_FRAG, BOLT_VERT } from './shaders/bolt.ts';
 import { buildSegmentQuads, expandBoltSegments } from './segmentQuads.ts';
 import type { BoltSegments } from './boltPool.ts';
+import { blendKeeping } from './sceneCoverage.ts';
 
 /**
  * One draw call for a pool of electrical arcs.
@@ -86,7 +87,7 @@ export class BoltBatch {
   drawTo(gl: WebGL2RenderingContext, segmentCount: number): void {
     if (segmentCount === 0) return;
     gl.enable(gl.BLEND);
-    gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
+    blendKeeping(gl, gl.SRC_ALPHA, gl.ONE);
     gl.depthMask(false);
     gl.disable(gl.CULL_FACE);
 

package/src/render/causticsRenderer.ts

@@ -7,6 +7,7 @@ import type { Atmosphere } from './atmosphere.ts';
 import { buildSheets } from './surfaceSheet.ts';
 import type { SheetSpan } from './surfaceSheet.ts';
 import { seaStateForWind } from './seaState.ts';
+import { blendKeeping } from './sceneCoverage.ts';
 
 /**
  * A surface lit by nearby water: the floor of a pool, the bottom of a flooded
@@ -149,7 +150,7 @@ export class CausticsRenderer {
     bindAtmosphere(gl, u, atmosphere, camera.position[1] ?? 0, underwaterEnabled);
 
     gl.enable(gl.BLEND);
-    gl.blendFunc(gl.ONE, gl.ONE);
+    blendKeeping(gl, gl.ONE, gl.ONE);
     /*
      * No depth write, but depth *testing* stays on: the sheet sits a couple of
      * centimetres under the surface it lights, so geometry in front of it — the

package/src/render/cutoutCaster.ts

@@ -13,19 +13,30 @@
  */
 import type { SurfaceMaterial } from './surfaceTexture.ts';
 
-/** A cutout caster's texture, its cutoff and its UV scale. */
+/** A cutout caster's texture, its cutoff and its UV scale and offset. */
 export interface CutoutCaster<Texture> {
   readonly albedo: Texture;
   readonly cutoff: number;
   readonly u: number;
   readonly v: number;
+  readonly uOffset: number;
+  readonly vOffset: number;
 }
 
-const answer: { albedo: unknown; cutoff: number; u: number; v: number } = {
+const answer: {
+  albedo: unknown;
+  cutoff: number;
+  u: number;
+  v: number;
+  uOffset: number;
+  vOffset: number;
+} = {
   albedo: null,
   cutoff: 0,
   u: 1,
   v: 1,
+  uOffset: 0,
+  vOffset: 0,
 };
 
 /** The cutout `material` casts, or null for an ordinary caster. */
@@ -40,5 +51,7 @@ export function cutoutOf<Texture>(
   answer.cutoff = cutoff;
   answer.u = material.uScale ?? 1;
   answer.v = material.vScale ?? 1;
+  answer.uOffset = material.uOffset ?? 0;
+  answer.vOffset = material.vOffset ?? 0;
   return answer as CutoutCaster<Texture>;
 }

package/src/render/decalPass.ts

@@ -7,6 +7,7 @@ import { DEPTH_01_TO_CLIP } from './lightVolumeDraw.ts';
 import { compileProgram, uniformLocations } from './shader.ts';
 import { DECAL_PROJECT_FRAG } from './shaders/decalProject.ts';
 import { FULLSCREEN_VERT } from './shaders/fullscreen.ts';
+import { blendKeeping } from './sceneCoverage.ts';
 
 /**
  * Drawn decals on WebGL2: one scissored triangle per mark, multiplied into the finished scene.
@@ -66,7 +67,7 @@ export class DecalPass {
     gl.depthMask(false);
     gl.disable(gl.CULL_FACE);
     gl.enable(gl.BLEND);
-    gl.blendFunc(gl.ZERO, gl.SRC_COLOR);
+    blendKeeping(gl, gl.ZERO, gl.SRC_COLOR);
     gl.enable(gl.SCISSOR_TEST);
 
     /* Unit 0, chosen rather than inherited: `bindTexture` binds to whichever unit is active, and

package/src/render/globalMediumPass.ts

@@ -7,6 +7,7 @@ import { DEPTH_01_TO_CLIP } from './lightVolumeDraw.ts';
 import { compileProgram, uniformLocations } from './shader.ts';
 import { FULLSCREEN_VERT } from './shaders/fullscreen.ts';
 import { MEDIUM_FRAG, MEDIUM_UPSAMPLE_FRAG } from './shaders/globalMedium.ts';
+import { blendCovering, blendTransmitting } from './sceneCoverage.ts';
 
 /** What the march needs about the light, which is the sun and the sky and nothing else. */
 export interface MediumLight {
@@ -270,7 +271,7 @@ export class GlobalMediumPass {
     gl.depthMask(false);
     gl.disable(gl.CULL_FACE);
     gl.enable(gl.BLEND);
-    gl.blendFuncSeparate(gl.ONE, gl.SRC_ALPHA, gl.ZERO, gl.ONE);
+    blendTransmitting(gl, gl.ONE, gl.SRC_ALPHA);
 
     gl.useProgram(this.upsample);
     gl.bindVertexArray(this.vao);
@@ -293,7 +294,7 @@ export class GlobalMediumPass {
     gl.activeTexture(gl.TEXTURE0);
     gl.bindTexture(gl.TEXTURE_2D, null);
     /* Back to the blend every other pass in this renderer assumes it inherits. */
-    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    blendCovering(gl, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
     gl.disable(gl.BLEND);
     gl.depthMask(true);
     gl.enable(gl.DEPTH_TEST);

package/src/render/lineBatch.ts

@@ -2,6 +2,7 @@ import { compileProgram, uniformLocations } from './shader.ts';
 import { LINE_FRAG, LINE_VERT } from './shaders/line.ts';
 import { buildSegmentQuads, expandLineSegments } from './segmentQuads.ts';
 import type { LineSegments } from './linePoints.ts';
+import { blendCovering, blendKeeping } from './sceneCoverage.ts';
 
 /**
  * One draw call for a polyline with a real width — an audio waveform, a trail, a plotted
@@ -102,7 +103,8 @@ export class LineBatch {
   drawTo(gl: WebGL2RenderingContext, segmentCount: number, additive = false): void {
     if (segmentCount === 0) return;
     gl.enable(gl.BLEND);
-    gl.blendFunc(gl.SRC_ALPHA, additive ? gl.ONE : gl.ONE_MINUS_SRC_ALPHA);
+    if (additive) blendKeeping(gl, gl.SRC_ALPHA, gl.ONE);
+    else blendCovering(gl, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
     gl.depthMask(false);
     // The quad billboards toward the view direction the same way a bolt's does — see
     // `line.ts`'s own `cross(dir, view)` — so its winding can flip with the camera exactly

package/src/render/oitPass.ts

@@ -1,6 +1,7 @@
 import { compileProgram, uniformLocations } from './shader.ts';
 import { FULLSCREEN_VERT } from './shaders/fullscreen.ts';
 import { OIT_RESOLVE_FRAG } from './shaders/oitResolve.ts';
+import { blendTransmitting } from './sceneCoverage.ts';
 
 /**
  * Order-independent transparency on WebGL2: two targets, two passes over the same geometry, and a
@@ -179,7 +180,7 @@ export class OitPass {
     gl.depthMask(false);
     gl.disable(gl.CULL_FACE);
     gl.enable(gl.BLEND);
-    gl.blendFunc(gl.ONE_MINUS_SRC_ALPHA, gl.SRC_ALPHA);
+    blendTransmitting(gl, gl.ONE_MINUS_SRC_ALPHA, gl.SRC_ALPHA);
 
     gl.useProgram(this.program);
     gl.activeTexture(gl.TEXTURE0);

package/src/render/particleBatch.ts

@@ -2,6 +2,7 @@ import { compileProgram, uniformLocations } from './shader.ts';
 import { particleShaders, type ParticleMaterial } from './particleMaterial.ts';
 import { PARTICLE_BLADES, PARTICLE_INDICES, PARTICLE_VERTS } from './shaders/particle.ts';
 import type { ParticleInstances } from './particlePool.ts';
+import { blendCovering, blendKeeping } from './sceneCoverage.ts';
 
 /**
  * One draw call for a live particle pool: one camera-facing quad per particle, or a
@@ -239,8 +240,8 @@ export class ParticleBatch {
   drawTo(gl: WebGL2RenderingContext, count: number): void {
     if (count === 0) return;
     gl.enable(gl.BLEND);
-    if (this.blend === 'additive') gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
-    else gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    if (this.blend === 'additive') blendKeeping(gl, gl.SRC_ALPHA, gl.ONE);
+    else blendCovering(gl, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
     gl.depthMask(false);
     gl.disable(gl.CULL_FACE);
 

package/src/render/particlePool.ts

@@ -21,7 +21,11 @@ import type { Vec3 } from '../math/color.ts';
 export interface ParticleInstances {
   /** World position, three floats each. */
   positions: Float32Array;
-  /** Metres across, and radians of roll about the particle's own axis. */
+  /**
+   * Metres from the centre to an edge, a half-width: the quad spans twice this. Then radians of
+   * roll about the particle's own axis. This said metres across until 4.8.3, and a caller who took
+   * it at its word drew every particle twice as wide as meant.
+   */
   sizes: Float32Array;
   spins: Float32Array;
   /** Linear colour, three floats each. */
@@ -72,7 +76,7 @@ export interface ParticlePoolOptions {
   capacity: number;
   /** Seconds a particle lives. */
   lifeSec: number;
-  /** Size at birth and at death, metres. */
+  /** Size at birth and at death: metres from the centre to an edge, so the quad is twice as wide. */
   sizeStart: number;
   sizeEnd: number;
   /** Colour at birth and at death. */

package/src/render/plumeRenderer.ts

@@ -6,6 +6,7 @@ import { plumeShaders, type PlumeMaterial } from './plumeMaterial.ts';
 import { buildPlumeGeometry } from './plumeGeometry.ts';
 import type { Atmosphere } from './atmosphere.ts';
 import type { Vec3 } from '../math/color.ts';
+import { blendCovering, blendKeeping } from './sceneCoverage.ts';
 
 /**
  * Batched camera-facing quads for volumetric effects — flames, smoke, steam,
@@ -202,8 +203,8 @@ export class PlumeRenderer {
     bindAtmosphere(gl, u, atmosphere, atmosphereCameraY, underwaterEnabled);
 
     gl.enable(gl.BLEND);
-    if (this.blend === 'additive') gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
-    else gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    if (this.blend === 'additive') blendKeeping(gl, gl.SRC_ALPHA, gl.ONE);
+    else blendCovering(gl, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
     gl.depthMask(false);
     gl.disable(gl.CULL_FACE);
 

package/src/render/renderQuality.ts

@@ -20,8 +20,14 @@ import { PREFILTER_SAMPLE_COUNTS } from './prefilterEnvMap.ts';
  * `aces` adds filmic tone mapping before that, rolling highlights off instead of
  * clipping them flat. Together they are what three.js does by default, which is why a
  * world ported from it looks wrong until this exists.
+ *
+ * `shoulder` keeps sRGB's midtones exactly and eases only the highlights: past 0.8 the brightest
+ * channel rolls toward 1 and the other two are scaled with it, so an overbright red spark stays
+ * red where `srgb` clips each channel and turns its core pink and wide. It is the curve a ported
+ * game's own resolve applied — for a port that has to match one — and it has none of ACES's toe or
+ * desaturation. See `HIGHLIGHT_SHOULDER_GLSL` for the arithmetic.
  */
-export type OutputTransform = 'none' | 'srgb' | 'aces';
+export type OutputTransform = 'none' | 'srgb' | 'aces' | 'shoulder';
 
 /**
  * The three settings whose accepted values are a closed set, written as one.
@@ -69,7 +75,8 @@ export interface RenderQuality {
    * chooses is a look rather than a standard — three.js uses 1/0.6 and says so. This
    * engine holds no opinion and takes the number from whoever is authoring the world, so
    * that matching another renderer, or simply preferring a different grade, is a setting
-   * rather than a patch. Ignored when `outputTransform` is not `aces`.
+   * rather than a patch. Scales into `aces` and into `shoulder`, the two curves; ignored by
+   * `none` and `srgb`, which have none.
    */
   readonly outputExposure: number;
   /**

package/src/render/sceneCoverage.ts

@@ -0,0 +1,78 @@
+/**
+ * What a blended draw into the scene does to its alpha, which holds how much of each pixel is still
+ * the opaque surface — the share ambient occlusion is allowed to darken.
+ *
+ * **Occlusion is applied in the composite, from the depth the opaque world left**, after every
+ * translucent draw has landed, and a particle or a pane writes no depth: so a puff of smoke in front
+ * of a wall was darkened by the corner behind it. Reported from a game as walls and two figures
+ * standing behind a cloud showing through it as outlines, and nothing at all with occlusion off.
+ *
+ * So the scene's alpha is a running share. The frame clears it to 1 and an opaque draw writes 1,
+ * which is the whole of the surface; then each draw blended in front of it says which of three
+ * things it is, and the composite darkens `share` of the pixel and leaves the rest:
+ *
+ * - **It covers**: glass, smoke, water, a line, text in the world, a panel. The share falls by what
+ *   the draw lets through, `share * (1 - a)`.
+ * - **It transmits**: the medium, the order-independent composite. Its alpha already *is* what gets
+ *   through, `share * a`.
+ * - **It keeps**: light added to the surface or a layer of the surface itself — caustics, a light
+ *   volume, a bolt, a wet film, a decal, a reflection. The share is unchanged.
+ *
+ * **What it gives up** is added light in front of an occluded corner: a glow or a spark adds to the
+ * pixel and keeps the share, so the composite darkens what it added along with the surface — which
+ * is how every blended draw behaved before this, and one multiply cannot tell the two apart. **What
+ * would make it wrong** is an opaque pass writing an alpha below 1: its surface would then take less
+ * occlusion than it should, which is the safe direction, and is the lit shader's own case at a
+ * cutout's edge or under a per-vertex alpha lane.
+ *
+ * **It survives the temporal passes.** A temporal resolve passes the frame's alpha through, since
+ * it is a fact about this frame and takes no history; a reconstruction reads it from the scene it
+ * rebuilt into the picture it shows, and the blended draws that land after it cover that picture.
+ *
+ * **One pipeline does not take part**: the GPU-driven pass blends its own surfaces into a target
+ * whose alpha is the mask its blit reads to tell a drawn pixel from an undrawn one, and that blit
+ * writes the share back to 1. Its panes still take the occlusion of what they cover. What would
+ * close it is a channel for that mask other than alpha.
+ *
+ * A contributed pass drawing something blended into the scene states the same thing for its own
+ * pipeline with `SCENE_ALPHA_COVERS`, `SCENE_ALPHA_TRANSMITS` or `SCENE_ALPHA_KEEPS`.
+ */
+
+/** A blended draw that covers the surface by its alpha: `share * (1 - a)`. */
+export const SCENE_ALPHA_COVERS: GPUBlendComponent = {
+  srcFactor: 'zero',
+  dstFactor: 'one-minus-src-alpha',
+  operation: 'add',
+};
+
+/** A draw whose alpha is what gets through it, a transmittance or a revealage: `share * a`. */
+export const SCENE_ALPHA_TRANSMITS: GPUBlendComponent = {
+  srcFactor: 'zero',
+  dstFactor: 'src-alpha',
+  operation: 'add',
+};
+
+/** Light added to the surface, or a layer of it: the share unchanged. */
+export const SCENE_ALPHA_KEEPS: GPUBlendComponent = {
+  srcFactor: 'zero',
+  dstFactor: 'one',
+  operation: 'add',
+};
+
+/**
+ * The same three on WebGL2, as the alpha half of `blendFuncSeparate` beside the colour half a
+ * caller already had. `src` and `dst` are the colour factors.
+ */
+export function blendCovering(gl: WebGL2RenderingContext, src: number, dst: number): void {
+  gl.blendFuncSeparate(src, dst, gl.ZERO, gl.ONE_MINUS_SRC_ALPHA);
+}
+
+/** `SCENE_ALPHA_TRANSMITS` on WebGL2, beside the colour factors `src` and `dst`. */
+export function blendTransmitting(gl: WebGL2RenderingContext, src: number, dst: number): void {
+  gl.blendFuncSeparate(src, dst, gl.ZERO, gl.SRC_ALPHA);
+}
+
+/** `SCENE_ALPHA_KEEPS` on WebGL2, beside the colour factors `src` and `dst`. */
+export function blendKeeping(gl: WebGL2RenderingContext, src: number, dst: number): void {
+  gl.blendFuncSeparate(src, dst, gl.ZERO, gl.ONE);
+}

package/src/render/sdfTextRenderer.ts

@@ -7,6 +7,7 @@ import { compileProgram, uniformLocations } from './shader.ts';
 import { SDF_TEXT_FRAG, SDF_TEXT_VERT } from './shaders/sdfText.ts';
 import type { SurfaceTexture } from './surfaceTexture.ts';
 import { SDF_TEXT_TEXTURE_UNIT } from './lightBudget.ts';
+import { blendCovering } from './sceneCoverage.ts';
 
 /**
  * Text from a signed distance field, on WebGL2.
@@ -144,7 +145,7 @@ export class SdfTextRenderer {
      */
     gl.depthMask(false);
     gl.enable(gl.BLEND);
-    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    blendCovering(gl, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
 
     this.atlas.bind(gl, SDF_TEXT_TEXTURE_UNIT);
 

package/src/render/shaders/depth.ts

@@ -60,12 +60,13 @@ ${CHANNEL_BEND}
 
 #if CUTOUT
 /*
- * **What a cutout caster adds, and where.** The UV at location 5, where every mesh carries it; two
+ * **What a cutout caster adds, and where.** The UV at location 5, where every mesh carries it; three
  * uniforms declared after every other, so no field of the plain variant moves and a binder written
  * against it stays right for this one; and two outputs after vLightPosition, which keeps location 0.
  */
 layout(location = 5) in vec3 aUv;
 uniform vec2 uUvScale;
+uniform vec2 uUvOffset;
 uniform float uAlphaCutout;
 #endif
 
@@ -104,7 +105,7 @@ void main() {
   vLightPosition = uLightViewProj * vec4(bent, world.w);
   gl_Position = vLightPosition;
 #if CUTOUT
-  vUv = vec3(aUv.xy * uUvScale, aUv.z);
+  vUv = vec3(aUv.xy * uUvScale + uUvOffset, aUv.z);
   vAlphaCutout = uAlphaCutout;
 #endif
 #if GLASS

package/src/render/shaders/flat/index.ts

@@ -62,6 +62,11 @@ uniform mat4 uLightViewProj;
  * when no texture is bound.
  */
 uniform vec2 uUvScale;
+/**
+ * Where the texture starts, per axis, added after the scale: \`uv * uUvScale + uUvOffset\`. What
+ * picks a cell of a flipbook or an atlas through the material. See \`SurfaceMaterial.uOffset\`.
+ */
+uniform vec2 uUvOffset;
 
 /*
  * **Placement and tint are declared last of the shared uniforms, and the position is the
@@ -244,7 +249,7 @@ void main() {
   vColor = aColor * tint;
   vEmissive = aEmissive;
   vSpecular = aSpecular;
-  vUv = vec3(aUv.xy * uUvScale, aUv.z);
+  vUv = vec3(aUv.xy * uUvScale + uUvOffset, aUv.z);
   vEmissiveColor = aEmissiveColor;
   vRoughness = aRoughness;
   vGrain = aGrain;

package/src/render/shaders/generated/depth.wgsl.ts

@@ -7,11 +7,11 @@
 
 export const DEPTH_CUTOUT_FRAG_WGSL = "struct Uniforms {\n    uPeelShadowLayer: i32,\n}\n\nvar<private> vUv_1: vec3<f32>;\n@group(0) @binding(34) \nvar uCutoutMap_t: texture_2d_array<f32>;\n@group(0) @binding(35) \nvar uCutoutMap_s: sampler;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vLightPosition_1: vec4<f32>;\n@group(0) @binding(32) \nvar uPreviousShadowMap_t: texture_2d_array<f32>;\n@group(0) @binding(33) \nvar uPreviousShadowMap_s: sampler;\nvar<private> gl_FragCoord_1: vec4<f32>;\nvar<private> vAlphaCutout_1: f32;\n\nfn cutoutAlpha_u0028_f1_u003b_vf2_u003b(alpha: ptr<function, f32>, texels: ptr<function, vec2<f32>>) -> f32 {\n    var dx: vec2<f32>;\n    var dy: vec2<f32>;\n    var level: f32;\n\n    let _e23 = (*texels);\n    let _e24 = dpdx(_e23);\n    dx = _e24;\n    let _e25 = (*texels);\n    let _e26 = dpdy(_e25);\n    dy = _e26;\n    let _e27 = dx;\n    let _e28 = dx;\n    let _e30 = dy;\n    let _e31 = dy;\n    level = max(0f, (0.5f * log2(max(dot(_e27, _e28), dot(_e30, _e31)))));\n    let _e37 = (*alpha);\n    let _e38 = level;\n    return (_e37 * (1f + (_e38 * 0.25f)));\n}\n\nfn main_1() {\n    var at: vec3<f32>;\n    var alpha_1: f32;\n    var param: f32;\n    var param_1: vec2<f32>;\n    var p: vec3<f32>;\n    var uv: vec2<f32>;\n    var previousDepth: f32;\n\n    let _e25 = vUv_1;\n    let _e26 = _e25.xy;\n    let _e28 = vUv_1[2u];\n    at = vec3<f32>(_e26.x, _e26.y, floor((_e28 + 0.5f)));\n    let _e34 = at;\n    let _e40 = textureSample(uCutoutMap_t, uCutoutMap_s, vec2<f32>(_e34.x, _e34.y), i32(_e34.z));\n    let _e41 = vUv_1;\n    let _e43 = textureDimensions(uCutoutMap_t, 0i);\n    param = _e40.w;\n    param_1 = (_e41.xy * vec2<f32>(vec2<i32>(_e43).xy));\n    let _e49 = cutoutAlpha_u0028_f1_u003b_vf2_u003b((&param), (&param_1));\n    alpha_1 = _e49;\n    let _e51 = unnamed.uPeelShadowLayer;\n    if (_e51 != 0i) {\n        let _e53 = vLightPosition_1;\n        let _e56 = vLightPosition_1[3u];\n        p = (_e53.xyz / vec3(_e56));\n        let _e59 = p;\n        uv = ((_e59.xy * 0.5f) + vec2(0.5f));\n        let _e64 = uv;\n        let _e67 = vec3<f32>(_e64.x, _e64.y, 0f);\n        let _e73 = textureSampleLevel(uPreviousShadowMap_t, uPreviousShadowMap_s, vec2<f32>(_e67.x, _e67.y), i32(_e67.z), 0f);\n        previousDepth = _e73.x;\n        let _e76 = gl_FragCoord_1[2u];\n        let _e77 = previousDepth;\n        if (_e76 <= (_e77 + 0.00001f)) {\n            discard;\n        }\n    }\n    let _e80 = alpha_1;\n    let _e81 = vAlphaCutout_1;\n    if (_e80 < _e81) {\n        discard;\n    }\n    return;\n}\n\n@fragment \nfn main(@location(1) vUv: vec3<f32>, @location(0) vLightPosition: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(2) @interpolate(flat) vAlphaCutout: f32) {\n    vUv_1 = vUv;\n    vLightPosition_1 = vLightPosition;\n    gl_FragCoord_1 = gl_FragCoord;\n    vAlphaCutout_1 = vAlphaCutout;\n    main_1();\n}\n";
 
-export const DEPTH_CUTOUT_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f32>,\n    uModel: mat4x4<f32>,\n    uWindDirection: vec2<f32>,\n    uWindSpeed: f32,\n    uWindGust: f32,\n    uWindTime: f32,\n    uWindSpatialPhase: vec2<f32>,\n    uUvScale: vec2<f32>,\n    uAlphaCutout: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(1) member_1: vec3<f32>,\n    @location(2) @interpolate(flat) member_2: f32,\n}\n\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aChannel_1: vec4<f32>;\nvar<private> vLightPosition: vec4<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> vUv: vec3<f32>;\nvar<private> aUv_1: vec3<f32>;\nvar<private> vAlphaCutout: f32;\n\nfn channelBend_u0028_vf3_u003b_f1_u003b(worldPos: ptr<function, vec3<f32>>, sway: ptr<function, f32>) -> vec3<f32> {\n    var phase: f32;\n    var bend: f32;\n\n    let _e27 = (*sway);\n    if (_e27 <= 0f) {\n        let _e29 = (*worldPos);\n        return _e29;\n    }\n    let _e30 = (*worldPos);\n    let _e33 = unnamed.uWindSpatialPhase;\n    let _e36 = unnamed.uWindTime;\n    phase = (dot(_e30.xz, _e33) + _e36);\n    let _e39 = unnamed.uWindSpeed;\n    let _e41 = unnamed.uWindGust;\n    let _e43 = phase;\n    let _e46 = (*sway);\n    bend = (((_e39 + _e41) * sin(_e43)) * _e46);\n    let _e49 = (*worldPos)[0u];\n    let _e52 = unnamed.uWindDirection[0u];\n    let _e53 = bend;\n    let _e57 = (*worldPos)[1u];\n    let _e59 = (*worldPos)[2u];\n    let _e62 = unnamed.uWindDirection[1u];\n    let _e63 = bend;\n    return vec3<f32>((_e49 + (_e52 * _e53)), _e57, (_e59 + (_e62 * _e63)));\n}\n\nfn main_1() {\n    var local: vec4<f32>;\n    var model: mat4x4<f32>;\n    var world: vec4<f32>;\n    var bent: vec3<f32>;\n    var param: vec3<f32>;\n    var param_1: f32;\n\n    let _e29 = aPosition_1;\n    local = vec4<f32>(_e29.x, _e29.y, _e29.z, 1f);\n    let _e35 = unnamed.uModel;\n    model = _e35;\n    let _e36 = model;\n    let _e37 = local;\n    world = (_e36 * _e37);\n    let _e39 = world;\n    param = _e39.xyz;\n    let _e42 = aChannel_1[0u];\n    param_1 = _e42;\n    let _e43 = channelBend_u0028_vf3_u003b_f1_u003b((&param), (&param_1));\n    bent = _e43;\n    let _e45 = unnamed.uLightViewProj;\n    let _e46 = bent;\n    let _e48 = world[3u];\n    vLightPosition = (_e45 * vec4<f32>(_e46.x, _e46.y, _e46.z, _e48));\n    let _e54 = vLightPosition;\n    unnamed_1.gl_Position = _e54;\n    let _e56 = aUv_1;\n    let _e59 = unnamed.uUvScale;\n    let _e60 = (_e56.xy * _e59);\n    let _e62 = aUv_1[2u];\n    vUv = vec3<f32>(_e60.x, _e60.y, _e62);\n    let _e67 = unnamed.uAlphaCutout;\n    vAlphaCutout = _e67;\n    return;\n}\n\n@vertex \nfn main(@location(0) aPosition: vec3<f32>, @location(13) aChannel: vec4<f32>, @location(5) aUv: vec3<f32>) -> VertexOutput {\n    aPosition_1 = aPosition;\n    aChannel_1 = aChannel;\n    aUv_1 = aUv;\n    main_1();\n    let _e12 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e12);\n    let _e14 = vLightPosition;\n    let _e15 = unnamed_1.gl_Position;\n    let _e16 = vUv;\n    let _e17 = vAlphaCutout;\n    return VertexOutput(_e14, _e15, _e16, _e17);\n}\n";
+export const DEPTH_CUTOUT_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f32>,\n    uModel: mat4x4<f32>,\n    uWindDirection: vec2<f32>,\n    uWindSpeed: f32,\n    uWindGust: f32,\n    uWindTime: f32,\n    uWindSpatialPhase: vec2<f32>,\n    uUvScale: vec2<f32>,\n    uUvOffset: vec2<f32>,\n    uAlphaCutout: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(1) member_1: vec3<f32>,\n    @location(2) @interpolate(flat) member_2: f32,\n}\n\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aChannel_1: vec4<f32>;\nvar<private> vLightPosition: vec4<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> vUv: vec3<f32>;\nvar<private> aUv_1: vec3<f32>;\nvar<private> vAlphaCutout: f32;\n\nfn channelBend_u0028_vf3_u003b_f1_u003b(worldPos: ptr<function, vec3<f32>>, sway: ptr<function, f32>) -> vec3<f32> {\n    var phase: f32;\n    var bend: f32;\n\n    let _e28 = (*sway);\n    if (_e28 <= 0f) {\n        let _e30 = (*worldPos);\n        return _e30;\n    }\n    let _e31 = (*worldPos);\n    let _e34 = unnamed.uWindSpatialPhase;\n    let _e37 = unnamed.uWindTime;\n    phase = (dot(_e31.xz, _e34) + _e37);\n    let _e40 = unnamed.uWindSpeed;\n    let _e42 = unnamed.uWindGust;\n    let _e44 = phase;\n    let _e47 = (*sway);\n    bend = (((_e40 + _e42) * sin(_e44)) * _e47);\n    let _e50 = (*worldPos)[0u];\n    let _e53 = unnamed.uWindDirection[0u];\n    let _e54 = bend;\n    let _e58 = (*worldPos)[1u];\n    let _e60 = (*worldPos)[2u];\n    let _e63 = unnamed.uWindDirection[1u];\n    let _e64 = bend;\n    return vec3<f32>((_e50 + (_e53 * _e54)), _e58, (_e60 + (_e63 * _e64)));\n}\n\nfn main_1() {\n    var local: vec4<f32>;\n    var model: mat4x4<f32>;\n    var world: vec4<f32>;\n    var bent: vec3<f32>;\n    var param: vec3<f32>;\n    var param_1: f32;\n\n    let _e30 = aPosition_1;\n    local = vec4<f32>(_e30.x, _e30.y, _e30.z, 1f);\n    let _e36 = unnamed.uModel;\n    model = _e36;\n    let _e37 = model;\n    let _e38 = local;\n    world = (_e37 * _e38);\n    let _e40 = world;\n    param = _e40.xyz;\n    let _e43 = aChannel_1[0u];\n    param_1 = _e43;\n    let _e44 = channelBend_u0028_vf3_u003b_f1_u003b((&param), (&param_1));\n    bent = _e44;\n    let _e46 = unnamed.uLightViewProj;\n    let _e47 = bent;\n    let _e49 = world[3u];\n    vLightPosition = (_e46 * vec4<f32>(_e47.x, _e47.y, _e47.z, _e49));\n    let _e55 = vLightPosition;\n    unnamed_1.gl_Position = _e55;\n    let _e57 = aUv_1;\n    let _e60 = unnamed.uUvScale;\n    let _e63 = unnamed.uUvOffset;\n    let _e64 = ((_e57.xy * _e60) + _e63);\n    let _e66 = aUv_1[2u];\n    vUv = vec3<f32>(_e64.x, _e64.y, _e66);\n    let _e71 = unnamed.uAlphaCutout;\n    vAlphaCutout = _e71;\n    return;\n}\n\n@vertex \nfn main(@location(0) aPosition: vec3<f32>, @location(13) aChannel: vec4<f32>, @location(5) aUv: vec3<f32>) -> VertexOutput {\n    aPosition_1 = aPosition;\n    aChannel_1 = aChannel;\n    aUv_1 = aUv;\n    main_1();\n    let _e12 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e12);\n    let _e14 = vLightPosition;\n    let _e15 = unnamed_1.gl_Position;\n    let _e16 = vUv;\n    let _e17 = vAlphaCutout;\n    return VertexOutput(_e14, _e15, _e16, _e17);\n}\n";
 
 export const DEPTH_FRAG_WGSL = "struct Uniforms {\n    uPeelShadowLayer: i32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vLightPosition_1: vec4<f32>;\n@group(0) @binding(32) \nvar uPreviousShadowMap_t: texture_2d_array<f32>;\n@group(0) @binding(33) \nvar uPreviousShadowMap_s: sampler;\nvar<private> gl_FragCoord_1: vec4<f32>;\n\nfn main_1() {\n    var p: vec3<f32>;\n    var uv: vec2<f32>;\n    var previousDepth: f32;\n\n    let _e16 = unnamed.uPeelShadowLayer;\n    if (_e16 != 0i) {\n        let _e18 = vLightPosition_1;\n        let _e21 = vLightPosition_1[3u];\n        p = (_e18.xyz / vec3(_e21));\n        let _e24 = p;\n        uv = ((_e24.xy * 0.5f) + vec2(0.5f));\n        let _e29 = uv;\n        let _e32 = vec3<f32>(_e29.x, _e29.y, 0f);\n        let _e38 = textureSample(uPreviousShadowMap_t, uPreviousShadowMap_s, vec2<f32>(_e32.x, _e32.y), i32(_e32.z));\n        previousDepth = _e38.x;\n        let _e41 = gl_FragCoord_1[2u];\n        let _e42 = previousDepth;\n        if (_e41 <= (_e42 + 0.00001f)) {\n            discard;\n        }\n    }\n    return;\n}\n\n@fragment \nfn main(@location(0) vLightPosition: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>) {\n    vLightPosition_1 = vLightPosition;\n    gl_FragCoord_1 = gl_FragCoord;\n    main_1();\n}\n";
 
-export const DEPTH_INSTANCED_CUTOUT_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f32>,\n    uUvScale: vec2<f32>,\n    uAlphaCutout: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(1) member_1: vec3<f32>,\n    @location(2) @interpolate(flat) member_2: f32,\n}\n\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aInstanceModel0_1: vec4<f32>;\nvar<private> aInstanceModel1_1: vec4<f32>;\nvar<private> aInstanceModel2_1: vec4<f32>;\nvar<private> aInstanceModel3_1: vec4<f32>;\nvar<private> vLightPosition: vec4<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> vUv: vec3<f32>;\nvar<private> aUv_1: vec3<f32>;\nvar<private> vAlphaCutout: f32;\n\nfn main_1() {\n    var local: vec4<f32>;\n    var model: mat4x4<f32>;\n    var world: vec4<f32>;\n    var bent: vec3<f32>;\n\n    let _e22 = aPosition_1;\n    local = vec4<f32>(_e22.x, _e22.y, _e22.z, 1f);\n    let _e27 = aInstanceModel0_1;\n    let _e28 = aInstanceModel1_1;\n    let _e29 = aInstanceModel2_1;\n    let _e30 = aInstanceModel3_1;\n    model = mat4x4<f32>(vec4<f32>(_e27.x, _e27.y, _e27.z, _e27.w), vec4<f32>(_e28.x, _e28.y, _e28.z, _e28.w), vec4<f32>(_e29.x, _e29.y, _e29.z, _e29.w), vec4<f32>(_e30.x, _e30.y, _e30.z, _e30.w));\n    let _e52 = model;\n    let _e53 = local;\n    world = (_e52 * _e53);\n    let _e55 = world;\n    bent = _e55.xyz;\n    let _e58 = unnamed.uLightViewProj;\n    let _e59 = bent;\n    let _e61 = world[3u];\n    vLightPosition = (_e58 * vec4<f32>(_e59.x, _e59.y, _e59.z, _e61));\n    let _e67 = vLightPosition;\n    unnamed_1.gl_Position = _e67;\n    let _e69 = aUv_1;\n    let _e72 = unnamed.uUvScale;\n    let _e73 = (_e69.xy * _e72);\n    let _e75 = aUv_1[2u];\n    vUv = vec3<f32>(_e73.x, _e73.y, _e75);\n    let _e80 = unnamed.uAlphaCutout;\n    vAlphaCutout = _e80;\n    return;\n}\n\n@vertex \nfn main(@location(0) aPosition: vec3<f32>, @location(11) aInstanceModel0_: vec4<f32>, @location(12) aInstanceModel1_: vec4<f32>, @location(13) aInstanceModel2_: vec4<f32>, @location(14) aInstanceModel3_: vec4<f32>, @location(5) aUv: vec3<f32>) -> VertexOutput {\n    aPosition_1 = aPosition;\n    aInstanceModel0_1 = aInstanceModel0_;\n    aInstanceModel1_1 = aInstanceModel1_;\n    aInstanceModel2_1 = aInstanceModel2_;\n    aInstanceModel3_1 = aInstanceModel3_;\n    aUv_1 = aUv;\n    main_1();\n    let _e18 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e18);\n    let _e20 = vLightPosition;\n    let _e21 = unnamed_1.gl_Position;\n    let _e22 = vUv;\n    let _e23 = vAlphaCutout;\n    return VertexOutput(_e20, _e21, _e22, _e23);\n}\n";
+export const DEPTH_INSTANCED_CUTOUT_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f32>,\n    uUvScale: vec2<f32>,\n    uUvOffset: vec2<f32>,\n    uAlphaCutout: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(1) member_1: vec3<f32>,\n    @location(2) @interpolate(flat) member_2: f32,\n}\n\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aInstanceModel0_1: vec4<f32>;\nvar<private> aInstanceModel1_1: vec4<f32>;\nvar<private> aInstanceModel2_1: vec4<f32>;\nvar<private> aInstanceModel3_1: vec4<f32>;\nvar<private> vLightPosition: vec4<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> vUv: vec3<f32>;\nvar<private> aUv_1: vec3<f32>;\nvar<private> vAlphaCutout: f32;\n\nfn main_1() {\n    var local: vec4<f32>;\n    var model: mat4x4<f32>;\n    var world: vec4<f32>;\n    var bent: vec3<f32>;\n\n    let _e23 = aPosition_1;\n    local = vec4<f32>(_e23.x, _e23.y, _e23.z, 1f);\n    let _e28 = aInstanceModel0_1;\n    let _e29 = aInstanceModel1_1;\n    let _e30 = aInstanceModel2_1;\n    let _e31 = aInstanceModel3_1;\n    model = mat4x4<f32>(vec4<f32>(_e28.x, _e28.y, _e28.z, _e28.w), vec4<f32>(_e29.x, _e29.y, _e29.z, _e29.w), vec4<f32>(_e30.x, _e30.y, _e30.z, _e30.w), vec4<f32>(_e31.x, _e31.y, _e31.z, _e31.w));\n    let _e53 = model;\n    let _e54 = local;\n    world = (_e53 * _e54);\n    let _e56 = world;\n    bent = _e56.xyz;\n    let _e59 = unnamed.uLightViewProj;\n    let _e60 = bent;\n    let _e62 = world[3u];\n    vLightPosition = (_e59 * vec4<f32>(_e60.x, _e60.y, _e60.z, _e62));\n    let _e68 = vLightPosition;\n    unnamed_1.gl_Position = _e68;\n    let _e70 = aUv_1;\n    let _e73 = unnamed.uUvScale;\n    let _e76 = unnamed.uUvOffset;\n    let _e77 = ((_e70.xy * _e73) + _e76);\n    let _e79 = aUv_1[2u];\n    vUv = vec3<f32>(_e77.x, _e77.y, _e79);\n    let _e84 = unnamed.uAlphaCutout;\n    vAlphaCutout = _e84;\n    return;\n}\n\n@vertex \nfn main(@location(0) aPosition: vec3<f32>, @location(11) aInstanceModel0_: vec4<f32>, @location(12) aInstanceModel1_: vec4<f32>, @location(13) aInstanceModel2_: vec4<f32>, @location(14) aInstanceModel3_: vec4<f32>, @location(5) aUv: vec3<f32>) -> VertexOutput {\n    aPosition_1 = aPosition;\n    aInstanceModel0_1 = aInstanceModel0_;\n    aInstanceModel1_1 = aInstanceModel1_;\n    aInstanceModel2_1 = aInstanceModel2_;\n    aInstanceModel3_1 = aInstanceModel3_;\n    aUv_1 = aUv;\n    main_1();\n    let _e18 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e18);\n    let _e20 = vLightPosition;\n    let _e21 = unnamed_1.gl_Position;\n    let _e22 = vUv;\n    let _e23 = vAlphaCutout;\n    return VertexOutput(_e20, _e21, _e22, _e23);\n}\n";
 
 export const DEPTH_INSTANCED_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f32>,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aInstanceModel0_1: vec4<f32>;\nvar<private> aInstanceModel1_1: vec4<f32>;\nvar<private> aInstanceModel2_1: vec4<f32>;\nvar<private> aInstanceModel3_1: vec4<f32>;\nvar<private> vLightPosition: vec4<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\n\nfn main_1() {\n    var local: vec4<f32>;\n    var model: mat4x4<f32>;\n    var world: vec4<f32>;\n    var bent: vec3<f32>;\n\n    let _e16 = aPosition_1;\n    local = vec4<f32>(_e16.x, _e16.y, _e16.z, 1f);\n    let _e21 = aInstanceModel0_1;\n    let _e22 = aInstanceModel1_1;\n    let _e23 = aInstanceModel2_1;\n    let _e24 = aInstanceModel3_1;\n    model = mat4x4<f32>(vec4<f32>(_e21.x, _e21.y, _e21.z, _e21.w), vec4<f32>(_e22.x, _e22.y, _e22.z, _e22.w), vec4<f32>(_e23.x, _e23.y, _e23.z, _e23.w), vec4<f32>(_e24.x, _e24.y, _e24.z, _e24.w));\n    let _e46 = model;\n    let _e47 = local;\n    world = (_e46 * _e47);\n    let _e49 = world;\n    bent = _e49.xyz;\n    let _e52 = unnamed.uLightViewProj;\n    let _e53 = bent;\n    let _e55 = world[3u];\n    vLightPosition = (_e52 * vec4<f32>(_e53.x, _e53.y, _e53.z, _e55));\n    let _e61 = vLightPosition;\n    unnamed_1.gl_Position = _e61;\n    return;\n}\n\n@vertex \nfn main(@location(0) aPosition: vec3<f32>, @location(11) aInstanceModel0_: vec4<f32>, @location(12) aInstanceModel1_: vec4<f32>, @location(13) aInstanceModel2_: vec4<f32>, @location(14) aInstanceModel3_: vec4<f32>) -> VertexOutput {\n    aPosition_1 = aPosition;\n    aInstanceModel0_1 = aInstanceModel0_;\n    aInstanceModel1_1 = aInstanceModel1_;\n    aInstanceModel2_1 = aInstanceModel2_;\n    aInstanceModel3_1 = aInstanceModel3_;\n    main_1();\n    let _e14 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e14);\n    let _e16 = vLightPosition;\n    let _e17 = unnamed_1.gl_Position;\n    return VertexOutput(_e16, _e17);\n}\n";
 
@@ -21,11 +21,11 @@ export const DEPTH_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f3
 
 export const GLASS_TINT_CUTOUT_FRAG_WGSL = "struct Uniforms {\n    uGlassPane: vec4<f32>,\n    uGlassLight: vec4<f32>,\n}\n\nvar<private> vUv_1: vec3<f32>;\n@group(0) @binding(32) \nvar uCutoutMap_t: texture_2d_array<f32>;\n@group(0) @binding(33) \nvar uCutoutMap_s: sampler;\nvar<private> vGlassWorld_1: vec3<f32>;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> outTint: vec4<f32>;\nvar<private> vAlphaCutout_1: f32;\nvar<private> vLightPosition_1: vec4<f32>;\n\nfn cutoutAlpha_u0028_f1_u003b_vf2_u003b(alpha: ptr<function, f32>, texels: ptr<function, vec2<f32>>) -> f32 {\n    var dx: vec2<f32>;\n    var dy: vec2<f32>;\n    var level: f32;\n\n    let _e24 = (*texels);\n    let _e25 = dpdx(_e24);\n    dx = _e25;\n    let _e26 = (*texels);\n    let _e27 = dpdy(_e26);\n    dy = _e27;\n    let _e28 = dx;\n    let _e29 = dx;\n    let _e31 = dy;\n    let _e32 = dy;\n    level = max(0f, (0.5f * log2(max(dot(_e28, _e29), dot(_e31, _e32)))));\n    let _e38 = (*alpha);\n    let _e39 = level;\n    return (_e38 * (1f + (_e39 * 0.25f)));\n}\n\nfn main_1() {\n    var at: vec3<f32>;\n    var alpha_1: f32;\n    var param: f32;\n    var param_1: vec2<f32>;\n    var n: vec3<f32>;\n    var toLight: vec3<f32>;\n    var local: vec3<f32>;\n    var cosLight: f32;\n    var reflected: f32;\n\n    let _e28 = vUv_1;\n    let _e29 = _e28.xy;\n    let _e31 = vUv_1[2u];\n    at = vec3<f32>(_e29.x, _e29.y, floor((_e31 + 0.5f)));\n    let _e37 = at;\n    let _e43 = textureSample(uCutoutMap_t, uCutoutMap_s, vec2<f32>(_e37.x, _e37.y), i32(_e37.z));\n    let _e44 = vUv_1;\n    let _e46 = textureDimensions(uCutoutMap_t, 0i);\n    param = _e43.w;\n    param_1 = (_e44.xy * vec2<f32>(vec2<i32>(_e46).xy));\n    let _e52 = cutoutAlpha_u0028_f1_u003b_vf2_u003b((&param), (&param_1));\n    alpha_1 = _e52;\n    let _e53 = vGlassWorld_1;\n    let _e54 = dpdx(_e53);\n    let _e55 = vGlassWorld_1;\n    let _e56 = dpdy(_e55);\n    n = normalize(cross(_e54, _e56));\n    let _e61 = unnamed.uGlassLight[3u];\n    if (_e61 > 0.5f) {\n        let _e64 = unnamed.uGlassLight;\n        let _e66 = vGlassWorld_1;\n        local = normalize((_e64.xyz - _e66));\n    } else {\n        let _e70 = unnamed.uGlassLight;\n        local = _e70.xyz;\n    }\n    let _e72 = local;\n    toLight = _e72;\n    let _e73 = n;\n    let _e74 = toLight;\n    cosLight = abs(dot(_e73, _e74));\n    let _e77 = cosLight;\n    reflected = (0.04f + (0.96f * pow((1f - _e77), 5f)));\n    let _e83 = unnamed.uGlassPane;\n    let _e85 = reflected;\n    let _e87 = (_e83.xyz * (1f - _e85));\n    let _e90 = unnamed.uGlassPane[3u];\n    outTint = vec4<f32>(_e87.x, _e87.y, _e87.z, _e90);\n    let _e95 = alpha_1;\n    let _e96 = vAlphaCutout_1;\n    if (_e95 < _e96) {\n        discard;\n    }\n    return;\n}\n\n@fragment \nfn main(@location(1) vUv: vec3<f32>, @location(3) vGlassWorld: vec3<f32>, @location(2) @interpolate(flat) vAlphaCutout: f32, @location(0) vLightPosition: vec4<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    vGlassWorld_1 = vGlassWorld;\n    vAlphaCutout_1 = vAlphaCutout;\n    vLightPosition_1 = vLightPosition;\n    main_1();\n    let _e9 = outTint;\n    return _e9;\n}\n";
 
-export const GLASS_TINT_CUTOUT_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f32>,\n    uModel: mat4x4<f32>,\n    uWindDirection: vec2<f32>,\n    uWindSpeed: f32,\n    uWindGust: f32,\n    uWindTime: f32,\n    uWindSpatialPhase: vec2<f32>,\n    uUvScale: vec2<f32>,\n    uAlphaCutout: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(1) member_1: vec3<f32>,\n    @location(2) @interpolate(flat) member_2: f32,\n    @location(3) member_3: vec3<f32>,\n}\n\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aChannel_1: vec4<f32>;\nvar<private> vLightPosition: vec4<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> vUv: vec3<f32>;\nvar<private> aUv_1: vec3<f32>;\nvar<private> vAlphaCutout: f32;\nvar<private> vGlassWorld: vec3<f32>;\n\nfn channelBend_u0028_vf3_u003b_f1_u003b(worldPos: ptr<function, vec3<f32>>, sway: ptr<function, f32>) -> vec3<f32> {\n    var phase: f32;\n    var bend: f32;\n\n    let _e28 = (*sway);\n    if (_e28 <= 0f) {\n        let _e30 = (*worldPos);\n        return _e30;\n    }\n    let _e31 = (*worldPos);\n    let _e34 = unnamed.uWindSpatialPhase;\n    let _e37 = unnamed.uWindTime;\n    phase = (dot(_e31.xz, _e34) + _e37);\n    let _e40 = unnamed.uWindSpeed;\n    let _e42 = unnamed.uWindGust;\n    let _e44 = phase;\n    let _e47 = (*sway);\n    bend = (((_e40 + _e42) * sin(_e44)) * _e47);\n    let _e50 = (*worldPos)[0u];\n    let _e53 = unnamed.uWindDirection[0u];\n    let _e54 = bend;\n    let _e58 = (*worldPos)[1u];\n    let _e60 = (*worldPos)[2u];\n    let _e63 = unnamed.uWindDirection[1u];\n    let _e64 = bend;\n    return vec3<f32>((_e50 + (_e53 * _e54)), _e58, (_e60 + (_e63 * _e64)));\n}\n\nfn main_1() {\n    var local: vec4<f32>;\n    var model: mat4x4<f32>;\n    var world: vec4<f32>;\n    var bent: vec3<f32>;\n    var param: vec3<f32>;\n    var param_1: f32;\n\n    let _e30 = aPosition_1;\n    local = vec4<f32>(_e30.x, _e30.y, _e30.z, 1f);\n    let _e36 = unnamed.uModel;\n    model = _e36;\n    let _e37 = model;\n    let _e38 = local;\n    world = (_e37 * _e38);\n    let _e40 = world;\n    param = _e40.xyz;\n    let _e43 = aChannel_1[0u];\n    param_1 = _e43;\n    let _e44 = channelBend_u0028_vf3_u003b_f1_u003b((&param), (&param_1));\n    bent = _e44;\n    let _e46 = unnamed.uLightViewProj;\n    let _e47 = bent;\n    let _e49 = world[3u];\n    vLightPosition = (_e46 * vec4<f32>(_e47.x, _e47.y, _e47.z, _e49));\n    let _e55 = vLightPosition;\n    unnamed_1.gl_Position = _e55;\n    let _e57 = aUv_1;\n    let _e60 = unnamed.uUvScale;\n    let _e61 = (_e57.xy * _e60);\n    let _e63 = aUv_1[2u];\n    vUv = vec3<f32>(_e61.x, _e61.y, _e63);\n    let _e68 = unnamed.uAlphaCutout;\n    vAlphaCutout = _e68;\n    let _e69 = bent;\n    vGlassWorld = _e69;\n    return;\n}\n\n@vertex \nfn main(@location(0) aPosition: vec3<f32>, @location(13) aChannel: vec4<f32>, @location(5) aUv: vec3<f32>) -> VertexOutput {\n    aPosition_1 = aPosition;\n    aChannel_1 = aChannel;\n    aUv_1 = aUv;\n    main_1();\n    let _e13 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e13);\n    let _e15 = vLightPosition;\n    let _e16 = unnamed_1.gl_Position;\n    let _e17 = vUv;\n    let _e18 = vAlphaCutout;\n    let _e19 = vGlassWorld;\n    return VertexOutput(_e15, _e16, _e17, _e18, _e19);\n}\n";
+export const GLASS_TINT_CUTOUT_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f32>,\n    uModel: mat4x4<f32>,\n    uWindDirection: vec2<f32>,\n    uWindSpeed: f32,\n    uWindGust: f32,\n    uWindTime: f32,\n    uWindSpatialPhase: vec2<f32>,\n    uUvScale: vec2<f32>,\n    uUvOffset: vec2<f32>,\n    uAlphaCutout: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(1) member_1: vec3<f32>,\n    @location(2) @interpolate(flat) member_2: f32,\n    @location(3) member_3: vec3<f32>,\n}\n\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aChannel_1: vec4<f32>;\nvar<private> vLightPosition: vec4<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> vUv: vec3<f32>;\nvar<private> aUv_1: vec3<f32>;\nvar<private> vAlphaCutout: f32;\nvar<private> vGlassWorld: vec3<f32>;\n\nfn channelBend_u0028_vf3_u003b_f1_u003b(worldPos: ptr<function, vec3<f32>>, sway: ptr<function, f32>) -> vec3<f32> {\n    var phase: f32;\n    var bend: f32;\n\n    let _e29 = (*sway);\n    if (_e29 <= 0f) {\n        let _e31 = (*worldPos);\n        return _e31;\n    }\n    let _e32 = (*worldPos);\n    let _e35 = unnamed.uWindSpatialPhase;\n    let _e38 = unnamed.uWindTime;\n    phase = (dot(_e32.xz, _e35) + _e38);\n    let _e41 = unnamed.uWindSpeed;\n    let _e43 = unnamed.uWindGust;\n    let _e45 = phase;\n    let _e48 = (*sway);\n    bend = (((_e41 + _e43) * sin(_e45)) * _e48);\n    let _e51 = (*worldPos)[0u];\n    let _e54 = unnamed.uWindDirection[0u];\n    let _e55 = bend;\n    let _e59 = (*worldPos)[1u];\n    let _e61 = (*worldPos)[2u];\n    let _e64 = unnamed.uWindDirection[1u];\n    let _e65 = bend;\n    return vec3<f32>((_e51 + (_e54 * _e55)), _e59, (_e61 + (_e64 * _e65)));\n}\n\nfn main_1() {\n    var local: vec4<f32>;\n    var model: mat4x4<f32>;\n    var world: vec4<f32>;\n    var bent: vec3<f32>;\n    var param: vec3<f32>;\n    var param_1: f32;\n\n    let _e31 = aPosition_1;\n    local = vec4<f32>(_e31.x, _e31.y, _e31.z, 1f);\n    let _e37 = unnamed.uModel;\n    model = _e37;\n    let _e38 = model;\n    let _e39 = local;\n    world = (_e38 * _e39);\n    let _e41 = world;\n    param = _e41.xyz;\n    let _e44 = aChannel_1[0u];\n    param_1 = _e44;\n    let _e45 = channelBend_u0028_vf3_u003b_f1_u003b((&param), (&param_1));\n    bent = _e45;\n    let _e47 = unnamed.uLightViewProj;\n    let _e48 = bent;\n    let _e50 = world[3u];\n    vLightPosition = (_e47 * vec4<f32>(_e48.x, _e48.y, _e48.z, _e50));\n    let _e56 = vLightPosition;\n    unnamed_1.gl_Position = _e56;\n    let _e58 = aUv_1;\n    let _e61 = unnamed.uUvScale;\n    let _e64 = unnamed.uUvOffset;\n    let _e65 = ((_e58.xy * _e61) + _e64);\n    let _e67 = aUv_1[2u];\n    vUv = vec3<f32>(_e65.x, _e65.y, _e67);\n    let _e72 = unnamed.uAlphaCutout;\n    vAlphaCutout = _e72;\n    let _e73 = bent;\n    vGlassWorld = _e73;\n    return;\n}\n\n@vertex \nfn main(@location(0) aPosition: vec3<f32>, @location(13) aChannel: vec4<f32>, @location(5) aUv: vec3<f32>) -> VertexOutput {\n    aPosition_1 = aPosition;\n    aChannel_1 = aChannel;\n    aUv_1 = aUv;\n    main_1();\n    let _e13 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e13);\n    let _e15 = vLightPosition;\n    let _e16 = unnamed_1.gl_Position;\n    let _e17 = vUv;\n    let _e18 = vAlphaCutout;\n    let _e19 = vGlassWorld;\n    return VertexOutput(_e15, _e16, _e17, _e18, _e19);\n}\n";
 
 export const GLASS_TINT_FRAG_WGSL = "struct Uniforms {\n    uGlassPane: vec4<f32>,\n    uGlassLight: vec4<f32>,\n}\n\nvar<private> vGlassWorld_1: vec3<f32>;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> outTint: vec4<f32>;\nvar<private> vLightPosition_1: vec4<f32>;\n\nfn main_1() {\n    var n: vec3<f32>;\n    var toLight: vec3<f32>;\n    var local: vec3<f32>;\n    var cosLight: f32;\n    var reflected: f32;\n\n    let _e17 = vGlassWorld_1;\n    let _e18 = dpdx(_e17);\n    let _e19 = vGlassWorld_1;\n    let _e20 = dpdy(_e19);\n    n = normalize(cross(_e18, _e20));\n    let _e25 = unnamed.uGlassLight[3u];\n    if (_e25 > 0.5f) {\n        let _e28 = unnamed.uGlassLight;\n        let _e30 = vGlassWorld_1;\n        local = normalize((_e28.xyz - _e30));\n    } else {\n        let _e34 = unnamed.uGlassLight;\n        local = _e34.xyz;\n    }\n    let _e36 = local;\n    toLight = _e36;\n    let _e37 = n;\n    let _e38 = toLight;\n    cosLight = abs(dot(_e37, _e38));\n    let _e41 = cosLight;\n    reflected = (0.04f + (0.96f * pow((1f - _e41), 5f)));\n    let _e47 = unnamed.uGlassPane;\n    let _e49 = reflected;\n    let _e51 = (_e47.xyz * (1f - _e49));\n    let _e54 = unnamed.uGlassPane[3u];\n    outTint = vec4<f32>(_e51.x, _e51.y, _e51.z, _e54);\n    return;\n}\n\n@fragment \nfn main(@location(1) vGlassWorld: vec3<f32>, @location(0) vLightPosition: vec4<f32>) -> @location(0) vec4<f32> {\n    vGlassWorld_1 = vGlassWorld;\n    vLightPosition_1 = vLightPosition;\n    main_1();\n    let _e5 = outTint;\n    return _e5;\n}\n";
 
-export const GLASS_TINT_INSTANCED_CUTOUT_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f32>,\n    uUvScale: vec2<f32>,\n    uAlphaCutout: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(1) member_1: vec3<f32>,\n    @location(2) @interpolate(flat) member_2: f32,\n    @location(3) member_3: vec3<f32>,\n}\n\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aInstanceModel0_1: vec4<f32>;\nvar<private> aInstanceModel1_1: vec4<f32>;\nvar<private> aInstanceModel2_1: vec4<f32>;\nvar<private> aInstanceModel3_1: vec4<f32>;\nvar<private> vLightPosition: vec4<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> vUv: vec3<f32>;\nvar<private> aUv_1: vec3<f32>;\nvar<private> vAlphaCutout: f32;\nvar<private> vGlassWorld: vec3<f32>;\n\nfn main_1() {\n    var local: vec4<f32>;\n    var model: mat4x4<f32>;\n    var world: vec4<f32>;\n    var bent: vec3<f32>;\n\n    let _e23 = aPosition_1;\n    local = vec4<f32>(_e23.x, _e23.y, _e23.z, 1f);\n    let _e28 = aInstanceModel0_1;\n    let _e29 = aInstanceModel1_1;\n    let _e30 = aInstanceModel2_1;\n    let _e31 = aInstanceModel3_1;\n    model = mat4x4<f32>(vec4<f32>(_e28.x, _e28.y, _e28.z, _e28.w), vec4<f32>(_e29.x, _e29.y, _e29.z, _e29.w), vec4<f32>(_e30.x, _e30.y, _e30.z, _e30.w), vec4<f32>(_e31.x, _e31.y, _e31.z, _e31.w));\n    let _e53 = model;\n    let _e54 = local;\n    world = (_e53 * _e54);\n    let _e56 = world;\n    bent = _e56.xyz;\n    let _e59 = unnamed.uLightViewProj;\n    let _e60 = bent;\n    let _e62 = world[3u];\n    vLightPosition = (_e59 * vec4<f32>(_e60.x, _e60.y, _e60.z, _e62));\n    let _e68 = vLightPosition;\n    unnamed_1.gl_Position = _e68;\n    let _e70 = aUv_1;\n    let _e73 = unnamed.uUvScale;\n    let _e74 = (_e70.xy * _e73);\n    let _e76 = aUv_1[2u];\n    vUv = vec3<f32>(_e74.x, _e74.y, _e76);\n    let _e81 = unnamed.uAlphaCutout;\n    vAlphaCutout = _e81;\n    let _e82 = bent;\n    vGlassWorld = _e82;\n    return;\n}\n\n@vertex \nfn main(@location(0) aPosition: vec3<f32>, @location(11) aInstanceModel0_: vec4<f32>, @location(12) aInstanceModel1_: vec4<f32>, @location(13) aInstanceModel2_: vec4<f32>, @location(14) aInstanceModel3_: vec4<f32>, @location(5) aUv: vec3<f32>) -> VertexOutput {\n    aPosition_1 = aPosition;\n    aInstanceModel0_1 = aInstanceModel0_;\n    aInstanceModel1_1 = aInstanceModel1_;\n    aInstanceModel2_1 = aInstanceModel2_;\n    aInstanceModel3_1 = aInstanceModel3_;\n    aUv_1 = aUv;\n    main_1();\n    let _e19 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e19);\n    let _e21 = vLightPosition;\n    let _e22 = unnamed_1.gl_Position;\n    let _e23 = vUv;\n    let _e24 = vAlphaCutout;\n    let _e25 = vGlassWorld;\n    return VertexOutput(_e21, _e22, _e23, _e24, _e25);\n}\n";
+export const GLASS_TINT_INSTANCED_CUTOUT_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f32>,\n    uUvScale: vec2<f32>,\n    uUvOffset: vec2<f32>,\n    uAlphaCutout: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(1) member_1: vec3<f32>,\n    @location(2) @interpolate(flat) member_2: f32,\n    @location(3) member_3: vec3<f32>,\n}\n\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aInstanceModel0_1: vec4<f32>;\nvar<private> aInstanceModel1_1: vec4<f32>;\nvar<private> aInstanceModel2_1: vec4<f32>;\nvar<private> aInstanceModel3_1: vec4<f32>;\nvar<private> vLightPosition: vec4<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> vUv: vec3<f32>;\nvar<private> aUv_1: vec3<f32>;\nvar<private> vAlphaCutout: f32;\nvar<private> vGlassWorld: vec3<f32>;\n\nfn main_1() {\n    var local: vec4<f32>;\n    var model: mat4x4<f32>;\n    var world: vec4<f32>;\n    var bent: vec3<f32>;\n\n    let _e24 = aPosition_1;\n    local = vec4<f32>(_e24.x, _e24.y, _e24.z, 1f);\n    let _e29 = aInstanceModel0_1;\n    let _e30 = aInstanceModel1_1;\n    let _e31 = aInstanceModel2_1;\n    let _e32 = aInstanceModel3_1;\n    model = mat4x4<f32>(vec4<f32>(_e29.x, _e29.y, _e29.z, _e29.w), vec4<f32>(_e30.x, _e30.y, _e30.z, _e30.w), vec4<f32>(_e31.x, _e31.y, _e31.z, _e31.w), vec4<f32>(_e32.x, _e32.y, _e32.z, _e32.w));\n    let _e54 = model;\n    let _e55 = local;\n    world = (_e54 * _e55);\n    let _e57 = world;\n    bent = _e57.xyz;\n    let _e60 = unnamed.uLightViewProj;\n    let _e61 = bent;\n    let _e63 = world[3u];\n    vLightPosition = (_e60 * vec4<f32>(_e61.x, _e61.y, _e61.z, _e63));\n    let _e69 = vLightPosition;\n    unnamed_1.gl_Position = _e69;\n    let _e71 = aUv_1;\n    let _e74 = unnamed.uUvScale;\n    let _e77 = unnamed.uUvOffset;\n    let _e78 = ((_e71.xy * _e74) + _e77);\n    let _e80 = aUv_1[2u];\n    vUv = vec3<f32>(_e78.x, _e78.y, _e80);\n    let _e85 = unnamed.uAlphaCutout;\n    vAlphaCutout = _e85;\n    let _e86 = bent;\n    vGlassWorld = _e86;\n    return;\n}\n\n@vertex \nfn main(@location(0) aPosition: vec3<f32>, @location(11) aInstanceModel0_: vec4<f32>, @location(12) aInstanceModel1_: vec4<f32>, @location(13) aInstanceModel2_: vec4<f32>, @location(14) aInstanceModel3_: vec4<f32>, @location(5) aUv: vec3<f32>) -> VertexOutput {\n    aPosition_1 = aPosition;\n    aInstanceModel0_1 = aInstanceModel0_;\n    aInstanceModel1_1 = aInstanceModel1_;\n    aInstanceModel2_1 = aInstanceModel2_;\n    aInstanceModel3_1 = aInstanceModel3_;\n    aUv_1 = aUv;\n    main_1();\n    let _e19 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e19);\n    let _e21 = vLightPosition;\n    let _e22 = unnamed_1.gl_Position;\n    let _e23 = vUv;\n    let _e24 = vAlphaCutout;\n    let _e25 = vGlassWorld;\n    return VertexOutput(_e21, _e22, _e23, _e24, _e25);\n}\n";
 
 export const GLASS_TINT_INSTANCED_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f32>,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(1) member_1: vec3<f32>,\n}\n\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aInstanceModel0_1: vec4<f32>;\nvar<private> aInstanceModel1_1: vec4<f32>;\nvar<private> aInstanceModel2_1: vec4<f32>;\nvar<private> aInstanceModel3_1: vec4<f32>;\nvar<private> vLightPosition: vec4<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> vGlassWorld: vec3<f32>;\n\nfn main_1() {\n    var local: vec4<f32>;\n    var model: mat4x4<f32>;\n    var world: vec4<f32>;\n    var bent: vec3<f32>;\n\n    let _e17 = aPosition_1;\n    local = vec4<f32>(_e17.x, _e17.y, _e17.z, 1f);\n    let _e22 = aInstanceModel0_1;\n    let _e23 = aInstanceModel1_1;\n    let _e24 = aInstanceModel2_1;\n    let _e25 = aInstanceModel3_1;\n    model = mat4x4<f32>(vec4<f32>(_e22.x, _e22.y, _e22.z, _e22.w), vec4<f32>(_e23.x, _e23.y, _e23.z, _e23.w), vec4<f32>(_e24.x, _e24.y, _e24.z, _e24.w), vec4<f32>(_e25.x, _e25.y, _e25.z, _e25.w));\n    let _e47 = model;\n    let _e48 = local;\n    world = (_e47 * _e48);\n    let _e50 = world;\n    bent = _e50.xyz;\n    let _e53 = unnamed.uLightViewProj;\n    let _e54 = bent;\n    let _e56 = world[3u];\n    vLightPosition = (_e53 * vec4<f32>(_e54.x, _e54.y, _e54.z, _e56));\n    let _e62 = vLightPosition;\n    unnamed_1.gl_Position = _e62;\n    let _e64 = bent;\n    vGlassWorld = _e64;\n    return;\n}\n\n@vertex \nfn main(@location(0) aPosition: vec3<f32>, @location(11) aInstanceModel0_: vec4<f32>, @location(12) aInstanceModel1_: vec4<f32>, @location(13) aInstanceModel2_: vec4<f32>, @location(14) aInstanceModel3_: vec4<f32>) -> VertexOutput {\n    aPosition_1 = aPosition;\n    aInstanceModel0_1 = aInstanceModel0_;\n    aInstanceModel1_1 = aInstanceModel1_;\n    aInstanceModel2_1 = aInstanceModel2_;\n    aInstanceModel3_1 = aInstanceModel3_;\n    main_1();\n    let _e15 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e15);\n    let _e17 = vLightPosition;\n    let _e18 = unnamed_1.gl_Position;\n    let _e19 = vGlassWorld;\n    return VertexOutput(_e17, _e18, _e19);\n}\n";
 
@@ -64,7 +64,7 @@ export const DEPTH_BINDINGS = {
   },
   "DEPTH_CUTOUT_VERT": {
     "uniforms": 0,
-    "uniformSize": 176,
+    "uniformSize": 192,
     "fields": {
       "uLightViewProj": {
         "offset": 0,
@@ -106,8 +106,13 @@ export const DEPTH_BINDINGS = {
         "size": 8,
         "type": "vec2"
       },
-      "uAlphaCutout": {
+      "uUvOffset": {
         "offset": 168,
+        "size": 8,
+        "type": "vec2"
+      },
+      "uAlphaCutout": {
+        "offset": 176,
         "size": 4,
         "type": "float"
       }
@@ -134,7 +139,7 @@ export const DEPTH_BINDINGS = {
   },
   "DEPTH_INSTANCED_CUTOUT_VERT": {
     "uniforms": 0,
-    "uniformSize": 80,
+    "uniformSize": 96,
     "fields": {
       "uLightViewProj": {
         "offset": 0,
@@ -146,8 +151,13 @@ export const DEPTH_BINDINGS = {
         "size": 8,
         "type": "vec2"
       },
-      "uAlphaCutout": {
+      "uUvOffset": {
         "offset": 72,
+        "size": 8,
+        "type": "vec2"
+      },
+      "uAlphaCutout": {
+        "offset": 80,
         "size": 4,
         "type": "float"
       }
@@ -281,7 +291,7 @@ export const DEPTH_BINDINGS = {
   },
   "GLASS_TINT_CUTOUT_VERT": {
     "uniforms": 0,
-    "uniformSize": 176,
+    "uniformSize": 192,
     "fields": {
       "uLightViewProj": {
         "offset": 0,
@@ -323,8 +333,13 @@ export const DEPTH_BINDINGS = {
         "size": 8,
         "type": "vec2"
       },
-      "uAlphaCutout": {
+      "uUvOffset": {
         "offset": 168,
+        "size": 8,
+        "type": "vec2"
+      },
+      "uAlphaCutout": {
+        "offset": 176,
         "size": 4,
         "type": "float"
       }
@@ -350,7 +365,7 @@ export const DEPTH_BINDINGS = {
   },
   "GLASS_TINT_INSTANCED_CUTOUT_VERT": {
     "uniforms": 0,
-    "uniformSize": 80,
+    "uniformSize": 96,
     "fields": {
       "uLightViewProj": {
         "offset": 0,
@@ -362,8 +377,13 @@ export const DEPTH_BINDINGS = {
         "size": 8,
         "type": "vec2"
       },
-      "uAlphaCutout": {
+      "uUvOffset": {
         "offset": 72,
+        "size": 8,
+        "type": "vec2"
+      },
+      "uAlphaCutout": {
+        "offset": 80,
         "size": 4,
         "type": "float"
       }