// }
// });
// }
+ private void addCollisionEvent_native(PhysicsCollisionObject node, PhysicsCollisionObject node1, long manifoldPointObjectId) {
+// System.out.println("addCollisionEvent:"+node.getObjectId()+" "+ node1.getObjectId());
+ collisionEvents.add(eventFactory.getEvent(PhysicsCollisionEvent.TYPE_PROCESSED, node, node1, manifoldPointObjectId));
+ }
/**
* updates the physics space
* @param time the current time value
private int type;
private PhysicsCollisionObject nodeA;
private PhysicsCollisionObject nodeB;
- public final Vector3f localPointA;
- public final Vector3f localPointB;
- public final Vector3f positionWorldOnB;
- public final Vector3f positionWorldOnA;
- public final Vector3f normalWorldOnB;
- public float distance1;
- public float combinedFriction;
- public float combinedRestitution;
- public int partId0;
- public int partId1;
- public int index0;
- public int index1;
- public Object userPersistentData;
- public float appliedImpulse;
- public boolean lateralFrictionInitialized;
- public float appliedImpulseLateral1;
- public float appliedImpulseLateral2;
- public int lifeTime;
- public final Vector3f lateralFrictionDir1;
- public final Vector3f lateralFrictionDir2;
+ private long manifoldPointObjectId = 0;
- public PhysicsCollisionEvent(int type, PhysicsCollisionObject nodeA, PhysicsCollisionObject nodeB) {
- this(type, nodeA, nodeB, new Vector3f(), new Vector3f(), new Vector3f(), new Vector3f(), new Vector3f(), 0, 0, 0, 0, 0, 0, 0, null, 0, false, 0, 0, 0, new Vector3f(), new Vector3f());
- }
-
- public PhysicsCollisionEvent(int type, PhysicsCollisionObject nodeA, PhysicsCollisionObject nodeB, Vector3f localPointA, Vector3f localPointB, Vector3f positionWorldOnB, Vector3f positionWorldOnA, Vector3f normalWorldOnB, float distance1, float combinedFriction, float combinedRestitution, int partId0, int partId1, int index0, int index1, Object userPersistentData, float appliedImpulse, boolean lateralFrictionInitialized, float appliedImpulseLateral1, float appliedImpulseLateral2, int lifeTime, Vector3f lateralFrictionDir1, Vector3f lateralFrictionDir2) {
+ public PhysicsCollisionEvent(int type, PhysicsCollisionObject nodeA, PhysicsCollisionObject nodeB, long manifoldPointObjectId) {
super(nodeA);
- this.type = type;
- this.nodeA = nodeA;
- this.nodeB = nodeB;
- this.localPointA = localPointA;
- this.localPointB = localPointB;
- this.positionWorldOnB = positionWorldOnB;
- this.positionWorldOnA = positionWorldOnA;
- this.normalWorldOnB = normalWorldOnB;
- this.distance1 = distance1;
- this.combinedFriction = combinedFriction;
- this.combinedRestitution = combinedRestitution;
- this.partId0 = partId0;
- this.partId1 = partId1;
- this.index0 = index0;
- this.index1 = index1;
- this.userPersistentData = userPersistentData;
- this.appliedImpulse = appliedImpulse;
- this.lateralFrictionInitialized = lateralFrictionInitialized;
- this.appliedImpulseLateral1 = appliedImpulseLateral1;
- this.appliedImpulseLateral2 = appliedImpulseLateral2;
- this.lifeTime = lifeTime;
- this.lateralFrictionDir1 = lateralFrictionDir1;
- this.lateralFrictionDir2 = lateralFrictionDir2;
+ this.manifoldPointObjectId = manifoldPointObjectId;
}
-
+
/**
* used by event factory, called when event is destroyed
*/
this.type = 0;
this.nodeA = null;
this.nodeB = null;
-// this.localPointA = null;
-// this.localPointB = null;
-// this.positionWorldOnB = null;
-// this.positionWorldOnA = null;
-// this.normalWorldOnB = null;
-// this.distance1 = null
-// this.combinedFriction = null;
-// this.combinedRestitution = null;
-// this.partId0 = null;
-// this.partId1 = null;
-// this.index0 = null;
-// this.index1 = null;
- this.userPersistentData = null;
-// this.appliedImpulse = null;
-// this.lateralFrictionInitialized = null;
-// this.appliedImpulseLateral1 = null;
-// this.appliedImpulseLateral2 = null;
-// this.lifeTime = null;
-// this.lateralFrictionDir1 = null;
-// this.lateralFrictionDir2 = null;
+ this.manifoldPointObjectId = 0;
}
/**
* used by event factory, called when event reused
*/
- public void refactor(int type, PhysicsCollisionObject source, PhysicsCollisionObject nodeB, Vector3f localPointA, Vector3f localPointB, Vector3f positionWorldOnB, Vector3f positionWorldOnA, Vector3f normalWorldOnB, float distance1, float combinedFriction, float combinedRestitution, int partId0, int partId1, int index0, int index1, Object userPersistentData, float appliedImpulse, boolean lateralFrictionInitialized, float appliedImpulseLateral1, float appliedImpulseLateral2, int lifeTime, Vector3f lateralFrictionDir1, Vector3f lateralFrictionDir2) {
+ public void refactor(int type, PhysicsCollisionObject source, PhysicsCollisionObject nodeB, long manifoldPointObjectId) {
this.source = source;
this.type = type;
this.nodeA = source;
this.nodeB = nodeB;
- this.localPointA.set(localPointA);
- this.localPointB.set(localPointB);
- this.positionWorldOnB.set(positionWorldOnB);
- this.positionWorldOnA.set(positionWorldOnA);
- this.normalWorldOnB.set(normalWorldOnB);
- this.distance1 = distance1;
- this.combinedFriction = combinedFriction;
- this.combinedRestitution = combinedRestitution;
- this.partId0 = partId0;
- this.partId1 = partId1;
- this.index0 = index0;
- this.index1 = index1;
- this.userPersistentData = userPersistentData;
- this.appliedImpulse = appliedImpulse;
- this.lateralFrictionInitialized = lateralFrictionInitialized;
- this.appliedImpulseLateral1 = appliedImpulseLateral1;
- this.appliedImpulseLateral2 = appliedImpulseLateral2;
- this.lifeTime = lifeTime;
- this.lateralFrictionDir1.set(lateralFrictionDir1);
- this.lateralFrictionDir2.set(lateralFrictionDir2);
+ this.manifoldPointObjectId = manifoldPointObjectId;
}
public int getType() {
}
public float getAppliedImpulse() {
- return appliedImpulse;
+ return getAppliedImpulse(manifoldPointObjectId);
}
+ private native float getAppliedImpulse(long manifoldPointObjectId);
public float getAppliedImpulseLateral1() {
- return appliedImpulseLateral1;
+ return getAppliedImpulseLateral1(manifoldPointObjectId);
}
+ private native float getAppliedImpulseLateral1(long manifoldPointObjectId);
public float getAppliedImpulseLateral2() {
- return appliedImpulseLateral2;
+ return getAppliedImpulseLateral2(manifoldPointObjectId);
}
+ private native float getAppliedImpulseLateral2(long manifoldPointObjectId);
public float getCombinedFriction() {
- return combinedFriction;
+ return getCombinedFriction(manifoldPointObjectId);
}
+ private native float getCombinedFriction(long manifoldPointObjectId);
public float getCombinedRestitution() {
- return combinedRestitution;
+ return getCombinedRestitution(manifoldPointObjectId);
}
+ private native float getCombinedRestitution(long manifoldPointObjectId);
public float getDistance1() {
- return distance1;
+ return getDistance1(manifoldPointObjectId);
}
+ private native float getDistance1(long manifoldPointObjectId);
public int getIndex0() {
- return index0;
+ return getIndex0(manifoldPointObjectId);
}
+ private native int getIndex0(long manifoldPointObjectId);
public int getIndex1() {
- return index1;
+ return getIndex1(manifoldPointObjectId);
}
+ private native int getIndex1(long manifoldPointObjectId);
- public Vector3f getLateralFrictionDir1() {
+ public Vector3f getLateralFrictionDir1(Vector3f lateralFrictionDir1) {
+ getLateralFrictionDir1(manifoldPointObjectId, lateralFrictionDir1);
return lateralFrictionDir1;
}
+ private native void getLateralFrictionDir1(long manifoldPointObjectId, Vector3f lateralFrictionDir1);
- public Vector3f getLateralFrictionDir2() {
+ public Vector3f getLateralFrictionDir2(Vector3f lateralFrictionDir2) {
+ getLateralFrictionDir2(manifoldPointObjectId, lateralFrictionDir2);
return lateralFrictionDir2;
}
+ private native void getLateralFrictionDir2(long manifoldPointObjectId, Vector3f lateralFrictionDir2);
public boolean isLateralFrictionInitialized() {
- return lateralFrictionInitialized;
+ return isLateralFrictionInitialized(manifoldPointObjectId);
}
+ private native boolean isLateralFrictionInitialized(long manifoldPointObjectId);
public int getLifeTime() {
- return lifeTime;
+ return getLifeTime(manifoldPointObjectId);
}
+ private native int getLifeTime(long manifoldPointObjectId);
- public Vector3f getLocalPointA() {
+ public Vector3f getLocalPointA(Vector3f localPointA) {
+ getLocalPointA(manifoldPointObjectId, localPointA);
return localPointA;
}
+ private native void getLocalPointA(long manifoldPointObjectId, Vector3f localPointA);
- public Vector3f getLocalPointB() {
+ public Vector3f getLocalPointB(Vector3f localPointB) {
+ getLocalPointB(manifoldPointObjectId, localPointB);
return localPointB;
}
+ private native void getLocalPointB(long manifoldPointObjectId, Vector3f localPointB);
- public Vector3f getNormalWorldOnB() {
+ public Vector3f getNormalWorldOnB(Vector3f normalWorldOnB) {
+ getNormalWorldOnB(manifoldPointObjectId, normalWorldOnB);
return normalWorldOnB;
}
+ private native void getNormalWorldOnB(long manifoldPointObjectId, Vector3f normalWorldOnB);
public int getPartId0() {
- return partId0;
+ return getPartId0(manifoldPointObjectId);
}
+ private native int getPartId0(long manifoldPointObjectId);
public int getPartId1() {
- return partId1;
+ return getPartId1(manifoldPointObjectId);
}
- public Vector3f getPositionWorldOnA() {
+ private native int getPartId1(long manifoldPointObjectId);
+
+ public Vector3f getPositionWorldOnA(Vector3f positionWorldOnA) {
+ getPositionWorldOnA(positionWorldOnA);
return positionWorldOnA;
}
+ private native void getPositionWorldOnA(long manifoldPointObjectId, Vector3f positionWorldOnA);
- public Vector3f getPositionWorldOnB() {
+ public Vector3f getPositionWorldOnB(Vector3f positionWorldOnB) {
+ getPositionWorldOnB(manifoldPointObjectId, positionWorldOnB);
return positionWorldOnB;
}
+ private native void getPositionWorldOnB(long manifoldPointObjectId, Vector3f positionWorldOnB);
- public Object getUserPersistentData() {
- return userPersistentData;
- }
+// public Object getUserPersistentData() {
+// return userPersistentData;
+// }
}
private ConcurrentLinkedQueue<PhysicsCollisionEvent> eventBuffer = new ConcurrentLinkedQueue<PhysicsCollisionEvent>();
- public PhysicsCollisionEvent getEvent(int type, PhysicsCollisionObject source, PhysicsCollisionObject nodeB) {
+ public PhysicsCollisionEvent getEvent(int type, PhysicsCollisionObject source, PhysicsCollisionObject nodeB, long manifoldPointObjectId) {
PhysicsCollisionEvent event = eventBuffer.poll();
if (event == null) {
- event = new PhysicsCollisionEvent(type, source, nodeB);
+ event = new PhysicsCollisionEvent(type, source, nodeB, manifoldPointObjectId);
}else{
-// event.refactor(type, source, nodeB);
+ event.refactor(type, source, nodeB, manifoldPointObjectId);
}
return event;
}
*/
public void setCollisionGroup(int collisionGroup) {
this.collisionGroup = collisionGroup;
+ if (objectId != 0) {
+ setCollisionGroup(objectId, collisionGroup);
+ }
}
/**
*/
public void addCollideWithGroup(int collisionGroup) {
this.collisionGroupsMask = this.collisionGroupsMask | collisionGroup;
+ if (objectId != 0) {
+ setCollideWithGroups(objectId, this.collisionGroupsMask);
+ }
}
/**
*/
public void removeCollideWithGroup(int collisionGroup) {
this.collisionGroupsMask = this.collisionGroupsMask & ~collisionGroup;
+ if (objectId != 0) {
+ setCollideWithGroups(this.collisionGroupsMask);
+ }
}
/**
*/
public void setCollideWithGroups(int collisionGroups) {
this.collisionGroupsMask = collisionGroups;
+ if (objectId != 0) {
+ setCollideWithGroups(objectId, this.collisionGroupsMask);
+ }
}
/**
return collisionGroupsMask;
}
+ protected void initUserPointer() {
+ Logger.getLogger(this.getClass().getName()).log(Level.INFO, "initUserPointer() objectId = {0}", Long.toHexString(objectId));
+ initUserPointer(objectId, collisionGroup, collisionGroupsMask);
+ }
+ native void initUserPointer(long objectId, int group, int groups);
/**
* Creates a visual debug shape of the current collision shape of this physics object<br/>
* <b>Does not work with detached physics, please switch to PARALLEL or SEQUENTIAL for debugging</b>
}
protected native void attachCollisionShape(long objectId, long collisionShapeId);
+ native void setCollisionGroup(long objectId, int collisionGroup);
+ native void setCollideWithGroups(long objectId, int collisionGroups);
@Override
public void write(JmeExporter e) throws IOException {
*/
public class SixDofJoint extends PhysicsJoint {
- private Matrix3f rotA, rotB;
- private boolean useLinearReferenceFrameA;
- private LinkedList<RotationalLimitMotor> rotationalMotors = new LinkedList<RotationalLimitMotor>();
- private TranslationalLimitMotor translationalMotor;
- private Vector3f angularUpperLimit = new Vector3f(Vector3f.POSITIVE_INFINITY);
- private Vector3f angularLowerLimit = new Vector3f(Vector3f.NEGATIVE_INFINITY);
- private Vector3f linearUpperLimit = new Vector3f(Vector3f.POSITIVE_INFINITY);
- private Vector3f linearLowerLimit = new Vector3f(Vector3f.NEGATIVE_INFINITY);
+ Matrix3f rotA, rotB;
+ boolean useLinearReferenceFrameA;
+ LinkedList<RotationalLimitMotor> rotationalMotors = new LinkedList<RotationalLimitMotor>();
+ TranslationalLimitMotor translationalMotor;
+ Vector3f angularUpperLimit = new Vector3f(Vector3f.POSITIVE_INFINITY);
+ Vector3f angularLowerLimit = new Vector3f(Vector3f.NEGATIVE_INFINITY);
+ Vector3f linearUpperLimit = new Vector3f(Vector3f.POSITIVE_INFINITY);
+ Vector3f linearLowerLimit = new Vector3f(Vector3f.NEGATIVE_INFINITY);
public SixDofJoint() {
}
private native void setAngularLowerLimit(long objctId, Vector3f vector);
- private native long createJoint(long objectIdA, long objectIdB, Vector3f pivotA, Matrix3f rotA, Vector3f pivotB, Matrix3f rotB, boolean useLinearReferenceFrameA);
+ native long createJoint(long objectIdA, long objectIdB, Vector3f pivotA, Matrix3f rotA, Vector3f pivotB, Matrix3f rotB, boolean useLinearReferenceFrameA);
@Override
public void read(JmeImporter im) throws IOException {
--- /dev/null
+/*
+ * Copyright (c) 2009-2010 jMonkeyEngine
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package com.jme3.bullet.joints;
+
+import com.jme3.export.JmeExporter;
+import com.jme3.export.JmeImporter;
+import com.jme3.math.Matrix3f;
+import com.jme3.math.Vector3f;
+import com.jme3.bullet.joints.motors.RotationalLimitMotor;
+import com.jme3.bullet.joints.motors.TranslationalLimitMotor;
+import com.jme3.bullet.objects.PhysicsRigidBody;
+import com.jme3.export.InputCapsule;
+import com.jme3.export.OutputCapsule;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * <i>From bullet manual:</i><br>
+ * This generic constraint can emulate a variety of standard constraints,
+ * by configuring each of the 6 degrees of freedom (dof).
+ * The first 3 dof axis are linear axis, which represent translation of rigidbodies,
+ * and the latter 3 dof axis represent the angular motion. Each axis can be either locked,
+ * free or limited. On construction of a new btGeneric6DofConstraint, all axis are locked.
+ * Afterwards the axis can be reconfigured. Note that several combinations that
+ * include free and/or limited angular degrees of freedom are undefined.
+ * @author normenhansen
+ */
+public class SixDofSpringJoint extends SixDofJoint {
+
+ final boolean springEnabled[] = new boolean[6];
+ final float equilibriumPoint[] = new float[6];
+ final float springStiffness[] = new float[6];
+ final float springDamping[] = new float[6]; // between 0 and 1 (1 == no damping)
+
+ public SixDofSpringJoint() {
+ }
+
+ /**
+ * @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 SixDofSpringJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Matrix3f rotA, Matrix3f rotB, boolean useLinearReferenceFrameA) {
+ super(nodeA, nodeB, pivotA, pivotB, rotA, rotB, useLinearReferenceFrameA);
+ }
+ public void enableSpring(int index, boolean onOff) {
+ enableSpring(objectId, index, onOff);
+ }
+ native void enableSpring(long objctId, int index, boolean onOff);
+
+ public void setStiffness(int index, float stiffness) {
+ setStiffness(objectId, index, stiffness);
+ }
+ native void setStiffness(long objctId, int index, float stiffness);
+
+ public void setDamping(int index, float damping) {
+ setDamping(objectId, index, damping);
+
+ }
+ native void setDamping(long objctId, int index, float damping);
+ public void setEquilibriumPoint() { // set the current constraint position/orientation as an equilibrium point for all DOF
+ setEquilibriumPoint(objectId);
+ }
+ native void setEquilibriumPoint(long objctId);
+ public void setEquilibriumPoint(int index){ // set the current constraint position/orientation as an equilibrium point for given DOF
+ setEquilibriumPoint(objectId, index);
+ }
+ native void setEquilibriumPoint(long objctId, int index);
+ @Override
+ native long createJoint(long objectIdA, long objectIdB, Vector3f pivotA, Matrix3f rotA, Vector3f pivotB, Matrix3f rotB, boolean useLinearReferenceFrameA);
+
+}
if (objectId == 0) {
objectId = createGhostObject();
Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Creating GhostObject {0}", Long.toHexString(objectId));
+ initUserPointer();
}
setCharacterFlags(objectId);
attachCollisionShape(objectId, collisionShape.getObjectId());
objectId = createGhostObject();
Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Ghost Object {0}", Long.toHexString(objectId));
setGhostFlags(objectId);
+ initUserPointer();
}
// if (gObject == null) {
// gObject = new PairCachingGhostObject();
private native long createGhostObject();
private native void setGhostFlags(long objectId);
-
+
@Override
public void setCollisionShape(CollisionShape collisionShape) {
super.setCollisionShape(collisionShape);
if (objectId == 0) {
buildObject();
- }else{
+ } else {
attachCollisionShape(objectId, collisionShape.getObjectId());
}
}
public void setPhysicsLocation(Vector3f location) {
setPhysicsLocation(objectId, location);
}
-
+
private native void setPhysicsLocation(long objectId, Vector3f location);
/**
public void setPhysicsRotation(Matrix3f rotation) {
setPhysicsRotation(objectId, rotation);
}
-
+
private native void setPhysicsRotation(long objectId, Matrix3f rotation);
/**
public void setPhysicsRotation(Quaternion rotation) {
setPhysicsRotation(objectId, rotation);
}
-
+
private native void setPhysicsRotation(long objectId, Quaternion rotation);
/**
getPhysicsLocation(objectId, trans);
return trans;
}
-
+
private native void getPhysicsLocation(long objectId, Vector3f vector);
/**
getPhysicsRotation(objectId, rot);
return rot;
}
-
+
private native void getPhysicsRotation(long objectId, Quaternion rot);
/**
getPhysicsRotationMatrix(objectId, rot);
return rot;
}
-
+
private native void getPhysicsRotationMatrix(long objectId, Matrix3f rot);
/**
getPhysicsLocation(objectId, vec);
return vec;
}
-
+
/**
* @return the physicsLocation
*/
// public PairCachingGhostObject getObjectId() {
// return gObject;
// }
-
/**
* destroys this PhysicsGhostNode and removes it from memory
*/
* @return All CollisionObjects overlapping with this GhostNode.
*/
public List<PhysicsCollisionObject> getOverlappingObjects() {
-// overlappingObjects.clear();
+ overlappingObjects.clear();
+ getOverlappingObjects(objectId);
// for (com.bulletphysics.collision.dispatch.CollisionObject collObj : gObject.getOverlappingPairs()) {
// overlappingObjects.add((PhysicsCollisionObject) collObj.getUserPointer());
// }
return overlappingObjects;
}
+ protected native void getOverlappingObjects(long objectId);
+
+ private void addOverlappingObject_native(PhysicsCollisionObject co) {
+ overlappingObjects.add(co);
+ }
+
/**
*
* @return With how many other CollisionObjects this GhostNode is currently overlapping.
public int getOverlappingCount() {
return getOverlappingCount(objectId);
}
-
+
private native int getOverlappingCount(long objectId);
/**
public void setCcdSweptSphereRadius(float radius) {
setCcdSweptSphereRadius(objectId, radius);
}
-
+
private native void setCcdSweptSphereRadius(long objectId, float radius);
public void setCcdMotionThreshold(float threshold) {
public float getCcdSweptSphereRadius() {
return getCcdSweptSphereRadius(objectId);
}
-
+
private native float getCcdSweptSphereRadius(long objectId);
public float getCcdMotionThreshold() {
} else {
setStatic(objectId, false);
}
+ initUserPointer();
}
/**
setCoordinateSystem(vehicleId, 0, 1, 2);
for (VehicleWheel wheel : wheels) {
wheel.setWheelId(addWheel(vehicleId, wheel.getLocation(), wheel.getDirection(), wheel.getAxle(), wheel.getRestLength(), wheel.getRadius(), tuning, wheel.isFrontWheel()));
+ wheel.setFrictionSlip(tuning.frictionSlip);
+ wheel.setMaxSuspensionTravelCm(tuning.maxSuspensionTravelCm);
+ wheel.setSuspensionStiffness(tuning.suspensionStiffness);
+ wheel.setWheelsDampingCompression(tuning.suspensionCompression);
+ wheel.setWheelsDampingRelaxation(tuning.suspensionDamping);
+ wheel.setMaxSuspensionForce(tuning.maxSuspensionForce);
}
}
<!-- load properties -->
<property file="src/bullet/native/bullet.properties"/>
<!-- condition for mac platform check -->
+ <condition property="isSolaris">
+ <os name="SunOS"/>
+ </condition>
<condition property="isMac">
<and>
<os family="mac" />
<not>
<os family="mac"/>
</not>
+ <not>
+ <os name="SunOS"/>
+ </not>
</and>
</condition>
<!-- condition for x86_64 check -->
<fileset refid="lib.jme.jars"/>
</pathconvert>
- <target name="build-bullet-natives" description="builds the native bullet library for the platform being run on" depends="-create-folders, create-native-headers, -nativelib-osx, -nativelib-windows, -nativelib-linux">
+ <target name="build-bullet-natives" description="builds the native bullet library for the platform being run on" depends="-create-folders, create-native-headers, -nativelib-osx, -nativelib-windows, -nativelib-linux, -nativelib-solaris">
<echo message="Updating native jME3-bullet-natives.jar"/>
<zip basedir="${bullet.output.base}/jarcontent" file="${bullet.output.base}/jME3-bullet-natives.jar" compress="true"/>
<copy file="${bullet.output.base}/jME3-bullet-natives.jar" todir="dist/lib"/>
<javah destdir="${bullet.source.dir}" classpath="${bullet.build.dir}${path.separator}${lib.importpath}" force="yes">
<class name="com.jme3.bullet.PhysicsSpace"/>
+ <class name="com.jme3.bullet.collision.PhysicsCollisionEvent"/>
<class name="com.jme3.bullet.collision.PhysicsCollisionObject"/>
<class name="com.jme3.bullet.objects.PhysicsCharacter"/>
<class name="com.jme3.bullet.objects.PhysicsGhostObject"/>
<class name="com.jme3.bullet.joints.HingeJoint"/>
<class name="com.jme3.bullet.joints.Point2PointJoint"/>
<class name="com.jme3.bullet.joints.SixDofJoint"/>
+ <class name="com.jme3.bullet.joints.SixDofSpringJoint"/>
<class name="com.jme3.bullet.joints.SliderJoint"/>
<class name="com.jme3.bullet.joints.motors.RotationalLimitMotor"/>
<class name="com.jme3.bullet.joints.motors.TranslationalLimitMotor"/>
<includepath path="${bullet.java.include}/linux"/>
<includepath path="${bullet.bullet.include}"/>
<!--compilerarg value="-m32"/-->
+ <compilerarg value="-m32"/>
+ <compilerarg value="-static-libgcc"/>
<linker name="${bullet.linux.compiler}">
+ <!-- linkerarg value="-static-libgcc"/ -->
<libset dir="${bullet.folder}/src/BulletMultiThreaded" libs="BulletMultiThreaded"/>
<libset dir="${bullet.folder}/src/BulletDynamics" libs="BulletDynamics"/>
<libset dir="${bullet.folder}/src/BulletCollision" libs="BulletCollision"/>
</cc>
<delete file="${bullet.output.dir}/linux/history.xml"/>
</target>
+
+ <target name="-nativelib-solaris" if="isSolaris">
+ <echo message="Building Solaris version of native bullet"/>
+ <mkdir dir="${bullet.output.dir}/linux"/>
+ <cc name="${bullet.solaris.compiler}" warnings="severe" debug="${bullet.compile.debug}" link="shared" outfile="${bullet.output.dir}/solaris/${bullet.library.name}" objdir="${bullet.build.dir}">
+ <fileset dir="${bullet.source.dir}">
+ <include name="*.cpp">
+ </include>
+ </fileset>
+ <includepath path="${bullet.java.include}"/>
+ <includepath path="${bullet.java.include}/solaris"/>
+ <includepath path="${bullet.bullet.include}"/>
+ <!--compilerarg value="-m32"/-->
+ <compilerarg value="-m32"/>
+ <compilerarg value="-fno-strict-aliasing"/>
+ <compilerarg value="-pthread"/>
+ <compilerarg value="-fPIC"/>
+ <compilerarg value="-D_REENTRANT"/>
+ <compilerarg value="-static-libstdc++"/>
+ <compilerarg value="-static-libgcc"/>
+ <compilerarg value="-D_REENTRANT"/>
+ <linker name="${bullet.solaris.compiler}">
+ <linkerarg value="-R/usr/sfw/lib"/>
+ <libset dir="${bullet.folder}/src/BulletMultiThreaded" libs="BulletMultiThreaded"/>
+ <libset dir="${bullet.folder}/src/BulletDynamics" libs="BulletDynamics"/>
+ <libset dir="${bullet.folder}/src/BulletCollision" libs="BulletCollision"/>
+ <libset dir="${bullet.folder}/src/LinearMath" libs="LinearMath"/>
+ </linker>
+ </cc>
+ <delete file="${bullet.output.dir}/solaris/history.xml"/>
+ </target>
<target name="-nativelib-windows" if="isWindows">
<echo message="Building Windows version of native bullet"/>
# change this to msvc for MS Visual Studio compiler
bullet.windows.compiler=g++
bullet.linux.compiler=g++
-
+bullet.solaris.compiler=g++
# native header include directories
bullet.java.include=${java.home}/../include
# OSX has no JRE, only JDK
#include "com_jme3_bullet_PhysicsSpace.h"
#include "jmePhysicsSpace.h"
#include "jmeBulletUtil.h"
-
+#include "jmeUserPointer.h"
/**
* Author: Normen Hansen
*/
env->ThrowNew(newExc, "The collision object does not exist.");
return;
}
+ jmeUserPointer *userPointer = (jmeUserPointer*)collisionObject->getUserPointer();
+ userPointer -> space = space;
+
space->getDynamicsWorld()->addCollisionObject(collisionObject);
}
return;
}
space->getDynamicsWorld()->removeCollisionObject(collisionObject);
+ jmeUserPointer *userPointer = (jmeUserPointer*)collisionObject->getUserPointer();
+ userPointer -> space = NULL;
}
/*
env->ThrowNew(newExc, "The collision object does not exist.");
return;
}
+ jmeUserPointer *userPointer = (jmeUserPointer*)collisionObject->getUserPointer();
+ userPointer -> space = space;
space->getDynamicsWorld()->addRigidBody(collisionObject);
}
env->ThrowNew(newExc, "The collision object does not exist.");
return;
}
+ jmeUserPointer *userPointer = (jmeUserPointer*)collisionObject->getUserPointer();
+ userPointer -> space = NULL;
space->getDynamicsWorld()->removeRigidBody(collisionObject);
}
env->ThrowNew(newExc, "The collision object does not exist.");
return;
}
- space->getDynamicsWorld()->addCollisionObject(collisionObject, btBroadphaseProxy::CharacterFilter, btBroadphaseProxy::StaticFilter | btBroadphaseProxy::DefaultFilter);
+ jmeUserPointer *userPointer = (jmeUserPointer*)collisionObject->getUserPointer();
+ userPointer -> space = space;
+ space->getDynamicsWorld()->addCollisionObject(collisionObject,
+ btBroadphaseProxy::CharacterFilter,
+ btBroadphaseProxy::StaticFilter | btBroadphaseProxy::DefaultFilter
+ );
}
/*
env->ThrowNew(newExc, "The collision object does not exist.");
return;
}
+ jmeUserPointer *userPointer = (jmeUserPointer*)collisionObject->getUserPointer();
+ userPointer -> space = NULL;
space->getDynamicsWorld()->removeCollisionObject(collisionObject);
}
*/
#include "com_jme3_bullet_collision_PhysicsCollisionObject.h"
#include "jmeBulletUtil.h"
+#include "jmePhysicsSpace.h"
+#include "jmeUserPointer.h"
#ifdef __cplusplus
extern "C" {
env->ThrowNew(newExc, "The native object does not exist.");
return;
}
+ if (collisionObject -> getUserPointer() != NULL){
+ jmeUserPointer *userPointer = (jmeUserPointer*)collisionObject->getUserPointer();
+ delete(userPointer);
+ }
delete(collisionObject);
}
+ /*
+ * Class: com_jme3_bullet_collision_PhysicsCollisionObject
+ * Method: initUserPointer
+ * Signature: (JII)V
+ */
+ JNIEXPORT void JNICALL Java_com_jme3_bullet_collision_PhysicsCollisionObject_initUserPointer
+ (JNIEnv *env, jobject object, jlong objectId, jint group, jint groups) {
+ btCollisionObject* collisionObject = (btCollisionObject*) objectId;
+ if (collisionObject == NULL) {
+ jclass newExc = env->FindClass("java/lang/NullPointerException");
+ env->ThrowNew(newExc, "The native object does not exist.");
+ return;
+ }
+ jmeUserPointer *userPointer = (jmeUserPointer*)collisionObject->getUserPointer();
+ if (userPointer != NULL) {
+// delete(userPointer);
+ }
+ userPointer = new jmeUserPointer();
+ userPointer -> javaCollisionObject = env->NewWeakGlobalRef(object);
+ userPointer -> group = group;
+ userPointer -> groups = groups;
+ userPointer -> space = NULL;
+ collisionObject -> setUserPointer(userPointer);
+ }
+ /*
+ * Class: com_jme3_bullet_collision_PhysicsCollisionObject
+ * Method: setCollisionGroup
+ * Signature: (JI)V
+ */
+ JNIEXPORT void JNICALL Java_com_jme3_bullet_collision_PhysicsCollisionObject_setCollisionGroup
+ (JNIEnv *env, jobject object, jlong objectId, jint group) {
+ btCollisionObject* collisionObject = (btCollisionObject*) objectId;
+ if (collisionObject == NULL) {
+ jclass newExc = env->FindClass("java/lang/NullPointerException");
+ env->ThrowNew(newExc, "The native object does not exist.");
+ return;
+ }
+ jmeUserPointer *userPointer = (jmeUserPointer*)collisionObject->getUserPointer();
+ if (userPointer != NULL){
+ userPointer -> group = group;
+ }
+ }
+ /*
+ * Class: com_jme3_bullet_collision_PhysicsCollisionObject
+ * Method: setCollideWithGroups
+ * Signature: (JI)V
+ */
+ JNIEXPORT void JNICALL Java_com_jme3_bullet_collision_PhysicsCollisionObject_setCollideWithGroups
+ (JNIEnv *env, jobject object, jlong objectId, jint groups) {
+ btCollisionObject* collisionObject = (btCollisionObject*) objectId;
+ if (collisionObject == NULL) {
+ jclass newExc = env->FindClass("java/lang/NullPointerException");
+ env->ThrowNew(newExc, "The native object does not exist.");
+ return;
+ }
+ jmeUserPointer *userPointer = (jmeUserPointer*)collisionObject->getUserPointer();
+ if (userPointer != NULL){
+ userPointer -> groups = groups;
+ }
+ }
+
#ifdef __cplusplus
}
#endif
#define com_jme3_bullet_collision_PhysicsCollisionObject_COLLISION_GROUP_16 32768L
/*
* Class: com_jme3_bullet_collision_PhysicsCollisionObject
+ * Method: initUserPointer
+ * Signature: (JII)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_collision_PhysicsCollisionObject_initUserPointer
+ (JNIEnv *, jobject, jlong, jint, jint);
+
+/*
+ * Class: com_jme3_bullet_collision_PhysicsCollisionObject
* Method: attachCollisionShape
* Signature: (JJ)V
*/
/*
* Class: com_jme3_bullet_collision_PhysicsCollisionObject
+ * Method: setCollisionGroup
+ * Signature: (JI)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_collision_PhysicsCollisionObject_setCollisionGroup
+ (JNIEnv *, jobject, jlong, jint);
+
+/*
+ * Class: com_jme3_bullet_collision_PhysicsCollisionObject
+ * Method: setCollideWithGroups
+ * Signature: (JI)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_collision_PhysicsCollisionObject_setCollideWithGroups
+ (JNIEnv *, jobject, jlong, jint);
+
+/*
+ * Class: com_jme3_bullet_collision_PhysicsCollisionObject
* Method: finalizeNative
* Signature: (J)V
*/
--- /dev/null
+
+/**
+ * Author: Normen Hansen
+ */
+#include "com_jme3_bullet_joints_SixDofSpringJoint.h"
+#include "jmeBulletUtil.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: enableString
+ * Signature: (JIZ)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_enableSpring
+ (JNIEnv *env, jobject object, jlong jointId, jint index, jboolean onOff) {
+ btGeneric6DofSpringConstraint* joint = (btGeneric6DofSpringConstraint*) jointId;
+ joint -> enableSpring(index, onOff);
+}
+
+
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: setStiffness
+ * Signature: (JIF)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_setStiffness
+ (JNIEnv *env, jobject object, jlong jointId, jint index, jfloat stiffness) {
+ btGeneric6DofSpringConstraint* joint = (btGeneric6DofSpringConstraint*) jointId;
+ joint -> setStiffness(index, stiffness);
+}
+
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: setDamping
+ * Signature: (JIF)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_setDamping
+ (JNIEnv *env, jobject object, jlong jointId, jint index, jfloat damping) {
+ btGeneric6DofSpringConstraint* joint = (btGeneric6DofSpringConstraint*) jointId;
+ joint -> setDamping(index, damping);
+}
+
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: setEquilibriumPoint
+ * Signature: (JIF)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_setEquilibriumPoint__J
+ (JNIEnv *env, jobject object, jlong jointId) {
+ btGeneric6DofSpringConstraint* joint = (btGeneric6DofSpringConstraint*) jointId;
+ joint -> setEquilibriumPoint();
+}
+
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: setEquilibriumPoint
+ * Signature: (JI)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_setEquilibriumPoint__JI
+ (JNIEnv *env, jobject object, jlong jointId, jint index) {
+ btGeneric6DofSpringConstraint* joint = (btGeneric6DofSpringConstraint*) jointId;
+ joint -> setEquilibriumPoint(index);
+}
+
+
+
+
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: createJoint
+ * Signature: (JJLcom/jme3/math/Vector3f;Lcom/jme3/math/Matrix3f;Lcom/jme3/math/Vector3f;Lcom/jme3/math/Matrix3f;Z)J
+ */
+JNIEXPORT jlong JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_createJoint
+ (JNIEnv * env, jobject object, jlong bodyIdA, jlong bodyIdB, jobject pivotA, jobject rotA, jobject pivotB, jobject rotB, jboolean useLinearReferenceFrameA) {
+ jmeClasses::initJavaClasses(env);
+ btRigidBody* bodyA = (btRigidBody*) bodyIdA;
+ btRigidBody* bodyB = (btRigidBody*) bodyIdB;
+ btMatrix3x3* mtx1 = &btMatrix3x3();
+ btMatrix3x3* mtx2 = &btMatrix3x3();
+/* btTransform* transA = &btTransform(*mtx1);
+ jmeBulletUtil::convert(env, pivotA, &transA->getOrigin());
+ jmeBulletUtil::convert(env, rotA, &transA->getBasis());
+ btTransform* transB = &btTransform(*mtx2);
+ jmeBulletUtil::convert(env, pivotB, &transB->getOrigin());
+ jmeBulletUtil::convert(env, rotB, &transB->getBasis());
+*/
+ btTransform transA;
+ jmeBulletUtil::convert(env, pivotA, &transA.getOrigin());
+ jmeBulletUtil::convert(env, rotA, &transA.getBasis());
+ btTransform transB;
+ jmeBulletUtil::convert(env, pivotB, &transB.getOrigin());
+ jmeBulletUtil::convert(env, rotB, &transB.getBasis());
+
+ btGeneric6DofSpringConstraint* joint = new btGeneric6DofSpringConstraint(*bodyA, *bodyB, transA, transB, useLinearReferenceFrameA);
+ return (long)joint;
+ }
+
+#ifdef __cplusplus
+}
+#endif
--- /dev/null
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_jme3_bullet_joints_SixDofSpringJoint */
+
+#ifndef _Included_com_jme3_bullet_joints_SixDofSpringJoint
+#define _Included_com_jme3_bullet_joints_SixDofSpringJoint
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: enableSpring
+ * Signature: (JIZ)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_enableSpring
+ (JNIEnv *, jobject, jlong, jint, jboolean);
+
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: setStiffness
+ * Signature: (JIF)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_setStiffness
+ (JNIEnv *, jobject, jlong, jint, jfloat);
+
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: setDamping
+ * Signature: (JIF)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_setDamping
+ (JNIEnv *, jobject, jlong, jint, jfloat);
+
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: setEquilibriumPoint
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_setEquilibriumPoint__J
+ (JNIEnv *, jobject, jlong);
+
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: setEquilibriumPoint
+ * Signature: (JI)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_setEquilibriumPoint__JI
+ (JNIEnv *, jobject, jlong, jint);
+
+/*
+ * Class: com_jme3_bullet_joints_SixDofSpringJoint
+ * Method: createJoint
+ * Signature: (JJLcom/jme3/math/Vector3f;Lcom/jme3/math/Matrix3f;Lcom/jme3/math/Vector3f;Lcom/jme3/math/Matrix3f;Z)J
+ */
+JNIEXPORT jlong JNICALL Java_com_jme3_bullet_joints_SixDofSpringJoint_createJoint
+ (JNIEnv *, jobject, jlong, jlong, jobject, jobject, jobject, jobject, jboolean);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
env->ThrowNew(newExc, "The native object does not exist.");
return;
}
- ghost->setCollisionFlags(ghost->getCollisionFlags() | btCollisionObject::CF_CHARACTER_OBJECT);
+ ghost->setCollisionFlags(/*ghost->getCollisionFlags() |*/ btCollisionObject::CF_CHARACTER_OBJECT);
ghost->setCollisionFlags(ghost->getCollisionFlags() & ~btCollisionObject::CF_NO_CONTACT_RESPONSE);
}
#include <BulletCollision/CollisionDispatch/btGhostObject.h>
#include "com_jme3_bullet_objects_PhysicsGhostObject.h"
+#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
#include "jmeBulletUtil.h"
-
+#include "jmePhysicsSpace.h"
+#include "jmeUserPointer.h"
#ifdef __cplusplus
extern "C" {
#endif
jmeBulletUtil::convert(env, &ghost->getWorldTransform().getBasis(), value);
}
+ class jmeGhostOverlapCallback : public btOverlapCallback {
+ JNIEnv* m_env;
+ jobject m_object;
+ public:
+ jmeGhostOverlapCallback(JNIEnv *env, jobject object)
+ :m_env(env),
+ m_object(object)
+ {
+ }
+ virtual ~jmeGhostOverlapCallback() {}
+ virtual bool processOverlap(btBroadphasePair& pair)
+ {
+ btCollisionObject *co1 = (btCollisionObject *)pair.m_pProxy0->m_clientObject;
+ jmeUserPointer *up1 = (jmeUserPointer*)co1 -> getUserPointer();
+
+ m_env->CallVoidMethod(m_object, jmeClasses::PhysicsGhostObject_addOverlappingObject, up1->javaCollisionObject);
+ if (m_env->ExceptionCheck()) {
+ m_env->Throw(m_env->ExceptionOccurred());
+ return false;
+ }
+
+ return false;
+ }
+ };
+
+ /*
+ * Class: com_jme3_bullet_objects_PhysicsGhostObject
+ * Method: getOverlappingObjects
+ * Signature: (J)V
+ */
+ JNIEXPORT void JNICALL Java_com_jme3_bullet_objects_PhysicsGhostObject_getOverlappingObjects
+ (JNIEnv *env, jobject object, jlong objectId) {
+ btPairCachingGhostObject* ghost = (btPairCachingGhostObject*) objectId;
+ if (ghost == NULL) {
+ jclass newExc = env->FindClass("java/lang/NullPointerException");
+ env->ThrowNew(newExc, "The native object does not exist.");
+ return;
+ }
+ btHashedOverlappingPairCache * pc = ghost->getOverlappingPairCache();
+ jmeGhostOverlapCallback cb(env, object);
+ pc -> processAllOverlappingPairs(&cb, NULL);
+ }
/*
* Class: com_jme3_bullet_objects_PhysicsGhostObject
* Method: getOverlappingCount
/*
* Class: com_jme3_bullet_objects_PhysicsGhostObject
+ * Method: getOverlappingObjects
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_jme3_bullet_objects_PhysicsGhostObject_getOverlappingObjects
+ (JNIEnv *, jobject, jlong);
+
+/*
+ * Class: com_jme3_bullet_objects_PhysicsGhostObject
* Method: getOverlappingCount
* Signature: (J)I
*/
btVector3 localInertia = btVector3();
shape->calculateLocalInertia(mass, localInertia);
btRigidBody* body = new btRigidBody(mass, motionState, shape, localInertia);
+ body->setUserPointer(NULL);
return (long) body;
}
jclass jmeClasses::PhysicsSpace;
jmethodID jmeClasses::PhysicsSpace_preTick;
jmethodID jmeClasses::PhysicsSpace_postTick;
+jmethodID jmeClasses::PhysicsSpace_addCollisionEvent;
+
+jclass jmeClasses::PhysicsGhostObject;
+jmethodID jmeClasses::PhysicsGhostObject_addOverlappingObject;
jclass jmeClasses::Vector3f;
jmethodID jmeClasses::Vector3f_set;
PhysicsSpace_preTick = env->GetMethodID(PhysicsSpace, "preTick_native", "(F)V");
PhysicsSpace_postTick = env->GetMethodID(PhysicsSpace, "postTick_native", "(F)V");
+ PhysicsSpace_addCollisionEvent = env->GetMethodID(PhysicsSpace, "addCollisionEvent_native","(Lcom/jme3/bullet/collision/PhysicsCollisionObject;Lcom/jme3/bullet/collision/PhysicsCollisionObject;J)V");
+ if (env->ExceptionCheck()) {
+ env->Throw(env->ExceptionOccurred());
+ return;
+ }
+
+ PhysicsGhostObject = env->FindClass("com/jme3/bullet/objects/PhysicsGhostObject");
+ if (env->ExceptionCheck()) {
+ env->Throw(env->ExceptionOccurred());
+ return;
+ }
+ PhysicsGhostObject_addOverlappingObject = env->GetMethodID(PhysicsGhostObject, "addOverlappingObject_native","(Lcom/jme3/bullet/collision/PhysicsCollisionObject;)V");
if (env->ExceptionCheck()) {
env->Throw(env->ExceptionOccurred());
return;
static jclass PhysicsSpace;
static jmethodID PhysicsSpace_preTick;
static jmethodID PhysicsSpace_postTick;
+ static jmethodID PhysicsSpace_addCollisionEvent;
+ static jclass PhysicsGhostObject;
+ static jmethodID PhysicsGhostObject_addOverlappingObject;
static jclass Vector3f;
static jmethodID Vector3f_set;
jmeMotionState::jmeMotionState() {
trans = new btTransform();
+ trans -> setIdentity();
worldTransform = *trans;
dirty = true;
}
*/
#include "jmePhysicsSpace.h"
#include "jmeBulletUtil.h"
+#include "jmeUserPointer.h"
+#include <stdio.h>
/**
* Author: Normen Hansen
// return true when pairs need collision
virtual bool needBroadphaseCollision(btBroadphaseProxy* proxy0, btBroadphaseProxy * proxy1) const {
+ // bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
+ // collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
-
- //add some additional logic here that modified 'collides'
+ if (collides) {
+ btCollisionObject* co0 = (btCollisionObject*) proxy0->m_clientObject;
+ btCollisionObject* co1 = (btCollisionObject*) proxy1->m_clientObject;
+ jmeUserPointer *up0 = (jmeUserPointer*) co0 -> getUserPointer();
+ jmeUserPointer *up1 = (jmeUserPointer*) co1 -> getUserPointer();
+ if (up0 != NULL && up1 != NULL) {
+ collides = (up0->group & up1->groups) != 0;
+ collides = collides && (up1->group & up0->groups);
+
+ //add some additional logic here that modified 'collides'
+ return collides;
+ }
+ return false;
+ }
return collides;
}
};
dynamicsWorld->getPairCache()->setOverlapFilterCallback(new jmeFilterCallback());
dynamicsWorld->setInternalTickCallback(&jmePhysicsSpace::preTickCallback, static_cast<void *> (this), true);
dynamicsWorld->setInternalTickCallback(&jmePhysicsSpace::postTickCallback, static_cast<void *> (this));
+ if (gContactProcessedCallback == NULL) {
+ gContactProcessedCallback = &jmePhysicsSpace::contactProcessedCallback;
+ }
}
void jmePhysicsSpace::preTickCallback(btDynamicsWorld *world, btScalar timeStep) {
}
}
+bool jmePhysicsSpace::contactProcessedCallback(btManifoldPoint &cp, void *body0, void *body1) {
+ // printf("contactProcessedCallback %d %dn", body0, body1);
+ btCollisionObject* co0 = (btCollisionObject*) body0;
+ jmeUserPointer *up0 = (jmeUserPointer*) co0 -> getUserPointer();
+ btCollisionObject* co1 = (btCollisionObject*) body1;
+ jmeUserPointer *up1 = (jmeUserPointer*) co1 -> getUserPointer();
+ if (up0 != NULL) {
+ jmePhysicsSpace *dynamicsWorld = up0->space;
+ if (dynamicsWorld != NULL) {
+ JNIEnv* env = dynamicsWorld->getEnv();
+ env->CallVoidMethod(dynamicsWorld->getJavaPhysicsSpace(), jmeClasses::PhysicsSpace_addCollisionEvent, up0->javaCollisionObject, up1->javaCollisionObject, (jlong) & cp);
+ if (env->ExceptionCheck()) {
+ env->Throw(env->ExceptionOccurred());
+ return true;
+ }
+ }
+ }
+ return true;
+}
+
btDynamicsWorld* jmePhysicsSpace::getDynamicsWorld() {
return dynamicsWorld;
}
#include "BulletMultiThreaded/SpuCollisionTaskProcess.h"
#include "BulletMultiThreaded/SequentialThreadSupport.h"
#include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h"
+#include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
/**
* Author: Normen Hansen
JNIEnv* getEnv();
static void preTickCallback(btDynamicsWorld*, btScalar);
static void postTickCallback(btDynamicsWorld*, btScalar);
+ static bool contactProcessedCallback(btManifoldPoint &, void *, void *);
};
\ No newline at end of file
--- /dev/null
+#ifndef _Included_jmeUserPointer
+#define _Included_jmeUserPointer
+#include <jni.h>
+class jmeUserPointer {
+public:
+ jobject javaCollisionObject;
+ jint group;
+ jint groups;
+ jmePhysicsSpace *space;
+};
+#endif
\ No newline at end of file
OSDN Git Service
