backend/libs/three/loaders/ObjectLoader.js

import {
	UVMapping,
	CubeReflectionMapping,
	CubeRefractionMapping,
	EquirectangularReflectionMapping,
	EquirectangularRefractionMapping,
	CubeUVReflectionMapping,
	CubeUVRefractionMapping,
	RepeatWrapping,
	ClampToEdgeWrapping,
	MirroredRepeatWrapping,
	NearestFilter,
	NearestMipmapNearestFilter,
	NearestMipmapLinearFilter,
	LinearFilter,
	LinearMipmapNearestFilter,
	LinearMipmapLinearFilter,
} from '../constants.js';
import { InstancedBufferAttribute } from '../core/InstancedBufferAttribute.js';
import { Color } from '../math/Color.js';
import { Object3D } from '../core/Object3D.js';
import { Group } from '../objects/Group.js';
import { InstancedMesh } from '../objects/InstancedMesh.js';
import { Sprite } from '../objects/Sprite.js';
import { Points } from '../objects/Points.js';
import { Line } from '../objects/Line.js';
import { LineLoop } from '../objects/LineLoop.js';
import { LineSegments } from '../objects/LineSegments.js';
import { LOD } from '../objects/LOD.js';
import { Mesh } from '../objects/Mesh.js';
import { SkinnedMesh } from '../objects/SkinnedMesh.js';
import { Bone } from '../objects/Bone.js';
import { Skeleton } from '../objects/Skeleton.js';
import { Shape } from '../extras/core/Shape.js';
import { Fog } from '../scenes/Fog.js';
import { FogExp2 } from '../scenes/FogExp2.js';
import { HemisphereLight } from '../lights/HemisphereLight.js';
import { SpotLight } from '../lights/SpotLight.js';
import { PointLight } from '../lights/PointLight.js';
import { DirectionalLight } from '../lights/DirectionalLight.js';
import { AmbientLight } from '../lights/AmbientLight.js';
import { RectAreaLight } from '../lights/RectAreaLight.js';
import { LightProbe } from '../lights/LightProbe.js';
import { OrthographicCamera } from '../cameras/OrthographicCamera.js';
import { PerspectiveCamera } from '../cameras/PerspectiveCamera.js';
import { Scene } from '../scenes/Scene.js';
import { CubeTexture } from '../textures/CubeTexture.js';
import { Texture } from '../textures/Texture.js';
import { DataTexture } from '../textures/DataTexture.js';
import { ImageLoader } from './ImageLoader.js';
import { LoadingManager } from './LoadingManager.js';
import { AnimationClip } from '../animation/AnimationClip.js';
import { MaterialLoader } from './MaterialLoader.js';
import { LoaderUtils } from './LoaderUtils.js';
import { BufferGeometryLoader } from './BufferGeometryLoader.js';
import { Loader } from './Loader.js';
import { FileLoader } from './FileLoader.js';
import * as Geometries from '../geometries/Geometries.js';
import { getTypedArray } from '../utils.js';

class ObjectLoader extends Loader {
	constructor(manager) {
		super(manager);
	}

	load(url, onLoad, onProgress, onError) {
		const scope = this;

		const path = this.path === '' ? LoaderUtils.extractUrlBase(url) : this.path;
		this.resourcePath = this.resourcePath || path;

		const loader = new FileLoader(this.manager);
		loader.setPath(this.path);
		loader.setRequestHeader(this.requestHeader);
		loader.setWithCredentials(this.withCredentials);
		loader.load(
			url,
			function (text) {
				let json = null;

				try {
					json = JSON.parse(text);
				} catch (error) {
					if (onError !== undefined) onError(error);

					console.error("THREE:ObjectLoader: Can't parse " + url + '.', error.message);

					return;
				}

				const metadata = json.metadata;

				if (metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry') {
					console.error("THREE.ObjectLoader: Can't load " + url);
					return;
				}

				scope.parse(json, onLoad);
			},
			onProgress,
			onError
		);
	}

	async loadAsync(url, onProgress) {
		const scope = this;

		const path = this.path === '' ? LoaderUtils.extractUrlBase(url) : this.path;
		this.resourcePath = this.resourcePath || path;

		const loader = new FileLoader(this.manager);
		loader.setPath(this.path);
		loader.setRequestHeader(this.requestHeader);
		loader.setWithCredentials(this.withCredentials);

		const text = await loader.loadAsync(url, onProgress);

		const json = JSON.parse(text);

		const metadata = json.metadata;

		if (metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry') {
			throw new Error("THREE.ObjectLoader: Can't load " + url);
		}

		return await scope.parseAsync(json);
	}

	parse(json, onLoad) {
		const animations = this.parseAnimations(json.animations);
		const shapes = this.parseShapes(json.shapes);
		const geometries = this.parseGeometries(json.geometries, shapes);

		const images = this.parseImages(json.images, function () {
			if (onLoad !== undefined) onLoad(object);
		});

		const textures = this.parseTextures(json.textures, images);
		const materials = this.parseMaterials(json.materials, textures);

		const object = this.parseObject(json.object, geometries, materials, textures, animations);
		const skeletons = this.parseSkeletons(json.skeletons, object);

		this.bindSkeletons(object, skeletons);

		//

		if (onLoad !== undefined) {
			let hasImages = false;

			for (const uuid in images) {
				if (images[uuid] instanceof HTMLImageElement) {
					hasImages = true;
					break;
				}
			}

			if (hasImages === false) onLoad(object);
		}

		return object;
	}

	async parseAsync(json) {
		const animations = this.parseAnimations(json.animations);
		const shapes = this.parseShapes(json.shapes);
		const geometries = this.parseGeometries(json.geometries, shapes);

		const images = await this.parseImagesAsync(json.images);

		const textures = this.parseTextures(json.textures, images);
		const materials = this.parseMaterials(json.materials, textures);

		const object = this.parseObject(json.object, geometries, materials, textures, animations);
		const skeletons = this.parseSkeletons(json.skeletons, object);

		this.bindSkeletons(object, skeletons);

		return object;
	}

	parseShapes(json) {
		const shapes = {};

		if (json !== undefined) {
			for (let i = 0, l = json.length; i < l; i++) {
				const shape = new Shape().fromJSON(json[i]);

				shapes[shape.uuid] = shape;
			}
		}

		return shapes;
	}

	parseSkeletons(json, object) {
		const skeletons = {};
		const bones = {};

		// generate bone lookup table

		object.traverse(function (child) {
			if (child.isBone) bones[child.uuid] = child;
		});

		// create skeletons

		if (json !== undefined) {
			for (let i = 0, l = json.length; i < l; i++) {
				const skeleton = new Skeleton().fromJSON(json[i], bones);

				skeletons[skeleton.uuid] = skeleton;
			}
		}

		return skeletons;
	}

	parseGeometries(json, shapes) {
		const geometries = {};

		if (json !== undefined) {
			const bufferGeometryLoader = new BufferGeometryLoader();

			for (let i = 0, l = json.length; i < l; i++) {
				let geometry;
				const data = json[i];

				switch (data.type) {
					case 'BufferGeometry':
					case 'InstancedBufferGeometry':
						geometry = bufferGeometryLoader.parse(data);

						break;

					case 'Geometry':
						console.error('THREE.ObjectLoader: The legacy Geometry type is no longer supported.');

						break;

					default:
						if (data.type in Geometries) {
							geometry = Geometries[data.type].fromJSON(data, shapes);
						} else {
							console.warn(`THREE.ObjectLoader: Unsupported geometry type "${data.type}"`);
						}
				}

				geometry.uuid = data.uuid;

				if (data.name !== undefined) geometry.name = data.name;
				if (geometry.isBufferGeometry === true && data.userData !== undefined) geometry.userData = data.userData;

				geometries[data.uuid] = geometry;
			}
		}

		return geometries;
	}

	parseMaterials(json, textures) {
		const cache = {}; // MultiMaterial
		const materials = {};

		if (json !== undefined) {
			const loader = new MaterialLoader();
			loader.setTextures(textures);

			for (let i = 0, l = json.length; i < l; i++) {
				const data = json[i];

				if (data.type === 'MultiMaterial') {
					// Deprecated

					const array = [];

					for (let j = 0; j < data.materials.length; j++) {
						const material = data.materials[j];

						if (cache[material.uuid] === undefined) {
							cache[material.uuid] = loader.parse(material);
						}

						array.push(cache[material.uuid]);
					}

					materials[data.uuid] = array;
				} else {
					if (cache[data.uuid] === undefined) {
						cache[data.uuid] = loader.parse(data);
					}

					materials[data.uuid] = cache[data.uuid];
				}
			}
		}

		return materials;
	}

	parseAnimations(json) {
		const animations = {};

		if (json !== undefined) {
			for (let i = 0; i < json.length; i++) {
				const data = json[i];

				const clip = AnimationClip.parse(data);

				animations[clip.uuid] = clip;
			}
		}

		return animations;
	}

	parseImages(json, onLoad) {
		const scope = this;
		const images = {};

		let loader;

		function loadImage(url) {
			scope.manager.itemStart(url);

			return loader.load(
				url,
				function () {
					scope.manager.itemEnd(url);
				},
				undefined,
				function () {
					scope.manager.itemError(url);
					scope.manager.itemEnd(url);
				}
			);
		}

		function deserializeImage(image) {
			if (typeof image === 'string') {
				const url = image;

				const path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test(url) ? url : scope.resourcePath + url;

				return loadImage(path);
			} else {
				if (image.data) {
					return {
						data: getTypedArray(image.type, image.data),
						width: image.width,
						height: image.height,
					};
				} else {
					return null;
				}
			}
		}

		if (json !== undefined && json.length > 0) {
			const manager = new LoadingManager(onLoad);

			loader = new ImageLoader(manager);
			loader.setCrossOrigin(this.crossOrigin);

			for (let i = 0, il = json.length; i < il; i++) {
				const image = json[i];
				const url = image.url;

				if (Array.isArray(url)) {
					// load array of images e.g CubeTexture

					images[image.uuid] = [];

					for (let j = 0, jl = url.length; j < jl; j++) {
						const currentUrl = url[j];

						const deserializedImage = deserializeImage(currentUrl);

						if (deserializedImage !== null) {
							if (deserializedImage instanceof HTMLImageElement) {
								images[image.uuid].push(deserializedImage);
							} else {
								// special case: handle array of data textures for cube textures

								images[image.uuid].push(new DataTexture(deserializedImage.data, deserializedImage.width, deserializedImage.height));
							}
						}
					}
				} else {
					// load single image

					const deserializedImage = deserializeImage(image.url);

					if (deserializedImage !== null) {
						images[image.uuid] = deserializedImage;
					}
				}
			}
		}

		return images;
	}

	async parseImagesAsync(json) {
		const scope = this;
		const images = {};

		let loader;

		async function deserializeImage(image) {
			if (typeof image === 'string') {
				const url = image;

				const path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test(url) ? url : scope.resourcePath + url;

				return await loader.loadAsync(path);
			} else {
				if (image.data) {
					return {
						data: getTypedArray(image.type, image.data),
						width: image.width,
						height: image.height,
					};
				} else {
					return null;
				}
			}
		}

		if (json !== undefined && json.length > 0) {
			loader = new ImageLoader(this.manager);
			loader.setCrossOrigin(this.crossOrigin);

			for (let i = 0, il = json.length; i < il; i++) {
				const image = json[i];
				const url = image.url;

				if (Array.isArray(url)) {
					// load array of images e.g CubeTexture

					images[image.uuid] = [];

					for (let j = 0, jl = url.length; j < jl; j++) {
						const currentUrl = url[j];

						const deserializedImage = await deserializeImage(currentUrl);

						if (deserializedImage !== null) {
							if (deserializedImage instanceof HTMLImageElement) {
								images[image.uuid].push(deserializedImage);
							} else {
								// special case: handle array of data textures for cube textures

								images[image.uuid].push(new DataTexture(deserializedImage.data, deserializedImage.width, deserializedImage.height));
							}
						}
					}
				} else {
					// load single image

					const deserializedImage = await deserializeImage(image.url);

					if (deserializedImage !== null) {
						images[image.uuid] = deserializedImage;
					}
				}
			}
		}

		return images;
	}

	parseTextures(json, images) {
		function parseConstant(value, type) {
			if (typeof value === 'number') return value;

			console.warn('THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value);

			return type[value];
		}

		const textures = {};

		if (json !== undefined) {
			for (let i = 0, l = json.length; i < l; i++) {
				const data = json[i];

				if (data.image === undefined) {
					console.warn('THREE.ObjectLoader: No "image" specified for', data.uuid);
				}

				if (images[data.image] === undefined) {
					console.warn('THREE.ObjectLoader: Undefined image', data.image);
				}

				let texture;
				const image = images[data.image];

				if (Array.isArray(image)) {
					texture = new CubeTexture(image);

					if (image.length === 6) texture.needsUpdate = true;
				} else {
					if (image && image.data) {
						texture = new DataTexture(image.data, image.width, image.height);
					} else {
						texture = new Texture(image);
					}

					if (image) texture.needsUpdate = true; // textures can have undefined image data
				}

				texture.uuid = data.uuid;

				if (data.name !== undefined) texture.name = data.name;

				if (data.mapping !== undefined) texture.mapping = parseConstant(data.mapping, TEXTURE_MAPPING);

				if (data.offset !== undefined) texture.offset.fromArray(data.offset);
				if (data.repeat !== undefined) texture.repeat.fromArray(data.repeat);
				if (data.center !== undefined) texture.center.fromArray(data.center);
				if (data.rotation !== undefined) texture.rotation = data.rotation;

				if (data.wrap !== undefined) {
					texture.wrapS = parseConstant(data.wrap[0], TEXTURE_WRAPPING);
					texture.wrapT = parseConstant(data.wrap[1], TEXTURE_WRAPPING);
				}

				if (data.format !== undefined) texture.format = data.format;
				if (data.type !== undefined) texture.type = data.type;
				if (data.encoding !== undefined) texture.encoding = data.encoding;

				if (data.minFilter !== undefined) texture.minFilter = parseConstant(data.minFilter, TEXTURE_FILTER);
				if (data.magFilter !== undefined) texture.magFilter = parseConstant(data.magFilter, TEXTURE_FILTER);
				if (data.anisotropy !== undefined) texture.anisotropy = data.anisotropy;

				if (data.flipY !== undefined) texture.flipY = data.flipY;

				if (data.premultiplyAlpha !== undefined) texture.premultiplyAlpha = data.premultiplyAlpha;
				if (data.unpackAlignment !== undefined) texture.unpackAlignment = data.unpackAlignment;

				if (data.userData !== undefined) texture.userData = data.userData;

				textures[data.uuid] = texture;
			}
		}

		return textures;
	}

	parseObject(data, geometries, materials, textures, animations) {
		let object;

		function getGeometry(name) {
			if (geometries[name] === undefined) {
				console.warn('THREE.ObjectLoader: Undefined geometry', name);
			}

			return geometries[name];
		}

		function getMaterial(name) {
			if (name === undefined) return undefined;

			if (Array.isArray(name)) {
				const array = [];

				for (let i = 0, l = name.length; i < l; i++) {
					const uuid = name[i];

					if (materials[uuid] === undefined) {
						console.warn('THREE.ObjectLoader: Undefined material', uuid);
					}

					array.push(materials[uuid]);
				}

				return array;
			}

			if (materials[name] === undefined) {
				console.warn('THREE.ObjectLoader: Undefined material', name);
			}

			return materials[name];
		}

		function getTexture(uuid) {
			if (textures[uuid] === undefined) {
				console.warn('THREE.ObjectLoader: Undefined texture', uuid);
			}

			return textures[uuid];
		}

		let geometry, material;

		switch (data.type) {
			case 'Scene':
				object = new Scene();

				if (data.background !== undefined) {
					if (Number.isInteger(data.background)) {
						object.background = new Color(data.background);
					} else {
						object.background = getTexture(data.background);
					}
				}

				if (data.environment !== undefined) {
					object.environment = getTexture(data.environment);
				}

				if (data.fog !== undefined) {
					if (data.fog.type === 'Fog') {
						object.fog = new Fog(data.fog.color, data.fog.near, data.fog.far);
					} else if (data.fog.type === 'FogExp2') {
						object.fog = new FogExp2(data.fog.color, data.fog.density);
					}
				}

				break;

			case 'PerspectiveCamera':
				object = new PerspectiveCamera(data.fov, data.aspect, data.near, data.far);

				if (data.focus !== undefined) object.focus = data.focus;
				if (data.zoom !== undefined) object.zoom = data.zoom;
				if (data.filmGauge !== undefined) object.filmGauge = data.filmGauge;
				if (data.filmOffset !== undefined) object.filmOffset = data.filmOffset;
				if (data.view !== undefined) object.view = Object.assign({}, data.view);

				break;

			case 'OrthographicCamera':
				object = new OrthographicCamera(data.left, data.right, data.top, data.bottom, data.near, data.far);

				if (data.zoom !== undefined) object.zoom = data.zoom;
				if (data.view !== undefined) object.view = Object.assign({}, data.view);

				break;

			case 'AmbientLight':
				object = new AmbientLight(data.color, data.intensity);

				break;

			case 'DirectionalLight':
				object = new DirectionalLight(data.color, data.intensity);

				break;

			case 'PointLight':
				object = new PointLight(data.color, data.intensity, data.distance, data.decay);

				break;

			case 'RectAreaLight':
				object = new RectAreaLight(data.color, data.intensity, data.width, data.height);

				break;

			case 'SpotLight':
				object = new SpotLight(data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay);

				break;

			case 'HemisphereLight':
				object = new HemisphereLight(data.color, data.groundColor, data.intensity);

				break;

			case 'LightProbe':
				object = new LightProbe().fromJSON(data);

				break;

			case 'SkinnedMesh':
				geometry = getGeometry(data.geometry);
				material = getMaterial(data.material);

				object = new SkinnedMesh(geometry, material);

				if (data.bindMode !== undefined) object.bindMode = data.bindMode;
				if (data.bindMatrix !== undefined) object.bindMatrix.fromArray(data.bindMatrix);
				if (data.skeleton !== undefined) object.skeleton = data.skeleton;

				break;

			case 'Mesh':
				geometry = getGeometry(data.geometry);
				material = getMaterial(data.material);

				object = new Mesh(geometry, material);

				break;

			case 'InstancedMesh':
				geometry = getGeometry(data.geometry);
				material = getMaterial(data.material);
				const count = data.count;
				const instanceMatrix = data.instanceMatrix;
				const instanceColor = data.instanceColor;

				object = new InstancedMesh(geometry, material, count);
				object.instanceMatrix = new InstancedBufferAttribute(new Float32Array(instanceMatrix.array), 16);
				if (instanceColor !== undefined)
					object.instanceColor = new InstancedBufferAttribute(new Float32Array(instanceColor.array), instanceColor.itemSize);

				break;

			case 'LOD':
				object = new LOD();

				break;

			case 'Line':
				object = new Line(getGeometry(data.geometry), getMaterial(data.material));

				break;

			case 'LineLoop':
				object = new LineLoop(getGeometry(data.geometry), getMaterial(data.material));

				break;

			case 'LineSegments':
				object = new LineSegments(getGeometry(data.geometry), getMaterial(data.material));

				break;

			case 'PointCloud':
			case 'Points':
				object = new Points(getGeometry(data.geometry), getMaterial(data.material));

				break;

			case 'Sprite':
				object = new Sprite(getMaterial(data.material));

				break;

			case 'Group':
				object = new Group();

				break;

			case 'Bone':
				object = new Bone();

				break;

			default:
				object = new Object3D();
		}

		object.uuid = data.uuid;

		if (data.name !== undefined) object.name = data.name;

		if (data.matrix !== undefined) {
			object.matrix.fromArray(data.matrix);

			if (data.matrixAutoUpdate !== undefined) object.matrixAutoUpdate = data.matrixAutoUpdate;
			if (object.matrixAutoUpdate) object.matrix.decompose(object.position, object.quaternion, object.scale);
		} else {
			if (data.position !== undefined) object.position.fromArray(data.position);
			if (data.rotation !== undefined) object.rotation.fromArray(data.rotation);
			if (data.quaternion !== undefined) object.quaternion.fromArray(data.quaternion);
			if (data.scale !== undefined) object.scale.fromArray(data.scale);
		}

		if (data.castShadow !== undefined) object.castShadow = data.castShadow;
		if (data.receiveShadow !== undefined) object.receiveShadow = data.receiveShadow;

		if (data.shadow) {
			if (data.shadow.bias !== undefined) object.shadow.bias = data.shadow.bias;
			if (data.shadow.normalBias !== undefined) object.shadow.normalBias = data.shadow.normalBias;
			if (data.shadow.radius !== undefined) object.shadow.radius = data.shadow.radius;
			if (data.shadow.mapSize !== undefined) object.shadow.mapSize.fromArray(data.shadow.mapSize);
			if (data.shadow.camera !== undefined) object.shadow.camera = this.parseObject(data.shadow.camera);
		}

		if (data.visible !== undefined) object.visible = data.visible;
		if (data.frustumCulled !== undefined) object.frustumCulled = data.frustumCulled;
		if (data.renderOrder !== undefined) object.renderOrder = data.renderOrder;
		if (data.userData !== undefined) object.userData = data.userData;
		if (data.layers !== undefined) object.layers.mask = data.layers;

		if (data.children !== undefined) {
			const children = data.children;

			for (let i = 0; i < children.length; i++) {
				object.add(this.parseObject(children[i], geometries, materials, textures, animations));
			}
		}

		if (data.animations !== undefined) {
			const objectAnimations = data.animations;

			for (let i = 0; i < objectAnimations.length; i++) {
				const uuid = objectAnimations[i];

				object.animations.push(animations[uuid]);
			}
		}

		if (data.type === 'LOD') {
			if (data.autoUpdate !== undefined) object.autoUpdate = data.autoUpdate;

			const levels = data.levels;

			for (let l = 0; l < levels.length; l++) {
				const level = levels[l];
				const child = object.getObjectByProperty('uuid', level.object);

				if (child !== undefined) {
					object.addLevel(child, level.distance);
				}
			}
		}

		return object;
	}

	bindSkeletons(object, skeletons) {
		if (Object.keys(skeletons).length === 0) return;

		object.traverse(function (child) {
			if (child.isSkinnedMesh === true && child.skeleton !== undefined) {
				const skeleton = skeletons[child.skeleton];

				if (skeleton === undefined) {
					console.warn('THREE.ObjectLoader: No skeleton found with UUID:', child.skeleton);
				} else {
					child.bind(skeleton, child.bindMatrix);
				}
			}
		});
	}

	/* DEPRECATED */

	setTexturePath(value) {
		console.warn('THREE.ObjectLoader: .setTexturePath() has been renamed to .setResourcePath().');
		return this.setResourcePath(value);
	}
}

const TEXTURE_MAPPING = {
	UVMapping: UVMapping,
	CubeReflectionMapping: CubeReflectionMapping,
	CubeRefractionMapping: CubeRefractionMapping,
	EquirectangularReflectionMapping: EquirectangularReflectionMapping,
	EquirectangularRefractionMapping: EquirectangularRefractionMapping,
	CubeUVReflectionMapping: CubeUVReflectionMapping,
	CubeUVRefractionMapping: CubeUVRefractionMapping,
};

const TEXTURE_WRAPPING = {
	RepeatWrapping: RepeatWrapping,
	ClampToEdgeWrapping: ClampToEdgeWrapping,
	MirroredRepeatWrapping: MirroredRepeatWrapping,
};

const TEXTURE_FILTER = {
	NearestFilter: NearestFilter,
	NearestMipmapNearestFilter: NearestMipmapNearestFilter,
	NearestMipmapLinearFilter: NearestMipmapLinearFilter,
	LinearFilter: LinearFilter,
	LinearMipmapNearestFilter: LinearMipmapNearestFilter,
	LinearMipmapLinearFilter: LinearMipmapLinearFilter,
};

export { ObjectLoader };