three-stdlib
Version:
stand-alone library of threejs examples
1,284 lines • 91.1 kB
JavaScript
"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const THREE = require("three");
const fflate = require("fflate");
const NURBSCurve = require("../curves/NURBSCurve.cjs");
const LoaderUtils = require("../_polyfill/LoaderUtils.cjs");
const uv1 = require("../_polyfill/uv1.cjs");
let fbxTree;
let connections;
let sceneGraph;
class FBXLoader extends THREE.Loader {
constructor(manager) {
super(manager);
}
load(url, onLoad, onProgress, onError) {
const scope = this;
const path = scope.path === "" ? THREE.LoaderUtils.extractUrlBase(url) : scope.path;
const loader = new THREE.FileLoader(this.manager);
loader.setPath(scope.path);
loader.setResponseType("arraybuffer");
loader.setRequestHeader(scope.requestHeader);
loader.setWithCredentials(scope.withCredentials);
loader.load(
url,
function(buffer) {
try {
onLoad(scope.parse(buffer, path));
} catch (e) {
if (onError) {
onError(e);
} else {
console.error(e);
}
scope.manager.itemError(url);
}
},
onProgress,
onError
);
}
parse(FBXBuffer, path) {
if (isFbxFormatBinary(FBXBuffer)) {
fbxTree = new BinaryParser().parse(FBXBuffer);
} else {
const FBXText = convertArrayBufferToString(FBXBuffer);
if (!isFbxFormatASCII(FBXText)) {
throw new Error("THREE.FBXLoader: Unknown format.");
}
if (getFbxVersion(FBXText) < 7e3) {
throw new Error("THREE.FBXLoader: FBX version not supported, FileVersion: " + getFbxVersion(FBXText));
}
fbxTree = new TextParser().parse(FBXText);
}
const textureLoader = new THREE.TextureLoader(this.manager).setPath(this.resourcePath || path).setCrossOrigin(this.crossOrigin);
return new FBXTreeParser(textureLoader, this.manager).parse(fbxTree);
}
}
class FBXTreeParser {
constructor(textureLoader, manager) {
this.textureLoader = textureLoader;
this.manager = manager;
}
parse() {
connections = this.parseConnections();
const images = this.parseImages();
const textures = this.parseTextures(images);
const materials = this.parseMaterials(textures);
const deformers = this.parseDeformers();
const geometryMap = new GeometryParser().parse(deformers);
this.parseScene(deformers, geometryMap, materials);
return sceneGraph;
}
// Parses FBXTree.Connections which holds parent-child connections between objects (e.g. material -> texture, model->geometry )
// and details the connection type
parseConnections() {
const connectionMap = /* @__PURE__ */ new Map();
if ("Connections" in fbxTree) {
const rawConnections = fbxTree.Connections.connections;
rawConnections.forEach(function(rawConnection) {
const fromID = rawConnection[0];
const toID = rawConnection[1];
const relationship = rawConnection[2];
if (!connectionMap.has(fromID)) {
connectionMap.set(fromID, {
parents: [],
children: []
});
}
const parentRelationship = { ID: toID, relationship };
connectionMap.get(fromID).parents.push(parentRelationship);
if (!connectionMap.has(toID)) {
connectionMap.set(toID, {
parents: [],
children: []
});
}
const childRelationship = { ID: fromID, relationship };
connectionMap.get(toID).children.push(childRelationship);
});
}
return connectionMap;
}
// Parse FBXTree.Objects.Video for embedded image data
// These images are connected to textures in FBXTree.Objects.Textures
// via FBXTree.Connections.
parseImages() {
const images = {};
const blobs = {};
if ("Video" in fbxTree.Objects) {
const videoNodes = fbxTree.Objects.Video;
for (const nodeID in videoNodes) {
const videoNode = videoNodes[nodeID];
const id = parseInt(nodeID);
images[id] = videoNode.RelativeFilename || videoNode.Filename;
if ("Content" in videoNode) {
const arrayBufferContent = videoNode.Content instanceof ArrayBuffer && videoNode.Content.byteLength > 0;
const base64Content = typeof videoNode.Content === "string" && videoNode.Content !== "";
if (arrayBufferContent || base64Content) {
const image = this.parseImage(videoNodes[nodeID]);
blobs[videoNode.RelativeFilename || videoNode.Filename] = image;
}
}
}
}
for (const id in images) {
const filename = images[id];
if (blobs[filename] !== void 0)
images[id] = blobs[filename];
else
images[id] = images[id].split("\\").pop();
}
return images;
}
// Parse embedded image data in FBXTree.Video.Content
parseImage(videoNode) {
const content = videoNode.Content;
const fileName = videoNode.RelativeFilename || videoNode.Filename;
const extension = fileName.slice(fileName.lastIndexOf(".") + 1).toLowerCase();
let type;
switch (extension) {
case "bmp":
type = "image/bmp";
break;
case "jpg":
case "jpeg":
type = "image/jpeg";
break;
case "png":
type = "image/png";
break;
case "tif":
type = "image/tiff";
break;
case "tga":
if (this.manager.getHandler(".tga") === null) {
console.warn("FBXLoader: TGA loader not found, skipping ", fileName);
}
type = "image/tga";
break;
default:
console.warn('FBXLoader: Image type "' + extension + '" is not supported.');
return;
}
if (typeof content === "string") {
return "data:" + type + ";base64," + content;
} else {
const array = new Uint8Array(content);
return window.URL.createObjectURL(new Blob([array], { type }));
}
}
// Parse nodes in FBXTree.Objects.Texture
// These contain details such as UV scaling, cropping, rotation etc and are connected
// to images in FBXTree.Objects.Video
parseTextures(images) {
const textureMap = /* @__PURE__ */ new Map();
if ("Texture" in fbxTree.Objects) {
const textureNodes = fbxTree.Objects.Texture;
for (const nodeID in textureNodes) {
const texture = this.parseTexture(textureNodes[nodeID], images);
textureMap.set(parseInt(nodeID), texture);
}
}
return textureMap;
}
// Parse individual node in FBXTree.Objects.Texture
parseTexture(textureNode, images) {
const texture = this.loadTexture(textureNode, images);
texture.ID = textureNode.id;
texture.name = textureNode.attrName;
const wrapModeU = textureNode.WrapModeU;
const wrapModeV = textureNode.WrapModeV;
const valueU = wrapModeU !== void 0 ? wrapModeU.value : 0;
const valueV = wrapModeV !== void 0 ? wrapModeV.value : 0;
texture.wrapS = valueU === 0 ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
texture.wrapT = valueV === 0 ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
if ("Scaling" in textureNode) {
const values = textureNode.Scaling.value;
texture.repeat.x = values[0];
texture.repeat.y = values[1];
}
return texture;
}
// load a texture specified as a blob or data URI, or via an external URL using TextureLoader
loadTexture(textureNode, images) {
let fileName;
const currentPath = this.textureLoader.path;
const children = connections.get(textureNode.id).children;
if (children !== void 0 && children.length > 0 && images[children[0].ID] !== void 0) {
fileName = images[children[0].ID];
if (fileName.indexOf("blob:") === 0 || fileName.indexOf("data:") === 0) {
this.textureLoader.setPath(void 0);
}
}
let texture;
const extension = textureNode.FileName.slice(-3).toLowerCase();
if (extension === "tga") {
const loader = this.manager.getHandler(".tga");
if (loader === null) {
console.warn("FBXLoader: TGA loader not found, creating placeholder texture for", textureNode.RelativeFilename);
texture = new THREE.Texture();
} else {
loader.setPath(this.textureLoader.path);
texture = loader.load(fileName);
}
} else if (extension === "psd") {
console.warn(
"FBXLoader: PSD textures are not supported, creating placeholder texture for",
textureNode.RelativeFilename
);
texture = new THREE.Texture();
} else {
texture = this.textureLoader.load(fileName);
}
this.textureLoader.setPath(currentPath);
return texture;
}
// Parse nodes in FBXTree.Objects.Material
parseMaterials(textureMap) {
const materialMap = /* @__PURE__ */ new Map();
if ("Material" in fbxTree.Objects) {
const materialNodes = fbxTree.Objects.Material;
for (const nodeID in materialNodes) {
const material = this.parseMaterial(materialNodes[nodeID], textureMap);
if (material !== null)
materialMap.set(parseInt(nodeID), material);
}
}
return materialMap;
}
// Parse single node in FBXTree.Objects.Material
// Materials are connected to texture maps in FBXTree.Objects.Textures
// FBX format currently only supports Lambert and Phong shading models
parseMaterial(materialNode, textureMap) {
const ID = materialNode.id;
const name = materialNode.attrName;
let type = materialNode.ShadingModel;
if (typeof type === "object") {
type = type.value;
}
if (!connections.has(ID))
return null;
const parameters = this.parseParameters(materialNode, textureMap, ID);
let material;
switch (type.toLowerCase()) {
case "phong":
material = new THREE.MeshPhongMaterial();
break;
case "lambert":
material = new THREE.MeshLambertMaterial();
break;
default:
console.warn('THREE.FBXLoader: unknown material type "%s". Defaulting to MeshPhongMaterial.', type);
material = new THREE.MeshPhongMaterial();
break;
}
material.setValues(parameters);
material.name = name;
return material;
}
// Parse FBX material and return parameters suitable for a three.js material
// Also parse the texture map and return any textures associated with the material
parseParameters(materialNode, textureMap, ID) {
const parameters = {};
if (materialNode.BumpFactor) {
parameters.bumpScale = materialNode.BumpFactor.value;
}
if (materialNode.Diffuse) {
parameters.color = new THREE.Color().fromArray(materialNode.Diffuse.value);
} else if (materialNode.DiffuseColor && (materialNode.DiffuseColor.type === "Color" || materialNode.DiffuseColor.type === "ColorRGB")) {
parameters.color = new THREE.Color().fromArray(materialNode.DiffuseColor.value);
}
if (materialNode.DisplacementFactor) {
parameters.displacementScale = materialNode.DisplacementFactor.value;
}
if (materialNode.Emissive) {
parameters.emissive = new THREE.Color().fromArray(materialNode.Emissive.value);
} else if (materialNode.EmissiveColor && (materialNode.EmissiveColor.type === "Color" || materialNode.EmissiveColor.type === "ColorRGB")) {
parameters.emissive = new THREE.Color().fromArray(materialNode.EmissiveColor.value);
}
if (materialNode.EmissiveFactor) {
parameters.emissiveIntensity = parseFloat(materialNode.EmissiveFactor.value);
}
if (materialNode.Opacity) {
parameters.opacity = parseFloat(materialNode.Opacity.value);
}
if (parameters.opacity < 1) {
parameters.transparent = true;
}
if (materialNode.ReflectionFactor) {
parameters.reflectivity = materialNode.ReflectionFactor.value;
}
if (materialNode.Shininess) {
parameters.shininess = materialNode.Shininess.value;
}
if (materialNode.Specular) {
parameters.specular = new THREE.Color().fromArray(materialNode.Specular.value);
} else if (materialNode.SpecularColor && materialNode.SpecularColor.type === "Color") {
parameters.specular = new THREE.Color().fromArray(materialNode.SpecularColor.value);
}
const scope = this;
connections.get(ID).children.forEach(function(child) {
const type = child.relationship;
switch (type) {
case "Bump":
parameters.bumpMap = scope.getTexture(textureMap, child.ID);
break;
case "Maya|TEX_ao_map":
parameters.aoMap = scope.getTexture(textureMap, child.ID);
break;
case "DiffuseColor":
case "Maya|TEX_color_map":
parameters.map = scope.getTexture(textureMap, child.ID);
if (parameters.map !== void 0) {
if ("colorSpace" in parameters.map)
parameters.map.colorSpace = "srgb";
else
parameters.map.encoding = 3001;
}
break;
case "DisplacementColor":
parameters.displacementMap = scope.getTexture(textureMap, child.ID);
break;
case "EmissiveColor":
parameters.emissiveMap = scope.getTexture(textureMap, child.ID);
if (parameters.emissiveMap !== void 0) {
if ("colorSpace" in parameters.emissiveMap)
parameters.emissiveMap.colorSpace = "srgb";
else
parameters.emissiveMap.encoding = 3001;
}
break;
case "NormalMap":
case "Maya|TEX_normal_map":
parameters.normalMap = scope.getTexture(textureMap, child.ID);
break;
case "ReflectionColor":
parameters.envMap = scope.getTexture(textureMap, child.ID);
if (parameters.envMap !== void 0) {
parameters.envMap.mapping = THREE.EquirectangularReflectionMapping;
if ("colorSpace" in parameters.envMap)
parameters.envMap.colorSpace = "srgb";
else
parameters.envMap.encoding = 3001;
}
break;
case "SpecularColor":
parameters.specularMap = scope.getTexture(textureMap, child.ID);
if (parameters.specularMap !== void 0) {
if ("colorSpace" in parameters.specularMap)
parameters.specularMap.colorSpace = "srgb";
else
parameters.specularMap.encoding = 3001;
}
break;
case "TransparentColor":
case "TransparencyFactor":
parameters.alphaMap = scope.getTexture(textureMap, child.ID);
parameters.transparent = true;
break;
case "AmbientColor":
case "ShininessExponent":
case "SpecularFactor":
case "VectorDisplacementColor":
default:
console.warn("THREE.FBXLoader: %s map is not supported in three.js, skipping texture.", type);
break;
}
});
return parameters;
}
// get a texture from the textureMap for use by a material.
getTexture(textureMap, id) {
if ("LayeredTexture" in fbxTree.Objects && id in fbxTree.Objects.LayeredTexture) {
console.warn("THREE.FBXLoader: layered textures are not supported in three.js. Discarding all but first layer.");
id = connections.get(id).children[0].ID;
}
return textureMap.get(id);
}
// Parse nodes in FBXTree.Objects.Deformer
// Deformer node can contain skinning or Vertex Cache animation data, however only skinning is supported here
// Generates map of Skeleton-like objects for use later when generating and binding skeletons.
parseDeformers() {
const skeletons = {};
const morphTargets = {};
if ("Deformer" in fbxTree.Objects) {
const DeformerNodes = fbxTree.Objects.Deformer;
for (const nodeID in DeformerNodes) {
const deformerNode = DeformerNodes[nodeID];
const relationships = connections.get(parseInt(nodeID));
if (deformerNode.attrType === "Skin") {
const skeleton = this.parseSkeleton(relationships, DeformerNodes);
skeleton.ID = nodeID;
if (relationships.parents.length > 1) {
console.warn("THREE.FBXLoader: skeleton attached to more than one geometry is not supported.");
}
skeleton.geometryID = relationships.parents[0].ID;
skeletons[nodeID] = skeleton;
} else if (deformerNode.attrType === "BlendShape") {
const morphTarget = {
id: nodeID
};
morphTarget.rawTargets = this.parseMorphTargets(relationships, DeformerNodes);
morphTarget.id = nodeID;
if (relationships.parents.length > 1) {
console.warn("THREE.FBXLoader: morph target attached to more than one geometry is not supported.");
}
morphTargets[nodeID] = morphTarget;
}
}
}
return {
skeletons,
morphTargets
};
}
// Parse single nodes in FBXTree.Objects.Deformer
// The top level skeleton node has type 'Skin' and sub nodes have type 'Cluster'
// Each skin node represents a skeleton and each cluster node represents a bone
parseSkeleton(relationships, deformerNodes) {
const rawBones = [];
relationships.children.forEach(function(child) {
const boneNode = deformerNodes[child.ID];
if (boneNode.attrType !== "Cluster")
return;
const rawBone = {
ID: child.ID,
indices: [],
weights: [],
transformLink: new THREE.Matrix4().fromArray(boneNode.TransformLink.a)
// transform: new Matrix4().fromArray( boneNode.Transform.a ),
// linkMode: boneNode.Mode,
};
if ("Indexes" in boneNode) {
rawBone.indices = boneNode.Indexes.a;
rawBone.weights = boneNode.Weights.a;
}
rawBones.push(rawBone);
});
return {
rawBones,
bones: []
};
}
// The top level morph deformer node has type "BlendShape" and sub nodes have type "BlendShapeChannel"
parseMorphTargets(relationships, deformerNodes) {
const rawMorphTargets = [];
for (let i = 0; i < relationships.children.length; i++) {
const child = relationships.children[i];
const morphTargetNode = deformerNodes[child.ID];
const rawMorphTarget = {
name: morphTargetNode.attrName,
initialWeight: morphTargetNode.DeformPercent,
id: morphTargetNode.id,
fullWeights: morphTargetNode.FullWeights.a
};
if (morphTargetNode.attrType !== "BlendShapeChannel")
return;
rawMorphTarget.geoID = connections.get(parseInt(child.ID)).children.filter(function(child2) {
return child2.relationship === void 0;
})[0].ID;
rawMorphTargets.push(rawMorphTarget);
}
return rawMorphTargets;
}
// create the main Group() to be returned by the loader
parseScene(deformers, geometryMap, materialMap) {
sceneGraph = new THREE.Group();
const modelMap = this.parseModels(deformers.skeletons, geometryMap, materialMap);
const modelNodes = fbxTree.Objects.Model;
const scope = this;
modelMap.forEach(function(model) {
const modelNode = modelNodes[model.ID];
scope.setLookAtProperties(model, modelNode);
const parentConnections = connections.get(model.ID).parents;
parentConnections.forEach(function(connection) {
const parent = modelMap.get(connection.ID);
if (parent !== void 0)
parent.add(model);
});
if (model.parent === null) {
sceneGraph.add(model);
}
});
this.bindSkeleton(deformers.skeletons, geometryMap, modelMap);
this.createAmbientLight();
sceneGraph.traverse(function(node) {
if (node.userData.transformData) {
if (node.parent) {
node.userData.transformData.parentMatrix = node.parent.matrix;
node.userData.transformData.parentMatrixWorld = node.parent.matrixWorld;
}
const transform = generateTransform(node.userData.transformData);
node.applyMatrix4(transform);
node.updateWorldMatrix();
}
});
const animations = new AnimationParser().parse();
if (sceneGraph.children.length === 1 && sceneGraph.children[0].isGroup) {
sceneGraph.children[0].animations = animations;
sceneGraph = sceneGraph.children[0];
}
sceneGraph.animations = animations;
}
// parse nodes in FBXTree.Objects.Model
parseModels(skeletons, geometryMap, materialMap) {
const modelMap = /* @__PURE__ */ new Map();
const modelNodes = fbxTree.Objects.Model;
for (const nodeID in modelNodes) {
const id = parseInt(nodeID);
const node = modelNodes[nodeID];
const relationships = connections.get(id);
let model = this.buildSkeleton(relationships, skeletons, id, node.attrName);
if (!model) {
switch (node.attrType) {
case "Camera":
model = this.createCamera(relationships);
break;
case "Light":
model = this.createLight(relationships);
break;
case "Mesh":
model = this.createMesh(relationships, geometryMap, materialMap);
break;
case "NurbsCurve":
model = this.createCurve(relationships, geometryMap);
break;
case "LimbNode":
case "Root":
model = new THREE.Bone();
break;
case "Null":
default:
model = new THREE.Group();
break;
}
model.name = node.attrName ? THREE.PropertyBinding.sanitizeNodeName(node.attrName) : "";
model.ID = id;
}
this.getTransformData(model, node);
modelMap.set(id, model);
}
return modelMap;
}
buildSkeleton(relationships, skeletons, id, name) {
let bone = null;
relationships.parents.forEach(function(parent) {
for (const ID in skeletons) {
const skeleton = skeletons[ID];
skeleton.rawBones.forEach(function(rawBone, i) {
if (rawBone.ID === parent.ID) {
const subBone = bone;
bone = new THREE.Bone();
bone.matrixWorld.copy(rawBone.transformLink);
bone.name = name ? THREE.PropertyBinding.sanitizeNodeName(name) : "";
bone.ID = id;
skeleton.bones[i] = bone;
if (subBone !== null) {
bone.add(subBone);
}
}
});
}
});
return bone;
}
// create a PerspectiveCamera or OrthographicCamera
createCamera(relationships) {
let model;
let cameraAttribute;
relationships.children.forEach(function(child) {
const attr = fbxTree.Objects.NodeAttribute[child.ID];
if (attr !== void 0) {
cameraAttribute = attr;
}
});
if (cameraAttribute === void 0) {
model = new THREE.Object3D();
} else {
let type = 0;
if (cameraAttribute.CameraProjectionType !== void 0 && cameraAttribute.CameraProjectionType.value === 1) {
type = 1;
}
let nearClippingPlane = 1;
if (cameraAttribute.NearPlane !== void 0) {
nearClippingPlane = cameraAttribute.NearPlane.value / 1e3;
}
let farClippingPlane = 1e3;
if (cameraAttribute.FarPlane !== void 0) {
farClippingPlane = cameraAttribute.FarPlane.value / 1e3;
}
let width = window.innerWidth;
let height = window.innerHeight;
if (cameraAttribute.AspectWidth !== void 0 && cameraAttribute.AspectHeight !== void 0) {
width = cameraAttribute.AspectWidth.value;
height = cameraAttribute.AspectHeight.value;
}
const aspect = width / height;
let fov = 45;
if (cameraAttribute.FieldOfView !== void 0) {
fov = cameraAttribute.FieldOfView.value;
}
const focalLength = cameraAttribute.FocalLength ? cameraAttribute.FocalLength.value : null;
switch (type) {
case 0:
model = new THREE.PerspectiveCamera(fov, aspect, nearClippingPlane, farClippingPlane);
if (focalLength !== null)
model.setFocalLength(focalLength);
break;
case 1:
model = new THREE.OrthographicCamera(
-width / 2,
width / 2,
height / 2,
-height / 2,
nearClippingPlane,
farClippingPlane
);
break;
default:
console.warn("THREE.FBXLoader: Unknown camera type " + type + ".");
model = new THREE.Object3D();
break;
}
}
return model;
}
// Create a DirectionalLight, PointLight or SpotLight
createLight(relationships) {
let model;
let lightAttribute;
relationships.children.forEach(function(child) {
const attr = fbxTree.Objects.NodeAttribute[child.ID];
if (attr !== void 0) {
lightAttribute = attr;
}
});
if (lightAttribute === void 0) {
model = new THREE.Object3D();
} else {
let type;
if (lightAttribute.LightType === void 0) {
type = 0;
} else {
type = lightAttribute.LightType.value;
}
let color = 16777215;
if (lightAttribute.Color !== void 0) {
color = new THREE.Color().fromArray(lightAttribute.Color.value);
}
let intensity = lightAttribute.Intensity === void 0 ? 1 : lightAttribute.Intensity.value / 100;
if (lightAttribute.CastLightOnObject !== void 0 && lightAttribute.CastLightOnObject.value === 0) {
intensity = 0;
}
let distance = 0;
if (lightAttribute.FarAttenuationEnd !== void 0) {
if (lightAttribute.EnableFarAttenuation !== void 0 && lightAttribute.EnableFarAttenuation.value === 0) {
distance = 0;
} else {
distance = lightAttribute.FarAttenuationEnd.value;
}
}
const decay = 1;
switch (type) {
case 0:
model = new THREE.PointLight(color, intensity, distance, decay);
break;
case 1:
model = new THREE.DirectionalLight(color, intensity);
break;
case 2:
let angle = Math.PI / 3;
if (lightAttribute.InnerAngle !== void 0) {
angle = THREE.MathUtils.degToRad(lightAttribute.InnerAngle.value);
}
let penumbra = 0;
if (lightAttribute.OuterAngle !== void 0) {
penumbra = THREE.MathUtils.degToRad(lightAttribute.OuterAngle.value);
penumbra = Math.max(penumbra, 1);
}
model = new THREE.SpotLight(color, intensity, distance, angle, penumbra, decay);
break;
default:
console.warn(
"THREE.FBXLoader: Unknown light type " + lightAttribute.LightType.value + ", defaulting to a PointLight."
);
model = new THREE.PointLight(color, intensity);
break;
}
if (lightAttribute.CastShadows !== void 0 && lightAttribute.CastShadows.value === 1) {
model.castShadow = true;
}
}
return model;
}
createMesh(relationships, geometryMap, materialMap) {
let model;
let geometry = null;
let material = null;
const materials = [];
relationships.children.forEach(function(child) {
if (geometryMap.has(child.ID)) {
geometry = geometryMap.get(child.ID);
}
if (materialMap.has(child.ID)) {
materials.push(materialMap.get(child.ID));
}
});
if (materials.length > 1) {
material = materials;
} else if (materials.length > 0) {
material = materials[0];
} else {
material = new THREE.MeshPhongMaterial({ color: 13421772 });
materials.push(material);
}
if ("color" in geometry.attributes) {
materials.forEach(function(material2) {
material2.vertexColors = true;
});
}
if (geometry.FBX_Deformer) {
model = new THREE.SkinnedMesh(geometry, material);
model.normalizeSkinWeights();
} else {
model = new THREE.Mesh(geometry, material);
}
return model;
}
createCurve(relationships, geometryMap) {
const geometry = relationships.children.reduce(function(geo, child) {
if (geometryMap.has(child.ID))
geo = geometryMap.get(child.ID);
return geo;
}, null);
const material = new THREE.LineBasicMaterial({ color: 3342591, linewidth: 1 });
return new THREE.Line(geometry, material);
}
// parse the model node for transform data
getTransformData(model, modelNode) {
const transformData = {};
if ("InheritType" in modelNode)
transformData.inheritType = parseInt(modelNode.InheritType.value);
if ("RotationOrder" in modelNode)
transformData.eulerOrder = getEulerOrder(modelNode.RotationOrder.value);
else
transformData.eulerOrder = "ZYX";
if ("Lcl_Translation" in modelNode)
transformData.translation = modelNode.Lcl_Translation.value;
if ("PreRotation" in modelNode)
transformData.preRotation = modelNode.PreRotation.value;
if ("Lcl_Rotation" in modelNode)
transformData.rotation = modelNode.Lcl_Rotation.value;
if ("PostRotation" in modelNode)
transformData.postRotation = modelNode.PostRotation.value;
if ("Lcl_Scaling" in modelNode)
transformData.scale = modelNode.Lcl_Scaling.value;
if ("ScalingOffset" in modelNode)
transformData.scalingOffset = modelNode.ScalingOffset.value;
if ("ScalingPivot" in modelNode)
transformData.scalingPivot = modelNode.ScalingPivot.value;
if ("RotationOffset" in modelNode)
transformData.rotationOffset = modelNode.RotationOffset.value;
if ("RotationPivot" in modelNode)
transformData.rotationPivot = modelNode.RotationPivot.value;
model.userData.transformData = transformData;
}
setLookAtProperties(model, modelNode) {
if ("LookAtProperty" in modelNode) {
const children = connections.get(model.ID).children;
children.forEach(function(child) {
if (child.relationship === "LookAtProperty") {
const lookAtTarget = fbxTree.Objects.Model[child.ID];
if ("Lcl_Translation" in lookAtTarget) {
const pos = lookAtTarget.Lcl_Translation.value;
if (model.target !== void 0) {
model.target.position.fromArray(pos);
sceneGraph.add(model.target);
} else {
model.lookAt(new THREE.Vector3().fromArray(pos));
}
}
}
});
}
}
bindSkeleton(skeletons, geometryMap, modelMap) {
const bindMatrices = this.parsePoseNodes();
for (const ID in skeletons) {
const skeleton = skeletons[ID];
const parents = connections.get(parseInt(skeleton.ID)).parents;
parents.forEach(function(parent) {
if (geometryMap.has(parent.ID)) {
const geoID = parent.ID;
const geoRelationships = connections.get(geoID);
geoRelationships.parents.forEach(function(geoConnParent) {
if (modelMap.has(geoConnParent.ID)) {
const model = modelMap.get(geoConnParent.ID);
model.bind(new THREE.Skeleton(skeleton.bones), bindMatrices[geoConnParent.ID]);
}
});
}
});
}
}
parsePoseNodes() {
const bindMatrices = {};
if ("Pose" in fbxTree.Objects) {
const BindPoseNode = fbxTree.Objects.Pose;
for (const nodeID in BindPoseNode) {
if (BindPoseNode[nodeID].attrType === "BindPose" && BindPoseNode[nodeID].NbPoseNodes > 0) {
const poseNodes = BindPoseNode[nodeID].PoseNode;
if (Array.isArray(poseNodes)) {
poseNodes.forEach(function(poseNode) {
bindMatrices[poseNode.Node] = new THREE.Matrix4().fromArray(poseNode.Matrix.a);
});
} else {
bindMatrices[poseNodes.Node] = new THREE.Matrix4().fromArray(poseNodes.Matrix.a);
}
}
}
}
return bindMatrices;
}
// Parse ambient color in FBXTree.GlobalSettings - if it's not set to black (default), create an ambient light
createAmbientLight() {
if ("GlobalSettings" in fbxTree && "AmbientColor" in fbxTree.GlobalSettings) {
const ambientColor = fbxTree.GlobalSettings.AmbientColor.value;
const r = ambientColor[0];
const g = ambientColor[1];
const b = ambientColor[2];
if (r !== 0 || g !== 0 || b !== 0) {
const color = new THREE.Color(r, g, b);
sceneGraph.add(new THREE.AmbientLight(color, 1));
}
}
}
}
class GeometryParser {
// Parse nodes in FBXTree.Objects.Geometry
parse(deformers) {
const geometryMap = /* @__PURE__ */ new Map();
if ("Geometry" in fbxTree.Objects) {
const geoNodes = fbxTree.Objects.Geometry;
for (const nodeID in geoNodes) {
const relationships = connections.get(parseInt(nodeID));
const geo = this.parseGeometry(relationships, geoNodes[nodeID], deformers);
geometryMap.set(parseInt(nodeID), geo);
}
}
return geometryMap;
}
// Parse single node in FBXTree.Objects.Geometry
parseGeometry(relationships, geoNode, deformers) {
switch (geoNode.attrType) {
case "Mesh":
return this.parseMeshGeometry(relationships, geoNode, deformers);
case "NurbsCurve":
return this.parseNurbsGeometry(geoNode);
}
}
// Parse single node mesh geometry in FBXTree.Objects.Geometry
parseMeshGeometry(relationships, geoNode, deformers) {
const skeletons = deformers.skeletons;
const morphTargets = [];
const modelNodes = relationships.parents.map(function(parent) {
return fbxTree.Objects.Model[parent.ID];
});
if (modelNodes.length === 0)
return;
const skeleton = relationships.children.reduce(function(skeleton2, child) {
if (skeletons[child.ID] !== void 0)
skeleton2 = skeletons[child.ID];
return skeleton2;
}, null);
relationships.children.forEach(function(child) {
if (deformers.morphTargets[child.ID] !== void 0) {
morphTargets.push(deformers.morphTargets[child.ID]);
}
});
const modelNode = modelNodes[0];
const transformData = {};
if ("RotationOrder" in modelNode)
transformData.eulerOrder = getEulerOrder(modelNode.RotationOrder.value);
if ("InheritType" in modelNode)
transformData.inheritType = parseInt(modelNode.InheritType.value);
if ("GeometricTranslation" in modelNode)
transformData.translation = modelNode.GeometricTranslation.value;
if ("GeometricRotation" in modelNode)
transformData.rotation = modelNode.GeometricRotation.value;
if ("GeometricScaling" in modelNode)
transformData.scale = modelNode.GeometricScaling.value;
const transform = generateTransform(transformData);
return this.genGeometry(geoNode, skeleton, morphTargets, transform);
}
// Generate a BufferGeometry from a node in FBXTree.Objects.Geometry
genGeometry(geoNode, skeleton, morphTargets, preTransform) {
const geo = new THREE.BufferGeometry();
if (geoNode.attrName)
geo.name = geoNode.attrName;
const geoInfo = this.parseGeoNode(geoNode, skeleton);
const buffers = this.genBuffers(geoInfo);
const positionAttribute = new THREE.Float32BufferAttribute(buffers.vertex, 3);
positionAttribute.applyMatrix4(preTransform);
geo.setAttribute("position", positionAttribute);
if (buffers.colors.length > 0) {
geo.setAttribute("color", new THREE.Float32BufferAttribute(buffers.colors, 3));
}
if (skeleton) {
geo.setAttribute("skinIndex", new THREE.Uint16BufferAttribute(buffers.weightsIndices, 4));
geo.setAttribute("skinWeight", new THREE.Float32BufferAttribute(buffers.vertexWeights, 4));
geo.FBX_Deformer = skeleton;
}
if (buffers.normal.length > 0) {
const normalMatrix = new THREE.Matrix3().getNormalMatrix(preTransform);
const normalAttribute = new THREE.Float32BufferAttribute(buffers.normal, 3);
normalAttribute.applyNormalMatrix(normalMatrix);
geo.setAttribute("normal", normalAttribute);
}
buffers.uvs.forEach(function(uvBuffer, i) {
if (uv1.UV1 === "uv2")
i++;
const name = i === 0 ? "uv" : `uv${i}`;
geo.setAttribute(name, new THREE.Float32BufferAttribute(buffers.uvs[i], 2));
});
if (geoInfo.material && geoInfo.material.mappingType !== "AllSame") {
let prevMaterialIndex = buffers.materialIndex[0];
let startIndex = 0;
buffers.materialIndex.forEach(function(currentIndex, i) {
if (currentIndex !== prevMaterialIndex) {
geo.addGroup(startIndex, i - startIndex, prevMaterialIndex);
prevMaterialIndex = currentIndex;
startIndex = i;
}
});
if (geo.groups.length > 0) {
const lastGroup = geo.groups[geo.groups.length - 1];
const lastIndex = lastGroup.start + lastGroup.count;
if (lastIndex !== buffers.materialIndex.length) {
geo.addGroup(lastIndex, buffers.materialIndex.length - lastIndex, prevMaterialIndex);
}
}
if (geo.groups.length === 0) {
geo.addGroup(0, buffers.materialIndex.length, buffers.materialIndex[0]);
}
}
this.addMorphTargets(geo, geoNode, morphTargets, preTransform);
return geo;
}
parseGeoNode(geoNode, skeleton) {
const geoInfo = {};
geoInfo.vertexPositions = geoNode.Vertices !== void 0 ? geoNode.Vertices.a : [];
geoInfo.vertexIndices = geoNode.PolygonVertexIndex !== void 0 ? geoNode.PolygonVertexIndex.a : [];
if (geoNode.LayerElementColor) {
geoInfo.color = this.parseVertexColors(geoNode.LayerElementColor[0]);
}
if (geoNode.LayerElementMaterial) {
geoInfo.material = this.parseMaterialIndices(geoNode.LayerElementMaterial[0]);
}
if (geoNode.LayerElementNormal) {
geoInfo.normal = this.parseNormals(geoNode.LayerElementNormal[0]);
}
if (geoNode.LayerElementUV) {
geoInfo.uv = [];
let i = 0;
while (geoNode.LayerElementUV[i]) {
if (geoNode.LayerElementUV[i].UV) {
geoInfo.uv.push(this.parseUVs(geoNode.LayerElementUV[i]));
}
i++;
}
}
geoInfo.weightTable = {};
if (skeleton !== null) {
geoInfo.skeleton = skeleton;
skeleton.rawBones.forEach(function(rawBone, i) {
rawBone.indices.forEach(function(index, j) {
if (geoInfo.weightTable[index] === void 0)
geoInfo.weightTable[index] = [];
geoInfo.weightTable[index].push({
id: i,
weight: rawBone.weights[j]
});
});
});
}
return geoInfo;
}
genBuffers(geoInfo) {
const buffers = {
vertex: [],
normal: [],
colors: [],
uvs: [],
materialIndex: [],
vertexWeights: [],
weightsIndices: []
};
let polygonIndex = 0;
let faceLength = 0;
let displayedWeightsWarning = false;
let facePositionIndexes = [];
let faceNormals = [];
let faceColors = [];
let faceUVs = [];
let faceWeights = [];
let faceWeightIndices = [];
const scope = this;
geoInfo.vertexIndices.forEach(function(vertexIndex, polygonVertexIndex) {
let materialIndex;
let endOfFace = false;
if (vertexIndex < 0) {
vertexIndex = vertexIndex ^ -1;
endOfFace = true;
}
let weightIndices = [];
let weights = [];
facePositionIndexes.push(vertexIndex * 3, vertexIndex * 3 + 1, vertexIndex * 3 + 2);
if (geoInfo.color) {
const data = getData(polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.color);
faceColors.push(data[0], data[1], data[2]);
}
if (geoInfo.skeleton) {
if (geoInfo.weightTable[vertexIndex] !== void 0) {
geoInfo.weightTable[vertexIndex].forEach(function(wt) {
weights.push(wt.weight);
weightIndices.push(wt.id);
});
}
if (weights.length > 4) {
if (!displayedWeightsWarning) {
console.warn(
"THREE.FBXLoader: Vertex has more than 4 skinning weights assigned to vertex. Deleting additional weights."
);
displayedWeightsWarning = true;
}
const wIndex = [0, 0, 0, 0];
const Weight = [0, 0, 0, 0];
weights.forEach(function(weight, weightIndex) {
let currentWeight = weight;
let currentIndex = weightIndices[weightIndex];
Weight.forEach(function(comparedWeight, comparedWeightIndex, comparedWeightArray) {
if (currentWeight > comparedWeight) {
comparedWeightArray[comparedWeightIndex] = currentWeight;
currentWeight = comparedWeight;
const tmp = wIndex[comparedWeightIndex];
wIndex[comparedWeightIndex] = currentIndex;
currentIndex = tmp;
}
});
});
weightIndices = wIndex;
weights = Weight;
}
while (weights.length < 4) {
weights.push(0);
weightIndices.push(0);
}
for (let i = 0; i < 4; ++i) {
faceWeights.push(weights[i]);
faceWeightIndices.push(weightIndices[i]);
}
}
if (geoInfo.normal) {
const data = getData(polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.normal);
faceNormals.push(data[0], data[1], data[2]);
}
if (geoInfo.material && geoInfo.material.mappingType !== "AllSame") {
materialIndex = getData(polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.material)[0];
}
if (geoInfo.uv) {
geoInfo.uv.forEach(function(uv, i) {
const data = getData(polygonVertexIndex, polygonIndex, vertexIndex, uv);
if (faceUVs[i] === void 0) {
faceUVs[i] = [];
}
faceUVs[i].push(data[0]);
faceUVs[i].push(data[1]);
});
}
faceLength++;
if (endOfFace) {
scope.genFace(
buffers,
geoInfo,
facePositionIndexes,
materialIndex,
faceNormals,
faceColors,
faceUVs,
faceWeights,
faceWeightIndices,
faceLength
);
polygonIndex++;
faceLength = 0;
facePositionIndexes = [];
faceNormals = [];
faceColors = [];
faceUVs = [];
faceWeights = [];
faceWeightIndices = [];
}
});
return buffers;
}
// Generate data for a single face in a geometry. If the face is a quad then split it into 2 tris
genFace(buffers, geoInfo, facePositionIndexes, materialIndex, faceNormals, faceColors, faceUVs, faceWeights, faceWeightIndices, faceLength) {
for (let i = 2; i < faceLength; i++) {
buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[0]]);
buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[1]]);
buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[2]]);
buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[(i - 1) * 3]]);
buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[(i - 1) * 3 + 1]]);
buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[(i - 1) * 3 + 2]]);
buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i * 3]]);
buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i * 3 + 1]]);
buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i * 3 + 2]]);
if (geoInfo.skeleton) {
buffers.vertexWeights.push(faceWeights[0]);
buffers.vertexWeights.push(faceWeights[1]);
buffers.vertexWeights.push(faceWeights[2]);
buffers.vertexWeights.push(faceWeights[3]);
buffers.vertexWeights.push(faceWeights[(i - 1) * 4]);
buffers.vertexWeights.push(faceWeights[(i - 1) * 4 + 1]);
buffers.vertexWeights.push(faceWeights[(i - 1) * 4 + 2]);
buffers.vertexWeights.push(faceWeights[(i - 1) * 4 + 3]);
buffers.vertexWeights.push(faceWeights[i * 4]);
buffers.vertexWeights.push(faceWeights[i * 4 + 1]);
buffers.vertexWeights.push(faceWeights[i * 4 + 2]);
buffers.vertexWeights.push(faceWeights[i * 4 + 3]);
buffers.weightsIndices.push(faceWeightIndices[0]);
buffers.weightsIndices.push(faceWeightIndices[1]);
buffers.weightsIndices.push(faceWeightIndices[2]);
buffers.weightsIndices.push(faceWeightIndices[3]);
buffers.weightsIndices.push(faceWeightIndices[(i - 1) * 4]);
buffers.weightsIndices.push(faceWeightIndices[(i - 1) * 4 + 1]);
buffers.weightsIndices.push(faceWeightIndices[(i - 1) * 4 + 2]);
buffers.weightsIndices.push(faceWeightIndices[(i - 1) * 4 + 3]);
buffers.weightsIndices.push(faceWeightIndices[i * 4]);
buffers.weightsIndices.push(faceWeightIndices[i * 4 + 1]);
buffers.weightsIndices.push(faceWeightIndices[i * 4 + 2]);
buffers.weightsIndices.push(faceWeightIndices[i * 4 + 3]);
}
if (geoInfo.color) {
buffers.colors.push(faceColors[0]);
buffers.colors.push(faceColors[1]);
buffers.colors.push(faceColors[2]);
buffers.colors.push(faceColors[(i - 1) * 3]);
buffers.colors.push(faceColors[(i - 1) * 3 + 1]);
buffers.colors.push(faceColors[(i - 1) * 3 + 2]);
buffers.colors.push(faceColors[i * 3]);
buffers.colors.push(faceColors[i * 3 + 1]);
buffers.colors.push(faceColors[i * 3 + 2]);
}
if (geoInfo.material && geoInfo.material.mappingType !== "AllSame") {
buffers.materialIndex.push(materialIndex);
buffers.materialIndex.push(materialIndex);
buffers.materialIndex.push(materialIndex);
}
if (geoInfo.normal) {
buffers.normal.push(faceNormals[0]);
buffers.normal.push(faceNormals[1]);
buffers.normal.push(faceNormals[2]);
buffers.normal.push(faceNormals[(i - 1) * 3]);
buffers.normal.push(faceNormals[(i - 1) * 3 + 1]);
buffers.normal.push(faceNormals[(i - 1) * 3 + 2]);
buffers.normal.push(faceNormals[i * 3]);
buffers.normal.push(faceNormals[i * 3 + 1]);
buffers.normal.push(faceNormals[i * 3 + 2]);
}
if (geoInfo.uv) {
geoInfo.uv.forEach(function(uv, j) {
if (buffers.uvs[j] === void 0)
buffers.uvs[j] = [];
buffers.uvs[j].push(faceUVs[j][0]);
buffers.uvs[j].push(faceUVs[j][1]);
buffers.uvs[j].push(faceUVs[j][(i - 1) * 2]);
buffers.uvs[j].push(faceUVs[j][(i - 1) * 2 + 1]);
buffers.uvs[j].push(faceUVs[j][i * 2]);
buffers.uvs[j].push(faceUVs[j][i * 2 + 1]);
});
}
}
}
addMorphTargets(parentGeo, parentGeoNode, morphTargets, preTransform) {
if (morphTargets.length === 0)
return;
parentGeo.morphTargetsRelative = true;
parentGeo.morphAttributes.position = [];
const scope = this;
morphTargets.forEach(function(morphTarget) {
morphTarget.rawTargets.forEach(function(rawTarget) {
const morphGeoNode = fbxTree.Objects.Geometry[rawTarget.geoID];
if (morphGeoNode !== void 0) {
scope.genMorphGeometry(parentGeo, parentGeoNode, morphGeoNode, preTransform, rawTarget.name);
}
});
});
}
// a morph geometry node is similar to a standard node, and the node is also contained
// in FBXTree.Objects.Geometry, however it can only have attributes for position, normal
// and a special attribute Index defining which vertices of the original geometry are affected
// Normal and position attributes only have data for the vertices that are affected by the morph
genMorphGeometry(parentGeo, parentGeoNode, morphGeoNode, preTransform, name) {
const vertexIndices = parentGeoNode.PolygonVertexIndex !== void 0 ? parentGeoNode.PolygonVertexIndex.a : [];
const morphPositionsSparse = morphGeoNode.Vertices !== void 0 ? morphGeoNode.Vertices.a : [];
const indices = morphGeoNode.Indexes !== void 0 ? morphGeoNode.Indexes.a : [];
const length = parentGeo.attributes.position.count * 3;
const morphPositions = new Float32Array(length);
for (let i = 0; i < indices.length; i++) {
const morphIndex = indices[i] * 3;
morphPositions[morphIndex] = morphPositionsSparse[i * 3];
morphPositions[morphIndex + 1] = morphPositionsSparse[i * 3 + 1];
morphPositions[morphIndex + 2] = morphPositionsSparse[i * 3 + 2];
}
const morphGeoInfo = {
vertexIndices,
vertexPositions: morphPositions
};
const morphBuffers = this.genBuffers(morphGeoInfo);
const positionAttribute = new THREE.Float32BufferAttribute(morphBuffers.vertex, 3);
positionAttribute.name = name || morphGeoNode.attrName;
positionAttribute.applyMatrix4(preTransform);
parentGeo.morphAttributes.position.push(positionAttribute);
}
// Parse normal from FBXTree.Objects.Geometry.LayerElementNormal if it exists
parseNormals(NormalNode) {
const mappingType = NormalNode.MappingInformationType;
const referenceType = NormalNode.ReferenceInformationType;
const buffer = NormalNode.Normals.a;
let indexBuffer = [];
if (referenceType === "IndexToDirect") {
if ("NormalIndex" in NormalNode) {
indexBuffer = NormalNode.NormalIndex.a;
} else if ("NormalsIndex" in NormalNode) {
indexBuffer = NormalNode.NormalsIndex.a;
}
}
return {
dataSize: 3,
buffer,
indices: indexBuffer,
mappingType,
referenceType
};
}
// Parse UVs from FBXTree.Objects.Geometry.LayerElementUV if it exists
parseUVs(UVNode) {
const mappingType = UVNode.MappingInformationType;
const referenceType = UVNode.ReferenceInformationType;
const buffer = UVNode.UV.a;
let indexBuffer = [];
if (referenceType === "IndexToDirect") {
indexBuffer = UVNode.UVIndex.a;
}
return {
dataSize: 2,
buffer,
indices: indexBuffer,
mappingType,
referenceType
};
}
// Parse Vertex Colors from FBXTree.Objects.Geometry.LayerElementColor if it ex