@aura3d/rendering 1.4.0 → 1.4.2

package/src/VegetationFixtures.ts

@@ -1,314 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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";
-  }
-}