Buoyancy-in-parts for irregular moving water

[PhoenixIllusion]

Since earlier discussion on buoyancy, (Apply buoyancy impulse offset #76) I've been brainstorming how to handle fluids such as the following scenarios:

1. A boat heading off a cliff. As the boat goes over the edge, the water only supports the rear, thus allowing gravity to overtake the front.

2. A stream of water with two opposing currents in it on opposing sides of a stream. Placing a log spanning the stream will cause the log to spin until the log is parallel to the currents.

##Current brainstorm logic:
By subdividing the body into a voxel like structure composed of tetrahedrons, each tetrahedrons can run a port of the following utility to calculate the forces regarding buoyancy and current:

PolyhedronSubmergedVolumeCalculator

This allows choosing a subdivision level and allowing currents and irregular water shapes to apply forces based on a chosen resolution of voxel size, allowing 1x distinct plane/current per voxel.

To some degree, any surface shape of the water, from curves to waves, can be broken down into planar cuts of the various tetrahedron.

##Simpler non-exact Workaround
Attach ball/buoys to the boat around the perimeter, or even some at the bottom or inside, as fixed constraint. Set these to a non-collision layer, but apply buoyancy only to them and not the boat, based on water levels/currents. This will float the boat at those levels and still allow currents to twist/turn/flip the boat as desired if there are undercurrents and underwater float-buoys. Tailor size/position/volume to desired boat behavior.

[jrouwe]

I think both methods could work. The first one would be quite CPU intensive (you'll get a lot of tetrahedrons).

W.r.t. point 2: We could add next to 'fluid velocity' a 'fluid angular velocity' which you could calculate by sampling the fluid velocity at e.g. the edges of the bounding box and use w = Sum(r x v) / num samples to get the average angular velocity.

As an option 3: You could probably add a 2nd plane to the buoyancy calculations and define the water volume as the intersection between the two half spaces of those 2 planes. You would use 1 plane as water surface, the 2nd one to limit the water horizontally.

[PhoenixIllusion]

I will see if I can make some PoC using some of the general ideas. My current thought is something like either surround a shape in 4 to 6 spheres, or fill the shape with a grid of large spheres to approximate voxels, ex: fill a boat with 3x4 width/height and x2 deep sphere buoyancy voxels.
Conceptually it almost makes me think about a buoyancy-form of the vehicle constraint, with floating supports instead of tires.

The goal with tetrahedron decomposition wasn't high density tetras, like what was needed for soft-body volume jelly. I was aiming more towards coarse convex hull subdivision to approximate the shape.

Regarding adding a second half-space plane, that potentially is sounding like a convex hull intersection equation on various shapes, in the realm of Constructive Solid Geometry.

[PhoenixIllusion]

Fixed Constraint does not seem to work for this. It kind of goes crazy trying to adjust the objects to the fixed point. A Distance Constraint of super low value appears to allow enough wiggle room to solve the constraint without the boat flying off into the sky with a helicopter of float spheres spinning around it.

import initJolt from './js/jolt-physics.wasm-compat.js';

const count = 128;
const data = new Float32Array(count);
for (let i = 0; i < count; i++) {
    data[i] = Math.sin(Math.PI * (2*i/count));
}
const sinoidalWave = new THREE.DataTexture(data, count, 1, THREE.RedFormat, THREE.FloatType); 
sinoidalWave.wrapS = sinoidalWave.wrapT = THREE.RepeatWrapping;
sinoidalWave.offset.set(0, 0);
sinoidalWave.repeat.set(16, 1);
sinoidalWave.magFilter = THREE.NearestFilter;
sinoidalWave.needsUpdate = true;

const WAVE_HEIGHT = 0.25;

function getWaveElevation(x) {
  const uv = x  * sinoidalWave.repeat.x + sinoidalWave.offset.x;
  return data[0|(count * (uv % 1.0))] * WAVE_HEIGHT; 
}

function makeRiver() {
  const planeMesh = new THREE.Mesh(
    new THREE.PlaneGeometry(32, 16, 256, 1),
    new THREE.MeshPhongMaterial({
      displacementMap: sinoidalWave,
      displacementScale: WAVE_HEIGHT,
      flatShading: true,
      color: 0x9999ff,
      opacity: 0.5,
      transparent: true
    })
  );
  planeMesh.material.needsUpdate = true;
  planeMesh.position.y += 1.5;
  scene.add(planeMesh);
  return planeMesh;
}


initJolt().then(function (Jolt) {
  // Initialize this example

  setupCollisionFiltering = function (settings) {
    let objectFilter = new Jolt.ObjectLayerPairFilterTable(3);
    objectFilter.EnableCollision(LAYER_NON_MOVING, LAYER_MOVING);
    objectFilter.EnableCollision(LAYER_MOVING, LAYER_MOVING);

    const BP_LAYER_NON_MOVING = new Jolt.BroadPhaseLayer(0);
    const BP_LAYER_MOVING = new Jolt.BroadPhaseLayer(1);
    const NUM_BROAD_PHASE_LAYERS = 2;
    let bpInterface = new Jolt.BroadPhaseLayerInterfaceTable(3, NUM_BROAD_PHASE_LAYERS);
    bpInterface.MapObjectToBroadPhaseLayer(LAYER_NON_MOVING, BP_LAYER_NON_MOVING);
    bpInterface.MapObjectToBroadPhaseLayer(LAYER_MOVING, BP_LAYER_MOVING);
    bpInterface.MapObjectToBroadPhaseLayer(2, BP_LAYER_MOVING);

    settings.mObjectLayerPairFilter = objectFilter;
    settings.mBroadPhaseLayerInterface = bpInterface;
    settings.mObjectVsBroadPhaseLayerFilter = new Jolt.ObjectVsBroadPhaseLayerFilterTable(settings.mBroadPhaseLayerInterface, NUM_BROAD_PHASE_LAYERS, settings.mObjectLayerPairFilter, NUM_OBJECT_LAYERS);
  };


  initExample(Jolt, null);
  const light = new THREE.AmbientLight( 0x404040 ); // soft white light
  scene.add( light );
  const river1 = makeRiver();
  river1.rotation.x = -Math.PI / 2;
  river1.position.z += 8;

  const river2 = makeRiver();
  river2.rotation.x = Math.PI / 2;
  river2.rotation.y = Math.PI;
  river2.position.z -= 8;


  const position = new Jolt.RVec3();
  position.Set(0.5,5,10);
  const floatingBodies = [];
  const ball = createSphere(position, 0.5, Jolt.EMotionType_Dynamic, LAYER_MOVING, 0x990000);
  floatingBodies.push(ball);
  createFloor();


  const W = 3;
  const H = 0.5;
  const D = 1;
  const extent = new Jolt.Vec3(W, H, D);
  position.Set(2.5,4,8);

  const constraintSettings = new Jolt.DistanceConstraintSettings();
  constraintSettings.mMinDistance = 0;
  constraintSettings.mMaxDistance = .025;

  {
    const shapeSettings = new Jolt.BoxShapeSettings(extent);
    const shape = shapeSettings.Create().Get();
    const bodySettings = new Jolt.BodyCreationSettings(shape, position,Jolt.Quat.prototype.sIdentity(), Jolt.EMotionType_Dynamic, LAYER_MOVING)
    bodySettings.mOverrideMassProperties = Jolt.EOverrideMassProperties_CalculateInertia;
    bodySettings.mMassPropertiesOverride.mMass = 2;
    const log = bodyInterface.CreateBody(bodySettings);
    addToScene(log, 0x003366);
    Jolt.destroy(bodySettings);
    Jolt.destroy(shapeSettings);

    [[1,-1],[1,1],[-1,-1],[-1,1],[0,-1],[0,1]].forEach(([x,z]) => {
      position.Set(x*W+2.5, 4-H, z*D+8);
      const float = createSphere(position, 0.5, Jolt.EMotionType_Dynamic, 2, 0x660099);
      constraintSettings.mPoint1 = constraintSettings.mPoint2 = position;
      physicsSystem.AddConstraint(constraintSettings.Create(log, float));
      floatingBodies.push(float);
    })
  }

  extent.Set(D,H,W);
  position.Set(0,4,0);

  {
    const shapeSettings = new Jolt.BoxShapeSettings(extent);
    const shape = shapeSettings.Create().Get();
    const bodySettings = new Jolt.BodyCreationSettings(shape, position,Jolt.Quat.prototype.sIdentity(), Jolt.EMotionType_Dynamic, LAYER_MOVING)
    bodySettings.mOverrideMassProperties = Jolt.EOverrideMassProperties_CalculateInertia;
    bodySettings.mMassPropertiesOverride.mMass = 2;
    const log = bodyInterface.CreateBody(bodySettings);
    addToScene(log, 0x003366);
    Jolt.destroy(bodySettings);
    Jolt.destroy(shapeSettings);

    [[1,-1],[1,1],[-1,-1],[-1,1],[1,0],[-1,0]].forEach(([x,z]) => {
      position.Set(x*D, 4-H, z*W);
      const float = createSphere(position, 0.5, Jolt.EMotionType_Dynamic, 2, 0x660099);
      constraintSettings.mPoint1 = constraintSettings.mPoint2 = position;
      physicsSystem.AddConstraint(constraintSettings.Create(log, float));
      floatingBodies.push(float);
    })
  }

  const raycaster = new THREE.Raycaster();
  const ray = raycaster.ray;
  ray.direction.set(0, -1, 0);
  const gravity = new Jolt.Vec3(0, -9.8, 0);

  const buoyancy = 1.1;
  const linearDrag = 0.3;
  const angularDrag = 0.05;
  const surfaceNormal = new Jolt.Vec3(0, 1, 0);

  const fluidVelocity = new Jolt.Vec3(-0.5, 0, 0);
  const waterSurfacePosition = new Jolt.RVec3(0, 2.5, 0);

  const WATER_SPEED = 0.4;
  function floatBody(body, deltaTime) {
    const pos = body.GetPosition();
    ray.origin.set(pos.GetX(), pos.GetY(), pos.GetZ());
      ray.origin.y += 3;
      const obj = raycaster.intersectObjects([river1, river2]);
      obj.forEach(result => {
        {
          const { x, y, z} = result.point;
          const height = getWaveElevation(result.uv.x);
          waterSurfacePosition.Set(x, y+height, z);
        }
        if(result.object == river1) {
          fluidVelocity.Set(-WATER_SPEED, 0, 0)
        }
        if(result.object == river2) {
          fluidVelocity.Set(WATER_SPEED, 0, 0)
        }
        body.ApplyBuoyancyImpulse(waterSurfacePosition, surfaceNormal, buoyancy, linearDrag, angularDrag, fluidVelocity, gravity, deltaTime);
      });
  }
  onExampleUpdate = function (time, deltaTime) {
    floatingBodies.forEach(body => floatBody(body, deltaTime));
    sinoidalWave.offset.x += deltaTime * 0.1;
  }
});

[PhoenixIllusion]

Fixed Constraint

2024-06-25-bouyant-fixed-constraint.mp4

Distance Constraint

2024-06-25-bouyant-distance-constraint.mp4

[PhoenixIllusion]

Though Sensors/non-collision layers attached to collide-able bodies via constraints cause everything to pass through the floor, and I'm not sure why.

[jrouwe]

So there are a couple of problems here:

1. It is best if the attachment point is auto calculated, so that means:

const constraintSettings = new Jolt.FixedConstraintSettings();
constraintSettings.mAutoDetectPoint = true;

and removing:

constraintSettings.mPoint1 = constraintSettings.mPoint2 = position;

2. The createSphere function doesn't override mass, so that sphere is about 500 kg. Attaching that to a 2 kg main body gives a very unstable situation (equivalent to what happens in the samples app HeavyOnLightTest). I fixed this by adding this to the createSphere function:

creationSettings.mOverrideMassProperties = Jolt.EOverrideMassProperties_CalculateInertia;
creationSettings.mMassPropertiesOverride.mMass = 2;

(note that we shouldn't change this globally for all demos, but for this experiment it's fine)
3. Now the boat is a bit heavy and sinks, so I changed the main body to 1 kg. After that it works.
4. This doesn't really show now but is still an issue: Your main body collides with the spheres leading to further instabilities. Look at the constraints.html demo and create a GroupFilterTable and set mCollisionGroup on each of the bodies.

[PhoenixIllusion]

The bodies are on different layers, would they be colliding?

The body is LAYER_MOVING (1) and the spheres are layer 2, which is not defined as colliding with anything.

[jrouwe]

Ah, you're right. I missed that detail.

[PhoenixIllusion]

Since the goal of the floats is just to allow more complex buoyant behavior (currents, falling off ledges, being partially on-land), and never colliding themselves, mIsSensor also works, but pure non-collide-able layer was my end-goal so it never even trigger collision events.

I'd tried porting the Body.cpp BuoyancyImpulse code to JS to drop the constraints and use raw force/impulse, but combining all the forces together by hand and then resolving them against the parent body with proper linear/angular drag was non-trivial. Challenge of doing it myself on a whim Ex: pushing on left-back side of box + right-back side of box equally should total a directional zero-torque impulse, and that needs linear-drag instead of angular drag before applying to the box. Now that this works with FixedConstraint, the result is probably closer to my end-goal and can be wrapped in my libraries own controller.

Possibly could have summed them all together and broken them into parts at the end, or could have snap-shotted the existing forces on the body, applied the piece-wise impulse/force, delta'd the difference after my buoyancy. Now that I had the summed forces, I could reset the force, split it to linear/angular and applied dragged impulse, and re-applied.

Regarding the float-weights, I believe an equation is:

1. Double the buoyancy, and divide the box weight among all floaters. This is because the buoyancy force will first counter the float's weight, then we want to apply 1x the force to the box as well. The buoyancy must support (float-spheres x6 + box), but it is only running the impulse on the (float x6) side, so it needs to carry the extra weight.

[jrouwe]

Buoyancy Force = -Density of Fluid * Submerged Volume * Gravity

We have defined:

Density of Fluid = Buoyancy Constant * Mass / Total Volume

So:

Buoyancy Force = -Buoyancy Constant * Mass * Gravity * Submerged Volume / Total Volume

When the object is fully submerged we have Submerged Volume / Total Volume = 1, so we can write:

Buoyancy Force = -Buoyancy Constant * Mass * Gravity

So if you double Buoyancy Constant and Mass then Buoyancy Force will be 4x as large. But since you're effectively setting the Buoyancy Constant to 0 for the box, you have only doubled the Buoyancy Force for the box/spheres combination.

Doubling the mass of the box/sphere combination will make the downward force 2x as big.

So yes, I think what you're saying should be correct.