babylon-mmd/esm/Runtime/Optimized/wasm/spd/index.js

babylon.js mmd loader and runtime

let wasm;

function logError(f, args) {
    try {
        return f.apply(this, args);
    } catch (e) {
        let error = (function () {
            try {
                return e instanceof Error ? `${e.message}\n\nStack:\n${e.stack}` : e.toString();
            } catch(_) {
                return "<failed to stringify thrown value>";
            }
        }());
        console.error("wasm-bindgen: imported JS function that was not marked as `catch` threw an error:", error);
        throw e;
    }
}

let cachedUint8ArrayMemory0 = null;

function getUint8ArrayMemory0() {
    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
    }
    return cachedUint8ArrayMemory0;
}

let cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );

if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };

const MAX_SAFARI_DECODE_BYTES = 2146435072;
let numBytesDecoded = 0;
function decodeText(ptr, len) {
    numBytesDecoded += len;
    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
        cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
        cachedTextDecoder.decode();
        numBytesDecoded = len;
    }
    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
}

function getStringFromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return decodeText(ptr, len);
}

let WASM_VECTOR_LEN = 0;

const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );

const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
    ? function (arg, view) {
    return cachedTextEncoder.encodeInto(arg, view);
}
    : function (arg, view) {
    const buf = cachedTextEncoder.encode(arg);
    view.set(buf);
    return {
        read: arg.length,
        written: buf.length
    };
});

function passStringToWasm0(arg, malloc, realloc) {

    if (typeof(arg) !== 'string') throw new Error(`expected a string argument, found ${typeof(arg)}`);

    if (realloc === undefined) {
        const buf = cachedTextEncoder.encode(arg);
        const ptr = malloc(buf.length, 1) >>> 0;
        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
        WASM_VECTOR_LEN = buf.length;
        return ptr;
    }

    let len = arg.length;
    let ptr = malloc(len, 1) >>> 0;

    const mem = getUint8ArrayMemory0();

    let offset = 0;

    for (; offset < len; offset++) {
        const code = arg.charCodeAt(offset);
        if (code > 0x7F) break;
        mem[ptr + offset] = code;
    }

    if (offset !== len) {
        if (offset !== 0) {
            arg = arg.slice(offset);
        }
        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
        const ret = encodeString(arg, view);
        if (ret.read !== arg.length) throw new Error('failed to pass whole string');
        offset += ret.written;
        ptr = realloc(ptr, len, offset, 1) >>> 0;
    }

    WASM_VECTOR_LEN = offset;
    return ptr;
}

let cachedDataViewMemory0 = null;

function getDataViewMemory0() {
    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
    }
    return cachedDataViewMemory0;
}

function _assertNum(n) {
    if (typeof(n) !== 'number') throw new Error(`expected a number argument, found ${typeof(n)}`);
}
/**
 * @param {number} physics_world
 * @returns {number}
 */
export function createPhysicsRuntime(physics_world) {
    _assertNum(physics_world);
    const ret = wasm.createPhysicsRuntime(physics_world);
    return ret >>> 0;
}

/**
 * @param {number} physics_runtime
 */
export function destroyPhysicsRuntime(physics_runtime) {
    _assertNum(physics_runtime);
    wasm.destroyPhysicsRuntime(physics_runtime);
}

/**
 * @param {number} physics_runtime
 * @returns {number}
 */
export function physicsRuntimeGetLockStatePtr(physics_runtime) {
    _assertNum(physics_runtime);
    const ret = wasm.physicsRuntimeGetLockStatePtr(physics_runtime);
    return ret >>> 0;
}

/**
 * @returns {number}
 */
export function createPhysicsWorld() {
    const ret = wasm.createPhysicsWorld();
    return ret >>> 0;
}

/**
 * @param {number} world
 */
export function destroyPhysicsWorld(world) {
    _assertNum(world);
    wasm.destroyPhysicsWorld(world);
}

/**
 * @param {number} world
 * @param {number} x
 * @param {number} y
 * @param {number} z
 */
export function physicsWorldSetGravity(world, x, y, z) {
    _assertNum(world);
    wasm.physicsWorldSetGravity(world, x, y, z);
}

/**
 * @param {number} world
 * @param {number} time_step
 * @param {number} max_sub_steps
 * @param {number} fixed_time_step
 */
export function physicsWorldStepSimulation(world, time_step, max_sub_steps, fixed_time_step) {
    _assertNum(world);
    _assertNum(max_sub_steps);
    wasm.physicsWorldStepSimulation(world, time_step, max_sub_steps, fixed_time_step);
}

/**
 * @param {number} world
 * @param {number} rigidbody
 */
export function physicsWorldAddRigidBody(world, rigidbody) {
    _assertNum(world);
    _assertNum(rigidbody);
    wasm.physicsWorldAddRigidBody(world, rigidbody);
}

/**
 * @param {number} world
 * @param {number} rigidbody
 */
export function physicsWorldRemoveRigidBody(world, rigidbody) {
    _assertNum(world);
    _assertNum(rigidbody);
    wasm.physicsWorldRemoveRigidBody(world, rigidbody);
}

/**
 * @param {number} world
 * @param {number} bundle
 */
export function physicsWorldAddRigidBodyBundle(world, bundle) {
    _assertNum(world);
    _assertNum(bundle);
    wasm.physicsWorldAddRigidBodyBundle(world, bundle);
}

/**
 * @param {number} world
 * @param {number} bundle
 */
export function physicsWorldRemoveRigidBodyBundle(world, bundle) {
    _assertNum(world);
    _assertNum(bundle);
    wasm.physicsWorldRemoveRigidBodyBundle(world, bundle);
}

function _assertBoolean(n) {
    if (typeof(n) !== 'boolean') {
        throw new Error(`expected a boolean argument, found ${typeof(n)}`);
    }
}
/**
 * @param {number} world
 * @param {number} constraint
 * @param {boolean} disable_collisions_between_linked_bodies
 */
export function physicsWorldAddConstraint(world, constraint, disable_collisions_between_linked_bodies) {
    _assertNum(world);
    _assertNum(constraint);
    _assertBoolean(disable_collisions_between_linked_bodies);
    wasm.physicsWorldAddConstraint(world, constraint, disable_collisions_between_linked_bodies);
}

/**
 * @param {number} world
 * @param {number} constraint
 */
export function physicsWorldRemoveConstraint(world, constraint) {
    _assertNum(world);
    _assertNum(constraint);
    wasm.physicsWorldRemoveConstraint(world, constraint);
}

/**
 * @param {number} world
 * @param {boolean} use_buffer
 */
export function physicsWorldUseMotionStateBuffer(world, use_buffer) {
    _assertNum(world);
    _assertBoolean(use_buffer);
    wasm.physicsWorldUseMotionStateBuffer(world, use_buffer);
}

/**
 * @param {number} info_list
 * @param {number} len
 * @returns {number}
 */
export function createRigidBodyBundle(info_list, len) {
    _assertNum(info_list);
    _assertNum(len);
    const ret = wasm.createRigidBodyBundle(info_list, len);
    return ret >>> 0;
}

/**
 * @param {number} ptr
 */
export function destroyRigidBodyBundle(ptr) {
    _assertNum(ptr);
    wasm.destroyRigidBodyBundle(ptr);
}

/**
 * @param {number} ptr
 * @returns {number}
 */
export function rigidBodyBundleGetMotionStatesPtr(ptr) {
    _assertNum(ptr);
    const ret = wasm.rigidBodyBundleGetMotionStatesPtr(ptr);
    return ret >>> 0;
}

/**
 * @param {number} ptr
 * @returns {number}
 */
export function rigidBodyBundleGetBufferedMotionStatesPtr(ptr) {
    _assertNum(ptr);
    const ret = wasm.rigidBodyBundleGetBufferedMotionStatesPtr(ptr);
    return ret >>> 0;
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} linear_damping
 * @param {number} angular_damping
 */
export function rigidBodyBundleSetDamping(ptr, index, linear_damping, angular_damping) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleSetDamping(ptr, index, linear_damping, angular_damping);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @returns {number}
 */
export function rigidBodyBundleGetLinearDamping(ptr, index) {
    _assertNum(ptr);
    _assertNum(index);
    const ret = wasm.rigidBodyBundleGetLinearDamping(ptr, index);
    return ret;
}

/**
 * @param {number} ptr
 * @param {number} index
 * @returns {number}
 */
export function rigidBodyBundleGetAngularDamping(ptr, index) {
    _assertNum(ptr);
    _assertNum(index);
    const ret = wasm.rigidBodyBundleGetAngularDamping(ptr, index);
    return ret;
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} mass
 * @param {number} local_inertia_x
 * @param {number} local_inertia_y
 * @param {number} local_inertia_z
 */
export function rigidBodyBundleSetMassProps(ptr, index, mass, local_inertia_x, local_inertia_y, local_inertia_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleSetMassProps(ptr, index, mass, local_inertia_x, local_inertia_y, local_inertia_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @returns {number}
 */
export function rigidBodyBundleGetMass(ptr, index) {
    _assertNum(ptr);
    _assertNum(index);
    const ret = wasm.rigidBodyBundleGetMass(ptr, index);
    return ret;
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} out
 */
export function rigidBodyBundleGetLocalInertia(ptr, index, out) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(out);
    wasm.rigidBodyBundleGetLocalInertia(ptr, index, out);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} out
 */
export function rigidBodyBundleGetTotalForce(ptr, index, out) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(out);
    wasm.rigidBodyBundleGetTotalForce(ptr, index, out);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} out
 */
export function rigidBodyBundleGetTotalTorque(ptr, index, out) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(out);
    wasm.rigidBodyBundleGetTotalTorque(ptr, index, out);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} force_x
 * @param {number} force_y
 * @param {number} force_z
 */
export function rigidBodyBundleApplyCentralForce(ptr, index, force_x, force_y, force_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleApplyCentralForce(ptr, index, force_x, force_y, force_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} torque_x
 * @param {number} torque_y
 * @param {number} torque_z
 */
export function rigidBodyBundleApplyTorque(ptr, index, torque_x, torque_y, torque_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleApplyTorque(ptr, index, torque_x, torque_y, torque_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} force_ptr
 * @param {number} relative_position_ptr
 */
export function rigidBodyBundleApplyForce(ptr, index, force_ptr, relative_position_ptr) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(force_ptr);
    _assertNum(relative_position_ptr);
    wasm.rigidBodyBundleApplyForce(ptr, index, force_ptr, relative_position_ptr);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} impulse_x
 * @param {number} impulse_y
 * @param {number} impulse_z
 */
export function rigidBodyBundleApplyCentralImpulse(ptr, index, impulse_x, impulse_y, impulse_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleApplyCentralImpulse(ptr, index, impulse_x, impulse_y, impulse_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} torque_x
 * @param {number} torque_y
 * @param {number} torque_z
 */
export function rigidBodyBundleApplyTorqueImpulse(ptr, index, torque_x, torque_y, torque_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleApplyTorqueImpulse(ptr, index, torque_x, torque_y, torque_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} impulse_ptr
 * @param {number} relative_position_ptr
 */
export function rigidBodyBundleApplyImpulse(ptr, index, impulse_ptr, relative_position_ptr) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(impulse_ptr);
    _assertNum(relative_position_ptr);
    wasm.rigidBodyBundleApplyImpulse(ptr, index, impulse_ptr, relative_position_ptr);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} impulse_ptr
 * @param {number} relative_position_ptr
 */
export function rigidBodyBundleApplyPushImpulse(ptr, index, impulse_ptr, relative_position_ptr) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(impulse_ptr);
    _assertNum(relative_position_ptr);
    wasm.rigidBodyBundleApplyPushImpulse(ptr, index, impulse_ptr, relative_position_ptr);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} out
 */
export function rigidBodyBundleGetPushVelocity(ptr, index, out) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(out);
    wasm.rigidBodyBundleGetPushVelocity(ptr, index, out);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} out
 */
export function rigidBodyBundleGetTurnVelocity(ptr, index, out) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(out);
    wasm.rigidBodyBundleGetTurnVelocity(ptr, index, out);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} velocity_x
 * @param {number} velocity_y
 * @param {number} velocity_z
 */
export function rigidBodyBundleSetPushVelocity(ptr, index, velocity_x, velocity_y, velocity_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleSetPushVelocity(ptr, index, velocity_x, velocity_y, velocity_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} velocity_x
 * @param {number} velocity_y
 * @param {number} velocity_z
 */
export function rigidBodyBundleSetTurnVelocity(ptr, index, velocity_x, velocity_y, velocity_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleSetTurnVelocity(ptr, index, velocity_x, velocity_y, velocity_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} impulse_x
 * @param {number} impulse_y
 * @param {number} impulse_z
 */
export function rigidBodyBundleApplyCentralPushImpulse(ptr, index, impulse_x, impulse_y, impulse_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleApplyCentralPushImpulse(ptr, index, impulse_x, impulse_y, impulse_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} torque_x
 * @param {number} torque_y
 * @param {number} torque_z
 */
export function rigidBodyBundleApplyTorqueTurnImpulse(ptr, index, torque_x, torque_y, torque_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleApplyTorqueTurnImpulse(ptr, index, torque_x, torque_y, torque_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 */
export function rigidBodyBundleClearForces(ptr, index) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleClearForces(ptr, index);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} out
 */
export function rigidBodyBundleGetLinearVelocity(ptr, index, out) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(out);
    wasm.rigidBodyBundleGetLinearVelocity(ptr, index, out);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} out
 */
export function rigidBodyBundleGetAngularVelocity(ptr, index, out) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(out);
    wasm.rigidBodyBundleGetAngularVelocity(ptr, index, out);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} velocity_x
 * @param {number} velocity_y
 * @param {number} velocity_z
 */
export function rigidBodyBundleSetLinearVelocity(ptr, index, velocity_x, velocity_y, velocity_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleSetLinearVelocity(ptr, index, velocity_x, velocity_y, velocity_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} velocity_x
 * @param {number} velocity_y
 * @param {number} velocity_z
 */
export function rigidBodyBundleSetAngularVelocity(ptr, index, velocity_x, velocity_y, velocity_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleSetAngularVelocity(ptr, index, velocity_x, velocity_y, velocity_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} relative_position_ptr
 * @param {number} out
 */
export function rigidBodyBundleGetVelocityInLocalPoint(ptr, index, relative_position_ptr, out) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(relative_position_ptr);
    _assertNum(out);
    wasm.rigidBodyBundleGetVelocityInLocalPoint(ptr, index, relative_position_ptr, out);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} relative_position_ptr
 * @param {number} out
 */
export function rigidBodyBundleGetPushVelocityInLocalPoint(ptr, index, relative_position_ptr, out) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(relative_position_ptr);
    _assertNum(out);
    wasm.rigidBodyBundleGetPushVelocityInLocalPoint(ptr, index, relative_position_ptr, out);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} translation_x
 * @param {number} translation_y
 * @param {number} translation_z
 */
export function rigidBodyBundleTranslate(ptr, index, translation_x, translation_y, translation_z) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.rigidBodyBundleTranslate(ptr, index, translation_x, translation_y, translation_z);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} shape
 */
export function rigidBodyBundleSetShape(ptr, index, shape) {
    _assertNum(ptr);
    _assertNum(index);
    _assertNum(shape);
    wasm.rigidBodyBundleSetShape(ptr, index, shape);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @returns {number}
 */
export function rigidBodyBundleGetWorldTransformPtr(ptr, index) {
    _assertNum(ptr);
    _assertNum(index);
    const ret = wasm.rigidBodyBundleGetWorldTransformPtr(ptr, index);
    return ret >>> 0;
}

/**
 * @param {number} ptr
 * @returns {number}
 */
export function rigidBodyBundleGetKinematicStatesPtr(ptr) {
    _assertNum(ptr);
    const ret = wasm.rigidBodyBundleGetKinematicStatesPtr(ptr);
    return ret >>> 0;
}

export function init() {
    wasm.init();
}

/**
 * @param {number} size
 * @returns {number}
 */
export function allocateBuffer(size) {
    _assertNum(size);
    const ret = wasm.allocateBuffer(size);
    return ret >>> 0;
}

/**
 * Deallocate a buffer allocated by `allocateBuffer`.
 * # Safety
 * `ptr` must be a pointer to a buffer allocated by `allocateBuffer`.
 * @param {number} ptr
 * @param {number} size
 */
export function deallocateBuffer(ptr, size) {
    _assertNum(ptr);
    _assertNum(size);
    wasm.deallocateBuffer(ptr, size);
}

/**
 * @returns {MmdRuntime}
 */
export function createMmdRuntime() {
    const ret = wasm.createMmdRuntime();
    return MmdRuntime.__wrap(ret);
}

/**
 * @returns {AnimationPool}
 */
export function createAnimationPool() {
    const ret = wasm.createAnimationPool();
    return AnimationPool.__wrap(ret);
}

/**
 * @param {number} info
 * @returns {number}
 */
export function createRigidBody(info) {
    _assertNum(info);
    const ret = wasm.createRigidBody(info);
    return ret >>> 0;
}

/**
 * @param {number} ptr
 */
export function destroyRigidBody(ptr) {
    _assertNum(ptr);
    wasm.destroyRigidBody(ptr);
}

/**
 * @param {number} ptr
 * @returns {number}
 */
export function rigidBodyGetMotionStatePtr(ptr) {
    _assertNum(ptr);
    const ret = wasm.rigidBodyGetMotionStatePtr(ptr);
    return ret >>> 0;
}

/**
 * @param {number} ptr
 * @returns {number}
 */
export function rigidBodyGetBufferedMotionStatePtr(ptr) {
    _assertNum(ptr);
    const ret = wasm.rigidBodyGetBufferedMotionStatePtr(ptr);
    return ret >>> 0;
}

/**
 * @param {number} ptr
 * @param {number} linear_damping
 * @param {number} angular_damping
 */
export function rigidBodySetDamping(ptr, linear_damping, angular_damping) {
    _assertNum(ptr);
    wasm.rigidBodySetDamping(ptr, linear_damping, angular_damping);
}

/**
 * @param {number} ptr
 * @returns {number}
 */
export function rigidBodyGetLinearDamping(ptr) {
    _assertNum(ptr);
    const ret = wasm.rigidBodyGetLinearDamping(ptr);
    return ret;
}

/**
 * @param {number} ptr
 * @returns {number}
 */
export function rigidBodyGetAngularDamping(ptr) {
    _assertNum(ptr);
    const ret = wasm.rigidBodyGetAngularDamping(ptr);
    return ret;
}

/**
 * @param {number} ptr
 * @param {number} mass
 * @param {number} local_inertia_x
 * @param {number} local_inertia_y
 * @param {number} local_inertia_z
 */
export function rigidBodySetMassProps(ptr, mass, local_inertia_x, local_inertia_y, local_inertia_z) {
    _assertNum(ptr);
    wasm.rigidBodySetMassProps(ptr, mass, local_inertia_x, local_inertia_y, local_inertia_z);
}

/**
 * @param {number} ptr
 * @returns {number}
 */
export function rigidBodyGetMass(ptr) {
    _assertNum(ptr);
    const ret = wasm.rigidBodyGetMass(ptr);
    return ret;
}

/**
 * @param {number} ptr
 * @param {number} out
 */
export function rigidBodyGetLocalInertia(ptr, out) {
    _assertNum(ptr);
    _assertNum(out);
    wasm.rigidBodyGetLocalInertia(ptr, out);
}

/**
 * @param {number} ptr
 * @param {number} out
 */
export function rigidBodyGetTotalForce(ptr, out) {
    _assertNum(ptr);
    _assertNum(out);
    wasm.rigidBodyGetTotalForce(ptr, out);
}

/**
 * @param {number} ptr
 * @param {number} out
 */
export function rigidBodyGetTotalTorque(ptr, out) {
    _assertNum(ptr);
    _assertNum(out);
    wasm.rigidBodyGetTotalTorque(ptr, out);
}

/**
 * @param {number} ptr
 * @param {number} force_x
 * @param {number} force_y
 * @param {number} force_z
 */
export function rigidBodyApplyCentralForce(ptr, force_x, force_y, force_z) {
    _assertNum(ptr);
    wasm.rigidBodyApplyCentralForce(ptr, force_x, force_y, force_z);
}

/**
 * @param {number} ptr
 * @param {number} torque_x
 * @param {number} torque_y
 * @param {number} torque_z
 */
export function rigidBodyApplyTorque(ptr, torque_x, torque_y, torque_z) {
    _assertNum(ptr);
    wasm.rigidBodyApplyTorque(ptr, torque_x, torque_y, torque_z);
}

/**
 * @param {number} ptr
 * @param {number} force_ptr
 * @param {number} relative_position_ptr
 */
export function rigidBodyApplyForce(ptr, force_ptr, relative_position_ptr) {
    _assertNum(ptr);
    _assertNum(force_ptr);
    _assertNum(relative_position_ptr);
    wasm.rigidBodyApplyForce(ptr, force_ptr, relative_position_ptr);
}

/**
 * @param {number} ptr
 * @param {number} impulse_x
 * @param {number} impulse_y
 * @param {number} impulse_z
 */
export function rigidBodyApplyCentralImpulse(ptr, impulse_x, impulse_y, impulse_z) {
    _assertNum(ptr);
    wasm.rigidBodyApplyCentralImpulse(ptr, impulse_x, impulse_y, impulse_z);
}

/**
 * @param {number} ptr
 * @param {number} torque_x
 * @param {number} torque_y
 * @param {number} torque_z
 */
export function rigidBodyApplyTorqueImpulse(ptr, torque_x, torque_y, torque_z) {
    _assertNum(ptr);
    wasm.rigidBodyApplyTorqueImpulse(ptr, torque_x, torque_y, torque_z);
}

/**
 * @param {number} ptr
 * @param {number} impulse_ptr
 * @param {number} relative_position_ptr
 */
export function rigidBodyApplyImpulse(ptr, impulse_ptr, relative_position_ptr) {
    _assertNum(ptr);
    _assertNum(impulse_ptr);
    _assertNum(relative_position_ptr);
    wasm.rigidBodyApplyImpulse(ptr, impulse_ptr, relative_position_ptr);
}

/**
 * @param {number} ptr
 * @param {number} impulse_ptr
 * @param {number} relative_position_ptr
 */
export function rigidBodyApplyPushImpulse(ptr, impulse_ptr, relative_position_ptr) {
    _assertNum(ptr);
    _assertNum(impulse_ptr);
    _assertNum(relative_position_ptr);
    wasm.rigidBodyApplyPushImpulse(ptr, impulse_ptr, relative_position_ptr);
}

/**
 * @param {number} ptr
 * @param {number} out
 */
export function rigidBodyGetPushVelocity(ptr, out) {
    _assertNum(ptr);
    _assertNum(out);
    wasm.rigidBodyGetPushVelocity(ptr, out);
}

/**
 * @param {number} ptr
 * @param {number} out
 */
export function rigidBodyGetTurnVelocity(ptr, out) {
    _assertNum(ptr);
    _assertNum(out);
    wasm.rigidBodyGetTurnVelocity(ptr, out);
}

/**
 * @param {number} ptr
 * @param {number} velocity_x
 * @param {number} velocity_y
 * @param {number} velocity_z
 */
export function rigidBodySetPushVelocity(ptr, velocity_x, velocity_y, velocity_z) {
    _assertNum(ptr);
    wasm.rigidBodySetPushVelocity(ptr, velocity_x, velocity_y, velocity_z);
}

/**
 * @param {number} ptr
 * @param {number} velocity_x
 * @param {number} velocity_y
 * @param {number} velocity_z
 */
export function rigidBodySetTurnVelocity(ptr, velocity_x, velocity_y, velocity_z) {
    _assertNum(ptr);
    wasm.rigidBodySetTurnVelocity(ptr, velocity_x, velocity_y, velocity_z);
}

/**
 * @param {number} ptr
 * @param {number} impulse_x
 * @param {number} impulse_y
 * @param {number} impulse_z
 */
export function rigidBodyApplyCentralPushImpulse(ptr, impulse_x, impulse_y, impulse_z) {
    _assertNum(ptr);
    wasm.rigidBodyApplyCentralPushImpulse(ptr, impulse_x, impulse_y, impulse_z);
}

/**
 * @param {number} ptr
 * @param {number} torque_x
 * @param {number} torque_y
 * @param {number} torque_z
 */
export function rigidBodyApplyTorqueTurnImpulse(ptr, torque_x, torque_y, torque_z) {
    _assertNum(ptr);
    wasm.rigidBodyApplyTorqueTurnImpulse(ptr, torque_x, torque_y, torque_z);
}

/**
 * @param {number} ptr
 */
export function rigidBodyClearForces(ptr) {
    _assertNum(ptr);
    wasm.rigidBodyClearForces(ptr);
}

/**
 * @param {number} ptr
 * @param {number} out
 */
export function rigidBodyGetLinearVelocity(ptr, out) {
    _assertNum(ptr);
    _assertNum(out);
    wasm.rigidBodyGetLinearVelocity(ptr, out);
}

/**
 * @param {number} ptr
 * @param {number} out
 */
export function rigidBodyGetAngularVelocity(ptr, out) {
    _assertNum(ptr);
    _assertNum(out);
    wasm.rigidBodyGetAngularVelocity(ptr, out);
}

/**
 * @param {number} ptr
 * @param {number} velocity_x
 * @param {number} velocity_y
 * @param {number} velocity_z
 */
export function rigidBodySetLinearVelocity(ptr, velocity_x, velocity_y, velocity_z) {
    _assertNum(ptr);
    wasm.rigidBodySetLinearVelocity(ptr, velocity_x, velocity_y, velocity_z);
}

/**
 * @param {number} ptr
 * @param {number} velocity_x
 * @param {number} velocity_y
 * @param {number} velocity_z
 */
export function rigidBodySetAngularVelocity(ptr, velocity_x, velocity_y, velocity_z) {
    _assertNum(ptr);
    wasm.rigidBodySetAngularVelocity(ptr, velocity_x, velocity_y, velocity_z);
}

/**
 * @param {number} ptr
 * @param {number} relative_position_ptr
 * @param {number} out
 */
export function rigidBodyGetVelocityInLocalPoint(ptr, relative_position_ptr, out) {
    _assertNum(ptr);
    _assertNum(relative_position_ptr);
    _assertNum(out);
    wasm.rigidBodyGetVelocityInLocalPoint(ptr, relative_position_ptr, out);
}

/**
 * @param {number} ptr
 * @param {number} relative_position_ptr
 * @param {number} out
 */
export function rigidBodyGetPushVelocityInLocalPoint(ptr, relative_position_ptr, out) {
    _assertNum(ptr);
    _assertNum(relative_position_ptr);
    _assertNum(out);
    wasm.rigidBodyGetPushVelocityInLocalPoint(ptr, relative_position_ptr, out);
}

/**
 * @param {number} ptr
 * @param {number} translation_x
 * @param {number} translation_y
 * @param {number} translation_z
 */
export function rigidBodyTranslate(ptr, translation_x, translation_y, translation_z) {
    _assertNum(ptr);
    wasm.rigidBodyTranslate(ptr, translation_x, translation_y, translation_z);
}

/**
 * @param {number} ptr
 * @param {number} shape
 */
export function rigidBodySetShape(ptr, shape) {
    _assertNum(ptr);
    _assertNum(shape);
    wasm.rigidBodySetShape(ptr, shape);
}

/**
 * @param {number} ptr
 * @returns {number}
 */
export function rigidBodyGetWorldTransformPtr(ptr) {
    _assertNum(ptr);
    const ret = wasm.rigidBodyGetWorldTransformPtr(ptr);
    return ret >>> 0;
}

/**
 * @param {number} ptr
 * @returns {number}
 */
export function rigidBodyGetKinematicStatePtr(ptr) {
    _assertNum(ptr);
    const ret = wasm.rigidBodyGetKinematicStatePtr(ptr);
    return ret >>> 0;
}

/**
 * @param {number} body_a
 * @param {number} body_b
 * @param {number} frame_a
 * @param {number} frame_b
 * @param {boolean} use_linear_reference_frame_a
 * @returns {number}
 */
export function createGeneric6DofConstraint(body_a, body_b, frame_a, frame_b, use_linear_reference_frame_a) {
    _assertNum(body_a);
    _assertNum(body_b);
    _assertNum(frame_a);
    _assertNum(frame_b);
    _assertBoolean(use_linear_reference_frame_a);
    const ret = wasm.createGeneric6DofConstraint(body_a, body_b, frame_a, frame_b, use_linear_reference_frame_a);
    return ret >>> 0;
}

/**
 * @param {number} body_bundle
 * @param {number} body_a_index
 * @param {number} body_b_index
 * @param {number} frame_a
 * @param {number} frame_b
 * @param {boolean} use_linear_reference_frame_a
 * @returns {number}
 */
export function createGeneric6DofConstraintFromBundle(body_bundle, body_a_index, body_b_index, frame_a, frame_b, use_linear_reference_frame_a) {
    _assertNum(body_bundle);
    _assertNum(body_a_index);
    _assertNum(body_b_index);
    _assertNum(frame_a);
    _assertNum(frame_b);
    _assertBoolean(use_linear_reference_frame_a);
    const ret = wasm.createGeneric6DofConstraintFromBundle(body_bundle, body_a_index, body_b_index, frame_a, frame_b, use_linear_reference_frame_a);
    return ret >>> 0;
}

/**
 * @param {number} body_a
 * @param {number} body_b
 * @param {number} frame_a
 * @param {number} frame_b
 * @param {boolean} use_linear_reference_frame_a
 * @returns {number}
 */
export function createGeneric6DofSpringConstraint(body_a, body_b, frame_a, frame_b, use_linear_reference_frame_a) {
    _assertNum(body_a);
    _assertNum(body_b);
    _assertNum(frame_a);
    _assertNum(frame_b);
    _assertBoolean(use_linear_reference_frame_a);
    const ret = wasm.createGeneric6DofSpringConstraint(body_a, body_b, frame_a, frame_b, use_linear_reference_frame_a);
    return ret >>> 0;
}

/**
 * @param {number} body_bundle
 * @param {number} body_a_index
 * @param {number} body_b_index
 * @param {number} frame_a
 * @param {number} frame_b
 * @param {boolean} use_linear_reference_frame_a
 * @returns {number}
 */
export function createGeneric6DofSpringConstraintFromBundle(body_bundle, body_a_index, body_b_index, frame_a, frame_b, use_linear_reference_frame_a) {
    _assertNum(body_bundle);
    _assertNum(body_a_index);
    _assertNum(body_b_index);
    _assertNum(frame_a);
    _assertNum(frame_b);
    _assertBoolean(use_linear_reference_frame_a);
    const ret = wasm.createGeneric6DofSpringConstraintFromBundle(body_bundle, body_a_index, body_b_index, frame_a, frame_b, use_linear_reference_frame_a);
    return ret >>> 0;
}

/**
 * @param {number} ptr
 */
export function destroyConstraint(ptr) {
    _assertNum(ptr);
    wasm.destroyConstraint(ptr);
}

/**
 * @param {number} ptr
 * @param {number} x
 * @param {number} y
 * @param {number} z
 */
export function constraintSetLinearLowerLimit(ptr, x, y, z) {
    _assertNum(ptr);
    wasm.constraintSetLinearLowerLimit(ptr, x, y, z);
}

/**
 * @param {number} ptr
 * @param {number} x
 * @param {number} y
 * @param {number} z
 */
export function constraintSetLinearUpperLimit(ptr, x, y, z) {
    _assertNum(ptr);
    wasm.constraintSetLinearUpperLimit(ptr, x, y, z);
}

/**
 * @param {number} ptr
 * @param {number} x
 * @param {number} y
 * @param {number} z
 */
export function constraintSetAngularLowerLimit(ptr, x, y, z) {
    _assertNum(ptr);
    wasm.constraintSetAngularLowerLimit(ptr, x, y, z);
}

/**
 * @param {number} ptr
 * @param {number} x
 * @param {number} y
 * @param {number} z
 */
export function constraintSetAngularUpperLimit(ptr, x, y, z) {
    _assertNum(ptr);
    wasm.constraintSetAngularUpperLimit(ptr, x, y, z);
}

/**
 * @param {number} ptr
 * @param {number} num
 * @param {number} value
 * @param {number} axis
 */
export function constraintSetParam(ptr, num, value, axis) {
    _assertNum(ptr);
    _assertNum(num);
    _assertNum(axis);
    wasm.constraintSetParam(ptr, num, value, axis);
}

/**
 * @param {number} ptr
 * @param {boolean} frame_offset_on_off
 */
export function constraintUseFrameOffset(ptr, frame_offset_on_off) {
    _assertNum(ptr);
    _assertBoolean(frame_offset_on_off);
    wasm.constraintUseFrameOffset(ptr, frame_offset_on_off);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {boolean} on_off
 */
export function constraintEnableSpring(ptr, index, on_off) {
    _assertNum(ptr);
    _assertNum(index);
    _assertBoolean(on_off);
    wasm.constraintEnableSpring(ptr, index, on_off);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} stiffness
 */
export function constraintSetStiffness(ptr, index, stiffness) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.constraintSetStiffness(ptr, index, stiffness);
}

/**
 * @param {number} ptr
 * @param {number} index
 * @param {number} damping
 */
export function constraintSetDamping(ptr, index, damping) {
    _assertNum(ptr);
    _assertNum(index);
    wasm.constraintSetDamping(ptr, index, damping);
}

/**
 * @param {number} physics_world
 * @returns {number}
 */
export function createMultiPhysicsRuntime(physics_world) {
    _assertNum(physics_world);
    const ret = wasm.createMultiPhysicsRuntime(physics_world);
    return ret >>> 0;
}

/**
 * @param {number} physics_runtime
 */
export function destroyMultiPhysicsRuntime(physics_runtime) {
    _assertNum(physics_runtime);
    wasm.destroyMultiPhysicsRuntime(physics_runtime);
}

/**
 * @param {number} runtime
 * @returns {number}
 */
export function multiPhysicsRuntimeGetLockStatePtr(runtime) {
    _assertNum(runtime);
    const ret = wasm.multiPhysicsRuntimeGetLockStatePtr(runtime);
    return ret >>> 0;
}

function isLikeNone(x) {
    return x === undefined || x === null;
}
/**
 * @param {boolean} allow_dynamic_shadow
 * @returns {number}
 */
export function createMultiPhysicsWorld(allow_dynamic_shadow) {
    _assertBoolean(allow_dynamic_shadow);
    const ret = wasm.createMultiPhysicsWorld(allow_dynamic_shadow);
    return ret >>> 0;
}

/**
 * @param {number} world
 */
export function destroyMultiPhysicsWorld(world) {
    _assertNum(world);
    wasm.destroyMultiPhysicsWorld(world);
}

/**
 * @param {number} world
 * @param {number} x
 * @param {number} y
 * @param {number} z
 */
export function multiPhysicsWorldSetGravity(world, x, y, z) {
    _assertNum(world);
    wasm.multiPhysicsWorldSetGravity(world, x, y, z);
}

/**
 * @param {number} world
 * @param {number} time_step
 * @param {number} max_sub_steps
 * @param {number} fixed_time_step
 */
export function multiPhysicsWorldStepSimulation(world, time_step, max_sub_steps, fixed_time_step) {
    _assertNum(world);
    _assertNum(max_sub_steps);
    wasm.multiPhysicsWorldStepSimulation(world, time_step, max_sub_steps, fixed_time_step);
}

/**
 * @param {number} world
 * @param {number} world_id
 * @param {number} rigidbody
 */
export function multiPhysicsWorldAddRigidBody(world, world_id, rigidbody) {
    _assertNum(world);
    _assertNum(world_id);
    _assertNum(rigidbody);
    wasm.multiPhysicsWorldAddRigidBody(world, world_id, rigidbody);
}

/**
 * @param {number} world
 * @param {number} world_id
 * @param {number} rigidbody
 */
export function multiPhysicsWorldRemoveRigidBody(world, world_id, rigidbody) {
    _assertNum(world);
    _assertNum(world_id);
    _assertNum(rigidbody);
    wasm.multiPhysicsWorldRemoveRigidBody(world, world_id, rigidbody);
}

/**
 * @param {number} world
 * @param {number} world_id
 * @param {number} bundle
 */
export function multiPhysicsWorldAddRigidBodyBundle(world, world_id, bundle) {
    _assertNum(world);
    _assertNum(world_id);
    _assertNum(bundle);
    wasm.multiPhysicsWorldAddRigidBodyBundle(world, world_id, bundle);
}

/**
 * @param {number} world
 * @param {number} world_id
 * @param {number} bundle
 */
export function multiPhysicsWorldRemoveRigidBodyBundle(world, world_id, bundle) {
    _assertNum(world);
    _assertNum(world_id);
    _assertNum(bundle);
    wasm.multiPhysicsWorldRemoveRigidBodyBundle(world, world_id, bundle);
}

/**
 * @param {number} world
 * @param {number} rigidbody
 */
export function multiPhysicsWorldAddRigidBodyToGlobal(world, rigidbody) {
    _assertNum(world);
    _assertNum(rigidbody);
    wasm.multiPhysicsWorldAddRigidBodyToGlobal(world, rigidbody);
}

/**
 * @param {number} world
 * @param {number} rigidbody
 */
export function multiPhysicsWorldRemoveRigidBodyFromGlobal(world, rigidbody) {
    _assertNum(world);
    _assertNum(rigidbody);
    wasm.multiPhysicsWorldRemoveRigidBodyFromGlobal(world, rigidbody);
}

/**
 * @param {number} world
 * @param {number} bundle
 */
export function multiPhysicsWorldAddRigidBodyBundleToGlobal(world, bundle) {
    _assertNum(world);
    _assertNum(bundle);
    wasm.multiPhysicsWorldAddRigidBodyBundleToGlobal(world, bundle);
}

/**
 * @param {number} world
 * @param {number} bundle
 */
export function multiPhysicsWorldRemoveRigidBodyBundleFromGlobal(world, bundle) {
    _assertNum(world);
    _assertNum(bundle);
    wasm.multiPhysicsWorldRemoveRigidBodyBundleFromGlobal(world, bundle);
}

/**
 * @param {number} world
 * @param {number} world_id
 * @param {number} rigidbody
 */
export function multiPhysicsWorldAddRigidBodyShadow(world, world_id, rigidbody) {
    _assertNum(world);
    _assertNum(world_id);
    _assertNum(rigidbody);
    wasm.multiPhysicsWorldAddRigidBodyShadow(world, world_id, rigidbody);
}

/**
 * @param {number} world
 * @param {number} world_id
 * @param {number} rigidbody
 */
export function multiPhysicsWorldRemoveRigidBodyShadow(world, world_id, rigidbody) {
    _assertNum(world);
    _assertNum(world_id);
    _assertNum(rigidbody);
    wasm.multiPhysicsWorldRemoveRigidBodyShadow(world, world_id, rigidbody);
}

/**
 * @param {number} world
 * @param {number} world_id
 * @param {number} bundle
 */
export function multiPhysicsWorldAddRigidBodyBundleShadow(world, world_id, bundle) {
    _assertNum(world);
    _assertNum(world_id);
    _assertNum(bundle);
    wasm.multiPhysicsWorldAddRigidBodyBundleShadow(world, world_id, bundle);
}

/**
 * @param {number} world
 * @param {number} world_id
 * @param {number} bundle
 */
export function multiPhysicsWorldRemoveRigidBodyBundleShadow(world, world_id, bundle) {
    _assertNum(world);
    _assertNum(world_id);
    _assertNum(bundle);
    wasm.multiPhysicsWorldRemoveRigidBodyBundleShadow(world, world_id, bundle);
}

/**
 * @param {number} world
 * @param {number} world_id
 * @param {number} constraint
 * @param {boolean} disable_collisions_between_linked_bodies
 */
export function multiPhysicsWorldAddConstraint(world, world_id, constraint, disable_collisions_between_linked_bodies) {
    _assertNum(world);
    _assertNum(world_id);
    _assertNum(constraint);
    _assertBoolean(disable_collisions_between_linked_bodies);
    wasm.multiPhysicsWorldAddConstraint(world, world_id, constraint, disable_collisions_between_linked_bodies);
}

/**
 * @param {number} world
 * @param {number} world_id
 * @param {number} constraint
 */
export function multiPhysicsWorldRemoveConstraint(world, world_id, constraint) {
    _assertNum(world);
    _assertNum(world_id);
    _assertNum(constraint);
    wasm.multiPhysicsWorldRemoveConstraint(world, world_id, constraint);
}

/**
 * @param {number} world
 * @param {boolean} use_buffer
 */
export function multiPhysicsWorldUseMotionStateBuffer(world, use_buffer) {
    _assertNum(world);
    _assertBoolean(use_buffer);
    wasm.multiPhysicsWorldUseMotionStateBuffer(world, use_buffer);
}

/**
 * @param {number} x
 * @param {number} y
 * @param {number} z
 * @returns {number}
 */
export function createBoxShape(x, y, z) {
    const ret = wasm.createBoxShape(x, y, z);
    return ret >>> 0;
}

/**
 * @param {number} radius
 * @returns {number}
 */
export function createSphereShape(radius) {
    const ret = wasm.createSphereShape(radius);
    return ret >>> 0;
}

/**
 * @param {number} radius
 * @param {number} height
 * @returns {number}
 */
export function createCapsuleShape(radius, height) {
    const ret = wasm.createCapsuleShape(radius, height);
    return ret >>> 0;
}

/**
 * @param {number} normal_x
 * @param {number} normal_y
 * @param {number} normal_z
 * @param {number} plane_constant
 * @returns {number}
 */
export function createStaticPlaneShape(normal_x, normal_y, normal_z, plane_constant) {
    const ret = wasm.createStaticPlaneShape(normal_x, normal_y, normal_z, plane_constant);
    return ret >>> 0;
}

/**
 * @param {number} ptr
 */
export function destroyShape(ptr) {
    _assertNum(ptr);
    wasm.destroyShape(ptr);
}

const AnimationPoolFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_animationpool_free(ptr >>> 0, 1));

export class AnimationPool {

    constructor() {
        throw new Error('cannot invoke `new` directly');
    }

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(AnimationPool.prototype);
        obj.__wbg_ptr = ptr;
        AnimationPoolFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        AnimationPoolFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_animationpool_free(ptr, 0);
    }
    /**
     * @param {number} count
     * @returns {number}
     */
    allocateLengthsBuffer(count) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(count);
        const ret = wasm.animationpool_allocateLengthsBuffer(this.__wbg_ptr, count);
        return ret >>> 0;
    }
    /**
     * @param {number} ptr
     * @param {number} count
     */
    deallocateLengthsBuffer(ptr, count) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(ptr);
        _assertNum(count);
        wasm.animationpool_deallocateLengthsBuffer(this.__wbg_ptr, ptr, count);
    }
    /**
     * @param {number} track_lengths
     * @param {number} track_count
     * @returns {number}
     */
    createBoneTracks(track_lengths, track_count) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(track_lengths);
        _assertNum(track_count);
        const ret = wasm.animationpool_createBoneTracks(this.__wbg_ptr, track_lengths, track_count);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getBoneTrackFrameNumbers(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getBoneTrackFrameNumbers(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getBoneTrackRotations(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getBoneTrackRotations(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getBoneTrackRotationInterpolations(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getBoneTrackRotationInterpolations(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getBoneTrackPhysicsToggles(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getBoneTrackPhysicsToggles(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
     * @param {number} track_lengths
     * @param {number} track_count
     * @returns {number}
     */
    createMovableBoneTracks(track_lengths, track_count) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(track_lengths);
        _assertNum(track_count);
        const ret = wasm.animationpool_createMovableBoneTracks(this.__wbg_ptr, track_lengths, track_count);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getMovableBoneTrackFrameNumbers(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMovableBoneTrackFrameNumbers(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getMovableBoneTrackPositions(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMovableBoneTrackPositions(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getMovableBoneTrackPositionInterpolations(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMovableBoneTrackPositionInterpolations(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getMovableBoneTrackRotations(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMovableBoneTrackRotations(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getMovableBoneTrackRotationInterpolations(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMovableBoneTrackRotationInterpolations(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getMovableBoneTrackPhysicsToggles(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMovableBoneTrackPhysicsToggles(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
     * @param {number} track_lengths
     * @param {number} track_count
     * @returns {number}
     */
    createMorphTracks(track_lengths, track_count) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(track_lengths);
        _assertNum(track_count);
        const ret = wasm.animationpool_createMorphTracks(this.__wbg_ptr, track_lengths, track_count);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getMorphTrackFrameNumbers(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMorphTrackFrameNumbers(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
     * @param {number} tracks
     * @param {number} index
     * @returns {number}
     */
    getMorphTrackWeights(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _as