import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
@Override
public void read(JmeImporter e) throws IOException {
    super.read(e);
    InputCapsule capsule = e.getCapsule(this);
    stepHeight = capsule.readFloat("stepHeight", 1.0f);
    buildObject();
    character = new KinematicCharacterController(gObject, (ConvexShape) collisionShape.getCShape(), stepHeight);
    setGravity(capsule.readFloat("gravity", 9.8f * 3));
    setMaxSlope(capsule.readFloat("maxSlope", 1.0f));
    setFallSpeed(capsule.readFloat("fallSpeed", 55.0f));
    setJumpSpeed(capsule.readFloat("jumpSpeed", 10.0f));
    setUpAxis(capsule.readInt("upAxis", 1));
    setCcdMotionThreshold(capsule.readFloat("ccdMotionThreshold", 0));
    setCcdSweptSphereRadius(capsule.readFloat("ccdSweptSphereRadius", 0));
    setPhysicsLocation((Vector3f) capsule.readSavable("physicsLocation", new Vector3f()));
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public boolean calcPenDepth(SimplexSolverInterface simplexSolver,
											  ConvexShape pConvexA, ConvexShape pConvexB,
											  Transform transformA, Transform transformB,
											  Vector3 v, Vector3 wWitnessOnA, Vector3 wWitnessOnB,
											  IDebugDraw debugDraw/*, btStackAlloc* stackAlloc*/)
{
	float radialmargin = 0f;

	// JAVA NOTE: 2.70b1: update when GjkEpaSolver2 is ported
	
	GjkEpaSolver.Results results = new GjkEpaSolver.Results();
	if (gjkEpaSolver.collide(pConvexA, transformA,
			pConvexB, transformB,
			radialmargin/*,stackAlloc*/, results)) {
		//debugDraw->drawLine(results.witnesses[1],results.witnesses[1]+results.normal,btVector3(255,0,0));
		//resultOut->addContactPoint(results.normal,results.witnesses[1],-results.depth);
		wWitnessOnA.set(results.witnesses[0]);
		wWitnessOnB.set(results.witnesses[1]);
		return true;
	}

	return false;
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public KinematicCharacterController (PairCachingGhostObject ghostObject, ConvexShape convexShape, float stepHeight,
	int upAxis) {
	this.upAxis = upAxis;
	this.addedMargin = 0.02f;
	this.walkDirection.set(0, 0, 0);
	this.useGhostObjectSweepTest = true;
	this.ghostObject = ghostObject;
	this.stepHeight = stepHeight;
	this.turnAngle = 0.0f;
	this.convexShape = convexShape;
	this.useWalkDirection = true;
	this.velocityTimeInterval = 0.0f;
	this.verticalVelocity = 0.0f;
	this.verticalOffset = 0.0f;
	this.gravity = 9.8f; // 1G acceleration
	this.fallSpeed = 55.0f; // Terminal velocity of a sky diver in m/s.
	this.jumpSpeed = 10.0f; // ?
	this.wasOnGround = false;
	setMaxSlope((float)((50.0f / 180.0f) * Math.PI));
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public boolean calcPenDepth(SimplexSolverInterface simplexSolver,
											  ConvexShape pConvexA, ConvexShape pConvexB,
											  Transform transformA, Transform transformB,
											  Vector3f v, Vector3f wWitnessOnA, Vector3f wWitnessOnB,
											  IDebugDraw debugDraw/*, btStackAlloc* stackAlloc*/)
{
	float radialmargin = 0f;

	// JAVA NOTE: 2.70b1: update when GjkEpaSolver2 is ported
	
	GjkEpaSolver.Results results = new GjkEpaSolver.Results();
	if (gjkEpaSolver.collide(pConvexA, transformA,
			pConvexB, transformB,
			radialmargin/*,stackAlloc*/, results)) {
		//debugDraw->drawLine(results.witnesses[1],results.witnesses[1]+results.normal,btVector3(255,0,0));
		//resultOut->addContactPoint(results.normal,results.witnesses[1],-results.depth);
		wWitnessOnA.set(results.witnesses[0]);
		wWitnessOnB.set(results.witnesses[1]);
		return true;
	}

	return false;
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public void init(/*StackAlloc psa,*/
		Matrix3f wrot0, Vector3f pos0, ConvexShape shape0,
		Matrix3f wrot1, Vector3f pos1, ConvexShape shape1,
		float pmargin) {
	pushStack();
	wrotations[0].set(wrot0);
	positions[0].set(pos0);
	shapes[0] = shape0;
	wrotations[1].set(wrot1);
	positions[1].set(pos1);
	shapes[1] = shape1;
	//sa		=psa;
	//sablock	=sa->beginBlock();
	margin = pmargin;
	failed = false;
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public KinematicCharacterController(PairCachingGhostObject ghostObject, ConvexShape convexShape, float stepHeight, int upAxis) {
	this.upAxis = upAxis;
	this.addedMargin = 0.02f;
	this.walkDirection.set(0, 0, 0);
	this.useGhostObjectSweepTest = true;
	this.ghostObject = ghostObject;
	this.stepHeight = stepHeight;
	this.turnAngle = 0.0f;
	this.convexShape = convexShape;
	this.useWalkDirection = true;
	this.velocityTimeInterval = 0.0f;
	this.verticalVelocity = 0.0f;
	this.verticalOffset = 0.0f;
	this.gravity = 9.8f; // 1G acceleration
	this.fallSpeed = 55.0f; // Terminal velocity of a sky diver in m/s.
	this.jumpSpeed = 10.0f; // ?
	this.wasOnGround = false;
	setMaxSlope((float)((50.0f/180.0f) * Math.PI));
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public boolean calcPenDepth(SimplexSolverInterface simplexSolver,
											  ConvexShape pConvexA, ConvexShape pConvexB,
											  Transform transformA, Transform transformB,
											  Vector3f v, Vector3f wWitnessOnA, Vector3f wWitnessOnB,
											  IDebugDraw debugDraw/*, btStackAlloc* stackAlloc*/)
{
	float radialmargin = 0f;

	// JAVA NOTE: 2.70b1: update when GjkEpaSolver2 is ported
	
	GjkEpaSolver.Results results = new GjkEpaSolver.Results();
	if (GjkEpaSolver.collide(pConvexA, transformA,
			pConvexB, transformB,
			radialmargin/*,stackAlloc*/, results)) {
		//debugDraw->drawLine(results.witnesses[1],results.witnesses[1]+results.normal,btVector3(255,0,0));
		//resultOut->addContactPoint(results.normal,results.witnesses[1],-results.depth);
		wWitnessOnA.set(results.witnesses[0]);
		wWitnessOnB.set(results.witnesses[1]);
		return true;
	}

	return false;
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
private void createRigidBody(EntityRef entity) {
    LocationComponent location = entity.getComponent(LocationComponent.class);
    RigidBodyComponent rigidBody = entity.getComponent(RigidBodyComponent.class);
    ConvexShape shape = getShapeFor(entity);
    if (shape != null) {
        float scale = location.getWorldScale();
        shape.setLocalScaling(new Vector3f(scale, scale, scale));

        Vector3f fallInertia = new Vector3f();
        shape.calculateLocalInertia(rigidBody.mass, fallInertia);
        RigidBodyConstructionInfo info = new RigidBodyConstructionInfo(rigidBody.mass, new EntityMotionState(entity), shape, fallInertia);
        RigidBody collider = new RigidBody(info);
        collider.setUserPointer(entity);
        updateKinematicSettings(rigidBody, collider);
        RigidBody oldBody = entityRigidBodies.put(entity, collider);
        physics.addRigidBody(collider, Lists.<CollisionGroup>newArrayList(rigidBody.collisionGroup), rigidBody.collidesWith);
        if (oldBody != null) {
            physics.removeRigidBody(oldBody);
        }
    }
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
/**
 * @param shape The CollisionShape (no Mesh or CompoundCollisionShapes)
 * @param stepHeight The quantization size for vertical movement
 */
public PhysicsCharacter(CollisionShape shape, float stepHeight) {
    this.collisionShape = shape;
    if (!(shape.getCShape() instanceof ConvexShape)) {
        throw (new UnsupportedOperationException("Kinematic character nodes cannot have mesh collision shapes"));
    }
    this.stepHeight = stepHeight;
    buildObject();
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
@Override
public void setCollisionShape(CollisionShape collisionShape) {
    if (!(collisionShape.getCShape() instanceof ConvexShape)) {
        throw (new UnsupportedOperationException("Kinematic character nodes cannot have mesh collision shapes"));
    }
    super.setCollisionShape(collisionShape);
    if (gObject == null) {
        buildObject();
    }else{
        gObject.setCollisionShape(collisionShape.getCShape());
    }
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
/**
 * Performs a sweep collision test and returns the results as a list of PhysicsSweepTestResults<br/>
 * You have to use different Transforms for start and end (at least distance > 0.4f).
 * SweepTest will not see a collision if it starts INSIDE an object and is moving AWAY from its center.
 */
public List<PhysicsSweepTestResult> sweepTest(CollisionShape shape, Transform start, Transform end) {
    List<PhysicsSweepTestResult> results = new LinkedList<PhysicsSweepTestResult>();
    if (!(shape.getCShape() instanceof ConvexShape)) {
        Logger.getLogger(PhysicsSpace.class.getName()).log(Level.WARNING, "Trying to sweep test with incompatible mesh shape!");
        return results;
    }
    dynamicsWorld.convexSweepTest((ConvexShape) shape.getCShape(), Converter.convert(start, sweepTrans1), Converter.convert(end, sweepTrans2), new InternalSweepListener(results));
    return results;

}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public TriangleConvexcastCallback (ConvexShape convexShape, Transform convexShapeFrom, Transform convexShapeTo,
	Transform triangleToWorld, float triangleCollisionMargin) {
	this.convexShape = convexShape;
	this.convexShapeFrom.set(convexShapeFrom);
	this.convexShapeTo.set(convexShapeTo);
	this.triangleToWorld.set(triangleToWorld);
	this.hitFraction = 1f;
	this.triangleCollisionMargin = triangleCollisionMargin;
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public void init (ConvexShape objectA, ConvexShape objectB, SimplexSolverInterface simplexSolver,
	ConvexPenetrationDepthSolver penetrationDepthSolver) {
	this.cachedSeparatingAxis.set(0f, 0f, 1f);
	this.ignoreMargin = false;
	this.lastUsedMethod = -1;
	this.catchDegeneracies = 1;

	this.penetrationDepthSolver = penetrationDepthSolver;
	this.simplexSolver = simplexSolver;
	this.minkowskiA = objectA;
	this.minkowskiB = objectB;
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public void init (/* StackAlloc psa, */
	Matrix3 wrot0, Vector3 pos0, ConvexShape shape0, Matrix3 wrot1, Vector3 pos1, ConvexShape shape1, float pmargin) {
	pushStack();
	wrotations[0].set(wrot0);
	positions[0].set(pos0);
	shapes[0] = shape0;
	wrotations[1].set(wrot1);
	positions[1].set(pos1);
	shapes[1] = shape1;
	// sa =psa;
	// sablock =sa->beginBlock();
	margin = pmargin;
	failed = false;
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public BridgeTriangleConvexcastCallback (ConvexShape castShape, Transform from, Transform to,
	ConvexResultCallback resultCallback, CollisionObject collisionObject, TriangleMeshShape triangleMesh,
	Transform triangleToWorld) {
	super(castShape, from, to, triangleToWorld, triangleMesh.getMargin());
	this.resultCallback = resultCallback;
	this.collisionObject = collisionObject;
	this.triangleMesh = triangleMesh;
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public TriangleConvexcastCallback(ConvexShape convexShape, Transform convexShapeFrom, Transform convexShapeTo, Transform triangleToWorld, float triangleCollisionMargin) {
	this.convexShape = convexShape;
	this.convexShapeFrom.set(convexShapeFrom);
	this.convexShapeTo.set(convexShapeTo);
	this.triangleToWorld.set(triangleToWorld);
	this.hitFraction = 1f;
	this.triangleCollisionMargin = triangleCollisionMargin;
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public void init(ConvexShape objectA, ConvexShape objectB, SimplexSolverInterface simplexSolver, ConvexPenetrationDepthSolver penetrationDepthSolver) {
	this.cachedSeparatingAxis.set(0f, 0f, 1f);
	this.ignoreMargin = false;
	this.lastUsedMethod = -1;
	this.catchDegeneracies = 1;
	
	this.penetrationDepthSolver = penetrationDepthSolver;
	this.simplexSolver = simplexSolver;
	this.minkowskiA = objectA;
	this.minkowskiB = objectB;
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
public void initPhysics() throws Exception {
	CollisionShape groundShape = new BoxShape(new Vector3f(50, 3, 50));
	collisionShapes.add(groundShape);

	collisionConfiguration = new DefaultCollisionConfiguration();
	dispatcher = new CollisionDispatcher(collisionConfiguration);
	Vector3f worldMin = new Vector3f(-1000f,-1000f,-1000f);
	Vector3f worldMax = new Vector3f(1000f,1000f,1000f);
	AxisSweep3 sweepBP = new AxisSweep3(worldMin, worldMax);
	overlappingPairCache = sweepBP;

	constraintSolver = new SequentialImpulseConstraintSolver();
	dynamicsWorld = new DiscreteDynamicsWorld(dispatcher,overlappingPairCache,constraintSolver,collisionConfiguration);

	Transform startTransform = new Transform();
	startTransform.setIdentity();
	startTransform.origin.set(0.0f, 4.0f, 0.0f);

	ghostObject = new PairCachingGhostObject();
	ghostObject.setWorldTransform(startTransform);
	sweepBP.getOverlappingPairCache().setInternalGhostPairCallback(new GhostPairCallback());
	float characterHeight = 1.75f * characterScale;
	float characterWidth = 1.75f * characterScale;
	ConvexShape capsule = new CapsuleShape(characterWidth, characterHeight);
	ghostObject.setCollisionShape(capsule);
	ghostObject.setCollisionFlags(CollisionFlags.CHARACTER_OBJECT);

	float stepHeight = 0.35f * characterScale;
	character = new KinematicCharacterController(ghostObject, capsule, stepHeight);

	new BspToBulletConverter().convertBsp(getClass().getResourceAsStream("/com/bulletphysics/demos/bsp/exported.bsp.txt"));

	dynamicsWorld.addCollisionObject(ghostObject, CollisionFilterGroups.CHARACTER_FILTER, (short)(CollisionFilterGroups.STATIC_FILTER | CollisionFilterGroups.DEFAULT_FILTER));

	dynamicsWorld.addAction(character);
	
	clientResetScene();

	setCameraDistance(56f);
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
private void createTrigger(EntityRef entity) {
    LocationComponent location = entity.getComponent(LocationComponent.class);
    TriggerComponent trigger = entity.getComponent(TriggerComponent.class);
    ConvexShape shape = getShapeFor(entity);
    if (shape != null) {
        float scale = location.getWorldScale();
        shape.setLocalScaling(new Vector3f(scale, scale, scale));
        List<CollisionGroup> detectGroups = Lists.newArrayList(trigger.detectGroups);
        PairCachingGhostObject triggerObj = physics.createCollider(location.getWorldPosition(), shape, Lists.<CollisionGroup>newArrayList(StandardCollisionGroup.SENSOR), detectGroups, CollisionFlags.NO_CONTACT_RESPONSE);
        triggerObj.setUserPointer(entity);
        entityTriggers.put(entity, triggerObj);
    }
}
 

import com.bulletphysics.collision.shapes.ConvexShape; //导入依赖的package包/类
private ConvexShape getShapeFor(EntityRef entity) {
    BoxShapeComponent box = entity.getComponent(BoxShapeComponent.class);
    if (box != null) {
        Vector3f halfExtents = new Vector3f(box.extents);
        halfExtents.scale(0.5f);
        return new BoxShape(halfExtents);
    }
    SphereShapeComponent sphere = entity.getComponent(SphereShapeComponent.class);
    if (sphere != null) {
        return new SphereShape(sphere.radius);
    }
    CapsuleShapeComponent capsule = entity.getComponent(CapsuleShapeComponent.class);
    if (capsule != null) {
        return new CapsuleShape(capsule.radius, capsule.height);
    }
    CylinderShapeComponent cylinder = entity.getComponent(CylinderShapeComponent.class);
    if (cylinder != null) {
        return new CylinderShape(new Vector3f(cylinder.radius, 0.5f * cylinder.height, cylinder.radius));
    }
    HullShapeComponent hull = entity.getComponent(HullShapeComponent.class);
    if (hull != null) {
        ObjectArrayList<Vector3f> verts = new ObjectArrayList<Vector3f>();
        TFloatIterator iterator = hull.sourceMesh.getVertices().iterator();
        while (iterator.hasNext()) {
            Vector3f newVert = new Vector3f();
            newVert.x = iterator.next();
            newVert.y = iterator.next();
            newVert.z = iterator.next();
            verts.add(newVert);
        }
        return new ConvexHullShape(verts);
    }
    CharacterMovementComponent characterMovementComponent = entity.getComponent(CharacterMovementComponent.class);
    if (characterMovementComponent != null) {
        return new CapsuleShape(characterMovementComponent.radius, characterMovementComponent.height);
    }
    return null;
}