Buoyancy formula

[Leadwerks]

I have adapted the code here into my buoyancy calculation:

dVector RotateVector(const dMatrix& mm, const dVector& v)
{
	return dVector(v.m_x * mm.m_front.m_x + v.m_y * mm.m_up.m_x + v.m_z * mm.m_right.m_x,
		v.m_x * mm.m_front.m_y + v.m_y * mm.m_up.m_y + v.m_z * mm.m_right.m_y,
		v.m_x * mm.m_front.m_z + v.m_y * mm.m_up.m_z + v.m_z * mm.m_right.m_z, dFloat(0.0f));
}

void PhysicsNode::AddBuoyancyForce(const dFloat nx, const dFloat ny, const dFloat nz, const dFloat d, const dFloat fluidDensity, const dFloat fluidViscosity)
{
	dFloat Ixx;
	dFloat Iyy;
	dFloat Izz;
	dFloat mass;
	const float m_waterToSolidVolumeRatio = 0.5;
	dVector m_plane = dVector(nx, ny, nz, d);
	NewtonBodyGetMass(newtonbody, &mass, &Ixx, &Iyy, &Izz);
	if (mass > 0.0f)
	{
		dMatrix matrix;
		dVector cenyterOfPreasure(0.0f);

		NewtonBodyGetMatrix(newtonbody, &matrix[0][0]);
		NewtonCollision* const collision = NewtonBodyGetCollision(newtonbody);

		// calculate the volume and center of mass of the shape under the water surface 
		//dVector plane(CalculateWaterPlane(matrix.m_posit));
		dVector plane(0.0f, 1.0f, 0.0f, 0.0f);
		dFloat volume = NewtonConvexCollisionCalculateBuoyancyVolume(collision, &matrix[0][0], &plane[0], &cenyterOfPreasure[0]);
		if (volume > 0.0f)
		{
			// if some part of the shape si under water, calculate the buoyancy force base on 
			// Archimedes's buoyancy principle, which is the buoyancy force is equal to the 
			// weight of the fluid displaced by the volume under water. 
			dVector cog(0.0f);
			//const dFloat viscousDrag = 1.0f - fluidViscosity;
			const dFloat viscousDrag = 0.99f;
			//const dFloat solidDentityFactor = 1.35f;

			// Get the body density form the collision material.
			NewtonCollisionMaterial collisionMaterial;
			NewtonCollisionGetMaterial(collision, &collisionMaterial);
			const dFloat solidDentityFactor = 1.35f;// collisionMaterial.m_userParam[0].m_float;

			// calculate the ratio of volumes an use it calculate a density equivalent
			dFloat shapeVolume = NewtonConvexCollisionCalculateVolume(collision);
			dFloat density = mass * solidDentityFactor / shapeVolume;

			dFloat displacedMass = density * volume;
			NewtonBodyGetCentreOfMass(newtonbody, &cog[0]);
			//cenyterOfPreasure -= matrix.TransformVector(cog);
			cenyterOfPreasure -= matrix.m_posit + RotateVector(matrix, &cog[0]);

			// now with the mass and center of mass of the volume under water, calculate buoyancy force and torque
			dVector force(dFloat(0.0f), dFloat(-world->gravity.y * displacedMass), dFloat(0.0f), dFloat(0.0f));
			dVector torque(cenyterOfPreasure.CrossProduct(force));

			NewtonBodyAddForce(newtonbody, &force[0]);
			NewtonBodyAddTorque(newtonbody, &torque[0]);

			// apply a fake viscous drag to damp the under water motion 
			dVector omega(0.0f);
			dVector veloc(0.0f);
			NewtonBodyGetOmega(newtonbody, &omega[0]);
			NewtonBodyGetVelocity(newtonbody, &veloc[0]);
			omega = omega.Scale(viscousDrag);
			veloc = veloc.Scale(viscousDrag);
			NewtonBodySetOmega(newtonbody, &omega[0]);
			NewtonBodySetVelocity(newtonbody, &veloc[0]);
		}
	}
}

1. Why does the collision object have a "solidDentityFactor" value? Shouldn't the density of the object be calculated automatically from the mass and volume?

2. I don't see anywhere the fluid density is taken into account?

[JulioJerez]

In the calculation, the fluid density cancels out.
What ultimately determines the buoyant force is the ratio between the object's volume and the volume of fluid it displaces.
If you scale the object's mass by a factor that accounts for the density of the solid material, you can express the relationship as:

density = mass * solidDensityFactor / shapeVolume;

For example, consider two balls with the same diameter but made from different materials. When placed in the same fluid, the denser ball must displace a greater volume of fluid before the buoyant force balances its weight. This relationship is independent of the fluid density and is reflected in the equation above.

The principle involved is simply that the buoyant force equals the weight of the displaced fluid.
The weight of the displaced fluid is the submerged volume multiplied by the fluid density and gravity.

When you solve for the amount of displacement required to support the object's weight,
both gravity and fluid density cancel out, leaving only a ratio of volumes.

For example:
1-If you want a ball to be fully submerged while neutrally buoyant, the volume ratio is 1.0.
2-If you want the ball to float with 10% of its volume above the surface, then only 90% of its volume is submerged. The required ratio becomes 1 / 0.9, since the displaced fluid volume must provide the same weight as the ball while using only 90% of the ball's volume.

Using this approach, the equation can be written as:

float fluidDensity = 1.0f;
density = mass * solidDensityFactor / (shapeVolume * fluidDensity);

You can store fluidDensity separately.
A value of 1.0 represents water. In a denser fluid, an object needs to displace less volume to generate the same buoyant force,
so it will float higher in the fluid.

It is difficult to get the intuition, because must solids do not really change volume, so using volume instead of mass, seen wrong.
The thing is that using mass and using volume is the same thing since mass = density * volume
so when you can see the expression as the nominal volume scaled by the density. make it in effect a changed volume.
You can literally get the intuition when you consider Ice and water.
while most solid only change density, for something like Ice what changes is the volume.