import Cartesian2 from "../Core/Cartesian2.js";
|
import Cartesian3 from "../Core/Cartesian3.js";
|
import Cartesian4 from "../Core/Cartesian4.js";
|
import Check from "../Core/Check.js";
|
import defaultValue from "../Core/defaultValue.js";
|
import defined from "../Core/defined.js";
|
import Matrix2 from "../Core/Matrix2.js";
|
import Matrix3 from "../Core/Matrix3.js";
|
import Matrix4 from "../Core/Matrix4.js";
|
import MetadataType from "./MetadataType.js";
|
import MetadataComponentType from "./MetadataComponentType.js";
|
|
/**
|
* A metadata property, as part of a {@link MetadataClass}
|
*
|
* @param {Object} options Object with the following properties:
|
* @param {String} options.id The ID of the property.
|
* @param {Object} options.property The property JSON object.
|
* @param {Object.<String, MetadataEnum>} [options.enums] A dictionary of enums.
|
*
|
* @alias MetadataClassProperty
|
* @constructor
|
* @private
|
* @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.
|
*/
|
function MetadataClassProperty(options) {
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
var id = options.id;
|
var property = options.property;
|
|
//>>includeStart('debug', pragmas.debug);
|
Check.typeOf.string("options.id", id);
|
Check.typeOf.object("options.property", property);
|
//>>includeEnd('debug');
|
|
var enumType;
|
if (defined(property.enumType)) {
|
enumType = options.enums[property.enumType];
|
}
|
|
var type = property.type;
|
var componentType;
|
if (MetadataComponentType.hasOwnProperty(type)) {
|
// For EXT_feature_metadata, single values were part of type, not
|
// componentType. Transcode to the newer format.
|
componentType = MetadataComponentType[type];
|
type = MetadataType.SINGLE;
|
} else {
|
type = defaultValue(MetadataType[type], MetadataType.SINGLE);
|
componentType = MetadataComponentType[property.componentType];
|
}
|
var valueType = getValueType(componentType, enumType);
|
|
var normalized =
|
MetadataComponentType.isIntegerType(componentType) &&
|
defaultValue(property.normalized, false);
|
|
var componentCount =
|
type === MetadataType.ARRAY
|
? property.componentCount
|
: MetadataType.getComponentCount(type);
|
|
this._id = id;
|
this._name = property.name;
|
this._description = property.description;
|
this._type = type;
|
this._enumType = enumType;
|
this._valueType = valueType;
|
this._componentType = componentType;
|
this._componentCount = componentCount;
|
this._normalized = normalized;
|
this._min = property.min;
|
this._max = property.max;
|
this._default = property.default;
|
this._optional = defaultValue(property.optional, false);
|
this._semantic = property.semantic;
|
this._extras = property.extras;
|
this._extensions = property.extensions;
|
}
|
|
Object.defineProperties(MetadataClassProperty.prototype, {
|
/**
|
* The ID of the property.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {String}
|
* @readonly
|
* @private
|
*/
|
id: {
|
get: function () {
|
return this._id;
|
},
|
},
|
|
/**
|
* The name of the property.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {String}
|
* @readonly
|
* @private
|
*/
|
name: {
|
get: function () {
|
return this._name;
|
},
|
},
|
|
/**
|
* The description of the property.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {String}
|
* @readonly
|
* @private
|
*/
|
description: {
|
get: function () {
|
return this._description;
|
},
|
},
|
|
/**
|
* The type of the property. Each type holds one (SINGLE) or more components
|
* (ARRAY, VECN, MATN).
|
*
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {MetadataType}
|
* @readonly
|
* @private
|
*/
|
type: {
|
get: function () {
|
return this._type;
|
},
|
},
|
|
/**
|
* The enum type of the property. Only defined when componentType is ENUM.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {MetadataEnum}
|
* @readonly
|
* @private
|
*/
|
enumType: {
|
get: function () {
|
return this._enumType;
|
},
|
},
|
|
/**
|
* The component type of the property. This includes integer
|
* (e.g. INT8 or UINT16), floating point (FLOAT32 and FLOAT64), STRING,
|
* BOOLEAN, and ENUM component types.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {MetadataComponentType}
|
* @readonly
|
* @private
|
*/
|
componentType: {
|
get: function () {
|
return this._componentType;
|
},
|
},
|
|
/**
|
* The datatype used for storing each component of the property. This
|
* is usually the same as componentType except for ENUM, where this
|
* returns an integer type
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {MetadataComponentType}
|
* @readonly
|
* @private
|
*/
|
valueType: {
|
get: function () {
|
return this._valueType;
|
},
|
},
|
|
/**
|
* The number of components per element. Only defined when type is a fixed size ARRAY.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {Number}
|
* @readonly
|
* @private
|
*/
|
componentCount: {
|
get: function () {
|
return this._componentCount;
|
},
|
},
|
|
/**
|
* Whether the property is normalized.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {Boolean}
|
* @readonly
|
* @private
|
*/
|
normalized: {
|
get: function () {
|
return this._normalized;
|
},
|
},
|
|
/**
|
* A number or an array of numbers storing the maximum allowable value of this property. Only defined when type or componentType is a numeric type.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {Number|Number[]}
|
* @readonly
|
* @private
|
*/
|
max: {
|
get: function () {
|
return this._max;
|
},
|
},
|
|
/**
|
* A number or an array of numbers storing the minimum allowable value of this property. Only defined when type or componentType is a numeric type.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {Number|Number[]}
|
* @readonly
|
* @private
|
*/
|
min: {
|
get: function () {
|
return this._min;
|
},
|
},
|
|
/**
|
* A default value to use when an entity's property value is not defined.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {Boolean|Number|String|Array}
|
* @readonly
|
* @private
|
*/
|
default: {
|
get: function () {
|
return this._default;
|
},
|
},
|
|
/**
|
* Whether the property is optional.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {Boolean}
|
* @readonly
|
* @private
|
*/
|
optional: {
|
get: function () {
|
return this._optional;
|
},
|
},
|
|
/**
|
* An identifier that describes how this property should be interpreted.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {String}
|
* @readonly
|
* @private
|
*/
|
semantic: {
|
get: function () {
|
return this._semantic;
|
},
|
},
|
|
/**
|
* Extras in the JSON object.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {*}
|
* @readonly
|
* @private
|
*/
|
extras: {
|
get: function () {
|
return this._extras;
|
},
|
},
|
|
/**
|
* Extensions in the JSON object.
|
*
|
* @memberof MetadataClassProperty.prototype
|
* @type {Object}
|
* @readonly
|
* @private
|
*/
|
extensions: {
|
get: function () {
|
return this._extensions;
|
},
|
},
|
});
|
|
/**
|
* Normalizes integer property values. If the property is not normalized
|
* the value is returned unmodified.
|
*
|
* @param {*} value The integer value or array of integer values.
|
* @returns {*} The normalized value or array of normalized values.
|
*
|
* @private
|
*/
|
MetadataClassProperty.prototype.normalize = function (value) {
|
return normalize(this, value, MetadataComponentType.normalize);
|
};
|
|
/**
|
* Unnormalizes integer property values. If the property is not normalized
|
* the value is returned unmodified.
|
*
|
* @param {*} value The normalized value or array of normalized values.
|
* @returns {*} The integer value or array of integer values.
|
*
|
* @private
|
*/
|
MetadataClassProperty.prototype.unnormalize = function (value) {
|
return normalize(this, value, MetadataComponentType.unnormalize);
|
};
|
|
/**
|
* Unpack VECN values into {@link Cartesian2}, {@link Cartesian3}, or
|
* {@link Cartesian4} and MATN values into {@link Matrix2}, {@link Matrix3}, or
|
* {@link Matrix4} depending on N. All other values (including arrays of
|
* other sizes) are passed through unaltered.
|
*
|
* @param {*} value the original, normalized values.
|
* @returns {*} The appropriate vector or matrix type if the value is a vector or matrix type, respectively. Otherwise, the value is returned unaltered.
|
* @private
|
*/
|
MetadataClassProperty.prototype.unpackVectorAndMatrixTypes = function (value) {
|
switch (this._type) {
|
case MetadataType.VEC2:
|
return Cartesian2.unpack(value);
|
case MetadataType.VEC3:
|
return Cartesian3.unpack(value);
|
case MetadataType.VEC4:
|
return Cartesian4.unpack(value);
|
case MetadataType.MAT2:
|
return Matrix2.unpack(value);
|
case MetadataType.MAT3:
|
return Matrix3.unpack(value);
|
case MetadataType.MAT4:
|
return Matrix4.unpack(value);
|
default:
|
return value;
|
}
|
};
|
|
/**
|
* Pack a {@link Cartesian2}, {@link Cartesian3}, or {@link Cartesian4} into an
|
* array if this property is an <code>VECN</code>.
|
* Pack a {@link Matrix2}, {@link Matrix3}, or {@link Matrix4} into an
|
* array if this property is an <code>MATN</code>.
|
* All other values (including arrays of other sizes) are passed through unaltered.
|
*
|
* @param {*} value The value of this property
|
* @returns {*} An array of the appropriate length if the property is a vector or matrix type. Otherwise, the value is returned unaltered.
|
* @private
|
*/
|
MetadataClassProperty.prototype.packVectorAndMatrixTypes = function (value) {
|
switch (this._type) {
|
case MetadataType.VEC2:
|
return Cartesian2.pack(value, []);
|
case MetadataType.VEC3:
|
return Cartesian3.pack(value, []);
|
case MetadataType.VEC4:
|
return Cartesian4.pack(value, []);
|
case MetadataType.MAT2:
|
return Matrix2.pack(value, []);
|
case MetadataType.MAT3:
|
return Matrix3.pack(value, []);
|
case MetadataType.MAT4:
|
return Matrix4.pack(value, []);
|
default:
|
return value;
|
}
|
};
|
|
/**
|
* Validates whether the given value conforms to the property.
|
*
|
* @param {*} value The value.
|
* @returns {String|undefined} An error message if the value does not conform to the property, otherwise undefined.
|
* @private
|
*/
|
MetadataClassProperty.prototype.validate = function (value) {
|
var type = this._type;
|
var componentType = this._componentType;
|
|
if (MetadataType.isVectorType(type) || MetadataType.isMatrixType(type)) {
|
return validateVectorOrMatrix(value, type, componentType);
|
} else if (type === MetadataType.ARRAY) {
|
return validateArray(this, value, this._componentCount);
|
}
|
|
return checkValue(this, value);
|
};
|
|
function validateArray(classProperty, value, componentCount) {
|
if (!Array.isArray(value)) {
|
return getTypeErrorMessage(value, MetadataType.ARRAY);
|
}
|
var length = value.length;
|
if (defined(componentCount) && componentCount !== length) {
|
return "Array length does not match componentCount";
|
}
|
for (var i = 0; i < length; ++i) {
|
var message = checkValue(classProperty, value[i]);
|
if (defined(message)) {
|
return message;
|
}
|
}
|
}
|
|
function validateVectorOrMatrix(value, type, componentType) {
|
if (!MetadataComponentType.isVectorCompatible(componentType)) {
|
var message = "componentType " + componentType + " is incompatible with ";
|
if (MetadataType.isVectorType(type)) {
|
return message + "vector type " + type;
|
}
|
|
return message + "matrix type " + type;
|
}
|
|
if (type === MetadataType.VEC2 && !(value instanceof Cartesian2)) {
|
return "vector value " + value + " must be a Cartesian2";
|
}
|
|
if (type === MetadataType.VEC3 && !(value instanceof Cartesian3)) {
|
return "vector value " + value + " must be a Cartesian3";
|
}
|
|
if (type === MetadataType.VEC4 && !(value instanceof Cartesian4)) {
|
return "vector value " + value + " must be a Cartesian4";
|
}
|
|
if (type === MetadataType.MAT2 && !(value instanceof Matrix2)) {
|
return "matrix value " + value + " must be a Matrix2";
|
}
|
|
if (type === MetadataType.MAT3 && !(value instanceof Matrix3)) {
|
return "matrix value " + value + " must be a Matrix3";
|
}
|
|
if (type === MetadataType.MAT4 && !(value instanceof Matrix4)) {
|
return "matrix value " + value + " must be a Matrix4";
|
}
|
}
|
|
function getTypeErrorMessage(value, type) {
|
return "value " + value + " does not match type " + type;
|
}
|
|
function getOutOfRangeErrorMessage(value, type, normalized) {
|
var errorMessage = "value " + value + " is out of range for type " + type;
|
if (normalized) {
|
errorMessage += " (normalized)";
|
}
|
return errorMessage;
|
}
|
|
function checkInRange(value, componentType, normalized) {
|
if (normalized) {
|
var min = MetadataComponentType.isUnsignedIntegerType(componentType)
|
? 0.0
|
: -1.0;
|
var max = 1.0;
|
if (value < min || value > max) {
|
return getOutOfRangeErrorMessage(value, componentType, normalized);
|
}
|
return;
|
}
|
|
if (
|
value < MetadataComponentType.getMinimum(componentType) ||
|
value > MetadataComponentType.getMaximum(componentType)
|
) {
|
return getOutOfRangeErrorMessage(value, componentType, normalized);
|
}
|
}
|
|
function getNonFiniteErrorMessage(value, type) {
|
return "value " + value + " of type " + type + " must be finite";
|
}
|
|
function checkValue(classProperty, value) {
|
var javascriptType = typeof value;
|
|
var enumType = classProperty._enumType;
|
if (defined(enumType)) {
|
if (javascriptType !== "string" || !defined(enumType.valuesByName[value])) {
|
return "value " + value + " is not a valid enum name for " + enumType.id;
|
}
|
return;
|
}
|
|
var valueType = classProperty._valueType;
|
var normalized = classProperty._normalized;
|
|
switch (valueType) {
|
case MetadataComponentType.INT8:
|
case MetadataComponentType.UINT8:
|
case MetadataComponentType.INT16:
|
case MetadataComponentType.UINT16:
|
case MetadataComponentType.INT32:
|
case MetadataComponentType.UINT32:
|
if (javascriptType !== "number") {
|
return getTypeErrorMessage(value, valueType);
|
}
|
return checkInRange(value, valueType, normalized);
|
case MetadataComponentType.INT64:
|
case MetadataComponentType.UINT64:
|
if (javascriptType !== "number" && javascriptType !== "bigint") {
|
return getTypeErrorMessage(value, valueType);
|
}
|
return checkInRange(value, valueType, normalized);
|
case MetadataComponentType.FLOAT32:
|
if (javascriptType !== "number") {
|
return getTypeErrorMessage(value, valueType);
|
}
|
if (isFinite(value)) {
|
return checkInRange(value, valueType, normalized);
|
}
|
return getNonFiniteErrorMessage(value, valueType);
|
case MetadataComponentType.FLOAT64:
|
if (javascriptType !== "number") {
|
return getTypeErrorMessage(value, valueType);
|
}
|
if (isFinite(value)) {
|
return checkInRange(value, valueType, normalized);
|
}
|
return getNonFiniteErrorMessage(value, valueType);
|
case MetadataComponentType.BOOLEAN:
|
if (javascriptType !== "boolean") {
|
return getTypeErrorMessage(value, valueType);
|
}
|
break;
|
case MetadataComponentType.STRING:
|
if (javascriptType !== "string") {
|
return getTypeErrorMessage(value, valueType);
|
}
|
break;
|
}
|
}
|
|
function normalize(classProperty, value, normalizeFunction) {
|
var normalized = classProperty._normalized;
|
if (!normalized) {
|
return value;
|
}
|
|
var type = classProperty._type;
|
var valueType = classProperty._valueType;
|
|
var i;
|
var length;
|
if (type === MetadataType.ARRAY) {
|
length = value.length;
|
for (i = 0; i < length; ++i) {
|
value[i] = normalizeFunction(value[i], valueType);
|
}
|
} else if (
|
MetadataType.isVectorType(type) ||
|
MetadataType.isMatrixType(type)
|
) {
|
length = MetadataType.getComponentCount(type);
|
for (i = 0; i < length; ++i) {
|
value[i] = normalizeFunction(value[i], valueType);
|
}
|
} else {
|
value = normalizeFunction(value, valueType);
|
}
|
|
return value;
|
}
|
|
function getValueType(componentType, enumType) {
|
if (componentType === MetadataComponentType.ENUM) {
|
return enumType.valueType;
|
}
|
|
return componentType;
|
}
|
|
export default MetadataClassProperty;
|
