@aura3d/rendering 1.0.6

package/src/VegetationFixtures.ts

@@ -0,0 +1,314 @@
+import { sampleTerrainHeightfield, type TerrainHeightfieldFixture } from "./TerrainFixtures";
+
+export type VegetationFixtureLayer = "tree" | "grass" | "shrub";
+export type VegetationFixtureLod = "mesh" | "impostor" | "culled";
+
+export interface VegetationFixtureOptions {
+  readonly terrain: TerrainHeightfieldFixture;
+  readonly seed?: number;
+  readonly cameraX?: number;
+  readonly elapsedSeconds?: number;
+  readonly maxInstances?: number;
+}
+
+export interface VegetationFixtureInstance {
+  readonly id: string;
+  readonly layer: VegetationFixtureLayer;
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+  readonly scale: number;
+  readonly rotation: number;
+  readonly distanceToCamera: number;
+  readonly lod: VegetationFixtureLod;
+  readonly windOffsetX: number;
+  readonly windOffsetZ: number;
+}
+
+export interface VegetationLSystemBranchSegment {
+  readonly instanceId: string;
+  readonly startX: number;
+  readonly startY: number;
+  readonly startZ: number;
+  readonly endX: number;
+  readonly endY: number;
+  readonly endZ: number;
+  readonly width: number;
+  readonly depth: number;
+}
+
+export interface VegetationLSystemFixture {
+  readonly source: "origin-master-lsystem-turtle-adapted";
+  readonly axiom: "F";
+  readonly rule: "F -> F[+F][-F]!F";
+  readonly iterations: number;
+  readonly generatedSymbolLength: number;
+  readonly branchSegmentCount: number;
+  readonly renderedBranchSegmentCount: number;
+  readonly branchTipCount: number;
+  readonly maxDepth: number;
+  readonly hash: string;
+  readonly segments: readonly VegetationLSystemBranchSegment[];
+  readonly claimBoundary: string;
+}
+
+export interface VegetationFixtureSample {
+  readonly id: "external-parity-old-branch-vegetation-fixture";
+  readonly source: "origin-master-vegetation-system-adapted";
+  readonly seed: number;
+  readonly instanceCount: number;
+  readonly visibleCount: number;
+  readonly culledCount: number;
+  readonly meshLodCount: number;
+  readonly impostorLodCount: number;
+  readonly treeCount: number;
+  readonly grassCount: number;
+  readonly shrubCount: number;
+  readonly maxWindOffset: number;
+  readonly instances: readonly VegetationFixtureInstance[];
+  readonly lsystem: VegetationLSystemFixture;
+  readonly hash: string;
+  readonly claimBoundary: string;
+}
+
+export function sampleVegetationFixture(options: VegetationFixtureOptions): VegetationFixtureSample {
+  const terrain = options.terrain;
+  const seed = options.seed ?? terrain.seed ^ 0x6eed;
+  if (!Number.isInteger(seed)) {
+    throw new RangeError("Vegetation fixture seed must be an integer.");
+  }
+  const cameraX = finite(options.cameraX ?? 0, "cameraX");
+  const elapsedSeconds = Math.max(0, finite(options.elapsedSeconds ?? 0, "elapsedSeconds"));
+  const maxInstances = Math.max(1, Math.min(512, Math.floor(options.maxInstances ?? 96)));
+  const instances: VegetationFixtureInstance[] = [];
+  const step = Math.max(2, Math.floor(Math.sqrt((terrain.width * terrain.height) / maxInstances)));
+  for (let y = 1; y < terrain.height - 1 && instances.length < maxInstances; y += step) {
+    for (let x = 1; x < terrain.width - 1 && instances.length < maxInstances; x += step) {
+      const sample = sampleTerrainHeightfield(terrain, x / (terrain.width - 1), y / (terrain.height - 1));
+      const placement = placementFor(sample.biome, seed + x * 17 + y * 31);
+      if (!placement) continue;
+      const worldX = (x / (terrain.width - 1) - 0.5) * 5.2;
+      const worldZ = (y / (terrain.height - 1) - 0.5) * 1.1;
+      const distance = Math.abs(worldX - cameraX) + Math.abs(worldZ) * 0.35;
+      const lod: VegetationFixtureLod = distance > 1.18 ? "culled" : distance > 0.62 ? "impostor" : "mesh";
+      const wind = windDisplacement(worldX, worldZ, elapsedSeconds, placement.windResponse, seed);
+      instances.push({
+        id: `veg-${x}-${y}`,
+        layer: placement.layer,
+        x: Number(worldX.toFixed(4)),
+        y: Number((sample.height * 0.7 - 0.53).toFixed(4)),
+        z: Number(worldZ.toFixed(4)),
+        scale: placement.scale,
+        rotation: Number((seeded01(seed + x * 101 + y * 7) * Math.PI * 2).toFixed(4)),
+        distanceToCamera: Number(distance.toFixed(4)),
+        lod,
+        windOffsetX: wind.x,
+        windOffsetZ: wind.z
+      });
+    }
+  }
+  const visible = instances.filter((instance) => instance.lod !== "culled");
+  const meshLodCount = instances.filter((instance) => instance.lod === "mesh").length;
+  const impostorLodCount = instances.filter((instance) => instance.lod === "impostor").length;
+  const treeCount = instances.filter((instance) => instance.layer === "tree").length;
+  const grassCount = instances.filter((instance) => instance.layer === "grass").length;
+  const shrubCount = instances.filter((instance) => instance.layer === "shrub").length;
+  const maxWindOffset = Math.max(0, ...instances.map((instance) => Math.hypot(instance.windOffsetX, instance.windOffsetZ)));
+  const lsystem = createVegetationLSystemFixture(instances, seed);
+  return {
+    id: "external-parity-old-branch-vegetation-fixture",
+    source: "origin-master-vegetation-system-adapted",
+    seed,
+    instanceCount: instances.length,
+    visibleCount: visible.length,
+    culledCount: instances.length - visible.length,
+    meshLodCount,
+    impostorLodCount,
+    treeCount,
+    grassCount,
+    shrubCount,
+    maxWindOffset: Number(maxWindOffset.toFixed(5)),
+    instances,
+    lsystem,
+    hash: hashVegetation(instances, lsystem.hash),
+    claimBoundary: "Deterministic biome-aware vegetation placement, LOD selection, culling, wind-displacement telemetry, and bounded L-system branch/tip telemetry adapted from the old vegetation and L-system systems; this is bounded fixture evidence, not instanced vegetation rendering, billboards, collision, seasonal growth, procedural mesh generation, or production terrain vegetation parity."
+  };
+}
+
+function createVegetationLSystemFixture(instances: readonly VegetationFixtureInstance[], seed: number): VegetationLSystemFixture {
+  const iterations = 3;
+  const generated = generateDOL("F", "F[+F][-F]!F", iterations);
+  const visibleTrees = instances.filter((instance) => instance.layer === "tree" && instance.lod !== "culled");
+  const visibleVegetation = instances.filter((instance) => instance.lod !== "culled");
+  const treeFallback = instances.filter((instance) => instance.layer === "tree");
+  const branchSources = (visibleTrees.length > 0 ? visibleTrees : visibleVegetation.length > 0 ? visibleVegetation : treeFallback).slice(0, 8);
+  const segments = branchSources.flatMap((instance, index) => interpretTreeLSystem(generated, instance, seed + index * 971)).slice(0, 160);
+  const branchTipCount = countBranchTips(generated) * branchSources.length;
+  const maxDepth = segments.reduce((max, segment) => Math.max(max, segment.depth), 0);
+  return {
+    source: "origin-master-lsystem-turtle-adapted",
+    axiom: "F",
+    rule: "F -> F[+F][-F]!F",
+    iterations,
+    generatedSymbolLength: generated.length,
+    branchSegmentCount: countDrawCommands(generated) * branchSources.length,
+    renderedBranchSegmentCount: segments.length,
+    branchTipCount,
+    maxDepth,
+    hash: hashLSystemSegments(generated, segments),
+    segments,
+    claimBoundary: "D0L grammar expansion and turtle-style branch interpretation adapted from the old L-system code as deterministic vegetation evidence only; this does not claim production procedural tree meshes, botanical simulation, growth, collision, or Unity/Unreal vegetation parity."
+  };
+}
+
+function generateDOL(axiom: string, successor: string, iterations: number): string {
+  let current = axiom;
+  for (let iteration = 0; iteration < iterations; iteration += 1) {
+    let next = "";
+    for (const symbol of current) {
+      next += symbol === "F" ? successor : symbol;
+    }
+    current = next.length > 4_096 ? next.slice(0, 4_096) : next;
+  }
+  return current;
+}
+
+function interpretTreeLSystem(generated: string, instance: VegetationFixtureInstance, seed: number): VegetationLSystemBranchSegment[] {
+  const angle = 0.45 + seeded01(seed ^ 0x512) * 0.22;
+  const step = instance.scale * (instance.lod === "impostor" ? 0.72 : 1);
+  const stack: { x: number; y: number; z: number; heading: number; width: number; depth: number }[] = [];
+  const state = { x: instance.x + instance.windOffsetX, y: instance.y, z: instance.z + instance.windOffsetZ, heading: Math.PI / 2, width: Math.max(0.006, step * 0.28), depth: 0 };
+  const segments: VegetationLSystemBranchSegment[] = [];
+  for (const symbol of generated) {
+    if (symbol === "F") {
+      const startX = state.x;
+      const startY = state.y;
+      const startZ = state.z;
+      state.x += Math.cos(state.heading) * step;
+      state.y += Math.sin(state.heading) * step * 1.45;
+      state.z += Math.sin(state.heading * 0.73 + seed * 0.001) * step * 0.22;
+      segments.push({
+        instanceId: instance.id,
+        startX: Number(startX.toFixed(4)),
+        startY: Number(startY.toFixed(4)),
+        startZ: Number(startZ.toFixed(4)),
+        endX: Number(state.x.toFixed(4)),
+        endY: Number(state.y.toFixed(4)),
+        endZ: Number(state.z.toFixed(4)),
+        width: Number(state.width.toFixed(5)),
+        depth: state.depth
+      });
+    } else if (symbol === "+") {
+      state.heading += angle;
+    } else if (symbol === "-") {
+      state.heading -= angle;
+    } else if (symbol === "[") {
+      stack.push({ ...state });
+      state.depth += 1;
+      state.width *= 0.72;
+    } else if (symbol === "]") {
+      const popped = stack.pop();
+      if (popped) {
+        state.x = popped.x;
+        state.y = popped.y;
+        state.z = popped.z;
+        state.heading = popped.heading;
+        state.width = popped.width;
+        state.depth = popped.depth;
+      }
+    } else if (symbol === "!") {
+      state.width *= 0.78;
+    }
+  }
+  return segments;
+}
+
+function countDrawCommands(value: string): number {
+  let count = 0;
+  for (const symbol of value) {
+    if (symbol === "F") count += 1;
+  }
+  return count;
+}
+
+function countBranchTips(value: string): number {
+  let tips = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] === "F" && value[index + 1] !== "[") tips += 1;
+  }
+  return tips;
+}
+
+function placementFor(biome: string, seed: number): { readonly layer: VegetationFixtureLayer; readonly scale: number; readonly windResponse: number } | null {
+  const roll = seeded01(seed);
+  if (biome === "forest") {
+    return roll < 0.72 ? { layer: "tree", scale: 0.09 + seeded01(seed ^ 0x51) * 0.08, windResponse: 0.45 } : { layer: "shrub", scale: 0.05, windResponse: 0.7 };
+  }
+  if (biome === "grassland") {
+    return roll < 0.62 ? { layer: "grass", scale: 0.035 + seeded01(seed ^ 0x22) * 0.025, windResponse: 1 } : null;
+  }
+  if (biome === "beach") {
+    return roll < 0.2 ? { layer: "grass", scale: 0.03, windResponse: 0.9 } : null;
+  }
+  return null;
+}
+
+function windDisplacement(x: number, z: number, time: number, response: number, seed: number): { readonly x: number; readonly z: number } {
+  const gust = Math.sin(time * 1.8 + x * 2.1 + z * 1.3 + seeded01(seed) * Math.PI * 2);
+  const turbulence = Math.sin(time * 3.2 + x * 4.4 - z * 2.7);
+  return {
+    x: Number(((gust * 0.018 + turbulence * 0.006) * response).toFixed(5)),
+    z: Number((Math.cos(time * 1.3 + z * 3.1) * 0.01 * response).toFixed(5))
+  };
+}
+
+function hashVegetation(instances: readonly VegetationFixtureInstance[], lsystemHash: string): string {
+  let hash = 0x811c9dc5;
+  for (const char of lsystemHash) {
+    hash ^= char.charCodeAt(0);
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  for (const instance of instances) {
+    for (const value of [instance.x, instance.y, instance.z, instance.scale, instance.windOffsetX, instance.windOffsetZ]) {
+      const scaled = Math.round(value * 10_000);
+      hash ^= scaled & 0xff;
+      hash = Math.imul(hash, 0x01000193) >>> 0;
+      hash ^= (scaled >>> 8) & 0xff;
+      hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    hash ^= instance.layer.charCodeAt(0);
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+    hash ^= instance.lod.charCodeAt(0);
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+function hashLSystemSegments(generated: string, segments: readonly VegetationLSystemBranchSegment[]): string {
+  let hash = 0x9e3779b9;
+  for (const symbol of generated) {
+    hash ^= symbol.charCodeAt(0);
+    hash = Math.imul(hash, 0x85ebca6b) >>> 0;
+  }
+  for (const segment of segments) {
+    for (const value of [segment.startX, segment.startY, segment.startZ, segment.endX, segment.endY, segment.endZ, segment.width, segment.depth]) {
+      const scaled = Math.round(value * 10_000);
+      hash ^= scaled & 0xffff;
+      hash = Math.imul(hash, 0xc2b2ae35) >>> 0;
+    }
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+function seeded01(seed: number): number {
+  let value = seed >>> 0;
+  value ^= value << 13;
+  value ^= value >>> 17;
+  value ^= value << 5;
+  return ((value >>> 0) % 10_000) / 10_000;
+}
+
+function finite(value: number, label: string): number {
+  if (!Number.isFinite(value)) throw new RangeError(`Vegetation fixture ${label} must be finite.`);
+  return value;
+}

package/src/VertexBuffer.ts

@@ -0,0 +1,120 @@
+import { type RenderBuffer, type RenderDevice, RenderDeviceError } from "./RenderDevice";
+import { type VertexAttributeSemantic, VertexFormat } from "./VertexFormat";
+
+export class VertexBuffer {
+  public readonly data: ArrayBuffer;
+  public readonly floats: Float32Array;
+  private gpuBuffer: RenderBuffer | null = null;
+  private dirtyStart = Number.POSITIVE_INFINITY;
+  private dirtyEnd = 0;
+  private disposed = false;
+
+  constructor(
+    public readonly format: VertexFormat,
+    public readonly vertexCount: number
+  ) {
+    if (vertexCount <= 0 || !Number.isInteger(vertexCount)) {
+      throw new Error("VertexBuffer vertexCount must be a positive integer");
+    }
+    this.data = new ArrayBuffer(format.stride * vertexCount);
+    this.floats = new Float32Array(this.data);
+    this.markDirty(0, this.data.byteLength);
+  }
+
+  get byteLength(): number {
+    return this.data.byteLength;
+  }
+
+  get uploadedBuffer(): RenderBuffer | null {
+    return this.gpuBuffer;
+  }
+
+  setAttribute(vertexIndex: number, semantic: VertexAttributeSemantic, values: readonly number[]): void {
+    this.assertAlive();
+    this.assertVertexIndex(vertexIndex);
+    const attribute = this.format.getAttribute(semantic);
+    if (values.length !== attribute.components) {
+      throw new Error(`Semantic ${semantic} requires ${attribute.components} values, got ${values.length}`);
+    }
+    if (!values.every(Number.isFinite)) {
+      throw new Error(`Semantic ${semantic} values must be finite`);
+    }
+    const byteOffset = vertexIndex * this.format.stride + attribute.offset;
+    const floatOffset = byteOffset / 4;
+    for (let i = 0; i < values.length; i += 1) {
+      this.floats[floatOffset + i] = values[i] ?? 0;
+    }
+    this.markDirty(byteOffset, attribute.byteLength);
+  }
+
+  getAttribute(vertexIndex: number, semantic: VertexAttributeSemantic): readonly number[] {
+    this.assertAlive();
+    this.assertVertexIndex(vertexIndex);
+    const attribute = this.format.getAttribute(semantic);
+    const byteOffset = vertexIndex * this.format.stride + attribute.offset;
+    const floatOffset = byteOffset / 4;
+    return Array.from(this.floats.slice(floatOffset, floatOffset + attribute.components));
+  }
+
+  upload(device: RenderDevice): RenderBuffer {
+    this.assertAlive();
+    if (!this.gpuBuffer || this.gpuBuffer.disposed) {
+      this.gpuBuffer = device.createBuffer("vertex", this.byteLength, new Uint8Array(this.data));
+      this.clearDirty();
+      return this.gpuBuffer;
+    }
+    if (this.isDirty()) {
+      const start = alignDown(this.dirtyStart, 4);
+      const end = alignUp(this.dirtyEnd, 4);
+      device.updateBuffer(this.gpuBuffer, start, new Uint8Array(this.data, start, end - start));
+      this.clearDirty();
+    }
+    return this.gpuBuffer;
+  }
+
+  getDirtyRange(): { readonly start: number; readonly end: number } | null {
+    if (!this.isDirty()) {
+      return null;
+    }
+    return { start: this.dirtyStart, end: this.dirtyEnd };
+  }
+
+  dispose(): void {
+    this.gpuBuffer?.dispose();
+    this.disposed = true;
+  }
+
+  private assertVertexIndex(vertexIndex: number): void {
+    if (!Number.isInteger(vertexIndex) || vertexIndex < 0 || vertexIndex >= this.vertexCount) {
+      throw new RangeError(`Vertex index ${vertexIndex} is out of range`);
+    }
+  }
+
+  private assertAlive(): void {
+    if (this.disposed) {
+      throw new RenderDeviceError("VertexBuffer is disposed", "DISPOSED_RESOURCE");
+    }
+  }
+
+  private markDirty(start: number, byteLength: number): void {
+    this.dirtyStart = Math.min(this.dirtyStart, start);
+    this.dirtyEnd = Math.max(this.dirtyEnd, start + byteLength);
+  }
+
+  private isDirty(): boolean {
+    return this.dirtyStart <= this.dirtyEnd;
+  }
+
+  private clearDirty(): void {
+    this.dirtyStart = Number.POSITIVE_INFINITY;
+    this.dirtyEnd = 0;
+  }
+}
+
+function alignDown(value: number, alignment: number): number {
+  return Math.floor(value / alignment) * alignment;
+}
+
+function alignUp(value: number, alignment: number): number {
+  return Math.ceil(value / alignment) * alignment;
+}

package/src/VertexFormat.ts

@@ -0,0 +1,171 @@
+export type VertexAttributeSemantic = "position" | "normal" | "uv" | "uv1" | "tangent" | "color" | "joints" | "weights";
+
+export type VertexAttributeType = "float32";
+
+export interface VertexAttributeDescriptor {
+  readonly semantic: VertexAttributeSemantic;
+  readonly components: 1 | 2 | 3 | 4;
+  readonly offset: number;
+  readonly type?: VertexAttributeType;
+  readonly normalized?: boolean;
+  readonly shaderLocation?: number;
+  readonly shaderName?: string;
+}
+
+export class VertexAttribute {
+  public readonly semantic: VertexAttributeSemantic;
+  public readonly components: 1 | 2 | 3 | 4;
+  public readonly offset: number;
+  public readonly type: VertexAttributeType;
+  public readonly normalized: boolean;
+  public readonly shaderLocation: number;
+  public readonly shaderName: string;
+
+  constructor(descriptor: VertexAttributeDescriptor) {
+    if (descriptor.offset < 0 || descriptor.offset % 4 !== 0) {
+      throw new Error(`Vertex attribute ${descriptor.semantic} offset must be non-negative and 4-byte aligned`);
+    }
+    this.semantic = descriptor.semantic;
+    this.components = descriptor.components;
+    this.offset = descriptor.offset;
+    this.type = descriptor.type ?? "float32";
+    this.normalized = descriptor.normalized ?? false;
+    this.shaderLocation = descriptor.shaderLocation ?? defaultShaderLocation(descriptor.semantic);
+    this.shaderName = descriptor.shaderName ?? defaultShaderName(descriptor.semantic);
+  }
+
+  get byteLength(): number {
+    return this.components * 4;
+  }
+}
+
+export class VertexFormat {
+  public readonly attributes: readonly VertexAttribute[];
+  public readonly stride: number;
+
+  constructor(attributes: readonly VertexAttributeDescriptor[], stride?: number) {
+    if (attributes.length === 0) {
+      throw new Error("VertexFormat requires at least one attribute");
+    }
+
+    const seen = new Set<VertexAttributeSemantic>();
+    this.attributes = attributes.map((attribute) => {
+      if (seen.has(attribute.semantic)) {
+        throw new Error(`Duplicate vertex semantic: ${attribute.semantic}`);
+      }
+      seen.add(attribute.semantic);
+      return new VertexAttribute(attribute);
+    });
+
+    const minimumStride = Math.max(...this.attributes.map((attribute) => attribute.offset + attribute.byteLength));
+    this.stride = stride ?? minimumStride;
+    if (this.stride < minimumStride) {
+      throw new Error(`Vertex stride ${this.stride} is smaller than minimum required stride ${minimumStride}`);
+    }
+    if (this.stride % 4 !== 0) {
+      throw new Error("Vertex stride must be 4-byte aligned");
+    }
+  }
+
+  static readonly P3 = new VertexFormat([{ semantic: "position", components: 3, offset: 0 }], 12);
+
+  static readonly P3N3 = new VertexFormat(
+    [
+      { semantic: "position", components: 3, offset: 0 },
+      { semantic: "normal", components: 3, offset: 12 }
+    ],
+    24
+  );
+
+  static readonly P3N3T2 = new VertexFormat(
+    [
+      { semantic: "position", components: 3, offset: 0 },
+      { semantic: "normal", components: 3, offset: 12 },
+      { semantic: "uv", components: 2, offset: 24 }
+    ],
+    32
+  );
+
+  static readonly P3N3T4T2 = new VertexFormat(
+    [
+      { semantic: "position", components: 3, offset: 0 },
+      { semantic: "normal", components: 3, offset: 12 },
+      { semantic: "tangent", components: 4, offset: 24 },
+      { semantic: "uv", components: 2, offset: 40 }
+    ],
+    48
+  );
+
+  static readonly P3J4W4 = new VertexFormat(
+    [
+      { semantic: "position", components: 3, offset: 0 },
+      { semantic: "joints", components: 4, offset: 12 },
+      { semantic: "weights", components: 4, offset: 28 }
+    ],
+    44
+  );
+
+  static readonly P3N3J4W4 = new VertexFormat(
+    [
+      { semantic: "position", components: 3, offset: 0 },
+      { semantic: "normal", components: 3, offset: 12 },
+      { semantic: "joints", components: 4, offset: 24 },
+      { semantic: "weights", components: 4, offset: 40 }
+    ],
+    56
+  );
+
+  getAttribute(semantic: VertexAttributeSemantic): VertexAttribute {
+    const attribute = this.attributes.find((candidate) => candidate.semantic === semantic);
+    if (!attribute) {
+      throw new Error(`Vertex format does not contain semantic ${semantic}`);
+    }
+    return attribute;
+  }
+
+  hasAttribute(semantic: VertexAttributeSemantic): boolean {
+    return this.attributes.some((attribute) => attribute.semantic === semantic);
+  }
+}
+
+function defaultShaderLocation(semantic: VertexAttributeSemantic): number {
+  switch (semantic) {
+    case "position":
+      return 0;
+    case "normal":
+      return 1;
+    case "uv":
+      return 2;
+    case "tangent":
+      return 3;
+    case "color":
+      return 4;
+    case "joints":
+      return 5;
+    case "weights":
+      return 6;
+    case "uv1":
+      return 7;
+  }
+}
+
+function defaultShaderName(semantic: VertexAttributeSemantic): string {
+  switch (semantic) {
+    case "position":
+      return "a_position";
+    case "normal":
+      return "a_normal";
+    case "uv":
+      return "a_uv";
+    case "uv1":
+      return "a_uv1";
+    case "tangent":
+      return "a_tangent";
+    case "color":
+      return "a_color";
+    case "joints":
+      return "a_joints";
+    case "weights":
+      return "a_weights";
+  }
+}