opengeometry 0.0.3 → 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();
@@ -1027,12 +1027,28 @@ class OGPolyLine {
     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
   */
-  set_config(points) {
+  add_multiple_points(points) {
     const ptr0 = passArrayJsValueToWasm0(points, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    wasm.ogpolyline_set_config(this.__wbg_ptr, ptr0, len0);
+    wasm.ogpolyline_add_multiple_points(this.__wbg_ptr, ptr0, len0);
   }
   /**
   * @param {Vector3D} point
@@ -1043,16 +1059,6 @@ class OGPolyLine {
     wasm.ogpolyline_add_point(this.__wbg_ptr, ptr0);
   }
   /**
-  */
-  dispose_points() {
-    wasm.ogpolyline_destroy(this.__wbg_ptr);
-  }
-  /**
-  */
-  destroy() {
-    wasm.ogpolyline_destroy(this.__wbg_ptr);
-  }
-  /**
   * @returns {string}
   */
   get_points() {
@@ -1099,6 +1105,65 @@ class OGPolyLine {
   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: () => {},
@@ -1247,6 +1312,14 @@ class OGPolygon {
     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}
   */
@@ -1369,6 +1442,11 @@ class OGPolygon {
   }
   /**
   */
+  clear_buffer() {
+    wasm.ogpolygon_clear_buffer(this.__wbg_ptr);
+  }
+  /**
+  */
   clear_vertices() {
     wasm.ogpolygon_clear_vertices(this.__wbg_ptr);
   }
@@ -1493,6 +1571,25 @@ class OGPolygon {
       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: () => {},
@@ -1928,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) {
@@ -1959,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);
@@ -1967,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));
@@ -13382,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;
     }
@@ -13460,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() {
@@ -13529,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;
@@ -13556,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);
@@ -13564,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) {
@@ -13590,7 +13787,6 @@ class BaseCircle extends Line {
         this.circleArc.generate_points();
         const bufRaw = this.circleArc.get_points();
         const bufFlush = JSON.parse(bufRaw);
-        console.log(bufFlush);
         const line = new BufferGeometry().setFromPoints(bufFlush);
         const material = new LineBasicMaterial({ color: 0x000000 });
         this.geometry = line;
@@ -13609,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);
@@ -13624,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;
     }
@@ -13658,7 +13870,6 @@ class Rectangle extends Line {
         this.geometry.dispose();
     }
 }
-_Rectangle_color = new WeakMap();
 
 var _Cylinder_outlineMesh;
 class Cylinder extends Mesh {
@@ -13770,6 +13981,19 @@ class Polygon extends Mesh {
         //   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)
@@ -13785,7 +14009,7 @@ class Polygon extends Mesh {
             return;
         this.layerVertices = [];
         this.geometry.dispose();
-        (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.reset_polygon();
+        (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.clear_vertices();
         this.isTriangulated = false;
     }
     addVertex(threeVertex) {
@@ -13793,7 +14017,7 @@ class Polygon extends Mesh {
         if (this.isTriangulated) {
             this.layerVertices = [];
             this.geometry.dispose();
-            (_a = this.polygon) === null || _a === void 0 ? void 0 : _a.reset_polygon();
+            (_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());
@@ -13835,7 +14059,7 @@ class Polygon extends Mesh {
         geometry.computeVertexNormals();
         const material = new MeshStandardMaterial({
             color: 0x00ff00,
-            // side: THREE.DoubleSide, 
+            side: DoubleSide,
             transparent: true,
             opacity: 0.5,
             // wireframe: true
@@ -13858,18 +14082,31 @@ class Polygon extends Mesh {
         geometry.setAttribute("position", new BufferAttribute(new Float32Array(flushBuffer), 3));
         geometry.computeVertexNormals();
         this.geometry = geometry;
-        // const material = new THREE.MeshStandardMaterial({
-        //   color: 0x3a86ff,
-        // });
-        // // material.side = THREE.DoubleSide;
-        // this.material = material;
+        const material = new MeshStandardMaterial({
+            color: 0x00ff00,
+            side: FrontSide,
+            transparent: true,
+            opacity: 0.5,
+            // wireframe: true
+        });
+        this.material = material;
     }
     getBrepData() {
         if (!this.polygon)
-            return;
+            return null;
         const brepData = this.polygon.get_brep_data();
-        const parsedData = JSON.parse(brepData);
-        console.log(parsedData);
+        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) {
@@ -13899,23 +14136,93 @@ class Polygon extends Mesh {
         }
         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;
@@ -13931,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");
@@ -13955,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)
@@ -13962,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);
@@ -14275,6 +14582,15 @@ class CirclePoly extends Mesh {
         this.geometry = geometry;
         // 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 {
     constructor(baseRectangle) {
@@ -14282,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)