void CollisionFace::SphereCollision(const VC3 &position, float radius, Storm3D_CollisionInfo &colinfo, bool accurate)
{
VC3 closest;
getClosestPoint(position, vertex0, vertex1, vertex2, closest);
float sqRange = closest.GetSquareRangeTo(position);
if(sqRange < radius * radius && sqRange < colinfo.range * colinfo.range)
{
colinfo.hit = true;
colinfo.range = sqrtf(sqRange);
colinfo.position = closest;
colinfo.plane_normal = plane.planenormal;
colinfo.inside_amount = radius - colinfo.range;
float planeRange = plane.GetPointRange(position);
if(planeRange < 0)
colinfo.plane_normal = -colinfo.plane_normal;
}
}
float SpotLightCalculator::getLightAmount(const VC3 &position, const IStorm3D_Terrain &terrain, float rayHeight) const
{
float squareRange = position.GetSquareRangeTo(data->position);
if(squareRange > data->squareRange)
return 0;
VC2 pdir(position.x - data->position.x, position.z - data->position.z);
VC2 sdir(data->direction.x, data->direction.z);
float pAngle = pdir.CalculateAngle();
float sAngle = sdir.CalculateAngle();
float diff = pAngle - sAngle;
//assert(diff
if(diff < -3.1415f)
diff += 3.1415f * 2;
else if(diff > 3.1415f)
diff -= 3.1415f * 2;
if(fabsf(diff) / 3.1415f * 180.f > data->fov)
return 0;
return data->getAmount(position, -diff, terrain, rayHeight);
}
void ParticlePhysics::update()
{
if(!data->physics)
return;
data->actorBaseList.clear();
data->fluidBaseList.clear();
// Update physics actors
{
for(PhysicsActorList::iterator it = data->physicsActorList.begin(); it != data->physicsActorList.end(); ++it)
{
PhysicsActor *actor = *it;
if(!actor->actor)
continue;
/*
if(actor->actor)
{
VC3 velocity;
actor->actor->getVelocity(velocity);
float len = velocity.GetLength();
if(len > 1)
{
velocity /= len;
actor->actor->setVelocity(velocity);
}
}
*/
#ifndef PHYSX_GRAVITY
if(actor->force.GetSquareLength() > 0.01f)
{
if(!actor->forceUpdate && ++actor->sleepCounter % 10 == 0)
{
VC3 currentPos;
actor->getPosition(currentPos);
VC3 currentAngular;
actor->actor->getAngularVelocity(currentAngular);
if(
currentPos.GetSquareRangeTo(actor->lastPosition1) < 0.00001f
||
currentAngular.GetSquareRangeTo(actor->lastAngular1) < 0.00001f
||
currentPos.GetSquareRangeTo(actor->lastPosition2) < 0.00001f
||
currentAngular.GetSquareRangeTo(actor->lastAngular2) < 0.00001f)
{
if(!actor->actor->isSleeping())
actor->actor->putToSleep();
}
actor->lastPosition2 = actor->lastPosition1;
actor->lastAngular2 = actor->lastAngular1;
actor->lastPosition1 = currentPos;
actor->lastAngular1 = currentAngular;
}
if(actor->forceUpdate || !actor->actor->isSleeping())
actor->actor->addVelocityChange(actor->force);
actor->force = VC3();
}
#else
if(actor->forceUpdate)
{
VC3 base;
actor->actor->getVelocity(base);
VC3 newForce = base;
newForce += actor->force;
float len = newForce.GetSquareLength();
if(len > MAX_VELOCITY * MAX_VELOCITY)
{
len = sqrtf(len);
newForce /= len;
newForce *= MAX_VELOCITY;
}
newForce -= base;
actor->actor->addVelocityChange(newForce);
{
QUAT rot;
rotateToward(VC3(0, 1.f, 0), actor->force.GetNormalized(), rot);
VC3 test(rot.x, rot.y, rot.z);
test.x += ((float)(rand() - RAND_MAX/2) / (float)RAND_MAX/2);
test.z += ((float)(rand() - RAND_MAX/2) / (float)RAND_MAX/2);
if(test.GetSquareLength() > 0.001f)
test.Normalize();
test *= 2.f;
actor->actor->setAngularVelocity(test * 2.f);
}
actor->force = VC3();
}
#endif
actor->forceUpdate = false;
}
physics::resetFluidParticleCount();
for(FluidActorList::iterator it = data->fluidActorList.begin(); it != data->fluidActorList.end(); ++it)
{
PhysicsFluid *fluid = *it;
if(!fluid->fluid)
continue;
if(fluid->addAmount)
{
fluid->fluid->addParticles(&fluid->buffer[0], fluid->addAmount);
fluid->buffer.clear();
fluid->addAmount = 0;
}
fluid->fluid->setAcceleration(fluid->acceleration);
fluid->fluid->update();
//fluid->renderFlag = false;
}
}
/*
// Meshes
{
for(MeshList::iterator it = data->meshList.begin(); it != data->meshList.end(); ++it)
{
MeshData &convex = *it;
boost::shared_ptr<PhysicsMesh> mesh = convex.mesh.lock();
if(!mesh)
continue;
filesystem::FB_FILE *fp = filesystem::fb_fopen(convex.filename.c_str(), "rb");
if(!fp)
{
physics::Cooker cooker;
cooker.cookApproxConvex(convex.filename.c_str(), convex.object);
}
else
filesystem::fb_fclose(fp);
mesh->mesh = data->physics->createConvexMesh(convex.filename.c_str());
}
data->meshList.clear();
}
*/
// Actors
{
/*
if(actorList.size() + physicsActorList.size() > MAX_ACTOR_AMOUNT)
{
boost::shared_ptr<PhysicsActor> nullActor;
return nullActor;
}
*/
bool sort = false;
int createAmount = data->actorList.size();
if(createAmount > data->maxParticleSpawnAmount)
{
createAmount = data->maxParticleSpawnAmount;
sort = true;
}
if(createAmount + data->createdActors > data->maxParticleAmount)
{
sort = true;
createAmount = data->maxParticleAmount - data->createdActors;
}
if(sort)
std::sort(data->actorList.begin(), data->actorList.end(), ActorListSorter());
// For collision test
#ifdef PHYSX_SPAWN_TEST
std::vector<BoxStruct> previousBoxes;
#endif
int index = 0;
for(ActorList::iterator it = data->actorList.begin(); it != data->actorList.end(); ++it)
{
ActorData &convex = *it;
if(convex.createDelayCounter++ >= MAX_WAIT_FOR_CREATE)
continue;
boost::shared_ptr<PhysicsActor> actor = convex.actor.lock();
if(!actor)
continue;
boost::shared_ptr<PhysicsMesh> mesh = convex.mesh.lock();
if(!mesh)
continue;
/*
//VC3 boxCenter = mesh->localPosition + actor->position;
VC3 boxCenter = mesh->localPosition;
actor->rotation.RotateVector(boxCenter);
boxCenter += actor->position;
// Test to previous tick physics
if(data->physics->checkOverlapOBB(boxCenter, mesh->size, actor->rotation, physics::PhysicsLib::CollisionStatic))
{
convex.actor.reset();
convex.mesh.reset();
continue;
}
*/
#ifdef PHYSX_SPAWN_TEST
BoxStruct currentBox;
currentBox.center.set(boxCenter.x, boxCenter.y, boxCenter.z);
currentBox.extents.set(mesh->size.x, mesh->size.y, mesh->size.z);
QUAT r = actor->rotation.GetInverse();
NxQuat quat;
quat.setXYZW(r.x, r.y, r.z, r.w);
currentBox.rotation.fromQuat(quat);
// Test to previous tick physics
if(data->physics->checkOverlapOBB(boxCenter, mesh->size, actor->rotation))
continue;
bool hit = false;
for(unsigned int i = 0; i < previousBoxes.size(); ++i)
{
const BoxStruct &b = previousBoxes[i];
if(NxBoxBoxIntersect(currentBox.extents, currentBox.center, currentBox.rotation, b.extents, b.center, b.rotation, true))
{
hit = true;
break;
}
}
if(hit)
continue;
#endif
// Don't create too many particles
if(index++ >= createAmount)
break;
/*
boost::shared_ptr<physics::ConvexActor> convexActor = data->physics->createConvexActor(mesh->mesh, actor->position);
if(convexActor)
{
convexActor->setRotation(actor->rotation);
convexActor->setVelocity(convex.velocity);
convexActor->setAngularVelocity(convex.angularVelocity);
convexActor->setMass(convex.mass);
convexActor->setCollisionGroup(2);
//convexActor->enableFeature(physics::ActorBase::DISABLE_GRAVITY, true);
actor->actor = convexActor;
}
*/
boost::shared_ptr<physics::BoxActor> boxActor = data->physics->createBoxActor(mesh->size, actor->position, mesh->localPosition);
if(boxActor)
{
++data->createdActors;
boxActor->setRotation(actor->rotation);
boxActor->setVelocity(convex.velocity);
boxActor->setAngularVelocity(convex.angularVelocity);
boxActor->setMass(convex.mass);
boxActor->setCollisionGroup(convex.collisionGroup);
#ifndef PHYSX_GRAVITY
boxActor->enableFeature(physics::ActorBase::DISABLE_GRAVITY, true);
#endif
boxActor->setIntData(convex.soundGroup);
actor->actor = boxActor;
#ifdef PHYSX_SPAWN_TEST
previousBoxes.push_back(currentBox);
#endif
}
}
int size = data->actorList.size();
for(int i = index; i < size; ++i)
{
data->actorList[i].createDelayCounter++;
}
if(index < size)
{
for(int i = 0; i < size - index; ++i)
data->actorList[i] = data->actorList[i + index];
data->actorList.resize(size - index);
}
else
data->actorList.clear();
}
// Fluids
{
for(FluidList::iterator it = data->fluidList.begin(); it != data->fluidList.end(); ++it)
{
FluidData &fluidData = *it;
boost::shared_ptr<PhysicsFluid> fluid = fluidData.fluid.lock();
if(!fluid)
continue;
boost::shared_ptr<physics::Fluid> fluidActor = data->physics->createFluid(physics::PhysicsLib::FluidType(fluidData.type), fluidData.maxParticles, fluidData.fluidStaticRestitution, fluidData.fluidStaticAdhesion, fluidData.fluidDynamicRestitution, fluidData.fluidDynamicAdhesion, fluidData.fluidDamping, fluidData.fluidStiffness, fluidData.fluidViscosity, fluidData.fluidKernelRadiusMultiplier, fluidData.fluidRestParticlesPerMeter, fluidData.fluidRestDensity, fluidData.fluidMotionLimit, fluidData.fluidPacketSizeMultiplier, fluidData.collisionGroup);
fluid->fluid = fluidActor;
fluid->lib = data;
}
data->fluidList.clear();
}
}
