import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
    protected void updateObject(PhysicsRigidBody rigidBody, Entity e) {
        RigidBody rigidBodyInfo = e.get(RigidBody.class);
        CustomShape collisionShapeInfo = e.get(CustomShape.class);
        rigidBody.setKinematic(rigidBodyInfo.isKinematic());
        rigidBody.setMass(rigidBodyInfo.getMass());
        //rigidBody.setFriction(rigidBodyInfo.getFriction());
        rigidBody.setRestitution(rigidBodyInfo.getRestitution());
        if(!rigidBody.getCollisionShape().equals(collisionShapeInfo.getDefinition())) {
            physicsSpace.remove(rigidBody);
            CollisionShape shape = provider.getShape(e.get(shapeType));
            rigidBody.setCollisionShape(shape);
            physicsSpace.add(rigidBody);
        }
//            rigidBody.setUserObject(e.getId()); already set?
    }
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
public void prePhysicsTick(PhysicsSpace space, float tpf) {
    warpPositions.applyChanges();
    warpPositions.forEach(entity -> {
        WarpPosition position = entity.get(WarpPosition.class);
        PhysicsRigidBody rigidBody = rigidBodies.getObject(entity.getId());
        if(rigidBody != null){
            rigidBody.setPhysicsLocation(position.getLocation());
            rigidBody.setPhysicsRotation(position.getRotation());
            entityData.removeComponent(entity.getId(), WarpPosition.class);
        }
        PhysicsGhostObject ghostObject = ghostObjects.getObject(entity.getId());
        if(ghostObject != null){
            ghostObject.setPhysicsLocation(position.getLocation());
            ghostObject.setPhysicsRotation(position.getRotation());
            entityData.removeComponent(entity.getId(), WarpPosition.class);
        }
    });
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
public void physicsTick(PhysicsSpace space, float f) {
    //get all overlapping objects and apply impulse to them
    for (Iterator<PhysicsCollisionObject> it = ghostObject.getOverlappingObjects().iterator(); it.hasNext();) {            
        PhysicsCollisionObject physicsCollisionObject = it.next();
        if (physicsCollisionObject instanceof PhysicsRigidBody) {
            PhysicsRigidBody rBody = (PhysicsRigidBody) physicsCollisionObject;
            rBody.getPhysicsLocation(vector2);
            vector2.subtractLocal(vector);
            float force = explosionRadius - vector2.length();
            force *= forceFactor;
            force = force > 0 ? force : 0;
            vector2.normalizeLocal();
            vector2.multLocal(force);
            ((PhysicsRigidBody) physicsCollisionObject).applyImpulse(vector2, Vector3f.ZERO);
        }
    }
    space.removeTickListener(this);
    space.remove(ghostObject);
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
private void scanSpatial(Spatial model) {
    AnimControl animControl = model.getControl(AnimControl.class);
    Map<Integer, List<Float>> pointsMap = null;
    if (weightThreshold == -1.0f) {
        pointsMap = RagdollUtils.buildPointMap(model);
    }

    skeleton = animControl.getSkeleton();
    skeleton.resetAndUpdate();
    for (int i = 0; i < skeleton.getRoots().length; i++) {
        Bone childBone = skeleton.getRoots()[i];
        if (childBone.getParent() == null) {
            logger.log(Level.INFO, "Found root bone in skeleton {0}", skeleton);
            baseRigidBody = new PhysicsRigidBody(new BoxCollisionShape(Vector3f.UNIT_XYZ.mult(0.1f)), 1);
            baseRigidBody.setKinematic(mode == Mode.Kinetmatic);
            boneRecursion(model, childBone, baseRigidBody, 1, pointsMap);
        }
    }
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
/**
 * @param pivotA local translation of the joint connection point in node A
 * @param pivotB local translation of the joint connection point in node B
 */
public SixDofJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Matrix3f rotA, Matrix3f rotB, boolean useLinearReferenceFrameA) {
    super(nodeA, nodeB, pivotA, pivotB);
    this.useLinearReferenceFrameA = useLinearReferenceFrameA;

    Transform transA = new Transform(Converter.convert(rotA));
    Converter.convert(pivotA, transA.origin);
    Converter.convert(rotA, transA.basis);

    Transform transB = new Transform(Converter.convert(rotB));
    Converter.convert(pivotB, transB.origin);
    Converter.convert(rotB, transB.basis);

    constraint = new Generic6DofConstraint(nodeA.getObjectId(), nodeB.getObjectId(), transA, transB, useLinearReferenceFrameA);
    gatherMotors();
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
private void addRigidBody(PhysicsRigidBody node) {
    physicsNodes.put(node.getObjectId(), node);

    //Workaround
    //It seems that adding a Kinematic RigidBody to the dynamicWorld prevent it from being non kinematic again afterward.
    //so we add it non kinematic, then set it kinematic again.
    boolean kinematic = false;
    if (node.isKinematic()) {
        kinematic = true;
        node.setKinematic(false);
    }
    dynamicsWorld.addRigidBody(node.getObjectId());
    if (kinematic) {
        node.setKinematic(true);
    }

    Logger.getLogger(PhysicsSpace.class.getName()).log(Level.INFO, "Adding RigidBody {0} to physics space.", node.getObjectId());
    if (node instanceof PhysicsVehicle) {
        Logger.getLogger(PhysicsSpace.class.getName()).log(Level.INFO, "Adding vehicle constraint {0} to physics space.", ((PhysicsVehicle) node).getVehicleId());
        ((PhysicsVehicle) node).createVehicle(this);
        dynamicsWorld.addVehicle(((PhysicsVehicle) node).getVehicleId());
    }
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
private void addRigidBody(PhysicsRigidBody node) {
        physicsNodes.put(node.getObjectId(), node);

        //Workaround
        //It seems that adding a Kinematic RigidBody to the dynamicWorld prevent it from being non kinematic again afterward.
        //so we add it non kinematic, then set it kinematic again.
        boolean kinematic = false;
        if (node.isKinematic()) {
            kinematic = true;
            node.setKinematic(false);
        }
        addRigidBody(physicsSpaceId, node.getObjectId());
        if (kinematic) {
            node.setKinematic(true);
        }

        Logger.getLogger(PhysicsSpace.class.getName()).log(Level.FINE, "Adding RigidBody {0} to physics space.", node.getObjectId());
        if (node instanceof PhysicsVehicle) {
            Logger.getLogger(PhysicsSpace.class.getName()).log(Level.FINE, "Adding vehicle constraint {0} to physics space.", Long.toHexString(((PhysicsVehicle) node).getVehicleId()));
            ((PhysicsVehicle) node).createVehicle(this);
            addVehicle(physicsSpaceId, ((PhysicsVehicle) node).getVehicleId());
//            dynamicsWorld.addVehicle(((PhysicsVehicle) node).getVehicleId());
        }
    }
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
protected void finalize() throws Throwable {
    for(;;) {
        try {
            while(physicsJoints.size() > 0) {
                remove(physicsJoints.get(0));
            }
            while(physicsNodes.size() > 0) {
                for(PhysicsRigidBody node : physicsNodes.values()) {
                    remove(node);
                    break;
                }
            }
            super.finalize();
            Logger.getLogger(this.getClass().getName()).log(Level.FINE, "Finalizing PhysicsSpace {0}", Long.toHexString(physicsSpaceId));
            finalizeNative(physicsSpaceId);
            break;
        } catch(Exception ex) {
            Logger.getLogger(PhysicsSpace.class.getName()).log(Level.SEVERE, "finalize failed.", ex);
        }
    }
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
public PhysicsRigidBody getObject(EntityId entityId) {
    PhysicsRigidBody body = customShapes.getObject(entityId);
    if(body != null){
        return body;
    }
    body = sphereShapes.getObject(entityId);
    if(body != null){
        return body;
    }
    body = boxShapes.getObject(entityId);
    return body;
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
protected PhysicsRigidBody addObject(Entity e) {
    RigidBody rigidBodyInfo = e.get(RigidBody.class);
    CollisionShape shape = provider.getShape(e.get(shapeType));
    PhysicsRigidBody rigidBody = new PhysicsRigidBody(shape, rigidBodyInfo.getMass());
    rigidBody.setMass(rigidBodyInfo.getMass());
    rigidBody.setKinematic(rigidBodyInfo.isKinematic());
    //rigidBody.setFriction(rigidBodyInfo.getFriction());
    rigidBody.setRestitution(rigidBodyInfo.getRestitution());
    rigidBody.setUserObject(e.getId());
    physicsSpace.add(rigidBody);
    return rigidBody;
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
public void prePhysicsTick(PhysicsSpace space, float tpf) {
    collidingObjects.applyChanges();
    collidingObjects.forEach(entity -> entityData.removeComponent(entity.getId(), Collision.class));
    collisionGroups.applyChanges();
    collisionGroups.forEach(entity -> {
        PhysicsRigidBody rigidBody = rigidBodies.getObject(entity.getId());
        if(rigidBody != null){
            CollisionGroup collisionGroup = entity.get(CollisionGroup.class);
            rigidBody.setCollideWithGroups(collisionGroup.getCollideWithGroups());
            rigidBody.setCollisionGroup(collisionGroup.getCollisionGroup());
        }
    });
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
public void prePhysicsTick(PhysicsSpace space, float tpf) {
    warpVelocities.applyChanges();
    warpVelocities.forEach(entity -> {
        PhysicsRigidBody rigidBody = rigidBodies.getObject(entity.getId());
        if(rigidBody != null){
            WarpVelocity warpVelocity = entity.get(WarpVelocity.class);
            rigidBody.setLinearVelocity(warpVelocity.getLinearVelocity());
            rigidBody.setAngularVelocity(warpVelocity.getAngularVelocity());
        }
        entityData.removeComponent(entity.getId(), WarpVelocity.class);
    });
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
public void prePhysicsTick(PhysicsSpace space, float tpf) {
    gravities.applyChanges();
    gravities.forEach(entity -> {
        PhysicsRigidBody rigidBody = rigidBodies.getObject(entity.getId());
        if(rigidBody != null){
            rigidBody.setGravity(entity.get(Gravity.class).getForce());
        }
    });
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
public BulletRigidBodyDebugControl(@NotNull final BulletDebugAppState debugAppState,
                                   @NotNull final PhysicsRigidBody body) {
    super(debugAppState);
    this.body = body;
    this.currentShape = body.getCollisionShape();
    this.geom = getDebugShape(body.getCollisionShape());
    this.geom.setName(body.toString());
    this.geom.setMaterial(debugAppState.getDebugBlue());
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
protected void controlUpdate(final float tpf) {

    final PhysicsRigidBody body = getBody();
    final CollisionShape shape = body.getCollisionShape();

    if (currentShape != shape) {
        final Node node = (Node) getSpatial();
        node.detachChild(geom);
        geom = getDebugShape(shape);
        node.attachChild(geom);
        currentShape = shape;
    }

    if (body.isActive()) {
        geom.setMaterial(debugAppState.getDebugMagenta());
    } else {
        geom.setMaterial(debugAppState.getDebugBlue());
    }

    final Vector3f physicsLocation = body.getPhysicsLocation(physicalLocation);
    final Quaternion physicsRotation = body.getPhysicsRotation(physicalRotation);

    applyPhysicsTransform(physicsLocation, physicsRotation);

    geom.setLocalScale(shape.getScale());
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
private void updateRigidBodies() {

        final Filter filter = getFilter();

        final Map<PhysicsRigidBody, Spatial> prevBodies = getPrevBodies();
        final Map<PhysicsRigidBody, Spatial> bodies = getBodies();

        prevBodies.putAll(bodies);
        bodies.clear();

        final Collection<PhysicsRigidBody> current = physicsSpace.getRigidBodyList();

        for (final PhysicsRigidBody object : current) {

            // copy existing spatials
            if (prevBodies.containsKey(object)) {
                bodies.put(object, prevBodies.get(object));
            } else {
                if (filter == null || filter.test(object)) {
                    //create new spatial
                    final Node node = new Node(object.toString());
                    node.addControl(new BulletRigidBodyDebugControl(this, object));
                    bodies.put(object, node);
                    debugRootNode.attachChild(node);
                }
            }
        }

        for (final Map.Entry<PhysicsRigidBody, Spatial> entry : prevBodies.entrySet()) {
            if(!bodies.containsKey(entry.getKey())) {
                entry.getValue().removeFromParent();
            }
        }

        prevBodies.clear();
    }
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
@FXThread
protected void buildForImpl(@NotNull final Object object, @Nullable final Object parent,
                            @NotNull final VBox container, @NotNull final ModelChangeConsumer changeConsumer) {

    if (object instanceof AbstractCinematicEvent) {
        build((AbstractCinematicEvent) object, container, changeConsumer);
    }  else if (object instanceof VehicleWheel) {
        build((VehicleWheel) object, container, changeConsumer);
    } else if (object instanceof Animation) {
        build((Animation) object, container, changeConsumer);
    }

    if (!(object instanceof Control)) return;

    if (object instanceof AbstractControl) {
        build((AbstractControl) object, container, changeConsumer);
    }

    super.buildForImpl(object, parent, container, changeConsumer);

    if (object instanceof SkeletonControl) {
        build((SkeletonControl) object, container, changeConsumer);
    } else if (object instanceof CharacterControl) {
        build((CharacterControl) object, container, changeConsumer);
    } else if (object instanceof RigidBodyControl) {
        build((RigidBodyControl) object, container, changeConsumer);
    } else if (object instanceof VehicleControl) {
        build((VehicleControl) object, container, changeConsumer);
    } else if (object instanceof MotionEvent) {
        build((MotionEvent) object, container, changeConsumer);
    }

    if (object instanceof PhysicsRigidBody) {
        build((PhysicsRigidBody) object, container, changeConsumer);
    }
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
public void read(JmeImporter im) throws IOException {
    super.read(im);
    InputCapsule in = im.getCapsule(this);
    this.radius = in.readFloat("radius", 1);
    this.height = in.readFloat("height", 2);
    this.mass = in.readFloat("mass", 80);
    this.physicsDamping = in.readFloat("physicsDamping", 0.9f);
    this.gravityDamping = in.readFloat("gravityDamping", 0.0f);
    this.jumpForce.set((Vector3f) in.readSavable("jumpForce", new Vector3f(0, mass * 5, 0)));
    rigidBody = new PhysicsRigidBody(getShape(), mass);
    jumpForce.set(new Vector3f(0, mass * 5, 0));
    rigidBody.setAngularFactor(0);
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
@Override
public void read(JmeImporter im) throws IOException {
    super.read(im);
    InputCapsule in = im.getCapsule(this);
    this.radius = in.readFloat("radius", 1);
    this.height = in.readFloat("height", 2);
    this.mass = in.readFloat("mass", 80);
    this.physicsDamping = in.readFloat("physicsDamping", 0.9f);
    this.jumpForce.set((Vector3f) in.readSavable("jumpForce", new Vector3f(0, mass * 5, 0)));
    rigidBody = new PhysicsRigidBody(getShape(), mass);
    jumpForce.set(new Vector3f(0, mass * 5, 0));
    rigidBody.setAngularFactor(0);
}
 

import com.jme3.bullet.objects.PhysicsRigidBody; //导入依赖的package包/类
/**
 * return the rigidBody associated to the given bone
 * @param boneName the name of the bone
 * @return the associated rigidBody.
 */
public PhysicsRigidBody getBoneRigidBody(String boneName) {
    PhysicsBoneLink link = boneLinks.get(boneName);
    if (link != null) {
        return link.rigidBody;
    }
    return null;
}