elchtest mod :)

[sebiastisch]

@NaN:
I'm looking at your code. I guess you have to add some synchronization to the pose not only the velocities, too. Then you have to decide which one of them integrates the velocities.

Further there is some possible problem with the velocities:
You are getting the vdrift velocities after a timestep and bullet assumes constant velocities. I solved it by calculating the velocitiy from the distance the car moved/rotated.

So, what are your concrete problems?

For your information: Here is my code for the cylinder collision detection.

Code:

void CarPhysics::UpdateWheelContacts()
{
    double bumpwave = 1;
    double bumpamp= 0.0;
    double frict_no= 1.5;
    double frict_tread=0;
    double roll_res=0.;
    double roll_drag=0;
    SURFACE::CARSURFACETYPE surface = SURFACE::ASPHALT;

    //Update the wheels!
    UpdateBulletWheelsFromVdrift();

    // some possible helpers for orientation conversion
    btQuaternion bullet_ori = chassisBody->getWorldTransform().getRotation().inverse();
    btQuaternion vdrift_ori = ( getbtQuaternion( car_dynamics->GetOrientation()));
    btQuaternion convertRotation= vdrift_ori * bullet_ori;

        if (debugGeode)
            OSGroot->removeChild(debugGeode);
    debugGeode = new osg::Geode();

    OSGroot->addChild(debugGeode);

    for (int wheel = 0; wheel < WHEEL_POSITION_SIZE; ++wheel)
    {
        int contactNum=0;
        //For (optional) averaging
        btVector3 colPoint(0,0,0);
        btVector3 colNormal(0,0,0);
        double colDepth=0;

        double minLength=10000000000.;
        double maxLength= 0;

        ////////////////////////////
        btManifoldArray   manifoldArray;
        btBroadphasePairArray& pairArray = wheel_infos[wheel]->wheelGhost->getOverlappingPairCache()->getOverlappingPairArray();
//        int numPairs = pairArray.size();
        int numPairs=  wheel_infos[wheel]->wheelGhost->getNumOverlappingObjects();
        for (int i=0;i<numPairs;i++)
        {
            manifoldArray.clear();

            const btBroadphasePair& pair = pairArray[i];

            //unless we manually perform collision detection on this pair, the contacts are in the dynamics world paircache:
            btBroadphasePair* collisionPair = m_dynamics_world->getPairCache()->findPair(pair.m_pProxy0,pair.m_pProxy1);
            if (!collisionPair)
                continue;

            if (collisionPair->m_algorithm)
                collisionPair->m_algorithm->getAllContactManifolds(manifoldArray);

            for (int j=0;j<manifoldArray.size();j++)
            {
                btPersistentManifold* manifold = manifoldArray[j];
                btScalar directionSign = manifold->getBody0() ==  wheel_infos[wheel]->wheelGhost ? btScalar(-1.0) : btScalar(1.0);
                if (directionSign>0.){
                //    cout << " QQQQQQQQ "<< endl;
                    continue; // Punkte nur in eine Richtung holen
                }
                if (manifold->getBody0() == chassisBody)
                {
                    //cout << " DAMN "<< endl;
                    continue;
                }
                for (int p=0;p<manifold->getNumContacts();p++)
                {
                    const btManifoldPoint&pt = manifold->getContactPoint(p);
                    if (pt.getDistance()<0.f)
                    {
                        const btVector3& ptA = pt.getPositionWorldOnA();
                        const btVector3& ptB = pt.getPositionWorldOnB();
                        const btVector3& normalOnB = pt.m_normalWorldOnB;
                        const float depth=(ptA-ptB).length();
                        btVector3 wheelLocalHitPos= wheel_infos[wheel]->wheelRigidbody->getCenterOfMassPosition() -ptB;
                        colPoint+= ptA*depth;
                        colNormal+= normalOnB*depth;
                        colDepth+= depth;
                        contactNum++;
                    }
                }
            }
        }
        //////////////////////////////
        ///Process the result
        if (contactNum>0)
        {
//            cout << " anzahl der kontakte für reifen " << wheel << " : "<<contactNum << endl;
            ////average
            colPoint/=colDepth;
            colNormal/=colDepth;
            colDepth/=contactNum;
            btVector3 wheelLocalHitPos= wheel_infos[wheel]->wheelRigidbody->getCenterOfMassPosition() -colPoint;
// // Get the distance from rotation axis to col point (no good: car does bounce)
//            btVector3 test (0,0,1);
//            test.rotate(wheel_infos[wheel]->wheelRigidbody->getOrientation().getAxis(),wheel_infos[wheel]->wheelRigidbody->getOrientation().getAngle());
//            test.normalize();
//            double distanceFromWheelCenter = wheelLocalHitPos.dot(test)*contactNum;

            // Fake the depth to be the distance from wheel center to the collision point
            double distanceFromWheelCenter= wheelLocalHitPos.length() ;

            colNormal.normalize();
            car_dynamics->SetWheelContactProperties(WHEEL_POSITION(wheel),    (double)distanceFromWheelCenter  ,getMATHVECTOR(colPoint), getMATHVECTOR(colNormal),bumpwave, bumpamp, frict_no, frict_tread, roll_res, roll_drag, surface);

            std::cout << "ColPoint:  " << colPoint.getX() << " " << colPoint.getY() << " " << colPoint.getZ() <<endl;
            std::cout << " Collision normal: "<< colNormal.getX() << " " << colNormal.getY() << " " << colNormal.getZ() << std::endl;
            cout << " distance from wheel center: " << "  "<<car.GetTireRadius((WHEEL_POSITION)wheel)<<" "<< distanceFromWheelCenter<<"  "<<colDepth<<"  "<<endl;
        cout << "-----------------------------------"<<endl;

        }    else
        {

            car_dynamics->SetWheelContactProperties(WHEEL_POSITION(wheel),    (double)1000,
                    MATHVECTOR<double,3>(0), MATHVECTOR<double,3>(0,0,1),
                    bumpwave, bumpamp, frict_no, frict_tread, roll_res, roll_drag, surface);
        }
    }
}

It is a mess, but I am still experimenting with different versions (getting the deepest hit depth, or using different normals, etc.)
Wheels are modeled as GhostObjects and therefore don't collide themselves, but save collisions. In the new bullet version, there must be a instant Collision check, which is preferable, but I did not yet try it.

My ray cast version looks almost identical to yours.

Edit:
world.stepSimulation(dt, maxsubsteps, dt);
makes bullet use your timestep and not interpolate to dt (thats what I understood).

Your implementation differs from mine, because I use bullet to trigger the physics tick in vdrift (it is all done in the updateAction function).
One StepSimulation is all, you have to do then.
Execution looks like follows:

Code:

void CarPhysics::updateAction( btCollisionWorld* collisionWorld, btScalar deltaTimeStep) {
    double dt= (double) deltaTimeStep *2.; // FIXME ... why is vdrift slower than bullet?
    int num_repeats= dt/internal_dt+0.5;

    /// overwrite vdrift pose/velocities with bullets calculation to integrate collision results
    UpdateInternalFromBullet();
    // Init deltaAngularVelocity (contains sum over all delta Velocities in substeps)
    deltaAngularVelocity=getVector3d(car_dynamics->GetBody().GetAngularVelocity());
    oldPosition=GetPosition();

    double old_force= force_feedback;
    force_feedback=0;

    UpdateWheelContacts(); //TODO do this in every substep (needs collision from bullet 2.76)

    /// Apply several vdrift steps (cause frequency must be very high for a vehicle
    for (int i= 0; i< num_repeats; ++i )
    {
        ///Get the new engine and so on sounds
        car.UpdateSounds(internal_dt);

        ///Use the input vector to update internal car controls (inputs has to be set by setInputVector! )
        // Input Handling differs and adds things to handling in Vdrift
        car.HandleInputsTransparent(inputs, internal_dt);

        force_feedback+= car.GetFeedback();

        //Set forward the vdrift physics
        car.TickPhysics(internal_dt);

        deltaAngularVelocity+= getVector3d(car_dynamics->GetBody().GetAngularVelocity());
    }
    force_feedback/=num_repeats;

    deltaAngularVelocity= deltaAngularVelocity/((double)num_repeats+1);

    newPosition= GetPosition();
    double dt_inv= 1. / (num_repeats*internal_dt);
    deltaVelocity= (newPosition-oldPosition) * dt_inv;

    // Update the Bullet angular and linear Velocities: This is the only connection from Vdrift to bullet
    UpdateBulletVelocities();
}