@threepipe/plugins-extra-importers 0.2.2 → 0.2.3

package/dist/dependencies.txt

@@ -1,5 +1,5 @@
 Name: three
-Version: 0.153.1006
+Version: 0.157.1007
 License: MIT
 Private: false
 Description: JavaScript 3D library

package/dist/index.d.ts

@@ -30,8 +30,6 @@ export declare class ColladaLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "ColladaLoadPlugin";
     protected _importer: Importer<{
         transform(res: Collada, _: AnyOptions): Scene;
-        load(url: string, onLoad: (collada: Collada) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>;
         parse(text: string, path: string): Collada;
         crossOrigin: string;
         withCredentials: boolean;
@@ -41,6 +39,8 @@ export declare class ColladaLoadPlugin extends BaseImporterPlugin {
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: Collada) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -73,8 +73,6 @@ export declare class BVHLoadPlugin extends BaseImporterPlugin {
         transform(res: BVH, _: AnyOptions): Object3D;
         animateBonePositions: boolean;
         animateBoneRotations: boolean;
-        load(url: string, onLoad: (bvh: BVH) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BVH>;
         parse(text: string): BVH;
         crossOrigin: string;
         withCredentials: boolean;
@@ -84,6 +82,8 @@ export declare class BVHLoadPlugin extends BaseImporterPlugin {
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: BVH) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BVH>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -100,8 +100,6 @@ export declare class VOXLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "VOXLoadPlugin";
     protected _importer: Importer<{
         transform(chunks: Chunk[], _: AnyOptions): Object3D;
-        load(url: string, onLoad: (chunks: Chunk[]) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Chunk[]>;
         parse(data: ArrayBuffer): object[];
         crossOrigin: string;
         withCredentials: boolean;
@@ -111,6 +109,8 @@ export declare class VOXLoadPlugin extends BaseImporterPlugin {
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: Chunk[]) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Chunk[]>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -127,8 +127,6 @@ export declare class MDDLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "MDDLoadPlugin";
     protected _importer: Importer<{
         transform(res: MDD, _: AnyOptions): Object3D;
-        load(url: string, onLoad: (result: MDD) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<MDD>;
         parse(data: ArrayBuffer): MDD;
         crossOrigin: string;
         withCredentials: boolean;
@@ -138,6 +136,8 @@ export declare class MDDLoadPlugin extends BaseImporterPlugin {
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: MDD) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<MDD>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -155,8 +155,6 @@ export declare class PCDLoadPlugin extends BaseImporterPlugin {
     protected _importer: Importer<{
         transform(points: Points, options: AnyOptions): any;
         littleEndian: boolean;
-        load(url: string, onLoad: (points: Points) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Points>;
         parse(data: ArrayBuffer | string): Points;
         crossOrigin: string;
         withCredentials: boolean;
@@ -166,6 +164,8 @@ export declare class PCDLoadPlugin extends BaseImporterPlugin {
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: Points<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>, import('threepipe').Material<import('./threepipe').MaterialEventMap> | import('threepipe').Material<import('./threepipe').MaterialEventMap>[]>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Points<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>, import('threepipe').Material<import('./threepipe').MaterialEventMap> | import('threepipe').Material<import('./threepipe').MaterialEventMap>[]>>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -200,8 +200,6 @@ export declare class LDrawLoadPlugin extends BaseImporterPlugin {
         materialsLibrary: Record<string, import('threepipe').Material>;
         fileMap: Record<string, string>;
         smoothNormals: boolean;
-        load(url: string, onLoad: (data: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>;
         preloadMaterials(url: string): Promise<void>;
         setFileMap(fileMap: Record<string, string>): void;
         setMaterials(materials: import('threepipe').Material[]): void;
@@ -216,6 +214,8 @@ export declare class LDrawLoadPlugin extends BaseImporterPlugin {
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: Group<import('./threepipe').Object3DEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group<import('./threepipe').Object3DEventMap>>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -232,8 +232,6 @@ export declare class VTKLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "VTKLoadPlugin";
     protected _importer: Importer<{
         transform(res: BufferGeometry, _: AnyOptions): Mesh | undefined;
-        load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>;
         parse(data: ArrayBuffer | string, path: string): BufferGeometry;
         crossOrigin: string;
         withCredentials: boolean;
@@ -243,6 +241,8 @@ export declare class VTKLoadPlugin extends BaseImporterPlugin {
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;
@@ -259,8 +259,6 @@ export declare class XYZLoadPlugin extends BaseImporterPlugin {
     static readonly PluginType = "XYZLoadPlugin";
     protected _importer: Importer<{
         transform(res: BufferGeometry, options: AnyOptions): Points | undefined;
-        load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>;
         parse(data: string, onLoad: (geometry: BufferGeometry) => void): object;
         crossOrigin: string;
         withCredentials: boolean;
@@ -270,6 +268,8 @@ export declare class XYZLoadPlugin extends BaseImporterPlugin {
         requestHeader: {
             [header: string]: string;
         };
+        load(url: string, onLoad: (data: BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>>;
         setCrossOrigin(crossOrigin: string): /*elided*/ any;
         setWithCredentials(value: boolean): /*elided*/ any;
         setPath(path: string): /*elided*/ any;

package/dist/index.js

@@ -1,6 +1,6 @@
 /**
  * @license
- * @threepipe/plugins-extra-importers v0.2.2
+ * @threepipe/plugins-extra-importers v0.2.3
  * Copyright 2022-2025 repalash <palash@shaders.app>
  * Apache-2.0 License
  * See ./dependencies.txt for any bundled third-party dependencies and licenses.
@@ -1660,7 +1660,11 @@ class ThreeMFLoader extends Loader {
       const geometry = new BufferGeometry();
       geometry.setIndex(new BufferAttribute(meshData["triangles"], 1));
       geometry.setAttribute("position", new BufferAttribute(meshData["vertices"], 3));
-      const material = new MeshPhongMaterial({ color: 16777215, flatShading: true });
+      const material = new MeshPhongMaterial({
+        name: Loader.DEFAULT_MATERIAL_NAME,
+        color: 16777215,
+        flatShading: true
+      });
       const mesh = new Mesh(geometry, material);
       return mesh;
     }
@@ -1882,7 +1886,7 @@ class TGALoader extends DataTextureLoader {
         case TGA_TYPE_INDEXED:
         case TGA_TYPE_RLE_INDEXED:
           if (header2.colormap_length > 256 || header2.colormap_size !== 24 || header2.colormap_type !== 1) {
-            console.error("THREE.TGALoader: Invalid type colormap data for indexed type.");
+            throw new Error("THREE.TGALoader: Invalid type colormap data for indexed type.");
           }
           break;
         // check colormap type
@@ -1891,21 +1895,21 @@ class TGALoader extends DataTextureLoader {
         case TGA_TYPE_RLE_RGB:
         case TGA_TYPE_RLE_GREY:
           if (header2.colormap_type) {
-            console.error("THREE.TGALoader: Invalid type colormap data for colormap type.");
+            throw new Error("THREE.TGALoader: Invalid type colormap data for colormap type.");
           }
           break;
         // What the need of a file without data ?
         case TGA_TYPE_NO_DATA:
-          console.error("THREE.TGALoader: No data.");
+          throw new Error("THREE.TGALoader: No data.");
         // Invalid type ?
         default:
-          console.error('THREE.TGALoader: Invalid type "%s".', header2.image_type);
+          throw new Error("THREE.TGALoader: Invalid type " + header2.image_type);
       }
       if (header2.width <= 0 || header2.height <= 0) {
-        console.error("THREE.TGALoader: Invalid image size.");
+        throw new Error("THREE.TGALoader: Invalid image size.");
       }
       if (header2.pixel_size !== 8 && header2.pixel_size !== 16 && header2.pixel_size !== 24 && header2.pixel_size !== 32) {
-        console.error('THREE.TGALoader: Invalid pixel size "%s".', header2.pixel_size);
+        throw new Error("THREE.TGALoader: Invalid pixel size " + header2.pixel_size);
       }
     }
     function tgaParse(use_rle2, use_pal2, header2, offset2, data) {
@@ -2078,8 +2082,7 @@ class TGALoader extends DataTextureLoader {
             tgaGetImageDataGrey16bits(data, y_start, y_step, y_end, x_start, x_step, x_end, image);
             break;
           default:
-            console.error("THREE.TGALoader: Format not supported.");
-            break;
+            throw new Error("THREE.TGALoader: Format not supported.");
         }
       } else {
         switch (header.pixel_size) {
@@ -2096,14 +2099,13 @@ class TGALoader extends DataTextureLoader {
             tgaGetImageData32bits(data, y_start, y_step, y_end, x_start, x_step, x_end, image);
             break;
           default:
-            console.error("THREE.TGALoader: Format not supported.");
-            break;
+            throw new Error("THREE.TGALoader: Format not supported.");
         }
       }
       return data;
     }
     const TGA_TYPE_NO_DATA = 0, TGA_TYPE_INDEXED = 1, TGA_TYPE_RGB = 2, TGA_TYPE_GREY = 3, TGA_TYPE_RLE_INDEXED = 9, TGA_TYPE_RLE_RGB = 10, TGA_TYPE_RLE_GREY = 11, TGA_ORIGIN_MASK = 48, TGA_ORIGIN_SHIFT = 4, TGA_ORIGIN_BL = 0, TGA_ORIGIN_BR = 1, TGA_ORIGIN_UL = 2, TGA_ORIGIN_UR = 3;
-    if (buffer.length < 19) console.error("THREE.TGALoader: Not enough data to contain header.");
+    if (buffer.length < 19) throw new Error("THREE.TGALoader: Not enough data to contain header.");
     let offset = 0;
     const content = new Uint8Array(buffer), header = {
       id_length: content[offset++],
@@ -2123,7 +2125,7 @@ class TGALoader extends DataTextureLoader {
     };
     tgaCheckHeader(header);
     if (header.id_length + offset > buffer.length) {
-      console.error("THREE.TGALoader: No data.");
+      throw new Error("THREE.TGALoader: No data.");
     }
     offset += header.id_length;
     let use_rle = false, use_pal = false, use_grey = false;
@@ -4268,7 +4270,10 @@ class ColladaLoader extends Loader {
       object.matrix.decompose(object.position, object.quaternion, object.scale);
       return object;
     }
-    const fallbackMaterial = new MeshBasicMaterial({ color: 16711935 });
+    const fallbackMaterial = new MeshBasicMaterial({
+      name: Loader.DEFAULT_MATERIAL_NAME,
+      color: 16711935
+    });
     function resolveMaterialBinding(keys, instanceMaterials) {
       const materials = [];
       for (let i = 0, l = keys.length; i < l; i++) {
@@ -4717,7 +4722,11 @@ class AMFLoader extends Loader {
       }
     }
     const sceneObject = new Group();
-    const defaultMaterial = new MeshPhongMaterial({ color: 11184895, flatShading: true });
+    const defaultMaterial = new MeshPhongMaterial({
+      name: Loader.DEFAULT_MATERIAL_NAME,
+      color: 11184895,
+      flatShading: true
+    });
     sceneObject.name = amfName;
     sceneObject.userData.author = amfAuthor;
     sceneObject.userData.loader = "AMF";
@@ -11387,7 +11396,10 @@ class VRMLLoader extends Loader {
     }
     function buildShapeNode(node) {
       const fields = node.fields;
-      let material = new MeshBasicMaterial({ color: 0 });
+      let material = new MeshBasicMaterial({
+        name: Loader.DEFAULT_MATERIAL_NAME,
+        color: 0
+      });
       let geometry;
       for (let i = 0, l = fields.length; i < l; i++) {
         const field = fields[i];
@@ -11413,7 +11425,10 @@ class VRMLLoader extends Loader {
       if (geometry && geometry.attributes.position) {
         const type = geometry._type;
         if (type === "points") {
-          const pointsMaterial = new PointsMaterial({ color: 16777215 });
+          const pointsMaterial = new PointsMaterial({
+            name: Loader.DEFAULT_MATERIAL_NAME,
+            color: 16777215
+          });
           if (geometry.attributes.color !== void 0) {
             pointsMaterial.vertexColors = true;
           } else {
@@ -11423,7 +11438,10 @@ class VRMLLoader extends Loader {
           }
           object = new Points(geometry, pointsMaterial);
         } else if (type === "line") {
-          const lineMaterial = new LineBasicMaterial({ color: 16777215 });
+          const lineMaterial = new LineBasicMaterial({
+            name: Loader.DEFAULT_MATERIAL_NAME,
+            color: 16777215
+          });
           if (geometry.attributes.color !== void 0) {
             lineMaterial.vertexColors = true;
           } else {
@@ -11466,7 +11484,10 @@ class VRMLLoader extends Loader {
               if (materialData.transparency) material.opacity = 1 - materialData.transparency;
               if (materialData.transparency > 0) material.transparent = true;
             } else {
-              material = new MeshBasicMaterial({ color: 0 });
+              material = new MeshBasicMaterial({
+                name: Loader.DEFAULT_MATERIAL_NAME,
+                color: 0
+              });
             }
             break;
           case "texture":
@@ -12924,7 +12945,7 @@ class LDrawConditionalLineMaterial extends ShaderMaterial {
 				outgoingLight = diffuseColor.rgb; // simple shader
 				gl_FragColor = vec4( outgoingLight, diffuseColor.a );
 				#include <tonemapping_fragment>
-				#include <encodings_fragment>
+				#include <colorspace_fragment>
 				#include <fog_fragment>
 				#include <premultiplied_alpha_fragment>
 			}
@@ -13285,7 +13306,7 @@ class LDrawParsedCache {
       try {
         const text = await fileLoader.loadAsync(subobjectURL);
         return text;
-      } catch {
+      } catch (_) {
         continue;
       }
     }
@@ -13755,13 +13776,13 @@ class LDrawPartsGeometryCache {
     }
     const group = info.group;
     if (info.faces.length > 0) {
-      group.add(createObject(info.faces, 3, false, info.totalFaces));
+      group.add(createObject(this.loader, info.faces, 3, false, info.totalFaces));
     }
     if (info.lineSegments.length > 0) {
-      group.add(createObject(info.lineSegments, 2));
+      group.add(createObject(this.loader, info.lineSegments, 2));
     }
     if (info.conditionalSegments.length > 0) {
-      group.add(createObject(info.conditionalSegments, 2, true));
+      group.add(createObject(this.loader, info.conditionalSegments, 2, true));
     }
     return group;
   }
@@ -13816,7 +13837,7 @@ function sortByMaterial(a, b) {
   }
   return 1;
 }
-function createObject(elements, elementSize, isConditionalSegments = false, totalElements = null) {
+function createObject(loader, elements, elementSize, isConditionalSegments = false, totalElements = null) {
   elements.sort(sortByMaterial);
   if (totalElements === null) {
     totalElements = elements.length;
@@ -13889,9 +13910,10 @@ function createObject(elements, elementSize, isConditionalSegments = false, tota
           materials.push(material);
         } else if (elementSize === 2) {
           if (isConditionalSegments) {
-            materials.push(material.userData.edgeMaterial.userData.conditionalEdgeMaterial);
+            const edgeMaterial = loader.edgeMaterialCache.get(material);
+            materials.push(loader.conditionalEdgeMaterialCache.get(edgeMaterial));
           } else {
-            materials.push(material.userData.edgeMaterial);
+            materials.push(loader.edgeMaterialCache.get(material));
           }
         }
       } else {
@@ -13966,19 +13988,18 @@ class LDrawLoader extends Loader {
     super(manager);
     this.materials = [];
     this.materialLibrary = {};
+    this.edgeMaterialCache = /* @__PURE__ */ new WeakMap();
+    this.conditionalEdgeMaterialCache = /* @__PURE__ */ new WeakMap();
     this.partsCache = new LDrawPartsGeometryCache(this);
     this.fileMap = {};
     this.setMaterials([]);
     this.smoothNormals = true;
     this.partsLibraryPath = "";
-    this.missingColorMaterial = new MeshStandardMaterial({ color: 16711935, roughness: 0.3, metalness: 0 });
-    this.missingColorMaterial.name = "Missing material";
-    this.missingEdgeColorMaterial = new LineBasicMaterial({ color: 16711935 });
-    this.missingEdgeColorMaterial.name = "Missing material - Edge";
-    this.missingConditionalEdgeColorMaterial = new LDrawConditionalLineMaterial({ fog: true, color: 16711935 });
-    this.missingConditionalEdgeColorMaterial.name = "Missing material - Conditional Edge";
-    this.missingColorMaterial.userData.edgeMaterial = this.missingEdgeColorMaterial;
-    this.missingEdgeColorMaterial.userData.conditionalEdgeMaterial = this.missingConditionalEdgeColorMaterial;
+    this.missingColorMaterial = new MeshStandardMaterial({ name: Loader.DEFAULT_MATERIAL_NAME, color: 16711935, roughness: 0.3, metalness: 0 });
+    this.missingEdgeColorMaterial = new LineBasicMaterial({ name: Loader.DEFAULT_MATERIAL_NAME, color: 16711935 });
+    this.missingConditionalEdgeColorMaterial = new LDrawConditionalLineMaterial({ name: Loader.DEFAULT_MATERIAL_NAME, fog: true, color: 16711935 });
+    this.edgeMaterialCache.set(this.missingColorMaterial, this.missingEdgeColorMaterial);
+    this.conditionalEdgeMaterialCache.set(this.missingEdgeColorMaterial, this.missingConditionalEdgeColorMaterial);
   }
   setPartsLibraryPath(path) {
     this.partsLibraryPath = path;
@@ -14094,9 +14115,9 @@ class LDrawLoader extends Loader {
         return colorCode;
       }
       if (c.isLineSegments) {
-        material = material.userData.edgeMaterial;
+        material = loader.edgeMaterialCache.get(material);
         if (c.isConditionalLine) {
-          material = material.userData.conditionalEdgeMaterial;
+          material = loader.conditionalEdgeMaterialCache.get(material);
         }
       }
       return material;
@@ -14107,7 +14128,7 @@ class LDrawLoader extends Loader {
   }
   getMainEdgeMaterial() {
     const mat = this.getMaterial(MAIN_EDGE_COLOUR_CODE);
-    return mat ? mat.userData.edgeMaterial : null;
+    return mat ? this.edgeMaterialCache.get(mat) : null;
   }
   parseColorMetaDirective(lineParser) {
     let code = null;
@@ -14150,7 +14171,7 @@ class LDrawLoader extends Loader {
               if (!edgeMaterial) {
                 throw new Error("LDrawLoader: Invalid edge color while parsing material" + lineParser.getLineNumberString() + ".");
               }
-              edgeMaterial = edgeMaterial.userData.edgeMaterial;
+              edgeMaterial = this.edgeMaterialCache.get(edgeMaterial);
             }
             break;
           case "ALPHA":
@@ -14232,19 +14253,20 @@ class LDrawLoader extends Loader {
       edgeMaterial.color;
       edgeMaterial.userData.code = code;
       edgeMaterial.name = name + " - Edge";
-      edgeMaterial.userData.conditionalEdgeMaterial = new LDrawConditionalLineMaterial({
+      const conditionalEdgeMaterial = new LDrawConditionalLineMaterial({
         fog: true,
         transparent: isTransparent,
         depthWrite: !isTransparent,
         color: new Color().setStyle(edgeColor, COLOR_SPACE_LDRAW),
         opacity: alpha
       });
-      edgeMaterial.userData.conditionalEdgeMaterial.userData.code = code;
-      edgeMaterial.userData.conditionalEdgeMaterial.name = name + " - Conditional Edge";
+      conditionalEdgeMaterial.userData.code = code;
+      conditionalEdgeMaterial.name = name + " - Conditional Edge";
+      this.conditionalEdgeMaterialCache.set(edgeMaterial, conditionalEdgeMaterial);
     }
     material.userData.code = code;
     material.name = name;
-    material.userData.edgeMaterial = edgeMaterial;
+    this.edgeMaterialCache.set(material, edgeMaterial);
     this.addMaterial(material);
     return material;
     function parseLuminance(token2) {