@driftengine/assets 4.4.2 → 4.6.0

package/dist/gltf.js

@@ -428,6 +428,7 @@ function materialOf(material) {
      * A separate occlusion image is dropped rather than loaded into a second unit. One map, one
      * unit, and `textureUnitBudget.test.ts` says the next unit belongs to emissive.
      */
+    const glass = glassOf(material, modulated ? undefined : roughness);
     const occlusion = material?.occlusionTexture;
     const occlusionStrength = modulated && occlusion !== undefined && occlusion.index === ormMap
         ? (occlusion.strength ?? 1)
@@ -447,7 +448,7 @@ function materialOf(material) {
          * cannot say the material blends, and a leaf whose shape is all in its texture's alpha drew as a
          * solid card. So it is said.
          */
-        blend: blends,
+        blend: blends || glass.transmission > 0,
         /* Seen from both faces: a curtain, a leaf card. The specification's default is one face. */
         doubleSided: material?.doubleSided === true,
         /* Only in MASK mode: the specification says `alphaCutoff` has no meaning in the other two. */
@@ -463,8 +464,42 @@ function materialOf(material) {
         metallicScale: modulated ? (pbr?.metallicFactor ?? 1) : 1,
         occlusionStrength,
         albedo: pbr?.baseColorTexture?.index ?? -1,
+        transmission: glass.transmission,
+        frost: glass.frost,
+        tint: glass.tint,
     };
 }
+const unit = (value, fallback) => Math.min(1, Math.max(0, value ?? fallback));
+/**
+ * What a material's extensions say about letting light through, as this engine's glass.
+ *
+ * **Rough glass is frosted glass.** `KHR_materials_transmission` says its roughness blurs what is
+ * seen through the surface, and that blur is exactly what `frost` is, so a transmissive material's
+ * roughness raises its frost and a diffusely transmitting share raises it too — whichever says
+ * more. Only transmission makes a material glass: a surface stating diffuse transmission alone is a
+ * leaf or a sheet of paper, which this engine's glass would draw see-through and let every shadow
+ * pass, so it stays the opaque surface it was. What that gives up is a paper shade stated by that
+ * extension alone, which arrives opaque; a per-material override is the door for it.
+ *
+ * `roughness` is `undefined` where a map carries the roughness per texel: the factor then only
+ * scales the map, so it says nothing about how rough the glass is, and frost comes from the
+ * diffuse share alone rather than from a number the file did not state.
+ */
+function glassOf(material, roughness) {
+    const ext = material?.extensions;
+    const transmission = unit(ext?.KHR_materials_transmission?.transmissionFactor, 0);
+    if (transmission <= 0)
+        return { transmission: 0, frost: 0, tint: [1, 1, 1] };
+    const diffuse = ext?.KHR_materials_diffuse_transmission;
+    const frost = Math.max(unit(diffuse?.diffuseTransmissionFactor, 0), unit(roughness, 0));
+    const colour = diffuse?.diffuseTransmissionColorFactor ?? ext?.KHR_materials_volume?.attenuationColor;
+    const tint = [
+        unit(colour?.[0], 1),
+        unit(colour?.[1], 1),
+        unit(colour?.[2], 1),
+    ];
+    return { transmission, frost, tint };
+}
 /** The required extensions this reader implements, or follows far enough to fail loudly. */
 const KNOWN_REQUIRED = new Set([
     'KHR_materials_pbrSpecularGlossiness',

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export type { DrftFit, DrftLoaderOptions } from './drftLoader.ts';
 export { drawKeyOf, resolveDrawGrouping } from './drawKey.ts';
 export type { DrawGrouping, DrawSurfaceOverride } from './drawKey.ts';
 export type { DrftLoadPhase, DrftLoadProgress, DrftPart } from './loadProgress.ts';
+export type { LoadedRegion, LoadedRegionLevel } from './regionStore.ts';
 export type { DrftFieldPlacement } from './fieldPlacement.ts';
 export { TextureSet, textureColorSpaces } from './drftTextures.ts';
 export { assetCandidates, basenameOf } from './assetPath.ts';

package/dist/loadProgress.d.ts

@@ -1,4 +1,4 @@
-import type { MeshHandle, InstancedHandle, MeshInstances } from '@driftengine/core';
+import type { GlassOptions, MeshHandle, InstancedHandle, MeshInstances } from '@driftengine/core';
 /**
  * The vocabulary of a load in flight: which phase it is in, how far it has got, and what a
  * finished part is.
@@ -120,6 +120,13 @@ export interface DrftPart {
     readonly blend: boolean;
     /** Whether both faces are seen: glTF's `doubleSided`. Drawn without culling, each face lit as the front. */
     readonly doubleSided: boolean;
+    /**
+     * The glass this part is, from its file or from `DrftLoaderOptions.surface`, or null for a part
+     * that lets no light through. A glass part is also `blend`, so a caller drawing blended parts
+     * translucent passes this as the draw's `glass` and every pane arrives as the file or the
+     * override said. One object per merged group, shared by its parts, so it is not rebuilt per draw.
+     */
+    readonly glass: GlassOptions | null;
     /**
      * The copies this part is drawn as, or null for a part drawn once.
      *

package/dist/regionStore.d.ts

@@ -0,0 +1,94 @@
+import type { MeshInstances, RendererApi } from '@driftengine/core';
+import type { DrftAssembly, DrftRegion, DrftRegionCollision, PieceLookup } from '@driftengine/drft';
+import type { MeshData } from '@driftengine/drft';
+import type { DrftPart } from './loadProgress.ts';
+/** How the loader placed the model: `p · scale + (x, y, z)`. */
+export interface LoaderFit {
+    readonly scale: number;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+export interface LoadedRegionLevel {
+    /** How far, in metres of the file, this level may stand from the real surface. */
+    readonly error: number;
+    /** One part a mesh, filled as they upload. */
+    readonly parts: DrftPart[];
+    /** Whether any of its meshes arrived as assemblies, kept small until paged in. */
+    paged: boolean;
+    /** Whether every mesh is up: always, for a level that is not paged. */
+    resident: boolean;
+}
+export interface LoadedRegion {
+    readonly id: number;
+    /** Min xyz then max xyz, placed. */
+    readonly bounds: Float32Array;
+    /** Finest first. `HlodSet.add` takes the errors, scaled by the fit. */
+    readonly levels: readonly LoadedRegionLevel[];
+    /** Its props, one instanced part a prototype, culled per instance. */
+    readonly batches: DrftPart[];
+    /**
+     * Which of the region's groups in the file each batch is, index for index. Batches are built as
+     * their prototypes arrive, not in the file's order, so a caller pairing something of its own with
+     * each group — a material, a blend — pairs through this, never by position.
+     */
+    readonly batchGroups: number[];
+    /** Six floats a box, placed, for `addOccluder`. */
+    readonly occluders: Float32Array;
+    /** What it collides as, placed, or null. */
+    readonly collision: DrftRegionCollision | null;
+    /** Meshes and batches still to come; 0 once every level and prop is up. */
+    pending: number;
+}
+/**
+ * Copies of a fitted prototype, each matrix conjugated by the fit: M becomes F·M·F⁻¹, the same turn
+ * and a translation of t − R·t + s·u for the fit's scale s and offset t and the copy's own
+ * translation u. The prototype already carries the fit, so the copies land where its geometry does
+ * and are not scaled twice.
+ */
+export declare function fitCopies(transforms: Float32Array, fit: LoaderFit): MeshInstances;
+export declare class RegionStore {
+    private readonly renderer;
+    private readonly fit;
+    readonly regions: Map<number, LoadedRegion>;
+    /** Level meshes by ordinal: whose, and which level. */
+    private readonly levelOwners;
+    /** Prototypes that have uploaded, by ordinal. */
+    private readonly prototypes;
+    /** Groups whose prototype has not uploaded yet, by its ordinal. */
+    private readonly waiting;
+    private readonly jobs;
+    private readonly made;
+    /** Assemblies held small, by ordinal, and each paged level's ordinals. */
+    private readonly compact;
+    private readonly levelCompact;
+    /** Paged meshes asked for and not yet up, and those that are. */
+    private readonly requested;
+    private readonly pagedParts;
+    constructor(renderer: RendererApi, fit: () => LoaderFit | null);
+    /** Whether a mesh is a region's, as a level or a prop, and so is not a part of the model. */
+    owns(ordinal: number): boolean;
+    /** Whether batches are queued. */
+    get busy(): boolean;
+    /** A region's chunk has landed, ahead of the meshes it introduces. */
+    admit(region: DrftRegion): void;
+    /** Whether a mesh is one of a region's levels. */
+    isLevelMesh(ordinal: number): boolean;
+    /** A level's assembly has arrived: held small, its level paged and not yet up. */
+    hold(ordinal: number, assembly: DrftAssembly, piece: PieceLookup): void;
+    /**
+     * Ask for a paged level's meshes, or free them. Coming up, returns each mesh still to upload with
+     * a way to expand it, for the loader's queue; going down, frees what is up and returns the
+     * ordinals released, so the loader can drop any still queued.
+     */
+    page(id: number, level: number, resident: boolean): {
+        ordinal: number;
+        expand: () => MeshData;
+    }[];
+    private release;
+    /** A region's mesh has uploaded, as the part the loader would have made of it. */
+    arrived(ordinal: number, part: DrftPart): void;
+    /** Build one queued batch inside the caller's budget; false when none was queued. */
+    buildNext(): boolean;
+    dispose(): void;
+}

package/dist/regionStore.js

@@ -0,0 +1,272 @@
+/**
+ * The regions of a streamed world as they arrive: each one's meshes at every level, its prop
+ * batches, its occluders and its collision, kept apart from the loader's parts and never merged.
+ *
+ * **Apart, because a region's levels are alternatives rather than pieces.** The loader merges its
+ * parts by material into one mesh a group, which is right for one model and wrong here twice over:
+ * it would weld a district's finest level to its coarsest, drawing both, and weld one district to
+ * the next, so none could be dropped when the eye leaves. So a region's meshes upload on the
+ * loader's clocked queue like any part and land here instead, one part a mesh, a list a level.
+ *
+ * **A prop's prototype arrives once and serves every region that places it.** A region naming a
+ * prototype already up gets its batch at the next budgeted build; one naming a prototype still to
+ * come waits for it. Either way the batch is built inside a frame's budget, never from the stream's
+ * callback, and culls instance by instance (`createInstanced`'s `cull`).
+ *
+ * **A level that arrives as assemblies is paged** (`MSHC`, `drftAssembly.ts`). A city's finest
+ * level is millions of triangles, more than any device keeps resident, so such a level is held as
+ * the copies the file carried — tens of kilobytes a district — and comes up only when the caller
+ * pages it in, expanded and uploaded on the same clocked queue; paged out, its meshes are freed and
+ * the copies stay. What it costs is a region that is not yet up when the eye arrives: the caller
+ * draws a coarser level until `resident` says the fine one is there, and pages ahead of the eye.
+ *
+ * Everything is in the loader's placement: a world loads with `{ fit: 'none' }`, where that is the
+ * file's own space.
+ */
+import { createMeshInstances } from '@driftengine/core';
+import { expandAssembly } from '@driftengine/drft';
+/**
+ * Copies of a fitted prototype, each matrix conjugated by the fit: M becomes F·M·F⁻¹, the same turn
+ * and a translation of t − R·t + s·u for the fit's scale s and offset t and the copy's own
+ * translation u. The prototype already carries the fit, so the copies land where its geometry does
+ * and are not scaled twice.
+ */
+export function fitCopies(transforms, fit) {
+    const count = transforms.length / 16;
+    const data = createMeshInstances(count);
+    for (let k = 0; k < count; k++) {
+        const at = k * 16;
+        for (let i = 0; i < 12; i++)
+            data.models[at + i] = transforms[at + i];
+        /* R·t, with R the copy's own 3×3 read column-major. */
+        const rtx = transforms[at] * fit.x +
+            transforms[at + 4] * fit.y +
+            transforms[at + 8] * fit.z;
+        const rty = transforms[at + 1] * fit.x +
+            transforms[at + 5] * fit.y +
+            transforms[at + 9] * fit.z;
+        const rtz = transforms[at + 2] * fit.x +
+            transforms[at + 6] * fit.y +
+            transforms[at + 10] * fit.z;
+        data.models[at + 12] = fit.x - rtx + fit.scale * transforms[at + 12];
+        data.models[at + 13] = fit.y - rty + fit.scale * transforms[at + 13];
+        data.models[at + 14] = fit.z - rtz + fit.scale * transforms[at + 14];
+        data.models[at + 15] = 1;
+    }
+    data.tints.fill(1);
+    data.count = count;
+    return data;
+}
+/** Points packed xyz, placed by the fit into a new array. */
+function placed(points, fit) {
+    const out = new Float32Array(points.length);
+    for (let i = 0; i < points.length; i += 3) {
+        out[i] = points[i] * fit.scale + fit.x;
+        out[i + 1] = points[i + 1] * fit.scale + fit.y;
+        out[i + 2] = points[i + 2] * fit.scale + fit.z;
+    }
+    return out;
+}
+export class RegionStore {
+    renderer;
+    fit;
+    regions = new Map();
+    /** Level meshes by ordinal: whose, and which level. */
+    levelOwners = new Map();
+    /** Prototypes that have uploaded, by ordinal. */
+    prototypes = new Map();
+    /** Groups whose prototype has not uploaded yet, by its ordinal. */
+    waiting = new Map();
+    jobs = [];
+    made = [];
+    /** Assemblies held small, by ordinal, and each paged level's ordinals. */
+    compact = new Map();
+    levelCompact = new Map();
+    /** Paged meshes asked for and not yet up, and those that are. */
+    requested = new Set();
+    pagedParts = new Map();
+    constructor(renderer, fit) {
+        this.renderer = renderer;
+        this.fit = fit;
+    }
+    /** Whether a mesh is a region's, as a level or a prop, and so is not a part of the model. */
+    owns(ordinal) {
+        return (this.levelOwners.has(ordinal) || this.prototypes.has(ordinal) || this.waiting.has(ordinal));
+    }
+    /** Whether batches are queued. */
+    get busy() {
+        return this.jobs.length > 0;
+    }
+    /** A region's chunk has landed, ahead of the meshes it introduces. */
+    admit(region) {
+        const fit = this.fit() ?? { scale: 1, x: 0, y: 0, z: 0 };
+        const loaded = {
+            id: region.id,
+            bounds: new Float32Array([
+                ...placed([region.bounds[0], region.bounds[1], region.bounds[2]], fit),
+                ...placed([region.bounds[3], region.bounds[4], region.bounds[5]], fit),
+            ]),
+            levels: region.levels.map((level) => ({
+                error: level.error * fit.scale,
+                parts: [],
+                paged: false,
+                resident: true,
+            })),
+            batches: [],
+            batchGroups: [],
+            occluders: placed(region.occluders, fit),
+            collision: region.collision === null
+                ? null
+                : {
+                    positions: placed(region.collision.positions, fit),
+                    indices: region.collision.indices,
+                },
+            pending: 0,
+        };
+        region.levels.forEach((level, index) => {
+            for (const mesh of level.meshes) {
+                this.levelOwners.set(mesh, { region: loaded, level: index });
+                loaded.pending++;
+            }
+        });
+        region.instances.forEach((group, index) => {
+            loaded.pending++;
+            const prototype = this.prototypes.get(group.mesh);
+            if (prototype !== undefined) {
+                this.jobs.push({ region: loaded, prototype, transforms: group.transforms, group: index });
+                return;
+            }
+            const list = this.waiting.get(group.mesh) ?? [];
+            list.push({ region: loaded, transforms: group.transforms, group: index });
+            this.waiting.set(group.mesh, list);
+        });
+        this.regions.set(region.id, loaded);
+    }
+    /** Whether a mesh is one of a region's levels. */
+    isLevelMesh(ordinal) {
+        return this.levelOwners.has(ordinal);
+    }
+    /** A level's assembly has arrived: held small, its level paged and not yet up. */
+    hold(ordinal, assembly, piece) {
+        const owner = this.levelOwners.get(ordinal);
+        const level = owner?.region.levels[owner.level];
+        if (owner === undefined || level === undefined)
+            return;
+        this.compact.set(ordinal, { assembly, piece });
+        const list = this.levelCompact.get(level) ?? [];
+        list.push(ordinal);
+        this.levelCompact.set(level, list);
+        level.paged = true;
+        level.resident = false;
+        owner.region.pending--;
+    }
+    /**
+     * Ask for a paged level's meshes, or free them. Coming up, returns each mesh still to upload with
+     * a way to expand it, for the loader's queue; going down, frees what is up and returns the
+     * ordinals released, so the loader can drop any still queued.
+     */
+    page(id, level, resident) {
+        const lv = this.regions.get(id)?.levels[level];
+        const ordinals = lv === undefined ? undefined : this.levelCompact.get(lv);
+        if (lv === undefined || ordinals === undefined)
+            return [];
+        const out = [];
+        for (const ordinal of ordinals) {
+            const held = this.compact.get(ordinal);
+            if (held === undefined)
+                continue;
+            if (resident) {
+                if (this.pagedParts.has(ordinal) || this.requested.has(ordinal))
+                    continue;
+                this.requested.add(ordinal);
+                out.push({ ordinal, expand: () => expandAssembly(held.assembly, held.piece) });
+                continue;
+            }
+            this.requested.delete(ordinal);
+            const part = this.pagedParts.get(ordinal);
+            out.push({ ordinal, expand: () => expandAssembly(held.assembly, held.piece) });
+            if (part === undefined)
+                continue;
+            this.pagedParts.delete(ordinal);
+            this.release(part);
+            const at = lv.parts.indexOf(part);
+            if (at >= 0)
+                lv.parts.splice(at, 1);
+        }
+        if (!resident)
+            lv.resident = false;
+        return out;
+    }
+    release(part) {
+        const at = this.made.indexOf(part.mesh);
+        if (at >= 0)
+            this.made.splice(at, 1);
+        this.renderer.disposeMesh(part.mesh);
+    }
+    /** A region's mesh has uploaded, as the part the loader would have made of it. */
+    arrived(ordinal, part) {
+        if (this.compact.has(ordinal)) {
+            /* Paged out again while it was on its way up: nothing wants it. */
+            if (!this.requested.delete(ordinal)) {
+                this.renderer.disposeMesh(part.mesh);
+                return;
+            }
+            this.made.push(part.mesh);
+            this.pagedParts.set(ordinal, part);
+            const owner = this.levelOwners.get(ordinal);
+            const level = owner?.region.levels[owner.level];
+            if (level === undefined)
+                return;
+            level.parts.push(part);
+            level.resident = (this.levelCompact.get(level) ?? []).every((o) => this.pagedParts.has(o));
+            return;
+        }
+        this.made.push(part.mesh);
+        const owner = this.levelOwners.get(ordinal);
+        if (owner !== undefined) {
+            owner.region.levels[owner.level]?.parts.push(part);
+            owner.region.pending--;
+            return;
+        }
+        this.prototypes.set(ordinal, part);
+        for (const group of this.waiting.get(ordinal) ?? []) {
+            this.jobs.push({
+                region: group.region,
+                prototype: part,
+                transforms: group.transforms,
+                group: group.group,
+            });
+        }
+        this.waiting.delete(ordinal);
+    }
+    /** Build one queued batch inside the caller's budget; false when none was queued. */
+    buildNext() {
+        const job = this.jobs.shift();
+        if (job === undefined)
+            return false;
+        const data = fitCopies(job.transforms, this.fit() ?? { scale: 1, x: 0, y: 0, z: 0 });
+        try {
+            const batch = this.renderer.createInstanced(job.prototype.mesh, data.count, { cull: true });
+            this.renderer.uploadInstanced(batch, data);
+            job.region.batches.push({ ...job.prototype, reveal: 1, instances: { batch, data } });
+            job.region.batchGroups.push(job.group);
+        }
+        catch (error) {
+            console.warn(`DrftLoader: region ${job.region.id}'s props would not upload`, error);
+        }
+        job.region.pending--;
+        return true;
+    }
+    dispose() {
+        for (const region of this.regions.values()) {
+            for (const part of region.batches) {
+                if (part.instances !== null)
+                    this.renderer.disposeInstanced(part.instances.batch);
+            }
+        }
+        for (const mesh of this.made)
+            this.renderer.disposeMesh(mesh);
+        this.made.length = 0;
+        this.regions.clear();
+    }
+}

package/dist/repeats.js

@@ -9,6 +9,7 @@ const EQUAL = [
     'relief',
     'emissiveColor',
     'channel',
+    'layers',
 ];
 /**
  * How far a copy's normal may sit from the prototype's once turned, as a chord on the unit sphere.

package/dist/weld.js

@@ -59,6 +59,12 @@ const ATTRIBUTES = {
      * tip merged into the trunk it grows from would stop moving.
      */
     channel: 4,
+    /*
+     * The texture-array layer. In the key for the same reason as the channel: two vertices at one
+     * position on two faces wearing different images are two vertices, and welding them would put one
+     * face on the other's picture.
+     */
+    layers: 1,
 };
 const NAMES = Object.keys(ATTRIBUTES);
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/assets",
-  "version": "4.4.2",
+  "version": "4.6.0",
   "description": "Model readers and the streaming loader for the .drft container",
   "license": "Apache-2.0",
   "type": "module",
@@ -27,11 +27,11 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@driftengine/drft": "4.4.2",
-    "@driftengine/texture": "4.4.2"
+    "@driftengine/drft": "4.6.0",
+    "@driftengine/texture": "4.6.0"
   },
   "peerDependencies": {
-    "@driftengine/core": "4.4.2"
+    "@driftengine/core": "4.6.0"
   },
   "author": "Drift Technologies",
   "repository": {

package/src/drawKey.ts

@@ -25,6 +25,15 @@ export interface DrawSurfaceOverride {
    * gallery and read as a black blotch. 0 says dielectric.
    */
   readonly metallicScale?: number;
+  /**
+   * Glass, in place of what the file says: the share of light that passes, how milky it is, and
+   * the colour it takes (`GlassOptions` in the renderer). For a model whose panes arrive as an
+   * opaque dark material, because its format or its exporter had no word for glass. Transmission
+   * above zero draws the part blended.
+   */
+  readonly transmission?: number;
+  readonly frost?: number;
+  readonly tint?: readonly [number, number, number];
 }
 
 /**
@@ -50,8 +59,17 @@ export interface DrawGrouping {
   /** Whether both faces are drawn and lit. A merge of a two-sided part and a one-sided one would cull
    *  one of them or unhide the back of the other, so it is part of the key. */
   readonly doubleSided: boolean;
+  /**
+   * Glass. Zero transmission is not glass, and then frost is 0 and the tint white whatever the
+   * file or the override said, so a stray value on an opaque surface never splits a draw.
+   */
+  readonly transmission: number;
+  readonly frost: number;
+  readonly tint: readonly [number, number, number];
 }
 
+const CLEAR: readonly [number, number, number] = [1, 1, 1];
+
 /**
  * Resolve what a part will actually be drawn with.
  *
@@ -60,7 +78,7 @@ export interface DrawGrouping {
  * 0, which is the identity that lets a file saying nothing about a property draw the same as one
  * that did not have the property to say.
  *
- * The override wins over the material for the three fields it may carry, because a consumer dressing
+ * The override wins over the material for the fields it may carry, because a consumer dressing
  * a surface by name knows more than a default an exporter wrote. A cutout is not among them: it is
  * a fact about the *image* a material wears, so nothing outside the file has anything to say
  * about it.
@@ -69,6 +87,8 @@ export function resolveDrawGrouping(
   material: DrftMaterial | undefined,
   override?: DrawSurfaceOverride,
 ): DrawGrouping {
+  const transmission = Math.max(0, override?.transmission ?? material?.transmission ?? 0);
+  const glass = transmission > 0;
   return {
     albedo: material?.albedo ?? -1,
     orm: material?.ormMap ?? -1,
@@ -80,8 +100,11 @@ export function resolveDrawGrouping(
     metallicScale: override?.metallicScale ?? material?.metallicScale ?? 1,
     occlusionStrength: material?.occlusionStrength ?? 0,
     cutout: material?.cutout ?? 0,
-    blend: material?.blend === true,
+    blend: material?.blend === true || glass,
     doubleSided: material?.doubleSided === true,
+    transmission,
+    frost: glass ? (override?.frost ?? material?.frost ?? 0) : 0,
+    tint: glass ? (override?.tint ?? material?.tint ?? CLEAR) : CLEAR,
   };
 }
 
@@ -101,5 +124,5 @@ export function drawKeyOf(
   override?: DrawSurfaceOverride,
 ): string {
   const g = resolveDrawGrouping(material, override);
-  return `${g.albedo}:${g.orm}:${g.normal}:${g.emissive}:${g.opacity}:${g.reflectivity}:${g.roughnessScale}:${g.metallicScale}:${g.occlusionStrength}:${g.cutout}:${g.blend ? 1 : 0}:${g.doubleSided ? 1 : 0}`;
+  return `${g.albedo}:${g.orm}:${g.normal}:${g.emissive}:${g.opacity}:${g.reflectivity}:${g.roughnessScale}:${g.metallicScale}:${g.occlusionStrength}:${g.cutout}:${g.blend ? 1 : 0}:${g.doubleSided ? 1 : 0}:${g.transmission}:${g.frost}:${g.tint[0]},${g.tint[1]},${g.tint[2]}`;
 }