bool FrustumPhysicsObject::frustumInit(unsigned int attributeIndex,short collisionFilterGroup)
{
if(attributeIndex < 0)
{
return false;
}
attributeIndex_ = attributeIndex;
collisionFilterGroup_ = collisionFilterGroup;
AttributePtr<Attribute_Camera> ptr_camera = itrCamera_3.at(attributeIndex);
btVector3 localInertia;
localInertia.setZero();
btCollisionShape* collisionShape = CollisionShapes::Instance()->getFrustumShape(attributeIndex_);
btScalar mass = static_cast<btScalar>(1);
setMassProps(mass, localInertia);
setCollisionShape(collisionShape);
btTransform world;
AttributePtr<Attribute_Spatial> ptr_spatial = itrCamera_3.at(attributeIndex_)->ptr_spatial;
AttributePtr<Attribute_Position> ptr_position = ptr_spatial->ptr_position;
world.setOrigin(convert(ptr_position->position));
world.setRotation(convert(ptr_spatial->rotation));
setWorldTransform(world);
setCollisionFlags(getCollisionFlags() | CF_NO_CONTACT_RESPONSE);
forceActivationState(DISABLE_DEACTIVATION);
return true;
}
//-----------------------------------------------------------------------
// T P h y s i c s O b j e c t
//-----------------------------------------------------------------------
TPhysicsObject::TPhysicsObject (const TString& name, ISceneNode *sceneNode,
TCollisionShape* bodyShape, float mass,
bool isSensor, bool isGhost, short groupMask, short collisionMask,
TVector3 colliderOffset) : btDefaultMotionState(),
m_name(name),
m_sceneNode(sceneNode),
m_shape(bodyShape),
m_mass(mass),
m_sensor(isSensor),
m_ghost(isGhost),
m_groupMask(groupMask),
m_collisionMask(collisionMask),
m_offset(colliderOffset)
{
m_sceneNode->OnRegisterSceneNode();
m_sceneNode->updateAbsolutePosition();
m_shape->setScale(m_sceneNode->getScale());
// calculate local intertia for dynamic objects
btVector3 localInertia(0,0,0);
if (mass != 0.f)
m_shape->calculateLocalInertia(mass,localInertia);
m_rigidBody = new btRigidBody(m_mass,this,m_shape->getShape(),localInertia);
m_rigidBody->setUserPointer(this);
if(m_sensor | m_ghost)
setCollisionFlags(getCollisionFlags() | btRigidBody::CF_NO_CONTACT_RESPONSE);
if(m_rigidBody->isStaticOrKinematicObject())
{
m_groupMask = short(btBroadphaseProxy::StaticFilter);
m_collisionMask = short(btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter);
}
else
{
m_groupMask = short(btBroadphaseProxy::DefaultFilter);
m_collisionMask = short(btBroadphaseProxy::AllFilter);
}
getApplication()->getPhysicsManager()->addPhysicsObject(this);
}
PhysicsInterface::CharacterControllerObject Bullet::createCharacterController(float height, float radius,
const Entity* entity)
{
auto ghostObject = new btPairCachingGhostObject;
auto cylinder = new btCylinderShape({radius, height * 0.5f, radius});
ghostObject->setCollisionShape(cylinder);
ghostObject->setCollisionFlags(btCollisionObject::CF_CHARACTER_OBJECT);
ghostObject->setRestitution(0.0f);
auto stepHeight = btScalar(5.0);
auto controller = new KinematicCharacterController(ghostObject, cylinder, stepHeight);
dynamicsWorld_->addCollisionObject(ghostObject, btBroadphaseProxy::CharacterFilter,
btBroadphaseProxy::StaticFilter | btBroadphaseProxy::DefaultFilter);
dynamicsWorld_->addAction(controller);
return new CharacterController(controller, ghostObject, entity);
}
bool PhysicsObject::init(unsigned int attributeIndex, short collisionFilterGroup)
{
if(attributeIndex < 0)
{
return false;
}
attributeIndex_ = attributeIndex;
collisionFilterGroup_ = collisionFilterGroup;
//Get the init data from a physics attribute
AttributePtr<Attribute_Physics> ptr_physics = itrPhysics_.at(attributeIndex);
btScalar mass = static_cast<btScalar>(ptr_physics->mass);
//Resolve mass, local inertia of the collision shape, and also the collision shape itself.
btCollisionShape* collisionShape = subClassSpecificCollisionShape();
if(collisionShape != nullptr)
{
setCollisionShape(collisionShape);
}
else
{
ERROR_MESSAGEBOX("Error in PhysicsObject::init. Expected collision shape pointer unexpectedly set to nullptr. Using default shape instead.");
setCollisionShape(CollisionShapes::Instance()->getDefaultShape());
}
btVector3 localInertia = subClassCalculateLocalInertiaHook(mass);
setMassProps(mass, localInertia); //Set inverse mass and inverse local inertia
updateInertiaTensor();
if((getCollisionFlags() & btCollisionObject::CF_STATIC_OBJECT))
{
btTransform world;
AttributePtr<Attribute_Spatial> ptr_spatial = itrPhysics_.at(attributeIndex_)->ptr_spatial;
AttributePtr<Attribute_Position> ptr_position = ptr_spatial->ptr_position;
world.setOrigin(convert(ptr_position->position));
world.setRotation(convert(ptr_spatial->rotation));
setWorldTransform(world); //Static physics objects: transform once
}
else
{
//Non-static physics objects: let a derived btMotionState handle transforms.
MotionState* customMotionState = new MotionState(attributeIndex);
setMotionState(customMotionState);
setAngularVelocity(btVector3(ptr_physics->angularVelocity.x,
ptr_physics->angularVelocity.y,
ptr_physics->angularVelocity.z));
setLinearVelocity(btVector3(ptr_physics->linearVelocity.x,
ptr_physics->linearVelocity.y,
ptr_physics->linearVelocity.z));
//Gravity is set after "addRigidBody" for non-static physics objects
}
if(ptr_physics->collisionResponse)
{
setCollisionFlags(getCollisionFlags() & ~CF_NO_CONTACT_RESPONSE); //Activate collision response
}
else
{
setCollisionFlags(getCollisionFlags() | CF_NO_CONTACT_RESPONSE); //Deactivate collision response
}
return subClassSpecificInitHook();
}
