opengeometry
Version:
CAD Kernel for Web with OpenGeometry
1,713 lines (1,705 loc) • 338 kB
JavaScript
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __classPrivateFieldGet(receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
}
typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
let wasm;
const cachedTextDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', {
ignoreBOM: true,
fatal: true
}) : {
decode: () => {
throw Error('TextDecoder not available');
}
};
if (typeof TextDecoder !== 'undefined') {
cachedTextDecoder.decode();
}
let cachedUint8ArrayMemory0 = null;
function getUint8ArrayMemory0() {
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
}
return cachedUint8ArrayMemory0;
}
function getStringFromWasm0(ptr, len) {
ptr = ptr >>> 0;
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
}
const heap = new Array(128).fill(undefined);
heap.push(undefined, null, true, false);
let heap_next = heap.length;
function addHeapObject(obj) {
if (heap_next === heap.length) heap.push(heap.length + 1);
const idx = heap_next;
heap_next = heap[idx];
heap[idx] = obj;
return idx;
}
function getObject(idx) {
return heap[idx];
}
function dropObject(idx) {
if (idx < 132) return;
heap[idx] = heap_next;
heap_next = idx;
}
function takeObject(idx) {
const ret = getObject(idx);
dropObject(idx);
return ret;
}
function _assertClass(instance, klass) {
if (!(instance instanceof klass)) {
throw new Error(`expected instance of ${klass.name}`);
}
return instance.ptr;
}
let WASM_VECTOR_LEN = 0;
const cachedTextEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : {
encode: () => {
throw Error('TextEncoder not available');
}
};
const encodeString = typeof cachedTextEncoder.encodeInto === 'function' ? function (arg, view) {
return cachedTextEncoder.encodeInto(arg, view);
} : function (arg, view) {
const buf = cachedTextEncoder.encode(arg);
view.set(buf);
return {
read: arg.length,
written: buf.length
};
};
function passStringToWasm0(arg, malloc, realloc) {
if (realloc === undefined) {
const buf = cachedTextEncoder.encode(arg);
const ptr = malloc(buf.length, 1) >>> 0;
getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
WASM_VECTOR_LEN = buf.length;
return ptr;
}
let len = arg.length;
let ptr = malloc(len, 1) >>> 0;
const mem = getUint8ArrayMemory0();
let offset = 0;
for (; offset < len; offset++) {
const code = arg.charCodeAt(offset);
if (code > 0x7F) break;
mem[ptr + offset] = code;
}
if (offset !== len) {
if (offset !== 0) {
arg = arg.slice(offset);
}
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
const ret = encodeString(arg, view);
offset += ret.written;
ptr = realloc(ptr, len, offset, 1) >>> 0;
}
WASM_VECTOR_LEN = offset;
return ptr;
}
let cachedDataViewMemory0 = null;
function getDataViewMemory0() {
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
}
return cachedDataViewMemory0;
}
function passArrayJsValueToWasm0(array, malloc) {
const ptr = malloc(array.length * 4, 4) >>> 0;
const mem = getDataViewMemory0();
for (let i = 0; i < array.length; i++) {
mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
}
WASM_VECTOR_LEN = array.length;
return ptr;
}
function getArrayJsValueFromWasm0(ptr, len) {
ptr = ptr >>> 0;
const mem = getDataViewMemory0();
const result = [];
for (let i = ptr; i < ptr + 4 * len; i += 4) {
result.push(takeObject(mem.getUint32(i, true)));
}
return result;
}
const BaseFlatMeshFinalization = typeof FinalizationRegistry === 'undefined' ? {
register: () => {},
unregister: () => {}
} : new FinalizationRegistry(ptr => wasm.__wbg_baseflatmesh_free(ptr >>> 0, 1));
/**
*/
class BaseFlatMesh {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
BaseFlatMeshFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_baseflatmesh_free(ptr, 0);
}
/**
* @returns {boolean}
*/
get extruded() {
const ret = wasm.__wbg_get_baseflatmesh_extruded(this.__wbg_ptr);
return ret !== 0;
}
/**
* @param {boolean} arg0
*/
set extruded(arg0) {
wasm.__wbg_set_baseflatmesh_extruded(this.__wbg_ptr, arg0);
}
/**
* @returns {boolean}
*/
get is_mesh() {
const ret = wasm.__wbg_get_baseflatmesh_is_mesh(this.__wbg_ptr);
return ret !== 0;
}
/**
* @param {boolean} arg0
*/
set is_mesh(arg0) {
wasm.__wbg_set_baseflatmesh_is_mesh(this.__wbg_ptr, arg0);
}
/**
* @returns {Vector3D}
*/
get position() {
const ret = wasm.__wbg_get_baseflatmesh_position(this.__wbg_ptr);
return Vector3D.__wrap(ret);
}
/**
* @param {Vector3D} arg0
*/
set position(arg0) {
_assertClass(arg0, Vector3D);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_baseflatmesh_position(this.__wbg_ptr, ptr0);
}
/**
* @returns {Vector3D}
*/
get rotation() {
const ret = wasm.__wbg_get_baseflatmesh_rotation(this.__wbg_ptr);
return Vector3D.__wrap(ret);
}
/**
* @param {Vector3D} arg0
*/
set rotation(arg0) {
_assertClass(arg0, Vector3D);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_baseflatmesh_rotation(this.__wbg_ptr, ptr0);
}
/**
* @returns {Vector3D}
*/
get scale() {
const ret = wasm.__wbg_get_baseflatmesh_scale(this.__wbg_ptr);
return Vector3D.__wrap(ret);
}
/**
* @param {Vector3D} arg0
*/
set scale(arg0) {
_assertClass(arg0, Vector3D);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_baseflatmesh_scale(this.__wbg_ptr, ptr0);
}
/**
* @param {string} id
*/
set id(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.baseflatmesh_set_id(this.__wbg_ptr, ptr0, len0);
}
/**
* @returns {string}
*/
get id() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.baseflatmesh_id(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @param {string} id
*/
constructor(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.baseflatmesh_new(ptr0, len0);
this.__wbg_ptr = ret >>> 0;
BaseFlatMeshFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* @param {(Vector3D)[]} vertices
*/
add_vertices(vertices) {
const ptr0 = passArrayJsValueToWasm0(vertices, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.baseflatmesh_add_vertices(this.__wbg_ptr, ptr0, len0);
}
/**
* @param {Vector3D} vertex
*/
add_vertex(vertex) {
_assertClass(vertex, Vector3D);
var ptr0 = vertex.__destroy_into_raw();
wasm.baseflatmesh_add_vertex(this.__wbg_ptr, ptr0);
}
/**
* @returns {string}
*/
triangulate() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.baseflatmesh_triangulate(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
get_buffer_flush() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.baseflatmesh_get_buffer_flush(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
*/
reset_mesh() {
wasm.baseflatmesh_reset_mesh(this.__wbg_ptr);
}
}
typeof FinalizationRegistry === 'undefined' ? {
} : new FinalizationRegistry(ptr => wasm.__wbg_basemesh_free(ptr >>> 0, 1));
const BasePolygonFinalization = typeof FinalizationRegistry === 'undefined' ? {
register: () => {},
unregister: () => {}
} : new FinalizationRegistry(ptr => wasm.__wbg_basepolygon_free(ptr >>> 0, 1));
/**
*/
class BasePolygon {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(BasePolygon.prototype);
obj.__wbg_ptr = ptr;
BasePolygonFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
BasePolygonFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_basepolygon_free(ptr, 0);
}
/**
* @returns {boolean}
*/
get extruded() {
const ret = wasm.__wbg_get_basepolygon_extruded(this.__wbg_ptr);
return ret !== 0;
}
/**
* @param {boolean} arg0
*/
set extruded(arg0) {
wasm.__wbg_set_basepolygon_extruded(this.__wbg_ptr, arg0);
}
/**
* @returns {number}
*/
get extruded_height() {
const ret = wasm.__wbg_get_basepolygon_extruded_height(this.__wbg_ptr);
return ret;
}
/**
* @param {number} arg0
*/
set extruded_height(arg0) {
wasm.__wbg_set_basepolygon_extruded_height(this.__wbg_ptr, arg0);
}
/**
* @returns {boolean}
*/
get is_polygon() {
const ret = wasm.__wbg_get_basepolygon_is_polygon(this.__wbg_ptr);
return ret !== 0;
}
/**
* @param {boolean} arg0
*/
set is_polygon(arg0) {
wasm.__wbg_set_basepolygon_is_polygon(this.__wbg_ptr, arg0);
}
/**
* @returns {Vector3D}
*/
get position() {
const ret = wasm.__wbg_get_basepolygon_position(this.__wbg_ptr);
return Vector3D.__wrap(ret);
}
/**
* @param {Vector3D} arg0
*/
set position(arg0) {
_assertClass(arg0, Vector3D);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_basepolygon_position(this.__wbg_ptr, ptr0);
}
/**
* @returns {Vector3D}
*/
get rotation() {
const ret = wasm.__wbg_get_basepolygon_rotation(this.__wbg_ptr);
return Vector3D.__wrap(ret);
}
/**
* @param {Vector3D} arg0
*/
set rotation(arg0) {
_assertClass(arg0, Vector3D);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_basepolygon_rotation(this.__wbg_ptr, ptr0);
}
/**
* @returns {Vector3D}
*/
get scale() {
const ret = wasm.__wbg_get_basepolygon_scale(this.__wbg_ptr);
return Vector3D.__wrap(ret);
}
/**
* @param {Vector3D} arg0
*/
set scale(arg0) {
_assertClass(arg0, Vector3D);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_basepolygon_scale(this.__wbg_ptr, ptr0);
}
/**
* @param {string} id
*/
set id(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.basepolygon_set_id(this.__wbg_ptr, ptr0, len0);
}
/**
* @returns {string}
*/
get id() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.basepolygon_id(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @param {string} id
*/
constructor(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.basepolygon_new(ptr0, len0);
this.__wbg_ptr = ret >>> 0;
BasePolygonFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* @param {CircleArc} circle_arc
* @returns {BasePolygon}
*/
static new_with_circle(circle_arc) {
_assertClass(circle_arc, CircleArc);
var ptr0 = circle_arc.__destroy_into_raw();
const ret = wasm.basepolygon_new_with_circle(ptr0);
return BasePolygon.__wrap(ret);
}
/**
* @param {OGRectangle} rectangle
* @returns {BasePolygon}
*/
static new_with_rectangle(rectangle) {
_assertClass(rectangle, OGRectangle);
var ptr0 = rectangle.__destroy_into_raw();
const ret = wasm.basepolygon_new_with_rectangle(ptr0);
return BasePolygon.__wrap(ret);
}
/**
* @param {(Vector3D)[]} vertices
*/
add_vertices(vertices) {
const ptr0 = passArrayJsValueToWasm0(vertices, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.basepolygon_add_vertices(this.__wbg_ptr, ptr0, len0);
}
/**
* @param {Vector3D} vertex
*/
add_vertex(vertex) {
_assertClass(vertex, Vector3D);
var ptr0 = vertex.__destroy_into_raw();
wasm.basepolygon_add_vertex(this.__wbg_ptr, ptr0);
}
/**
* @param {(Vector3D)[]} holes
*/
add_holes(holes) {
const ptr0 = passArrayJsValueToWasm0(holes, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.basepolygon_add_holes(this.__wbg_ptr, ptr0, len0);
}
/**
* @returns {string}
*/
triangulate() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.basepolygon_triangulate(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
new_triangulate() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.basepolygon_new_triangulate(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
get_buffer_flush() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.basepolygon_get_buffer_flush(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
*/
clear_vertices() {
wasm.basepolygon_clear_vertices(this.__wbg_ptr);
}
/**
*/
reset_polygon() {
wasm.basepolygon_reset_polygon(this.__wbg_ptr);
}
/**
* @param {number} height
* @returns {string}
*/
extrude_by_height(height) {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.basepolygon_extrude_by_height(retptr, this.__wbg_ptr, height);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
get_outlines() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.basepolygon_get_outlines(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
get_geometry() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.basepolygon_get_geometry(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
const CircleArcFinalization = typeof FinalizationRegistry === 'undefined' ? {
register: () => {},
unregister: () => {}
} : new FinalizationRegistry(ptr => wasm.__wbg_circlearc_free(ptr >>> 0, 1));
/**
*/
class CircleArc {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(CircleArc.prototype);
obj.__wbg_ptr = ptr;
CircleArcFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
CircleArcFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_circlearc_free(ptr, 0);
}
/**
* @param {string} id
*/
set id(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.circlearc_set_id(this.__wbg_ptr, ptr0, len0);
}
/**
* @returns {string}
*/
get id() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.circlearc_id(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @param {string} id
*/
constructor(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.circlearc_new(ptr0, len0);
this.__wbg_ptr = ret >>> 0;
CircleArcFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* @returns {CircleArc}
*/
clone() {
const ret = wasm.circlearc_clone(this.__wbg_ptr);
return CircleArc.__wrap(ret);
}
/**
* @param {Vector3D} center
* @param {number} radius
* @param {number} start_angle
* @param {number} end_angle
* @param {number} segments
*/
set_config(center, radius, start_angle, end_angle, segments) {
_assertClass(center, Vector3D);
var ptr0 = center.__destroy_into_raw();
wasm.circlearc_set_config(this.__wbg_ptr, ptr0, radius, start_angle, end_angle, segments);
}
/**
*/
generate_points() {
wasm.circlearc_generate_points(this.__wbg_ptr);
}
/**
* @param {number} radius
*/
update_radius(radius) {
wasm.circlearc_update_radius(this.__wbg_ptr, radius);
}
/**
* @param {Vector3D} center
*/
update_center(center) {
_assertClass(center, Vector3D);
var ptr0 = center.__destroy_into_raw();
wasm.circlearc_update_center(this.__wbg_ptr, ptr0);
}
/**
*/
dispose_points() {
wasm.circlearc_destroy(this.__wbg_ptr);
}
/**
*/
destroy() {
wasm.circlearc_destroy(this.__wbg_ptr);
}
/**
* @returns {string}
*/
get_points() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.circlearc_get_points(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {(Vector3D)[]}
*/
get_raw_points() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.circlearc_get_raw_points(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 4, 4);
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
}
typeof FinalizationRegistry === 'undefined' ? {
} : new FinalizationRegistry(ptr => wasm.__wbg_color_free(ptr >>> 0, 1));
typeof FinalizationRegistry === 'undefined' ? {
} : new FinalizationRegistry(ptr => wasm.__wbg_colorrgb_free(ptr >>> 0, 1));
typeof FinalizationRegistry === 'undefined' ? {
} : new FinalizationRegistry(ptr => wasm.__wbg_matrix3d_free(ptr >>> 0, 1));
const OGCylinderFinalization = typeof FinalizationRegistry === 'undefined' ? {
register: () => {},
unregister: () => {}
} : new FinalizationRegistry(ptr => wasm.__wbg_ogcylinder_free(ptr >>> 0, 1));
/**
*/
class OGCylinder {
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
OGCylinderFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_ogcylinder_free(ptr, 0);
}
/**
* @param {string} id
*/
set id(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.ogcylinder_set_id(this.__wbg_ptr, ptr0, len0);
}
/**
* @returns {string}
*/
get id() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogcylinder_id(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @param {string} id
*/
constructor(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.ogcylinder_new(ptr0, len0);
this.__wbg_ptr = ret >>> 0;
OGCylinderFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* @param {Vector3D} center
* @param {number} radius
* @param {number} height
* @param {number} angle
* @param {number} segments
*/
set_config(center, radius, height, angle, segments) {
_assertClass(center, Vector3D);
var ptr0 = center.__destroy_into_raw();
wasm.ogcylinder_set_config(this.__wbg_ptr, ptr0, radius, height, angle, segments);
}
/**
*/
generate_geometry() {
wasm.ogcylinder_generate_geometry(this.__wbg_ptr);
}
/**
* @returns {string}
*/
get_geometry() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogcylinder_get_geometry(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
*/
discard_geometry() {
wasm.ogcylinder_discard_geometry(this.__wbg_ptr);
}
/**
* @returns {string}
*/
outline_edges() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogcylinder_outline_edges(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
get_brep_dump() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogcylinder_get_brep_dump(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
const OGPolyLineFinalization = typeof FinalizationRegistry === 'undefined' ? {
register: () => {},
unregister: () => {}
} : new FinalizationRegistry(ptr => wasm.__wbg_ogpolyline_free(ptr >>> 0, 1));
/**
*/
class OGPolyLine {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(OGPolyLine.prototype);
obj.__wbg_ptr = ptr;
OGPolyLineFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
OGPolyLineFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_ogpolyline_free(ptr, 0);
}
/**
* @param {string} id
*/
set id(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.ogpolyline_set_id(this.__wbg_ptr, ptr0, len0);
}
/**
* @returns {string}
*/
get id() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolyline_id(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @param {string} id
*/
constructor(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.ogpolyline_new(ptr0, len0);
this.__wbg_ptr = ret >>> 0;
OGPolyLineFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* @returns {OGPolyLine}
*/
clone() {
const ret = wasm.ogpolyline_clone(this.__wbg_ptr);
return OGPolyLine.__wrap(ret);
}
/**
* @param {Vector3D} translation
*/
translate(translation) {
_assertClass(translation, Vector3D);
var ptr0 = translation.__destroy_into_raw();
wasm.ogpolyline_translate(this.__wbg_ptr, ptr0);
}
/**
* @param {Vector3D} position
*/
set_position(position) {
_assertClass(position, Vector3D);
var ptr0 = position.__destroy_into_raw();
wasm.ogpolyline_set_position(this.__wbg_ptr, ptr0);
}
/**
* @param {(Vector3D)[]} points
*/
add_multiple_points(points) {
const ptr0 = passArrayJsValueToWasm0(points, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.ogpolyline_add_multiple_points(this.__wbg_ptr, ptr0, len0);
}
/**
* @param {Vector3D} point
*/
add_point(point) {
_assertClass(point, Vector3D);
var ptr0 = point.__destroy_into_raw();
wasm.ogpolyline_add_point(this.__wbg_ptr, ptr0);
}
/**
* @returns {string}
*/
get_points() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolyline_get_points(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {(Vector3D)[]}
*/
get_raw_points() {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolyline_get_raw_points(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 4, 4);
return v1;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
}
}
/**
* @returns {boolean}
*/
is_closed() {
const ret = wasm.ogpolyline_is_closed(this.__wbg_ptr);
return ret !== 0;
}
/**
*/
check_closed_test() {
wasm.ogpolyline_check_closed_test(this.__wbg_ptr);
}
/**
*/
generate_brep() {
wasm.ogpolyline_generate_brep(this.__wbg_ptr);
}
/**
* @returns {string}
*/
get_brep_data() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolyline_get_brep_data(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @param {number} distance
* @returns {string}
*/
get_offset(distance) {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolyline_get_offset(retptr, this.__wbg_ptr, distance);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @param {Vector3D} point_a
* @param {Vector3D} point_b
* @param {Vector3D} point_c
* @param {Vector3D} point_d
* @returns {Vector3D | undefined}
*/
static calculate_2D_interesection(point_a, point_b, point_c, point_d) {
_assertClass(point_a, Vector3D);
_assertClass(point_b, Vector3D);
_assertClass(point_c, Vector3D);
_assertClass(point_d, Vector3D);
const ret = wasm.ogpolyline_calculate_2D_interesection(point_a.__wbg_ptr, point_b.__wbg_ptr, point_c.__wbg_ptr, point_d.__wbg_ptr);
return ret === 0 ? undefined : Vector3D.__wrap(ret);
}
}
const OGPolygonFinalization = typeof FinalizationRegistry === 'undefined' ? {
register: () => {},
unregister: () => {}
} : new FinalizationRegistry(ptr => wasm.__wbg_ogpolygon_free(ptr >>> 0, 1));
/**
*/
class OGPolygon {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(OGPolygon.prototype);
obj.__wbg_ptr = ptr;
OGPolygonFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
OGPolygonFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_ogpolygon_free(ptr, 0);
}
/**
* @returns {boolean}
*/
get extruded() {
const ret = wasm.__wbg_get_ogpolygon_extruded(this.__wbg_ptr);
return ret !== 0;
}
/**
* @param {boolean} arg0
*/
set extruded(arg0) {
wasm.__wbg_set_ogpolygon_extruded(this.__wbg_ptr, arg0);
}
/**
* @returns {number}
*/
get extruded_height() {
const ret = wasm.__wbg_get_ogpolygon_extruded_height(this.__wbg_ptr);
return ret;
}
/**
* @param {number} arg0
*/
set extruded_height(arg0) {
wasm.__wbg_set_ogpolygon_extruded_height(this.__wbg_ptr, arg0);
}
/**
* @returns {boolean}
*/
get is_polygon() {
const ret = wasm.__wbg_get_ogpolygon_is_polygon(this.__wbg_ptr);
return ret !== 0;
}
/**
* @param {boolean} arg0
*/
set is_polygon(arg0) {
wasm.__wbg_set_ogpolygon_is_polygon(this.__wbg_ptr, arg0);
}
/**
* @returns {Vector3D}
*/
get position() {
const ret = wasm.__wbg_get_ogpolygon_position(this.__wbg_ptr);
return Vector3D.__wrap(ret);
}
/**
* @param {Vector3D} arg0
*/
set position(arg0) {
_assertClass(arg0, Vector3D);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_ogpolygon_position(this.__wbg_ptr, ptr0);
}
/**
* @returns {Vector3D}
*/
get rotation() {
const ret = wasm.__wbg_get_ogpolygon_rotation(this.__wbg_ptr);
return Vector3D.__wrap(ret);
}
/**
* @param {Vector3D} arg0
*/
set rotation(arg0) {
_assertClass(arg0, Vector3D);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_ogpolygon_rotation(this.__wbg_ptr, ptr0);
}
/**
* @returns {Vector3D}
*/
get scale() {
const ret = wasm.__wbg_get_ogpolygon_scale(this.__wbg_ptr);
return Vector3D.__wrap(ret);
}
/**
* @param {Vector3D} arg0
*/
set scale(arg0) {
_assertClass(arg0, Vector3D);
var ptr0 = arg0.__destroy_into_raw();
wasm.__wbg_set_ogpolygon_scale(this.__wbg_ptr, ptr0);
}
/**
* @param {string} id
*/
set id(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.ogpolygon_set_id(this.__wbg_ptr, ptr0, len0);
}
/**
* @returns {string}
*/
get id() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_id(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @param {string} id
*/
constructor(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.ogpolygon_new(ptr0, len0);
this.__wbg_ptr = ret >>> 0;
OGPolygonFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* @param {Vector3D} translation
*/
translate(translation) {
_assertClass(translation, Vector3D);
var ptr0 = translation.__destroy_into_raw();
wasm.ogpolygon_translate(this.__wbg_ptr, ptr0);
}
/**
* @param {CircleArc} circle_arc
* @returns {OGPolygon}
*/
static new_with_circle(circle_arc) {
_assertClass(circle_arc, CircleArc);
var ptr0 = circle_arc.__destroy_into_raw();
const ret = wasm.ogpolygon_new_with_circle(ptr0);
return OGPolygon.__wrap(ret);
}
/**
* @param {OGRectangle} rectangle
* @returns {OGPolygon}
*/
static new_with_rectangle(rectangle) {
_assertClass(rectangle, OGRectangle);
var ptr0 = rectangle.__destroy_into_raw();
const ret = wasm.ogpolygon_new_with_rectangle(ptr0);
return OGPolygon.__wrap(ret);
}
/**
* @param {(Vector3D)[]} vertices
*/
add_vertices(vertices) {
const ptr0 = passArrayJsValueToWasm0(vertices, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.ogpolygon_add_vertices(this.__wbg_ptr, ptr0, len0);
}
/**
* @param {Vector3D} vertex
*/
add_vertex(vertex) {
_assertClass(vertex, Vector3D);
var ptr0 = vertex.__destroy_into_raw();
wasm.ogpolygon_add_vertex(this.__wbg_ptr, ptr0);
}
/**
* @param {(Vector3D)[]} holes
*/
add_holes(holes) {
const ptr0 = passArrayJsValueToWasm0(holes, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.ogpolygon_add_holes(this.__wbg_ptr, ptr0, len0);
}
/**
* @returns {string}
*/
triangulate() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_triangulate(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @param {boolean} is_ccw
* @returns {string}
*/
triangulate_with_holes_variable_geometry(is_ccw) {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_triangulate_with_holes_variable_geometry(retptr, this.__wbg_ptr, is_ccw);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
triangulate_with_holes() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_triangulate_with_holes(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
get_buffer_flush() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_get_buffer_flush(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
*/
clear_buffer() {
wasm.ogpolygon_clear_buffer(this.__wbg_ptr);
}
/**
*/
clear_vertices() {
wasm.ogpolygon_clear_vertices(this.__wbg_ptr);
}
/**
*/
reset_polygon() {
wasm.ogpolygon_reset_polygon(this.__wbg_ptr);
}
/**
* @param {number} height
* @returns {string}
*/
extrude_by_height_with_holes(height) {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_extrude_by_height_with_holes(retptr, this.__wbg_ptr, height);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @param {number} height
* @returns {string}
*/
extrude_by_height(height) {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_extrude_by_height(retptr, this.__wbg_ptr, height);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
get_outlines() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_get_outlines(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
get_geometry() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_get_geometry(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
get_brep_data() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_get_brep_data(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
outline_edges() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_outline_edges(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @returns {string}
*/
binary_tree() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogpolygon_binary_tree(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
}
const OGRectangleFinalization = typeof FinalizationRegistry === 'undefined' ? {
register: () => {},
unregister: () => {}
} : new FinalizationRegistry(ptr => wasm.__wbg_ogrectangle_free(ptr >>> 0, 1));
/**
*/
class OGRectangle {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(OGRectangle.prototype);
obj.__wbg_ptr = ptr;
OGRectangleFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
OGRectangleFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_ogrectangle_free(ptr, 0);
}
/**
* @param {string} id
*/
set id(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
wasm.ogrectangle_set_id(this.__wbg_ptr, ptr0, len0);
}
/**
* @returns {string}
*/
get id() {
let deferred1_0;
let deferred1_1;
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
wasm.ogrectangle_id(retptr, this.__wbg_ptr);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
deferred1_0 = r0;
deferred1_1 = r1;
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
}
}
/**
* @param {string} id
*/
constructor(id) {
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.ogrectangle_new(ptr0, len0);
this.__wbg_ptr = ret >>> 0;
OGRectangleFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* @returns {OGRectangle}
*/
clone() {
const ret = wasm.ogrectangle_clone(this.__wbg_ptr);
return OGRectangle.__wrap(ret);
}
/**
* @param {Vector3D} center
* @param {number} width
* @param {number} breadth
*/
set_config(center, width, breadth) {
_assertClass(center, Vector3D);
var ptr0 = center.__destroy_into_raw();
wasm.ogrectangle_set_config(this.__wbg_ptr, ptr0, width, breadth);
}
/**
*/
generate_points() {
wasm.ogrectangle_generate_points(this.__wbg_ptr);
}
/**
* @param {number} width
*/
update_width(width) {
wasm.ogrectangle_update_width(this.__wbg_ptr, width);
}
/**
* @param {number} breadth
*/
update_breadth(breadth) {
wasm.ogrectangle_update_breadth(this.__wbg_ptr, breadth);
}
/**
* @param {Vector3D} center
*/
update_center(center) {
_assertClass(center, Vector3D);
var ptr0 = center.__destroy_into_raw();
wasm.ogrectangle_update_center(this.__wbg_ptr, ptr0);
}
/**
*/
dispose_points() {
wasm.ogrectangle_destroy(this.__wbg_ptr);
}
/**
*/
destroy() {
wasm.ogrectangle_destroy(this.__wbg_ptr);
}
/**
* @returns {string}
*/
get_points() {
let deferred1_0;
let def