void particlesMove(struct particle_system *ps)
{
int i;
int nbparticles = ps->particles.id;
struct particle *p;
i = 0;
while(nbparticles < ps->particles.nbitems && i < ps->nbemitters) {
if(--ps->emit[i].time <= 0) {
add(ps->emit+i, &ps->particles);
ps->emit[i].time = ps->emit[i].freq;
}
i++;
}
for(i = 0; i < nbparticles; i++) {
p = (struct particle*)(ps->particles.pool) + i;
applyForces(ps, p);
if((--p->life < 0)
|| p->loc[0] > ps->maxx || p->loc[0] < ps->minx
|| p->loc[1] > ps->maxy || p->loc[1] < ps->miny
|| p->loc[2] > ps->maxz || p->loc[2] < ps->minz) {
poolDelete(&ps->particles, i);
}
}
poolFlush(&ps->particles);
}
void ParticleField::updateParticles() {
for (std::list<Particle>::iterator it = m_Particles.begin(); it != m_Particles.end(); it++) {
ci::Vec4f curParticle = it->history.back();
if (curParticle[3] < HEAT_KILL_THRESHOLD) {
it->history.pop_front();
continue;
}
if (inView(curParticle)) {
curParticle[3] = std::min(static_cast<float>(curParticle[3] + HEAT_CHANGE_RATE), 1.0f);
} else {
curParticle[3] = std::max(static_cast<float>(curParticle[3] - HEAT_CHANGE_RATE), 0.0f);
}
ci::Vec3f vel;
ci::Vec3f updatedLoc(curParticle[0], curParticle[1], curParticle[2]);
getPerlin(updatedLoc, vel);
updatedLoc += it->mult * vel * (m_CurTimeSeconds - m_LastTimeSeconds);
applyForces(updatedLoc);
curParticle[0] = updatedLoc[0];
curParticle[1] = updatedLoc[1];
curParticle[2] = updatedLoc[2];
it->history.push_back(curParticle);
if (it->history.size() > MAX_HISTORY_LENGTH) {
it->history.pop_front();
}
}
}
//===========================================================================
int cShapeMatching3dofPointer::setForcesOFF()
{
m_forceON = false;
m_lastComputedLocalForce.zero();
m_lastComputedGlobalForce.zero();
applyForces();
return 0;
}
/**
* Orchestrates physics for each tick
*/
void System::tickSimulation() {
updatePositions();
collideAndClean();
fireProjectiles();
applyForces();
updateVelocities();
}
// Function to update forces coming from a compute
void Patch::receiveForces(ParticleForceMsg *updates) {
int i;
// incrementing the counter for receiving updates
forceCount++;
// updating force information
for(i = 0; i < updates->lengthUpdates; i++){
particles[i].fx += updates->forces[i].x;
particles[i].fy += updates->forces[i].y;
particles[i].fz += updates->forces[i].z;
}
delete updates;
applyForces();
}
void Physics::update(float delta)
{
for (auto const & obj : colliders)
{
if (obj->isCollisionObject())
{
if (obj->isMover())
{
applyForces(delta, obj);
glm::vec3 &pos = obj->getVelocity() * delta + obj->getPosition();
obj->setPosition(pos.x, pos.y, pos.z);
}
}
}
}
//reduction to update forces coming from a compute
void Patch::reduceForces(CkReductionMsg *msg) {
//double d1 = CmiWallTimer();
int i, lengthUp;
forceCount=numNbrs;
int* forces = (int*)msg->getData();
lengthUp = msg->getSize()/sizeof(BigReal);
//CkPrintf("lengthup = %d numparts = %d\n",lengthUp, particles.length());
for(i = 0; i < lengthUp; i+=3){
particles[i/3].fx += forces[i];
particles[i/3].fy += forces[i+1];
particles[i/3].fz += forces[i+2];
}
applyForces();
delete msg;
//loadTime += CmiWallTimer()-d1;
}
void PS_EulerIntegrator::update(PS_Scalar dt,
const PS_ForceFields& forceFields,
size_t count,
const PS_Mass* masses,
PS_Motion* motions)
{
PS_Force* forces = &mForces.front();
applyForces(forceFields, count, masses, motions, forces);
for (size_t i = 0; i < count; ++i)
{
motions[i].velocity += (forces[i].internal + forces[i].external) * (masses[i].invertMass * dt);
motions[i].position += motions[i].velocity * dt;
}
}
void Solver::Solve(double dt)
{
for (int i = 0; i < ray.size(); i++)
ray[i]->setAABB();
if (applyg)
applyg(body);
else
applyG();
BPT.Start();
bp.sort();
BPT.End();
NPT.Start();
checkCol();
NPT.End();
applyForces(dt);
SLT.Start();
solveVelocities(dt);
SLT.End();
MVT.Start();
solvePositions(dt);
MVT.End();
clearForces();
}
void PS_VerletIntegrator::update(PS_Scalar dt,
const PS_ForceFields& forceFields,
size_t count,
const PS_Mass* masses,
PS_Motion* motions)
{
PS_Force* forces = &mForces.front();
applyForces(forceFields, count, masses, motions, forces);
PS_Vector3* oldPositions = &mOldPositions.front();
PS_Scalar dtSquared = dt * dt;
PS_Scalar dtInverted = 1 / dt;
for (size_t i = 0; i < count; ++i)
{
PS_Vector3 delta = (motions[i].position - oldPositions[i]) +
(forces[i].internal + forces[i].external) * (masses[i].invertMass * dtSquared);
oldPositions[i] = motions[i].position;
motions[i].position += delta;
motions[i].velocity = delta * dtInverted;
}
}
void Aircraft::update(float dt){
applyForces(dt);
}
