Merge ce9b656271 into 9bc10bd391
This commit is contained in:
ANTIH3IK0
GitHub
commit
3ce82c884e
|
|
@ -0,0 +1,330 @@
|
||||||
|
// realistic_system.js - Global Realistic Lighting, Shadows, and Water Effects for ALL elements (including addons)
|
||||||
|
// Features:
|
||||||
|
// - Dynamic colored light propagation from fire, lights, hot pixels, etc.
|
||||||
|
// - Realistic occlusion shadows (darker in crevices/caves), modulated by light intensity
|
||||||
|
// - Wavy foam on ALL liquids (water, oils, mod liquids)
|
||||||
|
// - Works with any mods/addons automatically (liquids get waves, all get lit/shadowed)
|
||||||
|
// Performance: Low-res lightmap + cached shadows = smooth even on large views
|
||||||
|
// Install: Save as realistic_system.js in mods folder, load via Mod Manager
|
||||||
|
|
||||||
|
// === LIGHTMAP SYSTEM (Dynamic Glow/Light Propagation) ===
|
||||||
|
var lightmap = [];
|
||||||
|
var nextLightmap = [];
|
||||||
|
var lightmapScale = 4; // Higher = lower quality/faster (2-8 recommended)
|
||||||
|
var lightSourceBoost = 3;
|
||||||
|
var falloff = 0.85;
|
||||||
|
|
||||||
|
// Helper functions
|
||||||
|
function rgbToArray(colorString) {
|
||||||
|
if (typeof colorString !== "string") return [255,255,255];
|
||||||
|
if (colorString.startsWith("rgb")) {
|
||||||
|
return colorString.slice(4, -1).split(",").map(val => parseInt(val.trim()));
|
||||||
|
} else if (colorString.startsWith("#")) {
|
||||||
|
let hex = colorString.slice(1);
|
||||||
|
if (hex.length === 3) hex = hex.split("").map(char => char + char).join("");
|
||||||
|
let r = parseInt(hex.slice(0, 2), 16);
|
||||||
|
let g = parseInt(hex.slice(2, 4), 16);
|
||||||
|
let b = parseInt(hex.slice(4, 6), 16);
|
||||||
|
return [r, g, b];
|
||||||
|
}
|
||||||
|
return [255,255,255];
|
||||||
|
}
|
||||||
|
|
||||||
|
function scaleList(numbers, scale) {
|
||||||
|
return numbers.map(number => number * scale);
|
||||||
|
}
|
||||||
|
|
||||||
|
function rgbToHsv(r, g, b) {
|
||||||
|
r /= 255; g /= 255; b /= 255;
|
||||||
|
let max = Math.max(r, g, b), min = Math.min(r, g, b);
|
||||||
|
let h, s, v = max;
|
||||||
|
let d = max - min;
|
||||||
|
s = max === 0 ? 0 : d / max;
|
||||||
|
if (max === min) h = 0;
|
||||||
|
else {
|
||||||
|
switch (max) {
|
||||||
|
case r: h = (g - b) / d + (g < b ? 6 : 0); break;
|
||||||
|
case g: h = (b - r) / d + 2; break;
|
||||||
|
case b: h = (r - g) / d + 4; break;
|
||||||
|
}
|
||||||
|
h /= 6;
|
||||||
|
}
|
||||||
|
return [h, s, v];
|
||||||
|
}
|
||||||
|
|
||||||
|
function hsvToRgb(h, s, v) {
|
||||||
|
let i = Math.floor(h * 6);
|
||||||
|
let f = h * 6 - i;
|
||||||
|
let p = v * (1 - s);
|
||||||
|
let q = v * (1 - f * s);
|
||||||
|
let t = v * (1 - (1 - f) * s);
|
||||||
|
let r, g, b;
|
||||||
|
switch (i % 6) {
|
||||||
|
case 0: r = v; g = t; b = p; break;
|
||||||
|
case 1: r = q; g = v; b = p; break;
|
||||||
|
case 2: r = p; g = v; b = t; break;
|
||||||
|
case 3: r = p; g = q; b = v; break;
|
||||||
|
case 4: r = t; g = p; b = v; break;
|
||||||
|
case 5: r = v; g = p; b = q; break;
|
||||||
|
}
|
||||||
|
return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
|
||||||
|
}
|
||||||
|
|
||||||
|
function initializeLightmap(w, h) {
|
||||||
|
let lw = Math.ceil(w / lightmapScale) + 1;
|
||||||
|
let lh = Math.ceil(h / lightmapScale) + 1;
|
||||||
|
function createArray(width_, height_) {
|
||||||
|
return Array.from({length: height_}, () => Array.from({length: width_}, () => ({color: [0, 0, 0]})));
|
||||||
|
}
|
||||||
|
lightmap = createArray(lw, lh);
|
||||||
|
nextLightmap = createArray(lw, lh);
|
||||||
|
}
|
||||||
|
|
||||||
|
function propagateLightmap() {
|
||||||
|
if (!lightmap[0]) return;
|
||||||
|
let width = lightmap[0].length;
|
||||||
|
let height = lightmap.length;
|
||||||
|
let neighbors = [{dx:1,dy:0},{dx:-1,dy:0},{dx:0,dy:1},{dx:0,dy:-1}];
|
||||||
|
for (let y = 0; y < height; y++) {
|
||||||
|
for (let x = 0; x < width; x++) {
|
||||||
|
let totalColor = [0,0,0];
|
||||||
|
let neighborCount = 0;
|
||||||
|
neighbors.forEach(n => {
|
||||||
|
let nx = x + n.dx, ny = y + n.dy;
|
||||||
|
if (nx >= 0 && ny >= 0 && nx < width && ny < height) {
|
||||||
|
totalColor[0] += lightmap[ny][nx].color[0];
|
||||||
|
totalColor[1] += lightmap[ny][nx].color[1];
|
||||||
|
totalColor[2] += lightmap[ny][nx].color[2];
|
||||||
|
neighborCount++;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
nextLightmap[y][x] = {
|
||||||
|
color: [
|
||||||
|
Math.min(765, Math.max(0, (totalColor[0] / neighborCount) * falloff)),
|
||||||
|
Math.min(765, Math.max(0, (totalColor[1] / neighborCount) * falloff)),
|
||||||
|
Math.min(765, Math.max(0, (totalColor[2] / neighborCount) * falloff))
|
||||||
|
]
|
||||||
|
};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Copy next to current
|
||||||
|
for (let y = 0; y < height; y++) {
|
||||||
|
for (let x = 0; x < width; x++) {
|
||||||
|
lightmap[y][x] = {...nextLightmap[y][x]};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function renderLightmap(ctx) {
|
||||||
|
if (!lightmap[0]) return;
|
||||||
|
let lw = lightmap[0].length;
|
||||||
|
let lh = lightmap.length;
|
||||||
|
for (let y = 0; y < lh; y++) {
|
||||||
|
for (let x = 0; x < lw; x++) {
|
||||||
|
let color = lightmap[y][x].color;
|
||||||
|
let r = color[0], g = color[1], b = color[2];
|
||||||
|
if (r > 16 || g > 16 || b > 16) {
|
||||||
|
let hsv = rgbToHsv(r, g, b);
|
||||||
|
let newColor = hsvToRgb(hsv[0], hsv[1], 1);
|
||||||
|
let alpha = hsv[2];
|
||||||
|
ctx.globalAlpha = 1;
|
||||||
|
ctx.fillStyle = `rgba(${newColor[0]},${newColor[1]},${newColor[2]},${alpha * 0.4})`;
|
||||||
|
ctx.fillRect(x * pixelSize * lightmapScale, y * pixelSize * lightmapScale, pixelSize * lightmapScale, pixelSize * lightmapScale);
|
||||||
|
ctx.fillStyle = `rgba(${newColor[0]},${newColor[1]},${newColor[2]},${alpha * 0.25})`;
|
||||||
|
ctx.fillRect((x * pixelSize - pixelSizeHalf) * lightmapScale, (y * pixelSize - pixelSizeHalf) * lightmapScale,
|
||||||
|
pixelSize * lightmapScale * 2, pixelSize * lightmapScale * 2);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function glowItsOwnColor(pixel) {
|
||||||
|
if (!pixel.color) return;
|
||||||
|
let x = Math.floor(pixel.x / lightmapScale);
|
||||||
|
let y = Math.floor(pixel.y / lightmapScale);
|
||||||
|
if (x < 0 || y < 0 || x >= lightmap[0]?.length || y >= lightmap?.length) return;
|
||||||
|
lightmap[y][x].color = scaleList(rgbToArray(pixel.color), lightSourceBoost);
|
||||||
|
}
|
||||||
|
|
||||||
|
function glowPowered(pixel) {
|
||||||
|
if (!pixel.charge || pixel.charge <= 0 || !pixel.color) return;
|
||||||
|
glowItsOwnColor(pixel);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Override ticks for common light sources (works with addons if they use these elements)
|
||||||
|
let lightEmitters = [
|
||||||
|
"fire", "cold_fire", "plasma", "lava", "magma", "sun", "light", "liquid_light", "laser", "flash", "rainbow",
|
||||||
|
"ember", "fw_ember", "explosion", "n_explosion", "supernova", "fireball", "blaster", "lightning", "electric",
|
||||||
|
"positron", "neutron", "proton", "radiation", "fallout", "rad_cloud", "rad_steam", "uranium", "molten_uranium"
|
||||||
|
];
|
||||||
|
lightEmitters.forEach(elName => {
|
||||||
|
let el = elements[elName];
|
||||||
|
if (el && el.tick) {
|
||||||
|
let origTick = el.tick;
|
||||||
|
el.tick = function(pixel) {
|
||||||
|
origTick(pixel);
|
||||||
|
glowItsOwnColor(pixel);
|
||||||
|
};
|
||||||
|
}
|
||||||
|
});
|
||||||
|
["neon", "led", "light_bulb"].forEach(elName => {
|
||||||
|
let el = elements[elName];
|
||||||
|
if (el && el.tick) {
|
||||||
|
let origTick = el.tick;
|
||||||
|
el.tick = function(pixel) {
|
||||||
|
origTick(pixel);
|
||||||
|
glowPowered(pixel);
|
||||||
|
};
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
// Temp-based glow for hot pixels (metals, etc.)
|
||||||
|
function glowTemp(pixel) {
|
||||||
|
let t = pixel.temp;
|
||||||
|
if (t < 500) return;
|
||||||
|
let intensity = Math.min(1, (t - 500) / 2000);
|
||||||
|
let r = Math.min(255, 100 + 155 * intensity);
|
||||||
|
let g = Math.min(255, 50 * intensity);
|
||||||
|
let b = Math.min(255, 10 * intensity);
|
||||||
|
let x = Math.floor(pixel.x / lightmapScale);
|
||||||
|
let y = Math.floor(pixel.y / lightmapScale);
|
||||||
|
if (x < 0 || y < 0 || x >= lightmap[0]?.length || y >= lightmap?.length) return;
|
||||||
|
lightmap[y][x].color = scaleList([r, g, b], lightSourceBoost * intensity);
|
||||||
|
}
|
||||||
|
runPerPixel(glowTemp);
|
||||||
|
|
||||||
|
// Lightmap render hook
|
||||||
|
renderPrePixel(function(ctx) {
|
||||||
|
if (!paused) propagateLightmap();
|
||||||
|
renderLightmap(ctx);
|
||||||
|
});
|
||||||
|
|
||||||
|
// Init lightmap
|
||||||
|
if (typeof runAfterReset !== 'undefined') {
|
||||||
|
runAfterReset(() => initializeLightmap(width, height));
|
||||||
|
} else {
|
||||||
|
setTimeout(() => initializeLightmap(width, height), 100);
|
||||||
|
}
|
||||||
|
|
||||||
|
// === SHADOWS / OCCLUSION (Realistic Darkness in Shadows) ===
|
||||||
|
const DEFAULT_LIGHT_FACTOR = 0.8;
|
||||||
|
const MIN_LIGHT_INTENSITY = 0.4;
|
||||||
|
const MAX_DIRECT_NEIGHBORS = 4;
|
||||||
|
const FOLLOWUP_COORDS_TO_CHECK = [
|
||||||
|
[-1,-1],[-1,1],[1,-1],[1,1], [-2,0],[2,0],[0,-2],[0,2],
|
||||||
|
[-3,0],[3,0],[0,-3],[0,3], [-4,0],[4,0],[0,-4],[0,4]
|
||||||
|
];
|
||||||
|
let transparentElements = [];
|
||||||
|
function initTransparent() {
|
||||||
|
transparentElements = [];
|
||||||
|
Object.keys(elements).forEach(name => {
|
||||||
|
let el = elements[name];
|
||||||
|
if (el.state === "gas" || el.category === "special" || el.putInTransparentList) {
|
||||||
|
transparentElements.push(name);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
// Add common transparents
|
||||||
|
["glass","stained_glass","glass_shard","ice","led"].forEach(t => transparentElements.includes(t) || transparentElements.push(t));
|
||||||
|
}
|
||||||
|
initTransparent();
|
||||||
|
|
||||||
|
let frameCounter = 0;
|
||||||
|
let pixelBrightnessCache = {};
|
||||||
|
|
||||||
|
function isOutOfBounds(x, y) {
|
||||||
|
return x >= width || y >= height || x < 0 || y < 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
function getOutOfBoundsNeighbors(pixel) {
|
||||||
|
let out = [];
|
||||||
|
[[-1,0],[1,0],[0,-1],[0,1]].forEach(([dx,dy]) => {
|
||||||
|
let nx = pixel.x + dx, ny = pixel.y + dy;
|
||||||
|
if (isOutOfBounds(nx, ny)) out.push({x:nx,y:ny});
|
||||||
|
});
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
function calculateBrightness(pixel) {
|
||||||
|
let neighCount = getNeighbors(pixel).length + getOutOfBoundsNeighbors(pixel).length;
|
||||||
|
if (neighCount >= MAX_DIRECT_NEIGHBORS) {
|
||||||
|
let lightFactor = computeBrightnessFurther(pixel);
|
||||||
|
return adjustBrightness(lightFactor);
|
||||||
|
}
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
function computeBrightnessFurther(pixel) {
|
||||||
|
let blockers = 0;
|
||||||
|
FOLLOWUP_COORDS_TO_CHECK.forEach(([dx,dy]) => {
|
||||||
|
let nx = pixel.x + dx, ny = pixel.y + dy;
|
||||||
|
if (isOutOfBounds(nx, ny)) {
|
||||||
|
blockers++;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let elName = pixelMap[nx]?.[ny]?.element;
|
||||||
|
if (elName && !transparentElements.includes(elName)) blockers++;
|
||||||
|
});
|
||||||
|
return 1 - (blockers / FOLLOWUP_COORDS_TO_CHECK.length);
|
||||||
|
}
|
||||||
|
|
||||||
|
function adjustBrightness(factor) {
|
||||||
|
return factor * DEFAULT_LIGHT_FACTOR + MIN_LIGHT_INTENSITY;
|
||||||
|
}
|
||||||
|
|
||||||
|
function applyShadows(ctx) {
|
||||||
|
if (frameCounter % 2 === 0) {
|
||||||
|
currentPixels.forEach(pixel => {
|
||||||
|
let brightness = calculateBrightness(pixel);
|
||||||
|
pixelBrightnessCache[`${pixel.x},${pixel.y}`] = brightness;
|
||||||
|
});
|
||||||
|
}
|
||||||
|
currentPixels.forEach(pixel => {
|
||||||
|
let brightness = pixelBrightnessCache[`${pixel.x},${pixel.y}`] || 1;
|
||||||
|
// Sample local lightmap intensity
|
||||||
|
let lx = Math.floor(pixel.x / lightmapScale);
|
||||||
|
let ly = Math.floor(pixel.y / lightmapScale);
|
||||||
|
let lightInt = 0;
|
||||||
|
if (ly >= 0 && ly < lightmap?.length && lx >= 0 && lx < lightmap[0]?.length) {
|
||||||
|
let lm = lightmap[ly][lx].color;
|
||||||
|
lightInt = (lm[0] + lm[1] + lm[2]) / (255 * 3);
|
||||||
|
}
|
||||||
|
let shadeAlpha = (1 - brightness) * 0.7 * Math.max(0.2, 1 - lightInt * 0.8);
|
||||||
|
ctx.globalAlpha = shadeAlpha;
|
||||||
|
ctx.fillStyle = "#000";
|
||||||
|
ctx.fillRect(pixel.x * pixelSize, pixel.y * pixelSize, pixelSize, pixelSize);
|
||||||
|
});
|
||||||
|
frameCounter++;
|
||||||
|
}
|
||||||
|
|
||||||
|
renderPostPixel(applyShadows);
|
||||||
|
|
||||||
|
// === REALISTIC WATER / LIQUIDS (Waves & Foam on ALL Liquids) ===
|
||||||
|
renderEachPixel(function(pixel, ctx) {
|
||||||
|
let el = elements[pixel.element];
|
||||||
|
if (el && el.state === "liquid") {
|
||||||
|
// Wavy foam surface
|
||||||
|
let time = (pixelTicks * 0.01 + pixel.x * 0.15 + pixel.y * 0.03) % (Math.PI * 2);
|
||||||
|
let waveOffset = Math.sin(time) * 0.35 - 0.15;
|
||||||
|
let foamY = Math.floor(pixel.y + waveOffset);
|
||||||
|
let foamAlpha = 0.6 + Math.sin(time * 1.5) * 0.3;
|
||||||
|
let foamColor = "#e8f4ff"; // Light blue-white foam
|
||||||
|
drawSquare(ctx, foamColor, pixel.x, foamY, 1, foamAlpha * 0.4);
|
||||||
|
// Subtle caustic glow if lit (bonus realism)
|
||||||
|
let lx = Math.floor(pixel.x / lightmapScale);
|
||||||
|
let ly = Math.floor(pixel.y / lightmapScale);
|
||||||
|
if (ly >= 0 && ly < lightmap?.length && lx >= 0 && lx < lightmap[0]?.length) {
|
||||||
|
let lmBright = (lightmap[ly][lx].color[0] + lightmap[ly][lx].color[1] + lightmap[ly][lx].color[2]) / (255 * 3);
|
||||||
|
if (lmBright > 0.2) {
|
||||||
|
let causticAlpha = lmBright * 0.3;
|
||||||
|
let causticX = pixel.x + Math.sin(time * 0.7) * 0.2;
|
||||||
|
let causticY = pixel.y + 0.5 + Math.cos(time * 1.2) * 0.15;
|
||||||
|
drawSquare(ctx, "#00ff88", causticX, causticY, 0.8, causticAlpha);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
// Re-init transparent on element changes (for mods)
|
||||||
|
if (typeof runEveryTick !== 'undefined') {
|
||||||
|
runEveryTick(initTransparent);
|
||||||
|
}
|
||||||
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,72 @@
|
||||||
|
// xVS_cal_wasm.c
|
||||||
|
#include <emscripten.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
|
#define CLAMP(x, low, high) ((x) < (low) ? (low) : ((x) > (high) ? (high) : (x)))
|
||||||
|
|
||||||
|
// === LIGHT PROPAGATION ===
|
||||||
|
EMSCRIPTEN_KEEPALIVE
|
||||||
|
void propagate_lightmap_f32(
|
||||||
|
const float* in_r, const float* in_g, const float* in_b,
|
||||||
|
float* out_r, float* out_g, float* out_b,
|
||||||
|
int width, int height, float falloff
|
||||||
|
) {
|
||||||
|
const int dx[4] = {1, -1, 0, 0};
|
||||||
|
const int dy[4] = {0, 0, 1, -1};
|
||||||
|
|
||||||
|
for (int y = 0; y < height; ++y) {
|
||||||
|
for (int x = 0; x < width; ++x) {
|
||||||
|
float sum_r = 0, sum_g = 0, sum_b = 0;
|
||||||
|
int count = 0;
|
||||||
|
for (int d = 0; d < 4; ++d) {
|
||||||
|
int nx = x + dx[d];
|
||||||
|
int ny = y + dy[d];
|
||||||
|
if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
|
||||||
|
int nidx = ny * width + nx;
|
||||||
|
sum_r += in_r[nidx];
|
||||||
|
sum_g += in_g[nidx];
|
||||||
|
sum_b += in_b[nidx];
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
int idx = y * width + x;
|
||||||
|
if (count > 0) {
|
||||||
|
float factor = falloff / count;
|
||||||
|
out_r[idx] = CLAMP(sum_r * factor, 0.0f, 765.0f);
|
||||||
|
out_g[idx] = CLAMP(sum_g * factor, 0.0f, 765.0f);
|
||||||
|
out_b[idx] = CLAMP(sum_b * factor, 0.0f, 765.0f);
|
||||||
|
} else {
|
||||||
|
out_r[idx] = out_g[idx] = out_b[idx] = 0.0f;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// === SHADOW OCCLUSION (blocker count only) ===
|
||||||
|
// Input: 1D array of element IDs (0 = empty, 1 = transparent, 2+ = opaque)
|
||||||
|
// Output: blocker count per pixel
|
||||||
|
EMSCRIPTEN_KEEPALIVE
|
||||||
|
void compute_blockers_u8(
|
||||||
|
const uint8_t* grid, // width × height
|
||||||
|
uint8_t* blockers_out, // same size
|
||||||
|
int width, int height,
|
||||||
|
const int8_t* coords, // [dx0,dy0,dx1,dy1,...] length = 2*N
|
||||||
|
int coord_count // N
|
||||||
|
) {
|
||||||
|
for (int y = 0; y < height; ++y) {
|
||||||
|
for (int x = 0; x < width; ++x) {
|
||||||
|
uint8_t blockers = 0;
|
||||||
|
for (int i = 0; i < coord_count; ++i) {
|
||||||
|
int nx = x + coords[i * 2];
|
||||||
|
int ny = y + coords[i * 2 + 1];
|
||||||
|
if (nx < 0 || nx >= width || ny < 0 || ny >= height) {
|
||||||
|
blockers++;
|
||||||
|
} else {
|
||||||
|
uint8_t val = grid[ny * width + nx];
|
||||||
|
if (val >= 2) blockers++; // opaque
|
||||||
|
}
|
||||||
|
}
|
||||||
|
blockers_out[y * width + x] = blockers;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,893 @@
|
||||||
|
// xVS_cal_wasm.js - xVS wasm version calculation kernel, IT IS NOT A MOD.
|
||||||
|
|
||||||
|
// include: shell.js
|
||||||
|
// include: minimum_runtime_check.js
|
||||||
|
// end include: minimum_runtime_check.js
|
||||||
|
var Module = typeof Module != 'undefined' ? Module : {};
|
||||||
|
|
||||||
|
// Determine the runtime environment we are in. You can customize this by
|
||||||
|
// setting the ENVIRONMENT setting at compile time (see settings.js).
|
||||||
|
|
||||||
|
// Attempt to auto-detect the environment
|
||||||
|
var ENVIRONMENT_IS_WEB = !!globalThis.window;
|
||||||
|
var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
|
||||||
|
// N.b. Electron.js environment is simultaneously a NODE-environment, but
|
||||||
|
// also a web environment.
|
||||||
|
var ENVIRONMENT_IS_NODE = globalThis.process?.versions?.node && globalThis.process?.type != 'renderer';
|
||||||
|
var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
|
||||||
|
|
||||||
|
// --pre-jses are emitted after the Module integration code, so that they can
|
||||||
|
// refer to Module (if they choose; they can also define Module)
|
||||||
|
|
||||||
|
|
||||||
|
var arguments_ = [];
|
||||||
|
var thisProgram = './this.program';
|
||||||
|
var quit_ = (status, toThrow) => {
|
||||||
|
throw toThrow;
|
||||||
|
};
|
||||||
|
|
||||||
|
// In MODULARIZE mode _scriptName needs to be captured already at the very top of the page immediately when the page is parsed, so it is generated there
|
||||||
|
// before the page load. In non-MODULARIZE modes generate it here.
|
||||||
|
var _scriptName = globalThis.document?.currentScript?.src;
|
||||||
|
|
||||||
|
if (typeof __filename != 'undefined') { // Node
|
||||||
|
_scriptName = __filename;
|
||||||
|
} else
|
||||||
|
if (ENVIRONMENT_IS_WORKER) {
|
||||||
|
_scriptName = self.location.href;
|
||||||
|
}
|
||||||
|
|
||||||
|
// `/` should be present at the end if `scriptDirectory` is not empty
|
||||||
|
var scriptDirectory = '';
|
||||||
|
function locateFile(path) {
|
||||||
|
if (Module['locateFile']) {
|
||||||
|
return Module['locateFile'](path, scriptDirectory);
|
||||||
|
}
|
||||||
|
return scriptDirectory + path;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Hooks that are implemented differently in different runtime environments.
|
||||||
|
var readAsync, readBinary;
|
||||||
|
|
||||||
|
if (ENVIRONMENT_IS_NODE) {
|
||||||
|
|
||||||
|
// These modules will usually be used on Node.js. Load them eagerly to avoid
|
||||||
|
// the complexity of lazy-loading.
|
||||||
|
var fs = require('fs');
|
||||||
|
|
||||||
|
scriptDirectory = __dirname + '/';
|
||||||
|
|
||||||
|
// include: node_shell_read.js
|
||||||
|
readBinary = (filename) => {
|
||||||
|
// We need to re-wrap `file://` strings to URLs.
|
||||||
|
filename = isFileURI(filename) ? new URL(filename) : filename;
|
||||||
|
var ret = fs.readFileSync(filename);
|
||||||
|
return ret;
|
||||||
|
};
|
||||||
|
|
||||||
|
readAsync = async (filename, binary = true) => {
|
||||||
|
// See the comment in the `readBinary` function.
|
||||||
|
filename = isFileURI(filename) ? new URL(filename) : filename;
|
||||||
|
var ret = fs.readFileSync(filename, binary ? undefined : 'utf8');
|
||||||
|
return ret;
|
||||||
|
};
|
||||||
|
// end include: node_shell_read.js
|
||||||
|
if (process.argv.length > 1) {
|
||||||
|
thisProgram = process.argv[1].replace(/\\/g, '/');
|
||||||
|
}
|
||||||
|
|
||||||
|
arguments_ = process.argv.slice(2);
|
||||||
|
|
||||||
|
// MODULARIZE will export the module in the proper place outside, we don't need to export here
|
||||||
|
if (typeof module != 'undefined') {
|
||||||
|
module['exports'] = Module;
|
||||||
|
}
|
||||||
|
|
||||||
|
quit_ = (status, toThrow) => {
|
||||||
|
process.exitCode = status;
|
||||||
|
throw toThrow;
|
||||||
|
};
|
||||||
|
|
||||||
|
} else
|
||||||
|
|
||||||
|
// Note that this includes Node.js workers when relevant (pthreads is enabled).
|
||||||
|
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
|
||||||
|
// ENVIRONMENT_IS_NODE.
|
||||||
|
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
|
||||||
|
try {
|
||||||
|
scriptDirectory = new URL('.', _scriptName).href; // includes trailing slash
|
||||||
|
} catch {
|
||||||
|
// Must be a `blob:` or `data:` URL (e.g. `blob:http://site.com/etc/etc`), we cannot
|
||||||
|
// infer anything from them.
|
||||||
|
}
|
||||||
|
|
||||||
|
{
|
||||||
|
// include: web_or_worker_shell_read.js
|
||||||
|
if (ENVIRONMENT_IS_WORKER) {
|
||||||
|
readBinary = (url) => {
|
||||||
|
var xhr = new XMLHttpRequest();
|
||||||
|
xhr.open('GET', url, false);
|
||||||
|
xhr.responseType = 'arraybuffer';
|
||||||
|
xhr.send(null);
|
||||||
|
return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
readAsync = async (url) => {
|
||||||
|
// Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
|
||||||
|
// See https://github.com/github/fetch/pull/92#issuecomment-140665932
|
||||||
|
// Cordova or Electron apps are typically loaded from a file:// url.
|
||||||
|
// So use XHR on webview if URL is a file URL.
|
||||||
|
if (isFileURI(url)) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
var xhr = new XMLHttpRequest();
|
||||||
|
xhr.open('GET', url, true);
|
||||||
|
xhr.responseType = 'arraybuffer';
|
||||||
|
xhr.onload = () => {
|
||||||
|
if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
|
||||||
|
resolve(xhr.response);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
reject(xhr.status);
|
||||||
|
};
|
||||||
|
xhr.onerror = reject;
|
||||||
|
xhr.send(null);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
var response = await fetch(url, { credentials: 'same-origin' });
|
||||||
|
if (response.ok) {
|
||||||
|
return response.arrayBuffer();
|
||||||
|
}
|
||||||
|
throw new Error(response.status + ' : ' + response.url);
|
||||||
|
};
|
||||||
|
// end include: web_or_worker_shell_read.js
|
||||||
|
}
|
||||||
|
} else
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
var out = console.log.bind(console);
|
||||||
|
var err = console.error.bind(console);
|
||||||
|
|
||||||
|
// end include: shell.js
|
||||||
|
|
||||||
|
// include: preamble.js
|
||||||
|
// === Preamble library stuff ===
|
||||||
|
|
||||||
|
// Documentation for the public APIs defined in this file must be updated in:
|
||||||
|
// site/source/docs/api_reference/preamble.js.rst
|
||||||
|
// A prebuilt local version of the documentation is available at:
|
||||||
|
// site/build/text/docs/api_reference/preamble.js.txt
|
||||||
|
// You can also build docs locally as HTML or other formats in site/
|
||||||
|
// An online HTML version (which may be of a different version of Emscripten)
|
||||||
|
// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
|
||||||
|
|
||||||
|
var wasmBinary;
|
||||||
|
|
||||||
|
// Wasm globals
|
||||||
|
|
||||||
|
//========================================
|
||||||
|
// Runtime essentials
|
||||||
|
//========================================
|
||||||
|
|
||||||
|
// whether we are quitting the application. no code should run after this.
|
||||||
|
// set in exit() and abort()
|
||||||
|
var ABORT = false;
|
||||||
|
|
||||||
|
// set by exit() and abort(). Passed to 'onExit' handler.
|
||||||
|
// NOTE: This is also used as the process return code code in shell environments
|
||||||
|
// but only when noExitRuntime is false.
|
||||||
|
var EXITSTATUS;
|
||||||
|
|
||||||
|
// In STRICT mode, we only define assert() when ASSERTIONS is set. i.e. we
|
||||||
|
// don't define it at all in release modes. This matches the behaviour of
|
||||||
|
// MINIMAL_RUNTIME.
|
||||||
|
// TODO(sbc): Make this the default even without STRICT enabled.
|
||||||
|
/** @type {function(*, string=)} */
|
||||||
|
function assert(condition, text) {
|
||||||
|
if (!condition) {
|
||||||
|
// This build was created without ASSERTIONS defined. `assert()` should not
|
||||||
|
// ever be called in this configuration but in case there are callers in
|
||||||
|
// the wild leave this simple abort() implementation here for now.
|
||||||
|
abort(text);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Indicates whether filename is delivered via file protocol (as opposed to http/https)
|
||||||
|
* @noinline
|
||||||
|
*/
|
||||||
|
var isFileURI = (filename) => filename.startsWith('file://');
|
||||||
|
|
||||||
|
// include: runtime_common.js
|
||||||
|
// include: runtime_stack_check.js
|
||||||
|
// end include: runtime_stack_check.js
|
||||||
|
// include: runtime_exceptions.js
|
||||||
|
// end include: runtime_exceptions.js
|
||||||
|
// include: runtime_debug.js
|
||||||
|
// end include: runtime_debug.js
|
||||||
|
// include: binaryDecode.js
|
||||||
|
// Prevent Closure from minifying the binaryDecode() function, or otherwise
|
||||||
|
// Closure may analyze through the WASM_BINARY_DATA placeholder string into this
|
||||||
|
// function, leading into incorrect results.
|
||||||
|
/** @noinline */
|
||||||
|
function binaryDecode(bin) {
|
||||||
|
for (var i = 0, l = bin.length, o = new Uint8Array(l), c; i < l; ++i) {
|
||||||
|
c = bin.charCodeAt(i);
|
||||||
|
o[i] = ~c >> 8 & c; // Recover the null byte in a manner that is compatible with https://crbug.com/453961758
|
||||||
|
}
|
||||||
|
return o;
|
||||||
|
}
|
||||||
|
// end include: binaryDecode.js
|
||||||
|
// Memory management
|
||||||
|
var
|
||||||
|
/** @type {!Int8Array} */
|
||||||
|
HEAP8,
|
||||||
|
/** @type {!Uint8Array} */
|
||||||
|
HEAPU8,
|
||||||
|
/** @type {!Int16Array} */
|
||||||
|
HEAP16,
|
||||||
|
/** @type {!Uint16Array} */
|
||||||
|
HEAPU16,
|
||||||
|
/** @type {!Int32Array} */
|
||||||
|
HEAP32,
|
||||||
|
/** @type {!Uint32Array} */
|
||||||
|
HEAPU32,
|
||||||
|
/** @type {!Float32Array} */
|
||||||
|
HEAPF32,
|
||||||
|
/** @type {!Float64Array} */
|
||||||
|
HEAPF64;
|
||||||
|
|
||||||
|
// BigInt64Array type is not correctly defined in closure
|
||||||
|
var
|
||||||
|
/** not-@type {!BigInt64Array} */
|
||||||
|
HEAP64,
|
||||||
|
/* BigUint64Array type is not correctly defined in closure
|
||||||
|
/** not-@type {!BigUint64Array} */
|
||||||
|
HEAPU64;
|
||||||
|
|
||||||
|
var runtimeInitialized = false;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
function updateMemoryViews() {
|
||||||
|
var b = wasmMemory.buffer;
|
||||||
|
HEAP8 = new Int8Array(b);
|
||||||
|
HEAP16 = new Int16Array(b);
|
||||||
|
HEAPU8 = new Uint8Array(b);
|
||||||
|
HEAPU16 = new Uint16Array(b);
|
||||||
|
HEAP32 = new Int32Array(b);
|
||||||
|
HEAPU32 = new Uint32Array(b);
|
||||||
|
HEAPF32 = new Float32Array(b);
|
||||||
|
HEAPF64 = new Float64Array(b);
|
||||||
|
HEAP64 = new BigInt64Array(b);
|
||||||
|
HEAPU64 = new BigUint64Array(b);
|
||||||
|
}
|
||||||
|
|
||||||
|
// include: memoryprofiler.js
|
||||||
|
// end include: memoryprofiler.js
|
||||||
|
// end include: runtime_common.js
|
||||||
|
function preRun() {
|
||||||
|
if (Module['preRun']) {
|
||||||
|
if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
|
||||||
|
while (Module['preRun'].length) {
|
||||||
|
addOnPreRun(Module['preRun'].shift());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Begin ATPRERUNS hooks
|
||||||
|
callRuntimeCallbacks(onPreRuns);
|
||||||
|
// End ATPRERUNS hooks
|
||||||
|
}
|
||||||
|
|
||||||
|
function initRuntime() {
|
||||||
|
runtimeInitialized = true;
|
||||||
|
|
||||||
|
// No ATINITS hooks
|
||||||
|
|
||||||
|
wasmExports['__wasm_call_ctors']();
|
||||||
|
|
||||||
|
// No ATPOSTCTORS hooks
|
||||||
|
}
|
||||||
|
|
||||||
|
function postRun() {
|
||||||
|
// PThreads reuse the runtime from the main thread.
|
||||||
|
|
||||||
|
if (Module['postRun']) {
|
||||||
|
if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
|
||||||
|
while (Module['postRun'].length) {
|
||||||
|
addOnPostRun(Module['postRun'].shift());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Begin ATPOSTRUNS hooks
|
||||||
|
callRuntimeCallbacks(onPostRuns);
|
||||||
|
// End ATPOSTRUNS hooks
|
||||||
|
}
|
||||||
|
|
||||||
|
/** @param {string|number=} what */
|
||||||
|
function abort(what) {
|
||||||
|
Module['onAbort']?.(what);
|
||||||
|
|
||||||
|
what = 'Aborted(' + what + ')';
|
||||||
|
// TODO(sbc): Should we remove printing and leave it up to whoever
|
||||||
|
// catches the exception?
|
||||||
|
err(what);
|
||||||
|
|
||||||
|
ABORT = true;
|
||||||
|
|
||||||
|
what += '. Build with -sASSERTIONS for more info.';
|
||||||
|
|
||||||
|
// Use a wasm runtime error, because a JS error might be seen as a foreign
|
||||||
|
// exception, which means we'd run destructors on it. We need the error to
|
||||||
|
// simply make the program stop.
|
||||||
|
// FIXME This approach does not work in Wasm EH because it currently does not assume
|
||||||
|
// all RuntimeErrors are from traps; it decides whether a RuntimeError is from
|
||||||
|
// a trap or not based on a hidden field within the object. So at the moment
|
||||||
|
// we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
|
||||||
|
// allows this in the wasm spec.
|
||||||
|
|
||||||
|
// Suppress closure compiler warning here. Closure compiler's builtin extern
|
||||||
|
// definition for WebAssembly.RuntimeError claims it takes no arguments even
|
||||||
|
// though it can.
|
||||||
|
// TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
|
||||||
|
/** @suppress {checkTypes} */
|
||||||
|
var e = new WebAssembly.RuntimeError(what);
|
||||||
|
|
||||||
|
// Throw the error whether or not MODULARIZE is set because abort is used
|
||||||
|
// in code paths apart from instantiation where an exception is expected
|
||||||
|
// to be thrown when abort is called.
|
||||||
|
throw e;
|
||||||
|
}
|
||||||
|
|
||||||
|
var wasmBinaryFile;
|
||||||
|
|
||||||
|
function findWasmBinary() {
|
||||||
|
return binaryDecode(' asm &` ` } ` ` `` pA ¾memory __wasm_call_ctors propagate_lightmap_f32 compute_blockers_u8 __indirect_function_table _emscripten_stack_restore _emscripten_stack_alloc emscripten_stack_get_current \n¹ }}}@ AH\r AH! A !\n@ \n! @ \r l! A !\n@ \n!\rC !C !A !\nA !C !@ ! ! ! !@@ \n"\nAt"( \rj"A H\r N\r ( j" O\r l jAt"j* ! Aj! j* ! j* ! ! ! ! ! "! "! \nAj"!\n "! "! AG\r \r j!\n@@ A L\r \nAt"jC C @?D ³" " C @?D^ C ]8 jC C @?D " C @?D^ C ]8 !C C @?D " C @?D^ C ]! \nAt"jA 6 jA 6 !C ! \nAtj 8 \rAj"!\n G\r Aj"!\n G\r ñ @ AH\r AH!A !@ !@ \r lj! A !@ !\nA !A ! @ A L\r @ ! @@ \n " Atj"\r, j"A N\r A! @ H\r A! A! \r, j"\r O\r \r lj j- AK! j! Aj" ! G\r \nj : \nAj" ! G\r Aj" ! G\r \n $ # kApq"$ # \' A ÿÿÿÿ ÿÿÿÿ target_features+ bulk-memory+bulk-memory-opt+call-indirect-overlong+\nmultivalue+mutable-globals+nontrapping-fptoint+reference-types+sign-ext');
|
||||||
|
}
|
||||||
|
|
||||||
|
function getBinarySync(file) {
|
||||||
|
return file;
|
||||||
|
}
|
||||||
|
|
||||||
|
async function getWasmBinary(binaryFile) {
|
||||||
|
|
||||||
|
// Otherwise, getBinarySync should be able to get it synchronously
|
||||||
|
return getBinarySync(binaryFile);
|
||||||
|
}
|
||||||
|
|
||||||
|
async function instantiateArrayBuffer(binaryFile, imports) {
|
||||||
|
try {
|
||||||
|
var binary = await getWasmBinary(binaryFile);
|
||||||
|
var instance = await WebAssembly.instantiate(binary, imports);
|
||||||
|
return instance;
|
||||||
|
} catch (reason) {
|
||||||
|
err(`failed to asynchronously prepare wasm: ${reason}`);
|
||||||
|
|
||||||
|
abort(reason);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async function instantiateAsync(binary, binaryFile, imports) {
|
||||||
|
return instantiateArrayBuffer(binaryFile, imports);
|
||||||
|
}
|
||||||
|
|
||||||
|
function getWasmImports() {
|
||||||
|
// prepare imports
|
||||||
|
var imports = {
|
||||||
|
'env': wasmImports,
|
||||||
|
'wasi_snapshot_preview1': wasmImports,
|
||||||
|
};
|
||||||
|
return imports;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Create the wasm instance.
|
||||||
|
// Receives the wasm imports, returns the exports.
|
||||||
|
async function createWasm() {
|
||||||
|
// Load the wasm module and create an instance of using native support in the JS engine.
|
||||||
|
// handle a generated wasm instance, receiving its exports and
|
||||||
|
// performing other necessary setup
|
||||||
|
/** @param {WebAssembly.Module=} module*/
|
||||||
|
function receiveInstance(instance, module) {
|
||||||
|
wasmExports = instance.exports;
|
||||||
|
|
||||||
|
assignWasmExports(wasmExports);
|
||||||
|
|
||||||
|
updateMemoryViews();
|
||||||
|
|
||||||
|
removeRunDependency('wasm-instantiate');
|
||||||
|
return wasmExports;
|
||||||
|
}
|
||||||
|
addRunDependency('wasm-instantiate');
|
||||||
|
|
||||||
|
// Prefer streaming instantiation if available.
|
||||||
|
function receiveInstantiationResult(result) {
|
||||||
|
// 'result' is a ResultObject object which has both the module and instance.
|
||||||
|
// receiveInstance() will swap in the exports (to Module.asm) so they can be called
|
||||||
|
// TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
|
||||||
|
// When the regression is fixed, can restore the above PTHREADS-enabled path.
|
||||||
|
return receiveInstance(result['instance']);
|
||||||
|
}
|
||||||
|
|
||||||
|
var info = getWasmImports();
|
||||||
|
|
||||||
|
// User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
|
||||||
|
// to manually instantiate the Wasm module themselves. This allows pages to
|
||||||
|
// run the instantiation parallel to any other async startup actions they are
|
||||||
|
// performing.
|
||||||
|
// Also pthreads and wasm workers initialize the wasm instance through this
|
||||||
|
// path.
|
||||||
|
if (Module['instantiateWasm']) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
Module['instantiateWasm'](info, (inst, mod) => {
|
||||||
|
resolve(receiveInstance(inst, mod));
|
||||||
|
});
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
wasmBinaryFile ??= findWasmBinary();
|
||||||
|
var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
|
||||||
|
var exports = receiveInstantiationResult(result);
|
||||||
|
return exports;
|
||||||
|
}
|
||||||
|
|
||||||
|
// end include: preamble.js
|
||||||
|
|
||||||
|
// Begin JS library code
|
||||||
|
|
||||||
|
|
||||||
|
class ExitStatus {
|
||||||
|
name = 'ExitStatus';
|
||||||
|
constructor(status) {
|
||||||
|
this.message = `Program terminated with exit(${status})`;
|
||||||
|
this.status = status;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var callRuntimeCallbacks = (callbacks) => {
|
||||||
|
while (callbacks.length > 0) {
|
||||||
|
// Pass the module as the first argument.
|
||||||
|
callbacks.shift()(Module);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
var onPostRuns = [];
|
||||||
|
var addOnPostRun = (cb) => onPostRuns.push(cb);
|
||||||
|
|
||||||
|
var onPreRuns = [];
|
||||||
|
var addOnPreRun = (cb) => onPreRuns.push(cb);
|
||||||
|
|
||||||
|
var runDependencies = 0;
|
||||||
|
|
||||||
|
|
||||||
|
var dependenciesFulfilled = null;
|
||||||
|
var removeRunDependency = (id) => {
|
||||||
|
runDependencies--;
|
||||||
|
|
||||||
|
Module['monitorRunDependencies']?.(runDependencies);
|
||||||
|
|
||||||
|
if (runDependencies == 0) {
|
||||||
|
if (dependenciesFulfilled) {
|
||||||
|
var callback = dependenciesFulfilled;
|
||||||
|
dependenciesFulfilled = null;
|
||||||
|
callback(); // can add another dependenciesFulfilled
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
var addRunDependency = (id) => {
|
||||||
|
runDependencies++;
|
||||||
|
|
||||||
|
Module['monitorRunDependencies']?.(runDependencies);
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
/** @noinline */
|
||||||
|
var base64Decode = (b64) => {
|
||||||
|
if (ENVIRONMENT_IS_NODE) {
|
||||||
|
var buf = Buffer.from(b64, 'base64');
|
||||||
|
return new Uint8Array(buf.buffer, buf.byteOffset, buf.length);
|
||||||
|
}
|
||||||
|
|
||||||
|
var b1, b2, i = 0, j = 0, bLength = b64.length;
|
||||||
|
var output = new Uint8Array((bLength*3>>2) - (b64[bLength-2] == '=') - (b64[bLength-1] == '='));
|
||||||
|
for (; i < bLength; i += 4, j += 3) {
|
||||||
|
b1 = base64ReverseLookup[b64.charCodeAt(i+1)];
|
||||||
|
b2 = base64ReverseLookup[b64.charCodeAt(i+2)];
|
||||||
|
output[j] = base64ReverseLookup[b64.charCodeAt(i)] << 2 | b1 >> 4;
|
||||||
|
output[j+1] = b1 << 4 | b2 >> 2;
|
||||||
|
output[j+2] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)];
|
||||||
|
}
|
||||||
|
return output;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {number} ptr
|
||||||
|
* @param {string} type
|
||||||
|
*/
|
||||||
|
function getValue(ptr, type = 'i8') {
|
||||||
|
if (type.endsWith('*')) type = '*';
|
||||||
|
switch (type) {
|
||||||
|
case 'i1': return HEAP8[ptr];
|
||||||
|
case 'i8': return HEAP8[ptr];
|
||||||
|
case 'i16': return HEAP16[((ptr)>>1)];
|
||||||
|
case 'i32': return HEAP32[((ptr)>>2)];
|
||||||
|
case 'i64': return HEAP64[((ptr)>>3)];
|
||||||
|
case 'float': return HEAPF32[((ptr)>>2)];
|
||||||
|
case 'double': return HEAPF64[((ptr)>>3)];
|
||||||
|
case '*': return HEAPU32[((ptr)>>2)];
|
||||||
|
default: abort(`invalid type for getValue: ${type}`);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var noExitRuntime = true;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {number} ptr
|
||||||
|
* @param {number} value
|
||||||
|
* @param {string} type
|
||||||
|
*/
|
||||||
|
function setValue(ptr, value, type = 'i8') {
|
||||||
|
if (type.endsWith('*')) type = '*';
|
||||||
|
switch (type) {
|
||||||
|
case 'i1': HEAP8[ptr] = value; break;
|
||||||
|
case 'i8': HEAP8[ptr] = value; break;
|
||||||
|
case 'i16': HEAP16[((ptr)>>1)] = value; break;
|
||||||
|
case 'i32': HEAP32[((ptr)>>2)] = value; break;
|
||||||
|
case 'i64': HEAP64[((ptr)>>3)] = BigInt(value); break;
|
||||||
|
case 'float': HEAPF32[((ptr)>>2)] = value; break;
|
||||||
|
case 'double': HEAPF64[((ptr)>>3)] = value; break;
|
||||||
|
case '*': HEAPU32[((ptr)>>2)] = value; break;
|
||||||
|
default: abort(`invalid type for setValue: ${type}`);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var stackRestore = (val) => __emscripten_stack_restore(val);
|
||||||
|
|
||||||
|
var stackSave = () => _emscripten_stack_get_current();
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
var getCFunc = (ident) => {
|
||||||
|
var func = Module['_' + ident]; // closure exported function
|
||||||
|
return func;
|
||||||
|
};
|
||||||
|
|
||||||
|
var writeArrayToMemory = (array, buffer) => {
|
||||||
|
HEAP8.set(array, buffer);
|
||||||
|
};
|
||||||
|
|
||||||
|
var lengthBytesUTF8 = (str) => {
|
||||||
|
var len = 0;
|
||||||
|
for (var i = 0; i < str.length; ++i) {
|
||||||
|
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
|
||||||
|
// unit, not a Unicode code point of the character! So decode
|
||||||
|
// UTF16->UTF32->UTF8.
|
||||||
|
// See http://unicode.org/faq/utf_bom.html#utf16-3
|
||||||
|
var c = str.charCodeAt(i); // possibly a lead surrogate
|
||||||
|
if (c <= 0x7F) {
|
||||||
|
len++;
|
||||||
|
} else if (c <= 0x7FF) {
|
||||||
|
len += 2;
|
||||||
|
} else if (c >= 0xD800 && c <= 0xDFFF) {
|
||||||
|
len += 4; ++i;
|
||||||
|
} else {
|
||||||
|
len += 3;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return len;
|
||||||
|
};
|
||||||
|
|
||||||
|
var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
|
||||||
|
// Parameter maxBytesToWrite is not optional. Negative values, 0, null,
|
||||||
|
// undefined and false each don't write out any bytes.
|
||||||
|
if (!(maxBytesToWrite > 0))
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
var startIdx = outIdx;
|
||||||
|
var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
|
||||||
|
for (var i = 0; i < str.length; ++i) {
|
||||||
|
// For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
|
||||||
|
// and https://www.ietf.org/rfc/rfc2279.txt
|
||||||
|
// and https://tools.ietf.org/html/rfc3629
|
||||||
|
var u = str.codePointAt(i);
|
||||||
|
if (u <= 0x7F) {
|
||||||
|
if (outIdx >= endIdx) break;
|
||||||
|
heap[outIdx++] = u;
|
||||||
|
} else if (u <= 0x7FF) {
|
||||||
|
if (outIdx + 1 >= endIdx) break;
|
||||||
|
heap[outIdx++] = 0xC0 | (u >> 6);
|
||||||
|
heap[outIdx++] = 0x80 | (u & 63);
|
||||||
|
} else if (u <= 0xFFFF) {
|
||||||
|
if (outIdx + 2 >= endIdx) break;
|
||||||
|
heap[outIdx++] = 0xE0 | (u >> 12);
|
||||||
|
heap[outIdx++] = 0x80 | ((u >> 6) & 63);
|
||||||
|
heap[outIdx++] = 0x80 | (u & 63);
|
||||||
|
} else {
|
||||||
|
if (outIdx + 3 >= endIdx) break;
|
||||||
|
heap[outIdx++] = 0xF0 | (u >> 18);
|
||||||
|
heap[outIdx++] = 0x80 | ((u >> 12) & 63);
|
||||||
|
heap[outIdx++] = 0x80 | ((u >> 6) & 63);
|
||||||
|
heap[outIdx++] = 0x80 | (u & 63);
|
||||||
|
// Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16.
|
||||||
|
// We need to manually skip over the second code unit for correct iteration.
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Null-terminate the pointer to the buffer.
|
||||||
|
heap[outIdx] = 0;
|
||||||
|
return outIdx - startIdx;
|
||||||
|
};
|
||||||
|
var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
|
||||||
|
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
|
||||||
|
};
|
||||||
|
|
||||||
|
var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
|
||||||
|
var stringToUTF8OnStack = (str) => {
|
||||||
|
var size = lengthBytesUTF8(str) + 1;
|
||||||
|
var ret = stackAlloc(size);
|
||||||
|
stringToUTF8(str, ret, size);
|
||||||
|
return ret;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
var UTF8Decoder = globalThis.TextDecoder && new TextDecoder();
|
||||||
|
|
||||||
|
var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
|
||||||
|
var maxIdx = idx + maxBytesToRead;
|
||||||
|
if (ignoreNul) return maxIdx;
|
||||||
|
// TextDecoder needs to know the byte length in advance, it doesn't stop on
|
||||||
|
// null terminator by itself.
|
||||||
|
// As a tiny code save trick, compare idx against maxIdx using a negation,
|
||||||
|
// so that maxBytesToRead=undefined/NaN means Infinity.
|
||||||
|
while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
|
||||||
|
return idx;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
|
||||||
|
* array that contains uint8 values, returns a copy of that string as a
|
||||||
|
* Javascript String object.
|
||||||
|
* heapOrArray is either a regular array, or a JavaScript typed array view.
|
||||||
|
* @param {number=} idx
|
||||||
|
* @param {number=} maxBytesToRead
|
||||||
|
* @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character.
|
||||||
|
* @return {string}
|
||||||
|
*/
|
||||||
|
var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
|
||||||
|
|
||||||
|
var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
|
||||||
|
|
||||||
|
// When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it.
|
||||||
|
if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
|
||||||
|
return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
|
||||||
|
}
|
||||||
|
var str = '';
|
||||||
|
while (idx < endPtr) {
|
||||||
|
// For UTF8 byte structure, see:
|
||||||
|
// http://en.wikipedia.org/wiki/UTF-8#Description
|
||||||
|
// https://www.ietf.org/rfc/rfc2279.txt
|
||||||
|
// https://tools.ietf.org/html/rfc3629
|
||||||
|
var u0 = heapOrArray[idx++];
|
||||||
|
if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }
|
||||||
|
var u1 = heapOrArray[idx++] & 63;
|
||||||
|
if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }
|
||||||
|
var u2 = heapOrArray[idx++] & 63;
|
||||||
|
if ((u0 & 0xF0) == 0xE0) {
|
||||||
|
u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
|
||||||
|
} else {
|
||||||
|
u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (u0 < 0x10000) {
|
||||||
|
str += String.fromCharCode(u0);
|
||||||
|
} else {
|
||||||
|
var ch = u0 - 0x10000;
|
||||||
|
str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return str;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
|
||||||
|
* emscripten HEAP, returns a copy of that string as a Javascript String object.
|
||||||
|
*
|
||||||
|
* @param {number} ptr
|
||||||
|
* @param {number=} maxBytesToRead - An optional length that specifies the
|
||||||
|
* maximum number of bytes to read. You can omit this parameter to scan the
|
||||||
|
* string until the first 0 byte. If maxBytesToRead is passed, and the string
|
||||||
|
* at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
|
||||||
|
* string will cut short at that byte index.
|
||||||
|
* @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character.
|
||||||
|
* @return {string}
|
||||||
|
*/
|
||||||
|
var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => {
|
||||||
|
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : '';
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {string|null=} returnType
|
||||||
|
* @param {Array=} argTypes
|
||||||
|
* @param {Array=} args
|
||||||
|
* @param {Object=} opts
|
||||||
|
*/
|
||||||
|
var ccall = (ident, returnType, argTypes, args, opts) => {
|
||||||
|
// For fast lookup of conversion functions
|
||||||
|
var toC = {
|
||||||
|
'string': (str) => {
|
||||||
|
var ret = 0;
|
||||||
|
if (str !== null && str !== undefined && str !== 0) { // null string
|
||||||
|
ret = stringToUTF8OnStack(str);
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
},
|
||||||
|
'array': (arr) => {
|
||||||
|
var ret = stackAlloc(arr.length);
|
||||||
|
writeArrayToMemory(arr, ret);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
function convertReturnValue(ret) {
|
||||||
|
if (returnType === 'string') {
|
||||||
|
return UTF8ToString(ret);
|
||||||
|
}
|
||||||
|
if (returnType === 'boolean') return Boolean(ret);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
var func = getCFunc(ident);
|
||||||
|
var cArgs = [];
|
||||||
|
var stack = 0;
|
||||||
|
if (args) {
|
||||||
|
for (var i = 0; i < args.length; i++) {
|
||||||
|
var converter = toC[argTypes[i]];
|
||||||
|
if (converter) {
|
||||||
|
if (stack === 0) stack = stackSave();
|
||||||
|
cArgs[i] = converter(args[i]);
|
||||||
|
} else {
|
||||||
|
cArgs[i] = args[i];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
var ret = func(...cArgs);
|
||||||
|
function onDone(ret) {
|
||||||
|
if (stack !== 0) stackRestore(stack);
|
||||||
|
return convertReturnValue(ret);
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = onDone(ret);
|
||||||
|
return ret;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Precreate a reverse lookup table from chars
|
||||||
|
// "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" back to
|
||||||
|
// bytes to make decoding fast.
|
||||||
|
for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) {
|
||||||
|
base64ReverseLookup[48+i] = 52+i; // '0-9'
|
||||||
|
base64ReverseLookup[65+i] = i; // 'A-Z'
|
||||||
|
base64ReverseLookup[97+i] = 26+i; // 'a-z'
|
||||||
|
}
|
||||||
|
base64ReverseLookup[43] = 62; // '+'
|
||||||
|
base64ReverseLookup[47] = 63; // '/'
|
||||||
|
;
|
||||||
|
// End JS library code
|
||||||
|
|
||||||
|
// include: postlibrary.js
|
||||||
|
// This file is included after the automatically-generated JS library code
|
||||||
|
// but before the wasm module is created.
|
||||||
|
|
||||||
|
{
|
||||||
|
|
||||||
|
// Begin ATMODULES hooks
|
||||||
|
if (Module['noExitRuntime']) noExitRuntime = Module['noExitRuntime'];
|
||||||
|
if (Module['print']) out = Module['print'];
|
||||||
|
if (Module['printErr']) err = Module['printErr'];
|
||||||
|
if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
|
||||||
|
// End ATMODULES hooks
|
||||||
|
|
||||||
|
if (Module['arguments']) arguments_ = Module['arguments'];
|
||||||
|
if (Module['thisProgram']) thisProgram = Module['thisProgram'];
|
||||||
|
|
||||||
|
if (Module['preInit']) {
|
||||||
|
if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
|
||||||
|
while (Module['preInit'].length > 0) {
|
||||||
|
Module['preInit'].shift()();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Begin runtime exports
|
||||||
|
Module['ccall'] = ccall;
|
||||||
|
// End runtime exports
|
||||||
|
// Begin JS library exports
|
||||||
|
// End JS library exports
|
||||||
|
|
||||||
|
// end include: postlibrary.js
|
||||||
|
|
||||||
|
|
||||||
|
// Imports from the Wasm binary.
|
||||||
|
var _propagate_lightmap_f32,
|
||||||
|
_compute_blockers_u8,
|
||||||
|
__emscripten_stack_restore,
|
||||||
|
__emscripten_stack_alloc,
|
||||||
|
_emscripten_stack_get_current,
|
||||||
|
memory,
|
||||||
|
__indirect_function_table,
|
||||||
|
wasmMemory;
|
||||||
|
|
||||||
|
|
||||||
|
function assignWasmExports(wasmExports) {
|
||||||
|
_propagate_lightmap_f32 = Module['_propagate_lightmap_f32'] = wasmExports['propagate_lightmap_f32'];
|
||||||
|
_compute_blockers_u8 = Module['_compute_blockers_u8'] = wasmExports['compute_blockers_u8'];
|
||||||
|
__emscripten_stack_restore = wasmExports['_emscripten_stack_restore'];
|
||||||
|
__emscripten_stack_alloc = wasmExports['_emscripten_stack_alloc'];
|
||||||
|
_emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'];
|
||||||
|
memory = wasmMemory = wasmExports['memory'];
|
||||||
|
__indirect_function_table = wasmExports['__indirect_function_table'];
|
||||||
|
}
|
||||||
|
|
||||||
|
var wasmImports = {
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
// include: postamble.js
|
||||||
|
// === Auto-generated postamble setup entry stuff ===
|
||||||
|
|
||||||
|
function run() {
|
||||||
|
|
||||||
|
if (runDependencies > 0) {
|
||||||
|
dependenciesFulfilled = run;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
preRun();
|
||||||
|
|
||||||
|
// a preRun added a dependency, run will be called later
|
||||||
|
if (runDependencies > 0) {
|
||||||
|
dependenciesFulfilled = run;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
function doRun() {
|
||||||
|
// run may have just been called through dependencies being fulfilled just in this very frame,
|
||||||
|
// or while the async setStatus time below was happening
|
||||||
|
Module['calledRun'] = true;
|
||||||
|
|
||||||
|
if (ABORT) return;
|
||||||
|
|
||||||
|
initRuntime();
|
||||||
|
|
||||||
|
Module['onRuntimeInitialized']?.();
|
||||||
|
|
||||||
|
postRun();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (Module['setStatus']) {
|
||||||
|
Module['setStatus']('Running...');
|
||||||
|
setTimeout(() => {
|
||||||
|
setTimeout(() => Module['setStatus'](''), 1);
|
||||||
|
doRun();
|
||||||
|
}, 1);
|
||||||
|
} else
|
||||||
|
{
|
||||||
|
doRun();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var wasmExports;
|
||||||
|
|
||||||
|
// With async instantation wasmExports is assigned asynchronously when the
|
||||||
|
// instance is received.
|
||||||
|
createWasm();
|
||||||
|
|
||||||
|
run();
|
||||||
|
|
||||||
|
// end include: postamble.js
|
||||||
|
|
||||||
|
|
||||||
Binary file not shown.
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue