public void doCalculateSpringForce(MegaSoft hose)
{
Vector3 deltaP = hose.masses[p1].pos - hose.masses[p2].pos;
float dist = deltaP.magnitude;
Vector3 dir = deltaP / dist;
Vector3 springForce = -ks * (dist - restlen) * dir;
Vector3 deltaV = hose.masses[p1].vel - hose.masses[p2].vel;
springForce += -kd *Vector3.Dot(deltaV, dir) * dir;
//float Hterm = (dist - restlen) * ks;
len = dist;
//float Dterm = (Vector3.Dot(deltaV, deltaP) * kd) / dist;
//Vector3 springForce = deltaP * (1.0f / dist);
//springForce *= -(Hterm + Dterm);
hose.masses[p1].force.x += springForce.x;
hose.masses[p1].force.y += springForce.y;
hose.masses[p1].force.z += springForce.z;
hose.masses[p2].force.x -= springForce.x;
hose.masses[p2].force.y -= springForce.y;
hose.masses[p2].force.z -= springForce.z;
}
public override void Apply(MegaSoft soft)
{
if (active)
{
soft.masses[p1].pos = tp;
}
}
public override void Apply(MegaSoft soft)
{
if (active)
{
moveVector.x = soft.masses[p2].pos.x - soft.masses[p1].pos.x;
moveVector.y = soft.masses[p2].pos.y - soft.masses[p1].pos.y;
moveVector.z = soft.masses[p2].pos.z - soft.masses[p1].pos.z;
if (moveVector.x != 0.0f || moveVector.y != 0.0f || moveVector.z != 0.0f)
{
float currentLength = moveVector.magnitude;
float do1 = 1.0f / currentLength;
float l = 0.5f * (currentLength - length) * do1;
moveVector.x *= l;
moveVector.y *= l;
moveVector.z *= l;
soft.masses[p1].pos.x += moveVector.x;
soft.masses[p1].pos.y += moveVector.y;
soft.masses[p1].pos.z += moveVector.z;
soft.masses[p2].pos.x -= moveVector.x;
soft.masses[p2].pos.y -= moveVector.y;
soft.masses[p2].pos.z -= moveVector.z;
}
}
}
public MegaSoftSpring(int _p1, int _p2, float _ks, float _kd, MegaSoft soft, float stretch)
{
p1 = _p1;
p2 = _p2;
ks = _ks;
kd = _kd;
restlen = (soft.masses[p1].pos - soft.masses[p2].pos).magnitude * stretch;
initlen = restlen;
}
// This is for cubic interpolation so dont need
public void MoveMasses(MegaSoft soft)
{
return;
for ( int i = 0; i < masses.Count; i++ )
{
masspos[i + 1] = masses[i].pos;
masses[i].forcec = Vector3.zero;
}
masspos[0] = masses[0].pos - (masses[1].pos - masses[0].pos);
masspos[masspos.Length - 1] = masses[masses.Count - 1].pos + (masses[masses.Count - 1].pos - masses[masses.Count - 2].pos);
}
// This is for cubic interpolation so dont need
public void MoveMasses(MegaSoft soft)
{
return;
for (int i = 0; i < masses.Count; i++)
{
masspos[i + 1] = masses[i].pos;
masses[i].forcec = Vector3.zero;
}
masspos[0] = masses[0].pos - (masses[1].pos - masses[0].pos);
masspos[masspos.Length - 1] = masses[masses.Count - 1].pos + (masses[masses.Count - 1].pos - masses[masses.Count - 2].pos);
}
void DoConstraints(MegaSoft soft)
{
for (int c = 0; c < soft.constraints.Count; c++)
{
soft.constraints[c].ReActivate(soft, soft.timeStep);
}
for (int i = 0; i < soft.iters; i++)
{
for (int c = 0; c < soft.lenconstraints.Count; c++)
{
soft.lenconstraints[c].Apply(soft);
}
for (int c = 0; c < soft.constraints.Count; c++)
{
soft.constraints[c].Apply(soft);
}
}
}
public override void doIntegration1(MegaSoft soft, float dt)
{
doCalculateForces(soft); // Calculate forces, only changes _f
/* Then do correction step by integration with central average (Heun) */
for (int i = 0; i < soft.masses.Count; i++)
{
soft.masses[i].last = soft.masses[i].pos;
soft.masses[i].vel += dt * soft.masses[i].force * soft.masses[i].oneovermass;
soft.masses[i].pos += soft.masses[i].vel * dt;
soft.masses[i].vel *= soft.airdrag; //friction;
}
DoConstraints(soft);
//DoCollisions(dt);
if (soft.doCollisions)
{
DoCollisions(soft);
}
}
void doCalculateForces(MegaSoft soft)
{
Vector3 frc = soft.gravity;
frc.x += soft.windFrc.x;
frc.y += soft.windFrc.y;
frc.z += soft.windFrc.z;
for (int i = 0; i < soft.masses.Count; i++)
{
soft.masses[i].force.x = (soft.masses[i].mass * frc.x) + soft.masses[i].forcec.x;
soft.masses[i].force.y = (soft.masses[i].mass * frc.y) + soft.masses[i].forcec.y;
soft.masses[i].force.z = (soft.masses[i].mass * frc.z) + soft.masses[i].forcec.z;
}
for (int i = 0; i < soft.springs.Count; i++)
{
soft.springs[i].doCalculateSpringForce(soft);
}
}
public void ReActivate(MegaSoft soft, float t)
{
tp = obj.TransformPoint(offset);
if (!active)
{
if (reactivate > 0.0f)
{
reactivate -= 0.01f;
//Vector3 delta = tp - soft.masses[p1].pos;
soft.masses[p1].pos = easeInOutSine(tp, ps, reactivate / rtime);
if (reactivate < 0.0f)
{
reactivate = 0.0f;
active = true;
}
}
}
}
public void doCalculateSpringForce1(MegaSoft mod)
{
Vector3 direction = mod.masses[p1].pos - mod.masses[p2].pos;
if (direction != Vector3.zero)
{
float currLength = direction.magnitude;
direction = direction.normalized;
Vector3 force = -ks * ((currLength - restlen) * direction);
mod.masses[p1].force.x += force.x;
mod.masses[p1].force.y += force.y;
mod.masses[p1].force.z += force.z;
mod.masses[p2].force.x -= force.x;
mod.masses[p2].force.y -= force.y;
mod.masses[p2].force.z -= force.z;
len = currLength;
}
}
void DoCollisions(MegaSoft soft)
{
for (int i = 0; i < soft.masses.Count; i++)
{
if (soft.masses[i].pos.y < soft.floor)
{
soft.masses[i].pos.y = soft.floor;
float VdotN = Vector3.Dot(Vector3.up, soft.masses[i].vel);
Vector3 Vn = Vector3.up * VdotN;
// CALCULATE Vt
//Vector3 Vt = (rope.masses[i].vel - Vn) * rope.floorfriction;
// SCALE Vn BY COEFFICIENT OF RESTITUTION
Vn *= 0.9f; //rope.bounce;
// SET THE VELOCITY TO BE THE NEW IMPULSE
soft.masses[i].vel = Vn; //Vt - Vn;
soft.masses[i].last = soft.masses[i].pos;
}
}
}
public override void doIntegration1(MegaSoft soft, float dt)
{
doCalculateForces(soft); // Calculate forces, only changes _f
float t2 = dt * dt;
/* Then do correction step by integration with central average (Heun) */
for (int i = 0; i < soft.masses.Count; i++)
{
Vector3 last = soft.masses[i].pos;
soft.masses[i].pos += soft.airdrag * (soft.masses[i].pos - soft.masses[i].last) + soft.masses[i].force * soft.masses[i].oneovermass * t2; // * t;
soft.masses[i].vel = (soft.masses[i].pos - last) / dt;
soft.masses[i].last = last;
}
DoConstraints(soft);
if (soft.doCollisions)
{
DoCollisions(soft);
}
}
public override void doIntegration1(MegaSoft soft, float dt)
{
doCalculateForces(soft); // Calculate forces, only changes _f
/* Then do correction step by integration with central average (Heun) */
for ( int i = 0; i < soft.masses.Count; i++ )
{
soft.masses[i].last = soft.masses[i].pos;
soft.masses[i].vel += dt * soft.masses[i].force * soft.masses[i].oneovermass;
soft.masses[i].pos += soft.masses[i].vel * dt;
soft.masses[i].vel *= soft.airdrag; //friction;
}
DoConstraints(soft);
//DoCollisions(dt);
if ( soft.doCollisions )
DoCollisions(soft);
}
void DoConstraints(MegaSoft soft)
{
for ( int c = 0; c < soft.constraints.Count; c++ )
{
soft.constraints[c].ReActivate(soft, soft.timeStep);
}
for ( int i = 0; i < soft.iters; i++ )
{
for ( int c = 0; c < soft.lenconstraints.Count; c++ )
soft.lenconstraints[c].Apply(soft);
for ( int c = 0; c < soft.constraints.Count; c++ )
soft.constraints[c].Apply(soft);
}
}
void doCalculateForces(MegaSoft soft)
{
Vector3 frc = soft.gravity;
frc.x += soft.windFrc.x;
frc.y += soft.windFrc.y;
frc.z += soft.windFrc.z;
for ( int i = 0; i < soft.masses.Count; i++ )
{
soft.masses[i].force.x = (soft.masses[i].mass * frc.x) + soft.masses[i].forcec.x;
soft.masses[i].force.y = (soft.masses[i].mass * frc.y) + soft.masses[i].forcec.y;
soft.masses[i].force.z = (soft.masses[i].mass * frc.z) + soft.masses[i].forcec.z;
}
for ( int i = 0; i < soft.springs.Count; i++ )
soft.springs[i].doCalculateSpringForce(soft);
}
public virtual void doIntegration1(MegaSoft soft, float dt) { }
public override void Apply(MegaSoft soft)
{
if ( active )
soft.masses[p1].pos = tp;
}
public MegaSoftSpring(int _p1, int _p2, float _ks, float _kd, MegaSoft soft, float stretch)
{
p1 = _p1;
p2 = _p2;
ks = _ks;
kd = _kd;
restlen = (soft.masses[p1].pos - soft.masses[p2].pos).magnitude * stretch;
initlen = restlen;
}
public void doCalculateSpringForce1(MegaSoft mod)
{
Vector3 direction = mod.masses[p1].pos - mod.masses[p2].pos;
if ( direction != Vector3.zero )
{
float currLength = direction.magnitude;
direction = direction.normalized;
Vector3 force = -ks * ((currLength - restlen) * direction);
mod.masses[p1].force.x += force.x;
mod.masses[p1].force.y += force.y;
mod.masses[p1].force.z += force.z;
mod.masses[p2].force.x -= force.x;
mod.masses[p2].force.y -= force.y;
mod.masses[p2].force.z -= force.z;
len = currLength;
}
}
public virtual void doIntegration1(MegaSoft soft, float dt)
{
}
public override void doIntegration1(MegaSoft soft, float dt)
{
doCalculateForces(soft); // Calculate forces, only changes _f
float t2 = dt * dt;
/* Then do correction step by integration with central average (Heun) */
for ( int i = 0; i < soft.masses.Count; i++ )
{
Vector3 last = soft.masses[i].pos;
soft.masses[i].pos += soft.airdrag * (soft.masses[i].pos - soft.masses[i].last) + soft.masses[i].force * soft.masses[i].oneovermass * t2; // * t;
soft.masses[i].vel = (soft.masses[i].pos - last) / dt;
soft.masses[i].last = last;
}
DoConstraints(soft);
if ( soft.doCollisions )
DoCollisions(soft);
}
void DoCollisions(MegaSoft soft)
{
for ( int i = 0; i < soft.masses.Count; i++ )
{
if ( soft.masses[i].pos.y < soft.floor )
{
soft.masses[i].pos.y = soft.floor;
float VdotN = Vector3.Dot(Vector3.up, soft.masses[i].vel);
Vector3 Vn = Vector3.up * VdotN;
// CALCULATE Vt
//Vector3 Vt = (rope.masses[i].vel - Vn) * rope.floorfriction;
// SCALE Vn BY COEFFICIENT OF RESTITUTION
Vn *= 0.9f; //rope.bounce;
// SET THE VELOCITY TO BE THE NEW IMPULSE
soft.masses[i].vel = Vn; //Vt - Vn;
soft.masses[i].last = soft.masses[i].pos;
}
}
}
public override void Apply(MegaSoft soft)
{
if ( active )
{
moveVector.x = soft.masses[p2].pos.x - soft.masses[p1].pos.x;
moveVector.y = soft.masses[p2].pos.y - soft.masses[p1].pos.y;
moveVector.z = soft.masses[p2].pos.z - soft.masses[p1].pos.z;
if ( moveVector.x != 0.0f || moveVector.y != 0.0f || moveVector.z != 0.0f )
{
float currentLength = moveVector.magnitude;
float do1 = 1.0f / currentLength;
float l = 0.5f * (currentLength - length) * do1;
moveVector.x *= l;
moveVector.y *= l;
moveVector.z *= l;
soft.masses[p1].pos.x += moveVector.x;
soft.masses[p1].pos.y += moveVector.y;
soft.masses[p1].pos.z += moveVector.z;
soft.masses[p2].pos.x -= moveVector.x;
soft.masses[p2].pos.y -= moveVector.y;
soft.masses[p2].pos.z -= moveVector.z;
}
}
}
public void doCalculateSpringForce2(MegaSoft hose)
{
Vector3 deltaP = hose.masses[p1].pos - hose.masses[p2].pos;
float dist = deltaP.magnitude;
float Hterm = (dist - restlen) * ks;
Vector3 deltaV = hose.masses[p1].vel - hose.masses[p2].vel;
float Dterm = (Vector3.Dot(deltaV, deltaP) * kd) / dist;
Vector3 springForce = deltaP * (1.0f / dist);
springForce *= -(Hterm + Dterm);
hose.masses[p1].force.x += springForce.x;
hose.masses[p1].force.y += springForce.y;
hose.masses[p1].force.z += springForce.z;
hose.masses[p2].force.x -= springForce.x;
hose.masses[p2].force.y -= springForce.y;
hose.masses[p2].force.z -= springForce.z;
}
public void ReActivate(MegaSoft soft, float t)
{
tp = obj.TransformPoint(offset);
if ( !active )
{
if ( reactivate > 0.0f )
{
reactivate -= 0.01f;
//Vector3 delta = tp - soft.masses[p1].pos;
soft.masses[p1].pos = easeInOutSine(tp, ps, reactivate / rtime);
if ( reactivate < 0.0f )
{
reactivate = 0.0f;
active = true;
}
}
}
}
public virtual void Apply(MegaSoft soft)
{
}
public virtual void Apply(MegaSoft soft)
{
}
