virtual void do_simulation_controller(IVP_Event_Sim *event,IVP_U_Vector<IVP_Core> *core_list) { int i; for( i = core_list->len()-1; i >=0; i--) { IVP_Core *pCore = core_list->element_at(i); IVP_Real_Object *pivp = pCore->objects.element_at(0); CPhysicsObject *pPhys = static_cast<CPhysicsObject *>(pivp->client_data); float dragForce = -0.5 * pPhys->GetDragInDirection( pCore->speed ) * m_airDensity * event->delta_time; if ( dragForce < -1.0f ) dragForce = -1.0f; if ( dragForce < 0 ) { IVP_U_Float_Point dragVelocity; dragVelocity.set_multiple( &pCore->speed, dragForce ); pCore->speed.add( &dragVelocity ); } float angDragForce = -pPhys->GetAngularDragInDirection( pCore->rot_speed ) * m_airDensity * event->delta_time; if ( angDragForce < -1.0f ) angDragForce = -1.0f; if ( angDragForce < 0 ) { IVP_U_Float_Point angDragVelocity; angDragVelocity.set_multiple( &pCore->rot_speed, angDragForce ); pCore->rot_speed.add( &angDragVelocity ); } } }
void UpdateSleepObjects( void ) { int i; CUtlVector<CPhysicsObject *> sleepObjects; for ( i = 0; i < m_activeObjects.Count(); i++ ) { CPhysicsObject *pObject = m_activeObjects[i]; if ( pObject->GetSleepState() != OBJ_AWAKE ) { sleepObjects.AddToTail( pObject ); } } for ( i = sleepObjects.Count()-1; i >= 0; --i ) { // put fully to sleep sleepObjects[i]->NotifySleep(); // remove from the active list DeleteObject( sleepObjects[i] ); } }
bool CPlayerController::IsInContact( void ) { IVP_Real_Object *pivp = m_pObject->GetObject(); if ( !pivp->flags.collision_detection_enabled ) return false; IVP_Synapse_Friction *pfriction = pivp->get_first_friction_synapse(); while ( pfriction ) { extern IVP_Real_Object *GetOppositeSynapseObject( IVP_Synapse_Friction *pfriction ); IVP_Real_Object *pobj = GetOppositeSynapseObject( pfriction ); if ( pobj->flags.collision_detection_enabled ) { // skip if this is a static object if ( !pobj->get_core()->physical_unmoveable && !pobj->get_core()->pinned ) { CPhysicsObject *pPhys = static_cast<CPhysicsObject *>(pobj->client_data); // skip if this is a shadow object // UNDONE: Is this a hack? need a better way to detect shadows? if ( !(pPhys->GetCallbackFlags() & CALLBACK_SHADOW_COLLISION) ) return true; } } pfriction = pfriction->get_next(); } return false; }
void GameObject::tick() { if (!m_HasStarted) { start(); m_HasStarted = true; } if (m_GoToNewPoint) { CPhysicsObject* physicsComponent = (CPhysicsObject*)getComponent(CPhysicsObject::classTypeID()); if (physicsComponent != 0) { b2Body* body = physicsComponent->getBody(); float angle = body->GetAngle(); body->SetTransform(m_NewPoint, angle); } m_GoToNewPoint = false; } for (map<int, Component*>::iterator it = m_Components->begin(); it != m_Components->end(); it++) { Component* component = it->second; component->tick(); } for (set<GameObject*>::iterator it = m_Children->begin(); it != m_Children->end(); it++) { GameObject* child = *it; child->tick(); } }
CPhysicsObject* CreatePhysicsSphere(CPhysicsEnvironment *pEnvironment, float radius, int materialIndex, const Vector &position, const QAngle &angles, objectparams_t *pParams, bool isStatic) { btSphereShape* shape = new btSphereShape(ConvertDistanceToBull(radius)); btVector3 vector; btMatrix3x3 matrix; ConvertPosToBull(position, vector); ConvertRotationToBull(angles, matrix); btTransform transform(matrix, vector); float mass = pParams->mass; if (isStatic) mass = 0; btMotionState* motionstate = new btMassCenterMotionState(transform); btRigidBody::btRigidBodyConstructionInfo info(mass,motionstate,shape); btRigidBody* body = new btRigidBody(info); if (mass > 0) pEnvironment->GetBulletEnvironment()->addRigidBody(body); else pEnvironment->GetBulletEnvironment()->addRigidBody(body, 2, ~2); float volume = pParams->volume; if (volume <= 0) { volume = 4.0f * radius * radius * radius * M_PI / 3.0f; } CPhysicsObject *pObject = new CPhysicsObject(); pObject->Init(pEnvironment, body, materialIndex, volume, 0, 0, NULL); pObject->SetGameData(pParams->pGameData); pObject->EnableCollisions(pParams->enableCollisions); return pObject; }
int CPlayerController::TryTeleportObject( void ) { if ( m_handler ) { Vector hlPosition; ConvertPositionToHL( m_targetPosition, hlPosition ); if ( !m_handler->ShouldMoveTo( m_pObject, hlPosition ) ) return 0; } IVP_Real_Object *pivp = m_pObject->GetObject(); IVP_U_Quat targetOrientation; IVP_U_Point outPosition; pivp->get_quat_world_f_object_AT( &targetOrientation, &outPosition ); if ( pivp->is_collision_detection_enabled() ) { m_pObject->EnableCollisions( false ); pivp->beam_object_to_new_position( &targetOrientation, &m_targetPosition, IVP_TRUE ); m_pObject->EnableCollisions( true ); } else { pivp->beam_object_to_new_position( &targetOrientation, &m_targetPosition, IVP_TRUE ); } return 1; }
void CShadowController::AttachObject( void ) { IVP_Real_Object *pivp = m_pObject->GetObject(); IVP_Core *pCore = pivp->get_core(); m_saveRot = pCore->rot_speed_damp_factor; m_savedRI = *pCore->get_rot_inertia(); m_savedMass = pCore->get_mass(); m_savedMaterialIndex = m_pObject->GetMaterialIndexInternal(); m_pObject->SetMaterialIndex( MATERIAL_INDEX_SHADOW ); pCore->rot_speed_damp_factor = IVP_U_Float_Point( 100, 100, 100 ); if ( !m_allowPhysicsRotation ) { IVP_U_Float_Point ri( 1e15f, 1e15f, 1e15f ); pCore->set_rotation_inertia( &ri ); } if ( !m_allowPhysicsMovement ) { m_pObject->SetMass( 1e6f ); //pCore->inv_rot_inertia.hesse_val = 0.0f; m_pObject->EnableGravity( false ); } pCore->calc_calc(); pivp->get_environment()->get_controller_manager()->add_controller_to_core( this, pCore ); m_shadow.lastPosition.set_to_zero(); }
void CPhysicsActor::RemoveVisualization() { // get the CPhysicsObject's name PHYSICSUSERDATA* userData = (PHYSICSUSERDATA*)m_Actor->userData; if( userData == NULL ) return; CPhysicsObject* physObj = userData->physObj; IHashString* cpoName = physObj->GetParentName(); // Remove oobb visualizations REMOVEOBJECTORIENTEDBOXPARAMS oobbParams; oobbParams.name = cpoName; static DWORD msgHash_RemoveObjectOrientedBox = CHashString(_T("RemoveObjectOrientedBox")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_RemoveObjectOrientedBox, sizeof(REMOVEOBJECTORIENTEDBOXPARAMS), &oobbParams ); // Remove aabb visualizations REMOVEAXISALIGNEDBOXPARAMS aabbParams; aabbParams.name = cpoName; static DWORD msgHash_RemoveAxisAlignedBox = CHashString(_T("RemoveAxisAlignedBox")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_RemoveAxisAlignedBox, sizeof(REMOVEAXISALIGNEDBOXPARAMS), &oobbParams ); // Remove sphere visualizations REMOVESPHEREPARAMS sphereParams; sphereParams.name = cpoName; static DWORD msgHash_RemoveSphere = CHashString(_T("RemoveSphere")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_RemoveSphere, sizeof(REMOVESPHEREPARAMS), &sphereParams ); }
void GOBall::updateVelocity() { // get desired move velocity CController* controller = (CController*)getComponent(CController::classTypeID()); float moveVelocity = controller->getMoveDirection() * VEL_MAX; // get actual velocity CPhysicsObject* physicsComponent = (CPhysicsObject*)getComponent(CPhysicsObject::classTypeID()); b2Body* body = physicsComponent->getBody(); b2Vec2 position = body->GetPosition(); b2Vec2 velocity = body->GetLinearVelocity(); // calculate difference and product float product = velocity.x * moveVelocity; float difference = moveVelocity - velocity.x; // if moving, change move velocity /*if (moveVelocity != 0) { std::cout << "MOVING\n" << std::flush; } else { std::cout << "NOT MOVING\n" << std::flush; }*/ if (moveVelocity != 0.0f && (product < 0.0f || fabs(velocity.x) < fabs(moveVelocity) )) { float force = difference * FORCE_CONST; body->ApplyForce(b2Vec2(force, 0.0f), position); } else { float force = -velocity.x * FORCE_CONST * 0.2f; body->ApplyForce(b2Vec2(force, 0.0f), position); } }
CPhysicsObject *CreatePhysicsSphere( CPhysicsEnvironment *pEnvironment, float radius, int materialIndex, const Vector &position, const QAngle &angles, objectparams_t *pParams, bool isStatic ) { IVP_U_Quat rotation; IVP_U_Point pos; ConvertRotationToIVP( angles, rotation ); ConvertPositionToIVP( position, pos ); IVP_Template_Real_Object objectTemplate; InitObjectTemplate( objectTemplate, materialIndex, pParams, isStatic ); IVP_Template_Ball ballTemplate; ballTemplate.radius = ConvertDistanceToIVP( radius ); IVP_Ball *realObject = pEnvironment->GetIVPEnvironment()->create_ball( &ballTemplate, &objectTemplate, &rotation, &pos ); float volume = pParams->volume; if ( volume <= 0 ) { volume = 4.0f * radius * radius * radius * M_PI / 3.0f; } CPhysicsObject *pObject = new CPhysicsObject(); pObject->Init( realObject, materialIndex, volume, 0, 0, NULL ); //, pParams->dragCoefficient, pParams->dragCoefficient pObject->SetGameData( pParams->pGameData ); if ( pParams->enableCollisions ) { pObject->EnableCollisions( true ); } // drag is not supported on spheres //pObject->EnableDrag( false ); // no rolling drag by default pObject->SetRollingDrag( 0 ); return pObject; }
void GOBall::kill() { m_Alive = false; CPhysicsObject* physicsComponent = (CPhysicsObject*)getComponent(CPhysicsObject::classTypeID()); physicsComponent->kill(); CGraphicsObject* graphicsComponent = (CGraphicsObject*)getComponent(CGraphicsObject::classTypeID()); graphicsComponent->kill(); }
bool CPlayerController::IsInContact() { CPhysicsEnvironment *pEnv = m_pObject->GetVPhysicsEnvironment(); int numManifolds = pEnv->GetBulletEnvironment()->getDispatcher()->getNumManifolds(); for (int i = 0; i < numManifolds; i++) { btPersistentManifold *contactManifold = pEnv->GetBulletEnvironment()->getDispatcher()->getManifoldByIndexInternal(i); const btCollisionObject *obA = contactManifold->getBody0(); const btCollisionObject *obB = contactManifold->getBody1(); CPhysicsObject *pPhysUs = NULL; CPhysicsObject *pPhysOther = NULL; if (contactManifold->getNumContacts() > 0 && (obA == m_pObject->GetObject() || obB == m_pObject->GetObject())) { if (obA == m_pObject->GetObject()) { pPhysUs = (CPhysicsObject *)obA->getUserPointer(); pPhysOther = (CPhysicsObject *)obB->getUserPointer(); } else if (obB == m_pObject->GetObject()) { pPhysUs = (CPhysicsObject *)obB->getUserPointer(); pPhysOther = (CPhysicsObject *)obA->getUserPointer(); } if (pPhysOther->IsStatic() || !pPhysOther->IsMotionEnabled() || (pPhysOther->GetCallbackFlags() & CALLBACK_SHADOW_COLLISION)) continue; return true; } } return false; }
void CPhysicsMotionController::DetachObject( IPhysicsObject *pObject ) { CPhysicsObject *pPhys = static_cast<CPhysicsObject *>(pObject); IVP_Real_Object *pIVP = pPhys->GetObject(); IVP_Core *core = pIVP->get_core(); RemoveCore(core); }
void GOBall::jump() { CController* controller = (CController*)getComponent(CController::classTypeID()); if (controller->getJump()) { CPhysicsObject* physicsComponent = (CPhysicsObject*)getComponent(CPhysicsObject::classTypeID()); b2Body* body = physicsComponent->getBody(); b2Vec2 velocity = body->GetLinearVelocity(); body->SetLinearVelocity(b2Vec2(velocity.x, JUMP_CONST)); } }
void event_object_frozen( IVP_Event_Object *pEvent ) { CPhysicsObject *pObject = static_cast<CPhysicsObject *>(pEvent->real_object->client_data); if ( !pObject ) return; pObject->NotifySleep(); if ( m_pCallback ) { m_pCallback->ObjectSleep( pObject ); } }
void CPhysicsSpring::AttachListener() { if ( !(m_pObjStart->GetCallbackFlags() & CALLBACK_NEVER_DELETED) ) { m_pObjStart->GetObject()->add_listener_object( this ); } if ( !(m_pObjEnd->GetCallbackFlags() & CALLBACK_NEVER_DELETED) ) { m_pObjEnd->GetObject()->add_listener_object( this ); } }
void Tick() { btDiscreteDynamicsWorld *pBulletEnv = m_pEnv->GetBulletEnvironment(); btCollisionObjectArray &colObjArray = pBulletEnv->getCollisionObjectArray(); for (int i = 0; i < colObjArray.size(); i++) { CPhysicsObject *pObj = (CPhysicsObject *)colObjArray[i]->getUserPointer(); if (!pObj) continue; // Internal object that the game doesn't need to know about Assert(*(char *)pObj != 0xDD); // Make sure the object isn't deleted (only works in debug builds) // Don't add objects marked for delete if (pObj->GetCallbackFlags() & CALLBACK_MARKED_FOR_DELETE) { continue; } if (colObjArray[i]->getActivationState() != pObj->GetLastActivationState()) { int newState = colObjArray[i]->getActivationState(); // Not a state we want to track. if (newState == WANTS_DEACTIVATION) continue; if (m_pObjEvents) { switch (newState) { // FIXME: Objects may call objectwake twice if they go from disable_deactivation -> active_tag case DISABLE_DEACTIVATION: case ACTIVE_TAG: m_pObjEvents->ObjectWake(pObj); break; case ISLAND_SLEEPING: // Don't call ObjectSleep on DISABLE_SIMULATION on purpose. m_pObjEvents->ObjectSleep(pObj); break; } } switch (newState) { case DISABLE_DEACTIVATION: case ACTIVE_TAG: // Don't add the object twice! if (m_activeObjects.Find(pObj) == -1) m_activeObjects.AddToTail(pObj); break; case DISABLE_SIMULATION: case ISLAND_SLEEPING: m_activeObjects.FindAndRemove(pObj); break; } pObj->SetLastActivationState(newState); } } }
CPhysicsObject* CreatePhysicsObject(CPhysicsEnvironment *pEnvironment, const CPhysCollide *pCollisionModel, int materialIndex, const Vector &position, const QAngle& angles, objectparams_t *pParams, bool isStatic) { btCollisionShape* shape = (btCollisionShape*)pCollisionModel; btVector3 vector; btMatrix3x3 matrix; ConvertPosToBull(position, vector); ConvertRotationToBull(angles, matrix); btTransform transform(matrix, vector); PhysicsShapeInfo *shapeInfo = (PhysicsShapeInfo*)shape->getUserPointer(); btTransform masscenter(btMatrix3x3::getIdentity()); if (shapeInfo) masscenter.setOrigin(shapeInfo->massCenter); float mass = pParams->mass; if (isStatic) mass = 0; btVector3 inertia; shape->calculateLocalInertia(mass, inertia); btMotionState* motionstate = new btMassCenterMotionState(transform, masscenter); btRigidBody::btRigidBodyConstructionInfo info(mass,motionstate,shape,inertia); info.m_linearDamping = pParams->damping; info.m_angularDamping = pParams->rotdamping; //info.m_localInertia = btVector3(pParams->inertia, pParams->inertia, pParams->inertia); btRigidBody* body = new btRigidBody(info); if (mass > 0) pEnvironment->GetBulletEnvironment()->addRigidBody(body); else pEnvironment->GetBulletEnvironment()->addRigidBody(body, 2, ~2); CPhysicsObject *pObject = new CPhysicsObject(); pObject->Init(pEnvironment, body, materialIndex, pParams->volume, pParams->dragCoefficient, pParams->dragCoefficient, pParams->massCenterOverride); pObject->SetGameData(pParams->pGameData); pObject->EnableCollisions(pParams->enableCollisions); if (!isStatic && pParams->dragCoefficient != 0.0f) pObject->EnableDrag(true); /*if (mass > 0) { btVector3 mins, maxs; shape->getAabb(btTransform::getIdentity(), mins, maxs); float maxradius = min(min(abs(maxs.getX()), abs(maxs.getY())), abs(maxs.getZ())); float minradius = min(min(abs(mins.getX()), abs(mins.getY())), abs(mins.getZ())); float radius = min(maxradius,minradius)/2.0f; body->setCcdMotionThreshold(radius*0.5f); body->setCcdSweptSphereRadius(0.2f*radius); }*/ return pObject; }
void CPhysicsSpring::DetachListener() { if ( !(m_pObjStart->GetCallbackFlags() & CALLBACK_NEVER_DELETED) ) { m_pObjStart->GetObject()->remove_listener_object( this ); } if ( !(m_pObjEnd->GetCallbackFlags() & CALLBACK_NEVER_DELETED) ) { m_pObjEnd->GetObject()->remove_listener_object( this ); } m_pObjStart = NULL; m_pObjEnd = NULL; m_pSpring = NULL; }
CPhysicsObject *CreatePhysicsObject(CPhysicsEnvironment *pEnvironment, const CPhysCollide *pCollisionModel, int materialIndex, const Vector &position, const QAngle &angles, objectparams_t *pParams, bool isStatic) { if (!pCollisionModel) return NULL; // Some checks Assert(position.IsValid() && angles.IsValid()); btCollisionShape *pShape = (btCollisionShape *)pCollisionModel->GetCollisionShape(); btTransform massCenterTrans = btTransform::getIdentity(); massCenterTrans.setOrigin(pCollisionModel->GetMassCenter()); btMassCenterMotionState *pMotionState = new btMassCenterMotionState(massCenterTrans); btVector3 bullPos; btMatrix3x3 bullMatrix; ConvertPosToBull(position, bullPos); ConvertRotationToBull(angles, bullMatrix); btTransform initialWordTrans(bullMatrix, bullPos); pMotionState->setGraphicTransform(initialWordTrans); // Grab some parameters btScalar mass = 0.f; btVector3 inertia(0, 0, 0); btVector3 inertiaCoeff(1, 1, 1); if (pParams && !isStatic) { mass = pParams->mass; // TODO: Grab massCenterOverride and set it up correctly. // Don't allow the inertia coefficient to be less than 0! if (pParams->inertia >= 0) inertiaCoeff.setValue(pParams->inertia, pParams->inertia, pParams->inertia); pShape->calculateLocalInertia(mass, inertia); //inertia = pCollisionModel->GetRotationInertia(); //inertia *= inertiaCoeff * mass; } btRigidBody::btRigidBodyConstructionInfo info(mass, pMotionState, pShape, inertia); btRigidBody *pBody = new btRigidBody(info); CPhysicsObject *pObject = new CPhysicsObject(); pObject->Init(pEnvironment, pBody, materialIndex, pParams, isStatic); return pObject; }
void event_object_revived( IVP_Event_Object *pEvent ) { CPhysicsObject *pObject = static_cast<CPhysicsObject *>(pEvent->real_object->client_data); if ( !pObject ) return; int sleepState = pObject->GetSleepState(); pObject->NotifyWake(); // asleep, but already in active list if ( sleepState == OBJ_STARTSLEEP ) return; // don't track static objects (like the world). That way we only track objects that will move if ( pObject->GetObject()->get_movement_state() != IVP_MT_STATIC ) { Assert(pObject->GetActiveIndex()==0xFFFF); if ( pObject->GetActiveIndex()!=0xFFFF) return; int index = m_activeObjects.AddToTail( pObject ); pObject->SetActiveIndex( index ); } if ( m_pCallback ) { m_pCallback->ObjectWake( pObject ); } }
void CPhysicsSpring::GetEndpoints( Vector* worldPositionStart, Vector* worldPositionEnd ) { IVP_U_Point world_coords; if ( worldPositionStart ) { const IVP_Anchor *anchor = m_pSpring->get_actuator_anchor(0); TransformLocalToIVP( anchor->object_pos, world_coords, m_pObjStart->GetObject(), true ); ConvertPositionToHL( world_coords, *worldPositionStart ); } if ( worldPositionEnd ) { const IVP_Anchor *anchor = m_pSpring->get_actuator_anchor(1); TransformLocalToIVP( anchor->object_pos, world_coords, m_pObjEnd->GetObject(), true ); ConvertPositionToHL( world_coords, *worldPositionEnd ); } }
void CPlayerController::AttachObject( void ) { IVP_Real_Object *pivp = m_pObject->GetObject(); IVP_Core *pCore = pivp->get_core(); m_saveRot = pCore->rot_speed_damp_factor; pCore->rot_speed_damp_factor = IVP_U_Float_Point( 100, 100, 100 ); pCore->calc_calc(); pivp->get_environment()->get_controller_manager()->add_controller_to_core( this, pCore ); }
void CShadowController::DetachObject( void ) { IVP_Real_Object *pivp = m_pObject->GetObject(); IVP_Core *pCore = pivp->get_core(); pCore->rot_speed_damp_factor = m_saveRot; pCore->set_mass( m_savedMass ); pCore->set_rotation_inertia( &m_savedRI ); // this calls calc_calc() m_pObject = NULL; pivp->get_environment()->get_controller_manager()->remove_controller_from_core( this, pCore ); }
void CPlayerController::do_simulation_controller( IVP_Event_Sim *es,IVP_U_Vector<IVP_Core> *) { if ( !m_enable ) return; IVP_Real_Object *pivp = m_pObject->GetObject(); IVP_Environment *pIVPEnv = pivp->get_environment(); CPhysicsEnvironment *pVEnv = (CPhysicsEnvironment *)pIVPEnv->client_data; float psiScale = pVEnv->GetInvPSIScale(); if ( !psiScale ) return; IVP_Core *pCore = pivp->get_core(); // current situation const IVP_U_Matrix *m_world_f_core = pCore->get_m_world_f_core_PSI(); const IVP_U_Point *cur_pos_ws = m_world_f_core->get_position(); // --------------------------------------------------------- // Translation // --------------------------------------------------------- IVP_U_Float_Point delta_position; delta_position.subtract( &m_targetPosition, cur_pos_ws); if (!pivp->flags.shift_core_f_object_is_zero) { IVP_U_Float_Point shift_cs_os_ws; m_world_f_core->vmult3( pivp->get_shift_core_f_object(), &shift_cs_os_ws); delta_position.subtract( &shift_cs_os_ws ); } IVP_DOUBLE qdist = delta_position.quad_length(); // UNDONE: This is totally bogus! Measure error using last known estimate // not current position! if ( qdist > m_maxDeltaPosition * m_maxDeltaPosition ) { if ( TryTeleportObject() ) return; } // float to allow stepping if ( m_onground ) { const IVP_U_Point *pgrav = es->environment->get_gravity(); IVP_U_Float_Point gravSpeed; gravSpeed.set_multiple( pgrav, es->delta_time ); pCore->speed.subtract( &gravSpeed ); } ComputeController( pCore->speed, delta_position, m_maxSpeed, psiScale / es->delta_time, m_dampFactor ); }
void CPhysicsDragController::Tick(btScalar dt) { for(int i = 0; i < m_ents.Size(); i++) { CPhysicsObject * object = (CPhysicsObject *)m_ents[i]; Vector dragLinearFinal(0,0,0); AngularImpulse dragAngularFinal(0,0,0); Vector vel; AngularImpulse ang; object->GetVelocity(&vel, &ang); btVector3 bull_vel; ConvertPosToBull(vel, bull_vel); float dragForce = -0.5 * object->GetDragInDirection( &bull_vel ) * m_airDensity * dt; if ( dragForce < -1.0f ) { dragForce = -1.0f; } if ( dragForce < 0 ) { Vector dragLinearFinal = vel * dragForce; } btVector3 bull_angimpulse; ConvertAngularImpulseToBull(ang, bull_angimpulse); float angDragForce = -object->GetAngularDragInDirection(&bull_angimpulse) * m_airDensity * dt; if ( angDragForce < -1.0f ) { angDragForce = -1.0f; } if( angDragForce < 0) { dragAngularFinal = ang * angDragForce; } object->AddVelocity(&dragLinearFinal, &dragAngularFinal); } }
void CPlayerController::DetachObject( void ) { if ( !m_pObject ) return; IVP_Real_Object *pivp = m_pObject->GetObject(); IVP_Core *pCore = pivp->get_core(); pCore->rot_speed_damp_factor = m_saveRot; pCore->calc_calc(); m_pObject = NULL; pivp->get_environment()->get_controller_manager()->remove_controller_from_core( this, pCore ); }
void CShadowController::StepUp( float height ) { Vector step( 0, 0, height ); IVP_Real_Object *pIVP = m_pObject->GetObject(); IVP_U_Quat world_f_object; IVP_U_Point positionIVP, deltaIVP; ConvertPositionToIVP( step, deltaIVP ); pIVP->get_quat_world_f_object_AT( &world_f_object, &positionIVP ); positionIVP.add( &deltaIVP ); pIVP->beam_object_to_new_position( &world_f_object, &positionIVP, IVP_TRUE ); }
CPhysicsObject *CreatePhysicsSphere(CPhysicsEnvironment *pEnvironment, float radius, int materialIndex, const Vector &position, const QAngle &angles, objectparams_t *pParams, bool isStatic) { if (!pEnvironment) return NULL; // Some checks Assert(position.IsValid() && angles.IsValid()); // Conversion unnecessary as this is an exposed function. btSphereShape *shape = (btSphereShape *)g_PhysicsCollision.SphereToConvex(radius); btVector3 vector; btMatrix3x3 matrix; ConvertPosToBull(position, vector); ConvertRotationToBull(angles, matrix); btTransform transform(matrix, vector); float mass = 0; float volume = 0; if (pParams) { mass = isStatic ? 0 : pParams->mass; volume = pParams->volume; if (volume <= 0) { pParams->volume = (4 / 3) * M_PI * radius * radius * radius; } } btMassCenterMotionState *motionstate = new btMassCenterMotionState(); motionstate->setGraphicTransform(transform); btRigidBody::btRigidBodyConstructionInfo info(mass, motionstate, shape); btRigidBody *body = new btRigidBody(info); CPhysicsObject *pObject = new CPhysicsObject; pObject->Init(pEnvironment, body, materialIndex, pParams, isStatic, true); return pObject; }
void CPhysicsMotionController::AttachObject( IPhysicsObject *pObject ) { Assert(pObject); // BUGBUG: Sometimes restore comes back with a NULL, REVISIT if ( !pObject || pObject->IsStatic() ) return; CPhysicsObject *pPhys = static_cast<CPhysicsObject *>(pObject); IVP_Real_Object *pIVP = pPhys->GetObject(); IVP_Core *pCore = pIVP->get_core(); #if DEBUG int index = m_coreList.Find(pCore); if ( m_coreList.IsValidIndex(index) ) { Msg("Attached core twice!!!\n"); return; } #endif m_coreList.AddToTail( pCore ); pCore->add_core_controller( (IVP_Controller *)this ); }