Solves issue #6787

src/webgl/p5.Geometry.js

@@ -24,6 +24,9 @@ p5.Geometry = class Geometry {
     //@type [p5.Vector]
     this.vertices = [];
 
+    this.boundingBoxCache = null;
+
+
     //an array containing every vertex for stroke drawing
     this.lineVertices = new p5.DataArray();
 
@@ -75,6 +78,61 @@ p5.Geometry = class Geometry {
     return this; // TODO: is this a constructor?
   }
 
+  /**
+ * Custom bounding box calculation based on the object's vertices.
+ * The bounding box is a rectangular prism that encompasses the entire object.
+ * It is defined by the minimum and maximum coordinates along each axis, as well
+ * as the size and offset of the box.
+ *
+ *
+ * @method calculateBoundingBox
+ * @memberof p5.Geometry.prototype
+ * @return {Object} An object containing the bounding box properties:
+ *
+ *   - `min`: The minimum coordinates of the bounding box as a p5.Vector.
+ *   - `max`: The maximum coordinates of the bounding box as a p5.Vector.
+ *   - `size`: The size of the bounding box as a p5.Vector.
+ *   - `offset`: The offset of the bounding box as a p5.Vector.
+ *
+ */
+
+  calculateBoundingBox() {
+    if (this.boundingBoxCache) {
+      return this.boundingBoxCache; // Return cached result if available
+    }
+
+    let minVertex = new p5.Vector(
+      Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
+    let maxVertex = new p5.Vector(
+      Number.MIN_VALUE, Number.MIN_VALUE, Number.MIN_VALUE);
+
+    for (let i = 0; i < this.vertices.length; i++) {
+      let vertex = this.vertices[i];
+      minVertex.x = min(minVertex.x, vertex.x);
+      minVertex.y = min(minVertex.y, vertex.y);
+      minVertex.z = min(minVertex.z, vertex.z);
+
+      maxVertex.x = max(maxVertex.x, vertex.x);
+      maxVertex.y = max(maxVertex.y, vertex.y);
+      maxVertex.z = max(maxVertex.z, vertex.z);
+    }
+    // Calculate size and offset properties
+    let size = new p5.Vector(maxVertex.x - minVertex.x,
+      maxVertex.y - minVertex.y, maxVertex.z - minVertex.z);
+    let offset = new p5.Vector((minVertex.x + maxVertex.x) / 2,
+      (minVertex.y + maxVertex.y) / 2, (minVertex.z + maxVertex.z) / 2);
+
+    // Cache the result for future access
+    this.boundingBoxCache = {
+      min: minVertex,
+      max: maxVertex,
+      size: size,
+      offset: offset
+    };
+
+    return this.boundingBoxCache;
+  }
+
   reset() {
     this._hasFillTransparency = undefined;
     this._hasStrokeTransparency = undefined;

test/unit/webgl/p5.Geometry.js

@@ -92,6 +92,20 @@ suite('p5.Geometry', function() {
       assert.equal(geom._addJoin.callCount, 4);
     });
 
+    test('calculateBoundingBox()', function() {
+      geom.vertices.push(
+        myp5.createVector(0, 0, 0),
+        myp5.createVector(10, 20, 30),
+        myp5.createVector(-5, 15, 25)
+      );
+      geom.calculateBoundingBox();
+      assert.deepEqual(geom.boundingBox.min.array(), [-5, 0, 0]);
+      assert.deepEqual(geom.boundingBox.max.array(), [10, 20, 30]);
+      assert.deepEqual(geom.boundingBox.size.array(), [15, 20, 30]);
+      assert.deepEqual(geom.boundingBox.offset.array(), [2.5, 10, 15]);
+    });
+
+
     test('degenerate edge in the middle', function() {
       geom.vertices.push(
         myp5.createVector(0, 0),