@polygonjs/polygonjs
Version:
node-based WebGL 3D engine https://polygonjs.com
1,394 lines • 212 kB
JavaScript
"use strict";
const import_meta = {};
var Module = (() => {
var _scriptDir = import_meta.url;
return async function(moduleArg = {}) {
var Module2 = moduleArg;
var readyPromiseResolve, readyPromiseReject;
Module2["ready"] = new Promise((resolve, reject) => {
readyPromiseResolve = resolve;
readyPromiseReject = reject;
});
var _ManifoldInitialized = false;
Module2.setup = function() {
if (_ManifoldInitialized)
return;
_ManifoldInitialized = true;
function toVec(vec, list, f = (x) => x) {
if (list) {
for (let x of list) {
vec.push_back(f(x));
}
}
return vec;
}
function fromVec(vec, f = (x) => x) {
const result = [];
const size = vec.size();
for (let i = 0; i < size; i++)
result.push(f(vec.get(i)));
return result;
}
function vec2polygons(vec, f = (x) => x) {
const result = [];
const nPoly = vec.size();
for (let i = 0; i < nPoly; i++) {
const v = vec.get(i);
const nPts = v.size();
const poly = [];
for (let j = 0; j < nPts; j++) {
poly.push(f(v.get(j)));
}
result.push(poly);
}
return result;
}
function polygons2vec(polygons) {
if (polygons[0].length < 3) {
polygons = [polygons];
}
return toVec(
new Module2.Vector2_vec2(),
polygons,
(poly) => toVec(new Module2.Vector_vec2(), poly, (p) => {
if (p instanceof Array)
return { x: p[0], y: p[1] };
return p;
})
);
}
function disposePolygons(polygonsVec) {
for (let i = 0; i < polygonsVec.size(); i++)
polygonsVec.get(i).delete();
polygonsVec.delete();
}
function vararg2vec2(vec) {
if (vec[0] instanceof Array)
return { x: vec[0][0], y: vec[0][1] };
if (typeof vec[0] == "number")
return { x: vec[0] || 0, y: vec[1] || 0 };
return vec[0];
}
function vararg2vec3(vec) {
if (vec[0] instanceof Array)
return { x: vec[0][0], y: vec[0][1], z: vec[0][2] };
if (typeof vec[0] == "number")
return { x: vec[0] || 0, y: vec[1] || 0, z: vec[2] || 0 };
return vec[0];
}
function fillRuleToInt(fillRule) {
return fillRule == "EvenOdd" ? 0 : fillRule == "NonZero" ? 1 : fillRule == "Negative" ? 3 : 2;
}
function joinTypeToInt(joinType) {
return joinType == "Round" ? 1 : joinType == "Miter" ? 2 : 0;
}
const CrossSectionCtor = Module2.CrossSection;
function cross(polygons, fillRule = "Positive") {
if (polygons instanceof CrossSectionCtor) {
return polygons;
} else {
const polygonsVec = polygons2vec(polygons);
const cs = new CrossSectionCtor(polygonsVec, fillRuleToInt(fillRule));
disposePolygons(polygonsVec);
return cs;
}
}
Module2.CrossSection.prototype.translate = function(...vec) {
return this._Translate(vararg2vec2(vec));
};
Module2.CrossSection.prototype.scale = function(vec) {
if (typeof vec == "number") {
return this._Scale({ x: vec, y: vec });
}
return this._Scale(vararg2vec2([vec]));
};
Module2.CrossSection.prototype.mirror = function(vec) {
return this._Mirror(vararg2vec2([vec]));
};
Module2.CrossSection.prototype.warp = function(func) {
const wasmFuncPtr = addFunction(function(vec2Ptr) {
const x = getValue(vec2Ptr, "float");
const y = getValue(vec2Ptr + 4, "float");
const vert = [x, y];
func(vert);
setValue(vec2Ptr, vert[0], "float");
setValue(vec2Ptr + 4, vert[1], "float");
}, "vi");
const out2 = this._Warp(wasmFuncPtr);
removeFunction(wasmFuncPtr);
return out2;
};
Module2.CrossSection.prototype.decompose = function() {
const vec = this._Decompose();
const result = fromVec(vec);
vec.delete();
return result;
};
Module2.CrossSection.prototype.bounds = function() {
const result = this._Bounds();
return { min: ["x", "y"].map((f) => result.min[f]), max: ["x", "y"].map((f) => result.max[f]) };
};
Module2.CrossSection.prototype.offset = function(delta, joinType = "Square", miterLimit = 2, circularSegments = 0) {
return this._Offset(delta, joinTypeToInt(joinType), miterLimit, circularSegments);
};
Module2.CrossSection.prototype.extrude = function(height, nDivisions = 0, twistDegrees = 0, scaleTop = [1, 1], center = false) {
scaleTop = vararg2vec2([scaleTop]);
const man = Module2._Extrude(this, height, nDivisions, twistDegrees, scaleTop);
return center ? man.translate([0, 0, -height / 2]) : man;
};
Module2.CrossSection.prototype.revolve = function(circularSegments = 0, revolveDegrees = 360) {
return Module2._Revolve(this, circularSegments, revolveDegrees);
};
Module2.CrossSection.prototype.add = function(other) {
return this._add(cross(other));
};
Module2.CrossSection.prototype.subtract = function(other) {
return this._subtract(cross(other));
};
Module2.CrossSection.prototype.intersect = function(other) {
return this._intersect(cross(other));
};
Module2.CrossSection.prototype.toPolygons = function() {
const vec = this._ToPolygons();
const result = vec2polygons(vec);
vec.delete();
return result;
};
Module2.Manifold.prototype.warp = function(func) {
const wasmFuncPtr = addFunction(function(vec3Ptr) {
const x = getValue(vec3Ptr, "float");
const y = getValue(vec3Ptr + 4, "float");
const z = getValue(vec3Ptr + 8, "float");
const vert = [x, y, z];
func(vert);
setValue(vec3Ptr, vert[0], "float");
setValue(vec3Ptr + 4, vert[1], "float");
setValue(vec3Ptr + 8, vert[2], "float");
}, "vi");
const out2 = this._Warp(wasmFuncPtr);
removeFunction(wasmFuncPtr);
const status = out2.status();
if (status.value !== 0) {
throw new Module2.ManifoldError(status.value);
}
return out2;
};
Module2.Manifold.prototype.setProperties = function(numProp2, func) {
const oldNumProp = this.numProp();
const wasmFuncPtr = addFunction(function(newPtr, vec3Ptr, oldPtr) {
const newProp = [];
for (let i = 0; i < numProp2; ++i) {
newProp[i] = getValue(newPtr + 4 * i, "float");
}
const pos = [];
for (let i = 0; i < 3; ++i) {
pos[i] = getValue(vec3Ptr + 4 * i, "float");
}
const oldProp = [];
for (let i = 0; i < oldNumProp; ++i) {
oldProp[i] = getValue(oldPtr + 4 * i, "float");
}
func(newProp, pos, oldProp);
for (let i = 0; i < numProp2; ++i) {
setValue(newPtr + 4 * i, newProp[i], "float");
}
}, "viii");
const out2 = this._SetProperties(numProp2, wasmFuncPtr);
removeFunction(wasmFuncPtr);
return out2;
};
Module2.Manifold.prototype.translate = function(...vec) {
return this._Translate(vararg2vec3(vec));
};
Module2.Manifold.prototype.rotate = function(vec) {
return this._Rotate(...vec);
};
Module2.Manifold.prototype.scale = function(vec) {
if (typeof vec == "number") {
return this._Scale({ x: vec, y: vec, z: vec });
}
return this._Scale(vararg2vec3([vec]));
};
Module2.Manifold.prototype.mirror = function(vec) {
return this._Mirror(vararg2vec3([vec]));
};
Module2.Manifold.prototype.trimByPlane = function(normal, offset = 0) {
return this._TrimByPlane(vararg2vec3([normal]), offset);
};
Module2.Manifold.prototype.split = function(manifold) {
const vec = this._split(manifold);
const result = fromVec(vec);
vec.delete();
return result;
};
Module2.Manifold.prototype.splitByPlane = function(normal, offset = 0) {
const vec = this._splitByPlane(vararg2vec3([normal]), offset);
const result = fromVec(vec);
vec.delete();
return result;
};
Module2.Manifold.prototype.decompose = function() {
const vec = this._Decompose();
const result = fromVec(vec);
vec.delete();
return result;
};
Module2.Manifold.prototype.boundingBox = function() {
const result = this._boundingBox();
return { min: ["x", "y", "z"].map((f) => result.min[f]), max: ["x", "y", "z"].map((f) => result.max[f]) };
};
class Mesh {
constructor({
numProp: numProp2 = 3,
triVerts = new Uint32Array(),
vertProperties = new Float32Array(),
mergeFromVert,
mergeToVert,
runIndex,
runOriginalID,
faceID,
halfedgeTangent,
runTransform
} = {}) {
this.numProp = numProp2;
this.triVerts = triVerts;
this.vertProperties = vertProperties;
this.mergeFromVert = mergeFromVert;
this.mergeToVert = mergeToVert;
this.runIndex = runIndex;
this.runOriginalID = runOriginalID;
this.faceID = faceID;
this.halfedgeTangent = halfedgeTangent;
this.runTransform = runTransform;
}
get numTri() {
return this.triVerts.length / 3;
}
get numVert() {
return this.vertProperties.length / this.numProp;
}
get numRun() {
return this.runOriginalID.length;
}
merge() {
const { changed, mesh } = Module2._Merge(this);
Object.assign(this, { ...mesh });
return changed;
}
verts(tri) {
return this.triVerts.subarray(3 * tri, 3 * (tri + 1));
}
position(vert) {
return this.vertProperties.subarray(numProp * vert, numProp * vert + 3);
}
extras(vert) {
return this.vertProperties.subarray(numProp * vert + 3, numProp * (vert + 1));
}
tangent(halfedge) {
return this.halfedgeTangent.subarray(4 * halfedge, 4 * (halfedge + 1));
}
transform(run2) {
const mat4 = new Array(16);
for (const col of [0, 1, 2, 3]) {
for (const row of [0, 1, 2]) {
mat4[4 * col + row] = this.runTransform[12 * run2 + 3 * col + row];
}
}
mat4[15] = 1;
return mat4;
}
}
Module2.Mesh = Mesh;
Module2.Manifold.prototype.getMesh = function(normalIdx = [0, 0, 0]) {
if (normalIdx instanceof Array)
normalIdx = { 0: normalIdx[0], 1: normalIdx[1], 2: normalIdx[2] };
return new Mesh(this._GetMeshJS(normalIdx));
};
Module2.ManifoldError = function ManifoldError(code, ...args) {
let message = "Unknown error";
switch (code) {
case Module2.status.NonFiniteVertex.value:
message = "Non-finite vertex";
break;
case Module2.status.NotManifold.value:
message = "Not manifold";
break;
case Module2.status.VertexOutOfBounds.value:
message = "Vertex index out of bounds";
break;
case Module2.status.PropertiesWrongLength.value:
message = "Properties have wrong length";
break;
case Module2.status.MissingPositionProperties.value:
message = "Less than three properties";
break;
case Module2.status.MergeVectorsDifferentLengths.value:
message = "Merge vectors have different lengths";
break;
case Module2.status.MergeIndexOutOfBounds.value:
message = "Merge index out of bounds";
break;
case Module2.status.TransformWrongLength.value:
message = "Transform vector has wrong length";
break;
case Module2.status.RunIndexWrongLength.value:
message = "Run index vector has wrong length";
break;
case Module2.status.FaceIDWrongLength.value:
message = "Face ID vector has wrong length";
case Module2.status.InvalidConstruction.value:
message = "Manifold constructed with invalid parameters";
}
const base = Error.apply(this, [message, ...args]);
base.name = this.name = "ManifoldError";
this.message = base.message;
this.stack = base.stack;
this.code = code;
};
Module2.ManifoldError.prototype = Object.create(Error.prototype, {
constructor: { value: Module2.ManifoldError, writable: true, configurable: true }
});
Module2.CrossSection = function(polygons, fillRule = "Positive") {
const polygonsVec = polygons2vec(polygons);
const cs = new CrossSectionCtor(polygonsVec, fillRuleToInt(fillRule));
disposePolygons(polygonsVec);
return cs;
};
Module2.CrossSection.ofPolygons = function(polygons, fillRule = "Positive") {
return new Module2.CrossSection(polygons, fillRule);
};
Module2.CrossSection.square = function(...args) {
let size = void 0;
if (args.length == 0)
size = { x: 1, y: 1 };
else if (typeof args[0] == "number")
size = { x: args[0], y: args[0] };
else
size = vararg2vec2(args);
const center = args[1] || false;
return Module2._Square(size, center);
};
Module2.CrossSection.circle = function(radius, circularSegments = 0) {
return Module2._Circle(radius, circularSegments);
};
function crossSectionBatchbool(name) {
return function(...args) {
if (args.length == 1)
args = args[0];
const v = new Module2.Vector_crossSection();
for (const cs of args)
v.push_back(cross(cs));
const result = Module2["_crossSection" + name](v);
v.delete();
return result;
};
}
Module2.CrossSection.compose = crossSectionBatchbool("Compose");
Module2.CrossSection.union = crossSectionBatchbool("UnionN");
Module2.CrossSection.difference = crossSectionBatchbool("DifferenceN");
Module2.CrossSection.intersection = crossSectionBatchbool("IntersectionN");
function pushVec2(vec, ps) {
toVec(vec, ps, (p) => {
if (p instanceof Array)
return { x: p[0], y: p[1] };
return p;
});
}
Module2.CrossSection.hull = function(...args) {
if (args.length == 1)
args = args[0];
let pts = new Module2.Vector_vec2();
for (const cs of args) {
if (cs instanceof CrossSectionCtor) {
Module2._crossSectionCollectVertices(pts, cs);
} else if (cs instanceof Array && cs.length == 2 && typeof cs[0] == "number") {
pts.push_back({ x: cs[0], y: cs[1] });
} else if (cs.x) {
pts.push_back(cs);
} else {
const wrap = cs[0].length == 2 && typeof cs[0][0] == "number" || cs[0].x;
const polys = wrap ? [cs] : cs;
for (const poly of polys)
pushVec2(pts, poly);
}
}
const result = Module2._crossSectionHullPoints(pts);
pts.delete();
return result;
};
Module2.CrossSection.prototype = Object.create(CrossSectionCtor.prototype);
Object.defineProperty(Module2.CrossSection, Symbol.hasInstance, {
get: () => (t) => t instanceof CrossSectionCtor
});
const ManifoldCtor = Module2.Manifold;
Module2.Manifold = function(mesh) {
const manifold = new ManifoldCtor(mesh);
const status = manifold.status();
if (status.value !== 0) {
throw new Module2.ManifoldError(status.value);
}
return manifold;
};
Module2.Manifold.ofMesh = function(mesh) {
return new Module2.Manifold(mesh);
};
Module2.Manifold.tetrahedron = function() {
return Module2._Tetrahedron();
};
Module2.Manifold.cube = function(...args) {
let size = void 0;
if (args.length == 0)
size = { x: 1, y: 1, z: 1 };
else if (typeof args[0] == "number")
size = { x: args[0], y: args[0], z: args[0] };
else
size = vararg2vec3(args);
const center = args[1] || false;
return Module2._Cube(size, center);
};
Module2.Manifold.cylinder = function(height, radiusLow, radiusHigh = -1, circularSegments = 0, center = false) {
return Module2._Cylinder(height, radiusLow, radiusHigh, circularSegments, center);
};
Module2.Manifold.sphere = function(radius, circularSegments = 0) {
return Module2._Sphere(radius, circularSegments);
};
Module2.Manifold.smooth = function(mesh, sharpenedEdges = []) {
const sharp = new Module2.Vector_smoothness();
toVec(sharp, sharpenedEdges);
const result = Module2._Smooth(mesh, sharp);
sharp.delete();
return result;
};
Module2.Manifold.extrude = function(polygons, height, nDivisions = 0, twistDegrees = 0, scaleTop = [1, 1], center = false) {
const cs = polygons instanceof CrossSectionCtor ? polygons : Module2.CrossSection(polygons, "Positive");
return cs.extrude(height, nDivisions, twistDegrees, scaleTop, center);
};
Module2.Manifold.revolve = function(polygons, circularSegments = 0, revolveDegrees = 360) {
const cs = polygons instanceof CrossSectionCtor ? polygons : Module2.CrossSection(polygons, "Positive");
return cs.revolve(circularSegments, revolveDegrees);
};
Module2.Manifold.reserveIDs = function(n) {
return Module2._ReserveIDs(n);
};
Module2.Manifold.compose = function(manifolds) {
const vec = new Module2.Vector_manifold();
toVec(vec, manifolds);
const result = Module2._manifoldCompose(vec);
vec.delete();
return result;
};
function manifoldBatchbool(name) {
return function(...args) {
if (args.length == 1)
args = args[0];
const v = new Module2.Vector_manifold();
for (const m of args)
v.push_back(m);
const result = Module2["_manifold" + name + "N"](v);
v.delete();
return result;
};
}
Module2.Manifold.union = manifoldBatchbool("Union");
Module2.Manifold.difference = manifoldBatchbool("Difference");
Module2.Manifold.intersection = manifoldBatchbool("Intersection");
Module2.Manifold.levelSet = function(sdf, bounds, edgeLength, level = 0) {
const bounds2 = {
min: { x: bounds.min[0], y: bounds.min[1], z: bounds.min[2] },
max: { x: bounds.max[0], y: bounds.max[1], z: bounds.max[2] }
};
const wasmFuncPtr = addFunction(function(vec3Ptr) {
const x = getValue(vec3Ptr, "float");
const y = getValue(vec3Ptr + 4, "float");
const z = getValue(vec3Ptr + 8, "float");
const vert = [x, y, z];
return sdf(vert);
}, "fi");
const out2 = Module2._LevelSet(wasmFuncPtr, bounds2, edgeLength, level);
removeFunction(wasmFuncPtr);
return out2;
};
function pushVec3(vec, ps) {
toVec(vec, ps, (p) => {
if (p instanceof Array)
return { x: p[0], y: p[1], z: p[2] };
return p;
});
}
Module2.Manifold.hull = function(...args) {
if (args.length == 1)
args = args[0];
let pts = new Module2.Vector_vec3();
for (const m of args) {
if (m instanceof ManifoldCtor) {
Module2._manifoldCollectVertices(pts, m);
} else if (m instanceof Array && m.length == 3 && typeof m[0] == "number") {
pts.push_back({ x: m[0], y: m[1], z: m[2] });
} else if (m.x) {
pts.push_back(m);
} else {
pushVec3(pts, m);
}
}
const result = Module2._manifoldHullPoints(pts);
pts.delete();
return result;
};
Module2.Manifold.prototype = Object.create(ManifoldCtor.prototype);
Object.defineProperty(Module2.Manifold, Symbol.hasInstance, { get: () => (t) => t instanceof ManifoldCtor });
Module2.triangulate = function(polygons, precision = -1) {
const polygonsVec = polygons2vec(polygons);
const result = fromVec(Module2._Triangulate(polygonsVec, precision), (x) => [x[0], x[1], x[2]]);
disposePolygons(polygonsVec);
return result;
};
};
var moduleOverrides = Object.assign({}, Module2);
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
throw toThrow;
};
var ENVIRONMENT_IS_WEB = typeof window == "object";
var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
var scriptDirectory = "";
function locateFile(path) {
if (Module2["locateFile"]) {
return Module2["locateFile"](path, scriptDirectory);
}
return scriptDirectory + path;
}
var read_, readAsync, readBinary, setWindowTitle;
if (ENVIRONMENT_IS_NODE) {
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = self.location.href;
} else if (typeof document != "undefined" && document.currentScript) {
scriptDirectory = document.currentScript.src;
}
if (_scriptDir) {
scriptDirectory = _scriptDir;
}
if (scriptDirectory.indexOf("blob:") !== 0) {
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
} else {
scriptDirectory = "";
}
{
read_ = (url) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.send(null);
return xhr.responseText;
};
if (ENVIRONMENT_IS_WORKER) {
readBinary = (url) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.responseType = "arraybuffer";
xhr.send(null);
return new Uint8Array(xhr.response);
};
}
readAsync = (url, onload, onerror) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, true);
xhr.responseType = "arraybuffer";
xhr.onload = () => {
if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
onload(xhr.response);
return;
}
onerror();
};
xhr.onerror = onerror;
xhr.send(null);
};
}
setWindowTitle = (title) => document.title = title;
} else {
}
var out = Module2["print"] || console.log.bind(console);
var err = Module2["printErr"] || console.error.bind(console);
Object.assign(Module2, moduleOverrides);
moduleOverrides = null;
if (Module2["arguments"])
arguments_ = Module2["arguments"];
if (Module2["thisProgram"])
thisProgram = Module2["thisProgram"];
if (Module2["quit"])
quit_ = Module2["quit"];
var wasmBinary;
if (Module2["wasmBinary"])
wasmBinary = Module2["wasmBinary"];
var noExitRuntime = Module2["noExitRuntime"] || true;
if (typeof WebAssembly != "object") {
abort("no native wasm support detected");
}
var wasmMemory;
var ABORT = false;
var EXITSTATUS;
function assert(condition, text) {
if (!condition) {
abort(text);
}
}
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
function updateMemoryViews() {
var b = wasmMemory.buffer;
Module2["HEAP8"] = HEAP8 = new Int8Array(b);
Module2["HEAP16"] = HEAP16 = new Int16Array(b);
Module2["HEAPU8"] = HEAPU8 = new Uint8Array(b);
Module2["HEAPU16"] = HEAPU16 = new Uint16Array(b);
Module2["HEAP32"] = HEAP32 = new Int32Array(b);
Module2["HEAPU32"] = HEAPU32 = new Uint32Array(b);
Module2["HEAPF32"] = HEAPF32 = new Float32Array(b);
Module2["HEAPF64"] = HEAPF64 = new Float64Array(b);
}
var wasmTable;
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
function preRun() {
if (Module2["preRun"]) {
if (typeof Module2["preRun"] == "function")
Module2["preRun"] = [Module2["preRun"]];
while (Module2["preRun"].length) {
addOnPreRun(Module2["preRun"].shift());
}
}
callRuntimeCallbacks(__ATPRERUN__);
}
function initRuntime() {
runtimeInitialized = true;
if (!Module2["noFSInit"] && !FS.init.initialized)
FS.init();
FS.ignorePermissions = false;
TTY.init();
callRuntimeCallbacks(__ATINIT__);
}
function postRun() {
if (Module2["postRun"]) {
if (typeof Module2["postRun"] == "function")
Module2["postRun"] = [Module2["postRun"]];
while (Module2["postRun"].length) {
addOnPostRun(Module2["postRun"].shift());
}
}
callRuntimeCallbacks(__ATPOSTRUN__);
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb);
}
function addOnInit(cb) {
__ATINIT__.unshift(cb);
}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb);
}
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null;
function getUniqueRunDependency(id) {
return id;
}
function addRunDependency(id) {
runDependencies++;
if (Module2["monitorRunDependencies"]) {
Module2["monitorRunDependencies"](runDependencies);
}
}
function removeRunDependency(id) {
runDependencies--;
if (Module2["monitorRunDependencies"]) {
Module2["monitorRunDependencies"](runDependencies);
}
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
}
}
function abort(what) {
if (Module2["onAbort"]) {
Module2["onAbort"](what);
}
what = "Aborted(" + what + ")";
err(what);
ABORT = true;
EXITSTATUS = 1;
what += ". Build with -sASSERTIONS for more info.";
var e = new WebAssembly.RuntimeError(what);
readyPromiseReject(e);
throw e;
}
var dataURIPrefix = "data:application/octet-stream;base64,";
function isDataURI(filename) {
return filename.startsWith(dataURIPrefix);
}
function isFileURI(filename) {
return filename.startsWith("file://");
}
var wasmBinaryFile;
if (Module2["locateFile"]) {
wasmBinaryFile = "manifold.wasm";
if (!isDataURI(wasmBinaryFile)) {
wasmBinaryFile = locateFile(wasmBinaryFile);
}
} else {
}
function getBinarySync(file) {
if (file == wasmBinaryFile && wasmBinary) {
return new Uint8Array(wasmBinary);
}
if (readBinary) {
return readBinary(file);
}
throw "both async and sync fetching of the wasm failed";
}
function getBinaryPromise(binaryFile) {
if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
if (typeof fetch == "function" && !isFileURI(binaryFile)) {
return fetch(binaryFile, { credentials: "same-origin" }).then((response) => {
if (!response["ok"]) {
throw "failed to load wasm binary file at '" + binaryFile + "'";
}
return response["arrayBuffer"]();
}).catch(() => getBinarySync(binaryFile));
} else if (readAsync) {
return new Promise((resolve, reject) => {
readAsync(binaryFile, (response) => resolve(new Uint8Array(response)), reject);
});
}
}
return Promise.resolve().then(() => getBinarySync(binaryFile));
}
function instantiateArrayBuffer(binaryFile, imports, receiver) {
return getBinaryPromise(binaryFile).then((binary) => WebAssembly.instantiate(binary, imports)).then((instance) => instance).then(receiver, (reason) => {
err(`failed to asynchronously prepare wasm: ${reason}`);
abort(reason);
});
}
function instantiateAsync(binary, binaryFile, imports, callback) {
if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
return fetch(binaryFile, { credentials: "same-origin" }).then((response) => {
var result = WebAssembly.instantiateStreaming(response, imports);
return result.then(callback, function(reason) {
err(`wasm streaming compile failed: ${reason}`);
err("falling back to ArrayBuffer instantiation");
return instantiateArrayBuffer(binaryFile, imports, callback);
});
});
}
return instantiateArrayBuffer(binaryFile, imports, callback);
}
function createWasm() {
var info = { a: wasmImports };
function receiveInstance(instance, module) {
var exports = instance.exports;
wasmExports = exports;
wasmMemory = wasmExports["Na"];
updateMemoryViews();
wasmTable = wasmExports["Pa"];
addOnInit(wasmExports["Oa"]);
removeRunDependency("wasm-instantiate");
return exports;
}
addRunDependency("wasm-instantiate");
function receiveInstantiationResult(result) {
receiveInstance(result["instance"]);
}
if (Module2["instantiateWasm"]) {
try {
return Module2["instantiateWasm"](info, receiveInstance);
} catch (e) {
err(`Module.instantiateWasm callback failed with error: ${e}`);
readyPromiseReject(e);
}
}
instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
return {};
}
var tempDouble;
var tempI64;
var callRuntimeCallbacks = (callbacks) => {
while (callbacks.length > 0) {
callbacks.shift()(Module2);
}
};
function getValue(ptr, type = "i8") {
if (type.endsWith("*"))
type = "*";
switch (type) {
case "i1":
return HEAP8[ptr >> 0];
case "i8":
return HEAP8[ptr >> 0];
case "i16":
return HEAP16[ptr >> 1];
case "i32":
return HEAP32[ptr >> 2];
case "i64":
abort("to do getValue(i64) use WASM_BIGINT");
case "float":
return HEAPF32[ptr >> 2];
case "double":
return HEAPF64[ptr >> 3];
case "*":
return HEAPU32[ptr >> 2];
default:
abort(`invalid type for getValue: ${type}`);
}
}
function setValue(ptr, value, type = "i8") {
if (type.endsWith("*"))
type = "*";
switch (type) {
case "i1":
HEAP8[ptr >> 0] = value;
break;
case "i8":
HEAP8[ptr >> 0] = value;
break;
case "i16":
HEAP16[ptr >> 1] = value;
break;
case "i32":
HEAP32[ptr >> 2] = value;
break;
case "i64":
abort("to do setValue(i64) use WASM_BIGINT");
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 exceptionCaught = [];
var uncaughtExceptionCount = 0;
var ___cxa_begin_catch = (ptr) => {
var info = new ExceptionInfo(ptr);
if (!info.get_caught()) {
info.set_caught(true);
uncaughtExceptionCount--;
}
info.set_rethrown(false);
exceptionCaught.push(info);
___cxa_increment_exception_refcount(info.excPtr);
return info.get_exception_ptr();
};
var exceptionLast = 0;
var ___cxa_end_catch = () => {
_setThrew(0, 0);
var info = exceptionCaught.pop();
___cxa_decrement_exception_refcount(info.excPtr);
exceptionLast = 0;
};
function ExceptionInfo(excPtr) {
this.excPtr = excPtr;
this.ptr = excPtr - 24;
this.set_type = function(type) {
HEAPU32[this.ptr + 4 >> 2] = type;
};
this.get_type = function() {
return HEAPU32[this.ptr + 4 >> 2];
};
this.set_destructor = function(destructor) {
HEAPU32[this.ptr + 8 >> 2] = destructor;
};
this.get_destructor = function() {
return HEAPU32[this.ptr + 8 >> 2];
};
this.set_caught = function(caught) {
caught = caught ? 1 : 0;
HEAP8[this.ptr + 12 >> 0] = caught;
};
this.get_caught = function() {
return HEAP8[this.ptr + 12 >> 0] != 0;
};
this.set_rethrown = function(rethrown) {
rethrown = rethrown ? 1 : 0;
HEAP8[this.ptr + 13 >> 0] = rethrown;
};
this.get_rethrown = function() {
return HEAP8[this.ptr + 13 >> 0] != 0;
};
this.init = function(type, destructor) {
this.set_adjusted_ptr(0);
this.set_type(type);
this.set_destructor(destructor);
};
this.set_adjusted_ptr = function(adjustedPtr) {
HEAPU32[this.ptr + 16 >> 2] = adjustedPtr;
};
this.get_adjusted_ptr = function() {
return HEAPU32[this.ptr + 16 >> 2];
};
this.get_exception_ptr = function() {
var isPointer = ___cxa_is_pointer_type(this.get_type());
if (isPointer) {
return HEAPU32[this.excPtr >> 2];
}
var adjusted = this.get_adjusted_ptr();
if (adjusted !== 0)
return adjusted;
return this.excPtr;
};
}
var ___resumeException = (ptr) => {
if (!exceptionLast) {
exceptionLast = ptr;
}
throw exceptionLast;
};
var findMatchingCatch = (args) => {
var thrown = exceptionLast;
if (!thrown) {
setTempRet0(0);
return 0;
}
var info = new ExceptionInfo(thrown);
info.set_adjusted_ptr(thrown);
var thrownType = info.get_type();
if (!thrownType) {
setTempRet0(0);
return thrown;
}
for (var arg in args) {
var caughtType = args[arg];
if (caughtType === 0 || caughtType === thrownType) {
break;
}
var adjusted_ptr_addr = info.ptr + 16;
if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {
setTempRet0(caughtType);
return thrown;
}
}
setTempRet0(thrownType);
return thrown;
};
var ___cxa_find_matching_catch_2 = () => findMatchingCatch([]);
var ___cxa_find_matching_catch_3 = (arg0) => findMatchingCatch([arg0]);
var ___cxa_rethrow = () => {
var info = exceptionCaught.pop();
if (!info) {
abort("no exception to throw");
}
var ptr = info.excPtr;
if (!info.get_rethrown()) {
exceptionCaught.push(info);
info.set_rethrown(true);
info.set_caught(false);
uncaughtExceptionCount++;
}
exceptionLast = ptr;
throw exceptionLast;
};
var ___cxa_throw = (ptr, type, destructor) => {
var info = new ExceptionInfo(ptr);
info.init(type, destructor);
exceptionLast = ptr;
uncaughtExceptionCount++;
throw exceptionLast;
};
var ___cxa_uncaught_exceptions = () => uncaughtExceptionCount;
var structRegistrations = {};
var runDestructors = (destructors) => {
while (destructors.length) {
var ptr = destructors.pop();
var del = destructors.pop();
del(ptr);
}
};
function simpleReadValueFromPointer(pointer) {
return this["fromWireType"](HEAP32[pointer >> 2]);
}
var awaitingDependencies = {};
var registeredTypes = {};
var typeDependencies = {};
var InternalError = void 0;
var throwInternalError = (message) => {
throw new InternalError(message);
};
var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
myTypes.forEach(function(type) {
typeDependencies[type] = dependentTypes;
});
function onComplete(typeConverters2) {
var myTypeConverters = getTypeConverters(typeConverters2);
if (myTypeConverters.length !== myTypes.length) {
throwInternalError("Mismatched type converter count");
}
for (var i = 0; i < myTypes.length; ++i) {
registerType(myTypes[i], myTypeConverters[i]);
}
}
var typeConverters = new Array(dependentTypes.length);
var unregisteredTypes = [];
var registered = 0;
dependentTypes.forEach((dt, i) => {
if (registeredTypes.hasOwnProperty(dt)) {
typeConverters[i] = registeredTypes[dt];
} else {
unregisteredTypes.push(dt);
if (!awaitingDependencies.hasOwnProperty(dt)) {
awaitingDependencies[dt] = [];
}
awaitingDependencies[dt].push(() => {
typeConverters[i] = registeredTypes[dt];
++registered;
if (registered === unregisteredTypes.length) {
onComplete(typeConverters);
}
});
}
});
if (0 === unregisteredTypes.length) {
onComplete(typeConverters);
}
};
var __embind_finalize_value_object = (structType) => {
var reg = structRegistrations[structType];
delete structRegistrations[structType];
var rawConstructor = reg.rawConstructor;
var rawDestructor = reg.rawDestructor;
var fieldRecords = reg.fields;
var fieldTypes = fieldRecords.map((field) => field.getterReturnType).concat(fieldRecords.map((field) => field.setterArgumentType));
whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes2) => {
var fields = {};
fieldRecords.forEach((field, i) => {
var fieldName = field.fieldName;
var getterReturnType = fieldTypes2[i];
var getter = field.getter;
var getterContext = field.getterContext;
var setterArgumentType = fieldTypes2[i + fieldRecords.length];
var setter = field.setter;
var setterContext = field.setterContext;
fields[fieldName] = {
read: (ptr) => getterReturnType["fromWireType"](getter(getterContext, ptr)),
write: (ptr, o) => {
var destructors = [];
setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o));
runDestructors(destructors);
}
};
});
return [
{
name: reg.name,
fromWireType: (ptr) => {
var rv = {};
for (var i in fields) {
rv[i] = fields[i].read(ptr);
}
rawDestructor(ptr);
return rv;
},
toWireType: (destructors, o) => {
for (var fieldName in fields) {
if (!(fieldName in o)) {
throw new TypeError(`Missing field: "${fieldName}"`);
}
}
var ptr = rawConstructor();
for (fieldName in fields) {
fields[fieldName].write(ptr, o[fieldName]);
}
if (destructors !== null) {
destructors.push(rawDestructor, ptr);
}
return ptr;
},
argPackAdvance: GenericWireTypeSize,
readValueFromPointer: simpleReadValueFromPointer,
destructorFunction: rawDestructor
}
];
});
};
var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {
};
var embind_init_charCodes = () => {
var codes = new Array(256);
for (var i = 0; i < 256; ++i) {
codes[i] = String.fromCharCode(i);
}
embind_charCodes = codes;
};
var embind_charCodes = void 0;
var readLatin1String = (ptr) => {
var ret = "";
var c = ptr;
while (HEAPU8[c]) {
ret += embind_charCodes[HEAPU8[c++]];
}
return ret;
};
var BindingError = void 0;
var throwBindingError = (message) => {
throw new BindingError(message);
};
function sharedRegisterType(rawType, registeredInstance, options = {}) {
var name = registeredInstance.name;
if (!rawType) {
throwBindingError(`type "${name}" must have a positive integer typeid pointer`);
}
if (registeredTypes.hasOwnProperty(rawType)) {
if (options.ignoreDuplicateRegistrations) {
return;
} else {
throwBindingError(`Cannot register type '${name}' twice`);
}
}
registeredTypes[rawType] = registeredInstance;
delete typeDependencies[rawType];
if (awaitingDependencies.hasOwnProperty(rawType)) {
var callbacks = awaitingDependencies[rawType];
delete awaitingDependencies[rawType];
callbacks.forEach((cb) => cb());
}
}
function registerType(rawType, registeredInstance, options = {}) {
if (!("argPackAdvance" in registeredInstance)) {
throw new TypeError("registerType registeredInstance requires argPackAdvance");
}
return sharedRegisterType(rawType, registeredInstance, options);
}
var GenericWireTypeSize = 8;
var __embind_register_bool = (rawType, name, trueValue, falseValue) => {
name = readLatin1String(name);
registerType(rawType, {
name,
fromWireType: function(wt) {
return !!wt;
},
toWireType: function(destructors, o) {
return o ? trueValue : falseValue;
},
argPackAdvance: GenericWireTypeSize,
readValueFromPointer: function(pointer) {
return this["fromWireType"](HEAPU8[pointer]);
},
destructorFunction: null
});
};
function ClassHandle_isAliasOf(other) {
if (!(this instanceof ClassHandle)) {
return false;
}
if (!(other instanceof ClassHandle)) {
return false;
}
var leftClass = this.$$.ptrType.registeredClass;
var left = this.$$.ptr;
var rightClass = other.$$.ptrType.registeredClass;
var right = other.$$.ptr;
while (leftClass.baseClass) {
left = leftClass.upcast(left);
leftClass = leftClass.baseClass;
}
while (rightClass.baseClass) {
right = rightClass.upcast(right);
rightClass = rightClass.baseClass;
}
return leftClass === rightClass && left === right;
}
var shallowCopyInternalPointer = (o) => ({
count: o.count,
deleteScheduled: o.deleteScheduled,
preservePointerOnDelete: o.preservePointerOnDelete,
ptr: o.ptr,
ptrType: o.ptrType,
smartPtr: o.smartPtr,
smartPtrType: o.smartPtrType
});
var throwInstanceAlreadyDeleted = (obj) => {
function getInstanceTypeName(handle) {
return handle.$$.ptrType.registeredClass.name;
}
throwBindingError(getInstanceTypeName(obj) + " instance already deleted");
};
var finalizationRegistry = false;
var detachFinalizer = (handle) => {
};
var runDestructor = ($$) => {
if ($$.smartPtr) {
$$.smartPtrType.rawDestructor($$.smartPtr);
} else {
$$.ptrType.registeredClass.rawDestructor($$.ptr);
}
};
var releaseClassHandle = ($$) => {
$$.count.value -= 1;
var toDelete = 0 === $$.count.value;
if (toDelete) {
runDestructor($$);
}
};
var downcastPointer = (ptr, ptrClass, desiredClass) => {
if (ptrClass === desiredClass) {
return ptr;
}
if (void 0 === desiredClass.baseClass) {
return null;
}
var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
if (rv === null) {
return null;
}
return desiredClass.downcast(rv);
};
var registeredPointers = {};
var getInheritedInstanceCount = () => Object.keys(registeredInstances).length;
var getLiveInheritedInstances = () => {
var rv = [];
for (var k in registeredInstances) {
if (registeredInstances.hasOwnProperty(k)) {
rv.push(registeredInstances[k]);
}
}
return rv;
};
var deletionQueue = [];
var flushPendingDeletes = () => {
while (deletionQueue.length) {
var obj = deletionQueue.pop();
obj.$$.deleteScheduled = false;
obj["delete"]();
}
};
var delayFunction = void 0;
var setDelayFunction = (fn) => {
delayFunction = fn;
if (deletionQueue.length && delayFunction) {
delayFunction(flushPendingDeletes);
}
};
var init_embind = () => {
Module2["getInheritedInstanceCount"] = getInheritedInstanceCount;
Module2["getLiveInheritedInstances"] = getLiveInheritedInstances;
Module2["flushPendingDeletes"] = flushPendingDeletes;
Module2["setDelayFunction"] = setDelayFunction;
};
var registeredInstances = {};
var getBasestPointer = (class_, ptr) => {
if (ptr === void 0) {
throwBindingError("ptr should not be undefined");
}
while (class_.baseClass) {
ptr = class_.upcast(ptr);
class_ = class_.baseClass;
}
return ptr;
};
var getInheritedInstance = (class_, ptr) => {
ptr = getBasestPointer(class_, ptr);
return registeredInstances[ptr];
};
var makeClassHandle = (prototype, record) => {
if (!record.ptrType || !record.ptr) {
throwInternalError("makeClassHandle requires ptr and ptrType");
}
var hasSmartPtrType = !!record.smartPtrType;
var hasSmartPtr = !!record.smartPtr;
if (hasSmartPtrType !== hasSmartPtr) {
throwInternalError("Both smartPtrType and smartPtr must be specified");
}
record.count = { value: 1 };
return attachFinalizer(Object.create(prototype, { $$: { value: record } }));
};
function RegisteredPointer_fromWireType(ptr) {
var rawPointer = this.getPointee(ptr);
if (!rawPointer) {
this.destructor(ptr);
return null;
}
var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
if (void 0 !== registeredInstance) {
if (0 === registeredInstance.$$.count.value) {
registeredInstance.$$.ptr = rawPointer;
registeredInstance.$$.smartPtr = ptr;
return registeredInstance["clone"]();
} else {
var rv = registeredInstance["clone"]();
this.destructor(ptr);
return rv;
}
}
function makeDefaultHandle() {
if (this.isSmartPointer) {
return makeClassHandle(this.registeredClass.instancePrototype, {
ptrType: this.pointeeType,
ptr: rawPointer,
smartPtrType: this,
smartPtr: ptr
});
} else {
return makeClassHandle(this.registeredClass.instancePrototype, { ptrType: this, ptr });
}
}
var actualType = this.registeredClass.getActualType(rawPointer);
var registeredPointerRecord = registeredPointers[actualType];
if (!registeredPointerRecord) {
return makeDefaultHandle.call(this);
}
var toType;
if (this.isConst) {
toType = registeredPointerRecord.constPointerType;
} else {
toType = registeredPointerRecord.pointerType;
}
var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);
if (dp === null) {
return makeDefaultHandle.call(this);
}
if (this.isSmartPointer) {
return makeClassHandle(toType.registeredClass.instancePrototype, {
ptrType: toType,
ptr: dp,
smartPtrType: this,
smartPtr: ptr
});
} else {
return makeClassHandle(toType.registeredClass.instancePrototype, { ptrType: toType, ptr: dp });
}
}
var attachFinalizer = (handle) => {
if ("undefined" === typeof FinalizationRegistry) {
attachFinalizer = (handle2) => handle2;
return handle;
}
finalizationRegistry = new FinalizationRegistry((info) => {
releaseClassHandle(info.$$);
});
attachFinalizer = (handle2) => {
var $$ = handle2.$$;
var hasSmartPtr = !!$$.smartPtr;
if (hasSmartPtr) {
var info = { $$ };
finalizationRegistry.register(handle2, info, handle2);
}
return handle2;
};
detachFinalizer = (handle2) => finalizationRegistry.unregister(handle2);
return attachFinalizer(handle);
};
function ClassHandle_clone() {
if (!this.$$.ptr) {
throwInstanceA