@openhps/core
Version:
Open Hybrid Positioning System - Core component
749 lines (730 loc) • 31.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ObjectLoader = void 0;
var _constants = require("../constants.js");
var _InstancedBufferAttribute = require("../core/InstancedBufferAttribute.js");
var _Color = require("../math/Color.js");
var _Object3D = require("../core/Object3D.js");
var _Group = require("../objects/Group.js");
var _InstancedMesh = require("../objects/InstancedMesh.js");
var _BatchedMesh = require("../objects/BatchedMesh.js");
var _Sprite = require("../objects/Sprite.js");
var _Points = require("../objects/Points.js");
var _Line = require("../objects/Line.js");
var _LineLoop = require("../objects/LineLoop.js");
var _LineSegments = require("../objects/LineSegments.js");
var _LOD = require("../objects/LOD.js");
var _Mesh = require("../objects/Mesh.js");
var _SkinnedMesh = require("../objects/SkinnedMesh.js");
var _Bone = require("../objects/Bone.js");
var _Skeleton = require("../objects/Skeleton.js");
var _Shape = require("../extras/core/Shape.js");
var _Fog = require("../scenes/Fog.js");
var _FogExp = require("../scenes/FogExp2.js");
var _HemisphereLight = require("../lights/HemisphereLight.js");
var _SpotLight = require("../lights/SpotLight.js");
var _PointLight = require("../lights/PointLight.js");
var _DirectionalLight = require("../lights/DirectionalLight.js");
var _AmbientLight = require("../lights/AmbientLight.js");
var _RectAreaLight = require("../lights/RectAreaLight.js");
var _LightProbe = require("../lights/LightProbe.js");
var _OrthographicCamera = require("../cameras/OrthographicCamera.js");
var _PerspectiveCamera = require("../cameras/PerspectiveCamera.js");
var _Scene = require("../scenes/Scene.js");
var _CubeTexture = require("../textures/CubeTexture.js");
var _Texture = require("../textures/Texture.js");
var _Source = require("../textures/Source.js");
var _DataTexture = require("../textures/DataTexture.js");
var _ImageLoader = require("./ImageLoader.js");
var _LoadingManager = require("./LoadingManager.js");
var _AnimationClip = require("../animation/AnimationClip.js");
var _MaterialLoader = require("./MaterialLoader.js");
var _LoaderUtils = require("./LoaderUtils.js");
var _BufferGeometryLoader = require("./BufferGeometryLoader.js");
var _Loader = require("./Loader.js");
var _FileLoader = require("./FileLoader.js");
var Geometries = _interopRequireWildcard(require("../geometries/Geometries.js"));
var _utils = require("../utils.js");
var _Box = require("../math/Box3.js");
var _Sphere = require("../math/Sphere.js");
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
/**
* A loader for loading a JSON resource in the [JSON Object/Scene format]{@link https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4}.
* The files are internally loaded via {@link FileLoader}.
*
* ```js
* const loader = new THREE.ObjectLoader();
* const obj = await loader.loadAsync( 'models/json/example.json' );
* scene.add( obj );
*
* // Alternatively, to parse a previously loaded JSON structure
* const object = await loader.parseAsync( a_json_object );
* scene.add( object );
* ```
*
* @augments Loader
*/
class ObjectLoader extends _Loader.Loader {
/**
* Constructs a new object loader.
*
* @param {LoadingManager} [manager] - The loading manager.
*/
constructor(manager) {
super(manager);
}
/**
* Starts loading from the given URL and pass the loaded 3D object to the `onLoad()` callback.
*
* @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
* @param {function(Object3D)} onLoad - Executed when the loading process has been finished.
* @param {onProgressCallback} onProgress - Executed while the loading is in progress.
* @param {onErrorCallback} onError - Executed when errors occur.
*/
load(url, onLoad, onProgress, onError) {
const scope = this;
const path = this.path === '' ? _LoaderUtils.LoaderUtils.extractUrlBase(url) : this.path;
this.resourcePath = this.resourcePath || path;
const loader = new _FileLoader.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') {
if (onError !== undefined) onError(new Error('THREE.ObjectLoader: Can\'t load ' + url));
console.error('THREE.ObjectLoader: Can\'t load ' + url);
return;
}
scope.parse(json, onLoad);
}, onProgress, onError);
}
/**
* Async version of {@link ObjectLoader#load}.
*
* @async
* @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
* @param {onProgressCallback} onProgress - Executed while the loading is in progress.
* @return {Promise<Object3D>} A Promise that resolves with the loaded 3D object.
*/
async loadAsync(url, onProgress) {
const scope = this;
const path = this.path === '' ? _LoaderUtils.LoaderUtils.extractUrlBase(url) : this.path;
this.resourcePath = this.resourcePath || path;
const loader = new _FileLoader.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);
}
/**
* Parses the given JSON. This is used internally by {@link ObjectLoader#load}
* but can also be used directly to parse a previously loaded JSON structure.
*
* @param {Object} json - The serialized 3D object.
* @param {onLoad} onLoad - Executed when all resources (e.g. textures) have been fully loaded.
* @return {Object3D} The parsed 3D object.
*/
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);
this.bindLightTargets(object);
//
if (onLoad !== undefined) {
let hasImages = false;
for (const uuid in images) {
if (images[uuid].data instanceof HTMLImageElement) {
hasImages = true;
break;
}
}
if (hasImages === false) onLoad(object);
}
return object;
}
/**
* Async version of {@link ObjectLoader#parse}.
*
* @param {Object} json - The serialized 3D object.
* @return {Promise<Object3D>} A Promise that resolves with the parsed 3D 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);
this.bindLightTargets(object);
return object;
}
// internals
parseShapes(json) {
const shapes = {};
if (json !== undefined) {
for (let i = 0, l = json.length; i < l; i++) {
const shape = new _Shape.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.Skeleton().fromJSON(json[i], bones);
skeletons[skeleton.uuid] = skeleton;
}
}
return skeletons;
}
parseGeometries(json, shapes) {
const geometries = {};
if (json !== undefined) {
const bufferGeometryLoader = new _BufferGeometryLoader.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;
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 (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.MaterialLoader();
loader.setTextures(textures);
for (let i = 0, l = json.length; i < l; i++) {
const data = json[i];
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.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: (0, _utils.getTypedArray)(image.type, image.data),
width: image.width,
height: image.height
};
} else {
return null;
}
}
}
if (json !== undefined && json.length > 0) {
const manager = new _LoadingManager.LoadingManager(onLoad);
loader = new _ImageLoader.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
const imageArray = [];
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) {
imageArray.push(deserializedImage);
} else {
// special case: handle array of data textures for cube textures
imageArray.push(new _DataTexture.DataTexture(deserializedImage.data, deserializedImage.width, deserializedImage.height));
}
}
}
images[image.uuid] = new _Source.Source(imageArray);
} else {
// load single image
const deserializedImage = deserializeImage(image.url);
images[image.uuid] = new _Source.Source(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: (0, _utils.getTypedArray)(image.type, image.data),
width: image.width,
height: image.height
};
} else {
return null;
}
}
}
if (json !== undefined && json.length > 0) {
loader = new _ImageLoader.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
const imageArray = [];
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) {
imageArray.push(deserializedImage);
} else {
// special case: handle array of data textures for cube textures
imageArray.push(new _DataTexture.DataTexture(deserializedImage.data, deserializedImage.width, deserializedImage.height));
}
}
}
images[image.uuid] = new _Source.Source(imageArray);
} else {
// load single image
const deserializedImage = await deserializeImage(image.url);
images[image.uuid] = new _Source.Source(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);
}
const source = images[data.image];
const image = source.data;
let texture;
if (Array.isArray(image)) {
texture = new _CubeTexture.CubeTexture();
if (image.length === 6) texture.needsUpdate = true;
} else {
if (image && image.data) {
texture = new _DataTexture.DataTexture();
} else {
texture = new _Texture.Texture();
}
if (image) texture.needsUpdate = true; // textures can have undefined image data
}
texture.source = source;
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.channel !== undefined) texture.channel = data.channel;
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.internalFormat !== undefined) texture.internalFormat = data.internalFormat;
if (data.type !== undefined) texture.type = data.type;
if (data.colorSpace !== undefined) texture.colorSpace = data.colorSpace;
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.generateMipmaps !== undefined) texture.generateMipmaps = data.generateMipmaps;
if (data.premultiplyAlpha !== undefined) texture.premultiplyAlpha = data.premultiplyAlpha;
if (data.unpackAlignment !== undefined) texture.unpackAlignment = data.unpackAlignment;
if (data.compareFunction !== undefined) texture.compareFunction = data.compareFunction;
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.Scene();
if (data.background !== undefined) {
if (Number.isInteger(data.background)) {
object.background = new _Color.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.Fog(data.fog.color, data.fog.near, data.fog.far);
} else if (data.fog.type === 'FogExp2') {
object.fog = new _FogExp.FogExp2(data.fog.color, data.fog.density);
}
if (data.fog.name !== '') {
object.fog.name = data.fog.name;
}
}
if (data.backgroundBlurriness !== undefined) object.backgroundBlurriness = data.backgroundBlurriness;
if (data.backgroundIntensity !== undefined) object.backgroundIntensity = data.backgroundIntensity;
if (data.backgroundRotation !== undefined) object.backgroundRotation.fromArray(data.backgroundRotation);
if (data.environmentIntensity !== undefined) object.environmentIntensity = data.environmentIntensity;
if (data.environmentRotation !== undefined) object.environmentRotation.fromArray(data.environmentRotation);
break;
case 'PerspectiveCamera':
object = new _PerspectiveCamera.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.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.AmbientLight(data.color, data.intensity);
break;
case 'DirectionalLight':
object = new _DirectionalLight.DirectionalLight(data.color, data.intensity);
object.target = data.target || '';
break;
case 'PointLight':
object = new _PointLight.PointLight(data.color, data.intensity, data.distance, data.decay);
break;
case 'RectAreaLight':
object = new _RectAreaLight.RectAreaLight(data.color, data.intensity, data.width, data.height);
break;
case 'SpotLight':
object = new _SpotLight.SpotLight(data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay);
object.target = data.target || '';
break;
case 'HemisphereLight':
object = new _HemisphereLight.HemisphereLight(data.color, data.groundColor, data.intensity);
break;
case 'LightProbe':
object = new _LightProbe.LightProbe().fromJSON(data);
break;
case 'SkinnedMesh':
geometry = getGeometry(data.geometry);
material = getMaterial(data.material);
object = new _SkinnedMesh.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.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.InstancedMesh(geometry, material, count);
object.instanceMatrix = new _InstancedBufferAttribute.InstancedBufferAttribute(new Float32Array(instanceMatrix.array), 16);
if (instanceColor !== undefined) object.instanceColor = new _InstancedBufferAttribute.InstancedBufferAttribute(new Float32Array(instanceColor.array), instanceColor.itemSize);
break;
case 'BatchedMesh':
geometry = getGeometry(data.geometry);
material = getMaterial(data.material);
object = new _BatchedMesh.BatchedMesh(data.maxInstanceCount, data.maxVertexCount, data.maxIndexCount, material);
object.geometry = geometry;
object.perObjectFrustumCulled = data.perObjectFrustumCulled;
object.sortObjects = data.sortObjects;
object._drawRanges = data.drawRanges;
object._reservedRanges = data.reservedRanges;
object._visibility = data.visibility;
object._active = data.active;
object._bounds = data.bounds.map(bound => {
const box = new _Box.Box3();
box.min.fromArray(bound.boxMin);
box.max.fromArray(bound.boxMax);
const sphere = new _Sphere.Sphere();
sphere.radius = bound.sphereRadius;
sphere.center.fromArray(bound.sphereCenter);
return {
boxInitialized: bound.boxInitialized,
box: box,
sphereInitialized: bound.sphereInitialized,
sphere: sphere
};
});
object._maxInstanceCount = data.maxInstanceCount;
object._maxVertexCount = data.maxVertexCount;
object._maxIndexCount = data.maxIndexCount;
object._geometryInitialized = data.geometryInitialized;
object._geometryCount = data.geometryCount;
object._matricesTexture = getTexture(data.matricesTexture.uuid);
if (data.colorsTexture !== undefined) object._colorsTexture = getTexture(data.colorsTexture.uuid);
break;
case 'LOD':
object = new _LOD.LOD();
break;
case 'Line':
object = new _Line.Line(getGeometry(data.geometry), getMaterial(data.material));
break;
case 'LineLoop':
object = new _LineLoop.LineLoop(getGeometry(data.geometry), getMaterial(data.material));
break;
case 'LineSegments':
object = new _LineSegments.LineSegments(getGeometry(data.geometry), getMaterial(data.material));
break;
case 'PointCloud':
case 'Points':
object = new _Points.Points(getGeometry(data.geometry), getMaterial(data.material));
break;
case 'Sprite':
object = new _Sprite.Sprite(getMaterial(data.material));
break;
case 'Group':
object = new _Group.Group();
break;
case 'Bone':
object = new _Bone.Bone();
break;
default:
object = new _Object3D.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.up !== undefined) object.up.fromArray(data.up);
if (data.castShadow !== undefined) object.castShadow = data.castShadow;
if (data.receiveShadow !== undefined) object.receiveShadow = data.receiveShadow;
if (data.shadow) {
if (data.shadow.intensity !== undefined) object.shadow.intensity = data.shadow.intensity;
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, level.hysteresis);
}
}
}
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);
}
}
});
}
bindLightTargets(object) {
object.traverse(function (child) {
if (child.isDirectionalLight || child.isSpotLight) {
const uuid = child.target;
const target = object.getObjectByProperty('uuid', uuid);
if (target !== undefined) {
child.target = target;
} else {
child.target = new _Object3D.Object3D();
}
}
});
}
}
exports.ObjectLoader = ObjectLoader;
const TEXTURE_MAPPING = {
UVMapping: _constants.UVMapping,
CubeReflectionMapping: _constants.CubeReflectionMapping,
CubeRefractionMapping: _constants.CubeRefractionMapping,
EquirectangularReflectionMapping: _constants.EquirectangularReflectionMapping,
EquirectangularRefractionMapping: _constants.EquirectangularRefractionMapping,
CubeUVReflectionMapping: _constants.CubeUVReflectionMapping
};
const TEXTURE_WRAPPING = {
RepeatWrapping: _constants.RepeatWrapping,
ClampToEdgeWrapping: _constants.ClampToEdgeWrapping,
MirroredRepeatWrapping: _constants.MirroredRepeatWrapping
};
const TEXTURE_FILTER = {
NearestFilter: _constants.NearestFilter,
NearestMipmapNearestFilter: _constants.NearestMipmapNearestFilter,
NearestMipmapLinearFilter: _constants.NearestMipmapLinearFilter,
LinearFilter: _constants.LinearFilter,
LinearMipmapNearestFilter: _constants.LinearMipmapNearestFilter,
LinearMipmapLinearFilter: _constants.LinearMipmapLinearFilter
};