reze-engine 0.62.1 → 0.64.0

package/dist/unity/globals.js

@@ -0,0 +1,340 @@
+// The game pipeline's per-frame globals, computed from the engine's scene.
+//
+// The game's shaders read what its render pipeline (UnityEngine.Rendering.
+// Replica / ReplicaExt, decompiled from GameAssembly.dll) sets before a camera
+// renders: the camera, the main light, the Forward+ light table and its bins,
+// the cascades, the ambient SH, fog, time. ag-rip's AGSimPipeline.cs and
+// AGSimShadows.cs reproduce those calls in Unity, method by method, and the
+// compare page proved them against the game's frames; this is that code again,
+// fed by the engine instead of by a Unity scene.
+//
+// SPACE. The game's shaders work in the game's world, and the engine's scene
+// is that world as ag-rip exports it to MMD: `scale` PMX units per game unit
+// (8: the one-scene-scale rule) and turned half round Y — game (x, y, z) is
+// PMX (-x, y, -z), the convention its camera and motion VMDs and its stages
+// share. Everything positional is handed over through that map (gameToEngine
+// and back) — the camera, the lights and their reach, the cascades — so a
+// shader's distances (outline widths, light ranges, fog) and directions mean
+// what they meant in the game. A half turn keeps handedness: both are
+// left-handed and Y-up.
+//
+// CLIP SPACE. naga negates y on the way out of every vertex shader (Vulkan to
+// WebGPU), so the projection handed to the shaders is the engine's with y
+// flipped: the two flips cancel and a native draw lands exactly where the
+// engine's own draw of the same triangle would, on the same depth.
+const PLUS_MAX = 255;
+/** Column-major 4x4 multiply. */
+export function mul4(a, b) {
+    const o = new Float32Array(16);
+    for (let c = 0; c < 4; c++)
+        for (let r = 0; r < 4; r++) {
+            let s = 0;
+            for (let k = 0; k < 4; k++)
+                s += a[k * 4 + r] * b[c * 4 + k];
+            o[c * 4 + r] = s;
+        }
+    return o;
+}
+export function invert4(m) {
+    const a = m;
+    const o = new Float32Array(16);
+    const a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3], a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+    const a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11], a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+    const b00 = a00 * a11 - a01 * a10, b01 = a00 * a12 - a02 * a10, b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11, b04 = a01 * a13 - a03 * a11, b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30, b07 = a20 * a32 - a22 * a30, b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31, b10 = a21 * a33 - a23 * a31, b11 = a22 * a33 - a23 * a32;
+    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    if (!det)
+        return Float32Array.from([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+    det = 1 / det;
+    o[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+    o[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+    o[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+    o[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+    o[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+    o[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+    o[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+    o[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+    o[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+    o[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+    o[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+    o[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+    o[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+    o[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+    o[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+    o[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+    return o;
+}
+/** Game world -> engine world: `s` PMX per unit, half a turn about Y. */
+export function gameToEngine(s) {
+    return Float32Array.from([-s, 0, 0, 0, 0, s, 0, 0, 0, 0, -s, 0, 0, 0, 0, 1]);
+}
+/** Engine world -> game world. */
+export function engineToGame(s) {
+    return Float32Array.from([-1 / s, 0, 0, 0, 0, 1 / s, 0, 0, 0, 0, -1 / s, 0, 0, 0, 0, 1]);
+}
+/** An engine point in the game's world. */
+export function gamePoint(p, s) {
+    return [-p[0] / s, p[1] / s, -p[2] / s];
+}
+/** An engine direction in the game's world. */
+export function gameDir(d) {
+    return [-d[0], d[1], -d[2]];
+}
+/** Uniform scale, as a column-major matrix. */
+export function scale4(s) {
+    return Float32Array.from([s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1]);
+}
+/** The projection with clip y negated — undone by naga's own negation. */
+export function flipY(p) {
+    const o = Float32Array.from(p);
+    for (let c = 0; c < 4; c++)
+        o[c * 4 + 1] = -p[c * 4 + 1];
+    return o;
+}
+/**
+ * The engine's folded SH9 (ibl.ts: c0 + c1·y + c2·z + c3·x + c4·xy + c5·yz +
+ * c6·(3z²−1) + c7·xz + c8·(x²−y²)) as Unity's seven shader constants —
+ * SHA = (x, y, z, constant), SHB = (xy, yz, z², zx), SHC = (x²−y²) — the same
+ * polynomial, regrouped.
+ */
+export function unitySH(sh, flat) {
+    const out = {};
+    const ch = ["r", "g", "b"];
+    const c = (i, k) => (sh ? sh[i * 3 + k] : i === 0 ? flat[k] : 0);
+    for (let k = 0; k < 3; k++) {
+        out[`_Replica_SHA${ch[k]}`] = [c(3, k), c(1, k), c(2, k), c(0, k) - c(6, k)];
+        out[`_Replica_SHB${ch[k]}`] = [c(4, k), c(5, k), 3 * c(6, k), c(7, k)];
+    }
+    out._Replica_SHC = [c(8, 0), c(8, 1), c(8, 2), 1];
+    return out;
+}
+/** Everything the frame sets, by name. */
+export function unityFrameGlobals(f) {
+    const s = f.scale;
+    const g = {};
+    // ---- the camera (UnityPerFrame), in game units
+    // Unity's own pair, so what a shader rebuilds from them means what it did
+    // in the game: the view in game units, right-handed and looking down -Z;
+    // the projection on game-unit depths (the engine's, conjugated by the scale
+    // and the z flip, and divided through by s, which leaves the same NDC). Their
+    // product puts every vertex exactly where the engine's own draw of it lands.
+    const zFlip = Float32Array.from([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]);
+    const view = mul4(zFlip, mul4(scale4(1 / s), mul4(f.view, gameToEngine(s))));
+    const toEngineView = mul4(scale4(s), zFlip);
+    const proj = flipY(mul4(f.proj, toEngineView));
+    for (let i = 0; i < 16; i++)
+        proj[i] /= s;
+    const vp = mul4(proj, view);
+    const w = Math.max(1, f.width);
+    const h = Math.max(1, f.height);
+    const near = f.near / s;
+    const far = f.far / s;
+    g._WorldSpaceCameraPos = [...gamePoint(f.eye, s), 1];
+    g.unity_MatrixV = view;
+    g.unity_MatrixInvV = invert4(view);
+    g.unity_MatrixP = proj;
+    g.glstate_matrix_projection = proj;
+    g.unity_MatrixVP = vp;
+    g._NonJitteredViewProjMatrix = vp;
+    // x = -1: a flipped projection, as Unity's into a texture.
+    g._ProjectionParams = [-1, near, far, 1 / far];
+    g._ScreenParams = [w, h, 1 + 1 / w, 1 + 1 / h];
+    g._ScaledScreenParams = [w, h, 1 + 1 / w, 1 + 1 / h];
+    g._ZBufferParams = [-1 + far / near, 1, (-1 + far / near) / far, 1 / far];
+    g.unity_OrthoParams = [0, 0, 0, 0];
+    const t = f.time;
+    g._Time = [t / 20, t, t * 2, t * 3];
+    g._SinTime = [Math.sin(t / 8), Math.sin(t / 4), Math.sin(t / 2), Math.sin(t)];
+    g._CosTime = [Math.cos(t / 8), Math.cos(t / 4), Math.cos(t / 2), Math.cos(t)];
+    const dt = Math.max(f.dt, 1e-4);
+    g.unity_DeltaTime = [dt, 1 / dt, dt, 1 / dt];
+    // UpdateRenderSettings: sim_Time = (t - floor t, floor t)
+    g.sim_Time = [t - Math.floor(t), Math.floor(t), 0, 0];
+    g.identity_matrix = scale4(1);
+    // ---- LightingFeatures.SetupLightings / PlusLighting SetupMainLightConstants
+    if (f.sunDirection) {
+        const d = gameDir(f.sunDirection);
+        g.SimMainLightDir = [-d[0], -d[1], -d[2], 0];
+        g.SimMainLightColor = [...f.sunColor, 1];
+        g.SimMainLightColorNoInt = [...f.sunColor, 1];
+        // As the game's pipeline leaves it (recorded): the way the light travels.
+        g._MainLightPosition = [d[0], d[1], d[2], 0];
+        g.sim_ShadowLightDirection = [-d[0], -d[1], -d[2], 0];
+        g._MainLightColor = [...f.sunColor, 1];
+    }
+    else {
+        g.SimMainLightDir = [0, 0, 0, 0];
+        g.SimMainLightColor = [0, 0, 0, 0];
+        g.SimMainLightColorNoInt = [0, 0, 0, 0];
+        g._MainLightPosition = [0, 1, 0, 0];
+        g._MainLightColor = [0, 0, 0, 0];
+    }
+    // ---- ForwardFeature.SetupRenderFeature, UpdateRenderSettings: a scene
+    // with no stage of the game's has no settings of its own — the defaults the
+    // game's SceneSetting starts from.
+    g.SimSceneTint = [1, 1, 1, 1];
+    g._ReceiveSceneShadow = 1;
+    g.sim_FogRotation = 0;
+    g.sim_FogInverseRootRotationMatrix = scale4(1);
+    g.sim_FogColor = [0, 0, 0, 0];
+    g.sim_FogColor2 = [0, 0, 0, 0];
+    g.sim_FogParams = [0, 1, 0, 1];
+    g.sim_FogDirectionalColor = [0, 0, 0, 0];
+    g.sim_FogDirectionalDir = [0, 0, 1, 0];
+    g.sim_FogDirectionalFalloff = 0;
+    g.sim_DYN_FOG_LINEAR_Variable = 0;
+    g.sim_DynFogColor = [0, 0, 0, 0];
+    g.sim_DynFogParams = [0, 1, 0, 1];
+    g._ProbeLightingBase = [1, 1, 1, 1];
+    g._ProbeLightingScale = 0;
+    g._AcceptLightProbe = 0;
+    g.sim_VertexAmbientScale = 1;
+    g._EnableShadowScatter = 0;
+    g._ShadowScatterColor = [0, 0, 0, 0];
+    g._ShadowScatterRange = 0;
+    // realtimeShadowColor's default grey, made linear (ConvertSRGBToActiveColorSpace)
+    g._SubtractiveShadowColor = [0.2158605, 0.2158605, 0.2158605, 1];
+    g._AmbientOcclusionParam = [0, 0, 0, 0];
+    g.sim_EnvCubeScale = 0;
+    g.sim_EnvCube_BoxMin = [0, 0, 0, 0];
+    g.sim_EnvCube_BoxMax = [0, 0, 0, 0];
+    g.sim_EnvCube_ProbePosition = [0, 0, 0, 0];
+    // ---- SetupEnvironmentLighting: the scene's ambient SH
+    // The half turn negates x and z: the terms odd in either (z, x, xy, yz) flip.
+    const sh = f.ambientSH ? Array.from(f.ambientSH) : null;
+    if (sh)
+        for (const i of [2, 3, 4, 5])
+            for (let k = 0; k < 3; k++)
+                sh[i * 3 + k] = -sh[i * 3 + k];
+    Object.assign(g, unitySH(sh, f.ambientFlat));
+    // ---- a game stage's own settings over all of the above
+    if (f.settings)
+        Object.assign(g, f.settings);
+    // ---- PlusLightingFeature: the light table, one tile and one depth bin
+    // holding every light (binning only culls; the shader applies each range)
+    const n = Math.min(f.lights.length, PLUS_MAX);
+    const pos = [], col = [], att = [], dir = [];
+    const extra = [], w2l = [];
+    const simDir = [], simColorW = [];
+    const types = new Float32Array(PLUS_MAX);
+    const masks = new Uint32Array(PLUS_MAX);
+    const ident = scale4(1);
+    for (let i = 0; i < PLUS_MAX; i++) {
+        const l = f.lights[i];
+        if (i >= n || !l) {
+            pos.push([0, 0, 0, 0]);
+            col.push([0, 0, 0, 0]);
+            att.push([0, 1, 0, 1]);
+            dir.push([0, 0, 0, 0]);
+            extra.push([0, 0, 0, 0]);
+            w2l.push(ident);
+            continue;
+        }
+        const spot = l.aim[0] !== 0 || l.aim[1] !== 0 || l.aim[2] !== 0;
+        const r = l.radius / s;
+        const r2 = r * r;
+        // LightInfo.GetPunctualLightDistanceAttenuation / GetSpotAngleAttenuation
+        let z = 0;
+        let ww = 1;
+        if (spot) {
+            const inv = 1 / Math.max(l.cosInner - l.cosOuter, 0.001);
+            z = inv;
+            ww = -l.cosOuter * inv;
+        }
+        pos.push([...gamePoint(l.position, s), 1]);
+        // The engine's lamp brightness is per its own unit; the inverse square in
+        // game units is s² larger at the same place, so the colour carries 1/s².
+        col.push([l.color[0] / (s * s), l.color[1] / (s * s), l.color[2] / (s * s), 1]);
+        att.push([1 / Math.max(r2, 1e-4), -r2 / (r2 * 0.64 - r2), z, ww]);
+        const u = l.unity;
+        if (u) {
+            col[col.length - 1][3] = u.colorW;
+            dir.push(u.spotDir.slice(0, 4));
+            extra.push(u.extra.slice(0, 4));
+            w2l.push(u.worldToLight ? Float32Array.from(u.worldToLight) : ident);
+            simDir.push((u.simSpotDir ?? u.spotDir).slice(0, 4));
+            simColorW.push(u.simColorW ?? 1);
+            types[i] = u.lightType;
+        }
+        else {
+            // The pipeline's own defaults for a light it did not author: forward
+            // along the aim, w = 1 / the 0.1 sphere every game lamp of these stages has.
+            const a = gameDir(l.aim);
+            dir.push(spot ? [...a, 10] : [0, 0, 1, 10]);
+            extra.push([0, 0, 0, 0]);
+            w2l.push(ident);
+            simDir.push(spot ? [...a, 10] : [0, 0, 1, 10]);
+            simColorW.push(1);
+            types[i] = spot ? 0 : 2;
+        }
+        masks[i] = l.layers >>> 0;
+    }
+    g._AdditionalLightsPosition = pos;
+    g._AdditionalLightsColor = col;
+    g._AdditionalLightsAttenuation = att;
+    g._AdditionalLightsSpotDir = dir;
+    g._AdditionalLightsExtra = extra;
+    g._AdditionalLightsWorldToLights = w2l;
+    g._AdditionalLightsLightTypes = types;
+    g._AdditionalLightsLayerMasks = masks;
+    g._AdditionalLightsCookieEnableBits = new Float32Array(8);
+    const words = Math.max(1, Math.ceil(n / 32));
+    const zb = new Uint32Array(4096);
+    const tiles = new Uint32Array(16384);
+    zb[0] = n > 0 ? ((n - 1) << 16) >>> 0 : 0xffff;
+    for (let k = 0; k < words; k++) {
+        const bits = Math.min(Math.max(n - k * 32, 0), 32);
+        const m = bits >= 32 ? 0xffffffff : ((1 << bits) >>> 0) - 1;
+        zb[1 + k] = m >>> 0;
+        tiles[k] = m >>> 0;
+    }
+    // LightingFeatures' own copy for the per-vertex lights: the first 16, colour
+    // without the intensity in w.
+    g.SimAdditionalLightPosition = pos.slice(0, 16);
+    g.SimAdditionalLightColor = col
+        .slice(0, 16)
+        .map((c, i) => (c[0] || c[1] || c[2] ? [c[0], c[1], c[2], simColorW[i] ?? 1] : [0, 0, 0, 0]));
+    g.SimAdditionalLightAttenuation = att.slice(0, 16);
+    g.SimAdditionalLightSpotDir = simDir.slice(0, 16).concat(dir.slice(simDir.length, 16));
+    g._PlusLighting_ZBins = zb;
+    g._PlusLighting_Tiles = tiles;
+    g._PlusLightingParams0 = [0, 0, 1, words];
+    g._PlusLightingParams1 = [1000, 0, 0, 0];
+    // ---- the main light's cascades, sampled from the engine's atlas
+    if (f.shadow) {
+        const sh = f.shadow;
+        const unit = sh.tileSize / sh.atlasSize;
+        const w2s = [];
+        for (let i = 0; i < 4; i++) {
+            const vpe = sh.viewProj[i];
+            const tile = sh.tiles[i];
+            if (!vpe || !tile) {
+                w2s.push(scale4(0));
+                continue;
+            }
+            // ndc -> the tile's uv (y down, as the atlas is addressed), depth as drawn
+            const tx = tile[0] / sh.atlasSize;
+            const ty = tile[1] / sh.atlasSize;
+            const toTile = Float32Array.from([0.5 * unit, 0, 0, 0, 0, -0.5 * unit, 0, 0, 0, 0, 1, 0, 0.5 * unit + tx, 0.5 * unit + ty, 0, 1]);
+            w2s.push(mul4(toTile, mul4(vpe, gameToEngine(s))));
+        }
+        g._MainLightWorldToShadow = w2s;
+        for (let i = 0; i < 4; i++) {
+            const sp = sh.spheres[i];
+            g[`_CascadeShadowSplitSpheres${i}`] = sp ? [...gamePoint(sp.center, s), sp.radius / s] : [0, 0, 0, 0];
+        }
+        const r = (i) => (sh.spheres[i] ? (sh.spheres[i].radius / s) ** 2 : 0);
+        g._CascadeShadowSplitSphereRadii = [r(0), r(1), r(2), r(3)];
+        const half = 0.5 / sh.atlasSize;
+        g._MainLightShadowOffset0 = [-half, -half, half, -half];
+        g._MainLightShadowOffset1 = [-half, half, half, half];
+        g._MainLightShadowmapSize = [1 / sh.atlasSize, 1 / sh.atlasSize, sh.atlasSize, sh.atlasSize];
+        g._MainLightShadowParams = [f.sunShadow, 1, 0, 0];
+    }
+    else {
+        g._MainLightShadowParams = [0, 0, 0, 0];
+    }
+    return g;
+}

package/dist/unity/host.d.ts

@@ -0,0 +1,137 @@
+import { type PassState } from "./state";
+export type NativeBinding = {
+    group: number;
+    binding: number;
+    space: string;
+    name: string;
+    type: string;
+    stages: string[];
+};
+export type NativeMember = {
+    name: string;
+    offset: number;
+    size: number;
+    type: string;
+};
+export type NativeStruct = {
+    size: number;
+    members: NativeMember[];
+};
+export type NativeShaderInfo = {
+    bindings: Record<string, NativeBinding>;
+    structs: Record<string, NativeStruct>;
+    vertexInputs: {
+        location: number;
+        name: string;
+        type: string;
+    }[];
+};
+/** One translated shader variant: what shader_wgsl.py writes for a pass. */
+export type NativeShader = {
+    name: string;
+    vert: string;
+    frag: string;
+    info: NativeShaderInfo;
+};
+/** A value a uniform member takes: a scalar, a flat vector or matrix, an array of
+ *  those, or raw integer bits (Uint32Array — never passed through a float). */
+export type NativeValue = number | ArrayLike<number> | ArrayLike<ArrayLike<number>>;
+/** Name -> value; the first source that has a name wins. */
+export type ValueSource = Record<string, NativeValue | undefined>;
+/** One vertex stream a draw binds, by the semantic a shader input names. */
+export type NativeStream = {
+    buffer: GPUBuffer;
+    offset: number;
+    stride: number;
+    format: GPUVertexFormat;
+};
+/** "in_u002e_var_u002e_TEXCOORD2_" -> "TEXCOORD2"; TEXCOORD alone is 0. */
+export declare function semantic(inputName: string): string;
+/**
+ * The fragment module, returning the engine's attachments.
+ *
+ * naga writes the entry point last: it copies its inputs to private globals,
+ * calls the translated body, and returns the one SV_Target. That return is
+ * rewritten to the engine's output struct — the colour as the game computed
+ * it, the aux mask (bloom on, canvas alpha from the colour's alpha) and, when
+ * the device has an id attachment, a zero id. Anything else about the module
+ * is left exactly as translated.
+ */
+export declare function wrapFragment(frag: string, ids: boolean): string;
+export type NativeHostTargets = {
+    /** The scene pass's colour formats, in attachment order: hdr, aux[, id]. */
+    colorFormats: GPUTextureFormat[];
+    depthFormat: GPUTextureFormat;
+    sampleCount: number;
+    reversedZ: boolean;
+};
+export type NativeDraw = {
+    shader: string;
+    state: PassState;
+    streams: NativeStream[];
+    index: {
+        buffer: GPUBuffer;
+        format: GPUIndexFormat;
+        offset: number;
+        count: number;
+    };
+    /** Name -> value, first match wins. */
+    sources: ValueSource[];
+    /** Texture name -> view (material slots, globals, render targets). */
+    textures: Record<string, GPUTextureView | undefined>;
+    /** Texture name -> its sampler (wrap and filter as the game imported it);
+     *  a texture without one samples repeating, trilinear. */
+    samplers?: Record<string, GPUSampler | undefined>;
+    /** Separates draws' uniform buffers: one renderer's pass, one slot. */
+    key: string;
+    /** The pass the frame's globals belong to (main, a shadow cascade): a block
+     *  filled from the globals alone is one buffer per shader and pass, shared by
+     *  every draw in it. */
+    pass?: string;
+};
+export declare class NativeHost {
+    private device;
+    private targets;
+    private fallback;
+    private prepared;
+    private pipelines;
+    private draws;
+    private shared;
+    private frame;
+    private sampler;
+    /** Names no source supplied, with how often — the audit the compare page showed. */
+    readonly missing: Map<string, number>;
+    readonly errors: string[];
+    constructor(device: GPUDevice, targets: NativeHostTargets, fallback: {
+        white: GPUTextureView;
+        black: GPUTextureView;
+        blackCube: GPUTextureView;
+        depth: GPUTextureView;
+        comparison: GPUSampler;
+    });
+    has(name: string): boolean;
+    /** Register a translated shader. Idempotent by name. */
+    register(shader: NativeShader): void;
+    /** The vertex inputs a shader reads, by Unity semantic, in location order. */
+    inputs(name: string): {
+        location: number;
+        semantic: string;
+    }[];
+    private pipeline;
+    private lookup;
+    /** A new frame: shared blocks are brought up to date once in it. */
+    beginFrame(): void;
+    private lookupFrom;
+    private newBlock;
+    /** Bring a block up to date with its sources; upload what changed. */
+    private fill;
+    /** Encode one draw into the scene pass. */
+    draw(pass: GPURenderPassEncoder, d: NativeDraw): void;
+    /** sampler_AlbedoTex / samplerAlbedoTex -> the sampler of the texture it pairs with. */
+    private samplerFor;
+    private textureView;
+    /** Forget a draw's buffers (its model left). */
+    release(prefix: string): void;
+}
+export declare function sameBytes(a: Uint8Array, b: Uint8Array): boolean;
+//# sourceMappingURL=host.d.ts.map

package/dist/unity/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../src/unity/host.ts"],"names":[],"mappings":"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"}