opengeometry 0.0.2 → 0.0.4

package/index.js

@@ -76,6 +76,19 @@ function addHeapObject(obj) {
   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}`);
@@ -144,19 +157,6 @@ function passArrayJsValueToWasm0(array, malloc) {
   WASM_VECTOR_LEN = array.length;
   return ptr;
 }
-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 getArrayJsValueFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   const mem = getDataViewMemory0();
@@ -783,12 +783,615 @@ class CircleArc {
   /**
   * @returns {string}
   */
-  get_points() {
+  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.circlearc_get_points(retptr, this.__wbg_ptr);
+      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;
@@ -800,69 +1403,33 @@ class CircleArc {
     }
   }
   /**
-  * @returns {(Vector3D)[]}
+  * @returns {string}
   */
-  get_raw_points() {
+  triangulate_with_holes() {
+    let deferred1_0;
+    let deferred1_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.circlearc_get_raw_points(retptr, this.__wbg_ptr);
+      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);
-      var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 4, 4);
-      return v1;
+      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);
     }
   }
-}
-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 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() {
+  get_buffer_flush() {
     let deferred1_0;
     let deferred1_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolyline_id(retptr, this.__wbg_ptr);
+      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;
@@ -874,58 +1441,88 @@ class OGPolyLine {
     }
   }
   /**
-  * @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;
+  clear_buffer() {
+    wasm.ogpolygon_clear_buffer(this.__wbg_ptr);
   }
   /**
-  * @returns {OGPolyLine}
   */
-  clone() {
-    const ret = wasm.ogpolyline_clone(this.__wbg_ptr);
-    return OGPolyLine.__wrap(ret);
+  clear_vertices() {
+    wasm.ogpolygon_clear_vertices(this.__wbg_ptr);
   }
   /**
-  * @param {(Vector3D)[]} points
   */
-  set_config(points) {
-    const ptr0 = passArrayJsValueToWasm0(points, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.ogpolyline_set_config(this.__wbg_ptr, ptr0, len0);
+  reset_polygon() {
+    wasm.ogpolygon_reset_polygon(this.__wbg_ptr);
   }
   /**
-  * @param {Vector3D} point
+  * @param {number} height
+  * @returns {string}
   */
-  add_point(point) {
-    _assertClass(point, Vector3D);
-    var ptr0 = point.__destroy_into_raw();
-    wasm.ogpolyline_add_point(this.__wbg_ptr, ptr0);
+  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}
   */
-  dispose_points() {
-    wasm.ogpolyline_destroy(this.__wbg_ptr);
+  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}
   */
-  destroy() {
-    wasm.ogpolyline_destroy(this.__wbg_ptr);
+  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_points() {
+  get_geometry() {
     let deferred1_0;
     let deferred1_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolyline_get_points(retptr, this.__wbg_ptr);
+      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;
@@ -937,32 +1534,61 @@ class OGPolyLine {
     }
   }
   /**
-  * @returns {(Vector3D)[]}
+  * @returns {string}
   */
-  get_raw_points() {
+  get_brep_data() {
+    let deferred1_0;
+    let deferred1_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ogpolyline_get_raw_points(retptr, this.__wbg_ptr);
+      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);
-      var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 4, 4);
-      return v1;
+      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 {boolean}
+  * @returns {string}
   */
-  is_closed() {
-    const ret = wasm.ogpolyline_is_closed(this.__wbg_ptr);
-    return ret !== 0;
+  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}
   */
-  check_closed_test() {
-    wasm.ogpolyline_check_closed_test(this.__wbg_ptr);
+  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' ? {
@@ -1198,12 +1824,12 @@ class OGSimpleLine {
   /**
   */
   dispose_points() {
-    wasm.ogpolyline_destroy(this.__wbg_ptr);
+    wasm.ogsimpleline_destroy(this.__wbg_ptr);
   }
   /**
   */
   destroy() {
-    wasm.ogpolyline_destroy(this.__wbg_ptr);
+    wasm.ogsimpleline_destroy(this.__wbg_ptr);
   }
   /**
   * @returns {string}
@@ -1399,6 +2025,44 @@ class Vector3D {
     const ret = wasm.vector3d_clone(this.__wbg_ptr);
     return Vector3D.__wrap(ret);
   }
+  /**
+  * @returns {number}
+  */
+  length_squared() {
+    const ret = wasm.vector3d_length_squared(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+  * @returns {number}
+  */
+  magnitude() {
+    const ret = wasm.vector3d_magnitude(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+  * @returns {Vector3D}
+  */
+  normalize() {
+    const ret = wasm.vector3d_normalize(this.__wbg_ptr);
+    return Vector3D.__wrap(ret);
+  }
+  /**
+  * @param {number} scalar
+  * @returns {Vector3D}
+  */
+  multiply(scalar) {
+    const ret = wasm.vector3d_multiply(this.__wbg_ptr, scalar);
+    return Vector3D.__wrap(ret);
+  }
+  /**
+  * @param {Vector3D} other
+  * @returns {number}
+  */
+  distance_to(other) {
+    _assertClass(other, Vector3D);
+    const ret = wasm.vector3d_distance_to(this.__wbg_ptr, other.__wbg_ptr);
+    return ret;
+  }
 }
 async function __wbg_load(module, imports) {
   if (typeof Response === 'function' && module instanceof Response) {
@@ -1430,6 +2094,13 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
   const imports = {};
   imports.wbg = {};
+  imports.wbg.__wbindgen_string_new = function (arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_object_drop_ref = function (arg0) {
+    takeObject(arg0);
+  };
   imports.wbg.__wbg_vector3d_new = function (arg0) {
     const ret = Vector3D.__wrap(arg0);
     return addHeapObject(ret);
@@ -1438,9 +2109,8 @@ function __wbg_get_imports() {
     const ret = Vector3D.__unwrap(takeObject(arg0));
     return ret;
   };
-  imports.wbg.__wbindgen_string_new = function (arg0, arg1) {
-    const ret = getStringFromWasm0(arg0, arg1);
-    return addHeapObject(ret);
+  imports.wbg.__wbg_log_b103404cc5920657 = function (arg0) {
+    console.log(getObject(arg0));
   };
   imports.wbg.__wbindgen_throw = function (arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
@@ -12066,7 +12736,57 @@ function checkIntersection( object, raycaster, ray, thresholdSq, a, b ) {
 		faceIndex: null,
 		object: object
 
-	};
+	};
+
+}
+
+const _start = /*@__PURE__*/ new Vector3();
+const _end = /*@__PURE__*/ new Vector3();
+
+class LineSegments extends Line {
+
+	constructor( geometry, material ) {
+
+		super( geometry, material );
+
+		this.isLineSegments = true;
+
+		this.type = 'LineSegments';
+
+	}
+
+	computeLineDistances() {
+
+		const geometry = this.geometry;
+
+		// we assume non-indexed geometry
+
+		if ( geometry.index === null ) {
+
+			const positionAttribute = geometry.attributes.position;
+			const lineDistances = [];
+
+			for ( let i = 0, l = positionAttribute.count; i < l; i += 2 ) {
+
+				_start.fromBufferAttribute( positionAttribute, i );
+				_end.fromBufferAttribute( positionAttribute, i + 1 );
+
+				lineDistances[ i ] = ( i === 0 ) ? 0 : lineDistances[ i - 1 ];
+				lineDistances[ i + 1 ] = lineDistances[ i ] + _start.distanceTo( _end );
+
+			}
+
+			geometry.setAttribute( 'lineDistance', new Float32BufferAttribute( lineDistances, 1 ) );
+
+		} else {
+
+			console.warn( 'THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.' );
+
+		}
+
+		return this;
+
+	}
 
 }
 
@@ -12803,12 +13523,14 @@ class Pencil {
         // Raycaster
         this.raycaster.params.Line.threshold = 0.1;
         // A Dummy Ground Plane
-        const geometry = new PlaneGeometry(100, 100);
+        const geometry = new PlaneGeometry(1000, 1000);
+        // const material = new THREE.MeshBasicMaterial({ color: 0xffff00, side: THREE.DoubleSide, wireframe: true });
         const material = new MeshBasicMaterial({ color: 0xffff00, side: DoubleSide, transparent: true, opacity: 0 });
         const plane = new Mesh(geometry, material);
         plane.name = "pencil-ground";
         plane.rotation.x = Math.PI / 2;
         this.scene.add(plane);
+        // plane.visible = true;
         plane.visible = false;
         this.dummyPlane = plane;
     }
@@ -12881,6 +13603,17 @@ class Pencil {
             }
         });
     }
+    fireCursor(mouse) {
+        const rect = this.container.getBoundingClientRect();
+        const x = ((mouse.clientX - rect.left) / rect.width) * 2 - 1;
+        const y = -((mouse.clientY - rect.top) / rect.height) * 2 + 1;
+        this.raycaster.setFromCamera(new Vector2(x, y), this.camera);
+        const intersects = this.raycaster.intersectObjects([this.dummyPlane]);
+        if (intersects.length > 0) {
+            const point = intersects[0].point;
+            this.onCursorDown.trigger(point);
+        }
+    }
 }
 
 function spotLabelElement() {
@@ -12950,23 +13683,40 @@ class PolyLine extends Line {
             this.material.color.set(color);
         }
     }
-    constructor(points = []) {
+    constructor(points) {
         super();
         this.points = [];
         this.isClosed = false;
+        this.polyline = null;
         this.ogid = getUUID();
-        this.points = points;
         this.polyline = new OGPolyLine(this.ogid);
-        this.setConfig(points);
+        if (points) {
+            this.addMultiplePoints(points);
+        }
+    }
+    addMultiplePoints(points) {
+        this.points = points;
+        if (!this.polyline)
+            return;
+        this.polyline.add_multiple_points(points);
         this.generateGeometry();
     }
-    setConfig(points) {
-        if (this.points.length < 2)
+    // TODO: This needs to be improved 
+    translate(translation) {
+        if (!this.polyline)
+            return;
+        this.polyline.translate(translation);
+        this.generateGeometry();
+    }
+    set_position(position) {
+        if (!this.polyline)
             return;
-        this.polyline.set_config(points);
+        this.polyline.set_position(position);
     }
     addPoint(point) {
         this.points.push(point);
+        if (!this.polyline)
+            return;
         this.polyline.add_point(point);
         if (this.points.length < 2)
             return;
@@ -12977,6 +13727,8 @@ class PolyLine extends Line {
     }
     generateGeometry() {
         this.clearGeometry();
+        if (!this.polyline)
+            return;
         const buf = this.polyline.get_points();
         const bufFlush = JSON.parse(buf);
         const line = new BufferGeometry().setFromPoints(bufFlush);
@@ -12985,8 +13737,32 @@ class PolyLine extends Line {
         this.material = material;
         this.isClosed = this.polyline.is_closed();
     }
+    getBrepData() {
+        if (!this.polyline)
+            return null;
+        return this.polyline.get_brep_data();
+    }
+    // TODO: Add proper return type
+    createOffset(offset) {
+        if (!this.polyline)
+            return null;
+        const offsetData = this.polyline.get_offset(offset);
+        if (!offsetData)
+            return null;
+        const data = JSON.parse(offsetData);
+        if (!data.treated || data.treated.length === 0) {
+            return null;
+        }
+        return data;
+    }
+    dispose() {
+        console.log("Disposing OG - Polyline");
+        this.clearGeometry();
+        this.polyline = null;
+    }
 }
 
+// TODO: What if user wants infintely smooth circle
 class BaseCircle extends Line {
     set color(color) {
         if (this.material instanceof LineBasicMaterial) {
@@ -13029,11 +13805,13 @@ class BaseCircle extends Line {
     }
 }
 
-var _Rectangle_color;
+class BasePrimitive extends Line {
+}
+
 /**
  * Rectangle
  */
-class Rectangle extends Line {
+class Rectangle extends BasePrimitive {
     set width(width) {
         this.options.width = width;
         this.polyLineRectangle.update_width(width);
@@ -13044,33 +13822,47 @@ class Rectangle extends Line {
         this.polyLineRectangle.update_breadth(breadth);
         this.generateGeometry();
     }
+    set center(center) {
+        this.options.center = center;
+        this.polyLineRectangle.update_center(center);
+        this.generateGeometry();
+    }
     set color(color) {
         if (this.material instanceof LineBasicMaterial) {
             this.material.color.set(color);
-            __classPrivateFieldSet(this, _Rectangle_color, color, "f");
+            this.options.color = color;
         }
     }
     constructor(options) {
+        var _a;
         super();
-        // nodeChild: RectanglePoly | null = null;
-        this.nodeOperation = "none";
-        _Rectangle_color.set(this, 0x000000);
-        this.ogid = getUUID();
-        this.options = options;
-        this.polyLineRectangle = new OGRectangle(this.ogid);
-        this.setConfig();
+        this.options = {
+            width: 1,
+            breadth: 1,
+            center: new Vector3D(0, 0, 0),
+            color: 0x000000,
+        };
+        const ogid = (_a = options === null || options === void 0 ? void 0 : options.ogid) !== null && _a !== void 0 ? _a : getUUID();
+        this.polyLineRectangle = new OGRectangle(ogid);
+        const mergedOptions = Object.assign(Object.assign(Object.assign({}, this.options), options), { ogid });
+        this.setConfig(mergedOptions);
         this.generateGeometry();
     }
-    setConfig() {
+    setConfig(options) {
+        this.options = options;
+        console.log("Rectangle options set:", this.options);
         const { breadth, width, center } = this.options;
         this.polyLineRectangle.set_config(center, width, breadth);
     }
+    getConfig() {
+        return this.options;
+    }
     generateGeometry() {
         this.polyLineRectangle.generate_points();
         const bufRaw = this.polyLineRectangle.get_points();
         const bufFlush = JSON.parse(bufRaw);
         const line = new BufferGeometry().setFromPoints(bufFlush);
-        const material = new LineBasicMaterial({ color: __classPrivateFieldGet(this, _Rectangle_color, "f") });
+        const material = new LineBasicMaterial({ color: this.options.color });
         this.geometry = line;
         this.material = material;
     }
@@ -13078,22 +13870,359 @@ class Rectangle extends Line {
         this.geometry.dispose();
     }
 }
-_Rectangle_color = new WeakMap();
+
+var _Cylinder_outlineMesh;
+class Cylinder extends Mesh {
+    constructor(options) {
+        super();
+        _Cylinder_outlineMesh.set(this, null);
+        // Store local center offset to align outlines
+        // TODO: Can this be moved to Engine? It can increase performance | Needs to be used in other shapes too
+        this._geometryCenterOffset = new Vector3();
+        this.ogid = getUUID();
+        this.options = options;
+        this.cylinder = new OGCylinder(this.ogid);
+        this.setConfig();
+        this.generateGeometry();
+    }
+    validateOptions() {
+        if (!this.options) {
+            throw new Error("Options are not defined for Cylinder");
+        }
+    }
+    setConfig() {
+        this.validateOptions();
+        const { radius, height, segments, angle, center } = this.options;
+        this.cylinder.set_config((center === null || center === void 0 ? void 0 : center.clone()) || new Vector3D(0, 0, 0), radius, height, angle, segments);
+    }
+    generateGeometry() {
+        var _a, _b, _c;
+        this.cylinder.generate_geometry();
+        const geometryData = this.cylinder.get_geometry();
+        const bufferData = JSON.parse(geometryData);
+        console.log(bufferData);
+        const geometry = new BufferGeometry();
+        geometry.setAttribute("position", new Float32BufferAttribute(bufferData, 3));
+        const material = new MeshStandardMaterial({
+            color: 0x00ff00,
+            transparent: true,
+            opacity: 0.6,
+        });
+        geometry.computeVertexNormals();
+        geometry.computeBoundingBox();
+        const boundingBox = geometry.boundingBox;
+        if (boundingBox) {
+            boundingBox.getCenter(this._geometryCenterOffset);
+            geometry.translate(-this._geometryCenterOffset.x, -this._geometryCenterOffset.y, -this._geometryCenterOffset.z);
+        }
+        this.geometry = geometry;
+        this.material = material;
+        this.position.set(((_a = this.options.center) === null || _a === void 0 ? void 0 : _a.x) || 0, ((_b = this.options.center) === null || _b === void 0 ? void 0 : _b.y) || 0, ((_c = this.options.center) === null || _c === void 0 ? void 0 : _c.z) || 0);
+    }
+    set outline(enable) {
+        if (enable && !__classPrivateFieldGet(this, _Cylinder_outlineMesh, "f")) {
+            const outline_buff = this.cylinder.outline_edges();
+            const outline_buf = JSON.parse(outline_buff);
+            const outlineGeometry = new BufferGeometry();
+            outlineGeometry.setAttribute("position", new Float32BufferAttribute(outline_buf, 3));
+            outlineGeometry.translate(-this._geometryCenterOffset.x, -this._geometryCenterOffset.y, -this._geometryCenterOffset.z);
+            const outlineMaterial = new LineBasicMaterial({ color: 0x000000 });
+            __classPrivateFieldSet(this, _Cylinder_outlineMesh, new LineSegments(outlineGeometry, outlineMaterial), "f");
+            this.add(__classPrivateFieldGet(this, _Cylinder_outlineMesh, "f"));
+        }
+        if (!enable && __classPrivateFieldGet(this, _Cylinder_outlineMesh, "f")) {
+            this.remove(__classPrivateFieldGet(this, _Cylinder_outlineMesh, "f"));
+            __classPrivateFieldGet(this, _Cylinder_outlineMesh, "f").geometry.dispose();
+            __classPrivateFieldSet(this, _Cylinder_outlineMesh, null, "f");
+        }
+    }
+    getBrepData() {
+        const brepData = this.cylinder.get_brep_dump();
+        const brepDataParsed = JSON.parse(brepData);
+        console.log(brepDataParsed);
+    }
+}
+_Cylinder_outlineMesh = new WeakMap();
+
+var _Polygon_outlineMesh;
+class Polygon extends Mesh {
+    constructor(vertices) {
+        var _a, _b;
+        super();
+        this.layerVertices = [];
+        this.layerBackVertices = [];
+        this.polygon = null;
+        this.isTriangulated = false;
+        _Polygon_outlineMesh.set(this, null);
+        this._geometryCenterOffset = new Vector3();
+        this.ogid = getUUID();
+        this.polygon = new OGPolygon(this.ogid);
+        if (vertices) {
+            this.polygon.add_vertices(vertices);
+            // Triangulate the polygon - WORKS
+            (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.triangulate();
+            const bufFlush = (_b = this.polygon) === null || _b === void 0 ? void 0 : _b.get_buffer_flush();
+            this.addFlushBufferToScene(bufFlush);
+            // Testing New Triangulation - FAILING
+            // const triResult = JSON.parse(this.polygon.new_triangulate());
+            // console.log(triResult);
+        }
+        // THIS MIGHT HELP WITH SHARING THE POSITION with KERNEL when something is changed
+        // const originalSet = this.position.set.bind(this.position);
+        // this.position.set = (x: number, y: number, z: number) => {
+        //   console.log(`Position set to (${x}, ${y}, ${z})`);
+        //   // your custom logic here (e.g., notify OpenGeometry)
+        //   return originalSet(x, y, z);
+        // };
+        // // Optional: Override copy if you're using .copy() too
+        // const originalCopy = this.position.copy.bind(this.position);
+        // this.position.copy = (v: THREE.Vector3) => {
+        //   console.log(`Position copied from ${v.x}, ${v.y}, ${v.z}`);
+        //   return originalCopy(v);
+        // };
+    }
+    translate(translation) {
+        if (!this.polygon)
+            return;
+        console.log("Translating polygon by", translation.x, translation.y, translation.z);
+        this.geometry.dispose();
+        this.polygon.clear_buffer();
+        this.polygon.translate(translation);
+        this.polygon.triangulate();
+        console.log("Polygon translated by", translation);
+        const bufFlush = this.polygon.get_buffer_flush();
+        console.log("Buffer flush after translation:", bufFlush);
+        this.addFlushBufferToScene(bufFlush);
+    }
+    addVertices(vertices) {
+        var _a, _b;
+        if (!this.polygon)
+            return;
+        this.polygon.add_vertices(vertices);
+        (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.triangulate();
+        const bufFlush = (_b = this.polygon) === null || _b === void 0 ? void 0 : _b.get_buffer_flush();
+        this.addFlushBufferToScene(bufFlush);
+    }
+    resetVertices() {
+        var _a;
+        if (!this.polygon)
+            return;
+        this.layerVertices = [];
+        this.geometry.dispose();
+        (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.clear_vertices();
+        this.isTriangulated = false;
+    }
+    addVertex(threeVertex) {
+        var _a, _b, _c;
+        if (this.isTriangulated) {
+            this.layerVertices = [];
+            this.geometry.dispose();
+            (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.clear_vertices();
+            this.isTriangulated = false;
+            for (const vertex of this.layerBackVertices) {
+                this.layerVertices.push(vertex.clone());
+            }
+        }
+        const backupVertex = new Vector3D(parseFloat(threeVertex.x.toFixed(2)), 0, parseFloat(threeVertex.z.toFixed(2)));
+        this.layerBackVertices.push(backupVertex);
+        const vertex = new Vector3D(parseFloat(threeVertex.x.toFixed(2)), 
+        // when doing the parse operation getting -0 instead of 0
+        0, parseFloat(threeVertex.z.toFixed(2)));
+        this.layerVertices.push(vertex);
+        if (this.layerVertices.length > 3) {
+            (_b = this.polygon) === null || _b === void 0 ? void 0 : _b.add_vertices(this.layerVertices);
+            const bufFlush = (_c = this.polygon) === null || _c === void 0 ? void 0 : _c.triangulate();
+            if (!bufFlush) {
+                return;
+            }
+            this.addFlushBufferToScene(bufFlush);
+            this.isTriangulated = true;
+        }
+    }
+    addHole(holeVertices) {
+        if (!this.polygon)
+            return;
+        this.polygon.add_holes(holeVertices);
+        const triResult = JSON.parse(this.polygon.triangulate_with_holes());
+        console.log(triResult);
+        const newBufferFlush = triResult.new_buffer;
+        const geometry = new BufferGeometry();
+        geometry.setAttribute("position", new BufferAttribute(new Float32Array(newBufferFlush), 3));
+        this.geometry = geometry;
+        // const bufFlush = this.polygon.get_buffer_flush();
+        // this.addFlushBufferToScene(bufFlush);
+    }
+    addFlushBufferToScene(flush) {
+        const flushBuffer = JSON.parse(flush);
+        const geometry = new BufferGeometry();
+        geometry.setAttribute("position", new BufferAttribute(new Float32Array(flushBuffer), 3));
+        geometry.computeVertexNormals();
+        const material = new MeshStandardMaterial({
+            color: 0x00ff00,
+            side: DoubleSide,
+            transparent: true,
+            opacity: 0.5,
+            // wireframe: true
+        });
+        this.geometry = geometry;
+        this.material = material;
+    }
+    extrude(height) {
+        if (!this.polygon)
+            return;
+        const extruded_buff = this.polygon.extrude_by_height(height);
+        console.log(extruded_buff);
+        this.generateExtrudedGeometry(extruded_buff);
+    }
+    generateExtrudedGeometry(extruded_buff) {
+        // THIS WORKS
+        const flushBuffer = JSON.parse(extruded_buff);
+        console.log(flushBuffer);
+        const geometry = new BufferGeometry();
+        geometry.setAttribute("position", new BufferAttribute(new Float32Array(flushBuffer), 3));
+        geometry.computeVertexNormals();
+        this.geometry = geometry;
+        const material = new MeshStandardMaterial({
+            color: 0x00ff00,
+            side: FrontSide,
+            transparent: true,
+            opacity: 0.5,
+            // wireframe: true
+        });
+        this.material = material;
+    }
+    getBrepData() {
+        if (!this.polygon)
+            return null;
+        const brepData = this.polygon.get_brep_data();
+        return brepData;
+    }
+    set outlineColor(color) {
+        if (__classPrivateFieldGet(this, _Polygon_outlineMesh, "f") && __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material instanceof LineBasicMaterial) {
+            __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material.color.set(color);
+        }
+    }
+    get outlineColor() {
+        if (__classPrivateFieldGet(this, _Polygon_outlineMesh, "f") && __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material instanceof LineBasicMaterial) {
+            return __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material.color.getHex();
+        }
+        return 0x000000; // Default color if outline mesh is not present
+    }
+    set outline(enable) {
+        if (enable && !__classPrivateFieldGet(this, _Polygon_outlineMesh, "f") && this.polygon) {
+            const outline_buff = this.polygon.outline_edges();
+            const outline_buf = JSON.parse(outline_buff);
+            const outlineGeometry = new BufferGeometry();
+            outlineGeometry.setAttribute("position", new Float32BufferAttribute(outline_buf, 3));
+            // TODO: Fix the outline position
+            // outlineGeometry.translate(
+            //   -this._geometryCenterOffset.x,
+            //   -this._geometryCenterOffset.y,
+            //   -this._geometryCenterOffset.z
+            // );
+            const outlineMaterial = new LineBasicMaterial({ color: 0x000000 });
+            __classPrivateFieldSet(this, _Polygon_outlineMesh, new LineSegments(outlineGeometry, outlineMaterial), "f");
+            this.add(__classPrivateFieldGet(this, _Polygon_outlineMesh, "f"));
+        }
+        if (!enable && __classPrivateFieldGet(this, _Polygon_outlineMesh, "f")) {
+            this.remove(__classPrivateFieldGet(this, _Polygon_outlineMesh, "f"));
+            __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").geometry.dispose();
+            __classPrivateFieldSet(this, _Polygon_outlineMesh, null, "f");
+        }
+    }
+    get outline() {
+        if (__classPrivateFieldGet(this, _Polygon_outlineMesh, "f")) {
+            return true;
+        }
+        return false;
+    }
+    bTree() {
+        if (!this.polygon)
+            return;
+        const bTree = this.polygon.binary_tree();
+        const parsedData = JSON.parse(bTree);
+        console.log(parsedData);
+    }
+    dispose() {
+        // console.log("Disposing OG - Polygon");
+        this.geometry.dispose();
+        if (this.material instanceof Material) {
+            this.material.dispose();
+        }
+        if (__classPrivateFieldGet(this, _Polygon_outlineMesh, "f")) {
+            __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").geometry.dispose();
+            if (__classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material instanceof Material) {
+                __classPrivateFieldGet(this, _Polygon_outlineMesh, "f").material.dispose();
+            }
+        }
+        this.polygon = null;
+        this.layerVertices = [];
+        this.layerBackVertices = [];
+    }
+}
+_Polygon_outlineMesh = new WeakMap();
 
 class OpenGeometry {
+    set enablePencil(value) {
+        if (value && !this._pencil) {
+            if (!this.container || !this.scene) {
+                throw new Error("Container or Scene is not defined");
+            }
+            this._pencil = new Pencil(this.container, this.scene, this.camera);
+        }
+        else if (!value && this._pencil) ;
+    }
+    get pencil() {
+        return this._pencil;
+    }
+    get labelRenderer() {
+        return this._labelRenderer;
+    }
+    get enableDebug() {
+        return this._enableDebug;
+    }
+    /**
+     * Enables or disables debug mode for OpenGeometry.
+     * When enabled, it logs debug information to the console.
+     * Addtionally,
+     * 1. The geometry will be rendered with a semi-transparent material.
+     * 2. The faces will be rendered with a random color.
+     * 3. The normals will be rendered for better visualization.
+     * @param value - A boolean indicating whether to enable or disable debug mode.
+     */
+    set enableDebug(value) {
+        this._enableDebug = value;
+        if (this._enableDebug) {
+            console.log("OpenGeometry Debug Mode Enabled");
+        }
+    }
     constructor(container, threeScene, camera) {
         this.camera = camera;
+        this._enableDebug = false;
         this.scene = threeScene;
         this.container = container;
     }
-    // Why Generic Types are used sometimes
-    // verifyOptions(options: OpenGeometryOptions) {
-    //   for (const key in options) {
-    //     if (options[key as keyof OpenGeometryOptions] === undefined) {
-    //       throw new Error(`Missing required option: ${key}`);
-    //     }
-    //   }
-    // }
+    /**
+     * Asynchronously creates and initializes an instance of OpenGeometry.
+     *
+     * This factory method sets up the OpenGeometry engine by linking it with the
+     * rendering context and the WebAssembly module. It ensures all required
+     * options are provided and prepares the instance for 3D geometry operations.
+     *
+     * @param options - Configuration object for initializing OpenGeometry.
+     * @returns A promise that resolves to a fully initialized OpenGeometry instance.
+     * @throws If any of the required options (`container`, `scene`, or `camera`) are missing.
+     *
+     * @example
+     * ```ts
+     * const openGeometry = await OpenGeometry.create({
+     *   container: document.getElementById('myContainer')!,
+     *   scene: threeScene,
+     *   camera: threeCamera,
+     *   wasmURL: '/assets/opengeometry.wasm'
+     * });
+     * ```
+     */
     static create(options) {
         return __awaiter(this, void 0, void 0, function* () {
             const { container, scene, camera } = options;
@@ -13109,18 +14238,9 @@ class OpenGeometry {
         return __awaiter(this, void 0, void 0, function* () {
             yield __wbg_init(wasmURL);
             this.setuplabelRenderer();
-            if (!this.container || !this.scene)
-                return;
-            this._pencil = new Pencil(this.container, this.scene, this.camera);
             this.setupEvent();
         });
     }
-    get pencil() {
-        return this._pencil;
-    }
-    get labelRenderer() {
-        return this._labelRenderer;
-    }
     setuplabelRenderer() {
         if (!this.container || !this.scene) {
             throw new Error("Container or Scene is not defined");
@@ -13133,6 +14253,8 @@ class OpenGeometry {
         this._labelRenderer = labelRenderer;
     }
     setupEvent() {
+        // NOTE: The responsibility to resize normal rendererer lies with the user
+        // but the label renderer should be resized automatically
         window.addEventListener("resize", () => {
             var _a, _b, _c;
             if (!this.container)
@@ -13140,6 +14262,13 @@ class OpenGeometry {
             (_a = this._labelRenderer) === null || _a === void 0 ? void 0 : _a.setSize((_b = this.container) === null || _b === void 0 ? void 0 : _b.clientWidth, (_c = this.container) === null || _c === void 0 ? void 0 : _c.clientHeight);
         });
     }
+    // TODO: Can this be handled inside the OpenGeometry class itself?
+    /**
+     * Updates the label renderer to render the scene with the given camera.
+     * This method should be called in the animation loop or render loop of your application.
+     * @param scene - The Three.js scene containing the objects to be rendered.
+     * @param camera - The Three.js camera used for rendering the scene.
+     */
     update(scene, camera) {
         var _a;
         (_a = this._labelRenderer) === null || _a === void 0 ? void 0 : _a.render(scene, camera);
@@ -13225,8 +14354,14 @@ class BasePoly extends Mesh {
         const flushBuffer = JSON.parse(flush);
         const geometry = new BufferGeometry();
         geometry.setAttribute("position", new BufferAttribute(new Float32Array(flushBuffer), 3));
-        geometry.computeVertexNormals();
-        const material = new MeshStandardMaterial({ color: 0x3a86ff, side: DoubleSide });
+        // geometry.computeVertexNormals();
+        const material = new MeshStandardMaterial({
+            color: 0x00ff00,
+            // side: THREE.DoubleSide, 
+            transparent: true,
+            opacity: 0.5,
+            // wireframe: true
+        });
         this.geometry = geometry;
         this.material = material;
     }
@@ -13239,15 +14374,16 @@ class BasePoly extends Mesh {
     generateExtrudedGeometry(extruded_buff) {
         // THIS WORKS
         const flushBuffer = JSON.parse(extruded_buff);
-        const geometry = new BufferGeometry();
-        geometry.setAttribute("position", new BufferAttribute(new Float32Array(flushBuffer), 3));
-        geometry.computeVertexNormals();
-        const material = new MeshPhongMaterial({
-            color: 0x3a86ff,
-        });
-        material.side = DoubleSide;
-        this.geometry = geometry;
-        this.material = material;
+        console.log(flushBuffer);
+        // const geometry = new THREE.BufferGeometry();
+        // geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array(flushBuffer), 3));
+        // // geometry.computeVertexNormals();
+        // // const material = new THREE.MeshPhongMaterial({
+        // //   color: 0x3a86ff,
+        // // });
+        // // material.side = THREE.DoubleSide;
+        // this.geometry = geometry;
+        // this.material = material;
     }
 }
 class CirclePoly extends Mesh {
@@ -13276,7 +14412,7 @@ class CirclePoly extends Mesh {
     generateGeometry() {
         if (!this.baseCircle.circleArc)
             return;
-        this.polygon = BasePolygon.new_with_circle(this.baseCircle.circleArc.clone());
+        this.polygon = OGPolygon.new_with_circle(this.baseCircle.circleArc.clone());
     }
     addFlushBufferToScene() {
         if (!this.polygon)
@@ -13304,10 +14440,11 @@ class CirclePoly extends Mesh {
         // }
         // geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
         const material = new MeshStandardMaterial({
-            color: 0x4460FF,
-            side: DoubleSide,
+            color: 0x00ff00,
+            // side: THREE.DoubleSide, 
             transparent: true,
-            opacity: 0.8
+            opacity: 0.5,
+            // wireframe: true
         });
         this.geometry = geometry;
         this.material = material;
@@ -13319,9 +14456,17 @@ class CirclePoly extends Mesh {
         if (!this.polygon)
             return;
         const extruded_buff = this.polygon.extrude_by_height(height);
+        console.log(JSON.parse(extruded_buff));
         this.isExtruded = true;
         this.generateExtrudedGeometry(extruded_buff);
     }
+    getBrepData() {
+        if (!this.polygon)
+            return;
+        const brepData = this.polygon.get_brep_data();
+        const parsedData = JSON.parse(brepData);
+        console.log(parsedData);
+    }
     getOutline(type) {
         if (!this.polygon)
             return;
@@ -13406,7 +14551,6 @@ class CirclePoly extends Mesh {
         const flushBuffer = JSON.parse(extruded_buff);
         const geometry = new BufferGeometry();
         geometry.setAttribute("position", new BufferAttribute(new Float32Array(flushBuffer), 3));
-        geometry.computeVertexNormals();
         // To Test If Triangulation is working
         // const colors = new Float32Array(flushBuffer.length);
         // for (let i = 0; i < colors.length; i += 9) {
@@ -13431,12 +14575,21 @@ class CirclePoly extends Mesh {
         //     shininess: 0,
         //     side: THREE.DoubleSide
         // });
-        const material = new MeshPhongMaterial({
-            color: 0x3a86ff,
-        });
-        material.side = DoubleSide;
+        // const material = new THREE.MeshPhongMaterial({
+        //   color: 0x3a86ff,
+        // });
+        // material.side = THREE.DoubleSide;
         this.geometry = geometry;
-        this.material = material;
+        // this.material = material;
+    }
+    dispose() {
+        var _a;
+        if (!this.polygon)
+            return;
+        this.geometry.dispose();
+        (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.clear_vertices();
+        this.polygon = null;
+        this.isExtruded = false;
     }
 }
 class RectanglePoly extends Mesh {
@@ -13445,27 +14598,26 @@ class RectanglePoly extends Mesh {
         this.polygon = null;
         this.isExtruded = false;
         this.ogid = getUUID();
-        if (!baseRectangle.polyLineRectangle) {
-            throw new Error("BaseRectangle is not defined");
-        }
-        // baseRectangle.nodeChild = this;
-        baseRectangle.nodeOperation = "polygon";
+        // if (!baseRectangle.polyLineRectangle) {
+        //   throw new Error("BaseRectangle is not defined");
+        // }
+        // // baseRectangle.nodeChild = this;
+        // baseRectangle.nodeOperation = "polygon";
         this.baseRectangle = baseRectangle;
         this.generateGeometry();
         this.addFlushBufferToScene();
     }
     update() {
-        var _a, _b;
+        var _a;
         this.geometry.dispose();
         (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.clear_vertices();
-        (_b = this.polygon) === null || _b === void 0 ? void 0 : _b.add_vertices(this.baseRectangle.polyLineRectangle.get_raw_points());
+        // this.polygon?.add_vertices(this.baseRectangle.polyLineRectangle.get_raw_points());
         this.generateGeometry();
         this.addFlushBufferToScene();
     }
     generateGeometry() {
-        if (!this.baseRectangle.polyLineRectangle)
-            return;
-        this.polygon = BasePolygon.new_with_rectangle(this.baseRectangle.polyLineRectangle.clone());
+        // if (!this.baseRectangle.polyLineRectangle) return;
+        // this.polygon = BasePolygon.new_with_rectangle(this.baseRectangle.polyLineRectangle.clone());
     }
     addFlushBufferToScene() {
         if (!this.polygon)
@@ -13622,5 +14774,5 @@ class FlatMesh extends Mesh {
     }
 }
 
-export { BaseCircle, BasePoly, CirclePoly, FlatMesh, OpenGeometry, PolyLine, Rectangle, RectanglePoly, SimpleLine, SpotLabel, Vector3D };
+export { BaseCircle, BasePoly, CirclePoly, Cylinder, FlatMesh, OpenGeometry, PolyLine, Polygon, Rectangle, RectanglePoly, SimpleLine, SpotLabel, Vector3D };
 //# sourceMappingURL=index.js.map