HaxeJolt

lib/haxejolt/JoltPhysics/Jolt/Shaders/HairIntegrate.h

@@ -0,0 +1,88 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2026 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+float DeltaDensity(uint inIndex)
+{
+	return gVelocityAndDensity[inIndex].w - gNeutralDensity[inIndex];
+}
+
+void ApplyGrid(JPH_IN(JPH_HairPosition) inPos, JPH_IN_OUT(JPH_HairVelocity) ioVel, JPH_IN(JPH_HairMaterial) inMaterial, float inStrandFraction)
+{
+	if (!inMaterial.mEnableGrid)
+		return;
+
+	// Convert position to grid index and fraction
+	uint3 index;
+	float3 ma;
+	GridPositionToIndexAndFraction(inPos.mPosition, index, ma);
+	float3 a = float3(1, 1, 1) - ma;
+
+	// Get average velocity at the vertex position (trilinear sample)
+	float3 velocity;
+	uint3 stride = cGridStride;
+	uint adr_000 = GridIndexToBufferIndex(index);
+	uint adr_100 = adr_000 + 1;
+	uint adr_010 = adr_000 + stride.y;
+	uint adr_110 = adr_010 + 1;
+	velocity =  gVelocityAndDensity[adr_000].xyz            * ( a.x *  a.y *  a.z);
+	velocity += gVelocityAndDensity[adr_100].xyz            * (ma.x *  a.y *  a.z);
+	velocity += gVelocityAndDensity[adr_010].xyz            * ( a.x * ma.y *  a.z);
+	velocity += gVelocityAndDensity[adr_110].xyz            * (ma.x * ma.y *  a.z);
+	velocity += gVelocityAndDensity[adr_000 + stride.z].xyz * ( a.x *  a.y * ma.z);
+	velocity += gVelocityAndDensity[adr_100 + stride.z].xyz * (ma.x *  a.y * ma.z);
+	velocity += gVelocityAndDensity[adr_010 + stride.z].xyz * ( a.x * ma.y * ma.z);
+	velocity += gVelocityAndDensity[adr_110 + stride.z].xyz * (ma.x * ma.y * ma.z);
+
+	// Drive towards the average velocity of the cell
+	ioVel.mVelocity += GradientSamplerSample(inMaterial.mGridVelocityFactor, inStrandFraction) * (velocity - ioVel.mVelocity);
+
+	// Calculate force to go towards neutral density
+	// Based on eq 3 of Volumetric Methods for Simulation and Rendering of Hair - Lena Petrovic, Mark Henne and John Anderson
+	float dd000 = DeltaDensity(adr_000);
+	float dd100 = DeltaDensity(adr_100);
+	float dd010 = DeltaDensity(adr_010);
+	float dd110 = DeltaDensity(adr_110);
+	float dd001 = DeltaDensity(adr_000 + stride.z);
+	float dd101 = DeltaDensity(adr_100 + stride.z);
+	float dd011 = DeltaDensity(adr_010 + stride.z);
+	float dd111 = DeltaDensity(adr_110 + stride.z);
+
+	float3 force = float3(
+		   a.y *  a.z * (dd000 - dd100)
+		+ ma.y *  a.z * (dd010 - dd110)
+		+  a.y * ma.z * (dd001 - dd101)
+		+ ma.y * ma.z * (dd011 - dd111),
+
+		   a.x *  a.z * (dd000 - dd010)
+		+ ma.x *  a.z * (dd100 - dd110)
+		+  a.x * ma.z * (dd001 - dd011)
+		+ ma.x * ma.z * (dd101 - dd111),
+
+		   a.x *  a.y * (dd000 - dd001)
+		+ ma.x *  a.y * (dd100 - dd101)
+		+  a.x * ma.y * (dd010 - dd011)
+		+ ma.x * ma.y * (dd110 - dd111));
+
+	ioVel.mVelocity += inMaterial.mGridDensityForceFactor * force * cDeltaTime; // / mass, but mass is 1
+}
+
+void Integrate(JPH_IN_OUT(JPH_HairPosition) ioPos, JPH_IN(JPH_HairVelocity) inVel, JPH_IN(JPH_HairMaterial) inMaterial, float inStrandFraction)
+{
+	JPH_HairVelocity vel = inVel;
+
+	// Gravity
+	vel.mVelocity += cSubStepGravity * GradientSamplerSample(inMaterial.mGravityFactor, inStrandFraction);
+
+	// Damping
+	vel.mVelocity *= inMaterial.mExpLinearDampingDeltaTime;
+	vel.mAngularVelocity *= inMaterial.mExpAngularDampingDeltaTime;
+
+	// Integrate position
+	ioPos.mPosition += vel.mVelocity * cDeltaTime;
+
+	// Integrate rotation
+	JPH_Quat rotation = ioPos.mRotation;
+	JPH_Quat delta_rotation = cHalfDeltaTime * JPH_QuatImaginaryMulQuat(vel.mAngularVelocity, rotation);
+	ioPos.mRotation = normalize(rotation + delta_rotation);
+}