Examples with Transform com.bulletphysics.linearmath.Transform used on opensource projects

Example 41 with Transform

use of com.bulletphysics.linearmath.Transform in project bdx by GoranM.

the class GameObject method transform.

public void transform(Matrix4f mat, boolean updateLocal) {
    activate();
    Transform t = new Transform();
    t.set(mat);
    Vector3f v = new Vector3f();
    for (int i = 0; i < 3; ++i) {
        t.basis.getColumn(i, v);
        v.normalize();
        t.basis.setColumn(i, v);
    }
    body.setWorldTransform(t);
    // required for static objects:
    body.getMotionState().setWorldTransform(t);
    if (body.isInWorld() && body.isStaticOrKinematicObject()) {
        scene.world.updateSingleAabb(body);
        for (GameObject g : touchingObjects) g.activate();
    }
    //
    updateChildTransforms();
    if (parent != null && updateLocal) {
        updateLocalTransform();
    }
}

Example 42 with Transform

use of com.bulletphysics.linearmath.Transform in project bdx by GoranM.

the class Dbvt method collideTT.

public static void collideTT(Node root0, Transform xform0, Node root1, Transform xform1, ICollide policy) {
    Stack stack = Stack.enter();
    Transform xform = stack.allocTransform();
    xform.inverse(xform0);
    xform.mul(xform1);
    collideTT(root0, root1, xform, policy);
    stack.leave();
}

Example 43 with Transform

use of com.bulletphysics.linearmath.Transform in project bdx by GoranM.

the class CompoundCollisionAlgorithm method calculateTimeOfImpact.

@Override
public float calculateTimeOfImpact(CollisionObject body0, CollisionObject body1, DispatcherInfo dispatchInfo, ManifoldResult resultOut) {
    Stack stack = Stack.enter();
    CollisionObject colObj = isSwapped ? body1 : body0;
    CollisionObject otherObj = isSwapped ? body0 : body1;
    assert (colObj.getCollisionShape().isCompound());
    CompoundShape compoundShape = (CompoundShape) colObj.getCollisionShape();
    // We will use the OptimizedBVH, AABB tree to cull potential child-overlaps
    // If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals
    // given Proxy0 and Proxy1, if both have a tree, Tree0 and Tree1, this means:
    // determine overlapping nodes of Proxy1 using Proxy0 AABB against Tree1
    // then use each overlapping node AABB against Tree0
    // and vise versa.
    Transform tmpTrans = stack.allocTransform();
    Transform orgTrans = stack.allocTransform();
    Transform childTrans = stack.allocTransform();
    float hitFraction = 1f;
    int numChildren = childCollisionAlgorithms.size();
    int i;
    for (i = 0; i < numChildren; i++) {
        // temporarily exchange parent btCollisionShape with childShape, and recurse
        CollisionShape childShape = compoundShape.getChildShape(i);
        // backup
        colObj.getWorldTransform(orgTrans);
        compoundShape.getChildTransform(i, childTrans);
        //btTransform	newChildWorldTrans = orgTrans*childTrans ;
        tmpTrans.set(orgTrans);
        tmpTrans.mul(childTrans);
        colObj.setWorldTransform(tmpTrans);
        CollisionShape tmpShape = colObj.getCollisionShape();
        colObj.internalSetTemporaryCollisionShape(childShape);
        float frac = childCollisionAlgorithms.getQuick(i).calculateTimeOfImpact(colObj, otherObj, dispatchInfo, resultOut);
        if (frac < hitFraction) {
            hitFraction = frac;
        }
        // revert back
        colObj.internalSetTemporaryCollisionShape(tmpShape);
        colObj.setWorldTransform(orgTrans);
    }
    stack.leave();
    return hitFraction;
}

Example 44 with Transform

use of com.bulletphysics.linearmath.Transform in project bdx by GoranM.

the class ConvexConcaveCollisionAlgorithm method calculateTimeOfImpact.

@Override
public float calculateTimeOfImpact(CollisionObject body0, CollisionObject body1, DispatcherInfo dispatchInfo, ManifoldResult resultOut) {
    Stack stack = Stack.enter();
    Vector3f tmp = stack.allocVector3f();
    CollisionObject convexbody = isSwapped ? body1 : body0;
    CollisionObject triBody = isSwapped ? body0 : body1;
    // quick approximation using raycast, todo: hook up to the continuous collision detection (one of the btConvexCast)
    // only perform CCD above a certain threshold, this prevents blocking on the long run
    // because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame...
    tmp.sub(convexbody.getInterpolationWorldTransform(stack.allocTransform()).origin, convexbody.getWorldTransform(stack.allocTransform()).origin);
    float squareMot0 = tmp.lengthSquared();
    if (squareMot0 < convexbody.getCcdSquareMotionThreshold()) {
        stack.leave();
        return 1f;
    }
    Transform tmpTrans = stack.allocTransform();
    //const btVector3& from = convexbody->m_worldTransform.getOrigin();
    //btVector3 to = convexbody->m_interpolationWorldTransform.getOrigin();
    //todo: only do if the motion exceeds the 'radius'
    Transform triInv = triBody.getWorldTransform(stack.allocTransform());
    triInv.inverse();
    Transform convexFromLocal = stack.allocTransform();
    convexFromLocal.mul(triInv, convexbody.getWorldTransform(tmpTrans));
    Transform convexToLocal = stack.allocTransform();
    convexToLocal.mul(triInv, convexbody.getInterpolationWorldTransform(tmpTrans));
    if (triBody.getCollisionShape().isConcave()) {
        Vector3f rayAabbMin = stack.alloc(convexFromLocal.origin);
        VectorUtil.setMin(rayAabbMin, convexToLocal.origin);
        Vector3f rayAabbMax = stack.alloc(convexFromLocal.origin);
        VectorUtil.setMax(rayAabbMax, convexToLocal.origin);
        float ccdRadius0 = convexbody.getCcdSweptSphereRadius();
        tmp.set(ccdRadius0, ccdRadius0, ccdRadius0);
        rayAabbMin.sub(tmp);
        rayAabbMax.add(tmp);
        // is this available?
        float curHitFraction = 1f;
        LocalTriangleSphereCastCallback raycastCallback = new LocalTriangleSphereCastCallback(convexFromLocal, convexToLocal, convexbody.getCcdSweptSphereRadius(), curHitFraction);
        raycastCallback.hitFraction = convexbody.getHitFraction();
        CollisionObject concavebody = triBody;
        ConcaveShape triangleMesh = (ConcaveShape) concavebody.getCollisionShape();
        if (triangleMesh != null) {
            triangleMesh.processAllTriangles(raycastCallback, rayAabbMin, rayAabbMax);
        }
        if (raycastCallback.hitFraction < convexbody.getHitFraction()) {
            convexbody.setHitFraction(raycastCallback.hitFraction);
            stack.leave();
            return raycastCallback.hitFraction;
        }
    }
    stack.leave();
    return 1f;
}

Example 45 with Transform

use of com.bulletphysics.linearmath.Transform in project bdx by GoranM.

the class ConvexTriangleCallback method processTriangle.

public void processTriangle(Vector3f[] triangle, int partId, int triangleIndex) {
    // just for debugging purposes
    //printf("triangle %d",m_triangleCount++);
    // aabb filter is already applied!	
    ci.dispatcher1 = dispatcher;
    CollisionObject ob = (CollisionObject) triBody;
    // debug drawing of the overlapping triangles
    if (dispatchInfoPtr != null && dispatchInfoPtr.debugDraw != null && dispatchInfoPtr.debugDraw.getDebugMode() > 0) {
        Stack stack = Stack.enter();
        Vector3f color = stack.allocVector3f();
        color.set(255, 255, 0);
        Transform tr = ob.getWorldTransform(stack.allocTransform());
        Vector3f tmp1 = stack.allocVector3f();
        Vector3f tmp2 = stack.allocVector3f();
        tmp1.set(triangle[0]);
        tr.transform(tmp1);
        tmp2.set(triangle[1]);
        tr.transform(tmp2);
        dispatchInfoPtr.debugDraw.drawLine(tmp1, tmp2, color);
        tmp1.set(triangle[1]);
        tr.transform(tmp1);
        tmp2.set(triangle[2]);
        tr.transform(tmp2);
        dispatchInfoPtr.debugDraw.drawLine(tmp1, tmp2, color);
        tmp1.set(triangle[2]);
        tr.transform(tmp1);
        tmp2.set(triangle[0]);
        tr.transform(tmp2);
        dispatchInfoPtr.debugDraw.drawLine(tmp1, tmp2, color);
        //btVector3 center = triangle[0] + triangle[1]+triangle[2];
        //center *= btScalar(0.333333);
        //m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]),tr(center),color);
        //m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(center),color);
        //m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(center),color);
        stack.leave();
    }
    if (convexBody.getCollisionShape().isConvex()) {
        tm.init(triangle[0], triangle[1], triangle[2]);
        tm.setMargin(collisionMarginTriangle);
        CollisionShape tmpShape = ob.getCollisionShape();
        ob.internalSetTemporaryCollisionShape(tm);
        CollisionAlgorithm colAlgo = ci.dispatcher1.findAlgorithm(convexBody, triBody, manifoldPtr);
        // this should use the btDispatcher, so the actual registered algorithm is used
        //		btConvexConvexAlgorithm cvxcvxalgo(m_manifoldPtr,ci,m_convexBody,m_triBody);
        resultOut.setShapeIdentifiers(-1, -1, partId, triangleIndex);
        //cvxcvxalgo.setShapeIdentifiers(-1,-1,partId,triangleIndex);
        //cvxcvxalgo.processCollision(m_convexBody,m_triBody,*m_dispatchInfoPtr,m_resultOut);
        colAlgo.processCollision(convexBody, triBody, dispatchInfoPtr, resultOut);
        //colAlgo.destroy();
        ci.dispatcher1.freeCollisionAlgorithm(colAlgo);
        ob.internalSetTemporaryCollisionShape(tmpShape);
    }
}