741 lines
25 KiB
JavaScript
741 lines
25 KiB
JavaScript
import THREE from "./init.js";
|
|
export const loadDDSLoader = async () => (await import("three/examples/jsm/loaders/DDSLoader.js")).DDSLoader;
|
|
export const loadMTLLoader = async () => (await import("three/examples/jsm/loaders/MTLLoader.js")).MTLLoader;
|
|
export const loadOBJLoader = async () => (await import("three/examples/jsm/loaders/OBJLoader.js")).OBJLoader;
|
|
export const loadFBXLoader = async () => (await import("three/examples/jsm/loaders/FBXLoader.js")).FBXLoader;
|
|
export const loadPLYLoader = async () => (await import("three/examples/jsm/loaders/PLYLoader.js")).PLYLoader;
|
|
export const loadColladaLoader = async () => (await import("three/examples/jsm/loaders/ColladaLoader.js")).ColladaLoader;
|
|
export const loadSTLLoader = async () => (await import("three/examples/jsm/loaders/STLLoader.js")).STLLoader;
|
|
export const loadXYZLoader = async () => (await import("three/examples/jsm/loaders/XYZLoader.js")).XYZLoader;
|
|
export const loadTDSLoader = async () => (await import("three/examples/jsm/loaders/TDSLoader.js")).TDSLoader;
|
|
export const loadPCDLoader = async () => (await import("three/examples/jsm/loaders/PCDLoader.js")).PCDLoader;
|
|
export const loadGLTFLoader = async () => (await import("three/examples/jsm/loaders/GLTFLoader.js")).GLTFLoader;
|
|
export const loadDRACOLoader = async () => (await import("three/examples/jsm/loaders/DRACOLoader.js")).DRACOLoader;
|
|
export const loadIFCLoader = async () => (await import("./js/loaders/IFCLoader.js")).IFCLoader;
|
|
export const loadRoomEnvironment = async () => (await import("three/examples/jsm/environments/RoomEnvironment.js")).RoomEnvironment;
|
|
export const loadHDRLoader = async () => (await import("three/examples/jsm/loaders/HDRLoader.js")).HDRLoader;
|
|
|
|
import { core } from './core.js';
|
|
import { fetchSettings, presentationMode } from "./metadata.js";
|
|
import { reportViewerError, showToast, toastHelper } from "./viewer-utils.js";
|
|
|
|
export var outlineClipping;
|
|
let environmentTextureCache = {};
|
|
|
|
const loaderMap = {
|
|
gltf: loadGLTFLoader,
|
|
glb: loadGLTFLoader,
|
|
obj: loadOBJLoader,
|
|
fbx: loadFBXLoader,
|
|
ply: loadPLYLoader,
|
|
stl: loadSTLLoader,
|
|
dae: loadColladaLoader,
|
|
xyz: loadXYZLoader,
|
|
'3ds': loadTDSLoader,
|
|
pcd: loadPCDLoader,
|
|
ifc: loadIFCLoader
|
|
};
|
|
|
|
async function createLoader(ext) {
|
|
|
|
const loadLoader = loaderMap[ext];
|
|
|
|
if (!loadLoader) {
|
|
throw new Error(`Unsupported format: ${ext}`);
|
|
}
|
|
|
|
const LoaderClass = await loadLoader();
|
|
return new LoaderClass();
|
|
}
|
|
|
|
const ENV_BUILD = __BUILD__;
|
|
const MODULES_PATH = __MODULES_PATH__;
|
|
const ENV_SUBDIR = __ENV_SUBDIR__;
|
|
console.log('[loaders] ENV_BUILD:', ENV_BUILD);
|
|
console.log('[loaders] MODULES_PATH:', MODULES_PATH);
|
|
console.log('[loaders] ENV_SUBDIR:', ENV_SUBDIR);
|
|
|
|
function normalizeWasmPath(path) {
|
|
if (typeof window === 'undefined' || !path) return path;
|
|
let normalized = path.trim();
|
|
|
|
// Force secure scheme for explicit http resources
|
|
if (normalized.startsWith('http://')) {
|
|
normalized = 'https://' + normalized.slice('http://'.length);
|
|
} else if (normalized.startsWith('//')) {
|
|
normalized = `${window.location.protocol}${normalized}`;
|
|
} else if (normalized.startsWith('/')) {
|
|
normalized = `${window.location.protocol}//${window.location.host}${normalized}`;
|
|
} else if (!/^[a-zA-Z][\w+-.]*:/.test(normalized)) {
|
|
normalized = new URL(normalized, window.location.href).href;
|
|
}
|
|
|
|
// Normalize duplicate slashes while keeping protocol separator intact
|
|
try {
|
|
const url = new URL(normalized);
|
|
url.pathname = url.pathname.replace(/\/\/{2,}/g, '/');
|
|
normalized = url.href;
|
|
} catch (err) {
|
|
normalized = normalized.replace(/\/\/{2,}/g, '/');
|
|
}
|
|
|
|
return normalized;
|
|
}
|
|
|
|
function sanitizeModuleAssetBasePath(input) {
|
|
if (!input || typeof input !== 'string') {
|
|
return '';
|
|
}
|
|
|
|
let basePath = input.trim().replace(/\/$/, '');
|
|
|
|
if (!basePath) {
|
|
return '';
|
|
}
|
|
|
|
if (/^[a-zA-Z][\w+-.]*:\/\//.test(basePath)) {
|
|
try {
|
|
const url = new URL(basePath);
|
|
const hostSegment = `/${url.host}`;
|
|
|
|
if (url.pathname.startsWith(hostSegment)) {
|
|
url.pathname = url.pathname.slice(hostSegment.length) || '/';
|
|
}
|
|
|
|
url.pathname = url.pathname.replace(/\/\/{2,}/g, '/');
|
|
return url.href.replace(/\/$/, '');
|
|
} catch (_err) {
|
|
return basePath;
|
|
}
|
|
}
|
|
|
|
if (/^[^\/]+\.[^\/]+\/.+/.test(basePath)) {
|
|
const parts = basePath.split('/');
|
|
const host = parts.shift();
|
|
const remainder = `/${parts.join('/')}`.replace(/\/\/{2,}/g, '/');
|
|
|
|
if (
|
|
host &&
|
|
typeof window !== 'undefined' &&
|
|
(host === window.location.host || /^\w[\w.-]*\.[a-z]{2,}$/i.test(host))
|
|
) {
|
|
return remainder.replace(/\/$/, '');
|
|
}
|
|
}
|
|
|
|
if (/^\/[^\/]+\.[^\/]+\/.+/.test(basePath)) {
|
|
const parts = basePath.split('/').filter(Boolean);
|
|
const host = parts.shift();
|
|
const remainder = `/${parts.join('/')}`.replace(/\/\/{2,}/g, '/');
|
|
|
|
if (
|
|
host &&
|
|
typeof window !== 'undefined' &&
|
|
(host === window.location.host || /^\w[\w.-]*\.[a-z]{2,}$/i.test(host))
|
|
) {
|
|
return remainder.replace(/\/$/, '');
|
|
}
|
|
}
|
|
|
|
return basePath.replace(/\/\/{2,}/g, '/');
|
|
}
|
|
|
|
function prepareOutlineClipping(_object) {
|
|
core.outlineClipping = _object.clone(true);
|
|
var gutsMaterial = new THREE.MeshBasicMaterial({
|
|
color: "crimson",
|
|
side: THREE.BackSide,
|
|
clippingPlanes: core.clippingPlanes,
|
|
clipShadows: true,
|
|
polygonOffset: true,
|
|
polygonOffsetFactor: 1,
|
|
polygonOffsetUnits: 1,
|
|
});
|
|
|
|
core.outlineClipping.traverse(function (child) {
|
|
if (child.type == "Mesh" || child.type == "Object3D") {
|
|
child.material = gutsMaterial;
|
|
}
|
|
});
|
|
core.outlineClipping.visible = false;
|
|
return core.outlineClipping;
|
|
}
|
|
|
|
function setupSingleMaterial(materials, material) {
|
|
if (material.map) {
|
|
material.map.anisotropy = 16;
|
|
material.map.colorSpace = THREE.SRGBColorSpace;
|
|
}
|
|
material.envMapIntensity = 0.76;
|
|
material.roughness = Math.min(material.roughness * 1.35, 1);
|
|
material.clipShadows = true;
|
|
material.side = core.PRESENTATION_MODE ? THREE.DoubleSide : THREE.FrontSide;
|
|
material.clippingPlanes = core.PRESENTATION_MODE ? [] : core.clippingPlanes;
|
|
//material.clipIntersection = false;
|
|
material.onBeforeCompile = (shader) => {
|
|
shader.fragmentShader = shader.fragmentShader.replace(
|
|
'reflectedLight.directSpecular += directSpecular;',
|
|
`
|
|
reflectedLight.directSpecular += directSpecular * 0.15;
|
|
`
|
|
);
|
|
};
|
|
|
|
material.needsUpdate = true;
|
|
if (material.name === "") material.name = material.uuid;
|
|
var newMaterial = { name: material.name, uuid: material.uuid };
|
|
if (!materials.some((item) => item.uuid === newMaterial.uuid)) materials.push(newMaterial);
|
|
}
|
|
|
|
function setupMaterials(_object) {
|
|
var materials = [];
|
|
if (_object.isMesh) {
|
|
_object.castShadow = true;
|
|
_object.receiveShadow = true;
|
|
if (
|
|
_object.geometry &&
|
|
typeof _object.geometry.computeVertexNormals === "function" &&
|
|
!_object.geometry.getAttribute?.("normal")
|
|
) {
|
|
_object.geometry.computeVertexNormals();
|
|
}
|
|
if (_object.material.isMaterial) {
|
|
setupSingleMaterial(materials, _object.material);
|
|
} else if (Array.isArray(_object.material)) {
|
|
_object.material.forEach((material) =>
|
|
setupSingleMaterial(materials, material)
|
|
);
|
|
}
|
|
}
|
|
return materials;
|
|
}
|
|
|
|
function getMaterialByID(_object, _uuid) {
|
|
var _material;
|
|
_object.traverse(function (child) {
|
|
if (
|
|
child.isMesh &&
|
|
child.material.isMaterial &&
|
|
child.material.uuid === _uuid
|
|
) {
|
|
_material = child.material;
|
|
}
|
|
});
|
|
return _material;
|
|
}
|
|
|
|
function traverseMesh(object) {
|
|
setupMaterials(object);
|
|
|
|
object.traverse(function (child) {
|
|
setupMaterials(child);
|
|
});
|
|
|
|
if (window.Viewer?.initializeMaterialsEditor && core.PRESENTATION_MODE !== true) {
|
|
window.Viewer.initializeMaterialsEditor(object);
|
|
}
|
|
}
|
|
|
|
function getEnvironmentTextureForPreset(renderer, preset = "neutral") {
|
|
if (!renderer) return Promise.resolve(null);
|
|
|
|
core.scene.environmentIntensity = core.environmentMapIntensity || 0.5;
|
|
|
|
// Initialize cache for this preset if not exists
|
|
if (!environmentTextureCache[preset]) {
|
|
environmentTextureCache[preset] = (async () => {
|
|
const pmrem = new THREE.PMREMGenerator(renderer);
|
|
try {
|
|
if (preset === "studio") {
|
|
// Studio uses RoomEnvironment
|
|
const TempRoomEnvironment = await loadRoomEnvironment();
|
|
return pmrem.fromScene(new TempRoomEnvironment()).texture;
|
|
} else if (preset === "neutral" || preset === "sunny" || preset === "goldenHour") {
|
|
// Load HDR map for other presets
|
|
const HDRLoader = await loadHDRLoader();
|
|
const loader = new HDRLoader();
|
|
const baseModulePath = core.CONFIG?.baseModulePath || core.DFG_ASSETS || '/assets';
|
|
const mapFilename = preset === "goldenHour" ? "golden_hour.hdr" : `${preset}.hdr`;
|
|
const mapUrl = `${baseModulePath.replace(/\/$/, '')}/maps/${mapFilename}`;
|
|
|
|
const texture = await new Promise((resolve, reject) => {
|
|
loader.load(mapUrl, resolve, undefined, reject);
|
|
});
|
|
texture.mapping = THREE.EquirectangularReflectionMapping;
|
|
return pmrem.fromEquirectangular(texture).texture;
|
|
}
|
|
return null;
|
|
} finally {
|
|
pmrem.dispose();
|
|
}
|
|
})();
|
|
}
|
|
|
|
return environmentTextureCache[preset];
|
|
}
|
|
|
|
function getEnvironmentTexture(renderer) {
|
|
// Legacy function for backwards compatibility
|
|
return getEnvironmentTextureForPreset(renderer, "neutral");
|
|
}
|
|
|
|
function markEnvironmentMaterialsDirty(root) {
|
|
root?.traverse?.((child) => {
|
|
const materials = child?.material
|
|
? (Array.isArray(child.material) ? child.material : [child.material])
|
|
: [];
|
|
materials.forEach((material) => {
|
|
if (material?.isMeshStandardMaterial || material?.isMeshPhysicalMaterial) {
|
|
material.needsUpdate = true;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
export async function syncSceneEnvironment(enabled = true, preset = null) {
|
|
if (!core.scene) return;
|
|
|
|
// Use provided preset or fall back to viewer's preset, then neutral
|
|
const effectivePreset = preset || window.viewer?.environmentMapPreset || "neutral";
|
|
|
|
if (enabled) {
|
|
core.scene.environment = await getEnvironmentTextureForPreset(core.renderer, effectivePreset);
|
|
if (core.scene.environmentIntensity === 0) {
|
|
core.scene.environmentIntensity = 0.5;
|
|
}
|
|
} else {
|
|
core.scene.environment = null;
|
|
core.scene.environmentIntensity = 0;
|
|
}
|
|
|
|
markEnvironmentMaterialsDirty(core.scene);
|
|
}
|
|
|
|
function reportLoadError(error, context = "") {
|
|
const message = reportViewerError(error, {
|
|
context,
|
|
consoleLabel: "Viewer load error:",
|
|
});
|
|
core.circle?.complete?.(1200);
|
|
if (typeof core.EXIT_CODE !== "undefined") core.EXIT_CODE = 1;
|
|
return message;
|
|
}
|
|
|
|
export async function loadModel() {
|
|
core.loadingLog?.start?.();
|
|
let modelPath = core.fileObject.filename.startsWith('blob:') ? core.fileObject.filename : core.fileObject.path + core.fileObject.filename;
|
|
if (core.CONFIG.entity.proxyPath !== undefined && !core.fileObject.filename.startsWith('blob:')) {
|
|
modelPath = core.getProxyPath(modelPath, core.CONFIG, core.fileObject);
|
|
}
|
|
|
|
function loadAsync(loader, url, progressHandler = onProgress) {
|
|
return new Promise((resolve, reject) => {
|
|
loader.load(url, resolve, progressHandler, reject);
|
|
});
|
|
}
|
|
|
|
function updateLoadingStage(stageKey, progressValue = null) {
|
|
core.circle?.setStage?.(stageKey, progressValue);
|
|
core.loadingLog?.setStage?.(stageKey, progressValue);
|
|
}
|
|
|
|
async function afterLoad({ object }) {
|
|
if (object === null || typeof object === "undefined") {
|
|
throw new Error("Loaded object is null or undefined.");
|
|
}
|
|
updateLoadingStage("loadingLog.loadingTextures", 99);
|
|
|
|
// Keep authoring transforms in presentation mode to avoid collapsing model parts.
|
|
if (!core.PRESENTATION_MODE) {
|
|
// Reset transform to ensure consistent positioning
|
|
if (Array.isArray(object)) {
|
|
object.forEach(obj => {
|
|
obj.position.set(0, 0, 0);
|
|
obj.rotation.set(0, 0, 0);
|
|
obj.scale.set(1, 1, 1);
|
|
obj.updateMatrixWorld(true);
|
|
});
|
|
} else {
|
|
object.position.set(0, 0, 0);
|
|
object.rotation.set(0, 0, 0);
|
|
object.scale.set(1, 1, 1);
|
|
object.updateMatrixWorld(true);
|
|
}
|
|
core.handHint.hidden = true;
|
|
}
|
|
|
|
window.viewer.modelLoaded = true;
|
|
updateLoadingStage("loadingLog.preparingGeometry", 99);
|
|
traverseMesh(object);
|
|
|
|
if (!core.PRESENTATION_MODE) {
|
|
const isArchiveDerivedPath = /\/[^/]+_(ZIP|RAR|TAR|XZ|GZ)\/gltf\/$/i.test(core.fileObject.path);
|
|
if (!isArchiveDerivedPath) {
|
|
if (core.fileObject.extension.toLowerCase() === "gltf" || core.fileObject.extension.toLowerCase() === "glb") {
|
|
core.fileObject.path = core.fileObject.path.replace("/gltf/", "/");
|
|
} else {
|
|
core.fileObject.path = core.fileObject.path.replace("gltf/", "");
|
|
}
|
|
}
|
|
updateLoadingStage("loadingLog.fetchingMetadata", 99);
|
|
await fetchSettings(object);
|
|
|
|
updateLoadingStage("loadingLog.settingUpMaterials", 99);
|
|
core.outlineClipping = prepareOutlineClipping(object);
|
|
if (Array.isArray(object)) {
|
|
core.helperObjects.push(object[0]);
|
|
} else {
|
|
core.helperObjects.push(object);
|
|
}
|
|
core.scene.add(core.outlineClipping);
|
|
} else {
|
|
updateLoadingStage("loadingLog.settingUpMaterials", 99);
|
|
presentationMode(object, null).catch(error => {
|
|
reportLoadError(error, "Presentation mode setup failed");
|
|
showToast("toasts.presentationModeError", "error");
|
|
});
|
|
}
|
|
|
|
updateLoadingStage("loadingLog.settingUpLighting", 99);
|
|
if (Array.isArray(object)) {
|
|
object.forEach(o => core.scene.add(o));
|
|
} else {
|
|
core.scene.add(object);
|
|
}
|
|
core.mainObject.push(object);
|
|
|
|
updateLoadingStage("loadingLog.compilingShaders", 99);
|
|
await syncSceneEnvironment(core.environmentMapEnabled !== false);
|
|
}
|
|
|
|
async function loadOBJWithMTL() {
|
|
const DDSLoader = await loadDDSLoader();
|
|
const MTLLoader = await loadMTLLoader();
|
|
const OBJLoader = await loadOBJLoader();
|
|
const manager = new THREE.LoadingManager();
|
|
manager.onLoad = () => toastHelper("objLoaded", "success");
|
|
manager.addHandler(/\.dds$/i, new DDSLoader());
|
|
|
|
const basename = core.fileObject.filename.replace(/\.[^/.]+$/, "");
|
|
const filename = core.fileObject.filename;
|
|
|
|
if (!core.CONFIG.noMTL) {
|
|
try {
|
|
const materials = await new Promise((resolve, reject) => {
|
|
new MTLLoader(manager)
|
|
.setPath(core.fileObject.path)
|
|
.load(basename + ".mtl", resolve, undefined, reject);
|
|
});
|
|
materials.preload();
|
|
|
|
const obj = await new Promise((resolve, reject) => {
|
|
new OBJLoader(manager)
|
|
.setMaterials(materials)
|
|
.setPath(core.fileObject.path)
|
|
.load(filename, resolve, onProgress, reject);
|
|
});
|
|
|
|
obj.position.set(0, 0, 0);
|
|
return obj;
|
|
} catch (error) {
|
|
core.CONFIG.noMTL = true;
|
|
toastHelper("mtlLoadError", "error");
|
|
console.warn("MTL load failed, falling back to OBJ-only load.", error);
|
|
}
|
|
}
|
|
|
|
const obj = await new Promise((resolve, reject) => {
|
|
new OBJLoader()
|
|
.setPath(core.fileObject.path)
|
|
.load(filename, resolve, onProgress, reject);
|
|
});
|
|
|
|
obj.position.set(0, 0, 0);
|
|
return obj;
|
|
}
|
|
|
|
function normalizePath(path) {
|
|
if (!path || typeof path !== 'string') {
|
|
return path;
|
|
}
|
|
|
|
if (/^[a-zA-Z][\w+-.]*:\/\//.test(path)) {
|
|
try {
|
|
const url = new URL(path);
|
|
url.pathname = url.pathname.replace(/\/{2,}/g, '/');
|
|
return url.href;
|
|
} catch (_err) {
|
|
return path;
|
|
}
|
|
}
|
|
|
|
return path.replace(/\/{2,}/g, '/');
|
|
}
|
|
|
|
async function resolveIfcWasmPath(basePath) {
|
|
const candidates = [
|
|
normalizePath(basePath.replace(/\/$/, '') + '/ifc/'),
|
|
normalizePath(basePath.replace(/\/$/, '') + '/ifc'),
|
|
];
|
|
|
|
for (const candidate of candidates) {
|
|
const wasmUrl = candidate.replace(/\/$/, '') + '/web-ifc.wasm';
|
|
try {
|
|
const res = await fetch(wasmUrl, { method: 'HEAD', cache: 'no-store' });
|
|
if (res.ok) {
|
|
return candidate;
|
|
}
|
|
} catch (err) {
|
|
// ignored, try next candidate
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async function loadGLTFModel() {
|
|
let gltfModelPath = core.fileObject.filename.startsWith('blob:') ? core.fileObject.filename : core.fileObject.path + core.fileObject.basename + "." + core.fileObject.extension;
|
|
if (core.CONFIG.entity.proxyPath !== undefined && !core.fileObject.filename.startsWith('blob:')) {
|
|
gltfModelPath = core.getProxyPath(gltfModelPath);
|
|
}
|
|
|
|
const dracoBase = normalizePath(normalizeWasmPath(`${getModuleAssetBasePath()}/draco/gltf/`));
|
|
|
|
const loader = await createLoader(core.fileObject.extension.toLowerCase());
|
|
const DRACOLoader = await loadDRACOLoader();
|
|
const draco = new DRACOLoader();
|
|
if (ENV_BUILD !== 'test' && ENV_BUILD !== 'dev') {
|
|
draco.setDecoderConfig({ type: 'js' });
|
|
}
|
|
draco.setDecoderPath(dracoBase);
|
|
loader.setDRACOLoader(draco);
|
|
|
|
try {
|
|
const gltf = await new Promise((resolve, reject) => {
|
|
loader.load(
|
|
gltfModelPath,
|
|
resolve,
|
|
(xhr) => {
|
|
progressLoaderHandler(xhr);
|
|
},
|
|
reject
|
|
);
|
|
});
|
|
return gltf.scene;
|
|
} finally {
|
|
draco.dispose();
|
|
}
|
|
}
|
|
|
|
try {
|
|
switch (core.fileObject.extension.toLowerCase()) {
|
|
case "obj": {
|
|
const object = await loadOBJWithMTL();
|
|
await afterLoad({ object });
|
|
break;
|
|
}
|
|
|
|
case "fbx": {
|
|
const loader = await createLoader(core.fileObject.extension.toLowerCase());
|
|
const object = await loadAsync(loader, modelPath, onProgress);
|
|
object.position.set(0, 0, 0);
|
|
await afterLoad({ object });
|
|
break;
|
|
}
|
|
|
|
case "ply": {
|
|
const loader = await createLoader(core.fileObject.extension.toLowerCase());
|
|
const geometry = await loadAsync(loader, modelPath, onProgress);
|
|
if (!geometry.getAttribute?.("normal")) {
|
|
geometry.computeVertexNormals();
|
|
}
|
|
const material = new THREE.MeshStandardMaterial({ color: 0x0055ff, flatShading: true });
|
|
const object = new THREE.Mesh(geometry, material);
|
|
object.position.set(0, 0, 0);
|
|
object.castShadow = true;
|
|
object.receiveShadow = true;
|
|
await afterLoad({ object });
|
|
break;
|
|
}
|
|
|
|
case "dae": {
|
|
const loader = await createLoader(core.fileObject.extension.toLowerCase());
|
|
const collada = await loadAsync(loader, modelPath, onProgress);
|
|
const object = collada.scene;
|
|
object.position.set(0, 0, 0);
|
|
await afterLoad({ object });
|
|
break;
|
|
}
|
|
|
|
case "ifc": {
|
|
const loader = await createLoader(core.fileObject.extension.toLowerCase());
|
|
const basePath = getModuleAssetBasePath();
|
|
|
|
let ifcWasmPath = await resolveIfcWasmPath(basePath);
|
|
|
|
if (!ifcWasmPath) {
|
|
const errorMsg = `[loadModel] IFC WASM not found in ${basePath}/ifc; please verify path and permissions`;
|
|
console.error(errorMsg);
|
|
throw new Error(errorMsg);
|
|
}
|
|
|
|
const normalizedIfcWasmPath = normalizeWasmPath(ifcWasmPath);
|
|
console.log('[loadModel] IFC WASM path:', normalizedIfcWasmPath);
|
|
loader.ifcManager.setWasmPath(normalizedIfcWasmPath, true);
|
|
const object = await loadAsync(loader, modelPath, onProgress);
|
|
await afterLoad({ object });
|
|
break;
|
|
}
|
|
|
|
case "stl": {
|
|
const loader = await createLoader(core.fileObject.extension.toLowerCase());
|
|
const geometry = await loadAsync(loader, modelPath, onProgress);
|
|
let meshMaterial = new THREE.MeshPhongMaterial({ color: 0xff5533, specular: 0x111111, shininess: 200 });
|
|
if (geometry.hasColors) {
|
|
meshMaterial = new THREE.MeshPhongMaterial({ opacity: geometry.alpha, vertexColors: true });
|
|
}
|
|
const object = new THREE.Mesh(geometry, meshMaterial);
|
|
object.position.set(0, 0, 0);
|
|
object.castShadow = true;
|
|
object.receiveShadow = true;
|
|
await afterLoad({ object });
|
|
break;
|
|
}
|
|
|
|
case "xyz": {
|
|
const loader = await createLoader(core.fileObject.extension.toLowerCase());
|
|
const geometry = await loadAsync(loader, modelPath, onProgress);
|
|
geometry.center();
|
|
const material = new THREE.PointsMaterial({ size: 0.1, vertexColors: geometry.hasAttribute("color") === true });
|
|
const object = new THREE.Points(geometry, material);
|
|
object.position.set(0, 0, 0);
|
|
await afterLoad({ object });
|
|
break;
|
|
}
|
|
|
|
case "pcd": {
|
|
const loader = await createLoader(core.fileObject.extension.toLowerCase());
|
|
const mesh = await loadAsync(loader, modelPath, onProgress);
|
|
mesh.geometry?.center?.();
|
|
if (mesh.material) {
|
|
mesh.material.size = Math.max(mesh.material.size ?? 0, 0.1);
|
|
}
|
|
await afterLoad({ object: mesh });
|
|
break;
|
|
}
|
|
|
|
case "json": {
|
|
const loader = new THREE.ObjectLoader();
|
|
const object = await loadAsync(loader, modelPath, onProgress);
|
|
object.position.set(0, 0, 0);
|
|
await afterLoad({ object });
|
|
break;
|
|
}
|
|
|
|
case "3ds": {
|
|
const loader = await createLoader(core.fileObject.extension.toLowerCase());
|
|
loader.setResourcePath(core.fileObject.path);
|
|
let mp = core.fileObject.path;
|
|
if (core.CONFIG.entity.proxyPath !== undefined) mp = core.getProxyPath(mp);
|
|
const object = await loadAsync(loader, mp + core.fileObject.basename + "." + core.fileObject.extension, onProgress);
|
|
await afterLoad({ object });
|
|
break;
|
|
}
|
|
|
|
case "glb":
|
|
case "gltf": {
|
|
const object = await loadGLTFModel();
|
|
await afterLoad({ object });
|
|
break;
|
|
}
|
|
default:
|
|
toastHelper("unsupportedExtension", "warning");
|
|
core.loadingLog?.fail?.();
|
|
return;
|
|
}
|
|
|
|
updateLoadingStage("loadingLog.modelLoaded", 100);
|
|
core.circle?.complete?.(2600);
|
|
core.editorToolbar?.classList.remove('editorToolbar-hidden');
|
|
core.editorToolbar?.classList.add('editorToolbar-visible');
|
|
core.loadingLog?.finish?.();
|
|
if (!core.PRESENTATION_MODE) {
|
|
toastHelper("modelLoaded", "success", {
|
|
filename: core.fileObject.filename
|
|
});
|
|
} else {
|
|
toastHelper("presentationModeReady", "success");
|
|
}
|
|
if (typeof core.EXIT_CODE !== "undefined") core.EXIT_CODE = 0;
|
|
core.UltraLoader?.finish();
|
|
core.poller?.updateSteps(2);
|
|
} catch (error) {
|
|
core.loadingLog?.fail?.();
|
|
reportLoadError(error, `Failed to load ${core.fileObject.filename}`);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
export const getModuleAssetBasePath = function() {
|
|
const configuredPath = sanitizeModuleAssetBasePath(core.CONFIG?.baseModulePath);
|
|
let basePath = configuredPath || sanitizeModuleAssetBasePath(core.DFG_ASSETS);
|
|
if (!basePath && typeof import.meta !== 'undefined' && import.meta.url) {
|
|
const moduleUrl = new URL(import.meta.url);
|
|
basePath = moduleUrl.pathname.includes('/assets/')
|
|
? new URL('../assets/', moduleUrl).pathname.replace(/\/$/, '')
|
|
: new URL('./assets/', moduleUrl).pathname.replace(/\/$/, '');
|
|
}
|
|
if (!basePath) {
|
|
basePath = '/assets';
|
|
}
|
|
// Standalone local dev servers expose assets at /assets; embedded hosts provide baseModulePath.
|
|
if (core.isLocalPreview && !configuredPath) {
|
|
basePath = '/assets';
|
|
}
|
|
basePath = sanitizeModuleAssetBasePath(basePath);
|
|
console.log('[loaders] resolved ModuleAssetBasePath:', basePath);
|
|
core.CONFIG.baseModulePath = basePath;
|
|
core.DFG_ASSETS = basePath;
|
|
return basePath;
|
|
};
|
|
|
|
export const onError = function (_event) {
|
|
reportLoadError(_event, "Loader error");
|
|
};
|
|
|
|
export const onErrorMTL = async function (_event) {
|
|
core.CONFIG.noMTL = true;
|
|
toastHelper("mtlLoadError", "error");
|
|
await loadModel();
|
|
};
|
|
|
|
export const onErrorGLB = async function (_event, params, loadedTimes) {
|
|
console.log("Loader error: " + _event);
|
|
if (window.__E2E__ && window.viewer) {
|
|
window.viewer.errors ??= [];
|
|
window.viewer.errors.push(String(_event));
|
|
}
|
|
core.loadedFile = params.path + params.basename + core.loadedFile + "gltf/";
|
|
if (typeof _event !== undefined && loadedTimes <= 1 && window.viewer.modelLoaded === false) {
|
|
await loadModel();
|
|
loadedTimes++;
|
|
} else {
|
|
toastHelper("glbLoadError", "error");
|
|
}
|
|
};
|
|
|
|
export const onProgress = function (xhr) {
|
|
progressLoaderHandler(xhr);
|
|
};
|
|
|
|
const progressLoaderHandler = function (xhr) {
|
|
if (!core.circle) return;
|
|
const total = xhr.total || xhr.loaded || 1;
|
|
const percentComplete = Math.min((xhr.loaded / total) * 100, 99);
|
|
if (!Number.isFinite(percentComplete)) return;
|
|
core.circle.show();
|
|
core.circle.set(percentComplete, 100);
|
|
core.editorToolbar?.classList.remove('editorToolbar-hidden');
|
|
core.editorToolbar?.classList.add('editorToolbar-visible');
|
|
core.loadingLog?.update?.(percentComplete);
|
|
core.UltraLoader?.set(percentComplete);
|
|
}
|