ContactListener: add the onContactConceived() method (issue #49)

stephengold · stephengold · commit 97335a5ac29d · 2026-03-22T09:32:23.000-07:00
diff --git a/LICENSE b/LICENSE
@@ -1,5 +1,5 @@
 The src/main/java/com/jme3 and src/main/native/glue software
-are Copyright (c) 2009-2025 jMonkeyEngine
+are Copyright (c) 2009-2026 jMonkeyEngine
 All rights reserved.
 
 The src/main/native/v-hacd software except vhacdMutex.h
diff --git a/src/main/java/com/jme3/bullet/PhysicsSpace.java b/src/main/java/com/jme3/bullet/PhysicsSpace.java
@@ -1003,6 +1003,27 @@ public void removeCollisionObject(PhysicsCollisionObject pco) {
     // *************************************************************************
     // ContactListener methods
 
+    /**
+     * Invoked by native code immediately before a contact point is added to a
+     * manifold. Skipped if stepSimulation() was invoked without the
+     * {@code contactConceived} flag set.
+     * <p>
+     * Override this method to customize how contacts are handled.
+     *
+     * @param pointId the native ID of the {@code btManifoldPoint} (not zero)
+     * @param manifoldId the native ID of the {@code btPersistentManifold} (not
+     * zero)
+     * @param pcoA the "A" collision object (not null)
+     * @param pcoB the "B" collision object (not null)
+     * @return true to accept the contact, or false to reject it
+     */
+    @Override
+    public boolean onContactConceived(long pointId, long manifoldId,
+            PhysicsCollisionObject pcoA, PhysicsCollisionObject pcoB) {
+        assert NativeLibrary.jniEnvId() == jniEnvId() : "wrong thread";
+        return true;
+    }
+
     /**
      * Invoked by native code immediately after a contact manifold is destroyed.
      * Skipped if stepSimulation() was invoked without the {@code contactEnded}
diff --git a/src/main/java/com/jme3/bullet/StepFlag.java b/src/main/java/com/jme3/bullet/StepFlag.java
@@ -57,6 +57,10 @@ final public class StepFlag {
      * enable {@code onContactStarted()} callbacks
      */
     final public static int contactStarted = 0x4;
+    /**
+     * enable {@code onContactConceived()} callbacks
+     */
+    final public static int contactConceived = 0x8;
     /**
      * message logger for this class
      */
@@ -81,6 +85,9 @@ private StepFlag() {
      */
     public static String describe(int flags) {
         Collection<String> flagList = new ArrayList<>(3);
+        if ((flags & contactConceived) != 0x0) {
+            flagList.add("contactConceived");
+        }
         if ((flags & contactStarted) != 0x0) {
             flagList.add("contactStarted");
         }
diff --git a/src/main/java/com/jme3/bullet/collision/ContactListener.java b/src/main/java/com/jme3/bullet/collision/ContactListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 jMonkeyEngine
+ * Copyright (c) 2022-2026 jMonkeyEngine
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -41,6 +41,19 @@
  * @author Stephen Gold sgold@sonic.net
  */
 public interface ContactListener {
+    /**
+     * Invoked immediately before a contact point is added to a manifold
+     *
+     * @param pointId the native ID of the {@code btManifoldPoint} (not zero)
+     * @param manifoldId the native ID of the {@code btPersistentManifold} (not
+     * zero)
+     * @param pcoA the "A" collision object (not null)
+     * @param pcoB the "B" collision object (not null)
+     * @return true to accept the contact, or false to reject it
+     */
+    boolean onContactConceived(long pointId, long manifoldId,
+            PhysicsCollisionObject pcoA, PhysicsCollisionObject pcoB);
+
     /**
      * Invoked immediately after a contact manifold is removed.
      *
diff --git a/src/main/native/bullet3/BulletCollision/CollisionDispatch/btManifoldResult.cpp b/src/main/native/bullet3/BulletCollision/CollisionDispatch/btManifoldResult.cpp
@@ -21,6 +21,7 @@ subject to the following restrictions:
 
 ///This is to allow MaterialCombiner/Custom Friction/Restitution values
 ContactAddedCallback gContactAddedCallback = 0;
+ContactConceivedCallback gContactConceivedCallback = 0;// stephengold added 2026-03-22
 
 CalculateCombinedCallback gCalculateCombinedRestitutionCallback = &btManifoldResult::calculateCombinedRestitution;
 CalculateCombinedCallback gCalculateCombinedFrictionCallback = &btManifoldResult::calculateCombinedFriction;
@@ -192,6 +193,12 @@ void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld, const
 		newPt.m_index1 = m_index1;
 	}
 	//printf("depth=%f\n",depth);
+        if (gContactConceivedCallback) {// stephengold added 2026-03-22
+	        const btCollisionObject* pco0 = getBody0Internal();// stephengold added 2026-03-22
+	        const btCollisionObject* pco1 = getBody1Internal();// stephengold added 2026-03-22
+                bool accept = (*gContactConceivedCallback)(newPt, m_manifoldPtr, pcoA, pcoB);// stephengold added 2026-03-22
+                if (!accept) return;// stephengold added 2026-03-22
+        }// stephengold added 2026-03-22
 	///@todo, check this for any side effects
 	if (insertIndex >= 0)
 	{
diff --git a/src/main/native/bullet3/BulletCollision/CollisionDispatch/btManifoldResult.h b/src/main/native/bullet3/BulletCollision/CollisionDispatch/btManifoldResult.h
@@ -30,6 +30,8 @@ class btManifoldPoint;
 
 typedef bool (*ContactAddedCallback)(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper* colObj1Wrap, int partId1, int index1);
 extern ContactAddedCallback gContactAddedCallback;
+typedef bool (*ContactConceivedCallback)(btManifoldPoint&, btPersistentManifold*, const btCollisionObject* pBodyA, const btCollisionObject* pBodyB);// stephengold added 2026-03-22
+extern ContactConceivedCallback gContactConceivedCallback;// stephengold added 2026-03-22
 
 //#define DEBUG_PART_INDEX 1
 
diff --git a/src/main/native/bullet3/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp b/src/main/native/bullet3/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp
@@ -905,13 +905,14 @@ void btDiscreteDynamicsWorld::createPredictiveContactsInternal(btRigidBody** bod
 						bool isSwapped = false; // stephengold added 2026-03-21
 						btManifoldPoint newPoint(btVector3(0, 0, 0), localPointB, sweepResults.m_hitNormalWorld, distance, isPredictive, isSwapped); // stephengold modified 2026-03-21
 
-						//bool isPredictive = true; // stephengold commented out 2026-03-21
+					      if (gContactConceivedCallback == NULL || (*gContactConceivedCallback)(newPoint, manifold, body, sweepResults.m_hitCollisionObject)) {// stephengold modified 2026-03-22
 						int index = manifold->addManifoldPoint(newPoint, isPredictive);
 						btManifoldPoint& pt = manifold->getContactPoint(index);
 						pt.m_combinedRestitution = 0;
 						pt.m_combinedFriction = gCalculateCombinedFrictionCallback(body, sweepResults.m_hitCollisionObject);
 						pt.m_positionWorldOnA = body->getWorldTransform().getOrigin();
 						pt.m_positionWorldOnB = worldPointB;
+					      }// stephengold added 2026-03-22
 					}
 				}
 			}
diff --git a/src/main/native/glue/com_jme3_bullet_StepFlag.h b/src/main/native/glue/com_jme3_bullet_StepFlag.h
diff --git a/src/main/native/glue/jmeClasses.cpp b/src/main/native/glue/jmeClasses.cpp
@@ -51,6 +51,7 @@ jmethodID jmeClasses::CustomConvexShape_locateSupport;
 
 jmethodID jmeClasses::PhysicsSpace_preTick;
 jmethodID jmeClasses::PhysicsSpace_postTick;
+jmethodID jmeClasses::PhysicsSpace_onContactConceived;
 jmethodID jmeClasses::PhysicsSpace_onContactEnded;
 jmethodID jmeClasses::PhysicsSpace_onContactProcessed;
 jmethodID jmeClasses::PhysicsSpace_onContactStarted;
@@ -248,6 +249,9 @@ void jmeClasses::initJavaClasses(JNIEnv *pEnv) {
     EXCEPTION_CHK(pEnv,);
     GLOBAL_METHOD(PhysicsSpace_preTick, physicsSpace, "preTick", "(F)V");
     GLOBAL_METHOD(PhysicsSpace_postTick, physicsSpace, "postTick", "(F)V");
+    GLOBAL_METHOD(PhysicsSpace_onContactConceived,
+            physicsSpace, "onContactConceived",
+            "(JJLcom/jme3/bullet/collision/PhysicsCollisionObject;Lcom/jme3/bullet/collision/PhysicsCollisionObject;)Z");
     GLOBAL_METHOD(PhysicsSpace_onContactEnded,
             physicsSpace, "onContactEnded", "(J)V");
     GLOBAL_METHOD(PhysicsSpace_onContactProcessed,
diff --git a/src/main/native/glue/jmeClasses.h b/src/main/native/glue/jmeClasses.h
@@ -78,6 +78,7 @@ class jmeClasses {
 
     static jmethodID PhysicsSpace_preTick;
     static jmethodID PhysicsSpace_postTick;
+    static jmethodID PhysicsSpace_onContactConceived;
     static jmethodID PhysicsSpace_onContactEnded;
     static jmethodID PhysicsSpace_onContactProcessed;
     static jmethodID PhysicsSpace_onContactStarted;
diff --git a/src/main/native/glue/jmePhysicsSpace.cpp b/src/main/native/glue/jmePhysicsSpace.cpp
@@ -101,6 +101,116 @@ void jmePhysicsSpace::createPhysicsSpace(const btVector3& min,
 
 #endif // BT_THREADSAFE
 
+bool jmePhysicsSpace::contactConceivedCallback(btManifoldPoint& contactPoint,
+            btPersistentManifold* pManifold,
+            const btCollisionObject* pBodyA, const btCollisionObject* pBodyB) {
+    btAssert(pManifold->getObjectType() == BT_PERSISTENT_MANIFOLD_TYPE);
+    BT_PROFILE("contactConceivedCallback");
+
+    if (pBodyA == NULL || pBodyB == NULL) {
+#ifdef _DEBUG
+        printf("null collision object in contactConceivedCallback\n");
+        fflush(stdout);
+#endif
+        return true;
+    }
+    jmeUserPointer const pUserA = (jmeUserPointer) pBodyA->getUserPointer();
+    jmeUserPointer const pUserB = (jmeUserPointer) pBodyB->getUserPointer();
+    if (pUserA == NULL || pUserB == NULL) {
+#ifdef _DEBUG
+        printf("null userPointer in contactConceivedCallback\n");
+        fflush(stdout);
+#endif
+        return true;
+    }
+
+    jmePhysicsSpace * pSpace = (jmePhysicsSpace *) pUserA->m_jmeSpace;
+    if (pSpace == NULL) {
+#ifdef _DEBUG
+        printf("can't access jmePhysicsSpace in contactConceivedCallback\n");
+        fflush(stdout);
+#endif
+        return true;
+    }
+
+#if BT_THREADSAFE
+    pSpace->m_mutex.lock();
+#endif
+    JNIEnv * const pEnv = pSpace->getEnvAndAttach();
+    jobject javaPhysicsSpace = pEnv->NewLocalRef(pSpace->getJavaPhysicsSpace());
+    if (javaPhysicsSpace == NULL) {
+#ifdef _DEBUG
+        printf("null javaPhysicsSpace in contactConceivedCallback\n");
+        fflush(stdout);
+#endif
+#if BT_THREADSAFE
+        pSpace->m_mutex.unlock();
+#endif
+        return true;
+    }
+
+    jobject javaCollisionObjectA = pEnv->NewLocalRef(pUserA->m_javaRef);
+    if (pEnv->ExceptionCheck()) {
+#if BT_THREADSAFE
+        pSpace->m_mutex.unlock();
+#endif
+        return true;
+    }
+    jobject javaCollisionObjectB = pEnv->NewLocalRef(pUserB->m_javaRef);
+    if (pEnv->ExceptionCheck()) {
+#if BT_THREADSAFE
+        pSpace->m_mutex.unlock();
+#endif
+        return true;
+    }
+    jlong pointId = reinterpret_cast<jlong> (&contactPoint);
+    jlong manifoldId = reinterpret_cast<jlong> (pManifold);
+    jboolean accept = pEnv->CallBooleanMethod(javaPhysicsSpace,
+            jmeClasses::PhysicsSpace_onContactConceived,
+            pointId, manifoldId, javaCollisionObjectA, javaCollisionObjectB);
+    if (pEnv->ExceptionCheck()) {
+#ifdef _DEBUG
+        printf("exception in contactConceivedCallback CallBooleanMethod\n");
+        fflush(stdout);
+#endif
+#if BT_THREADSAFE
+        pSpace->m_mutex.unlock();
+#endif
+        return accept;
+    }
+
+    pEnv->DeleteLocalRef(javaPhysicsSpace);
+#ifdef _DEBUG
+    if (pEnv->ExceptionCheck()) {
+        printf("exception in contactConceivedCallback DeleteLocalRef space\n");
+        fflush(stdout);
+    }
+#endif
+    pEnv->DeleteLocalRef(javaCollisionObjectA);
+    if (pEnv->ExceptionCheck()) {
+#ifdef _DEBUG
+        printf("exception in contactConceivedCallback DeleteLocalRef A\n");
+        fflush(stdout);
+#endif
+#if BT_THREADSAFE
+        pSpace->m_mutex.unlock();
+#endif
+        return true;
+    }
+    pEnv->DeleteLocalRef(javaCollisionObjectB);
+#ifdef _DEBUG
+    if (pEnv->ExceptionCheck()) {
+        printf("exception in contactConceivedCallback DeleteLocalRef B\n");
+        fflush(stdout);
+    }
+#endif
+#if BT_THREADSAFE
+    pSpace->m_mutex.unlock();
+#endif
+
+    return accept;
+}
+
 void jmePhysicsSpace::contactEndedCallback(btPersistentManifold * const &pm) {
     btAssert(pm->getObjectType() == BT_PERSISTENT_MANIFOLD_TYPE);
     BT_PROFILE("contactEndedCallback");
@@ -440,6 +550,13 @@ void jmePhysicsSpace::preTickCallback(btDynamicsWorld *pWorld,
 
 void jmePhysicsSpace::stepSimulation(jfloat timeInterval, jint maxSteps,
         jfloat accuracy, jint stepFlags) {
+
+    if (stepFlags & com_jme3_bullet_StepFlag_contactConceived) {
+        gContactConceivedCallback = &contactConceivedCallback;
+    } else {
+        gContactConceivedCallback = NULL;
+    }
+
     if (stepFlags & com_jme3_bullet_StepFlag_contactEnded) {
         gContactEndedCallback = &contactEndedCallback;
     } else {
diff --git a/src/main/native/glue/jmePhysicsSpace.h b/src/main/native/glue/jmePhysicsSpace.h
@@ -58,6 +58,10 @@ class jmePhysicsSpace : public jmeCollisionSpace {
 
     virtual ~jmePhysicsSpace();
 
+    static bool
+    contactConceivedCallback(btManifoldPoint&, btPersistentManifold*,
+            const btCollisionObject* pBodyA, const btCollisionObject* pBodyB);
+
     static void
     contactEndedCallback(btPersistentManifold * const &);
 

Original file line number	Diff line number	Diff line change
`@@ -905,13 +905,14 @@ void btDiscreteDynamicsWorld::createPredictiveContactsInternal(btRigidBody** bod`
`905`	`905`	`bool isSwapped = false; // stephengold added 2026-03-21`
`906`	`906`	`btManifoldPoint newPoint(btVector3(0, 0, 0), localPointB, sweepResults.m_hitNormalWorld, distance, isPredictive, isSwapped); // stephengold modified 2026-03-21`
`907`	`907`
`908`		`- //bool isPredictive = true; // stephengold commented out 2026-03-21`
	`908`	`+ if (gContactConceivedCallback == NULL \|\| (*gContactConceivedCallback)(newPoint, manifold, body, sweepResults.m_hitCollisionObject)) {// stephengold modified 2026-03-22`
`909`	`909`	`int index = manifold->addManifoldPoint(newPoint, isPredictive);`
`910`	`910`	`btManifoldPoint& pt = manifold->getContactPoint(index);`
`911`	`911`	`pt.m_combinedRestitution = 0;`
`912`	`912`	`pt.m_combinedFriction = gCalculateCombinedFrictionCallback(body, sweepResults.m_hitCollisionObject);`
`913`	`913`	`pt.m_positionWorldOnA = body->getWorldTransform().getOrigin();`
`914`	`914`	`pt.m_positionWorldOnB = worldPointB;`
	`915`	`+ }// stephengold added 2026-03-22`
`915`	`916`	`}`
`916`	`917`	`}`
`917`	`918`	`}`