Examples with ManifoldPoint com.bulletphysics.collision.narrowphase.ManifoldPoint used on opensource projects

Example 1 with ManifoldPoint

use of com.bulletphysics.collision.narrowphase.ManifoldPoint in project jmonkeyengine by jMonkeyEngine.

the class PhysicsSpace method setContactCallbacks.

private void setContactCallbacks() {
    BulletGlobals.setContactAddedCallback(new ContactAddedCallback() {

        public boolean contactAdded(ManifoldPoint cp, com.bulletphysics.collision.dispatch.CollisionObject colObj0, int partId0, int index0, com.bulletphysics.collision.dispatch.CollisionObject colObj1, int partId1, int index1) {
            System.out.println("contact added");
            return true;
        }
    });
    BulletGlobals.setContactProcessedCallback(new ContactProcessedCallback() {

        public boolean contactProcessed(ManifoldPoint cp, Object body0, Object body1) {
            if (body0 instanceof CollisionObject && body1 instanceof CollisionObject) {
                PhysicsCollisionObject node = null, node1 = null;
                CollisionObject rBody0 = (CollisionObject) body0;
                CollisionObject rBody1 = (CollisionObject) body1;
                node = (PhysicsCollisionObject) rBody0.getUserPointer();
                node1 = (PhysicsCollisionObject) rBody1.getUserPointer();
                collisionEvents.add(eventFactory.getEvent(PhysicsCollisionEvent.TYPE_PROCESSED, node, node1, cp));
            }
            return true;
        }
    });
    BulletGlobals.setContactDestroyedCallback(new ContactDestroyedCallback() {

        public boolean contactDestroyed(Object userPersistentData) {
            System.out.println("contact destroyed");
            return true;
        }
    });
}

Example 2 with ManifoldPoint

use of com.bulletphysics.collision.narrowphase.ManifoldPoint in project bdx by GoranM.

the class ManifoldResult method addContactPoint.

public void addContactPoint(Vector3f normalOnBInWorld, Vector3f pointInWorld, float depth) {
    assert (manifoldPtr != null);
    if (depth > manifoldPtr.getContactBreakingThreshold()) {
        return;
    }
    boolean isSwapped = manifoldPtr.getBody0() != body0;
    Stack stack = Stack.enter();
    Vector3f pointA = stack.allocVector3f();
    pointA.scaleAdd(depth, normalOnBInWorld, pointInWorld);
    Vector3f localA = stack.allocVector3f();
    Vector3f localB = stack.allocVector3f();
    if (isSwapped) {
        rootTransB.invXform(pointA, localA);
        rootTransA.invXform(pointInWorld, localB);
    } else {
        rootTransA.invXform(pointA, localA);
        rootTransB.invXform(pointInWorld, localB);
    }
    ManifoldPoint newPt = pointsPool.get();
    newPt.init(localA, localB, normalOnBInWorld, depth);
    newPt.positionWorldOnA.set(pointA);
    newPt.positionWorldOnB.set(pointInWorld);
    int insertIndex = manifoldPtr.getCacheEntry(newPt);
    newPt.combinedFriction = calculateCombinedFriction(body0, body1);
    newPt.combinedRestitution = calculateCombinedRestitution(body0, body1);
    // BP mod, store contact triangles.
    newPt.partId0 = partId0;
    newPt.partId1 = partId1;
    newPt.index0 = index0;
    newPt.index1 = index1;
    /// todo, check this for any side effects
    if (insertIndex >= 0) {
        //const btManifoldPoint& oldPoint = m_manifoldPtr->getContactPoint(insertIndex);
        manifoldPtr.replaceContactPoint(newPt, insertIndex);
    } else {
        insertIndex = manifoldPtr.addManifoldPoint(newPt);
    }
    // User can override friction and/or restitution
    if (BulletGlobals.getContactAddedCallback() != null && // and if either of the two bodies requires custom material
    ((body0.getCollisionFlags() & CollisionFlags.CUSTOM_MATERIAL_CALLBACK) != 0 || (body1.getCollisionFlags() & CollisionFlags.CUSTOM_MATERIAL_CALLBACK) != 0)) {
        //experimental feature info, for per-triangle material etc.
        CollisionObject obj0 = isSwapped ? body1 : body0;
        CollisionObject obj1 = isSwapped ? body0 : body1;
        BulletGlobals.getContactAddedCallback().contactAdded(manifoldPtr.getContactPoint(insertIndex), obj0, partId0, index0, obj1, partId1, index1);
    }
    pointsPool.release(newPt);
    stack.leave();
}

Example 3 with ManifoldPoint

use of com.bulletphysics.collision.narrowphase.ManifoldPoint in project bdx by GoranM.

the class SequentialImpulseConstraintSolver method solveGroupCacheFriendlySetup.

public float solveGroupCacheFriendlySetup(ObjectArrayList<CollisionObject> bodies, int numBodies, ObjectArrayList<PersistentManifold> manifoldPtr, int manifold_offset, int numManifolds, ObjectArrayList<TypedConstraint> constraints, int constraints_offset, int numConstraints, ContactSolverInfo infoGlobal, IDebugDraw debugDrawer) /*,btStackAlloc* stackAlloc*/
{
    BulletStats.pushProfile("solveGroupCacheFriendlySetup");
    Stack stack = Stack.enter();
    int sp = stack.getSp();
    try {
        if ((numConstraints + numManifolds) == 0) {
            // printf("empty\n");
            return 0f;
        }
        PersistentManifold manifold = null;
        CollisionObject colObj0 = null, colObj1 = null;
        //btRigidBody* rb0=0,*rb1=0;
        //	//#ifdef FORCE_REFESH_CONTACT_MANIFOLDS
        //
        //		BEGIN_PROFILE("refreshManifolds");
        //
        //		int i;
        //
        //
        //
        //		for (i=0;i<numManifolds;i++)
        //		{
        //			manifold = manifoldPtr[i];
        //			rb1 = (btRigidBody*)manifold->getBody1();
        //			rb0 = (btRigidBody*)manifold->getBody0();
        //
        //			manifold->refreshContactPoints(rb0->getCenterOfMassTransform(),rb1->getCenterOfMassTransform());
        //
        //		}
        //
        //		END_PROFILE("refreshManifolds");
        //	//#endif //FORCE_REFESH_CONTACT_MANIFOLDS
        Transform tmpTrans = stack.allocTransform();
        //int sizeofSB = sizeof(btSolverBody);
        //int sizeofSC = sizeof(btSolverConstraint);
        //if (1)
        {
            //if m_stackAlloc, try to pack bodies/constraints to speed up solving
            //		btBlock*					sablock;
            //		sablock = stackAlloc->beginBlock();
            //	int memsize = 16;
            //		unsigned char* stackMemory = stackAlloc->allocate(memsize);
            // todo: use stack allocator for this temp memory
            //int minReservation = numManifolds * 2;
            //m_tmpSolverBodyPool.reserve(minReservation);
            //don't convert all bodies, only the one we need so solver the constraints
            /*
				{
				for (int i=0;i<numBodies;i++)
				{
				btRigidBody* rb = btRigidBody::upcast(bodies[i]);
				if (rb && 	(rb->getIslandTag() >= 0))
				{
				btAssert(rb->getCompanionId() < 0);
				int solverBodyId = m_tmpSolverBodyPool.size();
				btSolverBody& solverBody = m_tmpSolverBodyPool.expand();
				initSolverBody(&solverBody,rb);
				rb->setCompanionId(solverBodyId);
				} 
				}
				}
				*/
            //m_tmpSolverConstraintPool.reserve(minReservation);
            //m_tmpSolverFrictionConstraintPool.reserve(minReservation);
            {
                int i;
                Vector3f rel_pos1 = stack.allocVector3f();
                Vector3f rel_pos2 = stack.allocVector3f();
                Vector3f pos1 = stack.allocVector3f();
                Vector3f pos2 = stack.allocVector3f();
                Vector3f vel = stack.allocVector3f();
                Vector3f torqueAxis0 = stack.allocVector3f();
                Vector3f torqueAxis1 = stack.allocVector3f();
                Vector3f vel1 = stack.allocVector3f();
                Vector3f vel2 = stack.allocVector3f();
                Vector3f frictionDir1 = stack.allocVector3f();
                Vector3f frictionDir2 = stack.allocVector3f();
                Vector3f vec = stack.allocVector3f();
                Matrix3f tmpMat = stack.allocMatrix3f();
                for (i = 0; i < numManifolds; i++) {
                    manifold = manifoldPtr.getQuick(manifold_offset + i);
                    colObj0 = (CollisionObject) manifold.getBody0();
                    colObj1 = (CollisionObject) manifold.getBody1();
                    int solverBodyIdA = -1;
                    int solverBodyIdB = -1;
                    if (manifold.getNumContacts() != 0) {
                        if (colObj0.getIslandTag() >= 0) {
                            if (colObj0.getCompanionId() >= 0) {
                                // body has already been converted
                                solverBodyIdA = colObj0.getCompanionId();
                            } else {
                                solverBodyIdA = tmpSolverBodyPool.size();
                                SolverBody solverBody = bodiesPool.get();
                                tmpSolverBodyPool.add(solverBody);
                                initSolverBody(solverBody, colObj0);
                                colObj0.setCompanionId(solverBodyIdA);
                            }
                        } else {
                            // create a static body
                            solverBodyIdA = tmpSolverBodyPool.size();
                            SolverBody solverBody = bodiesPool.get();
                            tmpSolverBodyPool.add(solverBody);
                            initSolverBody(solverBody, colObj0);
                        }
                        if (colObj1.getIslandTag() >= 0) {
                            if (colObj1.getCompanionId() >= 0) {
                                solverBodyIdB = colObj1.getCompanionId();
                            } else {
                                solverBodyIdB = tmpSolverBodyPool.size();
                                SolverBody solverBody = bodiesPool.get();
                                tmpSolverBodyPool.add(solverBody);
                                initSolverBody(solverBody, colObj1);
                                colObj1.setCompanionId(solverBodyIdB);
                            }
                        } else {
                            // create a static body
                            solverBodyIdB = tmpSolverBodyPool.size();
                            SolverBody solverBody = bodiesPool.get();
                            tmpSolverBodyPool.add(solverBody);
                            initSolverBody(solverBody, colObj1);
                        }
                    }
                    float relaxation;
                    for (int j = 0; j < manifold.getNumContacts(); j++) {
                        ManifoldPoint cp = manifold.getContactPoint(j);
                        if (cp.getDistance() <= 0f) {
                            cp.getPositionWorldOnA(pos1);
                            cp.getPositionWorldOnB(pos2);
                            rel_pos1.sub(pos1, colObj0.getWorldTransform(tmpTrans).origin);
                            rel_pos2.sub(pos2, colObj1.getWorldTransform(tmpTrans).origin);
                            relaxation = 1f;
                            float rel_vel;
                            int frictionIndex = tmpSolverConstraintPool.size();
                            {
                                SolverConstraint solverConstraint = constraintsPool.get();
                                tmpSolverConstraintPool.add(solverConstraint);
                                RigidBody rb0 = RigidBody.upcast(colObj0);
                                RigidBody rb1 = RigidBody.upcast(colObj1);
                                solverConstraint.solverBodyIdA = solverBodyIdA;
                                solverConstraint.solverBodyIdB = solverBodyIdB;
                                solverConstraint.constraintType = SolverConstraintType.SOLVER_CONTACT_1D;
                                solverConstraint.originalContactPoint = cp;
                                torqueAxis0.cross(rel_pos1, cp.normalWorldOnB);
                                if (rb0 != null) {
                                    solverConstraint.angularComponentA.set(torqueAxis0);
                                    rb0.getInvInertiaTensorWorld(tmpMat).transform(solverConstraint.angularComponentA);
                                } else {
                                    solverConstraint.angularComponentA.set(0f, 0f, 0f);
                                }
                                torqueAxis1.cross(rel_pos2, cp.normalWorldOnB);
                                if (rb1 != null) {
                                    solverConstraint.angularComponentB.set(torqueAxis1);
                                    rb1.getInvInertiaTensorWorld(tmpMat).transform(solverConstraint.angularComponentB);
                                } else {
                                    solverConstraint.angularComponentB.set(0f, 0f, 0f);
                                }
                                {
                                    //#ifdef COMPUTE_IMPULSE_DENOM
                                    //btScalar denom0 = rb0->computeImpulseDenominator(pos1,cp.m_normalWorldOnB);
                                    //btScalar denom1 = rb1->computeImpulseDenominator(pos2,cp.m_normalWorldOnB);
                                    //#else							
                                    float denom0 = 0f;
                                    float denom1 = 0f;
                                    if (rb0 != null) {
                                        vec.cross(solverConstraint.angularComponentA, rel_pos1);
                                        denom0 = rb0.getInvMass() + cp.normalWorldOnB.dot(vec);
                                    }
                                    if (rb1 != null) {
                                        vec.cross(solverConstraint.angularComponentB, rel_pos2);
                                        denom1 = rb1.getInvMass() + cp.normalWorldOnB.dot(vec);
                                    }
                                    //#endif //COMPUTE_IMPULSE_DENOM		
                                    float denom = relaxation / (denom0 + denom1);
                                    solverConstraint.jacDiagABInv = denom;
                                }
                                solverConstraint.contactNormal.set(cp.normalWorldOnB);
                                solverConstraint.relpos1CrossNormal.cross(rel_pos1, cp.normalWorldOnB);
                                solverConstraint.relpos2CrossNormal.cross(rel_pos2, cp.normalWorldOnB);
                                if (rb0 != null) {
                                    rb0.getVelocityInLocalPoint(rel_pos1, vel1);
                                } else {
                                    vel1.set(0f, 0f, 0f);
                                }
                                if (rb1 != null) {
                                    rb1.getVelocityInLocalPoint(rel_pos2, vel2);
                                } else {
                                    vel2.set(0f, 0f, 0f);
                                }
                                vel.sub(vel1, vel2);
                                rel_vel = cp.normalWorldOnB.dot(vel);
                                solverConstraint.penetration = Math.min(cp.getDistance() + infoGlobal.linearSlop, 0f);
                                //solverConstraint.m_penetration = cp.getDistance();
                                solverConstraint.friction = cp.combinedFriction;
                                solverConstraint.restitution = restitutionCurve(rel_vel, cp.combinedRestitution);
                                if (solverConstraint.restitution <= 0f) {
                                    solverConstraint.restitution = 0f;
                                }
                                float penVel = -solverConstraint.penetration / infoGlobal.timeStep;
                                if (solverConstraint.restitution > penVel) {
                                    solverConstraint.penetration = 0f;
                                }
                                Vector3f tmp = stack.allocVector3f();
                                // warm starting (or zero if disabled)
                                if ((infoGlobal.solverMode & SolverMode.SOLVER_USE_WARMSTARTING) != 0) {
                                    solverConstraint.appliedImpulse = cp.appliedImpulse * infoGlobal.warmstartingFactor;
                                    if (rb0 != null) {
                                        tmp.scale(rb0.getInvMass(), solverConstraint.contactNormal);
                                        tmpSolverBodyPool.getQuick(solverConstraint.solverBodyIdA).internalApplyImpulse(tmp, solverConstraint.angularComponentA, solverConstraint.appliedImpulse);
                                    }
                                    if (rb1 != null) {
                                        tmp.scale(rb1.getInvMass(), solverConstraint.contactNormal);
                                        tmpSolverBodyPool.getQuick(solverConstraint.solverBodyIdB).internalApplyImpulse(tmp, solverConstraint.angularComponentB, -solverConstraint.appliedImpulse);
                                    }
                                } else {
                                    solverConstraint.appliedImpulse = 0f;
                                }
                                solverConstraint.appliedPushImpulse = 0f;
                                solverConstraint.frictionIndex = tmpSolverFrictionConstraintPool.size();
                                if (!cp.lateralFrictionInitialized) {
                                    cp.lateralFrictionDir1.scale(rel_vel, cp.normalWorldOnB);
                                    cp.lateralFrictionDir1.sub(vel, cp.lateralFrictionDir1);
                                    float lat_rel_vel = cp.lateralFrictionDir1.lengthSquared();
                                    if (//0.0f)
                                    lat_rel_vel > BulletGlobals.FLT_EPSILON) {
                                        cp.lateralFrictionDir1.scale(1f / (float) Math.sqrt(lat_rel_vel));
                                        addFrictionConstraint(cp.lateralFrictionDir1, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
                                        cp.lateralFrictionDir2.cross(cp.lateralFrictionDir1, cp.normalWorldOnB);
                                        //??
                                        cp.lateralFrictionDir2.normalize();
                                        addFrictionConstraint(cp.lateralFrictionDir2, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
                                    } else {
                                        // re-calculate friction direction every frame, todo: check if this is really needed
                                        TransformUtil.planeSpace1(cp.normalWorldOnB, cp.lateralFrictionDir1, cp.lateralFrictionDir2);
                                        addFrictionConstraint(cp.lateralFrictionDir1, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
                                        addFrictionConstraint(cp.lateralFrictionDir2, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
                                    }
                                    cp.lateralFrictionInitialized = true;
                                } else {
                                    addFrictionConstraint(cp.lateralFrictionDir1, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
                                    addFrictionConstraint(cp.lateralFrictionDir2, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation);
                                }
                                {
                                    SolverConstraint frictionConstraint1 = tmpSolverFrictionConstraintPool.getQuick(solverConstraint.frictionIndex);
                                    if ((infoGlobal.solverMode & SolverMode.SOLVER_USE_WARMSTARTING) != 0) {
                                        frictionConstraint1.appliedImpulse = cp.appliedImpulseLateral1 * infoGlobal.warmstartingFactor;
                                        if (rb0 != null) {
                                            tmp.scale(rb0.getInvMass(), frictionConstraint1.contactNormal);
                                            tmpSolverBodyPool.getQuick(solverConstraint.solverBodyIdA).internalApplyImpulse(tmp, frictionConstraint1.angularComponentA, frictionConstraint1.appliedImpulse);
                                        }
                                        if (rb1 != null) {
                                            tmp.scale(rb1.getInvMass(), frictionConstraint1.contactNormal);
                                            tmpSolverBodyPool.getQuick(solverConstraint.solverBodyIdB).internalApplyImpulse(tmp, frictionConstraint1.angularComponentB, -frictionConstraint1.appliedImpulse);
                                        }
                                    } else {
                                        frictionConstraint1.appliedImpulse = 0f;
                                    }
                                }
                                {
                                    SolverConstraint frictionConstraint2 = tmpSolverFrictionConstraintPool.getQuick(solverConstraint.frictionIndex + 1);
                                    if ((infoGlobal.solverMode & SolverMode.SOLVER_USE_WARMSTARTING) != 0) {
                                        frictionConstraint2.appliedImpulse = cp.appliedImpulseLateral2 * infoGlobal.warmstartingFactor;
                                        if (rb0 != null) {
                                            tmp.scale(rb0.getInvMass(), frictionConstraint2.contactNormal);
                                            tmpSolverBodyPool.getQuick(solverConstraint.solverBodyIdA).internalApplyImpulse(tmp, frictionConstraint2.angularComponentA, frictionConstraint2.appliedImpulse);
                                        }
                                        if (rb1 != null) {
                                            tmp.scale(rb1.getInvMass(), frictionConstraint2.contactNormal);
                                            tmpSolverBodyPool.getQuick(solverConstraint.solverBodyIdB).internalApplyImpulse(tmp, frictionConstraint2.angularComponentB, -frictionConstraint2.appliedImpulse);
                                        }
                                    } else {
                                        frictionConstraint2.appliedImpulse = 0f;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        // TODO: btContactSolverInfo info = infoGlobal;
        {
            int j;
            for (j = 0; j < numConstraints; j++) {
                TypedConstraint constraint = constraints.getQuick(constraints_offset + j);
                constraint.buildJacobian();
            }
        }
        int numConstraintPool = tmpSolverConstraintPool.size();
        int numFrictionPool = tmpSolverFrictionConstraintPool.size();
        // todo: use stack allocator for such temporarily memory, same for solver bodies/constraints
        MiscUtil.resize(orderTmpConstraintPool, numConstraintPool, 0);
        MiscUtil.resize(orderFrictionConstraintPool, numFrictionPool, 0);
        {
            int i;
            for (i = 0; i < numConstraintPool; i++) {
                orderTmpConstraintPool.set(i, i);
            }
            for (i = 0; i < numFrictionPool; i++) {
                orderFrictionConstraintPool.set(i, i);
            }
        }
        return 0f;
    } finally {
        stack.leave(sp);
        BulletStats.popProfile();
    }
}

Example 4 with ManifoldPoint

use of com.bulletphysics.collision.narrowphase.ManifoldPoint in project bdx by GoranM.

the class SequentialImpulseConstraintSolver method solveGroupCacheFriendly.

public float solveGroupCacheFriendly(ObjectArrayList<CollisionObject> bodies, int numBodies, ObjectArrayList<PersistentManifold> manifoldPtr, int manifold_offset, int numManifolds, ObjectArrayList<TypedConstraint> constraints, int constraints_offset, int numConstraints, ContactSolverInfo infoGlobal, IDebugDraw debugDrawer) /*,btStackAlloc* stackAlloc*/
{
    solveGroupCacheFriendlySetup(bodies, numBodies, manifoldPtr, manifold_offset, numManifolds, constraints, constraints_offset, numConstraints, infoGlobal, debugDrawer);
    solveGroupCacheFriendlyIterations(bodies, numBodies, manifoldPtr, manifold_offset, numManifolds, constraints, constraints_offset, numConstraints, infoGlobal, debugDrawer);
    int numPoolConstraints = tmpSolverConstraintPool.size();
    for (int j = 0; j < numPoolConstraints; j++) {
        SolverConstraint solveManifold = tmpSolverConstraintPool.getQuick(j);
        ManifoldPoint pt = (ManifoldPoint) solveManifold.originalContactPoint;
        assert (pt != null);
        pt.appliedImpulse = solveManifold.appliedImpulse;
        pt.appliedImpulseLateral1 = tmpSolverFrictionConstraintPool.getQuick(solveManifold.frictionIndex).appliedImpulse;
        pt.appliedImpulseLateral1 = tmpSolverFrictionConstraintPool.getQuick(solveManifold.frictionIndex + 1).appliedImpulse;
    // do a callback here?
    }
    if (infoGlobal.splitImpulse) {
        for (int i = 0; i < tmpSolverBodyPool.size(); i++) {
            tmpSolverBodyPool.getQuick(i).writebackVelocity(infoGlobal.timeStep);
            bodiesPool.release(tmpSolverBodyPool.getQuick(i));
        }
    } else {
        for (int i = 0; i < tmpSolverBodyPool.size(); i++) {
            tmpSolverBodyPool.getQuick(i).writebackVelocity();
            bodiesPool.release(tmpSolverBodyPool.getQuick(i));
        }
    }
    //	printf("m_tmpSolverConstraintPool.size() = %i\n",m_tmpSolverConstraintPool.size());
    /*
		printf("m_tmpSolverBodyPool.size() = %i\n",m_tmpSolverBodyPool.size());
		printf("m_tmpSolverConstraintPool.size() = %i\n",m_tmpSolverConstraintPool.size());
		printf("m_tmpSolverFrictionConstraintPool.size() = %i\n",m_tmpSolverFrictionConstraintPool.size());
		printf("m_tmpSolverBodyPool.capacity() = %i\n",m_tmpSolverBodyPool.capacity());
		printf("m_tmpSolverConstraintPool.capacity() = %i\n",m_tmpSolverConstraintPool.capacity());
		printf("m_tmpSolverFrictionConstraintPool.capacity() = %i\n",m_tmpSolverFrictionConstraintPool.capacity());
		*/
    tmpSolverBodyPool.clear();
    for (int i = 0; i < tmpSolverConstraintPool.size(); i++) {
        constraintsPool.release(tmpSolverConstraintPool.getQuick(i));
    }
    tmpSolverConstraintPool.clear();
    for (int i = 0; i < tmpSolverFrictionConstraintPool.size(); i++) {
        constraintsPool.release(tmpSolverFrictionConstraintPool.getQuick(i));
    }
    tmpSolverFrictionConstraintPool.clear();
    return 0f;
}

Example 5 with ManifoldPoint

use of com.bulletphysics.collision.narrowphase.ManifoldPoint in project bdx by GoranM.

the class GameObject method reactionForce.

public float reactionForce() {
    float force = 0;
    int totalContacts = 0;
    for (PersistentManifold m : contactManifolds) {
        int numContacts = m.getNumContacts();
        totalContacts += numContacts;
        for (int i = 0; i < numContacts; ++i) {
            ManifoldPoint p = m.getContactPoint(i);
            force += p.appliedImpulse;
        }
    }
    return totalContacts != 0 ? force / totalContacts : 0;
}