babylon-mmd
Version:
babylon.js mmd loader and runtime
658 lines (602 loc) • 20.8 kB
JavaScript
let wasm;
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);
}
export function init() {
wasm.init();
}
/**
* @param {number} size
* @returns {number}
*/
export function allocateBuffer(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) {
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);
}
function isLikeNone(x) {
return x === undefined || x === null;
}
const AnimationPoolFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_animationpool_free(ptr >>> 0, 1));
export class AnimationPool {
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) {
const ret = wasm.animationpool_allocateLengthsBuffer(this.__wbg_ptr, count);
return ret >>> 0;
}
/**
* @param {number} ptr
* @param {number} count
*/
deallocateLengthsBuffer(ptr, count) {
wasm.animationpool_deallocateLengthsBuffer(this.__wbg_ptr, ptr, count);
}
/**
* @param {number} track_lengths
* @param {number} track_count
* @returns {number}
*/
createBoneTracks(track_lengths, 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) {
const ret = wasm.animationpool_getBoneTrackFrameNumbers(this.__wbg_ptr, tracks, index);
return ret >>> 0;
}
/**
* @param {number} tracks
* @param {number} index
* @returns {number}
*/
getBoneTrackRotations(tracks, 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) {
const ret = wasm.animationpool_getBoneTrackRotationInterpolations(this.__wbg_ptr, tracks, index);
return ret >>> 0;
}
/**
* @param {number} tracks
* @param {number} index
* @returns {number}
*/
getBoneTrackPhysicsToggles(tracks, 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) {
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) {
const ret = wasm.animationpool_getMovableBoneTrackFrameNumbers(this.__wbg_ptr, tracks, index);
return ret >>> 0;
}
/**
* @param {number} tracks
* @param {number} index
* @returns {number}
*/
getMovableBoneTrackPositions(tracks, 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) {
const ret = wasm.animationpool_getMovableBoneTrackPositionInterpolations(this.__wbg_ptr, tracks, index);
return ret >>> 0;
}
/**
* @param {number} tracks
* @param {number} index
* @returns {number}
*/
getMovableBoneTrackRotations(tracks, 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) {
const ret = wasm.animationpool_getMovableBoneTrackRotationInterpolations(this.__wbg_ptr, tracks, index);
return ret >>> 0;
}
/**
* @param {number} tracks
* @param {number} index
* @returns {number}
*/
getMovableBoneTrackPhysicsToggles(tracks, 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) {
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) {
const ret = wasm.animationpool_getMorphTrackFrameNumbers(this.__wbg_ptr, tracks, index);
return ret >>> 0;
}
/**
* @param {number} tracks
* @param {number} index
* @returns {number}
*/
getMorphTrackWeights(tracks, index) {
const ret = wasm.animationpool_getMorphTrackWeights(this.__wbg_ptr, tracks, index);
return ret >>> 0;
}
/**
* @param {number} bone_tracks_ptr
* @param {number} bone_track_count
* @param {number} movable_bone_tracks_ptr
* @param {number} movable_bone_track_count
* @param {number} morph_tracks_ptr
* @param {number} morph_track_count
* @param {number} property_track_length
* @param {number} property_track_ik_count
* @returns {number}
*/
createAnimation(bone_tracks_ptr, bone_track_count, movable_bone_tracks_ptr, movable_bone_track_count, morph_tracks_ptr, morph_track_count, property_track_length, property_track_ik_count) {
const ret = wasm.animationpool_createAnimation(this.__wbg_ptr, bone_tracks_ptr, bone_track_count, movable_bone_tracks_ptr, movable_bone_track_count, morph_tracks_ptr, morph_track_count, property_track_length, property_track_ik_count);
return ret >>> 0;
}
/**
* @param {number} animation_ptr
* @returns {number}
*/
getPropertyTrackFrameNumbers(animation_ptr) {
const ret = wasm.animationpool_getPropertyTrackFrameNumbers(this.__wbg_ptr, animation_ptr);
return ret >>> 0;
}
/**
* @param {number} animation_ptr
* @param {number} index
* @returns {number}
*/
getPropertyTrackIkStates(animation_ptr, index) {
const ret = wasm.animationpool_getPropertyTrackIkStates(this.__wbg_ptr, animation_ptr, index);
return ret >>> 0;
}
/**
* @param {number} animation_ptr
*/
destroyAnimation(animation_ptr) {
wasm.animationpool_destroyAnimation(this.__wbg_ptr, animation_ptr);
}
/**
* @param {number} animation_ptr
* @returns {number}
*/
createBoneBindIndexMap(animation_ptr) {
const ret = wasm.animationpool_createBoneBindIndexMap(this.__wbg_ptr, animation_ptr);
return ret >>> 0;
}
/**
* @param {number} animation_ptr
* @returns {number}
*/
createMovableBoneBindIndexMap(animation_ptr) {
const ret = wasm.animationpool_createMovableBoneBindIndexMap(this.__wbg_ptr, animation_ptr);
return ret >>> 0;
}
/**
* @param {number} animation_ptr
* @param {number} morph_lengths
* @returns {number}
*/
createMorphBindIndexMap(animation_ptr, morph_lengths) {
const ret = wasm.animationpool_createMorphBindIndexMap(this.__wbg_ptr, animation_ptr, morph_lengths);
return ret >>> 0;
}
/**
* @param {number} morph_bind_index_map
* @param {number} index
* @returns {number}
*/
getNthMorphBindIndexMap(morph_bind_index_map, index) {
const ret = wasm.animationpool_getNthBoneToBodyBindIndexMap(this.__wbg_ptr, morph_bind_index_map, index);
return ret >>> 0;
}
/**
* @param {number} animation_ptr
* @returns {number}
*/
createIkSolverBindIndexMap(animation_ptr) {
const ret = wasm.animationpool_createIkSolverBindIndexMap(this.__wbg_ptr, animation_ptr);
return ret >>> 0;
}
/**
* @param {number} animation_ptr
* @param {number} body_lengths
* @returns {number}
*/
createBoneToBodyBindIndexMap(animation_ptr, body_lengths) {
const ret = wasm.animationpool_createBoneToBodyBindIndexMap(this.__wbg_ptr, animation_ptr, body_lengths);
return ret >>> 0;
}
/**
* @param {number} bone_to_body_bind_index_map
* @param {number} index
* @returns {number}
*/
getNthBoneToBodyBindIndexMap(bone_to_body_bind_index_map, index) {
const ret = wasm.animationpool_getNthBoneToBodyBindIndexMap(this.__wbg_ptr, bone_to_body_bind_index_map, index);
return ret >>> 0;
}
/**
* @param {number} animation_ptr
* @param {number} bone_bind_index_map
* @param {number} movable_bone_bind_index_map
* @param {number} morph_bind_index_map
* @param {number} ik_solver_bind_index_map
* @param {number} bone_to_body_bind_index_map
* @returns {number}
*/
createRuntimeAnimation(animation_ptr, bone_bind_index_map, movable_bone_bind_index_map, morph_bind_index_map, ik_solver_bind_index_map, bone_to_body_bind_index_map) {
const ret = wasm.animationpool_createRuntimeAnimation(this.__wbg_ptr, animation_ptr, bone_bind_index_map, movable_bone_bind_index_map, morph_bind_index_map, ik_solver_bind_index_map, bone_to_body_bind_index_map);
return ret >>> 0;
}
/**
* @param {number} runtime_animation_ptr
*/
destroyRuntimeAnimation(runtime_animation_ptr) {
wasm.animationpool_destroyRuntimeAnimation(this.__wbg_ptr, runtime_animation_ptr);
}
/**
* @param {number} animation_ptr
* @param {number} mmd_model_ptr
* @param {number} frame_time
*/
animateMmdModel(animation_ptr, mmd_model_ptr, frame_time) {
wasm.animationpool_animateMmdModel(this.__wbg_ptr, animation_ptr, mmd_model_ptr, frame_time);
}
}
const MmdRuntimeFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_mmdruntime_free(ptr >>> 0, 1));
export class MmdRuntime {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(MmdRuntime.prototype);
obj.__wbg_ptr = ptr;
MmdRuntimeFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
MmdRuntimeFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_mmdruntime_free(ptr, 0);
}
/**
* @param {number} serialized_metadata_ptr
* @param {number} serialized_metadata_size
* @returns {number}
*/
createMmdModel(serialized_metadata_ptr, serialized_metadata_size) {
const ret = wasm.mmdruntime_createMmdModel(this.__wbg_ptr, serialized_metadata_ptr, serialized_metadata_size);
return ret >>> 0;
}
/**
* @param {number} ptr
*/
destroyMmdModel(ptr) {
wasm.mmdruntime_destroyMmdModel(this.__wbg_ptr, ptr);
}
/**
* @param {number} ptr
* @returns {number}
*/
getAnimationArena(ptr) {
const ret = wasm.mmdruntime_getAnimationArena(this.__wbg_ptr, ptr);
return ret >>> 0;
}
/**
* @param {number} ptr
* @returns {number}
*/
getAnimationIkSolverStateArena(ptr) {
const ret = wasm.mmdruntime_getAnimationIkSolverStateArena(this.__wbg_ptr, ptr);
return ret >>> 0;
}
/**
* @param {number} ptr
* @returns {number}
*/
getAnimationRigidBodyStateArena(ptr) {
const ret = wasm.mmdruntime_getAnimationRigidBodyStateArena(this.__wbg_ptr, ptr);
return ret >>> 0;
}
/**
* @param {number} ptr
* @returns {number}
*/
getAnimationRigidBodyStateArenaSize(ptr) {
const ret = wasm.mmdruntime_getAnimationRigidBodyStateArenaSize(this.__wbg_ptr, ptr);
return ret >>> 0;
}
/**
* @param {number} ptr
* @returns {number}
*/
getAnimationMorphArena(ptr) {
const ret = wasm.mmdruntime_getAnimationMorphArena(this.__wbg_ptr, ptr);
return ret >>> 0;
}
/**
* @param {number} ptr
* @returns {number}
*/
getBoneWorldMatrixArena(ptr) {
const ret = wasm.mmdruntime_getBoneWorldMatrixArena(this.__wbg_ptr, ptr);
return ret >>> 0;
}
/**
* @param {number} ptr
* @returns {number}
*/
createBoneWorldMatrixBackBuffer(ptr) {
const ret = wasm.mmdruntime_createBoneWorldMatrixBackBuffer(this.__wbg_ptr, ptr);
return ret >>> 0;
}
/**
* @param {number} ptr
* @param {number} runtime_animation
*/
setRuntimeAnimation(ptr, runtime_animation) {
wasm.mmdruntime_setRuntimeAnimation(this.__wbg_ptr, ptr, runtime_animation);
}
/**
* @param {number} ptr
* @param {number} rigidbody_state_size
*/
useExternalPhysics(ptr, rigidbody_state_size) {
wasm.mmdruntime_useExternalPhysics(this.__wbg_ptr, ptr, rigidbody_state_size);
}
/**
* @param {number | null} [frame_time]
*/
beforePhysics(frame_time) {
wasm.mmdruntime_beforePhysics(this.__wbg_ptr, isLikeNone(frame_time) ? 0x100000001 : Math.fround(frame_time));
}
afterPhysics() {
wasm.mmdruntime_afterPhysics(this.__wbg_ptr);
}
/**
* @returns {number}
*/
getLockStatePtr() {
const ret = wasm.mmdruntime_getLockStatePtr(this.__wbg_ptr);
return ret >>> 0;
}
swapWorldMatrixBuffer() {
wasm.mmdruntime_swapWorldMatrixBuffer(this.__wbg_ptr);
}
/**
* @returns {number}
*/
acquireDiagnosticErrorResult() {
const ret = wasm.mmdruntime_acquireDiagnosticErrorResult(this.__wbg_ptr);
return ret >>> 0;
}
/**
* @returns {number}
*/
acquireDiagnosticWarningResult() {
const ret = wasm.mmdruntime_acquireDiagnosticWarningResult(this.__wbg_ptr);
return ret >>> 0;
}
/**
* @returns {number}
*/
acquireDiagnosticInfoResult() {
const ret = wasm.mmdruntime_acquireDiagnosticInfoResult(this.__wbg_ptr);
return ret >>> 0;
}
releaseDiagnosticResult() {
wasm.mmdruntime_releaseDiagnosticResult(this.__wbg_ptr);
}
}
const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
async function __wbg_load(module, imports) {
if (typeof Response === 'function' && module instanceof Response) {
if (typeof WebAssembly.instantiateStreaming === 'function') {
try {
return await WebAssembly.instantiateStreaming(module, imports);
} catch (e) {
const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
} else {
throw e;
}
}
}
const bytes = await module.arrayBuffer();
return await WebAssembly.instantiate(bytes, imports);
} else {
const instance = await WebAssembly.instantiate(module, imports);
if (instance instanceof WebAssembly.Instance) {
return { instance, module };
} else {
return instance;
}
}
}
function __wbg_get_imports() {
const imports = {};
imports.wbg = {};
imports.wbg.__wbindgen_init_externref_table = function() {
const table = wasm.__wbindgen_export_0;
const offset = table.grow(4);
table.set(0, undefined);
table.set(offset + 0, undefined);
table.set(offset + 1, null);
table.set(offset + 2, true);
table.set(offset + 3, false);
;
};
imports.wbg.__wbindgen_throw = function(arg0, arg1) {
throw new Error(getStringFromWasm0(arg0, arg1));
};
return imports;
}
function __wbg_init_memory(imports, memory) {
}
function __wbg_finalize_init(instance, module) {
wasm = instance.exports;
__wbg_init.__wbindgen_wasm_module = module;
cachedUint8ArrayMemory0 = null;
wasm.__wbindgen_start();
return wasm;
}
function initSync(module) {
if (wasm !== undefined) return wasm;
if (typeof module !== 'undefined') {
if (Object.getPrototypeOf(module) === Object.prototype) {
({module} = module)
} else {
console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
}
}
const imports = __wbg_get_imports();
__wbg_init_memory(imports);
if (!(module instanceof WebAssembly.Module)) {
module = new WebAssembly.Module(module);
}
const instance = new WebAssembly.Instance(module, imports);
return __wbg_finalize_init(instance, module);
}
async function __wbg_init(module_or_path) {
if (wasm !== undefined) return wasm;
if (typeof module_or_path !== 'undefined') {
if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
({module_or_path} = module_or_path)
} else {
console.warn('using deprecated parameters for the initialization function; pass a single object instead')
}
}
if (typeof module_or_path === 'undefined') {
module_or_path = new URL('index_bg.wasm', import.meta.url);
}
const imports = __wbg_get_imports();
if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
module_or_path = fetch(module_or_path);
}
__wbg_init_memory(imports);
const { instance, module } = await __wbg_load(await module_or_path, imports);
return __wbg_finalize_init(instance, module);
}
export { initSync };
export default __wbg_init;