refactor: sole sampler for bouyancy

Author: codeagent

graphics/gizmos.ts

@@ -5,7 +5,7 @@ import { Transform } from './transform';
 import { createGrid } from './mesh';
 import { Camera } from './camera';
 import { vs, fs } from './programs/mesh';
-import { FloatingBody } from '../ocean';
+import { FloatingBody, OceanFieldBuoyancy } from '../ocean';
 
 export class Gizmos {
   private readonly wiredSphereGeometry: Geometry;
@@ -137,6 +137,7 @@ export class Gizmos {
   drawFloatingBody(
     camera: Camera,
     body: FloatingBody,
+    boyancy: OceanFieldBuoyancy,
     geometry?: Geometry
   ): void {
     const position = vec3.create();
@@ -150,10 +151,18 @@ export class Gizmos {
       this.drawGeometry(camera, geometry, position, rotation);
     }
 
-    if (body.sampled) {
+    if (boyancy['sampled']) {
       this.gpu.context.disable(WebGL2RenderingContext.DEPTH_TEST);
-      body['world'].forEach((world, i) => {
-        const sampled = body['sampled'][i];
+      const startIndex = boyancy['bodies']
+        .slice(0, boyancy['bodies'].indexOf(body))
+        .reduce((acc, curr) => acc + curr.floaters.length, 0);
+      const endIndex = startIndex + body.floaters.length;
+
+      const bodyWorld = boyancy['world'].slice(startIndex, endIndex);
+      const bodySampled = boyancy['sampled'].slice(startIndex, endIndex);
+
+      bodyWorld.forEach((world, i) => {
+        const sampled = bodySampled[i];
         const submerged = sampled?.[1] >= world?.[1];
         const color = !submerged
           ? vec4.fromValues(0.5, 1.0, 0.5, 0.0)

ocean/buoyancy/floating-body.ts

@@ -1,56 +1,25 @@
-import { vec2, vec3 } from 'gl-matrix';
+import { vec3 } from 'gl-matrix';
 
-import { PointsSampler, Sample, SampleStatus } from '../sampler';
 import { RigidBodyInterface } from './rigid-body.interface';
 
 export class FloatingBody {
-  public readonly world: vec3[] = [];
-  public readonly points: vec2[] = [];
-  public sampled: vec3[] | null = null;
-  public sample: Sample<vec3[]> = null;
-
   constructor(
     public readonly body: RigidBodyInterface,
     public readonly floaters: vec3[],
     public readonly submergeDepth: number,
     public readonly buoyancyStrength: number,
     public readonly waterDrag: number,
     public readonly waterAngularDrag: number,
-    public readonly gravity: vec3,
-    public readonly sampler: PointsSampler
-  ) {
-    this.floaters.forEach(() => {
-      this.world.push(vec3.create());
-      this.points.push(vec2.create());
-    });
-  }
-
-  applyForces(): void {
-    if (!this.sample) {
-      this.floaters.forEach((floater, i) => {
-        vec3.transformMat4(this.world[i], floater, this.body.transform);
-        vec2.set(this.points[i], this.world[i][0], this.world[i][2]);
-      });
-      this.sample = this.sampler.sample(...this.points);
-    } else {
-      const status = this.sample.status();
-      if (status !== SampleStatus.Pending) {
-        if (status === SampleStatus.Complete) {
-          this.sampled = this.sample.outcome();
-        }
-        this.sample.release();
-        this.sample = null;
-      }
-    }
-
-    if (this.sampled) {
-      this.applyForcesInternal(this.sampled, this.world);
-    }
-  }
+    public readonly gravity: vec3
+  ) {}
 
-  private applyForcesInternal(sampled: vec3[], world: vec3[]) {
+  applyForces(sampled: vec3[], world: vec3[], offset: number) {
     const center = vec3.create();
-    for (let i = 0; i < this.floaters.length; i++) {
+    for (
+      let i = offset, j = 0, end = this.floaters.length + offset;
+      i < end;
+      i++, j++
+    ) {
       if (sampled[i][1] <= world[i][1]) {
         continue;
       }
@@ -65,7 +34,7 @@ export class FloatingBody {
           this.gravity,
           -this.body.mass * submerging * this.buoyancyStrength
         ),
-        this.floaters[i]
+        this.floaters[j]
       );
       this.body.applyForce(
         vec3.scale(

ocean/buoyancy/ocean-field-buoyancy.ts

@@ -1,7 +1,9 @@
-import { vec3 } from 'gl-matrix';
+import { vec2, vec3 } from 'gl-matrix';
+import { SampleStatus } from '..';
 
 import { OceanField } from '../ocean-field';
 import { PointsSampler } from '../sampler';
+import { Sample } from '../sampler/sample';
 import { FloatingBody } from './floating-body';
 import { RigidBodyInterface } from './rigid-body.interface';
 
@@ -22,7 +24,13 @@ export const floatingBodyDefaultOptions: FloatingBodyOptions = {
 };
 
 export class OceanFieldBuoyancy {
-  public readonly bodies = new Set<FloatingBody>();
+  private readonly bodies: FloatingBody[] = [];
+  private readonly world: vec3[] = [];
+  private readonly points: vec2[] = [];
+  private sampled: vec3[] | null = null;
+  private sample: Sample<vec3[]> = null;
+  private sampler: PointsSampler;
+  private dirty = true;
 
   constructor(public readonly oceanField: OceanField) {}
 
@@ -33,33 +41,77 @@ export class OceanFieldBuoyancy {
   ): FloatingBody {
     options = { ...floatingBodyDefaultOptions, ...options };
 
-    const sampler = new PointsSampler(this.oceanField, floaters.length);
     const floatingBody = new FloatingBody(
       body,
       floaters,
       options.submergeDepth,
       options.buoyancyStrengh,
       options.waterDrag,
       options.waterAngularDrag,
-      options.gravity,
-      sampler
+      options.gravity
     );
-    this.bodies.add(floatingBody);
+    this.bodies.push(floatingBody);
+
+    floaters.forEach(() => {
+      this.world.push(vec3.create());
+      this.points.push(vec2.create());
+    });
+
+    this.dirty = true;
+    this.sample = null;
 
     return floatingBody;
   }
 
   update() {
-    for (const body of this.bodies) {
-      body.applyForces();
+    this.sampleOceanField();
+    if (this.sampled) {
+      let offset = 0;
+      for (const body of this.bodies) {
+        body.applyForces(this.sampled, this.world, offset);
+        offset += body.floaters.length;
+      }
     }
   }
 
-  destroy(body: FloatingBody) {
-    body.sampler.dispose();
-    if (body.sample) {
-      body.sample.release();
+  destroyFloatingBody(body: FloatingBody) {
+    this.bodies.splice(this.bodies.indexOf(body), 1);
+    body.floaters.forEach(() => {
+      this.world.pop();
+      this.points.pop();
+    });
+
+    this.dirty = true;
+    this.sample = null;
+  }
+
+  private sampleOceanField() {
+    if (!this.sample) {
+      let i = 0;
+      for (const body of this.bodies) {
+        for (const floater of body.floaters) {
+          vec3.transformMat4(this.world[i], floater, body.body.transform);
+          vec2.set(this.points[i], this.world[i][0], this.world[i][2]);
+          i++;
+        }
+      }
+
+      if (this.dirty) {
+        this.sampler?.dispose();
+        this.sampler = new PointsSampler(this.oceanField, i);
+        this.dirty = false;
+      }
+
+      this.sample = this.sampler.sample(...this.points);
+    } else {
+      const status = this.sample.status();
+      if (status !== SampleStatus.Pending) {
+        if (status === SampleStatus.Complete) {
+          this.sampled = this.sample.outcome();
+        }
+        this.sample.release();
+        this.sample = null;
+      }
     }
-    this.bodies.delete(body);
   }
 }

physics/interfaces/intergrator.interface.ts

@@ -88,15 +88,16 @@ export class Viewport {
     this.renderFloatings();
   }
 
-  public renderGrid() {
+  private renderGrid() {
     this.gizmos.drawGrid(this.cameraController.camera);
   }
 
-  public renderFloatings() {
+  private renderFloatings() {
     this.floaters.forEach(([floater, geometry]) =>
       this.gizmos.drawFloatingBody(
         this.cameraController.camera,
         floater,
+        this.buoyancy,
         geometry
       )
     );