@sw-file-lib/three 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Teinishi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,536 @@
+import * as THREE from "three";
+import { BufferGeometry } from "three";
+import { Color } from "@sw-file-lib/core/color";
+import { BinaryReaderInput, MeshData, PhysData, PhysGroup } from "@sw-file-lib/core";
+import { ComponentDefinitionImmutable, ComponentDefinitionSchemas, VehicleSchemas } from "@sw-file-lib/xml";
+import { BuildSurfaceGeometryOptions, GeometryBuilder } from "@sw-file-lib/geometry";
+//#region src/geometry.d.ts
+/**
+ * Transfers the contents of a {@link GeometryBuilder} into a `THREE.BufferGeometry`.
+ *
+ * This function clears the existing attributes and groups of the buffer geometry,
+ * then copies the position, normal, color, index, and group data from the builder.
+ *
+ * @param builder The source geometry builder.
+ * @param buffer The target buffer geometry.
+ */
+declare function applyBuilderOnBufferGeometry(builder: GeometryBuilder, buffer: BufferGeometry): void;
+/**
+ * Creates a new `THREE.BufferGeometry` from a {@link GeometryBuilder}.
+ */
+declare function bufferGeometryFromBuilder(builder: GeometryBuilder): BufferGeometry;
+//#endregion
+//#region src/lights.d.ts
+/** Options used when creating the default Stormworks-style lights. */
+interface CreateSwLightsOptions {
+  /** Intensity of the hemisphere light. Defaults to `1.6`. */
+  readonly hemisphereIntensity?: number;
+  /** Intensity of the directional light. Defaults to `1.0`. */
+  readonly directionalIntensity?: number;
+}
+/**
+ * Create the default Stormworks-style light objects.
+ *
+ * The returned array contains a hemisphere light and a directional light.
+ */
+declare function createSwLights(options?: CreateSwLightsOptions): [THREE.HemisphereLight, THREE.DirectionalLight];
+/** Create a group containing the default Stormworks-style lights. */
+declare function createSwLightGroup(options?: CreateSwLightsOptions): THREE.Group;
+//#endregion
+//#region src/material/uniformController.d.ts
+declare const CREATE: unique symbol;
+declare const ATTACH: unique symbol;
+type UniformTransformer<T> = {
+  toUniform(value: T): any;
+  fromUniform(value: any): T | undefined;
+};
+type UniformTransformerMap<T> = { [K in keyof T]: UniformTransformer<T[K]>; };
+/**
+ * Manages shader uniforms for a material.
+ */
+declare class UniformController<T extends object> {
+  private transformers;
+  private pending;
+  private shaderUniforms?;
+  /** @hidden */
+  static [CREATE]<T extends object>(transformers: UniformTransformerMap<T>): UniformController<T>;
+  private constructor();
+  /** @hidden */
+  [ATTACH](shader: Record<string, THREE.IUniform>): void;
+  /** Gets the value of a uniform. */
+  get<K extends keyof T>(key: K): T[K] | undefined;
+  /** Sets the value of a uniform. */
+  set<K extends keyof T>(key: K, value: T[K]): void;
+  /** Patches multiple uniforms at once. */
+  patch(values: Partial<T>): void;
+}
+//#endregion
+//#region src/material/additive.d.ts
+/** Uniforms used by the additive material. */
+interface AdditiveUniforms {
+  /**
+   * Whether to override the vertex colors with a single color.
+   *
+   * When enabled, the `overrideColor` uniform is used instead of the vertex colors.
+   */
+  overrideColorEnabled: boolean;
+  /** The color to use when `overrideColorEnabled` is true. */
+  overrideColor: Color;
+}
+/**
+ * Manages shader uniforms for the additive material.
+ *
+ * This can be created using {@link createAdditiveUniforms} and attached to a material using {@link createAdditiveMaterial}.
+ *
+ * @example
+ * ```ts
+ * const additiveUniforms: AdditiveUniformController = createAdditiveUniforms();
+ *
+ * additiveUniforms.set("overrideColorEnabled", true);
+ * additiveUniforms.set("overrideColor", { r: 255, g: 0, b: 0 });
+ * ```
+ */
+type AdditiveUniformController = UniformController<AdditiveUniforms>;
+/**
+ * Create the default uniforms used for additive materials.
+ *
+ * An additive material can be created using {@link createAdditiveMaterial}.
+ *
+ * The default uniforms are:
+ * - `overrideColorEnabled`: true
+ * - `overrideColor`: white
+ *
+ * @example
+ * ```ts
+ * const additiveUniforms = createAdditiveUniforms({
+ *  overrideColorEnabled: false
+ * });
+ *
+ * const additiveMaterial = createAdditiveMaterial(additiveUniforms);
+ * ```
+ */
+declare function createAdditiveUniforms(defaults?: Partial<AdditiveUniforms>): AdditiveUniformController;
+/**
+ * Create an additive material used for materialIndex 2 groups.
+ *
+ * If you want to use custom uniforms, you can create them using {@link createAdditiveUniforms} and pass them to this function.
+ *
+ * You can override the material parameters by passing a `THREE.MeshBasicMaterialParameters` object as the second argument.
+ *
+ * @returns A new `THREE.MeshBasicMaterial` with the specified uniforms, or a default one if not provided.
+ */
+declare function createAdditiveMaterial(uniforms?: AdditiveUniformController | undefined | null, materialParameters?: THREE.MeshBasicMaterialParameters): THREE.MeshBasicMaterial;
+//#endregion
+//#region src/material/glass.d.ts
+/** Uniforms used by the glass material. */
+interface GlassUniforms {
+  /** The color of the reflection of the sky when looking up. */
+  skyColorUp: Color;
+  /**  The color of the reflection of the sky when looking down. */
+  skyColorDown: Color;
+}
+/**
+ * Manages shader uniforms for the glass material.
+ *
+ * This can be created using {@link createGlassUniforms} and attached to a material using {@link createGlassMaterial}.
+ *
+ * @example
+ * ```ts
+ * const glassUniforms: GlassUniformController = createGlassUniforms();
+ *
+ * glassUniforms.set("skyColorUp", { r: 0, g: 61, b: 182 });
+ * glassUniforms.set("skyColorDown", { r: 139, g: 210, b: 207 });
+ * ```
+ */
+type GlassUniformController = UniformController<GlassUniforms>;
+/**
+ * Create the default uniforms used for glass materials.
+ *
+ * A glass material can be created using {@link createGlassMaterial}.
+ *
+ * The default uniforms are:
+ * - `skyColorUp`: { r: 0, g: 61, b: 182 }
+ * - `skyColorDown`: { r: 139, g: 210, b: 207 }
+ *
+ * @example
+ * ```ts
+ * const glassUniforms = createGlassUniforms({
+ *  skyColorUp: { r: 0, g: 61, b: 182 },
+ *  skyColorDown: { r: 139, g: 210, b: 207 }
+ * });
+ *
+ * const glassMaterial = createGlassMaterial(glassUniforms);
+ * ```
+ */
+declare function createGlassUniforms(defaults?: Partial<GlassUniforms>): GlassUniformController;
+/**
+ * Create the default glass material used for materialIndex 1 groups.
+ *
+ * If you want to use custom uniforms, you can create them using {@link createGlassUniforms} and pass them to this function.
+ *
+ * You can override the material parameters by passing a `THREE.ShaderMaterialParameters` object as the second argument.
+ *
+ * @returns A new `THREE.ShaderMaterial` with the specified uniforms, or a default one if not provided.
+ */
+declare function createGlassMaterial(uniforms?: GlassUniformController, materialParameters?: THREE.ShaderMaterialParameters): THREE.ShaderMaterial;
+//#endregion
+//#region src/material/opaque.d.ts
+/** Uniforms used by the opaque material. */
+interface OpaqueUniforms {
+  /**
+   * Whether to override the vertex colors.
+   *
+   * When enabled, the `overrideColor1`, `overrideColor2`, and `overrideColor3` uniforms are used instead of certain vertex colors.
+   */
+  overrideColorEnabled: boolean;
+  /** The color to override vertex colors that is close to `(255, 126, 0)` with when `overrideColorEnabled` is true. */
+  overrideColor1: Color;
+  /** The color to override vertex colors that is close to `(155, 126, 0)` with when `overrideColorEnabled` is true. */
+  overrideColor2: Color;
+  /** The color to override vertex colors that is close to `(55, 126, 0)` with when `overrideColorEnabled` is true. */
+  overrideColor3: Color;
+}
+/**
+ * Manages shader uniforms for the opaque material.
+ *
+ * This can be created using {@link createOpaqueUniforms} and attached to a material using {@link createOpaqueMaterial}.
+ *
+ * @example
+ * ```ts
+ * const opaqueUniforms: OpaqueUniformController = createOpaqueUniforms();
+ *
+ * opaqueUniforms.set("overrideColorEnabled", true);
+ * opaqueUniforms.set("overrideColor1", { r: 255, g: 0, b: 0 });
+ * opaqueUniforms.set("overrideColor2", { r: 0, g: 255, b: 0 });
+ * opaqueUniforms.set("overrideColor3", { r: 0, g: 0, b: 255 });
+ * ```
+ */
+type OpaqueUniformController = UniformController<OpaqueUniforms>;
+/**
+ * Create the default uniforms used for opaque materials.
+ *
+ * An opaque material can be created using {@link createOpaqueMaterial}.
+ *
+ * The default uniforms are:
+ * - `overrideColorEnabled`: true
+ * - `overrideColor1`: white
+ * - `overrideColor2`: white
+ * - `overrideColor3`: white
+ *
+ * @example
+ * ```ts
+ * const opaqueUniforms = createOpaqueUniforms({
+ *  overrideColorEnabled: false
+ * });
+ *
+ * const opaqueMaterial = createOpaqueMaterial(opaqueUniforms);
+ * ```
+ */
+declare function createOpaqueUniforms(defaults?: Partial<OpaqueUniforms>): OpaqueUniformController;
+/**
+ * Create the default opaque material used for materialIndex 0 groups.
+ *
+ * If you want to use custom uniforms, you can create them using {@link createOpaqueUniforms} and pass them to this function.
+ *
+ * You can override the material parameters by passing a `THREE.MeshStandardMaterialParameters` object as the second argument.
+ *
+ * @returns A new `THREE.MeshStandardMaterial` with the specified uniforms, or a default one if not provided.
+ */
+declare function createOpaqueMaterial(uniforms?: OpaqueUniformController, materialParameters?: THREE.MeshStandardMaterialParameters): THREE.MeshStandardMaterial;
+//#endregion
+//#region src/material/materials.d.ts
+/** Material families for Stormworks mesh. */
+type SwMaterialKind = "opaque" | "glass" | "additive";
+/** Mutable Three.js uniform stores owned by a Stormworks material set. */
+interface SwUniformControllers {
+  /** Uniforms used by the opaque render material. */
+  opaque: OpaqueUniformController;
+  /** Uniforms used by the glass render material. */
+  glass: GlassUniformController;
+  /** Uniforms used by the additive render material. */
+  additive: AdditiveUniformController;
+}
+/** Materials and their uniform stores used by Stormworks object creation helpers. */
+interface SwMaterialSet {
+  /** Material used for shader id `0` groups. */
+  opaque: THREE.MeshStandardMaterial;
+  /** Material used for shader id `1` groups. */
+  glass: THREE.ShaderMaterial;
+  /** Material used for shader id `2` groups. */
+  additive: THREE.MeshBasicMaterial;
+  /** Uniform stores attached to this material set. */
+  uniforms: SwUniformControllers;
+}
+/** Options used when creating the default Stormworks material set. */
+interface CreateSwMaterialsOptions {
+  /** Initial uniforms applied after each material family's defaults are created. */
+  readonly uniforms?: {
+    opaque?: Partial<OpaqueUniforms>;
+    glass?: Partial<GlassUniforms>;
+    additive?: Partial<AdditiveUniforms>;
+  };
+}
+/**
+ * Create the default materials used by Stormworks object helpers.
+ *
+ * A new material set has independent uniform stores, making it suitable for
+ * object-local color and shader state. Share the returned set only when objects
+ * should intentionally share uniform updates.
+ */
+declare function createSwMaterials(options?: CreateSwMaterialsOptions): SwMaterialSet;
+//#endregion
+//#region src/mesh.d.ts
+/** Options used when creating a render mesh object from parsed `mesh` data. */
+interface CreateSwMeshOptions {
+  /** Optional display name assigned to the created mesh. */
+  readonly name?: string;
+  /** Materials used for opaque, glass, and additive groups. */
+  readonly materials?: Readonly<SwMaterialSet>;
+}
+/** Options used when creating a physics mesh group from parsed `phys` data. */
+interface CreateSwPhysMeshOptions {
+  /** Optional display name assigned to the created group. */
+  readonly name?: string;
+}
+/**
+ * Create a renderable Three.js mesh from parsed Stormworks `mesh` data.
+ *
+ * The returned mesh owns its geometry. It uses material groups mapped from the
+ * file's group shader ids: opaque, glass, and additive.
+ */
+declare function createSwMesh(mesh: MeshData, options?: CreateSwMeshOptions): THREE.Mesh<THREE.BufferGeometry, THREE.Material[]>;
+/**
+ * Create a Three.js group from parsed Stormworks `phys` data.
+ *
+ * Each physics section becomes a child mesh using the `phys` material from the
+ * supplied material set.
+ */
+declare function createSwPhysMeshGroup(mesh: PhysData, material: THREE.Material, options?: CreateSwPhysMeshOptions): THREE.Group;
+/**
+ * Create buffer geometry for parsed Stormworks render mesh data.
+ *
+ * The geometry includes `position`, `normal`, and `color` attributes, and material groups derived from group shader ids.
+ */
+declare function createSwMeshGeometry(mesh: MeshData): THREE.BufferGeometry;
+/**
+ * Create buffer geometry for parsed Stormworks phys group.
+ *
+ * The geometry includes `position` attributes.
+ */
+declare function createSwPhysGroupGeometry(physGroup: PhysGroup): THREE.BufferGeometry;
+//#endregion
+//#region src/vehicleAssembler/assetResolver.d.ts
+/**
+ * Resolves a component definition from its component ID.
+ *
+ * Returns `undefined` if the component definition cannot be found.
+ */
+type ComponentDefinitionResolver = (componentId: string | undefined) => Promise<ComponentDefinitionImmutable | undefined>;
+/**
+ * Resolves a Three.js geometry from a Stormworks mesh path.
+ *
+ * Returns `undefined` if the mesh asset cannot be found.
+ */
+type MeshResolver = (meshPath: string) => Promise<THREE.BufferGeometry | undefined>;
+/**
+ * Asset resolver used by {@link VehicleBodyAssembler}.
+ *
+ * This interface provides parsed component definitions and mesh geometries,
+ * allowing applications to load assets from any source such as the local
+ * filesystem, HTTP, IndexedDB, or an in-memory cache.
+ */
+interface VehicleAssetResolver {
+  /** Resolves a parsed component definition. */
+  resolveComponentDefinition: ComponentDefinitionResolver;
+  /** Resolves a parsed mesh geometry. */
+  resolveMesh: MeshResolver;
+}
+/**
+ * Creates a {@link VehicleAssetResolver} from raw asset providers.
+ *
+ * The returned resolver automatically parses XML component definitions,
+ * converts Stormworks mesh files into `THREE.BufferGeometry`, and
+ * caches the results so each asset is loaded and parsed at most once.
+ *
+ * This is the recommended way to construct a resolver for {@link VehicleBodyAssembler}.
+ *
+ * @param getComponentDefinitionFile Returns the XML source of a component
+ * definition.
+ * @param getMeshFile Returns the binary contents of a Stormworks mesh file.
+ * @returns A cached asset resolver.
+ */
+declare function createVehicleAssetResolver(getComponentDefinitionFile: (componentId: string) => Promise<string | Uint8Array<ArrayBuffer> | undefined> | string | Uint8Array<ArrayBuffer> | undefined, getMeshFile: (meshPath: string) => Promise<BinaryReaderInput | undefined> | BinaryReaderInput | undefined): VehicleAssetResolver;
+/**
+ * Wraps an asynchronous resolver with memoization.
+ *
+ * The returned function caches both completed results and in-flight promises,
+ * ensuring that concurrent requests for the same key share a single operation.
+ *
+ * @param resolver The resolver to memoize.
+ * @returns A cached resolver.
+ */
+declare function withCache<K, V>(resolver: (key: K) => Promise<V>): (key: K) => Promise<V>;
+//#endregion
+//#region src/vehicleAssembler/bodyAssembler.d.ts
+/** The names of the mesh reference attributes in the component definition XML. */
+declare const MESH_ATTRIBUTE_NAMES: readonly ["mesh_data_name", "mesh_0_name", "mesh_1_name", "mesh_2_name"];
+/** The type for the mesh reference attributes in the component definition XML. */
+type MeshAttributeName = (typeof MESH_ATTRIBUTE_NAMES)[number];
+/**
+ * Options for {@link VehicleBodyAssembler.build}.
+ */
+interface VehicleBodyBuildOptions {
+  /**
+   * Generates border of surfaces.
+   *
+   * @default false
+   */
+  readonly edge?: boolean;
+  /**
+   * Generates only the surface border.
+   *
+   * Implies `edge=true`.
+   *
+   * @default false
+   */
+  readonly hollow?: boolean;
+  /**
+   * Removes hidden internal surfaces before generating geometry.
+   *
+   * @default true
+   */
+  readonly cull?: boolean;
+}
+/**
+ * Assembles a single Stormworks vehicle body into Three.js objects.
+ *
+ * The assembler collects component geometry and meshes, then produces one
+ * `THREE.Group` containing a culled surface mesh and any additional meshes.
+ *
+ * A single instance should be used for one vehicle body.
+ *
+ * The primary methods most applications should call are {@link appendComponent} and {@link build}.
+ *
+ * @example
+ * ```ts
+ * import * as THREE from "three";
+ * import { parseVehicleXml } from "@sw-file-lib/xml";
+ * import { createVehicleAssetResolver, VehicleBodyAssembler } from "@sw-file-lib/three";
+ *
+ * const assetResolver = createVehicleAssetResolver(
+ *   (componentId) =>
+ *     fetch(`/rom/data/definitions/${componentId}.xml`)
+ *     .then((res) => res.ok ? res.text() : undefined),
+ *   (meshPath) =>
+ *     fetch(`/rom/${meshPath}`)
+ *     .then((res) => res.ok ? res.arrayBuffer() : undefined)
+ * );
+ *
+ * const vehicle = parseVehicleXml(text);
+ * const vehicleGroup = new THREE.Group();
+ *
+ * for (const body of vehicle.bodies ?? []) {
+ *   const assembler = new VehicleBodyAssembler(assetResolver);
+ *   for (const component of body.components ?? []) {
+ *     await assembler.appendComponent(component);
+ *   }
+ *
+ *   const obj = assembler.build();
+ *   vehicleGroup.add(obj);
+ * }
+ *
+ * scene.add(vehicleGroup);
+ * ```
+ */
+declare class VehicleBodyAssembler {
+  private assets;
+  private surfaces;
+  private groups;
+  /**
+   * Creates a new body assembler.
+   *
+   * @param assets Callbacks used to resolve component definitions and mesh assets.
+   * Create a resolver with {@link createVehicleAssetResolver}, or make your own.
+   * Wrapping them with a cache is recommended when loading from disk or over the network.
+   */
+  constructor(assets: VehicleAssetResolver);
+  /**
+   * Appends a component to the body.
+   *
+   * The component type is detected automatically, and the appropriate builder
+   * is used internally. This is the primary method most applications should call.
+   *
+   * @param componentInstance The component instance from the vehicle body.
+   * Represented by a `<c>` element in the vehicle XML.
+   */
+  appendComponent(componentInstance: VehicleSchemas.ComponentImmutable): Promise<void>;
+  /**
+   * Appends surfaces and prebuilt objects to the body.
+   *
+   * This is a low-level API intended for custom or unsupported components.
+   * All surfaces and objects must be provided in the component's local
+   * coordinate system; they will be transformed into body space automatically.
+   *
+   * @param componentInstance The component instance from the vehicle body.
+   * Represented by a `<c>` element in the vehicle XML.
+   * @param surfaceDefinitions Surface definitions in local space.
+   * @param objects Additional Three.js objects in local space.
+   */
+  appendRawComponent(componentInstance: VehicleSchemas.ComponentImmutable, surfaceDefinitions?: readonly ComponentDefinitionSchemas.SurfaceImmutable[] | undefined, objects?: readonly THREE.Object3D[] | undefined): void;
+  /**
+   * Appends a standard component using its component definition.
+   *
+   * This resolves surface definitions and any required mesh assets, transforms
+   * them into world space, and adds them to the current body.
+   *
+   * Most users should prefer {@link appendComponent}, which performs type
+   * detection automatically.
+   *
+   * @param componentInstance The component instance from the vehicle body.
+   * Represented by a `<c>` element in the vehicle XML.
+   * @param definition The component definition for the component instance.
+   * @param meshesToExclude Optional list of mesh attributes to ignore.
+   */
+  appendStandardComponent(componentInstance: VehicleSchemas.ComponentImmutable, definition?: ComponentDefinitionImmutable, meshesToExclude?: readonly MeshAttributeName[]): Promise<void>;
+  /**
+   * Appends a paintable sign component.
+   *
+   * Paintable signs generate their geometry dynamically from the component
+   * properties and do not use a predefined mesh asset.
+   *
+   * @param componentInstance The component instance from the vehicle body.
+   * Represented by a `<c>` element in the vehicle XML.
+   * @param definition The component definition for the component instance.
+   */
+  appendPaintableSign(componentInstance: VehicleSchemas.ComponentImmutable, definition: ComponentDefinitionImmutable): Promise<void>;
+  /**
+   * Appends a microcontroller component.
+   *
+   * Microcontrollers have variable dimensions and therefore generate their
+   * surfaces and meshes procedurally instead of using a fixed definition.
+   *
+   * @param componentInstance The component instance from the vehicle body.
+   * Represented by a `<c>` element in the vehicle XML.
+   */
+  appendMicrocontroller(componentInstance: VehicleSchemas.ComponentImmutable): Promise<void>;
+  /**
+   * Builds the merged surface mesh for this body using {@link GeometryBuilder}.
+   *
+   * Surface culling is performed before constructing geometry unless explicitly disabled by the options.
+   * The returned geometry does not include any additional meshes.
+   *
+   * @see {@link build} for the complete object including additional meshes.
+   */
+  buildSurfaceMesh(options?: BuildSurfaceGeometryOptions): GeometryBuilder;
+  /**
+   * Builds the final Three.js object representing this vehicle body.
+   *
+   * The returned group contains the merged surface mesh together with every
+   * additional mesh appended during assembly.
+   *
+   * @returns A complete Three.js group for the body.
+   */
+  build(surfaceOptions?: VehicleBodyBuildOptions): THREE.Group;
+}
+//#endregion
+export { AdditiveUniformController, AdditiveUniforms, ComponentDefinitionResolver, CreateSwLightsOptions, CreateSwMaterialsOptions, CreateSwMeshOptions, CreateSwPhysMeshOptions, GlassUniformController, GlassUniforms, MESH_ATTRIBUTE_NAMES, MeshAttributeName, MeshResolver, OpaqueUniformController, OpaqueUniforms, SwMaterialKind, SwMaterialSet, SwUniformControllers, UniformController, VehicleAssetResolver, VehicleBodyAssembler, VehicleBodyBuildOptions, applyBuilderOnBufferGeometry, bufferGeometryFromBuilder, createAdditiveMaterial, createAdditiveUniforms, createGlassMaterial, createGlassUniforms, createOpaqueMaterial, createOpaqueUniforms, createSwLightGroup, createSwLights, createSwMaterials, createSwMesh, createSwMeshGeometry, createSwPhysGroupGeometry, createSwPhysMeshGroup, createVehicleAssetResolver, withCache };