@driftengine/core 4.9.0 → 4.10.0

package/dist/render/mesh.js

@@ -136,6 +136,11 @@ export class Mesh {
     isSkinnedEight;
     /** Whether it has texture coordinates, without which a material's maps read one texel. */
     hasUvs;
+    /**
+     * Whether it carries a grain lane, which is where second coordinates ride (`lightmap.ts`): what
+     * a bone animation reads each vertex's bone from.
+     */
+    hasGrain;
     /** How many vertices it has, which a cloth binding is checked against. */
     vertexCount;
     /**
@@ -304,6 +309,7 @@ export class Mesh {
         else {
             this.attachAttribute(gl, ATTR_TANGENT, data.tangents, 4);
         }
+        this.hasGrain = data.grain !== undefined;
         if (data.grain === undefined) {
             gl.disableVertexAttribArray(ATTR_GRAIN);
             this.constants.push({ location: ATTR_GRAIN, value: ABSENT_ATTRIBUTE['grain'] });

package/dist/render/pointLightSelection.d.ts

@@ -71,10 +71,10 @@ export interface PointLightSource {
     inLightField?: boolean;
     /**
      * How the light fades with distance when it names its own way: `(1 - (d/R)^2)^n` with no distance
-     * term, `R` its radius and `n` this. Unreal's falloff for a light without inverse-square falloff,
-     * so a rig authored there — a fill of brightness 160 across 164 m, a key at exponent 8 — lights
-     * the space it was authored for rather than one that ends a few metres out. Absent or 0, the
-     * frame's own falloff (`pointLightFalloff`), which is every light before 4.8.7.
+     * term, `R` its radius and `n` this. The usual falloff for a light without inverse-square
+     * falloff, so a rig authored that way — a fill of brightness 160 across 164 m, a key at exponent
+     * 8 — lights the space it was authored for rather than one that ends a few metres out. Absent or
+     * 0, the frame's own falloff (`pointLightFalloff`), which is every light before 4.8.7.
      */
     falloffExponent?: number;
 }

package/dist/render/screenSpaceReflection.d.ts

@@ -179,7 +179,8 @@ export interface ReflectiveSurfaceOptions extends DecalBox {
      * box. Each pixel then returns `F0 · A + B` of what its ray finds, the split-sum environment BRDF
      * at its own view and `roughness` — Karis's fit, the one the lit stage reflects its environment
      * by — so a floor returns more toward the horizon than underfoot, and the share follows the
-     * camera as Unreal weighs its reflections. **False by default**, the one share as before.
+     * camera as a physically based renderer weighs its reflections. **False by default**, the one
+     * share as before.
      *
      * **What it gives up**: the pass has no material buffer, so the roughness and F0 are the box's,
      * not each pixel's, and nothing occludes the reflection where the lit stage's ambient occlusion

package/dist/render/shaders/boneAnimation.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The vertex-stage bone animation: a crowd instance's vertex turned and placed by its bone, at its
+ * instance's moment of the clip — the GLSL of `boneAnimation.ts`'s `animateBoneVertex`, line for
+ * line. Shared by the lit stage and the depth stage, so a crowd's shadow moves with it.
+ *
+ * **Three textures, read by index and never filtered**: the places and the turns, a texel a bone a
+ * frame (bones across, frames down, sizes read with `textureSize` so no uniform says them), and the
+ * batch's clocks, two floats an instance wrapped onto rows, read at `gl_InstanceID`. The clip's speed
+ * and its bone scale are the one uniform, `uBoneClip`; the scene's time is the pass's `uSceneTime`.
+ *
+ * **The bone is read from the grain lane**, which is where a mesh's second coordinates ride, stored
+ * as `-1 - u` (`lightmap.ts`). An instanced batch reads no grain of its own from that lane: a crowd's
+ * mesh carries second coordinates, which is what makes it one.
+ *
+ * Integer arithmetic for the lattice, by the 2026-09-20 rule, except where a float is clamped onto
+ * it: the first frame is `min(floor(wrapped), frames - 1)`, so the wrap that division-by-reciprocal
+ * lands on `frames` is the last frame fully blended into the first — the first, which is right.
+ */
+export declare const BONE_ANIMATION_GLSL = "\nuniform highp sampler2D uBonePlaces;\nuniform highp sampler2D uBoneTurns;\nuniform highp sampler2D uInstanceClocks;\n/** x the clip's frames a second, y how many bones one unit of the second coordinates' u counts. */\nuniform vec2 uBoneClip;\n\n/** v turned by the unit quaternion q. */\nvec3 boneTurn(vec4 q, vec3 v) {\n  return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + q.w * v);\n}\n\n/**\n * Where the clip puts this vertex, from its place at rest; its normal and tangent turned with it.\n */\nvec3 boneAnimate(vec3 position, inout vec3 normal, inout vec3 tangent) {\n  ivec2 size = textureSize(uBonePlaces, 0);\n  int clocksWidth = textureSize(uInstanceClocks, 0).x;\n  vec2 clock = texelFetch(\n    uInstanceClocks,\n    ivec2(gl_InstanceID % clocksWidth, gl_InstanceID / clocksWidth),\n    0\n  ).xy;\n  float moment = (uSceneTime * clock.y + clock.x) * uBoneClip.x;\n  float frames = float(size.y);\n  float wrapped = moment - frames * floor(moment / frames);\n  int first = min(int(floor(wrapped)), size.y - 1);\n  int second = first + 1 == size.y ? 0 : first + 1;\n  float blend = clamp(wrapped - float(first), 0.0, 1.0);\n  int bone = clamp(int(floor((-1.0 - aGrain) * uBoneClip.y + 0.5)), 0, size.x - 1);\n  vec4 q0 = texelFetch(uBoneTurns, ivec2(bone, first), 0);\n  vec4 q1 = texelFetch(uBoneTurns, ivec2(bone, second), 0);\n  /* The shorter arc: a quaternion and its negation are one turn. */\n  if (dot(q0, q1) < 0.0) q1 = -q1;\n  vec4 q = normalize(mix(q0, q1, blend));\n  vec3 place = mix(\n    texelFetch(uBonePlaces, ivec2(bone, first), 0).xyz,\n    texelFetch(uBonePlaces, ivec2(bone, second), 0).xyz,\n    blend\n  );\n  normal = boneTurn(q, normal);\n  tangent = boneTurn(q, tangent);\n  return boneTurn(q, position) + place;\n}\n";

package/dist/render/shaders/boneAnimation.js

@@ -0,0 +1,63 @@
+/**
+ * The vertex-stage bone animation: a crowd instance's vertex turned and placed by its bone, at its
+ * instance's moment of the clip — the GLSL of `boneAnimation.ts`'s `animateBoneVertex`, line for
+ * line. Shared by the lit stage and the depth stage, so a crowd's shadow moves with it.
+ *
+ * **Three textures, read by index and never filtered**: the places and the turns, a texel a bone a
+ * frame (bones across, frames down, sizes read with `textureSize` so no uniform says them), and the
+ * batch's clocks, two floats an instance wrapped onto rows, read at `gl_InstanceID`. The clip's speed
+ * and its bone scale are the one uniform, `uBoneClip`; the scene's time is the pass's `uSceneTime`.
+ *
+ * **The bone is read from the grain lane**, which is where a mesh's second coordinates ride, stored
+ * as `-1 - u` (`lightmap.ts`). An instanced batch reads no grain of its own from that lane: a crowd's
+ * mesh carries second coordinates, which is what makes it one.
+ *
+ * Integer arithmetic for the lattice, by the 2026-09-20 rule, except where a float is clamped onto
+ * it: the first frame is `min(floor(wrapped), frames - 1)`, so the wrap that division-by-reciprocal
+ * lands on `frames` is the last frame fully blended into the first — the first, which is right.
+ */
+export const BONE_ANIMATION_GLSL = `
+uniform highp sampler2D uBonePlaces;
+uniform highp sampler2D uBoneTurns;
+uniform highp sampler2D uInstanceClocks;
+/** x the clip's frames a second, y how many bones one unit of the second coordinates' u counts. */
+uniform vec2 uBoneClip;
+
+/** v turned by the unit quaternion q. */
+vec3 boneTurn(vec4 q, vec3 v) {
+  return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + q.w * v);
+}
+
+/**
+ * Where the clip puts this vertex, from its place at rest; its normal and tangent turned with it.
+ */
+vec3 boneAnimate(vec3 position, inout vec3 normal, inout vec3 tangent) {
+  ivec2 size = textureSize(uBonePlaces, 0);
+  int clocksWidth = textureSize(uInstanceClocks, 0).x;
+  vec2 clock = texelFetch(
+    uInstanceClocks,
+    ivec2(gl_InstanceID % clocksWidth, gl_InstanceID / clocksWidth),
+    0
+  ).xy;
+  float moment = (uSceneTime * clock.y + clock.x) * uBoneClip.x;
+  float frames = float(size.y);
+  float wrapped = moment - frames * floor(moment / frames);
+  int first = min(int(floor(wrapped)), size.y - 1);
+  int second = first + 1 == size.y ? 0 : first + 1;
+  float blend = clamp(wrapped - float(first), 0.0, 1.0);
+  int bone = clamp(int(floor((-1.0 - aGrain) * uBoneClip.y + 0.5)), 0, size.x - 1);
+  vec4 q0 = texelFetch(uBoneTurns, ivec2(bone, first), 0);
+  vec4 q1 = texelFetch(uBoneTurns, ivec2(bone, second), 0);
+  /* The shorter arc: a quaternion and its negation are one turn. */
+  if (dot(q0, q1) < 0.0) q1 = -q1;
+  vec4 q = normalize(mix(q0, q1, blend));
+  vec3 place = mix(
+    texelFetch(uBonePlaces, ivec2(bone, first), 0).xyz,
+    texelFetch(uBonePlaces, ivec2(bone, second), 0).xyz,
+    blend
+  );
+  normal = boneTurn(q, normal);
+  tangent = boneTurn(q, tangent);
+  return boneTurn(q, position) + place;
+}
+`;

package/dist/render/shaders/depth.d.ts

@@ -23,6 +23,13 @@ export declare const DEPTH_INSTANCED_VERT: string;
  */
 export declare const DEPTH_CUTOUT_VERT: string;
 export declare const DEPTH_INSTANCED_CUTOUT_VERT: string;
+/**
+ * The variants a crowd casts through: an instanced batch playing a bone animation, its vertices
+ * where the clip puts them at each instance's moment. See `shaders/boneAnimation.ts`. No glass
+ * variant: a crowd is not glass, and a glass batch that animates casts its tint from rest.
+ */
+export declare const DEPTH_INSTANCED_ANIMATED_VERT: string;
+export declare const DEPTH_INSTANCED_ANIMATED_CUTOUT_VERT: string;
 export declare const DEPTH_FRAG = "#version 300 es\nprecision highp float;\nin vec4 vLightPosition;\n\nuniform highp sampler2DArray uPreviousShadowMap;\nuniform int uPeelShadowLayer;\n\nvoid main() {\n  if (uPeelShadowLayer != 0) {\n    vec3 p = vLightPosition.xyz / vLightPosition.w;\n    vec2 uv = p.xy * 0.5 + 0.5;\n    float previousDepth = texture(uPreviousShadowMap, vec3(uv, 0.0)).r;\n    // Discard the already-recorded surface and everything in front of it. The\n    // ordinary depth test then stores the next independently fading occluder.\n    if (gl_FragCoord.z <= previousDepth + 0.00001) discard;\n  }\n}\n";
 /**
  * The cutout caster's depth: the plain pass, and a texel of alpha under the cutoff writes nothing.

package/dist/render/shaders/depth.js

@@ -5,6 +5,7 @@ import { CUTOUT_DITHER_GLSL } from '../cutoutDither.js';
 import { SKINNING_GLSL } from './skinning.js';
 import { CLOTH_BINDING_GLSL } from './clothBinding.js';
 import { CHANNEL_ATTRIBUTE, CHANNEL_BEND } from './vertexChannel.js';
+import { BONE_ANIMATION_GLSL } from './boneAnimation.js';
 /**
  * Depth-only shadow pass. Its optional peel mode rejects the first recorded
  * surface so the next independently fading occluder can be retained.
@@ -77,6 +78,17 @@ uniform vec2 uUvOffset;
 uniform vec2 uAlphaCutout;
 #endif
 
+#if ANIMATED
+/*
+ * **A bone animation's, after every other declaration** so no field of the variants before it
+ * moves: the grain lane the vertex's bone rides in, the scene's clock, and the chunk the colour
+ * pass runs — the same expression, or a crowd's shadow stands still while the crowd moves.
+ */
+layout(location = 8) in float aGrain;
+uniform float uSceneTime;
+${BONE_ANIMATION_GLSL}
+#endif
+
 out vec4 vLightPosition;
 #if CUTOUT
 /* The texture coordinate and, in z, the texture-array layer the face wears. */
@@ -98,6 +110,12 @@ void main() {
 #else
   vec4 local = vec4(aPosition, 1.0);
 #endif
+#if ANIMATED
+  /* Turned and placed as the colour pass turns and places it; its normal and tangent unused. */
+  vec3 animatedNormal = vec3(0.0, 1.0, 0.0);
+  vec3 animatedTangent = vec3(1.0, 0.0, 0.0);
+  local = vec4(boneAnimate(local.xyz, animatedNormal, animatedTangent), 1.0);
+#endif
 #if INSTANCED
   mat4 model = mat4(aInstanceModel0, aInstanceModel1, aInstanceModel2, aInstanceModel3);
   /* The bottom row is the instance's texture cell, rebuilt as the row it stands for: see flat. */
@@ -144,9 +162,9 @@ void main() {
 }
 `;
 /** The rigid variant: the world, a prop, a mesh with no rig behind it. */
-export const DEPTH_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: false, GLASS: false }, 'depth');
+export const DEPTH_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: false, GLASS: false, ANIMATED: false }, 'depth');
 /** The skinned variant, which reads a joint palette and moves the vertex by it. */
-export const DEPTH_SKINNED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: true, INSTANCED: false, CUTOUT: false, GLASS: false }, 'depth-skinned');
+export const DEPTH_SKINNED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: true, INSTANCED: false, CUTOUT: false, GLASS: false, ANIMATED: false }, 'depth-skinned');
 /**
  * The variant an instanced draw casts its shadow through.
  *
@@ -155,7 +173,7 @@ export const DEPTH_SKINNED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINN
  * right place and the rest stacked underneath it, which reads as a lighting fault rather than as
  * a missing variant, and is the shape the per-draw ring exists to prevent one level up.
  */
-export const DEPTH_INSTANCED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: false, GLASS: false }, 'depth-instanced');
+export const DEPTH_INSTANCED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: false, GLASS: false, ANIMATED: false }, 'depth-instanced');
 /**
  * The variants a cutout caster casts through: a leaf card, a chain link, a fence, whose shape is in
  * its texture's alpha rather than in its geometry.
@@ -166,8 +184,15 @@ export const DEPTH_INSTANCED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKI
  * leaves every opaque caster byte for byte as it was. What it costs is one more program each, and
  * a skinned cutout, which nothing has asked for, is not among them.
  */
-export const DEPTH_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: true, GLASS: false }, 'depth-cutout');
-export const DEPTH_INSTANCED_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: true, GLASS: false }, 'depth-instanced-cutout');
+export const DEPTH_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: true, GLASS: false, ANIMATED: false }, 'depth-cutout');
+export const DEPTH_INSTANCED_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: true, GLASS: false, ANIMATED: false }, 'depth-instanced-cutout');
+/**
+ * The variants a crowd casts through: an instanced batch playing a bone animation, its vertices
+ * where the clip puts them at each instance's moment. See `shaders/boneAnimation.ts`. No glass
+ * variant: a crowd is not glass, and a glass batch that animates casts its tint from rest.
+ */
+export const DEPTH_INSTANCED_ANIMATED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: false, GLASS: false, ANIMATED: true }, 'depth-instanced-animated');
+export const DEPTH_INSTANCED_ANIMATED_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: true, GLASS: false, ANIMATED: true }, 'depth-instanced-animated-cutout');
 export const DEPTH_FRAG = `#version 300 es
 precision highp float;
 in vec4 vLightPosition;
@@ -238,11 +263,11 @@ void main() {
  * exactly where it casts its depth, deformed and placed the same way, or the coloured patch parts
  * from the pane's own shadow edge. The only addition is `vGlassWorld`.
  */
-export const GLASS_TINT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: false, GLASS: true }, 'glass-tint');
-export const GLASS_TINT_SKINNED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: true, INSTANCED: false, CUTOUT: false, GLASS: true }, 'glass-tint-skinned');
-export const GLASS_TINT_INSTANCED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: false, GLASS: true }, 'glass-tint-instanced');
-export const GLASS_TINT_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: true, GLASS: true }, 'glass-tint-cutout');
-export const GLASS_TINT_INSTANCED_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: true, GLASS: true }, 'glass-tint-instanced-cutout');
+export const GLASS_TINT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: false, GLASS: true, ANIMATED: false }, 'glass-tint');
+export const GLASS_TINT_SKINNED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: true, INSTANCED: false, CUTOUT: false, GLASS: true, ANIMATED: false }, 'glass-tint-skinned');
+export const GLASS_TINT_INSTANCED_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: false, GLASS: true, ANIMATED: false }, 'glass-tint-instanced');
+export const GLASS_TINT_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: false, CUTOUT: true, GLASS: true, ANIMATED: false }, 'glass-tint-cutout');
+export const GLASS_TINT_INSTANCED_CUTOUT_VERT = resolveConditionals(DEPTH_VERT_SOURCE, { SKINNED: false, INSTANCED: true, CUTOUT: true, GLASS: true, ANIMATED: false }, 'glass-tint-instanced-cutout');
 /**
  * What a pane lets through: its transmission and colour, less what it reflects toward the light,
  * and how clear it is — `glassShadow.ts`'s `paneTexel`, stated for the device. Drawn with a

package/dist/render/shaders/flat/index.d.ts

@@ -38,6 +38,12 @@ export interface FlatVertexOptions {
      * Excludes `skinned`: the joint attributes and the instance matrix want the same locations.
      */
     readonly instanced: boolean;
+    /**
+     * Whether an instanced variant follows a bone animation: \`shaders/boneAnimation.ts\`. A
+     * variant rather than a pipeline constant, because it declares three textures the other
+     * instanced pipelines would otherwise have to bind stand-ins for. Instanced only.
+     */
+    readonly animated?: boolean;
 }
 /**
  * The flat vertex shader, built for one variant.

package/dist/render/shaders/flat/index.js

@@ -21,7 +21,8 @@ import { DRIFT_LIGHT_GLSL } from './driftLight.js';
 import { SURFACE_EFFECTS_GLSL } from './surfaceEffects.js';
 import { overlayGlsl } from './overlay.js';
 import { reflectionSurfaceGlsl } from './reflectionSurface.js';
-import { CHANNEL_ATTRIBUTE, CHANNEL_BEND } from '../vertexChannel.js';
+import { CHANNEL_BEND, LIT_CHANNEL_ATTRIBUTE } from '../vertexChannel.js';
+import { BONE_ANIMATION_GLSL } from '../boneAnimation.js';
 import { FULL_LIGHT_BUDGET } from '../../uniformVectorBudget.js';
 /**
  * Flat-shaded vertex colours with one dominant directional source, ambient,
@@ -55,10 +56,16 @@ layout(location = 10) in vec4 aTangent;
 ${SKINNING_GLSL}
 #endif
 
-uniform mat4 uViewProj;
+uniform mat4 uViewProj; // wgsl:view
 /** 1 when the mesh carries a tangent frame. See vHasTangents. */
 uniform int uHasTangents;
-uniform mat4 uLightViewProj;
+uniform mat4 uLightViewProj; // wgsl:view
+/**
+ * The scene's clock, what \`setAnimationTime\` set: what a bone animation's instances read
+ * their moment from. In the view block, before the wind, so every variant's view block is the
+ * plain one's or a prefix of it — the instanced variant declares no wind and keeps this.
+ */
+uniform float uSceneTime; // wgsl:view
 /**
  * How often the surface texture repeats across this mesh's UV range, per axis.
  *
@@ -121,6 +128,9 @@ layout(location = 15) in vec4 aInstanceTint;
  * opacity of one. See lightmap.ts.
  */
 const bool LIGHTMAP_REGIONS = false; // wgsl:override
+#if ANIMATED
+${BONE_ANIMATION_GLSL}
+#endif
 #else
 uniform mat4 uModel;
 /**
@@ -146,7 +156,7 @@ uniform vec3 uTint;
  * agreeing about where the shared uniforms sit: the instanced variant drops these five along with
  * the two above it, and a dropped field moves nothing. flatPass.ts asserts exactly that.
  */
-${CHANNEL_ATTRIBUTE}
+${LIT_CHANNEL_ATTRIBUTE}
 ${CHANNEL_BEND}
 #endif
 
@@ -244,6 +254,10 @@ void main() {
   vec3 localNormal = aNormal;
   vec3 localTangent = aTangent.xyz;
 #endif
+#if ANIMATED
+  /* The clip's turn and place, in the mesh's own space, before the instance places it. */
+  local = vec4(boneAnimate(local.xyz, localNormal, localTangent), 1.0);
+#endif
 #if INSTANCED
   mat4 model = mat4(aInstanceModel0, aInstanceModel1, aInstanceModel2, aInstanceModel3);
   /*
@@ -353,7 +367,15 @@ export function flatVert(options) {
         throw new Error('flatVert: a variant cannot be both morphed and instanced — a morph weight is per draw, ' +
             'so every instance of the batch would wear one expression between them.');
     }
-    return resolveConditionals(FLAT_VERT_SOURCE, { SKINNED: options.skinned, MORPHED: options.morphed, INSTANCED: options.instanced }, 'flatVert');
+    if (options.animated === true && !options.instanced) {
+        throw new Error('flatVert: a bone animation is played by an instanced variant alone.');
+    }
+    return resolveConditionals(FLAT_VERT_SOURCE, {
+        SKINNED: options.skinned,
+        MORPHED: options.morphed,
+        INSTANCED: options.instanced,
+        ANIMATED: options.animated === true,
+    }, 'flatVert');
 }
 /**
  * The flat fragment shader, built for one quality profile.