forked from LeenkxTeam/LNXSDK
89 lines
3.4 KiB
C
89 lines
3.4 KiB
C
// 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);
|
|
}
|