@lingbi/studio 0.2.0 → 0.3.0

package/Application.d.ts

@@ -1,11 +1,15 @@
 import type { ObjImportResult } from './ObjImportResult';
 import type { ObjImportSource } from './ObjImportSource';
+import type { ObjResourceListSource } from './ObjResourceListSource';
+import type { ObjResourceSceneSource } from './ObjResourceSceneSource';
 import type { ObjSceneSource } from './ObjSceneSource';
 export declare class Application {
     private disposed;
     private renderer;
     attach(canvas: HTMLCanvasElement): void;
     importObj(source: ObjImportSource): Promise<ObjImportResult>;
+    importObjResources(source: ObjResourceListSource): Promise<ObjImportResult>;
+    importObjResourceScene(source: ObjResourceSceneSource): Promise<ObjImportResult>;
     importObjScene(source: ObjSceneSource): Promise<ObjImportResult>;
     resetView(): void;
     dispose(): void;

package/ObjResourceListSource.d.ts

@@ -0,0 +1,3 @@
+export interface ObjResourceListSource {
+    readonly fileUrls: readonly string[];
+}

package/ObjResourceSceneSource.d.ts

@@ -0,0 +1,5 @@
+import type { ObjResourceListSource } from './ObjResourceListSource';
+export interface ObjResourceSceneSource {
+    readonly stone?: ObjResourceListSource;
+    readonly base?: ObjResourceListSource;
+}

package/index.d.ts

@@ -2,4 +2,6 @@ export { Application } from './Application';
 export type { ObjImportResult } from './ObjImportResult';
 export { ObjImportFailureCode } from './ObjImportResult';
 export type { ObjImportSource } from './ObjImportSource';
+export type { ObjResourceListSource } from './ObjResourceListSource';
+export type { ObjResourceSceneSource } from './ObjResourceSceneSource';
 export type { ObjSceneSource } from './ObjSceneSource';

package/index.js

@@ -13983,6 +13983,91 @@ class RawShaderMaterial extends ShaderMaterial {
     this.type = "RawShaderMaterial";
   }
 }
+class MeshStandardMaterial extends Material {
+  /**
+   * Constructs a new mesh standard material.
+   *
+   * @param {Object} [parameters] - An object with one or more properties
+   * defining the material's appearance. Any property of the material
+   * (including any property from inherited materials) can be passed
+   * in here. Color values can be passed any type of value accepted
+   * by {@link Color#set}.
+   */
+  constructor(parameters) {
+    super();
+    this.isMeshStandardMaterial = true;
+    this.type = "MeshStandardMaterial";
+    this.defines = { "STANDARD": "" };
+    this.color = new Color(16777215);
+    this.roughness = 1;
+    this.metalness = 0;
+    this.map = null;
+    this.lightMap = null;
+    this.lightMapIntensity = 1;
+    this.aoMap = null;
+    this.aoMapIntensity = 1;
+    this.emissive = new Color(0);
+    this.emissiveIntensity = 1;
+    this.emissiveMap = null;
+    this.bumpMap = null;
+    this.bumpScale = 1;
+    this.normalMap = null;
+    this.normalMapType = TangentSpaceNormalMap;
+    this.normalScale = new Vector2(1, 1);
+    this.displacementMap = null;
+    this.displacementScale = 1;
+    this.displacementBias = 0;
+    this.roughnessMap = null;
+    this.metalnessMap = null;
+    this.alphaMap = null;
+    this.envMap = null;
+    this.envMapRotation = new Euler();
+    this.envMapIntensity = 1;
+    this.wireframe = false;
+    this.wireframeLinewidth = 1;
+    this.wireframeLinecap = "round";
+    this.wireframeLinejoin = "round";
+    this.flatShading = false;
+    this.fog = true;
+    this.setValues(parameters);
+  }
+  copy(source) {
+    super.copy(source);
+    this.defines = { "STANDARD": "" };
+    this.color.copy(source.color);
+    this.roughness = source.roughness;
+    this.metalness = source.metalness;
+    this.map = source.map;
+    this.lightMap = source.lightMap;
+    this.lightMapIntensity = source.lightMapIntensity;
+    this.aoMap = source.aoMap;
+    this.aoMapIntensity = source.aoMapIntensity;
+    this.emissive.copy(source.emissive);
+    this.emissiveMap = source.emissiveMap;
+    this.emissiveIntensity = source.emissiveIntensity;
+    this.bumpMap = source.bumpMap;
+    this.bumpScale = source.bumpScale;
+    this.normalMap = source.normalMap;
+    this.normalMapType = source.normalMapType;
+    this.normalScale.copy(source.normalScale);
+    this.displacementMap = source.displacementMap;
+    this.displacementScale = source.displacementScale;
+    this.displacementBias = source.displacementBias;
+    this.roughnessMap = source.roughnessMap;
+    this.metalnessMap = source.metalnessMap;
+    this.alphaMap = source.alphaMap;
+    this.envMap = source.envMap;
+    this.envMapRotation.copy(source.envMapRotation);
+    this.envMapIntensity = source.envMapIntensity;
+    this.wireframe = source.wireframe;
+    this.wireframeLinewidth = source.wireframeLinewidth;
+    this.wireframeLinecap = source.wireframeLinecap;
+    this.wireframeLinejoin = source.wireframeLinejoin;
+    this.flatShading = source.flatShading;
+    this.fog = source.fog;
+    return this;
+  }
+}
 class MeshPhongMaterial extends Material {
   /**
    * Constructs a new mesh phong material.
@@ -30474,6 +30559,12 @@ class ObjLoader {
     this.parser = parser;
   }
   async load(source, signal) {
+    return this.loadInternal(source, signal);
+  }
+  async loadResources(resources, signal) {
+    return this.loadInternal(this.createResourceSource(resources), signal, resources);
+  }
+  async loadInternal(source, signal, resources) {
     if (this.hasEmptyRequiredUrl(source)) {
       return {
         code: ObjImportFailureCode$1.EmptySource,
@@ -30485,12 +30576,15 @@ class ObjLoader {
     try {
       const objSource = await this.loadText(source.objUrl, signal);
       this.assertNotCancelled(signal);
-      const materialUrl = this.getMaterialUrl(source, objSource);
+      const materialReferences = this.getMaterialLibraryReferences(objSource);
+      resources?.assertMaterialLibraries(materialReferences);
+      const materialUrl = resources === void 0 ? this.getMaterialUrl(source, materialReferences) : resources.mtlUrl;
       if (materialUrl !== void 0) {
         materialContext = await this.loadMaterialContext(
           materialUrl,
           source.textureUrls,
-          signal
+          signal,
+          resources
         );
       }
       this.assertNotCancelled(signal);
@@ -30538,6 +30632,11 @@ class ObjLoader {
       throw new Error("The OBJ import was cancelled.");
     }
   }
+  assertMaterialTextures(resources, materialSource, materialBaseUrl, creator) {
+    for (const textureReference of this.getMaterialTextureReferences(materialSource, creator)) {
+      resources.resolveTextureUrl(materialBaseUrl, textureReference);
+    }
+  }
   collectMaterials(material, materials) {
     if (Array.isArray(material)) {
       for (const item of material) {
@@ -30547,6 +30646,17 @@ class ObjLoader {
     }
     materials.add(material);
   }
+  createResourceSource(resources) {
+    if (resources.mtlUrl === void 0) {
+      return {
+        objUrl: resources.objUrl
+      };
+    }
+    return {
+      mtlUrl: resources.mtlUrl,
+      objUrl: resources.objUrl
+    };
+  }
   disposeFailedModel(model) {
     if (model === void 0) {
       return;
@@ -30570,6 +30680,11 @@ class ObjLoader {
     const resourceOwner = new Model(new Group(), [...materials]);
     resourceOwner.dispose();
   }
+  disposeMaterialsWithoutTextures(materials) {
+    for (const material of materials) {
+      material.dispose();
+    }
+  }
   getMaterialArray(context) {
     if (context === void 0) {
       return [];
@@ -30592,20 +30707,33 @@ class ObjLoader {
   getTextureFailureCode(outcome) {
     return outcome === "cancelled" ? ObjImportFailureCode$1.Cancelled : ObjImportFailureCode$1.InvalidSource;
   }
-  getMaterialLibraryReference(objSource) {
+  getMaterialLibraryReferences(objSource) {
+    const materialReferences = [];
     for (const line of objSource.split(/\r?\n/u)) {
       const materialReference = /^\s*mtllib\s+(.+?)\s*$/u.exec(line)?.[1];
       if (materialReference !== void 0) {
-        return materialReference;
+        materialReferences.push(materialReference);
       }
     }
-    return void 0;
+    return materialReferences;
+  }
+  getMaterialTextureReferences(materialSource, creator) {
+    const textureReferences = [];
+    for (const line of materialSource.split(/\r?\n/u)) {
+      const textureValue = /^\s*(?:map_\S+|bump|decal|disp|norm|refl)\s+(.+?)\s*$/iu.exec(
+        line
+      )?.[1];
+      if (textureValue !== void 0) {
+        textureReferences.push(creator.getTextureParams(textureValue, {}).url);
+      }
+    }
+    return textureReferences;
   }
-  getMaterialUrl(source, objSource) {
+  getMaterialUrl(source, materialReferences) {
     if (source.mtlUrl !== void 0) {
       return source.mtlUrl;
     }
-    const materialReference = this.getMaterialLibraryReference(objSource);
+    const materialReference = materialReferences[0];
     if (materialReference === void 0) {
       return void 0;
     }
@@ -30635,21 +30763,29 @@ class ObjLoader {
   isPoints(object) {
     return object instanceof Points;
   }
-  async loadMaterialContext(mtlUrl, textureUrls, signal) {
+  async loadMaterialContext(mtlUrl, textureUrls, signal, resources) {
     const materialSource = await this.loadText(mtlUrl, signal);
     this.assertNotCancelled(signal);
     const materialBaseUrl = this.getResourceDirectoryUrl(mtlUrl);
     const manager = new LoadingManager();
-    manager.setURLModifier(this.resolveTextureUrl.bind(this, textureUrls, materialBaseUrl));
+    manager.setURLModifier(
+      resources === void 0 ? this.resolveTextureUrl.bind(this, textureUrls, materialBaseUrl) : resources.resolveTextureUrl.bind(resources, materialBaseUrl)
+    );
     const materialLoader = new MTLLoader(manager);
     materialLoader.setMaterialOptions({
       side: DoubleSide
     });
     const creator = materialLoader.parse(materialSource, materialBaseUrl);
+    const pbrMaterialReferences = this.parsePbrMaterialReferences(materialSource);
+    if (resources !== void 0) {
+      this.assertMaterialTextures(resources, materialSource, materialBaseUrl, creator);
+    }
     this.validateTextureOverrides(textureUrls);
+    this.removeLegacyPbrTextureMappings(creator);
     const monitor = new TextureLoadMonitor(manager, creator);
     try {
       creator.preload();
+      this.replaceMaterialsWithPbr(creator, pbrMaterialReferences, materialBaseUrl);
       monitor.finishScheduling();
     } catch (error2) {
       monitor.finishScheduling();
@@ -30704,6 +30840,77 @@ class ObjLoader {
     }
     this.disposeMaterials(materialsToDispose);
   }
+  createPbrMaterial(source, references, creator, materialBaseUrl) {
+    const material = new MeshStandardMaterial();
+    material.alphaMap = source.alphaMap;
+    material.alphaTest = source.alphaTest;
+    material.color.copy(source.color);
+    material.displacementBias = source.displacementBias;
+    material.displacementMap = source.displacementMap;
+    material.displacementScale = source.displacementScale;
+    material.emissive.copy(source.emissive);
+    material.emissiveIntensity = source.emissiveIntensity;
+    material.emissiveMap = source.emissiveMap;
+    material.map = source.map;
+    material.name = source.name;
+    material.opacity = source.opacity;
+    material.side = source.side;
+    material.transparent = source.transparent;
+    material.vertexColors = source.vertexColors;
+    if (material.map !== null) {
+      material.map.colorSpace = SRGBColorSpace;
+    }
+    if (material.emissiveMap !== null) {
+      material.emissiveMap.colorSpace = SRGBColorSpace;
+    }
+    const roughnessReference = references.roughness ?? references.roughnessFallback;
+    if (roughnessReference !== void 0) {
+      material.roughnessMap = this.loadPbrTexture(
+        creator,
+        materialBaseUrl,
+        roughnessReference
+      ).texture;
+    }
+    if (references.metalness !== void 0) {
+      material.metalnessMap = this.loadPbrTexture(
+        creator,
+        materialBaseUrl,
+        references.metalness
+      ).texture;
+    }
+    const normalReference = references.normal ?? references.legacyNormal;
+    if (normalReference !== void 0) {
+      const normalTexture = this.loadPbrTexture(creator, materialBaseUrl, normalReference);
+      material.normalMap = normalTexture.texture;
+      if (normalTexture.bumpScale !== void 0) {
+        material.normalScale.set(normalTexture.bumpScale, normalTexture.bumpScale);
+      }
+    }
+    if (references.bump !== void 0) {
+      const bumpTexture = this.loadPbrTexture(creator, materialBaseUrl, references.bump);
+      material.bumpMap = bumpTexture.texture;
+      if (bumpTexture.bumpScale !== void 0) {
+        material.bumpScale = bumpTexture.bumpScale;
+      }
+    }
+    return material;
+  }
+  loadPbrTexture(creator, materialBaseUrl, reference) {
+    const materialParameters = {};
+    const textureParameters = creator.getTextureParams(reference, materialParameters);
+    const texture = creator.loadTexture(
+      this.resolveResourceUrl(textureParameters.url, materialBaseUrl)
+    );
+    texture.colorSpace = NoColorSpace;
+    texture.offset.copy(textureParameters.offset);
+    texture.repeat.copy(textureParameters.scale);
+    texture.wrapS = creator.wrap;
+    texture.wrapT = creator.wrap;
+    return {
+      bumpScale: materialParameters.bumpScale,
+      texture
+    };
+  }
   parseObj(source, materials) {
     if (materials === void 0) {
       return this.parser.parse(source);
@@ -30712,6 +30919,78 @@ class ObjLoader {
     parser.setMaterials(materials);
     return parser.parse(source);
   }
+  parsePbrMaterialReferences(materialSource) {
+    const referencesByMaterial = {};
+    let currentReferences;
+    for (const line of materialSource.split(/\r?\n/u)) {
+      const materialName = /^\s*newmtl\s+(.+?)\s*$/iu.exec(line)?.[1];
+      if (materialName !== void 0) {
+        currentReferences = {
+          bump: void 0,
+          legacyNormal: void 0,
+          metalness: void 0,
+          normal: void 0,
+          roughness: void 0,
+          roughnessFallback: void 0
+        };
+        referencesByMaterial[materialName] = currentReferences;
+        continue;
+      }
+      if (currentReferences === void 0) {
+        continue;
+      }
+      const textureReference = /^\s*(map_pr|map_ns|map_pm|map_bump|bump|norm)\s+(.+?)\s*$/iu.exec(line);
+      if (textureReference === null) {
+        continue;
+      }
+      const [, directive = "", value = ""] = textureReference;
+      switch (directive.toLowerCase()) {
+        case "bump":
+          currentReferences.bump = value;
+          break;
+        case "map_bump":
+          currentReferences.legacyNormal = value;
+          break;
+        case "map_pm":
+          currentReferences.metalness = value;
+          break;
+        case "map_ns":
+          currentReferences.roughnessFallback = value;
+          break;
+        case "map_pr":
+          currentReferences.roughness = value;
+          break;
+        case "norm":
+          currentReferences.normal = value;
+          break;
+      }
+    }
+    return referencesByMaterial;
+  }
+  removeLegacyPbrTextureMappings(creator) {
+    for (const materialInfo of Object.values(creator.materialsInfo)) {
+      delete materialInfo.bump;
+      delete materialInfo.map_bump;
+      delete materialInfo.norm;
+    }
+  }
+  replaceMaterialsWithPbr(creator, referencesByMaterial, materialBaseUrl) {
+    const replacedMaterials = /* @__PURE__ */ new Set();
+    for (const [materialName, references] of Object.entries(referencesByMaterial)) {
+      const sourceMaterial = creator.materials[materialName];
+      if (!(sourceMaterial instanceof MeshPhongMaterial)) {
+        throw new Error("The MTL loader did not create a phong material.");
+      }
+      creator.materials[materialName] = this.createPbrMaterial(
+        sourceMaterial,
+        references,
+        creator,
+        materialBaseUrl
+      );
+      replacedMaterials.add(sourceMaterial);
+    }
+    this.disposeMaterialsWithoutTextures(replacedMaterials);
+  }
   resolveResourceUrl(reference, baseUrl) {
     return new URL(reference, this.toAbsoluteUrl(baseUrl)).href;
   }
@@ -30740,6 +31019,101 @@ class ObjLoader {
     }
   }
 }
+class ObjResourceList {
+  mtlUrl;
+  objUrl;
+  mtlFileName;
+  textureUrls = /* @__PURE__ */ new Set();
+  textureUrlsByFileName = /* @__PURE__ */ new Map();
+  constructor(fileUrls) {
+    let mtlFileName;
+    let mtlUrl;
+    let objUrl;
+    const seenFileNames = /* @__PURE__ */ new Set();
+    const seenUrls = /* @__PURE__ */ new Set();
+    for (const fileUrl of fileUrls) {
+      const resource = this.createResourceEntry(fileUrl);
+      if (seenUrls.has(resource.url) || seenFileNames.has(resource.fileName)) {
+        throw new Error("The OBJ resource list contains a duplicate resource.");
+      }
+      seenUrls.add(resource.url);
+      seenFileNames.add(resource.fileName);
+      if (this.isObjUrl(resource.url)) {
+        if (objUrl !== void 0) {
+          throw new Error("The OBJ resource list must contain exactly one OBJ file.");
+        }
+        objUrl = resource.url;
+        continue;
+      }
+      if (this.isMtlUrl(resource.url)) {
+        if (mtlUrl !== void 0) {
+          throw new Error("The OBJ resource list cannot contain multiple MTL files.");
+        }
+        mtlFileName = resource.fileName;
+        mtlUrl = resource.url;
+        continue;
+      }
+      this.textureUrls.add(resource.url);
+      this.textureUrlsByFileName.set(resource.fileName, resource.url);
+    }
+    if (objUrl === void 0) {
+      throw new Error("The OBJ resource list must contain an OBJ file.");
+    }
+    this.mtlFileName = mtlFileName;
+    this.mtlUrl = mtlUrl;
+    this.objUrl = objUrl;
+  }
+  assertMaterialLibraries(materialReferences) {
+    if (materialReferences.length === 0) {
+      return;
+    }
+    const mtlUrl = this.mtlUrl;
+    const mtlFileName = this.mtlFileName;
+    const [materialReference, ...remainingReferences] = materialReferences;
+    if (materialReference === void 0 || remainingReferences.length > 0 || mtlUrl === void 0 || mtlFileName === void 0) {
+      throw new Error("The OBJ material library is not present in the resource list.");
+    }
+    const referenceUrl = new URL(materialReference, this.objUrl).href;
+    if (referenceUrl === mtlUrl || this.getFileName(new URL(referenceUrl)) === mtlFileName) {
+      return;
+    }
+    throw new Error("The OBJ material library does not match the resource list.");
+  }
+  resolveTextureUrl(materialBaseUrl, textureUrl) {
+    const resolvedUrl = new URL(textureUrl, materialBaseUrl).href;
+    if (this.textureUrls.has(resolvedUrl)) {
+      return resolvedUrl;
+    }
+    const mappedUrl = this.textureUrlsByFileName.get(this.getFileName(new URL(resolvedUrl)));
+    if (mappedUrl === void 0) {
+      throw new Error("The MTL texture is not present in the resource list.");
+    }
+    return mappedUrl;
+  }
+  createResourceEntry(fileUrl) {
+    const url = new URL(fileUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new Error("The OBJ resource list only accepts HTTP URLs.");
+    }
+    return {
+      fileName: this.getFileName(url),
+      url: url.href
+    };
+  }
+  getFileName(url) {
+    const fileName = decodeURIComponent(url.pathname.slice(url.pathname.lastIndexOf("/") + 1));
+    if (fileName.length === 0) {
+      throw new Error("The OBJ resource URL must include a file name.");
+    }
+    return fileName;
+  }
+  isMtlUrl(url) {
+    return new URL(url).pathname.toLowerCase().endsWith(".mtl");
+  }
+  isObjUrl(url) {
+    return new URL(url).pathname.toLowerCase().endsWith(".obj");
+  }
+}
 const DEFAULT_BACKGROUND_COLOR = 3355443;
 class Renderer {
   activeModels = [];
@@ -30911,6 +31285,47 @@ class Renderer {
       stone: source
     });
   }
+  importObjResources(source) {
+    this.assertNotDisposed();
+    if (this.contextLost) {
+      return Promise.resolve({
+        code: ObjImportFailureCode$1.RenderFailed,
+        success: false
+      });
+    }
+    const session = this.startImportSession();
+    try {
+      return this.completeResourceListImport(session, new ObjResourceList(source.fileUrls));
+    } catch {
+      this.finishImportSession(session);
+      return Promise.resolve({
+        code: ObjImportFailureCode$1.InvalidSource,
+        success: false
+      });
+    }
+  }
+  importObjResourceScene(source) {
+    this.assertNotDisposed();
+    if (this.contextLost) {
+      return Promise.resolve({
+        code: ObjImportFailureCode$1.RenderFailed,
+        success: false
+      });
+    }
+    const session = this.startImportSession();
+    try {
+      return this.completeSceneImport(session, {
+        base: source.base === void 0 ? void 0 : new ObjResourceList(source.base.fileUrls),
+        stone: source.stone === void 0 ? void 0 : new ObjResourceList(source.stone.fileUrls)
+      });
+    } catch {
+      this.finishImportSession(session);
+      return Promise.resolve({
+        code: ObjImportFailureCode$1.InvalidSource,
+        success: false
+      });
+    }
+  }
   importObjScene(source) {
     this.assertNotDisposed();
     if (this.contextLost) {
@@ -30951,7 +31366,7 @@ class Renderer {
         success: false
       };
     }
-    const firstCandidate = await this.loadSceneModel(session, firstSource);
+    const firstCandidate = await this.loadModel(session, firstSource);
     if (this.isImportResult(firstCandidate)) {
       return firstCandidate;
     }
@@ -30959,7 +31374,7 @@ class Renderer {
     if (stoneSource === void 0 || baseSource === void 0) {
       return this.replaceActiveModels(session, candidateModels);
     }
-    const secondCandidate = await this.loadSceneModel(session, baseSource);
+    const secondCandidate = await this.loadModel(session, baseSource);
     if (this.isImportResult(secondCandidate)) {
       this.releaseModels(candidateModels);
       return secondCandidate;
@@ -30967,10 +31382,17 @@ class Renderer {
     candidateModels.push(secondCandidate);
     return this.replaceActiveModels(session, candidateModels);
   }
-  async loadSceneModel(session, source) {
+  async completeResourceListImport(session, resources) {
+    const candidate = await this.loadModel(session, resources);
+    if (this.isImportResult(candidate)) {
+      return candidate;
+    }
+    return this.replaceActiveModels(session, [candidate]);
+  }
+  async loadModel(session, source) {
     let result;
     try {
-      result = await this.modelLoader.load(source, session.controller.signal);
+      result = source instanceof ObjResourceList ? await this.modelLoader.loadResources(source, session.controller.signal) : await this.modelLoader.load(source, session.controller.signal);
     } catch {
       return this.completeUnexpectedImportFailure(session);
     }
@@ -31256,6 +31678,14 @@ class Application {
     this.assertNotDisposed();
     return this.mapAsyncObjImportResult(this.getRenderer().importObj(source));
   }
+  importObjResources(source) {
+    this.assertNotDisposed();
+    return this.mapAsyncObjImportResult(this.getRenderer().importObjResources(source));
+  }
+  importObjResourceScene(source) {
+    this.assertNotDisposed();
+    return this.mapAsyncObjImportResult(this.getRenderer().importObjResourceScene(source));
+  }
   importObjScene(source) {
     this.assertNotDisposed();
     return this.mapAsyncObjImportResult(this.getRenderer().importObjScene(source));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lingbi/studio",
-    "version": "0.2.0",
+    "version": "0.3.0",
     "type": "module",
     "main": "./index.js",
     "module": "./index.js",