@carbonenginejs/runtime 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/trinity/core/mesh/Tr2Mesh.js

@@ -1,224 +1,329 @@
-import { applyDecs2311 as _applyDecs2311 } from '../../../_virtual/_rollupPluginBabelHelpers.js';
-import { io, type, carbon, impl } from '#schema';
+import { identity as _identity, applyDecs2311 as _applyDecs2311 } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { edit, type, carbon, impl } from '#schema';
+import { ResourceRequirement } from '#resource';
+import { blue } from '#blue';
 import { Tr2MeshBase as _Tr2MeshBase } from './Tr2MeshBase.js';
 import { Tr2SerializedMorphAnimation as _Tr2SerializedMorphAn } from './Tr2SerializedMorphAnimation.js';
 
-let _initProto, _initClass, _init_geometryResPath, _init_extra_geometryResPath, _init_serializedMorphAnimations, _init_extra_serializedMorphAnimations, _init_deferGeometryLoad, _init_extra_deferGeometryLoad, _init_geometry, _init_extra_geometry;
+let _initProto, _initClass, _init_geometryResPath, _init_extra_geometryResPath, _init_serializedMorphAnimations, _init_extra_serializedMorphAnimations, _init_deferGeometryLoad, _init_extra_deferGeometryLoad, _init_geometry, _init_extra_geometry, _init_lowResGeometry, _init_extra_lowResGeometry;
 
 /**
  * A mesh backed by a geometry resource, adding the resource path plus the
  * morph-target weights and baked-morph state on top of Tr2MeshBase.
  */
 let _Tr2Mesh;
-class Tr2Mesh extends _Tr2MeshBase {
-  static {
-    ({
-      e: [_init_geometryResPath, _init_extra_geometryResPath, _init_serializedMorphAnimations, _init_extra_serializedMorphAnimations, _init_deferGeometryLoad, _init_extra_deferGeometryLoad, _init_geometry, _init_extra_geometry, _initProto],
-      c: [_Tr2Mesh, _initClass]
-    } = _applyDecs2311(this, [type.define({
-      className: "Tr2Mesh",
-      family: "trinityCore"
-    })], [[[void 0, io.rebuild("geometry"), io, io.notify, io, io.persist, type, type.string], 16, "geometryResPath"], [[io, io.persistOnly, void 0, type.list("Tr2SerializedMorphAnimation")], 16, "serializedMorphAnimations"], [[io, io.notify, io, io.persist, type, type.boolean], 16, "deferGeometryLoad"], [[void 0, io.rebuild("geometry"), io, io.read, void 0, type.objectRef("TriGeometryRes")], 16, "geometry"], [[carbon, carbon.method, impl, impl.adapted], 18, "Initialize"], [[carbon, carbon.method, impl, impl.adapted], 18, "OnModified"], [[carbon, carbon.method, impl, impl.adapted], 18, "SetMeshResPath"], [[carbon, carbon.method, impl, impl.adapted], 18, "SetGeometryRes"], [[carbon, carbon.method, impl, impl.adapted], 18, "GetGeometryResource"], [[carbon, carbon.method, impl, impl.adapted], 18, "GetGeometryResPath"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetAreasCount"], [[impl, impl.adapted], 18, "InitializeMorphTargets"], [[carbon, carbon.method, impl, impl.adapted], 18, "GetMorphTargetNames"], [[impl, impl.implemented], 18, "IsBakedMorph"], [[carbon, carbon.method, impl, impl.implemented], 18, "SetMorphTargetWeight"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetMorphTargetWeight"], [[carbon, carbon.method, impl, impl.adapted], 18, "SetBakedMorphTarget"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetBakedMorphTarget"], [[impl, impl.adapted], 18, "GetAllBakedMorphTargetStates"], [[impl, impl.adapted], 18, "GetMorphAnimations"]], 0, void 0, _Tr2MeshBase));
-  }
-  constructor(...args) {
-    super(...args);
-    _init_extra_geometry(this);
-  }
-  #bakedMorphTargets = (_initProto(this), []);
-  #morphAnimations = new Map();
-  geometryResPath = _init_geometryResPath(this, "");
-  serializedMorphAnimations = (_init_extra_geometryResPath(this), _init_serializedMorphAnimations(this, []));
-  deferGeometryLoad = (_init_extra_serializedMorphAnimations(this), _init_deferGeometryLoad(this, false));
-  geometry = (_init_extra_deferGeometryLoad(this), _init_geometry(this, null));
-
-  /**
-   * True while the bound geometry resource is still loading; false when no
-   * resource is bound.
-   */
-  get isLoading() {
-    return this.geometry?.IsLoading?.() ?? false;
-  }
+new class extends _identity {
+  static [class Tr2Mesh extends _Tr2MeshBase {
+    static {
+      ({
+        e: [_init_geometryResPath, _init_extra_geometryResPath, _init_serializedMorphAnimations, _init_extra_serializedMorphAnimations, _init_deferGeometryLoad, _init_extra_deferGeometryLoad, _init_geometry, _init_extra_geometry, _init_lowResGeometry, _init_extra_lowResGeometry, _initProto],
+        c: [_Tr2Mesh, _initClass]
+      } = _applyDecs2311(this, [type.define({
+        className: "Tr2Mesh",
+        family: "trinityCore"
+      })], [[[edit, edit.notify, edit, edit.persist, type, type.string], 16, "geometryResPath"], [[edit, edit.persistOnly, void 0, type.list("Tr2SerializedMorphAnimation")], 16, "serializedMorphAnimations"], [[edit, edit.notify, edit, edit.persist, type, type.boolean], 16, "deferGeometryLoad"], [[edit, edit.read, void 0, type.objectRef("TriGeometryRes")], 16, "geometry"], [[edit, edit.read, void 0, type.objectRef("TriGeometryRes")], 16, "lowResGeometry"], [[carbon, carbon.method, impl, impl.implemented], 18, "Initialize"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon's load fence (m_loadFence.Put) is unported; there is no prepare-phase fence here, so both requests are simply issued.")], 18, "InitializeGeometryResource"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("JS identifies Carbon's changed member address by its exposed property name.")], 18, "OnModified"], [[carbon, carbon.method, impl, impl.implemented], 18, "SetMeshResPath"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon's IBlueAsyncResNotifyTarget pair becomes the resource's own completion event; a caller-supplied object with no lifecycle (tests, hand-composed graphs) is treated as already complete.")], 18, "SetGeometryRes"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Bounds are computed on demand by Tr2MeshBase.GetBounds rather than cached, so Carbon's CacheBounds call has nothing to refresh.")], 18, "RebuildCachedData"], [[carbon, carbon.method, impl, impl.adapted, void 0, impl.reason("Carbon's IBlueAsyncResNotifyTarget pair becomes the resource's own completion event, as in SetGeometryRes.")], 18, "SetLowResGeometryRes"], [[carbon, carbon.method, impl, impl.implemented], 18, "PySetGeometryRes"], [[carbon, carbon.method, impl, impl.adapted], 18, "GetGeometryResource"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetMeshResPath"], [[carbon, carbon.method, impl, impl.adapted], 18, "GetGeometryResPath"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetAreasCount"], [[impl, impl.adapted], 18, "InitializeMorphTargets"], [[carbon, carbon.method, impl, impl.adapted], 18, "GetMorphTargetNames"], [[impl, impl.implemented], 18, "IsBakedMorph"], [[carbon, carbon.method, impl, impl.implemented], 18, "SetMorphTargetWeight"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetMorphTargetWeight"], [[carbon, carbon.method, impl, impl.adapted], 18, "SetBakedMorphTarget"], [[carbon, carbon.method, impl, impl.implemented], 18, "GetBakedMorphTarget"], [[impl, impl.adapted], 18, "GetAllBakedMorphTargetStates"], [[impl, impl.adapted], 18, "GetMorphAnimations"]], 0, void 0, _Tr2MeshBase));
+    }
+    #bakedMorphTargets = (_initProto(this), []);
+    #morphAnimations = new Map();
+    geometryResPath = _init_geometryResPath(this, "");
+    serializedMorphAnimations = (_init_extra_geometryResPath(this), _init_serializedMorphAnimations(this, []));
+    deferGeometryLoad = (_init_extra_serializedMorphAnimations(this), _init_deferGeometryLoad(this, false));
+    geometry = (_init_extra_deferGeometryLoad(this), _init_geometry(this, null));
+
+    /** m_lowResGeometryResource: the stand-in rendered while the authored mesh loads. */
+    lowResGeometry = (_init_extra_geometry(this), _init_lowResGeometry(this, null));
 
-  /** Rebuilds the morph-target state once a geometry resource is present. */
-  Initialize() {
-    if (this.GetGeometryResource()) {
-      this.InitializeMorphTargets();
+    /**
+     * True while the bound geometry resource is still loading; false when no
+     * resource is bound.
+     */
+    get isLoading() {
+      return this.geometry?.IsLoading?.() ?? false;
     }
-    return true;
-  }
 
-  /**
-   * Rebuilds the morph-target state after a field change when a geometry
-   * resource is present.
-   */
-  OnModified() {
-    if (this.GetGeometryResource()) {
-      this.InitializeMorphTargets();
+    /** Carbon Initialize (cpp:28-36): load the geometry unless the load is deferred. */
+    Initialize() {
+      if (!this.deferGeometryLoad) {
+        this.InitializeGeometryResource();
+      }
+      return true;
     }
-    return true;
-  }
 
-  /**
-   * Sets the geometry resource path to load from; the currently bound resource
-   * is left in place until the load resolves.
-   */
-  SetMeshResPath(path) {
-    this.geometryResPath = String(path ?? "");
-  }
+    /**
+     * Carbon InitializeGeometryResource (cpp:107-138): fetch the authored path
+     * through the resource manager and bind the result.
+     */
+    InitializeGeometryResource() {
+      if (!this.geometryResPath) {
+        // Carbon requests the empty path anyway and gets nothing back
+        // (cpp:131-133); short-circuiting reaches the same two nulls without
+        // asking the manager for "".
+        this.SetLowResGeometryRes(null);
+        this.SetGeometryRes(null);
+        return;
+      }
+      const request = path => blue.resMan.GetResource(path, {
+        requirement: ResourceRequirement.GEOMETRY
+      });
 
-  /**
-   * Binds an already-resolved geometry resource, clears the authored path and
-   * rebuilds morph targets; the geometry rebuild token is added explicitly
-   * because direct mutation bypasses SetValues.
-   */
-  SetGeometryRes(resource) {
-    this.geometryResPath = "";
-    this.geometry = resource ?? null;
-    // Direct mutation bypasses SetValues, so schedule the declared consequence
-    // explicitly; maintained class code may add declared rebuild tokens.
-    this.__state.rebuild.add("geometry");
-    this.InitializeMorphTargets();
-  }
+      // Carbon cpp:113-127: when the authored file is NOT there but a
+      // <base>_lowdetail<ext> sibling is, take the low-detail one to render with
+      // now and request the authored one behind it. The same question, to the
+      // same service Carbon asks - BePaths->FileExistsLocally is
+      // blue.paths.FileExistsLocally.
+      let lowRes = null;
+      if (!blue.paths.FileExistsLocally(this.geometryResPath)) {
+        const lowResPath = _Tr2Mesh.#lowDetailPath(this.geometryResPath);
+        if (lowResPath && blue.paths.FileExistsLocally(lowResPath)) lowRes = request(lowResPath);
+      }
+      this.SetLowResGeometryRes(lowRes);
+      this.SetGeometryRes(request(this.geometryResPath));
+    }
 
-  /** The bound geometry resource, or null until the resource layer supplies one. */
-  GetGeometryResource() {
-    return this.geometry;
-  }
+    /** Carbon cpp:115-118: the sibling path, inserting _lowdetail before the extension. */
 
-  /**
-   * The bound resource's own path when one is bound, otherwise the authored
-   * path.
-   */
-  GetGeometryResPath() {
-    return this.geometry?.GetPath() ?? this.geometryResPath;
-  }
+    /**
+     * Carbon OnModified (cpp:38-58): three arms, dispatched on which member
+     * changed - the path refetches, clearing the defer flag starts the load a
+     * deferred mesh skipped, and the mesh index rebuilds the morph targets.
+     */
+    OnModified(propertyName) {
+      if (propertyName === "geometryResPath") {
+        this.InitializeGeometryResource();
+      } else if (propertyName === "deferGeometryLoad") {
+        if (!this.deferGeometryLoad && !this.geometry) this.Initialize();
+      } else if (propertyName === "meshIndex") {
+        this.InitializeMorphTargets();
+      }
+      return true;
+    }
 
-  /** The fixed number of mesh-area lists a mesh carries (14). */
-  GetAreasCount() {
-    return 14;
-  }
+    /**
+     * Carbon SetMeshResPath (cpp:99-105): assign, then fire the notification by
+     * hand - "this will automatically be triggered when set through python".
+     */
+    SetMeshResPath(path) {
+      this.geometryResPath = String(path ?? "");
+      this.OnModified("geometryResPath");
+    }
 
-  /** Rebuilds indexed morph state from LOD-0 target names while preserving matching serialized weights. */
-  InitializeMorphTargets() {
-    if (!this.GetGeometryResource()) {
-      this.#morphAnimations.clear();
-      this.#bakedMorphTargets = [];
-      return 0;
-    }
-    const names = this.GetMorphTargetNames();
-    const nameSet = new Set();
-    for (const name of names) {
-      if (nameSet.has(name)) {
-        throw new Error(`Tr2Mesh morph target names contain duplicate "${name}"`);
-      }
-      nameSet.add(name);
-    }
-    const serializedMatches = this.serializedMorphAnimations.length === names.length && names.every((name, index) => this.serializedMorphAnimations[index]?.name === name);
-    if (!serializedMatches) {
-      this.serializedMorphAnimations = names.map(name => {
-        const value = new _Tr2SerializedMorphAn();
-        value.name = name;
-        value.weight = 0;
-        return value;
-      });
+    /**
+     * Carbon SetGeometryRes (cpp:60-74): detach from the old resource, bind the
+     * new one, attach to it. Carbon's attachment is AddNotifyTarget, whose
+     * contract is that an already-prepared resource calls back immediately
+     * (BlueAsyncRes.cpp:274-276); OnCompleted has the same rule, so a resource
+     * that is already good rebuilds here rather than on a later frame.
+     */
+    SetGeometryRes(resource) {
+      const next = resource ?? null;
+      const previous = this.geometry;
+      if (previous === next) return;
+      if (previous && typeof previous.OffEvent === "function") {
+        previous.OffEvent("completed", this.#geometryCompleted, this);
+      }
+      this.geometry = next;
+      // Direct mutation bypasses SetValues, so schedule the declared consequence
+      // explicitly; maintained class code may add declared rebuild tokens.
+
+      if (!next) return;
+      if (typeof next.OnCompleted === "function") next.OnCompleted(this.#geometryCompleted, this);else this.RebuildCachedData(next);
     }
-    const previousBaked = new Map([...this.#morphAnimations].map(([name, value]) => [name, this.#bakedMorphTargets[value.index] ?? false]));
-    const resourceBaked = GetMorphLod(this.GetGeometryResource(), this.meshIndex)?.isBakedMorphTarget;
-    this.#morphAnimations.clear();
-    this.#bakedMorphTargets = names.map((name, index) => Array.isArray(resourceBaked) ? !!resourceBaked[index] : previousBaked.get(name) ?? false);
-    names.forEach((name, index) => {
-      const weight = Number(this.serializedMorphAnimations[index]?.weight);
-      if (!Number.isFinite(weight)) {
-        throw new TypeError(`Tr2Mesh morph target "${name}" weight must be finite`);
+
+    /** Bound to this mesh so the resource can be unsubscribed by identity. */
+    #geometryCompleted = (_init_extra_lowResGeometry(this), (_event, resource) => this.RebuildCachedData(resource ?? this.geometry));
+
+    /**
+     * Carbon RebuildCachedData (cpp:185-196): the notify target's rebuild half -
+     * re-cache the bounds and the morph targets when the resource that finished
+     * is one of ours, and drop the low-detail stand-in once the real one arrives.
+     */
+    RebuildCachedData(resource) {
+      // Two ifs, not an else: a low-detail resource finishing rebuilds the
+      // targets and keeps its place; the authored one finishing also retires it.
+      if (resource === this.geometry || resource === this.lowResGeometry) {
+        this.InitializeMorphTargets();
       }
-      this.#morphAnimations.set(name, {
-        index,
-        weight
-      });
-    });
-    return names.length;
-  }
+      if (resource === this.geometry) {
+        this.SetLowResGeometryRes(null);
+      }
+    }
+
+    /**
+     * Carbon SetLowResGeometryRes (cpp:76-90): the same detach/bind/attach as
+     * SetGeometryRes, for the stand-in shown while the authored mesh loads.
+     */
+    SetLowResGeometryRes(resource) {
+      const next = resource ?? null;
+      const previous = this.lowResGeometry;
+      if (previous === next) return;
+      if (previous && typeof previous.OffEvent === "function") {
+        previous.OffEvent("completed", this.#geometryCompleted, this);
+      }
+      this.lowResGeometry = next;
+      if (!next) return;
+      if (typeof next.OnCompleted === "function") next.OnCompleted(this.#geometryCompleted, this);else this.RebuildCachedData(next);
+    }
 
-  /** Returns detached LOD-0 morph target names from the prepared geometry resource. */
-  GetMorphTargetNames() {
-    const resource = this.GetGeometryResource();
-    const mesh = GetMeshRecord(resource, this.meshIndex);
-    const lod = GetMorphLod(resource, this.meshIndex);
-    if (Array.isArray(lod?.morphTargetNames)) {
-      return lod.morphTargetNames.map(String);
+    /**
+     * Carbon PySetGeometryRes (cpp:202-206): binding a resource by hand clears
+     * the authored path first, so the next notification does not refetch it.
+     */
+    PySetGeometryRes(resource) {
+      this.SetMeshResPath("");
+      this.SetGeometryRes(resource);
     }
-    const targets = mesh?.morphTargets?.targets;
-    if (Array.isArray(targets)) {
-      return targets.map(value => String(value?.name ?? ""));
+
+    /** Uses the low-detail stand-in until the primary resource is good. */
+    GetGeometryResource() {
+      if (!this.lowResGeometry || this.geometry?.IsGood()) return this.geometry;
+      return this.lowResGeometry;
     }
-    if (Array.isArray(lod?.morphTargets)) {
-      return lod.morphTargets.map(value => String(value?.name ?? ""));
+
+    /** Returns the authored geometry resource path. */
+    GetMeshResPath() {
+      return this.geometryResPath;
     }
-    return [];
-  }
 
-  /** Returns whether one indexed morph target is currently marked as baked. */
-  IsBakedMorph(index) {
-    return Number.isInteger(index) && index >= 0 && index < this.#bakedMorphTargets.length ? this.#bakedMorphTargets[index] : false;
-  }
+    /**
+     * The bound resource's own path when one is bound, otherwise the authored
+     * path.
+     */
+    GetGeometryResPath() {
+      return this.geometry?.GetPath() ?? this.geometryResPath;
+    }
 
-  /** Sets one exact named morph target weight without clamping. */
-  SetMorphTargetWeight(name, value) {
-    const key = String(name ?? "");
-    const weight = Number(value);
-    const animation = this.#morphAnimations.get(key);
-    if (!Number.isFinite(weight)) {
-      throw new TypeError(`Tr2Mesh morph target "${key}" weight must be finite`);
+    /** The fixed number of mesh-area lists a mesh carries (14). */
+    GetAreasCount() {
+      return 14;
     }
-    if (!animation) {
-      return false;
+
+    /** Rebuilds indexed morph state from LOD-0 target names while preserving matching serialized weights. */
+    InitializeMorphTargets() {
+      if (!this.GetGeometryResource()) {
+        this.#morphAnimations.clear();
+        this.#bakedMorphTargets = [];
+        return 0;
+      }
+      const names = this.GetMorphTargetNames();
+      const nameSet = new Set();
+      for (const name of names) {
+        if (nameSet.has(name)) {
+          throw new Error(`Tr2Mesh morph target names contain duplicate "${name}"`);
+        }
+        nameSet.add(name);
+      }
+      const serializedMatches = this.serializedMorphAnimations.length === names.length && names.every((name, index) => this.serializedMorphAnimations[index]?.name === name);
+      if (!serializedMatches) {
+        this.serializedMorphAnimations = names.map(name => {
+          const value = new _Tr2SerializedMorphAn();
+          value.name = name;
+          value.weight = 0;
+          return value;
+        });
+      }
+      const previousBaked = new Map([...this.#morphAnimations].map(([name, value]) => [name, this.#bakedMorphTargets[value.index] ?? false]));
+      const resourceBaked = GetMorphLod(this.GetGeometryResource(), this.meshIndex)?.isBakedMorphTarget;
+      this.#morphAnimations.clear();
+      this.#bakedMorphTargets = names.map((name, index) => Array.isArray(resourceBaked) ? !!resourceBaked[index] : previousBaked.get(name) ?? false);
+      names.forEach((name, index) => {
+        const weight = Number(this.serializedMorphAnimations[index]?.weight);
+        if (!Number.isFinite(weight)) {
+          throw new TypeError(`Tr2Mesh morph target "${name}" weight must be finite`);
+        }
+        this.#morphAnimations.set(name, {
+          index,
+          weight
+        });
+      });
+      return names.length;
     }
-    animation.weight = weight;
-    this.serializedMorphAnimations[animation.index].weight = weight;
-    return true;
-  }
 
-  /** Returns one exact named morph target weight, or the native zero fallback. */
-  GetMorphTargetWeight(name) {
-    return this.#morphAnimations.get(String(name ?? ""))?.weight ?? 0;
-  }
+    /** Returns detached LOD-0 morph target names from the prepared geometry resource. */
+    GetMorphTargetNames() {
+      const resource = this.GetGeometryResource();
+      const mesh = GetMeshRecord(resource, this.meshIndex);
+      const lod = GetMorphLod(resource, this.meshIndex);
+      if (Array.isArray(lod?.morphTargetNames)) {
+        return lod.morphTargetNames.map(String);
+      }
+      const targets = mesh?.morphTargets?.targets;
+      if (Array.isArray(targets)) {
+        return targets.map(value => String(value?.name ?? ""));
+      }
+      if (Array.isArray(lod?.morphTargets)) {
+        return lod.morphTargets.map(value => String(value?.name ?? ""));
+      }
+      return [];
+    }
 
-  /** Sets the baked flag for one exact named morph target. */
-  SetBakedMorphTarget(name, value) {
-    const animation = this.#morphAnimations.get(String(name ?? ""));
-    if (!animation) {
-      return false;
+    /** Returns whether one indexed morph target is currently marked as baked. */
+    IsBakedMorph(index) {
+      return Number.isInteger(index) && index >= 0 && index < this.#bakedMorphTargets.length ? this.#bakedMorphTargets[index] : false;
     }
-    const baked = !!value;
-    this.#bakedMorphTargets[animation.index] = baked;
-    const states = GetMorphLod(this.GetGeometryResource(), this.meshIndex)?.isBakedMorphTarget;
-    if (Array.isArray(states) && animation.index < states.length) {
-      states[animation.index] = baked;
+
+    /** Sets one exact named morph target weight without clamping. */
+    SetMorphTargetWeight(name, value) {
+      const key = String(name ?? "");
+      const weight = Number(value);
+      const animation = this.#morphAnimations.get(key);
+      if (!Number.isFinite(weight)) {
+        throw new TypeError(`Tr2Mesh morph target "${key}" weight must be finite`);
+      }
+      if (!animation) {
+        return false;
+      }
+      animation.weight = weight;
+      this.serializedMorphAnimations[animation.index].weight = weight;
+      return true;
     }
-    return true;
-  }
 
-  /** Returns the baked flag for one exact named morph target. */
-  GetBakedMorphTarget(name) {
-    const animation = this.#morphAnimations.get(String(name ?? ""));
-    return animation ? this.#bakedMorphTargets[animation.index] : false;
-  }
+    /** Returns one exact named morph target weight, or the native zero fallback. */
+    GetMorphTargetWeight(name) {
+      return this.#morphAnimations.get(String(name ?? ""))?.weight ?? 0;
+    }
 
-  /** Returns detached baked flags in morph-target index order. */
-  GetAllBakedMorphTargetStates() {
-    return this.#bakedMorphTargets.slice();
-  }
+    /** Sets the baked flag for one exact named morph target. */
+    SetBakedMorphTarget(name, value) {
+      const animation = this.#morphAnimations.get(String(name ?? ""));
+      if (!animation) {
+        return false;
+      }
+      const baked = !!value;
+      this.#bakedMorphTargets[animation.index] = baked;
+      const states = GetMorphLod(this.GetGeometryResource(), this.meshIndex)?.isBakedMorphTarget;
+      if (Array.isArray(states) && animation.index < states.length) {
+        states[animation.index] = baked;
+      }
+      return true;
+    }
+
+    /** Returns the baked flag for one exact named morph target. */
+    GetBakedMorphTarget(name) {
+      const animation = this.#morphAnimations.get(String(name ?? ""));
+      return animation ? this.#bakedMorphTargets[animation.index] : false;
+    }
 
-  /** Returns detached indexed morph state in exact target-name order. */
-  GetMorphAnimations() {
-    return new Map([...this.#morphAnimations].map(([name, value]) => [name, {
-      ...value
-    }]));
+    /** Returns detached baked flags in morph-target index order. */
+    GetAllBakedMorphTargetStates() {
+      return this.#bakedMorphTargets.slice();
+    }
+
+    /** Returns detached indexed morph state in exact target-name order. */
+    GetMorphAnimations() {
+      return new Map([...this.#morphAnimations].map(([name, value]) => [name, {
+        ...value
+      }]));
+    }
+  }];
+  #lowDetailPath(path) {
+    const dot = String(path).lastIndexOf(".");
+    if (dot === -1) return null;
+    return `${path.slice(0, dot)}_lowdetail${path.slice(dot)}`;
   }
-  static {
-    _initClass();
+  constructor() {
+    super(_Tr2Mesh), _initClass();
   }
-}
+}();
 function GetMeshRecord(resource, meshIndex) {
   const payload = resource?.GetPayload?.() ?? resource;
   return payload?.meshes?.[meshIndex] ?? null;