@loaders.gl/math 3.1.3 → 4.0.0-alpha.5

package/dist/geometry/compression/attribute-compression.js

@@ -1,352 +1,175 @@
-"use strict";
-// This file is derived from the Cesium code base under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.zigZagDeltaDecode = exports.decompressTextureCoordinates = exports.compressTextureCoordinates = exports.octUnpack = exports.octPack = exports.octDecodeFloat = exports.octEncodeFloat = exports.octPackFloat = exports.octDecodeFromVector4 = exports.octDecode = exports.octDecodeInRange = exports.octEncodeToVector4 = exports.octEncode = exports.octEncodeInRange = void 0;
-// Attribute compression and decompression functions.
-const core_1 = require("@math.gl/core");
-const assert_1 = require("../utils/assert");
+import { Vector2, Vector3, clamp, _MathUtils } from '@math.gl/core';
+import { assert } from '../utils/assert';
 const RIGHT_SHIFT = 1.0 / 256.0;
 const LEFT_SHIFT = 256.0;
-const scratchVector2 = new core_1.Vector2();
-const scratchVector3 = new core_1.Vector3();
-const scratchEncodeVector2 = new core_1.Vector2();
-const octEncodeScratch = new core_1.Vector2();
+const scratchVector2 = new Vector2();
+const scratchVector3 = new Vector3();
+const scratchEncodeVector2 = new Vector2();
+const octEncodeScratch = new Vector2();
 const uint8ForceArray = new Uint8Array(1);
-/**
- * Force a value to Uint8
- *
- * @param value
- * @returns
- */
+
 function forceUint8(value) {
-    uint8ForceArray[0] = value;
-    return uint8ForceArray[0];
+  uint8ForceArray[0] = value;
+  return uint8ForceArray[0];
 }
-/**
- * Converts a SNORM value in the range [0, rangeMaximum] to a scalar in the range [-1.0, 1.0].
- *
- * @param value SNORM value in the range [0, rangeMaximum]
- * @param [rangeMaximum=255] The maximum value in the SNORM range, 255 by default.
- * @returns Scalar in the range [-1.0, 1.0].
- *
- * @see CesiumMath.toSNorm
- */
+
 function fromSNorm(value, rangeMaximum = 255) {
-    return ((0, core_1.clamp)(value, 0.0, rangeMaximum) / rangeMaximum) * 2.0 - 1.0;
+  return clamp(value, 0.0, rangeMaximum) / rangeMaximum * 2.0 - 1.0;
 }
-/**
- * Converts a scalar value in the range [-1.0, 1.0] to a SNORM in the range [0, rangeMaximum].
- *
- * @param value The scalar value in the range [-1.0, 1.0]
- * @param [rangeMaximum=255] The maximum value in the mapped range, 255 by default.
- * @returns A SNORM value, where 0 maps to -1.0 and rangeMaximum maps to 1.0.
- *
- * @see CesiumMath.fromSNorm
- */
+
 function toSNorm(value, rangeMaximum = 255) {
-    return Math.round(((0, core_1.clamp)(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMaximum);
+  return Math.round((clamp(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMaximum);
 }
-/**
- * Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.
- * This is similar to `Math.sign` except that returns 1.0 instead of
- * 0.0 when the input value is 0.0.
- *
- * @param value The value to return the sign of.
- * @returns The sign of value.
- */
+
 function signNotZero(value) {
-    return value < 0.0 ? -1.0 : 1.0;
-}
-/**
- * Encodes a normalized vector into 2 SNORM values in the range of [0-rangeMax] following the 'oct' encoding.
- *
- * Oct encoding is a compact representation of unit length vectors.
- * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
- * Cigolle et al 2014: {@link http://jcgt.org/published/0003/02/01/}
- *
- * @param vector The normalized vector to be compressed into 2 component 'oct' encoding.
- * @param result The 2 component oct-encoded unit length vector.
- * @param rangeMax The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.
- * @returns The 2 component oct-encoded unit length vector.
- *
- * @exception vector must be normalized.
- *
- * @see octDecodeInRange
- */
-function octEncodeInRange(vector, rangeMax, result) {
-    (0, assert_1.assert)(vector);
-    (0, assert_1.assert)(result);
-    const vector3 = scratchVector3.from(vector);
-    (0, assert_1.assert)(Math.abs(vector3.magnitudeSquared() - 1.0) <= core_1._MathUtils.EPSILON6);
-    result.x = vector.x / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
-    result.y = vector.y / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
-    if (vector.z < 0) {
-        const x = result.x;
-        const y = result.y;
-        result.x = (1.0 - Math.abs(y)) * signNotZero(x);
-        result.y = (1.0 - Math.abs(x)) * signNotZero(y);
-    }
-    result.x = toSNorm(result.x, rangeMax);
-    result.y = toSNorm(result.y, rangeMax);
-    return result;
-}
-exports.octEncodeInRange = octEncodeInRange;
-/**
- * Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding.
- *
- * @param vector The normalized vector to be compressed into 2 byte 'oct' encoding.
- * @param result The 2 byte oct-encoded unit length vector.
- * @returns he 2 byte oct-encoded unit length vector.
- *
- * @exception vector must be normalized.
- *
- * @see octEncodeInRange
- * @see octDecode
- */
-function octEncode(vector, result) {
-    return octEncodeInRange(vector, 255, result);
-}
-exports.octEncode = octEncode;
-/**
- * Encodes a normalized vector into 4-byte vector
- * @param vector The normalized vector to be compressed into 4 byte 'oct' encoding.
- * @param result The 4 byte oct-encoded unit length vector.
- * @returns The 4 byte oct-encoded unit length vector.
- *
- * @exception vector must be normalized.
- *
- * @see octEncodeInRange
- * @see octDecodeFromVector4
- */
-function octEncodeToVector4(vector, result) {
-    octEncodeInRange(vector, 65535, octEncodeScratch);
-    result.x = forceUint8(octEncodeScratch.x * RIGHT_SHIFT);
-    result.y = forceUint8(octEncodeScratch.x);
-    result.z = forceUint8(octEncodeScratch.y * RIGHT_SHIFT);
-    result.w = forceUint8(octEncodeScratch.y);
-    return result;
-}
-exports.octEncodeToVector4 = octEncodeToVector4;
-/**
- * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component vector.
- *
- * @param x The x component of the oct-encoded unit length vector.
- * @param y The y component of the oct-encoded unit length vector.
- * @param rangeMax The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.
- * @param result The decoded and normalized vector
- * @returns The decoded and normalized vector.
- *
- * @exception x and y must be unsigned normalized integers between 0 and rangeMax.
- *
- * @see octEncodeInRange
- */
-function octDecodeInRange(x, y, rangeMax, result) {
-    (0, assert_1.assert)(result);
-    if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {
-        throw new Error(`x and y must be unsigned normalized integers between 0 and ${rangeMax}`);
-    }
-    result.x = fromSNorm(x, rangeMax);
-    result.y = fromSNorm(y, rangeMax);
-    result.z = 1.0 - (Math.abs(result.x) + Math.abs(result.y));
-    if (result.z < 0.0) {
-        const oldVX = result.x;
-        result.x = (1.0 - Math.abs(result.y)) * signNotZero(oldVX);
-        result.y = (1.0 - Math.abs(oldVX)) * signNotZero(result.y);
-    }
-    return result.normalize();
-}
-exports.octDecodeInRange = octDecodeInRange;
-/**
- * Decodes a unit-length vector in 2 byte 'oct' encoding to a normalized 3-component vector.
- *
- * @param x The x component of the oct-encoded unit length vector.
- * @param y The y component of the oct-encoded unit length vector.
- * @param result The decoded and normalized vector.
- * @returns he decoded and normalized vector.
- *
- * @exception x and y must be an unsigned normalized integer between 0 and 255.
- *
- * @see octDecodeInRange
- */
-function octDecode(x, y, result) {
-    return octDecodeInRange(x, y, 255, result);
-}
-exports.octDecode = octDecode;
-/**
- * Decodes a unit-length vector in 4 byte 'oct' encoding to a normalized 3-component vector.
- *
- * @param encoded The oct-encoded unit length vector.
- * @param esult The decoded and normalized vector.
- * @returns The decoded and normalized vector.
- *
- * @exception x, y, z, and w must be unsigned normalized integers between 0 and 255.
- *
- * @see octDecodeInRange
- * @see octEncodeToVector4
- */
-function octDecodeFromVector4(encoded, result) {
-    (0, assert_1.assert)(encoded);
-    (0, assert_1.assert)(result);
-    const x = encoded.x;
-    const y = encoded.y;
-    const z = encoded.z;
-    const w = encoded.w;
-    if (x < 0 || x > 255 || y < 0 || y > 255 || z < 0 || z > 255 || w < 0 || w > 255) {
-        throw new Error('x, y, z, and w must be unsigned normalized integers between 0 and 255');
-    }
-    const xOct16 = x * LEFT_SHIFT + y;
-    const yOct16 = z * LEFT_SHIFT + w;
-    return octDecodeInRange(xOct16, yOct16, 65535, result);
-}
-exports.octDecodeFromVector4 = octDecodeFromVector4;
-/**
- * Packs an oct encoded vector into a single floating-point number.
- *
- * @param encoded The oct encoded vector.
- * @returns The oct encoded vector packed into a single float.
- *
- */
-function octPackFloat(encoded) {
-    const vector2 = scratchVector2.from(encoded);
-    return 256.0 * vector2.x + vector2.y;
-}
-exports.octPackFloat = octPackFloat;
-/**
- * Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding and
- * stores those values in a single float-point number.
- *
- * @param vector The normalized vector to be compressed into 2 byte 'oct' encoding.
- * @returns The 2 byte oct-encoded unit length vector.
- *
- * @exception vector must be normalized.
- */
-function octEncodeFloat(vector) {
-    octEncode(vector, scratchEncodeVector2);
-    return octPackFloat(scratchEncodeVector2);
-}
-exports.octEncodeFloat = octEncodeFloat;
-/**
- * Decodes a unit-length vector in 'oct' encoding packed in a floating-point number to a normalized 3-component vector.
- *
- * @param value The oct-encoded unit length vector stored as a single floating-point number.
- * @param result The decoded and normalized vector
- * @returns The decoded and normalized vector.
- *
- */
-function octDecodeFloat(value, result) {
-    (0, assert_1.assert)(Number.isFinite(value));
-    const temp = value / 256.0;
-    const x = Math.floor(temp);
-    const y = (temp - x) * 256.0;
-    return octDecode(x, y, result);
-}
-exports.octDecodeFloat = octDecodeFloat;
-/**
- * Encodes three normalized vectors into 6 SNORM values in the range of [0-255] following the 'oct' encoding and
- * packs those into two floating-point numbers.
- *
- * @param v1 A normalized vector to be compressed.
- * @param v2 A normalized vector to be compressed.
- * @param v3 A normalized vector to be compressed.
- * @param result The 'oct' encoded vectors packed into two floating-point numbers.
- * @returns The 'oct' encoded vectors packed into two floating-point numbers.
- *
- */
-function octPack(v1, v2, v3, result) {
-    (0, assert_1.assert)(v1);
-    (0, assert_1.assert)(v2);
-    (0, assert_1.assert)(v3);
-    (0, assert_1.assert)(result);
-    const encoded1 = octEncodeFloat(v1);
-    const encoded2 = octEncodeFloat(v2);
-    const encoded3 = octEncode(v3, scratchEncodeVector2);
-    result.x = 65536.0 * encoded3.x + encoded1;
-    result.y = 65536.0 * encoded3.y + encoded2;
-    return result;
-}
-exports.octPack = octPack;
-/**
- * Decodes three unit-length vectors in 'oct' encoding packed into a floating-point number to a normalized 3-component vector.
- *
- * @param packed The three oct-encoded unit length vectors stored as two floating-point number.
- * @param v1 One decoded and normalized vector.
- * @param v2 One decoded and normalized vector.
- * @param v3 One decoded and normalized vector.
- */
-function octUnpack(packed, v1, v2, v3) {
-    let temp = packed.x / 65536.0;
-    const x = Math.floor(temp);
-    const encodedFloat1 = (temp - x) * 65536.0;
-    temp = packed.y / 65536.0;
-    const y = Math.floor(temp);
-    const encodedFloat2 = (temp - y) * 65536.0;
-    octDecodeFloat(encodedFloat1, v1);
-    octDecodeFloat(encodedFloat2, v2);
-    octDecode(x, y, v3);
-}
-exports.octUnpack = octUnpack;
-/**
- * Pack texture coordinates into a single float. The texture coordinates will only preserve 12 bits of precision.
- *
- * @param textureCoordinates The texture coordinates to compress.  Both coordinates must be in the range 0.0-1.0.
- * @returns The packed texture coordinates.
- *
- */
-function compressTextureCoordinates(textureCoordinates) {
-    // Move x and y to the range 0-4095;
-    const x = (textureCoordinates.x * 4095.0) | 0;
-    const y = (textureCoordinates.y * 4095.0) | 0;
-    return 4096.0 * x + y;
-}
-exports.compressTextureCoordinates = compressTextureCoordinates;
-/**
- * Decompresses texture coordinates that were packed into a single float.
- *
- * @param compressed The compressed texture coordinates.
- * @param result The decompressed texture coordinates.
- * @returns The modified result parameter.
- *
- */
-function decompressTextureCoordinates(compressed, result) {
-    const temp = compressed / 4096.0;
-    const xZeroTo4095 = Math.floor(temp);
-    result.x = xZeroTo4095 / 4095.0;
-    result.y = (compressed - xZeroTo4095 * 4096) / 4095;
-    return result;
-}
-exports.decompressTextureCoordinates = decompressTextureCoordinates;
-/**
- * Decodes delta and ZigZag encoded vertices. This modifies the buffers in place.
- *
- * @param uBuffer The buffer view of u values.
- * @param vBuffer The buffer view of v values.
- * @param [heightBuffer] The buffer view of height values.
- *
- * @link https://github.com/AnalyticalGraphicsInc/quantized-mesh|quantized-mesh-1.0 terrain format
- */
-function zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer) {
-    (0, assert_1.assert)(uBuffer);
-    (0, assert_1.assert)(vBuffer);
-    (0, assert_1.assert)(uBuffer.length === vBuffer.length);
+  return value < 0.0 ? -1.0 : 1.0;
+}
+
+export function octEncodeInRange(vector, rangeMax, result) {
+  assert(vector);
+  assert(result);
+  const vector3 = scratchVector3.from(vector);
+  assert(Math.abs(vector3.magnitudeSquared() - 1.0) <= _MathUtils.EPSILON6);
+  result.x = vector.x / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
+  result.y = vector.y / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
+
+  if (vector.z < 0) {
+    const x = result.x;
+    const y = result.y;
+    result.x = (1.0 - Math.abs(y)) * signNotZero(x);
+    result.y = (1.0 - Math.abs(x)) * signNotZero(y);
+  }
+
+  result.x = toSNorm(result.x, rangeMax);
+  result.y = toSNorm(result.y, rangeMax);
+  return result;
+}
+export function octEncode(vector, result) {
+  return octEncodeInRange(vector, 255, result);
+}
+export function octEncodeToVector4(vector, result) {
+  octEncodeInRange(vector, 65535, octEncodeScratch);
+  result.x = forceUint8(octEncodeScratch.x * RIGHT_SHIFT);
+  result.y = forceUint8(octEncodeScratch.x);
+  result.z = forceUint8(octEncodeScratch.y * RIGHT_SHIFT);
+  result.w = forceUint8(octEncodeScratch.y);
+  return result;
+}
+export function octDecodeInRange(x, y, rangeMax, result) {
+  assert(result);
+
+  if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {
+    throw new Error("x and y must be unsigned normalized integers between 0 and ".concat(rangeMax));
+  }
+
+  result.x = fromSNorm(x, rangeMax);
+  result.y = fromSNorm(y, rangeMax);
+  result.z = 1.0 - (Math.abs(result.x) + Math.abs(result.y));
+
+  if (result.z < 0.0) {
+    const oldVX = result.x;
+    result.x = (1.0 - Math.abs(result.y)) * signNotZero(oldVX);
+    result.y = (1.0 - Math.abs(oldVX)) * signNotZero(result.y);
+  }
+
+  return result.normalize();
+}
+export function octDecode(x, y, result) {
+  return octDecodeInRange(x, y, 255, result);
+}
+export function octDecodeFromVector4(encoded, result) {
+  assert(encoded);
+  assert(result);
+  const x = encoded.x;
+  const y = encoded.y;
+  const z = encoded.z;
+  const w = encoded.w;
+
+  if (x < 0 || x > 255 || y < 0 || y > 255 || z < 0 || z > 255 || w < 0 || w > 255) {
+    throw new Error('x, y, z, and w must be unsigned normalized integers between 0 and 255');
+  }
+
+  const xOct16 = x * LEFT_SHIFT + y;
+  const yOct16 = z * LEFT_SHIFT + w;
+  return octDecodeInRange(xOct16, yOct16, 65535, result);
+}
+export function octPackFloat(encoded) {
+  const vector2 = scratchVector2.from(encoded);
+  return 256.0 * vector2.x + vector2.y;
+}
+export function octEncodeFloat(vector) {
+  octEncode(vector, scratchEncodeVector2);
+  return octPackFloat(scratchEncodeVector2);
+}
+export function octDecodeFloat(value, result) {
+  assert(Number.isFinite(value));
+  const temp = value / 256.0;
+  const x = Math.floor(temp);
+  const y = (temp - x) * 256.0;
+  return octDecode(x, y, result);
+}
+export function octPack(v1, v2, v3, result) {
+  assert(v1);
+  assert(v2);
+  assert(v3);
+  assert(result);
+  const encoded1 = octEncodeFloat(v1);
+  const encoded2 = octEncodeFloat(v2);
+  const encoded3 = octEncode(v3, scratchEncodeVector2);
+  result.x = 65536.0 * encoded3.x + encoded1;
+  result.y = 65536.0 * encoded3.y + encoded2;
+  return result;
+}
+export function octUnpack(packed, v1, v2, v3) {
+  let temp = packed.x / 65536.0;
+  const x = Math.floor(temp);
+  const encodedFloat1 = (temp - x) * 65536.0;
+  temp = packed.y / 65536.0;
+  const y = Math.floor(temp);
+  const encodedFloat2 = (temp - y) * 65536.0;
+  octDecodeFloat(encodedFloat1, v1);
+  octDecodeFloat(encodedFloat2, v2);
+  octDecode(x, y, v3);
+}
+export function compressTextureCoordinates(textureCoordinates) {
+  const x = textureCoordinates.x * 4095.0 | 0;
+  const y = textureCoordinates.y * 4095.0 | 0;
+  return 4096.0 * x + y;
+}
+export function decompressTextureCoordinates(compressed, result) {
+  const temp = compressed / 4096.0;
+  const xZeroTo4095 = Math.floor(temp);
+  result.x = xZeroTo4095 / 4095.0;
+  result.y = (compressed - xZeroTo4095 * 4096) / 4095;
+  return result;
+}
+export function zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer) {
+  assert(uBuffer);
+  assert(vBuffer);
+  assert(uBuffer.length === vBuffer.length);
+
+  if (heightBuffer) {
+    assert(uBuffer.length === heightBuffer.length);
+  }
+
+  function zigZagDecode(value) {
+    return value >> 1 ^ -(value & 1);
+  }
+
+  let u = 0;
+  let v = 0;
+  let height = 0;
+
+  for (let i = 0; i < uBuffer.length; ++i) {
+    u += zigZagDecode(uBuffer[i]);
+    v += zigZagDecode(vBuffer[i]);
+    uBuffer[i] = u;
+    vBuffer[i] = v;
+
     if (heightBuffer) {
-        (0, assert_1.assert)(uBuffer.length === heightBuffer.length);
-    }
-    function zigZagDecode(value) {
-        return (value >> 1) ^ -(value & 1);
-    }
-    let u = 0;
-    let v = 0;
-    let height = 0;
-    for (let i = 0; i < uBuffer.length; ++i) {
-        u += zigZagDecode(uBuffer[i]);
-        v += zigZagDecode(vBuffer[i]);
-        uBuffer[i] = u;
-        vBuffer[i] = v;
-        if (heightBuffer) {
-            height += zigZagDecode(heightBuffer[i]);
-            heightBuffer[i] = height;
-        }
+      height += zigZagDecode(heightBuffer[i]);
+      heightBuffer[i] = height;
     }
+  }
 }
-exports.zigZagDeltaDecode = zigZagDeltaDecode;
+//# sourceMappingURL=attribute-compression.js.map

package/dist/geometry/compression/attribute-compression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/geometry/compression/attribute-compression.ts"],"names":["Vector2","Vector3","clamp","_MathUtils","assert","RIGHT_SHIFT","LEFT_SHIFT","scratchVector2","scratchVector3","scratchEncodeVector2","octEncodeScratch","uint8ForceArray","Uint8Array","forceUint8","value","fromSNorm","rangeMaximum","toSNorm","Math","round","signNotZero","octEncodeInRange","vector","rangeMax","result","vector3","from","abs","magnitudeSquared","EPSILON6","x","y","z","octEncode","octEncodeToVector4","w","octDecodeInRange","Error","oldVX","normalize","octDecode","octDecodeFromVector4","encoded","xOct16","yOct16","octPackFloat","vector2","octEncodeFloat","octDecodeFloat","Number","isFinite","temp","floor","octPack","v1","v2","v3","encoded1","encoded2","encoded3","octUnpack","packed","encodedFloat1","encodedFloat2","compressTextureCoordinates","textureCoordinates","decompressTextureCoordinates","compressed","xZeroTo4095","zigZagDeltaDecode","uBuffer","vBuffer","heightBuffer","length","zigZagDecode","u","v","height","i"],"mappings":"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","sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n// Attribute compression and decompression functions.\n\nimport {Vector2, Vector3, clamp, _MathUtils} from '@math.gl/core';\nimport {Vector4} from '../types';\nimport {assert} from '../utils/assert';\n\nconst RIGHT_SHIFT = 1.0 / 256.0;\nconst LEFT_SHIFT = 256.0;\n\nconst scratchVector2 = new Vector2();\nconst scratchVector3 = new Vector3();\nconst scratchEncodeVector2 = new Vector2();\nconst octEncodeScratch = new Vector2();\n\nconst uint8ForceArray = new Uint8Array(1);\n\n/**\n * Force a value to Uint8\n *\n * @param value\n * @returns\n */\nfunction forceUint8(value: number): number {\n  uint8ForceArray[0] = value;\n  return uint8ForceArray[0];\n}\n\n/**\n * Converts a SNORM value in the range [0, rangeMaximum] to a scalar in the range [-1.0, 1.0].\n *\n * @param value SNORM value in the range [0, rangeMaximum]\n * @param [rangeMaximum=255] The maximum value in the SNORM range, 255 by default.\n * @returns Scalar in the range [-1.0, 1.0].\n *\n * @see CesiumMath.toSNorm\n */\nfunction fromSNorm(value: number, rangeMaximum = 255): number {\n  return (clamp(value, 0.0, rangeMaximum) / rangeMaximum) * 2.0 - 1.0;\n}\n\n/**\n * Converts a scalar value in the range [-1.0, 1.0] to a SNORM in the range [0, rangeMaximum].\n *\n * @param value The scalar value in the range [-1.0, 1.0]\n * @param [rangeMaximum=255] The maximum value in the mapped range, 255 by default.\n * @returns A SNORM value, where 0 maps to -1.0 and rangeMaximum maps to 1.0.\n *\n * @see CesiumMath.fromSNorm\n */\nfunction toSNorm(value: number, rangeMaximum = 255): number {\n  return Math.round((clamp(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMaximum);\n}\n\n/**\n * Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.\n * This is similar to `Math.sign` except that returns 1.0 instead of\n * 0.0 when the input value is 0.0.\n *\n * @param value The value to return the sign of.\n * @returns The sign of value.\n */\nfunction signNotZero(value: number): number {\n  return value < 0.0 ? -1.0 : 1.0;\n}\n\n/**\n * Encodes a normalized vector into 2 SNORM values in the range of [0-rangeMax] following the 'oct' encoding.\n *\n * Oct encoding is a compact representation of unit length vectors.\n * The 'oct' encoding is described in \"A Survey of Efficient Representations of Independent Unit Vectors\",\n * Cigolle et al 2014: {@link http://jcgt.org/published/0003/02/01/}\n *\n * @param vector The normalized vector to be compressed into 2 component 'oct' encoding.\n * @param result The 2 component oct-encoded unit length vector.\n * @param rangeMax The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.\n * @returns The 2 component oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n *\n * @see octDecodeInRange\n */\nexport function octEncodeInRange(vector: Vector3, rangeMax: number, result: Vector2): Vector2 {\n  assert(vector);\n  assert(result);\n\n  const vector3 = scratchVector3.from(vector);\n\n  assert(Math.abs(vector3.magnitudeSquared() - 1.0) <= _MathUtils.EPSILON6);\n\n  result.x = vector.x / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));\n  result.y = vector.y / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));\n\n  if (vector.z < 0) {\n    const x = result.x;\n    const y = result.y;\n    result.x = (1.0 - Math.abs(y)) * signNotZero(x);\n    result.y = (1.0 - Math.abs(x)) * signNotZero(y);\n  }\n\n  result.x = toSNorm(result.x, rangeMax);\n  result.y = toSNorm(result.y, rangeMax);\n\n  return result;\n}\n\n/**\n * Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding.\n *\n * @param vector The normalized vector to be compressed into 2 byte 'oct' encoding.\n * @param result The 2 byte oct-encoded unit length vector.\n * @returns he 2 byte oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n *\n * @see octEncodeInRange\n * @see octDecode\n */\nexport function octEncode(vector: Vector3, result: Vector2): Vector2 {\n  return octEncodeInRange(vector, 255, result);\n}\n\n/**\n * Encodes a normalized vector into 4-byte vector\n * @param vector The normalized vector to be compressed into 4 byte 'oct' encoding.\n * @param result The 4 byte oct-encoded unit length vector.\n * @returns The 4 byte oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n *\n * @see octEncodeInRange\n * @see octDecodeFromVector4\n */\nexport function octEncodeToVector4(vector: Vector3, result: Vector4): Vector4 {\n  octEncodeInRange(vector, 65535, octEncodeScratch);\n  result.x = forceUint8(octEncodeScratch.x * RIGHT_SHIFT);\n  result.y = forceUint8(octEncodeScratch.x);\n  result.z = forceUint8(octEncodeScratch.y * RIGHT_SHIFT);\n  result.w = forceUint8(octEncodeScratch.y);\n  return result;\n}\n\n/**\n * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component vector.\n *\n * @param x The x component of the oct-encoded unit length vector.\n * @param y The y component of the oct-encoded unit length vector.\n * @param rangeMax The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.\n * @param result The decoded and normalized vector\n * @returns The decoded and normalized vector.\n *\n * @exception x and y must be unsigned normalized integers between 0 and rangeMax.\n *\n * @see octEncodeInRange\n */\nexport function octDecodeInRange(x: number, y: number, rangeMax: number, result: Vector3): Vector3 {\n  assert(result);\n  if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {\n    throw new Error(`x and y must be unsigned normalized integers between 0 and ${rangeMax}`);\n  }\n\n  result.x = fromSNorm(x, rangeMax);\n  result.y = fromSNorm(y, rangeMax);\n  result.z = 1.0 - (Math.abs(result.x) + Math.abs(result.y));\n\n  if (result.z < 0.0) {\n    const oldVX = result.x;\n    result.x = (1.0 - Math.abs(result.y)) * signNotZero(oldVX);\n    result.y = (1.0 - Math.abs(oldVX)) * signNotZero(result.y);\n  }\n\n  return result.normalize();\n}\n\n/**\n * Decodes a unit-length vector in 2 byte 'oct' encoding to a normalized 3-component vector.\n *\n * @param x The x component of the oct-encoded unit length vector.\n * @param y The y component of the oct-encoded unit length vector.\n * @param result The decoded and normalized vector.\n * @returns he decoded and normalized vector.\n *\n * @exception x and y must be an unsigned normalized integer between 0 and 255.\n *\n * @see octDecodeInRange\n */\nexport function octDecode(x: number, y: number, result: Vector3): Vector3 {\n  return octDecodeInRange(x, y, 255, result);\n}\n\n/**\n * Decodes a unit-length vector in 4 byte 'oct' encoding to a normalized 3-component vector.\n *\n * @param encoded The oct-encoded unit length vector.\n * @param esult The decoded and normalized vector.\n * @returns The decoded and normalized vector.\n *\n * @exception x, y, z, and w must be unsigned normalized integers between 0 and 255.\n *\n * @see octDecodeInRange\n * @see octEncodeToVector4\n */\nexport function octDecodeFromVector4(encoded: Vector4, result: Vector3): Vector3 {\n  assert(encoded);\n  assert(result);\n  const x = encoded.x;\n  const y = encoded.y;\n  const z = encoded.z;\n  const w = encoded.w;\n\n  if (x < 0 || x > 255 || y < 0 || y > 255 || z < 0 || z > 255 || w < 0 || w > 255) {\n    throw new Error('x, y, z, and w must be unsigned normalized integers between 0 and 255');\n  }\n\n  const xOct16 = x * LEFT_SHIFT + y;\n  const yOct16 = z * LEFT_SHIFT + w;\n  return octDecodeInRange(xOct16, yOct16, 65535, result);\n}\n\n/**\n * Packs an oct encoded vector into a single floating-point number.\n *\n * @param encoded The oct encoded vector.\n * @returns The oct encoded vector packed into a single float.\n *\n */\nexport function octPackFloat(encoded: Vector2): number {\n  const vector2 = scratchVector2.from(encoded);\n  return 256.0 * vector2.x + vector2.y;\n}\n\n/**\n * Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding and\n * stores those values in a single float-point number.\n *\n * @param vector The normalized vector to be compressed into 2 byte 'oct' encoding.\n * @returns The 2 byte oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n */\nexport function octEncodeFloat(vector: Vector3): number {\n  octEncode(vector, scratchEncodeVector2);\n  return octPackFloat(scratchEncodeVector2);\n}\n\n/**\n * Decodes a unit-length vector in 'oct' encoding packed in a floating-point number to a normalized 3-component vector.\n *\n * @param value The oct-encoded unit length vector stored as a single floating-point number.\n * @param result The decoded and normalized vector\n * @returns The decoded and normalized vector.\n *\n */\nexport function octDecodeFloat(value: number, result: Vector3): Vector3 {\n  assert(Number.isFinite(value));\n\n  const temp = value / 256.0;\n  const x = Math.floor(temp);\n  const y = (temp - x) * 256.0;\n\n  return octDecode(x, y, result);\n}\n\n/**\n * Encodes three normalized vectors into 6 SNORM values in the range of [0-255] following the 'oct' encoding and\n * packs those into two floating-point numbers.\n *\n * @param v1 A normalized vector to be compressed.\n * @param v2 A normalized vector to be compressed.\n * @param v3 A normalized vector to be compressed.\n * @param result The 'oct' encoded vectors packed into two floating-point numbers.\n * @returns The 'oct' encoded vectors packed into two floating-point numbers.\n *\n */\nexport function octPack(v1: Vector3, v2: Vector3, v3: Vector3, result: Vector2): Vector2 {\n  assert(v1);\n  assert(v2);\n  assert(v3);\n  assert(result);\n\n  const encoded1 = octEncodeFloat(v1);\n  const encoded2 = octEncodeFloat(v2);\n\n  const encoded3 = octEncode(v3, scratchEncodeVector2);\n  result.x = 65536.0 * encoded3.x + encoded1;\n  result.y = 65536.0 * encoded3.y + encoded2;\n  return result;\n}\n\n/**\n * Decodes three unit-length vectors in 'oct' encoding packed into a floating-point number to a normalized 3-component vector.\n *\n * @param packed The three oct-encoded unit length vectors stored as two floating-point number.\n * @param v1 One decoded and normalized vector.\n * @param v2 One decoded and normalized vector.\n * @param v3 One decoded and normalized vector.\n */\nexport function octUnpack(packed: Vector2, v1: Vector3, v2: Vector3, v3: Vector3): void {\n  let temp = packed.x / 65536.0;\n  const x = Math.floor(temp);\n  const encodedFloat1 = (temp - x) * 65536.0;\n\n  temp = packed.y / 65536.0;\n  const y = Math.floor(temp);\n  const encodedFloat2 = (temp - y) * 65536.0;\n\n  octDecodeFloat(encodedFloat1, v1);\n  octDecodeFloat(encodedFloat2, v2);\n  octDecode(x, y, v3);\n}\n\n/**\n * Pack texture coordinates into a single float. The texture coordinates will only preserve 12 bits of precision.\n *\n * @param textureCoordinates The texture coordinates to compress.  Both coordinates must be in the range 0.0-1.0.\n * @returns The packed texture coordinates.\n *\n */\nexport function compressTextureCoordinates(textureCoordinates: Vector2): number {\n  // Move x and y to the range 0-4095;\n  const x = (textureCoordinates.x * 4095.0) | 0;\n  const y = (textureCoordinates.y * 4095.0) | 0;\n  return 4096.0 * x + y;\n}\n\n/**\n * Decompresses texture coordinates that were packed into a single float.\n *\n * @param compressed The compressed texture coordinates.\n * @param result The decompressed texture coordinates.\n * @returns The modified result parameter.\n *\n */\nexport function decompressTextureCoordinates(compressed: number, result: Vector2): Vector2 {\n  const temp = compressed / 4096.0;\n  const xZeroTo4095 = Math.floor(temp);\n  result.x = xZeroTo4095 / 4095.0;\n  result.y = (compressed - xZeroTo4095 * 4096) / 4095;\n  return result;\n}\n\n/**\n * Decodes delta and ZigZag encoded vertices. This modifies the buffers in place.\n *\n * @param uBuffer The buffer view of u values.\n * @param vBuffer The buffer view of v values.\n * @param [heightBuffer] The buffer view of height values.\n *\n * @link https://github.com/AnalyticalGraphicsInc/quantized-mesh|quantized-mesh-1.0 terrain format\n */\nexport function zigZagDeltaDecode(\n  uBuffer: Uint16Array,\n  vBuffer: Uint16Array,\n  heightBuffer?: Uint16Array | number[]\n) {\n  assert(uBuffer);\n  assert(vBuffer);\n  assert(uBuffer.length === vBuffer.length);\n  if (heightBuffer) {\n    assert(uBuffer.length === heightBuffer.length);\n  }\n\n  function zigZagDecode(value: number) {\n    return (value >> 1) ^ -(value & 1);\n  }\n\n  let u = 0;\n  let v = 0;\n  let height = 0;\n\n  for (let i = 0; i < uBuffer.length; ++i) {\n    u += zigZagDecode(uBuffer[i]);\n    v += zigZagDecode(vBuffer[i]);\n\n    uBuffer[i] = u;\n    vBuffer[i] = v;\n\n    if (heightBuffer) {\n      height += zigZagDecode(heightBuffer[i]);\n      heightBuffer[i] = height;\n    }\n  }\n}\n"],"file":"attribute-compression.js"}

package/dist/geometry/constants.js

@@ -1,34 +1,28 @@
-"use strict";
-// Subset of WebGL constants
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GL = exports.GL_TYPE = exports.GL_PRIMITIVE_MODE = exports.GL_PRIMITIVE = void 0;
-exports.GL_PRIMITIVE = {
-    POINTS: 0x0000,
-    LINES: 0x0001,
-    TRIANGLES: 0x0004 // Triangles. Each set of three vertices creates a separate triangle.
+export const GL_PRIMITIVE = {
+  POINTS: 0x0000,
+  LINES: 0x0001,
+  TRIANGLES: 0x0004
 };
-// Primitive modes
-exports.GL_PRIMITIVE_MODE = {
-    POINTS: 0x0000,
-    LINES: 0x0001,
-    LINE_LOOP: 0x0002,
-    LINE_STRIP: 0x0003,
-    TRIANGLES: 0x0004,
-    TRIANGLE_STRIP: 0x0005,
-    TRIANGLE_FAN: 0x0006 // Triangles. A connected group of triangles.
-    // Each vertex connects to the previous and the first vertex in the fan.
+export const GL_PRIMITIVE_MODE = {
+  POINTS: 0x0000,
+  LINES: 0x0001,
+  LINE_LOOP: 0x0002,
+  LINE_STRIP: 0x0003,
+  TRIANGLES: 0x0004,
+  TRIANGLE_STRIP: 0x0005,
+  TRIANGLE_FAN: 0x0006
 };
-exports.GL_TYPE = {
-    BYTE: 5120,
-    UNSIGNED_BYTE: 5121,
-    SHORT: 5122,
-    UNSIGNED_SHORT: 5123,
-    INT: 5124,
-    UNSIGNED_INT: 5125,
-    FLOAT: 5126,
-    DOUBLE: 5130
+export const GL_TYPE = {
+  BYTE: 5120,
+  UNSIGNED_BYTE: 5121,
+  SHORT: 5122,
+  UNSIGNED_SHORT: 5123,
+  INT: 5124,
+  UNSIGNED_INT: 5125,
+  FLOAT: 5126,
+  DOUBLE: 5130
 };
-exports.GL = {
-    ...exports.GL_PRIMITIVE_MODE,
-    ...exports.GL_TYPE
+export const GL = { ...GL_PRIMITIVE_MODE,
+  ...GL_TYPE
 };
+//# sourceMappingURL=constants.js.map

package/dist/geometry/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/geometry/constants.ts"],"names":["GL_PRIMITIVE","POINTS","LINES","TRIANGLES","GL_PRIMITIVE_MODE","LINE_LOOP","LINE_STRIP","TRIANGLE_STRIP","TRIANGLE_FAN","GL_TYPE","BYTE","UNSIGNED_BYTE","SHORT","UNSIGNED_SHORT","INT","UNSIGNED_INT","FLOAT","DOUBLE","GL"],"mappings":"AAEA,OAAO,MAAMA,YAAY,GAAG;AAC1BC,EAAAA,MAAM,EAAE,MADkB;AAE1BC,EAAAA,KAAK,EAAE,MAFmB;AAG1BC,EAAAA,SAAS,EAAE;AAHe,CAArB;AAOP,OAAO,MAAMC,iBAAiB,GAAG;AAC/BH,EAAAA,MAAM,EAAE,MADuB;AAE/BC,EAAAA,KAAK,EAAE,MAFwB;AAG/BG,EAAAA,SAAS,EAAE,MAHoB;AAI/BC,EAAAA,UAAU,EAAE,MAJmB;AAK/BH,EAAAA,SAAS,EAAE,MALoB;AAM/BI,EAAAA,cAAc,EAAE,MANe;AAO/BC,EAAAA,YAAY,EAAE;AAPiB,CAA1B;AAsBP,OAAO,MAAMC,OAAe,GAAG;AAC7BC,EAAAA,IAAI,EAAE,IADuB;AAE7BC,EAAAA,aAAa,EAAE,IAFc;AAG7BC,EAAAA,KAAK,EAAE,IAHsB;AAI7BC,EAAAA,cAAc,EAAE,IAJa;AAK7BC,EAAAA,GAAG,EAAE,IALwB;AAM7BC,EAAAA,YAAY,EAAE,IANe;AAO7BC,EAAAA,KAAK,EAAE,IAPsB;AAQ7BC,EAAAA,MAAM,EAAE;AARqB,CAAxB;AAWP,OAAO,MAAMC,EAAE,GAAG,EAChB,GAAGd,iBADa;AAEhB,KAAGK;AAFa,CAAX","sourcesContent":["// Subset of WebGL constants\n\nexport const GL_PRIMITIVE = {\n  POINTS: 0x0000, // Points. single points.\n  LINES: 0x0001, // Lines. Each vertex connects to the one after it.\n  TRIANGLES: 0x0004 // Triangles. Each set of three vertices creates a separate triangle.\n};\n\n// Primitive modes\nexport const GL_PRIMITIVE_MODE = {\n  POINTS: 0x0000, // Points. single points.\n  LINES: 0x0001, // Lines. Each vertex connects to the one after it.\n  LINE_LOOP: 0x0002, // Lines. Each set of two vertices is treated as a separate line segment.\n  LINE_STRIP: 0x0003, // Lines/ a connected group of line segments from the first vertex to the last\n  TRIANGLES: 0x0004, // Triangles. Each set of three vertices creates a separate triangle.\n  TRIANGLE_STRIP: 0x0005, // Triangles. A connected group of triangles.\n  TRIANGLE_FAN: 0x0006 // Triangles. A connected group of triangles.\n  // Each vertex connects to the previous and the first vertex in the fan.\n};\n\ntype glType = {\n  BYTE: number;\n  UNSIGNED_BYTE: number;\n  SHORT: number;\n  UNSIGNED_SHORT: number;\n  INT: number;\n  UNSIGNED_INT: number;\n  FLOAT: number;\n  DOUBLE: number;\n};\n\nexport const GL_TYPE: glType = {\n  BYTE: 5120,\n  UNSIGNED_BYTE: 5121,\n  SHORT: 5122,\n  UNSIGNED_SHORT: 5123,\n  INT: 5124,\n  UNSIGNED_INT: 5125,\n  FLOAT: 5126,\n  DOUBLE: 5130\n};\n\nexport const GL = {\n  ...GL_PRIMITIVE_MODE,\n  ...GL_TYPE\n};\n"],"file":"constants.js"}