import {
|
defined,
|
defaultValue,
|
FeatureDetection,
|
PropertyTable,
|
MetadataClass,
|
MetadataComponentType,
|
MetadataEnum,
|
MetadataTable,
|
MetadataType,
|
} from "../Source/Cesium.js";
|
|
function MetadataTester() {}
|
|
MetadataTester.isSupported = function () {
|
return (
|
FeatureDetection.supportsBigInt64Array() &&
|
FeatureDetection.supportsBigUint64Array() &&
|
FeatureDetection.supportsBigInt() &&
|
typeof TextEncoder !== "undefined"
|
);
|
};
|
|
MetadataTester.createProperty = function (options) {
|
var properties = {
|
propertyId: options.property,
|
};
|
var propertyValues = {
|
propertyId: options.values,
|
};
|
|
var table = MetadataTester.createMetadataTable({
|
properties: properties,
|
propertyValues: propertyValues,
|
// offsetType is for legacy EXT_feature_metadata, arrayOffsetType and
|
// stringOffsetType are for EXT_mesh_features
|
offsetType: options.offsetType,
|
arrayOffsetType: options.arrayOffsetType,
|
stringOffsetType: options.stringOffsetType,
|
enums: options.enums,
|
disableBigIntSupport: options.disableBigIntSupport,
|
disableBigInt64ArraySupport: options.disableBigInt64ArraySupport,
|
disableBigUint64ArraySupport: options.disableBigUint64ArraySupport,
|
});
|
|
return table._properties.propertyId;
|
};
|
|
function createProperties(options) {
|
var schema = options.schema;
|
var classId = options.classId;
|
var propertyValues = options.propertyValues;
|
var offsetType = options.offsetType;
|
var stringOffsetType = options.stringOffsetType;
|
var arrayOffsetType = options.arrayOffsetType;
|
var bufferViews = defined(options.bufferViews) ? options.bufferViews : {};
|
|
var enums = defined(schema.enums) ? schema.enums : {};
|
var enumDefinitions = {};
|
for (var enumId in enums) {
|
if (enums.hasOwnProperty(enumId)) {
|
enumDefinitions[enumId] = new MetadataEnum({
|
id: enumId,
|
enum: enums[enumId],
|
});
|
}
|
}
|
|
var classDefinition = new MetadataClass({
|
id: classId,
|
class: schema.classes[classId],
|
enums: enumDefinitions,
|
});
|
|
var properties = {};
|
var bufferViewIndex = Object.keys(bufferViews).length;
|
var count = 0;
|
|
for (var propertyId in propertyValues) {
|
if (propertyValues.hasOwnProperty(propertyId)) {
|
var classProperty = classDefinition.properties[propertyId];
|
var values = propertyValues[propertyId];
|
count = values.length;
|
|
var valuesBuffer = addPadding(createValuesBuffer(values, classProperty));
|
var valuesBufferView = bufferViewIndex++;
|
bufferViews[valuesBufferView] = valuesBuffer;
|
|
var property = {
|
bufferView: valuesBufferView,
|
};
|
|
properties[propertyId] = property;
|
|
// for legacy EXT_feature_metadata
|
if (defined(offsetType)) {
|
property.offsetType = offsetType;
|
}
|
|
if (defined(stringOffsetType)) {
|
property.stringOffsetType = offsetType;
|
}
|
|
if (defined(arrayOffsetType)) {
|
property.arrayOffsetType = arrayOffsetType;
|
}
|
|
if (
|
classProperty.type === MetadataType.ARRAY &&
|
!defined(classProperty.componentCount)
|
) {
|
var arrayOffsetBufferType = defaultValue(arrayOffsetType, offsetType);
|
var arrayOffsetBuffer = addPadding(
|
createArrayOffsetBuffer(values, arrayOffsetBufferType)
|
);
|
var arrayOffsetBufferView = bufferViewIndex++;
|
bufferViews[arrayOffsetBufferView] = arrayOffsetBuffer;
|
property.arrayOffsetBufferView = arrayOffsetBufferView;
|
}
|
|
if (classProperty.componentType === MetadataComponentType.STRING) {
|
var stringOffsetBufferType = defaultValue(stringOffsetType, offsetType);
|
var stringOffsetBuffer = addPadding(
|
createStringOffsetBuffer(values, stringOffsetBufferType)
|
);
|
var stringOffsetBufferView = bufferViewIndex++;
|
bufferViews[stringOffsetBufferView] = stringOffsetBuffer;
|
property.stringOffsetBufferView = stringOffsetBufferView;
|
}
|
}
|
}
|
|
return {
|
count: count,
|
properties: properties,
|
class: classDefinition,
|
bufferViews: bufferViews,
|
};
|
}
|
|
MetadataTester.createMetadataTable = function (options) {
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
var disableBigIntSupport = options.disableBigIntSupport;
|
var disableBigInt64ArraySupport = options.disableBigInt64ArraySupport;
|
var disableBigUint64ArraySupport = options.disableBigUint64ArraySupport;
|
|
var schema = {
|
enums: options.enums,
|
classes: {
|
classId: {
|
properties: options.properties,
|
},
|
},
|
};
|
|
var propertyResults = createProperties({
|
schema: schema,
|
classId: "classId",
|
propertyValues: options.propertyValues,
|
offsetType: options.offsetType,
|
});
|
|
var count = propertyResults.count;
|
var properties = propertyResults.properties;
|
var classDefinition = propertyResults.class;
|
var bufferViews = propertyResults.bufferViews;
|
|
if (disableBigIntSupport) {
|
spyOn(FeatureDetection, "supportsBigInt").and.returnValue(false);
|
}
|
|
if (disableBigInt64ArraySupport) {
|
spyOn(FeatureDetection, "supportsBigInt64Array").and.returnValue(false);
|
}
|
|
if (disableBigUint64ArraySupport) {
|
spyOn(FeatureDetection, "supportsBigUint64Array").and.returnValue(false);
|
}
|
|
return new MetadataTable({
|
count: count,
|
properties: properties,
|
class: classDefinition,
|
bufferViews: bufferViews,
|
});
|
};
|
|
MetadataTester.createPropertyTable = function (options) {
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
var disableBigIntSupport = options.disableBigIntSupport;
|
var disableBigInt64ArraySupport = options.disableBigInt64ArraySupport;
|
var disableBigUint64ArraySupport = options.disableBigUint64ArraySupport;
|
|
var schema = {
|
enums: options.enums,
|
classes: {
|
classId: {
|
properties: options.properties,
|
},
|
},
|
};
|
|
var propertyResults = createProperties({
|
schema: schema,
|
classId: "classId",
|
propertyValues: options.propertyValues,
|
offsetType: options.offsetType,
|
});
|
|
var count = propertyResults.count;
|
var properties = propertyResults.properties;
|
var classDefinition = propertyResults.class;
|
var bufferViews = propertyResults.bufferViews;
|
|
if (disableBigIntSupport) {
|
spyOn(FeatureDetection, "supportsBigInt").and.returnValue(false);
|
}
|
|
if (disableBigInt64ArraySupport) {
|
spyOn(FeatureDetection, "supportsBigInt64Array").and.returnValue(false);
|
}
|
|
if (disableBigUint64ArraySupport) {
|
spyOn(FeatureDetection, "supportsBigUint64Array").and.returnValue(false);
|
}
|
|
var metadataTable = new MetadataTable({
|
count: count,
|
class: classDefinition,
|
bufferViews: bufferViews,
|
properties: properties,
|
});
|
|
return new PropertyTable({
|
metadataTable: metadataTable,
|
count: count,
|
extras: options.extras,
|
extensions: options.extensions,
|
});
|
};
|
|
// for EXT_mesh_features
|
MetadataTester.createPropertyTables = function (options) {
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
|
var propertyTables = [];
|
var bufferViews = {};
|
|
for (var i = 0; i < options.propertyTables.length; i++) {
|
var propertyTable = options.propertyTables[i];
|
var tablePropertyResults = createProperties({
|
schema: options.schema,
|
classId: propertyTable.class,
|
propertyValues: propertyTable.properties,
|
bufferViews: bufferViews,
|
});
|
|
var count = tablePropertyResults.count;
|
var properties = tablePropertyResults.properties;
|
propertyTables.push({
|
name: propertyTable.name,
|
class: propertyTable.class,
|
count: count,
|
properties: properties,
|
});
|
}
|
|
return {
|
propertyTables: propertyTables,
|
bufferViews: bufferViews,
|
};
|
};
|
|
// For EXT_feature_metadata
|
MetadataTester.createFeatureTables = function (options) {
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
|
var featureTables = {};
|
var bufferViews = {};
|
|
for (var featureTableId in options.featureTables) {
|
if (options.featureTables.hasOwnProperty(featureTableId)) {
|
var featureTable = options.featureTables[featureTableId];
|
var propertyResults = createProperties({
|
schema: options.schema,
|
classId: featureTable.class,
|
propertyValues: featureTable.properties,
|
bufferViews: bufferViews,
|
});
|
|
var count = propertyResults.count;
|
var properties = propertyResults.properties;
|
featureTables[featureTableId] = {
|
class: featureTable.class,
|
count: count,
|
properties: properties,
|
};
|
}
|
}
|
|
return {
|
featureTables: featureTables,
|
bufferViews: bufferViews,
|
};
|
};
|
|
MetadataTester.createGltf = function (options) {
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
|
var propertyTableResults = MetadataTester.createPropertyTables(options);
|
|
var bufferByteLength = 0;
|
var bufferViewsMap = propertyTableResults.bufferViews;
|
var bufferViewsLength = Object.keys(bufferViewsMap).length;
|
|
var byteLengths = new Array(bufferViewsLength);
|
|
var bufferViewId;
|
var uint8Array;
|
|
for (bufferViewId in bufferViewsMap) {
|
if (bufferViewsMap.hasOwnProperty(bufferViewId)) {
|
uint8Array = bufferViewsMap[bufferViewId];
|
|
var remainder = uint8Array.byteLength % 8;
|
var padding = remainder === 0 ? 0 : 8 - remainder;
|
var byteLength = uint8Array.byteLength + padding;
|
bufferByteLength += byteLength;
|
byteLengths[bufferViewId] = byteLength;
|
}
|
}
|
|
var buffer = new Uint8Array(bufferByteLength);
|
var bufferViews = new Array(bufferViewsLength);
|
var byteOffset = 0;
|
|
for (bufferViewId in bufferViewsMap) {
|
if (bufferViewsMap.hasOwnProperty(bufferViewId)) {
|
uint8Array = bufferViewsMap[bufferViewId];
|
|
bufferViews[bufferViewId] = {
|
buffer: 0,
|
byteOffset: byteOffset,
|
byteLength: uint8Array.byteLength,
|
};
|
|
buffer.set(uint8Array, byteOffset);
|
byteOffset += byteLengths[bufferViewId];
|
}
|
}
|
|
var gltf = {
|
buffers: [
|
{
|
uri: "external.bin",
|
byteLength: buffer.byteLength,
|
},
|
],
|
images: options.images,
|
textures: options.textures,
|
bufferViews: bufferViews,
|
extensionsUsed: ["EXT_mesh_features"],
|
extensions: {
|
EXT_mesh_features: {
|
schema: options.schema,
|
propertyTables: propertyTableResults.propertyTables,
|
propertyTextures: options.propertyTextures,
|
},
|
},
|
};
|
|
return {
|
gltf: gltf,
|
buffer: buffer,
|
};
|
};
|
|
function createBuffer(values, componentType) {
|
var typedArray;
|
switch (componentType) {
|
case MetadataComponentType.INT8:
|
typedArray = new Int8Array(values);
|
break;
|
case MetadataComponentType.UINT8:
|
typedArray = new Uint8Array(values);
|
break;
|
case MetadataComponentType.INT16:
|
typedArray = new Int16Array(values);
|
break;
|
case MetadataComponentType.UINT16:
|
typedArray = new Uint16Array(values);
|
break;
|
case MetadataComponentType.INT32:
|
typedArray = new Int32Array(values);
|
break;
|
case MetadataComponentType.UINT32:
|
typedArray = new Uint32Array(values);
|
break;
|
case MetadataComponentType.INT64:
|
typedArray = new BigInt64Array(values); // eslint-disable-line
|
break;
|
case MetadataComponentType.UINT64:
|
typedArray = new BigUint64Array(values); // eslint-disable-line
|
break;
|
case MetadataComponentType.FLOAT32:
|
typedArray = new Float32Array(values);
|
break;
|
case MetadataComponentType.FLOAT64:
|
typedArray = new Float64Array(values);
|
break;
|
case MetadataComponentType.STRING:
|
var encoder = new TextEncoder();
|
typedArray = encoder.encode(values.join(""));
|
break;
|
case MetadataComponentType.BOOLEAN:
|
var length = Math.ceil(values.length / 8);
|
typedArray = new Uint8Array(length); // Initialized as 0's
|
for (var i = 0; i < values.length; ++i) {
|
var byteIndex = i >> 3;
|
var bitIndex = i % 8;
|
if (values[i]) {
|
typedArray[byteIndex] |= 1 << bitIndex;
|
}
|
}
|
break;
|
}
|
|
return new Uint8Array(typedArray.buffer);
|
}
|
|
function flatten(values) {
|
return [].concat.apply([], values);
|
}
|
|
function createValuesBuffer(values, classProperty) {
|
var valueType = classProperty.valueType;
|
var enumType = classProperty.enumType;
|
var flattenedValues = flatten(values);
|
|
if (defined(enumType)) {
|
var length = flattenedValues.length;
|
for (var i = 0; i < length; ++i) {
|
flattenedValues[i] = enumType.valuesByName[flattenedValues[i]];
|
}
|
}
|
|
return createBuffer(flattenedValues, valueType);
|
}
|
|
function createStringOffsetBuffer(values, offsetType) {
|
var encoder = new TextEncoder();
|
var strings = flatten(values);
|
var length = strings.length;
|
var offsets = new Array(length + 1);
|
var offset = 0;
|
for (var i = 0; i < length; ++i) {
|
offsets[i] = offset;
|
offset += encoder.encode(strings[i]).length;
|
}
|
offsets[length] = offset;
|
offsetType = defaultValue(offsetType, MetadataComponentType.UINT32);
|
return createBuffer(offsets, offsetType);
|
}
|
|
function createArrayOffsetBuffer(values, offsetType) {
|
var length = values.length;
|
var offsets = new Array(length + 1);
|
var offset = 0;
|
for (var i = 0; i < length; ++i) {
|
offsets[i] = offset;
|
offset += values[i].length;
|
}
|
offsets[length] = offset;
|
offsetType = defaultValue(offsetType, MetadataComponentType.UINT32);
|
return createBuffer(offsets, offsetType);
|
}
|
|
function addPadding(uint8Array) {
|
// This tests that MetadataTable uses the Uint8Array's byteOffset properly
|
var paddingBytes = 8;
|
var padded = new Uint8Array(paddingBytes + uint8Array.length);
|
padded.set(uint8Array, paddingBytes);
|
return new Uint8Array(padded.buffer, paddingBytes, uint8Array.length);
|
}
|
|
export default MetadataTester;
|
