@woosh/meep-engine 3.14.1 → 3.14.3

package/src/shade/renderer/loader/usd/usd_compose_transform.js

@@ -1,258 +0,0 @@
-/**
- * Composes a USD `xformOpOrder` stack into a single 4×4 column-major matrix.
- *
- * @see https://openusd.org/release/api/class_usd_geom_xformable.html#details — xformOpOrder semantics
- * @see https://openusd.org/release/api/class_usd_geom_xform_op.html — Individual xformOp types
- *
- * USD transforms are specified as an ordered list of operations:
- * ```usda
- * uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
- * double3 xformOp:translate = (10, 0, 0)
- * float3 xformOp:rotateXYZ = (0, 45, 0)
- * double3 xformOp:scale = (2, 2, 2)
- * ```
- *
- * These are composed left-to-right: T × R × S.
- *
- * @module usd_compose_transform
- */
-
-import { array_copy } from "../../../../core/collection/array/array_copy.js";
-import { M4_IDENTITY } from "../../../../core/geom/3d/mat4/M4_IDENTITY.js";
-import { m4_allocate } from "../../../../core/geom/3d/mat4/m4_allocate.js";
-import { m4_from_rotation_translation_scale } from "../../../../core/geom/3d/mat4/m4_from_rotation_translation_scale.js";
-import { m4_make_rotation_x } from "../../../../core/geom/3d/mat4/m4_make_rotation_x.js";
-import { m4_make_rotation_y } from "../../../../core/geom/3d/mat4/m4_make_rotation_y.js";
-import { m4_make_rotation_z } from "../../../../core/geom/3d/mat4/m4_make_rotation_z.js";
-import { m4_make_scale } from "../../../../core/geom/3d/mat4/m4_make_scale.js";
-import { m4_make_translation } from "../../../../core/geom/3d/mat4/m4_make_translation.js";
-import { m4_multiply } from "../../../../core/geom/3d/mat4/m4_multiply.js";
-import { m4_transpose } from "../../../../core/geom/3d/mat4/m4_transpose.js";
-import { DEG_TO_RAD } from "../../../../core/math/DEG_TO_RAD.js";
-
-/**
- * Reusable temporary matrix to avoid per-call allocations.
- * @type {Float32Array}
- */
-const _temp_mat = new Float32Array(16);
-
-/**
- * Reusable temporary matrix holding a single axis of an euler rotation, which is multiplied into
- * the accumulating rotation rather than replacing it.
- * @type {Float32Array}
- */
-const _temp_axis_mat = new Float32Array(16);
-
-/**
- * Reusable temporary quaternion.
- * @type {Float32Array}
- */
-const _temp_quat = new Float32Array(4);
-
-/**
- * An `xformOp:orient` carries rotation alone — translation and scale are separate ops with their
- * own place in `xformOpOrder` — so the matrix it composes from a quaternion has neither.
- * @type {number[]}
- */
-const NO_TRANSLATION = [0, 0, 0];
-
-/**
- * @see NO_TRANSLATION
- * @type {number[]}
- */
-const UNIT_SCALE = [1, 1, 1];
-
-/**
- * Compose a USD transform from its `xformOpOrder` and associated properties.
- *
- * NOTE: USD stores positions as `double3` (float64). The output matrix is
- * `Float32Array` (float32) to match the engine's transform representation.
- * This is a **precision-loss point** — positions far from origin may lose
- * sub-millimeter precision.
- *
- * @param {Object} fields - Prim fields containing xformOp:* values
- * @param {Object} specs_by_path - Full specsByPath map for attribute lookup
- * @param {string} prim_path - Prim path for resolving attribute paths
- * @returns {Float32Array} 4×4 column-major transform matrix
- */
-export function usd_compose_transform(fields, specs_by_path, prim_path) {
-
-    const xform_op_order = fields.xformOpOrder;
-
-    if (!xform_op_order || xform_op_order.length === 0) {
-        return m4_allocate();
-    }
-
-    const result = m4_allocate();
-
-    for (let i = 0; i < xform_op_order.length; i++) {
-        const op_name = xform_op_order[i];
-
-        // Resolve the operation value from the prim's attribute specs
-        const value = resolve_xform_op_value(op_name, fields, specs_by_path, prim_path);
-
-        if (value === null) {
-            continue;
-        }
-
-        apply_xform_op(result, op_name, value);
-    }
-
-    return new Float32Array(result);
-}
-
-
-/**
- * Resolve the value of an xform operation.
- *
- * Values can be stored either:
- * - Directly in the prim's fields (USDA parser may inline them)
- * - As attribute specs at `primPath.opName`
- *
- * @param {string} op_name - e.g. "xformOp:translate"
- * @param {Object} fields - Prim fields
- * @param {Object} specs_by_path - Full specsByPath
- * @param {string} prim_path - Prim path
- * @returns {number[]|Float32Array|Float64Array|null}
- */
-function resolve_xform_op_value(op_name, fields, specs_by_path, prim_path) {
-
-    // Check if directly stored as a field
-    if (fields[op_name] !== undefined) {
-        return fields[op_name];
-    }
-
-    // Look up as an attribute spec
-    const attr_path = prim_path + "." + op_name;
-    const attr_spec = specs_by_path[attr_path];
-
-    if (attr_spec && attr_spec.fields) {
-        // Prefer timeSamples first frame if present, otherwise default
-        if (attr_spec.fields.timeSamples) {
-            const ts = attr_spec.fields.timeSamples;
-            if (ts.values && ts.values.length > 0) {
-                return ts.values[0];
-            }
-        }
-
-        if (attr_spec.fields.default !== undefined) {
-            return attr_spec.fields.default;
-        }
-    }
-
-    return null;
-}
-
-
-/**
- * Apply a single xform operation to the accumulating matrix.
- *
- * Supported operations:
- * - `xformOp:translate` — vec3 translation
- * - `xformOp:scale` — vec3 scale
- * - `xformOp:rotateX/Y/Z` — single-axis rotation (degrees)
- * - `xformOp:rotateXYZ/XZY/YXZ/YZX/ZXY/ZYX` — euler rotation (degrees)
- * - `xformOp:orient` — quaternion rotation (USD format: w,x,y,z)
- * - `xformOp:transform` — full 4×4 matrix
- *
- * @param {Float32Array} result - Matrix to multiply into (modified in place)
- * @param {string} op_name - Operation name
- * @param {number[]|Float32Array|Float64Array} value - Operation value
- */
-function apply_xform_op(result, op_name, value) {
-
-    // Strip the "xformOp:" prefix and any namespace suffix (e.g. ":pivot")
-    const op = op_name.replace(/^xformOp:/, "");
-
-    if (op === "translate") {
-
-        // NOTE: float64 → float32 precision loss for large coordinates
-        m4_make_translation(_temp_mat, value);
-
-    } else if (op === "scale") {
-
-        m4_make_scale(_temp_mat, value);
-
-    } else if (op === "rotateX") {
-
-        m4_make_rotation_x(_temp_mat, value * DEG_TO_RAD);
-
-    } else if (op === "rotateY") {
-
-        m4_make_rotation_y(_temp_mat, value * DEG_TO_RAD);
-
-    } else if (op === "rotateZ") {
-
-        m4_make_rotation_z(_temp_mat, value * DEG_TO_RAD);
-
-    } else if (op === "rotateXYZ" || op === "rotateXZY" || op === "rotateYXZ" ||
-        op === "rotateYZX" || op === "rotateZXY" || op === "rotateZYX") {
-
-        apply_euler_rotation(_temp_mat, op, value);
-
-    } else if (op === "orient") {
-
-        // USD quaternion order: (w, x, y, z)
-        // engine quaternion order: (x, y, z, w)
-        // @see https://openusd.org/release/api/class_gf_quatf.html — GfQuatf real-part-first layout
-        _temp_quat[0] = value[1];
-        _temp_quat[1] = value[2];
-        _temp_quat[2] = value[3];
-        _temp_quat[3] = value[0];
-
-        m4_from_rotation_translation_scale(_temp_mat, _temp_quat, NO_TRANSLATION, UNIT_SCALE);
-
-    } else if (op === "transform") {
-
-        // Full 4×4 matrix — USD stores row-major, engine uses column-major
-        // NOTE: float64 → float32 precision loss for all 16 matrix elements
-        m4_transpose(_temp_mat, value);
-
-    } else {
-        console.warn(`[USD] Unknown xformOp: "${op_name}", skipping`);
-        return;
-    }
-
-    m4_multiply(result, result, _temp_mat);
-}
-
-
-/**
- * Apply euler rotation in the specified axis order.
- *
- * @param {Float32Array} out - Output matrix
- * @param {string} order - e.g. "rotateXYZ"
- * @param {number[]} angles - [x, y, z] in degrees
- */
-function apply_euler_rotation(out, order, angles) {
-
-    const rx = angles[0] * DEG_TO_RAD;
-    const ry = angles[1] * DEG_TO_RAD;
-    const rz = angles[2] * DEG_TO_RAD;
-
-    // Extract axis order from the op name (e.g. "rotateXYZ" → "XYZ")
-    const axis_order = order.replace("rotate", "");
-
-    const ops = {
-        "X": (m) => m4_make_rotation_x(m, rx),
-        "Y": (m) => m4_make_rotation_y(m, ry),
-        "Z": (m) => m4_make_rotation_z(m, rz),
-    };
-
-    array_copy(M4_IDENTITY, 0, out, 0, 16);
-
-    // OpenUSD applies the named axes to the point first-to-last (rotateXYZ ⇒ X
-    // first). A column-major matrix applies its rightmost factor first, so build
-    // the product in reverse: out = R_last · … · R_first.
-    // @see https://openusd.org/release/api/class_usd_geom_xform_op.html — TypeRotateXYZ
-    for (let i = axis_order.length - 1; i >= 0; i--) {
-        const axis = axis_order[i];
-        const fn = ops[axis];
-
-        if (fn) {
-            fn(_temp_axis_mat);
-
-            m4_multiply(out, out, _temp_axis_mat);
-        }
-    }
-}

package/src/shade/renderer/loader/usd/usd_lz4.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"usd_lz4.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_lz4.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;GAcG;AACH,0CANW,UAAU,qBACV,MAAM,GAEJ,UAAU,CA2DtB;AAGD;;;;;;;;;;GAUG;AACH,2DAJW,WAAW,YACX,MAAM,GACJ,UAAU,CAStB"}

package/src/shade/renderer/loader/usd/usd_lz4.js

@@ -1,182 +0,0 @@
-/**
- * USD's TfFastCompression framing over LZ4, and the Crate integer coding that rides on it.
- *
- * USDC (Crate) compresses its tokens, fields and integer arrays with LZ4, wrapped by Pixar's
- * TfFastCompression. The LZ4 block codec itself is generic and lives in core; what is USD's own is
- * the chunk framing around it and the delta coding inside it, and that is what this module is.
- *
- * @see https://openusd.org/release/glossary.html#usdglossary-crate — Crate binary file format
- * @see https://github.com/PixarAnimationStudios/OpenUSD/blob/release/pxr/base/tf/fastCompression.cpp — TfFastCompression
- * @see https://github.com/PixarAnimationStudios/OpenUSD/blob/release/pxr/usd/sdf/integerCoding.cpp — Crate integer coding
- *
- * @module usd_lz4
- */
-
-import { LZ4_MAX_INPUT_SIZE } from "../../../../core/binary/lz4/LZ4_MAX_INPUT_SIZE.js";
-import { lz4_decompress_block } from "../../../../core/binary/lz4/lz4_decompress_block.js";
-import { UsdParseError } from "./UsdError.js";
-
-
-/**
- * Decompress a TfFastCompression payload.
- *
- * The first byte is a chunk count. Zero means the whole of the rest is one LZ4 block. Anything else
- * is that many chunks, each one a 32-bit little-endian compressed size followed immediately by the
- * block it measures - the sizes are interleaved with the data, not gathered into a table up front.
- * Pixar chunks at the largest input LZ4 takes, so a payload has to exceed {@link LZ4_MAX_INPUT_SIZE}
- * before it is chunked at all.
- *
- * @param {Uint8Array} input - Compressed data including the TfFastCompression header
- * @param {number} uncompressed_size - Upper bound on the output; callers that only know a bound get
- *                                     a buffer of that size with the tail left zeroed
- * @returns {Uint8Array} Decompressed data
- * @throws {UsdParseError} If the framing does not fit the data
- */
-export function usd_lz4_decompress(input, uncompressed_size) {
-
-    if (input.length < 1) {
-        throw new UsdParseError("TfFastCompression payload is empty", { section: "lz4" });
-    }
-
-    const output = new Uint8Array(uncompressed_size);
-    const num_chunks = input[0];
-
-    if (num_chunks === 0) {
-        // Single chunk — all remaining bytes are one LZ4 block
-        lz4_decompress_block(output, 0, uncompressed_size, input, 1, input.length);
-
-        return output;
-    }
-
-    let input_cursor = 1;
-    let output_cursor = 0;
-
-    for (let i = 0; i < num_chunks; i++) {
-
-        if (input_cursor + 4 > input.length) {
-            throw new UsdParseError(
-                `TfFastCompression chunk ${i} of ${num_chunks} has no size header`,
-                { section: "lz4", offset: input_cursor }
-            );
-        }
-
-        const chunk_compressed_size = (
-            input[input_cursor]
-            | (input[input_cursor + 1] << 8)
-            | (input[input_cursor + 2] << 16)
-            | (input[input_cursor + 3] << 24)
-        ) >>> 0;
-
-        input_cursor += 4;
-
-        if (input_cursor + chunk_compressed_size > input.length) {
-            throw new UsdParseError(
-                `TfFastCompression chunk ${i} of ${num_chunks} claims ${chunk_compressed_size} bytes, past the end of the payload`,
-                { section: "lz4", offset: input_cursor }
-            );
-        }
-
-        // each chunk carries at most LZ4's largest input, and the last of them carries the remainder
-        output_cursor = lz4_decompress_block(
-            output,
-            output_cursor, Math.min(output_cursor + LZ4_MAX_INPUT_SIZE, uncompressed_size),
-            input,
-            input_cursor, input_cursor + chunk_compressed_size
-        );
-
-        input_cursor += chunk_compressed_size;
-    }
-
-    return output;
-}
-
-
-/**
- * Decompress USD integer-compressed data.
- *
- * USD uses a delta + variable-width encoding for integer arrays:
- * 1. LZ4-decompress the outer payload
- * 2. Decode: common_value (int32) + 2-bit codes per element + variable-width deltas
- *
- * @param {ArrayBuffer} compressed_buffer - Raw compressed bytes
- * @param {number} num_ints - Number of integers to decode
- * @returns {Int32Array} Decoded integers
- */
-export function usd_decompress_integers(compressed_buffer, num_ints) {
-
-    // Estimate encoded size: num_ints×4 bytes for values + 2 bits per code + 4 bytes for common value
-    const encoded_size = num_ints * 4 + ((num_ints * 2 + 7) >> 3) + 4;
-    const encoded = usd_lz4_decompress(new Uint8Array(compressed_buffer), encoded_size);
-
-    return decode_integers_32(encoded, num_ints);
-}
-
-
-/**
- * Decode delta + variable-width encoded integers.
- *
- * Format:
- * - int32 common_value
- * - ceil(num_ints * 2 / 8) bytes of 2-bit codes (4 codes per byte)
- * - Variable-width delta values following each code
- *
- * Code meanings:
- * - 0: delta = common_value
- * - 1: delta = next int8
- * - 2: delta = next int16 (LE)
- * - 3: delta = next int32 (LE)
- *
- * @param {Uint8Array} data - Decoded LZ4 payload
- * @param {number} num_ints - Number of integers
- * @returns {Int32Array}
- */
-function decode_integers_32(data, num_ints) {
-
-    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    let offset = 0;
-
-    const common_value = view.getInt32(offset, true);
-    offset += 4;
-
-    const num_code_bytes = (num_ints * 2 + 7) >> 3;
-    const codes_start = offset;
-    const values_start = offset + num_code_bytes;
-
-    const result = new Int32Array(num_ints);
-    let prev_value = 0;
-    let codes_offset = codes_start;
-    let values_offset = values_start;
-
-    for (let i = 0; i < num_ints;) {
-        const code_byte = data[codes_offset++];
-
-        // Each byte holds 4 × 2-bit codes
-        for (let j = 0; j < 4 && i < num_ints; j++, i++) {
-            const code = (code_byte >> (j * 2)) & 3;
-            let delta = 0;
-
-            switch (code) {
-                case 0:
-                    delta = common_value;
-                    break;
-                case 1:
-                    delta = view.getInt8(values_offset);
-                    values_offset += 1;
-                    break;
-                case 2:
-                    delta = view.getInt16(values_offset, true);
-                    values_offset += 2;
-                    break;
-                case 3:
-                    delta = view.getInt32(values_offset, true);
-                    values_offset += 4;
-                    break;
-            }
-
-            prev_value += delta;
-            result[i] = prev_value;
-        }
-    }
-
-    return result;
-}

package/src/shade/renderer/loader/usd/usd_triangulate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"usd_triangulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_triangulate.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH;;;;;;;;;;;;;GAaG;AACH,oDAXW,MAAM,EAAE,GAAC,UAAU,uBACnB,MAAM,EAAE,GAAC,UAAU;aAEd,WAAW;cACV,WAAW;oBACL,MAAM;EAwE5B;AAGD;;;;;;;;;;GAUG;AACH,4DALW,MAAM,EAAE,GAAC,UAAU,gBACnB,YAAY,GAAC,MAAM,EAAE,aACrB,MAAM,GACJ,YAAY,CAmDxB"}

package/src/shade/renderer/postprocess/taa/chunk_taa_sample_history_color.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=chunk_taa_sample_history_color.d.ts.map

package/src/shade/renderer/postprocess/taa/chunk_taa_sample_history_color.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_taa_sample_history_color.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_taa_sample_history_color.js"],"names":[],"mappings":""}

package/src/shade/renderer/postprocess/taa/chunk_taa_sample_history_color.js

@@ -1,43 +0,0 @@
-import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
-import { chunk_filter_blackman_harris } from "../../shader/chunk/filter/chunk_filter_blackman_harris.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-/**
- * @see https://github.com/TheRealMJP/MSAAFilter/blob/cfc1c19411e24dc07f74272c17f423330ac96941/MSAAFilter/Resolve.hlsl#L313
- * @type {CodeChunk}
- */
-const chunk_taa_sample_history_color = CodeChunk.from(
-    //language=WGSL
-    `
-fn taa_sample_history_color(history: texture_2d<f32>, origin: vec2<f32>) -> vec4<f32>{
-    
-    var color_sum = vec4(0.0);
-    var weight_sum = 0.0;
-    
-    for(var ty = -1; ty <= 1; ty++){
-        for(var tx = -1; tx <= 1; tx++){
-            
-            let sample_position = floor(origin + vec2<f32>(f32(tx), f32(ty))) + 0.5;
-            let history_sample = textureLoad(history, vec2<i32>(sample_position), 0);
-            
-            let distance = abs(sample_position - origin);
-            
-            var filter_weight = filter_blackman_harris(distance.x) * filter_blackman_harris(distance.y);
-            
-            let luminance = rgb_to_luminance(history_sample.rgb);
-            
-            // inverse luminance
-            filter_weight *= 1.0 / (1.0 + luminance);
-            
-            color_sum += history_sample * filter_weight;
-            weight_sum += filter_weight;
-        }
-    }
-
-    return max(color_sum/ weight_sum, vec4(0.0));
-}
-  `, [
-        chunk_filter_blackman_harris,
-        chunk_rgb_to_luminance,
-    ]
-);

package/src/shade/renderer/scene/optimization/sampler2d_compare.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sampler2d_compare.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/optimization/sampler2d_compare.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,+DAFa,MAAM,CAuFlB"}

package/src/shade/renderer/scene/optimization/sampler2d_compare.js

@@ -1,94 +0,0 @@
-import { array_copy } from "../../../../core/collection/array/array_copy.js";
-
-/**
- *
- * @param {Sampler2D} a
- * @param {Sampler2D} b
- * @returns {number} similarity score. 0 - nothing in common. 1 - identical.
- */
-export function sampler2d_compare(a, b) {
-    if (a === b) {
-        return 1.0;
-    }
-
-    if (
-        a.width !== b.width
-        || a.height !== b.height
-        || a.itemSize !== b.itemSize
-    ) {
-
-        // quick exit
-        return 0;
-    }
-
-    const width = a.width;
-    const height = a.height;
-    const itemSize = a.itemSize;
-
-    const sample_a = new Array(itemSize);
-    const sample_b = new Array(itemSize);
-
-    let difference_sum = 0;
-
-    const value_min = new Array(itemSize);
-    const value_max = new Array(itemSize);
-
-    for (let i = 0; i < itemSize; i++) {
-        value_min[i] = Infinity;
-        value_max[i] = -Infinity;
-    }
-
-    for (let y = 0; y < height; y++) {
-        for (let x = 0; x < width; x++) {
-
-            const offset = (y * width + x) * itemSize;
-
-            // read texels
-            array_copy(a.data, offset, sample_a, 0, itemSize);
-            array_copy(b.data, offset, sample_b, 0, itemSize);
-
-            // compare
-            let sum = 0;
-            for (let i = 0; i < itemSize; i++) {
-                const sample_value_a = sample_a[i];
-                const sample_value_b = sample_b[i];
-
-                const diff = sample_value_a - sample_value_b;
-                sum += diff * diff;
-
-                //
-                value_max[i] = Math.max(value_max[i], sample_value_a, sample_value_b);
-                value_min[i] = Math.min(value_min[i], sample_value_a, sample_value_b);
-            }
-
-            const texel_difference = Math.sqrt(sum);
-
-            difference_sum += texel_difference;
-        }
-    }
-
-    if (difference_sum === 0) {
-        return 1;
-    }
-
-    const total_texel_count = width * height;
-
-    const mean_texel_difference = difference_sum / total_texel_count;
-
-    // normalize difference
-    let bounds_vector_length = 0;
-    for (let i = 0; i < itemSize; i++) {
-        const span = value_max[i] - value_min[i];
-        bounds_vector_length += span * span;
-    }
-
-    if (bounds_vector_length === 0) {
-        // all values are the same.
-        // avoids NaN from division by zero.
-        return 1;
-    }
-
-    bounds_vector_length = Math.sqrt(bounds_vector_length);
-
-    return 1.0 - (mean_texel_difference / bounds_vector_length);
-}

package/src/shade/util/compute_max_mip_count.d.ts

@@ -1,8 +0,0 @@
-/**
- * Maximum mip count for given texture dimensions
- * @param {number} width
- * @param {number} height
- * @returns {number}
- */
-export function compute_max_mip_count(width: number, height: number): number;
-//# sourceMappingURL=compute_max_mip_count.d.ts.map

package/src/shade/util/compute_max_mip_count.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compute_max_mip_count.d.ts","sourceRoot":"","sources":["../../../../src/shade/util/compute_max_mip_count.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,6CAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAoBlB"}

package/src/shade/util/compute_max_mip_count.js

@@ -1,27 +0,0 @@
-import { assert } from "../../core/assert.js";
-
-/**
- * Maximum mip count for given texture dimensions
- * @param {number} width
- * @param {number} height
- * @returns {number}
- */
-export function compute_max_mip_count(width, height) {
-    assert.isNumber(width, 'width');
-    assert.isNumber(height, 'height');
-
-    assert.notNaN(width, "width");
-    assert.notNaN(height, "height");
-
-    assert.greaterThanOrEqual(width, 0);
-    assert.greaterThanOrEqual(height, 0);
-
-    // the +1 is to indicate that there's always at least 1 level
-    const max_size = Math.max(width, height);
-
-    if (max_size === 0) {
-        return 0;
-    }
-
-    return Math.floor(Math.log2(max_size)) + 1;
-}