@rezless/vm 0.6.2 → 0.7.0

package/dist/prim-params.js

@@ -1,6 +1,7 @@
-import { ALL_SIDES, CLICK_ACTION_TOUCH, PRIM_ALPHA_MODE, PRIM_ALPHA_MODE_NONE, PRIM_ALLOW_UNSIT, PRIM_BUMP_NONE, PRIM_BUMP_SHINY, PRIM_CAST_SHADOWS, PRIM_CLICK_ACTION, PRIM_COLOR, PRIM_DAMAGE, PRIM_DESC, PRIM_FLEXIBLE, PRIM_FULLBRIGHT, PRIM_GLOW, PRIM_GLTF_ALPHA_MODE_OPAQUE, PRIM_GLTF_BASE_COLOR, PRIM_GLTF_EMISSIVE, PRIM_GLTF_METALLIC_ROUGHNESS, PRIM_GLTF_NORMAL, PRIM_HEALTH, PRIM_HOLE_DEFAULT, PRIM_LINK_TARGET, PRIM_MATERIAL, PRIM_MATERIAL_WOOD, PRIM_NAME, PRIM_NORMAL, PRIM_OMEGA, PRIM_PHANTOM, PRIM_PHYSICS, PRIM_PHYSICS_SHAPE_PRIM, PRIM_PHYSICS_SHAPE_TYPE, PRIM_POINT_LIGHT, PRIM_POSITION, PRIM_POS_LOCAL, PRIM_PROJECTOR, PRIM_REFLECTION_PROBE, PRIM_RENDER_MATERIAL, PRIM_ROTATION, PRIM_ROT_LOCAL, PRIM_SCRIPTED_SIT_ONLY, PRIM_SCULPT_TYPE_SPHERE, PRIM_SHINY_NONE, PRIM_SIT_FLAGS, PRIM_SIT_TARGET, PRIM_SIZE, PRIM_SLICE, PRIM_SPECULAR, PRIM_TEMP_ON_REZ, PRIM_TEXGEN, PRIM_TEXGEN_DEFAULT, PRIM_TEXT, PRIM_TEXTURE, PRIM_TYPE, PRIM_TYPE_BOX, PRIM_TYPE_CYLINDER, PRIM_TYPE_PRISM, PRIM_TYPE_RING, PRIM_TYPE_SCULPT, PRIM_TYPE_SPHERE, PRIM_TYPE_TORUS, PRIM_TYPE_TUBE, STATUS_PHANTOM, STATUS_PHYSICS, TEXTURE_DEFAULT, } from './generated/constants.js';
+import { CLICK_ACTION_TOUCH, OVERRIDE_GLTF_BASE_ALPHA, OVERRIDE_GLTF_BASE_ALPHA_MASK, OVERRIDE_GLTF_BASE_ALPHA_MODE, OVERRIDE_GLTF_BASE_COLOR_FACTOR, OVERRIDE_GLTF_BASE_DOUBLE_SIDED, OVERRIDE_GLTF_EMISSIVE_FACTOR, OVERRIDE_GLTF_METALLIC_FACTOR, OVERRIDE_GLTF_ROUGHNESS_FACTOR, PRIM_ALPHA_MODE, PRIM_ALPHA_MODE_BLEND, PRIM_ALPHA_MODE_MASK, PRIM_ALLOW_UNSIT, PRIM_BUMP_NONE, PRIM_BUMP_SHINY, PRIM_CAST_SHADOWS, PRIM_CLICK_ACTION, PRIM_COLOR, PRIM_DAMAGE, PRIM_DESC, PRIM_FLEXIBLE, PRIM_FULLBRIGHT, PRIM_GLOW, PRIM_GLTF_BASE_COLOR, PRIM_GLTF_EMISSIVE, PRIM_GLTF_METALLIC_ROUGHNESS, PRIM_GLTF_NORMAL, PRIM_HEALTH, PRIM_HOLE_DEFAULT, PRIM_LINK_TARGET, PRIM_MATERIAL, PRIM_MATERIAL_WOOD, PRIM_NAME, PRIM_NORMAL, PRIM_OMEGA, PRIM_PHANTOM, PRIM_PHYSICS, PRIM_PHYSICS_SHAPE_PRIM, PRIM_PHYSICS_SHAPE_TYPE, PRIM_POINT_LIGHT, PRIM_POSITION, PRIM_POS_LOCAL, PRIM_PROJECTOR, PRIM_REFLECTION_PROBE, PRIM_RENDER_MATERIAL, PRIM_ROTATION, PRIM_ROT_LOCAL, PRIM_SCRIPTED_SIT_ONLY, PRIM_SCULPT_TYPE_SPHERE, PRIM_SHINY_NONE, PRIM_SIT_FLAGS, PRIM_SIT_TARGET, PRIM_SIZE, PRIM_SLICE, PRIM_SPECULAR, PRIM_TEMP_ON_REZ, PRIM_TEXGEN, PRIM_TEXGEN_DEFAULT, PRIM_TEXT, PRIM_TEXTURE, PRIM_TYPE, PRIM_TYPE_BOX, PRIM_TYPE_CYLINDER, PRIM_TYPE_PRISM, PRIM_TYPE_RING, PRIM_TYPE_SCULPT, PRIM_TYPE_SPHERE, PRIM_TYPE_TORUS, PRIM_TYPE_TUBE, STATUS_PHANTOM, STATUS_PHYSICS, TEXTURE_DEFAULT, } from './generated/constants.js';
 import { NULL_KEY, isRotation, isVector } from './values/types.js';
 import { listElementType } from './values/list-types.js';
+import { InventoryType } from './inventory.js';
 import { truncateUtf8 } from './values/utf8.js';
 /**
  * Typed-literal aliases for the PRIM_TYPE_* constants. The
@@ -45,18 +46,109 @@ export function defaultFace() {
         fullBright: false,
         glow: 0,
         texgen: PRIM_TEXGEN_DEFAULT,
-        renderMaterial: '',
-        normal: defaultFaceMaterial(),
-        specular: { ...defaultFaceMaterial(), color: one(), glossiness: 51, environment: 0 },
-        alphaMode: { mode: PRIM_ALPHA_MODE_NONE, cutoff: 0 },
+        renderMaterial: NULL_KEY,
+        normal: { ...defaultFaceMaterial(), texture: NULL_KEY },
+        specular: { ...defaultFaceMaterial(), texture: NULL_KEY, color: one(), glossiness: 51, environment: 0 },
+        alphaMode: { mode: PRIM_ALPHA_MODE_BLEND, cutoff: 0 },
         gltf: {
-            baseColor: { ...defaultFaceMaterial(), color: one(), alpha: 1, alphaMode: PRIM_GLTF_ALPHA_MODE_OPAQUE, alphaCutoff: 0.5, doubleSided: 0 },
+            baseColor: { ...defaultFaceMaterial(), color: '', alpha: '', alphaMode: '', alphaCutoff: '', doubleSided: '' },
             normal: defaultFaceMaterial(),
-            metallicRoughness: { ...defaultFaceMaterial(), metallic: 1, roughness: 1 },
-            emissive: { ...defaultFaceMaterial(), tint: zero() },
+            metallicRoughness: { ...defaultFaceMaterial(), metallic: '', roughness: '' },
+            emissive: { ...defaultFaceMaterial(), tint: '' },
         },
     };
 }
+function clearGltfOverrides(g) {
+    g.baseColor = { ...g.baseColor, texture: '', color: '', alpha: '', alphaMode: '', alphaCutoff: '', doubleSided: '' };
+    g.normal = { ...g.normal, texture: '' };
+    g.metallicRoughness = { ...g.metallicRoughness, texture: '', metallic: '', roughness: '' };
+    g.emissive = { ...g.emissive, texture: '', tint: '' };
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const findItem = (prim, type, name) => prim.inventory.find((it) => it.type === type && it.name === name);
+/** The key a render material argument names: "" (none), a key, or a material item's name; null if it names nothing. */
+export function renderMaterialKey(prim, material) {
+    if (material === '')
+        return NULL_KEY;
+    if (UUID.test(material))
+        return material;
+    return findItem(prim, InventoryType.MATERIAL, material)?.key ?? null;
+}
+export function textureKey(prim, texture) {
+    if (texture === '')
+        return NULL_KEY;
+    if (UUID.test(texture))
+        return texture;
+    return findItem(prim, InventoryType.TEXTURE, texture)?.key ?? null;
+}
+const itemName = (prim, type, key) => key === NULL_KEY ? key : (prim.inventory.find((it) => it.type === type && it.key === key)?.name ?? key);
+export const textureName = (prim, key) => itemName(prim, InventoryType.TEXTURE, key);
+export const materialName = (prim, key) => itemName(prim, InventoryType.MATERIAL, key);
+const OVERRIDE_TYPES = {
+    [OVERRIDE_GLTF_BASE_COLOR_FACTOR]: 'vector',
+    [OVERRIDE_GLTF_BASE_ALPHA]: 'float',
+    [OVERRIDE_GLTF_BASE_ALPHA_MODE]: 'integer',
+    [OVERRIDE_GLTF_BASE_ALPHA_MASK]: 'float',
+    [OVERRIDE_GLTF_BASE_DOUBLE_SIDED]: 'integer',
+    [OVERRIDE_GLTF_METALLIC_FACTOR]: 'float',
+    [OVERRIDE_GLTF_ROUGHNESS_FACTOR]: 'float',
+    [OVERRIDE_GLTF_EMISSIVE_FACTOR]: 'vector',
+};
+const overrideType = (code) => (typeof code === 'number' ? OVERRIDE_TYPES[code] : undefined);
+/**
+ * Apply llSetLinkGLTFOverrides' [OVERRIDE_GLTF_*, value, ...] pairs. The base
+ * colour and alpha form one factor that "" leaves alone; "" clears the others.
+ * One wrong-typed value rejects the whole call; an unknown code is skipped.
+ */
+export function setGltfOverrides(g, params) {
+    for (let i = 0; i + 1 < params.length; i += 2) {
+        const expected = overrideType(params[i]);
+        if (expected === undefined || params[i + 1] === '')
+            continue;
+        const given = givenType(params, i + 1);
+        if (given !== expected && !(expected === 'float' && given === 'integer'))
+            return;
+    }
+    const bc = g.baseColor;
+    for (let i = 0; i + 1 < params.length; i += 2) {
+        const v = params[i + 1];
+        const n = typeof v === 'number' ? v : '';
+        switch (params[i]) {
+            case OVERRIDE_GLTF_BASE_COLOR_FACTOR:
+                if (isVector(v)) {
+                    bc.color = clampVec(asVec(v), 0, 1);
+                    if (bc.alpha === '')
+                        bc.alpha = 1;
+                }
+                break;
+            case OVERRIDE_GLTF_BASE_ALPHA:
+                if (typeof v === 'number') {
+                    bc.alpha = clamp(v, 0, 1);
+                    if (bc.color === '')
+                        bc.color = one();
+                }
+                break;
+            case OVERRIDE_GLTF_BASE_ALPHA_MODE:
+                bc.alphaMode = n === '' ? '' : clamp(n, 0, 2);
+                break;
+            case OVERRIDE_GLTF_BASE_ALPHA_MASK:
+                bc.alphaCutoff = n === '' ? '' : clamp(n, 0, 1);
+                break;
+            case OVERRIDE_GLTF_BASE_DOUBLE_SIDED:
+                bc.doubleSided = n === '' ? '' : clamp(n, 0, 1);
+                break;
+            case OVERRIDE_GLTF_METALLIC_FACTOR:
+                g.metallicRoughness.metallic = n === '' ? '' : clamp(n, 0, 1);
+                break;
+            case OVERRIDE_GLTF_ROUGHNESS_FACTOR:
+                g.metallicRoughness.roughness = n === '' ? '' : clamp(n, 0, 1);
+                break;
+            case OVERRIDE_GLTF_EMISSIVE_FACTOR:
+                g.emissive.tint = isVector(v) ? clampVec(asVec(v), 0, 1) : '';
+                break;
+        }
+    }
+}
 export function defaultShape() {
     return {
         kind: SHAPE_BOX,
@@ -74,7 +166,7 @@ export function defaultPrimParams() {
         rotation: identityRot(),
         size: { x: 0.5, y: 0.5, z: 0.5 },
         faces: Array.from({ length: 6 }, () => defaultFace()),
-        pointLight: { enabled: false, color: one(), intensity: 1, radius: 10, falloff: 0.75 },
+        pointLight: { enabled: false, color: zero(), intensity: 0, radius: 0, falloff: 0 },
         glow: [0, 0, 0, 0, 0, 0],
         omega: { axis: zero(), spinrate: 0, gain: 0 },
         physicsShapeType: PRIM_PHYSICS_SHAPE_PRIM,
@@ -128,11 +220,11 @@ function normalizeRot(r) {
         return identityRot();
     return { x: r.x / mag, y: r.y / mag, z: r.z / mag, s: r.s / mag };
 }
-/** Face indexes a face argument names: every face for ALL_SIDES, none past the shape's face count. */
+/** Face indexes a face argument names: every face for a negative face, none past the shape's face count. */
 export function faceIndices(p, face) {
-    if (face === ALL_SIDES)
+    if (face < 0)
         return p.faces.map((_, i) => i);
-    return face >= 0 && face < p.faces.length ? [face] : [];
+    return face < p.faces.length ? [face] : [];
 }
 const facesOf = (p, faceArg) => faceIndices(p, num(faceArg, 0) | 0);
 /**
@@ -214,20 +306,23 @@ export function writePrimParamSlots(param, rules, cursor) {
  * advances by `1 + consumed`). Returns `null` for unsupported / unknown
  * rule constants — the walker stops parsing the list, matching LSL.
  */
-export function writePrimParam(prim, param, rules, cursor) {
+export function writePrimParam(prim, param, rules, cursor, caller = prim) {
     const p = prim.params;
     switch (param) {
         case PRIM_NAME:
-            prim.name = truncateUtf8(str(rules[cursor]), 63);
+            prim.name = truncateUtf8(plainText(str(rules[cursor])), 63);
             return 1;
         case PRIM_DESC:
-            prim.description = truncateUtf8(str(rules[cursor]), 127);
+            prim.description = truncateUtf8(plainText(str(rules[cursor])), 127);
             prim.appearance.description = prim.description;
             return 1;
         case PRIM_TEXT: {
             const text = truncateUtf8(str(rules[cursor]), 254);
             const color = asVec(rules[cursor + 1]);
             const alpha = num(rules[cursor + 2], 1);
+            const outOfRange = (v) => v < 0 || v > 1;
+            if (outOfRange(alpha) || outOfRange(color.x) || outOfRange(color.y) || outOfRange(color.z))
+                return 3;
             prim.appearance.text = { text, color, alpha };
             return 3;
         }
@@ -341,29 +436,33 @@ export function writePrimParam(prim, param, rules, cursor) {
         }
         case PRIM_TEXTURE: {
             const faces = facesOf(p, rules[cursor]);
-            const tex = str(rules[cursor + 1]);
+            const tex = textureKey(caller, str(rules[cursor + 1])) ?? NULL_KEY;
             const repeats = asVec(rules[cursor + 2]);
             const offsets = asVec(rules[cursor + 3]);
             const rot = num(rules[cursor + 4]);
             for (const f of faces) {
                 p.faces[f].texture = tex;
-                p.faces[f].textureRepeats = { x: repeats.x, y: repeats.y, z: repeats.z };
-                p.faces[f].textureOffsets = { x: offsets.x, y: offsets.y, z: offsets.z };
+                p.faces[f].textureRepeats = { x: repeats.x, y: repeats.y, z: 0 };
+                p.faces[f].textureOffsets = { x: offsets.x, y: offsets.y, z: 0 };
                 p.faces[f].textureRotation = rot;
             }
             return 5;
         }
         case PRIM_RENDER_MATERIAL: {
             const faces = facesOf(p, rules[cursor]);
-            const m = str(rules[cursor + 1]);
+            const m = renderMaterialKey(caller, str(rules[cursor + 1])) ?? NULL_KEY;
             for (const f of faces) {
                 p.faces[f].renderMaterial = m;
+                clearGltfOverrides(p.faces[f].gltf);
             }
             return 2;
         }
         case PRIM_FULLBRIGHT: {
             const faces = facesOf(p, rules[cursor]);
-            const v = num(rules[cursor + 1]) !== 0;
+            const raw = num(rules[cursor + 1]);
+            if (raw !== 0 && raw !== 1)
+                return 2;
+            const v = raw === 1;
             for (const f of faces) {
                 p.faces[f].fullBright = v;
             }
@@ -382,6 +481,8 @@ export function writePrimParam(prim, param, rules, cursor) {
             const faces = facesOf(p, rules[cursor]);
             const shiny = num(rules[cursor + 1]) | 0;
             const bump = num(rules[cursor + 2]) | 0;
+            if (shiny < 0 || shiny > 3 || bump < 0 || bump > 17)
+                return 3;
             for (const f of faces) {
                 p.faces[f].bumpShiny = { shiny, bump };
             }
@@ -390,6 +491,8 @@ export function writePrimParam(prim, param, rules, cursor) {
         case PRIM_TEXGEN: {
             const faces = facesOf(p, rules[cursor]);
             const mode = num(rules[cursor + 1]) | 0;
+            if (mode < 0 || mode > 1)
+                return 2;
             for (const f of faces) {
                 p.faces[f].texgen = mode;
             }
@@ -398,12 +501,13 @@ export function writePrimParam(prim, param, rules, cursor) {
         case PRIM_NORMAL: {
             const faces = facesOf(p, rules[cursor]);
             const tex = str(rules[cursor + 1]);
-            const repeats = asVec(rules[cursor + 2]);
-            const offsets = asVec(rules[cursor + 3]);
-            const rot = num(rules[cursor + 4]);
+            const key = textureKey(caller, tex) ?? NULL_KEY;
+            const repeats = tex === '' ? { x: 1, y: 1, z: 0 } : asVec(rules[cursor + 2]);
+            const offsets = tex === '' ? zero() : asVec(rules[cursor + 3]);
+            const rot = tex === '' ? 0 : num(rules[cursor + 4]);
             for (const f of faces) {
                 p.faces[f].normal = {
-                    texture: tex,
+                    texture: key,
                     textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
                     textureOffsets: { x: offsets.x, y: offsets.y, z: offsets.z },
                     textureRotation: rot,
@@ -414,15 +518,17 @@ export function writePrimParam(prim, param, rules, cursor) {
         case PRIM_SPECULAR: {
             const faces = facesOf(p, rules[cursor]);
             const tex = str(rules[cursor + 1]);
-            const repeats = asVec(rules[cursor + 2]);
-            const offsets = asVec(rules[cursor + 3]);
-            const rot = num(rules[cursor + 4]);
-            const color = asVec(rules[cursor + 5]);
-            const gloss = num(rules[cursor + 6]) | 0;
-            const env = num(rules[cursor + 7]) | 0;
+            const key = textureKey(caller, tex) ?? NULL_KEY;
+            const reset = tex === '';
+            const repeats = reset ? { x: 1, y: 1, z: 0 } : asVec(rules[cursor + 2]);
+            const offsets = reset ? zero() : asVec(rules[cursor + 3]);
+            const rot = reset ? 0 : num(rules[cursor + 4]);
+            const color = reset ? one() : asVec(rules[cursor + 5]);
+            const gloss = reset ? 51 : clamp(num(rules[cursor + 6]) | 0, 0, 255);
+            const env = reset ? 0 : clamp(num(rules[cursor + 7]) | 0, 0, 255);
             for (const f of faces) {
                 p.faces[f].specular = {
-                    texture: tex,
+                    texture: key,
                     textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
                     textureOffsets: { x: offsets.x, y: offsets.y, z: offsets.z },
                     // Second Life stores a negative rotation as 0 and the colour in 8 bits per channel
@@ -436,99 +542,66 @@ export function writePrimParam(prim, param, rules, cursor) {
         }
         case PRIM_ALPHA_MODE: {
             const faces = facesOf(p, rules[cursor]);
-            const mode = num(rules[cursor + 1]) | 0;
-            const cutoff = num(rules[cursor + 2]) | 0;
+            const mode = clamp(num(rules[cursor + 1]) | 0, 0, 3);
+            const cutoff = mode === PRIM_ALPHA_MODE_MASK ? clamp(num(rules[cursor + 2]) | 0, 0, 255) : 0;
             for (const f of faces) {
                 p.faces[f].alphaMode = { mode, cutoff };
             }
             return 3;
         }
         case PRIM_GLTF_BASE_COLOR: {
-            const faces = facesOf(p, rules[cursor]);
-            const tex = str(rules[cursor + 1]);
-            const repeats = asVec(rules[cursor + 2]);
-            const offsets = asVec(rules[cursor + 3]);
-            const rot = num(rules[cursor + 4]);
-            const color = asVec(rules[cursor + 5]);
-            const alpha = num(rules[cursor + 6], 1);
-            const aMode = num(rules[cursor + 7]) | 0;
-            const aCut = num(rules[cursor + 8]);
-            const dbl = num(rules[cursor + 9]) | 0;
-            for (const f of faces) {
-                p.faces[f].gltf.baseColor = {
-                    texture: tex,
-                    textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
-                    textureOffsets: { x: offsets.x, y: offsets.y, z: offsets.z },
-                    textureRotation: rot,
-                    color: { x: color.x, y: color.y, z: color.z },
-                    alpha,
-                    alphaMode: aMode,
-                    alphaCutoff: aCut,
-                    doubleSided: dbl,
-                };
-            }
+            const color = rules[cursor + 5];
+            const alpha = rules[cursor + 6];
+            const factor = color !== '' || alpha !== '';
+            writeGltf(prim, caller, rules, cursor, 'baseColor', {
+                color: factor ? (color === '' ? one() : clampVec(asVec(color), 0, 1)) : '',
+                alpha: factor ? clamp(num(alpha, 1), 0, 1) : '',
+                alphaMode: valueOverride(rules[cursor + 7], (v) => clamp(num(v) | 0, 0, 2)),
+                alphaCutoff: valueOverride(rules[cursor + 8], (v) => clamp(num(v), 0, 1)),
+                doubleSided: valueOverride(rules[cursor + 9], (v) => clamp(num(v) | 0, 0, 1)),
+            });
             return 10;
         }
-        case PRIM_GLTF_NORMAL: {
-            const faces = facesOf(p, rules[cursor]);
-            const tex = str(rules[cursor + 1]);
-            const repeats = asVec(rules[cursor + 2]);
-            const offsets = asVec(rules[cursor + 3]);
-            const rot = num(rules[cursor + 4]);
-            for (const f of faces) {
-                p.faces[f].gltf.normal = {
-                    texture: tex,
-                    textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
-                    textureOffsets: { x: offsets.x, y: offsets.y, z: offsets.z },
-                    textureRotation: rot,
-                };
-            }
+        case PRIM_GLTF_NORMAL:
+            writeGltf(prim, caller, rules, cursor, 'normal', {});
             return 5;
-        }
-        case PRIM_GLTF_METALLIC_ROUGHNESS: {
-            const faces = facesOf(p, rules[cursor]);
-            const tex = str(rules[cursor + 1]);
-            const repeats = asVec(rules[cursor + 2]);
-            const offsets = asVec(rules[cursor + 3]);
-            const rot = num(rules[cursor + 4]);
-            const metallic = num(rules[cursor + 5]);
-            const rough = num(rules[cursor + 6]);
-            for (const f of faces) {
-                p.faces[f].gltf.metallicRoughness = {
-                    texture: tex,
-                    textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
-                    textureOffsets: { x: offsets.x, y: offsets.y, z: offsets.z },
-                    textureRotation: rot,
-                    metallic,
-                    roughness: rough,
-                };
-            }
+        case PRIM_GLTF_METALLIC_ROUGHNESS:
+            writeGltf(prim, caller, rules, cursor, 'metallicRoughness', {
+                metallic: valueOverride(rules[cursor + 5], (v) => clamp(num(v), 0, 1)),
+                roughness: valueOverride(rules[cursor + 6], (v) => clamp(num(v), 0, 1)),
+            });
             return 7;
-        }
-        case PRIM_GLTF_EMISSIVE: {
-            const faces = facesOf(p, rules[cursor]);
-            const tex = str(rules[cursor + 1]);
-            const repeats = asVec(rules[cursor + 2]);
-            const offsets = asVec(rules[cursor + 3]);
-            const rot = num(rules[cursor + 4]);
-            const tint = asVec(rules[cursor + 5]);
-            for (const f of faces) {
-                p.faces[f].gltf.emissive = {
-                    texture: tex,
-                    textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
-                    textureOffsets: { x: offsets.x, y: offsets.y, z: offsets.z },
-                    textureRotation: rot,
-                    tint: { x: tint.x, y: tint.y, z: tint.z },
-                };
-            }
+        case PRIM_GLTF_EMISSIVE:
+            writeGltf(prim, caller, rules, cursor, 'emissive', { tint: valueOverride(rules[cursor + 5], (v) => clampVec(asVec(v), 0, 1)) });
             return 6;
-        }
         case PRIM_LINK_TARGET:
             return null;
         default:
             return null;
     }
 }
+const valueOverride = (v, read) => (v === '' ? '' : read(v));
+/**
+ * Write one PRIM_GLTF_* rule. "" in a transform slot resets it; "" in a texture
+ * or value slot unsets that override. Faces without a render material keep
+ * only the transforms.
+ */
+function writeGltf(prim, caller, rules, cursor, rule, values) {
+    const transform = {
+        textureRepeats: rules[cursor + 2] === '' ? { x: 1, y: 1, z: 0 } : asVec(rules[cursor + 2]),
+        textureOffsets: asVec(rules[cursor + 3]),
+        textureRotation: num(rules[cursor + 4]),
+    };
+    const name = str(rules[cursor + 1]);
+    const texture = name === '' ? '' : (textureKey(caller, name) ?? NULL_KEY);
+    for (const f of facesOf(prim.params, rules[cursor])) {
+        const face = prim.params.faces[f];
+        const overrides = face.renderMaterial === NULL_KEY ? {} : { texture, ...values };
+        face.gltf[rule] = { ...face.gltf[rule], ...transform, ...overrides };
+    }
+}
+/** Names and descriptions can't hold the separator characters; they become `?`. */
+const plainText = (s) => s.replace(/[|\n]/g, '?');
 function writePrimType(p, rules, cursor) {
     const kind = (num(rules[cursor]) | 0);
     const old = p.shape;
@@ -606,7 +679,7 @@ export function readPrimParam(prim, param, rules, cursor) {
             return { values: [prim.description], consumed: 0 };
         case PRIM_TEXT: {
             const t = prim.appearance.text;
-            return { values: t ? [t.text, t.color, t.alpha] : ['', zero(), 0], consumed: 0 };
+            return { values: t ? [t.text, t.color, t.alpha] : ['', zero(), 1], consumed: 0 };
         }
         case PRIM_POSITION:
             return { values: [prim.regionPosition()], consumed: 0 };
@@ -683,7 +756,7 @@ export function readPrimParam(prim, param, rules, cursor) {
             const out = [];
             for (const f of faces) {
                 const fa = p.faces[f];
-                out.push(fa.texture, fa.textureRepeats, fa.textureOffsets, fa.textureRotation);
+                out.push(textureName(prim, fa.texture), fa.textureRepeats, fa.textureOffsets, fa.textureRotation);
             }
             return { values: out, consumed: 1 };
         }
@@ -691,7 +764,7 @@ export function readPrimParam(prim, param, rules, cursor) {
             const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                out.push(p.faces[f].renderMaterial);
+                out.push(materialName(prim, p.faces[f].renderMaterial));
             }
             return { values: out, consumed: 1 };
         }
@@ -732,7 +805,7 @@ export function readPrimParam(prim, param, rules, cursor) {
             const out = [];
             for (const f of faces) {
                 const n = p.faces[f].normal;
-                out.push(n.texture, n.textureRepeats, n.textureOffsets, n.textureRotation);
+                out.push(textureName(prim, n.texture), n.textureRepeats, n.textureOffsets, n.textureRotation);
             }
             return { values: out, consumed: 1 };
         }
@@ -741,7 +814,7 @@ export function readPrimParam(prim, param, rules, cursor) {
             const out = [];
             for (const f of faces) {
                 const s = p.faces[f].specular;
-                out.push(s.texture, s.textureRepeats, s.textureOffsets, s.textureRotation, s.color, s.glossiness, s.environment);
+                out.push(textureName(prim, s.texture), s.textureRepeats, s.textureOffsets, s.textureRotation, s.color, s.glossiness, s.environment);
             }
             return { values: out, consumed: 1 };
         }
@@ -812,6 +885,7 @@ function readPrimType(p) {
     return [];
 }
 const MATERIAL_TYPES = ['string', 'vector', 'vector', 'float'];
+const MAP_TYPES = ['key', 'vector', 'vector', 'float'];
 /**
  * LSL types of the values each PRIM_* rule reads. Per-face rules list one
  * face's values; the pattern repeats for each face.
@@ -851,13 +925,13 @@ const PRIM_PARAM_TYPES = {
     [PRIM_GLOW]: ['float'],
     [PRIM_BUMP_SHINY]: ['integer', 'integer'],
     [PRIM_TEXGEN]: ['integer'],
-    [PRIM_NORMAL]: MATERIAL_TYPES,
-    [PRIM_SPECULAR]: [...MATERIAL_TYPES, 'vector', 'integer', 'integer'],
+    [PRIM_NORMAL]: MAP_TYPES,
+    [PRIM_SPECULAR]: [...MAP_TYPES, 'vector', 'integer', 'integer'],
     [PRIM_ALPHA_MODE]: ['integer', 'integer'],
-    [PRIM_GLTF_BASE_COLOR]: [...MATERIAL_TYPES, 'vector', 'float', 'integer', 'float', 'integer'],
-    [PRIM_GLTF_NORMAL]: MATERIAL_TYPES,
-    [PRIM_GLTF_METALLIC_ROUGHNESS]: [...MATERIAL_TYPES, 'float', 'float'],
-    [PRIM_GLTF_EMISSIVE]: [...MATERIAL_TYPES, 'vector'],
+    [PRIM_GLTF_BASE_COLOR]: [...MAP_TYPES, 'vector', 'float', 'integer', 'float', 'integer'],
+    [PRIM_GLTF_NORMAL]: MAP_TYPES,
+    [PRIM_GLTF_METALLIC_ROUGHNESS]: [...MAP_TYPES, 'float', 'float'],
+    [PRIM_GLTF_EMISSIVE]: [...MAP_TYPES, 'vector'],
 };
 /** LSL types of PRIM_TYPE's values, which depend on the shape. */
 function primTypeTypes(kind) {
@@ -871,10 +945,12 @@ function primTypeTypes(kind) {
     }
     return [...common, 'vector', 'vector'];
 }
+/** GLTF override rules take "" in any slot after the face to mean "no override", and read an unset one as "". */
+const GLTF_RULES = new Set([PRIM_GLTF_BASE_COLOR, PRIM_GLTF_NORMAL, PRIM_GLTF_METALLIC_ROUGHNESS, PRIM_GLTF_EMISSIVE]);
 /** LSL types of the values `readPrimParam` returns for `param`. */
 export function primParamTypes(param, values) {
     const pattern = param === PRIM_TYPE ? primTypeTypes(values[0]) : (PRIM_PARAM_TYPES[param] ?? []);
-    return values.map((_, i) => pattern[i % pattern.length]);
+    return values.map((v, i) => (GLTF_RULES.has(param) && v === '' ? 'string' : pattern[i % pattern.length]));
 }
 const PER_FACE_RULES = new Set([
     PRIM_COLOR, PRIM_TEXTURE, PRIM_RENDER_MATERIAL, PRIM_FULLBRIGHT, PRIM_GLOW, PRIM_BUMP_SHINY,
@@ -921,12 +997,12 @@ const formatG = (v) => String(Number(v.toPrecision(6)));
  * the rule can run, otherwise the error text that follows "rule #N" in the
  * simulator's message (e.g. " (PRIM_SIZE): arg #1 vector expected but string given").
  */
-/** GLTF override rules take "" in any slot after the face to mean "no override". */
-const GLTF_RULES = new Set([PRIM_GLTF_BASE_COLOR, PRIM_GLTF_NORMAL, PRIM_GLTF_METALLIC_ROUGHNESS, PRIM_GLTF_EMISSIVE]);
 export function checkPrimRule(param, rules, cursor) {
     const name = RULE_NAMES.get(param);
-    if (name === undefined || writePrimParamSlots(param, rules, cursor) === null)
+    if (name === undefined)
         return ': unknown rule';
+    if (writePrimParamSlots(param, rules, cursor) === null)
+        return param === PRIM_TYPE ? null : ': unknown rule';
     const pattern = param === PRIM_TYPE ? primTypeTypes(rules[cursor]) : PRIM_PARAM_TYPES[param];
     const expected = PER_FACE_RULES.has(param) ? ['integer', ...pattern] : pattern;
     for (let i = 0; i < expected.length; i++) {