mirror of
https://github.com/CesiumGS/obj2gltf.git
synced 2024-11-27 10:30:16 -05:00
711 lines
17 KiB
JavaScript
711 lines
17 KiB
JavaScript
"use strict";
|
|
const BUFFER_MAX_BYTE_LENGTH = require("buffer").constants.MAX_LENGTH;
|
|
const Cesium = require("cesium");
|
|
const getBufferPadded = require("./getBufferPadded");
|
|
const getDefaultMaterial = require("./loadMtl").getDefaultMaterial;
|
|
const Texture = require("./Texture");
|
|
|
|
const defaultValue = Cesium.defaultValue;
|
|
const defined = Cesium.defined;
|
|
const WebGLConstants = Cesium.WebGLConstants;
|
|
|
|
module.exports = createGltf;
|
|
|
|
/**
|
|
* Create a glTF from obj data.
|
|
*
|
|
* @param {Object} objData An object containing an array of nodes containing geometry information and an array of materials.
|
|
* @param {Object} options The options object passed along from lib/obj2gltf.js
|
|
* @returns {Object} A glTF asset.
|
|
*
|
|
* @private
|
|
*/
|
|
function createGltf(objData, options) {
|
|
const nodes = objData.nodes;
|
|
let materials = objData.materials;
|
|
const name = objData.name;
|
|
|
|
// Split materials used by primitives with different types of attributes
|
|
materials = splitIncompatibleMaterials(nodes, materials, options);
|
|
|
|
const gltf = {
|
|
accessors: [],
|
|
asset: {},
|
|
buffers: [],
|
|
bufferViews: [],
|
|
extensionsUsed: [],
|
|
extensionsRequired: [],
|
|
images: [],
|
|
materials: [],
|
|
meshes: [],
|
|
nodes: [],
|
|
samplers: [],
|
|
scene: 0,
|
|
scenes: [],
|
|
textures: [],
|
|
};
|
|
|
|
gltf.asset = {
|
|
generator: "obj2gltf",
|
|
version: "2.0",
|
|
};
|
|
|
|
gltf.scenes.push({
|
|
nodes: [],
|
|
});
|
|
|
|
const bufferState = {
|
|
positionBuffers: [],
|
|
normalBuffers: [],
|
|
uvBuffers: [],
|
|
indexBuffers: [],
|
|
positionAccessors: [],
|
|
normalAccessors: [],
|
|
uvAccessors: [],
|
|
indexAccessors: [],
|
|
};
|
|
|
|
const uint32Indices = requiresUint32Indices(nodes);
|
|
|
|
const nodesLength = nodes.length;
|
|
for (let i = 0; i < nodesLength; ++i) {
|
|
const node = nodes[i];
|
|
const meshes = node.meshes;
|
|
const meshesLength = meshes.length;
|
|
|
|
if (meshesLength === 1) {
|
|
const meshIndex = addMesh(
|
|
gltf,
|
|
materials,
|
|
bufferState,
|
|
uint32Indices,
|
|
meshes[0],
|
|
options
|
|
);
|
|
addNode(gltf, node.name, meshIndex, undefined);
|
|
} else {
|
|
// Add meshes as child nodes
|
|
const parentIndex = addNode(gltf, node.name);
|
|
for (let j = 0; j < meshesLength; ++j) {
|
|
const mesh = meshes[j];
|
|
const meshIndex = addMesh(
|
|
gltf,
|
|
materials,
|
|
bufferState,
|
|
uint32Indices,
|
|
mesh,
|
|
options
|
|
);
|
|
addNode(gltf, mesh.name, meshIndex, parentIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (gltf.images.length > 0) {
|
|
gltf.samplers.push({
|
|
wrapS: WebGLConstants.REPEAT,
|
|
wrapT: WebGLConstants.REPEAT,
|
|
});
|
|
}
|
|
|
|
addBuffers(gltf, bufferState, name, options.separate);
|
|
|
|
if (options.specularGlossiness) {
|
|
gltf.extensionsUsed.push("KHR_materials_pbrSpecularGlossiness");
|
|
gltf.extensionsRequired.push("KHR_materials_pbrSpecularGlossiness");
|
|
}
|
|
|
|
if (options.unlit) {
|
|
gltf.extensionsUsed.push("KHR_materials_unlit");
|
|
gltf.extensionsRequired.push("KHR_materials_unlit");
|
|
}
|
|
|
|
return gltf;
|
|
}
|
|
|
|
function addCombinedBufferView(gltf, buffers, accessors, byteStride, target) {
|
|
const length = buffers.length;
|
|
if (length === 0) {
|
|
return;
|
|
}
|
|
const bufferViewIndex = gltf.bufferViews.length;
|
|
const previousBufferView = gltf.bufferViews[bufferViewIndex - 1];
|
|
const byteOffset = defined(previousBufferView)
|
|
? previousBufferView.byteOffset + previousBufferView.byteLength
|
|
: 0;
|
|
let byteLength = 0;
|
|
for (let i = 0; i < length; ++i) {
|
|
const accessor = gltf.accessors[accessors[i]];
|
|
accessor.bufferView = bufferViewIndex;
|
|
accessor.byteOffset = byteLength;
|
|
byteLength += buffers[i].length;
|
|
}
|
|
gltf.bufferViews.push({
|
|
name: "bufferView_" + bufferViewIndex,
|
|
buffer: 0,
|
|
byteLength: byteLength,
|
|
byteOffset: byteOffset,
|
|
byteStride: byteStride,
|
|
target: target,
|
|
});
|
|
}
|
|
|
|
function addCombinedBuffers(gltf, bufferState, name) {
|
|
addCombinedBufferView(
|
|
gltf,
|
|
bufferState.positionBuffers,
|
|
bufferState.positionAccessors,
|
|
12,
|
|
WebGLConstants.ARRAY_BUFFER
|
|
);
|
|
addCombinedBufferView(
|
|
gltf,
|
|
bufferState.normalBuffers,
|
|
bufferState.normalAccessors,
|
|
12,
|
|
WebGLConstants.ARRAY_BUFFER
|
|
);
|
|
addCombinedBufferView(
|
|
gltf,
|
|
bufferState.uvBuffers,
|
|
bufferState.uvAccessors,
|
|
8,
|
|
WebGLConstants.ARRAY_BUFFER
|
|
);
|
|
addCombinedBufferView(
|
|
gltf,
|
|
bufferState.indexBuffers,
|
|
bufferState.indexAccessors,
|
|
undefined,
|
|
WebGLConstants.ELEMENT_ARRAY_BUFFER
|
|
);
|
|
|
|
let buffers = [];
|
|
buffers = buffers.concat(
|
|
bufferState.positionBuffers,
|
|
bufferState.normalBuffers,
|
|
bufferState.uvBuffers,
|
|
bufferState.indexBuffers
|
|
);
|
|
const buffer = getBufferPadded(Buffer.concat(buffers));
|
|
|
|
gltf.buffers.push({
|
|
name: name,
|
|
byteLength: buffer.length,
|
|
extras: {
|
|
_obj2gltf: {
|
|
source: buffer,
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
function addSeparateBufferView(
|
|
gltf,
|
|
buffer,
|
|
accessor,
|
|
byteStride,
|
|
target,
|
|
name
|
|
) {
|
|
const bufferIndex = gltf.buffers.length;
|
|
const bufferViewIndex = gltf.bufferViews.length;
|
|
|
|
gltf.buffers.push({
|
|
name: name + "_" + bufferIndex,
|
|
byteLength: buffer.length,
|
|
extras: {
|
|
_obj2gltf: {
|
|
source: buffer,
|
|
},
|
|
},
|
|
});
|
|
|
|
gltf.bufferViews.push({
|
|
buffer: bufferIndex,
|
|
byteLength: buffer.length,
|
|
byteOffset: 0,
|
|
byteStride: byteStride,
|
|
target: target,
|
|
});
|
|
|
|
gltf.accessors[accessor].bufferView = bufferViewIndex;
|
|
gltf.accessors[accessor].byteOffset = 0;
|
|
}
|
|
|
|
function addSeparateBufferViews(
|
|
gltf,
|
|
buffers,
|
|
accessors,
|
|
byteStride,
|
|
target,
|
|
name
|
|
) {
|
|
const length = buffers.length;
|
|
for (let i = 0; i < length; ++i) {
|
|
addSeparateBufferView(
|
|
gltf,
|
|
buffers[i],
|
|
accessors[i],
|
|
byteStride,
|
|
target,
|
|
name
|
|
);
|
|
}
|
|
}
|
|
|
|
function addSeparateBuffers(gltf, bufferState, name) {
|
|
addSeparateBufferViews(
|
|
gltf,
|
|
bufferState.positionBuffers,
|
|
bufferState.positionAccessors,
|
|
12,
|
|
WebGLConstants.ARRAY_BUFFER,
|
|
name
|
|
);
|
|
addSeparateBufferViews(
|
|
gltf,
|
|
bufferState.normalBuffers,
|
|
bufferState.normalAccessors,
|
|
12,
|
|
WebGLConstants.ARRAY_BUFFER,
|
|
name
|
|
);
|
|
addSeparateBufferViews(
|
|
gltf,
|
|
bufferState.uvBuffers,
|
|
bufferState.uvAccessors,
|
|
8,
|
|
WebGLConstants.ARRAY_BUFFER,
|
|
name
|
|
);
|
|
addSeparateBufferViews(
|
|
gltf,
|
|
bufferState.indexBuffers,
|
|
bufferState.indexAccessors,
|
|
undefined,
|
|
WebGLConstants.ELEMENT_ARRAY_BUFFER,
|
|
name
|
|
);
|
|
}
|
|
|
|
function addBuffers(gltf, bufferState, name, separate) {
|
|
const buffers = bufferState.positionBuffers.concat(
|
|
bufferState.normalBuffers,
|
|
bufferState.uvBuffers,
|
|
bufferState.indexBuffers
|
|
);
|
|
const buffersLength = buffers.length;
|
|
let buffersByteLength = 0;
|
|
for (let i = 0; i < buffersLength; ++i) {
|
|
buffersByteLength += buffers[i].length;
|
|
}
|
|
|
|
if (separate && buffersByteLength > createGltf._getBufferMaxByteLength()) {
|
|
// Don't combine buffers if the combined buffer will exceed the Node limit.
|
|
addSeparateBuffers(gltf, bufferState, name);
|
|
} else {
|
|
addCombinedBuffers(gltf, bufferState, name);
|
|
}
|
|
}
|
|
|
|
function addTexture(gltf, texture) {
|
|
const imageName = texture.name;
|
|
const textureName = texture.name;
|
|
const imageIndex = gltf.images.length;
|
|
const textureIndex = gltf.textures.length;
|
|
|
|
gltf.images.push({
|
|
name: imageName,
|
|
extras: {
|
|
_obj2gltf: texture,
|
|
},
|
|
});
|
|
|
|
gltf.textures.push({
|
|
name: textureName,
|
|
sampler: 0,
|
|
source: imageIndex,
|
|
});
|
|
|
|
return textureIndex;
|
|
}
|
|
|
|
function getTexture(gltf, texture) {
|
|
let textureIndex;
|
|
const images = gltf.images;
|
|
const length = images.length;
|
|
for (let i = 0; i < length; ++i) {
|
|
if (images[i].extras._obj2gltf === texture) {
|
|
textureIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!defined(textureIndex)) {
|
|
textureIndex = addTexture(gltf, texture);
|
|
}
|
|
|
|
return {
|
|
index: textureIndex,
|
|
};
|
|
}
|
|
|
|
function cloneMaterial(material, removeTextures) {
|
|
if (typeof material !== "object") {
|
|
return material;
|
|
} else if (material instanceof Texture) {
|
|
if (removeTextures) {
|
|
return undefined;
|
|
}
|
|
return material;
|
|
} else if (Array.isArray(material)) {
|
|
const length = material.length;
|
|
const clonedArray = new Array(length);
|
|
for (let i = 0; i < length; ++i) {
|
|
clonedArray[i] = cloneMaterial(material[i], removeTextures);
|
|
}
|
|
return clonedArray;
|
|
}
|
|
const clonedObject = {};
|
|
for (const name in material) {
|
|
if (Object.prototype.hasOwnProperty.call(material, name)) {
|
|
clonedObject[name] = cloneMaterial(material[name], removeTextures);
|
|
}
|
|
}
|
|
return clonedObject;
|
|
}
|
|
|
|
function resolveTextures(gltf, material) {
|
|
for (const name in material) {
|
|
if (Object.prototype.hasOwnProperty.call(material, name)) {
|
|
const property = material[name];
|
|
if (property instanceof Texture) {
|
|
material[name] = getTexture(gltf, property);
|
|
} else if (!Array.isArray(property) && typeof property === "object") {
|
|
resolveTextures(gltf, property);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function addGltfMaterial(gltf, material, options) {
|
|
resolveTextures(gltf, material);
|
|
const materialIndex = gltf.materials.length;
|
|
if (options.unlit) {
|
|
if (!defined(material.extensions)) {
|
|
material.extensions = {};
|
|
}
|
|
material.extensions.KHR_materials_unlit = {};
|
|
}
|
|
gltf.materials.push(material);
|
|
return materialIndex;
|
|
}
|
|
|
|
function getMaterialByName(materials, materialName) {
|
|
const materialsLength = materials.length;
|
|
for (let i = 0; i < materialsLength; ++i) {
|
|
if (materials[i].name === materialName) {
|
|
return materials[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
function getMaterialIndex(materials, materialName) {
|
|
const materialsLength = materials.length;
|
|
for (let i = 0; i < materialsLength; ++i) {
|
|
if (materials[i].name === materialName) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
function getOrCreateGltfMaterial(gltf, materials, materialName, options) {
|
|
const material = getMaterialByName(materials, materialName);
|
|
let materialIndex = getMaterialIndex(gltf.materials, materialName);
|
|
|
|
if (!defined(materialIndex)) {
|
|
materialIndex = addGltfMaterial(gltf, material, options);
|
|
}
|
|
|
|
return materialIndex;
|
|
}
|
|
|
|
function primitiveInfoMatch(a, b) {
|
|
return a.hasUvs === b.hasUvs && a.hasNormals === b.hasNormals;
|
|
}
|
|
|
|
function getSplitMaterialName(
|
|
originalMaterialName,
|
|
primitiveInfo,
|
|
primitiveInfoByMaterial
|
|
) {
|
|
let splitMaterialName = originalMaterialName;
|
|
let suffix = 2;
|
|
while (defined(primitiveInfoByMaterial[splitMaterialName])) {
|
|
if (
|
|
primitiveInfoMatch(
|
|
primitiveInfo,
|
|
primitiveInfoByMaterial[splitMaterialName]
|
|
)
|
|
) {
|
|
break;
|
|
}
|
|
splitMaterialName = originalMaterialName + "-" + suffix++;
|
|
}
|
|
return splitMaterialName;
|
|
}
|
|
|
|
function splitIncompatibleMaterials(nodes, materials, options) {
|
|
const splitMaterials = [];
|
|
const primitiveInfoByMaterial = {};
|
|
const nodesLength = nodes.length;
|
|
for (let i = 0; i < nodesLength; ++i) {
|
|
const meshes = nodes[i].meshes;
|
|
const meshesLength = meshes.length;
|
|
for (let j = 0; j < meshesLength; ++j) {
|
|
const primitives = meshes[j].primitives;
|
|
const primitivesLength = primitives.length;
|
|
for (let k = 0; k < primitivesLength; ++k) {
|
|
const primitive = primitives[k];
|
|
const hasUvs = primitive.uvs.length > 0;
|
|
const hasNormals = primitive.normals.length > 0;
|
|
const primitiveInfo = {
|
|
hasUvs: hasUvs,
|
|
hasNormals: hasNormals,
|
|
};
|
|
const originalMaterialName = defaultValue(
|
|
primitive.material,
|
|
"default"
|
|
);
|
|
const splitMaterialName = getSplitMaterialName(
|
|
originalMaterialName,
|
|
primitiveInfo,
|
|
primitiveInfoByMaterial
|
|
);
|
|
primitive.material = splitMaterialName;
|
|
primitiveInfoByMaterial[splitMaterialName] = primitiveInfo;
|
|
|
|
let splitMaterial = getMaterialByName(
|
|
splitMaterials,
|
|
splitMaterialName
|
|
);
|
|
if (defined(splitMaterial)) {
|
|
continue;
|
|
}
|
|
|
|
const originalMaterial = getMaterialByName(
|
|
materials,
|
|
originalMaterialName
|
|
);
|
|
if (defined(originalMaterial)) {
|
|
splitMaterial = cloneMaterial(originalMaterial, !hasUvs);
|
|
} else {
|
|
splitMaterial = getDefaultMaterial(options);
|
|
}
|
|
splitMaterial.name = splitMaterialName;
|
|
splitMaterials.push(splitMaterial);
|
|
}
|
|
}
|
|
}
|
|
return splitMaterials;
|
|
}
|
|
|
|
function addVertexAttribute(gltf, array, components, name) {
|
|
const count = array.length / components;
|
|
const minMax = array.getMinMax(components);
|
|
const type = components === 3 ? "VEC3" : "VEC2";
|
|
|
|
const accessor = {
|
|
name: name,
|
|
componentType: WebGLConstants.FLOAT,
|
|
count: count,
|
|
min: minMax.min,
|
|
max: minMax.max,
|
|
type: type,
|
|
};
|
|
|
|
const accessorIndex = gltf.accessors.length;
|
|
gltf.accessors.push(accessor);
|
|
return accessorIndex;
|
|
}
|
|
|
|
function addIndexArray(gltf, array, uint32Indices, name) {
|
|
const componentType = uint32Indices
|
|
? WebGLConstants.UNSIGNED_INT
|
|
: WebGLConstants.UNSIGNED_SHORT;
|
|
const count = array.length;
|
|
const minMax = array.getMinMax(1);
|
|
|
|
const accessor = {
|
|
name: name,
|
|
componentType: componentType,
|
|
count: count,
|
|
min: minMax.min,
|
|
max: minMax.max,
|
|
type: "SCALAR",
|
|
};
|
|
|
|
const accessorIndex = gltf.accessors.length;
|
|
gltf.accessors.push(accessor);
|
|
return accessorIndex;
|
|
}
|
|
|
|
function requiresUint32Indices(nodes) {
|
|
const nodesLength = nodes.length;
|
|
for (let i = 0; i < nodesLength; ++i) {
|
|
const meshes = nodes[i].meshes;
|
|
const meshesLength = meshes.length;
|
|
for (let j = 0; j < meshesLength; ++j) {
|
|
const primitives = meshes[j].primitives;
|
|
const primitivesLength = primitives.length;
|
|
for (let k = 0; k < primitivesLength; ++k) {
|
|
// Reserve the 65535 index for primitive restart
|
|
const vertexCount = primitives[k].positions.length / 3;
|
|
if (vertexCount > 65534) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function addPrimitive(
|
|
gltf,
|
|
materials,
|
|
bufferState,
|
|
uint32Indices,
|
|
mesh,
|
|
primitive,
|
|
index,
|
|
options
|
|
) {
|
|
const hasPositions = primitive.positions.length > 0;
|
|
const hasNormals = primitive.normals.length > 0;
|
|
const hasUVs = primitive.uvs.length > 0;
|
|
|
|
const attributes = {};
|
|
if (hasPositions) {
|
|
const accessorIndex = addVertexAttribute(
|
|
gltf,
|
|
primitive.positions,
|
|
3,
|
|
mesh.name + "_" + index + "_positions"
|
|
);
|
|
attributes.POSITION = accessorIndex;
|
|
bufferState.positionBuffers.push(primitive.positions.toFloatBuffer());
|
|
bufferState.positionAccessors.push(accessorIndex);
|
|
}
|
|
if (hasNormals) {
|
|
const accessorIndex = addVertexAttribute(
|
|
gltf,
|
|
primitive.normals,
|
|
3,
|
|
mesh.name + "_" + index + "_normals"
|
|
);
|
|
attributes.NORMAL = accessorIndex;
|
|
bufferState.normalBuffers.push(primitive.normals.toFloatBuffer());
|
|
bufferState.normalAccessors.push(accessorIndex);
|
|
}
|
|
if (hasUVs) {
|
|
const accessorIndex = addVertexAttribute(
|
|
gltf,
|
|
primitive.uvs,
|
|
2,
|
|
mesh.name + "_" + index + "_texcoords"
|
|
);
|
|
attributes.TEXCOORD_0 = accessorIndex;
|
|
bufferState.uvBuffers.push(primitive.uvs.toFloatBuffer());
|
|
bufferState.uvAccessors.push(accessorIndex);
|
|
}
|
|
|
|
const indexAccessorIndex = addIndexArray(
|
|
gltf,
|
|
primitive.indices,
|
|
uint32Indices,
|
|
mesh.name + "_" + index + "_indices"
|
|
);
|
|
const indexBuffer = uint32Indices
|
|
? primitive.indices.toUint32Buffer()
|
|
: primitive.indices.toUint16Buffer();
|
|
bufferState.indexBuffers.push(indexBuffer);
|
|
bufferState.indexAccessors.push(indexAccessorIndex);
|
|
|
|
// Unload resources
|
|
primitive.positions = undefined;
|
|
primitive.normals = undefined;
|
|
primitive.uvs = undefined;
|
|
primitive.indices = undefined;
|
|
|
|
const materialIndex = getOrCreateGltfMaterial(
|
|
gltf,
|
|
materials,
|
|
primitive.material,
|
|
options
|
|
);
|
|
|
|
return {
|
|
attributes: attributes,
|
|
indices: indexAccessorIndex,
|
|
material: materialIndex,
|
|
mode: WebGLConstants.TRIANGLES,
|
|
};
|
|
}
|
|
|
|
function addMesh(gltf, materials, bufferState, uint32Indices, mesh, options) {
|
|
const gltfPrimitives = [];
|
|
const primitives = mesh.primitives;
|
|
const primitivesLength = primitives.length;
|
|
for (let i = 0; i < primitivesLength; ++i) {
|
|
gltfPrimitives.push(
|
|
addPrimitive(
|
|
gltf,
|
|
materials,
|
|
bufferState,
|
|
uint32Indices,
|
|
mesh,
|
|
primitives[i],
|
|
i,
|
|
options
|
|
)
|
|
);
|
|
}
|
|
|
|
const gltfMesh = {
|
|
name: mesh.name,
|
|
primitives: gltfPrimitives,
|
|
};
|
|
|
|
const meshIndex = gltf.meshes.length;
|
|
gltf.meshes.push(gltfMesh);
|
|
return meshIndex;
|
|
}
|
|
|
|
function addNode(gltf, name, meshIndex, parentIndex) {
|
|
const node = {
|
|
name: name,
|
|
mesh: meshIndex,
|
|
};
|
|
|
|
const nodeIndex = gltf.nodes.length;
|
|
gltf.nodes.push(node);
|
|
|
|
if (defined(parentIndex)) {
|
|
const parentNode = gltf.nodes[parentIndex];
|
|
if (!defined(parentNode.children)) {
|
|
parentNode.children = [];
|
|
}
|
|
parentNode.children.push(nodeIndex);
|
|
} else {
|
|
gltf.scenes[gltf.scene].nodes.push(nodeIndex);
|
|
}
|
|
|
|
return nodeIndex;
|
|
}
|
|
|
|
// Exposed for testing
|
|
createGltf._getBufferMaxByteLength = function () {
|
|
return BUFFER_MAX_BYTE_LENGTH;
|
|
};
|